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.Name = name

    50

        self.Initial = initial

    51

        self.Id = id

    52

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

    53

        # Create an input and output connector

    54

        if not self.Initial:

    55

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

    56

        else:

    57

            self.Input = None

    58

        self.Output = None

    59

        self.Action = None

    60

    61

    # Destructor

    62

    def __del__(self):

    63

        self.Input = None

    64

        self.Output = None

    65

        self.Action = None

    66

    67

    # Make a clone of this SFC_Step

    68

    def Clone(self, id = None, pos = None):

    69

        step = SFC_Step(self.Parent, self.Type, self.Name, id)

    70

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

    71

        if pos is not None:

    72

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

    73

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

    74

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

    75

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

    76

        return step

    77

    78

    # Delete this step by calling the appropriate method

    79

    def Delete(self):

    80

        self.Parent.DeleteStep(self)

    81

    82

    # Unconnect input and output

    83

    def Clean(self):

    84

        if self.Input:

    85

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

    86

        if self.Output:

    87

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

    88

        if self.Action:

    89

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

    90

    91

    # Add output connector to step

    92

    def AddInput(self):

    93

        if not self.Input:

    94

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

    95

            self.RefreshBoundingBox()

    96

    97

    # Remove output connector from step

    98

    def RemoveInput(self):

    99

        if self.Input:

   100

            self.Input.UnConnect()

   101

            self.Input = None

   102

            self.RefreshBoundingBox()

   103

   104

    # Add output connector to step

   105

    def AddOutput(self):

   106

        if not self.Output:

   107

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

   108

            self.RefreshBoundingBox()

   109

   110

    # Remove output connector from step

   111

    def RemoveOutput(self):

   112

        if self.Output:

   113

            self.Output.UnConnect()

   114

            self.Output = None

   115

            self.RefreshBoundingBox()

   116

   117

    # Add action connector to step

   118

    def AddAction(self):

   119

        if not self.Action:

   120

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

   121

            self.RefreshBoundingBox()

   122

   123

    # Remove action connector from step

   124

    def RemoveAction(self):

   125

        if self.Action:

   126

            self.Action.UnConnect()

   127

            self.Action = None

   128

            self.RefreshBoundingBox()

   129

   130

    # Refresh the step bounding box

   131

    def RefreshBoundingBox(self):

   132

        dc = wx.ClientDC(self.Parent)

   133

        # Calculate the bounding box size

   134

        if self.Action:

   135

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   136

        else:

   137

            bbx_width = self.Size[0]

   138

        if self.Initial:

   139

            bbx_y = self.Pos.y

   140

            bbx_height = self.Size[1]

   141

            if self.Output:

   142

                bbx_height += CONNECTOR_SIZE

   143

        else:

   144

            bbx_y = self.Pos.y - CONNECTOR_SIZE

   145

            bbx_height = self.Size[1] + CONNECTOR_SIZE

   146

            if self.Output:

   147

                bbx_height += CONNECTOR_SIZE

   148

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

   149

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

   150

   151

    # Refresh the positions of the step connectors

   152

    def RefreshConnectors(self):

   153

        # Update input position if it exists

   154

        if self.Input:

   155

            self.Input.SetPosition(wx.Point(self.Size[0] / 2, 0))

   156

        # Update output position

   157

        if self.Output:

   158

            self.Output.SetPosition(wx.Point(self.Size[0] / 2, self.Size[1]))

   159

        # Update action position if it exists

   160

        if self.Action:

   161

            self.Action.SetPosition(wx.Point(self.Size[0], self.Size[1] / 2))

   162

        self.RefreshConnected()

   163

   164

    # Refresh the position of wires connected to step

   165

    def RefreshConnected(self, exclude = []):

   166

        if self.Input:

   167

            self.Input.MoveConnected(exclude)

   168

        if self.Output:

   169

            self.Output.MoveConnected(exclude)

   170

        if self.Action:

   171

            self.Action.MoveConnected(exclude)

   172

   173

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

   174

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

   175

        # if a name is given

   176

        if name:

   177

            # Test input, output and action connector if they exists

   178

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

   179

                return self.Input

   180

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

   181

                return self.Output

   182

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

   183

                return self.Action

   184

        # Test input connector if it exists

   185

        if self.Input:

   186

            input_pos = self.Input.GetRelPosition()

   187

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

   188

                return self.Input

   189

        # Test output connector if it exists

   190

        if self.Output:

   191

            output_pos = self.Output.GetRelPosition()

   192

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

   193

                return self.Output

   194

        # Test action connector if it exists

   195

        if self.Action:

   196

            action_pos = self.Action.GetRelPosition()

   197

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

   198

                return self.Action

   199

        return None

   200

   201

    # Returns input and output step connectors 

   202

    def GetConnectors(self):

   203

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

   204

   205

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

   206

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

   207

        # Test input connector if it exists

   208

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

   209

            return self.Input

   210

        # Test output connector

   211

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

   212

            return self.Output

   213

        # Test action connector

   214

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

   215

            return self.Action

   216

        return None

   217

   218

    # Changes the step name

   219

    def SetName(self, name):

   220

        self.Name = name

   221

   222

    # Returns the step name

   223

    def GetName(self):

   224

        return self.Name

   225

   226

    # Returns the step initial property

   227

    def GetInitial(self):

   228

        return self.Initial

   229

   230

    # Returns the connector connected to input

   231

    def GetPreviousConnector(self):

   232

        if self.Input:

   233

            wires = self.Input.GetWires()

   234

            if len(wires) == 1:

   235

                return wires[0][0].EndConnected

   236

        return None

   237

   238

    # Returns the connector connected to output

   239

    def GetNextConnector(self):

   240

        if self.Output:

   241

            wires = self.Output.GetWires()

   242

            if len(wires) == 1:

   243

                return wires[0][0].StartConnected

   244

        return None

   245

   246

    # Returns the connector connected to action

   247

    def GetActionConnector(self):

   248

        if self.Action:

   249

            wires = self.Action.GetWires()

   250

            if len(wires) == 1:

   251

                return wires[0][0].StartConnected

   252

        return None

   253

   254

    # Returns the number of action line

   255

    def GetActionExtraLineNumber(self):

   256

        if self.Action:

   257

            wires = self.Action.GetWires()

   258

            if len(wires) != 1:

   259

                return 0

   260

            action_block = wires[0][0].StartConnected.GetParentBlock()

   261

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

   262

        return 0

   263

   264

    # Returns the step minimum size

   265

    def GetMinSize(self):

   266

        dc = wx.ClientDC(self.Parent)

   267

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

   268

        if self.Initial:

   269

            return text_width + 14, text_height + 14

   270

        else:

   271

            return text_width + 10, text_height + 10

   272

   273

    # Updates the step size

   274

    def UpdateSize(self, width, height):

   275

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

   276

        diffy = height - self.Size.GetHeight()

   277

        self.Move(diffx, 0)

   278

        Graphic_Element.SetSize(self, width, height)

   279

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

   280

            self.RefreshConnected()

   281

        else:

   282

            self.RefreshOutputPosition((0, diffy))

   283

   284

    # Align input element with this step

   285

    def RefreshInputPosition(self):

   286

        if self.Input:

   287

            current_pos = self.Input.GetPosition(False)

   288

            input = self.GetPreviousConnector()

   289

            if input:

   290

                input_pos = input.GetPosition(False)

   291

                diffx = current_pos.x - input_pos.x

   292

                input_block = input.GetParentBlock()

   293

                if isinstance(input_block, SFC_Divergence):

   294

                    input_block.MoveConnector(input, diffx)

   295

                else:

   296

                    if isinstance(input_block, SFC_Step):

   297

                        input_block.MoveActionBlock((diffx, 0))

   298

                    input_block.Move(diffx, 0)

   299

                    input_block.RefreshInputPosition()

   300

   301

    # Align output element with this step

   302

    def RefreshOutputPosition(self, move = None):

   303

        if self.Output:

   304

            wires = self.Output.GetWires()

   305

            if len(wires) != 1:

   306

                return

   307

            current_pos = self.Output.GetPosition(False)

   308

            output = wires[0][0].StartConnected

   309

            output_pos = output.GetPosition(False)

   310

            diffx = current_pos.x - output_pos.x

   311

            output_block = output.GetParentBlock()

   312

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

   313

            diffy = wire_size - output_pos.y + current_pos.y

   314

            if diffy != 0:

   315

                if isinstance(output_block, SFC_Step):

   316

                    output_block.MoveActionBlock((diffx, diffy))

   317

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

   318

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

   319

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

   320

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

   321

                    output_block.RefreshOutputPosition((diffx, diffy))

   322

                else:

   323

                    output_block.RefreshPosition()

   324

            elif move:

   325

                if isinstance(output_block, SFC_Step):

   326

                    output_block.MoveActionBlock(move)

   327

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

   328

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

   329

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

   330

                    output_block.RefreshOutputPosition(move)

   331

                else:

   332

                    output_block.RefreshPosition()

   333

            elif isinstance(output_block, SFC_Divergence):

   334

                output_block.MoveConnector(output, diffx)

   335

            else:

   336

                if isinstance(output_block, SFC_Step):

   337

                    output_block.MoveActionBlock((diffx, 0))

   338

                output_block.Move(diffx, 0)

   339

                output_block.RefreshOutputPosition()

   340

   341

    # Refresh action element with this step

   342

    def MoveActionBlock(self, move):

   343

        if self.Action:

   344

            wires = self.Action.GetWires()

   345

            if len(wires) != 1:

   346

                return

   347

            action_block = wires[0][0].StartConnected.GetParentBlock()

   348

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

   349

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

   350

   351

    # Resize the divergence from position and size given

   352

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

   353

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

   354

            self.UpdateSize(width, height)

   355

        else:

   356

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

   357

   358

    # Method called when a LeftDClick event have been generated

   359

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

   360

        # Edit the step properties

   361

        self.Parent.EditStepContent(self)

   362

   363

    # Method called when a RightUp event have been generated

   364

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

   365

        # Popup the menu with special items for a step

   366

        self.Parent.PopupDefaultMenu()

   367

   368

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

   369

    def ProcessDragging(self, movex, movey):

   370

        handle_type, handle = self.Handle

   371

        if handle_type == HANDLE_MOVE:

   372

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

   373

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

   374

            action_block = None

   375

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

   376

                self.Move(movex, movey)

   377

                self.RefreshConnected()

   378

                return movex, movey

   379

            elif self.Initial:

   380

                self.MoveActionBlock((movex, movey))

   381

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

   382

                self.RefreshOutputPosition((movex, movey))

   383

                return movex, movey

   384

            else:

   385

                self.MoveActionBlock((movex, 0))

   386

                self.Move(movex, 0)

   387

                self.RefreshInputPosition()

   388

                self.RefreshOutputPosition()

   389

                return movex, 0

   390

        else:

   391

            return Graphic_Element.ProcessDragging(self, movex, movey)

   392

   393

    # Refresh input element model

   394

    def RefreshInputModel(self):

   395

        if self.Input:

   396

            input = self.GetPreviousConnector()

   397

            if input:                

   398

                input_block = input.GetParentBlock()

   399

                input_block.RefreshModel(False)

   400

                if not isinstance(input_block, SFC_Divergence):

   401

                    input_block.RefreshInputModel()

   402

   403

    # Refresh output element model

   404

    def RefreshOutputModel(self, move=False):

   405

        if self.Output:

   406

            output = self.GetNextConnector()

   407

            if output:

   408

                output_block = output.GetParentBlock()

   409

                output_block.RefreshModel(False)

   410

                if not isinstance(output_block, SFC_Divergence) or move:

   411

                    output_block.RefreshOutputModel(move)

   412

   413

    # Refreshes the step model

   414

    def RefreshModel(self, move=True):

   415

        self.Parent.RefreshStepModel(self)

   416

        if self.Action:

   417

            action = self.GetActionConnector()

   418

            if action:

   419

                action_block = action.GetParentBlock()

   420

                action_block.RefreshModel(False)

   421

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

   422

        if move:

   423

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

   424

                self.RefreshInputModel()

   425

                self.RefreshOutputModel(self.Initial)

   426

            elif self.Output:

   427

                self.Output.RefreshWires()

   428

   429

    # Draws step

   430

    def Draw(self, dc):

   431

        dc.SetPen(wx.BLACK_PEN)

   432

        dc.SetBrush(wx.WHITE_BRUSH)

   433

        # Draw two rectangles for representing the step

   434

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

   435

        if self.Initial:

   436

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

   437

        # Draw step name

   438

        namewidth, nameheight = dc.GetTextExtent(self.Name)

   439

        dc.DrawText(self.Name, self.Pos.x + (self.Size[0] - namewidth) / 2,

   440

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

   441

        # Draw input and output connectors

   442

        if self.Input:

   443

            self.Input.Draw(dc)

   444

        if self.Output:

   445

            self.Output.Draw(dc)

   446

        if self.Action:

   447

            self.Action.Draw(dc)

   448

        Graphic_Element.Draw(self, dc)

   450

   451

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

   452

#                       Sequencial Function Chart Transition

   453

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

   454

   455

"""

   456

Class that implements the graphic representation of a transition

   457

"""

   458

   459

class SFC_Transition(Graphic_Element):

   460

   461

    # Create a new transition

   462

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

   463

        Graphic_Element.__init__(self, parent)

   464

        self.Type = None

   465

        self.Id = id

   466

        self.Priority = 0

   467

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

   468

        # Create an input and output connector

   469

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

   470

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

   471

        self.SetType(type, condition)

   472

        self.SetPriority(priority)

   473

   474

    # Destructor

   475

    def __del__(self):

   476

        self.Input = None

   477

        self.Output = None

   478

        if self.Type == "connection":

   479

            self.Condition = None

   480

   481

    # Make a clone of this SFC_Transition

   482

    def Clone(self, id = None, pos = None):

   483

        transition = SFC_Transition(self.Parent, self.Type, self.Condition, self.Priority, id)

   484

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

   485

        if pos is not None:

   486

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

   487

        transition.Input = self.Input.Clone(transition)

   488

        transition.Output = self.Output.Clone(transition)

   489

        return transition

   490

   491

    # Forbids to change the transition size

   492

    def SetSize(self, width, height):

   493

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

   494

            Graphic_Element.SetSize(self, width, height)

   495

   496

    # Forbids to resize the transition

   497

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

   498

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

   499

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

   500

   501

    # Refresh the size of text for name

   502

    def RefreshConditionSize(self):

   503

        if self.Type != "connection":

   504

            dc = wx.ClientDC(self.Parent)

   505

            if self.Condition != "":

   506

                self.ConditionSize = dc.GetTextExtent(self.Condition)

   507

            else:

   508

                self.ConditionSize = dc.GetTextExtent("Transition")

   509

   510

    # Refresh the size of text for name

   511

    def RefreshPrioritySize(self):

   512

        if self.Priority != "":

   513

            dc = wx.ClientDC(self.Parent)

   514

            self.PrioritySize = dc.GetTextExtent(str(self.Priority))

   515

        else: