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 collections import namedtuple

    28

    29

import wx

    30

import wx.lib.agw.customtreectrl as CT

    31

import wx.lib.buttons

    32

    33

from plcopen.types_enums import *

    34

    35

from util.BitmapLibrary import GetBitmap

    36

    37

    38

# Customize CustomTreeItem for adding icon on item right

    39

CT.GenericTreeItem._rightimages = []

    40

    41

    42

def SetRightImages(self, images):

    43

    self._rightimages = images

    44

    45

    46

CT.GenericTreeItem.SetRightImages = SetRightImages

    47

    48

    49

def GetRightImages(self):

    50

    return self._rightimages

    51

    52

    53

CT.GenericTreeItem.GetRightImages = GetRightImages

    54

    55

    56

class CustomTreeCtrlWithRightImage(CT.CustomTreeCtrl):

    57

    58

    def SetRightImageList(self, imageList):

    59

        self._imageListRight = imageList

    60

    61

    def GetLineHeight(self, item):

    62

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

    63

        rightimages = item.GetRightImages()

    64

        if len(rightimages) > 0:

    65

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

    66

            return max(height, r_image_h + 8)

    67

        return height

    68

    69

    def GetItemRightImagesBBox(self, item):

    70

        rightimages = item.GetRightImages()

    71

        if len(rightimages) > 0:

    72

            w, _h = self.GetClientSize()

    73

            total_h = self.GetLineHeight(item)

    74

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

    75

    76

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

    77

            bbox_height = r_image_h + 8

    78

            bbox_x = w - bbox_width

    79

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

    80

    81

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

    82

    83

        return None

    84

    85

    def IsOverItemRightImage(self, item, point):

    86

        rightimages = item.GetRightImages()

    87

        if len(rightimages) > 0:

    88

            point = self.CalcUnscrolledPosition(point)

    89

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

    90

            images_bbx = self.GetItemRightImagesBBox(item)

    91

    92

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

    93

                           r_image_w, r_image_h)

    94

            for r_image in rightimages:

    95

                if rect.Inside(point):

    96

                    return r_image

    97

                rect.x += r_image_w + 4

    98

    99

            return None

   100

   101

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

   102

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

   103

   104

        rightimages = item.GetRightImages()

   105

        if len(rightimages) > 0:

   106

            images_bbx = self.GetItemRightImagesBBox(item)

   107

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

   108

   109

            dc.SetBrush(wx.TRANSPARENT_BRUSH)

   110

            dc.SetPen(wx.TRANSPARENT_PEN)

   111

   112

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

   113

                             images_bbx.width, images_bbx.height)

   114

            x_pos = images_bbx.x + 4

   115

            for r_image in rightimages:

   116

                self._imageListRight.Draw(

   117

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

   118

                    wx.IMAGELIST_DRAW_TRANSPARENT)

   119

                x_pos += r_image_w + 4

   120

   121

   122

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

   123

   124

   125

class PouInstanceVariablesPanel(wx.Panel):

   126

   127

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

   128

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

   129

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

   130

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

   131

   132

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

   133

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

   134

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

   135

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

   136

                  self.ParentButton)

   137

   138

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

   139

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

   140

                  self.InstanceChoice)

   141

   142

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

   143

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

   144

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

   145

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

   146

                  self.DebugButton)

   147

   148

        self.VariablesList = CustomTreeCtrlWithRightImage(

   149

            self,

   150

            style=wx.SUNKEN_BORDER,

   151

            agwStyle=(CT.TR_NO_BUTTONS |

   152

                      CT.TR_SINGLE |

   153

                      CT.TR_HAS_VARIABLE_ROW_HEIGHT |

   154

                      CT.TR_HIDE_ROOT |

   155

                      CT.TR_NO_LINES |

   156

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

   157

        self.VariablesList.SetIndent(0)

   158

        self.VariablesList.SetSpacing(5)

   159

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

   160

        self.VariablesList.Bind(CT.EVT_TREE_ITEM_ACTIVATED,

   161

                                self.OnVariablesListItemActivated)

   162

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

   163

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

   164

   165

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

   166

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

   167

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

   168

        self.VariablesList.SetRightImageList(self.TreeRightImageList)

   169

   170

        self.ButtonCallBacks = {

   171

            self.EditImage: _ButtonCallbacks(

   172

                self.EditButtonCallback, None),

   173

            self.DebugInstanceImage: _ButtonCallbacks(

   174

                self.DebugButtonCallback, self.DebugButtonDClickCallback)}

   175

   176

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

   177

        buttons_sizer.AddWindow(self.ParentButton)

   178

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

   179

        buttons_sizer.AddWindow(self.DebugButton)

   180

        buttons_sizer.AddGrowableCol(1)

   181

        buttons_sizer.AddGrowableRow(0)

   182

   183

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

   184

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

   185

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

   186

        main_sizer.AddGrowableCol(0)

   187

        main_sizer.AddGrowableRow(1)

   188

   189

        self.SetSizer(main_sizer)

   190

   191

        self.ParentWindow = window

   192

        self.Controller = controller

   193

        self.Debug = debug

   194

        if not self.Debug:

   195

            self.DebugButton.Hide()

   196

   197

        self.PouTagName = None

   198

        self.PouInfos = None

   199

        self.PouInstance = None

   200

   201

    def __del__(self):

   202

        self.Controller = None

   203

   204

    def SetTreeImageList(self, tree_image_list):

   205

        self.VariablesList.SetImageList(tree_image_list)

   206

   207

    def SetController(self, controller):

   208

        self.Controller = controller

   209

   210

        self.RefreshView()

   211

   212

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

   213

        if self.Controller is not None:

   214

            if tagname == "Project":

   215

                config_name = self.Controller.GetProjectMainConfigurationName()

   216

                if config_name is not None:

   217

                    tagname = ComputeConfigurationName(config_name)

   218

            if pou_instance is not None:

   219

                self.PouInstance = pou_instance

   220

   221

            if self.PouTagName != tagname:

   222

                self.PouTagName = tagname

   223

                self.RefreshView()

   224

            else:

   225

                self.RefreshInstanceChoice()

   226

        else:

   227

            self.RefreshView()

   228

   229

    def ResetView(self):

   230

        self.Controller = None

   231

   232

        self.PouTagName = None

   233

        self.PouInfos = None

   234

        self.PouInstance = None

   235

   236

        self.RefreshView()

   237

   238

    def RefreshView(self):

   239

        self.Freeze()

   240

        self.VariablesList.DeleteAllItems()

   241

   242

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

   243

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

   244

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

   245

            else:

   246

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

   247

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

   248

                self.PouInfos.debug = False

   249

        else:

   250

            self.PouInfos = None

   251

        if self.PouInfos is not None:

   252

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

   253

            for var_infos in self.PouInfos.variables:

   254

                if var_infos.type is not None:

   255

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

   256

                else:

   257

                    text = var_infos.name

   258

   259

                right_images = []

   260

                if var_infos.edit:

   261

                    right_images.append(self.EditImage)

   262

   263

                if var_infos.debug and self.Debug:

   264

                    right_images.append(self.DebugInstanceImage)

   265

   266

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

   267

                item.SetRightImages(right_images)

   268

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

   269

                self.VariablesList.SetPyData(item, var_infos)

   270

   271

        self.RefreshInstanceChoice()

   272

        self.RefreshButtons()

   273

   274

        self.Thaw()

   275

   276

    def RefreshInstanceChoice(self):

   277

        self.InstanceChoice.Clear()

   278

        self.InstanceChoice.SetValue("")

   279

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

   280

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

   281

            for instance in instances:

   282

                self.InstanceChoice.Append(instance)

   283

            if len(instances) == 1:

   284

                self.PouInstance = instances[0]

   285

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

   286

                self.PouInstance = None

   287

                self.InstanceChoice.SetSelection(0)

   288

            elif self.PouInstance in instances:

   289

                self.InstanceChoice.SetStringSelection(self.PouInstance)

   290

            else:

   291

                self.PouInstance = None

   292

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

   293

   294

    def RefreshButtons(self):

   295

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

   296

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

   297

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

   298

   299

        root = self.VariablesList.GetRootItem()

   300

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

   301

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

   302

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

   303

                panel = self.VariablesList.GetItemWindow(item)

   304

                if panel is not None:

   305

                    for child in panel.GetChildren():

   306

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

   307

                            child.Enable(enabled)

   308

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

   309

   310

    def EditButtonCallback(self, infos):

   311

        var_class = infos.var_class

   312

        if var_class == ITEM_RESOURCE:

   313

            tagname = ComputeConfigurationResourceName(

   314

                self.InstanceChoice.GetStringSelection(),

   315

                infos.name)

   316

        elif var_class == ITEM_TRANSITION:

   317

            tagname = ComputePouTransitionName(

   318

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

   319

                infos.name)

   320

        elif var_class == ITEM_ACTION:

   321

            tagname = ComputePouActionName(

   322

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

   323

                infos.name)

   324

        else:

   325

            var_class = ITEM_POU

   326

            tagname = ComputePouName(infos.type)

   327

        self.ParentWindow.EditProjectElement(var_class, tagname)

   328

   329

    def DebugButtonCallback(self, infos):

   330

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

   331

            var_class = infos.var_class

   332

            instance_path = self.InstanceChoice.GetStringSelection()

   333

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

   334

                pos = instance_path.rfind('.')

   335

                instance_path = instance_path[0:pos]

   336

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

   337

            if var_class in ITEMS_VARIABLE:

   338

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

   339

            elif var_class == ITEM_TRANSITION:

   340

                self.ParentWindow.OpenDebugViewer(

   341

                    var_class,

   342

                    var_path,

   343

                    ComputePouTransitionName(

   344

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

   345

                        infos.name))

   346

            elif var_class == ITEM_ACTION:

   347

                self.ParentWindow.OpenDebugViewer(

   348

                    var_class,

   349

                    var_path,

   350

                    ComputePouActionName(

   351

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

   352

                        infos.name))

   353

            else:

   354

                self.ParentWindow.OpenDebugViewer(

   355

                    var_class,

   356

                    var_path,

   357

                    ComputePouName(infos.type))

   358

   359

    def DebugButtonDClickCallback(self, infos):

   360

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

   361

            if infos.var_class in ITEMS_VARIABLE:

   362

                self.ParentWindow.AddDebugVariable(

   363

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

   364

                               infos.name),

   365

                    force=True,

   366

                    graph=True)

   367

   368

    def ShowInstanceChoicePopup(self):

   369

        self.InstanceChoice.SetFocusFromKbd()

   370

        size = self.InstanceChoice.GetSize()

   371

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

   372

        event.x = size.width / 2

   373

        event.y = size.height / 2

   374

        event.SetEventObject(self.InstanceChoice)

   375

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

   376

        # event.m_keyCode = wx.WXK_SPACE

   377

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

   378

   379

    def OnParentButtonClick(self, event):

   380

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

   381

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

   382

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

   383

            if tagname is not None:

   384

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

   385

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

   386

        event.Skip()

   387

   388

    def OnInstanceChoiceChanged(self, event):

   389

        self.RefreshButtons()

   390

        event.Skip()

   391

   392

    def OnDebugButtonClick(self, event):

   393

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

   394

            self.ParentWindow.OpenDebugViewer(

   395

                self.PouInfos.var_class,

   396

                self.InstanceChoice.GetStringSelection(),

   397

                self.PouTagName)

   398

        event.Skip()

   399

   400

    def OnVariablesListItemActivated(self, event):

   401

        selected_item = event.GetItem()

   402

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

   403

            item_infos = self.VariablesList.GetPyData(selected_item)

   404

            if item_infos is not None:

   405

   406

                item_button = self.VariablesList.IsOverItemRightImage(

   407

                    selected_item, event.GetPoint())

   408

                if item_button is not None:

   409

                    callback = self.ButtonCallBacks[item_button].dclick

   410

                    if callback is not None:

   411

                        callback(item_infos)

   412

   413

                elif item_infos.var_class not in ITEMS_VARIABLE:

   414

                    instance_path = self.InstanceChoice.GetStringSelection()

   415

                    if item_infos.var_class == ITEM_RESOURCE:

   416

                        if instance_path != "":

   417

                            tagname = ComputeConfigurationResourceName(

   418

                                instance_path,

   419

                                item_infos.name)

   420

                        else:

   421

                            tagname = None

   422

                    else:

   423

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

   424

                        if item_infos.var_class == ITEM_ACTION:

   425

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

   426

                        elif item_infos.var_class == ITEM_TRANSITION:

   427

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

   428

                        else:

   429

                            tagname = ComputePouName(item_infos.type)

   430

                    if tagname is not None:

   431

                        if instance_path != "":

   432

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

   433

                        else:

   434

                            item_path = None

   435

                        self.SetPouType(tagname, item_path)

   436

                        self.ParentWindow.SelectProjectTreeItem(tagname)

   437

        event.Skip()

   438

   439

    def OnVariablesListLeftDown(self, event):

   440

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

   441

            wx.CallAfter(self.ShowInstanceChoicePopup)

   442

        else:

   443

            instance_path = self.InstanceChoice.GetStringSelection()

   444

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

   445

            if item is not None:

   446

                item_infos = self.VariablesList.GetPyData(item)

   447

                if item_infos is not None:

   448

   449

                    item_button = self.VariablesList.IsOverItemRightImage(

   450

                        item, event.GetPosition())

   451

                    if item_button is not None:

   452

                        callback = self.ButtonCallBacks[item_button].leftdown

   453

                        if callback is not None:

   454

                            callback(item_infos)

   455

   456

                    elif (flags & CT.TREE_HITTEST_ONITEMLABEL and

   457

                          item_infos.var_class in ITEMS_VARIABLE):

   458

                        self.ParentWindow.EnsureTabVisible(

   459

                            self.ParentWindow.DebugVariablePanel)

   460

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

   461

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

   462

                        dragSource = wx.DropSource(self.VariablesList)

   463

                        dragSource.SetData(data)

   464

                        dragSource.DoDragDrop()

   465

        event.Skip()

   466

   467

    def OnVariablesListKeyDown(self, event):

   468

        keycode = event.GetKeyCode()

   469

        if keycode != wx.WXK_LEFT:

   470

            event.Skip()