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

matplotlib.use('WX')

    34

import matplotlib.pyplot

    35

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    36

    37

from editors.DebugViewer import DebugViewer

    38

from util.BitmapLibrary import GetBitmap

    39

    40

from DebugVariableItem import DebugVariableItem

    41

from DebugVariableTextViewer import DebugVariableTextViewer

    42

from DebugVariableGraphicViewer import *

    43

    44

MILLISECOND = 1000000       # Number of nanosecond in a millisecond

    45

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

    46

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

    47

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

    48

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

    49

    50

# List of values possible for graph range

    51

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

    52

RANGE_VALUES = \

    53

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

    54

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

    55

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

    56

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

    57

    58

# Scrollbar increment in pixel

    59

SCROLLBAR_UNIT = 10

    60

    61

def compute_mask(x, y):

    62

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

    63

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

    64

    65

def NextTick(variables):

    66

    next_tick = None

    67

    for item, data in variables:

    68

        if len(data) == 0:

    69

            continue

    70

    71

        next_tick = (data[0][0]

    72

                     if next_tick is None

    73

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

    74

    75

    return next_tick

    76

    77

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

    78

#                    Debug Variable Graphic Panel Drop Target

    79

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

    80

    81

"""

    82

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

    83

Panel

    84

"""

    85

    86

class DebugVariableDropTarget(wx.TextDropTarget):

    87

    88

    def __init__(self, window):

    89

        """

    90

        Constructor

    91

        @param window: Reference to the Debug Variable Panel

    92

        """

    93

        wx.TextDropTarget.__init__(self)

    94

        self.ParentWindow = window

    95

    96

    def __del__(self):

    97

        """

    98

        Destructor

    99

        """

   100

        # Remove reference to Debug Variable Panel

   101

        self.ParentWindow = None

   102

   103

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

   104

        """

   105

        Function called when mouse is dragged over Drop Target

   106

        @param x: X coordinate of mouse pointer

   107

        @param y: Y coordinate of mouse pointer

   108

        @param d: Suggested default for return value

   109

        """

   110

       # Signal Debug Variable Panel to refresh highlight giving mouse position

   111

        self.ParentWindow.RefreshHighlight(x, y)

   112

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

   113

   114

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

   115

        """

   116

        Function called when mouse is released in Drop Target

   117

        @param x: X coordinate of mouse pointer

   118

        @param y: Y coordinate of mouse pointer

   119

        @param data: Text associated to drag'n drop

   120

        """

   121

        # Signal Debug Variable Panel to reset highlight

   122

        self.ParentWindow.ResetHighlight()

   123

   124

        message = None

   125

   126

        # Check that data is valid regarding DebugVariablePanel

   127

        try:

   128

            values = eval(data)

   129

            if not isinstance(values, TupleType):

   130

                raise ValueError

   131

        except:

   132

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

   133

            values = None

   134

   135

        # Display message if data is invalid

   136

        if message is not None:

   137

            wx.CallAfter(self.ShowMessage, message)

   138

   139

        # Data contain a reference to a variable to debug

   140

        elif values[1] == "debug":

   141

   142

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

   143

            # Variable Panel 

   144

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

   145

                self.ParentWindow.MoveValue(values[0])

   146

   147

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

   148

            else:

   149

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

   150

   151

    def OnLeave(self):

   152

        """

   153

        Function called when mouse is leave Drop Target

   154

        """

   155

        # Signal Debug Variable Panel to reset highlight

   156

        self.ParentWindow.ResetHighlight()

   157

        return wx.TextDropTarget.OnLeave(self)

   158

   159

    def ShowMessage(self, message):

   160

        """

   161

        Show error message in Error Dialog

   162

        @param message: Error message to display

   163

        """

   164

        dialog = wx.MessageDialog(self.ParentWindow, 

   165

                                  message, 

   166

                                  _("Error"), 

   167

                                  wx.OK|wx.ICON_ERROR)

   168

        dialog.ShowModal()

   169

        dialog.Destroy()

   170

   171

   172

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

   173

#                      Debug Variable Graphic Panel Class

   174

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

   175

   176

"""

   177

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

   178

"""

   179

   180

class DebugVariablePanel(wx.Panel, DebugViewer):

   181

   182

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

   183

        """

   184

        Constructor

   185

        @param parent: Reference to the parent wx.Window

   186

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

   187

        consumers

   188

        @param window: Reference to Beremiz frame

   189

        """

   190

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

   191

   192

        # Save Reference to Beremiz frame

   193

        self.ParentWindow = window

   194

   195

        # Variable storing flag indicating that variable displayed in table

   196

        # received new value and then table need to be refreshed

   197

        self.HasNewData = False

   198

   199

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

   200

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

   201

        # data is available

   202

        self.Force = False

   203

   204

        self.SetBackgroundColour(wx.WHITE)

   205

   206

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   207

   208

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

   209

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

   210

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

   211

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

   212

   213

        self.DraggingAxesPanel = None

   214

        self.DraggingAxesBoundingBox = None

   215

        self.DraggingAxesMousePos = None

   216

        self.VetoScrollEvent = False

   217

   218

        self.VariableNameMask = []

   219

   220

        self.GraphicPanels = []

   221

   222

        graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   223

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

   224

   225

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

   226

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

   227

   228

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

   229

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

   230

        graphics_button_sizer.AddWindow(self.CanvasRange, 1, 

   231

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

   232

   233

        self.CanvasRange.Clear()

   234

        default_range_idx = 0

   235

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

   236

            self.CanvasRange.Append(text)

   237

            if text == "1s":

   238

                default_range_idx = idx

   239

        self.CanvasRange.SetSelection(default_range_idx)

   240

   241

        for name, bitmap, help in [

   242

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

   243

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

   244

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

   245

                  bitmap=GetBitmap(bitmap), 

   246

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

   247

            button.SetToolTipString(help)

   248

            setattr(self, name, button)

   249

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

   250

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

   251

   252

        self.CanvasPosition = wx.ScrollBar(self, 

   253

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

   254

        self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK, 

   255

              self.OnPositionChanging, self.CanvasPosition)

   256

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP, 

   257

              self.OnPositionChanging, self.CanvasPosition)

   258

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN, 

   259

              self.OnPositionChanging, self.CanvasPosition)

   260

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP, 

   261

              self.OnPositionChanging, self.CanvasPosition)

   262

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN, 

   263

              self.OnPositionChanging, self.CanvasPosition)

   264

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

   265

   266

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

   267

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

   268

   269

        self.TickLabel = wx.StaticText(self)

   270

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

   271

   272

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

   273

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

   274

   275

        self.TickTimeLabel = wx.StaticText(self)

   276

        self.TickSizer.AddWindow(self.TickTimeLabel)

   277

   278

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

   279

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   280

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   281

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

   282

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

   283

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

   284

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

   285

   286

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

   287

   288

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

   289

        self.GraphicsWindow.SetSizer(self.GraphicsSizer)

   290

   291

        DebugViewer.__init__(self, producer, True)

   292

   293

        self.SetSizer(main_sizer)

   294

        self.SetTickTime()

   295

   296

    def SetTickTime(self, ticktime=0):

   297

        """

   298

        Set Ticktime for calculate data range according to time range selected

   299

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

   300

        """

   301

        # Save ticktime

   302

        self.Ticktime = ticktime

   303

   304

        # Set ticktime to millisecond if undefined

   305

        if self.Ticktime == 0:

   306

            self.Ticktime = MILLISECOND

   307

   308

        # Calculate range to apply to data

   309

        self.CurrentRange = RANGE_VALUES[

   310

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

   311

   312

    def SetDataProducer(self, producer):

   313

        """

   314

        Set Data Producer

   315

        @param producer: Data Producer

   316

        """

   317

        DebugViewer.SetDataProducer(self, producer)

   318

   319

        # Set ticktime if data producer is available

   320

        if self.DataProducer is not None:

   321

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

   322

   323

    def RefreshNewData(self):

   324

        """

   325

        Called to refresh Panel according to values received by variables

   326

        Can receive any parameters (not used here)

   327

        """

   328

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

   329

        if self.HasNewData or self.Force:

   330

            self.HasNewData = False

   331

            self.RefreshView()

   332

   333

        DebugViewer.RefreshNewData(self)

   334

   335

    def NewDataAvailable(self, ticks):

   336

        """

   337

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

   338

        graphs

   339

        @param tick: PLC tick captured

   340

        All other parameters are passed to refresh function 

   341

        """

   342

        # If tick given

   343

        if ticks is not None:

   344

            tick = ticks[-1]

   345

   346

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

   347

            if len(self.Ticks) == 0:

   348

                self.StartTick = ticks[0]

   349

   350

            # Add tick to list of ticks received

   351

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

   352

   353

            # Update start tick for range if range follow ticks received

   354

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

   355

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

   356

   357

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

   358

            # is too small to fill data range selected

   359

            if self.Fixed and \

   360

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

   361

                self.Force = True

   362

   363

            self.HasNewData = False

   364

            self.RefreshView()

   365

   366

        else:

   367

            DebugViewer.NewDataAvailable(self, ticks)

   368

   369

    def ForceRefresh(self):

   370

        """

   371

        Called to force refresh of graphs

   372

        """

   373

        self.Force = True

   374

        wx.CallAfter(self.NewDataAvailable, None)

   375

   376

    def SetCursorTick(self, cursor_tick):

   377

        """

   378

        Set Cursor for displaying values of items at a tick given

   379

        @param cursor_tick: Tick of cursor

   380

        """

   381

        # Save cursor tick

   382

        self.CursorTick = cursor_tick

   383

        self.Fixed = cursor_tick is not None

   384

        self.UpdateCursorTick() 

   385

   386

    def MoveCursorTick(self, move):

   387

        if self.CursorTick is not None:

   388

            cursor_tick = max(self.Ticks[0], 

   389

                          min(self.CursorTick + move, 

   390

                              self.Ticks[-1]))

   391

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

   392

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

   393

                cursor_tick_idx = max(0, 

   394

                                  min(cursor_tick_idx + abs(move) / move, 

   395

                                      len(self.Ticks) - 1))

   396

            self.CursorTick = self.Ticks[cursor_tick_idx]

   397

            self.StartTick = max(self.Ticks[

   398

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

   399

                                        self.CursorTick + self.CurrentRange))],

   400

                             min(self.StartTick, self.CursorTick))

   401

            self.RefreshCanvasPosition()

   402

            self.UpdateCursorTick() 

   403

   404

    def ResetCursorTick(self):

   405

        self.CursorTick = None

   406

        self.Fixed = False

   407

        self.UpdateCursorTick()

   408

   409

    def UpdateCursorTick(self):

   410

        for panel in self.GraphicPanels:

   411

            if isinstance(panel, DebugVariableGraphicViewer):

   412

                panel.SetCursorTick(self.CursorTick)

   413

        self.ForceRefresh()

   414

   415

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

   416

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

   417

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

   418

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   419

            width, height = panel.GetSize()

   420

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

   421

            self.DraggingAxesPanel.ResetGraphics()

   422

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

   423

        else:

   424

            self.DraggingAxesPanel = panel

   425

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

   426

        self.DraggingAxesMousePos = wx.Point(

   427

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   428

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   429

        self.MoveDragNDrop(x_mouse, y_mouse)

   430

   431

    def MoveDragNDrop(self, x_mouse, y_mouse):

   432

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

   433

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

   434

        self.RefreshHighlight(x_mouse, y_mouse)

   435

   436

    def RefreshHighlight(self, x_mouse, y_mouse):

   437

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

   438

            x, y = panel.GetPosition()

   439

            width, height = panel.GetSize()

   440

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

   441

            if (rect.InsideXY(x_mouse, y_mouse) or 

   442

                idx == 0 and y_mouse < 0 or

   443

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

   444

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

   445

            else:

   446

                panel.SetHighlight(HIGHLIGHT_NONE)

   447

        if wx.Platform == "__WXMSW__":

   448

            self.RefreshView()

   449

        else:

   450

            self.ForceRefresh()

   451

   452

    def ResetHighlight(self):

   453

        for panel in self.GraphicPanels:

   454

            panel.SetHighlight(HIGHLIGHT_NONE)

   455

        if wx.Platform == "__WXMSW__":

   456

            self.RefreshView()

   457

        else:

   458

            self.ForceRefresh()

   459

   460

    def IsDragging(self):

   461

        return self.DraggingAxesPanel is not None

   462

   463

    def GetDraggingAxesClippingRegion(self, panel):

   464

        x, y = panel.GetPosition()

   465

        width, height = panel.GetSize()

   466

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

   467

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   468

        bbox.x -= x

   469

        bbox.y -= y

   470

        return bbox

   471

   472

    def GetDraggingAxesPosition(self, panel):

   473

        x, y = panel.GetPosition()

   474

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

   475

                        self.DraggingAxesBoundingBox.y - y)

   476

   477

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

   478

        if self.DraggingAxesPanel not in self.GraphicPanels:

   479

            self.DraggingAxesPanel.Destroy()

   480

        self.DraggingAxesPanel = None

   481

        self.DraggingAxesBoundingBox = None

   482

        self.DraggingAxesMousePos = None

   483

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

   484

            panel.SetHighlight(HIGHLIGHT_NONE)

   485

            xw, yw = panel.GetPosition()

   486

            width, height = panel.GetSize()

   487

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

   488

            if bbox.InsideXY(x_mouse, y_mouse):

   489