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

import time

    27

from types import *

    28

    29

from Viewer import *

    30

    31

def ExtractNextBlocks(block, block_list):

    32

    current_list = [block]

    33

    while len(current_list) > 0:

    34

        next_list = []

    35

        for current in current_list:

    36

            connectors = current.GetConnectors()

    37

            input_connectors = []

    38

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

    39

                input_connectors = connectors

    40

            else:

    41

                if "inputs" in connectors:

    42

                    input_connectors = connectors["inputs"]

    43

                if "input" in connectors:

    44

                    input_connectors = [connectors["input"]]

    45

            for connector in input_connectors:

    46

                for wire, handle in connector.GetWires():

    47

                    next = wire.EndConnected.GetParentBlock()

    48

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

    49

                        block_list.append(next)

    50

                        next_list.append(next)

    51

        current_list = next_list

    52

    53

def CalcBranchSize(elements, stops):

    54

    branch_size = 0

    55

    stop_list = stops

    56

    for stop in stops:

    57

        ExtractNextBlocks(stop, stop_list)

    58

    element_tree = {}

    59

    for element in elements:

    60

        if element not in element_tree:

    61

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

    62

            GenerateTree(element, element_tree, stop_list)

    63

        elif element_tree[element]:

    64

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

    65

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

    66

    for element, values in element_tree.items():

    67

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

    68

            removed = []

    69

            for child in values["children"]:

    70

                if child != "stop":

    71

##                    if child in elements:

    72

##                        RemoveElement(child, element_tree)

    73

##                        removed.append(child)

    74

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

    75

                        if element not in remove_stops["stop"]:

    76

                            remove_stops["stop"].append(element)

    77

                        if child not in remove_stops["start"]:

    78

                            remove_stops["start"].append(child)

    79

            for child in removed:

    80

                values["children"].remove(child)

    81

    for element in remove_stops["start"]:

    82

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

    83

    for element in remove_stops["stop"]:

    84

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

    85

    for element, values in element_tree.items():

    86

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

    87

            CalcWeight(element, element_tree)

    88

            if values["weight"]:

    89

                branch_size += values["weight"]

    90

            else:

    91

                return 1

    92

    #print branch_size

    93

    return branch_size

    94

    95

def RemoveElement(remove, element_tree):

    96

    if remove in element_tree and element_tree[remove]:

    97

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

    98

            if child != "stop":

    99

                RemoveElement(child, element_tree)

   100

        element_tree.pop(remove)

   101

##        element_tree[remove] = None

   102

   103

def GenerateTree(element, element_tree, stop_list):

   104

    if element in element_tree:

   105

        connectors = element.GetConnectors()

   106

        input_connectors = []

   107

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

   108

            input_connectors = connectors

   109

        else:

   110

            if "inputs" in connectors:

   111

                input_connectors = connectors["inputs"]

   112

            if "input" in connectors:

   113

                input_connectors = [connectors["input"]]

   114

        for connector in input_connectors:

   115

            for wire, handle in connector.GetWires():

   116

                next = wire.EndConnected.GetParentBlock()

   117

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

   118

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

   119

##                        RemoveElement(remove, element_tree)

   120

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

   121

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

   122

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

   123

##                    element_tree[next] = None

   124

                elif next not in element_tree or element_tree[next]:

   125

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

   126

                    if next in element_tree:

   127

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

   128

                    else:

   129

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

   130

                        GenerateTree(next, element_tree, stop_list)

   131

   132

def CalcWeight(element, element_tree):

   133

    weight = 0

   134

    parts = None

   135

    if element in element_tree:

   136

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

   137

            if parent == "start":

   138

                weight += 1

   139

            elif parent in element_tree:

   140

                if not parts:

   141

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

   142

                else:

   143

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

   144

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

   145

                    CalcWeight(parent, element_tree)

   146

                if element_tree[parent]["weight"]:

   147

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

   148

                else:

   149

                    element_tree[element]["weight"] = None

   150

                    return

   151

            else:

   152

                element_tree[element]["weight"] = None

   153

                return

   154

        if not parts:

   155

            parts = 1

   156

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

   157

   158

   159

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

   160

#                     Ladder Diagram Graphic elements Viewer class

   161

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

   162

   163

   164

"""

   165

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

   166

"""

   167

   168

class LD_Viewer(Viewer):

   169

   170

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

   171

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

   172

        self.Rungs = []

   173

        self.RungComments = []

   174

        self.CurrentLanguage = "LD"

   175

   176

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

   177

#                          Refresh functions

   178

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

   179

   180

    def ResetView(self):

   181

        self.Rungs = []

   182

        self.RungComments = []

   183

        Viewer.ResetView(self)

   184

   185

    def RefreshView(self, variablepanel=True, selection=None):

   186

        Viewer.RefreshView(self, variablepanel, selection)

   187

        wx.CallAfter(self.Refresh)

   188

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

   189

            bbox = rung.GetBoundingBox()

   190

            if i < len(self.RungComments):

   191

                if self.RungComments[i]:

   192

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

   193

                    if pos[1] > bbox.y:

   194

                        self.RungComments.insert(i, None)

   195

            else:

   196

                self.RungComments.insert(i, None)

   197

   198

    def loadInstance(self, instance, ids, selection):

   199

        Viewer.loadInstance(self, instance, ids, selection)

   200

        if self.GetDrawingMode() != FREEDRAWING_MODE:

   201

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

   202

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

   203

                rung = Graphic_Group(self)

   204

                rung.SelectElement(element)

   205

                self.Rungs.append(rung)

   206

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

   207

                rungs = []

   208

                for connector in instance["inputs"]:

   209

                    for link in connector["links"]:

   210

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

   211

                        rung = self.FindRung(connected)

   212

                        if rung not in rungs:

   213

                            rungs.append(rung)

   214

                if len(rungs) > 1:

   215

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

   216

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

   217

                element_connectors = element.GetConnectors()

   218

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

   219

                for connector in element_connectors["inputs"]:

   220

                    for wire, num in connector.GetWires():

   221

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

   222

                wx.CallAfter(self.RefreshPosition, element)

   223

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

   224

                rungs = []

   225

                for link in instance["inputs"][0]["links"]:

   226

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

   227

                    rung = self.FindRung(connected)

   228

                    if rung not in rungs:

   229

                        rungs.append(rung)

   230

                if len(rungs) > 1:

   231

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

   232

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

   233

                element_connectors = element.GetConnectors() 

   234

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

   235

                for wire, num in element_connectors["inputs"][0].GetWires():

   236

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

   237

                wx.CallAfter(self.RefreshPosition, element)

   238

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

   239

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

   240

                pos = element.GetPosition()

   241

                i = 0

   242

                inserted = False

   243

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

   244

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

   245

                    if pos[1] < ipos[1]:

   246

                        self.RungComments.insert(i, element)

   247

                        inserted = True

   248

                    i += 1

   249

                if not inserted:

   250

                    self.RungComments.append(element)

   251

   252

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

   253

#                          Search Element functions

   254

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

   255

   256

    def FindRung(self, element):

   257

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

   258

            if rung.IsElementIn(element):

   259

                return i

   260

        return None

   261

   262

    def FindElement(self, event, exclude_group = False, connectors = True):

   263

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   264

            return Viewer.FindElement(self, event, exclude_group, connectors)

   265

   266

        dc = self.GetLogicalDC()

   267

        pos = event.GetLogicalPosition(dc)

   268

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

   269

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

   270

                return self.SelectedElement

   271

        elements = []

   272

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

   273

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

   274

                elements.append(element)

   275

        if len(elements) == 1:

   276

            return elements[0]

   277

        elif len(elements) > 1:

   278

            group = Graphic_Group(self)

   279

            for element in elements:

   280

                if self.IsBlock(element):

   281

                    return element

   282

                group.SelectElement(element)

   283

            return group

   284

        return None

   285

   286

    def SearchElements(self, bbox):

   287

        elements = []

   288

        for element in self.Blocks.values() + self.Comments.values():

   289

            if element.IsInSelection(bbox):

   290

                elements.append(element)

   291

        return elements

   292

   293

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

   294

#                          Mouse event functions

   295

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

   296

   297

    def OnViewerLeftDown(self, event):

   298

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   299

            Viewer.OnViewerLeftDown(self, event)

   300

        elif self.Mode == MODE_SELECTION:

   301

            element = self.FindElement(event)

   302

            if self.SelectedElement:

   303

                if not isinstance(self.SelectedElement, Graphic_Group):

   304

                    if self.SelectedElement != element:

   305

                        if self.IsWire(self.SelectedElement):

   306

                            self.SelectedElement.SetSelectedSegment(None)

   307

                        else:

   308

                            self.SelectedElement.SetSelected(False)

   309

                    else:

   310

                        self.SelectedElement = None

   311

                elif element and isinstance(element, Graphic_Group):

   312

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

   313

                        for elt in self.SelectedElement.GetElements():

   314

                            if self.IsWire(elt):

   315

                                elt.SetSelectedSegment(None)

   316

                        self.SelectedElement.SetSelected(False)

   317

                        self.SelectedElement = None

   318

                else:

   319

                    for elt in self.SelectedElement.GetElements():

   320

                        if self.IsWire(elt):

   321

                            elt.SetSelectedSegment(None)

   322

                    self.SelectedElement.SetSelected(False)

   323

                    self.SelectedElement = None

   324

            if element:

   325

                self.SelectedElement = element

   326

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

   327

                self.SelectedElement.Refresh()

   328

            else:

   329

                self.rubberBand.Reset()

   330

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

   331

        event.Skip()

   332

   333

    def OnViewerLeftUp(self, event):

   334

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   335

            Viewer.OnViewerLeftUp(self, event)

   336

        elif self.rubberBand.IsShown():

   337

            if self.Mode == MODE_SELECTION:

   338

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

   339

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

   340

                if len(elements) > 0:

   341

                    self.SelectedElement = Graphic_Group(self)

   342

                    self.SelectedElement.SetElements(elements)

   343

                    self.SelectedElement.SetSelected(True)

   344

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

   345

            dc = self.GetLogicalDC() 

   346

            if not isinstance(self.SelectedElement, Graphic_Group):

   347

                if self.IsWire(self.SelectedElement):

   348

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

   349

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

   350

                        self.SelectedElement.SetSelectedSegment(result[0])

   351

                else:

   352

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

   353

            else:

   354

                for element in self.SelectedElement.GetElements():

   355

                    if self.IsWire(element):

   356

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

   357

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

   358

                            element.SetSelectedSegment(result[0])

   359

                    else:

   360

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

   361

            self.SelectedElement.Refresh()

   362

            wx.CallAfter(self.SetCurrentCursor, 0)

   363

        event.Skip()

   364

   365

    def OnViewerRightUp(self, event):

   366

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   367

            Viewer.OnViewerRightUp(self, event)

   368

        else:

   369

            element = self.FindElement(event)

   370

            if element:

   371

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

   372

                    self.SelectedElement.SetSelected(False)

   373

                self.SelectedElement = element

   374

                if self.IsWire(self.SelectedElement):

   375

                    self.SelectedElement.SetSelectedSegment(0)

   376

                else:

   377

                    self.SelectedElement.SetSelected(True)

   378

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

   379

                    self.SelectedElement.Refresh()

   380

                wx.CallAfter(self.SetCurrentCursor, 0)

   381

        event.Skip()

   382

   383

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

   384

#                          Keyboard event functions

   385

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

   386

   387

    def OnChar(self, event):

   388

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   389

            Viewer.OnChar(self, event)

   390

        else:

   391

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

   392

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

   393

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

   394

            keycode = event.GetKeyCode()

   395

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

   396

                if self.IsBlock(self.SelectedElement):

   397

                    self.SelectedElement.Delete()

   398

                elif self.IsWire(self.SelectedElement):

   399

                    self.DeleteWire(self.SelectedElement)

   400

                elif isinstance(self.SelectedElement, Graphic_Group):

   401

                    all_wires = True

   402

                    for element in self.SelectedElement.GetElements():

   403

                        all_wires &= self.IsWire(element)

   404

                    if all_wires:

   405

                        self.DeleteWire(self.SelectedElement)

   406

                    else:

   407

                        self.SelectedElement.Delete()

   408

                self.RefreshBuffer()

   409

                self.RefreshScrollBars()

   410

                self.Refresh(False)

   411

            elif keycode == wx.WXK_LEFT:

   412

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

   413

                    self.Scroll(0, ypos)

   414

                elif event.ControlDown():

   415

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

   416

            elif keycode == wx.WXK_RIGHT:

   417

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

   418

                    self.Scroll(xmax, ypos)

   419

                elif event.ControlDown():

   420

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

   421

            elif keycode == wx.WXK_UP:

   422

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

   423

                    self.Scroll(xpos, 0)

   424

                elif event.ControlDown():

   425

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

   426

            elif keycode == wx.WXK_DOWN:

   427

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

   428

                    self.Scroll(xpos, ymax)

   429

                elif event.ControlDown():

   430

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

   431

            else:

   432

                event.Skip()

   433

   434

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

   435

#                  Model adding functions from Drop Target

   436

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

   437

   438

    def AddVariableBlock(self, x, y, scaling, var_class, var_name, var_type):

   439

        if var_type == "BOOL":

   440

            id = self.GetNewId()

   441

            if var_class == INPUT:

   442

                contact = LD_Contact(self, CONTACT_NORMAL, var_name, id)

   443

                width, height = contact.GetMinSize()

   444

                if scaling is not None:

   445

                    x = round(float(x) / float(scaling[0])) * scaling[0]

   446

                    y = round(float(y) / float(scaling[1])) * scaling[1]

   447

                    width = round(float(width) / float(scaling[0]) + 0.5) * scaling[0]

   448

                    height = round(float(height) / float(scaling[1]) + 0.5) * scaling[1]

   449

                contact.SetPosition(x, y)

   450

                contact.SetSize(width, height)

   451

                self.AddBlock(contact)

   452

                self.Controler.AddEditedElementContact(self.GetTagName(), id)

   453

                self.RefreshContactModel(contact)

   454

            else:

   455

                coil = LD_Coil(self, COIL_NORMAL, var_name, id)

   456

                width, height = coil.GetMinSize()

   457

                if scaling is not None:

   458

                    x = round(float(x) / float(scaling[0])) * scaling[0]

   459

                    y = round(float(y) / float(scaling[1])) * scaling[1]

   460

                    width = round(float(width) / float(scaling[0]) + 0.5) * scaling[0]

   461

                    height = round(float(height) / float(scaling[1]) + 0.5) * scaling[1]

   462

                coil.SetPosition(x, y)

   463

                coil.SetSize(width, height)

   464

                self.AddBlock(coil)

   465

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

   466

                self.RefreshCoilModel(coil)

   467

            self.RefreshBuffer()

   468

            self.RefreshScrollBars()

   469

            self.RefreshVisibleElements()

   470

            self.Refresh(False)

   471

        else:

   472

            Viewer.AddVariableBlock(self, x, y, scaling, var_class, var_name, var_type)

   473

   474

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

   475

#                          Adding element functions

   476

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

   477

   478

    def AddLadderRung(self):

   479

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

   480

        dialog.SetPreviewFont(self.GetFont())

   481

        varlist = []

   482

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

   483

        if vars:

   484

            for var in vars:

   485

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

   486

                    varlist.append(var["Name"])

   487

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

   488

        if returntype == "BOOL":

   489

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

   490

        dialog.SetVariables(varlist)

   491

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

   492

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

   493

            values = dialog.GetValues()

   494

            startx, starty = LD_OFFSET[0], 0

   495

            if len(self.Rungs) > 0:

   496

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

   497

                starty = bbox.y + bbox.height

   498

            starty += LD_OFFSET[1]

   499

            rung = Graphic_Group(self)

   500

   501

            # Create comment

   502

            id = self.GetNewId()

   503

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

   504

            comment.SetPosition(startx, starty)

   505

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

   506

            self.AddComment(comment)

   507

            self.RungComments.append(comment)

   508

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

   509

            self.RefreshCommentModel(comment)

   510

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

   511

   512

            # Create LeftPowerRail

   513

            id = self.GetNewId()

   514

            leftpowerrail = LD_PowerRail(self, LEFTRAIL, id)

   515

            leftpowerrail.SetPosition(startx, starty)

   516

            leftpowerrail_connectors = leftpowerrail.GetConnectors()

   517

            self.AddBlock(leftpowerrail)

   518

            rung.SelectElement(leftpowerrail)

   519

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

   520

            self.RefreshPowerRailModel(leftpowerrail)

   521

   522

            # Create Coil

   523

            id = self.GetNewId()

   524

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

   525

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

   526

            coil_connectors = coil.GetConnectors()

   527

            self.AddBlock(coil)

   528

            rung.SelectElement(coil)

   529

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

   530