1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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

    35

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

    36

#                          Configuration Editor class

    37

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

    38

    39

[ID_CONFIGURATIONEDITOR, 

    40

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

    41

    42

class ConfigurationEditor(EditorPanel):

    43

    44

    ID = ID_CONFIGURATIONEDITOR

    45

    VARIABLE_PANEL_TYPE = "config"

    46

    47

    def GetBufferState(self):

    48

        return self.Controler.GetBufferState()

    49

    50

    def Undo(self):

    51

        self.Controler.LoadPrevious()

    52

        self.ParentWindow.CloseTabsWithoutModel()

    53

    54

    def Redo(self):

    55

        self.Controler.LoadNext()

    56

        self.ParentWindow.CloseTabsWithoutModel()

    57

    58

    def HasNoModel(self):

    59

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

    60

    61

    62

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

    63

#                            Resource Editor class

    64

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

    65

    66

def GetTasksTableColnames():

    67

    _ = lambda x : x

    68

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

    69

    70

def GetTaskTriggeringOptions():

    71

    _ = lambda x : x

    72

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

    73

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

    74

    75

def GetInstancesTableColnames():

    76

    _ = lambda x : x

    77

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

    78

    79

class ResourceTable(CustomTable):

    80

    81

    """

    82

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

    83

    """

    84

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

    85

        # The base class must be initialized *first*

    86

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

    87

        self.ColAlignements = []

    88

        self.ColSizes = []

    89

    90

    def GetColAlignements(self):

    91

        return self.ColAlignements

    92

    93

    def SetColAlignements(self, list):

    94

        self.ColAlignements = list

    95

    96

    def GetColSizes(self):

    97

        return self.ColSizes

    98

    99

    def SetColSizes(self, list):

   100

        self.ColSizes = list

   101

   102

    def GetValue(self, row, col):

   103

        if row < self.GetNumberRows():

   104

            colname = self.GetColLabelValue(col, False)

   105

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

   106

            if colname == "Triggering":

   107

                return _(value)

   108

            return value

   109

   110

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

   111

        if col < len(self.colnames):

   112

            colname = self.GetColLabelValue(col, False)

   113

            if colname == "Triggering":

   114

                value = TASKTRIGGERINGOPTIONS_DICT[value]

   115

            self.data[row][colname] = value

   116

   117

    def _updateColAttrs(self, grid):

   118

        """

   119

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

   120

        appropriate renderer given the column name.

   121

   122

        Otherwise default to the default renderer.

   123

        """

   124

   125

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

   126

            attr = wx.grid.GridCellAttr()

   127

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

   128

            grid.SetColAttr(col, attr)

   129

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

   130

   131

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

   132

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

   133

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

   134

                editor = None

   135

                renderer = None

   136

                error = False

   137

                colname = self.GetColLabelValue(col, False)

   138

                grid.SetReadOnly(row, col, False)

   139

                if colname == "Name":

   140

                    editor = wx.grid.GridCellTextEditor()

   141

                    renderer = wx.grid.GridCellStringRenderer()

   142

                elif colname == "Interval":

   143

                    editor = DurationCellEditor(self, colname)

   144

                    renderer = wx.grid.GridCellStringRenderer()

   145

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

   146

                        grid.SetReadOnly(row, col, True)

   147

                    interval = self.GetValueByName(row, colname)

   148

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

   149

                        error = True

   150

                elif colname == "Single":

   151

                    editor = wx.grid.GridCellChoiceEditor()

   152

                    editor.SetParameters(self.Parent.VariableList)

   153

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

   154

                        grid.SetReadOnly(row, col, True)

   155

                elif colname == "Triggering":

   156

                    editor = wx.grid.GridCellChoiceEditor()

   157

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

   158

                elif colname == "Type":

   159

                    editor = wx.grid.GridCellChoiceEditor()

   160

                    editor.SetParameters(self.Parent.TypeList)

   161

                elif colname == "Priority":

   162

                    editor = wx.grid.GridCellNumberEditor()

   163

                    editor.SetParameters("0,65535")

   164

                elif colname == "Task":

   165

                    editor = wx.grid.GridCellChoiceEditor()

   166

                    editor.SetParameters(self.Parent.TaskList)

   167

   168

                grid.SetCellEditor(row, col, editor)

   169

                grid.SetCellRenderer(row, col, renderer)

   170

   171

                if error:

   172

                    highlight_colours = ERROR_HIGHLIGHT

   173

                else:

   174

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

   175

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

   176

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

   177

            self.ResizeRow(grid, row)

   178

   179

   180

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

   181

#                        Highlights showing functions

   182

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

   183

   184

    def AddHighlight(self, infos, highlight_type):

   185

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

   186

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

   187

        col_highlights.append(highlight_type)

   188

   189

    def ClearHighlights(self, highlight_type=None):

   190

        if highlight_type is None:

   191

            self.Highlights = {}

   192

        else:

   193

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

   194

                row_items = row_highlights.items()

   195

                for col, col_highlights in row_items:

   196

                    if highlight_type in col_highlights:

   197

                        col_highlights.remove(highlight_type)

   198

                    if len(col_highlights) == 0:

   199

                        row_highlights.pop(col)

   200

   201

   202

   203

class ResourceEditor(EditorPanel):

   204

   205

    VARIABLE_PANEL_TYPE = "resource"

   206

   207

    def _init_Editor(self, parent):

   208

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

   209

   210

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

   211

        main_sizer.AddGrowableCol(0)

   212

        main_sizer.AddGrowableRow(0)

   213

        main_sizer.AddGrowableRow(1)

   214

   215

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

   216

        tasks_sizer.AddGrowableCol(0)

   217

        tasks_sizer.AddGrowableRow(1)

   218

        main_sizer.AddSizer(tasks_sizer, border=5, 

   219

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

   220

   221

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

   222

        tasks_buttons_sizer.AddGrowableCol(0)

   223

        tasks_buttons_sizer.AddGrowableRow(0)

   224

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

   225

   226

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

   227

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

   228

   229

        for name, bitmap, help in [

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

            button.SetToolTipString(help)

   237

            setattr(self, name, button)

   238

            tasks_buttons_sizer.AddWindow(button)

   239

   240

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

   241

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

   242

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

   243

   244

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

   245

        instances_sizer.AddGrowableCol(0)

   246

        instances_sizer.AddGrowableRow(1)

   247

        main_sizer.AddSizer(instances_sizer, border=5, 

   248

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

   249

   250

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

   251

        instances_buttons_sizer.AddGrowableCol(0)

   252

        instances_buttons_sizer.AddGrowableRow(0)

   253

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

   254

   255

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

   256

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

   257

   258

        for name, bitmap, help in [

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

            button.SetToolTipString(help)

   266

            setattr(self, name, button)

   267

            instances_buttons_sizer.AddWindow(button)

   268

   269

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

   270

        self.InstancesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, 

   271

              self.OnInstancesGridCellChange)

   272

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

   273

   274

        self.Editor.SetSizer(main_sizer)

   275

   276

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

   277

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

   278

   279

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

   280

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

   281

   282

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

   283

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

   284

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

   285

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

   286

        self.TasksGrid.SetTable(self.TasksTable)

   287

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

   288

                                   "Delete": self.DeleteTaskButton,

   289

                                   "Up": self.UpTaskButton,

   290

                                   "Down": self.DownTaskButton})

   291

   292

        def _AddTask(new_row):

   293

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

   294

            self.RefreshModel()

   295

            self.RefreshView()

   296

            return new_row

   297

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

   298

   299

        def _DeleteTask(row):

   300

            self.TasksTable.RemoveRow(row)

   301

            self.RefreshModel()

   302

            self.RefreshView()

   303

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

   304

   305

        def _MoveTask(row, move):

   306

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

   307

            if new_row != row:

   308

                self.RefreshModel()

   309

                self.RefreshView()

   310

            return new_row

   311

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

   312

   313

        self.TasksGrid.SetRowLabelSize(0)

   314

        self.TasksTable.ResetView(self.TasksGrid)

   315

        self.TasksGrid.RefreshButtons()

   316

   317

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

   318

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

   319

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

   320

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

   321

        self.InstancesGrid.SetTable(self.InstancesTable)

   322

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

   323

                                       "Delete": self.DeleteInstanceButton,

   324

                                       "Up": self.UpInstanceButton,

   325

                                       "Down": self.DownInstanceButton})

   326

   327

        def _AddInstance(new_row):

   328

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

   329

            self.RefreshModel()

   330

            self.RefreshView()

   331

            return new_row

   332

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

   333

   334

        def _DeleteInstance(row):

   335

            self.InstancesTable.RemoveRow(row)

   336

            self.RefreshModel()

   337

            self.RefreshView()

   338

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

   339

   340

        def _MoveInstance(row, move):

   341

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

   342

            if new_row != row:

   343

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

   344

                    return row 

   345

                self.InstancesTable.MoveRow(row, move)

   346

                self.RefreshModel()

   347

                self.RefreshView()

   348

            return new_row

   349

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

   350

   351

        def _RefreshInstanceButtons():

   352

            if self:

   353

                rows = self.InstancesTable.GetNumberRows()

   354

                row = self.InstancesGrid.GetGridCursorRow()

   355

                self.DeleteInstanceButton.Enable(rows > 0)

   356

                self.UpInstanceButton.Enable(row > 0 and 

   357

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

   358

                self.DownInstanceButton.Enable(0 <= row < rows - 1 and 

   359

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

   360

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

   361

   362

        self.InstancesGrid.SetRowLabelSize(0)

   363

        self.InstancesTable.ResetView(self.InstancesGrid)

   364

        self.InstancesGrid.RefreshButtons()

   365

   366

        self.TasksGrid.SetFocus()

   367

   368

    def __del__(self):

   369

        self.RefreshHighlightsTimer.Stop()

   370

   371

    def RefreshTypeList(self):

   372

        self.TypeList = ""

   373

        blocktypes = self.Controler.GetBlockResource()

   374

        for blocktype in blocktypes:

   375

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

   376

   377

    def RefreshTaskList(self):

   378

        self.TaskList = ""

   379

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

   380

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

   381

   382

    def RefreshVariableList(self):

   383

        self.VariableList = ""

   384

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

   385

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

   386

   387

    def RefreshModel(self):

   388

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

   389

        self.RefreshBuffer()

   390

   391

    # Buffer the last model state

   392

    def RefreshBuffer(self):

   393

        self.Controler.BufferProject()

   394

        self.ParentWindow.RefreshTitle()

   395

        self.ParentWindow.RefreshFileMenu()

   396

        self.ParentWindow.RefreshEditMenu()

   397

   398

    def GetBufferState(self):

   399

        return self.Controler.GetBufferState()

   400

   401

    def Undo(self):

   402

        self.Controler.LoadPrevious()

   403

        self.ParentWindow.CloseTabsWithoutModel()

   404

   405

    def Redo(self):

   406

        self.Controler.LoadNext()

   407

        self.ParentWindow.CloseTabsWithoutModel()

   408

   409

    def HasNoModel(self):

   410

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

   411

   412

    def RefreshView(self, variablepanel=True):

   413

        EditorPanel.RefreshView(self, variablepanel)

   414

   415

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

   416

        self.TasksTable.SetData(tasks)

   417

        self.InstancesTable.SetData(instances)

   418

        self.RefreshTypeList()

   419

        self.RefreshTaskList()

   420

        self.RefreshVariableList()

   421

        self.TasksTable.ResetView(self.TasksGrid)

   422

        self.InstancesTable.ResetView(self.InstancesGrid)

   423

        self.TasksGrid.RefreshButtons()

   424

        self.InstancesGrid.RefreshButtons()

   425

   426

    def OnTasksGridCellChange(self, event):

   427

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

   428

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

   429

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

   430

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

   431

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

   432

                if task in tasklist:

   433

                    tasklist.remove(task)

   434

            if len(tasklist) > 0:

   435

                old_name = tasklist[0]

   436

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

   437

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

   438

                    if self.InstancesTable.GetValueByName(i, "Task") == old_name:

   439

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

   440

        self.RefreshModel()

   441

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

   442

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

   443

            wx.CallAfter(self.RefreshView, False)

   444

        event.Skip()

   445

   446

    def OnInstancesGridCellChange(self, event):

   447

        self.RefreshModel()

   448

        self.ParentWindow.RefreshPouInstanceVariablesPanel()

   449

        self.InstancesGrid.RefreshButtons()

   450

        event.Skip()

   451

   452

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

   453

#                        Highlights showing functions

   454

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

   455

   456

    def OnRefreshHighlightsTimer(self, event):

   457

        self.RefreshView()

   458

        event.Skip()

   459

   460

    def AddHighlight(self, infos, start, end, highlight_type):

   461

        EditorPanel.AddHighlight(self, infos, start, end, highlight_type)

   462

   463

        if infos[0] == "task":

   464

            self.TasksTable.AddHighlight(infos[1:], highlight_type)

   465

        elif infos[0] == "instance":

   466

            self.InstancesTable.AddHighlight(infos[1:], highlight_type)

   467

        self.RefreshHighlightsTimer.Start(int(REFRESH_HIGHLIGHT_PERIOD * 1000), oneShot=True)

   468

   469

    def ClearHighlights(self, highlight_type=None):

   470

        EditorPanel.ClearHighlights(self, highlight_type)

   471

   472

        self.TasksTable.ClearHighlights(highlight_type)

   473

        self.InstancesTable.ClearHighlights(highlight_type)

   474

        self.TasksTable.ResetView(self.TasksGrid)

   475

        self.InstancesTable.ResetView(self.InstancesGrid)