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

from types import *

    27

    28

from Viewer import *

    29

    30

def ExtractNextBlocks(block, block_list):

    31

    current_list = [block]

    32

    while len(current_list) > 0:

    33

        next_list = []

    34

        for current in current_list:

    35

            connectors = current.GetConnectors()

    36

            input_connectors = []

    37

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

    38

                input_connectors = connectors

    39

            else:

    40

                if "inputs" in connectors:

    41

                    input_connectors = connectors["inputs"]

    42

                if "input" in connectors:

    43

                    input_connectors = [connectors["input"]]

    44

            for connector in input_connectors:

    45

                for wire, handle in connector.GetWires():

    46

                    next = wire.EndConnected.GetParentBlock()

    47

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

    48

                        block_list.append(next)

    49

                        next_list.append(next)

    50

        current_list = next_list

    51

    52

def CalcBranchSize(elements, stops):

    53

    branch_size = 0

    54

    stop_list = stops

    55

    for stop in stops:

    56

        ExtractNextBlocks(stop, stop_list)

    57

    element_tree = {}

    58

    for element in elements:

    59

        if element not in element_tree:

    60

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

    61

            GenerateTree(element, element_tree, stop_list)

    62

        elif element_tree[element]:

    63

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

    64

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

    65

    for element, values in element_tree.items():

    66

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

    67

            removed = []

    68

            for child in values["children"]:

    69

                if child != "stop":

    70

##                    if child in elements:

    71

##                        RemoveElement(child, element_tree)

    72

##                        removed.append(child)

    73

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

    74

                        if element not in remove_stops["stop"]:

    75

                            remove_stops["stop"].append(element)

    76

                        if child not in remove_stops["start"]:

    77

                            remove_stops["start"].append(child)

    78

            for child in removed:

    79

                values["children"].remove(child)

    80

    for element in remove_stops["start"]:

    81

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

    82

    for element in remove_stops["stop"]:

    83

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

    84

    for element, values in element_tree.items():

    85

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

    86

            CalcWeight(element, element_tree)

    87

            if values["weight"]:

    88

                branch_size += values["weight"]

    89

            else:

    90

                return 1

    91

    #print branch_size

    92

    return branch_size

    93

    94

def RemoveElement(remove, element_tree):

    95

    if remove in element_tree and element_tree[remove]:

    96

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

    97

            if child != "stop":

    98

                RemoveElement(child, element_tree)

    99

        element_tree.pop(remove)

   100

##        element_tree[remove] = None

   101

   102

def GenerateTree(element, element_tree, stop_list):

   103

    if element in element_tree:

   104

        connectors = element.GetConnectors()

   105

        input_connectors = []

   106

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

   107

            input_connectors = connectors

   108

        else:

   109

            if "inputs" in connectors:

   110

                input_connectors = connectors["inputs"]

   111

            if "input" in connectors:

   112

                input_connectors = [connectors["input"]]

   113

        for connector in input_connectors:

   114

            for wire, handle in connector.GetWires():

   115

                next = wire.EndConnected.GetParentBlock()

   116

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

   117

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

   118

##                        RemoveElement(remove, element_tree)

   119

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

   120

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

   121

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

   122

##                    element_tree[next] = None

   123

                elif next not in element_tree or element_tree[next]:

   124

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

   125

                    if next in element_tree:

   126

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

   127

                    else:

   128

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

   129

                        GenerateTree(next, element_tree, stop_list)

   130

   131

def CalcWeight(element, element_tree):

   132

    weight = 0

   133

    parts = None

   134

    if element in element_tree:

   135

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

   136

            if parent == "start":

   137

                weight += 1

   138

            elif parent in element_tree:

   139

                if not parts:

   140

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

   141

                else:

   142

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

   143

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

   144

                    CalcWeight(parent, element_tree)

   145

                if element_tree[parent]["weight"]:

   146

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

   147

                else:

   148

                    element_tree[element]["weight"] = None

   149

                    return

   150

            else:

   151

                element_tree[element]["weight"] = None

   152

                return

   153

        if not parts:

   154

            parts = 1

   155

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

   156

   157

   158

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

   159

#                     Ladder Diagram Graphic elements Viewer class

   160

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

   161

   162

   163

"""

   164

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

   165

"""

   166

   167

class LD_Viewer(Viewer):

   168

   169

    def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):

   170

        Viewer.__init__(self, parent, tagname, window, controler, debug, instancepath)

   171

        self.Rungs = []

   172

        self.RungComments = []

   173

        self.CurrentLanguage = "LD"

   174

   175

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

   176

#                          Refresh functions

   177

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

   178

   179

    def ResetView(self):

   180

        self.Rungs = []

   181

        self.RungComments = []

   182

        Viewer.ResetView(self)

   183

   184

    def RefreshView(self):

   185

        Viewer.RefreshView(self)

   186

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

   187

            bbox = rung.GetBoundingBox()

   188

            if i < len(self.RungComments):

   189

                if self.RungComments[i]:

   190

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

   191

                    if pos[1] > bbox.y:

   192

                        self.RungComments.insert(i, None)

   193

            else:

   194

                self.RungComments.insert(i, None)

   195

   198

        if self.GetDrawingMode() != FREEDRAWING_MODE:

   199

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

   200

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

   201

                rung = Graphic_Group(self)

   202

                rung.SelectElement(element)

   203

                self.Rungs.append(rung)

   204

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

   205

                rungs = []

   206

                for connector in instance["connectors"]:

   207

                    for link in connector["links"]:

   208

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

   209

                        rung = self.FindRung(connected)

   210

                        if rung not in rungs:

   211

                            rungs.append(rung)

   212

                if len(rungs) > 1:

   213

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

   214

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

   215

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

   216

                for connector in element.GetConnectors():

   217

                    for wire, num in connector.GetWires():

   218

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

   219

                self.RefreshPosition(element)

   220

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

   221

                rungs = []

   222

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

   223

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

   224

                    rung = self.FindRung(connected)

   225

                    if rung not in rungs:

   226

                        rungs.append(rung)

   227

                if len(rungs) > 1:

   228

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

   229

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

   230

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

   231

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

   232

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

   233

                self.RefreshPosition(element)

   234

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

   235

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

   236

                pos = element.GetPosition()

   237

                i = 0

   238

                inserted = False

   239

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

   240

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

   241

                    if pos[1] < ipos[1]:

   242

                        self.RungComments.insert(i, element)

   243

                        inserted = True

   244

                    i += 1

   245

                if not inserted:

   246

                    self.RungComments.append(element)

   247

   248

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

   249

#                          Search Element functions

   250

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

   251

   252

    def FindRung(self, element):

   253

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

   254

            if rung.IsElementIn(element):

   255

                return i

   256

        return None

   257

   258

    def FindElement(self, pos, exclude_group = False):

   259

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   260

            return Viewer.FindElement(self, pos, exclude_group)

   261

   262

        if self.SelectedElement and not (exclude_group and isinstance(self.SelectedElement, Graphic_Group)):

   263

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

   264

                return self.SelectedElement

   265

        elements = []

   266

        for element in self.GetElements(sort_wires=True):

   267

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

   268

                elements.append(element)

   269

        if len(elements) == 1:

   270

            return elements[0]

   271

        elif len(elements) > 1:

   272

            group = Graphic_Group(self)

   273

            for element in elements:

   274

                if self.IsBlock(element):

   275

                    return element

   276

                group.SelectElement(element)

   277

            return group

   278

        return None

   279

   280

    def SearchElements(self, bbox):

   281

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   282

            return Viewer.SearchElements(self, bbox)

   283

   284

        elements = []

   285

        for element in self.Blocks:

   286

            if element.IsInSelection(bbox):

   287

                elements.append(element)

   288

        return elements

   289

   290

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

   291

#                          Mouse event functions

   292

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

   293

   294

    def OnViewerLeftDown(self, event):

   295

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   296

            Viewer.OnViewerLeftDown(self, event)

   297

        elif self.Mode == MODE_SELECTION:

   298

            dc = self.GetLogicalDC()

   299

            pos = event.GetLogicalPosition(dc)

   300

            element = self.FindElement(pos)

   301

            if self.SelectedElement:

   302

                if not isinstance(self.SelectedElement, Graphic_Group):

   303

                    if self.SelectedElement != element:

   304

                        if self.IsWire(self.SelectedElement):

   305

                            self.SelectedElement.SetSelectedSegment(None)

   306

                        else:

   307

                            self.SelectedElement.SetSelected(False)

   308

                    else:

   309

                        self.SelectedElement = None

   310

                elif element and isinstance(element, Graphic_Group):

   311

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

   312

                        for elt in self.SelectedElement.GetElements():

   313

                            if self.IsWire(elt):

   314

                                elt.SetSelectedSegment(None)

   315

                        self.SelectedElement.SetSelected(False)

   316

                        self.SelectedElement = None

   317

                else:

   318

                    for elt in self.SelectedElement.GetElements():

   319

                        if self.IsWire(elt):

   320

                            elt.SetSelectedSegment(None)

   321

                    self.SelectedElement.SetSelected(False)

   322

                    self.SelectedElement = None

   323

            if element:

   324

                self.SelectedElement = element

   325

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

   326

                self.SelectedElement.Refresh()

   327

            else:

   328

                self.rubberBand.Reset()

   329

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

   330

        event.Skip()

   331

   332

    def OnViewerLeftUp(self, event):

   333

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   334

            Viewer.OnViewerLeftUp(self, event)

   335

        elif self.rubberBand.IsShown():

   336

            if self.Mode == MODE_SELECTION:

   337

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

   338

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

   339

                if len(elements) > 0:

   340

                    self.SelectedElement = Graphic_Group(self)

   341

                    self.SelectedElement.SetElements(elements)

   342

                    self.SelectedElement.SetSelected(True)

   343

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

   344

            dc = self.GetLogicalDC() 

   345

            if not isinstance(self.SelectedElement, Graphic_Group):

   346

                if self.IsWire(self.SelectedElement):

   347

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

   348

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

   349

                        self.SelectedElement.SetSelectedSegment(result[0])

   350

                else:

   351

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

   352

            else:

   353

                for element in self.SelectedElement.GetElements():

   354

                    if self.IsWire(element):

   355

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

   356

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

   357

                            element.SetSelectedSegment(result[0])

   358

                    else:

   359

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

   360

            self.SelectedElement.Refresh()

   361

            wx.CallAfter(self.SetCurrentCursor, 0)

   362

        event.Skip()

   363

   364

    def OnViewerRightUp(self, event):

   365

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   366

            Viewer.OnViewerRightUp(self, event)

   367

        else:

   368

            dc = self.GetLogicalDC()

   369

            pos = event.GetLogicalPosition(dc)

   370

            element = self.FindElement(pos)

   371

            if element:

   372

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

   373

                    self.SelectedElement.SetSelected(False)

   374

                self.SelectedElement = element

   375

                if self.IsWire(self.SelectedElement):

   376

                    self.SelectedElement.SetSelectedSegment(0)

   377

                else:

   378

                    self.SelectedElement.SetSelected(True)

   379

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

   380

                    self.SelectedElement.Refresh()

   381

                wx.CallAfter(self.SetCurrentCursor, 0)

   382

        event.Skip()

   383

   384

    def OnViewerLeftDClick(self, event):

   385

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   386

            Viewer.OnViewerLeftDClick(self, event)

   387

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

   388

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

   389

            self.SelectedElement.Refresh()

   390

        event.Skip()

   391

   392

    def OnViewerMotion(self, event):

   393

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   394

            Viewer.OnViewerMotion(self, event)

   395

        elif self.rubberBand.IsShown():

   396

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

   397

        event.Skip()

   398

   399

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

   400

#                          Keyboard event functions

   401

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

   402

   403

    def OnChar(self, event):

   404

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   405

            Viewer.OnChar(self, event)

   406

        else:

   407

            xpos, ypos = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL)

   408

            xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)

   409

            ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)

   410

            keycode = event.GetKeyCode()

   411

            if keycode == wx.WXK_DELETE and self.SelectedElement:

   412

                if self.IsBlock(self.SelectedElement):

   413

                    self.SelectedElement.Delete()

   414

                elif self.IsWire(self.SelectedElement):

   415

                    self.DeleteWire(self.SelectedElement)

   416

                elif isinstance(self.SelectedElement, Graphic_Group):

   417

                    all_wires = True

   418

                    for element in self.SelectedElement.GetElements():

   419

                        all_wires &= self.IsWire(element)

   420

                    if all_wires:

   421

                        self.DeleteWire(self.SelectedElement)

   422

                    else:

   423

                        self.SelectedElement.Delete()

   424

                self.RefreshBuffer()

   425

                self.RefreshScrollBars()

   426

                self.Refresh(False)

   427

            elif keycode == wx.WXK_LEFT:

   428

                if event.ControlDown() and event.ShiftDown():

   429

                    self.Scroll(0, ypos)

   430

                elif event.ControlDown():

   431

                    self.Scroll(max(0, xpos - 1), ypos)

   432

            elif keycode == wx.WXK_RIGHT:

   433

                if event.ControlDown() and event.ShiftDown():

   434

                    self.Scroll(xmax, ypos)

   435

                elif event.ControlDown():

   436

                    self.Scroll(min(xpos + 1, xmax), ypos)

   437

            elif keycode == wx.WXK_UP:

   438

                if event.ControlDown() and event.ShiftDown():

   439

                    self.Scroll(xpos, 0)

   440

                elif event.ControlDown():

   441

                    self.Scroll(xpos, max(0, ypos - 1))

   442

            elif keycode == wx.WXK_DOWN:

   443

                if event.ControlDown() and event.ShiftDown():

   444

                    self.Scroll(xpos, ymax)

   445

                elif event.ControlDown():

   446

                    self.Scroll(xpos, min(ypos + 1, ymax))

   447

            else:

   448

                event.Skip()

   449

   450

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

   451

#                          Adding element functions

   452

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

   453

   454

    def AddLadderRung(self):

   455

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

   456

        dialog.SetPreviewFont(self.GetFont())

   457

        varlist = []

   458

        vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)

   459

        if vars:

   460

            for var in vars:

   461

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

   462

                    varlist.append(var["Name"])

   463

        returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)

   464

        if returntype == "BOOL":

   465

            varlist.append(self.Controler.GetEditedElementName(self.TagName))

   466

        dialog.SetVariables(varlist)

   467

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

   468

        if dialog.ShowModal() == wx.ID_OK:

   469

            values = dialog.GetValues()

   470

            startx, starty = LD_OFFSET[0], 0

   471

            if len(self.Rungs) > 0:

   472

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

   473

                starty = bbox.y + bbox.height

   474

            starty += LD_OFFSET[1]

   475

            rung = Graphic_Group(self)

   476

            # Create comment

   477

            id = self.GetNewId()

   478

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

   479

            comment.SetPosition(startx, starty)

   480

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

   481

            self.AddComment(comment)

   482

            self.RungComments.append(comment)

   483

            self.Controler.AddEditedElementComment(self.TagName, id)

   484

            self.RefreshCommentModel(comment)

   485

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

   486

            # Create LeftPowerRail

   487

            id = self.GetNewId()

   488

            leftpowerrail = LD_PowerRail(self, LEFTRAIL, id)

   489

            leftpowerrail.SetPosition(startx, starty)

   490

            self.AddBlock(leftpowerrail)

   491

            rung.SelectElement(leftpowerrail)

   492

            self.Controler.AddEditedElementPowerRail(self.TagName, id, LEFTRAIL)

   493

            self.RefreshPowerRailModel(leftpowerrail)

   494

            # Create Coil

   495

            id = self.GetNewId()

   496

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

   497

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

   498

            self.AddBlock(coil)

   499

            rung.SelectElement(coil)

   500

            self.Controler.AddEditedElementCoil(self.TagName, id)

   501

            # Create Wire between LeftPowerRail and Coil

   502

            wire = Wire(self)

   503

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

   504