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) 2012: 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

import wx.lib.agw.customtreectrl as CT

    27

    28

import wx.lib.imageutils

    29

import wx.lib.buttons

    30

GrayedBitmapCache = {}

    31

def SetBitmapLabel(self, bitmap, createOthers=True):

    32

    """

    33

    Set the bitmap to display normally.

    34

    This is the only one that is required. If

    35

    createOthers is True, then the other bitmaps

    36

    will be generated on the fly.  Currently,

    37

    only the disabled bitmap is generated.

    38

    """

    39

    self.bmpLabel = bitmap

    40

    if bitmap is not None and createOthers:

    41

        GrayBitmap=GrayedBitmapCache.get(bitmap,None)

    42

        if GrayBitmap is None:

    43

            image = wx.ImageFromBitmap(bitmap)

    44

            wx.lib.imageutils.grayOut(image)

    45

            GrayBitmap = wx.BitmapFromImage(image)

    46

            GrayedBitmapCache[bitmap] = GrayBitmap

    47

        self.SetBitmapDisabled(GrayBitmap)

    48

wx.lib.buttons.GenBitmapButton.SetBitmapLabel = SetBitmapLabel

    49

    50

try:

    51

    import matplotlib

    52

    matplotlib.use('WX')

    53

    USE_MPL = True

    54

except:

    55

    USE_MPL = False

    56

    57

from PLCControler import ITEMS_VARIABLE, ITEM_CONFIGURATION, ITEM_RESOURCE, ITEM_POU, ITEM_TRANSITION, ITEM_ACTION

    58

from util.BitmapLibrary import GetBitmap

    59

    60

class PouInstanceVariablesPanel(wx.Panel):

    61

    62

    def __init__(self, parent, window, controller, debug):

    63

        wx.Panel.__init__(self, name='PouInstanceTreePanel', 

    64

                parent=parent, pos=wx.Point(0, 0), 

    65

                size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)

    66

    67

        self.ParentButton = wx.lib.buttons.GenBitmapButton(self,

    68

              bitmap=GetBitmap("top"), size=wx.Size(28, 28), style=wx.NO_BORDER)

    69

        self.ParentButton.SetToolTipString(_("Parent instance"))

    70

        self.Bind(wx.EVT_BUTTON, self.OnParentButtonClick, 

    71

                self.ParentButton)

    72

    73

        self.InstanceChoice = wx.ComboBox(self, size=wx.Size(0, 0), style=wx.CB_READONLY)

    74

        self.Bind(wx.EVT_COMBOBOX, self.OnInstanceChoiceChanged,

    75

                self.InstanceChoice)

    76

    77

        self.DebugButton = wx.lib.buttons.GenBitmapButton(self, 

    78

              bitmap=GetBitmap("debug_instance"), size=wx.Size(28, 28), style=wx.NO_BORDER)

    79

        self.DebugButton.SetToolTipString(_("Debug instance"))

    80

        self.Bind(wx.EVT_BUTTON, self.OnDebugButtonClick, 

    81

                self.DebugButton)

    82

    83

        self.VariablesList = CT.CustomTreeCtrl(self,

    84

              style=wx.SUNKEN_BORDER,

    85

              agwStyle=CT.TR_NO_BUTTONS|

    86

                       CT.TR_SINGLE|

    87

                       CT.TR_HAS_VARIABLE_ROW_HEIGHT|

    88

                       CT.TR_HIDE_ROOT|

    89

                       CT.TR_NO_LINES|

    90

                       getattr(CT, "TR_ALIGN_WINDOWS_RIGHT", CT.TR_ALIGN_WINDOWS))

    91

        self.VariablesList.SetIndent(0)

    92

        self.VariablesList.SetSpacing(5)

    93

        self.VariablesList.DoSelectItem = lambda *x,**y:True

    94

        self.VariablesList.Bind(CT.EVT_TREE_ITEM_ACTIVATED,

    95

                self.OnVariablesListItemActivated)

    96

        self.VariablesList.Bind(wx.EVT_LEFT_DOWN, self.OnVariablesListLeftDown)

    97

        self.VariablesList.Bind(wx.EVT_KEY_DOWN, self.OnVariablesListKeyDown)

    98

    99

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

   100

        buttons_sizer.AddWindow(self.ParentButton)

   101

        buttons_sizer.AddWindow(self.InstanceChoice, flag=wx.GROW)

   102

        buttons_sizer.AddWindow(self.DebugButton)

   103

        buttons_sizer.AddGrowableCol(1)

   104

        buttons_sizer.AddGrowableRow(0)

   105

   106

        main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   107

        main_sizer.AddSizer(buttons_sizer, flag=wx.GROW)

   108

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

   109

        main_sizer.AddGrowableCol(0)

   110

        main_sizer.AddGrowableRow(1)

   111

   112

        self.SetSizer(main_sizer)

   113

   114

        self.ParentWindow = window

   115

        self.Controller = controller

   116

        self.Debug = debug

   117

        if not self.Debug:

   118

            self.DebugButton.Hide()

   119

   120

        self.PouTagName = None

   121

        self.PouInfos = None

   122

        self.PouInstance = None

   123

   124

    def __del__(self):

   125

        self.Controller = None

   126

   127

    def SetTreeImageList(self, tree_image_list):

   128

        self.VariablesList.SetImageList(tree_image_list)

   129

   130

    def SetController(self, controller):

   131

        self.Controller = controller

   132

   133

        self.RefreshView()

   134

   135

    def SetPouType(self, tagname, pou_instance=None):

   136

        if self.Controller is not None:

   137

            if tagname == "Project":

   138

                config_name = self.Controller.GetProjectMainConfigurationName()

   139

                if config_name is not None:

   140

                    tagname = self.Controller.ComputeConfigurationName(config_name)

   141

            if pou_instance is not None:

   142

                self.PouInstance = pou_instance

   143

   144

            if self.PouTagName != tagname:

   145

                self.PouTagName = tagname

   146

                self.RefreshView()

   147

            else:

   148

                self.RefreshInstanceChoice()

   149

        else:

   150

            self.RefreshView()

   151

   152

    def ResetView(self):

   153

        self.Controller = None

   154

   155

        self.PouTagName = None

   156

        self.PouInfos = None

   157

        self.PouInstance = None

   158

   159

        self.RefreshView()

   160

   161

    def RefreshView(self):

   162

        self.Freeze()

   163

        self.VariablesList.DeleteAllItems()

   164

   165

        if self.Controller is not None and self.PouTagName is not None:

   166

            self.PouInfos = self.Controller.GetPouVariables(self.PouTagName, self.Debug)

   167

        else:

   168

            self.PouInfos = None

   169

        if self.PouInfos is not None:

   170

            root = self.VariablesList.AddRoot("")

   171

            for var_infos in self.PouInfos["variables"]:

   172

                if var_infos.get("type", None) is not None:

   173

                    text = "%(name)s (%(type)s)" % var_infos

   174

                else:

   175

                    text = var_infos["name"]

   176

   177

                panel = wx.Panel(self.VariablesList)

   178

   179

                buttons = []

   180

                if var_infos["class"] in ITEMS_VARIABLE:

   181

                    if (not USE_MPL and var_infos["debug"] and self.Debug and

   182

                        (self.Controller.IsOfType(var_infos["type"], "ANY_NUM", True) or

   183

                         self.Controller.IsOfType(var_infos["type"], "ANY_BIT", True))):

   184

                        graph_button = wx.lib.buttons.GenBitmapButton(panel, 

   185

                              bitmap=GetBitmap("instance_graph"), 

   186

                              size=wx.Size(28, 28), style=wx.NO_BORDER)

   187

                        self.Bind(wx.EVT_BUTTON, self.GenGraphButtonCallback(var_infos), graph_button)

   188

                        buttons.append(graph_button)

   189

                elif var_infos["edit"]:

   190

                    edit_button = wx.lib.buttons.GenBitmapButton(panel, 

   191

                          bitmap=GetBitmap("edit"), 

   192

                          size=wx.Size(28, 28), style=wx.NO_BORDER)

   193

                    self.Bind(wx.EVT_BUTTON, self.GenEditButtonCallback(var_infos), edit_button)

   194

                    buttons.append(edit_button)

   195

   196

                if var_infos["debug"] and self.Debug:

   197

                    debug_button = wx.lib.buttons.GenBitmapButton(panel, 

   198

                          bitmap=GetBitmap("debug_instance"), 

   199

                          size=wx.Size(28, 28), style=wx.NO_BORDER)

   200

                    self.Bind(wx.EVT_BUTTON, self.GenDebugButtonCallback(var_infos), debug_button)

   201

                    debug_button.Bind(wx.EVT_LEFT_DCLICK, self.GenDebugButtonDClickCallback(var_infos))

   202

                    buttons.append(debug_button)

   203

   204

                button_num = len(buttons)

   205

                if button_num > 0:

   206

                    panel.SetSize(wx.Size(button_num * 32, 28))

   207

                    panel.SetBackgroundColour(self.VariablesList.GetBackgroundColour())

   208

                    panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

   209

                    panel.SetSizer(panel_sizer)

   210

   211

                    for button in buttons:

   212

                        panel_sizer.AddWindow(button, 0, border=4, flag=wx.LEFT)

   213

                    panel_sizer.Layout()

   214

   215

                else:

   216

                    panel.Destroy()

   217

                    panel = None

   218

   219

                item = self.VariablesList.AppendItem(root, text, wnd=panel)

   220

                self.VariablesList.SetItemImage(item, self.ParentWindow.GetTreeImage(var_infos["class"]))

   221

                self.VariablesList.SetPyData(item, var_infos)

   222

   223

        self.RefreshInstanceChoice()

   224

        self.RefreshButtons()

   225

   226

        self.Thaw()

   227

   228

    def RefreshInstanceChoice(self):

   229

        self.InstanceChoice.Clear()

   230

        self.InstanceChoice.SetValue("")

   231

        if self.Controller is not None and self.PouInfos is not None:

   232

            instances = self.Controller.SearchPouInstances(self.PouTagName, self.Debug)

   233

            for instance in instances:

   234

                self.InstanceChoice.Append(instance)

   235

            if len(instances) == 1:

   236

                self.PouInstance = instances[0]

   237

            if self.PouInfos["class"] in [ITEM_CONFIGURATION, ITEM_RESOURCE]:

   238

                self.PouInstance = None

   239

                self.InstanceChoice.SetSelection(0)

   240

            elif self.PouInstance in instances:

   241

                self.InstanceChoice.SetStringSelection(self.PouInstance)

   242

            else:

   243

                self.PouInstance = None

   244

                self.InstanceChoice.SetValue(_("Select an instance"))

   245

   246

    def RefreshButtons(self):

   247

        enabled = self.InstanceChoice.GetSelection() != -1

   248

        self.ParentButton.Enable(enabled and self.PouInfos["class"] != ITEM_CONFIGURATION)

   249

        self.DebugButton.Enable(enabled and self.PouInfos["debug"] and self.Debug)

   250

   251

        root = self.VariablesList.GetRootItem()

   252

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

   253

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

   254

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

   255

                panel = self.VariablesList.GetItemWindow(item)

   256

                if panel is not None:

   257

                    for child in panel.GetChildren():

   258

                        if child.GetName() != "edit":

   259

                            child.Enable(enabled)

   260

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

   261

   262

    def GenEditButtonCallback(self, infos):

   263

        def EditButtonCallback(event):

   264

            var_class = infos["class"]

   265

            if var_class == ITEM_RESOURCE:

   266

                tagname = self.Controller.ComputeConfigurationResourceName(

   267

                    self.InstanceChoice.GetStringSelection(), 

   268

                    infos["name"])

   269

            elif var_class == ITEM_TRANSITION:

   270

                tagname = self.Controller.ComputePouTransitionName(

   271

                    self.PouTagName.split("::")[1],

   272

                    infos["name"])

   273

            elif var_class == ITEM_ACTION:

   274

                tagname = self.Controller.ComputePouActionName(

   275

                    self.PouTagName.split("::")[1],

   276

                    infos["name"])

   277

            else:

   278

                var_class = ITEM_POU

   279

                tagname = self.Controller.ComputePouName(infos["type"])

   280

            self.ParentWindow.EditProjectElement(var_class, tagname)

   281

            event.Skip()

   282

        return EditButtonCallback

   283

   284

    def GenDebugButtonCallback(self, infos):

   285

        def DebugButtonCallback(event):

   286

            if self.InstanceChoice.GetSelection() != -1:

   287

                var_class = infos["class"]

   288

                var_path = "%s.%s" % (self.InstanceChoice.GetStringSelection(), 

   289

                                      infos["name"])

   290

                if var_class in ITEMS_VARIABLE:

   291

                    self.ParentWindow.AddDebugVariable(var_path, force=True)

   292

                elif var_class == ITEM_TRANSITION:

   293

                    self.ParentWindow.OpenDebugViewer(

   294

                        var_class,

   295

                        var_path,

   296

                        self.Controller.ComputePouTransitionName(

   297

                            self.PouTagName.split("::")[1],

   298

                            infos["name"]))

   299

                elif var_class == ITEM_ACTION:

   300

                    self.ParentWindow.OpenDebugViewer(

   301

                        var_class,

   302

                        var_path,

   303

                        self.Controller.ComputePouActionName(

   304

                            self.PouTagName.split("::")[1],

   305

                            infos["name"]))

   306

                else:

   307

                    self.ParentWindow.OpenDebugViewer(

   308

                        var_class,

   309

                        var_path,

   310

                        self.Controller.ComputePouName(infos["type"]))

   311

            event.Skip()

   312

        return DebugButtonCallback

   313

   314

    def GenDebugButtonDClickCallback(self, infos):

   315

        def DebugButtonDClickCallback(event):

   316

            if self.InstanceChoice.GetSelection() != -1:

   317

                if infos["class"] in ITEMS_VARIABLE:

   318

                    self.ParentWindow.AddDebugVariable(

   319

                        "%s.%s" % (self.InstanceChoice.GetStringSelection(), 

   320

                                   infos["name"]), 

   321

                        force=True,

   322

                        graph=True)

   323

            event.Skip()

   324

        return DebugButtonDClickCallback

   325

   326

    def GenGraphButtonCallback(self, infos):

   327

        def GraphButtonCallback(event):

   328

            if self.InstanceChoice.GetSelection() != -1:

   329

                if infos["class"] in ITEMS_VARIABLE:

   330

                    var_path = "%s.%s" % (self.InstanceChoice.GetStringSelection(), 

   331

                                          infos["name"])

   332

                    self.ParentWindow.OpenDebugViewer(infos["class"], var_path, infos["type"])

   333

            event.Skip()

   334

        return GraphButtonCallback

   335

   336

    def ShowInstanceChoicePopup(self):

   337

        self.InstanceChoice.SetFocusFromKbd()

   338

        size = self.InstanceChoice.GetSize()

   339

        event = wx.MouseEvent(wx.EVT_LEFT_DOWN._getEvtType())

   340

        event.m_x = size.width / 2

   341

        event.m_y = size.height / 2

   342

        event.SetEventObject(self.InstanceChoice)

   343

        #event = wx.KeyEvent(wx.EVT_KEY_DOWN._getEvtType())

   344

        #event.m_keyCode = wx.WXK_SPACE

   345

        self.InstanceChoice.GetEventHandler().ProcessEvent(event)

   346

   347

    def OnParentButtonClick(self, event):

   348

        if self.InstanceChoice.GetSelection() != -1:

   349

            parent_path = self.InstanceChoice.GetStringSelection().rsplit(".", 1)[0]

   350

            tagname = self.Controller.GetPouInstanceTagName(parent_path, self.Debug)

   351

            if tagname is not None:

   352

                wx.CallAfter(self.SetPouType, tagname, parent_path)

   353

                wx.CallAfter(self.ParentWindow.SelectProjectTreeItem, tagname)

   354

        event.Skip()

   355

   356

    def OnInstanceChoiceChanged(self, event):

   357

        self.RefreshButtons()

   358

        event.Skip()

   359

   360

    def OnDebugButtonClick(self, event):

   361

        if self.InstanceChoice.GetSelection() != -1:

   362

            self.ParentWindow.OpenDebugViewer(

   363

                self.PouInfos["class"],

   364

                self.InstanceChoice.GetStringSelection(),

   365

                self.PouTagName)

   366

        event.Skip()

   367

   368

    def OnVariablesListItemActivated(self, event):

   369

        selected_item = event.GetItem()

   370

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

   371

            item_infos = self.VariablesList.GetPyData(selected_item)

   372

            if item_infos is not None and item_infos["class"] not in ITEMS_VARIABLE:

   373

                instance_path = self.InstanceChoice.GetStringSelection()

   374

                if item_infos["class"] == ITEM_RESOURCE:

   375

                    if instance_path != "":

   376

                        tagname = self.Controller.ComputeConfigurationResourceName(

   377

                                       instance_path, 

   378

                                       item_infos["name"])

   379

                    else:

   380

                        tagname = None

   381

                else:

   382

                    tagname = self.Controller.ComputePouName(item_infos["type"])

   383

                if tagname is not None:

   384

                    if instance_path != "":

   385

                        item_path = "%s.%s" % (instance_path, item_infos["name"])

   386

                    else:

   387

                        item_path = None

   388

                    self.SetPouType(tagname, item_path)

   389

                    self.ParentWindow.SelectProjectTreeItem(tagname)

   390

        event.Skip()

   391

   392

    def OnVariablesListLeftDown(self, event):

   393

        if self.InstanceChoice.GetSelection() == -1:

   394

            wx.CallAfter(self.ShowInstanceChoicePopup)

   395

        else:

   396

            instance_path = self.InstanceChoice.GetStringSelection()

   397

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

   398

            if item is not None and flags & CT.TREE_HITTEST_ONITEMLABEL:

   399

                item_infos = self.VariablesList.GetPyData(item)

   400

                if item_infos is not None and item_infos["class"] in ITEMS_VARIABLE:

   401

                    self.ParentWindow.EnsureTabVisible(

   402

                        self.ParentWindow.DebugVariablePanel)

   403

                    item_path = "%s.%s" % (instance_path, item_infos["name"])

   404

                    data = wx.TextDataObject(str((item_path, "debug")))

   405

                    dragSource = wx.DropSource(self.VariablesList)

   406

                    dragSource.SetData(data)

   407

                    dragSource.DoDragDrop()

   408

        event.Skip()

   409

   410

    def OnVariablesListKeyDown(self, event):

   411

        keycode = event.GetKeyCode()

   412

        if keycode != wx.WXK_LEFT:

   413

            event.Skip()

   414