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

import wx

    27

    28

from graphics import DebugDataConsumer, DebugViewer

    29

from controls import CustomGrid, CustomTable

    31

    32

def GetDebugVariablesTableColnames():

    33

    _ = lambda x : x

    34

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

    35

    36

class VariableTableItem(DebugDataConsumer):

    37

    38

    def __init__(self, parent, variable, value):

    39

        DebugDataConsumer.__init__(self)

    40

        self.Parent = parent

    41

        self.Variable = variable

    42

        self.Value = value

    43

    44

    def __del__(self):

    45

        self.Parent = None

    46

    47

    def SetVariable(self, variable):

    48

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

    49

            self.Variable = variable

    50

            self.Parent.RefreshGrid()

    51

    52

    def GetVariable(self):

    53

        return self.Variable

    54

    55

    def SetForced(self, forced):

    56

        if self.Forced != forced:

    57

            self.Forced = forced

    58

            self.Parent.HasNewData = True

    59

    60

    def SetValue(self, value):

    61

        if self.Value != value:

    62

            self.Value = value

    63

            self.Parent.HasNewData = True

    64

    65

    def GetValue(self):

    66

        return self.Value

    67

    68

class DebugVariableTable(CustomTable):

    69

    70

    def GetValue(self, row, col):

    71

        if row < self.GetNumberRows():

    72

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

    73

        return ""

    74

    75

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

    76

        if col < len(self.colnames):

    77

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

    78

    79

    def GetValueByName(self, row, colname):

    80

        if row < self.GetNumberRows():

    81

            if colname == "Variable":

    82

                return self.data[row].GetVariable()

    83

            elif colname == "Value":

    84

                return self.data[row].GetValue()

    85

        return ""

    86

    87

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

    88

        if row < self.GetNumberRows():

    89

            if colname == "Variable":

    90

                self.data[row].SetVariable(value)

    91

            elif colname == "Value":

    92

                self.data[row].SetValue(value)

    93

    94

    def IsForced(self, row):

    95

        if row < self.GetNumberRows():

    96

            return self.data[row].IsForced()

    97

        return False

    98

    99

    def _updateColAttrs(self, grid):

   100

        """

   101

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

   102

        appropriate renderer given the column name.

   103

   104

        Otherwise default to the default renderer.

   105

        """

   106

   107

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

   108

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

   109

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

   110

                    if self.IsForced(row):

   111

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

   112

                    else:

   113

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

   114

                grid.SetReadOnly(row, col, True)

   115

            self.ResizeRow(grid, row)

   116

   117

    def AppendItem(self, data):

   118

        self.data.append(data)

   119

   120

    def InsertItem(self, idx, data):

   121

        self.data.insert(idx, data)

   122

   123

    def RemoveItem(self, idx):

   124

        self.data.pop(idx)

   125

   126

    def MoveItem(self, idx, new_idx):

   127

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

   128

   129

    def GetItem(self, idx):

   130

        return self.data[idx]

   131

   132

class DebugVariableDropTarget(wx.TextDropTarget):

   133

   134

    def __init__(self, parent):

   135

        wx.TextDropTarget.__init__(self)

   136

        self.ParentWindow = parent

   137

   138

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

   139

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

   140

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

   141

        if row == wx.NOT_FOUND:

   142

            row = self.ParentWindow.Table.GetNumberRows()

   143

        message = None

   144

        try:

   145

            values = eval(data)

   146

        except:

   147

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

   148

            values = None

   149

        if not isinstance(values, TupleType):

   150

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

   151

            values = None

   152

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

   153

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

   154

        if message is not None:

   155

            wx.CallAfter(self.ShowMessage, message)

   156

   157

    def ShowMessage(self, message):

   158

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

   159

        dialog.ShowModal()

   160

        dialog.Destroy()

   161

   162

class DebugVariablePanel(wx.Panel, DebugViewer):

   163

   165

        wx.Panel.__init__(self, parent, style=wx.TAB_TRAVERSAL)

   166

        DebugViewer.__init__(self, producer, True)

   167

   168

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

   169

        main_sizer.AddGrowableCol(0)

   170

        main_sizer.AddGrowableRow(1)

   171

   172

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   173

        main_sizer.AddSizer(button_sizer, border=5, 

   174

              flag=wx.ALIGN_RIGHT|wx.ALL)

   175

   185

   186

        self.VariablesGrid = CustomGrid(self, size=wx.Size(0, 150), style=wx.VSCROLL)

   187

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self))

   188

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

   189

              self.OnVariablesGridCellRightClick)

   190

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

   191

   192

        self.SetSizer(main_sizer)

   193

   194

        self.HasNewData = False

   195

   196

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

   197

        self.VariablesGrid.SetTable(self.Table)

   201

   202

        def _AddVariable(new_row):

   203

            return self.VariablesGrid.GetGridCursorRow()

   204

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

   205

   206

        def _DeleteVariable(row):

   207

            item = self.Table.GetItem(row)

   208

            self.RemoveDataConsumer(item)

   209

            self.Table.RemoveItem(row)

   210

            self.RefreshGrid()

   211

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

   212

   213

        def _MoveVariable(row, move):

   214

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

   215

            if new_row != row:

   216

                self.Table.MoveItem(row, new_row)

   217

                self.RefreshGrid()

   218

            return new_row

   219

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

   220

   221

        self.VariablesGrid.SetRowLabelSize(0)

   222

   223

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

   224

            attr = wx.grid.GridCellAttr()

   225

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

   226

            self.VariablesGrid.SetColAttr(col, attr)

   227

            self.VariablesGrid.SetColSize(col, 100)

   228

   229

        self.Table.ResetView(self.VariablesGrid)

   230

        self.VariablesGrid.RefreshButtons()

   231

   232

    def RefreshNewData(self):

   233

        if self.HasNewData:

   234

            self.HasNewData = False

   235

            self.RefreshGrid()

   236

        DebugViewer.RefreshNewData(self)

   237

   238

    def RefreshGrid(self):

   239

        self.Freeze()

   240

        self.Table.ResetView(self.VariablesGrid)

   241

        self.VariablesGrid.RefreshButtons()

   242

        self.Thaw()

   243

   244

    def UnregisterObsoleteData(self):

   245

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

   246

        items.reverse()

   247

        for idx, item in items:

   248

            iec_path = item.GetVariable().upper()

   249

            if self.GetDataType(iec_path) is None:

   250

                self.RemoveDataConsumer(item)

   251

                self.Table.RemoveItem(idx)

   252

            else:

   253

                self.AddDataConsumer(iec_path, item)

   254

        self.Freeze()

   255

        self.Table.ResetView(self.VariablesGrid)

   256

        self.VariablesGrid.RefreshButtons()

   257

        self.Thaw()

   258

   259

    def ResetGrid(self):

   260

        self.DeleteDataConsumers()

   261

        self.Table.Empty()

   262

        self.Freeze()

   263

        self.Table.ResetView(self.VariablesGrid)

   264

        self.VariablesGrid.RefreshButtons()

   265

        self.Thaw()

   266

   267

    def GetForceVariableMenuFunction(self, iec_path, item):

   268

        iec_type = self.GetDataType(iec_path)

   269

        def ForceVariableFunction(event):

   270

            if iec_type is not None:

   271

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

   272

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

   273

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

   274

        return ForceVariableFunction

   275

   276

    def GetReleaseVariableMenuFunction(self, iec_path):

   277

        def ReleaseVariableFunction(event):

   278

            self.ReleaseDataValue(iec_path)

   279

        return ReleaseVariableFunction

   280

   281

    def OnVariablesGridCellRightClick(self, event):

   282

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

   283

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

   284

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

   285

   286

            menu = wx.Menu(title='')

   287

   288

            new_id = wx.NewId()

   289

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

   290

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

   291

   292

            new_id = wx.NewId()

   293

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

   294

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

   295

   296

            if self.Table.IsForced(row):

   297

                menu.Enable(new_id, True)

   298

            else:

   299

                menu.Enable(new_id, False)

   300

   301

            self.PopupMenu(menu)

   302

   303

            menu.Destroy()

   304

        event.Skip()

   305

   306

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

   307

        if idx is None:

   308

            idx = self.Table.GetNumberRows()

   309

        for item in self.Table.GetData():

   310

            if iec_path == item.GetVariable():

   311

                return

   312

        item = VariableTableItem(self, iec_path, "")

   313

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

   314

        if result is not None or force:

   315

            self.Table.InsertItem(idx, item)

   316

            self.RefreshGrid()

   317

   318

    def GetDebugVariables(self):

   319

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