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

import binascii

    30

    31

import wx

    32

import wx.lib.buttons

    33

    34

try:

    35

    import matplotlib

    36

    matplotlib.use('WX')

    37

    import matplotlib.pyplot

    38

    from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    39

    from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    40

    from matplotlib.backends.backend_agg import FigureCanvasAgg

    41

    from mpl_toolkits.mplot3d import Axes3D

    42

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

    43

    cursor_color = '#800080'

    44

    USE_MPL = True

    45

except:

    46

    USE_MPL = False

    47

    48

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    49

from controls import CustomGrid, CustomTable

    50

from dialogs.ForceVariableDialog import ForceVariableDialog

    51

from util.BitmapLibrary import GetBitmap

    52

    53

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

    54

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

    55

    56

def GetDebugVariablesTableColnames():

    57

    _ = lambda x : x

    58

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

    59

    60

CRC_SIZE = 8

    61

CRC_MASK = 2 ** CRC_SIZE - 1

    62

    63

class VariableTableItem(DebugDataConsumer):

    64

    65

    def __init__(self, parent, variable):

    66

        DebugDataConsumer.__init__(self)

    67

        self.Parent = parent

    68

        self.Variable = variable

    69

        self.RefreshVariableType()

    70

        self.Value = ""

    71

    72

    def __del__(self):

    73

        self.Parent = None

    74

    75

    def SetVariable(self, variable):

    76

        if self.Parent and self.Variable != variable:

    77

            self.Variable = variable

    78

            self.RefreshVariableType()

    79

            self.Parent.RefreshView()

    80

    81

    def GetVariable(self, mask=None):

    82

        variable = self.Variable

    83

        if mask is not None:

    84

            parts = variable.split('.')

    85

            mask = mask + ['*'] * max(0, len(parts) - len(mask))

    86

            last = None

    87

            variable = ""

    88

            for m, v in zip(mask, parts):

    89

                if m == '*':

    90

                    if last == '*':

    91

                        variable += '.'

    92

                    variable += v

    93

                elif last is None or last == '*':

    94

                    variable += '..'

    95

                last = m

    96

        return variable

    97

    98

    def RefreshVariableType(self):

    99

        self.VariableType = self.Parent.GetDataType(self.Variable)

   100

        if USE_MPL:

   101

            self.ResetData()

   102

   103

    def GetVariableType(self):

   104

        return self.VariableType

   105

   106

    def GetData(self, start_tick=None, end_tick=None):

   107

        if USE_MPL and self.IsNumVariable():

   108

            if len(self.Data) == 0:

   109

                return self.Data

   110

   111

            start_idx = end_idx = None

   112

            if start_tick is not None:

   113

                start_idx = self.GetNearestData(start_tick, -1)

   114

            if end_tick is not None:

   115

                end_idx = self.GetNearestData(end_tick, 1)

   116

            if start_idx is None:

   117

                start_idx = 0

   118

            if end_idx is not None:

   119

                return self.Data[start_idx:end_idx + 1]

   120

            else:

   121

                return self.Data[start_idx:]

   122

   123

        return None

   124

   125

    def GetRawValue(self, idx):

   126

        if self.VariableType in ["STRING", "WSTRING"] and idx < len(self.RawData):

   127

            return self.RawData[idx][0]

   128

        return ""

   129

   130

    def GetRange(self):

   131

        return self.MinValue, self.MaxValue

   132

   133

    def ResetData(self):

   134

        if self.IsNumVariable():

   135

            self.Data = numpy.array([]).reshape(0, 3)

   136

            if self.VariableType in ["STRING", "WSTRING"]:

   137

                self.RawData = []

   138

            self.MinValue = None

   139

            self.MaxValue = None

   140

        else:

   141

            self.Data = None

   142

   143

    def IsNumVariable(self):

   144

        return (self.Parent.IsNumType(self.VariableType) or 

   145

                self.VariableType in ["STRING", "WSTRING"])

   146

   147

    def NewValue(self, tick, value, forced=False):

   148

        if USE_MPL and self.IsNumVariable():

   149

            if self.VariableType in ["STRING", "WSTRING"]:

   150

                num_value = binascii.crc32(value) & CRC_MASK

   151

            else:

   152

                num_value = float(value)

   153

            if self.MinValue is None:

   154

                self.MinValue = num_value

   155

            else:

   156

                self.MinValue = min(self.MinValue, num_value)

   157

            if self.MaxValue is None:

   158

                self.MaxValue = num_value

   159

            else:

   160

                self.MaxValue = max(self.MaxValue, num_value)

   161

            forced_value = float(forced)

   162

            if self.VariableType in ["STRING", "WSTRING"]:

   163

                raw_data = (value, forced_value)

   164

                if len(self.RawData) == 0 or self.RawData[-1] != raw_data:

   165

                    extra_value = len(self.RawData)

   166

                    self.RawData.append(raw_data)

   167

                else:

   168

                    extra_value = len(self.RawData) - 1

   169

            else:

   170

                extra_value = forced_value

   171

            self.Data = numpy.append(self.Data, [[float(tick), num_value, extra_value]], axis=0)

   172

            self.Parent.HasNewData = True

   173

        DebugDataConsumer.NewValue(self, tick, value, forced)

   174

   175

    def SetForced(self, forced):

   176

        if self.Forced != forced:

   177

            self.Forced = forced

   178

            self.Parent.HasNewData = True

   179

   180

    def SetValue(self, value):

   181

        if (self.VariableType == "STRING" and value.startswith("'") and value.endswith("'") or

   182

            self.VariableType == "WSTRING" and value.startswith('"') and value.endswith('"')):

   183

            value = value[1:-1]

   184

        if self.Value != value:

   185

            self.Value = value

   186

            self.Parent.HasNewData = True

   187

   188

    def GetValue(self, tick=None, raw=False):

   189

        if tick is not None and self.IsNumVariable():

   190

            if len(self.Data) > 0:

   191

                idx = numpy.argmin(abs(self.Data[:, 0] - tick))

   192

                if self.VariableType in ["STRING", "WSTRING"]:

   193

                    value, forced = self.RawData[int(self.Data[idx, 2])]

   194

                    if not raw:

   195

                        if self.VariableType == "STRING":

   196

                            value = "'%s'" % value

   197

                        else:

   198

                            value = '"%s"' % value

   199

                    return value, forced

   200

                else:

   201

                    value = self.Data[idx, 1]

   202

                    if not raw and isinstance(value, FloatType):

   203

                        value = "%.6g" % value

   204

                    return value, self.Data[idx, 2]

   205

            return self.Value, self.IsForced()

   206

        elif not raw:

   207

            if self.VariableType == "STRING":

   208

                return "'%s'" % self.Value

   209

            elif self.VariableType == "WSTRING":

   210

                return '"%s"' % self.Value

   211

            elif isinstance(self.Value, FloatType):

   212

                return "%.6g" % self.Value

   213

        return self.Value

   214

   215

    def GetNearestData(self, tick, adjust):

   216

        if USE_MPL and self.IsNumVariable():

   217

            ticks = self.Data[:, 0]

   218

            new_cursor = numpy.argmin(abs(ticks - tick))

   219

            if adjust == -1 and ticks[new_cursor] > tick and new_cursor > 0:

   220

                new_cursor -= 1

   221

            elif adjust == 1 and ticks[new_cursor] < tick and new_cursor < len(ticks):

   222

                new_cursor += 1

   223

            return new_cursor

   224

        return None

   225

   226

class DebugVariableTable(CustomTable):

   227

   228

    def GetValue(self, row, col):

   229

        if row < self.GetNumberRows():

   230

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

   231

        return ""

   232

   233

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

   234

        if col < len(self.colnames):

   235

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

   236

   237

    def GetValueByName(self, row, colname):

   238

        if row < self.GetNumberRows():

   239

            if colname == "Variable":

   240

                return self.data[row].GetVariable()

   241

            elif colname == "Value":

   242

                return self.data[row].GetValue()

   243

        return ""

   244

   245

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

   246

        if row < self.GetNumberRows():

   247

            if colname == "Variable":

   248

                self.data[row].SetVariable(value)

   249

            elif colname == "Value":

   250

                self.data[row].SetValue(value)

   251

   252

    def IsForced(self, row):

   253

        if row < self.GetNumberRows():

   254

            return self.data[row].IsForced()

   255

        return False

   256

   257

    def IsNumVariable(self, row):

   258

        if row < self.GetNumberRows():

   259

            return self.data[row].IsNumVariable()

   260

        return False

   261

   262

    def _updateColAttrs(self, grid):

   263

        """

   264

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

   265

        appropriate renderer given the column name.

   266

   267

        Otherwise default to the default renderer.

   268

        """

   269

   270

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

   271

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

   272

                colname = self.GetColLabelValue(col, False)

   273

                if colname == "Value":

   274

                    if self.IsForced(row):

   275

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

   276

                    else:

   277

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

   278

                grid.SetReadOnly(row, col, True)

   279

            self.ResizeRow(grid, row)

   280

   281

    def AppendItem(self, data):

   282

        self.data.append(data)

   283

   284

    def InsertItem(self, idx, data):

   285

        self.data.insert(idx, data)

   286

   287

    def RemoveItem(self, idx):

   288

        self.data.pop(idx)

   289

   290

    def MoveItem(self, idx, new_idx):

   291

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

   292

   293

    def GetItem(self, idx):

   294

        return self.data[idx]

   295

   296

class DebugVariableDropTarget(wx.TextDropTarget):

   297

   298

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

   299

        wx.TextDropTarget.__init__(self)

   300

        self.ParentWindow = parent

   301

        self.ParentControl = control

   302

   303

    def __del__(self):

   304

        self.ParentWindow = None

   305

        self.ParentControl = None

   306

   307

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

   308

        if self.ParentControl is not None:

   309

            self.ParentControl.OnMouseDragging(x, y)

   310

        else:

   311

            self.ParentWindow.RefreshHighlight(x, y)

   312

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

   313

   314

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

   315

        message = None

   316

        try:

   317

            values = eval(data)

   318

        except:

   319

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

   320

            values = None

   321

        if not isinstance(values, TupleType):

   322

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

   323

            values = None

   324

   325

        if message is not None:

   326

            wx.CallAfter(self.ShowMessage, message)

   327

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

   328

            if isinstance(self.ParentControl, CustomGrid):

   329

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

   330

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

   331

                if row == wx.NOT_FOUND:

   332

                    row = self.ParentWindow.Table.GetNumberRows()

   333

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

   334

            elif self.ParentControl is not None:

   335

                width, height = self.ParentControl.GetSize()

   336

                target_idx = self.ParentControl.GetIndex()

   337

                merge_type = GRAPH_PARALLEL

   338

                if isinstance(self.ParentControl, DebugVariableGraphic):

   339

                    if self.ParentControl.Is3DCanvas():

   340

                        if y > height / 2:

   341

                            target_idx += 1

   342

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

   343

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

   344

                        else:

   345

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

   346

   347

                    else:

   348

                        rect = self.ParentControl.GetAxesBoundingBox()

   349

                        if rect.InsideXY(x, y):

   350

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

   351

                            if merge_rect.InsideXY(x, y):

   352

                                merge_type = GRAPH_ORTHOGONAL

   353

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

   354

                        else:

   355

                            if y > height / 2:

   356

                                target_idx += 1

   357

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

   358

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

   359

                            else:

   360

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

   361

                else:

   362

                    if y > height / 2:

   363

                        target_idx += 1

   364

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

   365

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

   366

                    else:

   367

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

   368

   369

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

   370

                self.ParentWindow.MoveValue(values[0])

   371

            else:

   372

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

   373

   374

    def OnLeave(self):

   375

        self.ParentWindow.ResetHighlight()

   376

        return wx.TextDropTarget.OnLeave(self)

   377

   378

    def ShowMessage(self, message):

   379

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

   380

        dialog.ShowModal()

   381

        dialog.Destroy()

   382

   383

if USE_MPL:

   384

    MILLISECOND = 1000000

   385

    SECOND = 1000 * MILLISECOND

   386

    MINUTE = 60 * SECOND

   387

    HOUR = 60 * MINUTE

   388

    DAY = 24 * HOUR

   389

   390

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

   391

    RANGE_VALUES = map(lambda x: (str(x), x), [25 * 2 ** i for i in xrange(6)])

   392

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

   393

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

   394

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

   395

   396

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   397

   398

    SCROLLBAR_UNIT = 10

   399

   400

    #CANVAS_HIGHLIGHT_TYPES

   401

    [HIGHLIGHT_NONE,

   402

     HIGHLIGHT_BEFORE,

   403

     HIGHLIGHT_AFTER,

   404

     HIGHLIGHT_LEFT,

   405

     HIGHLIGHT_RIGHT,

   406

     HIGHLIGHT_RESIZE] = range(6)

   407

   408

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

   409

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

   410

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

   411

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

   412

   413

    #CANVAS_SIZE_TYPES

   414

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

   415

   416

    DEFAULT_CANVAS_HEIGHT = 200.

   417

    CANVAS_BORDER = (20., 10.)

   418

    CANVAS_PADDING = 8.5

   419

    VALUE_LABEL_HEIGHT = 17.

   420

    AXES_LABEL_HEIGHT = 12.75

   421

   422

    def compute_mask(x, y):

   423

        mask = []

   424

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

   425

            if xp == yp:

   426

                mask.append(xp)

   427

            else:

   428

                mask.append("*")

   429

        return mask

   430

   431

    def NextTick(variables):

   432

        next_tick = None

   433

        for item, data in variables:

   434

            if len(data) > 0:

   435

                if next_tick is None:

   436

                    next_tick = data[0][0]

   437

                else:

   438

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

   439

        return next_tick

   440

   441

    def OrthogonalData(item, start_tick, end_tick):

   442

        data = item.GetData(start_tick, end_tick)

   443

        min_value, max_value = item.GetRange()

   444

        if min_value is not None and max_value is not None:

   445

            center = (min_value + max_value) / 2.

   446

            range = max(1.0, max_value - min_value)

   447

        else:

   448

            center = 0.5

   449

            range = 1.0

   450

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

   451

   452

    class GraphButton():

   453

   454

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

   455

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

   456

            self.Bitmap = bitmap

   457

            self.Shown = True

   458

            self.Enabled = True

   459

            self.Callback = callback

   460

   461

        def __del__(self):

   462

            self.callback = None

   463

   464

        def GetSize(self):

   465

            return self.Bitmap.GetSize()

   466

   467

        def SetPosition(self, x, y):

   468

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

   469

   470

        def Show(self):

   471

            self.Shown = True

   472

   473

        def Hide(self):

   474

            self.Shown = False

   475

   476

        def IsShown(self):

   477

            return self.Shown

   478

   479

        def Enable(self):

   480

            self.Enabled = True

   481

   482

        def Disable(self):

   483

            self.Enabled = False

   484

   485

        def IsEnabled(self):

   486

            return self.Enabled

   487

   488

        def HitTest(self, x, y):

   489

            if self.Shown and self.Enabled:

   490

                w, h = self.Bitmap.GetSize()

   491

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

   492

                if rect.InsideXY(x, y):

   493

                    return True

   494

            return False

   495

   496

        def ProcessCallback(self):

   497

            if self.Callback is not None:

   498

                wx.CallAfter(self.Callback)