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): 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

#Lesser 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

from wxPython.wx import *

    26

import wx

    27

    28

from plcopen.structures import *

    29

from graphics.GraphicCommons import *

    30

from graphics.FBD_Objects import *

    31

from Viewer import *

    32

    33

class FBD_Viewer(Viewer):

    34

    35

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

    36

        Viewer.__init__(self, parent, window, controler)

    37

    38

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

    39

#                          Mouse event functions

    40

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

    41

    42

    def OnViewerLeftDown(self, event):

    43

        if self.Mode == MODE_SELECTION:

    44

            pos = event.GetPosition()

    45

            if event.ControlDown() and self.SelectedElement:

    46

                element = self.FindElement(pos, True)

    47

                if element:

    48

                    if isinstance(self.SelectedElement, Graphic_Group):

    49

                        self.SelectedElement.SetSelected(False)

    50

                        self.SelectedElement.SelectElement(element)

    51

                    elif self.SelectedElement:

    52

                        group = Graphic_Group(self)

    53

                        group.SelectElement(self.SelectedElement)

    54

                        group.SelectElement(element)

    55

                        self.SelectedElement = group

    56

                    elements = self.SelectedElement.GetElements()

    57

                    if len(elements) == 0:

    58

                        self.SelectedElement = element

    59

                    elif len(elements) == 1:

    60

                        self.SelectedElement = elements[0]

    61

                    self.SelectedElement.SetSelected(True)

    62

            else:

    63

                element = self.FindElement(pos)

    64

                if self.SelectedElement and self.SelectedElement != element:

    65

                    self.SelectedElement.SetSelected(False)

    66

                    self.SelectedElement = None

    67

                    self.Refresh()

    68

                if element:

    69

                    self.SelectedElement = element

    70

                    self.SelectedElement.OnLeftDown(event, self.Scaling)

    71

                    self.Refresh()

    72

                else:

    73

                    self.rubberBand.Reset()

    74

                    self.rubberBand.OnLeftDown(event, self.Scaling)

    75

        elif self.Mode in [MODE_BLOCK,MODE_VARIABLE,MODE_CONNECTION,MODE_COMMENT]:

    76

            self.rubberBand.Reset()

    77

            self.rubberBand.OnLeftDown(event, self.Scaling)

    78

        elif self.Mode == MODE_WIRE:

    79

            pos = GetScaledEventPosition(event, self.Scaling)

    80

            connector = self.FindBlockConnector(pos)

    81

            if connector:

    82

                if (connector.GetDirection() == EAST):

    83

                    wire = Wire(self, [wxPoint(pos.x, pos.y), EAST], [wxPoint(pos.x, pos.y), WEST])

    84

                else:

    85

                    wire = Wire(self, [wxPoint(pos.x, pos.y), WEST], [wxPoint(pos.x, pos.y), EAST])

    86

                wire.oldPos = pos

    87

                wire.Handle = (HANDLE_POINT, 0)

    88

                wire.ProcessDragging(0, 0)

    89

                wire.Handle = (HANDLE_POINT, 1)

    90

                self.Wires.append(wire)

    91

                self.Elements.append(wire)

    92

                if self.SelectedElement:

    93

                    self.SelectedElement.SetSelected(False)

    94

                self.SelectedElement = wire

    95

            elif self.SelectedElement:

    96

                self.SelectedElement.SetSelected(False)

    97

                self.SelectedElement = None

    98

            self.Refresh()

    99

        event.Skip()

   100

   101

    def OnViewerLeftUp(self, event):

   102

        if self.rubberBand.IsShown():

   103

            if self.Mode == MODE_SELECTION:

   104

                elements = self.SearchElements(self.rubberBand.GetCurrentExtent())

   105

                self.rubberBand.OnLeftUp(event, self.Scaling)

   106

                if len(elements) > 0:

   107

                    self.SelectedElement = Graphic_Group(self)

   108

                    self.SelectedElement.SetElements(elements)

   109

                    self.SelectedElement.SetSelected(True)

   110

                    self.Refresh()

   111

            elif self.Mode == MODE_BLOCK:

   112

                bbox = self.rubberBand.GetCurrentExtent()

   113

                self.rubberBand.OnLeftUp(event, self.Scaling)

   114

                wxCallAfter(self.AddNewBlock, bbox)

   115

            elif self.Mode == MODE_VARIABLE:

   116

                bbox = self.rubberBand.GetCurrentExtent()

   117

                self.rubberBand.OnLeftUp(event, self.Scaling)

   118

                wxCallAfter(self.AddNewVariable, bbox)

   119

            elif self.Mode == MODE_CONNECTION:

   120

                bbox = self.rubberBand.GetCurrentExtent()

   121

                self.rubberBand.OnLeftUp(event, self.Scaling)

   122

                wxCallAfter(self.AddNewConnection, bbox)

   123

            elif self.Mode == MODE_COMMENT:

   124

                bbox = self.rubberBand.GetCurrentExtent()

   125

                self.rubberBand.OnLeftUp(event, self.Scaling)

   126

                wxCallAfter(self.AddNewComment, bbox)

   127

        elif self.Mode == MODE_SELECTION and self.SelectedElement:

   128

            self.SelectedElement.OnLeftUp(event, self.Scaling)

   129

            wxCallAfter(self.SetCursor, wxNullCursor)

   130

            self.ReleaseMouse()

   131

            self.Refresh()

   132

        elif self.Mode == MODE_WIRE and self.SelectedElement:

   133

            pos = GetScaledEventPosition(event, self.Scaling)

   134

            connector = self.FindBlockConnector(pos, False)

   135

            if connector and connector != self.SelectedElement.StartConnected:

   136

                self.SelectedElement.ResetPoints()

   137

                self.SelectedElement.OnMotion(event, self.Scaling)

   138

                self.SelectedElement.GeneratePoints()

   139

                self.SelectedElement.RefreshModel()

   140

                self.SelectedElement.SetSelected(True)

   141

            else:

   142

                self.SelectedElement.Delete()

   143

                self.SelectedElement = None

   144

            self.Refresh()

   145

        if not self.SavedMode:

   146

            wxCallAfter(self.Parent.ResetCurrentMode)

   147

        event.Skip()

   148

   149

    def OnViewerRightUp(self, event):

   150

        pos = event.GetPosition()

   151

        element = self.FindElement(pos)

   152

        if element:

   153

            if self.SelectedElement and self.SelectedElement != element:

   154

                self.SelectedElement.SetSelected(False)

   155

            self.SelectedElement = element

   156

            self.SelectedElement.SetSelected(True)

   157

            self.SelectedElement.OnRightUp(event, self.Scaling)

   158

            wxCallAfter(self.SetCursor, wxNullCursor)

   159

            self.ReleaseMouse()

   160

            self.Refresh()

   161

        event.Skip()

   162

   163

    def OnViewerLeftDClick(self, event):

   164

        if self.Mode == MODE_SELECTION and self.SelectedElement:

   165

            self.SelectedElement.OnLeftDClick(event, self.Scaling)

   166

            self.Refresh()

   167

        event.Skip()

   168

   169

    def OnViewerMotion(self, event):

   170

        if self.rubberBand.IsShown():

   171

            self.rubberBand.OnMotion(event, self.Scaling)

   172

        elif self.Mode == MODE_SELECTION and self.SelectedElement:

   173

            self.SelectedElement.OnMotion(event, self.Scaling)

   174

            self.Refresh()

   175

        elif self.Mode == MODE_WIRE and self.SelectedElement:

   176

            pos = GetScaledEventPosition(event, self.Scaling)

   177

            connector = self.FindBlockConnector(pos, False)

   178

            if not connector or self.SelectedElement.EndConnected == None:

   179

                self.SelectedElement.ResetPoints()

   180

                self.SelectedElement.OnMotion(event, self.Scaling)

   181

                self.SelectedElement.GeneratePoints()

   182

                self.Refresh()

   183

        event.Skip()

   184

   185

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

   186

#                          Keyboard event functions

   187

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

   188

   189

    def OnChar(self, event):

   190

        keycode = event.GetKeyCode()

   191

        if self.Scaling:

   192

            scaling = self.Scaling

   193

        else:

   194

            scaling = (8, 8)

   195

        if keycode == WXK_DELETE and self.SelectedElement:

   196

            self.SelectedElement.Clean()

   197

            self.SelectedElement.Delete()

   198

            self.SelectedElement = None

   199

        elif keycode == WXK_LEFT and self.SelectedElement:

   200

            self.SelectedElement.Move(-scaling[0], 0)

   201

        elif keycode == WXK_RIGHT and self.SelectedElement:

   202

            self.SelectedElement.Move(scaling[0], 0)

   203

        elif keycode == WXK_UP and self.SelectedElement:

   204

            self.SelectedElement.Move(0, -scaling[1])

   205

        elif keycode == WXK_DOWN and self.SelectedElement:

   206

            self.SelectedElement.Move(0, scaling[1])

   207

        self.Refresh()

   208

        event.Skip()

   209

   210

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

   211

#                          Adding element functions

   212

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

   213

   214

    def AddNewBlock(self, bbox):

   215

        dialog = BlockPropertiesDialog(self.Parent)

   216

        dialog.SetBlockList(self.Controler.GetBlockTypes())

   217

        dialog.SetMinBlockSize((bbox.width, bbox.height))

   218

        if dialog.ShowModal() == wxID_OK:

   219

            id = self.GetNewId()

   220

            values = dialog.GetValues()

   221

            if "name" in values:

   222

                block = FBD_Block(self, values["type"], values["name"], id, values["extension"])

   223

            else:

   224

                block = FBD_Block(self, values["type"], "", id, values["extension"])

   225

            block.SetPosition(bbox.x, bbox.y)

   226

            block.SetSize(values["width"], values["height"])

   227

            self.Blocks.append(block)

   228

            self.Elements.append(block)

   229

            self.Controler.AddCurrentElementEditingBlock(id)

   230

            self.RefreshBlockModel(block)

   231

            self.Refresh()

   232

        dialog.Destroy()

   233

   234

    def AddNewVariable(self, bbox):

   235

        dialog = VariablePropertiesDialog(self.Parent)

   236

        dialog.SetMinVariableSize((bbox.width, bbox.height))

   237

        varlist = []

   238

        vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   239

        if vars:

   240

            for var in vars:

   241

                varlist.append((var["Name"], var["Class"], var["Type"]))

   242

        returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()

   243

        if returntype:

   244

            varlist.append((self.Controler.GetCurrentElementEditingName(), "Output", returntype))

   245

        dialog.SetVariables(varlist)

   246

        if dialog.ShowModal() == wxID_OK:

   247

            id = self.GetNewId()

   248

            values = dialog.GetValues()

   249

            variable = FBD_Variable(self, values["type"], values["name"], values["value_type"], id)

   250

            variable.SetPosition(bbox.x, bbox.y)

   251

            variable.SetSize(values["width"], values["height"])

   252

            self.Blocks.append(variable)

   253

            self.Elements.append(variable)

   254

            self.Controler.AddCurrentElementEditingVariable(id, values["type"])

   255

            self.RefreshVariableModel(variable)

   256

            self.Refresh()

   257

        dialog.Destroy()

   258

   259

    def AddNewConnection(self, bbox):

   260

        dialog = ConnectionPropertiesDialog(self.Parent)

   261

        dialog.SetMinConnectionSize((bbox.width, bbox.height))

   262

        if dialog.ShowModal() == wxID_OK:

   263

            id = self.GetNewId()

   264

            values = dialog.GetValues()

   265

            connection = FBD_Connection(self, values["type"], values["name"], id)

   266

            connection.SetPosition(bbox.x, bbox.y)

   267

            connection.SetSize(values["width"], values["height"])

   268

            self.Blocks.append(connection)

   269

            self.Elements.append(connection)

   270

            self.Controler.AddCurrentElementEditingConnection(id, values["type"])

   271

            self.RefreshConnectionModel(connection)

   272

            self.Refresh()

   273

        dialog.Destroy()

   274

   275

    def AddNewComment(self, bbox):

   276

        dialog = wxTextEntryDialog(self.Parent, "Add a new comment", "Please enter comment text", "", wxOK|wxCANCEL|wxTE_MULTILINE)

   277

        if dialog.ShowModal() == wxID_OK:

   278

            value = dialog.GetValue()

   279

            id = self.GetNewId()

   280

            comment = Comment(self, value, id)

   281

            comment.SetPosition(bbox.x, bbox.y)

   282

            min_width, min_height = comment.GetMinSize()

   283

            comment.SetSize(max(min_width,bbox.width),max(min_height,bbox.height))

   284

            self.Elements.append(comment)

   285

            self.Controler.AddCurrentElementEditingComment(id)

   286

            self.RefreshCommentModel(comment)

   287

            self.Refresh()

   288

        dialog.Destroy()

   289

   290

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

   291

#                          Delete element functions

   292

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

   293

   294

    def DeleteBlock(self, block):

   295

        wires = []

   296

        for output in block.GetConnectors()["outputs"]:

   297

            wires.extend([wire[0] for wire in output.GetWires()])

   298

        block.Clean()

   299

        self.Blocks.remove(block)

   300

        self.Elements.remove(block)

   301

        self.Controler.RemoveCurrentElementEditingInstance(block.GetId())

   302

        for wire in wires:

   303

            wire.RefreshModel()

   304

   305

    def DeleteVariable(self, variable):

   306

        wires = []

   307

        if variable.GetType() == INPUT:

   308

            connector = variable.GetConnector()

   309

            wires.extend([wire[0] for wire in connector.GetWires()])

   310

        variable.Clean()

   311

        self.Blocks.remove(variable)

   312

        self.Elements.remove(variable)

   313

        self.Controler.RemoveCurrentElementEditingInstance(variable.GetId())

   314

        for wire in wires:

   315

            wire.RefreshModel()

   316

   317

    def DeleteConnection(self, connection):

   318

        wires = []

   319

        if connection.GetType() == CONTINUATION:

   320

            connector = connection.GetConnector()

   321

            wires.extend([wire[0] for wire in connector.GetWires()])

   322

        connection.Clean()

   323

        self.Blocks.remove(connection)

   324

        self.Elements.remove(connection)

   325

        self.Controler.RemoveCurrentElementEditingInstance(connection.GetId())

   326

        for wire in wires:

   327

            wire.RefreshModel()

   328

   329

    def DeleteComment(self, comment):

   330

        self.Elements.remove(comment)

   331

        self.Controler.RemoveCurrentElementEditingInstance(comment.GetId())

   332

   333

    def DeleteWire(self, wire):

   334

        connected = wire.GetConnected()

   335

        wire.Clean()

   336

        self.Wires.remove(wire)

   337

        self.Elements.remove(wire)

   338

        for connector in connected:

   339

            connector.RefreshParentBlock()

   340

   341

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

   342

#                          Edit element content functions

   343

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

   344

   345

    def EditBlockContent(self, block):

   346

        dialog = BlockPropertiesDialog(self.Parent)

   347

        dialog.SetBlockList(self.Controler.GetBlockTypes())

   348

        dialog.SetMinBlockSize(block.GetSize())

   349

        values = {"name" : block.GetName(), "type" : block.GetType()}

   350

        values["extension"] = block.GetExtension()

   351

        dialog.SetValues(values)

   352

        if dialog.ShowModal() == wxID_OK:

   353

            values = dialog.GetValues()

   354

            if "name" in values:

   355

                block.SetName(values["name"])

   356

            block.SetExtension(values["extension"])

   357

            block.SetSize(values["width"], values["height"])

   358

            block.SetType(values["type"])

   359

            self.RefreshBlockModel(block)

   360

            self.Refresh()

   361

        dialog.Destroy()

   362

   363

    def EditVariableContent(self, variable):

   364

        dialog = VariablePropertiesDialog(self.Parent)

   365

        dialog.SetMinVariableSize(variable.GetSize())

   366

        varlist = []

   367

        vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   368

        if vars:

   369

            for var in vars:

   370

                varlist.append((var["Name"], var["Class"], var["Type"]))

   371

        returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()

   372

        if returntype:

   373

            varlist.append((self.Controler.GetCurrentElementEditingName(), "Output", returntype))

   374

        dialog.SetVariables(varlist)

   375

        values = {"name" : variable.GetName(), "type" : variable.GetType()}

   376

        dialog.SetValues(values)

   377

        if dialog.ShowModal() == wxID_OK:

   378

            old_type = variable.GetType()

   379

            values = dialog.GetValues()

   380

            variable.SetName(values["name"])

   381

            variable.SetType(values["type"], values["value_type"])

   382

            variable.SetSize(values["width"], values["height"])

   383

            if old_type != values["type"]:

   384

                id = variable.GetId()

   385

                self.Controler.RemoveCurrentElementEditingInstance(id)

   386

                self.Controler.AddCurrentElementEditingVariable(id, values["type"])

   387

            self.RefreshVariableModel(variable)

   388

            self.Refresh()

   389

        dialog.Destroy()

   390

   391

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

   392

#                          Create New Block Dialog

   393

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

   394

   395

[wxID_BLOCKPROPERTIESDIALOG, wxID_BLOCKPROPERTIESDIALOGMAINPANEL, 

   396

 wxID_BLOCKPROPERTIESDIALOGNAME, wxID_BLOCKPROPERTIESDIALOGTYPETREE, 

   397

 wxID_BLOCKPROPERTIESDIALOGTYPEDESC, wxID_BLOCKPROPERTIESDIALOGINPUTS, 

   398

 wxID_BLOCKPROPERTIESDIALOGPREVIEW, wxID_BLOCKPROPERTIESDIALOGSTATICTEXT1, 

   399

 wxID_BLOCKPROPERTIESDIALOGSTATICTEXT2, wxID_BLOCKPROPERTIESDIALOGSTATICTEXT3, 

   400

 wxID_BLOCKPROPERTIESDIALOGSTATICTEXT4, 

   401

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

   402

   403

class BlockPropertiesDialog(wx.Dialog):

   404

    def _init_coll_flexGridSizer1_Items(self, parent):

   405

        # generated method, don't edit

   406

   407

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

   408

   409

    def _init_sizers(self):

   410

        # generated method, don't edit

   411

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

   412

   413

        self._init_coll_flexGridSizer1_Items(self.flexGridSizer1)

   414

   415

        self.SetSizer(self.flexGridSizer1)

   416

   417

    def _init_ctrls(self, prnt):

   418

        # generated method, don't edit

   419

        wx.Dialog.__init__(self, id=wxID_BLOCKPROPERTIESDIALOG,

   420

              name='BlockPropertiesDialog', parent=prnt, pos=wx.Point(376, 223),

   421

              size=wx.Size(600, 360), style=wx.DEFAULT_DIALOG_STYLE,

   422

              title='Block Properties')

   423

        self.SetClientSize(wx.Size(600, 360))

   424

   425

        self.MainPanel = wx.Panel(id=wxID_BLOCKPROPERTIESDIALOGMAINPANEL,

   426

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

   427

              size=wx.Size(600, 320), style=wx.TAB_TRAVERSAL)

   428

        self.MainPanel.SetAutoLayout(True)

   429

   430

        self.staticbox1 = wx.StaticBox(id=wxID_BLOCKPROPERTIESDIALOGSTATICTEXT1,

   431

              label='Type:', name='staticBox1', parent=self.MainPanel,

   432

              pos=wx.Point(24, 24), size=wx.Size(245, 280), style=0)

   433

   434

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

   435

              label='Name:', name='staticText2', parent=self.MainPanel,

   436

              pos=wx.Point(274, 24), size=wx.Size(70, 17), style=0)

   437

   438

        self.staticText3 = wx.StaticText(id=wxID_BLOCKPROPERTIESDIALOGSTATICTEXT2,

   439

              label='Inputs:', name='staticText4', parent=self.MainPanel,

   440

              pos=wx.Point(424, 24), size=wx.Size(70, 17), style=0)

   441

   442

        self.staticText4 = wx.StaticText(id=wxID_BLOCKPROPERTIESDIALOGSTATICTEXT4,

   443

              label='Preview:', name='staticText4', parent=self.MainPanel,

   444

              pos=wx.Point(274, 80), size=wx.Size(100, 17), style=0)

   445

   446

        self.TypeTree = wx.TreeCtrl(id=wxID_BLOCKPROPERTIESDIALOGTYPETREE,

   447

              name='TypeTree', parent=self.MainPanel, pos=wx.Point(34, 44),

   448

              size=wx.Size(225, 180), style=wx.TR_HAS_BUTTONS|wx.TR_HIDE_ROOT|wx.TR_SINGLE|wx.SUNKEN_BORDER)

   449

        EVT_TREE_SEL_CHANGED(self, wxID_BLOCKPROPERTIESDIALOGTYPETREE, self.OnTypeTreeItemSelected)

   450

   451

        self.TypeDesc = wx.TextCtrl(id=wxID_BLOCKPROPERTIESDIALOGTYPEDESC,

   452

              name='TypeDesc', parent=self.MainPanel, pos=wx.Point(34, 230),

   453

              size=wx.Size(225, 65), style=wx.TE_READONLY|wx.TE_MULTILINE)

   454

   455

        self.Name = wx.TextCtrl(id=wxID_BLOCKPROPERTIESDIALOGNAME, value='',

   456

              name='Name', parent=self.MainPanel, pos=wx.Point(274, 48),

   457

              size=wx.Size(145, 24), style=0)

   458

        EVT_TEXT(self, wxID_BLOCKPROPERTIESDIALOGNAME, self.OnNameChanged)

   459

   460

        self.Inputs = wx.SpinCtrl(id=wxID_BLOCKPROPERTIESDIALOGINPUTS,

   461

              name='Inputs', parent=self.MainPanel, pos=wx.Point(424, 48),

   462

              size=wx.Size(145, 24), style=0, min=2, max=20)

   463

        EVT_SPINCTRL(self, wxID_BLOCKPROPERTIESDIALOGINPUTS, self.OnInputsChanged)

   464

   465

        self.Preview = wx.Panel(id=wxID_BLOCKPROPERTIESDIALOGPREVIEW,

   466

              name='Preview', parent=self.MainPanel, pos=wx.Point(274, 104),

   467

              size=wx.Size(300, 200), style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)

   468

        self.Preview.SetBackgroundColour(wxColour(255,255,255))

   469

   470

        self._init_sizers()

   471

   472

    def __init__(self, parent):

   473

        self._init_ctrls(parent)

   474

        self.ButtonSizer = self.CreateButtonSizer(wxOK|wxCANCEL|wxCENTRE)

   475

        self.flexGridSizer1.Add(self.ButtonSizer, 1, wxALIGN_RIGHT)

   476

        self.Name.SetValue("")

   477

        self.Name.Enable(False)

   478

        self.Inputs.Enable(False)

   479

        self.Block = None

   480

        self.MinBlockSize = None

   481

   482

        EVT_PAINT(self, self.OnPaint)

   483

        EVT_BUTTON(self, self.ButtonSizer.GetAffirmativeButton().GetId(), self.OnOK)

   484

   485

    def FindTreeItem(self, root, name):

   486

        if root.IsOk():

   487

            if self.TypeTree.GetItemText(root) == name:

   488

                return root

   489

            else:

   490

                item, root_cookie = self.TypeTree.GetFirstChild(root)

   491

                while item.IsOk():

   492

                    result = self.FindTreeItem(item, name)

   493

                    if result:

   494

                        return result

   495

                    item, root_cookie = self.TypeTree.GetNextChild(root, root_cookie)

   496

        return None

   497

   498

    def OnOK(self, event):

   499

        error = []

   500

        selected = self.TypeTree.GetSelection()

   501

        if not selected.IsOk() or self.TypeTree.GetItemParent(selected) == self.TypeTree.GetRootItem() or selected == self.TypeTree.GetRootItem():

   502

            message = wxMessageDialog(self, "Form isn't complete. Valid block type must be selected!", "Error", wxOK|wxICON_ERROR)

   503

            message.ShowModal()

   504

            message.Destroy()

   505

        elif self.Name.IsEnabled() and self.Name.GetValue() == "":

   506

            message = wxMessageDialog(self, "Form isn't complete. Name must be filled!", "Error", wxOK|wxICON_ERROR)

   507

            message.ShowModal()

   508

            message.Destroy()

   509

        else:

   510

            self.EndModal(wxID_OK)

   511

   512

    def SetBlockList(self, blocktypes):

   513

        root = self.TypeTree.AddRoot("")

   514

        for category in blocktypes:

   515

            category_item = self.TypeTree.AppendItem(root, category["name"])

   516

            for blocktype in category["list"]:

   517

                blocktype_item = self.TypeTree.AppendItem(category_item, blocktype["name"])

   518

   519

    def SetMinBlockSize(self, size):

   520

        self.MinBlockSize = size