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

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

    36

#                         Ladder Diagram PowerRail

    37

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

    38

    39

    40

class LD_PowerRail(Graphic_Element):

    41

    """

    42

    Class that implements the graphic representation of a power rail

    43

    """

    44

    45

    # Create a new power rail

    46

    def __init__(self, parent, type, id=None, connectors=1):

    47

        Graphic_Element.__init__(self, parent)

    48

        self.Type = None

    49

        self.Connectors = []

    50

        self.RealConnectors = None

    51

        self.Id = id

    52

        self.Extensions = [LD_LINE_SIZE // 2, LD_LINE_SIZE // 2]

    53

        self.SetType(type, connectors)

    54

    55

    def Flush(self):

    56

        for connector in self.Connectors:

    57

            connector.Flush()

    58

        self.Connectors = []

    59

    60

    # Make a clone of this LD_PowerRail

    61

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

    62

        powerrail = LD_PowerRail(parent, self.Type, id)

    63

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

    64

        if pos is not None:

    65

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

    66

        else:

    67

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

    68

        powerrail.Connectors = []

    69

        for connector in self.Connectors:

    70

            powerrail.Connectors.append(connector.Clone(powerrail))

    71

        return powerrail

    72

    73

    def GetConnectorTranslation(self, element):

    74

        return dict(list(zip([connector for connector in self.Connectors],

    75

                        [connector for connector in element.Connectors])))

    76

    77

    # Returns the RedrawRect

    78

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

    79

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

    80

        for connector in self.Connectors:

    81

            rect = rect.Union(connector.GetRedrawRect(movex, movey))

    82

        if movex != 0 or movey != 0:

    83

            for connector in self.Connectors:

    84

                if connector.IsConnected():

    85

                    rect = rect.Union(connector.GetConnectedRedrawRect(movex, movey))

    86

        return rect

    87

    88

    # Forbids to change the power rail size

    89

    def SetSize(self, width, height):

    90

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

    91

            Graphic_Element.SetSize(self, width, height)

    92

        else:

    93

            Graphic_Element.SetSize(self, LD_POWERRAIL_WIDTH, height)

    94

        self.RefreshConnectors()

    95

    96

    # Forbids to select a power rail

    97

    def HitTest(self, pt, connectors=True):

    98

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

    99

            return Graphic_Element.HitTest(self, pt, connectors) or self.TestConnector(pt, exclude=False) is not None

   100

        return False

   101

   102

    # Forbids to select a power rail

   103

    def IsInSelection(self, rect):

   104

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

   105

            return Graphic_Element.IsInSelection(self, rect)

   106

        return False

   107

   108

    # Deletes this power rail by calling the appropriate method

   109

    def Delete(self):

   110

        self.Parent.DeletePowerRail(self)

   111

   112

    # Unconnect all connectors

   113

    def Clean(self):

   114

        for connector in self.Connectors:

   115

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

   116

   117

    # Refresh the power rail bounding box

   118

    def RefreshBoundingBox(self):

   119

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

   120

   121

    # Refresh the power rail size

   122

    def RefreshSize(self):

   123

        self.Size = wx.Size(LD_POWERRAIL_WIDTH, max(LD_LINE_SIZE * len(self.Connectors), self.Size[1]))

   124

        self.RefreshBoundingBox()

   125

   126

    # Returns the block minimum size

   127

    def GetMinSize(self, default=False):

   128

        height = (LD_LINE_SIZE * (len(self.Connectors) - 1)

   129

                  if default else 0)

   130

        return LD_POWERRAIL_WIDTH, height + self.Extensions[0] + self.Extensions[1]

   131

   132

    # Add a connector or a blank to this power rail at the last place

   133

    def AddConnector(self):

   134

        self.InsertConnector(len(self.Connectors))

   135

   136

    # Add a connector or a blank to this power rail at the place given

   137

    def InsertConnector(self, idx):

   138

        if self.Type == LEFTRAIL:

   139

            connector = Connector(self, "", "BOOL", wx.Point(self.Size[0], 0), EAST)

   140

        elif self.Type == RIGHTRAIL:

   141

            connector = Connector(self, "", "BOOL", wx.Point(0, 0), WEST)

   142

        self.Connectors.insert(idx, connector)

   143

        self.RefreshSize()

   144

        self.RefreshConnectors()

   145

   146

    # Moves the divergence connector given

   147

    def MoveConnector(self, connector, movey):

   148

        position = connector.GetRelPosition()

   149

        connector.SetPosition(wx.Point(position.x, position.y + movey))

   150

        miny = self.Size[1]

   151

        maxy = 0

   152

        for connect in self.Connectors:

   153

            connect_pos = connect.GetRelPosition()

   154

            miny = min(miny, connect_pos.y - self.Extensions[0])

   155

            maxy = max(maxy, connect_pos.y - self.Extensions[0])

   156

        min_pos = self.Pos.y + miny

   157

        self.Pos.y = min(min_pos, self.Pos.y)

   158

        if min_pos == self.Pos.y:

   159

            for connect in self.Connectors:

   160

                connect_pos = connect.GetRelPosition()

   161

                connect.SetPosition(wx.Point(connect_pos.x, connect_pos.y - miny))

   162

        self.Connectors.sort(key=cmp_to_key(lambda x, y: eq(x.Pos.y, y.Pos.y)))

   163

        maxy = 0

   164

        for connect in self.Connectors:

   165

            connect_pos = connect.GetRelPosition()

   166

            maxy = max(maxy, connect_pos.y)

   167

        self.Size[1] = max(maxy + self.Extensions[1], self.Size[1])

   168

        connector.MoveConnected()

   169

        self.RefreshBoundingBox()

   170

   171

    # Returns the index in connectors list for the connector given

   172

    def GetConnectorIndex(self, connector):

   173

        if connector in self.Connectors:

   174

            return self.Connectors.index(connector)

   175

        return None

   176

   177

    # Delete the connector or blank from connectors list at the index given

   178

    def DeleteConnector(self, idx):

   179

        self.Connectors.pop(idx)

   180

        self.RefreshConnectors()

   181

        self.RefreshSize()

   182

   183

    # Refresh the positions of the power rail connectors

   184

    def RefreshConnectors(self):

   185

        scaling = self.Parent.GetScaling()

   186

        height = self.Size[1] - self.Extensions[0] - self.Extensions[1]

   187

        interval = height / max(len(self.Connectors) - 1, 1)

   188

        for i, connector in enumerate(self.Connectors):

   189

            if self.RealConnectors:

   190

                position = self.Extensions[0] + int(round(self.RealConnectors[i] * height))

   191

            else:

   192

                position = self.Extensions[0] + int(round(i * interval))

   193

            if scaling is not None:

   194

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

   195

            if self.Type == LEFTRAIL:

   196

                connector.SetPosition(wx.Point(self.Size[0], position))

   197

            elif self.Type == RIGHTRAIL:

   198

                connector.SetPosition(wx.Point(0, position))

   199

        self.RefreshConnected()

   200

   201

    # Refresh the position of wires connected to power rail

   202

    def RefreshConnected(self, exclude=None):

   203

        for connector in self.Connectors:

   204

            connector.MoveConnected(exclude)

   205

   206

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

   207

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

   208

        # if a name is given

   209

        if name is not None:

   210

            # Test each connector if it exists

   211

            for connector in self.Connectors:

   212

                if name == connector.GetName():

   213

                    return connector

   214

        return self.FindNearestConnector(position, [connector for connector in self.Connectors if connector is not None])

   215

   216

    # Returns all the power rail connectors

   217

    def GetConnectors(self):

   218

        connectors = [connector for connector in self.Connectors if connector]

   219

        if self.Type == LEFTRAIL:

   220

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

   221

        else:

   222

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

   223

   224

    # Test if point given is on one of the power rail connectors

   225

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

   226

        for connector in self.Connectors:

   227

            if connector.TestPoint(pt, direction, exclude):

   228

                return connector

   229

        return None

   230

   231

    # Returns the power rail type

   232

    def SetType(self, type, connectors):

   233

        if type != self.Type or len(self.Connectors) != connectors:

   234

            # Create a connector or a blank according to 'connectors' and add it in

   235

            # the connectors list

   236

            self.Type = type

   237

            self.Clean()

   238

            self.Connectors = []

   239

            for dummy in range(connectors):

   240

                self.AddConnector()

   241

            self.RefreshSize()

   242

   243

    # Returns the power rail type

   244

    def GetType(self):

   245

        return self.Type

   246

   247

    # Method called when a LeftDown event have been generated

   248

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

   249

        self.RealConnectors = []

   250

        height = self.Size[1] - self.Extensions[0] - self.Extensions[1]

   251

        if height > 0:

   252

            for connector in self.Connectors:

   253

                position = connector.GetRelPosition()

   254

                self.RealConnectors.append(max(0., min((position.y - self.Extensions[0]) / height, 1.)))

   255

        elif len(self.Connectors) > 1:

   256

            self.RealConnectors = [x * 1 / (len(self.Connectors) - 1) for x in range(len(self.Connectors))]

   257

        else:

   258

            self.RealConnectors = [0.5]

   259

        Graphic_Element.OnLeftDown(self, event, dc, scaling)

   260

   261

    # Method called when a LeftUp event have been generated

   262

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

   263

        Graphic_Element.OnLeftUp(self, event, dc, scaling)

   264

        self.RealConnectors = None

   265

   266

    # Method called when a LeftDown event have been generated

   267

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

   268

        pos = GetScaledEventPosition(event, dc, scaling)

   269

        # Test if a connector have been handled

   270

        connector = self.TestConnector(pos, exclude=False)

   271

        if connector:

   272

            self.Handle = (HANDLE_CONNECTOR, connector)

   273

            wx.CallAfter(self.Parent.SetCurrentCursor, 1)

   274

            self.Selected = False

   275

            # Initializes the last position

   276

            self.oldPos = GetScaledEventPosition(event, dc, scaling)

   277

        else:

   278

            Graphic_Element.OnRightDown(self, event, dc, scaling)

   279

   280

    # Method called when a LeftDClick event have been generated

   281

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

   282

        # Edit the powerrail properties

   283

        self.Parent.EditPowerRailContent(self)

   284

   285

    # Method called when a RightUp event have been generated

   286

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

   287

        handle_type, handle = self.Handle

   288

        if handle_type == HANDLE_CONNECTOR and self.Dragging and self.oldPos:

   289

            wires = handle.GetWires()

   290

            if len(wires) == 1:

   291

                if handle == wires[0][0].StartConnected:

   292

                    block = wires[0][0].EndConnected.GetParentBlock()

   293

                else:

   294

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

   295

                block.RefreshModel(False)

   296

            Graphic_Element.OnRightUp(self, event, dc, scaling)

   297

        else:

   298

            self.Parent.PopupDefaultMenu()

   299

   300

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

   301

        self.Move(x, y)

   302

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

   303

            self.SetSize(width, height)

   304

        else:

   305

            self.SetSize(LD_POWERRAIL_WIDTH, height)

   306

   307

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

   308

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

   309

        handle_type, handle = self.Handle

   310

        # A connector has been handled

   311

        if handle_type == HANDLE_CONNECTOR:

   312

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

   313

            if scaling is not None:

   314

                position = handle.GetRelPosition()

   315

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

   316

            self.MoveConnector(handle, movey)

   317

            return 0, movey

   318

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

   319

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

   320

        return 0, 0

   321

   322

    # Refreshes the power rail model

   323

    def RefreshModel(self, move=True):

   324

        self.Parent.RefreshPowerRailModel(self)

   325

        # If power rail has moved and power rail is of type LEFT, refresh the model

   326

        # of wires connected to connectors

   327

        if move and self.Type == LEFTRAIL:

   328

            for connector in self.Connectors:

   329

                connector.RefreshWires()

   330

   331

    # Draws power rail

   332

    def Draw(self, dc):

   333

        Graphic_Element.Draw(self, dc)

   334

        dc.SetPen(MiterPen(wx.BLACK))

   335

        dc.SetBrush(wx.BLACK_BRUSH)

   336

        # Draw a rectangle with the power rail size

   337

        if self.Type == LEFTRAIL:

   338

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

   339

        else:

   340

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

   341

        # Draw connectors

   342

        for connector in self.Connectors:

   343

            connector.Draw(dc)

   344

   345

   346

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

   347

#                         Ladder Diagram Contact

   348

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

   349

   350

   351

class LD_Contact(Graphic_Element, DebugDataConsumer):

   352

    """

   353

    Class that implements the graphic representation of a contact

   354

    """

   355

   356

    # Create a new contact

   357

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

   358

        Graphic_Element.__init__(self, parent)

   359

        DebugDataConsumer.__init__(self)

   360

        self.Type = type

   361

        self.Name = name

   362

        self.Id = id

   363

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

   364

        self.Highlights = {}

   365

        # Create an input and output connector

   366

        self.Input = Connector(self, "", "BOOL", wx.Point(0, self.Size[1] // 2 + 1), WEST)

   367

        self.Output = Connector(self, "", "BOOL", wx.Point(self.Size[0], self.Size[1] // 2 + 1), EAST)

   368

        self.PreviousValue = False

   369

        self.PreviousSpreading = False

   370

        self.RefreshNameSize()

   371

        self.RefreshTypeSize()

   372

   373

    def Flush(self):

   374

        if self.Input is not None:

   375

            self.Input.Flush()

   376

            self.Input = None

   377

        if self.Output is not None:

   378

            self.Output.Flush()

   379

            self.Output = None

   380

   381

    def SetForced(self, forced):

   382

        if self.Forced != forced:

   383

            self.Forced = forced

   384

            if self.Visible:

   385

                self.Parent.ElementNeedRefresh(self)

   386

   387

    def SetValue(self, value):

   388

        if self.Type == CONTACT_RISING:

   389

            refresh = self.Value and not self.PreviousValue

   390

        elif self.Type == CONTACT_FALLING:

   391

            refresh = not self.Value and self.PreviousValue

   392

        else:

   393

            refresh = False

   394

        self.PreviousValue = self.Value

   395

        self.Value = value

   396

        if self.Value != self.PreviousValue or refresh:

   397

            if self.Visible:

   398

                self.Parent.ElementNeedRefresh(self)

   399

            self.SpreadCurrent()

   400

   401

    def SpreadCurrent(self):

   402

        if self.Parent.Debug:

   403

            if self.Value is None:

   404

                self.Value = False

   405

            spreading = self.Input.ReceivingCurrent()

   406

            if spreading == "undefined":

   407

                spreading = False

   408

            if self.Type == CONTACT_NORMAL:

   409

                spreading &= self.Value

   410

            elif self.Type == CONTACT_REVERSE:

   411

                spreading &= not self.Value

   412

            elif self.Type == CONTACT_RISING:

   413

                spreading &= self.Value and not self.PreviousValue

   414

            elif self.Type == CONTACT_FALLING:

   415

                spreading &= not self.Value and self.PreviousValue

   416

            else:

   417

                spreading = False

   418

            if spreading and not self.PreviousSpreading:

   419

                self.Output.SpreadCurrent(True)

   420

            elif not spreading and self.PreviousSpreading:

   421

                self.Output.SpreadCurrent(False)

   422

            self.PreviousSpreading = spreading

   423

   424

    # Make a clone of this LD_Contact

   425

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

   426

        contact = LD_Contact(parent, self.Type, self.Name, id)

   427

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

   428

        if pos is not None:

   429

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

   430

        else:

   431

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

   432

        contact.Input = self.Input.Clone(contact)

   433

        contact.Output = self.Output.Clone(contact)

   434

        return contact

   435

   436

    def GetConnectorTranslation(self, element):

   437

        return {self.Input: element.Input, self.Output: element.Output}

   438

   439

    # Returns the RedrawRect

   440

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

   441

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

   442

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

   443

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

   444

        if movex != 0 or movey != 0:

   445

            if self.Input.IsConnected():

   446

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

   447

            if self.Output.IsConnected():

   448

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

   449

        return rect

   450

   451

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

   452

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

   453

            movex = movey = 0

   454

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

   455

   456

    # Forbids to change the contact size

   457

    def SetSize(self, width, height):

   458

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

   459

            Graphic_Element.SetSize(self, width, height)

   460

            self.RefreshConnectors()

   461

   462

    # Delete this contact by calling the appropriate method

   463

    def Delete(self):

   464

        self.Parent.DeleteContact(self)

   465

   466

    # Unconnect input and output

   467

    def Clean(self):

   468

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

   469

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

   470

   471

    # Refresh the size of text for name

   472

    def RefreshNameSize(self):

   473

        if self.Name != "":

   474

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

   475

        else:

   476

            self.NameSize = 0, 0

   477

   478

    # Refresh the size of text for type

   479

    def RefreshTypeSize(self):

   480

        typetext = ""

   481

        if self.Type == CONTACT_REVERSE:

   482

            typetext = "/"

   483

        elif self.Type == CONTACT_RISING:

   484

            typetext = "P"

   485

        elif self.Type == CONTACT_FALLING:

   486

            typetext = "N"

   487

        if typetext != "":

   488

            self.TypeSize = self.Parent.GetTextExtent(typetext)

   489

        else:

   490

            self.TypeSize = 0, 0

   491

   492

    # Refresh the contact bounding box

   493

    def RefreshBoundingBox(self):

   494

        # Calculate the size of the name outside the contact

   495

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

   496

        # Calculate the bounding box size

   497

        if self.Name != "":

   498

            bbx_x = self.Pos.x - max(0, (text_width - self.Size[0]) // 2)

   499

            bbx_width = max(self.Size[0], text_width)

   500

            bbx_y = self.Pos.y - (text_height + 2)

   501

            bbx_height = self.Size[1] + (text_height + 2)

   502

        else:

   503

            bbx_x = self.Pos.x

   504

            bbx_width = self.Size[0]

   505

            bbx_y = self.Pos.y

   506

            bbx_height = self.Size[1]

   507

        self.BoundingBox = wx.Rect(bbx_x, bbx_y, bbx_width + 1, bbx_height + 1)

   508

   509

    # Returns the block minimum size

   510

    def GetMinSize(self):