cpython/Mac/Tools/IDE/Wwindows.py

612 lines
16 KiB
Python
Raw Normal View History

1999-01-30 22:39:17 +00:00
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
# 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, 1, 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)