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

   295

    def SetTickTime(self, ticktime=0):

   296

        """

   297

        Set Ticktime for calculate data range according to time range selected

   298

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

   299

        """

   300

        # Save ticktime

   301

        self.Ticktime = ticktime

   302

   303

        # Set ticktime to millisecond if undefined

   304

        if self.Ticktime == 0:

   305

            self.Ticktime = MILLISECOND

   306

   307

        # Calculate range to apply to data

   308

        self.CurrentRange = RANGE_VALUES[

   309

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

   310

   311

    def SetDataProducer(self, producer):

   312

        """

   313

        Set Data Producer

   314

        @param producer: Data Producer

   315

        """

   316

        DebugViewer.SetDataProducer(self, producer)

   317

   318

        # Set ticktime if data producer is available

   319

        if self.DataProducer is not None:

   320

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

   321

   322

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

   323

        """

   324

        Called to refresh Panel according to values received by variables

   325

        Can receive any parameters (not used here)

   326

        """

   327

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

   328

        if self.HasNewData or self.Force:

   329

            self.HasNewData = False

   330

            self.RefreshView()

   331

   332

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

   333

   334

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

   335

        """

   336

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

   337

        graphs

   338

        @param tick: PLC tick captured

   339

        All other parameters are passed to refresh function 

   340

        """

   341

        # If tick given

   342

        if ticks is not None:

   343

            tick = ticks[-1]

   344

   345

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

   346

            if len(self.Ticks) == 0:

   347

                self.StartTick = ticks[0]

   348

   349

            # Add tick to list of ticks received

   350

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

   351

   352

            # Update start tick for range if range follow ticks received

   353

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

   354

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

   355

   356

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

   357

            # is too small to fill data range selected

   358

            if self.Fixed and \

   359

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

   360

                self.Force = True

   361

   362

            self.HasNewData = False

   363

            self.RefreshView()

   364

   365

        else:

   366

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

   367

   368

    def ForceRefresh(self):

   369

        """

   370

        Called to force refresh of graphs

   371

        """

   372

        self.Force = True

   373

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

   374

   375

    def SetCursorTick(self, cursor_tick):

   376

        """

   377

        Set Cursor for displaying values of items at a tick given

   378

        @param cursor_tick: Tick of cursor

   379

        """

   380

        # Save cursor tick

   381

        self.CursorTick = cursor_tick

   382

        self.Fixed = cursor_tick is not None

   383

        self.UpdateCursorTick() 

   384

   385

    def MoveCursorTick(self, move):

   386

        if self.CursorTick is not None:

   387

            cursor_tick = max(self.Ticks[0], 

   388

                          min(self.CursorTick + move, 

   389

                              self.Ticks[-1]))

   390

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

   391

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

   392

                cursor_tick_idx = max(0, 

   393

                                  min(cursor_tick_idx + abs(move) / move, 

   394

                                      len(self.Ticks) - 1))

   395

            self.CursorTick = self.Ticks[cursor_tick_idx]

   396

            self.StartTick = max(self.Ticks[

   397

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

   398

                                        self.CursorTick + self.CurrentRange))],

   399

                             min(self.StartTick, self.CursorTick))

   400

            self.RefreshCanvasPosition()

   401

            self.UpdateCursorTick() 

   402

   403

    def ResetCursorTick(self):

   404

        self.CursorTick = None

   405

        self.Fixed = False

   406

        self.UpdateCursorTick()

   407

   408

    def UpdateCursorTick(self):

   409

        for panel in self.GraphicPanels:

   410

            if isinstance(panel, DebugVariableGraphicViewer):

   411

                panel.SetCursorTick(self.CursorTick)

   412

        self.ForceRefresh()

   413

   414

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

   415

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

   416

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

   417

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   418

            width, height = panel.GetSize()

   419

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

   420

            self.DraggingAxesPanel.ResetGraphics()

   421

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

   422

        else:

   423

            self.DraggingAxesPanel = panel

   424

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

   425

        self.DraggingAxesMousePos = wx.Point(

   426

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   427

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   428

        self.MoveDragNDrop(x_mouse, y_mouse)

   429

   430

    def MoveDragNDrop(self, x_mouse, y_mouse):

   431

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

   432

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

   433

        self.RefreshHighlight(x_mouse, y_mouse)

   434

   435

    def RefreshHighlight(self, x_mouse, y_mouse):

   436

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

   437

            x, y = panel.GetPosition()

   438

            width, height = panel.GetSize()

   439

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

   440

            if (rect.InsideXY(x_mouse, y_mouse) or 

   441

                idx == 0 and y_mouse < 0 or

   442

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

   443

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

   444

            else:

   445

                panel.SetHighlight(HIGHLIGHT_NONE)

   446

        if wx.Platform == "__WXMSW__":

   447

            self.RefreshView()

   448

        else:

   449

            self.ForceRefresh()

   450

   451

    def ResetHighlight(self):

   452

        for panel in self.GraphicPanels:

   453

            panel.SetHighlight(HIGHLIGHT_NONE)

   454

        if wx.Platform == "__WXMSW__":

   455

            self.RefreshView()

   456

        else:

   457

            self.ForceRefresh()

   458

   459

    def IsDragging(self):

   460

        return self.DraggingAxesPanel is not None

   461

   462

    def GetDraggingAxesClippingRegion(self, panel):

   463

        x, y = panel.GetPosition()

   464

        width, height = panel.GetSize()

   465

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

   466

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   467

        bbox.x -= x

   468

        bbox.y -= y

   469

        return bbox

   470

   471

    def GetDraggingAxesPosition(self, panel):

   472

        x, y = panel.GetPosition()

   473

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

   474

                        self.DraggingAxesBoundingBox.y - y)

   475

   476

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

   477

        if self.DraggingAxesPanel not in self.GraphicPanels:

   478

            self.DraggingAxesPanel.Destroy()

   479

        self.DraggingAxesPanel = None

   480

        self.DraggingAxesBoundingBox = None

   481

        self.DraggingAxesMousePos = None

   482

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

   483

            panel.SetHighlight(HIGHLIGHT_NONE)

   484

            xw, yw = panel.GetPosition()

   485

            width, height = panel.GetSize()

   486

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

   487

            if bbox.InsideXY(x_mouse, y_mouse):

   488

                panel.ShowButtons(True)

   489

                merge_type = GRAPH_PARALLEL