1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2012: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from types import TupleType

    26

from time import time as gettime

    27

import numpy

    28

    29

import wx

    30

    31

import matplotlib

    32

matplotlib.use('WX')

    33

import matplotlib.pyplot

    34

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    35

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    36

from matplotlib.backends.backend_agg import FigureCanvasAgg

    37

from mpl_toolkits.mplot3d import Axes3D

    38

    39

from editors.DebugViewer import REFRESH_PERIOD

    40

    41

from DebugVariableItem import DebugVariableItem

    42

from DebugVariableViewer import *

    43

from GraphButton import GraphButton

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

def OrthogonalDataAndRange(item, start_tick, end_tick):

    62

    data = item.GetData(start_tick, end_tick)

    63

    min_value, max_value = item.GetValueRange()

    64

    if min_value is not None and max_value is not None:

    65

        center = (min_value + max_value) / 2.

    66

        range = max(1.0, max_value - min_value)

    67

    else:

    68

        center = 0.5

    69

        range = 1.0

    70

    return data, center - range * 0.55, center + range * 0.55

    71

    72

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

    73

#                   Debug Variable Graphic Viewer Drop Target

    74

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

    75

    76

"""

    77

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

    78

"""

    79

    80

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

    81

    82

    def __init__(self, parent, window):

    83

        """

    84

        Constructor

    85

        @param parent: Reference to Debug Variable Graphic Viewer

    86

        @param window: Reference to the Debug Variable Panel

    87

        """

    88

        wx.TextDropTarget.__init__(self)

    89

        self.ParentControl = parent

    90

        self.ParentWindow = window

    91

    92

    def __del__(self):

    93

        """

    94

        Destructor

    95

        """

    96

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

    97

        # Panel

    98

        self.ParentControl = None

    99

        self.ParentWindow = None

   100

   101

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

   102

        """

   103

        Function called when mouse is dragged over Drop Target

   104

        @param x: X coordinate of mouse pointer

   105

        @param y: Y coordinate of mouse pointer

   106

        @param d: Suggested default for return value

   107

        """

   108

        # Signal parent that mouse is dragged over

   109

        self.ParentControl.OnMouseDragging(x, y)

   110

   111

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

   112

   113

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

   114

        """

   115

        Function called when mouse is dragged over Drop Target

   116

        @param x: X coordinate of mouse pointer

   117

        @param y: Y coordinate of mouse pointer

   118

        @param data: Text associated to drag'n drop

   119

        """

   120

        message = None

   121

   122

        # Check that data is valid regarding DebugVariablePanel

   123

        try:

   124

            values = eval(data)

   125

            if not isinstance(values, TupleType):

   126

                raise ValueError

   127

        except:

   128

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

   129

            values = None

   130

   131

        # Display message if data is invalid

   132

        if message is not None:

   133

            wx.CallAfter(self.ShowMessage, message)

   134

   135

        # Data contain a reference to a variable to debug

   136

        elif values[1] == "debug":

   137

            target_idx = self.ParentControl.GetIndex()

   138

   139

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

   140

            # not 3D canvas, graphs will be merged

   141

            rect = self.ParentControl.GetAxesBoundingBox()

   142

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

   143

                # Default merge type is parallel

   144

                merge_type = GRAPH_PARALLEL

   145

   146

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

   147

                # wall be merged orthogonally

   148

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

   149

                                     rect.width / 2., rect.height)

   150

                if merge_rect.InsideXY(x, y):

   151

                    merge_type = GRAPH_ORTHOGONAL

   152

   153

                # Merge graphs

   154

                wx.CallAfter(self.ParentWindow.MergeGraphs, 

   155

                             values[0], target_idx, 

   156

                             merge_type, force=True)

   157

   158

            else:

   159

                width, height = self.ParentControl.GetSize()

   160

   161

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

   162

                # according to the position of mouse in Viewer.

   163

                if y > height / 2:

   164

                    target_idx += 1

   165

   166

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

   167

                # Variable Panel 

   168

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

   169

                    self.ParentWindow.MoveValue(values[0], 

   170

                                                target_idx)

   171

   172

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

   173

                else:

   174

                    self.ParentWindow.InsertValue(values[0], 

   175

                                                  target_idx, 

   176

                                                  force=True)

   177

   178

    def OnLeave(self):

   179

        """

   180

        Function called when mouse is leave Drop Target

   181

        """

   182

        # Signal Debug Variable Panel to reset highlight

   183

        self.ParentWindow.ResetHighlight()

   184

        return wx.TextDropTarget.OnLeave(self)

   185

   186

    def ShowMessage(self, message):

   187

        """

   188

        Show error message in Error Dialog

   189

        @param message: Error message to display

   190

        """

   191

        dialog = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   192

        dialog.ShowModal()

   193

        dialog.Destroy()

   194

   195

   196

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

   197

#                      Debug Variable Graphic Viewer Class

   198

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

   199

   200

"""

   201

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

   202

"""

   203

   204

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

   205

   206

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

   207

        """

   208

        Constructor

   209

        @param parent: Parent wx.Window of DebugVariableText

   210

        @param window: Reference to the Debug Variable Panel

   211

        @param items: List of DebugVariableItem displayed by Viewer

   212

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

   213

        """

   214

        DebugVariableViewer.__init__(self, window, items)

   215

   216

        self.GraphType = graph_type        # Graph type display

   217

        self.CursorTick = None             # Tick of the graph cursor

   218

   219

        # Mouse position when start dragging

   220

        self.MouseStartPos = None

   221

        # Tick when moving tick start

   222

        self.StartCursorTick = None

   223

        # Canvas size when starting to resize canvas

   224

        self.CanvasStartSize = None        

   225

   226

        # List of current displayed contextual buttons

   227

        self.ContextualButtons = []

   228

        # Reference to item for which contextual buttons was displayed

   229

        self.ContextualButtonsItem = None

   230

   231

        # Create figure for drawing graphs

   232

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

   233

        # Defined border around figure in canvas

   234

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

   235

                                       bottom=0.1, right=0.95)

   236

   237

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

   238

        self.SetWindowStyle(wx.WANTS_CHARS)

   239

        self.SetBackgroundColour(wx.WHITE)

   240

   241

        # Bind wx events

   242

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

   243

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

   244

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

   245

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

   246

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

   247

   248

        # Set canvas min size

   249

        canvas_size = self.GetCanvasMinSize()

   250

        self.SetMinSize(canvas_size)

   251

   252

        # Define Viewer drop target

   253

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   254

   255

        # Connect matplotlib events

   256

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

   257

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

   258

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

   259

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

   260

   261

        # Add buttons for changing canvas size with predefined height

   262

        for size, bitmap in zip(

   263

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   264

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

   265

            self.Buttons.append(

   266

                    GraphButton(0, 0, bitmap, 

   267

                                self.GetOnChangeSizeButton(size)))

   268

   269

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

   270

        for bitmap, callback in [

   271

                ("export_graph_mini", self.OnExportGraphButton),

   272

                ("delete_graph", self.OnCloseButton)]:

   273

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

   274

   275

        # Update graphs elements

   276

        self.ResetGraphics()

   277

        self.RefreshLabelsPosition(canvas_size.height)

   278

   279

    def AddItem(self, item):

   280

        """

   281

        Add an item to the list of items displayed by Viewer

   282

        @param item: Item to add to the list

   283

        """

   284

        DebugVariableViewer.AddItem(self, item)

   285

        self.ResetGraphics()

   286

   287

    def RemoveItem(self, item):

   288

        """

   289

        Remove an item from the list of items displayed by Viewer

   290

        @param item: Item to remove from the list

   291

        """

   292

        DebugVariableViewer.RemoveItem(self, item)

   293

   294

        # If list of items is not empty

   295

        if not self.ItemsIsEmpty():

   296

            # Return to parallel graph if there is only one item

   297

            # especially if it's actually orthogonal

   298

            if len(self.Items) == 1:

   299

                self.GraphType = GRAPH_PARALLEL

   300

            self.ResetGraphics()

   301

   302

    def SetCursorTick(self, cursor_tick):

   303

        """

   304

        Set cursor tick

   305

        @param cursor_tick: Cursor tick

   306

        """

   307

        self.CursorTick = cursor_tick

   308

   309

    def SubscribeAllDataConsumers(self):

   310

        """

   311

        Function that unsubscribe and remove every item that store values of

   312

        a variable that doesn't exist in PLC anymore

   313

        """

   314

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   315

        if not self.ItemsIsEmpty():

   316

            self.ResetGraphics()

   317

   318

    def Is3DCanvas(self):

   319

        """

   320

        Return if Viewer is a 3D canvas

   321

        @return: True if Viewer is a 3D canvas

   322

        """

   323

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

   324

   325

    def GetButtons(self):

   326

        """

   327

        Return list of buttons defined in Viewer

   328

        @return: List of buttons

   329

        """

   330

        # Add contextual buttons to default buttons

   331

        return self.Buttons + self.ContextualButtons

   332

   333

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

   334

        """

   335

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

   336

        by the bounding box of label in figure

   337

        @param item: Item for which contextual is shown

   338

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

   339

        @param direction: Direction in which buttons must be drawn

   340

        """

   341

        # Return immediately if contextual menu for item is already shown

   342

        if self.ContextualButtonsItem == item:

   343

            return

   344

   345

        # Close already shown contextual menu

   346

        self.DismissContextualButtons()

   347

   348

        # Save item for which contextual menu is shown

   349

        self.ContextualButtonsItem = item

   350

   351

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

   352

        # contextual menu

   353

        if self.ContextualButtonsItem.IsForced():

   354

            self.ContextualButtons.append(

   355

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

   356

   357

        # Add other buttons to contextual menu

   358

        for bitmap, callback in [

   359

                ("force", self.OnForceItemButton),

   360

                ("export_graph_mini", self.OnExportItemGraphButton),

   361

                ("delete_graph", self.OnRemoveItemButton)]:

   362

            self.ContextualButtons.append(

   363

                    GraphButton(0, 0, bitmap, callback))

   364

   365

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

   366

        # will be set in reverse order

   367

        buttons = self.ContextualButtons[:]

   368

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

   369

             buttons.reverse()

   370

   371

        # Set contextual menu buttons position aside rect depending on

   372

        # direction given

   373

        offset = 0

   374

        for button in buttons:

   375

            w, h = button.GetSize()

   376

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

   377

                x = rect.x + (- w - offset

   378

                            if direction == wx.LEFT

   379

                            else rect.width + offset)

   380

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

   381

                offset += w

   382

            else:

   383

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

   384

                y = rect.y + (- h - offset

   385

                              if direction == wx.TOP

   386

                              else rect.height + offset)

   387

                offset += h

   388

            button.SetPosition(x, y)

   389

            button.Show()

   390

   391

        # Refresh canvas

   392

        self.ParentWindow.ForceRefresh()

   393

   394

    def DismissContextualButtons(self):

   395

        """

   396

        Close current shown contextual menu

   397

        """

   398

        # Return immediately if no contextual menu is shown

   399

        if self.ContextualButtonsItem is None:

   400

            return

   401

   402

        # Reset variables corresponding to contextual menu

   403

        self.ContextualButtonsItem = None

   404

        self.ContextualButtons = []

   405

   406

        # Refresh canvas

   407

        self.ParentWindow.ForceRefresh()

   408

   409

    def IsOverContextualButton(self, x, y):

   410

        """

   411

        Return if point is over one contextual button of Viewer

   412

        @param x: X coordinate of point

   413

        @param y: Y coordinate of point

   414

        @return: contextual button where point is over

   415

        """

   416

        for button in self.ContextualButtons:

   417

            if button.HitTest(x, y):

   418

                return button

   419

        return None

   420

   421

    def ExportGraph(self, item=None):

   422

        """

   423

        Export item(s) data to clipboard in CSV format

   424

        @param item: Item from which data to export, all items if None

   425

        (default None)

   426

        """

   427

        self.ParentWindow.CopyDataToClipboard(

   428

            [(item, [entry for entry in item.GetData()])

   429

             for item in (self.Items 

   430

                          if item is None 

   431

                          else [item])])

   432

   433

    def GetOnChangeSizeButton(self, height):

   434

        """

   435

        Function that generate callback function for change Viewer height to

   436

        pre-defined height button

   437

        @param height: Height that change Viewer to

   438

        @return: callback function

   439

        """

   440

        def OnChangeSizeButton():

   441

            self.SetCanvasSize(200, height)

   442

        return OnChangeSizeButton

   443

   444

    def OnExportGraphButton(self):

   445

        """

   446

        Function called when Viewer Export button is pressed

   447

        """

   448

        # Export data of every item in Viewer

   449

        self.ExportGraph()

   450

   451

    def OnForceItemButton(self):

   452

        """

   453

        Function called when contextual menu Force button is pressed

   454

        """

   455

        # Open dialog for forcing item variable value 

   456

        self.ForceValue(self.ContextualButtonsItem)

   457

        # Close contextual menu

   458

        self.DismissContextualButtons()

   459

   460

    def OnReleaseItemButton(self):

   461

        """

   462

        Function called when contextual menu Release button is pressed

   463

        """

   464

        # Release item variable value 

   465

        self.ReleaseValue(self.ContextualButtonsItem)

   466

        # Close contextual menu

   467

        self.DismissContextualButtons()

   468

   469

    def OnExportItemGraphButton(self):

   470

        """

   471

        Function called when contextual menu Export button is pressed

   472

        """

   473

        # Export data of item variable

   474

        self.ExportGraph(self.ContextualButtonsItem)

   475

        # Close contextual menu

   476

        self.DismissContextualButtons()

   477

   478

    def OnRemoveItemButton(self):            

   479

        """

   480

        Function called when contextual menu Remove button is pressed

   481

        """

   482

        # Remove item from Viewer

   483

        wx.CallAfter(self.ParentWindow.DeleteValue, self, 

   484

                     self.ContextualButtonsItem)

   485

        # Close contextual menu

   486

        self.DismissContextualButtons()

   487

   488

    def HandleCursorMove(self, event):

   489

        """

   490

        Update Cursor position according to mouse position and graph type

   491