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

from Dialogs import *

    34

    35

def ExtractNextBlocks(block, block_list):

    36

    current_list = [block]

    37

    while len(current_list) > 0:

    38

        next_list = []

    39

        for current in current_list:

    40

            connectors = current.GetConnectors()

    41

            input_connectors = []

    42

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

    43

                input_connectors = connectors

    44

            else:

    45

                if "inputs" in connectors:

    46

                    input_connectors = connectors["inputs"]

    47

                if "input" in connectors:

    48

                    input_connectors = [connectors["input"]]

    49

            for connector in input_connectors:

    50

                for wire, handle in connector.GetWires():

    51

                    next = wire.EndConnected.GetParentBlock()

    52

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

    53

                        block_list.append(next)

    54

                        next_list.append(next)

    55

        current_list = next_list

    56

    57

def CalcBranchSize(elements, stops):

    58

    branch_size = 0

    59

    stop_list = stops

    60

    for stop in stops:

    61

        ExtractNextBlocks(stop, stop_list)

    62

    element_tree = {}

    63

    for element in elements:

    64

        if element not in element_tree:

    65

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

    66

            GenerateTree(element, element_tree, stop_list)

    67

        elif element_tree[element]:

    68

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

    69

    remove_stops = {"start":[], "stop":[]}

    70

    for element, values in element_tree.items():

    71

        if "stop" in values["children"]:

    72

            removed = []

    73

            for child in values["children"]:

    74

                if child != "stop":

    75

##                    if child in elements:

    76

##                        RemoveElement(child, element_tree)

    77

##                        removed.append(child)

    78

                    if "start" in element_tree[child]["parents"]:

    79

                        if element not in remove_stops["stop"]:

    80

                            remove_stops["stop"].append(element)

    81

                        if child not in remove_stops["start"]:

    82

                            remove_stops["start"].append(child)

    83

            for child in removed:

    84

                values["children"].remove(child)

    85

    for element in remove_stops["start"]:

    86

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

    87

    for element in remove_stops["stop"]:

    88

        element_tree[element]["children"].remove("stop")

    89

    for element, values in element_tree.items():

    90

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

    91

            CalcWeight(element, element_tree)

    92

            if values["weight"]:

    93

                branch_size += values["weight"]

    94

            else:

    95

                return 1

    96

    #print branch_size

    97

    return branch_size

    98

    99

def RemoveElement(remove, element_tree):

   100

    if remove in element_tree and element_tree[remove]:

   101

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

   102

            if child != "stop":

   103

                RemoveElement(child, element_tree)

   104

        element_tree.pop(remove)

   105

##        element_tree[remove] = None

   106

   107

def GenerateTree(element, element_tree, stop_list):

   108

    if element in element_tree:

   109

        connectors = element.GetConnectors()

   110

        input_connectors = []

   111

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

   112

            input_connectors = connectors

   113

        else:

   114

            if "inputs" in connectors:

   115

                input_connectors = connectors["inputs"]

   116

            if "input" in connectors:

   117

                input_connectors = [connectors["input"]]

   118

        for connector in input_connectors:

   119

            for wire, handle in connector.GetWires():

   120

                next = wire.EndConnected.GetParentBlock()

   121

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

   122

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

   123

##                        RemoveElement(remove, element_tree)

   124

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

   125

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

   126

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

   127

##                    element_tree[next] = None

   128

                elif next not in element_tree or element_tree[next]:

   129

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

   130

                    if next in element_tree:

   131

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

   132

                    else:

   133

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

   134

                        GenerateTree(next, element_tree, stop_list)

   135

   136

def CalcWeight(element, element_tree):

   137

    weight = 0

   138

    parts = None

   139

    if element in element_tree:

   140

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

   141

            if parent == "start":

   142

                weight += 1

   143

            elif parent in element_tree:

   144

                if not parts:

   145

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

   146

                else:

   147

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

   148

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

   149

                    CalcWeight(parent, element_tree)

   150

                if element_tree[parent]["weight"]:

   151

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

   152

                else:

   153

                    element_tree[element]["weight"] = None

   154

                    return

   155

            else:

   156

                element_tree[element]["weight"] = None

   157

                return

   158

        if not parts:

   159

            parts = 1

   160

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

   161

   162

   163

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

   164

#                     Ladder Diagram Graphic elements Viewer class

   165

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

   166

   167

"""

   168

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

   169

"""

   170

   171

class LD_Viewer(Viewer):

   172

   173

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

   174

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

   175

        self.Rungs = []

   177

   178

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

   179

#                          Refresh functions

   180

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

   181

   182

    def RefreshView(self):

   183

        Viewer.RefreshView(self)

   184

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

   185

            bbox = rung.GetBoundingBox()

   188

                if pos[1] > bbox.y:

   190

            else:

   192

   193

    def loadInstance(self, instance, ids):

   194

        Viewer.loadInstance(self, instance, ids)

   195

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

   196

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

   197

            rung = Graphic_Group(self)

   198

            rung.SelectElement(element)

   199

            self.Rungs.append(rung)

   200

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

   201

            rungs = []

   202

            for connector in instance["connectors"]:

   203

                for link in connector["links"]:

   204

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

   205

                    rung = self.FindRung(connected)

   206

                    if rung not in rungs:

   207

                        rungs.append(rung)

   208

            if len(rungs) > 1:

   209

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

   210

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

   211

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

   212

            for connector in element.GetConnectors():

   213

                for wire, num in connector.GetWires():

   214

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

   215

            self.RefreshPosition(element)

   216

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

   217

            rungs = []

   218

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

   219

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

   220

                rung = self.FindRung(connected)

   221

                if rung not in rungs:

   222

                    rungs.append(rung)

   223

            if len(rungs) > 1:

   224

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

   225

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

   226

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

   227

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

   228

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

   229

            self.RefreshPosition(element)

   230

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

   231

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

   232

            pos = element.GetPosition()

   233

            i = 0

   234

            inserted = False

   237

                if pos[1] < ipos[1]:

   239

                    inserted = True

   240

                i += 1

   241

            if not inserted:

   243

   244

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

   245

#                          Search Element functions

   246

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

   247

   248

    def FindRung(self, element):

   249

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

   250

            if rung.IsElementIn(element):

   251

                return i

   252

        return None

   253

   254

    def FindElement(self, pos):

   255

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   256

            return Viewer.FindElement(self, pos)

   257

   258

        elements = []

   260

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

   261

                elements.append(element)

   262

        if len(elements) == 1:

   263

            return elements[0]

   264

        elif len(elements) > 1:

   265

            group = Graphic_Group(self)

   266

            for element in elements:

   268

                    return element

   269

                group.SelectElement(element)

   270

            return group

   271

        return None

   272

   273

    def SearchElements(self, bbox):

   274

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   275

            return Viewer.SearchElements(self, bbox)

   276

   277

        elements = []

   278

        for element in self.Blocks:

   280

                elements.append(element)

   281

        return elements

   282

   283

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

   284

#                          Mouse event functions

   285

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

   286

   287

    def OnViewerLeftDown(self, event):

   288

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   289

            Viewer.OnViewerLeftDown(self, event)

   290

        elif self.Mode == MODE_SELECTION:

   291

            dc = self.GetLogicalDC()

   292

            pos = event.GetLogicalPosition(dc)

   293

            element = self.FindElement(pos)

   294

            if self.SelectedElement:

   296

                    if self.SelectedElement != element:

   298

                            self.SelectedElement.SetSelectedSegment(None)

   299

                        else:

   300

                            self.SelectedElement.SetSelected(False)

   301

                    else:

   302

                        self.SelectedElement = None

   304

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

   305

                        for elt in self.SelectedElement.GetElements():

   307

                                elt.SetSelectedSegment(None)

   308

                        self.SelectedElement.SetSelected(False)

   309

                        self.SelectedElement = None

   310

                else:

   311

                    for elt in self.SelectedElement.GetElements():

   313

                            elt.SetSelectedSegment(None)

   314

                    self.SelectedElement.SetSelected(False)

   315

                    self.SelectedElement = None

   316

                self.Refresh()

   317

            if element:

   318

                self.SelectedElement = element

   319

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

   320

                self.Refresh()

   321

            else:

   322

                self.rubberBand.Reset()

   323

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

   324

        event.Skip()

   325

   326

    def OnViewerLeftUp(self, event):

   327

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   328

            Viewer.OnViewerLeftUp(self, event)

   329

        elif self.rubberBand.IsShown():

   330

            if self.Mode == MODE_SELECTION:

   331

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

   332

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

   333

                if len(elements) > 0:

   334

                    self.SelectedElement = Graphic_Group(self)

   335

                    self.SelectedElement.SetElements(elements)

   336

                    self.SelectedElement.SetSelected(True)

   337

                    self.Refresh()

   338

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

   339

            dc = self.GetLogicalDC() 

   342

                    result = self.SelectedElement.TestSegment(event.GetLogicalPosition(dc), True)

   343

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

   344

                        self.SelectedElement.SetSelectedSegment(result[0])

   345

                else:

   346

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

   347

            else:

   348

                for element in self.SelectedElement.GetElements():

   350

                        result = element.TestSegment(event.GetLogicalPosition(dc), True)

   351

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

   352

                            element.SetSelectedSegment(result[0])

   353

                    else:

   354

                        element.OnLeftUp(event, dc, self.Scaling)

   355

            wxCallAfter(self.SetCursor, wxNullCursor)

   356

            self.ReleaseMouse()

   357

            self.Refresh()

   358

        event.Skip()

   359

   360

    def OnViewerRightUp(self, event):

   361

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   362

            Viewer.OnViewerRightUp(self, event)

   363

        else:

   364

            dc = self.GetLogicalDC()

   365

            pos = event.GetLogicalPosition(dc)

   366

            element = self.FindElement(pos)

   367

            if element:

   368

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

   369

                    self.SelectedElement.SetSelected(False)

   370

                self.SelectedElement = element

   372

                    self.SelectedElement.SetSelectedSegment(0)

   373

                else:

   374

                    self.SelectedElement.SetSelected(True)

   375

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

   376

                wxCallAfter(self.SetCursor, wxNullCursor)

   377

                self.ReleaseMouse()

   378

                self.Refresh()

   379

        event.Skip()

   380

   381

    def OnViewerLeftDClick(self, event):

   382

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   383

            Viewer.OnViewerLeftDClick(self, event)

   384

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

   385

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

   386

            self.Refresh()

   387

        event.Skip()

   388

   389

    def OnViewerMotion(self, event):

   390

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   391

            Viewer.OnViewerMotion(self, event)

   394

        event.Skip()

   395

   396

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

   397

#                          Keyboard event functions

   398

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

   399

   400

    def OnChar(self, event):

   401

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   402

            Viewer.OnChar(self, event)

   403

        else:

   404

            keycode = event.GetKeyCode()

   405

            if keycode == WXK_DELETE and self.SelectedElement:

   407

                    self.SelectedElement.Delete()

   409

                    self.DeleteWire(self.SelectedElement)

   411

                    all_wires = True

   412

                    for element in self.SelectedElement.GetElements():

   414

                    if all_wires:

   415

                        self.DeleteWire(self.SelectedElement)

   416

                    else:

   417

                        self.SelectedElement.Delete()

   418

            self.Refresh()

   419

        event.Skip()

   420

   421

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

   422

#                          Adding element functions

   423

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

   424

   426

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

   427

        varlist = []

   428

        vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   429

        if vars:

   430

            for var in vars:

   431

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

   432

                    varlist.append(var["Name"])

   433

        returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()

   434

        if returntype == "BOOL":

   435

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

   436

        dialog.SetVariables(varlist)

   437

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

   438

        if dialog.ShowModal() == wxID_OK:

   439

            values = dialog.GetValues()

   440

            startx, starty = LD_OFFSET[0], 0

   441

            if len(self.Rungs) > 0:

   442

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

   443

                starty = bbox.y + bbox.height

   444

            starty += LD_OFFSET[1]

   445

            rung = Graphic_Group(self)

   446

            # Create comment

   447

            id = self.GetNewId()

   448

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

   449

            comment.SetPosition(startx, starty)

   450

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

   453

            self.Controler.AddCurrentElementEditingComment(id)

   454

            self.RefreshCommentModel(comment)

   455

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

   456

            # Create LeftPowerRail

   457

            id = self.GetNewId()

   458

            leftpowerrail = LD_PowerRail(self, LEFTRAIL, id)

   459

            leftpowerrail.SetPosition(startx, starty)

   461

            rung.SelectElement(leftpowerrail)

   462

            self.Controler.AddCurrentElementEditingPowerRail(id, LEFTRAIL)

   463

            self.RefreshPowerRailModel(leftpowerrail)

   464

            # Create Coil

   465

            id = self.GetNewId()

   466

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

   467

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

   469

            rung.SelectElement(coil)

   470

            self.Controler.AddCurrentElementEditingCoil(id)

   471

            # Create Wire between LeftPowerRail and Coil

   472

            wire = Wire(self)

   473

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

   474

            end_connector = leftpowerrail.GetConnectors()[0]

   475

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

   476

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

   477

            wire.ConnectStartPoint(None, start_connector)

   478

            wire.ConnectEndPoint(None, end_connector)

   480

            rung.SelectElement(wire)

   481

            # Create RightPowerRail

   482

            id = self.GetNewId()

   483

            rightpowerrail = LD_PowerRail(self, RIGHTRAIL, id)

   484

            rightpowerrail.SetPosition(startx, starty)

   486

            rung.SelectElement(rightpowerrail)

   487

            self.Controler.AddCurrentElementEditingPowerRail(id, RIGHTRAIL)

   488

            # Create Wire between LeftPowerRail and Coil

   489

            wire = Wire(self)

   490

            start_connector = rightpowerrail.GetConnectors()[0]

   491

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

   492

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

   493

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

   494

            wire.ConnectStartPoint(None, start_connector)

   495

            wire.ConnectEndPoint(None, end_connector)

   497

            rung.SelectElement(wire)

   498

            self.RefreshPosition(coil)

   499

            self.Rungs.append(rung)

   500

            self.Refresh()

   501

   503

        wires = []

   505

            left_element = self.SelectedElement.EndConnected

   506

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

   507

                wires.append(self.SelectedElement)

   510

                for element in self.SelectedElement.GetElements():

   511

                    wires.append(element)

   512

        if len(wires) > 0: