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 __future__ import absolute_import

    28

import wx

    29

from six.moves import xrange

    30

    31

from graphics.GraphicCommons import *

    32

from graphics.DebugDataConsumer import DebugDataConsumer

    33

from plcopen.structures import *

    34

    35

    36

def GetWireSize(block):

    37

    if isinstance(block, SFC_Step):

    38

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

    39

    else:

    40

        return SFC_WIRE_MIN_SIZE

    41

    42

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

    43

#                         Sequencial Function Chart Step

    44

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

    45

    46

    47

class SFC_Step(Graphic_Element, DebugDataConsumer):

    48

    """

    49

    Class that implements the graphic representation of a step

    50

    """

    51

    52

    # Create a new step

    53

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

    54

        Graphic_Element.__init__(self, parent)

    55

        DebugDataConsumer.__init__(self)

    56

        self.SetName(name)

    57

        self.Initial = initial

    58

        self.Id = id

    59

        self.Highlights = []

    60

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

    61

        # Create an input and output connector

    62

        if not self.Initial:

    64

        else:

    65

            self.Input = None

    66

        self.Output = None

    67

        self.Action = None

    68

        self.PreviousValue = None

    69

        self.PreviousSpreading = False

    70

    71

    def Flush(self):

    72

        if self.Input is not None:

    73

            self.Input.Flush()

    74

            self.Input = None

    75

        if self.Output is not None:

    76

            self.Output.Flush()

    77

            self.Output = None

    78

        if self.Action is not None:

    79

            self.Action.Flush()

    80

            self.Action = None

    81

    82

    def SetForced(self, forced):

    83

        if self.Forced != forced:

    84

            self.Forced = forced

    85

            if self.Visible:

    86

                self.Parent.ElementNeedRefresh(self)

    87

    88

    def SetValue(self, value):

    89

        self.PreviousValue = self.Value

    90

        self.Value = value

    91

        if self.Value != self.PreviousValue:

    92

            if self.Visible:

    93

                self.Parent.ElementNeedRefresh(self)

    94

            self.SpreadCurrent()

    95

    96

    def SpreadCurrent(self):

    97

        if self.Parent.Debug:

    98

            spreading = self.Value

    99

            if spreading and not self.PreviousSpreading:

   100

                if self.Output is not None:

   101

                    self.Output.SpreadCurrent(True)

   102

                if self.Action is not None:

   103

                    self.Action.SpreadCurrent(True)

   104

            elif not spreading and self.PreviousSpreading:

   105

                if self.Output is not None:

   106

                    self.Output.SpreadCurrent(False)

   107

                if self.Action is not None:

   108

                    self.Action.SpreadCurrent(False)

   109

            self.PreviousSpreading = spreading

   110

   111

    # Make a clone of this SFC_Step

   112

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

   113

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

   114

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

   115

        if pos is not None:

   116

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

   117

        else:

   118

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

   119

        if self.Input:

   120

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

   121

        if self.Output:

   122

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

   123

        if self.Action:

   124

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

   125

        return step

   126

   127

    def GetConnectorTranslation(self, element):

   128

        connectors = {}

   129

        if self.Input is not None:

   130

            connectors[self.Input] = element.Input

   131

        if self.Output is not None:

   132

            connectors[self.Output] = element.Output

   133

        if self.Action is not None:

   134

            connectors[self.Action] = element.Action

   135

        return connectors

   136

   137

    # Returns the RedrawRect

   138

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

   139

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

   140

        if self.Input:

   141

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

   142

        if self.Output:

   143

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

   144

        if self.Action:

   145

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

   146

        if movex != 0 or movey != 0:

   147

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

   148

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

   149

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

   150

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

   151

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

   152

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

   153

        return rect

   154

   155

    # Delete this step by calling the appropriate method

   156

    def Delete(self):

   157

        self.Parent.DeleteStep(self)

   158

   159

    # Unconnect input and output

   160

    def Clean(self):

   161

        if self.Input:

   162

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

   163

        if self.Output:

   164

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

   165

        if self.Action:

   166

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

   167

   168

    # Refresh the size of text for name

   169

    def RefreshNameSize(self):

   170

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

   171

   172

    # Add output connector to step

   173

    def AddInput(self):

   174

        if not self.Input:

   176

            self.RefreshBoundingBox()

   177

   178

    # Remove output connector from step

   179

    def RemoveInput(self):

   180

        if self.Input:

   181

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

   182

            self.Input = None

   183

            self.RefreshBoundingBox()

   184

   185

    # Add output connector to step

   186

    def AddOutput(self):

   187

        if not self.Output:

   189

            self.RefreshBoundingBox()

   190

   191

    # Remove output connector from step

   192

    def RemoveOutput(self):

   193

        if self.Output:

   194

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

   195

            self.Output = None

   196

            self.RefreshBoundingBox()

   197

   198

    # Add action connector to step

   199

    def AddAction(self):

   200

        if not self.Action:

   202

            self.RefreshBoundingBox()

   203

   204

    # Remove action connector from step

   205

    def RemoveAction(self):

   206

        if self.Action:

   207

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

   208

            self.Action = None

   209

            self.RefreshBoundingBox()

   210

   211

    # Refresh the step bounding box

   212

    def RefreshBoundingBox(self):

   213

        # TODO: check and remove dead coded

   214

        #

   215

        # Calculate the bounding box size

   216

        # if self.Action:

   217

        #     bbx_width = self.Size[0] + CONNECTOR_SIZE

   218

        # else:

   219

        #     bbx_width = self.Size[0]

   220

        # if self.Initial:

   221

        #     bbx_y = self.Pos.y

   222

        #     bbx_height = self.Size[1]

   223

        #     if self.Output:

   224

        #         bbx_height += CONNECTOR_SIZE

   225

        # else:

   226

        #     bbx_y = self.Pos.y - CONNECTOR_SIZE

   227

        #     bbx_height = self.Size[1] + CONNECTOR_SIZE

   228

        #     if self.Output:

   229

        #         bbx_height += CONNECTOR_SIZE

   230

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

   231

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

   232

   233

    # Refresh the positions of the step connectors

   234

    def RefreshConnectors(self):

   235

        scaling = self.Parent.GetScaling()

   238

        if scaling is not None:

   241

        # Update input position if it exists

   242

        if self.Input:

   243

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

   244

        # Update output position

   245

        if self.Output:

   246

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

   247

        # Update action position if it exists

   248

        if self.Action:

   249

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

   250

        self.RefreshConnected()

   251

   252

    # Refresh the position of wires connected to step

   253

    def RefreshConnected(self, exclude=None):

   254

        if self.Input:

   255

            self.Input.MoveConnected(exclude)

   256

        if self.Output:

   257

            self.Output.MoveConnected(exclude)

   258

        if self.Action:

   259

            self.Action.MoveConnected(exclude)

   260

   261

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

   262

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

   263

        # if a name is given

   264

        if name is not None:

   265

            # Test input, output and action connector if they exists

   266

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

   267

            #    return self.Input

   268

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

   269

                return self.Output

   270

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

   271

                return self.Action

   272

        connectors = []

   273

        # Test input connector if it exists

   274

        if self.Input:

   275

            connectors.append(self.Input)

   276

        # Test output connector if it exists

   277

        if self.Output:

   278

            connectors.append(self.Output)

   279

        # Test action connector if it exists

   280

        if self.Action:

   281

            connectors.append(self.Action)

   282

        return self.FindNearestConnector(position, connectors)

   283

   284

    # Returns action step connector

   285

    def GetActionConnector(self):

   286

        return self.Action

   287

   288

    # Returns input and output step connectors

   289

    def GetConnectors(self):

   290

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

   291

        if self.Input:

   292

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

   293

        if self.Output:

   294

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

   295

        return connectors

   296

   297

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

   298

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

   299

        # Test input connector if it exists

   300

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

   301

            return self.Input

   302

        # Test output connector

   303

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

   304

            return self.Output

   305

        # Test action connector

   306

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

   307

            return self.Action

   308

        return None

   309

   310

    # Changes the step name

   311

    def SetName(self, name):

   312

        self.Name = name

   313

        self.RefreshNameSize()

   314

   315

    # Returns the step name

   316

    def GetName(self):

   317

        return self.Name

   318

   319

    # Returns the step initial property

   320

    def GetInitial(self):

   321

        return self.Initial

   322

   323

    # Returns the connector connected to input

   324

    def GetPreviousConnector(self):

   325

        if self.Input:

   326

            wires = self.Input.GetWires()

   327

            if len(wires) == 1:

   328

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

   329

        return None

   330

   331

    # Returns the connector connected to output

   332

    def GetNextConnector(self):

   333

        if self.Output:

   334

            wires = self.Output.GetWires()

   335

            if len(wires) == 1:

   336

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

   337

        return None

   338

   339

    # Returns the connector connected to action

   340

    def GetActionConnected(self):

   341

        if self.Action:

   342

            wires = self.Action.GetWires()

   343

            if len(wires) == 1:

   344

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

   345

        return None

   346

   347

    # Returns the number of action line

   348

    def GetActionExtraLineNumber(self):

   349

        if self.Action:

   350

            wires = self.Action.GetWires()

   351

            if len(wires) != 1:

   352

                return 0

   353

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

   354

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

   355

        return 0

   356

   357

    # Returns the step minimum size

   358

    def GetMinSize(self):

   359

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

   360

        if self.Initial:

   361

            return text_width + 14, text_height + 14

   362

        else:

   363

            return text_width + 10, text_height + 10

   364

   365

    # Updates the step size

   366

    def UpdateSize(self, width, height):

   368

        diffy = height - self.Size.GetHeight()

   369

        self.Move(diffx, 0)

   370

        Graphic_Element.SetSize(self, width, height)

   371

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

   372

            self.RefreshConnected()

   373

        else:

   374

            self.RefreshOutputPosition((0, diffy))

   375

   376

    # Align input element with this step

   377

    def RefreshInputPosition(self):

   378

        if self.Input:

   379

            current_pos = self.Input.GetPosition(False)

   380

            input = self.GetPreviousConnector()

   381

            if input:

   382

                input_pos = input.GetPosition(False)

   383

                diffx = current_pos.x - input_pos.x

   384

                input_block = input.GetParentBlock()

   385

                if isinstance(input_block, SFC_Divergence):

   386

                    input_block.MoveConnector(input, diffx)

   387

                else:

   388

                    if isinstance(input_block, SFC_Step):

   389

                        input_block.MoveActionBlock((diffx, 0))

   390

                    input_block.Move(diffx, 0)

   391

                    input_block.RefreshInputPosition()

   392

   393

    # Align output element with this step

   394

    def RefreshOutputPosition(self, move=None):

   395

        if self.Output:

   396

            wires = self.Output.GetWires()

   397

            if len(wires) != 1:

   398

                return

   399

            current_pos = self.Output.GetPosition(False)

   400

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

   401

            output_pos = output.GetPosition(False)

   402

            diffx = current_pos.x - output_pos.x

   403

            output_block = output.GetParentBlock()

   404

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

   405

            diffy = wire_size - output_pos.y + current_pos.y

   406

            if diffy != 0:

   407

                if isinstance(output_block, SFC_Step):

   408

                    output_block.MoveActionBlock((diffx, diffy))

   409

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

   410

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

   411

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

   412

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

   413

                    output_block.RefreshOutputPosition((diffx, diffy))

   414

                else:

   415

                    output_block.RefreshPosition()

   416

            elif move:

   417

                if isinstance(output_block, SFC_Step):

   418

                    output_block.MoveActionBlock(move)

   419

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

   420

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

   421

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

   422

                    output_block.RefreshOutputPosition(move)

   423

                else:

   424

                    output_block.RefreshPosition()

   425

            elif isinstance(output_block, SFC_Divergence):

   426

                output_block.MoveConnector(output, diffx)

   427

            else:

   428

                if isinstance(output_block, SFC_Step):

   429

                    output_block.MoveActionBlock((diffx, 0))

   430

                output_block.Move(diffx, 0)

   431

                output_block.RefreshOutputPosition()

   432

   433

    # Refresh action element with this step

   434

    def MoveActionBlock(self, move):

   435

        if self.Action:

   436

            wires = self.Action.GetWires()

   437

            if len(wires) != 1:

   438

                return

   439

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

   440

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

   441

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

   442

   443

    # Resize the divergence from position and size given

   444

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

   445

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

   446

            self.UpdateSize(width, height)

   447

        else:

   448

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

   449

   450

    # Method called when a LeftDClick event have been generated

   451

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

   452

        # Edit the step properties

   453

        self.Parent.EditStepContent(self)

   454

   455

    # Method called when a RightUp event have been generated

   456

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

   457

        # Popup the menu with special items for a step

   458

        self.Parent.PopupDefaultMenu()

   459

   460

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

   461

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

   462

        handle_type, _handle = self.Handle

   463

        if handle_type == HANDLE_MOVE:

   464

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

   465

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

   466

            if scaling is not None:

   469

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

   470

                self.Move(movex, movey)

   471

                self.RefreshConnected()

   472

                return movex, movey

   473

            elif self.Initial:

   474

                self.MoveActionBlock((movex, movey))

   475

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

   476

                self.RefreshOutputPosition((movex, movey))

   477

                return movex, movey

   478

            else:

   479

                self.MoveActionBlock((movex, 0))

   480

                self.Move(movex, 0)

   481

                self.RefreshInputPosition()

   482

                self.RefreshOutputPosition()

   483

                return movex, 0

   484

        else:

   485

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

   486

   487

    # Refresh input element model

   488

    def RefreshInputModel(self):

   489

        if self.Input:

   490

            input = self.GetPreviousConnector()

   491

            if input:

   492

                input_block = input.GetParentBlock()

   493

                input_block.RefreshModel(False)

   494

                if not isinstance(input_block, SFC_Divergence):

   495

                    input_block.RefreshInputModel()

   496

   497

    # Refresh output element model

   498

    def RefreshOutputModel(self, move=False):

   499

        if self.Output:

   500

            output = self.GetNextConnector()

   501

            if output:

   502

                output_block = output.GetParentBlock()

   503

                output_block.RefreshModel(False)

   504

                if not isinstance(output_block, SFC_Divergence) or move:

   505

                    output_block.RefreshOutputModel(move)

   506

   507

    # Refreshes the step model

   508

    def RefreshModel(self, move=True):

   509

        self.Parent.RefreshStepModel(self)

   510

        if self.Action:

   511

            action = self.GetActionConnected()