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

    27

from GraphicCommons import *

    28

from plcopen.structures import *

    29

    30

def GetWireSize(block):

    31

    if isinstance(block, SFC_Step):

    32

        return SFC_WIRE_MIN_SIZE + block.GetActionExtraLineNumber() * SFC_ACTION_MIN_SIZE[1]

    33

    else:

    34

        return SFC_WIRE_MIN_SIZE

    35

    36

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

    37

#                         Sequencial Function Chart Step

    38

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

    39

    40

"""

    41

Class that implements the graphic representation of a step

    42

"""

    43

    44

class SFC_Step(Graphic_Element, DebugDataConsumer):

    45

    46

    # Create a new step

    47

    def __init__(self, parent, name, initial = False, id = None):

    48

        Graphic_Element.__init__(self, parent)

    49

        DebugDataConsumer.__init__(self)

    50

        self.SetName(name)

    51

        self.Initial = initial

    52

        self.Id = id

    53

        self.Error = None

    54

        self.Size = wx.Size(SFC_STEP_DEFAULT_SIZE[0], SFC_STEP_DEFAULT_SIZE[1])

    55

        # Create an input and output connector

    56

        if not self.Initial:

    57

            self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH)

    58

        else:

    59

            self.Input = None

    60

        self.Output = None

    61

        self.Action = None

    62

        self.PreviousValue = None

    63

        self.PreviousSpreading = False

    64

    65

    def Flush(self):

    66

        if self.Input is not None:

    67

            self.Input.Flush()

    68

            self.Input = None

    69

        if self.Output is not None:

    70

            self.Output.Flush()

    71

            self.Output = None

    72

        if self.Output is not None:

    73

            self.Action.Flush()

    74

            self.Action = None

    75

    76

    def SetValue(self, value):

    77

        self.PreviousValue = self.Value

    78

        self.Value = value

    79

        if self.Value != self.PreviousValue:

    80

            if self.Visible:

    81

                self.Parent.UpdateRefreshRect(self.GetRedrawRect())

    82

            self.SpreadCurrent()

    83

    84

    def SpreadCurrent(self):

    85

        if self.Parent.Debug:

    86

            spreading = self.Value

    87

            if spreading and not self.PreviousSpreading:

    88

                if self.Output is not None:

    89

                    self.Output.SpreadCurrent(True)

    90

                if self.Action is not None:

    91

                    self.Action.SpreadCurrent(True)

    92

            elif not spreading and self.PreviousSpreading:

    93

                if self.Output is not None:

    94

                    self.Output.SpreadCurrent(False)

    95

                if self.Action is not None:

    96

                    self.Action.SpreadCurrent(False)

    97

            self.PreviousSpreading = spreading

    98

    99

    # Make a clone of this SFC_Step

   100

    def Clone(self, parent, id = None, name = "Step", pos = None):

   101

        step = SFC_Step(parent, name, self.Initial, id)

   102

        step.SetSize(self.Size[0], self.Size[1])

   103

        if pos is not None:

   104

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

   105

        else:

   106

            step.SetPosition(self.Pos.x, self.Pos.y)

   107

        if self.Input:

   108

            step.Input = self.Input.Clone(step)

   109

        if self.Output:

   110

            step.Output = self.Output.Clone(step)

   111

        if self.Action:

   112

            step.Action = self.Action.Clone(step)

   113

        return step

   114

   115

    def GetConnectorTranslation(self, element):

   116

        connectors = {}

   117

        if self.Input is not None:

   118

            connectors[self.Input] = element.Input

   119

        if self.Output is not None:

   120

            connectors[self.Output] = element.Output

   121

        if self.Action is not None:

   122

            connectors[self.Action] = element.Action

   123

        return connectors

   124

   125

    # Returns the RedrawRect

   126

    def GetRedrawRect(self, movex = 0, movey = 0):

   127

        rect = Graphic_Element.GetRedrawRect(self, movex, movey)

   128

        if self.Input:

   129

            rect = rect.Union(self.Input.GetRedrawRect(movex, movey))

   130

        if self.Output:

   131

            rect = rect.Union(self.Output.GetRedrawRect(movex, movey))

   132

        if self.Action:

   133

            rect = rect.Union(self.Action.GetRedrawRect(movex, movey))

   134

        if movex != 0 or movey != 0:

   135

            if self.Input and self.Input.IsConnected():

   136

                rect = rect.Union(self.Input.GetConnectedRedrawRect(movex, movey))

   137

            if self.Output and self.Output.IsConnected():

   138

                rect = rect.Union(self.Output.GetConnectedRedrawRect(movex, movey))

   139

            if self.Action and self.Action.IsConnected():

   140

                rect = rect.Union(self.Action.GetConnectedRedrawRect(movex, movey))

   141

        return rect

   142

   143

    # Delete this step by calling the appropriate method

   144

    def Delete(self):

   145

        self.Parent.DeleteStep(self)

   146

   147

    # Unconnect input and output

   148

    def Clean(self):

   149

        if self.Input:

   150

            self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   151

        if self.Output:

   152

            self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   153

        if self.Action:

   154

            self.Action.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   155

   156

    # Refresh the size of text for name

   157

    def RefreshNameSize(self):

   158

        self.NameSize = self.Parent.GetTextExtent(self.Name)

   159

   160

    # Add output connector to step

   161

    def AddInput(self):

   162

        if not self.Input:

   163

            self.Input = Connector(self, "", None, wx.Point(self.Size[0] / 2, 0), NORTH)

   164

            self.RefreshBoundingBox()

   165

   166

    # Remove output connector from step

   167

    def RemoveInput(self):

   168

        if self.Input:

   169

            self.Input.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   170

            self.Input = None

   171

            self.RefreshBoundingBox()

   172

   173

    # Add output connector to step

   174

    def AddOutput(self):

   175

        if not self.Output:

   176

            self.Output = Connector(self, "", None, wx.Point(self.Size[0] / 2, self.Size[1]), SOUTH, onlyone = True)

   177

            self.RefreshBoundingBox()

   178

   179

    # Remove output connector from step

   180

    def RemoveOutput(self):

   181

        if self.Output:

   182

            self.Output.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   183

            self.Output = None

   184

            self.RefreshBoundingBox()

   185

   186

    # Add action connector to step

   187

    def AddAction(self):

   188

        if not self.Action:

   189

            self.Action = Connector(self, "", None, wx.Point(self.Size[0], self.Size[1] / 2), EAST, onlyone = True)

   190

            self.RefreshBoundingBox()

   191

   192

    # Remove action connector from step

   193

    def RemoveAction(self):

   194

        if self.Action:

   195

            self.Action.UnConnect(delete = self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

   196

            self.Action = None

   197

            self.RefreshBoundingBox()

   198

   199

    # Refresh the step bounding box

   200

    def RefreshBoundingBox(self):

   201

        # Calculate the bounding box size

   202

        if self.Action:

   203

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   204

        else:

   205

            bbx_width = self.Size[0]

   206

        if self.Initial:

   207

            bbx_y = self.Pos.y

   208

            bbx_height = self.Size[1]

   209

            if self.Output:

   210

                bbx_height += CONNECTOR_SIZE

   211

        else:

   212

            bbx_y = self.Pos.y - CONNECTOR_SIZE

   213

            bbx_height = self.Size[1] + CONNECTOR_SIZE

   214

            if self.Output:

   215

                bbx_height += CONNECTOR_SIZE

   216

        #self.BoundingBox = wx.Rect(self.Pos.x, bbx_y, bbx_width + 1, bbx_height + 1)

   217

        self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)

   218

   219

    # Refresh the positions of the step connectors

   220

    def RefreshConnectors(self):

   221

        scaling = self.Parent.GetScaling()

   222

        horizontal_pos = self.Size[0] / 2

   223

        vertical_pos = self.Size[1] / 2

   224

        if scaling is not None:

   225

            horizontal_pos = round(float(self.Pos.x + horizontal_pos) / float(scaling[0])) * scaling[0] - self.Pos.x

   226

            vertical_pos = round(float(self.Pos.y + vertical_pos) / float(scaling[1])) * scaling[1] - self.Pos.y

   227

        # Update input position if it exists

   228

        if self.Input:

   229

            self.Input.SetPosition(wx.Point(horizontal_pos, 0))

   230

        # Update output position

   231

        if self.Output:

   232

            self.Output.SetPosition(wx.Point(horizontal_pos, self.Size[1]))

   233

        # Update action position if it exists

   234

        if self.Action:

   235

            self.Action.SetPosition(wx.Point(self.Size[0], vertical_pos))

   236

        self.RefreshConnected()

   237

   238

    # Refresh the position of wires connected to step

   239

    def RefreshConnected(self, exclude = []):

   240

        if self.Input:

   241

            self.Input.MoveConnected(exclude)

   242

        if self.Output:

   243

            self.Output.MoveConnected(exclude)

   244

        if self.Action:

   245

            self.Action.MoveConnected(exclude)

   246

   247

    # Returns the step connector that starts with the point given if it exists 

   248

    def GetConnector(self, position, name = None):

   249

        # if a name is given

   250

        if name:

   251

            # Test input, output and action connector if they exists

   252

            if self.Input and name == self.Input.GetName():

   253

                return self.Input

   254

            if self.Output and name == self.Output.GetName():

   255

                return self.Output

   256

            if self.Action and name == self.Action.GetName():

   257

                return self.Action

   258

        # Test input connector if it exists

   259

        if self.Input:

   260

            input_pos = self.Input.GetRelPosition()

   261

            if position.x == self.Pos.x + input_pos.x and position.y == self.Pos.y + input_pos.y:

   262

                return self.Input

   263

        # Test output connector if it exists

   264

        if self.Output:

   265

            output_pos = self.Output.GetRelPosition()

   266

            if position.x == self.Pos.x + output_pos.x and position.y == self.Pos.y + output_pos.y:

   267

                return self.Output

   268

        # Test action connector if it exists

   269

        if self.Action:

   270

            action_pos = self.Action.GetRelPosition()

   271

            if position.x == self.Pos.x + action_pos.x and position.y == self.Pos.y + action_pos.y:

   272

                return self.Action

   273

        return None

   274

   275

    # Returns input and output step connectors 

   276

    def GetConnectors(self):

   277

        return {"input":self.Input,"output":self.Output,"action":self.Action}

   278

   279

    # Test if point given is on step input or output connector

   280

    def TestConnector(self, pt, direction = None, exclude=True):

   281

        # Test input connector if it exists

   282

        if self.Input and self.Input.TestPoint(pt, direction, exclude):

   283

            return self.Input

   284

        # Test output connector

   285

        if self.Output and self.Output.TestPoint(pt, direction, exclude):

   286

            return self.Output

   287

        # Test action connector

   288

        if self.Action and self.Action.TestPoint(pt, direction, exclude):

   289

            return self.Action

   290

        return None

   291

   292

    # Changes the step name

   293

    def SetName(self, name):

   294

        self.Name = name

   295

        self.RefreshNameSize()

   296

   297

    # Returns the step name

   298

    def GetName(self):

   299

        return self.Name

   300

   301

    # Returns the step initial property

   302

    def GetInitial(self):

   303

        return self.Initial

   304

   305

    # Returns the connector connected to input

   306

    def GetPreviousConnector(self):

   307

        if self.Input:

   308

            wires = self.Input.GetWires()

   309

            if len(wires) == 1:

   310

                return wires[0][0].GetOtherConnected(self.Input)

   311

        return None

   312

   313

    # Returns the connector connected to output

   314

    def GetNextConnector(self):

   315

        if self.Output:

   316

            wires = self.Output.GetWires()

   317

            if len(wires) == 1:

   318

                return wires[0][0].GetOtherConnected(self.Output)

   319

        return None

   320

   321

    # Returns the connector connected to action

   322

    def GetActionConnector(self):

   323

        if self.Action:

   324

            wires = self.Action.GetWires()

   325

            if len(wires) == 1:

   326

                return wires[0][0].GetOtherConnected(self.Action)

   327

        return None

   328

   329

    # Returns the number of action line

   330

    def GetActionExtraLineNumber(self):

   331

        if self.Action:

   332

            wires = self.Action.GetWires()

   333

            if len(wires) != 1:

   334

                return 0

   335

            action_block = wires[0][0].GetOtherConnected(self.Action).GetParentBlock()

   336

            return max(0, action_block.GetLineNumber() - 1)

   337

        return 0

   338

   339

    # Returns the step minimum size

   340

    def GetMinSize(self):

   341

        text_width, text_height = self.Parent.GetTextExtent(self.Name)

   342

        if self.Initial:

   343

            return text_width + 14, text_height + 14

   344

        else:

   345

            return text_width + 10, text_height + 10

   346

   347

    # Updates the step size

   348

    def UpdateSize(self, width, height):

   349

        diffx = self.Size.GetWidth() / 2 - width / 2

   350

        diffy = height - self.Size.GetHeight()

   351

        self.Move(diffx, 0)

   352

        Graphic_Element.SetSize(self, width, height)

   353

        if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

   354

            self.RefreshConnected()

   355

        else:

   356

            self.RefreshOutputPosition((0, diffy))

   357

   358

    # Align input element with this step

   359

    def RefreshInputPosition(self):

   360

        if self.Input:

   361

            current_pos = self.Input.GetPosition(False)

   362

            input = self.GetPreviousConnector()

   363

            if input:

   364

                input_pos = input.GetPosition(False)

   365

                diffx = current_pos.x - input_pos.x

   366

                input_block = input.GetParentBlock()

   367

                if isinstance(input_block, SFC_Divergence):

   368

                    input_block.MoveConnector(input, diffx)

   369

                else:

   370

                    if isinstance(input_block, SFC_Step):

   371

                        input_block.MoveActionBlock((diffx, 0))

   372

                    input_block.Move(diffx, 0)

   373

                    input_block.RefreshInputPosition()

   374

   375

    # Align output element with this step

   376

    def RefreshOutputPosition(self, move = None):

   377

        if self.Output:

   378

            wires = self.Output.GetWires()

   379

            if len(wires) != 1:

   380

                return

   381

            current_pos = self.Output.GetPosition(False)

   382

            output = wires[0][0].GetOtherConnected(self.Output)

   383

            output_pos = output.GetPosition(False)

   384

            diffx = current_pos.x - output_pos.x

   385

            output_block = output.GetParentBlock()

   386

            wire_size = SFC_WIRE_MIN_SIZE + self.GetActionExtraLineNumber() * SFC_ACTION_MIN_SIZE[1]

   387

            diffy = wire_size - output_pos.y + current_pos.y

   388

            if diffy != 0:

   389

                if isinstance(output_block, SFC_Step):

   390

                    output_block.MoveActionBlock((diffx, diffy))

   391

                wires[0][0].SetPoints([wx.Point(current_pos.x, current_pos.y + wire_size),

   392

                    wx.Point(current_pos.x, current_pos.y)])

   393

                if not isinstance(output_block, SFC_Divergence) or output_block.GetConnectors()["inputs"].index(output) == 0:

   394

                    output_block.Move(diffx, diffy, self.Parent.Wires)

   395

                    output_block.RefreshOutputPosition((diffx, diffy))

   396

                else:

   397

                    output_block.RefreshPosition()

   398

            elif move:

   399

                if isinstance(output_block, SFC_Step):

   400

                    output_block.MoveActionBlock(move)

   401

                wires[0][0].Move(move[0], move[1], True)

   402

                if not isinstance(output_block, SFC_Divergence) or output_block.GetConnectors()["inputs"].index(output) == 0:

   403

                    output_block.Move(move[0], move[1], self.Parent.Wires)

   404

                    output_block.RefreshOutputPosition(move)

   405

                else:

   406

                    output_block.RefreshPosition()

   407

            elif isinstance(output_block, SFC_Divergence):

   408

                output_block.MoveConnector(output, diffx)

   409

            else:

   410

                if isinstance(output_block, SFC_Step):

   411

                    output_block.MoveActionBlock((diffx, 0))

   412

                output_block.Move(diffx, 0)

   413

                output_block.RefreshOutputPosition()

   414

   415

    # Refresh action element with this step

   416

    def MoveActionBlock(self, move):

   417

        if self.Action:

   418

            wires = self.Action.GetWires()

   419

            if len(wires) != 1:

   420

                return

   421

            action_block = wires[0][0].GetOtherConnected(self.Action).GetParentBlock()

   422

            action_block.Move(move[0], move[1], self.Parent.Wires)

   423

            wires[0][0].Move(move[0], move[1], True)

   424

   425

    # Resize the divergence from position and size given

   426

    def Resize(self, x, y, width, height):

   427

        if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

   428

            self.UpdateSize(width, height)

   429

        else:

   430

            Graphic_Element.Resize(self, x, y, width, height)

   431

   432

    # Method called when a LeftDClick event have been generated

   433

    def OnLeftDClick(self, event, dc, scaling):

   434

        # Edit the step properties

   435

        self.Parent.EditStepContent(self)

   436

   437

    # Method called when a RightUp event have been generated

   438

    def OnRightUp(self, event, dc, scaling):

   439

        # Popup the menu with special items for a step

   440

        self.Parent.PopupDefaultMenu()

   441

   442

    # Refreshes the step state according to move defined and handle selected

   443

    def ProcessDragging(self, movex, movey, event, scaling):

   444

        handle_type, handle = self.Handle

   445

        if handle_type == HANDLE_MOVE:

   446

            movex = max(-self.BoundingBox.x, movex)

   447

            movey = max(-self.BoundingBox.y, movey)

   448

            if scaling is not None:

   449

                movex = round(float(self.Pos.x + movex) / float(scaling[0])) * scaling[0] - self.Pos.x

   450

                movey = round(float(self.Pos.y + movey) / float(scaling[1])) * scaling[1] - self.Pos.y

   451

            action_block = None

   452

            if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

   453

                self.Move(movex, movey)

   454

                self.RefreshConnected()

   455

                return movex, movey

   456

            elif self.Initial:

   457

                self.MoveActionBlock((movex, movey))

   458

                self.Move(movex, movey, self.Parent.Wires)

   459

                self.RefreshOutputPosition((movex, movey))

   460

                return movex, movey

   461

            else:

   462

                self.MoveActionBlock((movex, 0))

   463

                self.Move(movex, 0)

   464

                self.RefreshInputPosition()

   465

                self.RefreshOutputPosition()

   466

                return movex, 0

   467

        else:

   468

            return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling)

   469

   470

    # Refresh input element model

   471

    def RefreshInputModel(self):

   472

        if self.Input:

   473

            input = self.GetPreviousConnector()

   474

            if input:                

   475

                input_block = input.GetParentBlock()

   476

                input_block.RefreshModel(False)

   477

                if not isinstance(input_block, SFC_Divergence):

   478

                    input_block.RefreshInputModel()

   479

   480

    # Refresh output element model

   481

    def RefreshOutputModel(self, move=False):

   482

        if self.Output:

   483

            output = self.GetNextConnector()

   484

            if output:

   485

                output_block = output.GetParentBlock()

   486

                output_block.RefreshModel(False)

   487

                if not isinstance(output_block, SFC_Divergence) or move:

   488

                    output_block.RefreshOutputModel(move)

   489

   490

    # Refreshes the step model

   491

    def RefreshModel(self, move=True):

   492

        self.Parent.RefreshStepModel(self)

   493

        if self.Action:

   494

            action = self.GetActionConnector()

   495

            if action:

   496

                action_block = action.GetParentBlock()

   497

                action_block.RefreshModel(False)

   498

        # If step has moved, refresh the model of wires connected to output

   499

        if move:

   500

            if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

   501

                self.RefreshInputModel()

   502

                self.RefreshOutputModel(self.Initial)

   503

            elif self.Output:

   504

                self.Output.RefreshWires()

   505

   506

    def AddError(self, infos, start, end):

   507

        if infos[0] == "name" and start[0] == 0 and end[0] == 0:

   508

            self.Error = (start[1], end[1])

   509