home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 May / maximum-cd-2010-05.iso / DiscContents / boxee-0.9.20.10711.exe / system / python / Lib / plat-mac / FrameWork.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-07-20  |  38.3 KB  |  1,306 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''A sort of application framework for the Mac'''
  5. DEBUG = 0
  6. import MacOS
  7. import traceback
  8. from Carbon.AE import *
  9. from Carbon.AppleEvents import *
  10. from Carbon.Ctl import *
  11. from Carbon.Controls import *
  12. from Carbon.Dlg import *
  13. from Carbon.Dialogs import *
  14. from Carbon.Evt import *
  15. from Carbon.Events import *
  16. from Carbon.Help import *
  17. from Carbon.Menu import *
  18. from Carbon.Menus import *
  19. from Carbon.Qd import *
  20. from Carbon.QuickDraw import *
  21. from Carbon.Win import *
  22. from Carbon.Windows import *
  23. import types
  24. import EasyDialogs
  25.  
  26. try:
  27.     MyFrontWindow = FrontNonFloatingWindow
  28. except NameError:
  29.     MyFrontWindow = FrontWindow
  30.  
  31. kHighLevelEvent = 23
  32. SCROLLBARWIDTH = 16
  33. SIOUX_APPLEMENU_ID = 32000
  34. eventname = { }
  35. eventname[1] = 'mouseDown'
  36. eventname[2] = 'mouseUp'
  37. eventname[3] = 'keyDown'
  38. eventname[4] = 'keyUp'
  39. eventname[5] = 'autoKey'
  40. eventname[6] = 'updateEvt'
  41. eventname[7] = 'diskEvt'
  42. eventname[8] = 'activateEvt'
  43. eventname[15] = 'osEvt'
  44. eventname[23] = 'kHighLevelEvent'
  45. partname = { }
  46. partname[0] = 'inDesk'
  47. partname[1] = 'inMenuBar'
  48. partname[2] = 'inSysWindow'
  49. partname[3] = 'inContent'
  50. partname[4] = 'inDrag'
  51. partname[5] = 'inGrow'
  52. partname[6] = 'inGoAway'
  53. partname[7] = 'inZoomIn'
  54. partname[8] = 'inZoomOut'
  55. screenbounds = GetQDGlobalsScreenBits().bounds
  56. screenbounds = (screenbounds[0] + 4, screenbounds[1] + 4, screenbounds[2] - 4, screenbounds[3] - 4)
  57. next_window_x = 16
  58. next_window_y = 44
  59.  
  60. def windowbounds(width, height):
  61.     '''Return sensible window bounds'''
  62.     global next_window_x, next_window_y, next_window_x, next_window_y
  63.     r = next_window_x + width
  64.     b = next_window_y + height
  65.     if r > screenbounds[2]:
  66.         next_window_x = 16
  67.     
  68.     if b > screenbounds[3]:
  69.         next_window_y = 44
  70.     
  71.     l = next_window_x
  72.     t = next_window_y
  73.     r = next_window_x + width
  74.     b = next_window_y + height
  75.     next_window_x = next_window_x + 8
  76.     next_window_y = next_window_y + 20
  77.     return (l, t, r, b)
  78.  
  79. _watch = None
  80.  
  81. def setwatchcursor():
  82.     global _watch
  83.     if _watch == None:
  84.         _watch = GetCursor(4).data
  85.     
  86.     SetCursor(_watch)
  87.  
  88.  
  89. def setarrowcursor():
  90.     SetCursor(GetQDGlobalsArrow())
  91.  
  92.  
  93. class Application:
  94.     '''Application framework -- your application should be a derived class'''
  95.     
  96.     def __init__(self, nomenubar = 0):
  97.         self._doing_asyncevents = 0
  98.         self.quitting = 0
  99.         self.needmenubarredraw = 0
  100.         self._windows = { }
  101.         self._helpmenu = None
  102.         if nomenubar:
  103.             self.menubar = None
  104.         else:
  105.             self.makemenubar()
  106.  
  107.     
  108.     def __del__(self):
  109.         if self._doing_asyncevents:
  110.             self._doing_asyncevents = 0
  111.             MacOS.SetEventHandler()
  112.         
  113.  
  114.     
  115.     def makemenubar(self):
  116.         self.menubar = MenuBar(self)
  117.         AppleMenu(self.menubar, self.getabouttext(), self.do_about)
  118.         self.makeusermenus()
  119.  
  120.     
  121.     def makeusermenus(self):
  122.         self.filemenu = m = Menu(self.menubar, 'File')
  123.         self._quititem = MenuItem(m, 'Quit', 'Q', self._quit)
  124.  
  125.     
  126.     def gethelpmenu(self):
  127.         if self._helpmenu == None:
  128.             self._helpmenu = HelpMenu(self.menubar)
  129.         
  130.         return self._helpmenu
  131.  
  132.     
  133.     def _quit(self, *args):
  134.         self.quitting = 1
  135.  
  136.     
  137.     def cleanup(self):
  138.         for w in self._windows.values():
  139.             w.do_close()
  140.         
  141.         return self._windows == { }
  142.  
  143.     
  144.     def appendwindow(self, wid, window):
  145.         self._windows[wid] = window
  146.  
  147.     
  148.     def removewindow(self, wid):
  149.         del self._windows[wid]
  150.  
  151.     
  152.     def getabouttext(self):
  153.         return 'About %s...' % self.__class__.__name__
  154.  
  155.     
  156.     def do_about(self, id, item, window, event):
  157.         EasyDialogs.Message('Hello, world!' + '\r(%s)' % self.__class__.__name__)
  158.  
  159.     schedparams = (0, 0)
  160.     default_wait = None
  161.     
  162.     def mainloop(self, mask = everyEvent, wait = None):
  163.         self.quitting = 0
  164.         if hasattr(MacOS, 'SchedParams'):
  165.             saveparams = MacOS.SchedParams(*self.schedparams)
  166.         
  167.         
  168.         try:
  169.             while not self.quitting:
  170.                 
  171.                 try:
  172.                     self.do1event(mask, wait)
  173.                 continue
  174.                 except (Application, SystemExit):
  175.                     break
  176.                     continue
  177.                 
  178.  
  179.                 None<EXCEPTION MATCH>(Application, SystemExit)
  180.         finally:
  181.             if hasattr(MacOS, 'SchedParams'):
  182.                 MacOS.SchedParams(*saveparams)
  183.             
  184.  
  185.  
  186.     
  187.     def dopendingevents(self, mask = everyEvent):
  188.         '''dopendingevents - Handle all pending events'''
  189.         while self.do1event(mask, wait = 0):
  190.             pass
  191.  
  192.     
  193.     def do1event(self, mask = everyEvent, wait = None):
  194.         (ok, event) = self.getevent(mask, wait)
  195.         if IsDialogEvent(event):
  196.             if self.do_dialogevent(event):
  197.                 return None
  198.             
  199.         
  200.         if ok:
  201.             self.dispatch(event)
  202.         else:
  203.             self.idle(event)
  204.  
  205.     
  206.     def idle(self, event):
  207.         pass
  208.  
  209.     
  210.     def getevent(self, mask = everyEvent, wait = None):
  211.         if self.needmenubarredraw:
  212.             DrawMenuBar()
  213.             self.needmenubarredraw = 0
  214.         
  215.         if wait is None:
  216.             wait = self.default_wait
  217.             if wait is None:
  218.                 wait = GetCaretTime()
  219.             
  220.         
  221.         (ok, event) = WaitNextEvent(mask, wait)
  222.         return (ok, event)
  223.  
  224.     
  225.     def dispatch(self, event):
  226.         if IsDialogEvent(event):
  227.             if self.do_dialogevent(event):
  228.                 return None
  229.             
  230.         
  231.         (what, message, when, where, modifiers) = event
  232.         if eventname.has_key(what):
  233.             name = 'do_' + eventname[what]
  234.         else:
  235.             name = 'do_%d' % what
  236.         
  237.         try:
  238.             handler = getattr(self, name)
  239.         except AttributeError:
  240.             handler = self.do_unknownevent
  241.  
  242.         handler(event)
  243.  
  244.     
  245.     def asyncevents(self, onoff):
  246.         '''asyncevents - Set asynchronous event handling on or off'''
  247.         if MacOS.runtimemodel == 'macho':
  248.             raise 'Unsupported in MachoPython'
  249.         
  250.         old = self._doing_asyncevents
  251.         if old:
  252.             MacOS.SetEventHandler()
  253.             MacOS.SchedParams(*self.schedparams)
  254.         
  255.         if onoff:
  256.             MacOS.SetEventHandler(self.dispatch)
  257.             (doint, dummymask, benice, howoften, bgyield) = self.schedparams
  258.             MacOS.SchedParams(doint, everyEvent, benice, howoften, bgyield)
  259.         
  260.         self._doing_asyncevents = onoff
  261.         return old
  262.  
  263.     
  264.     def do_dialogevent(self, event):
  265.         (gotone, dlg, item) = DialogSelect(event)
  266.         if gotone:
  267.             window = dlg.GetDialogWindow()
  268.             if self._windows.has_key(window):
  269.                 self._windows[window].do_itemhit(item, event)
  270.             else:
  271.                 print 'Dialog event for unknown dialog'
  272.             return 1
  273.         
  274.         return 0
  275.  
  276.     
  277.     def do_mouseDown(self, event):
  278.         (what, message, when, where, modifiers) = event
  279.         (partcode, wid) = FindWindow(where)
  280.         if partname.has_key(partcode):
  281.             name = 'do_' + partname[partcode]
  282.         else:
  283.             name = 'do_%d' % partcode
  284.         if wid == None:
  285.             
  286.             try:
  287.                 handler = getattr(self, name)
  288.             except AttributeError:
  289.                 if hasattr(MacOS, 'HandleEvent'):
  290.                     MacOS.HandleEvent(event)
  291.                 
  292.                 return None
  293.             except:
  294.                 None<EXCEPTION MATCH>AttributeError
  295.             
  296.  
  297.         None<EXCEPTION MATCH>AttributeError
  298.         if self._windows.has_key(wid):
  299.             window = self._windows[wid]
  300.             
  301.             try:
  302.                 handler = getattr(window, name)
  303.             except AttributeError:
  304.                 handler = self.do_unknownpartcode
  305.             except:
  306.                 None<EXCEPTION MATCH>AttributeError
  307.             
  308.  
  309.         None<EXCEPTION MATCH>AttributeError
  310.         handler = self.do_unknownwindow
  311.         handler(partcode, wid, event)
  312.  
  313.     
  314.     def do_inSysWindow(self, partcode, window, event):
  315.         if hasattr(MacOS, 'HandleEvent'):
  316.             MacOS.HandleEvent(event)
  317.         
  318.  
  319.     
  320.     def do_inDesk(self, partcode, window, event):
  321.         if hasattr(MacOS, 'HandleEvent'):
  322.             MacOS.HandleEvent(event)
  323.         
  324.  
  325.     
  326.     def do_inMenuBar(self, partcode, window, event):
  327.         if not self.menubar:
  328.             if hasattr(MacOS, 'HandleEvent'):
  329.                 MacOS.HandleEvent(event)
  330.             
  331.             return None
  332.         
  333.         (what, message, when, where, modifiers) = event
  334.         result = MenuSelect(where)
  335.         id = result >> 16 & 65535
  336.         if id >= 32768:
  337.             id = -65536 + id
  338.         
  339.         item = result & 65535
  340.         self.do_rawmenu(id, item, window, event)
  341.  
  342.     
  343.     def do_rawmenu(self, id, item, window, event):
  344.         
  345.         try:
  346.             self.do_menu(id, item, window, event)
  347.         finally:
  348.             HiliteMenu(0)
  349.  
  350.  
  351.     
  352.     def do_menu(self, id, item, window, event):
  353.         if hasattr(MacOS, 'OutputSeen'):
  354.             MacOS.OutputSeen()
  355.         
  356.         self.menubar.dispatch(id, item, window, event)
  357.  
  358.     
  359.     def do_unknownpartcode(self, partcode, window, event):
  360.         (what, message, when, where, modifiers) = event
  361.         if DEBUG:
  362.             print 'Mouse down at global:', where
  363.         
  364.         if DEBUG:
  365.             print '\tUnknown part code:', partcode
  366.         
  367.         if DEBUG:
  368.             print '\tEvent:', self.printevent(event)
  369.         
  370.         if hasattr(MacOS, 'HandleEvent'):
  371.             MacOS.HandleEvent(event)
  372.         
  373.  
  374.     
  375.     def do_unknownwindow(self, partcode, window, event):
  376.         if DEBUG:
  377.             print 'Unknown window:', window
  378.         
  379.         if hasattr(MacOS, 'HandleEvent'):
  380.             MacOS.HandleEvent(event)
  381.         
  382.  
  383.     
  384.     def do_keyDown(self, event):
  385.         self.do_key(event)
  386.  
  387.     
  388.     def do_autoKey(self, event):
  389.         if not event[-1] & cmdKey:
  390.             self.do_key(event)
  391.         
  392.  
  393.     
  394.     def do_key(self, event):
  395.         (what, message, when, where, modifiers) = event
  396.         c = chr(message & charCodeMask)
  397.         if self.menubar:
  398.             result = MenuEvent(event)
  399.             id = result >> 16 & 65535
  400.             item = result & 65535
  401.             if id:
  402.                 self.do_rawmenu(id, item, None, event)
  403.                 return None
  404.             
  405.         
  406.         if modifiers & cmdKey:
  407.             if c == '.':
  408.                 raise self
  409.             elif not self.menubar:
  410.                 if hasattr(MacOS, 'HandleEvent'):
  411.                     MacOS.HandleEvent(event)
  412.                 
  413.             
  414.             return None
  415.         else:
  416.             w = MyFrontWindow()
  417.             if w and self._windows.has_key(w):
  418.                 window = self._windows[w]
  419.                 
  420.                 try:
  421.                     do_char = window.do_char
  422.                 except AttributeError:
  423.                     do_char = self.do_char
  424.  
  425.                 do_char(c, event)
  426.             
  427.  
  428.     
  429.     def do_char(self, c, event):
  430.         if DEBUG:
  431.             print 'Character', repr(c)
  432.         
  433.  
  434.     
  435.     def do_updateEvt(self, event):
  436.         (what, message, when, where, modifiers) = event
  437.         wid = WhichWindow(message)
  438.         if wid and self._windows.has_key(wid):
  439.             window = self._windows[wid]
  440.             window.do_rawupdate(wid, event)
  441.         elif hasattr(MacOS, 'HandleEvent'):
  442.             MacOS.HandleEvent(event)
  443.         
  444.  
  445.     
  446.     def do_activateEvt(self, event):
  447.         (what, message, when, where, modifiers) = event
  448.         wid = WhichWindow(message)
  449.         if wid and self._windows.has_key(wid):
  450.             window = self._windows[wid]
  451.             window.do_activate(modifiers & 1, event)
  452.         elif hasattr(MacOS, 'HandleEvent'):
  453.             MacOS.HandleEvent(event)
  454.         
  455.  
  456.     
  457.     def do_osEvt(self, event):
  458.         (what, message, when, where, modifiers) = event
  459.         which = message >> 24 & 255
  460.         if which == 1:
  461.             self.do_suspendresume(event)
  462.         elif DEBUG:
  463.             print 'unknown osEvt:',
  464.             self.printevent(event)
  465.         
  466.  
  467.     
  468.     def do_suspendresume(self, event):
  469.         (what, message, when, where, modifiers) = event
  470.         wid = MyFrontWindow()
  471.         if wid and self._windows.has_key(wid):
  472.             window = self._windows[wid]
  473.             window.do_activate(message & 1, event)
  474.         
  475.  
  476.     
  477.     def do_kHighLevelEvent(self, event):
  478.         (what, message, when, where, modifiers) = event
  479.         if DEBUG:
  480.             print 'High Level Event:',
  481.             self.printevent(event)
  482.         
  483.         
  484.         try:
  485.             AEProcessAppleEvent(event)
  486.         except:
  487.             pass
  488.  
  489.  
  490.     
  491.     def do_unknownevent(self, event):
  492.         if DEBUG:
  493.             print 'Unhandled event:',
  494.             self.printevent(event)
  495.         
  496.  
  497.     
  498.     def printevent(self, event):
  499.         (what, message, when, where, modifiers) = event
  500.         nicewhat = repr(what)
  501.         if eventname.has_key(what):
  502.             nicewhat = eventname[what]
  503.         
  504.         print nicewhat,
  505.         if what == kHighLevelEvent:
  506.             (h, v) = where
  507.             print repr(ostypecode(message)), hex(when), repr(ostypecode(h | v << 16)),
  508.         else:
  509.             print hex(message), hex(when), where,
  510.         print hex(modifiers)
  511.  
  512.  
  513.  
  514. class MenuBar:
  515.     '''Represent a set of menus in a menu bar.
  516.  
  517.     Interface:
  518.  
  519.     - (constructor)
  520.     - (destructor)
  521.     - addmenu
  522.     - addpopup (normally used internally)
  523.     - dispatch (called from Application)
  524.     '''
  525.     nextid = 1
  526.     
  527.     def getnextid(self):
  528.         id = MenuBar.nextid
  529.         MenuBar.nextid = id + 1
  530.         return id
  531.  
  532.     
  533.     def __init__(self, parent = None):
  534.         self.parent = parent
  535.         ClearMenuBar()
  536.         self.bar = GetMenuBar()
  537.         self.menus = { }
  538.  
  539.     
  540.     def close(self):
  541.         self.parent = None
  542.         self.bar = None
  543.         self.menus = None
  544.  
  545.     
  546.     def addmenu(self, title, after = 0, id = None):
  547.         if id == None:
  548.             id = self.getnextid()
  549.         
  550.         if DEBUG:
  551.             print 'Newmenu', title, id
  552.         
  553.         m = NewMenu(id, title)
  554.         m.InsertMenu(after)
  555.         if after >= 0:
  556.             if self.parent:
  557.                 self.parent.needmenubarredraw = 1
  558.             else:
  559.                 DrawMenuBar()
  560.         
  561.         return (id, m)
  562.  
  563.     
  564.     def delmenu(self, id):
  565.         if DEBUG:
  566.             print 'Delmenu', id
  567.         
  568.         DeleteMenu(id)
  569.  
  570.     
  571.     def addpopup(self, title = ''):
  572.         return self.addmenu(title, -1)
  573.  
  574.     
  575.     def fixmenudimstate(self):
  576.         for m in self.menus.keys():
  577.             menu = self.menus[m]
  578.             if menu.__class__ == FrameWork.AppleMenu:
  579.                 continue
  580.             
  581.             for i in range(len(menu.items)):
  582.                 (label, shortcut, callback, kind) = menu.items[i]
  583.                 if type(callback) == types.StringType:
  584.                     wid = MyFrontWindow()
  585.                     if wid and self.parent._windows.has_key(wid):
  586.                         window = self.parent._windows[wid]
  587.                         if hasattr(window, 'domenu_' + callback):
  588.                             menu.menu.EnableMenuItem(i + 1)
  589.                         elif hasattr(self.parent, 'domenu_' + callback):
  590.                             menu.menu.EnableMenuItem(i + 1)
  591.                         else:
  592.                             menu.menu.DisableMenuItem(i + 1)
  593.                     elif hasattr(self.parent, 'domenu_' + callback):
  594.                         menu.menu.EnableMenuItem(i + 1)
  595.                     else:
  596.                         menu.menu.DisableMenuItem(i + 1)
  597.                 self.parent._windows.has_key(wid)
  598.                 if callback:
  599.                     continue
  600.             
  601.         
  602.  
  603.     
  604.     def dispatch(self, id, item, window, event):
  605.         if self.menus.has_key(id):
  606.             self.menus[id].dispatch(id, item, window, event)
  607.         elif DEBUG:
  608.             print 'MenuBar.dispatch(%d, %d, %s, %s)' % (id, item, window, event)
  609.         
  610.  
  611.  
  612.  
  613. class Menu:
  614.     '''One menu.'''
  615.     
  616.     def __init__(self, bar, title, after = 0, id = None):
  617.         self.bar = bar
  618.         (self.id, self.menu) = self.bar.addmenu(title, after, id)
  619.         bar.menus[self.id] = self
  620.         self.items = []
  621.         self._parent = None
  622.  
  623.     
  624.     def delete(self):
  625.         self.bar.delmenu(self.id)
  626.         del self.bar.menus[self.id]
  627.         self.menu.DisposeMenu()
  628.         del self.bar
  629.         del self.items
  630.         del self.menu
  631.         del self.id
  632.         del self._parent
  633.  
  634.     
  635.     def additem(self, label, shortcut = None, callback = None, kind = None):
  636.         self.menu.AppendMenu('x')
  637.         self.items.append((label, shortcut, callback, kind))
  638.         item = len(self.items)
  639.         if isinstance(label, unicode):
  640.             self.menu.SetMenuItemTextWithCFString(item, label)
  641.         else:
  642.             self.menu.SetMenuItemText(item, label)
  643.         if shortcut and type(shortcut) == type(()):
  644.             (modifiers, char) = shortcut[:2]
  645.             self.menu.SetItemCmd(item, ord(char))
  646.             self.menu.SetMenuItemModifiers(item, modifiers)
  647.             if len(shortcut) > 2:
  648.                 self.menu.SetMenuItemKeyGlyph(item, shortcut[2])
  649.             
  650.         elif shortcut:
  651.             self.menu.SetItemCmd(item, ord(shortcut))
  652.         
  653.         return item
  654.  
  655.     
  656.     def delitem(self, item):
  657.         if item != len(self.items):
  658.             raise 'Can only delete last item of a menu'
  659.         
  660.         self.menu.DeleteMenuItem(item)
  661.         del self.items[item - 1]
  662.  
  663.     
  664.     def addcheck(self, label, shortcut = None, callback = None):
  665.         return self.additem(label, shortcut, callback, 'check')
  666.  
  667.     
  668.     def addradio(self, label, shortcut = None, callback = None):
  669.         return self.additem(label, shortcut, callback, 'radio')
  670.  
  671.     
  672.     def addseparator(self):
  673.         self.menu.AppendMenu('(-')
  674.         self.items.append(('', None, None, 'separator'))
  675.  
  676.     
  677.     def addsubmenu(self, label, title = ''):
  678.         sub = Menu(self.bar, title, -1)
  679.         item = self.additem(label, '\x1b', None, 'submenu')
  680.         self.menu.SetItemMark(item, sub.id)
  681.         sub._parent = self
  682.         sub._parent_item = item
  683.         return sub
  684.  
  685.     
  686.     def dispatch(self, id, item, window, event):
  687.         (title, shortcut, callback, mtype) = self.items[item - 1]
  688.         if callback:
  689.             if not (self.bar.parent) or type(callback) != types.StringType:
  690.                 menuhandler = callback
  691.             else:
  692.                 wid = MyFrontWindow()
  693.                 if wid and self.bar.parent._windows.has_key(wid):
  694.                     window = self.bar.parent._windows[wid]
  695.                     if hasattr(window, 'domenu_' + callback):
  696.                         menuhandler = getattr(window, 'domenu_' + callback)
  697.                     elif hasattr(self.bar.parent, 'domenu_' + callback):
  698.                         menuhandler = getattr(self.bar.parent, 'domenu_' + callback)
  699.                     else:
  700.                         return None
  701.                 elif hasattr(self.bar.parent, 'domenu_' + callback):
  702.                     menuhandler = getattr(self.bar.parent, 'domenu_' + callback)
  703.                 else:
  704.                     return None
  705.             menuhandler(id, item, window, event)
  706.         
  707.  
  708.     
  709.     def enable(self, onoff):
  710.         if onoff:
  711.             self.menu.EnableMenuItem(0)
  712.             if self._parent:
  713.                 self._parent.menu.EnableMenuItem(self._parent_item)
  714.             
  715.         else:
  716.             self.menu.DisableMenuItem(0)
  717.             if self._parent:
  718.                 self._parent.menu.DisableMenuItem(self._parent_item)
  719.             
  720.         if self.bar and self.bar.parent:
  721.             self.bar.parent.needmenubarredraw = 1
  722.         
  723.  
  724.  
  725.  
  726. class PopupMenu(Menu):
  727.     
  728.     def __init__(self, bar):
  729.         Menu.__init__(self, bar, '(popup)', -1)
  730.  
  731.     
  732.     def popup(self, x, y, event, default = 1, window = None):
  733.         reply = self.menu.PopUpMenuSelect(x, y, default)
  734.         if not reply:
  735.             return None
  736.         
  737.         id = reply >> 16 & 65535
  738.         item = reply & 65535
  739.         if not window:
  740.             wid = MyFrontWindow()
  741.             
  742.             try:
  743.                 window = self.bar.parent._windows[wid]
  744.  
  745.         
  746.         self.dispatch(id, item, window, event)
  747.  
  748.  
  749.  
  750. class MenuItem:
  751.     
  752.     def __init__(self, menu, title, shortcut = None, callback = None, kind = None):
  753.         self.item = menu.additem(title, shortcut, callback)
  754.         self.menu = menu
  755.  
  756.     
  757.     def delete(self):
  758.         self.menu.delitem(self.item)
  759.         del self.menu
  760.         del self.item
  761.  
  762.     
  763.     def check(self, onoff):
  764.         self.menu.menu.CheckMenuItem(self.item, onoff)
  765.  
  766.     
  767.     def enable(self, onoff):
  768.         if onoff:
  769.             self.menu.menu.EnableMenuItem(self.item)
  770.         else:
  771.             self.menu.menu.DisableMenuItem(self.item)
  772.  
  773.     
  774.     def settext(self, text):
  775.         self.menu.menu.SetMenuItemText(self.item, text)
  776.  
  777.     
  778.     def setstyle(self, style):
  779.         self.menu.menu.SetItemStyle(self.item, style)
  780.  
  781.     
  782.     def seticon(self, icon):
  783.         self.menu.menu.SetItemIcon(self.item, icon)
  784.  
  785.     
  786.     def setcmd(self, cmd):
  787.         self.menu.menu.SetItemCmd(self.item, cmd)
  788.  
  789.     
  790.     def setmark(self, cmd):
  791.         self.menu.menu.SetItemMark(self.item, cmd)
  792.  
  793.  
  794.  
  795. class RadioItem(MenuItem):
  796.     
  797.     def __init__(self, menu, title, shortcut = None, callback = None):
  798.         MenuItem.__init__(self, menu, title, shortcut, callback, 'radio')
  799.  
  800.  
  801.  
  802. class CheckItem(MenuItem):
  803.     
  804.     def __init__(self, menu, title, shortcut = None, callback = None):
  805.         MenuItem.__init__(self, menu, title, shortcut, callback, 'check')
  806.  
  807.  
  808.  
  809. def Separator(menu):
  810.     menu.addseparator()
  811.  
  812.  
  813. def SubMenu(menu, label, title = ''):
  814.     return menu.addsubmenu(label, title)
  815.  
  816.  
  817. class AppleMenu(Menu):
  818.     
  819.     def __init__(self, bar, abouttext = 'About me...', aboutcallback = None):
  820.         Menu.__init__(self, bar, '\x14', id = SIOUX_APPLEMENU_ID)
  821.         if MacOS.runtimemodel == 'ppc':
  822.             self.additem(abouttext, None, aboutcallback)
  823.             self.addseparator()
  824.             self.menu.AppendResMenu('DRVR')
  825.         else:
  826.             self.menu.InsertMenuItem(abouttext, 0)
  827.             self.items.append((abouttext, None, aboutcallback, None))
  828.  
  829.     
  830.     def dispatch(self, id, item, window, event):
  831.         if item == 1:
  832.             Menu.dispatch(self, id, item, window, event)
  833.         elif MacOS.runtimemodel == 'ppc':
  834.             name = self.menu.GetMenuItemText(item)
  835.             OpenDeskAcc(name)
  836.         
  837.  
  838.  
  839.  
  840. class HelpMenu(Menu):
  841.     
  842.     def __init__(self, bar):
  843.         self.bar = bar
  844.         (self.menu, index) = HMGetHelpMenu()
  845.         self.id = self.menu.GetMenuID()
  846.         bar.menus[self.id] = self
  847.         self.items = [
  848.             None] * (index - 1)
  849.         self._parent = None
  850.  
  851.  
  852.  
  853. class Window:
  854.     '''A single window belonging to an application'''
  855.     
  856.     def __init__(self, parent):
  857.         self.wid = None
  858.         self.parent = parent
  859.  
  860.     
  861.     def open(self, bounds = (40, 40, 400, 400), resid = None):
  862.         if resid != None:
  863.             self.wid = GetNewWindow(resid, -1)
  864.         else:
  865.             self.wid = NewWindow(bounds, self.__class__.__name__, 1, 8, -1, 1, 0)
  866.         self.do_postopen()
  867.  
  868.     
  869.     def do_postopen(self):
  870.         '''Tell our parent we exist'''
  871.         self.parent.appendwindow(self.wid, self)
  872.  
  873.     
  874.     def close(self):
  875.         self.do_postclose()
  876.  
  877.     
  878.     def do_postclose(self):
  879.         self.parent.removewindow(self.wid)
  880.         self.parent = None
  881.         self.wid = None
  882.  
  883.     
  884.     def SetPort(self):
  885.         SetPort(self.wid)
  886.  
  887.     
  888.     def GetWindow(self):
  889.         return self.wid
  890.  
  891.     
  892.     def do_inDrag(self, partcode, window, event):
  893.         where = event[3]
  894.         window.DragWindow(where, self.draglimit)
  895.  
  896.     draglimit = screenbounds
  897.     
  898.     def do_inGoAway(self, partcode, window, event):
  899.         where = event[3]
  900.         if window.TrackGoAway(where):
  901.             self.close()
  902.         
  903.  
  904.     
  905.     def do_inZoom(self, partcode, window, event):
  906.         (what, message, when, where, modifiers) = event
  907.         if window.TrackBox(where, partcode):
  908.             window.ZoomWindow(partcode, 1)
  909.             rect = window.GetWindowUserState()
  910.             self.do_postresize(rect[2] - rect[0], rect[3] - rect[1], window)
  911.         
  912.  
  913.     
  914.     def do_inZoomIn(self, partcode, window, event):
  915.         SetPort(window)
  916.         self.do_inZoom(partcode, window, event)
  917.  
  918.     
  919.     def do_inZoomOut(self, partcode, window, event):
  920.         SetPort(window)
  921.         self.do_inZoom(partcode, window, event)
  922.  
  923.     
  924.     def do_inGrow(self, partcode, window, event):
  925.         (what, message, when, where, modifiers) = event
  926.         result = window.GrowWindow(where, self.growlimit)
  927.         if result:
  928.             height = result >> 16 & 65535
  929.             width = result & 65535
  930.             self.do_resize(width, height, window)
  931.         
  932.  
  933.     growlimit = (50, 50, screenbounds[2] - screenbounds[0], screenbounds[3] - screenbounds[1])
  934.     
  935.     def do_resize(self, width, height, window):
  936.         (l, t, r, b) = self.wid.GetWindowPort().GetPortBounds()
  937.         self.SetPort()
  938.         self.wid.InvalWindowRect(((r - SCROLLBARWIDTH) + 1, (b - SCROLLBARWIDTH) + 1, r, b))
  939.         window.SizeWindow(width, height, 1)
  940.         self.do_postresize(width, height, window)
  941.  
  942.     
  943.     def do_postresize(self, width, height, window):
  944.         SetPort(window)
  945.         self.wid.InvalWindowRect(window.GetWindowPort().GetPortBounds())
  946.  
  947.     
  948.     def do_inContent(self, partcode, window, event):
  949.         if MyFrontWindow() != window:
  950.             window.SelectWindow()
  951.             return None
  952.         
  953.         (what, message, when, where, modifiers) = event
  954.         SetPort(window)
  955.         local = GlobalToLocal(where)
  956.         self.do_contentclick(local, modifiers, event)
  957.  
  958.     
  959.     def do_contentclick(self, local, modifiers, event):
  960.         if DEBUG:
  961.             print 'Click in contents at %s, modifiers %s' % (local, modifiers)
  962.         
  963.  
  964.     
  965.     def do_rawupdate(self, window, event):
  966.         if DEBUG:
  967.             print 'raw update for', window
  968.         
  969.         SetPort(window)
  970.         window.BeginUpdate()
  971.         self.do_update(window, event)
  972.         window.EndUpdate()
  973.  
  974.     
  975.     def do_update(self, window, event):
  976.         if DEBUG:
  977.             import time
  978.             for i in range(8):
  979.                 time.sleep(0.10000000000000001)
  980.                 InvertRgn(window.GetWindowPort().visRgn)
  981.             
  982.             FillRgn(window.GetWindowPort().visRgn, GetQDGlobalsGray())
  983.         else:
  984.             EraseRgn(window.GetWindowPort().visRgn)
  985.  
  986.     
  987.     def do_activate(self, activate, event):
  988.         if DEBUG:
  989.             print 'Activate %d for %s' % (activate, self.wid)
  990.         
  991.  
  992.  
  993.  
  994. class ControlsWindow(Window):
  995.     
  996.     def do_rawupdate(self, window, event):
  997.         if DEBUG:
  998.             print 'raw update for', window
  999.         
  1000.         SetPort(window)
  1001.         window.BeginUpdate()
  1002.         self.do_update(window, event)
  1003.         UpdateControls(window, window.GetWindowPort().visRgn)
  1004.         window.DrawGrowIcon()
  1005.         window.EndUpdate()
  1006.  
  1007.     
  1008.     def do_controlhit(self, window, control, pcode, event):
  1009.         if DEBUG:
  1010.             print 'control hit in', window, 'on', control, '; pcode =', pcode
  1011.         
  1012.  
  1013.     
  1014.     def do_inContent(self, partcode, window, event):
  1015.         if MyFrontWindow() != window:
  1016.             window.SelectWindow()
  1017.             return None
  1018.         
  1019.         (what, message, when, where, modifiers) = event
  1020.         SetPort(window)
  1021.         local = GlobalToLocal(where)
  1022.         (pcode, control) = FindControl(local, window)
  1023.         if pcode and control:
  1024.             self.do_rawcontrolhit(window, control, pcode, local, event)
  1025.         elif DEBUG:
  1026.             print 'FindControl(%s, %s) -> (%s, %s)' % (local, window, pcode, control)
  1027.         
  1028.         self.do_contentclick(local, modifiers, event)
  1029.  
  1030.     
  1031.     def do_rawcontrolhit(self, window, control, pcode, local, event):
  1032.         pcode = control.TrackControl(local)
  1033.         if pcode:
  1034.             self.do_controlhit(window, control, pcode, event)
  1035.         
  1036.  
  1037.  
  1038.  
  1039. class ScrolledWindow(ControlsWindow):
  1040.     
  1041.     def __init__(self, parent):
  1042.         self.barx = None
  1043.         self.bary = None
  1044.         self.barx_enabled = self.bary_enabled = 1
  1045.         self.activated = 1
  1046.         ControlsWindow.__init__(self, parent)
  1047.  
  1048.     
  1049.     def scrollbars(self, wantx = 1, wanty = 1):
  1050.         SetPort(self.wid)
  1051.         self.barx = None
  1052.         self.bary = None
  1053.         self.barx_enabled = self.bary_enabled = 1
  1054.         (x0, y0, x1, y1) = self.wid.GetWindowPort().GetPortBounds()
  1055.         (vx, vy) = self.getscrollbarvalues()
  1056.         if vx == None:
  1057.             (self.barx_enabled, vx) = (0, 0)
  1058.         
  1059.         if vy == None:
  1060.             (self.bary_enabled, vy) = (0, 0)
  1061.         
  1062.         if wantx:
  1063.             rect = (x0 - 1, y1 - SCROLLBARWIDTH - 1, x1 - SCROLLBARWIDTH - 2, y1 + 1)
  1064.             self.barx = NewControl(self.wid, rect, '', 1, vx, 0, 32767, 16, 0)
  1065.             if not self.barx_enabled:
  1066.                 self.barx.HiliteControl(255)
  1067.             
  1068.         
  1069.         if wanty:
  1070.             rect = (x1 - SCROLLBARWIDTH - 1, y0 - 1, x1 + 1, y1 - SCROLLBARWIDTH - 2)
  1071.             self.bary = NewControl(self.wid, rect, '', 1, vy, 0, 32767, 16, 0)
  1072.             if not self.bary_enabled:
  1073.                 self.bary.HiliteControl(255)
  1074.             
  1075.         
  1076.  
  1077.     
  1078.     def do_postclose(self):
  1079.         self.barx = None
  1080.         self.bary = None
  1081.         ControlsWindow.do_postclose(self)
  1082.  
  1083.     
  1084.     def do_activate(self, onoff, event):
  1085.         self.activated = onoff
  1086.         if onoff:
  1087.             if self.barx and self.barx_enabled:
  1088.                 self.barx.ShowControl()
  1089.             
  1090.             if self.bary and self.bary_enabled:
  1091.                 self.bary.ShowControl()
  1092.             
  1093.         elif self.barx:
  1094.             self.barx.HideControl()
  1095.         
  1096.         if self.bary:
  1097.             self.bary.HideControl()
  1098.         
  1099.         self.wid.DrawGrowIcon()
  1100.  
  1101.     
  1102.     def do_postresize(self, width, height, window):
  1103.         (l, t, r, b) = self.wid.GetWindowPort().GetPortBounds()
  1104.         self.SetPort()
  1105.         if self.barx:
  1106.             self.barx.HideControl()
  1107.             self.barx.MoveControl(l - 1, b - SCROLLBARWIDTH - 1)
  1108.             self.barx.SizeControl(r - l - SCROLLBARWIDTH - 3, SCROLLBARWIDTH)
  1109.         
  1110.         if self.bary:
  1111.             self.bary.HideControl()
  1112.             self.bary.MoveControl(r - SCROLLBARWIDTH - 1, t - 1)
  1113.             self.bary.SizeControl(SCROLLBARWIDTH, b - t - SCROLLBARWIDTH - 3)
  1114.         
  1115.         if self.barx:
  1116.             self.barx.ShowControl()
  1117.             self.wid.ValidWindowRect((l, (b - SCROLLBARWIDTH) + 1, (r - SCROLLBARWIDTH) + 2, b))
  1118.         
  1119.         if self.bary:
  1120.             self.bary.ShowControl()
  1121.             self.wid.ValidWindowRect(((r - SCROLLBARWIDTH) + 1, t, r, (b - SCROLLBARWIDTH) + 2))
  1122.         
  1123.         self.wid.InvalWindowRect(((r - SCROLLBARWIDTH) + 1, (b - SCROLLBARWIDTH) + 1, r, b))
  1124.  
  1125.     
  1126.     def do_rawcontrolhit(self, window, control, pcode, local, event):
  1127.         if control == self.barx:
  1128.             which = 'x'
  1129.         elif control == self.bary:
  1130.             which = 'y'
  1131.         else:
  1132.             return 0
  1133.         if pcode in (inUpButton, inDownButton, inPageUp, inPageDown):
  1134.             dummy = control.TrackControl(local, self.do_controltrack)
  1135.         else:
  1136.             pcode = control.TrackControl(local)
  1137.             if pcode == inThumb:
  1138.                 value = control.GetControlValue()
  1139.                 print 'setbars', which, value
  1140.                 self.scrollbar_callback(which, 'set', value)
  1141.                 self.updatescrollbars()
  1142.             else:
  1143.                 print 'funny part', pcode
  1144.         return 1
  1145.  
  1146.     
  1147.     def do_controltrack(self, control, pcode):
  1148.         if control == self.barx:
  1149.             which = 'x'
  1150.         elif control == self.bary:
  1151.             which = 'y'
  1152.         else:
  1153.             return None
  1154.         if pcode == inUpButton:
  1155.             what = '-'
  1156.         elif pcode == inDownButton:
  1157.             what = '+'
  1158.         elif pcode == inPageUp:
  1159.             what = '--'
  1160.         elif pcode == inPageDown:
  1161.             what = '++'
  1162.         else:
  1163.             return None
  1164.         self.scrollbar_callback(which, what, None)
  1165.         self.updatescrollbars()
  1166.  
  1167.     
  1168.     def updatescrollbars(self):
  1169.         SetPort(self.wid)
  1170.         (vx, vy) = self.getscrollbarvalues()
  1171.         if self.barx:
  1172.             if vx == None:
  1173.                 self.barx.HiliteControl(255)
  1174.                 self.barx_enabled = 0
  1175.             elif not self.barx_enabled:
  1176.                 self.barx_enabled = 1
  1177.                 if self.activated:
  1178.                     self.barx.HiliteControl(0)
  1179.                 
  1180.             
  1181.             self.barx.SetControlValue(vx)
  1182.         
  1183.         if self.bary:
  1184.             if vy == None:
  1185.                 self.bary.HiliteControl(255)
  1186.                 self.bary_enabled = 0
  1187.             elif not self.bary_enabled:
  1188.                 self.bary_enabled = 1
  1189.                 if self.activated:
  1190.                     self.bary.HiliteControl(0)
  1191.                 
  1192.             
  1193.             self.bary.SetControlValue(vy)
  1194.         
  1195.  
  1196.     
  1197.     def scalebarvalue(self, absmin, absmax, curmin, curmax):
  1198.         if curmin <= absmin and curmax >= absmax:
  1199.             return None
  1200.         
  1201.         if curmin <= absmin:
  1202.             return 0
  1203.         
  1204.         if curmax >= absmax:
  1205.             return 32767
  1206.         
  1207.         perc = float(curmin - absmin) / float(absmax - absmin)
  1208.         return int(perc * 32767)
  1209.  
  1210.     
  1211.     def getscrollbarvalues(self):
  1212.         return (0, 0)
  1213.  
  1214.     
  1215.     def scrollbar_callback(self, which, what, value):
  1216.         print 'scroll', which, what, value
  1217.  
  1218.  
  1219.  
  1220. class DialogWindow(Window):
  1221.     '''A modeless dialog window'''
  1222.     
  1223.     def open(self, resid):
  1224.         self.dlg = GetNewDialog(resid, -1)
  1225.         self.wid = self.dlg.GetDialogWindow()
  1226.         self.do_postopen()
  1227.  
  1228.     
  1229.     def close(self):
  1230.         self.do_postclose()
  1231.  
  1232.     
  1233.     def do_postclose(self):
  1234.         self.dlg = None
  1235.         Window.do_postclose(self)
  1236.  
  1237.     
  1238.     def do_itemhit(self, item, event):
  1239.         print 'Dialog %s, item %d hit' % (self.dlg, item)
  1240.  
  1241.     
  1242.     def do_rawupdate(self, window, event):
  1243.         pass
  1244.  
  1245.  
  1246.  
  1247. def ostypecode(x):
  1248.     '''Convert a long int to the 4-character code it really is'''
  1249.     s = ''
  1250.     for i in range(4):
  1251.         (x, c) = divmod(x, 256)
  1252.         s = chr(c) + s
  1253.     
  1254.     return s
  1255.  
  1256.  
  1257. class TestApp(Application):
  1258.     '''This class is used by the test() function'''
  1259.     
  1260.     def makeusermenus(self):
  1261.         self.filemenu = m = Menu(self.menubar, 'File')
  1262.         self.saveitem = MenuItem(m, 'Save', 'S', self.save)
  1263.         Separator(m)
  1264.         self.optionsmenu = mm = SubMenu(m, 'Options')
  1265.         self.opt1 = CheckItem(mm, 'Arguments', 'A')
  1266.         self.opt2 = CheckItem(mm, 'Being hit on the head lessons', (kMenuOptionModifier, 'A'))
  1267.         self.opt3 = CheckItem(mm, 'Complaints', (kMenuOptionModifier | kMenuNoCommandModifier, 'A'))
  1268.         Separator(m)
  1269.         self.itemeh = MenuItem(m, 'Enable Help', None, self.enablehelp)
  1270.         self.itemdbg = MenuItem(m, 'Debug', None, self.debug)
  1271.         Separator(m)
  1272.         self.quititem = MenuItem(m, 'Quit', 'Q', self.quit)
  1273.  
  1274.     
  1275.     def save(self, *args):
  1276.         print 'Save'
  1277.  
  1278.     
  1279.     def quit(self, *args):
  1280.         raise self
  1281.  
  1282.     
  1283.     def enablehelp(self, *args):
  1284.         hm = self.gethelpmenu()
  1285.         self.nohelpitem = MenuItem(hm, "There isn't any", None, self.nohelp)
  1286.  
  1287.     
  1288.     def nohelp(self, *args):
  1289.         print "I told you there isn't any!"
  1290.  
  1291.     
  1292.     def debug(self, *args):
  1293.         import pdb
  1294.         pdb.set_trace()
  1295.  
  1296.  
  1297.  
  1298. def test():
  1299.     '''Test program'''
  1300.     app = TestApp()
  1301.     app.mainloop()
  1302.  
  1303. if __name__ == '__main__':
  1304.     test()
  1305.  
  1306.