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

    28

    29

import wx

    30

import wx.lib.buttons

    38

from controls import CustomGrid, CustomTable

    39

from dialogs.ForceVariableDialog import ForceVariableDialog

    40

from util.BitmapLibrary import GetBitmap

    41

    42

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

    43

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

    44

    45

def GetDebugVariablesTableColnames():

    46

    _ = lambda x : x

    48

    49

class VariableTableItem(DebugDataConsumer):

    50

    52

        DebugDataConsumer.__init__(self)

    53

        self.Parent = parent

    54

        self.Variable = variable

    58

    59

    def __del__(self):

    60

        self.Parent = None

    61

    62

    def SetVariable(self, variable):

    63

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

    64

            self.Variable = variable

    66

            self.Parent.RefreshGrid()

    67

    68

    def GetVariable(self):

    69

        return self.Variable

    70

    97

    def SetForced(self, forced):

    98

        if self.Forced != forced:

    99

            self.Forced = forced

   100

            self.Parent.HasNewData = True

   101

   102

    def SetValue(self, value):

   103

        if self.Value != value:

   104

            self.Value = value

   105

            self.Parent.HasNewData = True

   106

   107

    def GetValue(self):

   109

            return "'%s'" % self.Value

   111

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

   114

        return self.Value

   115

   125

class DebugVariableTable(CustomTable):

   126

   127

    def GetValue(self, row, col):

   128

        if row < self.GetNumberRows():

   129

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

   130

        return ""

   131

   132

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

   133

        if col < len(self.colnames):

   134

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

   135

   136

    def GetValueByName(self, row, colname):

   137

        if row < self.GetNumberRows():

   138

            if colname == "Variable":

   139

                return self.data[row].GetVariable()

   140

            elif colname == "Value":

   141

                return self.data[row].GetValue()

   144

        return ""

   145

   146

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

   147

        if row < self.GetNumberRows():

   148

            if colname == "Variable":

   149

                self.data[row].SetVariable(value)

   150

            elif colname == "Value":

   151

                self.data[row].SetValue(value)

   154

   155

    def IsForced(self, row):

   156

        if row < self.GetNumberRows():

   157

            return self.data[row].IsForced()

   158

        return False

   159

   165

    def _updateColAttrs(self, grid):

   166

        """

   167

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

   168

        appropriate renderer given the column name.

   169

   170

        Otherwise default to the default renderer.

   171

        """

   172

   173

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

   174

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

   181

                    else:

   190

            self.ResizeRow(grid, row)

   191

   192

    def AppendItem(self, data):

   193

        self.data.append(data)

   194

   195

    def InsertItem(self, idx, data):

   196

        self.data.insert(idx, data)

   197

   198

    def RemoveItem(self, idx):

   199

        self.data.pop(idx)

   200

   201

    def MoveItem(self, idx, new_idx):

   202

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

   203

   204

    def GetItem(self, idx):

   205

        return self.data[idx]

   206

   207

class DebugVariableDropTarget(wx.TextDropTarget):

   208

   209

    def __init__(self, parent):

   210

        wx.TextDropTarget.__init__(self)

   211

        self.ParentWindow = parent

   212

   213

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

   214

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

   215

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

   216

        if row == wx.NOT_FOUND:

   217

            row = self.ParentWindow.Table.GetNumberRows()

   218

        message = None

   219

        try:

   220

            values = eval(data)

   221

        except:

   222

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

   223

            values = None

   224

        if not isinstance(values, TupleType):

   225

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

   226

            values = None

   227

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

   228

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

   229

        if message is not None:

   230

            wx.CallAfter(self.ShowMessage, message)

   231

   232

    def ShowMessage(self, message):

   233

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

   234

        dialog.ShowModal()

   235

        dialog.Destroy()

   236

   240

   241

    def __init__(self, parent, producer):

   243

        DebugViewer.__init__(self, producer, True)

   244

   254

   255

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   257

              flag=wx.ALIGN_RIGHT|wx.ALL)

   258

   259

        for name, bitmap, help in [

   260

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

   261

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

   262

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

   264

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

   265

            button.SetToolTipString(help)

   266

            setattr(self, name, button)

   267

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

   268

   270

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self))

   271

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

   272

              self.OnVariablesGridCellRightClick)

   278

   279

        self.HasNewData = False

   280

   281

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

   282

        self.VariablesGrid.SetTable(self.Table)

   283

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

   284

                                       "Up": self.UpButton,

   285

                                       "Down": self.DownButton})

   286

   287

        def _AddVariable(new_row):

   288

            return self.VariablesGrid.GetGridCursorRow()

   289

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

   290

   291

        def _DeleteVariable(row):

   292

            item = self.Table.GetItem(row)

   293

            self.RemoveDataConsumer(item)

   294

            self.Table.RemoveItem(row)

   296

            self.RefreshGrid()

   297

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

   298

   299

        def _MoveVariable(row, move):

   300

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

   301

            if new_row != row:

   302

                self.Table.MoveItem(row, new_row)

   304

                self.RefreshGrid()

   305

            return new_row

   306

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

   307

   308

        self.VariablesGrid.SetRowLabelSize(0)

   309

   310

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

   311

            attr = wx.grid.GridCellAttr()

   316

            self.VariablesGrid.SetColAttr(col, attr)

   317

            self.VariablesGrid.SetColSize(col, 100)

   318

   319

        self.Table.ResetView(self.VariablesGrid)

   320

        self.VariablesGrid.RefreshButtons()

   360

   361

    def RefreshNewData(self):

   362

        if self.HasNewData:

   363

            self.HasNewData = False

   365

        DebugViewer.RefreshNewData(self)

   366

   368

        self.Freeze()

   376

        self.VariablesGrid.RefreshButtons()

   398

        self.Thaw()

   400

    def UnregisterObsoleteData(self):

   401

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

   402

        items.reverse()

   403

        for idx, item in items:

   404

            iec_path = item.GetVariable().upper()

   405

            if self.GetDataType(iec_path) is None:

   406

                self.RemoveDataConsumer(item)

   407

                self.Table.RemoveItem(idx)

   408

            else:

   409

                self.AddDataConsumer(iec_path, item)

   411

        self.Freeze()

   412

        self.Table.ResetView(self.VariablesGrid)

   413

        self.VariablesGrid.RefreshButtons()

   414

        self.Thaw()

   415

   416

    def ResetGrid(self):

   417

        self.DeleteDataConsumers()

   418

        self.Table.Empty()

   419

        self.Freeze()

   420

        self.Table.ResetView(self.VariablesGrid)

   421

        self.VariablesGrid.RefreshButtons()

   422

        self.Thaw()

   424

   425

    def GetForceVariableMenuFunction(self, iec_path, item):

   426

        iec_type = self.GetDataType(iec_path)

   427

        def ForceVariableFunction(event):

   428

            if iec_type is not None:

   429

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

   430

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

   431

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

   432

        return ForceVariableFunction

   433

   434

    def GetReleaseVariableMenuFunction(self, iec_path):

   435

        def ReleaseVariableFunction(event):

   436

            self.ReleaseDataValue(iec_path)

   437

        return ReleaseVariableFunction

   438

   439

    def OnVariablesGridCellRightClick(self, event):

   440

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

   441

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

   442

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

   443

   444

            menu = wx.Menu(title='')

   445

   446

            new_id = wx.NewId()

   447

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

   448

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

   449

   450

            new_id = wx.NewId()

   451

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

   452

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

   453

   454

            if self.Table.IsForced(row):

   455

                menu.Enable(new_id, True)

   456

            else:

   457

                menu.Enable(new_id, False)

   458

   459

            self.PopupMenu(menu)

   460

   461

            menu.Destroy()

   462

        event.Skip()

   463

   471

        if idx is None:

   472

            idx = self.Table.GetNumberRows()

   473

        for item in self.Table.GetData():

   474

            if iec_path == item.GetVariable():

   475

                return

   477

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

   478

        if result is not None or force:

   479

            self.Table.InsertItem(idx, item)

   482

            self.RefreshGrid()

   484

    def GetDebugVariables(self):

   485

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