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

#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

import wx

    26

from types import *

    27

    28

from Viewer import *

    29

    30

class SFC_Viewer(Viewer):

    31

    32

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

    33

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

    34

    35

    def ConnectConnectors(self, start, end):

    36

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

    37

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

    38

        wire = Wire(self, startpoint, endpoint)

    39

        self.AddWire(wire)

    40

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

    41

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

    42

        wire.ConnectStartPoint(None, start)

    43

        wire.ConnectEndPoint(None, end)

    44

        return wire

    45

    46

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

    47

        previous = connector.GetParentBlock()

    48

        id = self.GetNewId()

    49

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

    50

        pos = connector.GetPosition(False)

    51

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

    52

        transition_connectors = transition.GetConnectors()

    53

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

    54

        if isinstance(previous, SFC_Divergence):

    55

            previous.RefreshConnectedPosition(connector)

    56

        else:

    57

            previous.RefreshOutputPosition()

    58

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

    59

        self.AddBlock(transition)

    60

        self.Controler.AddCurrentElementEditingTransition(id)

    61

        self.RefreshTransitionModel(transition)

    62

        if next:

    63

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

    64

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

    65

            next_block = next.GetParentBlock()

    66

            next_pos = next.GetPosition(False)

    67

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

    68

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

    69

            if isinstance(next_block, SFC_Divergence):

    70

                next_block.RefreshPosition()

    71

            transition.RefreshOutputModel(True)

    72

        return transition

    73

    74

    def RemoveTransition(self, transition):

    75

        connectors = transition.GetConnectors()

    76

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

    77

        if len(input_wires) != 1:

    78

            return

    79

        input_wire = input_wires[0][0]

    80

        previous = input_wire.EndConnected

    81

        input_wire.Clean()

    82

        self.RemoveWire(input_wire)

    83

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

    84

        if len(output_wires) != 1:

    85

            return

    86

        output_wire = output_wires[0][0]

    87

        next = output_wire.StartConnected

    88

        output_wire.Clean()

    89

        self.RemoveWire(output_wire)

    90

        transition.Clean()

    91

        self.RemoveBlock(transition)

    92

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

    93

        wire = self.ConnectConnectors(next, previous)

    94

        return wire

    95

    96

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

    97

        previous = connector.GetParentBlock()

    98

        id = self.GetNewId()

    99

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

   100

        if next:

   101

            step.AddOutput()

   102

        min_width, min_height = step.GetMinSize()

   103

        pos = connector.GetPosition(False)

   104

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

   105

        step.SetSize(min_width, min_height)

   106

        step_connectors = step.GetConnectors()

   107

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

   108

        if isinstance(previous, SFC_Divergence):

   109

            previous.RefreshConnectedPosition(connector)

   110

        else:

   111

            previous.RefreshOutputPosition()

   112

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

   113

        self.AddBlock(step)

   114

        self.Controler.AddCurrentElementEditingStep(id)

   115

        self.RefreshStepModel(step)

   116

        if next:

   117

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

   118

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

   119

            next_block = next.GetParentBlock()

   120

            next_pos = next.GetPosition(False)

   121

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

   122

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

   123

            if isinstance(next_block, SFC_Divergence):

   124

                next_block.RefreshPosition()

   125

            step.RefreshOutputModel(True)

   126

        return step

   127

   128

    def RemoveStep(self, step):

   129

        connectors = step.GetConnectors()

   130

        if connectors["input"]:

   131

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

   132

            if len(input_wires) != 1:

   133

                return

   134

            input_wire = input_wires[0][0]

   135

            previous = input_wire.EndConnected

   136

            input_wire.Clean()

   137

            self.RemoveWire(input_wire)

   138

        else:

   139

            previous = None

   140

        if connectors["output"]:

   141

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

   142

            if len(output_wires) != 1:

   143

                return

   144

            output_wire = output_wires[0][0]

   145

            next = output_wire.StartConnected

   146

            output_wire.Clean()

   147

            self.RemoveWire(output_wire)

   148

        else:

   149

            next = None

   150

        action = step.GetActionConnector()

   151

        if action:

   152

            self.DeleteActionBlock(action.GetParentBlock())

   153

        step.Clean()

   154

        self.RemoveBlock(step)

   155

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

   156

        if next and previous:

   157

            wire = self.ConnectConnectors(next, previous)

   158

            return wire

   159

        else:

   160

            return None

   161

   162

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

   163

#                          Mouse event functions

   164

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

   165

   166

    def OnViewerLeftDown(self, event):

   167

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   168

            Viewer.OnViewerLeftDown(self, event)

   169

        elif self.Mode == MODE_SELECTION:

   170

            dc = self.GetLogicalDC()

   171

            pos = event.GetLogicalPosition(dc)

   172

            if event.ControlDown():

   173

                element = self.FindElement(pos, True)

   174

                if element and not self.IsWire(element):

   175

                    if isinstance(self.SelectedElement, Graphic_Group):

   176

                        self.SelectedElement.SelectElement(element)

   177

                    else:

   178

                        group = Graphic_Group(self)

   179

                        self.SelectedElement.SetSelected(False)

   180

                        group.SelectElement(self.SelectedElement)

   181

                        group.SelectElement(element)

   182

                        self.SelectedElement = group

   183

                    elements = self.SelectedElement.GetElements()

   184

                    if len(elements) == 0:

   185

                        self.SelectedElement = element

   186

                    elif len(elements) == 1:

   187

                        self.SelectedElement = elements[0]

   188

            else:

   189

                element = self.FindElement(pos)

   190

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

   191

                    if self.IsWire(self.SelectedElement):

   192

                        self.SelectedElement.SetSelectedSegment(None)

   193

                    else:

   194

                        self.SelectedElement.SetSelected(False)

   195

                    self.SelectedElement = None

   196

                    self.Refresh()

   197

                if element:

   198

                    self.SelectedElement = element

   199

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

   200

                    self.Refresh()

   201

                else:

   202

                    self.rubberBand.Reset()

   203

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

   204

        elif self.Mode == MODE_COMMENT:

   205

            self.rubberBand.Reset()

   206

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

   207

        elif self.Mode == MODE_WIRE:

   208

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

   209

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

   210

            wire.oldPos = pos

   211

            wire.Handle = (HANDLE_POINT, 0)

   212

            wire.ProcessDragging(0, 0)

   213

            wire.Handle = (HANDLE_POINT, 1)

   214

            self.AddWire(wire)

   215

            if self.SelectedElement:

   216

                self.SelectedElement.SetSelected(False)

   217

            self.SelectedElement = wire

   218

            self.Refresh()

   219

        event.Skip()

   220

   221

    def OnViewerLeftUp(self, event):

   222

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   223

            Viewer.OnViewerLeftUp(self, event)

   224

        elif self.rubberBand.IsShown():

   225

            if self.Mode == MODE_SELECTION:

   226

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

   227

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

   228

                if len(elements) > 0:

   229

                    self.SelectedElement = Graphic_Group(self)

   230

                    self.SelectedElement.SetElements(elements)

   231

                    self.SelectedElement.SetSelected(True)

   232

                    self.Refresh()

   233

            elif self.Mode == MODE_COMMENT:

   234

                bbox = self.rubberBand.GetCurrentExtent()

   235

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

   236

                wx.CallAfter(self.AddComment, bbox)

   237

        elif self.Mode == MODE_INITIALSTEP:

   238

            wx.CallAfter(self.AddInitialStep, GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling))

   239

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

   240

            if self.IsWire(self.SelectedElement):

   241

                self.SelectedElement.SetSelectedSegment(0)

   242

            else:

   243

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

   244

            wx.CallAfter(self.SetCursor, wx.NullCursor)

   245

            self.ReleaseMouse()

   246

            self.Refresh()

   247

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

   248

            self.SelectedElement.ResetPoints()

   249

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

   250

            self.SelectedElement.GeneratePoints()

   251

            self.SelectedElement.RefreshModel()

   252

            self.SelectedElement.SetSelected(True)

   253

            self.Refresh()

   254

        event.Skip()

   255

   256

    def OnViewerRightUp(self, event):

   257

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   258

            Viewer.OnViewerRightUp(self, event)

   259

        else:

   260

            dc = self.GetLogicalDC()

   261

            pos = event.GetLogicalPosition(dc)

   262

            element = self.FindElement(pos)

   263

            if element:

   264

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

   265

                    self.SelectedElement.SetSelected(False)

   266

                self.SelectedElement = element

   267

                if self.IsWire(self.SelectedElement):

   268

                    self.SelectedElement.SetSelectedSegment(0)

   269

                else:

   270

                    self.SelectedElement.SetSelected(True)

   271

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

   272

                wx.CallAfter(self.SetCursor, wx.NullCursor)

   273

                self.ReleaseMouse()

   274

                self.Refresh()

   275

        event.Skip()

   276

   277

    def OnViewerLeftDClick(self, event):

   278

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   279

            Viewer.OnViewerLeftDClick(self, event)

   280

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

   281

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

   282

            self.Refresh()

   283

        event.Skip()

   284

   285

    def OnViewerMotion(self, event):

   286

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   287

            Viewer.OnViewerMotion(self, event)

   288

        elif self.rubberBand.IsShown():

   289

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

   290

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

   291

            if not self.IsWire(self.SelectedElement):

   292

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

   293

            self.Refresh()

   294

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

   295

            self.SelectedElement.ResetPoints()

   296

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

   297

            self.SelectedElement.GeneratePoints()

   298

            self.Refresh()

   299

        Viewer.OnViewerMotion(self, event)

   300

        event.Skip()

   301

   302

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

   303

#                          Keyboard event functions

   304

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

   305

   306

    def OnChar(self, event):

   307

        xpos, ypos = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL)

   308

        xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)

   309

        ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)

   310

        keycode = event.GetKeyCode()

   311

        if self.Scaling:

   312

            scaling = self.Scaling

   313

        else:

   314

            scaling = (8, 8)

   315

        if keycode == wx.WXK_DELETE and self.SelectedElement:

   316

            self.SelectedElement.Delete()

   317

            self.SelectedElement = None

   318

            self.RefreshBuffer()

   319

            self.RefreshScrollBars()

   320

            self.Refresh()

   321

        elif keycode == wx.WXK_LEFT:

   322

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

   323

                self.Scroll(0, ypos)

   324

            elif event.ControlDown():

   325

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

   326

            elif self.SelectedElement:

   327

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

   329

                self.RefreshBuffer()

   330

                self.RefreshScrollBars()

   331

                self.Refresh()

   332

        elif keycode == wx.WXK_RIGHT:

   333

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

   334

                self.Scroll(xmax, ypos)

   335

            elif event.ControlDown():

   336

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

   337

            elif self.SelectedElement:

   338

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

   340

                self.RefreshBuffer()

   341

                self.RefreshScrollBars()

   342

                self.Refresh()

   343

        elif keycode == wx.WXK_UP:

   344

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

   345

                self.Scroll(xpos, 0)

   346

            elif event.ControlDown():

   347

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

   348

            elif self.SelectedElement:

   349

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

   351

                self.RefreshBuffer()

   352

                self.RefreshScrollBars()

   353

                self.Refresh()

   354

        elif keycode == wx.WXK_DOWN:

   355

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

   356

                self.Scroll(xpos, ymax)

   357

            elif event.ControlDown():

   358

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

   359

            elif self.SelectedElement:

   360

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

   362

                self.RefreshBuffer()

   363

                self.RefreshScrollBars()

   364

                self.Refresh()

   365

   366

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

   367

#                          Adding element functions

   368

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

   369

   370

    def AddInitialStep(self, pos):

   371

        dialog = StepNameDialog(self.Parent, "Add a new initial step", "Please enter step name", "", wx.OK|wx.CANCEL)

   372

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

   373

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

   374

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

   375

        if dialog.ShowModal() == wx.ID_OK:

   376

            id = self.GetNewId()

   377

            name = dialog.GetValue()

   378

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

   379

            min_width, min_height = step.GetMinSize()

   380

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

   381

            width, height = step.GetSize()

   382

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

   383

            self.AddBlock(step)

   384

            self.Controler.AddCurrentElementEditingStep(id)

   385

            self.RefreshStepModel(step)

   386

            self.Parent.RefreshProjectTree()

   387

            self.RefreshBuffer()

   388

            self.RefreshScrollBars()

   389

            self.Refresh()

   390

        dialog.Destroy()

   391

   392

    def AddStep(self):

   393

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

   394

            dialog = StepNameDialog(self.Parent, "Add a new step", "Please enter step name", "", wx.OK|wx.CANCEL)

   395

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

   396

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

   397

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

   398

            if dialog.ShowModal() == wx.ID_OK:

   399

                name = dialog.GetValue()

   400

                if self.IsWire(self.SelectedElement):

   401

                    self.SelectedElement.SetSelectedSegment(None)

   402

                    previous = self.SelectedElement.EndConnected

   403

                    next = self.SelectedElement.StartConnected

   404

                    self.SelectedElement.Clean()

   405

                    self.RemoveWire(self.SelectedElement)

   406

                else:

   407

                    connectors = self.SelectedElement.GetConnectors()

   408

                    if connectors["output"]:

   409

                        previous = connectors["output"]

   410

                        wires = previous.GetWires()

   411

                        if len(wires) != 1:

   412

                            return

   413

                        wire = wires[0][0]

   414

                        next = wire.StartConnected

   415

                        wire.Clean()

   416

                        self.RemoveWire(wire)

   417

                    else:

   418

                        self.SelectedElement.AddOutput()

   419

                        connectors = self.SelectedElement.GetConnectors()

   420

                        self.RefreshStepModel(self.SelectedElement)

   421

                        previous = connectors["output"]

   422

                        next = None

   423

                previous_block = previous.GetParentBlock()

   424

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

   425

                    transition = self.CreateTransition(previous)

   426

                    transition_connectors = transition.GetConnectors()

   427

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

   428

                else:

   429

                    step = self.CreateStep(name, previous)

   430

                    step.AddOutput()

   431

                    step.RefreshModel()

   432

                    step_connectors = step.GetConnectors()

   433

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

   434

                if self.IsWire(self.SelectedElement):

   435

                    self.SelectedElement = wire

   436

                    self.SelectedElement.SetSelectedSegment(0)

   437

                else:

   438

                    self.SelectedElement.SetSelected(False)

   439

                    self.SelectedElement = step

   440

                    self.SelectedElement.SetSelected(True)

   441

                self.Parent.RefreshProjectTree()

   442

                self.RefreshBuffer()

   443

                self.RefreshScrollBars()

   444

                self.Refresh()

   445

            dialog.Destroy()

   446

   447

    def AddStepAction(self):

   448

        if isinstance(self.SelectedElement, SFC_Step):

   449

            connectors = self.SelectedElement.GetConnectors()

   450

            if not connectors["action"]:

   451

                dialog = ActionBlockDialog(self.Parent)

   452

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

   453

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

   454

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

   455

                if dialog.ShowModal() == wx.ID_OK:

   456

                    actions = dialog.GetValues()

   457

                    self.SelectedElement.AddAction()

   458

                    self.RefreshStepModel(self.SelectedElement)

   459

                    connectors = self.SelectedElement.GetConnectors()

   460

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

   461

                    id = self.GetNewId()

   462

                    actionblock = SFC_ActionBlock(self, [], id)

   463

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

   464

                    actionblock_connector = actionblock.GetConnector()

   465

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

   466

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

   467

                    actionblock.SetActions(actions)

   468

                    self.AddBlock(actionblock)

   469

                    self.Controler.AddCurrentElementEditingActionBlock(id)

   470

                    self.RefreshActionBlockModel(actionblock)

   471

                    self.RefreshBuffer()

   472

                    self.RefreshScrollBars()

   473

                    self.Refresh()

   474

                dialog.Destroy()

   475

   476

    def AddDivergence(self):

   477

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

   478

            dialog = DivergenceCreateDialog(self.Parent)

   479

            if dialog.ShowModal() == wx.ID_OK:

   480

                value = dialog.GetValues()

   481

                if value["type"] == SELECTION_DIVERGENCE:

   482

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

   483

                        self.SelectedElement.SetSelectedSegment(None)

   484

                        previous = self.SelectedElement.EndConnected

   485

                        next = self.SelectedElement.StartConnected

   486

                        self.SelectedElement.Clean()

   487

                        self.RemoveWire(self.SelectedElement)

   488

                        self.SelectedElement = None

   489

                    elif isinstance(self.SelectedElement, SFC_Step):

   490

                        connectors = self.SelectedElement.GetConnectors()

   491

                        if connectors["output"]:

   492

                            previous = connectors["output"]

   493

                            wires = previous.GetWires()

   494

                            if len(wires) != 1:

   495

                                return

   496

                            wire = wires[0][0]

   497

                            next = wire.StartConnected

   498

                            wire.Clean()

   499

                            self.RemoveWire(wire)

   500

                        else:

   501

                            self.SelectedElement.AddOutput()

   502

                            connectors = self.SelectedElement.GetConnectors()

   503

                            self.RefreshStepModel(self.SelectedElement)

   504

                            previous = connectors["output"]

   505

                            next = None

   506

                    else:

   507

                        return

   508

                    id = self.GetNewId()

   509

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

   510

                    pos = previous.GetPosition(False)