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 PLCControler import \

    34

    ITEMS_VARIABLE, \

    35

    ITEM_CONFIGURATION, \

    36

    ITEM_RESOURCE, \

    37

    ITEM_POU, \

    38

    ITEM_TRANSITION, \

    39

    ITEM_ACTION

    40

    41

from util.BitmapLibrary import GetBitmap

    42

    43

    44

# Customize CustomTreeItem for adding icon on item right

    45

CT.GenericTreeItem._rightimages = []

    46

    47

    48

def SetRightImages(self, images):

    49

    self._rightimages = images

    50

    51

    52

CT.GenericTreeItem.SetRightImages = SetRightImages

    53

    54

    55

def GetRightImages(self):

    56

    return self._rightimages

    57

    58

    59

CT.GenericTreeItem.GetRightImages = GetRightImages

    60

    61

    62

class CustomTreeCtrlWithRightImage(CT.CustomTreeCtrl):

    63

    64

    def SetRightImageList(self, imageList):

    65

        self._imageListRight = imageList

    66

    67

    def GetLineHeight(self, item):

    68

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

    69

        rightimages = item.GetRightImages()

    70

        if len(rightimages) > 0:

    71

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

    72

            return max(height, r_image_h + 8)

    73

        return height

    74

    75

    def GetItemRightImagesBBox(self, item):

    76

        rightimages = item.GetRightImages()

    77

        if len(rightimages) > 0:

    78

            w, _h = self.GetClientSize()

    79

            total_h = self.GetLineHeight(item)

    80

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

    81

    82

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

    83

            bbox_height = r_image_h + 8

    84

            bbox_x = w - bbox_width

    85

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

    86

    87

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

    88

    89

        return None

    90

    91

    def IsOverItemRightImage(self, item, point):

    92

        rightimages = item.GetRightImages()

    93

        if len(rightimages) > 0:

    94

            point = self.CalcUnscrolledPosition(point)

    95

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

    96

            images_bbx = self.GetItemRightImagesBBox(item)

    97

    98

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

    99

                           r_image_w, r_image_h)

   100

            for r_image in rightimages:

   101

                if rect.Inside(point):

   102

                    return r_image

   103

                rect.x += r_image_w + 4

   104

   105

            return None

   106

   107

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

   108

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

   109

   110

        rightimages = item.GetRightImages()

   111

        if len(rightimages) > 0:

   112

            images_bbx = self.GetItemRightImagesBBox(item)

   113

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

   114

   115

            dc.SetBrush(wx.TRANSPARENT_BRUSH)

   116

            dc.SetPen(wx.TRANSPARENT_PEN)

   117

   118

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

   119

                             images_bbx.width, images_bbx.height)

   120

            x_pos = images_bbx.x + 4

   121

            for r_image in rightimages:

   122

                self._imageListRight.Draw(

   123

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

   124

                    wx.IMAGELIST_DRAW_TRANSPARENT)

   125

                x_pos += r_image_w + 4

   126

   127

   128

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

   129

   130

   131

class PouInstanceVariablesPanel(wx.Panel):

   132

   133

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

   134

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

   135

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

   136

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

   137

   138

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

   139

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

   140

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

   141

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

   142

                  self.ParentButton)

   143

   144

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

   145

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

   146

                  self.InstanceChoice)

   147

   148

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

   149

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

   150

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

   151

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

   152

                  self.DebugButton)

   153

   154

        self.VariablesList = CustomTreeCtrlWithRightImage(

   155

            self,

   156

            style=wx.SUNKEN_BORDER,

   157

            agwStyle=(CT.TR_NO_BUTTONS |

   158

                      CT.TR_SINGLE |

   159

                      CT.TR_HAS_VARIABLE_ROW_HEIGHT |

   160

                      CT.TR_HIDE_ROOT |

   161

                      CT.TR_NO_LINES |

   162

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

   163

        self.VariablesList.SetIndent(0)

   164

        self.VariablesList.SetSpacing(5)

   165

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

   166

        self.VariablesList.Bind(CT.EVT_TREE_ITEM_ACTIVATED,

   167

                                self.OnVariablesListItemActivated)

   168

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

   169

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

   170

   171

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

   172

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

   173

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

   174

        self.VariablesList.SetRightImageList(self.TreeRightImageList)

   175

   176

        self.ButtonCallBacks = {

   177

            self.EditImage: _ButtonCallbacks(

   178

                self.EditButtonCallback, None),

   179

            self.DebugInstanceImage: _ButtonCallbacks(

   180

                self.DebugButtonCallback, self.DebugButtonDClickCallback)}

   181

   182

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

   183

        buttons_sizer.AddWindow(self.ParentButton)

   184

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

   185

        buttons_sizer.AddWindow(self.DebugButton)

   186

        buttons_sizer.AddGrowableCol(1)

   187

        buttons_sizer.AddGrowableRow(0)

   188

   189

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

   190

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

   191

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

   192

        main_sizer.AddGrowableCol(0)

   193

        main_sizer.AddGrowableRow(1)

   194

   195

        self.SetSizer(main_sizer)

   196

   197

        self.ParentWindow = window

   198

        self.Controller = controller

   199

        self.Debug = debug

   200

        if not self.Debug:

   201

            self.DebugButton.Hide()

   202

   203

        self.PouTagName = None

   204

        self.PouInfos = None

   205

        self.PouInstance = None

   206

   207

    def __del__(self):

   208

        self.Controller = None

   209

   210

    def SetTreeImageList(self, tree_image_list):

   211

        self.VariablesList.SetImageList(tree_image_list)

   212

   213

    def SetController(self, controller):

   214

        self.Controller = controller

   215

   216

        self.RefreshView()

   217

   218

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

   219

        if self.Controller is not None:

   220

            if tagname == "Project":

   221

                config_name = self.Controller.GetProjectMainConfigurationName()

   222

                if config_name is not None:

   223

                    tagname = self.Controller.ComputeConfigurationName(config_name)

   224

            if pou_instance is not None:

   225

                self.PouInstance = pou_instance

   226

   227

            if self.PouTagName != tagname:

   228

                self.PouTagName = tagname

   229

                self.RefreshView()

   230

            else:

   231

                self.RefreshInstanceChoice()

   232

        else:

   233

            self.RefreshView()

   234

   235

    def ResetView(self):

   236

        self.Controller = None

   237

   238

        self.PouTagName = None

   239

        self.PouInfos = None

   240

        self.PouInstance = None

   241

   242

        self.RefreshView()

   243

   244

    def RefreshView(self):

   245

        self.Freeze()

   246

        self.VariablesList.DeleteAllItems()

   247

   248

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

   249

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

   250

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

   251

            else:

   252

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

   253

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

   254

                self.PouInfos.debug = False

   255

        else:

   256

            self.PouInfos = None

   257

        if self.PouInfos is not None:

   258

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

   259

            for var_infos in self.PouInfos.variables:

   260

                if var_infos.type is not None:

   261

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

   262

                else:

   263

                    text = var_infos.name

   264

   265

                right_images = []

   266

                if var_infos.edit:

   267

                    right_images.append(self.EditImage)

   268

   269

                if var_infos.debug and self.Debug:

   270

                    right_images.append(self.DebugInstanceImage)

   271

   272

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

   273

                item.SetRightImages(right_images)

   274

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

   275

                self.VariablesList.SetPyData(item, var_infos)

   276

   277

        self.RefreshInstanceChoice()

   278

        self.RefreshButtons()

   279

   280

        self.Thaw()

   281

   282

    def RefreshInstanceChoice(self):

   283

        self.InstanceChoice.Clear()

   284

        self.InstanceChoice.SetValue("")

   285

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

   286

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

   287

            for instance in instances:

   288

                self.InstanceChoice.Append(instance)

   289

            if len(instances) == 1:

   290

                self.PouInstance = instances[0]

   291

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

   292

                self.PouInstance = None

   293

                self.InstanceChoice.SetSelection(0)

   294

            elif self.PouInstance in instances:

   295

                self.InstanceChoice.SetStringSelection(self.PouInstance)

   296

            else:

   297

                self.PouInstance = None

   298

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

   299

   300

    def RefreshButtons(self):

   301

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

   302

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

   303

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

   304

   305

        root = self.VariablesList.GetRootItem()

   306

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

   307

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

   308

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

   309

                panel = self.VariablesList.GetItemWindow(item)

   310

                if panel is not None:

   311

                    for child in panel.GetChildren():

   312

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

   313

                            child.Enable(enabled)

   314

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

   315

   316

    def EditButtonCallback(self, infos):

   317

        var_class = infos.var_class

   318

        if var_class == ITEM_RESOURCE:

   319

            tagname = self.Controller.ComputeConfigurationResourceName(

   320

                self.InstanceChoice.GetStringSelection(),

   321

                infos.name)

   322

        elif var_class == ITEM_TRANSITION:

   323

            tagname = self.Controller.ComputePouTransitionName(

   324

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

   325

                infos.name)

   326

        elif var_class == ITEM_ACTION:

   327

            tagname = self.Controller.ComputePouActionName(

   328

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

   329

                infos.name)

   330

        else:

   331

            var_class = ITEM_POU

   332

            tagname = self.Controller.ComputePouName(infos.type)

   333

        self.ParentWindow.EditProjectElement(var_class, tagname)

   334

   335

    def DebugButtonCallback(self, infos):

   336

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

   337

            var_class = infos.var_class

   338

            instance_path = self.InstanceChoice.GetStringSelection()

   339

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

   340

                pos = instance_path.rfind('.')

   341

                instance_path = instance_path[0:pos]

   342

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

   343

            if var_class in ITEMS_VARIABLE:

   344

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

   345

            elif var_class == ITEM_TRANSITION:

   346

                self.ParentWindow.OpenDebugViewer(

   347

                    var_class,

   348

                    var_path,

   349

                    self.Controller.ComputePouTransitionName(

   350

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

   351

                        infos.name))

   352

            elif var_class == ITEM_ACTION:

   353

                self.ParentWindow.OpenDebugViewer(

   354

                    var_class,

   355

                    var_path,

   356

                    self.Controller.ComputePouActionName(

   357

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

   358

                        infos.name))

   359

            else:

   360

                self.ParentWindow.OpenDebugViewer(

   361

                    var_class,

   362

                    var_path,

   363

                    self.Controller.ComputePouName(infos.type))

   364

   365

    def DebugButtonDClickCallback(self, infos):

   366

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

   367

            if infos.var_class in ITEMS_VARIABLE:

   368

                self.ParentWindow.AddDebugVariable(

   369

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

   370

                               infos.name),

   371

                    force=True,

   372

                    graph=True)

   373

   374

    def ShowInstanceChoicePopup(self):

   375

        self.InstanceChoice.SetFocusFromKbd()

   376

        size = self.InstanceChoice.GetSize()

   377

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

   378

        event.x = size.width / 2

   379

        event.y = size.height / 2

   380

        event.SetEventObject(self.InstanceChoice)

   381

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

   382

        # event.m_keyCode = wx.WXK_SPACE

   383

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

   384

   385

    def OnParentButtonClick(self, event):

   386

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

   387

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

   388

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

   389

            if tagname is not None:

   390

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

   391

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

   392

        event.Skip()

   393

   394

    def OnInstanceChoiceChanged(self, event):

   395

        self.RefreshButtons()

   396

        event.Skip()

   397

   398

    def OnDebugButtonClick(self, event):

   399

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

   400

            self.ParentWindow.OpenDebugViewer(

   401

                self.PouInfos.var_class,

   402

                self.InstanceChoice.GetStringSelection(),

   403

                self.PouTagName)

   404

        event.Skip()

   405

   406

    def OnVariablesListItemActivated(self, event):

   407

        selected_item = event.GetItem()

   408

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

   409

            item_infos = self.VariablesList.GetPyData(selected_item)

   410

            if item_infos is not None:

   411

   412

                item_button = self.VariablesList.IsOverItemRightImage(

   413

                    selected_item, event.GetPoint())

   414

                if item_button is not None:

   415

                    callback = self.ButtonCallBacks[item_button].dclick

   416

                    if callback is not None:

   417

                        callback(item_infos)

   418

   419

                elif item_infos.var_class not in ITEMS_VARIABLE:

   420

                    instance_path = self.InstanceChoice.GetStringSelection()

   421

                    if item_infos.var_class == ITEM_RESOURCE:

   422

                        if instance_path != "":

   423

                            tagname = self.Controller.ComputeConfigurationResourceName(

   424

                                instance_path,

   425

                                item_infos.name)

   426

                        else:

   427

                            tagname = None

   428

                    else:

   429

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

   430

                        if item_infos.var_class == ITEM_ACTION:

   431

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

   432

                        elif item_infos.var_class == ITEM_TRANSITION:

   433

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

   434

                        else:

   435

                            tagname = self.Controller.ComputePouName(item_infos.type)

   436

                    if tagname is not None:

   437

                        if instance_path != "":

   438

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

   439

                        else:

   440

                            item_path = None

   441

                        self.SetPouType(tagname, item_path)

   442

                        self.ParentWindow.SelectProjectTreeItem(tagname)

   443

        event.Skip()

   444

   445

    def OnVariablesListLeftDown(self, event):

   446

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

   447

            wx.CallAfter(self.ShowInstanceChoicePopup)

   448

        else:

   449

            instance_path = self.InstanceChoice.GetStringSelection()

   450

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

   451

            if item is not None:

   452

                item_infos = self.VariablesList.GetPyData(item)

   453

                if item_infos is not None:

   454

   455

                    item_button = self.VariablesList.IsOverItemRightImage(

   456

                        item, event.GetPosition())

   457

                    if item_button is not None:

   458

                        callback = self.ButtonCallBacks[item_button].leftdown

   459

                        if callback is not None:

   460

                            callback(item_infos)

   461

   462

                    elif (flags & CT.TREE_HITTEST_ONITEMLABEL and

   463

                          item_infos.var_class in ITEMS_VARIABLE):

   464

                        self.ParentWindow.EnsureTabVisible(

   465

                            self.ParentWindow.DebugVariablePanel)

   466

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

   467

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

   468

                        dragSource = wx.DropSource(self.VariablesList)

   469

                        dragSource.SetData(data)

   470

                        dragSource.DoDragDrop()

   471

        event.Skip()

   472

   473

    def OnVariablesListKeyDown(self, event):

   474

        keycode = event.GetKeyCode()

   475

        if keycode != wx.WXK_LEFT:

   476

            event.Skip()