summaryrefslogtreecommitdiff
path: root/lib/python2.7/plat-mac/FrameWork.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/plat-mac/FrameWork.py')
-rw-r--r--lib/python2.7/plat-mac/FrameWork.py1126
1 files changed, 1126 insertions, 0 deletions
diff --git a/lib/python2.7/plat-mac/FrameWork.py b/lib/python2.7/plat-mac/FrameWork.py
new file mode 100644
index 0000000..ca8aaa6
--- /dev/null
+++ b/lib/python2.7/plat-mac/FrameWork.py
@@ -0,0 +1,1126 @@
+"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()
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-06 21:54:09 +0000