1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

from types import *

    26

    27

import wx

    28

    29

from Viewer import *

    30

from graphics.SFC_Objects import *

    31

from graphics.GraphicCommons import SELECTION_DIVERGENCE, \

    32

    SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE, EAST, NORTH, WEST, SOUTH

    33

    34

SFC_Objects = (SFC_Step, SFC_ActionBlock, SFC_Transition, SFC_Divergence, SFC_Jump)

    35

    36

    37

class SFC_Viewer(Viewer):

    38

    39

    SFC_StandardRules = {

    40

        # The key of this dict is a block that user try to connect,

    41

        # and the value is a list of blocks, that can be connected with the current block

    42

        # and with directions of connection

    43

        "SFC_Step": [("SFC_ActionBlock", EAST),

    44

                     ("SFC_Transition", SOUTH),

    45

                     (SELECTION_DIVERGENCE, SOUTH),

    46

                     (SIMULTANEOUS_CONVERGENCE, SOUTH)],

    47

    48

        "SFC_ActionBlock": [("SFC_Step", EAST)],

    49

    50

        "SFC_Transition": [("SFC_Step", SOUTH),

    51

                           (SELECTION_CONVERGENCE, SOUTH),

    52

                           (SIMULTANEOUS_DIVERGENCE, SOUTH),

    53

                           ("SFC_Jump", SOUTH),

    54

                           ("FBD_Block", EAST),

    55

                           ("FBD_Variable", EAST),

    56

                           ("FBD_Connector", EAST),

    57

                           ("LD_Contact", EAST),

    58

                           ("LD_PowerRail", EAST),

    59

                           ("LD_Coil", EAST)],

    60

    61

        SELECTION_DIVERGENCE: [("SFC_Transition", SOUTH)],

    62

    63

        SELECTION_CONVERGENCE: [("SFC_Step", SOUTH),

    64

                                  ("SFC_Jump", SOUTH)],

    65

    66

        SIMULTANEOUS_DIVERGENCE: [("SFC_Step", SOUTH)],

    67

    68

        SIMULTANEOUS_CONVERGENCE: [("SFC_Transition", SOUTH)],

    69

    70

        "SFC_Jump": [],

    71

    72

        "FBD_Block": [("SFC_Transition", WEST)],

    73

    74

        "FBD_Variable": [("SFC_Transition", WEST)],

    75

    76

        "FBD_Connector": [("SFC_Transition", WEST)],

    77

    78

        "LD_Contact": [("SFC_Transition", WEST)],

    79

    80

        "LD_PowerRail": [("SFC_Transition", WEST)],

    81

    82

        "LD_Coil": [("SFC_Transition", WEST)]

    83

    }

    84

    85

    def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):

    86

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

    87

        self.CurrentLanguage = "SFC"

    88

    89

    def ConnectConnectors(self, start, end):

    90

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

    91

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

    92

        wire = Wire(self, startpoint, endpoint)

    93

        self.AddWire(wire)

    94

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

    95

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

    96

        wire.ConnectStartPoint(None, start)

    97

        wire.ConnectEndPoint(None, end)

    98

        return wire

    99

   100

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

   101

        previous = connector.GetParentBlock()

   102

        id = self.GetNewId()

   103

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

   104

        pos = connector.GetPosition(False)

   105

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

   106

        transition_connectors = transition.GetConnectors()

   107

        wire = self.ConnectConnectors(transition_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(transition)

   114

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

   115

        self.RefreshTransitionModel(transition)

   116

        if next:

   117

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

   118

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

   119

            next_block = next.GetParentBlock()

   120

            next_pos = next.GetPosition(False)

   121

            transition.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

            transition.RefreshOutputModel(True)

   126

        return transition

   127

   128

    def RemoveTransition(self, transition):

   129

        connectors = transition.GetConnectors()

   130

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

   131

        if len(input_wires) != 1:

   132

            return

   133

        input_wire = input_wires[0][0]

   134

        previous = input_wire.EndConnected

   135

        input_wire.Clean()

   136

        self.RemoveWire(input_wire)

   137

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

   138

        if len(output_wires) != 1:

   139

            return

   140

        output_wire = output_wires[0][0]

   141

        next = output_wire.StartConnected

   142

        output_wire.Clean()

   143

        self.RemoveWire(output_wire)

   144

        transition.Clean()

   145

        self.RemoveBlock(transition)

   146

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

   147

        wire = self.ConnectConnectors(next, previous)

   148

        return wire

   149

   150

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

   151

        previous = connector.GetParentBlock()

   152

        id = self.GetNewId()

   153

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

   154

        if next:

   155

            step.AddOutput()

   156

        min_width, min_height = step.GetMinSize()

   157

        pos = connector.GetPosition(False)

   158

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

   159

        step.SetSize(min_width, min_height)

   160

        step_connectors = step.GetConnectors()

   161

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

   162

        if isinstance(previous, SFC_Divergence):

   163

            previous.RefreshConnectedPosition(connector)

   164

        else:

   165

            previous.RefreshOutputPosition()

   166

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

   167

        self.AddBlock(step)

   168

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

   169

        self.RefreshStepModel(step)

   170

        if next:

   171

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

   172

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

   173

            next_block = next.GetParentBlock()

   174

            next_pos = next.GetPosition(False)

   175

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

   176

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

   177

            if isinstance(next_block, SFC_Divergence):

   178

                next_block.RefreshPosition()

   179

            step.RefreshOutputModel(True)

   180

        return step

   181

   182

    def RemoveStep(self, step):

   183

        connectors = step.GetConnectors()

   184

        if connectors["input"]:

   185

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

   186

            if len(input_wires) != 1:

   187

                return

   188

            input_wire = input_wires[0][0]

   189

            previous = input_wire.EndConnected

   190

            input_wire.Clean()

   191

            self.RemoveWire(input_wire)

   192

        else:

   193

            previous = None

   194

        if connectors["output"]:

   195

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

   196

            if len(output_wires) != 1:

   197

                return

   198

            output_wire = output_wires[0][0]

   199

            next = output_wire.StartConnected

   200

            output_wire.Clean()

   201

            self.RemoveWire(output_wire)

   202

        else:

   203

            next = None

   204

        action = step.GetActionConnected()

   205

        if action:

   206

            self.DeleteActionBlock(action.GetParentBlock())

   207

        step.Clean()

   208

        self.RemoveBlock(step)

   209

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

   210

        if next and previous:

   211

            wire = self.ConnectConnectors(next, previous)

   212

            return wire

   213

        else:

   214

            return None

   215

   216

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

   217

#                          Mouse event functions

   218

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

   219

   220

    def OnViewerLeftDown(self, event):

   221

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   222

            Viewer.OnViewerLeftDown(self, event)

   223

        elif self.Mode == MODE_SELECTION:

   224

            if event.ShiftDown() and not event.ControlDown() and self.SelectedElement is not None:

   225

                element = self.FindElement(event, True)

   226

                if element and not self.IsWire(element):

   227

                    if isinstance(self.SelectedElement, Graphic_Group):

   228

                        self.SelectedElement.SelectElement(element)

   229

                    else:

   230

                        group = Graphic_Group(self)

   231

                        self.SelectedElement.SetSelected(False)

   232

                        group.SelectElement(self.SelectedElement)

   233

                        group.SelectElement(element)

   234

                        self.SelectedElement = group

   235

                    elements = self.SelectedElement.GetElements()

   236

                    if len(elements) == 0:

   237

                        self.SelectedElement = element

   238

                    elif len(elements) == 1:

   239

                        self.SelectedElement = elements[0]

   240

                    self.SelectedElement.SetSelected(True)

   241

            else:

   242

                element = self.FindElement(event)

   243

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

   244

                    if self.IsWire(self.SelectedElement):

   245

                        self.SelectedElement.SetSelectedSegment(None)

   246

                    else:

   247

                        self.SelectedElement.SetSelected(False)

   248

                    self.SelectedElement = None

   249

                if element:

   250

                    self.SelectedElement = element

   251

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

   252

                    self.SelectedElement.Refresh()

   253

                else:

   254

                    self.rubberBand.Reset()

   255

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

   256

        elif self.Mode == MODE_COMMENT:

   257

            self.rubberBand.Reset()

   258

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

   259

        event.Skip()

   260

   261

    def OnViewerLeftUp(self, event):

   262

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   263

            Viewer.OnViewerLeftUp(self, event)

   264

        elif self.rubberBand.IsShown():

   265

            if self.Mode == MODE_SELECTION:

   266

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

   267

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

   268

                if len(elements) > 0:

   269

                    self.SelectedElement = Graphic_Group(self)

   270

                    self.SelectedElement.SetElements(elements)

   271

                    self.SelectedElement.SetSelected(True)

   272

            elif self.Mode == MODE_COMMENT:

   273

                bbox = self.rubberBand.GetCurrentExtent()

   274

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

   275

                wx.CallAfter(self.AddComment, bbox)

   276

        elif self.Mode == MODE_INITIALSTEP:

   277

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

   278

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

   279

            if self.IsWire(self.SelectedElement):

   280

                self.SelectedElement.SetSelectedSegment(0)

   281

            else:

   282

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

   283

                self.SelectedElement.Refresh()

   284

            wx.CallAfter(self.SetCurrentCursor, 0)

   285

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

   286

            self.SelectedElement.ResetPoints()

   287

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

   288

            self.SelectedElement.GeneratePoints()

   289

            self.SelectedElement.RefreshModel()

   290

            self.SelectedElement.SetSelected(True)

   291

        event.Skip()

   292

   293

    def OnViewerRightUp(self, event):

   294

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   295

            Viewer.OnViewerRightUp(self, event)

   296

        else:

   297

            element = self.FindElement(event)

   298

            if element:

   299

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

   300

                    self.SelectedElement.SetSelected(False)

   301

                self.SelectedElement = element

   302

                if self.IsWire(self.SelectedElement):

   303

                    self.SelectedElement.SetSelectedSegment(0)

   304

                else:

   305

                    self.SelectedElement.SetSelected(True)

   306

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

   307

                    self.SelectedElement.Refresh()

   308

                wx.CallAfter(self.SetCurrentCursor, 0)

   309

        event.Skip()

   310

   311

    def OnViewerLeftDClick(self, event):

   312

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   313

            Viewer.OnViewerLeftDClick(self, event)

   314

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

   315

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

   316

            self.Refresh(False)

   317

        event.Skip()

   318

   319

    def OnViewerMotion(self, event):

   320

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   321

            Viewer.OnViewerMotion(self, event)

   322

        else:

   323

            if self.rubberBand.IsShown():

   324

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

   325

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

   326

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

   327

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

   328

                    self.SelectedElement.Refresh()

   329

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

   330

                self.SelectedElement.ResetPoints()

   331

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

   332

                self.SelectedElement.GeneratePoints()

   333

                self.SelectedElement.Refresh()

   334

            self.UpdateScrollPos(event)

   335

        event.Skip()

   336

   337

    def GetBlockName(self, block):

   338

        blockName = block.__class__.__name__

   339

        if blockName == "SFC_Divergence":

   340

            blockName = block.Type

   341

        return blockName

   342

   343

    # This method check the IEC 61131-3 compatibility between two SFC blocks

   344

    def BlockCompatibility(self, startblock = None, endblock = None, direction = None):

   346

                                                               or isinstance(endblock, SFC_Objects)):

   347

            # Full "SFC_StandardRules" table would be symmetrical and

   348

            # to avoid duplicate records and minimize the table only upper part is defined.

   349

            if (direction == SOUTH or direction == EAST):

   350

                startblock, endblock = endblock, startblock

   351

            start = self.GetBlockName(startblock)

   352

            end = self.GetBlockName(endblock)

   353

            for val in self.SFC_StandardRules[start]:

   354

                if end in val:

   355

                    return True

   356

            return False

   357

        return True

   358

   359

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

   360

#                          Keyboard event functions

   361

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

   362

   363

    def OnChar(self, event):

   364

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   365

            Viewer.OnChar(self, event)

   366

        else:

   367

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

   368

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

   369

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

   370

            keycode = event.GetKeyCode()

   371

            if self.Scaling:

   372

                scaling = self.Scaling

   373

            else:

   374

                scaling = (8, 8)

   375

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

   376

                self.SelectedElement.Delete()

   377

                self.SelectedElement = None

   378

                self.RefreshBuffer()

   379

                self.RefreshScrollBars()

   380

                self.Refresh(False)

   381

            elif keycode == wx.WXK_LEFT:

   382

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

   383

                    self.Scroll(0, ypos)

   384

                elif event.ControlDown():

   385

                    event.Skip()

   386

                elif self.SelectedElement:

   387

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

   388

                    self.SelectedElement.RefreshModel()

   389

                    self.RefreshBuffer()

   390

                    self.RefreshScrollBars()

   391

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

   392

            elif keycode == wx.WXK_RIGHT:

   393

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

   394

                    self.Scroll(xmax, ypos)

   395

                elif event.ControlDown():

   396

                    event.Skip()

   397

                elif self.SelectedElement:

   398

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

   399

                    self.SelectedElement.RefreshModel()

   400

                    self.RefreshBuffer()

   401

                    self.RefreshScrollBars()

   402

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

   403

            elif keycode == wx.WXK_UP:

   404

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

   405

                    self.Scroll(xpos, 0)

   406

                elif event.ControlDown():

   407

                    event.Skip()

   408

                elif self.SelectedElement:

   409

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

   410

                    self.SelectedElement.RefreshModel()

   411

                    self.RefreshBuffer()

   412

                    self.RefreshScrollBars()

   413

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

   414

            elif keycode == wx.WXK_DOWN:

   415

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

   416

                    self.Scroll(xpos, ymax)

   417

                elif event.ControlDown():

   418

                    event.Skip()

   419

                elif self.SelectedElement:

   420

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

   421

                    self.SelectedElement.RefreshModel()

   422

                    self.RefreshBuffer()

   423

                    self.RefreshScrollBars()

   424

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

   425

            else:

   426

                event.Skip()

   427

   428

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

   429

#                          Adding element functions

   430

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

   431

   432

    def AddInitialStep(self, pos):

   433

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

   434

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

   435

        dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName, debug=self.Debug))

   436

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

   437

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

   438

            id = self.GetNewId()

   439

            name = dialog.GetValue()

   440

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

   441

            min_width, min_height = step.GetMinSize()

   442

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

   443

            width, height = step.GetSize()

   444

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

   445

            self.AddBlock(step)

   446

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

   447

            self.RefreshStepModel(step)

   448

            self.RefreshBuffer()

   449

            self.RefreshScrollBars()

   450

            self.Refresh(False)

   451

        dialog.Destroy()

   452

   453

    def AddStep(self):

   454

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

   455

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

   456

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

   457

            dialog.SetVariables(self.Controler.GetEditedElementInterfaceVars(self.TagName, debug=self.Debug))

   458

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

   459

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

   460

                name = dialog.GetValue()

   461

                if self.IsWire(self.SelectedElement):

   462

                    self.SelectedElement.SetSelectedSegment(None)

   463

                    previous = self.SelectedElement.EndConnected

   464

                    next = self.SelectedElement.StartConnected

   465

                    self.SelectedElement.Clean()

   466

                    self.RemoveWire(self.SelectedElement)

   467

                else:

   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

                previous_block = previous.GetParentBlock()

   485

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

   486

                    transition = self.CreateTransition(previous)

   487

                    transition_connectors = transition.GetConnectors()

   488

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

   489

                else:

   490

                    step = self.CreateStep(name, previous)

   491

                    step.AddOutput()

   492

                    step.RefreshModel()

   493

                    step_connectors = step.GetConnectors()

   494

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

   495

                if self.IsWire(self.SelectedElement):

   496

                    self.SelectedElement = wire

   497

                    self.SelectedElement.SetSelectedSegment(0)

   498

                else:

   499

                    self.SelectedElement.SetSelected(False)

   500

                    self.SelectedElement = step

   501

                    self.SelectedElement.SetSelected(True)

   502

                self.RefreshBuffer()

   503

                self.RefreshScrollBars()

   504

                self.Refresh(False)

   505

            dialog.Destroy()

   506

   507

    def AddStepAction(self):

   508

        if isinstance(self.SelectedElement, SFC_Step):

   509

            connectors = self.SelectedElement.GetConnectors()

   510

            if not connectors["action"]:

   511

                dialog = ActionBlockDialog(self.ParentWindow)

   512

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

   513

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

   514

                dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName, debug=self.Debug))

   515

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

   516

                    actions = dialog.GetValues()

   517

                    self.SelectedElement.AddAction()

   518

                    self.RefreshStepModel(self.SelectedElement)

   519

                    connectors = self.SelectedElement.GetConnectors()