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

import os

    26

import re

    27

from types import TupleType, StringType, UnicodeType

    28

    29

import wx

    30

import wx.grid

    31

import wx.lib.buttons

    32

    33

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

    34

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    35

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    36

from CustomGrid import CustomGrid

    37

from CustomTable import CustomTable

    38

from LocationCellEditor import LocationCellEditor

    39

from util.BitmapLibrary import GetBitmap

    40

from PLCControler import _VariableInfos

    41

from util.TranslationCatalogs import NoTranslate

    42

    43

    44

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

    45

#                                 Helpers

    46

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

    47

    48

    49

[

    50

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

    51

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    52

] = range(10)

    53

    54

    55

def GetVariableTableColnames(location):

    56

    _ = NoTranslate

    57

    cols = ["#",

    58

            _("Name"),

    59

            _("Class"),

    60

            _("Type"),

    61

            _("Location"),

    62

            _("Initial Value"),

    63

            _("Option"),

    64

            _("Documentation")]

    65

    if not location:

    66

        del cols[4]  # remove 'Location' column

    67

    return cols

    68

    69

    70

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

    71

    _ = NoTranslate

    72

    options = [""]

    73

    if constant:

    74

        options.append(_("Constant"))

    75

    if retain:

    76

        options.append(_("Retain"))

    77

    if non_retain:

    78

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

    79

    return options

    80

    81

    82

OPTIONS_DICT = dict([(_(option), option) for option in GetOptions()])

    83

    84

    85

def GetFilterChoiceTransfer():

    86

    _ = NoTranslate

    87

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

    88

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

    89

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

    90

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

    91

    92

    93

VARIABLE_CHOICES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().iterkeys()])

    94

VARIABLE_CLASSES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().itervalues()])

    95

    96

CheckOptionForClass = {

    97

    "Local": lambda x: x,

    98

    "Temp": lambda x: "",

    99

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

   100

    "InOut": lambda x: "",

   101

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

   102

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

   103

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

   104

}

   105

   106

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

   107

VARIABLE_NAME_SUFFIX_MODEL = re.compile("([0-9]*)$")

   108

   109

   110

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

   111

#                            Variables Panel Table

   112

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

   113

   114

   115

class VariableTable(CustomTable):

   116

   117

    """

   118

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

   119

    """

   120

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

   121

        # The base class must be initialized *first*

   122

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

   123

        self.old_value = None

   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(lambda x: "..".join(x), 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 = 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 = 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.MainSizer = wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=0)

   447

        self.MainSizer.AddGrowableCol(0)

   448

        self.MainSizer.AddGrowableRow(1)

   449

   450

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

   451

        controls_sizer.AddGrowableCol(5)

   452

        controls_sizer.AddGrowableRow(0)

   453

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

   454

   455

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

   456

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

   457

   458

        self.ReturnType = wx.ComboBox(self,

   459

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

   460

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

   461

        controls_sizer.AddWindow(self.ReturnType)

   462

   463

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

   464

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

   465

   466

        self.Description = wx.TextCtrl(self,

   467

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

   468

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

   469

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

   470

        controls_sizer.AddWindow(self.Description)

   471

   472

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

   473

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

   474

   475

        self.ClassFilter = wx.ComboBox(self,

   476

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

   477

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

   478

        controls_sizer.AddWindow(self.ClassFilter)

   479

   480

        for name, bitmap, help in [

   481

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

   482

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

   483

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

   484

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

   485

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

   486

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

   487

            button.SetToolTipString(help)

   488

            setattr(self, name, button)

   489

            controls_sizer.AddWindow(button)

   490