winmultiwindowwm.c [plain text]
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/select.h>
#include <fcntl.h>
#include <setjmp.h>
#include <pthread.h>
#include <X11/X.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xlocale.h>
#include <X11/Xproto.h>
#include <X11/Xutil.h>
#define ATOM DWORD
#include <windows.h>
#include "winwindow.h"
#define WIN_CONNECT_RETRIES 5
#define WIN_CONNECT_DELAY 5
#define WIN_MSG_QUEUE_FNAME "/dev/windows"
#define WIN_JMP_OKAY 0
#define WIN_JMP_ERROR_IO 2
typedef struct _WMMsgNodeRec {
winWMMessageRec msg;
struct _WMMsgNodeRec *pNext;
} WMMsgNodeRec, *WMMsgNodePtr;
typedef struct _WMMsgQueueRec {
struct _WMMsgNodeRec *pHead;
struct _WMMsgNodeRec *pTail;
pthread_mutex_t pmMutex;
pthread_cond_t pcNotEmpty;
} WMMsgQueueRec, *WMMsgQueuePtr;
typedef struct _WMInfo {
Display *pDisplay;
WMMsgQueueRec wmMsgQueue;
Atom atmWmProtos;
Atom atmWmDelete;
Atom atmPrivMap;
} WMInfoRec, *WMInfoPtr;
typedef struct _WMProcArgRec {
DWORD dwScreen;
WMInfoPtr pWMInfo;
pthread_mutex_t *ppmServerStarted;
} WMProcArgRec, *WMProcArgPtr;
typedef struct _XMsgProcArgRec {
Display *pDisplay;
DWORD dwScreen;
WMInfoPtr pWMInfo;
pthread_mutex_t *ppmServerStarted;
} XMsgProcArgRec, *XMsgProcArgPtr;
extern char *display;
extern void ErrorF (const char* , ...);
extern Bool g_fCalledSetLocale;
extern Bool g_fCalledXInitThreads;
static void
PushMessage (WMMsgQueuePtr pQueue, WMMsgNodePtr pNode);
static WMMsgNodePtr
PopMessage (WMMsgQueuePtr pQueue, WMInfoPtr pWMInfo);
static Bool
InitQueue (WMMsgQueuePtr pQueue);
static void
GetWindowName (Display * pDpy, Window iWin, char **ppName);
static int
SendXMessage (Display *pDisplay, Window iWin, Atom atmType, long nData);
static void
UpdateName (WMInfoPtr pWMInfo, Window iWindow);
static void*
winMultiWindowWMProc (void* pArg);
static int
winMultiWindowWMErrorHandler (Display *pDisp, XErrorEvent *e);
static void *
winMultiWindowXMsgProc (void *pArg);
static void
winInitMultiWindowWM (WMInfoPtr pWMInfo, WMProcArgPtr pProcArg);
static int
winMutliWindowWMIOErrorHandler (Display *pDisplay);
static int g_nQueueSize;
static jmp_buf g_jmpEntry;
static Bool g_shutdown = FALSE;
static void
PushMessage (WMMsgQueuePtr pQueue, WMMsgNodePtr pNode)
{
pthread_mutex_lock (&pQueue->pmMutex);
pNode->pNext = NULL;
if (pQueue->pTail != NULL)
{
pQueue->pTail->pNext = pNode;
}
pQueue->pTail = pNode;
if (pQueue->pHead == NULL)
{
pQueue->pHead = pNode;
}
#if 0
switch (pNode->msg.msg)
{
case WM_WM_MOVE:
ErrorF ("\tWM_WM_MOVE\n");
break;
case WM_WM_RAISE:
ErrorF ("\tWM_WM_RAISE\n");
break;
case WM_WM_LOWER:
ErrorF ("\tWM_WM_RAISE\n");
break;
case WM_WM_MAP:
ErrorF ("\tWM_WM_MAP\n");
break;
case WM_WM_UNMAP:
ErrorF ("\tWM_WM_UNMAP\n");
break;
case WM_WM_KILL:
ErrorF ("\tWM_WM_KILL\n");
break;
default:
ErrorF ("Unknown Message.\n");
break;
}
#endif
++g_nQueueSize;
pthread_mutex_unlock (&pQueue->pmMutex);
pthread_cond_signal (&pQueue->pcNotEmpty);
}
#if CYGMULTIWINDOW_DEBUG
static int
QueueSize (WMMsgQueuePtr pQueue)
{
WMMsgNodePtr pNode;
int nSize = 0;
for (pNode = pQueue->pHead; pNode != NULL; pNode = pNode->pNext)
++nSize;
return nSize;
}
#endif
static WMMsgNodePtr
PopMessage (WMMsgQueuePtr pQueue, WMInfoPtr pWMInfo)
{
WMMsgNodePtr pNode;
pthread_mutex_lock (&pQueue->pmMutex);
while (pQueue->pHead == NULL)
{
pthread_cond_wait (&pQueue->pcNotEmpty, &pQueue->pmMutex);
}
pNode = pQueue->pHead;
if (pQueue->pHead != NULL)
{
pQueue->pHead = pQueue->pHead->pNext;
}
if (pQueue->pTail == pNode)
{
pQueue->pTail = NULL;
}
--g_nQueueSize;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("Queue Size %d %d\n", g_nQueueSize, QueueSize(pQueue));
#endif
pthread_mutex_unlock (&pQueue->pmMutex);
return pNode;
}
#if 0
static Bool
HaveMessage (WMMsgQueuePtr pQueue, UINT msg, Window iWindow)
{
WMMsgNodePtr pNode;
for (pNode = pQueue->pHead; pNode != NULL; pNode = pNode->pNext)
{
if (pNode->msg.msg==msg && pNode->msg.iWindow==iWindow)
return True;
}
return False;
}
#endif
static
Bool
InitQueue (WMMsgQueuePtr pQueue)
{
if (pQueue == NULL)
{
ErrorF ("InitQueue - pQueue is NULL. Exiting.\n");
return FALSE;
}
pQueue->pHead = NULL;
pQueue->pTail = NULL;
g_nQueueSize = 0;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("InitQueue - Queue Size %d %d\n", g_nQueueSize, QueueSize(pQueue));
#endif
ErrorF ("InitQueue - Calling pthread_mutex_init\n");
pthread_mutex_init (&pQueue->pmMutex, NULL);
ErrorF ("InitQueue - pthread_mutex_init returned\n");
ErrorF ("InitQueue - Calling pthread_cond_init\n");
pthread_cond_init (&pQueue->pcNotEmpty, NULL);
ErrorF ("InitQueue - pthread_cond_init returned\n");
return TRUE;
}
static void
GetWindowName (Display *pDisplay, Window iWin, char **ppName)
{
int nResult, nNum;
char **ppList;
XTextProperty xtpName;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("GetWindowName\n");
#endif
*ppName = NULL;
nResult = XGetWMName (pDisplay, iWin, &xtpName);
if (!nResult || !xtpName.value || !xtpName.nitems)
{
#if CYGMULTIWINDOW_DEBUG
ErrorF ("GetWindowName - XGetWMName failed. No name.\n");
#endif
return;
}
if (xtpName.encoding == XA_STRING)
{
if (xtpName.value)
{
*ppName = strdup ((char*)xtpName.value);
XFree (xtpName.value);
}
#if CYGMULTIWINDOW_DEBUG
ErrorF ("GetWindowName - XA_STRING %s\n", *ppName);
#endif
}
else
{
XmbTextPropertyToTextList (pDisplay, &xtpName, &ppList, &nNum);
if (nNum && ppList && *ppList)
{
XFree (xtpName.value);
*ppName = strdup (*ppList);
XFreeStringList (ppList);
}
#if CYGMULTIWINDOW_DEBUG
ErrorF ("GetWindowName - %s %s\n",
XGetAtomName (pDisplay, xtpName.encoding), *ppName);
#endif
}
#if CYGMULTIWINDOW_DEBUG
ErrorF ("GetWindowName - Returning\n");
#endif
}
static int
SendXMessage (Display *pDisplay, Window iWin, Atom atmType, long nData)
{
XEvent e;
e.type = ClientMessage;
e.xclient.window = iWin;
e.xclient.message_type = atmType;
e.xclient.format = 32;
e.xclient.data.l[0] = nData;
e.xclient.data.l[1] = CurrentTime;
return XSendEvent (pDisplay, iWin, False, NoEventMask, &e);
}
static void
UpdateName (WMInfoPtr pWMInfo, Window iWindow)
{
char *pszName;
Atom atmType;
int fmtRet;
unsigned long items, remain;
HWND *retHwnd, hWnd;
XWindowAttributes attr;
hWnd = 0;
if (XGetWindowProperty (pWMInfo->pDisplay,
iWindow,
pWMInfo->atmPrivMap,
0,
1,
False,
pWMInfo->atmPrivMap,
&atmType,
&fmtRet,
&items,
&remain,
(unsigned char **) &retHwnd) == Success)
{
if (retHwnd)
{
hWnd = *retHwnd;
XFree (retHwnd);
}
}
if (!hWnd) return;
if (!IsWindow (hWnd)) return;
GetWindowName (pWMInfo->pDisplay, iWindow, &pszName);
if (pszName)
{
XGetWindowAttributes (pWMInfo->pDisplay,
iWindow,
&attr);
if (!attr.override_redirect)
{
SetWindowText (hWnd, pszName);
winUpdateIcon (iWindow);
}
free (pszName);
}
}
static void *
winMultiWindowWMProc (void *pArg)
{
WMProcArgPtr pProcArg = (WMProcArgPtr)pArg;
WMInfoPtr pWMInfo = pProcArg->pWMInfo;
winInitMultiWindowWM (pWMInfo, pProcArg);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winMultiWindowWMProc ()\n");
#endif
for (;;)
{
WMMsgNodePtr pNode;
pNode = PopMessage (&pWMInfo->wmMsgQueue, pWMInfo);
if (pNode == NULL)
{
ErrorF ("winMultiWindowWMProc - Queue is Empty?\n");
pthread_exit (NULL);
}
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winMultiWindowWMProc - %d ms MSG: %d ID: %d\n",
GetTickCount (), (int)pNode->msg.msg, (int)pNode->msg.dwID);
#endif
switch (pNode->msg.msg)
{
#if 0
case WM_WM_MOVE:
ErrorF ("\tWM_WM_MOVE\n");
break;
case WM_WM_SIZE:
ErrorF ("\tWM_WM_SIZE\n");
break;
#endif
case WM_WM_RAISE:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_RAISE\n");
#endif
XRaiseWindow (pWMInfo->pDisplay, pNode->msg.iWindow);
break;
case WM_WM_LOWER:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_LOWER\n");
#endif
XLowerWindow (pWMInfo->pDisplay, pNode->msg.iWindow);
break;
case WM_WM_MAP:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_MAP\n");
#endif
XChangeProperty (pWMInfo->pDisplay,
pNode->msg.iWindow,
pWMInfo->atmPrivMap,
pWMInfo->atmPrivMap,
32,
PropModeReplace,
(unsigned char *) &(pNode->msg.hwndWindow),
1);
UpdateName (pWMInfo, pNode->msg.iWindow);
winUpdateIcon (pNode->msg.iWindow);
break;
case WM_WM_UNMAP:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_UNMAP\n");
#endif
XUnmapWindow (pWMInfo->pDisplay, pNode->msg.iWindow);
break;
case WM_WM_KILL:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_KILL\n");
#endif
{
int i, n, found = 0;
Atom *protocols;
if (XGetWMProtocols (pWMInfo->pDisplay,
pNode->msg.iWindow,
&protocols,
&n))
{
for (i = 0; i < n; ++i)
if (protocols[i] == pWMInfo->atmWmDelete)
++found;
XFree (protocols);
}
if (found)
SendXMessage (pWMInfo->pDisplay,
pNode->msg.iWindow,
pWMInfo->atmWmProtos,
pWMInfo->atmWmDelete);
else
XKillClient (pWMInfo->pDisplay,
pNode->msg.iWindow);
}
break;
case WM_WM_ACTIVATE:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_ACTIVATE\n");
#endif
XSetInputFocus (pWMInfo->pDisplay,
pNode->msg.iWindow,
RevertToPointerRoot,
CurrentTime);
break;
case WM_WM_NAME_EVENT:
UpdateName (pWMInfo, pNode->msg.iWindow);
break;
case WM_WM_HINTS_EVENT:
winUpdateIcon (pNode->msg.iWindow);
break;
case WM_WM_CHANGE_STATE:
winMinimizeWindow (pNode->msg.iWindow);
break;
default:
ErrorF ("winMultiWindowWMProc - Unknown Message.\n");
pthread_exit (NULL);
break;
}
free (pNode);
XFlush (pWMInfo->pDisplay);
}
pthread_cond_destroy (&pWMInfo->wmMsgQueue.pcNotEmpty);
pthread_mutex_destroy (&pWMInfo->wmMsgQueue.pmMutex);
free (pProcArg);
#if CYGMULTIWINDOW_DEBUG
ErrorF("-winMultiWindowWMProc ()\n");
#endif
}
static int
winMultiWindowWMErrorHandler (Display *pDisplay, XErrorEvent *pErr)
{
char pszErrorMsg[100];
if (pErr->request_code == X_ChangeWindowAttributes
&& pErr->error_code == BadAccess)
{
ErrorF ("winMultiWindowWMErrorHandler - ChangeWindowAttributes "
"BadAccess.\n");
#if 0
pthread_exit (NULL);
#endif
return 0;
}
XGetErrorText (pDisplay,
pErr->error_code,
pszErrorMsg,
sizeof (pszErrorMsg));
ErrorF ("winMultiWindowWMErrorHandler - ERROR: %s\n", pszErrorMsg);
if (pErr->error_code == BadWindow
|| pErr->error_code == BadMatch
|| pErr->error_code == BadDrawable)
{
#if 0
pthread_exit (NULL);
#endif
return 0;
}
pthread_exit (NULL);
return 0;
}
static void *
winMultiWindowXMsgProc (void *pArg)
{
winWMMessageRec msg;
XMsgProcArgPtr pProcArg = (XMsgProcArgPtr) pArg;
char pszDisplay[512];
int iRetries;
XEvent event;
Atom atmWmName;
Atom atmWmHints;
Atom atmWmChange;
int iReturn;
XIconSize *xis;
ErrorF ("winMultiWindowXMsgProc - Hello\n");
if (pProcArg == NULL)
{
ErrorF ("winMultiWindowXMsgProc - pProcArg is NULL, bailing.\n");
pthread_exit (NULL);
}
ErrorF ("winMultiWindowXMsgProc - Calling pthread_mutex_lock ()\n");
iReturn = pthread_mutex_lock (pProcArg->ppmServerStarted);
if (iReturn != 0)
{
ErrorF ("winMultiWindowXMsgProc - pthread_mutex_lock () failed: %d\n",
iReturn);
pthread_exit (NULL);
}
ErrorF ("winMultiWindowXMsgProc - pthread_mutex_lock () returned.\n");
if (!g_fCalledXInitThreads)
{
if (XInitThreads () == 0)
{
ErrorF ("winMultiWindowXMsgProc - XInitThreads () failed.\n");
pthread_exit (NULL);
}
g_fCalledXInitThreads = TRUE;
ErrorF ("winMultiWindowXMsgProc - XInitThreads () returned.\n");
}
pthread_mutex_unlock (pProcArg->ppmServerStarted);
ErrorF ("winMultiWindowXMsgProc - pthread_mutex_unlock () returned.\n");
snprintf (pszDisplay,
512, "127.0.0.1:%s.%d", display, (int)pProcArg->dwScreen);
ErrorF ("winMultiWindowXMsgProc - DISPLAY=%s\n", pszDisplay);
iRetries = 0;
do
{
pProcArg->pDisplay = XOpenDisplay (pszDisplay);
if (pProcArg->pDisplay == NULL)
{
ErrorF ("winMultiWindowXMsgProc - Could not open display, try: %d, "
"sleeping: %d\n\f",
iRetries + 1, WIN_CONNECT_DELAY);
++iRetries;
sleep (WIN_CONNECT_DELAY);
continue;
}
else
break;
}
while (pProcArg->pDisplay == NULL && iRetries < WIN_CONNECT_RETRIES);
if (pProcArg->pDisplay == NULL)
{
ErrorF ("winMultiWindowXMsgProcwinInitMultiWindowWM - "
"Failed opening the display, giving up.\n\f");
pthread_exit (NULL);
}
ErrorF ("winMultiWindowXMsgProc - XOpenDisplay () returned and "
"successfully opened the display.\n");
XSetErrorHandler (winMultiWindowWMErrorHandler);
XSetIOErrorHandler (winMutliWindowWMIOErrorHandler);
XSelectInput (pProcArg->pDisplay,
RootWindow(pProcArg->pDisplay, pProcArg->dwScreen),
SubstructureNotifyMask);
xis = XAllocIconSize ();
if (xis)
{
xis->min_width = xis->min_height = 16;
xis->max_width = xis->max_height = 48;
xis->width_inc = xis->height_inc = 16;
XSetIconSizes (pProcArg->pDisplay,
RootWindow (pProcArg->pDisplay, pProcArg->dwScreen),
xis,
1);
XFree (xis);
}
atmWmName = XInternAtom (pProcArg->pDisplay,
"WM_NAME",
False);
atmWmHints = XInternAtom (pProcArg->pDisplay,
"WM_HINTS",
False);
atmWmChange = XInternAtom (pProcArg->pDisplay,
"WM_CHANGE_STATE",
False);
while (1)
{
XNextEvent (pProcArg->pDisplay, &event);
if (event.type == CreateNotify)
{
XSelectInput (pProcArg->pDisplay,
event.xcreatewindow.window,
PropertyChangeMask);
}
else if (event.type == PropertyNotify
&& event.xproperty.atom == atmWmName)
{
memset (&msg, 0, sizeof (msg));
msg.msg = WM_WM_NAME_EVENT;
msg.iWindow = event.xproperty.window;
winSendMessageToWM (pProcArg->pWMInfo, &msg);
}
else if (event.type == PropertyNotify
&& event.xproperty.atom == atmWmHints)
{
memset (&msg, 0, sizeof (msg));
msg.msg = WM_WM_HINTS_EVENT;
msg.iWindow = event.xproperty.window;
winSendMessageToWM (pProcArg->pWMInfo, &msg);
}
else if (event.type == ClientMessage
&& event.xclient.message_type == atmWmChange
&& event.xclient.data.l[0] == IconicState)
{
ErrorF ("winMultiWindowXMsgProc - WM_CHANGE_STATE - IconicState\n");
memset (&msg, 0, sizeof (msg));
msg.msg = WM_WM_CHANGE_STATE;
msg.iWindow = event.xclient.window;
winSendMessageToWM (pProcArg->pWMInfo, &msg);
}
}
}
Bool
winInitWM (void **ppWMInfo,
pthread_t *ptWMProc,
pthread_t *ptXMsgProc,
pthread_mutex_t *ppmServerStarted,
int dwScreen)
{
WMProcArgPtr pArg = (WMProcArgPtr) malloc (sizeof(WMProcArgRec));
WMInfoPtr pWMInfo = (WMInfoPtr) malloc (sizeof(WMInfoRec));
XMsgProcArgPtr pXMsgArg = (XMsgProcArgPtr) malloc (sizeof(XMsgProcArgRec));
if (pArg == NULL || pWMInfo == NULL)
{
ErrorF ("winInitWM - malloc fail.\n");
return FALSE;
}
*ppWMInfo = pWMInfo;
pArg->dwScreen = dwScreen;
pArg->pWMInfo = pWMInfo;
pArg->ppmServerStarted = ppmServerStarted;
if (!InitQueue (&pWMInfo->wmMsgQueue))
{
ErrorF ("winInitWM - InitQueue () failed.\n");
return FALSE;
}
if (pthread_create (ptWMProc, NULL, winMultiWindowWMProc, pArg))
{
ErrorF ("winInitWM - pthread_create failed for Window Manager.\n");
return FALSE;
}
pXMsgArg->dwScreen = dwScreen;
pXMsgArg->pWMInfo = pWMInfo;
pXMsgArg->ppmServerStarted = ppmServerStarted;
if (pthread_create (ptXMsgProc, NULL, winMultiWindowXMsgProc, pXMsgArg))
{
ErrorF ("winInitWM - pthread_create failed on XMSG.\n");
return FALSE;
}
#if CYGDEBUG || YES
ErrorF ("winInitWM - Returning.\n");
#endif
return TRUE;
}
Bool
winClipboardDetectUnicodeSupport ();
static void
winInitMultiWindowWM (WMInfoPtr pWMInfo, WMProcArgPtr pProcArg)
{
int iRetries = 0;
char pszDisplay[512];
int iReturn;
Bool fUnicodeSupport;
ErrorF ("winInitMultiWindowWM - Hello\n");
if (pProcArg == NULL)
{
ErrorF ("winInitMultiWindowWM - pProcArg is NULL, bailing.\n");
pthread_exit (NULL);
}
ErrorF ("winInitMultiWindowWM - Calling pthread_mutex_lock ()\n");
iReturn = pthread_mutex_lock (pProcArg->ppmServerStarted);
if (iReturn != 0)
{
ErrorF ("winInitMultiWindowWM - pthread_mutex_lock () failed: %d\n",
iReturn);
pthread_exit (NULL);
}
ErrorF ("winInitMultiWindowWM - pthread_mutex_lock () returned.\n");
fUnicodeSupport = winClipboardDetectUnicodeSupport ();
if (fUnicodeSupport && !g_fCalledSetLocale)
{
ErrorF ("winInitMultiWindowWM - Calling setlocale ()\n");
if (!setlocale (LC_ALL, ""))
{
ErrorF ("winInitMultiWindowWM - setlocale () error\n");
pthread_exit (NULL);
}
ErrorF ("winInitMultiWindowWM - setlocale () returned\n");
if (XSupportsLocale () == False)
{
ErrorF ("winInitMultiWindowWM - Locale not supported by X\n");
pthread_exit (NULL);
}
}
g_fCalledSetLocale = TRUE;
if (!g_fCalledXInitThreads)
{
if (XInitThreads () == 0)
{
ErrorF ("winInitMultiWindowWM - XInitThreads () failed.\n");
pthread_exit (NULL);
}
g_fCalledXInitThreads = TRUE;
ErrorF ("winInitMultiWindowWM - XInitThreads () returned.\n");
}
pthread_mutex_unlock (pProcArg->ppmServerStarted);
ErrorF ("winInitMultiWindowWM - pthread_mutex_unlock () returned.\n");
iReturn = setjmp (g_jmpEntry);
if (iReturn != WIN_JMP_ERROR_IO
&& iReturn != WIN_JMP_OKAY)
{
ErrorF ("winInitMultiWindowWM - setjmp returned: %d exiting\n",
iReturn);
pthread_exit (NULL);
}
else if (g_shutdown)
{
ErrorF ("winInitMultiWindowWM - Detected shutdown in progress\n");
pthread_exit (NULL);
}
else if (iReturn == WIN_JMP_ERROR_IO)
{
ErrorF ("winInitMultiWindowWM - setjmp returned WIN_JMP_ERROR_IO\n");
}
snprintf (pszDisplay,
512,
"127.0.0.1:%s.%d",
display,
(int) pProcArg->dwScreen);
ErrorF ("winInitMultiWindowWM - DISPLAY=%s\n", pszDisplay);
do
{
pWMInfo->pDisplay = XOpenDisplay (pszDisplay);
if (pWMInfo->pDisplay == NULL)
{
ErrorF ("winInitMultiWindowWM - Could not open display, try: %d, "
"sleeping: %d\n\f",
iRetries + 1, WIN_CONNECT_DELAY);
++iRetries;
sleep (WIN_CONNECT_DELAY);
continue;
}
else
break;
}
while (pWMInfo->pDisplay == NULL && iRetries < WIN_CONNECT_RETRIES);
if (pWMInfo->pDisplay == NULL)
{
ErrorF ("winInitMultiWindowWM - Failed opening the display, "
"giving up.\n\f");
pthread_exit (NULL);
}
ErrorF ("winInitMultiWindowWM - XOpenDisplay () returned and "
"successfully opened the display.\n");
XSetErrorHandler (winMultiWindowWMErrorHandler);
XSetIOErrorHandler (winMutliWindowWMIOErrorHandler);
pWMInfo->atmWmProtos = XInternAtom (pWMInfo->pDisplay,
"WM_PROTOCOLS",
False);
pWMInfo->atmWmDelete = XInternAtom (pWMInfo->pDisplay,
"WM_DELETE_WINDOW",
False);
pWMInfo->atmPrivMap = XInternAtom (pWMInfo->pDisplay,
WIN_HWND_CACHE,
False);
}
void
winSendMessageToWM (void *pWMInfo, winWMMessagePtr pMsg)
{
WMMsgNodePtr pNode;
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winSendMessageToWM ()\n");
#endif
pNode = (WMMsgNodePtr)malloc(sizeof(WMMsgNodeRec));
if (pNode != NULL)
{
memcpy (&pNode->msg, pMsg, sizeof(winWMMessageRec));
PushMessage (&((WMInfoPtr)pWMInfo)->wmMsgQueue, pNode);
}
}
static int
winMutliWindowWMIOErrorHandler (Display *pDisplay)
{
printf ("\nwinMutliWindowWMIOErrorHandler!\n\n");
longjmp (g_jmpEntry, WIN_JMP_ERROR_IO);
return 0;
}
void
winDeinitMultiWindowWM ()
{
ErrorF ("winDeinitMultiWindowWM - Noting shutdown in progress\n");
g_shutdown = TRUE;
}