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

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

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

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

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

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

from __future__ import absolute_import

    28

import re

    29

from six.moves import xrange

    30

    31

import wx

    32

import wx.grid

    33

import wx.lib.buttons

    34

from plcopen.structures import IEC_KEYWORDS, TestIdentifier, DefaultType

    35

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD

    36

from controls import CustomEditableListBox, CustomGrid, CustomTable, CustomIntCtrl

    37

from dialogs import ArrayTypeDialog

    38

from editors.EditorPanel import EditorPanel

    39

from util.BitmapLibrary import GetBitmap

    40

from util.TranslationCatalogs import NoTranslate

    41

    42

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

    43

#                                    Helpers

    44

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

    45

    46

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

    47

    48

    49

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

    50

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

    51

    52

    53

def GetElementsTableColnames():

    54

    _ = NoTranslate

    55

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

    56

    57

    58

def GetDatatypeTypes():

    59

    _ = NoTranslate

    60

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

    61

    62

    63

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

    64

#                            Structure Elements Table

    65

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

    66

    67

    68

class ElementsTable(CustomTable):

    69

    70

    """

    71

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

    72

    """

    73

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

    74

        # The base class must be initialized *first*

    75

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

    76

        self.old_value = None

    77

    78

    def GetValue(self, row, col):

    79

        if row < self.GetNumberRows():

    80

            if col == 0:

    81

                return row + 1

    82

            colname = self.GetColLabelValue(col, False)

    83

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

    84

    85

            if colname == "Type" and isinstance(value, tuple):

    86

                if value[0] == "array":

    87

                    return "ARRAY [%s] OF %s" % (",".join(map("..".join, value[2])), value[1])

    88

            return value

    89

    90

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

    91

        if col < len(self.colnames):

    92

            colname = self.GetColLabelValue(col, False)

    93

            if colname == "Name":

    94

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

    95

            self.data[row][colname] = value

    96

    97

    def GetOldValue(self):

    98

        return self.old_value

    99

   100

    def _updateColAttrs(self, grid):

   101

        """

   102

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

   103

        appropriate renderer given the column name.

   104

   105

        Otherwise default to the default renderer.

   106

        """

   107

   108

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

   109

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

   110

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

   111

                editor = None

   112

                renderer = None

   113

                colname = self.GetColLabelValue(col, False)

   114

                if col != 0:

   115

                    grid.SetReadOnly(row, col, False)

   116

                    if colname == "Name":

   117

                        editor = wx.grid.GridCellTextEditor()

   118

                        renderer = wx.grid.GridCellStringRenderer()

   119

                    elif colname == "Initial Value":

   120

                        editor = wx.grid.GridCellTextEditor()

   121

                        renderer = wx.grid.GridCellStringRenderer()

   122

                    elif colname == "Type":

   123

                        editor = wx.grid.GridCellTextEditor()

   124

                else:

   125

                    grid.SetReadOnly(row, col, True)

   126

   127

                grid.SetCellEditor(row, col, editor)

   128

                grid.SetCellRenderer(row, col, renderer)

   129

   130

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

   131

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

   132

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

   133

            self.ResizeRow(grid, row)

   134

   135

    def AddHighlight(self, infos, highlight_type):

   136

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

   137

        if infos[1] == "initial":

   138

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

   139

        else:

   140

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

   141

        col_highlights.append(highlight_type)

   142

   143

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

   144

#                          Datatype Editor class

   145

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

   146

   147

   148

class DataTypeEditor(EditorPanel):

   149

   150

    def _init_Editor(self, parent):

   151

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

   152

   153

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

   154

        self.MainSizer.AddGrowableCol(0)

   155

        self.MainSizer.AddGrowableRow(1)

   156

   157

        top_sizer = wx.BoxSizer(wx.HORIZONTAL)

   158

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

   159

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

   160

   161

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

   162

        top_sizer.AddWindow(derivation_type_label, border=5,

   163

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

   164

   165

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

   166

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

   167

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

   168

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

   169

   170

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

   171

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

   172

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

   173

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

   174

   175

        # Panel for Directly derived data types

   176

   177

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

   178

        typeinfos_sizer.AddWindow(self.DirectlyPanel, 1)

   179

   180

        directly_panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

   181

   182

        directly_basetype_label = wx.StaticText(self.DirectlyPanel,

   183

                                                label=_('Base Type:'))

   184

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

   185

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   186

   187

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

   188

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

   189

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

   190

                                       flag=wx.GROW | wx.ALL)

   191

   192

        directly_initialvalue_label = wx.StaticText(self.DirectlyPanel,

   193

                                                    label=_('Initial Value:'))

   194

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

   195

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   196

   197

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

   198

                                                style=wx.TE_PROCESS_ENTER | wx.TE_RICH)

   199

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

   200

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

   201

                                       flag=wx.ALL)

   202

   203

        self.DirectlyPanel.SetSizer(directly_panel_sizer)

   204

   205

        # Panel for Subrange data types

   206

   207

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

   208

        typeinfos_sizer.AddWindow(self.SubrangePanel, 1)

   209

   210

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

   211

   212

        subrange_basetype_label = wx.StaticText(self.SubrangePanel,

   213

                                                label=_('Base Type:'))

   214

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

   215

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   216

   217

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

   218

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

   219

                  self.SubrangeBaseType)

   220

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

   221

                                       flag=wx.GROW | wx.ALL)

   222

   223

        subrange_initialvalue_label = wx.StaticText(self.SubrangePanel,

   224

                                                    label=_('Initial Value:'))

   225

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

   226

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   227

   228

        self.SubrangeInitialValue = CustomIntCtrl(self.SubrangePanel, style=wx.TAB_TRAVERSAL)

   229

        self.SubrangeInitialValue.Bind(CustomIntCtrl.EVT_CUSTOM_INT, self.OnInfosChanged)

   230

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

   231

                                       flag=wx.GROW | wx.ALL)

   232

   233

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

   234

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

   235

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   236

   237

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

   238

        self.SubrangeMinimum.Bind(CustomIntCtrl.EVT_CUSTOM_INT, self.OnSubrangeMinimumChanged)

   239

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

   240

                                       flag=wx.GROW | wx.ALL)

   241

   242

        for dummy in xrange(2):

   243

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

   244

   245

        subrange_maximum_label = wx.StaticText(self.SubrangePanel,

   246

                                               label=_('Maximum:'))

   247

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

   248

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   249

   250

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

   251

        self.SubrangeMaximum.Bind(CustomIntCtrl.EVT_CUSTOM_INT, self.OnSubrangeMaximumChanged)

   252

   253

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

   254

                                       flag=wx.GROW | wx.ALL)

   255

   256

        self.SubrangePanel.SetSizer(subrange_panel_sizer)

   257

   258

        # Panel for Enumerated data types

   259

   260

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

   261

        typeinfos_sizer.AddWindow(self.EnumeratedPanel, 1)

   262

   263

        enumerated_panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

   264

   265

        self.EnumeratedValues = CustomEditableListBox(

   266

            self.EnumeratedPanel,

   267

            label=_("Values:"),

   268

            style=(wx.gizmos.EL_ALLOW_NEW |

   269

                   wx.gizmos.EL_ALLOW_EDIT |

   270

                   wx.gizmos.EL_ALLOW_DELETE))

   271

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

   272

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

   273

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

   274

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

   275

                                         flag=wx.GROW | wx.ALL)

   276

   277

        enumerated_panel_rightsizer = wx.BoxSizer(wx.HORIZONTAL)

   278

        enumerated_panel_sizer.AddSizer(enumerated_panel_rightsizer, 1)

   279

   280

        enumerated_initialvalue_label = wx.StaticText(self.EnumeratedPanel,

   281

                                                      label=_('Initial Value:'))

   282

        enumerated_panel_rightsizer.AddWindow(enumerated_initialvalue_label, 1,

   283

                                              border=5,

   284

                                              flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   285

   286

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

   287

                                                  style=wx.CB_READONLY)

   288

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

   289

        enumerated_panel_rightsizer.AddWindow(self.EnumeratedInitialValue, 1,

   290

                                              border=5, flag=wx.ALL)

   291

   292

        self.EnumeratedPanel.SetSizer(enumerated_panel_sizer)

   293

   294

        # Panel for Array data types

   295

   296

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

   297

        typeinfos_sizer.AddWindow(self.ArrayPanel, 1)

   298

   299

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

   300

        array_panel_sizer.AddGrowableCol(0)

   301

        array_panel_sizer.AddGrowableCol(1)

   302

        array_panel_sizer.AddGrowableRow(1)

   303

   304

        array_panel_leftSizer = wx.BoxSizer(wx.HORIZONTAL)

   305

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

   306

   307

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

   308

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

   309

                                        flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   310

   311

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

   312

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

   313

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

   314

                                        flag=wx.GROW | wx.ALL)

   315

   316

        array_panel_rightsizer = wx.BoxSizer(wx.HORIZONTAL)

   317

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

   318

   319

        array_initialvalue_label = wx.StaticText(self.ArrayPanel,

   320

                                                 label=_('Initial Value:'))

   321

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

   322

                                         flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   323

   324

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

   325

                                             style=wx.TE_PROCESS_ENTER | wx.TE_RICH)

   326

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

   327

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

   328

                                         flag=wx.ALL)

   329

   330

        self.ArrayDimensions = CustomEditableListBox(

   331

            self.ArrayPanel,

   332

            label=_("Dimensions:"),

   333

            style=(wx.gizmos.EL_ALLOW_NEW |

   334

                   wx.gizmos.EL_ALLOW_EDIT |

   335

                   wx.gizmos.EL_ALLOW_DELETE))

   336

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

   337

                     "_OnUpButton", "_OnDownButton"]:

   338

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

   339

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

   340

                                    flag=wx.GROW | wx.ALL)

   341

   342

        self.ArrayPanel.SetSizer(array_panel_sizer)

   343

   344

        # Panel for Structure data types

   345

   346

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

   347

        typeinfos_sizer.AddWindow(self.StructurePanel, 1)

   348

   349

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

   350

        structure_panel_sizer.AddGrowableCol(0)

   351

        structure_panel_sizer.AddGrowableRow(1)

   352

   353

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

   354

        structure_button_sizer.AddGrowableCol(0)

   355

        structure_button_sizer.AddGrowableRow(0)

   356

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

   357

                                       flag=wx.ALL | wx.GROW)

   358

   359

        structure_elements_label = wx.StaticText(self.StructurePanel,

   360

                                                 label=_('Elements :'))

   361

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

   362

   363

        for name, bitmap, help in [

   364

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

   365

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

   366

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

   367

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

   368

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

   369

                                                    bitmap=GetBitmap(bitmap),

   370

                                                    size=wx.Size(28, 28),

   371

                                                    style=wx.NO_BORDER)

   372

            button.SetToolTipString(help)

   373

            setattr(self, name, button)

   374

            structure_button_sizer.AddWindow(button)

   375

   376

        self.StructureElementsGrid = CustomGrid(self.StructurePanel,

   377

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

   378

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

   379

                                        self.OnStructureElementsGridCellChange)

   380

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

   381

                                        self.OnStructureElementsGridEditorShown)

   382

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

   383

   384

        self.StructurePanel.SetSizer(structure_panel_sizer)

   385

   386

        self.Editor.SetSizer(self.MainSizer)

   387

   388

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

   389

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

   390

   391

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

   392

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

   393

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

   394

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

   395

   396

        self.StructureElementsGrid.SetTable(self.StructureElementsTable)

   397

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

   398

                                               "Delete": self.StructureDeleteButton,

   399

                                               "Up": self.StructureUpButton,

   400

                                               "Down": self.StructureDownButton})

   401

   402

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

   403

   404

        def _AddStructureElement(new_row):

   405

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

   406

            self.RefreshTypeInfos()

   407

            self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   408

            return new_row

   409

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

   410

   411

        def _DeleteStructureElement(row):

   412

            self.StructureElementsTable.RemoveRow(row)

   413

            self.RefreshTypeInfos()

   414

            self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   415

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

   416

   417

        def _MoveStructureElement(row, move):

   418

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

   419

            if new_row != row:

   420

                self.RefreshTypeInfos()

   421

                self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   422

            return new_row

   423

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

   424

   425

        self.StructureElementsGrid.SetRowLabelSize(0)

   426

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

   427

            attr = wx.grid.GridCellAttr()

   428

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

   429

            self.StructureElementsGrid.SetColAttr(col, attr)

   430

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

   431

            self.StructureElementsGrid.AutoSizeColumn(col, False)

   432

        self.StructureElementsGrid.RefreshButtons()

   433

   434

        for datatype in GetDatatypeTypes():

   435

            self.DerivationType.Append(_(datatype))

   436

        self.SubrangePanel.Hide()

   437

        self.EnumeratedPanel.Hide()

   438

        self.ArrayPanel.Hide()

   439

        self.StructurePanel.Hide()

   440

        self.CurrentPanel = "Directly"

   441

        self.Highlights = []

   442

        self.Initializing = False

   443

   444

        self.HighlightControls = {

   445

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

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

        }

   457

   458

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

   459

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

   460

   461

    def __del__(self):

   462

        self.RefreshHighlightsTimer.Stop()

   463

   464

    def GetBufferState(self):

   465

        return self.Controler.GetBufferState()

   466

   467

    def Undo(self):

   468

        self.Controler.LoadPrevious()

   469

        self.ParentWindow.CloseTabsWithoutModel()

   470

   471

    def Redo(self):

   472

        self.Controler.LoadNext()

   473

        self.ParentWindow.CloseTabsWithoutModel()

   474

   475

    def HasNoModel(self):

   476

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

   477

   478

    def RefreshView(self):

   479

        self.Initializing = True

   480

        self.DirectlyBaseType.Clear()

   481

        self.ArrayBaseType.Clear()

   482

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

   483

            self.DirectlyBaseType.Append(datatype)

   484

            self.ArrayBaseType.Append(datatype)

   485

        self.DirectlyBaseType.SetSelection(0)

   486

        self.SubrangeBaseType.Clear()

   487

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

   488

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

   489

            self.SubrangeBaseType.Append(base_type)

   490

        self.SubrangeBaseType.SetSelection(0)

   491

        self.RefreshBoundsRange()

   492

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

   493

        if type_infos is not None:

   494

            datatype = type_infos["type"]

   495

            self.DerivationType.SetStringSelection(_(datatype))