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

   143

   144

    def IsNumVariable(self):

   145

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

   146

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

   147

   148

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

   149

        if USE_MPL and self.IsNumVariable():

   150

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

   151

                num_value = binascii.crc32(value) & CRC_MASK

   152

            else:

   153

                num_value = float(value)

   154

            if self.MinValue is None:

   155

                self.MinValue = num_value

   156

            else:

   157

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

   158

            if self.MaxValue is None:

   159

                self.MaxValue = num_value

   160

            else:

   161

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

   162

            forced_value = float(forced)

   163

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

   164

                raw_data = (value, forced_value)

   165

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

   166

                    extra_value = len(self.RawData)

   167

                    self.RawData.append(raw_data)

   168

                else:

   169

                    extra_value = len(self.RawData) - 1

   170

            else:

   171

                extra_value = forced_value

   172

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

   173

            self.Parent.HasNewData = True

   174

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

   175

   176

    def SetForced(self, forced):

   177

        if self.Forced != forced:

   178

            self.Forced = forced

   179

            self.Parent.HasNewData = True

   180

   181

    def SetValue(self, value):

   182

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

   183

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

   184

            value = value[1:-1]

   185

        if self.Value != value:

   186

            self.Value = value

   187

            self.Parent.HasNewData = True

   188

   189

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

   190

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

   191

            if len(self.Data) > 0:

   192

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

   193

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

   194

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

   195

                    if not raw:

   196

                        if self.VariableType == "STRING":

   197

                            value = "'%s'" % value

   198

                        else:

   199

                            value = '"%s"' % value

   200

                    return value, forced

   201

                else:

   202

                    value = self.Data[idx, 1]

   203

                    if not raw and isinstance(value, FloatType):

   204

                        value = "%.6g" % value

   205

                    return value, self.Data[idx, 2]

   206

            return self.Value, self.IsForced()

   207

        elif not raw:

   208

            if self.VariableType == "STRING":

   209

                return "'%s'" % self.Value

   210

            elif self.VariableType == "WSTRING":

   211

                return '"%s"' % self.Value

   212

            elif isinstance(self.Value, FloatType):

   213

                return "%.6g" % self.Value

   214

        return self.Value

   215

   216

    def GetNearestData(self, tick, adjust):

   217

        if USE_MPL and self.IsNumVariable():

   218

            ticks = self.Data[:, 0]

   219

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

   220

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

   221

                new_cursor -= 1

   222

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

   223

                new_cursor += 1

   224

            return new_cursor

   225

        return None

   226

   227

class DebugVariableTable(CustomTable):

   228

   229

    def GetValue(self, row, col):

   230

        if row < self.GetNumberRows():

   231

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

   232

        return ""

   233

   234

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

   235

        if col < len(self.colnames):

   236

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

   237

   238

    def GetValueByName(self, row, colname):

   239

        if row < self.GetNumberRows():

   240

            if colname == "Variable":

   241

                return self.data[row].GetVariable()

   242

            elif colname == "Value":

   243

                return self.data[row].GetValue()

   244

        return ""

   245

   246

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

   247

        if row < self.GetNumberRows():

   248

            if colname == "Variable":

   249

                self.data[row].SetVariable(value)

   250

            elif colname == "Value":

   251

                self.data[row].SetValue(value)

   252

   253

    def IsForced(self, row):

   254

        if row < self.GetNumberRows():

   255

            return self.data[row].IsForced()

   256

        return False

   257

   258

    def IsNumVariable(self, row):

   259

        if row < self.GetNumberRows():

   260

            return self.data[row].IsNumVariable()

   261

        return False

   262

   263

    def _updateColAttrs(self, grid):

   264

        """

   265

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

   266

        appropriate renderer given the column name.

   267

   268

        Otherwise default to the default renderer.

   269

        """

   270

   271

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

   272

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

   273

                colname = self.GetColLabelValue(col, False)

   274

                if colname == "Value":

   275

                    if self.IsForced(row):

   276

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

   277

                    else:

   278

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

   279

                grid.SetReadOnly(row, col, True)

   280

            self.ResizeRow(grid, row)

   281

   282

    def AppendItem(self, data):

   283

        self.data.append(data)

   284

   285

    def InsertItem(self, idx, data):

   286

        self.data.insert(idx, data)

   287

   288

    def RemoveItem(self, idx):

   289

        self.data.pop(idx)

   290

   291

    def MoveItem(self, idx, new_idx):

   292

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

   293

   294

    def GetItem(self, idx):

   295

        return self.data[idx]

   296

   297

class DebugVariableDropTarget(wx.TextDropTarget):

   298

   299

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

   300

        wx.TextDropTarget.__init__(self)

   301

        self.ParentWindow = parent

   302

        self.ParentControl = control

   303

   304

    def __del__(self):

   305

        self.ParentWindow = None

   306

        self.ParentControl = None

   307

   308

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

   309

        if not isinstance(self.ParentControl, CustomGrid):

   310

            if self.ParentControl is not None:

   311

                self.ParentControl.OnMouseDragging(x, y)

   312

            else:

   313

                self.ParentWindow.RefreshHighlight(x, y)

   314

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

   315

   316

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

   317

        message = None

   318

        try:

   319

            values = eval(data)

   320

        except:

   321

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

   322

            values = None

   323

        if not isinstance(values, TupleType):

   324

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

   325

            values = None

   326

   327

        if message is not None:

   328

            wx.CallAfter(self.ShowMessage, message)

   329

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

   330

            if isinstance(self.ParentControl, CustomGrid):

   331

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

   332

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

   333

                if row == wx.NOT_FOUND:

   334

                    row = self.ParentWindow.Table.GetNumberRows()

   335

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

   336

            elif self.ParentControl is not None:

   337

                width, height = self.ParentControl.GetSize()

   338

                target_idx = self.ParentControl.GetIndex()

   339

                merge_type = GRAPH_PARALLEL

   340

                if isinstance(self.ParentControl, DebugVariableGraphic):

   341

                    if self.ParentControl.Is3DCanvas():

   342

                        if y > height / 2:

   343

                            target_idx += 1

   344

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

   345

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

   346

                        else:

   347

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

   348

   349

                    else:

   350

                        rect = self.ParentControl.GetAxesBoundingBox()

   351

                        if rect.InsideXY(x, y):

   352

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

   353

                            if merge_rect.InsideXY(x, y):

   354

                                merge_type = GRAPH_ORTHOGONAL

   355

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

   356

                        else:

   357

                            if y > height / 2:

   358

                                target_idx += 1

   359

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

   360

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

   361

                            else:

   362

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

   363

                else:

   364

                    if y > height / 2:

   365

                        target_idx += 1

   366

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

   367

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

   368

                    else:

   369

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

   370

   371

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

   372

                self.ParentWindow.MoveValue(values[0])

   373

            else:

   374

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

   375

   376

    def OnLeave(self):

   377

        if not isinstance(self.ParentControl, CustomGrid):

   378

            self.ParentWindow.ResetHighlight()

   379

        return wx.TextDropTarget.OnLeave(self)

   380

   381

    def ShowMessage(self, message):

   382

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

   383

        dialog.ShowModal()

   384

        dialog.Destroy()

   385

   386

if USE_MPL:

   387

    MILLISECOND = 1000000

   388

    SECOND = 1000 * MILLISECOND

   389

    MINUTE = 60 * SECOND

   390

    HOUR = 60 * MINUTE

   391

    DAY = 24 * HOUR

   392

   393

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

   394

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

   395

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

   396

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

   397

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

   398

   399

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   400

   401

    SCROLLBAR_UNIT = 10

   402

   403

    #CANVAS_HIGHLIGHT_TYPES

   404

    [HIGHLIGHT_NONE,

   405

     HIGHLIGHT_BEFORE,

   406

     HIGHLIGHT_AFTER,

   407

     HIGHLIGHT_LEFT,

   408

     HIGHLIGHT_RIGHT,

   409

     HIGHLIGHT_RESIZE] = range(6)

   410

   411

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

   412

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

   413

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

   414

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

   415

   416

    #CANVAS_SIZE_TYPES

   417

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

   418

   419

    DEFAULT_CANVAS_HEIGHT = 200.

   420

    CANVAS_BORDER = (20., 10.)

   421

    CANVAS_PADDING = 8.5

   422

    VALUE_LABEL_HEIGHT = 17.

   423

    AXES_LABEL_HEIGHT = 12.75

   424

   425

    def compute_mask(x, y):

   426

        mask = []

   427

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

   428

            if xp == yp:

   429

                mask.append(xp)

   430

            else:

   431

                mask.append("*")

   432

        return mask

   433

   434

    def NextTick(variables):

   435

        next_tick = None

   436

        for item, data in variables:

   437

            if len(data) > 0:

   438

                if next_tick is None:

   439

                    next_tick = data[0][0]

   440

                else:

   441

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

   442

        return next_tick

   443

   444

    def OrthogonalData(item, start_tick, end_tick):

   445

        data = item.GetData(start_tick, end_tick)

   446

        min_value, max_value = item.GetRange()

   447

        if min_value is not None and max_value is not None:

   448

            center = (min_value + max_value) / 2.

   449

            range = max(1.0, max_value - min_value)

   450

        else:

   451

            center = 0.5

   452

            range = 1.0

   453

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

   454

   455

    class GraphButton():

   456

   457

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

   458

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

   459

            self.Bitmap = bitmap

   460

            self.Shown = True

   461

            self.Enabled = True

   462

            self.Callback = callback

   463

   464

        def __del__(self):

   465

            self.callback = None

   466

   467

        def GetSize(self):

   468

            return self.Bitmap.GetSize()

   469

   470

        def SetPosition(self, x, y):

   471

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

   472

   473

        def Show(self):

   474

            self.Shown = True

   475

   476

        def Hide(self):

   477

            self.Shown = False

   478

   479

        def IsShown(self):

   480

            return self.Shown

   481

   482

        def Enable(self):

   483

            self.Enabled = True

   484

   485

        def Disable(self):

   486

            self.Enabled = False

   487

   488

        def IsEnabled(self):

   489

            return self.Enabled

   490

   491

        def HitTest(self, x, y):

   492

            if self.Shown and self.Enabled:

   493

                w, h = self.Bitmap.GetSize()

   494

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

   495

                if rect.InsideXY(x, y):

   496

                    return True

   497

            return False

   498