Made into a module, updated

1 files changed, 549 insertions, 0 deletions

diff --git a/fileTreeBrowser.py b/fileTreeBrowser.py
new file mode 100644
index 0000000..162c981
--- /dev/null
+++ b/fileTreeBrowser.py
@@ -0,0 +1,549 @@
+from glob import glob
+from operator import itemgetter
+import tkinter as tk
+from tkinter import ttk
+from tkinter import messagebox
+from PIL import Image, ImageTk
+import win32api
+import os
+
+from . import windowsIcons
+
+MENU_DELETE = "menu_delete"
+MENU_OPEN = "open"
+MENU_CLIPBOARD = "clipboard"
+ALL = [MENU_DELETE, MENU_OPEN, MENU_CLIPBOARD]
+
+class TkFileBrowser(tk.Frame):
+
+    _open = []
+
+    def __init__(self, parent, command, rightclick_options = ALL, refresh = 20, types = [], showhidden = False):
+        """Widget for browsing a windows filesystem.
+        
+        Arguments:
+            parent {tk.Frame} -- parent frame
+            command {function} -- Called when the user clicks on a file
+        
+        Keyword Arguments:
+            rightclick_options {list} -- the options to show up in the menu when the user right
+            clicks. Choose from [MENU_DELETE, MENU_OPEN, MENU_CLIPBOARD] or just use ALL (default: ALL)
+            refresh {int} -- how often to refresh browser (ms) (default: {20})
+            types {list} -- file types that show up. Leave blank for all files: e
+                e.g. [".png", ".jpg"] (default: {[]})
+            showhiddem {bool} -- should the tree show hidden files or not (default: {False})
+        """
+
+        tk.Frame.__init__(self, parent)
+        self._parent = parent
+        self._command = command
+        self._rightclick_options = rightclick_options
+        self._refresh = refresh
+        self._types = types
+        self._showhidden = showhidden
+
+        self._img_clipboard = tk.PhotoImage(file = os.path.join(os.path.dirname(__file__), "Assets", "clipboard.png"))
+        self._img_cross = tk.PhotoImage(file = os.path.join(os.path.dirname(__file__), "Assets", "cross.png"))
+
+        self._book = DriveBook(self)
+        self._book.pack(fill = tk.BOTH, expand = True)
+        self.after(self._refresh, self.refresh)
+
+    #TODO: fix a bug here
+    def see(self, path):
+        """Open the tree and book to this folder
+        
+        Arguments:
+            path {str} -- path to open to
+        """
+        if not os.path.exists(path):
+            print("The system couldn't find the path: '%s'" % path)
+            return
+
+        #open the correct book tab
+        split = path.replace("\\", "/").split("/")
+
+        #if requested is file, go to the folder in which it's in
+        if os.path.isfile(path):
+            del split[-1]
+        
+        drive = split[0] + "\\"
+        self._book.select(self._book._get_drives().index(drive))
+
+        try:
+            self._book._tabs[drive]._tree.see("\\".join(split))
+        except tk.TclError:
+            #the node probably isn't loaded yet so we have to make it load before
+            #using .see()
+            for i in range(len(split) - 1):
+                self._book._tabs[drive]._populate_path("\\".join(split[:i+2]))
+                self._book._tabs[drive]._tree.item("\\".join(split[:i+2]), open = True)
+                
+                #add to list of open nodes
+                self._open.append([split[0]+"\\", "\\".join(split[:i+2])])
+
+            self._book._tabs[drive]._tree.see("\\".join(split))
+
+    def refresh(self):
+        def get_drive_and_path(search):
+            out = []
+            for i in self._open:
+                if i[1] == search:
+                    out.append(i)
+            return out
+
+        self._book._refresh()
+
+        print(self._open)
+
+        #work out which open nodes need to be updated
+        nodes_to_refresh = []
+        for i in self._open:
+            dir = i[1]
+            if not os.path.exists(dir):
+                continue
+            #work out all the dirs that the node is showing, ignoring the dummy by checking for paths
+            childirs = [p.split("\\")[-1] for p in self._book._tabs[i[0]]._tree.get_children(dir) if "\\" in p]
+            
+            #work out all the dirs that are in the file system. Use our own method so that settings
+            #are still here, show hidden files, etc.
+            files, folders = self._book._tabs[i[0]]._get_dirs_in_path(dir)
+            actualdirs = files + folders
+
+            if actualdirs != childirs:
+                nodes_to_refresh.append(dir)
+
+
+        #add drives to the list of stuff to check for updates
+        for drive in self._book._get_drives():
+            childirs = [p.split("\\")[-1] for p in self._book._tabs[drive]._tree.get_children("")]
+            files, folders = self._book._tabs[drive]._get_dirs_in_path(drive)
+            actualdirs = files + folders
+            if actualdirs != childirs:
+                nodes_to_refresh.append(drive)
+
+        #print(nodes_to_refresh)
+
+        drive_and_node = []
+        for node in nodes_to_refresh:
+            for drive, node1 in get_drive_and_path(node):
+
+                orignode = node1
+                if node1 == drive:
+                    node1 = ""
+
+                #print("node: ", node1, "\ndrive: ", drive)
+                tree = self._book._tabs[drive]._tree
+                children = tree.get_children(node1)
+
+                #get the full path of removals and additons
+                glob_pattern = os.path.join(orignode, "*")
+                deletions = list(set(list(children)) - set(sorted(glob(glob_pattern), key=os.path.getctime)))
+                additions = list(set(sorted(glob(glob_pattern), key=os.path.getctime)) - set(list(children)))
+
+                #print("deletions: ", deletions, "\nadditions: ", additions)
+
+                #delete from tree
+                for deletion in deletions:
+                    tree.delete(deletion)
+                    #if the node is open, and it's just been deleteted, remove it from the list
+                    if [drive.replace("\\", "\\"), deletion.replace("\\", "\\")] in self._open:
+                        self._open.remove([drive.replace("\\", "\\"), deletion.replace("\\", "\\")])
+
+                #add new entries in the correct place, highlighting them and getting appropitate icons
+                for addition in additions:
+
+                    if os.path.isdir(addition):
+                        #make an icon if it doesn't already exist
+                        if addition not in self._book._foldericons:
+                            self._book._foldericons[addition] = ImageTk.PhotoImage(
+                                self._get_icon(addition))
+
+                        #get the name
+                        folder = addition.split("\\")[-1]
+                        #work out all the other folders so we know an approprate place to put the new folder
+                        glob_pattern = os.path.join(orignode, "*")
+                        folders = [i for i in sorted(glob(glob_pattern), key=os.path.getctime) if os.path.isdir(i)]
+
+                        tree.insert(
+                            parent = node, 
+                            index = folders.index(addition), #insert in an appropriate place
+                            iid = addition,
+                            tags = (addition, ),
+                            text = folder,
+                            image = self._book._foldericons[addition],
+                            values = [folder, "", ""])
+                        #setup a dummy so the '+' appears before it's loaded. Child stuff will be loaded when the user
+                        #clicks on the plus, and the dummy will be removed. (or not if there are no files)
+                        tree.insert(parent = addition, index = tk.END, tag = "dummy", text = "No avaliable files")
+
+                    elif os.path.isfile(addition):
+                        _, type_ = os.path.splitext(addition)
+        
+                        if type_ == ".lnk" or type_ == ".exe":
+                            if addition not in self._book._fileicons:
+                                self._book._fileicons[addition] = ImageTk.PhotoImage(
+                                    self._get_icon(addition)
+                                )
+                            icon = self._book._fileicons[addition]
+                        else:
+                            if type_ not in self._book._fileicons:
+                                self._book._fileicons[type_] = ImageTk.PhotoImage(
+                                    self._get_icon(type_)
+                                )
+                            icon = self._book._fileicons[type_]
+
+                        file = addition.split("\\")[-1]
+                        tree.insert(
+                            parent = node, 
+                            index = tk.END, 
+                            iid = addition,
+                            tags = (addition, ),
+                            text = file,
+                            image = icon,
+                            values = [file, "", self._book._tabs[drive]._get_size(addition)])
+                
+                    #highlight
+                    tree.tag_configure(addition, background = "orange")
+
+        self.after(self._refresh, self.refresh)
+
+    def _get_icon(self, PATH):
+        """Gets the icon association for any folder or file in the system
+        
+        Arguments:
+            PATH {str} -- path to file or folder
+        
+        Raises:
+            TypeError -- Thrown if invalid arguments are given
+        
+        Returns:
+            PIL.Image -- PIL Image of the icon at the correct size
+        """
+
+        #https://stackoverflow.com/questions/21070423/python-sAaving-accessing-file-extension-icons-and-using-them-in-a-tkinter-progra/52957794#52957794
+        #https://aecomputervision.blogspot.com/2018/10/getting-icon-association-for-any-file.html
+        return windowsIcons.get_icon(PATH, windowsIcons.SMALL)
+        
+class DriveBook(ttk.Notebook):
+
+    _foldericons = {}
+    _fileicons = {}
+    _tabs = {}
+
+    def __init__(self, parent):
+        ttk.Notebook.__init__(self)
+        self._parent = parent
+
+        self._draw_tabs()
+
+    def _draw_tabs(self):
+        self._drive_icons = self._get_icons()   #store to attribute so it doesn't get removed by garbage deletion
+        for drive in self._drive_icons:
+            self._tabs[drive[0]] = FileTree(self, drive[0])
+            if os.path.split(drive[0])[1] != "":
+                self.add(self._tabs[drive[0]], text = "Home", image = drive[1], compound = tk.LEFT)
+            else:
+                self.add(self._tabs[drive[0]], text = drive[0], image = drive[1], compound = tk.LEFT)
+
+    def _refresh(self):
+        """Checks if a drive as been added or removed. If it has, tabs are refreshed.
+        """
+
+        #check if we need to refresh before refreshing
+        if list(map(itemgetter(0), self._drive_icons)) != self._get_drives():
+            display = [i[0] for i in self._drive_icons]
+            new = self._get_drives()
+
+            removals = list(set(display).difference(new))
+            additions = list(set(new).difference(display))
+
+            print("removed: ", removals, "added: ", additions)
+            
+            for removal in removals:
+                #delete open nodes that have just been removed
+                self._parent._open = [i for i in self._parent._open if i[0] != removal]
+
+                #deelte the tab
+                try:
+                    self.forget(self._tabs[removal])
+                except tk.TclError:
+                    #TODO: work out why this throws an error when it still works
+                    pass
+
+                #remove from tab dictionary
+                del self._tabs[removal]
+
+                #reset drive icons
+                self._drive_icons = [i for i in self._drive_icons if i[0] != removal]
+
+            for addition in additions:
+                self._drive_icons.append([addition, ImageTk.PhotoImage(self._parent._get_icon(addition))])
+                self._tabs[addition] = FileTree(self, addition)
+                self.add(self._tabs[addition], text = addition, image = self._drive_icons[-1][1], compound = tk.LEFT)
+
+    def _get_drives(self):
+        return [os.path.expanduser("~")] + win32api.GetLogicalDriveStrings().split('\x00')[:-1]
+
+    def _get_icons(self):
+        drives = self._get_drives()
+        return [[drive, ImageTk.PhotoImage(self._parent._get_icon(drive))] for drive in drives]
+
+    def _get_tab_name(self):
+        """Returns the name of the tab which is currently open
+        
+        Returns:
+            int -- the name of the tab that's currently open e.g. C:\\, C:\\Users\\Fred
+        """
+
+        return self._get_drives()[self.index(self.select())]
+
+class FileTree(tk.Frame):
+    def __init__(self, parent, drive):
+        tk.Frame.__init__(self, parent)
+        self._parent = parent
+        self._command = self._parent._parent._command
+        self._types = self._parent._parent._types
+        self._showhidden = self._parent._parent._showhidden
+
+        self._tree = ttk.Treeview(self, height = 20, columns = ('path', 'filetype', 'size'), displaycolumns = 'size')
+        self._tree.heading('#0', text = 'Directory', anchor = tk.W)
+        self._tree.heading('size', text = 'Size', anchor = tk.W)
+        self._tree.column('path', width = 180)
+        self._tree.column('size', stretch = 1, width = 48)
+        self._tree.grid(row = 0, column = 0, sticky = 'nsew')
+
+        sbr_y = ttk.Scrollbar(self, orient = tk.VERTICAL, command = self._tree.yview)
+        sbr_x = ttk.Scrollbar(self, orient = tk.HORIZONTAL, command = self._tree.xview)
+        self._tree['yscroll'] = sbr_y.set
+        self._tree['xscroll'] = sbr_x.set
+        sbr_y.grid(row = 0, column = 1, sticky = 'ns')
+        sbr_x.grid(row = 1, column = 0, sticky = 'ew')
+        
+        self.rowconfigure(0, weight = 1)
+        self.columnconfigure(0, weight = 1)
+
+        self._populate_path(drive)
+        self._tree.bind('<<TreeviewOpen>>', self._on_click)
+        self._tree.bind('<<TreeviewClose>>', self._on_close)
+        if self._parent._parent._rightclick_options != []:
+            self._tree.bind('<Button-3>', self._draw_menu)
+
+    def _draw_menu(self, event):
+        menu = RightClickMenu(self, self._parent._parent._rightclick_options, self._tree.identify_row(event.y))
+        try:
+            menu.tk_popup(event.x_root, event.y_root)
+        finally:
+            menu.grab_release()
+
+    def _on_click(self, event):
+        id = os.path.normpath(self._tree.focus())
+
+        #add to the list of open nodes
+        if os.path.isdir(id):
+            #add both the tab name and the path, since the same path could be open in multiple places
+            self._parent._parent._open.append([self._parent._get_tab_name(), id])
+            #print(self._parent._parent._open)
+
+        if os.path.isfile(id):
+            self._command(id)
+        else:
+            try:
+                self._populate_path(id)
+            except tk.TclError:
+                #this node has already been opened, so delete children and load again
+                for child in self._tree.get_children(id):
+                    self._tree.delete(child)
+                self._populate_path(id)
+
+        #print("\n clicked: ", self._parent._parent._open)
+
+    def _on_close(self, event):
+        """Method called when the user closes a node. This must delete the node,
+        and it's children, from the list of open nodes. To do this, a recursive
+        algoritm is used. We have to use this, as opposed to something like os.walk()
+        for preformance. A large folder could have thousands of children. This doesn't
+        'go deeper' unless the node in the tree is open.
+        
+        Arguments:
+            event {tkinter event} -- tkinter event is used to get the id,
+        """
+
+        id = os.path.normpath(self._tree.focus())
+        drive = self._parent._get_tab_name()
+
+        def recurse(path):
+            glob_pattern = os.path.join(path, '*')
+            for dir in sorted(glob(glob_pattern), key=os.path.getctime):
+                if os.path.isdir(dir) and self._tree.item(dir, "open"):
+                    self._parent._parent._open.remove([drive, dir])
+                    recurse(dir)
+
+        try:
+            self._parent._parent._open.remove([drive, id])
+        except ValueError:
+            #already removed by parent
+            pass
+
+        recurse(id)
+    
+    def _get_size(self, path):
+        """Returns the size of a file. From:
+        https://pyinmyeye.blogspot.co.uk/2012/07/tkinter-multi-column-list-demo.html
+        
+        Arguments:
+            path {str} -- Path to file
+        
+        Returns:
+            str -- file size in bytes/KB/MB/GB
+        """
+
+        size = os.path.getsize(path)
+        KB = 1024.0
+        MB = KB * KB
+        GB = MB * KB
+        if size >= GB:
+            return ('{:,.1f} GB').format(size / GB)
+        elif size >= MB:
+            return ('{:,.1f} MB').format(size / MB)
+        elif size >= KB:
+            return ('{:,.1f} KB').format(size / KB)
+        else:
+            return ('{} bytes').format(size)
+
+    def _populate_path(self, path):
+        #if the tree is blank, write to the root
+        if self._tree.get_children() == ():
+            node = ""
+        else:
+            node = path
+
+        folders, files = self._get_dirs_in_path(path)
+
+        for folder in folders:
+            fullpath = os.path.join(path, folder)
+            self._tree.insert(
+                parent = node, 
+                index = tk.END, 
+                iid = fullpath,
+                tags = (fullpath, ),
+                text = folder,
+                image = self._parent._foldericons[fullpath],
+                values = [folder, "", ""])
+            #setup a dummy so the '+' appears before it's loaded. Child stuff will be loaded when the user
+            #clicks on the plus, and the dummy will be removed. (or not if there are no files)
+            self._tree.insert(parent = fullpath, index = tk.END, tag = "dummy", text = "No avaliable files")
+
+        for file in files:
+            fullpath = os.path.join(path, file)
+            name, type_ = os.path.splitext(file)
+            #if the type is a shortcut, get the whole path as a key
+            if type_ == ".lnk" or type_ == ".exe":
+                icon = self._parent._fileicons[fullpath]
+            else:
+                icon = self._parent._fileicons[type_]
+            self._tree.insert(
+                parent = node, 
+                index = tk.END, 
+                iid = fullpath,
+                tag = fullpath,
+                text = file,
+                image = icon,
+                values = [file, "", self._get_size(fullpath)])
+
+        #if there is more than one child, delete every child that isn't a path
+        #and hence delete the dummy
+        children = self._tree.get_children(node)
+        if len(children) > 1:
+            for child in children:
+                if not os.path.exists(child):
+                    self._tree.delete(child)
+
+    def _get_dirs_in_path(self, path):
+        """Returns two lists, the first is a list of all folders in a directory,
+        the second is a list of files. Also loads the icons for these files and folders.
+        For folders, it puts a tk.PhotoImage as the value of the _foldericons dictionary
+        with the key being the full folder path. For files, it uses the _fileicons dictionary,
+        with they key being the filetype, e.g. "mp4". If the file is a shortcut (".lnk") or
+        executable (".exe"),  set the whole path as the key, since the icon is different for 
+        every file of that type.
+        
+        Arguments:
+            path {str} -- full path to the folder
+        
+        Returns:
+            tuple -- two lists of folders and files.
+        """
+
+        def add(p, type_):
+            files.append(p)
+
+            #if the file is a shortcut, set the key as the whole path
+            if type_ == ".lnk" or type_ == ".exe":
+                if os.path.join(path, p) not in self._parent._fileicons:
+                    self._parent._fileicons[os.path.join(path, p)] = ImageTk.PhotoImage(
+                        self._parent._parent._get_icon(os.path.join(path, p)))
+            else:
+                if type_ not in self._parent._fileicons:
+                    self._parent._fileicons[type_] = ImageTk.PhotoImage(
+                        self._parent._parent._get_icon(os.path.join(path, p)))
+
+            #print(self._parent._fileicons, "\n")
+
+        files = []
+        folders = []
+        try:
+            for p in os.listdir(path):
+                if p.startswith(".") and not self._showhidden:
+                    continue
+                
+                if os.path.isfile(os.path.join(path, p)):
+                    name, type_ = os.path.splitext(p)
+                    if self._types == []:
+                        add(p, type_)
+                    else:
+                        if type_ in self._types:
+                            add(p, type_)
+                    
+                else:
+                    folders.append(p)
+                    if os.path.join(path, p) not in self._parent._foldericons:
+                        self._parent._foldericons[os.path.join(path, p)] = ImageTk.PhotoImage(
+                            self._parent._parent._get_icon(os.path.join(path, p)))
+        except OSError:
+            pass
+        
+
+        #print("\n\nfolders: ", folders, "\nfiles: ", files)
+        return folders, files
+
+#for efficiency, it would be better to instatiate this only once, since now it's instatiated
+#every time the user right clicks
+class RightClickMenu(tk.Menu):
+    def __init__(self, parent, options, item):
+        tk.Menu.__init__(self, parent, tearoff = False)
+        self.parent = parent
+
+        print(item)
+        #only show menu options if the dev selected them
+        #if the dev selected no options, binding is never set
+        #it must be a file for the open option to appear
+        if MENU_OPEN in options and os.path.isfile(item):
+            self.add_command(label = "Open with default program", command = lambda: print("Open"))
+        if MENU_DELETE in options:
+            self.add_command(label = "Delete", image = self.parent._parent._parent._img_cross, compound = tk.LEFT, command = lambda: os.remove(item))
+        if MENU_CLIPBOARD in options:
+            self.add_command(label = "Copy path to clipboard", image = self.parent._parent._parent._img_clipboard, compound = tk.LEFT, command = lambda: print("clipboard"))
+
+def on_click(path):
+    print("click: ", path)
+
+# to debug, `python -m tkFileBrowser.fileTreeBrowser` from parent directory
+if __name__ == "__main__":
+    root = tk.Tk()
+    browser = TkFileBrowser(root, command = on_click)
+    browser.pack(side = tk.LEFT)
+
+    ttk.Button(root, text = "Goto", command = lambda: browser.see(r"C:\Users\eden\Pictures")).pack(side = tk.LEFT)
+
+    root.mainloop()
\ No newline at end of file