#!/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) 2007: 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
import wx
import wx.grid
from dialogs import DurationEditorDialog
from controls import CustomGrid
#-------------------------------------------------------------------------------
# Configuration Editor class
#-------------------------------------------------------------------------------
[ID_CONFIGURATIONEDITOR,
] = [wx.NewId() for _init_ctrls in range(1)]
class ConfigurationEditor(wx.Panel):
def _init_ctrls(self, prnt):
wx.Panel.__init__(self, id=ID_CONFIGURATIONEDITOR, name='', parent=prnt,
size=wx.Size(0, 0), style=wx.SUNKEN_BORDER)
def __init__(self, parent, tagname, window, controler):
self._init_ctrls(parent)
self.ParentWindow = window
self.Controler = controler
self.TagName = tagname
def SetTagName(self, tagname):
self.TagName = tagname
def GetTagName(self):
return self.TagName
def IsViewing(self, tagname):
return self.TagName == tagname
def IsDebugging(self):
return False
def SetMode(self, mode):
pass
def ResetBuffer(self):
pass
def RefreshView(self):
pass
def RefreshScaling(self, refresh=True):
pass
def ClearHighlights(self, highlight_type=None):
pass
#-------------------------------------------------------------------------------
# Resource Editor class
#-------------------------------------------------------------------------------
def GetTasksTableColnames():
_ = lambda x : x
return [_("Name"), _("Triggering"), _("Single"), _("Interval"), _("Priority")]
def GetTaskTriggeringOptions():
_ = lambda x : x
return [_("Interrupt"), _("Cyclic")]
TASKTRIGGERINGOPTIONS_DICT = dict([(_(option), option) for option in GetTaskTriggeringOptions()])
def GetInstancesTableColnames():
_ = lambda x : x
return [_("Name"), _("Type"), _("Task")]
class ResourceTable(wx.grid.PyGridTableBase):
"""
A custom wx.grid.Grid Table using user supplied data
"""
def __init__(self, parent, data, colnames):
# The base class must be initialized *first*
wx.grid.PyGridTableBase.__init__(self)
self.data = data
self.colnames = colnames
self.Highlights = {}
self.Parent = parent
self.ColAlignements = []
self.ColSizes = []
# XXX
# we need to store the row length and collength to
# see if the table has changed size
self._rows = self.GetNumberRows()
self._cols = self.GetNumberCols()
def GetColAlignements(self):
return self.ColAlignements
def SetColAlignements(self, list):
self.ColAlignements = list
def GetColSizes(self):
return self.ColSizes
def SetColSizes(self, list):
self.ColSizes = list
def GetNumberCols(self):
return len(self.colnames)
def GetNumberRows(self):
return len(self.data)
def GetColLabelValue(self, col, translate=True):
if col < len(self.colnames):
if translate:
return _(self.colnames[col])
return self.colnames[col]
def GetRowLabelValues(self, row, translate=True):
return row
def GetValue(self, row, col):
if row < self.GetNumberRows():
colname = self.GetColLabelValue(col, False)
value = str(self.data[row].get(colname, ""))
if colname == "Triggering":
return _(value)
return value
def GetValueByName(self, row, colname):
return self.data[row].get(colname)
def SetValue(self, row, col, value):
if col < len(self.colnames):
colname = self.GetColLabelValue(col, False)
if colname == "Triggering":
value = TASKTRIGGERINGOPTIONS_DICT[value]
self.data[row][colname] = value
def SetValueByName(self, row, colname, value):
if colname in self.colnames:
self.data[row][colname] = value
def ResetView(self, grid):
"""
(wx.grid.Grid) -> Reset the grid view. Call this to
update the grid if rows and columns have been added or deleted
"""
grid.BeginBatch()
for current, new, delmsg, addmsg in [
(self._rows, self.GetNumberRows(), wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED),
(self._cols, self.GetNumberCols(), wx.grid.GRIDTABLE_NOTIFY_COLS_DELETED, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED),
]:
if new < current:
msg = wx.grid.GridTableMessage(self,delmsg,new,current-new)
grid.ProcessTableMessage(msg)
elif new > current:
msg = wx.grid.GridTableMessage(self,addmsg,new-current)
grid.ProcessTableMessage(msg)
self.UpdateValues(grid)
grid.EndBatch()
self._rows = self.GetNumberRows()
self._cols = self.GetNumberCols()
# update the column rendering scheme
self._updateColAttrs(grid)
# update the scrollbars and the displayed part of the grid
grid.AdjustScrollbars()
grid.ForceRefresh()
def UpdateValues(self, grid):
"""Update all displayed values"""
# This sends an event to the grid table to update all of the values
msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES)
grid.ProcessTableMessage(msg)
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 col in range(self.GetNumberCols()):
attr = wx.grid.GridCellAttr()
attr.SetAlignment(self.ColAlignements[col], wx.ALIGN_CENTRE)
grid.SetColAttr(col, attr)
grid.SetColSize(col, self.ColSizes[col])
for row in range(self.GetNumberRows()):
row_highlights = self.Highlights.get(row, {})
for col in range(self.GetNumberCols()):
editor = None
renderer = None
colname = self.GetColLabelValue(col, False)
grid.SetReadOnly(row, col, False)
if colname == "Name":
editor = wx.grid.GridCellTextEditor()
renderer = wx.grid.GridCellStringRenderer()
elif colname == "Interval":
editor = DurationCellEditor(self)
renderer = wx.grid.GridCellStringRenderer()
if self.GetValueByName(row, "Triggering") != "Cyclic":
grid.SetReadOnly(row, col, True)
elif colname == "Single":
editor = wx.grid.GridCellChoiceEditor()
editor.SetParameters(self.Parent.VariableList)
if self.GetValueByName(row, "Triggering") != "Interrupt":
grid.SetReadOnly(row, col, True)
elif colname == "Triggering":
editor = wx.grid.GridCellChoiceEditor()
editor.SetParameters(",".join([""] + map(_, GetTaskTriggeringOptions())))
elif colname == "Type":
editor = wx.grid.GridCellChoiceEditor()
editor.SetParameters(self.Parent.TypeList)
elif colname == "Priority":
editor = wx.grid.GridCellNumberEditor()
editor.SetParameters("0,65535")
elif colname == "Task":
editor = wx.grid.GridCellChoiceEditor()
editor.SetParameters(self.Parent.TaskList)
grid.SetCellEditor(row, col, editor)
grid.SetCellRenderer(row, col, renderer)
highlight_colours = row_highlights.get(colname.lower(), [(wx.WHITE, wx.BLACK)])[-1]
grid.SetCellBackgroundColour(row, col, highlight_colours[0])
grid.SetCellTextColour(row, col, highlight_colours[1])
if wx.Platform == '__WXMSW__':
grid.SetRowMinimalHeight(row, 20)
else:
grid.SetRowMinimalHeight(row, 28)
grid.AutoSizeRow(row, False)
def SetData(self, data):
self.data = data
def GetData(self):
return self.data
def GetCurrentIndex(self):
return self.CurrentIndex
def SetCurrentIndex(self, index):
self.CurrentIndex = index
def AppendRow(self, row_content):
self.data.append(row_content)
def InsertRow(self, index, row_content):
self.data.insert(index, row_content)
def RemoveRow(self, row_index):
self.data.pop(row_index)
def MoveRow(self, row_index, move):
new_index = max(0, min(row_index + move, len(self.data) - 1))
if new_index != row_index:
self.data.insert(new_index, self.data.pop(row_index))
return new_index
def Empty(self):
self.data = []
#-------------------------------------------------------------------------------
# Highlights showing functions
#-------------------------------------------------------------------------------
def AddHighlight(self, infos, highlight_type):
row_highlights = self.Highlights.setdefault(infos[0], {})
col_highlights = row_highlights.setdefault(infos[1], [])
col_highlights.append(highlight_type)
def ClearHighlights(self, highlight_type=None):
if highlight_type is None:
self.Highlights = {}
else:
for row, row_highlights in self.Highlights.iteritems():
row_items = row_highlights.items()
for col, col_highlights in row_items:
if highlight_type in col_highlights:
col_highlights.remove(highlight_type)
if len(col_highlights) == 0:
row_highlights.pop(col)
[ID_RESOURCEEDITOR, ID_RESOURCEEDITORSTATICTEXT1,
ID_RESOURCEEDITORSTATICTEXT2, ID_RESOURCEEDITORINSTANCESGRID,
ID_RESOURCEEDITORTASKSGRID, ID_RESOURCEEDITORADDINSTANCEBUTTON,
ID_RESOURCEEDITORDELETEINSTANCEBUTTON, ID_RESOURCEEDITORUPINSTANCEBUTTON,
ID_RESOURCEEDITORDOWNINSTANCEBUTTON, ID_RESOURCEEDITORADDTASKBUTTON,
ID_RESOURCEEDITORDELETETASKBUTTON, ID_RESOURCEEDITORUPTASKBUTTON,
ID_RESOURCEEDITORDOWNTASKBUTTON,
] = [wx.NewId() for _init_ctrls in range(13)]
class ResourceEditor(wx.Panel):
if wx.VERSION < (2, 6, 0):
def Bind(self, event, function, id = None):
if id is not None:
event(self, id, function)
else:
event(self, function)
def _init_coll_InstancesSizer_Growables(self, parent):
parent.AddGrowableCol(0)
parent.AddGrowableRow(1)
def _init_coll_InstancesSizer_Items(self, parent):
parent.AddSizer(self.InstancesButtonsSizer, 0, border=0, flag=wx.GROW)
parent.AddWindow(self.InstancesGrid, 0, border=0, flag=wx.GROW)
def _init_coll_InstancesButtonsSizer_Growables(self, parent):
parent.AddGrowableCol(0)
parent.AddGrowableRow(0)
def _init_coll_InstancesButtonsSizer_Items(self, parent):
parent.AddWindow(self.staticText2, 0, border=0, flag=wx.ALIGN_BOTTOM)
parent.AddWindow(self.AddInstanceButton, 0, border=0, flag=0)
parent.AddWindow(self.DeleteInstanceButton, 0, border=0, flag=0)
parent.AddWindow(self.UpInstanceButton, 0, border=0, flag=0)
parent.AddWindow(self.DownInstanceButton, 0, border=0, flag=0)
def _init_coll_TasksSizer_Growables(self, parent):
parent.AddGrowableCol(0)
parent.AddGrowableRow(1)
def _init_coll_TasksSizer_Items(self, parent):
parent.AddSizer(self.TasksButtonsSizer, 0, border=0, flag=wx.GROW)
parent.AddWindow(self.TasksGrid, 0, border=0, flag=wx.GROW)
def _init_coll_TasksButtonsSizer_Growables(self, parent):
parent.AddGrowableCol(0)
parent.AddGrowableRow(0)
def _init_coll_TasksButtonsSizer_Items(self, parent):
parent.AddWindow(self.staticText1, 0, border=0, flag=wx.ALIGN_BOTTOM)
parent.AddWindow(self.AddTaskButton, 0, border=0, flag=0)
parent.AddWindow(self.DeleteTaskButton, 0, border=0, flag=0)
parent.AddWindow(self.UpTaskButton, 0, border=0, flag=0)
parent.AddWindow(self.DownTaskButton, 0, border=0, flag=0)
def _init_coll_MainGridSizer_Items(self, parent):
parent.AddSizer(self.TasksSizer, 0, border=5, flag=wx.GROW|wx.TOP|wx.LEFT|wx.RIGHT)
parent.AddSizer(self.InstancesSizer, 0, border=5, flag=wx.GROW|wx.BOTTOM|wx.LEFT|wx.RIGHT)
def _init_coll_MainGridSizer_Growables(self, parent):
parent.AddGrowableCol(0)
parent.AddGrowableRow(0)
parent.AddGrowableRow(1)
def _init_sizers(self):
self.MainGridSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)
self.InstancesSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)
self.InstancesButtonsSizer = wx.FlexGridSizer(cols=5, hgap=5, rows=1, vgap=0)
self.TasksSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)
self.TasksButtonsSizer = wx.FlexGridSizer(cols=5, hgap=5, rows=1, vgap=0)
self._init_coll_MainGridSizer_Growables(self.MainGridSizer)
self._init_coll_MainGridSizer_Items(self.MainGridSizer)
self._init_coll_InstancesSizer_Growables(self.InstancesSizer)
self._init_coll_InstancesSizer_Items(self.InstancesSizer)
self._init_coll_InstancesButtonsSizer_Growables(self.InstancesButtonsSizer)
self._init_coll_InstancesButtonsSizer_Items(self.InstancesButtonsSizer)
self._init_coll_TasksSizer_Growables(self.TasksSizer)
self._init_coll_TasksSizer_Items(self.TasksSizer)
self._init_coll_TasksButtonsSizer_Growables(self.TasksButtonsSizer)
self._init_coll_TasksButtonsSizer_Items(self.TasksButtonsSizer)
self.SetSizer(self.MainGridSizer)
def _init_ctrls(self, prnt):
wx.Panel.__init__(self, id=ID_RESOURCEEDITOR, name='', parent=prnt,
size=wx.Size(0, 0), style=wx.SUNKEN_BORDER)
self.staticText1 = wx.StaticText(id=ID_RESOURCEEDITORSTATICTEXT1,
label=_(u'Tasks:'), name='staticText2', parent=self, pos=wx.Point(0,
0), size=wx.DefaultSize, style=wx.ALIGN_CENTER)
self.TasksGrid = CustomGrid(id=ID_RESOURCEEDITORTASKSGRID,
name='TasksGrid', parent=self, pos=wx.Point(0, 0),
size=wx.Size(-1, -1), style=wx.VSCROLL)
self.TasksGrid.SetFont(wx.Font(12, 77, wx.NORMAL, wx.NORMAL, False,
'Sans'))
self.TasksGrid.SetLabelFont(wx.Font(10, 77, wx.NORMAL, wx.NORMAL,
False, 'Sans'))
if wx.VERSION >= (2, 6, 0):
self.TasksGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.OnTasksGridCellChange)
else:
wx.grid.EVT_GRID_CELL_CHANGE(self.TasksGrid, self.OnTasksGridCellChange)
self.AddTaskButton = wx.Button(id=ID_RESOURCEEDITORADDTASKBUTTON, label=_('Add Task'),
name='AddTaskButton', parent=self, pos=wx.Point(0, 0),
size=wx.DefaultSize, style=0)
self.DeleteTaskButton = wx.Button(id=ID_RESOURCEEDITORDELETETASKBUTTON, label=_('Delete Task'),
name='DeleteTaskButton', parent=self, pos=wx.Point(0, 0),
size=wx.DefaultSize, style=0)
self.UpTaskButton = wx.Button(id=ID_RESOURCEEDITORUPTASKBUTTON, label='^',
name='UpTaskButton', parent=self, pos=wx.Point(0, 0),
size=wx.Size(32, 32), style=0)
self.DownTaskButton = wx.Button(id=ID_RESOURCEEDITORDOWNTASKBUTTON, label='v',
name='DownTaskButton', parent=self, pos=wx.Point(0, 0),
size=wx.Size(32, 32), style=0)
self.staticText2 = wx.StaticText(id=ID_RESOURCEEDITORSTATICTEXT2,
label=_(u'Instances:'), name='staticText1', parent=self,
pos=wx.Point(0, 0), size=wx.DefaultSize, style=wx.ALIGN_CENTER)
self.InstancesGrid = CustomGrid(id=ID_RESOURCEEDITORINSTANCESGRID,
name='InstancesGrid', parent=self, pos=wx.Point(0, 0),
size=wx.Size(-1, -1), style=wx.VSCROLL)
self.InstancesGrid.SetFont(wx.Font(12, 77, wx.NORMAL, wx.NORMAL, False,
'Sans'))
self.InstancesGrid.SetLabelFont(wx.Font(10, 77, wx.NORMAL, wx.NORMAL,
False, 'Sans'))
if wx.VERSION >= (2, 6, 0):
self.InstancesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.OnInstancesGridCellChange)
else:
wx.grid.EVT_GRID_CELL_CHANGE(self.InstancesGrid, self.OnInstancesGridCellChange)
self.AddInstanceButton = wx.Button(id=ID_RESOURCEEDITORADDINSTANCEBUTTON, label=_('Add Instance'),
name='AddInstanceButton', parent=self, pos=wx.Point(0, 0),
size=wx.DefaultSize, style=0)
self.DeleteInstanceButton = wx.Button(id=ID_RESOURCEEDITORDELETEINSTANCEBUTTON, label=_('Delete Instance'),
name='DeleteInstanceButton', parent=self, pos=wx.Point(0, 0),
size=wx.DefaultSize, style=0)
self.UpInstanceButton = wx.Button(id=ID_RESOURCEEDITORUPINSTANCEBUTTON, label='^',
name='UpInstanceButton', parent=self, pos=wx.Point(0, 0),
size=wx.Size(32, 32), style=0)
self.DownInstanceButton = wx.Button(id=ID_RESOURCEEDITORDOWNINSTANCEBUTTON, label='v',
name='DownInstanceButton', parent=self, pos=wx.Point(0, 0),
size=wx.Size(32, 32), style=0)
self._init_sizers()
def __init__(self, parent, tagname, window, controler):
self._init_ctrls(parent)
self.ParentWindow = window
self.Controler = controler
self.TagName = tagname
self.RefreshHighlightsTimer = wx.Timer(self, -1)
self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, self.RefreshHighlightsTimer)
self.TasksDefaultValue = {"Name" : "", "Triggering" : "", "Single" : "", "Interval" : "", "Priority" : 0}
self.TasksTable = ResourceTable(self, [], GetTasksTableColnames())
self.TasksTable.SetColAlignements([wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_RIGHT, wx.ALIGN_RIGHT])
self.TasksTable.SetColSizes([200, 100, 100, 150, 100])
self.TasksGrid.SetTable(self.TasksTable)
self.TasksGrid.SetButtons({"Add": self.AddTaskButton,
"Delete": self.DeleteTaskButton,
"Up": self.UpTaskButton,
"Down": self.DownTaskButton})
def _AddTask(new_row):
self.TasksTable.InsertRow(new_row, self.TasksDefaultValue.copy())
self.RefreshModel()
self.RefreshView()
return new_row
setattr(self.TasksGrid, "_AddRow", _AddTask)
def _DeleteTask(row):
self.TasksTable.RemoveRow(row)
self.RefreshModel()
self.RefreshView()
setattr(self.TasksGrid, "_DeleteRow", _DeleteTask)
def _MoveTask(row, move):
new_row = self.TasksTable.MoveRow(row, move)
if new_row != row:
self.RefreshModel()
self.RefreshView()
return new_row
setattr(self.TasksGrid, "_MoveRow", _MoveTask)
self.TasksGrid.SetRowLabelSize(0)
self.TasksTable.ResetView(self.TasksGrid)
self.TasksGrid.RefreshButtons()
self.InstancesDefaultValue = {"Name" : "", "Type" : "", "Task" : ""}
self.InstancesTable = ResourceTable(self, [], GetInstancesTableColnames())
self.InstancesTable.SetColAlignements([wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT])
self.InstancesTable.SetColSizes([200, 150, 150])
self.InstancesGrid.SetTable(self.InstancesTable)
self.InstancesGrid.SetButtons({"Add": self.AddInstanceButton,
"Delete": self.DeleteInstanceButton,
"Up": self.UpInstanceButton,
"Down": self.DownInstanceButton})
def _AddInstance(new_row):
self.InstancesTable.InsertRow(new_row, self.InstancesDefaultValue.copy())
self.RefreshModel()
self.RefreshView()
return new_row
setattr(self.InstancesGrid, "_AddRow", _AddInstance)
def _DeleteInstance(row):
self.InstancesTable.RemoveRow(row)
self.RefreshModel()
self.RefreshView()
setattr(self.InstancesGrid, "_DeleteRow", _DeleteInstance)
def _MoveInstance(row, move):
new_row = max(0, min(row + move, self.InstancesTable.GetNumberRows() - 1))
if new_row != row:
if self.InstancesTable.GetValueByName(row, "Task") != self.InstancesTable.GetValueByName(new_row, "Task"):
return row
self.InstancesTable.MoveRow(row, move)
self.RefreshModel()
self.RefreshView()
return new_row
setattr(self.InstancesGrid, "_MoveRow", _MoveInstance)
def _RefreshInstanceButtons():
rows = self.InstancesTable.GetNumberRows()
row = self.InstancesGrid.GetGridCursorRow()
self.DeleteInstanceButton.Enable(rows > 0)
self.UpInstanceButton.Enable(row > 0 and
self.InstancesTable.GetValueByName(row, "Task") == self.InstancesTable.GetValueByName(row - 1, "Task"))
self.DownInstanceButton.Enable(0 <= row < rows - 1 and
self.InstancesTable.GetValueByName(row, "Task") == self.InstancesTable.GetValueByName(row + 1, "Task"))
setattr(self.InstancesGrid, "RefreshButtons", _RefreshInstanceButtons)
self.InstancesGrid.SetRowLabelSize(0)
self.InstancesTable.ResetView(self.InstancesGrid)
self.InstancesGrid.RefreshButtons()
self.TasksGrid.SetFocus()
def __del__(self):
self.RefreshHighlightsTimer.Stop()
def SetTagName(self, tagname):
self.TagName = tagname
def GetTagName(self):
return self.TagName
def IsViewing(self, tagname):
return self.TagName == tagname
def IsDebugging(self):
return False
def SetMode(self, mode):
pass
def RefreshTypeList(self):
self.TypeList = ""
blocktypes = self.Controler.GetBlockResource()
for blocktype in blocktypes:
self.TypeList += ",%s"%blocktype
def RefreshTaskList(self):
self.TaskList = ""
for row in xrange(self.TasksTable.GetNumberRows()):
self.TaskList += ",%s"%self.TasksTable.GetValueByName(row, "Name")
def RefreshVariableList(self):
self.VariableList = ""
for variable in self.Controler.GetEditedResourceVariables(self.TagName):
self.VariableList += ",%s"%variable
def RefreshModel(self):
self.Controler.SetEditedResourceInfos(self.TagName, self.TasksTable.GetData(), self.InstancesTable.GetData())
self.RefreshBuffer()
def ResetBuffer(self):
pass
# Buffer the last model state
def RefreshBuffer(self):
self.Controler.BufferProject()
self.ParentWindow.RefreshTitle()
self.ParentWindow.RefreshFileMenu()
self.ParentWindow.RefreshEditMenu()
def RefreshView(self):
tasks, instances = self.Controler.GetEditedResourceInfos(self.TagName)
self.TasksTable.SetData(tasks)
self.InstancesTable.SetData(instances)
self.RefreshTypeList()
self.RefreshTaskList()
self.RefreshVariableList()
self.TasksTable.ResetView(self.TasksGrid)
self.InstancesTable.ResetView(self.InstancesGrid)
self.TasksGrid.RefreshButtons()
self.InstancesGrid.RefreshButtons()
def RefreshScaling(self, refresh=True):
pass
def OnTasksGridCellChange(self, event):
row, col = event.GetRow(), event.GetCol()
if self.TasksTable.GetColLabelValue(event.GetCol()) == "Name":
tasklist = self.TaskList.split(",")
for i in xrange(self.TasksTable.GetNumberRows()):
task = self.TasksTable.GetValueByName(i, "Name")
if task in tasklist:
tasklist.remove(task)
tasklist.remove("")
if len(tasklist) > 0:
old_name = tasklist[0]
new_name = self.TasksTable.GetValue(row, col)
for i in xrange(self.InstancesTable.GetNumberRows()):
if self.InstancesTable.GetValueByName(i, "Task") == old_name:
self.InstancesTable.SetValueByName(i, "Task", new_name)
self.RefreshModel()
colname = self.TasksTable.GetColLabelValue(col, False)
if colname == "Triggering":
wx.CallAfter(self.RefreshView)
event.Skip()
def OnInstancesGridCellChange(self, event):
self.RefreshModel()
self.ParentWindow.RefreshInstancesTree()
self.InstancesGrid.RefreshButtons()
event.Skip()
#-------------------------------------------------------------------------------
# Highlights showing functions
#-------------------------------------------------------------------------------
def OnRefreshHighlightsTimer(self, event):
self.RefreshView()
event.Skip()
def AddHighlight(self, infos, start, end, highlight_type):
if infos[0] == "task":
self.TasksTable.AddHighlight(infos[1:], highlight_type)
elif infos[0] == "instance":
self.InstancesTable.AddHighlight(infos[1:], highlight_type)
def ClearHighlights(self, highlight_type=None):
self.TasksTable.ClearHighlights(highlight_type)
self.InstancesTable.ClearHighlights(highlight_type)
self.TasksTable.ResetView(self.TasksGrid)
self.InstancesTable.ResetView(self.InstancesGrid)
class DurationCellControl(wx.PyControl):
def _init_coll_MainSizer_Items(self, parent):
parent.AddWindow(self.Duration, 0, border=0, flag=wx.GROW)
parent.AddWindow(self.EditButton, 0, border=0, flag=wx.GROW)
def _init_coll_MainSizer_Growables(self, parent):
parent.AddGrowableCol(0)
parent.AddGrowableRow(0)
def _init_sizers(self):
self.MainSizer = wx.FlexGridSizer(cols=2, hgap=0, rows=1, vgap=0)
self._init_coll_MainSizer_Items(self.MainSizer)
self._init_coll_MainSizer_Growables(self.MainSizer)
self.SetSizer(self.MainSizer)
def _init_ctrls(self, prnt):
wx.Control.__init__(self, id=-1,
name='DurationCellControl', parent=prnt,
size=wx.DefaultSize, style=0)
# create location text control
self.Duration = wx.TextCtrl(id=-1, name='Duration', parent=self,
pos=wx.Point(0, 0), size=wx.Size(0, 0), style=wx.TE_PROCESS_ENTER)
self.Duration.Bind(wx.EVT_KEY_DOWN, self.OnDurationChar)
# create browse button
self.EditButton = wx.Button(id=-1, label='...',
name='EditButton', parent=self, pos=wx.Point(0, 0),
size=wx.Size(30, 0), style=0)
self.EditButton.Bind(wx.EVT_BUTTON, self.OnEditButtonClick)
self.Bind(wx.EVT_SIZE, self.OnSize)
self._init_sizers()
'''
Custom cell editor control with a text box and a button that launches
the DurationEditorDialog.
'''
def __init__(self, parent):
self._init_ctrls(parent)
def SetValue(self, value):
self.Duration.SetValue(value)
def GetValue(self):
return self.Duration.GetValue()
def OnSize(self, event):
self.Layout()
def OnEditButtonClick(self, event):
# pop up the Duration Editor dialog
dialog = DurationEditorDialog(self)
dialog.SetDuration(self.Duration.GetValue())
if dialog.ShowModal() == wx.ID_OK:
# set the duration
self.Duration.SetValue(dialog.GetDuration())
dialog.Destroy()
self.Duration.SetFocus()
def OnDurationChar(self, event):
keycode = event.GetKeyCode()
if keycode == wx.WXK_RETURN or keycode == wx.WXK_TAB:
self.Parent.Parent.ProcessEvent(event)
self.Parent.Parent.SetFocus()
else:
event.Skip()
def SetInsertionPoint(self, i):
self.Duration.SetInsertionPoint(i)
def SetFocus(self):
self.Duration.SetFocus()
class DurationCellEditor(wx.grid.PyGridCellEditor):
'''
Grid cell editor that uses DurationCellControl to display an edit button.
'''
def __init__(self, table):
wx.grid.PyGridCellEditor.__init__(self)
self.Table = table
def __del__(self):
self.CellControl = None
def Create(self, parent, id, evt_handler):
self.CellControl = DurationCellControl(parent)
self.SetControl(self.CellControl)
if evt_handler:
self.CellControl.PushEventHandler(evt_handler)
def BeginEdit(self, row, col, grid):
self.CellControl.SetValue(self.Table.GetValueByName(row, 'Interval'))
self.CellControl.SetFocus()
def EndEdit(self, row, col, grid):
duration = self.CellControl.GetValue()
old_duration = self.Table.GetValueByName(row, 'Interval')
if duration != old_duration:
self.Table.SetValueByName(row, 'Interval', duration)
return True
return False
def SetSize(self, rect):
self.CellControl.SetDimensions(rect.x + 1, rect.y,
rect.width, rect.height,
wx.SIZE_ALLOW_MINUS_ONE)
def Clone(self):
return DurationCellEditor(self.Table)