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

    # Destructor

    53

    def __del__(self):

    54

        self.Connectors = []

    55

    56

    # Make a clone of this LD_PowerRail

    57

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

    58

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

    59

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

    60

        if pos is not None:

    61

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

    62

        powerrail.Connectors = []

    63

        for connector in self.Connectors:

    64

            if connector is not None:

    65

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

    66

            else:

    67

                powerrail.Connectors.append(None)

    68

        return powerrail

    69

    70

    # Returns the RedrawRect

    71

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

    72

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

    73

        for connector in self.Connectors:

    74

            if connector is not None:

    75

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

    76

        if movex != 0 or movey != 0:

    77

            for connector in self.Connectors:

    78

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

    79

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

    80

        return rect

    81

    82

    # Forbids to change the power rail size

    83

    def SetSize(self, width, height):

    84

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

    85

            Graphic_Element.SetSize(self, width, height)

    86

            self.RefreshConnectors()

    87

    88

    # Forbids to select a power rail

    89

    def HitTest(self, pt):

    90

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

    91

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

    92

        return False

    93

    94

    # Forbids to select a power rail

    95

    def IsInSelection(self, rect):

    96

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

    97

            return Graphic_Element.IsInSelection(self, rect)

    98

        return False

    99

   100

    # Deletes this power rail by calling the appropriate method

   101

    def Delete(self):

   102

        self.Parent.DeletePowerRail(self)

   103

   104

    # Unconnect all connectors

   105

    def Clean(self):

   106

        for connector in self.Connectors:

   107

            if connector:

   108

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

   109

   110

    # Refresh the power rail bounding box

   111

    def RefreshBoundingBox(self):

   112

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

   113

   114

    # Refresh the power rail size

   115

    def RefreshSize(self):

   116

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

   117

        self.RefreshBoundingBox()

   118

   119

    # Returns the block minimum size

   120

    def GetMinSize(self):

   121

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

   122

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

   123

        else:

   124

            return LD_POWERRAIL_WIDTH, LD_LINE_SIZE * len(self.Connectors)

   125

   126

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

   127

    def AddConnector(self, connector = True):

   128

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

   129

   130

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

   131

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

   132

        if connector:

   133

            if self.Type == LEFTRAIL:

   134

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

   135

            elif self.Type == RIGHTRAIL:

   136

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

   137

            self.Connectors.insert(idx, connector)

   138

        else:

   139

            self.Connectors.insert(idx, None)

   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: x.Pos.y.__cmp__(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

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

   175

    def IsNullConnector(self, idx):

   176

        if idx < len(self.Connectors):

   177

            return self.Connectors[idx] == None

   178

        return False

   179

   180

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

   181

    def DeleteConnector(self, idx):

   182

        self.Connectors.pop(idx)

   183

        self.RefreshConnectors()

   184

        self.RefreshSize()

   185

   186

    # Refresh the positions of the power rail connectors

   187

    def RefreshConnectors(self):

   188

        scaling = self.Parent.GetScaling()

   189

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

   190

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

   191

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

   192

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

   193

                if self.RealConnectors:

   194

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

   195

                else:

   196

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

   197

                if scaling is not None:

   198

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

   199

                if self.Type == LEFTRAIL:

   200

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

   201

                elif self.Type == RIGHTRAIL:

   202

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

   203

        else:

   204

            position = self.Extensions[0]

   205

            for connector in self.Connectors:

   206

                if connector:

   207

                    if scaling is not None:

   208

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

   209

                    else:

   210

                        ypos = position

   211

                    if self.Type == LEFTRAIL:

   212

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

   213

                    elif self.Type == RIGHTRAIL:

   214

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

   215

                position += LD_LINE_SIZE

   216

        self.RefreshConnected()

   217

   218

    # Refresh the position of wires connected to power rail

   219

    def RefreshConnected(self, exclude = []):

   220

        for connector in self.Connectors:

   221

            if connector:

   222

                connector.MoveConnected(exclude)

   223

   224

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

   225

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

   226

        # if a name is given

   227

        if name:

   228

            # Test each connector if it exists

   229

            for connector in self.Connectors:

   230

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

   231

                    return connector

   232

        for connector in self.Connectors:

   233

            if connector:

   234

                connector_pos = connector.GetRelPosition()

   235

                if position.x == self.Pos.x + connector_pos.x and position.y == self.Pos.y + connector_pos.y:

   236

                    return connector

   237

        return None

   238

   239

    # Returns all the power rail connectors 

   240

    def GetConnectors(self):

   241

        return [connector for connector in self.Connectors if connector]

   242

   243

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

   244

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

   245

        for connector in self.Connectors:

   246

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

   247

                return connector

   248

        return None

   249

   250

    # Returns the power rail type

   251

    def SetType(self, type, connectors):

   252

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

   253

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

   254

            # the connectors list

   255

            self.Type = type

   256

            self.Clean()

   257

            self.Connectors = []

   258

            for connector in connectors:

   259

                self.AddConnector(connector)

   260

            self.RefreshSize()

   261

   262

    # Returns the power rail type

   263

    def GetType(self):

   264

        return self.Type

   265

   266

    # Method called when a LeftDown event have been generated

   267

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

   268

        self.RealConnectors = []

   269

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

   270

        for connector in self.Connectors:

   271

            position = connector.GetRelPosition()

   272

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

   273

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

   274

   275

    # Method called when a LeftUp event have been generated

   276

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

   277

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

   278

        self.RealConnectors = None

   279

   280

    # Method called when a LeftDown event have been generated

   281

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

   282

        pos = GetScaledEventPosition(event, dc, scaling)

   283

        # Test if a connector have been handled

   284

        connector = self.TestConnector(pos, False)

   285

        if connector:

   286

            self.Handle = (HANDLE_CONNECTOR, connector)

   287

            self.Parent.SetCursor(wx.StockCursor(wx.CURSOR_HAND))

   288

            self.Selected = False

   289

            # Initializes the last position

   290

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

   291

        else:

   292

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

   293

   294

    # Method called when a LeftDClick event have been generated

   295

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

   296

        # Edit the powerrail properties

   297

        self.Parent.EditPowerRailContent(self)

   298

   299

    # Method called when a RightUp event have been generated

   300

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

   301

        handle_type, handle = self.Handle

   302

        if handle_type == HANDLE_CONNECTOR:

   303

            wires = handle.GetWires()

   304

            if len(wires) == 1:

   305

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

   306

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

   307

                else:

   308

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

   309

                block.RefreshModel(False)

   310

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

   311

        else:

   312

            self.Parent.PopupDefaultMenu()

   313

   314

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

   315

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

   316

        handle_type, handle = self.Handle

   317

        # A connector has been handled

   318

        if handle_type == HANDLE_CONNECTOR:

   319

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

   320

            if scaling is not None:

   321

                position = handle.GetRelPosition()

   322

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

   323

            self.MoveConnector(handle, movey)

   324

            return 0, movey

   325

        else:

   326

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

   327

   328

    # Refreshes the power rail model

   329

    def RefreshModel(self, move=True):

   330

        self.Parent.RefreshPowerRailModel(self)

   331

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

   332

        # of wires connected to connectors

   333

        if move and self.Type == LEFTRAIL:

   334

            for connector in self.Connectors:

   335

                if connector:

   336

                    connector.RefreshWires()

   337

   338

    # Draws power rail

   339

    def Draw(self, dc):

   340

        Graphic_Element.Draw(self, dc)

   341

        dc.SetPen(wx.BLACK_PEN)

   342

        dc.SetBrush(wx.BLACK_BRUSH)

   343

        # Draw a rectangle with the power rail size

   344

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

   345

        # Draw connectors

   346

        for connector in self.Connectors:

   347

            if connector:

   348

                connector.Draw(dc)

   349

   350

   351

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

   352

#                         Ladder Diagram Contact

   353

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

   354

   355

"""

   356

Class that implements the graphic representation of a contact

   357

"""

   358

   359

class LD_Contact(Graphic_Element):

   360

   361

    # Create a new contact

   362

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

   363

        Graphic_Element.__init__(self, parent)

   364

        self.Type = type

   365

        self.Name = name

   366

        self.Id = id

   367

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

   368

        # Create an input and output connector

   369

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

   370

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

   371

        self.RefreshNameSize()

   372

        self.RefreshTypeSize()

   373

   374

    # Destructor

   375

    def __del__(self):

   376

        self.Input = None

   377

        self.Output = None

   378

   379

    # Make a clone of this LD_Contact

   380

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

   381

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

   382

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

   383

        if pos is not None:

   384

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

   385

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

   386

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

   387

        return contact

   388

   389

    # Returns the RedrawRect

   390

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

   391

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

   392

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

   393

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

   394

        if movex != 0 or movey != 0:

   395

            if self.Input.IsConnected():

   396

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

   397

            if self.Output.IsConnected():

   398

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

   399

        return rect

   400

   401

    # Forbids to change the contact size

   402

    def SetSize(self, width, height):

   403

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

   404

            Graphic_Element.SetSize(self, width, height)

   405

            self.RefreshConnectors()

   406

   407

    # Delete this contact by calling the appropriate method

   408

    def Delete(self):

   409

        self.Parent.DeleteContact(self)

   410

   411

    # Unconnect input and output

   412

    def Clean(self):

   413

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

   414

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

   415

   416

    # Refresh the size of text for name

   417

    def RefreshNameSize(self):

   418

        if self.Name != "":

   419

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

   420

        else:

   421

            self.NameSize = 0, 0

   422

   423

    # Refresh the size of text for type

   424

    def RefreshTypeSize(self):

   425

        typetext = ""

   426

        if self.Type == CONTACT_REVERSE:

   427

            typetext = "/"

   428

        elif self.Type == CONTACT_RISING:

   429

            typetext = "P"

   430

        elif self.Type == CONTACT_FALLING:

   431

            typetext = "N"

   432

        if typetext != "":

   433

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

   434

        else:

   435

            self.TypeSize = 0, 0

   436

   437

    # Refresh the contact bounding box

   438

    def RefreshBoundingBox(self):

   439

        # Calculate the size of the name outside the contact

   440

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

   441

        # Calculate the bounding box size

   442

        if self.Name != "":

   443

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

   444

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

   445

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

   446

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

   447

        else:

   448

            bbx_x = self.Pos.x

   449

            bbx_width = self.Size[0]

   450

            bbx_y = self.Pos.y

   451

            bbx_height = self.Size[1]

   452

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

   453

   454

    # Returns the block minimum size

   455

    def GetMinSize(self):

   456

        return LD_ELEMENT_SIZE

   457

   458

    # Refresh the position of wire connected to contact

   459

    def RefreshConnected(self, exclude = []):

   460

        self.Input.MoveConnected(exclude)

   461

        self.Output.MoveConnected(exclude)

   462

   463

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

   464

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

   465

        # if a name is given

   466

        if name:

   467

            # Test input and output connector

   468

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

   469

                return self.Input

   470

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

   471

                return self.Output

   472

        # Test input connector

   473

        input_pos = self.Input.GetRelPosition()

   474

        if position.x == self.Pos.x + input_pos.x and position.y == self.Pos.y + input_pos.y:

   475

            return self.Input

   476

        # Test output connector

   477

        output_pos = self.Output.GetRelPosition()

   478

        if position.x == self.Pos.x + output_pos.x and position.y == self.Pos.y + output_pos.y:

   479

            return self.Output

   480

        return None

   481

   482

    # Returns input and output contact connectors 

   483

    def GetConnectors(self):

   484

        return {"input":self.Input,"output":self.Output}

   485

   486

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

   487

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

   488

        # Test input connector

   489

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

   490

            return self.Input

   491

        # Test output connector

   492

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

   493

            return self.Output

   494

        return None

   495

   496

    # Refresh the positions of the block connectors

   497

    def RefreshConnectors(self):

   498

        scaling = self.Parent.GetScaling()

   499

        position = self.Size[1] / 2 + 1

   500

        if scaling is not None:

   501

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

   502

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