Mac/Python/macglue.c

   1 /***********************************************************
   2 Copyright 1991-1997 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25
  26 #include "Python.h"
  27
  28 #include "macglue.h"
  29 #include "marshal.h"
  30 #include "import.h"
  31 #include "importdl.h"
  32 #include "pymactoolbox.h"
  33
  34 #include "pythonresources.h"
  35
  36 #ifdef WITHOUT_FRAMEWORKS
  37 #include <OSUtils.h> /* for Set(Current)A5 */
  38 #include <Files.h>
  39 #include <StandardFile.h>
  40 #include <Resources.h>
  41 #include <Memory.h>
  42 #include <Windows.h>
  43 #include <Traps.h>
  44 #include <Processes.h>
  45 #include <Fonts.h>
  46 #include <Menus.h>
  47 #include <TextUtils.h>
  48 #include <LowMem.h>
  49 #include <Events.h>
  50 #else
  51 #include <Carbon/Carbon.h>
  52 #endif
  53
  54 #if !TARGET_API_MAC_OS8
  55 /* Unfortunately this call is probably slower... */
  56 #define LMGetTicks() TickCount()
  57 #endif
  58
  59 #ifdef __MWERKS__
  60 #include <SIOUX.h>
  61 extern void SIOUXSetupMenus(void);
  62 extern void SIOUXDoAboutBox(void);
  63 #endif
  64 #ifdef USE_GUSI
  65 /* Functions we redefine because they're in obscure libraries */
  66 extern void SpinCursor(short x);
  67 extern void RotateCursor(short x);
  68 extern pascal void PLstrcpy(unsigned char *, unsigned char *);
  69 extern pascal int PLstrcmp(unsigned char *, unsigned char *);
  70 extern pascal unsigned char *PLstrrchr(unsigned char *, unsigned char);
  71
  72 #endif
  73
  74 #ifdef USE_GUSI1
  75 #include <TFileSpec.h> /* For Path2FSSpec */
  76 #include <GUSI.h>
  77 #endif
  78
  79 /* The ID of the Sioux apple menu */
  80 #define SIOUX_APPLEID   32000
  81
  82 #include <signal.h>
  83 #include <stdio.h>
  84
  85 /*
  86 ** When less than this amount of stackspace is left we
  87 ** raise a MemoryError.
  88 */
  89 #ifndef MINIMUM_STACK_SIZE
  90 #define MINIMUM_STACK_SIZE 8192
  91 #endif
  92
  93 #if TARGET_API_MAC_CARBON
  94 /*
  95 ** On MacOSX StackSpace() lies: it gives the distance from heap end to stack pointer,
  96 ** but the stack cannot grow that far due to rlimit values. We cannot get at this value
  97 ** from Carbon, so we set a maximum to the stack here that is based on the default
  98 ** stack limit of 512K.
  99 */
 100 #define MAXIMUM_STACK_SIZE (256*1024)
 101 #endif
 102
 103 /*
 104 ** We have to be careful, since we can't handle
 105 ** things like updates (and they'll keep coming back if we don't
 106 ** handle them). Note that we don't know who has windows open, so
 107 ** even handing updates off to SIOUX under MW isn't going to work.
 108 */
 109 #define MAINLOOP_EVENTMASK (mDownMask|keyDownMask|osMask|activMask)
 110
 111 #include <signal.h>
 112
 113 /* XXX We should include Errors.h here, but it has a name conflict
 114 ** with the python errors.h. */
 115 #define fnfErr -43
 116
 117 /* Interrupt code variables: */
 118 static int interrupted;                 /* Set to true when cmd-. seen */
 119 static RETSIGTYPE intcatcher(int);
 120
 121 #if !TARGET_API_MAC_OSX
 122 static int PyMac_Yield(void);
 123 #endif
 124
 125 /*
 126 ** These are the real scheduling parameters that control what we check
 127 ** in the event loop, and how often we check. The values are initialized
 128 ** from pyMac_SchedParamStruct.
 129 */
 130
 131 struct real_sched_param_struct {
 132         int             check_interrupt;        /* if true check for command-dot */
 133         int             process_events;         /* if nonzero enable evt processing, this mask */
 134         int             besocial;               /* if nonzero be a little social with CPU */
 135         unsigned long   check_interval;         /* how often to check, in ticks */
 136         unsigned long   bg_yield;               /* yield so long when in background */
 137         /* these are computed from previous and clock and such */
 138         int             enabled;                /* check_interrupt OR process_event OR yield */
 139         unsigned long   next_check;             /* when to check/yield next, in ticks */
 140 };
 141
 142 static struct real_sched_param_struct schedparams =
 143         { 1, MAINLOOP_EVENTMASK, 1, 15, 15, 1, 0};
 144
 145 /*
 146 ** Workaround for sioux/gusi combo: set when we are exiting
 147 */
 148 int PyMac_ConsoleIsDead;
 149
 150 /*
 151 ** Sioux menu bar, saved early so we can restore it
 152 */
 153 static MenuBarHandle sioux_mbar;
 154
 155 /*
 156 ** Some stuff for our GetDirectory and PromptGetFile routines
 157 */
 158 struct hook_args {
 159         int selectcur_hit;              /* Set to true when "select current" selected */
 160         char *prompt;                   /* The prompt */
 161 };
 162 #if !TARGET_API_MAC_OS8
 163 /* The StandardFile hooks don't exist in Carbon. This breaks GetDirectory,
 164 ** but the macfsn code will replace it by a NavServices version anyway.
 165 */
 166 #define myhook_upp NULL
 167 #else
 168 static DlgHookYDUPP myhook_upp;
 169 static int upp_inited = 0;
 170 #endif
 171
 172 /*
 173 ** The python-code event handler
 174 */
 175 static PyObject *python_event_handler;
 176
 177 /*
 178 ** Set to true if we're appearance-compliant
 179 */
 180 int PyMac_AppearanceCompliant;
 181
 182 /* Given an FSSpec, return the FSSpec of the parent folder */
 183
 184 static OSErr
 185 get_folder_parent (FSSpec * fss, FSSpec * parent)
 186 {
 187         CInfoPBRec rec;
 188         short err;
 189
 190         * parent = * fss;
 191         rec.hFileInfo.ioNamePtr = parent->name;
 192         rec.hFileInfo.ioVRefNum = parent->vRefNum;
 193         rec.hFileInfo.ioDirID = parent->parID;
 194                 rec.hFileInfo.ioFDirIndex = -1;
 195         rec.hFileInfo.ioFVersNum = 0;
 196         if (err = PBGetCatInfoSync (& rec))
 197                 return err;
 198         parent->parID = rec.dirInfo.ioDrParID;
 199 /*      parent->name[0] = 0; */
 200         return 0;
 201 }
 202
 203 /* Given an FSSpec return a full, colon-separated pathname */
 204
 205 OSErr
 206 PyMac_GetFullPathname (FSSpec *fss, char *buf, int length)
 207 {
 208         short err;
 209         FSSpec fss_parent, fss_current;
 210         char tmpbuf[1024];
 211         int plen;
 212
 213         fss_current = *fss;
 214         plen = fss_current.name[0];
 215         if ( plen+2 > length ) {
 216                 *buf = 0;
 217                 return errFSNameTooLong;
 218         }
 219         memcpy(buf, &fss_current.name[1], plen);
 220         buf[plen] = 0;
 221         /* Special case for disk names */
 222         if ( fss_current.parID <= 1 ) {
 223                 buf[plen++] = ':';
 224                 buf[plen] = 0;
 225                 return 0;
 226         }
 227         while (fss_current.parID > 1) {
 228                 /* Get parent folder name */
 229                 if (err = get_folder_parent(&fss_current, &fss_parent)) {
 230                         *buf = 0;
 231                         return err;
 232                 }
 233                 fss_current = fss_parent;
 234                 /* Prepend path component just found to buf */
 235                         plen = fss_current.name[0];
 236                         if (strlen(buf) + plen + 1 > 1024) {
 237                                 /* Oops... Not enough space (shouldn't happen) */
 238                                 *buf = 0;
 239                                 return errFSNameTooLong;
 240                         }
 241                         memcpy(tmpbuf, &fss_current.name[1], plen);
 242                         tmpbuf[plen] = ':';
 243                         strcpy(&tmpbuf[plen+1], buf);
 244                         if ( strlen(tmpbuf) > length ) {
 245                                 *buf = 0;
 246                                 return errFSNameTooLong;
 247                         }
 248                         strcpy(buf, tmpbuf);
 249         }
 250         return 0;
 251 }
 252
 253 #ifdef USE_GUSI1
 254 /*
 255 ** GUSI (1.6.0 and earlier, at the least) do not set the MacOS idea of
 256 ** the working directory. Hence, we call this routine after each call
 257 ** to chdir() to rectify things.
 258 */
 259 void
 260 PyMac_FixGUSIcd()
 261 {
 262         WDPBRec pb;
 263         FSSpec curdirfss;
 264
 265         if ( Path2FSSpec(":x", &curdirfss) != noErr )
 266                 return;
 267
 268         /* Set MacOS "working directory" */
 269         pb.ioNamePtr= "\p";
 270         pb.ioVRefNum= curdirfss.vRefNum;
 271         pb.ioWDDirID= curdirfss.parID;
 272         if (PBHSetVolSync(&pb) != noErr)
 273                 return;
 274 }
 275 #endif
 276
 277 #ifdef USE_GUSI
 278 /*
 279 ** SpinCursor (needed by GUSI) drags in heaps of stuff, so we
 280 ** provide a dummy here.
 281 */
 282 void SpinCursor(short x) { /* Dummy */ }
 283 void RotateCursor(short x) { /* Dummy */ }
 284
 285 /*
 286 ** Replacement GUSI Spin function
 287 */
 288 #ifdef USE_GUSI1
 289 static int
 290 PyMac_GUSISpin(spin_msg msg, long arg)
 291 {
 292         static Boolean  inForeground = true;
 293         int             maxsleep = 6;   /* 6 ticks is "normal" sleeptime */
 294
 295         if (PyMac_ConsoleIsDead) return 0;
 296 #if 0
 297         if (inForeground)
 298                 SpinCursor(msg == SP_AUTO_SPIN ? short(arg) : 1);
 299 #endif
 300
 301
 302         if ( msg == SP_AUTO_SPIN )
 303                 maxsleep = 0;
 304         if ( msg==SP_SLEEP||msg==SP_SELECT ) {
 305                 maxsleep = arg;
 306                 /*
 307                 ** We force-scan for interrupts. Not pretty, but otherwise
 308                 ** a program may hang in select or sleep forever.
 309                 */
 310                 scan_event_queue(1);
 311         }
 312         if (interrupted) {
 313                 interrupted = 0;
 314                 return -1;
 315         }
 316
 317         PyMac_DoYield(maxsleep, 0); /* XXXX or is it safe to call python here? */
 318
 319         return 0;
 320 }
 321
 322 void
 323 PyMac_SetGUSISpin() {
 324         GUSISetHook(GUSI_SpinHook, (GUSIHook)PyMac_GUSISpin);
 325 }
 326 #endif
 327
 328 /* Called at exit() time thru atexit(), to stop event processing */
 329 void
 330 PyMac_StopGUSISpin() {
 331         PyMac_ConsoleIsDead = 1;
 332 }
 333
 334 #if TARGET_API_MAC_OS8
 335 /*
 336 ** Replacement routines for the PLstr... functions so we don't need
 337 ** StdCLib.
 338 */
 339 pascal void
 340 PLstrcpy(unsigned char *to, unsigned char *fr)
 341 {
 342         memcpy(to, fr, fr[0]+1);
 343 }
 344
 345 pascal int
 346 PLstrcmp(unsigned char *s1, unsigned char *s2)
 347 {
 348         int res;
 349         int l = s1[0] < s2[0] ? s1[0] : s2[0];
 350
 351         res = memcmp(s1+1, s2+1, l);
 352         if ( res != 0 )
 353                 return res;
 354
 355         if ( s1[0] < s2[0] )
 356                 return -1;
 357         else if ( s1[0] > s2[0] )
 358                 return 1;
 359         else
 360                 return 0;
 361 }
 362
 363 pascal unsigned char *
 364 PLstrrchr(unsigned char *str, unsigned char chr)
 365 {
 366         unsigned char *ptr = 0;
 367         unsigned char *p;
 368
 369         for(p=str+1; p<str+str[0]; p++)
 370                 if ( *p == chr )
 371                         ptr = p;
 372         return ptr;
 373 }
 374
 375 #endif /* TARGET_API_MAC_OS8 */
 376 #endif /* USE_GUSI */
 377
 378
 379 /* Convert C to Pascal string. Returns pointer to static buffer. */
 380 unsigned char *
 381 Pstring(char *str)
 382 {
 383         static Str255 buf;
 384         int len;
 385
 386         len = strlen(str);
 387         if (len > 255)
 388                 len = 255;
 389         buf[0] = (unsigned char)len;
 390         strncpy((char *)buf+1, str, len);
 391         return buf;
 392 }
 393
 394 #if TARGET_API_MAC_OS8
 395 Point
 396 LMGetMouse(void)
 397 {
 398         return LMGetMouseLocation();
 399 }
 400
 401 long LMGetExpandMem(void)
 402 {
 403         return 0;
 404 }
 405
 406 void
 407 c2pstrcpy(unsigned char *dst, const char *src)
 408 {
 409         int len;
 410
 411         len = strlen(src);
 412         if ( len > 255 ) len = 255;
 413         strncpy((char *)dst+1, src, len);
 414         dst[0] = len;
 415 }
 416 #endif /* TARGET_API_MAC_OS8 */
 417
 418 #ifdef USE_STACKCHECK
 419 /* Check for stack overflow */
 420 int
 421 PyOS_CheckStack()
 422 {
 423         char here;
 424         static char *sentinel = 0;
 425         static PyThreadState *thread_for_sentinel = 0;
 426
 427         if ( sentinel == 0 ) {
 428                 unsigned long stackspace = StackSpace();
 429
 430 #ifdef MAXIMUM_STACK_SIZE
 431         /* See the comment at the definition */
 432         if ( stackspace > MAXIMUM_STACK_SIZE )
 433                 stackspace = MAXIMUM_STACK_SIZE;
 434 #endif
 435                 sentinel = &here - stackspace + MINIMUM_STACK_SIZE;
 436         }
 437         if ( thread_for_sentinel == 0 ) {
 438                 thread_for_sentinel = PyThreadState_Get();
 439         }
 440         if ( &here < sentinel ) {
 441                 if (thread_for_sentinel == PyThreadState_Get()) {
 442                         return -1;
 443 #if 0
 444                 } else {
 445                         /* Else we are unsure... */
 446                         fprintf(stderr, "Stackcheck in other thread (was %x now %x)\n", thread_for_sentinel,PyThreadState_Get());
 447 #endif
 448                 }
 449         }
 450         return 0;
 451 }
 452 #endif /* USE_STACKCHECK */
 453
 454 #if !TARGET_API_MAC_OSX
 455 /* The catcher routine (which may not be used for all compilers) */
 456 static RETSIGTYPE
 457 intcatcher(sig)
 458         int sig;
 459 {
 460         interrupted = 1;
 461         signal(SIGINT, intcatcher);
 462 }
 463
 464 void
 465 PyOS_InitInterrupts()
 466 {
 467         if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 468                 signal(SIGINT, intcatcher);
 469 }
 470
 471 void
 472 PyOS_FiniInterrupts()
 473 {
 474 }
 475
 476 /* Check whether we are in the foreground */
 477 static int
 478 PyMac_InForeground(void)
 479 {
 480         static ProcessSerialNumber ours;
 481         static inited;
 482         ProcessSerialNumber curfg;
 483         Boolean eq;
 484
 485         if ( inited == 0 ) {
 486                 (void)GetCurrentProcess(&ours);
 487                 inited = 1;
 488         }
 489         if ( GetFrontProcess(&curfg) < 0 )
 490                 eq = 1;
 491         else if ( SameProcess(&ours, &curfg, &eq) < 0 )
 492                 eq = 1;
 493         return (int)eq;
 494 }
 495
 496 /*
 497 ** This routine scans the event queue looking for cmd-.
 498 */
 499 static void
 500 scan_event_queue(force)
 501         int force;
 502 {
 503 #if !TARGET_API_MAC_OS8
 504         if ( interrupted || (!schedparams.check_interrupt && !force) )
 505                 return;
 506         if ( CheckEventQueueForUserCancel() )
 507                 interrupted = 1;
 508 #else
 509         register EvQElPtr q;
 510
 511         if ( interrupted || (!schedparams.check_interrupt && !force) || !PyMac_InForeground() )
 512                 return;
 513         q = (EvQElPtr) LMGetEventQueue()->qHead;
 514
 515         for (; q; q = (EvQElPtr)q->qLink) {
 516                 if (q->evtQWhat == keyDown &&
 517                                 (char)q->evtQMessage == '.' &&
 518                                 (q->evtQModifiers & cmdKey) != 0) {
 519                         FlushEvents(keyDownMask, 0);
 520                         interrupted = 1;
 521                         break;
 522                 }
 523         }
 524 #endif
 525 }
 526
 527 int
 528 PyErr_CheckSignals()
 529 {
 530         if (schedparams.enabled) {
 531                 if ( interrupted || (unsigned long)LMGetTicks() > schedparams.next_check ) {
 532                         scan_event_queue(0);
 533                         if (interrupted) {
 534                                 interrupted = 0;
 535                                 PyErr_SetNone(PyExc_KeyboardInterrupt);
 536                                 return -1;
 537                         }
 538                         if ( PyMac_Yield() < 0)
 539                                 return -1;
 540                         schedparams.next_check = (unsigned long)LMGetTicks()
 541                                          + schedparams.check_interval;
 542                 }
 543         }
 544         return 0;
 545 }
 546
 547 int
 548 PyOS_InterruptOccurred()
 549 {
 550         scan_event_queue(0);
 551         if ( !interrupted )
 552                 return 0;
 553         interrupted = 0;
 554         return 1;
 555 }
 556 #endif
 557
 558 int
 559 PyMac_SetEventHandler(PyObject *evh)
 560 {
 561         if ( evh && python_event_handler ) {
 562                 PyErr_SetString(PyExc_RuntimeError, "Python event handler already set");
 563                 return 0;
 564         }
 565         if ( python_event_handler )
 566                 Py_DECREF(python_event_handler);
 567         if ( evh )
 568                 Py_INCREF(evh);
 569         python_event_handler = evh;
 570         return 1;
 571 }
 572
 573 /*
 574 ** Handle an event, either one found in the mainloop eventhandler or
 575 ** one passed back from the python program.
 576 */
 577 void
 578 PyMac_HandleEventIntern(evp)
 579         EventRecord *evp;
 580 {
 581 #if TARGET_API_MAC_OS8
 582         if ( evp->what == mouseDown ) {
 583                 WindowPtr wp;
 584
 585                 if ( FindWindow(evp->where, &wp) == inSysWindow ) {
 586                         SystemClick(evp, wp);
 587                         return;
 588                 }
 589         }
 590 #endif
 591 #ifdef __MWERKS__
 592         {
 593                 int siouxdidit;
 594
 595                 /* If SIOUX wants it we're done */
 596                 siouxdidit = SIOUXHandleOneEvent(evp);
 597                 if ( siouxdidit )
 598                         return;
 599         }
 600 #else
 601         /* Other compilers are just unlucky... */
 602 #endif /* !__MWERKS__ */
 603 }
 604
 605 /*
 606 ** Handle an event, either through HandleEvent or by passing it to the Python
 607 ** event handler.
 608 */
 609 int
 610 PyMac_HandleEvent(evp)
 611         EventRecord *evp;
 612 {
 613         PyObject *rv;
 614
 615         if ( python_event_handler ) {
 616                 rv = PyObject_CallFunction(python_event_handler, "(O&)",
 617                         PyMac_BuildEventRecord, evp);
 618                 if ( rv )
 619                         Py_DECREF(rv);
 620                 else
 621                         return -1;      /* Propagate exception */
 622         } else {
 623                 PyMac_HandleEventIntern(evp);
 624         }
 625         return 0;
 626 }
 627
 628 #if !TARGET_API_MAC_OSX
 629 /*
 630 ** Yield the CPU to other tasks without processing events.
 631 */
 632 int
 633 PyMac_DoYield(int maxsleep, int maycallpython)
 634 {
 635         EventRecord ev;
 636         int gotone;
 637         long latest_time_ready;
 638         static int in_here = 0;
 639
 640         in_here++;
 641
 642         /*
 643         ** Check which of the eventloop cases we have:
 644         ** - process events
 645         ** - don't process events but do yield
 646         ** - do neither
 647         */
 648         if( in_here > 1 || !schedparams.process_events ||
 649             (python_event_handler && !maycallpython) ) {
 650                 if ( maxsleep >= 0 ) {
 651 #if TARGET_API_MAC_OS8
 652                         SystemTask();
 653 #else
 654                         int xxx = 0;
 655 #endif
 656                 }
 657         } else {
 658                 latest_time_ready = LMGetTicks() + maxsleep;
 659                 do {
 660                         /* XXXX Hack by Jack.
 661                         ** In time.sleep() you can click to another application
 662                         ** once only. If you come back to Python you cannot get away
 663                         ** again.
 664                         **/
 665                         gotone = WaitNextEvent(schedparams.process_events, &ev, maxsleep, NULL);
 666                         /* Get out quickly if nothing interesting is happening */
 667                         if ( !gotone || ev.what == nullEvent )
 668                                 break;
 669                         if ( PyMac_HandleEvent(&ev) < 0 ) {
 670                                 in_here--;
 671                                 return -1;
 672                         }
 673                         maxsleep = latest_time_ready - LMGetTicks();
 674                 } while ( maxsleep > 0 );
 675         }
 676         in_here--;
 677         return 0;
 678 }
 679
 680 /*
 681 ** Process events and/or yield the CPU to other tasks if opportune
 682 */
 683 int
 684 PyMac_Yield() {
 685         unsigned long maxsleep;
 686
 687         if( PyMac_InForeground() )
 688                 maxsleep = 0;
 689         else
 690                 maxsleep = schedparams.bg_yield;
 691
 692         return PyMac_DoYield(maxsleep, 1);
 693 }
 694
 695 /*
 696 ** Return current scheduler parameters
 697 */
 698 void
 699 PyMac_GetSchedParams(PyMacSchedParams *sp)
 700 {
 701         sp->check_interrupt = schedparams.check_interrupt;
 702         sp->process_events = schedparams.process_events;
 703         sp->besocial = schedparams.besocial;
 704         sp->check_interval = schedparams.check_interval / 60.0;
 705         sp->bg_yield = schedparams.bg_yield / 60.0;
 706 }
 707
 708 /*
 709 ** Set current scheduler parameters
 710 */
 711 void
 712 PyMac_SetSchedParams(PyMacSchedParams *sp)
 713 {
 714         schedparams.check_interrupt = sp->check_interrupt;
 715         schedparams.process_events = sp->process_events;
 716         schedparams.besocial = sp->besocial;
 717         schedparams.check_interval = (unsigned long)(sp->check_interval*60);
 718         schedparams.bg_yield = (unsigned long)(sp->bg_yield*60);
 719         if ( schedparams.check_interrupt || schedparams.process_events ||
 720              schedparams.besocial )
 721                 schedparams.enabled = 1;
 722         else
 723                 schedparams.enabled = 0;
 724         schedparams.next_check = 0;     /* Check immedeately */
 725 }
 726
 727 /*
 728 ** Install our menu bar.
 729 */
 730 void
 731 PyMac_InitMenuBar()
 732 {
 733         MenuHandle applemenu;
 734         Str255 about_text;
 735         static unsigned char about_sioux[] = "\pAbout SIOUX";
 736
 737         if ( sioux_mbar ) return;
 738 #if 0
 739         /* This code does not seem to work anymore: apparently
 740         ** we now always have a menubar (since MacOS9?).
 741         ** So we simply always setup the Sioux menus here.
 742         */
 743         if ( (sioux_mbar=GetMenuBar()) == NULL )  {
 744 #else
 745         if ( (sioux_mbar=GetMenuBar()) == NULL || GetMenuHandle(SIOUX_APPLEID) == NULL)  {
 746 #endif
 747                 /* Sioux menu not installed yet. Do so */
 748                 SIOUXSetupMenus();
 749                 if ( (sioux_mbar=GetMenuBar()) == NULL )
 750                         return;
 751         }
 752         if ( (applemenu=GetMenuHandle(SIOUX_APPLEID)) == NULL ) return;
 753         GetMenuItemText(applemenu, 1, about_text);
 754         if ( about_text[0] == about_sioux[0] &&
 755                 strncmp((char *)(about_text+1), (char *)(about_sioux+1), about_text[0]) == 0 )
 756                 SetMenuItemText(applemenu, 1, "\pAbout Python...");
 757 }
 758
 759 /*
 760 ** Restore sioux menu bar
 761 */
 762 void
 763 PyMac_RestoreMenuBar()
 764 {
 765 #if 1
 766         /* This doesn't seem to work anymore? Or only for Carbon? */
 767         MenuBarHandle curmenubar;
 768
 769         curmenubar = GetMenuBar();
 770         if ( sioux_mbar ) {
 771                 SetMenuBar(sioux_mbar);
 772                 DrawMenuBar();
 773         } else {
 774                 PyMac_InitMenuBar();
 775                 DrawMenuBar();
 776         }
 777 #endif
 778 }
 779
 780 void
 781 PyMac_RaiseConsoleWindow()
 782 {
 783         /* Note: this is a hack. SIOUXTextWindow is SIOUX's internal structure
 784         ** and we happen to know that the first entry is the window pointer.
 785         */
 786         extern WindowRef *SIOUXTextWindow;
 787
 788         if ( SIOUXTextWindow == NULL || *SIOUXTextWindow == NULL )
 789                 return;
 790         if ( FrontWindow() != *SIOUXTextWindow )
 791                 BringToFront(*SIOUXTextWindow);
 792 }
 793
 794 /*
 795 ** Our replacement about box
 796 */
 797
 798 #include "patchlevel.h"
 799
 800 void
 801 SIOUXDoAboutBox(void)
 802 {
 803         DialogPtr theDialog;
 804         WindowPtr theWindow;
 805         short item;
 806         short fontID;
 807
 808         if( (theDialog = GetNewDialog(ABOUT_ID, NULL, (WindowPtr)-1)) == NULL )
 809                 return;
 810         theWindow = GetDialogWindow(theDialog);
 811         SetPortWindowPort(theWindow);
 812         GetFNum("\pPython-Sans", &fontID);
 813         if (fontID == 0)
 814                 fontID = kFontIDGeneva;
 815         TextFont(fontID);
 816         TextSize(9);
 817         ParamText(Pstring(PY_VERSION), "\p", "\p", "\p");
 818         ShowWindow(theWindow);
 819         ModalDialog(NULL, &item);
 820         DisposeDialog(theDialog);
 821 }
 822
 823 #endif /* !TARGET_API_MAC_OSX */
 824
 825 #if TARGET_API_MAC_OS8
 826 /*
 827 ** Helper routine for GetDirectory
 828 */
 829 static pascal short
 830 myhook_proc(short item, DialogPtr theDialog, struct hook_args *dataptr)
 831 {
 832         if ( item == sfHookFirstCall && dataptr->prompt) {
 833                 Handle prompth;
 834                 short type;
 835                 Rect rect;
 836
 837                 GetDialogItem(theDialog, PROMPT_ITEM, &type, &prompth, &rect);
 838                 if ( prompth )
 839                         SetDialogItemText(prompth, (unsigned char *)dataptr->prompt);
 840         } else
 841         if ( item == SELECTCUR_ITEM ) {
 842                 item = sfItemCancelButton;
 843                 dataptr->selectcur_hit = 1;
 844         }
 845         return item;
 846 }
 847
 848 /*
 849 ** Ask the user for a directory. I still can't understand
 850 ** why Apple doesn't provide a standard solution for this...
 851 */
 852 int
 853 PyMac_GetDirectory(dirfss, prompt)
 854         FSSpec *dirfss;
 855         char *prompt;
 856 {
 857         static SFTypeList list = {'fldr', 0, 0, 0};
 858         static Point where = {-1, -1};
 859         StandardFileReply reply;
 860         struct hook_args hook_args;
 861
 862         if ( !upp_inited ) {
 863                 myhook_upp = NewDlgHookYDProc(myhook_proc);
 864                 upp_inited = 1;
 865         }
 866         if ( prompt && *prompt )
 867                 hook_args.prompt = (char *)Pstring(prompt);
 868         else
 869                 hook_args.prompt = NULL;
 870         hook_args.selectcur_hit = 0;
 871         CustomGetFile((FileFilterYDUPP)0, 1, list, &reply, GETDIR_ID, where, myhook_upp,
 872                                 NULL, NULL, NULL, (void *)&hook_args);
 873
 874         reply.sfFile.name[0] = 0;
 875         if( FSMakeFSSpec(reply.sfFile.vRefNum, reply.sfFile.parID, reply.sfFile.name, dirfss) )
 876                 return 0;
 877         return hook_args.selectcur_hit;
 878 }
 879
 880 /*
 881 ** Slightly extended StandardGetFile: accepts a prompt */
 882 void PyMac_PromptGetFile(short numTypes, ConstSFTypeListPtr typeList,
 883                 StandardFileReply *reply, char *prompt)
 884 {
 885         static Point where = {-1, -1};
 886         struct hook_args hook_args;
 887
 888         if ( !upp_inited ) {
 889                 myhook_upp = NewDlgHookYDProc(myhook_proc);
 890                 upp_inited = 1;
 891         }
 892         if ( prompt && *prompt )
 893                 hook_args.prompt = (char *)Pstring(prompt);
 894         else
 895                 hook_args.prompt = NULL;
 896         hook_args.selectcur_hit = 0;
 897         CustomGetFile((FileFilterYDUPP)0, numTypes, typeList, reply, GETFILEPROMPT_ID, where,
 898                                 myhook_upp, NULL, NULL, NULL, (void *)&hook_args);
 899 }
 900 #endif /* TARGET_API_MAC_OS8 */
 901
 902