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

import wx

    27

import wx.lib.buttons

    28

import wx.grid

    29

    30

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    31

from controls import CustomGrid, CustomTable, DurationCellEditor

    32

from dialogs.DurationEditorDialog import IEC_TIME_MODEL

    33

from editors.EditorPanel import EditorPanel

    34

from util.BitmapLibrary import GetBitmap

    35

from util.TranslationCatalogs import NoTranslate

    36

from plcopen.structures import TestIdentifier, IEC_KEYWORDS

    37

    38

    39

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

    40

#                          Configuration Editor class

    41

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

    42

    43

    44

class ConfigurationEditor(EditorPanel):

    45

    46

    VARIABLE_PANEL_TYPE = "config"

    47

    48

    def GetBufferState(self):

    49

        return self.Controler.GetBufferState()

    50

    51

    def Undo(self):

    52

        self.Controler.LoadPrevious()

    53

        self.ParentWindow.CloseTabsWithoutModel()

    54

    55

    def Redo(self):

    56

        self.Controler.LoadNext()

    57

        self.ParentWindow.CloseTabsWithoutModel()

    58

    59

    def HasNoModel(self):

    60

        return self.Controler.GetEditedElement(self.TagName) is None

    61

    62

    63

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

    64

#                            Resource Editor class

    65

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

    66

    67

def GetTasksTableColnames():

    68

    _ = NoTranslate

    69

    return [_("Name"), _("Triggering"), _("Single"), _("Interval"), _("Priority")]

    70

    71

    72

def GetTaskTriggeringOptions():

    73

    _ = NoTranslate

    74

    return [_("Interrupt"), _("Cyclic")]

    75

    76

    77

def CheckSingle(single, varlist):

    78

    return single in varlist

    79

    80

    81

def GetInstancesTableColnames():

    82

    _ = NoTranslate

    83

    return [_("Name"), _("Type"), _("Task")]

    84

    85

    86

class ResourceTable(CustomTable):

    87

    """

    88

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

    89

    """

    90

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

    91

        # The base class must be initialized *first*

    92

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

    93

        self.ColAlignements = []

    94

        self.ColSizes = []

    95

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

    96

                                                for option in GetTaskTriggeringOptions()])

    97

    98

    def GetColAlignements(self):

    99

        return self.ColAlignements

   100

   101

    def SetColAlignements(self, list):

   102

        self.ColAlignements = list

   103

   104

    def GetColSizes(self):

   105

        return self.ColSizes

   106

   107

    def SetColSizes(self, list):

   108

        self.ColSizes = list

   109

   110

    def GetValue(self, row, col):

   111

        if row < self.GetNumberRows():

   112

            colname = self.GetColLabelValue(col, False)

   113

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

   114

            if colname == "Triggering":

   115

                return _(value)

   116

            return value

   117

   118

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

   119

        if col < len(self.colnames):

   120

            colname = self.GetColLabelValue(col, False)

   121

            if colname == "Triggering":

   122

                value = self.TASKTRIGGERINGOPTIONS_DICT[value]

   123

            self.data[row][colname] = value

   124

   125

    def _updateColAttrs(self, grid):

   126

        """

   127

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

   128

        appropriate renderer given the column name.

   129

   130

        Otherwise default to the default renderer.

   131

        """

   132

   133

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

   134

            attr = wx.grid.GridCellAttr()

   135

            attr.SetAlignment(self.ColAlignements[col], wx.ALIGN_CENTRE)

   136

            grid.SetColAttr(col, attr)

   137

            grid.SetColSize(col, self.ColSizes[col])

   138

   139

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

   140

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

   141

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

   142

                editor = None

   143

                renderer = None

   144

                error = False

   145

                colname = self.GetColLabelValue(col, False)

   146

                grid.SetReadOnly(row, col, False)

   147

                if colname == "Name":

   148

                    editor = wx.grid.GridCellTextEditor()

   149

                    renderer = wx.grid.GridCellStringRenderer()

   150

                elif colname == "Interval":

   151

                    editor = DurationCellEditor(self, colname)

   152

                    renderer = wx.grid.GridCellStringRenderer()

   153

                    if self.GetValueByName(row, "Triggering") != "Cyclic":

   154

                        grid.SetReadOnly(row, col, True)

   155

                    interval = self.GetValueByName(row, colname)

   156

                    if interval != "" and IEC_TIME_MODEL.match(interval.upper()) is None:

   157

                        error = True

   158

                elif colname == "Single":

   159

                    editor = wx.grid.GridCellChoiceEditor(self.Parent.VariableList)

   160

                    if self.GetValueByName(row, "Triggering") != "Interrupt":

   161

                        grid.SetReadOnly(row, col, True)

   162

                    single = self.GetValueByName(row, colname)

   163

                    if single != "" and not CheckSingle(single, self.Parent.VariableList):

   164

                        error = True

   165

                elif colname == "Triggering":

   166

                    editor = wx.grid.GridCellChoiceEditor(list(map(_, GetTaskTriggeringOptions())))

   167

                elif colname == "Type":

   168

                    editor = wx.grid.GridCellChoiceEditor(self.Parent.TypeList)

   169

                elif colname == "Priority":

   170

                    editor = wx.grid.GridCellNumberEditor()

   171

                    editor.SetParameters("0,65535")

   172

                elif colname == "Task":

   173

                    editor = wx.grid.GridCellChoiceEditor(self.Parent.TaskList)

   174

   175

                grid.SetCellEditor(row, col, editor)

   176

                grid.SetCellRenderer(row, col, renderer)

   177

   178

                if error:

   179

                    highlight_colours = ERROR_HIGHLIGHT

   180

                else:

   181

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

   182

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

   183

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

   184

            self.ResizeRow(grid, row)

   185

   186

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

   187

    #                        Highlights showing functions

   188

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

   189

   190

    def AddHighlight(self, infos, highlight_type):

   191

        row_highlights = self.Highlights.setdefault(infos[0], {})

   192

        col_highlights = row_highlights.setdefault(infos[1], [])

   193

        col_highlights.append(highlight_type)

   194

   195

    def ClearHighlights(self, highlight_type=None):

   196

        if highlight_type is None:

   197

            self.Highlights = {}

   198

        else:

   199

            for _row, row_highlights in self.Highlights.items():

   200

                row_items = list(row_highlights.items())

   201

                for col, col_highlights in row_items:

   202

                    if highlight_type in col_highlights:

   203

                        col_highlights.remove(highlight_type)

   204

                    if len(col_highlights) == 0:

   205

                        row_highlights.pop(col)

   206

   207

   208

class ResourceEditor(EditorPanel):

   209

   210

    VARIABLE_PANEL_TYPE = "resource"

   211

   212

    def _init_Editor(self, parent):

   213

        self.Editor = wx.Panel(parent, style=wx.SUNKEN_BORDER | wx.TAB_TRAVERSAL)

   214

   215

        main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)

   216

        main_sizer.AddGrowableCol(0)

   217

        main_sizer.AddGrowableRow(0)

   218

        main_sizer.AddGrowableRow(1)

   219

   220

        tasks_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)

   221

        tasks_sizer.AddGrowableCol(0)

   222

        tasks_sizer.AddGrowableRow(1)

   223

        main_sizer.Add(tasks_sizer, border=5,

   224

                            flag=wx.GROW | wx.TOP | wx.LEFT | wx.RIGHT)

   225

   226

        tasks_buttons_sizer = wx.FlexGridSizer(cols=5, hgap=5, rows=1, vgap=0)

   227

        tasks_buttons_sizer.AddGrowableCol(0)

   228

        tasks_buttons_sizer.AddGrowableRow(0)

   229

        tasks_sizer.Add(tasks_buttons_sizer, flag=wx.GROW)

   230

   231

        tasks_label = wx.StaticText(self.Editor, label=_('Tasks:'))

   232

        tasks_buttons_sizer.Add(tasks_label, flag=wx.ALIGN_BOTTOM)

   233

   234

        for name, bitmap, help in [

   235

                ("AddTaskButton", "add_element", _("Add task")),

   236

                ("DeleteTaskButton", "remove_element", _("Remove task")),

   237

                ("UpTaskButton", "up", _("Move task up")),

   238

                ("DownTaskButton", "down", _("Move task down"))]:

   239

            button = wx.lib.buttons.GenBitmapButton(self.Editor,

   240

                                                    bitmap=GetBitmap(bitmap),

   241

                                                    size=wx.Size(28, 28),

   242

                                                    style=wx.NO_BORDER)

   243

            button.SetToolTip(help)

   244

            setattr(self, name, button)

   245

            tasks_buttons_sizer.Add(button)

   246

   247

        self.TasksGrid = CustomGrid(self.Editor, style=wx.VSCROLL)

   248

        self.TasksGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGED, self.OnTasksGridCellChange)

   249

        tasks_sizer.Add(self.TasksGrid, flag=wx.GROW)

   250

   251

        instances_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)

   252

        instances_sizer.AddGrowableCol(0)

   253

        instances_sizer.AddGrowableRow(1)

   254

        main_sizer.Add(instances_sizer, border=5,

   255

                            flag=wx.GROW | wx.BOTTOM | wx.LEFT | wx.RIGHT)

   256

   257

        instances_buttons_sizer = wx.FlexGridSizer(cols=5, hgap=5, rows=1, vgap=0)

   258

        instances_buttons_sizer.AddGrowableCol(0)

   259

        instances_buttons_sizer.AddGrowableRow(0)

   260

        instances_sizer.Add(instances_buttons_sizer, flag=wx.GROW)

   261

   262

        instances_label = wx.StaticText(self.Editor, label=_('Instances:'))

   263

        instances_buttons_sizer.Add(instances_label, flag=wx.ALIGN_BOTTOM)

   264

   265

        for name, bitmap, help in [

   266

                ("AddInstanceButton", "add_element", _("Add instance")),

   267

                ("DeleteInstanceButton", "remove_element", _("Remove instance")),

   268

                ("UpInstanceButton", "up", _("Move instance up")),

   269

                ("DownInstanceButton", "down", _("Move instance down"))]:

   270

            button = wx.lib.buttons.GenBitmapButton(

   271

                self.Editor, bitmap=GetBitmap(bitmap),

   272

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

   273

            button.SetToolTip(help)

   274

            setattr(self, name, button)

   275

            instances_buttons_sizer.Add(button)

   276

   277

        self.InstancesGrid = CustomGrid(self.Editor, style=wx.VSCROLL)

   278

        self.InstancesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGED, self.OnInstancesGridCellChange)

   279

        instances_sizer.Add(self.InstancesGrid, flag=wx.GROW)

   280

   281

        self.Editor.SetSizer(main_sizer)

   282

   283

    def __init__(self, parent, tagname, window, controler):

   284

        EditorPanel.__init__(self, parent, tagname, window, controler)

   285

   286

        self.RefreshHighlightsTimer = wx.Timer(self, -1)

   287

        self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, self.RefreshHighlightsTimer)

   288

   289

        self.TasksDefaultValue = {"Name": "task0", "Triggering": "Cyclic",

   290

                                  "Single": "", "Interval": "T#20ms", "Priority": 0}

   291

        self.TasksTable = ResourceTable(self, [], GetTasksTableColnames())

   292

        self.TasksTable.SetColAlignements([wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_RIGHT, wx.ALIGN_RIGHT])

   293

        self.TasksTable.SetColSizes([200, 100, 100, 150, 100])

   294

        self.TasksGrid.SetTable(self.TasksTable)

   295

        self.TasksGrid.SetButtons({"Add": self.AddTaskButton,

   296

                                   "Delete": self.DeleteTaskButton,

   297

                                   "Up": self.UpTaskButton,

   298

                                   "Down": self.DownTaskButton})

   299

   300

        def _AddTask(new_row):

   301

            if new_row > 0:

   302

                row_content = self.TasksTable.data[new_row-1].copy()

   303

                old_name = row_content['Name']

   304

                row_content['Name'] =\

   305

                    self.Controler.GenerateNewName(self.TagName, old_name, old_name+'%d')

   306

            else:

   307

                row_content = self.TasksDefaultValue.copy()

   308

   309

            self.TasksTable.InsertRow(new_row, row_content)

   310

            self.RefreshModel()

   311

            self.RefreshView()

   312

            return new_row

   313

        setattr(self.TasksGrid, "_AddRow", _AddTask)

   314

   315

        def _DeleteTask(row):

   316

            self.TasksTable.RemoveRow(row)

   317

            self.RefreshModel()

   318

            self.RefreshView()

   319

        setattr(self.TasksGrid, "_DeleteRow", _DeleteTask)

   320

   321

        def _MoveTask(row, move):

   322

            new_row = self.TasksTable.MoveRow(row, move)

   323

            if new_row != row:

   324

                self.RefreshModel()

   325

                self.RefreshView()

   326

            return new_row

   327

        setattr(self.TasksGrid, "_MoveRow", _MoveTask)

   328

   329

        self.TasksGrid.SetRowLabelSize(0)

   330

        self.TasksTable.ResetView(self.TasksGrid)

   331

        self.TasksGrid.RefreshButtons()

   332

   333

        self.InstancesDefaultValue = {"Name": "instance0", "Type": "", "Task": ""}

   334

        self.InstancesTable = ResourceTable(self, [], GetInstancesTableColnames())

   335

        self.InstancesTable.SetColAlignements([wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT])

   336

        self.InstancesTable.SetColSizes([200, 150, 150])

   337

        self.InstancesGrid.SetTable(self.InstancesTable)

   338

        self.InstancesGrid.SetButtons({"Add": self.AddInstanceButton,

   339

                                       "Delete": self.DeleteInstanceButton,

   340

                                       "Up": self.UpInstanceButton,

   341

                                       "Down": self.DownInstanceButton})

   342

   343

        def _AddInstance(new_row):

   344

            if new_row > 0:

   345

                row_content = self.InstancesTable.data[new_row - 1].copy()

   346

                old_name = row_content['Name']

   347

                row_content['Name'] =\

   348

                    self.Controler.GenerateNewName(self.TagName, old_name, old_name+'%d')

   349

            else:

   350

                row_content = self.InstancesDefaultValue.copy()

   351

   352

            self.InstancesTable.InsertRow(new_row, row_content)

   353

            self.RefreshModel()

   354

            self.RefreshView()

   355

            return new_row

   356

        setattr(self.InstancesGrid, "_AddRow", _AddInstance)

   357

   358

        def _DeleteInstance(row):

   359

            self.InstancesTable.RemoveRow(row)

   360

            self.RefreshModel()

   361

            self.RefreshView()

   362

        setattr(self.InstancesGrid, "_DeleteRow", _DeleteInstance)

   363

   364

        def _MoveInstance(row, move):

   365

            new_row = max(0, min(row + move, self.InstancesTable.GetNumberRows() - 1))

   366

            if new_row != row:

   367

                if self.InstancesTable.GetValueByName(row, "Task") != self.InstancesTable.GetValueByName(new_row, "Task"):

   368

                    return row

   369

                self.InstancesTable.MoveRow(row, move)

   370

                self.RefreshModel()

   371

                self.RefreshView()

   372

            return new_row

   373

        setattr(self.InstancesGrid, "_MoveRow", _MoveInstance)

   374

   375

        def _RefreshInstanceButtons():

   376

            if self:

   377

                rows = self.InstancesTable.GetNumberRows()

   378

                row = self.InstancesGrid.GetGridCursorRow()

   379

                self.DeleteInstanceButton.Enable(rows > 0)

   380

                self.UpInstanceButton.Enable(

   381

                    row > 0 and

   382

                    self.InstancesTable.GetValueByName(row, "Task") == self.InstancesTable.GetValueByName(row - 1, "Task"))

   383

                self.DownInstanceButton.Enable(

   384

                    0 <= row < rows - 1 and

   385

                    self.InstancesTable.GetValueByName(row, "Task") == self.InstancesTable.GetValueByName(row + 1, "Task"))

   386

        setattr(self.InstancesGrid, "RefreshButtons", _RefreshInstanceButtons)

   387

   388

        self.InstancesGrid.SetRowLabelSize(0)

   389

        self.InstancesTable.ResetView(self.InstancesGrid)

   390

        self.InstancesGrid.RefreshButtons()

   391

   392

        self.TasksGrid.SetFocus()

   393

   394

    def RefreshTypeList(self):

   395

        self.TypeList = []

   396

        blocktypes = self.Controler.GetBlockResource()

   397

        for blocktype in blocktypes:

   398

            self.TypeList.append(blocktype)

   399

   400

    def RefreshTaskList(self):

   401

        self.TaskList = []

   402

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

   403

            self.TaskList.append(self.TasksTable.GetValueByName(row, "Name"))

   404

   405

    def RefreshVariableList(self):

   406

        self.VariableList = []

   407

        for variable in self.Controler.GetEditedResourceVariables(self.TagName):

   408

            self.VariableList.append(variable)

   409

   410

    def RefreshModel(self):

   411

        self.Controler.SetEditedResourceInfos(self.TagName, self.TasksTable.GetData(), self.InstancesTable.GetData())

   412

        self.RefreshBuffer()

   413

   414

    # Buffer the last model state

   415

    def RefreshBuffer(self):

   416

        self.Controler.BufferProject()

   417

        self.ParentWindow.RefreshTitle()

   418

        self.ParentWindow.RefreshFileMenu()

   419

        self.ParentWindow.RefreshEditMenu()

   420

   421

    def GetBufferState(self):

   422

        return self.Controler.GetBufferState()

   423

   424

    def Undo(self):

   425

        self.Controler.LoadPrevious()

   426

        self.ParentWindow.CloseTabsWithoutModel()

   427

   428

    def Redo(self):

   429

        self.Controler.LoadNext()

   430

        self.ParentWindow.CloseTabsWithoutModel()

   431

   432

    def HasNoModel(self):

   433

        return self.Controler.GetEditedElement(self.TagName) is None

   434

   435

    def RefreshView(self, variablepanel=True):

   436

        EditorPanel.RefreshView(self, variablepanel)

   437

   438

        tasks, instances = self.Controler.GetEditedResourceInfos(self.TagName)

   439

        self.TasksTable.SetData(tasks)

   440

        self.InstancesTable.SetData(instances)

   441

        self.RefreshTypeList()

   442

        self.RefreshTaskList()

   443

        self.RefreshVariableList()

   444

        self.TasksTable.ResetView(self.TasksGrid)

   445

        self.InstancesTable.ResetView(self.InstancesGrid)

   446

        self.TasksGrid.RefreshButtons()

   447

        self.InstancesGrid.RefreshButtons()

   448

   449

    def ShowErrorMessage(self, message):

   450

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

   451

        dialog.ShowModal()

   452

        dialog.Destroy()

   453

   454

    def OnTasksGridCellChange(self, event):

   455

        row, col = event.GetRow(), event.GetCol()

   456

        if self.TasksTable.GetColLabelValue(col, False) == "Name":

   457

            value = self.TasksTable.GetValue(row, col)

   458

            message = None

   459

   460

            if not TestIdentifier(value):

   461

                message = _("\"%s\" is not a valid identifier!") % value

   462

            elif value.upper() in IEC_KEYWORDS:

   463

                message = _("\"%s\" is a keyword. It can't be used!") % value

   464

            elif value.upper() in [var["Name"].upper() for i, var in enumerate(self.TasksTable.data) if i != row]:

   465

                message = _("A task with the same name already exists!")

   466

            if message is not None:

   467

                event.Veto()

   468

                wx.CallAfter(self.ShowErrorMessage, message)

   469

                return

   470

   471

            tasklist = [name for name in self.TaskList if name != ""]

   472

            for i in range(self.TasksTable.GetNumberRows()):

   473

                task = self.TasksTable.GetValueByName(i, "Name")

   474

                if task in tasklist:

   475

                    tasklist.remove(task)

   476

            if len(tasklist) > 0:

   477

                old_name = tasklist[0].upper()

   478

                new_name = self.TasksTable.GetValue(row, col)

   479

                for i in range(self.InstancesTable.GetNumberRows()):

   480

                    name = self.InstancesTable.GetValueByName(i, "Task").upper()

   481

                    if old_name == name:

   482

                        self.InstancesTable.SetValueByName(i, "Task", new_name)

   483

        if self.TasksTable.GetColLabelValue(col, False) == "Triggering":

   484

            self.TasksTable.SetValueByName(row, "Interval", "T#20ms")

   485

        self.RefreshModel()

   486

        colname = self.TasksTable.GetColLabelValue(col, False)

   487

        if colname in ["Triggering", "Name", "Single", "Interval"]:

   488

            wx.CallAfter(self.RefreshView, False)

   489

        event.Skip()

   490

   491

    def OnInstancesGridCellChange(self, event):

   492

        row, col = event.GetRow(), event.GetCol()

   493

        if self.InstancesTable.GetColLabelValue(col, False) == "Name":

   494

            value = self.InstancesTable.GetValue(row, col)

   495

            message = None

   496

   497

            if not TestIdentifier(value):

   498

                message = _("\"%s\" is not a valid identifier!") % value

   499

            elif value.upper() in IEC_KEYWORDS:

   500

                message = _("\"%s\" is a keyword. It can't be used!") % value