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

   221

    def SetTickTime(self, ticktime=0):

   222

        self.Ticktime = ticktime

   223

        if self.Ticktime == 0:

   224

            self.Ticktime = MILLISECOND

   225

        self.CurrentRange = RANGE_VALUES[

   226

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

   227

   228

    def SetDataProducer(self, producer):

   229

        DebugViewer.SetDataProducer(self, producer)

   230

   231

        if self.DataProducer is not None:

   232

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

   233

   234

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

   235

        if self.HasNewData or self.Force:

   236

            self.HasNewData = False

   237

            self.RefreshView()

   238

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

   239

   240

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

   241

        if tick is not None:

   242

            if len(self.Ticks) == 0:

   243

                self.StartTick = tick 

   244

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

   245

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

   246

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

   247

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

   248

                self.Force = True

   249

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

   250

   251

    def ForceRefresh(self):

   252

        self.Force = True

   253

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

   254

   255

    def RefreshGraphicsSizer(self):

   256

        self.GraphicsSizer.Clear()

   257

   258

        for panel in self.GraphicPanels:

   259

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

   260

   261

        self.GraphicsSizer.Layout()

   262

        self.RefreshGraphicsWindowScrollbars()

   263

   264

    def SetCanvasPosition(self, tick):

   265

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

   266

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

   267

        self.Fixed = True

   268

        self.RefreshCanvasPosition()

   269

        self.ForceRefresh()

   270

   271

    def SetCursorTick(self, cursor_tick):

   272

        self.CursorTick = cursor_tick

   273

        self.Fixed = cursor_tick is not None

   274

        self.UpdateCursorTick() 

   275

   276

    def MoveCursorTick(self, move):

   277

        if self.CursorTick is not None:

   278

            cursor_tick = max(self.Ticks[0], 

   279

                          min(self.CursorTick + move, 

   280

                              self.Ticks[-1]))

   281

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

   282

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

   283

                cursor_tick_idx = max(0, 

   284

                                  min(cursor_tick_idx + abs(move) / move, 

   285

                                      len(self.Ticks) - 1))

   286

            self.CursorTick = self.Ticks[cursor_tick_idx]

   287

            self.StartTick = max(self.Ticks[

   288

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

   289

                                        self.CursorTick + self.CurrentRange))],

   290

                             min(self.StartTick, self.CursorTick))

   291

            self.RefreshCanvasPosition()

   292

            self.UpdateCursorTick() 

   293

   294

    def ResetCursorTick(self):

   295

        self.CursorTick = None

   296

        self.UpdateCursorTick()

   297

   298

    def UpdateCursorTick(self):

   299

        for panel in self.GraphicPanels:

   300

            if isinstance(panel, DebugVariableGraphicViewer):

   301

                panel.SetCursorTick(self.CursorTick)

   302

        self.ForceRefresh()

   303

   304

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

   305

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

   306

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

   307

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   308

            width, height = panel.GetSize()

   309

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

   310

            self.DraggingAxesPanel.ResetGraphics()

   311

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

   312

        else:

   313

            self.DraggingAxesPanel = panel

   314

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

   315

        self.DraggingAxesMousePos = wx.Point(

   316

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   317

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   318

        self.MoveDragNDrop(x_mouse, y_mouse)

   319

   320

    def MoveDragNDrop(self, x_mouse, y_mouse):

   321

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

   322

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

   323

        self.RefreshHighlight(x_mouse, y_mouse)

   324

   325

    def RefreshHighlight(self, x_mouse, y_mouse):

   326

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

   327

            x, y = panel.GetPosition()

   328

            width, height = panel.GetSize()

   329

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

   330

            if (rect.InsideXY(x_mouse, y_mouse) or 

   331

                idx == 0 and y_mouse < 0 or

   332

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

   333

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

   334

            else:

   335

                panel.SetHighlight(HIGHLIGHT_NONE)

   336

        if wx.Platform == "__WXMSW__":

   337

            self.RefreshView()

   338

        else:

   339

            self.ForceRefresh()

   340

   341

    def ResetHighlight(self):

   342

        for panel in self.GraphicPanels:

   343

            panel.SetHighlight(HIGHLIGHT_NONE)

   344

        if wx.Platform == "__WXMSW__":

   345

            self.RefreshView()

   346

        else:

   347

            self.ForceRefresh()

   348

   349

    def IsDragging(self):

   350

        return self.DraggingAxesPanel is not None

   351

   352

    def GetDraggingAxesClippingRegion(self, panel):

   353

        x, y = panel.GetPosition()

   354

        width, height = panel.GetSize()

   355

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

   356

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   357

        bbox.x -= x

   358

        bbox.y -= y

   359

        return bbox

   360

   361

    def GetDraggingAxesPosition(self, panel):

   362

        x, y = panel.GetPosition()

   363

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

   364

                        self.DraggingAxesBoundingBox.y - y)

   365

   366

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

   367

        if self.DraggingAxesPanel not in self.GraphicPanels:

   368

            self.DraggingAxesPanel.Destroy()

   369

        self.DraggingAxesPanel = None

   370

        self.DraggingAxesBoundingBox = None

   371

        self.DraggingAxesMousePos = None

   372

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

   373

            panel.SetHighlight(HIGHLIGHT_NONE)

   374

            xw, yw = panel.GetPosition()

   375

            width, height = panel.GetSize()

   376

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

   377

            if bbox.InsideXY(x_mouse, y_mouse):

   378

                panel.ShowButtons(True)

   379

                merge_type = GRAPH_PARALLEL

   380

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

   381

                    if y_mouse > yw + height / 2:

   382

                        idx += 1

   384

                else:

   385

                    rect = panel.GetAxesBoundingBox(True)

   386

                    if rect.InsideXY(x_mouse, y_mouse):

   387

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

   388

                        if merge_rect.InsideXY(x_mouse, y_mouse):

   389

                            merge_type = GRAPH_ORTHOGONAL

   390

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

   391

                    else:

   392

                        if y_mouse > yw + height / 2:

   393

                            idx += 1

   395

                self.ForceRefresh()

   396

                return 

   397

        width, height = self.GraphicsWindow.GetVirtualSize()

   398

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

   399

        if rect.InsideXY(x_mouse, y_mouse):

   401

        self.ForceRefresh()

   402

   403

    def RefreshView(self):

   404

        self.RefreshCanvasPosition()

   405

   406

        width, height = self.GraphicsWindow.GetVirtualSize()

   407

        bitmap = wx.EmptyBitmap(width, height)

   408

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

   409

        dc.Clear()

   410

        dc.BeginDrawing()

   411

        if self.DraggingAxesPanel is not None:

   412

            destBBox = self.DraggingAxesBoundingBox

   413

            srcBBox = self.DraggingAxesPanel.GetAxesBoundingBox()

   414

   415

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

   416

            srcDC = wx.MemoryDC()

   417

            srcDC.SelectObject(srcBmp)

   418

   419

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

   420

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

   421

                    srcDC, srcBBox.x, srcBBox.y)

   422

        dc.EndDrawing()

   423

   424

        if not self.Fixed or self.Force:

   425

            self.Force = False

   426

            refresh_graphics = True

   427

        else:

   428

            refresh_graphics = False

   429

   430

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

   431

            self.DraggingAxesPanel.RefreshViewer(refresh_graphics)

   432

        for panel in self.GraphicPanels:

   433

            if isinstance(panel, DebugVariableGraphicViewer):

   434

                panel.RefreshViewer(refresh_graphics)

   435

            else:

   436

                panel.RefreshViewer()

   437

   438

        if self.CursorTick is not None:

   439

            tick = self.CursorTick

   440

        elif len(self.Ticks) > 0:

   441

            tick = self.Ticks[-1]

   442

        else:

   443

            tick = None

   444

        if tick is not None:

   445

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

   446

            tick_duration = int(tick * self.Ticktime)

   447

            not_null = False

   448

            duration = ""

   449

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

   450

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

   451

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

   452

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

   453

   454

                if value > 0 or not_null:

   455

                    duration += format % value

   456

                    not_null = True

   457

   458

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

   459

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

   460

        else:

   461

            self.TickLabel.SetLabel("")

   462

            self.TickTimeLabel.SetLabel("")

   463

        self.TickSizer.Layout()

   464

   465

    def SubscribeAllDataConsumers(self):

   466

        DebugViewer.SubscribeAllDataConsumers(self)

   467

   468

        if self.DataProducer is not None:

   469

            if self.DataProducer is not None:

   470

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

   471

   472

        for panel in self.GraphicPanels:

   473

            panel.SubscribeAllDataConsumers()

   474

            if panel.ItemsIsEmpty():

   475

                if panel.HasCapture():

   476

                    panel.ReleaseMouse()

   477

                self.GraphicPanels.remove(panel)

   478

                panel.Destroy()

   479

   480

        self.ResetVariableNameMask()

   481

        self.RefreshGraphicsSizer()

   482

        self.ForceRefresh()

   483

   484

    def ResetView(self):

   485

        self.UnsubscribeAllDataConsumers()

   486

   487

        self.Fixed = False

   488

        for panel in self.GraphicPanels:

   489

            panel.Destroy()

   490

        self.GraphicPanels = []

   491

        self.ResetVariableNameMask()