preferences.py

Go to the documentation of this file.

# Copyright 2005, 2006  Timo Savola
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.

import os
import gobject
import pango
import gtk
import gtk.glade

import settings
import extension

##
## Preferences

class Preferences (gobject.GObject):
        current = (None, None)

        def __init__(self, datadir):
                gobject.GObject.__init__(self)

                path = os.path.join(datadir, 'encode', 'preferences.glade')
                self.glade = gtk.glade.XML(path)
                self.glade.signal_autoconnect(self)

                # Tree

                treeview = self.glade.get_widget('treeview')

                store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_OBJECT, gobject.TYPE_INT, gobject.TYPE_BOOLEAN)
                treeview.set_model(store)

                render = gtk.CellRendererText()
                render.set_property('foreground', 'blue')
                column = gtk.TreeViewColumn(None, render)
                column.add_attribute(render, 'text', 0)
                column.add_attribute(render, 'foreground-set', 3)
                treeview.append_column(column)

                selection = treeview.get_selection()
                selection.connect('changed', self.on_selection_changed)

                # Extensions

                extensions_by_name = []

                for klass in extension.get_children(settings.SettingsExtension):
                        ext = klass()
                        name = ext.get_name()

                        extensions_by_name.append((name, ext))

                extensions_by_name.sort()

                # Pages

                import environment
                env = environment.Settings()
                del environment

                root = self.add_page(store, None, env)

                for name, ext in extensions_by_name:
                        self.add_page(store, root, ext)

                treeview.expand_row((0,), open_all=True)
                selection.select_iter(root)

                # Show

                window = self.glade.get_widget('window')
                window.show()

        def add_page(self, store, parent, settings):
                widget = settings.get_widget()

                normal_size = widget.style.font_desc.get_size()
                label_size = int(normal_size * 1.5)

                normal_weight = widget.style.font_desc.get_weight()
                label_weight = int(normal_weight * 1.5)

                attrs = pango.AttrList()
                attrs.insert(pango.AttrSize(label_size, end_index=-1))
                attrs.insert(pango.AttrWeight(label_weight, end_index=-1))

                title = settings.get_title()
                label = gtk.Label(title)
                label.set_attributes(attrs)
                label.set_alignment(0, 0)
                label.set_padding(12, 6)
                label.show()

                separator = gtk.HSeparator()
                separator.show()

                align = gtk.Alignment(xscale=1, yscale=1)
                align.set_padding(12, 12, 12, 12)
                align.show()
                align.add(widget)

                viewport = gtk.Viewport()
                viewport.set_shadow_type(gtk.SHADOW_NONE)
                viewport.show()
                viewport.add(align)

                window = gtk.ScrolledWindow()
                window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
                window.set_shadow_type(gtk.SHADOW_NONE)
                window.show()
                window.add(viewport)

                box = gtk.VBox()
                box.show()
                box.pack_start(label, expand=False, fill=False)
                box.pack_start(separator, expand=False, fill=False)
                box.pack_start(window, expand=True, fill=True)

                notebook = self.glade.get_widget('notebook')
                page = notebook.append_page(box)

                name = settings.get_name()
                iter = store.append(parent, (name, settings, page, False))

                settings.connect('modified', self.on_settings_modified, iter)

                return iter

        def on_selection_changed(self, selection):
                self.current = selection.get_selected()
                store, iter = self.current

                page = store.get_value(iter, 2)
                notebook = self.glade.get_widget('notebook')
                notebook.set_current_page(page)

                self._update_buttons()

        def on_settings_modified(self, settings, iter):
                if settings.accept:
                        store = self.current[0]
                        store.set_value(iter, 3, True)

                        self._update_buttons()

        def on_apply_clicked(self, button):
                store, iter = self.current

                settings = store.get_value(iter, 1)
                try:
                        settings.accept = False
                        settings.apply()
                finally:
                        settings.accept = True

                store.set_value(iter, 3, False)

                self._update_buttons()

        def on_revert_clicked(self, button):
                store, iter = self.current

                settings = store.get_value(iter, 1)
                try:
                        settings.accept = False
                        settings.revert()
                finally:
                        settings.accept = True

                store.set_value(iter, 3, False)

                self._update_buttons()

        # TODO: prompt user if there are unsaved changes?
        def on_close_clicked(self, button):
                window = self.glade.get_widget('window')
                window.destroy()

        def on_window_destroy(self, window):
                self.emit('quit')

        def _update_buttons(self):
                store, iter = self.current
                modified = store.get_value(iter, 3)

                for name in ('apply_button', 'revert_button'):
                        widget = self.glade.get_widget(name)
                        widget.set_sensitive(modified)

gobject.type_register(Preferences)
gobject.signal_new('quit', Preferences, 0, gobject.TYPE_NONE, [])

##
## Main

def main(datadir):
        try:
                extension.load(None, 'encode.*', datadir)

                def on_quit(prefs):
                        gtk.main_quit()

                prefs = Preferences(datadir)
                prefs.connect('quit', on_quit)

                gtk.main()

        except KeyboardInterrupt:
                pass

---