Elimination of redundant code, new registering method for plugins

svn: r367

src/filters/After.py

@@ -62,26 +62,7 @@ class EventAfter(Filter.Filter):
                 break
         return val
 
-#------------------------------------------------------------------------
-#
-# 
-#
-#------------------------------------------------------------------------
-def get_name():
-    return _("People with an event after ...")
+Filter.register_filter(EventAfter,
+                       description=_("People with an event after ..."),
+                       qualifier=1)
 
-#------------------------------------------------------------------------
-#
-# 
-#
-#------------------------------------------------------------------------
-def create(text):
-    return EventAfter(text)
-
-#------------------------------------------------------------------------
-#
-# 
-#
-#------------------------------------------------------------------------
-def need_qualifier():
-    return 1

src/filters/AltFam.py

@@ -33,11 +33,8 @@ class HaveAltFamilies(Filter.Filter):
     def match(self,person):
         return len(person.getAltFamilyList()) > 0
 
-def create(text):
-    return HaveAltFamilies(text)
 
-def need_qualifier():
-    return 0
+Filter.register_filter(HaveAltFamilies,
+                       description=_("People who were adopted"),
+                       qualifier=0)
 
-def get_name():
-    return _("People who were adopted")

src/filters/Before.py

@@ -68,21 +68,7 @@ class EventBefore(Filter.Filter):
 # 
 #
 #------------------------------------------------------------------------
-def create(text):
-    return EventBefore(text)
+Filter.register_filter(EventBefore,
+                       description=_("People with an event before ..."),
+                       qualifier=1)
 
-#------------------------------------------------------------------------
-#
-# 
-#
-#------------------------------------------------------------------------
-def need_qualifier():
-    return 1
-
-#------------------------------------------------------------------------
-#
-# 
-#
-#------------------------------------------------------------------------
-def get_name():
-    return _("People with an event before ...")

src/filters/Disconnected.py

@@ -31,11 +31,12 @@ class Disconnected(Filter.Filter):
     def match(self,person):
         return person.getMainFamily() == None and len(person.getFamilyList()) == 0
 
-def create(text):
-    return Disconnected(text)
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(Disconnected,
+                       description= _("Disconnected individuals"),
+                       qualifier=0)
 
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("Disconnected individuals")

src/filters/EventPlace.py

@@ -49,11 +49,11 @@ class EventPlace(Filter.Filter):
                 break
         return val
 
-def create(text):
-    return EventPlace(text)
-
-def need_qualifier():
-    return 1
-
-def get_name():
-    return _("People with an event location of ...")
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(EventPlace,
+                       description=_("People with an event location of ..."),
+                       qualifier=1)

src/filters/EventType.py

@@ -33,11 +33,11 @@ class EventType(Filter.Filter):
                 return 1
         return 0
     
-def create(text):
-    return EventType(text)
-
-def need_qualifier():
-    return 1
-
-def get_name():
-    return _("People who have an event type of ...")
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(EventType,
+                       description=_("People who have an event type of ..."),
+                       qualifier=1)

src/filters/Females.py

@@ -33,11 +33,11 @@ class Females(Filter.Filter):
     def match(self,person):
         return person.getGender() == Person.female
 
-def create(text):
-    return Females(text)
-
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("Females")
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(Females,
+                       description=_("Females"),
+                       qualifier=0)

src/filters/HavePhotos.py

@@ -32,11 +32,12 @@ class HavePhotos(Filter.Filter):
     def match(self,person):
         return len(person.getPhotoList()) > 0
 
-def create(text):
-    return HavePhotos(text)
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(HavePhotos,
+                       description=_("People who have images"),
+                       qualifier=0)
 
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("People who have images")

src/filters/IncompleteNames.py

@@ -32,11 +32,11 @@ class IncompleteNames(Filter.Filter):
         name = person.getPrimaryName()
         return name.getFirstName() == "" or name.getSurname() == ""
 
-def create(text):
-    return IncompleteNames(text)
-
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("People with incomplete names")
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(IncompleteNames,
+                       description=_("People with incomplete names"),
+                       qualifier=0)

src/filters/Males.py

@@ -33,11 +33,12 @@ class Males(Filter.Filter):
     def match(self,person):
         return person.getGender() == Person.male
 
-def create(text):
-    return Males(text)
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(Males,
+                       description=_("Males"),
+                       qualifier=0)
 
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("Males")

src/filters/MatchSndEx.py

@@ -36,11 +36,11 @@ class MatchSndEx(Filter.Filter):
     def match(self,person):
         return self.sndex == soundex.soundex(person.getPrimaryName().getSurname())
 
-def create(text):
-    return MatchSndEx(text)
-
-def need_qualifier():
-    return 1
-
-def get_name():
-    return _("Names with same SoundEx code as ...")
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(MatchSndEx,
+                       description=_("Names with same SoundEx code as ..."),
+                       qualifier=1)

src/filters/MatchSndEx2.py

@@ -32,11 +32,11 @@ class MatchSndEx2(Filter.Filter):
     def match(self,person):
         return self.text == soundex.soundex(person.getPrimaryName().getSurname())
 
-def create(text):
-    return MatchSndEx2(text)
-
-def need_qualifier():
-    return 1
-
-def get_name():
-    return _("Names with the specified SoundEx code")
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(MatchSndEx2,
+                       description=_("Names with the specified SoundEx code"),
+                       qualifier=1)

src/filters/MutlipleMarriages.py

@@ -32,11 +32,11 @@ class MultipleMarriages(Filter.Filter):
     def match(self,person):
         return len(person.getFamilyList()) > 1
 
-def create(text):
-    return MultipleMarriages(text)
-
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("People with multiple marriage records")
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(MultipleMarriages,
+                       description=_("People with multiple marriage records"),
+                       qualifier=0)

src/filters/NeverMarried.py

@@ -32,11 +32,12 @@ class NeverMarried(Filter.Filter):
     def match(self,person):
         return len(person.getFamilyList()) == 0
 
-def create(text):
-    return NeverMarried(text)
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(NeverMarried,
+                       description=_("People with no marriage records"),
+                       qualifier=0)
 
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("People with no marriage records")

src/filters/NoBirthdate.py

@@ -32,13 +32,12 @@ class NoBirthdate(Filter.Filter):
     def match(self,person):
         return person.getBirth().getDate() == ""
 
-def create(text):
-    return NoBirthdate(text)
-
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("People without a birth date")
-
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(NoBirthdate,
+                       description=_("People without a birth date"),
+                       qualifier=0)
 

src/filters/NoChildren.py

@@ -37,12 +37,12 @@ class HaveChildren(Filter.Filter):
                 break
         return val
 
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(HaveChildren,
+                       description=_("People with children"),
+                       qualifier=0)
 
-def create(text):
-    return HaveChildren(text)
-
-def need_qualifier():
-    return 0
-
-def get_name():
-    return _("People with children")

src/filters/RegExMatch.py

@@ -43,11 +43,18 @@ class RegExMatch(Filter.Filter):
         else:
             return self.regexp.search(utils.phonebook_name(person))
 
-def create(text):
-    return RegExMatch(text)
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(RegExMatch,
+                       description=_("Names that match a regular expression"),
+                       qualifier=1)
+
+
+
+
+
 
-def need_qualifier():
-    return 1
 
-def get_name():
-    return _("Names that match a regular expression")

src/filters/SubString.py

@@ -32,11 +32,12 @@ class SubString(Filter.Filter):
     def match(self,person):
         return string.find(utils.phonebook_name(person),self.text) >= 0
 
-def create(text):
-    return SubString(text)
+#------------------------------------------------------------------------
+#
+# 
+#
+#------------------------------------------------------------------------
+Filter.register_filter(SubString,
+                       description=_("Names that contain a substring"),
+                       qualifier=1)
 
-def need_qualifier():
-    return 1
-
-def get_name():
-    return _("Names that contain a substring")