Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 461 insertions, 0 deletions

diff --git a/xorg-server/hw/xquartz/darwinEvents.c b/xorg-server/hw/xquartz/darwinEvents.c
new file mode 100644
index 000000000..827fd81b8
--- /dev/null
+++ b/xorg-server/hw/xquartz/darwinEvents.c
@@ -0,0 +1,461 @@
+/*
+Darwin event queue and event handling
+
+Copyright 2007 Apple Inc.
+Copyright 2004 Kaleb S. KEITHLEY. All Rights Reserved.
+Copyright (c) 2002-2004 Torrey T. Lyons. All Rights Reserved.
+
+This file is based on mieq.c by Keith Packard,
+which contains the following copyright:
+Copyright 1990, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ */
+
+#define NEED_EVENTS
+#include   <X11/X.h>
+#include   <X11/Xmd.h>
+#include   <X11/Xproto.h>
+#include   "misc.h"
+#include   "windowstr.h"
+#include   "pixmapstr.h"
+#include   "inputstr.h"
+#include   "mi.h"
+#include   "scrnintstr.h"
+#include   "mipointer.h"
+
+#include "darwin.h"
+#include "quartz.h"
+#include "darwinKeyboard.h"
+#include "darwinEvents.h"
+
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <IOKit/hidsystem/IOLLEvent.h>
+
+/* Fake button press/release for scroll wheel move. */
+#define SCROLLWHEELUPFAKE   4
+#define SCROLLWHEELDOWNFAKE 5
+
+#define QUEUE_SIZE 256
+
+typedef struct _Event {
+    xEvent      event;
+    ScreenPtr   pScreen;
+} EventRec, *EventPtr;
+
+int input_check_zero, input_check_flag;
+
+static int old_flags = 0;  // last known modifier state
+
+typedef struct _EventQueue {
+    HWEventQueueType    head, tail; /* long for SetInputCheck */
+    CARD32      lastEventTime;      /* to avoid time running backwards */
+    Bool        lastMotion;
+    EventRec    events[QUEUE_SIZE]; /* static allocation for signals */
+    DevicePtr   pKbd, pPtr;         /* device pointer, to get funcs */
+    ScreenPtr   pEnqueueScreen;     /* screen events are being delivered to */
+    ScreenPtr   pDequeueScreen;     /* screen events are being dispatched to */
+} EventQueueRec, *EventQueuePtr;
+
+static EventQueueRec darwinEventQueue;
+xEvent *darwinEvents;
+
+/*
+ * DarwinPressModifierMask
+ *  Press or release the given modifier key, specified by its mask.
+ */
+static void DarwinPressModifierMask(
+    int pressed,				    
+    int mask)       // one of NX_*MASK constants
+{
+    int key = DarwinModifierNXMaskToNXKey(mask);
+
+    if (key != -1) {
+        int keycode = DarwinModifierNXKeyToNXKeycode(key, 0);
+        if (keycode != 0)
+	  DarwinSendKeyboardEvents(pressed, keycode);
+    }
+}
+
+#ifdef NX_DEVICELCTLKEYMASK
+#define CONTROL_MASK(flags) (flags & (NX_DEVICELCTLKEYMASK|NX_DEVICERCTLKEYMASK))
+#else
+#define CONTROL_MASK(flags) (NX_CONTROLMASK)
+#endif /* NX_DEVICELCTLKEYMASK */
+
+#ifdef NX_DEVICELSHIFTKEYMASK
+#define SHIFT_MASK(flags) (flags & (NX_DEVICELSHIFTKEYMASK|NX_DEVICERSHIFTKEYMASK))
+#else
+#define SHIFT_MASK(flags) (NX_SHIFTMASK)
+#endif /* NX_DEVICELSHIFTKEYMASK */
+
+#ifdef NX_DEVICELCMDKEYMASK
+#define COMMAND_MASK(flags) (flags & (NX_DEVICELCMDKEYMASK|NX_DEVICERCMDKEYMASK))
+#else
+#define COMMAND_MASK(flags) (NX_COMMANDMASK)
+#endif /* NX_DEVICELCMDKEYMASK */
+
+#ifdef NX_DEVICELALTKEYMASK
+#define ALTERNATE_MASK(flags) (flags & (NX_DEVICELALTKEYMASK|NX_DEVICERALTKEYMASK))
+#else
+#define ALTERNATE_MASK(flags) (NX_ALTERNATEMASK)
+#endif /* NX_DEVICELALTKEYMASK */
+
+/*
+ * DarwinUpdateModifiers
+ *  Send events to update the modifier state.
+ */
+static void DarwinUpdateModifiers(
+    int pressed,        // KeyPress or KeyRelease
+    int flags )         // modifier flags that have changed
+{
+    if (flags & NX_ALPHASHIFTMASK) {
+        DarwinPressModifierMask(pressed, NX_ALPHASHIFTMASK);
+    }
+    if (flags & NX_COMMANDMASK) {
+        DarwinPressModifierMask(pressed, COMMAND_MASK(flags));
+    }
+    if (flags & NX_CONTROLMASK) {
+        DarwinPressModifierMask(pressed, CONTROL_MASK(flags));
+    }
+    if (flags & NX_ALTERNATEMASK) {
+        DarwinPressModifierMask(pressed, ALTERNATE_MASK(flags));
+    }
+    if (flags & NX_SHIFTMASK) {
+        DarwinPressModifierMask(pressed, SHIFT_MASK(flags));
+    }
+    if (flags & NX_SECONDARYFNMASK) {
+        DarwinPressModifierMask(pressed, NX_SECONDARYFNMASK);
+    }
+}
+
+/*
+ * DarwinReleaseModifiers
+ * This hacky function releases all modifier keys.  It should be called when X11.app
+ * is deactivated (kXDarwinDeactivate) to prevent modifiers from getting stuck if they
+ * are held down during a "context" switch -- otherwise, we would miss the KeyUp.
+ */
+static void DarwinReleaseModifiers(void) {
+	DarwinUpdateModifiers(KeyRelease, COMMAND_MASK(-1) | CONTROL_MASK(-1) | ALTERNATE_MASK(-1) | SHIFT_MASK(-1));
+}
+
+/*
+ * DarwinSimulateMouseClick
+ *  Send a mouse click to X when multiple mouse buttons are simulated
+ *  with modifier-clicks, such as command-click for button 2. The dix
+ *  layer is told that the previously pressed modifier key(s) are
+ *  released, the simulated click event is sent. After the mouse button
+ *  is released, the modifier keys are reverted to their actual state,
+ *  which may or may not be pressed at that point. This is usually
+ *  closest to what the user wants. Ie. the user typically wants to
+ *  simulate a button 2 press instead of Command-button 2.
+ */
+static void DarwinSimulateMouseClick(
+    int pointer_x,
+    int pointer_y,
+    int whichButton,    // mouse button to be pressed
+    int modifierMask)   // modifiers used for the fake click
+{
+    // first fool X into forgetting about the keys
+	// for some reason, it's not enough to tell X we released the Command key -- 
+	// it has to be the *left* Command key.
+	if (modifierMask & NX_COMMANDMASK) modifierMask |=NX_DEVICELCMDKEYMASK ;
+    DarwinUpdateModifiers(KeyRelease, modifierMask);
+
+    // push the mouse button
+    DarwinSendPointerEvents(ButtonPress, whichButton, pointer_x, pointer_y);
+    DarwinSendPointerEvents(ButtonRelease, whichButton, pointer_x, pointer_y);
+
+    // restore old modifiers
+    DarwinUpdateModifiers(KeyPress, modifierMask);
+}
+
+
+Bool DarwinEQInit(DevicePtr pKbd, DevicePtr pPtr) { 
+    darwinEvents = (xEvent *)malloc(sizeof(xEvent) * GetMaximumEventsNum());
+    mieqInit();
+    darwinEventQueue.head = darwinEventQueue.tail = 0;
+    darwinEventQueue.lastEventTime = GetTimeInMillis ();
+    darwinEventQueue.pKbd = pKbd;
+    darwinEventQueue.pPtr = pPtr;
+    darwinEventQueue.pEnqueueScreen = screenInfo.screens[0];
+    darwinEventQueue.pDequeueScreen = darwinEventQueue.pEnqueueScreen;
+    SetInputCheck(&input_check_zero, &input_check_flag);
+    return TRUE;
+}
+
+
+/*
+ * DarwinEQEnqueue
+ *  Must be thread safe with ProcessInputEvents.
+ *    DarwinEQEnqueue    - called from event gathering thread
+ *    ProcessInputEvents - called from X server thread
+ *  DarwinEQEnqueue should never be called from more than one thread.
+ * 
+ * This should be deprecated in favor of miEQEnqueue -- BB
+ */
+void DarwinEQEnqueue(const xEventPtr e) {
+    HWEventQueueType oldtail, newtail;
+
+    oldtail = darwinEventQueue.tail;
+
+    // mieqEnqueue() collapses successive motion events into one event.
+    // This is difficult to do in a thread-safe way and rarely useful.
+
+    newtail = oldtail + 1;
+    if (newtail == QUEUE_SIZE) newtail = 0;
+    /* Toss events which come in late */
+    if (newtail == darwinEventQueue.head) return;
+
+    darwinEventQueue.events[oldtail].event = *e;
+
+    /*
+     * Make sure that event times don't go backwards - this
+     * is "unnecessary", but very useful
+     */
+    if (e->u.keyButtonPointer.time < darwinEventQueue.lastEventTime &&
+        darwinEventQueue.lastEventTime - e->u.keyButtonPointer.time < 10000)
+    {
+        darwinEventQueue.events[oldtail].event.u.keyButtonPointer.time =
+        darwinEventQueue.lastEventTime;
+    }
+    darwinEventQueue.events[oldtail].pScreen = darwinEventQueue.pEnqueueScreen;
+
+    // Update the tail after the event is prepared
+    darwinEventQueue.tail = newtail;
+
+    // Signal there is an event ready to handle
+    DarwinPokeEQ();
+}
+
+
+/*
+ * DarwinEQPointerPost
+ *  Post a pointer event. Used by the mipointer.c routines.
+ */
+void DarwinEQPointerPost(DeviceIntPtr pdev, xEventPtr e) {
+    (*darwinEventQueue.pPtr->processInputProc)
+            (e, (DeviceIntPtr)darwinEventQueue.pPtr, 1);
+}
+
+
+void DarwinEQSwitchScreen(ScreenPtr pScreen, Bool fromDIX) {
+    darwinEventQueue.pEnqueueScreen = pScreen;
+    if (fromDIX)
+        darwinEventQueue.pDequeueScreen = pScreen;
+}
+
+
+/*
+ * ProcessInputEvents
+ *  Read and process events from the event queue until it is empty.
+ */
+void ProcessInputEvents(void) {
+    EventRec *e;
+    int     x, y;
+    xEvent  xe;
+    // button number and modifier mask of currently pressed fake button
+    input_check_flag=0;
+
+    //    ErrorF("calling mieqProcessInputEvents\n");
+    mieqProcessInputEvents();
+
+    // Empty the signaling pipe
+    x = sizeof(xe);
+    while (x == sizeof(xe)) 
+        x = read(darwinEventReadFD, &xe, sizeof(xe));
+
+    while (darwinEventQueue.head != darwinEventQueue.tail)
+    {
+        if (screenIsSaved == SCREEN_SAVER_ON)
+            dixSaveScreens (serverClient, SCREEN_SAVER_OFF, ScreenSaverReset);
+
+        e = &darwinEventQueue.events[darwinEventQueue.head];
+        xe = e->event;
+
+        // Shift from global screen coordinates to coordinates relative to
+        // the origin of the current screen.
+        xe.u.keyButtonPointer.rootX -= darwinMainScreenX +
+                dixScreenOrigins[miPointerCurrentScreen()->myNum].x;
+        xe.u.keyButtonPointer.rootY -= darwinMainScreenY +
+                dixScreenOrigins[miPointerCurrentScreen()->myNum].y;
+	
+	/*	ErrorF("old rootX = (%d,%d) darwinMainScreen = (%d,%d) dixScreenOrigins[%d]=(%d,%d)\n",
+	       xe.u.keyButtonPointer.rootX, xe.u.keyButtonPointer.rootY,
+	       darwinMainScreenX, darwinMainScreenY,
+	       miPointerCurrentScreen()->myNum,
+	       dixScreenOrigins[miPointerCurrentScreen()->myNum].x,
+	       dixScreenOrigins[miPointerCurrentScreen()->myNum].y); */
+
+	//Assumption - screen switching can only occur on motion events
+
+        if (e->pScreen != darwinEventQueue.pDequeueScreen)
+        {
+            darwinEventQueue.pDequeueScreen = e->pScreen;
+            x = xe.u.keyButtonPointer.rootX;
+            y = xe.u.keyButtonPointer.rootY;
+            if (darwinEventQueue.head == QUEUE_SIZE - 1)
+                darwinEventQueue.head = 0;
+            else
+                ++darwinEventQueue.head;
+            NewCurrentScreen (darwinEventQueue.pDequeueScreen, x, y);
+        }
+        else
+        {
+            if (darwinEventQueue.head == QUEUE_SIZE - 1)
+                darwinEventQueue.head = 0;
+            else
+                ++darwinEventQueue.head;
+            switch (xe.u.u.type) {
+            case KeyPress:
+            case KeyRelease:
+	      ErrorF("Unexpected Keyboard event in DarwinProcessInputEvents\n");
+	      break;
+
+            case ButtonPress:
+	      ErrorF("Unexpected ButtonPress event in DarwinProcessInputEvents\n");
+                break;
+
+            case ButtonRelease:
+	      ErrorF("Unexpected ButtonRelease event in DarwinProcessInputEvents\n");
+                break;
+
+            case MotionNotify:
+	      ErrorF("Unexpected ButtonRelease event in DarwinProcessInputEvents\n");
+                break;
+
+            case kXDarwinUpdateModifiers:
+	      ErrorF("Unexpected ButtonRelease event in DarwinProcessInputEvents\n");
+	      break;
+
+            case kXDarwinUpdateButtons:
+	      ErrorF("Unexpected XDarwinScrollWheel event in DarwinProcessInputEvents\n");
+	      break;
+
+            case kXDarwinScrollWheel: 
+	      ErrorF("Unexpected XDarwinScrollWheel event in DarwinProcessInputEvents\n");
+	      break;
+
+			case kXDarwinDeactivate:
+				DarwinReleaseModifiers();
+				// fall through
+            default:
+                // Check for mode specific event
+                QuartzProcessEvent(&xe);
+            }
+        }
+    }
+
+    //    miPointerUpdate();
+}
+
+/* Sends a null byte down darwinEventWriteFD, which will cause the
+   Dispatch() event loop to check out event queue */
+void DarwinPokeEQ(void) {
+  char nullbyte=0;
+  input_check_flag++;
+  //  <daniels> bushing: oh, i ... er ... christ.
+  write(darwinEventWriteFD, &nullbyte, 1);
+}
+
+void DarwinSendPointerEvents(int ev_type, int ev_button, int pointer_x, int pointer_y) {
+  static int darwinFakeMouseButtonDown = 0;
+  static int darwinFakeMouseButtonMask = 0;
+  int i, num_events;
+  int valuators[2] = {pointer_x, pointer_y};
+  if (ev_type == ButtonPress && darwinFakeButtons && ev_button == 1) {
+    // Mimic multi-button mouse with modifier-clicks
+    // If both sets of modifiers are pressed,
+    // button 2 is clicked.
+    if ((old_flags & darwinFakeMouse2Mask) == darwinFakeMouse2Mask) {
+      DarwinSimulateMouseClick(pointer_x, pointer_y, 2, darwinFakeMouse2Mask);
+      darwinFakeMouseButtonDown = 2;
+      darwinFakeMouseButtonMask = darwinFakeMouse2Mask;
+    } else if ((old_flags & darwinFakeMouse3Mask) == darwinFakeMouse3Mask) {
+      DarwinSimulateMouseClick(pointer_x, pointer_y, 3, darwinFakeMouse3Mask);
+      darwinFakeMouseButtonDown = 3;
+      darwinFakeMouseButtonMask = darwinFakeMouse3Mask;
+    }
+  }
+  if (ev_type == ButtonRelease && darwinFakeButtons && darwinFakeMouseButtonDown) {
+    // If last mousedown was a fake click, don't check for
+    // mouse modifiers here. The user may have released the
+    // modifiers before the mouse button.
+    ev_button = darwinFakeMouseButtonDown;
+    darwinFakeMouseButtonDown = 0;
+    // Bring modifiers back up to date
+    DarwinUpdateModifiers(KeyPress, darwinFakeMouseButtonMask & old_flags);
+    darwinFakeMouseButtonMask = 0;
+  } 
+
+  num_events = GetPointerEvents(darwinEvents, darwinPointer, ev_type, ev_button, 
+				POINTER_ABSOLUTE, 0, 2, valuators);
+      
+  for(i=0; i<num_events; i++) mieqEnqueue (darwinPointer,&darwinEvents[i]);
+  DarwinPokeEQ();
+}
+
+void DarwinSendKeyboardEvents(int ev_type, int keycode) {
+  int i, num_events;
+  if (old_flags == 0 && darwinSyncKeymap && darwinKeymapFile == NULL) {
+    /* See if keymap has changed. */
+
+    static unsigned int last_seed;
+    unsigned int this_seed;
+
+    this_seed = QuartzSystemKeymapSeed();
+    if (this_seed != last_seed) {
+      last_seed = this_seed;
+      DarwinKeyboardReload(darwinKeyboard);
+    }
+  }
+
+  num_events = GetKeyboardEvents(darwinEvents, darwinKeyboard, ev_type, keycode + MIN_KEYCODE);
+  for(i=0; i<num_events; i++) mieqEnqueue(darwinKeyboard,&darwinEvents[i]);
+  DarwinPokeEQ();
+}
+
+/* Send the appropriate number of button 4 / 5 clicks to emulate scroll wheel */
+void DarwinSendScrollEvents(float count, int pointer_x, int pointer_y) {
+  int i;
+  int ev_button = count > 0.0f ? 4 : 5;
+  int valuators[2] = {pointer_x, pointer_y};
+
+  for (count = fabs(count); count > 0.0; count = count - 1.0f) {
+    int num_events = GetPointerEvents(darwinEvents, darwinPointer, ButtonPress, ev_button, 
+				      POINTER_ABSOLUTE, 0, 2, valuators);
+    for(i=0; i<num_events; i++) mieqEnqueue(darwinPointer,&darwinEvents[i]);
+    num_events = GetPointerEvents(darwinEvents, darwinPointer, ButtonRelease, ev_button, 
+				      POINTER_ABSOLUTE, 0, 2, valuators);
+    for(i=0; i<num_events; i++) mieqEnqueue(darwinPointer,&darwinEvents[i]);
+  }
+  DarwinPokeEQ();
+}
+
+/* Send the appropriate KeyPress/KeyRelease events to GetKeyboardEvents to
+   reflect changing modifier flags (alt, control, meta, etc) */
+void DarwinUpdateModKeys(int flags) {
+  DarwinUpdateModifiers(KeyRelease, old_flags & ~flags);
+  DarwinUpdateModifiers(KeyPress, ~old_flags & flags);
+  old_flags = flags;
+}