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

    50

from controls import CustomGrid, CustomTable

    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

CRC_SIZE = 8

    62

CRC_MASK = 2 ** CRC_SIZE - 1

    63

    64

class VariableTableItem(DebugDataConsumer):

    65

    66

    def __init__(self, parent, variable):

    67

        DebugDataConsumer.__init__(self)

    68

        self.Parent = parent

    69

        self.Variable = variable

    70

        self.RefreshVariableType()

    71

        self.Value = ""

    72

    73

    def __del__(self):

    74

        self.Parent = None

    75

    76

    def SetVariable(self, variable):

    77

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

    78

            self.Variable = variable

    79

            self.RefreshVariableType()

    80

            self.Parent.RefreshView()

    81

    82

    def GetVariable(self, mask=None):

    83

        variable = self.Variable

    84

        if mask is not None:

    85

            parts = variable.split('.')

    86

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

    87

            last = None

    88

            variable = ""

    89

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

    90

                if m == '*':

    91

                    if last == '*':

    92

                        variable += '.'

    93

                    variable += v

    94

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

    95

                    variable += '..'

    96

                last = m

    97

        return variable

    98

    99

    def RefreshVariableType(self):

   100

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

   101

        if USE_MPL:

   102

            self.ResetData()

   103

   104

    def GetVariableType(self):

   105

        return self.VariableType

   106

   107

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

   108

        if USE_MPL and self.IsNumVariable():

   109

            if len(self.Data) == 0:

   110

                return self.Data

   111

   112

            start_idx = end_idx = None

   113

            if start_tick is not None:

   114

                start_idx = self.GetNearestData(start_tick, -1)

   115

            if end_tick is not None:

   116

                end_idx = self.GetNearestData(end_tick, 1)

   117

            if start_idx is None:

   118

                start_idx = 0

   119

            if end_idx is not None:

   120

                return self.Data[start_idx:end_idx + 1]

   121

            else:

   122

                return self.Data[start_idx:]

   123

   124

        return None

   125

   126

    def GetRawValue(self, idx):

   127

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

   128

            return self.RawData[idx][0]

   129

        return ""

   130

   131

    def GetRange(self):

   132

        return self.MinValue, self.MaxValue

   133

   134

    def ResetData(self):

   135

        if self.IsNumVariable():

   136

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

   137

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

   138

                self.RawData = []

   139

            self.MinValue = None

   140

            self.MaxValue = None

   141

        else:

   142

            self.Data = None

   143

        self.Value = ""

   144

   145

    def IsNumVariable(self):

   146

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

   147

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

   148

   149

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

   150

        if USE_MPL and self.IsNumVariable():

   151

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

   152

                num_value = binascii.crc32(value) & CRC_MASK

   153

            else:

   154

                num_value = float(value)

   155

            if self.MinValue is None:

   156

                self.MinValue = num_value

   157

            else:

   158

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

   159

            if self.MaxValue is None:

   160

                self.MaxValue = num_value

   161

            else:

   162

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

   163

            forced_value = float(forced)

   164

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

   165

                raw_data = (value, forced_value)

   166

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

   167

                    extra_value = len(self.RawData)

   168

                    self.RawData.append(raw_data)

   169

                else:

   170

                    extra_value = len(self.RawData) - 1

   171

            else:

   172

                extra_value = forced_value

   173

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

   174

            self.Parent.HasNewData = True

   175

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

   176

   177

    def SetForced(self, forced):

   178

        if self.Forced != forced:

   179

            self.Forced = forced

   180

            self.Parent.HasNewData = True

   181

   182

    def SetValue(self, value):

   183

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

   184

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

   185

            value = value[1:-1]

   186

        if self.Value != value:

   187

            self.Value = value

   188

            self.Parent.HasNewData = True

   189

   190

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

   191

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

   192

            if len(self.Data) > 0:

   193

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

   194

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

   195

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

   196

                    if not raw:

   197

                        if self.VariableType == "STRING":

   198

                            value = "'%s'" % value

   199

                        else:

   200

                            value = '"%s"' % value

   201

                    return value, forced

   202

                else:

   203

                    value = self.Data[idx, 1]

   204

                    if not raw and isinstance(value, FloatType):

   205

                        value = "%.6g" % value

   206

                    return value, self.Data[idx, 2]

   207

            return self.Value, self.IsForced()

   208

        elif not raw:

   209

            if self.VariableType == "STRING":

   210

                return "'%s'" % self.Value

   211

            elif self.VariableType == "WSTRING":

   212

                return '"%s"' % self.Value

   213

            elif isinstance(self.Value, FloatType):

   214

                return "%.6g" % self.Value

   215

        return self.Value

   216

   217

    def GetNearestData(self, tick, adjust):

   218

        if USE_MPL and self.IsNumVariable():

   219

            ticks = self.Data[:, 0]

   220

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

   221

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

   222

                new_cursor -= 1

   223

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

   224

                new_cursor += 1

   225

            return new_cursor

   226

        return None

   227

   228

class DebugVariableTable(CustomTable):

   229

   230

    def GetValue(self, row, col):

   231

        if row < self.GetNumberRows():

   232

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

   233

        return ""

   234

   235

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

   236

        if col < len(self.colnames):

   237

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

   238

   239

    def GetValueByName(self, row, colname):

   240

        if row < self.GetNumberRows():

   241

            if colname == "Variable":

   242

                return self.data[row].GetVariable()

   243

            elif colname == "Value":

   244

                return self.data[row].GetValue()

   245

        return ""

   246

   247

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

   248

        if row < self.GetNumberRows():

   249

            if colname == "Variable":

   250

                self.data[row].SetVariable(value)

   251

            elif colname == "Value":

   252

                self.data[row].SetValue(value)

   253

   254

    def IsForced(self, row):

   255

        if row < self.GetNumberRows():

   256

            return self.data[row].IsForced()

   257

        return False

   258

   259

    def IsNumVariable(self, row):

   260

        if row < self.GetNumberRows():

   261

            return self.data[row].IsNumVariable()

   262

        return False

   263

   264

    def _updateColAttrs(self, grid):

   265

        """

   266

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

   267

        appropriate renderer given the column name.

   268

   269

        Otherwise default to the default renderer.

   270

        """

   271

   272

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

   273

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

   274

                colname = self.GetColLabelValue(col, False)

   275

                if colname == "Value":

   276

                    if self.IsForced(row):

   277

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

   278

                    else:

   279

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

   280

                grid.SetReadOnly(row, col, True)

   281

            self.ResizeRow(grid, row)

   282

   283

    def AppendItem(self, data):

   284

        self.data.append(data)

   285

   286

    def InsertItem(self, idx, data):

   287

        self.data.insert(idx, data)

   288

   289

    def RemoveItem(self, idx):

   290

        self.data.pop(idx)

   291

   292

    def MoveItem(self, idx, new_idx):

   293

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

   294

   295

    def GetItem(self, idx):

   296

        return self.data[idx]

   297

   298

class DebugVariableDropTarget(wx.TextDropTarget):

   299

   300

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

   301

        wx.TextDropTarget.__init__(self)

   302

        self.ParentWindow = parent

   303

        self.ParentControl = control

   304

   305

    def __del__(self):

   306

        self.ParentWindow = None

   307

        self.ParentControl = None

   308

   309

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

   310

        if not isinstance(self.ParentControl, CustomGrid):

   311

            if self.ParentControl is not None:

   312

                self.ParentControl.OnMouseDragging(x, y)

   313

            else:

   314

                self.ParentWindow.RefreshHighlight(x, y)

   315

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

   316

   317

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

   318

        message = None

   319

        try:

   320

            values = eval(data)

   321

        except:

   322

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

   323

            values = None

   324

        if not isinstance(values, TupleType):

   325

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

   326

            values = None

   327

   328

        if message is not None:

   329

            wx.CallAfter(self.ShowMessage, message)

   330

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

   331

            if isinstance(self.ParentControl, CustomGrid):

   332

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

   333

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

   334

                if row == wx.NOT_FOUND:

   335

                    row = self.ParentWindow.Table.GetNumberRows()

   336

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

   337

            elif self.ParentControl is not None:

   338

                width, height = self.ParentControl.GetSize()

   339

                target_idx = self.ParentControl.GetIndex()

   340

                merge_type = GRAPH_PARALLEL

   341

                if isinstance(self.ParentControl, DebugVariableGraphic):

   342

                    if self.ParentControl.Is3DCanvas():

   343

                        if y > height / 2:

   344

                            target_idx += 1

   345

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

   346

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

   347

                        else:

   348

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

   349

   350

                    else:

   351

                        rect = self.ParentControl.GetAxesBoundingBox()

   352

                        if rect.InsideXY(x, y):

   353

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

   354

                            if merge_rect.InsideXY(x, y):

   355

                                merge_type = GRAPH_ORTHOGONAL

   356

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

   357

                        else:

   358

                            if y > height / 2:

   359

                                target_idx += 1

   360

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

   361

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

   362

                            else:

   363

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

   364

                else:

   365

                    if y > height / 2:

   366

                        target_idx += 1

   367

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

   368

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

   369

                    else:

   370

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

   371

   372

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

   373

                self.ParentWindow.MoveValue(values[0])

   374

            else:

   375

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

   376

   377

    def OnLeave(self):

   378

        if not isinstance(self.ParentControl, CustomGrid):

   379

            self.ParentWindow.ResetHighlight()

   380

        return wx.TextDropTarget.OnLeave(self)

   381

   382

    def ShowMessage(self, message):

   383

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

   384

        dialog.ShowModal()

   385

        dialog.Destroy()

   386

   387

if USE_MPL:

   388

    MILLISECOND = 1000000

   389

    SECOND = 1000 * MILLISECOND

   390

    MINUTE = 60 * SECOND

   391

    HOUR = 60 * MINUTE

   392

    DAY = 24 * HOUR

   393

   394

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

   395

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

   396

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

   397

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

   398

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

   399

   400

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   401

   402

    SCROLLBAR_UNIT = 10

   403

   404

    #CANVAS_HIGHLIGHT_TYPES

   405

    [HIGHLIGHT_NONE,

   406

     HIGHLIGHT_BEFORE,

   407

     HIGHLIGHT_AFTER,

   408

     HIGHLIGHT_LEFT,

   409

     HIGHLIGHT_RIGHT,

   410

     HIGHLIGHT_RESIZE] = range(6)

   411

   412

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

   413

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

   414

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

   415

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

   416

   417

    #CANVAS_SIZE_TYPES

   418

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

   419

   420

    DEFAULT_CANVAS_HEIGHT = 200.

   421

    CANVAS_BORDER = (20., 10.)

   422

    CANVAS_PADDING = 8.5

   423

    VALUE_LABEL_HEIGHT = 17.

   424

    AXES_LABEL_HEIGHT = 12.75

   425

   426

    def compute_mask(x, y):

   427

        mask = []

   428

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

   429

            if xp == yp:

   430

                mask.append(xp)

   431

            else:

   432

                mask.append("*")

   433

        return mask

   434

   435

    def NextTick(variables):

   436

        next_tick = None

   437

        for item, data in variables:

   438

            if len(data) > 0:

   439

                if next_tick is None:

   440

                    next_tick = data[0][0]

   441

                else:

   442

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

   443

        return next_tick

   444

   445

    def OrthogonalData(item, start_tick, end_tick):

   446

        data = item.GetData(start_tick, end_tick)

   447

        min_value, max_value = item.GetRange()

   448

        if min_value is not None and max_value is not None:

   449

            center = (min_value + max_value) / 2.

   450

            range = max(1.0, max_value - min_value)

   451

        else:

   452

            center = 0.5

   453

            range = 1.0

   454

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

   455

   456

    class GraphButton():

   457

   458

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

   459

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

   460

            self.Bitmap = bitmap

   461

            self.Shown = True

   462

            self.Enabled = True

   463

            self.Callback = callback

   464

   465

        def __del__(self):

   466

            self.callback = None

   467

   468

        def GetSize(self):

   469

            return self.Bitmap.GetSize()

   470

   471

        def SetPosition(self, x, y):

   472

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

   473

   474

        def Show(self):

   475

            self.Shown = True

   476

   477

        def Hide(self):

   478

            self.Shown = False

   479

   480

        def IsShown(self):

   481

            return self.Shown

   482

   483

        def Enable(self):

   484

            self.Enabled = True

   485

   486

        def Disable(self):

   487

            self.Enabled = False

   488

   489

        def IsEnabled(self):

   490

            return self.Enabled

   491

   492

        def HitTest(self, x, y):

   493

            if self.Shown and self.Enabled:

   494

                w, h = self.Bitmap.GetSize()

   495

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

   496

                if rect.InsideXY(x, y):

   497

                    return True

   498

            return False