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

from __future__ import division

    28

import re

    29

from builtins import str as text

    30

    31

import wx

    32

import wx.grid

    33

import wx.lib.buttons

    34

from six import string_types

    35

from six.moves import xrange

    36

    37

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

    38

from plcopen.VariableInfoCollector import _VariableInfos

    39

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    40

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    41

from controls.CustomGrid import CustomGrid

    42

from controls.CustomTable import CustomTable

    43

from controls.LocationCellEditor import LocationCellEditor

    44

from util.BitmapLibrary import GetBitmap

    45

from util.TranslationCatalogs import NoTranslate

    46

    47

    48

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

    49

#                                 Helpers

    50

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

    51

    52

    53

[

    54

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

    55

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    56

] = range(10)

    57

    58

    59

def GetVariableTableColnames(location):

    60

    _ = NoTranslate

    61

    cols = ["#",

    62

            _("Name"),

    63

            _("Class"),

    64

            _("Type"),

    65

            _("Location"),

    66

            _("Initial Value"),

    67

            _("Option"),

    68

            _("Documentation")]

    69

    if not location:

    70

        del cols[4]  # remove 'Location' column

    71

    return cols

    72

    73

    74

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

    75

    _ = NoTranslate

    76

    options = [""]

    77

    if constant:

    78

        options.append(_("Constant"))

    79

    if retain:

    80

        options.append(_("Retain"))

    81

    if non_retain:

    82

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

    83

    return options

    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

CheckOptionForClass = {

    95

    "Local": lambda x: x,

    96

    "Temp": lambda x: "",

    97

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

    98

    "InOut": lambda x: "",

    99

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

   100

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

   101

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

   102

}

   103

   104

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

   105

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

   106

   107

   108

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

   109

#                            Variables Panel Table

   110

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

   111

   112

   113

class VariableTable(CustomTable):

   114

   115

    """

   116

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

   117

    """

   118

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

   119

        # The base class must be initialized *first*

   120

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

   121

        self.old_value = None

   122

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

   123

                                  for option in GetOptions()])

   124

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

   125

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

   126

   127

    def GetValueByName(self, row, colname):

   128

        if row < self.GetNumberRows():

   129

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

   130

   131

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

   132

        if row < self.GetNumberRows():

   133

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

   134

   135

    def GetValue(self, row, col):

   136

        if row < self.GetNumberRows():

   137

            if col == 0:

   138

                return self.data[row].Number

   139

            colname = self.GetColLabelValue(col, False)

   140

            if colname == "Initial Value":

   141

                colname = "InitialValue"

   142

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

   143

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

   144

                if value[0] == "array":

   145

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

   146

            if not isinstance(value, string_types):

   147

                value = str(value)

   148

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

   149

                return _(value)

   150

            return value

   151

   152

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

   153

        if col < len(self.colnames):

   154

            colname = self.GetColLabelValue(col, False)

   155

            if colname == "Name":

   156

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

   157

            elif colname == "Class":

   158

                value = self.VARIABLE_CLASSES_DICT[value]

   159

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

   160

                if value == "External":

   161

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

   162

            elif colname == "Option":

   163

                value = self.OPTIONS_DICT[value]

   164

            elif colname == "Initial Value":

   165

                colname = "InitialValue"

   166

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

   167

   168

    def GetOldValue(self):

   169

        return self.old_value

   170

   171

    def _GetRowEdit(self, row):

   172

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

   173

        var_type = self.Parent.GetTagName()

   174

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

   175

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

   176

            row_edit = True

   177

        return row_edit

   178

   179

    def _updateColAttrs(self, grid):

   180

        """

   181

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

   182

        appropriate renderer given the column name.

   183

   184

        Otherwise default to the default renderer.

   185

        """

   186

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

   187

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

   188

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

   189

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

   190

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

   191

                editor = None

   192

                renderer = None

   193

                colname = self.GetColLabelValue(col, False)

   194

                if self.Parent.Debug:

   195

                    grid.SetReadOnly(row, col, True)

   196

                else:

   197

                    if colname == "Option":

   198

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

   199

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

   200

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

   201

                        if len(options) > 1:

   202

                            editor = wx.grid.GridCellChoiceEditor()

   203

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

   204

                        else:

   205

                            grid.SetReadOnly(row, col, True)

   206

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

   207

                        grid.SetReadOnly(row, col, False)

   208

                        if colname == "Name":

   209

                            editor = wx.grid.GridCellTextEditor()

   210

                            renderer = wx.grid.GridCellStringRenderer()

   211

                        elif colname == "Initial Value":

   212

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

   213

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

   214

                                    editor = wx.grid.GridCellChoiceEditor()

   215

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

   216

                                else:

   217

                                    editor = wx.grid.GridCellTextEditor()

   218

                                renderer = wx.grid.GridCellStringRenderer()

   219

                            else:

   220

                                grid.SetReadOnly(row, col, True)

   221

                        elif colname == "Location":

   222

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

   223

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

   224

                                renderer = wx.grid.GridCellStringRenderer()

   225

                            else:

   226

                                grid.SetReadOnly(row, col, True)

   227

                        elif colname == "Class":

   228

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

   229

                                grid.SetReadOnly(row, col, True)

   230

                            else:

   231

                                editor = wx.grid.GridCellChoiceEditor()

   232

                                excluded = []

   233

                                if self.Parent.IsFunctionBlockType(var_type):

   234

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

   235

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

   236

                    elif colname != "Documentation":

   237

                        grid.SetReadOnly(row, col, True)

   238

   239

                grid.SetCellEditor(row, col, editor)

   240

                grid.SetCellRenderer(row, col, renderer)

   241

   242

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

   243

                    highlight_colours = ERROR_HIGHLIGHT

   244

                else:

   245

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

   246

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

   247

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

   248

            self.ResizeRow(grid, row)

   249

   250

   251

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

   252

#                         Variable Panel Drop Target

   253

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

   254

   255

   256

class VariableDropTarget(wx.TextDropTarget):

   257

    '''

   258

    This allows dragging a variable location from somewhere to the Location

   259

    column of a variable row.

   260

   261

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

   262

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

   263

   264

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

   265

    variable to the Location column of the variable panel).

   266

    '''

   267

    def __init__(self, parent):

   268

        wx.TextDropTarget.__init__(self)

   269

        self.ParentWindow = parent

   270

   271

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

   272

        self.ParentWindow.ParentWindow.Select()

   273

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

   274

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

   275

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

   276

        message = None

   277

        element_type = self.ParentWindow.ElementType

   278

        try:

   279

            values = eval(data)

   280

        except Exception:

   281

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

   282

            values = None

   283

        if not isinstance(values, tuple):

   284

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

   285

            values = None

   286

        if values is not None:

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

                    else:

   295

                        location = values[0]

   296

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

   297

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

   298

   299

                        if values[2] is not None:

   300

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

   301

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

   302

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

   303

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

   304

   305

                        if message is None:

   306

                            if not location.startswith("%"):

   307

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

   308

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

   309

                                elif location[0] not in LOCATIONDATATYPES:

   310

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

   311

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

   312

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

   313

                                              format(a1=location, a2=variable_type)

   314

                                else:

   315

                                    dialog = wx.SingleChoiceDialog(

   316

                                        self.ParentWindow.ParentWindow.ParentWindow,

   317

                                        _("Select a variable class:"),

   318

                                        _("Variable class"),

   319

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

   320

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

   321

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

   322

                                        selected = dialog.GetSelection()

   323

                                    else:

   324

                                        selected = None

   325

                                    dialog.Destroy()

   326

                                    if selected is None:

   327

                                        return

   328

                                    if selected == 0:

   329

                                        location = "%I" + location

   330

                                    elif selected == 1:

   331

                                        location = "%Q" + location

   332

                                    else:

   333

                                        location = "%M" + location

   334

   335

                            if message is None:

   336

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

   337

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

   338

                                self.ParentWindow.SaveValues()

   339

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

   340

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

   341

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

   342

                    else:

   343

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

   344

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

   345

                        self.ParentWindow.SaveValues()

   346

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

   347

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

   348

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

   349

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

   350

                    var_name = values[3]

   351

                else:

   352

                    var_name = values[0]

   353

                tagname = self.ParentWindow.GetTagName()

   354

                dlg = wx.TextEntryDialog(

   355

                    self.ParentWindow.ParentWindow.ParentWindow,

   356

                    _("Confirm or change variable name"),

   357

                    _('Variable Drop'), var_name)

   358

                dlg.SetValue(var_name)

   359

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

   360

                dlg.Destroy()

   361

                if var_name is None:

   362

                    return

   363

                elif var_name.upper() in [

   364

                        name.upper() for name in

   365

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

   366

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

   367

                elif not var_name.upper() in [

   368

                        name.upper()

   369

                        for name in self.ParentWindow.Controler.

   370

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

   371

                    var_infos = self.ParentWindow.DefaultValue.copy()

   372

                    var_infos.Name = var_name

   373

                    var_infos.Type = values[2]

   374

                    var_infos.Documentation = values[4]

   375

                    if values[1] == "location":

   376

                        location = values[0]

   377

                        if not location.startswith("%"):

   378

                            dialog = wx.SingleChoiceDialog(

   379

                                self.ParentWindow.ParentWindow.ParentWindow,

   380

                                _("Select a variable class:"),

   381

                                _("Variable class"),

   382

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

   383

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

   384

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

   385

                                selected = dialog.GetSelection()

   386

                            else:

   387

                                selected = None

   388

                            dialog.Destroy()

   389

                            if selected is None:

   390

                                return

   391

                            if selected == 0:

   392

                                location = "%I" + location

   393

                            elif selected == 1:

   394

                                location = "%Q" + location

   395

                            else:

   396

                                location = "%M" + location

   397

                        if element_type == "functionBlock":

   398

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   399

                                self.ParentWindow.Debug)

   400

                            if len(configs) == 0:

   401

                                return

   402

                            if not var_name.upper() in [

   403

                                    name.upper() for name in

   404

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

   405

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   406

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

   407

                            var_infos.Class = "External"

   408

                        else:

   409

                            if element_type == "program":

   410

                                var_infos.Class = "Local"

   411

                            else:

   412

                                var_infos.Class = "Global"

   413

                            var_infos.Location = location

   414

                    elif values[1] == "NamedConstant":

   415

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

   416

                            var_infos.Class = "Local"

   417

                            var_infos.InitialValue = values[0]

   418

                        else:

   419

                            return

   420

                    else:

   421

                        var_infos.Class = "External"

   422

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

   423

                    self.ParentWindow.Values.append(var_infos)

   424

                    self.ParentWindow.SaveValues()

   425

                    self.ParentWindow.RefreshValues()

   426

                else:

   427

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

   428

   429

        if message is not None:

   430

            wx.CallAfter(self.ShowMessage, message)

   431

   432

    def ShowMessage(self, message):

   433

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

   434

        message.ShowModal()

   435

        message.Destroy()

   436

   437

   438

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

   439

#                               Variable Panel

   440

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

   441

   442

   443

class VariablePanel(wx.Panel):

   444

   445

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

   446

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

   447

   448

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

   449

                                           _class in GetFilterChoiceTransfer().iterkeys()])

   450

   451

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

   452

        self.MainSizer.AddGrowableCol(0)

   453

        self.MainSizer.AddGrowableRow(1)

   454

   455

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

   456

        controls_sizer.AddGrowableCol(5)

   457

        controls_sizer.AddGrowableRow(0)

   458

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

   459

   460

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

   461

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

   462

   463

        self.ReturnType = wx.ComboBox(self,

   464

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

   465

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

   466

        controls_sizer.AddWindow(self.ReturnType)

   467

   468

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

   469

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

   470

   471

        self.Description = wx.TextCtrl(self,

   472

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

   473

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

   474

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

   475

        controls_sizer.AddWindow(self.Description)

   476

   477

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

   478

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

   479

   480

        self.ClassFilter = wx.ComboBox(self,

   481

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

   482

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

   483

        controls_sizer.AddWindow(self.ClassFilter)

   484

   485

        for name, bitmap, help in [

   486

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

   487

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

   488

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

   489

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