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=1):

    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

        self.SetType(type, connectors)

    49

    50

    def Flush(self):

    51

        for connector in self.Connectors:

    52

            connector.Flush()

    53

        self.Connectors = []

    54

    55

    # Make a clone of this LD_PowerRail

    56

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

    57

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

    58

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

    59

        if pos is not None:

    60

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

    61

        else:

    62

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

    63

        powerrail.Connectors = []

    64

        for connector in self.Connectors:

    65

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

    66

        return powerrail

    67

    68

    def GetConnectorTranslation(self, element):

    69

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

    70

                        [connector for connector in element.Connectors]))

    71

    72

    # Returns the RedrawRect

    73

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

    74

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

    75

        for connector in self.Connectors:

    76

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

    77

        if movex != 0 or movey != 0:

    78

            for connector in self.Connectors:

    79

                if connector.IsConnected():

    80

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

    81

        return rect

    82

    83

    # Forbids to change the power rail size

    84

    def SetSize(self, width, height):

    85

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

    86

            Graphic_Element.SetSize(self, width, height)

    87

        else:

    88

            Graphic_Element.SetSize(self, LD_POWERRAIL_WIDTH, height)

    89

        self.RefreshConnectors()

    90

    91

    # Forbids to select a power rail

    92

    def HitTest(self, pt):

    93

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

    94

            return Graphic_Element.HitTest(self, pt) or self.TestConnector(pt, exclude=False) != None

    95

        return False

    96

    97

    # Forbids to select a power rail

    98

    def IsInSelection(self, rect):

    99

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

   100

            return Graphic_Element.IsInSelection(self, rect)

   101

        return False

   102

   103

    # Deletes this power rail by calling the appropriate method

   104

    def Delete(self):

   105

        self.Parent.DeletePowerRail(self)

   106

   107

    # Unconnect all connectors

   108

    def Clean(self):

   109

        for connector in self.Connectors:

   110

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

   111

   112

    # Refresh the power rail bounding box

   113

    def RefreshBoundingBox(self):

   114

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

   115

   116

    # Refresh the power rail size

   117

    def RefreshSize(self):

   118

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

   119

        self.RefreshBoundingBox()

   120

   121

    # Returns the block minimum size

   122

    def GetMinSize(self):

   123

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

   124

   125

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

   126

    def AddConnector(self):

   127

        self.InsertConnector(len(self.Connectors))

   128

   129

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

   130

    def InsertConnector(self, idx):

   131

        if self.Type == LEFTRAIL:

   132

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

   133

        elif self.Type == RIGHTRAIL:

   134

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

   135

        self.Connectors.insert(idx, connector)

   136

        self.RefreshSize()

   137

        self.RefreshConnectors()

   138

   139

    # Moves the divergence connector given

   140

    def MoveConnector(self, connector, movey):

   141

        position = connector.GetRelPosition()

   142

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

   143

        miny = self.Size[1]

   144

        maxy = 0

   145

        for connect in self.Connectors:

   146

            connect_pos = connect.GetRelPosition()

   147

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

   148

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

   149

        min_pos = self.Pos.y + miny

   150

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

   151

        if min_pos == self.Pos.y:

   152

            for connect in self.Connectors:

   153

                connect_pos = connect.GetRelPosition()

   154

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

   155

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

   156

        maxy = 0

   157

        for connect in self.Connectors:

   158

            connect_pos = connect.GetRelPosition()

   159

            maxy = max(maxy, connect_pos.y)

   160

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

   161

        connector.MoveConnected()

   162

        self.RefreshBoundingBox()

   163

   164

    # Returns the index in connectors list for the connector given

   165

    def GetConnectorIndex(self, connector):

   166

        if connector in self.Connectors:

   167

            return self.Connectors.index(connector)

   168

        return None

   169

   170

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

   171

    def DeleteConnector(self, idx):

   172

        self.Connectors.pop(idx)

   173

        self.RefreshConnectors()

   174

        self.RefreshSize()

   175

   176

    # Refresh the positions of the power rail connectors

   177

    def RefreshConnectors(self):

   178

        scaling = self.Parent.GetScaling()

   179

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

   180

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

   181

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

   182

            if self.RealConnectors:

   183

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

   184

            else:

   185

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

   186

            if scaling is not None:

   187

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

   188

            if self.Type == LEFTRAIL:

   189

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

   190

            elif self.Type == RIGHTRAIL:

   191

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

   192

        self.RefreshConnected()

   193

   194

    # Refresh the position of wires connected to power rail

   195

    def RefreshConnected(self, exclude = []):

   196

        for connector in self.Connectors:

   197

            connector.MoveConnected(exclude)

   198

   199

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

   200

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

   201

        # if a name is given

   202

        if name:

   203

            # Test each connector if it exists

   204

            for connector in self.Connectors:

   205

                if name == connector.GetName():

   206

                    return connector

   207

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

   208

   209

    # Returns all the power rail connectors 

   210

    def GetConnectors(self):

   211

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

   212

        if self.Type == LEFTRAIL:

   213

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

   214

        else:

   215

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

   216

   217

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

   218

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

   219

        for connector in self.Connectors:

   220

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

   221

                return connector

   222

        return None

   223

   224

    # Returns the power rail type

   225

    def SetType(self, type, connectors):

   226

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

   227

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

   228

            # the connectors list

   229

            self.Type = type

   230

            self.Clean()

   231

            self.Connectors = []

   232

            for connector in xrange(connectors):

   233

                self.AddConnector()

   234

            self.RefreshSize()

   235

   236

    # Returns the power rail type

   237

    def GetType(self):

   238

        return self.Type

   239

   240

    # Method called when a LeftDown event have been generated

   241

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

   242

        self.RealConnectors = []

   243

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

   244

        if height > 0:

   245

            for connector in self.Connectors:

   246

                position = connector.GetRelPosition()

   247

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

   248

        elif len(self.Connectors) > 1:

   249

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

   250

        else:

   251

            self.RealConnectors = [0.5]

   252

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

   253

   254

    # Method called when a LeftUp event have been generated

   255

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

   256

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

   257

        self.RealConnectors = None

   258

   259

    # Method called when a LeftDown event have been generated

   260

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

   261

        pos = GetScaledEventPosition(event, dc, scaling)

   262

        # Test if a connector have been handled

   263

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

   264

        if connector:

   265

            self.Handle = (HANDLE_CONNECTOR, connector)

   266

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

   267

            self.Selected = False

   268

            # Initializes the last position

   269

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

   270

        else:

   271

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

   272

   273

    # Method called when a LeftDClick event have been generated

   274

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

   275

        # Edit the powerrail properties

   276

        self.Parent.EditPowerRailContent(self)

   277

   278

    # Method called when a RightUp event have been generated

   279

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

   280

        handle_type, handle = self.Handle

   281

        if handle_type == HANDLE_CONNECTOR:

   282

            wires = handle.GetWires()

   283

            if len(wires) == 1:

   284

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

   285

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

   286

                else:

   287

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

   288

                block.RefreshModel(False)

   289

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

   290

        else:

   291

            self.Parent.PopupDefaultMenu()

   292

   293

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

   294

        self.Move(x, y)

   295

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

   296

            self.SetSize(width, height)

   297

        else:

   298

            self.SetSize(LD_POWERRAIL_WIDTH, height)

   299

   300

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

   301

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

   302

        handle_type, handle = self.Handle

   303

        # A connector has been handled

   304

        if handle_type == HANDLE_CONNECTOR:

   305

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

   306

            if scaling is not None:

   307

                position = handle.GetRelPosition()

   308

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

   309

            self.MoveConnector(handle, movey)

   310

            return 0, movey

   311

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

   312

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

   313

        return 0, 0

   314

   315

    # Refreshes the power rail model

   316

    def RefreshModel(self, move=True):

   317

        self.Parent.RefreshPowerRailModel(self)

   318

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

   319

        # of wires connected to connectors

   320

        if move and self.Type == LEFTRAIL:

   321

            for connector in self.Connectors:

   322

                connector.RefreshWires()

   323

   324

    # Draws power rail

   325

    def Draw(self, dc):

   326

        Graphic_Element.Draw(self, dc)

   327

        dc.SetPen(wx.BLACK_PEN)

   328

        dc.SetBrush(wx.BLACK_BRUSH)

   329

        # Draw a rectangle with the power rail size

   330

        if self.Type == LEFTRAIL:

   331

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

   332

        else:

   333

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

   334

        # Draw connectors

   335

        for connector in self.Connectors:

   336

            connector.Draw(dc)

   337

   338

   339

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

   340

#                         Ladder Diagram Contact

   341

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

   342

   343

"""

   344

Class that implements the graphic representation of a contact

   345

"""

   346

   347

class LD_Contact(Graphic_Element, DebugDataConsumer):

   348

   349

    # Create a new contact

   350

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

   351

        Graphic_Element.__init__(self, parent)

   352

        DebugDataConsumer.__init__(self)

   353

        self.Type = type

   354

        self.Name = name

   355

        self.Id = id

   356

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

   357

        self.Errors = {}

   358

        # Create an input and output connector

   359

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

   360

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

   361

        self.PreviousValue = False

   362

        self.PreviousSpreading = False

   363

        self.RefreshNameSize()

   364

        self.RefreshTypeSize()

   365

   366

    def Flush(self):

   367

        if self.Input is not None:

   368

            self.Input.Flush()

   369

            self.Input = None

   370

        if self.Output is not None:

   371

            self.Output.Flush()

   372

            self.Output = None

   373

   374

    def SetForced(self, forced):

   375

        if self.Forced != forced:

   376

            self.Forced = forced

   377

            if self.Visible:

   378

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

   379

   380

    def SetValue(self, value):

   381

        if self.Type == CONTACT_RISING:

   382

            refresh = self.Value and not self.PreviousValue

   383

        elif self.Type == CONTACT_FALLING:

   384

            refresh = not self.Value and self.PreviousValue

   385

        else:

   386

            refresh = False

   387

        self.PreviousValue = self.Value

   388

        self.Value = value

   389

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

   390

            if self.Visible:

   391

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

   392

            self.SpreadCurrent()

   393

   394

    def SpreadCurrent(self):

   395

        if self.Parent.Debug:

   396

            if self.Value is None:

   397

                self.Value = False

   398

            spreading = self.Input.ReceivingCurrent()

   399

            if self.Type == CONTACT_NORMAL:

   400

                spreading &= self.Value

   401

            elif self.Type == CONTACT_REVERSE:

   402

                spreading &= not self.Value

   403

            elif self.Type == CONTACT_RISING:

   404

                spreading &= self.Value and not self.PreviousValue

   405

            elif self.Type == CONTACT_FALLING:

   406

                spreading &= not self.Value and self.PreviousValue

   407

            else:

   408

                spreading = False

   409

            if spreading and not self.PreviousSpreading:

   410

                self.Output.SpreadCurrent(True)

   411

            elif not spreading and self.PreviousSpreading:

   412

                self.Output.SpreadCurrent(False)

   413

            self.PreviousSpreading = spreading

   414

   415

    # Make a clone of this LD_Contact

   416

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

   417

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

   418

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

   419

        if pos is not None:

   420

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

   421

        else:

   422

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

   423

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

   424

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

   425

        return contact

   426

   427

    def GetConnectorTranslation(self, element):

   428

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

   429

   430

    # Returns the RedrawRect

   431

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

   432

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

   433

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

   434

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

   435

        if movex != 0 or movey != 0:

   436

            if self.Input.IsConnected():

   437

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

   438

            if self.Output.IsConnected():

   439

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

   440

        return rect

   441

   442

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

   443

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

   444

            movex = movey = 0

   445

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

   446

   447

    # Forbids to change the contact size

   448

    def SetSize(self, width, height):

   449

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

   450

            Graphic_Element.SetSize(self, width, height)

   451

            self.RefreshConnectors()

   452

   453

    # Delete this contact by calling the appropriate method

   454

    def Delete(self):

   455

        self.Parent.DeleteContact(self)

   456

   457

    # Unconnect input and output

   458

    def Clean(self):

   459

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

   460

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

   461

   462

    # Refresh the size of text for name

   463

    def RefreshNameSize(self):

   464

        if self.Name != "":

   465

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

   466

        else:

   467

            self.NameSize = 0, 0

   468

   469

    # Refresh the size of text for type

   470

    def RefreshTypeSize(self):

   471

        typetext = ""

   472

        if self.Type == CONTACT_REVERSE:

   473

            typetext = "/"

   474

        elif self.Type == CONTACT_RISING:

   475

            typetext = "P"

   476

        elif self.Type == CONTACT_FALLING:

   477

            typetext = "N"

   478

        if typetext != "":

   479

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

   480

        else:

   481

            self.TypeSize = 0, 0

   482

   483

    # Refresh the contact bounding box

   484

    def RefreshBoundingBox(self):

   485

        # Calculate the size of the name outside the contact

   486

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

   487

        # Calculate the bounding box size

   488

        if self.Name != "":

   489

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

   490

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

   491

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

   492

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

   493

        else:

   494

            bbx_x = self.Pos.x

   495