Mac/Tools/IDE/Wmenus.py

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