1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import wx

    26

    27

from graphics.GraphicCommons import *

    28

from graphics.DebugDataConsumer import DebugDataConsumer

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

    46

    47

    # Create a new step

    48

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

    49

        Graphic_Element.__init__(self, parent)

    50

        DebugDataConsumer.__init__(self)

    51

        self.SetName(name)

    52

        self.Initial = initial

    53

        self.Id = id

    54

        self.Highlights = []

    55

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

    56

        # Create an input and output connector

    57

        if not self.Initial:

    58

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

    59

        else:

    60

            self.Input = None

    61

        self.Output = None

    62

        self.Action = None

    63

        self.PreviousValue = None

    64

        self.PreviousSpreading = False

    65

    66

    def Flush(self):

    67

        if self.Input is not None:

    68

            self.Input.Flush()

    69

            self.Input = None

    70

        if self.Output is not None:

    71

            self.Output.Flush()

    72

            self.Output = None

    73

        if self.Output is not None:

    74

            self.Action.Flush()

    75

            self.Action = None

    76

    77

    def SetForced(self, forced):

    78

        if self.Forced != forced:

    79

            self.Forced = forced

    80

            if self.Visible:

    81

                self.Parent.ElementNeedRefresh(self)

    82

    83

    def SetValue(self, value):

    84

        self.PreviousValue = self.Value

    85

        self.Value = value

    86

        if self.Value != self.PreviousValue:

    87

            if self.Visible:

    88

                self.Parent.ElementNeedRefresh(self)

    89

            self.SpreadCurrent()

    90

    91

    def SpreadCurrent(self):

    92

        if self.Parent.Debug:

    93

            spreading = self.Value

    94

            if spreading and not self.PreviousSpreading:

    95

                if self.Output is not None:

    96

                    self.Output.SpreadCurrent(True)

    97

                if self.Action is not None:

    98

                    self.Action.SpreadCurrent(True)

    99

            elif not spreading and self.PreviousSpreading:

   100

                if self.Output is not None:

   101

                    self.Output.SpreadCurrent(False)

   102

                if self.Action is not None:

   103

                    self.Action.SpreadCurrent(False)

   104

            self.PreviousSpreading = spreading

   105

   106

    # Make a clone of this SFC_Step

   107

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

   108

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

   109

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

   110

        if pos is not None:

   111

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

   112

        else:

   113

            step.SetPosition(self.Pos.x, self.Pos.y)

   114

        if self.Input:

   115

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

   116

        if self.Output:

   117

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

   118

        if self.Action:

   119

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

   120

        return step

   121

   122

    def GetConnectorTranslation(self, element):

   123

        connectors = {}

   124

        if self.Input is not None:

   125

            connectors[self.Input] = element.Input

   126

        if self.Output is not None:

   127

            connectors[self.Output] = element.Output

   128

        if self.Action is not None:

   129

            connectors[self.Action] = element.Action

   130

        return connectors

   131

   132

    # Returns the RedrawRect

   133

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

   134

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

   135

        if self.Input:

   136

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

   137

        if self.Output:

   138

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

   139

        if self.Action:

   140

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

   141

        if movex != 0 or movey != 0:

   142

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

   143

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

   144

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

   145

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

   146

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

   147

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

   148

        return rect

   149

   150

    # Delete this step by calling the appropriate method

   151

    def Delete(self):

   152

        self.Parent.DeleteStep(self)

   153

   154

    # Unconnect input and output

   155

    def Clean(self):

   156

        if self.Input:

   157

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

   158

        if self.Output:

   159

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

   160

        if self.Action:

   161

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

   162

   163

    # Refresh the size of text for name

   164

    def RefreshNameSize(self):

   165

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

   166

   167

    # Add output connector to step

   168

    def AddInput(self):

   169

        if not self.Input:

   170

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

   171

            self.RefreshBoundingBox()

   172

   173

    # Remove output connector from step

   174

    def RemoveInput(self):

   175

        if self.Input:

   176

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

   177

            self.Input = None

   178

            self.RefreshBoundingBox()

   179

   180

    # Add output connector to step

   181

    def AddOutput(self):

   182

        if not self.Output:

   183

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

   184

            self.RefreshBoundingBox()

   185

   186

    # Remove output connector from step

   187

    def RemoveOutput(self):

   188

        if self.Output:

   189

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

   190

            self.Output = None

   191

            self.RefreshBoundingBox()

   192

   193

    # Add action connector to step

   194

    def AddAction(self):

   195

        if not self.Action:

   196

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

   197

            self.RefreshBoundingBox()

   198

   199

    # Remove action connector from step

   200

    def RemoveAction(self):

   201

        if self.Action:

   202

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

   203

            self.Action = None

   204

            self.RefreshBoundingBox()

   205

   206

    # Refresh the step bounding box

   207

    def RefreshBoundingBox(self):

   208

        # Calculate the bounding box size

   209

        if self.Action:

   210

            bbx_width = self.Size[0] + CONNECTOR_SIZE

   211

        else:

   212

            bbx_width = self.Size[0]

   213

        if self.Initial:

   214

            bbx_y = self.Pos.y

   215

            bbx_height = self.Size[1]

   216

            if self.Output:

   217

                bbx_height += CONNECTOR_SIZE

   218

        else:

   219

            bbx_y = self.Pos.y - CONNECTOR_SIZE

   220

            bbx_height = self.Size[1] + CONNECTOR_SIZE

   221

            if self.Output:

   222

                bbx_height += CONNECTOR_SIZE

   223

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

   224

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

   225

   226

    # Refresh the positions of the step connectors

   227

    def RefreshConnectors(self):

   228

        scaling = self.Parent.GetScaling()

   229

        horizontal_pos = self.Size[0] / 2

   230

        vertical_pos = self.Size[1] / 2

   231

        if scaling is not None:

   232

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

   233

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

   234

        # Update input position if it exists

   235

        if self.Input:

   236

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

   237

        # Update output position

   238

        if self.Output:

   239

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

   240

        # Update action position if it exists

   241

        if self.Action:

   242

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

   243

        self.RefreshConnected()

   244

   245

    # Refresh the position of wires connected to step

   246

    def RefreshConnected(self, exclude = []):

   247

        if self.Input:

   248

            self.Input.MoveConnected(exclude)

   249

        if self.Output:

   250

            self.Output.MoveConnected(exclude)

   251

        if self.Action:

   252

            self.Action.MoveConnected(exclude)

   253

   254

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

   255

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

   256

        # if a name is given

   257

        if name is not None:

   258

            # Test input, output and action connector if they exists

   259

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

   260

            #    return self.Input

   261

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

   262

                return self.Output

   263

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

   264

                return self.Action

   265

        connectors = []

   266

        # Test input connector if it exists

   267

        if self.Input:

   268

            connectors.append(self.Input)

   269

        # Test output connector if it exists

   270

        if self.Output:

   271

            connectors.append(self.Output)

   272

        # Test action connector if it exists

   273

        if self.Action:

   274

            connectors.append(self.Action)

   275

        return self.FindNearestConnector(position, connectors)

   276

   277

    # Returns action step connector 

   278

    def GetActionConnector(self):

   279

        return self.Action

   280

   281

    # Returns input and output step connectors 

   282

    def GetConnectors(self):

   283

        connectors = {"inputs": [], "outputs": []}

   284

        if self.Input:

   285

            connectors["inputs"].append(self.Input)

   286

        if self.Output:

   287

            connectors["outputs"].append(self.Output)

   288

        return connectors

   289

   290

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

   291

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

   292

        # Test input connector if it exists

   293

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

   294

            return self.Input

   295

        # Test output connector

   296

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

   297

            return self.Output

   298

        # Test action connector

   299

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

   300

            return self.Action

   301

        return None

   302

   303

    # Changes the step name

   304

    def SetName(self, name):

   305

        self.Name = name

   306

        self.RefreshNameSize()

   307

   308

    # Returns the step name

   309

    def GetName(self):

   310

        return self.Name

   311

   312

    # Returns the step initial property

   313

    def GetInitial(self):

   314

        return self.Initial

   315

   316

    # Returns the connector connected to input

   317

    def GetPreviousConnector(self):

   318

        if self.Input:

   319

            wires = self.Input.GetWires()

   320

            if len(wires) == 1:

   321

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

   322

        return None

   323

   324

    # Returns the connector connected to output

   325

    def GetNextConnector(self):

   326

        if self.Output:

   327

            wires = self.Output.GetWires()

   328

            if len(wires) == 1:

   329

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

   330

        return None

   331

   332

    # Returns the connector connected to action

   333

    def GetActionConnected(self):

   334

        if self.Action:

   335

            wires = self.Action.GetWires()

   336

            if len(wires) == 1:

   337

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

   338

        return None

   339

   340

    # Returns the number of action line

   341

    def GetActionExtraLineNumber(self):

   342

        if self.Action:

   343

            wires = self.Action.GetWires()

   344

            if len(wires) != 1:

   345

                return 0

   346

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

   347

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

   348

        return 0

   349

   350

    # Returns the step minimum size

   351

    def GetMinSize(self):

   352

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

   353

        if self.Initial:

   354

            return text_width + 14, text_height + 14

   355

        else:

   356

            return text_width + 10, text_height + 10

   357

   358

    # Updates the step size

   359

    def UpdateSize(self, width, height):

   360

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

   361

        diffy = height - self.Size.GetHeight()

   362

        self.Move(diffx, 0)

   363

        Graphic_Element.SetSize(self, width, height)

   364

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

   365

            self.RefreshConnected()

   366

        else:

   367

            self.RefreshOutputPosition((0, diffy))

   368

   369

    # Align input element with this step

   370

    def RefreshInputPosition(self):

   371

        if self.Input:

   372

            current_pos = self.Input.GetPosition(False)

   373

            input = self.GetPreviousConnector()

   374

            if input:

   375

                input_pos = input.GetPosition(False)

   376

                diffx = current_pos.x - input_pos.x

   377

                input_block = input.GetParentBlock()

   378

                if isinstance(input_block, SFC_Divergence):

   379

                    input_block.MoveConnector(input, diffx)

   380

                else:

   381

                    if isinstance(input_block, SFC_Step):

   382

                        input_block.MoveActionBlock((diffx, 0))

   383

                    input_block.Move(diffx, 0)

   384

                    input_block.RefreshInputPosition()

   385

   386

    # Align output element with this step

   387

    def RefreshOutputPosition(self, move = None):

   388

        if self.Output:

   389

            wires = self.Output.GetWires()

   390

            if len(wires) != 1:

   391

                return

   392

            current_pos = self.Output.GetPosition(False)

   393

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

   394

            output_pos = output.GetPosition(False)

   395

            diffx = current_pos.x - output_pos.x

   396

            output_block = output.GetParentBlock()

   397

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

   398

            diffy = wire_size - output_pos.y + current_pos.y

   399

            if diffy != 0:

   400

                if isinstance(output_block, SFC_Step):

   401

                    output_block.MoveActionBlock((diffx, diffy))

   402

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

   403

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

   404

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

   405

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

   406

                    output_block.RefreshOutputPosition((diffx, diffy))

   407

                else:

   408

                    output_block.RefreshPosition()

   409

            elif move:

   410

                if isinstance(output_block, SFC_Step):

   411

                    output_block.MoveActionBlock(move)

   412

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

   413

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

   414

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

   415

                    output_block.RefreshOutputPosition(move)

   416

                else:

   417

                    output_block.RefreshPosition()

   418

            elif isinstance(output_block, SFC_Divergence):

   419

                output_block.MoveConnector(output, diffx)

   420

            else:

   421

                if isinstance(output_block, SFC_Step):

   422

                    output_block.MoveActionBlock((diffx, 0))

   423

                output_block.Move(diffx, 0)

   424

                output_block.RefreshOutputPosition()

   425

   426

    # Refresh action element with this step

   427

    def MoveActionBlock(self, move):

   428

        if self.Action:

   429

            wires = self.Action.GetWires()

   430

            if len(wires) != 1:

   431

                return

   432

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

   433

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

   434

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

   435

   436

    # Resize the divergence from position and size given

   437

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

   438

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

   439

            self.UpdateSize(width, height)

   440

        else:

   441

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

   442

   443

    # Method called when a LeftDClick event have been generated

   444

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

   445

        # Edit the step properties

   446

        self.Parent.EditStepContent(self)

   447

   448

    # Method called when a RightUp event have been generated

   449

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

   450

        # Popup the menu with special items for a step

   451

        self.Parent.PopupDefaultMenu()

   452

   453

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

   454

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

   455

        handle_type, handle = self.Handle

   456

        if handle_type == HANDLE_MOVE:

   457

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

   458

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

   459

            if scaling is not None:

   460

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

   461

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

   462

            action_block = None

   463

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

   464

                self.Move(movex, movey)

   465

                self.RefreshConnected()

   466

                return movex, movey

   467

            elif self.Initial:

   468

                self.MoveActionBlock((movex, movey))

   469

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

   470

                self.RefreshOutputPosition((movex, movey))

   471

                return movex, movey

   472

            else:

   473

                self.MoveActionBlock((movex, 0))

   474

                self.Move(movex, 0)

   475

                self.RefreshInputPosition()

   476

                self.RefreshOutputPosition()

   477

                return movex, 0

   478

        else:

   479

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

   480

   481

    # Refresh input element model

   482

    def RefreshInputModel(self):

   483

        if self.Input:

   484

            input = self.GetPreviousConnector()

   485

            if input:                

   486

                input_block = input.GetParentBlock()

   487

                input_block.RefreshModel(False)

   488

                if not isinstance(input_block, SFC_Divergence):

   489

                    input_block.RefreshInputModel()

   490

   491

    # Refresh output element model

   492

    def RefreshOutputModel(self, move=False):

   493

        if self.Output:

   494

            output = self.GetNextConnector()

   495

            if output:

   496

                output_block = output.GetParentBlock()

   497

                output_block.RefreshModel(False)

   498

                if not isinstance(output_block, SFC_Divergence) or move:

   499

                    output_block.RefreshOutputModel(move)

   500

   501

    # Refreshes the step model

   502

    def RefreshModel(self, move=True):

   503

        self.Parent.RefreshStepModel(self)

   504

        if self.Action:

   505

            action = self.GetActionConnected()

   506

            if action:

   507

                action_block = action.GetParentBlock()

   508

                action_block.RefreshModel(False)

   509

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

   510

        if move:

   511

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

   512

                self.RefreshInputModel()

   513

                self.RefreshOutputModel(self.Initial)

   514

            elif self.Output:

   515

                self.Output.RefreshWires()

   516

   517

    # Adds an highlight to the connection

   518

    def AddHighlight(self, infos, start, end, highlight_type):

   519

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

   520

            AddHighlight(self.Highlights, (start, end, highlight_type))

   521

   522

    # Removes an highlight from the connection

   523

    def RemoveHighlight(self, infos, start, end, highlight_type):

   524

        if infos[0] == "name":

   525

            RemoveHighlight(self.Highlights, (start, end, highlight_type))

   526

   527

    # Removes all the highlights of one particular type from the connection