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

from wxPython.wx import *

    26

import wx

    27

    28

from GraphicCommons import *

    29

from plcopen.structures import *

    30

    31

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

    32

#                         Ladder Diagram PowerRail

    33

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

    34

    35

"""

    36

Class that implements the graphic representation of a power rail

    37

"""

    38

    39

class LD_PowerRail(Graphic_Element):

    40

    41

    # Create a new power rail

    42

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

    43

        Graphic_Element.__init__(self, parent)

    44

        self.Type = None

    45

        self.Connectors = []

    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

    # Forbids to change the power rail size

    57

    def SetSize(self, width, height):

    58

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

    59

            Graphic_Element.SetSize(self, width, height)

    60

            self.RefreshConnectors()

    61

    62

    # Forbids to select a power rail

    63

    def HitTest(self, pt):

    64

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

    65

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

    66

        return False

    67

    68

    # Forbids to select a power rail

    69

    def IsInSelection(self, rect):

    70

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

    71

            return Graphic_Element.IsInSelection(self, rect)

    72

        return False

    73

    74

    # Deletes this power rail by calling the appropriate method

    75

    def Delete(self):

    76

        self.Parent.DeletePowerRail(self)

    77

    78

    # Unconnect all connectors

    79

    def Clean(self):

    80

        for connector in self.Connectors:

    81

            if connector:

    82

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

    83

    84

    # Refresh the power rail bounding box

    85

    def RefreshBoundingBox(self):

    86

        dc = wxClientDC(self.Parent)

    87

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

    88

    89

    # Refresh the power rail size

    90

    def RefreshSize(self):

    91

        self.Size = wxSize(2, LD_LINE_SIZE * len(self.Connectors))

    92

        self.RefreshBoundingBox()

    93

    94

    # Returns the block minimum size

    95

    def GetMinSize(self):

    96

        return 2, LD_LINE_SIZE * len(self.Connectors)

    97

    98

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

    99

    def AddConnector(self, connector = True):

   100

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

   101

   102

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

   103

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

   104

        if connector:

   105

            if self.Type == LEFTRAIL:

   106

                connector = Connector(self, "", "BOOL", wxPoint(2, 0), EAST)

   107

            elif self.Type == RIGHTRAIL:

   108

                connector = Connector(self, "", "BOOL", wxPoint(0, 0), WEST)

   109

            self.Connectors.insert(idx, connector)

   110

        else:

   111

            self.Connectors.insert(idx, None)

   112

        self.RefreshSize()

   113

        self.RefreshConnectors()

   114

   115

    # Moves the divergence connector given

   116

    def MoveConnector(self, connector, movey):

   117

        position = connector.GetRelPosition()

   118

        connector.SetPosition(wxPoint(position.x, position.y + movey))

   119

        miny = self.Size[1]

   120

        maxy = 0

   121

        for connect in self.Connectors:

   122

            connect_pos = connect.GetRelPosition()

   123

            miny = min(miny, connect_pos.y)

   124

            maxy = max(maxy, connect_pos.y)

   125

        min_pos = self.Pos.y + miny - self.Extensions[0]

   126

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

   127

        if min_pos == self.Pos.y:

   128

            for connect in self.Connectors:

   129

                connect_pos = connect.GetRelPosition()

   130

                connect.SetPosition(wxPoint(connect_pos.x, connect_pos.y - miny + self.Extensions[0]))

   131

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

   132

        connector.MoveConnected()

   133

        self.RefreshBoundingBox()

   134

   135

    # Returns the index in connectors list for the connector given

   136

    def GetConnectorIndex(self, connector):

   137

        if connector in self.Connectors:

   138

            return self.Connectors.index(connector)

   139

        return None

   140

   141

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

   142

    def IsNullConnector(self, idx):

   143

        if idx < len(self.Connectors):

   144

            return self.Connectors[idx] == None

   145

        return False

   146

   147

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

   148

    def DeleteConnector(self, idx):

   149

        self.Connectors.pop(idx)

   150

        self.RefreshConnectors()

   151

        self.RefreshSize()

   152

   153

    # Refresh the positions of the power rail connectors

   154

    def RefreshConnectors(self):

   155

        position = self.Extensions[0]

   156

        for connector in self.Connectors:

   157

            if connector:

   158

                if self.Type == LEFTRAIL:

   159

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

   160

                elif self.Type == RIGHTRAIL:

   161

                    connector.SetPosition(wxPoint(0, position))

   162

            position += LD_LINE_SIZE

   163

        self.RefreshConnected()

   164

   165

    # Refresh the position of wires connected to power rail

   166

    def RefreshConnected(self, exclude = []):

   167

        for connector in self.Connectors:

   168

            if connector:

   169

                connector.MoveConnected(exclude)

   170

   171

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

   172

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

   173

        # if a name is given

   174

        if name:

   175

            # Test each connector if it exists

   176

            for connector in self.Connectors:

   177

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

   178

                    return connector

   179

        for connector in self.Connectors:

   180

            if connector:

   181

                connector_pos = connector.GetRelPosition()

   182

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

   183

                    return connector

   184

        return None

   185

   186

    # Returns all the power rail connectors 

   187

    def GetConnectors(self):

   188

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

   189

   190

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

   191

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

   192

        for connector in self.Connectors:

   193

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

   194

                return connector

   195

        return None

   196

   197

    # Returns the power rail type

   198

    def SetType(self, type, connectors):

   199

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

   200

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

   201

            # the connectors list

   202

            self.Type = type

   203

            self.Clean()

   204

            self.Connectors = []

   205

            for connector in connectors:

   206

                self.AddConnector(connector)

   207

            self.RefreshSize()

   208

   209

    # Returns the power rail type

   210

    def GetType(self):

   211

        return self.Type

   212

   213

    # Method called when a LeftDown event have been generated

   214

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

   215

        pos = GetScaledEventPosition(event, dc, scaling)

   216

        # Test if a connector have been handled

   217

        connector = self.TestConnector(pos, False)

   218

        if connector:

   219

            self.Handle = (HANDLE_CONNECTOR, connector)

   220

            self.Parent.SetCursor(wxStockCursor(wxCURSOR_HAND))

   221

            self.Selected = False

   222

            # Initializes the last position

   223

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

   224

        else:

   225

##            self.RealConnectors = {"Inputs":[],"Outputs":[]}

   226

##            for input in self.Inputs:

   227

##                position = input.GetRelPosition()

   228

##                self.RealConnectors["Inputs"].append(float(position.x)/float(self.Size[0]))

   229

##            for output in self.Outputs:

   230

##                position = output.GetRelPosition()

   231

##                self.RealConnectors["Outputs"].append(float(position.x)/float(self.Size[0]))

   232

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

   233

   234

    # Method called when a LeftUp event have been generated

   235

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

   236

        self.RealConnectors = None

   237

        handle_type, handle = self.Handle

   238

        if handle_type == HANDLE_CONNECTOR:

   239

            wires = handle.GetWires()

   240

            if len(wires) != 1:

   241

                return

   242

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

   243

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

   244

            else:

   245

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

   246

            block.RefreshModel(False)

   247

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

   248

   249

    # Method called when a LeftDClick event have been generated

   250

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

   251

        # Edit the powerrail properties

   252

        self.Parent.EditPowerRailContent(self)

   253

   254

    # Method called when a RightUp event have been generated

   255

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

   256

        pos = GetScaledEventPosition(event, dc, scaling)

   257

        # Popup the menu with special items for a block and a connector if one is handled

   258

        connector = self.TestConnector(pos, False)

   259

        if connector:

   260

            self.Handle = (HANDLE_CONNECTOR, connector)

   261

        #    self.Parent.PopupDivergenceMenu(True)

   262

        #else:

   263

            # Popup the divergence menu without delete branch

   264

        #    self.Parent.PopupDivergenceMenu(False)

   265

   266

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

   267

    def ProcessDragging(self, movex, movey):

   268

        handle_type, handle = self.Handle

   269

        # A connector has been handled

   270

        if handle_type == HANDLE_CONNECTOR:

   271

            self.MoveConnector(handle, movey)

   272

        else:

   273

            Graphic_Element.ProcessDragging(self, movex, movey)

   274

   275

    # Refreshes the power rail model

   276

    def RefreshModel(self, move=True):

   277

        self.Parent.RefreshPowerRailModel(self)

   278

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

   279

        # of wires connected to connectors

   280

        if move and self.Type == LEFTRAIL:

   281

            for connector in self.Connectors:

   282

                if connector:

   283

                    connector.RefreshWires()

   284

   285

    # Draws power rail

   286

    def Draw(self, dc):

   287

        dc.SetPen(wxBLACK_PEN)

   288

        dc.SetBrush(wxBLACK_BRUSH)

   289

        # Draw a rectangle with the power rail size

   290

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

   291

        # Draw connectors

   292

        for connector in self.Connectors:

   293

            if connector:

   294

                connector.Draw(dc)

   295

        Graphic_Element.Draw(self, dc)

   296

   297

   298

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

   299

#                         Ladder Diagram Contact

   300

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

   301

   302

"""

   303

Class that implements the graphic representation of a contact

   304

"""

   305

   306

class LD_Contact(Graphic_Element):

   307

   308

    # Create a new contact

   309

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

   310

        Graphic_Element.__init__(self, parent)

   311

        self.Type = type

   312

        self.Name = name

   313

        self.Id = id

   314

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

   315

        # Create an input and output connector

   316

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

   317

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

   318

        self.RefreshNameSize()

   319

        self.RefreshTypeSize()

   320

   321

    # Destructor

   322

    def __del__(self):

   323

        self.Input = None

   324

        self.Output = None

   325

   326

    # Forbids to change the contact size

   327

    def SetSize(self, width, height):

   328

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

   329

            Graphic_Element.SetSize(self, width, height)

   330

            self.RefreshConnectors()

   331

   332

    # Delete this contact by calling the appropriate method

   333

    def Delete(self):

   334

        self.Parent.DeleteContact(self)

   335

   336

    # Unconnect input and output

   337

    def Clean(self):

   338

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

   339

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

   340

   341

    # Refresh the size of text for name

   342

    def RefreshNameSize(self):

   343

        dc = wxClientDC(self.Parent)

   344

        if self.Name != "":

   345

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

   346

        else:

   347

            self.NameSize = 0, 0

   348

   349

    # Refresh the size of text for type

   350

    def RefreshTypeSize(self):

   351

        dc = wxClientDC(self.Parent)

   352

        typetext = ""

   353

        if self.Type == CONTACT_REVERSE:

   354

            typetext = "/"

   355

        elif self.Type == CONTACT_RISING:

   356

            typetext = "P"

   357

        elif self.Type == CONTACT_FALLING:

   358

            typetext = "N"

   359

        if typetext != "":

   360

            self.TypeSize = dc.GetTextExtent(typetext)

   361

        else:

   362

            self.TypeSize = 0, 0

   363

   364

    # Refresh the contact bounding box

   365

    def RefreshBoundingBox(self):

   366

        dc = wxClientDC(self.Parent)

   367

        # Calculate the size of the name outside the contact

   368

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

   369

        # Calculate the bounding box size

   370

        if self.Name != "":

   371

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

   372

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

   373

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

   374

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

   375

        else:

   376

            bbx_x = self.Pos.x

   377

            bbx_width = self.Size[0]

   378

            bbx_y = self.Pos.y

   379

            bbx_height = self.Size[1]

   380

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

   381

   382

    # Returns the block minimum size

   383

    def GetMinSize(self):

   384

        return LD_ELEMENT_SIZE

   385

   386

    # Refresh the position of wire connected to contact

   387

    def RefreshConnected(self, exclude = []):

   388

        self.Input.MoveConnected(exclude)

   389

        self.Output.MoveConnected(exclude)

   390

   391

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

   392

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

   393

        # if a name is given

   394

        if name:

   395

            # Test input and output connector

   396

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

   397

                return self.Input

   398

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

   399

                return self.Output

   400

        # Test input connector

   401

        input_pos = self.Input.GetRelPosition()

   402

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

   403

            return self.Input

   404

        # Test output connector

   405

        output_pos = self.Output.GetRelPosition()

   406

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

   407

            return self.Output

   408

        return None

   409

   410

    # Returns input and output contact connectors 

   411

    def GetConnectors(self):

   412

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

   413

   414

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

   415

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

   416

        # Test input connector

   417

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

   418

            return self.Input

   419

        # Test output connector

   420

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

   421

            return self.Output

   422

        return None

   423

   424

    # Refresh the positions of the block connectors

   425

    def RefreshConnectors(self):

   426

        self.Input.SetPosition(wxPoint(0, self.Size[1] / 2 + 1))

   427

        self.Output.SetPosition(wxPoint(self.Size[0], self.Size[1] / 2 + 1))

   428

        self.RefreshConnected()

   429

   430

    # Changes the contact name

   431

    def SetName(self, name):

   432

        self.Name = name

   433

        self.RefreshNameSize()

   434

   435

    # Returns the contact name

   436

    def GetName(self):

   437

        return self.Name

   438

   439

    # Changes the contact type

   440

    def SetType(self, type):

   441

        self.Type = type

   442

        self.RefreshTypeSize()

   443

   444

    # Returns the contact type

   445

    def GetType(self):

   446

        return self.Type

   447

   448

    # Method called when a LeftDClick event have been generated

   449

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

   450

        # Edit the contact properties

   451

        self.Parent.EditContactContent(self)

   452

   453

    # Refreshes the contact model

   454

    def RefreshModel(self, move=True):

   455

        self.Parent.RefreshContactModel(self)

   456

        # If contact has moved, refresh the model of wires connected to output

   457

        if move:

   458

            self.Output.RefreshWires()

   459

   460

    # Draws contact

   461

    def Draw(self, dc):

   462

        dc.SetPen(wxBLACK_PEN)

   463

        dc.SetBrush(wxBLACK_BRUSH)

   464

        # Draw two rectangles for representing the contact

   465

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

   466

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

   467

        # Draw contact name

   468

        dc.DrawText(self.Name, self.Pos.x + (self.Size[0] - self.NameSize[0]) / 2,

   469

                self.Pos.y - (self.NameSize[1] + 2))

   470

        # Draw the modifier symbol in the middle of contact

   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

            dc.DrawText(typetext, self.Pos.x + (self.Size[0] - self.TypeSize[0]) / 2 + 1,

   480

                    self.Pos.y + (self.Size[1] - self.TypeSize[1]) / 2)

   481

        # Draw input and output connectors

   482

        self.Input.Draw(dc)

   483

        self.Output.Draw(dc)

   484

        Graphic_Element.Draw(self, dc)

   485

   486

   487

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

   488

#                         Ladder Diagram Coil

   489

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

   490

   491

"""

   492

Class that implements the graphic representation of a coil

   493

"""

   494

   495

class LD_Coil(Graphic_Element):

   496

   497

    # Create a new coil

   498

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

   499

        Graphic_Element.__init__(self, parent)

   500

        self.Type = type

   501

        self.Name = name

   502

        self.Id = id

   503

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

   504

        # Create an input and output connector

   505

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

   506

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

   507

        self.RefreshNameSize()

   508

        self.RefreshTypeSize()

   509

   510

    # Destructor

   511

    def __del__(self):

   512

        self.Input = None