386 lines
12 KiB
Python
386 lines
12 KiB
Python
#
|
|
# 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$
|
|
|
|
#for debug, remove later
|
|
import sys
|
|
sys.path.append("..")
|
|
sys.path.append(".")
|
|
sys.path.append("ObjectSelector")
|
|
|
|
import os.path
|
|
import gtk
|
|
import gobject
|
|
from gettext import gettext as _
|
|
|
|
import _Factories
|
|
from _Constants import ObjectTypes
|
|
from _ObjectSelectorResult import ObjectSelectorResult
|
|
|
|
from DisplayState import ManagedWindow
|
|
import const
|
|
|
|
class _ObjectTypeWidgets(object):
|
|
|
|
def __init__(self):
|
|
self.frame = None
|
|
self.sel_label = None
|
|
self.selected_id = None
|
|
self.new_button = None
|
|
|
|
def show(self):
|
|
self.frame.show_all()
|
|
self.sel_label.show_all()
|
|
self.new_button.show()
|
|
|
|
def hide(self):
|
|
self.frame.hide_all()
|
|
self.sel_label.hide_all()
|
|
self.new_button.hide()
|
|
|
|
def set_selected_id(self,id):
|
|
self.selected_id = id
|
|
|
|
OBJECT_LIST = [ObjectTypes.PERSON, ObjectTypes.FAMILY,
|
|
ObjectTypes.SOURCE, ObjectTypes.EVENT,
|
|
ObjectTypes.MEDIA, ObjectTypes.PLACE,
|
|
ObjectTypes.REPOSITORY]
|
|
|
|
class ObjectSelectorWindow(gtk.Window,ManagedWindow):
|
|
|
|
__gproperties__ = {}
|
|
|
|
__gsignals__ = {
|
|
'add-object' : (gobject.SIGNAL_RUN_LAST,
|
|
gobject.TYPE_NONE,
|
|
(gobject.TYPE_PYOBJECT,)),
|
|
}
|
|
|
|
__default_border_width = 5
|
|
|
|
|
|
|
|
def __init__(self,
|
|
dbstate,
|
|
uistate,
|
|
track,
|
|
title = _("Select Object"),
|
|
filter_spec = None,
|
|
default_object_type = ObjectTypes.PERSON,
|
|
object_list = OBJECT_LIST):
|
|
|
|
# Init the display manager
|
|
ManagedWindow.__init__(self,uistate,track,self)
|
|
|
|
# Init the Window
|
|
gtk.Window.__init__(self)
|
|
|
|
self._dbstate = dbstate
|
|
self._uistate = dbstate
|
|
self._track = track
|
|
self._object_list = object_list
|
|
self._current_object_type = None
|
|
|
|
# Create objects to hold the information about
|
|
# each object type
|
|
self._object_frames = {}
|
|
for object_type in object_list:
|
|
self._object_frames[object_type] = _ObjectTypeWidgets()
|
|
|
|
self.set_title(title)
|
|
|
|
# Selected object label
|
|
|
|
new_button_box = gtk.VBox()
|
|
new_button_box.show()
|
|
|
|
for object_type in object_list:
|
|
new_button = gtk.Button(stock=gtk.STOCK_NEW)
|
|
|
|
self._object_frames[object_type].new_button = new_button
|
|
new_button_box.pack_start(new_button)
|
|
|
|
label = gtk.Label("<b>Selected:</b>")
|
|
label.set_use_markup(True)
|
|
label.set_alignment(xalign=0.9,yalign=0.5)
|
|
label.set_padding(self.__class__.__default_border_width,
|
|
self.__class__.__default_border_width)
|
|
|
|
label.show()
|
|
|
|
sel_frame = gtk.Frame()
|
|
sel_frame.set_shadow_type(gtk.SHADOW_IN)
|
|
sel_frame.set_border_width(self.__class__.__default_border_width*2)
|
|
|
|
sel_label_box = gtk.HBox()
|
|
sel_label_box.show()
|
|
|
|
for object_type in object_list:
|
|
sel_label = gtk.Label("No Selected Object")
|
|
sel_label.set_alignment(xalign=0,yalign=0.5)
|
|
sel_label_box.pack_start(sel_label)
|
|
|
|
self._object_frames[object_type].sel_label = sel_label
|
|
|
|
sel_frame.add(sel_label_box)
|
|
sel_frame.show()
|
|
|
|
label_box = gtk.HBox()
|
|
label_box.pack_start(new_button_box,False,False)
|
|
label_box.pack_start(label,False,False)
|
|
label_box.pack_start(sel_frame,True,True)
|
|
label_box.show()
|
|
|
|
# Object select
|
|
obj_label = gtk.Label("<b>Show</b>")
|
|
obj_label.set_use_markup(True)
|
|
obj_label.set_alignment(xalign=0.9,yalign=0.5)
|
|
obj_label.set_padding(self.__class__.__default_border_width,
|
|
self.__class__.__default_border_width)
|
|
|
|
|
|
person_pixbuf = gtk.gdk.pixbuf_new_from_file(os.path.join(const.rootDir,"person.svg"))
|
|
flist_pixbuf = gtk.gdk.pixbuf_new_from_file(os.path.join(const.rootDir,"flist.svg"))
|
|
|
|
self._tool_list = gtk.ListStore(gtk.gdk.Pixbuf, str,int)
|
|
|
|
d={ObjectTypes.PERSON: [person_pixbuf,'People',ObjectTypes.PERSON],
|
|
ObjectTypes.FAMILY: [flist_pixbuf,'Families',ObjectTypes.FAMILY],
|
|
ObjectTypes.EVENT: [person_pixbuf,'Events',ObjectTypes.EVENT]}
|
|
|
|
for object_type in self._object_list:
|
|
self._tool_list.append(d[object_type])
|
|
|
|
self._tool_combo = gtk.ComboBox(self._tool_list)
|
|
|
|
icon_cell = gtk.CellRendererPixbuf()
|
|
label_cell = gtk.CellRendererText()
|
|
|
|
self._tool_combo.pack_start(icon_cell, True)
|
|
self._tool_combo.pack_start(label_cell, True)
|
|
|
|
self._tool_combo.add_attribute(icon_cell, 'pixbuf', 0)
|
|
self._tool_combo.add_attribute(label_cell, 'text', 1)
|
|
|
|
self._tool_combo.set_active(0)
|
|
|
|
self._tool_combo.connect('changed', lambda c: self._set_object_type(self._tool_list.get_value(c.get_active_iter(),2)))
|
|
|
|
tool_box = gtk.HBox()
|
|
tool_box.pack_start(obj_label,False,False)
|
|
tool_box.pack_start(self._tool_combo,False,False)
|
|
|
|
# only show the object_list if there is more than
|
|
# one object_type requested.
|
|
if len(self._object_list) > 1:
|
|
self._tool_combo.show()
|
|
obj_label.show()
|
|
tool_box.show()
|
|
|
|
# Top box
|
|
|
|
top_box = gtk.HBox()
|
|
top_box.pack_start(tool_box,False,False)
|
|
top_box.pack_start(label_box,True,True)
|
|
top_box.show()
|
|
|
|
# Create the widgets for each of the object types
|
|
|
|
# Object frame box
|
|
|
|
frame_box = gtk.HBox()
|
|
frame_box.show()
|
|
|
|
|
|
for object_type in object_list:
|
|
|
|
self._object_frames[object_type].frame = \
|
|
_Factories.ObjectFrameFactory().get_frame(object_type,dbstate,uistate,filter_spec)
|
|
|
|
# connect signals
|
|
self._object_frames[object_type].frame.connect(
|
|
'selection-changed',
|
|
lambda widget,text,handle,label: label.set_text(text),
|
|
self._object_frames[object_type].sel_label)
|
|
|
|
self._object_frames[object_type].frame.connect(
|
|
'selection-changed',
|
|
lambda widget,text,handle,current_object: current_object.set_selected_id(handle),
|
|
self._object_frames[object_type])
|
|
|
|
self._object_frames[object_type].frame.connect(
|
|
'selection-changed',
|
|
self.on_selection_changed)
|
|
|
|
self._object_frames[object_type].frame.connect(
|
|
'add-object',
|
|
self.on_add)
|
|
|
|
self._object_frames[object_type].new_button.connect(
|
|
'clicked',
|
|
self._object_frames[object_type].frame.new_object)
|
|
|
|
frame_box.pack_start(self._object_frames[object_type].frame,True,True)
|
|
|
|
|
|
# Bottom buttons
|
|
self._add_button = gtk.Button(stock=gtk.STOCK_ADD)
|
|
self._add_button.set_sensitive(False)
|
|
self._add_button.show()
|
|
|
|
self._add_button.connect("clicked", self.on_add)
|
|
|
|
cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
|
|
cancel_button.show()
|
|
|
|
cancel_button.connect_object("clicked", gtk.Widget.destroy, self)
|
|
|
|
bottom_button_bar = gtk.HButtonBox()
|
|
bottom_button_bar.set_layout(gtk.BUTTONBOX_SPREAD)
|
|
bottom_button_bar.set_spacing(self.__class__.__default_border_width/2)
|
|
bottom_button_bar.set_border_width(self.__class__.__default_border_width)
|
|
bottom_button_bar.add(cancel_button)
|
|
bottom_button_bar.add(self._add_button)
|
|
bottom_button_bar.show()
|
|
|
|
box = gtk.VBox()
|
|
box.pack_start(top_box,False,False)
|
|
box.pack_start(frame_box,True,True)
|
|
box.pack_start(bottom_button_bar,False,False)
|
|
box.show()
|
|
|
|
align = gtk.Alignment()
|
|
align.set_padding(self.__class__.__default_border_width,
|
|
self.__class__.__default_border_width,
|
|
self.__class__.__default_border_width,
|
|
self.__class__.__default_border_width)
|
|
align.set(0.5,0.5,1,1)
|
|
align.add(box)
|
|
align.show()
|
|
|
|
self.add(align)
|
|
|
|
self._set_object_type(default_object_type)
|
|
self.set_default_size(700,300)
|
|
|
|
self.show()
|
|
|
|
|
|
def _set_object_type(self,selected_object_type):
|
|
# enable selected object type
|
|
self._object_frames[selected_object_type].show()
|
|
|
|
# disable all the others
|
|
[ self._object_frames[object_type].hide() for object_type in self._object_list
|
|
if object_type != selected_object_type]
|
|
|
|
# Set the object selector list to the selected object type
|
|
# this is required because we may be asked to set the object type
|
|
# without the use selecting it explicitly from the list.
|
|
store = self._tool_list
|
|
it = store.get_iter_first()
|
|
while it:
|
|
if store.get(it, 2)[0] == selected_object_type:
|
|
break
|
|
it = store.iter_next(it)
|
|
|
|
if it != None:
|
|
self._tool_combo.set_active_iter(it)
|
|
|
|
self._current_object_type = selected_object_type
|
|
|
|
# Set the add button sensitivity
|
|
if self._object_frames[selected_object_type].selected_id:
|
|
self._add_button.set_sensitive(True)
|
|
else:
|
|
self._add_button.set_sensitive(False)
|
|
|
|
|
|
def get_result(self):
|
|
result = ObjectSelectorResult()
|
|
result.set_object_type(self._current_object_type)
|
|
result.set_gramps_id(self._object_frames[self._current_object_type].selected_id)
|
|
return result
|
|
|
|
def on_add(self,button=None):
|
|
self.emit('add-object',self.get_result())
|
|
|
|
def on_selection_changed(self,widget,text,handle):
|
|
if handle:
|
|
self._add_button.set_sensitive(True)
|
|
else:
|
|
self._add_button.set_sensitive(False)
|
|
|
|
|
|
if gtk.pygtk_version < (2,8,0):
|
|
gobject.type_register(ObjectSelectorWindow)
|
|
|
|
if __name__ == "__main__":
|
|
|
|
|
|
import GrampsDb
|
|
import ViewManager
|
|
import const
|
|
|
|
import logging
|
|
import sys,os.path
|
|
|
|
form = logging.Formatter(fmt="%(relativeCreated)d: %(levelname)s: %(filename)s: line %(lineno)d: %(message)s")
|
|
stderrh = logging.StreamHandler(sys.stderr)
|
|
stderrh.setFormatter(form)
|
|
stderrh.setLevel(logging.DEBUG)
|
|
|
|
# everything.
|
|
l = logging.getLogger()
|
|
l.setLevel(logging.DEBUG)
|
|
l.addHandler(stderrh)
|
|
|
|
def cb(d):
|
|
pass
|
|
|
|
state = GrampsDb.DbState()
|
|
vm = ViewManager.ViewManager(state)
|
|
|
|
db = GrampsDb.gramps_db_factory(const.app_gramps)()
|
|
db.load(os.path.realpath(sys.argv[1]),
|
|
cb, # callback
|
|
"w")
|
|
class D:
|
|
pass
|
|
|
|
dbstate = D()
|
|
dbstate.db = db
|
|
|
|
|
|
w = ObjectSelectorWindow(dbstate=dbstate,
|
|
uistate=vm.uistate,
|
|
default_object_type = ObjectTypes.PERSON,
|
|
object_list=[ObjectTypes.PERSON,ObjectTypes.FAMILY])
|
|
w.show()
|
|
w.connect("destroy", gtk.main_quit)
|
|
|
|
def add(w,results):
|
|
print str(results)
|
|
|
|
w.connect('add-object',add)
|
|
|
|
gtk.main()
|