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 DebugVariableViewer import *

    40

from GraphButton import GraphButton

    41

    42

    43

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

    44

    from cycler import cycler

    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 = (20., 10.)  # 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(

   314

                    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(

   432

                    GraphButton(0, 0, bitmap, callback))

   433

   434

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

   435

        # will be set in reverse order

   436

        buttons = self.ContextualButtons[:]

   437

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

   438

            buttons.reverse()

   439

   440

        # Set contextual menu buttons position aside rect depending on

   441

        # direction given

   442

        offset = 0

   443

        for button in buttons:

   444

            w, h = button.GetSize()

   445

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

   446

                x = rect.x + (- w - offset

   447

                              if direction == wx.LEFT

   448

                              else rect.width + offset)

   449

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

   450

                offset += w

   451

            else:

   452

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

   453

                y = rect.y + (- h - offset

   454

                              if direction == wx.TOP

   455

                              else rect.height + offset)

   456

                offset += h

   457

            button.SetPosition(x, y)

   458

            button.Show()

   459

   460

        # Refresh canvas

   461

        self.ParentWindow.ForceRefresh()

   462

   463

    def DismissContextualButtons(self):

   464

        """

   465

        Close current shown contextual menu

   466

        """

   467

        # Return immediately if no contextual menu is shown

   468

        if self.ContextualButtonsItem is None:

   469

            return

   470

   471

        # Reset variables corresponding to contextual menu

   472

        self.ContextualButtonsItem = None

   473

        self.ContextualButtons = []

   474

   475

        # Refresh canvas

   476

        self.ParentWindow.ForceRefresh()

   477

   478

    def IsOverContextualButton(self, x, y):

   479

        """

   480

        Return if point is over one contextual button of Viewer

   481

        @param x: X coordinate of point

   482

        @param y: Y coordinate of point