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 Helpers

    63

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

    64

    65

def merge_ranges(ranges):

    66

    """

    67

    Merge variables data range in a list to return a range of minimal min range

    68

    value and maximal max range value extended of 10% for keeping a padding

    69

    around graph in canvas

    70

    @param ranges: [(range_min_value, range_max_value),...]

    71

    @return: merged_range_min_value, merged_range_max_value

    72

    """

    73

    # Get minimal and maximal range value

    74

    min_value = max_value = None

    75

    for range_min, range_max in ranges:

    76

        # Update minimal range value

    77

        if min_value is None:

    78

            min_value = range_min

    79

        elif range_min is not None:

    80

            min_value = min(min_value, range_min)

    81

    82

        # Update maximal range value

    83

        if max_value is None:

    84

            max_value = range_max

    85

        elif range_min is not None:

    86

            max_value = max(max_value, range_max)

    87

    88

    # Calculate range center and width if at least one valid range is defined

    89

    if min_value is not None and max_value is not None:

    90

        center = (min_value + max_value) / 2.

    91

        range_size = max(1.0, max_value - min_value)

    92

    93

    # Set default center and with if no valid range is defined

    94

    else:

    95

        center = 0.5

    96

        range_size = 1.0

    97

    98

    # Return range expended from 10 %

    99

    return center - range_size * 0.55, center + range_size * 0.55

   100

   101

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

   102

#                   Debug Variable Graphic Viewer Drop Target

   103

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

   104

   105

"""

   106

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

   107

Viewer

   108

"""

   109

   110

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

   111

   112

    def __init__(self, parent, window):

   113

        """

   114

        Constructor

   115

        @param parent: Reference to Debug Variable Graphic Viewer

   116

        @param window: Reference to the Debug Variable Panel

   117

        """

   118

        wx.TextDropTarget.__init__(self)

   119

        self.ParentControl = parent

   120

        self.ParentWindow = window

   121

   122

    def __del__(self):

   123

        """

   124

        Destructor

   125

        """

   126

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

   127

        # Panel

   128

        self.ParentControl = None

   129

        self.ParentWindow = None

   130

   131

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

   132

        """

   133

        Function called when mouse is dragged over Drop Target

   134

        @param x: X coordinate of mouse pointer

   135

        @param y: Y coordinate of mouse pointer

   136

        @param d: Suggested default for return value

   137

        """

   138

        # Signal parent that mouse is dragged over

   139

        self.ParentControl.OnMouseDragging(x, y)

   140

   141

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

   142

   143

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

   144

        """

   145

        Function called when mouse is released in Drop Target

   146

        @param x: X coordinate of mouse pointer

   147

        @param y: Y coordinate of mouse pointer

   148

        @param data: Text associated to drag'n drop

   149

        """

   150

        # Signal Debug Variable Panel to reset highlight

   151

        self.ParentWindow.ResetHighlight()

   152

   153

        message = None

   154

   155

        # Check that data is valid regarding DebugVariablePanel

   156

        try:

   157

            values = eval(data)

   158

            if not isinstance(values, TupleType):

   159

                raise ValueError

   160

        except:

   161

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

   162

            values = None

   163

   164

        # Display message if data is invalid

   165

        if message is not None:

   166

            wx.CallAfter(self.ShowMessage, message)

   167

   168

        # Data contain a reference to a variable to debug

   169

        elif values[1] == "debug":

   170

            target_idx = self.ParentControl.GetIndex()

   171

   172

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

   173

            # not 3D canvas, graphs will be merged

   174

            rect = self.ParentControl.GetAxesBoundingBox()

   175

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

   176

                # Default merge type is parallel

   177

                merge_type = GRAPH_PARALLEL

   178

   179

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

   180

                # wall be merged orthogonally

   181

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

   182

                                     rect.width / 2., rect.height)

   183

                if merge_rect.InsideXY(x, y):

   184

                    merge_type = GRAPH_ORTHOGONAL

   185

   186

                # Merge graphs

   187

                wx.CallAfter(self.ParentWindow.MergeGraphs, 

   188

                             values[0], target_idx, 

   189

                             merge_type, force=True)

   190

   191

            else:

   192

                width, height = self.ParentControl.GetSize()

   193

   194

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

   195

                # according to the position of mouse in Viewer.

   196

                if y > height / 2:

   197

                    target_idx += 1

   198

   199

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

   200

                # Variable Panel 

   201

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

   202

                    self.ParentWindow.MoveValue(values[0], 

   203

                                                target_idx)

   204

   205

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

   206

                else:

   207

                    self.ParentWindow.InsertValue(values[0], 

   208

                                                  target_idx, 

   209

                                                  force=True)

   210

   211

    def OnLeave(self):

   212

        """

   213

        Function called when mouse is leave Drop Target

   214

        """

   215

        # Signal Debug Variable Panel to reset highlight

   216

        self.ParentWindow.ResetHighlight()

   217

        return wx.TextDropTarget.OnLeave(self)

   218

   219

    def ShowMessage(self, message):

   220

        """

   221

        Show error message in Error Dialog

   222

        @param message: Error message to display

   223

        """

   224

        dialog = wx.MessageDialog(self.ParentWindow, 

   225

                                  message, 

   226

                                  _("Error"), 

   227

                                  wx.OK|wx.ICON_ERROR)

   228

        dialog.ShowModal()

   229

        dialog.Destroy()

   230

   231

   232

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

   233

#                      Debug Variable Graphic Viewer Class

   234

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

   235

   236

"""

   237

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

   238

"""

   239

   240

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   241

   242

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

   243

        """

   244

        Constructor

   245

        @param parent: Parent wx.Window of DebugVariableText

   246

        @param window: Reference to the Debug Variable Panel

   247

        @param items: List of DebugVariableItem displayed by Viewer

   248

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

   249

        """

   250

        DebugVariableViewer.__init__(self, window, items)

   251

   252

        self.GraphType = graph_type        # Graph type display

   253

        self.CursorTick = None             # Tick of the graph cursor

   254

   255

        # Mouse position when start dragging

   256

        self.MouseStartPos = None

   257

        # Tick when moving tick start

   258

        self.StartCursorTick = None

   259

        # Canvas size when starting to resize canvas

   260

        self.CanvasStartSize = None        

   261

   262

        # List of current displayed contextual buttons

   263

        self.ContextualButtons = []

   264

        # Reference to item for which contextual buttons was displayed

   265

        self.ContextualButtonsItem = None

   266

   267

        # Flag indicating that zoom fit current displayed data range or whole

   268

        # data range if False

   269

        self.ZoomFit = False

   270

   271

        # Create figure for drawing graphs

   272

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

   273

        # Defined border around figure in canvas

   274

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

   275

                                       bottom=0.1, right=0.95)

   276

   277

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

   278

        self.SetWindowStyle(wx.WANTS_CHARS)

   279

        self.SetBackgroundColour(wx.WHITE)

   280

   281

        # Bind wx events

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

   289

        # Set canvas min size

   290

        canvas_size = self.GetCanvasMinSize()

   291

        self.SetMinSize(canvas_size)

   292

   293

        # Define Viewer drop target

   294

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   295

   296

        # Connect matplotlib events

   297

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

   298

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

   299

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

   300

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

   301

   302

        # Add buttons for zooming on current displayed data range

   303

        self.Buttons.append(

   304

                GraphButton(0, 0, "fit_graph", self.OnZoomFitButton))

   305

   306

        # Add buttons for changing canvas size with predefined height

   307

        for size, bitmap in zip(

   308

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   309

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

   310

            self.Buttons.append(

   311

                    GraphButton(0, 0, bitmap, 

   312

                                self.GetOnChangeSizeButton(size)))

   313

   314

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

   315

        for bitmap, callback in [

   316

                ("export_graph_mini", self.OnExportGraphButton),

   317

                ("delete_graph", self.OnCloseButton)]:

   318

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

   319

   320

        # Update graphs elements

   321

        self.ResetGraphics()

   322

        self.RefreshLabelsPosition(canvas_size.height)

   323

   324

    def AddItem(self, item):

   325

        """

   326

        Add an item to the list of items displayed by Viewer

   327

        @param item: Item to add to the list

   328

        """

   329

        DebugVariableViewer.AddItem(self, item)

   330

        self.ResetGraphics()

   331

   332

    def RemoveItem(self, item):

   333

        """

   334

        Remove an item from the list of items displayed by Viewer

   335

        @param item: Item to remove from the list

   336

        """

   337

        DebugVariableViewer.RemoveItem(self, item)

   338

   339

        # If list of items is not empty

   340

        if not self.ItemsIsEmpty():

   341

            # Return to parallel graph if there is only one item

   342

            # especially if it's actually orthogonal

   343

            if len(self.Items) == 1:

   344

                self.GraphType = GRAPH_PARALLEL

   345

            self.ResetGraphics()

   346

   347

    def SetCursorTick(self, cursor_tick):

   348

        """

   349

        Set cursor tick

   350

        @param cursor_tick: Cursor tick

   351

        """

   352

        self.CursorTick = cursor_tick

   353

   354

    def SetZoomFit(self, zoom_fit):

   355

        """

   356

        Set flag indicating that zoom fit current displayed data range

   357

        @param zoom_fit: Flag for zoom fit (False: zoom fit whole data range)

   358

        """

   359

        # Flag is different from the actual one 

   360

        if zoom_fit != self.ZoomFit:

   361

            # Save new flag value

   362

            self.ZoomFit = zoom_fit

   363

   364

            # Update button for zoom fit bitmap

   365

            self.Buttons[0].SetBitmap("full_graph" if zoom_fit else "fit_graph")

   366

   367

            # Refresh canvas

   368

            self.RefreshViewer()

   369

   370

    def SubscribeAllDataConsumers(self):

   371

        """

   372

        Function that unsubscribe and remove every item that store values of

   373

        a variable that doesn't exist in PLC anymore

   374

        """

   375

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   376

   377

        # Graph still have data to display

   378

        if not self.ItemsIsEmpty():

   379

            # Reset flag indicating that zoom fit current displayed data range

   380

            self.SetZoomFit(False)

   381

   382

            self.ResetGraphics()

   383

   384

    def Is3DCanvas(self):

   385

        """

   386

        Return if Viewer is a 3D canvas

   387

        @return: True if Viewer is a 3D canvas

   388

        """

   389

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

   390

   391

    def GetButtons(self):

   392

        """

   393

        Return list of buttons defined in Viewer

   394

        @return: List of buttons

   395

        """

   396

        # Add contextual buttons to default buttons

   397

        return self.Buttons + self.ContextualButtons

   398

   399

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

   400

        """

   401

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

   402

        by the bounding box of label in figure

   403

        @param item: Item for which contextual is shown

   404

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

   405

        @param direction: Direction in which buttons must be drawn

   406

        """

   407

        # Return immediately if contextual menu for item is already shown

   408

        if self.ContextualButtonsItem == item:

   409

            return

   410

   411

        # Close already shown contextual menu

   412

        self.DismissContextualButtons()

   413

   414

        # Save item for which contextual menu is shown

   415

        self.ContextualButtonsItem = item

   416

   417

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

   418

        # contextual menu

   419

        if self.ContextualButtonsItem.IsForced():

   420

            self.ContextualButtons.append(

   421

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

   422

   423

        # Add other buttons to contextual menu

   424

        for bitmap, callback in [

   425

                ("force", self.OnForceItemButton),

   426

                ("export_graph_mini", self.OnExportItemGraphButton),

   427

                ("delete_graph", self.OnRemoveItemButton)]:

   428

            self.ContextualButtons.append(

   429

                    GraphButton(0, 0, bitmap, callback))

   430

   431

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

   432

        # will be set in reverse order

   433

        buttons = self.ContextualButtons[:]

   434

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

   435

             buttons.reverse()

   436

   437

        # Set contextual menu buttons position aside rect depending on

   438

        # direction given

   439

        offset = 0

   440

        for button in buttons:

   441

            w, h = button.GetSize()

   442

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

   443

                x = rect.x + (- w - offset

   444

                            if direction == wx.LEFT

   445

                            else rect.width + offset)

   446

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

   447

                offset += w

   448

            else:

   449

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

   450

                y = rect.y + (- h - offset

   451

                              if direction == wx.TOP

   452

                              else rect.height + offset)

   453

                offset += h

   454

            button.SetPosition(x, y)

   455

            button.Show()

   456

   457

        # Refresh canvas

   458

        self.ParentWindow.ForceRefresh()

   459

   460

    def DismissContextualButtons(self):

   461

        """

   462

        Close current shown contextual menu

   463

        """

   464

        # Return immediately if no contextual menu is shown

   465

        if self.ContextualButtonsItem is None:

   466

            return

   467

   468

        # Reset variables corresponding to contextual menu

   469

        self.ContextualButtonsItem = None

   470

        self.ContextualButtons = []

   471

   472

        # Refresh canvas

   473

        self.ParentWindow.ForceRefresh()

   474

   475

    def IsOverContextualButton(self, x, y):

   476

        """

   477

        Return if point is over one contextual button of Viewer

   478

        @param x: X coordinate of point

   479

        @param y: Y coordinate of point

   480

        @return: contextual button where point is over

   481

        """

   482

        for button in self.ContextualButtons:

   483

            if button.HitTest(x, y):

   484

                return button

   485

        return None

   486

   487

    def ExportGraph(self, item=None):

   488

        """

   489

        Export item(s) data to clipboard in CSV format

   490

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

   491

        (default None)