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 DebugVariableGraphicPanel(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, tick, *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 tick is not None:

   342

            self.HasNewData = True

   343

   344

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

   345

            if len(self.Ticks) == 0:

   346

                self.StartTick = tick 

   347

   348

            # Add tick to list of ticks received

   349

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

   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

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

   362

   363

    def ForceRefresh(self):

   364

        """

   365

        Called to force refresh of graphs

   366

        """

   367

        self.Force = True

   368

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

   369

   370

    def SetCursorTick(self, cursor_tick):

   371

        """

   372

        Set Cursor for displaying values of items at a tick given

   373

        @param cursor_tick: Tick of cursor

   374

        """

   375

        # Save cursor tick

   376

        self.CursorTick = cursor_tick

   377

        self.Fixed = cursor_tick is not None

   378

        self.UpdateCursorTick() 

   379

   380

    def MoveCursorTick(self, move):

   381

        if self.CursorTick is not None:

   382

            cursor_tick = max(self.Ticks[0], 

   383

                          min(self.CursorTick + move, 

   384

                              self.Ticks[-1]))

   385

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

   386

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

   387

                cursor_tick_idx = max(0, 

   388

                                  min(cursor_tick_idx + abs(move) / move, 

   389

                                      len(self.Ticks) - 1))

   390

            self.CursorTick = self.Ticks[cursor_tick_idx]

   391

            self.StartTick = max(self.Ticks[

   392

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

   393

                                        self.CursorTick + self.CurrentRange))],

   394

                             min(self.StartTick, self.CursorTick))

   395

            self.RefreshCanvasPosition()

   396

            self.UpdateCursorTick() 

   397

   398

    def ResetCursorTick(self):

   399

        self.CursorTick = None

   400

        self.Fixed = False

   401

        self.UpdateCursorTick()

   402

   403

    def UpdateCursorTick(self):

   404

        for panel in self.GraphicPanels:

   405

            if isinstance(panel, DebugVariableGraphicViewer):

   406

                panel.SetCursorTick(self.CursorTick)

   407

        self.ForceRefresh()

   408

   409

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

   410

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

   411

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

   412

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   413

            width, height = panel.GetSize()

   414

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

   415

            self.DraggingAxesPanel.ResetGraphics()

   416

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

   417

        else:

   418

            self.DraggingAxesPanel = panel

   419

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

   420

        self.DraggingAxesMousePos = wx.Point(

   421

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   422

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   423

        self.MoveDragNDrop(x_mouse, y_mouse)

   424

   425

    def MoveDragNDrop(self, x_mouse, y_mouse):

   426

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

   427

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

   428

        self.RefreshHighlight(x_mouse, y_mouse)

   429

   430

    def RefreshHighlight(self, x_mouse, y_mouse):

   431

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

   432

            x, y = panel.GetPosition()

   433

            width, height = panel.GetSize()

   434

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

   435

            if (rect.InsideXY(x_mouse, y_mouse) or 

   436

                idx == 0 and y_mouse < 0 or

   437

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

   438

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

   439

            else:

   440

                panel.SetHighlight(HIGHLIGHT_NONE)

   441

        if wx.Platform == "__WXMSW__":

   442

            self.RefreshView()

   443

        else:

   444

            self.ForceRefresh()

   445

   446

    def ResetHighlight(self):

   447

        for panel in self.GraphicPanels:

   448

            panel.SetHighlight(HIGHLIGHT_NONE)

   449

        if wx.Platform == "__WXMSW__":

   450

            self.RefreshView()

   451

        else:

   452

            self.ForceRefresh()

   453

   454

    def IsDragging(self):

   455

        return self.DraggingAxesPanel is not None

   456

   457

    def GetDraggingAxesClippingRegion(self, panel):

   458

        x, y = panel.GetPosition()

   459

        width, height = panel.GetSize()

   460

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

   461

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   462

        bbox.x -= x

   463

        bbox.y -= y

   464

        return bbox

   465

   466

    def GetDraggingAxesPosition(self, panel):

   467

        x, y = panel.GetPosition()

   468

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

   469

                        self.DraggingAxesBoundingBox.y - y)

   470

   471

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

   472

        if self.DraggingAxesPanel not in self.GraphicPanels:

   473

            self.DraggingAxesPanel.Destroy()

   474

        self.DraggingAxesPanel = None

   475

        self.DraggingAxesBoundingBox = None

   476

        self.DraggingAxesMousePos = None

   477

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

   478

            panel.SetHighlight(HIGHLIGHT_NONE)

   479

            xw, yw = panel.GetPosition()

   480

            width, height = panel.GetSize()

   481

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

   482

            if bbox.InsideXY(x_mouse, y_mouse):

   483

                panel.ShowButtons(True)

   484

                merge_type = GRAPH_PARALLEL

   485

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

   486

                    if y_mouse > yw + height / 2:

   487

                        idx += 1

   488

                    wx.CallAfter(self.MoveValue, variable, idx, True)

   489

                else: