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

import matplotlib.pyplot

    33

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    34

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    35

from matplotlib.backends.backend_agg import FigureCanvasAgg

    36

from mpl_toolkits.mplot3d import Axes3D

    37

    38

from editors.DebugViewer import REFRESH_PERIOD

    39

    40

from DebugVariableItem import DebugVariableItem

    41

from DebugVariableViewer import *

    42

from GraphButton import GraphButton

    43

    44

# Graph variable display type

    45

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    46

    47

# Canvas height

    48

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

    49

    50

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

    51

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

    52

VALUE_LABEL_HEIGHT = 17.   # Height of variable label in graph

    53

AXES_LABEL_HEIGHT = 12.75  # Height of variable value in graph

    54

    55

# Colors used cyclically for graph curves

    56

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

    57

# Color for graph cursor

    58

CURSOR_COLOR = '#800080'

    59

    60

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

    61

#                      Debug Variable Graphic Viewer Helpers

    62

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

    63

    64

def merge_ranges(ranges):

    65

    """

    66

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

    67

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

    68

    around graph in canvas

    69

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

    70

    @return: merged_range_min_value, merged_range_max_value

    71

    """

    72

    # Get minimal and maximal range value

    73

    min_value = max_value = None

    74

    for range_min, range_max in ranges:

    75

        # Update minimal range value

    76

        if min_value is None:

    77

            min_value = range_min

    78

        elif range_min is not None:

    79

            min_value = min(min_value, range_min)

    80

    81

        # Update maximal range value

    82

        if max_value is None:

    83

            max_value = range_max

    84

        elif range_min is not None:

    85

            max_value = max(max_value, range_max)

    86

    87

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

    88

    if min_value is not None and max_value is not None:

    89

        center = (min_value + max_value) / 2.

    90

        range_size = max(1.0, max_value - min_value)

    91

    92

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

    93

    else:

    94

        center = 0.5

    95

        range_size = 1.0

    96

    97

    # Return range expended from 10 %

    98

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

    99

   100

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

   101

#                   Debug Variable Graphic Viewer Drop Target

   102

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

   103

   104

"""

   105

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

   106

Viewer

   107

"""

   108

   109

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

   110

   111

    def __init__(self, parent, window):

   112

        """

   113

        Constructor

   114

        @param parent: Reference to Debug Variable Graphic Viewer

   115

        @param window: Reference to the Debug Variable Panel

   116

        """

   117

        wx.TextDropTarget.__init__(self)

   118

        self.ParentControl = parent

   119

        self.ParentWindow = window

   120

   121

    def __del__(self):

   122

        """

   123

        Destructor

   124

        """

   125

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

   126

        # Panel

   127

        self.ParentControl = None

   128

        self.ParentWindow = None

   129

   130

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

   131

        """

   132

        Function called when mouse is dragged over Drop Target

   133

        @param x: X coordinate of mouse pointer

   134

        @param y: Y coordinate of mouse pointer

   135

        @param d: Suggested default for return value

   136

        """

   137

        # Signal parent that mouse is dragged over

   138

        self.ParentControl.OnMouseDragging(x, y)

   139

   140

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

   141

   142

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

   143

        """

   144

        Function called when mouse is released in Drop Target

   145

        @param x: X coordinate of mouse pointer

   146

        @param y: Y coordinate of mouse pointer

   147

        @param data: Text associated to drag'n drop

   148

        """

   149

        # Signal Debug Variable Panel to reset highlight

   150

        self.ParentWindow.ResetHighlight()

   151

   152

        message = None

   153

   154

        # Check that data is valid regarding DebugVariablePanel

   155

        try:

   156

            values = eval(data)

   157

            if not isinstance(values, TupleType):

   158

                raise ValueError

   159

        except:

   160

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

   161

            values = None

   162

   163

        # Display message if data is invalid

   164

        if message is not None:

   165

            wx.CallAfter(self.ShowMessage, message)

   166

   167

        # Data contain a reference to a variable to debug

   168

        elif values[1] == "debug":

   169

            target_idx = self.ParentControl.GetIndex()

   170

   171

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

   172

            # not 3D canvas, graphs will be merged

   173

            rect = self.ParentControl.GetAxesBoundingBox()

   174

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

   175

                # Default merge type is parallel

   176

                merge_type = GRAPH_PARALLEL

   177

   178

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

   179

                # wall be merged orthogonally

   180

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

   181

                                     rect.width / 2., rect.height)

   182

                if merge_rect.InsideXY(x, y):

   183

                    merge_type = GRAPH_ORTHOGONAL

   184

   185

                # Merge graphs

   186

                wx.CallAfter(self.ParentWindow.MergeGraphs, 

   187

                             values[0], target_idx, 

   188

                             merge_type, force=True)

   189

   190

            else:

   191

                width, height = self.ParentControl.GetSize()

   192

   193

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

   194

                # according to the position of mouse in Viewer.

   195

                if y > height / 2:

   196

                    target_idx += 1

   197

   198

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

   199

                # Variable Panel 

   200

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

   201

                    self.ParentWindow.MoveValue(values[0], 

   202

                                                target_idx)

   203

   204

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

   205

                else:

   206

                    self.ParentWindow.InsertValue(values[0], 

   207

                                                  target_idx, 

   208

                                                  force=True)

   209

   210

    def OnLeave(self):

   211

        """

   212

        Function called when mouse is leave Drop Target

   213

        """

   214

        # Signal Debug Variable Panel to reset highlight

   215

        self.ParentWindow.ResetHighlight()

   216

        return wx.TextDropTarget.OnLeave(self)

   217

   218

    def ShowMessage(self, message):

   219

        """

   220

        Show error message in Error Dialog

   221

        @param message: Error message to display

   222

        """

   223

        dialog = wx.MessageDialog(self.ParentWindow, 

   224

                                  message, 

   225

                                  _("Error"), 

   226

                                  wx.OK|wx.ICON_ERROR)

   227

        dialog.ShowModal()

   228

        dialog.Destroy()

   229

   230

   231

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

   232

#                      Debug Variable Graphic Viewer Class

   233

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

   234

   235

"""

   236

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

   237

"""

   238

   239

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   240

   241

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

   242

        """

   243

        Constructor

   244

        @param parent: Parent wx.Window of DebugVariableText

   245

        @param window: Reference to the Debug Variable Panel

   246

        @param items: List of DebugVariableItem displayed by Viewer

   247

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

   248

        """

   249

        DebugVariableViewer.__init__(self, window, items)

   250

   251

        self.GraphType = graph_type        # Graph type display

   252

        self.CursorTick = None             # Tick of the graph cursor

   253

   254

        # Mouse position when start dragging

   255

        self.MouseStartPos = None

   256

        # Tick when moving tick start

   257

        self.StartCursorTick = None

   258

        # Canvas size when starting to resize canvas

   259

        self.CanvasStartSize = None        

   260

   261

        # List of current displayed contextual buttons

   262

        self.ContextualButtons = []

   263

        # Reference to item for which contextual buttons was displayed

   264

        self.ContextualButtonsItem = None

   265

   266

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

   267

        # data range if False

   268

        self.ZoomFit = False

   269

   270

        # Create figure for drawing graphs

   271

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

   272

        # Defined border around figure in canvas

   273

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

   274

                                       bottom=0.1, right=0.95)

   275

   276

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

   277

        self.SetWindowStyle(wx.WANTS_CHARS)

   278

        self.SetBackgroundColour(wx.WHITE)

   279

   280

        # Bind wx events

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

   288

        # Set canvas min size

   289

        canvas_size = self.GetCanvasMinSize()

   290

        self.SetMinSize(canvas_size)

   291

   292

        # Define Viewer drop target

   293

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   294

   295

        # Connect matplotlib events

   296

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

   297

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

   298

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

   299

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

   300

   301

        # Add buttons for zooming on current displayed data range

   302

        self.Buttons.append(

   303

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

   304

   305

        # Add buttons for changing canvas size with predefined height

   306

        for size, bitmap in zip(

   307

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   308

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

   309

            self.Buttons.append(

   310

                    GraphButton(0, 0, bitmap, 

   311

                                self.GetOnChangeSizeButton(size)))

   312

   313

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

   314

        for bitmap, callback in [

   315

                ("export_graph_mini", self.OnExportGraphButton),

   316

                ("delete_graph", self.OnCloseButton)]:

   317

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

   318

   319

        # Update graphs elements

   320

        self.ResetGraphics()

   321

        self.RefreshLabelsPosition(canvas_size.height)

   322

   323

    def AddItem(self, item):

   324

        """

   325

        Add an item to the list of items displayed by Viewer

   326

        @param item: Item to add to the list

   327

        """

   328

        DebugVariableViewer.AddItem(self, item)

   329

        self.ResetGraphics()

   330

   331

    def RemoveItem(self, item):

   332

        """

   333

        Remove an item from the list of items displayed by Viewer

   334

        @param item: Item to remove from the list

   335

        """

   336

        DebugVariableViewer.RemoveItem(self, item)

   337

   338

        # If list of items is not empty

   339

        if not self.ItemsIsEmpty():

   340

            # Return to parallel graph if there is only one item

   341

            # especially if it's actually orthogonal

   342

            if len(self.Items) == 1:

   343

                self.GraphType = GRAPH_PARALLEL

   344

            self.ResetGraphics()

   345

   346

    def SetCursorTick(self, cursor_tick):

   347

        """

   348

        Set cursor tick

   349

        @param cursor_tick: Cursor tick

   350

        """

   351

        self.CursorTick = cursor_tick

   352

   353

    def SetZoomFit(self, zoom_fit):

   354

        """

   355

        Set flag indicating that zoom fit current displayed data range

   356

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

   357

        """

   358

        # Flag is different from the actual one 

   359

        if zoom_fit != self.ZoomFit:

   360

            # Save new flag value

   361

            self.ZoomFit = zoom_fit

   362

   363

            # Update button for zoom fit bitmap

   364

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

   365

   366

            # Refresh canvas

   367

            self.RefreshViewer()

   368

   369

    def SubscribeAllDataConsumers(self):

   370

        """

   371

        Function that unsubscribe and remove every item that store values of

   372

        a variable that doesn't exist in PLC anymore

   373

        """

   374

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   375

   376

        # Graph still have data to display

   377

        if not self.ItemsIsEmpty():

   378

            # Reset flag indicating that zoom fit current displayed data range

   379

            self.SetZoomFit(False)

   380

   381

            self.ResetGraphics()

   382

   383

    def Is3DCanvas(self):

   384

        """

   385

        Return if Viewer is a 3D canvas

   386

        @return: True if Viewer is a 3D canvas

   387

        """

   388

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

   389

   390

    def GetButtons(self):

   391

        """

   392

        Return list of buttons defined in Viewer

   393

        @return: List of buttons

   394

        """

   395

        # Add contextual buttons to default buttons

   396

        return self.Buttons + self.ContextualButtons

   397

   398

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

   399

        """

   400

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

   401

        by the bounding box of label in figure

   402

        @param item: Item for which contextual is shown

   403

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

   404

        @param direction: Direction in which buttons must be drawn

   405

        """

   406

        # Return immediately if contextual menu for item is already shown

   407

        if self.ContextualButtonsItem == item:

   408

            return

   409

   410

        # Close already shown contextual menu

   411

        self.DismissContextualButtons()

   412

   413

        # Save item for which contextual menu is shown

   414

        self.ContextualButtonsItem = item

   415

   416

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

   417

        # contextual menu

   418

        if self.ContextualButtonsItem.IsForced():

   419

            self.ContextualButtons.append(

   420

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

   421

   422

        # Add other buttons to contextual menu

   423

        for bitmap, callback in [

   424

                ("force", self.OnForceItemButton),

   425

                ("export_graph_mini", self.OnExportItemGraphButton),

   426

                ("delete_graph", self.OnRemoveItemButton)]:

   427

            self.ContextualButtons.append(

   428

                    GraphButton(0, 0, bitmap, callback))

   429

   430

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

   431

        # will be set in reverse order

   432

        buttons = self.ContextualButtons[:]

   433

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

   434

             buttons.reverse()

   435

   436

        # Set contextual menu buttons position aside rect depending on

   437

        # direction given

   438

        offset = 0

   439

        for button in buttons:

   440

            w, h = button.GetSize()

   441

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

   442

                x = rect.x + (- w - offset

   443

                            if direction == wx.LEFT

   444

                            else rect.width + offset)

   445

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

   446

                offset += w

   447

            else:

   448

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

   449

                y = rect.y + (- h - offset

   450

                              if direction == wx.TOP

   451

                              else rect.height + offset)

   452

                offset += h

   453

            button.SetPosition(x, y)

   454

            button.Show()

   455

   456

        # Refresh canvas

   457

        self.ParentWindow.ForceRefresh()

   458

   459

    def DismissContextualButtons(self):

   460

        """

   461

        Close current shown contextual menu

   462

        """

   463

        # Return immediately if no contextual menu is shown

   464

        if self.ContextualButtonsItem is None:

   465

            return

   466

   467

        # Reset variables corresponding to contextual menu

   468

        self.ContextualButtonsItem = None

   469

        self.ContextualButtons = []

   470

   471

        # Refresh canvas

   472

        self.ParentWindow.ForceRefresh()

   473

   474

    def IsOverContextualButton(self, x, y):

   475

        """

   476

        Return if point is over one contextual button of Viewer

   477

        @param x: X coordinate of point

   478

        @param y: Y coordinate of point

   479

        @return: contextual button where point is over

   480

        """

   481

        for button in self.ContextualButtons:

   482

            if button.HitTest(x, y):

   483

                return button

   484

        return None

   485

   486

    def ExportGraph(self, item=None):

   487

        """

   488

        Export item(s) data to clipboard in CSV format

   489

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

   490

        (default None)

   491

        """