Merge lp:~rick-rickspencer3/quidgets/precise into lp:quidgets

[Rick Spencer]

Migrated quickly widgets to GObeject Introspection, so they will work with new Quickly projects.

1. deleted couchgrid, since DesktopCouch is no longer recommended (there is currently no upgrade path for apps that used CouchGrid in the past)
2. update all other quidgets to use GOI.
3. ensured all tests ran and passed.

[Michael Terry (mterry)]

Seems fine, but running the tests on the new code gives me several errors like:

Gtk-WARNING **: Cannot connect attribute `text' for cell renderer class `GtkCellRendererToggle' since attribute does not exist

Is that expected? Aside from that, this is approved. So if you fix that or it's innocuous, push away.

review: Needs Fixing

[Michael Terry (mterry)]

Looked into that warning, and it's harmless. Just comes from CheckColumns using the generic GridColumn intializer.

I pushed after porting the GStreamer code to use python-gi so that the gobject module doesn't get imported that way.

review: Approve

=== removed file 'quickly/widgets/asynch_task_progressbox.py'
--- quickly/widgets/asynch_task_progressbox.py	2010-09-11 19:59:30 +0000
+++ quickly/widgets/asynch_task_progressbox.py	1970-01-01 00:00:00 +0000
@@ -1,310 +0,0 @@
-### BEGIN LICENSE
-# Copyright (C) 2010 Rick Spencer [e-mail]
-#This program is free software: you can redistribute it and/or modify it 
-#under the terms of the GNU General Public License version 3, as published 
-#by the Free Software Foundation.
-#
-#This program is distributed in the hope that it will be useful, but 
-#WITHOUT ANY WARRANTY; without even the implied warranties of 
-#MERCHANTABILITY, SATISFACTORY QUALITY, 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 program.  If not, see <http://www.gnu.org/licenses/>.
-### END LICENSE
-
-try:
- import pygtk
- pygtk.require("2.0")
- import gtk
- import threading
- import time
- import gobject
- import gettext
- from gettext import gettext as _
- gettext.textdomain('quickly-widgets')
-
-except:
- print "couldn't load depencies"
-
-class AsynchTaskProgressBox( gtk.HBox ):
- """AsynchTaskProgressBox: encapsulates a pulstating progressbar, a cancel
- button, and a long running task. Use an AsynchTaskProgressBox when you want
- a window to perform a long running task in the background without freezing 
- the UI for the user.
-
- """
-
- def __init__(self, run_function, params = None, cancelable = True):
-  """Create an AsycnTaskProgressBox
-
-  Keyword arguments:
-  run_function -- the function to run asynchronously
-  params -- optional dictionary of parameters to be pass into run_function
-  cancelable -- optional value to determine whether to show cancel button. Defaults to True.
-  Do not use a value with the key of 'kill' in the params dictionary
-
-  """
-
-  gtk.HBox.__init__( self, False, 2 )
-
-  self.progressbar = gtk.ProgressBar()
-  self.progressbar.show()
-  self.pack_start(self.progressbar, True)
-
-  self.cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
-  if cancelable:
-   self.cancel_button.show()
-  if params is None:
-   params = {}
-  params["update_progress_function"] = self.update
-  self.cancel_button.set_sensitive(False)
-  self.cancel_button.connect("clicked",self.__stop_clicked)
-  self.pack_end(self.cancel_button, False)
-  
-  self.run_function = run_function
-  self.pulse_thread = None
-  self.work_thread = None
-  self.params = params
-
-  self.connect("destroy", self.__destroy)
-  
- __gsignals__ = {'complete' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
-		'cancelrequested' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,))
-		}
- 
- def start(self, caption = "Working"):
-  """executes run_function asynchronously and starts pulsating the progressbar
-  Keyword arguments:
-  caption -- optional text to display in the progressbar
-  """
-  #Throw an exception if the user tries to start an operating thread
-  if self.pulse_thread != None:
-   raise RuntimeError("AsynchTaskProgressBox already started.")
-
-  #Create and start a thread to run the users task
-  #pass in a callback and the user's params
-  self.work_thread = KillableThread(self.run_function, self.__on_complete, self.params)
-  self.work_thread.start()
-  
-  #create a thread to display the user feedback
-  self.pulse_thread = PulseThread(self.progressbar, caption)
-  self.pulse_thread.start()
-
-  #enable the button so the user can try to kill the task
-  self.cancel_button.set_sensitive( True )
-
- def update(self, fraction = None, displaytext = "Working"):
-  """updates the progress bar with a given percentage and/or changes the 
-  caption.
-  Keyword arguments:
-  fraction -- the current percentage complete
-  displaytext -- the new caption to display"""
-  if self.pulse_thread != None:
-   self.pulse_thread.update(fraction, displaytext)
-  
- #call back function for after run_function returns
- def __on_complete( self, data ):
-  self.emit("complete", data)
-  self.kill()
-
- #call back function for cancel button
- def __stop_clicked( self, widget, data = None ):
-  self.cancel()
-
- def cancel(self):
-  self.kill()
-  #emit the cancelrequested event
-  #note that this only signals that the kill function was called
-  #the thread may or may not have actually stopped
-  self.emit("cancelrequested", self)
-
- def kill( self ):
-  """
-  Stops pulstating the progressbar if the progressbar is working.
-  Sets the value of 'kill' to True in the run_function.
- 
-  """
-
-  #stop the pulse_thread and remove a reference to it if there is one
-  if self.pulse_thread != None:
-   self.pulse_thread.kill()
-   self.pulse_thread = None
-
-  #disable the cancel button since the task is about to be told to stop
-  gobject.idle_add(self.__disable_cancel_button)
-
-  #tell the users function tostop if it's thread exists
-  if self.work_thread != None:
-   self.work_thread.kill()
-
- #called when the widget is destroyed, attempts to clean up
- #the work thread and the pulse thread
- def __destroy(self, widget, data = None):
-  if self.work_thread != None:
-   self.work_thread.kill()
-  if self.pulse_thread != None:
-   self.pulse_thread.kill() 
-
- def __disable_cancel_button(self):
-  gtk.gdk.threads_enter()
-  self.cancel_button.set_sensitive( False )
-  gtk.gdk.threads_leave()
-
-class PulseThread ( threading.Thread ):
- """Class for use by AsynchTaskProgressBox. Not for general use.
-
- """
- def __init__(self,progressbar,displaytext = _("Working")):
-  threading.Thread.__init__(self)
-  self.displaytext = displaytext
-  self.setDaemon(False)
-  self.progressbar = progressbar
-  self.__kill = False
-  self.fraction = float(0)
-
- def kill(self):
-  self.__kill = True
-
- def update(self, fraction, displaytext):
-  self.displaytext = displaytext
-  self.fraction = fraction
-
- #As a subclass of Thread, this function runs when start() is called
- #It will cause the progressbar to pulse, showing that a task is running
- def run ( self ):
-  self.progressbar.set_text(self.displaytext)
-  #keep running until the __kill flag is set to True
-  while not self.__kill:
-   time.sleep(.1)
-   #get ahold of the UI thread and command the progress bar to pulse
-   gtk.gdk.threads_enter()
-   if self.fraction == 0:
-    self.progressbar.pulse()
-   else:
-    self.progressbar.set_fraction(self.fraction)
-   self.progressbar.set_text(self.displaytext)
-   gtk.gdk.threads_leave()
-  #before exiting, reset the progressbar to show that no task is running
-  gtk.gdk.threads_enter()
-  self.progressbar.set_fraction(0)
-  self.progressbar.set_text("")
-  gtk.gdk.threads_leave()
-
-class KillableThread( threading.Thread ):
- """Class for use by AsynchTaskProgressBox. Not for general use.
-
- """
- def __init__(self,run_function, on_complete,  params = None):
-  threading.Thread.__init__(self)
-  self.setDaemon(False)
-  self.run_function = run_function
-  self.params = params
-  self.on_complete = on_complete
-
- #As a subclass of Thread, this function runs when start() is called
- #It will run the user's function on this thread
- def run( self ):
-  #set up params and include the kill flag
-  if self.params == None:
-   self.params = {}
-  self.params["kill"] = False
-  #tell the function to run
-  data = self.run_function(self.params)
-  #return any data from the function so it can be sent in the complete signal
-  self.on_complete(data)
-
- #Tell the user's function that it should stop
- #Note the user's function may not check this
- def kill( self ):
-  self.params["kill"] = True
-
-class TestWindow(gtk.Window):
- """For testing and demonstrating AsycnTaskProgressBox.
-
- """
- def __init__(self):
-  #create a window a VBox to hold the controls
-  gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
-  self.set_title("AsynchTaskProgressBox Test Window")
-  windowbox = gtk.VBox(False, 2)
-  windowbox.show()
-  self.add(windowbox)
-
-  #create params for use by the function that should run asynchronously
-  params = {"start": 100, "stop": 110}
-
-  #pass in the function and the params, then add to the window
-  self.thread_progressbox = AsynchTaskProgressBox(self.asynch_function, params)
-  self.thread_progressbox.show()
-  windowbox.add(self.thread_progressbox)
-
-  #start the task, and set the text for the progressbar to "Testing"
-  #This will start the function and start the progressbar pulsating
-  self.thread_progressbox.start("Testing")
-
-  #connect to the complete event to respond when the task is complete
-  self.thread_progressbox.connect("complete",self.complete_function)
-
-  #connect to the cancel requested event for demonstration purposes
-  self.thread_progressbox.connect("cancelrequested", self.canceled_function)
-
-  #create a button for starting the task and add it to the window
-  start_button = gtk.Button(stock=gtk.STOCK_EXECUTE)
-  start_button.show()
-  windowbox.add(start_button)
-  start_button.connect("clicked",self.start_clicked) 
-  self.show()
-  
-  #finish wiring up the window
-  self.connect("destroy", self.destroy)
-
-  #start up gtk.main in a threaded environment  
-  gtk.gdk.threads_init()
-  gtk.gdk.threads_enter()
-  gtk.main()
-  gtk.gdk.threads_leave()
-
- #called when the window is destroyed
- def destroy(self, widget, data = None):
-  gtk.main_quit()
- 
- #start the AsynchTaskProgressBox when the button is clicked
- def start_clicked(self, widget, data = None):
-  self.thread_progressbox.start("Testing")
-
- #The function to run asynchronously
- def asynch_function( self, params ):
-  # do something interminate and cpu intensive at startup
-  print "starting..."
-  time.sleep(2)
-  #pull values from the params that were set above
-  total = float(abs(params["stop"]-params["start"]))
-  for x in range(params["start"],params["stop"]):
-   #check if to see if the user has told the task to stop
-   if params["kill"] == True:
-    #return a string if the user stopped the task
-    return "stopped at " + str(x)
-   else:
-    #if the user did not try to stop the task, go ahead and do something
-    print x
-    fraction=abs(x-params["start"])/total
-    # call the update_progress_function function with the current percentage and caption
-    params["update_progress_function"](fraction=fraction, displaytext=str(x))
-   #this is a processor intensive task, so
-   #sleep the loop to keep the UI from bogging down
-   time.sleep(.5)
-  #if the loop completes, return a string
-  return "counted all"
-
- #called when the task completes
- def complete_function(self, widget, data = None):
-  print "returned " + str(data)
- 
- def canceled_function(self, widget, data=None):
-  print "cancel requested"
-if __name__== "__main__":
- test = TestWindow()
-
 
=== modified file 'quickly/widgets/conventions.py'
--- quickly/widgets/conventions.py	2010-11-21 19:20:40 +0000
+++ quickly/widgets/conventions.py	2012-03-06 08:52:21 +0000
@@ -13,8 +13,6 @@
 #with this program.  If not, see <http://www.gnu.org/licenses/>.
 ### END LICENSE
 
-import gtk
-import gobject
 from grid_column import StringColumn, CurrencyColumn, CheckColumn
 from grid_column import IntegerColumn, TagsColumn, DateColumn
 
 
=== removed file 'quickly/widgets/couch_grid.py'
--- quickly/widgets/couch_grid.py	2011-08-19 17:22:14 +0000
+++ quickly/widgets/couch_grid.py	1970-01-01 00:00:00 +0000
@@ -1,458 +0,0 @@
-# -*- coding: utf-8 -*-
-### BEGIN LICENSE
-# Copyright (C) 2010 Rick Spencer [e-mail]
-#This program is free software: you can redistribute it and/or modify it 
-#under the terms of the GNU General Public License version 3, as published 
-#by the Free Software Foundation.
-#
-#This program is distributed in the hope that it will be useful, but 
-#WITHOUT ANY WARRANTY; without even the implied warranties of 
-#MERCHANTABILITY, SATISFACTORY QUALITY, 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 program.  If not, see <http://www.gnu.org/licenses/>.
-### END LICENSE
-
-"""A Treeview for Desktop CouchDB
-Displays and persists data in desktopcouch, handles presentation
-of the UI in a Gtk.TreeView, as well handles persistence to a backend
-desktopcouch database.
-
-Using
-#define the database and record type
-database = "couch_widget_test"
-record_type="test_record_type"
-
-#create a dictionary if you don't already have one
-dicts = [{"test?":True,"price":100,"foo count":100,"Key4":"1004"},
-    {"test?":True,"price":100,"foo count":100,"Key4":"1004"},
-    {"test?":True,"price":100,"foo count":100,"Key4":"1004"}]
-
-#create the CouchGrid
-cg = CouchGrid(database, record_type=record_type, dictionaries=dicts)
-
-Configuring
-#Define columns to display
-keys=["price","test?"]
-cg = CouchGrid(database, record_type=record_type, dictionaries=dicts,keys=keys)
-
-#Define column types to use
-hints = {"price": StringColumn}
-cg = CouchGrid(database, record_type=record_type, dictionaries=dicts,keys=keys, type_hints = hints)
-
-#A CouchGrid is a Dictionary Grid whcih is a TreeView,
-#so you can use DicationaryGrid and TreeView members
-cg.editable = True
-cg.get_column(0).set_title("Price")
-
-Extending
-To change the way CouchGrid persists data, change _refresh_treeview to
-handle persistence of data if needed, calling DictionaryGrid._populate_treeivew
-to handle the UI. You should do the same with append_row.
- 
-You may also want to override _edited and _edited_toggled to handle persistence 
-when the UI is changed.
-
-It is only useful to extend CouchGrid if you are using desktopcouch for
-persistence. Otherwise, derive from DictionaryGrid.
-
-"""
-
-import gtk
-import gobject
-from desktopcouch.records.server import CouchDatabase
-from desktopcouch.records.record import Record
-from quickly.widgets.dictionary_grid import DictionaryGrid
-from quickly.widgets.grid_column import CheckColumn
-
-class CouchGrid(DictionaryGrid):
-    def __init__(
-            self, database_name, record_type=None, dictionaries=None, editable=False, keys=None, type_hints=None, uri=None):
-        """Create a new Couchwidget
-        arguments:
-        database_name - specify the name of the database in the desktop
-        couchdb to use. If the specified database does not exist, it
-        will be created.
-
-        optional arguments:
-        record_type - a string to specify the record_type to use in
-        retrieving and creating records. Note that if no records exist
-        in the CouchDB then the keys argument must also be used or
-        a RuntimeError will result.
-
-        dictionaries - a list of dictionaries to initialize in the 
-        grid. If these haven't been added to desktopcouch, the will
-        be automatically persisted and updated using the recored_type
-        specified. Any previously saved data of the same record_type will
-        also be displayed. 
-
-        keys - a list of strings specifying keys to use in
-        the columns of the CouchGrid. The keys will also be used for the
-        column titles and keys in desktop couch.
-
-        If a record does not contain a value for a specified key
-        the CouchGrid will simply display an empty cell of the 
-        appropriate type. If the widget is set to editable, 
-        the user will be able to add values to the database.
-
-        The types for the columns will be inferred by the key based on
-        some conventions. the key "id" is assumed to be an integer, as
-        is any key ending in " count". A key ending in "?" is assumed
-        to be a Boolean displayed with a checkbox. The key "price" is
-        assumed to be currency, as is any key ending in "count". There
-        may be others. Defaults can be overridden using type-hints. All
-        other keys will be assumed to be strings.
-        
-        type-hints - a dictionary containing keys specificed for the
-        TreeView and GridColumns. Used to override types inferred
-        by convention, or for changing the type of a column from
-        the default of a string to something else.
-
-        uri - A uri for the DesktopCouch. This is only used to 
-        choose a Couch database running remotely. The default is
-        to use the local desktopcouch database.
-
-        """
-
-        if type(database_name) is not type(str()):
-            raise TypeError("database_name is required and must be a string")
-
-        #set up the database before trying to use it
-        self.uri = uri
-        self._record_type = None
-        self._db = None
-        if record_type is not None:
-            self._record_type = record_type
-
-	#QUESTION: What is the purpose of this? 
-        #if dictionaries is not None and keys is None:
-        #    DictionaryGrid.__init__(self, None, editable, keys, type_hints)
-        #else:
-        #    DictionaryGrid.__init__(self, None, editable, keys, type_hints)
-       
-        # Have to leave it in for now. But this is certainly a bug. 
-        # Note: adding dicts to a CG adds to empty cols in the model between the key values and the couch dict.
-        if dictionaries is not None and keys is None:
-            DictionaryGrid.__init__(self, None, editable, keys, type_hints)
-        else:
-            DictionaryGrid.__init__(self, None, editable, keys, type_hints)
-        
-
-        """
-        if dictionaries is not None and keys is not None:
-	        DictionaryGrid.__init__(self, dictionaries, editable, keys, type_hints)
-        elif keys is None:
-            DictionaryGrid.__init__(self, dictionaries, editable, None, type_hints)
-        elif dictionaries is None:
-            DictionaryGrid.__init__(self, None, editable, keys, type_hints)
-        """
-
-        
-        if self.uri:
-            self._db = CouchDatabase(database_name, create=True, uri=self.uri)
-        else:
-            self._db = CouchDatabase(database_name, create=True)
-
-        if dictionaries is not None:
-            for d in dictionaries:
-                self._persist_dict_to_couch(d)
-
-        self._refresh_treeview()
-
-    @property
-    def database(self):
-        """database - gets an instance to the CouchDB.
-        Set to a string to change the database.
-
-        """
-        return self._db
-
-    @database.setter
-    def database(self, db_name):
-        if self.uri:
-            self._db = CouchDatabase(db_name, create=True, uri=self.uri)
-        else:
-            self._db = CouchDatabase(db_name, create=True)
-        if self.record_type != None:
-            self._refresh_treeview()#first time treeview is reset
-
-    @property
-    def record_type(self):
-        """record_type - a string specifying the record type of
-        the documents to retrieve from the CouchDB.
-
-        Will cause the TreeView to refresh when set.
-        """
-        return self._record_type
-
-    @record_type.setter
-    def record_type(self, record_type):
-
-        #store the record type string
-        self._record_type = record_type
-        self._refresh_treeview()
-
-    @property
-    def selected_record_ids(self):
-        """ selected_record_ids - a list of document ids that are
-        selected in the CouchGrid. Throws an IndexError if
-        a specified id is not found in the list when setting
-        this property.
-
-        This property is read/write
-
-        """
-        ids = []
-        for row in self.selected_rows:
-            id_ = None
-            
-            if "__desktopcouch_id" in row:
-                id_ = row["__desktopcouch_id"]
-            ids.append(id_)
-        return ids
-
-    @selected_record_ids.setter
-    def selected_record_ids(self, indexes):
-        rows = [] #a list of rows to select
-        for id in indexes:
-            id_found = False #track if the id was found
-
-            for i,r in enumerate(self.list_store):
-                dictionary = r[len(self.keys)] #this dictionary always last column
-                if "__desktopcouch_id" in dictionary:
-                    if dictionary["__desktopcouch_id"] == id:
-                        id_found = True #id was good
-                        if r not in rows: #don't have duplicates to select
-                            rows.append(i)
-            if not id_found: #stop if a requested id was not in the list
-                raise IndexError("id %s not found" %id)
-
-        #select the requested ids
-        selection = self.get_selection()
-        selection.unselect_all()
-        for r in rows:
-            selection.select_path(r)
-
-    def remove_selected_rows(self, delete=False):
-        rows_to_delete = self.selected_rows
-        if delete:
-            for r in rows_to_delete:
-                self.database.delete_record(r["__desktopcouch_id"])
-        DictionaryGrid.remove_selected_rows(self)
-
-    def _refresh_treeview(self):
-        """
-        _refresh_treeview: internal function to handle rebuilding
-        the gtk.TreeView along with columns and cell renderers. extends
-        DictionaryGrid._refresh_treeview by retrieving stored desktopcouch
-        records before calling DictionaryGrid._refresh_treeview. 
-
-        _refresh_treeview is not typically called directly,
-        but may be useful to override in subclasses.
-
-        """
-
-        #if the database is not set up, just return
-        if self._db is None or self._record_type is None:
-            return
-
-        #if keys aren't set, infer them from the collection
-        if len(self._dictionaries) > 0 and self.keys is None:
-            self._infer_keys_from_dictionaries()        
-
-        #retrieve the docs for the record_type, if any
-        results = self._db.get_records(
-            record_type=self._record_type,create_view=True)
-
-
-        #if there are no rows and no keys set, there is no
-        #way to build the grid, just raise an error
-        if len(results) == 0 and self._keys is None:
-            raise RuntimeError("Cannot infer columns for CouchGrid")
-
-        dicts = []
-        for r in results:
-            d = r.value
-
-            #hmmm, maybe make these so they get hidden rather than delete them
-            #hide the desktopcouch variabls
-            for key in d:
-                if key.startswith("_") and not key.startswith("__desktopcouch"):
-                    d["__desktopcouch" + key] = d[key]
-                    del(d[key])
-
-            d["__record_type"] = d["record_type"]
-            del(d["record_type"])
-            dicts.append(d)
-
-        self._dictionaries = dicts
-        DictionaryGrid._refresh_treeview(self)
-
-
-		# CheckColumn is special because it is a one-shot change. A StringColumn
-		# should not be saved for each keystroke, but CheckColumn should.
-        for c in self.get_columns():
-            if type(c) == CheckColumn:
-                c.renderer.connect("toggled",self._edited_toggled, c)
-            else:
-                c.renderer.connect("edited",self._edited, c)
-
-    def append_row(self, dictionary):
-        """append_row: add a row to the TreeView and to DesktopCouch. 
-        If keys are already set up only the the keys in the dictionary 
-        matching the keys used for columns will be displayed, though 
-        all the key value pairs will be saved to the DesktopCouch. 
-        If no keys are set up, and this is the first row, keys will be
-        inferred from the dictionary keys.
-
-        arguments:
-        dictionary - a dictionary to add to the Treeview and to DesktopCouch
-
-        """
-
-        if dictionary is None:
-            dictionary = {}
-
-        #Here we add rows to desktopcouch if needed
-        if "__desktopcouch_id" not in dictionary:
-            self._persist_dict_to_couch(dictionary)
-        DictionaryGrid.append_row(self,dictionary)
-
-    def _persist_dict_to_couch(self,dictionary):
-        """ _persist_dict_to_couch - internal implementation. may be useful
-        a subclass of CouchGrid, but not normally called directly.
-
-        """
-
-        dictionary["record_type"] = self.record_type
-        rec = Record(dictionary)
-        #meh, best not to save an empty row
-		# Perhaps we should raise an exception if not?
-        if len(dictionary) > 1:
-            doc_id = self._db.put_record(rec)
-            dictionary["__desktopcouch_id"] = doc_id
-            dictionary["__record_type"] = self.record_type
-            del(dictionary["record_type"])
-        
-                
-    def _edited_toggled(self, cell, path, col):
-        """ _edited_toggled - internal signal handler.
-        Updates the database if a cell in the Treeview
-        has been edited special cased for CheckColumns.
-
-        """
-
-        iter = self.list_store.get_iter(path)
-        key = col.key
-        active = not cell.get_active()
-        self._edited(cell, path, active, col)
-
-    def _edited(self, cell, path, new_val, col):
-        """ _edited - internal signal handler.
-        Updates the database if a cell in the Treeview
-        has been edited.
-
-        """
-        iter = self.list_store.get_iter(path)
-        key = col.key
-        dictionary = self.list_store.get_value(iter,len(self.keys))
-
-        if "__desktopcouch_id" not in dictionary: #the row has not been stored
-            #create a document
-            dictionary["record_type"] = self.record_type
-            rec = Record(dictionary)
-            doc_id = self._db.put_record(rec)
-            dictionary["__desktopcouch_id"] = doc_id
-            self.list_store.set_value(iter, len(self.keys), dictionary)
-
-        else: #it has been saved
-            #get the record id from the dictionary
-            #then update the datbase with the change
-            id = dictionary["__desktopcouch_id"]
-            key = col.key
-            self._db.update_fields(id,{key:new_val})
-
-def __show_selected(widget, row, widgets):
-    """Test function for selection properties of CouchGrid"""
-    tv, cg = widgets
-    disp = "Rows:\n"
-    for r in cg.selected_rows:
-        disp += str(r) + "\n"
-
-    disp += "\n\n_Ids:\n"
-    for r in cg.selected_record_ids:
-        disp += str(r) + "\n"
-
-    tv.get_buffer().set_text(disp)
-    
-def __select_ids(widget, widgets):
-    """Test function for selecting ids."""
-    entry, cg, lbl = widgets
-    cg.selected_record_ids = entry.get_text().split(",")
-
-if __name__ == "__main__":
-    """creates a test CouchGrid if called directly"""
-
-    from quickly.widgets.grid_column import StringColumn
-
-    #create and show a test window and container
-    win = gtk.Window(gtk.WINDOW_TOPLEVEL)
-    win.set_title("CouchGrid Test Window")
-    win.connect("destroy",gtk.main_quit)
-    win.show()
-    vbox = gtk.VBox(False, False)
-    vbox.show()
-    win.add(vbox)
-
-    #create a test widget with test database values
-    dicts = [{"test?":True,"price":100,"foo count":100,"Key4":"1004"},
-             {"test?":True,"price":100,"foo count":100,"Key4":"1004"},
-             {"test?":True,"price":100,"foo count":100,"Key4":"1004"}]
-
-    #create some settings
-    database = "couch_widget_test"
-    record_type="test_record_type"
-    keys=["price","test?"]
-    hints = {"price": StringColumn}
-    
-    #create it and part a bit
-    cg = CouchGrid(database, record_type=record_type, dictionaries=dicts,keys=keys, type_hints = hints)
-    cg.editable = True
-    cg.get_column(0).set_title("Price")
-
-    #finish out and run the test UI
-    cg.show()
-    vbox.pack_start(cg, False, True)
-    hbox = gtk.HBox(False, 5)
-    hbox.show()
-    tv = gtk.TextView()
-    tv.show()
-    tv.set_wrap_mode(gtk.WRAP_CHAR)
-    tv.set_size_request(300,-1)
-    cg.connect("selection-changed",__show_selected, (tv,cg))
-
-    id_vbox = gtk.VBox(False, 5)
-    id_vbox.show()
-
-    fb_lbl = gtk.Label("paste ids into the edit box to select them")
-    fb_lbl.show()
-
-    entry = gtk.Entry()
-    entry.show()
-
-    btn = gtk.Button("select ids")
-    btn.show()
-    btn.connect("clicked", __select_ids, (entry,cg, fb_lbl))
-
-    id_vbox.pack_start(fb_lbl, False, False)
-    id_vbox.pack_start(entry, False, False)
-    id_vbox.pack_end(btn, False, False)
-
-    hbox.pack_start(tv, False, False)
-    vbox.pack_end(hbox, False, False)
-    hbox.pack_end(id_vbox, False, False)
-
-    #run the test app
-    gtk.main()
-
 
=== modified file 'quickly/widgets/dictionary_grid.py'
--- quickly/widgets/dictionary_grid.py	2011-09-04 23:58:24 +0000
+++ quickly/widgets/dictionary_grid.py	2012-03-06 08:52:21 +0000
@@ -14,10 +14,10 @@
 #You should have received a copy of the GNU General Public License along 
 #with this program.  If not, see <http://www.gnu.org/licenses/>.
 ### END LICENSE
-"""A gtk.TreeView for Dictionaries
-Displays and persists data in a gtk.TreeView. Handles the
-set up of the gtk.TreeView, gtk.ListModel, gtk.TreeViewColumns,
-and gtk.CellRenderers.
+"""A Gtk.TreeView for Dictionaries
+Displays and persists data in a Gtk.TreeView. Handles the
+set up of the Gtk.TreeView, Gtk.ListModel, Gtk.TreeViewColumns,
+and Gtk.CellRenderers.
 
 Using
 #create a dictionary if you don't already have one
@@ -40,7 +40,7 @@
 hints = {"price": StringColumn}
 dg = CouchGrid(dictionaries=dicts,keys=keys, type_hints = hints)
 
-#A CouchGrid is gtk.TreeView, so you can use gtk.TreeView members
+#A CouchGrid is Gtk.TreeView, so you can use Gtk.TreeView members
 dg.get_column(0).set_title("Price")
 
 #Use the selection-changed signal and read from the DictionaryGrid
@@ -67,13 +67,13 @@
 
 """
 
-import gtk
-import gobject
+from gi.repository import GObject
+from gi.repository import Gtk
 import conventions
-from quickly.widgets.grid_column import StringColumn
+from grid_column import StringColumn
 from grid_column import CheckColumn
 
-class DictionaryGrid(gtk.TreeView):
+class DictionaryGrid(Gtk.TreeView):
     __gtype_name__ = "DictionaryGrid"
     
     def __init__(self, dictionaries=None, editable = False, keys=None, type_hints=None):
@@ -102,7 +102,7 @@
 
         """
 
-        gtk.TreeView.__init__(self)
+        Gtk.TreeView.__init__(self)
         self.list_store = None
         self.unfiltered_store = None
         self._keys = keys
@@ -115,7 +115,7 @@
             self._type_hints = {}
         else:
             self._type_hints = type_hints
-        self.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
+        self.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
         self._refresh_treeview()
 
         #signal handlers to track selection in the treeview
@@ -193,7 +193,7 @@
         # themselves, but for now this works. 
 
         for column in self.get_columns():
-		    column.set_editable(editable)
+            column.set_editable(editable)
         self._editable = editable
 
     @property
@@ -251,7 +251,7 @@
     def _refresh_treeview(self):
         """
         _refresh_treeview: internal function to handle rebuilding
-        the gtk.TreeView along with columns and cell renderers.. 
+        the Gtk.TreeView along with columns and cell renderers.. 
 
         _refresh_treeview is not typically called directly,
         but may be useful to override in subclasses.
@@ -350,7 +350,7 @@
         """
         remove_selected_rows: removes the rows currently selected
         in the TreeView UI from the TreeView as well as the backing
-        gtk.ListStore.
+        Gtk.ListStore.
 
         """
 
@@ -361,11 +361,11 @@
             return
 
         #store the last selected row to reselect after removal
-        next_to_select = rows[-1][0] + 1 - len(rows)
+        next_to_select = rows[-1].get_indices()[0] + 1 - len(rows)
         
         #loop through and remove
 
-        if type(model) is not gtk.ListStore:
+        if type(model) is not Gtk.ListStore:
             iters = [model.get_model().get_iter(path) for path in rows]
             store_iters = []
 
@@ -431,8 +431,8 @@
             
         #create the liststore with the designated types
         #the last column is always for storing the backing dict
-        col_types.append(gobject.TYPE_PYOBJECT)
-        self.list_store = gtk.ListStore(*col_types)
+        col_types.append(GObject.TYPE_PYOBJECT)
+        self.list_store = Gtk.ListStore(*col_types)
 
         for c in self.get_columns():
             self.__last_sorted_col = None
@@ -459,11 +459,11 @@
                 self.__last_sorted_col.set_sort_indicator(False)
         self.__last_sorted_col = column
 
-    __gsignals__ = {'cell-edited' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-        (gobject.TYPE_PYOBJECT,gobject.TYPE_PYOBJECT,gobject.TYPE_PYOBJECT,gobject.TYPE_PYOBJECT,gobject.TYPE_PYOBJECT)),
+    __gsignals__ = {'cell-edited' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,GObject.TYPE_PYOBJECT,GObject.TYPE_PYOBJECT,GObject.TYPE_PYOBJECT,GObject.TYPE_PYOBJECT)),
 
-            'selection-changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-            (gobject.TYPE_PYOBJECT,))
+            'selection-changed' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+            (GObject.TYPE_PYOBJECT,))
         }
 
 def __show_selected(widget, selected_rows, data=None):
@@ -488,14 +488,14 @@
                  {"key?": True, "price":33.00,"tags" : "ccc ddd eee","_foo":"bar","bing count":15},
                  {"ID": 3, "tags" : "ddd eee fff","_foo":"bar"},
                  {"ID": 4, "price":5.00,"_foo":"bar"}]
-    #create and show a test window
-    win = gtk.Window(gtk.WINDOW_TOPLEVEL)
+    #create and show a test windowp
+    win = Gtk.Window()
     win.set_title("DictionaryGrid Test Window")
-    win.connect("destroy",gtk.main_quit)
+    win.connect("destroy",Gtk.main_quit)
     win.show()
 
     #create a top level container
-    vbox = gtk.VBox(False, False)
+    vbox = Gtk.VBox(False, False)
     vbox.show()
     win.add(vbox)
 
@@ -507,19 +507,19 @@
 
     #show the control, add it to the window, and run the main loop
     grid.show()
-    vbox.pack_start(grid, False, True)
+    vbox.pack_start(grid, False, False, 0)
 
     #create a test display area
-    hbox = gtk.HBox(False, 5)
+    hbox = Gtk.HBox(False, 5)
     hbox.show()
-    tv = gtk.TextView()
+    tv = Gtk.TextView()
     tv.show()
     grid.connect("selection-changed",__show_selected, tv)
     grid.connect("cell-edited",__on_edited, tv)
 
-    hbox.pack_start(tv, False, False)
-    vbox.pack_end(hbox, False, False)
+    hbox.pack_start(tv, False, False, 0)
+    vbox.pack_end(hbox, False, False, 0)
 
     #run the test app
-    gtk.main()
+    Gtk.main()
 
 
=== modified file 'quickly/widgets/grid_column.py'
--- quickly/widgets/grid_column.py	2011-09-04 23:58:24 +0000
+++ quickly/widgets/grid_column.py	2012-03-06 08:52:21 +0000
@@ -23,8 +23,8 @@
 to control the type of column used for a key in a dictionary.
 
 Customizing
-The column types in this module are all descendants of gtk.TreeView, so
-you can use all of the gtk.TreeView methods and properties to control
+The column types in this module are all descendants of Gtk.TreeView, so
+you can use all of the Gtk.TreeView methods and properties to control
 how a grid column looks or works.
 
 #Find a grid column and change the title
@@ -34,7 +34,7 @@
 
 Extending
 To display data in a column with a string, such as to display words and
-numbers, you should extend StringColumn. Otherwise, extend gtk.TreeView
+numbers, you should extend StringColumn. Otherwise, extend Gtk.TreeView
 directly. In either case, you will need to implement a set of functions.
 
 A Grid Column must track two different data, a "real" value, which is tracked
@@ -56,7 +56,7 @@
 a row does not contain a key, value pair for the specified column. For example
 StringColumn returns an empty string ("")
 
-A new column type will often require a specially configured gtk.CellRenderer.
+A new column type will often require a specially configured Gtk.CellRenderer.
 If you are deriving from StringColumn, but are using a custom renderer,
 you need to override the _initialize_renderer method, and set the 
 columns renderer property to the renderer. You should also connect the 
@@ -68,8 +68,8 @@
 _initialize_renderer:
 
     def _initialize_renderer( self, editable, index ):
-        self.renderer = gtk.CellRendererSpin()
-        adj = gtk.Adjustment(0,-10000000000,10000000000,1)
+        self.renderer = Gtk.CellRendererSpin()
+        adj = Gtk.Adjustment(0,-10000000000,10000000000,1)
         self.renderer.set_property("adjustment", adj)
         self.renderer.set_property("editable", editable)
         self.renderer.set_property("digits",2)
@@ -89,26 +89,20 @@
 """
 
 
-
 import sys
 import datetime
 import gettext
 from gettext import gettext as _
 gettext.textdomain('quickly-widgets')
 
-try:
-    import pygtk
-    pygtk.require("2.0")
-    import gtk
-    import gobject
-    import grid_filter
-
-
-except Exception, inst:
-    print "some dependencies for GridFilter are not available"
-    raise inst
-
-class GridColumn( gtk.TreeViewColumn ):
+import grid_filter
+
+from gi.repository import GObject
+from gi.repository import Gtk
+from gi.repository import Gdk
+
+
+class GridColumn( Gtk.TreeViewColumn ):
     """GridColumn - Base class that provides features that is important
     to all columns used in a DictionaryGrid or decendants. Currently
     it's useful only to StringColumn and CheckColumn, but should make it
@@ -116,7 +110,7 @@
     """
 
     def __init__(self, key, index, dictionary_index, renderer, editable=True, format_function = None ):
-        gtk.TreeViewColumn.__init__(self, key, renderer, text=index)
+        Gtk.TreeViewColumn.__init__(self, key, renderer, text=index)
 
         self.set_clickable(True)
         self.set_resizable(True)
@@ -124,6 +118,7 @@
         self.index = index
         self.key = key
         self.dictionary_index = dictionary_index
+        # Why should list_store be set to None? 
         self.list_store = None
 
 
@@ -135,21 +130,22 @@
         
         rows = [tuple(r) + (i,) for i, r in enumerate(self.list_store)]
 
-        # I NEED TO HAVE A LOOK AT THIS IF-BLOCK. At least, it needs a comment. 
-        if sort_order == gtk.SORT_ASCENDING:
-            sort_order = gtk.SORT_DESCENDING
+        # Sort opposite of last time 
+        if sort_order == Gtk.SortType.ASCENDING:
+            sort_order = Gtk.SortType.DESCENDING
         else:
-            sort_order = gtk.SORT_ASCENDING
+            sort_order = Gtk.SortType.ASCENDING
 
         self.set_sort_order(sort_order)
         self.set_sort_indicator(True)
         
-        if sort_order == gtk.SORT_ASCENDING:
+        if sort_order == Gtk.SortType.ASCENDING:
             rows.sort(self._sort_ascending)
         else:
             rows.sort(self._sort_descending)
 
-        self.list_store.reorder([r[-1] for r in rows])
+        # Where does self.list_store come from? 
+        self.list_store.set_sort_column_id(self.index, sort_order)
 
     def set_editable(self, editable):
         self.renderer.set_property("editable", editable)
@@ -164,7 +160,7 @@
 
     """
 
-    column_type = gobject.TYPE_STRING
+    column_type = GObject.TYPE_STRING
     __sort_order = None
     default_filter = grid_filter.StringFilterBox
     def __init__(self, key, index, dictionary_index, editable=True, format_function = None ):
@@ -247,7 +243,7 @@
         cell_renderer - a reference to the specific cell_renderer that is
         formatting the string
 
-        tree_model - the gtk.ListStore that is the backing data for the
+        tree_model - the Gtk.ListStore that is the backing data for the
         DictionaryGrid that contains the column.
 
         iter - an iterator that references the row of the the DictionaryGrid
@@ -274,8 +270,7 @@
 
         """
 
-        self.renderer = gtk.CellRendererText()
-        self.renderer.mode = gtk.CELL_RENDERER_MODE_EDITABLE
+        self.renderer = Gtk.CellRendererText()
         self.renderer.set_property("editable", editable)
         self.renderer.connect("edited", self._cell_edited)
   
@@ -340,14 +335,14 @@
         return ""
 
 class CurrencyColumn( StringColumn ):
-    """CurrencyColumn - display data in currency format. Uses a gtk.Spinner
+    """CurrencyColumn - display data in currency format. Uses a Gtk.Spinner
     to display data and support editing if enabled. Store real values as float.
 
     Inherits from StringColumn.
 
     """
 
-    column_type = gobject.TYPE_STRING
+    column_type = GObject.TYPE_STRING
     default_filter = grid_filter.NumericFilterBox
     def __init__(self, key, index,dictionary_index, editable=True ):
         """Creates a CurrencyColumn
@@ -380,8 +375,8 @@
 
         """
 
-        self.renderer = gtk.CellRendererSpin()
-        adj = gtk.Adjustment(0,-10000000000,10000000000,1)
+        self.renderer = Gtk.CellRendererSpin()
+        adj = Gtk.Adjustment(0,-10000000000,10000000000,1)
         self.renderer.set_property("adjustment", adj)
         self.renderer.set_property("editable", editable)
         self.renderer.set_property("digits",2)
@@ -494,19 +489,19 @@
 
     """
 
-    column_type = gobject.TYPE_STRING
+    column_type = GObject.TYPE_STRING
     default_filter = grid_filter.TagsFilterBox
 
 
 class IntegerColumn( StringColumn ):
-    """IntegerColumn - display data in Integer format. Uses a gtk.Spinner
+    """IntegerColumn - display data in Integer format. Uses a Gtk.Spinner
     to display data and support editing if enabled. Store real values as int.
 
     Inherits from StringColumn.
 
     """
 
-    column_type = gobject.TYPE_STRING
+    column_type = GObject.TYPE_STRING
     default_filter = grid_filter.IntegerFilterBox
 
     def __init__(self, key, index, dictionary_index, editable=True ):
@@ -529,8 +524,8 @@
         StringColumn.__init__( self, key, index, dictionary_index, editable)
 
     def _initialize_renderer( self, editable, index ):
-        self.renderer = gtk.CellRendererSpin()
-        adj = gtk.Adjustment(0,-10000000000,10000000000,1)
+        self.renderer = Gtk.CellRendererSpin()
+        adj = Gtk.Adjustment(0,-10000000000,10000000000,1)
         self.renderer.set_property("adjustment", adj)
         self.renderer.set_property("editable", editable)
         self.renderer.connect("edited", self._cell_edited)
@@ -640,11 +635,11 @@
 class CheckColumn( GridColumn ):
     """CheckColumn - display data as checkboxes. Store real values as bool.
 
-    Inherits from gtk.TreeViewColumn.
+    Inherits from Gtk.TreeViewColumn.
 
     """
 
-    column_type = gobject.TYPE_INT
+    column_type = GObject.TYPE_INT
     default_filter = grid_filter.CheckFilterBox
 
     def __init__(self, key, index, dictionary_index, editable=True, format_function = None ):
@@ -684,7 +679,7 @@
         y = y[self.index]
         return x - y
 
-    def _on_format(self,column, cell_renderer, tree_model, iter):
+    def _on_format(self,column, cell_renderer, tree_model, iter, format_function):
         cell_val = tree_model.get_value(iter, self.index)
         cell_renderer.set_property('inconsistent', False)
         if  cell_val == 1:        
@@ -698,9 +693,9 @@
             self.extra_format_function()
     
     def _initialize_renderer( self, editable, index ):
-        self.renderer = gtk.CellRendererToggle()
+        self.renderer = Gtk.CellRendererToggle()
         self.renderer.set_property("activatable", editable)
-        col = gtk.TreeViewColumn(self.key, self.renderer, active=index)
+        col = Gtk.TreeViewColumn(self.key, self.renderer, active=index)
         self.renderer.connect("toggled", self.toggled)
 
     def toggled(self, cell, path, data=None):
@@ -772,14 +767,14 @@
             return bool(val)
 
 class DateColumn( StringColumn ):
-    """DateColumn - display data in date format. Uses a gtk.Calendar
+    """DateColumn - display data in date format. Uses a Gtk.Calendar
     to display data and support editing if enabled. Store real values as tuple.
 
     Inherits from StringColumn.
 
     """
 
-    column_type = gobject.TYPE_STRING
+    column_type = GObject.TYPE_STRING
     default_filter = grid_filter.DateFilterBox
 
     def __init__(self, key, index,dictionary_index, editable=True ):
@@ -816,27 +811,27 @@
         self.renderer.set_property('editable',self._editable)
         self.renderer.connect("edited", self._cell_edited)
         
-class CellRendererDate(gtk.CellRendererText):
+class CellRendererDate(Gtk.CellRendererText):
     def __init__(self):
-        gtk.CellRendererText.__init__(self)
+        Gtk.CellRendererText.__init__(self)
         self.date_format = '%Y-%m-%d'
 
         self.calendar_window = None
         self.calendar = None
 
     def _create_calendar(self, treeview):
-        self.calendar_window = gtk.Dialog(parent=treeview.get_toplevel())
+        self.calendar_window = Gtk.Dialog(parent=treeview.get_toplevel())
         self.calendar_window.action_area.hide()
         self.calendar_window.set_decorated(False)
         self.calendar_window.set_property('skip-taskbar-hint', True)
 
-        self.calendar = gtk.Calendar()
-        self.calendar.display_options(gtk.CALENDAR_SHOW_DAY_NAMES | gtk.CALENDAR_SHOW_HEADING)
+        self.calendar = Gtk.Calendar()
+        self.calendar.display_options(Gtk.CalendarDisplayOptions.SHOW_DAY_NAMES | Gtk.CalendarDisplayOptions.SHOW_HEADING)
         self.calendar.connect('day-selected-double-click', self._day_selected, None)
         self.calendar.connect('key-press-event', self._day_selected)
         self.calendar.connect('focus-out-event', self._selection_cancelled)
         self.calendar_window.set_transient_for(None) # cancel the modality of dialog
-        self.calendar_window.vbox.pack_start(self.calendar)
+        self.calendar_window.vbox.pack_start(self.calendar, True, True, 0)
 
         # necessary for getting the (width, height) of calendar_window
         self.calendar.show()
@@ -871,20 +866,20 @@
     
         response = self.calendar_window.run()
         self.calendar_window.hide()
-        if response == gtk.RESPONSE_OK:
+        if response == Gtk.ResponseType.OK:
             (year, month, day) = self.calendar.get_date()
-            date = datetime.date(year, month + 1, day).strftime(self.date_format) # gtk.Calendar's month starts from zero
+            date = datetime.date(year, month + 1, day).strftime(self.date_format) # Gtk.Calendar's month starts from zero
             self.emit('edited', path, date)
             
-        return None # don't return any editable, our gtk.Dialog did the work already
+        return None # don't return any editable, our Gtk.Dialog did the work already
 
     def _day_selected(self, calendar, event):
         # event == None for day selected via doubleclick
-        if not event or event.type == gtk.gdk.KEY_PRESS and gtk.gdk.keyval_name(event.keyval) == 'Return':
-            self.calendar_window.response(gtk.RESPONSE_OK)
+        if not event or event.type == Gdk.EventType.KEY_PRESS and Gdk.keyval_name(event.keyval) == 'Return':
+            self.calendar_window.response(Gtk.ResponseType.OK)
             return True
 
     def _selection_cancelled(self, calendar, event):
-        self.calendar_window.response(gtk.RESPONSE_CANCEL)
+        self.calendar_window.response(Gtk.ResponseType.CANCEL)
         return True
 
 
=== modified file 'quickly/widgets/grid_filter.py'
--- quickly/widgets/grid_filter.py	2010-12-18 16:06:52 +0000
+++ quickly/widgets/grid_filter.py	2012-03-06 08:52:21 +0000
@@ -15,12 +15,12 @@
 ### END LICENSE
 
 """Widgets and Objects for filtering a DictionaryGrid
-GridFilter is as gtk.VBox that provides filtering UI for a 
+GridFilter is as Gtk.VBox that provides filtering UI for a 
 DictionaryGrid. Provides multiple filters, and choosing 
 between "And" and "Or" filtering. Provides default filters appropriate
 for each column.
 
-GridFilter row is a gtk.HBox that is a container for displaying FilterCombos.
+GridFilter row is a Gtk.HBox that is a container for displaying FilterCombos.
 
 FilterCombos display a filter and handle filtering of rows to
 display and hide in the associated DictionaryGrid. The GridColumns
@@ -60,374 +60,370 @@
   self.append("starts with",lambda x,y: x.startswith(y))
   self.append("ends with",lambda x,y: x.endswith(y))
 
-Filter UI could be created to use widgets other than gtk.Combo so long as
-the widget has a get_model function that returns a gtk.ListStore with
+Filter UI could be created to use widgets other than Gtk.Combo so long as
+the widget has a get_model function that returns a Gtk.ListStore with
 filtering functions stored as the last value (column) in the liststore.
 
 """
 
+
 import sys
 import datetime
 import gettext
 from gettext import gettext as _
 gettext.textdomain('quickly-widgets')
 
-try:
- import pygtk
- pygtk.require("2.0")
- import gtk
- import gobject
-
-except Exception, inst:
- print "some dependencies for GridFilter are not available"
- raise inst
-
-class GridFilter( gtk.VBox ):
- """GridFilter: A widget that provides a user interface for filtering a
- treeview. A GridFilter hosts one ore more GridRows, which in turn host
- an active filter.
-
- """
- def __init__(self, grid, filter_hints={} ):
-  """Create a GridFilter for filtering an associated treeview.
-  This class is used by BugsPane.
-
-  arguments:
-  grid - A DictionaryGrid to filter
-
-  options arguments:
-  filter_hints - a dictionary of column keys to FilterCombo types to
-  provide custom filtering. 
- 
-  """
-
-  gtk.VBox.__init__( self, False, 10 )
-  self.grid = grid  
-  self.store = grid.get_model()
-  self.filter_hints = filter_hints
-
-  #create the and/or radio buttons
-  radio_box = gtk.HBox(False,2)
-  radio_box.show()
-  self.pack_start(radio_box, False, False)
-  self.and_button = gtk.RadioButton(None,_("M_atch All of the following"), True)
-  self.and_button.show()
-  self.and_button.connect("toggled",self.__filter_changed)
-  radio_box.pack_start(self.and_button, False, False)
-  or_button = gtk.RadioButton(self.and_button,_("Match any _of the following"), True)
-  or_button.show()
-  radio_box.pack_start(or_button, False, False)
-  self.rows = []
-  self._add_row(self)
-
- def _add_row(self, widget, data=None):
-  """_add_row: internal signal handler that receives a request 
-  from a FilterRow to add a new row. Sets up and adds the row to the GridFilter.
-
-  Do not call directly
-  """
-
-  #TODO: I suppose this is leaking references to filter rows
-  row = FilterRow(self.grid, len(self.rows) > 0, self.filter_hints )
-  row.connect('add_row_requested',self._add_row)
-  row.connect('remove_row_requested',self._remove_row)
-  row.connect('refilter_requested',self.__filter_changed)
-  row.show()
-  self.rows.append(row)
-  self.pack_start(row, False, False)
- 
- def _remove_row(self, widget, data=None):
-  """_remove_row: internal signal handler that receives a 
-  request from a FilterRow to remove itself from the GridFilter.
-
-  Do not call directly
-  """
-
-  self.rows.remove(widget)
-  self.remove(widget)
-  self.__filter_changed(self)
-
- def __filter_changed(self,widget, data=None):
-  """__filter_changed: internal signal handler that handles 
-  requests to reapply the fitlers in the GridFilter's FilterRows.
-
-  """
-
-  filt = self.store.filter_new()
-  sort_mod = gtk.TreeModelSort(filt)
-  filt.set_visible_func(self.__filter_func, data )
-  filt.refilter()
-  self.grid.set_model(sort_mod)
-  
- def __filter_func(self, model, iter, data):
-  """filter_func: called for each row in the treeview model in response to
-  a __filter_changed signal. Determines for each row whether it should be
-  visible based on the FilterRows in the GridFilter.
-
-
-  Do not call directly
-  """
-  #determine whether this is an "and" or an "or" filter
-  match_all = self.and_button.get_active()
-
-  for r in self.rows:
-   rez = r.is_match(iter.copy(),model)  #check the result of each filter
-   if match_all:                        #if it's an "and" filter
-    if not rez:                         #and if the filter does not match
-     return False                       #then the row should not be visible
-   else:                                #but if it's an "or" filter
-    if rez:                             #and it is a match
-     return True                        #return that the row should be visible
-  return match_all  #all filters match an "and" or none matched an "or" 
-  
-class FilterRow( gtk.HBox):
- """FilterRow: A widget that displays a single filter in a GridFilter.
- Typically, this class will not be used directly, but only via a GridFilter.   
- 
- """
- wait_for_input = False
-
- def __init__(self, grid, removable=True, filter_hints={}):
-  """Create a FilterRow to be used in a GridFilter.
-  A FitlerRow is comprised of a combo that lists the treeview headings.
-  The combo stores the string to display for the heading, as well as
-  the widget that is used to filter each heading. When the user changes
-  the value in the dropdown, the FilterRow retrieves the correct filter from
-  the combo, and displays that filter to the user.
-
-  The FilterRow also handles offering UI for the user to add and remove
-  FilterRows for the GridFilter containing it.
+from gi.repository import GObject
+from gi.repository import Gtk
+
+class GridFilter( Gtk.VBox ):
+    """GridFilter: A widget that provides a user interface for filtering a
+    treeview. A GridFilter hosts one ore more GridRows, which in turn host
+    an active filter.
+     """
+
+    def __init__(self, grid, filter_hints={} ):
+        """Create a GridFilter for filtering an associated treeview.
+        This class is used by BugsPane.
+
+        arguments:
+        grid - A DictionaryGrid to filter
+
+        options arguments:
+        filter_hints - a dictionary of column keys to FilterCombo types to
+        provide custom filtering. 
+ 
+        """
+
+        Gtk.VBox.__init__( self, False, 10 )
+        self.grid = grid  
+        self.store = grid.get_model()
+        self.filter_hints = filter_hints
+
+        #create the and/or radio buttons
+        radio_box = Gtk.HBox(False,2)
+        radio_box.show()
+        self.pack_start(radio_box, False, False, 0)
+        self.and_button = Gtk.RadioButton.new_with_label_from_widget(None,_("M_atch All of the following"))
+        self.and_button.show()
+        self.and_button.connect("toggled",self.__filter_changed)
+        radio_box.pack_start(self.and_button, False, False, 0)
+        or_button = Gtk.RadioButton.new_with_label_from_widget(self.and_button,_("Match any _of the following"))
+        or_button.show()
+        radio_box.pack_start(or_button, False, False, 0)
+        self.rows = []
+        self._add_row(self)
+
+    def _add_row(self, widget, data=None):
+        """_add_row: internal signal handler that receives a request 
+        from a FilterRow to add a new row. Sets up and adds the row to the GridFilter.
+
+        Do not call directly
+        """
+
+        #TODO: I suppose this is leaking references to filter rows
+        row = FilterRow(self.grid, len(self.rows) > 0, self.filter_hints )
+        row.connect('add_row_requested',self._add_row)
+        row.connect('remove_row_requested',self._remove_row)
+        row.connect('refilter_requested',self.__filter_changed)
+        row.show()
+        self.rows.append(row)
+        self.pack_start(row, False, False, 0)
+ 
+    def _remove_row(self, widget, data=None):
+        """_remove_row: internal signal handler that receives a 
+        request from a FilterRow to remove itself from the GridFilter.
+
+        Do not call directly
+        """
+
+        self.rows.remove(widget)
+        self.remove(widget)
+        self.__filter_changed(self)
+
+    def __filter_changed(self,widget, data=None):
+        """__filter_changed: internal signal handler that handles 
+        requests to reapply the fitlers in the GridFilter's FilterRows.
+
+        """
+
+        filt = self.store.filter_new()
+        sort_mod = Gtk.TreeModelSort(model=filt)
+        filt.set_visible_func(self.__filter_func, data )
+        filt.refilter()
+        self.grid.set_model(sort_mod)
+  
+    def __filter_func(self, model, iter, data):
+        """filter_func: called for each row in the treeview model in response to
+        a __filter_changed signal. Determines for each row whether it should be
+        visible based on the FilterRows in the GridFilter.
+
+
+        Do not call directly
+        """
+        #determine whether this is an "and" or an "or" filter
+        match_all = self.and_button.get_active()
+
+        for r in self.rows:
+            rez = r.is_match(iter.copy(),model)  #check the result of each filter
+            if match_all:                        #if it's an "and" filter
+                if not rez:                         #and if the filter does not match
+                    return False                       #then the row should not be visible
+            else:                                #but if it's an "or" filter
+                if rez:                             #and it is a match
+                    return True                        #return that the row should be visible
+        return match_all  #all filters match an "and" or none matched an "or" 
+  
+class FilterRow( Gtk.HBox):
+    """FilterRow: A widget that displays a single filter in a GridFilter.
+    Typically, this class will not be used directly, but only via a GridFilter.   
+ 
+    """
+    wait_for_input = False
+
+    def __init__(self, grid, removable=True, filter_hints={}):
+        """Create a FilterRow to be used in a GridFilter.
+        A FitlerRow is comprised of a combo that lists the treeview headings.
+        The combo stores the string to display for the heading, as well as
+        the widget that is used to filter each heading. When the user changes
+        the value in the dropdown, the FilterRow retrieves the correct filter from
+        the combo, and displays that filter to the user.
+
+        The FilterRow also handles offering UI for the user to add and remove
+        FilterRows for the GridFilter containing it.
      
-  grid -  
-
-  keyword arguments:
-  removable - True if the row should be able to be removed from the GridFilter
-               Typicall False for the first row.
-
-  filter_hints - a dictionary of keys mapped to custom filters to apply to the
-  column designated by the key
-
-  """
-
-  gtk.HBox.__init__( self, False, 10 )
-  self.store = grid.get_model()
-  self.grid = grid
-
-  heading_combo_store = gtk.ListStore(gobject.TYPE_STRING,gobject.TYPE_PYOBJECT,gobject.TYPE_INT)
-
-  #apply default combos
-  for i, k in enumerate(self.grid.keys):
-   if k in filter_hints:
-    filt_combo = filter_hints[k]
-   else:
-    filt_combo = grid.get_columns()[i].default_filter()
+        grid -  
+
+        keyword arguments:
+        removable - True if the row should be able to be removed from the GridFilter
+                    Typicall False for the first row.
+
+        filter_hints - a dictionary of keys mapped to custom filters to apply to the
+        column designated by the key
+
+        """
+
+        Gtk.HBox.__init__( self, False, 10 )
+        self.store = grid.get_model()
+        self.grid = grid
+
+        heading_combo_store = Gtk.ListStore(GObject.TYPE_STRING,GObject.TYPE_PYOBJECT,GObject.TYPE_INT)
+
+
+        #apply default combos
+        for i, k in enumerate(self.grid.keys):
+            if k in filter_hints:
+                filt_combo = filter_hints[k]
+            else:
+                filt_combo = grid.get_columns()[i].default_filter()
          
-   column_title = grid.get_columns()[i].get_title()
-   heading_combo_store.append([column_title,filt_combo,i])
-
-   filt_combo.connect("changed",self.__filter_changed)
-   filt_combo.show()
- 
-  self.column_combo = gtk.ComboBox(heading_combo_store)
-  cell = gtk.CellRendererText()
-  self.column_combo.pack_start(cell, True)
-  self.column_combo.add_attribute(cell, 'text', 0)
-
-  self.filter_space = gtk.HBox(False,1)
-  self.filter_space.show()
-
-  self.column_combo.show()
-  vb = gtk.VBox(False, 5)
-  vb.show()
-  vb.pack_start(self.column_combo, True, False)
-  self.pack_start(vb,False, False)
-  self.column_combo.connect("changed",self.__column_changed)
-  self.column_combo.set_active(0)
-
-  self.pack_start(self.filter_space, False, False)
-
-  button_box = gtk.HBox(False,2)
-  button_box.show()
-  self.pack_start(button_box,False,False)
-
-  #add a button that can create a new row in the grid filter
-  add_button = gtk.Button(stock = gtk.STOCK_ADD)
-  add_button.show()
-  vb2 = gtk.VBox(False, 5)
-  vb2.show()
-  vb2.pack_start(add_button, True, False)
-  button_box.pack_start(vb2, False, False)
-  add_button.connect("clicked",lambda x: self.emit('add_row_requested',self) )
-
-  #add a button to remove the row if applicable
-  if removable:
-   rm_button = gtk.Button(stock = gtk.STOCK_REMOVE)
-   rm_button.show()
-   vb3 = gtk.VBox(False, 5)
-   vb3.show()
-   vb3.pack_start(rm_button, True, False)
-   rm_button.connect('clicked', lambda x: self.emit("remove_row_requested",self) )
-   button_box.pack_start(vb3)
-
- __gsignals__ = {'add_row_requested' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
-		'remove_row_requested' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
-		'refilter_requested' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,))
-		}
- 
- def __column_changed(self, widget, data = None):
-  """column_changed: internal signal handler for the user changing
-  the combo for the column that they wish to apply the filter to.
-  removes the other filter widgets and replaces them widgets stored in
-  the filter widget.
-
-  """
-
-  if len(self.filter_space.get_children()) > 0:
-   self.filter_space.remove(self.filter_space.get_children()[0])   
-  iter = widget.get_model().get_iter(widget.get_active())
-  filter_box = widget.get_model().get_value(iter,1)
-  self.filter_space.pack_start(filter_box, False, False)
-
- def __filter_changed(self,widget, data=None):
-  """filter_changed: internal signal handler called when the FilterRow has changed.
-  Used to tell the GridFilter to refilter. Only emits if the filter is 
-  active (a heading is selected in the combo and the user has entered
-  text in the filter.
-
-  """
+            column_title = grid.get_columns()[i].get_title()
+            heading_combo_store.append([column_title,filt_combo,i])
+
+            filt_combo.connect("changed",self.__filter_changed)
+            filt_combo.show()
+ 
+        self.column_combo = Gtk.ComboBox.new_with_model(heading_combo_store)
+        cell = Gtk.CellRendererText()
+        self.column_combo.pack_start(cell, True)
+        self.column_combo.add_attribute(cell, 'text', 0)
+
+        self.filter_space = Gtk.HBox(False,1)
+        self.filter_space.show()
+
+        self.column_combo.show()
+        vb = Gtk.VBox(False, 5)
+        vb.show()
+        vb.pack_start(self.column_combo, True, False, 0)
+        self.pack_start(vb,False, False, 0)
+        self.column_combo.connect("changed",self.__column_changed)
+        self.column_combo.set_active(0)
+
+        self.pack_start(self.filter_space, False, False, 0)
+
+        button_box = Gtk.HBox(False,2)
+        button_box.show()
+        self.pack_start(button_box,False,False, 0)
+
+        #add a button that can create a new row in the grid filter
+        add_button = Gtk.Button(stock = Gtk.STOCK_ADD)
+        add_button.show()
+        vb2 = Gtk.VBox(False, 5)
+        vb2.show()
+        vb2.pack_start(add_button, True, False, 0)
+        button_box.pack_start(vb2, False, False, 0)
+        add_button.connect("clicked",lambda x: self.emit('add_row_requested',self) )
+
+        #add a button to remove the row if applicable
+        if removable:
+            rm_button = Gtk.Button(stock = Gtk.STOCK_REMOVE)
+            rm_button.show()
+            vb3 = Gtk.VBox(False, 5)
+            vb3.show()
+            vb3.pack_start(rm_button, True, False, 0)
+            rm_button.connect('clicked', lambda x: self.emit("remove_row_requested",self) )
+            button_box.pack_start(vb3, True, True, 0)
+
+    __gsignals__ = {'add_row_requested' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,)),
+        'remove_row_requested' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,)),
+        'refilter_requested' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,))
+        }
+
+ 
+    def __column_changed(self, widget, data = None):
+        """column_changed: internal signal handler for the user changing
+        the combo for the column that they wish to apply the filter to.
+        removes the other filter widgets and replaces them widgets stored in
+        the filter widget.
+
+        """
+
+        if len(self.filter_space.get_children()) > 0:
+            self.filter_space.remove(self.filter_space.get_children()[0])   
+        iter = widget.get_model().get_iter(widget.get_active())
+        filter_box = widget.get_model().get_value(iter,1)
+        self.filter_space.pack_start(filter_box, False, False, 0)
+
+    def __filter_changed(self,widget, data=None):
+        """filter_changed: internal signal handler called when the FilterRow has changed.
+        Used to tell the GridFilter to refilter. Only emits if the filter is 
+        active (a heading is selected in the combo and the user has entered
+        text in the filter.
+
+        """
   
-  #if not self.wait_for_input:
-  #if self.__get_current_filter_combo().get_active > -1:
-  self.emit('refilter_requested',self)
-
- def __get_current_filter_combo(self):
-  """get_current_filter_combo: internal function that retrieves
-  the combobox stored for the filter for the user selected treeview column.
-
-  """
-  iter = self.column_combo.get_model().get_iter(self.column_combo.get_active())
-  return self.column_combo.get_model().get_value(iter,1)
-
- def is_match(self, store_iter, model):
-  """is_match: returns true if the filter set in the FilterRow matches
-  the value specified in the column and row. Used to determine whether 
-  to hide or show a row.
-
-  Typically called for each treeview row and each FilterRow in response
-  to a change in one of the FilterRows.
-
-  arguments:
-  store_iter: the iter pointing the the row in the treeview to test
-  model: the treeview model containing the rows being tested
-
-  """
-  col_iter = self.column_combo.get_model().get_iter(self.column_combo.get_active())
-  filter_widget = self.column_combo.get_model().get_value(col_iter,1)
-  treeview_col = self.column_combo.get_model().get_value(col_iter,2)
-
-  orig_val = model.get_value(store_iter.copy(), treeview_col)
-  return filter_widget.filter(orig_val)
-
-class BlankFilterBox( gtk.HBox):
- """BlankFilterBox provides a base class for FilterCombos, as
- well as an empty combo that can be used without subclassing
- by calling BlankFilterBox.append
-
- """
- __gsignals__ = {'changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
-		}
-
-
- def __init__(self):
-  """create a BlankFilterBox
-
-  """
-
-  gtk.HBox.__init__(self,False)
-  self.__combo_store = gtk.ListStore(gobject.TYPE_STRING,gobject.TYPE_PYOBJECT)
-  self.combo = gtk.ComboBox(self.__combo_store)
-  cell = gtk.CellRendererText()
-  self.combo.pack_start(cell, True)
-  self.combo.add_attribute(cell, 'text', 0)
-  self.combo.show()
-  self.combo.connect("changed",self.__changed)
-  self.entry = gtk.Entry()
-  self.entry.show()
-  self.entry.connect("changed",self.__changed)
-  self.pack_start(self.combo, False, False)
-  self.pack_start(self.entry)
-
- def filter(self, orig_val):
-  if self.combo.get_active() == -1:
-   return True
-  filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
-  filt_func = self.combo.get_model().get_value(filt_iter,1)
-  target_val = self.entry.get_text()
-  return filt_func(orig_val, self.entry.get_text())
-
- def __changed(self, widget, data=None):
-    self.emit("changed",data)
-
- def append(self, text, func):
-    """append: adds a row to the FilterCombo that includes a
-    string to display in the combo, and a function to determine
-    if a row should displayed or hidden by the filter. 
-
-    func should take a value indicated by text, and a value entered by
-    the user in the supplied gtk.TextEntry, and return True if the
-    row should be displayed or False if it should be hidden.
+        #if not self.wait_for_input:
+        #if self.__get_current_filter_combo().get_active > -1:
+        self.emit('refilter_requested',self)
+
+    def __get_current_filter_combo(self):
+        """get_current_filter_combo: internal function that retrieves
+        the combobox stored for the filter for the user selected treeview column.
+
+        """
+        iter = self.column_combo.get_model().get_iter(self.column_combo.get_active())
+        return self.column_combo.get_model().get_value(iter,1)
+
+    def is_match(self, store_iter, model):
+        """is_match: returns true if the filter set in the FilterRow matches
+        the value specified in the column and row. Used to determine whether 
+        to hide or show a row.
+
+        Typically called for each treeview row and each FilterRow in response
+        to a change in one of the FilterRows.
+
+        arguments:
+        store_iter: the iter pointing the the row in the treeview to test
+        model: the treeview model containing the rows being tested
+
+        """
+        col_iter = self.column_combo.get_model().get_iter(self.column_combo.get_active())
+        filter_widget = self.column_combo.get_model().get_value(col_iter,1)
+        treeview_col = self.column_combo.get_model().get_value(col_iter,2)
+
+        orig_val = model.get_value(store_iter.copy(), treeview_col)
+        return filter_widget.filter(orig_val)
+
+class BlankFilterBox( Gtk.HBox):
+    """BlankFilterBox provides a base class for FilterCombos, as
+    well as an empty combo that can be used without subclassing
+    by calling BlankFilterBox.append
 
     """
-
-    self.__combo_store.append([text, func])
+    __gsignals__ = {'changed' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,)),
+        }
+
+
+    def __init__(self):
+        """create a BlankFilterBox
+
+        """
+
+        Gtk.HBox.__init__(self,False)
+        self.__combo_store = Gtk.ListStore(GObject.TYPE_STRING,GObject.TYPE_PYOBJECT)
+        self.combo = Gtk.ComboBox.new_with_model(self.__combo_store)
+        cell = Gtk.CellRendererText()
+        self.combo.pack_start(cell, True)
+        self.combo.add_attribute(cell, 'text', 0)
+        self.combo.show()
+        self.combo.connect("changed",self.__changed)
+        self.entry = Gtk.Entry()
+        self.entry.show()
+        self.entry.connect("changed",self.__changed)
+        self.pack_start(self.combo, False, False, 0)
+        self.pack_start(self.entry, True, True, 0)
+
+    def filter(self, orig_val):
+        if self.combo.get_active() == -1:
+            return True
+        filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
+        filt_func = self.combo.get_model().get_value(filt_iter,1)
+        target_val = self.entry.get_text()
+        return filt_func(orig_val, self.entry.get_text())
+
+    def __changed(self, widget, data=None):
+        self.emit("changed",data)
+
+    def append(self, text, func):
+        """append: adds a row to the FilterCombo that includes a
+        string to display in the combo, and a function to determine
+        if a row should displayed or hidden by the filter. 
+
+        func should take a value indicated by text, and a value entered by
+        the user in the supplied Gtk.TextEntry, and return True if the
+        row should be displayed or False if it should be hidden.
+
+        """
+
+        self.__combo_store.append([text, func])
 
 class StringFilterBox( BlankFilterBox ):
- """StringFilterBox: A default string filter class for use in a FilterRow.
+    """StringFilterBox: A default string filter class for use in a FilterRow.
 
     Lets the user specify if the row should be displayed based on
     containing, not containing, starting with, or ending with a user specified
     string.
 
-
  """
- def __init__(self):
-  """create a StringFilterBox.
-
-  """
-
-  BlankFilterBox.__init__(self)
-  self.append(_("contains"),self.contains)
-  self.append(_("does not contain"),self.not_contains)
-  self.append(_("starts with"),self.starts_with)
-  self.append(_("ends with"),self.ends_with)
-
- def contains(self, orig_val, target_val):
-  if len(self.entry.get_text()) == 0 or orig_val is None:
-   return True
-  return orig_val.find(target_val) > -1
-
- def not_contains(self, orig_val, target_val):
-  if len(target_val) == 0 or orig_val is None:
-   return True
-  return orig_val.find(target_val) == -1
-
- def starts_with(self, orig_val, target_val):
-  if len(target_val) == 0 or orig_val is None:
-   return True
-  return orig_val.startswith(target_val)
-
- def ends_with(self, orig_val, target_val):
-  if len(target_val) == 0 or orig_val is None:
-   return True
-  return orig_val.endswith(target_val)
+
+    def __init__(self):
+        """create a StringFilterBox.
+
+        """
+
+        BlankFilterBox.__init__(self)
+        self.append(_("contains"),self.contains)
+        self.append(_("does not contain"),self.not_contains)
+        self.append(_("starts with"),self.starts_with)
+        self.append(_("ends with"),self.ends_with)
+
+    def contains(self, orig_val, target_val):
+        if len(self.entry.get_text()) == 0 or orig_val is None:
+            return True
+        return orig_val.find(target_val) > -1
+
+    def not_contains(self, orig_val, target_val):
+        if len(target_val) == 0 or orig_val is None:
+            return True
+        return orig_val.find(target_val) == -1
+
+    def starts_with(self, orig_val, target_val):
+        if len(target_val) == 0 or orig_val is None:
+            return True
+        return orig_val.startswith(target_val)
+
+    def ends_with(self, orig_val, target_val):
+        if len(target_val) == 0 or orig_val is None:
+            return True
+        return orig_val.endswith(target_val)
 
 
 class TagsFilterBox( BlankFilterBox ):
- """TagsFilterBox: A default tag filter class for use in a FilterRow.
+    """TagsFilterBox: A default tag filter class for use in a FilterRow.
 
     Lets the user specify if the row should be displayed based on
     containing a one tag or all tags. Assumes tags are seperated by
@@ -435,382 +431,382 @@
 
  """
 
- def __init__(self):
-  BlankFilterBox.__init__(self)
-  self.append(_("has any of these tags"), self._filter_any)
-  self.append(_("has all of these tags"), self._filter_all)
-  self.append(_("does not have one of these tags"), self._filter_not)
-  self.append(_("does not have any of these tags"), self._filter_not_all)
-
- def _filter_any(self, orig_val, target_val):
-  """
-  _filter_any: filter function that hides rows
-  if none of the tags supplied in "bugs_tags_s" are found
-  in the gtk.TextEntry.
-
-  Do not call directly
-
-  """
-
-  if len(target_val) == 0:
-   return True
-
-  tags_on_bug = orig_val.split()
-  tags_in_filter = target_val.split()
-
-  for tag in tags_in_filter:
-   if tag in tags_on_bug:
-    return True
-  return False
-
- def _filter_all(self, orig_val, target_val):
-  """
-  _filter_any: filter function that hides rows
-  if not all of the tags supplied in "bugs_tags_s" are found
-  in the gtk.TextEntry.
-
-  Do not call directly
-
-  """
-  if len(target_val) == 0:
-   return True
-
-  tags_on_bug = orig_val.split()
-  tags_in_filter = self.entry.get_text().split()
-
-  for tag in tags_in_filter:
-   if tag not in tags_on_bug:
-    return False
-  return True
-
- def _filter_not(self, orig_val, target_val):
-  """
-  _filter_not: filter function that hides rows
-  if one of the tags supplied in "bugs_tags_s" are found
-  in the gtk.TextEntry.
-
-  Do not call directly
-
-  """
-  if len(target_val) == 0:
-   return True
-
-  tags_on_bug = orig_val.split()
-  tags_in_filter = target_val.split()
+    def __init__(self):
+        BlankFilterBox.__init__(self)
+        self.append(_("has any of these tags"), self._filter_any)
+        self.append(_("has all of these tags"), self._filter_all)
+        self.append(_("does not have one of these tags"), self._filter_not)
+        self.append(_("does not have any of these tags"), self._filter_not_all)
+
+    def _filter_any(self, orig_val, target_val):
+        """
+        _filter_any: filter function that hides rows
+        if none of the tags supplied in "bugs_tags_s" are found
+        in the Gtk.TextEntry.
+
+        Do not call directly
+
+        """
+
+        if len(target_val) == 0:
+            return True
+
+        tags_on_bug = orig_val.split()
+        tags_in_filter = target_val.split()
+
+        for tag in tags_in_filter:
+            if tag in tags_on_bug:
+                return True
+        return False
+
+    def _filter_all(self, orig_val, target_val):
+        """
+        _filter_any: filter function that hides rows
+        if not all of the tags supplied in "bugs_tags_s" are found
+        in the Gtk.TextEntry.
+
+        Do not call directly
+
+        """
+        if len(target_val) == 0:
+            return True
+
+        tags_on_bug = orig_val.split()
+        tags_in_filter = self.entry.get_text().split()
+
+        for tag in tags_in_filter:
+            if tag not in tags_on_bug:
+                return False
+        return True
+
+    def _filter_not(self, orig_val, target_val):
+        """
+        _filter_not: filter function that hides rows
+        if one of the tags supplied in "bugs_tags_s" are found
+        in the Gtk.TextEntry.
+
+        Do not call directly
+
+        """
+        if len(target_val) == 0:
+            return True
+
+        tags_on_bug = orig_val.split()
+        tags_in_filter = target_val.split()
               
-  for tag in tags_in_filter:
-   if tag not in tags_on_bug:
-    return True
-  return False
-
- def _filter_not_all(self, orig_val, target_val):
-  """
-  _filter_not all: filter function that hides rows
-  if all of the tags supplied in "bugs_tags_s" are found
-  in the gtk.TextEntry.
-
-  Do not call directly
-
-  """
-  if len(self.entry.get_text()) == 0:
-   return True
-
-  tags_on_bug = orig_val.split()
-  tags_in_filter = target_val.split()
-
-  for tag in tags_in_filter:
-   if tag in tags_on_bug:
-    return False
-   return True
-  
-class IntegerFilterBox( gtk.HBox ):
- """
-
- """
- __gsignals__ = {'changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
-		}
-
- def __init__(self):
-  gtk.HBox.__init__(self, False, 10)
-  self.__combo_store = gtk.ListStore(gobject.TYPE_STRING,gobject.TYPE_PYOBJECT)
-  self.combo = gtk.ComboBox(self.__combo_store)
-  cell = gtk.CellRendererText()
-  self.combo.pack_start(cell, True)
-  self.combo.add_attribute(cell, 'text', 0)
-  self.combo.show()
-  self.combo.connect("changed",self.__changed)
-  adj = gtk.Adjustment(0,-1000000000,1000000000,1)
-  
-  self.spinner = gtk.SpinButton(adj,1,0)
-  self.spinner.set_activates_default(True)
-  self.spinner.show()
-  self.spinner.set_numeric(True)
-
-  self.spinner.connect("value-changed",self.__changed)
-  self.pack_start(self.combo, False, False)
-  self.pack_start(self.spinner)
-
-  self.__combo_store.append(["=",self._equals])
-  self.__combo_store.append(["<",self._less_than])
-  self.__combo_store.append([">",self._greater_than])
-  self.__combo_store.append(["<=",self._less_than_equals])
-  self.__combo_store.append([">=",self._greater_than_equals])
-
- def __changed(self, widget, data=None):
-    self.emit("changed",data)
-
- def filter(self, orig_val):
-  if self.combo.get_active() == -1:
-       return True
-
-  filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
-  filt_func = self.combo.get_model().get_value(filt_iter,1)
-
-  try:
-   target_val = int(self.spinner.get_value_as_int())
-
-
-  except Exception, inst:
-   print inst
-   return False
-
-  return filt_func(orig_val, target_val)
-
- def _equals(self, orig_val, target_val):
-  if orig_val == "":
-   return False
-  return int(orig_val) == target_val
-
- def _less_than(self, orig_val, target_val):
-  if orig_val == "":
-   return False
-  return int(orig_val) < target_val
-
- def _greater_than(self, orig_val, target_val):
-  if orig_val == "":
-   return False
-  return int(orig_val) > target_val
-
- def _less_than_equals(self, orig_val, target_val):
-  if orig_val == "":
-   return False
-  return int(orig_val) <= target_val
-
- def _greater_than_equals(self, orig_val, target_val):
-  if orig_val == "":
-   return False
-  return int(orig_val) >= target_val
-
-class DateFilterBox( gtk.HBox ):
- """DateFilterCombo: A default date filter class for use in a FilterRow.
+        for tag in tags_in_filter:
+            if tag not in tags_on_bug:
+                return True
+        return False
+
+    def _filter_not_all(self, orig_val, target_val):
+        """
+        _filter_not all: filter function that hides rows
+        if all of the tags supplied in "bugs_tags_s" are found
+        in the Gtk.TextEntry.
+
+        Do not call directly
+
+        """
+        if len(self.entry.get_text()) == 0:
+            return True
+
+        tags_on_bug = orig_val.split()
+        tags_in_filter = target_val.split()
+
+        for tag in tags_in_filter:
+            if tag in tags_on_bug:
+                return False
+            return True
+  
+class IntegerFilterBox( Gtk.HBox ):
+    """
+
+    """
+    __gsignals__ = {'changed' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,)),
+        }
+
+    def __init__(self):
+        Gtk.HBox.__init__(self, False, 10)
+        self.__combo_store = Gtk.ListStore(GObject.TYPE_STRING,GObject.TYPE_PYOBJECT)
+        self.combo = Gtk.ComboBox.new_with_model(self.__combo_store)
+        cell = Gtk.CellRendererText()
+        self.combo.pack_start(cell, True)
+        self.combo.add_attribute(cell, 'text', 0)
+        self.combo.show()
+        self.combo.connect("changed",self.__changed)
+        adj = Gtk.Adjustment(0,-1000000000,1000000000,1)
+  
+        self.spinner = Gtk.SpinButton.new(adj,1,0)
+        self.spinner.set_activates_default(True)
+        self.spinner.show()
+        self.spinner.set_numeric(True)
+
+        self.spinner.connect("value-changed",self.__changed)
+        self.pack_start(self.combo, False, False, 0)
+        self.pack_start(self.spinner, True, True, 0)
+
+        self.__combo_store.append(["=",self._equals])
+        self.__combo_store.append(["<",self._less_than])
+        self.__combo_store.append([">",self._greater_than])
+        self.__combo_store.append(["<=",self._less_than_equals])
+        self.__combo_store.append([">=",self._greater_than_equals])
+
+    def __changed(self, widget, data=None):
+        self.emit("changed",data)
+
+    def filter(self, orig_val):
+        if self.combo.get_active() == -1:
+            return True
+
+        filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
+        filt_func = self.combo.get_model().get_value(filt_iter,1)
+
+        try:
+            target_val = int(self.spinner.get_value_as_int())
+        except Exception, inst:
+            print inst
+            return False
+
+        return filt_func(orig_val, target_val)
+
+    def _equals(self, orig_val, target_val):
+        if orig_val == "":
+            return False
+        return int(orig_val) == target_val
+
+    def _less_than(self, orig_val, target_val):
+        if orig_val == "":
+            return False
+        return int(orig_val) < target_val
+
+    def _greater_than(self, orig_val, target_val):
+        if orig_val == "":
+            return False
+        return int(orig_val) > target_val
+
+    def _less_than_equals(self, orig_val, target_val):
+        if orig_val == "":
+            return False
+        return int(orig_val) <= target_val
+
+    def _greater_than_equals(self, orig_val, target_val):
+        if orig_val == "":
+            return False
+        return int(orig_val) >= target_val
+
+class DateFilterBox( Gtk.HBox ):
+    """DateFilterCombo: A default date filter class for use in a FilterRow.
 
     Lets the user specify if the row should be displayed based on
     the settings in a date widget.
 
- """
- __gsignals__ = {'changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
-		}
+    """
+    __gsignals__ = {'changed' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,)),
+        }
 
- def __init__(self):
-  """create a CheckFilterCombo
+    def __init__(self):
+        """create a CheckFilterCombo
   
-  """
-  gtk.HBox.__init__(self, False, 10)
-
-  self.__combo_store = gtk.ListStore(gobject.TYPE_STRING,gobject.TYPE_PYOBJECT)
-  self.combo = gtk.ComboBox(self.__combo_store)
-  cell = gtk.CellRendererText()
-  self.combo.pack_start(cell, False)
-  self.combo.add_attribute(cell, 'text', 0)
-  self.combo.show()
-  self.combo.connect("changed",self.__changed)
-
-  self.__combo_store.append([ _("before"),self.before ])
-  self.__combo_store.append([ _("on or before"),self.on_before ])
-  self.__combo_store.append([ _("on"), self.on_date ])
-  self.__combo_store.append([ _("on or after"),self.on_after ])
-  self.__combo_store.append([ _("after"),self.after ])
-
-  self.calendar = gtk.Calendar()
-  self.calendar.show()
-  self.calendar.connect("day-selected", self.__changed)
-  vb = gtk.VBox(False, 5)
-  vb.show()
-  vb.pack_start(self.combo, True, False)
-  self.pack_start(vb, False, False)
-  self.pack_start(self.calendar, False, False)
-
- def before(self, orig_val):
-   stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
-   if stored_date is None:
-    return False
-   return stored_date < target_date
-
- def on_before(self, orig_val):
-   stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
-   if stored_date is None:
-    return False
-   return stored_date <= target_date
-
- def on_date(self, orig_val):
-   stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
-   if stored_date is None:
-    return False
-   return stored_date == target_date
-
- def on_after(self, orig_val):
-   stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
-   if stored_date is None:
-    return False
-   return stored_date >= target_date
-
- def after(self, orig_val):
-   stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
-   if stored_date is None:
-    return False
-   return stored_date > target_date
-
- def __get_dates(self, orig_val, target_date):
-   target_date = self.calendar.get_date()
-   target_date = datetime.date(int(target_date[0]),int(target_date[1] + 1),int(target_date[2]))
-   if orig_val is not None and len(orig_val) > 0:
-    p = orig_val.split("-")
-    stored_date = datetime.date(int(p[0]),int(p[1]),int(p[2]))
-   else:
-    stored_date = None
-   return (stored_date, target_date)
-
- def filter(self, orig_val):
-  if self.combo.get_active() == -1:
-   return True
-
-  filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
-  filt_func = self.combo.get_model().get_value(filt_iter,1)
-  return filt_func(orig_val)
-
- def __changed(self, widget, data=None):
-  self.emit("changed",data)
-
-
-class CheckFilterBox( gtk.HBox ):
- """CheckFilterCombo: A default checkbox filter class for use in a FilterRow.
+        """
+        Gtk.HBox.__init__(self, False, 10)
+
+        self.__combo_store = Gtk.ListStore(GObject.TYPE_STRING,GObject.TYPE_PYOBJECT)
+        self.combo = Gtk.ComboBox.new_with_model(self.__combo_store)
+        cell = Gtk.CellRendererText()
+        self.combo.pack_start(cell, False)
+        self.combo.add_attribute(cell, 'text', 0)
+        self.combo.show()
+        self.combo.connect("changed",self.__changed)
+
+        self.__combo_store.append([ _("before"),self.before ])
+        self.__combo_store.append([ _("on or before"),self.on_before ])
+        self.__combo_store.append([ _("on"), self.on_date ])
+        self.__combo_store.append([ _("on or after"),self.on_after ])
+        self.__combo_store.append([ _("after"),self.after ])
+
+        self.calendar = Gtk.Calendar()
+        self.calendar.show()
+        self.calendar.connect("day-selected", self.__changed)
+        vb = Gtk.VBox(False, 5)
+        vb.show()
+        vb.pack_start(self.combo, True, False, 0)
+        self.pack_start(vb, False, False, 0)
+        self.pack_start(self.calendar, False, False, 0)
+
+    def before(self, orig_val):
+        stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
+        if stored_date is None:
+            return False
+        return stored_date < target_date
+
+    def on_before(self, orig_val):
+        stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
+        if stored_date is None:
+            return False
+        return stored_date <= target_date
+
+    def on_date(self, orig_val):
+        stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
+        if stored_date is None:
+            return False
+        return stored_date == target_date
+
+    def on_after(self, orig_val):
+        stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
+        if stored_date is None:
+            return False
+        return stored_date >= target_date
+
+    def after(self, orig_val):
+        stored_date, target_date = self.__get_dates(orig_val, self.calendar.get_date())
+        if stored_date is None:
+            return False
+        return stored_date > target_date
+
+    def __get_dates(self, orig_val, target_date):
+        target_date = self.calendar.get_date()
+        target_date = datetime.date(int(target_date[0]),int(target_date[1] + 1),int(target_date[2]))
+        if orig_val is not None and len(orig_val) > 0:
+            p = orig_val.split("-")
+            stored_date = datetime.date(int(p[0]),int(p[1]),int(p[2]))
+        else:
+            stored_date = None
+        return (stored_date, target_date)
+
+    def filter(self, orig_val):
+        if self.combo.get_active() == -1:
+            return True
+
+        filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
+        filt_func = self.combo.get_model().get_value(filt_iter,1)
+        return filt_func(orig_val)
+
+    def __changed(self, widget, data=None):
+        self.emit("changed",data)
+
+class CheckFilterBox( Gtk.HBox ):
+    """CheckFilterCombo: A default checkbox filter class for use in a FilterRow.
 
     Lets the user specify if the row should be displayed based on
     whether a Checkbox is active, inactive, or not set.
 
- """
- __gsignals__ = {'changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
-		}
+    """
+    __gsignals__ = {'changed' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_NONE,
+        (GObject.TYPE_PYOBJECT,)),
+        }
 
- def __init__(self):
-  """create a CheckFilterCombo
+    def __init__(self):
+        """create a CheckFilterCombo
   
-  """
-  gtk.HBox.__init__(self, False, 10)
-
-  self.__combo_store = gtk.ListStore(gobject.TYPE_STRING,gobject.TYPE_PYOBJECT)
-  self.combo = gtk.ComboBox(self.__combo_store)
-  cell = gtk.CellRendererText()
-  self.combo.pack_start(cell, True)
-  self.combo.add_attribute(cell, 'text', 0)
-  self.combo.show()
-  self.combo.connect("changed",self.__changed)
-
-  self.__combo_store.append([ _("checked"),self.filter_checked ])
-  self.__combo_store.append([ _("not Checked"),self.filter_not_checked ])
-  self.__combo_store.append([ _("unset"), self.filter_unset ])
-
-  self.pack_start(self.combo, False, False)
-
- def filter(self, orig_val):
-  if self.combo.get_active() == -1:
-   return True
-
-  filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
-  filt_func = self.combo.get_model().get_value(filt_iter,1)
-  return filt_func(orig_val)
-
- def filter_checked(self, orig_val):
-  return orig_val == 1
-
- def filter_not_checked(self, orig_val):
-  return orig_val == 0
-
- def filter_unset(self, orig_val):
-  return orig_val == -1
-
- def __changed(self, widget, data=None):
-  self.emit("changed",data)
+        """
+        Gtk.HBox.__init__(self, False, 10)
+
+        self.__combo_store = Gtk.ListStore(GObject.TYPE_STRING,GObject.TYPE_PYOBJECT)
+        self.combo = Gtk.ComboBox.new_with_model(self.__combo_store)
+        cell = Gtk.CellRendererText()
+        self.combo.pack_start(cell, True)
+        self.combo.add_attribute(cell, 'text', 0)
+        self.combo.show()
+        self.combo.connect("changed",self.__changed)
+
+        self.__combo_store.append([ _("checked"),self.filter_checked ])
+        self.__combo_store.append([ _("not Checked"),self.filter_not_checked ])
+        self.__combo_store.append([ _("unset"), self.filter_unset ])
+
+        self.pack_start(self.combo, False, False, 0)
+
+    def filter(self, orig_val):
+        if self.combo.get_active() == -1:
+            return True
+
+        filt_iter = self.combo.get_model().get_iter(self.combo.get_active())
+        filt_func = self.combo.get_model().get_value(filt_iter,1)
+        return filt_func(orig_val)
+
+    def filter_checked(self, orig_val):
+        return orig_val == 1
+
+    def filter_not_checked(self, orig_val):
+        return orig_val == 0
+
+    def filter_unset(self, orig_val):
+        return orig_val == -1
+
+    def __changed(self, widget, data=None):
+        self.emit("changed",data)
 
 
 class NumericFilterBox( BlankFilterBox ):
- """NumericFilterCombo: A default number filter class for use in a FilterRow.
+    """NumericFilterCombo: A default number filter class for use in a FilterRow.
 
     Lets the user specify if the row should be displayed based on numeric
     relationships to a number specified by the user.
 
- """
-
-
- def __init__(self):
-  """create a NumericFilterCombo
-
-  """
-  BlankFilterBox.__init__( self )
-  self.append("=",self._equals )
-  self.append("<",self._less_than )
-  self.append(">",self._greater_than )
-  self.append("<=",self._less_than_equals)
-  self.append(">=",self._greater_than_equals )
-
- def _equals(self, orig_val):
-  try:
-   return float(orig_val) == float(self.entry.get_text())
-  except:
-   return True
-
- def _less_than(self, orig_val):
-  try:
-   return float(orig_val) < float(self.entry.get_text())
-  except:
-   return True
-
- def _greater_than(self, orig_val):
-  try:
-   return float(orig_val) > float(self.entry.get_text())
-  except:
-   return True
-
- def _less_than_equals(self, orig_val):
-  try:
-   return float(orig_val) <= float(self.entry.get_text())
-  except:
-   return True
-
- def _greater_than_equals(self, orig_val):
-  try:
-   return float(orig_val) >= float(self.entry.get_text())
-  except:
-   return True
+    """
+
+
+    def __init__(self):
+        """create a NumericFilterCombo
+
+        """
+        BlankFilterBox.__init__( self )
+        self.append("=",self._equals )
+        self.append("<",self._less_than )
+        self.append(">",self._greater_than )
+        self.append("<=",self._less_than_equals)
+        self.append(">=",self._greater_than_equals )
+
+    def _equals(self, orig_val):
+        try:
+            return float(orig_val) == float(self.entry.get_text())
+        except:
+            return True
+
+    def _less_than(self, orig_val):
+        try:
+            return float(orig_val) < float(self.entry.get_text())
+        except:
+            return True
+
+    def _greater_than(self, orig_val):
+        try:
+            return float(orig_val) > float(self.entry.get_text())
+        except:
+            return True
+
+    def _less_than_equals(self, orig_val):
+        try:
+            return float(orig_val) <= float(self.entry.get_text())
+        except:
+            return True
+
+    def _greater_than_equals(self, orig_val):
+        try:
+            return float(orig_val) >= float(self.entry.get_text())
+        except:
+            return True
+
+
+# Test case begins here.
 
 def __delete_test(button, grid):
     grid.remove_selected_rows(delete=True)
 
 if __name__ == "__main__":
-    """creates a test CouchGrid if called directly"""
-    from couch_grid import CouchGrid
+    """creates a test DictionaryGrid and GridFilter if called directly"""
+    from dictionary_grid import DictionaryGrid
 
     #create and show a test window
-    win = gtk.Window(gtk.WINDOW_TOPLEVEL)
-    win.set_title("DictionaryGrid Test Window")
-    win.connect("destroy",gtk.main_quit)
+    win = Gtk.Window.new(Gtk.WindowType.TOPLEVEL)
+    win.set_title("CouchGrid Test Window")
+    win.connect("destroy",Gtk.main_quit)
     win.show()
 
     #create a top level container
-    vbox = gtk.VBox(False, 10)
+    vbox = Gtk.VBox(False, 10)
     vbox.show()
     win.add(vbox)
 
@@ -821,9 +817,7 @@
                  {"ID": 3, "key?": False, "tags": "ddd eee fff", "string":"dddddddd","date":"2010-10-01"},
                  {"ID": 4, "key?": True, "tags": "eee fff ggg", "string":"eeeeeeee","date":"2010-11-01"}]
 
-    database_name = "couch_widget_test"
-    record_type = "couch_grid_filter_test"
-    grid = CouchGrid(database_name, record_type=record_type, dictionaries=dicts, editable=True)
+    grid = DictionaryGrid(dictionaries=dicts, editable=True)
     grid.columns["tags"].set_title("modified title")
     grid.show()
 
@@ -831,15 +825,15 @@
     hints = {}
     filt = GridFilter(grid,hints)
     filt.show()
-    vbox.pack_start(filt, False, False)
-    vbox.pack_end(grid, True, True)
+    vbox.pack_start(filt, False, False, 0)
+    vbox.pack_end(grid, True, True, 0)
 
-    delete_button = gtk.Button("Delete Selected")
+    delete_button = Gtk.Button("Delete Selected")
     delete_button.connect("clicked",__delete_test,grid)
     delete_button.show()
 
 
-    vbox.pack_start(delete_button,False, False)
-    gtk.main()
+    vbox.pack_start(delete_button,False, False, 0)
+    Gtk.main()
 
 
 
=== modified file 'quickly/widgets/media_player_box.py'
--- quickly/widgets/media_player_box.py	2011-01-17 03:40:02 +0000
+++ quickly/widgets/media_player_box.py	2012-03-06 08:52:21 +0000
@@ -50,14 +50,14 @@
 #You can add Widgets to the MediaPlayerBox simply by packing them in
 player.pack_start(my_widget, False, False)
 
-#You can get a reference to the controls, which are a gtk.Toolbar
-mybutton = gtk.ToolButton()
+#You can get a reference to the controls, which are a Gtk.Toolbar
+mybutton = Gtk.ToolButton()
 player.controls.insert(mybutton, 0)
 
 #You can access the playbutton, slider, or time label directly as well
-player.play_button.hide()#a gtk.ToggleToolButton
-player.slider.hide()#a gtk.HScale
-player.time_label.hide()#a gtk.Label
+player.play_button.hide()#a Gtk.ToggleToolButton
+player.slider.hide()#a Gtk.HScale
+player.time_label.hide()#a Gtk.Label
 
 #If you want access to all the gstreamer knobs and dials, you can just
 #get a reference to the playbin (see gstreamer documentation for details.
@@ -67,13 +67,13 @@
 player.playbin.emit(signal_name)
 
 Extending
-A WebCamBox is gtk.VBox
-A WebCamBox is a gtk.VBox that contains a gtk.DrawingArea for displaying
+A WebCamBox is Gtk.VBox
+A WebCamBox is a Gtk.VBox that contains a Gtk.DrawingArea for displaying
 video output, and a thin wrapper around a playbin, which is a gstreamer
 pipleine sublcass that provides all the media playing functionality.
 
 To add GUI elements simple, create them and pack them into MediaPlayerBox, since
-it's just a gtk.VBox
+it's just a Gtk.VBox
 
 Similarly, to add to or change the media player functionality, modify properties on
 the playbin. You may also want to overide _on_message and/or _on_sync_message
@@ -81,18 +81,21 @@
 
 """
 
+
 import sys
 import os
-import gtk
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GdkX11
+from gi.repository import GObject
 import gst
 import datetime
-import gobject
 
 import gettext
 from gettext import gettext as _
 gettext.textdomain('quickly-widgets')
 
-class MediaPlayerBox(gtk.VBox):
+class MediaPlayerBox(Gtk.VBox):
     """MediaPlayerBox - A VBox that tries to play the media file as defined by it's URU property.
        It works for video and sound files.
 
@@ -102,13 +105,13 @@
         """Creates a MediaPlayerBox, Note that this does not start media.
         For that, set the uri property and then call play().
         
-        This function has no arguments
+        This function has no argumentsf
 
         """
-        gtk.VBox.__init__(self, False, 5)
-        self.video_window = gtk.DrawingArea()
+        Gtk.VBox.__init__(self, False, 5)
+        self.video_window = Gtk.DrawingArea()
         self.video_window.connect("realize",self.__on_video_window_realized)
-#        self.pack_start(self.video_window, True, True)
+#        self.pack_start(self.video_window, True, True, 0)
         self.video_window.show()
         self.connect("destroy", self.on_destroy)
 
@@ -121,21 +124,21 @@
         self.__uri = ""
         self.realized = False
 
-        self.controls = gtk.Toolbar()
+        self.controls = Gtk.Toolbar()
         if show_controls:
             self.controls.show()
-        self.pack_start(self.controls, False, False)
-        self.pack_start(self.video_window, True, True)
+        self.pack_start(self.controls, False, False, 0)
+        self.pack_start(self.video_window, True, True, 0)
 
-        self.play_button = gtk.ToggleToolButton()
-        self.play_button.set_stock_id(gtk.STOCK_MEDIA_PLAY)
+        self.play_button = Gtk.ToggleToolButton()
+        self.play_button.set_stock_id(Gtk.STOCK_MEDIA_PLAY)
         self.play_button.show()
         self._play_button_toggled_handler = self.play_button.connect("toggled",self._play_button_toggled)
         self.controls.add(self.play_button)
         
-        item = gtk.ToolItem()
+        item = Gtk.ToolItem()
         item.show()
-        self.slider = gtk.HScale()
+        self.slider = Gtk.HScale()
         self.slider_changed_handler = None
         self.slider.set_draw_value(False)
         self.slider.set_increments(10,60)
@@ -145,9 +148,9 @@
         item.add(self.slider)
         self.controls.insert(item, -1)
 
-        item2 = gtk.ToolItem()
+        item2 = Gtk.ToolItem()
         item2.show()
-        self.time_label = gtk.Label("")
+        self.time_label = Gtk.Label("")
         self.time_label.show()
         item2.add(self.time_label)
         self.controls.insert(item2, -1)
@@ -175,7 +178,7 @@
         self.slider.set_sensitive(True)
         self._reformat_slider()
         self._start_slider_updates()
-        self.play_button.set_stock_id(gtk.STOCK_MEDIA_PAUSE)
+        self.play_button.set_stock_id(Gtk.STOCK_MEDIA_PAUSE)
         self._set_play_button_active(True)
 
     def pause(self):
@@ -186,11 +189,12 @@
         This function has no arguments
         
         """
+
         self.playbin.set_state(gst.STATE_PAUSED)
         self.slider.set_sensitive(True)
         self._reformat_slider()
         self.slider.set_sensitive(True)
-        self.play_button.set_stock_id(gtk.STOCK_MEDIA_PLAY)
+        self.play_button.set_stock_id(Gtk.STOCK_MEDIA_PLAY)
         self._set_play_button_active(False)
 
     def stop(self):
@@ -203,7 +207,7 @@
 
         self.playbin.set_state(gst.STATE_NULL)
         self.slider.set_sensitive(False)
-        self.play_button.set_stock_id(gtk.STOCK_MEDIA_PLAY)
+        self.play_button.set_stock_id(Gtk.STOCK_MEDIA_PLAY)
         self._set_play_button_active(False)
         self.slider.set_value(0)
 
@@ -305,7 +309,7 @@
         if self.playbin.get_state()[1] == gst.STATE_NULL:
             self.slider.set_range(0, 0)
         else:
-            gobject.idle_add(self._set_slider_range)
+            GObject.idle_add(self._set_slider_range)
 
     def _set_slider_range(self):
         dur = self.duration
@@ -313,16 +317,16 @@
             return True
         else:
             self._duration_time_str = self._formatted_time(dur)
-            gtk.gdk.threads_enter()
+            Gdk.threads_enter()
             self.slider.set_range(0, dur)
-            gtk.gdk.threads_leave()
+            Gdk.threads_leave()
             return False
 
     def _start_slider_updates(self):
         if self.playbin.get_state()[1] == gst.STATE_NULL:
             self.slide.set_value(0)
         else:
-            gobject.timeout_add(1000, self._set_slider_position)
+            GObject.timeout_add(1000, self._set_slider_position)
 
     def _set_slider_position(self):
         if self._slider_changed_handler is not None:
@@ -395,7 +399,7 @@
         if message_name == "prepare-xwindow-id":
             imagesink = message.src
             imagesink.set_property("force-aspect-ratio", True)
-            imagesink.set_xwindow_id(self.video_window.window.xid)
+            imagesink.set_xwindow_id(self.video_window.get_window().get_xid())
 
     def __on_video_window_realized(self, widget, data=None):
         """__on_video_window_realized - internal signal handler, used
@@ -407,16 +411,16 @@
         self._set_video_window_id()
 
     def _set_video_window_id(self):
-        if not self.realized and self.video_window.window is not None:
-            x = self.video_window.window.xid
+        if not self.realized and self.video_window.get_window() is not None:
+            x = self.video_window.get_window().get_xid()
             self.realized = True
 
     def on_destroy(self, widget, data=None):
         #clean up the camera before exiting
         self.playbin.set_state(gst.STATE_NULL)
 
-    __gsignals__ = {'end-of-file' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
+    __gsignals__ = {'end-of-file' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+		(GObject.TYPE_PYOBJECT,)),
 		} 
 
 def __seek_func(sender, mb):
@@ -445,16 +449,15 @@
 
 if __name__ == "__main__":
     """creates a test WebCamBox"""
-    import quickly.prompts
 
     #create and show a test window
-    win = gtk.Window(gtk.WINDOW_TOPLEVEL)
+    win = Gtk.Window()
     win.set_title("WebCam Test Window")
-    win.connect("destroy",gtk.main_quit)
+    win.connect("destroy",Gtk.main_quit)
     win.show()
 
     #create a top level container
-    vbox = gtk.VBox(False, 10)
+    vbox = Gtk.VBox(False, 10)
     vbox.show()
     win.add(vbox)
 
@@ -464,47 +467,47 @@
     vbox.add(mb)
     mb.show()
 
-    uri_entry = gtk.Entry()
+    uri_entry = Gtk.Entry()
 
-    play_butt = gtk.Button("Play")
-    pause_butt = gtk.Button("Pause")
-    stop_butt = gtk.Button("Stop")
-    seek_butt = gtk.Button("Seek")
-    controls_butt = gtk.ToggleButton("Controls")
-    time_label = gtk.Label("")
+    play_butt = Gtk.Button("Play")
+    pause_butt = Gtk.Button("Pause")
+    stop_butt = Gtk.Button("Stop")
+    seek_butt = Gtk.Button("Seek")
+    controls_butt = Gtk.ToggleButton("Controls")
+    time_label = Gtk.Label("")
 
     play_butt.connect("clicked", lambda x:mb.play())
     play_butt.show()
-    mb.pack_end(play_butt, False)
+    mb.pack_end(play_butt, False, False, 0)
 
     uri_entry.connect("activate", __set_uri, (mb, uri_entry))
     uri_entry.set_text("file:///home/rick/Videos/VID00110.AVI")
     uri_entry.show()
-    mb.pack_end(uri_entry, False)
+    mb.pack_end(uri_entry, False, False, 0)
 
     pause_butt.connect("clicked", lambda x:mb.pause())
     pause_butt.show()
-    mb.pack_end(pause_butt, False)
+    mb.pack_end(pause_butt, False, False, 0)
 
     stop_butt.connect("clicked", lambda x:mb.stop())
     stop_butt.show()
-    mb.pack_end(stop_butt, False)
+    mb.pack_end(stop_butt, False, False, 0)
 
     seek_butt.connect("clicked", __seek_func, mb)
     seek_butt.show()
-    mb.pack_end(seek_butt, False)
+    mb.pack_end(seek_butt, False, False, 0)
 
     controls_butt.connect("clicked", __controls_func, mb)
     controls_butt.show()
-    mb.pack_end(controls_butt, False)
+    mb.pack_end(controls_butt, False, False, 0)
 
     mb.connect("end-of-file", __on_media_ended)
 
     time_label.show()
-    mb.pack_end(time_label, False)
-
-    gobject.timeout_add(1000, __seek_time, (mb, time_label))
-
-    gtk.main()
+    mb.pack_end(time_label, False, False, 0)
+
+    GObject.timeout_add(1000, __seek_time, (mb, time_label))
+
+    Gtk.main()
 
 
 
=== modified file 'quickly/widgets/press_and_hold_button.py'
--- quickly/widgets/press_and_hold_button.py	2011-01-17 20:27:12 +0000
+++ quickly/widgets/press_and_hold_button.py	2012-03-06 08:52:21 +0000
@@ -34,14 +34,14 @@
 pah.set_labe("Press and Hold")
 
 Extending
-A PressAndHoldButton is gtk.Button
+A PressAndHoldButton is Gtk.Button
 
 """
 
-import gobject
-import gtk
+from gi.repository import GObject
+from gi.repository import Gtk
 
-class PressAndHoldButton(gtk.Button):
+class PressAndHoldButton(Gtk.Button):
     def __init__(self):
         """Create a PressAndHoldButton
 
@@ -51,7 +51,7 @@
 
         """
 
-        gtk.Button.__init__(self)
+        Gtk.Button.__init__(self)
         self.timeout = 250
         self.connect("pressed",self.__pressed)
         self.connect("released",self.__released)
@@ -60,7 +60,7 @@
     def __pressed(self, widget, data=None):
         self.__continue_ticking = True
         widget.emit("tick",self)
-        gobject.timeout_add(self.timeout, self.__tick)
+        GObject.timeout_add(self.timeout, self.__tick)
 
     def __released(self, widget, data=None):
         self.__continue_ticking = False
@@ -70,7 +70,44 @@
             self.emit("tick",self)
         return self.__continue_ticking
 
-    __gsignals__ = {'tick' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
+    __gsignals__ = {'tick' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+		(GObject.TYPE_PYOBJECT,)),
 		}
 
+def __test_tick(sender, widget, label):
+    """internal method for testing.
+    Do not use.
+    """
+
+    label.set_text(str(int(label.get_text()) + 1))
+    
+
+
+if __name__ == "__main__":
+    """creates a test PressAndHoldButton"""
+
+    #create and show a test window
+    win = Gtk.Window()
+    win.set_title("Press and Hold Test Window")
+    win.connect("destroy",Gtk.main_quit)
+    win.show()
+
+    #create a top level container
+    vbox = Gtk.VBox(False, 10)
+    vbox.show()
+    win.add(vbox)
+
+    button = PressAndHoldButton()
+    button.set_label("Press and hold")
+    button.show()
+    vbox.pack_start(button, False, False, 5)
+
+    label = Gtk.Label("0")
+    label.show()
+    vbox.pack_end(label, False, False, 5)
+
+    button.timeout = 10
+
+    button.connect("tick",__test_tick, label)
+
+    Gtk.main()
 
=== removed file 'quickly/widgets/tests/test_asycnh_task_progress_box.py'
--- quickly/widgets/tests/test_asycnh_task_progress_box.py	2010-03-30 23:38:02 +0000
+++ quickly/widgets/tests/test_asycnh_task_progress_box.py	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-### BEGIN LICENSE
-# Copyright (C) 2010 Rick Spencer [e-mail]
-#This program is free software: you can redistribute it and/or modify it 
-#under the terms of the GNU General Public License version 3, as published 
-#by the Free Software Foundation.
-#
-#This program is distributed in the hope that it will be useful, but 
-#WITHOUT ANY WARRANTY; without even the implied warranties of 
-#MERCHANTABILITY, SATISFACTORY QUALITY, 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 program.  If not, see <http://www.gnu.org/licenses/>.
-### END LICENSE
-
-"""Tests for the AsyncTaskProgressBox"""
-
-from testtools import TestCase
-from quickly.widgets.asynch_task_progressbox import AsynchTaskProgressBox
-
-class TestAsynchTaskProgessBox(TestCase):
-    """Test the CouchGrid functionality"""
-
-    def setUp(self):
-        TestCase.setUp(self)
-
-    def tearDown(self):
-        TestCase.tearDown(self)
-
-    def test_constructions(self):
-        """Test a simple creating An AsynchTaskProgressBox """
-        box = AsynchTaskProgressBox(self.asynch_function)
-        self.assertEqual((box != None), True)
-
-    #A function to run asynchronously
-    def asynch_function( self, params ):
-        #pull values from the params that were set above
-        for x in range(params["start"],params["stop"]):
-        #check if to see if the user has told the task to stop
-            if params["kill"] == True:
-                #return a string if the user stopped the task
-                return "stopped at " + str(x)
-            else:
-                #if the user did not try to stop the task, go ahead and do something
-                print x
-                #this is a processor intensive task, so
-            #sleep the loop to keep the UI from bogging down
-            time.sleep(.5)
-        #if the loop completes, return a string
-        return "counted all"
-
 
=== removed file 'quickly/widgets/tests/test_couch_grid.py'
--- quickly/widgets/tests/test_couch_grid.py	2010-09-02 01:03:54 +0000
+++ quickly/widgets/tests/test_couch_grid.py	1970-01-01 00:00:00 +0000
@@ -1,284 +0,0 @@
-# Copyright 2009 Canonical Ltd.
-#
-# This file is part of desktopcouch.
-#
-#  desktopcouch is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License version 3
-# as published by the Free Software Foundation.
-#
-# desktopcouch 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 Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Authors: Rick Spencer <[e-mail]>
-
-"""Tests for the CouchGrid object"""
-
-from testtools import TestCase
-
-from desktopcouch.records.record import Record
-from desktopcouch.records.server import CouchDatabase
-from quickly.widgets.couch_grid import CouchGrid
-
-
-class TestCouchGrid(TestCase):
-    """Test the CouchGrid functionality"""
-
-    def setUp(self):
-        TestCase.setUp(self)
-        self.dbname = self._testMethodName
-        self.db = CouchDatabase(self.dbname, create=True)
-        self.record_type = "test_record_type"
-
-    def tearDown(self):
-        """tear down each test"""
-        TestCase.tearDown(self)
-        #delete the database
-        del self.db._server[self.dbname]
-
-    def test_constructor_guarded(self):
-        """Ensure that CouchGrid cannot be constructed without a
-        database name.
-        """
-        try:
-            cw = CouchGrid(None)
-        except TypeError, inst:
-            self.assertEqual(
-                inst.args[0],"database_name is required and must be a string")
-
-    def test_new_rows_with_headings(self):
-        """Test a simple creating a CouchGrid """
-
-        #create a test widget with test database values
-        cw = CouchGrid(self.dbname)
-
-        #allow editing
-        cw.editable = True
-
-        #create headers/keys
-        cw.keys = ["Key1", "Key2", "Key3", "Key4"]
-
-        #set the record_type for the TreeView
-        #it will not populate without this value being set
-        cw.record_type = self.record_type
-
-        #create a row with all four columns set
-        cw.append_row({"Key1":"val1", "Key2":"val2", "Key2":"val3", "Key4":"val4"})
-
-        #create a row with only the second column set
-        cw.append_row({"Key1":"", "Key2":"val2"})
-
-        #create an empty row (which will not be saved until the user edits it)
-        cw.append_row({})
-
-        #if this all worked, there should be three rows in the model
-        model = cw.get_model()
-        self.assertEqual(len(model), 3)
-
-    def test_headings_no_stored_records(self):
-        record_type = "a_new_record_type"
-        dicts = [{"key1":"val1"},{"key1":"val2"}]
-        cw = CouchGrid(self.dbname, record_type=record_type,dictionaries=dicts)
-        self.assertEqual(len(cw.get_model()),2)
-        self.assertEqual(cw.get_model().get_n_columns(),2)
-
-    def test_no_headings_or_stored_records(self):
-        """test when there is no defined headings and no stored records
-        to infer headings from. Should raise a proper exception.
-        """
-
-        try:
-            #create a test widget with test database values
-            cw = CouchGrid(self.dbname)
-
-            #set the record_type for the TreeView
-            #it will not populate without this value being set
-            cw.record_type = self.record_type
-
-            #create a row with all four columns set
-            cw.append_row(["val1", "val2", "val3", "val4"])
-
-            #create a row with only the second column set
-            cw.append_row(["", "val2"])
-
-            #create an empty row (which will not be saved until the
-            #user edits it)
-            cw.append_row([])
-
-            #if this all worked, there should be three rows in the model
-            model = cw.get_model()
-
-        #should be catching the following exception
-        except RuntimeError, inst:
-            self.assertEquals(
-                inst.args[0].find("Cannot infer columns for CouchGrid"),0)
-
-
-    def test_all_from_database(self):
-        #create some records
-        db = CouchDatabase(self.dbname, create=True)
-        db.put_record(Record({
-            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
-            "record_type": self.record_type}))
-        db.put_record(Record({
-            "key1_1": "val2_1", "key1_2": "val2_2", "key1_3": "val2_3",
-            "record_type": self.record_type}))
-
-        #build the CouchGrid
-        cw = CouchGrid(self.dbname)
-        cw.record_type = self.record_type
-        #make sure there are three columns and two rows
-        self.assertEqual(cw.get_model().get_n_columns(),4)
-        self.assertEqual(len(cw.get_model()),2)
-
-    def test_delete_selected_rows(self):
-        #create some records
-        db = CouchDatabase(self.dbname, create=True)
-        ids = []
-        for i in xrange(0,10):
-            ids.append( db.put_record(Record({
-            "key1_1": "val1_%s" % str(i), "iter_count": i,
-            "record_type": self.record_type})))
-
-        #build the CouchGrid
-        cw = CouchGrid(self.dbname, record_type = self.record_type)
-        cw.selected_record_ids = [ids[0],ids[5],ids[9]]
-        cw.remove_selected_rows(delete=True)
-        self.assertEqual(self.db.get_record(ids[0]) is None,True)     
-        self.assertEqual(self.db.get_record(ids[5]) is None,True)     
-        self.assertEqual(self.db.get_record(ids[9]) is None,True)     
-
-        self.assertEqual(self.db.get_record(ids[1]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[2]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[3]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[4]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[6]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[7]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[8]) is not None,True)     
-
-    def test_dont_delete_selected_rows(self):
-        #create some records
-        db = CouchDatabase(self.dbname, create=True)
-        ids = []
-        for i in xrange(0,10):
-            ids.append( db.put_record(Record({
-            "key1_1": "val1_%s" % str(i), "iter_count": i,
-            "record_type": self.record_type})))
-
-        #build the CouchGrid
-        cw = CouchGrid(self.dbname, record_type = self.record_type)
-        cw.selected_record_ids = [ids[0],ids[5],ids[9]]
-        cw.remove_selected_rows(delete=False)
-        cw.selected_record_ids = [ids[1],ids[4],ids[8]]
-        cw.remove_selected_rows()
-        self.assertEqual(self.db.get_record(ids[0]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[5]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[9]) is not None,True)     
-
-        self.assertEqual(self.db.get_record(ids[1]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[2]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[3]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[4]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[6]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[7]) is not None,True)     
-        self.assertEqual(self.db.get_record(ids[8]) is not None,True)     
-
-
-       
-    def test_selected_id_property(self):
-        #create some records
-        db = CouchDatabase(self.dbname, create=True)
-        id1 = db.put_record(Record({
-            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
-            "record_type": self.record_type}))
-        id2 = db.put_record(Record({
-            "key1_1": "val2_1", "key1_2": "val2_2", "key1_3": "val2_3",
-            "record_type": self.record_type}))
-
-        #build the CouchGrid
-        cw = CouchGrid(self.dbname)
-        cw.record_type = self.record_type
-
-        #make sure the record ids are selected properly
-        cw.selected_record_ids = [id1]
-        self.assertEqual(cw.selected_record_ids[0], id1)
-        cw.selected_record_ids = [id2]
-        self.assertEqual(cw.selected_record_ids[0], id2)
-
-    def test_single_col_from_database(self):
-        #create some records
-        self.db.put_record(Record({
-            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
-            "record_type": self.record_type}))
-        self.db.put_record(Record({
-            "key1_1": "val2_1", "key1_2": "val2_2", "key1_3": "val2_3",
-            "record_type": self.record_type}))
-        #build the CouchGrid
-        cw = CouchGrid(self.dbname)
-        cw.keys = ["key1_1"]
-        cw.record_type = self.record_type
-        #make sure there are three columns and two rows
-        self.assertEqual(cw.get_model().get_n_columns(),2)
-        self.assertEqual(len(cw.get_model()),2)
-
-    def test_optional_record_type_arg(self):
-        """Test a simple creating a CouchGrid """
-        #create some records
-        self.db.put_record(Record({
-            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
-            "record_type": self.record_type}))
-        self.db.put_record(Record({
-            "key1_1": "val1_1", "key1_2": "val2_2", "key1_3": "val2_3",
-            "record_type": self.record_type}))
-
-        #create a test widget with test database values
-        cw = CouchGrid(self.dbname, record_type=self.record_type)
-
-        #make sure there are three columns and two rows
-        self.assertEqual(cw.get_model().get_n_columns(),4)
-        self.assertEqual(len(cw.get_model()),2)
-
-    def test_optional_args_no_stored_records(self):
-        """Test a simple creating a CouchGrid """
-
-        #create a test widget with test database values
-        cw = CouchGrid(
-            self.dbname, record_type=self.record_type,
-            keys=["Key1", "Key2", "Key3", "Key4"])
-
-        #create a row with all four columns set
-        cw.append_row({"Key1":"val1", "Key2":"val2", "Key2":"val3", "Key4":"val4"})
-
-        #create a row with only the second column set
-        cw.append_row({"Key1":"", "Key2":"val2"})
-
-        #create an empty row (which will not be saved until the user edits it)
-        cw.append_row({})
-
-        #if this all worked, there should be three rows in the model
-        model = cw.get_model()
-        self.assertEqual(len(model), 3)
-
-    def test_programatically_add_row(self):
-        """test appending different sized rows programatically"""
-        #create some records
-        self.db.put_record(Record({
-            "key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3",
-            "record_type": self.record_type}))
-        self.db.put_record(Record({
-            "key1_1": "val2_1", "key1_2": "val2_2", "key1_3": "val2_3",
-            "record_type": self.record_type}))
-
-        #create a test widget with test database values
-        cw = CouchGrid(self.dbname, record_type=self.record_type)
-
-        #allow editing
-        cw.append_row({"key1_1":"boo", "key1_2":"ray"})
-
-        #make sure there are three columns and two rows
-        self.assertEqual(cw.get_model().get_n_columns(),4)
-        self.assertEqual(len(cw.get_model()),3)
 
=== modified file 'quickly/widgets/tests/test_dictionary_grid.py'
--- quickly/widgets/tests/test_dictionary_grid.py	2011-09-05 06:23:54 +0000
+++ quickly/widgets/tests/test_dictionary_grid.py	2012-03-06 08:52:21 +0000
@@ -18,7 +18,7 @@
 
 from testtools import TestCase
 from quickly.widgets.dictionary_grid import DictionaryGrid
-import gobject
+from gi.repository import GObject
 from quickly.widgets.grid_column import StringColumn, IntegerColumn, CurrencyColumn,CheckColumn, DateColumn
 
 class TestDictionaryGrid(TestCase):
@@ -42,7 +42,6 @@
         grid.append_row({"key1":"val11","key2":"val12"})
         self.assertEqual(len(grid.get_model()),1)
 
-
     def test_constructor_with_dicts(self):
         """test creating a grid with dictionaries in the contructor"""
         dicts = [{"key1_1": "val1_1", "key1_2": "val1_2", "key1_3": "val1_3"},
@@ -184,13 +183,13 @@
             key = c.key
             col_type = c.column_type
             if key == "id":
-                self.assertEqual(col_type,gobject.TYPE_STRING)
+                self.assertEqual(col_type,GObject.TYPE_STRING)
             elif key == "price":
-                self.assertEqual(col_type,gobject.TYPE_STRING)
+                self.assertEqual(col_type,GObject.TYPE_STRING)
             elif key == "bool?":
-                self.assertEqual(col_type,gobject.TYPE_STRING)
+                self.assertEqual(col_type,GObject.TYPE_STRING)
             elif key == "foo":
-                self.assertEqual(col_type,gobject.TYPE_INT)
+                self.assertEqual(col_type,GObject.TYPE_INT)
             else:
                 self.assertEqual("Extra key Found",False) 
 
@@ -253,9 +252,9 @@
         dicts = [{"price":"100.00","id":"50","bool?":"Yes"}]
         grid = DictionaryGrid(dicts, keys)
         grid.editable = False
-        ed1 = grid.columns["price"].get_cell_renderers()[0].get_property("editable")
+        ed1 = grid.columns["price"].get_cells()[0].get_property("editable")
         self.assertTrue(not ed1)
-        ed2 = grid.columns["bool?"].get_cell_renderers()[0].get_property("activatable")
+        ed2 = grid.columns["bool?"].get_cells()[0].get_property("activatable")
         self.assertTrue(not ed2)
 
     def test_set_a_column_title(self):
 
=== modified file 'quickly/widgets/text_editor.py'
--- quickly/widgets/text_editor.py	2011-02-03 16:28:49 +0000
+++ quickly/widgets/text_editor.py	2012-03-06 08:52:21 +0000
@@ -35,25 +35,26 @@
 
 Configuring
 #Configure as a TextView
-self.editor.set_wrap_mode(gtk.WRAP_CHAR)
+self.editor.set_wrap_mode(Gtk.WRAP_CHAR)
 
-#Access the gtk.TextBuffer if needed
+#Access the Gtk.TextBuffer if needed
 buffer = self.editor.get_buffer()
 
 Extending
-A TextEditor is gtk.TextView
+A TextEditor is Gtk.TextView
 
 """
 
+
 try:
-    import pygtk
-    pygtk.require("2.0")
-    import gtk
+    from gi.repository import Gtk
+    from gi.repository import Gdk
     import re
 except:
     print "couldn't load depencies"
 
-class TextEditor( gtk.TextView ):
+
+class TextEditor( Gtk.TextView ):
     """TextEditor encapsulates management of TextBuffer and TextIter for
     common functionality, such as cut, copy, paste, undo, redo, and 
     highlighting of text.
@@ -65,10 +66,10 @@
 
         """
 
-        gtk.TextView.__init__( self)
+        Gtk.TextView.__init__(self)
         self.undo_max = None
         self._highlight_strings = []
-        found_tag = gtk.TextTag("highlight")
+        found_tag = Gtk.TextTag(name="highlight")
         found_tag.set_property("background","yellow")
         self.get_buffer().get_tag_table().add(found_tag)
 
@@ -77,7 +78,8 @@
         self.change_event = self.get_buffer().connect("changed",self._on_text_changed)
         self._auto_bullet = None
         self.auto_bullets = False
-        self.clipboard = gtk.Clipboard()
+        display = self.get_display()
+        self.clipboard = Gtk.Clipboard.get_for_display(display, Gdk.SELECTION_CLIPBOARD)
 
         self.undos = []
         self.redos = []
@@ -92,7 +94,7 @@
         """
         start_iter = self.get_buffer().get_iter_at_offset(0)
         end_iter =  self.get_buffer().get_iter_at_offset(-1)
-        return self.get_buffer().get_text(start_iter,end_iter)
+        return self.get_buffer().get_text(start_iter,end_iter, False)
 
     @text.setter
     def text(self, text):
@@ -179,6 +181,7 @@
 
 
         self._highlight_strings = []
+
         self._highlight()
 
     def _highlight(self):
@@ -189,7 +192,7 @@
 
         start_iter = self.get_buffer().get_iter_at_offset(0)
         end_iter =  self.get_buffer().get_iter_at_offset(-1)
-        text = self.get_buffer().get_text(start_iter,end_iter)
+        text = self.get_buffer().get_text(start_iter,end_iter, False)
         self.get_buffer().remove_all_tags(start_iter, end_iter)
         for s in self._highlight_strings:
             hits = [match.start() for match in re.finditer(re.escape(s), text)]
@@ -213,7 +216,7 @@
         handler.
 
         """
-
+ 
         self.get_buffer().copy_clipboard(self.clipboard)            
 
     def paste(self, widget=None, data=None):
@@ -306,7 +309,7 @@
             cur_line = iter.get_line()
             prev_line_iter = self.get_buffer().get_iter_at_line(cur_line)
             pl_offset = prev_line_iter.get_offset()
-            pl_text = self.get_buffer().get_text(prev_line_iter, iter)
+            pl_text = self.get_buffer().get_text(prev_line_iter, iter, False)
             if pl_text.strip().find("*") == 0:
                 ws = ""
                 if not pl_text.startswith("*"):
@@ -320,7 +323,7 @@
         """
 
         self._highlight()
-        text = self.get_buffer().get_text(start_iter,end_iter)        
+        text = self.get_buffer().get_text(start_iter,end_iter, False)        
         cmd = {"action":"insert","offset":start_iter.get_offset(),"text":text}
         self._add_undo(cmd)
 
@@ -335,25 +338,25 @@
             del(self.undos[0])
         self.undos.append(cmd)
 
-class TestWindow(gtk.Window):
+class TestWindow(Gtk.Window):
     """For testing and demonstrating AsycnTaskProgressBox.
 
     """
     def __init__(self):
         #create a window a VBox to hold the controls
-        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
+        Gtk.Window.__init__(self)
         self.set_title("TextEditor Test Window")
-        windowbox = gtk.VBox(False, 2)
+        windowbox = Gtk.VBox(False, 2)
         windowbox.show()
         self.add(windowbox)
         self.editor = TextEditor()
         self.editor.show()
-        windowbox.pack_end(self.editor)
+        windowbox.pack_end(self.editor, True, True, 0)
         self.set_size_request(200,200)
         self.show()
         self.maximize()
   
-        self.connect("destroy", gtk.main_quit)
+        self.connect("destroy", Gtk.main_quit)
         self.editor.text = "this is some inserted text"
         self.editor.append("\nLine 3")
         self.editor.prepend("Line1\n")
@@ -364,35 +367,35 @@
         self.editor.add_highlight("some")
         self.editor.undo_max = 100
         self.editor.auto_bullets = True
-        cut_button = gtk.Button("Cut")
+        cut_button = Gtk.Button("Cut")
         cut_button.connect("clicked",self.editor.cut)
         cut_button.show()
-        windowbox.pack_start(cut_button, False)
+        windowbox.pack_start(cut_button, False, False, 0)
 
-        copy_button = gtk.Button("Copy")
+        copy_button = Gtk.Button("Copy")
         copy_button.connect("clicked",self.editor.copy)
         copy_button.show()
-        windowbox.pack_start(copy_button, False)
+        windowbox.pack_start(copy_button, False, False, 0)
 
-        paste_button = gtk.Button("Paste")
+        paste_button = Gtk.Button("Paste")
         paste_button.connect("clicked",self.editor.paste)
         paste_button.show()
-        windowbox.pack_start(paste_button, False)
+        windowbox.pack_start(paste_button, False, False, 0)
 
-        undo_button = gtk.Button("Undo")
+        undo_button = Gtk.Button("Undo")
         undo_button.connect("clicked",self.editor.undo)
         undo_button.show()
-        windowbox.pack_start(undo_button, False)
+        windowbox.pack_start(undo_button, False, False, 0)
 
-        redo_button = gtk.Button("Redo")
+        redo_button = Gtk.Button("Redo")
         redo_button.connect("clicked",self.editor.redo)
         redo_button.show()
-        windowbox.pack_start(redo_button, False)
+        windowbox.pack_start(redo_button, False, False, 0)
 
         print self.editor.text
 
 
 if __name__== "__main__":
     test = TestWindow()
-    gtk.main()
+    Gtk.main()
 
 
=== modified file 'quickly/widgets/url_fetch_progressbox.py'
--- quickly/widgets/url_fetch_progressbox.py	2011-09-05 06:19:23 +0000
+++ quickly/widgets/url_fetch_progressbox.py	2012-03-06 08:52:21 +0000
@@ -1,5 +1,6 @@
 ### BEGIN LICENSE
 # Copyright (C) 2010 Stuart Langridge [e-mail]
+# Copyright (C) 2012 Rick Spencer [e-mail]
 #This program is free software: you can redistribute it and/or modify it 
 #under the terms of the GNU General Public License version 3, as published 
 #by the Free Software Foundation.
@@ -14,18 +15,18 @@
 ### END LICENSE
 
 try:
-    import pygtk
-    pygtk.require("2.0")
-    import gtk, gobject, gio
+    from gi.repository import GObject
+    from gi.repository import Gtk
+    from gi.repository import Gio
+    from gi.repository import GLib
     import gettext
     from gettext import gettext as _
     gettext.textdomain('quickly-widgets')
-    import glib
 except:
     print "couldn't load dependencies"
 
 
-class UrlFetchProgressBox(gtk.HBox):
+class UrlFetchProgressBox(Gtk.HBox):
     """UrlFetchProgressBox: encapsulates a pulsating progressbar, a cancel
     button, and a URL that needs fetching. Use a UrlFetchProgressBox when you 
     need to fetch a URL; the box will show while the URL is being fetched 
@@ -37,10 +38,10 @@
     Cancelling fires the "downloaded" signal with a value of None.
     """
 
-    __gsignals__ = {'downloaded' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, 
-            (gobject.TYPE_PYOBJECT,)),
-        'download-error' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, 
-            (gobject.TYPE_PYOBJECT,))}
+    __gsignals__ = {'downloaded' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, 
+            (GObject.TYPE_PYOBJECT,)),
+        'download-error' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, 
+            (GObject.TYPE_PYOBJECT,))}
 
     def __init__(self, url, destroy_after_fetching=True, cancelable=True):
         """Create an UrlFetchProgressBox
@@ -51,39 +52,37 @@
           is fetched? Defaults to True.
         cancelable -- whether to show cancel button. Defaults to True.
         """
-        gtk.HBox.__init__( self, False, 2)
-        self.progressbar = gtk.ProgressBar()
-        gobject.timeout_add(10, self.__tick)
+        Gtk.HBox.__init__( self, False, 2)
+        self.progressbar = Gtk.ProgressBar()
+        GObject.timeout_add(10, self.__tick)
         self.running = True
         parts = [x for x in url.split("/") if x]
         self.progressbar.set_text(_("Downloading %s") % parts[-1])
         self.progressbar.show()
-        self.pack_start(self.progressbar, True)
+        self.pack_start(self.progressbar, True, True, 0)
         self.destroy_after_fetching = destroy_after_fetching
-        self.cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
+        self.cancel_button = Gtk.Button(stock=Gtk.STOCK_CANCEL)
         if cancelable:
             self.cancel_button.show()
         self.cancel_button.set_sensitive(False)
         self.cancel_button.connect("clicked",self.__cancel)
-        self.pack_end(self.cancel_button, False)
+        self.pack_end(self.cancel_button, False, False, 0)
         self.cancel_button.set_sensitive(True)
-        self.__canceller = gio.Cancellable()
-        self.stream = gio.File(url)
-        self.stream.load_contents_async(self.__download_finished, cancellable=self.__canceller)
+        self.__canceller = Gio.Cancellable()
+        self.stream = Gio.file_new_for_uri(url)
+        self.stream.load_contents_async(self.__canceller, self.__download_finished, None)
     
+
     def __tick(self):
         self.progressbar.pulse()
         return self.running
     
-    def __download_finished(self, gdaemonfile, result):
+    def __download_finished(self, gdaemonfile, result, data=None):
         try:
-            content = self.stream.load_contents_finish(result)[0]
-        except gio.Error, e:
-            if e.code == 19:
-                self.emit("downloaded", None)
-            else:
-                self.emit("download-error",e)
-        except glib.GError, e:
+            #GIO documentation says that the file is [0] in the tuple
+            #but it is realy [1]
+            content = self.stream.load_contents_finish(result)[1]
+        except Exception, e:
             self.emit("download-error",e)
         else:
             self.emit("downloaded", content)
@@ -97,29 +96,34 @@
         self.running = False
         if self.destroy_after_fetching: self.destroy()
 
-class TestWindow(gtk.Window):
+class TestWindow(Gtk.Window):
     def __init__(self):
-        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
+        Gtk.Window.__init__(self)
         self.set_title("UrlFetchProgressBox test")
-        self.vbox = gtk.VBox()
-        btn = gtk.Button(stock=gtk.STOCK_EXECUTE)
+        self.vbox = Gtk.VBox()
+        btn = Gtk.Button(stock=Gtk.STOCK_EXECUTE)
         btn.connect("clicked", self.start_download)
-        self.vbox.pack_end(btn)
+        self.vbox.pack_end(btn, True, True, 0)
         self.add(self.vbox)
         self.set_size_request(300,200)
-        self.connect("destroy", gtk.main_quit)
+        self.connect("destroy", Gtk.main_quit)
     
     def start_download(self, btn):
         prog = UrlFetchProgressBox("http://www.ubuntu.com/desktop/get-ubuntu/download")
+        
         prog.connect("downloaded", self.downloaded)
-        self.vbox.pack_start(prog, expand=False)
+        prog.connect("download-error", self.errored)
+        self.vbox.pack_start(prog, False, False, 0)
         prog.show()
-    
+
+    def errored(self, widget, e):
+        print "encountered error: %s " % e.message
+
     def downloaded(self, widget, content):
         print "downloaded %s bytes of content" % len(content)
 
 if __name__ == "__main__":
     w = TestWindow()
     w.show_all()
-    gtk.main()
+    Gtk.main()
 
 
=== modified file 'quickly/widgets/web_cam_box.py'
--- quickly/widgets/web_cam_box.py	2011-01-04 03:19:55 +0000
+++ quickly/widgets/web_cam_box.py	2012-03-06 08:52:21 +0000
@@ -53,13 +53,13 @@
 cam.pack_start(my_widget, False, False)
 
 Extending
-A WebCamBox is gtk.VBox
-A WebCamBox is a gtk.VBox that contains a gtk.DrawingArea for displaying
+A WebCamBox is Gtk.VBox
+A WebCamBox is a Gtk.VBox that contains a Gtk.DrawingArea for displaying
 webcam output, and a thin wrapper around a camerabin, which is a gstreamer
 pipleine sublcass that provides all the camera functionality.
 
 To add GUI elements simple, create them and pack them into WebCamBox, since
-it's just a gtk.VBox
+it's just a Gtk.VBox
 
 Similarly, to add to or change the web cam functionality, modify properties on
 the camerabin. You may also want to overide _on_message and/or _on_sync_message
@@ -67,18 +67,20 @@
 
 """
 
+from gi.repository import Gtk
+from gi.repository import GdkX11
+from gi.repository import GObject
+
 import sys
 import os
-import gtk
 import gst
 import datetime
-import gobject
 
 import gettext
 from gettext import gettext as _
 gettext.textdomain('quickly-widgets')
 
-class WebCamBox(gtk.VBox):
+class WebCamBox(Gtk.VBox):
     """WebCamBox - A VBox that tries to turn on and display the default webcam for the
         computer on which it is running. It is also capable of saving an image
         from the webcam to the user's Picture directory.
@@ -92,10 +94,10 @@
         This function has no arguments
 
         """
-        gtk.VBox.__init__(self, False, 5)
-        self.video_window = gtk.DrawingArea()
+        Gtk.VBox.__init__(self, False, 5)
+        self.video_window = Gtk.DrawingArea()
         self.video_window.connect("realize",self.__on_video_window_realized)
-        self.pack_start(self.video_window, True, True)
+        self.pack_start(self.video_window, True, True, 0)
         self.video_window.show()
         self.connect("destroy", self.on_destroy)
 
@@ -105,7 +107,7 @@
         bus.enable_sync_message_emission()
         bus.connect("message", self._on_message)
         bus.connect("sync-message::element", self._on_sync_message)
-        self.camerabin.set_property("image-encoder",gst.element_factory_make("pngenc", "png_encoder"))
+        #self.camerabin.set_property("image-encoder",gst.element_factory_make("pngenc", "png_encoder"))
         self.filename_prefix = ""
         self.realized = False
 
@@ -155,7 +157,7 @@
         """
 
         stamp = str(datetime.datetime.now())
-        extension = ".png"
+        extension = ".jpg"
         directory = os.environ["HOME"] + _("/Pictures/")
         self.filename = directory + self.filename_prefix + stamp + extension
         self.camerabin.set_property("filename", self.filename)
@@ -217,7 +219,7 @@
         if message_name == "prepare-xwindow-id":
             imagesink = message.src
             imagesink.set_property("force-aspect-ratio", True)
-            imagesink.set_xwindow_id(self.video_window.window.xid)
+            imagesink.set_xwindow_id(self.video_window.get_window().get_xid())
 
     def __on_video_window_realized(self, widget, data=None):
         """__on_video_window_realized - internal signal handler, used
@@ -229,16 +231,16 @@
         self._set_video_window_id()
 
     def _set_video_window_id(self):
-        if not self.realized and self.video_window.window is not None:
-            x = self.video_window.window.xid
+        if not self.realized and self.video_window.get_window() is not None:
+            x = self.video_window.get_window().get_xid()
             self.realized = True
 
     def on_destroy(self, widget, data=None):
         #clean up the camera before exiting
         self.camerabin.set_state(gst.STATE_NULL)
         
-    __gsignals__ = {'image-captured' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-		(gobject.TYPE_PYOBJECT,)),
+    __gsignals__ = {'image-captured' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+		(GObject.TYPE_PYOBJECT,)),
 		} 
 
 def __image_captured(widget, data=None):
@@ -247,20 +249,21 @@
 
     """
 
-    quickly.prompts.info("WebCam Test",data)    
+    #quickly.prompts.info("WebCam Test",data) 
+    print data   
 
 if __name__ == "__main__":
     """creates a test WebCamBox"""
-    import quickly.prompts
+    #import quickly.prompts
 
     #create and show a test window
-    win = gtk.Window(gtk.WINDOW_TOPLEVEL)
+    win = Gtk.Window()
     win.set_title("WebCam Test Window")
-    win.connect("destroy",gtk.main_quit)
+    win.connect("destroy",Gtk.main_quit)
     win.show()
 
     #create a top level container
-    vbox = gtk.VBox(False, 10)
+    vbox = Gtk.VBox(False, 10)
     vbox.show()
     win.add(vbox)
 
@@ -271,27 +274,27 @@
     mb.play()
 
     mb.connect("image-captured", __image_captured)
-    play_butt = gtk.Button("Play")
-    pause_butt = gtk.Button("Pause")
-    stop_butt = gtk.Button("Stop")
-    pic_butt = gtk.Button("Picture")
+    play_butt = Gtk.Button("Play")
+    pause_butt = Gtk.Button("Pause")
+    stop_butt = Gtk.Button("Stop")
+    pic_butt = Gtk.Button("Picture")
 
     play_butt.connect("clicked", lambda x:mb.play())
     play_butt.show()
-    mb.pack_end(play_butt, False)
+    mb.pack_end(play_butt, False, False, 0)
 
     pause_butt.connect("clicked", lambda x:mb.pause())
     pause_butt.show()
-    mb.pack_end(pause_butt, False)
+    mb.pack_end(pause_butt, False, False, 0)
 
     stop_butt.connect("clicked", lambda x:mb.stop())
     stop_butt.show()
-    mb.pack_end(stop_butt, False)
+    mb.pack_end(stop_butt, False, False, 0)
 
     pic_butt.connect("clicked", lambda x:mb.take_picture())
     pic_butt.show()
-    mb.pack_end(pic_butt, False)
+    mb.pack_end(pic_butt, False, False, 0)
 
-    gtk.main()
+    Gtk.main()