XQuartz: Transition from xEvent based mieq to InternalEvent

(cherry picked from commit a3dbde2de87ee4f577748a8c447501a3ea462559)

14 files changed, 147 insertions, 439 deletions

diff --git a/hw/xquartz/Makefile.am b/hw/xquartz/Makefile.am
index ae8aa7f53..65c70b076 100644
--- a/hw/xquartz/Makefile.am
+++ b/hw/xquartz/Makefile.am
@@ -33,7 +33,6 @@ libXquartz_la_SOURCES = \
 	quartzAudio.c \
 	quartzCocoa.m \
 	quartzKeyboard.c \
-	quartzPasteboard.c \
 	quartzStartup.c \
 	threadSafety.c
 
@@ -50,7 +49,6 @@ EXTRA_DIST = \
 	quartzAudio.h \
 	quartzCommon.h \
 	quartzKeyboard.h \
-	quartzPasteboard.h \
 	sanitizedCarbon.h \
 	sanitizedCocoa.h \
 	threadSafety.h
diff --git a/hw/xquartz/darwinEvents.c b/hw/xquartz/darwinEvents.c
index 4822af479..d300cce05 100644
--- a/hw/xquartz/darwinEvents.c
+++ b/hw/xquartz/darwinEvents.c
@@ -43,6 +43,7 @@ in this Software without prior written authorization from The Open Group.
 #include   "windowstr.h"
 #include   "pixmapstr.h"
 #include   "inputstr.h"
+#include   "eventstr.h"
 #include   "mi.h"
 #include   "scrnintstr.h"
 #include   "mipointer.h"
@@ -71,7 +72,7 @@ in this Software without prior written authorization from The Open Group.
 #include "applewmExt.h"
 
 /* FIXME: Abstract this better */
-void QuartzModeEQInit(void);
+extern Bool QuartzModeEventHandler(int screenNum, XQuartzEvent *e, DeviceIntPtr dev);
 
 int darwin_all_modifier_flags = 0;  // last known modifier state
 int darwin_all_modifier_mask = 0;
@@ -84,7 +85,7 @@ static pthread_mutex_t fd_add_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t fd_add_ready_cond = PTHREAD_COND_INITIALIZER;
 static pthread_t fd_add_tid = NULL;
 
-static EventList *darwinEvents = NULL;
+static EventListPtr darwinEvents = NULL;
 
 static pthread_mutex_t mieq_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t mieq_ready_cond = PTHREAD_COND_INITIALIZER;
@@ -190,89 +191,98 @@ static void DarwinUpdateModifiers(
    be moved into their own individual functions and set as handlers using
    mieqSetHandler. */
 
-static void DarwinEventHandler(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents) {
-    int i;
-    
+static void DarwinEventHandler(int screenNum, InternalEvent *ie, DeviceIntPtr dev) {
+    XQuartzEvent *e = &(ie->xquartz_event);
+
     TA_SERVER();
 
-//    DEBUG_LOG("DarwinEventHandler(%d, %p, %p, %d)\n", screenNum, xe, dev, nevents);
-    for (i=0; i<nevents; i++) {
-        switch(xe[i].u.u.type) {
-            case kXquartzControllerNotify:
-                DEBUG_LOG("kXquartzControllerNotify\n");
-                AppleWMSendEvent(AppleWMControllerNotify,
-                                 AppleWMControllerNotifyMask,
-                                 xe[i].u.clientMessage.u.l.longs0,
-                                 xe[i].u.clientMessage.u.l.longs1);
-                break;
-                
-            case kXquartzPasteboardNotify:
-                DEBUG_LOG("kXquartzPasteboardNotify\n");
-                AppleWMSendEvent(AppleWMPasteboardNotify,
-                                 AppleWMPasteboardNotifyMask,
-                                 xe[i].u.clientMessage.u.l.longs0,
-                                 xe[i].u.clientMessage.u.l.longs1);
-                break;
-                
-            case kXquartzActivate:
-                DEBUG_LOG("kXquartzActivate\n");
-                QuartzShow(xe[i].u.keyButtonPointer.rootX,
-                           xe[i].u.keyButtonPointer.rootY);
-                AppleWMSendEvent(AppleWMActivationNotify,
-                                 AppleWMActivationNotifyMask,
-                                 AppleWMIsActive, 0);
-                break;
-                
-            case kXquartzDeactivate:
-                DEBUG_LOG("kXquartzDeactivate\n");
-                AppleWMSendEvent(AppleWMActivationNotify,
-                                 AppleWMActivationNotifyMask,
-                                 AppleWMIsInactive, 0);
+    switch(e->subtype) {
+        case kXquartzControllerNotify:
+            DEBUG_LOG("kXquartzControllerNotify\n");
+            AppleWMSendEvent(AppleWMControllerNotify,
+                             AppleWMControllerNotifyMask,
+                             e->data[0],
+                             e->data[1]);
+            break;
+            
+        case kXquartzPasteboardNotify:
+            DEBUG_LOG("kXquartzPasteboardNotify\n");
+            AppleWMSendEvent(AppleWMPasteboardNotify,
+                             AppleWMPasteboardNotifyMask,
+                             e->data[0],
+                             e->data[1]);
+            break;
+            
+        case kXquartzActivate:
+            DEBUG_LOG("kXquartzActivate\n");
+            QuartzShow();
+            AppleWMSendEvent(AppleWMActivationNotify,
+                             AppleWMActivationNotifyMask,
+                             AppleWMIsActive, 0);
+            break;
+            
+        case kXquartzDeactivate:
+            DEBUG_LOG("kXquartzDeactivate\n");
+            AppleWMSendEvent(AppleWMActivationNotify,
+                             AppleWMActivationNotifyMask,
+                             AppleWMIsInactive, 0);
+            QuartzHide();
+            break;
+
+        case kXquartzReloadPreferences:
+            DEBUG_LOG("kXquartzReloadPreferences\n");
+            AppleWMSendEvent(AppleWMActivationNotify,
+                             AppleWMActivationNotifyMask,
+                             AppleWMReloadPreferences, 0);
+            break;
+            
+        case kXquartzToggleFullscreen:
+            DEBUG_LOG("kXquartzToggleFullscreen\n");
+            if (quartzEnableRootless) 
+                QuartzSetFullscreen(!quartzHasRoot);
+            else if (quartzHasRoot)
                 QuartzHide();
-                break;
-
-            case kXquartzReloadPreferences:
-                DEBUG_LOG("kXquartzReloadPreferences\n");
-                AppleWMSendEvent(AppleWMActivationNotify,
-                                 AppleWMActivationNotifyMask,
-                                 AppleWMReloadPreferences, 0);
-                break;
-                
-            case kXquartzToggleFullscreen:
-                DEBUG_LOG("kXquartzToggleFullscreen\n");
-                if (quartzEnableRootless) 
-                    QuartzSetFullscreen(!quartzHasRoot);
-                else if (quartzHasRoot)
-                    QuartzHide();
-                else
-                    QuartzShow(xe[i].u.keyButtonPointer.rootX,
-                               xe[i].u.keyButtonPointer.rootY);
-                break;
-                
-            case kXquartzSetRootless:
-                DEBUG_LOG("kXquartzSetRootless\n");
-                QuartzSetRootless(xe[i].u.clientMessage.u.l.longs0);
-                if (!quartzEnableRootless && !quartzHasRoot)
-                    QuartzHide();
-                break;
-                
-            case kXquartzSetRootClip:
-                QuartzSetRootClip((Bool)xe[i].u.clientMessage.u.l.longs0);
-                break;
-                
-            case kXquartzQuit:
-                GiveUp(0);
-                break;
-                
-            case kXquartzSpaceChanged:
-                DEBUG_LOG("kXquartzSpaceChanged\n");
-                QuartzSpaceChanged(xe[i].u.clientMessage.u.l.longs0);
-                break;
-
-            default:
-                ErrorF("Unknown application defined event type %d.\n", xe[i].u.u.type);
-		}	
-    }
+            else
+                QuartzShow();
+            break;
+            
+        case kXquartzSetRootless:
+            DEBUG_LOG("kXquartzSetRootless\n");
+            QuartzSetRootless(e->data[0]);
+            if (!quartzEnableRootless && !quartzHasRoot)
+                QuartzHide();
+            break;
+            
+        case kXquartzSetRootClip:
+            QuartzSetRootClip((Bool)e->data[0]);
+            break;
+            
+        case kXquartzQuit:
+            GiveUp(0);
+            break;
+            
+        case kXquartzSpaceChanged:
+            DEBUG_LOG("kXquartzSpaceChanged\n");
+            QuartzSpaceChanged(e->data[0]);
+            break;
+
+        case kXquartzListenOnOpenFD:
+            ErrorF("Calling ListenOnOpenFD() for new fd: %d\n", (int)e->data[0]);
+            ListenOnOpenFD((int)e->data[0], 1);
+            break;
+            
+        case kXquartzReloadKeymap:
+            DarwinKeyboardReloadHandler();
+            break;
+            
+        case kXquartzDisplayChanged:
+            QuartzUpdateScreens();
+            break;
+            
+        default:
+            if(!QuartzModeEventHandler(screenNum, e, dev))
+                ErrorF("Unknown application defined event type %d.\n", e->subtype);
+    }	
 }
 
 void DarwinListenOnOpenFD(int fd) {
@@ -298,16 +308,6 @@ static void DarwinProcessFDAdditionQueue_thread(void *args) {
     }
 }
 
-static void kXquartzListenOnOpenFDHandler(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents) {
-    size_t i;
-    TA_SERVER();
-    
-    for (i=0; i<nevents; i++) {
-        ErrorF("Calling ListenOnOpenFD() for new fd: %d\n", (int)xe[i].u.clientMessage.u.l.longs0);
-        ListenOnOpenFD((int)xe[i].u.clientMessage.u.l.longs0, 1);
-    }
-}
-
 Bool DarwinEQInit(void) { 
     int *p;
 
@@ -320,23 +320,7 @@ Bool DarwinEQInit(void) {
     }
     
     mieqInit();
-    mieqSetHandler(kXquartzReloadKeymap, DarwinKeyboardReloadHandler);
-    mieqSetHandler(kXquartzActivate, DarwinEventHandler);
-    mieqSetHandler(kXquartzDeactivate, DarwinEventHandler);
-    mieqSetHandler(kXquartzReloadPreferences, DarwinEventHandler);
-    mieqSetHandler(kXquartzSetRootClip, DarwinEventHandler);
-    mieqSetHandler(kXquartzQuit, DarwinEventHandler);
-    mieqSetHandler(kXquartzReadPasteboard, QuartzReadPasteboard);
-    mieqSetHandler(kXquartzWritePasteboard, QuartzWritePasteboard);
-    mieqSetHandler(kXquartzToggleFullscreen, DarwinEventHandler);
-    mieqSetHandler(kXquartzSetRootless, DarwinEventHandler);
-    mieqSetHandler(kXquartzSpaceChanged, DarwinEventHandler);
-    mieqSetHandler(kXquartzControllerNotify, DarwinEventHandler);
-    mieqSetHandler(kXquartzPasteboardNotify, DarwinEventHandler);
-    mieqSetHandler(kXquartzDisplayChanged, QuartzDisplayChangedHandler);
-    mieqSetHandler(kXquartzListenOnOpenFD, kXquartzListenOnOpenFDHandler);
-    
-    QuartzModeEQInit();
+    mieqSetHandler(ET_XQuartz, DarwinEventHandler);
 
     /* Note that this *could* cause a potential async issue, since we're checking
      * darwinEvents without holding the lock, but darwinEvents is only ever set
@@ -364,16 +348,16 @@ Bool DarwinEQInit(void) {
  *  Read and process events from the event queue until it is empty.
  */
 void ProcessInputEvents(void) {
-    xEvent  xe;
-	int x = sizeof(xe);
+    char nullbyte;
+	int x = sizeof(nullbyte);
     
     TA_SERVER();
 
     mieqProcessInputEvents();
 
     // Empty the signaling pipe
-    while (x == sizeof(xe)) {
-      x = read(darwinEventReadFD, &xe, sizeof(xe));
+    while (x == sizeof(nullbyte)) {
+      x = read(darwinEventReadFD, &nullbyte, sizeof(nullbyte));
     }
 }
 
@@ -382,7 +366,7 @@ void ProcessInputEvents(void) {
 static void DarwinPokeEQ(void) {
 	char nullbyte=0;
 	//  <daniels> oh, i ... er ... christ.
-	write(darwinEventWriteFD, &nullbyte, 1);
+	write(darwinEventWriteFD, &nullbyte, sizeof(nullbyte));
 }
 
 /* Convert from Appkit pointer input values to X input values:
@@ -476,7 +460,7 @@ void DarwinSendPointerEvents(DeviceIntPtr pDev, int ev_type, int ev_button, floa
     darwinEvents_lock(); {
         num_events = GetPointerEvents(darwinEvents, pDev, ev_type, ev_button, 
                                       POINTER_ABSOLUTE, 0, pDev==darwinTabletCurrent?5:2, valuators);
-        for(i=0; i<num_events; i++) mieqEnqueue (pDev, darwinEvents[i].event);
+        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
         if(num_events > 0) DarwinPokeEQ();
     } darwinEvents_unlock();
 }
@@ -491,7 +475,7 @@ void DarwinSendKeyboardEvents(int ev_type, int keycode) {
 
     darwinEvents_lock(); {
         num_events = GetKeyboardEvents(darwinEvents, darwinKeyboard, ev_type, keycode + MIN_KEYCODE);
-        for(i=0; i<num_events; i++) mieqEnqueue(darwinKeyboard,darwinEvents[i].event);
+        for(i=0; i<num_events; i++) mieqEnqueue(darwinKeyboard, (InternalEvent*)darwinEvents[i].event);
         if(num_events > 0) DarwinPokeEQ();
     } darwinEvents_unlock();
 }
@@ -519,7 +503,7 @@ void DarwinSendProximityEvents(int ev_type, float pointer_x, float pointer_y) {
     darwinEvents_lock(); {
         num_events = GetProximityEvents(darwinEvents, pDev, ev_type,
                                         0, 5, valuators);
-        for(i=0; i<num_events; i++) mieqEnqueue (pDev,darwinEvents[i].event);
+        for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
         if(num_events > 0) DarwinPokeEQ();
     } darwinEvents_unlock();
 }
@@ -566,27 +550,26 @@ void DarwinUpdateModKeys(int flags) {
  *  Send the X server thread a message by placing it on the event queue.
  */
 void DarwinSendDDXEvent(int type, int argc, ...) {
-    xEvent xe;
-    INT32 *argv;
-    int i, max_args;
+    XQuartzEvent e;
+    int i;
     va_list args;
 
-    memset(&xe, 0, sizeof(xe));
-    xe.u.u.type = type;
-    xe.u.clientMessage.u.l.type = type;
-
-    argv = &xe.u.clientMessage.u.l.longs0;
-    max_args = 4;
+    memset(&e, 0, sizeof(e));
+    e.header = ET_Internal;
+    e.type = ET_XQuartz;
+    e.length = sizeof(e);
+    e.time = GetTimeInMillis();
+    e.subtype = type;
 
-    if (argc > 0 && argc <= max_args) {
+    if (argc > 0 && argc < XQUARTZ_EVENT_MAXARGS) {
         va_start (args, argc);
         for (i = 0; i < argc; i++)
-            argv[i] = (int) va_arg (args, int);
+            e.data[i] = (uint32_t) va_arg (args, uint32_t);
         va_end (args);
     }
 
     darwinEvents_lock(); {
-        mieqEnqueue(NULL, &xe);
+        mieqEnqueue(NULL, (InternalEvent*)&e);
         DarwinPokeEQ();
     } darwinEvents_unlock();
 }
diff --git a/hw/xquartz/darwinEvents.h b/hw/xquartz/darwinEvents.h
index 126851422..590305f3e 100644
--- a/hw/xquartz/darwinEvents.h
+++ b/hw/xquartz/darwinEvents.h
@@ -45,17 +45,14 @@ void DarwinUpdateModKeys(int flags);
 void DarwinListenOnOpenFD(int fd);
 
 /*
- * Special ddx events understood by the X server
+ * Subtypes for the ET_XQuartz event type
  */
 enum {
-    kXquartzReloadKeymap      // Reload system keymap
-    = LASTEvent+1,    // (from X.h list of event names)
+    kXquartzReloadKeymap,     // Reload system keymap
     kXquartzActivate,         // restore X drawing and cursor
     kXquartzDeactivate,       // clip X drawing and switch to Aqua cursor
     kXquartzSetRootClip,      // enable or disable drawing to the X screen
     kXquartzQuit,             // kill the X server and release the display
-    kXquartzReadPasteboard,   // copy Mac OS X pasteboard into X cut buffer
-    kXquartzWritePasteboard,  // copy X cut buffer onto Mac OS X pasteboard
     kXquartzBringAllToFront,  // bring all X windows to front
     kXquartzToggleFullscreen, // Enable/Disable fullscreen mode
     kXquartzSetRootless,      // Set rootless mode
diff --git a/hw/xquartz/quartz.c b/hw/xquartz/quartz.c
index ca8b24595..64933135d 100644
--- a/hw/xquartz/quartz.c
+++ b/hw/xquartz/quartz.c
@@ -231,7 +231,7 @@ RREditConnectionInfo (ScreenPtr pScreen)
 }
 #endif
 
-static void QuartzUpdateScreens(void) {
+void QuartzUpdateScreens(void) {
     ScreenPtr pScreen;
     WindowPtr pRoot;
     int x, y, width, height, sx, sy;
@@ -299,14 +299,6 @@ static void QuartzUpdateScreens(void) {
 #endif    
 }
 
-/*
- * QuartzDisplayChangeHandler
- *  Adjust for screen arrangement changes.
- */
-void QuartzDisplayChangedHandler(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents) {
-    QuartzUpdateScreens();
-}
-
 void QuartzSetFullscreen(Bool state) {
     
     DEBUG_LOG("QuartzSetFullscreen: state=%d\n", state);
@@ -374,10 +366,7 @@ void QuartzSetRootless(Bool state) {
  *  Calls mode specific screen resume to restore the X clip regions
  *  (if needed) and the X server cursor state.
  */
-void QuartzShow(
-    int x,      // cursor location
-    int y )
-{
+void QuartzShow() {
     int i;
 
     if (quartzServerVisible)
@@ -386,7 +375,7 @@ void QuartzShow(
     quartzServerVisible = TRUE;
     for (i = 0; i < screenInfo.numScreens; i++) {
         if (screenInfo.screens[i]) {
-            quartzProcs->ResumeScreen(screenInfo.screens[i], x, y);
+            quartzProcs->ResumeScreen(screenInfo.screens[i]);
         }
     }
     
diff --git a/hw/xquartz/quartz.h b/hw/xquartz/quartz.h
index c5da4c510..64ef122ae 100644
--- a/hw/xquartz/quartz.h
+++ b/hw/xquartz/quartz.h
@@ -33,8 +33,6 @@
 #ifndef _QUARTZ_H
 #define _QUARTZ_H
 
-#include "quartzPasteboard.h"
-
 #include "screenint.h"
 #include "window.h"
 
@@ -59,7 +57,7 @@ typedef Bool (*InitCursorProc)(ScreenPtr pScreen);
  * Suspend and resume X11 activity
  */
 typedef void (*SuspendScreenProc)(ScreenPtr pScreen);
-typedef void (*ResumeScreenProc)(ScreenPtr pScreen, int x, int y);
+typedef void (*ResumeScreenProc)(ScreenPtr pScreen);
 
 /*
  * Screen state change support
@@ -123,9 +121,9 @@ void QuartzInitInput(int argc, char **argv);
 void QuartzInitServer(int argc, char **argv, char **envp);
 void QuartzGiveUp(void);
 void QuartzProcessEvent(xEvent *xe);
-void QuartzDisplayChangedHandler(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents);
+void QuartzUpdateScreens(void);
 
-void QuartzShow(int x, int y); // (x, y) = cursor loc
+void QuartzShow(void);
 void QuartzHide(void);
 void QuartzSetRootClip(BOOL enable);
 void QuartzSpaceChanged(uint32_t space_id);
diff --git a/hw/xquartz/quartzCocoa.m b/hw/xquartz/quartzCocoa.m
index 0ab94936c..450147207 100644
--- a/hw/xquartz/quartzCocoa.m
+++ b/hw/xquartz/quartzCocoa.m
@@ -40,67 +40,10 @@
 
 #include "quartzCommon.h"
 #include "inputstr.h"
-#include "quartzPasteboard.h"
 
 #include "darwin.h"
 
 /*
- * QuartzWriteCocoaPasteboard
- *  Write text to the Mac OS X pasteboard.
- */
-void QuartzWriteCocoaPasteboard(
-    char *text)
-{
-    NSPasteboard *pasteboard;
-    NSArray *pasteboardTypes;
-    NSString *string;
-
-    if (! text) return;
-    pasteboard = [NSPasteboard generalPasteboard];
-    if (! pasteboard) return;
-    string = [NSString stringWithCString:text];
-    if (! string) return;
-    pasteboardTypes = [NSArray arrayWithObject:NSStringPboardType];
-
-    // nil owner because we don't provide type translations
-    [pasteboard declareTypes:pasteboardTypes owner:nil];
-    [pasteboard setString:string forType:NSStringPboardType];
-}
-
-
-/*
- * QuartzReadCocoaPasteboard
- *  Read text from the Mac OS X pasteboard and return it as a heap string.
- *  The caller must free the string.
- */
-char *QuartzReadCocoaPasteboard(void)
-{
-    NSPasteboard *pasteboard;
-    NSArray *pasteboardTypes;
-    NSString *existingType;
-    char *text = NULL;
-
-    pasteboardTypes = [NSArray arrayWithObject:NSStringPboardType];
-    pasteboard = [NSPasteboard generalPasteboard];
-    if (! pasteboard) return NULL;
-
-    existingType = [pasteboard availableTypeFromArray:pasteboardTypes];
-    if (existingType) {
-        NSString *string = [pasteboard stringForType:existingType];
-        char *buffer;
-
-        if (! string) return NULL;
-        buffer = (char *) [string UTF8String];
-        text = (char *) malloc(strlen(buffer)+1);
-        if (text)
-            strcpy(text, buffer);
-    }
-
-    return text;
-}
-
-
-/*
  * QuartzFSUseQDCursor
  *  Return whether the screen should use a QuickDraw cursor.
  */
diff --git a/hw/xquartz/quartzKeyboard.c b/hw/xquartz/quartzKeyboard.c
index 503383f91..b3a4eccfb 100644
--- a/hw/xquartz/quartzKeyboard.c
+++ b/hw/xquartz/quartzKeyboard.c
@@ -354,7 +354,7 @@ void DarwinKeyboardInit(DeviceIntPtr pDev) {
     CopyKeyClass(pDev, inputInfo.keyboard);
 }
 
-void DarwinKeyboardReloadHandler(int screenNum, xEventPtr xe, DeviceIntPtr pDev, int nevents) {
+void DarwinKeyboardReloadHandler(void) {
     KeySymsRec keySyms;
 
     DEBUG_LOG("DarwinKeyboardReloadHandler\n");
diff --git a/hw/xquartz/quartzKeyboard.h b/hw/xquartz/quartzKeyboard.h
index 215a4a9a5..1aaec6ef2 100644
--- a/hw/xquartz/quartzKeyboard.h
+++ b/hw/xquartz/quartzKeyboard.h
@@ -53,7 +53,7 @@ Bool QuartzReadSystemKeymap(darwinKeyboardInfo *info);
 /* Provided for darwinEvents.c */
 extern darwinKeyboardInfo keyInfo;
 extern pthread_mutex_t keyInfo_mutex;
-void DarwinKeyboardReloadHandler(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents);
+void DarwinKeyboardReloadHandler(void);
 int DarwinModifierNXKeycodeToNXKey(unsigned char keycode, int *outSide);
 int DarwinModifierNXKeyToNXKeycode(int key, int side);
 int DarwinModifierNXKeyToNXMask(int key);
diff --git a/hw/xquartz/quartzPasteboard.c b/hw/xquartz/quartzPasteboard.c
deleted file mode 100644
index 60bcabe4c..000000000
--- a/hw/xquartz/quartzPasteboard.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/**************************************************************
- * quartzPasteboard.c
- *
- * Aqua pasteboard <-> X cut buffer
- * Greg Parker     gparker@cs.stanford.edu     March 8, 2001
- **************************************************************/
-/*
- * Copyright (c) 2001 Greg Parker. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name(s) of the above copyright
- * holders shall not be used in advertising or otherwise to promote the sale,
- * use or other dealings in this Software without prior written authorization.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "misc.h"
-#include "inputstr.h"
-#include "quartzPasteboard.h"
-
-#include <X11/Xatom.h>
-#include "windowstr.h"
-#include "propertyst.h"
-#include "scrnintstr.h"
-#include "selection.h"
-#include "globals.h"
-
-
-// Helper function to read the X11 cut buffer
-// FIXME: What about multiple screens? Currently, this reads the first
-// CUT_BUFFER0 from the first screen where the buffer content is a string.
-// Returns a string on the heap that the caller must free.
-// Returns NULL if there is no cut text or there is not enough memory.
-static char * QuartzReadCutBuffer(void)
-{
-    int rc, i;
-    char *text = NULL;
-
-    for (i = 0; i < screenInfo.numScreens; i++) {
-        ScreenPtr pScreen = screenInfo.screens[i];
-        PropertyPtr pProp;
-
-	rc = dixLookupProperty(&pProp, WindowTable[pScreen->myNum],
-			       XA_CUT_BUFFER0, serverClient, DixReadAccess);
-        if (rc != Success) continue;
-        if (pProp->type != XA_STRING) continue;
-        if (pProp->format != 8) continue;
-
-        text = xalloc(1 + pProp->size);
-        if (! text) continue;
-        memcpy(text, pProp->data, pProp->size);
-        text[pProp->size] = '\0';
-        return text;
-    }
-
-    // didn't find any text
-    return NULL;
-}
-
-// Write X cut buffer to Mac OS X pasteboard
-// Called by mieqProcessInputEvents() in response to request from X server thread.
-void QuartzWritePasteboard(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents)
-{
-    char *text;
-    text = QuartzReadCutBuffer();
-    if (text) {
-        QuartzWriteCocoaPasteboard(text);
-        free(text);
-    }
-}
-
-#define strequal(a, b) (0 == strcmp((a), (b)))
-
-// Read Mac OS X pasteboard into X cut buffer
-// Called by mieqProcessInputEvents() in response to request from X server thread.
-void QuartzReadPasteboard(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents)
-{
-    char *oldText = QuartzReadCutBuffer();
-    char *text = QuartzReadCocoaPasteboard();
-
-    // Compare text with current cut buffer contents.
-    // Change the buffer if both exist and are different
-    //   OR if there is new text but no old text.
-    // Otherwise, don't clear the selection unnecessarily.
-
-    if ((text && oldText && !strequal(text, oldText)) ||
-        (text && !oldText)) {
-        int scrn, rc;
-	Selection *pSel;
-
-        for (scrn = 0; scrn < screenInfo.numScreens; scrn++) {
-	    ScreenPtr pScreen = screenInfo.screens[scrn];
-	    // Set the cut buffers on each screen
-	    // fixme really on each screen?
-	    dixChangeWindowProperty(serverClient, WindowTable[pScreen->myNum],
-				    XA_CUT_BUFFER0, XA_STRING, 8, PropModeReplace,
-				    strlen(text), (pointer)text, TRUE);
-        }
-
-        // Undo any current X selection (similar to code in dispatch.c)
-        // FIXME: what about secondary selection?
-        // FIXME: only touch first XA_PRIMARY selection?
-	rc = dixLookupSelection(&pSel, XA_PRIMARY, serverClient,
-				DixSetAttrAccess);
-        if (rc == Success) {
-	    // Notify client if necessary
-	    if (pSel->client) {
-	        xEvent event;
-
-	        event.u.u.type = SelectionClear;
-		event.u.selectionClear.time = GetTimeInMillis();
-		event.u.selectionClear.window = pSel->window;
-		event.u.selectionClear.atom = pSel->selection;
-		TryClientEvents(pSel->client, dev, &event, 1, NoEventMask,
-				NoEventMask /*CantBeFiltered*/, NullGrab);
-	    }
-
-	    // Erase it
-	    pSel->pWin = NullWindow;
-	    pSel->window = None;
-	    pSel->client = NullClient;
-        }
-    }
-
-    if (text) free(text);
-    if (oldText) free(oldText);
-}
diff --git a/hw/xquartz/quartzPasteboard.h b/hw/xquartz/quartzPasteboard.h
deleted file mode 100644
index b51cd88e0..000000000
--- a/hw/xquartz/quartzPasteboard.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/* 
-   QuartzPasteboard.h
-
-   Mac OS X pasteboard <-> X cut buffer
-   Greg Parker     gparker@cs.stanford.edu     March 8, 2001
-*/
-/*
- * Copyright (c) 2001 Greg Parker. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name(s) of the above copyright
- * holders shall not be used in advertising or otherwise to promote the sale,
- * use or other dealings in this Software without prior written authorization.
- */
-
-#ifndef _QUARTZPASTEBOARD_H
-#define _QUARTZPASTEBOARD_H
-
-// Aqua->X 
-void QuartzReadPasteboard(int, xEventPtr, DeviceIntPtr, int);
-char * QuartzReadCocoaPasteboard(void);	// caller must free string
-
-// X->Aqua
-void QuartzWritePasteboard(int, xEventPtr, DeviceIntPtr, int);
-void QuartzWriteCocoaPasteboard(char *text);
-
-#endif	/* _QUARTZPASTEBOARD_H */
diff --git a/hw/xquartz/xpr/xpr.h b/hw/xquartz/xpr/xpr.h
index c657e1586..af1a90ca0 100644
--- a/hw/xquartz/xpr/xpr.h
+++ b/hw/xquartz/xpr/xpr.h
@@ -45,7 +45,7 @@ void xprHideWindows(Bool hide);
 
 Bool QuartzInitCursor(ScreenPtr pScreen);
 void QuartzSuspendXCursor(ScreenPtr pScreen);
-void QuartzResumeXCursor(ScreenPtr pScreen, int x, int y);
+void QuartzResumeXCursor(ScreenPtr pScreen);
 
 /* If we are rooted, we need the root window and desktop levels to be below
  * the menubar (24) but above native windows.  Normal window level is 0.
diff --git a/hw/xquartz/xpr/xprCursor.c b/hw/xquartz/xpr/xprCursor.c
index 8c47b671c..84291a938 100644
--- a/hw/xquartz/xpr/xprCursor.c
+++ b/hw/xquartz/xpr/xprCursor.c
@@ -212,7 +212,7 @@ QuartzUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
  *  Set the cursor sprite and position.
  */
 static void
-QuartzSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
+QuartzSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 {
     QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
 
@@ -392,7 +392,7 @@ QuartzSuspendXCursor(ScreenPtr pScreen)
  *  X server is showing. Restore the X cursor.
  */
 void
-QuartzResumeXCursor(ScreenPtr pScreen, int x, int y)
+QuartzResumeXCursor(ScreenPtr pScreen)
 {
     WindowPtr pWin;
     CursorPtr pCursor;
@@ -407,5 +407,5 @@ QuartzResumeXCursor(ScreenPtr pScreen, int x, int y)
     if (pCursor == NULL)
         return;
 
-    QuartzSetCursor(darwinPointer, pScreen, pCursor, x, y);
+    QuartzSetCursor(darwinPointer, pScreen, pCursor);
 }
diff --git a/hw/xquartz/xpr/xprEvent.c b/hw/xquartz/xpr/xprEvent.c
index f8e985aba..6245cce42 100644
--- a/hw/xquartz/xpr/xprEvent.c
+++ b/hw/xquartz/xpr/xprEvent.c
@@ -39,6 +39,7 @@
 #include   "windowstr.h"
 #include   "pixmapstr.h"
 #include   "inputstr.h"
+#include   "eventstr.h"
 #include   "mi.h"
 #include   "scrnintstr.h"
 #include   "mipointer.h"
@@ -55,36 +56,26 @@
 #include "rootlessWindow.h"
 #include "xprEvent.h"
 
-static void xprEventHandler(int screenNum, xEventPtr xe, DeviceIntPtr dev, int nevents) {
-    int i;
-    
+Bool QuartzModeEventHandler(int screenNum, XQuartzEvent *e, DeviceIntPtr dev) {
     TA_SERVER();
     
-    DEBUG_LOG("DarwinEventHandler(%d, %p, %p, %d)\n", screenNum, xe, dev, nevents);
-    for (i=0; i<nevents; i++) {
-        switch(xe[i].u.u.type) {
-                
-            case kXquartzWindowState:
-                DEBUG_LOG("kXquartzWindowState\n");
-                RootlessNativeWindowStateChanged(xprGetXWindow(xe[i].u.clientMessage.u.l.longs0),
-                                                 xe[i].u.clientMessage.u.l.longs1);
-                break;
-                
-            case kXquartzWindowMoved:
-                DEBUG_LOG("kXquartzWindowMoved\n");
-                RootlessNativeWindowMoved(xprGetXWindow(xe[i].u.clientMessage.u.l.longs0));
-                break;
-                
-            case kXquartzBringAllToFront:
-                DEBUG_LOG("kXquartzBringAllToFront\n");
-                RootlessOrderAllWindows();
-                break;
-        }
+    switch(e->subtype) {
+        case kXquartzWindowState:
+            DEBUG_LOG("kXquartzWindowState\n");
+            RootlessNativeWindowStateChanged(xprGetXWindow(e->data[0]),
+                                             e->data[1]);
+            return TRUE;
+            
+        case kXquartzWindowMoved:
+            DEBUG_LOG("kXquartzWindowMoved\n");
+            RootlessNativeWindowMoved(xprGetXWindow(e->data[0]));
+            return TRUE;
+            
+        case kXquartzBringAllToFront:
+            DEBUG_LOG("kXquartzBringAllToFront\n");
+            RootlessOrderAllWindows();
+            return TRUE;
+        default:
+            return FALSE;
     }
 }
-
-void QuartzModeEQInit(void) {
-    mieqSetHandler(kXquartzWindowState, xprEventHandler);
-    mieqSetHandler(kXquartzWindowMoved, xprEventHandler);
-    mieqSetHandler(kXquartzBringAllToFront, xprEventHandler);
-}
diff --git a/hw/xquartz/xpr/xprEvent.h b/hw/xquartz/xpr/xprEvent.h
index 5af9dfd77..ebfa36bd8 100644
--- a/hw/xquartz/xpr/xprEvent.h
+++ b/hw/xquartz/xpr/xprEvent.h
@@ -29,6 +29,6 @@
 #ifndef __XPR_EVENT_H__
 #define __XPR_EVENT_H__
 
-void QuartzModeEQInit(void);
+Bool QuartzModeEventHandler(int screenNum, XQuartzEvent *e, DeviceIntPtr dev);
 
 #endif