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

from types import TupleType

    26

from time import time as gettime

    27

from distutils.version import LooseVersion

    28

    29

import numpy

    30

import wx

    31

import matplotlib

    32

import matplotlib.pyplot

    33

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    34

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    35

from matplotlib.backends.backend_agg import FigureCanvasAgg

    36

from mpl_toolkits.mplot3d import Axes3D

    37

    38

from editors.DebugViewer import REFRESH_PERIOD

    39

from DebugVariableItem import DebugVariableItem

    40

from DebugVariableViewer import *

    41

from GraphButton import GraphButton

    42

    43

    44

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

    45

    from cycler import cycler

    46

    47

    48

# Graph variable display type

    49

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    50

    51

# Canvas height

    52

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

    53

    54

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

    55

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

    56

VALUE_LABEL_HEIGHT = 17.    # Height of variable label in graph

    57

AXES_LABEL_HEIGHT = 12.75   # Height of variable value in graph

    58

    59

# Colors used cyclically for graph curves

    60

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

    61

# Color for graph cursor

    62

CURSOR_COLOR = '#800080'

    63

    64

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

    65

#                      Debug Variable Graphic Viewer Helpers

    66

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

    67

    68

    69

def merge_ranges(ranges):

    70

    """

    71

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

    72

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

    73

    around graph in canvas

    74

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

    75

    @return: merged_range_min_value, merged_range_max_value

    76

    """

    77

    # Get minimal and maximal range value

    78

    min_value = max_value = None

    79

    for range_min, range_max in ranges:

    80

        # Update minimal range value

    81

        if min_value is None:

    82

            min_value = range_min

    83

        elif range_min is not None:

    84

            min_value = min(min_value, range_min)

    85

    86

        # Update maximal range value

    87

        if max_value is None:

    88

            max_value = range_max

    89

        elif range_min is not None:

    90

            max_value = max(max_value, range_max)

    91

    92

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

    93

    if min_value is not None and max_value is not None:

    94

        center = (min_value + max_value) / 2.

    95

        range_size = max(1.0, max_value - min_value)

    96

    97

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

    98

    else:

    99

        center = 0.5

   100

        range_size = 1.0

   101

   102

    # Return range expended from 10 %

   103

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

   104

   105

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

   106

#                   Debug Variable Graphic Viewer Drop Target

   107

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

   108

   109

   110

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

   111

    """

   112

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

   113

    Viewer

   114

    """

   115

   116

    def __init__(self, parent, window):

   117

        """

   118

        Constructor

   119

        @param parent: Reference to Debug Variable Graphic Viewer

   120

        @param window: Reference to the Debug Variable Panel

   121

        """

   122

        wx.TextDropTarget.__init__(self)

   123

        self.ParentControl = parent

   124

        self.ParentWindow = window

   125

   126

    def __del__(self):

   127

        """

   128

        Destructor

   129

        """

   130

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

   131

        # Panel

   132

        self.ParentControl = None

   133

        self.ParentWindow = None

   134

   135

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

   136

        """

   137

        Function called when mouse is dragged over Drop Target

   138

        @param x: X coordinate of mouse pointer

   139

        @param y: Y coordinate of mouse pointer

   140

        @param d: Suggested default for return value

   141

        """

   142

        # Signal parent that mouse is dragged over

   143

        self.ParentControl.OnMouseDragging(x, y)

   144

   145

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

   146

   147

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

   148

        """

   149

        Function called when mouse is released in Drop Target

   150

        @param x: X coordinate of mouse pointer

   151

        @param y: Y coordinate of mouse pointer

   152

        @param data: Text associated to drag'n drop

   153

        """

   154

        # Signal Debug Variable Panel to reset highlight

   155

        self.ParentWindow.ResetHighlight()

   156

   157

        message = None

   158

   159

        # Check that data is valid regarding DebugVariablePanel

   160

        try:

   161

            values = eval(data)

   162

            if not isinstance(values, TupleType):

   163

                raise ValueError

   164

        except Exception:

   165

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

   166

            values = None

   167

   168

        # Display message if data is invalid

   169

        if message is not None:

   170

            wx.CallAfter(self.ShowMessage, message)

   171

   172

        # Data contain a reference to a variable to debug

   173

        elif values[1] == "debug":

   174

            target_idx = self.ParentControl.GetIndex()

   175

   176

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

   177

            # not 3D canvas, graphs will be merged

   178

            rect = self.ParentControl.GetAxesBoundingBox()

   179

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

   180

                # Default merge type is parallel

   181

                merge_type = GRAPH_PARALLEL

   182

   183

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

   184

                # wall be merged orthogonally

   185

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

   186

                                     rect.width / 2., rect.height)

   187

                if merge_rect.InsideXY(x, y):

   188

                    merge_type = GRAPH_ORTHOGONAL

   189

   190

                # Merge graphs

   191

                wx.CallAfter(self.ParentWindow.MergeGraphs,

   192

                             values[0], target_idx,

   193

                             merge_type, force=True)

   194

   195

            else:

   196

                _width, height = self.ParentControl.GetSize()

   197

   198

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

   199

                # according to the position of mouse in Viewer.

   200

                if y > height / 2:

   201

                    target_idx += 1

   202

   203

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

   204

                # Variable Panel

   205

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

   206

                    self.ParentWindow.MoveValue(values[0],

   207

                                                target_idx)

   208

   209

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

   210

                else:

   211

                    self.ParentWindow.InsertValue(values[0],

   212

                                                  target_idx,

   213

                                                  force=True)

   214

   215

    def OnLeave(self):

   216

        """

   217

        Function called when mouse is leave Drop Target

   218

        """

   219

        # Signal Debug Variable Panel to reset highlight

   220

        self.ParentWindow.ResetHighlight()

   221

        return wx.TextDropTarget.OnLeave(self)

   222

   223

    def ShowMessage(self, message):

   224

        """

   225

        Show error message in Error Dialog

   226

        @param message: Error message to display

   227

        """

   228

        dialog = wx.MessageDialog(self.ParentWindow,

   229

                                  message,

   230

                                  _("Error"),

   231

                                  wx.OK | wx.ICON_ERROR)

   232

        dialog.ShowModal()

   233

        dialog.Destroy()

   234

   235

   236

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

   237

#                      Debug Variable Graphic Viewer Class

   238

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

   239

   240

   241

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   242

    """

   243

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

   244

    """

   245

   246

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

   247

        """

   248

        Constructor

   249

        @param parent: Parent wx.Window of DebugVariableText

   250

        @param window: Reference to the Debug Variable Panel

   251

        @param items: List of DebugVariableItem displayed by Viewer

   252

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

   253

        """

   254

        DebugVariableViewer.__init__(self, window, items)

   255

   256

        self.GraphType = graph_type        # Graph type display

   257

        self.CursorTick = None             # Tick of the graph cursor

   258

   259

        # Mouse position when start dragging

   260

        self.MouseStartPos = None

   261

        # Tick when moving tick start

   262

        self.StartCursorTick = None

   263

        # Canvas size when starting to resize canvas

   264

        self.CanvasStartSize = None

   265

   266

        # List of current displayed contextual buttons

   267

        self.ContextualButtons = []

   268

        # Reference to item for which contextual buttons was displayed

   269

        self.ContextualButtonsItem = None

   270

   271

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

   272

        # data range if False

   273

        self.ZoomFit = False

   274

   275

        # Create figure for drawing graphs

   276

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

   277

        # Defined border around figure in canvas

   278

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

   279

                                       bottom=0.1, right=0.95)

   280

   281

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

   282

        self.SetWindowStyle(wx.WANTS_CHARS)

   283

        self.SetBackgroundColour(wx.WHITE)

   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(

   315

                    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(

   433

                    GraphButton(0, 0, bitmap, callback))

   434

   435

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

   436

        # will be set in reverse order

   437

        buttons = self.ContextualButtons[:]

   438

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

   439

            buttons.reverse()

   440

   441

        # Set contextual menu buttons position aside rect depending on

   442

        # direction given

   443

        offset = 0

   444

        for button in buttons:

   445

            w, h = button.GetSize()

   446

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

   447

                x = rect.x + (- w - offset

   448

                              if direction == wx.LEFT

   449

                              else rect.width + offset)

   450

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

   451

                offset += w

   452

            else:

   453

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

   454

                y = rect.y + (- h - offset

   455

                              if direction == wx.TOP

   456

                              else rect.height + offset)

   457

                offset += h

   458

            button.SetPosition(x, y)

   459

            button.Show()

   460

   461

        # Refresh canvas

   462

        self.ParentWindow.ForceRefresh()

   463

   464

    def DismissContextualButtons(self):

   465

        """

   466

        Close current shown contextual menu

   467

        """

   468

        # Return immediately if no contextual menu is shown

   469

        if self.ContextualButtonsItem is None:

   470

            return

   471

   472

        # Reset variables corresponding to contextual menu

   473

        self.ContextualButtonsItem = None

   474

        self.ContextualButtons = []

   475

   476

        # Refresh canvas

   477

        self.ParentWindow.ForceRefresh()

   478

   479

    def IsOverContextualButton(self, x, y):

   480

        """

   481

        Return if point is over one contextual button of Viewer

   482

        @param x: X coordinate of point