You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tde-guidance/wineconfig/wineconfig.py

3554 lines
144 KiB

#!/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 python_tqt.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] = unicode(folder)
self.updateChanges()
def slotFolderEdited(self,folder):
""" Change the directory mapping when a new one is entered manually in the URL box """
if not self.updatingGUI:
self.urlcompletion.makeCompletion("") # Doesn't seem like this should be required.
self.slotFolderChanged(folder)
def slotBrowseClicked(self):
""" Bring up a browse window to choose a ndew mapping directory """
mapping = KFileDialog.getExistingDirectory(wineread.winepath,self,i18n("Drive Mapping"))
if mapping:
mapping = unicode(mapping)
self.drives[self.selecteddriveid][2] = mapping
self.updateChanges()
def slotAddClicked(self):
"""
Let the user choose a directory to map a new drive to.
Uses the next available drive letter. """
# TODO: Maybe the user should choose the drive letter?
for drive in self.drives[2:26]:
if drive[2]:
continue
else:
mapping = KFileDialog.getExistingDirectory(wineread.winepath,self,i18n("Drive Mapping"))
if mapping:
mapping = unicode(mapping)
drive[2] = mapping
else:
return
self.selecteddriveid = drive[0]
break
else:
KMessageBox.sorry(self, \
i18n("Can't add another drive. There can only be 26, for letters A-Z"))
return
self.updateChanges()
def slotRemoveClicked(self):
""" Removes the currently selected drive """
if self.selecteddriveid == 2: # Drive C:
if KMessageBox.warningContinueCancel(self, \
i18n("Are you sure you want to delete drive C:?\n\n"\
"Most Windows applications expect drive C: to exist, "\
"and will die messily if it doesn't. If you proceed "\
"remember to recreate it!"),\
i18n("Warning")) != KMessageBox.Continue:
return
self.drives[self.selecteddriveid][2:4] = ("","")
self.selecteddriveid -= 1 # Not quite correct, should select previous drive.
self.updateChanges()
def slotAutoClicked(self):
"""
Autodetects a default set of drives from /etc/fstab
Allows the user to start with a fresh list of drives or append to the current one
"""
automethod = KMessageBox.questionYesNoCancel(self, \
i18n("Would you like to remove the current set of drives?"),\
i18n("Drive Autodetection"))
if automethod == KMessageBox.Yes:
autodrives = drivedetect.autodetect()
autoshelllinks = drivedetect.autodetectshelllinks()
elif automethod == KMessageBox.No:
autodrives = drivedetect.autodetect(self.drives[:26])
autoshelllinks = drivedetect.autodetectshelllinks(self.drives[26:])
else:
return
if autodrives[0] == 1:
KMessageBox.sorry(self, \
i18n("There were not enough letters to add all the autodetected drives."))
self.drives[0:26] = autodrives[1]
self.drives[26:] = autoshelllinks
self.updateChanges()
def slotTypeActivated(self,index):
self.__selectType(self.types[index][2])
self.updateChanges()
def fillTypeCombo(self,combo):
""" Fill the combobox with the values from our list """
for drivetype in self.types:
combo.insertItem(drivetype[1])
def __selectType(self,typename):
if typename:
typeid = self.typesdic[typename]
else:
typeid = self.typesdic['auto']
self.drives[self.selecteddriveid][3] = typename
self.typecombo.setCurrentItem(typeid)
def updateDrivesList(self):
""" Updates the displayed list of drives """
self.driveslist.clear()
self.drivesToListItems = {}
firstselecteddriveid = None
lastdriveid = None
for driveid, driveletter, mapping, drivetype, drivelabel, serial in reversed(self.drives):
if mapping or drivelabel:
lvi = 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(unicode(i18n("Windows path: ")) + self.drives[driveid][4])
# It seems some old versions of wine didn't store the shell folders in the same place
if self.drives[driveid][5] != self.drives[driveid][4]:
changeregistryshell = KMessageBox.warningYesNo(self, \
i18n("The " + self.drives[driveid][1] + " folder is currently located in\n" + \
self.drives[driveid][5] + "\nIt is recommended that it is put in the default " + \
"location in\n" + wineread.defaultwinfolderspath + "\nWould you like to move it there?"),\
i18n("Shell Folder Mapping"))
changeregistryshell = changeregistryshell == KMessageBox.Yes
if changeregistryshell:
self.drives[driveid][5] = self.drives[driveid][4]
self.changed = True
self.emit(PYSIGNAL("changedSignal()"), ())
if self.drives[driveid][2] == wineread.profilesdirectory + self.drives[driveid][1]:
realfolderwarning = KMessageBox.information(self, \
i18n(self.drives[driveid][1] + " is an actual folder and is not linked elsewhere." + \
" Remapping it will create a backup of the directory in " + \
wineread.profilesdirectory),\
i18n("Shell Folder Mapping"))
else:
if self.typecombo.count() > 5:
self.typecombo.removeItem(5)
self.typecombo.setEnabled(True)
self.__selectType(self.drives[driveid][3])
self.removebutton.setEnabled(True)
if self.drives[driveid][4]:
self.infotext1.setText(unicode(i18n("Label: ")) + self.drives[driveid][4])
else:
self.infotext1.setText("")
if self.drives[driveid][5]:
self.infotext2.setText(unicode(i18n("Serial: ")) + self.drives[driveid][5])
else:
self.infotext2.setText("")
def setMargin(self,margin):
self.top_layout.setMargin(margin)
def setSpacing(self,spacing):
self.top_layout.setSpacing(spacing)
############################################################################
class AudioPage(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 = unicode(self.xsizeedit.text()) + 'x' + str(self.ysizeedit.text())
else:
self.currentemudesktop = ""
self.__setEmuDesktop(self.currentemudesktop)
self.emit(PYSIGNAL("changedSignal()"), ())
def slotDesktopSizeChanged(self,size):
self.slotEmuDesktopToggled(True)
def slotVertexShaderModeActivated(self,modeid):
mode = self.vertexshadersupport[modeid][1][0].lower() + self.vertexshadersupport[modeid][1][1:]
self.currentvertexshadermode = mode
self.emit(PYSIGNAL("changedSignal()"), ())
def slotPixelShaderModeToggled(self,mode):
if mode:
self.currentpixelshadermode = 'enabled'
else:
self.currentpixelshadermode = 'disabled'
self.emit(PYSIGNAL("changedSignal()"), ())
def slotGLSLToggled(self,mode):
if mode:
self.currentglsl = 'enabled'
else:
self.currentglsl = 'disabled'
self.emit(PYSIGNAL("changedSignal()"), ())
def __setAllowCursor(self, allow):
self.currentallowcursor = allow
allow = allow != 'N'
self.allowcursorcheckbox.setChecked(allow)
def __setDubBuffer(self, dub):
self.currentdubbuffer = dub
dub = dub != 'N'
self.dubbuffercheckbox.setChecked(dub)
def __setAllowWM(self, allow):
global currentallowwm
currentallowwm = allow
allow = allow != 'N'
self.allowwmcheckbox.setChecked(allow)
if not application:
if allow and self.currentemudesktop == "":
self.showdragcheckbox.setEnabled(False)
else:
self.showdragcheckbox.setEnabled(True)
def __setEmuDesktop(self, emudesktop):
self.currentemudesktop = emudesktop
emudesktopbool = emudesktop != ""
self.emudesktopcheckbox.setChecked(emudesktopbool)
self.desksizehbox.setEnabled(emudesktopbool)
if emudesktopbool:
desktopsize = emudesktop.split('x')
self.xsizeedit.setText(desktopsize[0])
self.ysizeedit.setText(desktopsize[1])
self.showdragcheckbox.setEnabled(True)
elif currentallowwm:
self.showdragcheckbox.setEnabled(False)
def __selectVertexShaderMode(self,mode):
self.currentvertexshadermode = mode
self.accelcombo.setCurrentItem(self.vertexshadersupportdic[mode])
def __setPixelShaderMode(self,mode):
self.currentpixelshadermode = mode
mode = mode == 'enabled'
self.pixelshadercheckbox.setChecked(mode)
def __setGLSL(self,mode):
self.currentglsl = mode
mode = mode == 'enabled'
self.glslcheckbox.setChecked(mode)
def __setShowDrag(self,show):
self.currentshowdrag = show
show = show != '0'
self.showdragcheckbox.setChecked(show)
def setMargin(self,margin):
self.top_layout.setMargin(margin)
def setSpacing(self,spacing):
self.top_layout.setSpacing(spacing)
############################################################################
class AppearancePage(TQWidget):
themes = [unicode(i18n("No Theme"))]
colorschemes = [unicode(i18n("Custom"))]
sizes = [("NormalSize",unicode(i18n("Normal"))),
("LargeSize",unicode(i18n("Large Fonts"))),
("ExtraLargeSize",unicode(i18n("Extra Large Fonts")))]
# Items for the combo box reference a tuple of dictionaries for color
# and size values and translations for that item
# For example, the value of BorderWidth is
# customizableitems[str(i18n("Window Border"))][1]["BorderWidth"][1]
customizableitems = {"Window Border":
({"ActiveBorder":[unicode(i18n("Active Color:")),TQColor()],
"InactiveBorder":[unicode(i18n("Inactive Color:")),TQColor()]},
{"BorderWidth":[unicode(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
"Title Bar":
({"ActiveTitle":[unicode(i18n("Active Color:")),TQColor()],
"GradientActiveTitle":[unicode(i18n("Gradient:")),TQColor()],
"InactiveTitle":[unicode(i18n("Inactive Color:")),TQColor()],
"GradientInactiveTitle":[unicode(i18n("Gradient:")),TQColor()],
"TitleText":[unicode(i18n("Active Text:")),TQColor()],
"InactiveTitleText":[unicode(i18n("Inactive Text:")),TQColor()]},
{}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
"Application Workspace":
({"AppWorkSpace":[unicode(i18n("Background Color:")),TQColor()]},
{}), #AppWorkSpace "Background"
"Buttons":
({"ButtonFace":[unicode(i18n("Face:")),TQColor()],
"ButtonHilight":[unicode(i18n("Hilight:")),TQColor()],
"ButtonLight":[unicode(i18n("Light:")),TQColor()],
"ButtonShadow":[unicode(i18n("Shadow:")),TQColor()],
"ButtonText":[unicode(i18n("Text Color:")),TQColor()],
"ButtonAlternateFace":[unicode(i18n("Alternate Face:")),TQColor()],
"ButtonDkShadow":[unicode(i18n("Dark Shadow:")),TQColor()],
"WindowFrame":[unicode(i18n("Frame:")),TQColor()]},
{}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
"Caption Buttons":
({},
{"CaptionHeight":[unicode(i18n("Height:")),1],
"CaptionWidth":[unicode(i18n("Width:")),1]}), #Metrics: CaptionHeight, CaptionWidth
"Desktop":
({"Background":[unicode(i18n("Background:")),TQColor()]},
{}), #Background
"Menu":
({"Menu":[unicode(i18n("Menu Background:")),TQColor()],
"MenuBar":[unicode(i18n("Menu Bar Color:")),TQColor()],
"MenuHilight":[unicode(i18n("Menu Hilight:")),TQColor()],
"MenuText":[unicode(i18n("Text Color:")),TQColor()]},
{"MenuHeight":[unicode(i18n("Menu Bar Height:")),1]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
"Scrollbar":
({"Scrollbar":[unicode(i18n("Color:")),TQColor()]},
{"ScrollWidth":[unicode(i18n("Width:")),1]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
"Window":
({"Window":[unicode(i18n("Background:")),TQColor()],
"WindowText":[unicode(i18n("Text Color:")),TQColor()]},
{}), #Window "Background", WindowText
"Selected Items":
({"Hilight":[unicode(i18n("Hilight Color:")),TQColor()],
"HilightText":[unicode(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 self.customizableitems.keys():
for key in 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 self.customizableitems[item][1].keys():
size = int(metrics.get(key,1))
if not custom and self.customizableitems[item][1][key][1] !=\
self.config.readNumEntry(key,1):
self.__selectColorScheme(0)
custom = True
if self.customizableitems[item][1][key][1] != size:
if custom:
return True
else:
changed = True
return changed
def reset(self):
self.fillItemCombo(self.itemcombo)
self.config.setGroup("")
self.currentcustomcolorscheme = unicode(self.config.readEntry("ColorScheme",i18n("Custom")))
self.originalcustomcolorscheme = self.currentcustomcolorscheme
schemeslist = self.config.readListEntry("ColorSchemes")
self.colorschemes = [unicode(i18n("Custom")),
unicode(i18n("Get KDE Colors"))] + list(schemeslist)
self.config.setGroup(self.currentcustomcolorscheme)
for preset in self.presets:
if preset[0] not in schemeslist:
self.saveColorScheme(preset[0],preset[1])
self.colorschemes.append(preset[0])
self.fillColorSchemeCombo(self.colorschemecombo)
theme = wineread.GetCurrentTheme()
if not theme:
self.currenttheme = self.themes[0]
self.originaltheme = self.currenttheme
self.__selectTheme(0)
self.currentthemecolorscheme = "NormalColor"
self.originalthemecolorscheme = self.currentthemecolorscheme
self.currentfontsize = self.sizes[0][0]
self.originalfontsize = self.currentfontsize
for i,sizename in enumerate(self.sizes):
if sizename[0] == self.currentfontsize:
self.__selectFontSize(i)
break
else:
self.currenttheme = theme[0]
self.originaltheme = self.currenttheme
for i,themename in enumerate(self.themes):
if themename == self.currenttheme:
self.__selectTheme(i)
break
self.currentthemecolorscheme = theme[1]
self.originalthemecolorscheme = self.currentthemecolorscheme
self.currentfontsize = theme[2]
self.originalfontsize = self.currentfontsize
for i,sizename in enumerate(self.sizes):
if sizename[0] == self.currentfontsize:
self.__selectFontSize(i)
break
colors = wineread.GetColorSettings()
metrics = wineread.GetWindowMetrics()
for item in self.customizableitems.keys():
for key in self.customizableitems[item][0].keys():
color = colors.get(key,"0 0 0")
color = color.split()
color = 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 self.customizableitems[item][1].keys():
size = int(metrics.get(key,1))
if size != self.config.readNumEntry(key,1):
self.currentcustomcolorscheme = self.colorschemes[0]
self.customizableitems[item][1][key][1] = size
for i,colorname in enumerate(self.colorschemes):
if colorname == self.currentcustomcolorscheme:
self.__selectColorScheme(i)
break
self.desktopsettings = wineread.GetDesktopSettings()
def applyChanges(self):
""" Applies the changes to wine's configuration """
if self.currenttheme == self.themes[0]:
winewrite.SetCurrentTheme(None)
else:
winewrite.SetCurrentTheme((self.currenttheme,
self.currentthemecolorscheme,
self.currentfontsize))
colorsettings = {}
metricssettings = {}
for item in self.customizableitems.keys():
for key in self.customizableitems[item][0].keys():
color = self.customizableitems[item][0][key][1]
color = str(color.red()) + " " + str(color.green()) +\
" " + str(color.blue())
colorsettings[key] = color
for key in self.customizableitems[item][1].keys():
size = self.customizableitems[item][1][key][1]
metricssettings[key] = str(size)
winewrite.SetColorSettings(colorsettings)
winewrite.SetWindowMetrics(metricssettings)
self.config.setGroup("")
if self.currentcustomcolorscheme == self.colorschemes[1]:
self.currentcustomcolorscheme = self.colorschemes[0]
self.config.writeEntry("ColorScheme",self.currentcustomcolorscheme)
self.config.sync()
if self.customizableitems["Title Bar"][0]["ActiveTitle"][1]\
!=\
self.customizableitems["Title Bar"][0]["GradientActiveTitle"][1]\
or\
self.customizableitems["Title Bar"][0]["InactiveTitle"][1]\
!=\
self.customizableitems["Title Bar"][0]["GradientInactiveTitle"][1]:
prefmask = self.desktopsettings["UserPreferencemask"]
prefmask = prefmask[:4] + "1" + prefmask[5:]
self.desktopsettings["UserPreferencemask"] = prefmask
else:
prefmask = self.desktopsettings["UserPreferencemask"]
prefmask = prefmask[:4] + "0" + prefmask[5:]
self.desktopsettings["UserPreferencemask"] = prefmask
winewrite.SetDesktopSettings(self.desktopsettings)
self.reset()
def fillThemeCombo(self,combo):
""" Fill the combo box with the list of themes """
for theme in self.themes:
combo.insertItem(theme)
def fillColorSchemeCombo(self,combo):
""" Fill the combo box with the list of color schemes """
combo.clear()
for color in self.colorschemes:
combo.insertItem(color)
def fillFontSizeCombo(self,combo):
""" Fill the combo box with the list of font sizes """
for size in self.sizes:
combo.insertItem(size[1])
def slotFillItemCombo(self,allowwm):
"""
Fill the combo box with the list of customizable items
Called when window managing is changed
"""
combo = self.itemcombo
combo.clear()
items = self.customizableitems.keys()
items.sort()
for item in items:
if not (allowwm and (item == "Window Border" \
or item == "Title Bar" or \
item == "Caption Buttons")):
combo.insertItem(unicode(i18n(item)))
def slotFillItemComboDesktop(self,desktop):
"""
Fill the combo box with the list of customizable items
Called when virtual desktop is changed
"""
self.slotFillItemCombo(not desktop)
def fillItemCombo(self,combo = None):
""" Fill the combo box with the list of customizable items """
if not combo:
combo = self.itemcombo
combo.clear()
items = self.customizableitems.keys()
items.sort()
self.currentitems = []
for item in items:
if not (currentallowwm == 'Y' and (item == "Window Border" \
or item == "Title Bar" or \
item == "Caption Buttons")):
combo.insertItem(unicode(i18n(item)))
self.currentitems.append(item)
def slotThemeActivated(self,themeid):
""" Picks an already installed theme """
self.__selectTheme(themeid)
self.emit(PYSIGNAL("changedSignal()"), ())
def slotInstallThemeClicked(self):
""" Opens up a dialog to install a new theme """
themepath = unicode(KFileDialog.getOpenFileName(os.environ['HOME'],\
"*.msstyles|" + str(i18n("Windows Styles (*.msstyles)")),self,i18n("Install Style")))
if themepath:
themename = themepath.split('/')
themename = themename[-1]
themename = themename.split('.')
themename = themename[0]
themedir = wineread.winepath +\
"/dosdevices/c:/windows/Resources/Themes/" +\
themename
if not os.path.exists(themedir):
os.mkdir(themedir)
shutil.copy(themepath, themedir)
self.themes.append(str(i18n(themename)))
self.themecombo.insertItem(self.themes[-1])
self.emit(PYSIGNAL("changedSignal()"), ())
def slotSaveSchemeClicked(self):
""" Lets the user save the current color scheme """
schemename = KInputDialog.getText(i18n("Save Color Scheme"),\
i18n("Name: "),\
i18n("CustomScheme"),\
self,"schemenameinput")
while schemename[1] and schemename[0] == "" or \
schemename[0] == self.colorschemes[0] or \
schemename[0] == self.colorschemes[1]:
KMessageBox.information(self, \
i18n("Please enter a unique name for the color scheme."), \
i18n("Save Color Scheme"))
schemename = KInputDialog.getText(i18n("Save Color Scheme"),\
i18n("Name: "),\
i18n("CustomScheme"),\
self,"schemenameinput")
if schemename[1]:
schemename = str(schemename[0])
self.saveColorScheme(schemename)
if schemename not in self.colorschemes:
self.colorschemes.append(schemename)
self.colorschemecombo.insertItem(schemename)
for i,colorname in enumerate(self.colorschemes):
if colorname == schemename:
self.__selectColorScheme(i)
break
def saveColorScheme(self,name,schemesettings = None):
""" Saves the colorscheme """
if not schemesettings:
schemesettings = self.customizableitems
self.config.setGroup("")
if name != self.colorschemes[1]:
self.config.writeEntry("ColorScheme",name)
schemeslist = self.config.readListEntry("ColorSchemes")
if name not in schemeslist and name != self.colorschemes[0] and \
name != self.colorschemes[1]:
schemeslist.append(name)
self.config.writeEntry("ColorSchemes",schemeslist)
self.config.setGroup(name)
for item in self.customizableitems.keys():
for key in schemesettings[item][0].keys():
self.config.writeEntry(key,schemesettings[item][0][key][1])
for key in schemesettings[item][1].keys():
self.config.writeEntry(key,schemesettings[item][1][key][1])
self.config.sync()
def GetKdeColorScheme(self):
""" Sets the current color scheme settings to those currently set in KDE """
# Create a configuration object.
config = 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 = self.customizableitems.keys()
items.sort()
for i,item in enumerate(self.currentitems):
if i == itemid:
if item != self.selecteditem:
self.__selectItem(item)
def slotColorActivated(self,color):
""" Picks a color for the currently selected item """
key = self.sender().name()
self.customizableitems[self.selecteditem][0][key][1] = color
self.emit(PYSIGNAL("changedSignal()"), ())
def slotSizeActivated(self,sizevalue):
""" Sets the size value from the spin box """
key = self.sender().name()
self.customizableitems[self.selecteditem][1][key][1] = sizevalue
self.emit(PYSIGNAL("changedSignal()"), ())
def __selectTheme(self,themeid):
""" Selects the browser in the combobox """
self.currenttheme = self.themes[themeid]
self.themecombo.setCurrentItem(themeid)
#if themeid == 0:
# self.colorfontbox.setEnabled(False)
#else:
# self.colorfontbox.setEnabled(True)
def __selectColorScheme(self,colorid):
""" Selects a color scheme in the combo box """
self.currentcustomcolorscheme = self.colorschemes[colorid]
self.colorschemecombo.setCurrentItem(colorid)
if colorid > 1:
self.config.setGroup("")
self.config.writeEntry("ColorScheme",self.colorschemes[colorid])
self.config.setGroup(self.colorschemes[colorid])
for item in self.customizableitems.keys():
for key in self.customizableitems[item][0].keys():
color = self.config.readColorEntry(key,TQColor(0,0,0))
self.customizableitems[item][0][key][1] = color
for key in self.customizableitems[item][1].keys():
size = self.config.readNumEntry(key,1)
self.customizableitems[item][1][key][1] = size
elif colorid == 1:
self.GetKdeColorScheme()
if not self.selecteditem:
self.__selectItem("Desktop")
else:
self.__selectItem(self.selecteditem)
def __selectColorSchemeByName(self,name):
""" Finds the index of name in colorschemes and calls the above function """
for i,colorname in enumerate(self.colorschemes):
if colorname == name:
self.__selectColorScheme(i)
break
def __selectFontSize(self,sizeid):
""" Selects a font size in the combo box """
self.currentfontsize = self.sizes[sizeid][0]
self.fontsizecombo.setCurrentItem(sizeid)
def __selectItem(self,item):
""" Sets the color and size settings boxes to those for item """
self.selecteditem = item
for i,item1 in enumerate(self.currentitems):
if item1 == item:
self.itemcombo.setCurrentItem(i)
if item == "Application Workspace":
key = "AppWorkSpace"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
self.colorsizehbox2.hide()
self.colorsizehbox3.hide()
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Buttons":
key = "ButtonFace"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
key = "WindowFrame"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox2.hide()
self.colorsizehbox2_layout.remove(self.sizespinbox2)
self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
self.colorcombo2.show()
self.colorcombo2.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo2.setName(key)
key = "ButtonShadow"
self.colorsizehbox3.show()
self.colorsizetext3.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox3.hide()
self.colorsizehbox3_layout.remove(self.sizespinbox3)
self.colorsizehbox3_layout.addWidget(self.colorcombo3,0,1)
self.colorcombo3.show()
self.colorcombo3.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo3.setName(key)
key = "ButtonDkShadow"
self.colorsizehbox4.show()
self.colorsizetext4.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox4.hide()
self.colorsizehbox4_layout.remove(self.sizespinbox4)
self.colorsizehbox4_layout.addWidget(self.colorcombo4,0,1)
self.colorcombo4.show()
self.colorcombo4.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo4.setName(key)
key = "ButtonLight"
self.colorsizehbox5.show()
self.colorsizetext5.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox5.hide()
self.colorsizehbox5_layout.remove(self.sizespinbox5)
self.colorsizehbox5_layout.addWidget(self.colorcombo5,0,1)
self.colorcombo5.show()
self.colorcombo5.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo5.setName(key)
key = "ButtonHilight"
self.colorsizehbox6.show()
self.colorsizetext6.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox6.hide()
self.colorsizehbox6_layout.remove(self.sizespinbox6)
self.colorsizehbox6_layout.addWidget(self.colorcombo6,0,1)
self.colorcombo6.show()
self.colorcombo6.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo6.setName(key)
key = "ButtonAlternateFace"
self.colorsizehbox7.show()
self.colorsizetext7.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox7.hide()
self.colorsizehbox7_layout.remove(self.sizespinbox7)
self.colorsizehbox7_layout.addWidget(self.colorcombo7,0,1)
self.colorcombo7.show()
self.colorcombo7.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo7.setName(key)
key = "ButtonText"
self.colorsizehbox8.show()
self.colorsizetext8.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox8.hide()
self.colorsizehbox8_layout.remove(self.sizespinbox8)
self.colorsizehbox8_layout.addWidget(self.colorcombo8,0,1)
self.colorcombo8.show()
self.colorcombo8.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo8.setName(key)
elif item == "Caption Buttons":
key = "CaptionHeight"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][1][key][0])
self.colorcombo1.hide()
self.colorsizehbox1_layout.remove(self.colorcombo1)
self.colorsizehbox1_layout.addWidget(self.sizespinbox1,0,1)
self.sizespinbox1.show()
self.sizespinbox1.setName(key)
self.sizespinbox1.setValue(\
self.customizableitems[item][1][key][1])
self.sizespinbox1.setMinValue(8)
self.sizespinbox1.setMaxValue(100)
key = "CaptionWidth"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][1][key][0])
self.colorcombo2.hide()
self.colorsizehbox2_layout.remove(self.colorcombo2)
self.colorsizehbox2_layout.addWidget(self.sizespinbox2,0,1)
self.sizespinbox2.show()
self.sizespinbox2.setName(key)
self.sizespinbox2.setValue(\
self.customizableitems[item][1][key][1])
self.sizespinbox2.setMinValue(8)
self.sizespinbox2.setMaxValue(100)
self.colorsizehbox3.hide()
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Desktop":
key = "Background"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
self.colorsizehbox2.hide()
self.colorsizehbox3.hide()
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Menu":
key = "Menu"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
key = "MenuBar"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox2.hide()
self.colorsizehbox2_layout.remove(self.sizespinbox2)
self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
self.colorcombo2.show()
self.colorcombo2.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo2.setName(key)
key = "MenuHilight"
self.colorsizehbox3.show()
self.colorsizetext3.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox3.hide()
self.colorsizehbox3_layout.remove(self.sizespinbox3)
self.colorsizehbox3_layout.addWidget(self.colorcombo3,0,1)
self.colorcombo3.show()
self.colorcombo3.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo3.setName(key)
key = "MenuText"
self.colorsizehbox4.show()
self.colorsizetext4.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox4.hide()
self.colorsizehbox4_layout.remove(self.sizespinbox4)
self.colorsizehbox4_layout.addWidget(self.colorcombo4,0,1)
self.colorcombo4.show()
self.colorcombo4.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo4.setName(key)
key = "MenuHeight"
self.colorsizehbox5.show()
self.colorsizetext5.setText(\
self.customizableitems[item][1][key][0])
self.colorcombo5.hide()
self.colorsizehbox5_layout.remove(self.colorcombo5)
self.colorsizehbox5_layout.addWidget(self.sizespinbox5,0,1)
self.sizespinbox5.show()
self.sizespinbox5.setName(key)
self.sizespinbox5.setValue(\
self.customizableitems[item][1][key][1])
self.sizespinbox5.setMinValue(15)
self.sizespinbox5.setMaxValue(100)
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Scrollbar":
key = "Scrollbar"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
key = "ScrollWidth"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][1][key][0])
self.colorcombo2.hide()
self.colorsizehbox2_layout.remove(self.colorcombo2)
self.colorsizehbox2_layout.addWidget(self.sizespinbox2,0,1)
self.sizespinbox2.show()
self.sizespinbox2.setName(key)
self.sizespinbox2.setValue(\
self.customizableitems[item][1][key][1])
self.sizespinbox2.setMinValue(8)
self.sizespinbox2.setMaxValue(100)
self.colorsizehbox3.hide()
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Selected Items":
key = "Hilight"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
key = "HilightText"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox2.hide()
self.colorsizehbox2_layout.remove(self.sizespinbox2)
self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
self.colorcombo2.show()
self.colorcombo2.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo2.setName(key)
self.colorsizehbox3.hide()
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Title Bar":
key = "ActiveTitle"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
key = "GradientActiveTitle"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox2.hide()
self.colorsizehbox2_layout.remove(self.sizespinbox2)
self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
self.colorcombo2.show()
self.colorcombo2.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo2.setName(key)
key = "InactiveTitle"
self.colorsizehbox3.show()
self.colorsizetext3.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox3.hide()
self.colorsizehbox3_layout.remove(self.sizespinbox3)
self.colorsizehbox3_layout.addWidget(self.colorcombo3,0,1)
self.colorcombo3.show()
self.colorcombo3.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo3.setName(key)
key = "GradientInactiveTitle"
self.colorsizehbox4.show()
self.colorsizetext4.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox4.hide()
self.colorsizehbox4_layout.remove(self.sizespinbox4)
self.colorsizehbox4_layout.addWidget(self.colorcombo4,0,1)
self.colorcombo4.show()
self.colorcombo4.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo4.setName(key)
key = "TitleText"
self.colorsizehbox5.show()
self.colorsizetext5.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox5.hide()
self.colorsizehbox5_layout.remove(self.sizespinbox5)
self.colorsizehbox5_layout.addWidget(self.colorcombo5,0,1)
self.colorcombo5.show()
self.colorcombo5.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo5.setName(key)
key = "InactiveTitleText"
self.colorsizehbox6.show()
self.colorsizetext6.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox6.hide()
self.colorsizehbox6_layout.remove(self.sizespinbox6)
self.colorsizehbox6_layout.addWidget(self.colorcombo6,0,1)
self.colorcombo6.show()
self.colorcombo6.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo6.setName(key)
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Window":
key = "Window"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
key = "WindowText"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox2.hide()
self.colorsizehbox2_layout.remove(self.sizespinbox2)
self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
self.colorcombo2.show()
self.colorcombo2.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo2.setName(key)
self.colorsizehbox3.hide()
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
elif item == "Window Border":
key = "ActiveBorder"
self.colorsizehbox1.show()
self.colorsizetext1.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox1.hide()
self.colorsizehbox1_layout.remove(self.sizespinbox1)
self.colorsizehbox1_layout.addWidget(self.colorcombo1,0,1)
self.colorcombo1.show()
self.colorcombo1.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo1.setName(key)
key = "InactiveBorder"
self.colorsizehbox2.show()
self.colorsizetext2.setText(\
self.customizableitems[item][0][key][0])
self.sizespinbox2.hide()
self.colorsizehbox2_layout.remove(self.sizespinbox2)
self.colorsizehbox2_layout.addWidget(self.colorcombo2,0,1)
self.colorcombo2.show()
self.colorcombo2.setColor(\
self.customizableitems[item][0][key][1])
self.colorcombo2.setName(key)
key = "BorderWidth"
self.colorsizehbox3.show()
self.colorsizetext3.setText(\
self.customizableitems[item][1][key][0])
self.colorcombo3.hide()
self.colorsizehbox3_layout.remove(self.colorcombo3)
self.colorsizehbox3_layout.addWidget(self.sizespinbox3,0,1)
self.sizespinbox3.show()
self.sizespinbox3.setName(key)
self.sizespinbox3.setValue(\
self.customizableitems[item][1][key][1])
self.sizespinbox3.setMinValue(1)
self.sizespinbox3.setMaxValue(50)
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
else:
# Shouldn't happen.
self.colorsizehbox1.hide()
self.colorsizehbox2.hide()
self.colorsizehbox3.hide()
self.colorsizehbox4.hide()
self.colorsizehbox5.hide()
self.colorsizehbox6.hide()
self.colorsizehbox7.hide()
self.colorsizehbox8.hide()
def setMargin(self,margin):
self.top_layout.setMargin(margin)
def setSpacing(self,spacing):
self.top_layout.setSpacing(spacing)
# --- Some default color schemes, with names ---
preset1 = (unicode(i18n("Purple")),
{"Window Border":
({"ActiveBorder":[unicode(i18n("Active Color:")),TQColor(239,239,239)],
"InactiveBorder":[unicode(i18n("Inactive Color:")),TQColor(239,239,239)]},
{"BorderWidth":[unicode(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
"Title Bar":
({"ActiveTitle":[unicode(i18n("Active Color:")),TQColor(91,86,168)],
"GradientActiveTitle":[unicode(i18n("Gradient:")),TQColor(136,118,202)],
"InactiveTitle":[unicode(i18n("Inactive Color:")),TQColor(223,225,230)],
"GradientInactiveTitle":[unicode(i18n("Gradient:")),TQColor(157,170,186)],
"TitleText":[unicode(i18n("Active Text:")),TQColor(255,255,255)],
"InactiveTitleText":[unicode(i18n("Inactive Text:")),TQColor(168,168,168)]},
{}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
"Application Workspace":
({"AppWorkSpace":[unicode(i18n("Background Color:")),TQColor(90,90,90)]},
{}), #AppWorkSpace "Background"
"Buttons":
({"ButtonFace":[unicode(i18n("Face:")),TQColor(238,239,242)],
"ButtonHilight":[unicode(i18n("Hilight:")),TQColor(255,255,255)],
"ButtonLight":[unicode(i18n("Light:")),TQColor(201,199,255)],
"ButtonShadow":[unicode(i18n("Shadow:")),TQColor(132,132,134)],
"ButtonText":[unicode(i18n("Text Color:")),TQColor(0,0,0)],
"ButtonAlternateFace":[unicode(i18n("Alternate Face:")),TQColor(238,239,242)],
"ButtonDkShadow":[unicode(i18n("Dark Shadow:")),TQColor(98,96,143)],
"WindowFrame":[unicode(i18n("Frame:")),TQColor(144,140,209)]},
{}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
"Caption Buttons":
({},
{"CaptionHeight":[unicode(i18n("Height:")),22],
"CaptionWidth":[unicode(i18n("Width:")),22]}), #Metrics: CaptionHeight, CaptionWidth
"Desktop":
({"Background":[unicode(i18n("Background:")),TQColor(146,127,188)]},
{}), #Background
"Menu":
({"Menu":[unicode(i18n("Menu Background:")),TQColor(250,251,254)],
"MenuBar":[unicode(i18n("Menu Bar Color:")),TQColor(238,239,242)],
"MenuHilight":[unicode(i18n("Menu Hilight:")),TQColor(144,140,209)],
"MenuText":[unicode(i18n("Text Color:")),TQColor(0,0,0)]},
{"MenuHeight":[unicode(i18n("Menu Bar Height:")),22]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
"Scrollbar":
({"Scrollbar":[unicode(i18n("Color:")),TQColor(238,239,242)]},
{"ScrollWidth":[unicode(i18n("Width:")),16]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
"Window":
({"Window":[unicode(i18n("Background:")),TQColor(255,255,255)],
"WindowText":[unicode(i18n("Text Color:")),TQColor(0,0,0)]},
{}), #Window "Background", WindowText
"Selected Items":
({"Hilight":[unicode(i18n("Hilight Color:")),TQColor(144,140,209)],
"HilightText":[unicode(i18n("Text Color:")),TQColor(255,255,255)]},
{})}) #Hilight, HilightText
preset2 = (unicode(i18n("Blue")),
{"Window Border":
({"ActiveBorder":[unicode(i18n("Active Color:")),TQColor(239,239,239)],
"InactiveBorder":[unicode(i18n("Inactive Color:")),TQColor(239,239,239)]},
{"BorderWidth":[unicode(i18n("Width:")),1]}), #ActiveBorder, InactiveBorder, metrics: BorderWidth
"Title Bar":
({"ActiveTitle":[unicode(i18n("Active Color:")),TQColor(0,113,201)],
"GradientActiveTitle":[unicode(i18n("Gradient:")),TQColor(87,161,219)],
"InactiveTitle":[unicode(i18n("Inactive Color:")),TQColor(191,191,191)],
"GradientInactiveTitle":[unicode(i18n("Gradient:")),TQColor(171,171,171)],
"TitleText":[unicode(i18n("Active Text:")),TQColor(255,255,255)],
"InactiveTitleText":[unicode(i18n("Inactive Text:")),TQColor(95,95,95)]},
{}), #ActiveTitle, GradientActiveTitle, InactiveTitle, GradientInactiveTitle, TitleText, InactiveTitleText
"Application Workspace":
({"AppWorkSpace":[unicode(i18n("Background Color:")),TQColor(90,90,90)]},
{}), #AppWorkSpace "Background"
"Buttons":
({"ButtonFace":[unicode(i18n("Face:")),TQColor(239,239,239)],
"ButtonHilight":[unicode(i18n("Hilight:")),TQColor(246,246,246)],
"ButtonLight":[unicode(i18n("Light:")),TQColor(191,207,251)],
"ButtonShadow":[unicode(i18n("Shadow:")),TQColor(148,148,153)],
"ButtonText":[unicode(i18n("Text Color:")),TQColor(0,0,0)],
"ButtonAlternateFace":[unicode(i18n("Alternate Face:")),TQColor(238,239,242)],
"ButtonDkShadow":[unicode(i18n("Dark Shadow:")),TQColor(50,101,146)],
"WindowFrame":[unicode(i18n("Frame:")),TQColor(74,149,214)]},
{}), #ButtonFace, ButtonHilight, ButtonLight, ButtonShadow, ButtonText, ButtonAlternateFace, ButtonDkShadow, WindowFrame
"Caption Buttons":
({},
{"CaptionHeight":[unicode(i18n("Height:")),22],
"CaptionWidth":[unicode(i18n("Width:")),22]}), #Metrics: CaptionHeight, CaptionWidth
"Desktop":
({"Background":[unicode(i18n("Background:")),TQColor(44,109,189)]},
{}), #Background
"Menu":
({"Menu":[unicode(i18n("Menu Background:")),TQColor(249,249,249)],
"MenuBar":[unicode(i18n("Menu Bar Color:")),TQColor(239,239,239)],
"MenuHilight":[unicode(i18n("Menu Hilight:")),TQColor(74,149,214)],
"MenuText":[unicode(i18n("Text Color:")),TQColor(0,0,0)]},
{"MenuHeight":[unicode(i18n("Menu Bar Height:")),22]}), #Menu (Background), MenuBar, MenuHilight, MenuText, metrics: MenuHeight, MenuWidth (does nothing)
"Scrollbar":
({"Scrollbar":[unicode(i18n("Color:")),TQColor(230,230,230)]},
{"ScrollWidth":[unicode(i18n("Width:")),16]}), #Scrollbar, metrics: ScrollHeight (does nothing), ScrollWidth
"Window":
({"Window":[unicode(i18n("Background:")),TQColor(255,255,255)],
"WindowText":[unicode(i18n("Text Color:")),TQColor(0,0,0)]},
{}), #Window "Background", WindowText
"Selected Items":
({"Hilight":[unicode(i18n("Hilight Color:")),TQColor(74,149,214)],
"HilightText":[unicode(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",\
unicode(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() + unicode(i18n(" (Native)"))
mailers.append((mailer,mailertr))
for mailer in wine:
if mailer and mailer[1] == ':':
mailer = mailer.lower()
mailertr = mailer[mailer.rfind('\\\\')+2:mailer.rfind('.exe')]
mailertr = mailertr.capitalize() + unicode(i18n(" (Windows, set by application)"))
else: # winebrowser
continue
mailers.append((mailer,mailertr))
return mailers
def slotListClicked(self,item):
""" Called when an application in the list is clicked """
for appid,appname in enumerate(self.applications):
if appname==item.text():
self.__selectApp(appid)
return
def slotAddClicked(self):
"""
Let the user choose a new application to change settings for
"""
app = KFileDialog.getOpenFileName(wineread.winepath + \
"/dosdevices/c:",\
"*.exe|" + unicode(i18n("Windows Executables (*.exe)")),self,i18n("Application"))
if app:
app = str(app).split('/')
app = app[-1]
self.applications.append(app)
self.updateAppsList()
for appid,appname in enumerate(self.applications):
if appname==app:
self.__selectApp(appid)
self.emit(PYSIGNAL("changedSignal()"), ())
def slotRemoveClicked(self):
""" Removes settings for selected application """
if KMessageBox.warningContinueCancel(self, \
i18n("This will remove all application specific settings for \n" +\
self.applications[self.selectedappid] +"\n" +\
"Do you want to proceed?"),\
i18n("Warning")) == KMessageBox.Continue:
del self.applications[self.selectedappid]
self.updateAppsList()
self.emit(PYSIGNAL("changedSignal()"), ())
def slotSettingsClicked(self):
"""
Launches a new wineconfig window for the selected application
"""
os.system("wineconfig " + self.applications[self.selectedappid])
def slotBrowserEdited(self,browser):
""" Sets the first browser to use to the one selected in the combo box """
self.currentbrowser = str(browser).strip()
self.emit(PYSIGNAL("changedSignal()"), ())
def slotBrowserActivated(self,browserid):
""" Sets the first browser to use to the one selected in the combo box """
self.currentbrowser = self.browsers[browserid][0]
self.emit(PYSIGNAL("changedSignal()"), ())
def slotBrowserClicked(self):
""" Sets the first browser to use to the one selected in the combo box """
browserdlg = KOpenWithDlg(self)
browserdlg.hideNoCloseOnExit()
browserdlg.hideRunInTerminal()
if browserdlg.exec_loop():#i18n("Choose a Web Browser"),self.currentbrowser)
self.__selectBrowser(str(browserdlg.text()))
self.emit(PYSIGNAL("changedSignal()"), ())
def slotMailerEdited(self,mailer):
""" Sets the first mailer to use to the one selected in the combo box """
self.currentmailer = str(mailer).strip()
self.emit(PYSIGNAL("changedSignal()"), ())
def slotMailerActivated(self,mailerid):
""" Sets the first browser to use to the one selected in the combo box """
self.currentmailer = self.mailers[mailerid][0]
self.emit(PYSIGNAL("changedSignal()"), ())
def slotMailerClicked(self):
""" Sets the first mailer to use to the one selected in the combo box """
mailerdlg = KOpenWithDlg(self)
mailerdlg.hideNoCloseOnExit()
mailerdlg.hideRunInTerminal()
if mailerdlg.exec_loop():#i18n("Choose a Web Browser"),self.currentbrowser)
self.__selectMailer(str(mailerdlg.text()))
self.emit(PYSIGNAL("changedSignal()"), ())
def fillCombo(self,combo,_list):
""" Fill the combobox with the values from our list
Uses the second value from each tuple """
for item in _list:
combo.insertItem(item[1])
def updateAppsList(self):
""" Updates the displayed list of applications """
self.appslist.clear()
self.applications.sort()
self.appslist.insertStringList(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 = [
unicode(i18n("Built-in (Wine)")),
unicode(i18n("Native (Windows)")),
unicode(i18n("Built-in then Native")),
unicode(i18n("Native then Built-in")),
unicode(i18n("Disable"))]
def __init__(self,parent = None,name = None,modal = 0,fl = 0):
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"),\
unicode(i18n("Load order for %s:")) % (unicode(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.iteritems():
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)