Mac/Tools/IDE/Wcontrols.py

   1 from Carbon import Ctl, Controls
   2 from Carbon import Evt, Qd, Win
   3 import Wbase
   4
   5
   6 class ControlWidget(Wbase.ClickableWidget):
   7
   8         """Baseclass for all native controls."""
   9
  10         def __init__(self, possize, title = "Control", procID = 0, callback = None, value = 0, min = 0, max = 1, viewsize = 0):
  11                 Wbase.ClickableWidget.__init__(self, possize)
  12                 self._control = None
  13                 self._title = title
  14                 self._callback = callback
  15                 self._procID = procID
  16                 self._value = value
  17                 self._min = min
  18                 self._max = max
  19                 self._enabled = 1
  20                 self._viewsize = viewsize
  21
  22         def open(self):
  23                 self._calcbounds()
  24
  25                 # NewControl doesn't accept 32-bit value, min, or max, so for consistency
  26                 # with the new 32-bit set/get methods, out-of-range values are initially
  27                 # set as zero, followed by a 32-bit set of the actual value.
  28                 # Values not representable in 16 bits will fail on MacOS 8.1, however
  29                 # the vast majority of control usage should still be compatible.
  30                 _value, _min, _max = self._value, self._min, self._max
  31                 if -32768 <= _value <= 32767:
  32                         bigvalue = None
  33                 else:
  34                         bigvalue = _value
  35                         _value = 0
  36                 if -32768 <= _min <= 32767:
  37                         bigmin = None
  38                 else:
  39                         bigmin = _min
  40                         _min = 0
  41                 if -32768 <= _max <= 32767:
  42                         bigmax = None
  43                 else:
  44                         bigmax = _max
  45                         _max = 0
  46                 self._control = Ctl.NewControl(self._parentwindow.wid,
  47                                                 self._bounds,
  48                                                 self._title,
  49                                                 1,
  50                                                 _value,
  51                                                 _min,
  52                                                 _max,
  53                                                 self._procID,
  54                                                 0)
  55                 if bigvalue:
  56                         self._control.SetControl32BitValue(bigvalue)
  57                 if bigmin:
  58                         self._control.SetControl32BitMinimum(bigmin)
  59                 if bigmax:
  60                         self._control.SetControl32BitMaximum(bigmax)
  61                 if self._viewsize:
  62                         try:
  63                                 self._control.SetControlViewSize(self._viewsize)
  64                                 # Not available in MacOS 8.1, but that's OK since it only affects
  65                                 # proportional scrollbars which weren't available in 8.1 either.
  66                         except NotImplementedError:
  67                                 pass
  68                 self.enable(self._enabled)
  69
  70         def adjust(self, oldbounds):
  71                 self.SetPort()
  72                 self._control.HideControl()
  73                 self._control.MoveControl(self._bounds[0], self._bounds[1])
  74                 self._control.SizeControl(self._bounds[2] - self._bounds[0], self._bounds[3] - self._bounds[1])
  75                 if self._visible:
  76                         Qd.EraseRect(self._bounds)
  77                         self._control.ShowControl()
  78                         self.GetWindow().ValidWindowRect(self._bounds)
  79
  80         def close(self):
  81                 self._control.HideControl()
  82                 self._control = None
  83                 Wbase.ClickableWidget.close(self)
  84
  85         def enable(self, onoff):
  86                 if self._control and self._enabled <> onoff:
  87                         self._control.HiliteControl((not onoff) and 255)
  88                         self._enabled = onoff
  89
  90         def show(self, onoff):
  91                 self._visible = onoff
  92                 for w in self._widgets:
  93                         w.show(onoff)
  94                 if onoff:
  95                         self._control.ShowControl()
  96                 else:
  97                         self._control.HideControl()
  98
  99         def activate(self, onoff):
 100                 self._activated = onoff
 101                 if self._enabled:
 102                         if onoff:
 103                                 self._control.ActivateControl()
 104                         else:
 105                                 self._control.DeactivateControl()
 106
 107         def draw(self, visRgn = None):
 108                 if self._visible:
 109                         self._control.Draw1Control()
 110
 111         def test(self, point):
 112                 if Qd.PtInRect(point, self._bounds) and self._enabled:
 113                         return 1
 114                 #ctltype, control = Ctl.FindControl(point, self._parentwindow.wid)
 115                 #if self._enabled and control == self._control:
 116                 #       return 1
 117
 118         def click(self, point, modifiers):
 119                 if not self._enabled:
 120                         return
 121                 part = self._control.TrackControl(point)
 122                 if part:
 123                         if self._callback:
 124                                 Wbase.CallbackCall(self._callback, 0)
 125
 126         def settitle(self, title):
 127                 if self._control:
 128                         self._control.SetControlTitle(title)
 129                 self._title = title
 130
 131         def gettitle(self):
 132                 return self._title
 133
 134         def set(self, value):
 135                 if self._control:
 136                         if -32768 <= value <= 32767:
 137                                 # No 32-bit control support in MacOS 8.1, so use
 138                                 # the 16-bit interface when possible.
 139                                 self._control.SetControlValue(value)
 140                         else:
 141                                 self._control.SetControl32BitValue(value)
 142                 else:
 143                         self._value = value
 144
 145         def get(self):
 146                 if self._control:
 147                         try:
 148                                 return self._control.GetControl32BitValue()
 149                                 # No 32-bit control support in MacOS 8.1, so fall
 150                                 # back to the 16-bit interface when needed.
 151                         except NotImplementedError:
 152                                 return self._control.GetControlValue()
 153                 else:
 154                         return self._value
 155
 156
 157 class Button(ControlWidget):
 158
 159         """Standard push button."""
 160
 161         procID = Controls.pushButProc | Controls.useWFont
 162
 163         def __init__(self, possize, title = "Button", callback = None):
 164                 ControlWidget.__init__(self, possize, title, self.procID, callback, 0, 0, 1)
 165                 self._isdefault = 0
 166
 167         def push(self):
 168                 if not self._enabled:
 169                         return
 170                 # emulate the pushing of the button
 171                 import time
 172                 self._control.HiliteControl(Controls.kControlButtonPart)
 173                 Qd.QDFlushPortBuffer(self._parentwindow.wid, None)  # needed under OSX
 174                 time.sleep(0.1)
 175                 self._control.HiliteControl(0)
 176                 if self._callback:
 177                         Wbase.CallbackCall(self._callback, 0)
 178
 179         def enable(self, onoff):
 180                 if self._control and self._enabled <> onoff:
 181                         self._control.HiliteControl((not onoff) and 255)
 182                         self._enabled = onoff
 183
 184         def show(self, onoff):
 185                 ControlWidget.show(self, onoff)
 186
 187         def draw(self, visRgn = None):
 188                 if self._visible:
 189                         self._control.Draw1Control()
 190
 191         def open(self):
 192                 ControlWidget.open(self)
 193                 if self._isdefault:
 194                         self._setdefault(self._isdefault)
 195
 196         def _setdefault(self, onoff):
 197                 c = self._control
 198                 if c is not None:
 199                         if onoff:
 200                                 data = "\xFF"
 201                         else:
 202                                 data = "\0"
 203                         # hide before changing state, otherwise the button isn't always
 204                         # redrawn correctly, although it's quite different under Aqua
 205                         # and Classic...
 206                         c.HideControl()
 207                         c.SetControlData(Controls.kControlNoPart,
 208                                         Controls.kControlPushButtonDefaultTag, data)
 209                         c.ShowControl()
 210                 self._isdefault = onoff
 211
 212         def adjust(self, oldbounds):
 213                 if self._isdefault:
 214                         old = Qd.InsetRect(oldbounds, -4, -4)
 215                         new = Qd.InsetRect(self._bounds, -4, -4)
 216                         Qd.EraseRect(old)
 217                         self.GetWindow().InvalWindowRect(old)
 218                         self.GetWindow().InvalWindowRect(new)
 219                 ControlWidget.adjust(self, oldbounds)
 220
 221
 222 class BevelButton(Button):
 223         procID = Controls.kControlBevelButtonNormalBevelProc | Controls.useWFont
 224
 225
 226 class CheckBox(ControlWidget):
 227
 228         """Standard checkbox."""
 229
 230         def __init__(self, possize, title = "Checkbox", callback = None, value = 0):
 231                 procID = Controls.checkBoxProc | Controls.useWFont
 232                 ControlWidget.__init__(self, possize, title, procID, callback, value, 0, 1)
 233
 234         def click(self, point, modifiers):
 235                 if not self._enabled:
 236                         return
 237                 part = self._control.TrackControl(point)
 238                 if part:
 239                         self.toggle()
 240                         if self._callback:
 241                                 Wbase.CallbackCall(self._callback, 0, self.get())
 242
 243         def push(self):
 244                 if not self._enabled:
 245                         return
 246                 self.toggle()
 247                 if self._callback:
 248                         Wbase.CallbackCall(self._callback, 0, self.get())
 249
 250         def toggle(self):
 251                 self.set(not self.get())
 252
 253
 254 class RadioButton(ControlWidget):
 255
 256         """Standard radiobutton."""
 257
 258         # XXX We need a radiogroup widget; this is too kludgy.
 259
 260         def __init__(self, possize, title, thebuttons, callback = None, value = 0):
 261                 procID = Controls.radioButProc | Controls.useWFont
 262                 ControlWidget.__init__(self, possize, title, procID, callback, value, 0, 1)
 263                 self.thebuttons = thebuttons
 264                 thebuttons.append(self)
 265
 266         def close(self):
 267                 self.thebuttons = None
 268                 ControlWidget.close(self)
 269
 270         def click(self, point, modifiers):
 271                 if not self._enabled:
 272                         return
 273                 part = self._control.TrackControl(point)
 274                 if part:
 275                         self.set(1)
 276                         if self._callback:
 277                                 Wbase.CallbackCall(self._callback, 0, 1)
 278
 279         def push(self):
 280                 if not self._enabled:
 281                         return
 282                 self.set(1)
 283                 if self._callback:
 284                         Wbase.CallbackCall(self._callback, 0, 1)
 285
 286         def set(self, value):
 287                 for button in self.thebuttons:
 288                         if button._control:
 289                                 button._control.SetControlValue(button == self)
 290                         else:
 291                                 button._value = (button == self)
 292
 293
 294 class Scrollbar(ControlWidget):
 295
 296         """Standard scrollbar."""
 297
 298         def __init__(self, possize, callback=None, value=0, min=0, max=0, livefeedback=1):
 299                 if livefeedback:
 300                         procID = Controls.kControlScrollBarLiveProc
 301                 else:
 302                         procID = Controls.scrollBarProc
 303                 ControlWidget.__init__(self, possize, "", procID, callback, value, min, max)
 304
 305         # interface
 306 #       def set(self, value):
 307 #               if self._callback:
 308 #                       Wbase.CallbackCall(self._callback, 1, value)
 309
 310         def up(self):
 311                 if self._callback:
 312                         Wbase.CallbackCall(self._callback, 1, '+')
 313
 314         def down(self):
 315                 if self._callback:
 316                         Wbase.CallbackCall(self._callback, 1, '-')
 317
 318         def pageup(self):
 319                 if self._callback:
 320                         Wbase.CallbackCall(self._callback, 1, '++')
 321
 322         def pagedown(self):
 323                 if self._callback:
 324                         Wbase.CallbackCall(self._callback, 1, '--')
 325
 326         def setmin(self, min):
 327                 if self._control is not None:
 328                         if -32768 <= min <= 32767:
 329                                 # No 32-bit control support in MacOS 8.1, so use
 330                                 # the 16-bit interface when possible.
 331                                 self._control.SetControlMinimum(min)
 332                         else:
 333                                 self._control.SetControl32BitMinimum(min)
 334                 else:
 335                         self._min = min
 336
 337         def setmax(self, max):
 338                 if self._control is not None:
 339                         if -32768 <= max <= 32767:
 340                                 # No 32-bit control support in MacOS 8.1, so use
 341                                 # the 16-bit interface when possible.
 342                                 self._control.SetControlMaximum(max)
 343                         else:
 344                                 self._control.SetControl32BitMaximum(max)
 345                 else:
 346                         self._max = max
 347
 348         def setviewsize(self, viewsize):
 349                 if self._control is not None:
 350                         try:
 351                                 self._control.SetControlViewSize(viewsize)
 352                                 # Not available in MacOS 8.1, but that's OK since it only affects
 353                                 # proportional scrollbars which weren't available in 8.1 either.
 354                         except NotImplementedError:
 355                                 pass
 356                 else:
 357                         self._viewsize = viewsize
 358
 359         def getmin(self):
 360                 try:
 361                         return self._control.GetControl32BitMinimum()
 362                         # No 32-bit control support in MacOS 8.1, so fall
 363                         # back to the 16-bit interface when needed.
 364                 except NotImplementedError:
 365                         return self._control.GetControlMinimum()
 366
 367         def getmax(self):
 368                 try:
 369                         return self._control.GetControl32BitMaximum()
 370                         # No 32-bit control support in MacOS 8.1, so fall
 371                         # back to the 16-bit interface when needed.
 372                 except NotImplementedError:
 373                         return self._control.GetControlMaximum()
 374
 375         # internals
 376         def click(self, point, modifiers):
 377                 if not self._enabled:
 378                         return
 379                 def hitter(ctl, part, self=self):
 380                         if part:
 381                                 self._hit(part)
 382                 part = self._control.TrackControl(point, hitter)
 383                 if part:
 384                         self._hit(part)
 385
 386         def _hit(self, part):
 387                 value = None
 388                 if part == Controls.inThumb:
 389                         try:
 390                                 value = self._control.GetControl32BitValue()
 391                                 # No 32-bit control support in MacOS 8.1, so fall
 392                                 # back to the 16-bit interface when needed.
 393                         except NotImplementedError:
 394                                 value = self._control.GetControlValue()
 395                 elif part == Controls.inUpButton:
 396                         value = "+"
 397                 elif part == Controls.inDownButton:
 398                         value = "-"
 399                 elif part == Controls.inPageUp:
 400                         value = "++"
 401                 elif part == Controls.inPageDown:
 402                         value = "--"
 403                 if value is not None and self._callback:
 404                         Wbase.CallbackCall(self._callback, 1, value)
 405
 406         def draw(self, visRgn = None):
 407                 if self._visible:
 408                         self._control.Draw1Control()
 409                         #Qd.FrameRect(self._bounds)
 410
 411         def adjust(self, oldbounds):
 412                 self.SetPort()
 413                 self.GetWindow().InvalWindowRect(oldbounds)
 414                 self._control.HideControl()
 415                 self._control.MoveControl(self._bounds[0], self._bounds[1])
 416                 self._control.SizeControl(self._bounds[2] - self._bounds[0], self._bounds[3] - self._bounds[1])
 417                 if self._visible:
 418                         Qd.EraseRect(self._bounds)
 419                         if self._activated:
 420                                 self._control.ShowControl()
 421                         else:
 422                                 Qd.FrameRect(self._bounds)
 423                         self.GetWindow().ValidWindowRect(self._bounds)
 424
 425
 426 def _scalebarvalue(absmin, absmax, curmin, curmax):
 427         if curmin <= absmin and curmax >= absmax:
 428                 return None
 429         if curmin <= absmin:
 430                 return 0
 431         if curmax >= absmax:
 432                 return 32767
 433         perc = float(curmin-absmin) / float((absmax - absmin) - (curmax - curmin))
 434         return int(perc*32767)
 435