synfig-osx/launcher/X11Application.m

   1 /* X11Application.m -- subclass of NSApplication to multiplex events
   2    $Id: X11Application.m,v 1.53 2003/09/13 02:00:46 jharper Exp $
   3
   4    Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
   5
   6    Permission is hereby granted, free of charge, to any person
   7    obtaining a copy of this software and associated documentation files
   8    (the "Software"), to deal in the Software without restriction,
   9    including without limitation the rights to use, copy, modify, merge,
  10    publish, distribute, sublicense, and/or sell copies of the Software,
  11    and to permit persons to whom the Software is furnished to do so,
  12    subject to the following conditions:
  13
  14    The above copyright notice and this permission notice shall be
  15    included in all copies or substantial portions of the Software.
  16
  17    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20    NONINFRINGEMENT.  IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT
  21    HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24    DEALINGS IN THE SOFTWARE.
  25
  26    Except as contained in this notice, the name(s) of the above
  27    copyright holders shall not be used in advertising or otherwise to
  28    promote the sale, use or other dealings in this Software without
  29    prior written authorization. */
  30
  31 #import "X11Application.h"
  32 #include <Carbon/Carbon.h>
  33
  34 /* ouch! */
  35 #define BOOL X_BOOL
  36 # include "Xproto.h"
  37 #define WindowPtr X_WindowPtr
  38 #define Cursor X_Cursor
  39 # include "quartz.h"
  40 # define _APPLEWM_SERVER_
  41 # include "applewm.h"
  42 # include "X.h"
  43 #undef Cursor
  44 #undef WindowPtr
  45 #undef BOOL
  46
  47 #include "xf86Version.h"
  48
  49 #include <mach/mach.h>
  50 #include <unistd.h>
  51 #include <pthread.h>
  52
  53 #define DEFAULTS_FILE "/etc/X11/xserver/Xquartz.plist"
  54
  55 int X11EnableKeyEquivalents = TRUE;
  56
  57 X11Application *X11App;
  58
  59 #define ALL_KEY_MASKS (NSShiftKeyMask | NSControlKeyMask \
  60                        | NSAlternateKeyMask | NSCommandKeyMask)
  61
  62 @implementation X11Application
  63
  64 typedef struct message_struct message;
  65 struct message_struct {
  66     mach_msg_header_t hdr;
  67     SEL selector;
  68     NSObject *arg;
  69 };
  70
  71 static mach_port_t _port;
  72
  73 static void send_nsevent (NSEventType type, NSEvent *e);
  74
  75 /* avoid header conflict hell */
  76 extern int RootlessKnowsWindowNumber (int number);
  77 extern void DarwinEnqueueEvent (const xEvent *e);
  78
  79 static void
  80 init_ports (void)
  81 {
  82     kern_return_t r;
  83     NSPort *p;
  84
  85     if (_port != MACH_PORT_NULL)
  86         return;
  87
  88     r = mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE, &_port);
  89     if (r != KERN_SUCCESS)
  90         return;
  91
  92     p = [NSMachPort portWithMachPort:_port];
  93     [p setDelegate:NSApp];
  94     [p scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
  95 }
  96
  97 static void
  98 message_kit_thread (SEL selector, NSObject *arg)
  99 {
 100     message msg;
 101     kern_return_t r;
 102
 103     msg.hdr.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_MAKE_SEND, 0);
 104     msg.hdr.msgh_size = sizeof (msg);
 105     msg.hdr.msgh_remote_port = _port;
 106     msg.hdr.msgh_local_port = MACH_PORT_NULL;
 107     msg.hdr.msgh_reserved = 0;
 108     msg.hdr.msgh_id = 0;
 109
 110     msg.selector = selector;
 111     msg.arg = [arg retain];
 112
 113     r = mach_msg (&msg.hdr, MACH_SEND_MSG, msg.hdr.msgh_size,
 114                   0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
 115     if (r != KERN_SUCCESS)
 116         fprintf (stderr, "%s: mach_msg failed: %x\n", __FUNCTION__, r);
 117 }
 118
 119 - (void) handleMachMessage:(void *)_msg
 120 {
 121     message *msg = _msg;
 122
 123     [self performSelector:msg->selector withObject:msg->arg];
 124     [msg->arg release];
 125 }
 126
 127 - (void) set_controller:obj
 128 {
 129     if (_controller == nil)
 130         _controller = [obj retain];
 131 }
 132
 133 - (void) dealloc
 134 {
 135     if (_controller != nil)
 136         [_controller release];
 137
 138     if (_port != MACH_PORT_NULL)
 139         mach_port_deallocate (mach_task_self (), _port);
 140
 141     [super dealloc];
 142 }
 143
 144 - (void) orderFrontStandardAboutPanel: (id) sender
 145 {
 146     NSMutableDictionary *dict;
 147     NSDictionary *infoDict;
 148     NSString *tem;
 149
 150     dict = [NSMutableDictionary dictionaryWithCapacity:2];
 151     infoDict = [[NSBundle mainBundle] infoDictionary];
 152
 153     [dict setObject: NSLocalizedString (@"The X Window System", @"About panel")
 154      forKey:@"ApplicationName"];
 155
 156     tem = [infoDict objectForKey:@"CFBundleShortVersionString"];
 157
 158     [dict setObject:[NSString stringWithFormat:@"X11 %@ - XFree86 %d.%d.%d",
 159                      tem, XF86_VERSION_MAJOR, XF86_VERSION_MINOR,
 160                      XF86_VERSION_PATCH] forKey:@"ApplicationVersion"];
 161
 162     [self orderFrontStandardAboutPanelWithOptions: dict];
 163 }
 164
 165 - (void) activateX:(BOOL)state
 166 {
 167     /* Create a TSM document that supports full Unicode input, and
 168        have it activated while X is active (unless using the old
 169        keymapping files) */
 170     static TSMDocumentID x11_document;
 171
 172     if (state)
 173     {
 174         QuartzMessageMainThread (kXquartzActivate, 0);
 175
 176         if (!_x_active)
 177         {
 178             if (x11_document == 0 && darwinKeymapFile == NULL)
 179             {
 180                 OSType types[1];
 181                 types[0] = kUnicodeDocument;
 182                 NewTSMDocument (1, types, &x11_document, 0);
 183             }
 184
 185             if (x11_document != 0)
 186                 ActivateTSMDocument (x11_document);
 187         }
 188     }
 189     else
 190     {
 191         QuartzMessageMainThread (kXquartzDeactivate, 0);
 192
 193         if (_x_active)
 194         {
 195             if (x11_document != 0)
 196                 DeactivateTSMDocument (x11_document);
 197         }
 198     }
 199
 200     _x_active = state;
 201 }
 202
 203 - (void) became_key:(NSWindow *)win
 204 {
 205     [self activateX:NO];
 206 }
 207
 208 - (void) sendEvent:(NSEvent *)e
 209 {
 210     NSEventType type;
 211     BOOL for_appkit, for_x;
 212
 213     type = [e type];
 214
 215     /* By default pass down the responder chain and to X. */
 216     for_appkit = YES;
 217     for_x = YES;
 218
 219     switch (type)
 220     {
 221     case NSLeftMouseDown: case NSRightMouseDown: case NSOtherMouseDown:
 222     case NSLeftMouseUp: case NSRightMouseUp: case NSOtherMouseUp:
 223         if ([e window] != nil)
 224         {
 225             /* Pointer event has a window. Probably something for the kit. */
 226
 227             for_x = NO;
 228
 229             if (_x_active)
 230                 [self activateX:NO];
 231         }
 232         else if ([self modalWindow] == nil)
 233         {
 234             /* Must be an X window. Tell appkit it doesn't have focus. */
 235
 236             for_appkit = NO;
 237
 238             if ([self isActive])
 239             {
 240                 [self deactivate];
 241
 242                 if (!_x_active && RootlessKnowsWindowNumber ([e windowNumber]))
 243                     [self activateX:YES];
 244             }
 245         }
 246         break;
 247
 248     case NSKeyDown: case NSKeyUp:
 249         if (_x_active)
 250         {
 251             static int swallow_up;
 252
 253             /* No kit window is focused, so send it to X. */
 254
 255             for_appkit = NO;
 256
 257             if (type == NSKeyDown)
 258             {
 259                 /* Before that though, see if there are any global
 260                    shortcuts bound to it. */
 261
 262                 if (X11EnableKeyEquivalents
 263                     && [[self mainMenu] performKeyEquivalent:e])
 264                 {
 265                     swallow_up = [e keyCode];
 266                     for_x = NO;
 267                 }
 268                 else if (!quartzEnableRootless
 269                          && ([e modifierFlags] & ALL_KEY_MASKS)
 270                             == (NSCommandKeyMask | NSAlternateKeyMask)
 271                          && ([e keyCode] == 0 /*a*/
 272                              || [e keyCode] == 53 /*Esc*/))
 273                 {
 274                     swallow_up = 0;
 275                     for_x = NO;
 276                     QuartzMessageMainThread (kXquartzToggleFullscreen, 0);
 277                 }
 278             }
 279             else
 280             {
 281                 /* If we saw a key equivalent on the down, don't pass
 282                    the up through to X. */
 283
 284                 if (swallow_up != 0 && [e keyCode] == swallow_up)
 285                 {
 286                     swallow_up = 0;
 287                     for_x = NO;
 288                 }
 289             }
 290         }
 291         else
 292         {
 293             for_x = NO;
 294         }
 295         break;
 296
 297     case NSFlagsChanged:
 298         /* For the l33t X users who remap modifier keys to normal keysyms. */
 299         if (!_x_active)
 300             for_x = NO;
 301         break;
 302
 303     case NSAppKitDefined:
 304         switch ([e subtype])
 305         {
 306         case NSApplicationActivatedEventType:
 307             for_x = NO;
 308             if ([self modalWindow] == nil)
 309             {
 310                 for_appkit = NO;
 311
 312                 /* FIXME: hack to avoid having to pass the event to appkit,
 313                    which would cause it to raise one of its windows. */
 314                 _appFlags._active = YES;
 315
 316                 [self activateX:YES];
 317             }
 318             break;
 319
 320         case 18: /* ApplicationDidReactivate */
 321             if (quartzHasRoot)
 322                 for_appkit = NO;
 323             break;
 324
 325         case NSApplicationDeactivatedEventType:
 326             for_x = NO;
 327             [self activateX:NO];
 328             break;
 329         }
 330         break;
 331
 332     default: break; /* for gcc */
 333     }
 334
 335     if (for_appkit)
 336     {
 337         [super sendEvent:e];
 338     }
 339
 340     if (for_x)
 341     {
 342         send_nsevent (type, e);
 343     }
 344 }
 345
 346 - (void) set_window_menu:(NSArray *)list
 347 {
 348     [_controller set_window_menu:list];
 349 }
 350
 351 - (void) set_window_menu_check:(NSNumber *)n
 352 {
 353     [_controller set_window_menu_check:n];
 354 }
 355
 356 - (void) set_apps_menu:(NSArray *)list
 357 {
 358     [_controller set_apps_menu:list];
 359 }
 360
 361 - (void) set_front_process:unused
 362 {
 363     [NSApp activateIgnoringOtherApps:YES];
 364
 365     if ([self modalWindow] == nil)
 366         [self activateX:YES];
 367 }
 368
 369 - (void) set_can_quit:(NSNumber *)state
 370 {
 371     [_controller set_can_quit:[state boolValue]];
 372 }
 373
 374 - (void) server_ready:unused
 375 {
 376     [_controller server_ready];
 377 }
 378
 379 - (void) show_hide_menubar:(NSNumber *)state
 380 {
 381     if ([state boolValue])
 382         ShowMenuBar ();
 383     else
 384         HideMenuBar ();
 385 }
 386
 387 \f
 388 /* user preferences */
 389
 390 /* Note that these functions only work for arrays whose elements
 391    can be toll-free-bridged between NS and CF worlds. */
 392
 393 static const void *cfretain (CFAllocatorRef a, const void *b) {
 394     return CFRetain (b);
 395 }
 396 static void cfrelease (CFAllocatorRef a, const void *b) {
 397     CFRelease (b);
 398 }
 399 static CFMutableArrayRef
 400 nsarray_to_cfarray (NSArray *in)
 401 {
 402     CFMutableArrayRef out;
 403     CFArrayCallBacks cb;
 404     NSObject *ns;
 405     const CFTypeRef *cf;
 406     int i, count;
 407
 408     memset (&cb, 0, sizeof (cb));
 409     cb.version = 0;
 410     cb.retain = cfretain;
 411     cb.release = cfrelease;
 412
 413     count = [in count];
 414     out = CFArrayCreateMutable (NULL, count, &cb);
 415
 416     for (i = 0; i < count; i++)
 417     {
 418         ns = [in objectAtIndex:i];
 419
 420         if ([ns isKindOfClass:[NSArray class]])
 421             cf = (CFTypeRef) nsarray_to_cfarray ((NSArray *) ns);
 422         else
 423             cf = CFRetain ((CFTypeRef) ns);
 424
 425         CFArrayAppendValue (out, cf);
 426         CFRelease (cf);
 427     }
 428
 429     return out;
 430 }
 431 static NSMutableArray *
 432 cfarray_to_nsarray (CFArrayRef in)
 433 {
 434     NSMutableArray *out;
 435     const CFTypeRef *cf;
 436     NSObject *ns;
 437     int i, count;
 438
 439     count = CFArrayGetCount (in);
 440     out = [[NSMutableArray alloc] initWithCapacity:count];
 441
 442     for (i = 0; i < count; i++)
 443     {
 444         cf = CFArrayGetValueAtIndex (in, i);
 445
 446         if (CFGetTypeID (cf) == CFArrayGetTypeID ())
 447             ns = cfarray_to_nsarray ((CFArrayRef) cf);
 448         else
 449             ns = [(id)cf retain];
 450
 451         [out addObject:ns];
 452         [ns release];
 453     }
 454
 455     return out;
 456 }
 457
 458 - (CFPropertyListRef) prefs_get:(NSString *)key
 459 {
 460     CFPropertyListRef value;
 461
 462     value = CFPreferencesCopyAppValue ((CFStringRef) key, CFSTR (APP_PREFS));
 463
 464     if (value == NULL)
 465     {
 466         static CFDictionaryRef defaults;
 467
 468         if (defaults == NULL)
 469         {
 470             CFStringRef error = NULL;
 471             CFDataRef data;
 472             CFURLRef url;
 473             SInt32 error_code;
 474
 475             url = (CFURLCreateFromFileSystemRepresentation
 476                    (NULL, DEFAULTS_FILE, strlen (DEFAULTS_FILE), false));
 477             if (CFURLCreateDataAndPropertiesFromResource (NULL, url, &data,
 478                                                           NULL, NULL,
 479                                                           &error_code))
 480             {
 481                 defaults = (CFPropertyListCreateFromXMLData
 482                             (NULL, data, kCFPropertyListImmutable, &error));
 483                 if (error != NULL)
 484                     CFRelease (error);
 485                 CFRelease (data);
 486             }
 487             CFRelease (url);
 488         }
 489
 490         if (defaults != NULL)
 491             value = CFDictionaryGetValue (defaults, key);
 492
 493         if (value != NULL)
 494             CFRetain (value);
 495     }
 496
 497     return value;
 498 }
 499
 500 - (int) prefs_get_integer:(NSString *)key default:(int)def
 501 {
 502     CFPropertyListRef value;
 503     int ret;
 504
 505     value = [self prefs_get:key];
 506
 507     if (value != NULL && CFGetTypeID (value) == CFNumberGetTypeID ())
 508         CFNumberGetValue (value, kCFNumberIntType, &ret);
 509     else if (value != NULL && CFGetTypeID (value) == CFStringGetTypeID ())
 510         ret = CFStringGetIntValue (value);
 511     else
 512         ret = def;
 513
 514     if (value != NULL)
 515         CFRelease (value);
 516
 517     return ret;
 518 }
 519
 520 - (const char *) prefs_get_string:(NSString *)key default:(const char *)def
 521 {
 522     CFPropertyListRef value;
 523     const char *ret = NULL;
 524
 525     value = [self prefs_get:key];
 526
 527     if (value != NULL && CFGetTypeID (value) == CFStringGetTypeID ())
 528     {
 529         NSString *s = (NSString *) value;
 530
 531         ret = [s UTF8String];
 532     }
 533
 534     if (value != NULL)
 535         CFRelease (value);
 536
 537     return ret != NULL ? ret : def;
 538 }
 539
 540 - (float) prefs_get_float:(NSString *)key default:(float)def
 541 {
 542     CFPropertyListRef value;
 543     float ret = def;
 544
 545     value = [self prefs_get:key];
 546
 547     if (value != NULL
 548         && CFGetTypeID (value) == CFNumberGetTypeID ()
 549         && CFNumberIsFloatType (value))
 550     {
 551         CFNumberGetValue (value, kCFNumberFloatType, &ret);
 552     }
 553     else if (value != NULL && CFGetTypeID (value) == CFStringGetTypeID ())
 554     {
 555         ret = CFStringGetDoubleValue (value);
 556     }
 557
 558     if (value != NULL)
 559         CFRelease (value);
 560
 561     return ret;
 562 }
 563
 564 - (int) prefs_get_boolean:(NSString *)key default:(int)def
 565 {
 566     CFPropertyListRef value;
 567     int ret = def;
 568
 569     value = [self prefs_get:key];
 570
 571     if (value != NULL)
 572     {
 573         if (CFGetTypeID (value) == CFNumberGetTypeID ())
 574             CFNumberGetValue (value, kCFNumberIntType, &ret);
 575         else if (CFGetTypeID (value) == CFBooleanGetTypeID ())
 576             ret = CFBooleanGetValue (value);
 577         else if (CFGetTypeID (value) == CFStringGetTypeID ())
 578         {
 579             const char *tem = [(NSString *) value lossyCString];
 580             if (strcasecmp (tem, "true") == 0 || strcasecmp (tem, "yes") == 0)
 581                 ret = YES;
 582             else
 583                 ret = NO;
 584         }
 585
 586         CFRelease (value);
 587     }
 588
 589     return ret;
 590 }
 591
 592 - (NSArray *) prefs_get_array:(NSString *)key
 593 {
 594     NSArray *ret = nil;
 595     CFPropertyListRef value;
 596
 597     value = [self prefs_get:key];
 598
 599     if (value != NULL)
 600     {
 601         if (CFGetTypeID (value) == CFArrayGetTypeID ())
 602             ret = [cfarray_to_nsarray (value) autorelease];
 603
 604         CFRelease (value);
 605     }
 606
 607     return ret;
 608 }
 609
 610 - (void) prefs_set_integer:(NSString *)key value:(int)value
 611 {
 612     CFNumberRef x;
 613
 614     x = CFNumberCreate (NULL, kCFNumberIntType, &value);
 615
 616     CFPreferencesSetValue ((CFStringRef) key, (CFTypeRef) x, CFSTR (APP_PREFS),
 617                            kCFPreferencesCurrentUser, kCFPreferencesAnyHost);
 618
 619     CFRelease (x);
 620 }
 621
 622 - (void) prefs_set_float:(NSString *)key value:(float)value
 623 {
 624     CFNumberRef x;
 625
 626     x = CFNumberCreate (NULL, kCFNumberFloatType, &value);
 627
 628     CFPreferencesSetValue ((CFStringRef) key, (CFTypeRef) x, CFSTR (APP_PREFS),
 629                            kCFPreferencesCurrentUser, kCFPreferencesAnyHost);
 630
 631     CFRelease (x);
 632 }
 633
 634 - (void) prefs_set_boolean:(NSString *)key value:(int)value
 635 {
 636     CFPreferencesSetValue ((CFStringRef) key,
 637                            (CFTypeRef) value ? kCFBooleanTrue
 638                            : kCFBooleanFalse, CFSTR (APP_PREFS),
 639                            kCFPreferencesCurrentUser, kCFPreferencesAnyHost);
 640
 641 }
 642
 643 - (void) prefs_set_array:(NSString *)key value:(NSArray *)value
 644 {
 645     CFArrayRef cfarray;
 646
 647     cfarray = nsarray_to_cfarray (value);
 648     CFPreferencesSetValue ((CFStringRef) key,
 649                            (CFTypeRef) cfarray,
 650                            CFSTR (APP_PREFS),
 651                            kCFPreferencesCurrentUser, kCFPreferencesAnyHost);
 652     CFRelease (cfarray);
 653 }
 654
 655 - (void) prefs_set_string:(NSString *)key value:(NSString *)value
 656 {
 657     CFPreferencesSetValue ((CFStringRef) key, (CFTypeRef) value,
 658                            CFSTR (APP_PREFS), kCFPreferencesCurrentUser,
 659                            kCFPreferencesAnyHost);
 660 }
 661
 662 - (void) prefs_synchronize
 663 {
 664     CFPreferencesAppSynchronize (kCFPreferencesCurrentApplication);
 665 }
 666
 667 - (void) read_defaults
 668 {
 669     extern int darwinFakeButtons;
 670     const char *tem;
 671
 672     quartzUseSysBeep = [self prefs_get_boolean:@PREFS_SYSBEEP
 673                         default:quartzUseSysBeep];
 674     quartzEnableRootless = [self prefs_get_boolean:@PREFS_ROOTLESS
 675                             default:quartzEnableRootless];
 676     quartzFullscreenDisableHotkeys = ![self prefs_get_boolean:
 677                                        @PREFS_FULLSCREEN_HOTKEYS default:
 678                                        !quartzFullscreenDisableHotkeys];
 679     quartzXpluginOptions = [self prefs_get_integer:@PREFS_XP_OPTIONS
 680                             default:quartzXpluginOptions];
 681
 682     darwinSwapAltMeta = [self prefs_get_boolean:@PREFS_SWAP_ALT_META
 683                          default:darwinSwapAltMeta];
 684     darwinFakeButtons = [self prefs_get_boolean:@PREFS_FAKEBUTTONS
 685                          default:darwinFakeButtons];
 686     if (darwinFakeButtons)
 687     {
 688         const char *fake2, *fake3;
 689
 690         fake2 = [self prefs_get_string:@PREFS_FAKE_BUTTON2 default:NULL];
 691         fake3 = [self prefs_get_string:@PREFS_FAKE_BUTTON3 default:NULL];
 692
 693         DarwinSetFakeButtons (fake2, fake3);
 694     }
 695
 696     X11EnableKeyEquivalents = [self prefs_get_boolean:@PREFS_KEYEQUIVS
 697                                default:X11EnableKeyEquivalents];
 698
 699     darwinSyncKeymap = [self prefs_get_boolean:@PREFS_SYNC_KEYMAP
 700                         default:darwinSyncKeymap];
 701
 702     tem = [self prefs_get_string:@PREFS_KEYMAP_FILE default:NULL];
 703     if (tem != NULL)
 704         darwinKeymapFile = strdup (tem);
 705
 706     quartzDesiredDepth = [self prefs_get_integer:@PREFS_DEPTH
 707                           default:quartzDesiredDepth];
 708 }
 709
 710 /* This will end up at the end of the responder chain. */
 711 - (void) copy:sender
 712 {
 713     QuartzMessageMainThread (kXquartzPasteboardNotify, 1,
 714                              AppleWMCopyToPasteboard);
 715 }
 716
 717 - (BOOL) x_active
 718 {
 719     return _x_active;
 720 }
 721
 722 @end
 723
 724 static NSArray *
 725 array_with_strings_and_numbers (int nitems, const char **items,
 726                                 const char *numbers)
 727 {
 728     NSMutableArray *array, *subarray;
 729     NSString *string;
 730     NSString *number;
 731     int i;
 732
 733     /* (Can't autorelease on the X server thread) */
 734
 735     array = [[NSMutableArray alloc] initWithCapacity:nitems];
 736
 737     for (i = 0; i < nitems; i++)
 738     {
 739         subarray = [[NSMutableArray alloc] initWithCapacity:2];
 740
 741         string = [[NSString alloc] initWithUTF8String:items[i]];
 742         [subarray addObject:string];
 743         [string release];
 744
 745         if (numbers[i] != 0)
 746         {
 747             number = [[NSString alloc] initWithFormat:@"%d", numbers[i]];
 748             [subarray addObject:number];
 749             [number release];
 750         }
 751         else
 752             [subarray addObject:@""];
 753
 754         [array addObject:subarray];
 755         [subarray release];
 756     }
 757
 758     return array;
 759 }
 760
 761 void
 762 X11ApplicationSetWindowMenu (int nitems, const char **items,
 763                              const char *shortcuts)
 764 {
 765     NSArray *array;
 766
 767     array = array_with_strings_and_numbers (nitems, items, shortcuts);
 768
 769     /* Send the array of strings over to the appkit thread */
 770
 771     message_kit_thread (@selector (set_window_menu:), array);
 772     [array release];
 773 }
 774
 775 void
 776 X11ApplicationSetWindowMenuCheck (int idx)
 777 {
 778     NSNumber *n;
 779
 780     n = [[NSNumber alloc] initWithInt:idx];
 781
 782     message_kit_thread (@selector (set_window_menu_check:), n);
 783
 784     [n release];
 785 }
 786
 787 void
 788 X11ApplicationSetFrontProcess (void)
 789 {
 790     message_kit_thread (@selector (set_front_process:), nil);
 791 }
 792
 793 void
 794 X11ApplicationSetCanQuit (int state)
 795 {
 796     NSNumber *n;
 797
 798     n = [[NSNumber alloc] initWithBool:state];
 799
 800     message_kit_thread (@selector (set_can_quit:), n);
 801
 802     [n release];
 803 }
 804
 805 void
 806 X11ApplicationServerReady (void)
 807 {
 808     message_kit_thread (@selector (server_ready:), nil);
 809 }
 810
 811 void
 812 X11ApplicationShowHideMenubar (int state)
 813 {
 814     NSNumber *n;
 815
 816     n = [[NSNumber alloc] initWithBool:state];
 817
 818     message_kit_thread (@selector (show_hide_menubar:), n);
 819
 820     [n release];
 821 }
 822
 823 static void *
 824 create_thread (void *func, void *arg)
 825 {
 826     pthread_attr_t attr;
 827     pthread_t tid;
 828
 829     pthread_attr_init (&attr);
 830
 831     pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
 832     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 833
 834     pthread_create (&tid, &attr, func, arg);
 835
 836     pthread_attr_destroy (&attr);
 837
 838     return (void *) tid;
 839 }
 840
 841 static void
 842 check_xinitrc (void)
 843 {
 844     char *tem, buf[1024];
 845     NSString *msg;
 846
 847     if ([X11App prefs_get_boolean:@PREFS_DONE_XINIT_CHECK default:NO])
 848         return;
 849
 850     tem = getenv ("HOME");
 851     if (tem == NULL)
 852         goto done;
 853
 854     snprintf (buf, sizeof (buf), "%s/.xinitrc", tem);
 855     if (access (buf, F_OK) != 0)
 856         goto done;
 857
 858     /* FIXME: put localized strings into Resources/English.lproj */
 859
 860     msg = NSLocalizedString (
 861 @"You have an existing ~/.xinitrc file.\n\n\
 862 Windows displayed by X11 applications may not have titlebars, or may look \
 863 different to windows displayed by native applications.\n\n\
 864 Would you like to move aside the existing file and use the standard X11 \
 865 environment?", @"");
 866
 867     if (NSRunAlertPanel (nil, msg, NSLocalizedString (@"Yes", @""),
 868                          NSLocalizedString (@"No", @""), nil)
 869         == NSAlertDefaultReturn)
 870     {
 871         char buf2[1024];
 872         int i = -1;
 873
 874         snprintf (buf2, sizeof (buf2), "%s.old", buf);
 875
 876         for (i = 1; access (buf2, F_OK) == 0; i++)
 877              snprintf (buf2, sizeof (buf2), "%s.old.%d", buf, i);
 878
 879         rename (buf, buf2);
 880     }
 881
 882 done:
 883     [X11App prefs_set_boolean:@PREFS_DONE_XINIT_CHECK value:YES];
 884     [X11App prefs_synchronize];
 885 }
 886
 887 void
 888 X11ApplicationMain (int argc, const char *argv[],
 889                     void (*server_thread) (void *), void *server_arg)
 890 {
 891     NSAutoreleasePool *pool;
 892
 893 #ifdef DEBUG
 894     while (access ("/tmp/x11-block", F_OK) == 0)
 895         sleep (1);
 896 #endif
 897
 898     pool = [[NSAutoreleasePool alloc] init];
 899
 900     X11App = (X11Application *) [X11Application sharedApplication];
 901
 902     init_ports ();
 903
 904     [NSApp read_defaults];
 905
 906     [NSBundle loadNibNamed:@"main" owner:NSApp];
 907
 908     [[NSNotificationCenter defaultCenter] addObserver:NSApp
 909      selector:@selector (became_key:)
 910      name:NSWindowDidBecomeKeyNotification object:nil];
 911
 912     check_xinitrc ();
 913
 914     if (!create_thread (server_thread, server_arg))
 915     {
 916         fprintf (stderr, "can't create secondary thread\n");
 917         exit (1);
 918     }
 919
 920     [NSApp run];
 921
 922     /* not reached */
 923 }
 924
 925 \f
 926 /* event conversion */
 927
 928 static inline unsigned short
 929 convert_flags (unsigned int nsflags)
 930 {
 931     unsigned int xflags;
 932
 933     if (nsflags == ~0)
 934         return 0xffff;
 935
 936     xflags = 0;
 937
 938     if (nsflags & NSAlphaShiftKeyMask)
 939         xflags |= LockMask;
 940     if (nsflags & NSShiftKeyMask)
 941         xflags |= ShiftMask;
 942     if (nsflags & NSControlKeyMask)
 943         xflags |= ControlMask;
 944     if (nsflags & NSAlternateKeyMask)
 945         xflags |= Mod1Mask;
 946     if (nsflags & NSCommandKeyMask)
 947         xflags |= Mod2Mask;
 948     /* FIXME: secondaryfn? */
 949
 950     return xflags;
 951 }
 952
 953 static void
 954 send_nsevent (NSEventType type, NSEvent *e)
 955 {
 956     static unsigned int button_state = 0;
 957
 958     xEvent xe;
 959
 960     memset (&xe, 0, sizeof (xe));
 961
 962     switch (type)
 963     {
 964         NSRect screen;
 965         NSPoint location;
 966         NSWindow *window;
 967         int pointer_x, pointer_y, count;
 968
 969     case NSLeftMouseDown:
 970         xe.u.u.type = ButtonPress;
 971         xe.u.u.detail = 1;
 972         goto do_press_event;
 973
 974     case NSRightMouseDown:
 975         xe.u.u.type = ButtonPress;
 976         xe.u.u.detail = 3;
 977         goto do_press_event;
 978
 979     case NSOtherMouseDown:
 980         xe.u.u.type = ButtonPress;
 981         xe.u.u.detail = 2; /* FIXME? */
 982         goto do_press_event;
 983
 984     do_press_event:
 985         if (RootlessKnowsWindowNumber ([e windowNumber]) == NULL)
 986         {
 987             /* X server doesn't grok this window, drop the event.
 988
 989                Note: theoretically this isn't necessary, but if I click
 990                on the menubar, we get sent a LeftMouseDown when the
 991                release happens, but no LeftMouseUp is ever seen! */
 992
 993             break;
 994         }
 995         goto do_event;
 996
 997     case NSLeftMouseUp:
 998         xe.u.u.type = ButtonRelease;
 999         xe.u.u.detail = 1;
1000         goto do_release_event;
1001
1002     case NSRightMouseUp:
1003         xe.u.u.type = ButtonRelease;
1004         xe.u.u.detail = 3;
1005         goto do_release_event;
1006
1007     case NSOtherMouseUp:
1008         xe.u.u.type = ButtonRelease;
1009         xe.u.u.detail = 2; /* FIXME? */
1010         goto do_release_event;
1011
1012     do_release_event:
1013         if ((button_state & (1 << xe.u.u.detail)) == 0)
1014         {
1015             /* X didn't see the button press for this release, so skip it */
1016             break;
1017         }
1018         goto do_event;
1019
1020     case NSMouseMoved:
1021     case NSLeftMouseDragged:
1022     case NSRightMouseDragged:
1023     case NSOtherMouseDragged:
1024         /* convert location to global top-left coordinates */
1025
1026         location = [e locationInWindow];
1027         window = [e window];
1028         screen = [[[NSScreen screens] objectAtIndex:0] frame];
1029
1030         if (window != nil)
1031         {
1032             NSRect frame = [window frame];
1033             pointer_x = location.x + frame.origin.x;
1034             pointer_y = (((screen.origin.y + screen.size.height)
1035                           - location.y) - frame.origin.y);
1036         }
1037         else
1038         {
1039             pointer_x = location.x;
1040             pointer_y = (screen.origin.y + screen.size.height) - location.y;
1041         }
1042
1043         xe.u.keyButtonPointer.rootX = pointer_x;
1044         xe.u.keyButtonPointer.rootY = pointer_y;
1045         xe.u.u.type = MotionNotify;
1046         goto do_event;
1047
1048     case NSKeyDown:
1049         xe.u.u.type = KeyPress;
1050         xe.u.u.detail = [e keyCode];
1051         goto do_event;
1052
1053     case NSKeyUp:
1054         xe.u.u.type = KeyRelease;
1055         xe.u.u.detail = [e keyCode];
1056         goto do_event;
1057
1058     case NSScrollWheel:
1059         xe.u.keyButtonPointer.state = convert_flags ([e modifierFlags]);
1060         count = [e deltaY];
1061         xe.u.u.detail = count > 0 ? 4 : 5;
1062         for (count = abs (count); count-- > 0;)
1063         {
1064             xe.u.u.type = ButtonPress;
1065             DarwinEnqueueEvent (&xe);
1066             xe.u.u.type = ButtonRelease;
1067             DarwinEnqueueEvent (&xe);
1068         }
1069         xe.u.u.type = 0;
1070         break;
1071
1072     case NSFlagsChanged:
1073     do_event:
1074         xe.u.keyButtonPointer.state = convert_flags ([e modifierFlags]);
1075         DarwinEnqueueEvent (&xe);
1076         break;
1077
1078     default: break; /* for gcc */
1079     }
1080
1081     if (xe.u.u.type == ButtonPress)
1082         button_state |= (1 << xe.u.u.detail);
1083     else if (xe.u.u.type == ButtonRelease)
1084         button_state &= ~(1 << xe.u.u.detail);
1085 }