# 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 os

import sys

from Tkinter import *

import imp

import ZoomHeight

from configHandler import idleConf

ICONDIR = "Icons"

# Look for Icons subdirectory in the same directory as this module

try:

    _icondir = os.path.join(os.path.dirname(__file__), ICONDIR)

except NameError:

    _icondir = ICONDIR

if os.path.isdir(_icondir):

    ICONDIR = _icondir

elif 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()