1

#!/usr/bin/env python

     2

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

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

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

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

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

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

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

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

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

    22

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

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

import wx

    26

    27

[CATEGORY, BLOCK] = range(2)

    28

    29

[ID_LIBRARYPANEL, ID_LIBRARYSEARCHCTRL, 

    30

 ID_LIBRARYTREE, ID_LIBRARYCOMMENT, 

    31

] = [wx.NewId() for _init_ctrls in range(4)]

    32

    33

class LibraryPanel(wx.Panel):

    34

    35

    def _init_coll_MainSizer_Items(self, parent):

    36

        parent.AddWindow(self.SearchCtrl, 0, border=0, flag=wx.GROW)

    37

        parent.AddWindow(self.Tree, 0, border=0, flag=wx.GROW)

    38

        parent.AddWindow(self.Comment, 0, border=0, flag=wx.GROW)

    39

    40

    def _init_coll_MainSizer_Growables(self, parent):

    41

        parent.AddGrowableCol(0)

    42

        parent.AddGrowableRow(1)

    43

    44

    def _init_sizers(self):

    45

        self.MainSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=3, vgap=0)

    46

    47

        self._init_coll_MainSizer_Growables(self.MainSizer)

    48

        self._init_coll_MainSizer_Items(self.MainSizer)

    49

    50

        self.SetSizer(self.MainSizer)

    51

    52

    def _init_ctrls(self, prnt, enable_drag=False):

    53

        wx.Panel.__init__(self, id=ID_LIBRARYPANEL,

    54

                  name='LibraryPanel', parent=prnt,

    55

                  pos=wx.Point(0, 0), size=wx.Size(0, 0), 

    56

                  style=wx.TAB_TRAVERSAL)

    57

    58

        self.SearchCtrl = wx.SearchCtrl(id=ID_LIBRARYSEARCHCTRL, 

    59

                  name='SearchCtrl', parent=self,

    60

                  pos=wx.Point(0, 0), size=wx.Size(0, 28), style=0)

    61

        self.SearchCtrl.ShowSearchButton(True)

    62

        self.Bind(wx.EVT_TEXT, self.OnSearchCtrlChanged,

    63

              id=ID_LIBRARYSEARCHCTRL)

    64

        self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN, self.OnSearchButtonClick,

    65

              id=ID_LIBRARYSEARCHCTRL)

    66

        search_textctrl = self.SearchCtrl.GetChildren()[0]

    67

        search_textctrl.Bind(wx.EVT_CHAR, self.OnKeyDown)

    68

    69

        self.Tree = wx.TreeCtrl(id=ID_LIBRARYTREE,

    70

                  name='Tree', parent=self, 

    71

                  pos=wx.Point(0, 0), size=wx.Size(0, 0),

    72

                  style=wx.TR_HAS_BUTTONS|wx.TR_SINGLE|wx.SUNKEN_BORDER|wx.TR_HIDE_ROOT|wx.TR_LINES_AT_ROOT)

    73

        self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTreeItemSelected,

    74

              id=ID_LIBRARYTREE)

    75

        self.Tree.Bind(wx.EVT_CHAR, self.OnKeyDown)

    76

        if enable_drag:

    77

            self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnTreeBeginDrag,

    78

                  id=ID_LIBRARYTREE)

    79

    80

        self.Comment = wx.TextCtrl(id=ID_LIBRARYCOMMENT,

    81

              name='Comment', parent=self, 

    82

              pos=wx.Point(0, 0), size=wx.Size(0, 80), 

    83

              style=wx.TE_READONLY|wx.TE_MULTILINE)

    84

    85

        self._init_sizers()

    86

    87

    def __init__(self, parent, enable_drag=False):

    88

        self._init_ctrls(parent, enable_drag)

    89

    90

        self.Controler = None

    91

    92

        self.BlockList = None

    93

    94

    def __del__(self):

    95

        self.Controler = None

    96

    97

    def SetControler(self, controler):

    98

        self.Controler = controler

    99

   100

    def SetBlockList(self, blocklist):

   101

        self.BlockList = blocklist

   102

        self.RefreshTree()

   103

   104

    def SetFocus(self):

   105

        self.SearchCtrl.SetFocus()

   106

   107

    def ResetTree(self):

   108

        self.SearchCtrl.SetValue("")

   109

        self.Tree.DeleteAllItems()

   110

        self.Comment.SetValue("")

   111

   112

    def RefreshTree(self):

   113

        if self.Controler is not None:

   114

            to_delete = []

   115

            selected_name = None

   116

            selected = self.Tree.GetSelection()

   117

            if selected.IsOk():

   118

                selected_pydata = self.Tree.GetPyData(selected)

   119

                if selected_pydata is not None and selected_pydata["type"] != CATEGORY:

   120

                    selected_name = self.Tree.GetItemText(selected)

   121

            if self.BlockList is not None:

   122

                blocktypes = self.BlockList

   123

            else:

   124

                blocktypes = self.Controler.GetBlockTypes()

   125

            root = self.Tree.GetRootItem()

   126

            if not root.IsOk():

   127

                root = self.Tree.AddRoot("")

   128

            if wx.VERSION >= (2, 6, 0):

   129

                category_item, root_cookie = self.Tree.GetFirstChild(root)

   130

            else:

   131

                category_item, root_cookie = self.Tree.GetFirstChild(root, 0)

   132

            for category in blocktypes:

   133

                category_name = category["name"]

   134

                if not category_item.IsOk():

   135

                    category_item = self.Tree.AppendItem(root, _(category_name))

   136

                    if wx.Platform != '__WXMSW__':

   137

                        category_item, root_cookie = self.Tree.GetNextChild(root, root_cookie)

   138

                else:

   139

                    self.Tree.SetItemText(category_item, _(category_name))

   140

                self.Tree.SetPyData(category_item, {"type" : CATEGORY})

   141

                if wx.VERSION >= (2, 6, 0):

   142

                    blocktype_item, category_cookie = self.Tree.GetFirstChild(category_item)

   143

                else:

   144

                    blocktype_item, category_cookie = self.Tree.GetFirstChild(category_item, 0)        

   145

                for blocktype in category["list"]:

   146

                    if not blocktype_item.IsOk():

   147

                        blocktype_item = self.Tree.AppendItem(category_item, blocktype["name"])

   148

                        if wx.Platform != '__WXMSW__':

   149

                            blocktype_item, category_cookie = self.Tree.GetNextChild(category_item, category_cookie)

   150

                    else:

   151

                        self.Tree.SetItemText(blocktype_item, blocktype["name"])

   152

                    block_data = {"type" : BLOCK, 

   153

                                  "block_type" : blocktype["type"], 

   154

                                  "inputs" : tuple([type for name, type, modifier in blocktype["inputs"]]), 

   155

                                  "extension" : None}

   156

                    if blocktype["extensible"]:

   157

                        block_data["extension"] = len(blocktype["inputs"])

   158

                    self.Tree.SetPyData(blocktype_item, block_data)

   159

                    if selected_name == blocktype["name"]:

   160

                        self.Tree.SelectItem(blocktype_item)

   161

                        comment = blocktype["comment"]

   162

                        self.Comment.SetValue(_(comment) + blocktype.get("usage", ""))

   163

                    blocktype_item, category_cookie = self.Tree.GetNextChild(category_item, category_cookie)

   164

                while blocktype_item.IsOk():

   165

                    to_delete.append(blocktype_item)

   166

                    blocktype_item, category_cookie = self.Tree.GetNextChild(category_item, category_cookie)

   167

                category_item, root_cookie = self.Tree.GetNextChild(root, root_cookie)

   168

            while category_item.IsOk():

   169

                to_delete.append(category_item)

   170

                category_item, root_cookie = self.Tree.GetNextChild(root, root_cookie)

   171

            for item in to_delete:

   172

                self.Tree.Delete(item)

   173

   174

    def GetSelectedBlock(self):

   175

        selected = self.Tree.GetSelection()

   176

        if (selected.IsOk() and 

   177

            self.Tree.GetItemParent(selected) != self.Tree.GetRootItem() and 

   178

            selected != self.Tree.GetRootItem()):

   179

            selected_data = self.Tree.GetPyData(selected)

   180

            return {"type": self.Tree.GetItemText(selected), 

   181

                    "inputs": selected_data["inputs"]}

   182

        return None

   183

   184

    def SelectTreeItem(self, name, inputs):

   185

        item = self.FindTreeItem(self.Tree.GetRootItem(), name, inputs)

   186

        if item is not None and item.IsOk():

   187

            self.Tree.SelectItem(item)

   188

            self.Tree.EnsureVisible(item)

   189

   190

    def FindTreeItem(self, root, name, inputs = None):

   191

        if root.IsOk():

   192

            pydata = self.Tree.GetPyData(root)

   193

            if pydata is not None:

   194

                type_inputs = pydata.get("inputs", None)

   195

                type_extension = pydata.get("extension", None)

   196

                if inputs is not None and type_inputs is not None:

   197

                    if type_extension is not None:

   198

                        same_inputs = type_inputs == inputs[:type_extension]

   199

                    else:

   200

                        same_inputs = type_inputs == inputs

   201

                else:

   202

                    same_inputs = True

   203

            if pydata is not None and self.Tree.GetItemText(root) == name and same_inputs:

   204

                return root

   205

            else:

   206

                if wx.VERSION < (2, 6, 0):

   207

                    item, root_cookie = self.Tree.GetFirstChild(root, 0)

   208

                else:

   209

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

   210

                while item.IsOk():

   211

                    result = self.FindTreeItem(item, name, inputs)

   212

                    if result:

   213

                        return result

   214

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

   215

        return None

   216

   217

    def SearchInTree(self, value, mode="first"):

   218

        root = self.Tree.GetRootItem()

   222

        if mode == "first":

   223

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

   224

            selected = None

   225

        else:

   226

            item = self.Tree.GetSelection()

   227

            selected = item

   228

            if not item.IsOk():

   229

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

   230

        while item.IsOk():

   231

            item_pydata = self.Tree.GetPyData(item)

   232

            if item_pydata["type"] == CATEGORY:

   233

                if mode == "previous":

   234

                    child = self.Tree.GetLastChild(item)

   235

                else:

   236

                    child, child_cookie = self.Tree.GetFirstChild(item)

   237

                if child.IsOk():

   238

                    item = child

   239

                elif mode == "previous":

   240

                    item = self.Tree.GetPrevSibling(item)

   241

                else:

   242

                    item = self.Tree.GetNextSibling(item)

   243

            else:

   244

                name = self.Tree.GetItemText(item)

   245

                if name.upper().startswith(value.upper()) and item != selected:

   250

                    self.Tree.SelectItem(item)

   251

                    self.Tree.EnsureVisible(item)

   252

                    return True

   253

   254

                elif mode == "previous":

   255

                    previous = self.Tree.GetPrevSibling(item)

   256

                    if previous.IsOk():

   257

                        item = previous

   258

                    else:

   259

                        parent = self.Tree.GetItemParent(item)

   260

                        item = self.Tree.GetPrevSibling(parent)

   261

   262

                else:

   263

                    next = self.Tree.GetNextSibling(item)

   264

                    if next.IsOk():

   265

                        item = next

   266

                    else:

   267

                        parent = self.Tree.GetItemParent(item)

   268

                        item = self.Tree.GetNextSibling(parent)

   269

        return False

   270

   271

    def OnSearchCtrlChanged(self, event):

   272

        self.SearchInTree(self.SearchCtrl.GetValue())

   273

        event.Skip()

   274

   275

    def OnSearchButtonClick(self, event):

   276

        self.SearchInTree(self.SearchCtrl.GetValue(), "next")

   277

        event.Skip()

   278

   279

    def OnTreeItemSelected(self, event):

   280

        selected = event.GetItem()

   281

        pydata = self.Tree.GetPyData(selected)

   282

        if pydata is not None and pydata["type"] != CATEGORY:

   283

            blocktype = self.Controler.GetBlockType(self.Tree.GetItemText(selected), pydata["inputs"])

   284

            if blocktype:

   285

                comment = blocktype["comment"]

   286

                self.Comment.SetValue(_(comment) + blocktype.get("usage", ""))

   287

            else:

   288

                self.Comment.SetValue("")

   289

        else:

   290

            self.Comment.SetValue("")

   291

        if getattr(self, "_OnTreeItemSelected", None) is not None:

   292

            self._OnTreeItemSelected(event)

   293

        event.Skip()

   294

   295

    def OnTreeBeginDrag(self, event):

   296

        selected = event.GetItem()

   297

        pydata = self.Tree.GetPyData(selected)

   298

        if pydata is not None and pydata["type"] == BLOCK:

   299

            data = wx.TextDataObject(str((self.Tree.GetItemText(selected), 

   300

                pydata["block_type"], "", pydata["inputs"])))

   301

            dragSource = wx.DropSource(self.Tree)

   302

            dragSource.SetData(data)

   303

            dragSource.DoDragDrop()

   304

   305

    def OnKeyDown(self, event):

   306

        keycode = event.GetKeyCode()

   307

        search_value = self.SearchCtrl.GetValue()

   308

        if keycode == wx.WXK_UP and search_value != "":

   309

            self.SearchInTree(search_value, "previous")

   310

        elif keycode == wx.WXK_DOWN and search_value != "":

   311

            self.SearchInTree(search_value, "next")

   312

        else:

   313

            event.Skip()