1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     6

#

     8

#

    10

#

    15

#

    20

#

    24

    25

import wx

    26

    27

from graphics.GraphicCommons import *

    28

from graphics.DebugDataConsumer import DebugDataConsumer

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

    43

        Graphic_Element.__init__(self, parent)

    44

        self.Type = None

    45

        self.Connectors = []

    46

        self.RealConnectors = None

    47

        self.Id = id

    48

        self.Extensions = [LD_LINE_SIZE / 2, LD_LINE_SIZE / 2]

    49

        self.SetType(type, connectors)

    50

    51

    def Flush(self):

    52

        for connector in self.Connectors:

    53

            connector.Flush()

    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

        else:

    63

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

    64

        powerrail.Connectors = []

    65

        for connector in self.Connectors:

    66

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

    67

        return powerrail

    68

    69

    def GetConnectorTranslation(self, element):

    70

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

    71

                        [connector for connector in element.Connectors]))

    72

    73

    # Returns the RedrawRect

    74

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

    75

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

    76

        for connector in self.Connectors:

    77

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

    78

        if movex != 0 or movey != 0:

    79

            for connector in self.Connectors:

    80

                if connector.IsConnected():

    81

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

    82

        return rect

    83

    84

    # Forbids to change the power rail size

    85

    def SetSize(self, width, height):

    86

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

    87

            Graphic_Element.SetSize(self, width, height)

    88

        else:

    89

            Graphic_Element.SetSize(self, LD_POWERRAIL_WIDTH, height)

    90

        self.RefreshConnectors()

    91

    92

    # Forbids to select a power rail

    93

    def HitTest(self, pt, connectors=True):

    94

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

    95

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

    96

        return False

    97

    98

    # Forbids to select a power rail

    99

    def IsInSelection(self, rect):

   100

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

   101

            return Graphic_Element.IsInSelection(self, rect)

   102

        return False

   103

   104

    # Deletes this power rail by calling the appropriate method

   105

    def Delete(self):

   106

        self.Parent.DeletePowerRail(self)

   107

   108

    # Unconnect all connectors

   109

    def Clean(self):

   110

        for connector in self.Connectors:

   111

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

   112

   113

    # Refresh the power rail bounding box

   114

    def RefreshBoundingBox(self):

   115

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

   116

   117

    # Refresh the power rail size

   118

    def RefreshSize(self):

   119

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

   120

        self.RefreshBoundingBox()

   121

   122

    # Returns the block minimum size

   123

    def GetMinSize(self, default=False):

   124

        height = (LD_LINE_SIZE * (len(self.Connectors) - 1)

   125

                  if default else 0)

   126

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

   127

   128

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

   129

    def AddConnector(self):

   130

        self.InsertConnector(len(self.Connectors))

   131

   132

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

   133

    def InsertConnector(self, idx):

   134

        if self.Type == LEFTRAIL:

   135

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

   136

        elif self.Type == RIGHTRAIL:

   137

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

   138

        self.Connectors.insert(idx, connector)

   139

        self.RefreshSize()

   140

        self.RefreshConnectors()

   141

   142

    # Moves the divergence connector given

   143

    def MoveConnector(self, connector, movey):

   144

        position = connector.GetRelPosition()

   145

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

   146

        miny = self.Size[1]

   147

        maxy = 0

   148

        for connect in self.Connectors:

   149

            connect_pos = connect.GetRelPosition()

   150

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

   151

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

   152

        min_pos = self.Pos.y + miny

   153

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

   154

        if min_pos == self.Pos.y:

   155

            for connect in self.Connectors:

   156

                connect_pos = connect.GetRelPosition()

   157

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

   158

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

   159

        maxy = 0

   160

        for connect in self.Connectors:

   161

            connect_pos = connect.GetRelPosition()

   162

            maxy = max(maxy, connect_pos.y)

   163

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

   164

        connector.MoveConnected()

   165

        self.RefreshBoundingBox()

   166

   167

    # Returns the index in connectors list for the connector given

   168

    def GetConnectorIndex(self, connector):

   169

        if connector in self.Connectors:

   170

            return self.Connectors.index(connector)

   171

        return None

   172

   173

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

   174

    def DeleteConnector(self, idx):

   175

        self.Connectors.pop(idx)

   176

        self.RefreshConnectors()

   177

        self.RefreshSize()

   178

   179

    # Refresh the positions of the power rail connectors

   180

    def RefreshConnectors(self):

   181

        scaling = self.Parent.GetScaling()

   182

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

   183

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

   184

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

   185

            if self.RealConnectors:

   186

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

   187

            else:

   188

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

   189

            if scaling is not None:

   190

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

   191

            if self.Type == LEFTRAIL:

   192

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

   193

            elif self.Type == RIGHTRAIL:

   194

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

   195

        self.RefreshConnected()

   196

   197

    # Refresh the position of wires connected to power rail

   198

    def RefreshConnected(self, exclude = []):

   199

        for connector in self.Connectors:

   200

            connector.MoveConnected(exclude)

   201

   202

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

   203

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

   204

        # if a name is given

   205

        if name is not None:

   206

            # Test each connector if it exists

   207

            for connector in self.Connectors:

   208

                if name == connector.GetName():

   209

                    return connector

   210

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

   211

   212

    # Returns all the power rail connectors 

   213

    def GetConnectors(self):

   214

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

   215

        if self.Type == LEFTRAIL:

   216

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

   217

        else:

   218

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

   219

   220

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

   221

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

   222

        for connector in self.Connectors:

   223

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

   224

                return connector

   225

        return None

   226

   227

    # Returns the power rail type

   228

    def SetType(self, type, connectors):

   229

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

   230

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

   231

            # the connectors list

   232

            self.Type = type

   233

            self.Clean()

   234

            self.Connectors = []

   235

            for connector in xrange(connectors):

   236

                self.AddConnector()

   237

            self.RefreshSize()

   238

   239

    # Returns the power rail type

   240

    def GetType(self):

   241

        return self.Type

   242

   243

    # Method called when a LeftDown event have been generated

   244

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

   245

        self.RealConnectors = []

   246

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

   247

        if height > 0:

   248

            for connector in self.Connectors:

   249

                position = connector.GetRelPosition()

   250

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

   251

        elif len(self.Connectors) > 1:

   252

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

   253

        else:

   254

            self.RealConnectors = [0.5]

   255

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

   256

   257

    # Method called when a LeftUp event have been generated

   258

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

   259

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

   260

        self.RealConnectors = None

   261

   262

    # Method called when a LeftDown event have been generated

   263

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

   264

        pos = GetScaledEventPosition(event, dc, scaling)

   265

        # Test if a connector have been handled

   266

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

   267

        if connector:

   268

            self.Handle = (HANDLE_CONNECTOR, connector)

   269

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

   270

            self.Selected = False

   271

            # Initializes the last position

   272

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

   273

        else:

   274

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

   275

   276

    # Method called when a LeftDClick event have been generated

   277

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

   278

        # Edit the powerrail properties

   279

        self.Parent.EditPowerRailContent(self)

   280

   281

    # Method called when a RightUp event have been generated

   282

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

   283

        handle_type, handle = self.Handle

   284

        if handle_type == HANDLE_CONNECTOR and self.Dragging and self.oldPos:

   285

            wires = handle.GetWires()

   286

            if len(wires) == 1:

   287

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

   288

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

   289

                else:

   290

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

   291

                block.RefreshModel(False)

   292

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

   293

        else:

   294

            self.Parent.PopupDefaultMenu()

   295

   296

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

   297

        self.Move(x, y)

   298

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

   299

            self.SetSize(width, height)

   300

        else:

   301

            self.SetSize(LD_POWERRAIL_WIDTH, height)

   302

   303

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

   304

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

   305

        handle_type, handle = self.Handle

   306

        # A connector has been handled

   307

        if handle_type == HANDLE_CONNECTOR:

   308

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

   309

            if scaling is not None:

   310

                position = handle.GetRelPosition()

   311

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

   312

            self.MoveConnector(handle, movey)

   313

            return 0, movey

   314

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

   315

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

   316

        return 0, 0

   317

   318

    # Refreshes the power rail model

   319

    def RefreshModel(self, move=True):

   320

        self.Parent.RefreshPowerRailModel(self)

   321

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

   322

        # of wires connected to connectors

   323

        if move and self.Type == LEFTRAIL:

   324

            for connector in self.Connectors:

   325

                connector.RefreshWires()

   326

   327

    # Draws power rail

   328

    def Draw(self, dc):

   329

        Graphic_Element.Draw(self, dc)

   330

        dc.SetPen(MiterPen(wx.BLACK))

   331

        dc.SetBrush(wx.BLACK_BRUSH)

   332

        # Draw a rectangle with the power rail size

   333

        if self.Type == LEFTRAIL:

   334

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

   335

        else:

   336

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

   337

        # Draw connectors

   338

        for connector in self.Connectors:

   339

            connector.Draw(dc)

   340

   341

   342

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

   343

#                         Ladder Diagram Contact

   344

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

   345

   346

"""

   347

Class that implements the graphic representation of a contact

   348

"""

   349

   350

class LD_Contact(Graphic_Element, DebugDataConsumer):

   351

   352

    # Create a new contact

   353

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

   354

        Graphic_Element.__init__(self, parent)

   355

        DebugDataConsumer.__init__(self)

   356

        self.Type = type

   357

        self.Name = name

   358

        self.Id = id

   359

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

   360

        self.Highlights = {}

   361

        # Create an input and output connector

   362

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

   363

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

   364

        self.PreviousValue = False

   365

        self.PreviousSpreading = False

   366

        self.RefreshNameSize()

   367

        self.RefreshTypeSize()

   368

   369

    def Flush(self):

   370

        if self.Input is not None:

   371

            self.Input.Flush()

   372

            self.Input = None

   373

        if self.Output is not None:

   374

            self.Output.Flush()

   375

            self.Output = None

   376

   377

    def SetForced(self, forced):

   378

        if self.Forced != forced:

   379

            self.Forced = forced

   380

            if self.Visible:

   381

                self.Parent.ElementNeedRefresh(self)

   382

   383

    def SetValue(self, value):

   384

        if self.Type == CONTACT_RISING:

   385

            refresh = self.Value and not self.PreviousValue

   386

        elif self.Type == CONTACT_FALLING:

   387

            refresh = not self.Value and self.PreviousValue

   388

        else:

   389

            refresh = False

   390

        self.PreviousValue = self.Value

   391

        self.Value = value

   392

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

   393

            if self.Visible:

   394

                self.Parent.ElementNeedRefresh(self)

   395

            self.SpreadCurrent()

   396

   397

    def SpreadCurrent(self):

   398

        if self.Parent.Debug:

   399

            if self.Value is None:

   400

                self.Value = False

   401

            spreading = self.Input.ReceivingCurrent()

   402

            if self.Type == CONTACT_NORMAL:

   403

                spreading &= self.Value

   404

            elif self.Type == CONTACT_REVERSE:

   405

                spreading &= not self.Value

   406

            elif self.Type == CONTACT_RISING:

   407

                spreading &= self.Value and not self.PreviousValue

   408

            elif self.Type == CONTACT_FALLING:

   409

                spreading &= not self.Value and self.PreviousValue

   410

            else:

   411

                spreading = False

   412

            if spreading and not self.PreviousSpreading:

   413

                self.Output.SpreadCurrent(True)

   414

            elif not spreading and self.PreviousSpreading:

   415

                self.Output.SpreadCurrent(False)

   416

            self.PreviousSpreading = spreading

   417

   418

    # Make a clone of this LD_Contact

   419

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

   420

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

   421

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

   422

        if pos is not None:

   423

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

   424

        else:

   425

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

   426

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

   427

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

   428

        return contact

   429

   430

    def GetConnectorTranslation(self, element):

   431

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

   432

   433

    # Returns the RedrawRect

   434

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

   435

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

   436

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

   437

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

   438

        if movex != 0 or movey != 0:

   439

            if self.Input.IsConnected():

   440

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

   441

            if self.Output.IsConnected():

   442

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

   443

        return rect

   444

   445

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

   446

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

   447

            movex = movey = 0

   448

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

   449

   450

    # Forbids to change the contact size

   451

    def SetSize(self, width, height):

   452

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

   453

            Graphic_Element.SetSize(self, width, height)

   454

            self.RefreshConnectors()

   455

   456

    # Delete this contact by calling the appropriate method

   457

    def Delete(self):

   458

        self.Parent.DeleteContact(self)

   459

   460

    # Unconnect input and output

   461

    def Clean(self):

   462

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

   463

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

   464

   465

    # Refresh the size of text for name

   466

    def RefreshNameSize(self):

   467

        if self.Name != "":

   468

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

   469

        else:

   470

            self.NameSize = 0, 0

   471

   472

    # Refresh the size of text for type

   473

    def RefreshTypeSize(self):

   474

        typetext = ""

   475

        if self.Type == CONTACT_REVERSE:

   476

            typetext = "/"

   477

        elif self.Type == CONTACT_RISING:

   478

            typetext = "P"

   479

        elif self.Type == CONTACT_FALLING:

   480

            typetext = "N"

   481

        if typetext != "":

   482

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

   483

        else:

   484

            self.TypeSize = 0, 0

   485

   486

    # Refresh the contact bounding box

   487

    def RefreshBoundingBox(self):

   488

        # Calculate the size of the name outside the contact

   489

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

   490

        # Calculate the bounding box size

   491

        if self.Name != "":

   492

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

   493

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

   494

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

   495

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

   496

        else:

   497

            bbx_x = self.Pos.x

   498

            bbx_width = self.Size[0]

   499

            bbx_y = self.Pos.y

   500

            bbx_height = self.Size[1]

   501

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

   502

   503

    # Returns the block minimum size

   504

    def GetMinSize(self):

   505

        return LD_ELEMENT_SIZE

   506

   507

    # Refresh the position of wire connected to contact

   508

    def RefreshConnected(self, exclude = []):

   509

        self.Input.MoveConnected(exclude)

   510

        self.Output.MoveConnected(exclude)

   511

   512

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

   513

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

   514

        # if a name is given

   515

        if name is not None:

   516

            # Test input and output connector

   517

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

   518

            #    return self.Input

   519

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

   520

                return self.Output

   521

        return self.FindNearestConnector(position, [self.Input, self.Output])

   522

   523

    # Returns input and output contact connectors 

   524

    def GetConnectors(self):

   525

        return {"inputs": [self.Input], "outputs": [self.Output]}

   526

   527