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

    26

    27

import wx

    28

import wx.lib.buttons

    29

    30

from editors.DebugViewer import DebugViewer

    31

from controls import CustomGrid, CustomTable

    32

from dialogs.ForceVariableDialog import ForceVariableDialog

    33

from util.BitmapLibrary import GetBitmap

    34

    37

def GetDebugVariablesTableColnames():

    38

    _ = lambda x : x

    39

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

    40

    41

class DebugVariableTable(CustomTable):

    42

    43

    def GetValue(self, row, col):

    44

        if row < self.GetNumberRows():

    45

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

    46

        return ""

    47

    48

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

    49

        if col < len(self.colnames):

    50

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

    51

    52

    def GetValueByName(self, row, colname):

    53

        if row < self.GetNumberRows():

    54

            if colname == "Variable":

    55

                return self.data[row].GetVariable()

    56

            elif colname == "Value":

    57

                return self.data[row].GetValue()

    58

        return ""

    59

    60

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

    61

        if row < self.GetNumberRows():

    62

            if colname == "Variable":

    63

                self.data[row].SetVariable(value)

    64

            elif colname == "Value":

    65

                self.data[row].SetValue(value)

    66

    67

    def IsForced(self, row):

    68

        if row < self.GetNumberRows():

    69

            return self.data[row].IsForced()

    70

        return False

    71

    72

    def IsNumVariable(self, row):

    73

        if row < self.GetNumberRows():

    74

            return self.data[row].IsNumVariable()

    75

        return False

    76

    77

    def _updateColAttrs(self, grid):

    78

        """

    79

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

    80

        appropriate renderer given the column name.

    81

    82

        Otherwise default to the default renderer.

    83

        """

    84

    85

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

    86

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

    87

                colname = self.GetColLabelValue(col, False)

    88

                if colname == "Value":

    89

                    if self.IsForced(row):

    90

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

    91

                    else:

    92

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

    93

                grid.SetReadOnly(row, col, True)

    94

            self.ResizeRow(grid, row)

    95

    96

    def AppendItem(self, data):

    97

        self.data.append(data)

    98

    99

    def InsertItem(self, idx, data):

   100

        self.data.insert(idx, data)

   101

   102

    def RemoveItem(self, idx):

   103

        self.data.pop(idx)

   104

   105

    def MoveItem(self, idx, new_idx):

   106

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

   107

   108

    def GetItem(self, idx):

   109

        return self.data[idx]

   110

   111

class DebugVariableTableDropTarget(wx.TextDropTarget):

   112

   113

    def __init__(self, parent):

   114

        wx.TextDropTarget.__init__(self)

   115

        self.ParentWindow = parent

   116

   117

    def __del__(self):

   118

        self.ParentWindow = None

   119

   120

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

   121

        message = None

   122

        try:

   123

            values = eval(data)

   124

        except:

   125

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

   126

            values = None

   127

        if not isinstance(values, TupleType):

   128

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

   129

            values = None

   130

   131

        if message is not None:

   132

            wx.CallAfter(self.ShowMessage, message)

   133

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

   134

            grid = self.ParentWindow.VariablesGrid

   135

            x, y = grid.CalcUnscrolledPosition(x, y)

   136

            row = grid.YToRow(y - grid.GetColLabelSize())

   137

            if row == wx.NOT_FOUND:

   138

                row = self.ParentWindow.Table.GetNumberRows()

   139

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

   140

   141

    def ShowMessage(self, message):

   142

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

   143

        dialog.ShowModal()

   144

        dialog.Destroy()

   145

   146

class DebugVariableTablePanel(wx.Panel, DebugViewer):

   147

   148

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

   149

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

   150

   151

        self.ParentWindow = window

   152

   153

        self.HasNewData = False

   154

   155

        DebugViewer.__init__(self, producer, True)

   156

   157

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

   158

        main_sizer.AddGrowableCol(0)

   159

        main_sizer.AddGrowableRow(1)

   160

   161

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   162

        main_sizer.AddSizer(button_sizer, border=5, 

   163

              flag=wx.ALIGN_RIGHT|wx.ALL)

   164

   165

        for name, bitmap, help in [

   166

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

   167

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

   168

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

   169

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

   170

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

   171

            button.SetToolTipString(help)

   172

            setattr(self, name, button)

   173

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

   174

   175

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

   176

        self.VariablesGrid.SetDropTarget(DebugVariableTableDropTarget(self))

   177

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

   178

              self.OnVariablesGridCellRightClick)

   179

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

   180

              self.OnVariablesGridCellLeftClick)

   181

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

   182

   183

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

   184

        self.VariablesGrid.SetTable(self.Table)

   185

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

   186

                                       "Up": self.UpButton,

   187

                                       "Down": self.DownButton})

   188

   189

        def _AddVariable(new_row):

   190

            return self.VariablesGrid.GetGridCursorRow()

   191

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

   192

   193

        def _DeleteVariable(row):

   194

            item = self.Table.GetItem(row)

   195

            self.RemoveDataConsumer(item)

   196

            self.Table.RemoveItem(row)

   197

            self.RefreshView()

   198

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

   199

   200

        def _MoveVariable(row, move):

   201

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

   202

            if new_row != row:

   203

                self.Table.MoveItem(row, new_row)

   204

                self.RefreshView()

   205

            return new_row

   206

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

   207

   208

        self.VariablesGrid.SetRowLabelSize(0)

   209

   210

        self.GridColSizes = [200, 100]

   211

   212

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

   213

            attr = wx.grid.GridCellAttr()

   214

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

   215

            self.VariablesGrid.SetColAttr(col, attr)

   216

            self.VariablesGrid.SetColSize(col, self.GridColSizes[col])

   217

   218

        self.Table.ResetView(self.VariablesGrid)

   219

        self.VariablesGrid.RefreshButtons()

   220

   221

        self.SetSizer(main_sizer)

   222

   223

    def RefreshNewData(self, *args, **kwargs):

   224

        if self.HasNewData:

   225

            self.HasNewData = False

   226

            self.RefreshView(only_values=True)

   227

        DebugViewer.RefreshNewData(self, *args, **kwargs)

   228

   229

    def RefreshView(self, only_values=False):

   230

        self.Freeze()

   231

   232

        if only_values:

   233

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

   234

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

   235

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

   236

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

   237

                        if self.Table.IsForced(row):

   238

                            self.VariablesGrid.SetCellTextColour(row, col, wx.BLUE)

   239

                        else:

   240

                            self.VariablesGrid.SetCellTextColour(row, col, wx.BLACK)

   241

        else:

   242

            self.Table.ResetView(self.VariablesGrid)

   243

        self.VariablesGrid.RefreshButtons()

   244

   245

        self.Thaw()

   246

   247

    def UnregisterObsoleteData(self):

   248

        self.SubscribeAllDataConsumers()

   249

   250

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

   251

        items.reverse()

   252

        for idx, item in items:

   253

            iec_path = item.GetVariable()

   254

            if self.GetDataType(iec_path) is None:

   255

                self.RemoveDataConsumer(item)

   256

                self.Table.RemoveItem(idx)

   257

            else:

   258

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

   259

                item.RefreshVariableType()

   260

        self.Freeze()

   261

        self.Table.ResetView(self.VariablesGrid)

   262

        self.VariablesGrid.RefreshButtons()

   263

        self.Thaw()

   264

   265

    def ResetView(self):

   266

        self.UnsubscribeAllDataConsumers()

   267

   268

        self.Table.Empty()

   269

        self.Freeze()

   270

        self.Table.ResetView(self.VariablesGrid)

   271

        self.VariablesGrid.RefreshButtons()

   272

        self.Thaw()

   273

   274

    def GetForceVariableMenuFunction(self, iec_path, item):

   275

        iec_type = self.GetDataType(iec_path)

   276

        def ForceVariableFunction(event):

   277

            if iec_type is not None:

   278

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

   279

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

   280

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

   281

        return ForceVariableFunction

   282

   283

    def GetReleaseVariableMenuFunction(self, iec_path):

   284

        def ReleaseVariableFunction(event):

   285

            self.ReleaseDataValue(iec_path)

   286

        return ReleaseVariableFunction

   287

   288

    def OnVariablesGridCellLeftClick(self, event):

   289

        if event.GetCol() == 0:

   290

            row = event.GetRow()

   291

            data = wx.TextDataObject(str((self.Table.GetValueByName(row, "Variable"), "debug")))

   292

            dragSource = wx.DropSource(self.VariablesGrid)

   293

            dragSource.SetData(data)

   294

            dragSource.DoDragDrop()

   295

        event.Skip()

   296

   297

    def OnVariablesGridCellRightClick(self, event):

   298

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

   299

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

   300

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

   301

   302

            menu = wx.Menu(title='')

   303

   304

            new_id = wx.NewId()

   305

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

   306

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

   307

   308

            new_id = wx.NewId()

   309

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

   310

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

   311

   312

            if self.Table.IsForced(row):

   313

                menu.Enable(new_id, True)

   314

            else:

   315

                menu.Enable(new_id, False)

   316

   317

            self.PopupMenu(menu)

   318

   319

            menu.Destroy()

   320

        event.Skip()

   321

   322

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

   323

        for item in self.Table.GetData():

   324

            if iec_path == item.GetVariable():

   325

                return

   326

        if idx is None:

   327

            idx = self.Table.GetNumberRows()

   328

        item = DebugVariableItem(self, iec_path)

   329

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

   330

        if result is not None or force:

   331

            self.Table.InsertItem(idx, item)

   332

            self.RefreshView()

   333

   334

    def ResetGraphicsValues(self):

   335

        pass

   336