tree.py

# XXX TO DO:
# - popup menu
# - support partial or total redisplay
# - key bindings (instead of quick-n-dirty bindings on Canvas):
# - up/down arrow keys to move focus around
# - ditto for page up/down, home/end
# - left/right arrows to expand/collapse & move out/in
# - more doc strings
# - add icons for "file", "module", "class", "method"; better "python" icon
# - callback for selection???
# - multiple-item selection
# - tooltips
# - redo geometry without magic numbers
# - keep track of object ids to allow more careful cleaning
# - optimize tree redraw after expand of subnode

importos

fromtkinterimport*
fromtkinter.ttkimportFrame, Scrollbar

fromidlelib.configimportidleConf
fromidlelibimportzoomheight

ICONDIR="Icons"

# Look for Icons subdirectory in the same directory as this module
try:
_icondir=os.path.join(os.path.dirname(__file__), ICONDIR)
exceptNameError:
_icondir=ICONDIR
ifos.path.isdir(_icondir):
ICONDIR=_icondir
elifnotos.path.isdir(ICONDIR):
raiseRuntimeError(f"can't find icon directory ({ICONDIR!r})")

deflisticons(icondir=ICONDIR):
"""Utility to display the available icons."""
root=Tk()
importglob
list=glob.glob(os.path.join(glob.escape(icondir), "*.gif"))
list.sort()
images= []
row=column=0
forfileinlist:
name=os.path.splitext(os.path.basename(file))[0]
image=PhotoImage(file=file, master=root)
images.append(image)
label=Label(root, image=image, bd=1, relief="raised")
label.grid(row=row, column=column)
label=Label(root, text=name)
label.grid(row=row+1, column=column)
column=column+1
ifcolumn>=10:
row=row+2
column=0
root.images=images

defwheel_event(event, widget=None):
"""Handle scrollwheel event.

 For wheel up, event.delta = 120*n on Windows, -1*n on darwin,
 where n can be > 1 if one scrolls fast. Flicking the wheel
 generates up to maybe 20 events with n up to 10 or more 1.
 Macs use wheel down (delta = 1*n) to scroll up, so positive
 delta means to scroll up on both systems.

 X-11 sends Control-Button-4,5 events instead.

 The widget parameter is needed so browser label bindings can pass
 the underlying canvas.

 This function depends on widget.yview to not be overridden by
 a subclass.
 """
up= {EventType.MouseWheel: event.delta>0,
EventType.ButtonPress: event.num==4}
lines=-5ifup[event.type] else5
widget=event.widgetifwidgetisNoneelsewidget
widget.yview(SCROLL, lines, 'units')
return'break'


classTreeNode:

dy=0

def__init__(self, canvas, parent, item):
self.canvas=canvas
self.parent=parent
self.item=item
self.state='collapsed'
self.selected=False
self.children= []
self.x=self.y=None
self.iconimages= {} # cache of PhotoImage instances for icons

defdestroy(self):
forcinself.children[:]:
self.children.remove(c)
c.destroy()
self.parent=None

defgeticonimage(self, name):
try:
returnself.iconimages[name]
exceptKeyError:
pass
file, ext=os.path.splitext(name)
ext=extor".gif"
fullname=os.path.join(ICONDIR, file+ext)
image=PhotoImage(master=self.canvas, file=fullname)
self.iconimages[name] =image
returnimage

defselect(self, event=None):
ifself.selected:
return
self.deselectall()
self.selected=True
self.canvas.delete(self.image_id)
self.drawicon()
self.drawtext()

defdeselect(self, event=None):
ifnotself.selected:
return
self.selected=False
self.canvas.delete(self.image_id)
self.drawicon()
self.drawtext()

defdeselectall(self):
ifself.parent:
self.parent.deselectall()
else:
self.deselecttree()

defdeselecttree(self):
ifself.selected:
self.deselect()
forchildinself.children:
child.deselecttree()

defflip(self, event=None):
ifself.state=='expanded':
self.collapse()
else:
self.expand()
self.item.OnDoubleClick()
return"break"

defexpand(self, event=None):
ifnotself.item._IsExpandable():
return
ifself.state!='expanded':
self.state='expanded'
self.update()
self.view()

defcollapse(self, event=None):
ifself.state!='collapsed':
self.state='collapsed'
self.update()

defview(self):
top=self.y-2
bottom=self.lastvisiblechild().y+17
height=bottom-top
visible_top=self.canvas.canvasy(0)
visible_height=self.canvas.winfo_height()
visible_bottom=self.canvas.canvasy(visible_height)
ifvisible_top<=topandbottom<=visible_bottom:
return
x0, y0, x1, y1=self.canvas._getints(self.canvas['scrollregion'])
iftop>=visible_topandheight<=visible_height:
fraction=top+height-visible_height
else:
fraction=top
fraction=float(fraction) /y1
self.canvas.yview_moveto(fraction)

deflastvisiblechild(self):
ifself.childrenandself.state=='expanded':
returnself.children[-1].lastvisiblechild()
else:
returnself

defupdate(self):
ifself.parent:
self.parent.update()
else:
oldcursor=self.canvas['cursor']
self.canvas['cursor'] ="watch"
self.canvas.update()
self.canvas.delete(ALL) # XXX could be more subtle
self.draw(7, 2)
x0, y0, x1, y1=self.canvas.bbox(ALL)
self.canvas.configure(scrollregion=(0, 0, x1, y1))
self.canvas['cursor'] =oldcursor

defdraw(self, x, y):
# XXX This hard-codes too many geometry constants!
self.x, self.y=x, y
self.drawicon()
self.drawtext()
ifself.state!='expanded':
returny+TreeNode.dy
# draw children
ifnotself.children:
sublist=self.item._GetSubList()
ifnotsublist:
# _IsExpandable() was mistaken; that's allowed
returny+TreeNode.dy
foriteminsublist:
child=self.__class__(self.canvas, self, item)
self.children.append(child)
cx=x+20
cy=y+TreeNode.dy
cylast=0
forchildinself.children:
cylast=cy
self.canvas.create_line(x+9, cy+7, cx, cy+7, fill="gray50")
cy=child.draw(cx, cy)
ifchild.item._IsExpandable():
ifchild.state=='expanded':
iconname="minusnode"
callback=child.collapse
else:
iconname="plusnode"
callback=child.expand
image=self.geticonimage(iconname)
id=self.canvas.create_image(x+9, cylast+7, image=image)
# XXX This leaks bindings until canvas is deleted:
self.canvas.tag_bind(id, "<1>", callback)
self.canvas.tag_bind(id, "<Double-1>", lambdax: None)
id=self.canvas.create_line(x+9, y+10, x+9, cylast+7,
##stipple="gray50", # XXX Seems broken in Tk 8.0.x
fill="gray50")
self.canvas.tag_lower(id) # XXX .lower(id) before Python 1.5.2
returncy

defdrawicon(self):
ifself.selected:
imagename= (self.item.GetSelectedIconName() or
self.item.GetIconName() or
"openfolder")
else:
imagename=self.item.GetIconName() or"folder"
image=self.geticonimage(imagename)
id=self.canvas.create_image(self.x, self.y, anchor="nw", image=image)
self.image_id=id
self.canvas.tag_bind(id, "<1>", self.select)
self.canvas.tag_bind(id, "<Double-1>", self.flip)

defdrawtext(self):
textx=self.x+20-1
texty=self.y-4
labeltext=self.item.GetLabelText()
iflabeltext:
id=self.canvas.create_text(textx, texty, anchor="nw",
text=labeltext)
self.canvas.tag_bind(id, "<1>", self.select)
self.canvas.tag_bind(id, "<Double-1>", self.flip)
x0, y0, x1, y1=self.canvas.bbox(id)
textx=max(x1, 200) +10
text=self.item.GetText() or"<no text>"
try:
self.entry
exceptAttributeError:
pass
else:
self.edit_finish()
try:
self.label
exceptAttributeError:
# padding carefully selected (on Windows) to match Entry widget:
self.label=Label(self.canvas, text=text, bd=0, padx=2, pady=2)
theme=idleConf.CurrentTheme()
ifself.selected:
self.label.configure(idleConf.GetHighlight(theme, 'hilite'))
else:
self.label.configure(idleConf.GetHighlight(theme, 'normal'))
id=self.canvas.create_window(textx, texty,
anchor="nw", window=self.label)
self.label.bind("<1>", self.select_or_edit)
self.label.bind("<Double-1>", self.flip)
self.label.bind("<MouseWheel>", lambdae: wheel_event(e, self.canvas))
ifself.label._windowingsystem=='x11':
self.label.bind("<Button-4>", lambdae: wheel_event(e, self.canvas))
self.label.bind("<Button-5>", lambdae: wheel_event(e, self.canvas))
self.text_id=id
ifTreeNode.dy==0:
# The first row doesn't matter what the dy is, just measure its
# size to get the value of the subsequent dy
coords=self.canvas.bbox(id)
TreeNode.dy=max(20, coords[3] -coords[1] -3)

defselect_or_edit(self, event=None):
ifself.selectedandself.item.IsEditable():
self.edit(event)
else:
self.select(event)

defedit(self, event=None):
self.entry=Entry(self.label, bd=0, highlightthickness=1, width=0)
self.entry.insert(0, self.label['text'])
self.entry.selection_range(0, END)
self.entry.pack(ipadx=5)
self.entry.focus_set()
self.entry.bind("<Return>", self.edit_finish)
self.entry.bind("<Escape>", self.edit_cancel)

defedit_finish(self, event=None):
try:
entry=self.entry
delself.entry
exceptAttributeError:
return
text=entry.get()
entry.destroy()
iftextandtext!=self.item.GetText():
self.item.SetText(text)
text=self.item.GetText()
self.label['text'] =text
self.drawtext()
self.canvas.focus_set()

defedit_cancel(self, event=None):
try:
entry=self.entry
delself.entry
exceptAttributeError:
return
entry.destroy()
self.drawtext()
self.canvas.focus_set()


classTreeItem:

"""Abstract class representing tree items.

 Methods should typically be overridden, otherwise a default action
 is used.

 """

def__init__(self):
"""Constructor. Do whatever you need to do."""

defGetText(self):
"""Return text string to display."""

defGetLabelText(self):
"""Return label text string to display in front of text (if any)."""

expandable=None

def_IsExpandable(self):
"""Do not override! Called by TreeNode."""
ifself.expandableisNone:
self.expandable=self.IsExpandable()
returnself.expandable

defIsExpandable(self):
"""Return whether there are subitems."""
return1

def_GetSubList(self):
"""Do not override! Called by TreeNode."""
ifnotself.IsExpandable():
return []
sublist=self.GetSubList()
ifnotsublist:
self.expandable=0
returnsublist

defIsEditable(self):
"""Return whether the item's text may be edited."""

defSetText(self, text):
"""Change the item's text (if it is editable)."""

defGetIconName(self):
"""Return name of icon to be displayed normally."""

defGetSelectedIconName(self):
"""Return name of icon to be displayed when selected."""

defGetSubList(self):
"""Return list of items forming sublist."""

defOnDoubleClick(self):
"""Called on a double-click on the item."""


# Example application

classFileTreeItem(TreeItem):

"""Example TreeItem subclass -- browse the file system."""

def__init__(self, path):
self.path=path

defGetText(self):
returnos.path.basename(self.path) orself.path

defIsEditable(self):
returnos.path.basename(self.path) !=""

defSetText(self, text):
newpath=os.path.dirname(self.path)
newpath=os.path.join(newpath, text)
ifos.path.dirname(newpath) !=os.path.dirname(self.path):
return
try:
os.rename(self.path, newpath)
self.path=newpath
exceptOSError:
pass

defGetIconName(self):
ifnotself.IsExpandable():
return"python"# XXX wish there was a "file" icon

defIsExpandable(self):
returnos.path.isdir(self.path)

defGetSubList(self):
try:
names=os.listdir(self.path)
exceptOSError:
return []
names.sort(key=os.path.normcase)
sublist= []
fornameinnames:
item=FileTreeItem(os.path.join(self.path, name))
sublist.append(item)
returnsublist


# A canvas widget with scroll bars and some useful bindings

classScrolledCanvas:

def__init__(self, master, **opts):
if'yscrollincrement'notinopts:
opts['yscrollincrement'] =17
self.master=master
self.frame=Frame(master)
self.frame.rowconfigure(0, weight=1)
self.frame.columnconfigure(0, weight=1)
self.canvas=Canvas(self.frame, **opts)
self.canvas.grid(row=0, column=0, sticky="nsew")
self.vbar=Scrollbar(self.frame, name="vbar")
self.vbar.grid(row=0, column=1, sticky="nse")
self.hbar=Scrollbar(self.frame, name="hbar", orient="horizontal")
self.hbar.grid(row=1, column=0, sticky="ews")
self.canvas['yscrollcommand'] =self.vbar.set
self.vbar['command'] =self.canvas.yview
self.canvas['xscrollcommand'] =self.hbar.set
self.hbar['command'] =self.canvas.xview
self.canvas.bind("<Key-Prior>", self.page_up)
self.canvas.bind("<Key-Next>", self.page_down)
self.canvas.bind("<Key-Up>", self.unit_up)
self.canvas.bind("<Key-Down>", self.unit_down)
self.canvas.bind("<MouseWheel>", wheel_event)
ifself.canvas._windowingsystem=='x11':
self.canvas.bind("<Button-4>", wheel_event)
self.canvas.bind("<Button-5>", wheel_event)
#if isinstance(master, Toplevel) or isinstance(master, Tk):
self.canvas.bind("<Alt-Key-2>", self.zoom_height)
self.canvas.focus_set()
defpage_up(self, event):
self.canvas.yview_scroll(-1, "page")
return"break"
defpage_down(self, event):
self.canvas.yview_scroll(1, "page")
return"break"
defunit_up(self, event):
self.canvas.yview_scroll(-1, "unit")
return"break"
defunit_down(self, event):
self.canvas.yview_scroll(1, "unit")
return"break"
defzoom_height(self, event):
zoomheight.zoom_height(self.master)
return"break"


def_tree_widget(parent): # htest #
top=Toplevel(parent)
x, y=map(int, parent.geometry().split('+')[1:])
top.geometry("+%d+%d"% (x+50, y+175))
sc=ScrolledCanvas(top, bg="white", highlightthickness=0, takefocus=1)
sc.frame.pack(expand=1, fill="both", side=LEFT)
item=FileTreeItem(ICONDIR)
node=TreeNode(sc.canvas, None, item)
node.expand()


if__name__=='__main__':
fromunittestimportmain
main('idlelib.idle_test.test_tree', verbosity=2, exit=False)

fromidlelib.idle_test.htestimportrun
run(_tree_widget)