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 Viewer import *

    30

    31

class SFC_Viewer(Viewer):

    32

    33

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

    34

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

    35

    36

    def ConnectConnectors(self, start, end):

    37

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

    38

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

    39

        wire = Wire(self, startpoint, endpoint)

    40

        self.AddWire(wire)

    41

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

    42

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

    43

        wire.ConnectStartPoint(None, start)

    44

        wire.ConnectEndPoint(None, end)

    45

        return wire

    46

    47

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

    48

        previous = connector.GetParentBlock()

    49

        id = self.GetNewId()

    50

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

    51

        pos = connector.GetPosition(False)

    52

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

    53

        transition_connectors = transition.GetConnectors()

    54

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

    55

        if isinstance(previous, SFC_Divergence):

    56

            previous.RefreshConnectedPosition(connector)

    57

        else:

    58

            previous.RefreshOutputPosition()

    59

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

    60

        self.AddBlock(transition)

    61

        self.Controler.AddCurrentElementEditingTransition(id)

    62

        self.RefreshTransitionModel(transition)

    63

        if next:

    64

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

    65

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

    66

            next_block = next.GetParentBlock()

    67

            next_pos = next.GetPosition(False)

    68

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

    69

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

    70

            if isinstance(next_block, SFC_Divergence):

    71

                next_block.RefreshPosition()

    72

            transition.RefreshOutputModel(True)

    73

        return transition

    74

    75

    def RemoveTransition(self, transition):

    76

        connectors = transition.GetConnectors()

    77

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

    78

        if len(input_wires) != 1:

    79

            return

    80

        input_wire = input_wires[0][0]

    81

        previous = input_wire.EndConnected

    82

        input_wire.Clean()

    83

        self.RemoveWire(input_wire)

    84

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

    85

        if len(output_wires) != 1:

    86

            return

    87

        output_wire = output_wires[0][0]

    88

        next = output_wire.StartConnected

    89

        output_wire.Clean()

    90

        self.RemoveWire(output_wire)

    91

        transition.Clean()

    92

        self.RemoveBlock(transition)

    93

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

    94

        wire = self.ConnectConnectors(next, previous)

    95

        return wire

    96

    97

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

    98

        previous = connector.GetParentBlock()

    99

        id = self.GetNewId()

   100

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

   101

        if next:

   102

            step.AddOutput()

   103

        min_width, min_height = step.GetMinSize()

   104

        pos = connector.GetPosition(False)

   105

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

   106

        step.SetSize(min_width, min_height)

   107

        step_connectors = step.GetConnectors()

   108

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

   109

        if isinstance(previous, SFC_Divergence):

   110

            previous.RefreshConnectedPosition(connector)

   111

        else:

   112

            previous.RefreshOutputPosition()

   113

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

   114

        self.AddBlock(step)

   115

        self.Controler.AddCurrentElementEditingStep(id)

   116

        self.RefreshStepModel(step)

   117

        if next:

   118

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

   119

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

   120

            next_block = next.GetParentBlock()

   121

            next_pos = next.GetPosition(False)

   122

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

   123

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

   124

            if isinstance(next_block, SFC_Divergence):

   125

                next_block.RefreshPosition()

   126

            step.RefreshOutputModel(True)

   127

        return step

   128

   129

    def RemoveStep(self, step):

   130

        connectors = step.GetConnectors()

   131

        if connectors["input"]:

   132

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

   133

            if len(input_wires) != 1:

   134

                return

   135

            input_wire = input_wires[0][0]

   136

            previous = input_wire.EndConnected

   137

            input_wire.Clean()

   138

            self.RemoveWire(input_wire)

   139

        else:

   140

            previous = None

   141

        if connectors["output"]:

   142

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

   143

            if len(output_wires) != 1:

   144

                return

   145

            output_wire = output_wires[0][0]

   146

            next = output_wire.StartConnected

   147

            output_wire.Clean()

   148

            self.RemoveWire(output_wire)

   149

        else:

   150

            next = None

   151

        action = step.GetActionConnector()

   152

        if action:

   153

            self.DeleteActionBlock(action.GetParentBlock())

   154

        step.Clean()

   155

        self.RemoveBlock(step)

   156

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

   157

        if next and previous:

   158

            wire = self.ConnectConnectors(next, previous)

   159

            return wire

   160

        else:

   161

            return None

   162

   163

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

   164

#                          Mouse event functions

   165

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

   166

   167

    def OnViewerLeftDown(self, event):

   168

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   169

            Viewer.OnViewerLeftDown(self, event)

   170

        elif self.Mode == MODE_SELECTION:

   171

            dc = self.GetLogicalDC()

   172

            pos = event.GetLogicalPosition(dc)

   173

            if event.ControlDown():

   174

                element = self.FindElement(pos, True)

   175

                if element and not self.IsWire(element):

   176

                    if isinstance(self.SelectedElement, Graphic_Group):

   177

                        self.SelectedElement.SelectElement(element)

   178

                    else:

   179

                        group = Graphic_Group(self)

   180

                        self.SelectedElement.SetSelected(False)

   181

                        group.SelectElement(self.SelectedElement)

   182

                        group.SelectElement(element)

   183

                        self.SelectedElement = group

   184

                    elements = self.SelectedElement.GetElements()

   185

                    if len(elements) == 0:

   186

                        self.SelectedElement = element

   187

                    elif len(elements) == 1:

   188

                        self.SelectedElement = elements[0]

   189

            else:

   190

                element = self.FindElement(pos)

   191

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

   192

                    if self.IsWire(self.SelectedElement):

   193

                        self.SelectedElement.SetSelectedSegment(None)

   194

                    else:

   195

                        self.SelectedElement.SetSelected(False)

   196

                    self.SelectedElement = None

   197

                    self.Refresh()

   198

                if element:

   199

                    self.SelectedElement = element

   200

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

   201

                    self.Refresh()

   202

                else:

   203

                    self.rubberBand.Reset()

   204

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

   205

        elif self.Mode == MODE_COMMENT:

   206

            self.rubberBand.Reset()

   207

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

   208

        elif self.Mode == MODE_WIRE:

   209

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

   210

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

   211

            wire.oldPos = pos

   212

            wire.Handle = (HANDLE_POINT, 0)

   213

            wire.ProcessDragging(0, 0)

   214

            wire.Handle = (HANDLE_POINT, 1)

   215

            self.AddWire(wire)

   216

            if self.SelectedElement:

   217

                self.SelectedElement.SetSelected(False)

   218

            self.SelectedElement = wire

   219

            self.Refresh()

   220

        event.Skip()

   221

   222

    def OnViewerLeftUp(self, event):

   223

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   224

            Viewer.OnViewerLeftUp(self, event)

   225

        elif self.rubberBand.IsShown():

   226

            if self.Mode == MODE_SELECTION:

   227

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

   228

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

   229

                if len(elements) > 0:

   230

                    self.SelectedElement = Graphic_Group(self)

   231

                    self.SelectedElement.SetElements(elements)

   232

                    self.SelectedElement.SetSelected(True)

   233

                    self.Refresh()

   234

            elif self.Mode == MODE_COMMENT:

   235

                bbox = self.rubberBand.GetCurrentExtent()

   236

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

   237

                wxCallAfter(self.AddComment, bbox)

   238

        elif self.Mode == MODE_INITIALSTEP:

   239

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

   240

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

   241

            if self.IsWire(self.SelectedElement):

   242

                self.SelectedElement.SetSelectedSegment(0)

   243

            else:

   244

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

   245

            wxCallAfter(self.SetCursor, wxNullCursor)

   246

            self.ReleaseMouse()

   247

            self.Refresh()

   248

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

   249

            self.SelectedElement.ResetPoints()

   250

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

   251

            self.SelectedElement.GeneratePoints()

   252

            self.SelectedElement.RefreshModel()

   253

            self.SelectedElement.SetSelected(True)

   254

            self.Refresh()

   255

        event.Skip()

   256

   257

    def OnViewerRightUp(self, event):

   258

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   259

            Viewer.OnViewerRightUp(self, event)

   260

        else:

   261

            dc = self.GetLogicalDC()

   262

            pos = event.GetLogicalPosition(dc)

   263

            element = self.FindElement(pos)

   264

            if element:

   265

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

   266

                    self.SelectedElement.SetSelected(False)

   267

                self.SelectedElement = element

   268

                if self.IsWire(self.SelectedElement):

   269

                    self.SelectedElement.SetSelectedSegment(0)

   270

                else:

   271

                    self.SelectedElement.SetSelected(True)

   272

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

   273

                wxCallAfter(self.SetCursor, wxNullCursor)

   274

                self.ReleaseMouse()

   275

                self.Refresh()

   276

        event.Skip()

   277

   278

    def OnViewerLeftDClick(self, event):

   279

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   280

            Viewer.OnViewerLeftDClick(self, event)

   281

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

   282

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

   283

            self.Refresh()

   284

        event.Skip()

   285

   286

    def OnViewerMotion(self, event):

   287

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   288

            Viewer.OnViewerMotion(self, event)

   289

        elif self.rubberBand.IsShown():

   290

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

   291

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

   292

            if not self.IsWire(self.SelectedElement):

   293

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

   294

            self.Refresh()

   295

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

   296

            self.SelectedElement.ResetPoints()

   297

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

   298

            self.SelectedElement.GeneratePoints()

   299

            self.Refresh()

   300

        Viewer.OnViewerMotion(self, event)

   301

        event.Skip()

   302

   303

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

   304

#                          Keyboard event functions

   305

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

   306

   307

    def OnChar(self, event):

   308

        keycode = event.GetKeyCode()

   309

        if self.Scaling:

   310

            scaling = self.Scaling

   311

        else:

   312

            scaling = (8, 8)

   313

        if keycode == WXK_DELETE and self.SelectedElement:

   314

            self.SelectedElement.Delete()

   315

            self.SelectedElement = None

   316

        elif keycode == WXK_LEFT:

   317

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

   318

                self.Scroll(0, ypos)

   319

            elif event.ControlDown():

   320

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

   321

            elif self.SelectedElement:

   322

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

   323

        elif keycode == WXK_RIGHT:

   324

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

   325

                self.Scroll(xmax, ypos)

   326

            elif event.ControlDown():

   327

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

   328

            elif self.SelectedElement:

   329

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

   330

        elif keycode == WXK_UP:

   331

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

   332

                self.Scroll(xpos, 0)

   333

            elif event.ControlDown():

   334

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

   335

            elif self.SelectedElement:

   336

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

   337

        elif keycode == WXK_DOWN:

   338

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

   339

                self.Scroll(xpos, ymax)

   340

            elif event.ControlDown():

   341

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

   342

            elif self.SelectedElement:

   343

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

   344

        self.Refresh()

   345

   346

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

   347

#                          Adding element functions

   348

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

   349

   350

    def AddInitialStep(self, pos):

   351

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

   352

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

   353

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

   354

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

   355

        if dialog.ShowModal() == wxID_OK:

   356

            id = self.GetNewId()

   357

            name = dialog.GetValue()

   358

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

   359

            min_width, min_height = step.GetMinSize()

   360

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

   361

            width, height = step.GetSize()

   362

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

   363

            self.AddBlock(step)

   364

            self.Controler.AddCurrentElementEditingStep(id)

   365

            self.RefreshStepModel(step)

   366

            self.Parent.RefreshProjectTree()

   367

            self.Refresh()

   368

        dialog.Destroy()

   369

   370

    def AddStep(self):

   371

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

   372

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

   373

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

   374

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

   375

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

   376

            if dialog.ShowModal() == wxID_OK:

   377

                name = dialog.GetValue()

   378

                if self.IsWire(self.SelectedElement):

   379

                    self.SelectedElement.SetSelectedSegment(None)

   380

                    previous = self.SelectedElement.EndConnected

   381

                    next = self.SelectedElement.StartConnected

   382

                    self.SelectedElement.Clean()

   383

                    self.RemoveWire(self.SelectedElement)

   384

                else:

   385

                    connectors = self.SelectedElement.GetConnectors()

   386

                    if connectors["output"]:

   387

                        previous = connectors["output"]

   388

                        wires = previous.GetWires()

   389

                        if len(wires) != 1:

   390

                            return

   391

                        wire = wires[0][0]

   392

                        next = wire.StartConnected

   393

                        wire.Clean()

   394

                        self.RemoveWire(wire)

   395

                    else:

   396

                        self.SelectedElement.AddOutput()

   397

                        connectors = self.SelectedElement.GetConnectors()

   398

                        self.RefreshStepModel(self.SelectedElement)

   399

                        previous = connectors["output"]

   400

                        next = None

   401

                previous_block = previous.GetParentBlock()

   402

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

   403

                    transition = self.CreateTransition(previous)

   404

                    transition_connectors = transition.GetConnectors()

   405

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

   406

                else:

   407

                    step = self.CreateStep(name, previous)

   408

                    step.AddOutput()

   409

                    step.RefreshModel()

   410

                    step_connectors = step.GetConnectors()

   411

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

   412

                if self.IsWire(self.SelectedElement):

   413

                    self.SelectedElement = wire

   414

                    self.SelectedElement.SetSelectedSegment(0)

   415

                else:

   416

                    self.SelectedElement.SetSelected(False)

   417

                    self.SelectedElement = step

   418

                    self.SelectedElement.SetSelected(True)

   419

                self.Parent.RefreshProjectTree()

   420

                self.Refresh()

   421

            dialog.Destroy()

   422

   423

    def AddStepAction(self):

   424

        if isinstance(self.SelectedElement, SFC_Step):

   425

            connectors = self.SelectedElement.GetConnectors()

   426

            if not connectors["action"]:

   427

                dialog = ActionBlockDialog(self.Parent)

   428

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

   429

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

   430

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

   431

                if dialog.ShowModal() == wxID_OK:

   432

                    actions = dialog.GetValues()

   433

                    self.SelectedElement.AddAction()

   434

                    self.RefreshStepModel(self.SelectedElement)

   435

                    connectors = self.SelectedElement.GetConnectors()

   436

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

   437

                    id = self.GetNewId()

   438

                    actionblock = SFC_ActionBlock(self, [], id)

   439

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

   440

                    actionblock_connector = actionblock.GetConnector()

   441

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

   442

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

   443

                    actionblock.SetActions(actions)

   444

                    self.AddBlock(actionblock)

   445

                    self.Controler.AddCurrentElementEditingActionBlock(id)

   446

                    self.RefreshActionBlockModel(actionblock)

   447

                    self.Refresh()

   448

                dialog.Destroy()

   449

   450

    def AddDivergence(self):

   451

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

   452

            dialog = DivergenceCreateDialog(self.Parent)

   453

            if dialog.ShowModal() == wxID_OK:

   454

                value = dialog.GetValues()

   455

                if value["type"] == SELECTION_DIVERGENCE:

   456

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

   457

                        self.SelectedElement.SetSelectedSegment(None)

   458

                        previous = self.SelectedElement.EndConnected

   459

                        next = self.SelectedElement.StartConnected

   460

                        self.SelectedElement.Clean()

   461

                        self.RemoveWire(self.SelectedElement)

   462

                        self.SelectedElement = None

   463

                    elif isinstance(self.SelectedElement, SFC_Step):

   464

                        connectors = self.SelectedElement.GetConnectors()

   465

                        if connectors["output"]:

   466

                            previous = connectors["output"]

   467

                            wires = previous.GetWires()

   468

                            if len(wires) != 1:

   469

                                return

   470

                            wire = wires[0][0]

   471

                            next = wire.StartConnected

   472

                            wire.Clean()

   473

                            self.RemoveWire(wire)

   474

                        else:

   475

                            self.SelectedElement.AddOutput()

   476

                            connectors = self.SelectedElement.GetConnectors()

   477

                            self.RefreshStepModel(self.SelectedElement)

   478

                            previous = connectors["output"]

   479

                            next = None

   480

                    else:

   481

                        return

   482

                    id = self.GetNewId()

   483

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

   484

                    pos = previous.GetPosition(False)

   485

                    previous_block = previous.GetParentBlock()

   486

                    wire_size = GetWireSize(previous_block)

   487

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

   488

                    divergence_connectors = divergence.GetConnectors()

   489

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

   490

                    previous_block.RefreshOutputPosition()

   491

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

   492

                    self.AddBlock(divergence)

   493

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

   494

                    self.RefreshDivergenceModel(divergence)

   495

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

   496

                        if next:

   497

                            wire = self.ConnectConnectors(next, connector)

   498

                            pos = connector.GetPosition(False)

   499

                            next_pos = next.GetPosition(False)

   500

                            next_block = next.GetParentBlock()

   501

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

   502

                            divergence.RefreshConnectedPosition(connector)

   503

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

   504

                            next_block.RefreshModel()

   505

                            next = None

   506

                        else:

   507

                            transition = self.CreateTransition(connector)

   508

                            transition_connectors = transition.GetConnectors()

   509

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

   510

                elif value["type"] == SIMULTANEOUS_DIVERGENCE:

   511

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

   512

                        self.SelectedElement.SetSelectedSegment(None)

   513

                        previous = self.SelectedElement.EndConnected

   514

                        next = self.SelectedElement.StartConnected

   515

                        self.SelectedElement.Clean()

   516