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 __future__ import division

    28

from types import TupleType

    29

from time import time as gettime

    30

from cycler import cycler

    31

    32

import numpy

    33

import wx

    34

import matplotlib

    35

import matplotlib.pyplot

    36

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    37

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    38

from matplotlib.backends.backend_agg import FigureCanvasAgg

    39

from mpl_toolkits.mplot3d import Axes3D

    40

from six.moves import xrange

    41

    42

from editors.DebugViewer import REFRESH_PERIOD

    43

from controls.DebugVariablePanel.DebugVariableViewer import *

    44

from controls.DebugVariablePanel.GraphButton import GraphButton

    45

    46

    47

# Graph variable display type

    48

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    49

    50

# Canvas height

    51

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

    52

    53

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

    54

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

    55

VALUE_LABEL_HEIGHT = 17.    # Height of variable label in graph

    56

AXES_LABEL_HEIGHT = 12.75   # Height of variable value in graph

    57

    58

# Colors used cyclically for graph curves

    59

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

    60

# Color for graph cursor

    61

CURSOR_COLOR = '#800080'

    62

    63

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

    64

#                      Debug Variable Graphic Viewer Helpers

    65

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

    66

    67

    68

def merge_ranges(ranges):

    69

    """

    70

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

    71

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

    72

    around graph in canvas

    73

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

    74

    @return: merged_range_min_value, merged_range_max_value

    75

    """

    76

    # Get minimal and maximal range value

    77

    min_value = max_value = None

    78

    for range_min, range_max in ranges:

    79

        # Update minimal range value

    80

        if min_value is None:

    81

            min_value = range_min

    82

        elif range_min is not None:

    83

            min_value = min(min_value, range_min)

    84

    85

        # Update maximal range value

    86

        if max_value is None:

    87

            max_value = range_max

    88

        elif range_min is not None:

    89

            max_value = max(max_value, range_max)

    90

    91

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

    92

    if min_value is not None and max_value is not None:

    93

        center = (min_value + max_value) / 2.

    94

        range_size = max(1.0, max_value - min_value)

    95

    96

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

    97

    else:

    98

        center = 0.5

    99

        range_size = 1.0

   100

   101

    # Return range expended from 10 %

   102

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

   103

   104

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

   105

#                   Debug Variable Graphic Viewer Drop Target

   106

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

   107

   108

   109

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

   110

    """

   111

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

   112

    Viewer

   113

    """

   114

   115

    def __init__(self, parent, window):

   116

        """

   117

        Constructor

   118

        @param parent: Reference to Debug Variable Graphic Viewer

   119

        @param window: Reference to the Debug Variable Panel

   120

        """

   121

        wx.TextDropTarget.__init__(self)

   122

        self.ParentControl = parent

   123

        self.ParentWindow = window

   124

   125

    def __del__(self):

   126

        """

   127

        Destructor

   128

        """

   129

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

   130

        # Panel

   131

        self.ParentControl = None

   132

        self.ParentWindow = None

   133

   134

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

   135

        """

   136

        Function called when mouse is dragged over Drop Target

   137

        @param x: X coordinate of mouse pointer

   138

        @param y: Y coordinate of mouse pointer

   139

        @param d: Suggested default for return value

   140

        """

   141

        # Signal parent that mouse is dragged over

   142

        self.ParentControl.OnMouseDragging(x, y)

   143

   144

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

   145

   146

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

   147

        """

   148

        Function called when mouse is released in Drop Target

   149

        @param x: X coordinate of mouse pointer

   150

        @param y: Y coordinate of mouse pointer

   151

        @param data: Text associated to drag'n drop

   152

        """

   153

        # Signal Debug Variable Panel to reset highlight

   154

        self.ParentWindow.ResetHighlight()

   155

   156

        message = None

   157

   158

        # Check that data is valid regarding DebugVariablePanel

   159

        try:

   160

            values = eval(data)

   161

            if not isinstance(values, TupleType):

   162

                raise ValueError

   163

        except Exception:

   164

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

   165

            values = None

   166

   167

        # Display message if data is invalid

   168

        if message is not None:

   169

            wx.CallAfter(self.ShowMessage, message)

   170

   171

        # Data contain a reference to a variable to debug

   172

        elif values[1] == "debug":

   173

            target_idx = self.ParentControl.GetIndex()

   174

   175

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

   176

            # not 3D canvas, graphs will be merged

   177

            rect = self.ParentControl.GetAxesBoundingBox()

   178

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

   179

                # Default merge type is parallel

   180

                merge_type = GRAPH_PARALLEL

   181

   182

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

   183

                # wall be merged orthogonally

   184

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

   185

                                     rect.width / 2., rect.height)

   186

                if merge_rect.InsideXY(x, y):

   187

                    merge_type = GRAPH_ORTHOGONAL

   188

   189

                # Merge graphs

   190

                wx.CallAfter(self.ParentWindow.MergeGraphs,

   191

                             values[0], target_idx,

   192

                             merge_type, force=True)

   193

   194

            else:

   195

                _width, height = self.ParentControl.GetSize()

   196

   197

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

   198

                # according to the position of mouse in Viewer.

   199

                if y > height // 2:

   200

                    target_idx += 1

   201

   202

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

   203

                # Variable Panel

   204

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

   205

                    self.ParentWindow.MoveValue(values[0],

   206

                                                target_idx)

   207

   208

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

   209

                else:

   210

                    self.ParentWindow.InsertValue(values[0],

   211

                                                  target_idx,

   212

                                                  force=True)

   213

   214

    def OnLeave(self):

   215

        """

   216

        Function called when mouse is leave Drop Target

   217

        """

   218

        # Signal Debug Variable Panel to reset highlight

   219

        self.ParentWindow.ResetHighlight()

   220

        return wx.TextDropTarget.OnLeave(self)

   221

   222

    def ShowMessage(self, message):

   223

        """

   224

        Show error message in Error Dialog

   225

        @param message: Error message to display

   226

        """

   227

        dialog = wx.MessageDialog(self.ParentWindow,

   228

                                  message,

   229

                                  _("Error"),

   230

                                  wx.OK | wx.ICON_ERROR)

   231

        dialog.ShowModal()

   232

        dialog.Destroy()

   233

   234

   235

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

   236

#                      Debug Variable Graphic Viewer Class

   237

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

   238

   239

   240

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   241

    """

   242

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

   243

    """

   244

   245

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

   246

        """

   247

        Constructor

   248

        @param parent: Parent wx.Window of DebugVariableText

   249

        @param window: Reference to the Debug Variable Panel

   250

        @param items: List of DebugVariableItem displayed by Viewer

   251

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

   252

        """

   253

        DebugVariableViewer.__init__(self, window, items)

   254

   255

        self.GraphType = graph_type        # Graph type display

   256

        self.CursorTick = None             # Tick of the graph cursor

   257

   258

        # Mouse position when start dragging

   259

        self.MouseStartPos = None

   260

        # Tick when moving tick start

   261

        self.StartCursorTick = None

   262

        # Canvas size when starting to resize canvas

   263

        self.CanvasStartSize = None

   264

   265

        # List of current displayed contextual buttons

   266

        self.ContextualButtons = []

   267

        # Reference to item for which contextual buttons was displayed

   268

        self.ContextualButtonsItem = None

   269

   270

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

   271

        # data range if False

   272

        self.ZoomFit = False

   273

   274

        # Create figure for drawing graphs

   275

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

   276

        # Defined border around figure in canvas

   277

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

   278

                                       bottom=0.1, right=0.95)

   279

   280

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

   281

        self.SetWindowStyle(wx.WANTS_CHARS)

   282

        self.SetBackgroundColour(wx.WHITE)

   283

   284

        # Bind wx events

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

   292

        # Set canvas min size

   293

        canvas_size = self.GetCanvasMinSize()

   294

        self.SetMinSize(canvas_size)

   295

   296

        # Define Viewer drop target

   297

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   298

   299

        # Connect matplotlib events

   300

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

   301

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

   302

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

   303

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

   304

   305

        # Add buttons for zooming on current displayed data range

   306

        self.Buttons.append(

   307

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

   308

   309

        # Add buttons for changing canvas size with predefined height

   310

        for size, bitmap in zip(

   311

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   312

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

   313

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

   314

                                            self.GetOnChangeSizeButton(size)))

   315

   316

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

   317

        for bitmap, callback in [

   318

                ("export_graph_mini", self.OnExportGraphButton),

   319

                ("delete_graph", self.OnCloseButton)]:

   320

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

   321

   322

        # Update graphs elements

   323

        self.ResetGraphics()

   324

        self.RefreshLabelsPosition(canvas_size.height)

   325

   326

    def AddItem(self, item):

   327

        """

   328

        Add an item to the list of items displayed by Viewer

   329

        @param item: Item to add to the list

   330

        """

   331

        DebugVariableViewer.AddItem(self, item)

   332

        self.ResetGraphics()

   333

   334

    def RemoveItem(self, item):

   335

        """

   336

        Remove an item from the list of items displayed by Viewer

   337

        @param item: Item to remove from the list

   338

        """

   339

        DebugVariableViewer.RemoveItem(self, item)

   340

   341

        # If list of items is not empty

   342

        if not self.ItemsIsEmpty():

   343

            # Return to parallel graph if there is only one item

   344

            # especially if it's actually orthogonal

   345

            if len(self.Items) == 1:

   346

                self.GraphType = GRAPH_PARALLEL

   347

            self.ResetGraphics()

   348

   349

    def SetCursorTick(self, cursor_tick):

   350

        """

   351

        Set cursor tick

   352

        @param cursor_tick: Cursor tick

   353

        """

   354

        self.CursorTick = cursor_tick

   355

   356

    def SetZoomFit(self, zoom_fit):

   357

        """

   358

        Set flag indicating that zoom fit current displayed data range

   359

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

   360

        """

   361

        # Flag is different from the actual one

   362

        if zoom_fit != self.ZoomFit:

   363

            # Save new flag value

   364

            self.ZoomFit = zoom_fit

   365

   366

            # Update button for zoom fit bitmap

   367

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

   368

   369

            # Refresh canvas

   370

            self.RefreshViewer()

   371

   372

    def SubscribeAllDataConsumers(self):

   373

        """

   374

        Function that unsubscribe and remove every item that store values of

   375

        a variable that doesn't exist in PLC anymore

   376

        """

   377

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   378

   379

        # Graph still have data to display

   380

        if not self.ItemsIsEmpty():

   381

            # Reset flag indicating that zoom fit current displayed data range

   382

            self.SetZoomFit(False)

   383

   384

            self.ResetGraphics()

   385

   386

    def Is3DCanvas(self):

   387

        """

   388

        Return if Viewer is a 3D canvas

   389

        @return: True if Viewer is a 3D canvas

   390

        """

   391

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

   392

   393

    def GetButtons(self):

   394

        """

   395

        Return list of buttons defined in Viewer

   396

        @return: List of buttons

   397

        """

   398

        # Add contextual buttons to default buttons

   399

        return self.Buttons + self.ContextualButtons

   400

   401

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

   402

        """

   403

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

   404

        by the bounding box of label in figure

   405

        @param item: Item for which contextual is shown

   406

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

   407

        @param direction: Direction in which buttons must be drawn

   408

        """

   409

        # Return immediately if contextual menu for item is already shown

   410

        if self.ContextualButtonsItem == item:

   411

            return

   412

   413

        # Close already shown contextual menu

   414

        self.DismissContextualButtons()

   415

   416

        # Save item for which contextual menu is shown

   417

        self.ContextualButtonsItem = item

   418

   419

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

   420

        # contextual menu

   421

        if self.ContextualButtonsItem.IsForced():

   422

            self.ContextualButtons.append(

   423

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

   424

   425

        # Add other buttons to contextual menu

   426

        for bitmap, callback in [

   427

                ("force", self.OnForceItemButton),

   428

                ("export_graph_mini", self.OnExportItemGraphButton),

   429

                ("delete_graph", self.OnRemoveItemButton)]:

   430

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

   431

   432

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

   433

        # will be set in reverse order

   434

        buttons = self.ContextualButtons[:]

   435

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

   436

            buttons.reverse()

   437

   438

        # Set contextual menu buttons position aside rect depending on

   439

        # direction given

   440

        offset = 0

   441

        for button in buttons:

   442

            w, h = button.GetSize()

   443

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

   444

                x = rect.x + (- w - offset

   445

                              if direction == wx.LEFT

   446

                              else rect.width + offset)

   447

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

   448

                offset += w

   449

            else:

   450

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

   451

                y = rect.y + (- h - offset

   452

                              if direction == wx.TOP

   453

                              else rect.height + offset)

   454

                offset += h

   455

            button.SetPosition(x, y)

   456

            button.Show()

   457

   458

        # Refresh canvas

   459

        self.ParentWindow.ForceRefresh()

   460

   461

    def DismissContextualButtons(self):

   462

        """

   463

        Close current shown contextual menu

   464

        """

   465

        # Return immediately if no contextual menu is shown

   466

        if self.ContextualButtonsItem is None:

   467

            return

   468

   469

        # Reset variables corresponding to contextual menu

   470

        self.ContextualButtonsItem = None

   471

        self.ContextualButtons = []

   472

   473

        # Refresh canvas

   474

        self.ParentWindow.ForceRefresh()

   475

   476

    def IsOverContextualButton(self, x, y):

   477

        """

   478

        Return if point is over one contextual button of Viewer

   479

        @param x: X coordinate of point

   480

        @param y: Y coordinate of point

   481

        @return: contextual button where point is over