1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

import wx

    26

    27

from GraphicCommons import *

    28

from plcopen.structures import *

    29

    30

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

    31

#                         Ladder Diagram PowerRail

    32

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

    33

    34

"""

    35

Class that implements the graphic representation of a power rail

    36

"""

    37

    38

class LD_PowerRail(Graphic_Element):

    39

    40

    # Create a new power rail

    41

    def __init__(self, parent, type, id = None, connectors = [True]):

    42

        Graphic_Element.__init__(self, parent)

    43

        self.Type = None

    44

        self.Connectors = []

    45

        self.RealConnectors = None

    46

        self.Id = id

    47

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

    48

        if len(connectors) < 1:

    49

            connectors = [True]

    50

        self.SetType(type, connectors)

    51

    52

    def Flush(self):

    53

        for connector in self.Connectors:

    54

            if connector is not None:

    55

                connector.Flush()

    56

        self.Connectors = []

    57

    58

    # Make a clone of this LD_PowerRail

    59

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

    60

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

    61

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

    62

        if pos is not None:

    63

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

    64

        else:

    65

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

    66

        powerrail.Connectors = []

    67

        for connector in self.Connectors:

    68

            if connector is not None:

    69

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

    70

            else:

    71

                powerrail.Connectors.append(None)

    72

        return powerrail

    73

    74

    def GetConnectorTranslation(self, element):

    75

        return dict(zip([connector for connector in self.Connectors if connector is not None],

    76

                        [connector for connector in element.Connectors if connector is not None]))

    77

    78

    # Returns the RedrawRect

    79

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

    80

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

    81

        for connector in self.Connectors:

    82

            if connector is not None:

    83

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

    84

        if movex != 0 or movey != 0:

    85

            for connector in self.Connectors:

    86

                if connector is not None and connector.IsConnected():

    87

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

    88

        return rect

    89

    90

    # Forbids to change the power rail size

    91

    def SetSize(self, width, height):

    92

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

    93

            Graphic_Element.SetSize(self, width, height)

    94

            self.RefreshConnectors()

    95

    96

    # Forbids to select a power rail

    97

    def HitTest(self, pt):

    98

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

    99

            return Graphic_Element.HitTest(self, pt) or self.TestConnector(pt, exclude=False) != 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

            if connector:

   116

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

   117

   118

    # Refresh the power rail bounding box

   119

    def RefreshBoundingBox(self):

   120

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

   121

   122

    # Refresh the power rail size

   123

    def RefreshSize(self):

   124

        self.Size = wx.Size(LD_POWERRAIL_WIDTH, LD_LINE_SIZE * len(self.Connectors))

   125

        self.RefreshBoundingBox()

   126

   127

    # Returns the block minimum size

   128

    def GetMinSize(self):

   129

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

   130

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

   131

        else:

   132

            return LD_POWERRAIL_WIDTH, LD_LINE_SIZE * len(self.Connectors)

   133

   134

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

   135

    def AddConnector(self, connector = True):

   136

        self.InsertConnector(len(self.Connectors), connector)

   137

   138

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

   139

    def InsertConnector(self, idx, connector = True):

   140

        if connector:

   141

            if self.Type == LEFTRAIL:

   142

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

   143

            elif self.Type == RIGHTRAIL:

   144

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

   145

            self.Connectors.insert(idx, connector)

   146

        else:

   147

            self.Connectors.insert(idx, None)

   148

        self.RefreshSize()

   149

        self.RefreshConnectors()

   150

   151

    # Moves the divergence connector given

   152

    def MoveConnector(self, connector, movey):

   153

        position = connector.GetRelPosition()

   154

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

   155

        miny = self.Size[1]

   156

        maxy = 0

   157

        for connect in self.Connectors:

   158

            connect_pos = connect.GetRelPosition()

   159

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

   160

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

   161

        min_pos = self.Pos.y + miny

   162

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

   163

        if min_pos == self.Pos.y:

   164

            for connect in self.Connectors:

   165

                connect_pos = connect.GetRelPosition()

   166

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

   167

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

   168

        maxy = 0

   169

        for connect in self.Connectors:

   170

            connect_pos = connect.GetRelPosition()

   171

            maxy = max(maxy, connect_pos.y)

   172

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

   173

        connector.MoveConnected()

   174

        self.RefreshBoundingBox()

   175

   176

    # Returns the index in connectors list for the connector given

   177

    def GetConnectorIndex(self, connector):

   178

        if connector in self.Connectors:

   179

            return self.Connectors.index(connector)

   180

        return None

   181

   182

    # Returns if there is a connector in connectors list at the index given

   183

    def IsNullConnector(self, idx):

   184

        if idx < len(self.Connectors):

   185

            return self.Connectors[idx] == None

   186

        return False

   187

   188

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

   189

    def DeleteConnector(self, idx):

   190

        self.Connectors.pop(idx)

   191

        self.RefreshConnectors()

   192

        self.RefreshSize()

   193

   194

    # Refresh the positions of the power rail connectors

   195

    def RefreshConnectors(self):

   196

        scaling = self.Parent.GetScaling()

   197

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

   198

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

   199

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

   200

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

   201

                if self.RealConnectors:

   202

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

   203

                else:

   204

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

   205

                if scaling is not None:

   206

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

   207

                if self.Type == LEFTRAIL:

   208

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

   209

                elif self.Type == RIGHTRAIL:

   210

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

   211

        else:

   212

            position = self.Extensions[0]

   213

            for connector in self.Connectors:

   214

                if connector:

   215

                    if scaling is not None:

   216

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

   217

                    else:

   218

                        ypos = position

   219

                    if self.Type == LEFTRAIL:

   220

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

   221

                    elif self.Type == RIGHTRAIL:

   222

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

   223

                position += LD_LINE_SIZE

   224

        self.RefreshConnected()

   225

   226

    # Refresh the position of wires connected to power rail

   227

    def RefreshConnected(self, exclude = []):

   228

        for connector in self.Connectors:

   229

            if connector:

   230

                connector.MoveConnected(exclude)

   231

   232

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

   233

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

   234

        # if a name is given

   235

        if name:

   236

            # Test each connector if it exists

   237

            for connector in self.Connectors:

   238

                if connector and name == connector.GetName():

   239

                    return connector

   240

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

   241

   242

    # Returns all the power rail connectors 

   243

    def GetConnectors(self):

   244

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

   245

        if self.Type == LEFTRAIL:

   246

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

   247

        else:

   248

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

   249

   250

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

   251

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

   252

        for connector in self.Connectors:

   253

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

   254

                return connector

   255

        return None

   256

   257

    # Returns the power rail type

   258

    def SetType(self, type, connectors):

   259

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

   260

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

   261

            # the connectors list

   262

            self.Type = type

   263

            self.Clean()

   264

            self.Connectors = []

   265

            for connector in connectors:

   266

                self.AddConnector(connector)

   267

            self.RefreshSize()

   268

   269

    # Returns the power rail type

   270

    def GetType(self):

   271

        return self.Type

   272

   273

    # Method called when a LeftDown event have been generated

   274

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

   275

        self.RealConnectors = []

   276

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

   277

        if height > 0:

   278

            for connector in self.Connectors:

   279

                position = connector.GetRelPosition()

   280

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

   281

        elif len(self.Connectors) > 1:

   282

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

   283

        else:

   284

            self.RealConnectors = [0.5]

   285

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

   286

   287

    # Method called when a LeftUp event have been generated

   288

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

   289

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

   290

        self.RealConnectors = None

   291

   292

    # Method called when a LeftDown event have been generated

   293

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

   294

        pos = GetScaledEventPosition(event, dc, scaling)

   295

        # Test if a connector have been handled

   296

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

   297

        if connector:

   298

            self.Handle = (HANDLE_CONNECTOR, connector)

   299

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

   300

            self.Selected = False

   301

            # Initializes the last position

   302

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

   303

        else:

   304

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

   305

   306

    # Method called when a LeftDClick event have been generated

   307

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

   308

        # Edit the powerrail properties

   309

        self.Parent.EditPowerRailContent(self)

   310

   311

    # Method called when a RightUp event have been generated

   312

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

   313

        handle_type, handle = self.Handle

   314

        if handle_type == HANDLE_CONNECTOR:

   315

            wires = handle.GetWires()

   316

            if len(wires) == 1:

   317

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

   318

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

   319

                else:

   320

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

   321

                block.RefreshModel(False)

   322

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

   323

        else:

   324

            self.Parent.PopupDefaultMenu()

   325

   326

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

   327

        self.Move(x, y)

   328

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

   329

            self.SetSize(width, height)

   330

        else:

   331

            self.SetSize(LD_POWERRAIL_WIDTH, height)

   332

   333

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

   334

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

   335

        handle_type, handle = self.Handle

   336

        # A connector has been handled

   337

        if handle_type == HANDLE_CONNECTOR:

   338

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

   339

            if scaling is not None:

   340

                position = handle.GetRelPosition()

   341

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

   342

            self.MoveConnector(handle, movey)

   343

            return 0, movey

   344

        else:

   345

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

   346

   347

    # Refreshes the power rail model

   348

    def RefreshModel(self, move=True):

   349

        self.Parent.RefreshPowerRailModel(self)

   350

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

   351

        # of wires connected to connectors

   352

        if move and self.Type == LEFTRAIL:

   353

            for connector in self.Connectors:

   354

                if connector:

   355

                    connector.RefreshWires()

   356

   357

    # Draws power rail

   358

    def Draw(self, dc):

   359

        Graphic_Element.Draw(self, dc)

   360

        dc.SetPen(wx.BLACK_PEN)

   361

        dc.SetBrush(wx.BLACK_BRUSH)

   362

        # Draw a rectangle with the power rail size

   363

        if self.Type == LEFTRAIL:

   364

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

   365

        else:

   366

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

   367

        # Draw connectors

   368

        for connector in self.Connectors:

   369

            if connector:

   370

                connector.Draw(dc)

   371

   372

   373

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

   374

#                         Ladder Diagram Contact

   375

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

   376

   377

"""

   378

Class that implements the graphic representation of a contact

   379

"""

   380

   381

class LD_Contact(Graphic_Element, DebugDataConsumer):

   382

   383

    # Create a new contact

   384

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

   385

        Graphic_Element.__init__(self, parent)

   386

        DebugDataConsumer.__init__(self)

   387

        self.Type = type

   388

        self.Name = name

   389

        self.Id = id

   390

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

   391

        self.Errors = {}

   392

        # Create an input and output connector

   393

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

   394

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

   395

        self.PreviousValue = False

   396

        self.PreviousSpreading = False

   397

        self.RefreshNameSize()

   398

        self.RefreshTypeSize()

   399

   400

    def Flush(self):

   401

        if self.Input is not None:

   402

            self.Input.Flush()

   403

            self.Input = None

   404

        if self.Output is not None:

   405

            self.Output.Flush()

   406

            self.Output = None

   407

   408

    def SetForced(self, forced):

   409

        if self.Forced != forced:

   410

            self.Forced = forced

   411

            if self.Visible:

   412

                self.Parent.UpdateRefreshRect(self.GetRedrawRect())

   413

   414

    def SetValue(self, value):

   415

        if self.Type == CONTACT_RISING:

   416

            refresh = self.Value and not self.PreviousValue

   417

        elif self.Type == CONTACT_FALLING:

   418

            refresh = not self.Value and self.PreviousValue

   419

        else:

   420

            refresh = False

   421

        self.PreviousValue = self.Value

   422

        self.Value = value

   423

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

   424

            if self.Visible:

   425

                self.Parent.UpdateRefreshRect(self.GetRedrawRect())

   426

            self.SpreadCurrent()

   427

   428

    def SpreadCurrent(self):

   429

        if self.Parent.Debug:

   430

            if self.Value is None:

   431

                self.Value = False

   432

            spreading = self.Input.ReceivingCurrent()

   433

            if self.Type == CONTACT_NORMAL:

   434

                spreading &= self.Value

   435

            elif self.Type == CONTACT_REVERSE:

   436

                spreading &= not self.Value

   437

            elif self.Type == CONTACT_RISING:

   438

                spreading &= self.Value and not self.PreviousValue

   439

            elif self.Type == CONTACT_FALLING:

   440

                spreading &= not self.Value and self.PreviousValue

   441

            else:

   442

                spreading = False

   443

            if spreading and not self.PreviousSpreading:

   444

                self.Output.SpreadCurrent(True)

   445

            elif not spreading and self.PreviousSpreading:

   446

                self.Output.SpreadCurrent(False)

   447

            self.PreviousSpreading = spreading

   448

   449

    # Make a clone of this LD_Contact

   450

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

   451

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

   452

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

   453

        if pos is not None:

   454

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

   455

        else:

   456

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

   457

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

   458

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

   459

        return contact

   460

   461

    def GetConnectorTranslation(self, element):

   462

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

   463

   464

    # Returns the RedrawRect

   465

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

   466

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

   467

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

   468

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

   469

        if movex != 0 or movey != 0:

   470

            if self.Input.IsConnected():

   471

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

   472

            if self.Output.IsConnected():

   473

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

   474

        return rect

   475

   476

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

   477

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

   478

   479

    # Forbids to change the contact size

   480

    def SetSize(self, width, height):

   481

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

   482

            Graphic_Element.SetSize(self, width, height)

   483

            self.RefreshConnectors()

   484

   485

    # Delete this contact by calling the appropriate method

   486

    def Delete(self):

   487

        self.Parent.DeleteContact(self)

   488

   489

    # Unconnect input and output

   490

    def Clean(self):

   491

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

   492

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

   493

   494

    # Refresh the size of text for name

   495

    def RefreshNameSize(self):

   496

        if self.Name != "":