721 lines
18 KiB
Python
721 lines
18 KiB
Python
import Qd
|
|
import Win
|
|
import QuickDraw
|
|
import Evt
|
|
import string
|
|
from types import *
|
|
import sys
|
|
|
|
WidgetsError = "WidgetsError"
|
|
|
|
DEBUG = 0
|
|
|
|
class Widget:
|
|
|
|
"""Base class for all widgets."""
|
|
|
|
_selectable = 0
|
|
|
|
def __init__(self, possize):
|
|
self._widgets = []
|
|
self._widgetsdict = {}
|
|
self._possize = possize
|
|
self._bounds = None
|
|
self._visible = 1
|
|
self._enabled = 0
|
|
self._selected = 0
|
|
self._activated = 0
|
|
self._callback = None
|
|
self._parent = None
|
|
self._parentwindow = None
|
|
self._bindings = {}
|
|
self._backcolor = None
|
|
|
|
def show(self, onoff):
|
|
self._visible = onoff
|
|
for w in self._widgets:
|
|
w.show(onoff)
|
|
if self._parentwindow is not None and self._parentwindow.wid is not None:
|
|
self.SetPort()
|
|
if onoff:
|
|
self.draw()
|
|
else:
|
|
Qd.EraseRect(self._bounds)
|
|
|
|
def draw(self, visRgn = None):
|
|
if self._visible:
|
|
# draw your stuff here
|
|
pass
|
|
|
|
def getpossize(self):
|
|
return self._possize
|
|
|
|
def getbounds(self):
|
|
return self._bounds
|
|
|
|
def move(self, x, y = None):
|
|
"""absolute move"""
|
|
if y == None:
|
|
x, y = x
|
|
if type(self._possize) <> TupleType:
|
|
raise WidgetsError, "can't move widget with bounds function"
|
|
l, t, r, b = self._possize
|
|
self.resize(x, y, r, b)
|
|
|
|
def rmove(self, x, y = None):
|
|
"""relative move"""
|
|
if y == None:
|
|
x, y = x
|
|
if type(self._possize) <> TupleType:
|
|
raise WidgetsError, "can't move widget with bounds function"
|
|
l, t, r, b = self._possize
|
|
self.resize(l + x, t + y, r, b)
|
|
|
|
def resize(self, *args):
|
|
if len(args) == 1:
|
|
if type(args[0]) == FunctionType or type(args[0]) == MethodType:
|
|
self._possize = args[0]
|
|
else:
|
|
apply(self.resize, args[0])
|
|
elif len(args) == 2:
|
|
self._possize = (0, 0) + args
|
|
elif len(args) == 4:
|
|
self._possize = args
|
|
else:
|
|
raise TypeError, "wrong number of arguments"
|
|
self._calcbounds()
|
|
|
|
def open(self):
|
|
self._calcbounds()
|
|
|
|
def close(self):
|
|
del self._callback
|
|
del self._possize
|
|
del self._bindings
|
|
del self._parent
|
|
del self._parentwindow
|
|
|
|
def bind(self, key, callback):
|
|
"""bind a key or an 'event' to a callback"""
|
|
if callback:
|
|
self._bindings[key] = callback
|
|
elif self._bindings.has_key(key):
|
|
del self._bindings[key]
|
|
|
|
def adjust(self, oldbounds):
|
|
self.SetPort()
|
|
Win.InvalRect(oldbounds)
|
|
Win.InvalRect(self._bounds)
|
|
|
|
def _calcbounds(self):
|
|
# calculate absolute bounds relative to the window origin from our
|
|
# abstract _possize attribute, which is either a 4-tuple or a callable object
|
|
oldbounds = self._bounds
|
|
pl, pt, pr, pb = self._parent._bounds
|
|
if callable(self._possize):
|
|
# _possize is callable, let it figure it out by itself: it should return
|
|
# the bounds relative to our parent widget.
|
|
width = pr - pl
|
|
height = pb - pt
|
|
self._bounds = Qd.OffsetRect(self._possize(width, height), pl, pt)
|
|
else:
|
|
# _possize must be a 4-tuple. This is where the algorithm by Peter Kriens and
|
|
# Petr van Blokland kicks in. (*** Parts of this algorithm are applied for
|
|
# patents by Ericsson, Sweden ***)
|
|
l, t, r, b = self._possize
|
|
# depending on the values of l(eft), t(op), r(right) and b(ottom),
|
|
# they mean different things:
|
|
if l < -1:
|
|
# l is less than -1, this mean it measures from the *right* of it's parent
|
|
l = pr + l
|
|
else:
|
|
# l is -1 or greater, this mean it measures from the *left* of it's parent
|
|
l = pl + l
|
|
if t < -1:
|
|
# t is less than -1, this mean it measures from the *bottom* of it's parent
|
|
t = pb + t
|
|
else:
|
|
# t is -1 or greater, this mean it measures from the *top* of it's parent
|
|
t = pt + t
|
|
if r > 1:
|
|
# r is greater than 1, this means r is the *width* of the widget
|
|
r = l + r
|
|
else:
|
|
# r is less than 1, this means it measures from the *right* of it's parent
|
|
r = pr + r
|
|
if b > 1:
|
|
# b is greater than 1, this means b is the *height* of the widget
|
|
b = t + b
|
|
else:
|
|
# b is less than 1, this means it measures from the *bottom* of it's parent
|
|
b = pb + b
|
|
self._bounds = (l, t, r, b)
|
|
if oldbounds and oldbounds <> self._bounds:
|
|
self.adjust(oldbounds)
|
|
for w in self._widgets:
|
|
w._calcbounds()
|
|
|
|
def test(self, point):
|
|
if Qd.PtInRect(point, self._bounds):
|
|
return 1
|
|
|
|
def click(self, point, modifiers):
|
|
pass
|
|
|
|
def findwidget(self, point, onlyenabled = 1):
|
|
if self.test(point):
|
|
for w in self._widgets:
|
|
widget = w.findwidget(point)
|
|
if widget is not None:
|
|
return widget
|
|
if self._enabled or not onlyenabled:
|
|
return self
|
|
|
|
def forall(self, methodname, *args):
|
|
for w in self._widgets:
|
|
rv = apply(w.forall, (methodname,) + args)
|
|
if rv:
|
|
return rv
|
|
if self._bindings.has_key("<" + methodname + ">"):
|
|
callback = self._bindings["<" + methodname + ">"]
|
|
rv = apply(callback, args)
|
|
if rv:
|
|
return rv
|
|
if hasattr(self, methodname):
|
|
method = getattr(self, methodname)
|
|
return apply(method, args)
|
|
|
|
def forall_butself(self, methodname, *args):
|
|
for w in self._widgets:
|
|
rv = apply(w.forall, (methodname,) + args)
|
|
if rv:
|
|
return rv
|
|
|
|
def forall_frombottom(self, methodname, *args):
|
|
if self._bindings.has_key("<" + methodname + ">"):
|
|
callback = self._bindings["<" + methodname + ">"]
|
|
rv = apply(callback, args)
|
|
if rv:
|
|
return rv
|
|
if hasattr(self, methodname):
|
|
method = getattr(self, methodname)
|
|
rv = apply(method, args)
|
|
if rv:
|
|
return rv
|
|
for w in self._widgets:
|
|
rv = apply(w.forall_frombottom, (methodname,) + args)
|
|
if rv:
|
|
return rv
|
|
|
|
def _addwidget(self, key, widget):
|
|
if widget in self._widgets:
|
|
raise ValueError, "duplicate widget"
|
|
if self._widgetsdict.has_key(key):
|
|
self._removewidget(key)
|
|
self._widgets.append(widget)
|
|
self._widgetsdict[key] = widget
|
|
widget._parent = self
|
|
self._setparentwindow(widget)
|
|
if self._parentwindow and self._parentwindow.wid:
|
|
widget.forall_frombottom("open")
|
|
Win.InvalRect(widget._bounds)
|
|
|
|
def _setparentwindow(self, widget):
|
|
widget._parentwindow = self._parentwindow
|
|
for w in widget._widgets:
|
|
self._setparentwindow(w)
|
|
|
|
def _removewidget(self, key):
|
|
if not self._widgetsdict.has_key(key):
|
|
raise KeyError, "no widget with key " + `key`
|
|
widget = self._widgetsdict[key]
|
|
for k in widget._widgetsdict.keys():
|
|
widget._removewidget(k)
|
|
if self._parentwindow._currentwidget == widget:
|
|
widget.select(0)
|
|
self._parentwindow._currentwidget = None
|
|
self.SetPort()
|
|
Win.InvalRect(widget._bounds)
|
|
widget.close()
|
|
del self._widgetsdict[key]
|
|
self._widgets.remove(widget)
|
|
|
|
def __setattr__(self, attr, value):
|
|
if type(value) == InstanceType and isinstance(value, Widget) and \
|
|
attr not in ("_currentwidget", "_lastrollover",
|
|
"_parent", "_parentwindow", "_defaultbutton"):
|
|
if hasattr(self, attr):
|
|
raise ValueError, "Can't replace existing attribute: " + attr
|
|
self._addwidget(attr, value)
|
|
self.__dict__[attr] = value
|
|
|
|
def __delattr__(self, attr):
|
|
if attr == "_widgetsdict":
|
|
raise AttributeError, "cannot delete attribute _widgetsdict"
|
|
if self._widgetsdict.has_key(attr):
|
|
self._removewidget(attr)
|
|
if self.__dict__.has_key(attr):
|
|
del self.__dict__[attr]
|
|
elif self.__dict__.has_key(attr):
|
|
del self.__dict__[attr]
|
|
else:
|
|
raise AttributeError, attr
|
|
|
|
def __setitem__(self, key, value):
|
|
self._addwidget(key, value)
|
|
|
|
def __getitem__(self, key):
|
|
if not self._widgetsdict.has_key(key):
|
|
raise KeyError, key
|
|
return self._widgetsdict[key]
|
|
|
|
def __delitem__(self, key):
|
|
self._removewidget(key)
|
|
|
|
def SetPort(self):
|
|
self._parentwindow.SetPort()
|
|
|
|
def __del__(self):
|
|
if DEBUG:
|
|
print "%s instance deleted" % self.__class__.__name__
|
|
|
|
def _drawbounds(self):
|
|
Qd.FrameRect(self._bounds)
|
|
|
|
|
|
class ClickableWidget(Widget):
|
|
|
|
"""Base class for clickable widgets. (note: self._enabled must be true to receive click events.)"""
|
|
|
|
def click(self, point, modifiers):
|
|
pass
|
|
|
|
def enable(self, onoff):
|
|
self._enabled = onoff
|
|
self.SetPort()
|
|
self.draw()
|
|
|
|
def callback(self):
|
|
if self._callback:
|
|
return CallbackCall(self._callback, 1)
|
|
|
|
|
|
class SelectableWidget(ClickableWidget):
|
|
|
|
"""Base class for selectable widgets."""
|
|
|
|
_selectable = 1
|
|
|
|
def select(self, onoff, isclick = 0):
|
|
if onoff == self._selected:
|
|
return 1
|
|
if self._bindings.has_key("<select>"):
|
|
callback = self._bindings["<select>"]
|
|
if callback(onoff):
|
|
return 1
|
|
self._selected = onoff
|
|
if onoff:
|
|
if self._parentwindow._currentwidget is not None:
|
|
self._parentwindow._currentwidget.select(0)
|
|
self._parentwindow._currentwidget = self
|
|
else:
|
|
self._parentwindow._currentwidget = None
|
|
|
|
def key(self, char, event):
|
|
pass
|
|
|
|
def drawselframe(self, onoff):
|
|
if not self._parentwindow._hasselframes:
|
|
return
|
|
thickrect = Qd.InsetRect(self._bounds, -3, -3)
|
|
state = Qd.GetPenState()
|
|
Qd.PenSize(2, 2)
|
|
if onoff:
|
|
Qd.PenPat(Qd.qd.black)
|
|
else:
|
|
Qd.PenPat(Qd.qd.white)
|
|
Qd.FrameRect(thickrect)
|
|
Qd.SetPenState(state)
|
|
|
|
def adjust(self, oldbounds):
|
|
self.SetPort()
|
|
if self._selected:
|
|
Win.InvalRect(Qd.InsetRect(oldbounds, -3, -3))
|
|
Win.InvalRect(Qd.InsetRect(self._bounds, -3, -3))
|
|
else:
|
|
Win.InvalRect(oldbounds)
|
|
Win.InvalRect(self._bounds)
|
|
|
|
|
|
class _Line(Widget):
|
|
|
|
def __init__(self, possize, thickness = 1):
|
|
Widget.__init__(self, possize)
|
|
self._thickness = thickness
|
|
|
|
def open(self):
|
|
self._calcbounds()
|
|
self.SetPort()
|
|
self.draw()
|
|
|
|
def draw(self, visRgn = None):
|
|
if self._visible:
|
|
Qd.PaintRect(self._bounds)
|
|
|
|
def _drawbounds(self):
|
|
pass
|
|
|
|
class HorizontalLine(_Line):
|
|
|
|
def _calcbounds(self):
|
|
Widget._calcbounds(self)
|
|
l, t, r, b = self._bounds
|
|
self._bounds = l, t, r, t + self._thickness
|
|
|
|
class VerticalLine(_Line):
|
|
|
|
def _calcbounds(self):
|
|
Widget._calcbounds(self)
|
|
l, t, r, b = self._bounds
|
|
self._bounds = l, t, l + self._thickness, b
|
|
|
|
|
|
class Frame(Widget):
|
|
|
|
def __init__(self, possize, pattern = Qd.qd.black, color = (0, 0, 0)):
|
|
Widget.__init__(self, possize)
|
|
self._framepattern = pattern
|
|
self._framecolor = color
|
|
|
|
def setcolor(self, color):
|
|
self._framecolor = color
|
|
self.SetPort()
|
|
self.draw()
|
|
|
|
def setpattern(self, pattern):
|
|
self._framepattern = pattern
|
|
self.SetPort()
|
|
self.draw()
|
|
|
|
def draw(self, visRgn = None):
|
|
if self._visible:
|
|
penstate = Qd.GetPenState()
|
|
Qd.PenPat(self._framepattern)
|
|
Qd.RGBForeColor(self._framecolor)
|
|
Qd.FrameRect(self._bounds)
|
|
Qd.RGBForeColor((0, 0, 0))
|
|
Qd.SetPenState(penstate)
|
|
|
|
def _darkencolor((r, g, b)):
|
|
return 0.75 * r, 0.75 * g, 0.75 * b
|
|
|
|
class BevelBox(Widget):
|
|
|
|
"""'Platinum' beveled rectangle."""
|
|
|
|
def __init__(self, possize, color = (0xe000, 0xe000, 0xe000)):
|
|
Widget.__init__(self, possize)
|
|
self._color = color
|
|
self._darkercolor = _darkencolor(color)
|
|
|
|
def setcolor(self, color):
|
|
self._color = color
|
|
self.SetPort()
|
|
self.draw()
|
|
|
|
def draw(self, visRgn = None):
|
|
if self._visible:
|
|
l, t, r, b = Qd.InsetRect(self._bounds, 1, 1)
|
|
Qd.RGBForeColor(self._color)
|
|
Qd.PaintRect((l, t, r, b))
|
|
Qd.RGBForeColor(self._darkercolor)
|
|
Qd.MoveTo(l, b)
|
|
Qd.LineTo(r, b)
|
|
Qd.LineTo(r, t)
|
|
Qd.RGBForeColor((0, 0, 0))
|
|
|
|
|
|
class Group(Widget):
|
|
|
|
"""A container for subwidgets"""
|
|
|
|
|
|
class HorizontalPanes(Widget):
|
|
|
|
"""Panes, a.k.a. frames. Works a bit like a group. Devides the widget area into "panes",
|
|
which can be resized by the user by clicking and dragging between the subwidgets."""
|
|
|
|
_direction = 1
|
|
|
|
def __init__(self, possize, panesizes = None, gutter = 8):
|
|
"""panesizes should be a tuple of numbers. The length of the tuple is the number of panes,
|
|
the items in the tuple are the relative sizes of these panes; these numbers should add up
|
|
to 1 (the total size of all panes)."""
|
|
ClickableWidget.__init__(self, possize)
|
|
self._panesizes = panesizes
|
|
self._gutter = gutter
|
|
self._enabled = 1
|
|
self.setuppanes()
|
|
|
|
#def open(self):
|
|
# self.installbounds()
|
|
# ClickableWidget.open(self)
|
|
|
|
def _calcbounds(self):
|
|
# hmmm. It should not neccesary be override _calcbounds :-(
|
|
self.installbounds()
|
|
Widget._calcbounds(self)
|
|
|
|
def setuppanes(self):
|
|
panesizes = self._panesizes
|
|
total = 0
|
|
if panesizes is not None:
|
|
#if len(self._widgets) <> len(panesizes):
|
|
# raise TypeError, 'number of widgets does not match number of panes'
|
|
for panesize in panesizes:
|
|
if not 0 < panesize < 1:
|
|
raise TypeError, 'pane sizes must be between 0 and 1, not including.'
|
|
total = total + panesize
|
|
if round(total, 4) <> 1.0:
|
|
raise TypeError, 'pane sizes must add up to 1'
|
|
else:
|
|
# XXX does not work!
|
|
step = 1.0 / len(self._widgets)
|
|
panesizes = []
|
|
for i in range(len(self._widgets)):
|
|
panesizes.append(step)
|
|
current = 0
|
|
self._panesizes = []
|
|
self._gutters = []
|
|
for panesize in panesizes:
|
|
if current:
|
|
self._gutters.append(current)
|
|
self._panesizes.append((current, current + panesize))
|
|
current = current + panesize
|
|
self.makepanebounds()
|
|
|
|
def getpanesizes(self):
|
|
return map(lambda (fr, to): to-fr, self._panesizes)
|
|
|
|
boundstemplate = "lambda width, height: (0, height * %s + %d, width, height * %s + %d)"
|
|
|
|
def makepanebounds(self):
|
|
halfgutter = self._gutter / 2
|
|
self._panebounds = []
|
|
for i in range(len(self._panesizes)):
|
|
panestart, paneend = self._panesizes[i]
|
|
boundsstring = self.boundstemplate % (`panestart`, panestart and halfgutter,
|
|
`paneend`, (paneend <> 1.0) and -halfgutter)
|
|
self._panebounds.append(eval(boundsstring))
|
|
|
|
def installbounds(self):
|
|
#self.setuppanes()
|
|
for i in range(len(self._widgets)):
|
|
w = self._widgets[i]
|
|
w._possize = self._panebounds[i]
|
|
#if hasattr(w, "setuppanes"):
|
|
# w.setuppanes()
|
|
if hasattr(w, "installbounds"):
|
|
w.installbounds()
|
|
|
|
def rollover(self, point, onoff):
|
|
if onoff:
|
|
orgmouse = point[self._direction]
|
|
halfgutter = self._gutter / 2
|
|
l, t, r, b = self._bounds
|
|
if self._direction:
|
|
begin, end = t, b
|
|
else:
|
|
begin, end = l, r
|
|
|
|
i = self.findgutter(orgmouse, begin, end)
|
|
if i is None:
|
|
SetCursor("arrow")
|
|
else:
|
|
SetCursor(self._direction and 'vmover' or 'hmover')
|
|
|
|
def findgutter(self, orgmouse, begin, end):
|
|
tolerance = max(4, self._gutter) / 2
|
|
for i in range(len(self._gutters)):
|
|
pos = begin + (end - begin) * self._gutters[i]
|
|
if abs(orgmouse - pos) <= tolerance:
|
|
break
|
|
else:
|
|
return
|
|
return i
|
|
|
|
def click(self, point, modifiers):
|
|
# what a mess...
|
|
orgmouse = point[self._direction]
|
|
halfgutter = self._gutter / 2
|
|
l, t, r, b = self._bounds
|
|
if self._direction:
|
|
begin, end = t, b
|
|
else:
|
|
begin, end = l, r
|
|
|
|
i = self.findgutter(orgmouse, begin, end)
|
|
if i is None:
|
|
return
|
|
|
|
pos = orgpos = begin + (end - begin) * self._gutters[i] # init pos too, for fast click on border, bug done by Petr
|
|
|
|
minpos = self._panesizes[i][0]
|
|
maxpos = self._panesizes[i+1][1]
|
|
minpos = begin + (end - begin) * minpos + 64
|
|
maxpos = begin + (end - begin) * maxpos - 64
|
|
if minpos > orgpos and maxpos < orgpos:
|
|
return
|
|
|
|
#SetCursor("fist")
|
|
self.SetPort()
|
|
if self._direction:
|
|
rect = l, orgpos - 1, r, orgpos
|
|
else:
|
|
rect = orgpos - 1, t, orgpos, b
|
|
|
|
# track mouse --- XXX move to separate method?
|
|
Qd.PenMode(QuickDraw.srcXor)
|
|
Qd.PenPat(Qd.qd.gray)
|
|
Qd.PaintRect(rect)
|
|
lastpos = None
|
|
while Evt.Button():
|
|
pos = orgpos - orgmouse + Evt.GetMouse()[self._direction]
|
|
pos = max(pos, minpos)
|
|
pos = min(pos, maxpos)
|
|
if pos == lastpos:
|
|
continue
|
|
Qd.PenPat(Qd.qd.gray)
|
|
Qd.PaintRect(rect)
|
|
if self._direction:
|
|
rect = l, pos - 1, r, pos
|
|
else:
|
|
rect = pos - 1, t, pos, b
|
|
Qd.PenPat(Qd.qd.gray)
|
|
Qd.PaintRect(rect)
|
|
lastpos = pos
|
|
Qd.PaintRect(rect)
|
|
Qd.PenNormal()
|
|
SetCursor("watch")
|
|
|
|
newpos = (pos - begin) / float(end - begin)
|
|
self._gutters[i] = newpos
|
|
self._panesizes[i] = self._panesizes[i][0], newpos
|
|
self._panesizes[i+1] = newpos, self._panesizes[i+1][1]
|
|
self.makepanebounds()
|
|
self.installbounds()
|
|
self._calcbounds()
|
|
|
|
|
|
class VerticalPanes(HorizontalPanes):
|
|
"""see HorizontalPanes"""
|
|
_direction = 0
|
|
boundstemplate = "lambda width, height: (width * %s + %d, 0, width * %s + %d, height)"
|
|
|
|
|
|
class ColorPicker(ClickableWidget):
|
|
|
|
"""Color picker widget. Allows the user to choose a color."""
|
|
|
|
def __init__(self, possize, color = (0, 0, 0), callback = None):
|
|
ClickableWidget.__init__(self, possize)
|
|
self._color = color
|
|
self._callback = callback
|
|
self._enabled = 1
|
|
|
|
def click(self, point, modifiers):
|
|
if not self._enabled:
|
|
return
|
|
import ColorPicker
|
|
newcolor, ok = ColorPicker.GetColor("", self._color)
|
|
if ok:
|
|
self._color = newcolor
|
|
self.SetPort()
|
|
self.draw()
|
|
if self._callback:
|
|
return CallbackCall(self._callback, 0, self._color)
|
|
|
|
def set(self, color):
|
|
self._color = color
|
|
self.SetPort()
|
|
self.draw()
|
|
|
|
def get(self):
|
|
return self._color
|
|
|
|
def draw(self, visRgn=None):
|
|
if self._visible:
|
|
if not visRgn:
|
|
visRgn = self._parentwindow.wid.GetWindowPort().visRgn
|
|
Qd.PenPat(Qd.qd.gray)
|
|
rect = self._bounds
|
|
Qd.FrameRect(rect)
|
|
rect = Qd.InsetRect(rect, 3, 3)
|
|
Qd.PenNormal()
|
|
Qd.RGBForeColor(self._color)
|
|
Qd.PaintRect(rect)
|
|
Qd.RGBForeColor((0, 0, 0))
|
|
|
|
|
|
# misc utils
|
|
|
|
def CallbackCall(callback, mustfit, *args):
|
|
"""internal helper routine for W"""
|
|
# XXX this function should die.
|
|
if type(callback) == FunctionType:
|
|
func = callback
|
|
maxargs = func.func_code.co_argcount
|
|
elif type(callback) == MethodType:
|
|
func = callback.im_func
|
|
maxargs = func.func_code.co_argcount - 1
|
|
else:
|
|
if callable(callback):
|
|
return apply(callback, args)
|
|
else:
|
|
raise TypeError, "uncallable callback object"
|
|
|
|
if func.func_defaults:
|
|
minargs = maxargs - len(func.func_defaults)
|
|
else:
|
|
minargs = maxargs
|
|
if minargs <= len(args) <= maxargs:
|
|
return apply(callback, args)
|
|
elif not mustfit and minargs == 0:
|
|
return callback()
|
|
else:
|
|
if mustfit:
|
|
raise TypeError, "callback accepts wrong number of arguments: " + `len(args)`
|
|
else:
|
|
raise TypeError, "callback accepts wrong number of arguments: 0 or " + `len(args)`
|
|
|
|
|
|
def HasBaseClass(obj, class_):
|
|
try:
|
|
raise obj
|
|
except class_:
|
|
return 1
|
|
except:
|
|
pass
|
|
return 0
|
|
|
|
|
|
_cursors = {
|
|
"watch" : Qd.GetCursor(QuickDraw.watchCursor).data,
|
|
"arrow" : Qd.qd.arrow,
|
|
"iBeam" : Qd.GetCursor(QuickDraw.iBeamCursor).data,
|
|
"cross" : Qd.GetCursor(QuickDraw.crossCursor).data,
|
|
"plus" : Qd.GetCursor(QuickDraw.plusCursor).data,
|
|
"hand" : Qd.GetCursor(468).data,
|
|
"fist" : Qd.GetCursor(469).data,
|
|
"hmover" : Qd.GetCursor(470).data,
|
|
"vmover" : Qd.GetCursor(471).data,
|
|
"zoomin" : Qd.GetCursor(472).data,
|
|
"zoomout" : Qd.GetCursor(473).data,
|
|
"zoom" : Qd.GetCursor(474).data,
|
|
}
|
|
|
|
def SetCursor(what):
|
|
"""Set the cursorshape to any of these: 'arrow', 'cross', 'fist', 'hand', 'hmover', 'iBeam',
|
|
'plus', 'vmover', 'watch', 'zoom', 'zoomin', 'zoomout'."""
|
|
Qd.SetCursor(_cursors[what])
|