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

    26

from __future__ import absolute_import

    27

from __future__ import division

    28

    29

import wx

    30

from six.moves import xrange

    31

    32

from editors.Viewer import *

    33

    34

    35

def ExtractNextBlocks(block, block_list):

    36

    current_list = [block]

    37

    while len(current_list) > 0:

    38

        next_list = []

    39

        for current in current_list:

    40

            connectors = current.GetConnectors()

    41

            input_connectors = []

    42

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

    43

                input_connectors = connectors

    44

            else:

    45

                if "inputs" in connectors:

    46

                    input_connectors = connectors["inputs"]

    47

                if "input" in connectors:

    48

                    input_connectors = [connectors["input"]]

    49

            for connector in input_connectors:

    50

                for wire, _handle in connector.GetWires():

    51

                    next = wire.EndConnected.GetParentBlock()

    52

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

    53

                        block_list.append(next)

    54

                        next_list.append(next)

    55

        current_list = next_list

    56

    57

    58

def CalcBranchSize(elements, stops):

    59

    branch_size = 0

    60

    stop_list = stops

    61

    for stop in stops:

    62

        ExtractNextBlocks(stop, stop_list)

    63

    element_tree = {}

    64

    for element in elements:

    65

        if element not in element_tree:

    66

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

    67

            GenerateTree(element, element_tree, stop_list)

    68

        elif element_tree[element]:

    69

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

    70

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

    71

    for element, values in element_tree.items():

    72

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

    73

            removed = []

    74

            for child in values["children"]:

    75

                if child != "stop":

    76

                    # if child in elements:

    77

                    #     RemoveElement(child, element_tree)

    78

                    #     removed.append(child)

    79

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

    80

                        if element not in remove_stops["stop"]:

    81

                            remove_stops["stop"].append(element)

    82

                        if child not in remove_stops["start"]:

    83

                            remove_stops["start"].append(child)

    84

            for child in removed:

    85

                values["children"].remove(child)

    86

    for element in remove_stops["start"]:

    87

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

    88

    for element in remove_stops["stop"]:

    89

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

    90

    for element, values in element_tree.items():

    91

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

    92

            CalcWeight(element, element_tree)

    93

            if values["weight"]:

    94

                branch_size += values["weight"]

    95

            else:

    96

                return 1

    97

    return branch_size

    98

    99

   100

def RemoveElement(remove, element_tree):

   101

    if remove in element_tree and element_tree[remove]:

   102

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

   103

            if child != "stop":

   104

                RemoveElement(child, element_tree)

   105

        element_tree.pop(remove)

   106

#        element_tree[remove] = None

   107

   108

   109

def GenerateTree(element, element_tree, stop_list):

   110

    if element in element_tree:

   111

        connectors = element.GetConnectors()

   112

        input_connectors = []

   113

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

   114

            input_connectors = connectors

   115

        else:

   116

            if "inputs" in connectors:

   117

                input_connectors = connectors["inputs"]

   118

            if "input" in connectors:

   119

                input_connectors = [connectors["input"]]

   120

        for connector in input_connectors:

   121

            for wire, _handle in connector.GetWires():

   122

                next = wire.EndConnected.GetParentBlock()

   123

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

   124

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

   125

                    #     RemoveElement(remove, element_tree)

   126

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

   127

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

   128

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

   129

                #     element_tree[next] = None

   130

                elif next not in element_tree or element_tree[next]:

   131

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

   132

                    if next in element_tree:

   133

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

   134

                    else:

   135

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

   136

                        GenerateTree(next, element_tree, stop_list)

   137

   138

   139

def CalcWeight(element, element_tree):

   140

    weight = 0

   141

    parts = None

   142

    if element in element_tree:

   143

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

   144

            if parent == "start":

   145

                weight += 1

   146

            elif parent in element_tree:

   147

                if not parts:

   148

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

   149

                else:

   150

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

   151

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

   152

                    CalcWeight(parent, element_tree)

   153

                if element_tree[parent]["weight"]:

   154

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

   155

                else:

   156

                    element_tree[element]["weight"] = None

   157

                    return

   158

            else:

   159

                element_tree[element]["weight"] = None

   160

                return

   161

        if not parts:

   162

            parts = 1

   163

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

   164

   165

   166

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

   167

#                     Ladder Diagram Graphic elements Viewer class

   168

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

   169

   170

   171

class LD_Viewer(Viewer):

   172

    """

   173

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

   174

    """

   175

   176

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

   177

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

   178

        self.Rungs = []

   179

        self.RungComments = []

   180

        self.CurrentLanguage = "LD"

   181

   182

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

   183

    #                          Refresh functions

   184

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

   185

   186

    def ResetView(self):

   187

        self.Rungs = []

   188

        self.RungComments = []

   189

        Viewer.ResetView(self)

   190

   191

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

   192

        Viewer.RefreshView(self, variablepanel, selection)

   193

        if self.GetDrawingMode() != FREEDRAWING_MODE:

   194

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

   195

                bbox = rung.GetBoundingBox()

   196

                if i < len(self.RungComments):

   197

                    if self.RungComments[i]:

   198

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

   199

                        if pos[1] > bbox.y:

   200

                            self.RungComments.insert(i, None)

   201

                else:

   202

                    self.RungComments.insert(i, None)

   203

   204

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

   205

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

   206

        if self.GetDrawingMode() != FREEDRAWING_MODE:

   207

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

   208

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

   209

                rung = Graphic_Group(self)

   210

                rung.SelectElement(element)

   211

                self.Rungs.append(rung)

   212

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

   213

                rungs = []

   214

                for connector in instance["inputs"]:

   215

                    for link in connector["links"]:

   216

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

   217

                        rung = self.FindRung(connected)

   218

                        if rung not in rungs:

   219

                            rungs.append(rung)

   220

                if len(rungs) > 1:

   221

                    raise ValueError(

   222

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

   223

                        % instance["id"])

   224

   225

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

   226

                element_connectors = element.GetConnectors()

   227

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

   228

                for connector in element_connectors["inputs"]:

   229

                    for wire, _num in connector.GetWires():

   230

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

   231

                wx.CallAfter(self.RefreshPosition, element)

   232

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

   233

                rungs = []

   234

                for link in instance["inputs"][0]["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(

   241

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

   242

                        % instance["id"])

   243

   244

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

   245

                element_connectors = element.GetConnectors()

   246

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

   247

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

   248

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

   249

                wx.CallAfter(self.RefreshPosition, element)

   250

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

   251

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

   252

                pos = element.GetPosition()

   253

                i = 0

   254

                inserted = False

   255

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

   256

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

   257

                    if pos[1] < ipos[1]:

   258

                        self.RungComments.insert(i, element)

   259

                        inserted = True

   260

                    i += 1

   261

                if not inserted:

   262

                    self.RungComments.append(element)

   263

   264

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

   265

    #                          Search Element functions

   266

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

   267

   268

    def FindRung(self, element):

   269

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

   270

            if rung.IsElementIn(element):

   271

                return i

   272

        return None

   273

   274

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

   275

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   276

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

   277

   278

        dc = self.GetLogicalDC()

   279

        pos = event.GetLogicalPosition(dc)

   280

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

   281

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

   282

                return self.SelectedElement

   283

        elements = []

   284

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

   285

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

   286

                elements.append(element)

   287

        if len(elements) == 1:

   288

            return elements[0]

   289

        elif len(elements) > 1:

   290

            group = Graphic_Group(self)

   291

            for element in elements:

   292

                if self.IsBlock(element):

   293

                    return element

   294

                group.SelectElement(element)

   295

            return group

   296

        return None

   297

   298

    def SearchElements(self, bbox):

   299

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   300

            return Viewer.SearchElements(self, bbox)

   301

   302

        elements = []

   303

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

   304

            if element.IsInSelection(bbox):

   305

                elements.append(element)

   306

        return elements

   307

   308

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

   309

    #                          Mouse event functions

   310

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

   311

   312

    def OnViewerLeftDown(self, event):

   313

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   314

            Viewer.OnViewerLeftDown(self, event)

   315

        elif self.Mode == MODE_SELECTION:

   316

            element = self.FindElement(event)

   317

            if self.SelectedElement:

   318

                if not isinstance(self.SelectedElement, Graphic_Group):

   319

                    if self.SelectedElement != element:

   320

                        if self.IsWire(self.SelectedElement):

   321

                            self.SelectedElement.SetSelectedSegment(None)

   322

                        else:

   323

                            self.SelectedElement.SetSelected(False)

   324

                    else:

   325

                        self.SelectedElement = None

   326

                elif element and isinstance(element, Graphic_Group):

   327

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

   328

                        for elt in self.SelectedElement.GetElements():

   329

                            if self.IsWire(elt):

   330

                                elt.SetSelectedSegment(None)

   331

                        self.SelectedElement.SetSelected(False)

   332

                        self.SelectedElement = None

   333

                else:

   334

                    for elt in self.SelectedElement.GetElements():

   335

                        if self.IsWire(elt):

   336

                            elt.SetSelectedSegment(None)

   337

                    self.SelectedElement.SetSelected(False)

   338

                    self.SelectedElement = None

   339

            if element:

   340

                self.SelectedElement = element

   341

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

   342

                self.SelectedElement.Refresh()

   343

            else:

   344

                self.rubberBand.Reset()

   345

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

   346

        event.Skip()

   347

   348

    def OnViewerLeftUp(self, event):

   349

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   350

            Viewer.OnViewerLeftUp(self, event)

   351

        elif self.rubberBand.IsShown():

   352

            if self.Mode == MODE_SELECTION:

   353

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

   354

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

   355

                if len(elements) > 0:

   356

                    self.SelectedElement = Graphic_Group(self)

   357

                    self.SelectedElement.SetElements(elements)

   358

                    self.SelectedElement.SetSelected(True)

   359

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

   360

            dc = self.GetLogicalDC()

   361

            if not isinstance(self.SelectedElement, Graphic_Group):

   362

                if self.IsWire(self.SelectedElement):

   363

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

   364

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

   365

                        self.SelectedElement.SetSelectedSegment(result[0])

   366

                else:

   367

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

   368

            else:

   369

                for element in self.SelectedElement.GetElements():

   370

                    if self.IsWire(element):

   371

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

   372

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

   373

                            element.SetSelectedSegment(result[0])

   374

                    else:

   375

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

   376

            self.SelectedElement.Refresh()

   377

            wx.CallAfter(self.SetCurrentCursor, 0)

   378

        event.Skip()

   379

   380

    def OnViewerRightUp(self, event):

   381

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   382

            Viewer.OnViewerRightUp(self, event)

   383

        else:

   384

            element = self.FindElement(event)

   385

            if element:

   386

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

   387

                    self.SelectedElement.SetSelected(False)

   388

                self.SelectedElement = element

   389

                if self.IsWire(self.SelectedElement):

   390

                    self.SelectedElement.SetSelectedSegment(0)

   391

                else:

   392

                    self.SelectedElement.SetSelected(True)

   393

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

   394

                    self.SelectedElement.Refresh()

   395

                wx.CallAfter(self.SetCurrentCursor, 0)

   396

        event.Skip()

   397

   398

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

   399

    #                          Keyboard event functions

   400

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

   401

   402

    def OnChar(self, event):

   403

        if self.GetDrawingMode() == FREEDRAWING_MODE:

   404

            Viewer.OnChar(self, event)

   405

        else:

   406

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

   407

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

   408

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

   409

            keycode = event.GetKeyCode()

   410

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

   411

                if self.IsBlock(self.SelectedElement):

   412

                    self.SelectedElement.Delete()

   413

                elif self.IsWire(self.SelectedElement):

   414

                    self.DeleteWire(self.SelectedElement)

   415

                elif isinstance(self.SelectedElement, Graphic_Group):

   416

                    all_wires = True

   417

                    for element in self.SelectedElement.GetElements():

   418

                        all_wires &= self.IsWire(element)

   419

                    if all_wires:

   420

                        self.DeleteWire(self.SelectedElement)

   421

                    else:

   422

                        self.SelectedElement.Delete()

   423

                self.RefreshBuffer()

   424

                self.RefreshScrollBars()

   425

                self.Refresh(False)

   426

            elif keycode == wx.WXK_LEFT:

   427

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

   428

                    self.Scroll(0, ypos)

   429

                elif event.ControlDown():

   430

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

   431

            elif keycode == wx.WXK_RIGHT:

   432

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

   433

                    self.Scroll(xmax, ypos)

   434

                elif event.ControlDown():

   435

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

   436

            elif keycode == wx.WXK_UP:

   437

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

   438

                    self.Scroll(xpos, 0)

   439

                elif event.ControlDown():

   440

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

   441

            elif keycode == wx.WXK_DOWN:

   442

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

   443

                    self.Scroll(xpos, ymax)

   444

                elif event.ControlDown():

   445

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

   446

            else:

   447

                event.Skip()

   448

   449

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

   450

    #                  Model adding functions from Drop Target

   451

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

   452

   453

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

   454

        if var_type == "BOOL":

   455

            id = self.GetNewId()

   456

            if var_class == INPUT:

   457

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

   458

                width, height = contact.GetMinSize()

   459

                if scaling is not None:

   460

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

   461

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

   462

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

   463

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

   464

                contact.SetPosition(x, y)

   465

                contact.SetSize(width, height)

   466

                self.AddBlock(contact)

   467

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

   468

                self.RefreshContactModel(contact)

   469

            else:

   470

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

   471

                width, height = coil.GetMinSize()

   472

                if scaling is not None:

   473

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

   474

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

   475

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

   476

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

   477

                coil.SetPosition(x, y)

   478

                coil.SetSize(width, height)

   479

                self.AddBlock(coil)

   480

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

   481

                self.RefreshCoilModel(coil)

   482

            self.RefreshBuffer()

   483

            self.RefreshScrollBars()

   484

            self.RefreshVisibleElements()

   485

            self.Refresh(False)

   486

        else:

   487

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

   488

   489

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

   490

    #                          Adding element functions

   491

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

   492

   493

    def AddLadderRung(self):

   494

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

   495

        dialog.SetPreviewFont(self.GetFont())

   496

        varlist = []

   497

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

   498

        if vars:

   499

            for var in vars:

   500

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

   501

                    varlist.append(var.Name)

   502

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

   503

        if returntype == "BOOL":

   504

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

   505

        dialog.SetVariables(varlist)

   506

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

   507

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

   508

            values = dialog.GetValues()

   509

            startx, starty = LD_OFFSET[0], 0

   510

            if len(self.Rungs) > 0:

   511

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

   512

                starty = bbox.y + bbox.height

   513

            starty += LD_OFFSET[1]

   514

            rung = Graphic_Group(self)

   515