1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2012: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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