util/FileManagementPanel.py
changeset 783 f5cea1a6851e
parent 782 6f0e10085df9
child 784 a1d970365e41
equal deleted inserted replaced
782:6f0e10085df9 783:f5cea1a6851e
    28 import wx
    28 import wx
    29 
    29 
    30 from controls import EditorPanel
    30 from controls import EditorPanel
    31 from utils.BitmapLibrary import GetBitmap
    31 from utils.BitmapLibrary import GetBitmap
    32 
    32 
       
    33 DRIVE, FOLDER, FILE = range(3)
       
    34 
    33 FILTER = _("All files (*.*)|*.*|CSV files (*.csv)|*.csv")
    35 FILTER = _("All files (*.*)|*.*|CSV files (*.csv)|*.csv")
    34 
    36 
    35 def sort_folder(x, y):
    37 def sort_folder(x, y):
    36     if x[1] == y[1]:
    38     if x[1] == y[1]:
    37         return cmp(x[0], y[0])
    39         return cmp(x[0], y[0])
    38     elif x[1]:
    40     elif x[1] != FILE:
    39         return -1
    41         return -1
    40     else:
    42     else:
    41         return 1
    43         return 1
    42 
    44 
    43 def splitpath(path):
    45 def splitpath(path):
    60                     wx.TR_SINGLE|
    62                     wx.TR_SINGLE|
    61                     wx.SUNKEN_BORDER|
    63                     wx.SUNKEN_BORDER|
    62                     wx.TR_HIDE_ROOT|
    64                     wx.TR_HIDE_ROOT|
    63                     wx.TR_LINES_AT_ROOT|
    65                     wx.TR_LINES_AT_ROOT|
    64                     wx.TR_EDIT_LABELS)
    66                     wx.TR_EDIT_LABELS)
    65         self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnTreeItemExpanded, self.Tree)
    67         if wx.Platform == '__WXMSW__':
       
    68             self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnTreeItemExpanded, self.Tree)
       
    69             self.Tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)
       
    70         else:
       
    71             self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnTreeItemExpanded, self.Tree)
    66         self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnTreeItemCollapsed, self.Tree)
    72         self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnTreeItemCollapsed, self.Tree)
    67         self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnTreeBeginLabelEdit, self.Tree)
    73         self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnTreeBeginLabelEdit, self.Tree)
    68         self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnTreeEndLabelEdit, self.Tree)
    74         self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnTreeEndLabelEdit, self.Tree)
    69         main_sizer.AddWindow(self.Tree, 1, flag=wx.GROW)
    75         main_sizer.AddWindow(self.Tree, 1, flag=wx.GROW)
    70         
    76         
    76         
    82         
    77         self.Folder = folder
    83         self.Folder = folder
    78         self.Editable = editable
    84         self.Editable = editable
    79         
    85         
    80         self.TreeImageList = wx.ImageList(16, 16)
    86         self.TreeImageList = wx.ImageList(16, 16)
    81         self.FOLDER_IMAGE = self.TreeImageList.Add(GetBitmap("tree_folder"))
    87         self.TreeImageDict = {}
    82         self.FILE_IMAGE = self.TreeImageList.Add(GetBitmap("tree_file"))
    88         for item_type, bitmap in [(DRIVE, "tree_drive"),
       
    89                                   (FOLDER, "tree_folder"),
       
    90                                   (FILE, "tree_file")]:
       
    91             self.TreeImageDict[item_type] = self.TreeImageList.Add(GetBitmap(bitmap))
    83         self.Tree.SetImageList(self.TreeImageList)
    92         self.Tree.SetImageList(self.TreeImageList)
    84         
    93         
    85         self.Filters = {}
    94         self.Filters = {}
    86         filter_parts = filter.split("|")
    95         filter_parts = filter.split("|")
    87         for idx in xrange(0, len(filter_parts), 2):
    96         for idx in xrange(0, len(filter_parts), 2):
    95             
   104             
    96         self.CurrentFilter = self.Filters[self.Filter.GetStringSelection()]
   105         self.CurrentFilter = self.Filters[self.Filter.GetStringSelection()]
    97     
   106     
    98     def _GetFolderChildren(self, folderpath, recursive=True):
   107     def _GetFolderChildren(self, folderpath, recursive=True):
    99         items = []
   108         items = []
   100         for filename in os.listdir(folderpath):
   109         if wx.Platform == '__WXMSW__' and folderpath == "/":
   101             if not filename.startswith("."):
   110             for c in xrange(ord('a'), ord('z')):
   102                 filepath = os.path.join(folderpath, filename)
   111                 drive = os.path.join("%s:\\" % chr(c))
   103                 if os.path.isdir(filepath):
   112                 if os.path.exists(drive):
   104                     if recursive:
   113                     items.append((drive, DRIVE, self._GetFolderChildren(drive, False)))
   105                         children = len(self._GetFolderChildren(filepath, False))
   114         else:
   106                     else:
   115             try:
   107                         children = 0
   116                 files = os.listdir(folderpath)
   108                     items.append((filename, True, children))
   117             except:
   109                 elif (self.CurrentFilter == "" or 
   118                 return []
   110                       os.path.splitext(filename)[1] == self.CurrentFilter):
   119             for filename in files:
   111                     items.append((filename, False, None))
   120                 if not filename.startswith("."):
       
   121                     filepath = os.path.join(folderpath, filename)
       
   122                     if os.path.isdir(filepath):
       
   123                         if recursive:
       
   124                             children = len(self._GetFolderChildren(filepath, False))
       
   125                         else:
       
   126                             children = 0
       
   127                         items.append((filename, FOLDER, children))
       
   128                     elif (self.CurrentFilter == "" or 
       
   129                           os.path.splitext(filename)[1] == self.CurrentFilter):
       
   130                         items.append((filename, FILE, None))
   112         if recursive:
   131         if recursive:
   113             items.sort(sort_folder)
   132             items.sort(sort_folder)
   114         return items
   133         return items
   115     
   134     
   116     def GetTreeCtrl(self):
   135     def GetTreeCtrl(self):
   122             root = self.Tree.AddRoot("")
   141             root = self.Tree.AddRoot("")
   123         self.GenerateTreeBranch(root, self.Folder)
   142         self.GenerateTreeBranch(root, self.Folder)
   124         
   143         
   125     def GenerateTreeBranch(self, root, folderpath):
   144     def GenerateTreeBranch(self, root, folderpath):
   126         item, item_cookie = self.Tree.GetFirstChild(root)
   145         item, item_cookie = self.Tree.GetFirstChild(root)
   127         for idx, (filename, isdir, children) in enumerate(self._GetFolderChildren(folderpath)):
   146         for idx, (filename, item_type, children) in enumerate(self._GetFolderChildren(folderpath)):
   128             new = False
       
   129             if not item.IsOk():
   147             if not item.IsOk():
   130                 item = self.Tree.AppendItem(root, filename)
   148                 item = self.Tree.AppendItem(root, filename, self.TreeImageDict[item_type])
   131                 if wx.Platform != '__WXMSW__':
   149                 if wx.Platform != '__WXMSW__':
   132                     item, item_cookie = self.Tree.GetNextChild(root, item_cookie)
   150                     item, item_cookie = self.Tree.GetNextChild(root, item_cookie)
   133                 new = True
       
   134             elif self.Tree.GetItemText(item) != filename:
   151             elif self.Tree.GetItemText(item) != filename:
   135                 item = self.Tree.InsertItemBefore(root, idx, filename)
   152                 item = self.Tree.InsertItemBefore(root, idx, filename, self.TreeImageDict[item_type])
   136                 new = True
       
   137             filepath = os.path.join(folderpath, filename)
   153             filepath = os.path.join(folderpath, filename)
   138             if isdir:
   154             if item_type != FILE:
   139                 if new:
   155                 if self.Tree.IsExpanded(item):
   140                     self.Tree.SetItemImage(item, self.FOLDER_IMAGE)
       
   141                     if children > 0:
       
   142                         self.Tree.SetItemHasChildren(item)
       
   143                 elif self.Tree.IsExpanded(item):
       
   144                     self.GenerateTreeBranch(item, filepath)
   156                     self.GenerateTreeBranch(item, filepath)
   145             elif new:
   157                 elif children > 0:
   146                 self.Tree.SetItemImage(item, self.FILE_IMAGE)
   158                     self.Tree.SetItemHasChildren(item)
   147             item, item_cookie = self.Tree.GetNextChild(root, item_cookie)
   159             item, item_cookie = self.Tree.GetNextChild(root, item_cookie)
   148         to_delete = []
   160         to_delete = []
   149         while item.IsOk():
   161         while item.IsOk():
   150             to_delete.append(item)
   162             to_delete.append(item)
   151             item, item_cookie = self.Tree.GetNextChild(root, item_cookie)
   163             item, item_cookie = self.Tree.GetNextChild(root, item_cookie)
   152         for item in to_delete:
   164         for item in to_delete:
   153             self.Tree.Delete(item)
   165             self.Tree.Delete(item)
   154 
   166 
       
   167     def ExpandItem(self, item):
       
   168         self.GenerateTreeBranch(item, self.GetPath(item))
       
   169         self.Tree.Expand(item)
       
   170     
       
   171     def OnTreeItemActivated(self, event):
       
   172         self.ExpandItem(event.GetItem())
       
   173         event.Skip()
       
   174     
       
   175     def OnTreeLeftDown(self, event):
       
   176         item, flags = self.Tree.HitTest(event.GetPosition())
       
   177         if flags & wx.TREE_HITTEST_ONITEMBUTTON and not self.Tree.IsExpanded(item):
       
   178             self.ExpandItem(item)
       
   179         else:
       
   180             event.Skip()
       
   181     
   155     def OnTreeItemExpanded(self, event):
   182     def OnTreeItemExpanded(self, event):
   156         item = event.GetItem()
   183         item = event.GetItem()
   157         self.GenerateTreeBranch(item, self.GetPath(item))
   184         self.GenerateTreeBranch(item, self.GetPath(item))
   158         event.Skip()
   185         event.Skip()
   159 
   186 
   272         self.Editor.SetSizer(main_sizer)
   299         self.Editor.SetSizer(main_sizer)
   273         
   300         
   274     def __init__(self, parent, controler, name, folder, enable_dragndrop=False):
   301     def __init__(self, parent, controler, name, folder, enable_dragndrop=False):
   275         self.Folder = os.path.realpath(folder)
   302         self.Folder = os.path.realpath(folder)
   276         self.EnableDragNDrop = enable_dragndrop
   303         self.EnableDragNDrop = enable_dragndrop
   277         self.HomeDirectory = os.path.expanduser("~")
   304         
       
   305         if wx.Platform == '__WXMSW__':
       
   306             self.HomeDirectory = "/"
       
   307         else:
       
   308             self.HomeDirectory = os.path.expanduser("~")
   278         
   309         
   279         EditorPanel.__init__(self, parent, name, None, None)
   310         EditorPanel.__init__(self, parent, name, None, None)
   280         
   311         
   281         self.Controler = controler
   312         self.Controler = controler
   282         
   313