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

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

    33

#                         Ladder Diagram PowerRail

    34

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

    35

    36

    37

class LD_PowerRail(Graphic_Element):

    38

    """

    39

    Class that implements the graphic representation of a power rail

    40

    """

    41

    42

    # Create a new power rail

    43

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

    44

        Graphic_Element.__init__(self, parent)

    45

        self.Type = None

    46

        self.Connectors = []

    47

        self.RealConnectors = None

    48

        self.Id = id

    49

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

    50

        self.SetType(type, connectors)

    51

    52

    def Flush(self):

    53

        for connector in self.Connectors:

    54

            connector.Flush()

    55

        self.Connectors = []

    56

    57

    # Make a clone of this LD_PowerRail

    58

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

    59

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

    60

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

    61

        if pos is not None:

    62

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

    63

        else:

    64

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

    65

        powerrail.Connectors = []

    66

        for connector in self.Connectors:

    67

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

    68

        return powerrail

    69

    70

    def GetConnectorTranslation(self, element):

    71

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

    72

                        [connector for connector in element.Connectors]))

    73

    74

    # Returns the RedrawRect

    75

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

    76

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

    77

        for connector in self.Connectors:

    78

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

    79

        if movex != 0 or movey != 0:

    80

            for connector in self.Connectors:

    81

                if connector.IsConnected():

    82

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

    83

        return rect

    84

    85

    # Forbids to change the power rail size

    86

    def SetSize(self, width, height):

    87

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

    88

            Graphic_Element.SetSize(self, width, height)

    89

        else:

    90

            Graphic_Element.SetSize(self, LD_POWERRAIL_WIDTH, height)

    91

        self.RefreshConnectors()

    92

    93

    # Forbids to select a power rail

    94

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

    95

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

    96

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

    97

        return False

    98

    99

    # Forbids to select a power rail

   100

    def IsInSelection(self, rect):

   101

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

   102

            return Graphic_Element.IsInSelection(self, rect)

   103

        return False

   104

   105

    # Deletes this power rail by calling the appropriate method

   106

    def Delete(self):

   107

        self.Parent.DeletePowerRail(self)

   108

   109

    # Unconnect all connectors

   110

    def Clean(self):

   111

        for connector in self.Connectors:

   112

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

   113

   114

    # Refresh the power rail bounding box

   115

    def RefreshBoundingBox(self):

   116

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

   117

   118

    # Refresh the power rail size

   119

    def RefreshSize(self):

   120

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

   121

        self.RefreshBoundingBox()

   122

   123

    # Returns the block minimum size

   124

    def GetMinSize(self, default=False):

   125

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

   126

                  if default else 0)

   127

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

   128

   129

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

   130

    def AddConnector(self):

   131

        self.InsertConnector(len(self.Connectors))

   132

   133

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

   134

    def InsertConnector(self, idx):

   135

        if self.Type == LEFTRAIL:

   136

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

   137

        elif self.Type == RIGHTRAIL:

   138

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

   139

        self.Connectors.insert(idx, connector)

   140

        self.RefreshSize()

   141

        self.RefreshConnectors()

   142

   143

    # Moves the divergence connector given

   144

    def MoveConnector(self, connector, movey):

   145

        position = connector.GetRelPosition()

   146

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

   147

        miny = self.Size[1]

   148

        maxy = 0

   149

        for connect in self.Connectors:

   150

            connect_pos = connect.GetRelPosition()

   151

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

   152

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

   153

        min_pos = self.Pos.y + miny

   154

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

   155

        if min_pos == self.Pos.y:

   156

            for connect in self.Connectors:

   157

                connect_pos = connect.GetRelPosition()

   158

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

   159

        self.Connectors.sort(lambda x, y: cmp(x.Pos.y, y.Pos.y))

   160

        maxy = 0

   161

        for connect in self.Connectors:

   162

            connect_pos = connect.GetRelPosition()

   163

            maxy = max(maxy, connect_pos.y)

   164

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

   165

        connector.MoveConnected()

   166

        self.RefreshBoundingBox()

   167

   168

    # Returns the index in connectors list for the connector given

   169

    def GetConnectorIndex(self, connector):

   170

        if connector in self.Connectors:

   171

            return self.Connectors.index(connector)

   172

        return None

   173

   174

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

   175

    def DeleteConnector(self, idx):

   176

        self.Connectors.pop(idx)

   177

        self.RefreshConnectors()

   178

        self.RefreshSize()

   179

   180

    # Refresh the positions of the power rail connectors

   181

    def RefreshConnectors(self):

   182

        scaling = self.Parent.GetScaling()

   183

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

   184

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

   185

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

   186

            if self.RealConnectors:

   187

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

   188

            else:

   189

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

   190

            if scaling is not None:

   191

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

   192

            if self.Type == LEFTRAIL:

   193

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

   194

            elif self.Type == RIGHTRAIL:

   195

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

   196

        self.RefreshConnected()

   197

   198

    # Refresh the position of wires connected to power rail

   199

    def RefreshConnected(self, exclude=[]):

   200

        for connector in self.Connectors:

   201

            connector.MoveConnected(exclude)

   202

   203

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

   204

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

   205

        # if a name is given

   206

        if name is not None:

   207

            # Test each connector if it exists

   208

            for connector in self.Connectors:

   209

                if name == connector.GetName():

   210

                    return connector

   211

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

   212

   213

    # Returns all the power rail connectors

   214

    def GetConnectors(self):

   215

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

   216

        if self.Type == LEFTRAIL:

   217

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

   218

        else:

   219

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

   220

   221

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

   222

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

   223

        for connector in self.Connectors:

   224

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

   225

                return connector

   226

        return None

   227

   228

    # Returns the power rail type

   229

    def SetType(self, type, connectors):

   230

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

   231

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

   232

            # the connectors list

   233

            self.Type = type

   234

            self.Clean()

   235

            self.Connectors = []

   236

            for connector in xrange(connectors):

   237

                self.AddConnector()

   238

            self.RefreshSize()

   239

   240

    # Returns the power rail type

   241

    def GetType(self):

   242

        return self.Type

   243

   244

    # Method called when a LeftDown event have been generated

   245

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

   246

        self.RealConnectors = []

   247

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

   248

        if height > 0:

   249

            for connector in self.Connectors:

   250

                position = connector.GetRelPosition()

   251

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

   252

        elif len(self.Connectors) > 1:

   253

            self.RealConnectors = map(lambda x: x * 1 / (len(self.Connectors) - 1), xrange(len(self.Connectors)))

   254

        else:

   255

            self.RealConnectors = [0.5]

   256

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

   257

   258

    # Method called when a LeftUp event have been generated

   259

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

   260

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

   261

        self.RealConnectors = None

   262

   263

    # Method called when a LeftDown event have been generated

   264

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

   265

        pos = GetScaledEventPosition(event, dc, scaling)

   266

        # Test if a connector have been handled

   267

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

   268

        if connector:

   269

            self.Handle = (HANDLE_CONNECTOR, connector)

   270

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

   271

            self.Selected = False

   272

            # Initializes the last position

   273

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

   274

        else:

   275

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

   276

   277

    # Method called when a LeftDClick event have been generated

   278

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

   279

        # Edit the powerrail properties

   280

        self.Parent.EditPowerRailContent(self)

   281

   282

    # Method called when a RightUp event have been generated

   283

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

   284

        handle_type, handle = self.Handle

   285

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

   286

            wires = handle.GetWires()

   287

            if len(wires) == 1:

   288

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

   289

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

   290

                else:

   291

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

   292

                block.RefreshModel(False)

   293

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

   294

        else:

   295

            self.Parent.PopupDefaultMenu()

   296

   297

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

   298

        self.Move(x, y)

   299

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

   300

            self.SetSize(width, height)

   301

        else:

   302

            self.SetSize(LD_POWERRAIL_WIDTH, height)

   303

   304

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

   305

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

   306

        handle_type, handle = self.Handle

   307

        # A connector has been handled

   308

        if handle_type == HANDLE_CONNECTOR:

   309

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

   310

            if scaling is not None:

   311

                position = handle.GetRelPosition()

   312

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

   313

            self.MoveConnector(handle, movey)

   314

            return 0, movey

   315

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

   316

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

   317

        return 0, 0

   318

   319

    # Refreshes the power rail model

   320

    def RefreshModel(self, move=True):

   321

        self.Parent.RefreshPowerRailModel(self)

   322

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

   323

        # of wires connected to connectors

   324

        if move and self.Type == LEFTRAIL:

   325

            for connector in self.Connectors:

   326

                connector.RefreshWires()

   327

   328

    # Draws power rail

   329

    def Draw(self, dc):

   330

        Graphic_Element.Draw(self, dc)

   331

        dc.SetPen(MiterPen(wx.BLACK))

   332

        dc.SetBrush(wx.BLACK_BRUSH)

   333

        # Draw a rectangle with the power rail size

   334

        if self.Type == LEFTRAIL:

   335

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

   336

        else:

   337

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

   338

        # Draw connectors

   339

        for connector in self.Connectors:

   340

            connector.Draw(dc)

   341

   342

   343

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

   344

#                         Ladder Diagram Contact

   345

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

   346

   347

   348

class LD_Contact(Graphic_Element, DebugDataConsumer):

   349

    """

   350

    Class that implements the graphic representation of a contact

   351

    """

   352

   353

    # Create a new contact

   354

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

   355

        Graphic_Element.__init__(self, parent)

   356

        DebugDataConsumer.__init__(self)

   357

        self.Type = type

   358

        self.Name = name

   359

        self.Id = id

   360

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

   361

        self.Highlights = {}

   362

        # Create an input and output connector

   363

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

   364

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

   365

        self.PreviousValue = False

   366

        self.PreviousSpreading = False

   367

        self.RefreshNameSize()

   368

        self.RefreshTypeSize()

   369

   370

    def Flush(self):

   371

        if self.Input is not None:

   372

            self.Input.Flush()

   373

            self.Input = None

   374

        if self.Output is not None:

   375

            self.Output.Flush()

   376

            self.Output = None

   377

   378

    def SetForced(self, forced):

   379

        if self.Forced != forced:

   380

            self.Forced = forced

   381

            if self.Visible:

   382

                self.Parent.ElementNeedRefresh(self)

   383

   384

    def SetValue(self, value):

   385

        if self.Type == CONTACT_RISING:

   386

            refresh = self.Value and not self.PreviousValue

   387

        elif self.Type == CONTACT_FALLING:

   388

            refresh = not self.Value and self.PreviousValue

   389

        else:

   390

            refresh = False

   391

        self.PreviousValue = self.Value

   392

        self.Value = value

   393

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

   394

            if self.Visible:

   395

                self.Parent.ElementNeedRefresh(self)

   396

            self.SpreadCurrent()

   397

   398

    def SpreadCurrent(self):

   399

        if self.Parent.Debug:

   400

            if self.Value is None:

   401

                self.Value = False

   402

            spreading = self.Input.ReceivingCurrent()

   403

            if self.Type == CONTACT_NORMAL:

   404

                spreading &= self.Value

   405

            elif self.Type == CONTACT_REVERSE:

   406

                spreading &= not self.Value

   407

            elif self.Type == CONTACT_RISING:

   408

                spreading &= self.Value and not self.PreviousValue

   409

            elif self.Type == CONTACT_FALLING:

   410

                spreading &= not self.Value and self.PreviousValue

   411

            else:

   412

                spreading = False

   413

            if spreading and not self.PreviousSpreading:

   414

                self.Output.SpreadCurrent(True)

   415

            elif not spreading and self.PreviousSpreading:

   416

                self.Output.SpreadCurrent(False)

   417

            self.PreviousSpreading = spreading

   418

   419

    # Make a clone of this LD_Contact

   420

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

   421

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

   422

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

   423

        if pos is not None:

   424

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

   425

        else:

   426

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

   427

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

   428

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

   429

        return contact

   430

   431

    def GetConnectorTranslation(self, element):

   432

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

   433

   434

    # Returns the RedrawRect

   435

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

   436

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

   437

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

   438

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

   439

        if movex != 0 or movey != 0:

   440

            if self.Input.IsConnected():

   441

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

   442

            if self.Output.IsConnected():

   443

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

   444

        return rect

   445

   446

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

   447

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

   448

            movex = movey = 0

   449

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

   450

   451

    # Forbids to change the contact size

   452

    def SetSize(self, width, height):

   453

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

   454

            Graphic_Element.SetSize(self, width, height)

   455

            self.RefreshConnectors()

   456

   457

    # Delete this contact by calling the appropriate method

   458

    def Delete(self):

   459

        self.Parent.DeleteContact(self)

   460

   461

    # Unconnect input and output

   462

    def Clean(self):

   463

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

   464

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

   465

   466

    # Refresh the size of text for name

   467

    def RefreshNameSize(self):

   468

        if self.Name != "":

   469

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

   470

        else:

   471

            self.NameSize = 0, 0

   472

   473

    # Refresh the size of text for type

   474

    def RefreshTypeSize(self):

   475

        typetext = ""

   476

        if self.Type == CONTACT_REVERSE:

   477

            typetext = "/"

   478

        elif self.Type == CONTACT_RISING:

   479

            typetext = "P"

   480

        elif self.Type == CONTACT_FALLING:

   481

            typetext = "N"

   482

        if typetext != "":

   483

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

   484

        else:

   485

            self.TypeSize = 0, 0

   486

   487

    # Refresh the contact bounding box

   488

    def RefreshBoundingBox(self):

   489

        # Calculate the size of the name outside the contact

   490

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

   491

        # Calculate the bounding box size

   492

        if self.Name != "":

   493

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

   494

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

   495

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

   496

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

   497

        else:

   498

            bbx_x = self.Pos.x

   499

            bbx_width = self.Size[0]

   500

            bbx_y = self.Pos.y

   501

            bbx_height = self.Size[1]

   502

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

   503

   504

    # Returns the block minimum size

   505

    def GetMinSize(self):

   506

        return LD_ELEMENT_SIZE

   507

   508

    # Refresh the position of wire connected to contact

   509

    def RefreshConnected(self, exclude=[]):

   510

        self.Input.MoveConnected(exclude)

   511

        self.Output.MoveConnected(exclude)

   512