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

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

   343

            self.HasNewData = True

   344

   345

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

   346

            if len(self.Ticks) == 0:

   347

                self.StartTick = tick 

   348

   349

            # Add tick to list of ticks received

   350

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

   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

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

   363

   364

    def ForceRefresh(self):

   365

        """

   366

        Called to force refresh of graphs

   367

        """

   368

        self.Force = True

   369

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

   370

   371

    def SetCursorTick(self, cursor_tick):

   372

        """

   373

        Set Cursor for displaying values of items at a tick given

   374

        @param cursor_tick: Tick of cursor

   375

        """

   376

        # Save cursor tick

   377

        self.CursorTick = cursor_tick

   378

        self.Fixed = cursor_tick is not None

   379

        self.UpdateCursorTick() 

   380

   381

    def MoveCursorTick(self, move):

   382

        if self.CursorTick is not None:

   383

            cursor_tick = max(self.Ticks[0], 

   384

                          min(self.CursorTick + move, 

   385

                              self.Ticks[-1]))

   386

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

   387

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

   388

                cursor_tick_idx = max(0, 

   389

                                  min(cursor_tick_idx + abs(move) / move, 

   390

                                      len(self.Ticks) - 1))

   391

            self.CursorTick = self.Ticks[cursor_tick_idx]

   392

            self.StartTick = max(self.Ticks[

   393

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

   394

                                        self.CursorTick + self.CurrentRange))],

   395

                             min(self.StartTick, self.CursorTick))

   396

            self.RefreshCanvasPosition()

   397

            self.UpdateCursorTick() 

   398

   399

    def ResetCursorTick(self):

   400

        self.CursorTick = None

   401

        self.Fixed = False

   402

        self.UpdateCursorTick()

   403

   404

    def UpdateCursorTick(self):

   405

        for panel in self.GraphicPanels:

   406

            if isinstance(panel, DebugVariableGraphicViewer):

   407

                panel.SetCursorTick(self.CursorTick)

   408

        self.ForceRefresh()

   409

   410

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

   411

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

   412

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

   413

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   414

            width, height = panel.GetSize()

   415

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

   416

            self.DraggingAxesPanel.ResetGraphics()

   417

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

   418

        else:

   419

            self.DraggingAxesPanel = panel

   420

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

   421

        self.DraggingAxesMousePos = wx.Point(

   422

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   423

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   424

        self.MoveDragNDrop(x_mouse, y_mouse)

   425

   426

    def MoveDragNDrop(self, x_mouse, y_mouse):

   427

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

   428

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

   429

        self.RefreshHighlight(x_mouse, y_mouse)

   430

   431

    def RefreshHighlight(self, x_mouse, y_mouse):

   432

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

   433

            x, y = panel.GetPosition()

   434

            width, height = panel.GetSize()

   435

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

   436

            if (rect.InsideXY(x_mouse, y_mouse) or 

   437

                idx == 0 and y_mouse < 0 or

   438

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

   439

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

   440

            else:

   441

                panel.SetHighlight(HIGHLIGHT_NONE)

   442

        if wx.Platform == "__WXMSW__":

   443

            self.RefreshView()

   444

        else:

   445

            self.ForceRefresh()

   446

   447

    def ResetHighlight(self):

   448

        for panel in self.GraphicPanels:

   449

            panel.SetHighlight(HIGHLIGHT_NONE)

   450

        if wx.Platform == "__WXMSW__":

   451

            self.RefreshView()

   452

        else:

   453

            self.ForceRefresh()

   454

   455

    def IsDragging(self):

   456

        return self.DraggingAxesPanel is not None

   457

   458

    def GetDraggingAxesClippingRegion(self, panel):

   459

        x, y = panel.GetPosition()

   460

        width, height = panel.GetSize()

   461

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

   462

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   463

        bbox.x -= x

   464

        bbox.y -= y

   465

        return bbox

   466

   467

    def GetDraggingAxesPosition(self, panel):

   468

        x, y = panel.GetPosition()

   469

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

   470

                        self.DraggingAxesBoundingBox.y - y)

   471

   472

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

   473

        if self.DraggingAxesPanel not in self.GraphicPanels:

   474

            self.DraggingAxesPanel.Destroy()

   475

        self.DraggingAxesPanel = None

   476

        self.DraggingAxesBoundingBox = None

   477

        self.DraggingAxesMousePos = None

   478

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

   479

            panel.SetHighlight(HIGHLIGHT_NONE)

   480

            xw, yw = panel.GetPosition()

   481

            width, height = panel.GetSize()

   482

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

   483

            if bbox.InsideXY(x_mouse, y_mouse):

   484

                panel.ShowButtons(True)

   485

                merge_type = GRAPH_PARALLEL

   486

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

   487

                    if y_mouse > yw + height / 2:

   488

                        idx += 1

   489

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