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

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

type = [SELECTION_DIVERGENCE, SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]

    35

divergence = dict(zip(type,["SELECTION_DIVERGENCE", "SELECTION_CONVERGENCE",\

    36

                            "SIMULTANEOUS_DIVERGENCE", "SIMULTANEOUS_CONVERGENCE"]))

    37

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

    38

    39

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

    "SFC_Step" :                 ["SFC_ActionBlock",

    43

                                  "SFC_Transition",

    44

                                  "SELECTION_DIVERGENCE",

    45

                                  "SIMULTANEOUS_CONVERGENCE"],

    46

    47

    "SFC_ActionBlock" :          ["SFC_Step"],

    48

    49

    "SFC_Transition" :           ["SFC_Step",

    50

                                  "SELECTION_CONVERGENCE",

    51

                                  "SIMULTANEOUS_DIVERGENCE",

    52

                                  "SFC_Jump",

    53

                                  "FBD_Block",

    54

                                  "FBD_Variable"

    55

                                  "LD_Contact",

    56

                                  "LD_PowerRail",

    57

                                  "LD_Coil"],

    58

    59

    "SELECTION_DIVERGENCE" :     ["SFC_Transition"],

    60

    61

    "SELECTION_CONVERGENCE" :    ["SFC_Step",

    62

                                  "SFC_Jump"],

    63

    64

    "SIMULTANEOUS_DIVERGENCE" :  ["SFC_Step"],

    65

    66

    "SIMULTANEOUS_CONVERGENCE" : ["SFC_Transition"],

    67

    68

    "SFC_Jump" :                 [],

    69

    70

    "FBD_Block" :                ["SFC_Transition"],

    71

    72

    "FBD_Variable" :             ["SFC_Transition"],

    73

    74

    "LD_Contact" :               ["SFC_Transition"],

    75

    76

    "LD_PowerRail" :             ["SFC_Transition"],

    77

    78

    "LD_Coil" :                  ["SFC_Transition"]

    79

                }

    80

    81

class SFC_Viewer(Viewer):

    82

    83

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

    84

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

    85

        self.CurrentLanguage = "SFC"

    86

    87

    def ConnectConnectors(self, start, end):

    88

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

    89

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

    90

        wire = Wire(self, startpoint, endpoint)

    91

        self.AddWire(wire)

    92

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

    93

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

    94

        wire.ConnectStartPoint(None, start)

    95

        wire.ConnectEndPoint(None, end)

    96

        return wire

    97

    98

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

    99

        previous = connector.GetParentBlock()

   100

        id = self.GetNewId()

   101

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

   102

        pos = connector.GetPosition(False)

   103

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

   104

        transition_connectors = transition.GetConnectors()

   105

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

   106

        if isinstance(previous, SFC_Divergence):

   107

            previous.RefreshConnectedPosition(connector)

   108

        else:

   109

            previous.RefreshOutputPosition()

   110

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

   111

        self.AddBlock(transition)

   112

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

   113

        self.RefreshTransitionModel(transition)

   114

        if next:

   115

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

   116

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

   117

            next_block = next.GetParentBlock()

   118

            next_pos = next.GetPosition(False)

   119

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

   120

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

   121

            if isinstance(next_block, SFC_Divergence):

   122

                next_block.RefreshPosition()

   123

            transition.RefreshOutputModel(True)

   124

        return transition

   125

   126

    def RemoveTransition(self, transition):

   127

        connectors = transition.GetConnectors()

   128

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

   129

        if len(input_wires) != 1:

   130

            return

   131

        input_wire = input_wires[0][0]

   132

        previous = input_wire.EndConnected

   133

        input_wire.Clean()

   134

        self.RemoveWire(input_wire)

   135

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

   136

        if len(output_wires) != 1:

   137

            return

   138

        output_wire = output_wires[0][0]

   139

        next = output_wire.StartConnected

   140

        output_wire.Clean()

   141

        self.RemoveWire(output_wire)

   142

        transition.Clean()

   143

        self.RemoveBlock(transition)

   144

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

   145

        wire = self.ConnectConnectors(next, previous)

   146

        return wire

   147

   148

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

   149

        previous = connector.GetParentBlock()

   150

        id = self.GetNewId()

   151

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

   152

        if next:

   153

            step.AddOutput()

   154

        min_width, min_height = step.GetMinSize()

   155

        pos = connector.GetPosition(False)

   156

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

   157

        step.SetSize(min_width, min_height)

   158

        step_connectors = step.GetConnectors()

   159

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

   160

        if isinstance(previous, SFC_Divergence):

   161

            previous.RefreshConnectedPosition(connector)

   162

        else:

   163

            previous.RefreshOutputPosition()

   164

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

   165

        self.AddBlock(step)

   166

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

   167

        self.RefreshStepModel(step)

   168

        if next:

   169

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

   170

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

   171

            next_block = next.GetParentBlock()

   172

            next_pos = next.GetPosition(False)

   173

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

   174

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

   175

            if isinstance(next_block, SFC_Divergence):

   176

                next_block.RefreshPosition()

   177

            step.RefreshOutputModel(True)

   178

        return step

   179

   180

    def RemoveStep(self, step):

   181

        connectors = step.GetConnectors()

   182

        if connectors["input"]:

   183

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

   184

            if len(input_wires) != 1:

   185

                return

   186

            input_wire = input_wires[0][0]

   187

            previous = input_wire.EndConnected

   188

            input_wire.Clean()

   189

            self.RemoveWire(input_wire)

   190

        else:

   191

            previous = None

   192

        if connectors["output"]:

   193

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

   194

            if len(output_wires) != 1:

   195

                return

   196

            output_wire = output_wires[0][0]

   197

            next = output_wire.StartConnected

   198

            output_wire.Clean()

   199

            self.RemoveWire(output_wire)

   200

        else:

   201

            next = None

   202

        action = step.GetActionConnected()

   203

        if action:

   204

            self.DeleteActionBlock(action.GetParentBlock())

   205

        step.Clean()

   206

        self.RemoveBlock(step)

   207

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

   208

        if next and previous:

   209

            wire = self.ConnectConnectors(next, previous)

   210

            return wire

   211

        else:

   212

            return None

   213

   214

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

   215

#                          Mouse event functions

   216

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

   217

   218

    def OnViewerLeftDown(self, event):

   219

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   220

            Viewer.OnViewerLeftDown(self, event)

   221

        elif self.Mode == MODE_SELECTION:

   222

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

   223

                element = self.FindElement(event, True)

   224

                if element and not self.IsWire(element):

   225

                    if isinstance(self.SelectedElement, Graphic_Group):

   226

                        self.SelectedElement.SelectElement(element)

   227

                    else:

   228

                        group = Graphic_Group(self)

   229

                        self.SelectedElement.SetSelected(False)

   230

                        group.SelectElement(self.SelectedElement)

   231

                        group.SelectElement(element)

   232

                        self.SelectedElement = group

   233

                    elements = self.SelectedElement.GetElements()

   234

                    if len(elements) == 0:

   235

                        self.SelectedElement = element

   236

                    elif len(elements) == 1:

   237

                        self.SelectedElement = elements[0]

   238

                    self.SelectedElement.SetSelected(True)

   239

            else:

   240

                element = self.FindElement(event)

   241

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

   242

                    if self.IsWire(self.SelectedElement):

   243

                        self.SelectedElement.SetSelectedSegment(None)

   244

                    else:

   245

                        self.SelectedElement.SetSelected(False)

   246

                    self.SelectedElement = None

   247

                if element:

   248

                    self.SelectedElement = element

   249

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

   250

                    self.SelectedElement.Refresh()

   251

                else:

   252

                    self.rubberBand.Reset()

   253

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

   254

        elif self.Mode == MODE_COMMENT:

   255

            self.rubberBand.Reset()

   256

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

   257

        event.Skip()

   258

   259

    def OnViewerLeftUp(self, event):

   260

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   261

            Viewer.OnViewerLeftUp(self, event)

   262

        elif self.rubberBand.IsShown():

   263

            if self.Mode == MODE_SELECTION:

   264

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

   265

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

   266

                if len(elements) > 0:

   267

                    self.SelectedElement = Graphic_Group(self)

   268

                    self.SelectedElement.SetElements(elements)

   269

                    self.SelectedElement.SetSelected(True)

   270

            elif self.Mode == MODE_COMMENT:

   271

                bbox = self.rubberBand.GetCurrentExtent()

   272

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

   273

                wx.CallAfter(self.AddComment, bbox)

   274

        elif self.Mode == MODE_INITIALSTEP:

   275

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

   276

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

   277

            if self.IsWire(self.SelectedElement):

   278

                self.SelectedElement.SetSelectedSegment(0)

   279

            else:

   280

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

   281

                self.SelectedElement.Refresh()

   282

            wx.CallAfter(self.SetCurrentCursor, 0)

   283

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

   284

            self.SelectedElement.ResetPoints()

   285

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

   286

            self.SelectedElement.GeneratePoints()

   287

            self.SelectedElement.RefreshModel()

   288

            self.SelectedElement.SetSelected(True)

   289

        event.Skip()

   290

   291

    def OnViewerRightUp(self, event):

   292

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   293

            Viewer.OnViewerRightUp(self, event)

   294

        else:

   295

            element = self.FindElement(event)

   296

            if element:

   297

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

   298

                    self.SelectedElement.SetSelected(False)

   299

                self.SelectedElement = element

   300

                if self.IsWire(self.SelectedElement):

   301

                    self.SelectedElement.SetSelectedSegment(0)

   302

                else:

   303

                    self.SelectedElement.SetSelected(True)

   304

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

   305

                    self.SelectedElement.Refresh()

   306

                wx.CallAfter(self.SetCurrentCursor, 0)

   307

        event.Skip()

   308

   309

    def OnViewerLeftDClick(self, event):

   310

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   311

            Viewer.OnViewerLeftDClick(self, event)

   312

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

   313

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

   314

            self.Refresh(False)

   315

        event.Skip()

   316

   317

    def OnViewerMotion(self, event):

   318

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   319

            Viewer.OnViewerMotion(self, event)

   320

        else:

   321

            if self.rubberBand.IsShown():

   322

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

   323

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

   324

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

   325

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

   326

                    self.SelectedElement.Refresh()

   327

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

   328

                self.SelectedElement.ResetPoints()

   329

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

   330

                self.SelectedElement.GeneratePoints()

   331

                self.SelectedElement.Refresh()

   332

            self.UpdateScrollPos(event)

   333

        event.Skip()

   334

   335

    def GetBlockName(self, block):

   336

        blockName = block.__class__.__name__

   337

        if blockName == "SFC_Divergence":

   338

            blockName = divergence[block.Type]

   339

        return blockName

   340

   341

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

   342

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

   343

        if startblock!= None and endblock != None and (isinstance(startblock,SFC_Objects)\

   344

                                                               or isinstance(endblock,SFC_Objects)):

   345

            # Full "StandardRules" table would be simmetrical and

   346

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

   347

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

   348

                startblock, endblock = endblock, startblock

   349

            start = self.GetBlockName(startblock)

   350

            end = self.GetBlockName(endblock)

   351

            return end in StandardRules[start]

   352

        return True

   353

   354

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

   355

#                          Keyboard event functions

   356

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

   357

   358

    def OnChar(self, event):

   359

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   360

            Viewer.OnChar(self, event)

   361

        else:

   362

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

   363

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

   364

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

   365

            keycode = event.GetKeyCode()

   366

            if self.Scaling:

   367

                scaling = self.Scaling

   368

            else:

   369

                scaling = (8, 8)

   370

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

   371

                self.SelectedElement.Delete()

   372

                self.SelectedElement = None

   373

                self.RefreshBuffer()

   374

                self.RefreshScrollBars()

   375

                self.Refresh(False)

   376

            elif keycode == wx.WXK_LEFT:

   377

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

   378

                    self.Scroll(0, ypos)

   379

                elif event.ControlDown():

   380

                    event.Skip()

   381

                elif self.SelectedElement:

   382

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

   383

                    self.SelectedElement.RefreshModel()

   384

                    self.RefreshBuffer()

   385

                    self.RefreshScrollBars()

   386

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

   387

            elif keycode == wx.WXK_RIGHT:

   388

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

   389

                    self.Scroll(xmax, ypos)

   390

                elif event.ControlDown():

   391

                    event.Skip()

   392

                elif self.SelectedElement:

   393

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

   394

                    self.SelectedElement.RefreshModel()

   395

                    self.RefreshBuffer()

   396

                    self.RefreshScrollBars()

   397

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

   398

            elif keycode == wx.WXK_UP:

   399

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

   400

                    self.Scroll(xpos, 0)

   401

                elif event.ControlDown():

   402

                    event.Skip()

   403

                elif self.SelectedElement:

   404

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

   405

                    self.SelectedElement.RefreshModel()

   406

                    self.RefreshBuffer()

   407

                    self.RefreshScrollBars()

   408

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

   409

            elif keycode == wx.WXK_DOWN:

   410

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

   411

                    self.Scroll(xpos, ymax)

   412

                elif event.ControlDown():

   413

                    event.Skip()

   414

                elif self.SelectedElement:

   415

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

   416

                    self.SelectedElement.RefreshModel()

   417

                    self.RefreshBuffer()

   418

                    self.RefreshScrollBars()

   419

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

   420

            else:

   421

                event.Skip()

   422

   423

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

   424

#                          Adding element functions

   425

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

   426

   427

    def AddInitialStep(self, pos):

   428

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

   429

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

   430

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

   431

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

   432

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

   433

            id = self.GetNewId()

   434

            name = dialog.GetValue()

   435

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

   436

            min_width, min_height = step.GetMinSize()

   437

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

   438

            width, height = step.GetSize()

   439

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

   440

            self.AddBlock(step)

   441

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

   442

            self.RefreshStepModel(step)

   443

            self.RefreshBuffer()

   444

            self.RefreshScrollBars()

   445

            self.Refresh(False)

   446

        dialog.Destroy()

   447

   448

    def AddStep(self):

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

                name = dialog.GetValue()

   456

                if self.IsWire(self.SelectedElement):

   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

                else:

   463

                    connectors = self.SelectedElement.GetConnectors()

   464

                    if connectors["output"]:

   465

                        previous = connectors["output"]

   466

                        wires = previous.GetWires()

   467

                        if len(wires) != 1:

   468

                            return

   469

                        wire = wires[0][0]

   470

                        next = wire.StartConnected

   471

                        wire.Clean()

   472

                        self.RemoveWire(wire)

   473

                    else:

   474

                        self.SelectedElement.AddOutput()

   475

                        connectors = self.SelectedElement.GetConnectors()

   476

                        self.RefreshStepModel(self.SelectedElement)

   477

                        previous = connectors["output"]

   478

                        next = None

   479

                previous_block = previous.GetParentBlock()

   480

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

   481

                    transition = self.CreateTransition(previous)

   482

                    transition_connectors = transition.GetConnectors()

   483

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

   484

                else:

   485

                    step = self.CreateStep(name, previous)

   486

                    step.AddOutput()

   487

                    step.RefreshModel()

   488

                    step_connectors = step.GetConnectors()

   489

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

   490

                if self.IsWire(self.SelectedElement):

   491

                    self.SelectedElement = wire

   492

                    self.SelectedElement.SetSelectedSegment(0)

   493

                else:

   494

                    self.SelectedElement.SetSelected(False)

   495

                    self.SelectedElement = step

   496

                    self.SelectedElement.SetSelected(True)

   497

                self.RefreshBuffer()

   498

                self.RefreshScrollBars()

   499

                self.Refresh(False)

   500

            dialog.Destroy()

   501

   502

    def AddStepAction(self):

   503

        if isinstance(self.SelectedElement, SFC_Step):

   504

            connectors = self.SelectedElement.GetConnectors()

   505

            if not connectors["action"]:

   506

                dialog = ActionBlockDialog(self.ParentWindow)

   507

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

   508

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

   509

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

   510

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

   511

                    actions = dialog.GetValues()

   512

                    self.SelectedElement.AddAction()

   513

                    self.RefreshStepModel(self.SelectedElement)

   514

                    connectors = self.SelectedElement.GetConnectors()

   515

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

   516

                    id = self.GetNewId()

   517

                    actionblock = SFC_ActionBlock(self, [], id)

   518

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

   519

                    actionblock_connector = actionblock.GetConnector()

   520

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

   521

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

   522

                    actionblock.SetActions(actions)

   523

                    self.AddBlock(actionblock)

   524

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