Mac/Contrib/PyIDE-src/IDELib/Widgets/Wmenus.py

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