← Back to branch summary

~lidaobing/ubuntu-tweak/ubuntu-ubuntu-tweak

« back to all changes in this revision

Viewing changes to ubuntutweak/widgets/widgets.py

  • Committer: LI Daobing
  • Date: 2010-07-31 10:10:26 UTC
  • mto: This revision was merged to the branch mainline in revision 13.
  • Revision ID: lidaobing@gmail.com-20100731101026-9o3m59258q5perbo
Tags: upstream-0.5.5
Import upstream version 0.5.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntutweak/widgets/widgets.py
1
1
#!/usr/bin/python
2
2
 
3
 
# Ubuntu Tweak - PyGTK based desktop configure tool
 
3
# Ubuntu Tweak - PyGTK based desktop configuration tool
4
4
#
5
5
# Copyright (C) 2007-2008 TualatriX <tualatrix@gmail.com>
6
6
#
22
22
pygtk.require("2.0")
23
23
import os
24
24
import gtk
25
 
import gconf
26
25
import gobject
27
 
import gettext
 
26
import logging
28
27
import time
29
 
from ubuntutweak.common.settings import *
 
28
 
 
29
from ubuntutweak.conf import GconfSetting
 
30
from ubuntutweak.conf import SystemGconfSetting
 
31
from ubuntutweak.conf import UserGconfSetting
 
32
from ubuntutweak.policykit import PolkitButton, proxy
 
33
 
 
34
log = logging.getLogger('widgets')
30
35
 
31
36
class GconfCheckButton(gtk.CheckButton):
32
 
    def __init__(self, label = None, key = None, default = None, tooltip = None):
 
37
    def __init__(self, label=None, key=None, default=None, tooltip=None):
33
38
        super(GconfCheckButton, self).__init__()
34
 
        self.__setting = BoolSetting(key, default)
35
 
 
36
 
        self.set_label(label)
37
 
        self.set_active(self.__setting.get_bool())
38
 
        if tooltip:
39
 
            self.set_tooltip_text(tooltip)
40
 
 
41
 
        self.__setting.client.notify_add(key, self.value_changed)
42
 
        self.connect('toggled', self.button_toggled)
43
 
 
44
 
    def value_changed(self, client, id, entry, data = None):
45
 
        self.set_active(self.__setting.get_bool())
46
 
 
47
 
    def button_toggled(self, widget, data = None):
48
 
        self.__setting.set_bool(self.get_active())
 
39
        self.__setting = GconfSetting(key=key, default=default, type=bool)
 
40
 
 
41
        self.set_label(label)
 
42
        self.set_active(self.__setting.get_value())
 
43
        if tooltip:
 
44
            self.set_tooltip_text(tooltip)
 
45
 
 
46
        self.__setting.get_client().notify_add(key, self.value_changed)
 
47
        self.connect('toggled', self.button_toggled)
 
48
 
 
49
    def value_changed(self, client, id, entry, data=None):
 
50
        self.set_active(self.__setting.get_value())
 
51
 
 
52
    def button_toggled(self, widget, data=None):
 
53
        self.__setting.set_value(self.get_active())
 
54
 
 
55
class SystemGconfCheckButton(gtk.CheckButton):
 
56
    def __init__(self, label=None, key=None, default=None, tooltip=None):
 
57
        super(SystemGconfCheckButton, self).__init__()
 
58
        self.__setting = SystemGconfSetting(key, default)
 
59
 
 
60
        self.set_label(label)
 
61
        self.set_active(self.__setting.get_value())
 
62
        if tooltip:
 
63
            self.set_tooltip_text(tooltip)
 
64
 
 
65
        self.connect('toggled', self.button_toggled)
 
66
 
 
67
    def button_toggled(self, widget):
 
68
        self.__setting.set_value(self.get_active())
49
69
        
 
70
class UserGconfCheckButton(gtk.CheckButton):
 
71
    def __init__(self, user=None, label=None, key=None, default=None, tooltip=None):
 
72
        super(UserGconfCheckButton, self).__init__()
 
73
        self.__setting = UserGconfSetting(key, default)
 
74
        self.__user = user
 
75
 
 
76
        self.set_label(label)
 
77
        self.set_active(bool(self.__setting.get_value(self.__user)))
 
78
        if tooltip:
 
79
            self.set_tooltip_text(tooltip)
 
80
 
 
81
        self.connect('toggled', self.button_toggled)
 
82
 
 
83
    def button_toggled(self, widget):
 
84
        self.__setting.set_value(self.__user, self.get_active())
 
85
 
50
86
class StrGconfCheckButton(GconfCheckButton):
51
87
    '''This class use to moniter the key with StringSetting, nothing else'''
52
88
    def __init__(self, **kwargs):
57
93
        pass
58
94
 
59
95
class GconfEntry(gtk.Entry):
60
 
    def __init__(self, key = None, default = None):
 
96
    def __init__(self, key=None, default=None):
61
97
        gtk.Entry.__init__(self)
62
 
        self.__setting = StringSetting(key, default)
 
98
        self.__setting = GconfSetting(key=key, default=default, type=str)
63
99
 
64
 
        string = self.__setting.get_string()
 
100
        string = self.__setting.get_value()
65
101
        if string:
66
102
            self.set_text(string)
67
103
        else:
68
104
            self.set_text(_("Unset"))
69
105
 
 
106
    def is_changed(self):
 
107
        return self.get_string_value() != self.get_text()
 
108
 
 
109
    def get_string_value(self):
 
110
        return self.__setting.get_value()
 
111
 
 
112
    def connect_activate_signal(self):
70
113
        self.connect('activate', self.on_edit_finished_cb)
71
114
 
72
115
    def get_gsetting(self):
73
 
         return self.__setting
 
116
        return self.__setting
 
117
 
 
118
    def reset(self):
 
119
        self.set_text(self.get_string_value())
74
120
 
75
121
    def on_edit_finished_cb(self, widget):
76
122
        string = self.get_text()
77
 
        client = self.__setting.client
78
 
        key = self.__setting.key
 
123
        client = self.__setting.get_client()
 
124
        key = self.__setting.get_key()
79
125
        if string:
80
126
            client.set_string(key, self.get_text())
81
127
        else:
82
128
            client.unset(key)
83
129
            self.set_text(_("Unset"))
84
130
 
85
 
def GconfComboBox(key = None, texts = None, values = None):
 
131
def GconfComboBox(key=None, texts=None, values=None):
86
132
    def value_changed_cb(widget, setting):
87
133
        text = widget.get_active_text()
88
 
        client = setting.client
89
 
        key = setting.key
90
134
 
91
 
        client.set_string(key, setting.values[setting.texts.index(text)])
 
135
        setting.get_client().set_value(setting.get_key(), \
 
136
                                setting.values[setting.texts.index(text)])
92
137
 
93
138
    combobox = gtk.combo_box_new_text()
94
 
    setting = ConstStringSetting(key, values)
 
139
    setting = GconfSetting(key=key)
95
140
    setting.texts = texts
 
141
    setting.values = values
96
142
 
97
143
    for text in texts:
98
144
        combobox.append_text(text)
99
145
 
100
 
    if setting.get_string() in values:
101
 
        combobox.set_active(values.index(setting.get_string()))
 
146
    if setting.get_value() in values:
 
147
        combobox.set_active(values.index(setting.get_value()))
102
148
    combobox.connect("changed", value_changed_cb, setting)
103
149
 
104
150
    return combobox
105
151
 
106
152
class GconfScale(gtk.HScale):
107
 
    def __init__(self, key = None, min = None, max = None, digits = 0):
 
153
    def __init__(self, key=None, min=None, max=None, digits=0, reversed=False):
108
154
        gtk.HScale.__init__(self)
109
 
        self.__setting = NumSetting(key)
 
155
        if digits > 0:
 
156
            self.__setting = GconfSetting(key=key, type=float)
 
157
        else:
 
158
            self.__setting = GconfSetting(key=key, type=int)
 
159
 
 
160
        if reversed:
 
161
            self.__reversed = True
 
162
        else:
 
163
            self.__reversed = False
110
164
        
111
165
        self.set_range(min, max)
112
166
        self.set_digits(digits)
113
167
        self.set_value_pos(gtk.POS_RIGHT)
114
168
        self.connect("value-changed", self.on_value_changed) 
115
 
        self.set_value(self.__setting.get_num())
 
169
        if self.__reversed:
 
170
            self.set_value(max - self.__setting.get_value())
 
171
        else:
 
172
            self.set_value(self.__setting.get_value())
116
173
 
117
 
    def on_value_changed(self, widget, data = None):
118
 
        self.__setting.set_num(widget.get_value())
 
174
    def on_value_changed(self, widget, data=None):
 
175
        if self.__reversed:
 
176
            self.__setting.set_value(100 - widget.get_value())
 
177
        else:
 
178
            self.__setting.set_value(widget.get_value())
119
179
 
120
180
class GconfSpinButton(gtk.SpinButton):
121
181
    def __init__(self, key, min=0, max=0, step=0):
122
 
        self.__setting = IntSetting(key)
123
 
        init = self.__setting.get_int()
124
 
        adjust = gtk.Adjustment(init, min, max, step)
 
182
        self.__setting = GconfSetting(key=key, type=int)
 
183
        adjust = gtk.Adjustment(self.__setting.get_value(), min, max, step)
125
184
 
126
185
        gtk.SpinButton.__init__(self, adjust)
127
186
        self.connect('value-changed', self.on_value_changed) 
128
187
 
129
188
    def on_value_changed(self, widget):
130
 
        self.__setting.set_int(widget.get_value())
131
 
 
132
 
class EntryBox(gtk.HBox):
133
 
    def __init__(self, label, text):
134
 
        gtk.HBox.__init__(self)
135
 
 
136
 
        label = gtk.Label(label)
137
 
        self.pack_start(label, False, False,10)
138
 
        entry = gtk.Entry()
139
 
        if text: entry.set_text(text)
140
 
        entry.set_editable(False)
141
 
        entry.set_size_request(300, -1)
142
 
        self.pack_end(entry, False, False, 0)
143
 
 
144
 
class HScaleBox(gtk.HBox):
145
 
    def __init__(self, label, min, max, key, digits = 0):
146
 
        gtk.HBox.__init__(self)
147
 
        self.pack_start(gtk.Label(label), False, False, 0)
148
 
        
149
 
        hscale = gtk.HScale()
150
 
        hscale.set_size_request(150, -1)
151
 
        hscale.set_range(min, max)
152
 
        hscale.set_digits(digits)
153
 
        hscale.set_value_pos(gtk.POS_RIGHT)
154
 
        self.pack_end(hscale, False, False, 0)
155
 
        hscale.connect("value-changed", self.hscale_value_changed_cb, key)
156
 
 
157
 
        client = gconf.client_get_default()
158
 
        value = client.get(key)
159
 
 
160
 
        if value:
161
 
            if value.type == gconf.VALUE_INT:
162
 
                hscale.set_value(client.get_int(key))
163
 
            elif value.type == gconf.VALUE_FLOAT:
164
 
                hscale.set_value(client.get_float(key))
165
 
 
166
 
    def hscale_value_changed_cb(self, widget, data = None):
167
 
        client = gconf.client_get_default()
168
 
        value = client.get(data)
169
 
        if value.type == gconf.VALUE_INT:
170
 
            client.set_int(data, int(widget.get_value()))
171
 
        elif value.type == gconf.VALUE_FLOAT:
172
 
            client.set_float(data, widget.get_value())
173
 
 
174
 
class ComboboxItem(gtk.HBox):
175
 
    def __init__(self, label, texts, values, key):
176
 
        gtk.HBox.__init__(self)
177
 
        self.pack_start(gtk.Label(label), False, False, 0)    
178
 
 
179
 
        combobox = gtk.combo_box_new_text()
180
 
        combobox.texts = texts
181
 
        combobox.values = values
182
 
        combobox.connect("changed", self.value_changed_cb, key)
183
 
        self.pack_end(combobox, False, False, 0)
184
 
 
185
 
        for element in texts:
186
 
            combobox.append_text(element)
187
 
 
188
 
        client = gconf.client_get_default()
189
 
 
190
 
        if client.get_string(key) in values:
191
 
            combobox.set_active(values.index(client.get_string(key)))
192
 
 
193
 
    def value_changed_cb(self, widget, data = None):
194
 
        client = gconf.client_get_default()
195
 
        text = widget.get_active_text()
196
 
        client.set_string(data, widget.values[widget.texts.index(text)]) 
 
189
        self.__setting.set_value(widget.get_value())
197
190
 
198
191
"""Popup and KeyGrabber come from ccsm"""
199
192
KeyModifier = ["Shift", "Control", "Mod1", "Mod2", "Mod3", "Mod4",