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

    26

from __future__ import absolute_import

    27

from types import TupleType

    28

from time import time as gettime

    29

from distutils.version import LooseVersion

    30

    31

import numpy

    32

import wx

    33

import matplotlib

    34

import matplotlib.pyplot

    35

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    36

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    37

from matplotlib.backends.backend_agg import FigureCanvasAgg

    38

from mpl_toolkits.mplot3d import Axes3D

    39

    40

from editors.DebugViewer import REFRESH_PERIOD

    41

from controls.DebugVariablePanel.DebugVariableViewer import *

    42

from controls.DebugVariablePanel.GraphButton import GraphButton

    43

    44

    45

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

    46

    from cycler import cycler

    47

    48

    49

# Graph variable display type

    50

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    51

    52

# Canvas height

    53

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

    54

    56

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

    57

VALUE_LABEL_HEIGHT = 17.    # Height of variable label in graph

    58

AXES_LABEL_HEIGHT = 12.75   # Height of variable value in graph

    59

    60

# Colors used cyclically for graph curves

    61

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

    62

# Color for graph cursor

    63

CURSOR_COLOR = '#800080'

    64

    65

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

    66

#                      Debug Variable Graphic Viewer Helpers

    67

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

    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 DebugVariableGraphicDropTarget(wx.TextDropTarget):

   112

    """

   113

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

   114

    Viewer

   115

    """

   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 Exception:

   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 DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   243

    """

   244

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

   245

    """

   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(GraphButton(0, 0, bitmap,

   316

                                            self.GetOnChangeSizeButton(size)))

   317

   318

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

   319

        for bitmap, callback in [

   320

                ("export_graph_mini", self.OnExportGraphButton),

   321

                ("delete_graph", self.OnCloseButton)]:

   322

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

   323

   324

        # Update graphs elements

   325

        self.ResetGraphics()

   326

        self.RefreshLabelsPosition(canvas_size.height)

   327

   328

    def AddItem(self, item):

   329

        """

   330

        Add an item to the list of items displayed by Viewer

   331

        @param item: Item to add to the list

   332

        """

   333

        DebugVariableViewer.AddItem(self, item)

   334

        self.ResetGraphics()

   335

   336

    def RemoveItem(self, item):

   337

        """

   338

        Remove an item from the list of items displayed by Viewer

   339

        @param item: Item to remove from the list

   340

        """

   341

        DebugVariableViewer.RemoveItem(self, item)

   342

   343

        # If list of items is not empty

   344

        if not self.ItemsIsEmpty():

   345

            # Return to parallel graph if there is only one item

   346

            # especially if it's actually orthogonal

   347

            if len(self.Items) == 1:

   348

                self.GraphType = GRAPH_PARALLEL

   349

            self.ResetGraphics()

   350

   351

    def SetCursorTick(self, cursor_tick):

   352

        """

   353

        Set cursor tick

   354

        @param cursor_tick: Cursor tick

   355

        """

   356

        self.CursorTick = cursor_tick

   357

   358

    def SetZoomFit(self, zoom_fit):

   359

        """

   360

        Set flag indicating that zoom fit current displayed data range

   361

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

   362

        """

   363

        # Flag is different from the actual one

   364

        if zoom_fit != self.ZoomFit:

   365

            # Save new flag value

   366

            self.ZoomFit = zoom_fit

   367

   368

            # Update button for zoom fit bitmap

   369

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

   370

   371

            # Refresh canvas

   372

            self.RefreshViewer()

   373

   374

    def SubscribeAllDataConsumers(self):

   375

        """

   376

        Function that unsubscribe and remove every item that store values of

   377

        a variable that doesn't exist in PLC anymore

   378

        """

   379

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   380

   381

        # Graph still have data to display

   382

        if not self.ItemsIsEmpty():

   383

            # Reset flag indicating that zoom fit current displayed data range

   384

            self.SetZoomFit(False)

   385

   386

            self.ResetGraphics()

   387

   388

    def Is3DCanvas(self):

   389

        """

   390

        Return if Viewer is a 3D canvas

   391

        @return: True if Viewer is a 3D canvas

   392

        """

   393

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

   394

   395

    def GetButtons(self):

   396

        """

   397

        Return list of buttons defined in Viewer

   398

        @return: List of buttons

   399

        """

   400

        # Add contextual buttons to default buttons

   401

        return self.Buttons + self.ContextualButtons

   402

   403

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

   404

        """

   405

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

   406

        by the bounding box of label in figure

   407

        @param item: Item for which contextual is shown

   408

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

   409

        @param direction: Direction in which buttons must be drawn

   410

        """

   411

        # Return immediately if contextual menu for item is already shown

   412

        if self.ContextualButtonsItem == item:

   413

            return

   414

   415

        # Close already shown contextual menu

   416

        self.DismissContextualButtons()

   417

   418

        # Save item for which contextual menu is shown

   419

        self.ContextualButtonsItem = item

   420

   421

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

   422

        # contextual menu

   423

        if self.ContextualButtonsItem.IsForced():

   424

            self.ContextualButtons.append(

   425

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

   426

   427

        # Add other buttons to contextual menu

   428

        for bitmap, callback in [

   429

                ("force", self.OnForceItemButton),

   430

                ("export_graph_mini", self.OnExportItemGraphButton),

   431

                ("delete_graph", self.OnRemoveItemButton)]:

   432

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

   433

   434

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

   435

        # will be set in reverse order

   436

        buttons = self.ContextualButtons[:]

   437

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

   438

            buttons.reverse()

   439

   440

        # Set contextual menu buttons position aside rect depending on

   441

        # direction given

   442

        offset = 0

   443

        for button in buttons:

   444

            w, h = button.GetSize()

   445

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

   446

                x = rect.x + (- w - offset

   447

                              if direction == wx.LEFT

   448

                              else rect.width + offset)

   449

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

   450

                offset += w

   451

            else:

   452

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

   453

                y = rect.y + (- h - offset

   454

                              if direction == wx.TOP

   455

                              else rect.height + offset)

   456

                offset += h

   457

            button.SetPosition(x, y)

   458

            button.Show()

   459

   460

        # Refresh canvas

   461

        self.ParentWindow.ForceRefresh()

   462

   463

    def DismissContextualButtons(self):

   464

        """

   465

        Close current shown contextual menu

   466

        """

   467

        # Return immediately if no contextual menu is shown

   468

        if self.ContextualButtonsItem is None:

   469

            return

   470

   471

        # Reset variables corresponding to contextual menu

   472

        self.ContextualButtonsItem = None

   473

        self.ContextualButtons = []

   474

   475

        # Refresh canvas

   476

        self.ParentWindow.ForceRefresh()

   477

   478

    def IsOverContextualButton(self, x, y):

   479

        """

   480

        Return if point is over one contextual button of Viewer

   481

        @param x: X coordinate of point

   482