gramps/gramps2/src/PeopleView.py

# -*- coding: utf-8 -*-
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2000-2003  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$

#-------------------------------------------------------------------------
#
# internationalization
#
#-------------------------------------------------------------------------
from gettext import gettext as _

#-------------------------------------------------------------------------
#
# gtk
#
#-------------------------------------------------------------------------
import gtk
import gtk.glade

from gtk.gdk import ACTION_COPY, BUTTON1_MASK

_sel_mode = gtk.SELECTION_MULTIPLE

#-------------------------------------------------------------------------
#
# gtk
#
#-------------------------------------------------------------------------
import PeopleStore
import Filter

#-------------------------------------------------------------------------
#
# PeopleView
#
#-------------------------------------------------------------------------
class PeopleView:

    def __init__(self,parent):
        self.parent = parent

        self.DataFilter = Filter.Filter("")
        self.ptabs      = self.parent.gtop.get_widget("ptabs")
        self.pl_other   = self.parent.gtop.get_widget("pl_other")

        self.ptabs.set_show_tabs(0)

        self.pl_page = [
            PeopleStore.PeopleStore(self.pl_other, self, self.row_changed,
                                    self.alpha_event, _sel_mode),
            ]

        self.person_tree = self.pl_page[0]
        self.person_list = self.pl_page[0].tree
        self.person_model = self.pl_page[0].model
        self.person_list.connect('button-press-event',self.on_plist_button_press)        
        
        self.default_list = self.pl_page[-1]

        self.alpha_page = {}
        self.model2page = {}
        self.model_used = {}
        self.tab_list = []
        self.clearing_tabs = 0

    def row_changed(self,obj):
        mlist = self.person_tree.get_selected_objects()
        if mlist and mlist[0]:
            try:
                self.parent.change_active_person(self.parent.db.getPerson(mlist[0]))
            except:
                self.parent.change_active_person(None)
                self.person_tree.unselect()
                
    def change_alpha_page(self,obj,junk,page):
        """Change the page. Be careful not to take action while the pages
        are begin removed. If clearing_tabs is set, then we don't do anything"""
        
        if self.clearing_tabs:
            return
	self.person_tree = self.pl_page[page]
        self.person_list = self.pl_page[page].tree
        self.person_model = self.pl_page[page].model
        if not self.model_used.has_key(self.person_tree) or self.model_used[self.person_tree] == 0:
            self.model_used[self.person_tree] = 1
            self.apply_filter(self.person_tree)
            self.person_list.connect('button-press-event',self.on_plist_button_press)
        mlist = self.person_tree.get_selected_objects()
        if mlist:
            self.parent.set_buttons(1)
        else:
            self.parent.set_buttons(0)
        
    def clear_person_tabs(self):
        self.clearing_tabs = 1
        self.ptabs.hide()
        for i in range(0,len(self.tab_list)):
            self.ptabs.remove_page(0)
        self.ptabs.set_show_tabs(0)
        self.ptabs.show()
        self.clearing_tabs = 0

        self.id2col  = {}
        self.tab_list = []
        self.alpha_page = {}
        self.model2page = {}
        self.model_used = {}

        self.default_list.clear()

        for page in self.pl_page[0:-1]:
            del page
        
        self.pl_page = [
            self.default_list
            ]

        self.person_tree = self.pl_page[-1]
        self.person_list = self.pl_page[-1].tree
        self.person_model = self.pl_page[-1].model
    
    def change_db(self,db):
        self.id2col = {}

    def clear(self):
        for model in self.pl_page:
            model.clear()

    def remove_from_person_list(self,person,old_id=None):
        pid = person.getId()
        if old_id:
            del_id = old_id
        else:
            del_id = pid

        if self.id2col.has_key(del_id):
            (model,iter) = self.id2col[del_id]
            model.remove(iter)
            del self.id2col[del_id]
            
            if person == self.parent.active_person:
                self.parent.active_person = None
    
    def remove_from_history(self,person,old_id=None):
        pid = person.getId()
        if old_id:
            del_id = old_id
        else:
            del_id = pid

        hc = self.parent.history.count(del_id)
        for c in range(hc):
            self.parent.history.remove(del_id)
            self.parent.hindex = self.parent.hindex - 1
        
        mhc = self.parent.mhistory.count(del_id)
        for c in range(mhc):
            self.parent.mhistory.remove(del_id)

    def apply_filter_clicked(self):
        invert_filter = self.parent.filter_inv.get_active()
        qualifer = self.parent.filter_text.get_text()
        mi = self.parent.filter_list.get_menu().get_active()
        class_init = mi.get_data("function")
        self.DataFilter = class_init(qualifer)
        self.DataFilter.set_invert(invert_filter)
        self.model_used = {}
        self.clear_person_tabs()
        self.apply_filter(self.person_tree)
        self.goto_active_person()

    def add_to_person_list(self,person,change):
        key = person.getId()
        val = self.parent.db.getPersonDisplay(person.getId())
        pg = unicode(val[5])
        pg = pg[0]
        if self.DataFilter.compare(person):

            if pg and pg != '@':
                if not self.alpha_page.has_key(pg):
                    self.create_new_panel(pg)
                model = self.alpha_page[pg]
            else:
                model = self.default_list

            iter = model.add([val[0],val[1],val[2],val[3],val[4],val[5],
                              val[6],val[7],val[8]],1)

            self.id2col[key] = (model,iter)

        if change:
            self.parent.change_active_person(person)
        self.goto_active_person()
        model.enable_sort()

    def goto_active_person(self,first=0):
        if not self.parent.active_person:
            if first:
                page = 0
            else:
                page = self.ptabs.get_current_page()

            self.person_tree = self.pl_page[page]
            self.person_list = self.pl_page[page].tree
            self.person_model = self.pl_page[page].model
            self.ptabs.set_current_page(page)
            return
        
        id = self.parent.active_person.getId()
        val = self.parent.db.getPersonDisplay(id)
        if self.id2col.has_key(id):
            (model,iter) = self.id2col[id]
        else:
            pg = val[5]
            if pg and pg != '@':
                pg = pg[0]
            else:
                pg = ''
            if not self.alpha_page.has_key(pg):
                self.create_new_panel(pg)
            model = self.alpha_page[pg]
            iter = None

        self.ptabs.set_current_page(self.model2page[model])

        if not self.model_used.has_key(model) or self.model_used[model] == 0 or not iter:
            self.model_used[model] = 1
            self.apply_filter(model)
            try:
                (model,iter) = self.id2col[id]
            except KeyError:
                return

        if not iter:
            self.parent.status_text(_('Updating display...'))
            model.expand_row(val[-1])
            (m,iter) = self.id2col[id]
            self.parent.modify_statusbar()

        try:
            model.selection.unselect_all()
            model.selection.select_iter(iter)
        except:
            print iter
            
        itpath = model.model.get_path(iter)
        col = model.tree.get_column(0)
        model.tree.scroll_to_cell(itpath,col,1,0.5,0)

    def alpha_event(self,obj):
        self.parent.load_person(self.parent.active_person)

    def apply_filter(self,current_model=None):
        self.parent.status_text(_('Updating display...'))

        datacomp = self.DataFilter.compare
        if current_model == None:
            self.id2col = {}

        for key in self.parent.db.sortPersonKeys():
            person = self.parent.db.getPerson(key)
            val = self.parent.db.getPersonDisplay(key)
            pg = val[5]
            if pg and pg != '@':
                pg = pg[0]
            else:
                pg = ''

            if datacomp(person):
                if self.id2col.has_key(key):
                    continue
                if pg and pg != '@':
                    if not self.alpha_page.has_key(pg):
                        self.create_new_panel(pg)
                    model = self.alpha_page[pg]
                else:
                    model = self.default_list

                if current_model == model:
                    iter = model.add([val[0],val[1],val[2],val[3],val[4],val[5],
                                      val[6],val[7],val[8]])
                    self.id2col[key] = (model,iter)
            else:
                if self.id2col.has_key(key):
                    (model,iter) = self.id2col[key]
                    model.remove(iter)
                    del self.id2col[key]

        for i in self.pl_page:
            i.sort()

        self.parent.modify_statusbar()

    def create_new_panel(self,pg):
        
        display = gtk.ScrolledWindow()
        display.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC)
        tree = gtk.TreeView()
        tree.show()
        display.add(tree)
        display.show()
        model = PeopleStore.PeopleStore(tree, self, self.row_changed,
                                        self.alpha_event,_sel_mode)
        self.alpha_page[pg] = model
        for index in range(0,len(self.tab_list)):
            try:
                if pg < self.tab_list[index]:
                    self.ptabs.insert_page(display,gtk.Label(pg),index)
                    self.ptabs.set_show_tabs(1)
                    self.tab_list.insert(index,pg)
                    self.pl_page.insert(index,model)
                    break
            except:
                print index
        else:
            #added by EARNEY on 5/5/2003
            #modified the block below because sometimes certain
            #letters under people panel
            #will not load properly after a quick add
            #(ie, adding a parent under the family panel)
            index=len(self.tab_list)
            self.ptabs.insert_page(display,gtk.Label(pg),index)
            self.ptabs.set_show_tabs(1)
            self.tab_list.insert(index,pg)
            self.pl_page.insert(index,model)

            #instead of the following..
            #self.ptabs.insert_page(display,gtk.Label(pg),len(self.tab_list))
            #self.ptabs.set_show_tabs(1)
            #self.tab_list.append(pg)
            #self.pl_page = self.pl_page[0:-1] + [model,self.default_list]


        for index in range(0,len(self.tab_list)):
            model = self.alpha_page[self.tab_list[index]]
            self.model2page[model] = index
            self.model_used[model] = 0
        self.model2page[self.default_list] = len(self.tab_list)
        self.model_used[self.default_list] = 0

        
    def on_plist_button_press(self,obj,event):
        if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
            self.build_people_context_menu(event)

    def build_people_context_menu(self,event):
        """Builds the menu with navigation and 
        editing operations on the people's list"""
        
        back_sensitivity = self.parent.hindex > 0 
        fwd_sensitivity = self.parent.hindex + 1 < len(self.parent.history)
        mlist = self.person_tree.get_selected_objects()
        if mlist:
            sel_sensitivity = 1
        else:
            sel_sensitivity = 0
        entries = [
            (gtk.STOCK_GO_BACK,self.parent.back_clicked,back_sensitivity),
            (gtk.STOCK_GO_FORWARD,self.parent.fwd_clicked,fwd_sensitivity),
            (gtk.STOCK_HOME,self.parent.on_home_clicked,1),
            (_("Add Bookmark"),self.parent.on_add_bookmark_activate,sel_sensitivity),
            (None,None,0),
            (gtk.STOCK_ADD, self.parent.add_button_clicked,1),
            (gtk.STOCK_REMOVE, self.parent.remove_button_clicked,sel_sensitivity),
            (_("Edit"), self.parent.edit_button_clicked,sel_sensitivity),
        ]

        menu = gtk.Menu()
        menu.set_title(_('People Menu'))
        for stock_id,callback,sensitivity in entries:
            item = gtk.ImageMenuItem(stock_id)
            if callback:
                item.connect("activate",callback)
            item.set_sensitive(sensitivity)
            item.show()
            menu.append(item)
        menu.popup(None,None,None,event.button,event.time)
        
    def redisplay_person_list(self,person):
        self.add_to_person_list(person,1)

    def update_person_list(self,person,old_id):
        key = person.getId()
        if old_id != key:
            (model,iter) = self.id2col[old_id]
            del self.id2col[old_id]
            self.id2col[key] = (model,iter)
        else:
            (model,iter) = self.id2col[key]
            
        val = self.parent.db.getPersonDisplay(person.getId())
        pg = unicode(val[5])[0]
        if self.DataFilter.compare(person):
            col = 0
            for object in val[:-1]:
                model.model.set_value(iter,col,object)
                col = col + 1