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, ListType, FloatType

    26

from time import time as gettime

    27

import math

    28

import numpy

    29

    30

import wx

    31

import wx.lib.buttons

    32

    33

try:

    34

    import matplotlib

    35

    matplotlib.use('WX')

    36

    import matplotlib.pyplot

    37

    from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    38

    from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    39

    from matplotlib.backends.backend_agg import FigureCanvasAgg

    40

    from mpl_toolkits.mplot3d import Axes3D

    41

    color_cycle = ['r', 'b', 'g', 'm', 'y', 'k']

    42

    cursor_color = '#800080'

    43

    USE_MPL = True

    44

except:

    45

    USE_MPL = False

    46

    47

from graphics.DebugDataConsumer import DebugDataConsumer

    48

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    49

from controls import CustomGrid, CustomTable

    50

from controls.DebugVariablePanel.DebugVariableItem import DebugVariableItem

    51

from dialogs.ForceVariableDialog import ForceVariableDialog

    52

from util.BitmapLibrary import GetBitmap

    53

    54

def AppendMenu(parent, help, id, kind, text):

    55

    parent.Append(help=help, id=id, kind=kind, text=text)

    56

    57

def GetDebugVariablesTableColnames():

    58

    _ = lambda x : x

    59

    return [_("Variable"), _("Value")]

    60

    61

class DebugVariableTable(CustomTable):

    62

    63

    def GetValue(self, row, col):

    64

        if row < self.GetNumberRows():

    65

            return self.GetValueByName(row, self.GetColLabelValue(col, False))

    66

        return ""

    67

    68

    def SetValue(self, row, col, value):

    69

        if col < len(self.colnames):

    70

            self.SetValueByName(row, self.GetColLabelValue(col, False), value)

    71

    72

    def GetValueByName(self, row, colname):

    73

        if row < self.GetNumberRows():

    74

            if colname == "Variable":

    75

                return self.data[row].GetVariable()

    76

            elif colname == "Value":

    77

                return self.data[row].GetValue()

    78

        return ""

    79

    80

    def SetValueByName(self, row, colname, value):

    81

        if row < self.GetNumberRows():

    82

            if colname == "Variable":

    83

                self.data[row].SetVariable(value)

    84

            elif colname == "Value":

    85

                self.data[row].SetValue(value)

    86

    87

    def IsForced(self, row):

    88

        if row < self.GetNumberRows():

    89

            return self.data[row].IsForced()

    90

        return False

    91

    92

    def IsNumVariable(self, row):

    93

        if row < self.GetNumberRows():

    94

            return self.data[row].IsNumVariable()

    95

        return False

    96

    97

    def _updateColAttrs(self, grid):

    98

        """

    99

        wx.grid.Grid -> update the column attributes to add the

   100

        appropriate renderer given the column name.

   101

   102

        Otherwise default to the default renderer.

   103

        """

   104

   105

        for row in range(self.GetNumberRows()):

   106

            for col in range(self.GetNumberCols()):

   107

                colname = self.GetColLabelValue(col, False)

   108

                if colname == "Value":

   109

                    if self.IsForced(row):

   110

                        grid.SetCellTextColour(row, col, wx.BLUE)

   111

                    else:

   112

                        grid.SetCellTextColour(row, col, wx.BLACK)

   113

                grid.SetReadOnly(row, col, True)

   114

            self.ResizeRow(grid, row)

   115

   116

    def AppendItem(self, data):

   117

        self.data.append(data)

   118

   119

    def InsertItem(self, idx, data):

   120

        self.data.insert(idx, data)

   121

   122

    def RemoveItem(self, idx):

   123

        self.data.pop(idx)

   124

   125

    def MoveItem(self, idx, new_idx):

   126

        self.data.insert(new_idx, self.data.pop(idx))

   127

   128

    def GetItem(self, idx):

   129

        return self.data[idx]

   130

   131

class DebugVariableDropTarget(wx.TextDropTarget):

   132

   133

    def __init__(self, parent, control=None):

   134

        wx.TextDropTarget.__init__(self)

   135

        self.ParentWindow = parent

   136

        self.ParentControl = control

   137

   138

    def __del__(self):

   139

        self.ParentWindow = None

   140

        self.ParentControl = None

   141

   142

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

   143

        if not isinstance(self.ParentControl, CustomGrid):

   144

            if self.ParentControl is not None:

   145

                self.ParentControl.OnMouseDragging(x, y)

   146

            else:

   147

                self.ParentWindow.RefreshHighlight(x, y)

   148

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

   149

   150

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

   151

        message = None

   152

        try:

   153

            values = eval(data)

   154

        except:

   155

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

   156

            values = None

   157

        if not isinstance(values, TupleType):

   158

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

   159

            values = None

   160

   161

        if message is not None:

   162

            wx.CallAfter(self.ShowMessage, message)

   163

        elif values is not None and values[1] == "debug":

   164

            if isinstance(self.ParentControl, CustomGrid):

   165

                x, y = self.ParentControl.CalcUnscrolledPosition(x, y)

   166

                row = self.ParentControl.YToRow(y - self.ParentControl.GetColLabelSize())

   167

                if row == wx.NOT_FOUND:

   168

                    row = self.ParentWindow.Table.GetNumberRows()

   169

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

   170

            elif self.ParentControl is not None:

   171

                width, height = self.ParentControl.GetSize()

   172

                target_idx = self.ParentControl.GetIndex()

   173

                merge_type = GRAPH_PARALLEL

   174

                if isinstance(self.ParentControl, DebugVariableGraphic):

   175

                    if self.ParentControl.Is3DCanvas():

   176

                        if y > height / 2:

   177

                            target_idx += 1

   178

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

   179

                            self.ParentWindow.MoveValue(values[0], target_idx)

   180

                        else:

   181

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

   182

   183

                    else:

   184

                        rect = self.ParentControl.GetAxesBoundingBox()

   185

                        if rect.InsideXY(x, y):

   186

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

   187

                            if merge_rect.InsideXY(x, y):

   188

                                merge_type = GRAPH_ORTHOGONAL

   189

                            wx.CallAfter(self.ParentWindow.MergeGraphs, values[0], target_idx, merge_type, force=True)

   190

                        else:

   191

                            if y > height / 2:

   192

                                target_idx += 1

   193

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

   194

                                self.ParentWindow.MoveValue(values[0], target_idx)

   195

                            else:

   196

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

   197

                else:

   198

                    if y > height / 2:

   199

                        target_idx += 1

   200

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

   201

                        self.ParentWindow.MoveValue(values[0], target_idx)

   202

                    else:

   203

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

   204

   205

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

   206

                self.ParentWindow.MoveValue(values[0])

   207

            else:

   208

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

   209

   210

    def OnLeave(self):

   211

        if not isinstance(self.ParentControl, CustomGrid):

   212

            self.ParentWindow.ResetHighlight()

   213

        return wx.TextDropTarget.OnLeave(self)

   214

   215

    def ShowMessage(self, message):

   216

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

   217

        dialog.ShowModal()

   218

        dialog.Destroy()

   219

   220

if USE_MPL:

   221

    MILLISECOND = 1000000

   222

    SECOND = 1000 * MILLISECOND

   223

    MINUTE = 60 * SECOND

   224

    HOUR = 60 * MINUTE

   225

    DAY = 24 * HOUR

   226

   227

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

   228

    RANGE_VALUES = \

   229

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

   230

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

   231

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

   232

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

   233

   234

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   235

   236

    SCROLLBAR_UNIT = 10

   237

   238

    #CANVAS_HIGHLIGHT_TYPES

   239

    [HIGHLIGHT_NONE,

   240

     HIGHLIGHT_BEFORE,

   241

     HIGHLIGHT_AFTER,

   242

     HIGHLIGHT_LEFT,

   243

     HIGHLIGHT_RIGHT,

   244

     HIGHLIGHT_RESIZE] = range(6)

   245

   246

    HIGHLIGHT_DROP_PEN = wx.Pen(wx.Colour(0, 128, 255))

   247

    HIGHLIGHT_DROP_BRUSH = wx.Brush(wx.Colour(0, 128, 255, 128))

   248

    HIGHLIGHT_RESIZE_PEN = wx.Pen(wx.Colour(200, 200, 200))

   249

    HIGHLIGHT_RESIZE_BRUSH = wx.Brush(wx.Colour(200, 200, 200))

   250

   251

    #CANVAS_SIZE_TYPES

   252

    [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI] = [0, 100, 200]

   253

   254

    DEFAULT_CANVAS_HEIGHT = 200.

   255

    CANVAS_BORDER = (20., 10.)

   256

    CANVAS_PADDING = 8.5

   257

    VALUE_LABEL_HEIGHT = 17.

   258

    AXES_LABEL_HEIGHT = 12.75

   259

   260

    def compute_mask(x, y):

   261

        mask = []

   262

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

   263

            if xp == yp:

   264

                mask.append(xp)

   265

            else:

   266

                mask.append("*")

   267

        return mask

   268

   269

    def NextTick(variables):

   270

        next_tick = None

   271

        for item, data in variables:

   272

            if len(data) > 0:

   273

                if next_tick is None:

   274

                    next_tick = data[0][0]

   275

                else:

   276

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

   277

        return next_tick

   278

   279

    def OrthogonalData(item, start_tick, end_tick):

   280

        data = item.GetData(start_tick, end_tick)

   281

        min_value, max_value = item.GetValueRange()

   282

        if min_value is not None and max_value is not None:

   283

            center = (min_value + max_value) / 2.

   284

            range = max(1.0, max_value - min_value)

   285

        else:

   286

            center = 0.5

   287

            range = 1.0

   288

        return data, center - range * 0.55, center + range * 0.55

   289

   290

    class GraphButton():

   291

   292

        def __init__(self, x, y, bitmap, callback):

   293

            self.Position = wx.Point(x, y)

   294

            self.Bitmap = bitmap

   295

            self.Shown = True

   296

            self.Enabled = True

   297

            self.Callback = callback

   298

   299

        def __del__(self):

   300

            self.callback = None

   301

   302

        def GetSize(self):

   303

            return self.Bitmap.GetSize()

   304

   305

        def SetPosition(self, x, y):

   306

            self.Position = wx.Point(x, y)

   307

   308

        def Show(self):

   309

            self.Shown = True

   310

   311

        def Hide(self):

   312

            self.Shown = False

   313

   314

        def IsShown(self):

   315

            return self.Shown

   316

   317

        def Enable(self):

   318

            self.Enabled = True

   319

   320

        def Disable(self):

   321

            self.Enabled = False

   322

   323

        def IsEnabled(self):

   324

            return self.Enabled

   325

   326

        def HitTest(self, x, y):

   327

            if self.Shown and self.Enabled:

   328

                w, h = self.Bitmap.GetSize()

   329

                rect = wx.Rect(self.Position.x, self.Position.y, w, h)

   330

                if rect.InsideXY(x, y):

   331

                    return True

   332

            return False

   333

   334

        def ProcessCallback(self):

   335

            if self.Callback is not None:

   336

                wx.CallAfter(self.Callback)

   337

   338

        def Draw(self, dc):

   339

            if self.Shown and self.Enabled:

   340

                dc.DrawBitmap(self.Bitmap, self.Position.x, self.Position.y, True)

   341

   342

    class DebugVariableViewer:

   343

   344

        def __init__(self, window, items=[]):

   345

            self.ParentWindow = window

   346

            self.Items = items

   347

   348

            self.Highlight = HIGHLIGHT_NONE

   349

            self.Buttons = []

   350

   351

        def __del__(self):

   352

            self.ParentWindow = None

   353

   354

        def GetIndex(self):

   355

            return self.ParentWindow.GetViewerIndex(self)

   356

   357

        def GetItem(self, variable):

   358

            for item in self.Items:

   359

                if item.GetVariable() == variable:

   360

                    return item

   361

            return None

   362

   363

        def GetItems(self):

   364

            return self.Items

   365

   366

        def GetVariables(self):

   367

            if len(self.Items) > 1:

   368

                variables = [item.GetVariable() for item in self.Items]

   369

                if self.GraphType == GRAPH_ORTHOGONAL:

   370

                    return tuple(variables)

   371

                return variables

   372

            return self.Items[0].GetVariable()

   373

   374

        def AddItem(self, item):

   375

            self.Items.append(item)

   376

   377

        def RemoveItem(self, item):

   378

            if item in self.Items:

   379

                self.Items.remove(item)

   380

   381

        def Clear(self):

   382

            for item in self.Items:

   383

                self.ParentWindow.RemoveDataConsumer(item)

   384

            self.Items = []

   385

   386

        def IsEmpty(self):

   387

            return len(self.Items) == 0

   388

   389

        def UnregisterObsoleteData(self):

   390

            for item in self.Items[:]:

   391

                iec_path = item.GetVariable()

   392

                if self.ParentWindow.GetDataType(iec_path) is None:

   393

                    self.ParentWindow.RemoveDataConsumer(item)

   394

                    self.RemoveItem(item)

   395

                else:

   396

                    self.ParentWindow.AddDataConsumer(iec_path.upper(), item)

   397

                    item.RefreshVariableType()

   398

   399

        def ResetData(self):

   400

            for item in self.Items:

   401

                item.ResetData()

   402

   403

        def RefreshViewer(self):

   404

            pass

   405

   406

        def SetHighlight(self, highlight):

   407

            if self.Highlight != highlight:

   408

                self.Highlight = highlight

   409

                return True

   410

            return False

   411

   412

        def GetButtons(self):

   413

            return self.Buttons

   414

   415

        def HandleButtons(self, x, y):

   416

            for button in self.GetButtons():

   417

                if button.HitTest(x, y):

   418

                    button.ProcessCallback()

   419

                    return True

   420

            return False

   421

   422

        def IsOverButton(self, x, y):

   423

            for button in self.GetButtons():

   424

                if button.HitTest(x, y):

   425

                    return True

   426

            return False

   427

   428

        def ShowButtons(self, show):

   429

            for button in self.Buttons:

   430

                if show:

   431

                    button.Show()

   432

                else:

   433

                    button.Hide()

   434

            self.RefreshButtonsState()

   435

            self.ParentWindow.ForceRefresh()

   436

   437

        def RefreshButtonsState(self, refresh_positions=False):

   438

            if self:

   439

                width, height = self.GetSize()

   440

                if refresh_positions:

   441

                    offset = 0

   442

                    buttons = self.Buttons[:]

   443

                    buttons.reverse()

   444

                    for button in buttons:

   445

                        w, h = button.GetSize()

   446

                        button.SetPosition(width - 5 - w - offset, 5)

   447

                        offset += w + 2

   448

                    self.ParentWindow.ForceRefresh()

   449

   450

        def DrawCommonElements(self, dc, buttons=None):

   451

            width, height = self.GetSize()

   452

   453

            dc.SetPen(HIGHLIGHT_DROP_PEN)

   454

            dc.SetBrush(HIGHLIGHT_DROP_BRUSH)

   455

            if self.Highlight in [HIGHLIGHT_BEFORE]:

   456

                dc.DrawLine(0, 1, width - 1, 1)

   457

            elif self.Highlight in [HIGHLIGHT_AFTER]:

   458

                dc.DrawLine(0, height - 1, width - 1, height - 1)

   459

   460

            if buttons is None:

   461

                buttons = self.Buttons

   462

            for button in buttons:

   463

                button.Draw(dc)

   464

   465

            if self.ParentWindow.IsDragging():

   466

                destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   467

                srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

   468

                if destBBox.width > 0 and destBBox.height > 0:

   469

                    srcPanel = self.ParentWindow.DraggingAxesPanel

   470

                    srcBBox = srcPanel.GetAxesBoundingBox()

   471

   472

                    if destBBox.x == 0:

   473

                        srcX = srcBBox.x - srcPos.x

   474

                    else:

   475

                        srcX = srcBBox.x

   476

                    if destBBox.y == 0:

   477

                        srcY = srcBBox.y - srcPos.y

   478

                    else:

   479

                        srcY = srcBBox.y

   480

   481

                    srcBmp = _convert_agg_to_wx_bitmap(srcPanel.get_renderer(), None)

   482

                    srcDC = wx.MemoryDC()

   483

                    srcDC.SelectObject(srcBmp)

   484

   485

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

   486

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

   487

                            srcDC, srcX, srcY)

   488

   489

        def OnEnter(self, event):

   490

            self.ShowButtons(True)

   491

            event.Skip()

   492

   493

        def OnLeave(self, event):

   494

            if self.Highlight != HIGHLIGHT_RESIZE or self.CanvasStartSize is None:

   495

                x, y = event.GetPosition()

   496

                width, height = self.GetSize()

   497

                if (x <= 0 or x >= width - 1 or

   498

                    y <= 0 or y >= height - 1):