X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Usermode%2FApplications%2Faxwin3_src%2FWM%2Fipc.c;h=7155c1155be966617b6111a5494a76c25311d689;hb=6f00be304598cbaac2ed145f4d2079574717e984;hp=a21c7835711a9d6c88c2f094af0bb26320115c7b;hpb=2f786d7164faa96acf47281debc2b458318701d0;p=tpg%2Facess2.git

diff --git a/Usermode/Applications/axwin3_src/WM/ipc.c b/Usermode/Applications/axwin3_src/WM/ipc.c
index a21c7835..7155c115 100644
--- a/Usermode/Applications/axwin3_src/WM/ipc.c
+++ b/Usermode/Applications/axwin3_src/WM/ipc.c
@@ -6,160 +6,78 @@
  * - Interprocess communication
  */
 #include <common.h>
-#include <acess/sys.h>
-#include <net.h>
 #include <string.h>
 #include <ipcmessages.h>
 #include <stdio.h>
 #include <wm.h>
+#include <wm_internals.h>
+#include <wm_hotkeys.h>	// Hotkey registration
+#include <wm_renderer.h>	// Renderer IPC messages
+#include <ipc_int.h>
 
-#define AXWIN_PORT	4101
-
-#define STATICBUF_SIZE	64
 #define MAX_WINDOWS_PER_APP	128
 
-// === TYPES ===
-typedef struct sIPC_Type	tIPC_Type;
-
-struct sIPC_Type
-{
-	 int	(*GetIdentSize)(const void *Ident);
-	 int	(*CompareIdent)(const void *Ident1, const void *Ident2);
-	void	(*SendMessage)(const void *Ident, size_t Length, const void *Data);
-};
-
-struct sIPC_Client
-{
-	const tIPC_Type	*IPCType;
-	const void	*Ident;	// Stored after structure
-
-	 int	nWindows;
-	tWindow	**Windows;
-};
-
+// === IMPORTS ===
+extern tWindow	*gpWM_FocusedWindow;	// Needed for _FocusWindow
 
 // === PROTOTYPES ===
-void	IPC_Init(void);
-void	IPC_FillSelect(int *nfds, fd_set *set);
-void	IPC_HandleSelect(fd_set *set);
- int	IPC_Type_Datagram_GetSize(const void *Ident);
- int	IPC_Type_Datagram_Compare(const void *Ident1, const void *Ident2);
-void	IPC_Type_Datagram_Send(const void *Ident, size_t Length, const void *Data);
- int	IPC_Type_Sys_GetSize(const void *Ident);
- int	IPC_Type_Sys_Compare(const void *Ident1, const void *Ident2);
-void	IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data);
-void	IPC_Handle(const tIPC_Type *IPCType, const void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg);
+tIPC_Client	*IPC_int_GetClient(const tIPC_Type *IPCType, const void *Ident);
+void	IPC_int_DropClient(tIPC_Client *Client);
+void	IPC_Handle(tIPC_Client *Client, size_t MsgLen, tAxWin_IPCMessage *Msg);
 
 // === GLOBALS ===
-const tIPC_Type	gIPC_Type_Datagram = {
-	IPC_Type_Datagram_GetSize,
-	IPC_Type_Datagram_Compare, 
-	IPC_Type_Datagram_Send
-};
-const tIPC_Type	gIPC_Type_SysMessage = {
-	IPC_Type_Sys_GetSize,
-	IPC_Type_Sys_Compare,
-	IPC_Type_Sys_Send
-};
- int	giNetworkFileHandle = -1;
- int	giMessagesFileHandle = -1;
  int	giIPC_ClientCount;
 tIPC_Client	**gIPC_Clients;
 
 // === CODE ===
-void IPC_Init(void)
-{
-	 int	tmp;
-	// TODO: Check this
-	giNetworkFileHandle = open("/Devices/ip/loop/udp", OPENFLAG_READ);
-	tmp = AXWIN_PORT;	ioctl(giNetworkFileHandle, 4, &tmp);	// TODO: Don't hard-code IOCtl number
-}
-
-void IPC_FillSelect(int *nfds, fd_set *set)
-{
-	if( giNetworkFileHandle > *nfds )	*nfds = giNetworkFileHandle;
-	FD_SET(giNetworkFileHandle, set);
-}
-
-void IPC_HandleSelect(fd_set *set)
-{
-	if( FD_ISSET(giNetworkFileHandle, set) )
-	{
-		char	staticBuf[STATICBUF_SIZE];
-		 int	readlen, identlen;
-		char	*msg;
-
-		readlen = read(giNetworkFileHandle, staticBuf, sizeof(staticBuf));
-		
-		identlen = 4 + Net_GetAddressSize( ((uint16_t*)staticBuf)[1] );
-		msg = staticBuf + identlen;
-
-		IPC_Handle(&gIPC_Type_Datagram, staticBuf, readlen - identlen, (void*)msg);
-//		_SysDebug("IPC_HandleSelect: UDP handled");
-	}
-
-	while(SysGetMessage(NULL, NULL))
-	{
-		pid_t	tid;
-		 int	len = SysGetMessage(&tid, NULL);
-		char	data[len];
-		SysGetMessage(NULL, data);
-
-		IPC_Handle(&gIPC_Type_SysMessage, &tid, len, (void*)data);
-//		_SysDebug("IPC_HandleSelect: Message handled");
-	}
-}
-
-int IPC_Type_Datagram_GetSize(const void *Ident)
-{
-	return 4 + Net_GetAddressSize( ((const uint16_t*)Ident)[1] );
-}
-
-int IPC_Type_Datagram_Compare(const void *Ident1, const void *Ident2)
-{
-	// Pass the buck :)
-	// - No need to worry about mis-matching sizes, as the size is computed
-	//   from the 3rd/4th bytes, hence it will differ before the size is hit.
-	return memcmp(Ident1, Ident2, IPC_Type_Datagram_GetSize(Ident1));
-}
-
-void IPC_Type_Datagram_Send(const void *Ident, size_t Length, const void *Data)
-{
-	 int	identlen = IPC_Type_Datagram_GetSize(Ident);
-	char	tmpbuf[ identlen + Length ];
-	memcpy(tmpbuf, Ident, identlen);	// Header
-	memcpy(tmpbuf + identlen, Data, Length);	// Data
-	// TODO: Handle fragmented packets
-	write(giNetworkFileHandle, tmpbuf, sizeof(tmpbuf));
-}
-
-int IPC_Type_Sys_GetSize(const void *Ident)
-{
-	return sizeof(pid_t);
-}
-
-int IPC_Type_Sys_Compare(const void *Ident1, const void *Ident2)
-{
-	return *(const tid_t*)Ident1 - *(const tid_t*)Ident2;
-}
-
-void IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data)
-{
-	SysSendMessage( *(const tid_t*)Ident, Length, Data );
-}
-
 // --- Client -> Window Mappings
 int _CompareClientPtrs(const void *_a, const void *_b)
 {
 	tIPC_Client	*a = *(tIPC_Client**)_a;
 	tIPC_Client	*b = *(tIPC_Client**)_b;
-	
+
+	ASSERT(a);
+	if(!b)	return -1;
+
 	if(a->IPCType < b->IPCType)	return -1;
 	if(a->IPCType > b->IPCType)	return 1;
 	
 	return a->IPCType->CompareIdent(a->Ident, b->Ident);
 }
 
+int IPC_int_BSearchClients(const tIPC_Client *TargetClient, int *Pos)
+{
+	 int	div;
+	 int	cmp = -1;
+	 int	pos = 0;
+
+	div = giIPC_ClientCount;
+	pos = div/2;
+	while(div > 0)
+	{
+		div /= 2;
+		_SysDebug("Cmp with %i [%i] (%p)", pos, div, gIPC_Clients[pos]);
+		cmp = _CompareClientPtrs(&TargetClient, &gIPC_Clients[pos]);
+//		_SysDebug("Checking against %i gives %i", pos, cmp);
+		if(cmp == 0)	break;
+		if(cmp < 0)
+			pos -= div;
+		else
+			pos += div;
+	}
+	
+	// - Return if found	
+	if(cmp == 0) {
+		*Pos = pos;
+		return 1;
+	}
+
+	// Adjust pos to be the index where the new client will be placed
+	if(cmp > 0)	pos ++;
+	*Pos = pos;
+	return 0;
+}
+
 tIPC_Client *IPC_int_GetClient(const tIPC_Type *IPCType, const void *Ident)
 {
 	 int	pos = 0;	// Position where the new client will be inserted
@@ -170,33 +88,10 @@ tIPC_Client *IPC_int_GetClient(const tIPC_Type *IPCType, const void *Ident)
 	if(giIPC_ClientCount > 0)
 	{
 		tIPC_Client	target;
-		 int	div;
-		 int	cmp = -1;
-	
 		target.IPCType = IPCType;
 		target.Ident = Ident;
-		ret = &target;	// Abuse ret to get a pointer
-		
-		div = giIPC_ClientCount;
-		pos = div/2;
-		while(div > 0)
-		{
-			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;
-			else
-				pos += div;
-		}
-		
-		// - Return if found	
-		if(cmp == 0)
+		if( IPC_int_BSearchClients(&target, &pos) )
 			return gIPC_Clients[pos];
-	
-		// Adjust pos to be the index where the new client will be placed
-		if(cmp > 0)	pos ++;
 	}
 
 
@@ -224,13 +119,46 @@ tIPC_Client *IPC_int_GetClient(const tIPC_Type *IPCType, const void *Ident)
 	return ret;
 }
 
+void IPC_int_DropClient(tIPC_Client *Client)
+{
+	// Remove from client list
+	 int	pos;
+	if( !IPC_int_BSearchClients(Client, &pos) ) {
+		_SysDebug("IPC_int_DropClient: Can't find client %p", Client);
+		return ;
+	}
+
+	giIPC_ClientCount --;
+	memmove(&gIPC_Clients[pos], &gIPC_Clients[pos+1], (giIPC_ClientCount-pos)*sizeof(tIPC_Client*));
+
+	// Terminate client's windows
+	// - If there were active windows, show an error?
+	 int	nWindowsDestroyed = 0;
+	for(int i = 0; i < Client->nWindows; i ++)
+	{
+		if( Client->Windows[i] )
+		{
+			_SysDebug("Window %p:%i %p still exists", Client, i, Client->Windows[i]);
+			WM_DestroyWindow(Client->Windows[i]);
+			nWindowsDestroyed ++;
+		}
+	}
+	if( nWindowsDestroyed )
+	{
+		_SysDebug("TODO: Show notice that application exited without destroying windows");
+	}
+	
+	// Free client structure
+	free(Client);
+	_SysDebug("Dropped client %p", Client);
+}
+
 tWindow *IPC_int_GetWindow(tIPC_Client *Client, uint32_t WindowID)
 {
 	if( WindowID == -1 )
 		return NULL;
 
 	if( WindowID >= Client->nWindows ) {
-//		_SysDebug("Window %i out of range for %p (%i)", WindowID, Client, Client->nWindows);
 		return NULL;
 	}
 
@@ -256,10 +184,88 @@ void IPC_int_SetWindow(tIPC_Client *Client, uint32_t WindowID, tWindow *WindowPt
 }
 
 // --- IPC Message Handlers ---
+int IPC_Msg_Ping(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+	ASSERT(Msg->ID == IPCMSG_PING);
+	
+	if( !(Msg->Flags & IPCMSG_FLAG_RETURN) )	return 0;
+	
+	if( Msg->Size < 4 )	return -1;
+	
+	tIPCMsg_ReturnInt	*ret = (void*)Msg->Data;
+	Msg->ID = IPCMSG_PING;
+	Msg->Size = sizeof(*ret);
+	ret->Value = AXWIN_VERSION;
+	Client->IPCType->SendMessage(Client->Ident, sizeof(*Msg)+sizeof(*ret), Msg);
+	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)];
+	
+	ASSERT(Msg->ID == IPCMSG_GETDISPLAYCOUNT);
+
+	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)];
+	
+	ASSERT(Msg->ID == IPCMSG_GETDISPLAYDIMS);
+
+	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;
+}
+
 int IPC_Msg_SendMsg(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
 {
 	tIPCMsg_SendMsg	*info = (void*)Msg->Data;
 	tWindow	*src, *dest;
+
+	ASSERT(Msg->ID == IPCMSG_SENDMSG);
 	
 	// - Sanity checks
 	if( Msg->Size < sizeof(tIPCMsg_SendMsg) )
@@ -282,12 +288,23 @@ int IPC_Msg_CreateWin(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
 	tIPCMsg_CreateWin	*info = (void*)Msg->Data;
 	tWindow	*newwin, *parent;
 
+	ASSERT(Msg->ID == IPCMSG_CREATEWIN);
+
 	// - 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);
@@ -303,18 +320,84 @@ int IPC_Msg_CreateWin(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
 	return 0;
 }
 
+int IPC_Msg_DestroyWin(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+	tWindow	*win;
+	
+	ASSERT(Msg->ID == IPCMSG_DESTROYWIN);
+
+	win = IPC_int_GetWindow(Client, Msg->Window);
+	if( !win )
+		return 0;
+	
+	WM_DestroyWindow(win);
+	IPC_int_SetWindow(Client, Msg->Window, NULL);
+	return 0;
+}
+
+int IPC_Msg_SetWindowTitle(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+	tWindow	*win;
+
+	ASSERT(Msg->ID == IPCMSG_SETWINTITLE);
+	
+	if( Msg->Size < 1 )	return -1;
+	if( Msg->Data[ Msg->Size-1 ] != '\0' )	return -1;	
+
+	win = IPC_int_GetWindow(Client, Msg->Window);
+	if(!win)	return 1;
+
+	WM_SetWindowTitle(win, Msg->Data);
+
+	return 0;
+}
+
 int IPC_Msg_ShowWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
 {
-	tIPCMsg_ShowWindow	*info = (void*)Msg->Data;
+	tIPCMsg_Boolean	*info = (void*)Msg->Data;
 	tWindow	*win;
 	
+	ASSERT(Msg->ID == IPCMSG_SHOWWINDOW);
+	
 	if( Msg->Size < sizeof(*info) )	return -1;
 	
 	win = IPC_int_GetWindow(Client, Msg->Window);
 	if(!win)	return 1;
 
-	WM_ShowWindow(win, !!info->bShow);
+	WM_ShowWindow(win, !!info->Value);
+	
+	return 0;
+}
+
+int IPC_Msg_DecorateWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+	tIPCMsg_Boolean	*info = (void*)Msg->Data;
+	tWindow	*win;
+	
+	if( Msg->Size < sizeof(*info) )	return -1;
+	
+	win = IPC_int_GetWindow(Client, Msg->Window);
+	if(!win)	return 1;
+	
+	WM_DecorateWindow(win, !!info->Value);
+	return 0;
+}
+
+int IPC_Msg_FocusWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+	tWindow	*win;
+
+	ASSERT(Msg->ID == IPCMSG_FOCUSWINDOW);
 	
+	// Don't allow the focus to be changed unless the client has the focus
+//	if(!gpWM_FocusedWindow)	return 1;
+//	if(gpWM_FocusedWindow->Client != Client)	return 1;
+
+	win = IPC_int_GetWindow(Client, Msg->Window);
+	if(!win)	return 1;
+
+	WM_FocusWindow(win);
+
 	return 0;
 }
 
@@ -323,6 +406,8 @@ int IPC_Msg_SetWinPos(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
 	tIPCMsg_SetWindowPos	*info = (void*)Msg->Data;
 	tWindow	*win;
 	
+	ASSERT(Msg->ID == IPCMSG_SETWINPOS);
+	
 	if(Msg->Size < sizeof(*info))	return -1;
 	
 	win = IPC_int_GetWindow(Client, Msg->Window);
@@ -338,69 +423,102 @@ int IPC_Msg_SetWinPos(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
 	return 0;
 }
 
-void IPC_Handle(const tIPC_Type *IPCType, const void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg)
+int IPC_Msg_RegisterAction(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
+{
+	tIPCMsg_RegAction	*info = (void*)Msg->Data;
+	tWindow	*win;
+	
+	ASSERT(Msg->ID == IPCMSG_REGACTION);
+
+	if( Msg->Size < sizeof(*info) + 1 )
+		return -1;
+	
+	win = IPC_int_GetWindow(Client, Msg->Window);
+	if(!win)	return 1;
+
+	if( strnlen(info->Action, Msg->Size - sizeof(*info)) == Msg->Size - sizeof(*info) )
+		return 1;
+
+	_SysDebug("RegisterAction %p:%i [%i]\"%s\"",
+		Client, Msg->Window, info->Index, info->Action
+		);
+
+	WM_Hotkey_RegisterAction(info->Action, win, info->Index);
+
+	return 0;
+}
+
+int (*gIPC_MessageHandlers[])(tIPC_Client *Client, tAxWin_IPCMessage *Msg) = {
+	IPC_Msg_Ping,
+	IPC_Msg_GetDisplayCount,
+	IPC_Msg_GetDisplayDims,
+	IPC_Msg_SendMsg,
+	IPC_Msg_CreateWin,
+	IPC_Msg_DestroyWin,	// Destroy window
+	IPC_Msg_SetWindowTitle,
+	IPC_Msg_ShowWindow,
+	IPC_Msg_DecorateWindow,
+	IPC_Msg_FocusWindow,
+	IPC_Msg_SetWinPos,
+	IPC_Msg_RegisterAction
+};
+const int giIPC_NumMessageHandlers = sizeof(gIPC_MessageHandlers)/sizeof(gIPC_MessageHandlers[0]);
+
+void IPC_Handle(tIPC_Client *Client, 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);
+//	_SysDebug("IPC_Handle: (IPCType=%p, Ident=%p, MsgLen=%i, Msg=%p)",
+//		IPCType, Ident, MsgLen, Msg);
 	
 	if( MsgLen < sizeof(tAxWin_IPCMessage) )
 		return ;
 	if( MsgLen < sizeof(tAxWin_IPCMessage) + Msg->Size )
 		return ;
 	
-	client = IPC_int_GetClient(IPCType, Ident);
-
-	switch((enum eAxWin_IPCMessageTypes) Msg->ID)
+	if( Msg->Flags & IPCMSG_FLAG_RENDERER )
 	{
-	// --- Ping message (reset timeout and get server version)
-	case IPCMSG_PING:
-		_SysDebug(" IPC_Handle: IPCMSG_PING");
-		if( Msg->Size < 4 )	return;
-		if( Msg->Flags & IPCMSG_FLAG_RETURN )
-		{
-			Msg->ID = IPCMSG_PING;
-			Msg->Size = sizeof(tIPCMsg_Return);
-			((tIPCMsg_Return*)Msg->Data)->Value = AXWIN_VERSION;
-			IPCType->SendMessage(Ident, sizeof(tIPCMsg_Return), Msg);
+		tWindow *win = IPC_int_GetWindow(Client, Msg->Window);
+		if( !win ) {
+			_SysDebug("WARNING: NULL window in message %i (%x)", Msg->ID, Msg->Window);
+			return ;
+		}
+		tWMRenderer	*renderer = win->Renderer;
+		if( Msg->ID >= renderer->nIPCHandlers ) {
+			_SysDebug("WARNING: Message %i out of range in %s", Msg->ID, renderer->Name);
+			return ;
 		}
-		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");
-		rv = IPC_Msg_CreateWin(client, Msg);
-		break;
-	// --- Show/Hide a window
-	case IPCMSG_SHOWWINDOW:
-		_SysDebug(" IPC_Handle: IPCMSG_SHOWWINDOW");
-		rv = IPC_Msg_ShowWindow(client, Msg);
-		break;
-	// --- Move/Resize a window
-	case IPCMSG_SETWINPOS:
-		_SysDebug(" IPC_Handle: IPCMSG_SETWINPOS");
-		rv = IPC_Msg_SetWinPos(client, Msg);
-		break;
-
-	// --- Unknown message
-	default:
-		fprintf(stderr, "WARNING: Unknown message %i (%p)\n", Msg->ID, IPCType);
-		_SysDebug("WARNING: Unknown message %i (%p)", Msg->ID, IPCType);
-		break;
+		if( !renderer->IPCHandlers[Msg->ID] ) {
+			_SysDebug("WARNING: Message %i has no handler in %s", Msg->ID, renderer->Name);
+			return ;
+		}
+		_SysDebug("IPC_Handle: Call %s-%i %ib", renderer->Name, Msg->ID, Msg->Size);
+		rv = renderer->IPCHandlers[Msg->ID](win, Msg->Size, Msg->Data);
+		if( rv )
+			_SysDebug("IPC_Handle: rv != 0 (%i)", rv);
+	}
+	else
+	{
+		if( Msg->ID >= giIPC_NumMessageHandlers ) {
+			fprintf(stderr, "WARNING: Unknown message %i (%p)\n", Msg->ID, Client);
+			_SysDebug("WARNING: Unknown message %i (%p)", Msg->ID, Client);
+			return ;
+		}
+		
+		if( !gIPC_MessageHandlers[ Msg->ID ] ) {
+			fprintf(stderr, "WARNING: Message %i does not have a handler\n", Msg->ID);
+			_SysDebug("WARNING: Message %i does not have a handler", Msg->ID);
+			return ;
+		}
+	
+		_SysDebug("IPC_Handle: Call WM-%i %ib", Msg->ID, Msg->Size);
+		rv = gIPC_MessageHandlers[Msg->ID](Client, Msg);
+		if( rv )
+			_SysDebug("IPC_Handle: rv != 0 (%i)", rv);
 	}
-	if(rv)
-		_SysDebug("IPC_Handle: rv = %i", rv);
 }
 
-// --- Server->Client replies
+// Dispatch a message to the client
 void IPC_SendWMMessage(tIPC_Client *Client, uint32_t Src, uint32_t Dst, int MsgID, int Len, void *Data)
 {
 	tAxWin_IPCMessage	*hdr;
@@ -423,3 +541,20 @@ void IPC_SendWMMessage(tIPC_Client *Client, uint32_t Src, uint32_t Dst, int MsgI
 	Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
 }
 
+// --- Server->Client replies
+void IPC_SendReply(tIPC_Client *Client, uint32_t WinID, int MsgID, size_t Len, const void *Data)
+{
+	tAxWin_IPCMessage	*hdr;
+	char	buf[sizeof(*hdr)+Len];
+	
+	hdr = (void*)buf;
+	
+	hdr->ID = MsgID;
+	hdr->Flags = IPCMSG_FLAG_RENDERER;
+	hdr->Size = Len;
+	hdr->Window = WinID;
+	
+	memcpy(hdr->Data, Data, Len);
+	Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
+}
+