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) 2012: 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

from types import TupleType

    26

from time import time as gettime

    27

import numpy

    28

    29

import wx

    30

    31

import matplotlib

    32

matplotlib.use('WX')

    33

import matplotlib.pyplot

    34

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    35

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    36

from matplotlib.backends.backend_agg import FigureCanvasAgg

    37

from mpl_toolkits.mplot3d import Axes3D

    38

    39

from editors.DebugViewer import REFRESH_PERIOD

    40

    41

from DebugVariableItem import DebugVariableItem

    42

from DebugVariableViewer import *

    43

from GraphButton import GraphButton

    44

    45

# Graph variable display type

    46

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    47

    48

# Canvas height

    49

[SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI] = [0, 100, 200]

    50

    51

CANVAS_BORDER = (20., 10.) # Border height on at bottom and top of graph

    52

CANVAS_PADDING = 8.5       # Border inside graph where no label is drawn

    53

VALUE_LABEL_HEIGHT = 17.   # Height of variable label in graph

    54

AXES_LABEL_HEIGHT = 12.75  # Height of variable value in graph

    55

    56

# Colors used cyclically for graph curves

    57

COLOR_CYCLE = ['r', 'b', 'g', 'm', 'y', 'k']

    58

# Color for graph cursor

    59

CURSOR_COLOR = '#800080'

    60

    61

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

    62

#                   Debug Variable Graphic Viewer Drop Target

    63

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

    64

    65

"""

    66

Class that implements a custom drop target class for Debug Variable Graphic

    67

Viewer

    68

"""

    69

    70

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

    71

    72

    def __init__(self, parent, window):

    73

        """

    74

        Constructor

    75

        @param parent: Reference to Debug Variable Graphic Viewer

    76

        @param window: Reference to the Debug Variable Panel

    77

        """

    78

        wx.TextDropTarget.__init__(self)

    79

        self.ParentControl = parent

    80

        self.ParentWindow = window

    81

    82

    def __del__(self):

    83

        """

    84

        Destructor

    85

        """

    86

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

    87

        # Panel

    88

        self.ParentControl = None

    89

        self.ParentWindow = None

    90

    91

    def OnDragOver(self, x, y, d):

    92

        """

    93

        Function called when mouse is dragged over Drop Target

    94

        @param x: X coordinate of mouse pointer

    95

        @param y: Y coordinate of mouse pointer

    96

        @param d: Suggested default for return value

    97

        """

    98

        # Signal parent that mouse is dragged over

    99

        self.ParentControl.OnMouseDragging(x, y)

   100

   101

        return wx.TextDropTarget.OnDragOver(self, x, y, d)

   102

   103

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

   104

        """

   105

        Function called when mouse is released in Drop Target

   106

        @param x: X coordinate of mouse pointer

   107

        @param y: Y coordinate of mouse pointer

   108

        @param data: Text associated to drag'n drop

   109

        """

   110

        # Signal Debug Variable Panel to reset highlight

   111

        self.ParentWindow.ResetHighlight()

   112

   113

        message = None

   114

   115

        # Check that data is valid regarding DebugVariablePanel

   116

        try:

   117

            values = eval(data)

   118

            if not isinstance(values, TupleType):

   119

                raise ValueError

   120

        except:

   121

            message = _("Invalid value \"%s\" for debug variable")%data

   122

            values = None

   123

   124

        # Display message if data is invalid

   125

        if message is not None:

   126

            wx.CallAfter(self.ShowMessage, message)

   127

   128

        # Data contain a reference to a variable to debug

   129

        elif values[1] == "debug":

   130

            target_idx = self.ParentControl.GetIndex()

   131

   132

            # If mouse is dropped in graph canvas bounding box and graph is

   133

            # not 3D canvas, graphs will be merged

   134

            rect = self.ParentControl.GetAxesBoundingBox()

   135

            if not self.ParentControl.Is3DCanvas() and rect.InsideXY(x, y):

   136

                # Default merge type is parallel

   137

                merge_type = GRAPH_PARALLEL

   138

   139

                # If mouse is dropped in left part of graph canvas, graph

   140

                # wall be merged orthogonally

   141

                merge_rect = wx.Rect(rect.x, rect.y, 

   142

                                     rect.width / 2., rect.height)

   143

                if merge_rect.InsideXY(x, y):

   144

                    merge_type = GRAPH_ORTHOGONAL

   145

   146

                # Merge graphs

   147

                wx.CallAfter(self.ParentWindow.MergeGraphs, 

   148

                             values[0], target_idx, 

   149

                             merge_type, force=True)

   150

   151

            else:

   152

                width, height = self.ParentControl.GetSize()

   153

   154

                # Get Before which Viewer the variable has to be moved or added

   155

                # according to the position of mouse in Viewer.

   156

                if y > height / 2:

   157

                    target_idx += 1

   158

   159

                # Drag'n Drop is an internal is an internal move inside Debug

   160

                # Variable Panel 

   161

                if len(values) > 2 and values[2] == "move":

   162

                    self.ParentWindow.MoveValue(values[0], 

   163

                                                target_idx)

   164

   165

                # Drag'n Drop was initiated by another control of Beremiz

   166

                else:

   167

                    self.ParentWindow.InsertValue(values[0], 

   168

                                                  target_idx, 

   169

                                                  force=True)

   170

   171

    def OnLeave(self):

   172

        """

   173

        Function called when mouse is leave Drop Target

   174

        """

   175

        # Signal Debug Variable Panel to reset highlight

   176

        self.ParentWindow.ResetHighlight()

   177

        return wx.TextDropTarget.OnLeave(self)

   178

   179

    def ShowMessage(self, message):

   180

        """

   181

        Show error message in Error Dialog

   182

        @param message: Error message to display

   183

        """

   184

        dialog = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   185

        dialog.ShowModal()

   186

        dialog.Destroy()

   187

   188

   189

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

   190

#                      Debug Variable Graphic Viewer Class

   191

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

   192

   193

"""

   194

Class that implements a Viewer that display variable values as a graphs

   195

"""

   196

   197

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   198

   199

    def __init__(self, parent, window, items, graph_type):

   200

        """

   201

        Constructor

   202

        @param parent: Parent wx.Window of DebugVariableText

   203

        @param window: Reference to the Debug Variable Panel

   204

        @param items: List of DebugVariableItem displayed by Viewer

   205

        @param graph_type: Graph display type (Parallel or orthogonal)

   206

        """

   207

        DebugVariableViewer.__init__(self, window, items)

   208

   209

        self.GraphType = graph_type        # Graph type display

   210

        self.CursorTick = None             # Tick of the graph cursor

   211

   212

        # Mouse position when start dragging

   213

        self.MouseStartPos = None

   214

        # Tick when moving tick start

   215

        self.StartCursorTick = None

   216

        # Canvas size when starting to resize canvas

   217

        self.CanvasStartSize = None        

   218

   219

        # List of current displayed contextual buttons

   220

        self.ContextualButtons = []

   221

        # Reference to item for which contextual buttons was displayed

   222

        self.ContextualButtonsItem = None

   223

   224

        # Create figure for drawing graphs

   225

        self.Figure = matplotlib.figure.Figure(facecolor='w')

   226

        # Defined border around figure in canvas

   227

        self.Figure.subplotpars.update(top=0.95, left=0.1, 

   228

                                       bottom=0.1, right=0.95)

   229

   230

        FigureCanvas.__init__(self, parent, -1, self.Figure)

   231

        self.SetWindowStyle(wx.WANTS_CHARS)

   232

        self.SetBackgroundColour(wx.WHITE)

   233

   234

        # Bind wx events

   235

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

   236

        self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)

   237

        self.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)

   238

        self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)

   239

        self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)

   240

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

   241

   242

        # Set canvas min size

   243

        canvas_size = self.GetCanvasMinSize()

   244

        self.SetMinSize(canvas_size)

   245

   246

        # Define Viewer drop target

   247

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   248

   249

        # Connect matplotlib events

   250

        self.mpl_connect('button_press_event', self.OnCanvasButtonPressed)

   251

        self.mpl_connect('motion_notify_event', self.OnCanvasMotion)

   252

        self.mpl_connect('button_release_event', self.OnCanvasButtonReleased)

   253

        self.mpl_connect('scroll_event', self.OnCanvasScroll)

   254

   255

        # Add buttons for changing canvas size with predefined height

   256

        for size, bitmap in zip(

   257

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   258

                ["minimize_graph", "middle_graph", "maximize_graph"]):

   259

            self.Buttons.append(

   260

                    GraphButton(0, 0, bitmap, 

   261

                                self.GetOnChangeSizeButton(size)))

   262

   263

        # Add buttons for exporting graph values to clipboard and close graph

   264

        for bitmap, callback in [

   265

                ("export_graph_mini", self.OnExportGraphButton),

   266

                ("delete_graph", self.OnCloseButton)]:

   267

            self.Buttons.append(GraphButton(0, 0, bitmap, callback))

   268

   269

        # Update graphs elements

   270

        self.ResetGraphics()

   271

        self.RefreshLabelsPosition(canvas_size.height)

   272

   273

    def AddItem(self, item):

   274

        """

   275

        Add an item to the list of items displayed by Viewer

   276

        @param item: Item to add to the list

   277

        """

   278

        DebugVariableViewer.AddItem(self, item)

   279

        self.ResetGraphics()

   280

   281

    def RemoveItem(self, item):

   282

        """

   283

        Remove an item from the list of items displayed by Viewer

   284

        @param item: Item to remove from the list

   285

        """

   286

        DebugVariableViewer.RemoveItem(self, item)

   287

   288

        # If list of items is not empty

   289

        if not self.ItemsIsEmpty():

   290

            # Return to parallel graph if there is only one item

   291

            # especially if it's actually orthogonal

   292

            if len(self.Items) == 1:

   293

                self.GraphType = GRAPH_PARALLEL

   294

            self.ResetGraphics()

   295

   296

    def SetCursorTick(self, cursor_tick):

   297

        """

   298

        Set cursor tick

   299

        @param cursor_tick: Cursor tick

   300

        """

   301

        self.CursorTick = cursor_tick

   302

   303

    def SubscribeAllDataConsumers(self):

   304

        """

   305

        Function that unsubscribe and remove every item that store values of

   306

        a variable that doesn't exist in PLC anymore

   307

        """

   308

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   309

        if not self.ItemsIsEmpty():

   310

            self.ResetGraphics()

   311

   312

    def Is3DCanvas(self):

   313

        """

   314

        Return if Viewer is a 3D canvas

   315

        @return: True if Viewer is a 3D canvas

   316

        """

   317

        return self.GraphType == GRAPH_ORTHOGONAL and len(self.Items) == 3

   318

   319

    def GetButtons(self):

   320

        """

   321

        Return list of buttons defined in Viewer

   322

        @return: List of buttons

   323

        """

   324

        # Add contextual buttons to default buttons

   325

        return self.Buttons + self.ContextualButtons

   326

   327

    def PopupContextualButtons(self, item, rect, direction=wx.RIGHT):

   328

        """

   329

        Show contextual menu for item aside a label of this item defined

   330

        by the bounding box of label in figure

   331

        @param item: Item for which contextual is shown

   332

        @param rect: Bounding box of label aside which drawing menu

   333

        @param direction: Direction in which buttons must be drawn

   334

        """

   335

        # Return immediately if contextual menu for item is already shown

   336

        if self.ContextualButtonsItem == item:

   337

            return

   338

   339

        # Close already shown contextual menu

   340

        self.DismissContextualButtons()

   341

   342

        # Save item for which contextual menu is shown

   343

        self.ContextualButtonsItem = item

   344

   345

        # If item variable is forced, add button for release variable to

   346

        # contextual menu

   347

        if self.ContextualButtonsItem.IsForced():

   348

            self.ContextualButtons.append(

   349

                GraphButton(0, 0, "release", self.OnReleaseItemButton))

   350

   351

        # Add other buttons to contextual menu

   352

        for bitmap, callback in [

   353

                ("force", self.OnForceItemButton),

   354

                ("export_graph_mini", self.OnExportItemGraphButton),

   355

                ("delete_graph", self.OnRemoveItemButton)]:

   356

            self.ContextualButtons.append(

   357

                    GraphButton(0, 0, bitmap, callback))

   358

   359

        # If buttons are shown at left side or upper side of rect, positions

   360

        # will be set in reverse order

   361

        buttons = self.ContextualButtons[:]

   362

        if direction in [wx.TOP, wx.LEFT]:

   363

             buttons.reverse()

   364

   365

        # Set contextual menu buttons position aside rect depending on

   366

        # direction given

   367

        offset = 0

   368

        for button in buttons:

   369

            w, h = button.GetSize()

   370

            if direction in [wx.LEFT, wx.RIGHT]:

   371

                x = rect.x + (- w - offset

   372

                            if direction == wx.LEFT

   373

                            else rect.width + offset)

   374

                y = rect.y + (rect.height - h) / 2

   375

                offset += w

   376

            else:

   377

                x = rect.x + (rect.width - w ) / 2

   378

                y = rect.y + (- h - offset

   379

                              if direction == wx.TOP

   380

                              else rect.height + offset)

   381

                offset += h

   382

            button.SetPosition(x, y)

   383

            button.Show()

   384

   385

        # Refresh canvas

   386

        self.ParentWindow.ForceRefresh()

   387

   388

    def DismissContextualButtons(self):

   389

        """

   390

        Close current shown contextual menu

   391

        """

   392

        # Return immediately if no contextual menu is shown

   393

        if self.ContextualButtonsItem is None:

   394

            return

   395

   396

        # Reset variables corresponding to contextual menu

   397

        self.ContextualButtonsItem = None

   398

        self.ContextualButtons = []

   399

   400

        # Refresh canvas

   401

        self.ParentWindow.ForceRefresh()

   402

   403

    def IsOverContextualButton(self, x, y):

   404

        """

   405

        Return if point is over one contextual button of Viewer

   406

        @param x: X coordinate of point

   407

        @param y: Y coordinate of point

   408

        @return: contextual button where point is over

   409

        """

   410

        for button in self.ContextualButtons:

   411

            if button.HitTest(x, y):

   412

                return button

   413

        return None

   414

   415

    def ExportGraph(self, item=None):

   416

        """

   417

        Export item(s) data to clipboard in CSV format

   418

        @param item: Item from which data to export, all items if None

   419

        (default None)

   420

        """

   421

        self.ParentWindow.CopyDataToClipboard(

   422

            [(item, [entry for entry in item.GetData()])

   423

             for item in (self.Items 

   424

                          if item is None 

   425

                          else [item])])

   426

   427

    def GetOnChangeSizeButton(self, height):

   428

        """

   429

        Function that generate callback function for change Viewer height to

   430

        pre-defined height button

   431

        @param height: Height that change Viewer to

   432

        @return: callback function

   433

        """

   434

        def OnChangeSizeButton():

   435

            self.SetCanvasSize(200, height)

   436

        return OnChangeSizeButton

   437

   438

    def OnExportGraphButton(self):

   439

        """

   440

        Function called when Viewer Export button is pressed

   441

        """

   442

        # Export data of every item in Viewer

   443

        self.ExportGraph()

   444

   445

    def OnForceItemButton(self):

   446

        """

   447

        Function called when contextual menu Force button is pressed

   448

        """

   449

        # Open dialog for forcing item variable value 

   450

        self.ForceValue(self.ContextualButtonsItem)

   451

        # Close contextual menu

   452

        self.DismissContextualButtons()

   453

   454

    def OnReleaseItemButton(self):

   455

        """

   456

        Function called when contextual menu Release button is pressed

   457

        """

   458

        # Release item variable value 

   459

        self.ReleaseValue(self.ContextualButtonsItem)

   460

        # Close contextual menu

   461

        self.DismissContextualButtons()

   462

   463

    def OnExportItemGraphButton(self):

   464

        """

   465

        Function called when contextual menu Export button is pressed

   466

        """

   467

        # Export data of item variable

   468

        self.ExportGraph(self.ContextualButtonsItem)

   469

        # Close contextual menu

   470

        self.DismissContextualButtons()

   471

   472

    def OnRemoveItemButton(self):            

   473

        """

   474

        Function called when contextual menu Remove button is pressed

   475

        """

   476

        # Remove item from Viewer

   477

        wx.CallAfter(self.ParentWindow.DeleteValue, self, 

   478

                     self.ContextualButtonsItem)

   479

        # Close contextual menu

   480

        self.DismissContextualButtons()

   481

   482

    def HandleCursorMove(self, event):

   483

        """

   484

        Update Cursor position according to mouse position and graph type

   485

        @param event: Mouse event

   486

        """

   487

        start_tick, end_tick = self.ParentWindow.GetRange()

   488

        cursor_tick = None

   489

        items = self.ItemsDict.values()

   490