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

    61

    62

    # Destructor

    63

    def __del__(self):

    64

        self.Input = None

    65

        self.Output = None

    66

        self.Action = None

    67

    68

    # Make a clone of this SFC_Step

    69

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

    70

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

    71

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

    72

        if pos is not None:

    73

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

    74

        if self.Input:

    75

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

    76

        if self.Output:

    77

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

    78

        if self.Action:

    79

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

    80

        return step

    81

    82

    # Returns the RedrawRect

    83

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

    84

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

    85

        if self.Input:

    86

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

    87

        if self.Output:

    88

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

    89

        if self.Action:

    90

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

    91

        if movex != 0 or movey != 0:

    92

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

    93

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

    94

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

    95

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

    96

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

    97

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

    98

        return rect

    99

   100

    # Delete this step by calling the appropriate method

   101

    def Delete(self):

   102

        self.Parent.DeleteStep(self)

   103

   104

    # Unconnect input and output

   105

    def Clean(self):

   106

        if self.Input:

   107

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

   108

        if self.Output:

   109

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

   110

        if self.Action:

   111

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

   112

   113

    # Refresh the size of text for name

   114

    def RefreshNameSize(self):

   115

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

   116

   117

    # Add output connector to step

   118

    def AddInput(self):

   119

        if not self.Input:

   120

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

   121

            self.RefreshBoundingBox()

   122

   123

    # Remove output connector from step

   124

    def RemoveInput(self):

   125

        if self.Input:

   126

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

   127

            self.Input = None

   128

            self.RefreshBoundingBox()

   129

   130

    # Add output connector to step

   131

    def AddOutput(self):

   132

        if not self.Output:

   133

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

   134

            self.RefreshBoundingBox()

   135

   136

    # Remove output connector from step

   137

    def RemoveOutput(self):

   138

        if self.Output:

   139

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

   140

            self.Output = None

   141

            self.RefreshBoundingBox()

   142

   143

    # Add action connector to step

   144

    def AddAction(self):

   145

        if not self.Action:

   146

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

   147

            self.RefreshBoundingBox()

   148

   149

    # Remove action connector from step

   150

    def RemoveAction(self):

   151

        if self.Action:

   152

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

   153

            self.Action = None

   154

            self.RefreshBoundingBox()

   155

   156

    # Refresh the step bounding box

   157

    def RefreshBoundingBox(self):

   158

        # Calculate the bounding box size

   159

        if self.Action:

   160

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   161

        else:

   162

            bbx_width = self.Size[0]

   163

        if self.Initial:

   164

            bbx_y = self.Pos.y

   165

            bbx_height = self.Size[1]

   166

            if self.Output:

   167

                bbx_height += CONNECTOR_SIZE

   168

        else:

   169

            bbx_y = self.Pos.y - CONNECTOR_SIZE

   170

            bbx_height = self.Size[1] + CONNECTOR_SIZE

   171

            if self.Output:

   172

                bbx_height += CONNECTOR_SIZE

   173

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

   174

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

   175

   176

    # Refresh the positions of the step connectors

   177

    def RefreshConnectors(self):

   178

        scaling = self.Parent.GetScaling()

   179

        horizontal_pos = self.Size[0] / 2

   180

        vertical_pos = self.Size[1] / 2

   181

        if scaling is not None:

   182

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

   183

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

   184

        # Update input position if it exists

   185

        if self.Input:

   186

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

   187

        # Update output position

   188

        if self.Output:

   189

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

   190

        # Update action position if it exists

   191

        if self.Action:

   192

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

   193

        self.RefreshConnected()

   194

   195

    # Refresh the position of wires connected to step

   196

    def RefreshConnected(self, exclude = []):

   197

        if self.Input:

   198

            self.Input.MoveConnected(exclude)

   199

        if self.Output:

   200

            self.Output.MoveConnected(exclude)

   201

        if self.Action:

   202

            self.Action.MoveConnected(exclude)

   203

   204

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

   205

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

   206

        # if a name is given

   207

        if name:

   208

            # Test input, output and action connector if they exists

   209

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

   210

                return self.Input

   211

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

   212

                return self.Output

   213

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

   214

                return self.Action

   215

        # Test input connector if it exists

   216

        if self.Input:

   217

            input_pos = self.Input.GetRelPosition()

   218

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

   219

                return self.Input

   220

        # Test output connector if it exists

   221

        if self.Output:

   222

            output_pos = self.Output.GetRelPosition()

   223

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

   224

                return self.Output

   225

        # Test action connector if it exists

   226

        if self.Action:

   227

            action_pos = self.Action.GetRelPosition()

   228

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

   229

                return self.Action

   230

        return None

   231

   232

    # Returns input and output step connectors 

   233

    def GetConnectors(self):

   234

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

   235

   236

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

   237

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

   238

        # Test input connector if it exists

   239

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

   240

            return self.Input

   241

        # Test output connector

   242

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

   243

            return self.Output

   244

        # Test action connector

   245

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

   246

            return self.Action

   247

        return None

   248

   249

    # Changes the step name

   250

    def SetName(self, name):

   251

        self.Name = name

   252

        self.RefreshNameSize()

   253

   254

    # Returns the step name

   255

    def GetName(self):

   256

        return self.Name

   257

   258

    # Returns the step initial property

   259

    def GetInitial(self):

   260

        return self.Initial

   261

   262

    # Returns the connector connected to input

   263

    def GetPreviousConnector(self):

   264

        if self.Input:

   265

            wires = self.Input.GetWires()

   266

            if len(wires) == 1:

   267

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

   268

        return None

   269

   270

    # Returns the connector connected to output

   271

    def GetNextConnector(self):

   272

        if self.Output:

   273

            wires = self.Output.GetWires()

   274

            if len(wires) == 1:

   275

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

   276

        return None

   277

   278

    # Returns the connector connected to action

   279

    def GetActionConnector(self):

   280

        if self.Action:

   281

            wires = self.Action.GetWires()

   282

            if len(wires) == 1:

   283

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

   284

        return None

   285

   286

    # Returns the number of action line

   287

    def GetActionExtraLineNumber(self):

   288

        if self.Action:

   289

            wires = self.Action.GetWires()

   290

            if len(wires) != 1:

   291

                return 0

   292

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

   293

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

   294

        return 0

   295

   296

    # Returns the step minimum size

   297

    def GetMinSize(self):

   298

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

   299

        if self.Initial:

   300

            return text_width + 14, text_height + 14

   301

        else:

   302

            return text_width + 10, text_height + 10

   303

   304

    # Updates the step size

   305

    def UpdateSize(self, width, height):

   306

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

   307

        diffy = height - self.Size.GetHeight()

   308

        self.Move(diffx, 0)

   309

        Graphic_Element.SetSize(self, width, height)

   310

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

   311

            self.RefreshConnected()

   312

        else:

   313

            self.RefreshOutputPosition((0, diffy))

   314

   315

    # Align input element with this step

   316

    def RefreshInputPosition(self):

   317

        if self.Input:

   318

            current_pos = self.Input.GetPosition(False)

   319

            input = self.GetPreviousConnector()

   320

            if input:

   321

                input_pos = input.GetPosition(False)

   322

                diffx = current_pos.x - input_pos.x

   323

                input_block = input.GetParentBlock()

   324

                if isinstance(input_block, SFC_Divergence):

   325

                    input_block.MoveConnector(input, diffx)

   326

                else:

   327

                    if isinstance(input_block, SFC_Step):

   328

                        input_block.MoveActionBlock((diffx, 0))

   329

                    input_block.Move(diffx, 0)

   330

                    input_block.RefreshInputPosition()

   331

   332

    # Align output element with this step

   333

    def RefreshOutputPosition(self, move = None):

   334

        if self.Output:

   335

            wires = self.Output.GetWires()

   336

            if len(wires) != 1:

   337

                return

   338

            current_pos = self.Output.GetPosition(False)

   339

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

   340

            output_pos = output.GetPosition(False)

   341

            diffx = current_pos.x - output_pos.x

   342

            output_block = output.GetParentBlock()

   343

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

   344

            diffy = wire_size - output_pos.y + current_pos.y

   345

            if diffy != 0:

   346

                if isinstance(output_block, SFC_Step):

   347

                    output_block.MoveActionBlock((diffx, diffy))

   348

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

   349

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

   350

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

   351

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

   352

                    output_block.RefreshOutputPosition((diffx, diffy))

   353

                else:

   354

                    output_block.RefreshPosition()

   355

            elif move:

   356

                if isinstance(output_block, SFC_Step):

   357

                    output_block.MoveActionBlock(move)

   358

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

   359

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

   360

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

   361

                    output_block.RefreshOutputPosition(move)

   362

                else:

   363

                    output_block.RefreshPosition()

   364

            elif isinstance(output_block, SFC_Divergence):

   365

                output_block.MoveConnector(output, diffx)

   366

            else:

   367

                if isinstance(output_block, SFC_Step):

   368

                    output_block.MoveActionBlock((diffx, 0))

   369

                output_block.Move(diffx, 0)

   370

                output_block.RefreshOutputPosition()

   371

   372

    # Refresh action element with this step

   373

    def MoveActionBlock(self, move):

   374

        if self.Action:

   375

            wires = self.Action.GetWires()

   376

            if len(wires) != 1:

   377

                return

   378

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

   379

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

   380

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

   381

   382

    # Resize the divergence from position and size given

   383

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

   384

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

   385

            self.UpdateSize(width, height)

   386

        else:

   387

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

   388

   389

    # Method called when a LeftDClick event have been generated

   390

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

   391

        # Edit the step properties

   392

        self.Parent.EditStepContent(self)

   393

   394

    # Method called when a RightUp event have been generated

   395

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

   396

        # Popup the menu with special items for a step

   397

        self.Parent.PopupDefaultMenu()

   398

   399

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

   400

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

   401

        handle_type, handle = self.Handle

   402

        if handle_type == HANDLE_MOVE:

   403

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

   404

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

   405

            if scaling is not None:

   406

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

   407

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

   408

            action_block = None

   409

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

   410

                self.Move(movex, movey)

   411

                self.RefreshConnected()

   412

                return movex, movey

   413

            elif self.Initial:

   414

                self.MoveActionBlock((movex, movey))

   415

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

   416

                self.RefreshOutputPosition((movex, movey))

   417

                return movex, movey

   418

            else:

   419

                self.MoveActionBlock((movex, 0))

   420

                self.Move(movex, 0)

   421

                self.RefreshInputPosition()

   422

                self.RefreshOutputPosition()

   423

                return movex, 0

   424

        else:

   425

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

   426

   427

    # Refresh input element model

   428

    def RefreshInputModel(self):

   429

        if self.Input:

   430

            input = self.GetPreviousConnector()

   431

            if input:                

   432

                input_block = input.GetParentBlock()

   433

                input_block.RefreshModel(False)

   434

                if not isinstance(input_block, SFC_Divergence):

   435

                    input_block.RefreshInputModel()

   436

   437

    # Refresh output element model

   438

    def RefreshOutputModel(self, move=False):

   439

        if self.Output:

   440

            output = self.GetNextConnector()

   441

            if output:

   442

                output_block = output.GetParentBlock()

   443

                output_block.RefreshModel(False)

   444

                if not isinstance(output_block, SFC_Divergence) or move:

   445

                    output_block.RefreshOutputModel(move)

   446

   447

    # Refreshes the step model

   448

    def RefreshModel(self, move=True):

   449

        self.Parent.RefreshStepModel(self)

   450

        if self.Action:

   451

            action = self.GetActionConnector()

   452

            if action:

   453

                action_block = action.GetParentBlock()

   454

                action_block.RefreshModel(False)

   455

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

   456

        if move:

   457

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

   458

                self.RefreshInputModel()

   459

                self.RefreshOutputModel(self.Initial)

   460

            elif self.Output:

   461

                self.Output.RefreshWires()

   462

   463

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

   464

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

   465

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

   466

   467

    # Draws step

   468

    def Draw(self, dc):

   469

        Graphic_Element.Draw(self, dc)

   470

        dc.SetPen(wx.BLACK_PEN)

   471

        dc.SetBrush(wx.WHITE_BRUSH)

   472

   473

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

   474

            name_size = dc.GetTextExtent(self.Name)

   475

        else:

   476

            name_size = self.NameSize

   477

   478

        # Draw two rectangles for representing the step

   479

        dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)

   480

        if self.Initial:

   481

            dc.DrawRectangle(self.Pos.x + 2, self.Pos.y + 2, self.Size[0] - 3, self.Size[1] - 3)

   482

        # Draw step name

   483

        name_pos = (self.Pos.x + (self.Size[0] - name_size[0]) / 2,

   484

                    self.Pos.y + (self.Size[1] - name_size[1]) / 2)

   485

        dc.DrawText(self.Name, name_pos[0], name_pos[1])

   486

        # Draw input and output connectors

   487

        if self.Input:

   488

            self.Input.Draw(dc)

   489

        if self.Output:

   490

            self.Output.Draw(dc)

   491

        if self.Action:

   492

            self.Action.Draw(dc)

   493

        if self.Error is not None:

   494

            HighlightErrorZone(dc, name_pos[0], name_pos[1], name_size[0], name_size[1])

   495

   496

   497

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

   498

#                       Sequencial Function Chart Transition

   499

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

   500

   501

"""

   502

Class that implements the graphic representation of a transition

   503

"""

   504

   505

class SFC_Transition(Graphic_Element):

   506

   507

    # Create a new transition

   508

    def __init__(self, parent, type = "reference", condition = None, priority = 0, id = None):

   509

        Graphic_Element.__init__(self, parent)

   510

        self.Type = None

   511

        self.Id = id