In .:

* src/Selectors/_SelectPerson.py: Use new package.
	* src/plugins/RelCalc.py: Use new package.
	* src/DataViews/_PersonView.py: Use new package.
	* src/DisplayModels: Make new package.
	* src/Makefile.am: Remove old files.
In po:
	* POTFILES.in: Add new files; remove old files.


svn: r6683

src/DisplayModels/Makefile.am

@@ -0,0 +1,26 @@
+# This is the src/DisplayModels level Makefile for Gramps
+
+pkgdatadir = $(datadir)/@PACKAGE@/DisplayModels
+
+pkgdata_PYTHON = \
+	__init__.py \
+	_BaseModel.py \
+	_EventModel.py \
+	_FamilyModel.py \
+	_MediaModel.py \
+	_PeopleModel.py \
+	_PlaceModel.py \
+	_RepositoryModel.py \
+	_SourceModel.py
+
+pkgpyexecdir = @pkgpyexecdir@/DisplayModels
+pkgpythondir = @pkgpythondir@/DisplayModels
+
+# Clean up all the byte-compiled files
+MOSTLYCLEANFILES = *pyc *pyo
+
+GRAMPS_PY_MODPATH = "../"
+
+pycheck: 
+	(export PYTHONPATH=$(GRAMPS_PY_MODPATH); \
+	pychecker $(pkgdata_PYTHON));

src/DisplayModels/_BaseModel.py

@@ -0,0 +1,201 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+#-------------------------------------------------------------------------
+#
+# python modules
+#
+#-------------------------------------------------------------------------
+import locale
+
+#-------------------------------------------------------------------------
+#
+# GNOME/GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+from Filters import SearchFilter
+
+#-------------------------------------------------------------------------
+#
+# BaseModel
+#
+#-------------------------------------------------------------------------
+class BaseModel(gtk.GenericTreeModel):
+
+    def __init__(self, db, scol=0, order=gtk.SORT_ASCENDING,
+                 tooltip_column=None, search=None):
+        gtk.GenericTreeModel.__init__(self)
+        self.prev_handle = None
+        self.prev_data = None
+        self.set_property("leak_references",False)
+        self.db = db
+        self.sort_func = self.smap[scol]
+        self.sort_col = scol
+
+        if search:
+            col = search[0]
+            text = search[1]
+            inv = search[2]
+            func = lambda x: self.on_get_value(x, col) or u""
+            self.search = SearchFilter(func, text, inv)
+        else:
+            self.search = None
+            
+        self.reverse = (order == gtk.SORT_DESCENDING)
+        self.tooltip_column = tooltip_column
+        self.rebuild_data()
+
+    def set_sort_column(self,col):
+        self.sort_func = self.smap[col]
+
+    def sort_keys(self):
+        cursor = self.gen_cursor()
+        sarray = []
+        data = cursor.next()
+
+        while data:
+            key = locale.strxfrm(self.sort_func(data[1]))
+            sarray.append((key,data[0]))
+            data = cursor.next()
+        cursor.close()
+
+        sarray.sort()
+
+        if self.reverse:
+            sarray.reverse()
+
+        return [ x[1] for x in sarray ]
+
+    def rebuild_data(self):
+        if self.db.is_open():
+            if self.search:
+                self.datalist = [h for h in self.sort_keys()\
+                                 if self.search.match(h)]
+            else:
+                self.datalist = self.sort_keys()
+            i = 0
+            self.indexlist = {}
+            for key in self.datalist:
+                self.indexlist[key] = i
+                i += 1
+        else:
+            self.datalist = []
+            self.indexlist = {}
+        
+    def add_row_by_handle(self,handle):
+        self.datalist = self.sort_keys()
+        i = 0
+        self.indexlist = {}
+        for key in self.datalist:
+            self.indexlist[key] = i
+            i += 1
+        index = self.indexlist[handle]
+        node = self.get_iter(index)
+        self.row_inserted(index,node)
+
+    def delete_row_by_handle(self,handle):
+        index = self.indexlist[handle]
+        self.indexlist = {}
+        self.datalist = []
+        i = 0
+        for key in self.sort_keys():
+            if key != handle:
+                self.indexlist[key] = i
+                self.datalist.append(key)
+                i += 1
+        self.row_deleted(index)
+
+    def update_row_by_handle(self,handle):
+        index = self.indexlist[handle]
+        node = self.get_iter(index)
+        self.row_changed(index,node)
+
+    def on_get_flags(self):
+	'''returns the GtkTreeModelFlags for this particular type of model'''
+	return gtk.TREE_MODEL_LIST_ONLY | gtk.TREE_MODEL_ITERS_PERSIST
+
+    def on_get_n_columns(self):
+        return 1
+
+    def on_get_path(self, node):
+	'''returns the tree path (a tuple of indices at the various
+	levels) for a particular node.'''
+        return self.indexlist[node]
+
+    def on_get_column_type(self,index):
+        if index == self.tooltip_column:
+            return object
+        return str
+
+    def on_get_iter(self, path):
+        try:
+            return self.datalist[path[0]]
+        except IndexError:
+            return None
+
+    def on_get_value(self,node,col):
+        try:
+            if node != self.prev_handle:
+                self.prev_data = self.map(str(node))
+                self.prev_handle = node
+            return self.fmap[col](self.prev_data)
+        except:
+            return u''
+
+    def on_iter_next(self, node):
+	'''returns the next node at this level of the tree'''
+        try:
+            return self.datalist[self.indexlist[node]+1]
+        except IndexError:
+            return None
+
+    def on_iter_children(self,node):
+        """Return the first child of the node"""
+        if node == None and self.datalist:
+            return self.datalist[0]
+        return None
+
+    def on_iter_has_child(self, node):
+	'''returns true if this node has children'''
+        if node == None:
+            return len(self.datalist) > 0
+        return False
+
+    def on_iter_n_children(self,node):
+        if node == None:
+            return len(self.datalist)
+        return 0
+
+    def on_iter_nth_child(self,node,n):
+        if node == None:
+            return self.datalist[n]
+        return None
+
+    def on_iter_parent(self, node):
+	'''returns the parent of this node'''
+        return None

src/DisplayModels/_EventModel.py

@@ -0,0 +1,129 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+#-------------------------------------------------------------------------
+#
+# python modules
+#
+#-------------------------------------------------------------------------
+import time
+import logging
+log = logging.getLogger(".")
+
+#-------------------------------------------------------------------------
+#
+# GNOME/GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+import const
+import ToolTips
+import GrampsLocale
+import DateHandler
+import RelLib
+from _BaseModel import BaseModel
+
+#-------------------------------------------------------------------------
+#
+# EventModel
+#
+#-------------------------------------------------------------------------
+class EventModel(BaseModel):
+
+    def __init__(self, db, scol=0, order=gtk.SORT_ASCENDING, search=None):
+        self.gen_cursor = db.get_event_cursor
+        self.map = db.get_raw_event_data
+        
+        self.fmap = [
+            self.column_description,
+            self.column_id,
+            self.column_type,
+            self.column_date,
+            self.column_place,
+            self.column_cause,
+            self.column_change,
+            self.column_handle,
+            self.column_tooltip,
+            ]
+        self.smap = [
+            self.column_description,
+            self.column_id,
+            self.column_type,
+            self.column_date,
+            self.column_place,
+            self.column_cause,
+            self.sort_change,
+            self.column_handle,
+            self.column_tooltip,
+            ]
+        BaseModel.__init__(self, db, scol, order, tooltip_column=8,
+                           search=search)
+
+    def on_get_n_columns(self):
+        return len(self.fmap)+1
+
+    def column_description(self,data):
+        return data[4]
+
+    def column_cause(self,data):
+        return data[6]
+
+    def column_place(self,data):
+        if data[5]:
+            return self.db.get_place_from_handle(data[5]).get_title()
+        else:
+            return u''
+
+    def column_type(self,data):
+        return str(RelLib.EventType(data[2]))
+
+    def column_id(self,data):
+        return unicode(data[1])
+
+    def column_date(self,data):
+        if data[3]:
+            event = RelLib.Event()
+            event.unserialize(data)
+            return DateHandler.get_date(event)
+        return u''
+
+    def column_handle(self,data):
+        return unicode(data[0])
+
+    def sort_change(self,data):
+        return "%012x" % data[10]
+
+    def column_change(self,data):
+        return unicode(time.strftime('%x %X',time.localtime(data[10])),
+                       GrampsLocale.codeset)
+
+    def column_tooltip(self,data):
+        try:
+            t = ToolTips.TipFromFunction(self.db, lambda: self.db.get_event_from_handle(data[0]))
+        except:
+            log.error("Failed to create tooltip.", exc_info=True)
+        return t

src/DisplayModels/_FamilyModel.py

@@ -0,0 +1,138 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+#-------------------------------------------------------------------------
+#
+# python modules
+#
+#-------------------------------------------------------------------------
+import time
+import logging
+log = logging.getLogger(".")
+
+#-------------------------------------------------------------------------
+#
+# GNOME/GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+import const
+import ToolTips
+import GrampsLocale
+import NameDisplay
+import RelLib
+
+from _BaseModel import BaseModel
+
+#-------------------------------------------------------------------------
+#
+# FamilyModel
+#
+#-------------------------------------------------------------------------
+class FamilyModel(BaseModel):
+
+    def __init__(self, db, scol=0, order=gtk.SORT_ASCENDING, search=None):
+        self.gen_cursor = db.get_family_cursor
+        self.map = db.get_raw_family_data
+        self.fmap = [
+            self.column_id,
+            self.column_father,
+            self.column_mother,
+            self.column_type,
+            self.column_change,
+            self.column_handle,
+            self.column_tooltip
+            ]
+        self.smap = [
+            self.column_id,
+            self.sort_father,
+            self.sort_mother,
+            self.column_type,
+            self.sort_change,
+            self.column_handle,
+            self.column_tooltip
+            ]
+        BaseModel.__init__(self, db, scol, order, tooltip_column=6,
+                           search=search)
+
+    def on_get_n_columns(self):
+        return len(self.fmap)+1
+
+    def column_handle(self,data):
+        return unicode(data[0])
+
+    def column_father(self,data):
+        if data[2]:
+            person = self.db.get_person_from_handle(data[2])
+            return unicode(NameDisplay.displayer.sorted_name(person.primary_name))
+        else:
+            return u""
+
+    def sort_father(self,data):
+        if data[2]:
+            person = self.db.get_person_from_handle(data[2])
+            return NameDisplay.displayer.sort_string(person.primary_name)
+        else:
+            return u""
+
+    def column_mother(self,data):
+        if data[3]:
+            person = self.db.get_person_from_handle(data[3])
+            return unicode(NameDisplay.displayer.sorted_name(person.primary_name))
+        else:
+            return u""
+
+    def sort_mother(self,data):
+        if data[3]:
+            person = self.db.get_person_from_handle(data[3])
+            return NameDisplay.displayer.sort_string(person.primary_name)
+        else:
+            return u""
+
+    def column_type(self,data):
+        return str(RelLib.FamilyRelType(data[5]))
+
+    def column_id(self,data):
+        return unicode(data[1])
+
+    def sort_change(self,data):
+        return "%012x" % data[13]
+    
+    def column_change(self,data):
+        return unicode(time.strftime('%x %X',time.localtime(data[13])),
+                       GrampsLocale.codeset)
+
+    def column_tooltip(self,data):
+        if const.use_tips:
+            try:
+                t = ToolTips.TipFromFunction(self.db, lambda:
+                                             self.db.get_family_from_handle(data[0]))
+            except:
+                log.error("Failed to create tooltip.", exc_info=True)
+            return t
+        else:
+            return u''

src/DisplayModels/_MediaModel.py

@@ -0,0 +1,134 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+#-------------------------------------------------------------------------
+#
+# python modules
+#
+#-------------------------------------------------------------------------
+import time
+from gettext import gettext as _
+import logging
+log = logging.getLogger(".")
+
+#-------------------------------------------------------------------------
+#
+# GNOME/GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+import const
+import ToolTips
+import GrampsLocale
+import DateHandler
+import RelLib
+from _BaseModel import BaseModel
+
+#-------------------------------------------------------------------------
+#
+# MediaModel
+#
+#-------------------------------------------------------------------------
+class MediaModel(BaseModel):
+
+    def __init__(self, db, scol=0, order=gtk.SORT_ASCENDING, search=None):
+        self.gen_cursor = db.get_media_cursor
+        self.map = db.get_raw_object_data
+        
+        self.fmap = [
+            self.column_description,
+            self.column_id,
+            self.column_mime,
+            self.column_path,
+            self.column_change,
+            self.column_date,
+            self.column_handle,
+            self.column_tooltip
+            ]
+        self.smap = [
+            self.column_description,
+            self.column_id,
+            self.column_mime,
+            self.column_path,
+            self.sort_change,
+            self.column_date,
+            self.column_handle,
+            ]
+        BaseModel.__init__(self, db, scol, order, tooltip_column=7,
+                           search=search)
+
+    def on_get_n_columns(self):
+        return len(self.fmap)+1
+
+    def column_description(self,data):
+        try:
+            return unicode(data[4])
+        except:
+            return unicode(data[4],'latin1')
+
+    def column_path(self,data):
+        try:
+            return unicode(data[2])
+        except:
+            return unicode(data[2].encode('iso-8859-1'))
+
+    def column_mime(self,data):
+        if data[3]:
+            return unicode(data[3])
+        else:
+            return _('Note')
+
+    def column_id(self,data):
+        return unicode(data[1])
+
+    def column_date(self,data):
+        if data[9]:
+            date = RelLib.Date()
+            date.unserialize(data[9])
+            return unicode(DateHandler.displayer.display(date))
+        return u''
+
+    def column_handle(self,data):
+        return unicode(data[0])
+
+    def sort_change(self,data):
+        return "%012x" % data[8]
+
+    def column_change(self,data):
+        return unicode(time.strftime('%x %X',time.localtime(data[8])),
+                       GrampsLocale.codeset)
+
+    def column_tooltip(self,data):
+        if const.use_tips:
+            try:
+                t = ToolTips.TipFromFunction(self.db, lambda:
+                                             self.db.get_object_from_handle(data[0]))
+            except:
+                log.error("Failed to create tooltip.", exc_info=True)
+            return t
+        else:
+            return u''

src/DisplayModels/_PeopleModel.py

@@ -0,0 +1,600 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+
+# $Id$
+
+"""
+TreeModel for the GRAMPS Person tree.
+"""
+
+__author__ = "Donald N. Allingham"
+__revision__ = "$Revision$"
+
+#-------------------------------------------------------------------------
+#
+# Standard python modules
+#
+#-------------------------------------------------------------------------
+from gettext import gettext as _
+import time
+import cgi
+import sys
+import locale
+
+try:
+    set()
+except:
+    from sets import Set as set
+
+#-------------------------------------------------------------------------
+#
+# set up logging
+#
+#-------------------------------------------------------------------------
+import logging
+log = logging.getLogger(".")
+
+#-------------------------------------------------------------------------
+#
+# GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+import const
+from RelLib import *
+import NameDisplay
+import DateHandler
+import ToolTips
+import GrampsLocale
+import Config
+from Filters import SearchFilter
+
+#-------------------------------------------------------------------------
+#
+# python 2.3 has a bug in the unicode sorting using locale.strcoll. Seems
+# to have a buffer overrun. We can convince it to do the right thing by
+# forcing the string to be nul terminated, sorting, then stripping off the
+# nul.
+#
+#-------------------------------------------------------------------------
+
+if sys.version_info[0:2] == (2, 3):
+    def locale_sort(mylist):
+        """
+        Sort version to get around a python2.3 bug with unicode strings
+        """
+        mylist = [ value + "\x00" for value in mylist ]
+        mylist.sort(locale.strcoll)
+        return [ value[:-1] for value in mylist ]
+else:
+    def locale_sort(mylist):
+        """
+        Normal sort routine
+        """
+        mylist.sort(locale.strcoll)
+        return mylist
+
+#-------------------------------------------------------------------------
+#
+# PeopleModel
+#
+#-------------------------------------------------------------------------
+class PeopleModel(gtk.GenericTreeModel):
+    """
+    Basic GenericTreeModel interface to handle the Tree interface for
+    the PersonView
+    """
+
+    # Model types
+    GENERIC = 0
+    SEARCH = 1
+    FAST = 2
+
+    # Column numbers
+    _ID_COL     = 1
+    _GENDER_COL = 2
+    _NAME_COL   = 3
+    _DEATH_COL  = 5
+    _BIRTH_COL  = 6
+    _EVENT_COL  = 7
+    _FAMILY_COL = 8
+    _CHANGE_COL = 17
+    _MARKER_COL = 18
+
+
+    _GENDER = [ _(u'female'), _(u'male'), _(u'unknown') ]
+
+    # dynamic calculation of column indices, for use by various Views
+    COLUMN_INT_ID = 13
+
+    # indices into main column definition table
+    COLUMN_DEF_LIST = 0
+    COLUMN_DEF_HEADER = 1
+    COLUMN_DEF_TYPE = 2
+
+    def __init__(self, db, filter_info=None, skip=[]):
+        """
+        Initialize the model building the initial data
+        """
+        gtk.GenericTreeModel.__init__(self)
+
+        self.db = db
+
+        Config.client.notify_add("/apps/gramps/preferences/todo-color",
+                                 self.update_todo)
+        Config.client.notify_add("/apps/gramps/preferences/custom-marker-color",
+                                 self.update_custom)
+        Config.client.notify_add("/apps/gramps/preferences/complete-color",
+                                 self.update_complete)
+
+        self.complete_color = Config.get(Config.COMPLETE_COLOR)
+        self.todo_color = Config.get(Config.TODO_COLOR)
+        self.custom_color = Config.get(Config.CUSTOM_MARKER_COLOR)
+
+        self.sortnames = {}
+        self.marker_color_column = 11
+        self.tooltip_column = 12
+        self.prev_handle = None
+        self.prev_data = None
+        self.temp_top_path2iter = []
+        self.iter2path = {}
+        self.path2iter = {}
+        self.sname_sub = {}
+        if filter_info:
+            if filter_info[0] == PeopleModel.GENERIC:
+                data_filter = filter_info[1]
+                self._build_data = self._build_filter_sub
+            elif filter_info[0] == PeopleModel.SEARCH:
+                col = filter_info[1][0]
+                text = filter_info[1][1]
+                inv = filter_info[1][2]
+                func = lambda x: self.on_get_value(x, col) or u""
+                data_filter = SearchFilter(func, text, inv)
+                self._build_data = self._build_search_sub
+            else:
+                data_filter = filter_info[1]
+                self._build_data = self._build_search_sub
+        else:
+            self._build_data = self._build_search_sub
+            data_filter = None
+        self.rebuild_data(data_filter, skip)
+
+    def update_todo(self,client,cnxn_id,entry,data):
+        self.todo_color = Config.get(Config.TODO_COLOR)
+        
+    def update_custom(self,client,cnxn_id,entry,data):
+        self.custom_color = Config.get(Config.CUSTOM_MARKER_COLOR)
+
+    def update_complete(self,client,cnxn_id,entry,data):
+        self.complete_color = Config.get(Config.COMPLETE_COLOR)
+
+    def rebuild_data(self, data_filter=None, skip=[]):
+        """
+        Convience function that calculates the new data and assigns it.
+        """
+        self.calculate_data(data_filter, skip)
+        self.assign_data()
+        
+    def _build_search_sub(self,dfilter, skip):
+        self.sortnames = {}
+
+        ngn = NameDisplay.displayer.name_grouping_name
+        nsn = NameDisplay.displayer.raw_sorted_name
+
+        cursor = self.db.get_person_cursor()
+        node = cursor.first()
+
+        while node:
+            handle, d = node
+            if not (handle in skip or (dfilter and not dfilter.match(handle))):
+                name_data = d[PeopleModel._NAME_COL]
+                self.sortnames[handle] = nsn(name_data)
+                try:
+                    self.temp_sname_sub[name_data[5]].append(handle)
+                except:
+                    self.temp_sname_sub[name_data[5]] = [handle]
+            node = cursor.next()
+        cursor.close()
+
+    def _build_filter_sub(self,dfilter, skip):
+        self.sortnames = {}
+
+        ngn = NameDisplay.displayer.name_grouping_name
+        nsn = NameDisplay.displayer.raw_sorted_name
+
+        if dfilter:
+            handle_list = dfilter.apply(self.db, self.db.get_person_handles())
+        else:
+            handle_list = self.db.get_person_handles()
+
+        for handle in handle_list:
+            d = self.db.get_raw_person_data(handle)
+            if not (handle in skip or (dfilter and not dfilter.match(handle))):
+                name_data = d[PeopleModel._NAME_COL]
+                self.sortnames[handle] = nsn(name_data)
+                try:
+                    self.temp_sname_sub[name_data[5]].append(handle)
+                except:
+                    self.temp_sname_sub[name_data[5]] = [handle]
+        
+    def calculate_data(self, dfilter=None, skip=[]):
+        """
+        Calculates the new path to node values for the model.
+        """
+
+        if dfilter:
+            self.dfilter = dfilter
+        self.temp_iter2path = {}
+        self.temp_path2iter = {}
+        self.temp_sname_sub = {}
+
+        if not self.db.is_open():
+            return
+
+        self._build_data(dfilter, skip)
+
+        self.temp_top_path2iter = locale_sort(self.temp_sname_sub.keys())
+        for name in self.temp_top_path2iter:
+            self.build_sub_entry(name)
+
+    def clear_cache(self):
+        self.prev_handle = None
+        
+    def build_sub_entry(self, name):
+        self.prev_handle = None
+        slist = [ (locale.strxfrm(self.sortnames[x]), x) \
+                  for x in self.temp_sname_sub[name] ]
+        slist.sort()
+
+        val = 0
+        for (junk, person_handle) in slist:
+            tpl = (name, val)
+            self.temp_iter2path[person_handle] = tpl
+            self.temp_path2iter[tpl] = person_handle
+            val += 1
+
+    def assign_data(self):
+        self.top_path2iter = self.temp_top_path2iter
+        self.iter2path = self.temp_iter2path
+        self.path2iter = self.temp_path2iter
+        self.sname_sub = self.temp_sname_sub
+
+    def on_get_flags(self):
+        '''returns the GtkTreeModelFlags for this particular type of model'''
+        return gtk.TREE_MODEL_ITERS_PERSIST
+
+    def on_get_n_columns(self):
+        return len(PeopleModel.COLUMN_DEFS)
+
+    def on_get_path(self,  node):
+        '''returns the tree path (a tuple of indices at the various
+        levels) for a particular node.'''
+        try:
+            return (self.top_path2iter.index(node), )
+        except:
+            (surname, index) = self.iter2path[node]
+            return (self.top_path2iter.index(surname), index)
+
+    def is_visable(self, handle):
+        return self.iter2path.has_key(handle)
+
+    def on_get_column_type(self, index):
+        return PeopleModel.COLUMN_DEFS[index][PeopleModel.COLUMN_DEF_TYPE]
+
+    def on_get_iter(self, path):
+        try:
+            if len(path)==1: # Top Level
+                return self.top_path2iter[path[0]]
+            else: # Sublevel
+                surname = self.top_path2iter[path[0]]
+                return self.path2iter[(surname, path[1])]
+        except:
+            return None
+
+    def on_get_value(self, node, col):
+        # test for header or data row-type
+        if self.sname_sub.has_key(node):
+            # Header rows dont get the foreground color set
+            if col == self.marker_color_column:
+                return None
+            # test for 'header' column being empty (most are)
+            if not PeopleModel.COLUMN_DEFS[col][PeopleModel.COLUMN_DEF_HEADER]:
+                return u''
+            # return values for 'header' row, calling a function
+            # according to column_defs table
+            val = PeopleModel.COLUMN_DEFS[col][PeopleModel.COLUMN_DEF_HEADER](self, node)
+            return val
+        else:
+            # return values for 'data' row, calling a function
+            # according to column_defs table
+            try:
+                if node != self.prev_handle:
+                    self.prev_data = self.db.get_raw_person_data(str(node))
+                    self.prev_handle = node
+                return PeopleModel.COLUMN_DEFS[col][PeopleModel.COLUMN_DEF_LIST](self,
+                                                         self.prev_data, node)
+            except:
+                return None
+
+    def on_iter_next(self,  node):
+        '''returns the next node at this level of the tree'''
+        try:
+            path = self.top_path2iter.index(node)
+            if path+1 == len(self.top_path2iter):
+                return None
+            return self.top_path2iter[path+1]
+        except:
+            (surname, val) = self.iter2path[node]
+            return self.path2iter.get((surname, val+1))
+
+    def on_iter_children(self, node):
+        """Return the first child of the node"""
+        if node == None:
+            return self.top_path2iter[0]
+        else:
+            return self.path2iter.get((node, 0))
+
+    def on_iter_has_child(self, node):
+        '''returns true if this node has children'''
+        if node == None:
+            return len(self.sname_sub)
+        if self.sname_sub.has_key(node) and len(self.sname_sub[node]) > 0:
+            return True
+        return False
+
+    def on_iter_n_children(self, node):
+        if node == None:
+            return len(self.sname_sub)
+        try:
+            return len(self.sname_sub[node])
+        except:
+            return 0
+
+    def on_iter_nth_child(self, node, n):
+        try:
+            if node == None:
+                return self.top_path2iter[n]
+            try:
+                return self.path2iter[(node, n)]
+            except:
+                return None
+        except IndexError:
+            return None
+
+    def on_iter_parent(self, node):
+        '''returns the parent of this node'''
+        path = self.iter2path.get(node)
+        if path:
+            return path[0]
+        return None
+
+    def column_sort_name(self, data, node):
+        n = Name()
+        n.unserialize(data[PeopleModel._NAME_COL])
+        return NameDisplay.displayer.sort_string(n)
+
+    def column_spouse(self, data, node):
+        spouses_names = u""
+        handle = data[0]
+        for family_handle in data[PeopleModel._FAMILY_COL]:
+            family = self.db.get_family_from_handle(family_handle)
+            for spouse_id in [family.get_father_handle(),
+                              family.get_mother_handle()]:
+                if not spouse_id:
+                    continue
+                if spouse_id == handle:
+                    continue
+                spouse = self.db.get_person_from_handle(spouse_id)
+                if len(spouses_names) > 0:
+                    spouses_names += ", "
+                spouses_names += NameDisplay.displayer.display(spouse)
+        return spouses_names
+
+    def column_name(self, data, node):
+        n = Name()
+        n.unserialize(data[PeopleModel._NAME_COL])
+        return NameDisplay.displayer.sorted_name(n)
+
+    def column_id(self, data, node):
+        return data[PeopleModel._ID_COL]
+
+    def column_change(self, data, node):
+        return unicode(
+            time.strftime('%x %X',
+                          time.localtime(data[PeopleModel._CHANGE_COL])),
+            GrampsLocale.codeset)
+
+    def column_gender(self, data, node):
+        return PeopleModel._GENDER[data[PeopleModel._GENDER_COL]]
+
+    def column_birth_day(self, data, node):
+        if data[PeopleModel._BIRTH_COL]:
+            b = EventRef()
+            b.unserialize(data[PeopleModel._BIRTH_COL])
+            birth = self.db.get_event_from_handle(b.ref)
+            date_str = DateHandler.get_date(birth)
+            if date_str != "":
+                return cgi.escape(date_str)
+        
+        for event_ref in data[PeopleModel._EVENT_COL]:
+            er = EventRef()
+            er.unserialize(event_ref)
+            event = self.db.get_event_from_handle(er.ref)
+            etype = event.get_type()[0]
+            date_str = DateHandler.get_date(event)
+            if (etype in [EventType.BAPTISM, EventType.CHRISTEN]
+                and date_str != ""):
+                return "<i>" + cgi.escape(date_str) + "</i>"
+        
+        return u""
+
+    def column_death_day(self, data, node):
+        if data[PeopleModel._DEATH_COL]:
+            dr = EventRef()
+            dr.unserialize(data[PeopleModel._DEATH_COL])
+            death = self.db.get_event_from_handle(dr.ref)
+            date_str = DateHandler.get_date(death)
+            if date_str != "":
+                return cgi.escape(date_str)
+        
+        for event_ref in data[PeopleModel._EVENT_COL]:
+            er = EventRef()
+            er.unserialize(event_ref)
+            event = self.db.get_event_from_handle(er.ref)
+            etype = event.get_type()[0]
+            date_str = DateHandler.get_date(event)
+            if (etype in [EventType.BURIAL, EventType.CREMATION]
+                and date_str != ""):
+                return "<i>" + cgi.escape(date_str) + "</i>"
+        
+        return u""
+
+    def column_cause_of_death(self, data, node):
+        if data[PeopleModel._DEATH_COL]:
+            dr = EventRef()
+            dr.unserialize(data[PeopleModel._DEATH_COL])
+            return self.db.get_event_from_handle(dr.ref).get_cause()
+        else:
+            return u""
+        
+    def column_birth_place(self, data, node):
+        if data[PeopleModel._BIRTH_COL]:
+            br = EventRef()
+            br.unserialize(data[PeopleModel._BIRTH_COL])
+            event = self.db.get_event_from_handle(br.ref)
+            if event:
+                place_handle = event.get_place_handle()
+                if place_handle:
+                    place = self.db.get_place_from_handle(place_handle)
+                    place_title = place.get_title()
+                    if place_title != "":
+                        return cgi.escape(place_title)
+        
+        for event_ref in data[PeopleModel._EVENT_COL]:
+            er = EventRef()
+            er.unserialize(event_ref)
+            event = self.db.get_event_from_handle(er.ref)
+            etype = event.get_type()[0]
+            if etype in [EventType.BAPTISM, EventType.CHRISTEN]:
+                place_handle = event.get_place_handle()
+                if place_handle:
+                    place = self.db.get_place_from_handle(place_handle)
+                    place_title = place.get_title()
+                    if place_title != "":
+                        return "<i>" + cgi.escape(place_title) + "</i>"
+        
+        return u""
+
+    def column_death_place(self, data, node):
+        if data[PeopleModel._DEATH_COL]:
+            dr = EventRef()
+            dr.unserialize(data[PeopleModel._DEATH_COL])
+            event = self.db.get_event_from_handle(dr.ref)
+            if event:
+                place_handle = event.get_place_handle()
+                if place_handle:
+                    place = self.db.get_place_from_handle(place_handle)
+                    place_title = place.get_title()
+                    if place_title != "":
+                        return cgi.escape(place_title)
+        
+        for event_ref in data[PeopleModel._EVENT_COL]:
+            er = EventRef()
+            er.unserialize(event_ref)
+            event = self.db.get_event_from_handle(er.ref)
+            etype = event.get_type()[0]
+            if etype in [EventType.BURIAL, EventType.CREMATION]:
+                place_handle = event.get_place_handle()
+                if place_handle:
+                    place = self.db.get_place_from_handle(place_handle)
+                    place_title = place.get_title()
+                    if place_title != "":
+                        return "<i>" + cgi.escape(place_title) + "</i>"
+        
+        return u""
+
+    def column_marker_text(self, data, node):
+        try:
+            if data[PeopleModel._MARKER_COL]:
+                return str(data[PeopleModel._MARKER_COL])
+        except IndexError:
+            return ""
+        return ""
+
+    def column_marker_color(self, data, node):
+        try:
+            if data[PeopleModel._MARKER_COL]:
+                if data[PeopleModel._MARKER_COL][0] == MarkerType.COMPLETE:
+                    return self.complete_color
+                if data[PeopleModel._MARKER_COL][0] == MarkerType.TODO:
+                    return self.todo_color
+                if data[PeopleModel._MARKER_COL][0] == MarkerType.CUSTOM:
+                    return self.custom_color
+        except IndexError:
+            pass
+        return None
+
+    def column_tooltip(self, data, node):
+        if const.use_tips:
+            return ToolTips.TipFromFunction(
+                self.db,
+                lambda: self.db.get_person_from_handle(data[0])
+                )
+        else:
+            return u''
+        
+
+    def column_int_id(self, data, node):
+        return node
+
+    def column_header(self, node):
+        return node
+
+    def column_header_view(self, node):
+        return True
+
+    # table of column definitions
+    # (unless this is declared after the PeopleModel class, an error is thrown)
+
+    COLUMN_DEFS = [
+        (column_name,           column_header, str),
+        (column_id,             None,                      str),
+        (column_gender,         None,                      str),
+        (column_birth_day,      None,                      str),
+        (column_birth_place,    None,                      str),
+        (column_death_day,      None,                      str),
+        (column_death_place,    None,                      str),
+        (column_spouse,         None,                      str),
+        (column_change,         None,                      str),
+        (column_cause_of_death, None,                      str),
+        (column_marker_text,    None,                      str),
+        (column_marker_color,   None,                      str),
+        # the order of the above columns must match PeopleView.column_names
+
+        # these columns are hidden, and must always be last in the list
+        (column_tooltip,        None,                      object),  
+        (column_int_id,         None,                      str),
+        ]

src/DisplayModels/_PlaceModel.py

@@ -0,0 +1,161 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+#-------------------------------------------------------------------------
+#
+# python modules
+#
+#-------------------------------------------------------------------------
+import time
+import logging
+log = logging.getLogger(".")
+
+#-------------------------------------------------------------------------
+#
+# GNOME/GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+import const
+import ToolTips
+import GrampsLocale
+from _BaseModel import BaseModel
+
+#-------------------------------------------------------------------------
+#
+# PlaceModel
+#
+#-------------------------------------------------------------------------
+class PlaceModel(BaseModel):
+
+    def __init__(self,db,scol=0,order=gtk.SORT_ASCENDING,search=None):
+        self.gen_cursor = db.get_place_cursor
+        self.map = db.get_raw_place_data
+        self.fmap = [
+            self.column_name,
+            self.column_id,
+            self.column_parish,
+            self.column_postal_code,
+            self.column_city,
+            self.column_county,
+            self.column_state,
+            self.column_country,
+            self.column_longitude,
+            self.column_latitude,
+            self.column_change,
+            self.column_handle,
+            self.column_tooltip
+            ]
+        self.smap = [
+            self.column_name,
+            self.column_id,
+            self.column_parish,
+            self.column_postal_code,
+            self.column_city,
+            self.column_county,
+            self.column_state,
+            self.column_country,
+            self.column_longitude,
+            self.column_latitude,
+            self.column_change,
+            self.column_handle,
+            ]
+        BaseModel.__init__(self, db, scol, order, tooltip_column=12,
+                           search=search)
+
+    def on_get_n_columns(self):
+        return len(self.fmap)+1
+
+    def column_handle(self,data):
+        return unicode(data[0])
+
+    def column_name(self,data):
+        return unicode(data[2])
+
+    def column_longitude(self,data):
+        return unicode(data[3])
+
+    def column_latitude(self,data):
+        return unicode(data[4])
+
+    def column_id(self,data):
+        return unicode(data[1])
+
+    def column_parish(self,data):
+        try:
+            return data[5][1]
+        except:
+            return u''
+
+    def column_city(self,data):
+        try:
+            return data[5][0][0]
+        except:
+            return u''
+        
+    def column_county(self,data):
+        try:
+            return data[5][2]
+        except:
+            return u''
+    
+    def column_state(self,data):
+        try:
+            return data[5][0][1]
+        except:
+            return u''
+
+    def column_country(self,data):
+        try:
+            return data[5][0][2]
+        except:
+            return u''
+
+    def column_postal_code(self,data):
+        try:
+            return data[5][0][3]
+        except:
+            return u''
+
+    def sort_change(self,data):
+        return "%012x" % data[11]
+    
+    def column_change(self,data):
+        return unicode(time.strftime('%x %X',time.localtime(data[11])),
+                            GrampsLocale.codeset)
+
+    def column_tooltip(self,data):
+        if const.use_tips:
+            try:
+                t = ToolTips.TipFromFunction(
+                    self.db, lambda:
+                    self.db.get_place_from_handle(data[0]))
+            except:
+                log.error("Failed to create tooltip.", exc_info=True)
+            return t
+        else:
+            return u''

src/DisplayModels/_RepositoryModel.py

@@ -0,0 +1,221 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+#-------------------------------------------------------------------------
+#
+# python modules
+#
+#-------------------------------------------------------------------------
+import time
+import logging
+log = logging.getLogger(".")
+
+#-------------------------------------------------------------------------
+#
+# GNOME/GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+import const
+import ToolTips
+import GrampsLocale
+import RelLib
+from _BaseModel import BaseModel
+
+#-------------------------------------------------------------------------
+#
+# RepositoryModel
+#
+#-------------------------------------------------------------------------
+class RepositoryModel(BaseModel):
+
+    def __init__(self, db, scol=0, order=gtk.SORT_ASCENDING, search=None):
+        self.gen_cursor = db.get_repository_cursor
+        self.get_handles = db.get_repository_handles
+        self.map = db.get_raw_repository_data
+        self.fmap = [
+            self.column_name,
+            self.column_id,
+            self.column_type,
+            self.column_home_url,
+            self.column_street,
+            self.column_postal_code,
+            self.column_city,
+            self.column_county,
+            self.column_state,
+            self.column_country,
+            self.column_email,
+            self.column_search_url,            
+            self.column_handle,
+            self.column_tooltip
+            ]
+        
+        self.smap = [
+            self.column_name,
+            self.column_id,
+            self.column_type,
+            self.column_home_url,
+            self.column_street,
+            self.column_postal_code,
+            self.column_city,
+            self.column_county,
+            self.column_state,
+            self.column_country,
+            self.column_email,
+            self.column_search_url,            
+            self.column_handle,            
+            ]
+        
+        BaseModel.__init__(self, db, scol, order, tooltip_column=12,
+                           search=search)
+
+    def on_get_n_columns(self):
+        return len(self.fmap)+1
+
+    def column_handle(self,data):
+        return unicode(data[0])
+
+    def column_id(self,data):
+        return unicode(data[1])
+
+    def column_type(self,data):
+        return str(RelLib.RepositoryType(data[2]))
+
+    def column_name(self,data):
+        return unicode(data[3])
+
+    def column_city(self,data):
+        try:
+            if data[4]:
+                addr = RelLib.Address()
+                addr.unserialize(data[4][0])
+                return addr.get_city()
+            else:
+                return u''
+        except:
+            return u''
+
+    def column_street(self,data):
+        try:
+            if data[5]:
+                addr = RelLib.Address()
+                addr.unserialize(data[5][0])
+                return addr.get_street()
+            else:
+                return u''
+        except:
+            return u''
+        
+    def column_county(self,data):
+        try:
+            if data[5]:
+                addr = RelLib.Address()
+                addr.unserialize(data[5][0])
+                return addr.get_county()
+            else:
+                return u''
+        except:
+            return u''
+    
+    def column_state(self,data):
+        try:
+            if data[5]:
+                addr = RelLib.Address()
+                addr.unserialize(data[5][0])
+                return addr.get_state()
+            else:
+                return u''
+        except:
+            return u''
+
+    def column_country(self,data):
+        try:
+            if data[5]:
+                addr = RelLib.Address()
+                addr.unserialize(data[5][0])
+                return addr.get_country()
+            else:
+                return u''
+        except:
+            return u''
+
+    def column_postal_code(self,data):
+        try:
+            if data[5]:
+                addr = RelLib.Address()
+                addr.unserialize(data[5][0])
+                return addr.get_postal_code()
+            else:
+                return u''
+        except:
+            return u''
+
+    def column_phone(self,data):
+        try:
+            if data[5]:
+                addr = RelLib.Address()
+                addr.unserialize(data[5][0])
+                return addr.get_phone()
+            else:
+                return u''
+        except:
+            return u''
+
+    def column_email(self,data):
+        if data[6]:
+            for i in data[6]:
+                url = RelLib.Url()
+                url.unserialize(i)
+                if url.get_type() == RelLib.UrlType.EMAIL:
+                    return unicode(url.path)
+        return u''
+
+    def column_search_url(self,data):
+        if data[6]:
+            for i in data[6]:
+                url = RelLib.Url()
+                url.unserialize(i)
+                if url.get_type() == RelLib.UrlType.WEB_SEARCH:
+                    return unicode(url.path)
+        return u''
+    
+    def column_home_url(self,data):
+        if data[6]:
+            for i in data[6]:
+                url = RelLib.Url()
+                url.unserialize(i)
+                if url.get_type() == RelLib.UrlType.WEB_HOME:
+                    return unicode(url.path)
+        return u""
+
+    def column_tooltip(self,data):
+        return ""
+#         try:
+#             t = ToolTips.TipFromFunction(self.db, lambda: self.db.get_repository_from_handle(data[0]))
+#         except:
+#             log.error("Failed to create tooltip.", exc_info=True)
+#         return t

src/DisplayModels/_SourceModel.py

@@ -0,0 +1,115 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+#-------------------------------------------------------------------------
+#
+# python modules
+#
+#-------------------------------------------------------------------------
+import time
+import logging
+log = logging.getLogger(".")
+
+#-------------------------------------------------------------------------
+#
+# GNOME/GTK modules
+#
+#-------------------------------------------------------------------------
+import gtk
+
+#-------------------------------------------------------------------------
+#
+# GRAMPS modules
+#
+#-------------------------------------------------------------------------
+import const
+import ToolTips
+import GrampsLocale
+from _BaseModel import BaseModel
+
+#-------------------------------------------------------------------------
+#
+# SourceModel
+#
+#-------------------------------------------------------------------------
+class SourceModel(BaseModel):
+
+    def __init__(self,db,scol=0,order=gtk.SORT_ASCENDING,search=None):
+        self.map = db.get_raw_source_data
+        self.gen_cursor = db.get_source_cursor
+        self.fmap = [
+            self.column_title,
+            self.column_id,
+            self.column_author,
+            self.column_abbrev,
+            self.column_pubinfo,
+            self.column_change,
+            self.column_handle,
+            self.column_tooltip
+            ]
+        self.smap = [
+            self.column_title,
+            self.column_id,
+            self.column_author,
+            self.column_abbrev,
+            self.column_pubinfo,
+            self.sort_change,
+            ]
+        BaseModel.__init__(self,db,scol,order,tooltip_column=7,search=search)
+
+    def on_get_n_columns(self):
+        return len(self.fmap)+1
+
+    def column_title(self,data):
+        return unicode(data[2])
+
+    def column_handle(self,data):
+        return unicode(data[0])
+
+    def column_author(self,data):
+        return unicode(data[3])
+
+    def column_abbrev(self,data):
+        return unicode(data[7])
+
+    def column_id(self,data):
+        return unicode(data[1])
+
+    def column_pubinfo(self,data):
+        return unicode(data[4])
+
+    def column_change(self,data):
+        return unicode(time.strftime('%x %X',time.localtime(data[8])),
+                       GrampsLocale.codeset)
+    
+    def sort_change(self,data):
+        return "%012x" % data[8]
+
+    def column_tooltip(self,data):
+        if const.use_tips:
+            try:
+                t = ToolTips.TipFromFunction(self.db, lambda:
+                                             self.db.get_source_from_handle(data[0]))
+            except:
+                log.error("Failed to create tooltip.",exc_info=True)
+                return t
+        else:
+            return u''

src/DisplayModels/__init__.py

@@ -0,0 +1,28 @@
+#
+# Gramps - a GTK+/GNOME based genealogy program
+#
+# Copyright (C) 2000-2006  Donald N. Allingham
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# $Id$
+
+from _PeopleModel import PeopleModel
+from _FamilyModel import FamilyModel
+from _EventModel import EventModel
+from _SourceModel import SourceModel
+from _PlaceModel import PlaceModel
+from _MediaModel import MediaModel
+from _RepositoryModel import RepositoryModel