| "A sort of application framework for the Mac" | |
| DEBUG=0 | |
| from warnings import warnpy3k | |
| warnpy3k("In 3.x, the FrameWork module is removed.", stacklevel=2) | |
| import MacOS | |
| import traceback | |
| from Carbon.AE import * | |
| from Carbon.AppleEvents import * | |
| from Carbon.Ctl import * | |
| from Carbon.Controls import * | |
| from Carbon.Dlg import * | |
| from Carbon.Dialogs import * | |
| from Carbon.Evt import * | |
| from Carbon.Events import * | |
| from Carbon.Help import * | |
| from Carbon.Menu import * | |
| from Carbon.Menus import * | |
| from Carbon.Qd import * | |
| from Carbon.QuickDraw import * | |
| #from Carbon.Res import * | |
| #from Carbon.Resources import * | |
| #from Carbon.Snd import * | |
| #from Carbon.Sound import * | |
| from Carbon.Win import * | |
| from Carbon.Windows import * | |
| import types | |
| import EasyDialogs | |
| try: | |
| MyFrontWindow = FrontNonFloatingWindow | |
| except NameError: | |
| MyFrontWindow = FrontWindow | |
| kHighLevelEvent = 23 # Don't know what header file this should come from | |
| SCROLLBARWIDTH = 16 # Again, not a clue... | |
| # Trick to forestall a set of SIOUX menus being added to our menubar | |
| SIOUX_APPLEMENU_ID=32000 | |
| # Map event 'what' field to strings | |
| eventname = {} | |
| eventname[1] = 'mouseDown' | |
| eventname[2] = 'mouseUp' | |
| eventname[3] = 'keyDown' | |
| eventname[4] = 'keyUp' | |
| eventname[5] = 'autoKey' | |
| eventname[6] = 'updateEvt' | |
| eventname[7] = 'diskEvt' | |
| eventname[8] = 'activateEvt' | |
| eventname[15] = 'osEvt' | |
| eventname[23] = 'kHighLevelEvent' | |
| # Map part codes returned by WhichWindow() to strings | |
| partname = {} | |
| partname[0] = 'inDesk' | |
| partname[1] = 'inMenuBar' | |
| partname[2] = 'inSysWindow' | |
| partname[3] = 'inContent' | |
| partname[4] = 'inDrag' | |
| partname[5] = 'inGrow' | |
| partname[6] = 'inGoAway' | |
| partname[7] = 'inZoomIn' | |
| partname[8] = 'inZoomOut' | |
| # | |
| # The useable portion of the screen | |
| # ## but what happens with multiple screens? jvr | |
| screenbounds = GetQDGlobalsScreenBits().bounds | |
| screenbounds = screenbounds[0]+4, screenbounds[1]+4, \ | |
| screenbounds[2]-4, screenbounds[3]-4 | |
| next_window_x = 16 # jvr | |
| next_window_y = 44 # jvr | |
| def windowbounds(width, height): | |
| "Return sensible window bounds" | |
| global next_window_x, next_window_y | |
| r, b = next_window_x+width, next_window_y+height | |
| if r > screenbounds[2]: | |
| next_window_x = 16 | |
| if b > screenbounds[3]: | |
| next_window_y = 44 | |
| l, t = next_window_x, next_window_y | |
| r, b = next_window_x+width, next_window_y+height | |
| next_window_x, next_window_y = next_window_x + 8, next_window_y + 20 # jvr | |
| return l, t, r, b | |
| _watch = None | |
| def setwatchcursor(): | |
| global _watch | |
| if _watch is None: | |
| _watch = GetCursor(4).data | |
| SetCursor(_watch) | |
| def setarrowcursor(): | |
| SetCursor(GetQDGlobalsArrow()) | |
| class Application: | |
| "Application framework -- your application should be a derived class" | |
| def __init__(self, nomenubar=0): | |
| self._doing_asyncevents = 0 | |
| self.quitting = 0 | |
| self.needmenubarredraw = 0 | |
| self._windows = {} | |
| self._helpmenu = None | |
| if nomenubar: | |
| self.menubar = None | |
| else: | |
| self.makemenubar() | |
| def __del__(self): | |
| if self._doing_asyncevents: | |
| self._doing_asyncevents = 0 | |
| MacOS.SetEventHandler() | |
| def makemenubar(self): | |
| self.menubar = MenuBar(self) | |
| AppleMenu(self.menubar, self.getabouttext(), self.do_about) | |
| self.makeusermenus() | |
| def makeusermenus(self): | |
| self.filemenu = m = Menu(self.menubar, "File") | |
| self._quititem = MenuItem(m, "Quit", "Q", self._quit) | |
| def gethelpmenu(self): | |
| if self._helpmenu is None: | |
| self._helpmenu = HelpMenu(self.menubar) | |
| return self._helpmenu | |
| def _quit(self, *args): | |
| self.quitting = 1 | |
| def cleanup(self): | |
| for w in self._windows.values(): | |
| w.do_close() | |
| return self._windows == {} | |
| def appendwindow(self, wid, window): | |
| self._windows[wid] = window | |
| def removewindow(self, wid): | |
| del self._windows[wid] | |
| def getabouttext(self): | |
| return "About %s..." % self.__class__.__name__ | |
| def do_about(self, id, item, window, event): | |
| EasyDialogs.Message("Hello, world!" + "\015(%s)" % self.__class__.__name__) | |
| # The main event loop is broken up in several simple steps. | |
| # This is done so you can override each individual part, | |
| # if you have a need to do extra processing independent of the | |
| # event type. | |
| # Normally, however, you'd just define handlers for individual | |
| # events. | |
| schedparams = (0, 0) # By default disable Python's event handling | |
| default_wait = None # By default we wait GetCaretTime in WaitNextEvent | |
| def mainloop(self, mask = everyEvent, wait = None): | |
| self.quitting = 0 | |
| if hasattr(MacOS, 'SchedParams'): | |
| saveparams = MacOS.SchedParams(*self.schedparams) | |
| try: | |
| while not self.quitting: | |
| try: | |
| self.do1event(mask, wait) | |
| except (Application, SystemExit): | |
| # Note: the raising of "self" is old-fashioned idiom to | |
| # exit the mainloop. Calling _quit() is better for new | |
| # applications. | |
| break | |
| finally: | |
| if hasattr(MacOS, 'SchedParams'): | |
| MacOS.SchedParams(*saveparams) | |
| def dopendingevents(self, mask = everyEvent): | |
| """dopendingevents - Handle all pending events""" | |
| while self.do1event(mask, wait=0): | |
| pass | |
| def do1event(self, mask = everyEvent, wait = None): | |
| ok, event = self.getevent(mask, wait) | |
| if IsDialogEvent(event): | |
| if self.do_dialogevent(event): | |
| return | |
| if ok: | |
| self.dispatch(event) | |
| else: | |
| self.idle(event) | |
| def idle(self, event): | |
| pass | |
| def getevent(self, mask = everyEvent, wait = None): | |
| if self.needmenubarredraw: | |
| DrawMenuBar() | |
| self.needmenubarredraw = 0 | |
| if wait is None: | |
| wait = self.default_wait | |
| if wait is None: | |
| wait = GetCaretTime() | |
| ok, event = WaitNextEvent(mask, wait) | |
| return ok, event | |
| def dispatch(self, event): | |
| # The following appears to be double work (already done in do1event) | |
| # but we need it for asynchronous event handling | |
| if IsDialogEvent(event): | |
| if self.do_dialogevent(event): | |
| return | |
| (what, message, when, where, modifiers) = event | |
| if what in eventname: | |
| name = "do_" + eventname[what] | |
| else: | |
| name = "do_%d" % what | |
| try: | |
| handler = getattr(self, name) | |
| except AttributeError: | |
| handler = self.do_unknownevent | |
| handler(event) | |
| def asyncevents(self, onoff): | |
| """asyncevents - Set asynchronous event handling on or off""" | |
| if MacOS.runtimemodel == 'macho': | |
| raise 'Unsupported in MachoPython' | |
| old = self._doing_asyncevents | |
| if old: | |
| MacOS.SetEventHandler() | |
| MacOS.SchedParams(*self.schedparams) | |
| if onoff: | |
| MacOS.SetEventHandler(self.dispatch) | |
| doint, dummymask, benice, howoften, bgyield = \ | |
| self.schedparams | |
| MacOS.SchedParams(doint, everyEvent, benice, | |
| howoften, bgyield) | |
| self._doing_asyncevents = onoff | |
| return old | |
| def do_dialogevent(self, event): | |
| gotone, dlg, item = DialogSelect(event) | |
| if gotone: | |
| window = dlg.GetDialogWindow() | |
| if window in self._windows: | |
| self._windows[window].do_itemhit(item, event) | |
| else: | |
| print 'Dialog event for unknown dialog' | |
| return 1 | |
| return 0 | |
| def do_mouseDown(self, event): | |
| (what, message, when, where, modifiers) = event | |
| partcode, wid = FindWindow(where) | |
| # | |
| # Find the correct name. | |
| # | |
| if partcode in partname: | |
| name = "do_" + partname[partcode] | |
| else: | |
| name = "do_%d" % partcode | |
| if wid is None: | |
| # No window, or a non-python window | |
| try: | |
| handler = getattr(self, name) | |
| except AttributeError: | |
| # Not menubar or something, so assume someone | |
| # else's window | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| return | |
| elif wid in self._windows: | |
| # It is a window. Hand off to correct window. | |
| window = self._windows[wid] | |
| try: | |
| handler = getattr(window, name) | |
| except AttributeError: | |
| handler = self.do_unknownpartcode | |
| else: | |
| # It is a python-toolbox window, but not ours. | |
| handler = self.do_unknownwindow | |
| handler(partcode, wid, event) | |
| def do_inSysWindow(self, partcode, window, event): | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| def do_inDesk(self, partcode, window, event): | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| def do_inMenuBar(self, partcode, window, event): | |
| if not self.menubar: | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| return | |
| (what, message, when, where, modifiers) = event | |
| result = MenuSelect(where) | |
| id = (result>>16) & 0xffff # Hi word | |
| if id >= 0x8000: | |
| id = -65536 + id | |
| item = result & 0xffff # Lo word | |
| self.do_rawmenu(id, item, window, event) | |
| def do_rawmenu(self, id, item, window, event): | |
| try: | |
| self.do_menu(id, item, window, event) | |
| finally: | |
| HiliteMenu(0) | |
| def do_menu(self, id, item, window, event): | |
| if hasattr(MacOS, 'OutputSeen'): | |
| MacOS.OutputSeen() | |
| self.menubar.dispatch(id, item, window, event) | |
| def do_unknownpartcode(self, partcode, window, event): | |
| (what, message, when, where, modifiers) = event | |
| if DEBUG: print "Mouse down at global:", where | |
| if DEBUG: print "\tUnknown part code:", partcode | |
| if DEBUG: print "\tEvent:", self.printevent(event) | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| def do_unknownwindow(self, partcode, window, event): | |
| if DEBUG: print 'Unknown window:', window | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| def do_keyDown(self, event): | |
| self.do_key(event) | |
| def do_autoKey(self, event): | |
| if not event[-1] & cmdKey: | |
| self.do_key(event) | |
| def do_key(self, event): | |
| (what, message, when, where, modifiers) = event | |
| c = chr(message & charCodeMask) | |
| if self.menubar: | |
| result = MenuEvent(event) | |
| id = (result>>16) & 0xffff # Hi word | |
| item = result & 0xffff # Lo word | |
| if id: | |
| self.do_rawmenu(id, item, None, event) | |
| return | |
| # Otherwise we fall-through | |
| if modifiers & cmdKey: | |
| if c == '.': | |
| raise self | |
| else: | |
| if not self.menubar: | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| return | |
| else: | |
| # See whether the front window wants it | |
| w = MyFrontWindow() | |
| if w and w in self._windows: | |
| window = self._windows[w] | |
| try: | |
| do_char = window.do_char | |
| except AttributeError: | |
| do_char = self.do_char | |
| do_char(c, event) | |
| # else it wasn't for us, sigh... | |
| def do_char(self, c, event): | |
| if DEBUG: print "Character", repr(c) | |
| def do_updateEvt(self, event): | |
| (what, message, when, where, modifiers) = event | |
| wid = WhichWindow(message) | |
| if wid and wid in self._windows: | |
| window = self._windows[wid] | |
| window.do_rawupdate(wid, event) | |
| else: | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| def do_activateEvt(self, event): | |
| (what, message, when, where, modifiers) = event | |
| wid = WhichWindow(message) | |
| if wid and wid in self._windows: | |
| window = self._windows[wid] | |
| window.do_activate(modifiers & 1, event) | |
| else: | |
| if hasattr(MacOS, 'HandleEvent'): | |
| MacOS.HandleEvent(event) | |
| def do_osEvt(self, event): | |
| (what, message, when, where, modifiers) = event | |
| which = (message >> 24) & 0xff | |
| if which == 1: # suspend/resume | |
| self.do_suspendresume(event) | |
| else: | |
| if DEBUG: | |
| print 'unknown osEvt:', | |
| self.printevent(event) | |
| def do_suspendresume(self, event): | |
| (what, message, when, where, modifiers) = event | |
| wid = MyFrontWindow() | |
| if wid and wid in self._windows: | |
| window = self._windows[wid] | |
| window.do_activate(message & 1, event) | |
| def do_kHighLevelEvent(self, event): | |
| (what, message, when, where, modifiers) = event | |
| if DEBUG: | |
| print "High Level Event:", | |
| self.printevent(event) | |
| try: | |
| AEProcessAppleEvent(event) | |
| except: | |
| pass | |
| #print "AEProcessAppleEvent error:" | |
| #traceback.print_exc() | |
| def do_unknownevent(self, event): | |
| if DEBUG: | |
| print "Unhandled event:", | |
| self.printevent(event) | |
| def printevent(self, event): | |
| (what, message, when, where, modifiers) = event | |
| nicewhat = repr(what) | |
| if what in eventname: | |
| nicewhat = eventname[what] | |
| print nicewhat, | |
| if what == kHighLevelEvent: | |
| h, v = where | |
| print repr(ostypecode(message)), hex(when), repr(ostypecode(h | (v<<16))), | |
| else: | |
| print hex(message), hex(when), where, | |
| print hex(modifiers) | |
| class MenuBar: | |
| """Represent a set of menus in a menu bar. | |
| Interface: | |
| - (constructor) | |
| - (destructor) | |
| - addmenu | |
| - addpopup (normally used internally) | |
| - dispatch (called from Application) | |
| """ | |
| nextid = 1 # Necessarily a class variable | |
| def getnextid(self): | |
| id = MenuBar.nextid | |
| MenuBar.nextid = id+1 | |
| return id | |
| def __init__(self, parent=None): | |
| self.parent = parent | |
| ClearMenuBar() | |
| self.bar = GetMenuBar() | |
| self.menus = {} | |
| # XXX necessary? | |
| def close(self): | |
| self.parent = None | |
| self.bar = None | |
| self.menus = None | |
| def addmenu(self, title, after = 0, id=None): | |
| if id is None: | |
| id = self.getnextid() | |
| if DEBUG: print 'Newmenu', title, id # XXXX | |
| m = NewMenu(id, title) | |
| m.InsertMenu(after) | |
| if after >= 0: | |
| if self.parent: | |
| self.parent.needmenubarredraw = 1 | |
| else: | |
| DrawMenuBar() | |
| return id, m | |
| def delmenu(self, id): | |
| if DEBUG: print 'Delmenu', id # XXXX | |
| DeleteMenu(id) | |
| def addpopup(self, title = ''): | |
| return self.addmenu(title, -1) | |
| # Useless: | |
| # def install(self): | |
| # if not self.bar: return | |
| # SetMenuBar(self.bar) | |
| # if self.parent: | |
| # self.parent.needmenubarredraw = 1 | |
| # else: | |
| # DrawMenuBar() | |
| def fixmenudimstate(self): | |
| for m in self.menus.keys(): | |
| menu = self.menus[m] | |
| if menu.__class__ == FrameWork.AppleMenu: | |
| continue | |
| for i in range(len(menu.items)): | |
| label, shortcut, callback, kind = menu.items[i] | |
| if type(callback) == types.StringType: | |
| wid = MyFrontWindow() | |
| if wid and wid in self.parent._windows: | |
| window = self.parent._windows[wid] | |
| if hasattr(window, "domenu_" + callback): | |
| menu.menu.EnableMenuItem(i + 1) | |
| elif hasattr(self.parent, "domenu_" + callback): | |
| menu.menu.EnableMenuItem(i + 1) | |
| else: | |
| menu.menu.DisableMenuItem(i + 1) | |
| elif hasattr(self.parent, "domenu_" + callback): | |
| menu.menu.EnableMenuItem(i + 1) | |
| else: | |
| menu.menu.DisableMenuItem(i + 1) | |
| elif callback: | |
| pass | |
| def dispatch(self, id, item, window, event): | |
| if id in self.menus: | |
| self.menus[id].dispatch(id, item, window, event) | |
| else: | |
| if DEBUG: print "MenuBar.dispatch(%d, %d, %s, %s)" % \ | |
| (id, item, window, event) | |
| # XXX Need a way to get menus as resources and bind them to callbacks | |
| class Menu: | |
| "One menu." | |
| def __init__(self, bar, title, after=0, id=None): | |
| self.bar = bar | |
| self.id, self.menu = self.bar.addmenu(title, after, id) | |
| bar.menus[self.id] = self | |
| self.items = [] | |
| self._parent = None | |
| def delete(self): | |
| self.bar.delmenu(self.id) | |
| del self.bar.menus[self.id] | |
| self.menu.DisposeMenu() | |
| del self.bar | |
| del self.items | |
| del self.menu | |
| del self.id | |
| del self._parent | |
| def additem(self, label, shortcut=None, callback=None, kind=None): | |
| self.menu.AppendMenu('x') # add a dummy string | |
| self.items.append((label, shortcut, callback, kind)) | |
| item = len(self.items) | |
| if isinstance(label, unicode): | |
| self.menu.SetMenuItemTextWithCFString(item, label) | |
| else: | |
| self.menu.SetMenuItemText(item, label) | |
| if shortcut and type(shortcut) == type(()): | |
| modifiers, char = shortcut[:2] | |
| self.menu.SetItemCmd(item, ord(char)) | |
| self.menu.SetMenuItemModifiers(item, modifiers) | |
| if len(shortcut) > 2: | |
| self.menu.SetMenuItemKeyGlyph(item, shortcut[2]) | |
| elif shortcut: | |
| self.menu.SetItemCmd(item, ord(shortcut)) | |
| return item | |
| def delitem(self, item): | |
| if item != len(self.items): | |
| raise 'Can only delete last item of a menu' | |
| self.menu.DeleteMenuItem(item) | |
| del self.items[item-1] | |
| def addcheck(self, label, shortcut=None, callback=None): | |
| return self.additem(label, shortcut, callback, 'check') | |
| def addradio(self, label, shortcut=None, callback=None): | |
| return self.additem(label, shortcut, callback, 'radio') | |
| def addseparator(self): | |
| self.menu.AppendMenu('(-') | |
| self.items.append(('', None, None, 'separator')) | |
| def addsubmenu(self, label, title=''): | |
| sub = Menu(self.bar, title, -1) | |
| item = self.additem(label, '\x1B', None, 'submenu') | |
| self.menu.SetItemMark(item, sub.id) | |
| sub._parent = self | |
| sub._parent_item = item | |
| return sub | |
| def dispatch(self, id, item, window, event): | |
| title, shortcut, callback, mtype = self.items[item-1] | |
| if callback: | |
| if not self.bar.parent or type(callback) != types.StringType: | |
| menuhandler = callback | |
| else: | |
| # callback is string | |
| wid = MyFrontWindow() | |
| if wid and wid in self.bar.parent._windows: | |
| window = self.bar.parent._windows[wid] | |
| if hasattr(window, "domenu_" + callback): | |
| menuhandler = getattr(window, "domenu_" + callback) | |
| elif hasattr(self.bar.parent, "domenu_" + callback): | |
| menuhandler = getattr(self.bar.parent, "domenu_" + callback) | |
| else: | |
| # nothing we can do. we shouldn't have come this far | |
| # since the menu item should have been disabled... | |
| return | |
| elif hasattr(self.bar.parent, "domenu_" + callback): | |
| menuhandler = getattr(self.bar.parent, "domenu_" + callback) | |
| else: | |
| # nothing we can do. we shouldn't have come this far | |
| # since the menu item should have been disabled... | |
| return | |
| menuhandler(id, item, window, event) | |
| def enable(self, onoff): | |
| if onoff: | |
| self.menu.EnableMenuItem(0) | |
| if self._parent: | |
| self._parent.menu.EnableMenuItem(self._parent_item) | |
| else: | |
| self.menu.DisableMenuItem(0) | |
| if self._parent: | |
| self._parent.menu.DisableMenuItem(self._parent_item) | |
| if self.bar and self.bar.parent: | |
| self.bar.parent.needmenubarredraw = 1 | |
| class PopupMenu(Menu): | |
| def __init__(self, bar): | |
| Menu.__init__(self, bar, '(popup)', -1) | |
| def popup(self, x, y, event, default=1, window=None): | |
| # NOTE that x and y are global coordinates, and they should probably | |
| # be topleft of the button the user clicked (not mouse-coordinates), | |
| # so the popup nicely overlaps. | |
| reply = self.menu.PopUpMenuSelect(x, y, default) | |
| if not reply: | |
| return | |
| id = (reply >> 16) & 0xffff | |
| item = reply & 0xffff | |
| if not window: | |
| wid = MyFrontWindow() | |
| try: | |
| window = self.bar.parent._windows[wid] | |
| except: | |
| pass # If we can't find the window we pass None | |
| self.dispatch(id, item, window, event) | |
| class MenuItem: | |
| def __init__(self, menu, title, shortcut=None, callback=None, kind=None): | |
| self.item = menu.additem(title, shortcut, callback) | |
| self.menu = menu | |
| def delete(self): | |
| self.menu.delitem(self.item) | |
| del self.menu | |
| del self.item | |
| def check(self, onoff): | |
| self.menu.menu.CheckMenuItem(self.item, onoff) | |
| def enable(self, onoff): | |
| if onoff: | |
| self.menu.menu.EnableMenuItem(self.item) | |
| else: | |
| self.menu.menu.DisableMenuItem(self.item) | |
| def settext(self, text): | |
| self.menu.menu.SetMenuItemText(self.item, text) | |
| def setstyle(self, style): | |
| self.menu.menu.SetItemStyle(self.item, style) | |
| def seticon(self, icon): | |
| self.menu.menu.SetItemIcon(self.item, icon) | |
| def setcmd(self, cmd): | |
| self.menu.menu.SetItemCmd(self.item, cmd) | |
| def setmark(self, cmd): | |
| self.menu.menu.SetItemMark(self.item, cmd) | |
| class RadioItem(MenuItem): | |
| def __init__(self, menu, title, shortcut=None, callback=None): | |
| MenuItem.__init__(self, menu, title, shortcut, callback, 'radio') | |
| class CheckItem(MenuItem): | |
| def __init__(self, menu, title, shortcut=None, callback=None): | |
| MenuItem.__init__(self, menu, title, shortcut, callback, 'check') | |
| def Separator(menu): | |
| menu.addseparator() | |
| def SubMenu(menu, label, title=''): | |
| return menu.addsubmenu(label, title) | |
| class AppleMenu(Menu): | |
| def __init__(self, bar, abouttext="About me...", aboutcallback=None): | |
| Menu.__init__(self, bar, "\024", id=SIOUX_APPLEMENU_ID) | |
| if MacOS.runtimemodel == 'ppc': | |
| self.additem(abouttext, None, aboutcallback) | |
| self.addseparator() | |
| self.menu.AppendResMenu('DRVR') | |
| else: | |
| # Additem()'s tricks do not work for "apple" menu under Carbon | |
| self.menu.InsertMenuItem(abouttext, 0) | |
| self.items.append((abouttext, None, aboutcallback, None)) | |
| def dispatch(self, id, item, window, event): | |
| if item == 1: | |
| Menu.dispatch(self, id, item, window, event) | |
| elif MacOS.runtimemodel == 'ppc': | |
| name = self.menu.GetMenuItemText(item) | |
| OpenDeskAcc(name) | |
| class HelpMenu(Menu): | |
| def __init__(self, bar): | |
| # Note we don't call Menu.__init__, we do the necessary things by hand | |
| self.bar = bar | |
| self.menu, index = HMGetHelpMenu() | |
| self.id = self.menu.GetMenuID() | |
| bar.menus[self.id] = self | |
| # The next line caters for the entries the system already handles for us | |
| self.items = [None]*(index-1) | |
| self._parent = None | |
| class Window: | |
| """A single window belonging to an application""" | |
| def __init__(self, parent): | |
| self.wid = None | |
| self.parent = parent | |
| def open(self, bounds=(40, 40, 400, 400), resid=None): | |
| if resid != None: | |
| self.wid = GetNewWindow(resid, -1) | |
| else: | |
| self.wid = NewWindow(bounds, self.__class__.__name__, 1, | |
| 8, -1, 1, 0) # changed to proc id 8 to include zoom box. jvr | |
| self.do_postopen() | |
| def do_postopen(self): | |
| """Tell our parent we exist""" | |
| self.parent.appendwindow(self.wid, self) | |
| def close(self): | |
| self.do_postclose() | |
| def do_postclose(self): | |
| self.parent.removewindow(self.wid) | |
| self.parent = None | |
| self.wid = None | |
| def SetPort(self): | |
| # Convinience method | |
| SetPort(self.wid) | |
| def GetWindow(self): | |
| return self.wid | |
| def do_inDrag(self, partcode, window, event): | |
| where = event[3] | |
| window.DragWindow(where, self.draglimit) | |
| draglimit = screenbounds | |
| def do_inGoAway(self, partcode, window, event): | |
| where = event[3] | |
| if window.TrackGoAway(where): | |
| self.close() | |
| def do_inZoom(self, partcode, window, event): | |
| (what, message, when, where, modifiers) = event | |
| if window.TrackBox(where, partcode): | |
| window.ZoomWindow(partcode, 1) | |
| rect = window.GetWindowUserState() # so that zoom really works... jvr | |
| self.do_postresize(rect[2] - rect[0], rect[3] - rect[1], window) # jvr | |
| def do_inZoomIn(self, partcode, window, event): | |
| SetPort(window) # !!! | |
| self.do_inZoom(partcode, window, event) | |
| def do_inZoomOut(self, partcode, window, event): | |
| SetPort(window) # !!! | |
| self.do_inZoom(partcode, window, event) | |
| def do_inGrow(self, partcode, window, event): | |
| (what, message, when, where, modifiers) = event | |
| result = window.GrowWindow(where, self.growlimit) | |
| if result: | |
| height = (result>>16) & 0xffff # Hi word | |
| width = result & 0xffff # Lo word | |
| self.do_resize(width, height, window) | |
| growlimit = (50, 50, screenbounds[2] - screenbounds[0], screenbounds[3] - screenbounds[1]) # jvr | |
| def do_resize(self, width, height, window): | |
| l, t, r, b = self.wid.GetWindowPort().GetPortBounds() # jvr, forGrowIcon | |
| self.SetPort() # jvr | |
| self.wid.InvalWindowRect((r - SCROLLBARWIDTH + 1, b - SCROLLBARWIDTH + 1, r, b)) # jvr | |
| window.SizeWindow(width, height, 1) # changed updateFlag to true jvr | |
| self.do_postresize(width, height, window) | |
| def do_postresize(self, width, height, window): | |
| SetPort(window) | |
| self.wid.InvalWindowRect(window.GetWindowPort().GetPortBounds()) | |
| def do_inContent(self, partcode, window, event): | |
| # | |
| # If we're not frontmost, select ourselves and wait for | |
| # the activate event. | |
| # | |
| if MyFrontWindow() != window: | |
| window.SelectWindow() | |
| return | |
| # We are. Handle the event. | |
| (what, message, when, where, modifiers) = event | |
| SetPort(window) | |
| local = GlobalToLocal(where) | |
| self.do_contentclick(local, modifiers, event) | |
| def do_contentclick(self, local, modifiers, event): | |
| if DEBUG: | |
| print 'Click in contents at %s, modifiers %s'%(local, modifiers) | |
| def do_rawupdate(self, window, event): | |
| if DEBUG: print "raw update for", window | |
| SetPort(window) | |
| window.BeginUpdate() | |
| self.do_update(window, event) | |
| window.EndUpdate() | |
| def do_update(self, window, event): | |
| if DEBUG: | |
| import time | |
| for i in range(8): | |
| time.sleep(0.1) | |
| InvertRgn(window.GetWindowPort().visRgn) | |
| FillRgn(window.GetWindowPort().visRgn, GetQDGlobalsGray()) | |
| else: | |
| EraseRgn(window.GetWindowPort().visRgn) | |
| def do_activate(self, activate, event): | |
| if DEBUG: print 'Activate %d for %s'%(activate, self.wid) | |
| class ControlsWindow(Window): | |
| def do_rawupdate(self, window, event): | |
| if DEBUG: print "raw update for", window | |
| SetPort(window) | |
| window.BeginUpdate() | |
| self.do_update(window, event) | |
| #DrawControls(window) # jvr | |
| UpdateControls(window, window.GetWindowPort().visRgn) # jvr | |
| window.DrawGrowIcon() | |
| window.EndUpdate() | |
| def do_controlhit(self, window, control, pcode, event): | |
| if DEBUG: print "control hit in", window, "on", control, "; pcode =", pcode | |
| def do_inContent(self, partcode, window, event): | |
| if MyFrontWindow() != window: | |
| window.SelectWindow() | |
| return | |
| (what, message, when, where, modifiers) = event | |
| SetPort(window) # XXXX Needed? | |
| local = GlobalToLocal(where) | |
| pcode, control = FindControl(local, window) | |
| if pcode and control: | |
| self.do_rawcontrolhit(window, control, pcode, local, event) | |
| else: | |
| if DEBUG: print "FindControl(%s, %s) -> (%s, %s)" % \ | |
| (local, window, pcode, control) | |
| self.do_contentclick(local, modifiers, event) | |
| def do_rawcontrolhit(self, window, control, pcode, local, event): | |
| pcode = control.TrackControl(local) | |
| if pcode: | |
| self.do_controlhit(window, control, pcode, event) | |
| class ScrolledWindow(ControlsWindow): | |
| def __init__(self, parent): | |
| self.barx = self.bary = None | |
| self.barx_enabled = self.bary_enabled = 1 | |
| self.activated = 1 | |
| ControlsWindow.__init__(self, parent) | |
| def scrollbars(self, wantx=1, wanty=1): | |
| SetPort(self.wid) | |
| self.barx = self.bary = None | |
| self.barx_enabled = self.bary_enabled = 1 | |
| x0, y0, x1, y1 = self.wid.GetWindowPort().GetPortBounds() | |
| vx, vy = self.getscrollbarvalues() | |
| if vx is None: self.barx_enabled, vx = 0, 0 | |
| if vy is None: self.bary_enabled, vy = 0, 0 | |
| if wantx: | |
| rect = x0-1, y1-(SCROLLBARWIDTH-1), x1-(SCROLLBARWIDTH-2), y1+1 | |
| self.barx = NewControl(self.wid, rect, "", 1, vx, 0, 32767, 16, 0) | |
| if not self.barx_enabled: self.barx.HiliteControl(255) | |
| ## self.wid.InvalWindowRect(rect) | |
| if wanty: | |
| rect = x1-(SCROLLBARWIDTH-1), y0-1, x1+1, y1-(SCROLLBARWIDTH-2) | |
| self.bary = NewControl(self.wid, rect, "", 1, vy, 0, 32767, 16, 0) | |
| if not self.bary_enabled: self.bary.HiliteControl(255) | |
| ## self.wid.InvalWindowRect(rect) | |
| def do_postclose(self): | |
| self.barx = self.bary = None | |
| ControlsWindow.do_postclose(self) | |
| def do_activate(self, onoff, event): | |
| self.activated = onoff | |
| if onoff: | |
| if self.barx and self.barx_enabled: | |
| self.barx.ShowControl() # jvr | |
| if self.bary and self.bary_enabled: | |
| self.bary.ShowControl() # jvr | |
| else: | |
| if self.barx: | |
| self.barx.HideControl() # jvr; An inactive window should have *hidden* | |
| # scrollbars, not just dimmed (no matter what | |
| # BBEdit does... look at the Finder) | |
| if self.bary: | |
| self.bary.HideControl() # jvr | |
| self.wid.DrawGrowIcon() # jvr | |
| def do_postresize(self, width, height, window): | |
| l, t, r, b = self.wid.GetWindowPort().GetPortBounds() | |
| self.SetPort() | |
| if self.barx: | |
| self.barx.HideControl() # jvr | |
| self.barx.MoveControl(l-1, b-(SCROLLBARWIDTH-1)) | |
| self.barx.SizeControl((r-l)-(SCROLLBARWIDTH-3), SCROLLBARWIDTH) # jvr | |
| if self.bary: | |
| self.bary.HideControl() # jvr | |
| self.bary.MoveControl(r-(SCROLLBARWIDTH-1), t-1) | |
| self.bary.SizeControl(SCROLLBARWIDTH, (b-t)-(SCROLLBARWIDTH-3)) # jvr | |
| if self.barx: | |
| self.barx.ShowControl() # jvr | |
| self.wid.ValidWindowRect((l, b - SCROLLBARWIDTH + 1, r - SCROLLBARWIDTH + 2, b)) # jvr | |
| if self.bary: | |
| self.bary.ShowControl() # jvr | |
| self.wid.ValidWindowRect((r - SCROLLBARWIDTH + 1, t, r, b - SCROLLBARWIDTH + 2)) # jvr | |
| self.wid.InvalWindowRect((r - SCROLLBARWIDTH + 1, b - SCROLLBARWIDTH + 1, r, b)) # jvr, growicon | |
| def do_rawcontrolhit(self, window, control, pcode, local, event): | |
| if control == self.barx: | |
| which = 'x' | |
| elif control == self.bary: | |
| which = 'y' | |
| else: | |
| return 0 | |
| if pcode in (inUpButton, inDownButton, inPageUp, inPageDown): | |
| # We do the work for the buttons and grey area in the tracker | |
| dummy = control.TrackControl(local, self.do_controltrack) | |
| else: | |
| # but the thumb is handled here | |
| pcode = control.TrackControl(local) | |
| if pcode == inThumb: | |
| value = control.GetControlValue() | |
| print 'setbars', which, value #DBG | |
| self.scrollbar_callback(which, 'set', value) | |
| self.updatescrollbars() | |
| else: | |
| print 'funny part', pcode #DBG | |
| return 1 | |
| def do_controltrack(self, control, pcode): | |
| if control == self.barx: | |
| which = 'x' | |
| elif control == self.bary: | |
| which = 'y' | |
| else: | |
| return | |
| if pcode == inUpButton: | |
| what = '-' | |
| elif pcode == inDownButton: | |
| what = '+' | |
| elif pcode == inPageUp: | |
| what = '--' | |
| elif pcode == inPageDown: | |
| what = '++' | |
| else: | |
| return | |
| self.scrollbar_callback(which, what, None) | |
| self.updatescrollbars() | |
| def updatescrollbars(self): | |
| SetPort(self.wid) | |
| vx, vy = self.getscrollbarvalues() | |
| if self.barx: | |
| if vx is None: | |
| self.barx.HiliteControl(255) | |
| self.barx_enabled = 0 | |
| else: | |
| if not self.barx_enabled: | |
| self.barx_enabled = 1 | |
| if self.activated: | |
| self.barx.HiliteControl(0) | |
| self.barx.SetControlValue(vx) | |
| if self.bary: | |
| if vy is None: | |
| self.bary.HiliteControl(255) | |
| self.bary_enabled = 0 | |
| else: | |
| if not self.bary_enabled: | |
| self.bary_enabled = 1 | |
| if self.activated: | |
| self.bary.HiliteControl(0) | |
| self.bary.SetControlValue(vy) | |
| # Auxiliary function: convert standard text/image/etc coordinate | |
| # to something palatable as getscrollbarvalues() return | |
| def scalebarvalue(self, absmin, absmax, curmin, curmax): | |
| if curmin <= absmin and curmax >= absmax: | |
| return None | |
| if curmin <= absmin: | |
| return 0 | |
| if curmax >= absmax: | |
| return 32767 | |
| perc = float(curmin-absmin)/float(absmax-absmin) | |
| return int(perc*32767) | |
| # To be overridden: | |
| def getscrollbarvalues(self): | |
| return 0, 0 | |
| def scrollbar_callback(self, which, what, value): | |
| print 'scroll', which, what, value | |
| class DialogWindow(Window): | |
| """A modeless dialog window""" | |
| def open(self, resid): | |
| self.dlg = GetNewDialog(resid, -1) | |
| self.wid = self.dlg.GetDialogWindow() | |
| self.do_postopen() | |
| def close(self): | |
| self.do_postclose() | |
| def do_postclose(self): | |
| self.dlg = None | |
| Window.do_postclose(self) | |
| def do_itemhit(self, item, event): | |
| print 'Dialog %s, item %d hit'%(self.dlg, item) | |
| def do_rawupdate(self, window, event): | |
| pass | |
| def ostypecode(x): | |
| "Convert a long int to the 4-character code it really is" | |
| s = '' | |
| for i in range(4): | |
| x, c = divmod(x, 256) | |
| s = chr(c) + s | |
| return s | |
| class TestApp(Application): | |
| "This class is used by the test() function" | |
| def makeusermenus(self): | |
| self.filemenu = m = Menu(self.menubar, "File") | |
| self.saveitem = MenuItem(m, "Save", "S", self.save) | |
| Separator(m) | |
| self.optionsmenu = mm = SubMenu(m, "Options") | |
| self.opt1 = CheckItem(mm, "Arguments", "A") | |
| self.opt2 = CheckItem(mm, "Being hit on the head lessons", (kMenuOptionModifier, "A")) | |
| self.opt3 = CheckItem(mm, "Complaints", (kMenuOptionModifier|kMenuNoCommandModifier, "A")) | |
| Separator(m) | |
| self.itemeh = MenuItem(m, "Enable Help", None, self.enablehelp) | |
| self.itemdbg = MenuItem(m, "Debug", None, self.debug) | |
| Separator(m) | |
| self.quititem = MenuItem(m, "Quit", "Q", self.quit) | |
| def save(self, *args): | |
| print "Save" | |
| def quit(self, *args): | |
| raise self | |
| def enablehelp(self, *args): | |
| hm = self.gethelpmenu() | |
| self.nohelpitem = MenuItem(hm, "There isn't any", None, self.nohelp) | |
| def nohelp(self, *args): | |
| print "I told you there isn't any!" | |
| def debug(self, *args): | |
| import pdb | |
| pdb.set_trace() | |
| def test(): | |
| "Test program" | |
| app = TestApp() | |
| app.mainloop() | |
| if __name__ == '__main__': | |
| test() |