Lib/plat-mac/FrameWork.py

   1 "A sort of application framework for the Mac"
   2
   3 DEBUG=0
   4
   5 from warnings import warnpy3k
   6 warnpy3k("In 3.x, the FrameWork module is removed.", stacklevel=2)
   7
   8 import MacOS
   9 import traceback
  10
  11 from Carbon.AE import *
  12 from Carbon.AppleEvents import *
  13 from Carbon.Ctl import *
  14 from Carbon.Controls import *
  15 from Carbon.Dlg import *
  16 from Carbon.Dialogs import *
  17 from Carbon.Evt import *
  18 from Carbon.Events import *
  19 from Carbon.Help import *
  20 from Carbon.Menu import *
  21 from Carbon.Menus import *
  22 from Carbon.Qd import *
  23 from Carbon.QuickDraw import *
  24 #from Carbon.Res import *
  25 #from Carbon.Resources import *
  26 #from Carbon.Snd import *
  27 #from Carbon.Sound import *
  28 from Carbon.Win import *
  29 from Carbon.Windows import *
  30 import types
  31
  32 import EasyDialogs
  33
  34 try:
  35     MyFrontWindow = FrontNonFloatingWindow
  36 except NameError:
  37     MyFrontWindow = FrontWindow
  38
  39 kHighLevelEvent = 23    # Don't know what header file this should come from
  40 SCROLLBARWIDTH = 16         # Again, not a clue...
  41
  42 # Trick to forestall a set of SIOUX menus being added to our menubar
  43 SIOUX_APPLEMENU_ID=32000
  44
  45
  46 # Map event 'what' field to strings
  47 eventname = {}
  48 eventname[1] = 'mouseDown'
  49 eventname[2] = 'mouseUp'
  50 eventname[3] = 'keyDown'
  51 eventname[4] = 'keyUp'
  52 eventname[5] = 'autoKey'
  53 eventname[6] = 'updateEvt'
  54 eventname[7] = 'diskEvt'
  55 eventname[8] = 'activateEvt'
  56 eventname[15] = 'osEvt'
  57 eventname[23] = 'kHighLevelEvent'
  58
  59 # Map part codes returned by WhichWindow() to strings
  60 partname = {}
  61 partname[0] = 'inDesk'
  62 partname[1] = 'inMenuBar'
  63 partname[2] = 'inSysWindow'
  64 partname[3] = 'inContent'
  65 partname[4] = 'inDrag'
  66 partname[5] = 'inGrow'
  67 partname[6] = 'inGoAway'
  68 partname[7] = 'inZoomIn'
  69 partname[8] = 'inZoomOut'
  70
  71 #
  72 # The useable portion of the screen
  73 #       ## but what happens with multiple screens? jvr
  74 screenbounds = GetQDGlobalsScreenBits().bounds
  75 screenbounds = screenbounds[0]+4, screenbounds[1]+4, \
  76     screenbounds[2]-4, screenbounds[3]-4
  77
  78 next_window_x = 16          # jvr
  79 next_window_y = 44          # jvr
  80
  81 def windowbounds(width, height):
  82     "Return sensible window bounds"
  83     global next_window_x, next_window_y
  84     r, b = next_window_x+width, next_window_y+height
  85     if r > screenbounds[2]:
  86         next_window_x = 16
  87     if b > screenbounds[3]:
  88         next_window_y = 44
  89     l, t = next_window_x, next_window_y
  90     r, b = next_window_x+width, next_window_y+height
  91     next_window_x, next_window_y = next_window_x + 8, next_window_y + 20    # jvr
  92     return l, t, r, b
  93
  94 _watch = None
  95 def setwatchcursor():
  96     global _watch
  97
  98     if _watch is None:
  99         _watch = GetCursor(4).data
 100     SetCursor(_watch)
 101
 102 def setarrowcursor():
 103     SetCursor(GetQDGlobalsArrow())
 104
 105 class Application:
 106
 107     "Application framework -- your application should be a derived class"
 108
 109     def __init__(self, nomenubar=0):
 110         self._doing_asyncevents = 0
 111         self.quitting = 0
 112         self.needmenubarredraw = 0
 113         self._windows = {}
 114         self._helpmenu = None
 115         if nomenubar:
 116             self.menubar = None
 117         else:
 118             self.makemenubar()
 119
 120     def __del__(self):
 121         if self._doing_asyncevents:
 122             self._doing_asyncevents = 0
 123             MacOS.SetEventHandler()
 124
 125     def makemenubar(self):
 126         self.menubar = MenuBar(self)
 127         AppleMenu(self.menubar, self.getabouttext(), self.do_about)
 128         self.makeusermenus()
 129
 130     def makeusermenus(self):
 131         self.filemenu = m = Menu(self.menubar, "File")
 132         self._quititem = MenuItem(m, "Quit", "Q", self._quit)
 133
 134     def gethelpmenu(self):
 135         if self._helpmenu is None:
 136             self._helpmenu = HelpMenu(self.menubar)
 137         return self._helpmenu
 138
 139     def _quit(self, *args):
 140         self.quitting = 1
 141
 142     def cleanup(self):
 143         for w in self._windows.values():
 144             w.do_close()
 145         return self._windows == {}
 146
 147     def appendwindow(self, wid, window):
 148         self._windows[wid] = window
 149
 150     def removewindow(self, wid):
 151         del self._windows[wid]
 152
 153     def getabouttext(self):
 154         return "About %s..." % self.__class__.__name__
 155
 156     def do_about(self, id, item, window, event):
 157         EasyDialogs.Message("Hello, world!" + "\015(%s)" % self.__class__.__name__)
 158
 159     # The main event loop is broken up in several simple steps.
 160     # This is done so you can override each individual part,
 161     # if you have a need to do extra processing independent of the
 162     # event type.
 163     # Normally, however, you'd just define handlers for individual
 164     # events.
 165
 166     schedparams = (0, 0)    # By default disable Python's event handling
 167     default_wait = None         # By default we wait GetCaretTime in WaitNextEvent
 168
 169     def mainloop(self, mask = everyEvent, wait = None):
 170         self.quitting = 0
 171         if hasattr(MacOS, 'SchedParams'):
 172             saveparams = MacOS.SchedParams(*self.schedparams)
 173         try:
 174             while not self.quitting:
 175                 try:
 176                     self.do1event(mask, wait)
 177                 except (Application, SystemExit):
 178                     # Note: the raising of "self" is old-fashioned idiom to
 179                     # exit the mainloop. Calling _quit() is better for new
 180                     # applications.
 181                     break
 182         finally:
 183             if hasattr(MacOS, 'SchedParams'):
 184                 MacOS.SchedParams(*saveparams)
 185
 186     def dopendingevents(self, mask = everyEvent):
 187         """dopendingevents - Handle all pending events"""
 188         while self.do1event(mask, wait=0):
 189             pass
 190
 191     def do1event(self, mask = everyEvent, wait = None):
 192         ok, event = self.getevent(mask, wait)
 193         if IsDialogEvent(event):
 194             if self.do_dialogevent(event):
 195                 return
 196         if ok:
 197             self.dispatch(event)
 198         else:
 199             self.idle(event)
 200
 201     def idle(self, event):
 202         pass
 203
 204     def getevent(self, mask = everyEvent, wait = None):
 205         if self.needmenubarredraw:
 206             DrawMenuBar()
 207             self.needmenubarredraw = 0
 208         if wait is None:
 209             wait = self.default_wait
 210             if wait is None:
 211                 wait = GetCaretTime()
 212         ok, event = WaitNextEvent(mask, wait)
 213         return ok, event
 214
 215     def dispatch(self, event):
 216         # The following appears to be double work (already done in do1event)
 217         # but we need it for asynchronous event handling
 218         if IsDialogEvent(event):
 219             if self.do_dialogevent(event):
 220                 return
 221         (what, message, when, where, modifiers) = event
 222         if eventname.has_key(what):
 223             name = "do_" + eventname[what]
 224         else:
 225             name = "do_%d" % what
 226         try:
 227             handler = getattr(self, name)
 228         except AttributeError:
 229             handler = self.do_unknownevent
 230         handler(event)
 231
 232     def asyncevents(self, onoff):
 233         """asyncevents - Set asynchronous event handling on or off"""
 234         if MacOS.runtimemodel == 'macho':
 235             raise 'Unsupported in MachoPython'
 236         old = self._doing_asyncevents
 237         if old:
 238             MacOS.SetEventHandler()
 239             MacOS.SchedParams(*self.schedparams)
 240         if onoff:
 241             MacOS.SetEventHandler(self.dispatch)
 242             doint, dummymask, benice, howoften, bgyield = \
 243                    self.schedparams
 244             MacOS.SchedParams(doint, everyEvent, benice,
 245                       howoften, bgyield)
 246         self._doing_asyncevents = onoff
 247         return old
 248
 249     def do_dialogevent(self, event):
 250         gotone, dlg, item = DialogSelect(event)
 251         if gotone:
 252             window = dlg.GetDialogWindow()
 253             if self._windows.has_key(window):
 254                 self._windows[window].do_itemhit(item, event)
 255             else:
 256                 print 'Dialog event for unknown dialog'
 257             return 1
 258         return 0
 259
 260     def do_mouseDown(self, event):
 261         (what, message, when, where, modifiers) = event
 262         partcode, wid = FindWindow(where)
 263
 264         #
 265         # Find the correct name.
 266         #
 267         if partname.has_key(partcode):
 268             name = "do_" + partname[partcode]
 269         else:
 270             name = "do_%d" % partcode
 271
 272         if wid is None:
 273             # No window, or a non-python window
 274             try:
 275                 handler = getattr(self, name)
 276             except AttributeError:
 277                 # Not menubar or something, so assume someone
 278                 # else's window
 279                 if hasattr(MacOS, 'HandleEvent'):
 280                     MacOS.HandleEvent(event)
 281                 return
 282         elif self._windows.has_key(wid):
 283             # It is a window. Hand off to correct window.
 284             window = self._windows[wid]
 285             try:
 286                 handler = getattr(window, name)
 287             except AttributeError:
 288                 handler = self.do_unknownpartcode
 289         else:
 290             # It is a python-toolbox window, but not ours.
 291             handler = self.do_unknownwindow
 292         handler(partcode, wid, event)
 293
 294     def do_inSysWindow(self, partcode, window, event):
 295         if hasattr(MacOS, 'HandleEvent'):
 296             MacOS.HandleEvent(event)
 297
 298     def do_inDesk(self, partcode, window, event):
 299         if hasattr(MacOS, 'HandleEvent'):
 300             MacOS.HandleEvent(event)
 301
 302     def do_inMenuBar(self, partcode, window, event):
 303         if not self.menubar:
 304             if hasattr(MacOS, 'HandleEvent'):
 305                 MacOS.HandleEvent(event)
 306             return
 307         (what, message, when, where, modifiers) = event
 308         result = MenuSelect(where)
 309         id = (result>>16) & 0xffff      # Hi word
 310         if id >= 0x8000:
 311             id = -65536 + id
 312         item = result & 0xffff      # Lo word
 313         self.do_rawmenu(id, item, window, event)
 314
 315     def do_rawmenu(self, id, item, window, event):
 316         try:
 317             self.do_menu(id, item, window, event)
 318         finally:
 319             HiliteMenu(0)
 320
 321     def do_menu(self, id, item, window, event):
 322         if hasattr(MacOS, 'OutputSeen'):
 323             MacOS.OutputSeen()
 324         self.menubar.dispatch(id, item, window, event)
 325
 326
 327     def do_unknownpartcode(self, partcode, window, event):
 328         (what, message, when, where, modifiers) = event
 329         if DEBUG: print "Mouse down at global:", where
 330         if DEBUG: print "\tUnknown part code:", partcode
 331         if DEBUG: print "\tEvent:", self.printevent(event)
 332         if hasattr(MacOS, 'HandleEvent'):
 333             MacOS.HandleEvent(event)
 334
 335     def do_unknownwindow(self, partcode, window, event):
 336         if DEBUG: print 'Unknown window:', window
 337         if hasattr(MacOS, 'HandleEvent'):
 338             MacOS.HandleEvent(event)
 339
 340     def do_keyDown(self, event):
 341         self.do_key(event)
 342
 343     def do_autoKey(self, event):
 344         if not event[-1] & cmdKey:
 345             self.do_key(event)
 346
 347     def do_key(self, event):
 348         (what, message, when, where, modifiers) = event
 349         c = chr(message & charCodeMask)
 350         if self.menubar:
 351             result = MenuEvent(event)
 352             id = (result>>16) & 0xffff      # Hi word
 353             item = result & 0xffff      # Lo word
 354             if id:
 355                 self.do_rawmenu(id, item, None, event)
 356                 return
 357             # Otherwise we fall-through
 358         if modifiers & cmdKey:
 359             if c == '.':
 360                 raise self
 361             else:
 362                 if not self.menubar:
 363                     if hasattr(MacOS, 'HandleEvent'):
 364                         MacOS.HandleEvent(event)
 365                 return
 366         else:
 367             # See whether the front window wants it
 368             w = MyFrontWindow()
 369             if w and self._windows.has_key(w):
 370                 window = self._windows[w]
 371                 try:
 372                     do_char = window.do_char
 373                 except AttributeError:
 374                     do_char = self.do_char
 375                 do_char(c, event)
 376             # else it wasn't for us, sigh...
 377
 378     def do_char(self, c, event):
 379         if DEBUG: print "Character", repr(c)
 380
 381     def do_updateEvt(self, event):
 382         (what, message, when, where, modifiers) = event
 383         wid = WhichWindow(message)
 384         if wid and self._windows.has_key(wid):
 385             window = self._windows[wid]
 386             window.do_rawupdate(wid, event)
 387         else:
 388             if hasattr(MacOS, 'HandleEvent'):
 389                 MacOS.HandleEvent(event)
 390
 391     def do_activateEvt(self, event):
 392         (what, message, when, where, modifiers) = event
 393         wid = WhichWindow(message)
 394         if wid and self._windows.has_key(wid):
 395             window = self._windows[wid]
 396             window.do_activate(modifiers & 1, event)
 397         else:
 398             if hasattr(MacOS, 'HandleEvent'):
 399                 MacOS.HandleEvent(event)
 400
 401     def do_osEvt(self, event):
 402         (what, message, when, where, modifiers) = event
 403         which = (message >> 24) & 0xff
 404         if which == 1:  # suspend/resume
 405             self.do_suspendresume(event)
 406         else:
 407             if DEBUG:
 408                 print 'unknown osEvt:',
 409                 self.printevent(event)
 410
 411     def do_suspendresume(self, event):
 412         (what, message, when, where, modifiers) = event
 413         wid = MyFrontWindow()
 414         if wid and self._windows.has_key(wid):
 415             window = self._windows[wid]
 416             window.do_activate(message & 1, event)
 417
 418     def do_kHighLevelEvent(self, event):
 419         (what, message, when, where, modifiers) = event
 420         if DEBUG:
 421             print "High Level Event:",
 422             self.printevent(event)
 423         try:
 424             AEProcessAppleEvent(event)
 425         except:
 426             pass
 427             #print "AEProcessAppleEvent error:"
 428             #traceback.print_exc()
 429
 430     def do_unknownevent(self, event):
 431         if DEBUG:
 432             print "Unhandled event:",
 433             self.printevent(event)
 434
 435     def printevent(self, event):
 436         (what, message, when, where, modifiers) = event
 437         nicewhat = repr(what)
 438         if eventname.has_key(what):
 439             nicewhat = eventname[what]
 440         print nicewhat,
 441         if what == kHighLevelEvent:
 442             h, v = where
 443             print repr(ostypecode(message)), hex(when), repr(ostypecode(h | (v<<16))),
 444         else:
 445             print hex(message), hex(when), where,
 446         print hex(modifiers)
 447
 448
 449 class MenuBar:
 450     """Represent a set of menus in a menu bar.
 451
 452     Interface:
 453
 454     - (constructor)
 455     - (destructor)
 456     - addmenu
 457     - addpopup (normally used internally)
 458     - dispatch (called from Application)
 459     """
 460
 461     nextid = 1      # Necessarily a class variable
 462
 463     def getnextid(self):
 464         id = MenuBar.nextid
 465         MenuBar.nextid = id+1
 466         return id
 467
 468     def __init__(self, parent=None):
 469         self.parent = parent
 470         ClearMenuBar()
 471         self.bar = GetMenuBar()
 472         self.menus = {}
 473
 474     # XXX necessary?
 475     def close(self):
 476         self.parent = None
 477         self.bar = None
 478         self.menus = None
 479
 480     def addmenu(self, title, after = 0, id=None):
 481         if id is None:
 482             id = self.getnextid()
 483         if DEBUG: print 'Newmenu', title, id # XXXX
 484         m = NewMenu(id, title)
 485         m.InsertMenu(after)
 486         if after >= 0:
 487             if self.parent:
 488                 self.parent.needmenubarredraw = 1
 489             else:
 490                 DrawMenuBar()
 491         return id, m
 492
 493     def delmenu(self, id):
 494         if DEBUG: print 'Delmenu', id # XXXX
 495         DeleteMenu(id)
 496
 497     def addpopup(self, title = ''):
 498         return self.addmenu(title, -1)
 499
 500 # Useless:
 501 #       def install(self):
 502 #           if not self.bar: return
 503 #           SetMenuBar(self.bar)
 504 #           if self.parent:
 505 #               self.parent.needmenubarredraw = 1
 506 #           else:
 507 #               DrawMenuBar()
 508
 509     def fixmenudimstate(self):
 510         for m in self.menus.keys():
 511             menu = self.menus[m]
 512             if menu.__class__ == FrameWork.AppleMenu:
 513                 continue
 514             for i in range(len(menu.items)):
 515                 label, shortcut, callback, kind = menu.items[i]
 516                 if type(callback) == types.StringType:
 517                     wid = MyFrontWindow()
 518                     if wid and self.parent._windows.has_key(wid):
 519                         window = self.parent._windows[wid]
 520                         if hasattr(window, "domenu_" + callback):
 521                             menu.menu.EnableMenuItem(i + 1)
 522                         elif hasattr(self.parent, "domenu_" + callback):
 523                             menu.menu.EnableMenuItem(i + 1)
 524                         else:
 525                             menu.menu.DisableMenuItem(i + 1)
 526                     elif hasattr(self.parent, "domenu_" + callback):
 527                         menu.menu.EnableMenuItem(i + 1)
 528                     else:
 529                         menu.menu.DisableMenuItem(i + 1)
 530                 elif callback:
 531                     pass
 532
 533     def dispatch(self, id, item, window, event):
 534         if self.menus.has_key(id):
 535             self.menus[id].dispatch(id, item, window, event)
 536         else:
 537             if DEBUG: print "MenuBar.dispatch(%d, %d, %s, %s)" % \
 538                 (id, item, window, event)
 539
 540
 541 # XXX Need a way to get menus as resources and bind them to callbacks
 542
 543 class Menu:
 544     "One menu."
 545
 546     def __init__(self, bar, title, after=0, id=None):
 547         self.bar = bar
 548         self.id, self.menu = self.bar.addmenu(title, after, id)
 549         bar.menus[self.id] = self
 550         self.items = []
 551         self._parent = None
 552
 553     def delete(self):
 554         self.bar.delmenu(self.id)
 555         del self.bar.menus[self.id]
 556         self.menu.DisposeMenu()
 557         del self.bar
 558         del self.items
 559         del self.menu
 560         del self.id
 561         del self._parent
 562
 563     def additem(self, label, shortcut=None, callback=None, kind=None):
 564         self.menu.AppendMenu('x')           # add a dummy string
 565         self.items.append((label, shortcut, callback, kind))
 566         item = len(self.items)
 567         if isinstance(label, unicode):
 568             self.menu.SetMenuItemTextWithCFString(item, label)
 569         else:
 570             self.menu.SetMenuItemText(item, label)
 571         if shortcut and type(shortcut) == type(()):
 572             modifiers, char = shortcut[:2]
 573             self.menu.SetItemCmd(item, ord(char))
 574             self.menu.SetMenuItemModifiers(item, modifiers)
 575             if len(shortcut) > 2:
 576                 self.menu.SetMenuItemKeyGlyph(item, shortcut[2])
 577         elif shortcut:
 578             self.menu.SetItemCmd(item, ord(shortcut))
 579         return item
 580
 581     def delitem(self, item):
 582         if item != len(self.items):
 583             raise 'Can only delete last item of a menu'
 584         self.menu.DeleteMenuItem(item)
 585         del self.items[item-1]
 586
 587     def addcheck(self, label, shortcut=None, callback=None):
 588         return self.additem(label, shortcut, callback, 'check')
 589
 590     def addradio(self, label, shortcut=None, callback=None):
 591         return self.additem(label, shortcut, callback, 'radio')
 592
 593     def addseparator(self):
 594         self.menu.AppendMenu('(-')
 595         self.items.append(('', None, None, 'separator'))
 596
 597     def addsubmenu(self, label, title=''):
 598         sub = Menu(self.bar, title, -1)
 599         item = self.additem(label, '\x1B', None, 'submenu')
 600         self.menu.SetItemMark(item, sub.id)
 601         sub._parent = self
 602         sub._parent_item = item
 603         return sub
 604
 605     def dispatch(self, id, item, window, event):
 606         title, shortcut, callback, mtype = self.items[item-1]
 607         if callback:
 608             if not self.bar.parent or type(callback) <> types.StringType:
 609                 menuhandler = callback
 610             else:
 611                 # callback is string
 612                 wid = MyFrontWindow()
 613                 if wid and self.bar.parent._windows.has_key(wid):
 614                     window = self.bar.parent._windows[wid]
 615                     if hasattr(window, "domenu_" + callback):
 616                         menuhandler = getattr(window, "domenu_" + callback)
 617                     elif hasattr(self.bar.parent, "domenu_" + callback):
 618                         menuhandler = getattr(self.bar.parent, "domenu_" + callback)
 619                     else:
 620                         # nothing we can do. we shouldn't have come this far
 621                         # since the menu item should have been disabled...
 622                         return
 623                 elif hasattr(self.bar.parent, "domenu_" + callback):
 624                     menuhandler = getattr(self.bar.parent, "domenu_" + callback)
 625                 else:
 626                     # nothing we can do. we shouldn't have come this far
 627                     # since the menu item should have been disabled...
 628                     return
 629             menuhandler(id, item, window, event)
 630
 631     def enable(self, onoff):
 632         if onoff:
 633             self.menu.EnableMenuItem(0)
 634             if self._parent:
 635                 self._parent.menu.EnableMenuItem(self._parent_item)
 636         else:
 637             self.menu.DisableMenuItem(0)
 638             if self._parent:
 639                 self._parent.menu.DisableMenuItem(self._parent_item)
 640         if self.bar and self.bar.parent:
 641             self.bar.parent.needmenubarredraw = 1
 642
 643 class PopupMenu(Menu):
 644     def __init__(self, bar):
 645         Menu.__init__(self, bar, '(popup)', -1)
 646
 647     def popup(self, x, y, event, default=1, window=None):
 648         # NOTE that x and y are global coordinates, and they should probably
 649         # be topleft of the button the user clicked (not mouse-coordinates),
 650         # so the popup nicely overlaps.
 651         reply = self.menu.PopUpMenuSelect(x, y, default)
 652         if not reply:
 653             return
 654         id = (reply >> 16) & 0xffff
 655         item = reply & 0xffff
 656         if not window:
 657             wid = MyFrontWindow()
 658             try:
 659                 window = self.bar.parent._windows[wid]
 660             except:
 661                 pass # If we can't find the window we pass None
 662         self.dispatch(id, item, window, event)
 663
 664 class MenuItem:
 665     def __init__(self, menu, title, shortcut=None, callback=None, kind=None):
 666         self.item = menu.additem(title, shortcut, callback)
 667         self.menu = menu
 668
 669     def delete(self):
 670         self.menu.delitem(self.item)
 671         del self.menu
 672         del self.item
 673
 674     def check(self, onoff):
 675         self.menu.menu.CheckMenuItem(self.item, onoff)
 676
 677     def enable(self, onoff):
 678         if onoff:
 679             self.menu.menu.EnableMenuItem(self.item)
 680         else:
 681             self.menu.menu.DisableMenuItem(self.item)
 682
 683     def settext(self, text):
 684         self.menu.menu.SetMenuItemText(self.item, text)
 685
 686     def setstyle(self, style):
 687         self.menu.menu.SetItemStyle(self.item, style)
 688
 689     def seticon(self, icon):
 690         self.menu.menu.SetItemIcon(self.item, icon)
 691
 692     def setcmd(self, cmd):
 693         self.menu.menu.SetItemCmd(self.item, cmd)
 694
 695     def setmark(self, cmd):
 696         self.menu.menu.SetItemMark(self.item, cmd)
 697
 698
 699 class RadioItem(MenuItem):
 700     def __init__(self, menu, title, shortcut=None, callback=None):
 701         MenuItem.__init__(self, menu, title, shortcut, callback, 'radio')
 702
 703 class CheckItem(MenuItem):
 704     def __init__(self, menu, title, shortcut=None, callback=None):
 705         MenuItem.__init__(self, menu, title, shortcut, callback, 'check')
 706
 707 def Separator(menu):
 708     menu.addseparator()
 709
 710 def SubMenu(menu, label, title=''):
 711     return menu.addsubmenu(label, title)
 712
 713
 714 class AppleMenu(Menu):
 715
 716     def __init__(self, bar, abouttext="About me...", aboutcallback=None):
 717         Menu.__init__(self, bar, "\024", id=SIOUX_APPLEMENU_ID)
 718         if MacOS.runtimemodel == 'ppc':
 719             self.additem(abouttext, None, aboutcallback)
 720             self.addseparator()
 721             self.menu.AppendResMenu('DRVR')
 722         else:
 723             # Additem()'s tricks do not work for "apple" menu under Carbon
 724             self.menu.InsertMenuItem(abouttext, 0)
 725             self.items.append((abouttext, None, aboutcallback, None))
 726
 727     def dispatch(self, id, item, window, event):
 728         if item == 1:
 729             Menu.dispatch(self, id, item, window, event)
 730         elif MacOS.runtimemodel == 'ppc':
 731             name = self.menu.GetMenuItemText(item)
 732             OpenDeskAcc(name)
 733
 734 class HelpMenu(Menu):
 735     def __init__(self, bar):
 736         # Note we don't call Menu.__init__, we do the necessary things by hand
 737         self.bar = bar
 738         self.menu, index = HMGetHelpMenu()
 739         self.id = self.menu.GetMenuID()
 740         bar.menus[self.id] = self
 741         # The next line caters for the entries the system already handles for us
 742         self.items = [None]*(index-1)
 743         self._parent = None
 744
 745
 746 class Window:
 747     """A single window belonging to an application"""
 748
 749     def __init__(self, parent):
 750         self.wid = None
 751         self.parent = parent
 752
 753     def open(self, bounds=(40, 40, 400, 400), resid=None):
 754         if resid <> None:
 755             self.wid = GetNewWindow(resid, -1)
 756         else:
 757             self.wid = NewWindow(bounds, self.__class__.__name__, 1,
 758                 8, -1, 1, 0)    # changed to proc id 8 to include zoom box. jvr
 759         self.do_postopen()
 760
 761     def do_postopen(self):
 762         """Tell our parent we exist"""
 763         self.parent.appendwindow(self.wid, self)
 764
 765     def close(self):
 766         self.do_postclose()
 767
 768     def do_postclose(self):
 769         self.parent.removewindow(self.wid)
 770         self.parent = None
 771         self.wid = None
 772
 773     def SetPort(self):
 774         # Convinience method
 775         SetPort(self.wid)
 776
 777     def GetWindow(self):
 778         return self.wid
 779
 780     def do_inDrag(self, partcode, window, event):
 781         where = event[3]
 782         window.DragWindow(where, self.draglimit)
 783
 784     draglimit = screenbounds
 785
 786     def do_inGoAway(self, partcode, window, event):
 787         where = event[3]
 788         if window.TrackGoAway(where):
 789             self.close()
 790
 791     def do_inZoom(self, partcode, window, event):
 792         (what, message, when, where, modifiers) = event
 793         if window.TrackBox(where, partcode):
 794             window.ZoomWindow(partcode, 1)
 795             rect = window.GetWindowUserState()                  # so that zoom really works... jvr
 796             self.do_postresize(rect[2] - rect[0], rect[3] - rect[1], window)    # jvr
 797
 798     def do_inZoomIn(self, partcode, window, event):
 799         SetPort(window) # !!!
 800         self.do_inZoom(partcode, window, event)
 801
 802     def do_inZoomOut(self, partcode, window, event):
 803         SetPort(window) # !!!
 804         self.do_inZoom(partcode, window, event)
 805
 806     def do_inGrow(self, partcode, window, event):
 807         (what, message, when, where, modifiers) = event
 808         result = window.GrowWindow(where, self.growlimit)
 809         if result:
 810             height = (result>>16) & 0xffff  # Hi word
 811             width = result & 0xffff     # Lo word
 812             self.do_resize(width, height, window)
 813
 814     growlimit = (50, 50, screenbounds[2] - screenbounds[0], screenbounds[3] - screenbounds[1])      # jvr
 815
 816     def do_resize(self, width, height, window):
 817         l, t, r, b = self.wid.GetWindowPort().GetPortBounds()           # jvr, forGrowIcon
 818         self.SetPort()                          # jvr
 819         self.wid.InvalWindowRect((r - SCROLLBARWIDTH + 1, b - SCROLLBARWIDTH + 1, r, b))    # jvr
 820         window.SizeWindow(width, height, 1)         # changed updateFlag to true jvr
 821         self.do_postresize(width, height, window)
 822
 823     def do_postresize(self, width, height, window):
 824         SetPort(window)
 825         self.wid.InvalWindowRect(window.GetWindowPort().GetPortBounds())
 826
 827     def do_inContent(self, partcode, window, event):
 828         #
 829         # If we're not frontmost, select ourselves and wait for
 830         # the activate event.
 831         #
 832         if MyFrontWindow() <> window:
 833             window.SelectWindow()
 834             return
 835         # We are. Handle the event.
 836         (what, message, when, where, modifiers) = event
 837         SetPort(window)
 838         local = GlobalToLocal(where)
 839         self.do_contentclick(local, modifiers, event)
 840
 841     def do_contentclick(self, local, modifiers, event):
 842         if DEBUG:
 843             print 'Click in contents at %s, modifiers %s'%(local, modifiers)
 844
 845     def do_rawupdate(self, window, event):
 846         if DEBUG: print "raw update for", window
 847         SetPort(window)
 848         window.BeginUpdate()
 849         self.do_update(window, event)
 850         window.EndUpdate()
 851
 852     def do_update(self, window, event):
 853         if DEBUG:
 854             import time
 855             for i in range(8):
 856                 time.sleep(0.1)
 857                 InvertRgn(window.GetWindowPort().visRgn)
 858             FillRgn(window.GetWindowPort().visRgn, GetQDGlobalsGray())
 859         else:
 860             EraseRgn(window.GetWindowPort().visRgn)
 861
 862     def do_activate(self, activate, event):
 863         if DEBUG: print 'Activate %d for %s'%(activate, self.wid)
 864
 865 class ControlsWindow(Window):
 866
 867     def do_rawupdate(self, window, event):
 868         if DEBUG: print "raw update for", window
 869         SetPort(window)
 870         window.BeginUpdate()
 871         self.do_update(window, event)
 872         #DrawControls(window)                   # jvr
 873         UpdateControls(window, window.GetWindowPort().visRgn)   # jvr
 874         window.DrawGrowIcon()
 875         window.EndUpdate()
 876
 877     def do_controlhit(self, window, control, pcode, event):
 878         if DEBUG: print "control hit in", window, "on", control, "; pcode =", pcode
 879
 880     def do_inContent(self, partcode, window, event):
 881         if MyFrontWindow() <> window:
 882             window.SelectWindow()
 883             return
 884         (what, message, when, where, modifiers) = event
 885         SetPort(window)  # XXXX Needed?
 886         local = GlobalToLocal(where)
 887         pcode, control = FindControl(local, window)
 888         if pcode and control:
 889             self.do_rawcontrolhit(window, control, pcode, local, event)
 890         else:
 891             if DEBUG: print "FindControl(%s, %s) -> (%s, %s)" % \
 892                 (local, window, pcode, control)
 893             self.do_contentclick(local, modifiers, event)
 894
 895     def do_rawcontrolhit(self, window, control, pcode, local, event):
 896         pcode = control.TrackControl(local)
 897         if pcode:
 898             self.do_controlhit(window, control, pcode, event)
 899
 900 class ScrolledWindow(ControlsWindow):
 901     def __init__(self, parent):
 902         self.barx = self.bary = None
 903         self.barx_enabled = self.bary_enabled = 1
 904         self.activated = 1
 905         ControlsWindow.__init__(self, parent)
 906
 907     def scrollbars(self, wantx=1, wanty=1):
 908         SetPort(self.wid)
 909         self.barx = self.bary = None
 910         self.barx_enabled = self.bary_enabled = 1
 911         x0, y0, x1, y1 = self.wid.GetWindowPort().GetPortBounds()
 912         vx, vy = self.getscrollbarvalues()
 913         if vx is None: self.barx_enabled, vx = 0, 0
 914         if vy is None: self.bary_enabled, vy = 0, 0
 915         if wantx:
 916             rect = x0-1, y1-(SCROLLBARWIDTH-1), x1-(SCROLLBARWIDTH-2), y1+1
 917             self.barx = NewControl(self.wid, rect, "", 1, vx, 0, 32767, 16, 0)
 918             if not self.barx_enabled: self.barx.HiliteControl(255)
 919 ##              self.wid.InvalWindowRect(rect)
 920         if wanty:
 921             rect = x1-(SCROLLBARWIDTH-1), y0-1, x1+1, y1-(SCROLLBARWIDTH-2)
 922             self.bary = NewControl(self.wid, rect, "", 1, vy, 0, 32767, 16, 0)
 923             if not self.bary_enabled: self.bary.HiliteControl(255)
 924 ##              self.wid.InvalWindowRect(rect)
 925
 926     def do_postclose(self):
 927         self.barx = self.bary = None
 928         ControlsWindow.do_postclose(self)
 929
 930     def do_activate(self, onoff, event):
 931         self.activated = onoff
 932         if onoff:
 933             if self.barx and self.barx_enabled:
 934                 self.barx.ShowControl() # jvr
 935             if self.bary and self.bary_enabled:
 936                 self.bary.ShowControl() # jvr
 937         else:
 938             if self.barx:
 939                 self.barx.HideControl() # jvr; An inactive window should have *hidden*
 940                             # scrollbars, not just dimmed (no matter what
 941                             # BBEdit does... look at the Finder)
 942             if self.bary:
 943                 self.bary.HideControl() # jvr
 944         self.wid.DrawGrowIcon()         # jvr
 945
 946     def do_postresize(self, width, height, window):
 947         l, t, r, b = self.wid.GetWindowPort().GetPortBounds()
 948         self.SetPort()
 949         if self.barx:
 950             self.barx.HideControl()     # jvr
 951             self.barx.MoveControl(l-1, b-(SCROLLBARWIDTH-1))
 952             self.barx.SizeControl((r-l)-(SCROLLBARWIDTH-3), SCROLLBARWIDTH) # jvr
 953         if self.bary:
 954             self.bary.HideControl()     # jvr
 955             self.bary.MoveControl(r-(SCROLLBARWIDTH-1), t-1)
 956             self.bary.SizeControl(SCROLLBARWIDTH, (b-t)-(SCROLLBARWIDTH-3)) # jvr
 957         if self.barx:
 958             self.barx.ShowControl()     # jvr
 959             self.wid.ValidWindowRect((l, b - SCROLLBARWIDTH + 1, r - SCROLLBARWIDTH + 2, b))    # jvr
 960         if self.bary:
 961             self.bary.ShowControl()     # jvr
 962             self.wid.ValidWindowRect((r - SCROLLBARWIDTH + 1, t, r, b - SCROLLBARWIDTH + 2))    # jvr
 963         self.wid.InvalWindowRect((r - SCROLLBARWIDTH + 1, b - SCROLLBARWIDTH + 1, r, b))    # jvr, growicon
 964
 965
 966     def do_rawcontrolhit(self, window, control, pcode, local, event):
 967         if control == self.barx:
 968             which = 'x'
 969         elif control == self.bary:
 970             which = 'y'
 971         else:
 972             return 0
 973         if pcode in (inUpButton, inDownButton, inPageUp, inPageDown):
 974             # We do the work for the buttons and grey area in the tracker
 975             dummy = control.TrackControl(local, self.do_controltrack)
 976         else:
 977             # but the thumb is handled here
 978             pcode = control.TrackControl(local)
 979             if pcode == inThumb:
 980                 value = control.GetControlValue()
 981                 print 'setbars', which, value #DBG
 982                 self.scrollbar_callback(which, 'set', value)
 983                 self.updatescrollbars()
 984             else:
 985                 print 'funny part', pcode #DBG
 986         return 1
 987
 988     def do_controltrack(self, control, pcode):
 989         if control == self.barx:
 990             which = 'x'
 991         elif control == self.bary:
 992             which = 'y'
 993         else:
 994             return
 995
 996         if pcode == inUpButton:
 997             what = '-'
 998         elif pcode == inDownButton:
 999             what = '+'
1000         elif pcode == inPageUp:
1001             what = '--'
1002         elif pcode == inPageDown:
1003             what = '++'
1004         else:
1005             return
1006         self.scrollbar_callback(which, what, None)
1007         self.updatescrollbars()
1008
1009     def updatescrollbars(self):
1010         SetPort(self.wid)
1011         vx, vy = self.getscrollbarvalues()
1012         if self.barx:
1013             if vx is None:
1014                 self.barx.HiliteControl(255)
1015                 self.barx_enabled = 0
1016             else:
1017                 if not self.barx_enabled:
1018                     self.barx_enabled = 1
1019                     if self.activated:
1020                         self.barx.HiliteControl(0)
1021                 self.barx.SetControlValue(vx)
1022         if self.bary:
1023             if vy is None:
1024                 self.bary.HiliteControl(255)
1025                 self.bary_enabled = 0
1026             else:
1027                 if not self.bary_enabled:
1028                     self.bary_enabled = 1
1029                     if self.activated:
1030                         self.bary.HiliteControl(0)
1031                 self.bary.SetControlValue(vy)
1032
1033     # Auxiliary function: convert standard text/image/etc coordinate
1034     # to something palatable as getscrollbarvalues() return
1035     def scalebarvalue(self, absmin, absmax, curmin, curmax):
1036         if curmin <= absmin and curmax >= absmax:
1037             return None
1038         if curmin <= absmin:
1039             return 0
1040         if curmax >= absmax:
1041             return 32767
1042         perc = float(curmin-absmin)/float(absmax-absmin)
1043         return int(perc*32767)
1044
1045     # To be overridden:
1046
1047     def getscrollbarvalues(self):
1048         return 0, 0
1049
1050     def scrollbar_callback(self, which, what, value):
1051         print 'scroll', which, what, value
1052
1053 class DialogWindow(Window):
1054     """A modeless dialog window"""
1055
1056     def open(self, resid):
1057         self.dlg = GetNewDialog(resid, -1)
1058         self.wid = self.dlg.GetDialogWindow()
1059         self.do_postopen()
1060
1061     def close(self):
1062         self.do_postclose()
1063
1064     def do_postclose(self):
1065         self.dlg = None
1066         Window.do_postclose(self)
1067
1068     def do_itemhit(self, item, event):
1069         print 'Dialog %s, item %d hit'%(self.dlg, item)
1070
1071     def do_rawupdate(self, window, event):
1072         pass
1073
1074 def ostypecode(x):
1075     "Convert a long int to the 4-character code it really is"
1076     s = ''
1077     for i in range(4):
1078         x, c = divmod(x, 256)
1079         s = chr(c) + s
1080     return s
1081
1082
1083 class TestApp(Application):
1084
1085     "This class is used by the test() function"
1086
1087     def makeusermenus(self):
1088         self.filemenu = m = Menu(self.menubar, "File")
1089         self.saveitem = MenuItem(m, "Save", "S", self.save)
1090         Separator(m)
1091         self.optionsmenu = mm = SubMenu(m, "Options")
1092         self.opt1 = CheckItem(mm, "Arguments", "A")
1093         self.opt2 = CheckItem(mm, "Being hit on the head lessons", (kMenuOptionModifier, "A"))
1094         self.opt3 = CheckItem(mm, "Complaints", (kMenuOptionModifier|kMenuNoCommandModifier, "A"))
1095         Separator(m)
1096         self.itemeh = MenuItem(m, "Enable Help", None, self.enablehelp)
1097         self.itemdbg = MenuItem(m, "Debug", None, self.debug)
1098         Separator(m)
1099         self.quititem = MenuItem(m, "Quit", "Q", self.quit)
1100
1101     def save(self, *args):
1102         print "Save"
1103
1104     def quit(self, *args):
1105         raise self
1106
1107     def enablehelp(self, *args):
1108         hm = self.gethelpmenu()
1109         self.nohelpitem = MenuItem(hm, "There isn't any", None, self.nohelp)
1110
1111     def nohelp(self, *args):
1112         print "I told you there isn't any!"
1113
1114     def debug(self, *args):
1115         import pdb
1116         pdb.set_trace()
1117
1118
1119 def test():
1120     "Test program"
1121     app = TestApp()
1122     app.mainloop()
1123
1124
1125 if __name__ == '__main__':
1126     test()