diff options
Diffstat (limited to 'nx-X11/programs/Xserver/hw/nxagent/Events.c')
| -rw-r--r-- | nx-X11/programs/Xserver/hw/nxagent/Events.c | 3822 |
1 files changed, 3822 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Events.c b/nx-X11/programs/Xserver/hw/nxagent/Events.c new file mode 100644 index 000000000..e1eab6fd2 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/nxagent/Events.c @@ -0,0 +1,3822 @@ +/**************************************************************************/ +/* */ +/* Copyright (c) 2001, 2007 NoMachine, http://www.nomachine.com/. */ +/* */ +/* NXAGENT, NX protocol compression and NX extensions to this software */ +/* are copyright of NoMachine. Redistribution and use of the present */ +/* software is allowed according to terms specified in the file LICENSE */ +/* which comes in the source distribution. */ +/* */ +/* Check http://www.nomachine.com/licensing.html for applicability. */ +/* */ +/* NX and NoMachine are trademarks of NoMachine S.r.l. */ +/* */ +/* All rights reserved. */ +/* */ +/**************************************************************************/ + +#include "X.h" +#include "signal.h" +#include "unistd.h" +#define NEED_EVENTS +#include "Xproto.h" +#include "screenint.h" +#include "input.h" +#include "misc.h" +#include "scrnintstr.h" +#include "windowstr.h" +#include "servermd.h" +#include "mi.h" +#include "selection.h" +#include "keysym.h" +#include "fb.h" +#include "mibstorest.h" +#include "osdep.h" + +#include "Agent.h" +#include "Args.h" +#include "Atoms.h" +#include "Colormap.h" +#include "Display.h" +#include "Screen.h" +#include "Windows.h" +#include "Pixmaps.h" +#include "Keyboard.h" +#include "Keystroke.h" +#include "Events.h" +#include "Pointer.h" +#include "Rootless.h" +#include "Splash.h" +#include "Trap.h" +#include "Dialog.h" +#include "Client.h" +#include "Clipboard.h" +#include "Split.h" +#include "Drawable.h" +#include "Handlers.h" +#include "Utils.h" + +#include "NX.h" +#include "NXvars.h" +#include "NXproto.h" + +#ifdef NXAGENT_FIXKEYS +#include "inputstr.h" +#include "input.h" +#endif + +#include "XKBlib.h" + +#define GC XlibGC +#define Font XlibFont +#define KeySym XlibKeySym +#define XID XlibXID +#include "Xlibint.h" +#undef GC +#undef Font +#undef KeySym +#undef XID + +#include <X11/cursorfont.h> + +#include "Shadow.h" +#include "Xrandr.h" + +#include "NXlib.h" + +/* + * Set here the required log level. Please note + * that if you want to enable DEBUG here, then + * you need to enable DEBUG even in Rootless.c + */ + +#define PANIC +#define WARNING +#undef TEST +#undef DEBUG + +/* + * Log begin and end of the important handlers. + */ + +#undef BLOCKS + +extern Bool nxagentOnce; + +extern WindowPtr nxagentRootTileWindow; +extern int nxagentSplashCount; + +extern int nxagentLastClipboardClient; + +#ifdef DEBUG +extern Bool nxagentRootlessTreesMatch(void); +#endif + +Bool xkbdRunning = False; +pid_t pidkbd; + +WindowPtr nxagentLastEnteredWindow = NULL; + +PropertyRequestRec nxagentPropertyRequests[NXNumberOfResources]; + +void nxagentHandleCollectPropertyEvent(XEvent*); + +/* + * Finalize the asynchronous handling + * of the X_GrabPointer requests. + */ + +void nxagentHandleCollectGrabPointerEvent(int resource); + +Bool nxagentCollectGrabPointerPredicate(Display *display, XEvent *X, XPointer ptr); + +/* + * Used in Handlers.c to synchronize + * the agent with the remote X server. + */ + +void nxagentHandleCollectInputFocusEvent(int resource); + +/* + * Viewport navigation. + */ + +static int viewportInc = 1; +static enum HandleEventResult viewportLastKeyPressResult; +static int viewportLastX; +static int viewportLastY; +static Cursor viewportCursor; + +/* + * Keyboard and pointer are handled as they were real devices by + * Xnest and we inherit this behaviour. The following mask will + * contain the event mask selected for the root window of the + * agent. All the keyboard and pointer events will be translated + * by the agent and sent to the internal clients according to + * events selected by the inferior windows. + */ + +static Mask defaultEventMask; + +#define MAX_INC 200 +#define INC_STEP 5 +#define nextinc(x) ((x) < MAX_INC ? (x) += INC_STEP : (x)) + +/* + * Used to mask the appropriate bits in + * the state reported by XkbStateNotify + * and XkbGetIndicatorState. + */ + +#define CAPSFLAG_IN_REPLY 1 +#define CAPSFLAG_IN_EVENT 2 +#define NUMFLAG_IN_EVENT 16 +#define NUMFLAG_IN_REPLY 2 + +CARD32 nxagentLastEventTime = 0; +CARD32 nxagentLastKeyPressTime = 0; +Time nxagentLastServerTime = 0; + +/* + * Used for storing windows that need to + * receive expose events from the agent. + */ + +#define nxagentExposeQueueHead nxagentExposeQueue.exposures[nxagentExposeQueue.start] + +ExposeQueue nxagentExposeQueue; + +RegionPtr nxagentRemoteExposeRegion = NULL; + +static void nxagentForwardRemoteExpose(void); + +static int nxagentClipAndSendExpose(WindowPtr pWin, pointer ptr); + +/* + * Associate a resource to a drawable and + * store the region affected by the split + * operation. + */ + +SplitResourceRec nxagentSplitResources[NXNumberOfResources]; + +/* + * Associate a resource to an unpack + * operation. + */ + +UnpackResourceRec nxagentUnpackResources[NXNumberOfResources]; + +/* + * We have to check these before launching + * the terminate dialog in rootless mode. + */ + +Bool nxagentLastWindowDestroyed = False; +Time nxagentLastWindowDestroyedTime = 0; + +/* + * Set this flag when an user input event + * is received. + */ + +int nxagentInputEvent = 0; + +int nxagentKeyDown = 0; + +void nxagentSwitchResizeMode(ScreenPtr pScreen); + +int nxagentCheckWindowConfiguration(XConfigureEvent* X); + +#define nxagentMonitoredDuplicate(keysym) \ + ((keysym) == XK_Left || (keysym) == XK_Up || \ + (keysym) == XK_Right || (keysym) == XK_Down || \ + (keysym) == XK_Page_Up || (keysym) == XK_Page_Down || \ + (keysym) == XK_Delete || (keysym) == XK_BackSpace) + +void nxagentRemoveDuplicatedKeys(XEvent *X); + +void ProcessInputEvents() +{ + mieqProcessInputEvents(); +} + +void nxagentSwitchResizeMode(ScreenPtr pScreen) +{ + XSizeHints sizeHints; + + int desktopResize = nxagentOption(DesktopResize); + + nxagentChangeOption(DesktopResize, !desktopResize); + + sizeHints.flags = PMaxSize; + + if (nxagentOption(DesktopResize) == 0) + { + fprintf(stderr,"Info: Disabled desktop resize mode in agent.\n"); + + nxagentLaunchDialog(DIALOG_DISABLE_DESKTOP_RESIZE_MODE); + + sizeHints.max_width = nxagentOption(RootWidth); + sizeHints.max_height = nxagentOption(RootHeight); + } + else + { + fprintf(stderr,"Info: Enabled desktop resize mode in agent.\n"); + + nxagentLaunchDialog(DIALOG_ENABLE_DESKTOP_RESIZE_MODE); + + nxagentRRSetScreenConfig(pScreen, nxagentOption(Width), nxagentOption(Height)); + + sizeHints.max_width = WidthOfScreen(DefaultScreenOfDisplay(nxagentDisplay)); + sizeHints.max_height = HeightOfScreen(DefaultScreenOfDisplay(nxagentDisplay)); + } + + XSetWMNormalHints(nxagentDisplay, nxagentDefaultWindows[pScreen->myNum], + &sizeHints); +} + +void nxagentShadowSwitchResizeMode(ScreenPtr pScreen) +{ + XSizeHints sizeHints; + + int desktopResize = nxagentOption(DesktopResize); + + nxagentChangeOption(DesktopResize, !desktopResize); + + sizeHints.flags = PMaxSize; + + if (nxagentOption(DesktopResize) == 0) + { + nxagentShadowSetRatio(1.0, 1.0); + + nxagentShadowCreateMainWindow(screenInfo.screens[DefaultScreen(nxagentDisplay)], WindowTable[0], + WindowTable[0] -> drawable.width, WindowTable[0] -> drawable.height); + + sizeHints.max_width = nxagentOption(RootWidth); + sizeHints.max_height = nxagentOption(RootHeight); + + fprintf(stderr,"Info: Disabled resize mode in shadow agent.\n"); + } + else + { + nxagentShadowSetRatio(nxagentOption(Width) * 1.0 / + WindowTable[0] -> drawable.width, + nxagentOption(Height) * 1.0 / + WindowTable[0] -> drawable.height); + + nxagentShadowCreateMainWindow(screenInfo.screens[DefaultScreen(nxagentDisplay)], + WindowTable[0], WindowTable[0] -> drawable.width, + WindowTable[0] -> drawable.height); + + sizeHints.max_width = WidthOfScreen(DefaultScreenOfDisplay(nxagentDisplay)); + sizeHints.max_height = HeightOfScreen(DefaultScreenOfDisplay(nxagentDisplay)); + + fprintf(stderr,"Info: Enabled resize mode in shadow agent.\n"); + } + + XSetWMNormalHints(nxagentDisplay, nxagentDefaultWindows[pScreen->myNum], + &sizeHints); +} + +static void nxagentSwitchDeferMode(void) +{ + if (nxagentOption(DeferLevel) == 0) + { + nxagentChangeOption(DeferLevel, UNDEFINED); + + nxagentSetDeferLevel(); + } + else + { + nxagentChangeOption(DeferLevel, 0); + } + + if (nxagentOption(DeferLevel) != 0) + { + nxagentLaunchDialog(DIALOG_ENABLE_DEFER_MODE); + } + else + { + nxagentLaunchDialog(DIALOG_DISABLE_DEFER_MODE); + + nxagentForceSynchronization = 1; + } +} + +static Bool nxagentExposurePredicate(Display *display, XEvent *event, XPointer window) +{ + /* + * Handle both Expose and ProcessedExpose events. + * The latters are those not filtered by function + * nxagentWindowExposures(). + */ + + if (window) + { + return ((event -> type == Expose || event -> type == ProcessedExpose) && + event -> xexpose.window == *((Window *) window)); + } + else + { + return (event -> type == Expose || event -> type == ProcessedExpose); + } +} + +static int nxagentAnyEventPredicate(Display *display, XEvent *event, XPointer parameter) +{ + return 1; +} + +int nxagentInputEventPredicate(Display *display, XEvent *event, XPointer parameter) +{ + switch (event -> type) + { + case KeyPress: + case KeyRelease: + case ButtonPress: + case ButtonRelease: + { + return 1; + } + default: + { + return 0; + } + } +} + +void nxagentInitDefaultEventMask() +{ + Mask mask = NoEventMask; + + mask |= (StructureNotifyMask | VisibilityChangeMask); + + mask |= ExposureMask; + + mask |= NXAGENT_KEYBOARD_EVENT_MASK; + mask |= NXAGENT_POINTER_EVENT_MASK; + + defaultEventMask = mask; +} + +void nxagentGetDefaultEventMask(Mask *mask_return) +{ + *mask_return = defaultEventMask; +} + +void nxagentSetDefaultEventMask(Mask mask) +{ + defaultEventMask = mask; +} + +void nxagentGetEventMask(WindowPtr pWin, Mask *mask_return) +{ + Mask mask = NoEventMask; + + if (nxagentOption(Rootless)) + { + /* + * mask = pWin -> eventMask & + * ~(NXAGENT_KEYBOARD_EVENT_MASK | NXAGENT_POINTER_EVENT_MASK); + */ + + if (pWin -> drawable.class == InputOutput) + { + if (nxagentWindowTopLevel(pWin)) + { + mask = defaultEventMask; + } + else + { + mask = ExposureMask | VisibilityChangeMask | PointerMotionMask; + } + } + + mask |= PropertyChangeMask; + } + else if (pWin -> drawable.class != InputOnly) + { + mask = ExposureMask | VisibilityChangeMask; + } + + *mask_return = mask; +} + +static int nxagentChangeMapPrivate(WindowPtr pWin, pointer ptr) +{ + if (pWin && nxagentWindowPriv(pWin)) + { + nxagentWindowPriv(pWin) -> isMapped = *((Bool *) ptr); + } + + return WT_WALKCHILDREN; +} + +static int nxagentChangeVisibilityPrivate(WindowPtr pWin, pointer ptr) +{ + if (pWin && nxagentWindowPriv(pWin)) + { + nxagentWindowPriv(pWin) -> visibilityState = *((int *) ptr); + } + + return WT_WALKCHILDREN; +} + +void nxagentDispatchEvents(PredicateFuncPtr predicate) +{ + XEvent X; + xEvent x; + ScreenPtr pScreen = NULL; + + Bool minimize = False; + Bool startKbd = False; + Bool closeSession = False; + Bool switchFullscreen = False; + + /* + * Last entered top level window. + */ + + static WindowPtr nxagentLastEnteredTopLevelWindow = NULL; + + #ifdef BLOCKS + fprintf(stderr, "[Begin read]\n"); + #endif + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new events with " + "predicate [%p].\n", predicate); + #endif + + if (nxagentRemoteExposeRegion == NULL) + { + nxagentInitRemoteExposeRegion(); + } + + /* + * We must read here, even if apparently there is + * nothing to read. The ioctl() based readable + * function, in fact, is often unable to detect a + * failure of the socket, in particular if the + * agent was connected to the proxy and the proxy + * is gone. Thus we must trust the wakeup handler + * that called us after the select(). + */ + + #ifdef TEST + + if (nxagentPendingEvents(nxagentDisplay) == 0) + { + fprintf(stderr, "nxagentDispatchEvents: PANIC! No event needs to be dispatched.\n"); + } + + #endif + + /* + * We want to process all the events already in + * the queue, plus any additional event that may + * be read from the network. If no event can be + * read, we want to continue handling our clients + * without flushing the output buffer. + */ + + while (nxagentCheckEvents(nxagentDisplay, &X, predicate != NULL ? predicate : + nxagentAnyEventPredicate, NULL) == 1) + { + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: Going to handle new event type [%d].\n", + X.type); + #endif + + /* + * Handle the incoming event. + */ + + switch (X.type) + { + #ifdef NXAGENT_CLIPBOARD + + case SelectionClear: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new SelectionClear event.\n"); + #endif + + nxagentClearSelection(&X); + + break; + } + case SelectionRequest: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new SelectionRequest event.\n"); + #endif + + nxagentRequestSelection(&X); + + break; + } + case SelectionNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new SelectionNotify event.\n"); + #endif + + nxagentNotifySelection(&X); + + break; + } + + #endif /* NXAGENT_CLIPBOARD */ + + case PropertyNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: PropertyNotify on " + "prop %d[%s] window %lx state %d\n", + (int)X.xproperty.atom, validateString(XGetAtomName(nxagentDisplay, X.xproperty.atom)), + X.xproperty.window, X.xproperty.state); + #endif + + nxagentHandlePropertyNotify(&X); + + break; + } + case KeyPress: + { + enum HandleEventResult result; + + KeySym keysym; + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new KeyPress event.\n"); + #endif + + nxagentInputEvent = 1; + + nxagentKeyDown++; + + nxagentHandleKeyPress(&X, &result); + + if (viewportLastKeyPressResult != result) + { + viewportInc = 1; + + viewportLastKeyPressResult = result; + } + + if (result != doNothing && result != doStartKbd) + { + pScreen = nxagentScreen(X.xkey.window); + } + + switch (result) + { + case doNothing: + { + break; + } + case doCloseSession: + { + closeSession = TRUE; + + break; + } + case doMinimize: + { + minimize = TRUE; + + break; + } + case doStartKbd: + { + startKbd = TRUE; + + break; + } + case doSwitchFullscreen: + { + switchFullscreen = TRUE; + + break; + } + case doViewportUp: + { + nxagentMoveViewport(pScreen, 0, -nextinc(viewportInc)); + + break; + } + case doViewportDown: + { + nxagentMoveViewport(pScreen, 0, +nextinc(viewportInc)); + + break; + } + case doViewportLeft: + { + nxagentMoveViewport(pScreen, -nextinc(viewportInc), 0); + + break; + } + case doViewportRight: + { + nxagentMoveViewport(pScreen, +nextinc(viewportInc), 0); + + break; + } + case doSwitchResizeMode: + { + if (nxagentOption(Shadow) == 0) + { + if (nxagentNoDialogIsRunning) + { + nxagentSwitchResizeMode(pScreen); + } + } + else + { + nxagentShadowSwitchResizeMode(pScreen); + } + + break; + } + case doSwitchDeferMode: + { + if (nxagentNoDialogIsRunning) + { + nxagentSwitchDeferMode(); + } + + break; + } + default: + { + FatalError("nxagentDispatchEvent: handleKeyPress returned unknown value\n"); + + break; + } + } + + /* + * Elide multiple KeyPress/KeyRelease events of + * the same key and generate a single pair. This + * is intended to reduce the impact of the laten- + * cy on the key auto-repeat, handled by the re- + * mote X server. We may optionally do that only + * if the timestamps in the events show an exces- + * sive delay. + */ + + keysym = XKeycodeToKeysym(nxagentDisplay, X.xkey.keycode, 0); + + if (nxagentMonitoredDuplicate(keysym) == 1) + { + nxagentRemoveDuplicatedKeys(&X); + } + + if (nxagentOption(ViewOnly) == 0 && nxagentOption(Shadow) == 1 && result == doNothing) + { + NXShadowEvent(nxagentDisplay, X); + } + + break; + } + case KeyRelease: + { + enum HandleEventResult result; + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new KeyRelease event.\n"); + #endif + + nxagentInputEvent = 1; + + nxagentKeyDown--; + + if (nxagentKeyDown <= 0) + { + nxagentKeyDown = 0; + } + + if (nxagentXkbState.Initialized == 0) + { + nxagentInitKeyboardState(); + } + + x.u.u.type = KeyRelease; + x.u.u.detail = X.xkey.keycode; + x.u.keyButtonPointer.time = nxagentLastKeyPressTime + (X.xkey.time - nxagentLastServerTime); + + nxagentLastServerTime = X.xkey.time; + + nxagentLastEventTime = GetTimeInMillis(); + + if (!(nxagentCheckSpecialKeystroke(&X.xkey, &result))) + { + mieqEnqueue(&x); + + CriticalOutputPending = 1; + + if (nxagentOption(ViewOnly) == 0 && nxagentOption(Shadow)) + { + NXShadowEvent(nxagentDisplay, X); + } + } + + break; + } + case ButtonPress: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new ButtonPress event.\n"); + #endif + + nxagentInputEvent = 1; + + if (nxagentOption(Fullscreen)) + { + if (nxagentMagicPixelZone(X.xbutton.x, X.xbutton.y)) + { + pScreen = nxagentScreen(X.xbutton.window); + + minimize = True; + + break; + } + } + + if (nxagentIpaq && nxagentClients <= 0) + { + closeSession = TRUE; + } + + if (nxagentOption(DesktopResize) == False && + (X.xbutton.state & (ControlMask | Mod1Mask)) == (ControlMask | Mod1Mask)) + { + /* + * Start viewport navigation mode. + */ + + int resource = nxagentWaitForResource(NXGetCollectGrabPointerResource, + nxagentCollectGrabPointerPredicate); + + ScreenPtr pScreen = nxagentScreen(X.xbutton.window); + viewportCursor = XCreateFontCursor(nxagentDisplay, XC_fleur); + + NXCollectGrabPointer(nxagentDisplay, resource, + nxagentDefaultWindows[pScreen -> myNum], True, + NXAGENT_POINTER_EVENT_MASK, GrabModeAsync, + GrabModeAsync, None, viewportCursor, + CurrentTime); + viewportLastX = X.xbutton.x; + viewportLastY = X.xbutton.y; + + break; + } + + if (!(nxagentOption(Fullscreen) && + X.xbutton.window == nxagentFullscreenWindow && + X.xbutton.subwindow == None)) + { + x.u.u.type = ButtonPress; + x.u.u.detail = X.xbutton.button; + x.u.keyButtonPointer.time = nxagentLastEventTime = GetTimeInMillis(); + + if (nxagentOption(Rootless)) + { + x.u.keyButtonPointer.rootX = X.xmotion.x_root; + x.u.keyButtonPointer.rootY = X.xmotion.y_root; + } + else + { + x.u.keyButtonPointer.rootX = X.xmotion.x - nxagentOption(RootX); + x.u.keyButtonPointer.rootY = X.xmotion.y - nxagentOption(RootY); + } + + mieqEnqueue(&x); + + CriticalOutputPending = 1; + } + + if (nxagentOption(ViewOnly) == 0 && nxagentOption(Shadow)) + { + X.xbutton.x -= nxagentOption(RootX); + X.xbutton.y -= nxagentOption(RootY); + + if (nxagentOption(YRatio) != DONT_SCALE) + { + X.xbutton.x = (X.xbutton.x << PRECISION) / nxagentOption(YRatio); + } + + if (nxagentOption(XRatio) != DONT_SCALE) + { + X.xbutton.y = (X.xbutton.y << PRECISION) / nxagentOption(YRatio); + } + + NXShadowEvent(nxagentDisplay, X); + } + + break; + } + case ButtonRelease: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new ButtonRelease event.\n"); + #endif + + nxagentInputEvent = 1; + + if (viewportCursor) + { + /* + * Leave viewport navigation mode. + */ + + XUngrabPointer(nxagentDisplay, CurrentTime); + + XFreeCursor(nxagentDisplay, viewportCursor); + + viewportCursor = None; + } + + if (minimize != True) + { + x.u.u.type = ButtonRelease; + x.u.u.detail = X.xbutton.button; + x.u.keyButtonPointer.time = nxagentLastEventTime = GetTimeInMillis(); + + if (nxagentOption(Rootless)) + { + x.u.keyButtonPointer.rootX = X.xmotion.x_root; + x.u.keyButtonPointer.rootY = X.xmotion.y_root; + } + else + { + x.u.keyButtonPointer.rootX = X.xmotion.x - nxagentOption(RootX); + x.u.keyButtonPointer.rootY = X.xmotion.y - nxagentOption(RootY); + } + + mieqEnqueue(&x); + + CriticalOutputPending = 1; + } + + if (nxagentOption(ViewOnly) == 0 && nxagentOption(Shadow)) + { + X.xbutton.x -= nxagentOption(RootX); + X.xbutton.y -= nxagentOption(RootY); + + if (nxagentOption(XRatio) != DONT_SCALE) + { + X.xbutton.x = (X.xbutton.x << PRECISION) / nxagentOption(XRatio); + } + + if (nxagentOption(YRatio) != DONT_SCALE) + { + X.xbutton.y = (X.xbutton.y << PRECISION) / nxagentOption(YRatio); + } + + NXShadowEvent(nxagentDisplay, X); + } + + break; + } + case MotionNotify: + { + ScreenPtr pScreen = nxagentScreen(X.xmotion.window); + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new MotionNotify event.\n"); + #endif + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Handling motion notify window [%ld] root [%ld] child [%ld].\n", + X.xmotion.window, X.xmotion.root, X.xmotion.subwindow); + + fprintf(stderr, "nxagentDispatchEvents: Pointer at [%d][%d] relative root [%d][%d].\n", + X.xmotion.x, X.xmotion.y, X.xmotion.x_root, X.xmotion.y_root); + #endif + + x.u.u.type = MotionNotify; + + if (nxagentOption(Rootless)) + { + WindowPtr pWin = nxagentWindowPtr(X.xmotion.window); + + if (pWin) + { + nxagentLastEnteredWindow = pWin; + } + + if (nxagentPulldownDialogPid == 0 && (X.xmotion.y_root < + nxagentLastEnteredTopLevelWindow -> drawable.y + 4)) + { + if (pWin && nxagentLastEnteredTopLevelWindow && + nxagentClientIsDialog(wClient(pWin)) == 0 && + nxagentLastEnteredTopLevelWindow -> parent == WindowTable[0] && + nxagentLastEnteredTopLevelWindow -> overrideRedirect == False && + X.xmotion.x_root > (nxagentLastEnteredTopLevelWindow -> drawable.x + + (nxagentLastEnteredTopLevelWindow -> drawable.width >> 1) - 50) && + X.xmotion.x_root < (nxagentLastEnteredTopLevelWindow -> drawable.x + + (nxagentLastEnteredTopLevelWindow -> drawable.width >> 1) + 50) && + nxagentOption(Menu) == 1) + { + nxagentPulldownDialog(nxagentLastEnteredTopLevelWindow -> drawable.id); + } + } + + x.u.keyButtonPointer.rootX = X.xmotion.x_root; + x.u.keyButtonPointer.rootY = X.xmotion.y_root; + } + else + { + x.u.keyButtonPointer.rootX = X.xmotion.x - nxagentOption(RootX); + x.u.keyButtonPointer.rootY = X.xmotion.y - nxagentOption(RootY); + } + + x.u.keyButtonPointer.time = nxagentLastEventTime = GetTimeInMillis(); + + if (viewportCursor == None && + !(nxagentOption(Fullscreen) && + X.xmotion.window == nxagentDefaultWindows[pScreen -> myNum] + && X.xmotion.subwindow == None)) + { + mieqEnqueue(&x); + } + + /* + * This test is more complicated and probably not necessary, compared + * to a simple check on viewportCursor. + * + * if (!nxagentOption(Fullscreen) && + * (X.xmotion.state & (ControlMask | Mod1Mask | Button1Mask)) == + * (ControlMask | Mod1Mask | Button1Mask)) + */ + + if (viewportCursor) + { + /* + * Pointer is in viewport navigation mode. + */ + + nxagentMoveViewport(pScreen, viewportLastX - X.xmotion.x, viewportLastY - X.xmotion.y); + + viewportLastX = X.xmotion.x; + viewportLastY = X.xmotion.y; + } + + if (nxagentOption(ViewOnly) == 0 && nxagentOption(Shadow) && !viewportCursor) + { + X.xmotion.x -= nxagentOption(RootX); + X.xmotion.y -= nxagentOption(RootY); + + if (nxagentOption(XRatio) != DONT_SCALE) + { + X.xmotion.x = (X.xmotion.x << PRECISION) / nxagentOption(XRatio); + } + + if (nxagentOption(YRatio) != DONT_SCALE) + { + X.xmotion.y = (X.xmotion.y << PRECISION) / nxagentOption(YRatio); + } + + NXShadowEvent(nxagentDisplay, X); + } + + if (nxagentOption(Shadow) == 0) + { + nxagentInputEvent = 1; + } + + break; + } + case FocusIn: + { + WindowPtr pWin; + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new FocusIn event.\n"); + #endif + + /* + * Here we change the focus state in the agent. + * It looks like this is needed only for root- + * less mode at the present moment. + */ + + if (nxagentOption(Rootless) && + (pWin = nxagentWindowPtr(X.xfocus.window))) + { + SetInputFocus(serverClient, inputInfo.keyboard, pWin -> drawable.id, + RevertToPointerRoot, GetTimeInMillis(), False); + } + + if (X.xfocus.detail != NotifyInferior) + { + pScreen = nxagentScreen(X.xfocus.window); + + if (pScreen) + { + nxagentDirectInstallColormaps(pScreen); + } + } + + break; + } + case FocusOut: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new FocusOut event.\n"); + #endif + + if (X.xfocus.detail != NotifyInferior) + { + pScreen = nxagentScreen(X.xfocus.window); + + if (pScreen) + { + nxagentDirectUninstallColormaps(pScreen); + } + } + + #ifdef NXAGENT_FIXKEYS + + { + /* + * Force the keys all up when focus is lost. + */ + + int i, k; + int mask = 1; + CARD8 val; + + XEvent xM; + memset(&xM, 0, sizeof(XEvent)); + + for (i = 0; i < DOWN_LENGTH; i++) /* input.h */ + { + val = inputInfo.keyboard->key->down[i]; + + if (val != 0) + { + for (k = 0; k < 8; k++) + { + if (val & (mask << k)) + { + #ifdef NXAGENT_FIXKEYS_DEBUG + fprintf(stderr, "sending KeyRelease event for keycode: %x\n", + i * 8 + k); + #endif + + if (!nxagentOption(Rootless) || + inputInfo.keyboard->key->modifierMap[i * 8 + k]) + { + x.u.u.type = KeyRelease; + x.u.u.detail = i * 8 + k; + x.u.keyButtonPointer.time = nxagentLastEventTime = GetTimeInMillis(); + + if (nxagentOption(ViewOnly) == 0 && nxagentOption(Shadow)) + { + xM.type = KeyRelease; + xM.xkey.display = nxagentDisplay; + xM.xkey.type = KeyRelease; + xM.xkey.keycode = i * 8 + k; + xM.xkey.state = inputInfo.keyboard->key->state; + xM.xkey.time = GetTimeInMillis(); + NXShadowEvent(nxagentDisplay, xM); + } + + mieqEnqueue(&x); + } + } + } + } + } + + nxagentKeyDown = 0; + } + + #endif /* NXAGENT_FIXKEYS */ + + break; + } + case KeymapNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new KeymapNotify event.\n"); + #endif + + break; + } + case EnterNotify: + { + WindowPtr pWin; + + WindowPtr pTLWin = NULL; + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new EnterNotify event.\n"); + #endif + + if (nxagentOption(Rootless)) + { + pWin = nxagentWindowPtr(X.xcrossing.window); + + if (pWin != NULL) + { + for (pTLWin = pWin; + pTLWin -> parent != WindowTable[pTLWin -> drawable.pScreen -> myNum]; + pTLWin = pTLWin -> parent); + } + + if (pTLWin) + { + nxagentLastEnteredTopLevelWindow = pTLWin; + } + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: nxagentLastEnteredTopLevelWindow [%p].\n", + nxagentLastEnteredTopLevelWindow); + #endif + } + + if (nxagentOption(Rootless) && nxagentWMIsRunning && + (pWin = nxagentWindowPtr(X.xcrossing.window)) && + nxagentWindowTopLevel(pWin) && !pWin -> overrideRedirect && + (pWin -> drawable.x != X.xcrossing.x_root - X.xcrossing.x - pWin -> borderWidth || + pWin -> drawable.y != X.xcrossing.y_root - X.xcrossing.y - pWin -> borderWidth)) + { + /* + * This code is useful for finding the window + * position. It should be re-implemented by + * following the ICCCM 4.1.5 recommendations. + */ + + XID values[4]; + register XID *value = values; + Mask mask = 0; + ClientPtr pClient = wClient(pWin); + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: pWin -> drawable.x [%d] pWin -> drawable.y [%d].\n", + pWin -> drawable.x, pWin -> drawable.y); + #endif + + *value++ = (XID) (X.xcrossing.x_root - X.xcrossing.x - pWin -> borderWidth); + *value++ = (XID) (X.xcrossing.y_root - X.xcrossing.y - pWin -> borderWidth); + + /* + * nxagentWindowPriv(pWin)->x = (X.xcrossing.x_root - X.xcrossing.x); + * nxagentWindowPriv(pWin)->y = (X.xcrossing.y_root - X.xcrossing.y); + */ + + mask = CWX | CWY; + + nxagentScreenTrap = 1; + + ConfigureWindow(pWin, mask, (XID *) values, pClient); + + nxagentScreenTrap = 0; + } + + if (nxagentOption(Fullscreen)) + { + if (X.xcrossing.window == nxagentFullscreenWindow && + X.xcrossing.detail != NotifyInferior) + { + nxagentGrabPointerAndKeyboard(&X); + } + } + + if (X.xcrossing.detail != NotifyInferior) + { + pScreen = nxagentScreen(X.xcrossing.window); + + if (pScreen) + { + NewCurrentScreen(pScreen, X.xcrossing.x, X.xcrossing.y); + + x.u.u.type = MotionNotify; + + if (nxagentOption(Rootless)) + { + nxagentLastEnteredWindow = nxagentWindowPtr(X.xcrossing.window); + x.u.keyButtonPointer.rootX = X.xcrossing.x_root; + x.u.keyButtonPointer.rootY = X.xcrossing.y_root; + } + else + { + x.u.keyButtonPointer.rootX = X.xcrossing.x - nxagentOption(RootX); + x.u.keyButtonPointer.rootY = X.xcrossing.y - nxagentOption(RootY); + } + + x.u.keyButtonPointer.time = nxagentLastEventTime = GetTimeInMillis(); + + mieqEnqueue(&x); + + nxagentDirectInstallColormaps(pScreen); + } + } + + nxagentInputEvent = 1; + + break; + } + case LeaveNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new LeaveNotify event.\n"); + #endif + + if (nxagentOption(Rootless) && X.xcrossing.mode == NotifyNormal && + X.xcrossing.detail != NotifyInferior) + { + nxagentLastEnteredWindow = NULL; + } + + if (nxagentOption(Fullscreen)) + { + if (X.xcrossing.window == nxagentFullscreenWindow && + X.xcrossing.detail != NotifyInferior && + X.xcrossing.mode == NotifyNormal) + { + nxagentUngrabPointerAndKeyboard(&X); + + pScreen = nxagentScreen(X.xcrossing.window); + + minimize = True; + } + } + + if (X.xcrossing.detail != NotifyInferior) + { + pScreen = nxagentScreen(X.xcrossing.window); + + if (pScreen) + { + nxagentDirectUninstallColormaps(pScreen); + } + } + + nxagentInputEvent = 1; + + break; + } + case DestroyNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new DestroyNotify event.\n"); + #endif + + if (nxagentParentWindow != (Window) 0 && + X.xdestroywindow.window == nxagentParentWindow) + { + fprintf(stderr, "Warning: Unhandled destroy notify event received in agent.\n"); + } + + break; + } + case ClientMessage: + { + enum HandleEventResult result; + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new ClientMessage event.\n"); + #endif + + nxagentHandleClientMessageEvent(&X, &result); + + if (result == doCloseSession) + { + closeSession = TRUE; + } + + break; + } + case VisibilityNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new VisibilityNotify event.\n"); + #endif + + if (X.xvisibility.window != nxagentDefaultWindows[0]) + { + Window window = X.xvisibility.window; + + WindowPtr pWin = nxagentWindowPtr(window); + + if (pWin && nxagentWindowPriv(pWin)) + { + if (nxagentWindowPriv(pWin) -> visibilityState != X.xvisibility.state) + { + int value = X.xvisibility.state; + + if (nxagentOption(Rootless) == 1) + { + TraverseTree(pWin, nxagentChangeVisibilityPrivate, &value); + } + else + { + nxagentChangeVisibilityPrivate(pWin, &value); + } + } + } + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Suppressing visibility notify on window [%lx].\n", + X.xvisibility.window); + #endif + + break; + } + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Visibility notify state is [%d] with previous [%d].\n", + X.xvisibility.state, nxagentVisibility); + #endif + + nxagentVisibility = X.xvisibility.state; + + break; + } + case Expose: + { + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: Going to handle new Expose event.\n"); + #endif + + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: WARNING! Received Expose event " + "for drawable [%lx] geometry [%d, %d, %d, %d] count [%d].\n", + X.xexpose.window, X.xexpose.x, X.xexpose.y, X.xexpose.width, + X.xexpose.height, X.xexpose.count); + #endif + + nxagentHandleExposeEvent(&X); + + break; + } + case GraphicsExpose: + { + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: Going to handle new GraphicsExpose event.\n"); + #endif + + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: WARNING! Received GraphicsExpose event " + "for drawable [%lx] geometry [%d, %d, %d, %d] count [%d].\n", + X.xgraphicsexpose.drawable, X.xgraphicsexpose.x, X.xgraphicsexpose.y, + X.xgraphicsexpose.width, X.xgraphicsexpose.height, + X.xgraphicsexpose.count); + #endif + + nxagentHandleGraphicsExposeEvent(&X); + + break; + } + case NoExpose: + { + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: Going to handle new NoExpose event.\n"); + #endif + + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: WARNING! Received NoExpose event for " + "drawable [%lx].\n", X.xnoexpose.drawable); + #endif + + break; + } + case CirculateNotify: + { + /* + * WindowPtr pWin; + * WindowPtr pSib; + * ClientPtr pClient; + + * XID values[2]; + * register XID *value = values; + * Mask mask = 0; + */ + + #ifdef WARNING + fprintf(stderr, "nxagentDispatchEvents: Going to handle new CirculateNotify event.\n"); + #endif + + /* + * FIXME: Do we need this? + * + * pWin = nxagentWindowPtr(X.xcirculate.window); + * + * if (!pWin) + * { + * pWin = nxagentRootlessTopLevelWindow(X.xcirculate.window); + * } + * + * if (!pWin) + * { + * break; + * } + * + * XQueryTree(nxagentDisplay, DefaultRootWindow(nxagentDisplay), + * &root_return, &parent_return, &children_return, &nchildren_return); + * + * nxagentRootlessRestack(children_return, nchildren_return); + */ + + break; + } + case ConfigureNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new ConfigureNotify event.\n"); + #endif + + if (nxagentConfiguredSynchroWindow == X.xconfigure.window) + { + if (nxagentExposeQueue.exposures[nxagentExposeQueue.start].serial != X.xconfigure.x) + { + #ifdef WARNING + fprintf(stderr, "nxagentDispatchEvents: Requested ConfigureNotify changes didn't take place.\n"); + #endif + } + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Received ConfigureNotify and going to call " + "nxagentSynchronizeExpose.\n"); + #endif + + nxagentSynchronizeExpose(); + + break; + } + + nxagentHandleConfigureNotify(&X); + + break; + } + case GravityNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new GravityNotify event.\n"); + #endif + + break; + } + case ReparentNotify: + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new ReparentNotify event.\n"); + #endif + + nxagentHandleReparentNotify(&X); + + break; + } + case UnmapNotify: + { + WindowPtr pWin; + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new UnmapNotify event.\n"); + #endif + + if (nxagentOption(Rootless) == 1) + { + if ((pWin = nxagentRootlessTopLevelWindow(X.xunmap.window)) != NULL || + ((pWin = nxagentWindowPtr(X.xunmap.window)) != NULL && + nxagentWindowTopLevel(pWin) == 1)) + { + nxagentScreenTrap = 1; + + UnmapWindow(pWin, False); + + nxagentScreenTrap = 0; + } + } + + if (nxagentUseNXTrans == 1 && nxagentOption(Rootless) == 0 && + nxagentOption(Nested) == 0 && X.xmap.window != nxagentIconWindow) + { + nxagentVisibility = VisibilityFullyObscured; + } + + break; + } + case MapNotify: + { + WindowPtr pWin; + ClientPtr pClient; + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Going to handle new MapNotify event.\n"); + #endif + + if (nxagentOption(Rootless) == 1) + { + Bool value = 1; + + if ((pWin = nxagentRootlessTopLevelWindow(X.xmap.window)) != NULL || + ((pWin = nxagentWindowPtr(X.xmap.window)) != NULL && + nxagentWindowTopLevel(pWin) == 1)) + { + pClient = wClient(pWin); + + nxagentScreenTrap = 1; + + MapWindow(pWin, pClient); + + nxagentScreenTrap = 0; + } + + if (pWin != NULL) + { + TraverseTree(pWin, nxagentChangeMapPrivate, &value); + } + } + + if (nxagentOption(Fullscreen) == 1) + { + if (X.xmap.window == nxagentIconWindow) + { + pScreen = nxagentScreen(X.xmap.window); + nxagentMaximizeToFullScreen(pScreen); + } + + nxagentVisibility = VisibilityUnobscured; + nxagentVisibilityStop = False; + nxagentVisibilityTimeout = GetTimeInMillis() + 2000; + } + + break; + } + case MappingNotify: + { + #ifdef DEBUG + fprintf(stderr, "nxagentDispatchEvents: WARNING! Going to handle new MappingNotify event.\n"); + #endif + + break; + } + default: + { + /* + * Let's check if this is a XKB + * state modification event. + */ + + if (nxagentHandleKeyboardEvent(&X) == 0) + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: WARNING! Unhandled event code [%d].\n", + X.type); + #endif + } + + break; + } + + } /* End of switch (X.type) */ + + } /* End of while (...) */ + + /* + * Send the exposed regions to the clients. + */ + + nxagentForwardRemoteExpose(); + + /* + * Handle the agent window's changes. + */ + + if (closeSession) + { + if (nxagentOption(Persistent)) + { + if (nxagentNoDialogIsRunning) + { + nxagentLaunchDialog(DIALOG_SUSPEND_SESSION); + } + } + else + { + if (nxagentNoDialogIsRunning) + { + nxagentLaunchDialog(DIALOG_KILL_SESSION); + } + } + } + + if (minimize) + { + nxagentWMDetect(); + + if (nxagentWMIsRunning) + { + if (nxagentOption(Fullscreen)) + { + nxagentMinimizeFromFullScreen(pScreen); + } + else + { + XIconifyWindow(nxagentDisplay, nxagentDefaultWindows[0], DefaultScreen(nxagentDisplay)); + } + } + } + + if (switchFullscreen) + { + nxagentSwitchFullscreen(pScreen, !nxagentOption(Fullscreen)); + } + + if (startKbd) + { + if (xkbdRunning) + { + #ifdef NXAGENT_XKBD_DEBUG + fprintf(stderr, "Events: nxkbd now is NOT running: %d, %d\n", + X.xkey.keycode, escapecode); + #endif + + xkbdRunning = False; + + kill(pidkbd, 9); + } + else + { + char kbddisplay[6]; + char *kbdargs[6]; + + strcpy(kbddisplay,":"); + strncat(kbddisplay, display, 4); + + kbdargs[0] = "nxkbd"; + kbdargs[1] = "-geometry"; + kbdargs[2] = "240x70+0+250"; + kbdargs[3] = "-display"; + kbdargs[4] = kbddisplay; + kbdargs[5] = NULL; + + switch (pidkbd = fork()) + { + case 0: + { + execvp(kbdargs[0], kbdargs); + + #ifdef NXAGENT_XKBD_DEBUG + fprintf(stderr, "Events: The execvp of nxkbd process failed.\n"); + #endif + + exit(1); + + break; + } + case -1: + { + #ifdef NXAGENT_XKBD_DEBUG + fprintf(stderr, "Events: Can't fork to run the nxkbd process.\n"); + #endif + + break; + } + default: + { + break; + } + } + + #ifdef NXAGENT_XKBD_DEBUG + fprintf(stderr, "Events: The nxkbd process now running with [%d][%d].\n", + X.xkey.keycode, escapecode); + #endif + + xkbdRunning = True; + } + } + + #ifdef BLOCKS + fprintf(stderr, "[End read]\n"); + #endif + + /* + * Let the underlying X server code + * process the input events. + */ + + #ifdef BLOCKS + fprintf(stderr, "[Begin events]\n"); + #endif + + ProcessInputEvents(); + + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Output pending flag is [%d] critical [%d].\n", + NewOutputPending, CriticalOutputPending); + #endif + + /* + * Write the events to our clients. We may + * flush only in the case of critical output + * but this doesn't seem beneficial. + * + * if (CriticalOutputPending == 1) + * { + * FlushAllOutput(); + * } + */ + + if (NewOutputPending == 1) + { + #ifdef TEST + fprintf(stderr, "nxagentDispatchEvents: Flushed the processed events to clients.\n"); + #endif + + FlushAllOutput(); + } + + #ifdef TEST + + if (nxagentPendingEvents(nxagentDisplay) > 0) + { + fprintf(stderr, "nxagentDispatchEvents: WARNING! More events need to be dispatched.\n"); + } + + #endif + + #ifdef BLOCKS + fprintf(stderr, "[End events]\n"); + #endif +} + +/* + * Functions providing the ad-hoc handling + * of the remote X events. + */ + +int nxagentHandleKeyPress(XEvent *X, enum HandleEventResult *result) +{ + xEvent x; + + if (nxagentXkbState.Initialized == 0) + { + nxagentInitKeyboardState(); + } + + if (nxagentCheckSpecialKeystroke(&X -> xkey, result)) + { + return 1; + } + + nxagentLastEventTime = nxagentLastKeyPressTime = GetTimeInMillis(); + + x.u.u.type = KeyPress; + x.u.u.detail = X -> xkey.keycode; + x.u.keyButtonPointer.time = nxagentLastKeyPressTime; + + nxagentLastServerTime = X -> xkey.time; + + mieqEnqueue(&x); + + CriticalOutputPending = 1; + + return 1; +} + +int nxagentHandlePropertyNotify(XEvent *X) +{ + int resource; + + if (nxagentOption(Rootless) && !nxagentNotifyMatchChangeProperty((XPropertyEvent *) X)) + { + #ifdef TEST + fprintf(stderr, "nxagentHandlePropertyNotify: Property %ld on window %lx.\n", + X -> xproperty.atom, X -> xproperty.window); + #endif + + if (nxagentWindowPtr(X -> xproperty.window) != NULL) + { + resource = NXGetCollectPropertyResource(nxagentDisplay); + + if (resource == -1) + { + #ifdef WARNING + fprintf(stderr, "nxagentHandlePropertyNotify: WARNING! Asyncronous get property queue is full.\n"); + #endif + + return 0; + } + + NXCollectProperty(nxagentDisplay, resource, + X -> xproperty.window, X -> xproperty.atom, 0, + MAX_RETRIEVED_PROPERTY_SIZE, False, AnyPropertyType); + + nxagentPropertyRequests[resource].window = X -> xproperty.window; + nxagentPropertyRequests[resource].property = X -> xproperty.atom; + } + #ifdef TEST + else + { + fprintf(stderr, "nxagentHandlePropertyNotify: Failed to look up remote window property.\n"); + } + #endif + } + + return 1; +} + +int nxagentHandleExposeEvent(XEvent *X) +{ + WindowPtr pWin = NULL; + Window window = None; + + RegionRec sum; + RegionRec add; + BoxRec box; + int index = 0; + int overlap = 0; + + #ifdef DEBUG + fprintf(stderr, "nxagentHandleExposeEvent: Checking remote expose events.\n"); + #endif + + #ifdef DEBUG + fprintf(stderr, "nxagentHandleExposeEvent: Looking for window id [%ld].\n", + X -> xexpose.window); + #endif + + window = X -> xexpose.window; + + pWin = nxagentWindowPtr(window); + + if (pWin != NULL) + { + REGION_INIT(pWin -> drawable.pScreen, &sum, (BoxRec *) NULL, 1); +/* +FIXME: This can be maybe optimized by consuming the + events that do not match the predicate. +*/ + do + { + #ifdef DEBUG + fprintf(stderr, "nxagentHandleExposeEvent: Adding event for window id [%ld].\n", + X -> xexpose.window); + #endif + + box.x1 = pWin -> drawable.x + wBorderWidth(pWin) + X -> xexpose.x; + box.y1 = pWin -> drawable.y + wBorderWidth(pWin) + X -> xexpose.y; + + box.x2 = box.x1 + X -> xexpose.width; + box.y2 = box.y1 + X -> xexpose.height; + + REGION_INIT(pWin -> drawable.pScreen, &add, &box, 1); + + REGION_APPEND(pWin -> drawable.pScreen, &sum, &add); + + REGION_UNINIT(pWin -> drawable.pScreen, &add); + + if (X -> xexpose.count == 0) + { + break; + } + } + while (nxagentCheckEvents(nxagentDisplay, X, nxagentExposurePredicate, + (XPointer) &window) == 1); + + REGION_VALIDATE(pWin -> drawable.pScreen, &sum, &overlap); + + REGION_INTERSECT(pWin->drawable.pScreen, &sum, &sum, + &WindowTable[pWin->drawable.pScreen->myNum]->winSize); + + #ifdef DEBUG + fprintf(stderr, "nxagentHandleExposeEvent: Sending events for window id [%ld].\n", + X -> xexpose.window); + #endif + + /* + * If the agent has already sent auto-generated expose, + * save received exposes for later processing. + */ + + index = nxagentLookupByWindow(pWin); + + if (index == -1) + { + miWindowExposures(pWin, &sum, NullRegion); + } + else + { + REGION_TRANSLATE(pWin -> drawable.pScreen, &sum, -pWin -> drawable.x, -pWin -> drawable.y); + + if (nxagentExposeQueue.exposures[index].remoteRegion == NullRegion) + { + nxagentExposeQueue.exposures[index].remoteRegion = REGION_CREATE(pwin -> drawable.pScreen, NULL, 1); + } + + REGION_UNION(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[index].remoteRegion, + nxagentExposeQueue.exposures[index].remoteRegion, &sum); + + #ifdef TEST + fprintf(stderr, "nxagentHandleExposeEvent: Added region for window [%ld] to position [%d].\n", + nxagentWindow(pWin), index); + #endif + + if (X -> xexpose.count == 0) + { + nxagentExposeQueue.exposures[index].remoteRegionIsCompleted = True; + } + else + { + nxagentExposeQueue.exposures[index].remoteRegionIsCompleted = False; + } + } + + if (nxagentRootTileWindow != NULL) + { + if (nxagentWindowPriv(nxagentRootTileWindow) -> window == nxagentWindowPriv(pWin) -> window && + nxagentSplashCount == 1 && X -> xexpose.count == 0) + { + #ifdef DEBUG + fprintf(stderr, "nxagentHandleExposeEvent: Clearing root tile window id [%ld].\n", + nxagentWindowPriv(nxagentRootTileWindow) -> window); + #endif + + XClearWindow(nxagentDisplay, nxagentWindowPriv(nxagentRootTileWindow) -> window); + } + } + + REGION_UNINIT(pWin -> drawable.pScreen, &sum); + } + + return 1; +} + +int nxagentHandleGraphicsExposeEvent(XEvent *X) +{ + /* + * Send an expose event to client, instead of graphics + * expose. If target drawable is a backing pixmap, send + * expose event for the saved window, else do nothing. + */ + + RegionPtr exposeRegion; + BoxRec rect; + WindowPtr pWin; + ScreenPtr pScreen; + StoringPixmapPtr pStoringPixmapRec = NULL; + miBSWindowPtr pBSwindow = NULL; + int drawableType; + + pWin = nxagentWindowPtr(X -> xgraphicsexpose.drawable); + + if (pWin != NULL) + { + drawableType = DRAWABLE_WINDOW; + } + else + { + drawableType = DRAWABLE_PIXMAP; + } + + if (drawableType == DRAWABLE_PIXMAP) + { + pStoringPixmapRec = nxagentFindItemBSPixmapList(X -> xgraphicsexpose.drawable); + + if (pStoringPixmapRec == NULL) + { + #ifdef TEST + fprintf(stderr, "nxagentHandleGraphicsExposeEvent: WARNING! Storing pixmap not found.\n"); + #endif + + return 1; + } + + pBSwindow = (miBSWindowPtr) pStoringPixmapRec -> pSavedWindow -> backStorage; + + if (pBSwindow == NULL) + { + #ifdef TEST + fprintf(stderr, "nxagentHandleGraphicsExposeEvent: WARNING! Back storage not found.\n"); + #endif + + return 1; + } + + pWin = pStoringPixmapRec -> pSavedWindow; + } + + pScreen = pWin -> drawable.pScreen; + + /* + * Rectangle affected by GraphicsExpose + * event. + */ + + rect.x1 = X -> xgraphicsexpose.x; + rect.y1 = X -> xgraphicsexpose.y; + rect.x2 = rect.x1 + X -> xgraphicsexpose.width; + rect.y2 = rect.y1 + X -> xgraphicsexpose.height; + + exposeRegion = REGION_CREATE(pScreen, &rect, 0); + + if (drawableType == DRAWABLE_PIXMAP) + { + #ifdef TEST + fprintf(stderr, "nxagentHandleGraphicsExposeEvent: Handling GraphicsExpose event on pixmap with id" + " [%lu].\n", X -> xgraphicsexpose.drawable); + #endif + + /* + * The exposeRegion coordinates are relative + * to the pixmap to which GraphicsExpose + * event refers. But the BS coordinates of + * the savedRegion are relative to the + * window. + */ + + REGION_TRANSLATE(pScreen, exposeRegion, pStoringPixmapRec -> backingStoreX, + pStoringPixmapRec -> backingStoreY); + + /* + * We remove from SavedRegion the part + * affected by the GraphicsExpose event. + */ + + REGION_SUBTRACT(pScreen, &(pBSwindow -> SavedRegion), &(pBSwindow -> SavedRegion), + exposeRegion); + } + + /* + * Store the exposeRegion in order to send + * the expose event later. The coordinates + * must be relative to the screen. + */ + + REGION_TRANSLATE(pScreen, exposeRegion, pWin -> drawable.x, pWin -> drawable.y); + + REGION_UNION(pScreen, nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, exposeRegion); + + REGION_DESTROY(pScreen, exposeRegion); + + return 1; +} + +int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result) +{ + ScreenPtr pScreen; + WindowPtr pWin; + xEvent x; + + *result = doNothing; + + #ifdef TEST + fprintf(stderr, "nxagentHandleClientMessageEvent: ClientMessage event window [%ld] with " + "type [%ld] format [%d].\n", X -> xclient.window, X -> xclient.message_type, + X -> xclient.format); + #endif + + /* + * If window is 0, message_type is 0 and format is + * 32 then we assume event is coming from proxy. + */ + + if (X -> xclient.window == 0 && + X -> xclient.message_type == 0 && + X -> xclient.format == 32) + { + nxagentHandleProxyEvent(X); + + return 1; + } + + if (nxagentOption(Rootless)) + { + Atom message_type = nxagentRemoteToLocalAtom(X -> xclient.message_type); + + if (!ValidAtom(message_type)) + { + #ifdef WARNING + fprintf(stderr, "nxagentHandleClientMessageEvent: WARNING Invalid type in client message.\n"); + #endif + + return 0; + } + + pWin = nxagentWindowPtr(X -> xclient.window); + + if (pWin == NULL) + { + #ifdef WARNING + fprintf(stderr, "WARNING: Invalid window in ClientMessage.\n"); + #endif + + return 0; + } + + if (message_type == MakeAtom("WM_PROTOCOLS", strlen("WM_PROTOCOLS"), False)) + { + char *message_data; + + x.u.u.type = ClientMessage; + x.u.u.detail = X -> xclient.format; + + x.u.clientMessage.window = pWin -> drawable.id; + x.u.clientMessage.u.l.type = message_type; + x.u.clientMessage.u.l.longs0 = nxagentRemoteToLocalAtom(X -> xclient.data.l[0]); + x.u.clientMessage.u.l.longs1 = GetTimeInMillis(); + + if (!ValidAtom(x.u.clientMessage.u.l.longs0)) + { + #ifdef WARNING + fprintf(stderr, "nxagentHandleClientMessageEvent: WARNING Invalid value in client message " + "of type WM_PROTOCOLS.\n"); + #endif + + return 0; + } + else + { + message_data = validateString(NameForAtom(x.u.clientMessage.u.l.longs0)); + } + + #ifdef TEST + fprintf(stderr, "nxagentHandleClientMessageEvent: Sent client message of type WM_PROTOCOLS " + "and value [%s].\n", message_data); + #endif + + TryClientEvents(wClient(pWin), &x, 1, 1, 1, 0); + } + else + { + #ifdef WARNING + fprintf(stderr, "nxagentHandleClientMessageEvent: Ignored message type %ld [%s].\n", + (long int) message_type, validateString(NameForAtom(message_type))); + #endif + + return 0; + } + + return 1; + } + + if (X -> xclient.message_type == nxagentAtoms[1]) /* WM_PROTOCOLS */ + { + Atom deleteWMatom, wmAtom; + + wmAtom = (Atom) X -> xclient.data.l[0]; + + deleteWMatom = nxagentAtoms[2]; /* WM_DELETE_WINDOW */ + + if (wmAtom == deleteWMatom) + { + if (nxagentOnce && (nxagentClients == 0)) + { + GiveUp(0); + } + else + { + #ifdef TEST + fprintf(stderr, "Events: WM_DELETE_WINDOW arrived Atom = %ld.\n", wmAtom); + #endif + + if (X -> xclient.window == nxagentIconWindow) + { + pScreen = nxagentScreen(X -> xmap.window); + + nxagentMaximizeToFullScreen(pScreen); + } + + if (X -> xclient.window == (nxagentOption(Fullscreen) ? + nxagentIconWindow : nxagentDefaultWindows[0])) + { + *result = doCloseSession; + } + } + } + } + + return 1; +} + +int nxagentHandleKeyboardEvent(XEvent *X) +{ + XkbEvent *xkbev = (XkbEvent *) X; + + #ifdef TEST + fprintf(stderr, "nxagentHandleKeyboardEvent: Handling event with caps [%d] num [%d] locked [%d].\n", + nxagentXkbState.Caps, nxagentXkbState.Num, nxagentXkbState.Locked); + #endif + + if (xkbev -> type == nxagentXkbInfo.EventBase + XkbEventCode && + xkbev -> any.xkb_type == XkbStateNotify) + { + nxagentXkbState.Locked = xkbev -> state.locked_mods; + + #ifdef TEST + fprintf(stderr, "nxagentHandleKeyboardEvent: Updated XKB locked modifier bits to [%x].\n", + nxagentXkbState.Locked); + #endif + + nxagentXkbState.Initialized = 1; + + if (nxagentXkbState.Caps == 0 && + (nxagentXkbState.Locked & CAPSFLAG_IN_EVENT)) + { + nxagentXkbState.Caps = 1; + + #ifdef TEST + fprintf(stderr, "nxagentHandleKeyboardEvent: Sending fake key [66] to engage capslock.\n"); + #endif + + nxagentSendFakeKey(66); + } + + if (nxagentXkbState.Caps == 1 && + !(nxagentXkbState.Locked & CAPSFLAG_IN_EVENT)) + { + nxagentXkbState.Caps = 0; + + #ifdef TEST + fprintf(stderr, "nxagentHandleKeyboardEvent: Sending fake key [66] to release capslock.\n"); + #endif + + nxagentSendFakeKey(66); + } + + if (nxagentXkbState.Num == 0 && + (nxagentXkbState.Locked & NUMFLAG_IN_EVENT)) + { + nxagentXkbState.Num = 1; + + #ifdef TEST + fprintf(stderr, "nxagentHandleKeyboardEvent: Sending fake key [77] to engage numlock.\n"); + #endif + + nxagentSendFakeKey(77); + } + + if (nxagentXkbState.Num == 1 && + !(nxagentXkbState.Locked & NUMFLAG_IN_EVENT)) + { + nxagentXkbState.Num = 0; + + #ifdef TEST + fprintf(stderr, "nxagentHandleKeyboardEvent: Sending fake key [77] to release numlock.\n"); + #endif + + nxagentSendFakeKey(77); + } + + return 1; + } + + return 0; +} + +int nxagentHandleProxyEvent(XEvent *X) +{ + switch (X -> xclient.data.l[0]) + { + case NXNoSplitNotify: + case NXStartSplitNotify: + { + /* + * We should never receive such events + * in the event loop, as they should + * be caught at the time the split is + * initiated. + */ + + #ifdef PANIC + + int client = (int) X -> xclient.data.l[1]; + + if (X -> xclient.data.l[0] == NXNoSplitNotify) + { + fprintf(stderr, "nxagentHandleProxyEvent: PANIC! NXNoSplitNotify received " + "with client [%d].\n", client); + } + else + { + fprintf(stderr, "nxagentHandleProxyEvent: PANIC! NXStartSplitNotify received " + "with client [%d].\n", client); + } + + #endif + + return 1; + } + case NXCommitSplitNotify: + { + /* + * We need to commit an image. Image can be the + * result of a PutSubImage() generated by Xlib, + * so there can be more than a single image to + * commit, even if only one PutImage was perfor- + * med by the agent. + */ + + int client = (int) X -> xclient.data.l[1]; + int request = (int) X -> xclient.data.l[2]; + int position = (int) X -> xclient.data.l[3]; + + #ifdef TEST + fprintf(stderr, "nxagentHandleProxyEvent: NXCommitSplitNotify received with " + "client [%d] request [%d] and position [%d].\n", + client, request, position); + #endif + + nxagentHandleCommitSplitEvent(client, request, position); + + return 1; + } + case NXEndSplitNotify: + { + /* + * All images for the split were transferred and + * we need to restart the client. + */ + + int client = (int) X -> xclient.data.l[1]; + + #ifdef TEST + fprintf(stderr, "nxagentHandleProxyEvent: NXEndSplitNotify received with " + "client [%d].\n", client); + #endif + + nxagentHandleEndSplitEvent(client); + + return 1; + } + case NXEmptySplitNotify: + { + /* + * All splits have been completed and none remain. + */ + + #ifdef TEST + fprintf(stderr, "nxagentHandleProxyEvent: NXEmptySplitNotify received.\n"); + #endif + + nxagentHandleEmptySplitEvent(); + + return 1; + } + case NXCollectPropertyNotify: + { + #ifdef TEST + int resource = (int) X -> xclient.data.l[1]; + + fprintf(stderr, "nxagentHandleProxyEvent: NXCollectPropertyNotify received with resource [%d].\n", + resource); + #endif + + nxagentHandleCollectPropertyEvent(X); + + return 1; + } + case NXCollectGrabPointerNotify: + { + int resource = (int) X -> xclient.data.l[1]; + + #ifdef TEST + fprintf(stderr, "nxagentHandleProxyEvent: NXCollectGrabPointerNotify received with resource [%d].\n", + resource); + #endif + + nxagentHandleCollectGrabPointerEvent(resource); + + return 1; + } + case NXCollectInputFocusNotify: + { + int resource = (int) X -> xclient.data.l[1]; + + /* + * This is not used at the present moment. + */ + + #ifdef TEST + fprintf(stderr, "nxagentHandleProxyEvent: NXCollectInputFocusNotify received with resource [%d].\n", + resource); + #endif + + nxagentHandleCollectInputFocusEvent(resource); + + return 1; + } + default: + { + /* + * Not a recognized ClientMessage event. + */ + + #ifdef WARNING + fprintf(stderr, "nxagentHandleProxyEvent: WARNING! Not a recognized ClientMessage proxy event [%d].\n", + (int) X -> xclient.data.l[0]); + #endif + + return 0; + } + } +} + +/* + * In this function it is assumed that we never + * get a configure with both stacking order and + * geometry changed, this way we can ignore + * stacking changes if the geometry has changed. + */ + +int nxagentCheckWindowConfiguration(XConfigureEvent* X) +{ + static int x = 0; + static int y = 0; + static int width = 0; + static int height = 0; + static Window win = None; + Bool geometryChanged = False; + + XlibWindow root_return = 0; + XlibWindow parent_return = 0; + XlibWindow *children_return = NULL; + unsigned int nchildren_return = 0; + Status result; + + WindowPtr pWin; + + pWin = nxagentWindowPtr(X -> window); + + /* + * This optimization has some problems to + * work in rootless mode inside NXWin. To + * verify this you can launch xterm and + * another application, f.e. firefox. By + * raising xterm above firefox, the stack + * order seems to become incoherent showing + * the underneath window content in the + * overlapping area when the mouse botton is + * pressed with the pointer inside of such area. + * + * if ((pWin != NULL) && X -> override_redirect == 0) + * { + * return 1; + * } + * + */ + + if (win == X -> window) + { + if (x != X -> x || + y != X -> y || + width != X -> width || + height != X -> height) + { + geometryChanged = True; + } + } + + win = X -> window; + + x = X -> x; + y = X -> y; + width = X -> width; + height = X -> height; + + if (geometryChanged) + { + #ifdef TEST + fprintf(stderr, "nxagentCheckWindowConfiguration: Configure frame. No restack.\n"); + #endif + + return 1; + } + + #ifdef TEST + { + WindowPtr pSib; + + fprintf(stderr, "nxagentCheckWindowConfiguration: Before restacking top level window [%p]\n", + (void *) nxagentWindowPtr(X -> window)); + + for (pSib = WindowTable[0] -> firstChild; pSib; pSib = pSib -> nextSib) + { + fprintf(stderr, "nxagentCheckWindowConfiguration: Top level window: [%p].\n", + (void *) pSib); + } + } + #endif + + result = XQueryTree(nxagentDisplay, DefaultRootWindow(nxagentDisplay), + &root_return, &parent_return, &children_return, &nchildren_return); + + if (result) + { + nxagentRootlessRestack(children_return, nchildren_return); + } + else + { + #ifdef WARNING + fprintf(stderr, "nxagentCheckWindowConfiguration: WARNING! Failed QueryTree request.\n"); + #endif + } + + if (result && nchildren_return) + { + XFree(children_return); + } + + #if 0 + fprintf(stderr, "nxagentCheckWindowConfiguration: Trees match: %s\n", + nxagentRootlessTreesMatch() ? "Yes" : "No"); + #endif + + return 1; +} + +int nxagentHandleConfigureNotify(XEvent* X) +{ + if (nxagentOption(Rootless) == True) + { + ClientPtr pClient; + WindowPtr pWinWindow; + WindowPtr pWin; + xEvent x; + int sendEventAnyway = 0; + + pWinWindow = nxagentWindowPtr(X -> xconfigure.window); + + #ifdef TEST + { + WindowPtr pWinEvent = nxagentWindowPtr(X -> xconfigure.event); + + fprintf(stderr, "nxagentHandleConfigureNotify: Generating window is [%p][%ld] target [%p][%ld].\n", + (void *) pWinEvent, X -> xconfigure.event, (void *) pWinWindow, X -> xconfigure.window); + } + #endif + + #ifdef TEST + fprintf(stderr, "nxagentHandleConfigureNotify: New configuration for window [%p][%ld] is [%d][%d][%d][%d] " + "send_event [%i].\n", (void *) pWinWindow, X -> xconfigure.window, + X -> xconfigure.x, X -> xconfigure.y, X -> xconfigure.width, + X -> xconfigure.height, X -> xconfigure.send_event); + #endif + + if ((pWin = nxagentRootlessTopLevelWindow(X -> xconfigure.window)) != NULL) + { + /* + * Cheking for new geometry or stacking order changes. + */ + + nxagentCheckWindowConfiguration((XConfigureEvent*)X); + + return 1; + } + + if (nxagentWindowTopLevel(pWinWindow) && !X -> xconfigure.override_redirect) + { + XID values[5]; + Mask mask = 0; + + register XID *value = values; + + pClient = wClient(pWinWindow); + + if (X -> xconfigure.send_event || !nxagentWMIsRunning || + X -> xconfigure.override_redirect) + { + *value++ = (XID)X -> xconfigure.x; + *value++ = (XID)X -> xconfigure.y; + + /* + * nxagentWindowPriv(pWinWindow)->x = X -> xconfigure.x; + * nxagentWindowPriv(pWinWindow)->y = X -> xconfigure.y; + */ + + mask |= CWX | CWY; + } + + *value++ = (XID)X -> xconfigure.width; + *value++ = (XID)X -> xconfigure.height; + *value++ = (XID)X -> xconfigure.border_width; + + /* + * We don't need width and height here. + * + * nxagentWindowPriv(pWinWindow)->width = X -> xconfigure.width; + * nxagentWindowPriv(pWinWindow)->height = X -> xconfigure.height; + */ + + mask |= CWHeight | CWWidth | CWBorderWidth; + + nxagentScreenTrap = 1; + + ConfigureWindow(pWinWindow, mask, (XID *) values, pClient); + + nxagentScreenTrap = 0; + + nxagentCheckWindowConfiguration((XConfigureEvent*)X); + + /* + * This workaround should help with + * Java 1.6.0 that seems to ignore + * non-synthetic events. + */ + + if (nxagentOption(ClientOs) == ClientOsWinnt) + { + #ifdef TEST + fprintf(stderr, "nxagentHandleConfigureNotify: Apply workaround for NXWin.\n"); + #endif + + sendEventAnyway = 1; + } + + if (sendEventAnyway || X -> xconfigure.send_event) + { + x.u.u.type = X -> xconfigure.type; + x.u.u.type |= 0x80; + + x.u.configureNotify.event = pWinWindow -> drawable.id; + x.u.configureNotify.window = pWinWindow -> drawable.id; + + if (pWinWindow -> nextSib) + { + x.u.configureNotify.aboveSibling = pWinWindow -> nextSib -> drawable.id; + } + else + { + x.u.configureNotify.aboveSibling = None; + } + + x.u.configureNotify.x = X -> xconfigure.x; + x.u.configureNotify.y = X -> xconfigure.y; + x.u.configureNotify.width = X -> xconfigure.width; + x.u.configureNotify.height = X -> xconfigure.height; + x.u.configureNotify.borderWidth = X -> xconfigure.border_width; + x.u.configureNotify.override = X -> xconfigure.override_redirect; + + TryClientEvents(pClient, &x, 1, 1, 1, 0); + } + + return 1; + } + } + else + { + /* + * Save the position of the agent default window. Don't + * save the values if the agent is in fullscreen mode. + * + * If we use these values to restore the position of a + * window after that we have dynamically changed the + * fullscreen attribute, depending on the behaviour of + * window manager, we could be not able to place the + * window exactly in the requested position, so let the + * window manager do the job for us. + */ + + ScreenPtr pScreen = nxagentScreen(X -> xconfigure.window); + + Bool doRandR = False; + struct timeval timeout; + + if (X -> xconfigure.window == nxagentDefaultWindows[pScreen -> myNum]) + { + if (nxagentOption(Fullscreen) == 0) + { + if (nxagentOption(DesktopResize) == 1) + { + if (nxagentOption(Width) != X -> xconfigure.width || + nxagentOption(Height) != X -> xconfigure.height) + { + Bool newEvents = False; + + doRandR = True; + + NXFlushDisplay(nxagentDisplay, NXFlushLink); + + do + { + newEvents = False; + + timeout.tv_sec = 0; + timeout.tv_usec = 500 * 1000; + + nxagentWaitEvents(nxagentDisplay, &timeout); + + /* + * This should also flush + * the NX link for us. + */ + + XSync(nxagentDisplay, 0); + + while (XCheckTypedWindowEvent(nxagentDisplay, nxagentDefaultWindows[pScreen -> myNum], + ConfigureNotify, X)) + { + newEvents = True; + } + + } while (newEvents); + } + } + + if (nxagentWMIsRunning == 0 || X -> xconfigure.send_event) + { + nxagentChangeOption(X, X -> xconfigure.x); + nxagentChangeOption(Y, X -> xconfigure.y); + } + + if (nxagentOption(Shadow) == 1 && nxagentOption(DesktopResize) == 1 && + (nxagentOption(Width) != X -> xconfigure.width || + nxagentOption(Height) != X -> xconfigure.height)) + { + nxagentShadowResize = 1; + } + + nxagentChangeOption(Width, X -> xconfigure.width); + nxagentChangeOption(Height, X -> xconfigure.height); + + nxagentChangeOption(ViewportXSpan, (int) X -> xconfigure.width - + (int) nxagentOption(RootWidth)); + nxagentChangeOption(ViewportYSpan, (int) X -> xconfigure.height - + (int) nxagentOption(RootHeight)); + + nxagentMoveViewport(pScreen, 0, 0); + + if (nxagentOption(Shadow) == 1 || + (nxagentOption(Width) == nxagentOption(RootWidth) && + nxagentOption(Height) == nxagentOption(RootHeight))) + { + doRandR = 0; + } + + if (doRandR) + { + #ifdef TEST + fprintf(stderr,"nxagentHandleConfigureNotify: Width %d Height %d.\n", + nxagentOption(Width), nxagentOption(Height)); + #endif + + nxagentRRSetScreenConfig(screenInfo.screens[DefaultScreen(nxagentDisplay)], + nxagentOption(Width), nxagentOption(Height)); + } + } + + return 1; + } + } + + return 0; +} + +int nxagentHandleReparentNotify(XEvent* X) +{ + ScreenPtr pScreen = nxagentScreen(X -> xreparent.window); + + #ifdef TEST + fprintf(stderr, "nxagentHandleReparentNotify: Going to handle a new reparent event.\n"); + #endif + + if (nxagentOption(Rootless)) + { + WindowPtr pWin; + + XlibWindow w; + XlibWindow root_return = 0; + XlibWindow parent_return = 0; + XlibWindow *children_return = NULL; + unsigned int nchildren_return = 0; + Status result; + + pWin = nxagentWindowPtr(X -> xreparent.window); + + #ifdef TEST + + { + WindowPtr pParent = nxagentWindowPtr(X -> xreparent.parent); + WindowPtr pEvent = nxagentWindowPtr(X -> xreparent.event); + + fprintf(stderr, "nxagentHandleReparentNotify: event %p[%lx] window %p[%lx] parent %p[%lx] at (%d, %d)\n", + (void*)pEvent, X -> xreparent.event, (void*)pWin, X -> xreparent.window, + (void*)pParent, X -> xreparent.parent, X -> xreparent.x, X -> xreparent.y); + } + + #endif + + if (nxagentWindowTopLevel(pWin)) + { + /* + * If the window manager reparents our top level + * window, we need to know the new top level + * ancestor. + */ + + w = None; + parent_return = X -> xreparent.parent; + + while (parent_return != RootWindow(nxagentDisplay, 0)) + { + w = parent_return; + result = XQueryTree(nxagentDisplay, w, &root_return, + &parent_return, &children_return, &nchildren_return); + + if (!result) + { + #ifdef WARNING + fprintf(stderr, "nxagentHandleReparentNotify: WARNING! Failed QueryTree request.\n"); + #endif + } + + if (result && children_return) + { + XFree(children_return); + } + } + + if (w && !nxagentWindowPtr(w)) + { + XSelectInput(nxagentDisplay, w, StructureNotifyMask); + + nxagentRootlessAddTopLevelWindow(pWin, w); + + #ifdef TEST + fprintf(stderr, "nxagentHandleReparentNotify: new top level window [%ld].\n", w); + fprintf(stderr, "nxagentHandleReparentNotify: reparented window [%ld].\n", + X -> xreparent.window); + #endif + + result = XQueryTree(nxagentDisplay, DefaultRootWindow(nxagentDisplay), + &root_return, &parent_return, &children_return, &nchildren_return); + + if (result) + { + nxagentRootlessRestack(children_return, nchildren_return); + } + else + { + #ifdef WARNING + fprintf(stderr, "nxagentHandleReparentNotify: WARNING! Failed QueryTree request.\n"); + #endif + } + + if (result && nchildren_return) + { + XFree(children_return); + } + } + else + { + #ifdef TEST + fprintf(stderr, "nxagentHandleReparentNotify: Window at [%p] has been reparented to [%ld]" + " top level parent [%ld].\n", (void *) pWin, X -> xreparent.parent, w); + #endif + + nxagentRootlessDelTopLevelWindow(pWin); + } + } + + return 1; + } + else + { + /* + * This code is supposed to detect if a window manager + * is running but in some cases it may be unreliable. + * Each window manager behaves differently so the check + * can fail for some less common WMs. + */ + + if (!nxagentWMIsRunning && nxagentOption(Fullscreen) && + X -> xreparent.window == nxagentDefaultWindows[pScreen -> myNum]) + { + #ifdef WARNING + fprintf(stderr, "Warning: The agent window was reparented. Is a " + "window manager running?\n"); + #endif + + /* + * If no window manager is running and we are supposed to + * be in fullscreen mode then don't wait for the reparent + * event. We can assume that there is an undetected window + * manager and, as switching to fullscreen could have fail- + * ed, we try it again. + */ + + nxagentSwitchFullscreen(pScreen, True); + + nxagentWMIsRunning = True; + } + else if (nxagentWMIsRunning && X -> xreparent.window == + nxagentDefaultWindows[pScreen -> myNum] && X -> xreparent.parent == + RootWindow(nxagentDisplay, (pScreen -> myNum))) + { + #ifdef WARNING + + fprintf(stderr, "Warning: The agent window has been reparented to the root.\n"); + + fprintf(stderr, "Warning: No window manager seems to be running.\n"); + + #endif + + /* + * The agent window was unexpectedly reparented + * to the root window. We assume that the window + * manager was terminated. + */ + + nxagentWMIsRunning = False; + } + } + + return 1; +} + +void nxagentEnableKeyboardEvents() +{ + int i; + Mask mask; + + nxagentGetDefaultEventMask(&mask); + + mask |= NXAGENT_KEYBOARD_EVENT_MASK; + + nxagentSetDefaultEventMask(mask); + + for (i = 0; i < nxagentNumScreens; i++) + { + XSelectInput(nxagentDisplay, nxagentDefaultWindows[i], mask); + } + + XkbSelectEvents(nxagentDisplay, XkbUseCoreKbd, + NXAGENT_KEYBOARD_EXTENSION_EVENT_MASK, + NXAGENT_KEYBOARD_EXTENSION_EVENT_MASK); +} + +void nxagentDisableKeyboardEvents() +{ + int i; + Mask mask; + + nxagentGetDefaultEventMask(&mask); + + mask &= ~NXAGENT_KEYBOARD_EVENT_MASK; + + nxagentSetDefaultEventMask(mask); + + for (i = 0; i < nxagentNumScreens; i++) + { + XSelectInput(nxagentDisplay, nxagentDefaultWindows[i], mask); + } + + XkbSelectEvents(nxagentDisplay, XkbUseCoreKbd, 0x0, 0x0); +} + +void nxagentEnablePointerEvents() +{ + int i; + Mask mask; + + nxagentGetDefaultEventMask(&mask); + + mask |= NXAGENT_POINTER_EVENT_MASK; + + nxagentSetDefaultEventMask(mask); + + for (i = 0; i < nxagentNumScreens; i++) + { + XSelectInput(nxagentDisplay, nxagentDefaultWindows[i], mask); + } +} + +void nxagentDisablePointerEvents() +{ + int i; + Mask mask; + + nxagentGetDefaultEventMask(&mask); + + mask &= ~NXAGENT_POINTER_EVENT_MASK; + + nxagentSetDefaultEventMask(mask); + + for (i = 0; i < nxagentNumScreens; i++) + { + XSelectInput(nxagentDisplay, nxagentDefaultWindows[i], mask); + } +} + +void nxagentSendFakeKey(int key) +{ + xEvent fake; + Time now; + + now = GetTimeInMillis(); + + fake.u.u.type = KeyPress; + fake.u.u.detail = key; + fake.u.keyButtonPointer.time = now; + + mieqEnqueue(&fake); + + fake.u.u.type = KeyRelease; + fake.u.u.detail = key; + fake.u.keyButtonPointer.time = now; + + mieqEnqueue(&fake); +} + +int nxagentInitKeyboardState() +{ + XEvent X; + + unsigned int modifiers; + + XkbEvent *xkbev = (XkbEvent *) &X; + + #ifdef TEST + fprintf(stderr, "nxagentInitKeyboardState: Initializing XKB state.\n"); + #endif + + XkbGetIndicatorState(nxagentDisplay, XkbUseCoreKbd, &modifiers); + + xkbev -> state.locked_mods = 0x0; + + if (modifiers & CAPSFLAG_IN_REPLY) + { + xkbev -> state.locked_mods |= CAPSFLAG_IN_EVENT; + } + + if (modifiers & NUMFLAG_IN_REPLY) + { + xkbev -> state.locked_mods |= NUMFLAG_IN_EVENT; + } + + #ifdef TEST + fprintf(stderr, "nxagentInitKeyboardState: Assuming XKB locked modifier bits [%x].\n", + xkbev -> state.locked_mods); + #endif + + xkbev -> type = nxagentXkbInfo.EventBase + XkbEventCode; + xkbev -> any.xkb_type = XkbStateNotify; + + nxagentHandleKeyboardEvent(&X); + + return 1; +} + +int nxagentWaitForResource(GetResourceFuncPtr pGetResource, PredicateFuncPtr pPredicate) +{ + int resource; + + while ((resource = (*pGetResource)(nxagentDisplay)) == -1) + { + if (nxagentWaitEvents(nxagentDisplay, NULL) == -1) + { + return -1; + } + + nxagentDispatchEvents(pPredicate); + } + + return resource; +} + +void nxagentGrabPointerAndKeyboard(XEvent *X) +{ + unsigned long now; + + int resource; + + #ifdef TEST + fprintf(stderr, "nxagentGrabPointerAndKeyboard: Grabbing pointer and keyboard with event at [%p].\n", + (void *) X); + #endif + + if (X != NULL) + { + now = X -> xcrossing.time; + } + else + { + now = CurrentTime; + } + + #ifdef TEST + fprintf(stderr, "nxagentGrabPointerAndKeyboard: Going to grab the keyboard in context [B1].\n"); + #endif + + XGrabKeyboard(nxagentDisplay, nxagentFullscreenWindow, + True, GrabModeAsync, GrabModeAsync, now); + + #ifdef TEST + fprintf(stderr, "nxagentGrabPointerAndKeyboard: Going to grab the pointer in context [B2].\n"); + #endif + + resource = nxagentWaitForResource(NXGetCollectGrabPointerResource, + nxagentCollectGrabPointerPredicate); + + NXCollectGrabPointer(nxagentDisplay, resource, + nxagentFullscreenWindow, True, NXAGENT_POINTER_EVENT_MASK, + GrabModeAsync, GrabModeAsync, None, None, now); + + /* + * This should not be needed. + * + * XGrabKey(nxagentDisplay, AnyKey, AnyModifier, nxagentFullscreenWindow, + * True, GrabModeAsync, GrabModeAsync); + */ + + if (X != NULL) + { + #ifdef TEST + fprintf(stderr, "nxagentGrabPointerAndKeyboard: Going to force focus in context [B4].\n"); + #endif + + XSetInputFocus(nxagentDisplay, nxagentFullscreenWindow, + RevertToParent, now); + } +} + +void nxagentUngrabPointerAndKeyboard(XEvent *X) +{ + unsigned long now; + + #ifdef TEST + fprintf(stderr, "nxagentUngrabPointerAndKeyboard: Ungrabbing pointer and keyboard with event at [%p].\n", + (void *) X); + #endif + + if (X != NULL) + { + now = X -> xcrossing.time; + } + else + { + now = CurrentTime; + } + + #ifdef TEST + fprintf(stderr, "nxagentUngrabPointerAndKeyboard: Going to ungrab the keyboard in context [B5].\n"); + #endif + + XUngrabKeyboard(nxagentDisplay, now); + + #ifdef TEST + fprintf(stderr, "nxagentGrabPointerAndKeyboard: Going to ungrab the pointer in context [B6].\n"); + #endif + + XUngrabPointer(nxagentDisplay, now); +} + +void nxagentDeactivatePointerGrab() +{ + GrabPtr grab = inputInfo.pointer -> grab; + + XButtonEvent X; + + if (grab) + { + X.type = ButtonRelease; + X.serial = 0; + X.send_event = FALSE; + X.time = currentTime.milliseconds; + X.display = nxagentDisplay; + X.window = nxagentWindow(grab -> window); + X.root = RootWindow(nxagentDisplay, 0); + X.subwindow = 0; + X.x = X.y = X.x_root = X.y_root = 0; + X.state = 0x100; + X.button = 1; + X.same_screen = TRUE; + + XPutBackEvent(nxagentDisplay, (XEvent*)&X); + } +} + +Bool nxagentCollectGrabPointerPredicate(Display *display, XEvent *X, XPointer ptr) +{ + return (X -> xclient.window == 0 && + X -> xclient.message_type == 0 && + X -> xclient.format == 32 && + X -> xclient.data.l[0] == NXCollectGrabPointerNotify); +} + +void nxagentHandleCollectGrabPointerEvent(int resource) +{ + int status; + + if (NXGetCollectedGrabPointer(nxagentDisplay, resource, &status) == 0) + { + #ifdef PANIC + fprintf(stderr, "nxagentHandleCollectGrabPointerEvent: PANIC! Failed to get GrabPointer " + "reply for resource [%d].\n", resource); + #endif + } +} + +void nxagentHandleCollectPropertyEvent(XEvent *X) +{ + Window window; + Atom property; + Atom atomReturnType; + int resultFormat; + unsigned long ulReturnItems; + unsigned long ulReturnBytesLeft; + unsigned char *pszReturnData = NULL; + int result; + int resource; + + resource = X -> xclient.data.l[1]; + + if (X -> xclient.data.l[2] == False) + { + #ifdef DEBUG + fprintf (stderr, "nxagentHandleCollectPropertyEvent: Failed to get reply data for client [%d].\n", + resource); + #endif + + return; + } + + if (resource == nxagentLastClipboardClient) + { + nxagentCollectPropertyEvent(resource); + } + else + { + result = NXGetCollectedProperty(nxagentDisplay, + resource, + &atomReturnType, + &resultFormat, + &ulReturnItems, + &ulReturnBytesLeft, + &pszReturnData); + + if (result == True) + { + window = nxagentPropertyRequests[resource].window; + property = nxagentPropertyRequests[resource].property; + + nxagentImportProperty(window, property, atomReturnType, resultFormat, + ulReturnItems, ulReturnBytesLeft, pszReturnData); + } + + if (result == 0) + { + #ifdef DEBUG + fprintf (stderr, "nxagentHandleCollectPropertyEvent: Failed to get reply data for client [%d].\n", + resource); + #endif + } + + if (pszReturnData != NULL) + { + XFree(pszReturnData); + } + + return; + } +} + +void nxagentSynchronizeExpose(void) +{ + WindowPtr pWin; + + if (nxagentExposeQueue.length <= 0) + { + #ifdef TEST + fprintf(stderr, "nxagentSynchronizeExpose: PANIC! Called with nxagentExposeQueue.length [%d].\n", + nxagentExposeQueue.length); + #endif + + return; + } + + pWin = nxagentExposeQueueHead.pWindow; + + if (pWin) + { + if ((nxagentExposeQueueHead.localRegion) != NullRegion) + { + REGION_TRANSLATE(pWin -> drawable.pScreen, (nxagentExposeQueueHead.localRegion), + pWin -> drawable.x, pWin -> drawable.y); + } + + if ((nxagentExposeQueueHead.remoteRegion) != NullRegion) + { + REGION_TRANSLATE(pWin -> drawable.pScreen, (nxagentExposeQueueHead.remoteRegion), + pWin -> drawable.x, pWin -> drawable.y); + } + + if ((nxagentExposeQueueHead.localRegion) != NullRegion && + (nxagentExposeQueueHead.remoteRegion) != NullRegion) + { + REGION_SUBTRACT(pWin -> drawable.pScreen, (nxagentExposeQueueHead.remoteRegion), + (nxagentExposeQueueHead.remoteRegion), + (nxagentExposeQueueHead.localRegion)); + + if (REGION_NIL(nxagentExposeQueueHead.remoteRegion) == 0) + { + #ifdef TEST + fprintf(stderr, "nxagentSynchronizeExpose: Going to call miWindowExposures" + " for window [%ld] - rects [%ld].\n", nxagentWindow(pWin), + REGION_NUM_RECTS(nxagentExposeQueueHead.remoteRegion)); + #endif + + miWindowExposures(pWin, nxagentExposeQueueHead.remoteRegion, NullRegion); + } + } + } + + nxagentExposeQueueHead.pWindow = NULL; + + if (nxagentExposeQueueHead.localRegion != NullRegion) + { + REGION_DESTROY(nxagentDefaultScreen, nxagentExposeQueueHead.localRegion); + } + + nxagentExposeQueueHead.localRegion = NullRegion; + + if (nxagentExposeQueueHead.remoteRegion != NullRegion) + { + REGION_DESTROY(nxagentDefaultScreen, nxagentExposeQueueHead.remoteRegion); + } + + nxagentExposeQueueHead.remoteRegion = NullRegion; + + nxagentExposeQueueHead.remoteRegionIsCompleted = False; + + nxagentExposeQueue.start = (nxagentExposeQueue.start + 1) % EXPOSED_SIZE; + + nxagentExposeQueue.length--; + + return; +} + +int nxagentLookupByWindow(WindowPtr pWin) +{ + int i; + int j; + + for (j = 0; j < nxagentExposeQueue.length; j++) + { + i = (nxagentExposeQueue.start + j) % EXPOSED_SIZE; + + if (nxagentExposeQueue.exposures[i].pWindow == pWin && + !nxagentExposeQueue.exposures[i].remoteRegionIsCompleted) + { + return i; + } + } + + return -1; +} + +void nxagentRemoveDuplicatedKeys(XEvent *X) +{ + _XQEvent *prev; + _XQEvent *qelt; + + _XQEvent *qeltKeyRelease; + _XQEvent *prevKeyRelease; + + KeyCode lastKeycode = X -> xkey.keycode; + + qelt = nxagentDisplay -> head; + + if (qelt == NULL) + { + #ifdef TEST + + int more; + + fprintf(stderr, "nxagentRemoveDuplicatedKeys: Trying to read more events " + "from the X server.\n"); + + more = nxagentReadEvents(nxagentDisplay); + + if (more > 0) + { + fprintf(stderr, "nxagentRemoveDuplicatedKeys: Successfully read more events " + "from the X server.\n"); + } + + #else + + nxagentReadEvents(nxagentDisplay); + + #endif + + qelt = nxagentDisplay -> head; + } + + if (qelt != NULL) + { + prev = qeltKeyRelease = prevKeyRelease = NULL; + + LockDisplay(nxagentDisplay); + + while (qelt != NULL) + { + if (qelt -> event.type == KeyRelease || + qelt -> event.type == KeyPress) + { + if (qelt -> event.xkey.keycode != lastKeycode || + (qelt -> event.type == KeyPress && qeltKeyRelease == NULL) || + (qelt -> event.type == KeyRelease && qeltKeyRelease != NULL)) + { + break; + } + + if (qelt -> event.type == KeyRelease) + { + prevKeyRelease = prev; + + qeltKeyRelease = qelt; + } + else if (qelt -> event.type == KeyPress) + { + _XDeq(nxagentDisplay, prev, qelt); + + qelt = prev -> next; + + if (prev == qeltKeyRelease) + { + prev = prevKeyRelease; + } + + _XDeq(nxagentDisplay, prevKeyRelease, qeltKeyRelease); + + qeltKeyRelease = prevKeyRelease = NULL; + + continue; + } + } + + prev = qelt; + + qelt = qelt -> next; + } + + UnlockDisplay(nxagentDisplay); + } +} + +void nxagentInitRemoteExposeRegion(void) +{ + if (nxagentRemoteExposeRegion == NULL) + { + nxagentRemoteExposeRegion = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1); + + if (nxagentRemoteExposeRegion == NULL) + { + #ifdef PANIC + fprintf(stderr, "nxagentInitRemoteExposeRegion: PANIC! Failed to create expose region.\n"); + #endif + } + } +} + +void nxagentForwardRemoteExpose(void) +{ + if (REGION_NOTEMPTY(WindowTable[0] -> drawable.pScreen, nxagentRemoteExposeRegion)) + { + #ifdef DEBUG + fprintf(stderr, "nxagentForwardRemoteExpose: Going to forward events.\n"); + #endif + + TraverseTree(WindowTable[0], nxagentClipAndSendExpose, (void *)nxagentRemoteExposeRegion); + + /* + * Now this region should be empty. + */ + + REGION_EMPTY(WindowTable[0] -> drawable.pScreen, nxagentRemoteExposeRegion); + } +} + +void nxagentAddRectToRemoteExposeRegion(BoxPtr rect) +{ + RegionRec exposeRegion; + + if (nxagentRemoteExposeRegion == NULL) + { + return; + } + + REGION_INIT(nxagentDefaultScreen, &exposeRegion, rect, 1); + + REGION_UNION(nxagentDefaultScreen, nxagentRemoteExposeRegion, + nxagentRemoteExposeRegion, &exposeRegion); + + REGION_UNINIT(nxagentDefaultScreen, &exposeRegion); +} + +int nxagentClipAndSendExpose(WindowPtr pWin, pointer ptr) +{ + RegionPtr exposeRgn; + RegionPtr remoteExposeRgn; + BoxRec box; + + #ifdef DEBUG + fprintf(stderr, "nxagentClipAndSendExpose: Called.\n"); + #endif + + remoteExposeRgn = (RegionRec *) ptr; + + if (pWin -> drawable.class != InputOnly) + { + exposeRgn = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1); + + box = *REGION_EXTENTS(pWin->drawable.pScreen, remoteExposeRgn); + + #ifdef DEBUG + fprintf(stderr, "nxagentClipAndSendExpose: Root expose extents: [%d] [%d] [%d] [%d].\n", + box.x1, box.y1, box.x2, box.y2); + #endif + + box = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin -> clipList); + + #ifdef DEBUG + fprintf(stderr, "nxagentClipAndSendExpose: Clip list extents for window at [%p]: [%d] [%d] [%d] [%d].\n", + pWin, box.x1, box.y1, box.x2, box.y2); + #endif + + REGION_INTERSECT(pWin -> drawable.pScreen, exposeRgn, remoteExposeRgn, &pWin -> clipList); + + if (REGION_NOTEMPTY(pWin -> drawable.pScreen, exposeRgn)) + { + #ifdef DEBUG + fprintf(stderr, "nxagentClipAndSendExpose: Forwarding expose to window at [%p] pWin.\n", + pWin); + #endif + + /* + * The miWindowExposures() clears out the + * region parameters, so the subtract ope- + * ration must be done before calling it. + */ + + REGION_SUBTRACT(pWin -> drawable.pScreen, remoteExposeRgn, remoteExposeRgn, exposeRgn); + + miWindowExposures(pWin, exposeRgn, NullRegion); + } + + REGION_DESTROY(pWin -> drawable.pScreen, exposeRgn); + } + + if (REGION_NOTEMPTY(pWin -> drawable.pScreen, remoteExposeRgn)) + { + #ifdef DEBUG + fprintf(stderr, "nxagentClipAndSendExpose: Region not empty. Walk children.\n"); + #endif + + return WT_WALKCHILDREN; + } + else + { + #ifdef DEBUG + fprintf(stderr, "nxagentClipAndSendExpose: Region empty. Stop walking.\n"); + #endif + + return WT_STOPWALKING; + } +} + +int nxagentUserInput(void *p) +{ + int result = 0; + + /* + * This function is used as callback in + * the polling handler of agent in shadow + * mode. When inside the polling loop the + * handlers are never called, so we have + * to dispatch enqueued events to eventu- + * ally change the nxagentInputEvent sta- + * tus. + */ + + if (nxagentOption(Shadow) == 1 && + nxagentPendingEvents(nxagentDisplay) > 0) + { + nxagentDispatchEvents(NULL); + } + + if (nxagentInputEvent == 1) + { + nxagentInputEvent = 0; + + result = 1; + } + + /* + * The agent working in shadow mode synch- + * ronizes the remote X server even if a + * button/key is not released (i.e. when + * scrolling a long browser's page), in + * order to update the screen smoothly. + */ + + if (nxagentOption(Shadow) == 1) + { + return result; + } + + if (result == 0) + { + /* + * If there is at least one button/key down, + * we are receiving an input. This is not a + * condition to break a synchronization loop + * if there is enough bandwidth. + */ + + if (nxagentCongestion > 0 && + (inputInfo.pointer -> button -> buttonsDown > 0 || + nxagentKeyDown > 0)) + { + #ifdef TEST + fprintf(stderr, "nxagentUserInput: Buttons [%d] Keys [%d].\n", + inputInfo.pointer -> button -> buttonsDown, nxagentKeyDown); + #endif + + result = 1; + } + } + + return result; +} + +int nxagentHandleRRScreenChangeNotify(XEvent *X) +{ + XRRScreenChangeNotifyEvent *Xr; + + Xr = (XRRScreenChangeNotifyEvent *) X; + + nxagentResizeScreen(screenInfo.screens[DefaultScreen(nxagentDisplay)], Xr -> width, Xr -> height, + Xr -> mwidth, Xr -> mheight); + + nxagentShadowCreateMainWindow(screenInfo.screens[DefaultScreen(nxagentDisplay)], WindowTable[0], + Xr -> width, Xr -> height); + + nxagentShadowSetWindowsSize(); + + return 1; +} + +/* + * Returns true if there is any event waiting to + * be dispatched. This function is critical for + * the performance because it is called very, + * very often. It must also handle the case when + * the display is down. The display descriptor, + * in fact, may have been reused by some other + * client. + */ + +int nxagentPendingEvents(Display *dpy) +{ + if (_XGetIOError(dpy) != 0) + { + #ifdef DEBUG + fprintf(stderr, "nxagentPendingEvents: Returning error with display down.\n"); + #endif + + return -1; + } + else if (XQLength(dpy) > 0) + { + #ifdef DEBUG + fprintf(stderr, "nxagentPendingEvents: Returning true with [%d] events queued.\n", + XQLength(dpy)); + #endif + + return 1; + } + else + { + int result; + int readable; + + result = NXTransReadable(dpy -> fd, &readable); + + if (result == 0) + { + if (readable > 0) + { + #ifdef DEBUG + fprintf(stderr, "nxagentPendingEvents: Returning true with [%d] bytes readable.\n", + readable); + #endif + + return 1; + } + + #ifdef DEBUG + fprintf(stderr, "nxagentPendingEvents: Returning false with [%d] bytes readable.\n", + readable); + #endif + + return 0; + } + + #ifdef TEST + fprintf(stderr, "nxagentPendingEvents: WARNING! Error detected on the X display.\n"); + #endif + + NXForceDisplayError(dpy); + + return -1; + } +} + +/* + * Blocks until an event becomes + * available. + */ + +int nxagentWaitEvents(Display *dpy, struct timeval *tm) +{ + XEvent ev; + + NXFlushDisplay(dpy, NXFlushLink); + + /* + * If the transport is not running we + * have to rely on Xlib to wait for an + * event. In this case the timeout is + * ignored. + */ + + if (NXTransRunning(NX_FD_ANY) == 1) + { + NXTransContinue(tm); + } + else + { + XPeekEvent(dpy, &ev); + } + + /* + * Check if we encountered a display + * error. If we did, wait for the + * time requested by the caller. + */ + + if (NXDisplayError(dpy) == 1) + { + if (tm != NULL) + { + usleep(tm -> tv_sec * 1000 * 1000 + + tm -> tv_usec); + } + + return -1; + } + + return 1; +} |