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

    40

from editors.DebugViewer import REFRESH_PERIOD

    41

from controls.DebugVariablePanel.DebugVariableViewer import *

    42

from controls.DebugVariablePanel.GraphButton import GraphButton

    43

    44

    45

# Graph variable display type

    46

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    47

    48

# Canvas height

    49

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

    50

    51

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

    52

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

    53

VALUE_LABEL_HEIGHT = 17.    # Height of variable label in graph

    54

AXES_LABEL_HEIGHT = 12.75   # Height of variable value in graph

    55

    56

# Colors used cyclically for graph curves

    57

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

    58

# Color for graph cursor

    59

CURSOR_COLOR = '#800080'

    60

    61

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

    62

#                      Debug Variable Graphic Viewer Helpers

    63

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

    64

    65

    66

def merge_ranges(ranges):

    67

    """

    68

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

    69

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

    70

    around graph in canvas

    71

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

    72

    @return: merged_range_min_value, merged_range_max_value

    73

    """

    74

    # Get minimal and maximal range value

    75

    min_value = max_value = None

    76

    for range_min, range_max in ranges:

    77

        # Update minimal range value

    78

        if min_value is None:

    79

            min_value = range_min

    80

        elif range_min is not None:

    81

            min_value = min(min_value, range_min)

    82

    83

        # Update maximal range value

    84

        if max_value is None:

    85

            max_value = range_max

    86

        elif range_min is not None:

    87

            max_value = max(max_value, range_max)

    88

    89

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

    90

    if min_value is not None and max_value is not None:

    91

        center = (min_value + max_value) / 2.

    92

        range_size = max(1.0, max_value - min_value)

    93

    94

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

    95

    else:

    96

        center = 0.5

    97

        range_size = 1.0

    98

    99

    # Return range expended from 10 %

   100

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

   101

   102

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

   103

#                   Debug Variable Graphic Viewer Drop Target

   104

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

   105

   106

   107

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

   108

    """

   109

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

   110

    Viewer

   111

    """

   112

   113

    def __init__(self, parent, window):

   114

        """

   115

        Constructor

   116

        @param parent: Reference to Debug Variable Graphic Viewer

   117

        @param window: Reference to the Debug Variable Panel

   118

        """

   119

        wx.TextDropTarget.__init__(self)

   120

        self.ParentControl = parent

   121

        self.ParentWindow = window

   122

   123

    def __del__(self):

   124

        """

   125

        Destructor

   126

        """

   127

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

   128

        # Panel

   129

        self.ParentControl = None

   130

        self.ParentWindow = None

   131

   132

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

   133

        """

   134

        Function called when mouse is dragged over Drop Target

   135

        @param x: X coordinate of mouse pointer

   136

        @param y: Y coordinate of mouse pointer

   137

        @param d: Suggested default for return value

   138

        """

   139

        # Signal parent that mouse is dragged over

   140

        self.ParentControl.OnMouseDragging(x, y)

   141

   142

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

   143

   144

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

   145

        """

   146

        Function called when mouse is released in Drop Target

   147

        @param x: X coordinate of mouse pointer

   148

        @param y: Y coordinate of mouse pointer

   149

        @param data: Text associated to drag'n drop

   150

        """

   151

        # Signal Debug Variable Panel to reset highlight

   152

        self.ParentWindow.ResetHighlight()

   153

   154

        message = None

   155

   156

        # Check that data is valid regarding DebugVariablePanel

   157

        try:

   158

            values = eval(data)

   159

            if not isinstance(values, TupleType):

   160

                raise ValueError

   161

        except Exception:

   162

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

   163

            values = None

   164

   165

        # Display message if data is invalid

   166

        if message is not None:

   167

            wx.CallAfter(self.ShowMessage, message)

   168

   169

        # Data contain a reference to a variable to debug

   170

        elif values[1] == "debug":

   171

            target_idx = self.ParentControl.GetIndex()

   172

   173

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

   174

            # not 3D canvas, graphs will be merged

   175

            rect = self.ParentControl.GetAxesBoundingBox()

   176

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

   177

                # Default merge type is parallel

   178

                merge_type = GRAPH_PARALLEL

   179

   180

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

   181

                # wall be merged orthogonally

   182

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

   183

                                     rect.width / 2., rect.height)

   184

                if merge_rect.InsideXY(x, y):

   185

                    merge_type = GRAPH_ORTHOGONAL

   186

   187

                # Merge graphs

   188

                wx.CallAfter(self.ParentWindow.MergeGraphs,

   189

                             values[0], target_idx,

   190

                             merge_type, force=True)

   191

   192

            else:

   193

                _width, height = self.ParentControl.GetSize()

   194

   195

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

   196

                # according to the position of mouse in Viewer.

   197

                if y > height / 2:

   198

                    target_idx += 1

   199

   200

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

   201

                # Variable Panel

   202

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

   203

                    self.ParentWindow.MoveValue(values[0],

   204

                                                target_idx)

   205

   206

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

   207

                else:

   208

                    self.ParentWindow.InsertValue(values[0],

   209

                                                  target_idx,

   210

                                                  force=True)

   211

   212

    def OnLeave(self):

   213

        """

   214

        Function called when mouse is leave Drop Target

   215

        """

   216

        # Signal Debug Variable Panel to reset highlight

   217

        self.ParentWindow.ResetHighlight()

   218

        return wx.TextDropTarget.OnLeave(self)

   219

   220

    def ShowMessage(self, message):

   221

        """

   222

        Show error message in Error Dialog

   223

        @param message: Error message to display

   224

        """

   225

        dialog = wx.MessageDialog(self.ParentWindow,

   226

                                  message,

   227

                                  _("Error"),

   228

                                  wx.OK | wx.ICON_ERROR)

   229

        dialog.ShowModal()

   230

        dialog.Destroy()

   231

   232

   233

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

   234

#                      Debug Variable Graphic Viewer Class

   235

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

   236

   237

   238

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   239

    """

   240

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

   241

    """

   242

   243

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

   244

        """

   245

        Constructor

   246

        @param parent: Parent wx.Window of DebugVariableText

   247

        @param window: Reference to the Debug Variable Panel

   248

        @param items: List of DebugVariableItem displayed by Viewer

   249

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

   250

        """

   251

        DebugVariableViewer.__init__(self, window, items)

   252

   253

        self.GraphType = graph_type        # Graph type display

   254

        self.CursorTick = None             # Tick of the graph cursor

   255

   256

        # Mouse position when start dragging

   257

        self.MouseStartPos = None

   258

        # Tick when moving tick start

   259

        self.StartCursorTick = None

   260

        # Canvas size when starting to resize canvas

   261

        self.CanvasStartSize = None

   262

   263

        # List of current displayed contextual buttons

   264

        self.ContextualButtons = []

   265

        # Reference to item for which contextual buttons was displayed

   266

        self.ContextualButtonsItem = None

   267

   268

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

   269

        # data range if False

   270

        self.ZoomFit = False

   271

   272

        # Create figure for drawing graphs

   273

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

   274

        # Defined border around figure in canvas

   275

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

   276

                                       bottom=0.1, right=0.95)

   277

   278

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

   279

        self.SetWindowStyle(wx.WANTS_CHARS)

   280

        self.SetBackgroundColour(wx.WHITE)

   281

   282

        # Bind wx events

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

   290

        # Set canvas min size

   291

        canvas_size = self.GetCanvasMinSize()

   292

        self.SetMinSize(canvas_size)

   293

   294

        # Define Viewer drop target

   295

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   296

   297

        # Connect matplotlib events

   298

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

   299

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

   300

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

   301

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

   302

   303

        # Add buttons for zooming on current displayed data range

   304

        self.Buttons.append(

   305

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

   306

   307

        # Add buttons for changing canvas size with predefined height

   308

        for size, bitmap in zip(

   309

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   310

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

   311

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

   312

                                            self.GetOnChangeSizeButton(size)))

   313

   314

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

   315

        for bitmap, callback in [

   316

                ("export_graph_mini", self.OnExportGraphButton),

   317

                ("delete_graph", self.OnCloseButton)]:

   318

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

   319

   320

        # Update graphs elements

   321

        self.ResetGraphics()

   322

        self.RefreshLabelsPosition(canvas_size.height)

   323

   324

    def AddItem(self, item):

   325

        """

   326

        Add an item to the list of items displayed by Viewer

   327

        @param item: Item to add to the list

   328

        """

   329

        DebugVariableViewer.AddItem(self, item)

   330

        self.ResetGraphics()

   331

   332

    def RemoveItem(self, item):

   333

        """

   334

        Remove an item from the list of items displayed by Viewer

   335

        @param item: Item to remove from the list

   336

        """

   337

        DebugVariableViewer.RemoveItem(self, item)

   338

   339

        # If list of items is not empty

   340

        if not self.ItemsIsEmpty():

   341

            # Return to parallel graph if there is only one item

   342

            # especially if it's actually orthogonal

   343

            if len(self.Items) == 1:

   344

                self.GraphType = GRAPH_PARALLEL

   345

            self.ResetGraphics()

   346

   347

    def SetCursorTick(self, cursor_tick):

   348

        """

   349

        Set cursor tick

   350

        @param cursor_tick: Cursor tick

   351

        """

   352

        self.CursorTick = cursor_tick

   353

   354

    def SetZoomFit(self, zoom_fit):

   355

        """

   356

        Set flag indicating that zoom fit current displayed data range

   357

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

   358

        """

   359

        # Flag is different from the actual one

   360

        if zoom_fit != self.ZoomFit:

   361

            # Save new flag value

   362

            self.ZoomFit = zoom_fit

   363

   364

            # Update button for zoom fit bitmap

   365

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

   366

   367

            # Refresh canvas

   368

            self.RefreshViewer()

   369

   370

    def SubscribeAllDataConsumers(self):

   371

        """

   372

        Function that unsubscribe and remove every item that store values of

   373

        a variable that doesn't exist in PLC anymore

   374

        """

   375

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   376

   377

        # Graph still have data to display

   378

        if not self.ItemsIsEmpty():

   379

            # Reset flag indicating that zoom fit current displayed data range

   380

            self.SetZoomFit(False)

   381

   382

            self.ResetGraphics()

   383

   384

    def Is3DCanvas(self):

   385

        """

   386

        Return if Viewer is a 3D canvas

   387

        @return: True if Viewer is a 3D canvas

   388

        """

   389

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

   390

   391

    def GetButtons(self):

   392

        """

   393

        Return list of buttons defined in Viewer

   394

        @return: List of buttons

   395

        """

   396

        # Add contextual buttons to default buttons

   397

        return self.Buttons + self.ContextualButtons

   398

   399

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

   400

        """

   401

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

   402

        by the bounding box of label in figure

   403

        @param item: Item for which contextual is shown

   404

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

   405

        @param direction: Direction in which buttons must be drawn

   406

        """

   407

        # Return immediately if contextual menu for item is already shown

   408

        if self.ContextualButtonsItem == item:

   409

            return

   410

   411

        # Close already shown contextual menu

   412

        self.DismissContextualButtons()

   413

   414

        # Save item for which contextual menu is shown

   415

        self.ContextualButtonsItem = item

   416

   417

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

   418

        # contextual menu

   419

        if self.ContextualButtonsItem.IsForced():

   420

            self.ContextualButtons.append(

   421

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

   422

   423

        # Add other buttons to contextual menu

   424

        for bitmap, callback in [

   425

                ("force", self.OnForceItemButton),

   426

                ("export_graph_mini", self.OnExportItemGraphButton),

   427

                ("delete_graph", self.OnRemoveItemButton)]:

   428

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

   429

   430

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

   431

        # will be set in reverse order

   432

        buttons = self.ContextualButtons[:]

   433

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

   434

            buttons.reverse()

   435

   436

        # Set contextual menu buttons position aside rect depending on

   437

        # direction given

   438

        offset = 0

   439

        for button in buttons:

   440

            w, h = button.GetSize()

   441

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

   442

                x = rect.x + (- w - offset

   443

                              if direction == wx.LEFT

   444

                              else rect.width + offset)

   445

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

   446

                offset += w

   447

            else:

   448

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

   449

                y = rect.y + (- h - offset

   450

                              if direction == wx.TOP

   451

                              else rect.height + offset)

   452

                offset += h

   453

            button.SetPosition(x, y)

   454

            button.Show()

   455

   456

        # Refresh canvas

   457

        self.ParentWindow.ForceRefresh()

   458

   459

    def DismissContextualButtons(self):

   460

        """

   461

        Close current shown contextual menu

   462

        """

   463

        # Return immediately if no contextual menu is shown

   464

        if self.ContextualButtonsItem is None:

   465

            return

   466

   467

        # Reset variables corresponding to contextual menu

   468

        self.ContextualButtonsItem = None

   469

        self.ContextualButtons = []

   470

   471

        # Refresh canvas

   472

        self.ParentWindow.ForceRefresh()

   473

   474

    def IsOverContextualButton(self, x, y):

   475

        """

   476

        Return if point is over one contextual button of Viewer

   477

        @param x: X coordinate of point

   478

        @param y: Y coordinate of point

   479

        @return: contextual button where point is over

   480

        """

   481

        for button in self.ContextualButtons: