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

    45

    46

    # Create a new step

    47

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

    48

        Graphic_Element.__init__(self, parent)

    49

        self.SetName(name)

    50

        self.Initial = initial

    51

        self.Id = id

    52

        self.Error = None

    53

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

    54

        # Create an input and output connector

    55

        if not self.Initial:

    56

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

    57

        else:

    58

            self.Input = None

    59

        self.Output = None

    60

        self.Action = None

    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

    96

    # Make a clone of this SFC_Step

    97

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

    98

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

    99

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

   100

        if pos is not None:

   101

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

   102

        if self.Input:

   103

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

   104

        if self.Output:

   105

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

   106

        if self.Action:

   107

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

   108

        return step

   109

   110

    # Returns the RedrawRect

   111

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

   112

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

   113

        if self.Input:

   114

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

   115

        if self.Output:

   116

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

   117

        if self.Action:

   118

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

   119

        if movex != 0 or movey != 0:

   120

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

   121

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

   122

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

   123

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

   124

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

   125

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

   126

        return rect

   127

   128

    # Delete this step by calling the appropriate method

   129

    def Delete(self):

   130

        self.Parent.DeleteStep(self)

   131

   132

    # Unconnect input and output

   133

    def Clean(self):

   134

        if self.Input:

   135

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

   136

        if self.Output:

   137

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

   138

        if self.Action:

   139

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

   140

   141

    # Refresh the size of text for name

   142

    def RefreshNameSize(self):

   143

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

   144

   145

    # Add output connector to step

   146

    def AddInput(self):

   147

        if not self.Input:

   148

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

   149

            self.RefreshBoundingBox()

   150

   151

    # Remove output connector from step

   152

    def RemoveInput(self):

   153

        if self.Input:

   154

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

   155

            self.Input = None

   156

            self.RefreshBoundingBox()

   157

   158

    # Add output connector to step

   159

    def AddOutput(self):

   160

        if not self.Output:

   161

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

   162

            self.RefreshBoundingBox()

   163

   164

    # Remove output connector from step

   165

    def RemoveOutput(self):

   166

        if self.Output:

   167

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

   168

            self.Output = None

   169

            self.RefreshBoundingBox()

   170

   171

    # Add action connector to step

   172

    def AddAction(self):

   173

        if not self.Action:

   174

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

   175

            self.RefreshBoundingBox()

   176

   177

    # Remove action connector from step

   178

    def RemoveAction(self):

   179

        if self.Action:

   180

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

   181

            self.Action = None

   182

            self.RefreshBoundingBox()

   183

   184

    # Refresh the step bounding box

   185

    def RefreshBoundingBox(self):

   186

        # Calculate the bounding box size

   187

        if self.Action:

   188

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   189

        else:

   190

            bbx_width = self.Size[0]

   191

        if self.Initial:

   192

            bbx_y = self.Pos.y

   193

            bbx_height = self.Size[1]

   194

            if self.Output:

   195

                bbx_height += CONNECTOR_SIZE

   196

        else:

   197

            bbx_y = self.Pos.y - CONNECTOR_SIZE

   198

            bbx_height = self.Size[1] + CONNECTOR_SIZE

   199

            if self.Output:

   200

                bbx_height += CONNECTOR_SIZE

   201

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

   202

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

   203

   204

    # Refresh the positions of the step connectors

   205

    def RefreshConnectors(self):

   206

        scaling = self.Parent.GetScaling()

   207

        horizontal_pos = self.Size[0] / 2

   208

        vertical_pos = self.Size[1] / 2

   209

        if scaling is not None:

   210

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

   211

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

   212

        # Update input position if it exists

   213

        if self.Input:

   214

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

   215

        # Update output position

   216

        if self.Output:

   217

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

   218

        # Update action position if it exists

   219

        if self.Action:

   220

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

   221

        self.RefreshConnected()

   222

   223

    # Refresh the position of wires connected to step

   224

    def RefreshConnected(self, exclude = []):

   225

        if self.Input:

   226

            self.Input.MoveConnected(exclude)

   227

        if self.Output:

   228

            self.Output.MoveConnected(exclude)

   229

        if self.Action:

   230

            self.Action.MoveConnected(exclude)

   231

   232

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

   233

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

   234

        # if a name is given

   235

        if name:

   236

            # Test input, output and action connector if they exists

   237

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

   238

                return self.Input

   239

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

   240

                return self.Output

   241

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

   242

                return self.Action

   243

        # Test input connector if it exists

   244

        if self.Input:

   245

            input_pos = self.Input.GetRelPosition()

   246

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

   247

                return self.Input

   248

        # Test output connector if it exists

   249

        if self.Output:

   250

            output_pos = self.Output.GetRelPosition()

   251

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

   252

                return self.Output

   253

        # Test action connector if it exists

   254

        if self.Action:

   255

            action_pos = self.Action.GetRelPosition()

   256

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

   257

                return self.Action

   258

        return None

   259

   260

    # Returns input and output step connectors 

   261

    def GetConnectors(self):

   262

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

   263

   264

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

   265

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

   266

        # Test input connector if it exists

   267

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

   268

            return self.Input

   269

        # Test output connector

   270

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

   271

            return self.Output

   272

        # Test action connector

   273

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

   274

            return self.Action

   275

        return None

   276

   277

    # Changes the step name

   278

    def SetName(self, name):

   279

        self.Name = name

   280

        self.RefreshNameSize()

   281

   282

    # Returns the step name

   283

    def GetName(self):

   284

        return self.Name

   285

   286

    # Returns the step initial property

   287

    def GetInitial(self):

   288

        return self.Initial

   289

   290

    # Returns the connector connected to input

   291

    def GetPreviousConnector(self):

   292

        if self.Input:

   293

            wires = self.Input.GetWires()

   294

            if len(wires) == 1:

   295

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

   296

        return None

   297

   298

    # Returns the connector connected to output

   299

    def GetNextConnector(self):

   300

        if self.Output:

   301

            wires = self.Output.GetWires()

   302

            if len(wires) == 1:

   303

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

   304

        return None

   305

   306

    # Returns the connector connected to action

   307

    def GetActionConnector(self):

   308

        if self.Action:

   309

            wires = self.Action.GetWires()

   310

            if len(wires) == 1:

   311

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

   312

        return None

   313

   314

    # Returns the number of action line

   315

    def GetActionExtraLineNumber(self):

   316

        if self.Action:

   317

            wires = self.Action.GetWires()

   318

            if len(wires) != 1:

   319

                return 0

   320

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

   321

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

   322

        return 0

   323

   324

    # Returns the step minimum size

   325

    def GetMinSize(self):

   326

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

   327

        if self.Initial:

   328

            return text_width + 14, text_height + 14

   329

        else:

   330

            return text_width + 10, text_height + 10

   331

   332

    # Updates the step size

   333

    def UpdateSize(self, width, height):

   334

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

   335

        diffy = height - self.Size.GetHeight()

   336

        self.Move(diffx, 0)

   337

        Graphic_Element.SetSize(self, width, height)

   338

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

   339

            self.RefreshConnected()

   340

        else:

   341

            self.RefreshOutputPosition((0, diffy))

   342

   343

    # Align input element with this step

   344

    def RefreshInputPosition(self):

   345

        if self.Input:

   346

            current_pos = self.Input.GetPosition(False)

   347

            input = self.GetPreviousConnector()

   348

            if input:

   349

                input_pos = input.GetPosition(False)

   350

                diffx = current_pos.x - input_pos.x

   351

                input_block = input.GetParentBlock()

   352

                if isinstance(input_block, SFC_Divergence):

   353

                    input_block.MoveConnector(input, diffx)

   354

                else:

   355

                    if isinstance(input_block, SFC_Step):

   356

                        input_block.MoveActionBlock((diffx, 0))

   357

                    input_block.Move(diffx, 0)

   358

                    input_block.RefreshInputPosition()

   359

   360

    # Align output element with this step

   361

    def RefreshOutputPosition(self, move = None):

   362

        if self.Output:

   363

            wires = self.Output.GetWires()

   364

            if len(wires) != 1:

   365

                return

   366

            current_pos = self.Output.GetPosition(False)

   367

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

   368

            output_pos = output.GetPosition(False)

   369

            diffx = current_pos.x - output_pos.x

   370

            output_block = output.GetParentBlock()

   371

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

   372

            diffy = wire_size - output_pos.y + current_pos.y

   373

            if diffy != 0:

   374

                if isinstance(output_block, SFC_Step):

   375

                    output_block.MoveActionBlock((diffx, diffy))

   376

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

   377

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

   378

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

   379

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

   380

                    output_block.RefreshOutputPosition((diffx, diffy))

   381

                else:

   382

                    output_block.RefreshPosition()

   383

            elif move:

   384

                if isinstance(output_block, SFC_Step):

   385

                    output_block.MoveActionBlock(move)

   386

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

   387

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

   388

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

   389

                    output_block.RefreshOutputPosition(move)

   390

                else:

   391

                    output_block.RefreshPosition()

   392

            elif isinstance(output_block, SFC_Divergence):

   393

                output_block.MoveConnector(output, diffx)

   394

            else:

   395

                if isinstance(output_block, SFC_Step):

   396

                    output_block.MoveActionBlock((diffx, 0))

   397

                output_block.Move(diffx, 0)

   398

                output_block.RefreshOutputPosition()

   399

   400

    # Refresh action element with this step

   401

    def MoveActionBlock(self, move):

   402

        if self.Action:

   403

            wires = self.Action.GetWires()

   404

            if len(wires) != 1:

   405

                return

   406

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

   407

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

   408

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

   409

   410

    # Resize the divergence from position and size given

   411

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

   412

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

   413

            self.UpdateSize(width, height)

   414

        else:

   415

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

   416

   417

    # Method called when a LeftDClick event have been generated

   418

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

   419

        # Edit the step properties

   420

        self.Parent.EditStepContent(self)

   421

   422

    # Method called when a RightUp event have been generated

   423

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

   424

        # Popup the menu with special items for a step

   425

        self.Parent.PopupDefaultMenu()

   426

   427

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

   428

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

   429

        handle_type, handle = self.Handle

   430

        if handle_type == HANDLE_MOVE:

   431

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

   432

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

   433

            if scaling is not None:

   434

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

   435

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

   436

            action_block = None

   437

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

   438

                self.Move(movex, movey)

   439

                self.RefreshConnected()

   440

                return movex, movey

   441

            elif self.Initial:

   442

                self.MoveActionBlock((movex, movey))

   443

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

   444

                self.RefreshOutputPosition((movex, movey))

   445

                return movex, movey

   446

            else:

   447

                self.MoveActionBlock((movex, 0))

   448

                self.Move(movex, 0)

   449

                self.RefreshInputPosition()

   450

                self.RefreshOutputPosition()

   451

                return movex, 0

   452

        else:

   453

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

   454

   455

    # Refresh input element model

   456

    def RefreshInputModel(self):

   457

        if self.Input:

   458

            input = self.GetPreviousConnector()

   459

            if input:                

   460

                input_block = input.GetParentBlock()

   461

                input_block.RefreshModel(False)

   462

                if not isinstance(input_block, SFC_Divergence):

   463

                    input_block.RefreshInputModel()

   464

   465

    # Refresh output element model

   466

    def RefreshOutputModel(self, move=False):

   467

        if self.Output:

   468

            output = self.GetNextConnector()

   469

            if output:

   470

                output_block = output.GetParentBlock()

   471

                output_block.RefreshModel(False)

   472

                if not isinstance(output_block, SFC_Divergence) or move:

   473

                    output_block.RefreshOutputModel(move)

   474

   475

    # Refreshes the step model

   476

    def RefreshModel(self, move=True):

   477

        self.Parent.RefreshStepModel(self)

   478

        if self.Action:

   479

            action = self.GetActionConnector()

   480

            if action:

   481

                action_block = action.GetParentBlock()

   482

                action_block.RefreshModel(False)

   483

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

   484

        if move:

   485

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

   486

                self.RefreshInputModel()

   487

                self.RefreshOutputModel(self.Initial)

   488

            elif self.Output:

   489

                self.Output.RefreshWires()

   490

   491

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

   492

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

   493

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

   494

   495

    # Draws step

   496

    def Draw(self, dc):

   497

        Graphic_Element.Draw(self, dc)

   502

        dc.SetBrush(wx.WHITE_BRUSH)

   503

   504

        if getattr(dc, "printing", False):

   505

            name_size = dc.GetTextExtent(self.Name)

   506

        else:

   507

            name_size = self.NameSize

   508

   509

        # Draw two rectangles for representing the step