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

    26

from __future__ import absolute_import

    27

import os

    28

    29

import wx

    30

from six.moves import xrange

    31

    32

from util.BitmapLibrary import GetBitmap

    33

    34

DRIVE, FOLDER, FILE = range(3)

    35

    36

    37

def sort_folder(x, y):

    38

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

    39

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

    40

    elif x[1] != FILE:

    41

        return -1

    42

    else:

    43

        return 1

    44

    45

    46

def splitpath(path):

    47

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

    48

    if head == "":

    49

        return [tail]

    50

    elif tail == "":

    51

        return splitpath(head)

    52

    return splitpath(head) + [tail]

    53

    54

    55

class FolderTree(wx.Panel):

    56

    57

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

    58

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

    59

    60

        main_sizer = wx.BoxSizer(wx.VERTICAL)

    61

    62

        self.Tree = wx.TreeCtrl(self,

    63

                                style=(wx.TR_HAS_BUTTONS |

    64

                                       wx.TR_SINGLE |

    65

                                       wx.SUNKEN_BORDER |

    66

                                       wx.TR_HIDE_ROOT |

    67

                                       wx.TR_LINES_AT_ROOT |

    68

                                       wx.TR_EDIT_LABELS))

    69

        if wx.Platform == '__WXMSW__':

    70

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

    71

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

    72

        else:

    73

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

    74

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

    75

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

    76

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

    77

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

    78

    79

        if filter is not None:

    80

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

    81

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

    82

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

    83

        else:

    84

            self.Filter = None

    85

    86

        self.SetSizer(main_sizer)

    87

    88

        self.Folder = folder

    89

        self.Editable = editable

    90

    91

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

    92

        self.TreeImageDict = {}

    93

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

    94

                                  (FOLDER, "tree_folder"),

    95

                                  (FILE, "tree_file")]:

    96

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

    97

        self.Tree.SetImageList(self.TreeImageList)

    98

    99

        self.Filters = {}

   100

        if self.Filter is not None:

   101

            filter_parts = filter.split("|")

   102

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

   103

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

   104

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

   105

                else:

   106

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

   107

                self.Filter.Append(filter_parts[idx])

   108

                if idx == 0:

   109

                    self.Filter.SetStringSelection(filter_parts[idx])

   110

   111

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

   112

        else:

   113

            self.CurrentFilter = ""

   114

   115

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

   116

        items = []

   117

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

   118

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

   119

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

   120

                if os.path.exists(drive):

   121

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

   122

        else:

   123

            try:

   124

                files = os.listdir(folderpath)

   125

            except Exception:

   126

                return []

   127

            for filename in files:

   128

                if not filename.startswith("."):

   129

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

   130

                    if os.path.isdir(filepath):

   131

                        if recursive:

   132

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

   133

                        else:

   134

                            children = 0

   135

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

   136

                    elif (self.CurrentFilter == "" or

   137

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

   138

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

   139

        if recursive:

   140

            items.sort(sort_folder)

   141

        return items

   142

   143

    def SetFilter(self, filter):

   144

        self.CurrentFilter = filter

   145

   146

    def GetTreeCtrl(self):

   147

        return self.Tree

   148

   149

    def RefreshTree(self):

   150

        root = self.Tree.GetRootItem()

   151

        if not root.IsOk():

   152

            root = self.Tree.AddRoot("")

   153

        self.GenerateTreeBranch(root, self.Folder)

   154

   155

    def GenerateTreeBranch(self, root, folderpath):

   156

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

   157

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

   158

            if not item.IsOk():

   159

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

   160

                if wx.Platform != '__WXMSW__':

   161

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

   162

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

   163

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

   164

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

   165

            if item_type != FILE:

   166

                if self.Tree.IsExpanded(item):

   167

                    self.GenerateTreeBranch(item, filepath)

   168

                elif children > 0:

   169

                    self.Tree.SetItemHasChildren(item)

   170

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

   171

        to_delete = []

   172

        while item.IsOk():

   173

            to_delete.append(item)

   174

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

   175

        for item in to_delete:

   176

            self.Tree.Delete(item)

   177

   178

    def ExpandItem(self, item):

   179

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

   180

        self.Tree.Expand(item)

   181

   182

    def OnTreeItemActivated(self, event):

   183

        self.ExpandItem(event.GetItem())

   184

        event.Skip()

   185

   186

    def OnTreeLeftDown(self, event):

   187

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

   188

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

   189

            self.ExpandItem(item)

   190

        else:

   191

            event.Skip()

   192

   193

    def OnTreeItemExpanded(self, event):

   194

        item = event.GetItem()

   195

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

   196

        event.Skip()

   197

   198

    def OnTreeItemCollapsed(self, event):

   199

        item = event.GetItem()

   200

        self.Tree.DeleteChildren(item)

   201

        self.Tree.SetItemHasChildren(item)

   202

        event.Skip()

   203

   204

    def OnTreeBeginLabelEdit(self, event):

   205

        item = event.GetItem()

   206

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

   207

            event.Skip()

   208

        else:

   209

            event.Veto()

   210

   211

    def OnTreeEndLabelEdit(self, event):

   212

        new_name = event.GetLabel()

   213

        if new_name != "":

   214

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

   215

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

   216

            if new_filepath != old_filepath:

   217

                if not os.path.exists(new_filepath):

   218

                    os.rename(old_filepath, new_filepath)

   219

                    event.Skip()

   220

                else:

   221

                    message = wx.MessageDialog(self,

   222

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

   223

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

   224

                    message.ShowModal()

   225

                    message.Destroy()

   226

                    event.Veto()

   227

        else:

   228

            event.Skip()

   229

   230

    def OnFilterChanged(self, event):

   231

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

   232

        self.RefreshTree()

   233

        event.Skip()

   234

   235

    def _SelectItem(self, root, parts):

   236

        if len(parts) == 0:

   237

            self.Tree.SelectItem(root)

   238

        else:

   239

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

   240

            while item.IsOk():

   241

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

   242

                    if self.Tree.ItemHasChildren(item) and \

   243

                       not self.Tree.IsExpanded(item):

   244

                        self.Tree.Expand(item)

   245

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

   246

                    else:

   247

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

   248

                    return

   249

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

   250

   251

    def SetPath(self, path):

   252

        if path.startswith(self.Folder):

   253

            root = self.Tree.GetRootItem()

   254

            if root.IsOk():

   255

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

   256

                self._SelectItem(root, splitpath(relative_path))

   257

   258

    def GetPath(self, item=None):

   259

        if item is None:

   260

            item = self.Tree.GetSelection()

   261

        if item.IsOk():

   262

            filepath = self.Tree.GetItemText(item)

   263

            parent = self.Tree.GetItemParent(item)

   264

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

   265

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

   266

                parent = self.Tree.GetItemParent(parent)

   267

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

   268

        return self.Folder