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

    27

from plcopen.structures import *

    28

from PLCControler import ITEM_POU

    29

    30

from Dialogs import *

    31

    32

SCROLLBAR_UNIT = 10

    33

WINDOW_BORDER = 10

    34

SCROLL_ZONE = 10

    35

    36

def AppendMenu(parent, help, id, kind, text):

    37

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

    38

        parent.Append(help=help, id=id, kind=kind, text=text)

    39

    else:

    40

        parent.Append(helpString=help, id=id, kind=kind, item=text)

    41

    42

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

    43

#                       Graphic elements Viewer base class

    44

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

    45

    46

# ID Constants for menu items

    47

[ID_FBDVIEWERCONTEXTUALMENUITEMS0, ID_FBDVIEWERCONTEXTUALMENUITEMS1,

    48

 ID_FBDVIEWERCONTEXTUALMENUITEMS2, ID_FBDVIEWERCONTEXTUALMENUITEMS3,

    49

 ID_FBDVIEWERCONTEXTUALMENUITEMS5, ID_FBDVIEWERCONTEXTUALMENUITEMS6,

    50

 ID_FBDVIEWERCONTEXTUALMENUITEMS8, ID_FBDVIEWERCONTEXTUALMENUITEMS9,

    51

 ID_FBDVIEWERCONTEXTUALMENUITEMS11, ID_FBDVIEWERCONTEXTUALMENUITEMS12,

    54

    55

    56

class ViewerDropTarget(wx.TextDropTarget):

    57

    58

    def __init__(self, parent):

    59

        wx.TextDropTarget.__init__(self)

    60

        self.ParentWindow = parent

    61

    62

    def OnDropText(self, x, y, data):

    63

        x, y = self.ParentWindow.CalcUnscrolledPosition(x, y)

    64

        values = eval(data)

    65

        if values[1] == "program":

    66

            message = wx.MessageDialog(self.ParentWindow, "Programs can't be used by other POUs!", "Error", wx.OK|wx.ICON_ERROR)

    67

            message.ShowModal()

    68

            message.Destroy()

    69

        elif values[1] in ["function", "functionBlock", "program"]:

    70

            name, type = self.ParentWindow.Controler.GetCurrentElementEditingType()

    71

            if name == values[0]:

    72

                message = wx.MessageDialog(self.ParentWindow, "\"%s\" can't use itself!"%name, "Error", wx.OK|wx.ICON_ERROR)

    73

                message.ShowModal()

    74

                message.Destroy()

    75

            elif type == "function" and values[1] != "function":

    76

                message = wx.MessageDialog(self.ParentWindow, "Function Blocks can't be used by Functions!", "Error", wx.OK|wx.ICON_ERROR)

    77

                message.ShowModal()

    78

                message.Destroy()

    79

            elif self.ParentWindow.Controler.PouIsUsedBy(name, values[0]):

    80

                message = wx.MessageDialog(self.ParentWindow, "\"%s\" is already used by \"%s\"!"%(name, values[0]), "Error", wx.OK|wx.ICON_ERROR)

    81

                message.ShowModal()

    82

                message.Destroy()

    83

            else:

    84

                blockname = values[2]

    85

                if values[1] != "function" and blockname == "":

    86

                    dialog = wx.TextEntryDialog(self.ParentWindow, "Block name", "Please enter a block name", "", wx.OK|wx.CANCEL|wx.CENTRE)

    87

                    if dialog.ShowModal():

    88

                        blockname = dialog.GetValue()

    89

                    dialog.Destroy()

    90

                id = self.ParentWindow.GetNewId()

    91

                block = FBD_Block(self.ParentWindow, values[0], blockname, id)

    92

                block.SetPosition(x, y)

    93

                width, height = block.GetMinSize()

    94

                block.SetSize(width, height)

    95

                self.ParentWindow.AddBlock(block)

    96

                self.ParentWindow.Controler.AddCurrentElementEditingBlock(id, values[0], blockname)

    97

                self.ParentWindow.RefreshBlockModel(block)

    98

                self.ParentWindow.RefreshBuffer()

    99

                self.ParentWindow.RefreshScrollBars()

   100

                self.ParentWindow.ParentWindow.RefreshEditor()

   101

                self.ParentWindow.Refresh()

   102

        elif values[1] != "location":

   103

            id = self.ParentWindow.GetNewId()

   104

            if values[1] == "Output":

   105

                var_type = OUTPUT

   106

            elif values[1] == "InOut":

   107

                var_type = INPUT

   108

            else:

   109

                var_type = INPUT

   110

            variable = FBD_Variable(self.ParentWindow, var_type, values[0], values[2], id)

   111

            variable.SetPosition(x, y)

   112

            width, height = variable.GetMinSize()

   113

            variable.SetSize(width, height)

   114

            self.ParentWindow.AddBlock(variable)

   115

            self.ParentWindow.Controler.AddCurrentElementEditingVariable(id, var_type)

   116

            self.ParentWindow.RefreshVariableModel(variable)

   117

            self.ParentWindow.RefreshBuffer()

   118

            self.ParentWindow.RefreshScrollBars()

   119

            self.ParentWindow.Refresh()

   120

   121

   122

"""

   123

Class that implements a Viewer based on a wx.ScrolledWindow for drawing and 

   124

manipulating graphic elements

   125

"""

   126

   127

class Viewer(wx.ScrolledWindow):

   128

   129

    if wx.VERSION < (2, 6, 0):

   130

        def Bind(self, event, function, id = None):

   131

            if id is not None:

   132

                event(self, id, function)

   133

            else:

   134

                event(self, function)

   135

   136

    # Create Contextual Menu items

   137

    def _init_coll_ContextualMenu_Items(self, parent):

   138

        # Create menu items

   139

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS0,

   140

              kind=wx.ITEM_RADIO, text=u'No Modifier')

   141

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS1,

   142

              kind=wx.ITEM_RADIO, text=u'Negated')

   143

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS2,

   144

              kind=wx.ITEM_RADIO, text=u'Rising Edge')

   145

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS3,

   146

              kind=wx.ITEM_RADIO, text=u'Falling Edge')

   147

        parent.AppendSeparator()

   148

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS5,

   149

              kind=wx.ITEM_NORMAL, text=u'Add Wire Segment')

   150

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS6,

   151

              kind=wx.ITEM_NORMAL, text=u'Delete Wire Segment')

   152

        parent.AppendSeparator()

   153

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS8,

   154

              kind=wx.ITEM_NORMAL, text=u'Add Divergence Branch')

   155

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS9,

   156

              kind=wx.ITEM_NORMAL, text=u'Delete Divergence Branch')

   157

        parent.AppendSeparator()

   158

        AppendMenu(parent, help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS11,

   164

              kind=wx.ITEM_NORMAL, text=u'Edit Block')

   166

              kind=wx.ITEM_NORMAL, text=u'Delete')

   167

        # Link menu event to corresponding called functions

   168

        self.Bind(wx.EVT_MENU, self.OnNoModifierMenu,

   169

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS0)

   170

        self.Bind(wx.EVT_MENU, self.OnNegatedMenu,

   171

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS1)

   172

        self.Bind(wx.EVT_MENU, self.OnRisingEdgeMenu,

   173

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS2)

   174

        self.Bind(wx.EVT_MENU, self.OnFallingEdgeMenu,

   175

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS3)

   176

        self.Bind(wx.EVT_MENU, self.OnAddSegmentMenu,

   177

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS5)

   178

        self.Bind(wx.EVT_MENU, self.OnDeleteSegmentMenu,

   179

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS6)

   180

        self.Bind(wx.EVT_MENU, self.OnAddBranchMenu,

   181

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS8)

   182

        self.Bind(wx.EVT_MENU, self.OnDeleteBranchMenu,

   183

              id=ID_FBDVIEWERCONTEXTUALMENUITEMS9)

   188

        self.Bind(wx.EVT_MENU, self.OnEditBlockMenu,

   190

        self.Bind(wx.EVT_MENU, self.OnDeleteMenu,

   192

   193

    # Create and initialize Contextual Menu

   194

    def _init_menus(self):

   195

        self.ContextualMenu = wx.Menu(title='')

   196

   197

        self._init_coll_ContextualMenu_Items(self.ContextualMenu)

   198

   199

    # Create a new Viewer

   200

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

   201

        wx.ScrolledWindow.__init__(self, parent, pos=wx.Point(0, 0), size=wx.Size(0, 0), 

   202

            style=wx.SUNKEN_BORDER | wx.HSCROLL | wx.VSCROLL)

   203

        self._init_menus()

   204

        # Adding a rubberband to Viewer

   205

        self.rubberBand = RubberBand(drawingSurface=self)

   206

        self.SetBackgroundColour(wx.Colour(255,255,255))

   207

        self.ResetView()

   208

        self.Scaling = None

   209

        #self.Scaling = (8, 8)

   210

        self.DrawGrid = True

   211

        self.current_id = 0

   212

   213

        # Initialize Block, Wire and Comment numbers

   214

        self.block_id = self.wire_id = self.comment_id = 0

   215

   216

        # Initialize Viewer mode to Selection mode

   217

        self.Mode = MODE_SELECTION

   218

        self.SavedMode = False

   219

        self.CurrentLanguage = "FBD"

   220

   221

        self.ParentWindow = window

   222

        self.Controler = controler

   223

   224

        self.SetDropTarget(ViewerDropTarget(self))

   225

   226

        # Link Viewer event to corresponding methods

   227

        self.Bind(wx.EVT_PAINT, self.OnPaint)

   228

        self.Bind(wx.EVT_LEFT_DOWN, self.OnViewerLeftDown)

   229

        self.Bind(wx.EVT_LEFT_UP, self.OnViewerLeftUp)

   230

        self.Bind(wx.EVT_LEFT_DCLICK, self.OnViewerLeftDClick)

   231

        self.Bind(wx.EVT_RIGHT_UP, self.OnViewerRightUp)

   232

        self.Bind(wx.EVT_MOTION, self.OnViewerMotion)

   233

        self.Bind(wx.EVT_CHAR, self.OnChar)

   234

        if wx.VERSION < (2, 7, 0):

   235

            self.Bind(wx.EVT_SCROLLWIN, self.OnMoveWindow)

   236

            self.Bind(wx.EVT_SIZE, self.OnMoveWindow)

   237

   238

    # Returns a new id

   239

    def GetNewId(self):

   240

        self.current_id += 1

   241

        return self.current_id

   242

   243

    # Destructor

   244

    def __del__(self):

   245

        self.ResetView()

   246

   247

    def GetLogicalDC(self, buffered=False):

   248

        if buffered:

   249

            dc = wx.BufferedPaintDC(self)

   250

        else:

   251

            dc = wx.ClientDC(self)

   252

        if wx.Platform != '__WXMSW__':

   253

            dc.SetFont(wx.NORMAL_FONT)

   254

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

   255

            self.DoPrepareDC(dc)

   256

        else:

   257

            self.PrepareDC(dc)

   258

        return dc

   259

   260

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

   261

#                         Element management functions

   262

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

   263

   264

    def AddBlock(self, block):

   265

        self.block_id += 1

   266

        self.Blocks[block] = self.block_id

   267

   268

    def AddWire(self, wire):

   269

        self.wire_id += 1

   270

        self.Wires[wire] = self.wire_id

   271

   272

    def AddComment(self, comment):

   273

        self.comment_id += 1

   274

        self.Comments[comment] = self.comment_id

   275

   276

    def IsBlock(self, block):

   277

        return self.Blocks.get(block, False)

   278

   279

    def IsWire(self, wire):

   280

        return self.Wires.get(wire, False)

   281

   282

    def IsComment(self, comment):

   283

        return self.Comments.get(comment, False)

   284

   285

    def RemoveBlock(self, block):

   286

        self.Blocks.pop(block)

   287

   288

    def RemoveWire(self, wire):

   289

        self.Wires.pop(wire)

   290

   291

    def RemoveComment(self, comment):

   292

        self.Comments.pop(comment)

   293

   294

    def GetElements(self, sort_blocks=False, sort_wires=False, sort_comments=False):

   295

        blocks = self.Blocks.keys()

   296

        wires = self.Wires.keys()

   297

        comments = self.Comments.keys()

   298

        if sort_blocks:

   299

            blocks.sort(lambda x,y:self.Blocks[x].__cmp__(self.Blocks[y]))

   300

        if sort_wires:

   301

            wires.sort(lambda x,y:self.Wires[x].__cmp__(self.Wires[y]))

   302

        if sort_comments:

   303

            comments.sort(lambda x,y:self.Comments[x].__cmp__(self.Comments[y]))

   304

        return blocks + wires + comments

   305

   306

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

   307

#                              Reset functions

   308

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

   309

   310

    # Resets Viewer lists

   311

    def ResetView(self):

   312

        self.Blocks = {}

   313

        self.Wires = {}

   314

        self.Comments = {}

   315

        self.SelectedElement = None

   316

   317

    # Verify wires type compatibility

   318

    def VerifyVariableTypeCompatibility(self):

   319

        to_delete = []

   320

        for wire in self.Wires:

   321

            if not wire.IsConnectedCompatible():

   322

                to_delete.append(wire)

   323

        for wire in to_delete:

   324

            wire.Delete()

   325

   326

    # Remove all elements

   327

    def CleanView(self):

   328

        for block in self.Blocks.keys():

   329

            block.Clean()

   330

        self.ResetView()

   331

   332

    # Changes Viewer mode

   333

    def SetMode(self, mode):

   334

        if self.Mode != mode or mode == MODE_SELECTION:

   335

            self.Mode = mode

   336

            self.SavedMode = False

   337

        else:

   338

            self.SavedMode = True

   339

        # Reset selection

   340

        if self.Mode != MODE_SELECTION and self.SelectedElement:

   341

            self.SelectedElement.SetSelected(False)

   342

            self.SelectedElement = None

   343

            self.Refresh(False)

   344

   345

    # Return current drawing mode

   346

    def GetDrawingMode(self):

   347

        return self.ParentWindow.GetDrawingMode()

   348

   349

    # Buffer the last model state

   350

    def RefreshBuffer(self):

   351

        self.Controler.BufferProject()

   352

        self.ParentWindow.RefreshTitle()

   353

        self.ParentWindow.RefreshEditMenu()

   354

   355

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

   356

#                          Refresh functions

   357

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

   358

   359

    def ResetBuffer(self):

   360

        pass

   361

   362

    # Refresh Viewer elements

   363

    def RefreshView(self):

   364

        self.current_id = 0

   365

        # Start by reseting Viewer

   366

        self.ResetView()

   367

        instance = True

   368

        # List of ids of already loaded blocks

   369

        ids = []

   370

        # Load Blocks until they are all loaded

   371

        while instance:

   372

            instance = self.Controler.GetCurrentElementEditingInstanceInfos(exclude=ids)

   373

            if instance:

   374

                self.loadInstance(instance, ids)

   375

        self.RefreshScrollBars()

   376

        self.Refresh(False)

   377

   378

    def RefreshScrollBars(self):

   379

        xstart, ystart = self.GetViewStart()

   380

        window_size = self.GetClientSize()

   381

        maxx = maxy = 0

   382

        for element in self.GetElements():

   383

            posx, posy = element.GetPosition()

   384

            width, height = element.GetSize()

   385

            maxx = max(maxx, posx + width)

   386

            maxy = max(maxy, posy + height)

   387

        maxx = max(maxx + WINDOW_BORDER, xstart * SCROLLBAR_UNIT + window_size[0])

   388

        maxy = max(maxy + WINDOW_BORDER, ystart * SCROLLBAR_UNIT + window_size[1])

   389

        if self.rubberBand.IsShown():

   390

            extent = self.rubberBand.GetCurrentExtent()

   391

            maxx = max(maxx, extent.x + extent.width)

   392

            maxy = max(maxy, extent.y + extent.height)

   393

        self.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, 

   394

            maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, xstart, ystart, True)

   395

   396

    # Load instance from given informations

   397

    def loadInstance(self, instance, ids):

   398

        ids.append(instance["id"])

   399

        self.current_id = max(self.current_id, instance["id"]) 

   400

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

   402

            variable.SetPosition(instance["x"], instance["y"])

   403

            variable.SetSize(instance["width"], instance["height"])

   404

            self.AddBlock(variable)

   405

            connectors = variable.GetConnectors()

   406

            connectors["output"].SetPosition(wx.Point(*instance["connector"]["position"]))

   407

            if instance["connector"]["negated"]:

   408

                connectors["output"].SetNegated(True)

   409

            if instance["connector"]["edge"]:

   410

                connectors["output"].SetEdge(instance["connector"]["edge"])

   411

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

   413

            variable.SetPosition(instance["x"], instance["y"])

   414

            variable.SetSize(instance["width"], instance["height"])

   415

            self.AddBlock(variable)

   416

            connectors = variable.GetConnectors()

   417

            connectors["input"].SetPosition(wx.Point(*instance["connector"]["position"]))

   418

            if instance["connector"]["negated"]:

   419

                connectors["input"].SetNegated(True)

   420

            if instance["connector"]["edge"]:

   421

                connectors["input"].SetEdge(instance["connector"]["edge"])

   422

            self.CreateWires(connectors["input"], instance["connector"]["links"], ids)

   423

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

   425

            variable.SetPosition(instance["x"], instance["y"])

   426

            variable.SetSize(instance["width"], instance["height"])

   427

            self.AddBlock(variable)

   428

            connectors = variable.GetConnectors()

   429

            connectors["output"].SetPosition(wx.Point(*instance["connectors"]["output"]["position"]))

   430

            connectors["input"].SetPosition(wx.Point(*instance["connectors"]["input"]["position"]))

   431

            if instance["connectors"]["output"]["negated"]:

   432

                connectors["output"].SetNegated(True)

   433

            if instance["connectors"]["output"]["edge"]:

   434

                connectors["output"].SetEdge(instance["connectors"]["output"]["edge"])

   435

            if instance["connectors"]["input"]["negated"]:

   436

                connectors["input"].SetNegated(True)

   437

            if instance["connectors"]["input"]["edge"]:

   438

                connectors["input"].SetEdge(instance["connectors"]["input"]["edge"])

   439

            self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)

   440

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

   441

            connection = FBD_Connector(self, CONTINUATION, instance["name"], instance["id"])

   442

            connection.SetPosition(instance["x"], instance["y"])

   443

            connection.SetSize(instance["width"], instance["height"])

   444

            self.AddBlock(connection)

   445

            connector = connection.GetConnector()

   446

            connector.SetPosition(wx.Point(*instance["connector"]["position"]))

   447

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

   448

            connection = FBD_Connector(self, CONNECTOR, instance["name"], instance["id"])

   449

            connection.SetPosition(instance["x"], instance["y"])

   450

            connection.SetSize(instance["width"], instance["height"])

   451

            self.AddBlock(connection)

   452

            connector = connection.GetConnector()

   453

            connector.SetPosition(wx.Point(*instance["connector"]["position"]))

   454

            self.CreateWires(connector, instance["connector"]["links"], ids)

   455

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

   456

            comment = Comment(self, instance["content"], instance["id"])

   457

            comment.SetPosition(instance["x"], instance["y"])

   458

            comment.SetSize(instance["width"], instance["height"])

   459

            self.AddComment(comment)

   460

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

   461

            leftpowerrail = LD_PowerRail(self, LEFTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])

   462

            leftpowerrail.SetPosition(instance["x"], instance["y"])

   463

            leftpowerrail.SetSize(instance["width"], instance["height"])

   464

            self.AddBlock(leftpowerrail)

   465

            connectors = leftpowerrail.GetConnectors()

   466

            for i, connector in enumerate(instance["connectors"]):

   467

                connectors[i].SetPosition(wx.Point(*connector["position"]))

   468

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

   469

            rightpowerrail = LD_PowerRail(self, RIGHTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])

   470

            rightpowerrail.SetPosition(instance["x"], instance["y"])

   471

            rightpowerrail.SetSize(instance["width"], instance["height"])

   472

            self.AddBlock(rightpowerrail)

   473

            connectors = rightpowerrail.GetConnectors()

   474

            for i, connector in enumerate(instance["connectors"]):

   475

                connectors[i].SetPosition(wx.Point(*connector["position"]))

   476

                self.CreateWires(connectors[i], connector["links"], ids)

   477

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

   478

            if instance["negated"]:

   479

                negated = instance["negated"]

   480

            else:

   481

                negated = False

   482

            if instance["edge"]:

   483

                edge = instance["edge"]

   484

            else:

   485

                edge = "none"

   486

            if negated and edge == "none":

   487

                contact_type = CONTACT_REVERSE

   488

            elif not negated and edge == "rising":

   489

                contact_type = CONTACT_RISING

   490

            elif not negated and edge == "falling":

   491

                contact_type = CONTACT_FALLING

   492

            else:

   493

                contact_type = CONTACT_NORMAL

   494

            contact = LD_Contact(self, contact_type, instance["name"], instance["id"])

   495

            contact.SetPosition(instance["x"], instance["y"])

   496

            self.AddBlock(contact)

   497

            connectors = contact.GetConnectors()

   498