Mac/Tools/IDE/Wmenus.py

   1 import FrameWork
   2 import Qd
   3 import Wbase
   4 from types import *
   5 import Wapplication
   6
   7 _arrowright = Qd.GetPicture(472)
   8 _arrowdown = Qd.GetPicture(473)
   9
  10
  11
  12 class PopupWidget(Wbase.ClickableWidget):
  13
  14         """Simple title-less popup widget. Should be 16x16 pixels.
  15         Builds the menu items on the fly, good for dynamic popup menus."""
  16
  17         def __init__(self, possize, items = [], callback = None):
  18                 Wbase.Widget.__init__(self, possize)
  19                 self._items = items
  20                 self._itemsdict = {}
  21                 self._callback = callback
  22                 self._enabled = 1
  23
  24         def close(self):
  25                 Wbase.Widget.close(self)
  26                 self._items = None
  27                 self._itemsdict = {}
  28
  29         def draw(self, visRgn = None):
  30                 if self._visible:
  31                         Qd.FrameRect(self._bounds)
  32                         Qd.EraseRect(Qd.InsetRect(self._bounds, 1, 1))
  33                         l, t, r, b = self._bounds
  34                         l = l + 2
  35                         t = t + 3
  36                         pictframe = (l, t, l + 10, t + 10)
  37                         Qd.DrawPicture(_arrowright, pictframe)
  38
  39         def click(self, point, modifiers):
  40                 if not self._enabled:
  41                         return
  42                 self.menu = FrameWork.Menu(self._parentwindow.parent.menubar, 'Foo', -1)
  43                 self._additems(self._items, self.menu)
  44                 self.SetPort()
  45                 l, t, r, b = self._bounds
  46                 l, t = Qd.LocalToGlobal((l+1, t+1))
  47                 Wbase.SetCursor("arrow")
  48                 self.menu.menu.EnableItem(0)
  49                 reply = self.menu.menu.PopUpMenuSelect(t, l, 1)
  50                 if reply:
  51                         id = (reply & 0xffff0000) >> 16
  52                         item = reply & 0xffff
  53                         self._menu_callback(id, item)
  54                 self._emptymenu()
  55
  56         def set(self, items):
  57                 self._items = items
  58
  59         def get(self):
  60                 return self._items
  61
  62         def _additems(self, items, menu):
  63                 from FrameWork import SubMenu, MenuItem
  64                 menu_id = menu.id
  65                 for item in items:
  66                         if item == "-":
  67                                 menu.addseparator()
  68                                 continue
  69                         elif type(item) == ListType:
  70                                 submenu = SubMenu(menu, item[0])
  71                                 self._additems(item[1:], submenu)
  72                                 continue
  73                         elif type(item) == StringType:
  74                                 menuitemtext = object = item
  75                         elif type(item) == TupleType and len(item) == 2:
  76                                 menuitemtext, object = item
  77                         else:
  78                                 raise Wbase.WidgetsError, "illegal itemlist for popup menu"
  79
  80                         if menuitemtext[:1] == '\0':
  81                                 check = ord(menuitemtext[1])
  82                                 menuitemtext = menuitemtext[2:]
  83                         else:
  84                                 check = 0
  85                         menuitem = MenuItem(menu, menuitemtext, None, None)
  86                         if check:
  87                                 menuitem.check(1)
  88                         self._itemsdict[(menu_id, menuitem.item)] = object
  89
  90         def _emptymenu(self):
  91                 menus = self._parentwindow.parent.menubar.menus
  92                 for id, item in self._itemsdict.keys():
  93                         if menus.has_key(id):
  94                                 self.menu = menus[id]
  95                                 self.menu.delete()
  96                 self._itemsdict = {}
  97
  98         def _menu_callback(self, id, item):
  99                 thing = self._itemsdict[(id, item)]
 100                 if callable(thing):
 101                         thing()
 102                 elif self._callback:
 103                         Wbase.CallbackCall(self._callback, 0, thing)
 104
 105
 106 class PopupMenu(PopupWidget):
 107
 108         """Simple title-less popup widget. Should be 16x16 pixels.
 109         Prebuilds the menu items, good for static (non changing) popup menus."""
 110
 111         def open(self):
 112                 self._calcbounds()
 113                 self.menu = Wapplication.Menu(self._parentwindow.parent.menubar, 'Foo', -1)
 114                 self._additems(self._items, self.menu)
 115
 116         def close(self):
 117                 self._emptymenu()
 118                 Wbase.Widget.close(self)
 119                 self._items = None
 120                 self._itemsdict = {}
 121                 self.menu = None
 122
 123         def set(self, items):
 124                 if self._itemsdict:
 125                         self._emptymenu()
 126                 self.menu = Wapplication.Menu(self._parentwindow.parent.menubar, 'Foo', -1)
 127                 self._items = items
 128                 self._additems(self._items, self.menu)
 129
 130         def click(self, point, modifiers):
 131                 if not self._enabled:
 132                         return
 133                 self.SetPort()
 134                 l, t, r, b = self._bounds
 135                 l, t = Qd.LocalToGlobal((l+1, t+1))
 136                 Wbase.SetCursor("arrow")
 137                 self.menu.menu.EnableItem(0)
 138                 reply = self.menu.menu.PopUpMenuSelect(t, l, 1)
 139                 if reply:
 140                         id = (reply & 0xffff0000) >> 16
 141                         item = reply & 0xffff
 142                         self._menu_callback(id, item)
 143
 144
 145 class FontMenu(PopupMenu):
 146
 147         """A font popup menu."""
 148
 149         menu = None
 150
 151         def __init__(self, possize, callback):
 152                 PopupMenu.__init__(self, possize)
 153                 _makefontmenu()
 154                 self._callback = callback
 155                 self._enabled = 1
 156
 157         def open(self):
 158                 self._calcbounds()
 159
 160         def close(self):
 161                 del self._callback
 162
 163         def set(self):
 164                 raise Wbase.WidgetsError, "can't change font menu widget"
 165
 166         def _menu_callback(self, id, item):
 167                 fontname = self.menu.menu.GetMenuItemText(item)
 168                 if self._callback:
 169                         Wbase.CallbackCall(self._callback, 0, fontname)
 170
 171         def click(self, point, modifiers):
 172                 if not self._enabled:
 173                         return
 174                 _makefontmenu()
 175                 return PopupMenu.click(self, point, modifiers)
 176
 177
 178 def _makefontmenu():
 179         """helper for font menu"""
 180         if FontMenu.menu is not None:
 181                 return
 182         import W
 183         FontMenu.menu = Wapplication.Menu(W.getapplication().menubar, 'Foo', -1)
 184         W.SetCursor('watch')
 185         for i in range(FontMenu.menu.menu.CountMItems(), 0, -1):
 186                 FontMenu.menu.menu.DeleteMenuItem(i)
 187         FontMenu.menu.menu.AppendResMenu('FOND')
 188
 189
 190 def _getfontlist():
 191         import Res
 192         fontnames = []
 193         for i in range(1, Res.CountResources('FOND') + 1):
 194                 r = Res.GetIndResource('FOND', i)
 195                 fontnames.append(r.GetResInfo()[2])
 196         return fontnames