Mac/Tools/IDE/Wmenus.py

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