1484 lines
54 KiB
Python
1484 lines
54 KiB
Python
#
|
|
# Gramps - a GTK+/GNOME based genealogy program
|
|
#
|
|
# Copyright (C) 2000-2007 Donald N. Allingham
|
|
#
|
|
# This program is free software; you can redistribute it and/or modiy
|
|
# 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$
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# standard python modules
|
|
#
|
|
#------------------------------------------------------------------------
|
|
import cPickle as pickle
|
|
import os
|
|
from xml.sax.saxutils import escape
|
|
from time import strftime as strftime
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# GTK/Gnome modules
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
import gtk
|
|
from gtk.gdk import ACTION_COPY, BUTTON1_MASK, ACTION_MOVE
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# gramps modules
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
import const
|
|
import config
|
|
import gen.lib
|
|
import DateHandler
|
|
import GrampsDisplay
|
|
import ManagedWindow
|
|
from gen.ggettext import sgettext as _
|
|
from TransUtils import trans_objclass
|
|
from constfunc import mac
|
|
from glade import Glade
|
|
from DdTargets import DdTargets
|
|
from gui.makefilter import make_filter
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Constants
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
WIKI_HELP_PAGE = '%s_-_Navigation' % const.URL_MANUAL_PAGE
|
|
WIKI_HELP_SEC = _('manual|Using_the_Clipboard')
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# icons used in the object listing
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
|
|
_stock_image = os.path.join(const.IMAGE_DIR,'stock_link.png')
|
|
LINK_PIC = gtk.gdk.pixbuf_new_from_file(_stock_image)
|
|
ICONS = {}
|
|
for (name, file) in (
|
|
("media", "gramps-media.png"),
|
|
("note", "gramps-notes.png"),
|
|
("person", "gramps-person.png"),
|
|
("place", "gramps-place.png"),
|
|
('address', 'gramps-address.png'),
|
|
('attribute', 'gramps-attribute.png'),
|
|
('event', 'gramps-event.png'),
|
|
('family', 'gramps-family.png'),
|
|
('location', 'geo-place-link.png'),
|
|
('media', 'gramps-media.png'),
|
|
('name', 'geo-show-person.png'),
|
|
('repository', 'gramps-repository.png'),
|
|
('source', 'gramps-source.png'),
|
|
('text', 'gramps-font.png'),
|
|
('url', 'gramps-geo.png'),
|
|
):
|
|
_image = os.path.join(const.IMAGE_DIR, '16x16', file)
|
|
ICONS[name] = gtk.gdk.pixbuf_new_from_file(_image)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Local functions
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def map2class(target):
|
|
d = {"person-link": ScratchPersonLink,
|
|
"family-link": ScratchFamilyLink,
|
|
'personref': ScratchPersonRef,
|
|
'source-link': ScratchSourceLink,
|
|
'srcref': ScratchSourceRef,
|
|
'repo-link': ScratchRepositoryLink,
|
|
'pevent': ScratchEvent,
|
|
'eventref': ScratchEventRef,
|
|
'mediaobj': ScratchMediaObj,
|
|
'mediaref': ScratchMediaRef,
|
|
'place-link': ScratchPlace,
|
|
'note-link': ScratchNote,
|
|
}
|
|
return d[target] if target in d else None
|
|
|
|
def obj2class(target):
|
|
d= {"Person": ScratchPersonLink,
|
|
"Family": ScratchFamilyLink,
|
|
'Source': ScratchSourceLink,
|
|
'Repository': ScratchRepositoryLink,
|
|
'Event': ScratchEvent,
|
|
'Media': ScratchMediaObj,
|
|
'Place': ScratchPlace,
|
|
'Note': ScratchNote,
|
|
}
|
|
return d[target] if target in d else None
|
|
|
|
def obj2target(target):
|
|
d = {"Person": 'person-link',
|
|
"Family": 'family-link',
|
|
'Source': 'source-link',
|
|
'Repository': 'repo-link',
|
|
'Event': 'pevent',
|
|
'Media': 'mediaobj',
|
|
'Place': 'place-link',
|
|
'Note': 'note-link',
|
|
}
|
|
return d[target] if target in d else None
|
|
|
|
def model_contains(model, data):
|
|
"""
|
|
Returns True if data is a row in model.
|
|
"""
|
|
# check type and value
|
|
# data[0] is type of drop item, data[1] is Scratch object
|
|
for row in model:
|
|
if data[0] == 'TEXT':
|
|
same = ((row[0] == data[0]) and
|
|
(row[1]._value == data[1]._value))
|
|
else:
|
|
# FIXME: too restrictive, birth and death won't both copy
|
|
same = ((row[0] == data[0]) and
|
|
(row[1]._title == data[1]._title) and
|
|
(row[1]._handle == data[1]._handle) and
|
|
(row[3] == data[3]) and
|
|
(row[4] == data[4]))
|
|
if same:
|
|
return True
|
|
return False
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# wrapper classes to provide object specific listing in the ListView
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
class ScratchWrapper(object):
|
|
UNAVAILABLE_ICON = gtk.STOCK_DIALOG_ERROR
|
|
|
|
def __init__(self, dbstate, obj):
|
|
dbstate.connect('database-changed', self.database_changed)
|
|
self.database_changed(dbstate.db)
|
|
self._obj = obj
|
|
self._pickle = obj
|
|
self._type = _("Unknown")
|
|
self._objclass = None
|
|
self._handle = None
|
|
self._title = _('Unavailable')
|
|
self._value = _('Unavailable')
|
|
self._dbid = self._db.get_dbid()
|
|
self._dbname = self._db.get_dbname()
|
|
|
|
def database_changed(self,db):
|
|
self._db = db
|
|
|
|
def get_type(self):
|
|
return self._type
|
|
|
|
def get_title(self):
|
|
return self._title
|
|
|
|
def get_value(self):
|
|
return self._value
|
|
|
|
def get_dbname(self):
|
|
return self._dbname
|
|
|
|
def pack(self):
|
|
if not self.is_valid():
|
|
data = list(pickle.loads(self._pickle))
|
|
data[2] = {
|
|
"_obj": self._obj,
|
|
"_pickle": self._pickle,
|
|
"_type": self._type,
|
|
"_handle": self._handle,
|
|
"_objclass": self._objclass,
|
|
"_title": self._title,
|
|
"_value": self._value,
|
|
"_dbid": self._dbid,
|
|
"_dbname": self._dbname,
|
|
}
|
|
return pickle.dumps(data)
|
|
else:
|
|
return str(self._obj)
|
|
|
|
def is_valid(self):
|
|
return True
|
|
|
|
|
|
class ScratchHandleWrapper(ScratchWrapper):
|
|
|
|
def __init__(self,dbstate, obj):
|
|
super(ScratchHandleWrapper, self).__init__(dbstate, obj)
|
|
#unpack object
|
|
(drag_type, idval, data, val) = pickle.loads(obj)
|
|
if isinstance(data, dict):
|
|
self.set_data(data)
|
|
else:
|
|
self._handle = data
|
|
|
|
def set_data(self, data):
|
|
for item in data:
|
|
setattr(self, item, data[item])
|
|
|
|
class ScratchObjWrapper(ScratchWrapper):
|
|
|
|
def __init__(self,dbstate, obj):
|
|
super(ScratchObjWrapper, self).__init__(dbstate, obj)
|
|
#unpack object
|
|
(drag_type, idval, self._obj, val) = pickle.loads(obj)
|
|
self._pickle = obj
|
|
|
|
def pack(self):
|
|
if not self.is_valid():
|
|
data = list(pickle.loads(self._pickle))
|
|
data[2] = {
|
|
"_obj": self._obj,
|
|
"_pickle": self._pickle,
|
|
"_type": self._type,
|
|
"_handle": self._handle,
|
|
"_objclass": self._objclass,
|
|
"_title": self._title,
|
|
"_value": self._value,
|
|
"_dbid": self._dbid,
|
|
"_dbname": self._dbname,
|
|
}
|
|
return pickle.dumps(data)
|
|
else:
|
|
return self._pickle
|
|
|
|
def is_valid(self):
|
|
if self._obj is None:
|
|
return False
|
|
valid_func_map = {'Person': self._db.get_person_from_handle,
|
|
'Family': self._db.get_family_from_handle,
|
|
'Event': self._db.get_event_from_handle,
|
|
'Place': self._db.get_place_from_handle,
|
|
'MediaObject': self._db.get_object_from_handle,
|
|
'Source': self._db.get_source_from_handle}
|
|
|
|
for (classname, handle) in self._obj.get_referenced_handles_recursively():
|
|
if classname in valid_func_map:
|
|
if not valid_func_map[classname](handle):
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
class ScratchAddress(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.ADDRESS]
|
|
DRAG_TARGET = DdTargets.ADDRESS
|
|
ICON = ICONS['address']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchAddress, self).__init__(dbstate, obj)
|
|
self._type = _("Address")
|
|
if self._obj:
|
|
self._title = DateHandler.get_date(self._obj)
|
|
self._value = "%s %s %s %s" % (self._obj.get_street(),
|
|
self._obj.get_city(),
|
|
self._obj.get_state(),
|
|
self._obj.get_country(),
|
|
)
|
|
|
|
class ScratchLocation(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.LOCATION]
|
|
DRAG_TARGET = DdTargets.LOCATION
|
|
ICON = ICONS['location']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchLocation, self).__init__(dbstate, obj)
|
|
self._type = _("Location")
|
|
self._value = "%s %s %s" % (self._obj.get_city(),
|
|
self._obj.get_state(),
|
|
self._obj.get_country(),
|
|
)
|
|
|
|
class ScratchEvent(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.EVENT]
|
|
DRAG_TARGET = DdTargets.EVENT
|
|
ICON = ICONS["event"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchEvent, self).__init__(dbstate, obj)
|
|
self._type = _("Event")
|
|
self._objclass = 'Event'
|
|
if self._handle:
|
|
value = self._db.get_event_from_handle(self._handle)
|
|
if value:
|
|
self._title = str(value.get_type())
|
|
self._value = value.get_description()
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_event_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
class ScratchPlace(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.PLACE_LINK]
|
|
DRAG_TARGET = DdTargets.PLACE_LINK
|
|
ICON = ICONS["place"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchPlace, self).__init__(dbstate, obj)
|
|
self._type = _("Place")
|
|
self._objclass = 'Place'
|
|
if self._handle:
|
|
value = self._db.get_place_from_handle(self._handle)
|
|
if value:
|
|
self._title = value.gramps_id
|
|
self._value = value.get_title()
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_place_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
class ScratchNote(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.NOTE_LINK]
|
|
DRAG_TARGET = DdTargets.NOTE_LINK
|
|
ICON = ICONS["note"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchNote, self).__init__(dbstate, obj)
|
|
self._type = _("Note")
|
|
self._objclass = 'Note'
|
|
value = self._db.get_note_from_handle(self._handle)
|
|
if value:
|
|
self._title = value.get_gramps_id()
|
|
note = value.get().replace('\n', ' ')
|
|
#String must be unicode for truncation to work for non
|
|
#ascii characters
|
|
note = unicode(note)
|
|
if len(note) > 80:
|
|
self._value = note[:80]+"..."
|
|
else:
|
|
self._value = note
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_note_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
class ScratchFamilyEvent(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.FAMILY_EVENT]
|
|
DRAG_TARGET = DdTargets.FAMILY_EVENT
|
|
ICON = ICONS['family']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchFamilyEvent, self).__init__(dbstate, obj)
|
|
self._type = _("Family Event")
|
|
if self._obj:
|
|
self._title = str(self._obj.get_type())
|
|
self._value = self._obj.get_description()
|
|
|
|
class ScratchUrl(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.URL]
|
|
DRAG_TARGET = DdTargets.URL
|
|
ICON = ICONS['url']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchUrl, self).__init__(dbstate, obj)
|
|
self._type = _("Url")
|
|
if self._obj:
|
|
self._title = self._obj.get_path()
|
|
self._value = self._obj.get_description()
|
|
|
|
class ScratchAttribute(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.ATTRIBUTE]
|
|
DRAG_TARGET = DdTargets.ATTRIBUTE
|
|
ICON = ICONS['attribute']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchAttribute, self).__init__(dbstate, obj)
|
|
self._type = _("Attribute")
|
|
self._title = str(self._obj.get_type())
|
|
self._value = self._obj.get_value()
|
|
|
|
class ScratchFamilyAttribute(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.FAMILY_ATTRIBUTE]
|
|
DRAG_TARGET = DdTargets.FAMILY_ATTRIBUTE
|
|
ICON = ICONS['attribute']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchFamilyAttribute, self).__init__(dbstate, obj)
|
|
self._type = _("Family Attribute")
|
|
if self._obj:
|
|
self._title = str(self._obj.get_type())
|
|
self._value = self._obj.get_value()
|
|
|
|
class ScratchSourceRef(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.SOURCEREF]
|
|
DRAG_TARGET = DdTargets.SOURCEREF
|
|
ICON = LINK_PIC
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchSourceRef, self).__init__(dbstate, obj)
|
|
self._type = _("Source ref")
|
|
if self._obj:
|
|
base = self._db.get_source_from_handle(self._obj.get_reference_handle())
|
|
if base:
|
|
self._title = base.get_title()
|
|
notelist = map(self._db.get_note_from_handle,
|
|
self._obj.get_note_list())
|
|
srctxtlist = [note for note in notelist
|
|
if note.get_type() == gen.lib.NoteType.SOURCE_TEXT]
|
|
page = self._obj.get_page()
|
|
if not page:
|
|
page = _('not available|NA')
|
|
text = ""
|
|
if len(srctxtlist) > 0:
|
|
text = " ".join(srctxtlist[0].get().split())
|
|
#String must be unicode for truncation to work for non
|
|
#ascii characters
|
|
text = unicode(text)
|
|
if len(text) > 60:
|
|
text = text[:60]+"..."
|
|
self._value = _("Volume/Page: %(pag)s -- %(sourcetext)s") % {
|
|
'pag' : page,
|
|
'sourcetext' : text,
|
|
}
|
|
|
|
class ScratchRepoRef(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.REPOREF]
|
|
DRAG_TARGET = DdTargets.REPOREF
|
|
ICON = LINK_PIC
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchRepoRef, self).__init__(dbstate, obj)
|
|
self._type = _("Repository ref")
|
|
if self._obj:
|
|
base = self._db.get_repository_from_handle(self._obj.ref)
|
|
if base:
|
|
self._title = str(base.get_type())
|
|
self._value = base.get_name()
|
|
|
|
class ScratchEventRef(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.EVENTREF]
|
|
DRAG_TARGET = DdTargets.EVENTREF
|
|
ICON = LINK_PIC
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchEventRef, self).__init__(dbstate, obj)
|
|
self._type = _("Event ref")
|
|
if self._obj:
|
|
base = self._db.get_event_from_handle(self._obj.ref)
|
|
if base:
|
|
self._title = base.gramps_id
|
|
self._value = str(base.get_type())
|
|
|
|
class ScratchName(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.NAME]
|
|
DRAG_TARGET = DdTargets.NAME
|
|
ICON = ICONS['name']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchName, self).__init__(dbstate, obj)
|
|
self._type = _("Name")
|
|
if self._obj:
|
|
self._title = str(self._obj.get_type())
|
|
self._value = self._obj.get_name()
|
|
|
|
class ScratchSurname(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.SURNAME]
|
|
DRAG_TARGET = DdTargets.SURNAME
|
|
ICON = ICONS['name']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchSurname, self).__init__(dbstate, obj)
|
|
self._type = _("Surname")
|
|
if self._obj:
|
|
self._title = self._obj.get_surname()
|
|
self._value = self._obj.get_surname()
|
|
|
|
class ScratchText(ScratchWrapper):
|
|
|
|
DROP_TARGETS = DdTargets.all_text()
|
|
DRAG_TARGET = DdTargets.TEXT
|
|
ICON = ICONS['text']
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchText, self).__init__(dbstate, obj)
|
|
self._type = _("Text")
|
|
self._title = _("Text")
|
|
self._value = self._obj
|
|
self._pickle = self._obj
|
|
|
|
class ScratchMediaObj(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.MEDIAOBJ]
|
|
DRAG_TARGET = DdTargets.MEDIAOBJ
|
|
ICON = ICONS["media"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchMediaObj, self).__init__(dbstate, obj)
|
|
self._type = _("Media")
|
|
self._objclass = 'Media'
|
|
if self._handle:
|
|
obj = self._db.get_object_from_handle(self._handle)
|
|
if obj:
|
|
self._title = obj.get_description()
|
|
self._value = obj.get_path()
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_object_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
class ScratchMediaRef(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.MEDIAREF]
|
|
DRAG_TARGET = DdTargets.MEDIAREF
|
|
ICON = LINK_PIC
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchMediaRef, self).__init__(dbstate, obj)
|
|
self._type = _("Media ref")
|
|
if self._obj:
|
|
base = self._db.get_object_from_handle(self._obj.get_reference_handle())
|
|
if base:
|
|
self._title = base.get_description()
|
|
self._value = base.get_path()
|
|
|
|
class ScratchPersonRef(ScratchObjWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.PERSONREF]
|
|
DRAG_TARGET = DdTargets.PERSONREF
|
|
ICON = LINK_PIC
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchPersonRef, self).__init__(dbstate, obj)
|
|
self._type = _("Person ref")
|
|
if self._obj:
|
|
person = self._db.get_person_from_handle(self._obj.get_reference_handle())
|
|
if person:
|
|
self._title = self._obj.get_relation()
|
|
self._value = person.get_primary_name().get_name()
|
|
|
|
class ScratchPersonLink(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.PERSON_LINK]
|
|
DRAG_TARGET = DdTargets.PERSON_LINK
|
|
ICON = ICONS["person"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchPersonLink, self).__init__(dbstate, obj)
|
|
self._type = _("Person")
|
|
self._objclass = 'Person'
|
|
if self._handle:
|
|
person = self._db.get_person_from_handle(self._handle)
|
|
if person:
|
|
self._title = person.gramps_id
|
|
self._value = person.get_primary_name().get_name()
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_person_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
|
|
class ScratchFamilyLink(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.FAMILY_LINK]
|
|
DRAG_TARGET = DdTargets.FAMILY_LINK
|
|
ICON = ICONS["family"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
from Simple import SimpleAccess
|
|
super(ScratchFamilyLink, self).__init__(dbstate, obj)
|
|
self._type = _("Family")
|
|
self._objclass = 'Family'
|
|
if self._handle:
|
|
family = self._db.get_family_from_handle(self._handle)
|
|
if family:
|
|
sa = SimpleAccess(self._db)
|
|
self._title = family.gramps_id
|
|
self._value = sa.describe(family)
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_family_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
class ScratchSourceLink(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.SOURCE_LINK]
|
|
DRAG_TARGET = DdTargets.SOURCE_LINK
|
|
ICON = ICONS["source"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchSourceLink, self).__init__(dbstate, obj)
|
|
self._type = _("Source")
|
|
self._objclass = 'Source'
|
|
if self._handle:
|
|
source = self._db.get_source_from_handle(self._handle)
|
|
if source:
|
|
self._title = source.get_gramps_id()
|
|
self._value = source.get_title()
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_source_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
class ScratchRepositoryLink(ScratchHandleWrapper):
|
|
|
|
DROP_TARGETS = [DdTargets.REPO_LINK]
|
|
DRAG_TARGET = DdTargets.REPO_LINK
|
|
ICON = ICONS["repository"]
|
|
|
|
def __init__(self, dbstate, obj):
|
|
super(ScratchRepositoryLink, self).__init__(dbstate, obj)
|
|
self._type = _("Repository")
|
|
self._objclass = 'Repository'
|
|
if self._handle:
|
|
source = self._db.get_repository_from_handle(self._handle)
|
|
if source:
|
|
self._title = str(source.get_type())
|
|
self._value = source.get_name()
|
|
|
|
def is_valid(self):
|
|
data = pickle.loads(self._obj)
|
|
handle = data[2]
|
|
obj = self._db.get_repository_from_handle(handle)
|
|
if obj:
|
|
return True
|
|
return False
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Wrapper classes to deal with lists of objects
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
|
|
class ScratchDropList(object):
|
|
DROP_TARGETS = [DdTargets.LINK_LIST]
|
|
DRAG_TARGET = None
|
|
|
|
def __init__(self, dbstate, obj_list):
|
|
self._dbstate = dbstate
|
|
# ('link-list', id, (('person-link', handle),
|
|
# ('person-link', handle), ...), 0)
|
|
self._obj_list = pickle.loads(obj_list)
|
|
|
|
def get_objects(self):
|
|
list_type, id, handles, timestamp = self._obj_list
|
|
retval = []
|
|
for (target, handle) in handles:
|
|
_class = map2class(target)
|
|
obj = _class(self._dbstate, pickle.dumps((target, id, handle, timestamp)))
|
|
retval.append(obj)
|
|
return retval
|
|
|
|
class ScratchDropRawList(ScratchDropList):
|
|
DROP_TARGETS = [DdTargets.RAW_LIST]
|
|
DRAG_TARGET = None
|
|
|
|
def __init__(self, dbstate, obj_list):
|
|
self._dbstate = dbstate
|
|
# ('raw-list', id, (ScratchObject, ScratchObject, ...), 0)
|
|
self._obj_list = pickle.loads(obj_list)
|
|
|
|
def get_objects(self):
|
|
retval = []
|
|
for item in self._obj_list:
|
|
if item is None:
|
|
continue
|
|
target = pickle.loads(item)[0]
|
|
_class = map2class(target)
|
|
if _class:
|
|
obj = _class(self._dbstate, item)
|
|
if obj:
|
|
retval.append(obj)
|
|
return retval
|
|
|
|
class ScratchDropHandleList(ScratchDropList):
|
|
DROP_TARGETS = [DdTargets.HANDLE_LIST]
|
|
DRAG_TARGET = None
|
|
|
|
def __init__(self, dbstate, obj_list):
|
|
self._dbstate = dbstate
|
|
# incoming:
|
|
# ('handle-list', id, (('Person', '2763526751235'),
|
|
# ('Source', '3786234743978'), ...), 0)
|
|
self._obj_list = pickle.loads(obj_list)
|
|
|
|
def get_objects(self):
|
|
retval = []
|
|
for (objclass, handle) in self._obj_list:
|
|
_class = obj2class(objclass)
|
|
target = obj2target(objclass)
|
|
# outgoing:
|
|
# (drag_type, idval, self._handle, val) = pickle.loads(self._obj)
|
|
data = (target, id(self), handle, 0)
|
|
obj = _class(self._dbstate, pickle.dumps(data))
|
|
retval.append(obj)
|
|
return retval
|
|
|
|
# FIXME: add family
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# ScratchPadListModel class
|
|
# Now shown as 'Clipboard'
|
|
#-------------------------------------------------------------------------
|
|
class ScratchPadListModel(gtk.ListStore):
|
|
|
|
def __init__(self):
|
|
gtk.ListStore.__init__(self,
|
|
str, # 0: object type
|
|
object, # 1: object
|
|
object, # 2: tooltip callback
|
|
str, # 3: type
|
|
str, # 4: value
|
|
str, # 5: unique database id (dbid)
|
|
str, # 6: db name (may be old)
|
|
)
|
|
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# ScratchPadListView class
|
|
# Now shown as 'Clipboard'
|
|
#-------------------------------------------------------------------------
|
|
class ScratchPadListView(object):
|
|
|
|
LOCAL_DRAG_TARGET = ('MY_TREE_MODEL_ROW', gtk.TARGET_SAME_WIDGET, 0)
|
|
LOCAL_DRAG_TYPE = 'MY_TREE_MODEL_ROW'
|
|
|
|
def __init__(self, dbstate, widget):
|
|
|
|
self._widget = widget
|
|
self.dbstate = dbstate
|
|
self.dbstate.connect('database-changed', self.database_changed)
|
|
self.database_changed(dbstate.db)
|
|
|
|
self._target_type_to_wrapper_class_map = {}
|
|
self._previous_drop_time = 0
|
|
|
|
# Create the tree columns
|
|
self._col1 = gtk.TreeViewColumn(_("Type"))
|
|
self._col1.set_property("resizable", True)
|
|
self._col1.set_sort_column_id(0)
|
|
self._col2 = gtk.TreeViewColumn(_("Title"))
|
|
self._col2.set_property("resizable", True)
|
|
self._col2.set_sort_column_id(3)
|
|
self._col3 = gtk.TreeViewColumn(_("Value"))
|
|
self._col3.set_property("resizable", True)
|
|
self._col3.set_sort_column_id(4)
|
|
self._col4 = gtk.TreeViewColumn(_("Family Tree"))
|
|
self._col4.set_property("resizable", True)
|
|
self._col4.set_sort_column_id(6)
|
|
|
|
# Add columns
|
|
self._widget.append_column(self._col1)
|
|
self._widget.append_column(self._col2)
|
|
self._widget.append_column(self._col3)
|
|
self._widget.append_column(self._col4)
|
|
|
|
# Create cell renders
|
|
self._col1_cellpb = gtk.CellRendererPixbuf()
|
|
self._col1_cell = gtk.CellRendererText()
|
|
self._col2_cell = gtk.CellRendererText()
|
|
self._col3_cell = gtk.CellRendererText()
|
|
self._col4_cell = gtk.CellRendererText()
|
|
|
|
# Add cells to view
|
|
self._col1.pack_start(self._col1_cellpb, False)
|
|
self._col1.pack_start(self._col1_cell, True)
|
|
self._col2.pack_start(self._col2_cell, True)
|
|
self._col3.pack_start(self._col3_cell, True)
|
|
self._col4.pack_start(self._col4_cell, True)
|
|
|
|
# Setup the cell data callback funcs
|
|
self._col1.set_cell_data_func(self._col1_cellpb, self.object_pixbuf)
|
|
self._col1.set_cell_data_func(self._col1_cell, self.object_type)
|
|
self._col2.set_cell_data_func(self._col2_cell, self.object_title)
|
|
self._col3.set_cell_data_func(self._col3_cell, self.object_value)
|
|
self._col4.set_cell_data_func(self._col4_cell, self.get_dbname)
|
|
|
|
# Set the column that inline searching will use.
|
|
self._widget.set_enable_search(True)
|
|
#self._widget.set_search_column(3)
|
|
|
|
self._widget.drag_dest_set(gtk.DEST_DEFAULT_ALL,
|
|
(ScratchPadListView.LOCAL_DRAG_TARGET,) + \
|
|
DdTargets.all_targets(),
|
|
ACTION_COPY)
|
|
|
|
self._widget.connect('drag_data_get', self.object_drag_data_get)
|
|
self._widget.connect('drag_begin', self.object_drag_begin)
|
|
self._widget.connect('drag_data_received',
|
|
self.object_drag_data_received)
|
|
self._widget.connect('drag_end', self.object_drag_end)
|
|
|
|
self.register_wrapper_classes()
|
|
|
|
def database_changed(self,db):
|
|
self._db = db
|
|
# Note: delete event is emitted before the delete, so checking
|
|
# if valid on this is useless !
|
|
db_signals = (
|
|
'person-update',
|
|
'person-rebuild',
|
|
'family-update',
|
|
'family-rebuild',
|
|
'source-update',
|
|
'source-rebuild',
|
|
'place-update',
|
|
'place-rebuild',
|
|
'media-update',
|
|
'media-rebuild',
|
|
'event-update',
|
|
'event-rebuild',
|
|
'repository-update',
|
|
'repository-rebuild',
|
|
'note-rebuild'
|
|
)
|
|
|
|
for signal in db_signals:
|
|
self._db.connect(signal,self.remove_invalid_objects)
|
|
|
|
self._db.connect('person-delete',
|
|
gen_del_obj(self.delete_object, 'person-link'))
|
|
self._db.connect('person-delete',
|
|
gen_del_obj(self.delete_object_ref, 'personref'))
|
|
self._db.connect('source-delete',
|
|
gen_del_obj(self.delete_object, 'source-link'))
|
|
self._db.connect('source-delete',
|
|
gen_del_obj(self.delete_object_ref, 'srcref'))
|
|
self._db.connect('repository-delete',
|
|
gen_del_obj(self.delete_object, 'repo-link'))
|
|
self._db.connect('event-delete',
|
|
gen_del_obj(self.delete_object, 'pevent'))
|
|
self._db.connect('event-delete',
|
|
gen_del_obj(self.delete_object_ref, 'eventref'))
|
|
self._db.connect('media-delete',
|
|
gen_del_obj(self.delete_object, 'mediaobj'))
|
|
self._db.connect('media-delete',
|
|
gen_del_obj(self.delete_object_ref, 'mediaref'))
|
|
self._db.connect('place-delete',
|
|
gen_del_obj(self.delete_object, 'place-link'))
|
|
self._db.connect('note-delete',
|
|
gen_del_obj(self.delete_object, 'note-link'))
|
|
# family-delete not needed, cannot be dragged!
|
|
|
|
self.remove_invalid_objects()
|
|
|
|
def remove_invalid_objects(self,dummy=None):
|
|
model = self._widget.get_model()
|
|
|
|
if model:
|
|
for o in model:
|
|
if not o[1].is_valid():
|
|
model.remove(o.iter)
|
|
|
|
def delete_object(self, handle_list, link_type):
|
|
model = self._widget.get_model()
|
|
|
|
if model:
|
|
for o in model:
|
|
if o[0] == link_type:
|
|
data = pickle.loads(o[1]._obj)
|
|
if data[2] in handle_list:
|
|
model.remove(o.iter)
|
|
|
|
def delete_object_ref(self, handle_list, link_type):
|
|
model = self._widget.get_model()
|
|
|
|
if model:
|
|
for o in model:
|
|
if o[0] == link_type:
|
|
data = o[1]._obj.get_reference_handle()
|
|
if data in handle_list:
|
|
model.remove(o.iter)
|
|
|
|
# Method to manage the wrapper classes.
|
|
|
|
def register_wrapper_classes(self):
|
|
self.register_wrapper_class(ScratchAddress)
|
|
self.register_wrapper_class(ScratchLocation)
|
|
self.register_wrapper_class(ScratchEvent)
|
|
self.register_wrapper_class(ScratchPlace)
|
|
self.register_wrapper_class(ScratchEventRef)
|
|
self.register_wrapper_class(ScratchSourceRef)
|
|
self.register_wrapper_class(ScratchRepoRef)
|
|
self.register_wrapper_class(ScratchFamilyEvent)
|
|
self.register_wrapper_class(ScratchUrl)
|
|
self.register_wrapper_class(ScratchAttribute)
|
|
self.register_wrapper_class(ScratchFamilyAttribute)
|
|
self.register_wrapper_class(ScratchName)
|
|
self.register_wrapper_class(ScratchRepositoryLink)
|
|
self.register_wrapper_class(ScratchMediaObj)
|
|
self.register_wrapper_class(ScratchMediaRef)
|
|
self.register_wrapper_class(ScratchSourceLink)
|
|
self.register_wrapper_class(ScratchPersonLink)
|
|
self.register_wrapper_class(ScratchFamilyLink)
|
|
self.register_wrapper_class(ScratchDropList)
|
|
self.register_wrapper_class(ScratchDropRawList)
|
|
self.register_wrapper_class(ScratchDropHandleList)
|
|
self.register_wrapper_class(ScratchPersonRef)
|
|
self.register_wrapper_class(ScratchText)
|
|
self.register_wrapper_class(ScratchNote)
|
|
|
|
def register_wrapper_class(self,wrapper_class):
|
|
for drop_target in wrapper_class.DROP_TARGETS:
|
|
self._target_type_to_wrapper_class_map[drop_target.drag_type] = wrapper_class
|
|
|
|
# Methods for rendering the cells.
|
|
|
|
def object_pixbuf(self, column, cell, model, node, user_data=None):
|
|
o = model.get_value(node, 1)
|
|
if o._dbid != self.dbstate.db.get_dbid():
|
|
if isinstance(o.__class__.UNAVAILABLE_ICON, basestring):
|
|
cell.set_property('stock-id',
|
|
o.__class__.UNAVAILABLE_ICON)
|
|
else:
|
|
cell.set_property('pixbuf',
|
|
o.__class__.UNAVAILABLE_ICON)
|
|
else:
|
|
cell.set_property('pixbuf', o.__class__.ICON)
|
|
|
|
def object_type(self, column, cell, model, node, user_data=None):
|
|
o = model.get_value(node, 1)
|
|
cell.set_property('text', o.get_type())
|
|
|
|
def object_title(self, column, cell, model, node, user_data=None):
|
|
o = model.get_value(node, 1)
|
|
cell.set_property('text', o.get_title())
|
|
|
|
def object_value(self, column, cell, model, node, user_data=None):
|
|
o = model.get_value(node, 1)
|
|
cell.set_property('text', o.get_value())
|
|
|
|
def get_dbname(self, column, cell, model, node, user_data=None):
|
|
o = model.get_value(node, 1)
|
|
cell.set_property('text', o.get_dbname())
|
|
|
|
|
|
# handlers for the drag and drop events.
|
|
|
|
def on_object_select_row(self, obj):
|
|
tree_selection = self._widget.get_selection()
|
|
model, paths = tree_selection.get_selected_rows()
|
|
if len(paths) > 1:
|
|
targets = [(DdTargets.RAW_LIST.drag_type, gtk.TARGET_SAME_WIDGET, 0),
|
|
ScratchPadListView.LOCAL_DRAG_TARGET]
|
|
else:
|
|
targets = [ScratchPadListView.LOCAL_DRAG_TARGET]
|
|
for path in paths:
|
|
node = model.get_iter(path)
|
|
if node is not None:
|
|
o = model.get_value(node,1)
|
|
targets += [target.target() for target in o.__class__.DROP_TARGETS]
|
|
|
|
self._widget.enable_model_drag_source(BUTTON1_MASK, targets,
|
|
ACTION_COPY | ACTION_MOVE)
|
|
|
|
def object_drag_begin(self, context, a):
|
|
""" Handle the beginning of a drag operation. """
|
|
pass
|
|
|
|
def object_drag_end(self, widget, drag_context):
|
|
""" Handle the end of a drag operation. """
|
|
pass
|
|
|
|
def object_drag_data_get(self, widget, context, sel_data, info, time):
|
|
tree_selection = widget.get_selection()
|
|
model, paths = tree_selection.get_selected_rows()
|
|
if len(paths) == 1:
|
|
path = paths[0]
|
|
node = model.get_iter(path)
|
|
o = model.get_value(node,1)
|
|
sel_data.set(sel_data.target, 8, o.pack())
|
|
elif len(paths) > 1:
|
|
raw_list = []
|
|
for path in paths:
|
|
node = model.get_iter(path)
|
|
o = model.get_value(node,1)
|
|
raw_list.append(o.pack())
|
|
sel_data.set(sel_data.target, 8, pickle.dumps(raw_list))
|
|
return True
|
|
|
|
def object_drag_data_received(self,widget,context,x,y,selection,info,time,
|
|
title=None, value=None, dbid=None,
|
|
dbname=None):
|
|
model = widget.get_model()
|
|
sel_data = selection.data
|
|
# In Windows time is always zero. Until that is fixed, use the seconds
|
|
# of the local time to filter out double drops.
|
|
realTime = strftime("%S")
|
|
|
|
# There is a strange bug that means that if there is a selection
|
|
# in the list we get multiple drops of the same object. Luckily
|
|
# the time values are the same so we can drop all but the first.
|
|
if (realTime == self._previous_drop_time) and (time != -1):
|
|
return None
|
|
|
|
# Find a wrapper class
|
|
possible_wrappers = []
|
|
if mac():
|
|
# context is empty on mac due to a bug, work around this
|
|
# Note that this workaround code works fine in linux too as
|
|
# we know very well inside of GRAMPS what sel_data can be, so
|
|
# we can anticipate on it, instead of letting the wrapper handle
|
|
# it. This is less clean however !
|
|
# See http://www.gramps-project.org/bugs/view.php?id=3089 for
|
|
# an explaination of why this is required.
|
|
dragtype = None
|
|
try:
|
|
dragtype = pickle.loads(sel_data)[0]
|
|
except pickle.UnpicklingError, msg :
|
|
# not a pickled object, probably text
|
|
if isinstance(sel_data, basestring):
|
|
dragtype = DdTargets.TEXT.drag_type
|
|
if dragtype in self._target_type_to_wrapper_class_map:
|
|
possible_wrappers = [dragtype]
|
|
else:
|
|
possible_wrappers = [target for target in context.targets
|
|
if target in self._target_type_to_wrapper_class_map]
|
|
|
|
if len(possible_wrappers) == 0:
|
|
# No wrapper for this class
|
|
return None
|
|
|
|
# Just select the first match.
|
|
wrapper_class = self._target_type_to_wrapper_class_map[
|
|
str(possible_wrappers[0])]
|
|
o = wrapper_class(self.dbstate, sel_data)
|
|
if title:
|
|
o._title = title
|
|
if value:
|
|
o._value = value
|
|
if dbid:
|
|
o._dbid = dbid
|
|
if dbname:
|
|
o._dbname = dbname
|
|
|
|
# If the wrapper object is a subclass of ScratchDropList then
|
|
# the drag data was a list of objects and we need to decode
|
|
# all of them.
|
|
if isinstance(o,ScratchDropList):
|
|
o_list = o.get_objects()
|
|
else:
|
|
o_list = [o]
|
|
for o in o_list:
|
|
if o.__class__.DRAG_TARGET is None:
|
|
continue
|
|
data = [o.__class__.DRAG_TARGET.drag_type, o, None,
|
|
o._type, o._value, o._dbid, o._dbname]
|
|
contains = model_contains(model, data)
|
|
if context.action != ACTION_MOVE and contains:
|
|
continue
|
|
drop_info = widget.get_dest_row_at_pos(x, y)
|
|
if drop_info:
|
|
path, position = drop_info
|
|
node = model.get_iter(path)
|
|
if (position == gtk.TREE_VIEW_DROP_BEFORE
|
|
or position == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE):
|
|
model.insert_before(node, data)
|
|
else:
|
|
model.insert_after(node, data)
|
|
else:
|
|
model.append(data)
|
|
|
|
# FIXME: there is one bug here: if you multi-select and drop
|
|
# on self, then it moves the first, and copies the rest.
|
|
|
|
if context.action == ACTION_MOVE:
|
|
context.finish(True, True, time)
|
|
|
|
# remember time for double drop workaround.
|
|
self._previous_drop_time = realTime
|
|
return o_list
|
|
|
|
# proxy methods to provide access to the real widget functions.
|
|
|
|
def set_model(self,model=None):
|
|
self._widget.set_model(model)
|
|
self._widget.get_selection().connect('changed',self.on_object_select_row)
|
|
self._widget.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
|
|
|
|
def get_model(self):
|
|
return self._widget.get_model()
|
|
|
|
def get_selection(self):
|
|
return self._widget.get_selection()
|
|
|
|
def set_search_column(self,col):
|
|
return self._widget.set_search_column(col)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# ScatchPadWindow class
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
class ScratchPadWindow(ManagedWindow.ManagedWindow):
|
|
"""
|
|
The Clipboard (was ScratchPad) provides a temporary area to hold objects
|
|
that can
|
|
be reused accross multiple Person records. The pad provides a window
|
|
onto which objects can be dropped and then dragged into new Person
|
|
dialogs. The objects are stored as the pickles that are built by the
|
|
origininating widget. The objects are only unpickled in order to
|
|
provide the text in the display.
|
|
|
|
No attempt is made to ensure that any references contained within
|
|
the pickles are valid. Because the pad extends the life time of drag
|
|
and drop objects, it is possible that references that were valid
|
|
when an object is copied to the pad are invalid by the time they
|
|
are dragged to a new Person. For this reason, using the pad places
|
|
a responsibility on all '_drag_data_received' methods to check the
|
|
references of objects before attempting to use them.
|
|
"""
|
|
|
|
# Class attribute used to hold the content of the
|
|
# Clipboard (was ScratchPad). A class attribute is used so that the content
|
|
# it preserved even when the Clipboard window is closed.
|
|
# As there is only ever one Clipboard we do not need to
|
|
# maintain a list of these.
|
|
otree = None
|
|
|
|
def __init__(self, dbstate, uistate):
|
|
"""Initialize the ScratchPad class, and displays the window"""
|
|
|
|
ManagedWindow.ManagedWindow.__init__(self,uistate,[],self.__class__)
|
|
self.dbstate = dbstate
|
|
|
|
self.database_changed(self.dbstate.db)
|
|
self.dbstate.connect('database-changed', self.database_changed)
|
|
|
|
self.width_key = 'interface.clipboard-width'
|
|
self.height_key = 'interface.clipboard-height'
|
|
|
|
self.top = Glade()
|
|
self.set_window(self.top.toplevel, None, None, msg=_("Clipboard"))
|
|
self._set_size()
|
|
|
|
self.clear_all_btn = self.top.get_object("btn_clear_all")
|
|
self.clear_btn = self.top.get_object("btn_clear")
|
|
objectlist = self.top.get_object('objectlist')
|
|
mtv = MultiTreeView(self.dbstate, self.uistate, _("Clipboard"))
|
|
scrolledwindow = self.top.get_object('scrolledwindow86')
|
|
scrolledwindow.remove(objectlist)
|
|
scrolledwindow.add_with_viewport(mtv)
|
|
self.object_list = ScratchPadListView(self.dbstate, mtv)
|
|
self.object_list.get_selection().connect('changed',
|
|
self.set_clear_btn_sensitivity)
|
|
self.object_list.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
|
|
self.set_clear_btn_sensitivity(sel=self.object_list.get_selection())
|
|
|
|
if not ScratchPadWindow.otree:
|
|
ScratchPadWindow.otree = ScratchPadListModel()
|
|
|
|
self.set_clear_all_btn_sensitivity(treemodel=ScratchPadWindow.otree)
|
|
ScratchPadWindow.otree.connect('row-deleted',
|
|
self.set_clear_all_btn_sensitivity)
|
|
ScratchPadWindow.otree.connect('row-inserted',
|
|
self.set_clear_all_btn_sensitivity)
|
|
|
|
|
|
self.object_list.set_model(ScratchPadWindow.otree)
|
|
|
|
#Database might have changed, objects might have been removed,
|
|
#we need to reevaluate if all data is valid
|
|
self.object_list.remove_invalid_objects()
|
|
|
|
self.top.connect_signals({
|
|
"on_close_scratchpad" : self.close,
|
|
"on_clear_clicked": self.on_clear_clicked,
|
|
"on_help_clicked": self.on_help_clicked,
|
|
})
|
|
|
|
self.clear_all_btn.connect_object('clicked', gtk.ListStore.clear,
|
|
ScratchPadWindow.otree)
|
|
self.db.connect('database-changed', lambda x: ScratchPadWindow.otree.clear())
|
|
|
|
self.show()
|
|
|
|
def build_menu_names(self, obj):
|
|
return (_('Clipboard'),None)
|
|
|
|
def database_changed(self,database):
|
|
self.db = database
|
|
|
|
def set_clear_all_btn_sensitivity(self, treemodel=None,
|
|
path=None, node=None, user_param1=None):
|
|
if len(treemodel) == 0:
|
|
self.clear_all_btn.set_sensitive(False)
|
|
else:
|
|
self.clear_all_btn.set_sensitive(True)
|
|
|
|
def set_clear_btn_sensitivity(self, sel=None, user_param1=None):
|
|
if sel.count_selected_rows() == 0:
|
|
self.clear_btn.set_sensitive(False)
|
|
else:
|
|
self.clear_btn.set_sensitive(True)
|
|
|
|
def on_help_clicked(self, obj):
|
|
"""Display the relevant portion of GRAMPS manual"""
|
|
GrampsDisplay.help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC)
|
|
|
|
def on_clear_clicked(self, obj):
|
|
"""Deletes the selected object from the object list"""
|
|
selection = self.object_list.get_selection()
|
|
model, paths = selection.get_selected_rows()
|
|
for path in paths:
|
|
node = model.get_iter(path)
|
|
if node:
|
|
model.remove(node)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# MultiTreeView class
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
class MultiTreeView(gtk.TreeView):
|
|
'''
|
|
TreeView that captures mouse events to make drag and drop work properly
|
|
'''
|
|
def __init__(self, dbstate, uistate, title=None):
|
|
self.dbstate = dbstate
|
|
self.uistate = uistate
|
|
self.title = title if title else _("Clipboard")
|
|
super(MultiTreeView, self).__init__()
|
|
self.connect('button_press_event', self.on_button_press)
|
|
self.connect('button_release_event', self.on_button_release)
|
|
self.connect('key_press_event', self.key_press_event)
|
|
self.defer_select = False
|
|
|
|
def key_press_event(self, widget, event):
|
|
if event.type == gtk.gdk.KEY_PRESS:
|
|
if event.keyval == gtk.keysyms.Delete:
|
|
model, paths = self.get_selection().get_selected_rows()
|
|
# reverse, to delete from the end
|
|
paths.sort(key=lambda x:-x[0])
|
|
for path in paths:
|
|
try:
|
|
node = model.get_iter(path)
|
|
except:
|
|
node = None
|
|
if node:
|
|
model.remove(node)
|
|
return True
|
|
|
|
def on_button_press(self, widget, event):
|
|
# Here we intercept mouse clicks on selected items so that we can
|
|
# drag multiple items without the click selecting only one
|
|
target = self.get_path_at_pos(int(event.x), int(event.y))
|
|
if event.button == 3: # right mouse
|
|
selection = widget.get_selection()
|
|
store, paths = selection.get_selected_rows()
|
|
tpath = paths[0] if len(paths) > 0 else None
|
|
node = store.get_iter(tpath) if tpath else None
|
|
o = None
|
|
if node:
|
|
o = store.get_value(node, 1)
|
|
popup = gtk.Menu()
|
|
# ---------------------------
|
|
if o:
|
|
objclass, handle = o._objclass, o._handle
|
|
else:
|
|
objclass, handle = None, None
|
|
if objclass in ['Person', 'Event', 'Media', 'Source',
|
|
'Repository', 'Family', 'Note', 'Place']:
|
|
menu_item = gtk.MenuItem(_("the object|See %s details") % trans_objclass(objclass))
|
|
menu_item.connect("activate",
|
|
lambda widget: self.edit_obj(objclass, handle))
|
|
popup.append(menu_item)
|
|
menu_item.show()
|
|
# ---------------------------
|
|
menu_item = gtk.MenuItem(_("the object|Make %s active") % trans_objclass(objclass))
|
|
menu_item.connect("activate",
|
|
lambda widget: self.uistate.set_active(handle, objclass))
|
|
popup.append(menu_item)
|
|
menu_item.show()
|
|
# ---------------------------
|
|
gids = set()
|
|
for path in paths:
|
|
node = store.get_iter(path)
|
|
if node:
|
|
o = store.get_value(node, 1)
|
|
if o._objclass == objclass:
|
|
my_handle = o._handle
|
|
obj = self.dbstate.db.get_table_metadata(objclass)["handle_func"](my_handle)
|
|
if obj:
|
|
gids.add(obj.gramps_id)
|
|
menu_item = gtk.MenuItem(_("the object|Create Filter from %s selected...") % trans_objclass(objclass))
|
|
menu_item.connect("activate",
|
|
lambda widget: make_filter(self.dbstate, self.uistate,
|
|
objclass, gids, title=self.title))
|
|
popup.append(menu_item)
|
|
menu_item.show()
|
|
# Show the popup menu:
|
|
popup.popup(None, None, None, 3, event.time)
|
|
return True
|
|
elif event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
|
|
model, paths = self.get_selection().get_selected_rows()
|
|
for path in paths:
|
|
node = model.get_iter(path)
|
|
if node is not None:
|
|
o = model.get_value(node,1)
|
|
objclass = o._objclass
|
|
handle = o._handle
|
|
self.edit_obj(objclass, handle)
|
|
return True
|
|
# otherwise:
|
|
if (target
|
|
and event.type == gtk.gdk.BUTTON_PRESS
|
|
and not (event.state & (gtk.gdk.CONTROL_MASK|gtk.gdk.SHIFT_MASK))
|
|
and self.get_selection().path_is_selected(target[0])):
|
|
# disable selection
|
|
self.get_selection().set_select_function(lambda *ignore: False)
|
|
self.defer_select = target[0]
|
|
|
|
def on_button_release(self, widget, event):
|
|
# re-enable selection
|
|
self.get_selection().set_select_function(lambda *ignore: True)
|
|
|
|
target = self.get_path_at_pos(int(event.x), int(event.y))
|
|
if (self.defer_select and target
|
|
and self.defer_select == target[0]
|
|
and not (event.x==0 and event.y==0)): # certain drag and drop
|
|
self.set_cursor(target[0], target[1], False)
|
|
|
|
self.defer_select=False
|
|
|
|
def edit_obj(self, objclass, handle):
|
|
from gui.editors import (EditPerson, EditEvent, EditFamily, EditSource,
|
|
EditPlace, EditRepository, EditNote, EditMedia)
|
|
if objclass == 'Person':
|
|
person = self.dbstate.db.get_person_from_handle(handle)
|
|
if person:
|
|
try:
|
|
EditPerson(self.dbstate,
|
|
self.uistate, [], person)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
elif objclass == 'Event':
|
|
event = self.dbstate.db.get_event_from_handle(handle)
|
|
if event:
|
|
try:
|
|
EditEvent(self.dbstate,
|
|
self.uistate, [], event)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
elif objclass == 'Family':
|
|
ref = self.dbstate.db.get_family_from_handle(handle)
|
|
if ref:
|
|
try:
|
|
EditFamily(self.dbstate,
|
|
self.uistate, [], ref)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
elif objclass == 'Source':
|
|
ref = self.dbstate.db.get_source_from_handle(handle)
|
|
if ref:
|
|
try:
|
|
EditSource(self.dbstate,
|
|
self.uistate, [], ref)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
elif objclass == 'Place':
|
|
ref = self.dbstate.db.get_place_from_handle(handle)
|
|
if ref:
|
|
try:
|
|
EditPlace(self.dbstate,
|
|
self.uistate, [], ref)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
elif objclass == 'Repository':
|
|
ref = self.dbstate.db.get_repository_from_handle(handle)
|
|
if ref:
|
|
try:
|
|
EditRepository(self.dbstate,
|
|
self.uistate, [], ref)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
elif objclass == 'Note':
|
|
ref = self.dbstate.db.get_note_from_handle(handle)
|
|
if ref:
|
|
try:
|
|
EditNote(self.dbstate,
|
|
self.uistate, [], ref)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
elif objclass in ['Media', 'MediaObject']:
|
|
ref = self.dbstate.db.get_object_from_handle(handle)
|
|
if ref:
|
|
try:
|
|
EditMedia(self.dbstate,
|
|
self.uistate, [], ref)
|
|
except Errors.WindowActiveError:
|
|
pass
|
|
|
|
def short(val,size=60):
|
|
if len(val) > size:
|
|
return "%s..." % val[0:size]
|
|
else:
|
|
return val
|
|
|
|
def place_title(db,event):
|
|
pid = event.get_place_handle()
|
|
if pid:
|
|
return db.get_place_from_handle(pid).get_title()
|
|
else:
|
|
return u''
|
|
|
|
def gen_del_obj(func, t):
|
|
return lambda l : func(l, t)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
#
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
def ScratchPad(database,person,callback,parent=None):
|
|
ScratchPadWindow(database,parent)
|