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

import re

    27

    28

import wx

    29

import wx.grid

    30

import wx.lib.buttons

    31

    32

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

    33

from plcopen.VariableInfoCollector import _VariableInfos

    34

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    35

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    36

from controls.CustomGrid import CustomGrid

    37

from controls.CustomTable import CustomTable

    38

from controls.LocationCellEditor import LocationCellEditor

    39

from util.BitmapLibrary import GetBitmap

    40

from util.TranslationCatalogs import NoTranslate

    41

    42

    43

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

    44

#                                 Helpers

    45

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

    46

    47

    48

[

    49

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

    50

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    51

] = list(range(10))

    52

    53

    54

def GetVariableTableColnames(location):

    55

    _ = NoTranslate

    56

    cols = ["#",

    57

            _("Name"),

    58

            _("Class"),

    59

            _("Type"),

    60

            _("Location"),

    61

            _("Initial Value"),

    62

            _("Option"),

    63

            _("Documentation")]

    64

    if not location:

    65

        del cols[4]  # remove 'Location' column

    66

    return cols

    67

    68

    69

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

    70

    _ = NoTranslate

    71

    options = [""]

    72

    if constant:

    73

        options.append(_("Constant"))

    74

    if retain:

    75

        options.append(_("Retain"))

    76

    if non_retain:

    77

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

    78

    return options

    79

    80

    81

def GetFilterChoiceTransfer():

    82

    _ = NoTranslate

    83

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

    84

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

    85

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

    86

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

    87

    88

    89

CheckOptionForClass = {

    90

    "Local": lambda x: x,

    91

    "Temp": lambda x: "",

    92

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

    93

    "InOut": lambda x: "",

    94

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

    95

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

    96

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

    97

}

    98

    99

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

   100

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

   101

   102

   103

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

   104

#                            Variables Panel Table

   105

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

   106

   107

   108

class VariableTable(CustomTable):

   109

   110

    """

   111

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

   112

    """

   113

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

   114

        # The base class must be initialized *first*

   115

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

   116

        self.old_value = None

   117

        self.OPTIONS_DICT = dict([(_(option), option)

   118

                                  for option in GetOptions()])

   119

        self.VARIABLE_CLASSES_DICT = dict([(_(_class), _class)

   120

                                           for _class in GetFilterChoiceTransfer().values()])

   121

   122

    def GetValueByName(self, row, colname):

   123

        if row < self.GetNumberRows():

   124

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

   125

   126

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

   127

        if row < self.GetNumberRows():

   128

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

   129

   130

    def GetValue(self, row, col):

   131

        if row < self.GetNumberRows():

   132

            if col == 0:

   133

                return self.data[row].Number

   134

            colname = self.GetColLabelValue(col, False)

   135

            if colname == "Initial Value":

   136

                colname = "InitialValue"

   137

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

   138

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

   139

                if value[0] == "array":

   140

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

   141

            if not isinstance(value, str):

   142

                value = str(value)

   143

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

   144

                return _(value)

   145

            return value

   146

   147

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

   148

        if col < len(self.colnames):

   149

            colname = self.GetColLabelValue(col, False)

   150

            if colname == "Name":

   151

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

   152

            elif colname == "Class":

   153

                value = self.VARIABLE_CLASSES_DICT[value]

   154

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

   155

                if value == "External":

   156

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

   157

            elif colname == "Option":

   158

                value = self.OPTIONS_DICT[value]

   159

            elif colname == "Initial Value":

   160

                colname = "InitialValue"

   161

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

   162

   163

    def GetOldValue(self):

   164

        return self.old_value

   165

   166

    def _GetRowEdit(self, row):

   167

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

   168

        var_type = self.Parent.GetTagName()

   169

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

   170

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

   171

            row_edit = True

   172

        return row_edit

   173

   174

    def _updateColAttrs(self, grid):

   175

        """

   176

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

   177

        appropriate renderer given the column name.

   178

   179

        Otherwise default to the default renderer.

   180

        """

   181

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

   182

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

   183

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

   184

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

   185

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

   186

                editor = None

   187

                renderer = None

   188

                colname = self.GetColLabelValue(col, False)

   189

                if self.Parent.Debug:

   190

                    grid.SetReadOnly(row, col, True)

   191

                else:

   192

                    if colname == "Option":

   193

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

   194

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

   195

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

   196

                        if len(options) > 1:

   197

                            editor = wx.grid.GridCellChoiceEditor(list(map(_, options)))

   198

                        else:

   199

                            grid.SetReadOnly(row, col, True)

   200

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

   201

                        grid.SetReadOnly(row, col, False)

   202

                        if colname == "Name":

   203

                            editor = wx.grid.GridCellTextEditor()

   204

                            renderer = wx.grid.GridCellStringRenderer()

   205

                        elif colname == "Initial Value":

   206

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

   207

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

   208

                                    editor = wx.grid.GridCellChoiceEditor([""] + self.Parent.Controler.GetEnumeratedDataValues(var_type))

   209

                                else:

   210

                                    editor = wx.grid.GridCellTextEditor()

   211

                                renderer = wx.grid.GridCellStringRenderer()

   212

                            else:

   213

                                grid.SetReadOnly(row, col, True)

   214

                        elif colname == "Location":

   215

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

   216

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

   217

                                renderer = wx.grid.GridCellStringRenderer()

   218

                            else:

   219

                                grid.SetReadOnly(row, col, True)

   220

                        elif colname == "Class":

   221

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

   222

                                grid.SetReadOnly(row, col, True)

   223

                            else:

   224

                                excluded = []

   225

                                if self.Parent.IsFunctionBlockType(var_type):

   226

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

   227

                                editor = wx.grid.GridCellChoiceEditor([_(choice) for choice in self.Parent.ClassList if choice not in excluded])

   228

                    elif colname != "Documentation":

   229

                        grid.SetReadOnly(row, col, True)

   230

   231

                grid.SetCellEditor(row, col, editor)

   232

                grid.SetCellRenderer(row, col, renderer)

   233

   234

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

   235

                    highlight_colours = ERROR_HIGHLIGHT

   236

                else:

   237

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

   238

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

   239

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

   240

            self.ResizeRow(grid, row)

   241

   242

   243

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

   244

#                         Variable Panel Drop Target

   245

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

   246

   247

   248

class VariableDropTarget(wx.TextDropTarget):

   249

    '''

   250

    This allows dragging a variable location from somewhere to the Location

   251

    column of a variable row.

   252

   253

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

   254

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

   255

   256

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

   257

    variable to the Location column of the variable panel).

   258

    '''

   259

    def __init__(self, parent):

   260

        wx.TextDropTarget.__init__(self)

   261

        self.ParentWindow = parent

   262

   263

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

   264

        self.ParentWindow.ParentWindow.Select()

   265

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

   266

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

   267

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

   268

        message = None

   269

        element_type = self.ParentWindow.ElementType

   270

        try:

   271

            values = eval(data)

   272

        except Exception:

   273

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

   274

            values = None

   275

        if not isinstance(values, tuple):

   276

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

   277

            values = None

   278

        if values is not None:

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

                    else:

   287

                        location = values[0]

   288

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

   289

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

   290

   291

                        if values[2] is not None:

   292

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

   293

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

   294

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

   295

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

   296

   297

                        if message is None:

   298

                            if not location.startswith("%"):

   299

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

   300

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

   301

                                elif location[0] not in LOCATIONDATATYPES:

   302

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

   303

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

   304

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

   305

                                              format(a1=location, a2=variable_type)

   306

                                else:

   307

                                    dialog = wx.SingleChoiceDialog(

   308

                                        self.ParentWindow.ParentWindow.ParentWindow,

   309

                                        _("Select a variable class:"),

   310

                                        _("Variable class"),

   311

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

   312

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

   313

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

   314

                                        selected = dialog.GetSelection()

   315

                                    else:

   316

                                        selected = None

   317

                                    dialog.Destroy()

   318

                                    if selected is None:

   319

                                        return False

   320

                                    if selected == 0:

   321

                                        location = "%I" + location

   322

                                    elif selected == 1:

   323

                                        location = "%Q" + location

   324

                                    else:

   325

                                        location = "%M" + location

   326

   327

                            if message is None:

   328

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

   329

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

   330

                                self.ParentWindow.SaveValues()

   331

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

   332

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

   333

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

   334

                    else:

   335

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

   336

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

   337

                        self.ParentWindow.SaveValues()

   338

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

   339

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

   340

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

   341

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

   342

                    var_name = values[3]

   343

                else:

   344

                    var_name = values[0]

   345

                tagname = self.ParentWindow.GetTagName()

   346

                dlg = wx.TextEntryDialog(

   347

                    self.ParentWindow.ParentWindow.ParentWindow,

   348

                    _("Confirm or change variable name"),

   349

                    _('Variable Drop'), var_name)

   350

                dlg.SetValue(var_name)

   351

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

   352

                dlg.Destroy()

   353

                if var_name is None:

   354

                    return False

   355

                elif var_name.upper() in [

   356

                        name.upper() for name in

   357

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

   358

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

   359

                elif not var_name.upper() in [

   360

                        name.upper()

   361

                        for name in self.ParentWindow.Controler.

   362

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

   363

                    var_infos = self.ParentWindow.DefaultValue.copy()

   364

                    var_infos.Name = var_name

   365

                    var_infos.Type = values[2]

   366

                    var_infos.Documentation = values[4]

   367

                    if values[1] == "location":

   368

                        location = values[0]

   369

                        if not location.startswith("%"):

   370

                            dialog = wx.SingleChoiceDialog(

   371

                                self.ParentWindow.ParentWindow.ParentWindow,

   372

                                _("Select a variable class:"),

   373

                                _("Variable class"),

   374

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

   375

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

   376

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

   377

                                selected = dialog.GetSelection()

   378

                            else:

   379

                                selected = None

   380

                            dialog.Destroy()

   381

                            if selected is None:

   382

                                return False

   383

                            if selected == 0:

   384

                                location = "%I" + location

   385

                            elif selected == 1:

   386

                                location = "%Q" + location

   387

                            else:

   388

                                location = "%M" + location

   389

                        if element_type == "functionBlock":

   390

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   391

                                self.ParentWindow.Debug)

   392

                            if len(configs) == 0:

   393

                                return False

   394

                            if not var_name.upper() in [

   395

                                    name.upper() for name in

   396

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

   397

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   398

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

   399

                            var_infos.Class = "External"

   400

                        else:

   401

                            if element_type == "program":

   402

                                var_infos.Class = "Local"

   403

                            else:

   404

                                var_infos.Class = "Global"

   405

                            var_infos.Location = location

   406

                    elif values[1] == "NamedConstant":

   407

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

   408

                            var_infos.Class = "Local"

   409

                            var_infos.InitialValue = values[0]

   410

                        else:

   411

                            return False

   412

                    else:

   413

                        var_infos.Class = "External"

   414

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

   415

                    self.ParentWindow.Values.append(var_infos)

   416

                    self.ParentWindow.SaveValues()

   417

                    self.ParentWindow.RefreshValues()

   418

                else:

   419

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

   420

   421

        if message is not None:

   422

            wx.CallAfter(self.ShowMessage, message)

   423

            return False

   424

   425

        return True

   426

   427

        return True

   428

   429

    def ShowMessage(self, message):

   430

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

   431

        message.ShowModal()

   432

        message.Destroy()

   433

   434

   435

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

   436

#                               Variable Panel

   437

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

   438

   439

   440

class VariablePanel(wx.Panel):

   441

   442

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

   443

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

   444

   445

        self.VARIABLE_CHOICES_DICT = dict([(_(_class), _class) for

   446

                                           _class in GetFilterChoiceTransfer().keys()])

   447

   448

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

   449

        self.MainSizer.AddGrowableCol(0)

   450

        self.MainSizer.AddGrowableRow(1)

   451

   452

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

   453

        controls_sizer.AddGrowableCol(5)

   454

        controls_sizer.AddGrowableRow(0)

   455

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

   456

   457

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

   458

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

   459

   460

        self.ReturnType = wx.ComboBox(self,

   461

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

   462

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

   463

        controls_sizer.Add(self.ReturnType)

   464

   465

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

   466

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

   467

   468

        self.Description = wx.TextCtrl(self,

   469

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

   470

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

   471

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

   472

        controls_sizer.Add(self.Description)

   473

   474

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

   475

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

   476

   477

        self.ClassFilter = wx.ComboBox(self,

   478

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

   479

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

   480

        controls_sizer.Add(self.ClassFilter)

   481

   482

        for name, bitmap, help in [

   483

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

   484

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

   485

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

   486

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

   487

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