path: root/wineconfig/wineconfig.py

#!/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.                                   #
#                                                                         #
###########################################################################

import sys
import os
import os.path
from PyTQt.qt import *
from tdecore import *
from tdeui import *
from tdefile import *
from tdeio import *
#import string
#import math
import shutil
#import select
#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 = TDECModule

############################################################################
class WineConfigApp(programbase):
    ########################################################################
    def __init__(self,parent=None,name=None):
        global standalone,kapp,default_winepath,application
        TDEGlobal.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 = TDECmdLineArgs.parsedArgs()
            if args.count() > 0:
                application = args.arg(0)
        else:
            TDECModule.__init__(self,parent,name)
            self.setButtons(TDECModule.Apply|TDECModule.Reset)
            self.aboutdata = MakeAboutData()

        # Create a configuration object.
        self.config = TDEConfig("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

        TDEGlobal.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 = TDEAboutApplication(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 = TQVBoxLayout( self, 0, KDialog.spacingHint() )
            tabcontrol = TQTabWidget(self)
            toplayout.addWidget(tabcontrol)
            toplayout.setStretchFactor(tabcontrol,1)

        #--- General tab ---
        tabname = i18n("General")
        if standalone:
            general1page = self.addGridPage(1,TQGrid.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,TQGrid.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,TQGrid.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,TQGrid.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,TQGrid.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,TQGrid.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,TQGrid.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 = TQVBoxLayout( self, 0, KDialog.spacingHint() )
            
        if not standalone:
            nowinewarning = TQLabel(self,"nowinewarning")
            toplayout.addWidget(nowinewarning)
        else:
            vbox = self.addVBoxPage ("Wine Not Installed")
            nowinewarning = TQLabel(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( TQFrame.Box | TQFrame.Raised )
            
    def InstallWine(self):
        """ Allows the user to enable the proper repositories and
        install wine.
        Currently Kubuntu specific, requires tdesudo, adept_batch
        and software-properties-kde """
        if not isroot:
            if os.system("tdesudo \"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("tdesudo \"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): # TDECModule
        # 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): # TDECModule
        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(TQWidget):
    """
    Displayed when there is no fake Windows drive
    """

    def __init__(self,parent = None, name = None, parentapp = None, modal = 0,fl=0):
        TQWidget.__init__(self,parent)

        if not name:
            self.setName("ErrorPage")

        self.parent = parentapp

        self.top_layout = TQVBoxLayout(self,0,0,"ErrorPageLayout")

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        self.top_layout.addWidget(vbox)

        errortext = TQLabel(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 = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.Expanding)
        self.top_layout.addItem(bottomspacer)

        self.clearWState(TQt.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(TQWidget):
    """
    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):
        TQWidget.__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 = TQVBoxLayout(self,0,0,"DrivesTabLayout")
        self.top_layout = drives_tab_layout

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        drives_tab_layout.addWidget(vbox)

        # -- Drive mappings group
        self.mappings_group_box = TQHGroupBox(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 = TQVBox(self.mappings_group_box)
        vbox2.setSpacing(KDialog.spacingHint())

        spacer = TQWidget(vbox2)
        vbox2.setStretchFactor(spacer,1)

        self.driveslist = TDEListView(vbox2)
        self.driveslist.addColumn(i18n("Directory"))
        self.driveslist.addColumn(i18n("Links to"))
        self.driveslist.setAllColumnsShowFocus(True)
        self.driveslist.setSelectionMode(TQListView.Single)
        self.driveslist.setSorting(-1,True)

        self.connect(self.driveslist, SIGNAL("selectionChanged(TQListViewItem *)"), self.slotListClicked)

        hbox = TQHBox(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 = TQWidget(hbox)
        hbox.setStretchFactor(spacer,1)

        self.autobutton = KPushButton(i18n("Autodetect"),hbox)
        self.connect(self.autobutton,SIGNAL("clicked()"),self.slotAutoClicked)

        hbox2 = TQHBox(vbox2)
        hbox2.setSpacing(KDialog.spacingHint())

        pathtext = TQLabel(hbox2,"pathtext")
        pathtext.setText(i18n("Path:"))

        self.fsfolderedit = KLineEdit("/",hbox2)
        self.urlcompletion = KURLCompletion(KURLCompletion.DirCompletion)
        self.fsfolderedit.setCompletionObject(self.urlcompletion)
        self.fsfolderedit.setCompletionMode(TDEGlobalSettings.CompletionPopup)
        self.connect(self.fsfolderedit,SIGNAL("textChanged(const TQString &)"),self.slotFolderEdited)

        self.browsebutton = KPushButton(i18n("Browse"),hbox2)
        self.connect(self.browsebutton,SIGNAL("clicked()"),self.slotBrowseClicked)

        hbox2 = TQHBox(vbox2)
        hbox2.setSpacing(KDialog.spacingHint())

        self.typetext = TQLabel(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 = TQWidget(hbox2)
        hbox2.setStretchFactor(spacer,1)

        hbox2 = TQHBox(vbox2)
        hbox2.setSpacing(KDialog.spacingHint())

        self.infotext1 = TQLabel(hbox2,"infotext1")

        hbox2 = TQHBox(vbox2)
        hbox2.setSpacing(KDialog.spacingHint())

        self.infotext2 = TQLabel(hbox2,"infotext2")

        bottomspacer = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.Expanding)
        drives_tab_layout.addItem(bottomspacer)

        self.changed = False

        self.clearWState(TQt.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] = str(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 = str(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 = str(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 = TQListViewItem(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(str(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(str(i18n("Label: ")) + self.drives[driveid][4])
            else:
                self.infotext1.setText("")
            if self.drives[driveid][5]:
                self.infotext2.setText(str(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(TQWidget):
    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
        TQWidget.__init__(self,parent)

        if not name:
            self.setName("AudioTab")

        audio_tab_layout = TQVBoxLayout(self,0,0,"AudioTabLayout")
        self.top_layout = audio_tab_layout

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        audio_tab_layout.addWidget(vbox)

        if application:
            appwarning = TQLabel(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( TQFrame.Box | TQFrame.Raised )

        # -- Drivers group
        self.driver_group_box = TQHGroupBox(vbox)
        self.driver_group_box.setTitle(i18n("Driver Selection"))
        self.driver_group_box.setInsideSpacing(KDialog.spacingHint())
        self.driver_group_box.setInsideMargin(KDialog.marginHint())

        vbox2 = TQVBox(self.driver_group_box)
        vbox2.setSpacing(KDialog.spacingHint())

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        drivertext = TQLabel(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)

        TQToolTip.add(hbox, i18n("Choose an audio driver.  Not all audio " +\
            "drivers are available."))
        spacer = TQWidget(hbox)
        hbox.setStretchFactor(spacer,1)

        if application:
            self.driver_group_box.hide()

        # -- DirectSound Settings group
        self.dsound_group_box = TQHGroupBox(vbox)
        self.dsound_group_box.setTitle(i18n("DirectSound"))
        self.dsound_group_box.setInsideSpacing(KDialog.spacingHint())
        self.dsound_group_box.setInsideMargin(KDialog.marginHint())

        vbox2 = TQVBox(self.dsound_group_box)
        vbox2.setSpacing(KDialog.spacingHint())

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        acceltext = TQLabel(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 = TQWidget(hbox)
        hbox.setStretchFactor(spacer,1)

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        self.overridecheckbox = TQCheckBox(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 = TQHBox(vbox2)
        self.sampleratehbox.setSpacing(KDialog.spacingHint())

        sampletext = TQLabel(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 = TQLabel(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 = TQWidget(self.sampleratehbox)
        self.sampleratehbox.setStretchFactor(spacer,1)

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        self.drvemucheckbox = TQCheckBox(i18n("Driver Emulation"),hbox)
        hbox.setStretchFactor(self.drvemucheckbox,0)
        self.connect(self.drvemucheckbox,SIGNAL("toggled(bool)"), self.slotDriverEmulToggled)

        bottomspacer = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.Expanding)
        audio_tab_layout.addItem(bottomspacer)

        self.reset()

        self.clearWState(TQt.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(TQWidget):

    # 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
        TQWidget.__init__(self,parent)

        if not name:
            self.setName("GraphicsTab")

        graphics_tab_layout = TQVBoxLayout(self,0,0,"GraphicsTabLayout")
        self.top_layout = graphics_tab_layout

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        graphics_tab_layout.addWidget(vbox)

        if application:
            appwarning = TQLabel(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( TQFrame.Box | TQFrame.Raised )

        # -- Window settings group
        self.windows_group_box = TQHGroupBox(vbox)
        self.windows_group_box.setTitle(i18n("Window Settings"))
        self.windows_group_box.setInsideSpacing(KDialog.spacingHint())
        self.windows_group_box.setInsideMargin(KDialog.marginHint())

        vbox2 = TQVBox(self.windows_group_box)
        vbox2.setSpacing(KDialog.spacingHint())

        self.allowcursorcheckbox = TQCheckBox(i18n("Allow DirectX applications to stop the mouse leaving their window"),vbox2)
        self.connect(self.allowcursorcheckbox,SIGNAL("toggled(bool)"), self.slotAllowCursorToggled)

        self.dubbuffercheckbox = TQCheckBox(i18n("Enable desktop double buffering"),vbox2)
        self.connect(self.dubbuffercheckbox,SIGNAL("toggled(bool)"), self.slotDubBufferToggled)

        self.allowwmcheckbox = TQCheckBox(i18n("Allow the window manager to control the windows"),vbox2)
        self.connect(self.allowwmcheckbox,SIGNAL("toggled(bool)"), self.slotAllowWMToggled)

        TQToolTip.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 = TQCheckBox(i18n("Display window contents while dragging"),vbox2)
        self.connect(self.showdragcheckbox,SIGNAL("toggled(bool)"), self.slotShowDragToggled)

        self.emudesktopcheckbox = TQCheckBox(i18n("Emulate a virtual desktop"),vbox2)
        self.connect(self.emudesktopcheckbox,SIGNAL("toggled(bool)"), self.slotEmuDesktopToggled)

        self.desksizehbox = TQHBox(vbox2)
        self.desksizehbox.setSpacing(KDialog.spacingHint())

        desksizetext = TQLabel(self.desksizehbox,"desksizetext")
        desksizetext.setText(i18n("Desktop size:"))

        self.xsizeedit = KLineEdit("640",self.desksizehbox)
        self.xsizeedit.setValidator(TQIntValidator(self.xsizeedit))
        self.connect(self.xsizeedit,SIGNAL("textChanged(const TQString &)"),self.slotDesktopSizeChanged)
        bytext = TQLabel(self.desksizehbox,"bytext")
        bytext.setText(i18n("x"))
        self.ysizeedit = KLineEdit("480",self.desksizehbox)
        self.ysizeedit.setValidator(TQIntValidator(self.ysizeedit))
        self.connect(self.ysizeedit,SIGNAL("textChanged(const TQString &)"),self.slotDesktopSizeChanged)

        spacer = TQWidget(self.desksizehbox)
        self.desksizehbox.setStretchFactor(spacer,1)

        TQToolTip.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>"))
        TQToolTip.add(self.desksizehbox, TQToolTip.textFor(self.emudesktopcheckbox))

        if application:
            self.emudesktopcheckbox.hide()
            self.desksizehbox.hide()
            self.showdragcheckbox.hide()

        # -- Direct3D settings group
        self.d3d_group_box = TQHGroupBox(vbox)
        self.d3d_group_box.setTitle(i18n("Direct3D"))
        self.d3d_group_box.setInsideSpacing(KDialog.spacingHint())
        self.d3d_group_box.setInsideMargin(KDialog.marginHint())

        vbox2 = TQVBox(self.d3d_group_box)
        vbox2.setSpacing(KDialog.spacingHint())

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        vertexshadertext = TQLabel(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 = TQWidget(hbox)
        hbox.setStretchFactor(spacer,1)

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        self.pixelshadercheckbox = TQCheckBox(i18n("Allow Pixel Shader (if supported by hardware)"),hbox)
        self.connect(self.pixelshadercheckbox,SIGNAL("toggled(bool)"), self.slotPixelShaderModeToggled)

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        self.glslcheckbox = TQCheckBox(i18n("Use GL Shader Language"),hbox)
        self.connect(self.glslcheckbox,SIGNAL("toggled(bool)"), self.slotGLSLToggled)

        TQToolTip.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 = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.Expanding)
        graphics_tab_layout.addItem(bottomspacer)

        self.reset()

        self.clearWState(TQt.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 = str(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(TQWidget):

    themes = [str(i18n("No Theme"))]
    colorschemes = [str(i18n("Custom"))]
    sizes = [("NormalSize",str(i18n("Normal"))),
        ("LargeSize",str(i18n("Large Fonts"))),
        ("ExtraLargeSize",str(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":[str(i18n("Active Color:")),TQColor()],
              "InactiveBorder":[str(i18n("Inactive Color:")),TQColor()]},
             {"BorderWidth":[str(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
        "Title Bar":
            ({"ActiveTitle":[str(i18n("Active Color:")),TQColor()],
              "GradientActiveTitle":[str(i18n("Gradient:")),TQColor()],
              "InactiveTitle":[str(i18n("Inactive Color:")),TQColor()],
              "GradientInactiveTitle":[str(i18n("Gradient:")),TQColor()],
              "TitleText":[str(i18n("Active Text:")),TQColor()],
              "InactiveTitleText":[str(i18n("Inactive Text:")),TQColor()]},
             {}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
        "Application Workspace":
            ({"AppWorkSpace":[str(i18n("Background Color:")),TQColor()]},
             {}), #AppWorkSpace "Background"
        "Buttons":
            ({"ButtonFace":[str(i18n("Face:")),TQColor()],
              "ButtonHilight":[str(i18n("Hilight:")),TQColor()],
              "ButtonLight":[str(i18n("Light:")),TQColor()],
              "ButtonShadow":[str(i18n("Shadow:")),TQColor()],
              "ButtonText":[str(i18n("Text Color:")),TQColor()],
              "ButtonAlternateFace":[str(i18n("Alternate Face:")),TQColor()],
              "ButtonDkShadow":[str(i18n("Dark Shadow:")),TQColor()],
              "WindowFrame":[str(i18n("Frame:")),TQColor()]},
             {}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
        "Caption Buttons":
            ({},
             {"CaptionHeight":[str(i18n("Height:")),1],
              "CaptionWidth":[str(i18n("Width:")),1]}), #Metrics: CaptionHeight, CaptionWidth
        "Desktop":
            ({"Background":[str(i18n("Background:")),TQColor()]},
             {}), #Background
        "Menu":
            ({"Menu":[str(i18n("Menu Background:")),TQColor()],
              "MenuBar":[str(i18n("Menu Bar Color:")),TQColor()],
              "MenuHilight":[str(i18n("Menu Hilight:")),TQColor()],
              "MenuText":[str(i18n("Text Color:")),TQColor()]},
             {"MenuHeight":[str(i18n("Menu Bar Height:")),1]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
        "Scrollbar":
            ({"Scrollbar":[str(i18n("Color:")),TQColor()]},
             {"ScrollWidth":[str(i18n("Width:")),1]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
        "Window":
            ({"Window":[str(i18n("Background:")),TQColor()],
              "WindowText":[str(i18n("Text Color:")),TQColor()]},
             {}), #Window "Background", WindowText
        "Selected Items":
            ({"Hilight":[str(i18n("Hilight Color:")),TQColor()],
              "HilightText":[str(i18n("Text Color:")),TQColor()]},
             {})} #Hilight, HilightText

    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
        global imagedir
        TQWidget.__init__(self,parent)

        if not name:
            self.setName("AppearanceTab")

        appearance_tab_layout = TQVBoxLayout(self,0,0,"AppearanceTabLayout")
        self.top_layout = appearance_tab_layout

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        appearance_tab_layout.addWidget(vbox)

        # -- Appearance group
        self.appearance_group_box = TQVGroupBox(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 = TQWidget(self.appearance_group_box)

        theme_layout = TQGridLayout(themebox,3,3)
        theme_layout.setSpacing(KDialog.spacingHint())
        theme_layout.setColStretch(1,1)

        styletext = TQLabel(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 = TQLabel(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 = TQLabel(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 = TQHBox(self.appearance_group_box)
        hbox.setSpacing(KDialog.spacingHint())

        self.sizehbox = hbox
        self.leftspacer = TQWidget(hbox)

        self.customcolorsvbox = TQVBox(hbox)
        self.customcolorsvbox.setSpacing(KDialog.spacingHint())

        hbox = TQHBox(self.customcolorsvbox)
        hbox.setSpacing(KDialog.spacingHint())

        itemtext = TQLabel(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 = TQWidget(self.customcolorsvbox)
        self.customcolorsgrid_layout = TQGridLayout(self.customcolorsgrid,4,2)
        self.customcolorsgrid_layout.setSpacing(KDialog.spacingHint())

        # Box 1 of 8
        self.colorsizehbox1 = TQWidget(self.customcolorsgrid,"colorsizehbox1")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox1,0,0)
        self.colorsizehbox1_layout = TQGridLayout(self.colorsizehbox1,1,2)
        self.colorsizehbox1_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext1 = TQLabel(self.colorsizehbox1,"colorsizetext1")
        self.colorsizetext1.setText(i18n(":"))
        self.colorsizehbox1_layout.addWidget(self.colorsizetext1,0,0,TQt.AlignRight)

        self.sizespinbox1 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        # Box 2 of 8
        self.colorsizehbox2 = TQWidget(self.customcolorsgrid,"colorsizehbox2")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox2,0,1)
        self.colorsizehbox2_layout = TQGridLayout(self.colorsizehbox2,1,2)
        self.colorsizehbox2_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext2 = TQLabel(self.colorsizehbox2,"colorsizetext2")
        self.colorsizetext2.setText(i18n(":"))
        self.colorsizehbox2_layout.addWidget(self.colorsizetext2,0,0,TQt.AlignRight)

        self.sizespinbox2 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        # Box 3 of 8
        self.colorsizehbox3 = TQWidget(self.customcolorsgrid,"colorsizehbox3")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox3,1,0)
        self.colorsizehbox3_layout = TQGridLayout(self.colorsizehbox3,1,2)
        self.colorsizehbox3_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext3 = TQLabel(self.colorsizehbox3,"colorsizetext3")
        self.colorsizetext3.setText(i18n(":"))
        self.colorsizehbox3_layout.addWidget(self.colorsizetext3,0,0,TQt.AlignRight)

        self.sizespinbox3 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        # Box 4 of 8
        self.colorsizehbox4 = TQWidget(self.customcolorsgrid,"colorsizehbox4")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox4,1,1)
        self.colorsizehbox4_layout = TQGridLayout(self.colorsizehbox4,1,2)
        self.colorsizehbox4_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext4 = TQLabel(self.colorsizehbox4,"colorsizetext4")
        self.colorsizetext4.setText(i18n(":"))
        self.colorsizehbox4_layout.addWidget(self.colorsizetext4,0,0,TQt.AlignRight)

        self.sizespinbox4 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        # Box 5 of 8
        self.colorsizehbox5 = TQWidget(self.customcolorsgrid,"colorsizehbox5")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox5,2,0)
        self.colorsizehbox5_layout = TQGridLayout(self.colorsizehbox5,1,2)
        self.colorsizehbox5_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext5 = TQLabel(self.colorsizehbox5,"colorsizetext5")
        self.colorsizetext5.setText(i18n(":"))
        self.colorsizehbox5_layout.addWidget(self.colorsizetext5,0,0,TQt.AlignRight)

        self.sizespinbox5 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        # Box 6 of 8
        self.colorsizehbox6 = TQWidget(self.customcolorsgrid,"colorsizehbox6")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox6,2,1)
        self.colorsizehbox6_layout = TQGridLayout(self.colorsizehbox6,1,2)
        self.colorsizehbox6_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext6 = TQLabel(self.colorsizehbox6,"colorsizetext6")
        self.colorsizetext6.setText(i18n(":"))
        self.colorsizehbox6_layout.addWidget(self.colorsizetext6,0,0,TQt.AlignRight)

        self.sizespinbox6 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        # Box 7 of 8
        self.colorsizehbox7 = TQWidget(self.customcolorsgrid,"colorsizehbox7")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox7,3,0)
        self.colorsizehbox7_layout = TQGridLayout(self.colorsizehbox7,1,2)
        self.colorsizehbox7_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext7 = TQLabel(self.colorsizehbox7,"colorsizetext7")
        self.colorsizetext7.setText(i18n(":"))
        self.colorsizehbox7_layout.addWidget(self.colorsizetext7,0,0,TQt.AlignRight)

        self.sizespinbox7 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        # Box 8 of 8
        self.colorsizehbox8 = TQWidget(self.customcolorsgrid,"colorsizehbox8")
        self.customcolorsgrid_layout.addWidget(self.colorsizehbox8,3,1)
        self.colorsizehbox8_layout = TQGridLayout(self.colorsizehbox8,1,2)
        self.colorsizehbox8_layout.setSpacing(KDialog.spacingHint())

        self.colorsizetext8 = TQLabel(self.colorsizehbox8,"colorsizetext8")
        self.colorsizetext8.setText(i18n(":"))
        self.colorsizehbox8_layout.addWidget(self.colorsizetext8,0,0,TQt.AlignRight)

        self.sizespinbox8 = TQSpinBox(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 TQColor &)"),self.slotColorActivated)

        spacer = TQWidget(self.customcolorsvbox)
        self.customcolorsvbox.setStretchFactor(spacer,1)
        self.customcolorsvbox.setMinimumHeight(itemtext.height()*4.5)
        #self.customcolorsvbox.setStretchFactor(self.customcolorsgrid,1)

        bottomspacer = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.Expanding)
        appearance_tab_layout.addItem(bottomspacer)

        self.selecteditem = None
        self.config = TDEConfig("wineconfigrc",False,False)
        self.reset()

        self.clearWState(TQt.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 list(self.customizableitems.keys()):
            for key in list(self.customizableitems[item][0].keys()):
                color = colors.get(key,"0 0 0")
                color = color.split()
                color = TQColor(int(color[0]),int(color[1]),int(color[2]))
                if not custom and self.customizableitems[item][0][key][1] !=\
                    self.config.readColorEntry(key,TQColor(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 list(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 = str(self.config.readEntry("ColorScheme",i18n("Custom")))
        self.originalcustomcolorscheme = self.currentcustomcolorscheme
        schemeslist = self.config.readListEntry("ColorSchemes")
        self.colorschemes = [str(i18n("Custom")),
            str(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 list(self.customizableitems.keys()):
            for key in list(self.customizableitems[item][0].keys()):
                color = colors.get(key,"0 0 0")
                color = color.split()
                color = TQColor(int(color[0]),int(color[1]),int(color[2]))
                if color != self.config.readColorEntry(key,TQColor(0,0,0)):
                    self.currentcustomcolorscheme = self.colorschemes[0]
                self.customizableitems[item][0][key][1] = color
            for key in list(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 list(self.customizableitems.keys()):
            for key in list(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 list(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 = list(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(str(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 = list(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(str(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 = str(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 list(self.customizableitems.keys()):
            for key in list(schemesettings[item][0].keys()):
                self.config.writeEntry(key,schemesettings[item][0][key][1])
            for key in list(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 = TDEConfig("kdesktoprc")

        config.setGroup("General")
        self.customizableitems["Application Workspace"][0]["AppWorkSpace"][1] =\
            config.readColorEntry("background",TQColor(100,100,100))
        self.customizableitems["Buttons"][0]["ButtonFace"][1] =\
            config.readColorEntry("background",TQColor(230,230,230))
        self.customizableitems["Buttons"][0]["ButtonHilight"][1] =\
            config.readColorEntry("windowBackground",TQColor(240,240,240))
        self.customizableitems["Buttons"][0]["ButtonLight"][1] =\
            config.readColorEntry("selectBackground",TQColor(200,200,200)).light(135)
        self.customizableitems["Buttons"][0]["ButtonShadow"][1] =\
            config.readColorEntry("background",TQColor(100,100,100)).dark(180)
        self.customizableitems["Buttons"][0]["ButtonText"][1] =\
            config.readColorEntry("buttonForeground",TQColor(0,0,0))
        self.customizableitems["Buttons"][0]["ButtonAlternateFace"][1] =\
            config.readColorEntry("background",TQColor(230,230,230))
        self.customizableitems["Buttons"][0]["ButtonDkShadow"][1] =\
            config.readColorEntry("selectBackground",TQColor(0,0,0)).dark(146)
        self.customizableitems["Buttons"][0]["WindowFrame"][1] =\
            config.readColorEntry("selectBackground",TQColor(0,0,0))
        self.customizableitems["Menu"][0]["Menu"][1] =\
            config.readColorEntry("background",TQColor(230,230,230)).light(105)
        self.customizableitems["Menu"][0]["MenuBar"][1] =\
            config.readColorEntry("background",TQColor(230,230,230))
        self.customizableitems["Menu"][0]["MenuHilight"][1] =\
            config.readColorEntry("selectBackground",TQColor(0,0,0))
        self.customizableitems["Menu"][0]["MenuText"][1] =\
            config.readColorEntry("foreground",TQColor(0,0,0))
        self.customizableitems["Scrollbar"][0]["Scrollbar"][1] =\
            config.readColorEntry("background",TQColor(230,230,230))
        self.customizableitems["Window"][0]["Window"][1] =\
            config.readColorEntry("windowBackground",TQColor(255,255,255))
        self.customizableitems["Window"][0]["WindowText"][1] =\
            config.readColorEntry("foreground",TQColor(0,0,0))
        self.customizableitems["Selected Items"][0]["Hilight"][1] =\
            config.readColorEntry("selectBackground",TQColor(0,0,0))
        self.customizableitems["Selected Items"][0]["HilightText"][1] =\
            config.readColorEntry("selectForeground",TQColor(255,255,255))

        config.setGroup("WM")
        self.customizableitems["Title Bar"][0]["ActiveTitle"][1] =\
            config.readColorEntry("activeBackground",TQColor(10,10,100))
        self.customizableitems["Title Bar"][0]["GradientActiveTitle"][1] =\
            config.readColorEntry("activeBlend",TQColor(10,10,200)).light(110)
        self.customizableitems["Title Bar"][0]["InactiveTitle"][1] =\
            config.readColorEntry("inactiveBackground",TQColor(100,100,100))
        self.customizableitems["Title Bar"][0]["GradientInactiveTitle"][1] =\
            config.readColorEntry("inactiveBlend",TQColor(100,100,200))
        self.customizableitems["Title Bar"][0]["TitleText"][1] =\
            config.readColorEntry("activeForeground",TQColor(255,255,255))
        self.customizableitems["Title Bar"][0]["InactiveTitleText"][1] =\
            config.readColorEntry("inactiveForeground",TQColor(250,250,250))
        self.customizableitems["Window Border"][0]["ActiveBorder"][1] =\
            config.readColorEntry("frame",TQColor(10,10,100))
        self.customizableitems["Window Border"][0]["InactiveBorder"][1] =\
            config.readColorEntry("frame",TQColor(100,100,200))

        config.setGroup("Desktop0")
        self.customizableitems["Desktop"][0]["Background"][1] =\
            config.readColorEntry("Color1",TQColor(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 = list(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 list(self.customizableitems.keys()):
                for key in list(self.customizableitems[item][0].keys()):
                    color = self.config.readColorEntry(key,TQColor(0,0,0))
                    self.customizableitems[item][0][key][1] = color
                for key in list(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 = (str(i18n("Purple")),
       {"Window Border":
            ({"ActiveBorder":[str(i18n("Active Color:")),TQColor(239,239,239)],
              "InactiveBorder":[str(i18n("Inactive Color:")),TQColor(239,239,239)]},
             {"BorderWidth":[str(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
        "Title Bar":
            ({"ActiveTitle":[str(i18n("Active Color:")),TQColor(91,86,168)],
              "GradientActiveTitle":[str(i18n("Gradient:")),TQColor(136,118,202)],
              "InactiveTitle":[str(i18n("Inactive Color:")),TQColor(223,225,230)],
              "GradientInactiveTitle":[str(i18n("Gradient:")),TQColor(157,170,186)],
              "TitleText":[str(i18n("Active Text:")),TQColor(255,255,255)],
              "InactiveTitleText":[str(i18n("Inactive Text:")),TQColor(168,168,168)]},
             {}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
        "Application Workspace":
            ({"AppWorkSpace":[str(i18n("Background Color:")),TQColor(90,90,90)]},
             {}), #AppWorkSpace "Background"
        "Buttons":
            ({"ButtonFace":[str(i18n("Face:")),TQColor(238,239,242)],
              "ButtonHilight":[str(i18n("Hilight:")),TQColor(255,255,255)],
              "ButtonLight":[str(i18n("Light:")),TQColor(201,199,255)],
              "ButtonShadow":[str(i18n("Shadow:")),TQColor(132,132,134)],
              "ButtonText":[str(i18n("Text Color:")),TQColor(0,0,0)],
              "ButtonAlternateFace":[str(i18n("Alternate Face:")),TQColor(238,239,242)],
              "ButtonDkShadow":[str(i18n("Dark Shadow:")),TQColor(98,96,143)],
              "WindowFrame":[str(i18n("Frame:")),TQColor(144,140,209)]},
             {}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
        "Caption Buttons":
            ({},
             {"CaptionHeight":[str(i18n("Height:")),22],
              "CaptionWidth":[str(i18n("Width:")),22]}), #Metrics: CaptionHeight, CaptionWidth
        "Desktop":
            ({"Background":[str(i18n("Background:")),TQColor(146,127,188)]},
             {}), #Background
        "Menu":
            ({"Menu":[str(i18n("Menu Background:")),TQColor(250,251,254)],
              "MenuBar":[str(i18n("Menu Bar Color:")),TQColor(238,239,242)],
              "MenuHilight":[str(i18n("Menu Hilight:")),TQColor(144,140,209)],
              "MenuText":[str(i18n("Text Color:")),TQColor(0,0,0)]},
             {"MenuHeight":[str(i18n("Menu Bar Height:")),22]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
        "Scrollbar":
            ({"Scrollbar":[str(i18n("Color:")),TQColor(238,239,242)]},
             {"ScrollWidth":[str(i18n("Width:")),16]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
        "Window":
            ({"Window":[str(i18n("Background:")),TQColor(255,255,255)],
              "WindowText":[str(i18n("Text Color:")),TQColor(0,0,0)]},
             {}), #Window "Background", WindowText
        "Selected Items":
            ({"Hilight":[str(i18n("Hilight Color:")),TQColor(144,140,209)],
              "HilightText":[str(i18n("Text Color:")),TQColor(255,255,255)]},
             {})}) #Hilight, HilightText

    preset2 = (str(i18n("Blue")),
       {"Window Border":
            ({"ActiveBorder":[str(i18n("Active Color:")),TQColor(239,239,239)],
              "InactiveBorder":[str(i18n("Inactive Color:")),TQColor(239,239,239)]},
             {"BorderWidth":[str(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
        "Title Bar":
            ({"ActiveTitle":[str(i18n("Active Color:")),TQColor(0,113,201)],
              "GradientActiveTitle":[str(i18n("Gradient:")),TQColor(87,161,219)],
              "InactiveTitle":[str(i18n("Inactive Color:")),TQColor(191,191,191)],
              "GradientInactiveTitle":[str(i18n("Gradient:")),TQColor(171,171,171)],
              "TitleText":[str(i18n("Active Text:")),TQColor(255,255,255)],
              "InactiveTitleText":[str(i18n("Inactive Text:")),TQColor(95,95,95)]},
             {}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
        "Application Workspace":
            ({"AppWorkSpace":[str(i18n("Background Color:")),TQColor(90,90,90)]},
             {}), #AppWorkSpace "Background"
        "Buttons":
            ({"ButtonFace":[str(i18n("Face:")),TQColor(239,239,239)],
              "ButtonHilight":[str(i18n("Hilight:")),TQColor(246,246,246)],
              "ButtonLight":[str(i18n("Light:")),TQColor(191,207,251)],
              "ButtonShadow":[str(i18n("Shadow:")),TQColor(148,148,153)],
              "ButtonText":[str(i18n("Text Color:")),TQColor(0,0,0)],
              "ButtonAlternateFace":[str(i18n("Alternate Face:")),TQColor(238,239,242)],
              "ButtonDkShadow":[str(i18n("Dark Shadow:")),TQColor(50,101,146)],
              "WindowFrame":[str(i18n("Frame:")),TQColor(74,149,214)]},
             {}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
        "Caption Buttons":
            ({},
             {"CaptionHeight":[str(i18n("Height:")),22],
              "CaptionWidth":[str(i18n("Width:")),22]}), #Metrics: CaptionHeight, CaptionWidth
        "Desktop":
            ({"Background":[str(i18n("Background:")),TQColor(44,109,189)]},
             {}), #Background
        "Menu":
            ({"Menu":[str(i18n("Menu Background:")),TQColor(249,249,249)],
              "MenuBar":[str(i18n("Menu Bar Color:")),TQColor(239,239,239)],
              "MenuHilight":[str(i18n("Menu Hilight:")),TQColor(74,149,214)],
              "MenuText":[str(i18n("Text Color:")),TQColor(0,0,0)]},
             {"MenuHeight":[str(i18n("Menu Bar Height:")),22]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
        "Scrollbar":
            ({"Scrollbar":[str(i18n("Color:")),TQColor(230,230,230)]},
             {"ScrollWidth":[str(i18n("Width:")),16]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
        "Window":
            ({"Window":[str(i18n("Background:")),TQColor(255,255,255)],
              "WindowText":[str(i18n("Text Color:")),TQColor(0,0,0)]},
             {}), #Window "Background", WindowText
        "Selected Items":
            ({"Hilight":[str(i18n("Hilight Color:")),TQColor(74,149,214)],
              "HilightText":[str(i18n("Text Color:")),TQColor(255,255,255)]},
             {})}) #Hilight, HilightText
    presets = [preset1,preset2]

############################################################################
class GeneralPage(TQWidget):

    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
        TQWidget.__init__(self,parent)

        if not name:
            self.setName("GeneralTab")

        general_tab_layout = TQVBoxLayout(self,0,0,"GeneralTabLayout")
        self.top_layout = general_tab_layout

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        general_tab_layout.addWidget(vbox)

        if application:
            appwarning = TQLabel(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( TQFrame.Box | TQFrame.Raised )
            self.winversions = self.winversions + (( "global",\
                str(i18n("Use Global Setting")),   0,  0, 0, "", "", 0, 0, ""),)
            self.verdic["global"]=11

        hbox = TQHBox(vbox)
        hbox.setSpacing(KDialog.spacingHint())

        versiontext = TQLabel(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 = TQWidget(hbox)
        hbox.setStretchFactor(spacer,1)

        bottomspacer = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.Expanding)
        general_tab_layout.addItem(bottomspacer)

        self.reset()

        self.clearWState(TQt.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(TQWidget):

    applications = []

    browsers = []
    mailers = []

    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
        TQWidget.__init__(self,parent)

        if not name:
            self.setName("ApplicationsTab")

        applications_tab_layout = TQVBoxLayout(self,0,0,"ApplicationsTabLayout")
        self.top_layout = applications_tab_layout

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        applications_tab_layout.addWidget(vbox)

        # -- Application Specific Settings group --
        self.perapp_group_box = TQHGroupBox(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 = TQVBox(self.perapp_group_box)
        vbox2.setSpacing(KDialog.spacingHint())

        applicationstext = TQLabel(vbox2,"applicationstext")
        applicationstext.setText(i18n("Change application specific settings for:"))

        self.appslist = TDEListBox(vbox2)
        self.connect(self.appslist, SIGNAL("selectionChanged(TQListBoxItem *)"), self.slotListClicked)

        hbox = TQHBox(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 = TQWidget(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 = TQVGroupBox(vbox)
        #self.nativeapp_group_box.setTitle(i18n("Native applications"))
        #self.nativeapp_group_box.setInsideSpacing(KDialog.spacingHint())
        #self.nativeapp_group_box.setInsideMargin(KDialog.marginHint())

        #vbox3 = TQWidget(self.nativeapp_group_box)

        #native_apps_layout = TQGridLayout(vbox3,2,3)
        #native_apps_layout.setSpacing(KDialog.spacingHint())

        #browsertext = TQLabel(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 = TQLabel(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 = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.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(TQt.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() + str(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() + str(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|" + str(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(TQStringList.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 = TDEConfig("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(TQWidget):

    dlls = [""]
    overriddendlls = {}

    orderoptions = ("builtin","native","builtin,native","native,builtin","")
    orderoptionstr = [
        str(i18n("Built-in (Wine)")),
        str(i18n("Native (Windows)")),
        str(i18n("Built-in then Native")),
        str(i18n("Native then Built-in")),
        str(i18n("Disable"))]

    def __init__(self,parent = None,name = None,modal = 0,fl = 0):
        TQWidget.__init__(self,parent)

        if not name:
            self.setName("LibrariesTab")

        libraries_tab_layout = TQVBoxLayout(self,0,0,"LibrariesTabLayout")
        self.top_layout = libraries_tab_layout

        vbox = TQVBox(self)
        vbox.setSpacing(KDialog.spacingHint())

        libraries_tab_layout.addWidget(vbox)

        # -- DLL overrides group
        self.overrides_group_box = TQHGroupBox(vbox)
        self.overrides_group_box.setTitle(i18n("DLL Overrides"))
        self.overrides_group_box.setInsideSpacing(KDialog.spacingHint())
        self.overrides_group_box.setInsideMargin(KDialog.marginHint())

        vbox2 = TQVBox(self.overrides_group_box)
        vbox2.setSpacing(KDialog.spacingHint())

        spacer = TQWidget(vbox2)
        vbox2.setStretchFactor(spacer,1)

        newtext = TQLabel(vbox2,"newtext")
        newtext.setText(i18n("New override for library:"))

        hbox = TQHBox(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)

        TQToolTip.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 = TQLabel(vbox2,"existingtext")
        existingtext.setText(i18n("Existing overrides:"))

        hbox = TQHBox(vbox2)
        hbox.setSpacing(KDialog.spacingHint())

        self.dllslist = TDEListView(hbox)
        self.dllslist.addColumn(i18n("Library"))
        self.dllslist.addColumn(i18n("Load Order"))
        self.dllslist.setAllColumnsShowFocus(True)
        self.dllslist.setSelectionMode(TQListView.Single)
        self.dllslist.setSorting(-1,True)
        hbox.setStretchFactor(self.dllslist,3)

        self.connect(self.dllslist, SIGNAL("selectionChanged(TQListViewItem *)"), self.slotListClicked)

        vbox3 = TQVBox(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 = TQWidget(vbox3)
        vbox3.setStretchFactor(spacer,1)

        bottomspacer = TQSpacerItem(51,160,TQSizePolicy.Minimum,TQSizePolicy.Expanding)
        libraries_tab_layout.addItem(bottomspacer)

        self.changed = False

        self.reset()

        self.clearWState(TQt.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"),\
                str(i18n("Load order for %s:")) % (str(self.selecteddll),),
                TQStringList.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.items():
            lvi = TQListViewItem(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 = TDEApplication.kApplication()
    return WineConfigApp(parent, name)

############################################################################
def MakeAboutData():
    aboutdata = TDEAboutData("guidance",programname,version, \
        "Wine Configuration Tool", TDEAboutData.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()
    TDECmdLineArgs.init(sys.argv,aboutdata)

    # Can't do i18n?
    options = [("+[appname]", str(i18n("Application to change settings for")))]
    TDECmdLineArgs.addCmdLineOptions( options )

    kapp = TDEApplication()

    wineconfigapp = WineConfigApp()
    wineconfigapp.exec_loop(None)