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 os

    26

import re

    27

from types import TupleType, StringType, UnicodeType

    28

    29

import wx

    30

import wx.grid

    31

import wx.lib.buttons

    32

    33

from plcopen.structures import LOCATIONDATATYPES, TestIdentifier, IEC_KEYWORDS

    34

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    35

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    36

from CustomGrid import CustomGrid

    37

from CustomTable import CustomTable

    38

from LocationCellEditor import LocationCellEditor

    39

from util.BitmapLibrary import GetBitmap

    40

    41

#-------------------------------------------------------------------------------

    42

#                                 Helpers

    43

#-------------------------------------------------------------------------------

    44

    45

def AppendMenu(parent, help, id, kind, text):

    46

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

    47

        parent.Append(help=help, id=id, kind=kind, text=text)

    48

    else:

    49

        parent.Append(helpString=help, id=id, kind=kind, item=text)

    50

    51

[TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, PROJECTTREE, 

    52

 POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    53

] = range(10)

    54

    55

def GetVariableTableColnames(location):

    56

    _ = lambda x : x

    57

    if location:

    58

    	return ["#", _("Name"), _("Class"), _("Type"), _("Location"), _("Initial Value"), _("Option"), _("Documentation")]

    59

    return ["#", _("Name"), _("Class"), _("Type"), _("Initial Value"), _("Option"), _("Documentation")]

    60

    61

def GetOptions(constant=True, retain=True, non_retain=True):

    62

    _ = lambda x : x

    63

    options = [""]

    64

    if constant:

    65

        options.append(_("Constant"))

    66

    if retain:

    67

        options.append(_("Retain"))

    68

    if non_retain:

    69

        options.append(_("Non-Retain"))

    70

    return options

    71

OPTIONS_DICT = dict([(_(option), option) for option in GetOptions()])

    72

    73

def GetFilterChoiceTransfer():

    74

    _ = lambda x : x

    75

    return {_("All"): _("All"), _("Interface"): _("Interface"), 

    76

            _("   Input"): _("Input"), _("   Output"): _("Output"), _("   InOut"): _("InOut"), 

    77

            _("   External"): _("External"), _("Variables"): _("Variables"), _("   Local"): _("Local"),

    78

            _("   Temp"): _("Temp"), _("Global"): _("Global")}#, _("Access") : _("Access")}

    79

VARIABLE_CHOICES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().iterkeys()])

    80

VARIABLE_CLASSES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().itervalues()])

    81

    82

CheckOptionForClass = {"Local": lambda x: x,

    83

                       "Temp": lambda x: "",

    84

                       "Input": lambda x: {"Retain": "Retain", "Non-Retain": "Non-Retain"}.get(x, ""),

    85

                       "InOut": lambda x: "",

    86

                       "Output": lambda x: {"Retain": "Retain", "Non-Retain": "Non-Retain"}.get(x, ""),

    87

                       "Global": lambda x: {"Constant": "Constant", "Retain": "Retain"}.get(x, ""),

    88

                       "External": lambda x: {"Constant": "Constant"}.get(x, "")

    89

                      }

    90

    91

LOCATION_MODEL = re.compile("((?:%[IQM](?:\*|(?:[XBWLD]?[0-9]+(?:\.[0-9]+)*)))?)$")

    92

VARIABLE_NAME_SUFFIX_MODEL = re.compile("([0-9]*)$")

    93

    94

#-------------------------------------------------------------------------------

    95

#                            Variables Panel Table

    96

#-------------------------------------------------------------------------------

    97

    98

class VariableTable(CustomTable):

    99

   100

    """

   101

    A custom wx.grid.Grid Table using user supplied data

   102

    """

   103

    def __init__(self, parent, data, colnames):

   104

        # The base class must be initialized *first*

   105

        CustomTable.__init__(self, parent, data, colnames)

   106

        self.old_value = None

   107

   108

    def GetValue(self, row, col):

   109

        if row < self.GetNumberRows():

   110

            if col == 0:

   111

                return self.data[row]["Number"]

   112

            colname = self.GetColLabelValue(col, False)

   113

            value = self.data[row].get(colname, "")

   114

            if colname == "Type" and isinstance(value, TupleType):

   115

                if value[0] == "array":

   116

                    return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "..".join(x), value[2])), value[1])

   117

            if not isinstance(value, (StringType, UnicodeType)):

   118

                value = str(value)

   119

            if colname in ["Class", "Option"]:

   120

                return _(value)

   121

            return value

   122

   123

    def SetValue(self, row, col, value):

   124

        if col < len(self.colnames):

   125

            colname = self.GetColLabelValue(col, False)

   126

            if colname == "Name":

   127

                self.old_value = self.data[row][colname]

   128

            elif colname == "Class":

   129

                value = VARIABLE_CLASSES_DICT[value]

   130

                self.SetValueByName(row, "Option", CheckOptionForClass[value](self.GetValueByName(row, "Option")))

   131

                if value == "External":

   132

                    self.SetValueByName(row, "Initial Value", "")

   133

            elif colname == "Option":

   134

                value = OPTIONS_DICT[value]

   135

            self.data[row][colname] = value

   136

   137

    def GetOldValue(self):

   138

        return self.old_value

   139

   140

    def _updateColAttrs(self, grid):

   141

        """

   142

        wx.grid.Grid -> update the column attributes to add the

   143

        appropriate renderer given the column name.

   144

   145

        Otherwise default to the default renderer.

   146

        """

   147

        for row in range(self.GetNumberRows()):

   148

            var_class = self.GetValueByName(row, "Class")

   149

            var_type = self.GetValueByName(row, "Type")

   150

            row_highlights = self.Highlights.get(row, {})

   151

            for col in range(self.GetNumberCols()):

   152

                editor = None

   153

                renderer = None

   154

                colname = self.GetColLabelValue(col, False)

   155

                if self.Parent.Debug:

   156

                    grid.SetReadOnly(row, col, True)

   157

                else:

   158

                    if colname == "Option":

   159

                        options = GetOptions(constant = var_class in ["Local", "External", "Global"],

   160

                                             retain = self.Parent.ElementType != "function" and var_class in ["Local", "Input", "Output", "Global"],

   161

                                             non_retain = self.Parent.ElementType != "function" and var_class in ["Local", "Input", "Output"])

   162

                        if len(options) > 1:

   163

                            editor = wx.grid.GridCellChoiceEditor()

   164

                            editor.SetParameters(",".join(map(_, options)))

   165

                        else:

   166

                            grid.SetReadOnly(row, col, True)

   167

                    elif col != 0 and self.GetValueByName(row, "Edit"):

   168

                        grid.SetReadOnly(row, col, False)

   169

                        if colname == "Name":

   170

                            editor = wx.grid.GridCellTextEditor()

   171

                            renderer = wx.grid.GridCellStringRenderer()

   172

                        elif colname == "Initial Value":

   173

                            if var_class not in ["External", "InOut"]:

   174

                                if self.Parent.Controler.IsEnumeratedType(var_type):

   175

                                    editor = wx.grid.GridCellChoiceEditor()

   176

                                    editor.SetParameters(",".join(self.Parent.Controler.GetEnumeratedDataValues(var_type)))

   177

                                else:

   178

                                    editor = wx.grid.GridCellTextEditor()

   179

                                renderer = wx.grid.GridCellStringRenderer()

   180

                            else:

   181

                                grid.SetReadOnly(row, col, True)

   182

                        elif colname == "Location":

   183

                            if var_class in ["Local", "Global"] and self.Parent.Controler.IsLocatableType(var_type):

   184

                                editor = LocationCellEditor(self, self.Parent.Controler)

   185

                                renderer = wx.grid.GridCellStringRenderer()

   186

                            else:

   187

                                grid.SetReadOnly(row, col, True)

   188

                        elif colname == "Class":

   189

                            if len(self.Parent.ClassList) == 1:

   190

                                grid.SetReadOnly(row, col, True)

   191

                            else:

   192

                                editor = wx.grid.GridCellChoiceEditor()

   193

                                excluded = []

   194

                                if self.Parent.IsFunctionBlockType(var_type):

   195

                                    excluded.extend(["Local","Temp"])

   196

                                editor.SetParameters(",".join([_(choice) for choice in self.Parent.ClassList if choice not in excluded]))

   197

                    elif colname != "Documentation":

   198

                        grid.SetReadOnly(row, col, True)

   199

   200

                grid.SetCellEditor(row, col, editor)

   201

                grid.SetCellRenderer(row, col, renderer)

   202

   203

                if colname == "Location" and LOCATION_MODEL.match(self.GetValueByName(row, colname)) is None:

   204

                    highlight_colours = ERROR_HIGHLIGHT

   205

                else:

   206

                    highlight_colours = row_highlights.get(colname.lower(), [(wx.WHITE, wx.BLACK)])[-1]

   207

                grid.SetCellBackgroundColour(row, col, highlight_colours[0])

   208

                grid.SetCellTextColour(row, col, highlight_colours[1])

   209

            self.ResizeRow(grid, row)

   210

   211

#-------------------------------------------------------------------------------

   212

#                         Variable Panel Drop Target

   213

#-------------------------------------------------------------------------------   

   214

   215

class VariableDropTarget(wx.TextDropTarget):

   216

    '''

   217

    This allows dragging a variable location from somewhere to the Location

   218

    column of a variable row.

   219

   220

    The drag source should be a TextDataObject containing a Python tuple like:

   221

        ('%ID0.0.0', 'location', 'REAL')

   222

   223

    c_ext/CFileEditor.py has an example of this (you can drag a C extension

   224

    variable to the Location column of the variable panel).

   225

    '''

   226

    def __init__(self, parent):

   227

        wx.TextDropTarget.__init__(self)

   228

        self.ParentWindow = parent

   229

   230

    def OnDropText(self, x, y, data):

   231

        self.ParentWindow.ParentWindow.Select()

   232

        x, y = self.ParentWindow.VariablesGrid.CalcUnscrolledPosition(x, y)

   233

        col = self.ParentWindow.VariablesGrid.XToCol(x)

   234

        row = self.ParentWindow.VariablesGrid.YToRow(y - self.ParentWindow.VariablesGrid.GetColLabelSize())

   235

        message = None

   236

        element_type = self.ParentWindow.ElementType

   237

        try:

   238

            values = eval(data)    

   239

        except:

   240

            message = _("Invalid value \"%s\" for variable grid element")%data

   241

            values = None

   242

        if not isinstance(values, TupleType):

   243

            message = _("Invalid value \"%s\" for variable grid element")%data

   244

            values = None

   245

        if values is not None:

   246

            if col != wx.NOT_FOUND and row != wx.NOT_FOUND:

   247

                colname = self.ParentWindow.Table.GetColLabelValue(col, False)

   248

                if colname == "Location" and values[1] == "location":

   249

                    if not self.ParentWindow.Table.GetValueByName(row, "Edit"):

   250

                        message = _("Can't give a location to a function block instance")

   251

                    elif self.ParentWindow.Table.GetValueByName(row, "Class") not in ["Local", "Global"]:

   252

                        message = _("Can only give a location to local or global variables")

   253

                    else:

   254

                        location = values[0]

   255

                        variable_type = self.ParentWindow.Table.GetValueByName(row, "Type")

   256

                        base_type = self.ParentWindow.Controler.GetBaseType(variable_type)

   257

   258

                        if values[2] is not None:

   259

                            base_location_type = self.ParentWindow.Controler.GetBaseType(values[2])

   260

                            if values[2] != variable_type and base_type != base_location_type:

   261

                                message = _("Incompatible data types between \"%s\" and \"%s\"")%(values[2], variable_type)

   262

   263

                        if message is None:

   264

                            if not location.startswith("%"):

   265

                                if location[0].isdigit() and base_type != "BOOL":

   266

                                    message = _("Incompatible size of data between \"%s\" and \"BOOL\"")%location

   267

                                elif location[0] not in LOCATIONDATATYPES:

   268

                                    message = _("Unrecognized data size \"%s\"")%location[0]

   269

                                elif base_type not in LOCATIONDATATYPES[location[0]]:

   270

                                    message = _("Incompatible size of data between \"%s\" and \"%s\"")%(location, variable_type)

   271

                                else:

   272

                                    dialog = wx.SingleChoiceDialog(self.ParentWindow.ParentWindow.ParentWindow, 

   273

                                          _("Select a variable class:"), _("Variable class"), 

   274

                                          ["Input", "Output", "Memory"], 

   275

                                          wx.DEFAULT_DIALOG_STYLE|wx.OK|wx.CANCEL)

   276

                                    if dialog.ShowModal() == wx.ID_OK:

   277

                                        selected = dialog.GetSelection()

   278

                                    else:

   279

                                        selected = None

   280

                                    dialog.Destroy()

   281

                                    if selected is None:

   282

                                        return

   283

                                    if selected == 0:

   284

                                        location = "%I" + location

   285

                                    elif selected == 1:

   286

                                        location = "%Q" + location

   287

                                    else:

   288

                                        location = "%M" + location

   289

   290

                            if message is None:

   291

                                self.ParentWindow.Table.SetValue(row, col, location)

   292

                                self.ParentWindow.Table.ResetView(self.ParentWindow.VariablesGrid)

   293

                                self.ParentWindow.SaveValues()

   294

                elif colname == "Initial Value" and values[1] == "Constant":

   295

                    if not self.ParentWindow.Table.GetValueByName(row, "Edit"):

   296

                        message = _("Can't set an initial value to a function block instance")

   297

                    else:

   298

                        self.ParentWindow.Table.SetValue(row, col, values[0])

   299

                        self.ParentWindow.Table.ResetView(self.ParentWindow.VariablesGrid)

   300

                        self.ParentWindow.SaveValues()

   301

            elif (element_type not in ["config", "resource", "function"] and values[1] == "Global" and 

   302

                  self.ParentWindow.Filter in ["All", "Interface", "External"] or

   304

                if values[1] == "location":

   305

                    var_name = values[3]

   306

                else:

   307

                    var_name = values[0]

   308

                tagname = self.ParentWindow.GetTagName()

   312

                    message = _("\"%s\" pou already exists!")%var_name

   316

                    var_infos = self.ParentWindow.DefaultValue.copy()

   317

                    var_infos["Name"] = var_name

   318

                    var_infos["Type"] = values[2]

   319

                    if values[1] == "location":

   350

                        else:

   356

                    else:

   357

                        var_infos["Class"] = "External"

   358

                    var_infos["Number"] = len(self.ParentWindow.Values)

   359

                    self.ParentWindow.Values.append(var_infos)

   360

                    self.ParentWindow.SaveValues()

   361

                    self.ParentWindow.RefreshValues()

   362

   363

        if message is not None:

   364

            wx.CallAfter(self.ShowMessage, message)

   365

   366

    def ShowMessage(self, message):

   367

        message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   368

        message.ShowModal()

   369

        message.Destroy()

   370

   371

#-------------------------------------------------------------------------------

   372

#                               Variable Panel

   373

#-------------------------------------------------------------------------------   

   374

   375

class VariablePanel(wx.Panel):

   376

   377

    def __init__(self, parent, window, controler, element_type, debug=False):

   378

        wx.Panel.__init__(self, parent, style=wx.TAB_TRAVERSAL)

   379

   380

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

   381

        self.MainSizer.AddGrowableCol(0)

   382

        self.MainSizer.AddGrowableRow(1)

   383

   384

        controls_sizer = wx.FlexGridSizer(cols=10, hgap=5, rows=1, vgap=5)

   385

        controls_sizer.AddGrowableCol(5)

   386

        controls_sizer.AddGrowableRow(0)

   387

        self.MainSizer.AddSizer(controls_sizer, border=5, flag=wx.GROW|wx.ALL)

   388

   389

        self.ReturnTypeLabel = wx.StaticText(self, label=_('Return Type:'))

   390

        controls_sizer.AddWindow(self.ReturnTypeLabel, flag=wx.ALIGN_CENTER_VERTICAL)

   391

   392

        self.ReturnType = wx.ComboBox(self,

   393

              size=wx.Size(145, -1), style=wx.CB_READONLY)

   394

        self.Bind(wx.EVT_COMBOBOX, self.OnReturnTypeChanged, self.ReturnType)

   395

        controls_sizer.AddWindow(self.ReturnType)

   396

   397

        self.DescriptionLabel = wx.StaticText(self, label=_('Description:'))

   398

        controls_sizer.AddWindow(self.DescriptionLabel, flag=wx.ALIGN_CENTER_VERTICAL)

   399

   400

        self.Description = wx.TextCtrl(self,

   401

              size=wx.Size(250, -1), style=wx.TE_PROCESS_ENTER)

   402

        self.Bind(wx.EVT_TEXT_ENTER, self.OnDescriptionChanged, self.Description)

   403

        self.Description.Bind(wx.EVT_KILL_FOCUS, self.OnDescriptionChanged)

   404

        controls_sizer.AddWindow(self.Description) 

   405

   406

        class_filter_label = wx.StaticText(self, label=_('Class Filter:'))

   407

        controls_sizer.AddWindow(class_filter_label, flag=wx.ALIGN_CENTER_VERTICAL)

   408

   409

        self.ClassFilter = wx.ComboBox(self, 

   410

              size=wx.Size(145, -1), style=wx.CB_READONLY)

   411

        self.Bind(wx.EVT_COMBOBOX, self.OnClassFilter, self.ClassFilter)

   412

        controls_sizer.AddWindow(self.ClassFilter)

   413

   414

        for name, bitmap, help in [

   415

                ("AddButton", "add_element", _("Add variable")),

   416

                ("DeleteButton", "remove_element", _("Remove variable")),

   417

                ("UpButton", "up", _("Move variable up")),

   418

                ("DownButton", "down", _("Move variable down"))]:

   419

            button = wx.lib.buttons.GenBitmapButton(self, bitmap=GetBitmap(bitmap), 

   420

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

   421

            button.SetToolTipString(help)

   422

            setattr(self, name, button)

   423

            controls_sizer.AddWindow(button)

   424

   425

        self.VariablesGrid = CustomGrid(self, style=wx.VSCROLL)

   426

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   427

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, 

   428

              self.OnVariablesGridCellChange)

   429

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, 

   430

              self.OnVariablesGridCellLeftClick)

   431

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN, 

   432

              self.OnVariablesGridEditorShown)

   433

        self.MainSizer.AddWindow(self.VariablesGrid, flag=wx.GROW)

   434

   435

        self.SetSizer(self.MainSizer)

   436

   437

        self.ParentWindow = window

   438

        self.Controler = controler

   439

        self.ElementType = element_type

   440

        self.Debug = debug

   441

   442

        self.RefreshHighlightsTimer = wx.Timer(self, -1)

   443

        self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, 

   444

              self.RefreshHighlightsTimer)

   445

   446

        self.Filter = "All"

   447

        self.FilterChoices = []

   448

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   449

   450

        self.DefaultValue = {

   451

             "Name" : "", 

   452

             "Class" : "", 

   453

             "Type" : "INT", 

   454

             "Location" : "",

   455

             "Initial Value" : "", 

   456

             "Option" : "",

   457

             "Documentation" : "", 

   458

             "Edit" : True

   459

        }

   460

   461

        if element_type in ["config", "resource"]:

   462

            self.DefaultTypes = {"All" : "Global"}

   463

        else:

   464

            self.DefaultTypes = {"All" : "Local", "Interface" : "Input", "Variables" : "Local"}

   465

   466

        if element_type in ["config", "resource"] \

   467

        or element_type in ["program", "transition", "action"]:

   468

            # this is an element that can have located variables

   469

            self.Table = VariableTable(self, [], GetVariableTableColnames(True))

   470

   471

            if element_type in ["config", "resource"]:

   472

                self.FilterChoices = ["All", "Global"]#,"Access"]

   473

            else:

   474

                self.FilterChoices = ["All",

   475

                                        "Interface", "   Input", "   Output", "   InOut", "   External",

   476

                                        "Variables", "   Local", "   Temp"]#,"Access"]

   477

   478

            # these condense the ColAlignements list

   479

            l = wx.ALIGN_LEFT

   480

            c = wx.ALIGN_CENTER 

   481

   482

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   483

            self.ColSizes       = [40,  80,     70,     80,     80,     80,     100,     80]

   484

            self.ColAlignements = [c,   l,      l,      l,      l,      l,      l,       l]

   485

   486

        else:

   487

            # this is an element that cannot have located variables

   488

            self.Table = VariableTable(self, [], GetVariableTableColnames(False))

   489

   490

            if element_type == "function":

   491

                self.FilterChoices = ["All",

   492

                                        "Interface", "   Input", "   Output", "   InOut",

   493

                                        "Variables", "   Local"]

   494

            else:

   495

                self.FilterChoices = ["All",

   496

                                        "Interface", "   Input", "   Output", "   InOut", "   External",

   497

                                        "Variables", "   Local", "   Temp"]

   498

   499

            # these condense the ColAlignements list

   500

            l = wx.ALIGN_LEFT

   501

            c = wx.ALIGN_CENTER 

   502

   503

            #                      Num  Name    Class   Type    Init    Option   Doc

   504

            self.ColSizes       = [40,  80,     70,     80,     80,     100,     160]

   505

            self.ColAlignements = [c,   l,      l,      l,      l,      l,       l]

   506

   507

        for choice in self.FilterChoices:

   508

            self.ClassFilter.Append(_(choice))

   509

   510

        reverse_transfer = {}

   511

        for filter, choice in self.FilterChoiceTransfer.items():

   512

            reverse_transfer[choice] = filter

   513

        self.ClassFilter.SetStringSelection(_(reverse_transfer[self.Filter]))

   514

        self.RefreshTypeList()

   515

   516

        self.VariablesGrid.SetTable(self.Table)

   517

        self.VariablesGrid.SetButtons({"Add": self.AddButton,

   518

                                       "Delete": self.DeleteButton,

   519

                                       "Up": self.UpButton,

   520

                                       "Down": self.DownButton})

   521

        self.VariablesGrid.SetEditable(not self.Debug)

   522