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 = (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

        message = None

   122

   123

        # Check that data is valid regarding DebugVariablePanel

   124

        try:

   125

            values = eval(data)

   126

            if not isinstance(values, TupleType):

   127

                raise ValueError

   128

        except:

   129

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

   130

            values = None

   131

   132

        # Display message if data is invalid

   133

        if message is not None:

   134

            wx.CallAfter(self.ShowMessage, message)

   135

   136

        # Data contain a reference to a variable to debug

   137

        elif values[1] == "debug":

   138

   139

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

   140

            # Variable Panel 

   141

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

   142

                self.ParentWindow.MoveValue(values[0])

   143

   144

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

   145

            else:

   146

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

   147

   148

    def OnLeave(self):

   149

        """

   150

        Function called when mouse is leave Drop Target

   151

        """

   152

        # Signal Debug Variable Panel to reset highlight

   153

        self.ParentWindow.ResetHighlight()

   154

        return wx.TextDropTarget.OnLeave(self)

   155

   156

    def ShowMessage(self, message):

   157

        """

   158

        Show error message in Error Dialog

   159

        @param message: Error message to display

   160

        """

   161

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

   162

        dialog.ShowModal()

   163

        dialog.Destroy()

   164

   165

   166

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

   167

#                      Debug Variable Graphic Panel Class

   168

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

   169

   170

"""

   171

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

   172

"""

   173

   174

class DebugVariableGraphicPanel(wx.Panel, DebugViewer):

   175

   176

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

   177

        """

   178

        Constructor

   179

        @param parent: Reference to the parent wx.Window

   180

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

   181

        consumers

   182

        @param window: Reference to Beremiz frame

   183

        """

   184

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

   185

   186

        # Save Reference to Beremiz frame

   187

        self.ParentWindow = window

   188

   189

        # Variable storing flag indicating that variable displayed in table

   190

        # received new value and then table need to be refreshed

   191

        self.HasNewData = False

   192

   193

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

   194

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

   195

        # data is available

   196

        self.Force = False

   197

   198

        self.SetBackgroundColour(wx.WHITE)

   199

   200

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   201

   202

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

   203

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

   204

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

   205

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

   206

   207

        # 

   208

        self.DraggingAxesPanel = None

   209

        self.DraggingAxesBoundingBox = None

   210

        self.DraggingAxesMousePos = None

   211

        self.VetoScrollEvent = False

   212

   213

        self.VariableNameMask = []

   214

   215

        self.GraphicPanels = []

   216

   217

        graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   218

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

   219

   220

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

   221

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

   222

   223

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

   224

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

   225

        graphics_button_sizer.AddWindow(self.CanvasRange, 1, 

   226

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

   227

   228

        self.CanvasRange.Clear()

   229

        default_range_idx = 0

   230

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

   231

            self.CanvasRange.Append(text)

   232

            if text == "1s":

   233

                default_range_idx = idx

   234

        self.CanvasRange.SetSelection(default_range_idx)

   235

   236

        for name, bitmap, help in [

   237

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

   238

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

   239

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

   240

                  bitmap=GetBitmap(bitmap), 

   241

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

   242

            button.SetToolTipString(help)

   243

            setattr(self, name, button)

   244

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

   245

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

   246

   247

        self.CanvasPosition = wx.ScrollBar(self, 

   248

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

   249

        self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK, 

   250

              self.OnPositionChanging, self.CanvasPosition)

   251

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP, 

   252

              self.OnPositionChanging, self.CanvasPosition)

   253

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN, 

   254

              self.OnPositionChanging, self.CanvasPosition)

   255

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP, 

   256

              self.OnPositionChanging, self.CanvasPosition)

   257

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN, 

   258

              self.OnPositionChanging, self.CanvasPosition)

   259

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

   260

   261

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

   262

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

   263

   264

        self.TickLabel = wx.StaticText(self)

   265

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

   266

   267

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

   268

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

   269

   270

        self.TickTimeLabel = wx.StaticText(self)

   271

        self.TickSizer.AddWindow(self.TickTimeLabel)

   272

   273

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

   274

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   275

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   276

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

   277

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

   278

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

   279

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

   280

   281

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

   282

   283

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

   284

        self.GraphicsWindow.SetSizer(self.GraphicsSizer)

   285

   286

        DebugViewer.__init__(self, producer, True)

   287

   288

        self.SetSizer(main_sizer)

   289

   290

    def SetTickTime(self, ticktime=0):

   291

        """

   292

        Set Ticktime for calculate data range according to time range selected

   293

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

   294

        """

   295

        # Save ticktime

   296

        self.Ticktime = ticktime

   297

   298

        # Set ticktime to millisecond if undefined

   299

        if self.Ticktime == 0:

   300

            self.Ticktime = MILLISECOND

   301

   302

        # Calculate range to apply to data

   303

        self.CurrentRange = RANGE_VALUES[

   304

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

   305

   306

    def SetDataProducer(self, producer):

   307

        """

   308

        Set Data Producer

   309

        @param producer: Data Producer

   310

        """

   311

        DebugViewer.SetDataProducer(self, producer)

   312

   313

        # Set ticktime if data producer is available

   314

        if self.DataProducer is not None:

   315

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

   316

   317

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

   318

        """

   319

        Called to refresh Panel according to values received by variables

   320

        Can receive any parameters (not used here)

   321

        """

   322

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

   323

        if self.HasNewData or self.Force:

   324

            self.HasNewData = False

   325

            self.RefreshView()

   326

   327

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

   328

   329

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

   330

        """

   331

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

   332

        graphs

   333

        @param tick: PLC tick captured

   334

        All other parameters are passed to refresh function 

   335

        """

   336

        # If tick given

   337

        if tick is not None:

   338

   339

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

   340

            if len(self.Ticks) == 0:

   341

                self.StartTick = tick 

   342

   343

            # Add tick to list of ticks received

   344

            self.Ticks = numpy.append(self.Ticks, [tick])

   345

   346

            # Update start tick for range if range follow ticks received

   347

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

   348

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

   349

   350

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

   351

            # is too small to fill data range selected

   352

            if self.Fixed and \

   353

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

   354

                self.Force = True

   355

   356

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

   357

   358

    def ForceRefresh(self):

   359

        """

   360

        Called to force refresh of graphs

   361

        """

   362

        self.Force = True

   363

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

   364

   365

    def RefreshGraphicsSizer(self):

   366

        self.GraphicsSizer.Clear()

   367

   368

        for panel in self.GraphicPanels:

   369

            self.GraphicsSizer.AddWindow(panel, flag=wx.GROW)

   370

   371

        self.GraphicsSizer.Layout()

   372

        self.RefreshGraphicsWindowScrollbars()

   373

   374

    def SetCanvasPosition(self, tick):

   375

        tick = max(self.Ticks[0], min(tick, self.Ticks[-1] - self.CurrentRange))

   376

        self.StartTick = self.Ticks[numpy.argmin(numpy.abs(self.Ticks - tick))]

   377

        self.Fixed = True

   378

        self.RefreshCanvasPosition()

   379

        self.ForceRefresh()

   380

   381

    def SetCursorTick(self, 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.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

   490

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