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

    32

def GetWireSize(block):

    33

    if isinstance(block, SFC_Step):

    34

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

    35

    else:

    36

        return SFC_WIRE_MIN_SIZE

    37

    38

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

    39

#                         Sequencial Function Chart Step

    40

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

    41

    42

    43

class SFC_Step(Graphic_Element, DebugDataConsumer):

    44

    """

    45

    Class that implements the graphic representation of a step

    46

    """

    47

    48

    # Create a new step

    49

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

    50

        Graphic_Element.__init__(self, parent)

    51

        DebugDataConsumer.__init__(self)

    52

        self.SetName(name)

    53

        self.Initial = initial

    54

        self.Id = id

    55

        self.Highlights = []

    56

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

    57

        # Create an input and output connector

    58

        if not self.Initial:

    59

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

    60

        else:

    61

            self.Input = None

    62

        self.Output = None

    63

        self.Action = None

    64

        self.PreviousValue = None

    65

        self.PreviousSpreading = False

    66

    67

    def Flush(self):

    68

        if self.Input is not None:

    69

            self.Input.Flush()

    70

            self.Input = None

    71

        if self.Output is not None:

    72

            self.Output.Flush()

    73

            self.Output = None

    74

        if self.Action is not None:

    75

            self.Action.Flush()

    76

            self.Action = None

    77

    78

    def SetForced(self, forced):

    79

        if self.Forced != forced:

    80

            self.Forced = forced

    81

            if self.Visible:

    82

                self.Parent.ElementNeedRefresh(self)

    83

    84

    def SetValue(self, value):

    85

        self.PreviousValue = self.Value

    86

        self.Value = value

    87

        if self.Value != self.PreviousValue:

    88

            if self.Visible:

    89

                self.Parent.ElementNeedRefresh(self)

    90

            self.SpreadCurrent()

    91

    92

    def SpreadCurrent(self):

    93

        if self.Parent.Debug:

    94

            spreading = self.Value

    95

            if spreading and not self.PreviousSpreading:

    96

                if self.Output is not None:

    97

                    self.Output.SpreadCurrent(True)

    98

                if self.Action is not None:

    99

                    self.Action.SpreadCurrent(True)

   100

            elif not spreading and self.PreviousSpreading:

   101

                if self.Output is not None:

   102

                    self.Output.SpreadCurrent(False)

   103

                if self.Action is not None:

   104

                    self.Action.SpreadCurrent(False)

   105

            self.PreviousSpreading = spreading

   106

   107

    # Make a clone of this SFC_Step

   108

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

   109

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

   110

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

   111

        if pos is not None:

   112

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

   113

        else:

   114

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

   115

        if self.Input:

   116

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

   117

        if self.Output:

   118

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

   119

        if self.Action:

   120

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

   121

        return step

   122

   123

    def GetConnectorTranslation(self, element):

   124

        connectors = {}

   125

        if self.Input is not None:

   126

            connectors[self.Input] = element.Input

   127

        if self.Output is not None:

   128

            connectors[self.Output] = element.Output

   129

        if self.Action is not None:

   130

            connectors[self.Action] = element.Action

   131

        return connectors

   132

   133

    # Returns the RedrawRect

   134

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

   135

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

   136

        if self.Input:

   137

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

   138

        if self.Output:

   139

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

   140

        if self.Action:

   141

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

   142

        if movex != 0 or movey != 0:

   143

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

   144

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

   145

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

   146

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

   147

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

   148

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

   149

        return rect

   150

   151

    # Delete this step by calling the appropriate method

   152

    def Delete(self):

   153

        self.Parent.DeleteStep(self)

   154

   155

    # Unconnect input and output

   156

    def Clean(self):

   157

        if self.Input:

   158

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

   159

        if self.Output:

   160

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

   161

        if self.Action:

   162

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

   163

   164

    # Refresh the size of text for name

   165

    def RefreshNameSize(self):

   166

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

   167

   168

    # Add output connector to step

   169

    def AddInput(self):

   170

        if not self.Input:

   171

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

   172

            self.RefreshBoundingBox()

   173

   174

    # Remove output connector from step

   175

    def RemoveInput(self):

   176

        if self.Input:

   177

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

   178

            self.Input = None

   179

            self.RefreshBoundingBox()

   180

   181

    # Add output connector to step

   182

    def AddOutput(self):

   183

        if not self.Output:

   184

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

   185

            self.RefreshBoundingBox()

   186

   187

    # Remove output connector from step

   188

    def RemoveOutput(self):

   189

        if self.Output:

   190

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

   191

            self.Output = None

   192

            self.RefreshBoundingBox()

   193

   194

    # Add action connector to step

   195

    def AddAction(self):

   196

        if not self.Action:

   197

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

   198

            self.RefreshBoundingBox()

   199

   200

    # Remove action connector from step

   201

    def RemoveAction(self):

   202

        if self.Action:

   203

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

   204

            self.Action = None

   205

            self.RefreshBoundingBox()

   206

   207

    # Refresh the step bounding box

   208

    def RefreshBoundingBox(self):

   209

        # TODO: check and remove dead coded

   210

        #

   211

        # Calculate the bounding box size

   212

        # if self.Action:

   213

        #     bbx_width = self.Size[0] + CONNECTOR_SIZE

   214

        # else:

   215

        #     bbx_width = self.Size[0]

   216

        # if self.Initial:

   217

        #     bbx_y = self.Pos.y

   218

        #     bbx_height = self.Size[1]

   219

        #     if self.Output:

   220

        #         bbx_height += CONNECTOR_SIZE

   221

        # else:

   222

        #     bbx_y = self.Pos.y - CONNECTOR_SIZE

   223

        #     bbx_height = self.Size[1] + CONNECTOR_SIZE

   224

        #     if self.Output:

   225

        #         bbx_height += CONNECTOR_SIZE

   226

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

   227

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

   228

   229

    # Refresh the positions of the step connectors

   230

    def RefreshConnectors(self):

   231

        scaling = self.Parent.GetScaling()

   232

        horizontal_pos = self.Size[0] / 2

   233

        vertical_pos = self.Size[1] / 2

   234

        if scaling is not None:

   235

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

   236

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

   237

        # Update input position if it exists

   238

        if self.Input:

   239

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

   240

        # Update output position

   241

        if self.Output:

   242

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

   243

        # Update action position if it exists

   244

        if self.Action:

   245

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

   246

        self.RefreshConnected()

   247

   248

    # Refresh the position of wires connected to step

   249

    def RefreshConnected(self, exclude=None):

   250

        if self.Input:

   251

            self.Input.MoveConnected(exclude)

   252

        if self.Output:

   253

            self.Output.MoveConnected(exclude)

   254

        if self.Action:

   255

            self.Action.MoveConnected(exclude)

   256

   257

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

   258

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

   259

        # if a name is given

   260

        if name is not None:

   261

            # Test input, output and action connector if they exists

   262

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

   263

            #    return self.Input

   264

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

   265

                return self.Output

   266

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

   267

                return self.Action

   268

        connectors = []

   269

        # Test input connector if it exists

   270

        if self.Input:

   271

            connectors.append(self.Input)

   272

        # Test output connector if it exists

   273

        if self.Output:

   274

            connectors.append(self.Output)

   275

        # Test action connector if it exists

   276

        if self.Action:

   277

            connectors.append(self.Action)

   278

        return self.FindNearestConnector(position, connectors)

   279

   280

    # Returns action step connector

   281

    def GetActionConnector(self):

   282

        return self.Action

   283

   284

    # Returns input and output step connectors

   285

    def GetConnectors(self):

   286

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

   287

        if self.Input:

   288

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

   289

        if self.Output:

   290

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

   291

        return connectors

   292

   293

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

   294

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

   295

        # Test input connector if it exists

   296

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

   297

            return self.Input

   298

        # Test output connector

   299

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

   300

            return self.Output

   301

        # Test action connector

   302

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

   303

            return self.Action

   304

        return None

   305

   306

    # Changes the step name

   307

    def SetName(self, name):

   308

        self.Name = name

   309

        self.RefreshNameSize()

   310

   311

    # Returns the step name

   312

    def GetName(self):

   313

        return self.Name

   314

   315

    # Returns the step initial property

   316

    def GetInitial(self):

   317

        return self.Initial

   318

   319

    # Returns the connector connected to input

   320

    def GetPreviousConnector(self):

   321

        if self.Input:

   322

            wires = self.Input.GetWires()

   323

            if len(wires) == 1:

   324

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

   325

        return None

   326

   327

    # Returns the connector connected to output

   328

    def GetNextConnector(self):

   329

        if self.Output:

   330

            wires = self.Output.GetWires()

   331

            if len(wires) == 1:

   332

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

   333

        return None

   334

   335

    # Returns the connector connected to action

   336

    def GetActionConnected(self):

   337

        if self.Action:

   338

            wires = self.Action.GetWires()

   339

            if len(wires) == 1:

   340

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

   341

        return None

   342

   343

    # Returns the number of action line

   344

    def GetActionExtraLineNumber(self):

   345

        if self.Action:

   346

            wires = self.Action.GetWires()

   347

            if len(wires) != 1:

   348

                return 0

   349

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

   350

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

   351

        return 0

   352

   353

    # Returns the step minimum size

   354

    def GetMinSize(self):

   355

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

   356

        if self.Initial:

   357

            return text_width + 14, text_height + 14

   358

        else:

   359

            return text_width + 10, text_height + 10

   360

   361

    # Updates the step size

   362

    def UpdateSize(self, width, height):

   363

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

   364

        diffy = height - self.Size.GetHeight()

   365

        self.Move(diffx, 0)

   366

        Graphic_Element.SetSize(self, width, height)

   367

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

   368

            self.RefreshConnected()

   369

        else:

   370

            self.RefreshOutputPosition((0, diffy))

   371

   372

    # Align input element with this step

   373

    def RefreshInputPosition(self):

   374

        if self.Input:

   375

            current_pos = self.Input.GetPosition(False)

   376

            input = self.GetPreviousConnector()

   377

            if input:

   378

                input_pos = input.GetPosition(False)

   379

                diffx = current_pos.x - input_pos.x

   380

                input_block = input.GetParentBlock()

   381

                if isinstance(input_block, SFC_Divergence):

   382

                    input_block.MoveConnector(input, diffx)

   383

                else:

   384

                    if isinstance(input_block, SFC_Step):

   385

                        input_block.MoveActionBlock((diffx, 0))

   386

                    input_block.Move(diffx, 0)

   387

                    input_block.RefreshInputPosition()

   388

   389

    # Align output element with this step

   390

    def RefreshOutputPosition(self, move=None):

   391

        if self.Output:

   392

            wires = self.Output.GetWires()

   393

            if len(wires) != 1:

   394

                return

   395

            current_pos = self.Output.GetPosition(False)

   396

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

   397

            output_pos = output.GetPosition(False)

   398

            diffx = current_pos.x - output_pos.x

   399

            output_block = output.GetParentBlock()

   400

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

   401

            diffy = wire_size - output_pos.y + current_pos.y

   402

            if diffy != 0:

   403

                if isinstance(output_block, SFC_Step):

   404

                    output_block.MoveActionBlock((diffx, diffy))

   405

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

   406

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

   407

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

   408

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

   409

                    output_block.RefreshOutputPosition((diffx, diffy))

   410

                else:

   411

                    output_block.RefreshPosition()

   412

            elif move:

   413

                if isinstance(output_block, SFC_Step):

   414

                    output_block.MoveActionBlock(move)

   415

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

   416

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

   417

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

   418

                    output_block.RefreshOutputPosition(move)

   419

                else:

   420

                    output_block.RefreshPosition()

   421

            elif isinstance(output_block, SFC_Divergence):

   422

                output_block.MoveConnector(output, diffx)

   423

            else:

   424

                if isinstance(output_block, SFC_Step):

   425

                    output_block.MoveActionBlock((diffx, 0))

   426

                output_block.Move(diffx, 0)

   427

                output_block.RefreshOutputPosition()

   428

   429

    # Refresh action element with this step

   430

    def MoveActionBlock(self, move):

   431

        if self.Action:

   432

            wires = self.Action.GetWires()

   433

            if len(wires) != 1:

   434

                return

   435

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

   436

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

   437

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

   438

   439

    # Resize the divergence from position and size given

   440

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

   441

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

   442

            self.UpdateSize(width, height)

   443

        else:

   444

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

   445

   446

    # Method called when a LeftDClick event have been generated

   447

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

   448

        # Edit the step properties

   449

        self.Parent.EditStepContent(self)

   450

   451

    # Method called when a RightUp event have been generated

   452

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

   453

        # Popup the menu with special items for a step

   454

        self.Parent.PopupDefaultMenu()

   455

   456

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

   457

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

   458

        handle_type, _handle = self.Handle

   459

        if handle_type == HANDLE_MOVE:

   460

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

   461

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

   462

            if scaling is not None:

   463

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

   464

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

   465

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

   466

                self.Move(movex, movey)

   467

                self.RefreshConnected()

   468

                return movex, movey

   469

            elif self.Initial:

   470

                self.MoveActionBlock((movex, movey))

   471

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

   472

                self.RefreshOutputPosition((movex, movey))

   473

                return movex, movey

   474

            else:

   475

                self.MoveActionBlock((movex, 0))

   476

                self.Move(movex, 0)

   477

                self.RefreshInputPosition()

   478

                self.RefreshOutputPosition()

   479

                return movex, 0

   480

        else:

   481

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

   482

   483

    # Refresh input element model

   484

    def RefreshInputModel(self):

   485

        if self.Input:

   486

            input = self.GetPreviousConnector()

   487

            if input:

   488

                input_block = input.GetParentBlock()

   489

                input_block.RefreshModel(False)

   490

                if not isinstance(input_block, SFC_Divergence):

   491

                    input_block.RefreshInputModel()

   492

   493

    # Refresh output element model

   494

    def RefreshOutputModel(self, move=False):

   495

        if self.Output:

   496

            output = self.GetNextConnector()

   497

            if output:

   498

                output_block = output.GetParentBlock()

   499

                output_block.RefreshModel(False)

   500

                if not isinstance(output_block, SFC_Divergence) or move:

   501

                    output_block.RefreshOutputModel(move)

   502

   503

    # Refreshes the step model

   504

    def RefreshModel(self, move=True):

   505

        self.Parent.RefreshStepModel(self)

   506

        if self.Action:

   507

            action = self.GetActionConnected()

   508

            if action:

   509

                action_block = action.GetParentBlock()

   510

                action_block.RefreshModel(False)

   511

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

   512

        if move:

   513

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