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.ParentControl.OnMouseDragging(x, y)

    55

        self.ParentWindow.RefreshHighlight(x, y)

    56

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

    57

    58

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

    59

        message = None

    60

        try:

    61

            values = eval(data)

    62

            if not isinstance(values, TupleType):

    64

        except:

    65

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

    66

            values = None

    67

    68

        if message is not None:

    69

            wx.CallAfter(self.ShowMessage, message)

    70

    71

        elif values[1] == "debug":

    72

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

    73

                self.ParentWindow.MoveValue(values[0])

    74

            else:

    75

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

    76

    77

    def OnLeave(self):

    78

        self.ParentWindow.ResetHighlight()

    79

        return wx.TextDropTarget.OnLeave(self)

    80

    81

    def ShowMessage(self, message):

    82

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

    83

        dialog.ShowModal()

    84

        dialog.Destroy()

    85

    86

MILLISECOND = 1000000

    87

SECOND = 1000 * MILLISECOND

    88

MINUTE = 60 * SECOND

    89

HOUR = 60 * MINUTE

    90

DAY = 24 * HOUR

    91

    92

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

    93

RANGE_VALUES = \

    94

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

    95

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

    96

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

    97

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

    98

    99

SCROLLBAR_UNIT = 10

   100

   101

def compute_mask(x, y):

   102

    mask = []

   103

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

   104

        if xp == yp:

   105

            mask.append(xp)

   106

        else:

   107

            mask.append("*")

   108

    return mask

   109

   110

def NextTick(variables):

   111

    next_tick = None

   112

    for item, data in variables:

   113

        if len(data) > 0:

   114

            if next_tick is None:

   115

                next_tick = data[0][0]

   116

            else:

   117

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

   118

    return next_tick

   119

   120

class DebugVariableGraphicPanel(wx.Panel, DebugViewer):

   121

   122

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

   123

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

   124

   125

        self.ParentWindow = window

   126

   127

        self.HasNewData = False

   128

        self.Force = False

   129

   130

        self.SetBackgroundColour(wx.WHITE)

   131

   132

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   133

   134

        self.Ticks = numpy.array([])

   135

        self.StartTick = 0

   136

        self.Fixed = False

   137

        self.CursorTick = None

   138

        self.DraggingAxesPanel = None

   139

        self.DraggingAxesBoundingBox = None

   140

        self.DraggingAxesMousePos = None

   141

        self.VetoScrollEvent = False

   142

        self.VariableNameMask = []

   143

   144

        self.GraphicPanels = []

   145

   146

        graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   147

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

   148

   149

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

   150

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

   151

   152

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

   153

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

   154

        graphics_button_sizer.AddWindow(self.CanvasRange, 1, 

   155

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

   156

   157

        self.CanvasRange.Clear()

   158

        default_range_idx = 0

   159

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

   160

            self.CanvasRange.Append(text)

   161

            if text == "1s":

   162

                default_range_idx = idx

   163

        self.CanvasRange.SetSelection(default_range_idx)

   164

   165

        for name, bitmap, help in [

   166

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

   167

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

   168

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

   169

                  bitmap=GetBitmap(bitmap), 

   170

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

   171

            button.SetToolTipString(help)

   172

            setattr(self, name, button)

   173

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

   174

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

   175

   176

        self.CanvasPosition = wx.ScrollBar(self, 

   177

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

   178

        self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK, 

   179

              self.OnPositionChanging, self.CanvasPosition)

   180

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP, 

   181

              self.OnPositionChanging, self.CanvasPosition)

   182

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN, 

   183

              self.OnPositionChanging, self.CanvasPosition)

   184

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP, 

   185

              self.OnPositionChanging, self.CanvasPosition)

   186

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN, 

   187

              self.OnPositionChanging, self.CanvasPosition)

   188

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

   189

   190

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

   191

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

   192

   193

        self.TickLabel = wx.StaticText(self)

   194

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

   195

   196

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

   197

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

   198

   199

        self.TickTimeLabel = wx.StaticText(self)

   200

        self.TickSizer.AddWindow(self.TickTimeLabel)

   201

   202

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

   203

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   204

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   205

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

   206

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

   207

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

   208

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

   209

   210

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

   211

   212

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

   213

        self.GraphicsWindow.SetSizer(self.GraphicsSizer)

   214

   215

        DebugViewer.__init__(self, producer, True)

   216

   217

        self.SetSizer(main_sizer)

   218

   219

    def SetTickTime(self, ticktime=0):

   220

        self.Ticktime = ticktime

   221

        if self.Ticktime == 0:

   222

            self.Ticktime = MILLISECOND

   223

        self.CurrentRange = RANGE_VALUES[

   224

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

   225

   226

    def SetDataProducer(self, producer):

   227

        DebugViewer.SetDataProducer(self, producer)

   228

   229

        if self.DataProducer is not None:

   230

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

   231

   232

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

   233

        if self.HasNewData or self.Force:

   234

            self.HasNewData = False

   235

            self.RefreshView()

   236

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

   237

   238

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

   239

        if tick is not None:

   240

            if len(self.Ticks) == 0:

   241

                self.StartTick = tick 

   242

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

   243

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

   244

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

   245

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

   246

                self.Force = True

   247

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

   248

   249

    def ForceRefresh(self):

   250

        self.Force = True

   251

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

   252

   253

    def RefreshGraphicsSizer(self):

   254

        self.GraphicsSizer.Clear()

   255

   256

        for panel in self.GraphicPanels:

   257

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

   258

   259

        self.GraphicsSizer.Layout()

   260

        self.RefreshGraphicsWindowScrollbars()

   261

   262

    def SetCanvasPosition(self, tick):

   263

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

   264

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

   265

        self.Fixed = True

   266

        self.RefreshCanvasPosition()

   267

        self.ForceRefresh()

   268

   269

    def SetCursorTick(self, cursor_tick):

   270

        self.CursorTick = cursor_tick

   271

        self.Fixed = True

   272

        self.UpdateCursorTick() 

   273

   274

    def MoveCursorTick(self, move):

   275

        if self.CursorTick is not None:

   276

            cursor_tick = max(self.Ticks[0], 

   277

                          min(self.CursorTick + move, 

   278

                              self.Ticks[-1]))

   279

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

   280

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

   281

                cursor_tick_idx = max(0, 

   282

                                  min(cursor_tick_idx + abs(move) / move, 

   283

                                      len(self.Ticks) - 1))

   284

            self.CursorTick = self.Ticks[cursor_tick_idx]

   285

            self.StartTick = max(self.Ticks[

   286

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

   287

                                        self.CursorTick + self.CurrentRange))],

   288

                             min(self.StartTick, self.CursorTick))

   289

            self.RefreshCanvasPosition()

   290

            self.UpdateCursorTick() 

   291

   292

    def ResetCursorTick(self):

   293

        self.CursorTick = None

   294

        self.UpdateCursorTick()

   295

   296

    def UpdateCursorTick(self):

   297

        for panel in self.GraphicPanels:

   298

            if isinstance(panel, DebugVariableGraphicViewer):

   299

                panel.SetCursorTick(self.CursorTick)

   300

        self.ForceRefresh()

   301

   302

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

   303

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

   304

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

   305

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   306

            width, height = panel.GetSize()

   307

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

   308

            self.DraggingAxesPanel.ResetGraphics()

   309

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

   310

        else:

   311

            self.DraggingAxesPanel = panel

   312

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

   313

        self.DraggingAxesMousePos = wx.Point(

   314

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   315

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   316

        self.MoveDragNDrop(x_mouse, y_mouse)

   317

   318

    def MoveDragNDrop(self, x_mouse, y_mouse):

   319

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

   320

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

   321

        self.RefreshHighlight(x_mouse, y_mouse)

   322

   323

    def RefreshHighlight(self, x_mouse, y_mouse):

   324

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

   325

            x, y = panel.GetPosition()

   326

            width, height = panel.GetSize()

   327

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

   328

            if (rect.InsideXY(x_mouse, y_mouse) or 

   329

                idx == 0 and y_mouse < 0 or

   330

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

   331

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

   332

            else:

   333

                panel.SetHighlight(HIGHLIGHT_NONE)

   334

        if wx.Platform == "__WXMSW__":

   335

            self.RefreshView()

   336

        else:

   337

            self.ForceRefresh()

   338

   339

    def ResetHighlight(self):

   340

        for panel in self.GraphicPanels:

   341

            panel.SetHighlight(HIGHLIGHT_NONE)

   342

        if wx.Platform == "__WXMSW__":

   343

            self.RefreshView()

   344

        else:

   345

            self.ForceRefresh()

   346

   347

    def IsDragging(self):

   348

        return self.DraggingAxesPanel is not None

   349

   350

    def GetDraggingAxesClippingRegion(self, panel):

   351

        x, y = panel.GetPosition()

   352

        width, height = panel.GetSize()

   353

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

   354

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   355

        bbox.x -= x

   356

        bbox.y -= y

   357

        return bbox

   358

   359

    def GetDraggingAxesPosition(self, panel):

   360

        x, y = panel.GetPosition()

   361

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

   362

                        self.DraggingAxesBoundingBox.y - y)

   363

   364

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

   365

        if self.DraggingAxesPanel not in self.GraphicPanels:

   366

            self.DraggingAxesPanel.Destroy()

   367

        self.DraggingAxesPanel = None

   368

        self.DraggingAxesBoundingBox = None

   369

        self.DraggingAxesMousePos = None

   370

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

   371

            panel.SetHighlight(HIGHLIGHT_NONE)

   372

            xw, yw = panel.GetPosition()

   373

            width, height = panel.GetSize()

   374

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

   375

            if bbox.InsideXY(x_mouse, y_mouse):

   376

                panel.ShowButtons(True)

   377

                merge_type = GRAPH_PARALLEL

   378

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

   379

                    if y_mouse > yw + height / 2:

   380

                        idx += 1

   381

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

   382

                else:

   383

                    rect = panel.GetAxesBoundingBox(True)

   384

                    if rect.InsideXY(x_mouse, y_mouse):

   385

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

   386

                        if merge_rect.InsideXY(x_mouse, y_mouse):

   387

                            merge_type = GRAPH_ORTHOGONAL

   388

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

   389

                    else:

   390

                        if y_mouse > yw + height / 2:

   391

                            idx += 1

   392

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

   393

                self.ForceRefresh()

   394

                return 

   395

        width, height = self.GraphicsWindow.GetVirtualSize()

   396

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

   397

        if rect.InsideXY(x_mouse, y_mouse):

   398

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

   399

        self.ForceRefresh()

   400

   401

    def RefreshView(self):

   402

        self.RefreshCanvasPosition()

   403

   404

        width, height = self.GraphicsWindow.GetVirtualSize()

   405

        bitmap = wx.EmptyBitmap(width, height)

   406

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

   407

        dc.Clear()

   408

        dc.BeginDrawing()

   409

        if self.DraggingAxesPanel is not None:

   410

            destBBox = self.DraggingAxesBoundingBox

   411

            srcBBox = self.DraggingAxesPanel.GetAxesBoundingBox()

   412

   413

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

   414

            srcDC = wx.MemoryDC()

   415

            srcDC.SelectObject(srcBmp)

   416

   417

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

   418

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

   419

                    srcDC, srcBBox.x, srcBBox.y)

   420

        dc.EndDrawing()

   421

   422

        if not self.Fixed or self.Force:

   423

            self.Force = False

   424

            refresh_graphics = True

   425

        else:

   426

            refresh_graphics = False

   427

   428

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

   429

            self.DraggingAxesPanel.RefreshViewer(refresh_graphics)

   430

        for panel in self.GraphicPanels:

   431

            if isinstance(panel, DebugVariableGraphicViewer):

   432

                panel.RefreshViewer(refresh_graphics)

   433

            else:

   434

                panel.RefreshViewer()

   435

   436

        if self.CursorTick is not None:

   437

            tick = self.CursorTick

   438

        elif len(self.Ticks) > 0:

   439

            tick = self.Ticks[-1]

   440

        else:

   441

            tick = None

   442

        if tick is not None:

   443

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

   444

            tick_duration = int(tick * self.Ticktime)

   445

            not_null = False

   446

            duration = ""

   447

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

   448

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

   449

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

   450

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

   451

   452

                if value > 0 or not_null:

   453

                    duration += format % value

   454

                    not_null = True

   455

   456

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

   457

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

   458

        else:

   459

            self.TickLabel.SetLabel("")

   460

            self.TickTimeLabel.SetLabel("")

   461

        self.TickSizer.Layout()

   462

   465

   466

        if self.DataProducer is not None:

   467

            if self.DataProducer is not None:

   468

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

   469

   470

        for panel in self.GraphicPanels:

   472

            if panel.ItemsIsEmpty():

   473

                if panel.HasCapture():

   474

                    panel.ReleaseMouse()

   475

                self.GraphicPanels.remove(panel)

   476

                panel.Destroy()

   477

   478

        self.ResetVariableNameMask()

   479

        self.RefreshGraphicsSizer()

   480

        self.ForceRefresh()

   481

   482

    def ResetView(self):

   483

        self.UnsubscribeAllDataConsumers()

   484

   485

        self.Fixed = False

   486

        for panel in self.GraphicPanels:

   487

            panel.Destroy()

   488

        self.GraphicPanels = []

   489

        self.ResetVariableNameMask()

   490

        self.RefreshGraphicsSizer()

   491