Separated several classes into header files from tool main.cpp
[synfig.git] / synfig-osx / launcher / darwin.c
1 /**************************************************************
2  *
3  * Shared code for the Darwin X Server
4  * running with Quartz or the IOKit
5  *
6  **************************************************************/
7 /*
8  * Copyright (c) 2001-2002 Torrey T. Lyons. All Rights Reserved.
9  * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
10  *
11  * Permission is hereby granted, free of charge, to any person obtaining a
12  * copy of this software and associated documentation files (the "Software"),
13  * to deal in the Software without restriction, including without limitation
14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15  * and/or sell copies of the Software, and to permit persons to whom the
16  * Software is furnished to do so, subject to the following conditions:
17  *
18  * The above copyright notice and this permission notice shall be included in
19  * all copies or substantial portions of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24  * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
25  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27  * DEALINGS IN THE SOFTWARE.
28  *
29  * Except as contained in this notice, the name(s) of the above copyright
30  * holders shall not be used in advertising or otherwise to promote the sale,
31  * use or other dealings in this Software without prior written authorization.
32  */
33 /* $XFree86: xc/programs/Xserver/hw/darwin/darwin.c,v 1.45 2002/03/28 02:21:08 torrey Exp $ */
34
35 #include <CoreGraphics/CoreGraphics.h>
36
37 #include "X.h"
38 #include "Xproto.h"
39 #include "os.h"
40 #include "servermd.h"
41 #include "inputstr.h"
42 #include "scrnintstr.h"
43 #include "mibstore.h"           // mi backing store implementation
44 #include "mipointer.h"          // mi software cursor
45 #include "micmap.h"             // mi colormap code
46 #include "fb.h"                 // fb framebuffer code
47 #include "site.h"
48 #include "globals.h"
49 #include "xf86Version.h"
50 #include "dix.h"
51 #include "dri-surface.h"
52 #define _APPLEDRI_SERVER_
53 #include "appledristr.h"
54
55 #include <sys/types.h>
56 #include <sys/time.h>
57 #include <sys/syslimits.h>
58 #include <stdio.h>
59 #include <fcntl.h>
60 #include <unistd.h>
61 #include <dirent.h>
62
63 #define NO_CFPLUGIN
64 #include <IOKit/IOKitLib.h>
65 #include <IOKit/hidsystem/IOHIDLib.h>
66 #include <IOKit/hidsystem/ev_keymap.h>
67
68 #include "darwin.h"
69 #include "quartz.h"
70 #include "rootless-common.h"
71 #include "pseudoramiX.h"
72 #include "X11Application.h"
73
74 /* Fake button press/release for scroll wheel move. */
75 #define SCROLLWHEELUPFAKE       4
76 #define SCROLLWHEELDOWNFAKE     5
77
78 /* X server shared global variables */
79 int darwinScreensFound = 0;
80 int darwinScreenIndex = 0;
81 int darwinFakeButtons = 1;
82 Bool darwinSwapAltMeta = FALSE;
83
84 /* location of X11's (0,0) point in global screen coordinates */
85 int darwinMainScreenX = 0;
86 int darwinMainScreenY = 0;
87
88 /* parameters read from the command line or user preferences */
89 char *darwinKeymapFile;
90 Bool darwinSyncKeymap = TRUE;
91
92 /* modifier masks for faking mouse buttons */
93 static int darwinFakeMouse2Mask = Mod1Mask;     /* option */
94 static int darwinFakeMouse3Mask = Mod2Mask;     /* command */
95
96 static DeviceIntPtr darwinPointer;
97 static DeviceIntPtr darwinKeyboard;
98
99 /* Track our view of the keyboard state. Everything we sent to dix will
100    be represented here until released. */
101 static CARD8 keysDown[DOWN_LENGTH];
102 static int lockMods;
103
104 #define SetBit(ptr,bit) \
105     do {((BYTE *) ptr)[(bit) >> 3] |= (1 << ((bit) & 7));} while (0)
106
107 #define ClearBit(ptr,bit) \
108     do {((BYTE *) ptr)[(bit) >> 3] &= ~(1 << ((bit) & 7));} while (0)
109
110 /* Common pixmap formats */
111 static PixmapFormatRec formats[] = {
112         { 1,    1,      BITMAP_SCANLINE_PAD },
113         { 4,    8,      BITMAP_SCANLINE_PAD },
114         { 8,    8,      BITMAP_SCANLINE_PAD },
115         { 15,   16,     BITMAP_SCANLINE_PAD },
116         { 16,   16,     BITMAP_SCANLINE_PAD },
117         { 24,   32,     BITMAP_SCANLINE_PAD },
118         { 32,   32,     BITMAP_SCANLINE_PAD }
119 };
120 const int NUMFORMATS = sizeof(formats)/sizeof(formats[0]);
121
122 #ifndef OSNAME
123 #define OSNAME " Mac OS X"
124 #endif
125 #ifndef OSVENDOR
126 #define OSVENDOR " Apple"
127 #endif
128 #ifndef PRE_RELEASE
129 #define PRE_RELEASE XF86_VERSION_SNAP
130 #endif
131
132 extern void AppleDRIExtensionInit(void);
133 extern void AppleWMExtensionInit(void);
134
135 static void
136 DarwinPrintBanner (void)
137 {
138   ErrorF("\nXFree86 Version %d.%d.%d", XF86_VERSION_MAJOR, XF86_VERSION_MINOR,
139                                     XF86_VERSION_PATCH);
140 #if XF86_VERSION_SNAP > 0
141   ErrorF(".%d", XF86_VERSION_SNAP);
142 #endif
143
144 #if XF86_VERSION_SNAP >= 900
145   ErrorF(" (%d.%d.0 RC %d)", XF86_VERSION_MAJOR, XF86_VERSION_MINOR + 1,
146                                 XF86_VERSION_SNAP - 900);
147 #endif
148
149 #ifdef XF86_CUSTOM_VERSION
150   ErrorF(" (%s)", XF86_CUSTOM_VERSION);
151 #endif
152   ErrorF(" / X Window System\n");
153   ErrorF("(protocol Version %d, revision %d, vendor release %d)\n",
154          X_PROTOCOL, X_PROTOCOL_REVISION, VENDOR_RELEASE );
155 }
156
157 /* X screensaver support. Not implemented. */
158 static Bool
159 DarwinSaveScreen (ScreenPtr pScreen, int on)
160 {
161     return TRUE;
162 }
163
164 /* This is a callback from dix during AddScreen() from InitOutput().
165    Initialize the screen and communicate information about it back to dix. */
166 static Bool
167 DarwinAddScreen (int index, ScreenPtr pScreen, int argc, char **argv)
168 {
169     int         i, dpi;
170     static int  foundIndex = 0;
171     Bool        ret;
172     VisualPtr   visual;
173     DarwinFramebufferPtr dfb;
174
175     /* reset index of found screens for each server generation */
176     if (index == 0)
177         foundIndex = 0;
178
179     /* allocate space for private per screen storage */
180     dfb = xalloc (sizeof (DarwinFramebufferRec));
181     SCREEN_PRIV(pScreen) = dfb;
182
183     /* setup hardware/mode specific details */
184     ret = QuartzAddScreen (foundIndex, pScreen);
185     foundIndex++;
186     if (!ret)
187         return FALSE;
188
189     /* reset the visual list */
190     miClearVisualTypes();
191
192     /* setup a single visual appropriate for our pixel type. Note: we use
193        TrueColor, not DirectColor */
194     if (dfb->componentCount != 1)
195     {
196         if (!miSetVisualTypes (dfb->colorBitsPerPixel, TrueColorMask,
197                                dfb->bitsPerComponent, TrueColor))
198             return FALSE;
199 #ifdef ENABLE_PSEUDOCOLOR
200         /* FIXME: currently we can't handle pseudocolor windows
201            inside truecolor top-level windows, so disable this. */
202         if (!miSetVisualTypes (8, PseudoColorMask, 8, PseudoColor))
203             return FALSE;
204 #endif
205     }
206     else
207     {
208         if (!miSetVisualTypes (8, PseudoColorMask, 8, PseudoColor))
209             return FALSE;
210     }
211
212     /* create the common 8 bit PseudoColor visual; do this last to prevent
213        it becoming the root visual. */
214
215     miSetPixmapDepths();
216
217     /* Machine independent screen init */
218     if (monitorResolution)
219         dpi = monitorResolution;
220     else
221         dpi = 75;
222
223     /* initialize fb */
224     if (!fbScreenInit (pScreen, dfb->framebuffer, dfb->width,
225                        dfb->height, dpi, dpi,
226                        dfb->pitch/(dfb->bitsPerPixel/8), dfb->bitsPerPixel))
227     {
228         return FALSE;
229     }
230
231     /* set the RGB order correctly for TrueColor */
232     if (dfb->bitsPerPixel > 8)
233     {
234         int bitsPerRGB = dfb->bitsPerComponent;
235
236         for (i = 0, visual = pScreen->visuals;
237             i < pScreen->numVisuals; i++, visual++)
238         {
239             if (visual->class == TrueColor) {
240                 visual->offsetRed = bitsPerRGB * 2;
241                 visual->offsetGreen = bitsPerRGB;
242                 visual->offsetBlue = 0;
243                 visual->redMask = ((1<<bitsPerRGB)-1) << visual->offsetRed;
244                 visual->greenMask = ((1<<bitsPerRGB)-1) << visual->offsetGreen;
245                 visual->blueMask = ((1<<bitsPerRGB)-1) << visual->offsetBlue;
246             }
247         }
248     }
249
250 #ifdef RENDER
251     if (! fbPictureInit (pScreen, 0, 0))
252         return FALSE;
253 #endif
254
255 #ifdef MITSHM
256     ShmRegisterFbFuncs (pScreen);
257 #endif
258
259     /* this must be initialized (why doesn't X have a default?) */
260     pScreen->SaveScreen = DarwinSaveScreen;
261
262     /* finish mode dependent screen setup including cursor support */
263     if (!QuartzSetupScreen (index, pScreen))
264         return FALSE;
265
266     /* create and install the default colormap and set black / white pixels */
267     if (!miCreateDefColormap (pScreen))
268         return FALSE;
269
270     dixScreenOrigins[index].x = dfb->x;
271     dixScreenOrigins[index].y = dfb->y;
272
273     ErrorF("Screen %d added: %dx%d @ (%d,%d)\n",
274             index, dfb->width, dfb->height, dfb->x, dfb->y);
275
276     return TRUE;
277 }
278
279 /* Search for a file in the standard Library paths, which are (in order):
280
281       ~/Library/              user specific
282       /Library/               host specific
283       /Network/Library/       LAN specific
284       /System/Library/        OS specific
285
286    A sub-path can be specified to search in below the various Library
287    directories. Returns a new character string (owned by the caller)
288    containing the full path to the first file found. */
289
290 /* Library search paths */
291 static const char *libraryPathList[] = {
292     "",
293     "/Network",
294     "/System",
295     NULL
296 };
297
298 char *
299 DarwinFindLibraryFile (const char *file, const char *pathext)
300 {
301     char *home;
302     char *fullPath;
303     int i = 0;
304
305     // Return the file name as is if it is already a fully qualified path.
306     if (!access(file, F_OK)) {
307         fullPath = xalloc(strlen(file)+1);
308         strcpy(fullPath, file);
309         return fullPath;
310     }
311
312     fullPath = xalloc(PATH_MAX);
313
314     home = getenv("HOME");
315     if (home) {
316         snprintf(fullPath, PATH_MAX, "%s/Library/%s/%s", home, pathext, file);
317         if (!access(fullPath, F_OK))
318             return fullPath;
319     }
320
321     while (libraryPathList[i]) {
322         snprintf(fullPath, PATH_MAX, "%s/Library/%s/%s", libraryPathList[i++],
323                  pathext, file);
324         if (!access(fullPath, F_OK))
325             return fullPath;
326     }
327
328     xfree(fullPath);
329     return NULL;
330 }
331
332 /* Press or release the given key, specified by NX keycode. xe must already
333    have event time and mouse location filled in. pressed is KeyPress or
334    KeyRelease. keycode is NX keycode without MIN_KEYCODE adjustment. */
335 static inline void
336 DarwinPressKeycode (xEvent *xe, int pressed, int keycode)
337 {
338     if (pressed == KeyRelease && !BitIsOn (keysDown, keycode + MIN_KEYCODE))
339     {
340         /* Don't release keys that aren't pressed. It generates extra
341            KeyPress events instead of just discarding them. */
342
343         return;
344     }
345
346     if (pressed == KeyPress)
347         SetBit (keysDown, keycode + MIN_KEYCODE);
348     else
349         ClearBit (keysDown, keycode + MIN_KEYCODE);
350
351     xe->u.u.type = pressed;
352     xe->u.u.detail = keycode + MIN_KEYCODE;
353     (darwinKeyboard->public.processInputProc) (xe, darwinKeyboard, 1);
354 }
355
356 /* Ensure that X's idea of what modifiers are down matches the real
357    window server's. Do this by looking at what keys we previously sent
358    X and deciding if they need to be released/toggled yet to make FLAGS
359    become X's current modifier state. */
360 static void
361 DarwinUpdateModifiers (xEvent xe, unsigned int flags)
362 {
363     static const struct {int mask; int nxkey;} pairs[] = {
364         {ShiftMask, NX_MODIFIERKEY_SHIFT},
365         {ControlMask, NX_MODIFIERKEY_CONTROL},
366         {Mod1Mask, NX_MODIFIERKEY_ALTERNATE},
367         {Mod2Mask, NX_MODIFIERKEY_COMMAND},
368         {Mod3Mask, NX_MODIFIERKEY_SECONDARYFN}
369     };
370
371     int i, keycode;
372
373     for (i = 0; i < (int) (sizeof (pairs) / sizeof (pairs[0])); i++)
374     {
375         keycode = DarwinModifierNXKeyToNXKeycode (pairs[i].nxkey, 0);
376
377         if (keycode == 0)
378             continue;
379
380         /* For each known modifier, sync up the state of the key X thinks
381            it's bound to and the real value of the flag. */
382
383         if ((flags & pairs[i].mask)
384             && !BitIsOn (keysDown, keycode + MIN_KEYCODE))
385         {
386             DarwinPressKeycode (&xe, KeyPress, keycode);
387         }
388         else if (!(flags & pairs[i].mask)
389                  && BitIsOn (keysDown, keycode + MIN_KEYCODE))
390         {
391             DarwinPressKeycode (&xe, KeyRelease, keycode);
392         }
393     }
394
395     /* Do the same for Lock, but need both press and release to toggle it. */
396
397     if ((flags ^ lockMods) & LockMask)
398     {
399         keycode = DarwinModifierNXKeyToNXKeycode (NX_MODIFIERKEY_ALPHALOCK, 0);
400
401         if (keycode != 0)
402         {
403             DarwinPressKeycode (&xe, KeyPress, keycode);
404             DarwinPressKeycode (&xe, KeyRelease, keycode);
405
406             lockMods ^= LockMask;
407         }
408     }
409 }
410
411 /* Release all non-modifier keys that we think are currently pressed.
412    Usually this is done when X becomes inactive to avoid leaving keys
413    stuck down when we become active again. Modifiers are handled separately
414    in the function above. */
415 static void
416 DarwinReleaseKeys (void)
417 {
418     KeyClassPtr keyc = darwinKeyboard->key;
419     xEvent xe;
420     int i, x, y;
421
422     memset (&xe, 0, sizeof (xe));
423     xe.u.keyButtonPointer.time = GetTimeInMillis ();
424     xe.u.keyButtonPointer.state = darwinKeyboard->key->state;
425     GetSpritePosition (&x, &y);
426     xe.u.keyButtonPointer.rootX = x;
427     xe.u.keyButtonPointer.rootY = y;
428     
429     for (i = 0; i < DOWN_LENGTH * 8; i++)
430     {
431         if (!keyc->modifierMap[i] && BitIsOn (keysDown, i))
432             DarwinPressKeycode (&xe, KeyRelease, i - MIN_KEYCODE);
433     }
434 }
435
436 static int
437 parseModifierString (const char *str)
438 {
439     if (strcasecmp (str, "shift") == 0)
440         return ShiftMask;
441     else if (strcasecmp (str, "control") == 0)
442         return ControlMask;
443     else if (strcasecmp (str, "option") == 0)
444         return Mod1Mask;
445     else if (strcasecmp (str, "command") == 0)
446         return Mod2Mask;
447     else if (strcasecmp (str, "fn") == 0)
448         return Mod3Mask;
449     else
450         return 0;
451 }
452
453 /* Parse a list of modifier names and return a corresponding modifier mask */
454 static int
455 DarwinParseModifierList (const char *constmodifiers)
456 {
457     int result, mask;
458     char *modifiers, *modifier, *p;
459
460     if (constmodifiers == NULL
461         || strlen (constmodifiers) == 0
462         || strcasecmp (constmodifiers, "none") == 0)
463     {
464         return 0;
465     }
466
467     modifiers = strdup (constmodifiers);
468     p = modifiers;
469     result = 0;
470
471     while (p != NULL)
472     {
473         modifier = strsep (&p, " ,+&|/"); /* allow lots of separators */
474         mask = parseModifierString (modifier);
475         if (mask != 0)
476             result |= mask;
477         else
478             ErrorF ("fakebuttons: Unknown modifier \"%s\"\n", modifier);
479     }
480
481     free (modifiers);
482     return result;
483 }
484
485 void
486 DarwinSetFakeButtons (const char *mod2, const char *mod3)
487 {
488     if (mod2 != NULL)
489         darwinFakeMouse2Mask = DarwinParseModifierList (mod2);
490     if (mod3 != NULL)
491         darwinFakeMouse3Mask = DarwinParseModifierList (mod3);
492 }
493
494 /* Read and process events from the event pipe until it is empty. */
495 void
496 ProcessInputEvents (void)
497 {
498     static int here_before = 0;
499
500     /* last known modifier state */
501     static unsigned int current_flags = 0;
502
503     /* button number and modifier mask of currently pressed fake button */
504     static int fake_button;
505     static unsigned int fake_button_mask, fake_button_modifier;
506
507     xEvent xe;
508
509     if (!here_before)
510     {
511         X11ApplicationServerReady ();
512         here_before = TRUE;
513     }
514
515     while (DarwinDequeueEvent (&xe))
516     {
517         unsigned int real_state;
518
519         real_state = xe.u.keyButtonPointer.state;
520         xe.u.keyButtonPointer.state |= fake_button_modifier;
521
522         /* Filter event for faked mouse button presses. */
523         if (darwinFakeButtons)
524         {
525             switch (xe.u.u.type)
526             {
527             case ButtonPress:
528                 if (xe.u.u.detail != 1)
529                     break;
530                 if ((xe.u.keyButtonPointer.state & darwinFakeMouse2Mask)
531                     == darwinFakeMouse2Mask)
532                 {
533                     fake_button = 2;
534                     fake_button_modifier = Button2Mask;
535                     fake_button_mask = darwinFakeMouse2Mask;
536                     xe.u.u.detail = 2;
537                 }
538                 else if ((xe.u.keyButtonPointer.state & darwinFakeMouse3Mask)
539                          == darwinFakeMouse3Mask)
540                 {
541                     fake_button = 3;
542                     fake_button_modifier = Button3Mask;
543                     fake_button_mask = darwinFakeMouse3Mask;
544                     xe.u.u.detail = 3;
545                 }
546                 break;
547
548             case ButtonRelease:
549                 if (fake_button != 0 && xe.u.u.detail == 1)
550                     xe.u.u.detail = fake_button;
551                 break;
552             }
553         }
554
555         xe.u.keyButtonPointer.state &= ~fake_button_mask;
556
557         switch (xe.u.u.type)
558         {
559         case 0: /* flags-changed */
560         case KeyPress:
561             if (current_flags == 0
562                 && darwinSyncKeymap && darwinKeymapFile == NULL)
563             {
564                 /* See if keymap has changed. */
565
566                 static unsigned int last_seed;
567                 unsigned int this_seed;
568
569                 this_seed = DarwinSystemKeymapSeed ();
570                 if (this_seed != last_seed)
571                 {
572                     last_seed = this_seed;
573                     DarwinKeyboardReload (darwinKeyboard);
574                 }
575             }
576             /* fall through */
577
578         case KeyRelease:
579         case ButtonPress:
580         case ButtonRelease:
581         case MotionNotify:
582
583             /* Initialize time field. */
584
585             xe.u.keyButtonPointer.time = GetTimeInMillis ();
586
587             /* Update X's idea of what modifiers are set. */
588
589             if (xe.u.keyButtonPointer.state != 0xffff
590                 && current_flags != xe.u.keyButtonPointer.state)
591             {
592                 current_flags = xe.u.keyButtonPointer.state;
593                 DarwinUpdateModifiers (xe, current_flags);
594             }
595         }
596
597         switch (xe.u.u.type)
598         {
599         case 0:
600             break;
601
602         case MotionNotify:
603             if (!quartzServerVisible)
604             {
605                 xp_window_id wid;
606
607                 /* Sigh. Need to check that we're really over one of
608                    our windows. (We need to receive pointer events while
609                    not in the foreground, and the only way to do that
610                    right now is to ask for _all_ pointer events..) */
611
612                 wid = 0;
613                 xp_find_window (xe.u.keyButtonPointer.rootX,
614                                 xe.u.keyButtonPointer.rootY, 0, &wid);
615                 if (wid == 0)
616                     break;
617             }
618
619             /* Shift from global screen coordinates to coordinates
620                relative to the origin of the current screen. */
621
622             xe.u.keyButtonPointer.rootX -= darwinMainScreenX -
623                     dixScreenOrigins[miPointerCurrentScreen()->myNum].x;
624             xe.u.keyButtonPointer.rootY -= darwinMainScreenY -
625                     dixScreenOrigins[miPointerCurrentScreen()->myNum].y;
626
627             miPointerAbsoluteCursor (xe.u.keyButtonPointer.rootX,
628                                      xe.u.keyButtonPointer.rootY,
629                                      xe.u.keyButtonPointer.time);
630             break;
631
632         case ButtonPress:
633         case ButtonRelease:
634             darwinPointer->public.processInputProc (&xe, darwinPointer, 1);
635             break;
636
637         case KeyPress:
638         case KeyRelease:
639             DarwinPressKeycode (&xe, xe.u.u.type, xe.u.u.detail);
640             break;
641
642         case ClientMessage:
643             /* Update server's current time, since we may generate
644                events, and it's nice if the timestamps are correct. */
645             currentTime.milliseconds = GetTimeInMillis ();
646
647             switch (xe.u.clientMessage.u.l.type)
648             {
649             case kXdarwinQuit:
650                 GiveUp (0);
651                 break;
652
653             case kXquartzDeactivate:
654                 DarwinReleaseKeys ();
655                 /* fall through */
656
657             default:
658                 if (xe.u.clientMessage.u.l.type >= kXquartzFirstEvent
659                     && xe.u.clientMessage.u.l.type <= kXquartzLastEvent)
660                 {
661                     QuartzClientMessage (&xe);
662                 }
663                 else
664                 {
665                     ErrorF ("Unknown application defined event: %d.\n",
666                             xe.u.clientMessage.u.l.longs0);
667                 }
668                 break;
669             }
670             break;
671
672         default:
673             ErrorF("Unknown event caught: %d\n", xe.u.u.type);
674             break;
675         }
676
677         /* Filter event for faked mouse button releases. */
678         if (fake_button != 0 && xe.u.u.type == ButtonRelease)
679         {
680             current_flags |= (real_state & fake_button_mask);
681             DarwinUpdateModifiers (xe, current_flags);
682
683             fake_button = 0;
684             fake_button_modifier = 0;
685             fake_button_mask = 0;
686         }
687     }
688
689     miPointerUpdate ();
690 }
691
692 void
693 DarwinEnqueuePointerEvent (xEvent *xe)
694 {
695     darwinPointer->public.processInputProc (xe, darwinPointer, 1);
696 }
697
698 /* Register the keyboard and mouse devices */
699 void
700 InitInput (int argc, char **argv)
701 {
702     DarwinInputInit ();
703
704     darwinPointer = AddInputDevice(DarwinMouseProc, TRUE);
705     RegisterPointerDevice( darwinPointer );
706
707     darwinKeyboard = AddInputDevice(DarwinKeybdProc, TRUE);
708     RegisterKeyboardDevice( darwinKeyboard );
709 }
710
711 void
712 DarwinAdjustScreenOrigins (ScreenInfo *pScreenInfo)
713 {
714     int i, left, top;
715
716     /* Shift all screens so the X11 (0, 0) coordinate is at the top
717        left of the global screen coordinates.
718
719        Screens can be arranged so the top left isn't on any screen, so
720        instead use the top left of the leftmost screen as (0,0). This
721        may mean some screen space is in -y, but it's better that (0,0)
722        be onscreen, or else default xterms disappear. It's better that
723        -y be used than -x, because when popup menus are forced
724        "onscreen" by dumb window managers like twm, they'll shift the
725        menus down instead of left, which still looks funny but is an
726        easier target to hit. */
727
728     left = dixScreenOrigins[0].x;
729     top  = dixScreenOrigins[0].y;
730
731     /* Find leftmost screen. If there's a tie, take the topmost of the two. */
732     for (i = 1; i < pScreenInfo->numScreens; i++) {
733         if (dixScreenOrigins[i].x < left  ||
734             (dixScreenOrigins[i].x == left &&
735              dixScreenOrigins[i].y < top))
736         {
737             left = dixScreenOrigins[i].x;
738             top = dixScreenOrigins[i].y;
739         }
740     }
741
742     darwinMainScreenX = left;
743     darwinMainScreenY = top;
744
745     /* Shift all screens so that there is a screen whose top left
746        is at X11 (0,0) and at global screen coordinate
747        (darwinMainScreenX, darwinMainScreenY). */
748
749     if (darwinMainScreenX != 0 || darwinMainScreenY != 0) {
750         for (i = 0; i < pScreenInfo->numScreens; i++) {
751             dixScreenOrigins[i].x -= darwinMainScreenX;
752             dixScreenOrigins[i].y -= darwinMainScreenY;
753             ErrorF("Screen %d placed at X11 coordinate (%d,%d).\n",
754                    i, dixScreenOrigins[i].x, dixScreenOrigins[i].y);
755         }
756     }
757 }
758
759 /* Initialize screenInfo for all actually accessible framebuffers.
760
761    The display mode dependent code gets called three times. The mode
762    specific InitOutput routines are expected to discover the number of
763    potentially useful screens and cache routes to them internally.
764    Inside DarwinAddScreen are two other mode specific calls. A mode
765    specific AddScreen routine is called for each screen to actually
766    initialize the screen with the ScreenPtr structure. After other
767    screen setup has been done, a mode specific SetupScreen function can
768    be called to finalize screen setup. */
769
770 void
771 InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
772 {
773     int i;
774     static unsigned long generation = 0;
775
776     pScreenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
777     pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
778     pScreenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
779     pScreenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
780
781     /* List how we want common pixmap formats to be padded */
782     pScreenInfo->numPixmapFormats = NUMFORMATS;
783     for (i = 0; i < NUMFORMATS; i++)
784         pScreenInfo->formats[i] = formats[i];
785
786     /* Allocate private storage for each screen's Darwin specific info */
787     if (generation != serverGeneration) {
788         darwinScreenIndex = AllocateScreenPrivateIndex();
789         generation = serverGeneration;
790     }
791
792     /* Discover screens and do mode specific initialization */
793     QuartzInitOutput(argc, argv);
794
795     for (i = 0; i < darwinScreensFound; i++)
796         AddScreen( DarwinAddScreen, argc, argv );
797
798     DarwinAdjustScreenOrigins (pScreenInfo);
799
800     PseudoramiXExtensionInit (argc, argv);
801     AppleDRIExtensionInit ();
802     AppleWMExtensionInit ();
803
804     DRIExtensionInit ();
805 }
806
807 void
808 OsVendorFatalError (void)
809 {
810     ErrorF( "   OsVendorFatalError\n" );
811 }
812
813 void
814 OsVendorInit (void)
815 {
816     if (serverGeneration == 1)
817         DarwinPrintBanner();
818 }
819
820 /* Process device-dependent command line args. Returns 0 if argument is
821    not device dependent, otherwise Count of number of elements of argv
822    that are part of a device dependent commandline option. */
823 int
824 ddxProcessArgument (int argc, char *argv[], int i)
825 {
826     int numDone;
827
828     if ((numDone = QuartzProcessArgument( argc, argv, i )))
829         return numDone;
830
831     if ( !strcmp( argv[i], "-fakebuttons" ) ) {
832         darwinFakeButtons = TRUE;
833         ErrorF( "Faking a three button mouse\n" );
834         return 1;
835     }
836
837     if ( !strcmp( argv[i], "-nofakebuttons" ) ) {
838         darwinFakeButtons = FALSE;
839         ErrorF( "Not faking a three button mouse\n" );
840         return 1;
841     }
842
843     if (!strcmp( argv[i], "-fakemouse2" ) ) {
844         if ( i == argc-1 ) {
845             FatalError( "-fakemouse2 must be followed by a modifer list\n" );
846         }
847         darwinFakeMouse2Mask = DarwinParseModifierList(argv[i+1]);
848         return 2;
849     }
850
851     if (!strcmp( argv[i], "-fakemouse3" ) ) {
852         if ( i == argc-1 ) {
853             FatalError( "-fakemouse3 must be followed by a modifer list\n" );
854         }
855         darwinFakeMouse3Mask = DarwinParseModifierList(argv[i+1]);
856         return 2;
857     }
858
859     if ( !strcmp( argv[i], "-keymap" ) ) {
860         if ( i == argc-1 ) {
861             FatalError( "-keymap must be followed by a filename\n" );
862         }
863         darwinKeymapFile = argv[i+1];
864         return 2;
865     }
866
867     if ( !strcmp( argv[i], "-nokeymap" ) ) {
868         darwinKeymapFile = NULL;
869         return 1;
870     }
871
872     if ( !strcmp( argv[i], "+synckeymap" ) ) {
873         darwinSyncKeymap = TRUE;
874         return 1;
875     }
876     if ( !strcmp( argv[i], "-synckeymap" ) ) {
877         darwinSyncKeymap = FALSE;
878         return 1;
879     }
880
881     if (strcmp (argv[i], "-swapAltMeta") == 0) {
882         darwinSwapAltMeta = TRUE;
883         return 1;
884     }
885
886     if (!strcmp( argv[i], "-showconfig" ) || !strcmp( argv[i], "-version" )) {
887         DarwinPrintBanner();
888         exit(0);
889     }
890
891     /* XDarwinStartup uses this argument to indicate the IOKit X server
892        should be started. Ignore it here. */
893     if ( !strcmp( argv[i], "-iokit" ) ) {
894         return 1;
895     }
896
897     return 0;
898 }
899
900 /* Print out correct use of device dependent commandline options.
901    Maybe the user now knows what really to do ... */
902 void
903 ddxUseMsg (void)
904 {
905     ErrorF("\n");
906     ErrorF("\n");
907     ErrorF("Device Dependent Usage:\n");
908     ErrorF("\n");
909     ErrorF("-depth <depth>         use <depth> bits per pixel. Options: 8, 15, 24\b\n");
910     ErrorF("-fakebuttons           fake a 3 button mouse with Command and Option\n");
911     ErrorF("-nofakebuttons\n");
912     ErrorF("-fakemouse2 <keys>     fake middle mouse button with modifier keys\n");
913     ErrorF("-fakemouse3 <keys>     fake right mouse button with modifier keys\n");
914     ErrorF("                         e.g.: -fakemouse2 \"option,shift\"\n");
915     ErrorF("-keymap <file>         read the keymap from <file>\n");
916     ErrorF("-nokeymap\n");
917     ErrorF("+synckeymap            synchronize X keymap with system keymap\n");
918     ErrorF("-synckeymap            only set X keymap on server startup\n");
919     ErrorF("-swapAltMeta           swap meaning of Alt and Meta modifiers\n");
920     ErrorF("-version               show server version.\n");
921     ErrorF("\n");
922 }
923
924 /* Device dependent cleanup. Called by dix before normal server death. */
925 void
926 ddxGiveUp (void)
927 {
928     ErrorF( "Quitting XDarwin...\n" );
929     QuartzGiveUp();
930 }
931
932 /* DDX - specific abort routine.  Called by AbortServer(). The attempt is
933    made to restore all original setting of the displays. Also all devices
934    are closed. */
935 void
936 AbortDDX (void)
937 {
938     ErrorF( "   AbortDDX\n" );
939
940     /* This is needed for a abnormal server exit, since the normal exit stuff
941        MUST also be performed (i.e. the vt must be left in a defined state) */
942     ddxGiveUp();
943 }
944
945 extern void GlxExtensionInit();
946 extern void GlxWrapInitVisuals(void *procPtr);
947 void DarwinGlxExtensionInit (void) { GlxExtensionInit (); }
948 void DarwinGlxWrapInitVisuals (void *ptr) { GlxWrapInitVisuals (ptr); }
949
950 #ifdef DPMSExtension
951 Bool
952 DPMSSupported (void)
953 {
954     return FALSE;
955 }
956
957 void
958 DPMSSet (int level)
959 {
960 }
961
962 int
963 DPMSGet (int *level)
964 {
965     return -1;
966 }
967 #endif
968
969 #ifdef DDXTIME
970 CARD32
971 GetTimeInMillis (void)
972 {
973     extern void Microseconds ();
974     UnsignedWide usec;
975
976     /* This doesn't involve trapping into the kernel, unlike gettimeofday. */
977     Microseconds (&usec);
978
979     /* Should be good enough? (-2% error) */
980     return (usec.hi << 22) | (usec.lo >> 10);
981 }
982 #endif