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

from __future__ import division

    28

from collections import namedtuple

    29

    30

import wx

    31

import wx.lib.agw.customtreectrl as CT

    32

import wx.lib.buttons

    33

    34

from plcopen.types_enums import *

    35

    36

from util.BitmapLibrary import GetBitmap

    37

    38

    39

# Customize CustomTreeItem for adding icon on item right

    40

CT.GenericTreeItem._rightimages = []

    41

    42

    43

def SetRightImages(self, images):

    44

    self._rightimages = images

    45

    46

    47

CT.GenericTreeItem.SetRightImages = SetRightImages

    48

    49

    50

def GetRightImages(self):

    51

    return self._rightimages

    52

    53

    54

CT.GenericTreeItem.GetRightImages = GetRightImages

    55

    56

    57

class CustomTreeCtrlWithRightImage(CT.CustomTreeCtrl):

    58

    59

    def SetRightImageList(self, imageList):

    60

        self._imageListRight = imageList

    61

    62

    def GetLineHeight(self, item):

    63

        height = CT.CustomTreeCtrl.GetLineHeight(self, item)

    64

        rightimages = item.GetRightImages()

    65

        if len(rightimages) > 0:

    66

            _r_image_w, r_image_h = self._imageListRight.GetSize(rightimages[0])

    67

            return max(height, r_image_h + 8)

    68

        return height

    69

    70

    def GetItemRightImagesBBox(self, item):

    71

        rightimages = item.GetRightImages()

    72

        if len(rightimages) > 0:

    73

            w, _h = self.GetClientSize()

    74

            total_h = self.GetLineHeight(item)

    75

            r_image_w, r_image_h = self._imageListRight.GetSize(rightimages[0])

    76

    77

            bbox_width = (r_image_w + 4) * len(rightimages) + 4

    78

            bbox_height = r_image_h + 8

    79

            bbox_x = w - bbox_width

    80

            bbox_y = item.GetY() + ((total_h > r_image_h) and [(total_h-r_image_h)//2] or [0])[0]

    81

    82

            return wx.Rect(bbox_x, bbox_y, bbox_width, bbox_height)

    83

    84

        return None

    85

    86

    def IsOverItemRightImage(self, item, point):

    87

        rightimages = item.GetRightImages()

    88

        if len(rightimages) > 0:

    89

            point = self.CalcUnscrolledPosition(point)

    90

            r_image_w, r_image_h = self._imageListRight.GetSize(rightimages[0])

    91

            images_bbx = self.GetItemRightImagesBBox(item)

    92

    93

            rect = wx.Rect(images_bbx.x + 4, images_bbx.y + 4,

    94

                           r_image_w, r_image_h)

    95

            for r_image in rightimages:

    96

                if rect.Contains(point):

    97

                    return r_image

    98

                rect.x += r_image_w + 4

    99

   100

            return None

   101

   102

    def PaintItem(self, item, dc, level, align):

   103

        CT.CustomTreeCtrl.PaintItem(self, item, dc, level, align)

   104

   105

        rightimages = item.GetRightImages()

   106

        if len(rightimages) > 0:

   107

            images_bbx = self.GetItemRightImagesBBox(item)

   108

            r_image_w, _r_image_h = self._imageListRight.GetSize(rightimages[0])

   109

   110

            dc.SetBrush(wx.TRANSPARENT_BRUSH)

   111

            dc.SetPen(wx.TRANSPARENT_PEN)

   112

   113

            dc.DrawRectangle(images_bbx.x, images_bbx.y,

   114

                             images_bbx.width, images_bbx.height)

   115

            x_pos = images_bbx.x + 4

   116

            for r_image in rightimages:

   117

                self._imageListRight.Draw(

   118

                    r_image, dc, x_pos, images_bbx.y + 4,

   119

                    wx.IMAGELIST_DRAW_TRANSPARENT)

   120

                x_pos += r_image_w + 4

   121

   122

   123

_ButtonCallbacks = namedtuple("ButtonCallbacks", ["leftdown", "dclick"])

   124

   125

   126

class PouInstanceVariablesPanel(wx.Panel):

   127

   128

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

   129

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

   130

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

   131

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

   132

   133

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

   134

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

   135

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

   136

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

   137

                  self.ParentButton)

   138

   139

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

   140

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

   141

                  self.InstanceChoice)

   142

   143

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

   144

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

   145

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

   146

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

   147

                  self.DebugButton)

   148

   149

        self.VariablesList = CustomTreeCtrlWithRightImage(

   150

            self,

   151

            style=wx.SUNKEN_BORDER,

   152

            agwStyle=(CT.TR_NO_BUTTONS |

   153

                      CT.TR_SINGLE |

   154

                      CT.TR_HAS_VARIABLE_ROW_HEIGHT |

   155

                      CT.TR_HIDE_ROOT |

   156

                      CT.TR_NO_LINES |

   157

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

   158

        self.VariablesList.SetIndent(0)

   159

        self.VariablesList.SetSpacing(5)

   160

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

   161

        self.VariablesList.Bind(CT.EVT_TREE_ITEM_ACTIVATED,

   162

                                self.OnVariablesListItemActivated)

   163

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

   164

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

   165

   166

        self.TreeRightImageList = wx.ImageList(24, 24)

   167

        self.EditImage = self.TreeRightImageList.Add(GetBitmap("edit"))

   168

        self.DebugInstanceImage = self.TreeRightImageList.Add(GetBitmap("debug_instance"))

   169

        self.VariablesList.SetRightImageList(self.TreeRightImageList)

   170

   171

        self.ButtonCallBacks = {

   172

            self.EditImage: _ButtonCallbacks(

   173

                self.EditButtonCallback, None),

   174

            self.DebugInstanceImage: _ButtonCallbacks(

   175

                self.DebugButtonCallback, self.DebugButtonDClickCallback)}

   176

   177

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

   178

        buttons_sizer.Add(self.ParentButton)

   179

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

   180

        buttons_sizer.Add(self.DebugButton)

   181

        buttons_sizer.AddGrowableCol(1)

   182

        buttons_sizer.AddGrowableRow(0)

   183

   184

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

   185

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

   186

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

   187

        main_sizer.AddGrowableCol(0)

   188

        main_sizer.AddGrowableRow(1)

   189

   190

        self.SetSizer(main_sizer)

   191

   192

        self.ParentWindow = window

   193

        self.Controller = controller

   194

        self.Debug = debug

   195

        if not self.Debug:

   196

            self.DebugButton.Hide()

   197

   198

        self.PouTagName = None

   199

        self.PouInfos = None

   200

        self.PouInstance = None

   201

   202

    def __del__(self):

   203

        self.Controller = None

   204

   205

    def SetTreeImageList(self, tree_image_list):

   206

        self.VariablesList.SetImageList(tree_image_list)

   207

   208

    def SetController(self, controller):

   209

        self.Controller = controller

   210

   211

        self.RefreshView()

   212

   213

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

   214

        if self.Controller is not None:

   215

            if tagname == "Project":

   216

                config_name = self.Controller.GetProjectMainConfigurationName()

   217

                if config_name is not None:

   218

                    tagname = ComputeConfigurationName(config_name)

   219

            if pou_instance is not None:

   220

                self.PouInstance = pou_instance

   221

   222

            if self.PouTagName != tagname:

   223

                self.PouTagName = tagname

   224

                self.RefreshView()

   225

            else:

   226

                self.RefreshInstanceChoice()

   227

        else:

   228

            self.RefreshView()

   229

   230

    def ResetView(self):

   231

        self.Controller = None

   232

   233

        self.PouTagName = None

   234

        self.PouInfos = None

   235

        self.PouInstance = None

   236

   237

        self.RefreshView()

   238

   239

    def RefreshView(self):

   240

        self.Freeze()

   241

        self.VariablesList.DeleteAllItems()

   242

   243

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

   244

            if self.PouTagName.split('::')[0] in ['A', 'T']:

   245

                self.PouInfos = self.Controller.GetPouVariables('P::%s' % self.PouTagName.split('::')[1], self.Debug)

   246

            else:

   247

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

   248

            if None in self.Controller.GetEditedElementType(self.PouTagName, self.Debug) and self.PouInfos is not None:

   249

                self.PouInfos.debug = False

   250

        else:

   251

            self.PouInfos = None

   252

        if self.PouInfos is not None:

   253

            root = self.VariablesList.AddRoot("", data=self.PouInfos)

   254

            for var_infos in self.PouInfos.variables:

   255

                if var_infos.type is not None:

   256

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

   257

                else:

   258

                    text = var_infos.name

   259

   260

                right_images = []

   261

                if var_infos.edit:

   262

                    right_images.append(self.EditImage)

   263

   264

                if var_infos.debug and self.Debug:

   265

                    right_images.append(self.DebugInstanceImage)

   266

   267

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

   268

                item.SetRightImages(right_images)

   269

                self.VariablesList.SetItemImage(item, self.ParentWindow.GetTreeImage(var_infos.var_class))

   270

                self.VariablesList.SetPyData(item, var_infos)

   271

   272

        self.RefreshInstanceChoice()

   273

        self.RefreshButtons()

   274

   275

        self.Thaw()

   276

   277

    def RefreshInstanceChoice(self):

   278

        self.InstanceChoice.Clear()

   279

        self.InstanceChoice.SetValue("")

   280

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

   281

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

   282

            for instance in instances:

   283

                self.InstanceChoice.Append(instance)

   284

            if len(instances) == 1:

   285

                self.PouInstance = instances[0]

   286

            if self.PouInfos.var_class in [ITEM_CONFIGURATION, ITEM_RESOURCE]:

   287

                self.PouInstance = None

   288

                self.InstanceChoice.SetSelection(0)

   289

            elif self.PouInstance in instances:

   290

                self.InstanceChoice.SetStringSelection(self.PouInstance)

   291

            else:

   292

                self.PouInstance = None

   293

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

   294

   295

    def RefreshButtons(self):

   296

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

   297

        self.ParentButton.Enable(enabled and self.PouInfos.var_class != ITEM_CONFIGURATION)

   298

        self.DebugButton.Enable(enabled and self.PouInfos.debug and self.Debug)

   299

   300

        root = self.VariablesList.GetRootItem()

   301

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

   302

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

   303

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

   304

                panel = self.VariablesList.GetItemWindow(item)

   305

                if panel is not None:

   306

                    for child in panel.GetChildren():

   307

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

   308

                            child.Enable(enabled)

   309

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

   310

   311

    def EditButtonCallback(self, infos):

   312

        var_class = infos.var_class

   313

        if var_class == ITEM_RESOURCE:

   314

            tagname = ComputeConfigurationResourceName(

   315

                self.InstanceChoice.GetStringSelection(),

   316

                infos.name)

   317

        elif var_class == ITEM_TRANSITION:

   318

            tagname = ComputePouTransitionName(

   319

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

   320

                infos.name)

   321

        elif var_class == ITEM_ACTION:

   322

            tagname = ComputePouActionName(

   323

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

   324

                infos.name)

   325

        else:

   326

            var_class = ITEM_POU

   327

            tagname = ComputePouName(infos.type)

   328

        self.ParentWindow.EditProjectElement(var_class, tagname)

   329

   330

    def DebugButtonCallback(self, infos):

   331

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

   332

            var_class = infos.var_class

   333

            instance_path = self.InstanceChoice.GetStringSelection()

   334

            if self.PouTagName.split("::")[0] in ["A", "T"]:

   335

                pos = instance_path.rfind('.')

   336

                instance_path = instance_path[0:pos]

   337

            var_path = "%s.%s" % (instance_path, infos.name)

   338

            if var_class in ITEMS_VARIABLE:

   339

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

   340

            elif var_class == ITEM_TRANSITION:

   341

                self.ParentWindow.OpenDebugViewer(

   342

                    var_class,

   343

                    var_path,

   344

                    ComputePouTransitionName(

   345

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

   346

                        infos.name))

   347

            elif var_class == ITEM_ACTION:

   348

                self.ParentWindow.OpenDebugViewer(

   349

                    var_class,

   350

                    var_path,

   351

                    ComputePouActionName(

   352

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

   353

                        infos.name))

   354

            else:

   355

                self.ParentWindow.OpenDebugViewer(

   356

                    var_class,

   357

                    var_path,

   358

                    ComputePouName(infos.type))

   359

   360

    def DebugButtonDClickCallback(self, infos):

   361

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

   362

            if infos.var_class in ITEMS_VARIABLE:

   363

                self.ParentWindow.AddDebugVariable(

   364

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

   365

                               infos.name),

   366

                    force=True,

   367

                    graph=True)

   368

   369

    def ShowInstanceChoicePopup(self):

   370

        self.InstanceChoice.SetFocusFromKbd()

   371

        size = self.InstanceChoice.GetSize()

   372

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

   373

        event.x = size.width // 2

   374

        event.y = size.height // 2

   375

        event.SetEventObject(self.InstanceChoice)

   376

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

   377

        # event.m_keyCode = wx.WXK_SPACE

   378

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

   379

   380

    def OnParentButtonClick(self, event):

   381

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

   382

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

   383

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

   384

            if tagname is not None:

   385

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

   386

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

   387

        event.Skip()

   388

   389

    def OnInstanceChoiceChanged(self, event):

   390

        self.RefreshButtons()

   391

        event.Skip()

   392

   393

    def OnDebugButtonClick(self, event):

   394

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

   395

            self.ParentWindow.OpenDebugViewer(

   396

                self.PouInfos.var_class,

   397

                self.InstanceChoice.GetStringSelection(),

   398

                self.PouTagName)

   399

        event.Skip()

   400

   401

    def OnVariablesListItemActivated(self, event):

   402

        selected_item = event.GetItem()

   403

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

   404

            item_infos = self.VariablesList.GetPyData(selected_item)

   405

            if item_infos is not None:

   406

   407

                item_button = self.VariablesList.IsOverItemRightImage(

   408

                    selected_item, event.GetPoint())

   409

                if item_button is not None:

   410

                    callback = self.ButtonCallBacks[item_button].dclick

   411

                    if callback is not None:

   412

                        callback(item_infos)

   413

   414

                elif item_infos.var_class not in ITEMS_VARIABLE:

   415

                    instance_path = self.InstanceChoice.GetStringSelection()

   416

                    if item_infos.var_class == ITEM_RESOURCE:

   417

                        if instance_path != "":

   418

                            tagname = ComputeConfigurationResourceName(

   419

                                instance_path,

   420

                                item_infos.name)

   421

                        else:

   422

                            tagname = None

   423

                    else:

   424

                        parent_infos = self.VariablesList.GetPyData(selected_item.GetParent())

   425

                        if item_infos.var_class == ITEM_ACTION:

   426

                            tagname = ComputePouActionName(parent_infos.type, item_infos.name)

   427

                        elif item_infos.var_class == ITEM_TRANSITION:

   428

                            tagname = ComputePouTransitionName(parent_infos.type, item_infos.name)

   429

                        else:

   430

                            tagname = ComputePouName(item_infos.type)

   431

                    if tagname is not None:

   432

                        if instance_path != "":

   433

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

   434

                        else:

   435

                            item_path = None

   436

                        self.SetPouType(tagname, item_path)

   437

                        self.ParentWindow.SelectProjectTreeItem(tagname)

   438

        event.Skip()

   439

   440

    def OnVariablesListLeftDown(self, event):

   441

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

   442

            wx.CallAfter(self.ShowInstanceChoicePopup)

   443

        else:

   444

            instance_path = self.InstanceChoice.GetStringSelection()

   445

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

   446

            if item is not None:

   447

                item_infos = self.VariablesList.GetPyData(item)

   448

                if item_infos is not None:

   449

   450

                    item_button = self.VariablesList.IsOverItemRightImage(

   451

                        item, event.GetPosition())

   452

                    if item_button is not None:

   453

                        callback = self.ButtonCallBacks[item_button].leftdown

   454

                        if callback is not None:

   455

                            callback(item_infos)

   456

   457

                    elif (flags & CT.TREE_HITTEST_ONITEMLABEL and

   458

                          item_infos.var_class in ITEMS_VARIABLE):

   459

                        self.ParentWindow.EnsureTabVisible(

   460

                            self.ParentWindow.DebugVariablePanel)

   461

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

   462

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

   463

                        dragSource = wx.DropSource(self.VariablesList)

   464

                        dragSource.SetData(data)

   465

                        dragSource.DoDragDrop()

   466

        event.Skip()

   467

   468

    def OnVariablesListKeyDown(self, event):

   469

        keycode = event.GetKeyCode()

   470

        if keycode != wx.WXK_LEFT:

   471

            event.Skip()