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

from types import *

    28

    29

from plcopen.structures import *

    30

from graphics.GraphicCommons import *

    31

from graphics.SFC_Objects import *

    32

from Viewer import *

    33

from Dialogs import *

    34

    35

class SFC_Viewer(Viewer):

    36

    37

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

    38

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

    39

    40

    def ConnectConnectors(self, start, end):

    41

        startpoint = [start.GetPosition(False), start.GetDirection()]

    42

        endpoint = [end.GetPosition(False), end.GetDirection()]

    43

        wire = Wire(self, startpoint, endpoint)

    44

        self.AddWire(wire)

    45

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

    46

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

    47

        wire.ConnectStartPoint(None, start)

    48

        wire.ConnectEndPoint(None, end)

    49

        return wire

    50

    51

    def CreateTransition(self, connector, next = None):

    52

        previous = connector.GetParentBlock()

    53

        id = self.GetNewId()

    54

        transition = SFC_Transition(self, "reference", "", id)

    55

        pos = connector.GetPosition(False)

    56

        transition.SetPosition(pos.x, pos.y + SFC_WIRE_MIN_SIZE)

    57

        transition_connectors = transition.GetConnectors()

    58

        wire = self.ConnectConnectors(transition_connectors["input"], connector)

    59

        if isinstance(previous, SFC_Divergence):

    60

            previous.RefreshConnectedPosition(connector)

    61

        else:

    62

            previous.RefreshOutputPosition()

    63

        wire.SetPoints([wxPoint(pos.x, pos.y + GetWireSize(previous)), wxPoint(pos.x, pos.y)])

    64

        self.AddBlock(transition)

    65

        self.Controler.AddCurrentElementEditingTransition(id)

    66

        self.RefreshTransitionModel(transition)

    67

        if next:

    68

            wire = self.ConnectConnectors(next, transition_connectors["output"])

    69

            pos = transition_connectors["output"].GetPosition(False)

    70

            next_block = next.GetParentBlock()

    71

            next_pos = next.GetPosition(False)

    72

            transition.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))

    73

            wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])

    74

            if isinstance(next_block, SFC_Divergence):

    75

                next_block.RefreshPosition()

    76

            transition.RefreshOutputModel(True)

    77

        return transition

    78

    79

    def RemoveTransition(self, transition):

    80

        connectors = transition.GetConnectors()

    81

        input_wires = connectors["input"].GetWires()

    82

        if len(input_wires) != 1:

    83

            return

    84

        input_wire = input_wires[0][0]

    85

        previous = input_wire.EndConnected

    86

        input_wire.Clean()

    87

        self.RemoveWire(input_wire)

    88

        output_wires = connectors["output"].GetWires()

    89

        if len(output_wires) != 1:

    90

            return

    91

        output_wire = output_wires[0][0]

    92

        next = output_wire.StartConnected

    93

        output_wire.Clean()

    94

        self.RemoveWire(output_wire)

    95

        transition.Clean()

    96

        self.RemoveBlock(transition)

    97

        self.Controler.RemoveCurrentElementEditingInstance(transition.GetId())

    98

        wire = self.ConnectConnectors(next, previous)

    99

        return wire

   100

   101

    def CreateStep(self, name, connector, next = None):

   102

        previous = connector.GetParentBlock()

   103

        id = self.GetNewId()

   104

        step = SFC_Step(self, name, False, id)

   105

        if next:

   106

            step.AddOutput()

   107

        min_width, min_height = step.GetMinSize()

   108

        pos = connector.GetPosition(False)

   109

        step.SetPosition(pos.x, pos.y + SFC_WIRE_MIN_SIZE)

   110

        step.SetSize(min_width, min_height)

   111

        step_connectors = step.GetConnectors()

   112

        wire = self.ConnectConnectors(step_connectors["input"], connector)

   113

        if isinstance(previous, SFC_Divergence):

   114

            previous.RefreshConnectedPosition(connector)

   115

        else:

   116

            previous.RefreshOutputPosition()

   117

        wire.SetPoints([wxPoint(pos.x, pos.y + GetWireSize(previous)), wxPoint(pos.x, pos.y)])

   118

        self.AddBlock(step)

   119

        self.Controler.AddCurrentElementEditingStep(id)

   120

        self.RefreshStepModel(step)

   121

        if next:

   122

            wire = self.ConnectConnectors(next, step_connectors["output"])

   123

            pos = step_connectors["output"].GetPosition(False)

   124

            next_block = next.GetParentBlock()

   125

            next_pos = next.GetPosition(False)

   126

            step.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))

   127

            wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])

   128

            if isinstance(next_block, SFC_Divergence):

   129

                next_block.RefreshPosition()

   130

            step.RefreshOutputModel(True)

   131

        return step

   132

   133

    def RemoveStep(self, step):

   134

        connectors = step.GetConnectors()

   135

        if connectors["input"]:

   136

            input_wires = connectors["input"].GetWires()

   137

            if len(input_wires) != 1:

   138

                return

   139

            input_wire = input_wires[0][0]

   140

            previous = input_wire.EndConnected

   141

            input_wire.Clean()

   142

            self.RemoveWire(input_wire)

   143

        else:

   144

            previous = None

   145

        if connectors["output"]:

   146

            output_wires = connectors["output"].GetWires()

   147

            if len(output_wires) != 1:

   148

                return

   149

            output_wire = output_wires[0][0]

   150

            next = output_wire.StartConnected

   151

            output_wire.Clean()

   152

            self.RemoveWire(output_wire)

   153

        else:

   154

            next = None

   155

        action = step.GetActionConnector()

   156

        if action:

   157

            self.DeleteActionBlock(action.GetParentBlock())

   158

        step.Clean()

   159

        self.RemoveBlock(step)

   160

        self.Controler.RemoveCurrentElementEditingInstance(step.GetId())

   161

        if next and previous:

   162

            wire = self.ConnectConnectors(next, previous)

   163

            return wire

   164

        else:

   165

            return None

   166

   167

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

   168

#                          Mouse event functions

   169

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

   170

   171

    def OnViewerLeftDown(self, event):

   172

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   173

            Viewer.OnViewerLeftDown(self, event)

   174

        elif self.Mode == MODE_SELECTION:

   175

            dc = self.GetLogicalDC()

   176

            pos = event.GetLogicalPosition(dc)

   177

            if event.ControlDown():

   178

                element = self.FindElement(pos, True)

   179

                if element and not self.IsWire(element):

   180

                    if isinstance(self.SelectedElement, Graphic_Group):

   181

                        self.SelectedElement.SelectElement(element)

   182

                    else:

   183

                        group = Graphic_Group(self)

   184

                        self.SelectedElement.SetSelected(False)

   185

                        group.SelectElement(self.SelectedElement)

   186

                        group.SelectElement(element)

   187

                        self.SelectedElement = group

   188

                    elements = self.SelectedElement.GetElements()

   189

                    if len(elements) == 0:

   190

                        self.SelectedElement = element

   191

                    elif len(elements) == 1:

   192

                        self.SelectedElement = elements[0]

   193

            else:

   194

                element = self.FindElement(pos)

   195

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

   196

                    if self.IsWire(self.SelectedElement):

   197

                        self.SelectedElement.SetSelectedSegment(None)

   198

                    else:

   199

                        self.SelectedElement.SetSelected(False)

   200

                    self.SelectedElement = None

   201

                    self.Refresh()

   202

                if element:

   203

                    self.SelectedElement = element

   204

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

   205

                    self.Refresh()

   206

                else:

   207

                    self.rubberBand.Reset()

   208

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

   209

        elif self.Mode == MODE_COMMENT:

   210

            self.rubberBand.Reset()

   211

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

   212

        elif self.Mode == MODE_WIRE:

   213

            pos = GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling)

   214

            wire = Wire(self, [wxPoint(pos.x, pos.y), SOUTH], [wxPoint(pos.x, pos.y), NORTH])

   215

            wire.oldPos = pos

   216

            wire.Handle = (HANDLE_POINT, 0)

   217

            wire.ProcessDragging(0, 0)

   218

            wire.Handle = (HANDLE_POINT, 1)

   219

            self.AddWire(wire)

   220

            if self.SelectedElement:

   221

                self.SelectedElement.SetSelected(False)

   222

            self.SelectedElement = wire

   223

            self.Refresh()

   224

        event.Skip()

   225

   226

    def OnViewerLeftUp(self, event):

   227

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   228

            Viewer.OnViewerLeftUp(self, event)

   229

        elif self.rubberBand.IsShown():

   230

            if self.Mode == MODE_SELECTION:

   231

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

   232

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

   233

                if len(elements) > 0:

   234

                    self.SelectedElement = Graphic_Group(self)

   235

                    self.SelectedElement.SetElements(elements)

   236

                    self.SelectedElement.SetSelected(True)

   237

                    self.Refresh()

   238

            elif self.Mode == MODE_COMMENT:

   239

                bbox = self.rubberBand.GetCurrentExtent()

   240

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

   241

                wxCallAfter(self.AddComment, bbox)

   242

        elif self.Mode == MODE_INITIALSTEP:

   243

            wxCallAfter(self.AddInitialStep, GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling))

   244

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

   245

            if self.IsWire(self.SelectedElement):

   246

                self.SelectedElement.SetSelectedSegment(0)

   247

            else:

   248

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

   249

            wxCallAfter(self.SetCursor, wxNullCursor)

   250

            self.ReleaseMouse()

   251

            self.Refresh()

   252

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

   253

            self.SelectedElement.ResetPoints()

   254

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

   255

            self.SelectedElement.GeneratePoints()

   256

            self.SelectedElement.RefreshModel()

   257

            self.SelectedElement.SetSelected(True)

   258

            self.Refresh()

   259

        event.Skip()

   260

   261

    def OnViewerRightUp(self, event):

   262

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   263

            Viewer.OnViewerRightUp(self, event)

   264

        else:

   265

            dc = self.GetLogicalDC()

   266

            pos = event.GetLogicalPosition(dc)

   267

            element = self.FindElement(pos)

   268

            if element:

   269

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

   270

                    self.SelectedElement.SetSelected(False)

   271

                self.SelectedElement = element

   272

                if self.IsWire(self.SelectedElement):

   273

                    self.SelectedElement.SetSelectedSegment(0)

   274

                else:

   275

                    self.SelectedElement.SetSelected(True)

   276

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

   277

                wxCallAfter(self.SetCursor, wxNullCursor)

   278

                self.ReleaseMouse()

   279

                self.Refresh()

   280

        event.Skip()

   281

   282

    def OnViewerLeftDClick(self, event):

   283

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   284

            Viewer.OnViewerLeftDClick(self, event)

   285

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

   286

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

   287

            self.Refresh()

   288

        event.Skip()

   289

   290

    def OnViewerMotion(self, event):

   291

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   292

            Viewer.OnViewerMotion(self, event)

   293

        elif self.rubberBand.IsShown():

   294

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

   295

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

   296

            if not self.IsWire(self.SelectedElement):

   297

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

   298

            self.Refresh()

   299

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

   300

            self.SelectedElement.ResetPoints()

   301

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

   302

            self.SelectedElement.GeneratePoints()

   303

            self.Refresh()

   304

        Viewer.OnViewerMotion(self, event)

   305

        event.Skip()

   306

   307

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

   308

#                          Keyboard event functions

   309

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

   310

   311

    def OnChar(self, event):

   312

        keycode = event.GetKeyCode()

   313

        if self.Scaling:

   314

            scaling = self.Scaling

   315

        else:

   316

            scaling = (8, 8)

   317

        if keycode == WXK_DELETE and self.SelectedElement:

   318

            self.SelectedElement.Delete()

   319

            self.SelectedElement = None

   320

        elif keycode == WXK_LEFT:

   321

            if event.ControlDown() and event.ShiftDown():

   322

                self.Scroll(0, ypos)

   323

            elif event.ControlDown():

   324

                self.Scroll(max(0, xpos - 1), ypos)

   325

            elif self.SelectedElement:

   326

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

   327

        elif keycode == WXK_RIGHT:

   328

            if event.ControlDown() and event.ShiftDown():

   329

                self.Scroll(xmax, ypos)

   330

            elif event.ControlDown():

   331

                self.Scroll(min(xpos + 1, xmax), ypos)

   332

            elif self.SelectedElement:

   333

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

   334

        elif keycode == WXK_UP:

   335

            if event.ControlDown() and event.ShiftDown():

   336

                self.Scroll(xpos, 0)

   337

            elif event.ControlDown():

   338

                self.Scroll(xpos, max(0, ypos - 1))

   339

            elif self.SelectedElement:

   340

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

   341

        elif keycode == WXK_DOWN:

   342

            if event.ControlDown() and event.ShiftDown():

   343

                self.Scroll(xpos, ymax)

   344

            elif event.ControlDown():

   345

                self.Scroll(xpos, min(ypos + 1, ymax))

   346

            elif self.SelectedElement:

   347

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

   348

        self.Refresh()

   349

   350

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

   351

#                          Adding element functions

   352

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

   353

   354

    def AddInitialStep(self, pos):

   355

        dialog = StepNameDialog(self.Parent, "Add a new initial step", "Please enter step name", "", wxOK|wxCANCEL)

   356

        dialog.SetPouNames(self.Controler.GetProjectPouNames())

   357

        dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())

   358

        dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])

   359

        if dialog.ShowModal() == wxID_OK:

   360

            id = self.GetNewId()

   361

            name = dialog.GetValue()

   362

            step = SFC_Step(self, name, True, id)

   363

            min_width, min_height = step.GetMinSize()

   364

            step.SetPosition(pos.x, pos.y)

   365

            width, height = step.GetSize()

   366

            step.SetSize(max(min_width, width), max(min_height, height))

   367

            self.AddBlock(step)

   368

            self.Controler.AddCurrentElementEditingStep(id)

   369

            self.RefreshStepModel(step)

   370

            self.Parent.RefreshProjectTree()

   371

            self.Refresh()

   372

        dialog.Destroy()

   373

   374

    def AddStep(self):

   375

        if self.SelectedElement in self.Wires or isinstance(self.SelectedElement, SFC_Step):

   376

            dialog = StepNameDialog(self.Parent, "Add a new step", "Please enter step name", "", wxOK|wxCANCEL)

   377

            dialog.SetPouNames(self.Controler.GetProjectPouNames())

   378

            dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())

   379

            dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])

   380

            if dialog.ShowModal() == wxID_OK:

   381

                name = dialog.GetValue()

   382

                if self.IsWire(self.SelectedElement):

   383

                    self.SelectedElement.SetSelectedSegment(None)

   384

                    previous = self.SelectedElement.EndConnected

   385

                    next = self.SelectedElement.StartConnected

   386

                    self.SelectedElement.Clean()

   387

                    self.RemoveWire(self.SelectedElement)

   388

                else:

   389

                    connectors = self.SelectedElement.GetConnectors()

   390

                    if connectors["output"]:

   391

                        previous = connectors["output"]

   392

                        wires = previous.GetWires()

   393

                        if len(wires) != 1:

   394

                            return

   395

                        wire = wires[0][0]

   396

                        next = wire.StartConnected

   397

                        wire.Clean()

   398

                        self.RemoveWire(wire)

   399

                    else:

   400

                        self.SelectedElement.AddOutput()

   401

                        connectors = self.SelectedElement.GetConnectors()

   402

                        self.RefreshStepModel(self.SelectedElement)

   403

                        previous = connectors["output"]

   404

                        next = None

   405

                previous_block = previous.GetParentBlock()

   406

                if isinstance(previous_block, SFC_Step) or isinstance(previous_block, SFC_Divergence) and previous_block.GetType() in [SELECTION_DIVERGENCE, SELECTION_CONVERGENCE]:

   407

                    transition = self.CreateTransition(previous)

   408

                    transition_connectors = transition.GetConnectors()

   409

                    step = self.CreateStep(name, transition_connectors["output"], next)

   410

                else:

   411

                    step = self.CreateStep(name, previous)

   412

                    step.AddOutput()

   413

                    step.RefreshModel()

   414

                    step_connectors = step.GetConnectors()

   415

                    transition = self.CreateTransition(step_connectors["output"], next)

   416

                if self.IsWire(self.SelectedElement):

   417

                    self.SelectedElement = wire

   418

                    self.SelectedElement.SetSelectedSegment(0)

   419

                else:

   420

                    self.SelectedElement.SetSelected(False)

   421

                    self.SelectedElement = step

   422

                    self.SelectedElement.SetSelected(True)

   423

                self.Parent.RefreshProjectTree()

   424

                self.Refresh()

   425

            dialog.Destroy()

   426

   427

    def AddStepAction(self):

   428

        if isinstance(self.SelectedElement, SFC_Step):

   429

            connectors = self.SelectedElement.GetConnectors()

   430

            if not connectors["action"]:

   431

                dialog = ActionBlockDialog(self.Parent)

   432

                dialog.SetQualifierList(self.Controler.GetQualifierTypes())

   433

                dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())

   434

                dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())

   435

                if dialog.ShowModal() == wxID_OK:

   436

                    actions = dialog.GetValues()

   437

                    self.SelectedElement.AddAction()

   438

                    self.RefreshStepModel(self.SelectedElement)

   439

                    connectors = self.SelectedElement.GetConnectors()

   440

                    pos = connectors["action"].GetPosition(False)

   441

                    id = self.GetNewId()

   442

                    actionblock = SFC_ActionBlock(self, [], id)

   443

                    actionblock.SetPosition(pos.x + SFC_WIRE_MIN_SIZE, pos.y - SFC_STEP_DEFAULT_SIZE[1] / 2)

   444

                    actionblock_connector = actionblock.GetConnector()

   445

                    wire = self.ConnectConnectors(actionblock_connector, connectors["action"])

   446

                    wire.SetPoints([wxPoint(pos.x + SFC_WIRE_MIN_SIZE, pos.y), wxPoint(pos.x, pos.y)])

   447

                    actionblock.SetActions(actions)

   448

                    self.AddBlock(actionblock)

   449

                    self.Controler.AddCurrentElementEditingActionBlock(id)

   450

                    self.RefreshActionBlockModel(actionblock)

   451

                    self.Refresh()

   452

                dialog.Destroy()

   453

   454

    def AddDivergence(self):

   455

        if self.SelectedElement in self.Wires or isinstance(self.SelectedElement, Graphic_Group) or isinstance(self.SelectedElement, SFC_Step):        

   456

            dialog = DivergenceCreateDialog(self.Parent)

   457

            if dialog.ShowModal() == wxID_OK:

   458

                value = dialog.GetValues()

   459

                if value["type"] == SELECTION_DIVERGENCE:

   460

                    if self.SelectedElement in self.Wires and isinstance(self.SelectedElement.EndConnected.GetParentBlock(), SFC_Step):

   461

                        self.SelectedElement.SetSelectedSegment(None)

   462

                        previous = self.SelectedElement.EndConnected

   463

                        next = self.SelectedElement.StartConnected

   464

                        self.SelectedElement.Clean()

   465

                        self.RemoveWire(self.SelectedElement)

   466

                        self.SelectedElement = None

   467

                    elif isinstance(self.SelectedElement, SFC_Step):

   468

                        connectors = self.SelectedElement.GetConnectors()

   469

                        if connectors["output"]:

   470

                            previous = connectors["output"]

   471

                            wires = previous.GetWires()

   472

                            if len(wires) != 1:

   473

                                return

   474

                            wire = wires[0][0]

   475

                            next = wire.StartConnected

   476

                            wire.Clean()

   477

                            self.RemoveWire(wire)

   478

                        else:

   479

                            self.SelectedElement.AddOutput()

   480

                            connectors = self.SelectedElement.GetConnectors()

   481

                            self.RefreshStepModel(self.SelectedElement)

   482

                            previous = connectors["output"]

   483

                            next = None

   484

                    else:

   485

                        return

   486

                    id = self.GetNewId()

   487

                    divergence = SFC_Divergence(self, SELECTION_DIVERGENCE, value["number"], id)

   488

                    pos = previous.GetPosition(False)

   489

                    previous_block = previous.GetParentBlock()

   490

                    wire_size = GetWireSize(previous_block)

   491

                    divergence.SetPosition(pos.x, pos.y + wire_size)

   492

                    divergence_connectors = divergence.GetConnectors()

   493

                    wire = self.ConnectConnectors(divergence_connectors["inputs"][0], previous)

   494

                    previous_block.RefreshOutputPosition()

   495

                    wire.SetPoints([wxPoint(pos.x, pos.y + wire_size), wxPoint(pos.x, pos.y)])

   496

                    self.AddBlock(divergence)

   497

                    self.Controler.AddCurrentElementEditingDivergence(id, value["type"])

   498

                    self.RefreshDivergenceModel(divergence)

   499

                    for index, connector in enumerate(divergence_connectors["outputs"]):

   500

                        if next:

   501

                            wire = self.ConnectConnectors(next, connector)

   502

                            pos = connector.GetPosition(False)

   503

                            next_pos = next.GetPosition(False)

   504

                            next_block = next.GetParentBlock()

   505

                            divergence.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))

   506

                            divergence.RefreshConnectedPosition(connector)

   507

                            wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])

   508

                            next_block.RefreshModel()

   509

                            next = None

   510

                        else:

   511

                            transition = self.CreateTransition(connector)

   512

                            transition_connectors = transition.GetConnectors()

   513

                            step = self.CreateStep("Step", transition_connectors["output"])

   514

                elif value["type"] == SIMULTANEOUS_DIVERGENCE:

   515

                    if self.SelectedElement in self.Wires and isinstance(self.SelectedElement.EndConnected.GetParentBlock(), SFC_Transition):

   516