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

if wx.VERSION >= (2, 8, 0):

    31

    import wx.aui

    32

    33

    class SFC_MDIViewer(wx.aui.AuiMDIChildFrame):

    34

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

    35

            wx.aui.AuiMDIChildFrame.__init__(self, parent, -1, title = "")

    36

    37

            sizer = wx.BoxSizer(wx.HORIZONTAL)

    38

    39

            self.Viewer = SFC_Viewer(self, tagname, window, controler)

    40

    41

            sizer.AddWindow(self.Viewer, 1, border=0, flag=wx.GROW)

    42

    43

            self.SetSizer(sizer)

    44

    45

        def GetViewer(self):

    46

            return self.Viewer

    47

    48

class SFC_Viewer(Viewer):

    49

    50

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

    51

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

    52

        self.CurrentLanguage = "SFC"

    53

    54

    def ConnectConnectors(self, start, end):

    55

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

    56

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

    57

        wire = Wire(self, startpoint, endpoint)

    58

        self.AddWire(wire)

    59

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

    60

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

    61

        wire.ConnectStartPoint(None, start)

    62

        wire.ConnectEndPoint(None, end)

    63

        return wire

    64

    65

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

    66

        previous = connector.GetParentBlock()

    67

        id = self.GetNewId()

    68

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

    69

        pos = connector.GetPosition(False)

    70

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

    71

        transition_connectors = transition.GetConnectors()

    72

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

    73

        if isinstance(previous, SFC_Divergence):

    74

            previous.RefreshConnectedPosition(connector)

    75

        else:

    76

            previous.RefreshOutputPosition()

    77

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

    78

        self.AddBlock(transition)

    79

        self.Controler.AddEditedElementTransition(self.TagName, id)

    80

        self.RefreshTransitionModel(transition)

    81

        if next:

    82

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

    83

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

    84

            next_block = next.GetParentBlock()

    85

            next_pos = next.GetPosition(False)

    86

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

    87

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

    88

            if isinstance(next_block, SFC_Divergence):

    89

                next_block.RefreshPosition()

    90

            transition.RefreshOutputModel(True)

    91

        return transition

    92

    93

    def RemoveTransition(self, transition):

    94

        connectors = transition.GetConnectors()

    95

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

    96

        if len(input_wires) != 1:

    97

            return

    98

        input_wire = input_wires[0][0]

    99

        previous = input_wire.EndConnected

   100

        input_wire.Clean()

   101

        self.RemoveWire(input_wire)

   102

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

   103

        if len(output_wires) != 1:

   104

            return

   105

        output_wire = output_wires[0][0]

   106

        next = output_wire.StartConnected

   107

        output_wire.Clean()

   108

        self.RemoveWire(output_wire)

   109

        transition.Clean()

   110

        self.RemoveBlock(transition)

   111

        self.Controler.RemoveEditedElementInstance(self.TagName, transition.GetId())

   112

        wire = self.ConnectConnectors(next, previous)

   113

        return wire

   114

   115

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

   116

        previous = connector.GetParentBlock()

   117

        id = self.GetNewId()

   118

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

   119

        if next:

   120

            step.AddOutput()

   121

        min_width, min_height = step.GetMinSize()

   122

        pos = connector.GetPosition(False)

   123

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

   124

        step.SetSize(min_width, min_height)

   125

        step_connectors = step.GetConnectors()

   126

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

   127

        if isinstance(previous, SFC_Divergence):

   128

            previous.RefreshConnectedPosition(connector)

   129

        else:

   130

            previous.RefreshOutputPosition()

   131

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

   132

        self.AddBlock(step)

   133

        self.Controler.AddEditedElementStep(self.TagName, id)

   134

        self.RefreshStepModel(step)

   135

        if next:

   136

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

   137

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

   138

            next_block = next.GetParentBlock()

   139

            next_pos = next.GetPosition(False)

   140

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

   141

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

   142

            if isinstance(next_block, SFC_Divergence):

   143

                next_block.RefreshPosition()

   144

            step.RefreshOutputModel(True)

   145

        return step

   146

   147

    def RemoveStep(self, step):

   148

        connectors = step.GetConnectors()

   149

        if connectors["input"]:

   150

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

   151

            if len(input_wires) != 1:

   152

                return

   153

            input_wire = input_wires[0][0]

   154

            previous = input_wire.EndConnected

   155

            input_wire.Clean()

   156

            self.RemoveWire(input_wire)

   157

        else:

   158

            previous = None

   159

        if connectors["output"]:

   160

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

   161

            if len(output_wires) != 1:

   162

                return

   163

            output_wire = output_wires[0][0]

   164

            next = output_wire.StartConnected

   165

            output_wire.Clean()

   166

            self.RemoveWire(output_wire)

   167

        else:

   168

            next = None

   169

        action = step.GetActionConnector()

   170

        if action:

   171

            self.DeleteActionBlock(action.GetParentBlock())

   172

        step.Clean()

   173

        self.RemoveBlock(step)

   174

        self.Controler.RemoveEditedElementInstance(self.TagName, step.GetId())

   175

        if next and previous:

   176

            wire = self.ConnectConnectors(next, previous)

   177

            return wire

   178

        else:

   179

            return None

   180

   181

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

   182

#                          Mouse event functions

   183

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

   184

   185

    def OnViewerLeftDown(self, event):

   186

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   187

            Viewer.OnViewerLeftDown(self, event)

   188

        elif self.Mode == MODE_SELECTION:

   189

            dc = self.GetLogicalDC()

   190

            pos = event.GetLogicalPosition(dc)

   191

            if event.ControlDown():

   192

                element = self.FindElement(pos, True)

   193

                if element and not self.IsWire(element):

   194

                    if isinstance(self.SelectedElement, Graphic_Group):

   195

                        self.SelectedElement.SelectElement(element)

   196

                    else:

   197

                        group = Graphic_Group(self)

   198

                        self.SelectedElement.SetSelected(False)

   199

                        group.SelectElement(self.SelectedElement)

   200

                        group.SelectElement(element)

   201

                        self.SelectedElement = group

   202

                    elements = self.SelectedElement.GetElements()

   203

                    if len(elements) == 0:

   204

                        self.SelectedElement = element

   205

                    elif len(elements) == 1:

   206

                        self.SelectedElement = elements[0]

   207

            else:

   208

                element = self.FindElement(pos)

   209

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

   210

                    if self.IsWire(self.SelectedElement):

   211

                        self.SelectedElement.SetSelectedSegment(None)

   212

                    else:

   213

                        self.SelectedElement.SetSelected(False)

   214

                    self.SelectedElement = None

   215

                if element:

   216

                    self.SelectedElement = element

   217

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

   218

                    self.SelectedElement.Refresh()

   219

                else:

   220

                    self.rubberBand.Reset()

   221

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

   222

        elif self.Mode == MODE_COMMENT:

   223

            self.rubberBand.Reset()

   224

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

   225

        event.Skip()

   226

   227

    def OnViewerLeftUp(self, event):

   228

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   229

            Viewer.OnViewerLeftUp(self, event)

   230

        elif self.rubberBand.IsShown():

   231

            if self.Mode == MODE_SELECTION:

   232

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

   233

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

   234

                if len(elements) > 0:

   235

                    self.SelectedElement = Graphic_Group(self)

   236

                    self.SelectedElement.SetElements(elements)

   237

                    self.SelectedElement.SetSelected(True)

   238

            elif self.Mode == MODE_COMMENT:

   239

                bbox = self.rubberBand.GetCurrentExtent()

   240

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

   241

                wx.CallAfter(self.AddComment, bbox)

   242

        elif self.Mode == MODE_INITIALSTEP:

   243

            wx.CallAfter(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

                self.SelectedElement.Refresh()

   250

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

   251

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

   252

            self.SelectedElement.ResetPoints()

   253

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

   254

            self.SelectedElement.GeneratePoints()

   255

            self.SelectedElement.RefreshModel()

   256

            self.SelectedElement.SetSelected(True)

   257

        event.Skip()

   258

   259

    def OnViewerRightUp(self, event):

   260

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   261

            Viewer.OnViewerRightUp(self, event)

   262

        else:

   263

            dc = self.GetLogicalDC()

   264

            pos = event.GetLogicalPosition(dc)

   265

            element = self.FindElement(pos)

   266

            if element:

   267

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

   268

                    self.SelectedElement.SetSelected(False)

   269

                self.SelectedElement = element

   270

                if self.IsWire(self.SelectedElement):

   271

                    self.SelectedElement.SetSelectedSegment(0)

   272

                else:

   273

                    self.SelectedElement.SetSelected(True)

   274

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

   275

                    self.SelectedElement.Refresh()

   276

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

   277

        event.Skip()

   278

   279

    def OnViewerLeftDClick(self, event):

   280

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   281

            Viewer.OnViewerLeftDClick(self, event)

   282

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

   283

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

   284

            self.Refresh(False)

   285

        event.Skip()

   286

   287

    def OnViewerMotion(self, event):

   288

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   289

            Viewer.OnViewerMotion(self, event)

   290

        else:

   291

            if self.rubberBand.IsShown():

   292

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

   293

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

   294

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

   295

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

   296

                    self.SelectedElement.Refresh()

   297

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

   298

                self.SelectedElement.ResetPoints()

   299

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

   300

                self.SelectedElement.GeneratePoints()

   301

                self.SelectedElement.Refresh()

   302

            self.UpdateScrollPos(event)

   303

        event.Skip()

   304

   305

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

   306

#                          Keyboard event functions

   307

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

   308

   309

    def OnChar(self, event):

   310

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

   311

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

   312

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

   313

        keycode = event.GetKeyCode()

   314

        if self.Scaling:

   315

            scaling = self.Scaling

   316

        else:

   317

            scaling = (8, 8)

   318

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

   319

            self.SelectedElement.Delete()

   320

            self.SelectedElement = None

   321

            self.RefreshBuffer()

   322

            self.RefreshScrollBars()

   323

            self.Refresh(False)

   324

        elif keycode == wx.WXK_LEFT:

   325

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

   326

                self.Scroll(0, ypos)

   327

            elif event.ControlDown():

   328

                event.Skip()

   329

            elif self.SelectedElement:

   330

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

   331

                self.SelectedElement.RefreshModel()

   332

                self.RefreshBuffer()

   333

                self.RefreshScrollBars()

   334

                self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(-scaling[0], 0)), False)

   335

        elif keycode == wx.WXK_RIGHT:

   336

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

   337

                self.Scroll(xmax, ypos)

   338

            elif event.ControlDown():

   339

                event.Skip()

   340

            elif self.SelectedElement:

   341

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

   342

                self.SelectedElement.RefreshModel()

   343

                self.RefreshBuffer()

   344

                self.RefreshScrollBars()

   345

                self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(scaling[0], 0)), False)

   346

        elif keycode == wx.WXK_UP:

   347

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

   348

                self.Scroll(xpos, 0)

   349

            elif event.ControlDown():

   350

                event.Skip()

   351

            elif self.SelectedElement:

   352

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

   353

                self.SelectedElement.RefreshModel()

   354

                self.RefreshBuffer()

   355

                self.RefreshScrollBars()

   356

                self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(0, -scaling[1])), False)

   357

        elif keycode == wx.WXK_DOWN:

   358

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

   359

                self.Scroll(xpos, ymax)

   360

            elif event.ControlDown():

   361

                event.Skip()

   362

            elif self.SelectedElement:

   363

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

   364

                self.SelectedElement.RefreshModel()

   365

                self.RefreshBuffer()

   366

                self.RefreshScrollBars()

   367

                self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(0, scaling[1])), False)

   368

        else:

   369

            event.Skip()

   370

   371

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

   372

#                          Adding element functions

   373

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

   374

   375

    def AddInitialStep(self, pos):

   376

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

   377

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

   378

        dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName))

   379

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

   380

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

   381

            id = self.GetNewId()

   382

            name = dialog.GetValue()

   383

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

   384

            min_width, min_height = step.GetMinSize()

   385

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

   386

            width, height = step.GetSize()

   387

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

   388

            self.AddBlock(step)

   389

            self.Controler.AddEditedElementStep(self.TagName, id)

   390

            self.RefreshStepModel(step)

   391

            self.RefreshBuffer()

   392

            self.RefreshScrollBars()

   393

            self.Refresh(False)

   394

        dialog.Destroy()

   395

   396

    def AddStep(self):

   397

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

   398

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

   399

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

   400

            dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName))

   401

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

   402

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

   403

                name = dialog.GetValue()

   404

                if self.IsWire(self.SelectedElement):

   405

                    self.SelectedElement.SetSelectedSegment(None)

   406

                    previous = self.SelectedElement.EndConnected

   407

                    next = self.SelectedElement.StartConnected

   408

                    self.SelectedElement.Clean()

   409

                    self.RemoveWire(self.SelectedElement)

   410

                else:

   411

                    connectors = self.SelectedElement.GetConnectors()

   412

                    if connectors["output"]:

   413

                        previous = connectors["output"]

   414

                        wires = previous.GetWires()

   415

                        if len(wires) != 1:

   416

                            return

   417

                        wire = wires[0][0]

   418

                        next = wire.StartConnected

   419

                        wire.Clean()

   420

                        self.RemoveWire(wire)

   421

                    else:

   422

                        self.SelectedElement.AddOutput()

   423

                        connectors = self.SelectedElement.GetConnectors()

   424

                        self.RefreshStepModel(self.SelectedElement)

   425

                        previous = connectors["output"]

   426

                        next = None

   427

                previous_block = previous.GetParentBlock()

   428

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

   429

                    transition = self.CreateTransition(previous)

   430

                    transition_connectors = transition.GetConnectors()

   431

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

   432

                else:

   433

                    step = self.CreateStep(name, previous)

   434

                    step.AddOutput()

   435

                    step.RefreshModel()

   436

                    step_connectors = step.GetConnectors()

   437

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

   438

                if self.IsWire(self.SelectedElement):

   439

                    self.SelectedElement = wire

   440

                    self.SelectedElement.SetSelectedSegment(0)

   441

                else:

   442

                    self.SelectedElement.SetSelected(False)

   443

                    self.SelectedElement = step

   444

                    self.SelectedElement.SetSelected(True)

   445

                self.RefreshBuffer()

   446

                self.RefreshScrollBars()

   447

                self.Refresh(False)

   448

            dialog.Destroy()

   449

   450

    def AddStepAction(self):

   451

        if isinstance(self.SelectedElement, SFC_Step):

   452

            connectors = self.SelectedElement.GetConnectors()

   453

            if not connectors["action"]:

   454

                dialog = ActionBlockDialog(self.ParentWindow)

   455

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

   456

                dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName))

   457

                dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName))

   458

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

   459

                    actions = dialog.GetValues()

   460

                    self.SelectedElement.AddAction()

   461

                    self.RefreshStepModel(self.SelectedElement)

   462

                    connectors = self.SelectedElement.GetConnectors()

   463

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

   464

                    id = self.GetNewId()

   465

                    actionblock = SFC_ActionBlock(self, [], id)

   466

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

   467

                    actionblock_connector = actionblock.GetConnector()

   468

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

   469

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

   470

                    actionblock.SetActions(actions)

   471

                    self.AddBlock(actionblock)

   472

                    self.Controler.AddEditedElementActionBlock(self.TagName, id)

   473

                    self.RefreshActionBlockModel(actionblock)

   474

                    self.RefreshBuffer()

   475

                    self.RefreshScrollBars()

   476

                    self.Refresh(False)

   477

                dialog.Destroy()

   478

   479

    def AddDivergence(self):

   480

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

   481

            dialog = DivergenceCreateDialog(self.ParentWindow)

   482

            dialog.SetPreviewFont(self.GetFont())

   483

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

   484

                value = dialog.GetValues()

   485

                if value["type"] == SELECTION_DIVERGENCE:

   486

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

   487

                        self.SelectedElement.SetSelectedSegment(None)

   488

                        previous = self.SelectedElement.EndConnected

   489

                        next = self.SelectedElement.StartConnected

   490

                        self.SelectedElement.Clean()

   491

                        self.RemoveWire(self.SelectedElement)

   492

                        self.SelectedElement = None

   493

                    elif isinstance(self.SelectedElement, SFC_Step):

   494

                        connectors = self.SelectedElement.GetConnectors()

   495

                        if connectors["output"]:

   496

                            previous = connectors["output"]

   497

                            wires = previous.GetWires()

   498

                            if len(wires) != 1:

   499

                                return

   500

                            wire = wires[0][0]

   501

                            next = wire.StartConnected

   502

                            wire.Clean()

   503

                            self.RemoveWire(wire)

   504

                        else: