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

    34

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

    35

from plcopen.VariableInfoCollector import _VariableInfos

    36

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    37

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    38

from controls.CustomGrid import CustomGrid

    39

from controls.CustomTable import CustomTable

    40

from controls.LocationCellEditor import LocationCellEditor

    41

from util.BitmapLibrary import GetBitmap

    42

from util.TranslationCatalogs import NoTranslate

    43

    44

    45

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

    46

#                                 Helpers

    47

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

    48

    49

    50

[

    51

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

    52

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    53

] = range(10)

    54

    55

    56

def GetVariableTableColnames(location):

    57

    _ = NoTranslate

    58

    cols = ["#",

    59

            _("Name"),

    60

            _("Class"),

    61

            _("Type"),

    62

            _("Location"),

    63

            _("Initial Value"),

    64

            _("Option"),

    65

            _("Documentation")]

    66

    if not location:

    67

        del cols[4]  # remove 'Location' column

    68

    return cols

    69

    70

    71

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

    72

    _ = NoTranslate

    73

    options = [""]

    74

    if constant:

    75

        options.append(_("Constant"))

    76

    if retain:

    77

        options.append(_("Retain"))

    78

    if non_retain:

    79

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

    80

    return options

    81

    82

    83

def GetFilterChoiceTransfer():

    84

    _ = NoTranslate

    85

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

    86

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

    87

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

    88

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

    89

    90

    91

CheckOptionForClass = {

    92

    "Local": lambda x: x,

    93

    "Temp": lambda x: "",

    94

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

    95

    "InOut": lambda x: "",

    96

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

    97

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

    98

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

    99

}

   100

   101

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

   102

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

   103

   104

   105

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

   106

#                            Variables Panel Table

   107

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

   108

   109

   110

class VariableTable(CustomTable):

   111

   112

    """

   113

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

   114

    """

   115

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

   116

        # The base class must be initialized *first*

   117

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

   118

        self.old_value = None

   123

   124

    def GetValueByName(self, row, colname):

   125

        if row < self.GetNumberRows():

   126

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

   127

   128

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

   129

        if row < self.GetNumberRows():

   130

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

   131

   132

    def GetValue(self, row, col):

   133

        if row < self.GetNumberRows():

   134

            if col == 0:

   135

                return self.data[row].Number

   136

            colname = self.GetColLabelValue(col, False)

   137

            if colname == "Initial Value":

   138

                colname = "InitialValue"

   139

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

   140

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

   141

                if value[0] == "array":

   142

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

   143

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

   144

                value = str(value)

   145

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

   146

                return _(value)

   147

            return value

   148

   149

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

   150

        if col < len(self.colnames):

   151

            colname = self.GetColLabelValue(col, False)

   152

            if colname == "Name":

   153

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

   154

            elif colname == "Class":

   156

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

   157

                if value == "External":

   158

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

   159

            elif colname == "Option":

   161

            elif colname == "Initial Value":

   162

                colname = "InitialValue"

   163

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

   164

   165

    def GetOldValue(self):

   166

        return self.old_value

   167

   168

    def _GetRowEdit(self, row):

   169

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

   170

        var_type = self.Parent.GetTagName()

   171

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

   172

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

   173

            row_edit = True

   174

        return row_edit

   175

   176

    def _updateColAttrs(self, grid):

   177

        """

   178

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

   179

        appropriate renderer given the column name.

   180

   181

        Otherwise default to the default renderer.

   182

        """

   183

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

   184

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

   185

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

   186

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

   187

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

   188

                editor = None

   189

                renderer = None

   190

                colname = self.GetColLabelValue(col, False)

   191

                if self.Parent.Debug:

   192

                    grid.SetReadOnly(row, col, True)

   193

                else:

   194

                    if colname == "Option":

   195

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

   196

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

   197

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

   198

                        if len(options) > 1:

   199

                            editor = wx.grid.GridCellChoiceEditor()

   200

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

   201

                        else:

   202

                            grid.SetReadOnly(row, col, True)

   203

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

   204

                        grid.SetReadOnly(row, col, False)

   205

                        if colname == "Name":

   206

                            editor = wx.grid.GridCellTextEditor()

   207

                            renderer = wx.grid.GridCellStringRenderer()

   208

                        elif colname == "Initial Value":

   209

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

   210

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

   211

                                    editor = wx.grid.GridCellChoiceEditor()

   212

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

   213

                                else:

   214

                                    editor = wx.grid.GridCellTextEditor()

   215

                                renderer = wx.grid.GridCellStringRenderer()

   216

                            else:

   217

                                grid.SetReadOnly(row, col, True)

   218

                        elif colname == "Location":

   219

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

   220

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

   221

                                renderer = wx.grid.GridCellStringRenderer()

   222

                            else:

   223

                                grid.SetReadOnly(row, col, True)

   224

                        elif colname == "Class":

   225

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

   226

                                grid.SetReadOnly(row, col, True)

   227

                            else:

   228

                                editor = wx.grid.GridCellChoiceEditor()

   229

                                excluded = []

   230

                                if self.Parent.IsFunctionBlockType(var_type):

   231

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

   232

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

   233

                    elif colname != "Documentation":

   234

                        grid.SetReadOnly(row, col, True)

   235

   236

                grid.SetCellEditor(row, col, editor)

   237

                grid.SetCellRenderer(row, col, renderer)

   238

   239

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

   240

                    highlight_colours = ERROR_HIGHLIGHT

   241

                else:

   242

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

   243

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

   244

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

   245

            self.ResizeRow(grid, row)

   246

   247

   248

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

   249

#                         Variable Panel Drop Target

   250

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

   251

   252

   253

class VariableDropTarget(wx.TextDropTarget):

   254

    '''

   255

    This allows dragging a variable location from somewhere to the Location

   256

    column of a variable row.

   257

   258

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

   259

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

   260

   261

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

   262

    variable to the Location column of the variable panel).

   263

    '''

   264

    def __init__(self, parent):

   265

        wx.TextDropTarget.__init__(self)

   266

        self.ParentWindow = parent

   267

   268

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

   269

        self.ParentWindow.ParentWindow.Select()

   270

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

   271

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

   272

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

   273

        message = None

   274

        element_type = self.ParentWindow.ElementType

   275

        try:

   276

            values = eval(data)

   277

        except Exception:

   278

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

   279

            values = None

   280

        if not isinstance(values, TupleType):

   281

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

   282

            values = None

   283

        if values is not None:

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

                    else:

   292

                        location = values[0]

   293

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

   294

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

   295

   296

                        if values[2] is not None:

   297

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

   298

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

   299

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

   300

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

   301

   302

                        if message is None:

   303

                            if not location.startswith("%"):

   304

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

   305

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

   306

                                elif location[0] not in LOCATIONDATATYPES:

   307

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

   308

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

   309

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

   310

                                              format(a1=location, a2=variable_type)

   311

                                else:

   312

                                    dialog = wx.SingleChoiceDialog(

   313

                                        self.ParentWindow.ParentWindow.ParentWindow,

   314

                                        _("Select a variable class:"),

   315

                                        _("Variable class"),

   316

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

   317

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

   318

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

   319

                                        selected = dialog.GetSelection()

   320

                                    else:

   321

                                        selected = None

   322

                                    dialog.Destroy()

   323

                                    if selected is None:

   324

                                        return

   325

                                    if selected == 0:

   326

                                        location = "%I" + location

   327

                                    elif selected == 1:

   328

                                        location = "%Q" + location

   329

                                    else:

   330

                                        location = "%M" + location

   331

   332

                            if message is None:

   333

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

   334

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

   335

                                self.ParentWindow.SaveValues()

   336

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

   337

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

   338

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

   339

                    else:

   340

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

   341

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

   342

                        self.ParentWindow.SaveValues()

   343

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

   344

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

   345

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

   346

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

   347

                    var_name = values[3]

   348

                else:

   349

                    var_name = values[0]

   350

                tagname = self.ParentWindow.GetTagName()

   351

                dlg = wx.TextEntryDialog(

   352

                    self.ParentWindow.ParentWindow.ParentWindow,

   353

                    _("Confirm or change variable name"),

   354

                    _('Variable Drop'), var_name)

   355

                dlg.SetValue(var_name)

   356

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

   357

                dlg.Destroy()

   358

                if var_name is None:

   359

                    return

   360

                elif var_name.upper() in [

   361

                        name.upper() for name in

   362

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

   363

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

   364

                elif not var_name.upper() in [

   365

                        name.upper()

   366

                        for name in self.ParentWindow.Controler.

   367

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

   368

                    var_infos = self.ParentWindow.DefaultValue.copy()

   369

                    var_infos.Name = var_name

   370

                    var_infos.Type = values[2]

   371

                    var_infos.Documentation = values[4]

   372

                    if values[1] == "location":

   373

                        location = values[0]

   374

                        if not location.startswith("%"):

   375

                            dialog = wx.SingleChoiceDialog(

   376

                                self.ParentWindow.ParentWindow.ParentWindow,

   377

                                _("Select a variable class:"),

   378

                                _("Variable class"),

   379

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

   380

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

   381

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

   382

                                selected = dialog.GetSelection()

   383

                            else:

   384

                                selected = None

   385

                            dialog.Destroy()

   386

                            if selected is None:

   387

                                return

   388

                            if selected == 0:

   389

                                location = "%I" + location

   390

                            elif selected == 1:

   391

                                location = "%Q" + location

   392

                            else:

   393

                                location = "%M" + location

   394

                        if element_type == "functionBlock":

   395

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   396

                                self.ParentWindow.Debug)

   397

                            if len(configs) == 0:

   398

                                return

   399

                            if not var_name.upper() in [

   400

                                    name.upper() for name in

   401

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

   402

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   403

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

   404

                            var_infos.Class = "External"

   405

                        else:

   406

                            if element_type == "program":

   407

                                var_infos.Class = "Local"

   408

                            else:

   409

                                var_infos.Class = "Global"

   410

                            var_infos.Location = location

   411

                    elif values[1] == "NamedConstant":

   412

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

   413

                            var_infos.Class = "Local"

   414

                            var_infos.InitialValue = values[0]

   415

                        else:

   416

                            return

   417

                    else:

   418

                        var_infos.Class = "External"

   419

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

   420

                    self.ParentWindow.Values.append(var_infos)

   421

                    self.ParentWindow.SaveValues()

   422

                    self.ParentWindow.RefreshValues()

   423

                else:

   424

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

   425

   426

        if message is not None:

   427

            wx.CallAfter(self.ShowMessage, message)

   428

   429

    def ShowMessage(self, message):

   430

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

   431

        message.ShowModal()

   432

        message.Destroy()

   433

   434

   435

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

   436

#                               Variable Panel

   437

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

   438

   439

   440

class VariablePanel(wx.Panel):

   441

   442

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

   443

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

   444

   448

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

   449

        self.MainSizer.AddGrowableCol(0)

   450

        self.MainSizer.AddGrowableRow(1)

   451

   452

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

   453

        controls_sizer.AddGrowableCol(5)

   454

        controls_sizer.AddGrowableRow(0)

   455

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

   456

   457

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

   458

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

   459

   460

        self.ReturnType = wx.ComboBox(self,

   461

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

   462

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

   463

        controls_sizer.AddWindow(self.ReturnType)

   464

   465

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

   466

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

   467

   468

        self.Description = wx.TextCtrl(self,

   469

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

   470

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

   471

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

   472

        controls_sizer.AddWindow(self.Description)

   473

   474

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

   475

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

   476

   477

        self.ClassFilter = wx.ComboBox(self,

   478

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

   479

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

   480

        controls_sizer.AddWindow(self.ClassFilter)

   481

   482

        for name, bitmap, help in [

   483

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

   484

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

   485

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

   486

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

   487

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

   488

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