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(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([""] + self.Parent.Controler.GetEnumeratedDataValues(var_type))

   215

                                else:

   216

                                    editor = wx.grid.GridCellTextEditor()

   217

                                renderer = wx.grid.GridCellStringRenderer()

   218

                            else:

   219

                                grid.SetReadOnly(row, col, True)

   220

                        elif colname == "Location":

   221

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

   222

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

   223

                                renderer = wx.grid.GridCellStringRenderer()

   224

                            else:

   225

                                grid.SetReadOnly(row, col, True)

   226

                        elif colname == "Class":

   227

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

   228

                                grid.SetReadOnly(row, col, True)

   229

                            else:

   230

                                excluded = []

   231

                                if self.Parent.IsFunctionBlockType(var_type):

   232

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

   233

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

   234

                    elif colname != "Documentation":

   235

                        grid.SetReadOnly(row, col, True)

   236

   237

                grid.SetCellEditor(row, col, editor)

   238

                grid.SetCellRenderer(row, col, renderer)

   239

   240

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

   241

                    highlight_colours = ERROR_HIGHLIGHT

   242

                else:

   243

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

   244

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

   245

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

   246

            self.ResizeRow(grid, row)

   247

   248

   249

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

   250

#                         Variable Panel Drop Target

   251

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

   252

   253

   254

class VariableDropTarget(wx.TextDropTarget):

   255

    '''

   256

    This allows dragging a variable location from somewhere to the Location

   257

    column of a variable row.

   258

   259

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

   260

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

   261

   262

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

   263

    variable to the Location column of the variable panel).

   264

    '''

   265

    def __init__(self, parent):

   266

        wx.TextDropTarget.__init__(self)

   267

        self.ParentWindow = parent

   268

   269

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

   270

        self.ParentWindow.ParentWindow.Select()

   271

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

   272

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

   273

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

   274

        message = None

   275

        element_type = self.ParentWindow.ElementType

   276

        try:

   277

            values = eval(data)

   278

        except Exception:

   279

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

   280

            values = None

   281

        if not isinstance(values, tuple):

   282

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

   283

            values = None

   284

        if values is not None:

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

                    else:

   293

                        location = values[0]

   294

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

   295

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

   296

   297

                        if values[2] is not None:

   298

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

   299

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

   300

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

   301

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

   302

   303

                        if message is None:

   304

                            if not location.startswith("%"):

   305

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

   306

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

   307

                                elif location[0] not in LOCATIONDATATYPES:

   308

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

   309

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

   310

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

   311

                                              format(a1=location, a2=variable_type)

   312

                                else:

   313

                                    dialog = wx.SingleChoiceDialog(

   314

                                        self.ParentWindow.ParentWindow.ParentWindow,

   315

                                        _("Select a variable class:"),

   316

                                        _("Variable class"),

   317

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

   318

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

   319

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

   320

                                        selected = dialog.GetSelection()

   321

                                    else:

   322

                                        selected = None

   323

                                    dialog.Destroy()

   324

                                    if selected is None:

   325

                                        return

   326

                                    if selected == 0:

   327

                                        location = "%I" + location

   328

                                    elif selected == 1:

   329

                                        location = "%Q" + location

   330

                                    else:

   331

                                        location = "%M" + location

   332

   333

                            if message is None:

   334

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

   335

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

   336

                                self.ParentWindow.SaveValues()

   337

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

   338

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

   339

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

   340

                    else:

   341

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

   342

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

   343

                        self.ParentWindow.SaveValues()

   344

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

   345

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

   346

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

   347

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

   348

                    var_name = values[3]

   349

                else:

   350

                    var_name = values[0]

   351

                tagname = self.ParentWindow.GetTagName()

   352

                dlg = wx.TextEntryDialog(

   353

                    self.ParentWindow.ParentWindow.ParentWindow,

   354

                    _("Confirm or change variable name"),

   355

                    _('Variable Drop'), var_name)

   356

                dlg.SetValue(var_name)

   357

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

   358

                dlg.Destroy()

   359

                if var_name is None:

   360

                    return

   361

                elif var_name.upper() in [

   362

                        name.upper() for name in

   363

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

   364

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

   365

                elif not var_name.upper() in [

   366

                        name.upper()

   367

                        for name in self.ParentWindow.Controler.

   368

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

   369

                    var_infos = self.ParentWindow.DefaultValue.copy()

   370

                    var_infos.Name = var_name

   371

                    var_infos.Type = values[2]

   372

                    var_infos.Documentation = values[4]

   373

                    if values[1] == "location":

   374

                        location = values[0]

   375

                        if not location.startswith("%"):

   376

                            dialog = wx.SingleChoiceDialog(

   377

                                self.ParentWindow.ParentWindow.ParentWindow,

   378

                                _("Select a variable class:"),

   379

                                _("Variable class"),

   380

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

   381

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

   382

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

   383

                                selected = dialog.GetSelection()

   384

                            else:

   385

                                selected = None

   386

                            dialog.Destroy()

   387

                            if selected is None:

   388

                                return

   389

                            if selected == 0:

   390

                                location = "%I" + location

   391

                            elif selected == 1:

   392

                                location = "%Q" + location

   393

                            else:

   394

                                location = "%M" + location

   395

                        if element_type == "functionBlock":

   396

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   397

                                self.ParentWindow.Debug)

   398

                            if len(configs) == 0:

   399

                                return

   400

                            if not var_name.upper() in [

   401

                                    name.upper() for name in

   402

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

   403

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   404

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

   405

                            var_infos.Class = "External"

   406

                        else:

   407

                            if element_type == "program":

   408

                                var_infos.Class = "Local"

   409

                            else:

   410

                                var_infos.Class = "Global"

   411

                            var_infos.Location = location

   412

                    elif values[1] == "NamedConstant":

   413

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

   414

                            var_infos.Class = "Local"

   415

                            var_infos.InitialValue = values[0]

   416

                        else:

   417

                            return

   418

                    else:

   419

                        var_infos.Class = "External"

   420

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

   421

                    self.ParentWindow.Values.append(var_infos)

   422

                    self.ParentWindow.SaveValues()

   423

                    self.ParentWindow.RefreshValues()

   424

                else:

   425

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

   426

   427

        if message is not None:

   428

            wx.CallAfter(self.ShowMessage, message)

   429

   430

    def ShowMessage(self, message):

   431

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

   432

        message.ShowModal()

   433

        message.Destroy()

   434

   435

   436

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

   437

#                               Variable Panel

   438

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

   439

   440

   441

class VariablePanel(wx.Panel):

   442

   443

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

   444

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

   445

   446

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

   447

                                           _class in GetFilterChoiceTransfer().iterkeys()])

   448

   449

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

   450

        self.MainSizer.AddGrowableCol(0)

   451

        self.MainSizer.AddGrowableRow(1)

   452

   453

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

   454

        controls_sizer.AddGrowableCol(5)

   455

        controls_sizer.AddGrowableRow(0)

   456

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

   457

   458

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

   459

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

   460

   461

        self.ReturnType = wx.ComboBox(self,

   462

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

   463

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

   464

        controls_sizer.Add(self.ReturnType)

   465

   466

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

   467

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

   468

   469

        self.Description = wx.TextCtrl(self,

   470

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

   471

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

   472

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

   473

        controls_sizer.Add(self.Description)

   474

   475

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

   476

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

   477

   478

        self.ClassFilter = wx.ComboBox(self,

   479

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

   480

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

   481

        controls_sizer.Add(self.ClassFilter)

   482

   483

        for name, bitmap, help in [

   484

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

   485

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

   486

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

   487

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