/Lib/plat-mac/FrameWork.py

http://unladen-swallow.googlecode.com/ · Python · 1126 lines · 869 code · 171 blank · 86 comment · 217 complexity · fb10cc18214a6b3fd7585e56a7894d45 MD5 · raw file

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