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

def OrthogonalDataAndRange(item, start_tick, end_tick):

    62

    data = item.GetData(start_tick, end_tick)

    63

    min_value, max_value = item.GetValueRange()

    64

    if min_value is not None and max_value is not None:

    65

        center = (min_value + max_value) / 2.

    66

        range = max(1.0, max_value - min_value)

    67

    else:

    68

        center = 0.5

    69

        range = 1.0

    70

    return data, center - range * 0.55, center + range * 0.55

    71

    72

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

    73

#                   Debug Variable Graphic Viewer Drop Target

    74

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

    75

    76

"""

    77

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

    78

"""

    79

    80

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

    81

    82

    def __init__(self, parent, window):

    83

        """

    84

        Constructor

    85

        @param parent: Reference to Debug Variable Graphic Viewer

    86

        @param window: Reference to the Debug Variable Panel

    87

        """

    88

        wx.TextDropTarget.__init__(self)

    89

        self.ParentControl = parent

    90

        self.ParentWindow = window

    91

    92

    def __del__(self):

    93

        """

    94

        Destructor

    95

        """

    96

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

    97

        # Panel

    98

        self.ParentControl = None

    99

        self.ParentWindow = None

   100

   101

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

   102

        """

   103

        Function called when mouse is dragged over Drop Target

   104

        @param x: X coordinate of mouse pointer

   105

        @param y: Y coordinate of mouse pointer

   106

        @param d: Suggested default for return value

   107

        """

   108

        # Signal parent that mouse is dragged over

   109

        self.ParentControl.OnMouseDragging(x, y)

   110

   111

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

   112

   113

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

   114

        """

   115

        Function called when mouse is dragged over Drop Target

   116

        @param x: X coordinate of mouse pointer

   117

        @param y: Y coordinate of mouse pointer

   118

        @param data: Text associated to drag'n drop

   119

        """

   120

        message = None

   121

   122

        # Check that data is valid regarding DebugVariablePanel

   123

        try:

   124

            values = eval(data)

   125

            if not isinstance(values, TupleType):

   126

                raise ValueError

   127

        except:

   128

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

   129

            values = None

   130

   131

        # Display message if data is invalid

   132

        if message is not None:

   133

            wx.CallAfter(self.ShowMessage, message)

   134

   135

        # Data contain a reference to a variable to debug

   136

        elif values[1] == "debug":

   137

            target_idx = self.ParentControl.GetIndex()

   138

   139

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

   140

            # not 3D canvas, graphs will be merged

   141

            rect = self.ParentControl.GetAxesBoundingBox()

   142

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

   143

                # Default merge type is parallel

   144

                merge_type = GRAPH_PARALLEL

   145

   146

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

   147

                # wall be merged orthogonally

   148

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

   149

                                     rect.width / 2., rect.height)

   150

                if merge_rect.InsideXY(x, y):

   151

                    merge_type = GRAPH_ORTHOGONAL

   152

   153

                # Merge graphs

   154

                wx.CallAfter(self.ParentWindow.MergeGraphs, 

   155

                             values[0], target_idx, 

   156

                             merge_type, force=True)

   157

   158

            else:

   159

                width, height = self.ParentControl.GetSize()

   160

   161

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

   162

                # according to the position of mouse in Viewer.

   163

                if y > height / 2:

   164

                    target_idx += 1

   165

   166

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

   167

                # Variable Panel 

   168

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

   169

                    self.ParentWindow.MoveValue(values[0], 

   170

                                                target_idx)

   171

   172

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

   173

                else:

   174

                    self.ParentWindow.InsertValue(values[0], 

   175

                                                  target_idx, 

   176

                                                  force=True)

   177

   178

    def OnLeave(self):

   179

        """

   180

        Function called when mouse is leave Drop Target

   181

        """

   182

        # Signal Debug Variable Panel to reset highlight

   183

        self.ParentWindow.ResetHighlight()

   184

        return wx.TextDropTarget.OnLeave(self)

   185

   186

    def ShowMessage(self, message):

   187

        """

   188

        Show error message in Error Dialog

   189

        @param message: Error message to display

   190

        """

   191

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

   192

        dialog.ShowModal()

   193

        dialog.Destroy()

   194

   195

   196

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

   197

#                      Debug Variable Graphic Viewer Class

   198

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

   199

   200

"""

   201

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

   202

"""

   203

   204

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   205

   206

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

   207

        """

   208

        Constructor

   209

        @param parent: Parent wx.Window of DebugVariableText

   210

        @param window: Reference to the Debug Variable Panel

   211

        @param items: List of DebugVariableItem displayed by Viewer

   212

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

   213

        """

   214

        DebugVariableViewer.__init__(self, window, items)

   215

   216

        self.GraphType = graph_type        # Graph type display

   217

        self.CursorTick = None             # Tick of the graph cursor

   218

   219

        # Mouse position when start dragging

   220

        self.MouseStartPos = None

   221

        # Tick when moving tick start

   222

        self.StartCursorTick = None

   223

        # Canvas size when starting to resize canvas

   224

        self.CanvasStartSize = None        

   225

   226

        # List of current displayed contextual buttons

   227

        self.ContextualButtons = []

   228

        # Reference to item for which contextual buttons was displayed

   229

        self.ContextualButtonsItem = None

   230

   231

        # Create figure for drawing graphs

   232

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

   233

        # Defined border around figure in canvas

   234

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

   235

                                       bottom=0.1, right=0.95)

   236

   237

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

   238

        self.SetWindowStyle(wx.WANTS_CHARS)

   239

        self.SetBackgroundColour(wx.WHITE)

   240

   241

        # Bind wx events

   243

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

   244

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

   245

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

   246

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

   247

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

   248

   249

        # Set canvas min size

   250

        canvas_size = self.GetCanvasMinSize()

   251

        self.SetMinSize(canvas_size)

   252

   253

        # Define Viewer drop target

   254

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   255

   256

        # Connect matplotlib events

   257

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

   258

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

   259

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

   260

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

   261

   262

        # Add buttons for changing canvas size with predefined height

   263

        for size, bitmap in zip(

   264

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   265

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

   266

            self.Buttons.append(

   267

                    GraphButton(0, 0, bitmap, 

   268

                                self.GetOnChangeSizeButton(size)))

   269

   270

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

   271

        for bitmap, callback in [

   272

                ("export_graph_mini", self.OnExportGraphButton),

   273

                ("delete_graph", self.OnCloseButton)]:

   274

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

   275

   276

        # Update graphs elements

   277

        self.ResetGraphics()

   278

        self.RefreshLabelsPosition(canvas_size.height)

   279

   280

    def AddItem(self, item):

   281

        """

   282

        Add an item to the list of items displayed by Viewer

   283

        @param item: Item to add to the list

   284

        """

   285

        DebugVariableViewer.AddItem(self, item)

   286

        self.ResetGraphics()

   287

   288

    def RemoveItem(self, item):

   289

        """

   290

        Remove an item from the list of items displayed by Viewer

   291

        @param item: Item to remove from the list

   292

        """

   293

        DebugVariableViewer.RemoveItem(self, item)

   294

   295

        # If list of items is not empty

   296

        if not self.ItemsIsEmpty():

   297

            # Return to parallel graph if there is only one item

   298

            # especially if it's actually orthogonal

   299

            if len(self.Items) == 1:

   300

                self.GraphType = GRAPH_PARALLEL

   301

            self.ResetGraphics()

   302

   303

    def SetCursorTick(self, cursor_tick):

   304

        """

   305

        Set cursor tick

   306

        @param cursor_tick: Cursor tick

   307

        """

   308

        self.CursorTick = cursor_tick

   309

   310

    def SubscribeAllDataConsumers(self):

   311

        """

   312

        Function that unsubscribe and remove every item that store values of

   313

        a variable that doesn't exist in PLC anymore

   314

        """

   315

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   316

        if not self.ItemsIsEmpty():

   317

            self.ResetGraphics()

   318

   319

    def Is3DCanvas(self):

   320

        """

   321

        Return if Viewer is a 3D canvas

   322

        @return: True if Viewer is a 3D canvas

   323

        """

   324

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

   325

   326

    def GetButtons(self):

   327

        """

   328

        Return list of buttons defined in Viewer

   329

        @return: List of buttons

   330

        """

   331

        # Add contextual buttons to default buttons

   332

        return self.Buttons + self.ContextualButtons

   333

   334

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

   335

        """

   336

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

   337

        by the bounding box of label in figure

   338

        @param item: Item for which contextual is shown

   339

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

   340

        @param direction: Direction in which buttons must be drawn

   341

        """

   342

        # Return immediately if contextual menu for item is already shown

   343

        if self.ContextualButtonsItem == item:

   344

            return

   345

   346

        # Close already shown contextual menu

   347

        self.DismissContextualButtons()

   348

   349

        # Save item for which contextual menu is shown

   350

        self.ContextualButtonsItem = item

   351

   352

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

   353

        # contextual menu

   354

        if self.ContextualButtonsItem.IsForced():

   355

            self.ContextualButtons.append(

   356

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

   357

   358

        # Add other buttons to contextual menu

   359

        for bitmap, callback in [

   360

                ("force", self.OnForceItemButton),

   361

                ("export_graph_mini", self.OnExportItemGraphButton),

   362

                ("delete_graph", self.OnRemoveItemButton)]:

   363

            self.ContextualButtons.append(

   364

                    GraphButton(0, 0, bitmap, callback))

   365

   366

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

   367

        # will be set in reverse order

   368

        buttons = self.ContextualButtons[:]

   369

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

   370

             buttons.reverse()

   371

   372

        # Set contextual menu buttons position aside rect depending on

   373

        # direction given

   374

        offset = 0

   375

        for button in buttons:

   376

            w, h = button.GetSize()

   377

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

   378

                x = rect.x + (- w - offset

   379

                            if direction == wx.LEFT

   380

                            else rect.width + offset)

   381

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

   382

                offset += w

   383

            else:

   384

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

   385

                y = rect.y + (- h - offset

   386

                              if direction == wx.TOP

   387

                              else rect.height + offset)

   388

                offset += h

   389

            button.SetPosition(x, y)

   390

            button.Show()

   391

   392

        # Refresh canvas

   393

        self.ParentWindow.ForceRefresh()

   394

   395

    def DismissContextualButtons(self):

   396

        """

   397

        Close current shown contextual menu

   398

        """

   399

        # Return immediately if no contextual menu is shown

   400

        if self.ContextualButtonsItem is None:

   401

            return

   402

   403

        # Reset variables corresponding to contextual menu

   404

        self.ContextualButtonsItem = None

   405

        self.ContextualButtons = []

   406

   407

        # Refresh canvas

   408

        self.ParentWindow.ForceRefresh()

   409

   410

    def IsOverContextualButton(self, x, y):

   411

        """

   412

        Return if point is over one contextual button of Viewer

   413

        @param x: X coordinate of point

   414

        @param y: Y coordinate of point

   415

        @return: contextual button where point is over

   416

        """

   417

        for button in self.ContextualButtons:

   418

            if button.HitTest(x, y):

   419

                return button

   420

        return None

   421

   422

    def ExportGraph(self, item=None):

   423

        """

   424

        Export item(s) data to clipboard in CSV format

   425

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

   426

        (default None)

   427

        """

   428

        self.ParentWindow.CopyDataToClipboard(

   429

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

   430

             for item in (self.Items 

   431

                          if item is None 

   432

                          else [item])])

   433

   434

    def GetOnChangeSizeButton(self, height):

   435

        """

   436

        Function that generate callback function for change Viewer height to

   437

        pre-defined height button

   438

        @param height: Height that change Viewer to

   439

        @return: callback function

   440

        """

   441

        def OnChangeSizeButton():

   442

            self.SetCanvasSize(200, height)

   443

        return OnChangeSizeButton

   444

   445

    def OnExportGraphButton(self):

   446

        """

   447

        Function called when Viewer Export button is pressed

   448

        """

   449

        # Export data of every item in Viewer

   450

        self.ExportGraph()

   451

   452

    def OnForceItemButton(self):

   453

        """

   454

        Function called when contextual menu Force button is pressed

   455

        """

   456

        # Open dialog for forcing item variable value 

   457

        self.ForceValue(self.ContextualButtonsItem)

   458

        # Close contextual menu

   459

        self.DismissContextualButtons()

   460

   461

    def OnReleaseItemButton(self):

   462

        """

   463

        Function called when contextual menu Release button is pressed

   464

        """

   465

        # Release item variable value 

   466

        self.ReleaseValue(self.ContextualButtonsItem)

   467

        # Close contextual menu

   468

        self.DismissContextualButtons()

   469

   470

    def OnExportItemGraphButton(self):

   471

        """

   472

        Function called when contextual menu Export button is pressed

   473

        """

   474

        # Export data of item variable

   475

        self.ExportGraph(self.ContextualButtonsItem)

   476

        # Close contextual menu

   477

        self.DismissContextualButtons()

   478

   479

    def OnRemoveItemButton(self):            

   480

        """

   481

        Function called when contextual menu Remove button is pressed

   482

        """

   483

        # Remove item from Viewer

   484

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

   485

                     self.ContextualButtonsItem)

   486

        # Close contextual menu

   487

        self.DismissContextualButtons()

   488

   489

    def HandleCursorMove(self, event):

   490

        """

   491