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 wx

    26

import wx.lib.buttons

    27

import wx.grid

    28

    29

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    30

from controls import CustomGrid, CustomTable, DurationCellEditor

    31

from dialogs.DurationEditorDialog import IEC_TIME_MODEL

    32

from EditorPanel import EditorPanel

    33

from util.BitmapLibrary import GetBitmap

    34

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

    35

from util.TranslationCatalogs import NoTranslate

    36

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

    37

#                          Configuration Editor class

    38

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

    39

    40

[ID_CONFIGURATIONEDITOR,

    41

] = [wx.NewId() for _init_ctrls in range(1)]

    42

    43

    44

class ConfigurationEditor(EditorPanel):

    45

    46

    ID = ID_CONFIGURATIONEDITOR

    47

    VARIABLE_PANEL_TYPE = "config"

    48

    49

    def GetBufferState(self):

    50

        return self.Controler.GetBufferState()

    51

    52

    def Undo(self):

    53

        self.Controler.LoadPrevious()

    54

        self.ParentWindow.CloseTabsWithoutModel()

    55

    56

    def Redo(self):

    57

        self.Controler.LoadNext()

    58

        self.ParentWindow.CloseTabsWithoutModel()

    59

    60

    def HasNoModel(self):

    61

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

    62

    63

    64

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

    65

#                            Resource Editor class

    66

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

    67

    68

def GetTasksTableColnames():

    69

    _ = NoTranslate

    70

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

    71

    72

    73

def GetTaskTriggeringOptions():

    74

    _ = NoTranslate

    75

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

    76

    77

    78

TASKTRIGGERINGOPTIONS_DICT = dict([(_(option), option) for option in GetTaskTriggeringOptions()])

    79

    80

    81

def SingleCellEditor(*x):

    82

    return wx.grid.GridCellChoiceEditor()

    83

    84

    85

def CheckSingle(single, varlist):

    86

    return single in varlist

    87

    88

    89

def GetInstancesTableColnames():

    90

    _ = NoTranslate

    91

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

    92

    93

    94

class ResourceTable(CustomTable):

    95

    96

    """

    97

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

    98

    """

    99

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

   100

        # The base class must be initialized *first*

   101

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

   102

        self.ColAlignements = []

   103

        self.ColSizes = []

   104

   105

    def GetColAlignements(self):

   106

        return self.ColAlignements

   107

   108

    def SetColAlignements(self, list):

   109

        self.ColAlignements = list

   110

   111

    def GetColSizes(self):

   112

        return self.ColSizes

   113

   114

    def SetColSizes(self, list):

   115

        self.ColSizes = list

   116

   117

    def GetValue(self, row, col):

   118

        if row < self.GetNumberRows():

   119

            colname = self.GetColLabelValue(col, False)

   120

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

   121

            if colname == "Triggering":

   122

                return _(value)

   123

            return value

   124

   125

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

   126

        if col < len(self.colnames):

   127

            colname = self.GetColLabelValue(col, False)

   128

            if colname == "Triggering":

   129

                value = TASKTRIGGERINGOPTIONS_DICT[value]

   130

            self.data[row][colname] = value

   131

   132

    def _updateColAttrs(self, grid):

   133

        """

   134

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

   135

        appropriate renderer given the column name.

   136

   137

        Otherwise default to the default renderer.

   138

        """

   139

   140

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

   141

            attr = wx.grid.GridCellAttr()

   142

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

   143

            grid.SetColAttr(col, attr)

   144

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

   145

   146

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

   147

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

   148

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

   149

                editor = None

   150

                renderer = None

   151

                error = False

   152

                colname = self.GetColLabelValue(col, False)

   153

                grid.SetReadOnly(row, col, False)

   154

                if colname == "Name":

   155

                    editor = wx.grid.GridCellTextEditor()

   156

                    renderer = wx.grid.GridCellStringRenderer()

   157

                elif colname == "Interval":

   158

                    editor = DurationCellEditor(self, colname)

   159

                    renderer = wx.grid.GridCellStringRenderer()

   160

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

   161

                        grid.SetReadOnly(row, col, True)

   162

                    interval = self.GetValueByName(row, colname)

   163

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

   164

                        error = True

   165

                elif colname == "Single":

   166

                    editor = SingleCellEditor(self, colname)

   167

                    editor.SetParameters(self.Parent.VariableList)

   168

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

   169

                        grid.SetReadOnly(row, col, True)

   170

                    single = self.GetValueByName(row, colname)

   171

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

   172

                        error = True

   173

                elif colname == "Triggering":

   174

                    editor = wx.grid.GridCellChoiceEditor()

   175

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

   176

                elif colname == "Type":

   177

                    editor = wx.grid.GridCellChoiceEditor()

   178

                    editor.SetParameters(self.Parent.TypeList)

   179

                elif colname == "Priority":

   180

                    editor = wx.grid.GridCellNumberEditor()

   181

                    editor.SetParameters("0,65535")

   182

                elif colname == "Task":

   183

                    editor = wx.grid.GridCellChoiceEditor()

   184

                    editor.SetParameters(self.Parent.TaskList)

   185

   186

                grid.SetCellEditor(row, col, editor)

   187

                grid.SetCellRenderer(row, col, renderer)

   188

   189

                if error:

   190

                    highlight_colours = ERROR_HIGHLIGHT

   191

                else:

   192

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

   193

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

   194

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

   195

            self.ResizeRow(grid, row)

   196

   197

   198

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

   199

#                        Highlights showing functions

   200

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

   201

   202

    def AddHighlight(self, infos, highlight_type):

   203

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

   204

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

   205

        col_highlights.append(highlight_type)

   206

   207

    def ClearHighlights(self, highlight_type=None):

   208

        if highlight_type is None:

   209

            self.Highlights = {}

   210

        else:

   211

            for row, row_highlights in self.Highlights.iteritems():

   212

                row_items = row_highlights.items()

   213

                for col, col_highlights in row_items:

   214

                    if highlight_type in col_highlights:

   215

                        col_highlights.remove(highlight_type)

   216

                    if len(col_highlights) == 0:

   217

                        row_highlights.pop(col)

   218

   219

   220

class ResourceEditor(EditorPanel):

   221

   222

    VARIABLE_PANEL_TYPE = "resource"

   223

   224

    def _init_Editor(self, parent):

   225

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

   226

   227

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

   228

        main_sizer.AddGrowableCol(0)

   229

        main_sizer.AddGrowableRow(0)

   230

        main_sizer.AddGrowableRow(1)

   231

   232

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

   233

        tasks_sizer.AddGrowableCol(0)

   234

        tasks_sizer.AddGrowableRow(1)

   235

        main_sizer.AddSizer(tasks_sizer, border=5,

   237

   238

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

   239

        tasks_buttons_sizer.AddGrowableCol(0)

   240

        tasks_buttons_sizer.AddGrowableRow(0)

   241

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

   242

   243

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

   244

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

   245

   246

        for name, bitmap, help in [

   247

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

   248

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

   249

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

   250

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

   251

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

   255

            button.SetToolTipString(help)

   256

            setattr(self, name, button)

   257

            tasks_buttons_sizer.AddWindow(button)

   258

   259

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

   260

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

   261

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

   262

   263

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

   264

        instances_sizer.AddGrowableCol(0)

   265

        instances_sizer.AddGrowableRow(1)

   266

        main_sizer.AddSizer(instances_sizer, border=5,

   268

   269

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

   270

        instances_buttons_sizer.AddGrowableCol(0)

   271

        instances_buttons_sizer.AddGrowableRow(0)

   272

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

   273

   274

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

   275

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

   276

   277

        for name, bitmap, help in [

   278

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

   279

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

   280

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

   281

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

   285

            button.SetToolTipString(help)

   286

            setattr(self, name, button)

   287

            instances_buttons_sizer.AddWindow(button)

   288

   289

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

   291

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

   292

   293

        self.Editor.SetSizer(main_sizer)

   294

   295

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

   296

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

   297

   298

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

   299

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

   300

   301

        self.TasksDefaultValue = {"Name": "", "Triggering": "", "Single": "", "Interval": "", "Priority": 0}

   302

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

   303

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

   304

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

   305

        self.TasksGrid.SetTable(self.TasksTable)

   306

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

   307

                                   "Delete": self.DeleteTaskButton,

   308

                                   "Up": self.UpTaskButton,

   309

                                   "Down": self.DownTaskButton})

   310

   311

        def _AddTask(new_row):

   312

            self.TasksTable.InsertRow(new_row, self.TasksDefaultValue.copy())

   313

            self.RefreshModel()

   314

            self.RefreshView()

   315

            return new_row

   316

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

   317

   318

        def _DeleteTask(row):

   319

            self.TasksTable.RemoveRow(row)

   320

            self.RefreshModel()

   321

            self.RefreshView()

   322

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

   323

   324

        def _MoveTask(row, move):

   325

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

   326

            if new_row != row:

   327

                self.RefreshModel()

   328

                self.RefreshView()

   329

            return new_row

   330

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

   331

   332

        self.TasksGrid.SetRowLabelSize(0)

   333

        self.TasksTable.ResetView(self.TasksGrid)

   334

        self.TasksGrid.RefreshButtons()

   335

   336

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

   337

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

   338

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

   339

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

   340

        self.InstancesGrid.SetTable(self.InstancesTable)

   341

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

   342

                                       "Delete": self.DeleteInstanceButton,

   343

                                       "Up": self.UpInstanceButton,

   344

                                       "Down": self.DownInstanceButton})

   345

   346

        def _AddInstance(new_row):

   347

            self.InstancesTable.InsertRow(new_row, self.InstancesDefaultValue.copy())

   348

            self.RefreshModel()

   349

            self.RefreshView()

   350

            return new_row

   351

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

   352

   353

        def _DeleteInstance(row):

   354

            self.InstancesTable.RemoveRow(row)

   355

            self.RefreshModel()

   356

            self.RefreshView()

   357

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

   358

   359

        def _MoveInstance(row, move):

   360

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

   361

            if new_row != row:

   362

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

   363

                    return row

   364

                self.InstancesTable.MoveRow(row, move)

   365

                self.RefreshModel()

   366

                self.RefreshView()

   367

            return new_row

   368

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

   369

   370

        def _RefreshInstanceButtons():

   371

            if self:

   372

                rows = self.InstancesTable.GetNumberRows()

   373

                row = self.InstancesGrid.GetGridCursorRow()

   374

                self.DeleteInstanceButton.Enable(rows > 0)

   377

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

   380

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

   381

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

   382

   383

        self.InstancesGrid.SetRowLabelSize(0)

   384

        self.InstancesTable.ResetView(self.InstancesGrid)

   385

        self.InstancesGrid.RefreshButtons()

   386

   387

        self.TasksGrid.SetFocus()

   388

   389

    def __del__(self):

   390

        self.RefreshHighlightsTimer.Stop()

   391

   392

    def RefreshTypeList(self):

   393

        self.TypeList = ""

   394

        blocktypes = self.Controler.GetBlockResource()

   395

        for blocktype in blocktypes:

   396

            self.TypeList += ",%s" % blocktype

   397

   398

    def RefreshTaskList(self):

   399

        self.TaskList = ""

   400

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

   401

            self.TaskList += ",%s" % self.TasksTable.GetValueByName(row, "Name")

   402

   403

    def RefreshVariableList(self):

   404

        self.VariableList = ""

   405

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

   406

            self.VariableList += ",%s" % variable

   407

   408

    def RefreshModel(self):

   409

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

   410

        self.RefreshBuffer()

   411

   412

    # Buffer the last model state

   413

    def RefreshBuffer(self):

   414

        self.Controler.BufferProject()

   415

        self.ParentWindow.RefreshTitle()

   416

        self.ParentWindow.RefreshFileMenu()

   417

        self.ParentWindow.RefreshEditMenu()

   418

   419

    def GetBufferState(self):

   420

        return self.Controler.GetBufferState()

   421

   422

    def Undo(self):

   423

        self.Controler.LoadPrevious()

   424

        self.ParentWindow.CloseTabsWithoutModel()

   425

   426

    def Redo(self):

   427

        self.Controler.LoadNext()

   428

        self.ParentWindow.CloseTabsWithoutModel()

   429

   430

    def HasNoModel(self):

   431

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

   432

   433

    def RefreshView(self, variablepanel=True):

   434

        EditorPanel.RefreshView(self, variablepanel)

   435

   436

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

   437

        self.TasksTable.SetData(tasks)

   438

        self.InstancesTable.SetData(instances)

   439

        self.RefreshTypeList()

   440

        self.RefreshTaskList()

   441

        self.RefreshVariableList()

   442

        self.TasksTable.ResetView(self.TasksGrid)

   443

        self.InstancesTable.ResetView(self.InstancesGrid)

   444

        self.TasksGrid.RefreshButtons()

   445

        self.InstancesGrid.RefreshButtons()

   446

   447

    def ShowErrorMessage(self, message):

   448

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

   449

        dialog.ShowModal()

   450

        dialog.Destroy()

   451

   452

    def OnTasksGridCellChange(self, event):

   453

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

   454

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

   455

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

   456

            message = None

   457

   458

            if not TestIdentifier(value):

   459

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

   460

            elif value.upper() in IEC_KEYWORDS:

   461

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

   462

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

   463

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

   464

            if message is not None:

   465

                event.Veto()

   466

                wx.CallAfter(self.ShowErrorMessage, message)

   467

                return

   468

   469

            tasklist = [name for name in self.TaskList.split(",") if name != ""]

   470

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

   471

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

   472

                if task in tasklist:

   473

                    tasklist.remove(task)

   474

            if len(tasklist) > 0:

   475

                old_name = tasklist[0].upper()

   476

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

   477

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

   478

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

   479

                    if old_name == name:

   480

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

   481

        self.RefreshModel()

   482

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

   483

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

   484

            wx.CallAfter(self.RefreshView, False)

   485

        event.Skip()

   486

   487

    def OnInstancesGridCellChange(self, event):

   488

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

   489

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

   490

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

   491

            message = None

   492

   493

            if not TestIdentifier(value):

   494

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

   495

            elif value.upper() in IEC_KEYWORDS:

   496

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

   497

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

   498

                message = _("An instance with the same name already exists!")

   499

            if message is not None:

   500

                event.Veto()

   501

                wx.CallAfter(self.ShowErrorMessage, message)

   502

                return

   503

   504

        self.RefreshModel()

   505

        self.ParentWindow.RefreshPouInstanceVariablesPanel()