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

    # 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 = wx.ClientDC(self.Parent)

    87

        self.BoundingBox = wx.Rect(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 = wx.Size(2, LD_LINE_SIZE * len(self.Connectors))

    92

        self.RefreshBoundingBox()

    93

    94

    # Returns the block minimum size

    95

    def GetMinSize(self):

    96

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

    97

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

    98

        else:

    99

            return 2, LD_LINE_SIZE * len(self.Connectors)

   100

   101

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

   102

    def AddConnector(self, connector = True):

   103

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

   104

   105

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

   106

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

   107

        if connector:

   108

            if self.Type == LEFTRAIL:

   109

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

   110

            elif self.Type == RIGHTRAIL:

   111

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

   112

            self.Connectors.insert(idx, connector)

   113

        else:

   114

            self.Connectors.insert(idx, None)

   115

        self.RefreshSize()

   116

        self.RefreshConnectors()

   117

   118

    # Moves the divergence connector given

   119

    def MoveConnector(self, connector, movey):

   120

        position = connector.GetRelPosition()

   121

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

   122

        miny = self.Size[1]

   123

        maxy = 0

   124

        for connect in self.Connectors:

   125

            connect_pos = connect.GetRelPosition()

   126

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

   127

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

   128

        min_pos = self.Pos.y + miny

   129

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

   130

        if min_pos == self.Pos.y:

   131

            for connect in self.Connectors:

   132

                connect_pos = connect.GetRelPosition()

   133

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

   134

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

   135

        maxy = 0

   136

        for connect in self.Connectors:

   137

            connect_pos = connect.GetRelPosition()

   138

            maxy = max(maxy, connect_pos.y)

   139

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

   140

        connector.MoveConnected()

   141

        self.RefreshBoundingBox()

   142

   143

    # Returns the index in connectors list for the connector given

   144

    def GetConnectorIndex(self, connector):

   145

        if connector in self.Connectors:

   146

            return self.Connectors.index(connector)

   147

        return None

   148

   149

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

   150

    def IsNullConnector(self, idx):

   151

        if idx < len(self.Connectors):

   152

            return self.Connectors[idx] == None

   153

        return False

   154

   155

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

   156

    def DeleteConnector(self, idx):

   157

        self.Connectors.pop(idx)

   158

        self.RefreshConnectors()

   159

        self.RefreshSize()

   160

   161

    # Refresh the positions of the power rail connectors

   162

    def RefreshConnectors(self):

   163

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

   164

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

   165

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

   166

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

   167

                position = connector.GetRelPosition()

   168

                if self.Type == LEFTRAIL:

   169

                    if self.RealConnectors:

   170

                        connector.SetPosition(wx.Point(self.Size[0], self.Extensions[0] + int(round(self.RealConnectors[i] * height))))

   171

                    else:

   172

                        connector.SetPosition(wx.Point(self.Size[0], self.Extensions[0] + int(round(i * interval))))

   173

                elif self.Type == RIGHTRAIL:

   174

                    if self.RealConnectors:

   175

                        connector.SetPosition(wx.Point(0, self.Extensions[0] + int(round(self.RealConnectors[i] * height))))

   176

                    else:

   177

                        connector.SetPosition(wx.Point(0, self.Extensions[0] + int(round(i * interval))))

   178

        else:

   179

            position = self.Extensions[0]

   180

            for connector in self.Connectors:

   181

                if connector:

   182

                    if self.Type == LEFTRAIL:

   183

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

   184

                    elif self.Type == RIGHTRAIL:

   185

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

   186

                position += LD_LINE_SIZE

   187

        self.RefreshConnected()

   188

   189

    # Refresh the position of wires connected to power rail

   190

    def RefreshConnected(self, exclude = []):

   191

        for connector in self.Connectors:

   192

            if connector:

   193

                connector.MoveConnected(exclude)

   194

   195

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

   196

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

   197

        # if a name is given

   198

        if name:

   199

            # Test each connector if it exists

   200

            for connector in self.Connectors:

   201

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

   202

                    return connector

   203

        for connector in self.Connectors:

   204

            if connector:

   205

                connector_pos = connector.GetRelPosition()

   206

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

   207

                    return connector

   208

        return None

   209

   210

    # Returns all the power rail connectors 

   211

    def GetConnectors(self):

   212

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

   213

   214

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

   215

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

   216

        for connector in self.Connectors:

   217

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

   218

                return connector

   219

        return None

   220

   221

    # Returns the power rail type

   222

    def SetType(self, type, connectors):

   223

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

   224

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

   225

            # the connectors list

   226

            self.Type = type

   227

            self.Clean()

   228

            self.Connectors = []

   229

            for connector in connectors:

   230

                self.AddConnector(connector)

   231

            self.RefreshSize()

   232

   233

    # Returns the power rail type

   234

    def GetType(self):

   235

        return self.Type

   236

   237

    # Method called when a LeftDown event have been generated

   238

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

   239

        pos = GetScaledEventPosition(event, dc, scaling)

   240

        # Test if a connector have been handled

   241

        connector = self.TestConnector(pos, False)

   242

        if connector:

   243

            self.Handle = (HANDLE_CONNECTOR, connector)

   244

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

   245

            self.Selected = False

   246

            # Initializes the last position

   247

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

   248

        else:

   249

            self.RealConnectors = []

   250

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

   251

            for connector in self.Connectors:

   252

                position = connector.GetRelPosition()

   253

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

   254

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

   255

   256

    # Method called when a LeftUp event have been generated

   257

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

   258

        handle_type, handle = self.Handle

   259

        if handle_type == HANDLE_CONNECTOR:

   260

            wires = handle.GetWires()

   261

            if len(wires) == 1:

   262

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

   263

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

   264

                else:

   265

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

   266

                block.RefreshModel(False)

   267

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

   268

        self.RealConnectors = None

   269

   270

    # Method called when a LeftDClick event have been generated

   271

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

   272

        # Edit the powerrail properties

   273

        self.Parent.EditPowerRailContent(self)

   274

   275

    # Method called when a RightUp event have been generated

   276

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

   277

        pos = GetScaledEventPosition(event, dc, scaling)

   278

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

   279

        connector = self.TestConnector(pos, False)

   280

        if connector:

   281

            self.Handle = (HANDLE_CONNECTOR, connector)

   282

        #    self.Parent.PopupDivergenceMenu(True)

   283

        #else:

   284

            # Popup the divergence menu without delete branch

   285

        #    self.Parent.PopupDivergenceMenu(False)

   286

   287

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

   288

    def ProcessDragging(self, movex, movey):

   289

        handle_type, handle = self.Handle

   290

        # A connector has been handled

   291

        if handle_type == HANDLE_CONNECTOR:

   292

            self.MoveConnector(handle, movey)

   293

            return False, True

   294

        else:

   295

            return Graphic_Element.ProcessDragging(self, movex, movey)

   296

   297

    # Refreshes the power rail model

   298

    def RefreshModel(self, move=True):

   299

        self.Parent.RefreshPowerRailModel(self)

   300

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

   301

        # of wires connected to connectors

   302

        if move and self.Type == LEFTRAIL:

   303

            for connector in self.Connectors:

   304

                if connector:

   305

                    connector.RefreshWires()

   306

   307

    # Draws power rail

   308

    def Draw(self, dc):

   309

        dc.SetPen(wx.BLACK_PEN)

   310

        dc.SetBrush(wx.BLACK_BRUSH)

   311

        # Draw a rectangle with the power rail size

   312

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

   313

        # Draw connectors

   314

        for connector in self.Connectors:

   315

            if connector:

   316

                connector.Draw(dc)

   317

        Graphic_Element.Draw(self, dc)

   318

   319

   320

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

   321

#                         Ladder Diagram Contact

   322

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

   323

   324

"""

   325

Class that implements the graphic representation of a contact

   326

"""

   327

   328

class LD_Contact(Graphic_Element):

   329

   330

    # Create a new contact

   331

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

   332

        Graphic_Element.__init__(self, parent)

   333

        self.Type = type

   334

        self.Name = name

   335

        self.Id = id

   336

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

   337

        # Create an input and output connector

   338

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

   339

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

   340

        self.RefreshNameSize()

   341

        self.RefreshTypeSize()

   342

   343

    # Destructor

   344

    def __del__(self):

   345

        self.Input = None

   346

        self.Output = None

   347

   348

    # Forbids to change the contact size

   349

    def SetSize(self, width, height):

   350

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

   351

            Graphic_Element.SetSize(self, width, height)

   352

            self.RefreshConnectors()

   353

   354

    # Delete this contact by calling the appropriate method

   355

    def Delete(self):

   356

        self.Parent.DeleteContact(self)

   357

   358

    # Unconnect input and output

   359

    def Clean(self):

   360

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

   361

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

   362

   363

    # Refresh the size of text for name

   364

    def RefreshNameSize(self):

   365

        dc = wx.ClientDC(self.Parent)

   366

        if self.Name != "":

   367

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

   368

        else:

   369

            self.NameSize = 0, 0

   370

   371

    # Refresh the size of text for type

   372

    def RefreshTypeSize(self):

   373

        dc = wx.ClientDC(self.Parent)

   374

        typetext = ""

   375

        if self.Type == CONTACT_REVERSE:

   376

            typetext = "/"

   377

        elif self.Type == CONTACT_RISING:

   378

            typetext = "P"

   379

        elif self.Type == CONTACT_FALLING:

   380

            typetext = "N"

   381

        if typetext != "":

   382

            self.TypeSize = dc.GetTextExtent(typetext)

   383

        else:

   384

            self.TypeSize = 0, 0

   385

   386

    # Refresh the contact bounding box

   387

    def RefreshBoundingBox(self):

   388

        dc = wx.ClientDC(self.Parent)

   389

        # Calculate the size of the name outside the contact

   390

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

   391

        # Calculate the bounding box size

   392

        if self.Name != "":

   393

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

   394

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

   395

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

   396

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

   397

        else:

   398

            bbx_x = self.Pos.x

   399

            bbx_width = self.Size[0]

   400

            bbx_y = self.Pos.y

   401

            bbx_height = self.Size[1]

   402

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

   403

   404

    # Returns the block minimum size

   405

    def GetMinSize(self):

   406

        return LD_ELEMENT_SIZE

   407

   408

    # Refresh the position of wire connected to contact

   409

    def RefreshConnected(self, exclude = []):

   410

        self.Input.MoveConnected(exclude)

   411

        self.Output.MoveConnected(exclude)

   412

   413

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

   414

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

   415

        # if a name is given

   416

        if name:

   417

            # Test input and output connector

   418

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

   419

                return self.Input

   420

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

   421

                return self.Output

   422

        # Test input connector

   423

        input_pos = self.Input.GetRelPosition()

   424

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

   425

            return self.Input

   426

        # Test output connector

   427

        output_pos = self.Output.GetRelPosition()

   428

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

   429

            return self.Output

   430

        return None

   431

   432

    # Returns input and output contact connectors 

   433

    def GetConnectors(self):

   434

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

   435

   436

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

   437

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

   438

        # Test input connector

   439

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

   440

            return self.Input

   441

        # Test output connector

   442

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

   443

            return self.Output

   444

        return None

   445

   446

    # Refresh the positions of the block connectors

   447

    def RefreshConnectors(self):

   448

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

   449

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

   450

        self.RefreshConnected()

   451

   452

    # Changes the contact name

   453

    def SetName(self, name):

   454

        self.Name = name

   455

        self.RefreshNameSize()

   456

   457

    # Returns the contact name

   458

    def GetName(self):

   459

        return self.Name

   460

   461

    # Changes the contact type

   462

    def SetType(self, type):

   463

        self.Type = type

   464

        self.RefreshTypeSize()

   465

   466

    # Returns the contact type

   467

    def GetType(self):

   468

        return self.Type

   469

   470

    # Method called when a LeftDClick event have been generated

   471

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

   472

        # Edit the contact properties

   473

        self.Parent.EditContactContent(self)

   474

   475

    # Refreshes the contact model

   476

    def RefreshModel(self, move=True):

   477

        self.Parent.RefreshContactModel(self)

   478

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

   479

        if move:

   480

            self.Output.RefreshWires()

   481

   482

    # Draws contact

   483

    def Draw(self, dc):

   484

        dc.SetPen(wx.BLACK_PEN)

   485

        dc.SetBrush(wx.BLACK_BRUSH)

   486

        # Draw two rectangles for representing the contact

   487

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

   488

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

   489

        # Draw contact name

   490

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

   491

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

   492

        # Draw the modifier symbol in the middle of contact

   493

        typetext = ""

   494

        if self.Type == CONTACT_REVERSE:

   495

            typetext = "/"

   496

        elif self.Type == CONTACT_RISING:

   497

            typetext = "P"

   498

        elif self.Type == CONTACT_FALLING:

   499

            typetext = "N"

   500

        if typetext != "":

   501

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

   502

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

   503

        # Draw input and output connectors

   504

        self.Input.Draw(dc)

   505

        self.Output.Draw(dc)

   506

        Graphic_Element.Draw(self, dc)