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

            return False

   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.Contains(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.Contains(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

            return True

   214

        return False

   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

   285

        # Bind wx events

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

   293

        # Set canvas min size

   294

        canvas_size = self.GetCanvasMinSize()

   295

        self.SetMinSize(canvas_size)

   296

   297

        # Define Viewer drop target

   298

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   299

   300

        # Connect matplotlib events

   301

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

   302

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

   303

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

   304

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

   305

   306

        # Add buttons for zooming on current displayed data range

   307

        self.Buttons.append(

   308

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

   309

   310

        # Add buttons for changing canvas size with predefined height

   311

        for size, bitmap in zip(

   312

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   313

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

   314

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

   315

                                            self.GetOnChangeSizeButton(size)))

   316

   317

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

   318

        for bitmap, callback in [

   319

                ("export_graph_mini", self.OnExportGraphButton),

   320

                ("delete_graph", self.OnCloseButton)]:

   321

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

   322

   323

        # Update graphs elements

   324

        self.ResetGraphics()

   325

        self.RefreshLabelsPosition(canvas_size.height)

   326

   327

    def AddItem(self, item):

   328

        """

   329

        Add an item to the list of items displayed by Viewer

   330

        @param item: Item to add to the list

   331

        """

   332

        DebugVariableViewer.AddItem(self, item)

   333

        self.ResetGraphics()

   334

   335

    def RemoveItem(self, item):

   336

        """

   337

        Remove an item from the list of items displayed by Viewer

   338

        @param item: Item to remove from the list

   339

        """

   340

        DebugVariableViewer.RemoveItem(self, item)

   341

   342

        # If list of items is not empty

   343

        if not self.ItemsIsEmpty():

   344

            # Return to parallel graph if there is only one item

   345

            # especially if it's actually orthogonal

   346

            if len(self.Items) == 1:

   347

                self.GraphType = GRAPH_PARALLEL

   348

            self.ResetGraphics()

   349

   350

    def SetCursorTick(self, cursor_tick):

   351

        """

   352

        Set cursor tick

   353

        @param cursor_tick: Cursor tick

   354

        """

   355

        self.CursorTick = cursor_tick

   356

   357

    def SetZoomFit(self, zoom_fit):

   358

        """

   359

        Set flag indicating that zoom fit current displayed data range

   360

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

   361

        """

   362

        # Flag is different from the actual one

   363

        if zoom_fit != self.ZoomFit:

   364

            # Save new flag value

   365

            self.ZoomFit = zoom_fit

   366

   367

            # Update button for zoom fit bitmap

   368

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

   369

   370

            # Refresh canvas

   371

            self.RefreshViewer()

   372

   373

    def SubscribeAllDataConsumers(self):

   374

        """

   375

        Function that unsubscribe and remove every item that store values of

   376

        a variable that doesn't exist in PLC anymore

   377

        """

   378

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   379

   380

        # Graph still have data to display

   381

        if not self.ItemsIsEmpty():

   382

            # Reset flag indicating that zoom fit current displayed data range

   383

            self.SetZoomFit(False)

   384

   385

            self.ResetGraphics()

   386

   387

    def Is3DCanvas(self):

   388

        """

   389

        Return if Viewer is a 3D canvas

   390

        @return: True if Viewer is a 3D canvas

   391

        """

   392

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

   393

   394

    def GetButtons(self):

   395

        """

   396

        Return list of buttons defined in Viewer

   397

        @return: List of buttons

   398

        """

   399

        # Add contextual buttons to default buttons

   400

        return self.Buttons + self.ContextualButtons

   401

   402

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

   403

        """

   404

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

   405

        by the bounding box of label in figure

   406

        @param item: Item for which contextual is shown

   407

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

   408

        @param direction: Direction in which buttons must be drawn

   409

        """

   410

        # Return immediately if contextual menu for item is already shown

   411

        if self.ContextualButtonsItem == item:

   412

            return

   413

   414

        # Close already shown contextual menu

   415

        self.DismissContextualButtons()

   416

   417

        # Save item for which contextual menu is shown

   418

        self.ContextualButtonsItem = item

   419

   420

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

   421

        # contextual menu

   422

        if self.ContextualButtonsItem.IsForced():

   423

            self.ContextualButtons.append(

   424

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

   425

   426

        # Add other buttons to contextual menu

   427

        for bitmap, callback in [

   428

                ("force", self.OnForceItemButton),

   429

                ("export_graph_mini", self.OnExportItemGraphButton),

   430

                ("delete_graph", self.OnRemoveItemButton)]:

   431

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

   432

   433

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

   434

        # will be set in reverse order

   435

        buttons = self.ContextualButtons[:]

   436

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

   437

            buttons.reverse()

   438

   439

        # Set contextual menu buttons position aside rect depending on

   440

        # direction given

   441

        offset = 0

   442

        for button in buttons:

   443

            w, h = button.GetSize()

   444

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

   445

                x = rect.x + (- w - offset

   446

                              if direction == wx.LEFT

   447

                              else rect.width + offset)

   448

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

   449

                offset += w

   450

            else:

   451

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

   452

                y = rect.y + (- h - offset

   453

                              if direction == wx.TOP

   454

                              else rect.height + offset)

   455

                offset += h

   456

            button.SetPosition(x, y)

   457

            button.Show()

   458

   459

        # Refresh canvas

   460

        self.ParentWindow.ForceRefresh()

   461

   462

    def DismissContextualButtons(self):

   463

        """

   464

        Close current shown contextual menu

   465

        """

   466

        # Return immediately if no contextual menu is shown

   467

        if self.ContextualButtonsItem is None:

   468

            return

   469

   470

        # Reset variables corresponding to contextual menu

   471

        self.ContextualButtonsItem = None

   472

        self.ContextualButtons = []

   473

   474

        # Refresh canvas

   475

        self.ParentWindow.ForceRefresh()

   476

   477

    def IsOverContextualButton(self, x, y):

   478

        """

   479

        Return if point is over one contextual button of Viewer

   480

        @param x: X coordinate of point

   481