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): 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 Lesser 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

#Lesser General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU Lesser 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 = type

    45

        self.Id = id

    46

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

    47

        # the connectors list

    48

        self.Connectors = []

    49

        for connector in connectors:

    50

            self.AddConnector(connector)

    51

        self.RefreshSize()

    52

    53

    # Destructor

    54

    def __del__(self):

    55

        self.Connectors = []

    56

    57

    # Forbids to change the power rail size

    58

    def SetSize(self, width, height):

    59

        pass

    60

    61

    # Forbids to select a power rail

    62

    def HitTest(self, pt):

    63

        return False

    64

    65

    # Deletes this power rail by calling the appropriate method

    66

    def Delete(self):

    67

        self.Parent.DeletePowerRail(self)

    68

    69

    # Unconnect all connectors

    70

    def Clean(self):

    71

        for connector in self.Connectors:

    72

            if connector:

    73

                connector.UnConnect()

    74

    75

    # Refresh the power rail bounding box

    76

    def RefreshBoundingBox(self):

    77

        dc = wxClientDC(self.Parent)

    78

        if self.Type == LEFTRAIL:

    79

            bbx_x = self.Pos.x

    80

        elif self.Type == RIGHTRAIL:

    81

            bbx_x = self.Pos.x - CONNECTOR_SIZE

    82

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

    83

    84

    # Refresh the power rail size

    85

    def RefreshSize(self):

    86

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

    87

        self.RefreshBoundingBox()

    88

    89

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

    90

    def AddConnector(self, connector = True):

    91

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

    92

    93

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

    94

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

    95

        if connector:

    96

            if self.Type == LEFTRAIL:

    97

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

    98

            elif self.Type == RIGHTRAIL:

    99

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

   100

            self.Connectors.insert(idx, connector)

   101

        else:

   102

            self.Connectors.insert(idx, None)

   103

        self.RefreshSize()

   104

        self.RefreshConnectors()

   105

   106

    # Returns the index in connectors list for the connector given

   107

    def GetConnectorIndex(self, connector):

   108

        if connector in self.Connectors:

   109

            return self.Connectors.index(connector)

   110

        return None

   111

   112

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

   113

    def IsNullConnector(self, idx):

   114

        if idx < len(self.Connectors):

   115

            return self.Connectors[idx] == None

   116

        return False

   117

   118

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

   119

    def DeleteConnector(self, idx):

   120

        self.Connectors.pop(idx)

   121

        self.RefreshConnectors()

   122

        self.RefreshSize()

   123

   124

    # Refresh the positions of the power rail connectors

   125

    def RefreshConnectors(self):

   126

        position = LD_LINE_SIZE / 2

   127

        for connector in self.Connectors:

   128

            if connector:

   129

                if self.Type == LEFTRAIL:

   130

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

   131

                elif self.Type == RIGHTRAIL:

   132

                    connector.SetPosition(wxPoint(0, position))

   133

            position += LD_LINE_SIZE

   134

        self.RefreshConnected()

   135

   136

    # Refresh the position of wires connefcted to power rail

   137

    def RefreshConnected(self, exclude = []):

   138

        for connector in self.Connectors:

   139

            connector.MoveConnected(exclude)

   140

   141

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

   142

    def GetConnector(self, position):

   143

        for connector in self.Connectors:

   144

            if connector:

   145

                connector_pos = connector.GetRelPosition()

   146

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

   147

                    return connector

   148

        return None

   149

   150

    # Returns all the power rail connectors 

   151

    def GetConnectors(self):

   152

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

   153

   154

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

   155

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

   156

        for connector in self.Connectors:

   157

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

   158

                return connector

   159

        return None

   160

   161

    # Returns the power rail type

   162

    def GetType(self):

   163

        return self.Type

   164

   165

    # Refreshes the power rail model

   166

    def RefreshModel(self, move=True):

   167

        self.Parent.RefreshPowerRailModel(self)

   168

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

   169

        # of wires connected to connectors

   170

        if move and self.Type == LEFTRAIL:

   171

            for connector in self.Connectors:

   172

                if connector:

   173

                    connector.RefreshWires()

   174

   175

    # Draws power rail

   176

    def Draw(self, dc):

   177

        dc.SetPen(wxBLACK_PEN)

   178

        dc.SetBrush(wxBLACK_BRUSH)

   179

        # Draw a rectangle with the power rail size

   180

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

   181

        # Draw connectors

   182

        for connector in self.Connectors:

   183

            if connector:

   184

                connector.Draw(dc)

   185

        Graphic_Element.Draw(self, dc)

   186

   187

   188

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

   189

#                         Ladder Diagram Contact

   190

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

   191

   192

"""

   193

Class that implements the graphic representation of a contact

   194

"""

   195

   196

class LD_Contact(Graphic_Element):

   197

   198

    # Create a new contact

   199

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

   200

        Graphic_Element.__init__(self, parent)

   201

        self.Type = type

   202

        self.Name = name

   203

        self.Id = id

   204

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

   205

        # Create an input and output connector

   206

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

   207

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

   208

   209

    # Destructor

   210

    def __del__(self):

   211

        self.Input = None

   212

        self.Output = None

   213

   214

    # Forbids to change the contact size

   215

    def SetSize(self, width, height):

   216

        pass

   217

   218

    # Delete this contact by calling the appropriate method

   219

    def Delete(self):

   220

        self.Parent.DeleteContact(self)

   221

   222

    # Unconnect input and output

   223

    def Clean(self):

   224

        self.Input.UnConnect()

   225

        self.Output.UnConnect()

   226

   227

    # Refresh the contact bounding box

   228

    def RefreshBoundingBox(self):

   229

        dc = wxClientDC(self.Parent)

   230

        # Calculate the size of the name outside the contact

   231

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

   232

        # Calculate the bounding box size

   233

        if self.Name != "":

   234

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

   235

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

   236

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

   237

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

   238

        else:

   239

            bbx_x = self.Pos.x

   240

            bbx_width = self.Size[0]

   241

            bbx_y = self.Pos.y

   242

            bbx_height = self.Size[1]

   243

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

   244

   245

    # Refresh the position of wire connected to contact

   246

    def RefreshConnected(self, exclude = []):

   247

        self.Input.MoveConnected(exclude)

   248

        self.Output.MoveConnected(exclude)

   249

   250

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

   251

    def GetConnector(self, position):

   252

        # Test input connector

   253

        input_pos = self.Input.GetRelPosition()

   254

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

   255

            return self.Input

   256

        # Test output connector

   257

        output_pos = self.Output.GetRelPosition()

   258

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

   259

            return self.Output

   260

        return None

   261

   262

    # Returns input and output contact connectors 

   263

    def GetConnectors(self):

   264

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

   265

   266

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

   267

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

   268

        # Test input connector

   269

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

   270

            return self.Input

   271

        # Test output connector

   272

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

   273

            return self.Output

   274

        return None

   275

   276

    # Changes the contact name

   277

    def SetName(self, name):

   278

        self.Name = name

   279

   280

    # Returns the contact name

   281

    def GetName(self):

   282

        return self.Name

   283

   284

    # Changes the contact type

   285

    def SetType(self, type):

   286

        self.Type = type

   287

   288

    # Returns the contact type

   289

    def GetType(self):

   290

        return self.Type

   291

   292

    # Method called when a LeftDClick event have been generated

   293

    def OnLeftDClick(self, event, scaling):

   294

        # Edit the contact properties

   295

        self.Parent.EditContactContent(self)

   296

   297

    # Refreshes the contact model

   298

    def RefreshModel(self, move=True):

   299

        self.Parent.RefreshContactModel(self)

   300

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

   301

        if move:

   302

            self.Output.RefreshWires()

   303

   304

    # Draws contact

   305

    def Draw(self, dc):

   306

        dc.SetPen(wxBLACK_PEN)

   307

        dc.SetBrush(wxBLACK_BRUSH)

   308

        # Draw two rectangles for representing the contact

   309

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

   310

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

   311

        # Draw contact name

   312

        namewidth, nameheight = dc.GetTextExtent(self.Name)

   313

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

   314

                self.Pos.y - (nameheight + 2))

   315

        # Draw the modifier symbol in the middle of contact

   316

        typetext = ""

   317

        if self.Type == CONTACT_REVERSE:

   318

            typetext = "/"

   319

        elif self.Type == CONTACT_RISING:

   320

            typetext = "P"

   321

        elif self.Type == CONTACT_FALLING:

   322

            typetext = "N"

   323

        if typetext != "":

   324

            typewidth, typeheight = dc.GetTextExtent(typetext)

   325

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

   326

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

   327

        # Draw input and output connectors

   328

        self.Input.Draw(dc)

   329

        self.Output.Draw(dc)

   330

        Graphic_Element.Draw(self, dc)

   331

   332

   333

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

   334

#                         Ladder Diagram Coil

   335

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

   336

   337

"""

   338

Class that implements the graphic representation of a coil

   339

"""

   340

   341

class LD_Coil(Graphic_Element):

   342

   343

    # Create a new coil

   344

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

   345

        Graphic_Element.__init__(self, parent)

   346

        self.Type = type

   347

        self.Name = name

   348

        self.Id = id

   349

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

   350

        # Create an input and output connector

   351

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

   352

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

   353

   354

    # Destructor

   355

    def __del__(self):

   356

        self.Input = None

   357

        self.Output = None

   358

   359

    # Forbids to change the contact size

   360

    def SetSize(self, width, height):

   361

        pass

   362

   363

    # Delete this coil by calling the appropriate method

   364

    def Delete(self):

   365

        self.Parent.DeleteCoil(self)

   366

   367

    # Unconnect input and output

   368

    def Clean(self):

   369

        self.Input.UnConnect()

   370

        self.Output.UnConnect()

   371

   372

    # Refresh the coil bounding box

   373

    def RefreshBoundingBox(self):

   374

        dc = wxClientDC(self.Parent)

   375

        # Calculate the size of the name outside the coil

   376

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

   377

        # Calculate the bounding box size

   378

        if self.Name != "":

   379

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

   380

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

   381

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

   382

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

   383

        else:

   384

            bbx_x = self.Pos.x

   385

            bbx_width = self.Size[0]

   386

            bbx_y = self.Pos.y

   387

            bbx_height = self.Size[1]

   388

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

   389

   390

    # Refresh the position of wire connected to coil

   391

    def RefreshConnected(self, exclude = []):

   392

        self.Input.MoveConnected(exclude)

   393

        self.Output.MoveConnected(exclude)

   394

   395

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

   396

    def GetConnector(self, position):

   397

        # Test input connector

   398

        input_pos = self.Input.GetRelPosition()

   399

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

   400

            return self.Input

   401

        # Test output connector

   402

        output_pos = self.Output.GetRelPosition()

   403

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

   404

            return self.Output

   405

        return None

   406

   407

    # Returns input and output coil connectors 

   408

    def GetConnectors(self):

   409

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

   410

   411

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

   412

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

   413

        # Test input connector

   414

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

   415

            return self.Input

   416

        # Test output connector

   417

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

   418

            return self.Output

   419

        return None

   420

   421

    # Changes the coil name

   422

    def SetName(self, name):

   423

        self.Name = name

   424

   425

    # Returns the coil name

   426

    def GetName(self):

   427

        return self.Name

   428

   429

    # Changes the coil type

   430

    def SetType(self, type):

   431

        self.Type = type

   432

   433

    # Returns the coil type

   434

    def GetType(self):

   435

        return self.Type

   436

   437

    # Method called when a LeftDClick event have been generated

   438

    def OnLeftDClick(self, event, scaling):

   439

        # Edit the coil properties

   440

        self.Parent.EditCoilContent(self)

   441

   442

    # Refreshes the coil model

   443

    def RefreshModel(self, move=True):

   444

        self.Parent.RefreshCoilModel(self)

   445

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

   446

        if move:

   447

            self.Output.RefreshWires()

   448

   449

    # Draws coil

   450

    def Draw(self, dc):

   451

        dc.SetPen(wxPen(wxBLACK, 2, wxSOLID))

   452

        dc.SetBrush(wxTRANSPARENT_BRUSH)

   453

        # Draw a two circle arcs for representing the coil

   454

        dc.DrawEllipticArc(self.Pos.x, self.Pos.y - int(self.Size[1] * (sqrt(2) - 1.) / 2.) + 1, self.Size[0], int(self.Size[1] * sqrt(2)) - 1, 135, 225)

   455

        dc.DrawEllipticArc(self.Pos.x, self.Pos.y - int(self.Size[1] * (sqrt(2) - 1.) / 2.) + 1, self.Size[0], int(self.Size[1] * sqrt(2)) - 1, -45, 45)

   456

        dc.SetPen(wxBLACK_PEN)

   457

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

   458

        # Draw coil name

   459

        namewidth, nameheight = dc.GetTextExtent(self.Name)

   460

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

   461

                self.Pos.y - (nameheight + 2))

   462

        # Draw the modifier symbol in the middle of coil

   463

        typetext = ""

   464

        if self.Type == COIL_REVERSE:

   465

            typetext = "/"

   466

        elif self.Type == COIL_SET:

   467

            typetext = "S"

   468

        elif self.Type == COIL_RESET:

   469

            typetext = "R"

   470

        if typetext != "":

   471

            typewidth, typeheight = dc.GetTextExtent(typetext)

   472

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

   473

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

   474

        # Draw input and output connectors

   475

        self.Input.Draw(dc)

   476

        self.Output.Draw(dc)

   477

        Graphic_Element.Draw(self, dc)