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 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 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

from types import *

    28

    29

from plcopen.structures import *

    30

from graphics.GraphicCommons import *

    31

from graphics.FBD_Objects import *

    32

from Viewer import *

    33

    34

def ExtractNextBlocks(block, block_list):

    35

    current_list = [block]

    36

    while len(current_list) > 0:

    37

        next_list = []

    38

        for current in current_list:

    39

            connectors = current.GetConnectors()

    40

            input_connectors = []

    41

            if isinstance(current, LD_PowerRail) and current.GetType() == RIGHTRAIL:

    42

                input_connectors = connectors

    43

            else:

    44

                if "inputs" in connectors:

    45

                    input_connectors = connectors["inputs"]

    46

                if "input" in connectors:

    47

                    input_connectors = [connectors["input"]]

    48

            for connector in input_connectors:

    49

                for wire, handle in connector.GetWires():

    50

                    next = wire.EndConnected.GetParentBlock()

    51

                    if not isinstance(next, LD_PowerRail) and next not in block_list:

    52

                        block_list.append(next)

    53

                        next_list.append(next)

    54

        current_list = next_list

    55

    56

def CalcBranchSize(elements, stop):

    57

    branch_size = 0

    58

    stop_list = [stop]

    59

    ExtractNextBlocks(stop, stop_list)

    60

    element_tree = {}

    61

    for element in elements:

    62

        if element not in element_tree:

    63

            element_tree[element] = {"parents":["start"], "children":[], "weight":None}

    64

            GenerateTree(element, element_tree, stop_list)

    65

        elif element_tree[element]:

    66

            element_tree[element]["parents"].append("start")

    67

    for element, values in element_tree.items():

    68

        if values and values["children"] == ["stop"]:

    69

            CalcWeight(element, element_tree)

    70

            if values["weight"]:

    71

                branch_size += values["weight"]

    72

            else:

    73

                return 1

    74

    return branch_size

    75

    76

def RemoveElement(remove, element_tree):

    77

    if remove in element_tree and element_tree[remove]:

    78

        for child in element_tree[remove]["children"]:

    79

            if child != "stop":

    80

                RemoveElement(child, element_tree)

    81

        element_tree[remove] = None

    82

    83

def GenerateTree(element, element_tree, stop_list):

    84

    if element in element_tree:

    85

        connectors = element.GetConnectors()

    86

        input_connectors = []

    87

        if isinstance(element, LD_PowerRail) and element.GetType() == RIGHTRAIL:

    88

            input_connectors = connectors

    89

        else:

    90

            if "inputs" in connectors:

    91

                input_connectors = connectors["inputs"]

    92

            if "input" in connectors:

    93

                input_connectors = [connectors["input"]]

    94

        for connector in input_connectors:

    95

            for wire, handle in connector.GetWires():

    96

                next = wire.EndConnected.GetParentBlock()

    97

                if isinstance(next, LD_PowerRail) and next.GetType() == LEFTRAIL or next in stop_list:

    98

                    for remove in element_tree[element]["children"]:

    99

                        RemoveElement(remove, element_tree)

   100

                    element_tree[element]["children"] = ["stop"]

   101

                elif element_tree[element]["children"] == ["stop"]:

   102

                    element_tree[next] = None

   103

                elif next not in element_tree or element_tree[next]:

   104

                    element_tree[element]["children"].append(next)

   105

                    if next in element_tree:

   106

                        element_tree[next]["parents"].append(element)

   107

                    else:

   108

                        element_tree[next] = {"parents":[element], "children":[], "weight":None}

   109

                        GenerateTree(next, element_tree, stop_list)

   110

   111

def CalcWeight(element, element_tree):

   112

    weight = 0

   113

    parts = None

   114

    if element in element_tree:

   115

        for parent in element_tree[element]["parents"]:

   116

            if parent == "start":

   117

                weight += 1

   118

            elif parent in element_tree:

   119

                if not parts:

   120

                    parts = len(element_tree[parent]["children"])

   121

                else:

   122

                    parts = min(parts, len(element_tree[parent]["children"]))

   123

                if not element_tree[parent]["weight"]:

   124

                    CalcWeight(parent, element_tree)

   125

                if element_tree[parent]["weight"]:

   126

                    weight += element_tree[parent]["weight"]

   127

                else:

   128

                    element_tree[element]["weight"] = None

   129

                    return

   130

            else:

   131

                element_tree[element]["weight"] = None

   132

                return

   133

        if not parts:

   134

            parts = 1

   135

        element_tree[element]["weight"] = max(1, weight / parts)

   136

   137

   138

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

   139

#                     Ladder Diagram Graphic elements Viewer class

   140

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

   141

   142

"""

   143

Class derived from Viewer class that implements a Viewer of Ladder Diagram

   144

"""

   145

   146

class LD_Viewer(Viewer):

   147

   148

    def __init__(self, parent, window, controler):

   149

        Viewer.__init__(self, parent, window, controler)

   150

        self.Rungs = []

   151

        self.Comments = []

   152

   153

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

   154

#                          Refresh functions

   155

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

   156

   157

    def RefreshView(self):

   158

        Viewer.RefreshView(self)

   159

        for i, rung in enumerate(self.Rungs):

   160

            bbox = rung.GetBoundingBox()

   161

            if i < len(self.Comments):

   162

                pos = self.Comments[i].GetPosition()

   163

                if pos[1] > bbox.y:

   164

                    self.Comment.insert(i, None)

   165

            else:

   166

                self.Comment.insert(i, None)

   167

   168

    def loadInstance(self, instance, ids):

   169

        Viewer.loadInstance(self, instance, ids)

   170

        if instance["type"] == "leftPowerRail":

   171

            element = self.FindElementById(instance["id"])

   172

            rung = Graphic_Group(self)

   173

            rung.SelectElement(element)

   174

            self.Rungs.append(rung)

   175

        elif instance["type"] == "rightPowerRail":

   176

            rungs = []

   177

            for connector in instance["connectors"]:

   178

                for link in connector["links"]:

   179

                    connected = self.FindElementById(link["refLocalId"])

   180

                    rung = self.FindRung(connected)

   181

                    if rung not in rungs:

   182

                        rungs.append(rung)

   183

            if len(rungs) > 1:

   184

                raise "ValueError", "Ladder element with id %d is on more than one rung."%instance["id"]

   185

            element = self.FindElementById(instance["id"])

   186

            self.Rungs[rungs[0]].SelectElement(element)

   187

            for connector in element.GetConnectors():

   188

                for wire, num in connector.GetWires():

   189

                    self.Rungs[rungs[0]].SelectElement(wire)

   190

            self.RefreshPosition(element)

   191

        elif instance["type"] in ["contact", "coil"]:

   192

            rungs = []

   193

            for link in instance["connectors"]["input"]["links"]:

   194

                connected = self.FindElementById(link["refLocalId"])

   195

                rung = self.FindRung(connected)

   196

                if rung not in rungs:

   197

                    rungs.append(rung)

   198

            if len(rungs) > 1:

   199

                raise "ValueError", "Ladder element with id %d is on more than one rung."%instance["id"]

   200

            element = self.FindElementById(instance["id"])

   201

            self.Rungs[rungs[0]].SelectElement(element)

   202

            for wire, num in element.GetConnectors()["input"].GetWires():

   203

                self.Rungs[rungs[0]].SelectElement(wire)

   204

            self.RefreshPosition(element)

   205

        elif instance["type"] == "comment":

   206

            element = self.FindElementById(instance["id"])

   207

            pos = element.GetPosition()

   208

            i = 0

   209

            inserted = False

   210

            while i < len(self.Comments) and not inserted: 

   211

                ipos = self.Comments[i].GetPosition()

   212

                if pos[1] < ipos[1]:

   213

                    self.Comments.insert(i, element)

   214

                    inserted = True

   215

                i += 1

   216

            if not inserted:

   217

                self.Comments.append(element)

   218

   219

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

   220

#                          Search Element functions

   221

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

   222

   223

    def FindRung(self, element):

   224

        for i, rung in enumerate(self.Rungs):

   225

            if rung.IsElementIn(element):

   226

                return i

   227

        return None

   228

   229

    def FindElement(self, pos):

   230

        elements = []

   231

        for element in self.Elements:

   232

            if element.HitTest(pos) or element.TestHandle(pos) != (0, 0):

   233

                elements.append(element)

   234

        if len(elements) == 1:

   235

            return elements[0]

   236

        elif len(elements) > 1:

   237

            group = Graphic_Group(self)

   238

            for element in elements:

   239

                if element in self.Blocks:

   240

                    return element

   241

                group.SelectElement(element)

   242

            return group

   243

        return None

   244

   245

    def SearchElements(self, bbox):

   246

        elements = []

   247

        for element in self.Blocks:

   248

            element_bbox = element.GetBoundingBox()

   249

            if element_bbox.x >= bbox.x and element_bbox.y >= bbox.y and element_bbox.x + element_bbox.width <= bbox.x + bbox.width and element_bbox.y + element_bbox.height <= bbox.y + bbox.height:

   250

                elements.append(element)

   251

        return elements

   252

   253

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

   254

#                          Mouse event functions

   255

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

   256

   257

    def OnViewerLeftDown(self, event):

   258

        if self.Mode == MODE_SELECTION:

   259

            pos = event.GetPosition()

   260

            element = self.FindElement(pos)

   261

            if self.SelectedElement:

   262

                if self.SelectedElement in self.Elements:

   263

                    if self.SelectedElement != element:

   264

                        if self.SelectedElement in self.Wires:

   265

                            self.SelectedElement.SetSelectedSegment(None)

   266

                        else:

   267

                            self.SelectedElement.SetSelected(False)

   268

                    else:

   269

                        self.SelectedElement = None

   270

                elif element and element not in self.Elements:

   271

                    if self.SelectedElement.GetElements() != element.GetElements():

   272

                        for elt in self.SelectedElement.GetElements():

   273

                            if elt in self.Wires:

   274

                                elt.SetSelectedSegment(None)

   275

                        self.SelectedElement.SetSelected(False)

   276

                        self.SelectedElement = None

   277

                else:

   278

                    for elt in self.SelectedElement.GetElements():

   279

                        if elt in self.Wires:

   280

                            elt.SetSelectedSegment(None)

   281

                    self.SelectedElement.SetSelected(False)

   282

                    self.SelectedElement = None

   283

                self.Refresh()

   284

            if element:

   285

                self.SelectedElement = element

   286

                self.SelectedElement.OnLeftDown(event, self.Scaling)

   287

                self.Refresh()

   288

            else:

   289

                self.rubberBand.Reset()

   290

                self.rubberBand.OnLeftDown(event, self.Scaling)

   291

        event.Skip()

   292

   293

    def OnViewerLeftUp(self, event):

   294

        if self.rubberBand.IsShown():

   295

            if self.Mode == MODE_SELECTION:

   296

                elements = self.SearchElements(self.rubberBand.GetCurrentExtent())

   297

                self.rubberBand.OnLeftUp(event, self.Scaling)

   298

                if len(elements) > 0:

   299

                    self.SelectedElement = Graphic_Group(self)

   300

                    self.SelectedElement.SetElements(elements)

   301

                    self.SelectedElement.SetSelected(True)

   302

                    self.Refresh()

   303

        elif self.Mode == MODE_SELECTION and self.SelectedElement:

   304

            if self.SelectedElement in self.Elements:

   305

                if self.SelectedElement in self.Wires:

   306

                    result = self.SelectedElement.TestSegment(event.GetPosition(), True)

   307

                    if result and result[1] in [EAST, WEST]:

   308

                        self.SelectedElement.SetSelectedSegment(result[0])

   309

                else:

   310

                    self.SelectedElement.OnLeftUp(event, self.Scaling)

   311

            else:

   312

                for element in self.SelectedElement.GetElements():

   313

                    if element in self.Wires:

   314

                        result = element.TestSegment(event.GetPosition(), True)

   315

                        if result and result[1] in [EAST, WEST]:

   316

                            element.SetSelectedSegment(result[0])

   317

                    else:

   318

                        element.OnLeftUp(event, self.Scaling)

   319

            wxCallAfter(self.SetCursor, wxNullCursor)

   320

            self.ReleaseMouse()

   321

            self.Refresh()

   322

        event.Skip()

   323

   324

    def OnViewerRightUp(self, event):

   325

        pos = event.GetPosition()

   326

        element = self.FindElement(pos)

   327

        if element:

   328

            if self.SelectedElement and self.SelectedElement != element:

   329

                self.SelectedElement.SetSelected(False)

   330

            self.SelectedElement = element

   331

            if self.SelectedElement in self.Wires:

   332

                self.SelectedElement.SetSelectedSegment(0)

   333

            else:

   334

                self.SelectedElement.SetSelected(True)

   335

                self.SelectedElement.OnRightUp(event, self.Scaling)

   336

            wxCallAfter(self.SetCursor, wxNullCursor)

   337

            self.ReleaseMouse()

   338

            self.Refresh()

   339

        event.Skip()

   340

   341

    def OnViewerLeftDClick(self, event):

   342

        if self.Mode == MODE_SELECTION and self.SelectedElement:

   343

            self.SelectedElement.OnLeftDClick(event, self.Scaling)

   344

            self.Refresh()

   345

        event.Skip()

   346

   347

    def OnViewerMotion(self, event):

   348

        if self.rubberBand.IsShown():

   349

            self.rubberBand.OnMotion(event, self.Scaling)

   350

        event.Skip()

   351

   352

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

   353

#                          Keyboard event functions

   354

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

   355

   356

    def OnChar(self, event):

   357

        keycode = event.GetKeyCode()

   358

        if keycode == WXK_DELETE and self.SelectedElement:

   359

            if self.SelectedElement in self.Blocks:

   360

                self.SelectedElement.Delete()

   361

            elif self.SelectedElement in self.Wires:

   362

                self.DeleteWire(self.SelectedElement)

   363

            elif self.SelectedElement not in self.Elements:

   364

                all_wires = True

   365

                for element in self.SelectedElement.GetElements():

   366

                    all_wires &= element in self.Wires

   367

                if all_wires:

   368

                    self.DeleteWire(self.SelectedElement)

   369

                else:

   370

                    self.SelectedElement.Delete()

   371

        self.Refresh()

   372

        event.Skip()

   373

   374

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

   375

#                          Adding element functions

   376

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

   377

   378

    def AddRung(self):

   379

        dialog = LDElementDialog(self.Parent, "coil")

   380

        varlist = []

   381

        vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   382

        if vars:

   383

            for var in vars:

   384

                if var["Class"] != "Input" and var["Type"] == "BOOL":

   385

                    varlist.append(var["Name"])

   386

        returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()

   387

        if returntype == "BOOL":

   388

            varlist.append(self.Controler.GetCurrentElementEditingName())

   389

        dialog.SetVariables(varlist)

   390

        dialog.SetValues({"name":"","type":COIL_NORMAL})

   391

        if dialog.ShowModal() == wxID_OK:

   392

            values = dialog.GetValues()

   393

            startx, starty = LD_OFFSET[0], 0

   394

            if len(self.Rungs) > 0:

   395

                bbox = self.Rungs[-1].GetBoundingBox()

   396

                starty = bbox.y + bbox.height

   397

            starty += LD_OFFSET[1]

   398

            rung = Graphic_Group(self)

   399

            # Create comment

   400

            id = self.GetNewId()

   401

            comment = Comment(self, "Commentaire", id)

   402

            comment.SetPosition(startx, starty)

   403

            comment.SetSize(LD_COMMENT_DEFAULTSIZE[0], LD_COMMENT_DEFAULTSIZE[1])

   404

            self.Elements.append(comment)

   405

            self.Comments.append(comment)

   406

            self.Controler.AddCurrentElementEditingComment(id)

   407

            self.RefreshCommentModel(comment)

   408

            starty += LD_COMMENT_DEFAULTSIZE[1] + LD_OFFSET[1]

   409

            # Create LeftPowerRail

   410

            id = self.GetNewId()

   411

            leftpowerrail = LD_PowerRail(self, LEFTRAIL, id)

   412

            leftpowerrail.SetPosition(startx, starty)

   413

            self.Elements.append(leftpowerrail)

   414

            self.Blocks.append(leftpowerrail)

   415

            rung.SelectElement(leftpowerrail)

   416

            self.Controler.AddCurrentElementEditingPowerRail(id, LEFTRAIL)

   417

            self.RefreshPowerRailModel(leftpowerrail)

   418

            # Create Coil

   419

            id = self.GetNewId()

   420

            coil = LD_Coil(self, values["type"], values["name"], id)

   421

            coil.SetPosition(startx, starty + (LD_LINE_SIZE - LD_ELEMENT_SIZE[1]) / 2)

   422

            self.Elements.append(coil)

   423

            self.Blocks.append(coil)

   424

            rung.SelectElement(coil)

   425

            self.Controler.AddCurrentElementEditingCoil(id)

   426

            # Create Wire between LeftPowerRail and Coil

   427

            wire = Wire(self)

   428

            start_connector = coil.GetConnectors()["input"]

   429

            end_connector = leftpowerrail.GetConnectors()[0]

   430

            start_connector.Connect((wire, 0), False)

   431

            end_connector.Connect((wire, -1), False)

   432

            wire.ConnectStartPoint(None, start_connector)

   433

            wire.ConnectEndPoint(None, end_connector)

   434

            self.Wires.append(wire)

   435

            self.Elements.append(wire)

   436

            rung.SelectElement(wire)

   437

            # Create RightPowerRail

   438

            id = self.GetNewId()

   439

            rightpowerrail = LD_PowerRail(self, RIGHTRAIL, id)

   440

            rightpowerrail.SetPosition(startx, starty)

   441

            self.Elements.append(rightpowerrail)

   442

            self.Blocks.append(rightpowerrail)

   443

            rung.SelectElement(rightpowerrail)

   444

            self.Controler.AddCurrentElementEditingPowerRail(id, RIGHTRAIL)

   445

            # Create Wire between LeftPowerRail and Coil

   446

            wire = Wire(self)

   447

            start_connector = rightpowerrail.GetConnectors()[0]

   448

            end_connector = coil.GetConnectors()["output"]

   449

            start_connector.Connect((wire, 0), False)

   450

            end_connector.Connect((wire, -1), False)

   451

            wire.ConnectStartPoint(None, start_connector)

   452

            wire.ConnectEndPoint(None, end_connector)

   453

            self.Wires.append(wire)

   454

            self.Elements.append(wire)

   455

            rung.SelectElement(wire)

   456

            self.RefreshPosition(coil)

   457

            self.Rungs.append(rung)

   458

            self.Refresh()

   459

   460

    def AddContact(self):

   461

        wires = []

   462

        if self.SelectedElement in self.Wires:

   463

            left_element = self.SelectedElement.EndConnected

   464

            if not isinstance(left_element.GetParentBlock(), LD_Coil):

   465

                wires.append(self.SelectedElement)

   466

        elif self.SelectedElement and self.SelectedElement not in self.Elements:

   467

            if False not in [element in self.Wires for element in self.SelectedElement.GetElements()]:

   468

                for element in self.SelectedElement.GetElements():

   469

                    wires.append(element)

   470

        if len(wires) > 0:

   471

            dialog = LDElementDialog(self.Parent, "contact")

   472

            varlist = []

   473

            vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   474

            if vars:

   475

                for var in vars:

   476

                    if var["Class"] != "Output" and var["Type"] == "BOOL":

   477

                        varlist.append(var["Name"])

   478

            dialog.SetVariables(varlist)

   479

            dialog.SetValues({"name":"","type":CONTACT_NORMAL})

   480

            if dialog.ShowModal() == wxID_OK:

   481

                values = dialog.GetValues()

   482

                points = wires[0].GetSelectedSegmentPoints()

   483

                id = self.GetNewId()

   484

                contact = LD_Contact(self, values["type"], values["name"], id)

   485

                contact.SetPosition(0, points[0].y - (LD_ELEMENT_SIZE[1] + 1) / 2)

   486

                self.Elements.append(contact)

   487

                self.Blocks.append(contact)

   488

                self.Controler.AddCurrentElementEditingContact(id)

   489

                rungindex = self.FindRung(wires[0])

   490

                rung = self.Rungs[rungindex]

   491

                old_bbox = rung.GetBoundingBox()

   492

                rung.SelectElement(contact)

   493

                connectors = contact.GetConnectors()

   494

                left_elements = []

   495

                right_elements = []

   496

                left_index = []

   497

                right_index = []

   498

                for wire in wires:

   499

                    if wire.EndConnected not in left_elements:

   500

                        left_elements.append(wire.EndConnected)

   501

                        left_index.append(wire.EndConnected.GetWireIndex(wire))

   502

                    else:

   503

                        idx = left_elements.index(wire.EndConnected)

   504

                        left_index[idx] = min(left_index[idx], wire.EndConnected.GetWireIndex(wire))

   505

                    if wire.StartConnected not in right_elements:

   506

                        right_elements.append(wire.StartConnected)

   507

                        right_index.append(wire.StartConnected.GetWireIndex(wire))

   508

                    else:

   509

                        idx = right_elements.index(wire.StartConnected)

   510

                        right_index[idx] = min(right_index[idx], wire.StartConnected.GetWireIndex(wire))

   511

                    wire.SetSelectedSegment(None)

   512

                    wire.Clean()

   513

                    rung.SelectElement(wire)

   514

                    self.Wires.remove(wire)

   515

                    self.Elements.remove(wire)

   516

                wires = []

   517

                right_wires = []

   518

                for i, left_element in enumerate(left_elements):

   519

                    wire = Wire(self)

   520

                    wires.append(wire)

   521

                    connectors["input"].Connect((wire, 0), False)

   522

                    left_element.InsertConnect(left_index[i], (wire, -1), False)

   523

                    wire.ConnectStartPoint(None, connectors["input"])

   524

                    wire.ConnectEndPoint(None, left_element)

   525

                for i, right_element in enumerate(right_elements):

   526

                    wire = Wire(self)

   527

                    wires.append(wire)

   528

                    right_wires.append(wire)

   529

                    right_element.InsertConnect(right_index[i], (wire, 0), False)