beckermj/gramps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* src/AddrEdit.py: remove already_exist check in favor of exception

Browse Source 
* src/AttrEdit.py: remove already_exist check in favor of exception
* src/DisplayState.py: remove already_exist variable
* src/DisplayTabs.py: handle exception
* src/EditEventRef.py: remove already_exist check in favor of exception
* src/EditFamily.py: update to derive from EditPrimary
* src/EditMedia.py: update to derive from EditPrimary
* src/EditMediaRef.py: remove already_exist check in favor of exception
* src/EditPerson.py: update to derive from EditPrimary
* src/EditPlace.py: update to derive from EditPrimary
* src/EditRepository.py:update to derive from EditPrimary
* src/EditSource.py: update to derive from EditPrimary
* src/EditSourceRef.py: remove already_exist check in favor of exception
* src/Errors.py: new exception
* src/EventEdit.py: update to derive from EditPrimary
* src/EventView.py: catch exception of window already exists
* src/FamilyList.py: catch exception of window already exists
* src/FamilyView.py: catch exception of window already exists
* src/GrampsWidgets.py: typos
* src/NameEdit.py: remove already_exist check in favor of exception
* src/PedView.py: catch exception of window already exists
* src/PersonView.py: catch exception of window already exists
* src/PlaceView.py: catch exception of window already exists
* src/Plugins.py: catch exception of window already exists
* src/UrlEdit.py: remove already_exist check in favor of exception
* src/const.py.in: dynamically determine path
* src/gramps.glade: name changes
* src/gramps.py: set path


svn: r6014
This commit is contained in:
Don Allingham 2006-03-01 05:08:11 +00:00
parent 3ec34df9c5
commit 26092c071a
32 changed files with 933 additions and 1326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
ChangeLog
View File

@ -1,3 +1,33 @@
2006-02-28 Don Allingham <don@gramps-project.org>
* src/AddrEdit.py: remove already_exist check in favor of exception
* src/AttrEdit.py: remove already_exist check in favor of exception
* src/DisplayState.py: remove already_exist variable
* src/DisplayTabs.py: handle exception
* src/EditEventRef.py: remove already_exist check in favor of exception
* src/EditFamily.py: update to derive from EditPrimary
* src/EditMedia.py: update to derive from EditPrimary
* src/EditMediaRef.py: remove already_exist check in favor of exception
* src/EditPerson.py: update to derive from EditPrimary
* src/EditPlace.py: update to derive from EditPrimary
* src/EditRepository.py:update to derive from EditPrimary
* src/EditSource.py: update to derive from EditPrimary
* src/EditSourceRef.py: remove already_exist check in favor of exception
* src/Errors.py: new exception
* src/EventEdit.py: update to derive from EditPrimary
* src/EventView.py: catch exception of window already exists
* src/FamilyList.py: catch exception of window already exists
* src/FamilyView.py: catch exception of window already exists
* src/GrampsWidgets.py: typos
* src/NameEdit.py: remove already_exist check in favor of exception
* src/PedView.py: catch exception of window already exists
* src/PersonView.py: catch exception of window already exists
* src/PlaceView.py: catch exception of window already exists
* src/Plugins.py: catch exception of window already exists
* src/UrlEdit.py: remove already_exist check in favor of exception
* src/const.py.in: dynamically determine path
* src/gramps.glade: name changes
* src/gramps.py: set path
2006-02-28 Alex Roitman <shura@gramps-project.org> 2006-02-28 Alex Roitman <shura@gramps-project.org>
* src/plugins/WritePkg.py (PackageWriter.export): Add existing * src/plugins/WritePkg.py (PackageWriter.export): Add existing
image filenames to the archive. image filenames to the archive.

6
src/AddrEdit.py
View File

@ -48,11 +48,7 @@ import GrampsDisplay
import const import const
import Utils import Utils
import RelLib import RelLib
import Sources
import DateEdit
import DateHandler
import DisplayState import DisplayState
import Spell
from DisplayTabs import * from DisplayTabs import *
from GrampsWidgets import * from GrampsWidgets import *
@ -81,8 +77,6 @@ class AddressEditor(DisplayState.ManagedWindow):
self.addr = addr self.addr = addr
DisplayState.ManagedWindow.__init__(self, uistate, track, addr) DisplayState.ManagedWindow.__init__(self, uistate, track, addr)
if self.already_exist:
return
if not self.addr: if not self.addr:
self.addr = RelLib.Address() self.addr = RelLib.Address()

2
src/AttrEdit.py
View File

@ -85,8 +85,6 @@ class AttributeEditor(DisplayState.ManagedWindow):
self.alist = data_list self.alist = data_list
DisplayState.ManagedWindow.__init__(self, uistate, track, attrib) DisplayState.ManagedWindow.__init__(self, uistate, track, attrib)
if self.already_exist:
return
if not attrib: if not attrib:
self.attrib = RelLib.Attribute() self.attrib = RelLib.Attribute()

4
src/DateEdit.py
View File

@ -100,10 +100,6 @@ class DateEdit:
"""Class that associates a pixmap with a text widget, providing visual """Class that associates a pixmap with a text widget, providing visual
feedback that indicates if the text widget contains a valid date""" feedback that indicates if the text widget contains a valid date"""
good = gtk.gdk.pixbuf_new_from_file(const.good_xpm)
bad = gtk.gdk.pixbuf_new_from_file(const.bad_xpm)
caution = gtk.gdk.pixbuf_new_from_file(const.caution_xpm)
def __init__(self,date_obj,text_obj,button_obj,parent_window=None): def __init__(self,date_obj,text_obj,button_obj,parent_window=None):
""" """
Creates a connection between the date_obj, text_obj and the pixmap_obj. Creates a connection between the date_obj, text_obj and the pixmap_obj.

7
src/DisplayState.py
View File

@ -45,6 +45,7 @@ import GrampsKeys
import NameDisplay import NameDisplay
import GrampsMime import GrampsMime
import const import const
import Errors
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
@ -453,9 +454,6 @@ class ManagedWindow:
window_id, window_id,
submenu_label, submenu_label,
menu_label) menu_label)
if self.already_exist:
return
# Proceed with the class. # Proceed with the class.
... ...
@ -466,9 +464,8 @@ class ManagedWindow:
if uistate.gwm.get_item_from_id(window_key): if uistate.gwm.get_item_from_id(window_key):
uistate.gwm.get_item_from_id(window_key).present() uistate.gwm.get_item_from_id(window_key).present()
self.already_exist = True raise Errors.WindowActiveError('This window is already active')
else: else:
self.already_exist = False
self.window_id = window_key self.window_id = window_key
self.submenu_label = submenu_label self.submenu_label = submenu_label
self.menu_label = menu_label self.menu_label = menu_label

140
src/DisplayTabs.py
View File

@ -54,6 +54,7 @@ import RelLib
import Utils import Utils
import ImgManip import ImgManip
import Spell import Spell
import Errors
from DdTargets import DdTargets from DdTargets import DdTargets
from GrampsWidgets import SimpleButton from GrampsWidgets import SimpleButton
@ -593,8 +594,11 @@ class EventEmbedList(EmbeddedList):
def add_button_clicked(self,obj): def add_button_clicked(self,obj):
from EditEventRef import EditEventRef from EditEventRef import EditEventRef
EditEventRef(self.dbstate,self.uistate,self.track, try:
None, None, self.obj, self.event_added) EditEventRef(self.dbstate,self.uistate,self.track,
None, None, self.obj, self.event_added)
except Errors.WindowActiveError:
pass
def share_button_clicked(self,obj): def share_button_clicked(self,obj):
from EditEventRef import EditEventRef from EditEventRef import EditEventRef
@ -602,16 +606,22 @@ class EventEmbedList(EmbeddedList):
sel = SelectEvent.SelectEvent(self.dbstate.db,"Event Select") sel = SelectEvent.SelectEvent(self.dbstate.db,"Event Select")
event = sel.run() event = sel.run()
EditEventRef(self.dbstate,self.uistate,self.track, try:
event, None, self.obj, self.event_added) EditEventRef(self.dbstate,self.uistate,self.track,
event, None, self.obj, self.event_added)
except Errors.WindowActiveError:
pass
def edit_button_clicked(self,obj): def edit_button_clicked(self,obj):
ref = self.get_selected() ref = self.get_selected()
if ref: if ref:
from EditEventRef import EditEventRef from EditEventRef import EditEventRef
event = self.dbstate.db.get_event_from_handle(ref.ref) event = self.dbstate.db.get_event_from_handle(ref.ref)
EditEventRef(self.dbstate,self.uistate,self.track, try:
event, ref, self.obj, self.event_updated) EditEventRef(self.dbstate,self.uistate,self.track,
event, ref, self.obj, self.event_updated)
except Errors.WindowActiveError:
pass
def event_updated(self,value): def event_updated(self,value):
self.changed = True self.changed = True
@ -814,9 +824,12 @@ class AttrEmbedList(EmbeddedList):
import AttrEdit import AttrEdit
pname = '' pname = ''
attr_list = [] attr_list = []
AttrEdit.AttributeEditor( try:
self.dbstate, self.uistate, self.track, None, AttrEdit.AttributeEditor(
pname, attr_list, self.add_callback) self.dbstate, self.uistate, self.track, None,
pname, attr_list, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,name): def add_callback(self,name):
self.get_data().append(name) self.get_data().append(name)
@ -829,9 +842,12 @@ class AttrEmbedList(EmbeddedList):
import AttrEdit import AttrEdit
pname = '' pname = ''
attr_list = [] attr_list = []
AttrEdit.AttributeEditor( try:
self.dbstate, self.uistate, self.track, attr, AttrEdit.AttributeEditor(
pname, attr_list, self.edit_callback) self.dbstate, self.uistate, self.track, attr,
pname, attr_list, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self,name): def edit_callback(self,name):
self.changed = True self.changed = True
@ -867,8 +883,11 @@ class WebEmbedList(EmbeddedList):
def add_button_clicked(self,obj): def add_button_clicked(self,obj):
import UrlEdit import UrlEdit
url = RelLib.Url() url = RelLib.Url()
UrlEdit.UrlEditor(self.dbstate, self.uistate, self.track, try:
'', url, self.add_callback) UrlEdit.UrlEditor(self.dbstate, self.uistate, self.track,
'', url, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,url): def add_callback(self,url):
self.get_data().append(url) self.get_data().append(url)
@ -878,8 +897,11 @@ class WebEmbedList(EmbeddedList):
url = self.get_selected() url = self.get_selected()
if url: if url:
import UrlEdit import UrlEdit
UrlEdit.UrlEditor(self.dbstate, self.uistate, self.track, try:
'', url, self.edit_callback) UrlEdit.UrlEditor(self.dbstate, self.uistate, self.track,
'', url, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self,url): def edit_callback(self,url):
self.rebuild() self.rebuild()
@ -913,8 +935,11 @@ class NameEmbedList(EmbeddedList):
def add_button_clicked(self,obj): def add_button_clicked(self,obj):
import NameEdit import NameEdit
name = RelLib.Name() name = RelLib.Name()
NameEdit.NameEditor(self.dbstate, self.uistate, self.track, try:
name, self.add_callback) NameEdit.NameEditor(self.dbstate, self.uistate, self.track,
name, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,name): def add_callback(self,name):
self.get_data().append(name) self.get_data().append(name)
@ -924,8 +949,11 @@ class NameEmbedList(EmbeddedList):
name = self.get_selected() name = self.get_selected()
if name: if name:
import NameEdit import NameEdit
NameEdit.NameEditor(self.dbstate, self.uistate, self.track, try:
name, self.edit_callback) NameEdit.NameEditor(self.dbstate, self.uistate, self.track,
name, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self,name): def edit_callback(self,name):
self.rebuild() self.rebuild()
@ -962,8 +990,11 @@ class AddrEmbedList(EmbeddedList):
def add_button_clicked(self,obj): def add_button_clicked(self,obj):
import AddrEdit import AddrEdit
addr = RelLib.Address() addr = RelLib.Address()
AddrEdit.AddressEditor(self.dbstate, self.uistate, self.track, try:
addr, self.add_callback) AddrEdit.AddressEditor(self.dbstate, self.uistate, self.track,
addr, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,name): def add_callback(self,name):
self.get_data().append(name) self.get_data().append(name)
@ -973,8 +1004,11 @@ class AddrEmbedList(EmbeddedList):
addr = self.get_selected() addr = self.get_selected()
if addr: if addr:
import AddrEdit import AddrEdit
AddrEdit.AddressEditor(self.dbstate, self.uistate, self.track, try:
addr, self.edit_callback) AddrEdit.AddressEditor(self.dbstate, self.uistate, self.track,
addr, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self,name): def edit_callback(self,name):
self.rebuild() self.rebuild()
@ -1011,8 +1045,11 @@ class LocationEmbedList(EmbeddedList):
def add_button_clicked(self,obj): def add_button_clicked(self,obj):
import LocEdit import LocEdit
loc = RelLib.Location() loc = RelLib.Location()
LocEdit.LocationEditor(self.dbstate, self.uistate, self.track, try:
loc, self.add_callback) LocEdit.LocationEditor(self.dbstate, self.uistate, self.track,
loc, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,name): def add_callback(self,name):
self.get_data().append(name) self.get_data().append(name)
@ -1022,8 +1059,11 @@ class LocationEmbedList(EmbeddedList):
loc = self.get_selected() loc = self.get_selected()
if loc: if loc:
import LocEdit import LocEdit
LocEdit.LocationEditor(self.dbstate, self.uistate, self.track, try:
loc, self.edit_callback) LocEdit.LocationEditor(self.dbstate, self.uistate, self.track,
loc, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self,name): def edit_callback(self,name):
self.rebuild() self.rebuild()
@ -1213,8 +1253,11 @@ class GalleryTab(ButtonTab):
sref = RelLib.MediaRef() sref = RelLib.MediaRef()
src = RelLib.MediaObject() src = RelLib.MediaObject()
EditMediaRef(self.dbstate, self.uistate, self.track, try:
src, sref, self.add_callback) EditMediaRef(self.dbstate, self.uistate, self.track,
src, sref, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,name): def add_callback(self,name):
self.get_data().append(name) self.get_data().append(name)
@ -1233,8 +1276,11 @@ class GalleryTab(ButtonTab):
from EditMediaRef import EditMediaRef from EditMediaRef import EditMediaRef
obj = self.dbstate.db.get_object_from_handle(ref.get_reference_handle()) obj = self.dbstate.db.get_object_from_handle(ref.get_reference_handle())
EditMediaRef(self.dbstate, self.uistate, self.track, try:
obj, ref, self.edit_callback) EditMediaRef(self.dbstate, self.uistate, self.track,
obj, ref, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self, name): def edit_callback(self, name):
self.changed = True self.changed = True
@ -1276,8 +1322,11 @@ class SourceEmbedList(EmbeddedList):
sref = RelLib.SourceRef() sref = RelLib.SourceRef()
src = RelLib.Source() src = RelLib.Source()
EditSourceRef(self.dbstate, self.uistate, self.track, try:
src, sref, self.add_callback) EditSourceRef(self.dbstate, self.uistate, self.track,
src, sref, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,obj): def add_callback(self,obj):
self.get_data().append(obj) self.get_data().append(obj)
@ -1290,8 +1339,11 @@ class SourceEmbedList(EmbeddedList):
sref = self.get_selected() sref = self.get_selected()
src = self.dbstate.db.get_source_from_handle(sref.ref) src = self.dbstate.db.get_source_from_handle(sref.ref)
if sref: if sref:
EditSourceRef(self.dbstate, self.uistate, self.track, try:
src, sref, self.edit_callback) EditSourceRef(self.dbstate, self.uistate, self.track,
src, sref, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self,name): def edit_callback(self,name):
self.changed = True self.changed = True
@ -1333,8 +1385,11 @@ class RepoEmbedList(EmbeddedList):
ref = RelLib.RepoRef() ref = RelLib.RepoRef()
repo = RelLib.Repository() repo = RelLib.Repository()
EditRepositoryRef( try:
self.dbstate, self.uistate, self.track, repo, ref, self.add_callback) EditRepositoryRef(
self.dbstate, self.uistate, self.track, repo, ref, self.add_callback)
except Errors.WindowActiveError:
pass
def add_callback(self,value): def add_callback(self,value):
value[0].ref = value[1].handle value[0].ref = value[1].handle
@ -1348,9 +1403,12 @@ class RepoEmbedList(EmbeddedList):
ref = self.get_selected() ref = self.get_selected()
if ref: if ref:
repo = self.dbstate.db.get_repository_from_handle(ref.ref) repo = self.dbstate.db.get_repository_from_handle(ref.ref)
EditRepositoryRef.EditRepositoryRef( try:
self.dbstate, self.uistate, self.track, repo, EditRepositoryRef.EditRepositoryRef(
ref, self.edit_callback) self.dbstate, self.uistate, self.track, repo,
ref, self.edit_callback)
except Errors.WindowActiveError:
pass
def edit_callback(self,name): def edit_callback(self,name):
self.changed = True self.changed = True

12
src/EditEventRef.py
View File

@ -50,12 +50,9 @@ import const
import Utils import Utils
import AutoComp import AutoComp
import RelLib import RelLib
from DateHandler import displayer as _dd
import DateEdit
import DisplayState import DisplayState
from QuestionDialog import WarningDialog, ErrorDialog from QuestionDialog import WarningDialog, ErrorDialog
from WindowUtils import GladeIf
from DisplayTabs import * from DisplayTabs import *
from GrampsWidgets import * from GrampsWidgets import *
@ -84,8 +81,6 @@ class EditEventRef(DisplayState.ManagedWindow):
self.event = event self.event = event
DisplayState.ManagedWindow.__init__(self, uistate, track, event_ref) DisplayState.ManagedWindow.__init__(self, uistate, track, event_ref)
if self.already_exist:
return
self.update = update self.update = update
@ -187,11 +182,12 @@ class EditEventRef(DisplayState.ManagedWindow):
dict(total_events), dict(total_events),
RelLib.Event.CUSTOM) RelLib.Event.CUSTOM)
self.date_check = DateEdit.DateEdit( self.date_check = MonitoredDate(
self.event.get_date_object(),
self.top.get_widget("eer_date"), self.top.get_widget("eer_date"),
self.top.get_widget("eer_date_stat"), self.top.get_widget("eer_date_stat"),
self.window) self.event.get_date_object(),
self.window,
self.db.readonly)
def _connect_signals(self): def _connect_signals(self):
self.top.get_widget('ok').connect('clicked',self.ok_clicked) self.top.get_widget('ok').connect('clicked',self.ok_clicked)

266
src/EditFamily.py
View File

@ -26,8 +26,6 @@
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import cPickle as pickle import cPickle as pickle
import os
import sys
from gettext import gettext as _ from gettext import gettext as _
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -66,16 +64,14 @@ import gtk.glade
import const import const
import Utils import Utils
import NameDisplay import NameDisplay
import DisplayState import EditPrimary
import Spell import Spell
import GrampsDisplay import GrampsDisplay
import RelLib import RelLib
import ReportUtils import ReportUtils
import AutoComp import AutoComp
import GrampsWidgets
from DdTargets import DdTargets from DdTargets import DdTargets
from WindowUtils import GladeIf
from DisplayTabs import * from DisplayTabs import *
from GrampsWidgets import * from GrampsWidgets import *
from ObjectSelector import PersonSelector,PersonFilterSpec from ObjectSelector import PersonSelector,PersonFilterSpec
@ -204,40 +200,35 @@ class ChildEmbedList(EmbeddedList):
handle = self.get_selected() handle = self.get_selected()
if handle: if handle:
import EditPerson import EditPerson
person = self.dbstate.db.get_person_from_handle(handle) try:
EditPerson.EditPerson(self.dbstate,self.uistate,self.track,person) person = self.dbstate.db.get_person_from_handle(handle)
EditPerson.EditPerson(self.dbstate,self.uistate,self.track,person)
except Errors.WindowActiveError:
pass
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# EditFamily # EditFamily
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class EditFamily(DisplayState.ManagedWindow): class EditFamily(EditPrimary.EditPrimary):
def __init__(self,dbstate,uistate,track,family): def __init__(self,dbstate,uistate,track,family):
self.dbstate = dbstate EditPrimary.EditPrimary.__init__(self, dbstate, uistate, track,
self.uistate = uistate family, dbstate.db.get_family_from_handle)
self.family = family
DisplayState.ManagedWindow.__init__(self, uistate, track, family)
if self.already_exist: def _local_init(self):
return
self.build_interface() self.build_interface()
self.load_data()
self.mname = None self.mname = None
self.fname = None self.fname = None
self.signal_keys = [] self._add_db_signal('person-update', self.check_for_change)
self.signal_keys.append(self.dbstate.db.connect('person-update', self._add_db_signal('person-delete', self.check_for_change)
self.check_for_change)) self._add_db_signal('person-rebuild', self.reload_people)
self.signal_keys.append(self.dbstate.db.connect('person-delete',
self.check_for_change))
self.signal_keys.append(self.dbstate.db.connect('person-rebuild',
self.reload_people))
self.show() self.load_data()
def check_for_change(self,handles): def check_for_change(self,handles):
for node in handles: for node in handles:
@ -246,27 +237,22 @@ class EditFamily(DisplayState.ManagedWindow):
break; break;
def reload_people(self): def reload_people(self):
fhandle = self.family.get_father_handle() fhandle = self.obj.get_father_handle()
self.update_father(fhandle) self.update_father(fhandle)
mhandle = self.family.get_mother_handle() mhandle = self.obj.get_mother_handle()
self.update_mother(mhandle) self.update_mother(mhandle)
self.child_list.rebuild() self.child_list.rebuild()
def build_menu_names(self,obj): def build_menu_names(self,obj):
return ('Edit Family','Undefined Submenu') return ('Edit Family','Undefined Submenu')
def build_window_key(self,obj):
if self.family.handle:
return id(self.family.handle)
else:
return id(self)
def build_interface(self): def build_interface(self):
self.top = gtk.glade.XML(const.gladeFile,"marriageEditor","gramps") self.top = gtk.glade.XML(const.gladeFile,"family_editor","gramps")
self.gladeif = GladeIf(self.top)
self.window = self.top.get_widget("marriageEditor") self.define_top_level(self.top.get_widget("family_editor"),
None,_('Family Editor'))
self.fbirth = self.top.get_widget('fbirth') self.fbirth = self.top.get_widget('fbirth')
self.fdeath = self.top.get_widget('fdeath') self.fdeath = self.top.get_widget('fdeath')
@ -280,83 +266,79 @@ class EditFamily(DisplayState.ManagedWindow):
self.mbox = self.top.get_widget('mbox') self.mbox = self.top.get_widget('mbox')
self.fbox = self.top.get_widget('fbox') self.fbox = self.top.get_widget('fbox')
self.ok = self.top.get_widget('ok')
self.cancel = self.top.get_widget('cancel')
self.vbox = self.top.get_widget('vbox')
self.child_list = self.top.get_widget('child_list') self.child_list = self.top.get_widget('child_list')
self.notebook = gtk.Notebook() def _connect_signals(self):
self.notebook.show() self.define_ok_button(self.top.get_widget('ok'), self.save)
self.vbox.pack_start(self.notebook,True) self.define_cancel_button(self.top.get_widget('cancel'))
self._setup_monitored_values() def _setup_fields(self):
self.cancel.connect('clicked', self.close_window)
self.ok.connect('clicked', self.apply_changes)
def _setup_monitored_values(self):
self.private= GrampsWidgets.PrivacyButton(self.top.get_widget('private'),
self.family)
self.gid = GrampsWidgets.MonitoredEntry(self.top.get_widget('gid'),
self.family.set_gramps_id,
self.family.get_gramps_id)
self.data_type = GrampsWidgets.MonitoredType( self.private= PrivacyButton(
self.top.get_widget('marriage_type'), self.family.set_relationship, self.top.get_widget('private'),
self.family.get_relationship, dict(Utils.family_relations), self.obj,
self.db.readonly)
self.gid = MonitoredEntry(
self.top.get_widget('gid'),
self.obj.set_gramps_id,
self.obj.get_gramps_id,
self.db.readonly)
self.data_type = MonitoredType(
self.top.get_widget('marriage_type'),
self.obj.set_relationship,
self.obj.get_relationship,
dict(Utils.family_relations),
RelLib.Family.CUSTOM) RelLib.Family.CUSTOM)
def load_data(self): def load_data(self):
fhandle = self.family.get_father_handle() fhandle = self.obj.get_father_handle()
self.update_father(fhandle) self.update_father(fhandle)
mhandle = self.family.get_mother_handle() mhandle = self.obj.get_mother_handle()
self.update_mother(mhandle) self.update_mother(mhandle)
self.phandles = [mhandle, fhandle] + self.family.get_child_handle_list() self.phandles = [mhandle, fhandle] + self.obj.get_child_handle_list()
self.phandles = [handle for handle in self.phandles if handle] self.phandles = [handle for handle in self.phandles if handle]
self.mbutton.connect('clicked',self.mother_clicked) self.mbutton.connect('clicked',self.mother_clicked)
self.fbutton.connect('clicked',self.father_clicked) self.fbutton.connect('clicked',self.father_clicked)
self.child_list = ChildEmbedList(self.dbstate,self.uistate, def _create_tabbed_pages(self):
self.track, self.family)
self.event_list = EventEmbedList(self.dbstate,self.uistate,
self.track,self.family)
self.src_list = SourceEmbedList(self.dbstate,self.uistate,
self.track,self.family.source_list)
self.attr_list = AttrEmbedList(self.dbstate, self.uistate, self.track,
self.family.get_attribute_list())
self.note_tab = NoteTab(self.dbstate, self.uistate, self.track,
self.family.get_note_object())
self.gallery_tab = GalleryTab(self.dbstate, self.uistate, self.track,
self.family.get_media_list())
self.notebook.insert_page(self.child_list) notebook = gtk.Notebook()
self.notebook.set_tab_label(self.child_list,
self.child_list.get_tab_widget())
self.notebook.insert_page(self.event_list) self.child_list = self._add_tab(
self.notebook.set_tab_label(self.event_list, notebook,
self.event_list.get_tab_widget()) ChildEmbedList(self.dbstate,self.uistate, self.track, self.obj))
self.event_list = self._add_tab(
notebook,
EventEmbedList(self.dbstate,self.uistate, self.track,self.obj))
self.src_list = self._add_tab(
notebook,
SourceEmbedList(self.dbstate,self.uistate,
self.track,self.obj.source_list))
self.attr_list = self._add_tab(
notebook,
AttrEmbedList(self.dbstate, self.uistate, self.track,
self.obj.get_attribute_list()))
self.note_tab = self._add_tab(
notebook,
NoteTab(self.dbstate, self.uistate, self.track,
self.obj.get_note_object()))
self.gallery_tab = self._add_tab(
notebook,
GalleryTab(self.dbstate, self.uistate, self.track,
self.obj.get_media_list()))
self.notebook.insert_page(self.src_list) notebook.show_all()
self.notebook.set_tab_label(self.src_list, self.top.get_widget('vbox').pack_start(notebook,True)
self.src_list.get_tab_widget())
self.notebook.insert_page(self.attr_list)
self.notebook.set_tab_label(self.attr_list,
self.attr_list.get_tab_widget())
self.notebook.insert_page(self.note_tab)
self.notebook.set_tab_label(self.note_tab,
self.note_tab.get_tab_widget())
self.notebook.insert_page(self.gallery_tab)
self.notebook.set_tab_label(self.gallery_tab,
self.gallery_tab.get_tab_widget())
def update_father(self,handle): def update_father(self,handle):
self.load_parent(handle, self.fbox, self.fbirth, self.load_parent(handle, self.fbox, self.fbirth,
@ -370,7 +352,7 @@ class EditFamily(DisplayState.ManagedWindow):
if obj.__class__ == RelLib.Person: if obj.__class__ == RelLib.Person:
try: try:
person = obj person = obj
self.family.set_mother_handle(person.get_handle()) self.obj.set_mother_handle(person.get_handle())
self.update_mother(person.get_handle()) self.update_mother(person.get_handle())
except: except:
log.warn( log.warn(
@ -388,21 +370,21 @@ class EditFamily(DisplayState.ManagedWindow):
def mother_clicked(self,obj): def mother_clicked(self,obj):
handle = self.family.get_mother_handle() handle = self.obj.get_mother_handle()
if handle: if handle:
self.family.set_mother_handle(None) self.obj.set_mother_handle(None)
self.update_mother(None) self.update_mother(None)
else: else:
filter_spec = PersonFilterSpec() filter_spec = PersonFilterSpec()
filter_spec.set_gender(RelLib.Person.FEMALE) filter_spec.set_gender(RelLib.Person.FEMALE)
child_birth_years = [] child_birth_years = []
for person_handle in self.family.get_child_handle_list(): for person_handle in self.obj.get_child_handle_list():
person = self.dbstate.db.get_person_from_handle(person_handle) person = self.db.get_person_from_handle(person_handle)
event_ref = person.get_birth_ref() event_ref = person.get_birth_ref()
event_handle = event_ref.ref event_handle = event_ref.ref
if event_handle: if event_handle:
event = self.dbstate.db.get_event_from_handle(event_handle) event = self.db.get_event_from_handle(event_handle)
child_birth_years.append(event.get_date_object().get_year()) child_birth_years.append(event.get_date_object().get_year())
if len(child_birth_years) > 0: if len(child_birth_years) > 0:
@ -419,7 +401,7 @@ class EditFamily(DisplayState.ManagedWindow):
if obj.__class__ == RelLib.Person: if obj.__class__ == RelLib.Person:
try: try:
person = obj person = obj
self.family.set_father_handle(person.get_handle()) self.obj.set_father_handle(person.get_handle())
self.update_father(person.get_handle()) self.update_father(person.get_handle())
except: except:
log.warn("Failed to update father: \n" log.warn("Failed to update father: \n"
@ -436,21 +418,21 @@ class EditFamily(DisplayState.ManagedWindow):
selector_window.close() selector_window.close()
def father_clicked(self,obj): def father_clicked(self,obj):
handle = self.family.get_father_handle() handle = self.obj.get_father_handle()
if handle: if handle:
self.family.set_father_handle(None) self.obj.set_father_handle(None)
self.update_father(None) self.update_father(None)
else: else:
filter_spec = PersonFilterSpec() filter_spec = PersonFilterSpec()
filter_spec.set_gender(RelLib.Person.MALE) filter_spec.set_gender(RelLib.Person.MALE)
child_birth_years = [] child_birth_years = []
for person_handle in self.family.get_child_handle_list(): for person_handle in self.obj.get_child_handle_list():
person = self.dbstate.db.get_person_from_handle(person_handle) person = self.db.get_person_from_handle(person_handle)
event_ref = person.get_birth_ref() event_ref = person.get_birth_ref()
event_handle = event_ref.ref event_handle = event_ref.ref
if event_handle: if event_handle:
event = self.dbstate.db.get_event_from_handle(event_handle) event = self.db.get_event_from_handle(event_handle)
child_birth_years.append(event.get_date_object().get_year()) child_birth_years.append(event.get_date_object().get_year())
if len(child_birth_years) > 0: if len(child_birth_years) > 0:
@ -465,9 +447,12 @@ class EditFamily(DisplayState.ManagedWindow):
def edit_person(self,obj,event,handle): def edit_person(self,obj,event,handle):
if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1: if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1:
import EditPerson import EditPerson
person = self.dbstate.db.get_person_from_handle(handle) try:
EditPerson.EditPerson(self.dbstate, self.uistate, person = self.db.get_person_from_handle(handle)
self.track, person) EditPerson.EditPerson(self.dbstate, self.uistate,
self.track, person)
except Errors.WindowActiveError:
pass
def load_parent(self,handle,box,birth_obj,death_obj,btn_obj): def load_parent(self,handle,box,birth_obj,death_obj,btn_obj):
@ -479,7 +464,7 @@ class EditFamily(DisplayState.ManagedWindow):
btn_obj.remove(btn_obj.get_children()[0]) btn_obj.remove(btn_obj.get_children()[0])
if is_used: if is_used:
db = self.dbstate.db db = self.db
person = db.get_person_from_handle(handle) person = db.get_person_from_handle(handle)
name = "%s [%s]" % (NameDisplay.displayer.display(person), name = "%s [%s]" % (NameDisplay.displayer.display(person),
person.gramps_id) person.gramps_id)
@ -492,9 +477,9 @@ class EditFamily(DisplayState.ManagedWindow):
del_image.set_from_stock(gtk.STOCK_REMOVE,gtk.ICON_SIZE_BUTTON) del_image.set_from_stock(gtk.STOCK_REMOVE,gtk.ICON_SIZE_BUTTON)
btn_obj.add(del_image) btn_obj.add(del_image)
box.pack_start(GrampsWidgets.LinkBox( box.pack_start(LinkBox(
GrampsWidgets.BasicLabel(name), BasicLabel(name),
GrampsWidgets.IconButton(self.edit_person,person.handle) IconButton(self.edit_person,person.handle)
)) ))
else: else:
name = "" name = ""
@ -512,54 +497,49 @@ class EditFamily(DisplayState.ManagedWindow):
def fix_parent_handles(self,orig_handle, new_handle, trans): def fix_parent_handles(self,orig_handle, new_handle, trans):
if orig_handle != new_handle: if orig_handle != new_handle:
if orig_handle: if orig_handle:
person = self.dbstate.db.get_person_from_handle(orig_handle) person = self.db.get_person_from_handle(orig_handle)
person.family_list.remove(self.family.handle) person.family_list.remove(self.obj.handle)
self.dbstate.db.commit_person(person,trans) self.db.commit_person(person,trans)
if new_handle: if new_handle:
person = self.dbstate.db.get_person_from_handle(orig_handle) person = self.db.get_person_from_handle(orig_handle)
if self.family.handle not in self.person.family_list: if self.obj.handle not in self.obj.family_list:
person.family_list.append(self.family.handle) person.family_list.append(self.obj.handle)
self.dbstate.db.commit_person(person,trans) self.db.commit_person(person,trans)
def apply_changes(self,obj): def save(self,obj):
if self.family.handle: if self.obj.handle:
original = self.dbstate.db.get_family_from_handle(self.family.handle) original = self.db.get_family_from_handle(self.obj.handle)
else: else:
original = None original = None
if not original: if not original:
trans = self.dbstate.db.transaction_begin() trans = self.db.transaction_begin()
self.dbstate.db.add_family(self.family,trans) self.db.add_family(self.obj,trans)
self.dbstate.db.transaction_commit(trans,_("Edit Family")) self.db.transaction_commit(trans,_("Edit Family"))
elif cmp(original.serialize(),self.family.serialize()): elif cmp(original.serialize(),self.obj.serialize()):
trans = self.dbstate.db.transaction_begin() trans = self.db.transaction_begin()
self.fix_parent_handles(original.get_father_handle(), self.fix_parent_handles(original.get_father_handle(),
self.family.get_father_handle(),trans) self.obj.get_father_handle(),trans)
self.fix_parent_handles(original.get_mother_handle(), self.fix_parent_handles(original.get_mother_handle(),
self.family.get_mother_handle(),trans) self.obj.get_mother_handle(),trans)
orig_set = set(original.get_child_handle_list()) orig_set = set(original.get_child_handle_list())
new_set = set(self.family.get_child_handle_list()) new_set = set(self.obj.get_child_handle_list())
# remove the family from children which have been removed # remove the family from children which have been removed
for handle in orig_set.difference(new_set): for handle in orig_set.difference(new_set):
person = self.dbstate.db.get_person_from_handle(handle) person = self.db.get_person_from_handle(handle)
person.remove_parent_family_handle(self.family.handle) person.remove_parent_family_handle(self.obj.handle)
self.dbstate.db.commit_person(person,trans) self.db.commit_person(person,trans)
# add the family from children which have been removed # add the family from children which have been removed
for handle in new_set.difference(orig_set): for handle in new_set.difference(orig_set):
person = self.dbstate.db.get_person_from_handle(handle) person = self.db.get_person_from_handle(handle)
#person.remove_parent_family_handle(self.family.handle) #person.remove_parent_family_handle(self.obj.handle)
#self.dbstate.db.commit_person(person,trans) #self.db.commit_person(person,trans)
self.dbstate.db.commit_family(self.family,trans) self.db.commit_family(self.obj,trans)
self.dbstate.db.transaction_commit(trans,_("Edit Family")) self.db.transaction_commit(trans,_("Edit Family"))
self.close_window() self.close_window()
def close_window(self,*obj):
for key in self.signal_keys:
self.dbstate.db.disconnect(key)
self.close()

242
src/EditMedia.py
View File

@ -46,174 +46,130 @@ import const
import Utils import Utils
import RelLib import RelLib
import GrampsMime import GrampsMime
import DateEdit
import DateHandler
import ImgManip import ImgManip
import DisplayState import EditPrimary
import GrampsDisplay
from GrampsWidgets import *
from QuestionDialog import ErrorDialog from QuestionDialog import ErrorDialog
from DdTargets import DdTargets
from WindowUtils import GladeIf
from DisplayTabs import * from DisplayTabs import *
_drag_targets = [
('STRING', 0, 0),
('text/plain',0,0),
('text/uri-list',0,2),
('application/x-rootwin-drop',0,1)]
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# EditMedia # EditMedia
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class EditMedia(DisplayState.ManagedWindow): class EditMedia(EditPrimary.EditPrimary):
def __init__(self,state,uistate,track,obj): def __init__(self,state,uistate,track,obj):
self.dp = DateHandler.parser
self.dd = DateHandler.displayer
DisplayState.ManagedWindow.__init__(self, uistate, track, obj) EditPrimary.EditPrimary.__init__(self, state, uistate, track, obj,
state.db.get_object_from_handle)
if self.already_exist: def _local_init(self):
return assert(self.obj)
self.glade = gtk.glade.XML(const.gladeFile,
"change_global","gramps")
self.define_top_level(self.glade.get_widget('change_global'),
self.glade.get_widget('title'),
_('Media Properties Editor'))
self.state = state def _connect_signals(self):
self.define_cancel_button(self.glade.get_widget('button91'))
self.define_ok_button(self.glade.get_widget('ok'),self.save)
self.define_help_button(self.glade.get_widget('button102'),'adv-media')
self.pdmap = {} def _setup_fields(self):
self.obj = obj self.date_field = MonitoredDate(
self.lists_changed = 0 self.glade.get_widget('date'),
self.db = self.state.db self.glade.get_widget("date_edit"),
self.idle = None self.obj.get_date_object(),
if obj: self.window,
self.date_object = RelLib.Date(self.obj.get_date_object()) self.db.readonly)
self.alist = self.obj.get_attribute_list()[:]
self.refs = 0
else:
self.date_object = RelLib.Date()
self.alist = []
self.refs = 1
self.refmodel = None # this becomes the model for the references self.descr_window = MonitoredEntry(
self.glade.get_widget("description"),
self.obj.set_description,
self.obj.get_description,
self.db.readonly)
self.path = self.db.get_save_path() self.gid = MonitoredEntry(
self.change_dialog = gtk.glade.XML(const.gladeFile, self.glade.get_widget("gid"),
"change_global","gramps") self.obj.set_gramps_id,
self.gladeif = GladeIf(self.change_dialog) self.obj.get_gramps_id,
self.db.readonly)
mode = not self.db.readonly pixmap = self.glade.get_widget("pixmap")
title = _('Media Properties Editor')
self.window = self.change_dialog.get_widget('change_global')
self.date_entry = self.change_dialog.get_widget('date')
self.date_entry.set_editable(mode)
if self.obj:
self.date_entry.set_text(self.dd.display(self.date_object))
Utils.set_titles(self.window,
self.change_dialog.get_widget('title'),title)
self.descr_window = self.change_dialog.get_widget("description")
self.descr_window.set_editable(mode)
self.descr_window.set_text(self.obj.get_description())
self.date_edit = self.change_dialog.get_widget("date_edit")
self.date_edit.set_sensitive(mode)
self.date_check = DateEdit.DateEdit(
self.date_object, self.date_entry,
self.date_edit, self.window)
self.pixmap = self.change_dialog.get_widget("pixmap")
mtype = self.obj.get_mime_type() mtype = self.obj.get_mime_type()
if mtype: if mtype:
pb = ImgManip.get_thumbnail_image(self.obj.get_path(),mtype) pb = ImgManip.get_thumbnail_image(self.obj.get_path(),mtype)
self.pixmap.set_from_pixbuf(pb) pixmap.set_from_pixbuf(pb)
descr = GrampsMime.get_description(mtype) descr = GrampsMime.get_description(mtype)
if descr: if descr:
self.change_dialog.get_widget("type").set_text(descr) self.glade.get_widget("type").set_text(descr)
else: else:
pb = GrampsMime.find_mime_type_pixbuf('text/plain') pb = GrampsMime.find_mime_type_pixbuf('text/plain')
self.pixmap.set_from_pixbuf(pb) pixmap.set_from_pixbuf(pb)
self.change_dialog.get_widget("type").set_text(_('Note')) self.glade.get_widget("type").set_text(_('Note'))
self.change_dialog.get_widget("gid").set_text(self.obj.get_gramps_id())
self.setup_filepath() self.setup_filepath()
self.gladeif.connect('change_global','delete_event', def _create_tabbed_pages(self):
self.on_delete_event) notebook = gtk.Notebook()
self.gladeif.connect('button91','clicked',self.close_window)
self.gladeif.connect('ok','clicked',self.on_ok_clicked)
self.gladeif.connect('button102','clicked',self.on_help_clicked)
self._create_tabbed_windows()
self.show()
def _create_tabbed_windows(self):
self.vbox = self.change_dialog.get_widget('vbox')
self.notebook = gtk.Notebook()
self.notebook.show()
self.vbox.pack_start(self.notebook,True)
self.attr_list = AttrEmbedList(self.state, self.uistate, self.track,
self.obj.get_attribute_list())
self.note_tab = NoteTab(self.state, self.uistate, self.track,
self.obj.get_note_object())
self.src_list = SourceEmbedList(self.state,self.uistate,
self.track,self.obj.source_list)
if self.obj.get_mime_type(): if self.obj.get_mime_type():
self.notebook.insert_page(self.src_list) self.src_list = self._add_tab(
self.notebook.insert_page(self.attr_list) notebook,
self.notebook.insert_page(self.note_tab) SourceEmbedList(self.dbstate,self.uistate,
self.track,self.obj.source_list))
self.attr_list = self._add_tab(
notebook,
AttrEmbedList(self.dbstate, self.uistate, self.track,
self.obj.get_attribute_list()))
self.note_tab = self._add_tab(
notebook,
NoteTab(self.dbstate, self.uistate, self.track,
self.obj.get_note_object()))
else: else:
self.notebook.insert_page(self.note_tab) self.note_tab = self._add_tab(
self.notebook.insert_page(self.src_list) notebook,
self.notebook.insert_page(self.attr_list) NoteTab(self.dbstate, self.uistate, self.track,
self.obj.get_note_object()))
self.notebook.set_tab_label(self.src_list,self.src_list.get_tab_widget()) self.src_list = self._add_tab(
self.notebook.set_tab_label(self.note_tab,self.note_tab.get_tab_widget()) notebook,
self.notebook.set_tab_label(self.attr_list,self.attr_list.get_tab_widget()) SourceEmbedList(self.dbstate,self.uistate,
self.track,self.obj.source_list))
self.attr_list = self._add_tab(
notebook,
AttrEmbedList(self.dbstate, self.uistate, self.track,
self.obj.get_attribute_list()))
self.backref_list = self._add_page(MediaBackRefList( self.backref_list = self._add_tab(
self.state,self.uistate,self.track, notebook,
self.db.find_backlink_handles(self.obj.handle))) MediaBackRefList(self.dbstate,self.uistate,self.track,
self.db.find_backlink_handles(self.obj.handle)))
def _add_page(self,page): notebook.show_all()
self.notebook.insert_page(page) self.glade.get_widget('vbox').pack_start(notebook,True)
self.notebook.set_tab_label(page,page.get_tab_widget())
return page
def build_menu_names(self,person): def build_menu_names(self,person):
win_menu_label = _("Media Properties") win_menu_label = _("Media Properties")
return (_('Edit Media Object'),win_menu_label) return (_('Edit Media Object'),win_menu_label)
def build_window_key(self,person):
if person:
return person.get_handle()
else:
return id(self)
def on_delete_event(self,obj,b):
self.close()
def select_file(self,obj): def select_file(self,obj):
f = gtk.FileChooserDialog(_('Select Media Object'), f = gtk.FileChooserDialog(
action=gtk.FILE_CHOOSER_ACTION_OPEN, _('Select Media Object'),
buttons=(gtk.STOCK_CANCEL, action=gtk.FILE_CHOOSER_ACTION_OPEN,
gtk.RESPONSE_CANCEL, buttons=(gtk.STOCK_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_CANCEL,
gtk.RESPONSE_OK)) gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
text = self.file_path.get_text() text = self.file_path.get_text()
name = os.path.basename(text)
path = os.path.dirname(text) path = os.path.dirname(text)
f.set_filename(path) f.set_filename(path)
@ -223,48 +179,31 @@ class EditMedia(DisplayState.ManagedWindow):
self.file_path.set_text(f.get_filename()) self.file_path.set_text(f.get_filename())
f.destroy() f.destroy()
def close_window(self,obj):
if self.idle != None:
gobject.source_remove(self.idle)
self.close()
def setup_filepath(self): def setup_filepath(self):
self.select = self.change_dialog.get_widget('file_select') self.select = self.glade.get_widget('file_select')
self.file_path = self.change_dialog.get_widget("path") self.file_path = self.glade.get_widget("path")
if self.obj.get_mime_type(): if self.obj.get_mime_type():
fname = self.obj.get_path() fname = self.obj.get_path()
self.file_path.set_text(fname) self.file_path.set_text(fname)
self.select.connect('clicked', self.select_file) self.select.connect('clicked', self.select_file)
else: else:
self.change_dialog.get_widget('path_label').hide() self.glade.get_widget('path_label').hide()
self.file_path.hide() self.file_path.hide()
self.select.hide() self.select.hide()
def on_apply_clicked(self, obj): def save(self, *obj):
desc = unicode(self.descr_window.get_text()) path = self.glade.get_widget('path').get_text()
note = self.obj.get_note()
path = self.change_dialog.get_widget('path').get_text()
if path != self.obj.get_path(): if path != self.obj.get_path():
mime = GrampsMime.get_type(path) mime = GrampsMime.get_type(path)
self.obj.set_mime_type(mime) self.obj.set_mime_type(mime)
self.obj.set_path(path) self.obj.set_path(path)
if not self.date_object.is_equal(self.obj.get_date_object()):
self.obj.set_date_object(self.date_object)
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
self.db.commit_media_object(self.obj,trans) self.db.commit_media_object(self.obj,trans)
self.db.transaction_commit(trans,_("Edit Media Object")) self.db.transaction_commit(trans,_("Edit Media Object"))
self.close_window()
def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help('adv-media')
def on_ok_clicked(self, obj):
self.on_apply_clicked(obj)
self.close(obj)
class DeleteMediaQuery: class DeleteMediaQuery:
@ -319,12 +258,3 @@ class DeleteMediaQuery:
self.db.remove_object(self.media_handle,trans) self.db.remove_object(self.media_handle,trans)
self.db.transaction_commit(trans,_("Remove Media Object")) self.db.transaction_commit(trans,_("Remove Media Object"))
def build_dropdown(entry,strings):
store = gtk.ListStore(str)
for value in strings:
node = store.append()
store.set(node,0,value)
completion = gtk.EntryCompletion()
completion.set_text_column(0)
completion.set_model(store)
entry.set_completion(completion)

20
src/EditMediaRef.py
View File

@ -25,7 +25,6 @@
# Standard python modules # Standard python modules
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import urlparse
from gettext import gettext as _ from gettext import gettext as _
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -44,22 +43,14 @@ import gtk.glade
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import const import const
import Utils import Utils
import GrampsKeys
import NameDisplay
import PluginMgr
import RelLib import RelLib
import RelImage
import ListModel
import GrampsMime import GrampsMime
import ImgManip import ImgManip
import DisplayState import DisplayState
import GrampsDisplay import GrampsDisplay
from QuestionDialog import ErrorDialog from QuestionDialog import ErrorDialog
from DdTargets import DdTargets
from WindowUtils import GladeIf from WindowUtils import GladeIf
import DisplayState
from DisplayTabs import * from DisplayTabs import *
from GrampsWidgets import * from GrampsWidgets import *
@ -80,10 +71,7 @@ class EditMediaRef(DisplayState.ManagedWindow):
self.db = self.state.db self.db = self.state.db
DisplayState.ManagedWindow.__init__(self, uistate, track, media_ref) DisplayState.ManagedWindow.__init__(self, uistate, track, media_ref)
if self.already_exist:
return
fname = self.media.get_path()
self.change_dialog = gtk.glade.XML(const.gladeFile, self.change_dialog = gtk.glade.XML(const.gladeFile,
"change_description","gramps") "change_description","gramps")
@ -135,7 +123,7 @@ class EditMediaRef(DisplayState.ManagedWindow):
self.gladeif = GladeIf(self.change_dialog) self.gladeif = GladeIf(self.change_dialog)
self.window.connect('delete_event',self.on_delete_event) self.window.connect('delete_event',self.on_delete_event)
self.gladeif.connect('button84','clicked',self.close) self.gladeif.connect('button84','clicked',self.close_window)
self.gladeif.connect('button82','clicked',self.on_ok_clicked) self.gladeif.connect('button82','clicked',self.on_ok_clicked)
self.gladeif.connect('button104','clicked',self.on_help_clicked) self.gladeif.connect('button104','clicked',self.on_help_clicked)
@ -192,10 +180,12 @@ class EditMediaRef(DisplayState.ManagedWindow):
def on_delete_event(self,obj,b): def on_delete_event(self,obj,b):
self.gladeif.close() self.gladeif.close()
self.close()
def close(self,obj): def close_window(self,obj):
self.gladeif.close() self.gladeif.close()
self.window.destroy() self.window.destroy()
self.close()
def on_apply_clicked(self): def on_apply_clicked(self):
@ -226,4 +216,4 @@ class EditMediaRef(DisplayState.ManagedWindow):
def on_ok_clicked(self,obj): def on_ok_clicked(self,obj):
self.on_apply_clicked() self.on_apply_clicked()
self.close(obj) self.close()

733
src/EditPerson.py
View File

@ -37,7 +37,6 @@ from cgi import escape
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import gtk import gtk
import gtk.glade import gtk.glade
import gobject
import gtk.gdk import gtk.gdk
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -49,7 +48,6 @@ import const
import Utils import Utils
import GrampsKeys import GrampsKeys
import GrampsMime import GrampsMime
import AutoComp
import RelLib import RelLib
import DateHandler import DateHandler
import NameDisplay import NameDisplay
@ -57,218 +55,201 @@ import NameEdit
import DisplayState import DisplayState
import GrampsDisplay import GrampsDisplay
import GrampsWidgets import GrampsWidgets
import EditPrimary
from DisplayTabs import * from DisplayTabs import *
from WindowUtils import GladeIf from QuestionDialog import WarningDialog, ErrorDialog, QuestionDialog2
from QuestionDialog import WarningDialog, ErrorDialog, SaveDialog, QuestionDialog2
from DdTargets import DdTargets from DdTargets import DdTargets
try:
set()
except:
from sets import Set as set
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Constants # Constants
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
_temple_names = const.lds_temple_codes.keys()
_temple_names.sort()
_temple_names = [""] + _temple_names
_select_gender = ((True,False,False),(False,True,False),(False,False,True)) _select_gender = ((True,False,False),(False,True,False),(False,False,True))
_use_patronymic = [ _use_patronymic = set(["ru","RU","ru_RU","koi8r","ru_koi8r","russian","Russian"])
"ru","RU","ru_RU","koi8r","ru_koi8r","russian","Russian",
]
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# EditPerson class # EditPerson class
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class EditPerson(DisplayState.ManagedWindow): class EditPerson(EditPrimary.EditPrimary):
use_patronymic = locale.getlocale(locale.LC_TIME)[0] in _use_patronymic use_patronymic = locale.getlocale(locale.LC_TIME)[0] in _use_patronymic
def __init__(self,state,uistate,track,person,callback=None): def __init__(self,state,uistate,track,person,callback=None):
"""Creates an edit window. Associates a person with the window.""" """Creates an edit window. Associates a person with the window."""
self.dp = DateHandler.parser EditPrimary.EditPrimary.__init__(self, state, uistate, track,
self.dd = DateHandler.displayer person, state.db.get_person_from_handle,
self.nd = NameDisplay.displayer callback)
self.person = person def _local_init(self):
self.orig_handle = self.person.get_handle() self.pname = self.obj.get_primary_name()
if self.orig_handle: self.should_guess_gender = (not self.obj.get_gramps_id() and
self.person = state.db.get_person_from_handle(self.orig_handle) self.obj.get_gender () ==
DisplayState.ManagedWindow.__init__(self, uistate, track, self.person)
if self.already_exist:
return
self.dbstate = state
self.uistate = uistate
self.retval = const.UPDATE_PERSON
self.orig_surname = self.person.get_primary_name().get_group_name()
self.db = self.dbstate.db
self.callback = callback
self.pdmap = {}
self.add_places = []
self.should_guess_gender = (not person.get_gramps_id() and
person.get_gender () ==
RelLib.Person.UNKNOWN) RelLib.Person.UNKNOWN)
for key in self.db.get_place_handles():
p = self.db.get_place_from_handle(key).get_display_info()
self.pdmap[p[0]] = key
mod = not self.db.readonly
self.load_obj = None self.load_obj = None
self.top = gtk.glade.XML(const.editPersonFile, "edit_person","gramps") self.top = gtk.glade.XML(const.editPersonFile, "edit_person","gramps")
self.window = self.top.get_widget("edit_person") self.define_top_level(self.top.get_widget("edit_person"), None,
self.gladeif = GladeIf(self.top) _('Edit Person'))
self.window.set_title("%s - GRAMPS" % _('Edit Person'))
self.marker = self.top.get_widget('marker') self.obj_photo = self.top.get_widget("personPix")
self.marker.set_sensitive(mod)
if person:
try:
defval = person.get_marker()[0]
except:
defval = (RelLib.PrimaryObject.MARKER_NONE,"")
else:
defval = None
self.marker_type_selector = AutoComp.StandardCustomSelector(
Utils.marker_types, self.marker,
RelLib.PrimaryObject.MARKER_CUSTOM, defval)
self.gender = self.top.get_widget('gender')
self.gender.set_sensitive(mod)
self.private = GrampsWidgets.PrivacyButton(self.top.get_widget('private'),
self.person)
self.ntype_field = self.top.get_widget("ntype")
self.ntype_field.set_sensitive(mod)
self.vbox = self.top.get_widget('vbox')
self.suffix = self.top.get_widget("suffix")
self.suffix.set_editable(mod)
self.prefix = self.top.get_widget("prefix")
self.prefix.set_editable(mod)
self.given = self.top.get_widget("given_name")
self.given.set_editable(mod)
self.title = self.top.get_widget("title")
self.title.set_editable(mod)
self.surname = self.top.get_widget("surname")
self.surname.set_editable(mod)
self.gid = self.top.get_widget("gid")
self.gid.set_editable(mod)
self.person_photo = self.top.get_widget("personPix")
self.eventbox = self.top.get_widget("eventbox1") self.eventbox = self.top.get_widget("eventbox1")
self.prefix_label = self.top.get_widget('prefix_label')
if self.use_patronymic: def _post_init(self):
self.prefix_label.set_text(_('Patronymic:'))
self.prefix_label.set_use_underline(True)
self.birth_ref = person.get_birth_ref()
self.death_ref = person.get_death_ref()
self.pname = RelLib.Name(self.person.get_primary_name())
self.gender.set_active(self.person.get_gender())
self.place_list = self.pdmap.keys()
self.place_list.sort()
build_dropdown(self.surname,self.db.get_surname_list())
gid = self.person.get_gramps_id()
if gid:
self.gid.set_text(gid)
self.gid.set_editable(True)
# self.lds_baptism = RelLib.LdsOrd(self.person.get_lds_baptism())
# self.lds_endowment = RelLib.LdsOrd(self.person.get_lds_endowment())
# self.lds_sealing = RelLib.LdsOrd(self.person.get_lds_sealing())
# if GrampsKeys.get_uselds() \
# or (not self.lds_baptism.is_empty()) \
# or (not self.lds_endowment.is_empty()) \
# or (not self.lds_sealing.is_empty()):
# self.top.get_widget("lds_tab").show()
# self.top.get_widget("lds_page").show()
# if (not self.lds_baptism.is_empty()) \
# or (not self.lds_endowment.is_empty()) \
# or (not self.lds_sealing.is_empty()):
# Utils.bold_label(self.lds_tab)
# else:
# self.top.get_widget("lds_tab").hide()
# self.top.get_widget("lds_page").hide()
self.ntype_selector = \
AutoComp.StandardCustomSelector(Utils.name_types,
self.ntype_field,
RelLib.Name.CUSTOM,
RelLib.Name.BIRTH)
self.write_primary_name()
self.load_person_image() self.load_person_image()
self.surname_field.grab_focus()
self.gladeif.connect("edit_person", "delete_event", self.on_delete_event)
self.gladeif.connect("button15", "clicked", self.on_cancel_edit) def _connect_signals(self):
self.gladeif.connect("ok", "clicked", self.on_apply_person_clicked) self.define_cancel_button(self.top.get_widget("button15"))
self.gladeif.connect("button134", "clicked", self.on_help_clicked) self.define_ok_button(self.top.get_widget("ok"), self.save)
self.gladeif.connect("given_name", "focus_out_event", self.define_help_button(self.top.get_widget("button134"),'adv-pers')
self.on_given_focus_out_event)
self.gladeif.connect("button177", "clicked", self.on_edit_name_clicked) self.top.get_widget("given_name").connect("focus_out_event",
self.given_focus_out_event)
self.top.get_widget("button177").connect("clicked", self.edit_name_clicked)
self.eventbox.connect('button-press-event',self.image_button_press) self.eventbox.connect('button-press-event',self.image_button_press)
self._create_tabbed_pages() def _setup_fields(self):
self.surname.grab_focus()
self.show()
def _add_page(self,page): self.private = GrampsWidgets.PrivacyButton(
self.notebook.insert_page(page) self.top.get_widget('private'),
self.notebook.set_tab_label(page,page.get_tab_widget()) self.obj)
return page
self.gender = GrampsWidgets.MonitoredMenu(
self.top.get_widget('gender'),
self.obj.set_gender,
self.obj.get_gender,
(
(_('female'),RelLib.Person.FEMALE),
(_('male'),RelLib.Person.MALE),
(_('unknown'),RelLib.Person.UNKNOWN)
),
self.db.readonly)
self.ntype_field = GrampsWidgets.MonitoredType(
self.top.get_widget("ntype"),
self.pname.set_type,
self.pname.get_type,
dict(Utils.name_types),
RelLib.Name.CUSTOM,
self.db.readonly)
self.marker = GrampsWidgets.MonitoredType(
self.top.get_widget('marker'),
self.obj.set_marker,
self.obj.get_marker,
dict(Utils.marker_types),
RelLib.PrimaryObject.MARKER_CUSTOM,
self.db.readonly)
if self.use_patronymic:
self.prefix = GrampsWidgets.MonitoredEntry(
self.top.get_widget("prefix"),
self.pname.set_patronymic,
self.pname.get_patronymic,
self.db.readonly)
prefix_label = self.top.get_widget('prefix_label')
prefix_label.set_text(_('Patronymic:'))
prefix_label.set_use_underline(True)
else:
self.prefix = GrampsWidgets.MonitoredEntry(
self.top.get_widget("prefix"),
self.pname.set_surname_prefix,
self.pname.get_surname_prefix,
self.db.readonly)
self.suffix = GrampsWidgets.MonitoredEntry(
self.top.get_widget("suffix"),
self.pname.set_suffix,
self.pname.get_suffix,
self.db.readonly)
self.given = GrampsWidgets.MonitoredEntry(
self.top.get_widget("given_name"),
self.pname.set_first_name,
self.pname.get_first_name,
self.db.readonly)
self.title = GrampsWidgets.MonitoredEntry(
self.top.get_widget("title"),
self.pname.set_title,
self.pname.get_title,
self.db.readonly)
self.surname_field = GrampsWidgets.MonitoredEntry(
self.top.get_widget("surname"),
self.pname.set_surname,
self.pname.get_surname,
self.db.readonly)
self.gid = GrampsWidgets.MonitoredEntry(
self.top.get_widget("gid"),
self.obj.set_gramps_id,
self.obj.get_gramps_id,
self.db.readonly)
def _create_tabbed_pages(self): def _create_tabbed_pages(self):
""" """
Creates the notebook tabs and inserts them into the main Creates the notebook tabs and inserts them into the main
window. window.
""" """
self.notebook = gtk.Notebook() notebook = gtk.Notebook()
self.event_list = self._add_page(PersonEventEmbedList( self.event_list = self._add_tab(
self.dbstate,self.uistate, self.track,self.person)) notebook,
PersonEventEmbedList(self.dbstate,self.uistate,
self.track,self.obj))
self.name_list = self._add_page(NameEmbedList( self.name_list = self._add_tab(
self.dbstate, self.uistate, self.track, notebook,
self.person.get_alternate_names())) NameEmbedList(self.dbstate, self.uistate, self.track,
self.srcref_list = self._add_page(SourceEmbedList( self.obj.get_alternate_names()))
self.dbstate,self.uistate, self.track,
self.person.source_list)) self.srcref_list = self._add_tab(
self.attr_list = self._add_page(AttrEmbedList( notebook,
self.dbstate,self.uistate,self.track, SourceEmbedList(self.dbstate,self.uistate,
self.person.get_attribute_list())) self.track, self.obj.source_list))
self.addr_list = self._add_page(AddrEmbedList(
self.dbstate,self.uistate,self.track, self.attr_list = self._add_tab(
self.person.get_address_list())) notebook,
self.note_tab = self._add_page(NoteTab( AttrEmbedList(self.dbstate,self.uistate, self.track,
self.dbstate, self.uistate, self.track, self.obj.get_attribute_list()))
self.person.get_note_object()))
self.gallery_tab = self._add_page(GalleryTab( self.addr_list = self._add_tab(
self.dbstate, self.uistate, self.track, notebook,
self.person.get_media_list())) AddrEmbedList(self.dbstate,self.uistate,self.track,
self.web_list = self._add_page(WebEmbedList( self.obj.get_address_list()))
self.dbstate,self.uistate,self.track,
self.person.get_url_list())) self.note_tab = self._add_tab(
notebook,
NoteTab(self.dbstate, self.uistate, self.track,
self.obj.get_note_object()))
self.gallery_tab = self._add_tab(
notebook,
GalleryTab(self.dbstate, self.uistate, self.track,
self.obj.get_media_list()))
self.web_list = self._add_tab(
notebook,
WebEmbedList(self.dbstate,self.uistate,self.track,
self.obj.get_url_list()))
self.notebook.show_all() notebook.show_all()
self.vbox.pack_start(self.notebook,True) self.top.get_widget('vbox').pack_start(notebook,True)
def build_menu_names(self,person): def build_menu_names(self,person):
win_menu_label = self.nd.display(person) win_menu_label = self.nd.display(person)
@ -276,31 +257,15 @@ class EditPerson(DisplayState.ManagedWindow):
win_menu_label = _("New Person") win_menu_label = _("New Person")
return (_('Edit Person'),win_menu_label) return (_('Edit Person'),win_menu_label)
def build_window_key(self,person): # def set_list_dnd(self,obj, get, begin, receive):
if person: # obj.drag_dest_set(gtk.DEST_DEFAULT_ALL, [DdTargets.NAME.target()],
return person.get_handle() # gtk.gdk.ACTION_COPY)
else: # obj.drag_source_set(gtk.gdk.BUTTON1_MASK,[DdTargets.NAME.target()],
return id(self) # gtk.gdk.ACTION_COPY)
# obj.connect('drag_data_get', get)
def set_list_dnd(self,obj, get, begin, receive): # obj.connect('drag_begin', begin)
obj.drag_dest_set(gtk.DEST_DEFAULT_ALL, [DdTargets.NAME.target()], # if not self.db.readonly:
gtk.gdk.ACTION_COPY) # obj.connect('drag_data_received', receive)
obj.drag_source_set(gtk.gdk.BUTTON1_MASK,[DdTargets.NAME.target()],
gtk.gdk.ACTION_COPY)
obj.connect('drag_data_get', get)
obj.connect('drag_begin', begin)
if not self.db.readonly:
obj.connect('drag_data_received', receive)
def build_pdmap(self):
self.pdmap.clear()
cursor = self.db.get_place_cursor()
data = cursor.next()
while data:
if data[1][2]:
self.pdmap[data[1][2]] = data[0]
data = cursor.next()
cursor.close()
def image_callback(self,ref): def image_callback(self,ref):
obj = self.db.get_object_from_handle(ref.get_reference_handle()) obj = self.db.get_object_from_handle(ref.get_reference_handle())
@ -309,7 +274,7 @@ class EditPerson(DisplayState.ManagedWindow):
def image_button_press(self,obj,event): def image_button_press(self,obj,event):
if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1: if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
media_list = self.person.get_media_list() media_list = self.obj.get_media_list()
if media_list: if media_list:
from EditMediaRef import EditMediaRef from EditMediaRef import EditMediaRef
@ -320,7 +285,7 @@ class EditPerson(DisplayState.ManagedWindow):
EditMediaRef(self.dbstate, self.uistate, self.track, EditMediaRef(self.dbstate, self.uistate, self.track,
media_obj, media_ref, self.image_callback) media_obj, media_ref, self.image_callback)
elif event.type == gtk.gdk.BUTTON_PRESS and event.button == 3: elif event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
media_list = self.person.get_media_list() media_list = self.obj.get_media_list()
if media_list: if media_list:
ph = media_list[0] ph = media_list[0]
self.show_popup(ph,event) self.show_popup(ph,event)
@ -347,7 +312,7 @@ class EditPerson(DisplayState.ManagedWindow):
def popup_view_photo(self, obj): def popup_view_photo(self, obj):
"""Open this picture in a picture viewer""" """Open this picture in a picture viewer"""
media_list = self.person.get_media_list() media_list = self.obj.get_media_list()
if media_list: if media_list:
ph = media_list[0] ph = media_list[0]
object_handle = ph.get_reference_handle() object_handle = ph.get_reference_handle()
@ -355,7 +320,7 @@ class EditPerson(DisplayState.ManagedWindow):
def popup_edit_photo(self, obj): def popup_edit_photo(self, obj):
"""Open this picture in a picture editor""" """Open this picture in a picture editor"""
media_list = self.person.get_media_list() media_list = self.obj.get_media_list()
if media_list: if media_list:
ph = media_list[0] ph = media_list[0]
object_handle = ph.get_reference_handle() object_handle = ph.get_reference_handle()
@ -364,7 +329,7 @@ class EditPerson(DisplayState.ManagedWindow):
os.execvp(const.editor,[const.editor, obj.get_path()]) os.execvp(const.editor,[const.editor, obj.get_path()])
def popup_change_description(self,obj): def popup_change_description(self,obj):
media_list = self.person.get_media_list() media_list = self.obj.get_media_list()
if media_list: if media_list:
from EditMediaRef import EditMediaRef from EditMediaRef import EditMediaRef
@ -375,167 +340,17 @@ class EditPerson(DisplayState.ManagedWindow):
media_obj, media_ref, self.image_callback) media_obj, media_ref, self.image_callback)
def on_help_clicked(self,obj): def given_focus_out_event (self, entry, event):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help('adv-pers')
def on_gender_activate (self, button):
self.should_guess_gender = False
def on_given_focus_out_event (self, entry, event):
if not self.should_guess_gender: if not self.should_guess_gender:
return return
gender = self.db.genderStats.guess_gender(unicode(entry.get_text ())) self.gender.force(self.db.genderStats.guess_gender(self.given.get_value()))
self.gender.set_active( gender)
def build_menu(self,list,task,opt_menu,type):
cell = gtk.CellRendererText()
opt_menu.pack_start(cell,True)
opt_menu.add_attribute(cell,'text',0)
store = gtk.ListStore(str)
for val in list:
store.append(row=[val])
opt_menu.set_model(store)
opt_menu.connect('changed',task)
opt_menu.set_active(type)
def on_cancel_edit(self,obj):
"""If the data has changed, give the user a chance to cancel
the close window"""
if not self.db.readonly and self.did_data_change() and not GrampsKeys.get_dont_ask():
n = "<i>%s</i>" % escape(self.nd.display(self.person))
SaveDialog(_('Save changes to %s?') % n,
_('If you close without saving, the changes you '
'have made will be lost'),
self.cancel_callback,
self.save)
else:
self.close()
def save(self):
self.on_apply_person_clicked(None)
def on_delete_event(self,obj,b):
"""If the data has changed, give the user a chance to cancel
the close window"""
if not self.db.readonly and self.did_data_change() and not GrampsKeys.get_dont_ask():
n = "<i>%s</i>" % escape(self.nd.display(self.person))
SaveDialog(_('Save Changes to %s?') % n,
_('If you close without saving, the changes you '
'have made will be lost'),
self.cancel_callback,
self.save)
return True
else:
self.close()
return False
def cancel_callback(self):
"""If the user answered yes to abandoning changes, close the window"""
self.close()
def did_data_change(self):
"""Check to see if any of the data has changed from the
orig record"""
return False
surname = unicode(self.surname.get_text())
ntype = self.ntype_selector.get_values()
suffix = unicode(self.suffix.get_text())
prefix = unicode(self.prefix.get_text())
given = unicode(self.given.get_text())
title = unicode(self.title.get_text())
idval = unicode(self.gid.get_text())
if idval == "":
idval = None
changed = False
name = self.person.get_primary_name()
if self.private.get_active() != self.person.get_privacy():
changed = True
if self.person.get_gramps_id() != idval:
changed = True
if suffix != name.get_suffix():
changed = True
if self.use_patronymic:
if prefix != name.get_patronymic():
changed = True
elif prefix != name.get_surname_prefix():
changed = True
if surname.upper() != name.get_surname().upper():
changed = True
if ntype != name.get_type():
changed = True
if given != name.get_first_name():
changed = True
if title != name.get_title():
changed = True
if self.pname.get_note() != name.get_note():
changed = True
# if self.check_lds():
# changed = True
(female,male,unknown) = _select_gender[self.gender.get_active()]
if male and self.person.get_gender() != RelLib.Person.MALE:
changed = True
elif female and self.person.get_gender() != RelLib.Person.FEMALE:
changed = True
elif unknown and self.person.get_gender() != RelLib.Person.UNKNOWN:
changed = True
# if not self.lds_baptism.are_equal(self.person.get_lds_baptism()):
# changed= True
# if not self.lds_endowment.are_equal(self.person.get_lds_endowment()):
# changed = True
# if not self.lds_sealing.are_equal(self.person.get_lds_sealing()):
# changed = True
return changed
# def check_lds(self):
# date_str = unicode(self.ldsbap_date.get_text())
# DateHandler.set_date(self.lds_baptism,date_str)
# temple = _temple_names[self.ldsbap_temple.get_active()]
# if const.lds_temple_codes.has_key(temple):
# self.lds_baptism.set_temple(const.lds_temple_codes[temple])
# else:
# self.lds_baptism.set_temple("")
# self.lds_baptism.set_place_handle(self.get_place(self.ldsbapplace,1))
# date_str = unicode(self.ldsend_date.get_text())
# DateHandler.set_date(self.lds_endowment,date_str)
# temple = _temple_names[self.ldsend_temple.get_active()]
# if const.lds_temple_codes.has_key(temple):
# self.lds_endowment.set_temple(const.lds_temple_codes[temple])
# else:
# self.lds_endowment.set_temple("")
# self.lds_endowment.set_place_handle(self.get_place(self.ldsendowplace,1))
# date_str = unicode(self.ldsseal_date.get_text())
# DateHandler.set_date(self.lds_sealing,date_str)
# temple = _temple_names[self.ldsseal_temple.get_active()]
# if const.lds_temple_codes.has_key(temple):
# self.lds_sealing.set_temple(const.lds_temple_codes[temple])
# else:
# self.lds_sealing.set_temple("")
# self.lds_sealing.set_family_handle(self.ldsfam)
# self.lds_sealing.set_place_handle(self.get_place(self.ldssealplace,1))
def load_photo(self,photo): def load_photo(self,photo):
"""loads, scales, and displays the person's main photo""" """loads, scales, and displays the person's main photo"""
self.load_obj = photo self.load_obj = photo
if photo == None: if photo == None:
self.person_photo.hide() self.obj_photo.hide()
else: else:
try: try:
i = gtk.gdk.pixbuf_new_from_file(photo) i = gtk.gdk.pixbuf_new_from_file(photo)
@ -544,13 +359,13 @@ class EditPerson(DisplayState.ManagedWindow):
x = int(scale*(i.get_width())) x = int(scale*(i.get_width()))
y = int(scale*(i.get_height())) y = int(scale*(i.get_height()))
i = i.scale_simple(x,y,gtk.gdk.INTERP_BILINEAR) i = i.scale_simple(x,y,gtk.gdk.INTERP_BILINEAR)
self.person_photo.set_from_pixbuf(i) self.obj_photo.set_from_pixbuf(i)
self.person_photo.show() self.obj_photo.show()
except: except:
self.person_photo.hide() self.obj_photo.hide()
def _check_for_unknown_gender(self): def _check_for_unknown_gender(self):
if self.gender.get_active() == RelLib.Person.UNKNOWN: if self.obj.get_gender() == RelLib.Person.UNKNOWN:
dialog = QuestionDialog2( dialog = QuestionDialog2(
_("Unknown gender specified"), _("Unknown gender specified"),
_("The gender of the person is currently unknown. " _("The gender of the person is currently unknown. "
@ -564,12 +379,12 @@ class EditPerson(DisplayState.ManagedWindow):
return False return False
def _check_and_update_id(self): def _check_and_update_id(self):
idval = unicode(self.gid.get_text()) original = self.db.get_person_from_handle(self.obj.get_handle())
if idval != self.person.get_gramps_id():
if original.get_gramps_id() != self.obj.get_gramps_id():
idval = self.obj.get_gramps_id()
person = self.db.get_person_from_gramps_id(idval) person = self.db.get_person_from_gramps_id(idval)
if not person: if person:
self.person.set_gramps_id(idval)
else:
n = self.nd.display(person) n = self.nd.display(person)
msg1 = _("GRAMPS ID value was not changed.") msg1 = _("GRAMPS ID value was not changed.")
msg2 = _("You have attempted to change the GRAMPS ID to a value " msg2 = _("You have attempted to change the GRAMPS ID to a value "
@ -578,92 +393,56 @@ class EditPerson(DisplayState.ManagedWindow):
'person' : n } 'person' : n }
WarningDialog(msg1,msg2) WarningDialog(msg1,msg2)
def _update_primary_name(self):
surname = unicode(self.surname.get_text())
suffix = unicode(self.suffix.get_text())
prefix = unicode(self.prefix.get_text())
ntype = self.ntype_selector.get_values()
given = unicode(self.given.get_text())
title = unicode(self.title.get_text())
name = self.pname
if suffix != name.get_suffix():
name.set_suffix(suffix)
if self.use_patronymic:
if prefix != name.get_patronymic():
name.set_patronymic(prefix)
else:
if prefix != name.get_surname_prefix():
name.set_surname_prefix(prefix)
if surname != name.get_surname():
name.set_surname(surname)
if given != name.get_first_name():
name.set_first_name(given)
if title != name.get_title():
name.set_title(title)
name.set_source_reference_list(self.pname.get_source_references())
if name != self.person.get_primary_name():
self.person.set_primary_name(name)
def _update_family_ids(self, trans): def _update_family_ids(self, trans):
# Update each of the families child lists to reflect any # Update each of the families child lists to reflect any
# change in ordering due to the new birth date # change in ordering due to the new birth date
family = self.person.get_main_parents_family_handle() family = self.obj.get_main_parents_family_handle()
if (family): if (family):
f = self.db.find_family_from_handle(family,trans) f = self.db.find_family_from_handle(family,trans)
new_order = self.reorder_child_list(self.person,f.get_child_handle_list()) new_order = self.reorder_child_list(self.obj,f.get_child_handle_list())
f.set_child_handle_list(new_order) f.set_child_handle_list(new_order)
for (family, rel1, rel2) in self.person.get_parent_family_handle_list(): for (family, rel1, rel2) in self.obj.get_parent_family_handle_list():
f = self.db.find_family_from_handle(family,trans) f = self.db.find_family_from_handle(family,trans)
new_order = self.reorder_child_list(self.person,f.get_child_handle_list()) new_order = self.reorder_child_list(self.obj,f.get_child_handle_list())
f.set_child_handle_list(new_order) f.set_child_handle_list(new_order)
error = False error = False
(female,male,unknown) = _select_gender[self.gender.get_active()] original = self.db.get_person_from_handle(self.obj.handle)
if male and self.person.get_gender() != RelLib.Person.MALE:
self.person.set_gender(RelLib.Person.MALE) (female,male,unknown) = _select_gender[self.obj.get_gender()]
for temp_family_handle in self.person.get_family_handle_list(): if male and original.get_gender() != RelLib.Person.MALE:
for temp_family_handle in self.obj.get_family_handle_list():
temp_family = self.db.get_family_from_handle(temp_family_handle) temp_family = self.db.get_family_from_handle(temp_family_handle)
if self.person == temp_family.get_mother_handle(): if self.obj == temp_family.get_mother_handle():
if temp_family.get_father_handle() != None: if temp_family.get_father_handle() != None:
error = True error = True
else: else:
temp_family.set_mother_handle(None) temp_family.set_mother_handle(None)
temp_family.set_father_handle(self.person) temp_family.set_father_handle(self.obj)
elif female and self.person.get_gender() != RelLib.Person.FEMALE: elif female and original != RelLib.Person.FEMALE:
self.person.set_gender(RelLib.Person.FEMALE) for temp_family_handle in self.obj.get_family_handle_list():
for temp_family_handle in self.person.get_family_handle_list():
temp_family = self.db.get_family_from_handle(temp_family_handle) temp_family = self.db.get_family_from_handle(temp_family_handle)
if self.person == temp_family.get_father_handle(): if self.obj == temp_family.get_father_handle():
if temp_family.get_mother_handle() != None: if temp_family.get_mother_handle() != None:
error = True error = True
else: else:
temp_family.set_father_handle(None) temp_family.set_father_handle(None)
temp_family.set_mother_handle(self.person) temp_family.set_mother_handle(self.obj)
elif unknown and self.person.get_gender() != RelLib.Person.UNKNOWN: elif unknown and original.get_gender() != RelLib.Person.UNKNOWN:
self.person.set_gender(RelLib.Person.UNKNOWN) for temp_family_handle in self.obj.get_family_handle_list():
for temp_family_handle in self.person.get_family_handle_list():
temp_family = self.db.get_family_from_handle(temp_family_handle) temp_family = self.db.get_family_from_handle(temp_family_handle)
if self.person == temp_family.get_father_handle(): if self.obj == temp_family.get_father_handle():
if temp_family.get_mother_handle() != None: if temp_family.get_mother_handle() != None:
error = True error = True
else: else:
temp_family.set_father_handle(None) temp_family.set_father_handle(None)
temp_family.set_mother_handle(self.person) temp_family.set_mother_handle(self.obj)
if self.person == temp_family.get_mother_handle(): if self.obj == temp_family.get_mother_handle():
if temp_family.get_father_handle() != None: if temp_family.get_father_handle() != None:
error = True error = True
else: else:
temp_family.set_mother_handle(None) temp_family.set_mother_handle(None)
temp_family.set_father_handle(self.person) temp_family.set_father_handle(self.obj)
if error: if error:
msg2 = _("Problem changing the gender") msg2 = _("Problem changing the gender")
@ -671,104 +450,47 @@ class EditPerson(DisplayState.ManagedWindow):
"with marriage information.\nPlease check " "with marriage information.\nPlease check "
"the person's marriages.") "the person's marriages.")
ErrorDialog(msg) ErrorDialog(msg)
def on_apply_person_clicked(self,obj): def save(self,*obj):
""" """
Save the data. Save the data.
""" """
if self._check_for_unknown_gender(): if self._check_for_unknown_gender():
return return
(br, dr, el) = self.event_list.return_info() (br, dr, el) = self.event_list.return_info()
self.person.set_birth_ref(br) self.obj.set_birth_ref(br)
self.person.set_death_ref(dr) self.obj.set_death_ref(dr)
self.person.set_event_ref_list(el) self.obj.set_event_ref_list(el)
self.window.hide() self.window.hide()
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
self._check_and_update_id() self._check_and_update_id()
self._update_primary_name()
self.build_pdmap()
self._update_family_ids(trans) self._update_family_ids(trans)
self.person.set_marker(self.marker_type_selector.get_values()) if not self.obj.get_handle():
self.person.set_privacy(self.private.get_active()) self.db.add_person(self.obj, trans)
# if not self.lds_not_loaded:
# self.check_lds()
# lds_ord = RelLib.LdsOrd(self.person.get_lds_baptism())
# if not self.lds_baptism.are_equal(lds_ord):
# self.person.set_lds_baptism(self.lds_baptism)
# lds_ord = RelLib.LdsOrd(self.person.get_lds_endowment())
# if not self.lds_endowment.are_equal(lds_ord):
# self.person.set_lds_endowment(self.lds_endowment)
# lds_ord = RelLib.LdsOrd(self.person.get_lds_sealing())
# if not self.lds_sealing.are_equal(lds_ord):
# self.person.set_lds_sealing(self.lds_sealing)
# self.person.set_source_reference_list(self.srcreflist)
if not self.person.get_handle():
self.db.add_person(self.person, trans)
else: else:
if not self.person.get_gramps_id(): if not self.obj.get_gramps_id():
self.person.set_gramps_id(self.db.find_next_person_gramps_id()) self.obj.set_gramps_id(self.db.find_next_person_gramps_id())
self.db.commit_person(self.person, trans) self.db.commit_person(self.obj, trans)
n = self.nd.display(self.person) self.db.transaction_commit(trans,_("Edit Person (%s)") % self.nd.display(self.obj))
self.db.transaction_commit(trans,_("Edit Person (%s)") % n)
self.close() self.close()
def get_place(self,field,makenew=0): def edit_name_clicked(self,obj):
text = unicode(field.get_text().strip())
if text:
if self.pdmap.has_key(text):
return self.pdmap[text]
elif makenew:
place = RelLib.Place()
place.set_title(text)
trans = self.db.transaction_begin()
self.db.add_place(place,trans)
self.retval |= const.UPDATE_PLACE
self.db.transaction_commit(trans,_('Add Place (%s)' % text))
self.pdmap[text] = place.get_handle()
self.add_places.append(place)
return place.get_handle()
else:
return u""
else:
return u""
def on_edit_name_clicked(self,obj):
ntype = self.ntype_selector.get_values()
self.pname.set_type(ntype)
self.pname.set_suffix(unicode(self.suffix.get_text()))
self.pname.set_surname(unicode(self.surname.get_text()))
if self.use_patronymic:
self.pname.set_patronymic(unicode(self.prefix.get_text()))
else:
self.pname.set_surname_prefix(unicode(self.prefix.get_text()))
self.pname.set_first_name(unicode(self.given.get_text()))
self.pname.set_title(unicode(self.title.get_text()))
NameEdit.NameEditor(self.dbstate, self.uistate, self.track, NameEdit.NameEditor(self.dbstate, self.uistate, self.track,
self.pname, self) self.pname, self.update_name)
def update_name(self,name): def update_name(self,name):
self.write_primary_name() for obj in (self.suffix, self.prefix, self.given, self.title, self.ntype_field,
self.surname_field):
obj.update()
def load_person_image(self): def load_person_image(self):
media_list = self.person.get_media_list() media_list = self.obj.get_media_list()
if media_list: if media_list:
ph = media_list[0] ph = media_list[0]
object_handle = ph.get_reference_handle() object_handle = ph.get_reference_handle()
@ -782,18 +504,6 @@ class EditPerson(DisplayState.ManagedWindow):
else: else:
self.load_photo(None) self.load_photo(None)
def write_primary_name(self):
# initial values
self.suffix.set_text(self.pname.get_suffix())
if self.use_patronymic:
self.prefix.set_text(self.pname.get_patronymic())
else:
self.prefix.set_text(self.pname.get_surname_prefix())
self.surname.set_text(self.pname.get_surname())
self.given.set_text(self.pname.get_first_name())
self.title.set_text(self.pname.get_title())
def birth_dates_in_order(self,list): def birth_dates_in_order(self,list):
"""Check any *valid* birthdates in the list to insure that they are in """Check any *valid* birthdates in the list to insure that they are in
numerically increasing order.""" numerically increasing order."""
@ -867,22 +577,3 @@ class EditPerson(DisplayState.ManagedWindow):
list.insert(target,person.get_handle()) list.insert(target,person.get_handle())
return list return list
def build_dropdown(entry,strings):
store = gtk.ListStore(str)
for value in strings:
node = store.append()
store.set(node,0,unicode(value))
completion = gtk.EntryCompletion()
completion.set_text_column(0)
completion.set_model(store)
entry.set_completion(completion)
def build_combo(entry,strings):
cell = gtk.CellRendererText()
entry.pack_start(cell,True)
entry.add_attribute(cell,'text',0)
store = gtk.ListStore(str)
for value in strings:
node = store.append()
store.set(node,0,unicode(value))
entry.set_model(store)

168
src/EditPlace.py
View File

@ -26,9 +26,7 @@
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import cPickle as pickle import cPickle as pickle
import gc
from gettext import gettext as _ from gettext import gettext as _
import sys
import logging import logging
log = logging.getLogger(".") log = logging.getLogger(".")
@ -49,15 +47,9 @@ import gtk.glade
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import const import const
import Utils import Utils
import Sources
import NameDisplay
import DisplayState
import Spell
import GrampsDisplay
import RelLib import RelLib
import ListModel import EditPrimary
from DdTargets import DdTargets
from DisplayTabs import * from DisplayTabs import *
from GrampsWidgets import * from GrampsWidgets import *
@ -66,50 +58,33 @@ from GrampsWidgets import *
# EditPlace # EditPlace
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class EditPlace(DisplayState.ManagedWindow): class EditPlace(EditPrimary.EditPrimary):
def __init__(self,dbstate,uistate,track,place): def __init__(self,dbstate,uistate,track,place,callback=None):
self.dbstate = dbstate EditPrimary.EditPrimary.__init__(
self, dbstate, uistate, track, place,
dbstate.db.get_place_from_handle, callback)
DisplayState.ManagedWindow.__init__(self, uistate, track, place) def _local_init(self):
self.top = gtk.glade.XML(const.gladeFile,"place_editor","gramps")
self.name_display = NameDisplay.displayer.display self.define_top_level(self.top.get_widget("place_editor"),
self.place = place self.top.get_widget('title'),
self.db = dbstate.db _('Place Editor'))
self.top = gtk.glade.XML(const.gladeFile,"placeEditor","gramps")
self.window = self.top.get_widget("placeEditor")
title_label = self.top.get_widget('title')
Utils.set_titles(self.window,title_label,_('Place Editor'))
self.top.get_widget('changed').set_text(place.get_change_display())
self.notebook = self.top.get_widget('notebook3')
self._create_tabbed_pages()
self._setup_fields()
self._connect_signals()
self.show()
self.pdmap = {}
self.build_pdmap()
def _connect_signals(self): def _connect_signals(self):
self.top.get_widget('placeEditor').connect('delete_event', self.delete_event) self.define_ok_button(self.top.get_widget('ok'),self.save)
self.top.get_widget('button127').connect('clicked', self.close) self.define_cancel_button(self.top.get_widget('cancel'))
self.top.get_widget('button135').connect('clicked', self.help_clicked) self.define_help_button(self.top.get_widget('help'),'adv-plc')
ok = self.top.get_widget('ok')
ok.connect('clicked', self.apply_clicked)
ok.set_sensitive(not self.db.readonly)
def _setup_fields(self): def _setup_fields(self):
mloc = self.place.get_main_location() mloc = self.obj.get_main_location()
self.top.get_widget('changed').set_text(self.obj.get_change_display())
self.title = MonitoredEntry( self.title = MonitoredEntry(
self.top.get_widget("place_title"), self.top.get_widget("place_title"),
self.place.set_title, self.place.get_title, self.obj.set_title, self.obj.get_title,
self.db.readonly) self.db.readonly)
self.city = MonitoredEntry( self.city = MonitoredEntry(
@ -142,21 +117,14 @@ class EditPlace(DisplayState.ManagedWindow):
self.longitude = MonitoredEntry( self.longitude = MonitoredEntry(
self.top.get_widget("longitude"), self.top.get_widget("longitude"),
self.place.set_longitude, self.place.get_longitude, self.obj.set_longitude, self.obj.get_longitude,
self.db.readonly) self.db.readonly)
self.latitude = MonitoredEntry( self.latitude = MonitoredEntry(
self.top.get_widget("latitude"), self.top.get_widget("latitude"),
self.place.set_latitude, self.place.get_latitude, self.obj.set_latitude, self.obj.get_latitude,
self.db.readonly) self.db.readonly)
def build_window_key(self,place):
if place:
return place.get_handle()
else:
return id(self)
def build_menu_names(self,place): def build_menu_names(self,place):
win_menu_label = place.get_title() win_menu_label = place.get_title()
if not win_menu_label.strip(): if not win_menu_label.strip():
@ -164,7 +132,7 @@ class EditPlace(DisplayState.ManagedWindow):
return (win_menu_label, _('Edit Place')) return (win_menu_label, _('Edit Place'))
def build_pdmap(self): def build_pdmap(self):
self.pdmap.clear() self.pdmap = {}
cursor = self.db.get_place_cursor() cursor = self.db.get_place_cursor()
data = cursor.next() data = cursor.next()
while data: while data:
@ -173,60 +141,52 @@ class EditPlace(DisplayState.ManagedWindow):
data = cursor.next() data = cursor.next()
cursor.close() cursor.close()
def _add_page(self,page):
self.notebook.insert_page(page)
self.notebook.set_tab_label(page,page.get_tab_widget())
return page
def _create_tabbed_pages(self): def _create_tabbed_pages(self):
""" """
Creates the notebook tabs and inserts them into the main Creates the notebook tabs and inserts them into the main
window. window.
""" """
self.loc_list = self._add_page(LocationEmbedList( notebook = self.top.get_widget('notebook3')
self.dbstate,self.uistate, self.track,
self.place.alt_loc))
self.srcref_list = self._add_page(SourceEmbedList(
self.dbstate,self.uistate, self.track,
self.place.source_list))
self.note_tab = self._add_page(NoteTab(
self.dbstate, self.uistate, self.track,
self.place.get_note_object()))
self.gallery_tab = self._add_page(GalleryTab(
self.dbstate, self.uistate, self.track,
self.place.get_media_list()))
self.web_list = self._add_page(WebEmbedList(
self.dbstate,self.uistate,self.track,
self.place.get_url_list()))
self.backref_list = self._add_page(PlaceBackRefList(
self.dbstate,self.uistate,self.track,
self.db.find_backlink_handles(self.place.handle)))
def delete_event(self,obj,b): self.loc_list = self._add_tab(
self.close() notebook,
LocationEmbedList(self.dbstate,self.uistate, self.track,
self.obj.alt_loc))
self.srcref_list = self._add_tab(
notebook,
SourceEmbedList(self.dbstate,self.uistate, self.track,
self.obj.source_list))
self.note_tab = self._add_tab(
notebook,
NoteTab(self.dbstate, self.uistate, self.track,
self.obj.get_note_object()))
self.gallery_tab = self._add_tab(
notebook,
GalleryTab(self.dbstate, self.uistate, self.track,
self.obj.get_media_list()))
self.web_list = self._add_tab(
notebook,
WebEmbedList(self.dbstate,self.uistate,self.track,
self.obj.get_url_list()))
self.backref_list = self._add_tab(
notebook,
PlaceBackRefList(self.dbstate,self.uistate,self.track,
self.db.find_backlink_handles(self.obj.handle)))
def close_window(self,obj): def _cleanup_on_exit(self):
self.close() self.backref_list.close()
self.window.destroy()
def help_clicked(self,obj): def save(self,*obj):
"""Display the relevant portion of GRAMPS manual""" title = self.obj.get_title()
GrampsDisplay.help('adv-plc') self.build_pdmap()
def build_columns(self,tree,list): if self.pdmap.has_key(title) and self.pdmap[title] != self.obj.handle:
cnum = 0
for name in list:
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(name[0],renderer,text=cnum)
column.set_min_width(name[1])
cnum = cnum + 1
tree.append_column(column)
def apply_clicked(self,obj):
title = self.place.get_title()
if self.pdmap.has_key(title) and self.pdmap[title] != self.place.handle:
import QuestionDialog import QuestionDialog
QuestionDialog.ErrorDialog( QuestionDialog.ErrorDialog(
_("Place title is already in use"), _("Place title is already in use"),
@ -236,12 +196,12 @@ class EditPlace(DisplayState.ManagedWindow):
return return
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
if self.place.get_handle(): if self.obj.get_handle():
self.db.commit_place(self.place,trans) self.db.commit_place(self.obj,trans)
else: else:
self.db.add_place(self.place,trans) self.db.add_place(self.obj,trans)
self.db.transaction_commit(trans, self.db.transaction_commit(trans,
_("Edit Place (%s)") % self.place.get_title()) _("Edit Place (%s)") % self.obj.get_title())
self.close(obj) self.close(obj)
@ -254,13 +214,13 @@ class DeletePlaceQuery:
def __init__(self,place,db): def __init__(self,place,db):
self.db = db self.db = db
self.place = place self.obj = place
def query_response(self): def query_response(self):
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
self.db.disable_signals() self.db.disable_signals()
place_handle = self.place.get_handle() place_handle = self.obj.get_handle()
for handle in self.db.get_person_handles(sort_handles=False): for handle in self.db.get_person_handles(sort_handles=False):
person = self.db.get_person_from_handle(handle) person = self.db.get_person_from_handle(handle)
@ -283,4 +243,4 @@ class DeletePlaceQuery:
self.db.enable_signals() self.db.enable_signals()
self.db.remove_place(place_handle,trans) self.db.remove_place(place_handle,trans)
self.db.transaction_commit(trans, self.db.transaction_commit(trans,
_("Delete Place (%s)") % self.place.get_title()) _("Delete Place (%s)") % self.obj.get_title())

137
src/EditRepository.py
View File

@ -32,9 +32,8 @@ from gettext import gettext as _
# GTK/Gnome modules # GTK/Gnome modules
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import gobject import gtk
import gtk.glade import gtk.glade
import gtk.gdk
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
@ -44,117 +43,91 @@ import gtk.gdk
import const import const
import Utils import Utils
import RelLib import RelLib
import NameDisplay
import GrampsDisplay
from GrampsWidgets import * from GrampsWidgets import *
from DisplayTabs import * from DisplayTabs import *
import DisplayState import EditPrimary
class EditRepository(DisplayState.ManagedWindow): class EditRepository(EditPrimary.EditPrimary):
def __init__(self,dbstate,uistate,track,repository): def __init__(self,dbstate,uistate,track,repository):
if repository: EditPrimary.EditPrimary.__init__(self, dbstate, uistate, track,
self.repository = repository repository, dbstate.db.get_repository_from_handle)
else:
self.repository = RelLib.Repository()
DisplayState.ManagedWindow.__init__(self, uistate, track, repository) def _local_init(self):
self.glade = gtk.glade.XML(const.gladeFile,"repository_editor","gramps")
self.define_top_level(self.glade.get_widget("repository_editor"),
self.glade.get_widget('repository_title'),
_('Repository Editor'))
self.dbstate = dbstate def _setup_fields(self):
self.db = dbstate.db
self.name_display = NameDisplay.displayer.display
self.path = self.db.get_save_path()
self.glade = gtk.glade.XML(const.gladeFile,"repositoryEditor","gramps")
self.window = self.glade.get_widget("repositoryEditor")
Utils.set_titles(self.window,self.glade.get_widget('repository_title'),
_('Repository Editor'))
self.name = MonitoredEntry( self.name = MonitoredEntry(
self.glade.get_widget("repository_name"), self.glade.get_widget("repository_name"),
self.repository.set_name, self.obj.set_name,
self.repository.get_name, self.obj.get_name,
self.db.readonly) self.db.readonly)
self.type = MonitoredType( self.type = MonitoredType(
self.glade.get_widget("repository_type"), self.glade.get_widget("repository_type"),
self.repository.set_type, self.obj.set_type,
self.repository.get_type, self.obj.get_type,
dict(Utils.repository_types), dict(Utils.repository_types),
RelLib.Repository.CUSTOM) RelLib.Repository.CUSTOM)
self.call_number = MonitoredEntry( self.call_number = MonitoredEntry(
self.glade.get_widget('gid'), self.glade.get_widget('gid'),
self.repository.set_gramps_id, self.obj.set_gramps_id,
self.repository.get_gramps_id, self.obj.get_gramps_id,
self.db.readonly) self.db.readonly)
self.notebook = gtk.Notebook() def _create_tabbed_pages(self):
self.notebook.show()
self.glade.get_widget("vbox").pack_start(self.notebook,True,True)
self.addr_tab = self._add_page(AddrEmbedList(
self.dbstate, self.uistate, self.track,
repository.get_address_list()))
self.url_tab = self._add_page(WebEmbedList(
self.dbstate, self.uistate, self.track,
repository.get_url_list()))
self.note_tab = self._add_page(NoteTab( notebook = gtk.Notebook()
self.dbstate, self.uistate, self.track,
repository.get_note_object()))
self.backref_tab = self._add_page(SourceBackRefList( self.addr_tab = self._add_tab(
self.dbstate, self.uistate, self.track, notebook,
self.db.find_backlink_handles(self.repository.handle))) AddrEmbedList(self.dbstate, self.uistate, self.track,
self.obj.get_address_list()))
self.glade.signal_autoconnect({ self.url_tab = self._add_tab(
"on_repositoryEditor_help_clicked" : self.on_help_clicked, notebook,
"on_repositoryEditor_ok_clicked" : self.on_repository_apply_clicked, WebEmbedList(self.dbstate, self.uistate, self.track,
"on_repositoryEditor_cancel_clicked" : self.close_window, self.obj.get_url_list()))
"on_repositoryEditor_delete_event" : self.on_delete_event,
})
self.glade.get_widget('ok').set_sensitive(not self.db.readonly)
self.window.show()
def _add_page(self,page):
self.notebook.insert_page(page)
self.notebook.set_tab_label(page,page.get_tab_widget())
return page
def on_delete_event(self,obj,b):
self.close()
def on_help_clicked(self,obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help('adv-src')
def close_window(self,obj):
self.close()
self.window.destroy()
def on_repository_apply_clicked(self,obj): self.note_tab = self._add_tab(
notebook,
NoteTab(self.dbstate, self.uistate, self.track,
self.obj.get_note_object()))
self.backref_tab = self._add_tab(
notebook,
SourceBackRefList(self.dbstate, self.uistate, self.track,
self.db.find_backlink_handles(self.obj.handle)))
notebook.show_all()
self.glade.get_widget("vbox").pack_start(notebook,True,True)
def _connect_signals(self):
self.define_help_button(self.glade.get_widget('help'),'adv-src')
self.define_cancel_button(self.glade.get_widget('cancel'))
self.define_ok_button(self.glade.get_widget('ok'), self.save)
def save(self,*obj):
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
handle = None if self.obj.get_handle() == None:
if self.repository.get_handle() == None: handle = self.db.add_repository(self.obj,trans)
handle = self.db.add_repository(self.repository,trans)
else: else:
self.db.commit_repository(self.repository,trans) self.db.commit_repository(self.obj,trans)
handle = self.repository.get_handle() handle = self.obj.get_handle()
self.db.transaction_commit(trans,_("Edit Repository (%s)") % self.repository.get_name()) msg = _("Edit Repository (%s)") % self.obj.get_name()
self.db.transaction_commit(trans,msg)
self.close(obj) self.close(obj)
class DelRepositoryQuery: class DelRepositoryQuery:
def __init__(self,repository,db,sources): def __init__(self,repository,db,sources):
self.repository = repository self.obj = repository
self.db = db self.db = db
self.sources = sources self.sources = sources
@ -162,13 +135,13 @@ class DelRepositoryQuery:
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
repos_handle_list = [self.repository.get_handle()] repos_handle_list = [self.obj.get_handle()]
for handle in self.sources: for handle in self.sources:
source = self.db.get_source_from_handle(handle) source = self.db.get_source_from_handle(handle)
source.remove_repo_references(repos_handle_list) source.remove_repo_references(repos_handle_list)
self.db.commit_source(source,trans) self.db.commit_source(source,trans)
self.db.remove_repository(self.repository.get_handle(),trans) self.db.remove_repository(self.obj.get_handle(),trans)
self.db.transaction_commit( self.db.transaction_commit(
trans,_("Delete Repository (%s)") % self.repository.get_name()) trans,_("Delete Repository (%s)") % self.obj.get_name())

145
src/EditSource.py
View File

@ -26,8 +26,6 @@
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
from gettext import gettext as _ from gettext import gettext as _
import gc
import sys
import logging import logging
log = logging.getLogger(".") log = logging.getLogger(".")
@ -51,7 +49,7 @@ import RelLib
import NameDisplay import NameDisplay
import Spell import Spell
import GrampsDisplay import GrampsDisplay
import DisplayState import EditPrimary
from DisplayTabs import * from DisplayTabs import *
from WindowUtils import GladeIf from WindowUtils import GladeIf
@ -62,104 +60,84 @@ from GrampsWidgets import *
# Constants # Constants
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class EditSource(DisplayState.ManagedWindow): class EditSource(EditPrimary.EditPrimary):
def __init__(self,dbstate,uistate,track,source,readonly=False): def __init__(self,dbstate,uistate,track,source):
self.dbstate = dbstate
self.track = track
self.uistate = uistate
self.db = dbstate.db EditPrimary.EditPrimary.__init__(
self.name_display = NameDisplay.displayer.display self, dbstate, uistate, track,
source, dbstate.db.get_source_from_handle)
DisplayState.ManagedWindow.__init__(self, uistate, self.track, source) def _local_init(self):
if source: assert(self.obj)
self.source = source self.glade = gtk.glade.XML(const.gladeFile,"source_editor","gramps")
else:
self.source = RelLib.Source()
self.glade = gtk.glade.XML(const.gladeFile,"sourceEditor","gramps") self.define_top_level(self.glade.get_widget("source_editor"),
self.window = self.glade.get_widget("sourceEditor") self.glade.get_widget('title'),
_('Source Editor'))
Utils.set_titles(self.window,self.glade.get_widget('title'),
_('Source Editor'))
self.vbox = self.glade.get_widget('vbox')
self.notebook = gtk.Notebook()
self.notebook.show()
self.vbox.pack_start(self.notebook,True)
self._create_tabbed_pages()
self._setup_fields()
self._connect_signals()
self.show()
def _connect_signals(self): def _connect_signals(self):
self.glade.get_widget('cancel').connect('clicked', self.close_window) self.define_ok_button(self.glade.get_widget('ok'),self.save)
self.define_cancel_button(self.glade.get_widget('cancel'))
ok = self.glade.get_widget('ok') self.define_help_button(self.glade.get_widget('help'),'adv-src')
ok.set_sensitive(not self.db.readonly)
ok.connect('clicked', self.apply_clicked)
def _setup_fields(self): def _setup_fields(self):
self.author = MonitoredEntry( self.author = MonitoredEntry(
self.glade.get_widget("author"), self.glade.get_widget("author"),
self.source.set_author, self.obj.set_author,
self.source.get_author, self.obj.get_author,
self.db.readonly) self.db.readonly)
self.pubinfo = MonitoredEntry( self.pubinfo = MonitoredEntry(
self.glade.get_widget("pubinfo"), self.glade.get_widget("pubinfo"),
self.source.set_publication_info, self.obj.set_publication_info,
self.source.get_publication_info, self.obj.get_publication_info,
self.db.readonly) self.db.readonly)
self.abbrev = MonitoredEntry( self.abbrev = MonitoredEntry(
self.glade.get_widget("abbrev"), self.glade.get_widget("abbrev"),
self.source.set_abbreviation, self.obj.set_abbreviation,
self.source.get_abbreviation, self.obj.get_abbreviation,
self.db.readonly) self.db.readonly)
self.title = MonitoredEntry( self.title = MonitoredEntry(
self.glade.get_widget("source_title"), self.glade.get_widget("source_title"),
self.source.set_title, self.obj.set_title,
self.source.get_title, self.obj.get_title,
self.db.readonly) self.db.readonly)
def _add_page(self,page):
self.notebook.insert_page(page)
self.notebook.set_tab_label(page,page.get_tab_widget())
return page
def _create_tabbed_pages(self): def _create_tabbed_pages(self):
self.note_tab = self._add_page(NoteTab( notebook = gtk.Notebook()
self.dbstate, self.uistate, self.track,
self.source.get_note_object()))
self.gallery_tab = self._add_page(GalleryTab(
self.dbstate, self.uistate, self.track,
self.source.get_media_list()))
self.data_tab = self._add_page(DataEmbedList(
self.dbstate, self.uistate, self.track, self.source))
self.repo_tab = self._add_page(RepoEmbedList(
self.dbstate, self.uistate, self.track,
self.source.get_reporef_list()))
self.backref_tab = self._add_page(SourceBackRefList(
self.dbstate, self.uistate, self.track,
self.db.find_backlink_handles(self.source.handle)))
self.notebook.show_all()
def build_window_key(self,source): self.note_tab = self._add_tab(
if source: notebook,
return source.get_handle() NoteTab(self.dbstate, self.uistate, self.track,
else: self.obj.get_note_object()))
return id(self)
self.gallery_tab = self._add_tab(
notebook,
GalleryTab(self.dbstate, self.uistate, self.track,
self.obj.get_media_list()))
self.data_tab = self._add_tab(
notebook,
DataEmbedList(self.dbstate, self.uistate, self.track,
self.obj))
self.repo_tab = self._add_tab(
notebook,
RepoEmbedList(self.dbstate, self.uistate, self.track,
self.obj.get_reporef_list()))
self.backref_tab = self._add_tab(
notebook,
SourceBackRefList(self.dbstate, self.uistate, self.track,
self.db.find_backlink_handles(self.obj.handle)))
notebook.show_all()
self.glade.get_widget('vbox').pack_start(notebook,True)
def build_menu_names(self,source): def build_menu_names(self,source):
if source: if source:
@ -168,27 +146,18 @@ class EditSource(DisplayState.ManagedWindow):
label = "New Source" label = "New Source"
return (label, _('Source Editor')) return (label, _('Source Editor'))
def on_delete_event(self,obj,b): def _cleanup_on_exit(self):
self.backref_tab.close() self.backref_tab.close()
self.close()
def on_help_clicked(self,obj): def save(self,*obj):
"""Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help('adv-src')
def close_window(self,obj):
self.backref_tab.close()
self.close()
def apply_clicked(self,obj):
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
if self.source.get_handle() == None: if self.obj.get_handle() == None:
self.db.add_source(self.source,trans) self.db.add_source(self.obj,trans)
else: else:
self.db.commit_source(self.source,trans) self.db.commit_source(self.obj,trans)
self.db.transaction_commit(trans, self.db.transaction_commit(trans,
_("Edit Source (%s)") % self.source.get_title()) _("Edit Source (%s)") % self.obj.get_title())
self.close(obj) self.close(obj)
class DelSrcQuery: class DelSrcQuery:

5
src/EditSourceRef.py
View File

@ -45,13 +45,10 @@ import gtk.glade
# gramps modules # gramps modules
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import Sources
import Witness
import const import const
import Utils import Utils
import AutoComp import AutoComp
import RelLib import RelLib
import GrampsDisplay
import DisplayState import DisplayState
from QuestionDialog import WarningDialog, ErrorDialog from QuestionDialog import WarningDialog, ErrorDialog
@ -74,8 +71,6 @@ class EditSourceRef(DisplayState.ManagedWindow):
self.source = source self.source = source
DisplayState.ManagedWindow.__init__(self, uistate, track, source_ref) DisplayState.ManagedWindow.__init__(self, uistate, track, source_ref)
if self.already_exist:
return
self.update = update self.update = update

9
src/Errors.py
View File

@ -102,3 +102,12 @@ class FileVersionError(Exception):
def __str__(self): def __str__(self):
return self.value return self.value
class WindowActiveError(Exception):
"""Error used to report that the request window is already displayed."""
def __init__(self,value):
Exception.__init__(self)
self.value = value
def __str__(self):
return self.value

150
src/EventEdit.py
View File

@ -49,9 +49,8 @@ import const
import Utils import Utils
import AutoComp import AutoComp
import RelLib import RelLib
import DateEdit
import GrampsDisplay import GrampsDisplay
import DisplayState import EditPrimary
from QuestionDialog import WarningDialog, ErrorDialog from QuestionDialog import WarningDialog, ErrorDialog
from DisplayTabs import * from DisplayTabs import *
@ -72,111 +71,95 @@ for event_type in Utils.family_events.keys():
# EventEditor class # EventEditor class
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class EventEditor(DisplayState.ManagedWindow): class EventEditor(EditPrimary.EditPrimary):
def __init__(self,event,dbstate,uistate,track=[],callback=None): def __init__(self,event,dbstate,uistate,track=[],callback=None):
self.db = dbstate.db
self.uistate = uistate
self.dbstate = dbstate
self.track = track
self.callback = callback
self.event = event
self.path = self.db.get_save_path()
self.plist = []
self.pmap = {}
DisplayState.ManagedWindow.__init__(self, uistate, self.track, event) EditPrimary.EditPrimary.__init__(self, dbstate, uistate, track,
if self.already_exist: event, dbstate.db.get_event_from_handle)
return
if not event:
self.event = RelLib.Event()
def _local_init(self):
self.top = gtk.glade.XML(const.gladeFile, "event_edit","gramps") self.top = gtk.glade.XML(const.gladeFile, "event_edit","gramps")
self.window = self.top.get_widget("event_edit") self.window = self.top.get_widget("event_edit")
title_label = self.top.get_widget('title')
etitle = _('Event Editor') etitle = _('Event Editor')
Utils.set_titles(self.window,title_label, etitle, Utils.set_titles(self.window, self.top.get_widget('title'),
_('Event Editor')) etitle, etitle)
self._create_tabbed_pages()
self._setup_fields()
self._connect_signals()
self.show()
def _connect_signals(self): def _connect_signals(self):
self.top.get_widget('button111').connect('clicked',self.close_window) self.top.get_widget('button111').connect('clicked',self.delete_event)
self.top.get_widget('button126').connect('clicked',self.on_help_clicked) self.top.get_widget('button126').connect('clicked',self.help_clicked)
ok = self.top.get_widget('ok') ok = self.top.get_widget('ok')
ok.set_sensitive(not self.db.readonly) ok.set_sensitive(not self.db.readonly)
ok.connect('clicked',self.on_event_edit_ok_clicked) ok.connect('clicked',self.save)
def _setup_fields(self): def _setup_fields(self):
self.place_field = PlaceEntry( self.place_field = PlaceEntry(
self.top.get_widget("eventPlace"), self.top.get_widget("eventPlace"),
self.event.get_place_handle(), self.obj.get_place_handle(),
self.dbstate.get_place_completion(), self.dbstate.get_place_completion(),
self.db.readonly) self.db.readonly)
self.cause_monitor = MonitoredEntry( self.cause_monitor = MonitoredEntry(
self.top.get_widget("eventCause"), self.top.get_widget("eventCause"),
self.event.set_cause, self.obj.set_cause,
self.event.get_cause, self.db.readonly) self.obj.get_cause, self.db.readonly)
self.descr_field = MonitoredEntry( self.descr_field = MonitoredEntry(
self.top.get_widget("event_description"), self.top.get_widget("event_description"),
self.event.set_description, self.obj.set_description,
self.event.get_description, self.db.readonly) self.obj.get_description, self.db.readonly)
self.priv = PrivacyButton( self.priv = PrivacyButton(
self.top.get_widget("private"), self.top.get_widget("private"),
self.event, self.db.readonly) self.obj, self.db.readonly)
self.event_menu = MonitoredType( self.event_menu = MonitoredType(
self.top.get_widget("personal_events"), self.top.get_widget("personal_events"),
self.event.set_type, self.obj.set_type,
self.event.get_type, self.obj.get_type,
dict(total_events), dict(total_events),
RelLib.Event.CUSTOM) RelLib.Event.CUSTOM)
self.date_field = MonitoredDate( self.date_field = MonitoredDate(
self.top.get_widget("eventDate"), self.top.get_widget("eventDate"),
self.top.get_widget("date_stat"), self.top.get_widget("date_stat"),
self.event.get_date_object(), self.obj.get_date_object(),
self.window, self.db.readonly) self.window, self.db.readonly)
def _add_page(self,page):
self.notebook.insert_page(page)
self.notebook.set_tab_label(page,page.get_tab_widget())
return page
def _create_tabbed_pages(self): def _create_tabbed_pages(self):
""" """
Creates the notebook tabs and inserts them into the main Creates the notebook tabs and inserts them into the main
window. window.
""" """
vbox = self.top.get_widget('vbox') notebook = gtk.Notebook()
self.notebook = gtk.Notebook()
self.srcref_list = self._add_tab(
notebook,
SourceEmbedList(self.dbstate,self.uistate, self.track,
self.obj.source_list))
self.note_tab = self._add_tab(
notebook,
NoteTab(self.dbstate, self.uistate, self.track,
self.obj.get_note_object()))
self.gallery_tab = self._add_tab(
notebook,
GalleryTab(self.dbstate, self.uistate, self.track,
self.obj.get_media_list()))
self.backref_tab = self._add_tab(
notebook,
EventBackRefList(self.dbstate, self.uistate, self.track,
self.dbstate.db.find_backlink_handles(self.obj.handle)))
self.srcref_list = self._add_page(SourceEmbedList( notebook.show_all()
self.dbstate,self.uistate, self.track, self.top.get_widget('vbox').pack_start(notebook,True)
self.event.source_list))
self.note_tab = self._add_page(NoteTab(
self.dbstate, self.uistate, self.track,
self.event.get_note_object()))
self.gallery_tab = self._add_page(GalleryTab(
self.dbstate, self.uistate, self.track,
self.event.get_media_list()))
self.backref_tab = self._add_page(EventBackRefList(
self.dbstate, self.uistate, self.track,
self.dbstate.db.find_backlink_handles(self.event.handle)))
self.notebook.show_all() def _cleanup_on_exit(self):
vbox.pack_start(self.notebook,True) self.backref_tab.close()
def build_menu_names(self,event): def build_menu_names(self,event):
if event: if event:
@ -192,60 +175,53 @@ class EventEditor(DisplayState.ManagedWindow):
submenu_label = _('New Event') submenu_label = _('New Event')
return (_('Event Editor'),submenu_label) return (_('Event Editor'),submenu_label)
def build_window_key(self,obj): def help_clicked(self,obj):
if obj:
return obj.get_handle()
else:
return id(self)
def on_delete_event(self,obj,b):
self.close()
def close_window(self,obj):
self.close()
self.window.destroy()
def on_help_clicked(self,obj):
"""Display the relevant portion of GRAMPS manual""" """Display the relevant portion of GRAMPS manual"""
GrampsDisplay.help('adv-ev') GrampsDisplay.help('adv-ev')
def on_event_edit_ok_clicked(self,obj): def save(self,*obj):
(need_new, handle) = self.place_field.get_place_info() (need_new, handle) = self.place_field.get_place_info()
if need_new: if need_new:
place_obj = RelLib.Place() place_obj = RelLib.Place()
place_obj.set_title(handle) place_obj.set_title(handle)
self.event.set_place_handle(place_obj.get_handle()) self.obj.set_place_handle(place_obj.get_handle())
else: else:
self.event.set_place_handle(handle) self.obj.set_place_handle(handle)
if self.event.handle == None: if self.obj.handle == None:
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
if need_new: if need_new:
self.db.add_place(place_obj,trans) self.db.add_place(place_obj,trans)
self.db.add_event(self.event,trans) self.db.add_event(self.obj,trans)
self.db.transaction_commit(trans,_("Add Event")) self.db.transaction_commit(trans,_("Add Event"))
else: else:
orig = self.dbstate.db.get_event_from_handle(self.event.handle) orig = self.dbstate.db.get_event_from_handle(self.obj.handle)
if cmp(self.event.serialize(),orig.serialize()): if cmp(self.obj.serialize(),orig.serialize()):
trans = self.db.transaction_begin() trans = self.db.transaction_begin()
if need_new: if need_new:
self.db.add_place(place_obj,trans) self.db.add_place(place_obj,trans)
self.db.commit_event(self.event,trans) self.db.commit_event(self.obj,trans)
self.db.transaction_commit(trans,_("Edit Event")) self.db.transaction_commit(trans,_("Edit Event"))
if self.callback: if self.callback:
self.callback(self.event) self.callback(self.obj)
self.close(obj) self.close(obj)
def commit(self,event,trans):
self.db.commit_event(event,trans)
def get_event_names(self): def get_event_names(self):
data = set(self.db.get_family_event_types()) data = set(self.db.get_family_event_types())
data.union(self.db.get_person_event_types()) data.union(self.db.get_person_event_types())
return list(data) return list(data)
def data_has_changed(self):
if self.db.readonly:
return False
elif self.obj.handle:
orig = self.db.get_event_from_handle(self.obj.handle)
return cmp(orig.serialize(),self.obj.serialize()) != 0
else:
return True
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Delete Query class # Delete Query class

15
src/EventView.py
View File

@ -114,10 +114,16 @@ class EventView(PageView.ListView):
def on_double_click(self,obj,event): def on_double_click(self,obj,event):
handle = self.first_selected() handle = self.first_selected()
the_event = self.dbstate.db.get_event_from_handle(handle) the_event = self.dbstate.db.get_event_from_handle(handle)
EventEdit.EventEditor(the_event,self.dbstate, self.uistate, []) try:
EventEdit.EventEditor(the_event,self.dbstate, self.uistate, [])
except Errors.WindowActiveError:
pass
def add(self,obj): def add(self,obj):
EventEdit.EventEditor(RelLib.Event(),self.dbstate, self.uistate, []) try:
EventEdit.EventEditor(RelLib.Event(),self.dbstate, self.uistate, [])
except Errors.WindowActiveError:
pass
def remove(self,obj): def remove(self,obj):
for event_handle in self.selected_handles(): for event_handle in self.selected_handles():
@ -155,5 +161,8 @@ class EventView(PageView.ListView):
for handle in mlist: for handle in mlist:
event = self.dbstate.db.get_event_from_handle(handle) event = self.dbstate.db.get_event_from_handle(handle)
EventEdit.EventEditor(event, self.dbstate, self.uistate) try:
EventEdit.EventEditor(event, self.dbstate, self.uistate)
except Errors.WindowActiveError:
pass

11
src/FamilyList.py
View File

@ -37,6 +37,7 @@ import PageView
import DisplayModels import DisplayModels
import const import const
import Utils import Utils
import Errors
from QuestionDialog import QuestionDialog, ErrorDialog from QuestionDialog import QuestionDialog, ErrorDialog
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -114,7 +115,10 @@ class FamilyListView(PageView.ListView):
def add(self,obj): def add(self,obj):
import EditFamily import EditFamily
family = RelLib.Family() family = RelLib.Family()
EditFamily.EditFamily(self.dbstate,self.uistate,[],family) try:
EditFamily.EditFamily(self.dbstate,self.uistate,[],family)
except Errors.WindowActiveError:
pass
def remove(self,obj): def remove(self,obj):
return return
@ -126,4 +130,7 @@ class FamilyListView(PageView.ListView):
for handle in mlist: for handle in mlist:
import EditFamily import EditFamily
family = self.dbstate.db.get_family_from_handle(handle) family = self.dbstate.db.get_family_from_handle(handle)
EditFamily.EditFamily(self.dbstate,self.uistate,[],family) try:
EditFamily.EditFamily(self.dbstate,self.uistate,[],family)
except Errors.WindowActiveError:
pass

21
src/FamilyView.py
View File

@ -31,6 +31,7 @@ import ImgManip
import ReportUtils import ReportUtils
import GrampsKeys import GrampsKeys
import GrampsWidgets import GrampsWidgets
import Errors
_GenderCode = { _GenderCode = {
RelLib.Person.MALE : u'\u2642', RelLib.Person.MALE : u'\u2642',
@ -556,24 +557,36 @@ class FamilyView(PageView.PersonNavView):
if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1: if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1:
import EditPerson import EditPerson
person = self.dbstate.db.get_person_from_handle(handle) person = self.dbstate.db.get_person_from_handle(handle)
EditPerson.EditPerson(self.dbstate, self.uistate, [], person) try:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person)
except Errors.WindowActiveError:
pass
def edit_person(self,obj,handle): def edit_person(self,obj,handle):
import EditPerson import EditPerson
person = self.dbstate.db.get_person_from_handle(handle) person = self.dbstate.db.get_person_from_handle(handle)
EditPerson.EditPerson(self.dbstate, self.uistate, [], person) try:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person)
except Errors.WindowActiveError:
pass
def edit_family(self,obj,event,handle): def edit_family(self,obj,event,handle):
if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1: if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1:
import EditFamily import EditFamily
family = self.dbstate.db.get_family_from_handle(handle) family = self.dbstate.db.get_family_from_handle(handle)
EditFamily.EditFamily(self.dbstate,self.uistate,[],family) try:
EditFamily.EditFamily(self.dbstate,self.uistate,[],family)
except Errors.WindowActiveError:
pass
def add_family(self,obj,event,handle): def add_family(self,obj,event,handle):
if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1: if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1:
import EditFamily import EditFamily
family = RelLib.Family() family = RelLib.Family()
EditFamily.EditFamily(self.dbstate,self.uistate,[],family) try:
EditFamily.EditFamily(self.dbstate,self.uistate,[],family)
except Errors.WindowActiveError:
pass
def delete_family(self,obj,event,handle): def delete_family(self,obj,event,handle):
if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1: if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1:

24
src/GrampsWidgets.py
View File

@ -236,12 +236,12 @@ class MonitoredCheckbox:
self.obj = obj self.obj = obj
self.set_val = set_val self.set_val = set_val
self.get_val = get_val self.get_val = get_val
self.set_active(get_val()) self.obj.set_active(get_val())
def _on_toggle(self,obj): def _on_toggle(self,obj):
self.set_val(obj.get_active()) self.set_val(obj.get_active())
if self.on_toggle: if self.on_toggle:
self.on_toggle(get_val()) self.on_toggle(self.get_val())
class MonitoredEntry: class MonitoredEntry:
@ -256,6 +256,9 @@ class MonitoredEntry:
self.obj.connect('changed', self._on_change) self.obj.connect('changed', self._on_change)
self.obj.set_editable(not read_only) self.obj.set_editable(not read_only)
def connect(self,signal,callback):
self.obj.connect(signal,callback)
def _on_change(self,obj): def _on_change(self,obj):
self.set_val(unicode(obj.get_text())) self.set_val(unicode(obj.get_text()))
if self.changed: if self.changed:
@ -264,10 +267,20 @@ class MonitoredEntry:
def force_value(self,value): def force_value(self,value):
self.obj.set_text(value) self.obj.set_text(value)
def get_value(self,value):
return unicode(self.obj.get_text())
def enable(self,value): def enable(self,value):
self.obj.set_sensitive(value) self.obj.set_sensitive(value)
self.obj.set_editable(value) self.obj.set_editable(value)
def grab_focus(self):
self.obj.grab_focus()
def update(self):
if self.get_val():
self.obj.set_text(self.get_val())
class MonitoredText: class MonitoredText:
def __init__(self,obj,set_val,get_val,read_only=False): def __init__(self,obj,set_val,get_val,read_only=False):
@ -304,6 +317,10 @@ class MonitoredType:
self.obj.set_sensitive(not readonly) self.obj.set_sensitive(not readonly)
self.obj.connect('changed', self.on_change) self.obj.connect('changed', self.on_change)
def update(self):
if self.get_val():
self.sel.set_values(self.get_val())
def on_change(self, obj): def on_change(self, obj):
self.set_val(self.sel.get_values()) self.set_val(self.sel.get_values())
@ -322,6 +339,9 @@ class MonitoredMenu:
self.obj.connect('changed',self.on_change) self.obj.connect('changed',self.on_change)
self.obj.set_sensitive(not readonly) self.obj.set_sensitive(not readonly)
def force(self,value):
self.obj.set_active(value)
def on_change(self, obj): def on_change(self, obj):
self.set_val(self.model.get_value(obj.get_active_iter(),1)) self.set_val(self.model.get_value(obj.get_active_iter(),1))

1
src/LocEdit.py
View File

@ -35,7 +35,6 @@ import gtk.glade
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import const import const
import Utils import Utils
import RelLib
import GrampsDisplay import GrampsDisplay
import DisplayState import DisplayState

7
src/NameEdit.py
View File

@ -43,13 +43,8 @@ import gtk.glade
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import const import const
import Utils import Utils
import AutoComp
import Sources
import RelLib import RelLib
import NameDisplay import NameDisplay
import DateEdit
import DateHandler
import Spell
import GrampsDisplay import GrampsDisplay
import DisplayState import DisplayState
from DisplayTabs import * from DisplayTabs import *
@ -71,8 +66,6 @@ class NameEditor(DisplayState.ManagedWindow):
self.callback = callback self.callback = callback
DisplayState.ManagedWindow.__init__(self, uistate, track, name) DisplayState.ManagedWindow.__init__(self, uistate, track, name)
if self.already_exist:
return
self.name = name self.name = name
self.original_group_as = self.name.get_group_as() self.original_group_as = self.name.get_group_as()

13
src/PedView.py
View File

@ -908,7 +908,11 @@ class PedView(PageView.PersonNavView):
def edit_person_cb(self,obj,person_handle): def edit_person_cb(self,obj,person_handle):
person = self.db.get_person_from_handle(person_handle) person = self.db.get_person_from_handle(person_handle)
if person: if person:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person, self.person_edited_cb) try:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person,
self.person_edited_cb)
except Errors.WindowActiveError:
pass
return True return True
return False return False
@ -929,7 +933,12 @@ class PedView(PageView.PersonNavView):
if event.button==1 and event.type == gtk.gdk._2BUTTON_PRESS: if event.button==1 and event.type == gtk.gdk._2BUTTON_PRESS:
person = self.db.get_person_from_handle(person_handle) person = self.db.get_person_from_handle(person_handle)
if person: if person:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person, self.person_edited_cb) try:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person,
self.person_edited_cb)
except Errors.WindowActiveError:
pass
elif event.button!=1: elif event.button!=1:
self.build_full_nav_menu_cb(obj,event,person_handle) self.build_full_nav_menu_cb(obj,event,person_handle)
return True return True

18
src/PersonView.py
View File

@ -53,6 +53,7 @@ import NameDisplay
import Utils import Utils
import QuestionDialog import QuestionDialog
import TreeTips import TreeTips
import Errors
from DdTargets import DdTargets from DdTargets import DdTargets
@ -349,12 +350,18 @@ class PersonView(PageView.PersonNavView):
def add(self,obj): def add(self,obj):
person = RelLib.Person() person = RelLib.Person()
EditPerson.EditPerson(self.dbstate, self.uistate, [], person) try:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person)
except Errors.WindowActiveError:
pass
def edit(self,obj): def edit(self,obj):
if self.dbstate.active: if self.dbstate.active:
EditPerson.EditPerson(self.dbstate, self.uistate, [], try:
self.dbstate.active) EditPerson.EditPerson(self.dbstate, self.uistate, [],
self.dbstate.active)
except Errors.WindowActiveError:
pass
def remove(self,obj): def remove(self,obj):
mlist = self.get_selected_objects() mlist = self.get_selected_objects()
@ -608,7 +615,10 @@ class PersonView(PageView.PersonNavView):
handle = self.first_selected() handle = self.first_selected()
person = self.dbstate.db.get_person_from_handle(handle) person = self.dbstate.db.get_person_from_handle(handle)
if person: if person:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person) try:
EditPerson.EditPerson(self.dbstate, self.uistate, [], person)
except Errors.WindowActiveError:
pass
return True return True
elif event.type == gtk.gdk.BUTTON_PRESS and event.button == 3: elif event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
menu = self.uistate.uimanager.get_widget('/Popup') menu = self.uistate.uimanager.get_widget('/Popup')

16
src/PlaceView.py
View File

@ -38,6 +38,7 @@ import EditPlace
import DisplayModels import DisplayModels
import const import const
import Utils import Utils
import Errors
from QuestionDialog import QuestionDialog, ErrorDialog from QuestionDialog import QuestionDialog, ErrorDialog
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -118,10 +119,16 @@ class PlaceView(PageView.ListView):
def on_double_click(self,obj,event): def on_double_click(self,obj,event):
handle = self.first_selected() handle = self.first_selected()
place = self.dbstate.db.get_place_from_handle(handle) place = self.dbstate.db.get_place_from_handle(handle)
EditPlace.EditPlace(self.dbstate,self.uistate,[],place) try:
EditPlace.EditPlace(self.dbstate,self.uistate,[],place)
except Errors.WindowActiveError:
pass
def add(self,obj): def add(self,obj):
EditPlace.EditPlace(self.dbstate,self.uistate,[],RelLib.Place()) try:
EditPlace.EditPlace(self.dbstate,self.uistate,[],RelLib.Place())
except Errors.WindowActiveError:
pass
def remove(self,obj): def remove(self,obj):
for event_handle in self.selected_handles(): for event_handle in self.selected_handles():
@ -159,5 +166,8 @@ class PlaceView(PageView.ListView):
for handle in mlist: for handle in mlist:
place = self.dbstate.db.get_place_from_handle(handle) place = self.dbstate.db.get_place_from_handle(handle)
EditPlace.EditPlace(self.dbstate,self.uistate,[],place) try:
EditPlace.EditPlace(self.dbstate,self.uistate,[],place)
except Errors.WindowActiveError:
pass

6
src/Plugins.py
View File

@ -94,8 +94,7 @@ class PluginDialog(DisplayState.ManagedWindow):
self.content = content self.content = content
DisplayState.ManagedWindow.__init__(self, uistate, [], None) DisplayState.ManagedWindow.__init__(self, uistate, [], None)
if self.already_exist:
return
self.state = state self.state = state
self.uistate = uistate self.uistate = uistate
@ -315,8 +314,7 @@ class PluginStatus(DisplayState.ManagedWindow):
import cStringIO import cStringIO
DisplayState.ManagedWindow.__init__(self, uistate, [], None) DisplayState.ManagedWindow.__init__(self, uistate, [], None)
if self.already_exist:
return
self.state = state self.state = state
self.uistate = uistate self.uistate = uistate

3
src/UrlEdit.py
View File

@ -26,7 +26,6 @@
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
from gettext import gettext as _ from gettext import gettext as _
import gc
from cgi import escape from cgi import escape
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -65,8 +64,6 @@ class UrlEditor(DisplayState.ManagedWindow):
self.name = name self.name = name
DisplayState.ManagedWindow.__init__(self, uistate, track, url) DisplayState.ManagedWindow.__init__(self, uistate, track, url)
if self.already_exist:
return
self.url = url self.url = url
self.callback = callback self.callback = callback

5
src/Utils.py
View File

@ -654,8 +654,9 @@ def set_title_label(xmlobj,t):
title_label.set_use_markup(True) title_label.set_use_markup(True)
def set_titles(window,title,t,msg=None): def set_titles(window,title,t,msg=None):
title.set_text('<span weight="bold" size="larger">%s</span>' % t) if title:
title.set_use_markup(True) title.set_text('<span weight="bold" size="larger">%s</span>' % t)
title.set_use_markup(True)
if msg: if msg:
window.set_title('%s - GRAMPS' % msg) window.set_title('%s - GRAMPS' % msg)
else: else:

24
src/const.py.in
View File

@ -22,6 +22,14 @@
# $Id$ # $Id$
#-------------------------------------------------------------------------
#
# Standard python modules
#
#-------------------------------------------------------------------------
import os
from gettext import gettext as _
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Standard GRAMPS Websites # Standard GRAMPS Websites
@ -31,14 +39,6 @@ url_homepage = "http://gramps-project.org/"
url_mailinglist = "http://sourceforge.net/mail/?group_id=25770" url_mailinglist = "http://sourceforge.net/mail/?group_id=25770"
url_burtracker = "http://sourceforge.net/tracker/?group_id=25770&atid=385137" url_burtracker = "http://sourceforge.net/tracker/?group_id=25770&atid=385137"
#-------------------------------------------------------------------------
#
# Standard python modules
#
#-------------------------------------------------------------------------
import os
from gettext import gettext as _
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Mime Types # Mime Types
@ -88,14 +88,8 @@ no_gconf = False
# this one, and that the plugins directory is in a directory below this. # this one, and that the plugins directory is in a directory below this.
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
if os.environ.has_key('GRAMPSDIR'):
rootDir = os.environ['GRAMPSDIR']
else:
rootDir = os.getcwd()
good_xpm = os.path.join(rootDir,"good.png") rootDir = os.path.abspath(os.path.dirname(__file__))
bad_xpm = os.path.join(rootDir,"bad.png")
caution_xpm = os.path.join(rootDir,"caution.png")
system_filters = os.path.join(rootDir,"system_filters.xml") system_filters = os.path.join(rootDir,"system_filters.xml")
custom_filters = "~/.gramps/custom_filters.xml" custom_filters = "~/.gramps/custom_filters.xml"

14
src/gramps.glade
View File

@ -4,7 +4,7 @@
<glade-interface> <glade-interface>
<requires lib="gnome"/> <requires lib="gnome"/>
<widget class="GtkDialog" id="sourceEditor"> <widget class="GtkDialog" id="source_editor">
<property name="visible">True</property> <property name="visible">True</property>
<property name="title" translatable="yes"></property> <property name="title" translatable="yes"></property>
<property name="type">GTK_WINDOW_TOPLEVEL</property> <property name="type">GTK_WINDOW_TOPLEVEL</property>
@ -68,7 +68,7 @@
</child> </child>
<child> <child>
<widget class="GtkButton" id="button166"> <widget class="GtkButton" id="help">
<property name="visible">True</property> <property name="visible">True</property>
<property name="can_default">True</property> <property name="can_default">True</property>
<property name="can_focus">True</property> <property name="can_focus">True</property>
@ -492,7 +492,7 @@
</child> </child>
</widget> </widget>
<widget class="GtkDialog" id="marriageEditor"> <widget class="GtkDialog" id="family_editor">
<property name="visible">True</property> <property name="visible">True</property>
<property name="title" translatable="yes"></property> <property name="title" translatable="yes"></property>
<property name="type">GTK_WINDOW_TOPLEVEL</property> <property name="type">GTK_WINDOW_TOPLEVEL</property>
@ -1370,7 +1370,7 @@
</child> </child>
</widget> </widget>
<widget class="GtkDialog" id="placeEditor"> <widget class="GtkDialog" id="place_editor">
<property name="visible">True</property> <property name="visible">True</property>
<property name="title" translatable="yes"></property> <property name="title" translatable="yes"></property>
<property name="type">GTK_WINDOW_TOPLEVEL</property> <property name="type">GTK_WINDOW_TOPLEVEL</property>
@ -1403,7 +1403,7 @@
<property name="layout_style">GTK_BUTTONBOX_END</property> <property name="layout_style">GTK_BUTTONBOX_END</property>
<child> <child>
<widget class="GtkButton" id="button127"> <widget class="GtkButton" id="cancel">
<property name="visible">True</property> <property name="visible">True</property>
<property name="can_default">True</property> <property name="can_default">True</property>
<property name="can_focus">True</property> <property name="can_focus">True</property>
@ -1432,7 +1432,7 @@
</child> </child>
<child> <child>
<widget class="GtkButton" id="button135"> <widget class="GtkButton" id="help">
<property name="visible">True</property> <property name="visible">True</property>
<property name="can_default">True</property> <property name="can_default">True</property>
<property name="can_focus">True</property> <property name="can_focus">True</property>
@ -12995,7 +12995,7 @@ Text Beside Icons</property>
</child> </child>
</widget> </widget>
<widget class="GtkDialog" id="repositoryEditor"> <widget class="GtkDialog" id="repository_editor">
<property name="visible">True</property> <property name="visible">True</property>
<property name="title" translatable="yes"></property> <property name="title" translatable="yes"></property>
<property name="type">GTK_WINDOW_TOPLEVEL</property> <property name="type">GTK_WINDOW_TOPLEVEL</property>

5
src/gramps.py
View File

@ -48,6 +48,11 @@ import gtk.gdk
import gtk import gtk
import gtk.glade import gtk.glade
# setup import path
sys.path.append(os.path.abspath(os.path.basename(__file__)))
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Load internationalization setup # Load internationalization setup