// === TYPES ===
typedef struct sIPC_Type tIPC_Type;
-typedef struct sIPC_Client tIPC_Client;
struct sIPC_Type
{
msg = staticBuf + identlen;
IPC_Handle(&gIPC_Type_Datagram, staticBuf, readlen - identlen, (void*)msg);
- _SysDebug("IPC_HandleSelect: UDP handled");
+// _SysDebug("IPC_HandleSelect: UDP handled");
}
while(SysGetMessage(NULL, NULL))
SysGetMessage(NULL, data);
IPC_Handle(&gIPC_Type_SysMessage, &tid, len, (void*)data);
- _SysDebug("IPC_HandleSelect: Message handled");
+// _SysDebug("IPC_HandleSelect: Message handled");
}
}
int IPC_Type_Sys_Compare(const void *Ident1, const void *Ident2)
{
- return *(const int*)Ident1 - *(const int*)Ident2;
+ return *(const tid_t*)Ident1 - *(const tid_t*)Ident2;
}
void IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data)
tIPC_Client *IPC_int_GetClient(const tIPC_Type *IPCType, const void *Ident)
{
- int pos; // Position where the new client will be inserted
+ int pos = 0; // Position where the new client will be inserted
int ident_size;
tIPC_Client *ret;
// - Search list of registered clients
+ if(giIPC_ClientCount > 0)
{
tIPC_Client target;
int div;
{
div /= 2;
cmp = _CompareClientPtrs(&ret, &gIPC_Clients[pos]);
+// _SysDebug("Checking against %i gives %i", pos, cmp);
if(cmp == 0) break;
if(cmp < 0)
pos -= div;
// - Create a new client entry
ident_size = IPCType->GetIdentSize(Ident);
+// _SysDebug("ident_size = %i", ident_size);
ret = malloc( sizeof(tIPC_Client) + ident_size );
if(!ret) return NULL;
ret->IPCType = IPCType;
- ret->Ident = &ret + 1; // Get the end of the structure
+ ret->Ident = ret + 1; // Get the end of the structure
memcpy( (void*)ret->Ident, Ident, ident_size );
ret->nWindows = 0;
ret->Windows = NULL;
if( WindowID == -1 )
return NULL;
- if( WindowID >= Client->nWindows )
+ if( WindowID >= Client->nWindows ) {
+// _SysDebug("Window %i out of range for %p (%i)", WindowID, Client, Client->nWindows);
return NULL;
+ }
return Client->Windows[WindowID];
}
Client->nWindows = WindowID + 1;
Client->Windows = realloc(Client->Windows, Client->nWindows*sizeof(tWindow*));
memset( &Client->Windows[oldCount], 0, (Client->nWindows-oldCount)*sizeof(tWindow*) );
+ _SysDebug("Expanded %p's window list from %i to %i", Client, oldCount, Client->nWindows);
}
-
+
+ _SysDebug("Assigned %p to window %i for %p", WindowPtr, WindowID, Client);
Client->Windows[WindowID] = WindowPtr;
}
// --- IPC Message Handlers ---
+int IPC_Msg_SendMsg(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+ tIPCMsg_SendMsg *info = (void*)Msg->Data;
+ tWindow *src, *dest;
+
+ // - Sanity checks
+ if( Msg->Size < sizeof(tIPCMsg_SendMsg) )
+ return -1;
+ if( Msg->Size < sizeof(tIPCMsg_SendMsg) + info->Length )
+ return -1;
+
+ src = IPC_int_GetWindow(Client, Msg->Window);
+ if(!src) return 1;
+ dest = IPC_int_GetWindow(Client, info->Remote);
+ if(!dest) return 1;
+
+ WM_SendMessage(src, dest, info->ID, info->Length, info->Data);
+
+ return 0;
+}
+
int IPC_Msg_CreateWin(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
{
tIPCMsg_CreateWin *info = (void*)Msg->Data;
// - Sanity checks
// > +1 is for NULL byte on string
- if( Msg->Size < sizeof(tIPCMsg_CreateWin) + 1 )
+ if( Msg->Size < sizeof(*info) + 1 ) {
+ _SysDebug("IPC_Msg_CreateWin: Size check 1 failed");
return -1;
- if( info->Renderer[Msg->Size - sizeof(tIPCMsg_CreateWin)] != '\0' )
+ }
+ if( info->Renderer[Msg->Size - sizeof(*info) - 1] != '\0' ) {
+ _SysDebug("IPC_Msg_CreateWin: Size check 2 failed");
+ _SysDebug("info = {");
+ _SysDebug(" .NewWinID = %i", info->NewWinID);
+ _SysDebug(" .RendererArg = %i", info->RendererArg);
+ _SysDebug(" .Renderer = '%.*s'", Msg->Size - sizeof(*info), info->Renderer);
+ _SysDebug("}");
return -1;
+ }
// - Get the parent window ID
parent = IPC_int_GetWindow(Client, Msg->Window);
return 1;
// - Create the new window, and save its pointer
- newwin = WM_CreateWindow(parent, info->RendererArg, info->Renderer);
+ newwin = WM_CreateWindow(parent, Client, info->NewWinID, info->RendererArg, info->Renderer);
IPC_int_SetWindow(Client, info->NewWinID, newwin);
return 0;
win = IPC_int_GetWindow(Client, Msg->Window);
if(!win) return 1;
+ _SysDebug("info = {..., bSetPos=%i,bSetDims=%i}", info->bSetPos, info->bSetDims);
+
if(info->bSetPos)
WM_MoveWindow(win, info->X, info->Y);
if(info->bSetDims)
return 0;
}
+int IPC_Msg_GetDisplayCount(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+ tAxWin_IPCMessage *ret_hdr;
+ tIPCMsg_ReturnInt *ret;
+ char buf[sizeof(*ret_hdr)+sizeof(*ret)];
+
+ if( !(Msg->Flags & IPCMSG_FLAG_RETURN) ) return 0;
+
+ ret_hdr = (void*)buf;
+ ret_hdr->ID = IPCMSG_GETDISPLAYCOUNT;
+ ret_hdr->Flags = 0;
+ ret_hdr->Window = -1;
+ ret_hdr->Size = sizeof(*ret);
+ ret = (void*)ret_hdr->Data;
+ ret->Value = 1; // HARD CODE - Current version only supports one display
+
+ Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
+ return 0;
+}
+
+int IPC_Msg_GetDisplayDims(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+ tIPCMsg_GetDisplayDims *info;
+ tAxWin_IPCMessage *ret_hdr;
+ tIPCMsg_RetDisplayDims *ret;
+ char buf[sizeof(*ret_hdr)+sizeof(*ret)];
+
+ if( !(Msg->Flags & IPCMSG_FLAG_RETURN) ) return 0;
+
+ info = (void*)Msg->Data;
+
+ ret_hdr = (void*)buf;
+ ret_hdr->ID = IPCMSG_GETDISPLAYDIMS;
+ ret_hdr->Flags = 0;
+ ret_hdr->Window = -1;
+ ret_hdr->Size = sizeof(*ret);
+ ret = (void*)ret_hdr->Data;
+
+ // HARD CODE! Only one display supported
+ if( info->DisplayID == 0 )
+ {
+ ret->X = 0;
+ ret->Y = 0;
+ ret->W = giScreenWidth;
+ ret->H = giScreenHeight;
+ }
+ else
+ {
+ ret->X = 0; ret->Y = 0;
+ ret->W = 0; ret->H = 0;
+ }
+
+ Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
+ return 0;
+}
+
void IPC_Handle(const tIPC_Type *IPCType, const void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg)
{
tIPC_Client *client;
+ int rv = 0;
_SysDebug("IPC_Handle: (IPCType=%p, Ident=%p, MsgLen=%i, Msg=%p)",
IPCType, Ident, MsgLen, Msg);
if( Msg->Size < 4 ) return;
if( Msg->Flags & IPCMSG_FLAG_RETURN )
{
+ tIPCMsg_ReturnInt *ret = (void*)Msg->Data;
Msg->ID = IPCMSG_PING;
- Msg->Size = sizeof(tIPCMsg_Return);
- ((tIPCMsg_Return*)Msg->Data)->Value = AXWIN_VERSION;
- IPCType->SendMessage(Ident, sizeof(tIPCMsg_Return), Msg);
+ Msg->Size = sizeof(*ret);
+ ret->Value = AXWIN_VERSION;
+ IPCType->SendMessage(Ident, sizeof(*Msg)+sizeof(*ret), Msg);
}
break;
+ // -- Get display count
+ case IPCMSG_GETDISPLAYCOUNT:
+ rv = IPC_Msg_GetDisplayCount(client, Msg);
+ break;
+
+ // --- Get display dimensions
+ case IPCMSG_GETDISPLAYDIMS:
+ rv = IPC_Msg_GetDisplayDims(client, Msg);
+ break;
+
+ // --- Send a message
+ case IPCMSG_SENDMSG:
+ _SysDebug(" IPC_Handle: IPCMSG_SENDMSG %i", ((tIPCMsg_SendMsg*)Msg->Data)->ID);
+ rv = IPC_Msg_SendMsg(client, Msg);
+ break;
+
// --- Create window
case IPCMSG_CREATEWIN:
_SysDebug(" IPC_Handle: IPCMSG_CREATEWIN");
- IPC_Msg_CreateWin(client, Msg);
+ rv = IPC_Msg_CreateWin(client, Msg);
break;
// --- Show/Hide a window
case IPCMSG_SHOWWINDOW:
_SysDebug(" IPC_Handle: IPCMSG_SHOWWINDOW");
- IPC_Msg_ShowWindow(client, Msg);
+ rv = IPC_Msg_ShowWindow(client, Msg);
break;
// --- Move/Resize a window
case IPCMSG_SETWINPOS:
_SysDebug(" IPC_Handle: IPCMSG_SETWINPOS");
- IPC_Msg_SetWinPos(client, Msg);
+ rv = IPC_Msg_SetWinPos(client, Msg);
break;
// --- Unknown message
_SysDebug("WARNING: Unknown message %i (%p)", Msg->ID, IPCType);
break;
}
+ if(rv)
+ _SysDebug("IPC_Handle: rv = %i", rv);
+}
+
+// --- Server->Client replies
+void IPC_SendWMMessage(tIPC_Client *Client, uint32_t Src, uint32_t Dst, int MsgID, int Len, void *Data)
+{
+ tAxWin_IPCMessage *hdr;
+ tIPCMsg_SendMsg *msg;
+ char buf[sizeof(*hdr)+sizeof(*msg)+Len];
+
+ hdr = (void*)buf;
+ msg = (void*)hdr->Data;
+
+ hdr->ID = IPCMSG_SENDMSG;
+ hdr->Flags = 0;
+ hdr->Size = sizeof(*msg) + Len;
+ hdr->Window = Dst;
+
+ msg->Remote = Src;
+ msg->ID = MsgID;
+ msg->Length = Len;
+ memcpy(msg->Data, Data, Len);
+
+ Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
}
git.ucc.asn.au / tpg / acess2.git / blobdiff
UCC git Repository :: git.ucc.asn.au