hi Alessandro Dentella ,
Sorry for the pain.Now i am two py files one is ex.py and other is
gridset.py.In ex.py i am using gridset.py which is a module for treeview
with easy navigation.And in ex.py i am facing the above mentioned issues.
On Tue, Sep 29, 2009 at 1:13 PM, Alessandro Dentella <[email protected]>wrote:
> > I am attaching the py file in which i used the module in the above url.
>
> that's a long listing. Can you reproduce the problem in a simple example?
> To run your example you need at least 3 modules that are not provided
> (report,
> gnukhata_global, and gridset)
>
> sandro
> *:-)
>
"""
This file is part of GNUKhata:A modular,robust and Free Accounting System.
GNUKhata 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 3 of
the License, or (at your option) any later version.
GNUKhata 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 GNUKhata (COPYING); if not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301 USA59 Temple Place, Suite 330,
Contributor: "Anusha Kadambala"<[email protected]>"""
import pygtk
pygtk.require('2.0')
import os
import sys
import gtk,gobject
import gtk.glade,gnome,gnome.ui,datetime,time
import gridset
class purchase:
def __init__(self):
self.window = gtk.Window (gtk.WINDOW_TOPLEVEL)
self.scrolledwindow_treeview = gtk.ScrolledWindow()
self.window.add(self.scrolledwindow_treeview)
self.window.connect("destroy", self.destroy)
self.scrolledwindow_treeview.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.taxnames = ['vat','cst']
self.billList = gtk.ListStore(*(([gobject.TYPE_STRING] * 7)+([gobject.TYPE_BOOLEAN] * 2)+([gobject.TYPE_STRING] * 2)+([gobject.TYPE_BOOLEAN]*len(self.taxnames))+([gobject.TYPE_STRING] * 2)))
lst=['', '','','','','','',False,False,'','']
for r in self.taxnames:
lst.append(False)
lst.append('')
lst.append('')
self.treeview_bill = gridset.Grid(self.billList)
for i in range(10):
iter = self.billList.append(tuple(lst))
self.scrolledwindow_treeview.add(self.treeview_bill)
self.scrolledwindow_treeview.show_all()
self.editors = []
column_labels=["Product code","Product name","Manufacturer/Publisher","Stock quantity","Quantity","Price/Product","Amount","Discount percentage/product","Flat discount","Discounted Amount","Total discount amount"]
for i in range(0,7):
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(column_labels[i], renderer, text=i)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorText(self.treeview_bill, i))
renderer = gtk.CellRendererToggle()
#renderer.connect("toggled",self.discountpercentChanged,self.billList,6)
column = gtk.TreeViewColumn(column_labels[7], renderer, active=7)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorToggle(self.treeview_bill, 7))
renderer = gtk.CellRendererToggle()
#renderer.connect("toggled",self.flatdiscountChanged,self.billList,7)
column = gtk.TreeViewColumn(column_labels[8], renderer, active=8)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorToggle(self.treeview_bill, 8))
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(column_labels[9], renderer, text=9)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorText(self.treeview_bill, 9))
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(column_labels[10], renderer, text=10)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorText(self.treeview_bill, 10))
for r in range(0,len(self.taxnames)):
renderer = gtk.CellRendererToggle()
column = gtk.TreeViewColumn(self.taxnames[r][0], renderer, active=11+r)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorToggle(self.treeview_bill,11+r))
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Total Taxed amount", renderer, text=len(column_labels)+len(self.taxnames)+0)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorText(self.treeview_bill, len(column_labels)+len(self.taxnames)+0))
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Total amount", renderer, text=len(column_labels)+len(self.taxnames)+1)
column.set_resizable(True)
self.treeview_bill.append_column(column)
self.editors.append(gridset.GridCellEditorText(self.treeview_bill, len(column_labels)+len(self.taxnames)+1))
self.treeview_bill.setEditors(self.editors)
self.editors[0].connect("focus-out-event",self.prodcode_lostfocus)
self.window.resize(500,200)
self.window.show()
def prodcode_lostfocus(self,widget,event):
result = ['c1','p1',10.00,100,'anusha']
self.editors[1].setValue(result[1])
self.editors[2].setValue(result[4])
print result
print self.editors[2].getValue()
print self.editors[3].getValue()
print self.editors[5].getValue()
def destroy(self, widget, data=None):
gtk.main_quit()
if __name__ == '__main__':
p=purchase()
gtk.main()
import pygtk
pygtk.require('2.0')
import gtk
import gobject
import pango
class GridCellEditor(gtk.Window):
def __init__(self, grid, columnIndex):
gtk.Window.__init__(self)
self.grid = grid
self.columnIndex = columnIndex
self.set_decorated(False)
self.editor = self.createEditor()
self.add(self.editor)
self.editor.grab_focus()
self.path = None
self.connect('delete-event', self.deleteEvent)
def applyChanges(self):
iter = self.grid.model.get_iter(self.path)
self.grid.model.set_value(iter, self.columnIndex, self.getValue())
def createEditor(self):
raise 'this is an abstract method'
def deleteEvent(self, widget, event, data=None):
self.grid.get_toplevel().destroy()
def focusOutEvent(self, widget, data=None):
self.hide()
def getValue(self):
raise 'this is an abstract method'
def keyPressEvent(self, widget, event, data=None):
if event.keyval in [gtk.keysyms.Tab, gtk.keysyms.Down, gtk.keysyms.Up,
gtk.keysyms.Page_Down, gtk.keysyms.Page_Up]:
self.applyChanges()
self.grid.keyPressCallback(widget, event)
return True
return False
def setValue(self, value):
raise 'this is an abstract method'
def setEditable(self,value):
raise 'this is an abstract method'
def grabFocus(self):
raise 'this is an abstract method'
def setVisibility(self,value):
raise 'this is an abstract method'
def show(self, x, y, w, h, path):
self.set_transient_for(self.grid.get_toplevel())
self.set_destroy_with_parent(True)
self.set_skip_taskbar_hint(True)
self.path = path
iter = self.grid.model.get_iter(self.path)
value = self.grid.model.get_value(iter, self.columnIndex)
self.setValue(value)
self.set_size_request(w, h)
self.resize(w, h)
self.show_all()
self.present()
self.move(x, y)
#def buttonchanged(self,widget,data=None):
#print 'anusja'
class GridCellEditorText(GridCellEditor):
def __init__(self, grid, columnIndex):
GridCellEditor.__init__(self, grid, columnIndex)
def createEditor(self):
editor = gtk.Entry()
editor.set_has_frame(False)
editor.connect('key-press-event', self.keyPressEvent)
editor.connect('focus-out-event', self.focusOutEvent)
return editor
def getValue(self):
return self.editor.get_text()
def setValue(self, value):
if value == None:
value = ''
self.editor.set_text(value)
def setEditable(self,active=True):
self.editor.set_editable(active)
def grabFocus(self):
self.editor.grab_focus()
def setVisibity(self,active=True):
self.editor.set_visibility(active)
class GridCellEditorToggle(GridCellEditor):
def __init__(self, grid, columnIndex):
GridCellEditor.__init__(self, grid, columnIndex)
def createEditor(self):
editor = gtk.Alignment(xalign=0.5, yalign=0.5)
button = gtk.CheckButton()
button.connect('key-press-event', self.keyPressEvent)
button.connect('focus-out-event', self.focusOutEvent)
#button.connect('toggled', self.buttonchanged)
button.show()
editor.add(button)
return editor
def getValue(self):
return self.editor.get_child().get_active()
def setValue(self, value):
self.editor.get_child().set_active(value)
class GridCellEditorCombo(GridCellEditor):
def __init__(self, grid, columnIndex, values):
self.values = values
GridCellEditor.__init__(self, grid, columnIndex)
def buttonPressEvent(self, widget, data=None):
self.listOpened = True
def createEditor(self):
combo = gtk.Combo()
combo.set_popdown_strings(self.values)
combo.set_use_arrows(False)
combo.entry.connect('key-press-event', self.keyPressEvent)
combo.entry.connect('focus-out-event', self.focusOutEvent)
button = combo.get_children()[-1]
button.connect('pressed', self.buttonPressEvent)
self.listOpened = False
combo.show()
return combo
def focusOutEvent(self, widget, data=None):
if not self.listOpened:
self.hide()
def keyPressEvent(self, widget, event, data=None):
self.listOpened = False
return GridCellEditor.keyPressEvent(self, widget, event, data)
def getValue(self):
return self.editor.entry.get_text()
def setValue(self, value):
self.editor.entry.set_text(value)
class Grid(gtk.TreeView):
def __init__(self, model):
gtk.TreeView.__init__(self, model)
self.model = model
self.connect('key-press-event', self.keyPressCallback)
self.connect('button-release-event', self.buttonReleaseCallback)
self.set_rules_hint(True)
def cursorChangedCallback(self, widget, data=None):
path, column = self.get_cursor()
if path != None and column != None:
self.updateEditor(path, column)
def buttonReleaseCallback(self, widget, event, data=None):
if event.button == 1:
path, column, x, y = self.get_path_at_pos(int(event.x),int(event.y))
self.setCursor(path, column)
def keyPressCallback(self, widget, event, data=None):
if event.keyval == gtk.keysyms.Tab:
self.onKeyTab(event)
elif event.keyval == gtk.keysyms.Down:
self.onKeyDown(event)
elif event.keyval == gtk.keysyms.Up:
self.onKeyUp(event)
elif event.keyval == gtk.keysyms.Page_Down:
self.onKeyPageDown(event)
elif event.keyval == gtk.keysyms.Page_Up:
self.onKeyPageUp(event)
elif event.keyval == gtk.keysyms.Return:
self.cursorChangedCallback(None, None)
return True
def onKeyDown(self, event):
path, column = self.get_cursor()
self.moveCursorToNextRow(path, column)
def onKeyPageDown(self, event):
path, column = self.get_cursor()
self.moveCursorToNextPage(path, column)
def onKeyPageUp(self, event):
path, column = self.get_cursor()
self.moveCursorToPrevPage(path, column)
def onKeyUp(self, event):
path, column = self.get_cursor()
self.moveCursorToPrevRow(path, column)
def onKeyTab(self, event):
path, column = self.get_cursor()
if event.state == gtk.gdk.SHIFT_MASK:
self.moveCursorToPrevCell(path, column)
else:
self.moveCursorToNextCell(path, column)
def setCursor(self, path, column):
self.set_cursor(path, column)
self.updateEditor(path, column)
def updateEditor(self, path, column):
cell_area = self.get_cell_area(path, column)
bin = self.get_bin_window()
x_bin, y_bin = bin.get_origin()
columns = self.get_columns()
index = columns.index(column)
if self.editors[index] != None:
self.editors[index].show(x_bin + cell_area.x,
y_bin + cell_area.y,
cell_area.width,
cell_area.height,
path)
def moveCursorToNextCell(self, path, column):
columns = self.get_columns()
index = columns.index(column) + 1
if index == len(columns):
index = 0
path = (path[0]+1,)
try:
self.model.get_iter(path)
except:
return
column = columns[index]
self.setCursor(path, column)
def moveCursorToNextPage(self, path, column):
rowHeight = column.cell_get_size()[4]
gridHeight = self.allocation[3] - rowHeight
visibleRows = gridHeight / rowHeight
valid = 0
path = (path[0]+visibleRows,)
while not valid:
try:
self.model.get_iter(path)
valid = 1
except:
path = (path[0]-1,)
self.setCursor(path, column)
def moveCursorToNextRow(self, path, column):
path = (path[0]+1,)
try:
self.model.get_iter(path)
except:
path = (path[0]-1,)
self.setCursor(path, column)
def moveCursorToPrevCell(self, path, column):
columns = self.get_columns()
index = columns.index(column) - 1
if index == -1:
index = len(columns) - 1
if path[0] == 0:
self.get_toplevel().child_focus(gtk.DIR_TAB_BACKWARD)
return
else:
path = (path[0]-1, )
column = columns[index]
self.setCursor(path, column)
def moveCursorToPrevPage(self, path, column):
rowHeight = column.cell_get_size()[4]
gridHeight = self.allocation[3] - rowHeight
visibleRows = gridHeight / rowHeight
path = (max(0,path[0]-visibleRows),)
self.setCursor(path, column)
def moveCursorToPrevRow(self, path, column):
if path[0] > 0:
path = (path[0]-1,)
self.setCursor(path, column)
def createColumns(self):
self.editors = []
for i in range(self.model.get_n_columns()):
title = self.model.getColumnTitle(i)
type = self.model.get_column_type(i)
if type == gobject.TYPE_BOOLEAN:
renderer = gtk.CellRendererToggle()
column = gtk.TreeViewColumn(title, renderer, active=i)
self.editors.append(GridCellEditorToggle(self, i))
elif type == gobject.TYPE_PYOBJECT:
renderer = gtk.CellRendererText()
xalign = 1.0
renderer.set_property('xalign', xalign)
column = gtk.TreeViewColumn(title, renderer, text=i)
self.editors.append(GridCellEditorCombo(self, i, ['value 1','2','3']))
else:
renderer = gtk.CellRendererText()
if type in [gobject.TYPE_INT, gobject.TYPE_FLOAT]:
xalign = 1.0
else:
xalign = 0.0
renderer.set_property('xalign', xalign)
column = gtk.TreeViewColumn(title, renderer, text=i)
self.editors.append(GridCellEditorText(self, i))
column.set_alignment(0.5)
column.set_resizable(True)
self.append_column(column)
def setEditors(self, editors):
self.editors = editors
#this is the example where we can follow
def test():
win = gtk.Window(gtk.WINDOW_TOPLEVEL)
win.connect('destroy', lambda w: gtk.main_quit())
model = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,gobject.TYPE_BOOLEAN)
for i in range(10):
iter = model.append(('foo', 'option%d'%(i%3),False))
grid = Grid(model)
editors = [GridCellEditorText(grid, 0),
GridCellEditorCombo(grid, 1, ['option 0','option 1','option 2']),
GridCellEditorToggle(grid, 2)
]
grid.setEditors(editors)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Column 1', renderer, text=0)
column.set_resizable(True)
grid.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Column 3', renderer, text=1)
column.set_resizable(True)
grid.append_column(column)
renderer = gtk.CellRendererToggle()
column = gtk.TreeViewColumn('Column 2', renderer, active=2)
column.set_resizable(True)
grid.append_column(column)
grid.show()
win.add(grid)
win.show()
gtk.main()
if __name__ == '__main__':
test()
_______________________________________________
pygtk mailing list [email protected]
http://www.daa.com.au/mailman/listinfo/pygtk
Read the PyGTK FAQ: http://faq.pygtk.org/
