"""A tkinter class for providing table functionality"""

def __init__(self, parent=None, model=None, data=None, read_only=False,

width=None, height=None, bgcolor='#F7F7FA', fgcolor='black',

rows=10, cols=5, **kwargs):

Canvas.__init__(self, parent, bg=bgcolor,

width=width, height=height,

relief=GROOVE,

scrollregion=(0,0,300,200))

self.parentframe = parent

#get platform into a variable

self.ostyp = self.checkOSType()

self.platform = platform.system()

self.width = width

self.height = height

self.set_defaults()

self.fgcolor = fgcolor

self.currentpage = None

self.navFrame = None

self.currentrow = 0

self.currentcol = 0

self.reverseorder = 0

self.startrow = self.endrow = None

self.startcol = self.endcol = None

self.allrows = False #for selected all rows without setting multiplerowlist

self.multiplerowlist=[]

self.multiplecollist=[]

self.col_positions=[] #record current column grid positions

self.mode = 'normal'

self.read_only = read_only

self.filtered = False

self.loadPrefs()

#set any options passed in kwargs to overwrite defaults and prefs

for key in kwargs:

self.__dict__[key] = kwargs[key]

if data is not None:

self.model = TableModel()

self.model.importDict(data)

elif model is not None:

self.model = model

else:

self.model = TableModel(rows=rows,columns=cols)

self.rows = self.model.getRowCount()

self.cols = self.model.getColumnCount()

self.tablewidth = (self.cellwidth)*self.cols

self.do_bindings()

#initial sort order

self.model.setSortOrder()

#column specific actions, define for every column type in the model

#when you add a column type you should edit this dict

self.columnactions = {'text' : {"Edit": 'drawCellEntry' },

'number' : {"Edit": 'drawCellEntry' }}

self.setFontSize()

return

def set_defaults(self):

"""Set default settings"""

self.cellwidth=150

self.maxcellwidth=200

self.rowheight=20

self.horizlines=1

self.vertlines=1

self.alternaterows=0

self.autoresizecols = 0

self.inset=2

self.x_start=0

self.y_start=1

self.linewidth=1.0

self.rowheaderwidth=40

self.showkeynamesinheader=False

self.thefont = ('Arial',12)

self.bgcolor = '#F7F7FA'

self.fgcolor = 'black'

self.entrybackgr = 'white'

self.grid_color = '#ABB1AD'

self.selectedcolor = 'yellow'

self.rowselectedcolor = '#CCCCFF'

self.multipleselectioncolor = '#ECD672'

return

def setFontSize(self):

"""Set font size to match font, we need to get rid of fontsize as

if hasattr(self, 'thefont') and type(self.thefont) is tuple:

self.fontsize = self.thefont[1]

return

def mouse_wheel(self, event):

"""Handle mouse wheel scroll for windows"""

if event.num == 5 or event.delta == -120:

event.widget.yview_scroll(1, UNITS)

self.tablerowheader.yview_scroll(1, UNITS)

if event.num == 4 or event.delta == 120:

if self.canvasy(0) < 0:

return

event.widget.yview_scroll(-1, UNITS)

self.tablerowheader.yview_scroll(-1, UNITS)

self.redrawVisible()

return

def do_bindings(self):

"""Bind keys and mouse clicks, this can be overriden"""

self.bind("<Button-1>",self.handle_left_click)

self.bind("<Double-Button-1>",self.handle_double_click)

self.bind("<Control-Button-1>", self.handle_left_ctrl_click)

self.bind("<Shift-Button-1>", self.handle_left_shift_click)

self.bind("<ButtonRelease-1>", self.handle_left_release)

if self.ostyp=='mac':

#For mac we bind Shift, left-click to right click

self.bind("<Button-2>", self.handle_right_click)

self.bind('<Shift-Button-1>',self.handle_right_click)

else:

self.bind("<Button-3>", self.handle_right_click)

self.bind('<B1-Motion>', self.handle_mouse_drag)

self.bind('<Motion>', self.handle_motion)

self.bind_all("<Control-x>", self.deleteRow)

self.bind_all("<Control-n>", self.addRow)

self.bind_all("<Delete>", self.clearData)

self.bind_all("<Control-v>", self.paste)

#if not hasattr(self,'parentapp'):

# self.parentapp = self.parentframe

self.parentframe.master.bind_all("<Right>", self.handle_arrow_keys)

self.parentframe.master.bind_all("<Left>", self.handle_arrow_keys)

self.parentframe.master.bind_all("<Up>", self.handle_arrow_keys)

self.parentframe.master.bind_all("<Down>", self.handle_arrow_keys)

self.parentframe.master.bind_all("<KP_8>", self.handle_arrow_keys)

self.parentframe.master.bind_all("<Return>", self.handle_arrow_keys)

self.parentframe.master.bind_all("<Tab>", self.handle_arrow_keys)

#if 'windows' in self.platform:

self.bind("<MouseWheel>", self.mouse_wheel)

self.bind('<Button-4>', self.mouse_wheel)

self.bind('<Button-5>', self.mouse_wheel)

self.focus_set()

return

def getModel(self):

"""Get the current table model"""

return self.model

def setModel(self, model):

"""Set a new model - requires redraw to reflect changes"""

self.model = model

return

def createfromDict(self, data):

"""Attempt to create a new model/table from a dict"""

try:

namefield=self.namefield

except:

namefield=data.keys()[0]

self.model = TableModel()

self.model.importDict(data, namefield=namefield)

self.model.setSortOrder(0,reverse=self.reverseorder)

return

def createTableFrame(self, callback=None):

self.show(callback)

return

def show(self, callback=None):

"""Adds column header and scrollbars and combines them with

#Add the table and header to the frame

self.tablerowheader = RowHeader(self.parentframe, self, width=self.rowheaderwidth)

self.tablecolheader = ColumnHeader(self.parentframe, self)

self.Yscrollbar = AutoScrollbar(self.parentframe,orient=VERTICAL,command=self.set_yviews)

self.Yscrollbar.grid(row=1,column=2,rowspan=1,sticky='news',pady=0,ipady=0)

self.Xscrollbar = AutoScrollbar(self.parentframe,orient=HORIZONTAL,command=self.set_xviews)

self.Xscrollbar.grid(row=2,column=1,columnspan=1,sticky='news')

self['xscrollcommand'] = self.Xscrollbar.set

self['yscrollcommand'] = self.Yscrollbar.set

self.tablecolheader['xscrollcommand'] = self.Xscrollbar.set

self.tablerowheader['yscrollcommand'] = self.Yscrollbar.set

self.parentframe.rowconfigure(1,weight=1)

self.parentframe.columnconfigure(1,weight=1)

self.tablecolheader.grid(row=0,column=1,rowspan=1,sticky='news',pady=0,ipady=0)

self.tablerowheader.grid(row=1,column=0,rowspan=1,sticky='news',pady=0,ipady=0)

self.grid(row=1,column=1,rowspan=1,sticky='news',pady=0,ipady=0)

self.adjustColumnWidths()

self.redrawTable(callback=callback)

self.parentframe.bind("<Configure>", self.redrawVisible)

self.tablecolheader.xview("moveto", 0)

self.xview("moveto", 0)

return

def getVisibleRegion(self):

"""Get visible region of table to display"""

x1, y1 = self.canvasx(0), self.canvasy(0)

#w, h = self.winfo_width(), self.winfo_height()

w,h= self.master.winfo_width(), self.master.winfo_height()

if w <= 1.0 or h <= 1.0:

w, h = self.master.winfo_width(), self.master.winfo_height()

x2, y2 = self.canvasx(w), self.canvasy(h)

return x1, y1, x2, y2

def getRowPosition(self, y):

"""Get current row from canvas position"""

h = self.rowheight

y_start = self.y_start

row = (int(y)-y_start)/h

if row < 0:

return 0

if row > self.rows:

row = self.rows

return row

def getColPosition(self, x):

"""Get current col from canvas position"""

x_start = self.x_start

w = self.cellwidth

i=0

col=0

for c in self.col_positions:

col = i

if c+w>=x:

break

i+=1

return col

def getVisibleRows(self, y1, y2):

"""Get the visible row range"""

start = int(self.getRowPosition(y1))

end = int(self.getRowPosition(y2))+1

if end > self.rows:

end = self.rows

return start, end

def getVisibleCols(self, x1, x2):

"""Get the visible column range"""

start = self.getColPosition(x1)

end = self.getColPosition(x2)+1

if end > self.cols:

end = self.cols

return start, end

def redrawVisible(self, event=None, callback=None):

"""Redraw the visible portion of the canvas"""

model = self.model

self.rows = self.model.getRowCount()

self.cols = self.model.getColumnCount()

self.tablewidth = (self.cellwidth) * self.cols

self.configure(bg=self.bgcolor)

self.setColPositions()

#are we drawing a filtered subset of the recs?

if self.filtered == True and self.model.filteredrecs != None:

self.rows = len(self.model.filteredrecs)

self.delete('colrect')

self.rowrange = range(0,self.rows)

self.configure(scrollregion=(0,0, self.tablewidth+self.x_start,

self.rowheight*self.rows+10))

x1, y1, x2, y2 = self.getVisibleRegion()

startvisiblerow, endvisiblerow = self.getVisibleRows(y1, y2)

self.visiblerows = range(startvisiblerow, endvisiblerow)

startvisiblecol, endvisiblecol = self.getVisibleCols(x1, x2)

self.visiblecols = range(startvisiblecol, endvisiblecol)

if self.cols == 0 or self.rows == 0:

self.delete('entry')

self.delete('rowrect')

self.delete('currentrect')

self.delete('gridline','text')

self.tablerowheader.redraw()

return

self.drawGrid(startvisiblerow, endvisiblerow)

align = self.align

self.delete('fillrect')

for row in self.visiblerows:

if callback != None:

callback()

for col in self.visiblecols:

colname = model.getColumnName(col)

bgcolor = model.getColorAt(row,col, 'bg')

fgcolor = model.getColorAt(row,col, 'fg')

text = model.getValueAt(row,col)

self.drawText(row, col, text, fgcolor, align)

if bgcolor != None:

self.drawRect(row,col, color=bgcolor)

#self.drawSelectedCol()

self.tablecolheader.redraw()

self.tablerowheader.redraw(align=self.align, showkeys=self.showkeynamesinheader)

#self.setSelectedRow(self.currentrow)

self.drawSelectedRow()

self.drawSelectedRect(self.currentrow, self.currentcol)

#print self.multiplerowlist

if len(self.multiplerowlist)>1:

self.tablerowheader.drawSelectedRows(self.multiplerowlist)

self.drawMultipleRows(self.multiplerowlist)

self.drawMultipleCells()

return

def redrawTable(self, event=None, callback=None):

self.redrawVisible(event, callback)

return

def redraw(self, event=None, callback=None):

self.redrawVisible(event, callback)

return

def redrawCell(self, row=None, col=None, recname=None, colname=None):

"""Redraw a specific cell only"""

if row == None and recname != None:

row = self.model.getRecordIndex(recname)

if col == None and colname != None:

col = self.model.getColumnIndex(colname)

bgcolor = self.model.getColorAt(row,col, 'bg')

fgcolor = self.model.getColorAt(row,col, 'fg')

text = self.model.getValueAt(row,col)

self.drawText(row, col, text, fgcolor)

if bgcolor != None:

self.drawRect(row,col, color=bgcolor)

return

def adjustColumnWidths(self):

"""Optimally adjust col widths to accomodate the longest entry

#self.cols = self.model.getColumnCount()

try:

fontsize = self.thefont[1]

except:

fontsize = self.fontsize

scale = 8.5 * float(fontsize)/12

for col in range(self.cols):

colname = self.model.getColumnName(col)

if colname in self.model.columnwidths:

w = self.model.columnwidths[colname]

else:

w = self.cellwidth

maxlen = self.model.getlongestEntry(col)

size = maxlen * scale

if size < w:

continue

#print col, size, self.cellwidth

if size >= self.maxcellwidth:

size = self.maxcellwidth

self.model.columnwidths[colname] = size + float(fontsize)/12*6

return

def autoResizeColumns(self):

"""Automatically set nice column widths and draw"""

self.adjustColumnWidths()

self.redrawTable()

return

def setColPositions(self):

"""Determine current column grid positions"""

self.col_positions=[]

w=self.cellwidth

x_pos=self.x_start

self.col_positions.append(x_pos)

for col in range(self.cols):

colname=self.model.getColumnName(col)

if colname in self.model.columnwidths:

x_pos=x_pos+self.model.columnwidths[colname]

else:

x_pos=x_pos+w

self.col_positions.append(x_pos)

self.tablewidth = self.col_positions[len(self.col_positions)-1]

return

def sortTable(self, columnIndex=0, columnName=None, reverse=0):

"""Set up sort order dict based on currently selected field"""

self.model.setSortOrder(columnIndex, columnName, reverse)

self.redrawTable()

return

def set_xviews(self,*args):

"""Set the xview of table and col header"""

self.xview(*args)

self.tablecolheader.xview(*args)

self.redrawVisible()

return

def set_yviews(self,*args):

"""Set the xview of table and row header"""

self.yview(*args)

self.tablerowheader.yview(*args)

self.redrawVisible()

return

def addRow(self, key=None, **kwargs):

"""Add new row"""

key = self.model.addRow(key, **kwargs)

self.redrawTable()

self.setSelectedRow(self.model.getRecordIndex(key))

return

def addRows(self, num=None):

"""Add new rows"""

if num == None:

num = simpledialog.askinteger("Now many rows?",

"Number of rows:",initialvalue=1,

parent=self.parentframe)

if not num:

return

keys = self.model.autoAddRows(num)

self.redrawTable()

self.setSelectedRow(self.model.getRecordIndex(keys[0]))

return

def addColumn(self, newname=None):

"""Add a new column"""

if newname == None:

coltypes = self.getModel().getDefaultTypes()

d = MultipleValDialog(title='New Column',

initialvalues=(coltypes, ''),

labels=('Column Type','Name'),

types=('list','string'),

parent=self.parentframe)

if d.result == None:

return

else:

coltype = d.results[0]

newname = d.results[1]

if newname != None:

if newname in self.getModel().columnNames:

messagebox.showwarning("Name exists",

"Name already exists!",

parent=self.parentframe)

else:

self.model.addColumn(newname)

self.parentframe.configure(width=self.width)

self.redrawTable()

return

def deleteRow(self):

"""Delete a row"""

if len(self.multiplerowlist)>1:

n = messagebox.askyesno("Delete",

"Delete Selected Records?",

parent=self.parentframe)

if n == True:

rows = self.multiplerowlist

self.model.deleteRows(rows)

self.clearSelected()

self.setSelectedRow(0)

self.redrawTable()

else:

n = messagebox.askyesno("Delete",

"Delete This Record?",

parent=self.parentframe)

if n:

row = self.getSelectedRow()

self.model.deleteRow(row)

self.setSelectedRow(row-1)

self.clearSelected()

self.redrawTable()

return

def deleteColumn(self):

"""Delete currently selected column"""

n = messagebox.askyesno("Delete",

"Delete This Column?",

parent=self.parentframe)

if n:

col = self.getSelectedColumn()

self.model.deleteColumn(col)

self.currentcol = self.currentcol - 1

self.redrawTable()

return

def deleteCells(self, rows, cols):

"""Clear the cell contents"""

n = messagebox.askyesno("Clear Confirm",

"Clear this data?",

parent=self.parentframe)

if not n:

return

for col in cols:

for row in rows:

#absrow = self.get_AbsoluteRow(row)

self.model.deleteCellRecord(row, col)

self.redrawCell(row,col)

return

def clearData(self, evt=None):

"""Delete cells from gui event"""

rows = self.multiplerowlist

cols = self.multiplecollist

self.deleteCells(rows, cols)

return

def autoAddColumns(self, numcols=None):

"""Automatically add x number of cols"""

if numcols == None:

numcols = simpledialog.askinteger("Auto add rows.",

"How many empty columns?",

parent=self.parentframe)

self.model.auto_AddColumns(numcols)

self.parentframe.configure(width=self.width)

self.redrawTable()

return

def getRecordInfo(self, row):

"""Show the record for this row"""

model = self.model

#We need a custom dialog for allowing field entries here

#absrow = self.get_AbsoluteRow(row)

d = RecordViewDialog(title="Record Details",

parent=self.parentframe, table=self, row=row)

return

def findValue(self, searchstring=None, findagain=None):

"""Return the row/col for the input value"""

if searchstring == None:

searchstring = simpledialog.askstring("Search table.",

"Enter search value",

parent=self.parentframe)

found=0

if findagain == None or not hasattr(self,'foundlist'):

self.foundlist=[]

if self.model!=None:

for row in range(self.rows):

for col in range(self.cols):

text = str(self.model.getValueAt(row,col))

if text=='' or text==None:

continue

cell=row,col

if findagain == 1 and cell in self.foundlist:

continue

if text.lower().find(searchstring.lower())!=-1:

print ('found in',row,col)

found=1

#highlight cell

self.delete('searchrect')

self.drawRect(row, col, color='red', tag='searchrect', delete=0)

self.lift('searchrect')

self.lift('celltext'+str(col)+'_'+str(row))

#add row/col to foundlist

self.foundlist.append(cell)

#need to scroll to centre the cell here..

x,y = self.getCanvasPos(row, col)

self.xview('moveto', x)

self.yview('moveto', y)

self.tablecolheader.xview('moveto', x)

self.tablerowheader.yview('moveto', y)

return row, col

if found==0:

self.delete('searchrect')

print ('nothing found')

return None

def showAll(self):

self.model.filteredrecs = None

self.filtered = False

self.redrawTable()

return

def doFilter(self, event=None):

"""Filter the table display by some column values.

if self.model==None:

return

names = self.filterframe.doFiltering(searchfunc=self.model.filterBy)

#create a list of filtered recs

self.model.filteredrecs = names

self.filtered = True

self.redrawTable()

return

def createFilteringBar(self, parent=None, fields=None):

"""Add a filter frame"""

if parent == None:

parent = Toplevel()

parent.title('Filter Records')

x,y,w,h = self.getGeometry(self.master)

parent.geometry('+%s+%s' %(x,y+h))

if fields == None:

fields = self.model.columnNames

from .Filtering import FilterFrame

self.filterframe = FilterFrame(parent, fields,

self.doFilter, self.closeFilterFrame)

self.filterframe.pack()

return parent

def showFilteringBar(self):

if not hasattr(self, 'filterwin') or self.filterwin == None:

self.filterwin = self.createFilteringBar()

self.filterwin.protocol("WM_DELETE_WINDOW", self.closeFilterFrame)

else:

self.filterwin.lift()

return

def closeFilterFrame(self):

"""Callback for closing filter frame"""

self.filterwin.destroy()

self.filterwin = None

self.showAll()

return

def resizeColumn(self, col, width):

"""Resize a column by dragging"""

#print 'resizing column', col

#recalculate all col positions..

colname=self.model.getColumnName(col)

self.model.columnwidths[colname]=width

self.setColPositions()

self.redrawTable()

self.drawSelectedCol(self.currentcol)

return

def get_currentRecord(self):

"""Get the currently selected record"""

rec = self.model.getRecordAtRow(self.currentrow)

return rec

def get_currentColName(self):

"""Get the currently selected record name"""

colname = self.mo(self.currentcol)

return colname

def get_currentRecordName(self):

"""Get the currently selected record name"""

recname = self.model.getRecName(self.currentrow)

return recname

def get_selectedRecordNames(self):

"""Get a list of the current multiple selection, if any"""

recnames=[]

for row in self.multiplerowlist:

recnames.append(self.model.getRecName(row))

return recnames

def get_currentRecCol(self):

"""Get the clicked rec and col names as a tuple"""

recname = self.get_currentRecordName()

colname = self.get_currentColName()

return (recname, colname)

def get_row_clicked(self, event):

"""get row where event on canvas occurs"""

h=self.rowheight

#get coord on canvas, not window, need this if scrolling

y = int(self.canvasy(event.y))

y_start=self.y_start

rowc = int((int(y)-y_start)/h)

#rowc = math.floor(rowc)

#print 'event.y',event.y, 'y',y

#print 'rowclicked', rowc

return rowc

def get_col_clicked(self,event):

"""get col where event on canvas occurs"""

w=self.cellwidth

x = int(self.canvasx(event.x))

x_start=self.x_start

#print self.col_positions

for colpos in self.col_positions:

try:

nextpos=self.col_positions[self.col_positions.index(colpos)+1]

except:

nextpos=self.tablewidth

if x > colpos and x <= nextpos:

#print 'x=', x, 'colpos', colpos, self.col_positions.index(colpos)

return self.col_positions.index(colpos)

else:

#print None

pass

#return colc

def setSelectedRow(self, row):

"""Set currently selected row and reset multiple row list"""

self.currentrow = row

self.multiplerowlist = []

self.multiplerowlist.append(row)

return

def setSelectedCol(self, col):

"""Set currently selected column"""

self.currentcol = col

self.multiplecollist = []

self.multiplecollist.append(col)

return

def setSelectedCells(self, startrow, endrow, startcol, endcol):

"""Set a block of cells selected"""

self.currentrow = startrow

self.currentcol = startcol

if startrow < 0 or startcol < 0:

return

if endrow > self.rows or endcol > self.cols:

return

for r in range(startrow, endrow):

self.multiplerowlist.append(r)

for c in range(startcol, endcol):

self.multiplecollist.append(c)

return

def getSelectedRow(self):

"""Get currently selected row"""

return self.currentrow

def getSelectedColumn(self):

"""Get currently selected column"""

return self.currentcol

def select_All(self):

"""Select all rows and cells"""

self.startrow = 0

self.endrow = self.rows

self.multiplerowlist = range(self.startrow,self.endrow)

self.drawMultipleRows(self.multiplerowlist)

self.startcol = 0

self.endcol = self.cols

self.multiplecollist = range(self.startcol, self.endcol)

self.drawMultipleCells()

return

def getCellCoords(self, row, col):

"""Get x-y coordinates to drawing a cell in a given row/col"""

colname=self.model.getColumnName(col)

if colname in self.model.columnwidths:

w=self.model.columnwidths[colname]

else:

w=self.cellwidth

h=self.rowheight

x_start=self.x_start

y_start=self.y_start

#get nearest rect co-ords for that row/col

#x1=x_start+w*col

x1=self.col_positions[col]

y1=y_start+h*row

x2=x1+w

y2=y1+h

return x1,y1,x2,y2

def getCanvasPos(self, row, col):

"""Get the cell x-y coords as a fraction of canvas size"""

if self.rows==0:

return None, None

x1,y1,x2,y2 = self.getCellCoords(row,col)

cx=float(x1)/self.tablewidth

cy=float(y1)/(self.rows*self.rowheight)

return cx, cy

def isInsideTable(self,x,y):

"""Returns true if x-y coord is inside table bounds"""

if self.x_start < x < self.tablewidth and self.y_start < y < self.rows*self.rowheight:

return 1

else:

return 0

return answer

def setRowHeight(self, h):

"""Set the row height"""

self.rowheight = h

return

def clearSelected(self):

self.delete('rect')

self.delete('entry')

self.delete('tooltip')

self.delete('searchrect')

self.delete('colrect')

self.delete('multicellrect')

#self.delete('formulabox')

return

def gotoprevRow(self):

"""Programmatically set previous row - eg. for button events"""

self.clearSelected()

current = self.getSelectedRow()

self.setSelectedRow(current-1)

self.startrow = current-1

self.endrow = current-1

#reset multiple selection list

self.multiplerowlist=[]

self.multiplerowlist.append(self.currentrow)

self.drawSelectedRect(self.currentrow, self.currentcol)

self.drawSelectedRow()

coltype = self.model.getColumnType(self.currentcol)

if coltype == 'text' or coltype == 'number':

self.drawCellEntry(self.currentrow, self.currentcol)

return

def gotonextRow(self):

"""Programmatically set next row - eg. for button events"""

self.clearSelected()

current = self.getSelectedRow()

self.setSelectedRow(current+1)

self.startrow = current+1

self.endrow = current+1

#reset multiple selection list

self.multiplerowlist=[]

self.multiplerowlist.append(self.currentrow)

self.drawSelectedRect(self.currentrow, self.currentcol)

self.drawSelectedRow()

coltype = self.model.getColumnType(self.currentcol)

if coltype == 'text' or coltype == 'number':

self.drawCellEntry(self.currentrow, self.currentcol)

return

def handle_left_click(self, event):

"""Respond to a single press"""

#which row and column is the click inside?

self.clearSelected()

self.allrows = False

rowclicked = self.get_row_clicked(event)

colclicked = self.get_col_clicked(event)

self.focus_set()

if self.mode == 'formula':

self.handleFormulaClick(rowclicked, colclicked)

return

if hasattr(self, 'cellentry'):

self.cellentry.destroy()

#ensure popup menus are removed if present

if hasattr(self, 'rightmenu'):

self.rightmenu.destroy()

if hasattr(self.tablecolheader, 'rightmenu'):

self.tablecolheader.rightmenu.destroy()

self.startrow = rowclicked

self.endrow = rowclicked

self.startcol = colclicked

self.endcol = colclicked

#reset multiple selection list

self.multiplerowlist=[]

self.multiplerowlist.append(rowclicked)

if rowclicked is None or colclicked is None:

return

if self.read_only is True:

return

if 0 <= rowclicked < self.rows and 0 <= colclicked < self.cols:

self.setSelectedRow(rowclicked)

self.setSelectedCol(colclicked)

self.drawSelectedRect(self.currentrow, self.currentcol)

self.drawSelectedRow()

self.tablerowheader.drawSelectedRows(rowclicked)

coltype = self.model.getColumnType(colclicked)

if coltype == 'text' or coltype == 'number':

self.drawCellEntry(rowclicked, colclicked)

return

def handle_left_release(self,event):

self.endrow = self.get_row_clicked(event)

return

def handle_left_ctrl_click(self, event):

"""Handle ctrl clicks for multiple row selections"""

rowclicked = self.get_row_clicked(event)

colclicked = self.get_col_clicked(event)

if 0 <= rowclicked < self.rows and 0 <= colclicked < self.cols:

if rowclicked not in self.multiplerowlist:

self.multiplerowlist.append(rowclicked)

else:

self.multiplerowlist.remove(rowclicked)

self.drawMultipleRows(self.multiplerowlist)

if colclicked not in self.multiplecollist:

self.multiplecollist.append(colclicked)

#print self.multiplecollist

self.drawMultipleCells()

return

def handle_left_shift_click(self, event):

"""Handle shift click, for selecting multiple rows"""

#Has same effect as mouse drag, so just use same method

self.handle_mouse_drag(event)

return

def handle_mouse_drag(self, event):

"""Handle mouse moved with button held down, multiple selections"""

if hasattr(self, 'cellentry'):

self.cellentry.destroy()

rowover = self.get_row_clicked(event)

colover = self.get_col_clicked(event)

if colover == None or rowover == None:

return

if rowover >= self.rows or self.startrow > self.rows:

return

else:

self.endrow = rowover

#do columns

if colover > self.cols or self.startcol > self.cols:

return

else:

self.endcol = colover

if self.startcol is None or self.endcol is None:

return

if self.endcol < self.startcol:

self.multiplecollist = range(self.endcol, self.startcol+1)