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

    45

from distutils.version import LooseVersion

    46

if LooseVersion(matplotlib.__version__) >= LooseVersion("1.5.0"):

    47

    from cycler import cycler

    48

    49

    50

# Graph variable display type

    51

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    52

    53

# Canvas height

    54

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

    55

    56

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

    57

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

    58

VALUE_LABEL_HEIGHT = 17.   # Height of variable label in graph

    59

AXES_LABEL_HEIGHT = 12.75  # Height of variable value in graph

    60

    61

# Colors used cyclically for graph curves

    62

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

    63

# Color for graph cursor

    64

CURSOR_COLOR = '#800080'

    65

    66

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

    67

#                      Debug Variable Graphic Viewer Helpers

    68

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

    69

    70

def merge_ranges(ranges):

    71

    """

    72

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

    73

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

    74

    around graph in canvas

    75

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

    76

    @return: merged_range_min_value, merged_range_max_value

    77

    """

    78

    # Get minimal and maximal range value

    79

    min_value = max_value = None

    80

    for range_min, range_max in ranges:

    81

        # Update minimal range value

    82

        if min_value is None:

    83

            min_value = range_min

    84

        elif range_min is not None:

    85

            min_value = min(min_value, range_min)

    86

    87

        # Update maximal range value

    88

        if max_value is None:

    89

            max_value = range_max

    90

        elif range_min is not None:

    91

            max_value = max(max_value, range_max)

    92

    93

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

    94

    if min_value is not None and max_value is not None:

    95

        center = (min_value + max_value) / 2.

    96

        range_size = max(1.0, max_value - min_value)

    97

    98

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

    99

    else:

   100

        center = 0.5

   101

        range_size = 1.0

   102

   103

    # Return range expended from 10 %

   104

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

   105

   106

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

   107

#                   Debug Variable Graphic Viewer Drop Target

   108

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

   109

   110

"""

   111

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

   112

Viewer

   113

"""

   114

   115

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

   116

   117

    def __init__(self, parent, window):

   118

        """

   119

        Constructor

   120

        @param parent: Reference to Debug Variable Graphic Viewer

   121

        @param window: Reference to the Debug Variable Panel

   122

        """

   123

        wx.TextDropTarget.__init__(self)

   124

        self.ParentControl = parent

   125

        self.ParentWindow = window

   126

   127

    def __del__(self):

   128

        """

   129

        Destructor

   130

        """

   131

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

   132

        # Panel

   133

        self.ParentControl = None

   134

        self.ParentWindow = None

   135

   136

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

   137

        """

   138

        Function called when mouse is dragged over Drop Target

   139

        @param x: X coordinate of mouse pointer

   140

        @param y: Y coordinate of mouse pointer

   141

        @param d: Suggested default for return value

   142

        """

   143

        # Signal parent that mouse is dragged over

   144

        self.ParentControl.OnMouseDragging(x, y)

   145

   146

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

   147

   148

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

   149

        """

   150

        Function called when mouse is released in Drop Target

   151

        @param x: X coordinate of mouse pointer

   152

        @param y: Y coordinate of mouse pointer

   153

        @param data: Text associated to drag'n drop

   154

        """

   155

        # Signal Debug Variable Panel to reset highlight

   156

        self.ParentWindow.ResetHighlight()

   157

   158

        message = None

   159

   160

        # Check that data is valid regarding DebugVariablePanel

   161

        try:

   162

            values = eval(data)

   163

            if not isinstance(values, TupleType):

   164

                raise ValueError

   165

        except:

   166

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

   167

            values = None

   168

   169

        # Display message if data is invalid

   170

        if message is not None:

   171

            wx.CallAfter(self.ShowMessage, message)

   172

   173

        # Data contain a reference to a variable to debug

   174

        elif values[1] == "debug":

   175

            target_idx = self.ParentControl.GetIndex()

   176

   177

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

   178

            # not 3D canvas, graphs will be merged

   179

            rect = self.ParentControl.GetAxesBoundingBox()

   180

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

   181

                # Default merge type is parallel

   182

                merge_type = GRAPH_PARALLEL

   183

   184

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

   185

                # wall be merged orthogonally

   186

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

   187

                                     rect.width / 2., rect.height)

   188

                if merge_rect.InsideXY(x, y):

   189

                    merge_type = GRAPH_ORTHOGONAL

   190

   191

                # Merge graphs

   192

                wx.CallAfter(self.ParentWindow.MergeGraphs, 

   193

                             values[0], target_idx, 

   194

                             merge_type, force=True)

   195

   196

            else:

   197

                width, height = self.ParentControl.GetSize()

   198

   199

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

   200

                # according to the position of mouse in Viewer.

   201

                if y > height / 2:

   202

                    target_idx += 1

   203

   204

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

   205

                # Variable Panel 

   206

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

   207

                    self.ParentWindow.MoveValue(values[0], 

   208

                                                target_idx)

   209

   210

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

   211

                else:

   212

                    self.ParentWindow.InsertValue(values[0], 

   213

                                                  target_idx, 

   214

                                                  force=True)

   215

   216

    def OnLeave(self):

   217

        """

   218

        Function called when mouse is leave Drop Target

   219

        """

   220

        # Signal Debug Variable Panel to reset highlight

   221

        self.ParentWindow.ResetHighlight()

   222

        return wx.TextDropTarget.OnLeave(self)

   223

   224

    def ShowMessage(self, message):

   225

        """

   226

        Show error message in Error Dialog

   227

        @param message: Error message to display

   228

        """

   229

        dialog = wx.MessageDialog(self.ParentWindow, 

   230

                                  message, 

   231

                                  _("Error"), 

   232

                                  wx.OK|wx.ICON_ERROR)

   233

        dialog.ShowModal()

   234

        dialog.Destroy()

   235

   236

   237

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

   238

#                      Debug Variable Graphic Viewer Class

   239

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

   240

   241

"""

   242

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

   243

"""

   244

   245

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   246

   247

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

   248

        """

   249

        Constructor

   250

        @param parent: Parent wx.Window of DebugVariableText

   251

        @param window: Reference to the Debug Variable Panel

   252

        @param items: List of DebugVariableItem displayed by Viewer

   253

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

   254

        """

   255

        DebugVariableViewer.__init__(self, window, items)

   256

   257

        self.GraphType = graph_type        # Graph type display

   258

        self.CursorTick = None             # Tick of the graph cursor

   259

   260

        # Mouse position when start dragging

   261

        self.MouseStartPos = None

   262

        # Tick when moving tick start

   263

        self.StartCursorTick = None

   264

        # Canvas size when starting to resize canvas

   265

        self.CanvasStartSize = None        

   266

   267

        # List of current displayed contextual buttons

   268

        self.ContextualButtons = []

   269

        # Reference to item for which contextual buttons was displayed

   270

        self.ContextualButtonsItem = None

   271

   272

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

   273

        # data range if False

   274

        self.ZoomFit = False

   275

   276

        # Create figure for drawing graphs

   277

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

   278

        # Defined border around figure in canvas

   279

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

   280

                                       bottom=0.1, right=0.95)

   281

   282

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

   283

        self.SetWindowStyle(wx.WANTS_CHARS)

   284

        self.SetBackgroundColour(wx.WHITE)

   285

   286

        # Bind wx events

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

   294

        # Set canvas min size

   295

        canvas_size = self.GetCanvasMinSize()

   296

        self.SetMinSize(canvas_size)

   297

   298

        # Define Viewer drop target

   299

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   300

   301

        # Connect matplotlib events

   302

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

   303

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

   304

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

   305

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

   306

   307

        # Add buttons for zooming on current displayed data range

   308

        self.Buttons.append(

   309

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

   310

   311

        # Add buttons for changing canvas size with predefined height

   312

        for size, bitmap in zip(

   313

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   314

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

   315

            self.Buttons.append(

   316

                    GraphButton(0, 0, bitmap, 

   317

                                self.GetOnChangeSizeButton(size)))

   318

   319

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

   320

        for bitmap, callback in [

   321

                ("export_graph_mini", self.OnExportGraphButton),

   322

                ("delete_graph", self.OnCloseButton)]:

   323

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

   324

   325

        # Update graphs elements

   326

        self.ResetGraphics()

   327

        self.RefreshLabelsPosition(canvas_size.height)

   328

   329

    def AddItem(self, item):

   330

        """

   331

        Add an item to the list of items displayed by Viewer

   332

        @param item: Item to add to the list

   333

        """

   334

        DebugVariableViewer.AddItem(self, item)

   335

        self.ResetGraphics()

   336

   337

    def RemoveItem(self, item):

   338

        """

   339

        Remove an item from the list of items displayed by Viewer

   340

        @param item: Item to remove from the list

   341

        """

   342

        DebugVariableViewer.RemoveItem(self, item)

   343

   344

        # If list of items is not empty

   345

        if not self.ItemsIsEmpty():

   346

            # Return to parallel graph if there is only one item

   347

            # especially if it's actually orthogonal

   348

            if len(self.Items) == 1:

   349

                self.GraphType = GRAPH_PARALLEL

   350

            self.ResetGraphics()

   351

   352

    def SetCursorTick(self, cursor_tick):

   353

        """

   354

        Set cursor tick

   355

        @param cursor_tick: Cursor tick

   356

        """

   357

        self.CursorTick = cursor_tick

   358

   359

    def SetZoomFit(self, zoom_fit):

   360

        """

   361

        Set flag indicating that zoom fit current displayed data range

   362

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

   363

        """

   364

        # Flag is different from the actual one 

   365

        if zoom_fit != self.ZoomFit:

   366

            # Save new flag value

   367

            self.ZoomFit = zoom_fit

   368

   369

            # Update button for zoom fit bitmap

   370

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

   371

   372

            # Refresh canvas

   373

            self.RefreshViewer()

   374

   375

    def SubscribeAllDataConsumers(self):

   376

        """

   377

        Function that unsubscribe and remove every item that store values of

   378

        a variable that doesn't exist in PLC anymore

   379

        """

   380

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   381

   382

        # Graph still have data to display

   383

        if not self.ItemsIsEmpty():

   384

            # Reset flag indicating that zoom fit current displayed data range

   385

            self.SetZoomFit(False)

   386

   387

            self.ResetGraphics()

   388

   389

    def Is3DCanvas(self):

   390

        """

   391

        Return if Viewer is a 3D canvas

   392

        @return: True if Viewer is a 3D canvas

   393

        """

   394

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

   395

   396

    def GetButtons(self):

   397

        """

   398

        Return list of buttons defined in Viewer

   399

        @return: List of buttons

   400

        """

   401

        # Add contextual buttons to default buttons

   402

        return self.Buttons + self.ContextualButtons

   403

   404

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

   405

        """

   406

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

   407

        by the bounding box of label in figure

   408

        @param item: Item for which contextual is shown

   409

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

   410

        @param direction: Direction in which buttons must be drawn

   411

        """

   412

        # Return immediately if contextual menu for item is already shown

   413

        if self.ContextualButtonsItem == item:

   414

            return

   415

   416

        # Close already shown contextual menu

   417

        self.DismissContextualButtons()

   418

   419

        # Save item for which contextual menu is shown

   420

        self.ContextualButtonsItem = item

   421

   422

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

   423

        # contextual menu

   424

        if self.ContextualButtonsItem.IsForced():

   425

            self.ContextualButtons.append(

   426

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

   427

   428

        # Add other buttons to contextual menu

   429

        for bitmap, callback in [

   430

                ("force", self.OnForceItemButton),

   431

                ("export_graph_mini", self.OnExportItemGraphButton),

   432

                ("delete_graph", self.OnRemoveItemButton)]:

   433

            self.ContextualButtons.append(

   434

                    GraphButton(0, 0, bitmap, callback))

   435

   436

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

   437

        # will be set in reverse order

   438

        buttons = self.ContextualButtons[:]

   439

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

   440

             buttons.reverse()

   441

   442

        # Set contextual menu buttons position aside rect depending on

   443

        # direction given

   444

        offset = 0

   445

        for button in buttons:

   446

            w, h = button.GetSize()

   447

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

   448

                x = rect.x + (- w - offset

   449

                            if direction == wx.LEFT

   450

                            else rect.width + offset)

   451

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

   452

                offset += w

   453

            else:

   454

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

   455

                y = rect.y + (- h - offset

   456

                              if direction == wx.TOP

   457

                              else rect.height + offset)

   458

                offset += h

   459

            button.SetPosition(x, y)

   460

            button.Show()

   461

   462

        # Refresh canvas

   463

        self.ParentWindow.ForceRefresh()

   464

   465

    def DismissContextualButtons(self):

   466

        """

   467

        Close current shown contextual menu

   468

        """

   469

        # Return immediately if no contextual menu is shown

   470

        if self.ContextualButtonsItem is None:

   471

            return

   472

   473

        # Reset variables corresponding to contextual menu

   474

        self.ContextualButtonsItem = None

   475

        self.ContextualButtons = []

   476

   477

        # Refresh canvas

   478

        self.ParentWindow.ForceRefresh()

   479

   480

    def IsOverContextualButton(self, x, y):

   481

        """

   482

        Return if point is over one contextual button of Viewer

   483

        @param x: X coordinate of point

   484

        @param y: Y coordinate of point

   485

        @return: contextual button where point is over

   486

        """

   487

        for button in self.ContextualButtons:

   488

            if button.HitTest(x, y):

   489

                return button

   490

        return None

   491