path: root/Mac/Tools/IDE/Wbase.py

from Carbon import App, Evt, Qd, QuickDraw, Win
import string
from types import *
import sys

class WidgetsError(Exception): pass

DEBUG = 0


def _intRect((l, t, r, b)):
    return (int(l), int(t), int(r), int(b))


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()
        self.GetWindow().InvalWindowRect(oldbounds)
        self.GetWindow().InvalWindowRect(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(_intRect(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")
            self.GetWindow().InvalWindowRect(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 %r" % (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()
        self.GetWindow().InvalWindowRect(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 GetWindow(self):
        return self._parentwindow.GetWindow()

    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
        App.DrawThemeFocusRect(self._bounds, onoff)

    def adjust(self, oldbounds):
        self.SetPort()
        if self._selected:
            self.GetWindow().InvalWindowRect(Qd.InsetRect(oldbounds, -3, -3))
            self.GetWindow().InvalWindowRect(Qd.InsetRect(self._bounds, -3, -3))
        else:
            self.GetWindow().InvalWindowRect(oldbounds)
            self.GetWindow().InvalWindowRect(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.GetQDGlobalsBlack(), 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 int(0.75 * r), int(0.75 * g), int(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)."""
        Widget.__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 % (repr(panestart), panestart and halfgutter,
                                            repr(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.GetQDGlobalsGray())
        Qd.PaintRect(_intRect(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.GetQDGlobalsGray())
            Qd.PaintRect(_intRect(rect))
            if self._direction:
                rect = l, pos - 1, r, pos
            else:
                rect = pos - 1, t, pos, b
            Qd.PenPat(Qd.GetQDGlobalsGray())
            Qd.PaintRect(_intRect(rect))
            lastpos = pos
            self._parentwindow.wid.GetWindowPort().QDFlushPortBuffer(None)
            Evt.WaitNextEvent(0, 3)
        Qd.PaintRect(_intRect(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.GetQDGlobalsGray())
            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: %r" % len(args)
        else:
            raise TypeError, "callback accepts wrong number of arguments: 0 or %r" % len(args)


def HasBaseClass(obj, class_):
    try:
        raise obj
    except class_:
        return 1
    except:
        pass
    return 0


#
# To remove the dependence of Widgets.rsrc we hardcode the cursor
# data below.
#_cursors = {
#       "watch" : Qd.GetCursor(QuickDraw.watchCursor).data,
#       "arrow" : Qd.GetQDGlobalsArrow(),
#       "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,
#}

_cursors = {
        'arrow':
        '\x00\x00\x40\x00\x60\x00\x70\x00\x78\x00\x7c\x00\x7e\x00\x7f\x00'
        '\x7f\x80\x7c\x00\x6c\x00\x46\x00\x06\x00\x03\x00\x03\x00\x00\x00'
        '\xc0\x00\xe0\x00\xf0\x00\xf8\x00\xfc\x00\xfe\x00\xff\x00\xff\x80'
        '\xff\xc0\xff\xe0\xfe\x00\xef\x00\xcf\x00\x87\x80\x07\x80\x03\x80'
        '\x00\x01\x00\x01',
        'cross':
        '\x04\x00\x04\x00\x04\x00\x04\x00\x04\x00\xff\xe0\x04\x00\x04\x00'
        '\x04\x00\x04\x00\x04\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00'
        '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
        '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
        '\x00\x05\x00\x05',
        'fist':
        '\x00\x00\x00\x00\x0d\x80\x12\x70\x12\x4c\x12\x4a\x28\x0a\x28\x02'
        '\x48\x02\x40\x02\x20\x02\x20\x04\x10\x04\x08\x08\x04\x08\x04\x08'
        '\x00\x00\x00\x00\x0d\x80\x1f\xf0\x1f\xfc\x1f\xfe\x3f\xfe\x3f\xfe'
        '\x7f\xfe\x7f\xfe\x3f\xfe\x3f\xfc\x1f\xfc\x0f\xf8\x07\xf8\x07\xf8'
        '\x00\x09\x00\x08',
        'hand':
        '\x01\x80\x1a\x70\x26\x48\x26\x4a\x12\x4d\x12\x49\x68\x09\x98\x01'
        '\x88\x02\x40\x02\x20\x02\x20\x04\x10\x04\x08\x08\x04\x08\x04\x08'
        '\x01\x80\x1b\xf0\x3f\xf8\x3f\xfa\x1f\xff\x1f\xff\x6f\xff\xff\xff'
        '\xff\xfe\x7f\xfe\x3f\xfe\x3f\xfc\x1f\xfc\x0f\xf8\x07\xf8\x07\xf8'
        '\x00\x09\x00\x08',
        'hmover':
        '\x00\x00\x01\x80\x01\x80\x01\x80\x01\x80\x11\x88\x31\x8c\x7f\xfe'
        '\x31\x8c\x11\x88\x01\x80\x01\x80\x01\x80\x01\x80\x00\x00\x00\x00'
        '\x03\xc0\x03\xc0\x03\xc0\x03\xc0\x1b\xd8\x3b\xdc\x7f\xfe\xff\xff'
        '\x7f\xfe\x3b\xdc\x1b\xd8\x03\xc0\x03\xc0\x03\xc0\x03\xc0\x00\x00'
        '\x00\x07\x00\x07',
        'iBeam':
        '\x0c\x60\x02\x80\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00'
        '\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x02\x80\x0c\x60'
        '\x0c\x60\x02\x80\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00'
        '\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x02\x80\x0c\x60'
        '\x00\x04\x00\x07',
        'plus':
        '\x00\x00\x07\xc0\x04\x60\x04\x60\x04\x60\x7c\x7c\x43\x86\x42\x86'
        '\x43\x86\x7c\x7e\x3c\x7e\x04\x60\x04\x60\x07\xe0\x03\xe0\x00\x00'
        '\x0f\xc0\x0f\xe0\x0f\xf0\x0f\xf0\xff\xff\xff\xfe\xfc\x7f\xfc\x7f'
        '\xfc\x7f\xff\xff\x7f\xff\x7f\xff\x0f\xf0\x0f\xf0\x07\xf0\x03\xe0'
        '\x00\x08\x00\x08',
        'vmover':
        '\x00\x00\x01\x00\x03\x80\x07\xc0\x01\x00\x01\x00\x01\x00\x7f\xfc'
        '\x7f\xfc\x01\x00\x01\x00\x01\x00\x07\xc0\x03\x80\x01\x00\x00\x00'
        '\x01\x00\x03\x80\x07\xc0\x0f\xe0\x0f\xe0\x03\x80\xff\xfe\xff\xfe'
        '\xff\xfe\xff\xfe\x03\x80\x0f\xe0\x0f\xe0\x07\xc0\x03\x80\x01\x00'
        '\x00\x07\x00\x07',
        'watch':
        '\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x40\x80\x84\x40\x84\x40\x84\x60'
        '\x9c\x60\x80\x40\x80\x40\x40\x80\x3f\x00\x3f\x00\x3f\x00\x3f\x00'
        '\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x7f\x80\xff\xc0\xff\xc0\xff\xc0'
        '\xff\xc0\xff\xc0\xff\xc0\x7f\x80\x3f\x00\x3f\x00\x3f\x00\x3f\x00'
        '\x00\x08\x00\x08',
        'zoom':
        '\x0f\x00\x30\xc0\x40\x20\x40\x20\x80\x10\x80\x10\x80\x10\x80\x10'
        '\x40\x20\x40\x20\x30\xf0\x0f\x38\x00\x1c\x00\x0e\x00\x07\x00\x02'
        '\x0f\x00\x3f\xc0\x7f\xe0\x7f\xe0\xff\xf0\xff\xf0\xff\xf0\xff\xf0'
        '\x7f\xe0\x7f\xe0\x3f\xf0\x0f\x38\x00\x1c\x00\x0e\x00\x07\x00\x02'
        '\x00\x06\x00\x06',
        'zoomin':
        '\x0f\x00\x30\xc0\x40\x20\x46\x20\x86\x10\x9f\x90\x9f\x90\x86\x10'
        '\x46\x20\x40\x20\x30\xf0\x0f\x38\x00\x1c\x00\x0e\x00\x07\x00\x02'
        '\x0f\x00\x3f\xc0\x7f\xe0\x7f\xe0\xff\xf0\xff\xf0\xff\xf0\xff\xf0'
        '\x7f\xe0\x7f\xe0\x3f\xf0\x0f\x38\x00\x1c\x00\x0e\x00\x07\x00\x02'
        '\x00\x06\x00\x06',
        'zoomout':
        '\x0f\x00\x30\xc0\x40\x20\x40\x20\x80\x10\x9f\x90\x9f\x90\x80\x10'
        '\x40\x20\x40\x20\x30\xf0\x0f\x38\x00\x1c\x00\x0e\x00\x07\x00\x02'
        '\x0f\x00\x3f\xc0\x7f\xe0\x7f\xe0\xff\xf0\xff\xf0\xff\xf0\xff\xf0'
        '\x7f\xe0\x7f\xe0\x3f\xf0\x0f\x38\x00\x1c\x00\x0e\x00\x07\x00\x02'
        '\x00\x06\x00\x06',
}

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])