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

if wx.VERSION >= (2, 8, 0):

   163

    import wx.aui

   164

   165

    class LD_MDIViewer(wx.aui.AuiMDIChildFrame):

   166

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

   167

            wx.aui.AuiMDIChildFrame.__init__(self, parent, -1, title = "")

   168

   169

            sizer = wx.BoxSizer(wx.HORIZONTAL)

   170

   171

            self.Viewer = LD_Viewer(self, tagname, window, controler)

   172

   173

            sizer.AddWindow(self.Viewer, 1, border=0, flag=wx.GROW)

   174

   175

            self.SetSizer(sizer)

   176

   177

        def GetViewer(self):

   178

            return self.Viewer

   179

   180

"""

   181

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

   182

"""

   183

   184

class LD_Viewer(Viewer):

   185

   186

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

   187

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

   188

        self.Rungs = []

   189

        self.RungComments = []

   190

        self.CurrentLanguage = "LD"

   191

   192

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

   193

#                          Refresh functions

   194

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

   195

   196

    def RefreshView(self):

   197

        Viewer.RefreshView(self)

   198

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

   199

            bbox = rung.GetBoundingBox()

   200

            if i < len(self.RungComments):

   201

                if self.RungComments[i]:

   202

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

   203

                    if pos[1] > bbox.y:

   204

                        self.RungComments.insert(i, None)

   205

            else:

   206

                self.RungComments.insert(i, None)

   207

   208

    def loadInstance(self, instance, ids):

   209

        Viewer.loadInstance(self, instance, ids)

   210

        if self.GetDrawingMode() != FREEDRAWING_MODE:

   211

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

   212

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

   213

                rung = Graphic_Group(self)

   214

                rung.SelectElement(element)

   215

                self.Rungs.append(rung)

   216

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

   217

                rungs = []

   218

                for connector in instance["connectors"]:

   219

                    for link in connector["links"]:

   220

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

   221

                        rung = self.FindRung(connected)

   222

                        if rung not in rungs:

   223

                            rungs.append(rung)

   224

                if len(rungs) > 1:

   225

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

   226

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

   227

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

   228

                for connector in element.GetConnectors():

   229

                    for wire, num in connector.GetWires():

   230

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

   231

                self.RefreshPosition(element)

   232

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

   233

                rungs = []

   234

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

   235

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

   236

                    rung = self.FindRung(connected)

   237

                    if rung not in rungs:

   238

                        rungs.append(rung)

   239

                if len(rungs) > 1:

   240

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

   241

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

   242

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

   243

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

   244

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

   245

                self.RefreshPosition(element)

   246

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

   247

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

   248

                pos = element.GetPosition()

   249

                i = 0

   250

                inserted = False

   251

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

   252

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

   253

                    if pos[1] < ipos[1]:

   254

                        self.RungComments.insert(i, element)

   255

                        inserted = True

   256

                    i += 1

   257

                if not inserted:

   258

                    self.RungComments.append(element)

   259

   260

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

   261

#                          Search Element functions

   262

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

   263

   264

    def FindRung(self, element):

   265

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

   266

            if rung.IsElementIn(element):

   267

                return i

   268

        return None

   269

   270

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

   271

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   272

            return Viewer.FindElement(self, pos, exclude_group)

   273

   274

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

   275

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

   276

                return self.SelectedElement

   277

        elements = []

   278

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

   279

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

   280

                elements.append(element)

   281

        if len(elements) == 1:

   282

            return elements[0]

   283

        elif len(elements) > 1:

   284

            group = Graphic_Group(self)

   285

            for element in elements:

   286

                if self.IsBlock(element):

   287

                    return element

   288

                group.SelectElement(element)

   289

            return group

   290

        return None

   291

   292

    def SearchElements(self, bbox):

   293

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   294

            return Viewer.SearchElements(self, bbox)

   295

   296

        elements = []

   297

        for element in self.Blocks:

   298

            if element.IsInSelection(bbox):

   299

                elements.append(element)

   300

        return elements

   301

   302

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

   303

#                          Mouse event functions

   304

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

   305

   306

    def OnViewerLeftDown(self, event):

   307

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   308

            Viewer.OnViewerLeftDown(self, event)

   309

        elif self.Mode == MODE_SELECTION:

   310

            dc = self.GetLogicalDC()

   311

            pos = event.GetLogicalPosition(dc)

   312

            element = self.FindElement(pos)

   313

            if self.SelectedElement:

   314

                if not isinstance(self.SelectedElement, Graphic_Group):

   315

                    if self.SelectedElement != element:

   316

                        if self.IsWire(self.SelectedElement):

   317

                            self.SelectedElement.SetSelectedSegment(None)

   318

                        else:

   319

                            self.SelectedElement.SetSelected(False)

   320

                    else:

   321

                        self.SelectedElement = None

   322

                elif element and isinstance(element, Graphic_Group):

   323

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

   324

                        for elt in self.SelectedElement.GetElements():

   325

                            if self.IsWire(elt):

   326

                                elt.SetSelectedSegment(None)

   327

                        self.SelectedElement.SetSelected(False)

   328

                        self.SelectedElement = None

   329

                else:

   330

                    for elt in self.SelectedElement.GetElements():

   331

                        if self.IsWire(elt):

   332

                            elt.SetSelectedSegment(None)

   333

                    self.SelectedElement.SetSelected(False)

   334

                    self.SelectedElement = None

   335

                self.Refresh()

   336

            if element:

   337

                self.SelectedElement = element

   338

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

   339

                self.Refresh()

   340

            else:

   341

                self.rubberBand.Reset()

   342

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

   343

        event.Skip()

   344

   345

    def OnViewerLeftUp(self, event):

   346

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   347

            Viewer.OnViewerLeftUp(self, event)

   348

        elif self.rubberBand.IsShown():

   349

            if self.Mode == MODE_SELECTION:

   350

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

   351

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

   352

                if len(elements) > 0:

   353

                    self.SelectedElement = Graphic_Group(self)

   354

                    self.SelectedElement.SetElements(elements)

   355

                    self.SelectedElement.SetSelected(True)

   356

                    self.Refresh()

   357

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

   358

            dc = self.GetLogicalDC() 

   359

            if not isinstance(self.SelectedElement, Graphic_Group):

   360

                if self.IsWire(self.SelectedElement):

   361

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

   362

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

   363

                        self.SelectedElement.SetSelectedSegment(result[0])

   364

                else:

   365

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

   366

            else:

   367

                for element in self.SelectedElement.GetElements():

   368

                    if self.IsWire(element):

   369

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

   370

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

   371

                            element.SetSelectedSegment(result[0])

   372

                    else:

   373

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

   374

            wx.CallAfter(self.SetCursor, wx.NullCursor)

   375

            self.ReleaseMouse()

   376

            self.Refresh()

   377

        event.Skip()

   378

   379

    def OnViewerRightUp(self, event):

   380

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   381

            Viewer.OnViewerRightUp(self, event)

   382

        else:

   383

            dc = self.GetLogicalDC()

   384

            pos = event.GetLogicalPosition(dc)

   385

            element = self.FindElement(pos)

   386

            if element:

   387

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

   388

                    self.SelectedElement.SetSelected(False)

   389

                self.SelectedElement = element

   390

                if self.IsWire(self.SelectedElement):

   391

                    self.SelectedElement.SetSelectedSegment(0)

   392

                else:

   393

                    self.SelectedElement.SetSelected(True)

   394

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

   395

                wx.CallAfter(self.SetCursor, wx.NullCursor)

   396

                self.ReleaseMouse()

   397

                self.Refresh()

   398

        event.Skip()

   399

   400

    def OnViewerLeftDClick(self, event):

   401

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   402

            Viewer.OnViewerLeftDClick(self, event)

   403

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

   404

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

   405

            self.Refresh()

   406

        event.Skip()

   407

   408

    def OnViewerMotion(self, event):

   409

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   410

            Viewer.OnViewerMotion(self, event)

   411

        elif self.rubberBand.IsShown():

   412

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

   413

        event.Skip()

   414

   415

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

   416

#                          Keyboard event functions

   417

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

   418

   419

    def OnChar(self, event):

   420

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   421

            Viewer.OnChar(self, event)

   422

        else:

   423

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

   424

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

   425

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

   426

            keycode = event.GetKeyCode()

   427

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

   428

                if self.IsBlock(self.SelectedElement):

   429

                    self.SelectedElement.Delete()

   430

                elif self.IsWire(self.SelectedElement):

   431

                    self.DeleteWire(self.SelectedElement)

   432

                elif isinstance(self.SelectedElement, Graphic_Group):

   433

                    all_wires = True

   434

                    for element in self.SelectedElement.GetElements():

   435

                        all_wires &= self.IsWire(element)

   436

                    if all_wires:

   437

                        self.DeleteWire(self.SelectedElement)

   438

                    else:

   439

                        self.SelectedElement.Delete()

   440

                self.RefreshBuffer()

   441

                self.RefreshScrollBars()

   442

                self.Refresh()

   443

            elif keycode == wx.WXK_LEFT:

   444

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

   445

                    self.Scroll(0, ypos)

   446

                elif event.ControlDown():

   447

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

   448

            elif keycode == wx.WXK_RIGHT:

   449

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

   450

                    self.Scroll(xmax, ypos)

   451

                elif event.ControlDown():

   452

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

   453

            elif keycode == wx.WXK_UP:

   454

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

   455

                    self.Scroll(xpos, 0)

   456

                elif event.ControlDown():

   457

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

   458

            elif keycode == wx.WXK_DOWN:

   459

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

   460

                    self.Scroll(xpos, ymax)

   461

                elif event.ControlDown():

   462

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

   463

            else:

   464

                event.Skip()

   465

   466

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

   467

#                          Adding element functions

   468

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

   469

   470

    def AddLadderRung(self):

   471

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

   472

        varlist = []

   473

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

   474

        if vars:

   475

            for var in vars:

   476

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

   477

                    varlist.append(var["Name"])

   478

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

   479

        if returntype == "BOOL":

   480

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

   481

        dialog.SetVariables(varlist)

   482

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

   483

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

   484

            values = dialog.GetValues()

   485

            startx, starty = LD_OFFSET[0], 0

   486

            if len(self.Rungs) > 0:

   487

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

   488

                starty = bbox.y + bbox.height

   489

            starty += LD_OFFSET[1]

   490

            rung = Graphic_Group(self)

   491

            # Create comment

   492

            id = self.GetNewId()

   493

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

   494

            comment.SetPosition(startx, starty)

   495

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

   496

            self.AddComment(comment)

   497

            self.RungComments.append(comment)

   498

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

   499

            self.RefreshCommentModel(comment)

   500

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

   501

            # Create LeftPowerRail

   502

            id = self.GetNewId()

   503

            leftpowerrail = LD_PowerRail(self, LEFTRAIL, id)

   504

            leftpowerrail.SetPosition(startx, starty)