Issue #24225: Rename many idlelib/*.py and idlelib/idle_test/test_*.py files.

1 files changed, 0 insertions, 466 deletions

diff --git a/Lib/idlelib/TreeWidget.py b/Lib/idlelib/TreeWidget.py
deleted file mode 100644
index a19578f..0000000
--- a/Lib/idlelib/TreeWidget.py
+++ /dev/null
@@ -1,466 +0,0 @@
-# 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
-from tkinter import *
-
-from idlelib import ZoomHeight
-from idlelib.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!
-        dy = 20
-        self.x, self.y = x, y
-        self.drawicon()
-        self.drawtext()
-        if self.state != 'expanded':
-            return y + dy
-        # 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 + dy
-        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-4
-        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:
-            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.CurrentTheme()
-        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 OSError:
-            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 OSError:
-            return []
-        names.sort(key = os.path.normcase)
-        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 'yscrollincrement' not in opts:
-            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"
-
-
-def _tree_widget(parent):
-    root = Tk()
-    root.title("Test TreeWidget")
-    width, height, x, y = list(map(int, re.split('[x+]', parent.geometry())))
-    root.geometry("+%d+%d"%(x, y + 150))
-    sc = ScrolledCanvas(root, bg="white", highlightthickness=0, takefocus=1)
-    sc.frame.pack(expand=1, fill="both", side=LEFT)
-    item = FileTreeItem(os.getcwd())
-    node = TreeNode(sc.canvas, None, item)
-    node.expand()
-    root.mainloop()
-
-if __name__ == '__main__':
-    from idlelib.idle_test.htest import run
-    run(_tree_widget)