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

    26

from functools import cmp_to_key

    27

from operator import eq

    28

import wx

    29

    30

from graphics.GraphicCommons import *

    31

from graphics.DebugDataConsumer import DebugDataConsumer

    32

from plcopen.structures import *

    33

    34

    35

def GetWireSize(block):

    36

    if isinstance(block, SFC_Step):

    37

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

    38

    else:

    39

        return SFC_WIRE_MIN_SIZE

    40

    41

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

    42

#                         Sequencial Function Chart Step

    43

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

    44

    45

    46

class SFC_Step(Graphic_Element, DebugDataConsumer):

    47

    """

    48

    Class that implements the graphic representation of a step

    49

    """

    50

    51

    # Create a new step

    52

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

    53

        Graphic_Element.__init__(self, parent)

    54

        DebugDataConsumer.__init__(self)

    55

        self.SetName(name)

    56

        self.Initial = initial

    57

        self.Id = id

    58

        self.Highlights = []

    59

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

    60

        # Create an input and output connector

    61

        if not self.Initial:

    62

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

    63

        else:

    64

            self.Input = None

    65

        self.Output = None

    66

        self.Action = None

    67

        self.PreviousValue = None

    68

        self.PreviousSpreading = False

    69

    70

    def Flush(self):

    71

        if self.Input is not None:

    72

            self.Input.Flush()

    73

            self.Input = None

    74

        if self.Output is not None:

    75

            self.Output.Flush()

    76

            self.Output = None

    77

        if self.Action is not None:

    78

            self.Action.Flush()

    79

            self.Action = None

    80

    81

    def SetForced(self, forced):

    82

        if self.Forced != forced:

    83

            self.Forced = forced

    84

            if self.Visible:

    85

                self.Parent.ElementNeedRefresh(self)

    86

    87

    def SetValue(self, value):

    88

        self.PreviousValue = self.Value

    89

        self.Value = value

    90

        if self.Value != self.PreviousValue:

    91

            if self.Visible:

    92

                self.Parent.ElementNeedRefresh(self)

    93

            self.SpreadCurrent()

    94

    95

    def SpreadCurrent(self):

    96

        if self.Parent.Debug:

    97

            spreading = self.Value

    98

            if spreading and not self.PreviousSpreading:

    99

                if self.Output is not None:

   100

                    self.Output.SpreadCurrent(True)

   101

                if self.Action is not None:

   102

                    self.Action.SpreadCurrent(True)

   103

            elif not spreading and self.PreviousSpreading:

   104

                if self.Output is not None:

   105

                    self.Output.SpreadCurrent(False)

   106

                if self.Action is not None:

   107

                    self.Action.SpreadCurrent(False)

   108

            self.PreviousSpreading = spreading

   109

   110

    # Make a clone of this SFC_Step

   111

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

   112

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

   113

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

   114

        if pos is not None:

   115

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

   116

        else:

   117

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

   118

        if self.Input:

   119

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

   120

        if self.Output:

   121

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

   122

        if self.Action:

   123

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

   124

        return step

   125

   126

    def GetConnectorTranslation(self, element):

   127

        connectors = {}

   128

        if self.Input is not None:

   129

            connectors[self.Input] = element.Input

   130

        if self.Output is not None:

   131

            connectors[self.Output] = element.Output

   132

        if self.Action is not None:

   133

            connectors[self.Action] = element.Action

   134

        return connectors

   135

   136

    # Returns the RedrawRect

   137

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

   138

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

   139

        if self.Input:

   140

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

   141

        if self.Output:

   142

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

   143

        if self.Action:

   144

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

   145

        if movex != 0 or movey != 0:

   146

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

   147

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

   148

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

   149

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

   150

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

   151

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

   152

        return rect

   153

   154

    # Delete this step by calling the appropriate method

   155

    def Delete(self):

   156

        self.Parent.DeleteStep(self)

   157

   158

    # Unconnect input and output

   159

    def Clean(self):

   160

        if self.Input:

   161

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

   162

        if self.Output:

   163

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

   164

        if self.Action:

   165

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

   166

   167

    # Refresh the size of text for name

   168

    def RefreshNameSize(self):

   169

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

   170

   171

    # Add output connector to step

   172

    def AddInput(self):

   173

        if not self.Input:

   174

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

   175

            self.RefreshBoundingBox()

   176

   177

    # Remove output connector from step

   178

    def RemoveInput(self):

   179

        if self.Input:

   180

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

   181

            self.Input = None

   182

            self.RefreshBoundingBox()

   183

   184

    # Add output connector to step

   185

    def AddOutput(self):

   186

        if not self.Output:

   187

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

   188

            self.RefreshBoundingBox()

   189

   190

    # Remove output connector from step

   191

    def RemoveOutput(self):

   192

        if self.Output:

   193

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

   194

            self.Output = None

   195

            self.RefreshBoundingBox()

   196

   197

    # Add action connector to step

   198

    def AddAction(self):

   199

        if not self.Action:

   200

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

   201

            self.RefreshBoundingBox()

   202

   203

    # Remove action connector from step

   204

    def RemoveAction(self):

   205

        if self.Action:

   206

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

   207

            self.Action = None

   208

            self.RefreshBoundingBox()

   209

   210

    # Refresh the step bounding box

   211

    def RefreshBoundingBox(self):

   212

        # TODO: check and remove dead coded

   213

        #

   214

        # Calculate the bounding box size

   215

        # if self.Action:

   216

        #     bbx_width = self.Size[0] + CONNECTOR_SIZE

   217

        # else:

   218

        #     bbx_width = self.Size[0]

   219

        # if self.Initial:

   220

        #     bbx_y = self.Pos.y

   221

        #     bbx_height = self.Size[1]

   222

        #     if self.Output:

   223

        #         bbx_height += CONNECTOR_SIZE

   224

        # else:

   225

        #     bbx_y = self.Pos.y - CONNECTOR_SIZE

   226

        #     bbx_height = self.Size[1] + CONNECTOR_SIZE

   227

        #     if self.Output:

   228

        #         bbx_height += CONNECTOR_SIZE

   229

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

   230

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

   231

   232

    # Refresh the positions of the step connectors

   233

    def RefreshConnectors(self):

   234

        scaling = self.Parent.GetScaling()

   235

        horizontal_pos = self.Size[0] // 2

   236

        vertical_pos = self.Size[1] // 2

   237

        if scaling is not None:

   238

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

   239

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

   240

        # Update input position if it exists

   241

        if self.Input:

   242

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

   243

        # Update output position

   244

        if self.Output:

   245

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

   246

        # Update action position if it exists

   247

        if self.Action:

   248

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

   249

        self.RefreshConnected()

   250

   251

    # Refresh the position of wires connected to step

   252

    def RefreshConnected(self, exclude=None):

   253

        if self.Input:

   254

            self.Input.MoveConnected(exclude)

   255

        if self.Output:

   256

            self.Output.MoveConnected(exclude)

   257

        if self.Action:

   258

            self.Action.MoveConnected(exclude)

   259

   260

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

   261

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

   262

        # if a name is given

   263

        if name is not None:

   264

            # Test input, output and action connector if they exists

   265

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

   266

            #    return self.Input

   267

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

   268

                return self.Output

   269

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

   270

                return self.Action

   271

        connectors = []

   272

        # Test input connector if it exists

   273

        if self.Input:

   274

            connectors.append(self.Input)

   275

        # Test output connector if it exists

   276

        if self.Output:

   277

            connectors.append(self.Output)

   278

        # Test action connector if it exists

   279

        if self.Action:

   280

            connectors.append(self.Action)

   281

        return self.FindNearestConnector(position, connectors)

   282

   283

    # Returns action step connector

   284

    def GetActionConnector(self):

   285

        return self.Action

   286

   287

    # Returns input and output step connectors

   288

    def GetConnectors(self):

   289

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

   290

        if self.Input:

   291

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

   292

        if self.Output:

   293

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

   294

        return connectors

   295

   296

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

   297

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

   298

        # Test input connector if it exists

   299

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

   300

            return self.Input

   301

        # Test output connector

   302

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

   303

            return self.Output

   304

        # Test action connector

   305

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

   306

            return self.Action

   307

        return None

   308

   309

    # Changes the step name

   310

    def SetName(self, name):

   311

        self.Name = name

   312

        self.RefreshNameSize()

   313

   314

    # Returns the step name

   315

    def GetName(self):

   316

        return self.Name

   317

   318

    # Returns the step initial property

   319

    def GetInitial(self):

   320

        return self.Initial

   321

   322

    # Returns the connector connected to input

   323

    def GetPreviousConnector(self):

   324

        if self.Input:

   325

            wires = self.Input.GetWires()

   326

            if len(wires) == 1:

   327

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

   328

        return None

   329

   330

    # Returns the connector connected to output

   331

    def GetNextConnector(self):

   332

        if self.Output:

   333

            wires = self.Output.GetWires()

   334

            if len(wires) == 1:

   335

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

   336

        return None

   337

   338

    # Returns the connector connected to action

   339

    def GetActionConnected(self):

   340

        if self.Action:

   341

            wires = self.Action.GetWires()

   342

            if len(wires) == 1:

   343

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

   344

        return None

   345

   346

    # Returns the number of action line

   347

    def GetActionExtraLineNumber(self):

   348

        if self.Action:

   349

            wires = self.Action.GetWires()

   350

            if len(wires) != 1:

   351

                return 0

   352

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

   353

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

   354

        return 0

   355

   356

    # Returns the step minimum size

   357

    def GetMinSize(self):

   358

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

   359

        if self.Initial:

   360

            return text_width + 14, text_height + 14

   361

        else:

   362

            return text_width + 10, text_height + 10

   363

   364

    # Updates the step size

   365

    def UpdateSize(self, width, height):

   366

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

   367

        diffy = height - self.Size.GetHeight()

   368

        self.Move(diffx, 0)

   369

        Graphic_Element.SetSize(self, width, height)

   370

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

   371

            self.RefreshConnected()

   372

        else:

   373

            self.RefreshOutputPosition((0, diffy))

   374

   375

    # Align input element with this step

   376

    def RefreshInputPosition(self):

   377

        if self.Input:

   378

            current_pos = self.Input.GetPosition(False)

   379

            input = self.GetPreviousConnector()

   380

            if input:

   381

                input_pos = input.GetPosition(False)

   382

                diffx = current_pos.x - input_pos.x

   383

                input_block = input.GetParentBlock()

   384

                if isinstance(input_block, SFC_Divergence):

   385

                    input_block.MoveConnector(input, diffx)

   386

                else:

   387

                    if isinstance(input_block, SFC_Step):

   388

                        input_block.MoveActionBlock((diffx, 0))

   389

                    input_block.Move(diffx, 0)

   390

                    input_block.RefreshInputPosition()

   391

   392

    # Align output element with this step

   393

    def RefreshOutputPosition(self, move=None):

   394

        if self.Output:

   395

            wires = self.Output.GetWires()

   396

            if len(wires) != 1:

   397

                return

   398

            current_pos = self.Output.GetPosition(False)

   399

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

   400

            output_pos = output.GetPosition(False)

   401

            diffx = current_pos.x - output_pos.x

   402

            output_block = output.GetParentBlock()

   403

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

   404

            diffy = wire_size - output_pos.y + current_pos.y

   405

            if diffy != 0:

   406

                if isinstance(output_block, SFC_Step):

   407

                    output_block.MoveActionBlock((diffx, diffy))

   408

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

   409

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

   410

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

   411

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

   412

                    output_block.RefreshOutputPosition((diffx, diffy))

   413

                else:

   414

                    output_block.RefreshPosition()

   415

            elif move:

   416

                if isinstance(output_block, SFC_Step):

   417

                    output_block.MoveActionBlock(move)

   418

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

   419

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

   420

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

   421

                    output_block.RefreshOutputPosition(move)

   422

                else:

   423

                    output_block.RefreshPosition()

   424

            elif isinstance(output_block, SFC_Divergence):

   425

                output_block.MoveConnector(output, diffx)

   426

            else:

   427

                if isinstance(output_block, SFC_Step):

   428

                    output_block.MoveActionBlock((diffx, 0))

   429

                output_block.Move(diffx, 0)

   430

                output_block.RefreshOutputPosition()

   431

   432

    # Refresh action element with this step

   433

    def MoveActionBlock(self, move):

   434

        if self.Action:

   435

            wires = self.Action.GetWires()

   436

            if len(wires) != 1:

   437

                return

   438

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

   439

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

   440

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

   441

   442

    # Resize the divergence from position and size given

   443

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

   444

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

   445

            self.UpdateSize(width, height)

   446

        else:

   447

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

   448

   449

    # Method called when a LeftDClick event have been generated

   450

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

   451

        # Edit the step properties

   452

        self.Parent.EditStepContent(self)

   453

   454

    # Method called when a RightUp event have been generated

   455

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

   456

        # Popup the menu with special items for a step

   457

        self.Parent.PopupDefaultMenu()

   458

   459

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

   460

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

   461

        handle_type, _handle = self.Handle

   462

        if handle_type == HANDLE_MOVE:

   463

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

   464

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

   465

            if scaling is not None:

   466

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

   467

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

   468

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

   469

                self.Move(movex, movey)

   470

                self.RefreshConnected()

   471

                return movex, movey

   472

            elif self.Initial:

   473

                self.MoveActionBlock((movex, movey))

   474

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

   475

                self.RefreshOutputPosition((movex, movey))

   476

                return movex, movey

   477

            else:

   478

                self.MoveActionBlock((movex, 0))

   479

                self.Move(movex, 0)

   480

                self.RefreshInputPosition()

   481

                self.RefreshOutputPosition()

   482

                return movex, 0

   483

        else:

   484

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

   485

   486

    # Refresh input element model

   487

    def RefreshInputModel(self):

   488

        if self.Input:

   489

            input = self.GetPreviousConnector()

   490

            if input:

   491

                input_block = input.GetParentBlock()

   492

                input_block.RefreshModel(False)

   493

                if not isinstance(input_block, SFC_Divergence):

   494

                    input_block.RefreshInputModel()

   495

   496

    # Refresh output element model

   497

    def RefreshOutputModel(self, move=False):

   498

        if self.Output:

   499

            output = self.GetNextConnector()

   500

            if output:

   501

                output_block = output.GetParentBlock()

   502

                output_block.RefreshModel(False)

   503

                if not isinstance(output_block, SFC_Divergence) or move:

   504

                    output_block.RefreshOutputModel(move)

   505

   506

    # Refreshes the step model

   507

    def RefreshModel(self, move=True):

   508

        self.Parent.RefreshStepModel(self)

   509

        if self.Action:

   510

            action = self.GetActionConnected()

   511

            if action: