mirror of https://github.com/python/cpython
613 lines
16 KiB
Python
613 lines
16 KiB
Python
import Qd
|
||
import Win
|
||
import Evt
|
||
import Fm
|
||
import FrameWork
|
||
import Windows
|
||
import Events
|
||
import Wbase
|
||
import Dlg
|
||
import MacOS
|
||
import Menu
|
||
import struct
|
||
import traceback
|
||
|
||
from types import *
|
||
|
||
|
||
class Window(FrameWork.Window, Wbase.SelectableWidget):
|
||
|
||
windowkind = Windows.documentProc
|
||
|
||
def __init__(self, possize, title = "", minsize = None, maxsize = None, tabbable = 1, show = 1):
|
||
import W
|
||
W.SelectableWidget.__init__(self, possize)
|
||
self._globalbounds = l, t, r, b = self.getwindowbounds(possize, minsize)
|
||
self._bounds = (0, 0, r - l, b - t)
|
||
self._tabchain = []
|
||
self._currentwidget = None
|
||
self.title = title
|
||
self._parentwindow = self
|
||
self._tabbable = tabbable
|
||
self._defaultbutton = None
|
||
self._drawwidgetbounds = 0
|
||
self._show = show
|
||
self._lastrollover = None
|
||
self.hasclosebox = 1
|
||
# XXX the following is not really compatible with the
|
||
# new (system >= 7.5) window procs.
|
||
if minsize:
|
||
self._hasgrowbox = 1
|
||
self.windowkind = self.windowkind | 8
|
||
l, t = minsize
|
||
if maxsize:
|
||
r, b = maxsize[0] + 1, maxsize[1] + 1
|
||
else:
|
||
r, b = 32000, 32000
|
||
self.growlimit = (l, t, r, b)
|
||
else:
|
||
self._hasgrowbox = 0
|
||
if (self.windowkind == 0 or self.windowkind >= 8) and self.windowkind < 1000:
|
||
self.windowkind = self.windowkind | 4
|
||
FrameWork.Window.__init__(self, W.getapplication())
|
||
|
||
def gettitle(self):
|
||
return self.title
|
||
|
||
def settitle(self, title):
|
||
self.title = title
|
||
if self.wid:
|
||
self.wid.SetWTitle(title)
|
||
|
||
def getwindowbounds(self, size, minsize = None):
|
||
return windowbounds(size, minsize)
|
||
|
||
def getcurrentwidget(self):
|
||
return self._currentwidget
|
||
|
||
def show(self, onoff):
|
||
if onoff:
|
||
self.wid.ShowWindow()
|
||
else:
|
||
self.wid.HideWindow()
|
||
|
||
def isvisible(self):
|
||
return self.wid.IsWindowVisible()
|
||
|
||
def getbounds(self):
|
||
if 0: #self.isvisible():
|
||
self.wid.GetWindowContentRgn(scratchRegion)
|
||
self._globalbounds = GetRgnBounds(scratchRegion)
|
||
return self._globalbounds
|
||
|
||
def select(self):
|
||
self.wid.SelectWindow()
|
||
# not sure if this is the best place, I need it when
|
||
# an editor gets selected, and immediately scrolled
|
||
# to a certain line, waste scroll assumes everything
|
||
# to be in tact.
|
||
self.do_rawupdate(self.wid, "DummyEvent")
|
||
|
||
def open(self):
|
||
self.wid = Win.NewCWindow(self._globalbounds, self.title, self._show,
|
||
self.windowkind, -1, self.hasclosebox, 0)
|
||
self.SetPort()
|
||
fnum = Fm.GetFNum("Python-Sans")
|
||
if fnum == 0:
|
||
fnum = Fm.GetFNum("Geneva")
|
||
Qd.TextFont(fnum) # XXX font&size from a function?
|
||
Qd.TextSize(9) # XXX font&size from a function?
|
||
if self._bindings.has_key("<open>"):
|
||
callback = self._bindings["<open>"]
|
||
callback()
|
||
for w in self._widgets:
|
||
w.forall_frombottom("open")
|
||
self._maketabchain()
|
||
if self._tabchain:
|
||
self._tabchain[0].select(1)
|
||
if self._tabbable:
|
||
self.bind('tab', self.nextwidget)
|
||
self.bind('shifttab', self.previouswidget)
|
||
self.do_postopen()
|
||
|
||
def close(self):
|
||
if not self.wid:
|
||
return # we are already closed
|
||
if self._bindings.has_key("<close>"):
|
||
callback = self._bindings["<close>"]
|
||
try:
|
||
rv = callback()
|
||
except:
|
||
print 'error in <close> callback'
|
||
traceback.print_exc()
|
||
else:
|
||
if rv:
|
||
return rv
|
||
#for key in self._widgetsdict.keys():
|
||
# self._removewidget(key)
|
||
self.forall_butself("close")
|
||
Wbase.SelectableWidget.close(self)
|
||
self._tabchain = []
|
||
self._currentwidget = None
|
||
self.wid.HideWindow()
|
||
self.do_postclose()
|
||
|
||
def domenu_close(self, *args):
|
||
self.close()
|
||
|
||
def move(self, x, y = None):
|
||
"""absolute move"""
|
||
if y == None:
|
||
x, y = x
|
||
self.wid.MoveWindow(x, y, 0)
|
||
|
||
def resize(self, x, y = None):
|
||
if y == None:
|
||
x, y = x
|
||
if self._hasgrowbox:
|
||
self.SetPort()
|
||
Win.InvalRect(self.getgrowrect())
|
||
self.wid.SizeWindow(x, y, 1)
|
||
self._calcbounds()
|
||
|
||
def test(self, point):
|
||
return 1
|
||
|
||
def draw(self, visRgn = None):
|
||
if self._hasgrowbox:
|
||
self.tempcliprect(self.getgrowrect())
|
||
self.wid.DrawGrowIcon()
|
||
self.restoreclip()
|
||
|
||
def idle(self, *args):
|
||
self.SetPort()
|
||
point = Evt.GetMouse()
|
||
widget = self.findwidget(point, 0)
|
||
if self._bindings.has_key("<idle>"):
|
||
callback = self._bindings["<idle>"]
|
||
if callback():
|
||
return
|
||
if self._currentwidget is not None and hasattr(self._currentwidget, "idle"):
|
||
if self._currentwidget._bindings.has_key("<idle>"):
|
||
callback = self._currentwidget._bindings["<idle>"]
|
||
if callback():
|
||
return
|
||
if self._currentwidget.idle():
|
||
return
|
||
if widget is not None and hasattr(widget, "rollover"):
|
||
if 1: #self._lastrollover <> widget:
|
||
if self._lastrollover:
|
||
self._lastrollover.rollover(point, 0)
|
||
self._lastrollover = widget
|
||
self._lastrollover.rollover(point, 1)
|
||
else:
|
||
if self._lastrollover:
|
||
self._lastrollover.rollover(point, 0)
|
||
self._lastrollover = None
|
||
Wbase.SetCursor("arrow")
|
||
|
||
def xxx___select(self, widget):
|
||
if self._currentwidget == widget:
|
||
return
|
||
if self._bindings.has_key("<select>"):
|
||
callback = self._bindings["<select>"]
|
||
if callback(widget):
|
||
return
|
||
if widget is None:
|
||
if self._currentwidget is not None:
|
||
self._currentwidget.select(0)
|
||
elif type(widget) == InstanceType and widget._selectable:
|
||
widget.select(1)
|
||
elif widget == -1 or widget == 1:
|
||
if len(self._tabchain) <= 1:
|
||
return
|
||
temp = self._tabchain[(self._tabchain.index(self._currentwidget) + widget) % len(self._tabchain)]
|
||
temp.select(1)
|
||
else:
|
||
raise TypeError, "Widget is not selectable"
|
||
|
||
def setdefaultbutton(self, newdefaultbutton = None, *keys):
|
||
if newdefaultbutton == self._defaultbutton:
|
||
return
|
||
if self._defaultbutton:
|
||
self._defaultbutton._setdefault(0)
|
||
if not newdefaultbutton:
|
||
self.bind("return", None)
|
||
self.bind("enter", None)
|
||
return
|
||
import Wcontrols
|
||
if not isinstance(newdefaultbutton, Wcontrols.Button):
|
||
raise TypeError, "widget is not a button"
|
||
self._defaultbutton = newdefaultbutton
|
||
self._defaultbutton._setdefault(1)
|
||
if not keys:
|
||
self.bind("return", self._defaultbutton.push)
|
||
self.bind("enter", self._defaultbutton.push)
|
||
else:
|
||
for key in keys:
|
||
self.bind(key, self._defaultbutton.push)
|
||
|
||
def nextwidget(self):
|
||
self.xxx___select(1)
|
||
|
||
def previouswidget(self):
|
||
self.xxx___select(-1)
|
||
|
||
def drawwidgetbounds(self, onoff):
|
||
self._drawwidgetbounds = onoff
|
||
self.SetPort()
|
||
Win.InvalRect(self._bounds)
|
||
|
||
def _drawbounds(self):
|
||
pass
|
||
|
||
def _maketabchain(self):
|
||
# XXX This has to change, it's no good when we are adding or deleting widgets.
|
||
# XXX Perhaps we shouldn't keep a "tabchain" at all.
|
||
self._hasselframes = 0
|
||
self._collectselectablewidgets(self._widgets)
|
||
if self._hasselframes and len(self._tabchain) > 1:
|
||
self._hasselframes = 1
|
||
else:
|
||
self._hasselframes = 0
|
||
|
||
def _collectselectablewidgets(self, widgets):
|
||
import W
|
||
for w in widgets:
|
||
if w._selectable:
|
||
self._tabchain.append(w)
|
||
if isinstance(w, W.List):
|
||
self._hasselframes = 1
|
||
self._collectselectablewidgets(w._widgets)
|
||
|
||
def _calcbounds(self):
|
||
self._possize = self.wid.GetWindowPort().portRect[2:]
|
||
w, h = self._possize
|
||
self._bounds = (0, 0, w, h)
|
||
self.wid.GetWindowContentRgn(scratchRegion)
|
||
l, t, r, b = GetRgnBounds(scratchRegion)
|
||
self._globalbounds = l, t, l + w, t + h
|
||
for w in self._widgets:
|
||
w._calcbounds()
|
||
|
||
# FrameWork override methods
|
||
def do_inDrag(self, partcode, window, event):
|
||
where = event[3]
|
||
self.wid.GetWindowContentRgn(scratchRegion)
|
||
was_l, was_t, r, b = GetRgnBounds(scratchRegion)
|
||
window.DragWindow(where, self.draglimit)
|
||
self.wid.GetWindowContentRgn(scratchRegion)
|
||
is_l, is_t, r, b = GetRgnBounds(scratchRegion)
|
||
self._globalbounds = Qd.OffsetRect(self._globalbounds,
|
||
is_l - was_l, is_t - was_t)
|
||
|
||
def do_char(self, char, event):
|
||
import Wkeys
|
||
(what, message, when, where, modifiers) = event
|
||
key = char
|
||
if Wkeys.keynames.has_key(key):
|
||
key = Wkeys.keynames[char]
|
||
if modifiers & Events.shiftKey:
|
||
key = 'shift' + key
|
||
if modifiers & Events.cmdKey:
|
||
key = 'cmd' + key
|
||
if modifiers & Events.controlKey:
|
||
key = 'control' + key
|
||
if self._bindings.has_key("<key>"):
|
||
callback = self._bindings["<key>"]
|
||
if Wbase.CallbackCall(callback, 0, char, event):
|
||
return
|
||
if self._bindings.has_key(key):
|
||
callback = self._bindings[key]
|
||
Wbase.CallbackCall(callback, 0, char, event)
|
||
elif self._currentwidget is not None:
|
||
if self._currentwidget._bindings.has_key(key):
|
||
callback = self._currentwidget._bindings[key]
|
||
Wbase.CallbackCall(callback, 0, char, event)
|
||
else:
|
||
if self._currentwidget._bindings.has_key("<key>"):
|
||
callback = self._currentwidget._bindings["<key>"]
|
||
if Wbase.CallbackCall(callback, 0, char, event):
|
||
return
|
||
self._currentwidget.key(char, event)
|
||
|
||
def do_contentclick(self, point, modifiers, event):
|
||
widget = self.findwidget(point)
|
||
if widget is not None:
|
||
if self._bindings.has_key("<click>"):
|
||
callback = self._bindings["<click>"]
|
||
if Wbase.CallbackCall(callback, 0, point, modifiers):
|
||
return
|
||
if widget._bindings.has_key("<click>"):
|
||
callback = widget._bindings["<click>"]
|
||
if Wbase.CallbackCall(callback, 0, point, modifiers):
|
||
return
|
||
if widget._selectable:
|
||
widget.select(1, 1)
|
||
widget.click(point, modifiers)
|
||
|
||
def do_update(self, window, event):
|
||
Qd.EraseRgn(window.GetWindowPort().visRgn)
|
||
self.forall_frombottom("draw", window.GetWindowPort().visRgn)
|
||
if self._drawwidgetbounds:
|
||
self.forall_frombottom("_drawbounds")
|
||
|
||
def do_activate(self, onoff, event):
|
||
if not onoff:
|
||
if self._lastrollover:
|
||
self._lastrollover.rollover((0, 0), 0)
|
||
self._lastrollover = None
|
||
self.SetPort()
|
||
self.forall("activate", onoff)
|
||
self.draw()
|
||
|
||
def do_postresize(self, width, height, window):
|
||
Win.InvalRect(self.getgrowrect())
|
||
self._calcbounds()
|
||
|
||
def do_inGoAway(self, partcode, window, event):
|
||
where = event[3]
|
||
closeall = event[4] & Events.optionKey
|
||
if window.TrackGoAway(where):
|
||
if not closeall:
|
||
self.close()
|
||
else:
|
||
for window in self.parent._windows.values():
|
||
rv = window.close()
|
||
if rv and rv > 0:
|
||
return
|
||
|
||
# utilities
|
||
def tempcliprect(self, tempcliprect):
|
||
tempclip = Qd.NewRgn()
|
||
Qd.RectRgn(tempclip, tempcliprect)
|
||
self.tempclip(tempclip)
|
||
Qd.DisposeRgn(tempclip)
|
||
|
||
def tempclip(self, tempclip):
|
||
if not hasattr(self, "saveclip"):
|
||
self.saveclip = []
|
||
saveclip = Qd.NewRgn()
|
||
Qd.GetClip(saveclip)
|
||
self.saveclip.append(saveclip)
|
||
Qd.SetClip(tempclip)
|
||
|
||
def restoreclip(self):
|
||
Qd.SetClip(self.saveclip[-1])
|
||
Qd.DisposeRgn(self.saveclip[-1])
|
||
del self.saveclip[-1]
|
||
|
||
def getgrowrect(self):
|
||
l, t, r, b = self.wid.GetWindowPort().portRect
|
||
return (r - 15, b - 15, r, b)
|
||
|
||
def has_key(self, key):
|
||
return self._widgetsdict.has_key(key)
|
||
|
||
def __getattr__(self, attr):
|
||
global _successcount, _failcount, _magiccount
|
||
if self._widgetsdict.has_key(attr):
|
||
_successcount = _successcount + 1
|
||
return self._widgetsdict[attr]
|
||
if self._currentwidget is None or (attr[:7] <> 'domenu_' and
|
||
attr[:4] <> 'can_' and attr <> 'insert'):
|
||
_failcount = _failcount + 1
|
||
raise AttributeError, attr
|
||
# special case: if a domenu_xxx, can_xxx or insert method is asked for,
|
||
# see if the active widget supports it
|
||
_magiccount = _magiccount + 1
|
||
return getattr(self._currentwidget, attr)
|
||
|
||
_successcount = 0
|
||
_failcount = 0
|
||
_magiccount = 0
|
||
|
||
class Dialog(Window):
|
||
|
||
windowkind = Windows.movableDBoxProc
|
||
|
||
# this __init__ seems redundant, but it's not: it has less args
|
||
def __init__(self, possize, title = ""):
|
||
Window.__init__(self, possize, title)
|
||
|
||
def can_close(self, *args):
|
||
return 0
|
||
|
||
def getwindowbounds(self, size, minsize = None):
|
||
screenbounds = sl, st, sr, sb = Qd.qd.screenBits.bounds
|
||
w, h = size
|
||
l = sl + (sr - sl - w) / 2
|
||
t = st + (sb - st - h) / 3
|
||
return l, t, l + w, t + h
|
||
|
||
|
||
class ModalDialog(Dialog):
|
||
|
||
def __init__(self, possize, title = ""):
|
||
Dialog.__init__(self, possize, title)
|
||
if title:
|
||
self.windowkind = Windows.movableDBoxProc
|
||
else:
|
||
self.windowkind = Windows.dBoxProc
|
||
|
||
def open(self):
|
||
import W
|
||
Dialog.open(self)
|
||
self.app = W.getapplication()
|
||
self.done = 0
|
||
Menu.HiliteMenu(0)
|
||
app = self.parent
|
||
app.enablemenubar(0)
|
||
try:
|
||
self.mainloop()
|
||
finally:
|
||
app.enablemenubar(1)
|
||
|
||
def close(self):
|
||
if not self.wid:
|
||
return # we are already closed
|
||
self.done = 1
|
||
del self.app
|
||
Dialog.close(self)
|
||
|
||
def mainloop(self):
|
||
saveyield = MacOS.EnableAppswitch(-1)
|
||
while not self.done:
|
||
#self.do1event()
|
||
self.do1event( Events.keyDownMask +
|
||
Events.autoKeyMask +
|
||
Events.activMask +
|
||
Events.updateMask +
|
||
Events.mDownMask +
|
||
Events.mUpMask,
|
||
10)
|
||
MacOS.EnableAppswitch(saveyield)
|
||
|
||
def do1event(self, mask = Events.everyEvent, wait = 0):
|
||
ok, event = self.app.getevent(mask, wait)
|
||
if Dlg.IsDialogEvent(event):
|
||
if self.app.do_dialogevent(event):
|
||
return
|
||
if ok:
|
||
self.dispatch(event)
|
||
else:
|
||
self.app.idle(event)
|
||
|
||
def do_keyDown(self, event):
|
||
self.do_key(event)
|
||
|
||
def do_autoKey(self, event):
|
||
if not event[-1] & Events.cmdKey:
|
||
self.do_key(event)
|
||
|
||
def do_key(self, event):
|
||
(what, message, when, where, modifiers) = event
|
||
w = Win.FrontWindow()
|
||
if w <> self.wid:
|
||
return
|
||
c = chr(message & Events.charCodeMask)
|
||
if modifiers & Events.cmdKey:
|
||
self.app.checkmenus(self)
|
||
result = Menu.MenuKey(ord(c))
|
||
id = (result>>16) & 0xffff # Hi word
|
||
item = result & 0xffff # Lo word
|
||
if id:
|
||
self.app.do_rawmenu(id, item, None, event)
|
||
return
|
||
self.do_char(c, event)
|
||
|
||
def do_mouseDown(self, event):
|
||
(what, message, when, where, modifiers) = event
|
||
partcode, wid = Win.FindWindow(where)
|
||
#
|
||
# Find the correct name.
|
||
#
|
||
if FrameWork.partname.has_key(partcode):
|
||
name = "do_" + FrameWork.partname[partcode]
|
||
else:
|
||
name = "do_%d" % partcode
|
||
|
||
if name == "do_inDesk":
|
||
MacOS.HandleEvent(event)
|
||
return
|
||
if wid == self.wid:
|
||
try:
|
||
handler = getattr(self, name)
|
||
except AttributeError:
|
||
handler = self.app.do_unknownpartcode
|
||
else:
|
||
#MacOS.HandleEvent(event)
|
||
if name == 'do_inMenuBar':
|
||
handler = getattr(self.parent, name)
|
||
else:
|
||
return
|
||
handler(partcode, wid, event)
|
||
|
||
def dispatch(self, event):
|
||
(what, message, when, where, modifiers) = event
|
||
if FrameWork.eventname.has_key(what):
|
||
name = "do_" + FrameWork.eventname[what]
|
||
else:
|
||
name = "do_%d" % what
|
||
try:
|
||
handler = getattr(self, name)
|
||
except AttributeError:
|
||
try:
|
||
handler = getattr(self.app, name)
|
||
except AttributeError:
|
||
handler = self.app.do_unknownevent
|
||
handler(event)
|
||
|
||
|
||
def FrontWindowInsert(stuff):
|
||
if not stuff:
|
||
return
|
||
if type(stuff) <> StringType:
|
||
raise TypeError, 'string expected'
|
||
import W
|
||
app = W.getapplication()
|
||
wid = Win.FrontWindow()
|
||
if wid and app._windows.has_key(wid):
|
||
window = app._windows[wid]
|
||
if hasattr(window, "insert"):
|
||
try:
|
||
window.insert(stuff)
|
||
return
|
||
except:
|
||
pass
|
||
import EasyDialogs
|
||
if EasyDialogs.AskYesNoCancel(
|
||
"Can<EFBFBD>t find window or widget to insert text into; copy to clipboard instead?",
|
||
1) == 1:
|
||
import Scrap
|
||
Scrap.ZeroScrap()
|
||
Scrap.PutScrap('TEXT', stuff)
|
||
|
||
|
||
# not quite based on the same function in FrameWork
|
||
_windowcounter = 0
|
||
|
||
def getnextwindowpos():
|
||
global _windowcounter
|
||
rows = 8
|
||
l = 4 * (rows + 1 - (_windowcounter % rows) + _windowcounter / rows)
|
||
t = 44 + 20 * (_windowcounter % rows)
|
||
_windowcounter = _windowcounter + 1
|
||
return l, t
|
||
|
||
def windowbounds(preferredsize, minsize = None):
|
||
"Return sensible window bounds"
|
||
|
||
global _windowcounter
|
||
if len(preferredsize) == 4:
|
||
bounds = l, t, r, b = preferredsize
|
||
union = Qd.UnionRect(bounds, Qd.qd.screenBits.bounds)
|
||
if union == Qd.qd.screenBits.bounds:
|
||
return bounds
|
||
else:
|
||
preferredsize = r - l, b - t
|
||
if not minsize:
|
||
minsize = preferredsize
|
||
minwidth, minheight = minsize
|
||
width, height = preferredsize
|
||
|
||
sl, st, sr, sb = screenbounds = Qd.InsetRect(Qd.qd.screenBits.bounds, 4, 4)
|
||
l, t = getnextwindowpos()
|
||
if (l + width) > sr:
|
||
_windowcounter = 0
|
||
l, t = getnextwindowpos()
|
||
r = l + width
|
||
b = t + height
|
||
if (t + height) > sb:
|
||
b = sb
|
||
if (b - t) < minheight:
|
||
b = t + minheight
|
||
return l, t, r, b
|
||
|
||
scratchRegion = Qd.NewRgn()
|
||
|
||
# util -- move somewhere convenient???
|
||
def GetRgnBounds(the_Rgn):
|
||
(t, l, b, r) = struct.unpack("hhhh", the_Rgn.data[2:10])
|
||
return (l, t, r, b)
|