cpython/Mac/Tools/IDE/Wwindows.py

629 lines
16 KiB
Python
Raw Blame History

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, fontsettings=None):
import W
if fontsettings is None:
fontsettings = W.getdefaultfont()
self._fontsettings = fontsettings
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 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()
fontname, fontstyle, fontsize, fontcolor = self._fontsettings
fnum = Fm.GetFNum(fontname)
if fnum == 0:
fnum = Fm.GetFNum("Geneva")
Qd.TextFont(fnum)
Qd.TextFace(fontstyle)
Qd.TextSize(fontsize)
if self._bindings.has_key("<open>"):
callback = self._bindings["<open>"]
callback()
for w in self._widgets:
w.forall_frombottom("open")
self._maketabchain()
if self._tabbable:
self.bind('tab', self.nextwidget)
self.bind('shifttab', self.previouswidget)
else:
self._hasselframes = 0
if self._tabchain:
self._tabchain[0].select(1)
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 getbounds(self):
return self._globalbounds
def setbounds(self, bounds):
l, t, r, b = bounds
self.move(l, t)
self.resize(r-l, b-t)
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 not self._hasgrowbox:
return # hands off!
if y == None:
x, y = x
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[key]
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
desktopRgn = Win.GetGrayRgn()
tempRgn = Qd.NewRgn()
Qd.RectRgn(tempRgn, bounds)
union = Qd.UnionRgn(tempRgn, desktopRgn, tempRgn)
equal = Qd.EqualRgn(tempRgn, desktopRgn)
Qd.DisposeRgn(tempRgn)
if equal:
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)