beremiz

Fix bug in graphic viewer height when drag'n dropping variable in parallel mode

2013-06-17, Laurent Bessard
242512c56ea1
Fix bug in graphic viewer height when drag'n dropping variable in parallel mode
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
#based on the plcopen standard.
#
#Copyright (C) 2012: Edouard TISSERANT and Laurent BESSARD
#
#See COPYING file for copyrights details.
#
#This library is free software; you can redistribute it and/or
#modify it under the terms of the GNU General Public
#License as published by the Free Software Foundation; either
#version 2.1 of the License, or (at your option) any later version.
#
#This library is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
#General Public License for more details.
#
#You should have received a copy of the GNU General Public
#License along with this library; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from types import TupleType
import wx
import wx.lib.buttons
from editors.DebugViewer import DebugViewer
from controls import CustomGrid, CustomTable
from dialogs.ForceVariableDialog import ForceVariableDialog
from util.BitmapLibrary import GetBitmap
from DebugVariableItem import DebugVariableItem
def GetDebugVariablesTableColnames():
"""
Function returning table column header labels
@return: List of labels [col_label,...]
"""
_ = lambda x : x
return [_("Variable"), _("Value")]
#-------------------------------------------------------------------------------
# Debug Variable Table Panel
#-------------------------------------------------------------------------------
"""
Class that implements a custom table storing value to display in Debug Variable
Table Panel grid
"""
class DebugVariableTable(CustomTable):
def GetValue(self, row, col):
if row < self.GetNumberRows():
return self.GetValueByName(row, self.GetColLabelValue(col, False))
return ""
def SetValue(self, row, col, value):
if col < len(self.colnames):
self.SetValueByName(row, self.GetColLabelValue(col, False), value)
def GetValueByName(self, row, colname):
if row < self.GetNumberRows():
if colname == "Variable":
return self.data[row].GetVariable()
elif colname == "Value":
return self.data[row].GetValue()
return ""
def SetValueByName(self, row, colname, value):
if row < self.GetNumberRows():
if colname == "Variable":
self.data[row].SetVariable(value)
elif colname == "Value":
self.data[row].SetValue(value)
def IsForced(self, row):
if row < self.GetNumberRows():
return self.data[row].IsForced()
return False
def _updateColAttrs(self, grid):
"""
wx.grid.Grid -> update the column attributes to add the
appropriate renderer given the column name.
Otherwise default to the default renderer.
"""
for row in range(self.GetNumberRows()):
for col in range(self.GetNumberCols()):
colname = self.GetColLabelValue(col, False)
if colname == "Value":
if self.IsForced(row):
grid.SetCellTextColour(row, col, wx.BLUE)
else:
grid.SetCellTextColour(row, col, wx.BLACK)
grid.SetReadOnly(row, col, True)
self.ResizeRow(grid, row)
def RefreshValues(self, grid):
for col in xrange(self.GetNumberCols()):
colname = self.GetColLabelValue(col, False)
if colname == "Value":
for row in xrange(self.GetNumberRows()):
grid.SetCellValue(row, col, str(self.data[row].GetValue()))
if self.IsForced(row):
grid.SetCellTextColour(row, col, wx.BLUE)
else:
grid.SetCellTextColour(row, col, wx.BLACK)
def AppendItem(self, item):
self.data.append(item)
def InsertItem(self, idx, item):
self.data.insert(idx, item)
def RemoveItem(self, item):
self.data.remove(item)
def MoveItem(self, idx, new_idx):
self.data.insert(new_idx, self.data.pop(idx))
def GetItem(self, idx):
return self.data[idx]
#-------------------------------------------------------------------------------
# Debug Variable Table Panel Drop Target
#-------------------------------------------------------------------------------
"""
Class that implements a custom drop target class for Debug Variable Table Panel
"""
class DebugVariableTableDropTarget(wx.TextDropTarget):
def __init__(self, parent):
"""
Constructor
@param window: Reference to the Debug Variable Panel
"""
wx.TextDropTarget.__init__(self)
self.ParentWindow = parent
def __del__(self):
"""
Destructor
"""
# Remove reference to Debug Variable Panel
self.ParentWindow = None
def OnDropText(self, x, y, data):
"""
Function called when mouse is dragged over Drop Target
@param x: X coordinate of mouse pointer
@param y: Y coordinate of mouse pointer
@param data: Text associated to drag'n drop
"""
message = None
# Check that data is valid regarding DebugVariablePanel
try:
values = eval(data)
if not isinstance(values, TupleType):
raise ValueError
except:
message = _("Invalid value \"%s\" for debug variable") % data
values = None
# Display message if data is invalid
if message is not None:
wx.CallAfter(self.ShowMessage, message)
# Data contain a reference to a variable to debug
elif values[1] == "debug":
grid = self.ParentWindow.VariablesGrid
# Get row where variable was dropped
x, y = grid.CalcUnscrolledPosition(x, y)
row = grid.YToRow(y - grid.GetColLabelSize())
# If no row found add variable at table end
if row == wx.NOT_FOUND:
row = self.ParentWindow.Table.GetNumberRows()
# Add variable to table
self.ParentWindow.InsertValue(values[0], row, force=True)
def ShowMessage(self, message):
"""
Show error message in Error Dialog
@param message: Error message to display
"""
dialog = wx.MessageDialog(self.ParentWindow,
message,
_("Error"),
wx.OK|wx.ICON_ERROR)
dialog.ShowModal()
dialog.Destroy()
#-------------------------------------------------------------------------------
# Debug Variable Table Panel
#-------------------------------------------------------------------------------
"""
Class that implements a panel displaying debug variable values in a table
"""
class DebugVariableTablePanel(wx.Panel, DebugViewer):
def __init__(self, parent, producer, window):
"""
Constructor
@param parent: Reference to the parent wx.Window
@param producer: Object receiving debug value and dispatching them to
consumers
@param window: Reference to Beremiz frame
"""
wx.Panel.__init__(self, parent, style=wx.SP_3D|wx.TAB_TRAVERSAL)
# Save Reference to Beremiz frame
self.ParentWindow = window
# Variable storing flag indicating that variable displayed in table
# received new value and then table need to be refreshed
self.HasNewData = False
DebugViewer.__init__(self, producer, True)
# Construction of window layout by creating controls and sizers
main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)
main_sizer.AddGrowableCol(0)
main_sizer.AddGrowableRow(1)
button_sizer = wx.BoxSizer(wx.HORIZONTAL)
main_sizer.AddSizer(button_sizer, border=5,
flag=wx.ALIGN_RIGHT|wx.ALL)
# Creation of buttons for navigating in table
for name, bitmap, help in [
("DeleteButton", "remove_element", _("Remove debug variable")),
("UpButton", "up", _("Move debug variable up")),
("DownButton", "down", _("Move debug variable down"))]:
button = wx.lib.buttons.GenBitmapButton(self,
bitmap=GetBitmap(bitmap),
size=wx.Size(28, 28), style=wx.NO_BORDER)
button.SetToolTipString(help)
setattr(self, name, button)
button_sizer.AddWindow(button, border=5, flag=wx.LEFT)
# Creation of grid and associated table
self.VariablesGrid = CustomGrid(self,
size=wx.Size(-1, 150), style=wx.VSCROLL)
# Define grid drop target
self.VariablesGrid.SetDropTarget(DebugVariableTableDropTarget(self))
self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK,
self.OnVariablesGridCellRightClick)
self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK,
self.OnVariablesGridCellLeftClick)
main_sizer.AddWindow(self.VariablesGrid, flag=wx.GROW)
self.Table = DebugVariableTable(self, [],
GetDebugVariablesTableColnames())
self.VariablesGrid.SetTable(self.Table)
self.VariablesGrid.SetButtons({"Delete": self.DeleteButton,
"Up": self.UpButton,
"Down": self.DownButton})
# Definition of function associated to navigation buttons
def _AddVariable(new_row):
return self.VariablesGrid.GetGridCursorRow()
setattr(self.VariablesGrid, "_AddRow", _AddVariable)
def _DeleteVariable(row):
item = self.Table.GetItem(row)
self.RemoveDataConsumer(item)
self.Table.RemoveItem(item)
self.RefreshView()
setattr(self.VariablesGrid, "_DeleteRow", _DeleteVariable)
def _MoveVariable(row, move):
new_row = max(0, min(row + move, self.Table.GetNumberRows() - 1))
if new_row != row:
self.Table.MoveItem(row, new_row)
self.RefreshView()
return new_row
setattr(self.VariablesGrid, "_MoveRow", _MoveVariable)
# Initialization of grid layout
self.VariablesGrid.SetRowLabelSize(0)
self.GridColSizes = [200, 100]
for col in range(self.Table.GetNumberCols()):
attr = wx.grid.GridCellAttr()
attr.SetAlignment(wx.ALIGN_RIGHT, wx.ALIGN_CENTER)
self.VariablesGrid.SetColAttr(col, attr)
self.VariablesGrid.SetColSize(col, self.GridColSizes[col])
self.Table.ResetView(self.VariablesGrid)
self.VariablesGrid.RefreshButtons()
self.SetSizer(main_sizer)
def RefreshNewData(self, *args, **kwargs):
"""
Called to refresh Table according to values received by variables
Can receive any parameters (not used here)
"""
# Refresh 'Value' column of table if new data have been received since
# last refresh
if self.HasNewData:
self.HasNewData = False
self.RefreshView(only_values=True)
DebugViewer.RefreshNewData(self, *args, **kwargs)
def RefreshView(self, only_values=False):
"""
Function refreshing table layout and values
@param only_values: True if only 'Value' column need to be updated
"""
# Block refresh until table layout and values are completely updated
self.Freeze()
# Update only 'value' column from table
if only_values:
self.Table.RefreshValues(self.VariablesGrid)
# Update complete table layout refreshing table navigation buttons
# state according to
else:
self.Table.ResetView(self.VariablesGrid)
self.VariablesGrid.RefreshButtons()
self.Thaw()
def ResetView(self):
"""
Function removing all variables denugged from table
@param only_values: True if only 'Value' column need to be updated
"""
# Unsubscribe all variables debugged
self.UnsubscribeAllDataConsumers()
# Clear table content
self.Table.Empty()
# Update table layout
self.Freeze()
self.Table.ResetView(self.VariablesGrid)
self.VariablesGrid.RefreshButtons()
self.Thaw()
def SubscribeAllDataConsumers(self):
"""
Function refreshing table layout and values
@param only_values: True if only 'Value' column need to be updated
"""
DebugViewer.SubscribeAllDataConsumers(self)
# Navigate through variable displayed in table, removing those that
# doesn't exist anymore in PLC
for item in self.Table.GetData()[:]:
iec_path = item.GetVariable()
if self.GetDataType(iec_path) is None:
self.RemoveDataConsumer(item)
self.Table.RemoveItem(idx)
else:
self.AddDataConsumer(iec_path.upper(), item)
item.RefreshVariableType()
# Update table layout
self.Freeze()
self.Table.ResetView(self.VariablesGrid)
self.VariablesGrid.RefreshButtons()
self.Thaw()
def GetForceVariableMenuFunction(self, item):
"""
Function returning callback function for contextual menu 'Force' item
@param item: Debug Variable item where contextual menu was opened
@return: Callback function
"""
def ForceVariableFunction(event):
# Get variable path and data type
iec_path = item.GetVariable()
iec_type = self.GetDataType(iec_path)
# Return immediately if not data type found
if iec_type is None:
return
# Open dialog for entering value to force variable
dialog = ForceVariableDialog(self, iec_type, str(item.GetValue()))
# If valid value entered, force variable
if dialog.ShowModal() == wx.ID_OK:
self.ForceDataValue(iec_path.upper(), dialog.GetValue())
return ForceVariableFunction
def GetReleaseVariableMenuFunction(self, iec_path):
"""
Function returning callback function for contextual menu 'Release' item
@param iec_path: Debug Variable path where contextual menu was opened
@return: Callback function
"""
def ReleaseVariableFunction(event):
# Release variable
self.ReleaseDataValue(iec_path)
return ReleaseVariableFunction
def OnVariablesGridCellLeftClick(self, event):
"""
Called when left mouse button is pressed on a table cell
@param event: wx.grid.GridEvent
"""
# Initiate a drag and drop if the cell clicked was in 'Variable' column
if self.Table.GetColLabelValue(event.GetCol(), False) == "Variable":
item = self.Table.GetItem(event.GetRow())
data = wx.TextDataObject(str((item.GetVariable(), "debug")))
dragSource = wx.DropSource(self.VariablesGrid)
dragSource.SetData(data)
dragSource.DoDragDrop()
event.Skip()
def OnVariablesGridCellRightClick(self, event):
"""
Called when right mouse button is pressed on a table cell
@param event: wx.grid.GridEvent
"""
# Open a contextual menu if the cell clicked was in 'Value' column
if self.Table.GetColLabelValue(event.GetCol(), False) == "Value":
row = event.GetRow()
# Get variable path
item = self.Table.GetItem(row)
iec_path = item.GetVariable().upper()
# Create contextual menu
menu = wx.Menu(title='')
# Add menu items
for text, enable, callback in [
(_("Force value"), True,
self.GetForceVariableMenuFunction(item)),
# Release menu item is enabled only if variable is forced
(_("Release value"), self.Table.IsForced(row),
self.GetReleaseVariableMenuFunction(iec_path))]:
new_id = wx.NewId()
menu.Append(help='', id=new_id, kind=wx.ITEM_NORMAL, text=text)
menu.Enable(new_id, enable)
self.Bind(wx.EVT_MENU, callback, id=new_id)
# Popup contextual menu
self.PopupMenu(menu)
menu.Destroy()
event.Skip()
def InsertValue(self, iec_path, index=None, force=False, graph=False):
"""
Insert a new variable to debug in table
@param iec_path: Variable path to debug
@param index: Row where insert the variable in table (default None,
insert at last position)
@param force: Force insertion of variable even if not defined in
producer side
@param graph: Values must be displayed in graph canvas (Do nothing,
here for compatibility with Debug Variable Graphic Panel)
"""
# Return immediately if variable is already debugged
for item in self.Table.GetData():
if iec_path == item.GetVariable():
return
# Insert at last position if index not defined
if index is None:
index = self.Table.GetNumberRows()
# Subscribe variable to producer
item = DebugVariableItem(self, iec_path)
result = self.AddDataConsumer(iec_path.upper(), item)
# Insert variable in table if subscription done or insertion forced
if result is not None or force:
self.Table.InsertItem(index, item)
self.RefreshView()
def ResetGraphicsValues(self):
"""
Called to reset graphics values when PLC is started
(Nothing to do because no graphic values here. Defined for
compatibility with Debug Variable Graphic Panel)
"""
pass