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 time import time as gettime

    29

from cycler import cycler

    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

from six.moves import xrange

    40

    41

from editors.DebugViewer import REFRESH_PERIOD

    42

from controls.DebugVariablePanel.DebugVariableViewer import *

    43

from controls.DebugVariablePanel.GraphButton import GraphButton

    44

    45

    46

# Graph variable display type

    47

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    48

    49

# Canvas height

    50

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

    51

    52

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

    53

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

    54

VALUE_LABEL_HEIGHT = 17.    # Height of variable label in graph

    55

AXES_LABEL_HEIGHT = 12.75   # Height of variable value in graph

    56

    57

# Colors used cyclically for graph curves

    58

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

    59

# Color for graph cursor

    60

CURSOR_COLOR = '#800080'

    61

    62

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

    63

#                      Debug Variable Graphic Viewer Helpers

    64

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

    65

    66

    67

def merge_ranges(ranges):

    68

    """

    69

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

    70

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

    71

    around graph in canvas

    72

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

    73

    @return: merged_range_min_value, merged_range_max_value

    74

    """

    75

    # Get minimal and maximal range value

    76

    min_value = max_value = None

    77

    for range_min, range_max in ranges:

    78

        # Update minimal range value

    79

        if min_value is None:

    80

            min_value = range_min

    81

        elif range_min is not None:

    82

            min_value = min(min_value, range_min)

    83

    84

        # Update maximal range value

    85

        if max_value is None:

    86

            max_value = range_max

    87

        elif range_min is not None:

    88

            max_value = max(max_value, range_max)

    89

    90

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

    91

    if min_value is not None and max_value is not None:

    92

        center = (min_value + max_value) / 2.

    93

        range_size = max(1.0, max_value - min_value)

    94

    95

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

    96

    else:

    97

        center = 0.5

    98

        range_size = 1.0

    99

   100

    # Return range expended from 10 %

   101

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

   102

   103

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

   104

#                   Debug Variable Graphic Viewer Drop Target

   105

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

   106

   107

   108

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

   109

    """

   110

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

   111

    Viewer

   112

    """

   113

   114

    def __init__(self, parent, window):

   115

        """

   116

        Constructor

   117

        @param parent: Reference to Debug Variable Graphic Viewer

   118

        @param window: Reference to the Debug Variable Panel

   119

        """

   120

        wx.TextDropTarget.__init__(self)

   121

        self.ParentControl = parent

   122

        self.ParentWindow = window

   123

   124

    def __del__(self):

   125

        """

   126

        Destructor

   127

        """

   128

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

   129

        # Panel

   130

        self.ParentControl = None

   131

        self.ParentWindow = None

   132

   133

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

   134

        """

   135

        Function called when mouse is dragged over Drop Target

   136

        @param x: X coordinate of mouse pointer

   137

        @param y: Y coordinate of mouse pointer

   138

        @param d: Suggested default for return value

   139

        """

   140

        # Signal parent that mouse is dragged over

   141

        self.ParentControl.OnMouseDragging(x, y)

   142

   143

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

   144

   145

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

   146

        """

   147

        Function called when mouse is released in Drop Target

   148

        @param x: X coordinate of mouse pointer

   149

        @param y: Y coordinate of mouse pointer

   150

        @param data: Text associated to drag'n drop

   151

        """

   152

        # Signal Debug Variable Panel to reset highlight

   153

        self.ParentWindow.ResetHighlight()

   154

   155

        message = None

   156

   157

        # Check that data is valid regarding DebugVariablePanel

   158

        try:

   159

            values = eval(data)

   160

            if not isinstance(values, tuple):

   161

                raise ValueError

   162

        except Exception:

   163

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

   164

            values = None

   165

   166

        # Display message if data is invalid

   167

        if message is not None:

   168

            wx.CallAfter(self.ShowMessage, message)

   169

   170

        # Data contain a reference to a variable to debug

   171

        elif values[1] == "debug":

   172

            target_idx = self.ParentControl.GetIndex()

   173

   174

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

   175

            # not 3D canvas, graphs will be merged

   176

            rect = self.ParentControl.GetAxesBoundingBox()

   177

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

   178

                # Default merge type is parallel

   179

                merge_type = GRAPH_PARALLEL

   180

   181

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

   182

                # wall be merged orthogonally

   183

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

   184

                                     rect.width / 2., rect.height)

   185

                if merge_rect.InsideXY(x, y):

   186

                    merge_type = GRAPH_ORTHOGONAL

   187

   188

                # Merge graphs

   189

                wx.CallAfter(self.ParentWindow.MergeGraphs,

   190

                             values[0], target_idx,

   191

                             merge_type, force=True)

   192

   193

            else:

   194

                _width, height = self.ParentControl.GetSize()

   195

   196

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

   197

                # according to the position of mouse in Viewer.

   198

                if y > height // 2:

   199

                    target_idx += 1

   200

   201

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

   202

                # Variable Panel

   203

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

   204

                    self.ParentWindow.MoveValue(values[0],

   205

                                                target_idx)

   206

   207

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

   208

                else:

   209

                    self.ParentWindow.InsertValue(values[0],

   210

                                                  target_idx,

   211

                                                  force=True)

   212

   213

    def OnLeave(self):

   214

        """

   215

        Function called when mouse is leave Drop Target

   216

        """

   217

        # Signal Debug Variable Panel to reset highlight

   218

        self.ParentWindow.ResetHighlight()

   219

        return wx.TextDropTarget.OnLeave(self)

   220

   221

    def ShowMessage(self, message):

   222

        """

   223

        Show error message in Error Dialog

   224

        @param message: Error message to display

   225

        """

   226

        dialog = wx.MessageDialog(self.ParentWindow,

   227

                                  message,

   228

                                  _("Error"),

   229

                                  wx.OK | wx.ICON_ERROR)

   230

        dialog.ShowModal()

   231

        dialog.Destroy()

   232

   233

   234

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

   235

#                      Debug Variable Graphic Viewer Class

   236

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

   237

   238

   239

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   240

    """

   241

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

   242

    """

   243

   244

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

   245

        """

   246

        Constructor

   247

        @param parent: Parent wx.Window of DebugVariableText

   248

        @param window: Reference to the Debug Variable Panel

   249

        @param items: List of DebugVariableItem displayed by Viewer

   250

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

   251

        """

   252

        DebugVariableViewer.__init__(self, window, items)

   253

   254

        self.GraphType = graph_type        # Graph type display

   255

        self.CursorTick = None             # Tick of the graph cursor

   256

   257

        # Mouse position when start dragging

   258

        self.MouseStartPos = None

   259

        # Tick when moving tick start

   260

        self.StartCursorTick = None

   261

        # Canvas size when starting to resize canvas

   262

        self.CanvasStartSize = None

   263

   264

        # List of current displayed contextual buttons

   265

        self.ContextualButtons = []

   266

        # Reference to item for which contextual buttons was displayed

   267

        self.ContextualButtonsItem = None

   268

   269

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

   270

        # data range if False

   271

        self.ZoomFit = False

   272

   273

        # Create figure for drawing graphs

   274

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

   275

        # Defined border around figure in canvas

   276

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

   277

                                       bottom=0.1, right=0.95)

   278

   279

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

   280

        self.SetWindowStyle(wx.WANTS_CHARS)

   281

        self.SetBackgroundColour(wx.WHITE)

   282

   283

        # Bind wx events

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

   291

        # Set canvas min size

   292

        canvas_size = self.GetCanvasMinSize()

   293

        self.SetMinSize(canvas_size)

   294

   295

        # Define Viewer drop target

   296

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   297

   298

        # Connect matplotlib events

   299

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

   300

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

   301

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

   302

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

   303

   304

        # Add buttons for zooming on current displayed data range

   305

        self.Buttons.append(

   306

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

   307

   308

        # Add buttons for changing canvas size with predefined height

   309

        for size, bitmap in zip(

   310

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   311

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

   312

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

   313

                                            self.GetOnChangeSizeButton(size)))

   314

   315

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

   316

        for bitmap, callback in [

   317

                ("export_graph_mini", self.OnExportGraphButton),

   318

                ("delete_graph", self.OnCloseButton)]:

   319

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

   320

   321

        # Update graphs elements

   322

        self.ResetGraphics()

   323

        self.RefreshLabelsPosition(canvas_size.height)

   324

   325

    def AddItem(self, item):

   326

        """

   327

        Add an item to the list of items displayed by Viewer

   328

        @param item: Item to add to the list

   329

        """

   330

        DebugVariableViewer.AddItem(self, item)

   331

        self.ResetGraphics()

   332

   333

    def RemoveItem(self, item):

   334

        """

   335

        Remove an item from the list of items displayed by Viewer

   336

        @param item: Item to remove from the list

   337

        """

   338

        DebugVariableViewer.RemoveItem(self, item)

   339

   340

        # If list of items is not empty

   341

        if not self.ItemsIsEmpty():

   342

            # Return to parallel graph if there is only one item

   343

            # especially if it's actually orthogonal

   344

            if len(self.Items) == 1:

   345

                self.GraphType = GRAPH_PARALLEL

   346

            self.ResetGraphics()

   347

   348

    def SetCursorTick(self, cursor_tick):

   349

        """

   350

        Set cursor tick

   351

        @param cursor_tick: Cursor tick

   352

        """

   353

        self.CursorTick = cursor_tick

   354

   355

    def SetZoomFit(self, zoom_fit):

   356

        """

   357

        Set flag indicating that zoom fit current displayed data range

   358

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

   359

        """

   360

        # Flag is different from the actual one

   361

        if zoom_fit != self.ZoomFit:

   362

            # Save new flag value

   363

            self.ZoomFit = zoom_fit

   364

   365

            # Update button for zoom fit bitmap

   366

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

   367

   368

            # Refresh canvas

   369

            self.RefreshViewer()

   370

   371

    def SubscribeAllDataConsumers(self):

   372

        """

   373

        Function that unsubscribe and remove every item that store values of

   374

        a variable that doesn't exist in PLC anymore

   375

        """

   376

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   377

   378

        # Graph still have data to display

   379

        if not self.ItemsIsEmpty():

   380

            # Reset flag indicating that zoom fit current displayed data range

   381

            self.SetZoomFit(False)

   382

   383

            self.ResetGraphics()

   384

   385

    def Is3DCanvas(self):

   386

        """

   387

        Return if Viewer is a 3D canvas

   388

        @return: True if Viewer is a 3D canvas

   389

        """

   390

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

   391

   392

    def GetButtons(self):

   393

        """

   394

        Return list of buttons defined in Viewer

   395

        @return: List of buttons

   396

        """

   397

        # Add contextual buttons to default buttons

   398

        return self.Buttons + self.ContextualButtons

   399

   400

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

   401

        """

   402

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

   403

        by the bounding box of label in figure

   404

        @param item: Item for which contextual is shown

   405

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

   406

        @param direction: Direction in which buttons must be drawn

   407

        """

   408

        # Return immediately if contextual menu for item is already shown

   409

        if self.ContextualButtonsItem == item:

   410

            return

   411

   412

        # Close already shown contextual menu

   413

        self.DismissContextualButtons()

   414

   415

        # Save item for which contextual menu is shown

   416

        self.ContextualButtonsItem = item

   417

   418

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

   419

        # contextual menu

   420

        if self.ContextualButtonsItem.IsForced():

   421

            self.ContextualButtons.append(

   422

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

   423

   424

        # Add other buttons to contextual menu

   425

        for bitmap, callback in [

   426

                ("force", self.OnForceItemButton),

   427

                ("export_graph_mini", self.OnExportItemGraphButton),

   428

                ("delete_graph", self.OnRemoveItemButton)]:

   429

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

   430

   431

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

   432

        # will be set in reverse order

   433

        buttons = self.ContextualButtons[:]

   434

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

   435

            buttons.reverse()

   436

   437

        # Set contextual menu buttons position aside rect depending on

   438

        # direction given

   439

        offset = 0

   440

        for button in buttons:

   441

            w, h = button.GetSize()

   442

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

   443

                x = rect.x + (- w - offset

   444

                              if direction == wx.LEFT

   445

                              else rect.width + offset)

   446

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

   447

                offset += w

   448

            else:

   449

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

   450

                y = rect.y + (- h - offset

   451

                              if direction == wx.TOP

   452

                              else rect.height + offset)

   453

                offset += h

   454

            button.SetPosition(x, y)

   455

            button.Show()

   456

   457

        # Refresh canvas

   458

        self.ParentWindow.ForceRefresh()

   459

   460

    def DismissContextualButtons(self):

   461

        """

   462

        Close current shown contextual menu

   463

        """

   464

        # Return immediately if no contextual menu is shown

   465

        if self.ContextualButtonsItem is None:

   466

            return

   467

   468

        # Reset variables corresponding to contextual menu

   469

        self.ContextualButtonsItem = None

   470

        self.ContextualButtons = []

   471

   472

        # Refresh canvas

   473

        self.ParentWindow.ForceRefresh()

   474

   475

    def IsOverContextualButton(self, x, y):

   476

        """

   477

        Return if point is over one contextual button of Viewer

   478

        @param x: X coordinate of point

   479

        @param y: Y coordinate of point

   480

        @return: contextual button where point is over

   481

        """