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

import re

    28

from types import TupleType, StringType, UnicodeType

    29

    30

import wx

    31

import wx.grid

    32

import wx.lib.buttons

    33

from six.moves import xrange

    34

    35

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

    36

from plcopen.VariableInfoCollector import _VariableInfos

    37

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    38

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    39

from controls.CustomGrid import CustomGrid

    40

from controls.CustomTable import CustomTable

    41

from controls.LocationCellEditor import LocationCellEditor

    42

from util.BitmapLibrary import GetBitmap

    43

from util.TranslationCatalogs import NoTranslate

    44

    45

    46

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

    47

#                                 Helpers

    48

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

    49

    50

    51

[

    52

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

    53

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    54

] = range(10)

    55

    56

    57

def GetVariableTableColnames(location):

    58

    _ = NoTranslate

    59

    cols = ["#",

    60

            _("Name"),

    61

            _("Class"),

    62

            _("Type"),

    63

            _("Location"),

    64

            _("Initial Value"),

    65

            _("Option"),

    66

            _("Documentation")]

    67

    if not location:

    68

        del cols[4]  # remove 'Location' column

    69

    return cols

    70

    71

    72

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

    73

    _ = NoTranslate

    74

    options = [""]

    75

    if constant:

    76

        options.append(_("Constant"))

    77

    if retain:

    78

        options.append(_("Retain"))

    79

    if non_retain:

    80

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

    81

    return options

    82

    83

    84

def GetFilterChoiceTransfer():

    85

    _ = NoTranslate

    86

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

    87

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

    88

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

    89

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

    90

    91

    92

CheckOptionForClass = {

    93

    "Local": lambda x: x,

    94

    "Temp": lambda x: "",

    95

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

    96

    "InOut": lambda x: "",

    97

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

    98

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

    99

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

   100

}

   101

   102

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

   103

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

   104

   105

   106

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

   107

#                            Variables Panel Table

   108

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

   109

   110

   111

class VariableTable(CustomTable):

   112

   113

    """

   114

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

   115

    """

   116

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

   117

        # The base class must be initialized *first*

   118

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

   119

        self.old_value = None

   120

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

   121

                                  for option in GetOptions()])

   122

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

   123

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

   124

   125

    def GetValueByName(self, row, colname):

   126

        if row < self.GetNumberRows():

   127

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

   128

   129

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

   130

        if row < self.GetNumberRows():

   131

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

   132

   133

    def GetValue(self, row, col):

   134

        if row < self.GetNumberRows():

   135

            if col == 0:

   136

                return self.data[row].Number

   137

            colname = self.GetColLabelValue(col, False)

   138

            if colname == "Initial Value":

   139

                colname = "InitialValue"

   140

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

   141

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

   142

                if value[0] == "array":

   143

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

   144

            if not isinstance(value, (StringType, UnicodeType)):

   145

                value = str(value)

   146

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

   147

                return _(value)

   148

            return value

   149

   150

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

   151

        if col < len(self.colnames):

   152

            colname = self.GetColLabelValue(col, False)

   153

            if colname == "Name":

   154

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

   155

            elif colname == "Class":

   156

                value = self.VARIABLE_CLASSES_DICT[value]

   157

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

   158

                if value == "External":

   159

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

   160

            elif colname == "Option":

   161

                value = self.OPTIONS_DICT[value]

   162

            elif colname == "Initial Value":

   163

                colname = "InitialValue"

   164

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

   165

   166

    def GetOldValue(self):

   167

        return self.old_value

   168

   169

    def _GetRowEdit(self, row):

   170

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

   171

        var_type = self.Parent.GetTagName()

   172

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

   173

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

   174

            row_edit = True

   175

        return row_edit

   176

   177

    def _updateColAttrs(self, grid):

   178

        """

   179

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

   180

        appropriate renderer given the column name.

   181

   182

        Otherwise default to the default renderer.

   183

        """

   184

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

   185

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

   186

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

   187

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

   188

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

   189

                editor = None

   190

                renderer = None

   191

                colname = self.GetColLabelValue(col, False)

   192

                if self.Parent.Debug:

   193

                    grid.SetReadOnly(row, col, True)

   194

                else:

   195

                    if colname == "Option":

   196

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

   197

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

   198

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

   199

                        if len(options) > 1:

   200

                            editor = wx.grid.GridCellChoiceEditor()

   201

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

   202

                        else:

   203

                            grid.SetReadOnly(row, col, True)

   204

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

   205

                        grid.SetReadOnly(row, col, False)

   206

                        if colname == "Name":

   207

                            editor = wx.grid.GridCellTextEditor()

   208

                            renderer = wx.grid.GridCellStringRenderer()

   209

                        elif colname == "Initial Value":

   210

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

   211

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

   212

                                    editor = wx.grid.GridCellChoiceEditor()

   213

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

   214

                                else:

   215

                                    editor = wx.grid.GridCellTextEditor()

   216

                                renderer = wx.grid.GridCellStringRenderer()

   217

                            else:

   218

                                grid.SetReadOnly(row, col, True)

   219

                        elif colname == "Location":

   220

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

   221

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

   222

                                renderer = wx.grid.GridCellStringRenderer()

   223

                            else:

   224

                                grid.SetReadOnly(row, col, True)

   225

                        elif colname == "Class":

   226

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

   227

                                grid.SetReadOnly(row, col, True)

   228

                            else:

   229

                                editor = wx.grid.GridCellChoiceEditor()

   230

                                excluded = []

   231

                                if self.Parent.IsFunctionBlockType(var_type):

   232

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

   233

                                editor.SetParameters(",".join([_(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, TupleType):

   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.AddSizer(controls_sizer, border=5, flag=wx.GROW | wx.ALL)

   457

   458

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

   459

        controls_sizer.AddWindow(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.AddWindow(self.ReturnType)

   465

   466

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

   467

        controls_sizer.AddWindow(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.AddWindow(self.Description)

   474

   475

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

   476

        controls_sizer.AddWindow(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.AddWindow(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"))]:

   488

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

   489

                                                    size=wx.Size(28, 28), style=wx.NO_BORDER)