1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import time

    26

from types import *

    27

    28

import wx

    29

    30

from Viewer import *

    31

    32

    33

def ExtractNextBlocks(block, block_list):

    34

    current_list = [block]

    35

    while len(current_list) > 0:

    36

        next_list = []

    37

        for current in current_list:

    38

            connectors = current.GetConnectors()

    39

            input_connectors = []

    40

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

    41

                input_connectors = connectors

    42

            else:

    43

                if "inputs" in connectors:

    44

                    input_connectors = connectors["inputs"]

    45

                if "input" in connectors:

    46

                    input_connectors = [connectors["input"]]

    47

            for connector in input_connectors:

    48

                for wire, handle in connector.GetWires():

    49

                    next = wire.EndConnected.GetParentBlock()

    50

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

    51

                        block_list.append(next)

    52

                        next_list.append(next)

    53

        current_list = next_list

    54

    55

    56

def CalcBranchSize(elements, stops):

    57

    branch_size = 0

    58

    stop_list = stops

    59

    for stop in stops:

    60

        ExtractNextBlocks(stop, stop_list)

    61

    element_tree = {}

    62

    for element in elements:

    63

        if element not in element_tree:

    64

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

    65

            GenerateTree(element, element_tree, stop_list)

    66

        elif element_tree[element]:

    67

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

    68

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

    69

    for element, values in element_tree.items():

    70

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

    71

            removed = []

    72

            for child in values["children"]:

    73

                if child != "stop":

    74

                    # if child in elements:

    75

                    #     RemoveElement(child, element_tree)

    76

                    #     removed.append(child)

    77

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

    78

                        if element not in remove_stops["stop"]:

    79

                            remove_stops["stop"].append(element)

    80

                        if child not in remove_stops["start"]:

    81

                            remove_stops["start"].append(child)

    82

            for child in removed:

    83

                values["children"].remove(child)

    84

    for element in remove_stops["start"]:

    85

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

    86

    for element in remove_stops["stop"]:

    87

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

    88

    for element, values in element_tree.items():

    89

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

    90

            CalcWeight(element, element_tree)

    91

            if values["weight"]:

    92

                branch_size += values["weight"]

    93

            else:

    94

                return 1

    95

    return branch_size

    96

    97

    98

def RemoveElement(remove, element_tree):

    99

    if remove in element_tree and element_tree[remove]:

   100

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

   101

            if child != "stop":

   102

                RemoveElement(child, element_tree)

   103

        element_tree.pop(remove)

   104

#        element_tree[remove] = None

   105

   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

   137

def CalcWeight(element, element_tree):

   138

    weight = 0

   139

    parts = None

   140

    if element in element_tree:

   141

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

   142

            if parent == "start":

   143

                weight += 1

   144

            elif parent in element_tree:

   145

                if not parts:

   146

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

   147

                else:

   148

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

   149

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

   150

                    CalcWeight(parent, element_tree)

   151

                if element_tree[parent]["weight"]:

   152

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

   153

                else:

   154

                    element_tree[element]["weight"] = None

   155

                    return

   156

            else:

   157

                element_tree[element]["weight"] = None

   158

                return

   159

        if not parts:

   160

            parts = 1

   161

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

   162

   163

   164

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

   165

#                     Ladder Diagram Graphic elements Viewer class

   166

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

   167

   168

   169

class LD_Viewer(Viewer):

   170

    """

   171

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

   172

    """

   173

   174

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

   175

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

   176

        self.Rungs = []

   177

        self.RungComments = []

   178

        self.CurrentLanguage = "LD"

   179

   180

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

   181

    #                          Refresh functions

   182

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

   183

   184

    def ResetView(self):

   185

        self.Rungs = []

   186

        self.RungComments = []

   187

        Viewer.ResetView(self)

   188

   189

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

   190

        Viewer.RefreshView(self, variablepanel, selection)

   191

        if self.GetDrawingMode() != FREEDRAWING_MODE:

   192

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

   193

                bbox = rung.GetBoundingBox()

   194

                if i < len(self.RungComments):

   195

                    if self.RungComments[i]:

   196

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

   197

                        if pos[1] > bbox.y:

   198

                            self.RungComments.insert(i, None)

   199

                else:

   200

                    self.RungComments.insert(i, None)

   201

   202

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

   203

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

   204

        if self.GetDrawingMode() != FREEDRAWING_MODE:

   205

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

   206

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

   207

                rung = Graphic_Group(self)

   208

                rung.SelectElement(element)

   209

                self.Rungs.append(rung)

   210

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

   211

                rungs = []

   212

                for connector in instance["inputs"]:

   213

                    for link in connector["links"]:

   214

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

   215

                        rung = self.FindRung(connected)

   216

                        if rung not in rungs:

   217

                            rungs.append(rung)

   218

                if len(rungs) > 1:

   219

                    raise ValueError(

   220

                        _("Ladder element with id %d is on more than one rung.")

   221

                        % instance["id"])

   222

   223

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

   224

                element_connectors = element.GetConnectors()

   225

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

   226

                for connector in element_connectors["inputs"]:

   227

                    for wire, num in connector.GetWires():

   228

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

   229

                wx.CallAfter(self.RefreshPosition, element)

   230

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

   231

                rungs = []

   232

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

   233

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

   234

                    rung = self.FindRung(connected)

   235

                    if rung not in rungs:

   236

                        rungs.append(rung)

   237

                if len(rungs) > 1:

   238

                    raise ValueError(

   239

                        _("Ladder element with id %d is on more than one rung.")

   240

                        % instance["id"])

   241

   242

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

   243

                element_connectors = element.GetConnectors()

   244

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

   245

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

   246

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

   247

                wx.CallAfter(self.RefreshPosition, element)

   248

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

   249

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

   250

                pos = element.GetPosition()

   251

                i = 0

   252

                inserted = False

   253

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

   254

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

   255

                    if pos[1] < ipos[1]:

   256

                        self.RungComments.insert(i, element)

   257

                        inserted = True

   258

                    i += 1

   259

                if not inserted:

   260

                    self.RungComments.append(element)

   261

   262

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

   263

    #                          Search Element functions

   264

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

   265

   266

    def FindRung(self, element):

   267

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

   268

            if rung.IsElementIn(element):

   269

                return i

   270

        return None

   271

   272

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

   273

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   274

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

   275

   276

        dc = self.GetLogicalDC()

   277

        pos = event.GetLogicalPosition(dc)

   278

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

   279

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

   280

                return self.SelectedElement

   281

        elements = []

   282

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

   283

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

   284

                elements.append(element)

   285

        if len(elements) == 1:

   286

            return elements[0]

   287

        elif len(elements) > 1:

   288

            group = Graphic_Group(self)

   289

            for element in elements:

   290

                if self.IsBlock(element):

   291

                    return element

   292

                group.SelectElement(element)

   293

            return group

   294

        return None

   295

   296

    def SearchElements(self, bbox):

   297

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   298

            return Viewer.SearchElements(self, bbox)

   299

   300

        elements = []

   301

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

   302

            if element.IsInSelection(bbox):

   303

                elements.append(element)

   304

        return elements

   305

   306

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

   307

    #                          Mouse event functions

   308

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

   309

   310

    def OnViewerLeftDown(self, event):

   311

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   312

            Viewer.OnViewerLeftDown(self, event)

   313

        elif self.Mode == MODE_SELECTION:

   314

            element = self.FindElement(event)

   315

            if self.SelectedElement:

   316

                if not isinstance(self.SelectedElement, Graphic_Group):

   317

                    if self.SelectedElement != element:

   318

                        if self.IsWire(self.SelectedElement):

   319

                            self.SelectedElement.SetSelectedSegment(None)

   320

                        else:

   321

                            self.SelectedElement.SetSelected(False)

   322

                    else:

   323

                        self.SelectedElement = None

   324

                elif element and isinstance(element, Graphic_Group):

   325

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

   326

                        for elt in self.SelectedElement.GetElements():

   327

                            if self.IsWire(elt):

   328

                                elt.SetSelectedSegment(None)

   329

                        self.SelectedElement.SetSelected(False)

   330

                        self.SelectedElement = None

   331

                else:

   332

                    for elt in self.SelectedElement.GetElements():

   333

                        if self.IsWire(elt):

   334

                            elt.SetSelectedSegment(None)

   335

                    self.SelectedElement.SetSelected(False)

   336

                    self.SelectedElement = None

   337

            if element:

   338

                self.SelectedElement = element

   339

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

   340

                self.SelectedElement.Refresh()

   341

            else:

   342

                self.rubberBand.Reset()

   343

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

   344

        event.Skip()

   345

   346

    def OnViewerLeftUp(self, event):

   347

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   348

            Viewer.OnViewerLeftUp(self, event)

   349

        elif self.rubberBand.IsShown():

   350

            if self.Mode == MODE_SELECTION:

   351

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

   352

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

   353

                if len(elements) > 0:

   354

                    self.SelectedElement = Graphic_Group(self)

   355

                    self.SelectedElement.SetElements(elements)

   356

                    self.SelectedElement.SetSelected(True)

   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

            self.SelectedElement.Refresh()

   375

            wx.CallAfter(self.SetCurrentCursor, 0)

   376

        event.Skip()

   377

   378

    def OnViewerRightUp(self, event):

   379

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   380

            Viewer.OnViewerRightUp(self, event)

   381

        else:

   382

            element = self.FindElement(event)

   383

            if element:

   384

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

   385

                    self.SelectedElement.SetSelected(False)

   386

                self.SelectedElement = element

   387

                if self.IsWire(self.SelectedElement):

   388

                    self.SelectedElement.SetSelectedSegment(0)

   389

                else:

   390

                    self.SelectedElement.SetSelected(True)

   391

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

   392

                    self.SelectedElement.Refresh()

   393

                wx.CallAfter(self.SetCurrentCursor, 0)

   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

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

   405

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

   406

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

   407

            keycode = event.GetKeyCode()

   408

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

   409

                if self.IsBlock(self.SelectedElement):

   410

                    self.SelectedElement.Delete()

   411

                elif self.IsWire(self.SelectedElement):

   412

                    self.DeleteWire(self.SelectedElement)

   413

                elif isinstance(self.SelectedElement, Graphic_Group):

   414

                    all_wires = True

   415

                    for element in self.SelectedElement.GetElements():

   416

                        all_wires &= self.IsWire(element)

   417

                    if all_wires:

   418

                        self.DeleteWire(self.SelectedElement)

   419

                    else:

   420

                        self.SelectedElement.Delete()

   421

                self.RefreshBuffer()

   422

                self.RefreshScrollBars()

   423

                self.Refresh(False)

   424

            elif keycode == wx.WXK_LEFT:

   425

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

   426

                    self.Scroll(0, ypos)

   427

                elif event.ControlDown():

   428

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

   429

            elif keycode == wx.WXK_RIGHT:

   430

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

   431

                    self.Scroll(xmax, ypos)

   432

                elif event.ControlDown():

   433

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

   434

            elif keycode == wx.WXK_UP:

   435

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

   436

                    self.Scroll(xpos, 0)

   437

                elif event.ControlDown():

   438

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

   439

            elif keycode == wx.WXK_DOWN:

   440

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

   441

                    self.Scroll(xpos, ymax)

   442

                elif event.ControlDown():

   443

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

   444

            else:

   445

                event.Skip()

   446

   447

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

   448

    #                  Model adding functions from Drop Target

   449

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

   450

   451

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

   452

        if var_type == "BOOL":

   453

            id = self.GetNewId()

   454

            if var_class == INPUT:

   455

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

   456

                width, height = contact.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

                contact.SetPosition(x, y)

   463

                contact.SetSize(width, height)

   464

                self.AddBlock(contact)

   465

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

   466

                self.RefreshContactModel(contact)

   467

            else:

   468

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

   469

                width, height = coil.GetMinSize()

   470

                if scaling is not None:

   471

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

   472

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

   473

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

   474

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

   475

                coil.SetPosition(x, y)

   476

                coil.SetSize(width, height)

   477

                self.AddBlock(coil)

   478

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

   479

                self.RefreshCoilModel(coil)

   480

            self.RefreshBuffer()

   481

            self.RefreshScrollBars()

   482

            self.RefreshVisibleElements()

   483

            self.Refresh(False)

   484

        else:

   485

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

   486

   487

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

   488

    #                          Adding element functions

   489

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

   490

   491

    def AddLadderRung(self):

   492

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

   493

        dialog.SetPreviewFont(self.GetFont())

   494

        varlist = []

   495

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

   496

        if vars:

   497

            for var in vars:

   498

                if var.Class != "Input" and var.Type == "BOOL":

   499

                    varlist.append(var.Name)

   500

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

   501

        if returntype == "BOOL":

   502

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

   503

        dialog.SetVariables(varlist)

   504

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

   505

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

   506

            values = dialog.GetValues()

   507

            startx, starty = LD_OFFSET[0], 0

   508

            if len(self.Rungs) > 0:

   509

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

   510

                starty = bbox.y + bbox.height

   511

            starty += LD_OFFSET[1]

   512

            rung = Graphic_Group(self)

   513

   514

            # Create comment

   515

            id = self.GetNewId()

   516

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

   517

            comment.SetPosition(startx, starty)