Added KDE3 version of KDE Guidance utilities

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kde-guidance@1102646 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 3552 insertions, 0 deletions

diff --git a/wineconfig/wineconfig.py b/wineconfig/wineconfig.py
new file mode 100755
index 0000000..d4c39ac
--- /dev/null
+++ b/wineconfig/wineconfig.py
@@ -0,0 +1,3552 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+###########################################################################
+# wineconfig.py - description                                             #
+# ------------------------------                                          #
+# begin     : Fri Mar 26 2004                                             #
+# copyright : (C) 2006 by Yuriy Kozlov                                    #
+# email     : yuriy.kozlov@gmail.com                                      #
+#                                                                         #
+###########################################################################
+#                                                                         #
+#   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.                                   #
+#                                                                         #
+###########################################################################
+
+from qt import *
+from kdecore import *
+from kdeui import *
+from kfile import *
+from kio import *
+#import string
+#import math
+import os
+import shutil
+#import select
+import sys
+#import struct
+#import csv
+#import time
+import signal
+#import shutil
+import wineread
+import winewrite
+import drivedetect
+import wineconfig
+
+programname = "Wine Configuration"
+version = "0.7.1"
+
+default_winepath = os.environ['HOME'] + "/.wine"
+
+# Are we running as a separate standalone application or in KControl?
+standalone = __name__=='__main__'
+
+# Editing application specific settings?  For which application?
+application = None
+
+# Running as the root user or not? Doesn't matter for wine
+isroot = os.getuid()==0
+
+############################################################################
+if standalone:
+    programbase = KDialogBase
+else:
+    programbase = KCModule
+
+############################################################################
+class WineConfigApp(programbase):
+    ########################################################################
+    def __init__(self,parent=None,name=None):
+        global standalone,kapp,default_winepath,application
+        KGlobal.locale().insertCatalogue("guidance")
+
+        if standalone:
+            KDialogBase.__init__(self,KJanusWidget.Tabbed,"Wine Configuration",\
+                KDialogBase.Apply|KDialogBase.User1|KDialogBase.User2|KDialogBase.Close, KDialogBase.Close)
+            self.setButtonText(KDialogBase.User1,i18n("Reset"))
+            self.setButtonText(KDialogBase.User2,i18n("About"))
+            args = KCmdLineArgs.parsedArgs()
+            if args.count() > 0:
+                application = args.arg(0)
+        else:
+            KCModule.__init__(self,parent,name)
+            self.setButtons(KCModule.Apply|KCModule.Reset)
+            self.aboutdata = MakeAboutData()
+
+        # Create a configuration object.
+        self.config = KConfig("wineconfigrc")
+
+        # Compact mode means that we have to make the GUI 
+        # much smaller to fit on low resolution screens.
+        self.compact_mode = kapp.desktop().height()<=600
+
+        KGlobal.iconLoader().addAppDir("guidance")
+
+        self.wineconfigchanged = False
+
+        self.updatingGUI = True
+
+        if not wineread.GetWineBuildPath():
+            install = KMessageBox.questionYesNo(self, \
+                i18n("It appears that you do not have Wine installed. Wine " + \
+                    "can be used to run some programs designed for Windows.  " + \
+                    "Would you " + \
+                    "like to install it?\n" + \
+                    "You will need administrative privileges, and the " + \
+                    "community-maintained (universe) repository will be enabled."), \
+                i18n("Windows Applications"))
+            if install == KMessageBox.Yes:
+                self.InstallWine()
+                
+        wineread.SetWineBuildPath(wineread.GetWineBuildPath())
+        
+        if wineread.GetWineBuildPath():
+            # wine doesn't set the WINEPREFIX globally, but just in case...
+            wineprefix = os.environ.get('WINEPREFIX',default_winepath)
+            newrc = not self.config.hasKey("ColorScheme")
+            firstrun = not wineread.VerifyWineDrive(wineprefix)
+            if firstrun:
+                KMessageBox.information(self, \
+                    i18n("It appears that you do not yet have a Windows drive set up.  " + \
+                        "A fake Windows installation will be created for you in " + \
+                        wineprefix + "\nThis may take up to a minute."), \
+                    i18n("Setting up your Windows drive"))
+                self.CreateWindowsInstall()
+                        
+            self._buildGUI()
+    
+            if firstrun and newrc:
+                self.appearancepage.slotColorSchemeActivated(1)
+        else:
+            self._buildGUI_noWine()
+                    
+        self.aboutus = KAboutApplication(self)
+
+        if standalone:
+            self.enableButton(KDialogBase.User1,False) # Reset button
+            self.enableButtonApply(False) # Apply button
+
+        self.updatingGUI = False
+        
+        
+    def _buildGUI(self):
+        global standalone,application
+        if not standalone:
+            toplayout = QVBoxLayout( self, 0, KDialog.spacingHint() )
+            tabcontrol = QTabWidget(self)
+            toplayout.addWidget(tabcontrol)
+            toplayout.setStretchFactor(tabcontrol,1)
+
+        #--- General tab ---
+        tabname = i18n("General")
+        if standalone:
+            general1page = self.addGridPage(1,QGrid.Horizontal,tabname)
+            general1page.setSpacing(0)
+            self.generalpage = GeneralPage(general1page,self.compact_mode)
+        else:
+            self.generalpage = GeneralPage(tabcontrol,self.compact_mode)
+            self.generalpage.setMargin(KDialog.marginHint())
+
+        # Connect all PYSIGNALs from GeneralPage Widget to appropriate actions.
+        self.connect(self.generalpage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
+
+        if not standalone:
+            tabcontrol.addTab(self.generalpage,tabname)
+
+        #--- Drives tab ---
+        if not application:
+            tabname = i18n("Drives && Directories")
+            if standalone:
+                drives1page = self.addGridPage(1,QGrid.Horizontal,tabname)
+                drives1page.setSpacing(0)
+                self.drivespage = DrivesPage(drives1page,self.compact_mode)
+            else:
+                self.drivespage = DrivesPage(tabcontrol,self.compact_mode)
+                self.drivespage.setMargin(KDialog.marginHint())
+
+            # Connect all PYSIGNALs from DrivesPage Widget to appropriate actions.
+            self.connect(self.drivespage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
+
+            if not standalone:
+                tabcontrol.addTab(self.drivespage,tabname)
+
+        #--- Audio tab ---
+        tabname = i18n("Audio")
+        if standalone:
+            audio1page = self.addGridPage(1,QGrid.Horizontal,tabname)
+            self.audiopage = AudioPage(audio1page)
+        else:
+            self.audiopage = AudioPage(tabcontrol)
+            self.audiopage.setMargin(KDialog.marginHint())
+
+        # Connect all PYSIGNALs from AudioPage Widget to appropriate actions.
+        self.connect(self.audiopage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
+
+        if not standalone:
+            tabcontrol.addTab(self.audiopage,tabname)
+
+        #--- Graphics tab ---
+        tabname = i18n("Graphics")
+        if standalone:
+            graphics1page = self.addGridPage(1,QGrid.Horizontal,tabname)
+            self.graphicspage = GraphicsPage(graphics1page)
+        else:
+            self.graphicspage = GraphicsPage(tabcontrol)
+            self.graphicspage.setMargin(KDialog.marginHint())
+
+
+        # Connect all PYSIGNALs from GraphicsPage Widget to appropriate actions.
+        self.connect(self.graphicspage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
+
+        if not standalone:
+            tabcontrol.addTab(self.graphicspage,tabname)
+
+        #--- Appearance tab ---
+        if not application:
+            tabname = i18n("Appearance")
+            if standalone:
+                appearance1page = self.addGridPage(1,QGrid.Horizontal,tabname)
+                self.appearancepage = AppearancePage(appearance1page)
+            else:
+                self.appearancepage = AppearancePage(tabcontrol)
+                self.appearancepage.setMargin(KDialog.marginHint())
+
+            # Connect all PYSIGNALs from DesktopPage Widget to appropriate actions.
+            self.connect(self.appearancepage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
+            self.graphicspage.connect(self.graphicspage.allowwmcheckbox,
+                SIGNAL("toggled(bool)"),
+                self.appearancepage.slotFillItemCombo)
+            self.connect(self.graphicspage.emudesktopcheckbox,
+                SIGNAL("toggled(bool)"),
+                self.appearancepage.slotFillItemComboDesktop)
+
+            self.appearancepage.slotFillItemComboDesktop(\
+                self.graphicspage.currentemudesktop)
+
+            if not standalone:
+                tabcontrol.addTab(self.appearancepage,tabname)
+
+        #--- Applications tab ---
+        if not application:
+            tabname = i18n("Applications")
+            if standalone:
+                apps1page = self.addGridPage(1,QGrid.Horizontal,tabname)
+                self.appspage = ApplicationsPage(apps1page)
+            else:
+                self.appspage = ApplicationsPage(tabcontrol)
+                self.appspage.setMargin(KDialog.marginHint())
+
+            # Connect all PYSIGNALs from ApplicationsPage Widget to appropriate actions.
+            self.connect(self.appspage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
+
+            if not standalone:
+                tabcontrol.addTab(self.appspage,tabname)
+
+        #--- Libraries tab ---
+        tabname = i18n("Libraries")
+        if standalone:
+            libs1page = self.addGridPage(1,QGrid.Horizontal,tabname)
+            self.libspage = LibrariesPage(libs1page)
+        else:
+            self.libspage = LibrariesPage(tabcontrol)
+            self.libspage.setMargin(KDialog.marginHint())
+
+        # Connect all PYSIGNALs from LibrariesPage Widget to appropriate actions.
+        self.connect(self.libspage,PYSIGNAL("changedSignal()"),self._sendChangedSignal)
+
+        if not standalone:
+            tabcontrol.addTab(self.libspage,tabname)
+
+
+    def _buildGUI_noWine(self):
+        """ Displays an error that wine is not installed """
+        global standalone
+        if not standalone:
+            toplayout = QVBoxLayout( self, 0, KDialog.spacingHint() )
+            
+        if not standalone:
+            nowinewarning = QLabel(self,"nowinewarning")
+            toplayout.addWidget(nowinewarning)
+        else:
+            vbox = self.addVBoxPage ("Wine Not Installed")
+            nowinewarning = QLabel(vbox,"nowinewarning")
+        nowinewarning.setText(i18n("It appears that you do not have wine " +\
+                    "installed.\nwine " + \
+                    "can be used to run some programs designed for " + \
+                    "Windows.\nPlease " +\
+                    "install the wine package to get this functionality."))
+        nowinewarning.setFrameStyle( QFrame.Box | QFrame.Raised )
+            
+    def InstallWine(self):
+        """ Allows the user to enable the proper repositories and
+        install wine.
+        Currently Kubuntu specific, requires kdesudo, adept_batch
+        and software-properties-kde """
+        if not isroot:
+            if os.system("kdesudo \"software-properties-kde --enable-component universe\""):
+                KMessageBox.error(self, i18n("There was a problem running " + \
+                    "software-properties-kde.  Make sure " + \
+                    "software-properties-kde is installed."))
+            elif os.system("kdesudo \"adept_batch install wine\""):
+                KMessageBox.error(self, i18n("There was a problem running " + \
+                    "adept_batch.  Make sure " + \
+                    "Adept is installed."))
+        else:
+            if os.system("software-properties-kde --enable-component=universe" + \
+                " && adept_batch install wine"):
+                KMessageBox.error(self, i18n("There was a problem running " + \
+                    "software-properties-kde and adept_batch.  Make sure " + \
+                    "Adept and software-properties-kde are installed."))
+                    
+    def CreateWindowsInstall(self,winepath = None):
+        if not winepath:
+            winepath = default_winepath
+        winewrite.CreateWineDrive(winepath)
+        wineread.SetWinePath(winepath)
+
+        drives = wineread.LoadDrives()
+        autodrives = drivedetect.autodetect(drives)
+        autoshelllinks = drivedetect.autodetectshelllinks()
+
+        if autodrives[0] == 1:
+            KMessageBox.sorry(self, \
+                i18n("There were not enough letters to add all the autodetected drives."))
+        drives = autodrives[1]
+        drives[26:] = autoshelllinks
+
+        winewrite.SetDriveMappings(drives)
+
+        winewrite.SetAudioDriver('alsa')
+
+        dsoundsettings = {"HardwareAcceleration":"Full",
+            "DefaultSampleRate":"44100",
+            "DefaultBitsPerSample":"8",
+            "EmulDriver":"N"}
+
+        winewrite.SetDSoundSettings(dsoundsettings)
+
+        windowsettings = {"DXGrab":"N",
+            "DesktopDoubleBuffered":"Y",
+            "Managed":"Y",
+            "Desktop":""}
+
+        winewrite.SetWindowSettings(windowsettings)
+
+        d3dsettings = {"VertexShaderMode":"hardware",
+            "PixelShaderMode":"Y",
+            "UseGLSL":"enabled"}
+
+        winewrite.SetD3DSettings(d3dsettings)
+
+        winewrite.SetWinVersion(wineread.winversions[1])
+
+        # Removed pending a patch to winebrowser
+        #winewrite.SetFirstBrowser("kfmclient exec")
+        #winewrite.SetFirstMailer("kfmclient exec")
+
+    def exec_loop(self,appname):
+        global application, programbase
+        if appname:
+            application = appname
+            KDialogBase.exec_loop(self)
+        else:
+            programbase.exec_loop(self)
+
+    def save(self): # KCModule
+        # Find out what's changed
+        generalchanged = self.generalpage.isChanged()
+        driveschanged = not application and self.drivespage.isChanged()
+        audiochanged = self.audiopage.isChanged()
+        graphicschanged = self.graphicspage.isChanged()
+        appearancechanged = not application and self.appearancepage.isChanged()
+        applicationschanged = not application and self.appspage.isChanged()
+        libschanged = self.libspage.isChanged()
+
+        # Apply changes for each tab
+        if generalchanged:
+            self.generalpage.applyChanges()
+        if driveschanged:
+            self.drivespage.applyChanges()
+        if audiochanged:
+            self.audiopage.applyChanges()
+        if graphicschanged:
+            self.graphicspage.applyChanges()
+        if appearancechanged:
+            self.appearancepage.applyChanges()
+        if applicationschanged:
+            self.appspage.applyChanges()
+        if libschanged:
+            self.libspage.applyChanges()
+
+        self._sendChangedSignal()
+
+    def slotApply(self): # KDialogBase
+        self.save()
+
+    def slotClose(self): # KDialogBase
+        KDialogBase.slotClose(self)
+
+    def load(self): # KCModule
+        self.__reset()
+        self._sendChangedSignal()
+
+    def slotUser1(self): # Reset button, KDialogBase
+        self.load()
+
+    def slotUser2(self): # About button, KDialogBase
+        self.aboutus.show()
+
+    def __reset(self):
+        # Reset each configuration page
+        if not application:
+            self.drivespage.reset()
+        self.audiopage.reset()
+        self.graphicspage.reset()
+        self.appearancepage.reset()
+        if not application:
+            self.appspage.reset()
+        self.libspage.reset()
+
+    # Kcontrol expects updates about whether the contents have changed.
+    # Also we fake the Apply and Reset buttons here when running outside kcontrol.
+    def _sendChangedSignal(self):
+        global standalone
+
+        changed = False
+        changed = changed or (not application and self.drivespage.isChanged()) or \
+            self.audiopage.isChanged() \
+            or self.generalpage.isChanged() or \
+            (not application and self.appspage.isChanged()) or \
+            self.libspage.isChanged() or \
+            (not application and self.appearancepage.isChanged())
+        graphicschanged = self.graphicspage.isChanged()
+        changed = changed or graphicschanged
+
+        if standalone:
+            self.enableButton(KDialogBase.User1,changed) # Reset button
+            self.enableButtonApply(changed) # Apply button
+        else:
+            self.emit(SIGNAL("changed(bool)"), (changed,) )
+
+############################################################################
+''' Not used.
+class ErrorPage(QWidget):
+    """
+    Displayed when there is no fake Windows drive
+    """
+
+    def __init__(self,parent = None, name = None, parentapp = None, modal = 0,fl=0):
+        QWidget.__init__(self,parent)
+
+        if not name:
+            self.setName("ErrorPage")
+
+        self.parent = parentapp
+
+        self.top_layout = QVBoxLayout(self,0,0,"ErrorPageLayout")
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        self.top_layout.addWidget(vbox)
+
+        errortext = QLabel(vbox,"errortext")
+        errortext.setText(i18n("You need to set up a " +\
+            "fake Windows drive\n before you can edit settings or run " +\
+            "Windows applications."))
+
+        self.createbutton = KPushButton(i18n("Create Fake Windows Drive"),vbox)
+        self.connect(self.createbutton,SIGNAL("clicked()"),self.slotCreateClicked)
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        self.top_layout.addItem(bottomspacer)
+
+        self.clearWState(Qt.WState_Polished)
+
+    def slotCreateClicked(self):
+        self.parent.CreateWindowsInstall()
+        self.parent._buildGUI()
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+'''
+
+##############################################################################
+
+class DrivesPage(QWidget):
+    """
+    A TabPage with configuration for drive mappings
+    """
+
+    types = (
+        (0,i18n("Autodetect"),"auto"),
+        (1,i18n("Local Hard Disk"),"hd"),
+        (2,i18n("Network Share"),"network"),
+        (3,i18n("Floppy Disk"),"floppy"),
+        (4,i18n("CD-ROM"),"cdrom"))
+
+    typesdic = {
+        'auto':0,
+        'hd':1,
+        'network':2,
+        'floppy':3,
+        'cdrom':4}
+
+    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
+        QWidget.__init__(self,parent)
+
+        self.updatingGUI = True
+
+        self.selecteddriveid = None
+
+        if not name:
+            self.setName("DrivesTab")
+
+        self.drives = wineread.LoadDrives()
+        self.drives[26:] = wineread.GetShellLinks()
+
+        drives_tab_layout = QVBoxLayout(self,0,0,"DrivesTabLayout")
+        self.top_layout = drives_tab_layout
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        drives_tab_layout.addWidget(vbox)
+
+        # -- Drive mappings group
+        self.mappings_group_box = QHGroupBox(vbox)
+        self.mappings_group_box.setTitle(i18n("Drive and Directory Mappings"))
+        self.mappings_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.mappings_group_box.setInsideMargin(KDialog.marginHint())
+
+        vbox2 = QVBox(self.mappings_group_box)
+        vbox2.setSpacing(KDialog.spacingHint())
+
+        spacer = QWidget(vbox2)
+        vbox2.setStretchFactor(spacer,1)
+
+        self.driveslist = KListView(vbox2)
+        self.driveslist.addColumn(i18n("Directory"))
+        self.driveslist.addColumn(i18n("Links to"))
+        self.driveslist.setAllColumnsShowFocus(True)
+        self.driveslist.setSelectionMode(QListView.Single)
+        self.driveslist.setSorting(-1,True)
+
+        self.connect(self.driveslist, SIGNAL("selectionChanged(QListViewItem *)"), self.slotListClicked)
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.addbutton = KPushButton(i18n("Add Drive..."),hbox)
+        self.connect(self.addbutton,SIGNAL("clicked()"),self.slotAddClicked)
+
+        self.removebutton = KPushButton(i18n("Remove Drive"),hbox)
+        self.connect(self.removebutton,SIGNAL("clicked()"),self.slotRemoveClicked)
+
+        spacer = QWidget(hbox)
+        hbox.setStretchFactor(spacer,1)
+
+        self.autobutton = KPushButton(i18n("Autodetect"),hbox)
+        self.connect(self.autobutton,SIGNAL("clicked()"),self.slotAutoClicked)
+
+        hbox2 = QHBox(vbox2)
+        hbox2.setSpacing(KDialog.spacingHint())
+
+        pathtext = QLabel(hbox2,"pathtext")
+        pathtext.setText(i18n("Path:"))
+
+        self.fsfolderedit = KLineEdit("/",hbox2)
+        self.urlcompletion = KURLCompletion(KURLCompletion.DirCompletion)
+        self.fsfolderedit.setCompletionObject(self.urlcompletion)
+        self.fsfolderedit.setCompletionMode(KGlobalSettings.CompletionPopup)
+        self.connect(self.fsfolderedit,SIGNAL("textChanged(const QString &)"),self.slotFolderEdited)
+
+        self.browsebutton = KPushButton(i18n("Browse"),hbox2)
+        self.connect(self.browsebutton,SIGNAL("clicked()"),self.slotBrowseClicked)
+
+        hbox2 = QHBox(vbox2)
+        hbox2.setSpacing(KDialog.spacingHint())
+
+        self.typetext = QLabel(hbox2,"typetext")
+        self.typetext.setText(i18n("Type:"))
+
+        self.typecombo = KComboBox(0,hbox2,"typecombo")
+        self.fillTypeCombo(self.typecombo)
+        self.connect(self.typecombo,SIGNAL("activated(int)"),self.slotTypeActivated)
+
+        spacer = QWidget(hbox2)
+        hbox2.setStretchFactor(spacer,1)
+
+        hbox2 = QHBox(vbox2)
+        hbox2.setSpacing(KDialog.spacingHint())
+
+        self.infotext1 = QLabel(hbox2,"infotext1")
+
+        hbox2 = QHBox(vbox2)
+        hbox2.setSpacing(KDialog.spacingHint())
+
+        self.infotext2 = QLabel(hbox2,"infotext2")
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        drives_tab_layout.addItem(bottomspacer)
+
+        self.changed = False
+
+        self.clearWState(Qt.WState_Polished)
+
+        self.updatingGUI=False
+
+        self.updateDrivesList()
+
+    def reset(self):
+        self.drives = wineread.LoadDrives()
+        self.drives[26:] = wineread.GetShellLinks()
+        self.updatingGUI=True
+        self.updateDrivesList()
+        self.updatingGUI=False
+        self.changed = False
+
+    def isChanged(self):
+        """ Check if something has changed since startup or last apply(). """
+        return self.changed
+
+    def applyChanges(self):
+        """ Apply the changes """
+        winewrite.SetDriveMappings(self.drives)
+        self.reset()
+
+    def updateChanges(self):
+        """ Update the GUI and send the signal that changes were made """
+        self.updatingGUI=True
+        self.updateDrivesList()
+        self.updatingGUI=False
+        self.changed = True
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotListClicked(self,item):
+        """ Show the drive information and settings for the newly selected drive """
+        if self.updatingGUI==False:
+            for driveid in self.drivesToListItems:
+                if self.drivesToListItems[driveid]==item:
+                    self.updatingGUI = True
+                    self.__selectDrive(driveid)
+                    self.updatingGUI = False
+                    return
+
+    def slotFolderChanged(self,folder):
+        """ Change the directory mapping when a new one is entered in the URL box """
+        self.drives[self.selecteddriveid][2] = unicode(folder)
+        self.updateChanges()
+
+    def slotFolderEdited(self,folder):
+        """ Change the directory mapping when a new one is entered manually in the URL box """
+        if not self.updatingGUI:
+            self.urlcompletion.makeCompletion("")   # Doesn't seem like this should be required.
+            self.slotFolderChanged(folder)
+
+    def slotBrowseClicked(self):
+        """ Bring up a browse window to choose a ndew mapping directory """
+        mapping = KFileDialog.getExistingDirectory(wineread.winepath,self,i18n("Drive Mapping"))
+        if mapping:
+            mapping = unicode(mapping)
+            self.drives[self.selecteddriveid][2] = mapping
+            self.updateChanges()
+
+    def slotAddClicked(self):
+        """
+        Let the user choose a directory to map a new drive to.
+        Uses the next available drive letter. """
+        # TODO: Maybe the user should choose the drive letter?
+        for drive in self.drives[2:26]:
+            if drive[2]:
+                continue
+            else:
+                mapping = KFileDialog.getExistingDirectory(wineread.winepath,self,i18n("Drive Mapping"))
+                if mapping:
+                    mapping = unicode(mapping)
+                    drive[2] = mapping
+                else:
+                    return
+                self.selecteddriveid = drive[0]
+                break
+        else:
+            KMessageBox.sorry(self, \
+                i18n("Can't add another drive.  There can only be 26, for letters A-Z"))
+            return
+
+        self.updateChanges()
+
+    def slotRemoveClicked(self):
+        """ Removes the currently selected drive """
+        if self.selecteddriveid == 2:   # Drive C:
+            if KMessageBox.warningContinueCancel(self, \
+                i18n("Are you sure you want to delete drive C:?\n\n"\
+                    "Most Windows applications expect drive C: to exist, "\
+                    "and will die messily if it doesn't.  If you proceed "\
+                    "remember to recreate it!"),\
+                i18n("Warning")) != KMessageBox.Continue:
+                return
+        self.drives[self.selecteddriveid][2:4] = ("","")
+        self.selecteddriveid -= 1     # Not quite correct, should select previous drive.
+        self.updateChanges()
+
+    def slotAutoClicked(self):
+        """ 
+        Autodetects a default set of drives from /etc/fstab
+        Allows the user to start with a fresh list of drives or append to the current one
+        """
+        automethod = KMessageBox.questionYesNoCancel(self, \
+            i18n("Would you like to remove the current set of drives?"),\
+            i18n("Drive Autodetection"))
+        if automethod == KMessageBox.Yes:
+            autodrives = drivedetect.autodetect()
+            autoshelllinks = drivedetect.autodetectshelllinks()
+        elif automethod == KMessageBox.No:
+            autodrives = drivedetect.autodetect(self.drives[:26])
+            autoshelllinks = drivedetect.autodetectshelllinks(self.drives[26:])
+        else:
+            return
+
+        if autodrives[0] == 1:
+            KMessageBox.sorry(self, \
+                i18n("There were not enough letters to add all the autodetected drives."))
+        self.drives[0:26] = autodrives[1]
+        self.drives[26:] = autoshelllinks
+
+        self.updateChanges()
+
+    def slotTypeActivated(self,index):
+        self.__selectType(self.types[index][2])
+        self.updateChanges()
+
+    def fillTypeCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for drivetype in self.types:
+            combo.insertItem(drivetype[1])
+
+    def __selectType(self,typename):
+        if typename:
+            typeid = self.typesdic[typename]
+        else:
+            typeid = self.typesdic['auto']
+        self.drives[self.selecteddriveid][3] = typename
+        self.typecombo.setCurrentItem(typeid)
+
+    def updateDrivesList(self):
+        """ Updates the displayed list of drives """
+        self.driveslist.clear()
+        self.drivesToListItems = {}
+        firstselecteddriveid = None
+        lastdriveid = None
+
+        for driveid, driveletter, mapping, drivetype, drivelabel, serial in reversed(self.drives):
+            if mapping or drivelabel:
+                lvi = QListViewItem(self.driveslist,driveletter,mapping)
+                self.drivesToListItems[driveid] = lvi
+                if self.selecteddriveid==driveid:
+                    firstselecteddriveid = driveid
+                lastdriveid = driveid
+            else:
+                continue
+
+        if firstselecteddriveid==None:
+            firstselecteddriveid = lastdriveid
+
+        self.selecteddriveid = firstselecteddriveid
+        self.__selectDrive(self.selecteddriveid)
+        self.driveslist.ensureItemVisible(self.driveslist.currentItem())
+
+    def __selectDrive(self,driveid):
+        """ Updates the GUI for a newly selected drive """
+        self.selecteddriveid = driveid
+        lvi = self.drivesToListItems[driveid]
+        self.driveslist.setSelected(lvi,True)
+        self.driveslist.setCurrentItem(lvi)
+
+        self.fsfolderedit.setText(self.drives[driveid][2])
+        if self.drives[driveid][3] == 'shellfolder':
+            self.typecombo.insertItem(i18n("Shell Folder"))
+            self.typecombo.setCurrentItem(5)
+            self.typecombo.setEnabled(False)
+
+            self.removebutton.setEnabled(False)
+
+            self.infotext1.setText(unicode(i18n("Windows path: ")) + self.drives[driveid][4])
+
+            # It seems some old versions of wine didn't store the shell folders in the same place
+            if self.drives[driveid][5] != self.drives[driveid][4]:
+                changeregistryshell = KMessageBox.warningYesNo(self, \
+                    i18n("The " + self.drives[driveid][1] + " folder is currently located in\n" + \
+                    self.drives[driveid][5] + "\nIt is recommended that it is put in the default " + \
+                    "location in\n" + wineread.defaultwinfolderspath + "\nWould you like to move it there?"),\
+                    i18n("Shell Folder Mapping"))
+                changeregistryshell = changeregistryshell == KMessageBox.Yes
+
+                if changeregistryshell:
+                    self.drives[driveid][5] = self.drives[driveid][4]
+                    self.changed = True
+                    self.emit(PYSIGNAL("changedSignal()"), ())
+
+            if self.drives[driveid][2] == wineread.profilesdirectory + self.drives[driveid][1]:
+                realfolderwarning = KMessageBox.information(self, \
+                    i18n(self.drives[driveid][1] + " is an actual folder and is not linked elsewhere." + \
+                    "  Remapping it will create a backup of the directory in " + \
+                    wineread.profilesdirectory),\
+                    i18n("Shell Folder Mapping"))
+        else:
+            if self.typecombo.count() > 5:
+                self.typecombo.removeItem(5)
+                self.typecombo.setEnabled(True)
+            self.__selectType(self.drives[driveid][3])
+
+            self.removebutton.setEnabled(True)
+
+            if self.drives[driveid][4]:
+                self.infotext1.setText(unicode(i18n("Label: ")) + self.drives[driveid][4])
+            else:
+                self.infotext1.setText("")
+            if self.drives[driveid][5]:
+                self.infotext2.setText(unicode(i18n("Serial: ")) + self.drives[driveid][5])
+            else:
+                self.infotext2.setText("")
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+############################################################################
+class AudioPage(QWidget):
+    driversdic = {
+        "":i18n("None - Disable Sound"),
+        "alsa":"ALSA",
+        "arts":"aRts",
+        "esd":"EsounD",
+        "oss":"OSS",
+        "jack":"JACK",
+        "nas":"NAS",
+        "coreaudio":"CoreAudio"}
+
+    drivers = ("","alsa","arts","esd","oss","jack","nas","coreaudio")
+
+    accel = (
+        (0,i18n("Full")),
+        (1,i18n("Standard")),
+        (2,i18n("Basic")),
+        (3,i18n("Emulation")))
+
+    samplerates = (
+        (0,"48000",48000),
+        (1,"44100",44100),
+        (2,"22050",22050),
+        (3,"16000",16000),
+        (4,"11025",11025),
+        (5,"8000",8000))
+
+    bitspersample = (
+        (0,"8",8),
+        (1,"16",16))
+
+    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
+        global application
+        QWidget.__init__(self,parent)
+
+        if not name:
+            self.setName("AudioTab")
+
+        audio_tab_layout = QVBoxLayout(self,0,0,"AudioTabLayout")
+        self.top_layout = audio_tab_layout
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        audio_tab_layout.addWidget(vbox)
+
+        if application:
+            appwarning = QLabel(vbox,"appwarning")
+            appwarning.setText(i18n("Application specific settings for <b>" +\
+                application + "</b><p>Changing a setting here will permanently " +\
+                "make that setting independent of settings for all other " +\
+                "applications.</p>"))
+            appwarning.setFrameStyle( QFrame.Box | QFrame.Raised )
+
+        # -- Drivers group
+        self.driver_group_box = QHGroupBox(vbox)
+        self.driver_group_box.setTitle(i18n("Driver Selection"))
+        self.driver_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.driver_group_box.setInsideMargin(KDialog.marginHint())
+
+        vbox2 = QVBox(self.driver_group_box)
+        vbox2.setSpacing(KDialog.spacingHint())
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        drivertext = QLabel(hbox,"drivertext")
+        drivertext.setText(i18n("Audio Driver:"))
+
+        self.drivercombo = KComboBox(0,hbox,"drivercombo")
+        self.fillDriverCombo(self.drivercombo)
+        self.connect(self.drivercombo,SIGNAL("activated(int)"),self.slotDriverActivated)
+
+        QToolTip.add(hbox, i18n("Choose an audio driver.  Not all audio " +\
+            "drivers are available."))
+        spacer = QWidget(hbox)
+        hbox.setStretchFactor(spacer,1)
+
+        if application:
+            self.driver_group_box.hide()
+
+        # -- DirectSound Settings group
+        self.dsound_group_box = QHGroupBox(vbox)
+        self.dsound_group_box.setTitle(i18n("DirectSound"))
+        self.dsound_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.dsound_group_box.setInsideMargin(KDialog.marginHint())
+
+        vbox2 = QVBox(self.dsound_group_box)
+        vbox2.setSpacing(KDialog.spacingHint())
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        acceltext = QLabel(hbox,"acceltext")
+        acceltext.setText(i18n("Hardware Acceleration:"))
+
+        self.accelcombo = KComboBox(0,hbox,"accelcombo")
+        self.fillAccelCombo(self.accelcombo)
+        self.connect(self.accelcombo,SIGNAL("activated(int)"),self.slotAccelActivated)
+
+        spacer = QWidget(hbox)
+        hbox.setStretchFactor(spacer,1)
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.overridecheckbox = QCheckBox(i18n("Override KDE Sample Rate"),hbox)
+        hbox.setStretchFactor(self.overridecheckbox,0)
+        self.connect(self.overridecheckbox,SIGNAL("toggled(bool)"),self.slotOverrideKDESoundToggled)
+        self.overridecheckbox.hide()
+
+        self.sampleratehbox = QHBox(vbox2)
+        self.sampleratehbox.setSpacing(KDialog.spacingHint())
+
+        sampletext = QLabel(self.sampleratehbox,"sampletext")
+        sampletext.setText(i18n("Default Sample Rate:"))
+
+        self.samplecombo = KComboBox(0,self.sampleratehbox,"samplecombo")
+        self.fillSampleCombo(self.samplecombo)
+        self.connect(self.samplecombo,SIGNAL("activated(int)"),self.slotSampleActivated)
+
+        bitstext = QLabel(self.sampleratehbox,"bitstext")
+        bitstext.setText(i18n("Default Bits Per Sample:"))
+
+        self.bitscombo = KComboBox(0,self.sampleratehbox,"bitscombo")
+        self.fillBitsCombo(self.bitscombo)
+        self.connect(self.bitscombo,SIGNAL("activated(int)"),self.slotBitsActivated)
+
+        spacer = QWidget(self.sampleratehbox)
+        self.sampleratehbox.setStretchFactor(spacer,1)
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.drvemucheckbox = QCheckBox(i18n("Driver Emulation"),hbox)
+        hbox.setStretchFactor(self.drvemucheckbox,0)
+        self.connect(self.drvemucheckbox,SIGNAL("toggled(bool)"), self.slotDriverEmulToggled)
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        audio_tab_layout.addItem(bottomspacer)
+
+        self.reset()
+
+        self.clearWState(Qt.WState_Polished)
+
+    def fillDriverCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for driver in self.drivers:
+            combo.insertItem(self.driversdic[driver])
+
+    def fillAccelCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for accel in self.accel:
+            combo.insertItem(accel[1])
+
+    def fillSampleCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for rate in self.samplerates:
+            combo.insertItem(rate[1])
+
+    def fillBitsCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for bits in self.bitspersample:
+            combo.insertItem(bits[1])
+
+    def isChanged(self):
+        changed = False
+        changed = changed or (not application and self.currentdriver != self.originaldriver)
+        changed = changed or self.currentaccel != self.originalaccel
+        changed = changed or self.currentsamplerate != self.originalsamplerate
+        changed = changed or self.currentbitspersample != self.originalbitspersample
+        changed = changed or self.currentemuldriver != self.originalemuldriver
+        return changed
+
+    def reset(self):
+        if not application:
+            self.currentdriver = wineread.GetAudioDriver()
+            self.originaldriver = self.currentdriver
+            self.__selectDriver(self.currentdriver)
+
+        dsoundsettings = wineread.GetDSoundSettings(application)
+        globaldsoundsettings = wineread.GetDSoundSettings()
+
+        self.currentaccel = dsoundsettings.get("HardwareAcceleration",\
+            globaldsoundsettings.get("HardwareAcceleration", "Full"))
+        self.originalaccel = self.currentaccel
+        self.__selectAccel(self.currentaccel)
+
+        self.currentsamplerate = dsoundsettings.get("DefaultSampleRate",\
+            globaldsoundsettings.get("DefaultSampleRate", "44100"))
+        self.originalsamplerate = self.currentsamplerate
+        self.__selectSampleRate(self.currentsamplerate)
+
+        self.currentbitspersample = dsoundsettings.get("DefaultBitsPerSample",\
+             globaldsoundsettings.get("DefaultBitsPerSample","16"))
+        self.originalbitspersample = self.currentbitspersample
+        self.__selectBitsPerSample(self.currentbitspersample)
+
+        self.currentemuldriver = dsoundsettings.get("EmulDriver",\
+            globaldsoundsettings.get("EmulDriver", "N"))
+        self.originalemuldriver = self.currentemuldriver
+        self.__setDriverEmul(self.currentemuldriver)
+
+        self.currentkdeoverride = True
+        self.originalkdeoverride = self.currentkdeoverride
+        self.__setOverrideKDESound(self.currentkdeoverride)
+
+    def applyChanges(self):
+        if not application:
+            winewrite.SetAudioDriver(self.currentdriver)
+
+        dsoundsettings = {"HardwareAcceleration":self.currentaccel,
+            "DefaultSampleRate":self.currentsamplerate,
+            "DefaultBitsPerSample":self.currentbitspersample,
+            "EmulDriver":self.currentemuldriver}
+
+        winewrite.SetDSoundSettings(dsoundsettings, application)
+
+        self.reset()
+
+    def slotDriverActivated(self,driverid):
+        self.currentdriver = self.drivers[driverid]
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotAccelActivated(self,accelid):
+        self.currentaccel = self.accel[accelid][1]
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotSampleActivated(self,sampleid):
+        self.currentsamplerate = self.samplerates[sampleid][1]
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotBitsActivated(self,bitsid):
+        self.currentbitspersample = self.bitspersample[bitsid][1]
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotDriverEmulToggled(self,driveremul):
+        if driveremul:
+            self.currentemuldriver = 'Y'
+        else:
+            self.currentemuldriver = 'N'
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotOverrideKDESoundToggled(self,override):
+        self.__setOverrideKDESound(override)
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def __selectDriver(self,drivername):
+        """
+        Sets the current driver and selects it in the combo box
+        Assumes drivername is a valid driver
+        """
+        driverid = 0
+        for driver in self.drivers:
+            if driver == drivername:
+                break
+            else:
+                driverid += 1
+
+        self.currentdriver = drivername
+        self.drivercombo.setCurrentItem(driverid)
+
+    def __selectAccel(self,accelmode):
+        """
+        Sets the current acceleration mode and selects it in the combo box
+        Assumes accelmode i sa valid acceleration mode
+        """
+        accelid = 0
+        for accelmode1 in self.accel:
+            if accelmode1[1] == accelmode:
+                break
+            else:
+                accelid += 1
+
+        self.currentaccel = accelmode
+        self.accelcombo.setCurrentItem(accelid)
+
+    def __selectSampleRate(self,samplerate):
+        """
+        Sets the current acceleration mode and selects it in the combo box
+        Assumes samplerate is a valid sample rate
+        """
+        sampleid = 0
+        for samplerate1 in self.samplerates:
+            if samplerate1[1] == samplerate:
+                break
+            else:
+                sampleid += 1
+
+        self.currentsamplerate = samplerate
+        self.samplecombo.setCurrentItem(sampleid)
+
+    def __selectBitsPerSample(self,bits):
+        """
+        Sets the current acceleration mode and selects it in the combo box
+        Assumes bits is a valid value for bits per sample
+        """
+        bitsid = 0
+        for bits1 in self.bitspersample:
+            if bits1[1] == bits:
+                break
+            else:
+                bitsid += 1
+
+        self.currentbitspersample = bits
+        self.bitscombo.setCurrentItem(bitsid)
+
+    def __setDriverEmul(self,driveremul):
+        """ Enables/disables the driver emulation mode """
+        self.currentdriveremul = driveremul
+        driveremul = driveremul != 'N'
+        self.drvemucheckbox.setChecked(driveremul)
+
+    def __setOverrideKDESound(self,override):
+        """ Enables/disables use of KDE's (aRts) sample rate settings """
+        self.currentkdeoverride = override
+        self.sampleratehbox.setEnabled(override)
+        self.overridecheckbox.setChecked(override)
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+
+############################################################################
+class GraphicsPage(QWidget):
+
+    # Mapping values in seconds to human-readable labels.
+    vertexshadersupport = (
+        (0,i18n("Hardware")),
+        (1,i18n("None")),
+        (2,i18n("Emulation")))
+
+    vertexshadersupportdic = {
+        "hardware":0,
+        "none":1,
+        "emulation":2}
+
+    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
+        global currentallowwm
+        QWidget.__init__(self,parent)
+
+        if not name:
+            self.setName("GraphicsTab")
+
+        graphics_tab_layout = QVBoxLayout(self,0,0,"GraphicsTabLayout")
+        self.top_layout = graphics_tab_layout
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        graphics_tab_layout.addWidget(vbox)
+
+        if application:
+            appwarning = QLabel(vbox,"appwarning")
+            appwarning.setText(i18n("Application specific settings for <b>" +\
+                application + "</b><p>Changing a setting here will permanently " +\
+                "make that setting independent of settings for all other " +\
+                "applications.</p>"))
+            appwarning.setFrameStyle( QFrame.Box | QFrame.Raised )
+
+        # -- Window settings group
+        self.windows_group_box = QHGroupBox(vbox)
+        self.windows_group_box.setTitle(i18n("Window Settings"))
+        self.windows_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.windows_group_box.setInsideMargin(KDialog.marginHint())
+
+        vbox2 = QVBox(self.windows_group_box)
+        vbox2.setSpacing(KDialog.spacingHint())
+
+        self.allowcursorcheckbox = QCheckBox(i18n("Allow DirectX applications to stop the mouse leaving their window"),vbox2)
+        self.connect(self.allowcursorcheckbox,SIGNAL("toggled(bool)"), self.slotAllowCursorToggled)
+
+        self.dubbuffercheckbox = QCheckBox(i18n("Enable desktop double buffering"),vbox2)
+        self.connect(self.dubbuffercheckbox,SIGNAL("toggled(bool)"), self.slotDubBufferToggled)
+
+        self.allowwmcheckbox = QCheckBox(i18n("Allow the window manager to control the windows"),vbox2)
+        self.connect(self.allowwmcheckbox,SIGNAL("toggled(bool)"), self.slotAllowWMToggled)
+
+        QToolTip.add(self.allowwmcheckbox, \
+            i18n("<p>If windows are managed by your window manager, then they" +\
+            " will have the standard borders, they will respect your virtual" +\
+            " desktop and appear in your window list.\n</p><p>" +\
+            "If the windows are unmanaged, they will be disconnected from your" +\
+            " window manager.  This will mean the windows do not integrate as" +\
+            " closely with your desktop, but the emulation will be more" +\
+            " accurate so it can help some programs work better.</p>"))
+
+        self.showdragcheckbox = QCheckBox(i18n("Display window contents while dragging"),vbox2)
+        self.connect(self.showdragcheckbox,SIGNAL("toggled(bool)"), self.slotShowDragToggled)
+
+        self.emudesktopcheckbox = QCheckBox(i18n("Emulate a virtual desktop"),vbox2)
+        self.connect(self.emudesktopcheckbox,SIGNAL("toggled(bool)"), self.slotEmuDesktopToggled)
+
+        self.desksizehbox = QHBox(vbox2)
+        self.desksizehbox.setSpacing(KDialog.spacingHint())
+
+        desksizetext = QLabel(self.desksizehbox,"desksizetext")
+        desksizetext.setText(i18n("Desktop size:"))
+
+        self.xsizeedit = KLineEdit("640",self.desksizehbox)
+        self.xsizeedit.setValidator(QIntValidator(self.xsizeedit))
+        self.connect(self.xsizeedit,SIGNAL("textChanged(const QString &)"),self.slotDesktopSizeChanged)
+        bytext = QLabel(self.desksizehbox,"bytext")
+        bytext.setText(i18n("x"))
+        self.ysizeedit = KLineEdit("480",self.desksizehbox)
+        self.ysizeedit.setValidator(QIntValidator(self.ysizeedit))
+        self.connect(self.ysizeedit,SIGNAL("textChanged(const QString &)"),self.slotDesktopSizeChanged)
+
+        spacer = QWidget(self.desksizehbox)
+        self.desksizehbox.setStretchFactor(spacer,1)
+
+        QToolTip.add(self.emudesktopcheckbox,
+            i18n("<p>You can choose to emulate a Windows desktop, where all" +\
+            " the windows are confined to one 'virtual screen', or you" +\
+            " can have the windows placed on your standard desktop.</p>"))
+        QToolTip.add(self.desksizehbox, QToolTip.textFor(self.emudesktopcheckbox))
+
+        if application:
+            self.emudesktopcheckbox.hide()
+            self.desksizehbox.hide()
+            self.showdragcheckbox.hide()
+
+        # -- Direct3D settings group
+        self.d3d_group_box = QHGroupBox(vbox)
+        self.d3d_group_box.setTitle(i18n("Direct3D"))
+        self.d3d_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.d3d_group_box.setInsideMargin(KDialog.marginHint())
+
+        vbox2 = QVBox(self.d3d_group_box)
+        vbox2.setSpacing(KDialog.spacingHint())
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        vertexshadertext = QLabel(hbox,"vertexshadertext")
+        vertexshadertext.setText(i18n("Vertex Shader Support:"))
+
+        self.accelcombo = KComboBox(0,hbox,"accelcombo")
+        self.fillCombo(self.accelcombo)
+        self.connect(self.accelcombo,SIGNAL("activated(int)"),self.slotVertexShaderModeActivated)
+
+        spacer = QWidget(hbox)
+        hbox.setStretchFactor(spacer,1)
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.pixelshadercheckbox = QCheckBox(i18n("Allow Pixel Shader (if supported by hardware)"),hbox)
+        self.connect(self.pixelshadercheckbox,SIGNAL("toggled(bool)"), self.slotPixelShaderModeToggled)
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.glslcheckbox = QCheckBox(i18n("Use GL Shader Language"),hbox)
+        self.connect(self.glslcheckbox,SIGNAL("toggled(bool)"), self.slotGLSLToggled)
+
+        QToolTip.add(hbox,
+            i18n("<p>This enables the use of GL Shading Language for vertex" +\
+                " and pixel shaders, as long as the hardware supports it." +\
+                "  This is experimental.</p>"))
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        graphics_tab_layout.addItem(bottomspacer)
+
+        self.reset()
+
+        self.clearWState(Qt.WState_Polished)
+
+    def fillCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for accel in self.vertexshadersupport:
+            combo.insertItem(accel[1])
+
+    def isChanged(self):
+        changed = False
+        changed = changed or self.originalallowcursor != self.currentallowcursor
+        changed = changed or self.originaldubbuffer != self.currentdubbuffer
+        changed = changed or self.originalallowwm != currentallowwm
+        changed = changed or (not application and \
+            self.originalemudesktop != self.currentemudesktop)
+        changed = changed or self.originalvertexshadermode != self.currentvertexshadermode
+        changed = changed or self.originalpixelshadermode != self.currentpixelshadermode
+        changed = changed or self.originalglsl != self.currentglsl
+        changed = changed or (not application and \
+            self.originalshowdrag != self.currentshowdrag)
+        return changed
+
+    def reset(self):
+        """ Resets the settings to ones read from the registry """
+        global currentallowwm
+        settings = wineread.GetWindowSettings(application)
+        globalsettings = wineread.GetWindowSettings()
+
+        self.currentallowcursor = settings.get("DXGrab",\
+            globalsettings.get("DXGrab",'N'))
+        self.originalallowcursor = self.currentallowcursor
+        self.__setAllowCursor(self.currentallowcursor)
+
+        self.currentdubbuffer = settings.get("DesktopDoubleBuffered",\
+            globalsettings.get("DesktopDoubleBuffered",'Y'))
+        self.originaldubbuffer = self.currentdubbuffer
+        self.__setDubBuffer(self.currentdubbuffer)
+
+        currentallowwm = settings.get("Managed",\
+            globalsettings.get("Managed",'Y'))
+        self.originalallowwm = currentallowwm
+
+        if not application:
+            self.currentemudesktop = settings.get("Desktop","")
+            self.originalemudesktop = self.currentemudesktop
+            self.__setEmuDesktop(self.currentemudesktop)
+        self.__setAllowWM(currentallowwm)
+
+        d3dsettings = wineread.GetD3DSettings(application)
+        globald3dsettings = wineread.GetD3DSettings()
+
+        self.currentvertexshadermode = d3dsettings.get("VertexShaderMode",\
+            globald3dsettings.get("VertexShaderMode","hardware"))
+        self.originalvertexshadermode = self.currentvertexshadermode
+        self.__selectVertexShaderMode(self.currentvertexshadermode)
+
+        self.currentpixelshadermode = d3dsettings.get("PixelShaderMode",\
+            globald3dsettings.get("PixelShaderMode","enabled"))
+        self.originalpixelshadermode = self.currentpixelshadermode
+        self.__setPixelShaderMode(self.currentpixelshadermode)
+
+        self.currentglsl = d3dsettings.get("UseGLSL",\
+            globald3dsettings.get("UseGLSL","disabled"))
+        self.originalglsl = self.currentglsl
+        self.__setGLSL(self.currentglsl)
+
+        if not application:
+            cpdesktopsettings = wineread.GetDesktopSettings()
+
+            self.currentshowdrag = cpdesktopsettings.get("DragFullWindows","0")
+            self.originalshowdrag = self.currentshowdrag
+            self.__setShowDrag(self.currentshowdrag)
+
+    def applyChanges(self):
+        """ Applies the changes to wine's configuration """
+        settings = {"DXGrab":self.currentallowcursor,
+            "DesktopDoubleBuffered":self.currentdubbuffer,
+            "Managed":currentallowwm}
+
+        if not application:
+            settings["Desktop"] = self.currentemudesktop
+
+        winewrite.SetWindowSettings(settings, application)
+
+        d3dsettings = {"VertexShaderMode":self.currentvertexshadermode,
+            "PixelShaderMode":self.currentpixelshadermode,
+            "UseGLSL":self.currentglsl}
+
+        winewrite.SetD3DSettings(d3dsettings, application)
+
+        if not application:
+            cpdesktopsettings = {"DragFullWindows":self.currentshowdrag}
+
+            winewrite.SetDesktopSettings(cpdesktopsettings)
+
+        self.reset()
+
+    def slotAllowCursorToggled(self,allow):
+        if allow:
+            self.currentallowcursor = 'Y'
+        else:
+            self.currentallowcursor = 'N'
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotDubBufferToggled(self,dub):
+        if dub:
+            self.currentdubbuffer = 'Y'
+        else:
+            self.currentdubbuffer = 'N'
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotAllowWMToggled(self,allow):
+        global currentallowwm
+        if allow:
+            currentallowwm = 'Y'
+        else:
+            currentallowwm = 'N'
+        if not application:
+            if allow and self.currentemudesktop == "":
+                self.showdragcheckbox.setEnabled(False)
+            else:
+                self.showdragcheckbox.setEnabled(True)
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotShowDragToggled(self,show):
+        if show:
+            self.currentshowdrag = '2'
+        else:
+            self.currentshowdrag = '0'
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotEmuDesktopToggled(self,emudesktop):
+        if emudesktop:
+            self.currentemudesktop = unicode(self.xsizeedit.text()) + 'x' + str(self.ysizeedit.text())
+        else:
+            self.currentemudesktop = ""
+        self.__setEmuDesktop(self.currentemudesktop)
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotDesktopSizeChanged(self,size):
+        self.slotEmuDesktopToggled(True)
+
+    def slotVertexShaderModeActivated(self,modeid):
+        mode = self.vertexshadersupport[modeid][1][0].lower() + self.vertexshadersupport[modeid][1][1:]
+        self.currentvertexshadermode = mode
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotPixelShaderModeToggled(self,mode):
+        if mode:
+            self.currentpixelshadermode = 'enabled'
+        else:
+            self.currentpixelshadermode = 'disabled'
+
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotGLSLToggled(self,mode):
+        if mode:
+            self.currentglsl = 'enabled'
+        else:
+            self.currentglsl = 'disabled'
+
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def __setAllowCursor(self, allow):
+        self.currentallowcursor = allow
+        allow = allow != 'N'
+        self.allowcursorcheckbox.setChecked(allow)
+
+    def __setDubBuffer(self, dub):
+        self.currentdubbuffer = dub
+        dub = dub != 'N'
+        self.dubbuffercheckbox.setChecked(dub)
+
+    def __setAllowWM(self, allow):
+        global currentallowwm
+        currentallowwm = allow
+        allow = allow != 'N'
+        self.allowwmcheckbox.setChecked(allow)
+        if not application:
+            if allow and self.currentemudesktop == "":
+                self.showdragcheckbox.setEnabled(False)
+            else:
+                self.showdragcheckbox.setEnabled(True)
+
+    def __setEmuDesktop(self, emudesktop):
+        self.currentemudesktop = emudesktop
+        emudesktopbool = emudesktop != ""
+        self.emudesktopcheckbox.setChecked(emudesktopbool)
+        self.desksizehbox.setEnabled(emudesktopbool)
+        if emudesktopbool:
+            desktopsize = emudesktop.split('x')
+            self.xsizeedit.setText(desktopsize[0])
+            self.ysizeedit.setText(desktopsize[1])
+            self.showdragcheckbox.setEnabled(True)
+        elif currentallowwm:
+            self.showdragcheckbox.setEnabled(False)
+
+    def __selectVertexShaderMode(self,mode):
+        self.currentvertexshadermode = mode
+        self.accelcombo.setCurrentItem(self.vertexshadersupportdic[mode])
+
+    def __setPixelShaderMode(self,mode):
+        self.currentpixelshadermode = mode
+        mode = mode == 'enabled'
+        self.pixelshadercheckbox.setChecked(mode)
+
+    def __setGLSL(self,mode):
+        self.currentglsl = mode
+        mode = mode == 'enabled'
+        self.glslcheckbox.setChecked(mode)
+
+    def __setShowDrag(self,show):
+        self.currentshowdrag = show
+        show = show != '0'
+        self.showdragcheckbox.setChecked(show)
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+
+############################################################################
+class AppearancePage(QWidget):
+
+    themes = [unicode(i18n("No Theme"))]
+    colorschemes = [unicode(i18n("Custom"))]
+    sizes = [("NormalSize",unicode(i18n("Normal"))),
+        ("LargeSize",unicode(i18n("Large Fonts"))),
+        ("ExtraLargeSize",unicode(i18n("Extra Large Fonts")))]
+
+    # Items for the combo box reference a tuple of dictionaries for color
+    # and size values and translations for that item
+    # For example, the value of BorderWidth is
+    #  customizableitems[str(i18n("Window Border"))][1]["BorderWidth"][1]
+    customizableitems = {"Window Border":
+            ({"ActiveBorder":[unicode(i18n("Active Color:")),QColor()],
+              "InactiveBorder":[unicode(i18n("Inactive Color:")),QColor()]},
+             {"BorderWidth":[unicode(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
+        "Title Bar":
+            ({"ActiveTitle":[unicode(i18n("Active Color:")),QColor()],
+              "GradientActiveTitle":[unicode(i18n("Gradient:")),QColor()],
+              "InactiveTitle":[unicode(i18n("Inactive Color:")),QColor()],
+              "GradientInactiveTitle":[unicode(i18n("Gradient:")),QColor()],
+              "TitleText":[unicode(i18n("Active Text:")),QColor()],
+              "InactiveTitleText":[unicode(i18n("Inactive Text:")),QColor()]},
+             {}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
+        "Application Workspace":
+            ({"AppWorkSpace":[unicode(i18n("Background Color:")),QColor()]},
+             {}), #AppWorkSpace "Background"
+        "Buttons":
+            ({"ButtonFace":[unicode(i18n("Face:")),QColor()],
+              "ButtonHilight":[unicode(i18n("Hilight:")),QColor()],
+              "ButtonLight":[unicode(i18n("Light:")),QColor()],
+              "ButtonShadow":[unicode(i18n("Shadow:")),QColor()],
+              "ButtonText":[unicode(i18n("Text Color:")),QColor()],
+              "ButtonAlternateFace":[unicode(i18n("Alternate Face:")),QColor()],
+              "ButtonDkShadow":[unicode(i18n("Dark Shadow:")),QColor()],
+              "WindowFrame":[unicode(i18n("Frame:")),QColor()]},
+             {}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
+        "Caption Buttons":
+            ({},
+             {"CaptionHeight":[unicode(i18n("Height:")),1],
+              "CaptionWidth":[unicode(i18n("Width:")),1]}), #Metrics: CaptionHeight, CaptionWidth
+        "Desktop":
+            ({"Background":[unicode(i18n("Background:")),QColor()]},
+             {}), #Background
+        "Menu":
+            ({"Menu":[unicode(i18n("Menu Background:")),QColor()],
+              "MenuBar":[unicode(i18n("Menu Bar Color:")),QColor()],
+              "MenuHilight":[unicode(i18n("Menu Hilight:")),QColor()],
+              "MenuText":[unicode(i18n("Text Color:")),QColor()]},
+             {"MenuHeight":[unicode(i18n("Menu Bar Height:")),1]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
+        "Scrollbar":
+            ({"Scrollbar":[unicode(i18n("Color:")),QColor()]},
+             {"ScrollWidth":[unicode(i18n("Width:")),1]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
+        "Window":
+            ({"Window":[unicode(i18n("Background:")),QColor()],
+              "WindowText":[unicode(i18n("Text Color:")),QColor()]},
+             {}), #Window "Background", WindowText
+        "Selected Items":
+            ({"Hilight":[unicode(i18n("Hilight Color:")),QColor()],
+              "HilightText":[unicode(i18n("Text Color:")),QColor()]},
+             {})} #Hilight, HilightText
+
+    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
+        global imagedir
+        QWidget.__init__(self,parent)
+
+        if not name:
+            self.setName("AppearanceTab")
+
+        appearance_tab_layout = QVBoxLayout(self,0,0,"AppearanceTabLayout")
+        self.top_layout = appearance_tab_layout
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        appearance_tab_layout.addWidget(vbox)
+
+        # -- Appearance group
+        self.appearance_group_box = QVGroupBox(vbox)
+        self.appearance_group_box.setTitle(i18n("Style and Colors"))
+        self.appearance_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.appearance_group_box.setInsideMargin(KDialog.marginHint())
+
+        themebox = QWidget(self.appearance_group_box)
+
+        theme_layout = QGridLayout(themebox,3,3)
+        theme_layout.setSpacing(KDialog.spacingHint())
+        theme_layout.setColStretch(1,1)
+
+        styletext = QLabel(themebox,"styletext")
+        styletext.setText(i18n("Widget Style:"))
+        theme_layout.addWidget(styletext,0,0)
+
+        self.themes = self.themes + wineread.GetThemesList()
+        self.themecombo = KComboBox(0,themebox,"themecombo")
+        self.fillThemeCombo(self.themecombo)
+        self.connect(self.themecombo,SIGNAL("activated(int)"),self.slotThemeActivated)
+        theme_layout.addWidget(self.themecombo,0,1)
+
+        self.installbutton = KPushButton(i18n("Install style..."),themebox)
+        self.connect(self.installbutton,SIGNAL("clicked()"),self.slotInstallThemeClicked)
+        theme_layout.addWidget(self.installbutton,0,2)
+
+        fontsizetext = QLabel(themebox,"fontsizetext")
+        fontsizetext.setText(i18n("Font Size:"))
+        theme_layout.addWidget(fontsizetext,1,0)
+
+        self.fontsizecombo = KComboBox(0,themebox,"fontsizecombo")
+        self.fillFontSizeCombo(self.fontsizecombo)
+        self.connect(self.fontsizecombo,SIGNAL("activated(int)"),self.slotFontSizeActivated)
+        theme_layout.addWidget(self.fontsizecombo,1,1)
+
+        colorschemetext = QLabel(themebox,"colorschemetext")
+        colorschemetext.setText(i18n("Color Scheme:"))
+        theme_layout.addWidget(colorschemetext,2,0)
+
+        self.colorschemecombo = KComboBox(0,themebox,"colorschemecombo")
+        self.fillColorSchemeCombo(self.colorschemecombo)
+        self.connect(self.colorschemecombo,SIGNAL("activated(int)"),self.slotColorSchemeActivated)
+        theme_layout.addWidget(self.colorschemecombo,2,1)
+
+        self.saveschemebutton = KPushButton(i18n("Save..."),themebox)
+        self.connect(self.saveschemebutton,SIGNAL("clicked()"),self.slotSaveSchemeClicked)
+        theme_layout.addWidget(self.saveschemebutton,2,2)
+
+        # --- Custom Colors ---
+        hbox = QHBox(self.appearance_group_box)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.sizehbox = hbox
+        self.leftspacer = QWidget(hbox)
+
+        self.customcolorsvbox = QVBox(hbox)
+        self.customcolorsvbox.setSpacing(KDialog.spacingHint())
+
+        hbox = QHBox(self.customcolorsvbox)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        itemtext = QLabel(hbox,"itemtext")
+        itemtext.setText(i18n("Item:"))
+
+        self.itemcombo = KComboBox(0,hbox,"itemcombo")
+        self.fillItemCombo(self.itemcombo)
+        self.connect(self.itemcombo,SIGNAL("activated(int)"),self.slotItemActivated)
+        hbox.setStretchFactor(self.itemcombo,1)
+
+        self.customcolorsgrid = QWidget(self.customcolorsvbox)
+        self.customcolorsgrid_layout = QGridLayout(self.customcolorsgrid,4,2)
+        self.customcolorsgrid_layout.setSpacing(KDialog.spacingHint())
+
+        # Box 1 of 8
+        self.colorsizehbox1 = QWidget(self.customcolorsgrid,"colorsizehbox1")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox1,0,0)
+        self.colorsizehbox1_layout = QGridLayout(self.colorsizehbox1,1,2)
+        self.colorsizehbox1_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext1 = QLabel(self.colorsizehbox1,"colorsizetext1")
+        self.colorsizetext1.setText(i18n(":"))
+        self.colorsizehbox1_layout.addWidget(self.colorsizetext1,0,0,Qt.AlignRight)
+
+        self.sizespinbox1 = QSpinBox(self.colorsizehbox1,"sizespinbox1")
+        self.sizespinbox1.setMinValue(0)
+        self.connect(self.sizespinbox1,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo1 = KColorCombo(self.colorsizehbox1,"colorcombo1")
+        self.connect(self.colorcombo1,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        # Box 2 of 8
+        self.colorsizehbox2 = QWidget(self.customcolorsgrid,"colorsizehbox2")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox2,0,1)
+        self.colorsizehbox2_layout = QGridLayout(self.colorsizehbox2,1,2)
+        self.colorsizehbox2_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext2 = QLabel(self.colorsizehbox2,"colorsizetext2")
+        self.colorsizetext2.setText(i18n(":"))
+        self.colorsizehbox2_layout.addWidget(self.colorsizetext2,0,0,Qt.AlignRight)
+
+        self.sizespinbox2 = QSpinBox(self.colorsizehbox2,"sizespinbox2")
+        self.sizespinbox2.setMinValue(0)
+        self.connect(self.sizespinbox2,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo2 = KColorCombo(self.colorsizehbox2,"colorcombo2")
+        self.connect(self.colorcombo2,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        # Box 3 of 8
+        self.colorsizehbox3 = QWidget(self.customcolorsgrid,"colorsizehbox3")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox3,1,0)
+        self.colorsizehbox3_layout = QGridLayout(self.colorsizehbox3,1,2)
+        self.colorsizehbox3_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext3 = QLabel(self.colorsizehbox3,"colorsizetext3")
+        self.colorsizetext3.setText(i18n(":"))
+        self.colorsizehbox3_layout.addWidget(self.colorsizetext3,0,0,Qt.AlignRight)
+
+        self.sizespinbox3 = QSpinBox(self.colorsizehbox3,"sizespinbox3")
+        self.sizespinbox3.setMinValue(0)
+        self.connect(self.sizespinbox3,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo3 = KColorCombo(self.colorsizehbox3,"colorcombo3")
+        self.connect(self.colorcombo3,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        # Box 4 of 8
+        self.colorsizehbox4 = QWidget(self.customcolorsgrid,"colorsizehbox4")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox4,1,1)
+        self.colorsizehbox4_layout = QGridLayout(self.colorsizehbox4,1,2)
+        self.colorsizehbox4_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext4 = QLabel(self.colorsizehbox4,"colorsizetext4")
+        self.colorsizetext4.setText(i18n(":"))
+        self.colorsizehbox4_layout.addWidget(self.colorsizetext4,0,0,Qt.AlignRight)
+
+        self.sizespinbox4 = QSpinBox(self.colorsizehbox4,"sizespinbox4")
+        self.sizespinbox4.setMinValue(0)
+        self.connect(self.sizespinbox4,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo4 = KColorCombo(self.colorsizehbox4,"colorcombo4")
+        self.connect(self.colorcombo4,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        # Box 5 of 8
+        self.colorsizehbox5 = QWidget(self.customcolorsgrid,"colorsizehbox5")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox5,2,0)
+        self.colorsizehbox5_layout = QGridLayout(self.colorsizehbox5,1,2)
+        self.colorsizehbox5_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext5 = QLabel(self.colorsizehbox5,"colorsizetext5")
+        self.colorsizetext5.setText(i18n(":"))
+        self.colorsizehbox5_layout.addWidget(self.colorsizetext5,0,0,Qt.AlignRight)
+
+        self.sizespinbox5 = QSpinBox(self.colorsizehbox5,"sizespinbox5")
+        self.sizespinbox5.setMinValue(0)
+        self.connect(self.sizespinbox5,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo5 = KColorCombo(self.colorsizehbox5,"colorcombo5")
+        self.connect(self.colorcombo5,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        # Box 6 of 8
+        self.colorsizehbox6 = QWidget(self.customcolorsgrid,"colorsizehbox6")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox6,2,1)
+        self.colorsizehbox6_layout = QGridLayout(self.colorsizehbox6,1,2)
+        self.colorsizehbox6_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext6 = QLabel(self.colorsizehbox6,"colorsizetext6")
+        self.colorsizetext6.setText(i18n(":"))
+        self.colorsizehbox6_layout.addWidget(self.colorsizetext6,0,0,Qt.AlignRight)
+
+        self.sizespinbox6 = QSpinBox(self.colorsizehbox6,"sizespinbox6")
+        self.sizespinbox6.setMinValue(0)
+        self.connect(self.sizespinbox6,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo6 = KColorCombo(self.colorsizehbox6,"colorcombo6")
+        self.connect(self.colorcombo6,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        # Box 7 of 8
+        self.colorsizehbox7 = QWidget(self.customcolorsgrid,"colorsizehbox7")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox7,3,0)
+        self.colorsizehbox7_layout = QGridLayout(self.colorsizehbox7,1,2)
+        self.colorsizehbox7_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext7 = QLabel(self.colorsizehbox7,"colorsizetext7")
+        self.colorsizetext7.setText(i18n(":"))
+        self.colorsizehbox7_layout.addWidget(self.colorsizetext7,0,0,Qt.AlignRight)
+
+        self.sizespinbox7 = QSpinBox(self.colorsizehbox7,"sizespinbox7")
+        self.sizespinbox7.setMinValue(0)
+        self.connect(self.sizespinbox7,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo7 = KColorCombo(self.colorsizehbox7,"colorcombo7")
+        self.connect(self.colorcombo7,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        # Box 8 of 8
+        self.colorsizehbox8 = QWidget(self.customcolorsgrid,"colorsizehbox8")
+        self.customcolorsgrid_layout.addWidget(self.colorsizehbox8,3,1)
+        self.colorsizehbox8_layout = QGridLayout(self.colorsizehbox8,1,2)
+        self.colorsizehbox8_layout.setSpacing(KDialog.spacingHint())
+
+        self.colorsizetext8 = QLabel(self.colorsizehbox8,"colorsizetext8")
+        self.colorsizetext8.setText(i18n(":"))
+        self.colorsizehbox8_layout.addWidget(self.colorsizetext8,0,0,Qt.AlignRight)
+
+        self.sizespinbox8 = QSpinBox(self.colorsizehbox8,"sizespinbox8")
+        self.sizespinbox8.setMinValue(0)
+        self.connect(self.sizespinbox8,SIGNAL("valueChanged(int)"),self.slotSizeActivated)
+
+        self.colorcombo8 = KColorCombo(self.colorsizehbox8,"colorcombo8")
+        self.connect(self.colorcombo8,SIGNAL("activated(const QColor &)"),self.slotColorActivated)
+
+        spacer = QWidget(self.customcolorsvbox)
+        self.customcolorsvbox.setStretchFactor(spacer,1)
+        self.customcolorsvbox.setMinimumHeight(itemtext.height()*4.5)
+        #self.customcolorsvbox.setStretchFactor(self.customcolorsgrid,1)
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        appearance_tab_layout.addItem(bottomspacer)
+
+        self.selecteditem = None
+        self.config = KConfig("wineconfigrc",False,False)
+        self.reset()
+
+        self.clearWState(Qt.WState_Polished)
+
+    def isChanged(self):
+        changed = False
+        changed = changed or self.currenttheme != self.originaltheme\
+            or self.currentthemecolorscheme != self.originalthemecolorscheme\
+            or self.currentfontsize != self.originalfontsize\
+            or self.customizableItemsChanged()
+        return changed
+
+    def customizableItemsChanged(self):
+        """ Returns true if any custom setting was changed """
+        colors = wineread.GetColorSettings()
+        metrics = wineread.GetWindowMetrics()
+
+        changed = False
+        custom = False  # For a little efficiency
+        for item in self.customizableitems.keys():
+            for key in self.customizableitems[item][0].keys():
+                color = colors.get(key,"0 0 0")
+                color = color.split()
+                color = QColor(int(color[0]),int(color[1]),int(color[2]))
+                if not custom and self.customizableitems[item][0][key][1] !=\
+                    self.config.readColorEntry(key,QColor(0,0,0)):
+                    self.__selectColorScheme(0)
+                    custom = True
+                if self.customizableitems[item][0][key][1] != color:
+                    if custom:
+                        return True
+                    else:
+                        changed = True
+            for key in self.customizableitems[item][1].keys():
+                size = int(metrics.get(key,1))
+                if not custom and self.customizableitems[item][1][key][1] !=\
+                    self.config.readNumEntry(key,1):
+                    self.__selectColorScheme(0)
+                    custom = True
+                if self.customizableitems[item][1][key][1] != size:
+                    if custom:
+                        return True
+                    else:
+                        changed = True
+        return changed
+
+    def reset(self):
+        self.fillItemCombo(self.itemcombo)
+        self.config.setGroup("")
+        self.currentcustomcolorscheme = unicode(self.config.readEntry("ColorScheme",i18n("Custom")))
+        self.originalcustomcolorscheme = self.currentcustomcolorscheme
+        schemeslist = self.config.readListEntry("ColorSchemes")
+        self.colorschemes = [unicode(i18n("Custom")),
+            unicode(i18n("Get KDE Colors"))] + list(schemeslist)
+        self.config.setGroup(self.currentcustomcolorscheme)
+
+        for preset in self.presets:
+            if preset[0] not in schemeslist:
+                self.saveColorScheme(preset[0],preset[1])
+                self.colorschemes.append(preset[0])
+
+        self.fillColorSchemeCombo(self.colorschemecombo)
+
+        theme = wineread.GetCurrentTheme()
+        if not theme:
+            self.currenttheme = self.themes[0]
+            self.originaltheme = self.currenttheme
+            self.__selectTheme(0)
+
+            self.currentthemecolorscheme = "NormalColor"
+            self.originalthemecolorscheme = self.currentthemecolorscheme
+
+            self.currentfontsize = self.sizes[0][0]
+            self.originalfontsize = self.currentfontsize
+            for i,sizename in enumerate(self.sizes):
+                if sizename[0] == self.currentfontsize:
+                    self.__selectFontSize(i)
+                    break
+        else:
+            self.currenttheme = theme[0]
+            self.originaltheme = self.currenttheme
+            for i,themename in enumerate(self.themes):
+                if themename == self.currenttheme:
+                    self.__selectTheme(i)
+                    break
+            self.currentthemecolorscheme = theme[1]
+            self.originalthemecolorscheme = self.currentthemecolorscheme
+
+            self.currentfontsize = theme[2]
+            self.originalfontsize = self.currentfontsize
+            for i,sizename in enumerate(self.sizes):
+                if sizename[0] == self.currentfontsize:
+                    self.__selectFontSize(i)
+                    break
+
+        colors = wineread.GetColorSettings()
+        metrics = wineread.GetWindowMetrics()
+
+        for item in self.customizableitems.keys():
+            for key in self.customizableitems[item][0].keys():
+                color = colors.get(key,"0 0 0")
+                color = color.split()
+                color = QColor(int(color[0]),int(color[1]),int(color[2]))
+                if color != self.config.readColorEntry(key,QColor(0,0,0)):
+                    self.currentcustomcolorscheme = self.colorschemes[0]
+                self.customizableitems[item][0][key][1] = color
+            for key in self.customizableitems[item][1].keys():
+                size = int(metrics.get(key,1))
+                if size != self.config.readNumEntry(key,1):
+                    self.currentcustomcolorscheme = self.colorschemes[0]
+                self.customizableitems[item][1][key][1] = size
+
+        for i,colorname in enumerate(self.colorschemes):
+            if colorname == self.currentcustomcolorscheme:
+                self.__selectColorScheme(i)
+                break
+
+        self.desktopsettings = wineread.GetDesktopSettings()
+
+    def applyChanges(self):
+        """ Applies the changes to wine's configuration """
+        if self.currenttheme == self.themes[0]:
+            winewrite.SetCurrentTheme(None)
+        else:
+            winewrite.SetCurrentTheme((self.currenttheme,
+                self.currentthemecolorscheme,
+                self.currentfontsize))
+
+        colorsettings = {}
+        metricssettings = {}
+        for item in self.customizableitems.keys():
+            for key in self.customizableitems[item][0].keys():
+                color = self.customizableitems[item][0][key][1]
+                color = str(color.red()) + " " + str(color.green()) +\
+                    " " + str(color.blue())
+                colorsettings[key] = color
+            for key in self.customizableitems[item][1].keys():
+                size = self.customizableitems[item][1][key][1]
+
+                metricssettings[key] = str(size)
+
+        winewrite.SetColorSettings(colorsettings)
+        winewrite.SetWindowMetrics(metricssettings)
+
+        self.config.setGroup("")
+        if self.currentcustomcolorscheme == self.colorschemes[1]:
+            self.currentcustomcolorscheme = self.colorschemes[0]
+        self.config.writeEntry("ColorScheme",self.currentcustomcolorscheme)
+        self.config.sync()
+
+        if self.customizableitems["Title Bar"][0]["ActiveTitle"][1]\
+            !=\
+            self.customizableitems["Title Bar"][0]["GradientActiveTitle"][1]\
+            or\
+            self.customizableitems["Title Bar"][0]["InactiveTitle"][1]\
+            !=\
+            self.customizableitems["Title Bar"][0]["GradientInactiveTitle"][1]:
+            prefmask = self.desktopsettings["UserPreferencemask"]
+            prefmask = prefmask[:4] + "1" + prefmask[5:]
+            self.desktopsettings["UserPreferencemask"] = prefmask
+        else:
+            prefmask = self.desktopsettings["UserPreferencemask"]
+            prefmask = prefmask[:4] + "0" + prefmask[5:]
+            self.desktopsettings["UserPreferencemask"] = prefmask
+
+        winewrite.SetDesktopSettings(self.desktopsettings)
+
+        self.reset()
+
+    def fillThemeCombo(self,combo):
+        """ Fill the combo box with the list of themes """
+        for theme in self.themes:
+            combo.insertItem(theme)
+
+    def fillColorSchemeCombo(self,combo):
+        """ Fill the combo box with the list of color schemes """
+        combo.clear()
+        for color in self.colorschemes:
+            combo.insertItem(color)
+
+    def fillFontSizeCombo(self,combo):
+        """ Fill the combo box with the list of font sizes """
+        for size in self.sizes:
+            combo.insertItem(size[1])
+
+    def slotFillItemCombo(self,allowwm):
+        """
+        Fill the combo box with the list of customizable items
+        Called when window managing is changed
+        """
+        combo = self.itemcombo
+        combo.clear()
+        items = self.customizableitems.keys()
+        items.sort()
+        for item in items:
+            if not (allowwm and (item == "Window Border" \
+                or item == "Title Bar" or \
+                item == "Caption Buttons")):
+                combo.insertItem(unicode(i18n(item)))
+
+    def slotFillItemComboDesktop(self,desktop):
+        """
+        Fill the combo box with the list of customizable items
+        Called when virtual desktop is changed
+        """
+        self.slotFillItemCombo(not desktop)
+
+    def fillItemCombo(self,combo = None):
+        """ Fill the combo box with the list of customizable items """
+        if not combo:
+            combo = self.itemcombo
+        combo.clear()
+        items = self.customizableitems.keys()
+        items.sort()
+        self.currentitems = []
+        for item in items:
+            if not (currentallowwm == 'Y' and (item == "Window Border" \
+                or item == "Title Bar" or \
+                item == "Caption Buttons")):
+                combo.insertItem(unicode(i18n(item)))
+                self.currentitems.append(item)
+
+    def slotThemeActivated(self,themeid):
+        """ Picks an already installed theme """
+        self.__selectTheme(themeid)
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotInstallThemeClicked(self):
+        """ Opens up a dialog to install a new theme """
+        themepath = unicode(KFileDialog.getOpenFileName(os.environ['HOME'],\
+            "*.msstyles|" + str(i18n("Windows Styles (*.msstyles)")),self,i18n("Install Style")))
+        if themepath:
+            themename = themepath.split('/')
+            themename = themename[-1]
+            themename = themename.split('.')
+            themename = themename[0]
+            themedir = wineread.winepath +\
+                "/dosdevices/c:/windows/Resources/Themes/" +\
+                themename
+            if not os.path.exists(themedir):
+                os.mkdir(themedir)
+            shutil.copy(themepath, themedir)
+            self.themes.append(str(i18n(themename)))
+            self.themecombo.insertItem(self.themes[-1])
+            self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotSaveSchemeClicked(self):
+        """ Lets the user save the current color scheme """
+        schemename = KInputDialog.getText(i18n("Save Color Scheme"),\
+            i18n("Name: "),\
+            i18n("CustomScheme"),\
+            self,"schemenameinput")
+
+        while schemename[1] and schemename[0] == "" or \
+            schemename[0] == self.colorschemes[0] or \
+            schemename[0] == self.colorschemes[1]:
+            KMessageBox.information(self, \
+                i18n("Please enter a unique name for the color scheme."), \
+                i18n("Save Color Scheme"))
+            schemename = KInputDialog.getText(i18n("Save Color Scheme"),\
+                i18n("Name: "),\
+                i18n("CustomScheme"),\
+                self,"schemenameinput")
+
+        if schemename[1]:
+            schemename = str(schemename[0])
+            self.saveColorScheme(schemename)
+            if schemename not in self.colorschemes:
+                self.colorschemes.append(schemename)
+                self.colorschemecombo.insertItem(schemename)
+            for i,colorname in enumerate(self.colorschemes):
+                if colorname == schemename:
+                    self.__selectColorScheme(i)
+                    break
+
+    def saveColorScheme(self,name,schemesettings = None):
+        """ Saves the colorscheme """
+        if not schemesettings:
+            schemesettings = self.customizableitems
+        self.config.setGroup("")
+        if name != self.colorschemes[1]:
+            self.config.writeEntry("ColorScheme",name)
+        schemeslist = self.config.readListEntry("ColorSchemes")
+        if name not in schemeslist and name != self.colorschemes[0] and \
+            name != self.colorschemes[1]:
+            schemeslist.append(name)
+        self.config.writeEntry("ColorSchemes",schemeslist)
+        self.config.setGroup(name)
+        for item in self.customizableitems.keys():
+            for key in schemesettings[item][0].keys():
+                self.config.writeEntry(key,schemesettings[item][0][key][1])
+            for key in schemesettings[item][1].keys():
+                self.config.writeEntry(key,schemesettings[item][1][key][1])
+        self.config.sync()
+
+    def GetKdeColorScheme(self):
+        """ Sets the current color scheme settings to those currently set in KDE """
+        # Create a configuration object.
+        config = KConfig("kdesktoprc")
+
+        config.setGroup("General")
+        self.customizableitems["Application Workspace"][0]["AppWorkSpace"][1] =\
+            config.readColorEntry("background",QColor(100,100,100))
+        self.customizableitems["Buttons"][0]["ButtonFace"][1] =\
+            config.readColorEntry("background",QColor(230,230,230))
+        self.customizableitems["Buttons"][0]["ButtonHilight"][1] =\
+            config.readColorEntry("windowBackground",QColor(240,240,240))
+        self.customizableitems["Buttons"][0]["ButtonLight"][1] =\
+            config.readColorEntry("selectBackground",QColor(200,200,200)).light(135)
+        self.customizableitems["Buttons"][0]["ButtonShadow"][1] =\
+            config.readColorEntry("background",QColor(100,100,100)).dark(180)
+        self.customizableitems["Buttons"][0]["ButtonText"][1] =\
+            config.readColorEntry("buttonForeground",QColor(0,0,0))
+        self.customizableitems["Buttons"][0]["ButtonAlternateFace"][1] =\
+            config.readColorEntry("background",QColor(230,230,230))
+        self.customizableitems["Buttons"][0]["ButtonDkShadow"][1] =\
+            config.readColorEntry("selectBackground",QColor(0,0,0)).dark(146)
+        self.customizableitems["Buttons"][0]["WindowFrame"][1] =\
+            config.readColorEntry("selectBackground",QColor(0,0,0))
+        self.customizableitems["Menu"][0]["Menu"][1] =\
+            config.readColorEntry("background",QColor(230,230,230)).light(105)
+        self.customizableitems["Menu"][0]["MenuBar"][1] =\
+            config.readColorEntry("background",QColor(230,230,230))
+        self.customizableitems["Menu"][0]["MenuHilight"][1] =\
+            config.readColorEntry("selectBackground",QColor(0,0,0))
+        self.customizableitems["Menu"][0]["MenuText"][1] =\
+            config.readColorEntry("foreground",QColor(0,0,0))
+        self.customizableitems["Scrollbar"][0]["Scrollbar"][1] =\
+            config.readColorEntry("background",QColor(230,230,230))
+        self.customizableitems["Window"][0]["Window"][1] =\
+            config.readColorEntry("windowBackground",QColor(255,255,255))
+        self.customizableitems["Window"][0]["WindowText"][1] =\
+            config.readColorEntry("foreground",QColor(0,0,0))
+        self.customizableitems["Selected Items"][0]["Hilight"][1] =\
+            config.readColorEntry("selectBackground",QColor(0,0,0))
+        self.customizableitems["Selected Items"][0]["HilightText"][1] =\
+            config.readColorEntry("selectForeground",QColor(255,255,255))
+
+        config.setGroup("WM")
+        self.customizableitems["Title Bar"][0]["ActiveTitle"][1] =\
+            config.readColorEntry("activeBackground",QColor(10,10,100))
+        self.customizableitems["Title Bar"][0]["GradientActiveTitle"][1] =\
+            config.readColorEntry("activeBlend",QColor(10,10,200)).light(110)
+        self.customizableitems["Title Bar"][0]["InactiveTitle"][1] =\
+            config.readColorEntry("inactiveBackground",QColor(100,100,100))
+        self.customizableitems["Title Bar"][0]["GradientInactiveTitle"][1] =\
+            config.readColorEntry("inactiveBlend",QColor(100,100,200))
+        self.customizableitems["Title Bar"][0]["TitleText"][1] =\
+            config.readColorEntry("activeForeground",QColor(255,255,255))
+        self.customizableitems["Title Bar"][0]["InactiveTitleText"][1] =\
+            config.readColorEntry("inactiveForeground",QColor(250,250,250))
+        self.customizableitems["Window Border"][0]["ActiveBorder"][1] =\
+            config.readColorEntry("frame",QColor(10,10,100))
+        self.customizableitems["Window Border"][0]["InactiveBorder"][1] =\
+            config.readColorEntry("frame",QColor(100,100,200))
+
+        config.setGroup("Desktop0")
+        self.customizableitems["Desktop"][0]["Background"][1] =\
+            config.readColorEntry("Color1",QColor(50,150,85))
+
+        self.saveColorScheme(self.colorschemes[1])
+
+    def slotColorSchemeActivated(self,colorid):
+        """ Picks a color scheme """
+        self.__selectColorScheme(colorid)
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotFontSizeActivated(self,fontid):
+        """ Picks a font size """
+        self.__selectFontSize(fontid)
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotItemActivated(self,itemid):
+        """ Picks an item to customize """
+        items = self.customizableitems.keys()
+        items.sort()
+        for i,item in enumerate(self.currentitems):
+            if i == itemid:
+                if item != self.selecteditem:
+                    self.__selectItem(item)
+
+    def slotColorActivated(self,color):
+        """ Picks a color for the currently selected item """
+        key = self.sender().name()
+        self.customizableitems[self.selecteditem][0][key][1] = color
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotSizeActivated(self,sizevalue):
+        """ Sets the size value from the spin box """
+        key = self.sender().name()
+        self.customizableitems[self.selecteditem][1][key][1] = sizevalue
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def __selectTheme(self,themeid):
+        """ Selects the browser in the combobox """
+        self.currenttheme = self.themes[themeid]
+
+        self.themecombo.setCurrentItem(themeid)
+
+        #if themeid == 0:
+        #    self.colorfontbox.setEnabled(False)
+        #else:
+        #    self.colorfontbox.setEnabled(True)
+
+    def __selectColorScheme(self,colorid):
+        """ Selects a color scheme in the combo box """
+        self.currentcustomcolorscheme = self.colorschemes[colorid]
+
+        self.colorschemecombo.setCurrentItem(colorid)
+
+        if colorid > 1:
+            self.config.setGroup("")
+            self.config.writeEntry("ColorScheme",self.colorschemes[colorid])
+            self.config.setGroup(self.colorschemes[colorid])
+            for item in self.customizableitems.keys():
+                for key in self.customizableitems[item][0].keys():
+                    color = self.config.readColorEntry(key,QColor(0,0,0))
+                    self.customizableitems[item][0][key][1] = color
+                for key in self.customizableitems[item][1].keys():
+                    size = self.config.readNumEntry(key,1)
+                    self.customizableitems[item][1][key][1] = size
+        elif colorid == 1:
+            self.GetKdeColorScheme()
+
+        if not self.selecteditem:
+            self.__selectItem("Desktop")
+        else:
+            self.__selectItem(self.selecteditem)
+
+    def __selectColorSchemeByName(self,name):
+        """ Finds the index of name in colorschemes and calls the above function """
+        for i,colorname in enumerate(self.colorschemes):
+            if colorname == name:
+                self.__selectColorScheme(i)
+                break
+
+    def __selectFontSize(self,sizeid):
+        """ Selects a font size in the combo box """
+        self.currentfontsize = self.sizes[sizeid][0]
+
+        self.fontsizecombo.setCurrentItem(sizeid)
+
+    def __selectItem(self,item):
+        """ Sets the color and size settings boxes to those for item """
+        self.selecteditem = item
+
+        for i,item1 in enumerate(self.currentitems):
+            if item1 == item:
+                self.itemcombo.setCurrentItem(i)
+
+        if item == "Application Workspace":
+            key = "AppWorkSpace"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            self.colorsizehbox2.hide()
+            self.colorsizehbox3.hide()
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Buttons":
+            key = "ButtonFace"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            key = "WindowFrame"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox2.hide()
+            self.colorsizehbox2_layout.remove(self.sizespinbox2)
+            self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
+            self.colorcombo2.show()
+            self.colorcombo2.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo2.setName(key)
+
+            key = "ButtonShadow"
+            self.colorsizehbox3.show()
+            self.colorsizetext3.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox3.hide()
+            self.colorsizehbox3_layout.remove(self.sizespinbox3)
+            self.colorsizehbox3_layout.addWidget(self.colorcombo3,0,1)
+            self.colorcombo3.show()
+            self.colorcombo3.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo3.setName(key)
+
+            key = "ButtonDkShadow"
+            self.colorsizehbox4.show()
+            self.colorsizetext4.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox4.hide()
+            self.colorsizehbox4_layout.remove(self.sizespinbox4)
+            self.colorsizehbox4_layout.addWidget(self.colorcombo4,0,1)
+            self.colorcombo4.show()
+            self.colorcombo4.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo4.setName(key)
+
+            key = "ButtonLight"
+            self.colorsizehbox5.show()
+            self.colorsizetext5.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox5.hide()
+            self.colorsizehbox5_layout.remove(self.sizespinbox5)
+            self.colorsizehbox5_layout.addWidget(self.colorcombo5,0,1)
+            self.colorcombo5.show()
+            self.colorcombo5.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo5.setName(key)
+
+            key = "ButtonHilight"
+            self.colorsizehbox6.show()
+            self.colorsizetext6.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox6.hide()
+            self.colorsizehbox6_layout.remove(self.sizespinbox6)
+            self.colorsizehbox6_layout.addWidget(self.colorcombo6,0,1)
+            self.colorcombo6.show()
+            self.colorcombo6.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo6.setName(key)
+
+            key = "ButtonAlternateFace"
+            self.colorsizehbox7.show()
+            self.colorsizetext7.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox7.hide()
+            self.colorsizehbox7_layout.remove(self.sizespinbox7)
+            self.colorsizehbox7_layout.addWidget(self.colorcombo7,0,1)
+            self.colorcombo7.show()
+            self.colorcombo7.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo7.setName(key)
+
+            key = "ButtonText"
+            self.colorsizehbox8.show()
+            self.colorsizetext8.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox8.hide()
+            self.colorsizehbox8_layout.remove(self.sizespinbox8)
+            self.colorsizehbox8_layout.addWidget(self.colorcombo8,0,1)
+            self.colorcombo8.show()
+            self.colorcombo8.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo8.setName(key)
+        elif item == "Caption Buttons":
+            key = "CaptionHeight"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][1][key][0])
+            self.colorcombo1.hide()
+            self.colorsizehbox1_layout.remove(self.colorcombo1)
+            self.colorsizehbox1_layout.addWidget(self.sizespinbox1,0,1)
+            self.sizespinbox1.show()
+            self.sizespinbox1.setName(key)
+            self.sizespinbox1.setValue(\
+                self.customizableitems[item][1][key][1])
+            self.sizespinbox1.setMinValue(8)
+            self.sizespinbox1.setMaxValue(100)
+
+            key = "CaptionWidth"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][1][key][0])
+            self.colorcombo2.hide()
+            self.colorsizehbox2_layout.remove(self.colorcombo2)
+            self.colorsizehbox2_layout.addWidget(self.sizespinbox2,0,1)
+            self.sizespinbox2.show()
+            self.sizespinbox2.setName(key)
+            self.sizespinbox2.setValue(\
+                self.customizableitems[item][1][key][1])
+            self.sizespinbox2.setMinValue(8)
+            self.sizespinbox2.setMaxValue(100)
+
+            self.colorsizehbox3.hide()
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Desktop":
+            key = "Background"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            self.colorsizehbox2.hide()
+            self.colorsizehbox3.hide()
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Menu":
+            key = "Menu"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            key = "MenuBar"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox2.hide()
+            self.colorsizehbox2_layout.remove(self.sizespinbox2)
+            self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
+            self.colorcombo2.show()
+            self.colorcombo2.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo2.setName(key)
+
+            key = "MenuHilight"
+            self.colorsizehbox3.show()
+            self.colorsizetext3.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox3.hide()
+            self.colorsizehbox3_layout.remove(self.sizespinbox3)
+            self.colorsizehbox3_layout.addWidget(self.colorcombo3,0,1)
+            self.colorcombo3.show()
+            self.colorcombo3.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo3.setName(key)
+
+            key = "MenuText"
+            self.colorsizehbox4.show()
+            self.colorsizetext4.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox4.hide()
+            self.colorsizehbox4_layout.remove(self.sizespinbox4)
+            self.colorsizehbox4_layout.addWidget(self.colorcombo4,0,1)
+            self.colorcombo4.show()
+            self.colorcombo4.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo4.setName(key)
+
+            key = "MenuHeight"
+            self.colorsizehbox5.show()
+            self.colorsizetext5.setText(\
+                self.customizableitems[item][1][key][0])
+            self.colorcombo5.hide()
+            self.colorsizehbox5_layout.remove(self.colorcombo5)
+            self.colorsizehbox5_layout.addWidget(self.sizespinbox5,0,1)
+            self.sizespinbox5.show()
+            self.sizespinbox5.setName(key)
+            self.sizespinbox5.setValue(\
+                self.customizableitems[item][1][key][1])
+            self.sizespinbox5.setMinValue(15)
+            self.sizespinbox5.setMaxValue(100)
+
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Scrollbar":
+            key = "Scrollbar"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            key = "ScrollWidth"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][1][key][0])
+            self.colorcombo2.hide()
+            self.colorsizehbox2_layout.remove(self.colorcombo2)
+            self.colorsizehbox2_layout.addWidget(self.sizespinbox2,0,1)
+            self.sizespinbox2.show()
+            self.sizespinbox2.setName(key)
+            self.sizespinbox2.setValue(\
+                self.customizableitems[item][1][key][1])
+            self.sizespinbox2.setMinValue(8)
+            self.sizespinbox2.setMaxValue(100)
+
+            self.colorsizehbox3.hide()
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Selected Items":
+            key = "Hilight"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            key = "HilightText"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox2.hide()
+            self.colorsizehbox2_layout.remove(self.sizespinbox2)
+            self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
+            self.colorcombo2.show()
+            self.colorcombo2.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo2.setName(key)
+
+            self.colorsizehbox3.hide()
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Title Bar":
+            key = "ActiveTitle"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            key = "GradientActiveTitle"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox2.hide()
+            self.colorsizehbox2_layout.remove(self.sizespinbox2)
+            self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
+            self.colorcombo2.show()
+            self.colorcombo2.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo2.setName(key)
+
+            key = "InactiveTitle"
+            self.colorsizehbox3.show()
+            self.colorsizetext3.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox3.hide()
+            self.colorsizehbox3_layout.remove(self.sizespinbox3)
+            self.colorsizehbox3_layout.addWidget(self.colorcombo3,0,1)
+            self.colorcombo3.show()
+            self.colorcombo3.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo3.setName(key)
+
+            key = "GradientInactiveTitle"
+            self.colorsizehbox4.show()
+            self.colorsizetext4.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox4.hide()
+            self.colorsizehbox4_layout.remove(self.sizespinbox4)
+            self.colorsizehbox4_layout.addWidget(self.colorcombo4,0,1)
+            self.colorcombo4.show()
+            self.colorcombo4.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo4.setName(key)
+
+            key = "TitleText"
+            self.colorsizehbox5.show()
+            self.colorsizetext5.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox5.hide()
+            self.colorsizehbox5_layout.remove(self.sizespinbox5)
+            self.colorsizehbox5_layout.addWidget(self.colorcombo5,0,1)
+            self.colorcombo5.show()
+            self.colorcombo5.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo5.setName(key)
+
+            key = "InactiveTitleText"
+            self.colorsizehbox6.show()
+            self.colorsizetext6.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox6.hide()
+            self.colorsizehbox6_layout.remove(self.sizespinbox6)
+            self.colorsizehbox6_layout.addWidget(self.colorcombo6,0,1)
+            self.colorcombo6.show()
+            self.colorcombo6.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo6.setName(key)
+
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Window":
+            key = "Window"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            key = "WindowText"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox2.hide()
+            self.colorsizehbox2_layout.remove(self.sizespinbox2)
+            self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
+            self.colorcombo2.show()
+            self.colorcombo2.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo2.setName(key)
+
+            self.colorsizehbox3.hide()
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        elif item == "Window Border":
+            key = "ActiveBorder"
+            self.colorsizehbox1.show()
+            self.colorsizetext1.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox1.hide()
+            self.colorsizehbox1_layout.remove(self.sizespinbox1)
+            self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
+            self.colorcombo1.show()
+            self.colorcombo1.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo1.setName(key)
+
+            key = "InactiveBorder"
+            self.colorsizehbox2.show()
+            self.colorsizetext2.setText(\
+                self.customizableitems[item][0][key][0])
+            self.sizespinbox2.hide()
+            self.colorsizehbox2_layout.remove(self.sizespinbox2)
+            self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
+            self.colorcombo2.show()
+            self.colorcombo2.setColor(\
+                self.customizableitems[item][0][key][1])
+            self.colorcombo2.setName(key)
+
+            key = "BorderWidth"
+            self.colorsizehbox3.show()
+            self.colorsizetext3.setText(\
+                self.customizableitems[item][1][key][0])
+            self.colorcombo3.hide()
+            self.colorsizehbox3_layout.remove(self.colorcombo3)
+            self.colorsizehbox3_layout.addWidget(self.sizespinbox3,0,1)
+            self.sizespinbox3.show()
+            self.sizespinbox3.setName(key)
+            self.sizespinbox3.setValue(\
+                self.customizableitems[item][1][key][1])
+            self.sizespinbox3.setMinValue(1)
+            self.sizespinbox3.setMaxValue(50)
+
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+        else:
+            # Shouldn't happen.
+            self.colorsizehbox1.hide()
+            self.colorsizehbox2.hide()
+            self.colorsizehbox3.hide()
+            self.colorsizehbox4.hide()
+            self.colorsizehbox5.hide()
+            self.colorsizehbox6.hide()
+            self.colorsizehbox7.hide()
+            self.colorsizehbox8.hide()
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+    # --- Some default color schemes, with names ---
+    preset1 = (unicode(i18n("Purple")),
+       {"Window Border":
+            ({"ActiveBorder":[unicode(i18n("Active Color:")),QColor(239,239,239)],
+              "InactiveBorder":[unicode(i18n("Inactive Color:")),QColor(239,239,239)]},
+             {"BorderWidth":[unicode(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
+        "Title Bar":
+            ({"ActiveTitle":[unicode(i18n("Active Color:")),QColor(91,86,168)],
+              "GradientActiveTitle":[unicode(i18n("Gradient:")),QColor(136,118,202)],
+              "InactiveTitle":[unicode(i18n("Inactive Color:")),QColor(223,225,230)],
+              "GradientInactiveTitle":[unicode(i18n("Gradient:")),QColor(157,170,186)],
+              "TitleText":[unicode(i18n("Active Text:")),QColor(255,255,255)],
+              "InactiveTitleText":[unicode(i18n("Inactive Text:")),QColor(168,168,168)]},
+             {}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
+        "Application Workspace":
+            ({"AppWorkSpace":[unicode(i18n("Background Color:")),QColor(90,90,90)]},
+             {}), #AppWorkSpace "Background"
+        "Buttons":
+            ({"ButtonFace":[unicode(i18n("Face:")),QColor(238,239,242)],
+              "ButtonHilight":[unicode(i18n("Hilight:")),QColor(255,255,255)],
+              "ButtonLight":[unicode(i18n("Light:")),QColor(201,199,255)],
+              "ButtonShadow":[unicode(i18n("Shadow:")),QColor(132,132,134)],
+              "ButtonText":[unicode(i18n("Text Color:")),QColor(0,0,0)],
+              "ButtonAlternateFace":[unicode(i18n("Alternate Face:")),QColor(238,239,242)],
+              "ButtonDkShadow":[unicode(i18n("Dark Shadow:")),QColor(98,96,143)],
+              "WindowFrame":[unicode(i18n("Frame:")),QColor(144,140,209)]},
+             {}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
+        "Caption Buttons":
+            ({},
+             {"CaptionHeight":[unicode(i18n("Height:")),22],
+              "CaptionWidth":[unicode(i18n("Width:")),22]}), #Metrics: CaptionHeight, CaptionWidth
+        "Desktop":
+            ({"Background":[unicode(i18n("Background:")),QColor(146,127,188)]},
+             {}), #Background
+        "Menu":
+            ({"Menu":[unicode(i18n("Menu Background:")),QColor(250,251,254)],
+              "MenuBar":[unicode(i18n("Menu Bar Color:")),QColor(238,239,242)],
+              "MenuHilight":[unicode(i18n("Menu Hilight:")),QColor(144,140,209)],
+              "MenuText":[unicode(i18n("Text Color:")),QColor(0,0,0)]},
+             {"MenuHeight":[unicode(i18n("Menu Bar Height:")),22]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
+        "Scrollbar":
+            ({"Scrollbar":[unicode(i18n("Color:")),QColor(238,239,242)]},
+             {"ScrollWidth":[unicode(i18n("Width:")),16]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
+        "Window":
+            ({"Window":[unicode(i18n("Background:")),QColor(255,255,255)],
+              "WindowText":[unicode(i18n("Text Color:")),QColor(0,0,0)]},
+             {}), #Window "Background", WindowText
+        "Selected Items":
+            ({"Hilight":[unicode(i18n("Hilight Color:")),QColor(144,140,209)],
+              "HilightText":[unicode(i18n("Text Color:")),QColor(255,255,255)]},
+             {})}) #Hilight, HilightText
+
+    preset2 = (unicode(i18n("Blue")),
+       {"Window Border":
+            ({"ActiveBorder":[unicode(i18n("Active Color:")),QColor(239,239,239)],
+              "InactiveBorder":[unicode(i18n("Inactive Color:")),QColor(239,239,239)]},
+             {"BorderWidth":[unicode(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
+        "Title Bar":
+            ({"ActiveTitle":[unicode(i18n("Active Color:")),QColor(0,113,201)],
+              "GradientActiveTitle":[unicode(i18n("Gradient:")),QColor(87,161,219)],
+              "InactiveTitle":[unicode(i18n("Inactive Color:")),QColor(191,191,191)],
+              "GradientInactiveTitle":[unicode(i18n("Gradient:")),QColor(171,171,171)],
+              "TitleText":[unicode(i18n("Active Text:")),QColor(255,255,255)],
+              "InactiveTitleText":[unicode(i18n("Inactive Text:")),QColor(95,95,95)]},
+             {}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
+        "Application Workspace":
+            ({"AppWorkSpace":[unicode(i18n("Background Color:")),QColor(90,90,90)]},
+             {}), #AppWorkSpace "Background"
+        "Buttons":
+            ({"ButtonFace":[unicode(i18n("Face:")),QColor(239,239,239)],
+              "ButtonHilight":[unicode(i18n("Hilight:")),QColor(246,246,246)],
+              "ButtonLight":[unicode(i18n("Light:")),QColor(191,207,251)],
+              "ButtonShadow":[unicode(i18n("Shadow:")),QColor(148,148,153)],
+              "ButtonText":[unicode(i18n("Text Color:")),QColor(0,0,0)],
+              "ButtonAlternateFace":[unicode(i18n("Alternate Face:")),QColor(238,239,242)],
+              "ButtonDkShadow":[unicode(i18n("Dark Shadow:")),QColor(50,101,146)],
+              "WindowFrame":[unicode(i18n("Frame:")),QColor(74,149,214)]},
+             {}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
+        "Caption Buttons":
+            ({},
+             {"CaptionHeight":[unicode(i18n("Height:")),22],
+              "CaptionWidth":[unicode(i18n("Width:")),22]}), #Metrics: CaptionHeight, CaptionWidth
+        "Desktop":
+            ({"Background":[unicode(i18n("Background:")),QColor(44,109,189)]},
+             {}), #Background
+        "Menu":
+            ({"Menu":[unicode(i18n("Menu Background:")),QColor(249,249,249)],
+              "MenuBar":[unicode(i18n("Menu Bar Color:")),QColor(239,239,239)],
+              "MenuHilight":[unicode(i18n("Menu Hilight:")),QColor(74,149,214)],
+              "MenuText":[unicode(i18n("Text Color:")),QColor(0,0,0)]},
+             {"MenuHeight":[unicode(i18n("Menu Bar Height:")),22]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
+        "Scrollbar":
+            ({"Scrollbar":[unicode(i18n("Color:")),QColor(230,230,230)]},
+             {"ScrollWidth":[unicode(i18n("Width:")),16]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
+        "Window":
+            ({"Window":[unicode(i18n("Background:")),QColor(255,255,255)],
+              "WindowText":[unicode(i18n("Text Color:")),QColor(0,0,0)]},
+             {}), #Window "Background", WindowText
+        "Selected Items":
+            ({"Hilight":[unicode(i18n("Hilight Color:")),QColor(74,149,214)],
+              "HilightText":[unicode(i18n("Text Color:")),QColor(255,255,255)]},
+             {})}) #Hilight, HilightText
+    presets = [preset1,preset2]
+
+############################################################################
+class GeneralPage(QWidget):
+
+    winversions = wineread.winversions
+
+    verdic = {
+        "win2003":0,
+        "winxp":1,
+        "win2k":2,
+        "winme":3,
+        "win98":4,
+        "win95":5,
+        "nt40":6,
+        "nt351":7,
+        "win31":8,
+        "win30":9,
+        "win20":10}
+
+    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
+        global application
+        QWidget.__init__(self,parent)
+
+        if not name:
+            self.setName("GeneralTab")
+
+        general_tab_layout = QVBoxLayout(self,0,0,"GeneralTabLayout")
+        self.top_layout = general_tab_layout
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        general_tab_layout.addWidget(vbox)
+
+        if application:
+            appwarning = QLabel(vbox,"appwarning")
+            appwarning.setText(i18n("Application specific settings for <b>" +\
+                application + "</b><p>Changing a setting here will permanently " +\
+                "make that setting independent of settings for all other " +\
+                "applications.</p>"))
+            appwarning.setFrameStyle( QFrame.Box | QFrame.Raised )
+            self.winversions = self.winversions + (( "global",\
+                unicode(i18n("Use Global Setting")),   0,  0, 0, "", "", 0, 0, ""),)
+            self.verdic["global"]=11
+
+        hbox = QHBox(vbox)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        versiontext = QLabel(hbox,"versiontext")
+        versiontext.setText(i18n("Windows version:"))
+
+        self.versioncombo = KComboBox(0,hbox,"versioncombo")
+        self.fillVersionCombo(self.versioncombo)
+        self.connect(self.versioncombo,SIGNAL("activated(int)"),self.slotVersionActivated)
+
+        spacer = QWidget(hbox)
+        hbox.setStretchFactor(spacer,1)
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        general_tab_layout.addItem(bottomspacer)
+
+        self.reset()
+
+        self.clearWState(Qt.WState_Polished)
+
+    def isChanged(self):
+        changed = False
+        changed = changed or self.currentwinverid != self.originalwinverid
+        return changed
+
+    def reset(self):
+        settings = wineread.GetGeneralWineSettings(application)
+
+        if application:
+            self.currentwinverid = self.verdic[settings.get("Version","global")]
+        else:
+            self.currentwinverid = self.verdic[settings.get("Version","winxp")]
+        self.originalwinverid = self.currentwinverid
+        self.__selectWinVer(self.currentwinverid)
+
+    def applyChanges(self):
+        """ Applies the changes to wine's configuration """
+        winewrite.SetWinVersion(self.winversions[self.currentwinverid], application)
+
+        self.reset()
+
+    def fillVersionCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for version in self.winversions:
+            combo.insertItem(version[1])
+
+    def slotVersionActivated(self,verid):
+        self.currentwinverid = verid
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def __selectWinVer(self,verid):
+        """
+        Sets the current Windows version and selects it in the combo box
+        """
+        self.versioncombo.setCurrentItem(verid)
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+
+############################################################################
+class ApplicationsPage(QWidget):
+
+    applications = []
+
+    browsers = []
+    mailers = []
+
+    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
+        QWidget.__init__(self,parent)
+
+        if not name:
+            self.setName("ApplicationsTab")
+
+        applications_tab_layout = QVBoxLayout(self,0,0,"ApplicationsTabLayout")
+        self.top_layout = applications_tab_layout
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        applications_tab_layout.addWidget(vbox)
+
+        # -- Application Specific Settings group --
+        self.perapp_group_box = QHGroupBox(vbox)
+        self.perapp_group_box.setTitle(i18n("Application specific settings"))
+        self.perapp_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.perapp_group_box.setInsideMargin(KDialog.marginHint())
+
+        vbox2 = QVBox(self.perapp_group_box)
+        vbox2.setSpacing(KDialog.spacingHint())
+
+        applicationstext = QLabel(vbox2,"applicationstext")
+        applicationstext.setText(i18n("Change application specific settings for:"))
+
+        self.appslist = KListBox(vbox2)
+        self.connect(self.appslist, SIGNAL("selectionChanged(QListBoxItem *)"), self.slotListClicked)
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.addbutton = KPushButton(i18n("Add Application..."),hbox)
+        self.connect(self.addbutton,SIGNAL("clicked()"),self.slotAddClicked)
+
+        self.removebutton = KPushButton(i18n("Remove..."),hbox)
+        self.connect(self.removebutton,SIGNAL("clicked()"),self.slotRemoveClicked)
+
+        spacer = QWidget(hbox)
+        hbox.setStretchFactor(spacer,1)
+
+        self.settingsbutton = KPushButton(i18n("Settings"),hbox)
+        self.connect(self.settingsbutton,SIGNAL("clicked()"),self.slotSettingsClicked)
+
+        # -- Native Applications Settings group --
+        # Removed pending a patch to winebrowser
+        #self.nativeapp_group_box = QVGroupBox(vbox)
+        #self.nativeapp_group_box.setTitle(i18n("Native applications"))
+        #self.nativeapp_group_box.setInsideSpacing(KDialog.spacingHint())
+        #self.nativeapp_group_box.setInsideMargin(KDialog.marginHint())
+
+        #vbox3 = QWidget(self.nativeapp_group_box)
+
+        #native_apps_layout = QGridLayout(vbox3,2,3)
+        #native_apps_layout.setSpacing(KDialog.spacingHint())
+
+        #browsertext = QLabel(vbox3,"browsertext")
+        #browsertext.setText(i18n("Web Browser:"))
+        #native_apps_layout.addWidget(browsertext,0,0)
+
+        #self.browsercombo = KComboBox(0,vbox3,"browsercombo")
+        #self.browsercombo.setEditable(False)
+        #self.connect(self.browsercombo,SIGNAL("activated(int)"),self.slotBrowserActivated)
+        #native_apps_layout.addWidget(self.browsercombo,0,1)
+        #native_apps_layout.setColStretch(1,1)
+
+        #QToolTip.add(self.browsercombo,
+            #i18n("<p>Select the browser to be launched when clicking on a link" +\
+            #" in a Windows application.</p>"))
+
+        #self.browserbutton = KPushButton(i18n("..."),vbox3)
+        #self.connect(self.browserbutton,SIGNAL("clicked()"),self.slotBrowserClicked)
+        #native_apps_layout.addWidget(self.browserbutton,0,2)
+
+        #mailertext = QLabel(vbox3,"mailertext")
+        #mailertext.setText(i18n("Mail Client:"))
+        #native_apps_layout.addWidget(mailertext,1,0)
+
+        #self.mailercombo = KComboBox(0,vbox3,"mailercombo")
+        #self.connect(self.mailercombo,SIGNAL("activated(int)"),self.slotMailerActivated)
+        #native_apps_layout.addWidget(self.mailercombo,1,1)
+
+        #QToolTip.add(self.mailercombo,
+            #i18n("<p>Select the mail client to be launched when clicking on" +\
+            #" a mailto link in a Windows application.</p>"))
+
+        #self.mailerbutton = KPushButton(i18n("..."),vbox3)
+        #self.connect(self.mailerbutton,SIGNAL("clicked()"),self.slotMailerClicked)
+        #native_apps_layout.addWidget(self.mailerbutton,1,2)
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        applications_tab_layout.addItem(bottomspacer)
+
+        self.changed = False
+
+        # Removed pending a patch to winebrowser
+        #browsers = wineread.GetNativeBrowserList()
+        #if "kfmclient exec" not in browsers:
+            #browsers.append("kfmclient exec")
+        #self.currentbrowser = wineread.GetBrowser()
+        #self.browsers = self.createBrowserList(browsers,[self.currentbrowser])
+        #self.fillCombo(self.browsercombo,self.browsers)
+
+        #mailers = wineread.GetNativeMailerList()
+        #if "kfmclient exec" not in mailers:
+            #mailers.append("kfmclient exec")
+        #self.currentmailer = wineread.GetMailer()
+        #self.mailers = self.createMailerList(mailers,[self.currentmailer])
+        #self.fillCombo(self.mailercombo,self.mailers)
+
+        self.reset()
+
+        self.clearWState(Qt.WState_Polished)
+
+    def isChanged(self):
+        changed = False
+        changed = changed or self.applications != self.originalapplications
+        #changed = changed or self.currentbrowser != self.originalbrowser
+        #changed = changed or self.currentmailer != self.originalmailer
+        return changed
+
+    def reset(self):
+        self.applications = wineread.GetApps()
+        self.originalapplications = self.applications[:]
+        self.updateAppsList()
+
+        # Removed pending a patch to winebrowser
+        #self.currentbrowser = wineread.GetBrowser()
+        #self.__selectBrowser(self.currentbrowser)
+        #self.originalbrowser = self.currentbrowser
+
+        #self.currentmailer = wineread.GetMailer()
+        #self.__selectMailer(self.currentmailer)
+        #self.originalmailer = self.currentmailer
+
+    def applyChanges(self):
+        """ Applies the changes to wine's configuration """
+        if self.applications != self.originalapplications:
+            winewrite.SetApps(self.applications)
+        # Removed pending a patch to winebrowser
+        #if self.currentbrowser != self.originalbrowser:
+            #winewrite.SetDefaultBrowser(self.currentbrowser)
+        #if self.currentmailer != self.originalmailer:
+            #winewrite.SetDefaultMailer(self.currentmailer)
+        self.reset()
+
+    def createBrowserList(self,native,wine):
+        """
+        Takes a list of native browsers and a list wine browsers
+        and creates a list of the commands with descriptions
+        """
+
+        browsers = []
+
+        for browser in native:
+            browserwords = browser.split()
+            if browserwords and browserwords[0] == "kfmclient":
+                browserkfmcmd = browser.split(' ')
+                if len(browserkfmcmd) > 2 and \
+                    browserkfmcmd[1] == 'openProfile':
+                    browsertr = "Konqueror " + browserkfmcmd[2] +\
+                        str(i18n(" profile (Native)"))
+                elif len(browserkfmcmd) > 1 and \
+                    browserkfmcmd[1] == 'exec':
+                    browsertr = str(i18n("Use KDE Default"))
+                else:
+                    browsertr = str(i18n("Konqueror (Native)"))
+            else:
+                browsertr = browser.capitalize() + str(i18n(" (Native)"))
+            browsers.append((browser,browsertr))
+        for browser in wine:
+            if browser and browser[1] == ':':
+                browser = browser.lower()
+                browsertr = browser[browser.rfind('\\\\')+2:browser.rfind('.exe')]
+                browsertr = browsertr.capitalize() + str(i18n(" (Windows, set by application)"))
+            else:   # winebrowser
+                continue
+            browsers.append((browser,browsertr))
+
+        return browsers
+
+    def createMailerList(self,native,wine):
+        """
+        Takes a list of native mailers and a list wine mailers
+        and creates a list of the commands with descriptions
+        """
+
+        mailers = []
+
+        for mailer in native:
+            mailerwords = mailer.split()
+            if mailerwords and mailerwords[0] == "kfmclient":
+                mailerkfmcmd = mailer.split(' ')
+                if len(mailerkfmcmd) > 1 and \
+                    mailerkfmcmd[1] == 'exec':
+                    mailertr = str(i18n("Use KDE Default"))
+                else:
+                    mailertr = str(i18n("KDE (Native)"))
+            else:
+                mailertr = mailer.capitalize() + unicode(i18n(" (Native)"))
+            mailers.append((mailer,mailertr))
+        for mailer in wine:
+            if mailer and mailer[1] == ':':
+                mailer = mailer.lower()
+                mailertr = mailer[mailer.rfind('\\\\')+2:mailer.rfind('.exe')]
+                mailertr = mailertr.capitalize() + unicode(i18n(" (Windows, set by application)"))
+            else:   # winebrowser
+                continue
+            mailers.append((mailer,mailertr))
+
+        return mailers
+
+    def slotListClicked(self,item):
+        """ Called when an application in the list is clicked """
+        for appid,appname in enumerate(self.applications):
+            if appname==item.text():
+                self.__selectApp(appid)
+                return
+
+    def slotAddClicked(self):
+        """
+        Let the user choose a new application to change settings for
+        """
+        app = KFileDialog.getOpenFileName(wineread.winepath + \
+            "/dosdevices/c:",\
+            "*.exe|" + unicode(i18n("Windows Executables (*.exe)")),self,i18n("Application"))
+        if app:
+            app = str(app).split('/')
+            app = app[-1]
+            self.applications.append(app)
+            self.updateAppsList()
+            for appid,appname in enumerate(self.applications):
+                if appname==app:
+                    self.__selectApp(appid)
+            self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotRemoveClicked(self):
+        """ Removes settings for selected application """
+        if KMessageBox.warningContinueCancel(self, \
+                i18n("This will remove all application specific settings for \n" +\
+                    self.applications[self.selectedappid] +"\n" +\
+                    "Do you want to proceed?"),\
+                i18n("Warning")) == KMessageBox.Continue:
+            del self.applications[self.selectedappid]
+            self.updateAppsList()
+            self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotSettingsClicked(self):
+        """ 
+        Launches a new wineconfig window for the selected application
+        """
+        os.system("wineconfig " + self.applications[self.selectedappid])
+
+    def slotBrowserEdited(self,browser):
+        """ Sets the first browser to use to the one selected in the combo box """
+        self.currentbrowser = str(browser).strip()
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotBrowserActivated(self,browserid):
+        """ Sets the first browser to use to the one selected in the combo box """
+        self.currentbrowser = self.browsers[browserid][0]
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotBrowserClicked(self):
+        """ Sets the first browser to use to the one selected in the combo box """
+        browserdlg = KOpenWithDlg(self)
+        browserdlg.hideNoCloseOnExit()
+        browserdlg.hideRunInTerminal()
+        if browserdlg.exec_loop():#i18n("Choose a Web Browser"),self.currentbrowser)
+            self.__selectBrowser(str(browserdlg.text()))
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotMailerEdited(self,mailer):
+        """ Sets the first mailer to use to the one selected in the combo box """
+        self.currentmailer = str(mailer).strip()
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotMailerActivated(self,mailerid):
+        """ Sets the first browser to use to the one selected in the combo box """
+        self.currentmailer = self.mailers[mailerid][0]
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotMailerClicked(self):
+        """ Sets the first mailer to use to the one selected in the combo box """
+        mailerdlg = KOpenWithDlg(self)
+        mailerdlg.hideNoCloseOnExit()
+        mailerdlg.hideRunInTerminal()
+        if mailerdlg.exec_loop():#i18n("Choose a Web Browser"),self.currentbrowser)
+            self.__selectMailer(str(mailerdlg.text()))
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def fillCombo(self,combo,_list):
+        """ Fill the combobox with the values from our list
+        Uses the second value from each tuple """
+        for item in _list:
+            combo.insertItem(item[1])
+
+    def updateAppsList(self):
+        """ Updates the displayed list of applications """
+        self.appslist.clear()
+
+        self.applications.sort()
+
+        self.appslist.insertStringList(QStringList.fromStrList(self.applications))
+
+        self.__selectApp(None)
+
+    def __selectBrowser(self,browsercommand):
+        """ Selects the browser in the combobox """
+        self.currentbrowser = browsercommand
+
+        for i,browser in enumerate(self.browsers):
+            if browser[0].lower() == browsercommand.lower():
+                self.browsercombo.setCurrentItem(i)
+                break
+        else:
+            browserwords = browsercommand.split()
+            #if len(browserwords) > 1 and browserwords[0] != "kfmclient":
+            #    browsercommand = browserwords[0]
+            self.browsers = self.browsers +\
+                self.createBrowserList([browsercommand],[])
+            self.browsercombo.insertItem(self.browsers[-1][1])
+            self.__selectBrowser(browsercommand)
+
+    def __selectMailer(self,mailercommand):
+        """ Selects the mailer in the combobox """
+        self.currentmailer = mailercommand
+
+        for i,mailer in enumerate(self.mailers):
+            if mailer[0] == mailercommand:
+                self.mailercombo.setCurrentItem(i)
+                break
+        else:
+            mailerwords = mailercommand.split()
+            #if len(mailerwords) > 1 and mailerwords[0] != "kfmclient":
+            #    mailercommand = mailerwords[0]
+            self.mailers = self.mailers +\
+                self.createBrowserList([mailercommand],[])
+            self.mailercombo.insertItem(self.mailers[-1][1])
+            self.__selectMailer(mailercommand)
+
+    def __selectApp(self,appid):
+        """ Selects the application """
+        if appid or appid == 0:
+            self.selectedappid = appid
+            self.appslist.setCurrentItem(appid)
+            self.removebutton.setEnabled(True)
+            self.settingsbutton.setEnabled(True)
+        else:
+            self.selectedappid = None
+            self.removebutton.setEnabled(False)
+            self.settingsbutton.setEnabled(False)
+
+    def GetKdeDefaultBrowser(self):
+        """ Returns the default browser set in KDE """
+        # Create a configuration object.
+        config = KConfig("wineconfigrc")
+        return str(config.lookupData(KEntryKey("General","BrowserApplication")).mValue).strip('!')
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+
+############################################################################
+class LibrariesPage(QWidget):
+
+    dlls = [""]
+    overriddendlls = {}
+
+    orderoptions = ("builtin","native","builtin,native","native,builtin","")
+    orderoptionstr = [
+        unicode(i18n("Built-in (Wine)")),
+        unicode(i18n("Native (Windows)")),
+        unicode(i18n("Built-in then Native")),
+        unicode(i18n("Native then Built-in")),
+        unicode(i18n("Disable"))]
+
+    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
+        QWidget.__init__(self,parent)
+
+        if not name:
+            self.setName("LibrariesTab")
+
+        libraries_tab_layout = QVBoxLayout(self,0,0,"LibrariesTabLayout")
+        self.top_layout = libraries_tab_layout
+
+        vbox = QVBox(self)
+        vbox.setSpacing(KDialog.spacingHint())
+
+        libraries_tab_layout.addWidget(vbox)
+
+        # -- DLL overrides group
+        self.overrides_group_box = QHGroupBox(vbox)
+        self.overrides_group_box.setTitle(i18n("DLL Overrides"))
+        self.overrides_group_box.setInsideSpacing(KDialog.spacingHint())
+        self.overrides_group_box.setInsideMargin(KDialog.marginHint())
+
+        vbox2 = QVBox(self.overrides_group_box)
+        vbox2.setSpacing(KDialog.spacingHint())
+
+        spacer = QWidget(vbox2)
+        vbox2.setStretchFactor(spacer,1)
+
+        newtext = QLabel(vbox2,"newtext")
+        newtext.setText(i18n("New override for library:"))
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.dllcombo = KComboBox(0,hbox,"dllcombo")
+        self.dllcombo.setEditable(True)
+        hbox.setStretchFactor(self.dllcombo,3)
+        self.connect(self.dllcombo,SIGNAL("activated(int)"),self.slotDllComboActivated)
+
+        QToolTip.add(self.dllcombo,
+            i18n("<p>Dynamic Link Libraries can be specified individually to" +\
+            " be either builtin (provided by Wine) or native (taken from" +\
+            " Windows or provided by the application).</p>"))
+        self.addbutton = KPushButton(i18n("Add"),hbox)
+        hbox.setStretchFactor(self.addbutton,1)
+        self.connect(self.addbutton,SIGNAL("clicked()"),self.slotAddClicked)
+
+        existingtext = QLabel(vbox2,"existingtext")
+        existingtext.setText(i18n("Existing overrides:"))
+
+        hbox = QHBox(vbox2)
+        hbox.setSpacing(KDialog.spacingHint())
+
+        self.dllslist = KListView(hbox)
+        self.dllslist.addColumn(i18n("Library"))
+        self.dllslist.addColumn(i18n("Load Order"))
+        self.dllslist.setAllColumnsShowFocus(True)
+        self.dllslist.setSelectionMode(QListView.Single)
+        self.dllslist.setSorting(-1,True)
+        hbox.setStretchFactor(self.dllslist,3)
+
+        self.connect(self.dllslist, SIGNAL("selectionChanged(QListViewItem *)"), self.slotListClicked)
+
+        vbox3 = QVBox(hbox)
+        vbox3.setSpacing(KDialog.spacingHint())
+        hbox.setStretchFactor(vbox3,1)
+
+        self.editbutton = KPushButton(i18n("Edit"),vbox3)
+        self.connect(self.editbutton,SIGNAL("clicked()"),self.slotEditClicked)
+        self.editbutton.setEnabled(False)
+
+        self.removebutton = KPushButton(i18n("Remove"),vbox3)
+        self.connect(self.removebutton,SIGNAL("clicked()"),self.slotRemoveClicked)
+        self.removebutton.setEnabled(False)
+
+        spacer = QWidget(vbox3)
+        vbox3.setStretchFactor(spacer,1)
+
+        bottomspacer = QSpacerItem(51,160,QSizePolicy.Minimum,QSizePolicy.Expanding)
+        libraries_tab_layout.addItem(bottomspacer)
+
+        self.changed = False
+
+        self.reset()
+
+        self.clearWState(Qt.WState_Polished)
+
+    def isChanged(self):
+        changed = False
+        changed = changed or self.overriddendlls != self.originaloverriddendlls
+        return changed
+
+    def reset(self):
+        self.dlls = wineread.GetDllsList()
+        self.fillCombo(self.dllcombo)
+
+        self.overriddendlls = wineread.GetDllOverrides(application)
+        self.originaloverriddendlls = self.overriddendlls.copy()
+        self.selecteddll = None
+        self.updateDllOverridesList()
+
+    def applyChanges(self):
+        """ Applies the changes to wine's configuration """
+        winewrite.SetDllOverrides(self.overriddendlls,application)
+        self.reset()
+
+    def slotListClicked(self,item):
+        """ Called when an application in the list is clicked """
+        self.__selectOverriddenDll(item.text(0))
+
+    def slotAddClicked(self):
+        """
+        Adds the selected library to the overrides list
+        """
+        dll = self.dllcombo.currentText()
+        if dll:
+            self.overriddendlls[str(dll)]="native,builtin"
+            self.updateDllOverridesList()
+            self.__selectOverriddenDll(dll)
+            self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotRemoveClicked(self):
+        """ Removes override for selected library """
+        del self.overriddendlls[str(self.selecteddll)]
+        self.updateDllOverridesList()
+        self.__selectOverriddenDll(None)
+        self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotEditClicked(self):
+        """ 
+        Gives a choice for the load order for the library
+        """
+        if self.selecteddll:
+            order = KInputDialog.getItem(i18n("Edit Library Override"),\
+                unicode(i18n("Load order for %s:")) % (unicode(self.selecteddll),),
+                QStringList.fromStrList(self.orderoptionstr),\
+                False,0,self,"editdll")
+
+            if order[1]:
+                self.overriddendlls[str(self.selecteddll)] = \
+                    self.orderoptions[self.orderoptionstr.index(str(order[0]))]
+                self.updateDllOverridesList()
+                self.emit(PYSIGNAL("changedSignal()"), ())
+
+    def slotDllComboActivated(self,dllid):
+        return
+
+    def fillCombo(self,combo):
+        """ Fill the combobox with the values from our list """
+        for dll in self.dlls:
+            combo.insertItem(dll)
+
+    def updateDllOverridesList(self):
+        """ Updates the displayed list of drives """
+        self.dllslist.clear()
+        self.dllsToListItems = {}
+        firstselecteddll = None
+        lastdll = None
+
+        for dll,order in self.overriddendlls.iteritems():
+            lvi = QListViewItem(self.dllslist,dll,order)
+            self.dllsToListItems[dll] = lvi
+            if self.selecteddll and self.selecteddll==dll:
+                firstselecteddll = dll
+            lastdll = dll
+
+        self.dllslist.setSortColumn(0)
+        self.selecteddll = firstselecteddll
+        self.__selectOverriddenDll(self.selecteddll)
+        self.dllslist.ensureItemVisible(self.dllslist.currentItem())
+
+    def __selectOverriddenDll(self,dll):
+        """ Select a dll from the overridden list """
+        self.selecteddll = dll
+        if dll:
+            self.dllslist.setSelected(self.dllsToListItems[str(dll)],True)
+            self.editbutton.setEnabled(True)
+            self.removebutton.setEnabled(True)
+        else:
+            self.editbutton.setEnabled(False)
+            self.removebutton.setEnabled(False)
+
+    def setMargin(self,margin):
+        self.top_layout.setMargin(margin)
+
+    def setSpacing(self,spacing):
+        self.top_layout.setSpacing(spacing)
+
+
+############################################################################
+def create_wineconfig(parent,name):
+    """ Factory function for KControl """
+    global kapp
+    kapp = KApplication.kApplication()
+    return WineConfigApp(parent, name)
+
+############################################################################
+def MakeAboutData():
+    aboutdata = KAboutData("guidance",programname,version, \
+        "Wine Configuration Tool", KAboutData.License_GPL, \
+        "Copyright (C) 2006-2007 Yuriy Kozlov", \
+        "Thanks go to  Simon Edwards, Sebastian Kügler")
+    aboutdata.addAuthor("Yuriy Kozlov","Developer","yuriy.kozlov@gmail.com", \
+            "http://www.yktech.us/")
+    aboutdata.addAuthor("Simon Edwards","Developer","simon@simonzone.com", \
+            "http://www.simonzone.com/software/")
+    aboutdata.addAuthor("Sebastian Kügler","Developer","sebas@kde.org", \
+            "http://vizZzion.org")
+    return aboutdata
+
+if standalone:
+    aboutdata = MakeAboutData()
+    KCmdLineArgs.init(sys.argv,aboutdata)
+
+    # Can't do i18n?
+    options = [("+[appname]", str(i18n("Application to change settings for")))]
+    KCmdLineArgs.addCmdLineOptions( options )
+
+    kapp = KApplication()
+
+    wineconfigapp = WineConfigApp()
+    wineconfigapp.exec_loop(None)