def _local_init(self):
"""
Performs basic initialization, including setting up widgets and the
glade interface.
Local initialization function.
This is called by the base class of EditPrimary, and overridden here.
"""
self.width_key = 'interface.person-width'
self.height_key = 'interface.person-height'
self.pname = self.obj.get_primary_name()
self.should_guess_gender = (not self.obj.get_gramps_id()
and self.obj.get_gender()
== gen.lib.Person.UNKNOWN)
self.top = Glade()
self.set_window(self.top.toplevel, None, self.get_menu_title())
self.obj_photo = self.top.get_object("personPix")
self.frame_photo = self.top.get_object("frame5")
self.eventbox = self.top.get_object("eventbox1")
self.singsurnfr = SingSurn(self.top)
self.multsurnfr = self.top.get_object("hboxmultsurnames")
self.singlesurn_active = True
self.surntab = SurnameTab(self.dbstate,
self.uistate,
self.track,
self.obj.get_primary_name(),
on_change=self._changed_name)
self.set_contexteventbox(self.top.get_object("eventboxtop"))
def _local_init(self):
self.width_key = 'interface.source-width'
self.height_key = 'interface.source-height'
assert (self.obj)
self.glade = Glade()
self.set_window(self.glade.toplevel, None, self.get_menu_title())
def __init__(self, dbstate, parent=None):
"""
Create the top level window from the glade description, and extracts
the GTK widgets that are needed.
"""
CLIDbManager.__init__(self, dbstate)
self.glade = Glade()
self.top = self.glade.toplevel
if parent:
self.top.set_transient_for(parent)
for attr in [
'connect', 'cancel', 'new', 'remove', 'dblist', 'rename',
'repair', 'rcs', 'msg'
]:
setattr(self, attr, self.glade.get_object(attr))
self.model = None
self.column = None
self.lock_file = None
self.data_to_delete = None
self.selection = self.dblist.get_selection()
self.dblist.set_rules_hint(True)
self.__connect_signals()
self.__build_interface()
self._populate_model()
def _local_init(self):
self.width_key = 'interface.repo-width'
self.height_key = 'interface.repo-height'
self.glade = Glade()
self.set_window(self.glade.toplevel, None, self.get_menu_title())
def _local_init(self):
self.width_key = 'interface.attribute-width'
self.height_key = 'interface.attribute-height'
self.top = Glade()
self.set_window(self.top.toplevel, self.top.get_object('title'),
_('Attribute Editor'))
def __init__(self, uistate):
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self)
xml = Glade()
window = xml.toplevel
self.set_window(window,
xml.get_object("title"),
_("Tip of the Day"),
_("Tip of the Day"))
self.tip = xml.get_object("tip")
self.use = xml.get_object('usetips')
self.use.set_active(config.get('behavior.use-tips'))
image = xml.get_object('image')
image.set_from_file(os.path.join(const.IMAGE_DIR, 'splash.jpg'))
next = xml.get_object('next')
next.connect("clicked", self.next_tip_cb)
close = xml.get_object('close')
close.connect("clicked", self.close_cb)
try:
tparser = TipParser()
except (IOError,ExpatError), e:
self.close()
ErrorDialog(
_("Failed to display tip of the day"),
_("Unable to read the tips from external file.\n\n%s")%e)
return
def __init__(self, msg1, msg2, label_msg1, label_msg2, parent=None):
self.xml = Glade(toplevel='questiondialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
label1 = self.xml.get_object('qd_label1')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('qd_label2')
# see https://github.com/emesene/emesene/issues/723
label2.connect('activate-link', on_activate_link)
label2.set_text(msg2)
label2.set_use_markup(True)
self.xml.get_object('okbutton').set_label(label_msg1)
self.xml.get_object('okbutton').set_use_underline(True)
self.xml.get_object('no').set_label(label_msg2)
self.xml.get_object('no').set_use_underline(True)
if parent:
self.top.set_transient_for(parent)
self.top.show()
def _local_init(self):
self.width_key = 'interface.media-ref-width'
self.height_key = 'interface.media-ref-height'
self.top = Glade()
self.set_window(self.top.toplevel, self.top.get_object('title'),
_('Media Reference Editor'))
self.define_warn_box(self.top.get_object("warn_box"))
self.top.get_object("label427").set_text(_("Y coordinate|Y"))
self.top.get_object("label428").set_text(_("Y coordinate|Y"))
tblref = self.top.get_object('table50')
self.notebook_ref = self.top.get_object('notebook_ref')
self.track_ref_for_deletion("notebook_ref")
#recreate start page as GrampsTab
self.notebook_ref.remove_page(0)
self.reftab = RefTab(self.dbstate, self.uistate, self.track,
_('General'), tblref)
self.track_ref_for_deletion("reftab")
tblref = self.top.get_object('table2')
self.notebook_shared = self.top.get_object('notebook_shared')
#recreate start page as GrampsTab
self.notebook_shared.remove_page(0)
self.track_ref_for_deletion("notebook_shared")
self.primtab = RefTab(self.dbstate, self.uistate, self.track,
_('_General'), tblref)
self.track_ref_for_deletion("primtab")
self.rect_pixbuf = None
def _local_init(self):
self.width_key = 'interface.name-width'
self.height_key = 'interface.name-height'
self.top = Glade()
self.set_window(self.top.toplevel, None, _("Name Editor"))
tblgnam = self.top.get_object('table23')
notebook = self.top.get_object('notebook')
hbox_surn = self.top.get_object('hboxmultsurnames')
hbox_surn.set_size_request(
-1, int(config.get('interface.surname-box-height')))
hbox_surn.pack_start(
SurnameTab(self.dbstate,
self.uistate,
self.track,
self.obj,
top_label=None))
#recreate start page as GrampsTab
notebook.remove_page(0)
self.gennam = GeneralNameTab(self.dbstate, self.uistate, self.track,
_('_General'), tblgnam)
self.original_group_as = self.obj.get_group_as()
self.original_group_set = not (self.original_group_as == '')
srn = self.obj.get_primary_surname().get_surname()
self._get_global_grouping(srn)
self.group_over = self.top.get_object('group_over')
self.group_over.connect('toggled', self.on_group_over_toggled)
self.group_over.set_sensitive(not self.db.readonly)
self.toggle_dirty = False
def __init__(self,
msg1,
msg2,
btnmsg1,
task1,
btnmsg2,
task2,
parent=None):
self.xml = Glade(toplevel='optiondialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
label1 = self.xml.get_object('od_label1')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('od_label2')
label2.set_text(msg2)
label2.set_use_markup(True)
self.xml.get_object('option1').set_label(btnmsg1)
self.xml.get_object('option2').set_label(btnmsg2)
if parent:
self.top.set_transient_for(parent)
self.top.show()
self.response = self.top.run()
if self.response == gtk.RESPONSE_NO:
if task1:
task1()
else:
if task2:
task2()
self.top.destroy()
def __init__(self, msg1, msg2, task1, task2, parent=None):
self.xml = Glade(toplevel='savedialog')
self.top = self.xml.toplevel
self.top.set_icon(ICON)
self.top.set_title("%s - Gramps" % msg1)
self.dontask = self.xml.get_object('dontask')
self.task1 = task1
self.task2 = task2
label1 = self.xml.get_object('sd_label1')
label1.set_text('<span weight="bold" size="larger">%s</span>' % msg1)
label1.set_use_markup(True)
label2 = self.xml.get_object('sd_label2')
label2.set_text(msg2)
label2.set_use_markup(True)
if parent:
self.top.set_transient_for(parent)
self.top.show()
response = self.top.run()
if response == gtk.RESPONSE_NO:
self.task1()
elif response == gtk.RESPONSE_YES:
self.task2()
config.set('interface.dont-ask', self.dontask.get_active())
self.top.destroy()
def __build_window(self):
"""Build the window from Glade.
"""
from glade import Glade
glade_xml = Glade()
self._window = glade_xml.toplevel
#self._window.set_transient_for(parent)
# remember active widgets for future use
self._swin = glade_xml.get_object('swin')
self._drawing_area = glade_xml.get_object('drawingarea')
self._first_button = glade_xml.get_object('first')
self._prev_button = glade_xml.get_object('prev')
self._next_button = glade_xml.get_object('next')
self._last_button = glade_xml.get_object('last')
self._pages_entry = glade_xml.get_object('entry')
self._pages_label = glade_xml.get_object('label')
self._zoom_fit_width_button = glade_xml.get_object('zoom_fit_width')
self._zoom_fit_width_button.set_stock_id('gramps-zoom-fit-width')
self._zoom_best_fit_button = glade_xml.get_object('zoom_best_fit')
self._zoom_best_fit_button.set_stock_id('gramps-zoom-best-fit')
self._zoom_in_button = glade_xml.get_object('zoom_in')
self._zoom_in_button.set_stock_id('gramps-zoom-in')
self._zoom_out_button = glade_xml.get_object('zoom_out')
self._zoom_out_button.set_stock_id('gramps-zoom-out')
# connect the signals
glade_xml.connect_signals(self)
def __init__(self, dbstate, uistate, options_class, name, callback=None):
self.dbstate = dbstate
self.uistate = uistate
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self)
self.qual = 0
self.filterDialog = Glade(toplevel="filters")
self.filterDialog.connect_signals({
"on_apply_clicked": self.on_apply_clicked,
"on_editor_clicked": self.filter_editor_clicked,
"on_help_clicked": self.on_help_clicked,
"destroy_passed_object": self.close,
"on_write_table": self.__dummy,
})
window = self.filterDialog.toplevel
window.show()
self.filters = self.filterDialog.get_object("filter_list")
self.label = _('Event comparison filter selection')
self.set_window(window, self.filterDialog.get_object('title'),
self.label)
self.on_filters_changed('Person')
uistate.connect('filters-changed', self.on_filters_changed)
self.show()
def _local_init(self):
"""Local initialization function.
Perform basic initialization, including setting up widgets
and the glade interface. It is called by the base class L{EditPrimary},
and overridden here.
"""
self.width_key = 'interface.note-width'
self.height_key = 'interface.note-height'
self.top = Glade()
win = self.top.toplevel
self.set_window(win, None, self.get_menu_title())
vboxnote = self.top.get_object('vbox131')
notebook = self.top.get_object('note_notebook')
#recreate start page as GrampsTab
notebook.remove_page(0)
self.ntab = NoteTab(self.dbstate, self.uistate, self.track,
_('_Note'), vboxnote)
self.track_ref_for_deletion("ntab")
self.build_interface()
def init_gui(self):
# Draw dialog and make it handle everything
self.glade = Glade()
self.auto1 = self.glade.get_object("original")
self.auto2 = self.glade.get_object("new")
# Need to display localized event names
etype = EventType()
event_names = sorted(etype.get_standard_names(), key=locale.strxfrm)
AutoComp.fill_combo(self.auto1, event_names)
AutoComp.fill_combo(self.auto2, event_names)
etype.set_from_xml_str(self.options.handler.options_dict['fromtype'])
self.auto1.child.set_text(str(etype))
etype.set_from_xml_str(self.options.handler.options_dict['totype'])
self.auto2.child.set_text(str(etype))
window = self.glade.toplevel
self.set_window(window, self.glade.get_object('title'), self.title)
self.glade.connect_signals({
"on_close_clicked": self.close,
"on_apply_clicked": self.on_apply_clicked,
"on_delete_event": self.close,
})
self.show()
def _local_init(self):
self.width_key = 'interface.address-width'
self.height_key = 'interface.address-height'
self.top = Glade()
self.set_window(self.top.toplevel,
self.top.get_object("title"),
_('Address Editor'))
def _local_init(self):
self.width_key = 'interface.url-width'
self.height_key = 'interface.url-height'
self.top = Glade()
self.jump = self.top.get_object('jump')
self.set_window(self.top.toplevel, self.top.get_object("title"),
_('Internet Address Editor'))
def _local_init(self):
self.width_key = 'interface.lds-width'
self.height_key = 'interface.lds-height'
self.top = Glade()
self.set_window(self.top.toplevel, self.top.get_object('title'),
_('LDS Ordinance Editor'))
self.share_btn = self.top.get_object('share_place')
self.add_del_btn = self.top.get_object('add_del_place')
def _local_init(self):
self.width_key = 'interface.person-ref-width'
self.height_key = 'interface.person-ref-height'
self.top = Glade()
self.set_window(self.top.toplevel,
self.top.get_object("title"),
_('Person Reference Editor'))
self.person_label = self.top.get_object('person')
def display(self, obj):
obj.hide()
self.glade = Glade()
top = self.glade.toplevel
msg = self.glade.get_object('msg')
buf = msg.get_buffer()
for i in self.get_formatted_log():
buf.insert_at_cursor(i + '\n')
top.run()
top.destroy()
def _local_init(self):
self.width_key = 'interface.event-width'
self.height_key = 'interface.event-height'
self.top = Glade()
self.set_window(self.top.toplevel, None, self.get_menu_title())
self.place = self.top.get_object('place')
self.share_btn = self.top.get_object('select_place')
self.add_del_btn = self.top.get_object('add_del_place')
def check_in(dbase, filename, callback, cursor_func=None):
"""
Checks in the specified file into RCS
"""
init = ["rcs", '-x,v', '-i', '-U', '-q', '-t-"Gramps database"']
ci_cmd = ["ci", '-x,v', "-q", "-f"]
archive_name = filename + ",v"
glade = Glade(toplevel='comment')
top = glade.toplevel
text = glade.get_object('description')
top.run()
comment = text.get_text()
top.destroy()
if not os.path.isfile(archive_name):
cmd = init + [archive_name]
proc = subprocess.Popen(cmd, stderr=subprocess.PIPE)
status = proc.wait()
message = "\n".join(proc.stderr.readlines())
proc.stderr.close()
del proc
if status != 0:
ErrorDialog(
_("Archiving failed"),
_("An attempt to create the archive failed "
"with the following message:\n\n%s") % message)
if cursor_func:
cursor_func(_("Creating data to be archived..."))
plugin_manager = GuiPluginManager.get_instance()
for plugin in plugin_manager.get_export_plugins():
if plugin.get_extension() == "gramps":
export_function = plugin.get_export_function()
export_function(dbase, filename, None, callback)
if cursor_func:
cursor_func(_("Saving archive..."))
cmd = ci_cmd + ['-m%s' % comment, filename, archive_name]
proc = subprocess.Popen(cmd, stderr=subprocess.PIPE)
status = proc.wait()
message = "\n".join(proc.stderr.readlines())
proc.stderr.close()
del proc
if status != 0:
ErrorDialog(
_("Archiving failed"),
_("An attempt to archive the data failed "
"with the following message:\n\n%s") % message)
def importData(database, filename, callback=None):
"""
Try to handle ANSEL encoded files that are not really ANSEL encoded
"""
if DbMixin not in database.__class__.__bases__:
database.__class__.__bases__ = (DbMixin,) + \
database.__class__.__bases__
try:
ifile = open(filename, "r")
except IOError:
return
ansel = False
gramps = False
for index in range(50):
line = ifile.readline().split()
if len(line) == 0:
break
if len(line) > 2 and line[1][0:4] == 'CHAR' and line[2] == "ANSEL":
ansel = True
if len(line) > 2 and line[1][0:4] == 'SOUR' and line[2] == "GRAMPS":
gramps = True
ifile.close()
if not gramps and ansel:
top = Glade()
code = top.get_object('codeset')
code.set_active(0)
dialog = top.toplevel
dialog.run()
enc = ['ANSEL', 'ANSEL', 'ANSI', 'ASCII', 'UTF-8']
code_set = enc[code.get_active()]
dialog.destroy()
else:
code_set = ""
assert (isinstance(code_set, basestring))
try:
ifile = open(filename, "rU")
stage_one = libgedcom.GedcomStageOne(ifile)
stage_one.parse()
if code_set:
stage_one.set_encoding(code_set)
ifile.seek(0)
gedparse = libgedcom.GedcomParser(
database, ifile, filename, callback, stage_one,
config.get('preferences.default-source'))
except IOError, msg:
ErrorDialog(_("%s could not be opened\n") % filename, str(msg))
return
def _local_init(self):
self.top = Glade()
self.set_window(self.top.toplevel, self.top.get_object("title"),
_('Link Editor'))
self.table = self.top.get_object('table27')
self.uri_list = gtk.combo_box_new_text()
for text in [
_("Internet Address"), # 0 this order range above
_("Event"), # 1
_("Family"), # 2
_("Media"), # 3
_("Note"), # 4
_("Person"), # 5
_("Place"), # 6
_("Repository"), # 7
_("Source"), # 8
]:
self.uri_list.append_text(text)
self.table.attach(self.uri_list, 1, 2, 0, 1)
self.pick_item = self.top.get_object('button1')
#self.edit_item = self.top.get_object('button2')
self.selected = self.top.get_object('label1')
self.url_link = self.top.get_object('entry1')
self.uri_list.connect("changed", self._on_type_changed)
self.pick_item.connect("clicked", self._on_pick_one)
#self.edit_item.connect("clicked", self._on_edit_one)
if self.url.startswith("gramps://"):
object_class, prop, value = self.url[9:].split("/", 2)
if object_class == "Event":
self.uri_list.set_active(EVENT)
elif object_class == "Family":
self.uri_list.set_active(FAMILY)
elif object_class == "Media":
self.uri_list.set_active(MEDIA)
elif object_class == "Note":
self.uri_list.set_active(NOTE)
elif object_class == "Person":
self.uri_list.set_active(PERSON)
elif object_class == "Place":
self.uri_list.set_active(PLACE)
elif object_class == "Repository":
self.uri_list.set_active(REPOSITORY)
elif object_class == "Source":
self.uri_list.set_active(SOURCE)
# set texts:
self.selected.set_text(self.display_link(object_class, prop,
value))
self.url_link.set_text("gramps://%s/%s/%s" %
(object_class, prop, value))
else:
self.uri_list.set_active(WEB)
self.url_link.set_text(self.url)
self.url_link.connect("changed", self.update_ui)
def _local_init(self):
self.width_key = 'interface.child-ref-width'
self.height_key = 'interface.child-ref-height'
self.top = Glade()
self.set_window(self.top.toplevel, self.top.get_object("title"),
self.name, _('Child Reference Editor'))
self.ok_button = self.top.get_object('ok')
self.edit_button = self.top.get_object('edit')
self.name_label = self.top.get_object('name')
self.name_label.set_text(self.name)
def __init__(self, name, style, parent):
"""
Create the StyleEditor.
name - name of the style that is to be edited
style - style object that is to be edited
parent - StyleListDisplay object that called the editor
"""
self.current_p = None
self.current_name = None
self.style = StyleSheet(style)
self.parent = parent
self.top = Glade(toplevel='editor')
self.window = self.top.toplevel
self.top.connect_signals({
"on_save_style_clicked": self.on_save_style_clicked,
"destroy_passed_object": self.__close,
"on_ok_clicked": dummy_callback,
"on_add_clicked": dummy_callback,
"on_delete_clicked": dummy_callback,
"on_button_press": dummy_callback,
"on_edit_clicked": dummy_callback,
})
self.pname = self.top.get_object('pname')
self.pdescription = self.top.get_object('pdescription')
ManagedWindow.set_titles(self.window, self.top.get_object('title'),
_('Style editor'))
self.top.get_object("label6").set_text(_("point size|pt"))
titles = [(_('Paragraph'), 0, 130)]
self.plist = ListModel.ListModel(self.top.get_object("ptree"), titles,
self.change_display)
self.top.get_object('color').connect('color-set', self.fg_color_set)
self.top.get_object('bgcolor').connect('color-set', self.bg_color_set)
self.top.get_object("style_name").set_text(name)
names = self.style.get_paragraph_style_names()
names.reverse()
for p_name in names:
self.plist.add([p_name], self.style.get_paragraph_style(p_name))
self.plist.select_row(0)
if self.parent:
self.window.set_transient_for(parent.window)
self.window.run()
self.window.destroy()
def display(self):
# get the main window from glade
topDialog = Glade()
# set gramps style title for the window
window = topDialog.toplevel
self.set_window(window, topDialog.get_object("title"),
_("Database Owner Editor"))
# move help button to the left side
action_area = topDialog.get_object("action_area")
help_button = topDialog.get_object("help_button")
action_area.set_child_secondary(help_button, True)
# connect signals
topDialog.connect_signals({
"on_ok_button_clicked": self.on_ok_button_clicked,
"on_cancel_button_clicked": self.close,
"on_help_button_clicked": self.on_help_button_clicked,
"on_eventbox_button_press_event": self.on_button_press_event,
"on_menu_activate": self.on_menu_activate,
"on_delete_event": self.close,
})
# fetch the popup menu
self.menu = topDialog.get_object("popup_menu")
#topDialog.connect_signals({"on_menu_activate": self.on_menu_activate})
# get current db owner and attach it to the entries of the window
self.owner = self.db.get_researcher()
self.entries = []
entry = [
("name", self.owner.set_name, self.owner.get_name),
("address", self.owner.set_address, self.owner.get_address),
("locality", self.owner.set_locality, self.owner.get_locality),
("city", self.owner.set_city, self.owner.get_city),
("state", self.owner.set_state, self.owner.get_state),
("country", self.owner.set_country, self.owner.get_country),
("zip", self.owner.set_postal_code, self.owner.get_postal_code),
("phone", self.owner.set_phone, self.owner.get_phone),
("email", self.owner.set_email, self.owner.get_email),
]
for (name, set_fn, get_fn) in entry:
self.entries.append(
MonitoredEntry(topDialog.get_object(name), set_fn, get_fn,
self.db.readonly))
# ok, let's see what we've done
self.show()
def __init__(self, booklist, nodelete=0, dosave=0):
"""
Create a BookListDisplay object that displays the books in BookList.
booklist: books that are displayed
nodelete: if not 0 then the Delete button is hidden
dosave: if 1 then the book list is saved on hitting OK
"""
self.booklist = booklist
self.dosave = dosave
self.xml = Glade()
self.top = self.xml.toplevel
self.unsaved_changes = False
ManagedWindow.set_titles(self.top, self.xml.get_object('title'),
_('Available Books'))
if nodelete:
delete_button = self.xml.get_object("delete_button")
delete_button.hide()
self.xml.connect_signals({
"on_booklist_cancel_clicked": self.on_booklist_cancel_clicked,
"on_booklist_ok_clicked": self.on_booklist_ok_clicked,
"on_booklist_delete_clicked": self.on_booklist_delete_clicked,
"on_book_ok_clicked": self.do_nothing,
"destroy_passed_object": self.do_nothing,
"on_setup_clicked": self.do_nothing,
"on_down_clicked": self.do_nothing,
"on_up_clicked": self.do_nothing,
"on_remove_clicked": self.do_nothing,
"on_add_clicked": self.do_nothing,
"on_edit_clicked": self.do_nothing,
"on_open_clicked": self.do_nothing,
"on_save_clicked": self.do_nothing,
"on_clear_clicked": self.do_nothing
})
title_label = self.xml.get_object('title')
title_label.set_text(Utils.title(_('Book List')))
title_label.set_use_markup(True)
self.blist = ListModel.ListModel(
self.xml.get_object("list"),
[('Name', -1, 10)],
)
self.redraw()
self.selection = None
self.top.run()
def _local_init(self):
self.width_key = 'interface.place-width'
self.height_key = 'interface.place-height'
self.top = Glade()
self.set_window(self.top.toplevel, None,
self.get_menu_title())
tblmloc = self.top.get_object('table19')
notebook = self.top.get_object('notebook3')
#recreate start page as GrampsTab
notebook.remove_page(0)
self.mloc = MainLocTab(self.dbstate, self.uistate, self.track,
_('_Location'), tblmloc)
self.track_ref_for_deletion("mloc")
def __init__(self,default_metric,default_name,default_orientation,
margins=[2.54,2.54,2.54,2.54], custom=[29.7,21.0]):
gtk.HBox.__init__(self)
glade_xml = Glade()
self.paper_table = glade_xml.get_object('paper_table')
# get all the widgets
widgets = ('pwidth', 'pheight', 'lmargin', 'rmargin', 'tmargin',
'bmargin', 'lunits1', 'lunits2', 'lunits3', 'lunits4',
'lunits5', 'lunits6', 'metric')
for w in widgets:
setattr(self, w, glade_xml.get_object(w))
# insert custom widgets
self.papersize_menu = PaperComboBox(default_name)
self.orientation_menu = OrientationComboBox(default_orientation)
self.metric.set_active(default_metric)
# connect all widgets
format_table = glade_xml.get_object('format_table')
format_table.attach(self.papersize_menu, 1, 3, 0, 1,
yoptions=gtk.SHRINK)
format_table.attach(self.orientation_menu, 1, 3, 3, 4,
yoptions=gtk.SHRINK)
# connect signals
self.papersize_menu.connect('changed',self.size_changed)
self.metric.connect('toggled',self.units_changed)
# set initial values
self.paper_unit = 'cm'
self.paper_unit_multiplier = 1.0
self.pwidth.set_text("%.2f" % custom[0])
self.pheight.set_text("%.2f" % custom[1])
self.lmargin.set_text("%.2f" % margins[0])
self.rmargin.set_text("%.2f" % margins[1])
self.tmargin.set_text("%.2f" % margins[2])
self.bmargin.set_text("%.2f" % margins[3])
self.paper_table.show_all()
self.paper_table.reparent(self)
self.units_changed(self.metric)
self.size_changed(None)
