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

import math

    27

import numpy

    28

    29

import wx

    30

import wx.lib.buttons

    31

    32

import matplotlib

    33

import matplotlib.pyplot

    34

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    35

    36

from editors.DebugViewer import DebugViewer

    37

from util.BitmapLibrary import GetBitmap

    38

    39

from DebugVariableItem import DebugVariableItem

    40

from DebugVariableTextViewer import DebugVariableTextViewer

    41

from DebugVariableGraphicViewer import *

    42

    43

MILLISECOND = 1000000       # Number of nanosecond in a millisecond

    44

SECOND = 1000 * MILLISECOND # Number of nanosecond in a second

    45

MINUTE = 60 * SECOND        # Number of nanosecond in a minute

    46

HOUR = 60 * MINUTE          # Number of nanosecond in a hour

    47

DAY = 24 * HOUR             # Number of nanosecond in a day

    48

    49

# List of values possible for graph range

    50

# Format is [(time_in_plain_text, value_in_nanosecond),...]

    51

RANGE_VALUES = \

    52

    [("%dms" % i, i * MILLISECOND) for i in (10, 20, 50, 100, 200, 500)] + \

    53

    [("%ds" % i, i * SECOND) for i in (1, 2, 5, 10, 20, 30)] + \

    54

    [("%dm" % i, i * MINUTE) for i in (1, 2, 5, 10, 20, 30)] + \

    55

    [("%dh" % i, i * HOUR) for i in (1, 2, 3, 6, 12, 24)]

    56

    57

# Scrollbar increment in pixel

    58

SCROLLBAR_UNIT = 10

    59

    60

def compute_mask(x, y):

    61

    return [(xp if xp == yp else "*")

    62

            for xp, yp in zip(x, y)]

    63

    64

def NextTick(variables):

    65

    next_tick = None

    66

    for item, data in variables:

    67

        if len(data) == 0:

    68

            continue

    69

    70

        next_tick = (data[0][0]

    71

                     if next_tick is None

    72

                     else min(next_tick, data[0][0]))

    73

    74

    return next_tick

    75

    76

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

    77

#                    Debug Variable Graphic Panel Drop Target

    78

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

    79

    80

"""

    81

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

    82

Panel

    83

"""

    84

    85

class DebugVariableDropTarget(wx.TextDropTarget):

    86

    87

    def __init__(self, window):

    88

        """

    89

        Constructor

    90

        @param window: Reference to the Debug Variable Panel

    91

        """

    92

        wx.TextDropTarget.__init__(self)

    93

        self.ParentWindow = window

    94

    95

    def __del__(self):

    96

        """

    97

        Destructor

    98

        """

    99

        # Remove reference to Debug Variable Panel

   100

        self.ParentWindow = None

   101

   102

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

   103

        """

   104

        Function called when mouse is dragged over Drop Target

   105

        @param x: X coordinate of mouse pointer

   106

        @param y: Y coordinate of mouse pointer

   107

        @param d: Suggested default for return value

   108

        """

   109

       # Signal Debug Variable Panel to refresh highlight giving mouse position

   110

        self.ParentWindow.RefreshHighlight(x, y)

   111

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

   112

   113

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

   114

        """

   115

        Function called when mouse is released in 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

        # Signal Debug Variable Panel to reset highlight

   121

        self.ParentWindow.ResetHighlight()

   122

   123

        message = None

   124

   125

        # Check that data is valid regarding DebugVariablePanel

   126

        try:

   127

            values = eval(data)

   128

            if not isinstance(values, TupleType):

   129

                raise ValueError

   130

        except:

   131

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

   132

            values = None

   133

   134

        # Display message if data is invalid

   135

        if message is not None:

   136

            wx.CallAfter(self.ShowMessage, message)

   137

   138

        # Data contain a reference to a variable to debug

   139

        elif values[1] == "debug":

   140

   141

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

   142

            # Variable Panel 

   143

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

   144

                self.ParentWindow.MoveValue(values[0])

   145

   146

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

   147

            else:

   148

                self.ParentWindow.InsertValue(values[0], force=True)

   149

   150

    def OnLeave(self):

   151

        """

   152

        Function called when mouse is leave Drop Target

   153

        """

   154

        # Signal Debug Variable Panel to reset highlight

   155

        self.ParentWindow.ResetHighlight()

   156

        return wx.TextDropTarget.OnLeave(self)

   157

   158

    def ShowMessage(self, message):

   159

        """

   160

        Show error message in Error Dialog

   161

        @param message: Error message to display

   162

        """

   163

        dialog = wx.MessageDialog(self.ParentWindow, 

   164

                                  message, 

   165

                                  _("Error"), 

   166

                                  wx.OK|wx.ICON_ERROR)

   167

        dialog.ShowModal()

   168

        dialog.Destroy()

   169

   170

   171

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

   172

#                      Debug Variable Graphic Panel Class

   173

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

   174

   175

"""

   176

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

   177

"""

   178

   179

class DebugVariablePanel(wx.Panel, DebugViewer):

   180

   181

    def __init__(self, parent, producer, window):

   182

        """

   183

        Constructor

   184

        @param parent: Reference to the parent wx.Window

   185

        @param producer: Object receiving debug value and dispatching them to

   186

        consumers

   187

        @param window: Reference to Beremiz frame

   188

        """

   189

        wx.Panel.__init__(self, parent, style=wx.SP_3D|wx.TAB_TRAVERSAL)

   190

   191

        # Save Reference to Beremiz frame

   192

        self.ParentWindow = window

   193

   194

        # Variable storing flag indicating that variable displayed in table

   195

        # received new value and then table need to be refreshed

   196

        self.HasNewData = False

   197

   198

        # Variable storing flag indicating that refresh has been forced, and

   199

        # that next time refresh is possible, it will be done even if no new

   200

        # data is available

   201

        self.Force = False

   202

   203

        self.SetBackgroundColour(wx.WHITE)

   204

   205

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   206

   207

        self.Ticks = numpy.array([]) # List of tick received

   208

        self.StartTick = 0           # Tick starting range of data displayed

   209

        self.Fixed = False           # Flag that range of data is fixed

   210

        self.CursorTick = None       # Tick of cursor for displaying values

   211

   212

        self.DraggingAxesPanel = None

   213

        self.DraggingAxesBoundingBox = None

   214

        self.DraggingAxesMousePos = None

   215

        self.VetoScrollEvent = False

   216

   217

        self.VariableNameMask = []

   218

   219

        self.GraphicPanels = []

   220

   221

        graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   222

        main_sizer.AddSizer(graphics_button_sizer, border=5, flag=wx.GROW|wx.ALL)

   223

   224

        range_label = wx.StaticText(self, label=_('Range:'))

   225

        graphics_button_sizer.AddWindow(range_label, flag=wx.ALIGN_CENTER_VERTICAL)

   226

   227

        self.CanvasRange = wx.ComboBox(self, style=wx.CB_READONLY)

   228

        self.Bind(wx.EVT_COMBOBOX, self.OnRangeChanged, self.CanvasRange)

   229

        graphics_button_sizer.AddWindow(self.CanvasRange, 1, 

   230

              border=5, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL)

   231

   232

        self.CanvasRange.Clear()

   233

        default_range_idx = 0

   234

        for idx, (text, value) in enumerate(RANGE_VALUES):

   235

            self.CanvasRange.Append(text)

   236

            if text == "1s":

   237

                default_range_idx = idx

   238

        self.CanvasRange.SetSelection(default_range_idx)

   239

   240

        for name, bitmap, help in [

   241

            ("CurrentButton", "current", _("Go to current value")),

   242

            ("ExportGraphButton", "export_graph", _("Export graph values to clipboard"))]:

   243

            button = wx.lib.buttons.GenBitmapButton(self, 

   244

                  bitmap=GetBitmap(bitmap), 

   245

                  size=wx.Size(28, 28), style=wx.NO_BORDER)

   246

            button.SetToolTipString(help)

   247

            setattr(self, name, button)

   248

            self.Bind(wx.EVT_BUTTON, getattr(self, "On" + name), button)

   249

            graphics_button_sizer.AddWindow(button, border=5, flag=wx.LEFT)

   250

   251

        self.CanvasPosition = wx.ScrollBar(self, 

   252

              size=wx.Size(0, 16), style=wx.SB_HORIZONTAL)

   253

        self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK, 

   254

              self.OnPositionChanging, self.CanvasPosition)

   255

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP, 

   256

              self.OnPositionChanging, self.CanvasPosition)

   257

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN, 

   258

              self.OnPositionChanging, self.CanvasPosition)

   259

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP, 

   260

              self.OnPositionChanging, self.CanvasPosition)

   261

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN, 

   262

              self.OnPositionChanging, self.CanvasPosition)

   263

        main_sizer.AddWindow(self.CanvasPosition, border=5, flag=wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM)

   264

   265

        self.TickSizer = wx.BoxSizer(wx.HORIZONTAL)

   266

        main_sizer.AddSizer(self.TickSizer, border=5, flag=wx.ALL|wx.GROW)

   267

   268

        self.TickLabel = wx.StaticText(self)

   269

        self.TickSizer.AddWindow(self.TickLabel, border=5, flag=wx.RIGHT)

   270

   271

        self.MaskLabel = wx.TextCtrl(self, style=wx.TE_READONLY|wx.TE_CENTER|wx.NO_BORDER)

   272

        self.TickSizer.AddWindow(self.MaskLabel, 1, border=5, flag=wx.RIGHT|wx.GROW)

   273

   274

        self.TickTimeLabel = wx.StaticText(self)

   275

        self.TickSizer.AddWindow(self.TickTimeLabel)

   276

   277

        self.GraphicsWindow = wx.ScrolledWindow(self, style=wx.HSCROLL|wx.VSCROLL)

   278

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   279

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   280

        self.GraphicsWindow.Bind(wx.EVT_ERASE_BACKGROUND, self.OnGraphicsWindowEraseBackground)

   281

        self.GraphicsWindow.Bind(wx.EVT_PAINT, self.OnGraphicsWindowPaint)

   282

        self.GraphicsWindow.Bind(wx.EVT_SIZE, self.OnGraphicsWindowResize)

   283

        self.GraphicsWindow.Bind(wx.EVT_MOUSEWHEEL, self.OnGraphicsWindowMouseWheel)

   284

   285

        main_sizer.AddWindow(self.GraphicsWindow, 1, flag=wx.GROW)

   286

   287

        self.GraphicsSizer = wx.BoxSizer(wx.VERTICAL)

   288

        self.GraphicsWindow.SetSizer(self.GraphicsSizer)

   289

   290

        DebugViewer.__init__(self, producer, True)

   291

   292

        self.SetSizer(main_sizer)

   293

   294

    def SetTickTime(self, ticktime=0):

   295

        """

   296

        Set Ticktime for calculate data range according to time range selected

   297

        @param ticktime: Ticktime to apply to range (default: 0)

   298

        """

   299

        # Save ticktime

   300

        self.Ticktime = ticktime

   301

   302

        # Set ticktime to millisecond if undefined

   303

        if self.Ticktime == 0:

   304

            self.Ticktime = MILLISECOND

   305

   306

        # Calculate range to apply to data

   307

        self.CurrentRange = RANGE_VALUES[

   308

            self.CanvasRange.GetSelection()][1] / self.Ticktime

   309

   310

    def SetDataProducer(self, producer):

   311

        """

   312

        Set Data Producer

   313

        @param producer: Data Producer

   314

        """

   315

        DebugViewer.SetDataProducer(self, producer)

   316

   317

        # Set ticktime if data producer is available

   318

        if self.DataProducer is not None:

   319

            self.SetTickTime(self.DataProducer.GetTicktime())

   320

   321

    def RefreshNewData(self, *args, **kwargs):

   322

        """

   323

        Called to refresh Panel according to values received by variables

   324

        Can receive any parameters (not used here)

   325

        """

   326

        # Refresh graphs if new data is available or refresh is forced

   327

        if self.HasNewData or self.Force:

   328

            self.HasNewData = False

   329

            self.RefreshView()

   330

   331

        DebugViewer.RefreshNewData(self, *args, **kwargs)

   332

   333

    def NewDataAvailable(self, ticks, *args, **kwargs):

   334

        """

   335

        Called by DataProducer for each tick captured or by panel to refresh

   336

        graphs

   337

        @param tick: PLC tick captured

   338

        All other parameters are passed to refresh function 

   339

        """

   340

        # If tick given

   341

        if ticks is not None:

   342

            tick = ticks[-1]

   343

   344

            # Save tick as start tick for range if data is still empty

   345

            if len(self.Ticks) == 0:

   346

                self.StartTick = ticks[0]

   347

   348

            # Add tick to list of ticks received

   349

            self.Ticks = numpy.append(self.Ticks, ticks)

   350

   351

            # Update start tick for range if range follow ticks received

   352

            if not self.Fixed or tick < self.StartTick + self.CurrentRange:

   353

                self.StartTick = max(self.StartTick, tick - self.CurrentRange)

   354

   355

            # Force refresh if graph is fixed because range of data received

   356

            # is too small to fill data range selected

   357

            if self.Fixed and \

   358

               self.Ticks[-1] - self.Ticks[0] < self.CurrentRange:

   359

                self.Force = True

   360

   361

            self.HasNewData = False

   362

            self.RefreshView()

   363

   364

        else:

   365

            DebugViewer.NewDataAvailable(self, ticks, *args, **kwargs)

   366

   367

    def ForceRefresh(self):

   368

        """

   369

        Called to force refresh of graphs

   370

        """

   371

        self.Force = True

   372

        wx.CallAfter(self.NewDataAvailable, None, True)

   373

   374

    def SetCursorTick(self, cursor_tick):

   375

        """

   376

        Set Cursor for displaying values of items at a tick given

   377

        @param cursor_tick: Tick of cursor

   378

        """

   379

        # Save cursor tick

   380

        self.CursorTick = cursor_tick

   381

        self.Fixed = cursor_tick is not None

   382

        self.UpdateCursorTick() 

   383

   384

    def MoveCursorTick(self, move):

   385

        if self.CursorTick is not None:

   386

            cursor_tick = max(self.Ticks[0], 

   387

                          min(self.CursorTick + move, 

   388

                              self.Ticks[-1]))

   389

            cursor_tick_idx = numpy.argmin(numpy.abs(self.Ticks - cursor_tick))

   390

            if self.Ticks[cursor_tick_idx] == self.CursorTick:

   391

                cursor_tick_idx = max(0, 

   392

                                  min(cursor_tick_idx + abs(move) / move, 

   393

                                      len(self.Ticks) - 1))

   394

            self.CursorTick = self.Ticks[cursor_tick_idx]

   395

            self.StartTick = max(self.Ticks[

   396

                                numpy.argmin(numpy.abs(self.Ticks - 

   397

                                        self.CursorTick + self.CurrentRange))],

   398

                             min(self.StartTick, self.CursorTick))

   399

            self.RefreshCanvasPosition()

   400

            self.UpdateCursorTick() 

   401

   402

    def ResetCursorTick(self):

   403

        self.CursorTick = None

   404

        self.Fixed = False

   405

        self.UpdateCursorTick()

   406

   407

    def UpdateCursorTick(self):

   408

        for panel in self.GraphicPanels:

   409

            if isinstance(panel, DebugVariableGraphicViewer):

   410

                panel.SetCursorTick(self.CursorTick)

   411

        self.ForceRefresh()

   412

   413

    def StartDragNDrop(self, panel, item, x_mouse, y_mouse, x_mouse_start, y_mouse_start):

   414

        if len(panel.GetItems()) > 1:

   415

            self.DraggingAxesPanel = DebugVariableGraphicViewer(self.GraphicsWindow, self, [item], GRAPH_PARALLEL)

   416

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   417

            width, height = panel.GetSize()

   418

            self.DraggingAxesPanel.SetSize(wx.Size(width, height))

   419

            self.DraggingAxesPanel.ResetGraphics()

   420

            self.DraggingAxesPanel.SetPosition(wx.Point(0, -height))

   421

        else:

   422

            self.DraggingAxesPanel = panel

   423

        self.DraggingAxesBoundingBox = panel.GetAxesBoundingBox(parent_coordinate=True)

   424

        self.DraggingAxesMousePos = wx.Point(

   425

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   426

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   427

        self.MoveDragNDrop(x_mouse, y_mouse)

   428

   429

    def MoveDragNDrop(self, x_mouse, y_mouse):

   430

        self.DraggingAxesBoundingBox.x = x_mouse - self.DraggingAxesMousePos.x

   431

        self.DraggingAxesBoundingBox.y = y_mouse - self.DraggingAxesMousePos.y

   432

        self.RefreshHighlight(x_mouse, y_mouse)

   433

   434

    def RefreshHighlight(self, x_mouse, y_mouse):

   435

        for idx, panel in enumerate(self.GraphicPanels):

   436

            x, y = panel.GetPosition()

   437

            width, height = panel.GetSize()

   438

            rect = wx.Rect(x, y, width, height)

   439

            if (rect.InsideXY(x_mouse, y_mouse) or 

   440

                idx == 0 and y_mouse < 0 or

   441

                idx == len(self.GraphicPanels) - 1 and y_mouse > panel.GetPosition()[1]):

   442

                panel.RefreshHighlight(x_mouse - x, y_mouse - y)

   443

            else:

   444

                panel.SetHighlight(HIGHLIGHT_NONE)

   445

        if wx.Platform == "__WXMSW__":

   446

            self.RefreshView()

   447

        else:

   448

            self.ForceRefresh()

   449

   450

    def ResetHighlight(self):

   451

        for panel in self.GraphicPanels:

   452

            panel.SetHighlight(HIGHLIGHT_NONE)

   453

        if wx.Platform == "__WXMSW__":

   454

            self.RefreshView()

   455

        else:

   456

            self.ForceRefresh()

   457

   458

    def IsDragging(self):

   459

        return self.DraggingAxesPanel is not None

   460

   461

    def GetDraggingAxesClippingRegion(self, panel):

   462

        x, y = panel.GetPosition()

   463

        width, height = panel.GetSize()

   464

        bbox = wx.Rect(x, y, width, height)

   465

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   466

        bbox.x -= x

   467

        bbox.y -= y

   468

        return bbox

   469

   470

    def GetDraggingAxesPosition(self, panel):

   471

        x, y = panel.GetPosition()

   472

        return wx.Point(self.DraggingAxesBoundingBox.x - x,

   473

                        self.DraggingAxesBoundingBox.y - y)

   474

   475

    def StopDragNDrop(self, variable, x_mouse, y_mouse):

   476

        if self.DraggingAxesPanel not in self.GraphicPanels:

   477

            self.DraggingAxesPanel.Destroy()

   478

        self.DraggingAxesPanel = None

   479

        self.DraggingAxesBoundingBox = None

   480

        self.DraggingAxesMousePos = None

   481

        for idx, panel in enumerate(self.GraphicPanels):

   482

            panel.SetHighlight(HIGHLIGHT_NONE)

   483

            xw, yw = panel.GetPosition()

   484

            width, height = panel.GetSize()

   485

            bbox = wx.Rect(xw, yw, width, height)

   486

            if bbox.InsideXY(x_mouse, y_mouse):

   487

                panel.ShowButtons(True)

   488

                merge_type = GRAPH_PARALLEL

   489

                if isinstance(panel, DebugVariableTextViewer) or panel.Is3DCanvas():