mirror of
https://github.com/AdaCore/cpython.git
synced 2026-02-12 12:57:15 -08:00
54a8e1cfda
Make object browser work in OSX (by rewriting the old browser LDEF in Python). If at all possible, this should go into 2.2.1.
582 lines
15 KiB
Python
582 lines
15 KiB
Python
import Wbase
|
|
import Wkeys
|
|
import string
|
|
from Carbon import Evt, Events, Fm, Lists, Qd, Scrap, Win
|
|
from Carbon.List import LNew, CreateCustomList, GetListPort
|
|
from Carbon.Lists import kListDefUserProcType, lInitMsg, lDrawMsg, lHiliteMsg, lCloseMsg
|
|
from Carbon.QuickDraw import hilitetransfermode
|
|
from Carbon import App
|
|
from Carbon.Appearance import kThemeStateActive, kThemeStateInactive, kThemeStatePressed
|
|
|
|
|
|
class List(Wbase.SelectableWidget):
|
|
|
|
"""Standard list widget."""
|
|
|
|
LDEF_ID = 0
|
|
|
|
def __init__(self, possize, items = None, callback = None, flags = 0, cols = 1, typingcasesens=0):
|
|
if items is None:
|
|
items = []
|
|
self.items = items
|
|
Wbase.SelectableWidget.__init__(self, possize)
|
|
self._selected = 0
|
|
self._enabled = 1
|
|
self._list = None
|
|
self._cols = cols
|
|
self._callback = callback
|
|
self._flags = flags
|
|
self.typingcasesens = typingcasesens
|
|
self.lasttyping = ""
|
|
self.lasttime = Evt.TickCount()
|
|
self.timelimit = 30
|
|
self.setitems(items)
|
|
self.drawingmode = 0
|
|
|
|
def open(self):
|
|
self.setdrawingmode(0)
|
|
self.createlist()
|
|
self.setdrawingmode(1)
|
|
|
|
def createlist(self):
|
|
self._calcbounds()
|
|
self.SetPort()
|
|
rect = self._bounds
|
|
rect = rect[0]+1, rect[1]+1, rect[2]-16, rect[3]-1
|
|
self._viewbounds = rect
|
|
self._list = LNew(rect, (0, 0, self._cols, 0), (0, 0), self.LDEF_ID, self._parentwindow.wid,
|
|
0, 1, 0, 1)
|
|
if self.drawingmode:
|
|
self._list.LSetDrawingMode(0)
|
|
self._list.selFlags = self._flags
|
|
self.setitems(self.items)
|
|
if hasattr(self, "_sel"):
|
|
self.setselection(self._sel)
|
|
del self._sel
|
|
|
|
def adjust(self, oldbounds):
|
|
self.SetPort()
|
|
# Appearance frames are drawn outside the specified bounds,
|
|
# so we always need to outset the invalidated area.
|
|
self.GetWindow().InvalWindowRect(Qd.InsetRect(oldbounds, -3, -3))
|
|
self.GetWindow().InvalWindowRect(Qd.InsetRect(self._bounds, -3, -3))
|
|
|
|
if oldbounds[:2] == self._bounds[:2]:
|
|
# set visRgn to empty, to prevent nasty drawing side effect of LSize()
|
|
Qd.RectRgn(self._parentwindow.wid.GetWindowPort().visRgn, (0, 0, 0, 0))
|
|
# list still has the same upper/left coordinates, use LSize
|
|
l, t, r, b = self._bounds
|
|
width = r - l - 17
|
|
height = b - t - 2
|
|
vl, vt, vr, vb = self._viewbounds
|
|
self._viewbounds = vl, vt, vl + width, vt + height
|
|
self._list.LSize(width, height)
|
|
# now *why* doesn't the list manager recalc the cellrect???
|
|
l, t, r, b = self._list.LRect((0,0))
|
|
cellheight = b - t
|
|
self._list.LCellSize((width, cellheight))
|
|
# reset visRgn
|
|
self._parentwindow.wid.CalcVis()
|
|
else:
|
|
# oh well, since the list manager doesn't have a LMove call,
|
|
# we have to make the list all over again...
|
|
sel = self.getselection()
|
|
topcell = self.gettopcell()
|
|
self._list = None
|
|
self.setdrawingmode(0)
|
|
self.createlist()
|
|
self.setselection(sel)
|
|
self.settopcell(topcell)
|
|
self.setdrawingmode(1)
|
|
|
|
def close(self):
|
|
self._list = None
|
|
self._callback = None
|
|
self.items = []
|
|
Wbase.SelectableWidget.close(self)
|
|
|
|
def set(self, items):
|
|
self.setitems(items)
|
|
|
|
def setitems(self, items):
|
|
self.items = items
|
|
the_list = self._list
|
|
if not self._parent or not self._list:
|
|
return
|
|
self.setdrawingmode(0)
|
|
topcell = self.gettopcell()
|
|
the_list.LDelRow(0, 1)
|
|
the_list.LAddRow(len(self.items), 0)
|
|
self_itemrepr = self.itemrepr
|
|
set_cell = the_list.LSetCell
|
|
for i in range(len(items)):
|
|
set_cell(self_itemrepr(items[i]), (0, i))
|
|
self.settopcell(topcell)
|
|
self.setdrawingmode(1)
|
|
|
|
def click(self, point, modifiers):
|
|
if not self._enabled:
|
|
return
|
|
isdoubleclick = self._list.LClick(point, modifiers)
|
|
if self._callback:
|
|
Wbase.CallbackCall(self._callback, 0, isdoubleclick)
|
|
return 1
|
|
|
|
def key(self, char, event):
|
|
(what, message, when, where, modifiers) = event
|
|
sel = self.getselection()
|
|
newselection = []
|
|
if char == Wkeys.uparrowkey:
|
|
if len(sel) >= 1 and min(sel) > 0:
|
|
newselection = [min(sel) - 1]
|
|
else:
|
|
newselection = [0]
|
|
elif char == Wkeys.downarrowkey:
|
|
if len(sel) >= 1 and max(sel) < (len(self.items) - 1):
|
|
newselection = [max(sel) + 1]
|
|
else:
|
|
newselection = [len(self.items) - 1]
|
|
else:
|
|
modifiers = 0
|
|
if (self.lasttime + self.timelimit) < Evt.TickCount():
|
|
self.lasttyping = ""
|
|
if self.typingcasesens:
|
|
self.lasttyping = self.lasttyping + char
|
|
else:
|
|
self.lasttyping = self.lasttyping + string.lower(char)
|
|
self.lasttime = Evt.TickCount()
|
|
i = self.findmatch(self.lasttyping)
|
|
newselection = [i]
|
|
if modifiers & Events.shiftKey and not self._list.selFlags & Lists.lOnlyOne:
|
|
newselection = newselection + sel
|
|
self.setselection(newselection)
|
|
self._list.LAutoScroll()
|
|
self.click((-1, -1), 0)
|
|
|
|
def findmatch(self, tag):
|
|
lower = string.lower
|
|
items = self.items
|
|
typingcasesens = self.typingcasesens
|
|
taglen = len(tag)
|
|
match = '\377' * 100
|
|
match_i = -1
|
|
for i in range(len(items)):
|
|
item = str(items[i])
|
|
if not typingcasesens:
|
|
item = lower(item)
|
|
if tag <= item < match:
|
|
match = item
|
|
match_i = i
|
|
if match_i >= 0:
|
|
return match_i
|
|
else:
|
|
return len(items) - 1
|
|
|
|
def domenu_copy(self, *args):
|
|
sel = self.getselection()
|
|
selitems = []
|
|
for i in sel:
|
|
selitems.append(str(self.items[i]))
|
|
text = string.join(selitems, '\r')
|
|
if text:
|
|
if hasattr(Scrap, 'PutScrap'):
|
|
Scrap.ZeroScrap()
|
|
Scrap.PutScrap('TEXT', text)
|
|
else:
|
|
Scrap.ClearCurrentScrap()
|
|
sc = Scrap.GetCurrentScrap()
|
|
sc.PutScrapFlavor('TEXT', 0, text)
|
|
|
|
def can_copy(self, *args):
|
|
return len(self.getselection()) <> 0
|
|
|
|
def domenu_selectall(self, *args):
|
|
self.selectall()
|
|
|
|
def can_selectall(self, *args):
|
|
return not self._list.selFlags & Lists.lOnlyOne
|
|
|
|
def selectall(self):
|
|
if not self._list.selFlags & Lists.lOnlyOne:
|
|
self.setselection(range(len(self.items)))
|
|
self._list.LAutoScroll()
|
|
self.click((-1, -1), 0)
|
|
|
|
def getselection(self):
|
|
if not self._parent or not self._list:
|
|
if hasattr(self, "_sel"):
|
|
return self._sel
|
|
return []
|
|
items = []
|
|
point = (0,0)
|
|
while 1:
|
|
ok, point = self._list.LGetSelect(1, point)
|
|
if not ok:
|
|
break
|
|
items.append(point[1])
|
|
point = point[0], point[1]+1
|
|
return items
|
|
|
|
def setselection(self, selection):
|
|
if not self._parent or not self._list:
|
|
self._sel = selection
|
|
return
|
|
set_sel = self._list.LSetSelect
|
|
for i in range(len(self.items)):
|
|
if i in selection:
|
|
set_sel(1, (0, i))
|
|
else:
|
|
set_sel(0, (0, i))
|
|
self._list.LAutoScroll()
|
|
|
|
def getselectedobjects(self):
|
|
sel = self.getselection()
|
|
objects = []
|
|
for i in sel:
|
|
objects.append(self.items[i])
|
|
return objects
|
|
|
|
def setselectedobjects(self, objects):
|
|
sel = []
|
|
for o in objects:
|
|
try:
|
|
sel.append(self.items.index(o))
|
|
except:
|
|
pass
|
|
self.setselection(sel)
|
|
|
|
def gettopcell(self):
|
|
l, t, r, b = self._bounds
|
|
t = t + 1
|
|
cl, ct, cr, cb = self._list.LRect((0, 0))
|
|
cellheight = cb - ct
|
|
return (t - ct) / cellheight
|
|
|
|
def settopcell(self, topcell):
|
|
top = self.gettopcell()
|
|
diff = topcell - top
|
|
self._list.LScroll(0, diff)
|
|
|
|
def draw(self, visRgn = None):
|
|
if self._visible:
|
|
if not visRgn:
|
|
visRgn = self._parentwindow.wid.GetWindowPort().visRgn
|
|
self._list.LUpdate(visRgn)
|
|
state = [kThemeStateActive, kThemeStateInactive][not self._activated]
|
|
App.DrawThemeListBoxFrame(Qd.InsetRect(self._bounds, 1, 1), state)
|
|
if self._selected and self._activated:
|
|
self.drawselframe(1)
|
|
|
|
def select(self, onoff, isclick = 0):
|
|
if Wbase.SelectableWidget.select(self, onoff):
|
|
return
|
|
self.SetPort()
|
|
self.drawselframe(onoff)
|
|
|
|
def activate(self, onoff):
|
|
self._activated = onoff
|
|
if self._visible:
|
|
self._list.LActivate(onoff)
|
|
#state = [kThemeStateActive, kThemeStateInactive][not onoff]
|
|
#App.DrawThemeListBoxFrame(Qd.InsetRect(self._bounds, 1, 1), state)
|
|
if self._selected:
|
|
self.drawselframe(onoff)
|
|
|
|
def get(self):
|
|
return self.items
|
|
|
|
def itemrepr(self, item):
|
|
return str(item)[:255]
|
|
|
|
def __getitem__(self, index):
|
|
return self.items[index]
|
|
|
|
def __setitem__(self, index, item):
|
|
if self._parent and self._list:
|
|
self._list.LSetCell(self.itemrepr(item), (0, index))
|
|
self.items[index] = item
|
|
|
|
def __delitem__(self, index):
|
|
if self._parent and self._list:
|
|
self._list.LDelRow(1, index)
|
|
del self.items[index]
|
|
|
|
def __getslice__(self, a, b):
|
|
return self.items[a:b]
|
|
|
|
def __delslice__(self, a, b):
|
|
if b-a:
|
|
if self._parent and self._list:
|
|
self._list.LDelRow(b-a, a)
|
|
del self.items[a:b]
|
|
|
|
def __setslice__(self, a, b, items):
|
|
if self._parent and self._list:
|
|
l = len(items)
|
|
the_list = self._list
|
|
self.setdrawingmode(0)
|
|
if b-a:
|
|
if b > len(self.items):
|
|
# fix for new 1.5 "feature" where b is sys.maxint instead of len(self)...
|
|
# LDelRow doesn't like maxint.
|
|
b = len(self.items)
|
|
the_list.LDelRow(b-a, a)
|
|
the_list.LAddRow(l, a)
|
|
self_itemrepr = self.itemrepr
|
|
set_cell = the_list.LSetCell
|
|
for i in range(len(items)):
|
|
set_cell(self_itemrepr(items[i]), (0, i + a))
|
|
self.items[a:b] = items
|
|
self.setdrawingmode(1)
|
|
else:
|
|
self.items[a:b] = items
|
|
|
|
def __len__(self):
|
|
return len(self.items)
|
|
|
|
def append(self, item):
|
|
if self._parent and self._list:
|
|
index = len(self.items)
|
|
self._list.LAddRow(1, index)
|
|
self._list.LSetCell(self.itemrepr(item), (0, index))
|
|
self.items.append(item)
|
|
|
|
def remove(self, item):
|
|
index = self.items.index(item)
|
|
self.__delitem__(index)
|
|
|
|
def index(self, item):
|
|
return self.items.index(item)
|
|
|
|
def insert(self, index, item):
|
|
if index < 0:
|
|
index = 0
|
|
if self._parent and self._list:
|
|
self._list.LAddRow(1, index)
|
|
self._list.LSetCell(self.itemrepr(item), (0, index))
|
|
self.items.insert(index, item)
|
|
|
|
def setdrawingmode(self, onoff):
|
|
if onoff:
|
|
self.drawingmode = self.drawingmode - 1
|
|
if self.drawingmode == 0 and self._list is not None:
|
|
self._list.LSetDrawingMode(1)
|
|
if self._visible:
|
|
bounds = l, t, r, b = Qd.InsetRect(self._bounds, 1, 1)
|
|
cl, ct, cr, cb = self._list.LRect((0, len(self.items)-1))
|
|
if cb < b:
|
|
self.SetPort()
|
|
Qd.EraseRect((l, cb, cr, b))
|
|
self._list.LUpdate(self._parentwindow.wid.GetWindowPort().visRgn)
|
|
self.GetWindow().ValidWindowRect(bounds)
|
|
else:
|
|
if self.drawingmode == 0 and self._list is not None:
|
|
self._list.LSetDrawingMode(0)
|
|
self.drawingmode = self.drawingmode + 1
|
|
|
|
|
|
class CustomList(List):
|
|
|
|
"""Base class for writing custom list definitions."""
|
|
|
|
_cellHeight = 0
|
|
|
|
def createlist(self):
|
|
self._calcbounds()
|
|
self.SetPort()
|
|
rect = self._bounds
|
|
rect = rect[0]+1, rect[1]+1, rect[2]-16, rect[3]-1
|
|
self._viewbounds = rect
|
|
self._list = CreateCustomList(
|
|
rect,
|
|
(0, 0, 1, 0),
|
|
(0, self._cellHeight),
|
|
(kListDefUserProcType, self.listDefinitionFunc),
|
|
self._parentwindow.wid,
|
|
0, 1, 0, 1)
|
|
if self.drawingmode:
|
|
self._list.LSetDrawingMode(0)
|
|
self._list.selFlags = self._flags
|
|
self.setitems(self.items)
|
|
if hasattr(self, "_sel"):
|
|
self.setselection(self._sel)
|
|
del self._sel
|
|
|
|
def listDefinitionFunc(self, message, selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList):
|
|
"""The LDEF message dispatcher routine, no need to override."""
|
|
if message == lInitMsg:
|
|
self.listDefInit(theList)
|
|
elif message == lDrawMsg:
|
|
self.listDefDraw(selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList)
|
|
elif message == lHiliteMsg:
|
|
self.listDefHighlight(selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList)
|
|
elif message == lCloseMsg:
|
|
self.listDefClose(theList)
|
|
|
|
def listDefInit(self, theList):
|
|
pass
|
|
def listDefClose(self, theList):
|
|
pass
|
|
def listDefDraw(self, selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList):
|
|
pass
|
|
def listDefHighlight(self, selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList):
|
|
pass
|
|
|
|
|
|
class TwoLineList(CustomList):
|
|
|
|
_cellHeight = 28
|
|
|
|
def listDefDraw(self, selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList):
|
|
savedPort = Qd.GetPort()
|
|
Qd.SetPort(GetListPort(theList))
|
|
savedClip = Qd.NewRgn()
|
|
Qd.GetClip(savedClip)
|
|
Qd.ClipRect(cellRect)
|
|
savedPenState = Qd.GetPenState()
|
|
Qd.PenNormal()
|
|
Qd.EraseRect(cellRect)
|
|
|
|
#draw the cell if it contains data
|
|
ascent, descent, leading, size, hm = Fm.FontMetrics()
|
|
linefeed = ascent + descent + leading
|
|
|
|
if dataLen:
|
|
left, top, right, bottom = cellRect
|
|
data = theList.LGetCell(dataLen, theCell)
|
|
lines = data.split("\r")
|
|
line1 = lines[0]
|
|
if len(lines) > 1:
|
|
line2 = lines[1]
|
|
else:
|
|
line2 = ""
|
|
Qd.MoveTo(left + 4, top + ascent)
|
|
Qd.DrawText(line1, 0, len(line1))
|
|
if line2:
|
|
Qd.MoveTo(left + 4, top + ascent + linefeed)
|
|
Qd.DrawText(line2, 0, len(line2))
|
|
Qd.PenPat("\x11\x11\x11\x11\x11\x11\x11\x11")
|
|
bottom = top + theList.cellSize[1]
|
|
Qd.MoveTo(left, bottom - 1)
|
|
Qd.LineTo(right, bottom - 1)
|
|
if selected:
|
|
self.listDefHighlight(selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList)
|
|
#restore graphics environment
|
|
Qd.SetPort(savedPort)
|
|
Qd.SetClip(savedClip)
|
|
Qd.DisposeRgn(savedClip)
|
|
Qd.SetPenState(savedPenState)
|
|
|
|
def listDefHighlight(self, selected, cellRect, theCell,
|
|
dataOffset, dataLen, theList):
|
|
savedPort = Qd.GetPort()
|
|
Qd.SetPort(GetListPort(theList))
|
|
savedClip = Qd.NewRgn()
|
|
Qd.GetClip(savedClip)
|
|
Qd.ClipRect(cellRect)
|
|
savedPenState = Qd.GetPenState()
|
|
Qd.PenNormal()
|
|
Qd.PenMode(hilitetransfermode)
|
|
Qd.PaintRect(cellRect)
|
|
|
|
#restore graphics environment
|
|
Qd.SetPort(savedPort)
|
|
Qd.SetClip(savedClip)
|
|
Qd.DisposeRgn(savedClip)
|
|
Qd.SetPenState(savedPenState)
|
|
|
|
|
|
class ResultsWindow:
|
|
|
|
"""Simple results window. The user cannot make this window go away completely:
|
|
closing it will just hide it. It will remain in the windows list. The owner of this window
|
|
should call the done() method to indicate it's done with it.
|
|
"""
|
|
|
|
def __init__(self, possize=None, title="Results", callback=None):
|
|
import W
|
|
if possize is None:
|
|
possize = (500, 200)
|
|
self.w = W.Window(possize, title, minsize=(200, 100))
|
|
self.w.results = W.TwoLineList((-1, -1, 1, -14), callback=None)
|
|
self.w.bind("<close>", self.hide)
|
|
self.w.open()
|
|
self._done = 0
|
|
|
|
def done(self):
|
|
self._done = 1
|
|
if not self.w.isvisible():
|
|
self.w.close()
|
|
|
|
def hide(self):
|
|
if not self._done:
|
|
self.w.show(0)
|
|
return -1
|
|
|
|
def append(self, msg):
|
|
if not self.w.isvisible():
|
|
self.w.show(1)
|
|
self.w.select()
|
|
msg = string.replace(msg, '\n', '\r')
|
|
self.w.results.append(msg)
|
|
self.w.results.setselection([len(self.w.results)-1])
|
|
|
|
def __getattr__(self, attr):
|
|
return getattr(self.w.results, attr)
|
|
|
|
|
|
class MultiList(List):
|
|
|
|
"""XXX Experimantal!!!"""
|
|
|
|
def setitems(self, items):
|
|
self.items = items
|
|
if not self._parent or not self._list:
|
|
return
|
|
self._list.LDelRow(0, 1)
|
|
self.setdrawingmode(0)
|
|
self._list.LAddRow(len(self.items), 0)
|
|
self_itemrepr = self.itemrepr
|
|
set_cell = self._list.LSetCell
|
|
for i in range(len(items)):
|
|
row = items[i]
|
|
for j in range(len(row)):
|
|
item = row[j]
|
|
set_cell(self_itemrepr(item), (j, i))
|
|
self.setdrawingmode(1)
|
|
|
|
def getselection(self):
|
|
if not self._parent or not self._list:
|
|
if hasattr(self, "_sel"):
|
|
return self._sel
|
|
return []
|
|
items = []
|
|
point = (0,0)
|
|
while 1:
|
|
ok, point = self._list.LGetSelect(1, point)
|
|
if not ok:
|
|
break
|
|
items.append(point[1])
|
|
point = point[0], point[1]+1
|
|
return items
|
|
|
|
def setselection(self, selection):
|
|
if not self._parent or not self._list:
|
|
self._sel = selection
|
|
return
|
|
set_sel = self._list.LSetSelect
|
|
for i in range(len(self.items)):
|
|
if i in selection:
|
|
set_sel(1, (0, i))
|
|
else:
|
|
set_sel(0, (0, i))
|
|
#self._list.LAutoScroll()
|
|
|