Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2006-08-03 Alex Roitman <shura@gramps-project.org>

Browse Source 
* src/Filters/Rules/Person/_HasIdOf.py: Cleanup.
	* src/Filters/Rules/Person/__init__.py (editor_rule_list): Add
	RegExpIdOf.
	* src/Filters/Rules/Person/_RegExpIdOf.py: Cleanup.
	* src/Filters/Rules/_RegExpIdBase.py: Cleanup.
	* src/Filters/Rules/Person/_HasRelationship.py: Cleanup.
	* src/Filters/Rules/Family/_HasIdOf.py: Cleanup.
	* src/Filters/Rules/Family/_RegExpIdOf.py: Cleanup.
	* src/FilterEditor/_EditRule.py: Clean, localization fixes, ID
	selection fixes.
	* src/NameDisplay.py: Import gettext.
	* src/Filters/Rules/Family/_HasRelType.py (labels): Use lowercase.
	* src/FilterEditor/_EditFilter.py (on_add_clicked,
	on_edit_clicked): Catch exception.



svn: r7115
This commit is contained in:
Alex Roitman 2006-08-03 19:49:29 +00:00
parent 5af5a2a3c2
commit 7c5077280c
11 changed files with 146 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
ChangeLog
View File

@ -1,3 +1,19 @@
2006-08-03 Alex Roitman <shura@gramps-project.org>
* src/Filters/Rules/Person/_HasIdOf.py: Cleanup.
* src/Filters/Rules/Person/__init__.py (editor_rule_list): Add
RegExpIdOf.
* src/Filters/Rules/Person/_RegExpIdOf.py: Cleanup.
* src/Filters/Rules/_RegExpIdBase.py: Cleanup.
* src/Filters/Rules/Person/_HasRelationship.py: Cleanup.
* src/Filters/Rules/Family/_HasIdOf.py: Cleanup.
* src/Filters/Rules/Family/_RegExpIdOf.py: Cleanup.
* src/FilterEditor/_EditRule.py: Clean, localization fixes, ID
selection fixes.
* src/NameDisplay.py: Import gettext.
* src/Filters/Rules/Family/_HasRelType.py (labels): Use lowercase.
* src/FilterEditor/_EditFilter.py (on_add_clicked,
on_edit_clicked): Catch exception.
2006-08-03 Zsolt Foldvari <zfoldvar@users.sourceforge.net>
* src/plugins/Check.py (cleanup_deleted_name_formats): Change hardcoded
values with constants.

15
src/FilterEditor/_EditFilter.py
View File

@ -50,6 +50,7 @@ import const
import ListModel
import ManagedWindow
import GrampsDisplay
import Errors
#-------------------------------------------------------------------------
#
@ -165,8 +166,11 @@ class EditFilter(ManagedWindow.ManagedWindow):
def on_add_clicked(self,obj):
from _EditRule import EditRule
EditRule(self.space, self.dbstate, self.uistate, self.track,
self.filterdb, None, _('Add Rule'), self.update_rule)
try:
EditRule(self.space, self.dbstate, self.uistate, self.track,
self.filterdb, None, _('Add Rule'), self.update_rule)
except Errors.WindowActiveError:
pass
def on_edit_clicked(self,obj):
store, node = self.rlist.get_selected()
@ -175,8 +179,11 @@ class EditFilter(ManagedWindow.ManagedWindow):
d = self.rlist.get_object(node)
EditRule(self.space, self.dbstate, self.uistate, self.track,
self.filterdb, d, _('Edit Rule'), self.update_rule)
try:
EditRule(self.space, self.dbstate, self.uistate, self.track,
self.filterdb, d, _('Edit Rule'), self.update_rule)
except Errors.WindowActiveError:
pass
def update_rule(self, old_rule, new_rule):
if old_rule:

151
src/FilterEditor/_EditRule.py
View File

@ -48,19 +48,20 @@ log = logging.getLogger(".FilterEdit")
#-------------------------------------------------------------------------
import gtk
import gobject
import GrampsDisplay
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
import GrampsDisplay
import const
import RelLib
from Filters import Rules
import AutoComp
from Selectors import selector_factory
SelectPerson = selector_factory('Person')
from NameDisplay import displayer as _nd
import Utils
import ManagedWindow
#-------------------------------------------------------------------------
@ -76,17 +77,14 @@ def by_rule_name(f,s):
# Constants
#
#-------------------------------------------------------------------------
_name2list = {
_('Personal event:') : RelLib.EventType().get_map(),
_('Family event:') : RelLib.EventType().get_map(),
_('Personal attribute:') : RelLib.AttributeType().get_map(),
_('Family attribute:') : RelLib.AttributeType().get_map(),
_name2typeclass = {
_('Personal event:') : RelLib.EventType,
_('Family event:') : RelLib.EventType,
_('Personal attribute:') : RelLib.AttributeType,
_('Family attribute:') : RelLib.AttributeType,
_('Relationship type:') : RelLib.FamilyRelType,
}
_menulist = {
_('Relationship type:') : RelLib.FamilyRelType().get_map(),
}
#-------------------------------------------------------------------------
#
# MyBoolean - check button with standard interface
@ -99,10 +97,19 @@ class MyBoolean(gtk.CheckButton):
self.show()
def get_text(self):
"""
This method returns the text to save. It should be the same
no matter the present locale (English or numeric types).
This class sets this to get_display_text, but when localization
is an issue (events/attr/etc types) then it has to be overridden.
"""
return str(int(self.get_active()))
def set_text(self,val):
is_active = not not int(val)
"""
This method sets the selector state to display the passed value.
"""
is_active = bool(int(val))
self.set_active(is_active)
#-------------------------------------------------------------------------
@ -210,14 +217,25 @@ class MyPlaces(gtk.Entry):
#
#-------------------------------------------------------------------------
class MyID(gtk.HBox):
obj_name = {
'Person' : _('Person'),
'Family' : _('Family'),
'Event' : _('Event'),
'Place' : _('Place'),
'Source' : _('Source'),
'MediaObject' : _('Media Object'),
'Repository' : _('Repository'),
}
def __init__(self, dbstate, uistate, track):
def __init__(self, dbstate, uistate, track, obj_class='Person'):
gtk.HBox.__init__(self,False,6)
self.dbstate = dbstate
self.db = dbstate.db
self.uistate = uistate
self.track = track
self.obj_class = obj_class
self.entry = gtk.Entry()
self.entry.show()
self.button = gtk.Button()
@ -227,14 +245,15 @@ class MyID(gtk.HBox):
self.pack_start(self.entry)
self.add(self.button)
self.tooltips = gtk.Tooltips()
self.tooltips.set_tip(self.button,_('Select person from a list'))
self.tooltips.set_tip(self.button,_('Select %s from a list')
% self.obj_name[obj_class])
self.tooltips.enable()
self.show()
self.set_text('')
def button_press(self,obj):
inst = SelectPerson(self.dbstate, self.uistate, self.track,
_('Select Person'))
selector = selector_factory(self.obj_class)
inst = selector(self.dbstate, self.uistate, self.track)
val = inst.run()
if val == None:
self.set_text('')
@ -244,13 +263,37 @@ class MyID(gtk.HBox):
def get_text(self):
return unicode(self.entry.get_text())
def name_from_gramps_id(self,gramps_id):
if self.obj_class == 'Person':
person = self.db.get_person_from_gramps_id(gramps_id)
print gramps_id
name = _nd.display_name(person.get_primary_name())
elif self.obj_class == 'Family':
family = self.db.get_family_from_gramps_id(gramps_id)
name = Utils.family_name(family, self.db)
elif self.obj_class == 'Event':
event = self.db.get_event_from_gramps_id(gramps_id)
name = str(event.get_type)
elif self.obj_class == 'Place':
place = self.db.get_place_from_gramps_id(gramps_id)
name = place.get_title()
elif self.obj_class == 'Source':
source = self.db.get_source_from_gramps_id(gramps_id)
name = source.get_title()
elif self.obj_class == 'MediaObject':
obj = self.db.get_object_from_gramps_id(gramps_id)
name = obj.get_path()
elif self.obj_class == 'Repository':
repo = self.db.get_repository_from_gramps_id(gramps_id)
name = repo.get_name()
return name
def set_text(self,val):
try:
p = self.db.get_person_from_handle(val)
n = p.get_primary_name().get_name()
self.tooltips.set_tip(self.entry,n)
except:
self.tooltips.set_tip(self.entry,_('Not a valid person'))
name = self.name_from_gramps_id(val)
self.tooltips.set_tip(self.entry,name)
except AttributeError:
self.tooltips.set_tip(self.entry,_('Not a valid ID'))
self.entry.set_text(val)
#-------------------------------------------------------------------------
@ -260,48 +303,21 @@ class MyID(gtk.HBox):
#-------------------------------------------------------------------------
class MySelect(gtk.ComboBoxEntry):
def __init__(self, values):
def __init__(self, type_class):
gtk.ComboBoxEntry.__init__(self)
AutoComp.fill_combo(self, values)
self.type_class = type_class
self.sel = AutoComp.StandardCustomSelector(type_class._I2SMAP, self,
type_class._CUSTOM,
type_class._DEFAULT)
self.show()
def get_text(self):
return unicode(self.child.get_text())
return self.type_class(self.sel.get_values()).xml_str()
def set_text(self,val):
self.child.set_text(_(val))
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
class MyListSelect(gtk.ComboBox):
def __init__(self,data_list):
gtk.ComboBox.__init__(self)
store = gtk.ListStore(str)
self.set_model(store)
cell = gtk.CellRendererText()
self.pack_start(cell,True)
self.add_attribute(cell,'text',0)
self.data_list = data_list
for item in data_list:
store.append(row=[item])
self.set_active(0)
self.show()
def get_text(self):
active = self.get_active()
if active < 0:
return str(-1)
return str(active)
def set_text(self,val):
active = int(val)
if active >=0:
self.set_active(active)
tc = self.type_class()
tc.set_from_xml_str(val)
self.sel.set_values((tc.val,tc.string))
#-------------------------------------------------------------------------
#
@ -379,26 +395,23 @@ class EditRule(ManagedWindow.ManagedWindow):
table.set_row_spacings(6)
table.show()
for v in arglist:
v1 = _(v)
l = gtk.Label(v1)
l = gtk.Label(v)
l.set_alignment(1,0.5)
l.show()
if v == _('Place:'):
t = MyPlaces([])
elif v == _('Number of generations:'):
t = MyInteger(1,32)
elif v == _('ID:'):
t = MyID(self.dbstate, self.uistate, self.track)
elif v == _('Person ID:'):
t = MyID(self.dbstate, self.uistate, self.track, 'Person')
elif v == _('Family ID:'):
t = MyID(self.dbstate, self.uistate, self.track, 'Family')
elif v == _('Source ID:'):
t = MySource(self.db)
elif v == _('Filter name:'):
t = MyFilters(self.filterdb.get_filters(self.space))
elif _name2list.has_key(v1):
data =_name2list[v1]
t = MySelect(data.values())
elif _menulist.has_key(v1):
data =_menulist[v1]
t = MyListSelect(data.values())
elif _name2typeclass.has_key(v):
t = MySelect(_name2typeclass[v])
elif v == _('Inclusive:'):
t = MyBoolean(_('Include original person'))
elif v == _('Case sensitive:'):
@ -516,8 +529,8 @@ class EditRule(ManagedWindow.ManagedWindow):
page = self.notebook.get_current_page()
(class_obj,vallist,tlist) = self.page[page]
value_list = []
for x in tlist:
value_list.append(unicode(x.get_text()))
for selector_class in tlist:
value_list.append(unicode(selector_class.get_text()))
new_rule = class_obj(value_list)
self.update_rule(self.active_rule, new_rule)

6
src/Filters/Rules/Family/_HasIdOf.py
View File

@ -40,10 +40,8 @@ from Filters.Rules import HasGrampsId
#
#-------------------------------------------------------------------------
class HasIdOf(HasGrampsId):
"""Rule that checks for a person with a specific GRAMPS ID"""
"""Rule that checks for a family with a specific GRAMPS ID"""
labels = [ _('ID:') ]
labels = [ _('Family ID:') ]
name = _('Family with <Id>')
description = _("Matches a family with a specified GRAMPS ID")
category = _('General filters')

2
src/Filters/Rules/Family/_HasRelType.py
View File

@ -42,7 +42,7 @@ from Filters.Rules._Rule import Rule
class HasRelType(Rule):
"""Rule that checks for a person with a particular personal attribute"""
labels = [ _('Relationship Type:') ]
labels = [ _('Relationship type:') ]
name = _('Family with the relationship type')
description = _("Matches family with the relationship type "
"of a particular value")

12
src/Filters/Rules/Family/_RegExpIdOf.py
View File

@ -26,7 +26,6 @@
#
#-------------------------------------------------------------------------
from gettext import gettext as _
import re
#-------------------------------------------------------------------------
#
@ -41,8 +40,11 @@ from Filters.Rules._RegExpIdBase import RegExpIdBase
#
#-------------------------------------------------------------------------
class RegExpIdOf(RegExpIdBase):
"""Rule that checks for a person with a specific GRAMPS ID"""
name = _('Families with <Id>')
description = _("Matches families with a GRAMPS ID that contains the regular expression")
"""
Rule that checks for a family whose GRAMPS ID
matches regular expression.
"""
name = _('Families with <Id> matching regular expression')
description = _("Matches families whose GRAMPS ID matches "
"the regular expression")

4
src/Filters/Rules/Person/_HasIdOf.py
View File

@ -42,8 +42,6 @@ from Filters.Rules import HasGrampsId
class HasIdOf(HasGrampsId):
"""Rule that checks for a person with a specific GRAMPS ID"""
labels = [ _('ID:') ]
labels = [ _('Person ID:') ]
name = _('People with <Id>')
description = _("Matches people with a specified GRAMPS ID")
category = _('General filters')

27
src/Filters/Rules/Person/_RegExpIdOf.py
View File

@ -26,35 +26,24 @@
#
#-------------------------------------------------------------------------
from gettext import gettext as _
import re
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules._Rule import Rule
from Filters.Rules._RegExpIdBase import RegExpIdBase
#-------------------------------------------------------------------------
#
# HasIdOf
#
#-------------------------------------------------------------------------
class RegExpIdOf(Rule):
"""Rule that checks for a person with a specific GRAMPS ID"""
class RegExpIdOf(RegExpIdBase):
"""Rule that checks for a person whose GRAMPS ID
matches regular expression.
"""
labels = [ _('ID:') ]
name = _('People with <Id>')
description = _("Matches people with a GRAMPS ID that contains the regular expression")
category = _('General filters')
def __init__(self, list):
Rule.__init__(self, list)
try:
self.match = re.compile(list[0],re.I|re.U|re.L)
except:
self.match = re.compile('')
def apply(self,db,person):
return self.match.match(person.gramps_id) != None
name = _('People with <Id> matching regular expression')
description = _("Matches people whose GRAMPS ID matches "
"the regular expression")

1
src/Filters/Rules/Person/__init__.py
View File

@ -151,6 +151,7 @@ editor_rule_list = [
HasTextMatchingSubstringOf,
HasNote,
HasNoteRegexp,
RegExpIdOf,
]
def register(rule):

16
src/Filters/Rules/_RegExpIdBase.py
View File

@ -41,11 +41,15 @@ from _Rule import Rule
#
#-------------------------------------------------------------------------
class RegExpIdBase(Rule):
"""Rule that checks for a person with a specific GRAMPS ID"""
"""
Rule that checks for an object whose GRAMPS ID
matches regular expression.
"""
labels = [ _('ID:') ]
name = _('Families with <Id>')
description = _("Matches families with a GRAMPS ID that contains the regular expression")
labels = [ _('Regular expression:') ]
name = _('Objects with <Id>')
description = _("Matches objects whose GRAMPS ID matches "
"the regular expression")
category = _('General filters')
def __init__(self, list):
@ -56,5 +60,5 @@ class RegExpIdBase(Rule):
except:
self.match = re.compile('')
def apply(self,db,person):
return self.match.match(person.gramps_id) != None
def apply(self,db,obj):
return self.match.match(obj.gramps_id) != None

7
src/NameDisplay.py
View File

@ -24,6 +24,13 @@
Class handling language-specific displaying of names.
"""
#-------------------------------------------------------------------------
#
# Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules