AppRun

#!/usr/bin/env python
import findrox; findrox.version(1, 9, 6)

import os
import subprocess
import sys
import gtk
import rox
from rox.settings import Setting, Settings
from rox.OptionsBox import OptionsBox as OBBase

__builtins__._ = rox.i18n.translation(os.path.join(rox.app_dir, 'Messages'))

class OptionsBox(OBBase):
    def __init__(self, options_group, options_xml, translation = None):
        self.wdict = {}
        OBBase.__init__(self, options_group, options_xml, translation)
        self.all_timeouts = map(self.__get_spin_button_by_name,
                ('BlankTime', 'DPMSStandby', 'DPMSSuspend', 'DPMSOff'))
        self.__connect_signals()
    
    def __build_and_store(self, node, label, option, builder):
        widgets = builder(self, node, label, option)
        name = rox.OptionsBox.str_attr(node, 'name')
        if name:
            if name.startswith('ROX/'):
                name = name[4:]
            self.wdict[name] = widgets
        return widgets
        
    def build_toggle(self, node, label, option):
        return self.__build_and_store(node, label, option,
                OBBase.build_toggle)

    def build_radio_group(self, node, label, option):
        return self.__build_and_store(node, label, option,
                OBBase.build_radio_group)
    
    def build_numentry(self, node, label, option):
        return self.__build_and_store(node, label, option,
                OBBase.build_numentry)
    
    def __connect_signals(self):
        self.__connect_toggled('ManageScreensaver', self.__radio_toggled)
        self.__connect_toggled('DPMSEnable', self.__dpms_toggled)
        self.__connect_timeout_changed('BlankTime')
        self.__connect_timeout_changed('DPMSStandby')
        self.__connect_timeout_changed('DPMSSuspend')
        self.__connect_timeout_changed('DPMSOff')
    
    def __connect_toggled(self, name, fn):
        self.wdict[name][0].connect("toggled", fn)
    
    def __connect_timeout_changed(self, name):
        w = self.__get_spin_button_by_name(name)
        if w:
            w.connect("changed", self.__timeout_changed)
    
    def __get_spin_button_by_name(self, name):
        for w in self.wdict[name][0].get_children():
            if isinstance(w, gtk.SpinButton):
                return w
        else:
            print >> sys.stderr, \
                    'No spin button found for option "ROX/%s"' % name
        return None
    
    def __radio_toggled(self, w):
        radios = self.wdict['ManageScreensaver']
        for n in range(3):
            if radios[n].get_active():
                sensitive = n == 1
                gnome = n == 2
                break
        else:
            sensitive = False
            gnome = False
        for n in ['BlankTime', 'DPMSEnable']:
            self.__set_sensitive(n, sensitive)
        if sensitive:
            sensitive = self.wdict['DPMSEnable'][0].get_active()
        self.__set_dpms_sensitive(sensitive)
        self.gss_prefs_button.set_sensitive(gnome)
    
    def __dpms_toggled(self, w):
        sensitive = self.wdict['DPMSEnable'][0].get_active()
        self.__set_dpms_sensitive(sensitive)
    
    def __set_dpms_sensitive(self, sensitive):
        for n in ['DPMSStandby', 'DPMSSuspend', 'DPMSOff']:
            self.__set_sensitive(n, sensitive)
    
    def __set_sensitive(self, name, sensitive):
        for w in self.wdict[name]:
            w.set_sensitive(sensitive)
    
    def __timeout_changed(self, w):
        timeout = w.get_value_as_int()
        if not timeout:
            return
        if w == self.all_timeouts[0]:
            before = []
            after = self.all_timeouts[1:]
        elif w == self.all_timeouts[1]:
            before = self.all_timeouts[:1]
            after = self.all_timeouts[2:]
        elif w == self.all_timeouts[2]:
            before = self.all_timeouts[:2]
            after = self.all_timeouts[3:]
        elif w == self.all_timeouts[3]:
            before = self.all_timeouts[:3]
            after = []
        else:
            print >>sys.stderr, "Value of unknown widget changed"
            return
        for w in before:
            if w.get_value_as_int() > timeout:
                w.set_value(timeout)
        for w in after:
            t = w.get_value_as_int()
            if t and t < timeout:
                w.set_value(timeout)
    
    def open(self):
        self.__dpms_toggled(None)
        self.__radio_toggled(None)
        for n in ['BlankTime', 'DPMSStandby', 'DPMSSuspend', 'DPMSOff']:
            self.__timeout_changed(self.__get_spin_button_by_name(n))
        OBBase.open(self)


def launch_from_button(w, command):
    subprocess.Popen([command])

def build_cmd_button(box, node, label):
    button = gtk.Button(label)
    box.may_add_tip(button, node)
    button.connect('clicked', launch_from_button,
            rox.OptionsBox.str_attr(node, 'value'))
    box.gss_prefs_button = button
    return [button]

rox.OptionsBox.widget_registry['cmd_button'] = build_cmd_button


settings = Settings()

class SSS(Setting):
	def __init__(self, name, default):
		Setting.__init__(self, name, default, settings)

SSS('ROX/ManageScreensaver', 0)
SSS('ROX/BlankTime', 10)
SSS('ROX/DPMSEnable', 1)
SSS('ROX/DPMSStandby', 15)
SSS('ROX/DPMSSuspend', 20)
SSS('ROX/DPMSOff', 30)

box = OptionsBox(settings, os.path.join(rox.app_dir, 'Options.xml'))
box.open()

rox.mainloop()