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

    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

        print("SetValue",row, col, value)

   155

        if col < len(self.colnames):

   156

            colname = self.GetColLabelValue(col, False)

   157

            if colname == "Name":

   158

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

   159

            elif colname == "Class":

   160

                value = self.VARIABLE_CLASSES_DICT[value]

   161

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

   162

                if value == "External":

   163

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

   164

            elif colname == "Option":

   165

                value = self.OPTIONS_DICT[value]

   166

            elif colname == "Initial Value":

   167

                colname = "InitialValue"

   168

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

   169

   170

    def GetOldValue(self):

   171

        return self.old_value

   172

   173

    def _GetRowEdit(self, row):

   174

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

   175

        var_type = self.Parent.GetTagName()

   176

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

   177

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

   178

            row_edit = True

   179

        return row_edit

   180

   181

    def _updateColAttrs(self, grid):

   182

        """

   183

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

   184

        appropriate renderer given the column name.

   185

   186

        Otherwise default to the default renderer.

   187

        """

   188

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

   189

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

   190

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

   191

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

   192

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

   193

                editor = None

   194

                renderer = None

   195

                colname = self.GetColLabelValue(col, False)

   196

                if self.Parent.Debug:

   197

                    grid.SetReadOnly(row, col, True)

   198

                else:

   199

                    if colname == "Option":

   200

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

   201

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

   202

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

   203

                        if len(options) > 1:

   204

                            editor = wx.grid.GridCellChoiceEditor()

   205

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

   206

                        else:

   207

                            grid.SetReadOnly(row, col, True)

   208

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

   209

                        grid.SetReadOnly(row, col, False)

   210

                        if colname == "Name":

   211

                            editor = wx.grid.GridCellTextEditor()

   212

                            renderer = wx.grid.GridCellStringRenderer()

   213

                        elif colname == "Initial Value":

   214

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

   215

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

   216

                                    editor = wx.grid.GridCellChoiceEditor()

   217

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

   218

                                else:

   219

                                    editor = wx.grid.GridCellTextEditor()

   220

                                renderer = wx.grid.GridCellStringRenderer()

   221

                            else:

   222

                                grid.SetReadOnly(row, col, True)

   223

                        elif colname == "Location":

   224

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

   225

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

   226

                                renderer = wx.grid.GridCellStringRenderer()

   227

                            else:

   228

                                grid.SetReadOnly(row, col, True)

   229

                        elif colname == "Class":

   230

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

   231

                                grid.SetReadOnly(row, col, True)

   232

                            else:

   233

                                editor = wx.grid.GridCellChoiceEditor()

   234

                                excluded = []

   235

                                if self.Parent.IsFunctionBlockType(var_type):

   236

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

   237

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

   238

                    elif colname != "Documentation":

   239

                        grid.SetReadOnly(row, col, True)

   240

   241

                grid.SetCellEditor(row, col, editor)

   242

                grid.SetCellRenderer(row, col, renderer)

   243

   244

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

   245

                    highlight_colours = ERROR_HIGHLIGHT

   246

                else:

   247

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

   248

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

   249

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

   250

            self.ResizeRow(grid, row)

   251

   252

   253

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

   254

#                         Variable Panel Drop Target

   255

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

   256

   257

   258

class VariableDropTarget(wx.TextDropTarget):

   259

    '''

   260

    This allows dragging a variable location from somewhere to the Location

   261

    column of a variable row.

   262

   263

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

   264

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

   265

   266

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

   267

    variable to the Location column of the variable panel).

   268

    '''

   269

    def __init__(self, parent):

   270

        wx.TextDropTarget.__init__(self)

   271

        self.ParentWindow = parent

   272

   273

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

   274

        self.ParentWindow.ParentWindow.Select()

   275

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

   276

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

   277

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

   278

        message = None

   279

        element_type = self.ParentWindow.ElementType

   280

        try:

   281

            values = eval(data)

   282

        except Exception:

   283

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

   284

            values = None

   285

        if not isinstance(values, tuple):

   286

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

   287

            values = None

   288

        if values is not None:

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

                    else:

   297

                        location = values[0]

   298

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

   299

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

   300

   301

                        if values[2] is not None:

   302

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

   303

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

   304

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

   305

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

   306

   307

                        if message is None:

   308

                            if not location.startswith("%"):

   309

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

   310

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

   311

                                elif location[0] not in LOCATIONDATATYPES:

   312

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

   313

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

   314

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

   315

                                              format(a1=location, a2=variable_type)

   316

                                else:

   317

                                    dialog = wx.SingleChoiceDialog(

   318

                                        self.ParentWindow.ParentWindow.ParentWindow,

   319

                                        _("Select a variable class:"),

   320

                                        _("Variable class"),

   321

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

   322

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

   323

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

   324

                                        selected = dialog.GetSelection()

   325

                                    else:

   326

                                        selected = None

   327

                                    dialog.Destroy()

   328

                                    if selected is None:

   329

                                        return

   330

                                    if selected == 0:

   331

                                        location = "%I" + location

   332

                                    elif selected == 1:

   333

                                        location = "%Q" + location

   334

                                    else:

   335

                                        location = "%M" + location

   336

   337

                            if message is None:

   338

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

   339

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

   340

                                self.ParentWindow.SaveValues()

   341

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

   342

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

   343

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

   344

                    else:

   345

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

   346

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

   347

                        self.ParentWindow.SaveValues()

   348

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

   349

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

   350

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

   351

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

   352

                    var_name = values[3]

   353

                else:

   354

                    var_name = values[0]

   355

                tagname = self.ParentWindow.GetTagName()

   356

                dlg = wx.TextEntryDialog(

   357

                    self.ParentWindow.ParentWindow.ParentWindow,

   358

                    _("Confirm or change variable name"),

   359

                    _('Variable Drop'), var_name)

   360

                dlg.SetValue(var_name)

   361

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

   362

                dlg.Destroy()

   363

                if var_name is None:

   364

                    return

   365

                elif var_name.upper() in [

   366

                        name.upper() for name in

   367

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

   368

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

   369

                elif not var_name.upper() in [

   370

                        name.upper()

   371

                        for name in self.ParentWindow.Controler.

   372

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

   373

                    var_infos = self.ParentWindow.DefaultValue.copy()

   374

                    var_infos.Name = var_name

   375

                    var_infos.Type = values[2]

   376

                    var_infos.Documentation = values[4]

   377

                    if values[1] == "location":

   378

                        location = values[0]

   379

                        if not location.startswith("%"):

   380

                            dialog = wx.SingleChoiceDialog(

   381

                                self.ParentWindow.ParentWindow.ParentWindow,

   382

                                _("Select a variable class:"),

   383

                                _("Variable class"),

   384

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

   385

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

   386

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

   387

                                selected = dialog.GetSelection()

   388

                            else:

   389

                                selected = None

   390

                            dialog.Destroy()

   391

                            if selected is None:

   392

                                return

   393

                            if selected == 0:

   394

                                location = "%I" + location

   395

                            elif selected == 1:

   396

                                location = "%Q" + location

   397

                            else:

   398

                                location = "%M" + location

   399

                        if element_type == "functionBlock":

   400

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   401

                                self.ParentWindow.Debug)

   402

                            if len(configs) == 0:

   403

                                return

   404

                            if not var_name.upper() in [

   405

                                    name.upper() for name in

   406

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

   407

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   408

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

   409

                            var_infos.Class = "External"

   410

                        else:

   411

                            if element_type == "program":

   412

                                var_infos.Class = "Local"

   413

                            else:

   414

                                var_infos.Class = "Global"

   415

                            var_infos.Location = location

   416

                    elif values[1] == "NamedConstant":

   417

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

   418

                            var_infos.Class = "Local"

   419

                            var_infos.InitialValue = values[0]

   420

                        else:

   421

                            return

   422

                    else:

   423

                        var_infos.Class = "External"

   424

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

   425

                    self.ParentWindow.Values.append(var_infos)

   426

                    self.ParentWindow.SaveValues()

   427

                    self.ParentWindow.RefreshValues()

   428

                else:

   429

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

   430

   431

        if message is not None:

   432

            wx.CallAfter(self.ShowMessage, message)

   433

   434

    def ShowMessage(self, message):

   435

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

   436

        message.ShowModal()

   437

        message.Destroy()

   438

   439

   440

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

   441

#                               Variable Panel

   442

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

   443

   444

   445

class VariablePanel(wx.Panel):

   446

   447

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

   448

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

   449

   450

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

   451

                                           _class in GetFilterChoiceTransfer().iterkeys()])

   452

   453

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

   454

        self.MainSizer.AddGrowableCol(0)

   455

        self.MainSizer.AddGrowableRow(1)

   456

   457

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

   458

        controls_sizer.AddGrowableCol(5)

   459

        controls_sizer.AddGrowableRow(0)

   460

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

   461

   462

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

   463

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

   464

   465

        self.ReturnType = wx.ComboBox(self,

   466

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

   467

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

   468

        controls_sizer.AddWindow(self.ReturnType)

   469

   470

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

   471

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

   472

   473

        self.Description = wx.TextCtrl(self,

   474

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

   475

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

   476

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

   477

        controls_sizer.AddWindow(self.Description)

   478

   479

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

   480

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

   481

   482

        self.ClassFilter = wx.ComboBox(self,

   483

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

   484

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

   485

        controls_sizer.AddWindow(self.ClassFilter)

   486

   487

        for name, bitmap, help in [

   488

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