summaryrefslogtreecommitdiffstats
path: root/kutils/kpluginselector.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kutils/kpluginselector.cpp')
-rw-r--r--kutils/kpluginselector.cpp727
1 files changed, 727 insertions, 0 deletions
diff --git a/kutils/kpluginselector.cpp b/kutils/kpluginselector.cpp
new file mode 100644
index 000000000..4bcc166d1
--- /dev/null
+++ b/kutils/kpluginselector.cpp
@@ -0,0 +1,727 @@
+/* This file is part of the KDE project
+ Copyright (C) 2002-2003 Matthias Kretz <kretz@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+
+*/
+
+#include "kpluginselector.h"
+#include "kpluginselector_p.h"
+
+#include <qtooltip.h>
+#include <qvbox.h>
+#include <qlabel.h>
+#include <qstrlist.h>
+#include <qfile.h>
+#include <qstring.h>
+#include <qlayout.h>
+#include <qptrlist.h>
+#include <qwidgetstack.h>
+#include <qcursor.h>
+#include <qapplication.h>
+#include <qobjectlist.h>
+#include <qcstring.h>
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <klistview.h>
+#include <ksimpleconfig.h>
+#include <kdialog.h>
+#include <kglobal.h>
+#include <kglobalsettings.h>
+#include <kstandarddirs.h>
+#include <ktabctl.h>
+#include <kcmoduleinfo.h>
+#include <qvaluelist.h>
+#include <kservice.h>
+#include <ktrader.h>
+#include <ktabwidget.h>
+#include <kiconloader.h>
+#include <kcmodule.h>
+#include "kcmoduleinfo.h"
+#include "kcmoduleloader.h"
+#include <qsplitter.h>
+#include <qframe.h>
+#include "kplugininfo.h"
+#include <kinstance.h>
+#include <qptrdict.h>
+#include <qstringlist.h>
+#include "kcmoduleproxy.h"
+
+/*
+ QCheckListViewItem that holds a pointer to the KPluginInfo object.
+ Used in the tooltip code to access additional fields
+*/
+class KPluginInfoLVI : public QCheckListItem
+{
+public:
+ KPluginInfoLVI( KPluginInfo *pluginInfo, KListView *parent )
+ : QCheckListItem( parent, pluginInfo->name(), QCheckListItem::CheckBox ), m_pluginInfo( pluginInfo )
+ {
+ }
+
+ KPluginInfo * pluginInfo() { return m_pluginInfo; }
+
+private:
+ KPluginInfo *m_pluginInfo;
+};
+
+/*
+ Custom QToolTip for the list view.
+ The decision whether or not to show tooltips is taken in
+ maybeTip(). See also the QListView sources from Qt itself.
+*/
+class KPluginListViewToolTip : public QToolTip
+{
+public:
+ KPluginListViewToolTip( QWidget *parent, KListView *lv );
+
+ void maybeTip( const QPoint &pos );
+
+private:
+ KListView *m_listView;
+};
+
+KPluginListViewToolTip::KPluginListViewToolTip( QWidget *parent, KListView *lv )
+: QToolTip( parent ), m_listView( lv )
+{
+}
+
+void KPluginListViewToolTip::maybeTip( const QPoint &pos )
+{
+ if ( !parentWidget() || !m_listView )
+ return;
+
+ KPluginInfoLVI *item = dynamic_cast<KPluginInfoLVI *>( m_listView->itemAt( pos ) );
+ if ( !item )
+ return;
+
+ QString toolTip = i18n( "<qt><table>"
+ "<tr><td><b>Description:</b></td><td>%1</td></tr>"
+ "<tr><td><b>Author:</b></td><td>%2</td></tr>"
+ "<tr><td><b>Version:</b></td><td>%3</td></tr>"
+ "<tr><td><b>License:</b></td><td>%4</td></tr></table></qt>" ).arg( item->pluginInfo()->comment(),
+ item->pluginInfo()->author(), item->pluginInfo()->version(), item->pluginInfo()->license() );
+
+ //kdDebug( 702 ) << k_funcinfo << "Adding tooltip: itemRect: " << itemRect << ", tooltip: " << toolTip << endl;
+ tip( m_listView->itemRect( item ), toolTip );
+}
+
+struct KPluginSelectionWidget::KPluginSelectionWidgetPrivate
+{
+ KPluginSelectionWidgetPrivate( KPluginSelector * _kps,
+ const QString & _cat,
+ KConfigGroup * _config )
+ : widgetstack( 0 )
+ , kps( _kps )
+ , config( _config )
+ , tooltip( 0 )
+ , catname( _cat )
+ , currentplugininfo( 0 )
+ , visible( true )
+ , currentchecked( false )
+ , changed( 0 )
+ {
+ moduleParentComponents.setAutoDelete( true );
+ }
+
+ ~KPluginSelectionWidgetPrivate()
+ {
+ delete config;
+ }
+
+ QMap<QCheckListItem*, KPluginInfo*> pluginInfoMap;
+
+ QWidgetStack * widgetstack;
+ KPluginSelector * kps;
+ KConfigGroup * config;
+ KPluginListViewToolTip *tooltip;
+
+ QDict<KCModuleInfo> pluginconfigmodules;
+ QMap<QString, int> widgetIDs;
+ QMap<KPluginInfo*, bool> plugincheckedchanged;
+ QString catname;
+ QValueList<KCModuleProxy*> modulelist;
+ QPtrDict<QStringList> moduleParentComponents;
+
+ KPluginInfo * currentplugininfo;
+ bool visible;
+ bool currentchecked;
+ int changed;
+};
+
+KPluginSelectionWidget::KPluginSelectionWidget(
+ const QValueList<KPluginInfo*> & plugininfos, KPluginSelector * kps,
+ QWidget * parent, const QString & catname, const QString & category,
+ KConfigGroup * config, const char * name )
+ : QWidget( parent, name )
+ , d( new KPluginSelectionWidgetPrivate( kps, catname, config ) )
+{
+ init( plugininfos, category );
+}
+
+inline QString KPluginSelectionWidget::catName() const
+{
+ return d->catname;
+}
+
+void KPluginSelectionWidget::init( const QValueList<KPluginInfo*> & plugininfos,
+ const QString & category )
+{
+ // setup Widgets
+ ( new QVBoxLayout( this, 0, KDialog::spacingHint() ) )->setAutoAdd( true );
+ KListView * listview = new KListView( this );
+ d->tooltip = new KPluginListViewToolTip( listview->viewport(), listview );
+ connect( listview, SIGNAL( pressed( QListViewItem * ) ), this,
+ SLOT( executed( QListViewItem * ) ) );
+ connect( listview, SIGNAL( spacePressed( QListViewItem * ) ), this,
+ SLOT( executed( QListViewItem * ) ) );
+ connect( listview, SIGNAL( returnPressed( QListViewItem * ) ), this,
+ SLOT( executed( QListViewItem * ) ) );
+ connect( listview, SIGNAL( selectionChanged( QListViewItem * ) ), this,
+ SLOT( executed( QListViewItem * ) ) );
+ listview->setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Preferred );
+ listview->setAcceptDrops( false );
+ listview->setFullWidth( true );
+ listview->setSelectionModeExt( KListView::Single );
+ listview->setAllColumnsShowFocus( true );
+ listview->addColumn( i18n( "Name" ) );
+ for( QValueList<KPluginInfo*>::ConstIterator it = plugininfos.begin();
+ it != plugininfos.end(); ++it )
+ {
+ d->plugincheckedchanged[ *it ] = false;
+ if( !( *it )->isHidden() &&
+ ( category.isNull() || ( *it )->category() == category ) )
+ {
+ QCheckListItem * item = new KPluginInfoLVI( *it, listview );
+ if( ! ( *it )->icon().isEmpty() )
+ item->setPixmap( 0, SmallIcon( ( *it )->icon(), IconSize( KIcon::Small ) ) );
+ item->setOn( ( *it )->isPluginEnabled() );
+ d->pluginInfoMap.insert( item, *it );
+ }
+ }
+
+ // widgetstack
+ d->widgetstack = d->kps->widgetStack();
+ load();
+ // select and highlight the first item in the plugin list
+ if( listview->firstChild() )
+ listview->setSelected( listview->firstChild(), true );
+}
+
+KPluginSelectionWidget::~KPluginSelectionWidget()
+{
+ delete d->tooltip;
+ delete d;
+}
+
+bool KPluginSelectionWidget::pluginIsLoaded( const QString & pluginName ) const
+{
+ for( QMap<QCheckListItem*, KPluginInfo*>::ConstIterator it =
+ d->pluginInfoMap.begin(); it != d->pluginInfoMap.end(); ++it )
+ if( it.data()->pluginName() == pluginName )
+ return it.data()->isPluginEnabled();
+ return false;
+}
+
+
+QWidget * KPluginSelectionWidget::insertKCM( QWidget * parent,
+ const KCModuleInfo & moduleinfo )
+{
+ KCModuleProxy * module = new KCModuleProxy( moduleinfo, false,
+ parent );
+ if( !module->realModule() )
+ {
+ //FIXME: not very verbose
+ QLabel * label = new QLabel( i18n( "Error" ), parent );
+ label->setAlignment( Qt::AlignCenter );
+
+ return label;
+ }
+ // add the KCM to the list so that we can call load/save/defaults on it
+ d->modulelist.append( module );
+ QStringList * parentComponents = new QStringList(
+ moduleinfo.service()->property(
+ "X-KDE-ParentComponents" ).toStringList() );
+ d->moduleParentComponents.insert( module, parentComponents );
+ connect( module, SIGNAL( changed( bool ) ), SLOT( clientChanged( bool ) ) );
+ return module;
+}
+
+void KPluginSelectionWidget::embeddPluginKCMs( KPluginInfo * plugininfo, bool checked )
+{
+ //if we have Services for the plugin we should be able to
+ //create KCM(s)
+ QApplication::setOverrideCursor( Qt::WaitCursor );
+ if( plugininfo->kcmServices().size() > 1 )
+ {
+ // we need a tabwidget
+ KTabWidget * tabwidget = new KTabWidget( d->widgetstack );
+ tabwidget->setEnabled( checked );
+
+ int id = d->widgetstack->addWidget( tabwidget );
+ d->kps->configPage( id );
+ d->widgetIDs[ plugininfo->pluginName() ] = id;
+
+ for( QValueList<KService::Ptr>::ConstIterator it =
+ plugininfo->kcmServices().begin();
+ it != plugininfo->kcmServices().end(); ++it )
+ {
+ if( !( *it )->noDisplay() )
+ {
+ KCModuleInfo moduleinfo( *it );
+ QWidget * module = insertKCM( tabwidget, moduleinfo );
+ tabwidget->addTab( module, moduleinfo.moduleName() );
+ }
+ }
+ }
+ else
+ {
+ if( !plugininfo->kcmServices().front()->noDisplay() )
+ {
+ KCModuleInfo moduleinfo(
+ plugininfo->kcmServices().front() );
+ QWidget * module = insertKCM( d->widgetstack, moduleinfo );
+ module->setEnabled( checked );
+
+ int id = d->widgetstack->addWidget( module );
+ d->kps->configPage( id );
+ d->widgetIDs[ plugininfo->pluginName() ] = id;
+ }
+ }
+ QApplication::restoreOverrideCursor();
+}
+
+inline void KPluginSelectionWidget::updateConfigPage()
+{
+ updateConfigPage( d->currentplugininfo, d->currentchecked );
+}
+
+void KPluginSelectionWidget::updateConfigPage( KPluginInfo * plugininfo,
+ bool checked )
+{
+ //kdDebug( 702 ) << k_funcinfo << endl;
+ d->currentplugininfo = plugininfo;
+ d->currentchecked = checked;
+
+ // if this widget is not currently visible (meaning that it's in a tabwidget
+ // and another tab is currently opened) it's not allowed to change the
+ // widgetstack
+ if( ! d->visible )
+ return;
+
+ if( 0 == plugininfo )
+ {
+ d->kps->configPage( 1 );
+ return;
+ }
+
+ if( plugininfo->kcmServices().empty() )
+ d->kps->configPage( 1 );
+ else
+ {
+ if( !d->widgetIDs.contains( plugininfo->pluginName() ) )
+ // if no widget exists for the plugin create it
+ embeddPluginKCMs( plugininfo, checked );
+ else
+ {
+ // the page already exists
+ int id = d->widgetIDs[ plugininfo->pluginName() ];
+ d->kps->configPage( id );
+ d->widgetstack->widget( id )->setEnabled( checked );
+ }
+ }
+}
+
+void KPluginSelectionWidget::clientChanged( bool didchange )
+{
+ kdDebug( 702 ) << k_funcinfo << endl;
+ d->changed += didchange ? 1 : -1;
+ if( d->changed == 1 )
+ emit changed( true );
+ else if( d->changed == 0 )
+ emit changed( false );
+ else if( d->changed < 0 )
+ kdError( 702 ) << "negative changed value: " << d->changed << endl;
+}
+
+void KPluginSelectionWidget::tabWidgetChanged( QWidget * widget )
+{
+ if( widget == this )
+ {
+ d->visible = true;
+ updateConfigPage();
+ }
+ else
+ d->visible = false;
+}
+
+void KPluginSelectionWidget::executed( QListViewItem * item )
+{
+ kdDebug( 702 ) << k_funcinfo << endl;
+ if( item == 0 )
+ return;
+
+ // Why not a dynamic_cast? - Martijn
+ // because this is what the Qt API suggests; and since gcc 3.x I don't
+ // trust dynamic_cast anymore - mkretz
+ if( item->rtti() != 1 ) //check for a QCheckListItem
+ return;
+
+ QCheckListItem * citem = static_cast<QCheckListItem *>( item );
+ bool checked = citem->isOn();
+ //kdDebug( 702 ) << "it's a " << ( checked ? "checked" : "unchecked" )
+ // << " QCheckListItem" << endl;
+
+ KPluginInfo * info = d->pluginInfoMap[ citem ];
+ Q_ASSERT( !info->isHidden() );
+
+ if ( info->isPluginEnabled() != checked )
+ {
+ kdDebug( 702 ) << "Item changed state, emitting changed()" << endl;
+
+ if( ! d->plugincheckedchanged[ info ] )
+ {
+ ++d->changed;
+ if ( d->changed == 1 )
+ emit changed( true );
+ }
+ d->plugincheckedchanged[ info ] = true;
+
+ checkDependencies( info );
+ }
+ else
+ {
+ if( d->plugincheckedchanged[ info ] )
+ {
+ --d->changed;
+ if ( d->changed == 0 )
+ emit changed( false );
+ }
+ d->plugincheckedchanged[ info ] = false;
+ // FIXME: plugins that depend on this plugin need to be disabled, too
+ }
+
+ updateConfigPage( info, checked );
+}
+
+void KPluginSelectionWidget::load()
+{
+ //kdDebug( 702 ) << k_funcinfo << endl;
+
+ for( QMap<QCheckListItem*, KPluginInfo*>::Iterator it =
+ d->pluginInfoMap.begin(); it != d->pluginInfoMap.end(); ++it )
+ {
+ KPluginInfo * info = it.data();
+ info->load( d->config );
+ it.key()->setOn( info->isPluginEnabled() );
+ if( d->visible && info == d->currentplugininfo )
+ d->currentchecked = info->isPluginEnabled();
+ }
+
+ for( QValueList<KCModuleProxy*>::Iterator it = d->modulelist.begin();
+ it != d->modulelist.end(); ++it )
+ if( ( *it )->changed() )
+ ( *it )->load();
+
+ updateConfigPage();
+ // TODO: update changed state
+}
+
+void KPluginSelectionWidget::save()
+{
+ kdDebug( 702 ) << k_funcinfo << endl;
+
+ for( QMap<QCheckListItem*, KPluginInfo*>::Iterator it =
+ d->pluginInfoMap.begin(); it != d->pluginInfoMap.end(); ++it )
+ {
+ KPluginInfo * info = it.data();
+ bool checked = it.key()->isOn();
+ info->setPluginEnabled( checked );
+ info->save( d->config );
+ d->plugincheckedchanged[ info ] = false;
+ }
+ QStringList updatedModules;
+ for( QValueList<KCModuleProxy*>::Iterator it = d->modulelist.begin();
+ it != d->modulelist.end(); ++it )
+ if( ( *it )->changed() )
+ {
+ ( *it )->save();
+ QStringList * names = d->moduleParentComponents[ *it ];
+ if( names->size() == 0 )
+ names->append( QString::null );
+ for( QStringList::ConstIterator nameit = names->begin();
+ nameit != names->end(); ++nameit )
+ if( updatedModules.find( *nameit ) == updatedModules.end() )
+ updatedModules.append( *nameit );
+ }
+ for( QStringList::ConstIterator it = updatedModules.begin(); it != updatedModules.end(); ++it )
+ emit configCommitted( ( *it ).latin1() );
+
+ updateConfigPage();
+ kdDebug( 702 ) << "syncing config file" << endl;
+ d->config->sync();
+ d->changed = 0;
+ emit changed( false );
+}
+
+void KPluginSelectionWidget::checkDependencies( const KPluginInfo * info )
+{
+ if( info->dependencies().isEmpty() )
+ return;
+
+ for( QStringList::ConstIterator it = info->dependencies().begin();
+ it != info->dependencies().end(); ++it )
+ for( QMap<QCheckListItem*,
+ KPluginInfo*>::Iterator infoIt = d->pluginInfoMap.begin();
+ infoIt != d->pluginInfoMap.end(); ++infoIt )
+ if( infoIt.data()->pluginName() == *it )
+ {
+ if( !infoIt.key()->isOn() )
+ {
+ infoIt.key()->setOn( true );
+ checkDependencies( infoIt.data() );
+ }
+ continue;
+ }
+}
+
+class KPluginSelector::KPluginSelectorPrivate
+{
+ public:
+ KPluginSelectorPrivate()
+ : frame( 0 )
+ , tabwidget( 0 )
+ , widgetstack( 0 )
+ , hideconfigpage( false )
+ {
+ }
+
+ QFrame * frame;
+ KTabWidget * tabwidget;
+ QWidgetStack * widgetstack;
+ QValueList<KPluginSelectionWidget *> pswidgets;
+ bool hideconfigpage;
+};
+
+KPluginSelector::KPluginSelector( QWidget * parent, const char * name )
+: QWidget( parent, name )
+, d( new KPluginSelectorPrivate )
+{
+ QBoxLayout * hbox = new QHBoxLayout( this, 0, KDialog::spacingHint() );
+ hbox->setAutoAdd( true );
+
+ QSplitter* splitter = new QSplitter( QSplitter::Horizontal, this );
+ d->frame = new QFrame( splitter, "KPluginSelector left frame" );
+ d->frame->setFrameStyle( QFrame::NoFrame );
+ ( new QVBoxLayout( d->frame, 0, KDialog::spacingHint() ) )->setAutoAdd( true );
+
+ // widgetstack
+ d->widgetstack = new QWidgetStack( splitter, "KPluginSelector Config Pages" );
+ d->widgetstack->setFrameStyle( QFrame::Panel | QFrame::Sunken );
+ d->widgetstack->setMinimumSize( 200, 200 );
+
+ QLabel * label = new QLabel( i18n( "(This plugin is not configurable)" ),
+ d->widgetstack );
+ ( new QVBoxLayout( label, 0, KDialog::spacingHint() ) )->setAutoAdd( true );
+ label->setAlignment( Qt::AlignCenter );
+ label->setMinimumSize( 200, 200 );
+
+ d->widgetstack->addWidget( label, 1 );
+
+ configPage( 1 );
+}
+
+KPluginSelector::~KPluginSelector()
+{
+ delete d;
+}
+
+void KPluginSelector::checkNeedForTabWidget()
+{
+ kdDebug( 702 ) << k_funcinfo << endl;
+ if( ! d->tabwidget && d->pswidgets.size() == 1 )
+ {
+ kdDebug( 702 ) << "no TabWidget and one KPluginSelectionWidget" << endl;
+ // there's only one KPluginSelectionWidget yet, we need a TabWidget
+ KPluginSelectionWidget * w = d->pswidgets.first();
+ if( w )
+ {
+ kdDebug( 702 ) << "create TabWidget" << endl;
+ d->tabwidget = new KTabWidget( d->frame,
+ "KPluginSelector TabWidget" );
+ w->reparent( d->tabwidget, QPoint( 0, 0 ) );
+ d->tabwidget->addTab( w, w->catName() );
+ connect( d->tabwidget, SIGNAL( currentChanged( QWidget * ) ), w,
+ SLOT( tabWidgetChanged( QWidget * ) ) );
+ }
+ }
+}
+
+static QValueList<KPluginInfo*> kpartsPluginInfos( const QString& instanceName )
+{
+ if( instanceName.isNull() )
+ return QValueList<KPluginInfo*>(); //nothing
+
+ const QStringList desktopfilenames = KGlobal::dirs()->findAllResources( "data",
+ instanceName + "/kpartplugins/*.desktop", true, false );
+ return KPluginInfo::fromFiles( desktopfilenames );
+}
+
+void KPluginSelector::addPlugins( const QString & instanceName,
+ const QString & catname, const QString & category, KConfig * config )
+{
+ const QValueList<KPluginInfo*> plugininfos = kpartsPluginInfos( instanceName );
+ if ( plugininfos.isEmpty() )
+ return;
+ checkNeedForTabWidget();
+ Q_ASSERT( config ); // please set config, or use addPlugins( instance, ... ) which takes care of it
+ if ( !config ) // KDE4: ensure that config is always set; make it second in the arg list?
+ config = new KSimpleConfig( instanceName ); // memleak!
+ KConfigGroup * cfgGroup = new KConfigGroup( config, "KParts Plugins" );
+ kdDebug( 702 ) << k_funcinfo << "cfgGroup = " << cfgGroup << endl;
+ addPluginsInternal( plugininfos, catname, category, cfgGroup );
+}
+
+void KPluginSelector::addPluginsInternal( const QValueList<KPluginInfo*> plugininfos,
+ const QString & catname, const QString & category,
+ KConfigGroup* cfgGroup )
+{
+ KPluginSelectionWidget * w;
+ if( d->tabwidget )
+ {
+ w = new KPluginSelectionWidget( plugininfos, this,
+ d->tabwidget, catname, category, cfgGroup );
+ d->tabwidget->addTab( w, catname );
+ connect( d->tabwidget, SIGNAL( currentChanged( QWidget * ) ), w,
+ SLOT( tabWidgetChanged( QWidget * ) ) );
+ }
+ else
+ w = new KPluginSelectionWidget( plugininfos, this, d->frame,
+ catname, category, cfgGroup );
+ w->setMinimumSize( 200, 200 );
+ connect( w, SIGNAL( changed( bool ) ), this, SIGNAL( changed( bool ) ) );
+ connect( w, SIGNAL( configCommitted( const QCString & ) ), this,
+ SIGNAL( configCommitted( const QCString & ) ) );
+ d->pswidgets += w;
+}
+
+void KPluginSelector::addPlugins( const KInstance * instance, const QString &
+ catname, const QString & category, KConfig * config )
+{
+ if ( !config )
+ config = instance->config();
+ addPlugins( instance->instanceName(), catname, category, config );
+}
+
+void KPluginSelector::addPlugins( const QValueList<KPluginInfo*> & plugininfos,
+ const QString & catname, const QString & category, KConfig * config )
+{
+ checkNeedForTabWidget();
+ // the KConfigGroup becomes owned by KPluginSelectionWidget
+ KConfigGroup * cfgGroup = new KConfigGroup( config ? config : KGlobal::config(), "Plugins" );
+ kdDebug( 702 ) << k_funcinfo << "cfgGroup = " << cfgGroup << endl;
+ addPluginsInternal( plugininfos, catname, category, cfgGroup );
+}
+
+QWidgetStack * KPluginSelector::widgetStack()
+{
+ return d->widgetstack;
+}
+
+inline void KPluginSelector::configPage( int id )
+{
+ if( id == 1 )
+ {
+ // no config page
+ if( d->hideconfigpage )
+ {
+ d->widgetstack->hide();
+ return;
+ }
+ }
+ else
+ d->widgetstack->show();
+
+ d->widgetstack->raiseWidget( id );
+}
+
+void KPluginSelector::setShowEmptyConfigPage( bool show )
+{
+ d->hideconfigpage = !show;
+ if( d->hideconfigpage )
+ if( d->widgetstack->id( d->widgetstack->visibleWidget() ) == 1 )
+ d->widgetstack->hide();
+}
+
+void KPluginSelector::load()
+{
+ for( QValueList<KPluginSelectionWidget *>::Iterator it =
+ d->pswidgets.begin(); it != d->pswidgets.end(); ++it )
+ {
+ ( *it )->load();
+ }
+}
+
+void KPluginSelector::save()
+{
+ for( QValueList<KPluginSelectionWidget *>::Iterator it =
+ d->pswidgets.begin(); it != d->pswidgets.end(); ++it )
+ {
+ ( *it )->save();
+ }
+}
+
+void KPluginSelector::defaults()
+{
+ kdDebug( 702 ) << k_funcinfo << endl;
+
+ // what should defaults do? here's what I think:
+ // Pressing a button in the dialog should not change any widgets that are
+ // not visible for the user. Therefor we may only change the currently
+ // visible plugin's KCM. Restoring the default plugin selections is therefor
+ // not possible. (if the plugin has multiple KCMs they will be shown in a
+ // tabwidget - defaults() will be called for all of them)
+
+ QWidget * pluginconfig = d->widgetstack->visibleWidget();
+ KCModuleProxy * kcm = ( KCModuleProxy* )pluginconfig->qt_cast(
+ "KCModuleProxy" );
+ if( kcm )
+ {
+ kdDebug( 702 ) << "call KCModule::defaults() for the plugins KCM"
+ << endl;
+ kcm->defaults();
+ return;
+ }
+
+ // if we get here the visible Widget must be a tabwidget holding more than
+ // one KCM
+ QObjectList * kcms = pluginconfig->queryList( "KCModuleProxy",
+ 0, false, false );
+ QObjectListIt it( *kcms );
+ QObject * obj;
+ while( ( obj = it.current() ) != 0 )
+ {
+ ++it;
+ ( ( KCModule* )obj )->defaults();
+ }
+ delete kcms;
+ // FIXME: update changed state
+}
+
+// vim: sw=4 sts=4 et
+
+#include "kpluginselector.moc"
+#include "kpluginselector_p.moc"