Set svn:ignore recursively
[synfig.git] / synfig-osx / trunk / launcher / quartz.c
1 /**************************************************************
2  *
3  * Quartz-specific support for the Darwin X Server
4  *
5  **************************************************************/
6 /*
7  * Copyright (c) 2001 Greg Parker and Torrey T. Lyons.
8  * Copyright (c) 2002 Apple Computer, Inc.
9  *                 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/quartz/quartz.c,v 1.1 2002/03/28 02:21:18 torrey Exp $ */
34
35 #include "quartz.h"
36 #include "darwin.h"
37 #include "quartz-audio.h"
38 #include "quartz-cursor.h"
39 #include "rootless.h"
40 #include "rootless-window.h"
41 #include "pseudoramiX.h"
42 #include "globals.h"
43 #include "dri.h"
44 #define _APPLEWM_SERVER_
45 #include "applewmstr.h"
46 #include "X11Application.h"
47
48 #include "scrnintstr.h"
49 #include "colormapst.h"
50
51 #include <sys/types.h>
52 #include <sys/stat.h>
53 #include <fcntl.h>
54 #include <unistd.h>
55 #include <sys/wait.h>
56
57 #include <AvailabilityMacros.h>
58 #include <CoreGraphics/CoreGraphics.h>
59
60 /* Shared global variables for Quartz modes */
61 int quartzEventWriteFD = -1;
62 int quartzUseSysBeep = 1;
63 int quartzServerVisible = FALSE;
64 int quartzDesiredDepth = -1;
65 int quartzHasRoot = FALSE, quartzEnableRootless = TRUE;
66 int quartzFullscreenDisableHotkeys = TRUE;
67 int noPseudoramiXExtension = FALSE;
68 int quartzXpluginOptions = 0;
69
70 extern char *display;
71
72 static CGDirectDisplayID
73 display_at_index (int index)
74 {
75     CGError err;
76     CGDisplayCount cnt;
77     CGDirectDisplayID dpy[index+1];
78
79     err = CGGetActiveDisplayList (index + 1, dpy, &cnt);
80     if (err == kCGErrorSuccess && (int) cnt == index + 1)
81         return dpy[index];
82     else
83         return kCGNullDirectDisplay;
84 }
85
86 static CGRect
87 display_screen_bounds (CGDirectDisplayID id, Bool remove_menubar)
88 {
89     CGRect frame;
90
91     frame = CGDisplayBounds (id);
92
93     if (remove_menubar && !quartzHasRoot
94         && frame.origin.x == 0 && frame.origin.y == 0)
95     {
96         /* Remove Aqua menubar from display bounds. */
97
98         frame.origin.y += 22;
99         frame.size.height -= 22;
100     }
101
102     return frame;
103 }
104
105 static void
106 addPseudoramiXScreens (int *x, int *y, int *width, int *height)
107 {
108     CGDisplayCount i, total = 16;       /* FIXME: hardcoded maximum */
109     CGRect unionRect = CGRectNull, frame;
110     CGDirectDisplayID screens[total];
111         
112     CGGetActiveDisplayList (total, screens, &total);
113
114     /* Get the union of all screens */
115     for (i = 0; i < total; i++)
116     {
117         CGDirectDisplayID dpy = screens[i];
118
119         /* we can't remove the menubar from the screen - doing so
120            would constrain the pointer to the screen, not allowing it
121            to reach the menubar.. */
122
123         frame = display_screen_bounds (dpy, FALSE);
124         unionRect = CGRectUnion (unionRect, frame);
125     }
126
127     /* Use unionRect as the screen size for the X server. */
128     *x = unionRect.origin.x;
129     *y = unionRect.origin.y;
130     *width = unionRect.size.width;
131     *height = unionRect.size.height;
132
133     /* Tell PseudoramiX about the real screens. */
134     for (i = 0; i < total; i++)
135     {
136         CGDirectDisplayID dpy = screens[i];
137
138         frame = display_screen_bounds (dpy, TRUE);
139
140 #ifdef DEBUG
141         ErrorF("PseudoramiX screen %d added: %dx%d @ (%d,%d).\n", i,
142                (int)frame.size.width, (int)frame.size.height,
143                (int)frame.origin.x, (int)frame.origin.y);
144 #endif
145
146         frame.origin.x -= unionRect.origin.x;
147         frame.origin.y -= unionRect.origin.y;
148
149 #ifdef DEBUG
150         ErrorF("PseudoramiX screen %d placed at X11 coordinate (%d,%d).\n",
151                i, (int)frame.origin.x, (int)frame.origin.y);
152 #endif
153
154         PseudoramiXAddScreen(frame.origin.x, frame.origin.y,
155                              frame.size.width, frame.size.height);
156     }
157 }
158
159 /* Do mode dependent initialization of each screen for Quartz. */
160 Bool
161 QuartzAddScreen (int index, ScreenPtr pScreen)
162 {
163     DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
164
165     /* If no specific depth chosen, look for the depth of the main display.
166        Else if 16bpp specified, use that. Else use 32bpp. */
167
168     dfb->componentCount = 3;
169     dfb->bitsPerComponent = 8;
170     dfb->bitsPerPixel = 32;
171
172     if (quartzDesiredDepth == -1)
173     {
174         dfb->bitsPerComponent = CGDisplayBitsPerSample (kCGDirectMainDisplay);
175         dfb->bitsPerPixel = CGDisplayBitsPerPixel (kCGDirectMainDisplay);
176     }
177     else if (quartzDesiredDepth == 15)
178     {
179         dfb->bitsPerComponent = 5;
180         dfb->bitsPerPixel = 16;
181     }
182     else if (quartzDesiredDepth == 8)
183     {
184         dfb->bitsPerComponent = 8;
185         dfb->bitsPerPixel = 8;
186         dfb->componentCount = 1;
187     }
188
189     if (noPseudoramiXExtension)
190     {
191         CGDirectDisplayID dpy;
192         CGRect frame;
193
194         dpy = display_at_index (index);
195
196         frame = display_screen_bounds (dpy, TRUE);
197
198         dfb->x = frame.origin.x;
199         dfb->y = frame.origin.y;
200         dfb->width =  frame.size.width;
201         dfb->height = frame.size.height;
202     }
203     else
204     {
205         addPseudoramiXScreens (&dfb->x, &dfb->y, &dfb->width, &dfb->height);
206     }
207
208     dfb->colorBitsPerPixel = dfb->bitsPerComponent * dfb->componentCount;
209
210     /* Passing zero width (pitch) makes miCreateScreenResources set the
211        screen pixmap to the framebuffer pointer, i.e. null. We'll take
212        it from there.. */
213     dfb->pitch = 0;
214     dfb->framebuffer = NULL;
215
216     DRIScreenInit (pScreen);
217
218     return TRUE;
219 }
220
221 /* Finalize mode specific setup of each screen. */
222 Bool
223 QuartzSetupScreen (int index, ScreenPtr pScreen)
224 {
225     // do full screen or rootless specific setup
226     if (! RootlessSetupScreen(index, pScreen))
227         return FALSE;
228
229     // setup cursor support
230     if (! QuartzInitCursor(pScreen))
231         return FALSE;
232
233     DRIFinishScreenInit (pScreen);
234
235     return TRUE;
236 }
237
238
239 /* Quartz display initialization. */
240 void
241 QuartzInitOutput (int argc, char **argv)
242 {
243     static int orig_noPanoramiXExtension;
244     int total;
245
246     if (serverGeneration == 1) {
247         orig_noPanoramiXExtension = noPanoramiXExtension;
248         QuartzAudioInit();
249     }
250
251     /* +xinerama option sets noPanoramiXExtension variable */
252     noPseudoramiXExtension = orig_noPanoramiXExtension;
253
254     total = 16;                         /* FIXME: hardcoded maximum */
255     if (total > 0)
256     {
257         CGDirectDisplayID screens[total];
258         CGGetActiveDisplayList (total, screens, &total);
259     }
260
261     if (noPseudoramiXExtension)
262         darwinScreensFound = total;
263     else
264         darwinScreensFound =  1; // only PseudoramiX knows about the rest
265
266     if (!quartzEnableRootless)
267         RootlessHideAllWindows ();
268 }
269
270 /* This function from randr.c */
271 extern char     *ConnectionInfo;
272 static int padlength[4] = {0, 3, 2, 1};
273 static void
274 RREditConnectionInfo (ScreenPtr pScreen)
275 {
276     xConnSetup      *connSetup;
277     char            *vendor;
278     xPixmapFormat   *formats;
279     xWindowRoot     *root;
280     xDepth          *depth;
281     xVisualType     *visual;
282     int             screen = 0;
283     int             d;
284
285     connSetup = (xConnSetup *) ConnectionInfo;
286     vendor = (char *) connSetup + sizeof (xConnSetup);
287     formats = (xPixmapFormat *) ((char *) vendor +
288                                  connSetup->nbytesVendor +
289                                  padlength[connSetup->nbytesVendor & 3]);
290     root = (xWindowRoot *) ((char *) formats +
291                             sizeof (xPixmapFormat) * screenInfo.numPixmapFormats);
292     while (screen != pScreen->myNum)
293     {
294         depth = (xDepth *) ((char *) root + 
295                             sizeof (xWindowRoot));
296         for (d = 0; d < root->nDepths; d++)
297         {
298             visual = (xVisualType *) ((char *) depth +
299                                       sizeof (xDepth));
300             depth = (xDepth *) ((char *) visual +
301                                 depth->nVisuals * sizeof (xVisualType));
302         }
303         root = (xWindowRoot *) ((char *) depth);
304         screen++;
305     }
306     root->pixWidth = pScreen->width;
307     root->pixHeight = pScreen->height;
308     root->mmWidth = pScreen->mmWidth;
309     root->mmHeight = pScreen->mmHeight;
310 }
311
312 static void
313 QuartzUpdateScreens (void)
314 {
315     ScreenPtr pScreen;
316     WindowPtr pRoot;
317     int x, y, width, height, sx, sy;
318     xEvent e;
319
320     if (noPseudoramiXExtension || screenInfo.numScreens != 1)
321     {
322         /* FIXME: if not using Xinerama, we have multiple screens, and
323            to do this properly may need to add or remove screens. Which
324            isn't possible. So don't do anything. Another reason why
325            we default to running with Xinerama. */
326
327         return;
328     }
329
330     pScreen = screenInfo.screens[0];
331
332     PseudoramiXResetScreens ();
333     addPseudoramiXScreens (&x, &y, &width, &height);
334
335     dixScreenOrigins[pScreen->myNum].x = x;
336     dixScreenOrigins[pScreen->myNum].y = y;
337     pScreen->mmWidth = pScreen->mmWidth * ((double) width / pScreen->width);
338     pScreen->mmHeight = pScreen->mmHeight * ((double) height / pScreen->height);
339     pScreen->width = width;
340     pScreen->height = height;
341
342     /* FIXME: should probably do something with RandR here. */
343
344     DarwinAdjustScreenOrigins (&screenInfo);
345     RootlessRepositionWindows (screenInfo.screens[0]);
346     RootlessUpdateScreenPixmap (screenInfo.screens[0]);
347
348     sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
349     sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
350
351     /* Adjust the root window. */
352
353     pRoot = WindowTable[pScreen->myNum];
354     pScreen->ResizeWindow (pRoot, x - sx, y - sy, width, height, NULL);
355     pScreen->PaintWindowBackground (pRoot, &pRoot->borderClip,  PW_BACKGROUND);
356     QuartzIgnoreNextWarpCursor ();
357     DefineInitialRootWindow (pRoot);
358
359     /* Send an event for the root reconfigure */
360
361     e.u.u.type = ConfigureNotify;
362     e.u.configureNotify.window = pRoot->drawable.id;
363     e.u.configureNotify.aboveSibling = None;
364     e.u.configureNotify.x = x - sx;
365     e.u.configureNotify.y = y - sy;
366     e.u.configureNotify.width = width;
367     e.u.configureNotify.height = height;
368     e.u.configureNotify.borderWidth = wBorderWidth (pRoot);
369     e.u.configureNotify.override = pRoot->overrideRedirect;
370     DeliverEvents (pRoot, &e, 1, NullWindow);
371
372     /* FIXME: what does this do? */
373     RREditConnectionInfo (pScreen);
374 }
375
376 static void
377 do_exec (void (*callback) (void *data), void *data)
378 {
379     /* Do the fork-twice trick to avoid needing to reap zombies */
380
381     int child1, child2 = 0;
382     int status;
383
384     /* we should really try to report errors here.. */
385
386     child1 = fork ();
387
388     switch (child1)
389     {
390     case -1:                            /* error */
391         break;
392
393     case 0:                             /* child1 */
394         child2 = fork ();
395
396         switch (child2)
397         {
398             int max_files, i;
399             char buf[1024], *tem;
400
401         case -1:                        /* error */
402             _exit (1);
403
404         case 0:                         /* child2 */
405             /* close all open files except for standard streams */
406             max_files = sysconf (_SC_OPEN_MAX);
407             for (i = 3; i < max_files; i++)
408                 close (i);
409
410             /* ensure stdin is on /dev/null */
411             close (0);
412             open ("/dev/null", O_RDONLY);
413
414             /* cd $HOME */
415             tem = getenv ("HOME");
416             if (tem != NULL)
417                 chdir (tem);
418
419             /* Setup environment */
420             snprintf (buf, sizeof (buf), ":%s", display);
421             setenv ("DISPLAY", buf, TRUE);
422             tem = getenv ("PATH");
423             if (tem != NULL && tem[0] != NULL)
424                 snprintf (buf, sizeof (buf), "%s:/usr/X11R6/bin", tem);
425             else
426                 snprintf (buf, sizeof (buf), "/bin:/usr/bin:/usr/X11R6/bin");
427             setenv ("PATH", buf, TRUE);
428
429             (*callback) (data);
430
431             _exit (2);
432
433         default:                        /* parent (child1) */
434             _exit (0);
435         }
436         break;
437
438     default:                            /* parent */
439         waitpid (child1, &status, 0);
440     }
441 }
442
443 static void
444 run_client_callback (void *data)
445 {
446     char **argv = data;
447     execvp (argv[0], argv);
448 }
449
450 /* Note that this function is called from both X server and appkit threads */
451 void
452 QuartzRunClient (const char *command)
453 {
454     const char *shell;
455     const char *argv[5];
456
457     shell = getenv ("SHELL");
458     if (shell == NULL)
459         shell = "/bin/bash";
460
461     /* At least [ba]sh, [t]csh and zsh all work with this syntax. We
462        need to use an interactive shell to force it to load the user's
463        environment. Otherwise things like fink don't work at all well.. */
464
465     argv[0] = shell;
466     argv[1] = "-i";
467     argv[2] = "-c";
468     argv[3] = command;
469     argv[4] = NULL;
470
471     do_exec (run_client_callback, argv);
472 }
473
474 static void
475 QuartzSetFullscreen (Bool state)
476 {
477     if (quartzHasRoot == state)
478         return;
479
480     quartzHasRoot = state;
481
482     xp_disable_update ();
483
484     if (!quartzHasRoot && !quartzEnableRootless)
485         RootlessHideAllWindows ();
486
487     RootlessUpdateRooted (quartzHasRoot);
488
489     if (quartzHasRoot && !quartzEnableRootless)
490         RootlessShowAllWindows ();
491
492     /* Only update screen info when something is visible. Avoids the wm
493        moving the windows out from under the menubar when it shouldn't */
494
495     if (quartzHasRoot || quartzEnableRootless)
496         QuartzUpdateScreens ();
497
498     /* Somehow the menubar manages to interfere with our event stream
499        in fullscreen mode, even though it's not visible. */
500
501     X11ApplicationShowHideMenubar (!quartzHasRoot);
502
503     xp_reenable_update ();
504
505 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
506     if (quartzFullscreenDisableHotkeys)
507         xp_disable_hot_keys (quartzHasRoot);
508 #endif
509 }
510
511 static void
512 QuartzSetRootless (Bool state)
513 {
514     if (quartzEnableRootless == state)
515         return;
516
517     quartzEnableRootless = state;
518
519     if (!quartzEnableRootless && !quartzHasRoot)
520     {
521         xp_disable_update ();
522         RootlessHideAllWindows ();
523         xp_reenable_update ();
524     }
525     else if (quartzEnableRootless && !quartzHasRoot)
526     {
527         xp_disable_update ();
528         RootlessShowAllWindows ();
529         QuartzUpdateScreens ();
530         xp_reenable_update ();
531     }
532 }
533
534 /* Show the X server on screen. Does nothing if already shown.  Restore the
535    X clip regions the X server cursor state. */
536 static void
537 QuartzShow (void)
538 {
539     int i;
540
541     if (quartzServerVisible)
542         return;
543
544     quartzServerVisible = TRUE;
545
546     for (i = 0; i < screenInfo.numScreens; i++)
547     {
548         if (screenInfo.screens[i])
549             QuartzResumeXCursor(screenInfo.screens[i]);
550     }
551
552     /* FIXME: not sure about this, it may need to have a preference like
553        in XDarwin..? */
554
555     if (!quartzEnableRootless)
556         QuartzSetFullscreen (TRUE);
557 }
558
559 /* Remove the X server display from the screen. Does nothing if already
560    hidden. Set X clip regions to prevent drawing, and restore the Aqua
561    cursor. */
562 static void
563 QuartzHide (void)
564 {
565     int i;
566
567     if (!quartzServerVisible)
568         return;
569
570     for (i = 0; i < screenInfo.numScreens; i++)
571     {
572         if (screenInfo.screens[i])
573             QuartzSuspendXCursor(screenInfo.screens[i]);
574     }
575
576     QuartzSetFullscreen (FALSE);
577
578     quartzServerVisible = FALSE;
579 }
580
581 /* Cleanup before X server shutdown. Release the screen and restore the
582    Aqua cursor. */
583 void
584 QuartzGiveUp (void)
585 {
586     int i;
587
588     for (i = 0; i < screenInfo.numScreens; i++) {
589         if (screenInfo.screens[i]) {
590             QuartzSuspendXCursor(screenInfo.screens[i]);
591         }
592     }
593 }
594
595 int
596 QuartzProcessArgument( int argc, char *argv[], int i )
597 {
598     /* This arg is passed when launched from the Aqua GUI. */
599     if (strncmp (argv[i], "-psn_", 5) == 0)
600     {
601         return 1;
602     }
603
604     if (strcmp (argv[i], "-depth") == 0)
605     {
606         int arg;
607
608         if (i == argc - 1)
609             FatalError ("-depth requires an argument\n");
610
611         arg = atoi (argv[i + 1]);
612         if (arg == 8 || arg == 15 || arg == 24)
613             quartzDesiredDepth = arg;
614         else
615             FatalError ("Only 8, 15 and 24 bit color depths are supported.\n");
616
617         return 2;
618     }
619
620     return 0;
621 }
622
623 void
624 QuartzClientMessage (const xEvent *xe)
625 {
626     switch (xe->u.clientMessage.u.l.type)
627     {
628     case kXquartzControllerNotify:
629         AppleWMSendEvent (AppleWMControllerNotify,
630                           AppleWMControllerNotifyMask,
631                           xe->u.clientMessage.u.l.longs0,
632                           xe->u.clientMessage.u.l.longs1);
633         break;
634
635     case kXquartzPasteboardNotify:
636         AppleWMSendEvent (AppleWMPasteboardNotify,
637                           AppleWMPasteboardNotifyMask,
638                           xe->u.clientMessage.u.l.longs0,
639                           xe->u.clientMessage.u.l.longs1);
640         break;
641
642     case kXquartzActivate:
643         QuartzShow ();
644         AppleWMSendEvent (AppleWMActivationNotify,
645                           AppleWMActivationNotifyMask,
646                           AppleWMIsActive, 0);
647         break;
648
649     case kXquartzDeactivate:
650         AppleWMSendEvent (AppleWMActivationNotify,
651                           AppleWMActivationNotifyMask,
652                           AppleWMIsInactive, 0);
653         QuartzHide ();
654         break;
655
656     case kXquartzDisplayChanged:
657         QuartzUpdateScreens ();
658         break;
659
660     case kXquartzWindowState:
661         RootlessNativeWindowStateChanged (xe->u.clientMessage.u.l.longs0,
662                                           xe->u.clientMessage.u.l.longs1);
663         break;
664
665     case kXquartzWindowMoved:
666         RootlessNativeWindowMoved (xe->u.clientMessage.u.l.longs0);
667         break;
668
669     case kXquartzToggleFullscreen:
670         if (quartzEnableRootless)
671             QuartzSetFullscreen (!quartzHasRoot);
672         else if (quartzHasRoot)
673             QuartzHide ();
674         else
675             QuartzShow ();
676         break;
677
678     case kXquartzSetRootless:
679         QuartzSetRootless (xe->u.clientMessage.u.l.longs0);
680         if (!quartzEnableRootless && !quartzHasRoot)
681             QuartzHide ();
682     }
683 }