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

from wxPython.stc import * 

    27

from wxPython.grid import *

    28

import wx

    29

    30

from plcopen.structures import *

    31

from graphics.GraphicCommons import *

    32

from graphics.SFC_Objects import *

    33

from graphics.FBD_Objects import *

    34

from graphics.LD_Objects import *

    35

    36

import re

    37

    38

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

    39

#                       Graphic elements Viewer base class

    40

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

    41

    42

# ID Constants for menu items

    43

[wxID_FBDVIEWERCONTEXTUALMENUITEMS0, wxID_FBDVIEWERCONTEXTUALMENUITEMS1,

    44

 wxID_FBDVIEWERCONTEXTUALMENUITEMS2, wxID_FBDVIEWERCONTEXTUALMENUITEMS3,

    45

 wxID_FBDVIEWERCONTEXTUALMENUITEMS5, wxID_FBDVIEWERCONTEXTUALMENUITEMS6,

    46

 wxID_FBDVIEWERCONTEXTUALMENUITEMS8, wxID_FBDVIEWERCONTEXTUALMENUITEMS9,

    47

 wxID_FBDVIEWERCONTEXTUALMENUITEMS11,

    48

] = [wx.NewId() for _init_coll_ContextualMenu_Items in range(9)]

    49

    50

    51

"""

    52

Class that implements a Viewer based on a wxScrolledWindow for drawing and 

    53

manipulating graphic elements

    54

"""

    55

    56

class Viewer(wx.ScrolledWindow):

    57

    58

    # Create Contextual Menu items

    59

    def _init_coll_ContextualMenu_Items(self, parent):

    60

        # Create menu items

    61

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS0,

    62

              kind=wx.ITEM_RADIO, text=u'No Modifier')

    63

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS1,

    64

              kind=wx.ITEM_RADIO, text=u'Negated')

    65

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS2,

    66

              kind=wx.ITEM_RADIO, text=u'Rising Edge')

    67

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS3,

    68

              kind=wx.ITEM_RADIO, text=u'Falling Edge')

    69

        parent.AppendSeparator()

    70

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS5,

    71

              kind=wx.ITEM_NORMAL, text=u'Add Wire Segment')

    72

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS6,

    73

              kind=wx.ITEM_NORMAL, text=u'Delete Wire Segment')

    74

        parent.AppendSeparator()

    75

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS8,

    76

              kind=wx.ITEM_NORMAL, text=u'Add Divergence Branch')

    77

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS9,

    78

              kind=wx.ITEM_NORMAL, text=u'Delete Divergence Branch')

    79

        parent.AppendSeparator()

    80

        parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS11,

    81

              kind=wx.ITEM_NORMAL, text=u'Delete')

    82

        # Link menu event to corresponding called functions

    83

        self.Bind(wx.EVT_MENU, self.OnNoModifierMenu,

    84

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS0)

    85

        self.Bind(wx.EVT_MENU, self.OnNegatedMenu,

    86

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS1)

    87

        self.Bind(wx.EVT_MENU, self.OnRisingEdgeMenu,

    88

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS2)

    89

        self.Bind(wx.EVT_MENU, self.OnFallingEdgeMenu,

    90

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS3)

    91

        self.Bind(wx.EVT_MENU, self.OnAddSegmentMenu,

    92

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS5)

    93

        self.Bind(wx.EVT_MENU, self.OnDeleteSegmentMenu,

    94

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS6)

    95

        self.Bind(wx.EVT_MENU, self.OnAddBranchMenu,

    96

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS8)

    97

        self.Bind(wx.EVT_MENU, self.OnDeleteBranchMenu,

    98

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS9)

    99

        self.Bind(wx.EVT_MENU, self.OnDeleteMenu,

   100

              id=wxID_FBDVIEWERCONTEXTUALMENUITEMS11)

   101

   102

    # Create and initialize Contextual Menu

   103

    def _init_menus(self):

   104

        self.ContextualMenu = wx.Menu(title='')

   105

   106

        self._init_coll_ContextualMenu_Items(self.ContextualMenu)

   107

   108

    # Create a new Viewer

   109

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

   110

        wx.ScrolledWindow.__init__(self, parent, style=wx.SUNKEN_BORDER)

   111

        self._init_menus()

   112

        # Adding a rubberband to Viewer

   113

        self.rubberBand = RubberBand(drawingSurface=self)

   114

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

   115

        self.ResetView()

   116

        self.Scaling = None

   117

        #self.Scaling = (8, 8)

   118

        self.DrawGrid = True

   119

        self.current_id = 0    

   120

   121

        # Initialize Viewer mode to Selection mode

   122

        self.Mode = MODE_SELECTION

   123

   124

        self.Parent = window

   125

        self.Controler = controler

   126

   127

        # Link Viewer event to corresponding methods

   128

        EVT_PAINT(self, self.OnPaint)

   129

        EVT_LEFT_DOWN(self, self.OnViewerLeftDown)

   130

        EVT_LEFT_UP(self, self.OnViewerLeftUp)

   131

        EVT_LEFT_DCLICK(self, self.OnViewerLeftDClick)

   132

        EVT_RIGHT_UP(self, self.OnViewerRightUp)

   133

        EVT_MOTION(self, self.OnViewerMotion)

   134

        EVT_CHAR(self, self.OnChar)

   135

   136

    # Returns a new id

   137

    def GetNewId(self):

   138

        self.current_id += 1

   139

        return self.current_id

   140

   141

    # Destructor

   142

    def __del__(self):

   143

        self.ResetView()

   144

   145

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

   146

#                              Reset functions

   147

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

   148

   149

    # Resets Viewer lists

   150

    def ResetView(self):

   151

        self.Blocks = []

   152

        self.Wires = []

   153

        self.Elements = []

   154

        self.SelectedElement = None

   155

   156

    # Changes Viewer mode

   157

    def SetMode(self, mode):

   158

        self.Mode = mode

   159

        # Reset selection

   160

        if self.SelectedElement:

   161

            self.SelectedElement.SetSelected(False)

   162

            self.SelectedElement = None

   163

            self.Refresh()

   164

   165

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

   166

#                          Refresh functions

   167

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

   168

   169

    # Refresh Viewer elements

   170

    def RefreshView(self):

   171

        self.current_id = 0

   172

        # Start by reseting Viewer

   173

        self.ResetView()

   174

        instance = True

   175

        # List of ids of already loaded blocks

   176

        ids = []

   177

        # Load Blocks until they are all loaded

   178

        while instance:

   179

            instance = self.Controler.GetCurrentElementEditingInstanceInfos(exclude=ids)

   180

            if instance:

   181

                self.loadInstance(instance, ids)

   182

        self.Refresh()

   183

   184

    # Load instance from given informations

   185

    def loadInstance(self, instance, ids):

   186

        ids.append(instance["id"])

   187

        self.current_id = max(self.current_id, instance["id"]) 

   188

        if instance["type"] == "input":

   189

            variable = FBD_Variable(self, INPUT, instance["name"], instance["value_type"], instance["id"])

   190

            variable.SetPosition(instance["x"], instance["y"])

   191

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

   192

            self.Blocks.append(variable)

   193

            self.Elements.append(variable)

   194

            connectors = variable.GetConnectors()

   195

            connectors["output"].SetPosition(wxPoint(*instance["connector"]["position"]))

   196

            if instance["connector"]["negated"]:

   197

                connectors["output"].SetNegated(True)

   198

            if instance["connector"]["edge"]:

   199

                connectors["output"].SetEdge(instance["connector"]["edge"])

   200

        elif instance["type"] == "output":

   201

            variable = FBD_Variable(self, OUTPUT, instance["name"], instance["value_type"], instance["id"])

   202

            variable.SetPosition(instance["x"], instance["y"])

   203

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

   204

            self.Blocks.append(variable)

   205

            self.Elements.append(variable)

   206

            connectors = variable.GetConnectors()

   207

            connectors["input"].SetPosition(wxPoint(*instance["connector"]["position"]))

   208

            if instance["connector"]["negated"]:

   209

                connectors["input"].SetNegated(True)

   210

            if instance["connector"]["edge"]:

   211

                connectors["input"].SetEdge(instance["connector"]["edge"])

   212

            self.CreateWires(connectors["input"], instance["connector"]["links"], ids)

   213

        elif instance["type"] == "inout":

   214

            variable = FBD_Variable(self, INOUT, instance["name"], instance["value_type"], instance["id"])

   215

            variable.SetPosition(instance["x"], instance["y"])

   216

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

   217

            self.Blocks.append(variable)

   218

            self.Elements.append(variable)

   219

            connectors = variable.GetConnectors()

   220

            connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))

   221

            connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))

   222

            if instance["connectors"]["output"]["negated"]:

   223

                connectors["output"].SetNegated(True)

   224

            if instance["connectors"]["output"]["edge"]:

   225

                connectors["output"].SetEdge(instance["connectors"]["output"]["edge"])

   226

            if instance["connectors"]["input"]["negated"]:

   227

                connectors["input"].SetNegated(True)

   228

            if instance["connectors"]["input"]["edge"]:

   229

                connectors["input"].SetEdge(instance["connectors"]["input"]["edge"])

   230

            self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)

   231

        elif instance["type"] == "continuation":

   232

            connection = FBD_Connector(self, CONTINUATION, instance["name"], instance["id"])

   233

            connection.SetPosition(instance["x"], instance["y"])

   234

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

   235

            self.Blocks.append(connection)

   236

            self.Elements.append(connection)

   237

            connector = connection.GetConnector()

   238

            connector.SetPosition(wxPoint(*instance["connector"]["position"]))

   239

        elif instance["type"] == "connection":

   240

            connection = FBD_Connection(self, CONNECTOR, instance["name"], instance["id"])

   241

            connection.SetPosition(instance["x"], instance["y"])

   242

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

   243

            self.Blocks.append(connection)

   244

            self.Elements.append(connection)

   245

            connector = connection.GetConnector()

   246

            connector.SetPosition(wxPoint(*instance["connector"]["position"]))

   247

            self.CreateWires(connector, instance["connector"]["links"], ids)

   248

        elif instance["type"] == "comment":

   249

            comment = Comment(self, instance["content"], instance["id"])

   250

            comment.SetPosition(instance["x"], instance["y"])

   251

            comment.SetSize(instance["width"], instance["height"])

   252

            self.Elements.append(comment)

   253

        elif instance["type"] == "leftPowerRail":

   254

            leftpowerrail = LD_PowerRail(self, LEFTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])

   255

            leftpowerrail.SetPosition(instance["x"], instance["y"])

   256

            self.Blocks.append(leftpowerrail)

   257

            self.Elements.append(leftpowerrail)

   258

            connectors = leftpowerrail.GetConnectors()

   259

            for i, connector in enumerate(instance["connectors"]):

   260

                connectors[i].SetPosition(wxPoint(*connector["position"]))

   261

        elif instance["type"] == "rightPowerRail":

   262

            rightpowerrail = LD_PowerRail(self, RIGHTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])

   263

            rightpowerrail.SetPosition(instance["x"], instance["y"])

   264

            self.Blocks.append(rightpowerrail)

   265

            self.Elements.append(rightpowerrail)

   266

            connectors = rightpowerrail.GetConnectors()

   267

            for i, connector in enumerate(instance["connectors"]):

   268

                connectors[i].SetPosition(wxPoint(*connector["position"]))

   269

                self.CreateWires(connectors[i], connector["links"], ids)

   270

        elif instance["type"] == "contact":

   271

            if instance["negated"]:

   272

                negated = instance["negated"]

   273

            else:

   274

                negated = False

   275

            if instance["edge"]:

   276

                edge = instance["edge"]

   277

            else:

   278

                edge = "none"

   279

            if negated and edge == "none":

   280

                contact_type = CONTACT_REVERSE

   281

            elif not negated and edge == "rising":

   282

                contact_type = CONTACT_RISING

   283

            elif not negated and edge == "falling":

   284

                contact_type = CONTACT_FALLING

   285

            else:

   286

                contact_type = CONTACT_NORMAL

   287

            contact = LD_Contact(self, contact_type, instance["name"], instance["id"])

   288

            contact.SetPosition(instance["x"], instance["y"])

   289

            self.Blocks.append(contact)

   290

            self.Elements.append(contact)

   291

            connectors = contact.GetConnectors()

   292

            connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))

   293

            self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)

   294

            connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))

   295

        elif instance["type"] == "coil":

   296

            if instance["negated"]:

   297

                negated = instance["negated"]

   298

            else:

   299

                negated = False

   300

            if instance["storage"]:

   301

                storage = instance["storage"]

   302

            else:

   303

                storage = "none"

   304

            if negated and storage == "none":

   305

                coil_type = COIL_REVERSE

   306

            elif not negated and storage == "set":

   307

                coil_type = COIL_SET

   308

            elif not negated and storage == "reset":

   309

                coil_type = COIL_RESET

   310

            else:

   311

                coil_type = COIL_NORMAL

   312

            coil = LD_Coil(self, coil_type, instance["name"], instance["id"])

   313

            coil.SetPosition(instance["x"], instance["y"])

   314

            self.Blocks.append(coil)

   315

            self.Elements.append(coil)

   316

            connectors = coil.GetConnectors()

   317

            connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))

   318

            self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)

   319

            connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))

   320

        elif instance["type"] == "step":

   321

            if instance["initial"]:

   322

                initial = instance["initial"]

   323

            else:

   324

                initial = False

   325

            step = SFC_Step(self, instance["name"], initial, instance["id"])

   326

            step.SetPosition(instance["x"], instance["y"])

   327

            step.SetSize(instance["width"], instance["height"])

   328

            self.Blocks.append(step)

   329

            self.Elements.append(step)

   330

            if "output" in instance["connectors"]:

   331

                step.AddOutput()

   332

            if "action" in instance["connectors"]:

   333

                step.AddAction()

   334

            connectors = step.GetConnectors()

   335

            if connectors["input"]:

   336

                connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))

   337

                self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)

   338

            if connectors["output"]:

   339

                connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))

   340

            if connectors["action"]:

   341

                connectors["action"].SetPosition(wxPoint(*instance["connectors"]["action"]["position"]))

   342

        elif instance["type"] == "transition":

   343

            transition = SFC_Transition(self, instance["condition_type"], instance["condition"], instance["id"])

   344

            transition.SetPosition(instance["x"], instance["y"])

   345

            self.Blocks.append(transition)

   346

            self.Elements.append(transition)

   347

            connectors = transition.GetConnectors()

   348

            connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))

   349

            self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)

   350

            connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))

   351

        elif instance["type"] in ["selectionDivergence", "selectionConvergence", "simultaneousDivergence", "simultaneousConvergence"]:

   352

            if instance["type"] == "selectionDivergence":

   353

                divergence = SFC_Divergence(self, SELECTION_DIVERGENCE, 

   354

                    len(instance["connectors"]["outputs"]), instance["id"])

   355

            elif instance["type"] == "selectionConvergence":

   356

                divergence = SFC_Divergence(self, SELECTION_CONVERGENCE, 

   357

                    len(instance["connectors"]["inputs"]), instance["id"])

   358

            elif instance["type"] == "simultaneousDivergence":

   359

                divergence = SFC_Divergence(self, SIMULTANEOUS_DIVERGENCE, 

   360

                    len(instance["connectors"]["outputs"]), instance["id"])

   361

            else:

   362

                divergence = SFC_Divergence(self, SIMULTANEOUS_CONVERGENCE, 

   363

                    len(instance["connectors"]["inputs"]), instance["id"])

   364

            divergence.SetPosition(instance["x"], instance["y"])

   365

            divergence.SetSize(instance["width"], instance["height"])

   366

            self.Blocks.append(divergence)

   367

            self.Elements.append(divergence)

   368

            connectors = divergence.GetConnectors()

   369

            for i, input_connector in enumerate(instance["connectors"]["inputs"]):

   370

                connector = connectors["inputs"][i]

   371

                connector.SetPosition(wxPoint(*input_connector["position"]))

   372

                self.CreateWires(connector, input_connector["links"], ids)

   373

            for i, output_connector in enumerate(instance["connectors"]["outputs"]):

   374

                connector = connectors["outputs"][i]

   375

                connector.SetPosition(wxPoint(*output_connector["position"]))

   376

        elif instance["type"] == "jump":

   377

            jump = SFC_Jump(self, instance["target"], instance["id"])

   378

            jump.SetPosition(instance["x"], instance["y"])

   379

            self.Blocks.append(jump)

   380

            self.Elements.append(jump)

   381

            connector = jump.GetConnector()

   382

            connector.SetPosition(wxPoint(*instance["connector"]["position"]))

   383

            self.CreateWires(connector, instance["connector"]["links"], ids)

   384

        elif instance["type"] == "actionBlock":

   385

            actionBlock = SFC_ActionBlock(self, instance["actions"], instance["id"])

   386

            actionBlock.SetPosition(instance["x"], instance["y"])

   387

            actionBlock.SetSize(instance["width"], instance["height"])

   388

            self.Blocks.append(actionBlock)

   389

            self.Elements.append(actionBlock)

   390

            connector = actionBlock.GetConnector()

   391

            connector.SetPosition(wxPoint(*instance["connector"]["position"]))

   392

            self.CreateWires(connector, instance["connector"]["links"], ids)

   393

        else:

   394

            if instance["name"] != None:

   395

                block = FBD_Block(self, instance["type"], instance["name"], instance["id"], len(instance["connectors"]["inputs"]))

   396

            else:

   397

                block = FBD_Block(self, instance["type"], "", instance["id"], len(instance["connectors"]["inputs"]))

   398

            block.SetPosition(instance["x"], instance["y"])

   399

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

   400

            self.Blocks.append(block)

   401

            self.Elements.append(block)

   402

            connectors = block.GetConnectors()

   403

            for i, input_connector in enumerate(instance["connectors"]["inputs"]):

   404

                connector = connectors["inputs"][i]

   405

                connector.SetPosition(wxPoint(*input_connector["position"]))

   406

                if input_connector["negated"]:

   407

                    connector.SetNegated(True)

   408

                if input_connector["edge"]:

   409

                    connector.SetEdge(input_connector["edge"])

   410

                self.CreateWires(connector, input_connector["links"], ids)

   411

            for i, output_connector in enumerate(instance["connectors"]["outputs"]):

   412

                connector = connectors["outputs"][i]

   413

                if output_connector["negated"]:

   414

                    connector.SetNegated(True)

   415

                if output_connector["edge"]:

   416

                    connector.SetEdge(output_connector["edge"])

   417

                connector.SetPosition(wxPoint(*output_connector["position"]))

   418

   419

    def CreateWires(self, start_connector, links, ids):

   420

        for link in links:

   421

            refLocalId = link["refLocalId"]

   422

            if refLocalId != None:

   423

                if refLocalId not in ids:

   424

                    new_instance = self.Controler.GetCurrentElementEditingInstanceInfos(refLocalId)

   425

                    if new_instance:

   426

                        self.loadInstance(new_instance, ids)

   427

                connected = self.FindElementById(refLocalId)

   428

                if connected:

   429

                    points = link["points"]

   430

                    end_connector = connected.GetConnector(wxPoint(points[-1][0], points[-1][1]))

   431

                    if end_connector:

   432

                        wire = Wire(self)

   433

                        wire.SetPoints(points)

   434

                        start_connector.Connect((wire, 0), False)

   435

                        end_connector.Connect((wire, -1), False)

   436

                        wire.ConnectStartPoint(None, start_connector)

   437

                        wire.ConnectEndPoint(None, end_connector)

   438

                        self.Wires.append(wire)

   439

                        self.Elements.append(wire)

   440

   441

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

   442

#                          Search Element functions

   443

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

   444

   445

    def FindBlock(self, pos):

   446

        for block in self.Blocks:

   447

            if block.HitTest(pos) or block.TestHandle(pos) != (0, 0):

   448

                return block

   449

        return None

   450

   451

    def FindWire(self, pos):

   452

        for wire in self.Wires:

   453

            if wire.HitTest(pos) or wire.TestHandle(pos) != (0, 0):

   454

                return wire

   455

        return None

   456

   457

    def FindElement(self, pos, exclude_group = False):

   458

        if self.SelectedElement and not (exclude_group and isinstance(self.SelectedElement, Graphic_Group)):

   459

            if self.SelectedElement.HitTest(pos) or self.SelectedElement.TestHandle(pos) != (0, 0):

   460

                return self.SelectedElement

   461

        for element in self.Elements:

   462

            if element.HitTest(pos) or element.TestHandle(pos) != (0, 0):

   463

                return element

   464

        return None

   465

   466

    def FindBlockConnector(self, pos):

   467

        for block in self.Blocks:

   468

            result = block.TestConnector(pos)

   469

            if result:

   470

                return result

   471

        return None

   472

   473

    def FindElementById(self, id):

   474

        for element in self.Elements:

   475

            if element.GetId() == id:

   476

                return element

   477

        return None

   478

   479

    def SearchElements(self, bbox):

   480

        elements = []

   481

        for element in self.Elements:

   482

            element_bbox = element.GetBoundingBox()

   483

            if element_bbox.x >= bbox.x and element_bbox.y >= bbox.y and element_bbox.x + element_bbox.width <= bbox.x + bbox.width and element_bbox.y + element_bbox.height <= bbox.y + bbox.height:

   484

                elements.append(element)

   485

        return elements

   486

   487

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

   488

#                           Popup menu functions

   489

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

   490

   491

    def PopupBlockMenu(self, connector = None):

   492

        self.ContextualMenu.FindItemByPosition(0).Enable(connector != None)

   493

        self.ContextualMenu.FindItemByPosition(1).Enable(connector != None)

   494

        self.ContextualMenu.FindItemByPosition(2).Enable(connector != None)

   495

        self.ContextualMenu.FindItemByPosition(3).Enable(connector != None)

   496

        self.ContextualMenu.FindItemByPosition(5).Enable(False)

   497

        self.ContextualMenu.FindItemByPosition(6).Enable(False)

   498

        self.ContextualMenu.FindItemByPosition(8).Enable(False)

   499

        self.ContextualMenu.FindItemByPosition(9).Enable(False)

   500

        if connector:

   501

            if connector.IsNegated():

   502

                self.ContextualMenu.FindItemByPosition(1).Check(True)

   503

            elif connector.GetEdge() == "rising":

   504

                self.ContextualMenu.FindItemByPosition(2).Check(True)

   505

            elif connector.GetEdge() == "falling":

   506

                self.ContextualMenu.FindItemByPosition(3).Check(True)

   507

            else:

   508

                self.ContextualMenu.FindItemByPosition(0).Check(True)

   509

        self.PopupMenu(self.ContextualMenu)

   510

   511

    def PopupVariableMenu(self, connector = None):

   512

        self.ContextualMenu.FindItemByPosition(0).Enable(connector != None)

   513

        self.ContextualMenu.FindItemByPosition(1).Enable(connector != None)

   514

        self.ContextualMenu.FindItemByPosition(2).Enable(False)

   515

        self.ContextualMenu.FindItemByPosition(3).Enable(False)

   516

        self.ContextualMenu.FindItemByPosition(5).Enable(False)

   517

        self.ContextualMenu.FindItemByPosition(6).Enable(False)

   518

        self.ContextualMenu.FindItemByPosition(8).Enable(False)

   519

        self.ContextualMenu.FindItemByPosition(9).Enable(False)

   520

        if connector:

   521

            if connector.IsNegated():

   522

                self.ContextualMenu.FindItemByPosition(1).Check(True)

   523

            else:

   524

                self.ContextualMenu.FindItemByPosition(0).Check(True)

   525

        self.PopupMenu(self.ContextualMenu)

   526

   527

    def PopupWireMenu(self):

   528

        self.ContextualMenu.FindItemByPosition(0).Enable(False)

   529

        self.ContextualMenu.FindItemByPosition(1).Enable(False)

   530

        self.ContextualMenu.FindItemByPosition(2).Enable(False)