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

     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

    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

from PLCControler import _VariableInfos

    41

    42

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

    43

#                                 Helpers

    44

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

    45

    46

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

    47

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

    48

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

    49

    else:

    50

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

    51

    53

 POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    54

] = range(10)

    55

    56

def GetVariableTableColnames(location):

    57

    _ = lambda x : x

    58

    if location:

    59

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

    60

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

    61

    62

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

    63

    _ = lambda x : x

    64

    options = [""]

    65

    if constant:

    66

        options.append(_("Constant"))

    67

    if retain:

    68

        options.append(_("Retain"))

    69

    if non_retain:

    70

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

    71

    return options

    72

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

    73

    74

def GetFilterChoiceTransfer():

    75

    _ = lambda x : x

    78

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

    79

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

    80

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

    81

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

    82

    83

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

    84

                       "Temp": lambda x: "",

    85

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

    86

                       "InOut": lambda x: "",

    87

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

    88

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

    89

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

    90

                      }

    91

    92

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

    93

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

    94

    95

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

    96

#                            Variables Panel Table

    97

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

    98

    99

class VariableTable(CustomTable):

   101

    """

   102

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

   103

    """

   104

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

   105

        # The base class must be initialized *first*

   106

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

   107

        self.old_value = None

   109

    def GetValueByName(self, row, colname):

   110

        if row < self.GetNumberRows():

   111

            return getattr(self.data[row], colname)

   112

   113

    def SetValueByName(self, row, colname, value):

   114

        if row < self.GetNumberRows():

   115

            setattr(self.data[row], colname, value)

   117

    def GetValue(self, row, col):

   118

        if row < self.GetNumberRows():

   119

            if col == 0:

   120

                return self.data[row].Number

   121

            colname = self.GetColLabelValue(col, False)

   122

            if colname == "Initial Value":

   123

                colname = "InitialValue"

   124

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

   125

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

   126

                if value[0] == "array":

   127

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

   128

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

   129

                value = str(value)

   130

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

   131

                return _(value)

   132

            return value

   134

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

   135

        if col < len(self.colnames):

   136

            colname = self.GetColLabelValue(col, False)

   137

            if colname == "Name":

   138

                self.old_value = getattr(self.data[row], colname)

   139

            elif colname == "Class":

   140

                value = VARIABLE_CLASSES_DICT[value]

   141

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

   142

                if value == "External":

   143

                    self.SetValueByName(row, "InitialValue", "")

   144

            elif colname == "Option":

   145

                value = OPTIONS_DICT[value]

   146

            elif colname == "Initial Value":

   147

                colname = "InitialValue"

   148

            setattr(self.data[row], colname, value)

   149

   150

    def GetOldValue(self):

   151

        return self.old_value

   152

   153

    def _updateColAttrs(self, grid):

   154

        """

   155

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

   156

        appropriate renderer given the column name.

   157

   158

        Otherwise default to the default renderer.

   159

        """

   160

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

   161

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

   162

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

   163

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

   164

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

   165

                editor = None

   166

                renderer = None

   167

                colname = self.GetColLabelValue(col, False)

   168

                if self.Parent.Debug:

   169

                    grid.SetReadOnly(row, col, True)

   170

                else:

   171

                    if colname == "Option":

   172

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

   173

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

   174

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

   175

                        if len(options) > 1:

   176

                            editor = wx.grid.GridCellChoiceEditor()

   177

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

   178

                        else:

   179

                            grid.SetReadOnly(row, col, True)

   180

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

   181

                        grid.SetReadOnly(row, col, False)

   182

                        if colname == "Name":

   183

                            editor = wx.grid.GridCellTextEditor()

   184

                            renderer = wx.grid.GridCellStringRenderer()

   185

                        elif colname == "Initial Value":

   186

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

   187

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

   188

                                    editor = wx.grid.GridCellChoiceEditor()

   189

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

   190

                                else:

   191

                                    editor = wx.grid.GridCellTextEditor()

   192

                                renderer = wx.grid.GridCellStringRenderer()

   193

                            else:

   194

                                grid.SetReadOnly(row, col, True)

   195

                        elif colname == "Location":

   196

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

   197

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

   198

                                renderer = wx.grid.GridCellStringRenderer()

   199

                            else:

   200

                                grid.SetReadOnly(row, col, True)

   201

                        elif colname == "Class":

   202

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

   203

                                grid.SetReadOnly(row, col, True)

   204

                            else:

   205

                                editor = wx.grid.GridCellChoiceEditor()

   206

                                excluded = []

   207

                                if self.Parent.IsFunctionBlockType(var_type):

   208

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

   209

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

   210

                    elif colname != "Documentation":

   211

                        grid.SetReadOnly(row, col, True)

   213

                grid.SetCellEditor(row, col, editor)

   214

                grid.SetCellRenderer(row, col, renderer)

   216

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

   217

                    highlight_colours = ERROR_HIGHLIGHT

   218

                else:

   219

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

   220

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

   221

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

   222

            self.ResizeRow(grid, row)

   223

   224

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

   225

#                         Variable Panel Drop Target

   227

   228

class VariableDropTarget(wx.TextDropTarget):

   229

    '''

   230

    This allows dragging a variable location from somewhere to the Location

   231

    column of a variable row.

   233

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

   234

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

   236

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

   237

    variable to the Location column of the variable panel).

   238

    '''

   239

    def __init__(self, parent):

   240

        wx.TextDropTarget.__init__(self)

   241

        self.ParentWindow = parent

   243

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

   244

        self.ParentWindow.ParentWindow.Select()

   245

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

   246

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

   247

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

   248

        message = None

   249

        element_type = self.ParentWindow.ElementType

   250

        try:

   252

        except:

   253

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

   254

            values = None

   255

        if not isinstance(values, TupleType):

   256

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

   257

            values = None

   258

        if values is not None:

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

                    else:

   267

                        location = values[0]

   268

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

   269

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

   271

                        if values[2] is not None:

   272

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

   273

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

   274

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

   276

                        if message is None:

   277

                            if not location.startswith("%"):

   278

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

   279

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

   280

                                elif location[0] not in LOCATIONDATATYPES:

   281

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

   282

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

   283

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

   284

                                else:

   288

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

   289

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

   290

                                        selected = dialog.GetSelection()

   291

                                    else:

   292

                                        selected = None

   293

                                    dialog.Destroy()

   294

                                    if selected is None:

   295

                                        return

   296

                                    if selected == 0:

   297

                                        location = "%I" + location

   298

                                    elif selected == 1:

   299

                                        location = "%Q" + location

   300

                                    else:

   301

                                        location = "%M" + location

   303

                            if message is None:

   304

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

   305

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

   306

                                self.ParentWindow.SaveValues()

   307

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

   308

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

   309

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

   310

                    else:

   311

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

   312

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

   313

                        self.ParentWindow.SaveValues()

   315

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

   316

                  element_type != "function" and values[1] == "location"):

   317

                if values[1] == "location":

   318

                    var_name = values[3]

   319

                else:

   320

                    var_name = values[0]

   321

                tagname = self.ParentWindow.GetTagName()

   323

                        for name in self.ParentWindow.Controler.\

   324

                            GetProjectPouNames(self.ParentWindow.Debug)]:

   325

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

   327

                        for name in self.ParentWindow.Controler.\

   328

                            GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   329

                    var_infos = self.ParentWindow.DefaultValue.copy()

   330

                    var_infos.Name = var_name

   331

                    var_infos.Type = values[2]

   332

                    if values[1] == "location":

   333

                        location = values[0]

   334

                        if not location.startswith("%"):

   338

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

   339

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

   340

                                selected = dialog.GetSelection()

   341

                            else:

   342

                                selected = None

   343

                            dialog.Destroy()

   344

                            if selected is None:

   345

                                return

   346

                            if selected == 0:

   347

                                location = "%I" + location

   348

                            elif selected == 1:

   349

                                location = "%Q" + location

   350

                            else:

   351

                                location = "%M" + location

   352

                        if element_type == "functionBlock":

   353

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   354

                                                                self.ParentWindow.Debug)

   355

                            if len(configs) == 0:

   356

                                return

   358

                                for name in self.ParentWindow.Controler.\

   359

                                    GetConfigurationVariableNames(configs[0])]:

   360

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   361

                                    configs[0], values[2], var_name, location, "")

   362

                            var_infos.Class = "External"

   363

                        else:

   364

                            if element_type == "program":

   365

                                var_infos.Class = "Local"

   366

                            else:

   367

                                var_infos.Class = "Global"

   368

                            var_infos.Location = location

   369

                    else:

   370

                        var_infos.Class = "External"

   371

                    var_infos.Number = len(self.ParentWindow.Values)

   372

                    self.ParentWindow.Values.append(var_infos)

   373

                    self.ParentWindow.SaveValues()

   374

                    self.ParentWindow.RefreshValues()

   376

        if message is not None:

   377

            wx.CallAfter(self.ShowMessage, message)

   379

    def ShowMessage(self, message):

   380

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

   381

        message.ShowModal()

   382

        message.Destroy()

   383

   384

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

   385

#                               Variable Panel

   387

   388

class VariablePanel(wx.Panel):

   390

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

   391

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

   393

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

   394

        self.MainSizer.AddGrowableCol(0)

   395

        self.MainSizer.AddGrowableRow(1)

   397

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

   398

        controls_sizer.AddGrowableCol(5)

   399

        controls_sizer.AddGrowableRow(0)

   400

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

   402

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

   403

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

   405

        self.ReturnType = wx.ComboBox(self,

   406

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

   407

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

   408

        controls_sizer.AddWindow(self.ReturnType)

   410

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

   411

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

   413

        self.Description = wx.TextCtrl(self,

   414

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

   415

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

   416

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

   419

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

   420

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

   423

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

   424

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

   425

        controls_sizer.AddWindow(self.ClassFilter)

   427

        for name, bitmap, help in [

   428

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

   429

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

   430

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

   431

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

   433

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

   434

            button.SetToolTipString(help)

   435

            setattr(self, name, button)

   436

            controls_sizer.AddWindow(button)

   438

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

   439

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   441

              self.OnVariablesGridCellChange)

   443

              self.OnVariablesGridCellLeftClick)

   445

              self.OnVariablesGridEditorShown)

   446

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

   448

        self.SetSizer(self.MainSizer)

   450

        self.ParentWindow = window

   451

        self.Controler = controler

   452

        self.ElementType = element_type

   453

        self.Debug = debug

   455

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

   457

              self.RefreshHighlightsTimer)

   459

        self.Filter = "All"

   460

        self.FilterChoices = []

   461

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   465

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

   466

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

   467

        else:

   468

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

   469

   470

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

   471

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

   472

            # this is an element that can have located variables

   473

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

   474

   475

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

   476

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

   477

            else:

   478

                self.FilterChoices = ["All",

   479

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

   480

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

   481

   482

            # these condense the ColAlignements list

   483

            l = wx.ALIGN_LEFT

   485

   486

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   487

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

   488

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

   489

   490

        else:

   491

            # this is an element that cannot have located variables

   492

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

   493

   494

            if element_type == "function":

   495

                self.FilterChoices = ["All",

   496

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

   497

                                        "Variables", "   Local"]

   498

            else:

   499

                self.FilterChoices = ["All",

   500

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

   501

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

   502

   503

            # these condense the ColAlignements list

   504

            l = wx.ALIGN_LEFT

   506

   507

            #                      Num  Name    Class   Type    Init    Option   Doc

   508

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

   509

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