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

    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

    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

    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

    97

class VariableTable(CustomTable):

    98

    99

    """

   100

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

   101

    """

   102

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

   103

        # The base class must be initialized *first*

   104

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

   105

        self.old_value = None

   106

   107

    def GetValue(self, row, col):

   108

        if row < self.GetNumberRows():

   109

            if col == 0:

   110

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

   111

            colname = self.GetColLabelValue(col, False)

   112

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

   113

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

   114

                if value[0] == "array":

   115

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

   116

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

   117

                value = str(value)

   118

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

   119

                return _(value)

   120

            return value

   121

   122

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

   123

        if col < len(self.colnames):

   124

            colname = self.GetColLabelValue(col, False)

   125

            if colname == "Name":

   126

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

   127

            elif colname == "Class":

   128

                value = VARIABLE_CLASSES_DICT[value]

   129

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

   130

                if value == "External":

   131

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

   132

            elif colname == "Option":

   133

                value = OPTIONS_DICT[value]

   134

            self.data[row][colname] = value

   135

   136

    def GetOldValue(self):

   137

        return self.old_value

   138

   139

    def _updateColAttrs(self, grid):

   140

        """

   141

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

   142

        appropriate renderer given the column name.

   143

   144

        Otherwise default to the default renderer.

   145

        """

   146

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

   147

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

   148

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

   149

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

   150

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

   151

                editor = None

   152

                renderer = None

   153

                colname = self.GetColLabelValue(col, False)

   154

                if self.Parent.Debug:

   155

                    grid.SetReadOnly(row, col, True)

   156

                else:

   157

                    if colname == "Option":

   158

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

   159

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

   160

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

   161

                        if len(options) > 1:

   162

                            editor = wx.grid.GridCellChoiceEditor()

   163

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

   164

                        else:

   165

                            grid.SetReadOnly(row, col, True)

   166

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

   167

                        grid.SetReadOnly(row, col, False)

   168

                        if colname == "Name":

   169

                            if self.Parent.PouIsUsed and var_class in ["Input", "Output", "InOut"]:

   170

                                grid.SetReadOnly(row, col, True)

   171

                            else:

   172

                                editor = wx.grid.GridCellTextEditor()

   173

                                renderer = wx.grid.GridCellStringRenderer()

   174

                        elif colname == "Initial Value":

   175

                            if var_class != "External":

   176

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

   177

                                    editor = wx.grid.GridCellChoiceEditor()

   178

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

   179

                                else:

   180

                                    editor = wx.grid.GridCellTextEditor()

   181

                                renderer = wx.grid.GridCellStringRenderer()

   182

                            else:

   183

                                grid.SetReadOnly(row, col, True)

   184

                        elif colname == "Location":

   185

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

   186

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

   187

                                renderer = wx.grid.GridCellStringRenderer()

   188

                            else:

   189

                                grid.SetReadOnly(row, col, True)

   190

                        elif colname == "Class":

   191

                            if len(self.Parent.ClassList) == 1 or self.Parent.PouIsUsed and var_class in ["Input", "Output", "InOut"]:

   192

                                grid.SetReadOnly(row, col, True)

   193

                            else:

   194

                                editor = wx.grid.GridCellChoiceEditor()

   195

                                excluded = []

   196

                                if self.Parent.PouIsUsed:

   197

                                    excluded.extend(["Input","Output","InOut"])

   198

                                if self.Parent.IsFunctionBlockType(var_type):

   199

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

   200

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

   201

                    elif colname != "Documentation":

   202

                        grid.SetReadOnly(row, col, True)

   203

   204

                grid.SetCellEditor(row, col, editor)

   205

                grid.SetCellRenderer(row, col, renderer)

   206

   207

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

   208

                    highlight_colours = ERROR_HIGHLIGHT

   209

                else:

   210

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

   211

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

   212

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

   213

            self.ResizeRow(grid, row)

   218

   219

class VariableDropTarget(wx.TextDropTarget):

   220

    '''

   221

    This allows dragging a variable location from somewhere to the Location

   222

    column of a variable row.

   223

   224

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

   225

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

   226

   227

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

   228

    variable to the Location column of the variable panel).

   229

    '''

   230

    def __init__(self, parent):

   231

        wx.TextDropTarget.__init__(self)

   232

        self.ParentWindow = parent

   233

   234

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

   235

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

   236

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

   237

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

   238

        message = None

   239

        element_type = self.ParentWindow.ElementType

   240

        try:

   241

            values = eval(data)    

   242

        except:

   243

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

   244

            values = None

   245

        if not isinstance(values, TupleType):

   246

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

   247

            values = None

   248

        if values is not None:

   249

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

   250

                if self.ParentWindow.Table.GetColLabelValue(col, False) != "Location":

   251

                    return

   252

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

   253

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

   254

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

   255

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

   256

                elif values is not None and values[1] == "location":

   257

                    location = values[0]

   258

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

   259

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

   260

                    if location.startswith("%"):

   261

                        if base_type != values[2]:

   262

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

   263

                        else:

   264

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

   265

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

   266

                            self.ParentWindow.SaveValues()

   267

                    else:

   268

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

   269

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

   270

                        elif location[0] not in LOCATIONDATATYPES:

   271

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

   272

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

   273

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

   274

                        else:

   275

                            dialog = wx.SingleChoiceDialog(self.ParentWindow, _("Select a variable class:"), _("Variable class"), ["Input", "Output", "Memory"], wx.OK|wx.CANCEL)

   276

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

   277

                                selected = dialog.GetSelection()

   278

                                if selected == 0:

   279

                                    location = "%I" + location

   280

                                elif selected == 1:

   281

                                    location = "%Q" + location

   282

                                else:

   283

                                    location = "%M" + location

   284

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

   285

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

   286

                                self.ParentWindow.SaveValues()

   287

                            dialog.Destroy()

   288

            elif (element_type not in ["config", "resource"] and values[1] == "Global" and self.ParentWindow.Filter in ["All", "Interface", "External"] or

   289

                  element_type in ["config", "resource"] and values[1] == "location"):

   290

                if values[1] == "location":

   291

                    var_name = values[3]

   292

                else:

   293

                    var_name = values[0]

   294

                tagname = self.ParentWindow.GetTagName()

   295

                if var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   296

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

   297

                elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   298

                    var_infos = self.ParentWindow.DefaultValue.copy()

   299

                    var_infos["Name"] = var_name

   300

                    var_infos["Type"] = values[2]

   301

                    if values[1] == "location":

   302

                        var_infos["Class"] = "Global"

   303

                        var_infos["Location"] = values[0]

   304

                    else:

   305

                        var_infos["Class"] = "External"

   306

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

   307

                    self.ParentWindow.Values.append(var_infos)

   308

                    self.ParentWindow.SaveValues()

   309

                    self.ParentWindow.RefreshValues()

   310

   311

        if message is not None:

   312

            wx.CallAfter(self.ShowMessage, message)

   314

    def ShowMessage(self, message):

   315

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

   316

        message.ShowModal()

   317

        message.Destroy()

   318

   322

   323

class VariablePanel(wx.Panel):

   324

   328

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

   383

        self.SetSizer(self.MainSizer)

   385

        self.ParentWindow = window

   386

        self.Controler = controler

   387

        self.ElementType = element_type

   388

        self.Debug = debug

   389

   390

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

   393

   394

        self.Filter = "All"

   395

        self.FilterChoices = []

   396

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   397

   408

   409

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

   410

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

   411

        else:

   412

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

   413

   414

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

   415

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

   416

            # this is an element that can have located variables

   417

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

   418

   419

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

   420

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

   421

            else:

   422

                self.FilterChoices = ["All",

   423

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

   424

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

   425

   426

            # these condense the ColAlignements list

   427

            l = wx.ALIGN_LEFT

   428

            c = wx.ALIGN_CENTER 

   429

   430

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   431

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

   432

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

   433

   434

        else:

   435

            # this is an element that cannot have located variables

   436

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

   437

   438

            if element_type == "function":

   439

                self.FilterChoices = ["All",

   440

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

   441

                                        "Variables", "   Local"]

   442

            else:

   443

                self.FilterChoices = ["All",

   444

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

   445

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

   446

   447

            # these condense the ColAlignements list

   448

            l = wx.ALIGN_LEFT

   449

            c = wx.ALIGN_CENTER 

   450

   451

            #                      Num  Name    Class   Type    Init    Option   Doc

   452

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

   453

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

   454

   455

        for choice in self.FilterChoices:

   456

            self.ClassFilter.Append(_(choice))

   457

   458

        reverse_transfer = {}

   459

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

   460

            reverse_transfer[choice] = filter

   461

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

   462

        self.RefreshTypeList()

   463

   464

        self.VariablesGrid.SetTable(self.Table)

   465

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

   466

                                       "Delete": self.DeleteButton,

   467

                                       "Up": self.UpButton,

   468

                                       "Down": self.DownButton})

   469

        self.VariablesGrid.SetEditable(not self.Debug)

   470

   471

        def _AddVariable(new_row):

   472

            if not self.PouIsUsed or self.Filter not in ["Interface", "Input", "Output", "InOut"]:

   473

                row_content = self.DefaultValue.copy()

   474

                if self.Filter in self.DefaultTypes:

   475

                    row_content["Class"] = self.DefaultTypes[self.Filter]

   476

                else:

   477

                    row_content["Class"] = self.Filter

   478

                if self.Filter == "All" and len(self.Values) > 0:

   479

                    self.Values.insert(new_row, row_content)

   480

                else:

   481

                    self.Values.append(row_content)

   482

                    new_row = self.Table.GetNumberRows()

   483

                self.SaveValues()

   484

                self.RefreshValues()

   485

                return new_row

   486

            return self.VariablesGrid.GetGridCursorRow()

   487

        setattr(self.VariablesGrid, "_AddRow", _AddVariable)

   488

   489

        def _DeleteVariable(row):

   490

            if (self.Table.GetValueByName(row, "Edit") and 

   491

                (not self.PouIsUsed or self.Table.GetValueByName(row, "Class") not in ["Input", "Output", "InOut"])):

   492

                self.Values.remove(self.Table.GetRow(row))

   493

                self.SaveValues()

   494

                self.RefreshValues()

   495

        setattr(self.VariablesGrid, "_DeleteRow", _DeleteVariable)

   496

   497

        def _MoveVariable(row, move):

   498

            if (self.Filter == "All" and 

   499

                (not self.PouIsUsed or self.Table.GetValueByName(row, "Class") not in ["Input", "Output", "InOut"])):

   500

                new_row = max(0, min(row + move, len(self.Values) - 1))