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

    26

    27

from graphics import DebugDataConsumer, DebugViewer

    28

from controls import CustomGrid, CustomTable

    29

    30

def GetDebugVariablesTableColnames():

    31

    _ = lambda x : x

    32

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

    33

    34

class VariableTableItem(DebugDataConsumer):

    35

    36

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

    37

        DebugDataConsumer.__init__(self)

    38

        self.Parent = parent

    39

        self.Variable = variable

    40

        self.Value = value

    41

    42

    def __del__(self):

    43

        self.Parent = None

    44

    45

    def SetVariable(self, variable):

    46

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

    47

            self.Variable = variable

    48

            self.Parent.RefreshGrid()

    49

    50

    def GetVariable(self):

    51

        return self.Variable

    52

    53

    def SetForced(self, forced):

    54

        if self.Forced != forced:

    55

            self.Forced = forced

    56

            self.Parent.HasNewData = True

    57

    58

    def SetValue(self, value):

    59

        if self.Value != value:

    60

            self.Value = value

    61

            self.Parent.HasNewData = True

    62

    63

    def GetValue(self):

    64

        return self.Value

    65

    66

class DebugVariableTable(CustomTable):

    67

    68

    def GetValue(self, row, col):

    69

        if row < self.GetNumberRows():

    70

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

    71

        return ""

    72

    73

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

    74

        if col < len(self.colnames):

    75

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

    76

    77

    def GetValueByName(self, row, colname):

    78

        if row < self.GetNumberRows():

    79

            if colname == "Variable":

    80

                return self.data[row].GetVariable()

    81

            elif colname == "Value":

    82

                return self.data[row].GetValue()

    83

        return ""

    84

    85

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

    86

        if row < self.GetNumberRows():

    87

            if colname == "Variable":

    88

                self.data[row].SetVariable(value)

    89

            elif colname == "Value":

    90

                self.data[row].SetValue(value)

    91

    92

    def IsForced(self, row):

    93

        if row < self.GetNumberRows():

    94

            return self.data[row].IsForced()

    95

        return False

    96

    97

    def _updateColAttrs(self, grid):

    98

        """

    99

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

   100

        appropriate renderer given the column name.

   101

   102

        Otherwise default to the default renderer.

   103

        """

   104

   105

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

   106

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

   107

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

   108

                    if self.IsForced(row):

   109

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

   110

                    else:

   111

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

   112

                grid.SetReadOnly(row, col, True)

   113

            self.ResizeRow(grid, row)

   114

   115

    def AppendItem(self, data):

   116

        self.data.append(data)

   117

   118

    def InsertItem(self, idx, data):

   119

        self.data.insert(idx, data)

   120

   121

    def RemoveItem(self, idx):

   122

        self.data.pop(idx)

   123

   124

    def MoveItem(self, idx, new_idx):

   125

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

   126

   127

    def GetItem(self, idx):

   128

        return self.data[idx]

   129

   130

class DebugVariableDropTarget(wx.TextDropTarget):

   131

   132

    def __init__(self, parent):

   133

        wx.TextDropTarget.__init__(self)

   134

        self.ParentWindow = parent

   135

   136

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

   137

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

   138

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

   139

        if row == wx.NOT_FOUND:

   140

            row = self.ParentWindow.Table.GetNumberRows()

   141

        message = None

   142

        try:

   143

            values = eval(data)

   144

        except:

   145

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

   146

            values = None

   147

        if not isinstance(values, TupleType):

   148

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

   149

            values = None

   150

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

   151

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

   152

        if message is not None:

   153

            wx.CallAfter(self.ShowMessage, message)

   154

   155

    def ShowMessage(self, message):

   156

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

   157

        dialog.ShowModal()

   158

        dialog.Destroy()

   159

   160

class DebugVariablePanel(wx.Panel, DebugViewer):

   161

   162

    def __init__(self, parent, window, producer):

   163

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

   164

        DebugViewer.__init__(self, producer, True)

   165

   166

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

   167

        main_sizer.AddGrowableCol(0)

   168

        main_sizer.AddGrowableRow(1)

   169

   170

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   171

        main_sizer.AddSizer(button_sizer, border=5, 

   172

              flag=wx.ALIGN_RIGHT|wx.ALL)

   173

   174

        up_button = wx.Button(self, label='^', size=wx.Size(28, 28))

   175

        button_sizer.AddWindow(up_button, border=5, flag=wx.RIGHT)

   176

   177

        down_button = wx.Button(self, label='v', size=wx.Size(28, 28))

   178

        button_sizer.AddWindow(down_button, border=5, flag=wx.RIGHT)

   179

   180

        delete_button = wx.Button(self, label=_('Delete'), size=wx.DefaultSize)

   181

        button_sizer.AddWindow(delete_button)

   182

   183

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

   184

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self))

   185

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

   186

              self.OnVariablesGridCellRightClick)

   187

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

   188

   189

        self.SetSizer(main_sizer)

   190

   191

        self.HasNewData = False

   192

   193

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

   194

        self.VariablesGrid.SetTable(self.Table)

   195

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

   196

                                       "Up": up_button,

   197

                                       "Down": down_button})

   198

   199

        def _AddVariable(new_row):

   200

            return self.VariablesGrid.GetGridCursorRow()

   201

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

   202

   203

        def _DeleteVariable(row):

   204

            item = self.Table.GetItem(row)

   205

            self.RemoveDataConsumer(item)

   206

            self.Table.RemoveItem(row)

   207

            self.RefreshGrid()

   208

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

   209

   210

        def _MoveVariable(row, move):

   211

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

   212

            if new_row != row:

   213

                self.Table.MoveItem(row, new_row)

   214

                self.RefreshGrid()

   215

            return new_row

   216

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

   217

   218

        self.VariablesGrid.SetRowLabelSize(0)

   219

   220

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

   221

            attr = wx.grid.GridCellAttr()

   222

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

   223

            self.VariablesGrid.SetColAttr(col, attr)

   224

            self.VariablesGrid.SetColSize(col, 100)

   225

   226

        self.Table.ResetView(self.VariablesGrid)

   227

        self.VariablesGrid.RefreshButtons()

   228

   229

    def RefreshNewData(self):

   230

        if self.HasNewData:

   231

            self.HasNewData = False

   232

            self.RefreshGrid()

   233

        DebugViewer.RefreshNewData(self)

   234

   235

    def RefreshGrid(self):

   236

        self.Freeze()

   237

        self.Table.ResetView(self.VariablesGrid)

   238

        self.VariablesGrid.RefreshButtons()

   239

        self.Thaw()

   240

   241

    def UnregisterObsoleteData(self):

   242

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

   243

        items.reverse()

   244

        for idx, item in items:

   245

            iec_path = item.GetVariable().upper()

   246

            if self.GetDataType(iec_path) is None:

   247

                self.RemoveDataConsumer(item)

   248

                self.Table.RemoveItem(idx)

   249

            else:

   250

                self.AddDataConsumer(iec_path, item)

   251

        self.Freeze()

   252

        self.Table.ResetView(self.VariablesGrid)

   253

        self.VariablesGrid.RefreshButtons()

   254

        self.Thaw()

   255

   256

    def ResetGrid(self):

   257

        self.DeleteDataConsumers()

   258

        self.Table.Empty()

   259

        self.Freeze()

   260

        self.Table.ResetView(self.VariablesGrid)

   261

        self.VariablesGrid.RefreshButtons()

   262

        self.Thaw()

   263

   264

    def GetForceVariableMenuFunction(self, iec_path, item):

   265

        iec_type = self.GetDataType(iec_path)

   266

        def ForceVariableFunction(event):

   267

            if iec_type is not None:

   268

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

   269

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

   270

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

   271

        return ForceVariableFunction

   272

   273

    def GetReleaseVariableMenuFunction(self, iec_path):

   274

        def ReleaseVariableFunction(event):

   275

            self.ReleaseDataValue(iec_path)

   276

        return ReleaseVariableFunction

   277

   278

    def OnVariablesGridCellRightClick(self, event):

   279

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

   280

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

   281

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

   282

   283

            menu = wx.Menu(title='')

   284

   285

            new_id = wx.NewId()

   286

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

   287

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

   288

   289

            new_id = wx.NewId()

   290

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

   291

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

   292

   293

            if self.Table.IsForced(row):

   294

                menu.Enable(new_id, True)

   295

            else:

   296

                menu.Enable(new_id, False)

   297

   298

            self.PopupMenu(menu)

   299

   300

            menu.Destroy()

   301

        event.Skip()

   302

   303

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

   304

        if idx is None:

   305

            idx = self.Table.GetNumberRows()

   306

        for item in self.Table.GetData():

   307

            if iec_path == item.GetVariable():

   308

                return

   309

        item = VariableTableItem(self, iec_path, "")

   310

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

   311

        if result is not None or force:

   312

            self.Table.InsertItem(idx, item)

   313

            self.RefreshGrid()

   314

   315

    def GetDebugVariables(self):

   316

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