diff --git a/src/ExportAssistant.py b/src/ExportAssistant.py
index 9e8c5316f..5ebcc41b0 100644
--- a/src/ExportAssistant.py
+++ b/src/ExportAssistant.py
@@ -280,7 +280,7 @@ class ExportAssistant(gtk.Assistant, ManagedWindow.ManagedWindow) :
         vbox.foreach(vbox.remove)
         # add new content
         if config_box_class:
-            self.option_box_instance = config_box_class(self.person)
+            self.option_box_instance = config_box_class(self.person, self.dbstate, self.uistate)
             box = self.option_box_instance.get_option_box()
             vbox.add(box)
         else: 
diff --git a/src/ExportOptions.py b/src/ExportOptions.py
index 7a1622892..89d9128f2 100644
--- a/src/ExportOptions.py
+++ b/src/ExportOptions.py
@@ -28,6 +28,7 @@
 #
 #-------------------------------------------------------------------------
 import gtk
+import pango
 from gen.ggettext import gettext as _
 import gobject
 
@@ -37,9 +38,56 @@ import gobject
 #
 #-------------------------------------------------------------------------
 import config
-
 from gen.display.name import displayer as name_displayer
 from Filters import GenericFilter, Rules
+from gui.utils import ProgressMeter
+        
+def get_proxy_value(proxy_name):
+    return [value for (name, value) in 
+            config.get('export.proxy-order') if name == proxy_name][0]
+
+def set_proxy_value(proxy_name, proxy_value):
+    [name_value for name_value in 
+     config.get('export.proxy-order') if name_value[0] == proxy_name][0][1] = int(proxy_value)
+
+def get_proxy_names():
+    return [name for (name, value) in config.get('export.proxy-order')]
+
+def swap_proxy_order(row1, row2):
+    po = config.get('export.proxy-order')
+    po[row1], po[row2] = po[row2], po[row1]
+
+class Progress(object):
+    """
+    Mirros the same interface that the ExportAssistant uses in the
+    selection, but this is for the preview selection.
+    """
+    def __init__(self):
+        self.pm = ProgressMeter(_("Selecting Preview Data"), _('Selecting...'))
+        self.progress_cnt = 0
+        self.title = _("Selecting...")
+        while gtk.events_pending():
+            gtk.main_iteration()
+
+    def reset(self, title):
+        self.pm.set_header(title)
+        self.title = title
+        while gtk.events_pending():
+            gtk.main_iteration()
+
+    def set_total(self, count):
+        self.pm.set_pass(self.title, total=count+1)
+        while gtk.events_pending():
+            gtk.main_iteration()
+
+    def update(self, count):
+        self.pm.step()
+        while gtk.events_pending():
+            gtk.main_iteration()
+
+    def close(self):
+        self.pm.step()
+        self.pm.close()
 
 #-------------------------------------------------------------------------
 #
@@ -52,60 +100,84 @@ class WriterOptionBox(object):
     the options.
      
     """
-    def __init__(self, person):
+    def __init__(self, person, dbstate, uistate):
         self.person = person
+        self.dbstate = dbstate
+        self.uistate = uistate
+        self.preview_dbase = None
+        self.preview_button = None
+        self.preview_proxy_button = {}
+        self.proxy_options_showing = False
+        self.proxy_dbase = {}
         self.private = 0
-        self.restrict = 0
-        self.unlinked = 0
+        self.restrict_num = 0
+        self.reference_num = 0
         self.cfilter = None
         self.nfilter = None
-        self.restrict_check = None
+        self.restrict_option = None
         self.private_check = None
-        self.unlinked_check = None
         self.filter_obj = None
         self.filter_note = None
+        self.reference_filter = None
+        self.initialized_show_options = False
         # The following are special properties. Create them to force the
         # export wizard to not ask for a file, and to override the 
         # confirmation message:
         #self.no_fileselect = True
         #self.confirm_text = "You made it, kid!"
 
+    def mark_dirty(self, widget):
+        self.preview_dbase = None
+        if self.preview_button:
+            self.preview_button.set_sensitive(1)
+        for proxy_name in self.preview_proxy_button:
+            if proxy_name != "unfiltered":
+                self.preview_proxy_button[proxy_name].set_sensitive(0)
+        self.parse_options()
+
     def get_option_box(self):
         """Build up a gtk.Table that contains the standard options."""
-        table = gtk.Table(5, 2)
+        widget = gtk.VBox()
         
-        self.filter_obj = gtk.ComboBox()
-        label = gtk.Label(_('_Person Filter'))
-        label.set_use_underline(True)
-        label.set_mnemonic_widget(self.filter_obj)
-        
-        # Objects for choosing a Note filter
-        self.filter_note = gtk.ComboBox()
-        label_note = gtk.Label(_('_Note Filter'))
-        label_note.set_use_underline(True)
-        label_note.set_mnemonic_widget(self.filter_note)
+        full_database_row = gtk.HBox()
+        full_database_row.pack_start(gtk.Label("Unfiltered Family Tree:"), False)
+        button = gtk.Button("%d People" % len(self.dbstate.db.get_person_handles()))
+        button.set_tooltip_text(_("Click to see preview of unfiltered data"))
+        button.set_size_request(100, -1)
+        button.connect("clicked", self.show_preview_data)
+        button.proxy_name = "unfiltered"
+        self.preview_proxy_button["unfiltered"] = button
+        self.spacer = gtk.HBox()
+        full_database_row.pack_end(self.spacer, False)
+        full_database_row.pack_end(button, False)
 
+        widget.pack_start(full_database_row, False)
+        
         self.private_check = gtk.CheckButton(
             _('_Do not include records marked private'))
-        self.restrict_check = gtk.CheckButton(
-            _('_Restrict data on living people'))
-        self.unlinked_check = gtk.CheckButton(
-            _('_Do not include unlinked records'))
+        self.private_check.connect("clicked", self.mark_dirty)
+        self.private_check.set_active(get_proxy_value("privacy"))
 
-        self.private_check.set_active(config.get('export.no-private'))
-        self.restrict_check.set_active(config.get('export.restrict-living'))
-        self.unlinked_check.set_active(config.get('export.no-unlinked'))
-        
-        table.set_border_width(12)
-        table.set_row_spacings(6)
-        table.set_col_spacings(6)
-        table.attach(label, 0, 1, 0, 1, xoptions=0, yoptions=0)
-        table.attach(self.filter_obj, 1, 2, 0, 1, yoptions=0)
-        table.attach(label_note, 0, 1, 1, 2, xoptions =0, yoptions=0)
-        table.attach(self.filter_note, 1, 2, 1, 2, yoptions=0)
-        table.attach(self.private_check, 1, 2, 2, 3, yoptions=0)
-        table.attach(self.restrict_check, 1, 2, 3, 4, yoptions=0)
-        table.attach(self.unlinked_check, 1, 2, 4, 5, yoptions=0)
+        self.proxy_widget = {}
+        self.vbox_n = []
+        self.up_n = []
+        self.down_n = []
+        row = 0
+        for proxy_name in get_proxy_names():
+            frame = self.build_frame(proxy_name, row)
+            widget.pack_start(frame, False)
+            row += 1
+
+        hbox = gtk.HBox()
+        self.advanced_button = gtk.Button(_("Change order"))
+        self.advanced_button.set_size_request(150, -1)
+        self.proxy_options_showing = False
+        self.advanced_button.connect("clicked", self.show_options)
+        hbox.pack_end(self.advanced_button, False)
+        self.preview_button = gtk.Button(_("Calculate Previews"))
+        self.preview_button.connect("clicked", self.preview)
+        hbox.pack_end(self.preview_button, False)
+        widget.pack_end(hbox, False)
 
         # Populate the Person Filter
         entire_db = GenericFilter()
@@ -123,11 +195,42 @@ class WriterOptionBox(object):
             model.append(row=[item.get_name(), item])
 
         cell = gtk.CellRendererText()
+        cell.set_property('ellipsize', pango.ELLIPSIZE_END)
         self.filter_obj.pack_start(cell, True)
         self.filter_obj.add_attribute(cell, 'text', 0)
         self.filter_obj.set_model(model)
-        self.filter_obj.set_active(0)
-        
+        self.filter_obj.set_active(get_proxy_value("person"))
+
+        model = gtk.ListStore(gobject.TYPE_STRING, int)
+        row = 0
+        for item in [
+            _('Include living people'),
+            _('Restrict given names on living people'),
+            _('Remove living people')]:
+            model.append(row=[item, row])
+            row += 1
+        cell = gtk.CellRendererText()
+        cell.set_property('ellipsize', pango.ELLIPSIZE_END)
+        self.restrict_option.pack_start(cell, True)
+        self.restrict_option.add_attribute(cell, 'text', 0)
+        self.restrict_option.set_model(model)
+        self.restrict_option.set_active(get_proxy_value("living"))
+
+        model = gtk.ListStore(gobject.TYPE_STRING, int)
+        row = 0
+        for item in [
+            _('Include all objects'),
+            _('Include only items connected to selected people'),
+            _('Include items that are not orphans')]:
+            model.append(row=[item, row])
+            row += 1
+        cell = gtk.CellRendererText()
+        cell.set_property('ellipsize', pango.ELLIPSIZE_END)
+        self.reference_filter.pack_start(cell, True)
+        self.reference_filter.add_attribute(cell, 'text', 0)
+        self.reference_filter.set_model(model)
+        self.reference_filter.set_active(get_proxy_value("reference"))
+
         # Populate the Notes Filter
         notes_filters = [entire_db]
         
@@ -136,13 +239,204 @@ class WriterOptionBox(object):
         for item in notes_filters:
             notes_model.append(row=[item.get_name(), item])
         notes_cell = gtk.CellRendererText()
+        notes_cell.set_property('ellipsize', pango.ELLIPSIZE_END)
         self.filter_note.pack_start(notes_cell, True)
         self.filter_note.add_attribute(notes_cell, 'text', 0)
         self.filter_note.set_model(notes_model)
-        self.filter_note.set_active(0)       
+        self.filter_note.set_active(get_proxy_value("note"))
 
-        table.show()
-        return table
+        self.filter_note.connect("changed", self.mark_dirty)
+        self.filter_obj.connect("changed", self.mark_dirty)
+        self.restrict_option.connect("changed", self.mark_dirty)
+        self.reference_filter.connect("changed", self.mark_dirty)
+        return widget
+
+    def show_preview_data(self, widget):
+        from DbState import DbState
+        from QuickReports import run_quick_report_by_name
+        if widget.proxy_name == "unfiltered":
+            dbstate = self.dbstate
+        else:
+            dbstate = DbState()
+            dbstate.db = self.proxy_dbase[widget.proxy_name]
+            dbstate.open = True
+        run_quick_report_by_name(dbstate,
+                                 self.uistate, 
+                                 'filterbyname', 
+                                 'all')
+
+    def preview(self, widget):
+        """
+        Calculate previews to see the selected data.
+        """
+        self.parse_options()
+        pm = Progress()
+        self.preview_dbase = self.get_filtered_database(self.dbstate.db, pm, preview=True)
+        pm.close()
+        self.preview_button.set_sensitive(0)
+
+    def build_frame(self, proxy_name, row):
+        """
+        Build a frame for a proxy option. proxy_name is a string.
+        """
+        # Make a box and put the option in it:
+        button = gtk.Button("%d People" % 0)
+        button.set_size_request(100, -1)
+        button.connect("clicked", self.show_preview_data)
+        button.proxy_name = proxy_name
+        if proxy_name == "person":
+            # Frame Person:
+            self.filter_obj = gtk.ComboBox()
+            label = gtk.Label(_('_Person Filter') + ": ")
+            label.set_alignment(0, 0.5)
+            label.set_size_request(150, -1)
+            label.set_use_underline(True)
+            label.set_mnemonic_widget(self.filter_obj)
+            box = gtk.HBox()
+            box.pack_start(label, False)
+            box.pack_start(self.filter_obj)
+            button.set_tooltip_text(_("Click to see preview after person filter"))
+        elif proxy_name == "note":
+            # Frame Note:
+            # Objects for choosing a Note filter:
+            self.filter_note = gtk.ComboBox()
+            label_note = gtk.Label(_('_Note Filter') + ": ")
+            label_note.set_alignment(0, 0.5)
+            label_note.set_size_request(150, -1)
+            label_note.set_use_underline(True)
+            label_note.set_mnemonic_widget(self.filter_note)
+            box = gtk.HBox()
+            box.pack_start(label_note, False)
+            box.pack_start(self.filter_note)
+            button.set_tooltip_text(_("Click to see preview after note filter"))
+        elif proxy_name == "privacy":
+            # Frame 3:
+            label = gtk.Label(_("Privacy Filter") + ":")
+            label.set_alignment(0, 0.5)
+            label.set_size_request(150, -1)
+            box = gtk.HBox()
+            box.pack_start(label, False)
+            box.add(self.private_check)
+            button.set_tooltip_text(_("Click to see preview after privacy filter"))
+        elif proxy_name == "living":
+            # Frame 4:
+            label = gtk.Label(_("Living Filter") + ":")
+            label.set_alignment(0, 0.5)
+            label.set_size_request(150, -1)
+            box = gtk.HBox()
+            box.pack_start(label, False)
+            self.restrict_option = gtk.ComboBox()
+            box.add(self.restrict_option)
+            button.set_tooltip_text(_("Click to see preview after living filter"))
+        elif proxy_name == "reference":
+            # Frame 5:
+            self.reference_filter = gtk.ComboBox()
+            label = gtk.Label(_('Reference Filter') + ": ")
+            label.set_alignment(0, 0.5)
+            label.set_size_request(150, -1)
+            box = gtk.HBox()
+            box.pack_start(label, False)
+            box.pack_start(self.reference_filter)
+            button.set_tooltip_text(_("Click to see preview after reference filter"))
+        else:
+            raise AttributeError("Unknown proxy '%s'" % proxy_name)
+
+        frame = gtk.Frame()
+        hbox = gtk.HBox()
+        frame.add(hbox)
+        vbox = gtk.HBox()
+        self.vbox_n.append(vbox)
+        up = gtk.Button()
+        up.connect("clicked", self.swap)
+        if row == 0:
+            up.set_sensitive(0) # can't go up
+        image = gtk.Image()
+        image.set_from_stock(gtk.STOCK_GO_UP,
+                             gtk.ICON_SIZE_MENU)
+        up.set_image(image)
+        up.row = row - 1
+        self.up_n.append(up)
+        down = gtk.Button()
+        down.connect("clicked", self.swap)
+        image = gtk.Image()
+        image.set_from_stock(gtk.STOCK_GO_DOWN,
+                             gtk.ICON_SIZE_MENU)
+        down.set_image(image)
+        down.row = row
+        if row == 4:
+            down.set_sensitive(0) # can't go down
+        self.down_n.append(down)
+        self.preview_proxy_button[proxy_name] = button
+        self.preview_proxy_button[proxy_name].set_sensitive(0)
+        box.pack_end(button, False)
+        hbox.pack_start(box)
+        hbox.pack_end(vbox, False)
+        self.proxy_widget[proxy_name] = box
+        return frame
+
+    def show_options(self, widget=None):
+        """
+        Show or hide the option arrows. Needs to add them if first
+        time due to the fact that Gramps tends to use show_all rather
+        than show.
+        """
+        if self.proxy_options_showing:
+            self.advanced_button.set_label(_("Change order"))
+            self.spacer_up.hide()
+            self.spacer_down.hide()
+            for n in range(5):
+                self.up_n[n].hide()
+                self.down_n[n].hide()
+        else:
+            self.advanced_button.set_label(_("Hide order"))
+            if not self.initialized_show_options:
+                self.initialized_show_options = True
+                # This is necessary because someone used show_all up top
+                # Now, we can't add something that we want hidden
+                for n in range(5):
+                    self.vbox_n[n].pack_start(self.up_n[n])
+                    self.vbox_n[n].pack_end(self.down_n[n])
+                # some spacer buttons:
+                up = gtk.Button()
+                up.set_sensitive(0) 
+                image = gtk.Image()
+                image.set_from_stock(gtk.STOCK_GO_UP,
+                                     gtk.ICON_SIZE_MENU)
+                up.set_image(image)
+                self.spacer.pack_start(up, False)
+                down = gtk.Button()
+                down.set_sensitive(0) 
+                image = gtk.Image()
+                image.set_from_stock(gtk.STOCK_GO_DOWN,
+                                     gtk.ICON_SIZE_MENU)
+                down.set_image(image)
+                self.spacer.pack_end(down, False)
+                self.spacer_up = up
+                self.spacer_down = down
+            self.spacer_up.show()
+            self.spacer_down.show()
+            for n in range(5):
+                self.up_n[n].show()
+                self.down_n[n].show()
+            
+        self.proxy_options_showing = not self.proxy_options_showing
+
+    def swap(self, widget):
+        """
+        Swap the order of two proxies. 
+        """
+        row1 = widget.row
+        row2 = widget.row + 1
+        proxy1 = config.get('export.proxy-order')[row1][0]
+        proxy2 = config.get('export.proxy-order')[row2][0]
+        widget1 = self.proxy_widget[proxy1]
+        widget2 = self.proxy_widget[proxy2]
+        parent1 = widget1.get_parent()
+        parent2 = widget2.get_parent()
+        widget1.reparent(parent2)
+        widget2.reparent(parent1)
+        swap_proxy_order(row1, row2)
+        self.mark_dirty(widget)
 
     def __define_person_filters(self):
         """Add person filters if the active person is defined."""
@@ -178,24 +472,145 @@ class WriterOptionBox(object):
            restrict = restrict information on living peoplel
            cfitler  = return the GenericFilter selected
            nfilter  = return the NoteFilter selected
-           unlinked = restrict unlinked records
+           reference = restrict referenced/orphaned records
 
         """
-        self.restrict = self.restrict_check.get_active()
-        self.private = self.private_check.get_active()
-        self.unlinked = self.unlinked_check.get_active()
+        if self.private_check:
+            self.private = self.private_check.get_active()
+            set_proxy_value("privacy", self.private)
 
-        config.set('export.no-private', self.private)
-        config.set('export.restrict-living', self.restrict)
-        config.set('export.no-unlinked', self.unlinked)
-        config.save()
+        if self.filter_obj:
+            model = self.filter_obj.get_model()
+            node = self.filter_obj.get_active_iter()
+            self.cfilter = model[node][1]
+            set_proxy_value("person", self.filter_obj.get_active())
 
-        model = self.filter_obj.get_model()
-        node = self.filter_obj.get_active_iter()
-        self.cfilter = model[node][1]
+        if self.restrict_option:
+            model = self.restrict_option.get_model()
+            node = self.restrict_option.get_active_iter()
+            self.restrict_num = model[node][1]
+            set_proxy_value("living", self.restrict_option.get_active())
         
-        model = self.filter_note.get_model()
-        node = self.filter_note.get_active_iter()
-        self.nfilter = model[node][1]
+        if self.filter_note:
+            model = self.filter_note.get_model()
+            node = self.filter_note.get_active_iter()
+            self.nfilter = model[node][1]
+            set_proxy_value("note", self.filter_note.get_active())
 
+        if self.reference_filter:
+            model = self.reference_filter.get_model()
+            node = self.reference_filter.get_active_iter()
+            self.reference_num = model[node][1]
+            set_proxy_value("reference", self.reference_filter.get_active())
 
+    def get_filtered_database(self, dbase, progress=None, preview=False):
+        """
+        dbase - the database
+        progress - instance that has:
+           .reset() method
+           .set_total() method
+           .update() method
+           .progress_cnt integer representing N of total done
+        """
+        # Increment the progress count for each filter type chosen
+        if self.private and progress:
+            progress.progress_cnt += 1
+
+        if self.restrict_num > 0 and progress:
+            progress.progress_cnt += 1
+
+        if not self.cfilter.is_empty() and progress:
+            progress.progress_cnt += 1
+
+        if not self.nfilter.is_empty() and progress:
+            progress.progress_cnt += 1
+
+        if self.reference_num > 0 and progress:
+            progress.progress_cnt += 1
+
+        if progress:
+            progress.set_total(progress.progress_cnt)
+            progress.progress_cnt = 0
+
+        if self.preview_dbase:
+            if progress:
+                progress.progress_cnt += 5
+            return self.preview_dbase
+
+        self.proxy_dbase.clear()
+        for proxy_name in get_proxy_names():
+            dbase = self.apply_proxy(proxy_name, dbase, progress)
+            if preview:
+                self.proxy_dbase[proxy_name] = dbase
+                self.preview_proxy_button[proxy_name].set_sensitive(1)
+                self.preview_proxy_button[proxy_name].set_label(_("%d People" % len(dbase.get_person_handles())))
+        return dbase
+
+    def apply_proxy(self, proxy_name, dbase, progress=None):
+        """
+        Apply the named proxy to the dbase, and return.
+        proxy_name is one of 
+           ["person", "note", "privacy", "living", "reference"]
+        """
+        # If the private flag is set, apply the PrivateProxyDb
+        import gen.proxy
+        if proxy_name == "privacy":
+            if self.private:
+                if progress:
+                    progress.reset(_("Filtering private data"))
+                    progress.progress_cnt += 1
+                    progress.update(progress.progress_cnt)
+                dbase = gen.proxy.PrivateProxyDb(dbase)
+
+        # If the restrict flag is set, apply the LivingProxyDb
+        elif proxy_name == "living":
+            if self.restrict_num > 0:
+                if progress:
+                    progress.reset(_("Filtering living persons"))
+                    progress.progress_cnt += 1
+                    progress.update(progress.progress_cnt)
+                mode = [None, # include living
+                        gen.proxy.LivingProxyDb.MODE_INCLUDE_LAST_NAME_ONLY,
+                        gen.proxy.LivingProxyDb.MODE_EXCLUDE_ALL,
+                        ][self.restrict_num]
+                dbase = gen.proxy.LivingProxyDb(
+                            dbase, 
+                            mode) # 
+
+        # If the filter returned by cfilter is not empty, apply the 
+        # FilterProxyDb (Person Filter)
+        elif proxy_name == "person":
+            if not self.cfilter.is_empty():
+                if progress:
+                    progress.reset(_("Applying selected person filter"))
+                    progress.progress_cnt += 1
+                    progress.update(progress.progress_cnt)
+                dbase = gen.proxy.FilterProxyDb(
+                    dbase, self.cfilter)
+
+        # Apply the Note Filter
+        elif proxy_name == "note":
+            if not self.nfilter.is_empty():
+                if progress:
+                    progress.reset(_("Applying selected note filter"))
+                    progress.progress_cnt += 1
+                    progress.update(progress.progress_cnt)
+                dbase = gen.proxy.FilterProxyDb(
+                    dbase, note_filter=self.nfilter)
+
+        # Apply the ReferencedBySelection
+        elif proxy_name == "reference":
+            if progress:
+                progress.reset(_("Filtering referenced records"))
+                progress.progress_cnt += 1
+                progress.update(progress.progress_cnt)
+            if self.reference_num == 0:
+                pass
+            elif self.reference_num == 1:
+                dbase = gen.proxy.ReferencedBySelectionProxyDb(dbase)
+            elif self.reference_num == 2:
+                dbase = gen.proxy.ReferencedProxyDb(dbase)
+        else:
+            raise AttributeError("no such proxy '%s'" % proxy_name)
+
+        return dbase
diff --git a/src/config.py b/src/config.py
index fde825d19..b3780c334 100644
--- a/src/config.py
+++ b/src/config.py
@@ -144,9 +144,13 @@ register('behavior.surname-guessing', 0)
 register('behavior.use-tips', False)
 register('behavior.welcome', 100)
 
-register('export.no-private', True)
-register('export.no-unlinked', True)
-register('export.restrict-living', True)
+register('export.proxy-order', [
+        ["privacy", 0], 
+        ["living", 0], 
+        ["person", 0], 
+        ["note", 0], 
+        ["reference", 0],
+        ])
 
 register('geoview.latitude', "0.0")
 register('geoview.lock', False)
diff --git a/src/plugins/export/ExportCsv.py b/src/plugins/export/ExportCsv.py
index b8c0e1ed4..faa8b6412 100644
--- a/src/plugins/export/ExportCsv.py
+++ b/src/plugins/export/ExportCsv.py
@@ -156,7 +156,7 @@ class CSVWriterOptionBox(object):
     the options. 
     
     """
-    def __init__(self,person):
+    def __init__(self, person, dbstate, uistate):
         self.person = person
         self.include_individuals = 1
         self.include_marriages = 1
diff --git a/src/plugins/export/ExportFtree.py b/src/plugins/export/ExportFtree.py
index cf3f7d286..850be9bd9 100644
--- a/src/plugins/export/ExportFtree.py
+++ b/src/plugins/export/ExportFtree.py
@@ -47,6 +47,7 @@ log = logging.getLogger(".WriteFtree")
 #-------------------------------------------------------------------------
 import Utils
 from Filters import GenericFilter, Rules, build_filter_model
+from ExportOptions import WriterOptionBox
 import Errors
 from glade import Glade
 
@@ -56,66 +57,9 @@ from glade import Glade
 #
 #-------------------------------------------------------------------------
 def writeData(database, filename, msg_callback, option_box=None, callback=None):
-    writer = FtreeWriter(database, msg_callback, filename, option_box, callback)
+    writer = FtreeWriter(database, filename, msg_callback, option_box, callback)
     return writer.export_data()
     
-class FtreeWriterOptionBox(object):
-    """
-    Create a VBox with the option widgets and define methods to retrieve
-    the options. 
-    """
-    def __init__(self, person):
-        self.person = person
-        self.restrict = True
-
-    def get_option_box(self):
-        self.top = Glade()
-
-        self.filters = self.top.get_object("filter")
-
-        all = GenericFilter()
-        all.set_name(_("Entire Database"))
-        all.add_rule(Rules.Person.Everyone([]))
-
-        the_filters = [all]
-        
-        if self.person:
-            des = GenericFilter()
-            des.set_name(_("Descendants of %s") %
-                         self.person.get_primary_name().get_name())
-            des.add_rule(Rules.Person.IsDescendantOf(
-                [self.person.get_gramps_id(),1]))
-        
-            ans = GenericFilter()
-            ans.set_name(_("Ancestors of %s")
-                         % self.person.get_primary_name().get_name())
-            ans.add_rule(Rules.Person.IsAncestorOf(
-                [self.person.get_gramps_id(),1]))
-        
-            com = GenericFilter()
-            com.set_name(_("People with common ancestor with %s") %
-                         self.person.get_primary_name().get_name())
-            com.add_rule(Rules.Person.HasCommonAncestorWith(
-                [self.person.get_gramps_id()]))
-        
-            the_filters += [des, ans, com]
-
-        from Filters import CustomFilters
-        the_filters.extend(CustomFilters.get_filters('Person'))
-        self.filter_menu = build_filter_model(the_filters)
-        self.filters.set_model(self.filter_menu)
-        self.filters.set_active(0)
-
-        the_box = self.top.get_object("vbox1")
-        the_parent = self.top.get_object('dialog-vbox1')
-        the_parent.remove(the_box)
-        self.top.toplevel.destroy()
-        return the_box
-
-    def parse_options(self):
-        self.restrict = self.top.get_object("restrict").get_active()
-        self.cfilter = self.filter_menu[self.filters.get_active()][1]
-
 #-------------------------------------------------------------------------
 #
 # FtreeWriter
@@ -123,40 +67,23 @@ class FtreeWriterOptionBox(object):
 #-------------------------------------------------------------------------
 class FtreeWriter(object):
 
-    def __init__(self, database, msg_callback, filename="", option_box=None,
+    def __init__(self, database, filename, msg_callback, option_box=None,
                  callback = None):
         self.db = database
-        self.option_box = option_box
         self.filename = filename
-        self.callback = callback
         self.msg_callback = msg_callback
+        self.option_box = option_box
+        self.callback = callback
         if callable(self.callback): # callback is really callable
             self.update = self.update_real
         else:
             self.update = self.update_empty
 
-        self.plist = {}
-
-        if not option_box:
-            self.cl_setup()
-        else:
+        if option_box:
             self.option_box.parse_options()
+            self.db = option_box.get_filtered_database(self.db)
 
-            self.restrict = self.option_box.restrict
-            if self.option_box.cfilter is None:
-                self.plist.update((p,1) 
-                    for p in self.db.iter_person_handles())
-
-            else:
-                try:
-                    self.plist.update((p,1) 
-                        for p in self.option_box.cfilter.apply(
-                            self.db, self.db.iter_person_handles()))
-
-                except Errors.FilterError, msg:
-                    (m1, m2) = msg.messages()
-                    self.msg_callback(m1, m2)
-                    return
+        self.plist = [x for x in self.db.iter_person_handles()]
 
     def update_empty(self):
         pass
@@ -168,11 +95,6 @@ class FtreeWriter(object):
             self.callback(newval)
             self.oldval = newval
 
-    def cl_setup(self):
-        self.restrict = True
-        self.plist.update((p,1) 
-            for p in self.db.iter_person_handles())        
-
     def export_data(self):
         name_map = {}
         id_map = {}
@@ -237,18 +159,18 @@ class FtreeWriter(object):
             else:
                 death = None
 
-            if self.restrict:
-                alive = Utils.probably_alive(p, self.db)
-            else:
-                alive = 0
+            #if self.restrict:
+            #    alive = Utils.probably_alive(p, self.db)
+            #else:
+            #    alive = 0
                 
-            if birth and not alive:
-                if death and not alive :
+            if birth:
+                if death:
                     dates = "%s-%s" % (fdate(birth), fdate(death))
                 else:
                     dates = fdate(birth)
             else:
-                if death and not alive:
+                if death:
                     dates = fdate(death)
                 else:
                     dates = ""
diff --git a/src/plugins/export/ExportGedcom.py b/src/plugins/export/ExportGedcom.py
index e615dccce..5a1538a74 100644
--- a/src/plugins/export/ExportGedcom.py
+++ b/src/plugins/export/ExportGedcom.py
@@ -46,7 +46,6 @@ import Errors
 from ExportOptions import WriterOptionBox
 from gen.updatecallback import UpdateCallback
 from Utils import media_path_full, get_unicode_path
-import gen.proxy
 from PlaceUtils import conv_lat_lon
 
 #-------------------------------------------------------------------------
@@ -234,66 +233,7 @@ class GedcomWriter(UpdateCallback):
         """
         if option_box:
             option_box.parse_options()
-
-            # Increment the progress count for each filter type chosen
-            if option_box.private:
-                self.progress_cnt += 1
-
-            if option_box.restrict:
-                self.progress_cnt += 1
-
-            if not option_box.cfilter.is_empty():
-                self.progress_cnt += 1
-
-            if not option_box.nfilter.is_empty():
-                self.progress_cnt += 1
-
-            if option_box.unlinked:
-                self.progress_cnt += 1
-
-            self.set_total(self.progress_cnt)
-            self.progress_cnt = 0
-
-            # If the private flag is set, apply the PrivateProxyDb
-            if option_box.private:
-                self.reset(_("Filtering private data"))
-                self.progress_cnt += 1
-                self.update(self.progress_cnt)
-                self.dbase = gen.proxy.PrivateProxyDb(self.dbase)
-
-            # If the restrict flag is set, apply the LivingProxyDb
-            if option_box.restrict:
-                self.reset(_("Filtering living persons"))
-                self.progress_cnt += 1
-                self.update(self.progress_cnt)
-                self.dbase = gen.proxy.LivingProxyDb(
-                            self.dbase, 
-                            gen.proxy.LivingProxyDb.MODE_INCLUDE_LAST_NAME_ONLY)
-
-            # If the filter returned by cfilter is not empty, apply the 
-            # FilterProxyDb (Person Filter)
-            if not option_box.cfilter.is_empty():
-                self.reset(_("Applying selected person filter"))
-                self.progress_cnt += 1
-                self.update(self.progress_cnt)
-                self.dbase = gen.proxy.FilterProxyDb(
-                    self.dbase, option_box.cfilter)
-            
-            # Apply the Note Filter
-            if not option_box.nfilter.is_empty():
-                self.reset(_("Applying selected note filter"))
-                self.progress_cnt += 1
-                self.update(self.progress_cnt)
-                self.dbase = gen.proxy.FilterProxyDb(
-                    self.dbase, note_filter=option_box.nfilter)
-
-            # Apply the ReferencedProxyDb to remove any objects not referenced
-            # after any of the other proxies have been applied
-            if option_box.unlinked:
-                self.reset(_("Filtering unlinked records"))
-                self.progress_cnt += 1
-                self.update(self.progress_cnt)
-                self.dbase = gen.proxy.ReferencedProxyDb(self.dbase)
+            self.dbase = option_box.get_filtered_database(self.dbase, self)
 
     def write_gedcom_file(self, filename):
         """
diff --git a/src/plugins/export/ExportGeneWeb.py b/src/plugins/export/ExportGeneWeb.py
index b82bef296..b70c40df2 100644
--- a/src/plugins/export/ExportGeneWeb.py
+++ b/src/plugins/export/ExportGeneWeb.py
@@ -48,153 +48,32 @@ log = logging.getLogger(".WriteGeneWeb")
 #-------------------------------------------------------------------------
 import gen.lib
 from Filters import GenericFilter, Rules, build_filter_model
+from ExportOptions import WriterOptionBox
 #import const
 import Utils
 from glade import Glade
 import config
 
-#-------------------------------------------------------------------------
-#
-# GeneWebWriterOptionBox class
-#
-#-------------------------------------------------------------------------
-class GeneWebWriterOptionBox(object):
-    """
-    Create a VBox with the option widgets and define methods to retrieve
-    the options.
-     
-    """
-    def __init__(self, person):
-        self.person = person
-
-    def get_option_box(self):
-        self.restrict = 1
-
-        self.topDialog = Glade()
-        self.topDialog.connect_signals({
-                "on_restrict_toggled": self.on_restrict_toggled
-                })
-
-        self.filters = self.topDialog.get_object("filter")
-        self.copy = 0
-
-        all = GenericFilter()
-        all.set_name(_("Entire Database"))
-        all.add_rule(Rules.Person.Everyone([]))
-
-        the_filters = [all]
-
-        if self.person:
-            des = GenericFilter()
-            des.set_name(_("Descendants of %s") %
-                         self.person.get_primary_name().get_name())
-            des.add_rule(Rules.Person.IsDescendantOf(
-                [self.person.get_gramps_id(),1]))
-
-            ans = GenericFilter()
-            ans.set_name(_("Ancestors of %s") %
-                         self.person.get_primary_name().get_name())
-            ans.add_rule(Rules.Person.IsAncestorOf(
-                [self.person.get_gramps_id(),1]))
-
-            com = GenericFilter()
-            com.set_name(_("People with common ancestor with %s") %
-                         self.person.get_primary_name().get_name())
-            com.add_rule(Rules.Person.HasCommonAncestorWith(
-                [self.person.get_gramps_id()]))
-
-            the_filters += [des, ans, com]
-
-        from Filters import CustomFilters
-        the_filters.extend(CustomFilters.get_filters('Person'))
-        self.filter_menu = build_filter_model(the_filters)
-        self.filters.set_model(self.filter_menu)
-        self.filters.set_active(0)
-
-        the_box = self.topDialog.get_object('vbox1')
-        the_parent = self.topDialog.get_object('dialog-vbox1')
-        the_parent.remove(the_box)
-        self.topDialog.toplevel.destroy()
-        return the_box
-
-    def on_restrict_toggled(self, restrict):
-        active = restrict.get_active ()
-        for x in [self.topDialog.get_object("living"),
-                  self.topDialog.get_object("notes")]:
-            x.set_sensitive(active)
-
-    def parse_options(self):
-        self.restrict = self.topDialog.get_object("restrict").get_active()
-        self.living = (self.restrict and
-                       self.topDialog.get_object("living").get_active())
-        self.exclnotes = (self.restrict and
-                          self.topDialog.get_object("notes").get_active())
-        self.cfilter = self.filter_menu[self.filters.get_active()][1]
-
-        self.images = self.topDialog.get_object ("images").get_active ()
-        if self.images:
-            images_path = self.topDialog.get_object ("images_path")
-            self.images_path = unicode(images_path.get_text ())
-        else:
-            self.images_path = ""
-
 class GeneWebWriter(object):
-    def __init__(self, database, msg_callback, filename="", option_box=None,
+    def __init__(self, database, filename, msg_callback, option_box=None,
                  callback=None):
         self.db = database
-        self.option_box = option_box
         self.filename = filename
-        self.callback = callback
         self.msg_callback = msg_callback
+        self.option_box = option_box
+        self.callback = callback
         if callable(self.callback): # callback is really callable
             self.update = self.update_real
         else:
             self.update = self.update_empty
 
-        self.plist = {}
-        self.flist = {}
-        
         self.persons_details_done = []
         self.persons_notes_done = []
         self.person_ids = {}
         
-        if not option_box:
-            self.restrict = 0
-            self.copy = 0
-            self.images = 0
-        else:
+        if option_box:
             self.option_box.parse_options()
-
-            self.restrict = self.option_box.restrict
-            self.living = self.option_box.living
-            self.exclnotes = self.option_box.exclnotes
-            self.copy = self.option_box.copy
-            self.images = self.option_box.images
-            self.images_path = self.option_box.images_path
-            
-            if not option_box.cfilter.is_empty():
-                self.db = gen.proxy.FilterProxyDb(self.db, option_box.cfilter)
-
-        self.plist.update([p, 1] for p in self.db.iter_person_handles())
-            
-        self.flist = {}
-        for key in self.plist:
-            p = self.db.get_person_from_handle(key)
-            for family_handle in p.get_family_handle_list():
-                self.flist[family_handle] = 1
-
-        # remove families that dont contain father AND mother
-        # because GeneWeb requires both to be present
-        templist = self.flist
-        self.flist = {}
-        for family_handle in templist:
-            family = self.db.get_family_from_handle(family_handle)
-            if family:
-                father_handle = family.get_father_handle()
-                mother_handle = family.get_mother_handle()
-                if father_handle and mother_handle:
-                    self.flist[family_handle] = 1
-
+            self.db = option_box.get_filtered_database(self.db)
 
     def update_empty(self):
         pass
@@ -222,6 +101,7 @@ class GeneWebWriter(object):
             self.msg_callback(_("Could not create %s") % self.filename)
             return False
 
+        self.flist = [x for x in self.db.iter_family_handles()]
         if len(self.flist) < 1:
             self.msg_callback(_("No families matched by selected filter"))
             return False
@@ -258,7 +138,7 @@ class GeneWebWriter(object):
                     self.write_sources( family.get_source_references())
                     self.write_children( family, father)
                     self.write_notes( family, father, mother)
-                    if not (self.restrict and self.exclnotes):
+                    if True: # FIXME: not (self.restrict and self.exclnotes):
                         notelist = family.get_note_list()
                         note = ""
                         for notehandle in notelist:
@@ -274,7 +154,7 @@ class GeneWebWriter(object):
     def write_witness(self, family):
         # FIXME: witnesses are not in events anymore
         return
-        
+    
         if self.restrict:
             return
         event_ref_list = family.get_event_ref_list()
@@ -301,8 +181,9 @@ class GeneWebWriter(object):
                                     )
 
     def write_sources(self,reflist):
-        if self.restrict and self.exclnotes:
-            return
+        # FIXME
+        #if self.restrict and self.exclnotes:
+        #    return
             
         if reflist:
             for sr in reflist:
@@ -336,8 +217,9 @@ class GeneWebWriter(object):
             self.writeln("end")
 
     def write_notes(self,family, father, mother):
-        if self.restrict and self.exclnotes:
-            return
+        # FIXME:
+        #if self.restrict and self.exclnotes:
+        #    return
             
         self.write_note_of_person(father)
         self.write_note_of_person(mother)
@@ -379,8 +261,9 @@ class GeneWebWriter(object):
                 self.writeln("end notes")
     
     def get_full_person_info(self, person):
-        if self.restrict:
-            return "0 "
+        # FIXME:
+        #if self.restrict:
+        #    return "0 "
             
         retval = ""
 
@@ -451,27 +334,27 @@ class GeneWebWriter(object):
         return str.replace(' ','_')
     
     def get_ref_name(self,person):
-        missing_surname = config.get("preferences.no-surname-text")
+        #missing_surname = config.get("preferences.no-surname-text")
         surname = self.rem_spaces( person.get_primary_name().get_surname())
-        firstname = config.get('preferences.private-given-text') 
-        if not (Utils.probably_alive(person,self.db) and \
-          self.restrict and self.living):
-            firstname = self.rem_spaces( person.get_primary_name().get_first_name())
+        #firstname = config.get('preferences.private-given-text') 
+        #if not (Utils.probably_alive(person,self.db) and \
+        #  self.restrict and self.living):
+        firstname = self.rem_spaces( person.get_primary_name().get_first_name())
         if person.get_handle() not in self.person_ids:
             self.person_ids[person.get_handle()] = len(self.person_ids)
-        return "%s %s.%d" % (surname or missing_surname, firstname, 
+        return "%s %s.%d" % (surname, firstname, 
                              self.person_ids[person.get_handle()])
 
     def get_child_ref_name(self,person,father_lastname):
-        missing_first_name = config.get("preferences.no-given-text")
+        #missing_first_name = config.get("preferences.no-given-text")
         surname = self.rem_spaces( person.get_primary_name().get_surname())
-        firstname = config.get('preferences.private-given-text')
-        if not (Utils.probably_alive(person,self.db) and \
-          self.restrict and self.living):
-            firstname = self.rem_spaces( person.get_primary_name().get_first_name())
+        #firstname = config.get('preferences.private-given-text')
+        #if not (Utils.probably_alive(person,self.db) and \
+        #  self.restrict and self.living):
+        firstname = self.rem_spaces( person.get_primary_name().get_first_name())
         if person.get_handle() not in self.person_ids:
             self.person_ids[person.get_handle()] = len(self.person_ids)
-        ret = "%s.%d" % (firstname or missing_first_name, self.person_ids[person.get_handle()])
+        ret = "%s.%d" % (firstname, self.person_ids[person.get_handle()])
         if surname != father_lastname: ret += " " + surname
         return ret
 
@@ -611,5 +494,5 @@ class GeneWebWriter(object):
 #
 #-------------------------------------------------------------------------
 def exportData(database, filename, msg_callback, option_box=None, callback=None):
-    gw = GeneWebWriter(database, msg_callback, filename, option_box, callback)
+    gw = GeneWebWriter(database, filename, msg_callback, option_box, callback)
     return gw.export_data()
diff --git a/src/plugins/export/ExportPkg.py b/src/plugins/export/ExportPkg.py
index db1dca05c..be5c46a7a 100644
--- a/src/plugins/export/ExportPkg.py
+++ b/src/plugins/export/ExportPkg.py
@@ -84,27 +84,7 @@ def writeData(database, filename, msg_callback, option_box=None, callback=None):
 
     if option_box:
         option_box.parse_options()
-    
-        if option_box.private:
-            database = gen.proxy.PrivateProxyDb(database)
-    
-        if option_box.restrict:
-            database = gen.proxy.LivingProxyDb(
-                database, gen.proxy.LivingProxyDb.MODE_INCLUDE_LAST_NAME_ONLY)
-    
-        # Apply the Person Filter
-        if not option_box.cfilter.is_empty():
-            database = gen.proxy.FilterProxyDb(database, option_box.cfilter)
-    
-        # Apply the Note Filter
-        if not option_box.nfilter.is_empty():
-            database = gen.proxy.FilterProxyDb(
-                database, note_filter=option_box.nfilter)
-        
-        # Apply the ReferencedProxyDb to remove any objects not referenced
-        # after any of the other proxies have been applied
-        if option_box.unlinked:
-            database = gen.proxy.ReferencedProxyDb(database)
+        database = option_box.get_filtered_database(database)
 
     writer = PackageWriter(database, filename, msg_callback, callback)
     return writer.export()
diff --git a/src/plugins/export/ExportVCalendar.py b/src/plugins/export/ExportVCalendar.py
index eb1154838..ae72cc210 100644
--- a/src/plugins/export/ExportVCalendar.py
+++ b/src/plugins/export/ExportVCalendar.py
@@ -47,83 +47,21 @@ log = logging.getLogger(".ExportVCal")
 # GRAMPS modules
 #
 #-------------------------------------------------------------------------
+from ExportOptions import WriterOptionBox
 from Filters import GenericFilter, Rules, build_filter_model
 import Utils
 from gen.lib import Date, EventType
 import Errors
 from glade import Glade
 
-#-------------------------------------------------------------------------
-#
-# CalendarWriterOptionBox class
-#
-#-------------------------------------------------------------------------
-class CalendarWriterOptionBox(object):
-    """
-    Create a VBox with the option widgets and define methods to retrieve
-    the options.
-     
-    """
-    def __init__(self, person):
-        self.person = person
-
-        self.topDialog = Glade()
-        self.copy = 0
-        
-    def get_option_box(self):
-        self.filters = self.topDialog.get_object("filter")
-
-        everyone_filter = GenericFilter()
-        everyone_filter.set_name(_("Entire Database"))
-        everyone_filter.add_rule(Rules.Person.Everyone([]))
-
-        the_filters = [everyone_filter]
-
-        if self.person:
-            des = GenericFilter()
-            des.set_name(_("Descendants of %s") %
-                         self.person.get_primary_name().get_name())
-            des.add_rule(Rules.Person.IsDescendantOf(
-                [self.person.get_gramps_id(),1]))
-
-            ans = GenericFilter()
-            ans.set_name(_("Ancestors of %s") %
-                         self.person.get_primary_name().get_name())
-            ans.add_rule(Rules.Person.IsAncestorOf(
-                [self.person.get_gramps_id(),1]))
-            
-            com = GenericFilter()
-            com.set_name(_("People with common ancestor with %s") %
-                         self.person.get_primary_name().get_name())
-            com.add_rule(Rules.Person.HasCommonAncestorWith(
-                [self.person.get_gramps_id()]))
-            
-            the_filters += [des, ans, com]
-
-        from Filters import CustomFilters
-        the_filters.extend(CustomFilters.get_filters('Person'))
-        self.filter_menu = build_filter_model(the_filters)
-        self.filters.set_model(self.filter_menu)
-        self.filters.set_active(0)
-
-        the_box = self.topDialog.get_object('vbox1')
-        the_parent = self.topDialog.get_object('dialog-vbox1')
-        the_parent.remove(the_box)
-        self.topDialog.toplevel.destroy()
-        return the_box
-
-    def parse_options(self):
-        self.cfilter = self.filter_menu[self.filters.get_active()][1]
-
 class CalendarWriter(object):
-    def __init__(self, database, msg_callback, cl=0, filename="", option_box=None,
+    def __init__(self, database, filename, msg_callback, option_box=None,
                  callback=None):
         self.db = database
-        self.option_box = option_box
-        self.cl = cl
         self.filename = filename
-        self.callback = callback
         self.msg_callback = msg_callback
+        self.option_box = option_box
+        self.callback = callback
         if callable(self.callback): # callback is really callable
             self.update = self.update_real
         else:
@@ -139,29 +77,9 @@ class CalendarWriter(object):
         self.persons_notes_done = []
         self.person_ids = {}
         
-        if not option_box:
-            self.cl_setup()
-        else:
+        if option_box:
             self.option_box.parse_options()
-
-            if self.option_box.cfilter is None:
-                self.plist.udpate([p, 1]
-                    for p in self.db.iter_person_handles())
-            else:
-                try:
-                    self.plist.update([p, 1] 
-                        for p in self.option_box.cfilter.apply(
-                            self.db, self.db.iter_person_handles()))
-                except Errors.FilterError, msg:
-                    (m1, m2) = msg.messages()
-                    self.msg_callback(m1, m2)
-                    return
-
-            self.flist = {}
-            for key in self.plist:
-                p = self.db.get_person_from_handle(key)
-                for family_handle in p.get_family_handle_list():
-                    self.flist[family_handle] = 1
+            self.db = option_box.get_filtered_database(self.db)
  
     def update_empty(self):
         pass
@@ -173,17 +91,6 @@ class CalendarWriter(object):
             self.callback(newval)
             self.oldval = newval
 
-    def cl_setup(self):
-        for p in self.db.iter_person_handles():
-            self.plist[p] = 1
-
-        self.flist = {}
-
-        for key in self.plist:
-            p = self.db.get_person_from_handle(key)
-            for family_handle in p.get_family_handle_list():
-                self.flist[family_handle] = 1
-
     def writeln(self, text):
         #self.g.write('%s\n' % (text.encode('iso-8859-1')))
         self.g.write('%s\n' % (text.encode(sys.getfilesystemencoding())))
@@ -205,12 +112,13 @@ class CalendarWriter(object):
         self.writeln("PRODID:-//GNU//Gramps//EN")
         self.writeln("VERSION:1.0")
 
-        self.total = len(self.plist) + len(self.flist)
-        for key in self.plist:
+        self.total = (len([x for x in self.db.iter_person_handles()]) + 
+                      len([x for x in self.db.iter_family_handles()]))
+        for key in self.db.iter_person_handles():
             self.write_person(key)
             self.update()
 
-        for key in self.flist:
+        for key in self.db.iter_family_handles():
             self.write_family(key)
             self.update()
 
@@ -339,6 +247,6 @@ class CalendarWriter(object):
 #
 #
 #-------------------------------------------------------------------------
-def exportData(database, filename, option_box=None, callback=None):
+def exportData(database, filename, msg_callback, option_box=None, callback=None):
     cw = CalendarWriter(database, 0, filename, option_box, callback)
     return cw.export_data(filename)
diff --git a/src/plugins/export/ExportVCard.py b/src/plugins/export/ExportVCard.py
index 5f7607f7e..c77535cfa 100644
--- a/src/plugins/export/ExportVCard.py
+++ b/src/plugins/export/ExportVCard.py
@@ -46,107 +46,27 @@ log = logging.getLogger(".ExportVCard")
 # GRAMPS modules
 #
 #-------------------------------------------------------------------------
+from ExportOptions import WriterOptionBox
 from Filters import GenericFilter, Rules, build_filter_model
 from gen.lib import Date
 import Errors
 from glade import Glade
 
-#-------------------------------------------------------------------------
-#
-# CardWriterOptionBox class
-#
-#-------------------------------------------------------------------------
-class CardWriterOptionBox(object):
-    """
-    Create a VBox with the option widgets and define methods to retrieve
-    the options.
-     
-    """
-    def __init__(self, person):
-        self.person = person
-
-    def get_option_box(self):
-
-        self.topDialog = Glade()
-
-        self.filters = self.topDialog.get_object("filter")
-        self.copy = 0
-
-        all = GenericFilter()
-        all.set_name(_("Entire Database"))
-        all.add_rule(Rules.Person.Everyone([]))
-
-        the_filters = [all]
-
-        if self.person:
-            des = GenericFilter()
-            des.set_name(_("Descendants of %s") %
-                         self.person.get_primary_name().get_name())
-            des.add_rule(Rules.Person.IsDescendantOf(
-                [self.person.get_gramps_id(),1]))
-
-            ans = GenericFilter()
-            ans.set_name(_("Ancestors of %s") %
-                         self.person.get_primary_name().get_name())
-            ans.add_rule(Rules.Person.IsAncestorOf(
-                [self.person.get_gramps_id(),1]))
-
-            com = GenericFilter()
-            com.set_name(_("People with common ancestor with %s") %
-                         self.person.get_primary_name().get_name())
-            com.add_rule(Rules.Person.HasCommonAncestorWith(
-                [self.person.get_gramps_id()]))
-
-            the_filters += [des, ans, com]
-
-        from Filters import CustomFilters
-        the_filters.extend(CustomFilters.get_filters('Person'))
-        self.filter_menu = build_filter_model(the_filters)
-        self.filters.set_model(self.filter_menu)
-        self.filters.set_active(0)
-
-        the_box = self.topDialog.get_object('vbox1')
-        the_parent = self.topDialog.get_object('dialog-vbox1')
-        the_parent.remove(the_box)
-        self.topDialog.toplevel.destroy()
-        return the_box
-
-    def parse_options(self):
-        self.cfilter = self.filter_menu[self.filters.get_active()][1]
-
 class CardWriter(object):
-    def __init__(self, database, msg_callback, cl=0, filename="", option_box=None,
-                 callback=None):
+    def __init__(self, database, filename, msg_callback, option_box=None, callback=None):
         self.db = database
-        self.option_box = option_box
-        self.cl = cl
         self.filename = filename
-        self.callback = callback
         self.msg_callback = msg_callback
+        self.option_box = option_box
+        self.callback = callback
         if callable(self.callback): # callback is really callable
             self.update = self.update_real
         else:
             self.update = self.update_empty
 
-        self.plist = {}
-        
-        if not option_box:
-            self.cl_setup()
-        else:
+        if option_box:
             self.option_box.parse_options()
-
-            if self.option_box.cfilter is None:
-                for p in self.db.iter_person_handles():
-                    self.plist[p] = 1
-            else:
-                try:
-                    for p in self.option_box.cfilter.apply(self.db, 
-                               self.db.iter_person_handles()):
-                        self.plist[p] = 1
-                except Errors.FilterError, msg:
-                    (m1, m2) = msg.messages()
-                    self.msg_callback(m1, m2)
-                    return
+            self.db = option_box.get_filtered_database(self.db)
 
     def update_empty(self):
         pass
@@ -158,9 +78,6 @@ class CardWriter(object):
             self.callback(newval)
             self.oldval = newval
 
-    def cl_setup(self):
-        self.plist.update([p, 1] for p in self.db.iter_person_handles())
-
     def writeln(self, text):
         #self.g.write('%s\n' % (text.encode('iso-8859-1')))
         self.g.write('%s\n' % (text.encode(sys.getfilesystemencoding())))
@@ -180,8 +97,8 @@ class CardWriter(object):
 
         self.count = 0
         self.oldval = 0
-        self.total = len(self.plist)
-        for key in self.plist:
+        self.total = len([x for x in self.db.iter_person_handles()])
+        for key in self.db.iter_person_handles():
             self.write_person(key)
             self.update()
 
@@ -252,6 +169,6 @@ class CardWriter(object):
 #
 #
 #-------------------------------------------------------------------------
-def exportData(database, filename, option_box=None, callback=None):
-    cw = CardWriter(database, 0, filename, option_box, callback)
+def exportData(database, filename, msg_callback, option_box=None, callback=None):
+    cw = CardWriter(database, filename, msg_callback, option_box, callback)
     return cw.export_data(filename)
diff --git a/src/plugins/export/ExportXml.py b/src/plugins/export/ExportXml.py
index 473a77939..369968dd7 100644
--- a/src/plugins/export/ExportXml.py
+++ b/src/plugins/export/ExportXml.py
@@ -1163,27 +1163,7 @@ def export_data(database, filename, msg_callback, option_box=None, callback=None
 
     if option_box:
         option_box.parse_options()
-    
-        if option_box.private:
-            database = gen.proxy.PrivateProxyDb(database)
-    
-        if option_box.restrict:
-            database = gen.proxy.LivingProxyDb(
-                database, gen.proxy.LivingProxyDb.MODE_INCLUDE_LAST_NAME_ONLY)
-    
-        # Apply the Person Filter
-        if not option_box.cfilter.is_empty():
-            database = gen.proxy.FilterProxyDb(database, option_box.cfilter)
-    
-        # Apply the Note Filter
-        if not option_box.nfilter.is_empty():
-            database = gen.proxy.FilterProxyDb(
-                database, note_filter=option_box.nfilter)
-        
-        # Apply the ReferencedProxyDb to remove any objects not referenced
-        # after any of the other proxies have been applied
-        if option_box.unlinked:
-            database = gen.proxy.ReferencedProxyDb(database)
+        database = option_box.get_filtered_database(database)
 
     g = XmlWriter(database, msg_callback, callback, 0, compress)
     return g.write(filename)
diff --git a/src/plugins/export/export.gpr.py b/src/plugins/export/export.gpr.py
index 9fd89397c..0fe29f01d 100644
--- a/src/plugins/export/export.gpr.py
+++ b/src/plugins/export/export.gpr.py
@@ -58,7 +58,7 @@ plg.status = STABLE
 plg.fname = 'ExportFtree.py'
 plg.ptype = EXPORT
 plg.export_function = 'writeData'
-plg.export_options = 'FtreeWriterOptionBox'
+plg.export_options = 'WriterOptionBox'
 plg.export_options_title = ('Web Family Tree export options')
 plg.extension = "wft"
 
@@ -101,7 +101,7 @@ plg.status = STABLE
 plg.fname = 'ExportGeneWeb.py'
 plg.ptype = EXPORT
 plg.export_function = 'exportData'
-plg.export_options = 'GeneWebWriterOptionBox'
+plg.export_options = 'WriterOptionBox'
 plg.export_options_title = ('GeneWeb export options')
 plg.extension = "gw"
 
@@ -167,7 +167,7 @@ plg.status = STABLE
 plg.fname = 'ExportVCalendar.py'
 plg.ptype = EXPORT
 plg.export_function = 'exportData'
-plg.export_options = 'CalendarWriterOptionBox'
+plg.export_options = 'WriterOptionBox'
 plg.export_options_title = ('vCalendar export options')
 plg.extension = "vcs"
 
@@ -188,6 +188,6 @@ plg.status = STABLE
 plg.fname = 'ExportVCard.py'
 plg.ptype = EXPORT
 plg.export_function = 'exportData'
-plg.export_options = 'CardWriterOptionBox'
+plg.export_options = 'WriterOptionBox'
 plg.export_options_title = ('vCard export options')
 plg.extension = "vcf"