"A sort of application framework for the Mac" DEBUG=0 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 == 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 == 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 eventname.has_key(what): 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 self._windows.has_key(window): 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 partname.has_key(partcode): name = "do_" + partname[partcode] else: name = "do_%d" % partcode if wid == 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 self._windows.has_key(wid): # 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 self._windows.has_key(w): 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", `c` def do_updateEvt(self, event): (what, message, when, where, modifiers) = event wid = WhichWindow(message) if wid and self._windows.has_key(wid): 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 self._windows.has_key(wid): 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 self._windows.has_key(wid): 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 = `what` if eventname.has_key(what): nicewhat = eventname[what] print nicewhat, if what == kHighLevelEvent: h, v = where print `ostypecode(message)`, hex(when), `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 == 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 self.parent._windows.has_key(wid): 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 self.menus.has_key(id): 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 self.bar.parent._windows.has_key(wid): 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 == None: self.barx_enabled, vx = 0, 0 if vy == 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 == 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 == 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()