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, "", "ANY", 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

    # Delete this step by calling the appropriate method

    68

    def Delete(self):

    69

        self.Parent.DeleteStep(self)

    70

    71

    # Unconnect input and output

    72

    def Clean(self):

    73

        if self.Input:

    74

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

    75

        if self.Output:

    76

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

    77

        if self.Action:

    78

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

    79

    80

    # Add output connector to step

    81

    def AddOutput(self):

    82

        if not self.Output:

    83

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

    84

            self.RefreshBoundingBox()

    85

    86

    # Remove output connector from step

    87

    def RemoveOutput(self):

    88

        if self.Output:

    89

            self.Output.UnConnect()

    90

            self.Output = None

    91

            self.RefreshBoundingBox()

    92

    93

    # Add action connector to step

    94

    def AddAction(self):

    95

        if not self.Action:

    96

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

    97

            self.RefreshBoundingBox()

    98

    99

    # Remove action connector from step

   100

    def RemoveAction(self):

   101

        if self.Action:

   102

            self.Action.UnConnect()

   103

            self.Action = None

   104

            self.RefreshBoundingBox()

   105

   106

    # Refresh the step bounding box

   107

    def RefreshBoundingBox(self):

   108

        dc = wx.ClientDC(self.Parent)

   109

        # Calculate the bounding box size

   110

        if self.Action:

   111

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   112

        else:

   113

            bbx_width = self.Size[0]

   114

        if self.Initial:

   115

            bbx_y = self.Pos.y

   116

            bbx_height = self.Size[1]

   117

            if self.Output:

   118

                bbx_height += CONNECTOR_SIZE

   119

        else:

   120

            bbx_y = self.Pos.y - CONNECTOR_SIZE

   121

            bbx_height = self.Size[1] + CONNECTOR_SIZE

   122

            if self.Output:

   123

                bbx_height += CONNECTOR_SIZE

   124

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

   125

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

   126

   127

    # Refresh the positions of the step connectors

   128

    def RefreshConnectors(self):

   129

        # Update input position if it exists

   130

        if self.Input:

   131

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

   132

        # Update output position

   133

        if self.Output:

   134

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

   135

        # Update action position if it exists

   136

        if self.Action:

   137

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

   138

        self.RefreshConnected()

   139

   140

    # Refresh the position of wires connected to step

   141

    def RefreshConnected(self, exclude = []):

   142

        if self.Input:

   143

            self.Input.MoveConnected(exclude)

   144

        if self.Output:

   145

            self.Output.MoveConnected(exclude)

   146

        if self.Action:

   147

            self.Action.MoveConnected(exclude)

   148

   149

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

   150

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

   151

        # if a name is given

   152

        if name:

   153

            # Test input, output and action connector if they exists

   154

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

   155

                return self.Input

   156

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

   157

                return self.Output

   158

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

   159

                return self.Action

   160

        # Test input connector if it exists

   161

        if self.Input:

   162

            input_pos = self.Input.GetRelPosition()

   163

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

   164

                return self.Input

   165

        # Test output connector if it exists

   166

        if self.Output:

   167

            output_pos = self.Output.GetRelPosition()

   168

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

   169

                return self.Output

   170

        # Test action connector if it exists

   171

        if self.Action:

   172

            action_pos = self.Action.GetRelPosition()

   173

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

   174

                return self.Action

   175

        return None

   176

   177

    # Returns input and output step connectors 

   178

    def GetConnectors(self):

   179

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

   180

   181

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

   182

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

   183

        # Test input connector if it exists

   184

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

   185

            return self.Input

   186

        # Test output connector

   187

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

   188

            return self.Output

   189

        return None

   190

   191

    # Changes the step name

   192

    def SetName(self, name):

   193

        self.Name = name

   194

   195

    # Returns the step name

   196

    def GetName(self):

   197

        return self.Name

   198

   199

    # Returns the step initial property

   200

    def GetInitial(self):

   201

        return self.Initial

   202

   203

    # Returns the connector connected to input

   204

    def GetPreviousConnector(self):

   205

        if self.Input:

   206

            wires = self.Input.GetWires()

   207

            if len(wires) == 1:

   208

                return wires[0][0].EndConnected

   209

        return None

   210

   211

    # Returns the connector connected to output

   212

    def GetNextConnector(self):

   213

        if self.Output:

   214

            wires = self.Output.GetWires()

   215

            if len(wires) == 1:

   216

                return wires[0][0].StartConnected

   217

        return None

   218

   219

    # Returns the connector connected to action

   220

    def GetActionConnector(self):

   221

        if self.Action:

   222

            wires = self.Action.GetWires()

   223

            if len(wires) == 1:

   224

                return wires[0][0].StartConnected

   225

        return None

   226

   227

    # Returns the number of action line

   228

    def GetActionExtraLineNumber(self):

   229

        if self.Action:

   230

            wires = self.Action.GetWires()

   231

            if len(wires) != 1:

   232

                return 0

   233

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

   234

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

   235

        return 0

   236

   237

    # Returns the step minimum size

   238

    def GetMinSize(self):

   239

        dc = wx.ClientDC(self.Parent)

   240

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

   241

        if self.Initial:

   242

            return text_width + 14, text_height + 14

   243

        else:

   244

            return text_width + 10, text_height + 10

   245

   246

    # Updates the step size

   247

    def UpdateSize(self, width, height):

   248

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

   249

        diffy = height - self.Size.GetHeight()

   250

        self.Move(diffx, 0)

   251

        Graphic_Element.SetSize(self, width, height)

   252

        self.RefreshOutputPosition((0, diffy))

   253

   254

    # Align input element with this step

   255

    def RefreshInputPosition(self):

   256

        if self.Input:

   257

            current_pos = self.Input.GetPosition(False)

   258

            input = self.GetPreviousConnector()

   259

            if input:

   260

                input_pos = input.GetPosition(False)

   261

                diffx = current_pos.x - input_pos.x

   262

                input_block = input.GetParentBlock()

   263

                if isinstance(input_block, SFC_Divergence):

   264

                    input_block.MoveConnector(input, diffx)

   265

                else:

   266

                    if isinstance(input_block, SFC_Step):

   267

                        input_block.MoveActionBlock((diffx, 0))

   268

                    input_block.Move(diffx, 0)

   269

                    input_block.RefreshInputPosition()

   270

   271

    # Align output element with this step

   272

    def RefreshOutputPosition(self, move = None):

   273

        if self.Output:

   274

            wires = self.Output.GetWires()

   275

            if len(wires) != 1:

   276

                return

   277

            current_pos = self.Output.GetPosition(False)

   278

            output = wires[0][0].StartConnected

   279

            output_pos = output.GetPosition(False)

   280

            diffx = current_pos.x - output_pos.x

   281

            output_block = output.GetParentBlock()

   282

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

   283

            diffy = wire_size - output_pos.y + current_pos.y

   284

            if diffy != 0:

   285

                if isinstance(output_block, SFC_Step):

   286

                    output_block.MoveActionBlock((diffx, diffy))

   287

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

   288

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

   289

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

   290

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

   291

                    output_block.RefreshOutputPosition((diffx, diffy))

   292

                else:

   293

                    output_block.RefreshPosition()

   294

            elif move:

   295

                if isinstance(output_block, SFC_Step):

   296

                    output_block.MoveActionBlock(move)

   297

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

   298

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

   299

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

   300

                    output_block.RefreshOutputPosition(move)

   301

                else:

   302

                    output_block.RefreshPosition()

   303

            elif isinstance(output_block, SFC_Divergence):

   304

                output_block.MoveConnector(output, diffx)

   305

            else:

   306

                if isinstance(output_block, SFC_Step):

   307

                    output_block.MoveActionBlock((diffx, 0))

   308

                output_block.Move(diffx, 0)

   309

                output_block.RefreshOutputPosition()

   310

   311

    # Refresh action element with this step

   312

    def MoveActionBlock(self, move):

   313

        if self.Action:

   314

            wires = self.Action.GetWires()

   315

            if len(wires) != 1:

   316

                return

   317

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

   318

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

   319

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

   320

   321

    # Resize the divergence from position and size given

   322

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

   323

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

   324

            self.UpdateSize(width, height)

   325

        else:

   326

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

   327

   328

    # Method called when a LeftDClick event have been generated

   329

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

   330

        # Edit the step properties

   331

        self.Parent.EditStepContent(self)

   332

   333

    # Method called when a RightUp event have been generated

   334

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

   335

        # Popup the menu with special items for a step

   336

        self.Parent.PopupDefaultMenu()

   337

   338

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

   339

    def ProcessDragging(self, movex, movey):

   340

        handle_type, handle = self.Handle

   341

        if handle_type == HANDLE_MOVE:

   342

            action_block = None

   343

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

   344

                self.Move(movex, movey)

   345

                self.RefreshConnected()

   346

            elif self.Initial:

   347

                self.MoveActionBlock((movex, movey))

   348

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

   349

                self.RefreshOutputPosition((movex, movey))

   350

            else:

   351

                self.MoveActionBlock((movex, 0))

   352

                self.Move(movex, 0)

   353

                self.RefreshInputPosition()

   354

                self.RefreshOutputPosition()

   355

        else:

   356

            Graphic_Element.ProcessDragging(self, movex, movey)

   357

   358

    # Refresh input element model

   359

    def RefreshInputModel(self):

   360

        if self.Input:

   361

            input = self.GetPreviousConnector()

   362

            if input:                

   363

                input_block = input.GetParentBlock()

   364

                input_block.RefreshModel(False)

   365

                if not isinstance(input_block, SFC_Divergence):

   366

                    input_block.RefreshInputModel()

   367

   368

    # Refresh output element model

   369

    def RefreshOutputModel(self, move=False):

   370

        if self.Output:

   371

            output = self.GetNextConnector()

   372

            if output:

   373

                output_block = output.GetParentBlock()

   374

                output_block.RefreshModel(False)

   375

                if not isinstance(output_block, SFC_Divergence) or move:

   376

                    output_block.RefreshOutputModel(move)

   377

   378

    # Refreshes the step model

   379

    def RefreshModel(self, move=True):

   380

        self.Parent.RefreshStepModel(self)

   381

        if self.Action:

   382

            action = self.GetActionConnector()

   383

            if action:

   384

                action_block = action.GetParentBlock()

   385

                action_block.RefreshModel(False)

   386

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

   387

        if move:

   388

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

   389

                self.RefreshInputModel()

   390

                self.RefreshOutputModel(self.Initial)

   391

            elif self.Output:

   392

                self.Output.RefreshWires()

   393

   394

    # Draws step

   395

    def Draw(self, dc):

   396

        dc.SetPen(wx.BLACK_PEN)

   397

        dc.SetBrush(wx.WHITE_BRUSH)

   398

        # Draw two rectangles for representing the step

   399

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

   400

        if self.Initial:

   401

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

   402

        # Draw step name

   403

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

   404

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

   405

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

   406

        # Draw input and output connectors

   407

        if self.Input:

   408

            self.Input.Draw(dc)

   409

        if self.Output:

   410

            self.Output.Draw(dc)

   411

        if self.Action:

   412

            self.Action.Draw(dc)

   413

        Graphic_Element.Draw(self, dc)

   414

   415

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

   416

#                       Sequencial Function Chart Transition

   417

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

   418

   419

"""

   420

Class that implements the graphic representation of a transition

   421

"""

   422

   423

class SFC_Transition(Graphic_Element):

   424

   425

    # Create a new transition

   426

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

   427

        Graphic_Element.__init__(self, parent)

   428

        self.Type = None

   429

        self.Id = id

   430

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

   431

        # Create an input and output connector

   432

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

   433

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

   434

        self.SetType(type, condition)

   435

   436

    # Destructor

   437

    def __del__(self):

   438

        self.Input = None

   439

        self.Output = None

   440

        if self.Type == "connection":

   441

            self.Condition = None

   442

   443

    # Forbids to change the transition size

   444

    def SetSize(self, width, height):

   445

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

   446

            Graphic_Element.SetSize(self, width, height)

   447

   448

    # Forbids to resize the transition

   449

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

   450

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

   451

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

   452

   453

    # Refresh the size of text for name

   454

    def RefreshConditionSize(self):

   455

        if self.Type != "connection":

   456

            dc = wx.ClientDC(self.Parent)

   457

            if self.Condition != "":

   458

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

   459

            else:

   460

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

   461

   462

    # Delete this transition by calling the appropriate method

   463

    def Delete(self):

   464

        self.Parent.DeleteTransition(self)

   465

   466

    # Unconnect input and output

   467

    def Clean(self):

   468

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

   469

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

   470

        if self.Type == "connection":

   471

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

   472

   473

    # Refresh the transition bounding box

   474

    def RefreshBoundingBox(self):

   475

        dc = wx.ClientDC(self.Parent)

   476

        if self.Type == "connection":

   477

            bbx_x = self.Pos.x - CONNECTOR_SIZE

   478

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   479

            bbx_y = self.Pos.y

   480

            bbx_height = self.Size[1]

   481

        else:

   482

            text_width, text_height = self.ConditionSize

   483

            # Calculate the bounding box size

   484

            bbx_x = self.Pos.x

   485

            bbx_width = self.Size[0] + 5 + text_width

   486

            bbx_y = self.Pos.y - max(0, (text_height - 5 - self.Size[1]) / 2)

   487

            bbx_height = max(self.Size[1], text_height) - 5

   488

        self.BoundingBox = wx.Rect(bbx_x, bbx_y, bbx_width + 1, bbx_height + 1)

   489

   490

    # Returns the connector connected to input

   491

    def GetPreviousConnector(self):

   492

        wires = self.Input.GetWires()

   493

        if len(wires) == 1:

   494

            return wires[0][0].EndConnected

   495

        return None

   496

   497

    # Returns the connector connected to output

   498

    def GetNextConnector(self):

   499

        wires = self.Output.GetWires()

   500

        if len(wires) == 1:

   501

            return wires[0][0].StartConnected

   502

        return None

   503

   504

    # Refresh the positions of the transition connectors

   505

    def RefreshConnectors(self):

   506

        # Update input position

   507

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

   508

        # Update output position

   509

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

   510

        if self.Type == "connection":

   511

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

   512

        self.RefreshConnected()

   513

   514

    # Refresh the position of the wires connected to transition

   515

    def RefreshConnected(self, exclude = []):

   516

        self.Input.MoveConnected(exclude)

   517

        self.Output.MoveConnected(exclude)

   518

        if self.Type == "connection":