# 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 import osimport sysfrom Tkinter import *import imp import ZoomHeightfrom configHandler import idleConf ICONDIR = "Icons" # Look for Icons subdirectory in the same directory as this moduletry:    _icondir = os.path.join(os.path.dirname(__file__), ICONDIR)except NameError:    _icondir = ICONDIRif os.path.isdir(_icondir):    ICONDIR = _icondirelif not os.path.isdir(ICONDIR):    raise RuntimeError, "can't find icon directory (%r)" % (ICONDIR,) def listicons(icondir=ICONDIR):    """Utility to display the available icons."""    root = Tk()    import glob    list = glob.glob(os.path.join(icondir, "*.gif"))    list.sort()    images = []    row = column = 0    for file in list:        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        if column >= 10:            row = row+2            column = 0    root.images = images  class TreeNode:     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     def destroy(self):        for c in self.children[:]:            self.children.remove(c)            c.destroy()        self.parent = None     def geticonimage(self, name):        try:            return self.iconimages[name]        except KeyError:            pass        file, ext = os.path.splitext(name)        ext = ext or ".gif"        fullname = os.path.join(ICONDIR, file + ext)        image = PhotoImage(master=self.canvas, file=fullname)        self.iconimages[name] = image        return image     def select(self, event=None):        if self.selected:            return        self.deselectall()        self.selected = True        self.canvas.delete(self.image_id)        self.drawicon()        self.drawtext()     def deselect(self, event=None):        if not self.selected:            return        self.selected = False        self.canvas.delete(self.image_id)        self.drawicon()        self.drawtext()     def deselectall(self):        if self.parent:            self.parent.deselectall()        else:            self.deselecttree()     def deselecttree(self):        if self.selected:            self.deselect()        for child in self.children:            child.deselecttree()     def flip(self, event=None):        if self.state == 'expanded':            self.collapse()        else:            self.expand()        self.item.OnDoubleClick()        return "break"     def expand(self, event=None):        if not self.item._IsExpandable():            return        if self.state != 'expanded':            self.state = 'expanded'            self.update()            self.view()     def collapse(self, event=None):        if self.state != 'collapsed':            self.state = 'collapsed'            self.update()     def view(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)        if visible_top <= top and bottom <= visible_bottom:            return        x0, y0, x1, y1 = self.canvas._getints(self.canvas['scrollregion'])        if top >= visible_top and height <= visible_height:            fraction = top + height - visible_height        else:            fraction = top        fraction = float(fraction) / y1        self.canvas.yview_moveto(fraction)     def lastvisiblechild(self):        if self.children and self.state == 'expanded':            return self.children[-1].lastvisiblechild()        else:            return self     def update(self):        if self.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     def draw(self, x, y):        # XXX This hard-codes too many geometry constants!        self.x, self.y = x, y        self.drawicon()        self.drawtext()        if self.state != 'expanded':            return y+17        # draw children        if not self.children:            sublist = self.item._GetSubList()            if not sublist:                # _IsExpandable() was mistaken; that's allowed                return y+17            for item in sublist:                child = self.__class__(self.canvas, self, item)                self.children.append(child)        cx = x+20        cy = y+17        cylast = 0        for child in self.children:            cylast = cy            self.canvas.create_line(x+9, cy+7, cx, cy+7, fill="gray50")            cy = child.draw(cx, cy)            if child.item._IsExpandable():                if child.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>", lambda x: 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        return cy     def drawicon(self):        if self.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)     def drawtext(self):        textx = self.x+20-1        texty = self.y-1        labeltext = self.item.GetLabelText()        if labeltext:            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        except AttributeError:            pass        else:            self.edit_finish()        try:            label = self.label        except AttributeError:            # padding carefully selected (on Windows) to match Entry widget:            self.label = Label(self.canvas, text=text, bd=0, padx=2, pady=2)        theme = idleConf.GetOption('main','Theme','name')        if self.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.text_id = id     def select_or_edit(self, event=None):        if self.selected and self.item.IsEditable():            self.edit(event)        else:            self.select(event)     def edit(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)     def edit_finish(self, event=None):        try:            entry = self.entry            del self.entry        except AttributeError:            return        text = entry.get()        entry.destroy()        if text and text != self.item.GetText():            self.item.SetText(text)        text = self.item.GetText()        self.label['text'] = text        self.drawtext()        self.canvas.focus_set()     def edit_cancel(self, event=None):        try:            entry = self.entry            del self.entry        except AttributeError:            return        entry.destroy()        self.drawtext()        self.canvas.focus_set()  class TreeItem:     """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."""     def GetText(self):        """Return text string to display."""     def GetLabelText(self):        """Return label text string to display in front of text (if any)."""     expandable = None     def _IsExpandable(self):        """Do not override!  Called by TreeNode."""        if self.expandable is None:            self.expandable = self.IsExpandable()        return self.expandable     def IsExpandable(self):        """Return whether there are subitems."""        return 1     def _GetSubList(self):        """Do not override!  Called by TreeNode."""        if not self.IsExpandable():            return []        sublist = self.GetSubList()        if not sublist:            self.expandable = 0        return sublist     def IsEditable(self):        """Return whether the item's text may be edited."""     def SetText(self, text):        """Change the item's text (if it is editable)."""     def GetIconName(self):        """Return name of icon to be displayed normally."""     def GetSelectedIconName(self):        """Return name of icon to be displayed when selected."""     def GetSubList(self):        """Return list of items forming sublist."""     def OnDoubleClick(self):        """Called on a double-click on the item."""  # Example application class FileTreeItem(TreeItem):     """Example TreeItem subclass -- browse the file system."""     def __init__(self, path):        self.path = path     def GetText(self):        return os.path.basename(self.path) or self.path     def IsEditable(self):        return os.path.basename(self.path) != ""     def SetText(self, text):        newpath = os.path.dirname(self.path)        newpath = os.path.join(newpath, text)        if os.path.dirname(newpath) != os.path.dirname(self.path):            return        try:            os.rename(self.path, newpath)            self.path = newpath        except os.error:            pass     def GetIconName(self):        if not self.IsExpandable():            return "python" # XXX wish there was a "file" icon     def IsExpandable(self):        return os.path.isdir(self.path)     def GetSubList(self):        try:            names = os.listdir(self.path)        except os.error:            return []        names.sort(lambda a, b: cmp(os.path.normcase(a), os.path.normcase(b)))        sublist = []        for name in names:            item = FileTreeItem(os.path.join(self.path, name))            sublist.append(item)        return sublist  # A canvas widget with scroll bars and some useful bindings class ScrolledCanvas:    def __init__(self, master, **opts):        if not opts.has_key('yscrollincrement'):            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)        #if isinstance(master, Toplevel) or isinstance(master, Tk):        self.canvas.bind("<Alt-Key-2>", self.zoom_height)        self.canvas.focus_set()    def page_up(self, event):        self.canvas.yview_scroll(-1, "page")        return "break"    def page_down(self, event):        self.canvas.yview_scroll(1, "page")        return "break"    def unit_up(self, event):        self.canvas.yview_scroll(-1, "unit")        return "break"    def unit_down(self, event):        self.canvas.yview_scroll(1, "unit")        return "break"    def zoom_height(self, event):        ZoomHeight.zoom_height(self.master)        return "break"  # Testing functions def test():    import PyShell    root = Toplevel(PyShell.root)    root.configure(bd=0, bg="yellow")    root.focus_set()    sc = ScrolledCanvas(root, bg="white", highlightthickness=0, takefocus=1)    sc.frame.pack(expand=1, fill="both")    item = FileTreeItem("C:/windows/desktop")    node = TreeNode(sc.canvas, None, item)    node.expand() def test2():    # test w/o scrolling canvas    root = Tk()    root.configure(bd=0)    canvas = Canvas(root, bg="white", highlightthickness=0)    canvas.pack(expand=1, fill="both")    item = FileTreeItem(os.curdir)    node = TreeNode(canvas, None, item)    node.update()    canvas.focus_set() if __name__ == '__main__':    test()