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

#Lesser 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

from wxPython.wx import *

    26

import wx

    27

    28

from GraphicCommons import *

    29

from plcopen.structures import *

    30

    31

def GetWireSize(block):

    32

    if isinstance(block, SFC_Step):

    33

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

    34

    else:

    35

        return SFC_WIRE_MIN_SIZE

    36

    37

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

    38

#                         Sequencial Function Chart Step

    39

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

    40

    41

"""

    42

Class that implements the graphic representation of a step

    43

"""

    44

    45

class SFC_Step(Graphic_Element):

    46

    47

    # Create a new step

    48

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

    49

        Graphic_Element.__init__(self, parent)

    50

        self.Name = name

    51

        self.Initial = initial

    52

        self.Id = id

    53

        self.Size = wxSize(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, "", "ANY", wxPoint(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

    # Delete this step by calling the appropriate method

    69

    def Delete(self):

    70

        self.Parent.DeleteStep(self)

    71

    72

    # Unconnect input and output

    73

    def Clean(self):

    74

        if self.Input:

    75

            self.Input.UnConnect()

    76

        if self.Output:

    77

            self.Output.UnConnect()

    78

        if self.Action:

    79

            self.Action.UnConnect()

    80

    81

    # Add output connector to step

    82

    def AddOutput(self):

    83

        if not self.Output:

    84

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

    85

            self.RefreshBoundingBox()

    86

    87

    # Remove output connector from step

    88

    def RemoveOutput(self):

    89

        if self.Output:

    90

            self.Output.UnConnect()

    91

            self.Output = None

    92

            self.RefreshBoundingBox()

    93

    94

    # Add action connector to step

    95

    def AddAction(self):

    96

        if not self.Action:

    97

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

    98

            self.RefreshBoundingBox()

    99

   100

    # Remove action connector from step

   101

    def RemoveAction(self):

   102

        if self.Action:

   103

            self.Action.UnConnect()

   104

            self.Action = None

   105

            self.RefreshBoundingBox()

   106

   107

    # Refresh the step bounding box

   108

    def RefreshBoundingBox(self):

   109

        dc = wxClientDC(self.Parent)

   110

        # Calculate the bounding box size

   111

        if self.Action:

   112

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   113

        else:

   114

            bbx_width = self.Size[0]

   115

        if self.Initial:

   116

            bbx_y = self.Pos.y

   117

            bbx_height = self.Size[1]

   118

            if self.Output:

   119

                bbx_height += CONNECTOR_SIZE

   120

        else:

   121

            bbx_y = self.Pos.y - CONNECTOR_SIZE

   122

            bbx_height = self.Size[1] + CONNECTOR_SIZE

   123

            if self.Output:

   124

                bbx_height += CONNECTOR_SIZE

   125

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

   126

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

   127

   128

    # Refresh the positions of the step connectors

   129

    def RefreshConnectors(self):

   130

        # Update input position if it exists

   131

        if self.Input:

   132

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

   133

        # Update output position

   134

        if self.Output:

   135

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

   136

        # Update action position if it exists

   137

        if self.Action:

   138

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

   139

        self.RefreshConnected()

   140

   141

    # Refresh the position of wires connected to step

   142

    def RefreshConnected(self, exclude = []):

   143

        if self.Input:

   144

            self.Input.MoveConnected(exclude)

   145

        if self.Output:

   146

            self.Output.MoveConnected(exclude)

   147

        if self.Action:

   148

            self.Action.MoveConnected(exclude)

   149

   150

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

   151

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

   152

        # if a name is given

   153

        if name:

   154

            # Test input, output and action connector if they exists

   155

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

   156

                return self.Input

   157

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

   158

                return self.Output

   159

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

   160

                return self.Action

   161

        # Test input connector if it exists

   162

        if self.Input:

   163

            input_pos = self.Input.GetRelPosition()

   164

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

   165

                return self.Input

   166

        # Test output connector if it exists

   167

        if self.Output:

   168

            output_pos = self.Output.GetRelPosition()

   169

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

   170

                return self.Output

   171

        # Test action connector if it exists

   172

        if self.Action:

   173

            action_pos = self.Action.GetRelPosition()

   174

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

   175

                return self.Action

   176

        return None

   177

   178

    # Returns input and output step connectors 

   179

    def GetConnectors(self):

   180

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

   181

   182

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

   183

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

   184

        # Test input connector if it exists

   185

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

   186

            return self.Input

   187

        # Test output connector

   188

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

   189

            return self.Output

   190

        return None

   191

   192

    # Changes the step name

   193

    def SetName(self, name):

   194

        self.Name = name

   195

   196

    # Returns the step name

   197

    def GetName(self):

   198

        return self.Name

   199

   200

    # Returns the step initial property

   201

    def GetInitial(self):

   202

        return self.Initial

   203

   204

    # Returns the connector connected to input

   205

    def GetPreviousConnector(self):

   206

        if self.Input:

   207

            wires = self.Input.GetWires()

   208

            if len(wires) == 1:

   209

                return wires[0][0].EndConnected

   210

        return None

   211

   212

    # Returns the connector connected to output

   213

    def GetNextConnector(self):

   214

        if self.Output:

   215

            wires = self.Output.GetWires()

   216

            if len(wires) == 1:

   217

                return wires[0][0].StartConnected

   218

        return None

   219

   220

    # Returns the connector connected to action

   221

    def GetActionConnector(self):

   222

        if self.Action:

   223

            wires = self.Action.GetWires()

   224

            if len(wires) == 1:

   225

                return wires[0][0].StartConnected

   226

        return None

   227

   228

    # Returns the number of action line

   229

    def GetActionExtraLineNumber(self):

   230

        if self.Action:

   231

            wires = self.Action.GetWires()

   232

            if len(wires) != 1:

   233

                return 0

   234

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

   235

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

   236

        return 0

   237

   238

    # Returns the step minimum size

   239

    def GetMinSize(self):

   240

        dc = wxClientDC(self.Parent)

   241

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

   242

        if self.Initial:

   243

            return text_width + 14, text_height + 14

   244

        else:

   245

            return text_width + 10, text_height + 10

   246

   247

    # Updates the step size

   248

    def UpdateSize(self, width, height):

   249

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

   250

        diffy = height - self.Size.GetHeight()

   251

        self.Move(diffx, 0)

   252

        Graphic_Element.SetSize(self, width, height)

   253

        self.RefreshOutputPosition((0, diffy))

   254

   255

    # Align input element with this step

   256

    def RefreshInputPosition(self):

   257

        if self.Input:

   258

            current_pos = self.Input.GetPosition(False)

   259

            input = self.GetPreviousConnector()

   260

            if input:

   261

                input_pos = input.GetPosition(False)

   262

                diffx = current_pos.x - input_pos.x

   263

                input_block = input.GetParentBlock()

   264

                if isinstance(input_block, SFC_Divergence):

   265

                    input_block.MoveConnector(input, diffx)

   266

                else:

   267

                    if isinstance(input_block, SFC_Step):

   268

                        input_block.MoveActionBlock((diffx, 0))

   269

                    input_block.Move(diffx, 0)

   270

                    input_block.RefreshInputPosition()

   271

   272

    # Align output element with this step

   273

    def RefreshOutputPosition(self, move = None):

   274

        if self.Output:

   275

            wires = self.Output.GetWires()

   276

            if len(wires) != 1:

   277

                return

   278

            current_pos = self.Output.GetPosition(False)

   279

            output = wires[0][0].StartConnected

   280

            output_pos = output.GetPosition(False)

   281

            diffx = current_pos.x - output_pos.x

   282

            output_block = output.GetParentBlock()

   283

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

   284

            diffy = wire_size - output_pos.y + current_pos.y

   285

            if diffy != 0:

   286

                if isinstance(output_block, SFC_Step):

   287

                    output_block.MoveActionBlock((diffx, diffy))

   288

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

   289

                    wxPoint(current_pos.x, current_pos.y)])

   290

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

   291

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

   292

                    output_block.RefreshOutputPosition((diffx, diffy))

   293

                else:

   294

                    output_block.RefreshPosition()

   295

            elif move:

   296

                if isinstance(output_block, SFC_Step):

   297

                    output_block.MoveActionBlock(move)

   298

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

   299

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

   300

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

   301

                    output_block.RefreshOutputPosition(move)

   302

                else:

   303

                    output_block.RefreshPosition()

   304

            elif isinstance(output_block, SFC_Divergence):

   305

                output_block.MoveConnector(output, diffx)

   306

            else:

   307

                if isinstance(output_block, SFC_Step):

   308

                    output_block.MoveActionBlock((diffx, 0))

   309

                output_block.Move(diffx, 0)

   310

                output_block.RefreshOutputPosition()

   311

   312

    # Refresh action element with this step

   313

    def MoveActionBlock(self, move):

   314

        if self.Action:

   315

            wires = self.Action.GetWires()

   316

            if len(wires) != 1:

   317

                return

   318

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

   319

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

   320

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

   321

   322

    # Resize the divergence from position and size given

   323

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

   324

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

   325

            self.UpdateSize(width, height)

   326

        else:

   327

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

   328

   329

    # Method called when a LeftDClick event have been generated

   330

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

   331

        # Edit the step properties

   332

        self.Parent.EditStepContent(self)

   333

   334

    # Method called when a RightUp event have been generated

   335

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

   336

        # Popup the menu with special items for a step

   337

        self.Parent.PopupDefaultMenu()

   338

   339

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

   340

    def ProcessDragging(self, movex, movey):

   341

        handle_type, handle = self.Handle

   342

        if handle_type == HANDLE_MOVE:

   343

            action_block = None

   344

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

   345

                self.Move(movex, movey)

   346

                self.RefreshConnected()

   347

            elif self.Initial:

   348

                self.MoveActionBlock((movex, movey))

   349

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

   350

                self.RefreshOutputPosition((movex, movey))

   351

            else:

   352

                self.MoveActionBlock((movex, 0))

   353

                self.Move(movex, 0)

   354

                self.RefreshInputPosition()

   355

                self.RefreshOutputPosition()

   356

        else:

   357

            Graphic_Element.ProcessDragging(self, movex, movey)

   358

   359

    # Refresh input element model

   360

    def RefreshInputModel(self):

   361

        if self.Input:

   362

            input = self.GetPreviousConnector()

   363

            if input:                

   364

                input_block = input.GetParentBlock()

   365

                input_block.RefreshModel(False)

   366

                if not isinstance(input_block, SFC_Divergence):

   367

                    input_block.RefreshInputModel()

   368

   369

    # Refresh output element model

   370

    def RefreshOutputModel(self, move=False):

   371

        if self.Output:

   372

            output = self.GetNextConnector()

   373

            if output:

   374

                output_block = output.GetParentBlock()

   375

                output_block.RefreshModel(False)

   376

                if not isinstance(output_block, SFC_Divergence) or move:

   377

                    output_block.RefreshOutputModel(move)

   378

   379

    # Refreshes the step model

   380

    def RefreshModel(self, move=True):

   381

        self.Parent.RefreshStepModel(self)

   382

        if self.Action:

   383

            action = self.GetActionConnector()

   384

            if action:

   385

                action_block = action.GetParentBlock()

   386

                action_block.RefreshModel(False)

   387

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

   388

        if move:

   389

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

   390

                self.RefreshInputModel()

   391

                self.RefreshOutputModel(self.Initial)

   392

            elif self.Output:

   393

                self.Output.RefreshWires()

   394

   395

    # Draws step

   396

    def Draw(self, dc):

   397

        dc.SetPen(wxBLACK_PEN)

   398

        dc.SetBrush(wxWHITE_BRUSH)

   399

        # Draw two rectangles for representing the step

   400

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

   401

        if self.Initial:

   402

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

   403

        # Draw step name

   404

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

   405

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

   406

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

   407

        # Draw input and output connectors

   408

        if self.Input:

   409

            self.Input.Draw(dc)

   410

        if self.Output:

   411

            self.Output.Draw(dc)

   412

        if self.Action:

   413

            self.Action.Draw(dc)

   414

        Graphic_Element.Draw(self, dc)

   415

   416

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

   417

#                       Sequencial Function Chart Transition

   418

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

   419

   420

"""

   421

Class that implements the graphic representation of a transition

   422

"""

   423

   424

class SFC_Transition(Graphic_Element):

   425

   426

    # Create a new transition

   427

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

   428

        Graphic_Element.__init__(self, parent)

   429

        self.Type = type

   430

        self.Condition = condition

   431

        self.Id = id

   432

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

   433

        # Create an input and output connector

   434

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

   435

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

   436

   437

    # Destructor

   438

    def __del__(self):

   439

        self.Input = None

   440

        self.Output = None

   441

   442

    # Forbids to change the transition size

   443

    def SetSize(self, width, height):

   444

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

   445

            Graphic_Element.SetSize(self, width, height)

   446

   447

    # Forbids to resize the transition

   448

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

   449

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

   450

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

   451

   452

    # Delete this transition by calling the appropriate method

   453

    def Delete(self):

   454

        self.Parent.DeleteTransition(self)

   455

   456

    # Unconnect input and output

   457

    def Clean(self):

   458

        self.Input.UnConnect()

   459

        self.Output.UnConnect()

   460

   461

    # Refresh the transition bounding box

   462

    def RefreshBoundingBox(self):

   463

        dc = wxClientDC(self.Parent)

   464

        if self.Condition != "":

   465

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

   466

        else:

   467

            text_width, text_height = dc.GetTextExtent("Transition")

   468

        # Calculate the bounding box size

   469

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

   470

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

   471

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

   472

        self.BoundingBox = wxRect(self.Pos.x, bbx_y, bbx_width + 1, bbx_height - 4)

   473

   474

    # Returns the connector connected to input

   475

    def GetPreviousConnector(self):

   476

        wires = self.Input.GetWires()

   477

        if len(wires) == 1:

   478

            return wires[0][0].EndConnected

   479

        return None

   480

   481

    # Returns the connector connected to output

   482

    def GetNextConnector(self):

   483

        wires = self.Output.GetWires()

   484

        if len(wires) == 1:

   485

            return wires[0][0].StartConnected

   486

        return None

   487

   488

    # Refresh the positions of the transition connectors

   489

    def RefreshConnectors(self):

   490

        # Update input position

   491

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

   492

        # Update output position

   493

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

   494

        self.RefreshConnected()

   495

   496

    # Refresh the position of the wires connected to transition

   497

    def RefreshConnected(self, exclude = []):

   498

        self.Input.MoveConnected(exclude)

   499

        self.Output.MoveConnected(exclude)

   500

   501

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

   502

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

   503

        # if a name is given

   504

        if name:

   505

            # Test input and output connector

   506

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

   507

                return self.Input

   508

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

   509

                return self.Output

   510

        # Test input connector

   511

        input_pos = self.Input.GetRelPosition()

   512

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

   513

            return self.Input

   514

        # Test output connector

   515

        output_pos = self.Output.GetRelPosition()

   516

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

   517

            return self.Output

   518

        return None

   519

   520

    # Returns input and output transition connectors

   521

    def GetConnectors(self):

   522

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

   523

   524

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

   525

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