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

import re

    27

from types import TupleType

    28

    29

import wx

    30

import wx.grid

    31

import wx.lib.buttons

    32

from plcopen.structures import IEC_KEYWORDS, TestIdentifier, DefaultType

    33

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD

    34

from controls import CustomEditableListBox, CustomGrid, CustomTable, CustomIntCtrl

    35

from dialogs import ArrayTypeDialog

    36

from EditorPanel import EditorPanel

    37

from util.BitmapLibrary import GetBitmap

    38

from util.TranslationCatalogs import NoTranslate

    39

    40

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

    41

#                                    Helpers

    42

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

    43

    44

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

    45

    46

    47

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

    48

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

    49

    50

    51

def GetElementsTableColnames():

    52

    _ = NoTranslate

    53

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

    54

    55

    56

def GetDatatypeTypes():

    57

    _ = NoTranslate

    58

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

    59

    60

    61

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

    62

#                            Structure Elements Table

    63

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

    64

    65

    66

class ElementsTable(CustomTable):

    67

    68

    """

    69

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

    70

    """

    71

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

    72

        # The base class must be initialized *first*

    73

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

    74

        self.old_value = None

    75

    76

    def GetValue(self, row, col):

    77

        if row < self.GetNumberRows():

    78

            if col == 0:

    79

                return row + 1

    80

            colname = self.GetColLabelValue(col, False)

    81

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

    82

    83

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

    84

                if value[0] == "array":

    85

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

    86

            return value

    87

    88

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

    89

        if col < len(self.colnames):

    90

            colname = self.GetColLabelValue(col, False)

    91

            if colname == "Name":

    92

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

    93

            self.data[row][colname] = value

    94

    95

    def GetOldValue(self):

    96

        return self.old_value

    97

    98

    def _updateColAttrs(self, grid):

    99

        """

   100

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

   101

        appropriate renderer given the column name.

   102

   103

        Otherwise default to the default renderer.

   104

        """

   105

   106

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

   107

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

   108

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

   109

                editor = None

   110

                renderer = None

   111

                colname = self.GetColLabelValue(col, False)

   112

                if col != 0:

   113

                    grid.SetReadOnly(row, col, False)

   114

                    if colname == "Name":

   115

                        editor = wx.grid.GridCellTextEditor()

   116

                        renderer = wx.grid.GridCellStringRenderer()

   117

                    elif colname == "Initial Value":

   118

                        editor = wx.grid.GridCellTextEditor()

   119

                        renderer = wx.grid.GridCellStringRenderer()

   120

                    elif colname == "Type":

   121

                        editor = wx.grid.GridCellTextEditor()

   122

                else:

   123

                    grid.SetReadOnly(row, col, True)

   124

   125

                grid.SetCellEditor(row, col, editor)

   126

                grid.SetCellRenderer(row, col, renderer)

   127

   128

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

   129

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

   130

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

   131

            self.ResizeRow(grid, row)

   132

   133

    def AddHighlight(self, infos, highlight_type):

   134

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

   135

        if infos[1] == "initial":

   136

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

   137

        else:

   138

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

   139

        col_highlights.append(highlight_type)

   140

   141

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

   142

#                          Datatype Editor class

   143

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

   144

   145

   146

class DataTypeEditor(EditorPanel):

   147

   148

    def _init_Editor(self, parent):

   149

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

   150

   151

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

   152

        self.MainSizer.AddGrowableCol(0)

   153

        self.MainSizer.AddGrowableRow(1)

   154

   155

        top_sizer = wx.BoxSizer(wx.HORIZONTAL)

   156

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

   157

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

   158

   159

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

   160

        top_sizer.AddWindow(derivation_type_label, border=5,

   161

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

   162

   163

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

   164

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

   165

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

   166

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

   167

   168

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

   169

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

   170

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

   171

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

   172

   173

        # Panel for Directly derived data types

   174

   175

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

   176

        typeinfos_sizer.AddWindow(self.DirectlyPanel, 1)

   177

   178

        directly_panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

   179

   180

        directly_basetype_label = wx.StaticText(self.DirectlyPanel,

   181

                                                label=_('Base Type:'))

   182

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

   183

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   184

   185

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

   186

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

   187

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

   188

                                       flag=wx.GROW | wx.ALL)

   189

   190

        directly_initialvalue_label = wx.StaticText(self.DirectlyPanel,

   191

                                                    label=_('Initial Value:'))

   192

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

   193

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   194

   195

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

   196

                                                style=wx.TE_PROCESS_ENTER | wx.TE_RICH)

   197

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

   198

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

   199

                                       flag=wx.ALL)

   200

   201

        self.DirectlyPanel.SetSizer(directly_panel_sizer)

   202

   203

        # Panel for Subrange data types

   204

   205

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

   206

        typeinfos_sizer.AddWindow(self.SubrangePanel, 1)

   207

   208

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

   209

   210

        subrange_basetype_label = wx.StaticText(self.SubrangePanel,

   211

                                                label=_('Base Type:'))

   212

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

   213

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   214

   215

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

   216

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

   217

                  self.SubrangeBaseType)

   218

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

   219

                                       flag=wx.GROW | wx.ALL)

   220

   221

        subrange_initialvalue_label = wx.StaticText(self.SubrangePanel,

   222

                                                    label=_('Initial Value:'))

   223

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

   224

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   225

   226

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

   227

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

   228

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

   229

                                       flag=wx.GROW | wx.ALL)

   230

   231

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

   232

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

   233

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   234

   235

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

   236

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

   237

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

   238

                                       flag=wx.GROW | wx.ALL)

   239

   241

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

   242

   243

        subrange_maximum_label = wx.StaticText(self.SubrangePanel,

   244

                                               label=_('Maximum:'))

   245

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

   246

                                       flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   247

   248

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

   249

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

   250

   251

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

   252

                                       flag=wx.GROW | wx.ALL)

   253

   254

        self.SubrangePanel.SetSizer(subrange_panel_sizer)

   255

   256

        # Panel for Enumerated data types

   257

   258

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

   259

        typeinfos_sizer.AddWindow(self.EnumeratedPanel, 1)

   260

   261

        enumerated_panel_sizer = wx.BoxSizer(wx.HORIZONTAL)

   262

   263

        self.EnumeratedValues = CustomEditableListBox(

   264

                self.EnumeratedPanel,

   265

                label=_("Values:"),

   266

                style=(wx.gizmos.EL_ALLOW_NEW |

   267

                       wx.gizmos.EL_ALLOW_EDIT |

   268

                       wx.gizmos.EL_ALLOW_DELETE))

   269

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

   270

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

   271

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

   272

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

   273

                                         flag=wx.GROW | wx.ALL)

   274

   275

        enumerated_panel_rightsizer = wx.BoxSizer(wx.HORIZONTAL)

   276

        enumerated_panel_sizer.AddSizer(enumerated_panel_rightsizer, 1)

   277

   278

        enumerated_initialvalue_label = wx.StaticText(self.EnumeratedPanel,

   279

                                                      label=_('Initial Value:'))

   280

        enumerated_panel_rightsizer.AddWindow(enumerated_initialvalue_label, 1,

   281

                                              border=5,

   282

                                              flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   283

   284

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

   285

                                                  style=wx.CB_READONLY)

   286

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

   287

        enumerated_panel_rightsizer.AddWindow(self.EnumeratedInitialValue, 1,

   288

                                              border=5, flag=wx.ALL)

   289

   290

        self.EnumeratedPanel.SetSizer(enumerated_panel_sizer)

   291

   292

        # Panel for Array data types

   293

   294

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

   295

        typeinfos_sizer.AddWindow(self.ArrayPanel, 1)

   296

   297

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

   298

        array_panel_sizer.AddGrowableCol(0)

   299

        array_panel_sizer.AddGrowableCol(1)

   300

        array_panel_sizer.AddGrowableRow(1)

   301

   302

        array_panel_leftSizer = wx.BoxSizer(wx.HORIZONTAL)

   303

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

   304

   305

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

   306

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

   307

                                        flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   308

   309

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

   310

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

   311

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

   312

                                        flag=wx.GROW | wx.ALL)

   313

   314

        array_panel_rightsizer = wx.BoxSizer(wx.HORIZONTAL)

   315

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

   316

   317

        array_initialvalue_label = wx.StaticText(self.ArrayPanel,

   318

                                                 label=_('Initial Value:'))

   319

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

   320

                                         flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL)

   321

   322

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

   323

                                             style=wx.TE_PROCESS_ENTER | wx.TE_RICH)

   324

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

   325

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

   326

                                         flag=wx.ALL)

   327

   328

        self.ArrayDimensions = CustomEditableListBox(

   329

                self.ArrayPanel,

   330

                label=_("Dimensions:"),

   331

                style=(wx.gizmos.EL_ALLOW_NEW |

   332

                       wx.gizmos.EL_ALLOW_EDIT |

   333

                       wx.gizmos.EL_ALLOW_DELETE))

   334

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

   335

                     "_OnUpButton", "_OnDownButton"]:

   336

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

   337

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

   338

                                    flag=wx.GROW | wx.ALL)

   339

   340

        self.ArrayPanel.SetSizer(array_panel_sizer)

   341

   342

        # Panel for Structure data types

   343

   344

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

   345

        typeinfos_sizer.AddWindow(self.StructurePanel, 1)

   346

   347

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

   348

        structure_panel_sizer.AddGrowableCol(0)

   349

        structure_panel_sizer.AddGrowableRow(1)

   350

   351

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

   352

        structure_button_sizer.AddGrowableCol(0)

   353

        structure_button_sizer.AddGrowableRow(0)

   354

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

   355

                                       flag=wx.ALL | wx.GROW)

   356

   357

        structure_elements_label = wx.StaticText(self.StructurePanel,

   358

                                                 label=_('Elements :'))

   359

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

   360

   361

        for name, bitmap, help in [

   362

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

   363

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

   364

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

   365

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

   366

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

   367

                                                    bitmap=GetBitmap(bitmap),

   368

                                                    size=wx.Size(28, 28),

   369

                                                    style=wx.NO_BORDER)

   370

            button.SetToolTipString(help)

   371

            setattr(self, name, button)

   372

            structure_button_sizer.AddWindow(button)

   373

   374

        self.StructureElementsGrid = CustomGrid(self.StructurePanel,

   375

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

   376

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

   377

                                        self.OnStructureElementsGridCellChange)

   378

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

   379

                                        self.OnStructureElementsGridEditorShown)

   380

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

   381

   382

        self.StructurePanel.SetSizer(structure_panel_sizer)

   383

   384

        self.Editor.SetSizer(self.MainSizer)

   385

   386

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

   387

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

   388

   389

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

   390

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

   391

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

   392

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

   393

   394

        self.StructureElementsGrid.SetTable(self.StructureElementsTable)

   395

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

   396

                                               "Delete": self.StructureDeleteButton,

   397

                                               "Up": self.StructureUpButton,

   398

                                               "Down": self.StructureDownButton})

   399

   400

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

   401

   402

        def _AddStructureElement(new_row):

   403

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

   404

            self.RefreshTypeInfos()

   405

            self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   406

            return new_row

   407

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

   408

   409

        def _DeleteStructureElement(row):

   410

            self.StructureElementsTable.RemoveRow(row)

   411

            self.RefreshTypeInfos()

   412

            self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   413

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

   414

   415

        def _MoveStructureElement(row, move):

   416

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

   417

            if new_row != row:

   418

                self.RefreshTypeInfos()

   419

                self.StructureElementsTable.ResetView(self.StructureElementsGrid)

   420

            return new_row

   421

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

   422

   423

        self.StructureElementsGrid.SetRowLabelSize(0)

   424

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

   425

            attr = wx.grid.GridCellAttr()

   426

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

   427

            self.StructureElementsGrid.SetColAttr(col, attr)

   428

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

   429

            self.StructureElementsGrid.AutoSizeColumn(col, False)

   430

        self.StructureElementsGrid.RefreshButtons()

   431

   432

        for datatype in GetDatatypeTypes():

   433

            self.DerivationType.Append(_(datatype))

   434

        self.SubrangePanel.Hide()

   435

        self.EnumeratedPanel.Hide()

   436

        self.ArrayPanel.Hide()

   437

        self.StructurePanel.Hide()

   438

        self.CurrentPanel = "Directly"

   439

        self.Highlights = []

   440

        self.Initializing = False

   441

   442

        self.HighlightControls = {

   443

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

   444

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

   445

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

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

        }

   455

   456

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

   457

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

   458

   459

    def __del__(self):

   460

        self.RefreshHighlightsTimer.Stop()

   461

   462

    def GetBufferState(self):

   463

        return self.Controler.GetBufferState()

   464

   465

    def Undo(self):

   466

        self.Controler.LoadPrevious()

   467

        self.ParentWindow.CloseTabsWithoutModel()

   468

   469

    def Redo(self):

   470

        self.Controler.LoadNext()

   471

        self.ParentWindow.CloseTabsWithoutModel()

   472

   473

    def HasNoModel(self):

   474

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

   475

   476

    def RefreshView(self):

   477

        self.Initializing = True

   478

        self.DirectlyBaseType.Clear()

   479

        self.ArrayBaseType.Clear()

   480

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

   481

            self.DirectlyBaseType.Append(datatype)

   482

            self.ArrayBaseType.Append(datatype)

   483

        self.DirectlyBaseType.SetSelection(0)

   484

        self.SubrangeBaseType.Clear()

   485

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

   486

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

   487

            self.SubrangeBaseType.Append(base_type)

   488

        self.SubrangeBaseType.SetSelection(0)

   489

        self.RefreshBoundsRange()

   490

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

   491

        if type_infos is not None:

   492

            datatype = type_infos["type"]

   493

            self.DerivationType.SetStringSelection(_(datatype))

   494

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

   495

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