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

    26

from time import time as gettime

    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

    39

    from mpl_toolkits.mplot3d import Axes3D

    40

    USE_MPL = True

    41

except:

    42

    USE_MPL = False

    43

    44

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    45

from controls import CustomGrid, CustomTable

    46

from dialogs.ForceVariableDialog import ForceVariableDialog

    47

from util.BitmapLibrary import GetBitmap

    48

    59

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

    60

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

    61

    62

def GetDebugVariablesTableColnames():

    63

    _ = lambda x : x

    64

    cols = [_("Variable"), _("Value")]

    65

    if USE_MPL:

    66

        cols.append(_("3DAxis"))

    67

    return cols

    68

    69

class VariableTableItem(DebugDataConsumer):

    70

    71

    def __init__(self, parent, variable):

    72

        DebugDataConsumer.__init__(self)

    73

        self.Parent = parent

    74

        self.Variable = variable

    75

        self.RefreshVariableType()

    76

        self.Value = ""

    77

        self.Axis3D = False

    78

    79

    def __del__(self):

    80

        self.Parent = None

    81

    82

    def SetVariable(self, variable):

    83

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

    84

            self.Variable = variable

    85

            self.RefreshVariableType()

    86

            self.Parent.RefreshGrid()

    87

    88

    def GetVariable(self):

    89

        return self.Variable

    90

    91

    def RefreshVariableType(self):

    92

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

    93

        self.ResetData()

    94

    95

    def GetVariableType(self):

    96

        return self.VariableType

    97

   119

   120

    def ResetData(self):

   121

        if self.IsNumVariable():

   122

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

   125

        else:

   126

            self.Data = None

   127

   128

    def IsNumVariable(self):

   129

        return self.Parent.IsNumType(self.VariableType)

   130

   131

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

   132

        if self.IsNumVariable():

   133

            num_value = {True:1., False:0.}.get(value, float(value))

   142

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

   143

            self.Parent.HasNewData = True

   144

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

   145

   146

    def SetForced(self, forced):

   147

        if self.Forced != forced:

   148

            self.Forced = forced

   149

            self.Parent.HasNewData = True

   150

   151

    def SetValue(self, value):

   152

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

   153

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

   154

            value = value[1:-1]

   155

        if self.Value != value:

   156

            self.Value = value

   157

            self.Parent.HasNewData = True

   158

   159

    def GetValue(self):

   160

        if self.VariableType == "STRING":

   161

            return "'%s'" % self.Value

   162

        elif self.VariableType == "WSTRING":

   163

            return "\"%s\"" % self.Value

   164

        elif isinstance(self.Value, FloatType):

   165

            return "%.6g" % self.Value

   166

        return self.Value

   167

   168

    def SetAxis3D(self, axis_3d):

   169

        if self.IsNumVariable():

   170

            self.Axis3D = axis_3d

   171

   172

    def GetAxis3D(self):

   173

        if self.IsNumVariable():

   174

            return self.Axis3D

   175

        return ""

   176

   188

class DebugVariableTable(CustomTable):

   189

   190

    def GetValue(self, row, col):

   191

        if row < self.GetNumberRows():

   192

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

   193

        return ""

   194

   195

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

   196

        if col < len(self.colnames):

   197

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

   198

   199

    def GetValueByName(self, row, colname):

   200

        if row < self.GetNumberRows():

   201

            if colname == "Variable":

   202

                return self.data[row].GetVariable()

   203

            elif colname == "Value":

   204

                return self.data[row].GetValue()

   205

            elif colname == "3DAxis":

   206

                return self.data[row].GetAxis3D()

   207

        return ""

   208

   209

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

   210

        if row < self.GetNumberRows():

   211

            if colname == "Variable":

   212

                self.data[row].SetVariable(value)

   213

            elif colname == "Value":

   214

                self.data[row].SetValue(value)

   215

            elif colname == "3DAxis":

   216

                self.data[row].SetAxis3D(value)

   217

   218

    def IsForced(self, row):

   219

        if row < self.GetNumberRows():

   220

            return self.data[row].IsForced()

   221

        return False

   222

   223

    def IsNumVariable(self, row):

   224

        if row < self.GetNumberRows():

   225

            return self.data[row].IsNumVariable()

   226

        return False

   227

   228

    def _updateColAttrs(self, grid):

   229

        """

   230

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

   231

        appropriate renderer given the column name.

   232

   233

        Otherwise default to the default renderer.

   234

        """

   235

   236

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

   237

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

   238

                colname = self.GetColLabelValue(col, False)

   239

                if colname == "3DAxis":

   240

                    if self.IsNumVariable(row):

   241

                        grid.SetCellRenderer(row, col, wx.grid.GridCellBoolRenderer())

   242

                        grid.SetCellEditor(row, col, wx.grid.GridCellBoolEditor())

   243

                        grid.SetReadOnly(row, col, False)

   244

                    else:

   245

                        grid.SetReadOnly(row, col, True)

   246

                else:

   247

                    if colname == "Value":

   248

                        if self.IsForced(row):

   249

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

   250

                        else:

   251

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

   252

                    grid.SetReadOnly(row, col, True)

   253

            self.ResizeRow(grid, row)

   254

   255

    def AppendItem(self, data):

   256

        self.data.append(data)

   257

   258

    def InsertItem(self, idx, data):

   259

        self.data.insert(idx, data)

   260

   261

    def RemoveItem(self, idx):

   262

        self.data.pop(idx)

   263

   264

    def MoveItem(self, idx, new_idx):

   265

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

   266

   267

    def GetItem(self, idx):

   268

        return self.data[idx]

   269

   270

class DebugVariableDropTarget(wx.TextDropTarget):

   271

   272

    def __init__(self, parent):

   273

        wx.TextDropTarget.__init__(self)

   274

        self.ParentWindow = parent

   275

   276

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

   277

        x, y = self.ParentWindow.VariablesGrid.CalcUnscrolledPosition(x, y)

   278

        row = self.ParentWindow.VariablesGrid.YToRow(y - self.ParentWindow.VariablesGrid.GetColLabelSize())

   279

        if row == wx.NOT_FOUND:

   280

            row = self.ParentWindow.Table.GetNumberRows()

   281

        message = None

   282

        try:

   283

            values = eval(data)

   284

        except:

   285

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

   286

            values = None

   287

        if not isinstance(values, TupleType):

   288

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

   289

            values = None

   290

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

   291

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

   292

        if message is not None:

   293

            wx.CallAfter(self.ShowMessage, message)

   294

   295

    def ShowMessage(self, message):

   296

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

   297

        dialog.ShowModal()

   298

        dialog.Destroy()

   299

   300

SCROLLBAR_UNIT = 10

   301

   312

class DebugVariablePanel(wx.SplitterWindow, DebugViewer):

   313

   315

        wx.SplitterWindow.__init__(self, parent, style=wx.SP_3D)

   319

        DebugViewer.__init__(self, producer, True)

   320

   321

        self.SetSashGravity(0.5)

   322

        self.SetNeedUpdating(True)

   323

        self.SetMinimumPaneSize(1)

   324

   325

        self.MainPanel = wx.Panel(self, style=wx.TAB_TRAVERSAL)

   326

   327

        main_panel_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   328

        main_panel_sizer.AddGrowableCol(0)

   329

        main_panel_sizer.AddGrowableRow(1)

   330

   331

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   332

        main_panel_sizer.AddSizer(button_sizer, border=5, 

   333

              flag=wx.ALIGN_RIGHT|wx.ALL)

   334

   335

        for name, bitmap, help in [

   336

                ("DeleteButton", "remove_element", _("Remove debug variable")),

   337

                ("UpButton", "up", _("Move debug variable up")),

   338

                ("DownButton", "down", _("Move debug variable down"))]:

   339

            button = wx.lib.buttons.GenBitmapButton(self.MainPanel, bitmap=GetBitmap(bitmap), 

   340

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

   341

            button.SetToolTipString(help)

   342

            setattr(self, name, button)

   343

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

   344

   345

        self.VariablesGrid = CustomGrid(self.MainPanel, size=wx.Size(-1, 150), style=wx.VSCROLL)

   346

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self))

   347

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, 

   348

              self.OnVariablesGridCellRightClick)

   349

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, 

   350

              self.OnVariablesGridCellLeftClick)

   351

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, 

   352

              self.OnVariablesGridCellChange)

   353

        main_panel_sizer.AddWindow(self.VariablesGrid, flag=wx.GROW)

   354

   355

        self.MainPanel.SetSizer(main_panel_sizer)

   356

   357

        self.HasNewData = False

   363

   364

        self.Table = DebugVariableTable(self, [], GetDebugVariablesTableColnames())

   365

        self.VariablesGrid.SetTable(self.Table)

   366

        self.VariablesGrid.SetButtons({"Delete": self.DeleteButton,

   367

                                       "Up": self.UpButton,

   368

                                       "Down": self.DownButton})

   369

   370

        def _AddVariable(new_row):

   371

            return self.VariablesGrid.GetGridCursorRow()

   372

        setattr(self.VariablesGrid, "_AddRow", _AddVariable)

   373

   374

        def _DeleteVariable(row):

   375

            item = self.Table.GetItem(row)

   376

            self.RemoveDataConsumer(item)

   377

            self.Table.RemoveItem(row)

   378

            self.ResetGraphics()

   379

            self.RefreshGrid()

   380

        setattr(self.VariablesGrid, "_DeleteRow", _DeleteVariable)

   381

   382

        def _MoveVariable(row, move):

   383

            new_row = max(0, min(row + move, self.Table.GetNumberRows() - 1))

   384

            if new_row != row:

   385

                self.Table.MoveItem(row, new_row)

   386

                self.ResetGraphics()

   387

                self.RefreshGrid()

   388

            return new_row

   389

        setattr(self.VariablesGrid, "_MoveRow", _MoveVariable)

   390

   391

        self.VariablesGrid.SetRowLabelSize(0)

   392

   393

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

   394

            attr = wx.grid.GridCellAttr()

   395

            if self.Table.GetColLabelValue(col, False) == "3DAxis":

   396

                attr.SetAlignment(wx.ALIGN_CENTER, wx.ALIGN_CENTER)

   397

            else:

   398

                attr.SetAlignment(wx.ALIGN_RIGHT, wx.ALIGN_CENTER)

   399

            self.VariablesGrid.SetColAttr(col, attr)

   400

            self.VariablesGrid.SetColSize(col, 100)

   401

   402

        self.Table.ResetView(self.VariablesGrid)

   403

        self.VariablesGrid.RefreshButtons()

   404

   405

        if USE_MPL:

   406

            self.GraphicsPanel = wx.Panel(self, style=wx.TAB_TRAVERSAL)

   407

   408

            graphics_panel_sizer = wx.BoxSizer(wx.VERTICAL)

   409

   447

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

   448

            self.GraphicsCanvasWindow.Bind(wx.EVT_SIZE, self.OnGraphicsCanvasWindowResize)

   449

            graphics_panel_sizer.AddWindow(self.GraphicsCanvasWindow, 1, flag=wx.GROW)

   450

   451

            graphics_canvas_window_sizer = wx.BoxSizer(wx.VERTICAL)

   452

   453

            self.GraphicsFigure = matplotlib.figure.Figure()

   454

            self.GraphicsFigure.subplots_adjust(hspace=0)

   455

            self.GraphicsAxes = []

   456

   457

            self.GraphicsCanvas = FigureCanvas(self.GraphicsCanvasWindow, -1, self.GraphicsFigure)

   458

            graphics_canvas_window_sizer.AddWindow(self.GraphicsCanvas, 1, flag=wx.GROW)

   459

   460

            self.GraphicsCanvasWindow.SetSizer(graphics_canvas_window_sizer)

   461

   462

            self.Graphics3DFigure = matplotlib.figure.Figure()

   463

            self.Graphics3DFigure.subplotpars.update(left=0.0, right=1.0, bottom=0.0, top=1.0)

   464

   465

            self.LastMotionTime = gettime()

   466

            self.Graphics3DAxes = self.Graphics3DFigure.gca(projection='3d')

   467

            self.Graphics3DAxes.set_color_cycle(['b'])

   468

            setattr(self.Graphics3DAxes, "_on_move", self.OnGraphics3DMotion)

   469

   470

            self.Graphics3DCanvas = FigureCanvas(self.GraphicsPanel, -1, self.Graphics3DFigure)

   471

            self.Graphics3DCanvas.SetMinSize(wx.Size(1, 1))

   472

            graphics_panel_sizer.AddWindow(self.Graphics3DCanvas, 1, flag=wx.GROW)

   473

   474

            self.Graphics3DAxes.mouse_init()

   475

   476

            self.GraphicsPanel.SetSizer(graphics_panel_sizer)

   477

   478

            self.SplitHorizontally(self.MainPanel, self.GraphicsPanel, -200)

   479

   480

        else:

   481

            self.Initialize(self.MainPanel)

   482

   483

        self.ResetGraphics()

   498

            self.HasNewData = False

   499

            self.RefreshGrid(only_values=True)