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, 

   185

                                  message, 

   186

                                  _("Error"), 

   187

                                  wx.OK|wx.ICON_ERROR)

   188

        dialog.ShowModal()

   189

        dialog.Destroy()

   190

   191

   192

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

   193

#                      Debug Variable Graphic Viewer Class

   194

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

   195

   196

"""

   197

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

   198

"""

   199

   200

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   201

   202

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

   203

        """

   204

        Constructor

   205

        @param parent: Parent wx.Window of DebugVariableText

   206

        @param window: Reference to the Debug Variable Panel

   207

        @param items: List of DebugVariableItem displayed by Viewer

   208

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

   209

        """

   210

        DebugVariableViewer.__init__(self, window, items)

   211

   212

        self.GraphType = graph_type        # Graph type display

   213

        self.CursorTick = None             # Tick of the graph cursor

   214

   215

        # Mouse position when start dragging

   216

        self.MouseStartPos = None

   217

        # Tick when moving tick start

   218

        self.StartCursorTick = None

   219

        # Canvas size when starting to resize canvas

   220

        self.CanvasStartSize = None        

   221

   222

        # List of current displayed contextual buttons

   223

        self.ContextualButtons = []

   224

        # Reference to item for which contextual buttons was displayed

   225

        self.ContextualButtonsItem = None

   226

   227

        # Create figure for drawing graphs

   228

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

   229

        # Defined border around figure in canvas

   230

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

   231

                                       bottom=0.1, right=0.95)

   232

   233

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

   234

        self.SetWindowStyle(wx.WANTS_CHARS)

   235

        self.SetBackgroundColour(wx.WHITE)

   236

   237

        # Bind wx events

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

   245

        # Set canvas min size

   246

        canvas_size = self.GetCanvasMinSize()

   247

        self.SetMinSize(canvas_size)

   248

   249

        # Define Viewer drop target

   250

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   251

   252

        # Connect matplotlib events

   253

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

   254

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

   255

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

   256

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

   257

   258

        # Add buttons for changing canvas size with predefined height

   259

        for size, bitmap in zip(

   260

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   261

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

   262

            self.Buttons.append(

   263

                    GraphButton(0, 0, bitmap, 

   264

                                self.GetOnChangeSizeButton(size)))

   265

   266

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

   267

        for bitmap, callback in [

   268

                ("export_graph_mini", self.OnExportGraphButton),

   269

                ("delete_graph", self.OnCloseButton)]:

   270

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

   271

   272

        # Update graphs elements

   273

        self.ResetGraphics()

   274

        self.RefreshLabelsPosition(canvas_size.height)

   275

   276

    def AddItem(self, item):

   277

        """

   278

        Add an item to the list of items displayed by Viewer

   279

        @param item: Item to add to the list

   280

        """

   281

        DebugVariableViewer.AddItem(self, item)

   282

        self.ResetGraphics()

   283

   284

    def RemoveItem(self, item):

   285

        """

   286

        Remove an item from the list of items displayed by Viewer

   287

        @param item: Item to remove from the list

   288

        """

   289

        DebugVariableViewer.RemoveItem(self, item)

   290

   291

        # If list of items is not empty

   292

        if not self.ItemsIsEmpty():

   293

            # Return to parallel graph if there is only one item

   294

            # especially if it's actually orthogonal

   295

            if len(self.Items) == 1:

   296

                self.GraphType = GRAPH_PARALLEL

   297

            self.ResetGraphics()

   298

   299

    def SetCursorTick(self, cursor_tick):

   300

        """

   301

        Set cursor tick

   302

        @param cursor_tick: Cursor tick

   303

        """

   304

        self.CursorTick = cursor_tick

   305

   306

    def SubscribeAllDataConsumers(self):

   307

        """

   308

        Function that unsubscribe and remove every item that store values of

   309

        a variable that doesn't exist in PLC anymore

   310

        """

   311

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   312

        if not self.ItemsIsEmpty():

   313

            self.ResetGraphics()

   314

   315

    def Is3DCanvas(self):

   316

        """

   317

        Return if Viewer is a 3D canvas

   318

        @return: True if Viewer is a 3D canvas

   319

        """

   320

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

   321

   322

    def GetButtons(self):

   323

        """

   324

        Return list of buttons defined in Viewer

   325

        @return: List of buttons

   326

        """

   327

        # Add contextual buttons to default buttons

   328

        return self.Buttons + self.ContextualButtons

   329

   330

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

   331

        """

   332

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

   333

        by the bounding box of label in figure

   334

        @param item: Item for which contextual is shown

   335

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

   336

        @param direction: Direction in which buttons must be drawn

   337

        """

   338

        # Return immediately if contextual menu for item is already shown

   339

        if self.ContextualButtonsItem == item:

   340

            return

   341

   342

        # Close already shown contextual menu

   343

        self.DismissContextualButtons()

   344

   345

        # Save item for which contextual menu is shown

   346

        self.ContextualButtonsItem = item

   347

   348

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

   349

        # contextual menu

   350

        if self.ContextualButtonsItem.IsForced():

   351

            self.ContextualButtons.append(

   352

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

   353

   354

        # Add other buttons to contextual menu

   355

        for bitmap, callback in [

   356

                ("force", self.OnForceItemButton),

   357

                ("export_graph_mini", self.OnExportItemGraphButton),

   358

                ("delete_graph", self.OnRemoveItemButton)]:

   359

            self.ContextualButtons.append(

   360

                    GraphButton(0, 0, bitmap, callback))

   361

   362

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

   363

        # will be set in reverse order

   364

        buttons = self.ContextualButtons[:]

   365

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

   366

             buttons.reverse()

   367

   368

        # Set contextual menu buttons position aside rect depending on

   369

        # direction given

   370

        offset = 0

   371

        for button in buttons:

   372

            w, h = button.GetSize()

   373

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

   374

                x = rect.x + (- w - offset

   375

                            if direction == wx.LEFT

   376

                            else rect.width + offset)

   377

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

   378

                offset += w

   379

            else:

   380

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

   381

                y = rect.y + (- h - offset

   382

                              if direction == wx.TOP

   383

                              else rect.height + offset)

   384

                offset += h

   385

            button.SetPosition(x, y)

   386

            button.Show()

   387

   388

        # Refresh canvas

   389

        self.ParentWindow.ForceRefresh()

   390

   391

    def DismissContextualButtons(self):

   392

        """

   393

        Close current shown contextual menu

   394

        """

   395

        # Return immediately if no contextual menu is shown

   396

        if self.ContextualButtonsItem is None:

   397

            return

   398

   399

        # Reset variables corresponding to contextual menu

   400

        self.ContextualButtonsItem = None

   401

        self.ContextualButtons = []

   402

   403

        # Refresh canvas

   404

        self.ParentWindow.ForceRefresh()

   405

   406

    def IsOverContextualButton(self, x, y):

   407

        """

   408

        Return if point is over one contextual button of Viewer

   409

        @param x: X coordinate of point

   410

        @param y: Y coordinate of point

   411

        @return: contextual button where point is over

   412

        """

   413

        for button in self.ContextualButtons:

   414

            if button.HitTest(x, y):

   415

                return button

   416

        return None

   417

   418

    def ExportGraph(self, item=None):

   419

        """

   420

        Export item(s) data to clipboard in CSV format

   421

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

   422

        (default None)

   423

        """

   424

        self.ParentWindow.CopyDataToClipboard(

   425

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

   426

             for item in (self.Items 

   427

                          if item is None 

   428

                          else [item])])

   429

   430

    def GetOnChangeSizeButton(self, height):

   431

        """

   432

        Function that generate callback function for change Viewer height to

   433

        pre-defined height button

   434

        @param height: Height that change Viewer to

   435

        @return: callback function

   436

        """

   437

        def OnChangeSizeButton():

   438

            self.SetCanvasSize(200, height)

   439

        return OnChangeSizeButton

   440

   441

    def OnExportGraphButton(self):

   442

        """

   443

        Function called when Viewer Export button is pressed

   444

        """

   445

        # Export data of every item in Viewer

   446

        self.ExportGraph()

   447

   448

    def OnForceItemButton(self):

   449

        """

   450

        Function called when contextual menu Force button is pressed

   451

        """

   452

        # Open dialog for forcing item variable value 

   453

        self.ForceValue(self.ContextualButtonsItem)

   454

        # Close contextual menu

   455

        self.DismissContextualButtons()

   456

   457

    def OnReleaseItemButton(self):

   458

        """

   459

        Function called when contextual menu Release button is pressed

   460

        """

   461

        # Release item variable value 

   462

        self.ReleaseValue(self.ContextualButtonsItem)

   463

        # Close contextual menu

   464

        self.DismissContextualButtons()

   465

   466

    def OnExportItemGraphButton(self):

   467

        """

   468

        Function called when contextual menu Export button is pressed

   469

        """

   470

        # Export data of item variable

   471

        self.ExportGraph(self.ContextualButtonsItem)

   472

        # Close contextual menu

   473

        self.DismissContextualButtons()

   474

   475

    def OnRemoveItemButton(self):            

   476

        """

   477

        Function called when contextual menu Remove button is pressed

   478

        """

   479

        # Remove item from Viewer

   480

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

   481

                     self.ContextualButtonsItem)

   482

        # Close contextual menu

   483

        self.DismissContextualButtons()

   484

   485

    def HandleCursorMove(self, event):

   486

        """

   487

        Update Cursor position according to mouse position and graph type

   488

        @param event: Mouse event

   489

        """

   490

        start_tick, end_tick = self.ParentWindow.GetRange()