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 re

    26

    27

import wx

    28

import wx.grid

    29

import wx.lib.buttons

    30

    31

from plcopen.structures import IEC_KEYWORDS, TestIdentifier

    32

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD

    33

from controls import CustomEditableListBox, CustomGrid, CustomTable, EditorPanel

    34

from utils.BitmapLibrary import GetBitmap

    35

    36

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

    37

#                                    Helpers

    38

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

    39

    40

DIMENSION_MODEL = re.compile("([0-9]+)\.\.([0-9]+)$")

    41

    42

def AppendMenu(parent, help, id, kind, text):

    43

    parent.Append(help=help, id=id, kind=kind, text=text)

    44

    45

def GetElementsTableColnames():

    46

    _ = lambda x : x

    47

    return ["#", _("Name"), _("Type"), _("Initial Value")]

    48

    49

def GetDatatypeTypes():

    50

    _ = lambda x : x

    51

    return [_("Directly"), _("Subrange"), _("Enumerated"), _("Array"), _("Structure")]

    52

DATATYPE_TYPES_DICT = dict([(_(datatype), datatype) for datatype in GetDatatypeTypes()])

    53

    54

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

    55

#                            Structure Elements Table

    56

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

    57

    58

class ElementsTable(CustomTable):

    59

    60

    """

    61

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

    62

    """

    63

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

    64

        # The base class must be initialized *first*

    65

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

    66

        self.old_value = None

    67

    68

    def GetValue(self, row, col):

    69

        if row < self.GetNumberRows():

    70

            if col == 0:

    71

                return row + 1

    72

            name = str(self.data[row].get(self.GetColLabelValue(col, False), ""))

    73

            return name

    74

    75

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

    76

        if col < len(self.colnames):

    77

            colname = self.GetColLabelValue(col, False)

    78

            if colname == "Name":

    79

                self.old_value = self.data[row][colname]

    80

            self.data[row][colname] = value

    81

    82

    def GetOldValue(self):

    83

        return self.old_value

    84

    85

    def _updateColAttrs(self, grid):

    86

        """

    87

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

    88

        appropriate renderer given the column name.

    89

    90

        Otherwise default to the default renderer.

    91

        """

    92

    93

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

    94

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

    95

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

    96

                editor = None

    97

                renderer = None

    98

                colname = self.GetColLabelValue(col, False)

    99

                if col != 0:

   100

                    grid.SetReadOnly(row, col, False)

   101

                    if colname == "Name":

   102

                        editor = wx.grid.GridCellTextEditor()

   103

                        renderer = wx.grid.GridCellStringRenderer()

   104

                    elif colname == "Initial Value":

   105

                        editor = wx.grid.GridCellTextEditor()

   106

                        renderer = wx.grid.GridCellStringRenderer()

   107

                    elif colname == "Type":

   108

                        editor = wx.grid.GridCellTextEditor()

   109

                else:

   110

                    grid.SetReadOnly(row, col, True)

   111

   112

                grid.SetCellEditor(row, col, editor)

   113

                grid.SetCellRenderer(row, col, renderer)

   114

   115

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

   116

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

   117

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

   118

            self.ResizeRow(grid, row)

   119

   120

    def AddHighlight(self, infos, highlight_type):

   121

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

   122

        if infos[1] == "initial":

   123

            col_highlights = row_highlights.setdefault("initial value", [])

   124

        else:

   125

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

   126

        col_highlights.append(highlight_type)

   127

   128

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

   129

#                          Datatype Editor class

   130

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

   131

   132

class DataTypeEditor(EditorPanel):

   133

   134

    def _init_Editor(self, parent):

   135

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

   136

   137

        self.MainSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=10)

   138

        self.MainSizer.AddGrowableCol(0)

   139

        self.MainSizer.AddGrowableRow(1)

   140

   141

        top_sizer = wx.BoxSizer(wx.HORIZONTAL)

   142

        self.MainSizer.AddSizer(top_sizer, border=5, 

   143

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

   144

   145

        derivation_type_label = wx.StaticText(self.Editor, label=_('Derivation Type:'))

   146

        top_sizer.AddWindow(derivation_type_label, border=5, 

   147

              flag=wx.ALIGN_CENTER_VERTICAL|wx.LEFT|wx.RIGHT)

   148

   149

        self.DerivationType = wx.ComboBox(self.Editor,

   150

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

   151

        self.Bind(wx.EVT_COMBOBOX, self.OnDerivationTypeChanged, self.DerivationType)

   152

        top_sizer.AddWindow(self.DerivationType, border=5, flag=wx.GROW|wx.RIGHT)

   153

   154

        typeinfos_staticbox = wx.StaticBox(self.Editor, label=_('Type infos:'))

   155

        typeinfos_sizer = wx.StaticBoxSizer(typeinfos_staticbox, wx.HORIZONTAL)

   156

        self.MainSizer.AddSizer(typeinfos_sizer, border=5, 

   157

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

   158

   159

        # Panel for Directly derived data types

   160

   161

        self.DirectlyPanel = wx.Panel(self.Editor, style=wx.TAB_TRAVERSAL)

   162

        typeinfos_sizer.AddWindow(self.DirectlyPanel, 1)

   163

   164

        directly_panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

   165

   166

        directly_basetype_label = wx.StaticText(self.DirectlyPanel, 

   167

              label=_('Base Type:'))

   168

        directly_panel_sizer.AddWindow(directly_basetype_label, 1, border=5, 

   169

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   170

   171

        self.DirectlyBaseType = wx.ComboBox(self.DirectlyPanel, style=wx.CB_READONLY)

   172

        self.Bind(wx.EVT_COMBOBOX, self.OnInfosChanged, self.DirectlyPanel)

   173

        directly_panel_sizer.AddWindow(self.DirectlyBaseType, 1, border=5, 

   174

              flag=wx.GROW|wx.ALL)

   175

   176

        directly_initialvalue_label = wx.StaticText(self.DirectlyPanel,

   177

              label=_('Initial Value:'))

   178

        directly_panel_sizer.AddWindow(directly_initialvalue_label, 1, border=5, 

   179

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   180

   181

        self.DirectlyInitialValue = wx.TextCtrl(self.DirectlyPanel, 

   182

              style=wx.TAB_TRAVERSAL|wx.TE_PROCESS_ENTER|wx.TE_RICH)

   183

        self.Bind(wx.EVT_TEXT_ENTER, self.OnReturnKeyPressed, self.DirectlyInitialValue)

   184

        directly_panel_sizer.AddWindow(self.DirectlyInitialValue, 1, border=5, 

   185

              flag=wx.ALL)

   186

   187

        self.DirectlyPanel.SetSizer(directly_panel_sizer)

   188

   189

        # Panel for Subrange data types

   190

   191

        self.SubrangePanel = wx.Panel(self.Editor, style=wx.TAB_TRAVERSAL)

   192

        typeinfos_sizer.AddWindow(self.SubrangePanel, 1)

   193

   194

        subrange_panel_sizer = wx.GridSizer(cols=4, hgap=5, rows=3, vgap=0)

   195

   196

        subrange_basetype_label = wx.StaticText(self.SubrangePanel,

   197

              label=_('Base Type:'))

   198

        subrange_panel_sizer.AddWindow(subrange_basetype_label, 1, border=5, 

   199

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   200

   201

        self.SubrangeBaseType = wx.ComboBox(self.SubrangePanel, style=wx.CB_READONLY)

   202

        self.Bind(wx.EVT_COMBOBOX, self.OnSubrangeBaseTypeChanged, 

   203

              self.SubrangeBaseType)

   204

        subrange_panel_sizer.AddWindow(self.SubrangeBaseType, 1, border=5, 

   205

              flag=wx.GROW|wx.ALL)

   206

   207

        subrange_initialvalue_label = wx.StaticText(self.SubrangePanel,

   208

              label=_('Initial Value:'))

   209

        subrange_panel_sizer.AddWindow(subrange_initialvalue_label, 1, border=5, 

   210

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   211

   212

        self.SubrangeInitialValue = wx.SpinCtrl(self.SubrangePanel, 

   213

              style=wx.TAB_TRAVERSAL)

   214

        self.Bind(wx.EVT_SPINCTRL, self.OnInfosChanged, self.SubrangeInitialValue)

   215

        subrange_panel_sizer.AddWindow(self.SubrangeInitialValue, 1, border=5, 

   216

              flag=wx.GROW|wx.ALL)

   217

   218

        subrange_minimum_label = wx.StaticText(self.SubrangePanel, label=_('Minimum:'))

   219

        subrange_panel_sizer.AddWindow(subrange_minimum_label, 1, border=5, 

   220

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   221

   222

        self.SubrangeMinimum = wx.SpinCtrl(self.SubrangePanel, style=wx.TAB_TRAVERSAL)

   223

        self.Bind(wx.EVT_SPINCTRL, self.OnSubrangeMinimumChanged, self.SubrangeMinimum)

   224

        subrange_panel_sizer.AddWindow(self.SubrangeMinimum, 1, border=5, 

   225

              flag=wx.GROW|wx.ALL)

   226

   227

        for i in xrange(2):

   228

            subrange_panel_sizer.AddWindow(wx.Size(0, 0), 1)

   229

   230

        subrange_maximum_label = wx.StaticText(self.SubrangePanel,

   231

              label=_('Maximum:'))

   232

        subrange_panel_sizer.AddWindow(subrange_maximum_label, 1, border=5, 

   233

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   234

   235

        self.SubrangeMaximum = wx.SpinCtrl(self.SubrangePanel, style=wx.TAB_TRAVERSAL)

   236

        self.Bind(wx.EVT_SPINCTRL, self.OnSubrangeMaximumChanged, self.SubrangeMaximum)

   237

   238

        subrange_panel_sizer.AddWindow(self.SubrangeMaximum, 1, border=5, 

   239

              flag=wx.GROW|wx.ALL)

   240

   241

        self.SubrangePanel.SetSizer(subrange_panel_sizer)

   242

   243

        # Panel for Enumerated data types

   244

   245

        self.EnumeratedPanel = wx.Panel(self.Editor, style=wx.TAB_TRAVERSAL)

   246

        typeinfos_sizer.AddWindow(self.EnumeratedPanel, 1)

   247

   248

        enumerated_panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

   249

   250

        self.EnumeratedValues = CustomEditableListBox(self.EnumeratedPanel, 

   251

              label=_("Values:"), style=wx.gizmos.EL_ALLOW_NEW| 

   252

                                        wx.gizmos.EL_ALLOW_EDIT| 

   253

                                        wx.gizmos.EL_ALLOW_DELETE)

   254

        setattr(self.EnumeratedValues, "_OnLabelEndEdit", self.OnEnumeratedValueEndEdit)

   255

        for func in ["_OnAddButton", "_OnDelButton", "_OnUpButton", "_OnDownButton"]:

   256

            setattr(self.EnumeratedValues, func, self.OnEnumeratedValuesChanged)

   257

        enumerated_panel_sizer.AddWindow(self.EnumeratedValues, 1, border=5, 

   258

              flag=wx.GROW|wx.ALL)

   259

   260

        enumerated_panel_rightsizer = wx.BoxSizer(wx.HORIZONTAL)

   261

        enumerated_panel_sizer.AddSizer(enumerated_panel_rightsizer, 1)

   262

   263

        enumerated_initialvalue_label = wx.StaticText(self.EnumeratedPanel,

   264

              label=_('Initial Value:'))

   265

        enumerated_panel_rightsizer.AddWindow(enumerated_initialvalue_label, 1, 

   266

              border=5, flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   267

   268

        self.EnumeratedInitialValue = wx.ComboBox(self.EnumeratedPanel, 

   269

              style=wx.CB_READONLY)

   270

        self.Bind(wx.EVT_COMBOBOX, self.OnInfosChanged, self.EnumeratedInitialValue)

   271

        enumerated_panel_rightsizer.AddWindow(self.EnumeratedInitialValue, 1, 

   272

              border=5, flag=wx.ALL)

   273

   274

        self.EnumeratedPanel.SetSizer(enumerated_panel_sizer)

   275

   276

        # Panel for Array data types

   277

   278

        self.ArrayPanel = wx.Panel(self.Editor, style=wx.TAB_TRAVERSAL)

   279

        typeinfos_sizer.AddWindow(self.ArrayPanel, 1)

   280

   281

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

   282

        array_panel_sizer.AddGrowableCol(0)

   283

        array_panel_sizer.AddGrowableCol(1)

   284

        array_panel_sizer.AddGrowableRow(1)

   285

   286

        array_panel_leftSizer = wx.BoxSizer(wx.HORIZONTAL)

   287

        array_panel_sizer.AddSizer(array_panel_leftSizer, flag=wx.GROW)

   288

   289

        array_basetype_label = wx.StaticText(self.ArrayPanel, label=_('Base Type:'))

   290

        array_panel_leftSizer.AddWindow(array_basetype_label, 1, border=5, 

   291

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   292

   293

        self.ArrayBaseType = wx.ComboBox(self.ArrayPanel, style=wx.CB_READONLY)

   294

        self.Bind(wx.EVT_COMBOBOX, self.OnInfosChanged, self.ArrayBaseType)

   295

        array_panel_leftSizer.AddWindow(self.ArrayBaseType, 1, border=5, 

   296

              flag=wx.GROW|wx.ALL)

   297

   298

        array_panel_rightsizer = wx.BoxSizer(wx.HORIZONTAL)

   299

        array_panel_sizer.AddSizer(array_panel_rightsizer, flag=wx.GROW)

   300

   301

        array_initialvalue_label = wx.StaticText(self.ArrayPanel,

   302

              label=_('Initial Value:'))

   303

        array_panel_rightsizer.AddWindow(array_initialvalue_label, 1, border=5, 

   304

              flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL)

   305

   306

        self.ArrayInitialValue = wx.TextCtrl(self.ArrayPanel,

   307

              style=wx.TAB_TRAVERSAL|wx.TE_PROCESS_ENTER|wx.TE_RICH)

   308

        self.Bind(wx.EVT_TEXT_ENTER, self.OnReturnKeyPressed, self.ArrayInitialValue)

   309

        array_panel_rightsizer.AddWindow(self.ArrayInitialValue, 1, border=5, 

   310

              flag=wx.ALL)        

   311

   312

        self.ArrayDimensions = CustomEditableListBox(self.ArrayPanel, 

   313

              label=_("Dimensions:"), style=wx.gizmos.EL_ALLOW_NEW|

   314

                                            wx.gizmos.EL_ALLOW_EDIT|

   315

                                            wx.gizmos.EL_ALLOW_DELETE)

   316

        for func in ["_OnLabelEndEdit", "_OnAddButton", "_OnDelButton", 

   317

                     "_OnUpButton", "_OnDownButton"]:

   318

            setattr(self.ArrayDimensions, func, self.OnDimensionsChanged)

   319

        array_panel_sizer.AddWindow(self.ArrayDimensions, 0, border=5, 

   320

              flag=wx.GROW|wx.ALL)

   321

   322

        self.ArrayPanel.SetSizer(array_panel_sizer)

   323

   324

        # Panel for Structure data types

   325

   326

        self.StructurePanel = wx.Panel(self.Editor, style=wx.TAB_TRAVERSAL)

   327

        typeinfos_sizer.AddWindow(self.StructurePanel, 1)

   328

   329

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

   330

        structure_panel_sizer.AddGrowableCol(0)

   331

        structure_panel_sizer.AddGrowableRow(1)

   332

   333

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

   334

        structure_button_sizer.AddGrowableCol(0)

   335

        structure_button_sizer.AddGrowableRow(0)

   336

        structure_panel_sizer.AddSizer(structure_button_sizer, 0, border=5, 

   337

              flag=wx.ALL|wx.GROW)

   338

   339

        structure_elements_label = wx.StaticText(self.StructurePanel,

   340

              label=_('Elements :'))

   341

        structure_button_sizer.AddWindow(structure_elements_label, flag=wx.ALIGN_BOTTOM)

   342

   343

        for name, bitmap, help in [

   344

                ("StructureAddButton", "add_element", _("Add element")),

   345

                ("StructureDeleteButton", "remove_element", _("Remove element")),

   346

                ("StructureUpButton", "up", _("Move element up")),

   347

                ("StructureDownButton", "down", _("Move element down"))]:

   348

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

   349

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

   350

            button.SetToolTipString(help)

   351

            setattr(self, name, button)

   352

            structure_button_sizer.AddWindow(button)

   353

   354

        self.StructureElementsGrid = CustomGrid(self.StructurePanel, 

   355

              size=wx.Size(0, 150), style=wx.VSCROLL)

   356

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

   357

              self.OnStructureElementsGridCellChange)

   358

        self.StructureElementsGrid.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN, 

   359

              self.OnStructureElementsGridEditorShown)

   360

        structure_panel_sizer.AddWindow(self.StructureElementsGrid, flag=wx.GROW)

   361

   362

        self.StructurePanel.SetSizer(structure_panel_sizer)

   363

   364

        self.Editor.SetSizer(self.MainSizer)

   365

   366

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

   367

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

   368

   369

        self.StructureElementDefaultValue = {"Name" : "", "Type" : "INT", "Initial Value" : ""}

   370

        self.StructureElementsTable = ElementsTable(self, [], GetElementsTableColnames())

   371

        self.StructureColSizes = [40, 150, 100, 250]

   372

        self.StructureColAlignements = [wx.ALIGN_CENTER, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT]

   373

   374

        self.StructureElementsGrid.SetTable(self.StructureElementsTable)

   375

        self.StructureElementsGrid.SetButtons({"Add": self.StructureAddButton,

   376

                                               "Delete": self.StructureDeleteButton,

   377

                                               "Up": self.StructureUpButton,

   378

                                               "Down": self.StructureDownButton})

   379

   380

        def _AddStructureElement(new_row):

   381

            self.StructureElementsTable.InsertRow(new_row, self.StructureElementDefaultValue.copy())

   382

            self.RefreshTypeInfos()

   383

            self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   384

            return new_row

   385

        setattr(self.StructureElementsGrid, "_AddRow", _AddStructureElement)

   386

   387

        def _DeleteStructureElement(row):

   388

            self.StructureElementsTable.RemoveRow(row)

   389

            self.RefreshTypeInfos()

   390

            self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   391

        setattr(self.StructureElementsGrid, "_DeleteRow", _DeleteStructureElement)

   392

   393

        def _MoveStructureElement(row, move):

   394

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

   395

            if new_row != row:

   396

                self.RefreshTypeInfos()

   397

                self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   398

            return new_row

   399

        setattr(self.StructureElementsGrid, "_MoveRow", _MoveStructureElement)

   400

   401

        self.StructureElementsGrid.SetRowLabelSize(0)

   402

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

   403

            attr = wx.grid.GridCellAttr()

   404

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

   405

            self.StructureElementsGrid.SetColAttr(col, attr)

   406

            self.StructureElementsGrid.SetColMinimalWidth(col, self.StructureColSizes[col])

   407

            self.StructureElementsGrid.AutoSizeColumn(col, False)

   408

        self.StructureElementsGrid.RefreshButtons()

   409

   410

        for datatype in GetDatatypeTypes():

   411

            self.DerivationType.Append(_(datatype))

   412

        self.SubrangePanel.Hide()

   413

        self.EnumeratedPanel.Hide()

   414

        self.ArrayPanel.Hide()

   415

        self.StructurePanel.Hide()

   416

        self.CurrentPanel = "Directly"

   417

        self.Highlights = []

   418

        self.Initializing = False

   419

   420

        self.HighlightControls = {

   421

            ("Directly", "base"): self.DirectlyBaseType,

   422

            ("Directly", "initial"): self.DirectlyInitialValue,

   423

            ("Subrange", "base"): self.SubrangeBaseType,

   424

            ("Subrange", "lower"): self.SubrangeMinimum,

   425

            ("Subrange", "upper"): self.SubrangeMaximum,

   426

            ("Subrange", "initial"): self.SubrangeInitialValue,

   427

            ("Enumerated", "value"): self.EnumeratedValues,

   428

            ("Enumerated", "initial"): self.EnumeratedInitialValue,

   429

            ("Array", "initial"): self.ArrayInitialValue,

   430

            ("Array", "base"): self.ArrayBaseType,

   431

            ("Array", "range"): self.ArrayDimensions,

   432

        }

   433

   434

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

   435

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

   436

   437

    def __del__(self):

   438

        self.RefreshHighlightsTimer.Stop()

   439

   440

    def GetBufferState(self):

   441

        return self.Controler.GetBufferState()

   442

   443

    def Undo(self):

   444

        self.Controler.LoadPrevious()

   445

        self.ParentWindow.CloseTabsWithoutModel()

   446

   447

    def Redo(self):

   448

        self.Controler.LoadNext()

   449

        self.ParentWindow.CloseTabsWithoutModel()

   450

   451

    def HasNoModel(self):

   452

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

   453

   454

    def RefreshView(self):

   455

        self.Initializing = True

   456

        self.DirectlyBaseType.Clear()

   457

        self.ArrayBaseType.Clear()

   458

        for datatype in self.Controler.GetDataTypes(self.TagName):

   459

            self.DirectlyBaseType.Append(datatype)

   460

            self.ArrayBaseType.Append(datatype)

   461

        self.DirectlyBaseType.SetSelection(0)

   462

        self.SubrangeBaseType.Clear()

   463

        words = self.TagName.split("::")

   464

        for base_type in self.Controler.GetSubrangeBaseTypes(words[1]):

   465

            self.SubrangeBaseType.Append(base_type)

   466

        self.SubrangeBaseType.SetSelection(0)

   467

        self.RefreshBoundsRange()

   468

        type_infos = self.Controler.GetDataTypeInfos(self.TagName)

   469

        if type_infos is not None:

   470

            datatype = type_infos["type"]

   471

            self.DerivationType.SetStringSelection(_(datatype))

   472

            if type_infos["type"] == "Directly":

   473

                self.DirectlyBaseType.SetStringSelection(type_infos["base_type"])

   474

                self.DirectlyInitialValue.SetValue(type_infos["initial"])

   475

            elif type_infos["type"] == "Subrange":

   476

                self.SubrangeBaseType.SetStringSelection(type_infos["base_type"])

   477

                self.RefreshBoundsRange()

   478

                self.SubrangeMinimum.SetValue(int(type_infos["min"]))

   479

                self.SubrangeMaximum.SetValue(int(type_infos["max"]))

   480

                self.RefreshSubrangeInitialValueRange()

   481

                if type_infos["initial"] != "":

   482

                    self.SubrangeInitialValue.SetValue(int(type_infos["initial"]))

   483

                else:

   484

                    self.SubrangeInitialValue.SetValue(type_infos["min"])

   485

            elif type_infos["type"] == "Enumerated":

   486

                self.EnumeratedValues.SetStrings(type_infos["values"])

   487

                self.RefreshEnumeratedValues()

   488

                self.EnumeratedInitialValue.SetStringSelection(type_infos["initial"])

   489

            elif type_infos["type"] == "Array":

   490

                self.ArrayBaseType.SetStringSelection(type_infos["base_type"])

   491

                self.ArrayDimensions.SetStrings(map(lambda x : "..".join(x), type_infos["dimensions"]))

   492

                self.ArrayInitialValue.SetValue(type_infos["initial"])

   493

            elif type_infos["type"] == "Structure":

   494

                self.StructureElementsTable.SetData(type_infos["elements"])

   495

            self.RefreshDisplayedInfos()

   496

        self.ShowHighlights()