1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2013: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import os

    26

    27

import wx

    28

    29

from util.BitmapLibrary import GetBitmap

    30

    31

DRIVE, FOLDER, FILE = range(3)

    32

    33

    34

def sort_folder(x, y):

    35

    if x[1] == y[1]:

    36

        return cmp(x[0], y[0])

    37

    elif x[1] != FILE:

    38

        return -1

    39

    else:

    40

        return 1

    41

    42

    43

def splitpath(path):

    44

    head, tail = os.path.split(path)

    45

    if head == "":

    46

        return [tail]

    47

    elif tail == "":

    48

        return splitpath(head)

    49

    return splitpath(head) + [tail]

    50

    51

    52

class FolderTree(wx.Panel):

    53

    54

    def __init__(self, parent, folder, filter=None, editable=True):

    55

        wx.Panel.__init__(self, parent, style=wx.TAB_TRAVERSAL)

    56

    57

        main_sizer = wx.BoxSizer(wx.VERTICAL)

    58

    59

        self.Tree = wx.TreeCtrl(self,

    60

              style=wx.TR_HAS_BUTTONS |

    61

                    wx.TR_SINGLE |

    62

                    wx.SUNKEN_BORDER |

    63

                    wx.TR_HIDE_ROOT |

    64

                    wx.TR_LINES_AT_ROOT |

    65

                    wx.TR_EDIT_LABELS)

    66

        if wx.Platform == '__WXMSW__':

    67

            self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnTreeItemExpanded, self.Tree)

    68

            self.Tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)

    69

        else:

    70

            self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnTreeItemExpanded, self.Tree)

    71

        self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnTreeItemCollapsed, self.Tree)

    72

        self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnTreeBeginLabelEdit, self.Tree)

    73

        self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnTreeEndLabelEdit, self.Tree)

    74

        main_sizer.AddWindow(self.Tree, 1, flag=wx.GROW)

    75

    76

        if filter is not None:

    77

            self.Filter = wx.ComboBox(self, style=wx.CB_READONLY)

    78

            self.Bind(wx.EVT_COMBOBOX, self.OnFilterChanged, self.Filter)

    79

            main_sizer.AddWindow(self.Filter, flag=wx.GROW)

    80

        else:

    81

            self.Filter = None

    82

    83

        self.SetSizer(main_sizer)

    84

    85

        self.Folder = folder

    86

        self.Editable = editable

    87

    88

        self.TreeImageList = wx.ImageList(16, 16)

    89

        self.TreeImageDict = {}

    90

        for item_type, bitmap in [(DRIVE, "tree_drive"),

    91

                                  (FOLDER, "tree_folder"),

    92

                                  (FILE, "tree_file")]:

    93

            self.TreeImageDict[item_type] = self.TreeImageList.Add(GetBitmap(bitmap))

    94

        self.Tree.SetImageList(self.TreeImageList)

    95

    96

        self.Filters = {}

    97

        if self.Filter is not None:

    98

            filter_parts = filter.split("|")

    99

            for idx in xrange(0, len(filter_parts), 2):

   100

                if filter_parts[idx + 1] == "*.*":

   101

                    self.Filters[filter_parts[idx]] = ""

   102

                else:

   103

                    self.Filters[filter_parts[idx]] = filter_parts[idx + 1].replace("*", "")

   104

                self.Filter.Append(filter_parts[idx])

   105

                if idx == 0:

   106

                    self.Filter.SetStringSelection(filter_parts[idx])

   107

   108

            self.CurrentFilter = self.Filters[self.Filter.GetStringSelection()]

   109

        else:

   110

            self.CurrentFilter = ""

   111

   112

    def _GetFolderChildren(self, folderpath, recursive=True):

   113

        items = []

   114

        if wx.Platform == '__WXMSW__' and folderpath == "/":

   115

            for c in xrange(ord('a'), ord('z')):

   116

                drive = os.path.join("%s:\\" % chr(c))

   117

                if os.path.exists(drive):

   118

                    items.append((drive, DRIVE, self._GetFolderChildren(drive, False)))

   119

        else:

   120

            try:

   121

                files = os.listdir(folderpath)

   122

            except:

   123

                return []

   124

            for filename in files:

   125

                if not filename.startswith("."):

   126

                    filepath = os.path.join(folderpath, filename)

   127

                    if os.path.isdir(filepath):

   128

                        if recursive:

   129

                            children = len(self._GetFolderChildren(filepath, False))

   130

                        else:

   131

                            children = 0

   132

                        items.append((filename, FOLDER, children))

   133

                    elif (self.CurrentFilter == "" or

   134

                          os.path.splitext(filename)[1] == self.CurrentFilter):

   135

                        items.append((filename, FILE, None))

   136

        if recursive:

   137

            items.sort(sort_folder)

   138

        return items

   139

   140

    def SetFilter(self, filter):

   141

        self.CurrentFilter = filter

   142

   143

    def GetTreeCtrl(self):

   144

        return self.Tree

   145

   146

    def RefreshTree(self):

   147

        root = self.Tree.GetRootItem()

   148

        if not root.IsOk():

   149

            root = self.Tree.AddRoot("")

   150

        self.GenerateTreeBranch(root, self.Folder)

   151

   152

    def GenerateTreeBranch(self, root, folderpath):

   153

        item, item_cookie = self.Tree.GetFirstChild(root)

   154

        for idx, (filename, item_type, children) in enumerate(self._GetFolderChildren(folderpath)):

   155

            if not item.IsOk():

   156

                item = self.Tree.AppendItem(root, filename, self.TreeImageDict[item_type])

   157

                if wx.Platform != '__WXMSW__':

   158

                    item, item_cookie = self.Tree.GetNextChild(root, item_cookie)

   159

            elif self.Tree.GetItemText(item) != filename:

   160

                item = self.Tree.InsertItemBefore(root, idx, filename, self.TreeImageDict[item_type])

   161

            filepath = os.path.join(folderpath, filename)

   162

            if item_type != FILE:

   163

                if self.Tree.IsExpanded(item):

   164

                    self.GenerateTreeBranch(item, filepath)

   165

                elif children > 0:

   166

                    self.Tree.SetItemHasChildren(item)

   167

            item, item_cookie = self.Tree.GetNextChild(root, item_cookie)

   168

        to_delete = []

   169

        while item.IsOk():

   170

            to_delete.append(item)

   171

            item, item_cookie = self.Tree.GetNextChild(root, item_cookie)

   172

        for item in to_delete:

   173

            self.Tree.Delete(item)

   174

   175

    def ExpandItem(self, item):

   176

        self.GenerateTreeBranch(item, self.GetPath(item))

   177

        self.Tree.Expand(item)

   178

   179

    def OnTreeItemActivated(self, event):

   180

        self.ExpandItem(event.GetItem())

   181

        event.Skip()

   182

   183

    def OnTreeLeftDown(self, event):

   184

        item, flags = self.Tree.HitTest(event.GetPosition())

   185

        if flags & wx.TREE_HITTEST_ONITEMBUTTON and not self.Tree.IsExpanded(item):

   186

            self.ExpandItem(item)

   187

        else:

   188

            event.Skip()

   189

   190

    def OnTreeItemExpanded(self, event):

   191

        item = event.GetItem()

   192

        self.GenerateTreeBranch(item, self.GetPath(item))

   193

        event.Skip()

   194

   195

    def OnTreeItemCollapsed(self, event):

   196

        item = event.GetItem()

   197

        self.Tree.DeleteChildren(item)

   198

        self.Tree.SetItemHasChildren(item)

   199

        event.Skip()

   200

   201

    def OnTreeBeginLabelEdit(self, event):

   202

        item = event.GetItem()

   203

        if self.Editable and not self.Tree.ItemHasChildren(item):

   204

            event.Skip()

   205

        else:

   206

            event.Veto()

   207

   208

    def OnTreeEndLabelEdit(self, event):

   209

        new_name = event.GetLabel()

   210

        if new_name != "":

   211

            old_filepath = self.GetPath(event.GetItem())

   212

            new_filepath = os.path.join(os.path.split(old_filepath)[0], new_name)

   213

            if new_filepath != old_filepath:

   214

                if not os.path.exists(new_filepath):

   215

                    os.rename(old_filepath, new_filepath)

   216

                    event.Skip()

   217

                else:

   219

                        _("File '%s' already exists!") % new_name,

   220

                        _("Error"), wx.OK | wx.ICON_ERROR)

   221

                    message.ShowModal()

   222

                    message.Destroy()

   223

                    event.Veto()

   224

        else:

   225

            event.Skip()

   226

   227

    def OnFilterChanged(self, event):

   228

        self.CurrentFilter = self.Filters[self.Filter.GetStringSelection()]

   229

        self.RefreshTree()

   230

        event.Skip()

   231

   232

    def _SelectItem(self, root, parts):

   233

        if len(parts) == 0:

   234

            self.Tree.SelectItem(root)

   235

        else:

   236

            item, item_cookie = self.Tree.GetFirstChild(root)

   237

            while item.IsOk():

   238

                if self.Tree.GetItemText(item) == parts[0]:

   239

                    if (self.Tree.ItemHasChildren(item) and

   240

                        not self.Tree.IsExpanded(item)):

   241

                        self.Tree.Expand(item)

   242

                        wx.CallAfter(self._SelectItem, item, parts[1:])

   243

                    else:

   244

                        self._SelectItem(item, parts[1:])

   245

                    return

   246

                item, item_cookie = self.Tree.GetNextChild(root, item_cookie)

   247

   248

    def SetPath(self, path):

   249

        if path.startswith(self.Folder):

   250

            root = self.Tree.GetRootItem()

   251

            if root.IsOk():

   252

                relative_path = path.replace(os.path.join(self.Folder, ""), "")

   253

                self._SelectItem(root, splitpath(relative_path))

   254

   255

    def GetPath(self, item=None):

   256

        if item is None:

   257

            item = self.Tree.GetSelection()

   258

        if item.IsOk():

   259

            filepath = self.Tree.GetItemText(item)

   260

            parent = self.Tree.GetItemParent(item)

   261

            while parent.IsOk() and parent != self.Tree.GetRootItem():

   262

                filepath = os.path.join(self.Tree.GetItemText(parent), filepath)

   263

                parent = self.Tree.GetItemParent(parent)

   264

            return os.path.join(self.Folder, filepath)

   265

        return self.Folder