home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / TreeWidget.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  14.9 KB  |  478 lines
  1. # XXX TO DO:
  2. # - popup menu
  3. # - support partial or total redisplay
  4. # - key bindings (instead of quick-n-dirty bindings on Canvas):
  5. #   - up/down arrow keys to move focus around
  6. #   - ditto for page up/down, home/end
  7. #   - left/right arrows to expand/collapse & move out/in
  8. # - more doc strings
  9. # - add icons for "file", "module", "class", "method"; better "python" icon
  10. # - callback for selection???
  11. # - multiple-item selection
  12. # - tooltips
  13. # - redo geometry without magic numbers
  14. # - keep track of object ids to allow more careful cleaning
  15. # - optimize tree redraw after expand of subnode
  16.  
  17. import os
  18. from Tkinter import *
  19. import imp
  20.  
  21. import ZoomHeight
  22. from configHandler import idleConf
  23.  
  24. ICONDIR = "Icons"
  25.  
  26. # Look for Icons subdirectory in the same directory as this module
  27. try:
  28.     _icondir = os.path.join(os.path.dirname(__file__), ICONDIR)
  29. except NameError:
  30.     _icondir = ICONDIR
  31. if os.path.isdir(_icondir):
  32.     ICONDIR = _icondir
  33. elif not os.path.isdir(ICONDIR):
  34.     raise RuntimeError, "can't find icon directory (%r)" % (ICONDIR,)
  35.  
  36. def listicons(icondir=ICONDIR):
  37.     """Utility to display the available icons."""
  38.     root = Tk()
  39.     import glob
  40.     list = glob.glob(os.path.join(icondir, "*.gif"))
  41.     list.sort()
  42.     images = []
  43.     row = column = 0
  44.     for file in list:
  45.         name = os.path.splitext(os.path.basename(file))[0]
  46.         image = PhotoImage(file=file, master=root)
  47.         images.append(image)
  48.         label = Label(root, image=image, bd=1, relief="raised")
  49.         label.grid(row=row, column=column)
  50.         label = Label(root, text=name)
  51.         label.grid(row=row+1, column=column)
  52.         column = column + 1
  53.         if column >= 10:
  54.             row = row+2
  55.             column = 0
  56.     root.images = images
  57.  
  58.  
  59. class TreeNode:
  60.  
  61.     def __init__(self, canvas, parent, item):
  62.         self.canvas = canvas
  63.         self.parent = parent
  64.         self.item = item
  65.         self.state = 'collapsed'
  66.         self.selected = False
  67.         self.children = []
  68.         self.x = self.y = None
  69.         self.iconimages = {} # cache of PhotoImage instances for icons
  70.  
  71.     def destroy(self):
  72.         for c in self.children[:]:
  73.             self.children.remove(c)
  74.             c.destroy()
  75.         self.parent = None
  76.  
  77.     def geticonimage(self, name):
  78.         try:
  79.             return self.iconimages[name]
  80.         except KeyError:
  81.             pass
  82.         file, ext = os.path.splitext(name)
  83.         ext = ext or ".gif"
  84.         fullname = os.path.join(ICONDIR, file + ext)
  85.         image = PhotoImage(master=self.canvas, file=fullname)
  86.         self.iconimages[name] = image
  87.         return image
  88.  
  89.     def select(self, event=None):
  90.         if self.selected:
  91.             return
  92.         self.deselectall()
  93.         self.selected = True
  94.         self.canvas.delete(self.image_id)
  95.         self.drawicon()
  96.         self.drawtext()
  97.  
  98.     def deselect(self, event=None):
  99.         if not self.selected:
  100.             return
  101.         self.selected = False
  102.         self.canvas.delete(self.image_id)
  103.         self.drawicon()
  104.         self.drawtext()
  105.  
  106.     def deselectall(self):
  107.         if self.parent:
  108.             self.parent.deselectall()
  109.         else:
  110.             self.deselecttree()
  111.  
  112.     def deselecttree(self):
  113.         if self.selected:
  114.             self.deselect()
  115.         for child in self.children:
  116.             child.deselecttree()
  117.  
  118.     def flip(self, event=None):
  119.         if self.state == 'expanded':
  120.             self.collapse()
  121.         else:
  122.             self.expand()
  123.         self.item.OnDoubleClick()
  124.         return "break"
  125.  
  126.     def expand(self, event=None):
  127.         if not self.item._IsExpandable():
  128.             return
  129.         if self.state != 'expanded':
  130.             self.state = 'expanded'
  131.             self.update()
  132.             self.view()
  133.  
  134.     def collapse(self, event=None):
  135.         if self.state != 'collapsed':
  136.             self.state = 'collapsed'
  137.             self.update()
  138.  
  139.     def view(self):
  140.         top = self.y - 2
  141.         bottom = self.lastvisiblechild().y + 17
  142.         height = bottom - top
  143.         visible_top = self.canvas.canvasy(0)
  144.         visible_height = self.canvas.winfo_height()
  145.         visible_bottom = self.canvas.canvasy(visible_height)
  146.         if visible_top <= top and bottom <= visible_bottom:
  147.             return
  148.         x0, y0, x1, y1 = self.canvas._getints(self.canvas['scrollregion'])
  149.         if top >= visible_top and height <= visible_height:
  150.             fraction = top + height - visible_height
  151.         else:
  152.             fraction = top
  153.         fraction = float(fraction) / y1
  154.         self.canvas.yview_moveto(fraction)
  155.  
  156.     def lastvisiblechild(self):
  157.         if self.children and self.state == 'expanded':
  158.             return self.children[-1].lastvisiblechild()
  159.         else:
  160.             return self
  161.  
  162.     def update(self):
  163.         if self.parent:
  164.             self.parent.update()
  165.         else:
  166.             oldcursor = self.canvas['cursor']
  167.             self.canvas['cursor'] = "watch"
  168.             self.canvas.update()
  169.             self.canvas.delete(ALL)     # XXX could be more subtle
  170.             self.draw(7, 2)
  171.             x0, y0, x1, y1 = self.canvas.bbox(ALL)
  172.             self.canvas.configure(scrollregion=(0, 0, x1, y1))
  173.             self.canvas['cursor'] = oldcursor
  174.  
  175.     def draw(self, x, y):
  176.         # XXX This hard-codes too many geometry constants!
  177.         self.x, self.y = x, y
  178.         self.drawicon()
  179.         self.drawtext()
  180.         if self.state != 'expanded':
  181.             return y+17
  182.         # draw children
  183.         if not self.children:
  184.             sublist = self.item._GetSubList()
  185.             if not sublist:
  186.                 # _IsExpandable() was mistaken; that's allowed
  187.                 return y+17
  188.             for item in sublist:
  189.                 child = self.__class__(self.canvas, self, item)
  190.                 self.children.append(child)
  191.         cx = x+20
  192.         cy = y+17
  193.         cylast = 0
  194.         for child in self.children:
  195.             cylast = cy
  196.             self.canvas.create_line(x+9, cy+7, cx, cy+7, fill="gray50")
  197.             cy = child.draw(cx, cy)
  198.             if child.item._IsExpandable():
  199.                 if child.state == 'expanded':
  200.                     iconname = "minusnode"
  201.                     callback = child.collapse
  202.                 else:
  203.                     iconname = "plusnode"
  204.                     callback = child.expand
  205.                 image = self.geticonimage(iconname)
  206.                 id = self.canvas.create_image(x+9, cylast+7, image=image)
  207.                 # XXX This leaks bindings until canvas is deleted:
  208.                 self.canvas.tag_bind(id, "<1>", callback)
  209.                 self.canvas.tag_bind(id, "<Double-1>", lambda x: None)
  210.         id = self.canvas.create_line(x+9, y+10, x+9, cylast+7,
  211.             ##stipple="gray50",     # XXX Seems broken in Tk 8.0.x
  212.             fill="gray50")
  213.         self.canvas.tag_lower(id) # XXX .lower(id) before Python 1.5.2
  214.         return cy
  215.  
  216.     def drawicon(self):
  217.         if self.selected:
  218.             imagename = (self.item.GetSelectedIconName() or
  219.                          self.item.GetIconName() or
  220.                          "openfolder")
  221.         else:
  222.             imagename = self.item.GetIconName() or "folder"
  223.         image = self.geticonimage(imagename)
  224.         id = self.canvas.create_image(self.x, self.y, anchor="nw", image=image)
  225.         self.image_id = id
  226.         self.canvas.tag_bind(id, "<1>", self.select)
  227.         self.canvas.tag_bind(id, "<Double-1>", self.flip)
  228.  
  229.     def drawtext(self):
  230.         textx = self.x+20-1
  231.         texty = self.y-1
  232.         labeltext = self.item.GetLabelText()
  233.         if labeltext:
  234.             id = self.canvas.create_text(textx, texty, anchor="nw",
  235.                                          text=labeltext)
  236.             self.canvas.tag_bind(id, "<1>", self.select)
  237.             self.canvas.tag_bind(id, "<Double-1>", self.flip)
  238.             x0, y0, x1, y1 = self.canvas.bbox(id)
  239.             textx = max(x1, 200) + 10
  240.         text = self.item.GetText() or "<no text>"
  241.         try:
  242.             self.entry
  243.         except AttributeError:
  244.             pass
  245.         else:
  246.             self.edit_finish()
  247.         try:
  248.             label = self.label
  249.         except AttributeError:
  250.             # padding carefully selected (on Windows) to match Entry widget:
  251.             self.label = Label(self.canvas, text=text, bd=0, padx=2, pady=2)
  252.         theme = idleConf.GetOption('main','Theme','name')
  253.         if self.selected:
  254.             self.label.configure(idleConf.GetHighlight(theme, 'hilite'))
  255.         else:
  256.             self.label.configure(idleConf.GetHighlight(theme, 'normal'))
  257.         id = self.canvas.create_window(textx, texty,
  258.                                        anchor="nw", window=self.label)
  259.         self.label.bind("<1>", self.select_or_edit)
  260.         self.label.bind("<Double-1>", self.flip)
  261.         self.text_id = id
  262.  
  263.     def select_or_edit(self, event=None):
  264.         if self.selected and self.item.IsEditable():
  265.             self.edit(event)
  266.         else:
  267.             self.select(event)
  268.  
  269.     def edit(self, event=None):
  270.         self.entry = Entry(self.label, bd=0, highlightthickness=1, width=0)
  271.         self.entry.insert(0, self.label['text'])
  272.         self.entry.selection_range(0, END)
  273.         self.entry.pack(ipadx=5)
  274.         self.entry.focus_set()
  275.         self.entry.bind("<Return>", self.edit_finish)
  276.         self.entry.bind("<Escape>", self.edit_cancel)
  277.  
  278.     def edit_finish(self, event=None):
  279.         try:
  280.             entry = self.entry
  281.             del self.entry
  282.         except AttributeError:
  283.             return
  284.         text = entry.get()
  285.         entry.destroy()
  286.         if text and text != self.item.GetText():
  287.             self.item.SetText(text)
  288.         text = self.item.GetText()
  289.         self.label['text'] = text
  290.         self.drawtext()
  291.         self.canvas.focus_set()
  292.  
  293.     def edit_cancel(self, event=None):
  294.         try:
  295.             entry = self.entry
  296.             del self.entry
  297.         except AttributeError:
  298.             return
  299.         entry.destroy()
  300.         self.drawtext()
  301.         self.canvas.focus_set()
  302.  
  303.  
  304. class TreeItem:
  305.  
  306.     """Abstract class representing tree items.
  307.  
  308.     Methods should typically be overridden, otherwise a default action
  309.     is used.
  310.  
  311.     """
  312.  
  313.     def __init__(self):
  314.         """Constructor.  Do whatever you need to do."""
  315.  
  316.     def GetText(self):
  317.         """Return text string to display."""
  318.  
  319.     def GetLabelText(self):
  320.         """Return label text string to display in front of text (if any)."""
  321.  
  322.     expandable = None
  323.  
  324.     def _IsExpandable(self):
  325.         """Do not override!  Called by TreeNode."""
  326.         if self.expandable is None:
  327.             self.expandable = self.IsExpandable()
  328.         return self.expandable
  329.  
  330.     def IsExpandable(self):
  331.         """Return whether there are subitems."""
  332.         return 1
  333.  
  334.     def _GetSubList(self):
  335.         """Do not override!  Called by TreeNode."""
  336.         if not self.IsExpandable():
  337.             return []
  338.         sublist = self.GetSubList()
  339.         if not sublist:
  340.             self.expandable = 0
  341.         return sublist
  342.  
  343.     def IsEditable(self):
  344.         """Return whether the item's text may be edited."""
  345.  
  346.     def SetText(self, text):
  347.         """Change the item's text (if it is editable)."""
  348.  
  349.     def GetIconName(self):
  350.         """Return name of icon to be displayed normally."""
  351.  
  352.     def GetSelectedIconName(self):
  353.         """Return name of icon to be displayed when selected."""
  354.  
  355.     def GetSubList(self):
  356.         """Return list of items forming sublist."""
  357.  
  358.     def OnDoubleClick(self):
  359.         """Called on a double-click on the item."""
  360.  
  361.  
  362. # Example application
  363.  
  364. class FileTreeItem(TreeItem):
  365.  
  366.     """Example TreeItem subclass -- browse the file system."""
  367.  
  368.     def __init__(self, path):
  369.         self.path = path
  370.  
  371.     def GetText(self):
  372.         return os.path.basename(self.path) or self.path
  373.  
  374.     def IsEditable(self):
  375.         return os.path.basename(self.path) != ""
  376.  
  377.     def SetText(self, text):
  378.         newpath = os.path.dirname(self.path)
  379.         newpath = os.path.join(newpath, text)
  380.         if os.path.dirname(newpath) != os.path.dirname(self.path):
  381.             return
  382.         try:
  383.             os.rename(self.path, newpath)
  384.             self.path = newpath
  385.         except os.error:
  386.             pass
  387.  
  388.     def GetIconName(self):
  389.         if not self.IsExpandable():
  390.             return "python" # XXX wish there was a "file" icon
  391.  
  392.     def IsExpandable(self):
  393.         return os.path.isdir(self.path)
  394.  
  395.     def GetSubList(self):
  396.         try:
  397.             names = os.listdir(self.path)
  398.         except os.error:
  399.             return []
  400.         names.sort(lambda a, b: cmp(os.path.normcase(a), os.path.normcase(b)))
  401.         sublist = []
  402.         for name in names:
  403.             item = FileTreeItem(os.path.join(self.path, name))
  404.             sublist.append(item)
  405.         return sublist
  406.  
  407.  
  408. # A canvas widget with scroll bars and some useful bindings
  409.  
  410. class ScrolledCanvas:
  411.     def __init__(self, master, **opts):
  412.         if not opts.has_key('yscrollincrement'):
  413.             opts['yscrollincrement'] = 17
  414.         self.master = master
  415.         self.frame = Frame(master)
  416.         self.frame.rowconfigure(0, weight=1)
  417.         self.frame.columnconfigure(0, weight=1)
  418.         self.canvas = Canvas(self.frame, **opts)
  419.         self.canvas.grid(row=0, column=0, sticky="nsew")
  420.         self.vbar = Scrollbar(self.frame, name="vbar")
  421.         self.vbar.grid(row=0, column=1, sticky="nse")
  422.         self.hbar = Scrollbar(self.frame, name="hbar", orient="horizontal")
  423.         self.hbar.grid(row=1, column=0, sticky="ews")
  424.         self.canvas['yscrollcommand'] = self.vbar.set
  425.         self.vbar['command'] = self.canvas.yview
  426.         self.canvas['xscrollcommand'] = self.hbar.set
  427.         self.hbar['command'] = self.canvas.xview
  428.         self.canvas.bind("<Key-Prior>", self.page_up)
  429.         self.canvas.bind("<Key-Next>", self.page_down)
  430.         self.canvas.bind("<Key-Up>", self.unit_up)
  431.         self.canvas.bind("<Key-Down>", self.unit_down)
  432.         #if isinstance(master, Toplevel) or isinstance(master, Tk):
  433.         self.canvas.bind("<Alt-Key-2>", self.zoom_height)
  434.         self.canvas.focus_set()
  435.     def page_up(self, event):
  436.         self.canvas.yview_scroll(-1, "page")
  437.         return "break"
  438.     def page_down(self, event):
  439.         self.canvas.yview_scroll(1, "page")
  440.         return "break"
  441.     def unit_up(self, event):
  442.         self.canvas.yview_scroll(-1, "unit")
  443.         return "break"
  444.     def unit_down(self, event):
  445.         self.canvas.yview_scroll(1, "unit")
  446.         return "break"
  447.     def zoom_height(self, event):
  448.         ZoomHeight.zoom_height(self.master)
  449.         return "break"
  450.  
  451.  
  452. # Testing functions
  453.  
  454. def test():
  455.     import PyShell
  456.     root = Toplevel(PyShell.root)
  457.     root.configure(bd=0, bg="yellow")
  458.     root.focus_set()
  459.     sc = ScrolledCanvas(root, bg="white", highlightthickness=0, takefocus=1)
  460.     sc.frame.pack(expand=1, fill="both")
  461.     item = FileTreeItem("C:/windows/desktop")
  462.     node = TreeNode(sc.canvas, None, item)
  463.     node.expand()
  464.  
  465. def test2():
  466.     # test w/o scrolling canvas
  467.     root = Tk()
  468.     root.configure(bd=0)
  469.     canvas = Canvas(root, bg="white", highlightthickness=0)
  470.     canvas.pack(expand=1, fill="both")
  471.     item = FileTreeItem(os.curdir)
  472.     node = TreeNode(canvas, None, item)
  473.     node.update()
  474.     canvas.focus_set()
  475.  
  476. if __name__ == '__main__':
  477.     test()
  478.