LogoopenSUSE Build Service > Projects
Sign Up | Log In

View File simple-ccsm-default-plugins_herbster0815.patch of Package simple-ccsm (Project openSUSE:Factory)

diff -Naur simple-ccsm-0.8.8/profiles/Advanced.profile simple-ccsm-0.8.8_herbster0815/profiles/Advanced.profile
--- simple-ccsm-0.8.8/profiles/Advanced.profile	2011-04-21 12:18:45.000000000 +0200
+++ simple-ccsm-0.8.8_herbster0815/profiles/Advanced.profile	2011-04-28 11:59:11.000000000 +0200
@@ -1,5 +1,7 @@
 [core]
-s0_active_plugins = core;composite;opengl;decor;obs;place;move;shift;compiztoolbox;resize;gnomecompat;mousepoll;regex;cube;session;scale;animation;rotate;cubeaddon;expo;ezoom;
+s0_active_plugins = core;workarounds;dbus;resize;crashhandler;mousepoll;wm;glx;dmx;decoration;svg;place;png;text;move;regex;animation;cube;shift;scale;rotate;cubeaddon;expo;ezoom;
+s0_hsize = 4
+s0_vsize = 1
 
 [cubeaddon]
 s0_reflection = false
diff -Naur simple-ccsm-0.8.8/profiles/Medium.profile simple-ccsm-0.8.8_herbster0815/profiles/Medium.profile
--- simple-ccsm-0.8.8/profiles/Medium.profile	2011-04-21 12:18:45.000000000 +0200
+++ simple-ccsm-0.8.8_herbster0815/profiles/Medium.profile	2011-04-28 12:00:03.000000000 +0200
@@ -1,5 +1,5 @@
 [core]
-s0_active_plugins = core;composite;opengl;decor;obs;scale;place;move;compiztoolbox;resize;gnomecompat;mousepoll;regex;session;animation;wall;expo;ezoom;switcher;
+s0_active_plugins = core;workarounds;dbus;resize;crashhandler;mousepoll;wm;glx;dmx;decoration;svg;wall;place;png;text;move;regex;animation;scale;expo;ezoom;switcher;
 s0_hsize = 2
 s0_vsize = 2
 
diff -Naur simple-ccsm-0.8.8/profiles/Minimal.profile simple-ccsm-0.8.8_herbster0815/profiles/Minimal.profile
--- simple-ccsm-0.8.8/profiles/Minimal.profile	2011-04-21 12:18:45.000000000 +0200
+++ simple-ccsm-0.8.8_herbster0815/profiles/Minimal.profile	2011-04-28 12:00:49.000000000 +0200
@@ -1,5 +1,5 @@
 [core]
-s0_active_plugins = core;composite;opengl;decor;obs;place;move;compiztoolbox;resize;gnomecompat;mousepoll;regex;session;ezoom;staticswitcher;wall;
+s0_active_plugins = core;workarounds;dbus;resize;crashhandler;mousepoll;wm;glx;dmx;decoration;svg;wall;place;png;text;move;regex;animation;ezoom;
 s0_hsize = 2
 s0_vsize = 2
 
diff -Naur simple-ccsm-0.8.8/profiles/Ultimate.profile simple-ccsm-0.8.8_herbster0815/profiles/Ultimate.profile
--- simple-ccsm-0.8.8/profiles/Ultimate.profile	2011-04-21 12:18:45.000000000 +0200
+++ simple-ccsm-0.8.8_herbster0815/profiles/Ultimate.profile	2011-04-28 12:01:34.000000000 +0200
@@ -2,7 +2,9 @@
 s0_active_opacity = 70,000000
 
 [core]
-s0_active_plugins = core;composite;opengl;decor;obs;place;move;shift;compiztoolbox;resize;gnomecompat;mousepoll;regex;wobbly;cube;session;td;scale;animation;rotate;animationaddon;cubeaddon;expo;ezoom;
+s0_active_plugins = core;workarounds;dbus;resize;crashhandler;mousepoll;wm;glx;dmx;decoration;svg;wobbly;place;png;text;move;regex;animation;cube;3d;shift;scale;rotate;cubeaddon;expo;ezoom;
+s0_hsize = 4
+s0_vsize = 1
 
 [animation]
 s0_open_effects = animationaddon:Skewer;animation:Fade;animation:Fade;
diff -Naur simple-ccsm-0.8.8/simple-ccsm.in simple-ccsm-0.8.8_herbster0815/simple-ccsm.in
--- simple-ccsm-0.8.8/simple-ccsm.in	2011-04-21 12:18:45.000000000 +0200
+++ simple-ccsm-0.8.8_herbster0815/simple-ccsm.in	2011-04-28 11:35:26.000000000 +0200
@@ -185,9 +185,9 @@
 
 # Change to your default
 CompizEnableDesktopEffects = @enable_desktop_effects@
-CompizStartCommand = "compiz-manager --replace"
+CompizStartCommand = "compiz-manager"
 CompizDryRunCommand = "CM_DRY=yes compiz-manager"
-CompizNoChecksCommand = "SKIP_CHECKS=yes compiz-manager --replace"
+CompizNoChecksCommand = "SKIP_CHECKS=yes compiz-manager"
 GnomeSession = "GNOME_DESKTOP_SESSION_ID"
 KdeSession = "KDE_FULL_SESSION"
 
diff -Naur simple-ccsm-0.8.8/simple-ccsm.in.orig simple-ccsm-0.8.8_herbster0815/simple-ccsm.in.orig
--- simple-ccsm-0.8.8/simple-ccsm.in.orig	1970-01-01 01:00:00.000000000 +0100
+++ simple-ccsm-0.8.8_herbster0815/simple-ccsm.in.orig	2011-04-21 12:18:45.000000000 +0200
@@ -0,0 +1,1428 @@
+#!/usr/bin/env python
+# -*-  coding: UTF-8 -*-
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, 
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# Authors: Patrick Niklaus (marex@opencompositing.org)
+# Copyright (C) 2007 Patrick Niklaus
+
+import shutil
+import os
+import subprocess
+import pygtk
+import gtk
+import gobject
+import gtk.gdk as gdk
+import gtk.glade as glade
+import cairo
+import compizconfig as ccs
+import ccm
+import locale
+import gettext
+import time
+from optparse import OptionParser
+from threading import Thread
+locale.setlocale(locale.LC_ALL, "")
+_ = gettext.gettext
+
+Tooltips = gtk.Tooltips()
+
+DataDir = '@prefix@/share/simple-ccsm/'
+
+# Switcher keybinding
+SwitcherKey = "<Alt>Tab"
+ReverseSwitcherKey = "<Shift><Alt>Tab"
+
+# Since there seems no way to get the untranslated names,
+# we need to keep a list here.
+CloseOpenEffectNames = {\
+'animation:None':'None',
+'animation:Random':'Random',
+'animation:Curved Fold':'Curved Fold',
+'animation:Dream':'Dream',
+'animation:Fade':'Fade',
+'animation:Glide 1':'Glide 1',
+'animation:Glide 2':'Glide 2',
+'animation:Horizontal Folds':'Horizontal Folds',
+'animation:Magic Lamp':'Magic Lamp',
+'animation:Sidekick':'Sidekick',
+'animation:Vacuum':'Vacuum',
+'animation:Wave':'Wave',
+'animationaddon:Zoom':'Zoom',
+'animationaddon:Airplane':'Airplane',
+'animationaddon:Beam Up':'Beam Up',
+'animationaddon:Burn':'Burn',
+'animationaddon:Domino':'Domino',
+'animationaddon:Explode':'Explode',
+'animationaddon:Fold':'Fold',
+'animationaddon:Glide 3':'Glide 3',
+'animationaddon:Leaf Spread':'Leaf Spread',
+'animationaddon:Razr':'Razr',
+'animationaddon:Skewer':'Skewer'
+}
+
+MinimizeEffectNames = {\
+'animation:None':'None',
+'animation:Random':'Random',
+'animation:Curved Fold':'Curved Fold',
+'animation:Dream':'Dream',
+'animation:Fade':'Fade',
+'animation:Glide 1':'Glide 1',
+'animation:Glide 2':'Glide 2',
+'animation:Horizontal Folds':'Horizontal Folds',
+'animation:Magic Lamp':'Magic Lamp',
+'animation:Sidekick':'Sidekick',
+'animation:Zoom':'Zoom',
+'animationaddon:Airplane':'Airplane',
+'animationaddon:Beam Up':'Beam Up',
+'animationaddon:Burn':'Burn',
+'animationaddon:Domino':'Domino',
+'animationaddon:Explode':'Explode',
+'animationaddon:Fold':'Fold',
+'animationaddon:Glide 3':'Glide 3',
+'animationaddon:Leaf Spread':'Leaf Spread',
+'animationaddon:Razr':'Razr',
+'animationaddon:Skewer':'Skewer'
+}
+
+FocusEffectNames = {\
+'animation:None':'None',
+'animation:Dodge':'Dodge',
+'animation:Fade':'Fade',
+'animation:Wave':'Wave'
+}
+
+# 0 to 5 stars
+AnimationRatings = {\
+'None': 0,
+'Random': 5,
+'Airplane': 5,
+'Beam Up': 4,
+'Burn': 4,
+'Curved Fold': 2,
+'Domino': 3,
+'Dream': 4,
+'Explode': 4,
+'Fade': 1,
+'Fold': 2,
+'Glide 1': 2,
+'Glide 2': 2,
+'Glide 3': 2,
+'Horizontal Folds': 2,
+'Leaf Spread': 4,
+'Magic Lamp': 5,
+'Razr': 4,
+'Sidekick': 3,
+'Skewer': 3,
+'Vacuum': 5,
+'Wave': 4,
+'Zoom': 2,
+'Dodge': 5
+}
+
+gtk.glade.bindtextdomain("simple-ccsm", "@prefix@/share/locale")
+gettext.bindtextdomain("simple-ccsm", "@prefix@/share/locale")
+gettext.textdomain("simple-ccsm")
+
+Profiles = {\
+_("Minimal"): 'Minimal',
+_("Medium"): 'Medium',
+_("Advanced"): 'Advanced',
+_("Ultimate"): 'Ultimate'
+}
+
+Descriptions = {\
+'Minimal': _("Provides a simple desktop environment with very few effects."),
+'Medium': _("Provides good balance between attractiveness and moderate performence requirements."),
+'Advanced': _("Provides more aesthetically pleasing set of effects."),
+'Ultimate': _("Provides very advanced and eye-catching set of effects. Requires faster graphics card.")
+}
+
+# 0 to 5 stars
+EffectPluginRatings = {\
+'wobbly': 5,
+'cube': 3,
+'wall': 1,
+'expo': 4,
+'blur': 5,
+'mblur': 5,
+'3d': 5,
+'water': 5,
+'firepaint': 4,
+'shift': 5,
+'scale': 2,
+'cubeaddon': 5
+}
+
+Pages = {
+'profile': 0,
+'animations': 1,
+'desktop': 2,
+'accessibility': 3
+}
+
+AnimationSettings = {
+'openAnimationBox': "open_effects",
+'closeAnimationBox': "close_effects",
+'minimizeAnimationBox': "minimize_effects",
+'focusAnimationBox': "focus_effects"
+}
+
+Tooltips = gtk.Tooltips()
+CompizName = "compiz"
+
+# Change to your default
+CompizEnableDesktopEffects = @enable_desktop_effects@
+CompizStartCommand = "compiz-manager --replace"
+CompizDryRunCommand = "CM_DRY=yes compiz-manager"
+CompizNoChecksCommand = "SKIP_CHECKS=yes compiz-manager --replace"
+GnomeSession = "GNOME_DESKTOP_SESSION_ID"
+KdeSession = "KDE_FULL_SESSION"
+
+# Utility Functions
+def GetXdgConfigHome(subdir):
+    if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
+        xdg = os.path.expanduser(os.environ['XDG_CONFIG_HOME'])
+    else:
+        xdg = os.path.expanduser('~/.config')
+
+    if subdir:
+        ret = os.path.join(xdg, subdir)
+    else:
+        ret = xdg
+
+    # create the directory if it's not there
+    try:
+        os.makedirs(ret, 0700)
+    except Exception:
+        pass
+
+    return ret
+
+def EnablePlugin(plugin, active):
+    # attempt to resolve conflicts...
+    conflicts = (plugin.Enabled and plugin.DisableConflicts) or plugin.EnableConflicts
+    conflict = ccm.PluginConflict(plugin, conflicts, autoResolve=True)
+    if conflict.Resolve():
+        plugin.Enabled = active
+    else:
+        return False
+
+    plugin.Context.Write()
+
+    return True
+
+def SetupBoxModel(box):
+    if not box.get_model():
+        store = gtk.ListStore(gobject.TYPE_STRING)
+        box.set_model(store)
+        cell = gtk.CellRendererText()
+        box.pack_start(cell, True)
+        box.add_attribute(cell, 'text', 0)
+    else:
+        box.get_model().clear()
+
+class DesktopPreview(gtk.Widget):
+    def __init__(self, size=(0,0)):
+        gtk.Widget.__init__(self)
+
+        self.size = size
+        self.default_desktop_height = 30
+        self.default_desktop_width = 40
+        self.desktop_height = 30
+        self.desktop_width = 40
+        self.desktop_space = 5
+        self.line_width = 1.0
+
+        self.set_flags(self.flags() | gtk.NO_WINDOW)
+
+    def set_value(self, size):
+        self.size = size
+        self.queue_resize()
+
+    def get_value(self):
+        return self.size
+    
+    def do_unrealize(self):
+        self.window.destroy()
+
+    def do_size_request(self, req):
+        req.width = (self.default_desktop_width+self.desktop_space)*4
+        req.height = (self.default_desktop_height+self.desktop_space)*2
+
+    def do_size_allocate(self, allocation):
+        self.allocation = allocation
+
+        width = self.allocation.width
+        height = self.allocation.height
+        self.desktop_width = (width / self.size[0]) - self.desktop_space
+        self.desktop_height = (self.desktop_width * 3.0) / 4.0
+        factor = ((height / self.size[1]) - self.desktop_space) / self.desktop_height
+        #factor = height / ((self.desktop_height + self.desktop_space) * self.size[1])
+
+        if factor < 1.0:
+            self.desktop_width = int(int(self.desktop_width) * factor)
+            self.desktop_height = int(int(self.desktop_height) * factor)
+        
+    def do_expose_event(self, event):
+        cr = self.window.cairo_create()
+        
+        fg = self.style.bg[gtk.STATE_SELECTED]
+        dark = self.style.fg[gtk.STATE_NORMAL]
+
+        x = self.allocation.x + self.line_width / 2.0
+        y = self.allocation.y + self.line_width / 2.0
+        for i in range(self.size[1]):
+            for j in range(self.size[0]):
+                cr.set_source_rgb(fg.red/65535.0,
+                              fg.green/65535.0,
+                              fg.blue/65535.0)
+
+                cr.rectangle(x, y, self.desktop_width, self.desktop_height)
+                cr.fill_preserve()
+                
+                cr.set_line_width(self.line_width)
+                cr.set_source_rgb(dark.red/65535.0,
+                              dark.green/65535.0,
+                              dark.blue/65535.0)
+                cr.stroke()
+
+                x += self.desktop_width + self.desktop_space
+
+            y += self.desktop_height + self.desktop_space 
+            x = self.allocation.x + self.line_width / 2.0
+
+class StarScale(gtk.Widget):
+    def __init__(self, stars=0.0, max=5):
+        gtk.Widget.__init__(self)
+
+        self.stars = stars
+        self.max = max
+        self.star_size = 16
+        self.star_space = 5
+
+        self.image_star = cairo.ImageSurface.create_from_png("%s/images/star.png" % DataDir)
+        self.image_dark = cairo.ImageSurface.create_from_png("%s/images/star_dark.png" % DataDir)
+        self.surface_star = None
+        self.surface_dark = None
+        self.surface      = None
+
+        self._size_changed = False
+        
+        self.set_flags(self.flags() | gtk.NO_WINDOW)
+
+    def set_value(self, stars):
+        self.stars = stars
+        if self.surface:
+            self.draw_surface()
+
+    def set_max(self, max):
+        self.max = max
+        self.queue_resize()
+
+    def get_value(self):
+        return self.stars
+    
+    def get_max(self):
+        return self.max
+
+    def do_size_request(self, req):
+        req.height = self.star_size
+        req.width = (self.star_size+self.star_space)*self.max
+        self._size_changed = True
+
+    def draw_sources(self):
+        width = self.allocation.width
+        height = self.allocation.height
+        self.surface_star = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+        self.surface_dark = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+
+        data = ((self.surface_star, self.image_star), (self.surface_dark, self.image_dark))
+
+        for target, source in data:
+            cr = cairo.Context(target)
+            x = 0
+            for i in range(self.max):
+                cr.set_source_surface(source, x, 0)
+                cr.rectangle(x, 0, self.star_size, self.star_size)
+                cr.fill()
+                x += self.star_size + self.star_space
+
+    def draw_surface(self):
+        if not self.surface_dark or not self.surface_star or self._size_changed:
+            self.draw_sources()
+            self._size_changed = False
+
+        width = self.allocation.width
+        height = self.allocation.height
+        self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+        cr = cairo.Context(self.surface)
+
+        width = (self.star_size+self.star_space)*self.max
+
+        q = (self.max - self.stars) / self.max
+        cr.set_source_surface(self.surface_dark)
+        cr.rectangle(width - q*width, 0, q*width, self.star_size)
+        cr.fill()
+
+        q = self.stars / self.max
+        cr.set_source_surface(self.surface_star)
+        cr.rectangle(0, 0, q*width, self.star_size)
+        cr.fill()
+
+    def do_expose_event(self, event):
+        if not self.surface or self._size_changed:
+            self.draw_surface()
+
+        x = self.allocation.x
+        y = self.allocation.y
+        width  = self.allocation.width
+        height = self.allocation.height
+
+        cr = self.window.cairo_create()
+        cr.set_source_surface(self.surface, x, y)
+        cr.rectangle(x, y, width, height)
+        cr.fill()
+
+
+gobject.type_register(StarScale)
+gobject.type_register(DesktopPreview)
+
+class CheckImage(gtk.HBox):
+    def __init__(self, text="", value=False):
+        gtk.HBox.__init__(self)
+        self.image = gtk.Image()
+        self.label = gtk.Label(text)
+        self.set_spacing(5)
+
+        self.pack_start(self.image, False, False)
+        self.pack_start(self.label, False, False)
+
+        self.value = value
+
+        self.image.props.xalign = 0.0
+        self.label.props.xalign = 0.0
+
+        self.update()
+    
+    def set_value(self, value):
+        self.value = value
+
+        self.update()
+
+    def get_value(self):
+        return self.value
+    
+    def update(self):
+        size = gtk.ICON_SIZE_BUTTON
+        if self.value:
+            self.image.set_from_stock(gtk.STOCK_APPLY, size)
+            Tooltips.set_tip(self, _("Enabled"))
+        else:
+            self.image.set_from_stock(gtk.STOCK_DIALOG_ERROR, size)
+            Tooltips.set_tip(self, _("Disabled"))
+
+class ProfilePage:
+    def __init__(self, context, gladeXML):
+        self.GladeXML = gladeXML
+        self.Context  = context
+        self.DesktopPlugins = {}
+
+        # Check List
+        self.EffectStars = StarScale()
+        self.AnimationStars = StarScale()
+        self.ZoomCheck = CheckImage(_("Zoom"))
+        self.ColorfilterCheck = CheckImage(_("Colorfilter"))
+        effectsAlign = self.GladeXML.get_widget("effectsAlignment")
+        effectsAlign.add(self.EffectStars)
+        animationAlign = self.GladeXML.get_widget("animationsAlignment")
+        animationAlign.add(self.AnimationStars)
+        accessibilityBox = self.GladeXML.get_widget("accessibilityBox")
+        accessibilityBox.pack_start(self.ZoomCheck, False, False)
+        accessibilityBox.pack_start(self.ColorfilterCheck, False, False)
+
+        # Desktop Label
+        self.DesktopLayout = "%s"
+        self.DesktopLabel = self.GladeXML.get_widget("desktopLabel")
+
+        self.GladeXML.signal_autoconnect(self)
+
+    def UpdateDesktopPlugins(self):
+        self.DesktopPlugins = {}
+        for plugin in self.Context.Plugins.values():
+            if "largedesktop" in plugin.Features:
+                self.DesktopPlugins[plugin.ShortDesc] = plugin
+    
+    def SetDesktopLabel(self, widget=None):
+        for shortDesc, plugin in self.DesktopPlugins.items():
+            if plugin.Enabled:
+                self.DesktopLabel.set_markup(self.DesktopLayout % shortDesc)
+                break
+
+    def SetDescriptionLabel(self):
+        label = self.GladeXML.get_widget("descriptionLabel")
+        name = self.Context.CurrentProfile.Name
+
+        description = _("None")
+        if name in Descriptions:
+            description = Descriptions[name]
+
+        label.set_text(description)
+
+    def SetEffectRating(self, widget=None):
+        rating = 0.0
+
+        for pluginName, stars in EffectPluginRatings.items():
+            if not pluginName in self.Context.Plugins:
+                continue
+            plugin = self.Context.Plugins[pluginName]
+            if plugin.Enabled:
+                rating += stars
+
+        rating = rating / float(len(EffectPluginRatings) - 1)
+
+        self.EffectStars.set_value(rating)
+
+    def SetAnimationRating(self, widget=None):
+        if 'animation' not in self.Context.Plugins:
+            return
+
+        names = {
+            'close_effects': CloseOpenEffectNames,
+            'open_effects': CloseOpenEffectNames,
+            'minimize_effects': MinimizeEffectNames,
+            'focus_effects': FocusEffectNames
+        }
+        plugin = self.Context.Plugins['animation']
+
+        rating = 0.0
+        for box, settingName in AnimationSettings.items():
+            box = self.GladeXML.get_widget(box)
+            if not box.get_model():
+                continue
+            text = box.get_active_text()
+            setting = plugin.Screen[settingName]
+            if len(setting.Value) >= 1:
+                value = setting.Value[0]
+                if names[settingName].has_key(value):
+                    name = names[settingName][value]
+                    rating += AnimationRatings[name]
+                else:
+                    rating += 5 # Assume "medium" rating for unknown animations
+
+        if not plugin.Enabled:
+            rating = 0.0
+
+        rating = rating / len(AnimationSettings)
+
+        self.AnimationStars.set_value(rating)
+
+    def CheckAccessibility(self, widget=None):
+        enabled = False
+        for name in ('ezoom', 'zoom', 'mag'):
+            plugin = self.Context.Plugins[name]
+            if plugin.Enabled:
+                enabled = True
+                break
+        self.ZoomCheck.set_value(enabled)
+
+        enabled = False
+        if 'colorfilter' in self.Context.Plugins:
+            enabled = self.Context.Plugins['colorfilter'].Enabled
+        self.ColorfilterCheck.set_value(enabled)
+
+    def Update(self):
+        self.UpdateDesktopPlugins()
+        self.SetDesktopLabel()
+        self.SetDescriptionLabel()
+        self.SetEffectRating()
+        self.SetAnimationRating()
+        self.CheckAccessibility()
+
+class AnimationPage:
+    def __init__(self, context, gladeXML):
+        self.GladeXML = gladeXML
+        self.Context  = context
+        self.Block    = 0
+        self.AnimExtensionPlugins = []
+
+        self.GladeXML.signal_autoconnect(self)
+
+        if 'animation' not in self.Context.Plugins:
+            # Disable animations CheckButton
+            widget = self.GladeXML.get_widget("enableAnimations")
+            widget.set_sensitive(False)
+            Tooltips.set_tip(widget, _(("Can't find the animation plugin.")))
+
+            # Disable extra animations CheckButton
+            widget = self.GladeXML.get_widget("enableExtraAnim")
+            widget.set_sensitive(False)
+            return
+
+        context.Plugins['animation'].Update()
+
+        # Get a list of plugins that extend the animation plugin
+        for (name, plugin) in self.Context.Plugins.items():
+            # Assume the name of extension plugins will start with 'animation'
+            if name == 'animation' or name[:9] != 'animation':
+                continue
+            for basePlugin in plugin.GetExtensionBasePlugins():
+                if basePlugin.Name == 'animation':
+                    self.AnimExtensionPlugins.append(plugin)
+                    context.Plugins[name].Update()
+
+        if len(self.AnimExtensionPlugins) == 0:
+            # Disable extra animations CheckButton
+            widget = self.GladeXML.get_widget("enableExtraAnim")
+            widget.set_sensitive(False)
+            Tooltips.set_tip(widget, _(("Can't find any animation extension plugins.")))
+
+    def EnableAnimationsChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        active = widget.get_active()
+        plugin = self.Context.Plugins['animation']
+        EnablePlugin(plugin, active)
+        for prefix in ("open", "close", "minimize", "focus"):
+            name = prefix + "AnimationBox"
+            widget = self.GladeXML.get_widget(name)
+            widget.set_sensitive(active)
+        widget = self.GladeXML.get_widget('enableExtraAnim')
+        widget.set_sensitive(active)
+        if active:
+            if widget.get_active():
+                # If enableExtraAnim is checked, enable the extension plugins
+                self.EnableExtraAnimationsChanged(widget)
+            else:
+                # Otherwise, just fill boxes with the base animation effects
+                self.Context.UpdateExtensiblePlugins()
+                self.FillAnimationBoxes()
+    
+    def EnableExtraAnimationsChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        # Enable/disable all extension plugins, considering dependencies
+        pluginsToChange = list(self.AnimExtensionPlugins)
+        while len(pluginsToChange) > 0:
+            lastPluginsToActivate = list(pluginsToChange)
+            pluginList = list(pluginsToChange)
+            for plugin in pluginList:
+                if plugin.Enabled != widget.get_active() and \
+                    EnablePlugin(plugin, widget.get_active()):
+                    pluginsToChange.remove(plugin)
+            if pluginsToChange == lastPluginsToActivate:
+                break  # no progress this iteration, so stop
+
+        self.Context.UpdateExtensiblePlugins()
+        self.FillAnimationBoxes()
+
+    def AnimationBoxChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        name = widget.get_name()
+        settingName = AnimationSettings[name]
+
+        text = widget.get_active_text()
+        plugin = self.Context.Plugins['animation']
+        setting = plugin.Screen[settingName]
+        value = setting.Value
+        if len(value) >= 1:
+            if text:  # Handle "chosen animation is in an extension plugin" case
+                value[0] = setting.Info[1][0][text]
+                setting.Value = value
+                self.Context.Write()
+        else:
+            for setting in plugin.Groups[setting.Group][setting.SubGroup].Screen.values():
+                setting.Reset()
+            self.Context.Write()
+            self.AnimationBoxChanged(widget, settingName)
+
+    def SetEnableAnimations(self):
+        widget = self.GladeXML.get_widget("enableAnimations")
+        active = False
+        if 'animation' in self.Context.Plugins:
+            plugin = self.Context.Plugins['animation']
+            active = plugin.Enabled
+
+        widget.set_active(active)
+
+        # If at least one animation extension plugin is active,
+        # make the enableExtraAnimations widget active
+        widget = self.GladeXML.get_widget("enableExtraAnim")
+        atLeastOneActive = False
+        for plugin in self.AnimExtensionPlugins:
+            if plugin.Enabled:
+                atLeastOneActive = True
+                break
+        widget.set_active(atLeastOneActive)
+
+        for prefix in ("open", "close", "minimize", "focus"):
+            name = prefix + "AnimationBox"
+            widget = self.GladeXML.get_widget(name)
+            widget.set_sensitive(active)
+    
+    def FillAnimationBoxes(self):
+        if 'animation' not in self.Context.Plugins:
+            return
+
+        plugin = self.Context.Plugins['animation']
+        
+        for boxName, settingName in AnimationSettings.items():
+            box = self.GladeXML.get_widget(boxName)
+            setting = plugin.Screen[settingName]
+            info = setting.Info[1]
+            itemsByValue = info[1]
+            items = info[2]
+            SetupBoxModel(box)
+            for key, value in items:
+                box.append_text(key)
+            if len(setting.Value) >= 1:
+                value = setting.Value[0]
+                if itemsByValue.has_key(value):
+                    box.set_active(itemsByValue[value][1])
+            else:
+                box.set_active(0)
+
+    def Update(self):
+        self.Block += 1
+        self.SetEnableAnimations()
+        self.FillAnimationBoxes()
+        self.Block -= 1
+
+class EffectPage:
+    def __init__(self, context, gladeXML):
+        self.GladeXML = gladeXML
+        self.Context  = context
+        self.Block    = 0
+
+        self.GladeXML.signal_autoconnect(self)
+
+    def UpdateSwitcherPlugins(self):
+        self.SwitcherPlugins = {}
+        self.SwitcherKeySettings = {}
+        self.ReverseSwitcherKeySettings = {}
+        for pluginName in ('switcher', 'shift', 'ring', 'staticswitcher', 'stackswitch'):
+            if pluginName in self.Context.Plugins:
+                plugin = self.Context.Plugins[pluginName]
+
+                if pluginName == 'shift':
+                    self.SwitcherPlugins[_("%s (Cover)") % plugin.ShortDesc] = plugin
+                    self.SwitcherPlugins[_("%s (Flip)") % plugin.ShortDesc] = plugin
+                else:
+                    self.SwitcherPlugins[plugin.ShortDesc] = plugin
+
+                setting = plugin.Screen['next_key']
+                self.SwitcherKeySettings[pluginName] = setting
+                setting = plugin.Screen['prev_key']
+                self.ReverseSwitcherKeySettings[pluginName] = setting
+
+
+    def EffectPluginChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        name = widget.get_name()
+        effectPlugins = {
+        'enableScale': "scale",
+        'enableWobbly': "wobbly",
+        'enableBlur': "blur",
+        'enableExpo': "expo",
+        'enable3D': "3d"
+        }
+        pluginName = effectPlugins[name]
+
+        plugin = self.Context.Plugins[pluginName]
+        value  = widget.get_active()
+
+        EnablePlugin(plugin, value)
+ 
+    def SwitcherBoxChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        text = widget.get_active_text()
+
+        for shortDesc, plugin in self.SwitcherPlugins.items():
+            if text != shortDesc:
+                EnablePlugin(plugin, False)
+                setting = self.SwitcherKeySettings[plugin.Name]
+                if not setting.IsDefault and setting.DefaultValue != SwitcherKey:
+                    setting.Reset()
+                setting = self.ReverseSwitcherKeySettings[plugin.Name]
+                if not setting.IsDefault and setting.DefaultValue != ReverseSwitcherKey:
+                    setting.Reset()
+
+        self.Context.Write()
+
+        if not text in self.SwitcherPlugins:
+            return
+
+        plugin = self.SwitcherPlugins[text]
+        EnablePlugin(plugin, True)
+
+        # Set default key binding to Alt-Tab
+        setting = self.SwitcherKeySettings[plugin.Name]
+        settings = self.SwitcherKeySettings.values()
+        conflict = ccm.KeyConflict(setting, SwitcherKey, settings=settings, autoResolve=True)
+        if conflict.Resolve(ccm.GlobalUpdater):
+            setting.Value = SwitcherKey
+
+            setting = self.ReverseSwitcherKeySettings[plugin.Name]
+            settings = self.ReverseSwitcherKeySettings.values()
+            conflict = ccm.KeyConflict(setting, SwitcherKey, settings=settings, autoResolve=True)
+            if conflict.Resolve(ccm.GlobalUpdater):
+                setting.Value = ReverseSwitcherKey
+
+            # Exception for shift, since it has 2 modes
+            if plugin.Name == 'shift':
+                setting = plugin.Screen['mode']
+
+                if text.find(_("Cover")) != -1:
+                    setting.Value = 0
+                elif text.find(_("Flip")) != -1:
+                    setting.Value = 1
+
+        self.Context.Write()
+
+    def DeformationBoxChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        text = widget.get_active_text()
+        plugin = self.Context.Plugins['cubeaddon']
+        setting = plugin.Screen['deformation']
+        value = setting.Info[2][text]
+        if value != 0 and not plugin.Enabled:
+            EnablePlugin(plugin, True)
+        setting.Value = value
+
+        self.Context.Write()
+
+    def OpacityChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        value = widget.get_value()
+        plugin = self.Context.Plugins['cube']
+        # Only change cube opacity on rotate
+        setting = plugin.Screen['active_opacity']
+        setting.Value = float(value)
+
+        self.Context.Write()
+
+    def EnableReflectionChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        value = widget.get_active()
+        plugin = self.Context.Plugins['cubeaddon']
+        setting = plugin.Screen['reflection']
+        setting.Value = value
+
+        self.Context.Write()
+
+    def SetEffectPlugins(self):
+        widgets = {
+        'scale': "enableScale",
+        'wobbly': "enableWobbly",
+        'blur': "enableBlur",
+        'expo': "enableExpo",
+        '3d': "enable3D"
+        }
+
+        for pluginName, widgetName in widgets.items():
+            widget = self.GladeXML.get_widget(widgetName)
+            active = False
+            sensitive = False
+            if pluginName in self.Context.Plugins:
+                plugin = self.Context.Plugins[pluginName]
+                active = plugin.Enabled
+                sensitive = True
+            widget.set_sensitive(sensitive)
+            widget.set_active(active)
+
+    def SetCubeEffects(self, widget=None):
+        alignment = self.GladeXML.get_widget("cubeEffectsAlignment")
+        sensitive = False
+        if 'cube' in self.Context.Plugins:
+            plugin = self.Context.Plugins['cube']
+            sensitive = plugin.Enabled
+        alignment.set_sensitive(sensitive)
+
+    def SetOpacity(self):
+        widget = self.GladeXML.get_widget("cubeOpacity")
+
+        if not 'cube' in self.Context.Plugins:
+            return
+
+        plugin = self.Context.Plugins['cube']
+        setting = plugin.Screen['active_opacity']
+        value = setting.Value
+        widget.set_value(int(value))
+
+    def SetReflection(self):
+        widget = self.GladeXML.get_widget("enableReflection")
+
+        if not 'cubeaddon' in self.Context.Plugins:
+            return
+
+        plugin = self.Context.Plugins['cubeaddon']
+        setting = plugin.Screen['reflection']
+        value = setting.Value
+        widget.set_active(value)
+
+    def FillSwitcherBox(self):
+        box = self.GladeXML.get_widget("switcherPluginChooser")
+        SetupBoxModel(box)
+        box.append_text(_("None"))
+        box.set_active(0)
+
+        i = 1
+        for shortDesc, plugin in self.SwitcherPlugins.items():
+            box.append_text(shortDesc)
+            if plugin.Enabled:
+                if plugin.Name == 'shift':
+                    modes = [_("Cover"), _("Flip")]
+                    setting = plugin.Screen['mode']
+                    mode = modes[setting.Value]
+                    if mode in shortDesc:
+                        box.set_active(i)
+                else:
+                    box.set_active(i)
+            i += 1
+
+    def FillDeformationBox(self):
+        box = self.GladeXML.get_widget("deformationChooser")
+        SetupBoxModel(box)
+
+        if not 'cubeaddon' in self.Context.Plugins:
+            box.set_sensitive(False)
+            return
+
+        plugin = self.Context.Plugins['cubeaddon']
+        setting = plugin.Screen['deformation']
+
+        items = sorted(setting.Info[2].items(), key=ccm.EnumSettingKeyFunc)
+        for key, value in items:
+            box.append_text(key)
+        box.set_active(setting.Value)
+
+    def Update(self):
+        self.Block += 1
+        self.SetEffectPlugins()
+        self.SetCubeEffects()
+        self.SetOpacity()
+        self.SetReflection()
+        self.UpdateSwitcherPlugins()
+        self.FillSwitcherBox()
+        self.FillDeformationBox()
+        self.Block -= 1
+
+class DesktopPage:
+    def __init__(self, context, gladeXML):
+        self.GladeXML = gladeXML
+        self.Context  = context
+        self.Block    = 0
+
+        self.GladeXML.signal_autoconnect(self)
+
+        # Preview Widget
+        self.DesktopPreview = DesktopPreview()
+        previewAlign = self.GladeXML.get_widget("previewAlignment")
+        previewAlign.add(self.DesktopPreview)
+
+    def UpdateDesktopPlugins(self):
+        self.DesktopPlugins = {}
+        for plugin in self.Context.Plugins.values():
+            if "largedesktop" in plugin.Features:
+                self.DesktopPlugins[plugin.ShortDesc] = plugin
+    
+    def DesktopSizeChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        name = widget.get_name()
+        settings = {
+        'horizontalDesktops': "hsize",
+        'verticalDesktops': "vsize"
+        }
+        settingName = settings[name]
+
+        value = widget.get_value()
+        self.Context.Plugins['core'].Screen[settingName].Value = value
+        self.Context.Write()
+        self.SetDesktopPreview()
+
+    def AppearenceBoxChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        text = widget.get_active_text()
+
+        for shortDesc, plugin in self.DesktopPlugins.items():
+            if text != shortDesc:
+                EnablePlugin(plugin, False)
+
+        self.Context.Write()
+
+        for shortDesc, plugin in self.DesktopPlugins.items():
+            if text == shortDesc:
+                plugin.Enabled = True
+                # exception for cube, since it requires rotate
+                if plugin.Name == 'cube':
+                    setting = self.Context.Plugins['core'].Screen['vsize']
+                    setting.Value = 1 # Cube can only use 1 vertical viewport
+                    EnablePlugin(self.Context.Plugins['rotate'], True)
+                    EnablePlugin(self.Context.Plugins['cubeaddon'], True)
+
+        self.Context.Write()
+        self.SetDesktopSize()
+
+    def SetDesktopPreview(self):
+        hsize = self.Context.Plugins['core'].Screen["hsize"].Value
+        vsize = self.Context.Plugins['core'].Screen["vsize"].Value
+        self.DesktopPreview.set_value((hsize, vsize))
+
+    def SetDesktopSize(self):
+        scales = {"horizontalDesktops" : "hsize",
+                  "verticalDesktops"   : "vsize"}
+
+        for widgetName, settingName in scales.items():
+            widget = self.GladeXML.get_widget(widgetName)
+            setting = self.Context.Plugins['core'].Screen[settingName]
+            widget.set_value(setting.Value)
+
+    def FillAppearenceBox(self):
+        box = self.GladeXML.get_widget("desktopPluginChooser")
+        SetupBoxModel(box)
+
+        i = 0
+        for shortDesc, plugin in self.DesktopPlugins.items():
+            box.append_text(shortDesc)
+            if plugin.Enabled:
+                box.set_active(i)
+            i += 1
+
+    def Update(self):
+        self.Block += 1
+        self.SetDesktopPreview()
+        self.SetDesktopSize()
+        self.UpdateDesktopPlugins()
+        self.FillAppearenceBox()
+        self.Block -= 1
+
+class ZoomPage:
+    def __init__(self, context, gladeXML):
+        self.GladeXML = gladeXML
+        self.Context  = context
+        self.Block    = 0
+
+        self.GladeXML.signal_autoconnect(self)
+
+        # Zoom Keybindings
+        self.Widgets = {}
+        self.Settings = {
+        # identifier  -   plugin   -    setting     -      container
+        'screenZoomIn':  ('ezoom', 'zoom_in_button',  'screenZoomBox'),
+        'screenZoomOut': ('ezoom', 'zoom_out_button', 'screenZoomBox'),
+        'areaZoomIn':    ('mag',   'zoom_in_button',  'areaZoomBox'),
+        'areaZoomOut':   ('mag',   'zoom_out_button', 'areaZoomBox')
+        }
+
+    def ZoomChanged(self, widget):
+        if self.Block > 0:
+            return
+        
+        available = {}
+        for name in ('ezoom', 'mag'):
+            if name in self.Context.Plugins:
+                plugin = self.Context.Plugins[name]
+                available[name] = plugin
+        
+        widget = self.GladeXML.get_widget("enableZoom")
+        if 'ezoom' in available:
+            available['ezoom'].Enabled = widget.get_active()
+        elif 'zoom' in available:
+            available['ezoom'].Enabled = widget.get_active()
+
+        widget = self.GladeXML.get_widget("enableMag")
+        if 'mag' in available:
+            available['mag'].Enabled = widget.get_active()
+
+        self.Context.Write()
+        for identifier, data in self.Settings.items():
+            pluginName, settingName, containerName = data
+
+            if pluginName not in self.Context.Plugins:
+                continue
+
+            plugin    = self.Context.Plugins[pluginName]
+            container = self.GladeXML.get_widget(containerName)
+            container.set_sensitive(plugin.Enabled)
+    
+    def SetZoom(self):
+        for identifier, data in self.Settings.items():
+            pluginName, settingName, containerName = data
+
+            if pluginName not in self.Context.Plugins:
+                continue
+
+            if identifier not in self.Widgets:
+                plugin    = self.Context.Plugins[pluginName]
+                setting   = plugin.Screen[settingName]
+                widget    = ccm.MakeSetting(setting)
+                container = self.GladeXML.get_widget(containerName)
+                container.pack_start(widget.EBox)
+                if not plugin.Enabled:
+                    container.set_sensitive(False)
+                self.Widgets[identifier] = widget
+
+            self.Widgets[identifier].Read()
+
+        available = {}
+        for name in ('ezoom', 'zoom', 'mag'):
+            if name in self.Context.Plugins:
+                plugin = self.Context.Plugins[name]
+                available[name] = plugin
+
+        widget = self.GladeXML.get_widget("enableZoom")
+        widget.set_sensitive(True)
+        if 'ezoom' in available:
+            plugin = available['ezoom']
+            widget.set_active(plugin.Enabled)
+        elif 'zoom' in available:
+            plugin = available['zoom']
+            widget.set_active(plugin.Enabled)
+        else:
+            widget.set_sensitive(False)
+            widget.set_active(False)
+
+        widget = self.GladeXML.get_widget("enableMag")
+        widget.set_sensitive(True)
+        if 'mag' in available:
+            plugin = available['mag']
+            widget.set_active(plugin.Enabled)
+        else:
+            widget.set_sensitive(False)
+            widget.set_active(False)
+
+    def Update(self):
+        self.Block += 1
+        self.SetZoom()
+        self.Block -= 1
+
+class EdgePage:
+    def __init__(self, context, gladeXML):
+        self.GladeXML = gladeXML
+        self.Context  = context
+        self.Block    = 0
+
+        align = self.GladeXML.get_widget("edgesAlignment")
+        self.EdgeSelector = ccm.GlobalEdgeSelector(self.Context)
+        align.add(self.EdgeSelector)
+
+    def Update(self):
+        pass
+
+class PagesThread(Thread):
+    def __init__(self, mainWin):
+        self.mainWin = mainWin
+        Thread.__init__(self)
+
+    def InitPages(self):
+        mainWin = self.mainWin
+
+        # Wait until main window is shown
+        while not mainWin.DoneUpdate:
+            time.sleep(0.1)
+
+        mainWin.EffectPage = EffectPage(mainWin.Context, mainWin.GladeXML)
+        mainWin.EffectPage.Update()
+        mainWin.Window.show_all()
+
+        mainWin.EdgePage = EdgePage(mainWin.Context, mainWin.GladeXML)
+        mainWin.EdgePage.Update()
+        mainWin.Window.show_all()
+
+    def run(self):
+        self.InitPages()
+
+    def Quit (self):
+        gtk.main_quit()
+
+class MainWin:
+    def __init__(self, context, page = -1):
+        self.GladeXML = glade.XML(DataDir + "simple-ccsm.glade", domain="simple-ccsm")
+        self.GladeXML.signal_autoconnect(self)
+
+        self.Context = context
+        self.Block = 0
+
+        if page != -1 and page in Pages:
+            notebook = self.GladeXML.get_widget("notebook")
+            notebook.set_current_page (Pages[page])
+
+        # Window
+        self.Window = self.GladeXML.get_widget("mainWin")
+
+        # Enable effects button
+        self.EnableEffectsButton = self.GladeXML.get_widget("enableEffects")
+        self.EnableEffectsButton.connect ("toggled", self.EnableDesktopEffectsChanged)
+        self.Notebook = self.GladeXML.get_widget("notebook")
+        if not CompizEnableDesktopEffects:
+            self.EnableEffectsButton.hide_all()
+            self.EnableEffectsButton.set_no_show_all(True)
+
+        # Profile Chooser
+        self.ProfileChooser = self.GladeXML.get_widget("profileChooser")
+
+        # Pages
+        self.AnimationPage = AnimationPage(self.Context, self.GladeXML)
+        self.DesktopPage   = DesktopPage(self.Context, self.GladeXML)
+        self.ZoomPage      = ZoomPage(self.Context, self.GladeXML)
+        self.ProfilePage   = ProfilePage(self.Context, self.GladeXML)
+        self.EffectPage    = None
+        self.EdgePage      = None
+
+        self.DoneUpdate = False
+        PagesThread(self).start()
+
+        self.Update()
+        self.Window.show_all()
+        self.DoneUpdate = True
+
+        gobject.timeout_add(1000, self.EnableIntegration)
+
+    def EnableIntegration(self):
+        if GnomeSession in os.environ and os.environ[GnomeSession]:
+            if not self.Context.Integration:
+                self.Context.Integration = True
+
+            compat = self.Context.Plugins["gnomecompat"]
+            if not compat.Enabled:
+                EnablePlugin(compat, True)
+        elif KdeSession in os.environ and os.environ[KdeSession]:
+            if not self.Context.Integration:
+                self.Context.Integration = True
+
+        self.Context.Write()
+
+
+    def CheckForCompiz(self):
+        composited = self.Window.is_composited()
+        if composited:
+            # Now do the dirty work - check if it is really Compiz
+            psCMD = "ps -e".split(" ")
+            ps = subprocess.Popen(psCMD, stdout=subprocess.PIPE)
+            grepCMD = "grep compiz".split(" ")
+            grep = subprocess.Popen(grepCMD, stdin=ps.stdout, stdout=subprocess.PIPE)
+            grep.wait()
+            lines = grep.stdout.readlines()
+            for l in lines:
+                name = l.replace("\n", "").split(" ")[-1]
+                if name == CompizName:
+                    return True
+
+        return False
+
+    def Update(self):
+        self.Context.Read()
+        self.Block += 1
+
+        self.AnimationPage.Update()
+        self.DesktopPage.Update()
+        if self.EffectPage:
+            self.EffectPage.Update()
+        self.ZoomPage.Update()
+        self.ProfilePage.Update()
+        if self.EdgePage:
+            self.EdgePage.Update()
+
+        self.SetProfile()
+        if CompizEnableDesktopEffects:
+            self.SetEnableDesktopEffects()
+
+        self.Block -= 1
+
+    def SetEnableDesktopEffects(self):
+        running = self.CheckForCompiz()
+        self.EnableEffectsButton.set_active(running)
+        self.Notebook.set_sensitive(running)
+        self.ProfileChooser.set_sensitive(running)
+
+    def EnableDesktopEffectsChanged(self, widget):
+        if self.Block > 0:
+            return
+
+        enabled = self.EnableEffectsButton.get_active()
+        if enabled:
+            # First try to check if compiz can be run
+            cmd = CompizDryRunCommand.split(" ")
+            proc = subprocess.Popen(cmd, shell=True)
+            proc.wait()
+            if proc.returncode != 0:
+                # Dry run detected problems, warn the user
+                dialog = gtk.Dialog ()
+                dialog.set_title("Error")
+                dialog.set_border_width(6)
+                label = gtk.Label(_("Desktop effects are not supported on your current hardware / configuration. Would you like to cancel enabling of desktop effects or run them anyway?"))
+                label.set_line_wrap(True)
+                dialog.vbox.pack_start(label,
+                                       gtk.TRUE,
+                                       gtk.FALSE,
+                                       3)
+                dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
+                dialog.add_button("Run anyway", gtk.RESPONSE_OK)
+                dialog.show_all()
+                response = dialog.run()
+                dialog.destroy()
+                if response != gtk.RESPONSE_OK:
+                    self.EnableEffectsButton.set_active(False)
+                    return
+
+            # Make compiz manager skip further checks
+            path = os.path.expanduser("~/.config/compiz/compiz-manager")
+            hasSkip = False
+
+            try:
+                config = open(path, "r")
+                for l in config.readlines():
+                    if "SKIP_CHECKS" in l:
+                        hasSkip = True
+                        break
+                config.close()
+            except IOError, e:
+                print "No compiz manager config found!"
+                dir = os.path.expanduser("~/.config/compiz/")
+                if not os.path.exists(dir):
+                    os.makedirs(dir)
+
+            if not hasSkip:
+                config = open(path, "a")
+                config.write("SKIP_CHECKS=yes")
+                config.close()
+
+            # Start compiz
+            cmd = CompizStartCommand.split(" ")
+            subprocess.Popen(cmd)
+
+            # Enable compiz in kde
+            try:
+                 subprocess.call('kwriteconfig --file ksmserverrc --group General --key windowManager compiz'.split())
+            except (IOError, OSError):
+                 pass
+
+            # Create a file that indicates wether compiz is enabled or not
+            xdg_compiz = GetXdgConfigHome('compiz')
+            path = os.path.join(xdg_compiz, 'enable-compiz')
+            open(path, "w+").close() # touch replacement
+
+            path = os.path.join(xdg_compiz, 'disable-compiz')
+            try:
+                os.remove(path)
+            except (IOError, OSError):
+                pass
+        else:
+            fallbackWM = ""
+            if GnomeSession in os.environ and os.environ[GnomeSession]:
+                fallbackWM = "metacity"
+            elif KdeSession in os.environ and os.environ[KdeSession]:
+                fallbackWM = "kwin"
+
+            if fallbackWM:
+                cmd = "%s --replace" % fallbackWM
+                cmd = cmd.split(" ")
+                subprocess.Popen(cmd)
+
+            # Reset window manager config for KDE
+            cmd = "kwriteconfig --file ksmserverrc --group General --key windowManager kwin".split(" ")
+            try:
+                subprocess.Popen(cmd)
+            except (IOError, OSError):
+                pass
+
+            # Create a file that indicates compiz is explicitly disabled, so should not be started
+            xdg_compiz = GetXdgConfigHome('compiz')
+            path = os.path.join(xdg_compiz, 'disable-compiz')
+            open(path, "w+").close() # touch replacement
+
+            # Remove old config
+            files = (os.path.join(xdg_compiz, 'enable-compiz'), os.path.join(xdg_compiz, 'compiz-manager'))
+            for file in files:
+                path = os.path.expanduser(file)
+                try:
+                    os.remove(path)
+                except (IOError, OSError):
+                    pass
+
+        self.Notebook.set_sensitive(enabled)
+        self.ProfileChooser.set_sensitive(enabled)
+
+
+    def ApplyProfile(self, widget):
+        profile = self.ProfileChooser.get_active_text()
+        self.Context.ResetProfile()
+        self.Context.Read()
+
+        if  profile != _("Default")\
+        and profile in Profiles:
+            profile = Profiles[profile]
+
+        profilePath = "%s/profiles/%s.profile" % (DataDir, profile)
+        self.Context.CurrentProfile = ccs.Profile(self.Context, profile)
+        self.Context.UpdateProfiles()
+        self.Context.Import(profilePath)
+        self.Context.Write()
+        self.Update()
+
+    def SetProfile(self):
+        SetupBoxModel(self.ProfileChooser)
+
+        self.Context.UpdateProfiles()
+
+        self.ProfileChooser.append_text(_("Default"))
+        profiles = sorted(Profiles.values())
+        for profile in profiles:
+            self.ProfileChooser.append_text(_(profile))
+
+        current = self.Context.CurrentProfile.Name or _("Default")
+        if current in profiles:
+            pos = profiles.index(current) + 1
+            self.ProfileChooser.set_active(pos)
+        elif current != _("Default"):
+            self.ProfileChooser.prepend_text(current)
+            self.ProfileChooser.set_active(0)
+        else:
+            self.ProfileChooser.set_active(0)
+
+    def Quit(self, widget):
+        gtk.main_quit()
+
+if __name__ == "__main__":
+    context = ccs.Context()
+    page = -1
+    parser = OptionParser()
+    parser.add_option("-p", "--page", dest = "page",
+		      help = "Directly jump to page PAGE", metavar = "PAGE")
+    (options, args) = parser.parse_args()
+    if options.page:
+        page = options.page
+    gtk.window_set_default_icon_name('simple-ccsm')
+    mainWin = MainWin(context, page)
+    gdk.threads_init()
+    gtk.main()