~ubuntu-branches/ubuntu/oneiric/compizconfig-settings-manager/oneiric

« back to all changes in this revision

Viewing changes to ccm/Utils.py

  • Committer: Bazaar Package Importer
  • Author(s): Michael Vogt
  • Date: 2007-09-12 19:45:56 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20070912194556-ka6cvdxpqgj4b4ul
Tags: 0.5.2+git20070912-0ubuntu1
* new 0.6 snapshot
* fixes focus events and keyboard navigation
* debian/patches/02_rename_ccsm.patch:
  - set name to "Advanced Desktop Effects Settings"

Show diffs side-by-side

added added

removed removed

Lines of Context:
36
36
_ = gettext.gettext
37
37
 
38
38
def getScreens():
39
 
        screens = []
40
 
        display = gtk.gdk.display_get_default()
41
 
        nScreens = display.get_n_screens()
42
 
        for i in range(nScreens):
43
 
                screens.append(i)
44
 
        return screens
 
39
    screens = []
 
40
    display = gtk.gdk.display_get_default()
 
41
    nScreens = display.get_n_screens()
 
42
    for i in range(nScreens):
 
43
        screens.append(i)
 
44
    return screens
45
45
 
46
46
class Style:
47
 
        def __init__(self):
48
 
                fakeWindow = gtk.Window()
49
 
                styleWidget = gtk.Entry()
50
 
                fakeWindow.add(styleWidget)
51
 
                styleWidget.realize()
52
 
                bc = styleWidget.style.bg[gtk.STATE_SELECTED]
53
 
                self.BrightColor = "#%.4x%.4x%.4x" % (bc.red, bc.green, bc.blue)
54
 
                bc = styleWidget.style.light[gtk.STATE_NORMAL]
55
 
                self.BackgroundColor = "#%.4x%.4x%.4x" % (bc.red, bc.green, bc.blue)
56
 
                styleWidget.destroy()
57
 
                fakeWindow.destroy()
 
47
    def __init__(self):
 
48
        fakeWindow = gtk.Window()
 
49
        styleWidget = gtk.Entry()
 
50
        fakeWindow.add(styleWidget)
 
51
        styleWidget.realize()
 
52
        bc = styleWidget.style.bg[gtk.STATE_SELECTED]
 
53
        self.BrightColor = "#%.4x%.4x%.4x" % (bc.red, bc.green, bc.blue)
 
54
        bc = styleWidget.style.light[gtk.STATE_NORMAL]
 
55
        self.BackgroundColor = "#%.4x%.4x%.4x" % (bc.red, bc.green, bc.blue)
 
56
        styleWidget.destroy()
 
57
        fakeWindow.destroy()
58
58
 
59
59
class Image(gtk.Image):
60
 
        def __init__(self, name=None, type=ImageNone, size = 32):
61
 
                gtk.Image.__init__(self)
62
 
 
63
 
                if name != None:
64
 
                        if type == ImagePlugin:
65
 
                                iconpath = "%s/plugin-%s.svg" % (PixmapDir, name)
66
 
                                if not os.path.exists(iconpath):
67
 
                                        iconpath = "%s/plugin-unknown.svg"%PixmapDir
68
 
                                try:
69
 
                                        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(iconpath, size, size)
70
 
                                        self.set_from_pixbuf(pixbuf)
71
 
                                except:
72
 
                                        self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
73
 
 
74
 
                        elif type == ImageCategory:
75
 
                                iconpath = "%s/category-%s.svg" % (PixmapDir, name)
76
 
                                if not os.path.exists(iconpath):
77
 
                                        iconpath = "%s/category-uncategorized.svg" % PixmapDir
78
 
                                try:
79
 
                                        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(iconpath, size, size)
80
 
                                        self.set_from_pixbuf(pixbuf)
81
 
                                except:
82
 
                                        self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
83
 
 
84
 
                        elif type == ImageThemed:
85
 
                                iconTheme = gtk.icon_theme_get_default()
86
 
                                try:
87
 
                                        pixbuf = iconTheme.load_icon(name, size, 0)
88
 
                                        self.set_from_pixbuf(pixbuf)
89
 
                                except:
90
 
                                        self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
91
 
 
92
 
                        elif type == ImageStock:
93
 
                                try:
94
 
                                        self.set_from_stock(name, size)
95
 
                                except:
96
 
                                        self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
 
60
    def __init__(self, name=None, type=ImageNone, size = 32):
 
61
        gtk.Image.__init__(self)
 
62
 
 
63
        if name != None:
 
64
            if type == ImagePlugin:
 
65
                iconpath = "%s/plugin-%s.svg" % (PixmapDir, name)
 
66
                if not os.path.exists(iconpath):
 
67
                    iconpath = "%s/plugin-unknown.svg"%PixmapDir
 
68
                try:
 
69
                    pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(iconpath, size, size)
 
70
                    self.set_from_pixbuf(pixbuf)
 
71
                except:
 
72
                    self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
 
73
 
 
74
            elif type == ImageCategory:
 
75
                iconpath = "%s/category-%s.svg" % (PixmapDir, name)
 
76
                if not os.path.exists(iconpath):
 
77
                    iconpath = "%s/category-uncategorized.svg" % PixmapDir
 
78
                try:
 
79
                    pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(iconpath, size, size)
 
80
                    self.set_from_pixbuf(pixbuf)
 
81
                except:
 
82
                    self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
 
83
 
 
84
            elif type == ImageThemed:
 
85
                iconTheme = gtk.icon_theme_get_default()
 
86
                try:
 
87
                    pixbuf = iconTheme.load_icon(name, size, 0)
 
88
                    self.set_from_pixbuf(pixbuf)
 
89
                except:
 
90
                    self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
 
91
 
 
92
            elif type == ImageStock:
 
93
                try:
 
94
                    self.set_from_stock(name, size)
 
95
                except:
 
96
                    self.set_from_stock(gtk.STOCK_MISSING_IMAGE, gtk.ICON_SIZE_BUTTON)
 
97
 
 
98
class PrettyButton (gtk.Button):
 
99
 
 
100
    __gsignals__ = {
 
101
        'expose-event'      : 'override',
 
102
    }
 
103
 
 
104
    def __init__ (self):
 
105
        super (PrettyButton, self).__init__ ()
 
106
        self.states = {
 
107
                        "focus"   : False,
 
108
                        "pointer" : False
 
109
                      }
 
110
        self.set_size_request (200, -1)
 
111
        self.set_relief (gtk.RELIEF_NONE)
 
112
        self.connect ("focus-in-event", self.update_state_in, "focus")
 
113
        self.connect ("focus-out-event", self.update_state_out, "focus")
 
114
 
 
115
    def update_state_in (self, *args):
 
116
        widget, state = args[0], args[-1]
 
117
        widget.set_state (gtk.STATE_PRELIGHT)
 
118
        self.states[state] = True
 
119
 
 
120
    def update_state_out (self, *args):
 
121
        widget, state = args[0], args[-1]
 
122
        self.states[state] = False
 
123
        if True in self.states.values ():
 
124
            widget.set_state (gtk.STATE_PRELIGHT)
 
125
        else:
 
126
            widget.set_state (gtk.STATE_NORMAL)
 
127
 
 
128
    def do_expose_event (self, event):
 
129
        has_focus = self.flags () & gtk.HAS_FOCUS
 
130
        if has_focus:
 
131
            self.unset_flags (gtk.HAS_FOCUS)
 
132
 
 
133
        ret = super (PrettyButton, self).do_expose_event (self, event)
 
134
 
 
135
        if has_focus:
 
136
            self.set_flags (gtk.HAS_FOCUS)
 
137
 
 
138
        return ret
97
139
 
98
140
class Label(gtk.Label):
99
 
        def __init__(self, value = "", wrap = 160):
100
 
                gtk.Label.__init__(self, value)
101
 
                self.props.xalign = 0
102
 
                self.props.wrap_mode = gtk.WRAP_WORD
103
 
                self.set_line_wrap(True)
104
 
                self.set_size_request(wrap, -1)
 
141
    def __init__(self, value = "", wrap = 160):
 
142
        gtk.Label.__init__(self, value)
 
143
        self.props.xalign = 0
 
144
        self.props.wrap_mode = gtk.WRAP_WORD
 
145
        self.set_line_wrap(True)
 
146
        self.set_size_request(wrap, -1)
105
147
 
106
148
class NotFoundBox(gtk.Alignment):
107
 
        def __init__(self, value):
108
 
                gtk.Alignment.__init__(self, 0.5, 0.5, 0.0, 0.0)
109
 
                
110
 
                box = gtk.HBox()
111
 
                self.Warning = gtk.Label()
112
 
                self.Markup = _("<span size=\"large\"><b>No matches found.</b> </span><span>\n\n Your filter \"<b>%s</b>\" does not match any items.</span>")
113
 
                self.Warning.set_markup(self.Markup % value)
114
 
                image = Image("face-surprise", ImageThemed, 48)
115
 
                        
116
 
                box.pack_start(image, False, False, 0)
117
 
                box.pack_start(self.Warning, True, True, 15)
118
 
                self.add(box)
 
149
    def __init__(self, value):
 
150
        gtk.Alignment.__init__(self, 0.5, 0.5, 0.0, 0.0)
 
151
        
 
152
        box = gtk.HBox()
 
153
        self.Warning = gtk.Label()
 
154
        self.Markup = _("<span size=\"large\"><b>No matches found.</b> </span><span>\n\n Your filter \"<b>%s</b>\" does not match any items.</span>")
 
155
        self.Warning.set_markup(self.Markup % value)
 
156
        image = Image("face-surprise", ImageThemed, 48)
 
157
            
 
158
        box.pack_start(image, False, False, 0)
 
159
        box.pack_start(self.Warning, True, True, 15)
 
160
        self.add(box)
119
161
 
120
 
        def update(self, value):
121
 
                self.Warning.set_markup(self.Markup % value)
 
162
    def update(self, value):
 
163
        self.Warning.set_markup(self.Markup % value)
122
164
 
123
165
# Updates all registered setting when they where changed through CompizConfig
124
166
class Updater:
125
 
        def __init__(self, context):
126
 
                self.VisibleSettings = []
127
 
                self.NotRemoved = []
128
 
                self.Context = context
129
 
 
130
 
                gobject.timeout_add(2000, self.Update)
131
 
        
132
 
        def Append(self, setting):
133
 
                self.VisibleSettings.append(setting)
134
 
 
135
 
        def Update(self):
136
 
                changed = self.Context.ProcessEvents()
137
 
                if changed:
138
 
                        changedSettings = self.Context.ChangedSettings
139
 
                        for settingWidget in self.VisibleSettings:
140
 
                                # Remove already destroyed widgets
141
 
                                if not settingWidget.Widget.get_parent():
142
 
                                        self.VisibleSettings.remove(settingWidget)
143
 
                                
144
 
                                # Exception for multi settings widgets (multi list widget, action page, etc.)
145
 
                                if settingWidget.Setting.__class__ != list:
146
 
                                        if settingWidget.Setting in changedSettings:
147
 
                                                settingWidget.Read()
148
 
                                                changedSettings.remove(settingWidget.Setting)
149
 
                                else:
150
 
                                        read = False
151
 
                                        for setting in settingWidget.Setting:
152
 
                                                if setting in changedSettings:
153
 
                                                        read = True
154
 
                                                        changedSettings.remove(setting)
155
 
                                        if read:
156
 
                                                settingWidget.Read()
157
 
                        # For removing non-visible settings
158
 
                        for oldSetting in self.NotRemoved:
159
 
                                if oldSetting in changedSettings:
160
 
                                        changedSettings.remove(oldSetting)
161
 
                        self.NotRemoved = changedSettings
162
 
                        self.Context.ChangedSettings = changedSettings
163
 
 
164
 
                return True
 
167
    def __init__(self, context):
 
168
        self.VisibleSettings = []
 
169
        self.NotRemoved = []
 
170
        self.Context = context
 
171
 
 
172
        gobject.timeout_add(2000, self.Update)
 
173
    
 
174
    def Append(self, setting):
 
175
        self.VisibleSettings.append(setting)
 
176
 
 
177
    def Update(self):
 
178
        changed = self.Context.ProcessEvents()
 
179
        if changed:
 
180
            changedSettings = self.Context.ChangedSettings
 
181
            for settingWidget in self.VisibleSettings:
 
182
                # Remove already destroyed widgets
 
183
                if not settingWidget.Widget.get_parent():
 
184
                    self.VisibleSettings.remove(settingWidget)
 
185
                
 
186
                # Exception for multi settings widgets (multi list widget, action page, etc.)
 
187
                if settingWidget.Setting.__class__ != list:
 
188
                    if settingWidget.Setting in changedSettings:
 
189
                        settingWidget.Read()
 
190
                        changedSettings.remove(settingWidget.Setting)
 
191
                else:
 
192
                    read = False
 
193
                    for setting in settingWidget.Setting:
 
194
                        if setting in changedSettings:
 
195
                            read = True
 
196
                            changedSettings.remove(setting)
 
197
                    if read:
 
198
                        settingWidget.Read()
 
199
            # For removing non-visible settings
 
200
            for oldSetting in self.NotRemoved:
 
201
                if oldSetting in changedSettings:
 
202
                    changedSettings.remove(oldSetting)
 
203
            self.NotRemoved = changedSettings
 
204
            self.Context.ChangedSettings = changedSettings
 
205
 
 
206
        return True
165
207
 
166
208
class PureVirtualError(Exception):
167
 
        pass
 
209
    pass
168
210
 
169
211
def SettingSortCompare(v1, v2):
170
 
        return cmp(v1.Plugin.Ranking[v1.Name], v2.Plugin.Ranking[v2.Name])
 
212
    return cmp(v1.Plugin.Ranking[v1.Name], v2.Plugin.Ranking[v2.Name])
171
213
 
172
214
def FirstItemSortCompare(sg1, sg2):
173
 
        return cmp(sg1[0], sg2[0])
 
215
    return cmp(sg1[0], sg2[0])
174
216
 
175
217
def EnumSettingSortCompare(v1, v2):
176
 
        return cmp(v1[1], v2[1])
 
218
    return cmp(v1[1], v2[1])
177
219
 
178
220
def PluginSortCompare(p1, p2):
179
 
        return cmp(p1.ShortDesc, p2.ShortDesc)
 
221
    return cmp(p1.ShortDesc, p2.ShortDesc)
180
222
 
181
223
# singleRun is used to combine the run stages, in this case run is a list
182
224
# containing the run levels which should be used to filter the settings
183
225
def FilterSettings(settings, filter, run=0, noActions=False, singleRun=False):
184
 
        if filter == None:
185
 
                return settings
186
 
 
187
 
        filteredSettings = []
188
 
 
189
 
        for setting in settings:
190
 
                if noActions and setting.Type == 'Action':
191
 
                        continue
192
 
                # First run, only search in shortDesc and name
193
 
                if run == 0 or (singleRun and run.count(0) != 0):
194
 
                        shortDesc = setting.ShortDesc.lower()
195
 
                        name = setting.Name.lower()
196
 
                        if shortDesc.find(filter) != -1:
197
 
                                filteredSettings.append(setting)
198
 
                                continue
199
 
                        elif name.find(filter) != -1:
200
 
                                filteredSettings.append(setting)
201
 
                                continue
202
 
                # Then in longDesc
203
 
                if run == 1 or (singleRun and run.count(1) != 0):
204
 
                        longDesc = setting.LongDesc.lower()
205
 
                        if longDesc.find(filter) != -1:
206
 
                                filteredSettings.append(setting)
207
 
                                continue
208
 
                # Finally search in the option value
209
 
                if run == 2 or (singleRun and run.count(2) != 0):
210
 
                        value = ""
211
 
                        # make sure enum settings work too
212
 
                        if setting.Type == 'Int' and len(setting.Info[2].keys()) > 0:
213
 
                                        value = sorted(setting.Info[2].items(), EnumSettingSortCompare)[setting.Value][0]
214
 
                                        value = value.lower()
215
 
                        # also make sure intDesc settings work right
216
 
                        elif setting.Type == 'List' and setting.Info[0] == 'Int' and len(setting.Info[1][2]) > 0:
217
 
                                for int in setting.Value:
218
 
                                        for item in setting.Info[1][2].items():
219
 
                                                if item[1] == int:
220
 
                                                        value += item[0]
221
 
                                value = value.lower()
222
 
                        # we also need actions support
223
 
                        elif setting.Type == 'Action':
224
 
                                value = str(setting.Value).lower()
225
 
                        else:
226
 
                                value = str(setting.Value).lower()
227
 
                        if value.find(filter) != -1:
228
 
                                filteredSettings.append(setting)
229
 
 
230
 
        # Nothing was found, search also in the longDesc/value
231
 
        if len(filteredSettings) == 0 and run < 2 and not singleRun:
232
 
                return FilterSettings(settings, filter, run+1, noActions, False)
233
 
 
234
 
        return filteredSettings
 
226
    if filter == None:
 
227
        return settings
 
228
 
 
229
    filteredSettings = []
 
230
 
 
231
    for setting in settings:
 
232
        if noActions and setting.Type == 'Action':
 
233
            continue
 
234
        # First run, only search in shortDesc and name
 
235
        if run == 0 or (singleRun and run.count(0) != 0):
 
236
            shortDesc = setting.ShortDesc.lower()
 
237
            name = setting.Name.lower()
 
238
            if shortDesc.find(filter) != -1:
 
239
                filteredSettings.append(setting)
 
240
                continue
 
241
            elif name.find(filter) != -1:
 
242
                filteredSettings.append(setting)
 
243
                continue
 
244
        # Then in longDesc
 
245
        if run == 1 or (singleRun and run.count(1) != 0):
 
246
            longDesc = setting.LongDesc.lower()
 
247
            if longDesc.find(filter) != -1:
 
248
                filteredSettings.append(setting)
 
249
                continue
 
250
        # Finally search in the option value
 
251
        if run == 2 or (singleRun and run.count(2) != 0):
 
252
            value = ""
 
253
            # make sure enum settings work too
 
254
            if setting.Type == 'Int' and len(setting.Info[2].keys()) > 0:
 
255
                    value = sorted(setting.Info[2].items(), EnumSettingSortCompare)[setting.Value][0]
 
256
                    value = value.lower()
 
257
            # also make sure intDesc settings work right
 
258
            elif setting.Type == 'List' and setting.Info[0] == 'Int' and len(setting.Info[1][2]) > 0:
 
259
                for int in setting.Value:
 
260
                    for item in setting.Info[1][2].items():
 
261
                        if item[1] == int:
 
262
                            value += item[0]
 
263
                value = value.lower()
 
264
            # we also need actions support
 
265
            elif setting.Type == 'Action':
 
266
                value = str(setting.Value).lower()
 
267
            else:
 
268
                value = str(setting.Value).lower()
 
269
            if value.find(filter) != -1:
 
270
                filteredSettings.append(setting)
 
271
 
 
272
    # Nothing was found, search also in the longDesc/value
 
273
    if len(filteredSettings) == 0 and run < 2 and not singleRun:
 
274
        return FilterSettings(settings, filter, run+1, noActions, False)
 
275
 
 
276
    return filteredSettings
235
277
 
236
278
def HasOnlyType(settings, type):
237
 
        empty = True
238
 
        for setting in settings:
239
 
                empty = False
240
 
                if setting.Type != type:
241
 
                        return False
242
 
        return not empty
 
279
    empty = True
 
280
    for setting in settings:
 
281
        empty = False
 
282
        if setting.Type != type:
 
283
            return False
 
284
    return not empty