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) 2007: 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

import re

    28

from types import TupleType, StringType, UnicodeType

    29

    30

import wx

    31

import wx.grid

    32

import wx.lib.buttons

    33

    34

from plcopen.structures import LOCATIONDATATYPES, TestIdentifier, IEC_KEYWORDS, DefaultType

    35

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    36

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    37

from controls.CustomGrid import CustomGrid

    38

from controls.CustomTable import CustomTable

    39

from controls.LocationCellEditor import LocationCellEditor

    40

from util.BitmapLibrary import GetBitmap

    41

from util.TranslationCatalogs import NoTranslate

    42

from PLCControler import _VariableInfos

    43

    44

    45

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

    46

#                                 Helpers

    47

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

    48

    49

    50

[

    51

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

    52

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    53

] = range(10)

    54

    55

    56

def GetVariableTableColnames(location):

    57

    _ = NoTranslate

    58

    cols = ["#",

    59

            _("Name"),

    60

            _("Class"),

    61

            _("Type"),

    62

            _("Location"),

    63

            _("Initial Value"),

    64

            _("Option"),

    65

            _("Documentation")]

    66

    if not location:

    67

        del cols[4]  # remove 'Location' column

    68

    return cols

    69

    70

    71

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

    72

    _ = NoTranslate

    73

    options = [""]

    74

    if constant:

    75

        options.append(_("Constant"))

    76

    if retain:

    77

        options.append(_("Retain"))

    78

    if non_retain:

    79

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

    80

    return options

    81

    82

    83

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

    84

    85

    86

def GetFilterChoiceTransfer():

    87

    _ = NoTranslate

    88

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

    89

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

    90

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

    91

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

    92

    93

    94

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

    95

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

    96

    97

CheckOptionForClass = {

    98

    "Local": lambda x: x,

    99

    "Temp": lambda x: "",

   100

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

   101

    "InOut": lambda x: "",

   102

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

   103

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

   104

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

   105

}

   106

   107

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

   108

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

   109

   110

   111

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

   112

#                            Variables Panel Table

   113

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

   114

   115

   116

class VariableTable(CustomTable):

   117

   118

    """

   119

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

   120

    """

   121

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

   122

        # The base class must be initialized *first*

   123

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

   124

        self.old_value = None

   125

   126

    def GetValueByName(self, row, colname):

   127

        if row < self.GetNumberRows():

   128

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

   129

   130

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

   131

        if row < self.GetNumberRows():

   132

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

   133

   134

    def GetValue(self, row, col):

   135

        if row < self.GetNumberRows():

   136

            if col == 0:

   137

                return self.data[row].Number

   138

            colname = self.GetColLabelValue(col, False)

   139

            if colname == "Initial Value":

   140

                colname = "InitialValue"

   141

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

   142

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

   143

                if value[0] == "array":

   144

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

   145

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

   146

                value = str(value)

   147

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

   148

                return _(value)

   149

            return value

   150

   151

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

   152

        if col < len(self.colnames):

   153

            colname = self.GetColLabelValue(col, False)

   154

            if colname == "Name":

   155

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

   156

            elif colname == "Class":

   157

                value = VARIABLE_CLASSES_DICT[value]

   158

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

   159

                if value == "External":

   160

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

   161

            elif colname == "Option":

   162

                value = OPTIONS_DICT[value]

   163

            elif colname == "Initial Value":

   164

                colname = "InitialValue"

   165

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

   166

   167

    def GetOldValue(self):

   168

        return self.old_value

   169

   170

    def _GetRowEdit(self, row):

   171

        row_edit = self.GetValueByName(row, "Edit")

   172

        var_type = self.Parent.GetTagName()

   173

        bodytype = self.Parent.Controler.GetEditedElementBodyType(var_type)

   174

        if bodytype in ["ST", "IL"]:

   175

            row_edit = True

   176

        return row_edit

   177

   178

    def _updateColAttrs(self, grid):

   179

        """

   180

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

   181

        appropriate renderer given the column name.

   182

   183

        Otherwise default to the default renderer.

   184

        """

   185

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

   186

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

   187

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

   188

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

   189

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

   190

                editor = None

   191

                renderer = None

   192

                colname = self.GetColLabelValue(col, False)

   193

                if self.Parent.Debug:

   194

                    grid.SetReadOnly(row, col, True)

   195

                else:

   196

                    if colname == "Option":

   197

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

   198

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

   199

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

   200

                        if len(options) > 1:

   201

                            editor = wx.grid.GridCellChoiceEditor()

   202

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

   203

                        else:

   204

                            grid.SetReadOnly(row, col, True)

   205

                    elif col != 0 and self._GetRowEdit(row):

   206

                        grid.SetReadOnly(row, col, False)

   207

                        if colname == "Name":

   208

                            editor = wx.grid.GridCellTextEditor()

   209

                            renderer = wx.grid.GridCellStringRenderer()

   210

                        elif colname == "Initial Value":

   211

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

   212

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

   213

                                    editor = wx.grid.GridCellChoiceEditor()

   214

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

   215

                                else:

   216

                                    editor = wx.grid.GridCellTextEditor()

   217

                                renderer = wx.grid.GridCellStringRenderer()

   218

                            else:

   219

                                grid.SetReadOnly(row, col, True)

   220

                        elif colname == "Location":

   221

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

   222

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

   223

                                renderer = wx.grid.GridCellStringRenderer()

   224

                            else:

   225

                                grid.SetReadOnly(row, col, True)

   226

                        elif colname == "Class":

   227

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

   228

                                grid.SetReadOnly(row, col, True)

   229

                            else:

   230

                                editor = wx.grid.GridCellChoiceEditor()

   231

                                excluded = []

   232

                                if self.Parent.IsFunctionBlockType(var_type):

   233

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

   234

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

   235

                    elif colname != "Documentation":

   236

                        grid.SetReadOnly(row, col, True)

   237

   238

                grid.SetCellEditor(row, col, editor)

   239

                grid.SetCellRenderer(row, col, renderer)

   240

   241

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

   242

                    highlight_colours = ERROR_HIGHLIGHT

   243

                else:

   244

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

   245

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

   246

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

   247

            self.ResizeRow(grid, row)

   248

   249

   250

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

   251

#                         Variable Panel Drop Target

   252

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

   253

   254

   255

class VariableDropTarget(wx.TextDropTarget):

   256

    '''

   257

    This allows dragging a variable location from somewhere to the Location

   258

    column of a variable row.

   259

   260

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

   261

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

   262

   263

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

   264

    variable to the Location column of the variable panel).

   265

    '''

   266

    def __init__(self, parent):

   267

        wx.TextDropTarget.__init__(self)

   268

        self.ParentWindow = parent

   269

   270

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

   271

        self.ParentWindow.ParentWindow.Select()

   272

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

   273

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

   274

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

   275

        message = None

   276

        element_type = self.ParentWindow.ElementType

   277

        try:

   278

            values = eval(data)

   279

        except Exception:

   280

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

   281

            values = None

   282

        if not isinstance(values, TupleType):

   283

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

   284

            values = None

   285

        if values is not None:

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

                    else:

   294

                        location = values[0]

   295

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

   296

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

   297

   298

                        if values[2] is not None:

   299

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

   300

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

   301

                                message = _("Incompatible data types between \"{a1}\" and \"{a2}\"").\

   302

                                          format(a1=values[2], a2=variable_type)

   303

   304

                        if message is None:

   305

                            if not location.startswith("%"):

   306

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

   307

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

   308

                                elif location[0] not in LOCATIONDATATYPES:

   309

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

   310

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

   311

                                    message = _("Incompatible size of data between \"{a1}\" and \"{a2}\"").\

   312

                                              format(a1=location, a2=variable_type)

   313

                                else:

   314

                                    dialog = wx.SingleChoiceDialog(

   315

                                        self.ParentWindow.ParentWindow.ParentWindow,

   316

                                        _("Select a variable class:"),

   317

                                        _("Variable class"),

   318

                                        [_("Input"), _("Output"), _("Memory")],

   319

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

   320

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

   321

                                        selected = dialog.GetSelection()

   322

                                    else:

   323

                                        selected = None

   324

                                    dialog.Destroy()

   325

                                    if selected is None:

   326

                                        return

   327

                                    if selected == 0:

   328

                                        location = "%I" + location

   329

                                    elif selected == 1:

   330

                                        location = "%Q" + location

   331

                                    else:

   332

                                        location = "%M" + location

   333

   334

                            if message is None:

   335

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

   336

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

   337

                                self.ParentWindow.SaveValues()

   338

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

   339

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

   340

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

   341

                    else:

   342

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

   343

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

   344

                        self.ParentWindow.SaveValues()

   345

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

   346

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

   347

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

   348

                if values[1] in ["location", "NamedConstant"]:

   349

                    var_name = values[3]

   350

                else:

   351

                    var_name = values[0]

   352

                tagname = self.ParentWindow.GetTagName()

   353

                dlg = wx.TextEntryDialog(

   354

                    self.ParentWindow.ParentWindow.ParentWindow,

   355

                    _("Confirm or change variable name"),

   356

                    _('Variable Drop'), var_name)

   357

                dlg.SetValue(var_name)

   358

                var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   359

                dlg.Destroy()

   360

                if var_name is None:

   361

                    return

   362

                elif var_name.upper() in [

   363

                        name.upper() for name in

   364

                        self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   365

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

   366

                elif not var_name.upper() in [

   367

                        name.upper()

   368

                        for name in self.ParentWindow.Controler.

   369

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

   370

                    var_infos = self.ParentWindow.DefaultValue.copy()

   371

                    var_infos.Name = var_name

   372

                    var_infos.Type = values[2]

   373

                    var_infos.Documentation = values[4]

   374

                    if values[1] == "location":

   375

                        location = values[0]

   376

                        if not location.startswith("%"):

   377

                            dialog = wx.SingleChoiceDialog(

   378

                                self.ParentWindow.ParentWindow.ParentWindow,

   379

                                _("Select a variable class:"),

   380

                                _("Variable class"),

   381

                                [_("Input"), _("Output"), _("Memory")],

   382

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

   383

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

   384

                                selected = dialog.GetSelection()

   385

                            else:

   386

                                selected = None

   387

                            dialog.Destroy()

   388

                            if selected is None:

   389

                                return

   390

                            if selected == 0:

   391

                                location = "%I" + location

   392

                            elif selected == 1:

   393

                                location = "%Q" + location

   394

                            else:

   395

                                location = "%M" + location

   396

                        if element_type == "functionBlock":

   397

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   398

                                                                self.ParentWindow.Debug)

   399

                            if len(configs) == 0:

   400

                                return

   401

                            if not var_name.upper() in [

   402

                                    name.upper() for name in

   403

                                    self.ParentWindow.Controler.GetConfigurationVariableNames(configs[0])]:

   404

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   405

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

   406

                            var_infos.Class = "External"

   407

                        else:

   408

                            if element_type == "program":

   409

                                var_infos.Class = "Local"

   410

                            else:

   411

                                var_infos.Class = "Global"

   412

                            var_infos.Location = location

   413

                    elif values[1] == "NamedConstant":

   414

                        if element_type in ["functionBlock", "program"]:

   415

                            var_infos.Class = "Local"

   416

                            var_infos.InitialValue = values[0]

   417

                        else:

   418

                            return

   419

                    else:

   420

                        var_infos.Class = "External"

   421

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

   422

                    self.ParentWindow.Values.append(var_infos)

   423

                    self.ParentWindow.SaveValues()

   424

                    self.ParentWindow.RefreshValues()

   425

                else:

   426

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

   427

   428

        if message is not None:

   429

            wx.CallAfter(self.ShowMessage, message)

   430

   431

    def ShowMessage(self, message):

   432

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

   433

        message.ShowModal()

   434

        message.Destroy()

   435

   436

   437

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

   438

#                               Variable Panel

   439

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

   440

   441

   442

class VariablePanel(wx.Panel):

   443

   444

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

   445

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

   446

   447

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

   448

        self.MainSizer.AddGrowableCol(0)

   449

        self.MainSizer.AddGrowableRow(1)

   450

   451

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

   452

        controls_sizer.AddGrowableCol(5)

   453

        controls_sizer.AddGrowableRow(0)

   454

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

   455

   456

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

   457

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

   458

   459

        self.ReturnType = wx.ComboBox(self,

   460

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

   461

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

   462

        controls_sizer.AddWindow(self.ReturnType)

   463

   464

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

   465

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

   466

   467

        self.Description = wx.TextCtrl(self,

   468

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

   469

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

   470

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

   471

        controls_sizer.AddWindow(self.Description)

   472

   473

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

   474

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

   475

   476

        self.ClassFilter = wx.ComboBox(self,

   477

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

   478

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

   479

        controls_sizer.AddWindow(self.ClassFilter)

   480

   481

        for name, bitmap, help in [

   482

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

   483

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

   484

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

   485

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

   486

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

   487

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

   488

            button.SetToolTipString(help)

   489

            setattr(self, name, button)

   490

            controls_sizer.AddWindow(button)