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.grid

    27

    28

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD

    29

from controls import CustomGrid, CustomTable, EditorPanel, DurationCellEditor

    30

    31

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

    32

#                          Configuration Editor class

    33

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

    34

    35

[ID_CONFIGURATIONEDITOR, 

    36

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

    37

    38

class ConfigurationEditor(EditorPanel):

    39

    40

    ID = ID_CONFIGURATIONEDITOR

    41

    VARIABLE_PANEL_TYPE = "config"

    42

    43

    def GetBufferState(self):

    44

        return self.Controler.GetBufferState()

    45

    46

    def Undo(self):

    47

        self.Controler.LoadPrevious()

    48

        self.ParentWindow.CloseTabsWithoutModel()

    49

    50

    def Redo(self):

    51

        self.Controler.LoadNext()

    52

        self.ParentWindow.CloseTabsWithoutModel()

    53

    54

    def HasNoModel(self):

    55

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

    56

    57

    58

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

    59

#                            Resource Editor class

    60

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

    61

    62

def GetTasksTableColnames():

    63

    _ = lambda x : x

    64

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

    65

    66

def GetTaskTriggeringOptions():

    67

    _ = lambda x : x

    68

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

    69

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

    70

    71

def GetInstancesTableColnames():

    72

    _ = lambda x : x

    73

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

    74

    75

class ResourceTable(CustomTable):

    76

    77

    """

    78

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

    79

    """

    80

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

    81

        # The base class must be initialized *first*

    82

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

    83

        self.ColAlignements = []

    84

        self.ColSizes = []

    85

    86

    def GetColAlignements(self):

    87

        return self.ColAlignements

    88

    89

    def SetColAlignements(self, list):

    90

        self.ColAlignements = list

    91

    92

    def GetColSizes(self):

    93

        return self.ColSizes

    94

    95

    def SetColSizes(self, list):

    96

        self.ColSizes = list

    97

    98

    def GetValue(self, row, col):

    99

        if row < self.GetNumberRows():

   100

            colname = self.GetColLabelValue(col, False)

   101

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

   102

            if colname == "Triggering":

   103

                return _(value)

   104

            return value

   105

   106

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

   107

        if col < len(self.colnames):

   108

            colname = self.GetColLabelValue(col, False)

   109

            if colname == "Triggering":

   110

                value = TASKTRIGGERINGOPTIONS_DICT[value]

   111

            self.data[row][colname] = value

   112

   113

    def _updateColAttrs(self, grid):

   114

        """

   115

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

   116

        appropriate renderer given the column name.

   117

   118

        Otherwise default to the default renderer.

   119

        """

   120

   121

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

   122

            attr = wx.grid.GridCellAttr()

   123

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

   124

            grid.SetColAttr(col, attr)

   125

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

   126

   127

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

   128

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

   129

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

   130

                editor = None

   131

                renderer = None

   132

                colname = self.GetColLabelValue(col, False)

   133

                grid.SetReadOnly(row, col, False)

   134

                if colname == "Name":

   135

                    editor = wx.grid.GridCellTextEditor()

   136

                    renderer = wx.grid.GridCellStringRenderer()

   137

                elif colname == "Interval":

   138

                    editor = DurationCellEditor(self)

   139

                    renderer = wx.grid.GridCellStringRenderer()

   140

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

   141

                        grid.SetReadOnly(row, col, True)

   142

                elif colname == "Single":

   143

                    editor = wx.grid.GridCellChoiceEditor()

   144

                    editor.SetParameters(self.Parent.VariableList)

   145

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

   146

                        grid.SetReadOnly(row, col, True)

   147

                elif colname == "Triggering":

   148

                    editor = wx.grid.GridCellChoiceEditor()

   149

                    editor.SetParameters(",".join([""] + map(_, GetTaskTriggeringOptions())))

   150

                elif colname == "Type":

   151

                    editor = wx.grid.GridCellChoiceEditor()

   152

                    editor.SetParameters(self.Parent.TypeList)

   153

                elif colname == "Priority":

   154

                    editor = wx.grid.GridCellNumberEditor()

   155

                    editor.SetParameters("0,65535")

   156

                elif colname == "Task":

   157

                    editor = wx.grid.GridCellChoiceEditor()

   158

                    editor.SetParameters(self.Parent.TaskList)

   159

   160

                grid.SetCellEditor(row, col, editor)

   161

                grid.SetCellRenderer(row, col, renderer)

   162

   163

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

   164

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

   165

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

   166

            self.ResizeRow(grid, row)

   167

   168

   169

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

   170

#                        Highlights showing functions

   171

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

   172

   173

    def AddHighlight(self, infos, highlight_type):

   174

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

   175

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

   176

        col_highlights.append(highlight_type)

   177

   178

    def ClearHighlights(self, highlight_type=None):

   179

        if highlight_type is None:

   180

            self.Highlights = {}

   181

        else:

   182

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

   183

                row_items = row_highlights.items()

   184

                for col, col_highlights in row_items:

   185

                    if highlight_type in col_highlights:

   186

                        col_highlights.remove(highlight_type)

   187

                    if len(col_highlights) == 0:

   188

                        row_highlights.pop(col)

   189

   190

[ID_RESOURCEEDITOR, ID_RESOURCEEDITORPANEL, ID_RESOURCEEDITORSTATICTEXT1,

   191

 ID_RESOURCEEDITORSTATICTEXT2, ID_RESOURCEEDITORINSTANCESGRID,

   192

 ID_RESOURCEEDITORTASKSGRID, ID_RESOURCEEDITORADDINSTANCEBUTTON,

   193

 ID_RESOURCEEDITORDELETEINSTANCEBUTTON, ID_RESOURCEEDITORUPINSTANCEBUTTON,

   194

 ID_RESOURCEEDITORDOWNINSTANCEBUTTON, ID_RESOURCEEDITORADDTASKBUTTON,

   195

 ID_RESOURCEEDITORDELETETASKBUTTON, ID_RESOURCEEDITORUPTASKBUTTON,

   196

 ID_RESOURCEEDITORDOWNTASKBUTTON,

   197

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

   198

   199

class ResourceEditor(EditorPanel):

   200

   201

    ID = ID_RESOURCEEDITOR

   202

    VARIABLE_PANEL_TYPE = "resource"

   203

   204

    def _init_coll_InstancesSizer_Growables(self, parent):

   205

        parent.AddGrowableCol(0)

   206

        parent.AddGrowableRow(1)

   207

   208

    def _init_coll_InstancesSizer_Items(self, parent):

   209

        parent.AddSizer(self.InstancesButtonsSizer, 0, border=0, flag=wx.GROW)

   210

        parent.AddWindow(self.InstancesGrid, 0, border=0, flag=wx.GROW)

   211

   212

    def _init_coll_InstancesButtonsSizer_Growables(self, parent):

   213

        parent.AddGrowableCol(0)

   214

        parent.AddGrowableRow(0)

   215

   216

    def _init_coll_InstancesButtonsSizer_Items(self, parent):

   217

        parent.AddWindow(self.staticText2, 0, border=0, flag=wx.ALIGN_BOTTOM)

   218

        parent.AddWindow(self.AddInstanceButton, 0, border=0, flag=0)

   219

        parent.AddWindow(self.DeleteInstanceButton, 0, border=0, flag=0)

   220

        parent.AddWindow(self.UpInstanceButton, 0, border=0, flag=0)

   221

        parent.AddWindow(self.DownInstanceButton, 0, border=0, flag=0)

   222

   223

    def _init_coll_TasksSizer_Growables(self, parent):

   224

        parent.AddGrowableCol(0)

   225

        parent.AddGrowableRow(1)

   226

   227

    def _init_coll_TasksSizer_Items(self, parent):

   228

        parent.AddSizer(self.TasksButtonsSizer, 0, border=0, flag=wx.GROW)

   229

        parent.AddWindow(self.TasksGrid, 0, border=0, flag=wx.GROW)

   230

   231

    def _init_coll_TasksButtonsSizer_Growables(self, parent):

   232

        parent.AddGrowableCol(0)

   233

        parent.AddGrowableRow(0)

   234

   235

    def _init_coll_TasksButtonsSizer_Items(self, parent):

   236

        parent.AddWindow(self.staticText1, 0, border=0, flag=wx.ALIGN_BOTTOM)

   237

        parent.AddWindow(self.AddTaskButton, 0, border=0, flag=0)

   238

        parent.AddWindow(self.DeleteTaskButton, 0, border=0, flag=0)

   239

        parent.AddWindow(self.UpTaskButton, 0, border=0, flag=0)

   240

        parent.AddWindow(self.DownTaskButton, 0, border=0, flag=0)

   241

   242

    def _init_coll_MainGridSizer_Items(self, parent):

   243

        parent.AddSizer(self.TasksSizer, 0, border=5, flag=wx.GROW|wx.TOP|wx.LEFT|wx.RIGHT)

   244

        parent.AddSizer(self.InstancesSizer, 0, border=5, flag=wx.GROW|wx.BOTTOM|wx.LEFT|wx.RIGHT)

   245

   246

    def _init_coll_MainGridSizer_Growables(self, parent):

   247

        parent.AddGrowableCol(0)

   248

        parent.AddGrowableRow(0)

   249

        parent.AddGrowableRow(1)

   250

   251

    def _init_sizers(self):

   252

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

   253

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

   254

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

   255

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

   256

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

   257

   258

        self._init_coll_MainGridSizer_Growables(self.MainGridSizer)

   259

        self._init_coll_MainGridSizer_Items(self.MainGridSizer)

   260

        self._init_coll_InstancesSizer_Growables(self.InstancesSizer)

   261

        self._init_coll_InstancesSizer_Items(self.InstancesSizer)

   262

        self._init_coll_InstancesButtonsSizer_Growables(self.InstancesButtonsSizer)

   263

        self._init_coll_InstancesButtonsSizer_Items(self.InstancesButtonsSizer)

   264

        self._init_coll_TasksSizer_Growables(self.TasksSizer)

   265

        self._init_coll_TasksSizer_Items(self.TasksSizer)

   266

        self._init_coll_TasksButtonsSizer_Growables(self.TasksButtonsSizer)

   267

        self._init_coll_TasksButtonsSizer_Items(self.TasksButtonsSizer)

   268

   269

        self.Editor.SetSizer(self.MainGridSizer)

   270

   271

    def _init_Editor(self, prnt):

   272

        self.Editor = wx.Panel(id=ID_RESOURCEEDITORPANEL, name='ResourceEditor', parent=prnt,

   273

              size=wx.Size(0, 0), style=wx.SUNKEN_BORDER|wx.TAB_TRAVERSAL)

   274

   275

        self.staticText1 = wx.StaticText(id=ID_RESOURCEEDITORSTATICTEXT1,

   276

              label=_(u'Tasks:'), name='staticText2', parent=self.Editor, pos=wx.Point(0,

   277

              0), size=wx.DefaultSize, style=0)

   278

   279

        self.TasksGrid = CustomGrid(id=ID_RESOURCEEDITORTASKSGRID,

   280

              name='TasksGrid', parent=self.Editor, pos=wx.Point(0, 0), 

   281

              size=wx.Size(-1, -1), style=wx.VSCROLL)

   282

        if wx.VERSION >= (2, 6, 0):

   283

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

   284

        else:

   285

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

   286

   287

        self.AddTaskButton = wx.Button(id=ID_RESOURCEEDITORADDTASKBUTTON, label=_('Add Task'),

   288

              name='AddTaskButton', parent=self.Editor, pos=wx.Point(0, 0),

   289

              size=wx.DefaultSize, style=0)

   290

   291

        self.DeleteTaskButton = wx.Button(id=ID_RESOURCEEDITORDELETETASKBUTTON, label=_('Delete Task'),

   292

              name='DeleteTaskButton', parent=self.Editor, pos=wx.Point(0, 0),

   293

              size=wx.DefaultSize, style=0)

   294

   295

        self.UpTaskButton = wx.Button(id=ID_RESOURCEEDITORUPTASKBUTTON, label='^',

   296

              name='UpTaskButton', parent=self.Editor, pos=wx.Point(0, 0),

   297

              size=wx.Size(32, -1), style=0)

   298

   299

        self.DownTaskButton = wx.Button(id=ID_RESOURCEEDITORDOWNTASKBUTTON, label='v',

   300

              name='DownTaskButton', parent=self.Editor, pos=wx.Point(0, 0),

   301

              size=wx.Size(32, -1), style=0)

   302

   303

        self.staticText2 = wx.StaticText(id=ID_RESOURCEEDITORSTATICTEXT2,

   304

              label=_(u'Instances:'), name='staticText1', parent=self.Editor,

   305

              pos=wx.Point(0, 0), size=wx.DefaultSize, style=0)

   306

   307

        self.InstancesGrid = CustomGrid(id=ID_RESOURCEEDITORINSTANCESGRID,

   308

              name='InstancesGrid', parent=self.Editor, pos=wx.Point(0, 0), 

   309

              size=wx.Size(-1, -1), style=wx.VSCROLL)

   310

        if wx.VERSION >= (2, 6, 0):

   311

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

   312

        else:

   313

            wx.grid.EVT_GRID_CELL_CHANGE(self.InstancesGrid, self.OnInstancesGridCellChange)

   314

   315

        self.AddInstanceButton = wx.Button(id=ID_RESOURCEEDITORADDINSTANCEBUTTON, label=_('Add Instance'),

   316

              name='AddInstanceButton', parent=self.Editor, pos=wx.Point(0, 0),

   317

              size=wx.DefaultSize, style=0)

   318

   319

        self.DeleteInstanceButton = wx.Button(id=ID_RESOURCEEDITORDELETEINSTANCEBUTTON, label=_('Delete Instance'),

   320

              name='DeleteInstanceButton', parent=self.Editor, pos=wx.Point(0, 0),

   321

              size=wx.DefaultSize, style=0)

   322

   323

        self.UpInstanceButton = wx.Button(id=ID_RESOURCEEDITORUPINSTANCEBUTTON, label='^',

   324

              name='UpInstanceButton', parent=self.Editor, pos=wx.Point(0, 0),

   325

              size=wx.Size(32, -1), style=0)

   326

   327

        self.DownInstanceButton = wx.Button(id=ID_RESOURCEEDITORDOWNINSTANCEBUTTON, label='v',

   328

              name='DownInstanceButton', parent=self.Editor, pos=wx.Point(0, 0),

   329

              size=wx.Size(32, -1), style=0)

   330

   331

        self._init_sizers()

   332

   333

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

   334

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

   335

   336

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

   337

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

   338

   339

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

   340

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

   341

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

   342

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

   343

        self.TasksGrid.SetTable(self.TasksTable)

   344

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

   345

                                   "Delete": self.DeleteTaskButton,

   346

                                   "Up": self.UpTaskButton,

   347

                                   "Down": self.DownTaskButton})

   348

   349

        def _AddTask(new_row):

   350

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

   351

            self.RefreshModel()

   352

            self.RefreshView()

   353

            return new_row

   354

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

   355

   356

        def _DeleteTask(row):

   357

            self.TasksTable.RemoveRow(row)

   358

            self.RefreshModel()

   359

            self.RefreshView()

   360

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

   361

   362

        def _MoveTask(row, move):

   363

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

   364

            if new_row != row:

   365

                self.RefreshModel()

   366

                self.RefreshView()

   367

            return new_row

   368

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

   369

   370

        self.TasksGrid.SetRowLabelSize(0)

   371

        self.TasksTable.ResetView(self.TasksGrid)

   372

        self.TasksGrid.RefreshButtons()

   373

   374

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

   375

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

   376

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

   377

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

   378

        self.InstancesGrid.SetTable(self.InstancesTable)

   379

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

   380

                                       "Delete": self.DeleteInstanceButton,

   381

                                       "Up": self.UpInstanceButton,

   382

                                       "Down": self.DownInstanceButton})

   383

   384

        def _AddInstance(new_row):

   385

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

   386

            self.RefreshModel()

   387

            self.RefreshView()

   388

            return new_row

   389

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

   390

   391

        def _DeleteInstance(row):

   392

            self.InstancesTable.RemoveRow(row)

   393

            self.RefreshModel()

   394

            self.RefreshView()

   395

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

   396

   397

        def _MoveInstance(row, move):

   398

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

   399

            if new_row != row:

   400

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

   401

                    return row 

   402

                self.InstancesTable.MoveRow(row, move)

   403

                self.RefreshModel()

   404

                self.RefreshView()

   405

            return new_row

   406

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

   407

   408

        def _RefreshInstanceButtons():

   409

            rows = self.InstancesTable.GetNumberRows()

   410

            row = self.InstancesGrid.GetGridCursorRow()

   411

            self.DeleteInstanceButton.Enable(rows > 0)

   412

            self.UpInstanceButton.Enable(row > 0 and 

   413

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

   414

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

   415

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

   416

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

   417

   418

        self.InstancesGrid.SetRowLabelSize(0)

   419

        self.InstancesTable.ResetView(self.InstancesGrid)

   420

        self.InstancesGrid.RefreshButtons()

   421

   422

        self.TasksGrid.SetFocus()

   423

   424

    def __del__(self):

   425

        self.RefreshHighlightsTimer.Stop()

   426

   427

    def RefreshTypeList(self):

   428

        self.TypeList = ""

   429

        blocktypes = self.Controler.GetBlockResource()

   430

        for blocktype in blocktypes:

   431

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

   432

   433

    def RefreshTaskList(self):

   434

        self.TaskList = ""

   435

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

   436

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

   437

   438

    def RefreshVariableList(self):

   439

        self.VariableList = ""

   440

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

   441

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

   442

   443

    def RefreshModel(self):

   444

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

   445

        self.RefreshBuffer()

   446

   447

    # Buffer the last model state

   448

    def RefreshBuffer(self):

   449

        self.Controler.BufferProject()

   450

        self.ParentWindow.RefreshTitle()

   451

        self.ParentWindow.RefreshFileMenu()

   452

        self.ParentWindow.RefreshEditMenu()

   453

   454

    def GetBufferState(self):

   455

        return self.Controler.GetBufferState()

   456

   457

    def Undo(self):

   458

        self.Controler.LoadPrevious()

   459

        self.ParentWindow.CloseTabsWithoutModel()

   460

   461

    def Redo(self):

   462

        self.Controler.LoadNext()

   463

        self.ParentWindow.CloseTabsWithoutModel()

   464

   465

    def HasNoModel(self):

   466

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

   467

   468

    def RefreshView(self, variablepanel=True):

   469

        EditorPanel.RefreshView(self, variablepanel)

   470

   471

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

   472

        self.TasksTable.SetData(tasks)

   473

        self.InstancesTable.SetData(instances)

   474

        self.RefreshTypeList()

   475

        self.RefreshTaskList()

   476

        self.RefreshVariableList()

   477

        self.TasksTable.ResetView(self.TasksGrid)

   478

        self.InstancesTable.ResetView(self.InstancesGrid)

   479

        self.TasksGrid.RefreshButtons()

   480

        self.InstancesGrid.RefreshButtons()

   481

   482

    def OnTasksGridCellChange(self, event):

   483

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

   484

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

   485

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

   486

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

   487

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

   488

                if task in tasklist:

   489

                    tasklist.remove(task)

   490

            if len(tasklist) > 0:

   491

                old_name = tasklist[0]

   492

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

   493

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

   494

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

   495

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

   496

        self.RefreshModel()

   497

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

   498