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

    31

from util.BitmapLibrary import GetBitmap

    32

    33

DRIVE, FOLDER, FILE = range(3)

    34

    35

    36

def sort_folder(x, y):

    37

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

    38

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

    39

    elif x[1] != FILE:

    40

        return -1

    41

    else:

    42

        return 1

    43

    44

    45

def splitpath(path):

    46

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

    47

    if head == "":

    48

        return [tail]

    49

    elif tail == "":

    50

        return splitpath(head)

    51

    return splitpath(head) + [tail]

    52

    53

    54

class FolderTree(wx.Panel):

    55

    56

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

    57

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

    58

    59

        main_sizer = wx.BoxSizer(wx.VERTICAL)

    60

    61

        self.Tree = wx.TreeCtrl(self,

    62

                                style=(wx.TR_HAS_BUTTONS |

    63

                                       wx.TR_SINGLE |

    64

                                       wx.SUNKEN_BORDER |

    65

                                       wx.TR_HIDE_ROOT |

    66

                                       wx.TR_LINES_AT_ROOT |

    67

                                       wx.TR_EDIT_LABELS))

    68

        if wx.Platform == '__WXMSW__':

    69

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

    70

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

    71

        else:

    72

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

    73

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

    74

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

    75

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

    76

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

    77

    78

        if filter is not None:

    79

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

    80

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

    81

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

    82

        else:

    83

            self.Filter = None

    84

    85

        self.SetSizer(main_sizer)

    86

    87

        self.Folder = folder

    88

        self.Editable = editable

    89

    90

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

    91

        self.TreeImageDict = {}

    92

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

    93

                                  (FOLDER, "tree_folder"),

    94

                                  (FILE, "tree_file")]:

    95

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

    96

        self.Tree.SetImageList(self.TreeImageList)

    97

    98

        self.Filters = {}

    99

        if self.Filter is not None:

   100

            filter_parts = filter.split("|")

   101

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

   102

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

   103

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

   104

                else:

   105

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

   106

                self.Filter.Append(filter_parts[idx])

   107

                if idx == 0:

   108

                    self.Filter.SetStringSelection(filter_parts[idx])

   109

   110

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

   111

        else:

   112

            self.CurrentFilter = ""

   113

   114

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

   115

        items = []

   116

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

   117

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

   118

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

   119

                if os.path.exists(drive):

   120

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

   121

        else:

   122

            try:

   123

                files = os.listdir(folderpath)

   124

            except Exception:

   125

                return []

   126

            for filename in files:

   127

                if not filename.startswith("."):

   128

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

   129

                    if os.path.isdir(filepath):

   130

                        if recursive:

   131

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

   132

                        else:

   133

                            children = 0

   134

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

   135

                    elif (self.CurrentFilter == "" or

   136

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

   137

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

   138

        if recursive:

   139

            items.sort(sort_folder)

   140

        return items

   141

   142

    def SetFilter(self, filter):

   143

        self.CurrentFilter = filter

   144

   145

    def GetTreeCtrl(self):

   146

        return self.Tree

   147

   148

    def RefreshTree(self):

   149

        root = self.Tree.GetRootItem()

   150

        if not root.IsOk():

   151

            root = self.Tree.AddRoot("")

   152

        self.GenerateTreeBranch(root, self.Folder)

   153

   154

    def GenerateTreeBranch(self, root, folderpath):

   155

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

   156

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

   157

            if not item.IsOk():

   158

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

   159

                if wx.Platform != '__WXMSW__':

   160

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

   161

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

   162

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

   163

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

   164

            if item_type != FILE:

   165

                if self.Tree.IsExpanded(item):

   166

                    self.GenerateTreeBranch(item, filepath)

   167

                elif children > 0:

   168

                    self.Tree.SetItemHasChildren(item)

   169

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

   170

        to_delete = []

   171

        while item.IsOk():

   172

            to_delete.append(item)

   173

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

   174

        for item in to_delete:

   175

            self.Tree.Delete(item)

   176

   177

    def ExpandItem(self, item):

   178

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

   179

        self.Tree.Expand(item)

   180

   181

    def OnTreeItemActivated(self, event):

   182

        self.ExpandItem(event.GetItem())

   183

        event.Skip()

   184

   185

    def OnTreeLeftDown(self, event):

   186

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

   187

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

   188

            self.ExpandItem(item)

   189

        else:

   190

            event.Skip()

   191

   192

    def OnTreeItemExpanded(self, event):

   193

        item = event.GetItem()

   194

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

   195

        event.Skip()

   196

   197

    def OnTreeItemCollapsed(self, event):

   198

        item = event.GetItem()

   199

        self.Tree.DeleteChildren(item)

   200

        self.Tree.SetItemHasChildren(item)

   201

        event.Skip()

   202

   203

    def OnTreeBeginLabelEdit(self, event):

   204

        item = event.GetItem()

   205

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

   206

            event.Skip()

   207

        else:

   208

            event.Veto()

   209

   210

    def OnTreeEndLabelEdit(self, event):

   211

        new_name = event.GetLabel()

   212

        if new_name != "":

   213

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

   214

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

   215

            if new_filepath != old_filepath:

   216

                if not os.path.exists(new_filepath):

   217

                    os.rename(old_filepath, new_filepath)

   218

                    event.Skip()

   219

                else:

   220

                    message = wx.MessageDialog(self,

   221

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

   222

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

   223

                    message.ShowModal()

   224

                    message.Destroy()

   225

                    event.Veto()

   226

        else:

   227

            event.Skip()

   228

   229

    def OnFilterChanged(self, event):

   230

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

   231

        self.RefreshTree()

   232

        event.Skip()

   233

   234

    def _SelectItem(self, root, parts):

   235

        if len(parts) == 0:

   236

            self.Tree.SelectItem(root)

   237

        else:

   238

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

   239

            while item.IsOk():

   240

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

   241

                    if self.Tree.ItemHasChildren(item) and \

   242

                       not self.Tree.IsExpanded(item):

   243

                        self.Tree.Expand(item)

   244

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

   245

                    else:

   246

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

   247

                    return

   248

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

   249

   250

    def SetPath(self, path):

   251

        if path.startswith(self.Folder):

   252

            root = self.Tree.GetRootItem()

   253

            if root.IsOk():

   254

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

   255

                self._SelectItem(root, splitpath(relative_path))

   256

   257

    def GetPath(self, item=None):

   258

        if item is None:

   259

            item = self.Tree.GetSelection()

   260

        if item.IsOk():

   261

            filepath = self.Tree.GetItemText(item)

   262

            parent = self.Tree.GetItemParent(item)

   263

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

   264

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

   265

                parent = self.Tree.GetItemParent(parent)

   266

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

   267

        return self.Folder