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

    38

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

    39

from plcopen.VariableInfoCollector import _VariableInfos

    40

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    41

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    42

from controls.CustomGrid import CustomGrid

    43

from controls.CustomTable import CustomTable

    44

from controls.LocationCellEditor import LocationCellEditor

    45

from util.BitmapLibrary import GetBitmap

    46

from util.TranslationCatalogs import NoTranslate

    47

    48

    49

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

    50

#                                 Helpers

    51

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

    52

    53

    54

[

    55

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

    56

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    57

] = range(10)

    58

    59

    60

def GetVariableTableColnames(location):

    61

    _ = NoTranslate

    62

    cols = ["#",

    63

            _("Name"),

    64

            _("Class"),

    65

            _("Type"),

    66

            _("Location"),

    67

            _("Initial Value"),

    68

            _("Option"),

    69

            _("Documentation")]

    70

    if not location:

    71

        del cols[4]  # remove 'Location' column

    72

    return cols

    73

    74

    75

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

    76

    _ = NoTranslate

    77

    options = [""]

    78

    if constant:

    79

        options.append(_("Constant"))

    80

    if retain:

    81

        options.append(_("Retain"))

    82

    if non_retain:

    83

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

    84

    return options

    85

    86

    87

def GetFilterChoiceTransfer():

    88

    _ = NoTranslate

    89

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

    90

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

    91

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

    92

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

    93

    94

    95

CheckOptionForClass = {

    96

    "Local": lambda x: x,

    97

    "Temp": lambda x: "",

    98

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

    99

    "InOut": lambda x: "",

   100

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

   101

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

   102

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

   103

}

   104

   105

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

   106

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

   107

   108

   109

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

   110

#                            Variables Panel Table

   111

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

   112

   113

   114

class VariableTable(CustomTable):

   115

   116

    """

   117

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

   118

    """

   119

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

   120

        # The base class must be initialized *first*

   121

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

   122

        self.old_value = None

   123

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

   124

                                  for option in GetOptions()])

   125

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

   126

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

   127

   128

    def GetValueByName(self, row, colname):

   129

        if row < self.GetNumberRows():

   130

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

   131

   132

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

   133

        if row < self.GetNumberRows():

   134

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

   135

   136

    def GetValue(self, row, col):

   137

        if row < self.GetNumberRows():

   138

            if col == 0:

   139

                return self.data[row].Number

   140

            colname = self.GetColLabelValue(col, False)

   141

            if colname == "Initial Value":

   142

                colname = "InitialValue"

   143

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

   144

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

   145

                if value[0] == "array":

   146

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

   147

            if not isinstance(value, string_types):

   148

                value = str(value)

   149

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

   150

                return _(value)

   151

            return value

   152

   153

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

   154

        if col < len(self.colnames):

   155

            colname = self.GetColLabelValue(col, False)

   156

            if colname == "Name":

   157

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

   158

            elif colname == "Class":

   159

                value = self.VARIABLE_CLASSES_DICT[value]

   160

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

   161

                if value == "External":

   162

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

   163

            elif colname == "Option":

   164

                value = self.OPTIONS_DICT[value]

   165

            elif colname == "Initial Value":

   166

                colname = "InitialValue"

   167

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

   168

   169

    def GetOldValue(self):

   170

        return self.old_value

   171

   172

    def _GetRowEdit(self, row):

   173

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

   174

        var_type = self.Parent.GetTagName()

   175

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

   176

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

   177

            row_edit = True

   178

        return row_edit

   179

   180

    def _updateColAttrs(self, grid):

   181

        """

   182

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

   183

        appropriate renderer given the column name.

   184

   185

        Otherwise default to the default renderer.

   186

        """

   187

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

   188

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

   189

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

   190

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

   191

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

   192

                editor = None

   193

                renderer = None

   194

                colname = self.GetColLabelValue(col, False)

   195

                if self.Parent.Debug:

   196

                    grid.SetReadOnly(row, col, True)

   197

                else:

   198

                    if colname == "Option":

   199

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

   200

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

   201

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

   202

                        if len(options) > 1:

   203

                            editor = wx.grid.GridCellChoiceEditor()

   204

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

   205

                        else:

   206

                            grid.SetReadOnly(row, col, True)

   207

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

   208

                        grid.SetReadOnly(row, col, False)

   209

                        if colname == "Name":

   210

                            editor = wx.grid.GridCellTextEditor()

   211

                            renderer = wx.grid.GridCellStringRenderer()

   212

                        elif colname == "Initial Value":

   213

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

   214

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

   215

                                    editor = wx.grid.GridCellChoiceEditor()

   216

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

   217

                                else:

   218

                                    editor = wx.grid.GridCellTextEditor()

   219

                                renderer = wx.grid.GridCellStringRenderer()

   220

                            else:

   221

                                grid.SetReadOnly(row, col, True)

   222

                        elif colname == "Location":

   223

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

   224

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

   225

                                renderer = wx.grid.GridCellStringRenderer()

   226

                            else:

   227

                                grid.SetReadOnly(row, col, True)

   228

                        elif colname == "Class":

   229

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

   230

                                grid.SetReadOnly(row, col, True)

   231

                            else:

   232

                                editor = wx.grid.GridCellChoiceEditor()

   233

                                excluded = []

   234

                                if self.Parent.IsFunctionBlockType(var_type):

   235

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

   236

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

   237

                    elif colname != "Documentation":

   238

                        grid.SetReadOnly(row, col, True)

   239

   240

                grid.SetCellEditor(row, col, editor)

   241

                grid.SetCellRenderer(row, col, renderer)

   242

   243

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

   244

                    highlight_colours = ERROR_HIGHLIGHT

   245

                else:

   246

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

   247

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

   248

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

   249

            self.ResizeRow(grid, row)

   250

   251

   252

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

   253

#                         Variable Panel Drop Target

   254

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

   255

   256

   257

class VariableDropTarget(wx.TextDropTarget):

   258

    '''

   259

    This allows dragging a variable location from somewhere to the Location

   260

    column of a variable row.

   261

   262

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

   263

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

   264

   265

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

   266

    variable to the Location column of the variable panel).

   267

    '''

   268

    def __init__(self, parent):

   269

        wx.TextDropTarget.__init__(self)

   270

        self.ParentWindow = parent

   271

   272

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

   273

        self.ParentWindow.ParentWindow.Select()

   274

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

   275

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

   276

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

   277

        message = None

   278

        element_type = self.ParentWindow.ElementType

   279

        try:

   280

            values = eval(data)

   281

        except Exception:

   282

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

   283

            values = None

   284

        if not isinstance(values, tuple):

   285

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

   286

            values = None

   287

        if values is not None:

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

                    else:

   296

                        location = values[0]

   297

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

   298

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

   299

   300

                        if values[2] is not None:

   301

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

   302

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

   303

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

   304

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

   305

   306

                        if message is None:

   307

                            if not location.startswith("%"):

   308

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

   309

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

   310

                                elif location[0] not in LOCATIONDATATYPES:

   311

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

   312

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

   313

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

   314

                                              format(a1=location, a2=variable_type)

   315

                                else:

   316

                                    dialog = wx.SingleChoiceDialog(

   317

                                        self.ParentWindow.ParentWindow.ParentWindow,

   318

                                        _("Select a variable class:"),

   319

                                        _("Variable class"),

   320

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

   321

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

   322

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

   323

                                        selected = dialog.GetSelection()

   324

                                    else:

   325

                                        selected = None

   326

                                    dialog.Destroy()

   327

                                    if selected is None:

   328

                                        return

   329

                                    if selected == 0:

   330

                                        location = "%I" + location

   331

                                    elif selected == 1:

   332

                                        location = "%Q" + location

   333

                                    else:

   334

                                        location = "%M" + location

   335

   336

                            if message is None:

   337

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

   338

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

   339

                                self.ParentWindow.SaveValues()

   340

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

   341

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

   342

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

   343

                    else:

   344

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

   345

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

   346

                        self.ParentWindow.SaveValues()

   347

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

   348

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

   349

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

   350

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

   351

                    var_name = values[3]

   352

                else:

   353

                    var_name = values[0]

   354

                tagname = self.ParentWindow.GetTagName()

   355

                dlg = wx.TextEntryDialog(

   356

                    self.ParentWindow.ParentWindow.ParentWindow,

   357

                    _("Confirm or change variable name"),

   358

                    _('Variable Drop'), var_name)

   359

                dlg.SetValue(var_name)

   360

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

   361

                dlg.Destroy()

   362

                if var_name is None:

   363

                    return

   364

                elif var_name.upper() in [

   365

                        name.upper() for name in

   366

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

   367

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

   368

                elif not var_name.upper() in [

   369

                        name.upper()

   370

                        for name in self.ParentWindow.Controler.

   371

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

   372

                    var_infos = self.ParentWindow.DefaultValue.copy()

   373

                    var_infos.Name = var_name

   374

                    var_infos.Type = values[2]

   375

                    var_infos.Documentation = values[4]

   376

                    if values[1] == "location":

   377

                        location = values[0]

   378

                        if not location.startswith("%"):

   379

                            dialog = wx.SingleChoiceDialog(

   380

                                self.ParentWindow.ParentWindow.ParentWindow,

   381

                                _("Select a variable class:"),

   382

                                _("Variable class"),

   383

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

   384

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

   385

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

   386

                                selected = dialog.GetSelection()

   387

                            else:

   388

                                selected = None

   389

                            dialog.Destroy()

   390

                            if selected is None:

   391

                                return

   392

                            if selected == 0:

   393

                                location = "%I" + location

   394

                            elif selected == 1:

   395

                                location = "%Q" + location

   396

                            else:

   397

                                location = "%M" + location

   398

                        if element_type == "functionBlock":

   399

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   400

                                self.ParentWindow.Debug)

   401

                            if len(configs) == 0:

   402

                                return

   403

                            if not var_name.upper() in [

   404

                                    name.upper() for name in

   405

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

   406

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   407

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

   408

                            var_infos.Class = "External"

   409

                        else:

   410

                            if element_type == "program":

   411

                                var_infos.Class = "Local"

   412

                            else:

   413

                                var_infos.Class = "Global"

   414

                            var_infos.Location = location

   415

                    elif values[1] == "NamedConstant":

   416

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

   417

                            var_infos.Class = "Local"

   418

                            var_infos.InitialValue = values[0]

   419

                        else:

   420

                            return

   421

                    else:

   422

                        var_infos.Class = "External"

   423

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

   424

                    self.ParentWindow.Values.append(var_infos)

   425

                    self.ParentWindow.SaveValues()

   426

                    self.ParentWindow.RefreshValues()

   427

                else:

   428

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

   429

   430

        if message is not None:

   431

            wx.CallAfter(self.ShowMessage, message)

   432

   433

    def ShowMessage(self, message):

   434

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

   435

        message.ShowModal()

   436

        message.Destroy()

   437

   438

   439

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

   440

#                               Variable Panel

   441

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

   442

   443

   444

class VariablePanel(wx.Panel):

   445

   446

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

   447

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

   448

   449

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

   450

                                           _class in GetFilterChoiceTransfer().iterkeys()])

   451

   452

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

   453

        self.MainSizer.AddGrowableCol(0)

   454

        self.MainSizer.AddGrowableRow(1)

   455

   456

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

   457

        controls_sizer.AddGrowableCol(5)

   458

        controls_sizer.AddGrowableRow(0)

   459

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

   460

   461

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

   462

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

   463

   464

        self.ReturnType = wx.ComboBox(self,

   465

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

   466

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

   467

        controls_sizer.AddWindow(self.ReturnType)

   468

   469

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

   470

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

   471

   472

        self.Description = wx.TextCtrl(self,

   473

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

   474

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

   475

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

   476

        controls_sizer.AddWindow(self.Description)

   477

   478

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

   479

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

   480

   481

        self.ClassFilter = wx.ComboBox(self,

   482

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

   483

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

   484

        controls_sizer.AddWindow(self.ClassFilter)

   485

   486

        for name, bitmap, help in [

   487

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

   488

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