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

class DebugVariableDropTarget(wx.TextDropTarget):

    45

    46

    def __init__(self, parent):

    47

        wx.TextDropTarget.__init__(self)

    48

        self.ParentWindow = parent

    49

    50

    def __del__(self):

    51

        self.ParentWindow = None

    52

    53

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

    54

        self.ParentWindow.RefreshHighlight(x, y)

    55

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

    56

    57

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

    58

        message = None

    59

        try:

    60

            values = eval(data)

    61

            if not isinstance(values, TupleType):

    62

                raise ValueError

    63

        except:

    64

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

    65

            values = None

    66

    67

        if message is not None:

    68

            wx.CallAfter(self.ShowMessage, message)

    69

    70

        elif values[1] == "debug":

    71

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

    72

                self.ParentWindow.MoveValue(values[0])

    73

            else:

    74

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

    75

    76

    def OnLeave(self):

    77

        self.ParentWindow.ResetHighlight()

    78

        return wx.TextDropTarget.OnLeave(self)

    79

    80

    def ShowMessage(self, message):

    81

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

    82

        dialog.ShowModal()

    83

        dialog.Destroy()

    84

    85

MILLISECOND = 1000000

    86

SECOND = 1000 * MILLISECOND

    87

MINUTE = 60 * SECOND

    88

HOUR = 60 * MINUTE

    89

DAY = 24 * HOUR

    90

    91

ZOOM_VALUES = map(lambda x:("x %.1f" % x, x), [math.sqrt(2) ** i for i in xrange(8)])

    92

RANGE_VALUES = \

    93

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

    94

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

    95

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

    96

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

    97

    98

SCROLLBAR_UNIT = 10

    99

   100

def compute_mask(x, y):

   101

    mask = []

   102

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

   103

        if xp == yp:

   104

            mask.append(xp)

   105

        else:

   106

            mask.append("*")

   107

    return mask

   108

   109

def NextTick(variables):

   110

    next_tick = None

   111

    for item, data in variables:

   112

        if len(data) > 0:

   113

            if next_tick is None:

   114

                next_tick = data[0][0]

   115

            else:

   116

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

   117

    return next_tick

   118

   119

class DebugVariableGraphicPanel(wx.Panel, DebugViewer):

   120

   121

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

   122

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

   123

   124

        self.ParentWindow = window

   125

   126

        self.HasNewData = False

   127

        self.Force = False

   128

   129

        self.SetBackgroundColour(wx.WHITE)

   130

   131

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   132

   133

        self.Ticks = numpy.array([])

   134

        self.StartTick = 0

   135

        self.Fixed = False

   136

        self.CursorTick = None

   137

        self.DraggingAxesPanel = None

   138

        self.DraggingAxesBoundingBox = None

   139

        self.DraggingAxesMousePos = None

   140

        self.VetoScrollEvent = False

   141

        self.VariableNameMask = []

   142

   143

        self.GraphicPanels = []

   144

   145

        graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   146

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

   147

   148

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

   149

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

   150

   151

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

   152

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

   153

        graphics_button_sizer.AddWindow(self.CanvasRange, 1, 

   154

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

   155

   156

        self.CanvasRange.Clear()

   157

        default_range_idx = 0

   158

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

   159

            self.CanvasRange.Append(text)

   160

            if text == "1s":

   161

                default_range_idx = idx

   162

        self.CanvasRange.SetSelection(default_range_idx)

   163

   164

        for name, bitmap, help in [

   165

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

   166

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

   167

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

   168

                  bitmap=GetBitmap(bitmap), 

   169

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

   170

            button.SetToolTipString(help)

   171

            setattr(self, name, button)

   172

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

   173

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

   174

   175

        self.CanvasPosition = wx.ScrollBar(self, 

   176

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

   177

        self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK, 

   178

              self.OnPositionChanging, self.CanvasPosition)

   179

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP, 

   180

              self.OnPositionChanging, self.CanvasPosition)

   181

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN, 

   182

              self.OnPositionChanging, self.CanvasPosition)

   183

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP, 

   184

              self.OnPositionChanging, self.CanvasPosition)

   185

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN, 

   186

              self.OnPositionChanging, self.CanvasPosition)

   187

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

   188

   189

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

   190

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

   191

   192

        self.TickLabel = wx.StaticText(self)

   193

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

   194

   195

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

   196

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

   197

   198

        self.TickTimeLabel = wx.StaticText(self)

   199

        self.TickSizer.AddWindow(self.TickTimeLabel)

   200

   201

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

   202

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   203

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   204

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

   205

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

   206

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

   207

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

   208

   209

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

   210

   211

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

   212

        self.GraphicsWindow.SetSizer(self.GraphicsSizer)

   213

   214

        DebugViewer.__init__(self, producer, True)

   215

   216

        self.SetSizer(main_sizer)

   217

   218

    def SetTickTime(self, ticktime=0):

   219

        self.Ticktime = ticktime

   220

        if self.Ticktime == 0:

   221

            self.Ticktime = MILLISECOND

   222

        self.CurrentRange = RANGE_VALUES[

   223

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

   224

   225

    def SetDataProducer(self, producer):

   226

        DebugViewer.SetDataProducer(self, producer)

   227

   228

        if self.DataProducer is not None:

   229

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

   230

   231

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

   232

        if self.HasNewData or self.Force:

   233

            self.HasNewData = False

   234

            self.RefreshView()

   235

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

   236

   237

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

   238

        if tick is not None:

   239

            if len(self.Ticks) == 0:

   240

                self.StartTick = tick 

   241

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

   242

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

   243

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

   244

            if self.Fixed and self.Ticks[-1] - self.Ticks[0] < self.CurrentRange:

   245

                self.Force = True

   246

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

   247

   248

    def ForceRefresh(self):

   249

        self.Force = True

   250

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

   251

   252

    def RefreshGraphicsSizer(self):

   253

        self.GraphicsSizer.Clear()

   254

   255

        for panel in self.GraphicPanels:

   256

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

   257

   258

        self.GraphicsSizer.Layout()

   259

        self.RefreshGraphicsWindowScrollbars()

   260

   261

    def SetCanvasPosition(self, tick):

   262

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

   263

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

   264

        self.Fixed = True

   265

        self.RefreshCanvasPosition()

   266

        self.ForceRefresh()

   267

   268

    def SetCursorTick(self, cursor_tick):

   269

        self.CursorTick = cursor_tick

   270

        self.Fixed = cursor_tick is not None

   271

        self.UpdateCursorTick() 

   272

   273

    def MoveCursorTick(self, move):

   274

        if self.CursorTick is not None:

   275

            cursor_tick = max(self.Ticks[0], 

   276

                          min(self.CursorTick + move, 

   277

                              self.Ticks[-1]))

   278

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

   279

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

   280

                cursor_tick_idx = max(0, 

   281

                                  min(cursor_tick_idx + abs(move) / move, 

   282

                                      len(self.Ticks) - 1))

   283

            self.CursorTick = self.Ticks[cursor_tick_idx]

   284

            self.StartTick = max(self.Ticks[

   285

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

   286

                                        self.CursorTick + self.CurrentRange))],

   287

                             min(self.StartTick, self.CursorTick))

   288

            self.RefreshCanvasPosition()

   289

            self.UpdateCursorTick() 

   290

   291

    def ResetCursorTick(self):

   292

        self.CursorTick = None

   293

        self.UpdateCursorTick()

   294

   295

    def UpdateCursorTick(self):

   296

        for panel in self.GraphicPanels:

   297

            if isinstance(panel, DebugVariableGraphicViewer):

   298

                panel.SetCursorTick(self.CursorTick)

   299

        self.ForceRefresh()

   300

   301

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

   302

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

   303

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

   304

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   305

            width, height = panel.GetSize()

   306

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

   307

            self.DraggingAxesPanel.ResetGraphics()

   308

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

   309

        else:

   310

            self.DraggingAxesPanel = panel

   311

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

   312

        self.DraggingAxesMousePos = wx.Point(

   313

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   314

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   315

        self.MoveDragNDrop(x_mouse, y_mouse)

   316

   317

    def MoveDragNDrop(self, x_mouse, y_mouse):

   318

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

   319

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

   320

        self.RefreshHighlight(x_mouse, y_mouse)

   321

   322

    def RefreshHighlight(self, x_mouse, y_mouse):

   323

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

   324

            x, y = panel.GetPosition()

   325

            width, height = panel.GetSize()

   326

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

   327

            if (rect.InsideXY(x_mouse, y_mouse) or 

   328

                idx == 0 and y_mouse < 0 or

   329

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

   330

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

   331

            else:

   332

                panel.SetHighlight(HIGHLIGHT_NONE)

   333

        if wx.Platform == "__WXMSW__":

   334

            self.RefreshView()

   335

        else:

   336

            self.ForceRefresh()

   337

   338

    def ResetHighlight(self):

   339

        for panel in self.GraphicPanels:

   340

            panel.SetHighlight(HIGHLIGHT_NONE)

   341

        if wx.Platform == "__WXMSW__":

   342

            self.RefreshView()

   343

        else:

   344

            self.ForceRefresh()

   345

   346

    def IsDragging(self):

   347

        return self.DraggingAxesPanel is not None

   348

   349

    def GetDraggingAxesClippingRegion(self, panel):

   350

        x, y = panel.GetPosition()

   351

        width, height = panel.GetSize()

   352

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

   353

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   354

        bbox.x -= x

   355

        bbox.y -= y

   356

        return bbox

   357

   358

    def GetDraggingAxesPosition(self, panel):

   359

        x, y = panel.GetPosition()

   360

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

   361

                        self.DraggingAxesBoundingBox.y - y)

   362

   363

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

   364

        if self.DraggingAxesPanel not in self.GraphicPanels:

   365

            self.DraggingAxesPanel.Destroy()

   366

        self.DraggingAxesPanel = None

   367

        self.DraggingAxesBoundingBox = None

   368

        self.DraggingAxesMousePos = None

   369

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

   370

            panel.SetHighlight(HIGHLIGHT_NONE)

   371

            xw, yw = panel.GetPosition()

   372

            width, height = panel.GetSize()

   373

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

   374

            if bbox.InsideXY(x_mouse, y_mouse):

   375

                panel.ShowButtons(True)

   376

                merge_type = GRAPH_PARALLEL

   377

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

   378

                    if y_mouse > yw + height / 2:

   379

                        idx += 1

   380

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

   381

                else:

   382

                    rect = panel.GetAxesBoundingBox(True)

   383

                    if rect.InsideXY(x_mouse, y_mouse):

   384

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

   385

                        if merge_rect.InsideXY(x_mouse, y_mouse):

   386

                            merge_type = GRAPH_ORTHOGONAL

   387

                        wx.CallAfter(self.MergeGraphs, variable, idx, merge_type, force=True)

   388

                    else:

   389

                        if y_mouse > yw + height / 2:

   390

                            idx += 1

   391

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

   392

                self.ForceRefresh()

   393

                return 

   394

        width, height = self.GraphicsWindow.GetVirtualSize()

   395

        rect = wx.Rect(0, 0, width, height)

   396

        if rect.InsideXY(x_mouse, y_mouse):

   397

            wx.CallAfter(self.MoveValue, variable, len(self.GraphicPanels))

   398

        self.ForceRefresh()

   399

   400

    def RefreshView(self):

   401

        self.RefreshCanvasPosition()

   402

   403

        width, height = self.GraphicsWindow.GetVirtualSize()

   404

        bitmap = wx.EmptyBitmap(width, height)

   405

        dc = wx.BufferedDC(wx.ClientDC(self.GraphicsWindow), bitmap)

   406

        dc.Clear()

   407

        dc.BeginDrawing()

   408

        if self.DraggingAxesPanel is not None:

   409

            destBBox = self.DraggingAxesBoundingBox

   410

            srcBBox = self.DraggingAxesPanel.GetAxesBoundingBox()

   411

   412

            srcBmp = _convert_agg_to_wx_bitmap(self.DraggingAxesPanel.get_renderer(), None)

   413

            srcDC = wx.MemoryDC()

   414

            srcDC.SelectObject(srcBmp)

   415

   416

            dc.Blit(destBBox.x, destBBox.y, 

   417

                    int(destBBox.width), int(destBBox.height), 

   418

                    srcDC, srcBBox.x, srcBBox.y)

   419

        dc.EndDrawing()

   420

   421

        if not self.Fixed or self.Force:

   422

            self.Force = False

   423

            refresh_graphics = True

   424

        else:

   425

            refresh_graphics = False

   426

   427

        if self.DraggingAxesPanel is not None and self.DraggingAxesPanel not in self.GraphicPanels:

   428

            self.DraggingAxesPanel.RefreshViewer(refresh_graphics)

   429

        for panel in self.GraphicPanels:

   430

            if isinstance(panel, DebugVariableGraphicViewer):

   431

                panel.RefreshViewer(refresh_graphics)

   432

            else:

   433

                panel.RefreshViewer()

   434

   435

        if self.CursorTick is not None:

   436

            tick = self.CursorTick

   437

        elif len(self.Ticks) > 0:

   438

            tick = self.Ticks[-1]

   439

        else:

   440

            tick = None

   441

        if tick is not None:

   442

            self.TickLabel.SetLabel("Tick: %d" % tick)

   443

            tick_duration = int(tick * self.Ticktime)

   444

            not_null = False

   445

            duration = ""

   446

            for value, format in [(tick_duration / DAY, "%dd"),

   447

                                  ((tick_duration % DAY) / HOUR, "%dh"),

   448

                                  ((tick_duration % HOUR) / MINUTE, "%dm"),

   449

                                  ((tick_duration % MINUTE) / SECOND, "%ds")]:

   450

   451

                if value > 0 or not_null:

   452

                    duration += format % value

   453

                    not_null = True

   454

   455

            duration += "%gms" % (float(tick_duration % SECOND) / MILLISECOND) 

   456

            self.TickTimeLabel.SetLabel("t: %s" % duration)

   457

        else:

   458

            self.TickLabel.SetLabel("")

   459

            self.TickTimeLabel.SetLabel("")

   460

        self.TickSizer.Layout()

   461

   462

    def SubscribeAllDataConsumers(self):

   463

        DebugViewer.SubscribeAllDataConsumers(self)

   464

   465

        if self.DataProducer is not None:

   466

            if self.DataProducer is not None:

   467

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

   468

   469

        for panel in self.GraphicPanels:

   470

            panel.SubscribeAllDataConsumers()

   471

            if panel.ItemsIsEmpty():

   472

                if panel.HasCapture():

   473

                    panel.ReleaseMouse()

   474

                self.GraphicPanels.remove(panel)

   475

                panel.Destroy()

   476

   477

        self.ResetVariableNameMask()

   478

        self.RefreshGraphicsSizer()

   479

        self.ForceRefresh()

   480

   481

    def ResetView(self):

   482

        self.UnsubscribeAllDataConsumers()

   483

   484

        self.Fixed = False

   485

        for panel in self.GraphicPanels:

   486

            panel.Destroy()

   487

        self.GraphicPanels = []

   488

        self.ResetVariableNameMask()

   489

        self.RefreshGraphicsSizer()

   490

   491

    def RefreshCanvasPosition(self):