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

    27

import numpy

    28

    29

import wx

    30

import wx.lib.buttons

    41

    42

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    43

from controls import CustomGrid, CustomTable

    44

from dialogs.ForceVariableDialog import ForceVariableDialog

    45

from util.BitmapLibrary import GetBitmap

    46

    47

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

    48

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

    49

    50

def GetDebugVariablesTableColnames():

    51

    _ = lambda x : x

    56

    57

class VariableTableItem(DebugDataConsumer):

    58

    59

    def __init__(self, parent, variable):

    60

        DebugDataConsumer.__init__(self)

    61

        self.Parent = parent

    62

        self.Variable = variable

    63

        self.RefreshVariableType()

    64

        self.Value = ""

    65

        self.Axis3D = False

    66

    67

    def __del__(self):

    68

        self.Parent = None

    69

    70

    def SetVariable(self, variable):

    71

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

    72

            self.Variable = variable

    73

            self.RefreshVariableType()

    74

            self.Parent.RefreshGrid()

    75

    76

    def GetVariable(self):

    77

        return self.Variable

    78

    79

    def RefreshVariableType(self):

    80

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

    81

        self.ResetData()

    82

    83

    def GetVariableType(self):

    84

        return self.VariableType

    85

    86

    def GetData(self):

    87

        return self.Data

    88

    89

    def ResetData(self):

    90

        if self.IsNumVariable():

    91

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

    92

        else:

    93

            self.Data = None

    94

    95

    def IsNumVariable(self):

    96

        return self.Parent.IsNumType(self.VariableType)

    97

    98

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

    99

        if self.IsNumVariable():

   100

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

   101

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

   102

            self.Parent.HasNewData = True

   103

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

   104

   105

    def SetForced(self, forced):

   106

        if self.Forced != forced:

   107

            self.Forced = forced

   108

            self.Parent.HasNewData = True

   109

   110

    def SetValue(self, value):

   111

        if self.Value != value:

   112

            self.Value = value

   113

            self.Parent.HasNewData = True

   114

   115

    def GetValue(self):

   116

        if self.VariableType == "STRING":

   117

            return "'%s'" % self.Value

   118

        elif self.VariableType == "WSTRING":

   119

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

   120

        elif isinstance(self.Value, FloatType):

   121

            return "%.6g" % self.Value

   122

        return self.Value

   123

   124

    def SetAxis3D(self, axis_3d):

   125

        if self.IsNumVariable():

   126

            self.Axis3D = axis_3d

   127

   128

    def GetAxis3D(self):

   129

        if self.IsNumVariable():

   130

            return self.Axis3D

   131

        return ""

   132

   133

class DebugVariableTable(CustomTable):

   134

   135

    def GetValue(self, row, col):

   136

        if row < self.GetNumberRows():

   137

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

   138

        return ""

   139

   140

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

   141

        if col < len(self.colnames):

   142

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

   143

   144

    def GetValueByName(self, row, colname):

   145

        if row < self.GetNumberRows():

   146

            if colname == "Variable":

   147

                return self.data[row].GetVariable()

   148

            elif colname == "Value":

   149

                return self.data[row].GetValue()

   150

            elif colname == "3DAxis":

   151

                return self.data[row].GetAxis3D()

   152

        return ""

   153

   154

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

   155

        if row < self.GetNumberRows():

   156

            if colname == "Variable":

   157

                self.data[row].SetVariable(value)

   158

            elif colname == "Value":

   159

                self.data[row].SetValue(value)

   160

            elif colname == "3DAxis":

   161

                self.data[row].SetAxis3D(value)

   162

   163

    def IsForced(self, row):

   164

        if row < self.GetNumberRows():

   165

            return self.data[row].IsForced()

   166

        return False

   167

   168

    def IsNumVariable(self, row):

   169

        if row < self.GetNumberRows():

   170

            return self.data[row].IsNumVariable()

   171

        return False

   172

   173

    def _updateColAttrs(self, grid):

   174

        """

   175

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

   176

        appropriate renderer given the column name.

   177

   178

        Otherwise default to the default renderer.

   179

        """

   180

   181

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

   182

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

   183

                colname = self.GetColLabelValue(col, False)

   184

                if colname == "3DAxis":

   185

                    if self.IsNumVariable(row):

   186

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

   187

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

   188

                        grid.SetReadOnly(row, col, False)

   189

                    else:

   190

                        grid.SetReadOnly(row, col, True)

   191

                else:

   192

                    if colname == "Value":

   193

                        if self.IsForced(row):

   194

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

   195

                        else:

   196

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

   197

                    grid.SetReadOnly(row, col, True)

   198

            self.ResizeRow(grid, row)

   199

   200

    def AppendItem(self, data):

   201

        self.data.append(data)

   202

   203

    def InsertItem(self, idx, data):

   204

        self.data.insert(idx, data)

   205

   206

    def RemoveItem(self, idx):

   207

        self.data.pop(idx)

   208

   209

    def MoveItem(self, idx, new_idx):

   210

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

   211

   212

    def GetItem(self, idx):

   213

        return self.data[idx]

   214

   215

class DebugVariableDropTarget(wx.TextDropTarget):

   216

   217

    def __init__(self, parent):

   218

        wx.TextDropTarget.__init__(self)

   219

        self.ParentWindow = parent

   220

   221

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

   222

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

   223

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

   224

        if row == wx.NOT_FOUND:

   225

            row = self.ParentWindow.Table.GetNumberRows()

   226

        message = None

   227

        try:

   228

            values = eval(data)

   229

        except:

   230

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

   231

            values = None

   232

        if not isinstance(values, TupleType):

   233

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

   234

            values = None

   235

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

   236

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

   237

        if message is not None:

   238

            wx.CallAfter(self.ShowMessage, message)

   239

   240

    def ShowMessage(self, message):

   241

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

   242

        dialog.ShowModal()

   243

        dialog.Destroy()

   244

   245

SCROLLBAR_UNIT = 10

   246

   247

class DebugVariablePanel(wx.SplitterWindow, DebugViewer):

   248

   249

    def __init__(self, parent, producer):

   250

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

   251

        DebugViewer.__init__(self, producer, True)

   252

   253

        self.SetSashGravity(0.5)

   254

        self.SetNeedUpdating(True)

   255

        self.SetMinimumPaneSize(1)

   256

   257

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

   258

   259

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

   260

        main_panel_sizer.AddGrowableCol(0)

   261

        main_panel_sizer.AddGrowableRow(1)

   262

   263

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   264

        main_panel_sizer.AddSizer(button_sizer, border=5, 

   265

              flag=wx.ALIGN_RIGHT|wx.ALL)

   266

   267

        for name, bitmap, help in [

   268

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

   269

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

   270

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

   271

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

   272

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

   273

            button.SetToolTipString(help)

   274

            setattr(self, name, button)

   275

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

   276

   277

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

   278

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self))

   279

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

   280

              self.OnVariablesGridCellRightClick)

   281

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

   282

              self.OnVariablesGridCellChange)

   283

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

   284

   285

        self.MainPanel.SetSizer(main_panel_sizer)

   286

   287

        self.HasNewData = False

   288

   289

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

   290

        self.VariablesGrid.SetTable(self.Table)

   291

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

   292

                                       "Up": self.UpButton,

   293

                                       "Down": self.DownButton})

   294

   295

        def _AddVariable(new_row):

   296

            return self.VariablesGrid.GetGridCursorRow()

   297

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

   298

   299

        def _DeleteVariable(row):

   300

            item = self.Table.GetItem(row)

   301

            self.RemoveDataConsumer(item)

   302

            self.Table.RemoveItem(row)

   303

            self.ResetGraphics()

   304

            self.RefreshGrid()

   305

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

   306

   307

        def _MoveVariable(row, move):

   308

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

   309

            if new_row != row:

   310

                self.Table.MoveItem(row, new_row)

   311

                self.ResetGraphics()

   312

                self.RefreshGrid()

   313

            return new_row

   314

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

   315

   316

        self.VariablesGrid.SetRowLabelSize(0)

   317

   318

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

   319

            attr = wx.grid.GridCellAttr()

   320

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

   321

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

   322

            else:

   323

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

   324

            self.VariablesGrid.SetColAttr(col, attr)

   325

            self.VariablesGrid.SetColSize(col, 100)

   326

   327

        self.Table.ResetView(self.VariablesGrid)

   328

        self.VariablesGrid.RefreshButtons()

   329

   370

   371

        self.ResetGraphics()

   372

   373

    def RefreshNewData(self):

   374

        if self.HasNewData:

   375

            self.HasNewData = False

   376

            self.RefreshGrid(only_values=True)

   377

        DebugViewer.RefreshNewData(self)

   378

   379

    def RefreshGrid(self, only_values=False):

   380

        self.Freeze()

   381

        if only_values:

   382

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

   383

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

   384

                    for row in xrange(self.Table.GetNumberRows()):

   385

                        self.VariablesGrid.SetCellValue(row, col, str(self.Table.GetValueByName(row, "Value")))

   386

        else:

   387

            self.Table.ResetView(self.VariablesGrid)

   388

        self.VariablesGrid.RefreshButtons()

   389

   410

   411

        self.Thaw()

   412

   413

    def UnregisterObsoleteData(self):

   414

        items = [(idx, item) for idx, item in enumerate(self.Table.GetData())]

   415

        items.reverse()

   416

        for idx, item in items:

   417

            iec_path = item.GetVariable().upper()

   418

            if self.GetDataType(iec_path) is None:

   419

                self.RemoveDataConsumer(item)

   420

                self.Table.RemoveItem(idx)

   421

            else:

   422

                self.AddDataConsumer(iec_path, item)

   423

                item.RefreshVariableType()

   424

        self.Freeze()

   425

        self.Table.ResetView(self.VariablesGrid)

   426

        self.VariablesGrid.RefreshButtons()

   427

        self.Thaw()

   428

   429

    def ResetGrid(self):

   430

        self.DeleteDataConsumers()

   431

        self.Table.Empty()

   432

        self.Freeze()

   433

        self.Table.ResetView(self.VariablesGrid)

   434

        self.VariablesGrid.RefreshButtons()

   435

        self.Thaw()

   436

        self.ResetGraphics()

   437

   438

    def GetForceVariableMenuFunction(self, iec_path, item):

   439

        iec_type = self.GetDataType(iec_path)

   440

        def ForceVariableFunction(event):

   441

            if iec_type is not None:

   442

                dialog = ForceVariableDialog(self, iec_type, str(item.GetValue()))

   443

                if dialog.ShowModal() == wx.ID_OK:

   444

                    self.ForceDataValue(iec_path, dialog.GetValue())

   445

        return ForceVariableFunction

   446

   447

    def GetReleaseVariableMenuFunction(self, iec_path):

   448

        def ReleaseVariableFunction(event):

   449

            self.ReleaseDataValue(iec_path)

   450

        return ReleaseVariableFunction

   451

   452

    def OnVariablesGridCellRightClick(self, event):

   453

        row, col = event.GetRow(), event.GetCol()

   454

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

   455

            iec_path = self.Table.GetValueByName(row, "Variable").upper()

   456

   457

            menu = wx.Menu(title='')

   458

   459

            new_id = wx.NewId()

   460

            AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=_("Force value"))

   461

            self.Bind(wx.EVT_MENU, self.GetForceVariableMenuFunction(iec_path.upper(), self.Table.GetItem(row)), id=new_id)

   462

   463

            new_id = wx.NewId()

   464

            AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=_("Release value"))

   465

            self.Bind(wx.EVT_MENU, self.GetReleaseVariableMenuFunction(iec_path.upper()), id=new_id)

   466

   467

            if self.Table.IsForced(row):

   468

                menu.Enable(new_id, True)

   469

            else:

   470

                menu.Enable(new_id, False)

   471

   472

            self.PopupMenu(menu)

   473

   474

            menu.Destroy()

   475

        event.Skip()

   476

   477

    def OnVariablesGridCellChange(self, event):

   478

        row, col = event.GetRow(), event.GetCol()

   479

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

   480

            wx.CallAfter(self.Reset3DGraphics)

   481

        event.Skip()

   482

   483

    def InsertValue(self, iec_path, idx = None, force=False, axis3D=False):

   484

        if idx is None:

   485

            idx = self.Table.GetNumberRows()

   486

        for item in self.Table.GetData():

   487

            if iec_path == item.GetVariable():

   488

                return

   489

        item = VariableTableItem(self, iec_path)

   490

        result = self.AddDataConsumer(iec_path.upper(), item)

   491

        if result is not None or force:

   492

            self.Table.InsertItem(idx, item)

   493

            item.SetAxis3D(int(axis3D))

   494

            self.ResetGraphics()

   495

            self.RefreshGrid()

   496

   497

    def GetDebugVariables(self):

   498

        return [item.GetVariable() for item in self.Table.GetData()]

   499

   500

    def GetAxis3D(self):

   501

        return [item.GetVariable() for item in self.Table.GetData() if item.GetAxis3D()]

   502

   503

    def ResetGraphicsValues(self):

   504

        for item in self.Table.GetData():

   505

            item.ResetData()

   506

   507

    def ResetGraphics(self):