Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


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

1 files changed, 1070 insertions, 0 deletions

diff --git a/kcontrol/style/kcmstyle.cpp b/kcontrol/style/kcmstyle.cpp
new file mode 100644
index 000000000..9333c0f72
--- /dev/null
+++ b/kcontrol/style/kcmstyle.cpp
@@ -0,0 +1,1070 @@
+/*
+ * KCMStyle
+ * Copyright (C) 2002 Karol Szwed <gallium@kde.org>
+ * Copyright (C) 2002 Daniel Molkentin <molkentin@kde.org>
+ *
+ * Portions Copyright (C) 2000 TrollTech AS.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <qcheckbox.h>
+#include <kcombobox.h>
+#include <qlistbox.h>
+#include <qgroupbox.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qslider.h>
+#include <qstylefactory.h>
+#include <qtabwidget.h>
+#include <qvbox.h>
+#include <qfile.h>
+#include <qsettings.h>
+#include <qobjectlist.h>
+#include <qpixmapcache.h>
+#include <qwhatsthis.h>
+#include <qpushbutton.h>
+
+#include <dcopclient.h>
+#include <kapplication.h>
+#include <kglobalsettings.h>
+#include <kdebug.h>
+#include <kipc.h>
+#include <kaboutdata.h>
+#include <kdialog.h>
+#include <klibloader.h>
+#include <klistview.h>
+#include <kmessagebox.h>
+#include <ksimpleconfig.h>
+#include <kstyle.h>
+#include <kstandarddirs.h>
+
+#include "../krdb/krdb.h"
+
+#include "kcmstyle.h"
+#include "styleconfdialog.h"
+
+#include <X11/Xlib.h>
+// X11 namespace cleanup
+#undef Below
+#undef KeyPress
+#undef KeyRelease
+
+
+/**** DLL Interface for kcontrol ****/
+
+// Plugin Interface
+// Danimo: Why do we use the old interface?!
+extern "C"
+{
+    KDE_EXPORT KCModule *create_style(QWidget *parent, const char*)
+    {
+        KGlobal::locale()->insertCatalogue("kcmstyle");
+        return new KCMStyle(parent, "kcmstyle");
+    }
+
+    KDE_EXPORT void init_style()
+    {
+        uint flags = KRdbExportQtSettings | KRdbExportQtColors | KRdbExportXftSettings;
+        KConfig config("kcmdisplayrc", true /*readonly*/, false /*don't read kdeglobals etc.*/);
+        config.setGroup("X11");
+
+        // This key is written by the "colors" module.
+        bool exportKDEColors = config.readBoolEntry("exportKDEColors", true);
+        if (exportKDEColors)
+            flags |= KRdbExportColors;
+        runRdb( flags );
+
+        // Write some Qt root property.
+#ifndef __osf__      // this crashes under Tru64 randomly -- will fix later
+        QByteArray properties;
+        QDataStream d(properties, IO_WriteOnly);
+        d.setVersion( 3 );      // Qt2 apps need this.
+        d << kapp->palette() << KGlobalSettings::generalFont();
+        Atom a = XInternAtom(qt_xdisplay(), "_QT_DESKTOP_PROPERTIES", false);
+
+        // do it for all root windows - multihead support
+        int screen_count = ScreenCount(qt_xdisplay());
+        for (int i = 0; i < screen_count; i++)
+            XChangeProperty(qt_xdisplay(),  RootWindow(qt_xdisplay(), i),
+                            a, a, 8, PropModeReplace,
+                            (unsigned char*) properties.data(), properties.size());
+#endif
+    }
+}
+
+/*
+typedef KGenericFactory<KWidgetSettingsModule, QWidget> GeneralFactory;
+K_EXPORT_COMPONENT_FACTORY( kcm_kcmstyle, GeneralFactory )
+*/
+
+
+KCMStyle::KCMStyle( QWidget* parent, const char* name )
+	: KCModule( parent, name ), appliedStyle(NULL)
+{
+    setQuickHelp( i18n("<h1>Style</h1>"
+			"This module allows you to modify the visual appearance "
+			"of user interface elements, such as the widget style "
+			"and effects."));
+
+	m_bEffectsDirty = false;
+	m_bStyleDirty= false;
+	m_bToolbarsDirty = false;
+
+	KGlobal::dirs()->addResourceType("themes",
+		KStandardDirs::kde_default("data") + "kstyle/themes");
+
+	KAboutData *about =
+		new KAboutData( I18N_NOOP("kcmstyle"),
+						I18N_NOOP("KDE Style Module"),
+						0, 0, KAboutData::License_GPL,
+						I18N_NOOP("(c) 2002 Karol Szwed, Daniel Molkentin"));
+
+	about->addAuthor("Karol Szwed", 0, "gallium@kde.org");
+	about->addAuthor("Daniel Molkentin", 0, "molkentin@kde.org");
+	about->addAuthor("Ralf Nolden", 0, "nolden@kde.org");
+	setAboutData( about );
+
+	// Setup pages and mainLayout
+	mainLayout = new QVBoxLayout( this );
+	tabWidget  = new QTabWidget( this );
+	mainLayout->addWidget( tabWidget );
+
+	page1 = new QWidget( tabWidget );
+	page1Layout = new QVBoxLayout( page1, KDialog::marginHint(), KDialog::spacingHint() );
+	page2 = new QWidget( tabWidget );
+	page2Layout = new QVBoxLayout( page2, KDialog::marginHint(), KDialog::spacingHint() );
+	page3 = new QWidget( tabWidget );
+	page3Layout = new QVBoxLayout( page3, KDialog::marginHint(), KDialog::spacingHint() );
+
+	// Add Page1 (Style)
+	// -----------------
+	gbWidgetStyle = new QGroupBox( i18n("Widget Style"), page1, "gbWidgetStyle" );
+	gbWidgetStyle->setColumnLayout( 0, Qt::Vertical );
+	gbWidgetStyle->layout()->setMargin( KDialog::marginHint() );
+	gbWidgetStyle->layout()->setSpacing( KDialog::spacingHint() );
+
+	gbWidgetStyleLayout = new QVBoxLayout( gbWidgetStyle->layout() );
+	gbWidgetStyleLayout->setAlignment( Qt::AlignTop );
+	hbLayout = new QHBoxLayout( KDialog::spacingHint(), "hbLayout" );
+
+	cbStyle = new KComboBox( gbWidgetStyle, "cbStyle" );
+	cbStyle->setEditable( FALSE );
+	hbLayout->addWidget( cbStyle );
+
+	pbConfigStyle = new QPushButton( i18n("Con&figure..."), gbWidgetStyle );
+	pbConfigStyle->setSizePolicy( QSizePolicy::Maximum, QSizePolicy::Minimum );
+	pbConfigStyle->setEnabled( FALSE );
+	hbLayout->addWidget( pbConfigStyle );
+
+	gbWidgetStyleLayout->addLayout( hbLayout );
+
+	lblStyleDesc = new QLabel( gbWidgetStyle );
+	lblStyleDesc->setTextFormat(Qt::RichText);
+	gbWidgetStyleLayout->addWidget( lblStyleDesc );
+
+	cbIconsOnButtons = new QCheckBox( i18n("Sho&w icons on buttons"), gbWidgetStyle );
+	gbWidgetStyleLayout->addWidget( cbIconsOnButtons );
+	cbEnableTooltips = new QCheckBox( i18n("E&nable tooltips"), gbWidgetStyle );
+	gbWidgetStyleLayout->addWidget( cbEnableTooltips );
+	cbTearOffHandles = new QCheckBox( i18n("Show tear-off handles in &popup menus"), gbWidgetStyle );
+	gbWidgetStyleLayout->addWidget( cbTearOffHandles );
+	cbTearOffHandles->hide(); // reenable when the corresponding Qt method is virtual and properly reimplemented
+
+    QGroupBox *gbPreview = new QGroupBox( i18n( "Preview" ), page1 );
+	gbPreview->setColumnLayout( 0, Vertical );
+	gbPreview->layout()->setMargin( 0 );
+	gbPreview->layout()->setSpacing( KDialog::spacingHint() );
+	gbPreview->setFlat( true );
+	stylePreview = new StylePreview( gbPreview );
+	gbPreview->layout()->add( stylePreview );
+
+	page1Layout->addWidget( gbWidgetStyle );
+	page1Layout->addWidget( gbPreview );
+
+	// Connect all required stuff
+	connect( cbStyle, SIGNAL(activated(int)), this, SLOT(styleChanged()) );
+	connect( cbStyle, SIGNAL(activated(int)), this, SLOT(updateConfigButton()));
+	connect( pbConfigStyle, SIGNAL(clicked()), this, SLOT(styleSpecificConfig()));
+
+	// Add Page2 (Effects)
+	// -------------------
+	cbEnableEffects = new QCheckBox( i18n("&Enable GUI effects"), page2 );
+	containerFrame = new QFrame( page2 );
+	containerFrame->setFrameStyle( QFrame::NoFrame | QFrame::Plain );
+	containerFrame->setMargin(0);
+	containerLayout = new QGridLayout( containerFrame, 1, 1,	// rows, columns
+		KDialog::marginHint(), KDialog::spacingHint() );
+
+	comboComboEffect = new QComboBox( FALSE, containerFrame );
+	comboComboEffect->insertItem( i18n("Disable") );
+	comboComboEffect->insertItem( i18n("Animate") );
+	lblComboEffect = new QLabel( i18n("Combobo&x effect:"), containerFrame );
+	lblComboEffect->setBuddy( comboComboEffect );
+	containerLayout->addWidget( lblComboEffect, 0, 0 );
+	containerLayout->addWidget( comboComboEffect, 0, 1 );
+
+	comboTooltipEffect = new QComboBox( FALSE, containerFrame );
+	comboTooltipEffect->insertItem( i18n("Disable") );
+	comboTooltipEffect->insertItem( i18n("Animate") );
+	comboTooltipEffect->insertItem( i18n("Fade") );
+	lblTooltipEffect = new QLabel( i18n("&Tool tip effect:"), containerFrame );
+	lblTooltipEffect->setBuddy( comboTooltipEffect );
+	containerLayout->addWidget( lblTooltipEffect, 1, 0 );
+	containerLayout->addWidget( comboTooltipEffect, 1, 1 );
+
+	comboMenuEffect = new QComboBox( FALSE, containerFrame );
+	comboMenuEffect->insertItem( i18n("Disable") );
+	comboMenuEffect->insertItem( i18n("Animate") );
+	comboMenuEffect->insertItem( i18n("Fade") );
+	comboMenuEffect->insertItem( i18n("Make Translucent") );
+	lblMenuEffect = new QLabel( i18n("&Menu effect:"), containerFrame );
+	lblMenuEffect->setBuddy( comboMenuEffect );
+	containerLayout->addWidget( lblMenuEffect, 2, 0 );
+	containerLayout->addWidget( comboMenuEffect, 2, 1 );
+
+	comboMenuHandle = new QComboBox( FALSE, containerFrame );
+	comboMenuHandle->insertItem( i18n("Disable") );
+	comboMenuHandle->insertItem( i18n("Application Level") );
+//	comboMenuHandle->insertItem( i18n("Enable") );
+	lblMenuHandle = new QLabel( i18n("Me&nu tear-off handles:"), containerFrame );
+	lblMenuHandle->setBuddy( comboMenuHandle );
+	containerLayout->addWidget( lblMenuHandle, 3, 0 );
+	containerLayout->addWidget( comboMenuHandle, 3, 1 );
+
+	cbMenuShadow = new QCheckBox( i18n("Menu &drop shadow"), containerFrame );
+	containerLayout->addWidget( cbMenuShadow, 4, 0 );
+
+	// Push the [label combo] to the left.
+	comboSpacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
+	containerLayout->addItem( comboSpacer, 1, 2 );
+
+	// Separator.
+	QFrame* hline = new QFrame ( page2 );
+	hline->setFrameStyle( QFrame::HLine | QFrame::Sunken );
+
+	// Now implement the Menu Transparency container.
+	menuContainer = new QFrame( page2 );
+	menuContainer->setFrameStyle( QFrame::NoFrame | QFrame::Plain );
+	menuContainer->setMargin(0);
+	menuContainerLayout = new QGridLayout( menuContainer, 1, 1,    // rows, columns
+		KDialog::marginHint(), KDialog::spacingHint() );
+
+	menuPreview = new MenuPreview( menuContainer, /* opacity */ 90, MenuPreview::Blend );
+
+	comboMenuEffectType = new QComboBox( FALSE, menuContainer );
+	comboMenuEffectType->insertItem( i18n("Software Tint") );
+	comboMenuEffectType->insertItem( i18n("Software Blend") );
+#ifdef HAVE_XRENDER
+	comboMenuEffectType->insertItem( i18n("XRender Blend") );
+#endif
+
+	// So much stuffing around for a simple slider..
+	sliderBox = new QVBox( menuContainer );
+	sliderBox->setSpacing( KDialog::spacingHint() );
+	sliderBox->setMargin( 0 );
+	slOpacity = new QSlider( 0, 100, 5, /*opacity*/ 90, Qt::Horizontal, sliderBox );
+	slOpacity->setTickmarks( QSlider::Below );
+	slOpacity->setTickInterval( 10 );
+	QHBox* box1 = new QHBox( sliderBox );
+	box1->setSpacing( KDialog::spacingHint() );
+	box1->setMargin( 0 );
+	QLabel* lbl = new QLabel( i18n("0%"), box1 );
+	lbl->setAlignment( AlignLeft );
+	lbl = new QLabel( i18n("50%"), box1 );
+	lbl->setAlignment( AlignHCenter );
+	lbl = new QLabel( i18n("100%"), box1 );
+	lbl->setAlignment( AlignRight );
+
+	lblMenuEffectType = new QLabel( comboMenuEffectType, i18n("Menu trans&lucency type:"), menuContainer );
+	lblMenuEffectType->setAlignment( AlignBottom | AlignLeft );
+	lblMenuOpacity    = new QLabel( slOpacity, i18n("Menu &opacity:"), menuContainer );
+	lblMenuOpacity->setAlignment( AlignBottom | AlignLeft );
+
+	menuContainerLayout->addWidget( lblMenuEffectType, 0, 0 );
+	menuContainerLayout->addWidget( comboMenuEffectType, 1, 0 );
+	menuContainerLayout->addWidget( lblMenuOpacity, 2, 0 );
+	menuContainerLayout->addWidget( sliderBox, 3, 0 );
+	menuContainerLayout->addMultiCellWidget( menuPreview, 0, 3, 1, 1 );
+
+	// Layout page2.
+	page2Layout->addWidget( cbEnableEffects );
+	page2Layout->addWidget( containerFrame );
+	page2Layout->addWidget( hline );
+	page2Layout->addWidget( menuContainer );
+
+	QSpacerItem* sp1 = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding );
+	page2Layout->addItem( sp1 );
+
+	// Data flow stuff.
+	connect( cbEnableEffects,     SIGNAL(toggled(bool)), containerFrame, SLOT(setEnabled(bool)) );
+	connect( cbEnableEffects,     SIGNAL(toggled(bool)), this, SLOT(menuEffectChanged(bool)) );
+	connect( slOpacity,           SIGNAL(valueChanged(int)),menuPreview, SLOT(setOpacity(int)) );
+	connect( comboMenuEffect,     SIGNAL(activated(int)), this, SLOT(menuEffectChanged()) );
+	connect( comboMenuEffect,     SIGNAL(highlighted(int)), this, SLOT(menuEffectChanged()) );
+	connect( comboMenuEffectType, SIGNAL(activated(int)), this, SLOT(menuEffectTypeChanged()) );
+	connect( comboMenuEffectType, SIGNAL(highlighted(int)), this, SLOT(menuEffectTypeChanged()) );
+
+	// Add Page3 (Miscellaneous)
+	// -------------------------
+	cbHoverButtons = new QCheckBox( i18n("High&light buttons under mouse"), page3 );
+	cbTransparentToolbars = new QCheckBox( i18n("Transparent tool&bars when moving"), page3 );
+
+	QWidget * dummy = new QWidget( page3 );
+	
+	QHBoxLayout* box2 = new QHBoxLayout( dummy, 0, KDialog::spacingHint() );
+	lbl = new QLabel( i18n("Text pos&ition:"), dummy );
+	comboToolbarIcons = new QComboBox( FALSE, dummy );
+	comboToolbarIcons->insertItem( i18n("Icons Only") );
+	comboToolbarIcons->insertItem( i18n("Text Only") );
+	comboToolbarIcons->insertItem( i18n("Text Alongside Icons") );
+	comboToolbarIcons->insertItem( i18n("Text Under Icons") );
+	lbl->setBuddy( comboToolbarIcons );
+
+	box2->addWidget( lbl );
+	box2->addWidget( comboToolbarIcons );
+	QSpacerItem* sp2 = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
+	box2->addItem( sp2 );
+	
+	page3Layout->addWidget( cbHoverButtons );
+	page3Layout->addWidget( cbTransparentToolbars );
+	page3Layout->addWidget( dummy );
+	
+	// Layout page3.
+	QSpacerItem* sp3 = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding );
+	page3Layout->addItem( sp3 );
+
+	// Load settings
+	load();
+
+	// Do all the setDirty connections.
+	connect(cbStyle, SIGNAL(activated(int)), this, SLOT(setStyleDirty()));
+	// Page2
+	connect( cbEnableEffects,     SIGNAL(toggled(bool)),    this, SLOT(setEffectsDirty()));
+	connect( cbEnableEffects,     SIGNAL(toggled(bool)),    this, SLOT(setStyleDirty()));
+	connect( comboTooltipEffect,  SIGNAL(activated(int)), this, SLOT(setEffectsDirty()));
+	connect( comboComboEffect,    SIGNAL(activated(int)), this, SLOT(setEffectsDirty()));
+	connect( comboMenuEffect,     SIGNAL(activated(int)), this, SLOT(setStyleDirty()));
+	connect( comboMenuHandle,     SIGNAL(activated(int)), this, SLOT(setStyleDirty()));
+	connect( comboMenuEffectType, SIGNAL(activated(int)), this, SLOT(setStyleDirty()));
+	connect( slOpacity,           SIGNAL(valueChanged(int)),this, SLOT(setStyleDirty()));
+	connect( cbMenuShadow,        SIGNAL(toggled(bool)),    this, SLOT(setStyleDirty()));
+	// Page3
+	connect( cbHoverButtons,        SIGNAL(toggled(bool)),    this, SLOT(setToolbarsDirty()));
+	connect( cbTransparentToolbars, SIGNAL(toggled(bool)),    this, SLOT(setToolbarsDirty()));
+	connect( cbEnableTooltips,      SIGNAL(toggled(bool)),    this, SLOT(setEffectsDirty()));
+	connect( cbIconsOnButtons,      SIGNAL(toggled(bool)),    this, SLOT(setEffectsDirty()));
+	connect( cbTearOffHandles,      SIGNAL(toggled(bool)),    this, SLOT(setEffectsDirty()));
+	connect( comboToolbarIcons,     SIGNAL(activated(int)), this, SLOT(setToolbarsDirty()));
+
+	addWhatsThis();
+
+	// Insert the pages into the tabWidget
+	tabWidget->insertTab( page1, i18n("&Style"));
+	tabWidget->insertTab( page2, i18n("&Effects"));
+	tabWidget->insertTab( page3, i18n("&Toolbar"));
+
+	//Enable/disable the button for the initial style
+	updateConfigButton();
+}
+
+
+KCMStyle::~KCMStyle()
+{
+	delete appliedStyle;
+}
+
+void KCMStyle::updateConfigButton()
+{
+	if (!styleEntries[currentStyle()] || styleEntries[currentStyle()]->configPage.isEmpty()) {
+		pbConfigStyle->setEnabled(false);
+		return;
+	}
+
+	// We don't check whether it's loadable here -
+	// lets us report an error and not waste time
+	// loading things if the user doesn't click the button
+	pbConfigStyle->setEnabled( true );
+}
+
+void KCMStyle::styleSpecificConfig()
+{
+	QString libname = styleEntries[currentStyle()]->configPage;
+
+	// Use KLibLoader to get the library, handling
+	// any errors that arise
+	KLibLoader* loader = KLibLoader::self();
+
+	KLibrary* library = loader->library( QFile::encodeName(libname) );
+	if (!library)
+	{
+		KMessageBox::detailedError(this,
+			i18n("There was an error loading the configuration dialog for this style."),
+			loader->lastErrorMessage(),
+			i18n("Unable to Load Dialog"));
+		return;
+	}
+
+	void* allocPtr = library->symbol("allocate_kstyle_config");
+
+	if (!allocPtr)
+	{
+		KMessageBox::detailedError(this,
+			i18n("There was an error loading the configuration dialog for this style."),
+			loader->lastErrorMessage(),
+			i18n("Unable to Load Dialog"));
+		return;
+	}
+
+	//Create the container dialog
+	StyleConfigDialog* dial = new StyleConfigDialog(this, styleEntries[currentStyle()]->name);
+	dial->enableButtonSeparator(true);
+
+	typedef QWidget*(* factoryRoutine)( QWidget* parent );
+
+	//Get the factory, and make the widget.
+	factoryRoutine factory      = (factoryRoutine)(allocPtr); //Grmbl. So here I am on my
+	//"never use C casts" moralizing streak, and I find that one can't go void* -> function ptr
+	//even with a reinterpret_cast.
+
+	QWidget*       pluginConfig = factory( dial );
+
+	//Insert it in...
+	dial->setMainWidget( pluginConfig );
+
+	//..and connect it to the wrapper
+	connect(pluginConfig, SIGNAL(changed(bool)), dial, SLOT(setDirty(bool)));
+	connect(dial, SIGNAL(defaults()), pluginConfig, SLOT(defaults()));
+	connect(dial, SIGNAL(save()), pluginConfig, SLOT(save()));
+
+	if (dial->exec() == QDialog::Accepted  && dial->isDirty() ) {
+		// Force re-rendering of the preview, to apply settings
+		switchStyle(currentStyle(), true);
+
+		//For now, ask all KDE apps to recreate their styles to apply the setitngs
+		KIPC::sendMessageAll(KIPC::StyleChanged);
+
+		// We call setStyleDirty here to make sure we force style re-creation
+		setStyleDirty();
+	}
+
+	delete dial;
+}
+
+void KCMStyle::load()
+{
+   load( false );
+}
+
+void KCMStyle::load(bool useDefaults)
+{
+	KConfig config( "kdeglobals", true, false );
+
+	config.setReadDefaults( useDefaults );
+
+	// Page1 - Build up the Style ListBox
+	loadStyle( config );
+
+	// Page2 - Effects
+	loadEffects( config );
+
+	// Page3 - Misc.
+	loadMisc( config );
+
+	m_bEffectsDirty = false;
+	m_bStyleDirty= false;
+	m_bToolbarsDirty = false;
+
+	emit changed( useDefaults );
+}
+
+
+void KCMStyle::save()
+{
+	// Don't do anything if we don't need to.
+	if ( !(m_bToolbarsDirty | m_bEffectsDirty | m_bStyleDirty ) )
+		return;
+
+	bool allowMenuTransparency = false;
+	bool allowMenuDropShadow   = false;
+
+	// Read the KStyle flags to see if the style writer
+	// has enabled menu translucency in the style.
+	if (appliedStyle && appliedStyle->inherits("KStyle"))
+	{
+		allowMenuDropShadow = true;
+		KStyle* style = dynamic_cast<KStyle*>(appliedStyle);
+		if (style) {
+			KStyle::KStyleFlags flags = style->styleFlags();
+			if (flags & KStyle::AllowMenuTransparency)
+				allowMenuTransparency = true;
+		}
+	}
+
+	QString warn_string( i18n("<qt>Selected style: <b>%1</b><br><br>"
+		"One or more effects that you have chosen could not be applied because the selected "
+		"style does not support them; they have therefore been disabled.<br>"
+		"<br>" ).arg( cbStyle->currentText()) );
+	bool show_warning = false;
+
+	// Warn the user if they're applying a style that doesn't support
+	// menu translucency and they enabled it.
+    if ( (!allowMenuTransparency) &&
+		(cbEnableEffects->isChecked()) &&
+		(comboMenuEffect->currentItem() == 3) )	// Make Translucent
+    {
+		warn_string += i18n("Menu translucency is not available.<br>");
+		comboMenuEffect->setCurrentItem(0);    // Disable menu effect.
+		show_warning = true;
+	}
+
+	if (!allowMenuDropShadow && cbMenuShadow->isChecked())
+	{
+		warn_string += i18n("Menu drop-shadows are not available.");
+		cbMenuShadow->setChecked(false);
+		show_warning = true;
+	}
+
+	// Tell the user what features we could not apply on their behalf.
+	if (show_warning)
+		KMessageBox::information(this, warn_string);
+
+
+	// Save effects.
+	KConfig config( "kdeglobals" );
+	config.setGroup("KDE");
+
+	config.writeEntry( "EffectsEnabled", cbEnableEffects->isChecked());
+	int item = comboComboEffect->currentItem();
+	config.writeEntry( "EffectAnimateCombo", item == 1 );
+	item = comboTooltipEffect->currentItem();
+	config.writeEntry( "EffectAnimateTooltip", item == 1);
+	config.writeEntry( "EffectFadeTooltip", item == 2 );
+	item = comboMenuHandle->currentItem();
+	config.writeEntry( "InsertTearOffHandle", item );
+	item = comboMenuEffect->currentItem();
+	config.writeEntry( "EffectAnimateMenu", item == 1 );
+	config.writeEntry( "EffectFadeMenu", item == 2 );
+
+	// Handle KStyle's menu effects
+	QString engine("Disabled");
+	if (item == 3 && cbEnableEffects->isChecked())	// Make Translucent
+		switch( comboMenuEffectType->currentItem())
+		{
+			case 1: engine = "SoftwareBlend"; break;
+			case 2: engine = "XRender"; break;
+			default:
+			case 0: engine = "SoftwareTint"; break;
+		}
+
+	{	// Braces force a QSettings::sync()
+		QSettings settings;	// Only for KStyle stuff
+		settings.writeEntry("/KStyle/Settings/MenuTransparencyEngine", engine);
+		settings.writeEntry("/KStyle/Settings/MenuOpacity", slOpacity->value()/100.0);
+ 		settings.writeEntry("/KStyle/Settings/MenuDropShadow",
+					   		cbEnableEffects->isChecked() && cbMenuShadow->isChecked() );
+	}
+
+	// Misc page
+	config.writeEntry( "ShowIconsOnPushButtons", cbIconsOnButtons->isChecked(), true, true );
+	config.writeEntry( "EffectNoTooltip", !cbEnableTooltips->isChecked(), true, true );
+
+	config.setGroup("General");
+	config.writeEntry( "widgetStyle", currentStyle() );
+
+	config.setGroup("Toolbar style");
+	config.writeEntry( "Highlighting", cbHoverButtons->isChecked(), true, true );
+	config.writeEntry( "TransparentMoving", cbTransparentToolbars->isChecked(), true, true );
+	QString tbIcon;
+	switch( comboToolbarIcons->currentItem() )
+	{
+		case 1: tbIcon = "TextOnly"; break;
+		case 2: tbIcon = "IconTextRight"; break;
+		case 3: tbIcon = "IconTextBottom"; break;
+		case 0:
+		default: tbIcon = "IconOnly"; break;
+	}
+	config.writeEntry( "IconText", tbIcon, true, true );
+	config.sync();
+
+	// Export the changes we made to qtrc, and update all qt-only
+	// applications on the fly, ensuring that we still follow the user's
+	// export fonts/colors settings.
+	if (m_bStyleDirty | m_bEffectsDirty)	// Export only if necessary
+	{
+		uint flags = KRdbExportQtSettings;
+		KConfig kconfig("kcmdisplayrc", true /*readonly*/, false /*no globals*/);
+		kconfig.setGroup("X11");
+		bool exportKDEColors = kconfig.readBoolEntry("exportKDEColors", true);
+		if (exportKDEColors)
+			flags |= KRdbExportColors;
+		runRdb( flags );
+	}
+
+	// Now allow KDE apps to reconfigure themselves.
+	if ( m_bStyleDirty )
+		KIPC::sendMessageAll(KIPC::StyleChanged);
+
+	if ( m_bToolbarsDirty )
+		// ##### FIXME - Doesn't apply all settings correctly due to bugs in
+		// KApplication/KToolbar
+		KIPC::sendMessageAll(KIPC::ToolbarStyleChanged);
+
+	if (m_bEffectsDirty) {
+		KIPC::sendMessageAll(KIPC::SettingsChanged);
+		kapp->dcopClient()->send("kwin*", "", "reconfigure()", "");
+	}
+        //update kicker to re-used tooltips kicker parameter otherwise, it overwritted
+        //by style tooltips parameters.
+        QByteArray data;
+        kapp->dcopClient()->send( "kicker", "kicker", "configure()", data );
+
+	// Clean up
+	m_bEffectsDirty  = false;
+	m_bToolbarsDirty = false;
+	m_bStyleDirty    = false;
+	emit changed( false );
+}
+
+
+bool KCMStyle::findStyle( const QString& str, int& combobox_item )
+{
+	StyleEntry* se   = styleEntries.find(str.lower());
+
+	QString     name = se ? se->name : str;
+
+	combobox_item = 0;
+
+	//look up name
+	for( int i = 0; i < cbStyle->count(); i++ )
+	{
+		if ( cbStyle->text(i) == name )
+		{
+			combobox_item = i;
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+
+void KCMStyle::defaults()
+{
+   load( true );
+}
+
+void KCMStyle::setEffectsDirty()
+{
+	m_bEffectsDirty = true;
+	emit changed(true);
+}
+
+void KCMStyle::setToolbarsDirty()
+{
+	m_bToolbarsDirty = true;
+	emit changed(true);
+}
+
+void KCMStyle::setStyleDirty()
+{
+	m_bStyleDirty = true;
+	emit changed(true);
+}
+
+// ----------------------------------------------------------------
+// All the Style Switching / Preview stuff
+// ----------------------------------------------------------------
+
+void KCMStyle::loadStyle( KConfig& config )
+{
+	cbStyle->clear();
+
+	// Create a dictionary of WidgetStyle to Name and Desc. mappings,
+	// as well as the config page info
+	styleEntries.clear();
+	styleEntries.setAutoDelete(true);
+
+	QString strWidgetStyle;
+	QStringList list = KGlobal::dirs()->findAllResources("themes", "*.themerc", true, true);
+	for (QStringList::iterator it = list.begin(); it != list.end(); ++it)
+	{
+		KSimpleConfig config( *it, true );
+		if ( !(config.hasGroup("KDE") && config.hasGroup("Misc")) )
+			continue;
+
+		config.setGroup("KDE");
+
+		strWidgetStyle = config.readEntry("WidgetStyle");
+		if (strWidgetStyle.isNull())
+			continue;
+
+		// We have a widgetstyle, so lets read the i18n entries for it...
+		StyleEntry* entry = new StyleEntry;
+		config.setGroup("Misc");
+		entry->name = config.readEntry("Name");
+		entry->desc = config.readEntry("Comment", i18n("No description available."));
+		entry->configPage = config.readEntry("ConfigPage", QString::null);
+
+		// Check if this style should be shown
+		config.setGroup("Desktop Entry");
+		entry->hidden = config.readBoolEntry("Hidden", false);
+
+		// Insert the entry into our dictionary.
+		styleEntries.insert(strWidgetStyle.lower(), entry);
+	}
+
+	// Obtain all style names
+	QStringList allStyles = QStyleFactory::keys();
+
+	// Get translated names, remove all hidden style entries.
+	QStringList styles;
+	StyleEntry* entry;
+	for (QStringList::iterator it = allStyles.begin(); it != allStyles.end(); it++)
+	{
+		QString id = (*it).lower();
+		// Find the entry.
+		if ( (entry = styleEntries.find(id)) != 0 )
+		{
+			// Do not add hidden entries
+			if (entry->hidden)
+				continue;
+
+			styles += entry->name;
+
+			nameToStyleKey[entry->name] = id;
+		}
+		else
+		{
+			styles += (*it); //Fall back to the key (but in original case)
+			nameToStyleKey[*it] = id;
+		}
+	}
+
+	// Sort the style list, and add it to the combobox
+	styles.sort();
+	cbStyle->insertStringList( styles );
+
+	// Find out which style is currently being used
+	config.setGroup( "General" );
+	QString defaultStyle = KStyle::defaultStyle();
+	QString cfgStyle = config.readEntry( "widgetStyle", defaultStyle );
+
+	// Select the current style
+	// Do not use cbStyle->listBox() as this may be NULL for some styles when
+	// they use QPopupMenus for the drop-down list!
+
+	// ##### Since Trolltech likes to seemingly copy & paste code,
+	// QStringList::findItem() doesn't have a Qt::StringComparisonMode field.
+	// We roll our own (yuck)
+	cfgStyle = cfgStyle.lower();
+	int item = 0;
+	for( int i = 0; i < cbStyle->count(); i++ )
+	{
+		QString id = nameToStyleKey[cbStyle->text(i)];
+		item = i;
+		if ( id == cfgStyle )	// ExactMatch
+			break;
+		else if ( id.contains( cfgStyle ) )
+			break;
+		else if ( id.contains( QApplication::style().className() ) )
+			break;
+		item = 0;
+	}
+	cbStyle->setCurrentItem( item );
+
+	m_bStyleDirty = false;
+
+	switchStyle( currentStyle() );	// make resets visible
+}
+
+QString KCMStyle::currentStyle()
+{
+	return nameToStyleKey[cbStyle->currentText()];
+}
+
+
+void KCMStyle::styleChanged()
+{
+	switchStyle( currentStyle() );
+}
+
+
+void KCMStyle::switchStyle(const QString& styleName, bool force)
+{
+	// Don't flicker the preview if the same style is chosen in the cb
+	if (!force && appliedStyle && appliedStyle->name() == styleName) 
+		return;
+         
+	// Create an instance of the new style...
+	QStyle* style = QStyleFactory::create(styleName);
+	if (!style)
+		return;
+
+	// Prevent Qt from wrongly caching radio button images
+	QPixmapCache::clear();
+
+	setStyleRecursive( stylePreview, style );
+
+	// this flickers, but reliably draws the widgets correctly.
+	stylePreview->resize( stylePreview->sizeHint() );
+
+	delete appliedStyle;
+	appliedStyle = style;
+
+	// Set the correct style description
+	StyleEntry* entry = styleEntries.find( styleName );
+	QString desc;
+	desc = i18n("Description: %1").arg( entry ? entry->desc : i18n("No description available.") );
+	lblStyleDesc->setText( desc );
+}
+
+void KCMStyle::setStyleRecursive(QWidget* w, QStyle* s)
+{
+	// Don't let broken styles kill the palette
+	// for other styles being previewed. (e.g SGI style)
+	w->unsetPalette();
+
+	QPalette newPalette(KApplication::createApplicationPalette());
+	s->polish( newPalette );
+	w->setPalette(newPalette);
+
+	// Apply the new style.
+	w->setStyle(s);
+
+	// Recursively update all children.
+	const QObjectList *children = w->children();
+	if (!children)
+		return;
+
+	// Apply the style to each child widget.
+	QPtrListIterator<QObject> childit(*children);
+	QObject *child;
+	while ((child = childit.current()) != 0)
+	{
+		++childit;
+		if (child->isWidgetType())
+			setStyleRecursive((QWidget *) child, s);
+	}
+}
+
+
+// ----------------------------------------------------------------
+// All the Effects stuff
+// ----------------------------------------------------------------
+
+void KCMStyle::loadEffects( KConfig& config )
+{
+	// Load effects.
+	config.setGroup("KDE");
+
+	cbEnableEffects->setChecked( config.readBoolEntry( "EffectsEnabled", false) );
+
+	if ( config.readBoolEntry( "EffectAnimateCombo", false) )
+		comboComboEffect->setCurrentItem( 1 );
+	else
+		comboComboEffect->setCurrentItem( 0 );
+
+	if ( config.readBoolEntry( "EffectAnimateTooltip", false) )
+		comboTooltipEffect->setCurrentItem( 1 );
+	else if ( config.readBoolEntry( "EffectFadeTooltip", false) )
+		comboTooltipEffect->setCurrentItem( 2 );
+	else
+		comboTooltipEffect->setCurrentItem( 0 );
+
+	if ( config.readBoolEntry( "EffectAnimateMenu", false) )
+		comboMenuEffect->setCurrentItem( 1 );
+	else if ( config.readBoolEntry( "EffectFadeMenu", false) )
+		comboMenuEffect->setCurrentItem( 2 );
+	else
+		comboMenuEffect->setCurrentItem( 0 );
+
+	comboMenuHandle->setCurrentItem(config.readNumEntry("InsertTearOffHandle", 0));
+
+	// KStyle Menu transparency and drop-shadow options...
+	QSettings settings;
+	QString effectEngine = settings.readEntry("/KStyle/Settings/MenuTransparencyEngine", "Disabled");
+
+#ifdef HAVE_XRENDER
+	if (effectEngine == "XRender") {
+		comboMenuEffectType->setCurrentItem(2);
+		comboMenuEffect->setCurrentItem(3);
+	} else if (effectEngine == "SoftwareBlend") {
+		comboMenuEffectType->setCurrentItem(1);
+		comboMenuEffect->setCurrentItem(3);
+#else
+	if (effectEngine == "XRender" || effectEngine == "SoftwareBlend") {
+		comboMenuEffectType->setCurrentItem(1);	// Software Blend
+		comboMenuEffect->setCurrentItem(3);
+#endif
+	} else if (effectEngine == "SoftwareTint") {
+		comboMenuEffectType->setCurrentItem(0);
+		comboMenuEffect->setCurrentItem(3);
+	} else
+		comboMenuEffectType->setCurrentItem(0);
+
+	if (comboMenuEffect->currentItem() != 3)	// If not translucency...
+		menuPreview->setPreviewMode( MenuPreview::Tint );
+	else if (comboMenuEffectType->currentItem() == 0)
+		menuPreview->setPreviewMode( MenuPreview::Tint );
+	else
+		menuPreview->setPreviewMode( MenuPreview::Blend );
+
+	slOpacity->setValue( (int)(100 * settings.readDoubleEntry("/KStyle/Settings/MenuOpacity", 0.90)) );
+
+	// Menu Drop-shadows...
+	cbMenuShadow->setChecked( settings.readBoolEntry("/KStyle/Settings/MenuDropShadow", false) );
+
+	if (cbEnableEffects->isChecked()) {
+		containerFrame->setEnabled( true );
+		menuContainer->setEnabled( comboMenuEffect->currentItem() == 3 );
+	} else {
+		menuContainer->setEnabled( false );
+		containerFrame->setEnabled( false );
+	}
+
+	m_bEffectsDirty = false;
+}
+
+
+void KCMStyle::menuEffectTypeChanged()
+{
+	MenuPreview::PreviewMode mode;
+
+	if (comboMenuEffect->currentItem() != 3)
+		mode = MenuPreview::Tint;
+	else if (comboMenuEffectType->currentItem() == 0)
+		mode = MenuPreview::Tint;
+	else
+		mode = MenuPreview::Blend;
+
+	menuPreview->setPreviewMode(mode);
+
+	m_bEffectsDirty = true;
+}
+
+
+void KCMStyle::menuEffectChanged()
+{
+	menuEffectChanged( cbEnableEffects->isChecked() );
+	m_bEffectsDirty = true;
+}
+
+
+void KCMStyle::menuEffectChanged( bool enabled )
+{
+	if (enabled &&
+		comboMenuEffect->currentItem() == 3) {
+		menuContainer->setEnabled(true);
+	} else
+		menuContainer->setEnabled(false);
+	m_bEffectsDirty = true;
+}
+
+
+// ----------------------------------------------------------------
+// All the Miscellaneous stuff
+// ----------------------------------------------------------------
+
+void KCMStyle::loadMisc( KConfig& config )
+{
+	// KDE's Part via KConfig
+	config.setGroup("Toolbar style");
+	cbHoverButtons->setChecked(config.readBoolEntry("Highlighting", true));
+	cbTransparentToolbars->setChecked(config.readBoolEntry("TransparentMoving", true));
+
+	QString tbIcon = config.readEntry("IconText", "IconOnly");
+	if (tbIcon == "TextOnly")
+		comboToolbarIcons->setCurrentItem(1);
+	else if (tbIcon == "IconTextRight")
+		comboToolbarIcons->setCurrentItem(2);
+	else if (tbIcon == "IconTextBottom")
+		comboToolbarIcons->setCurrentItem(3);
+	else
+		comboToolbarIcons->setCurrentItem(0);
+
+	config.setGroup("KDE");
+	cbIconsOnButtons->setChecked(config.readBoolEntry("ShowIconsOnPushButtons", false));
+	cbEnableTooltips->setChecked(!config.readBoolEntry("EffectNoTooltip", false));
+	cbTearOffHandles->setChecked(config.readBoolEntry("InsertTearOffHandle", false));
+
+	m_bToolbarsDirty = false;
+}
+
+void KCMStyle::addWhatsThis()
+{
+	// Page1
+	QWhatsThis::add( cbStyle, i18n("Here you can choose from a list of"
+							" predefined widget styles (e.g. the way buttons are drawn) which"
+							" may or may not be combined with a theme (additional information"
+							" like a marble texture or a gradient).") );
+	QWhatsThis::add( stylePreview, i18n("This area shows a preview of the currently selected style "
+							"without having to apply it to the whole desktop.") );
+
+	// Page2
+	QWhatsThis::add( page2, i18n("This page allows you to enable various widget style effects. "
+							"For best performance, it is advisable to disable all effects.") );
+	QWhatsThis::add( cbEnableEffects, i18n( "If you check this box, you can select several effects "
+							"for different widgets like combo boxes, menus or tooltips.") );
+	QWhatsThis::add( comboComboEffect, i18n( "<p><b>Disable: </b>do not use any combo box effects.</p>\n"
+							"<b>Animate: </b>Do some animation.") );
+	QWhatsThis::add( comboTooltipEffect, i18n( "<p><b>Disable: </b>do not use any tooltip effects.</p>\n"
+							"<p><b>Animate: </b>Do some animation.</p>\n"
+							"<b>Fade: </b>Fade in tooltips using alpha-blending.") );
+	QWhatsThis::add( comboMenuEffect, i18n( "<p><b>Disable: </b>do not use any menu effects.</p>\n"
+							"<p><b>Animate: </b>Do some animation.</p>\n"
+							"<p><b>Fade: </b>Fade in menus using alpha-blending.</p>\n"
+							"<b>Make Translucent: </b>Alpha-blend menus for a see-through effect. (KDE styles only)") );
+	QWhatsThis::add( cbMenuShadow, i18n( "When enabled, all popup menus will have a drop-shadow, otherwise "
+							"drop-shadows will not be displayed. At present, only KDE styles can have this "
+							"effect enabled.") );
+	QWhatsThis::add( comboMenuEffectType, i18n( "<p><b>Software Tint: </b>Alpha-blend using a flat color.</p>\n"
+							"<p><b>Software Blend: </b>Alpha-blend using an image.</p>\n"
+							"<b>XRender Blend: </b>Use the XFree RENDER extension for image blending (if available). "
+							"This method may be slower than the Software routines on non-accelerated displays, "
+							"but may however improve performance on remote displays.</p>\n") );
+	QWhatsThis::add( slOpacity, i18n("By adjusting this slider you can control the menu effect opacity.") );
+
+	// Page3
+	QWhatsThis::add( page3, i18n("<b>Note:</b> that all widgets in this combobox "
+							"do not apply to Qt-only applications.") );
+	QWhatsThis::add( cbHoverButtons, i18n("If this option is selected, toolbar buttons will change "
+							"their color when the mouse cursor is moved over them." ) );
+	QWhatsThis::add( cbTransparentToolbars, i18n("If you check this box, the toolbars will be "
+							"transparent when moving them around.") );
+	QWhatsThis::add( cbEnableTooltips, i18n( "If you check this option, the KDE application "
+							"will offer tooltips when the cursor remains over items in the toolbar." ) );
+	QWhatsThis::add( comboToolbarIcons, i18n( "<p><b>Icons only:</b> Shows only icons on toolbar buttons. "
+							"Best option for low resolutions.</p>"
+							"<p><b>Text only: </b>Shows only text on toolbar buttons.</p>"
+							"<p><b>Text alongside icons: </b> Shows icons and text on toolbar buttons. "
+							"Text is aligned alongside the icon.</p>"
+							"<b>Text under icons: </b> Shows icons and text on toolbar buttons. "
+							"Text is aligned below the icon.") );
+	QWhatsThis::add( cbIconsOnButtons, i18n( "If you enable this option, KDE Applications will "
+							"show small icons alongside some important buttons.") );
+	QWhatsThis::add( cbTearOffHandles, i18n( "If you enable this option some pop-up menus will "
+							"show so called tear-off handles. If you click them, you get the menu "
+							"inside a widget. This can be very helpful when performing "
+							"the same action multiple times.") );
+}
+
+#include "kcmstyle.moc"
+
+// vim: set noet ts=4: