diff --git a/src/kcm/configdialog.cpp b/src/kcm/configdialog.cpp
index d1f9d3b..474d2a9 100644
--- a/src/kcm/configdialog.cpp
+++ b/src/kcm/configdialog.cpp
@@ -1,1806 +1,1804 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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 <QDBusInterface>
 #include <QDBusMessage>
 #include <QPainter>
 #include <QSortFilterProxyModel>
 #include <QStandardItemModel>
 
 #include <KCalendarSystem>
 #include <KColorScheme>
 #include <KConfigGroup>
 #include <QInputDialog>
 #include <kio/global.h>
 #include <KMessageBox>
 #include <KPluginFactory>
 #include <KNotifyConfigWidget>
 #include <math.h>
 
 #include "ui_configdlg.h"
 #include "config-knemo.h"
 #include "configdialog.h"
 #include "statsconfig.h"
 #include "warnconfig.h"
 #include "themeconfig.h"
 #include "utils.h"
 
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <ifaddrs.h>
 #include <netdb.h>
 
 #ifdef __linux__
   #include <netlink/route/rtnl.h>
   #include <netlink/route/link.h>
   #include <netlink/route/route.h>
 #endif
 
 
 K_PLUGIN_FACTORY(KNemoFactory, registerPlugin<ConfigDialog>(QLatin1String("knemo"));)
 K_EXPORT_PLUGIN(KNemoFactory("kcm_knemo"))
 
 Q_DECLARE_METATYPE( KNemoTheme )
 Q_DECLARE_METATYPE( StatsRule )
 Q_DECLARE_METATYPE( WarnRule )
 
 
 static bool themesLessThan( const KNemoTheme& s1, const KNemoTheme& s2 )
 {
     if ( s1.name < s2.name )
         return true;
     else
         return false;
 }
 
 static QString periodText( int c, int u )
 {
     QString units;
     switch ( u )
     {
         case KNemoStats::Hour:
             units = i18np( "%1 hour", "%1 hours", c );
             break;
         case KNemoStats::Day:
             units = i18np( "%1 day", "%1 days", c );
             break;
         case KNemoStats::Week:
             units = i18np( "%1 week", "%1 weeks", c );
             break;
         case KNemoStats::Month:
             units = i18np( "%1 month", "%1 months", c );
             break;
         case KNemoStats::BillPeriod:
             units = i18np( "%1 billing period", "%1 billing periods", c );
             break;
         case KNemoStats::Year:
             units = i18np( "%1 year", "%1 years", c );
             break;
         default:
             units = i18n( "Invalid period" );
             ;;
     }
     return units;
 }
 
 void StatsRuleModel::setCalendar( const KCalendarSystem *cal )
 {
     mCalendar = cal;
 }
 
 QString StatsRuleModel::dateText( const StatsRule &s )
 {
     QString dateStr = mCalendar->formatDate( s.startDate, KLocale::LongDate );
     if ( !mCalendar->isValid( s.startDate ) )
         dateStr = i18n( "Invalid Date" );
     return dateStr;
 }
 
 QList<StatsRule> StatsRuleModel::getRules()
 {
     QList<StatsRule> statsRules;
     for ( int i = 0; i < rowCount(); ++i )
     {
         statsRules << item( i, 0 )->data( Qt::UserRole ).value<StatsRule>();
     }
     return statsRules;
 }
 
 QModelIndex StatsRuleModel::addRule( const StatsRule &s )
 {
     QList<QStandardItem*> items;
     QStandardItem *item = new QStandardItem( dateText( s ) );
     QVariant v;
     v.setValue( s );
     item->setData( v, Qt::UserRole );
     item->setData( s.startDate, Qt::UserRole + 1 );
     items << item;
 
     item = new QStandardItem( periodText( s.periodCount, s.periodUnits ) );
     items << item;
     appendRow( items );
     return indexFromItem (items[0] );
 }
 
 void StatsRuleModel::modifyRule( const QModelIndex &index, const StatsRule &s )
 {
     QVariant v;
     v.setValue( s );
     item( index.row(), 0 )->setData( v, Qt::UserRole );
     item( index.row(), 0 )->setData( s.startDate, Qt::UserRole + 1 );
     item( index.row(), 0 )->setData( dateText( s ), Qt::DisplayRole );
     item( index.row(), 1 )->setData( periodText( s.periodCount, s.periodUnits ), Qt::DisplayRole );
 }
 
 QString WarnModel::ruleText( const WarnRule &warn )
 {
     QString warnText;
     quint64 siz = warn.threshold * pow( 1024, warn.trafficUnits );
     switch ( warn.trafficDirection )
     {
         case KNemoStats::TrafficIn:
             if ( warn.trafficType == KNemoStats::Peak )
                 warnText = i18n( "peak incoming traffic > %1" ).arg( KIO::convertSize( siz ) );
             else if ( warn.trafficType == KNemoStats::Offpeak )
                 warnText = i18n( "off-peak incoming traffic > %1" ).arg( KIO::convertSize( siz ) );
             else
                 warnText = i18n( "incoming traffic > %1" ).arg( KIO::convertSize( siz ) );
             break;
         case KNemoStats::TrafficOut:
             if ( warn.trafficType == KNemoStats::Peak )
                 warnText = i18n( "peak outgoing traffic > %1" ).arg( KIO::convertSize( siz ) );
             else if ( warn.trafficType == KNemoStats::Offpeak )
                 warnText = i18n( "off-peak outgoing traffic > %1" ).arg( KIO::convertSize( siz ) );
             else
                 warnText = i18n( "outgoing traffic > %1" ).arg( KIO::convertSize( siz ) );
             break;
         case KNemoStats::TrafficTotal:
             if ( warn.trafficType == KNemoStats::Peak )
                 warnText = i18n( "peak incoming and outgoing traffic > %1" ).arg( KIO::convertSize( siz ) );
             else if ( warn.trafficType == KNemoStats::Offpeak )
                 warnText = i18n( "off-peak incoming and outgoing traffic > %1" ).arg( KIO::convertSize( siz ) );
             else
                 warnText = i18n( "incoming and outgoing traffic > %1" ).arg( KIO::convertSize( siz ) );
     }
     return warnText;
 }
 
 QList<WarnRule> WarnModel::getRules()
 {
     QList<WarnRule> warnRules;
     for ( int i = 0; i < rowCount(); ++i )
     {
         warnRules << item( i, 0 )->data( Qt::UserRole ).value<WarnRule>();
     }
     return warnRules;
 }
 
 QModelIndex WarnModel::addWarn( const WarnRule &warn )
 {
     QList<QStandardItem*> items;
     QStandardItem *item = new QStandardItem( ruleText( warn ) );
     QVariant v;
     v.setValue( warn );
     item->setData( v, Qt::UserRole );
     items << item;
     item = new QStandardItem( periodText( warn.periodCount, warn.periodUnits ) );
     items << item;
     appendRow( items );
     return indexFromItem( items[0] );
 }
 
 void WarnModel::modifyWarn( const QModelIndex &index, const WarnRule &warn )
 {
     QVariant v;
     v.setValue( warn );
     item( index.row(), 0 )->setData( v, Qt::UserRole );
     item( index.row(), 0 )->setData( ruleText( warn ), Qt::DisplayRole );
     item( index.row(), 1 )->setData( periodText( warn.periodCount, warn.periodUnits ), Qt::DisplayRole );
 }
 
 
 ConfigDialog::ConfigDialog( QWidget *parent, const QVariantList &args )
     : KCModule( parent, args ),
       mLock( false ),
       mDlg( new Ui::ConfigDlg() ),
       mCalendar( 0 )
 {
     migrateKde4Conf();
 
-    mConfig = KSharedConfig::openConfig( QLatin1String("knemorc") );
-
     setupToolTipMap();
 
     QWidget *main = new QWidget( this );
     QVBoxLayout* top = new QVBoxLayout( this );
     mDlg->setupUi( main );
     top->addWidget( main );
     statsModel = new StatsRuleModel( this );
     QStringList l;
     l << i18n( "Start Date" ) << i18n( "Period" );
     statsModel->setHorizontalHeaderLabels( l );
     QSortFilterProxyModel *proxy = new QSortFilterProxyModel( mDlg->statsView );
     proxy->setSourceModel( statsModel );
     proxy->setSortRole( Qt::UserRole + 1 );
     mDlg->statsView->setModel( proxy );
     mDlg->statsView->sortByColumn( 0, Qt::AscendingOrder );
 
     warnModel = new WarnModel( this );
     l.clear();
     l << i18n( "Alert" ) << i18n( "Period" );
     warnModel->setHorizontalHeaderLabels( l );
     mDlg->warnView->setModel( warnModel );
 
     QList<KNemoTheme> themes = findThemes();
     qSort( themes.begin(), themes.end(), themesLessThan );
     foreach ( KNemoTheme theme, themes )
         mDlg->comboBoxIconTheme->addItem( theme.name, QVariant::fromValue( theme ) );
 
     // We want these hardcoded and at the bottom of the list
     KNemoTheme systemTheme;
     systemTheme.name = i18n( "System Theme" );
     systemTheme.comment = i18n( "Use the current icon theme's network status icons" );
     systemTheme.internalName = SYSTEM_THEME;
 
     KNemoTheme textTheme;
     textTheme.name = i18n( "Text" );
     textTheme.comment = i18n( "KNemo theme that shows the upload/download speed as text" );
     textTheme.internalName = TEXT_THEME;
 
     KNemoTheme netloadTheme;
     netloadTheme.name = i18n( "Netload" );
     netloadTheme.comment = i18n( "KNemo theme that shows the upload/download speed as bar graphs" );
     netloadTheme.internalName = NETLOAD_THEME;
 
     // Leave this out for now.  Looks like none of the KDE icon themes provide
     // status/network-* icons.
     //mDlg->comboBoxIconTheme->addItem( systemTheme.name, QVariant::fromValue( systemTheme ) );
     mDlg->comboBoxIconTheme->addItem( netloadTheme.name, QVariant::fromValue( netloadTheme ) );
     mDlg->comboBoxIconTheme->addItem( textTheme.name, QVariant::fromValue( textTheme ) );
 
     InterfaceSettings s;
     int index = findIndexFromName( s.iconTheme );
     if ( index < 0 )
         index = findIndexFromName( TEXT_THEME );
     mDlg->comboBoxIconTheme->setCurrentIndex( index );
 
     for ( size_t i = 0; i < sizeof(pollIntervals)/sizeof(double); i++ )
         mDlg->comboBoxPoll->addItem( i18n( "%1 sec", pollIntervals[i] ), pollIntervals[i] );
 
     mDlg->pushButtonNew->setIcon( QIcon::fromTheme( QLatin1String("list-add") ) );
     mDlg->pushButtonAll->setIcon( QIcon::fromTheme( QLatin1String("document-new") ) );
     mDlg->pushButtonDelete->setIcon( QIcon::fromTheme( QLatin1String("list-remove") ) );
     mDlg->pushButtonAddCommand->setIcon( QIcon::fromTheme( QLatin1String("list-add") ) );
     mDlg->pushButtonRemoveCommand->setIcon( QIcon::fromTheme( QLatin1String("list-remove") ) );
     mDlg->pushButtonUp->setIcon( QIcon::fromTheme( QLatin1String("arrow-up") ) );
     mDlg->pushButtonDown->setIcon( QIcon::fromTheme( QLatin1String("arrow-down") ) );
     mDlg->pushButtonAddToolTip->setIcon( QIcon::fromTheme( QLatin1String("arrow-right") ) );
     mDlg->pushButtonRemoveToolTip->setIcon( QIcon::fromTheme( QLatin1String("arrow-left") ) );
 
     mDlg->themeColorBox->setEnabled( false );
 
     //mDlg->listViewCommands->setSorting( -1 );
 
     setButtons( KCModule::Default | KCModule::Apply );
 
     connect( mDlg->checkBoxStartKNemo, SIGNAL( toggled( bool ) ),
              this, SLOT( checkBoxStartKNemoToggled( bool ) ) );
 
     // Interface
     connect( mDlg->listBoxInterfaces, SIGNAL( currentRowChanged( int ) ),
              this, SLOT( interfaceSelected( int ) ) );
     connect( mDlg->pushButtonNew, SIGNAL( clicked() ),
              this, SLOT( buttonNewSelected() ) );
     connect( mDlg->pushButtonAll, SIGNAL( clicked() ),
              this, SLOT( buttonAllSelected() ) );
     connect( mDlg->pushButtonDelete, SIGNAL( clicked() ),
              this, SLOT( buttonDeleteSelected() ) );
     connect( mDlg->lineEditAlias, SIGNAL( textChanged( const QString& ) ),
              this, SLOT( aliasChanged( const QString& ) ) );
 
     // Interface - Icon Appearance
     connect( mDlg->comboHiding, SIGNAL( activated( int ) ),
              this, SLOT( comboHidingChanged( int ) ) );
     connect( mDlg->comboBoxIconTheme, SIGNAL( activated( int ) ),
              this, SLOT( iconThemeChanged( int ) ) );
     connect( mDlg->colorIncoming, SIGNAL( changed( const QColor& ) ),
              this, SLOT( colorButtonChanged() ) );
     connect( mDlg->colorOutgoing, SIGNAL( changed( const QColor& ) ),
              this, SLOT( colorButtonChanged() ) );
     connect( mDlg->colorDisabled, SIGNAL( changed( const QColor& ) ),
              this, SLOT( colorButtonChanged() ) );
     connect( mDlg->colorUnavailable, SIGNAL( changed( const QColor& ) ),
              this, SLOT( colorButtonChanged() ) );
     connect( mDlg->iconFont, SIGNAL( currentFontChanged( const QFont& ) ),
              this, SLOT( iconFontChanged( const QFont& ) ) );
     connect( mDlg->advancedButton, SIGNAL( clicked() ),
              this, SLOT( advancedButtonClicked() ) );
 
     // Interface - Statistics
     connect( mDlg->checkBoxStatistics, SIGNAL( toggled( bool ) ),
              this, SLOT( checkBoxStatisticsToggled ( bool ) ) );
     connect( mDlg->addStats, SIGNAL( clicked() ),
              this, SLOT( addStatsClicked() ) );
     connect( mDlg->modifyStats, SIGNAL( clicked() ),
              this, SLOT( modifyStatsClicked() ) );
     connect( mDlg->removeStats, SIGNAL( clicked() ),
              this, SLOT( removeStatsClicked() ) );
     connect( mDlg->addWarn, SIGNAL( clicked() ),
              this, SLOT( addWarnClicked() ) );
     connect( mDlg->modifyWarn, SIGNAL( clicked() ),
              this, SLOT( modifyWarnClicked() ) );
     connect( mDlg->removeWarn, SIGNAL( clicked() ),
              this, SLOT( removeWarnClicked() ) );
 
     // Interface - Context Menu
     connect( mDlg->listViewCommands, SIGNAL( currentItemChanged( QTreeWidgetItem*, QTreeWidgetItem* ) ),
              this, SLOT( listViewCommandsSelectionChanged( QTreeWidgetItem*, QTreeWidgetItem* ) ) );
     connect( mDlg->listViewCommands, SIGNAL( itemChanged( QTreeWidgetItem*, int ) ),
              this, SLOT( listViewCommandsChanged( QTreeWidgetItem*, int ) ) );
     connect( mDlg->pushButtonAddCommand, SIGNAL( clicked() ),
              this, SLOT( buttonAddCommandSelected() ) );
     connect( mDlg->pushButtonRemoveCommand, SIGNAL( clicked() ),
              this, SLOT( buttonRemoveCommandSelected() ) );
     connect( mDlg->pushButtonUp, SIGNAL( clicked() ),
              this, SLOT( buttonCommandUpSelected() ) );
     connect( mDlg->pushButtonDown, SIGNAL( clicked() ),
              this, SLOT( buttonCommandDownSelected() ) );
 
     // ToolTip
     connect( mDlg->pushButtonAddToolTip, SIGNAL( clicked() ),
              this, SLOT( buttonAddToolTipSelected() ) );
     connect( mDlg->pushButtonRemoveToolTip, SIGNAL( clicked() ),
              this, SLOT( buttonRemoveToolTipSelected() ) );
 
     // General
     connect( mDlg->pushButtonNotifications, SIGNAL( clicked() ),
              this, SLOT( buttonNotificationsSelected() ) );
     connect( mDlg->comboBoxPoll, SIGNAL( currentIndexChanged( int ) ),
              this, SLOT( changed() ) );
     connect( mDlg->numInputSaveInterval, SIGNAL( valueChanged( int ) ),
              this, SLOT( changed() ) );
     connect( mDlg->useBitrate, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
 }
 
 ConfigDialog::~ConfigDialog()
 {
     delete mDlg;
 }
 
 void ConfigDialog::load()
 {
     mSettingsMap.clear();
     mDlg->listBoxInterfaces->clear();
-    KConfig *config = mConfig.data();
+    KSharedConfig::Ptr config = KSharedConfig::openConfig( QLatin1String("knemorc") );
 
     KConfigGroup generalGroup( config, confg_general );
     bool startKNemo = generalGroup.readEntry( conf_autoStart, true );
     mDlg->checkBoxStartKNemo->setChecked( startKNemo );
     GeneralSettings g;
     double pollVal = clamp<double>(generalGroup.readEntry( conf_pollInterval, g.pollInterval ), 0.1, 2.0 );
     pollVal = validatePoll( pollVal );
     int index = mDlg->comboBoxPoll->findData( pollVal );
     if ( index >= 0 )
         mDlg->comboBoxPoll->setCurrentIndex( index );
     mDlg->numInputSaveInterval->setValue( clamp<int>(generalGroup.readEntry( conf_saveInterval, g.saveInterval ), 0, 300 ) );
     mDlg->useBitrate->setChecked( generalGroup.readEntry( conf_useBitrate, g.useBitrate ) );
     mToolTipContent = generalGroup.readEntry( conf_toolTipContent, g.toolTipContent );
 
     QStringList list = generalGroup.readEntry( conf_interfaces, QStringList() );
 
     // Get defaults from the struct
     InterfaceSettings s;
     foreach ( QString interface, list )
     {
         QString group( confg_interface );
         group += interface;
         InterfaceSettings* settings = new InterfaceSettings();
         if ( config->hasGroup( group ) )
         {
             KConfigGroup interfaceGroup( config, group );
             settings->alias = interfaceGroup.readEntry( conf_alias ).trimmed();
             settings->hideWhenDisconnected = interfaceGroup.readEntry( conf_hideWhenNotAvail, s.hideWhenDisconnected );
             settings->hideWhenUnavailable = interfaceGroup.readEntry( conf_hideWhenNotExist, s.hideWhenUnavailable );
             settings->trafficThreshold = clamp<int>(interfaceGroup.readEntry( conf_trafficThreshold, s.trafficThreshold ), 0, 1000 );
             settings->iconTheme = interfaceGroup.readEntry( conf_iconTheme, s.iconTheme );
             settings->colorIncoming = interfaceGroup.readEntry( conf_colorIncoming, s.colorIncoming );
             settings->colorOutgoing = interfaceGroup.readEntry( conf_colorOutgoing, s.colorOutgoing );
             KColorScheme scheme(QPalette::Active, KColorScheme::View);
             settings->colorDisabled = interfaceGroup.readEntry( conf_colorDisabled, scheme.foreground( KColorScheme::InactiveText ).color() );
             settings->colorUnavailable = interfaceGroup.readEntry( conf_colorUnavailable, scheme.foreground( KColorScheme::InactiveText ).color() );
             settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
             settings->iconFont = interfaceGroup.readEntry( conf_iconFont, s.iconFont );
             settings->dynamicColor = interfaceGroup.readEntry( conf_dynamicColor, s.dynamicColor );
             settings->colorIncomingMax = interfaceGroup.readEntry( conf_colorIncomingMax, s.colorIncomingMax );
             settings->colorOutgoingMax = interfaceGroup.readEntry( conf_colorOutgoingMax, s.colorOutgoingMax );
             settings->barScale = interfaceGroup.readEntry( conf_barScale, s.barScale );
             settings->inMaxRate = interfaceGroup.readEntry( conf_inMaxRate, s.inMaxRate );
             settings->outMaxRate = interfaceGroup.readEntry( conf_outMaxRate, s.outMaxRate );
             settings->calendarSystem = static_cast<KLocale::CalendarSystem>(interfaceGroup.readEntry( conf_calendarSystem, static_cast<int>(KLocale::QDateCalendar) ));
             settings->activateStatistics = interfaceGroup.readEntry( conf_activateStatistics, s.activateStatistics );
             int statsRuleCount = interfaceGroup.readEntry( conf_statsRules, 0 );
             for ( int i = 0; i < statsRuleCount; ++i )
             {
                 group = QString::fromLatin1( "%1%2 #%3" ).arg( confg_statsRule ).arg( interface ).arg( i );
                 if ( config->hasGroup( group ) )
                 {
                     KConfigGroup statsGroup( config, group );
                     StatsRule stats;
 
                     stats.startDate = statsGroup.readEntry( conf_statsStartDate, QDate() );
                     stats.periodUnits = clamp<int>(statsGroup.readEntry( conf_statsPeriodUnits, stats.periodUnits ), KNemoStats::Day, KNemoStats::Year );
                     stats.periodCount = clamp<int>(statsGroup.readEntry( conf_statsPeriodCount, stats.periodCount ), 1, 1000 );
                     stats.logOffpeak = statsGroup.readEntry( conf_logOffpeak,stats.logOffpeak );
                     stats.offpeakStartTime = QTime::fromString( statsGroup.readEntry( conf_offpeakStartTime, stats.offpeakStartTime.toString( Qt::ISODate ) ), Qt::ISODate );
                     stats.offpeakEndTime = QTime::fromString( statsGroup.readEntry( conf_offpeakEndTime, stats.offpeakEndTime.toString( Qt::ISODate ) ), Qt::ISODate );
                     stats.weekendIsOffpeak = statsGroup.readEntry( conf_weekendIsOffpeak, stats.weekendIsOffpeak );
                     stats.weekendDayStart = statsGroup.readEntry( conf_weekendDayStart, stats.weekendDayStart );
                     stats.weekendDayEnd = statsGroup.readEntry( conf_weekendDayEnd, stats.weekendDayEnd );
                     stats.weekendTimeStart = QTime::fromString( statsGroup.readEntry( conf_weekendTimeStart, stats.weekendTimeStart.toString( Qt::ISODate ) ), Qt::ISODate );
                     stats.weekendTimeEnd = QTime::fromString( statsGroup.readEntry( conf_weekendTimeEnd, stats.weekendTimeEnd.toString( Qt::ISODate ) ), Qt::ISODate );
                     settings->statsRules << stats;
                 }
             }
 
             int warnRuleCount = interfaceGroup.readEntry( conf_warnRules, 0 );
             for ( int i = 0; i < warnRuleCount; ++i )
             {
                 group = QString::fromLatin1( "%1%2 #%3" ).arg( confg_warnRule ).arg( interface ).arg( i );
                 if ( config->hasGroup( group ) )
                 {
                     KConfigGroup warnGroup( config, group );
                     WarnRule warn;
 
                     warn.periodUnits = clamp<int>(warnGroup.readEntry( conf_warnPeriodUnits, warn.periodUnits ), KNemoStats::Hour, KNemoStats::Year );
                     warn.periodCount = clamp<int>(warnGroup.readEntry( conf_warnPeriodCount, warn.periodCount ), 1, 1000 );
                     warn.trafficType = clamp<int>(warnGroup.readEntry( conf_warnTrafficType, warn.trafficType ), KNemoStats::Peak, KNemoStats::PeakOffpeak );
                     warn.trafficDirection = clamp<int>(warnGroup.readEntry( conf_warnTrafficDirection, warn.trafficDirection ), KNemoStats::TrafficIn, KNemoStats::TrafficTotal );
                     warn.trafficUnits = clamp<int>(warnGroup.readEntry( conf_warnTrafficUnits, warn.trafficUnits ), KNemoStats::UnitB, KNemoStats::UnitG );
                     warn.threshold = clamp<double>(warnGroup.readEntry( conf_warnThreshold, warn.threshold ), 0.0, 9999.0 );
                     warn.customText = warnGroup.readEntry( conf_warnCustomText, warn.customText ).trimmed();
 
                     settings->warnRules << warn;
                 }
             }
 
             int numCommands = interfaceGroup.readEntry( conf_numCommands, s.numCommands );
             for ( int i = 0; i < numCommands; i++ )
             {
                 QString entry;
                 InterfaceCommand cmd;
                 entry = QString::fromLatin1( "%1%2" ).arg( conf_runAsRoot ).arg( i + 1 );
                 cmd.runAsRoot = interfaceGroup.readEntry( entry, false );
                 entry = QString::fromLatin1( "%1%2" ).arg( conf_command ).arg( i + 1 );
                 cmd.command = interfaceGroup.readEntry( entry );
                 entry = QString::fromLatin1( "%1%2" ).arg( conf_menuText ).arg( i + 1 );
                 cmd.menuText = interfaceGroup.readEntry( entry );
                 settings->commands.append( cmd );
             }
         }
         mSettingsMap.insert( interface, settings );
         mDlg->listBoxInterfaces->addItem( interface );
         mDlg->pushButtonDelete->setEnabled( true );
         mDlg->ifaceTab->setEnabled( true );
     }
 
     // These things need to be here so that 'Reset' from the control
     // center is handled correctly.
     setupToolTipTab();
 
     // In case the user opened the control center via the context menu
     // this call to the daemon will deliver the interface the menu
     // belongs to. This way we can preselect the appropriate entry in the list.
     QString selectedInterface = QString::null;
     QDBusMessage reply = QDBusInterface(QLatin1String("org.kde.knemo"), QLatin1String("/knemo"), QLatin1String("org.kde.knemo")).call(QLatin1String("getSelectedInterface"));
     if ( reply.arguments().count() )
     {
         selectedInterface = reply.arguments().first().toString();
     }
 
     if ( selectedInterface != QString::null )
     {
         // Try to preselect the interface.
         int i;
         for ( i = 0; i < mDlg->listBoxInterfaces->count(); i++ )
         {
             if ( mDlg->listBoxInterfaces->item( i )->text() == selectedInterface )
             {
                 // Found it.
                 mDlg->listBoxInterfaces->setCurrentRow( i );
                 break;
             }
         }
         if ( i == mDlg->listBoxInterfaces->count() )
         {
             // Not found. Select first entry in list.
             mDlg->listBoxInterfaces->setCurrentRow( 0 );
         }
     }
     else if ( mDlg->listBoxInterfaces->count() )
     {
         // No interface from KNemo. Select first entry in list.
         mDlg->listBoxInterfaces->setCurrentRow( 0 );
     }
 }
 
 void ConfigDialog::save()
 {
-    KConfig *config = mConfig.data();
+    KSharedConfig::Ptr config = KSharedConfig::openConfig( QLatin1String("knemorc") );
 
     QStringList list;
 
     // Remove interfaces from the config that were deleted during this session
     foreach ( QString delIface, mDeletedIfaces )
     {
         if ( !mSettingsMap.contains( delIface ) )
         {
             config->deleteGroup( confg_interface + delIface );
             config->deleteGroup( confg_plotter + delIface );
         }
     }
 
     QStringList groupList = config->groupList();
     foreach ( QString tempDel, groupList )
     {
         if ( tempDel.contains( confg_statsRule ) || tempDel.contains( confg_warnRule ) )
             config->deleteGroup( tempDel );
     }
 
     foreach ( QString it, mSettingsMap.keys() )
     {
         list.append( it );
         InterfaceSettings* settings = mSettingsMap.value( it );
         KConfigGroup interfaceGroup( config, confg_interface + it );
 
         // Preserve settings set by the app before delete
         QPoint plotterPos = interfaceGroup.readEntry( conf_plotterPos, QPoint() );
         QSize plotterSize = interfaceGroup.readEntry( conf_plotterSize, QSize() );
         QPoint statisticsPos = interfaceGroup.readEntry( conf_statisticsPos, QPoint() );
         QSize statisticsSize = interfaceGroup.readEntry( conf_statisticsSize, QSize() );
         QPoint statusPos = interfaceGroup.readEntry( conf_statusPos, QPoint() );
         QSize statusSize = interfaceGroup.readEntry( conf_statusSize, QSize() );
         QByteArray hourState = interfaceGroup.readEntry( conf_hourState, QByteArray() );
         QByteArray dayState = interfaceGroup.readEntry( conf_dayState, QByteArray() );
         QByteArray weekState = interfaceGroup.readEntry( conf_weekState, QByteArray() );
         QByteArray monthState = interfaceGroup.readEntry( conf_monthState, QByteArray() );
         QByteArray billingState = interfaceGroup.readEntry( conf_billingState, QByteArray() );
         QByteArray yearState = interfaceGroup.readEntry( conf_yearState, QByteArray() );
 
         // Make sure we don't get crufty commands left over
         interfaceGroup.deleteGroup();
 
         if ( !plotterPos.isNull() )
             interfaceGroup.writeEntry( conf_plotterPos, plotterPos );
         if ( !plotterSize.isEmpty() )
             interfaceGroup.writeEntry( conf_plotterSize, plotterSize );
         if ( !statisticsPos.isNull() )
             interfaceGroup.writeEntry( conf_statisticsPos, statisticsPos );
         if ( !statisticsSize.isEmpty() )
             interfaceGroup.writeEntry( conf_statisticsSize, statisticsSize );
         if ( !statusPos.isNull() )
             interfaceGroup.writeEntry( conf_statusPos, statusPos );
         if ( !statusSize.isEmpty() )
             interfaceGroup.writeEntry( conf_statusSize, statusSize );
         if ( !settings->alias.trimmed().isEmpty() )
             interfaceGroup.writeEntry( conf_alias, settings->alias );
         if ( !hourState.isNull() )
             interfaceGroup.writeEntry( conf_hourState, hourState );
         if ( !dayState.isNull() )
             interfaceGroup.writeEntry( conf_dayState, dayState );
         if ( !weekState.isNull() )
             interfaceGroup.writeEntry( conf_weekState, weekState );
         if ( !monthState.isNull() )
             interfaceGroup.writeEntry( conf_monthState, monthState );
         if ( !billingState.isNull() )
             interfaceGroup.writeEntry( conf_billingState, billingState );
         if ( !yearState.isNull() )
             interfaceGroup.writeEntry( conf_yearState, yearState );
 
         interfaceGroup.writeEntry( conf_hideWhenNotAvail, settings->hideWhenDisconnected );
         interfaceGroup.writeEntry( conf_hideWhenNotExist, settings->hideWhenUnavailable );
         interfaceGroup.writeEntry( conf_trafficThreshold, settings->trafficThreshold );
         interfaceGroup.writeEntry( conf_iconTheme, settings->iconTheme );
         if ( settings->iconTheme == TEXT_THEME ||
              settings->iconTheme == NETLOAD_THEME
            )
         {
             interfaceGroup.writeEntry( conf_colorIncoming, settings->colorIncoming );
             interfaceGroup.writeEntry( conf_colorOutgoing, settings->colorOutgoing );
             interfaceGroup.writeEntry( conf_colorDisabled, settings->colorDisabled );
             interfaceGroup.writeEntry( conf_colorUnavailable, settings->colorUnavailable );
             interfaceGroup.writeEntry( conf_dynamicColor, settings->dynamicColor );
             if ( settings->dynamicColor )
             {
                 interfaceGroup.writeEntry( conf_colorIncomingMax, settings->colorIncomingMax );
                 interfaceGroup.writeEntry( conf_colorOutgoingMax, settings->colorOutgoingMax );
             }
             if ( settings->iconTheme == NETLOAD_THEME )
             {
                 interfaceGroup.writeEntry( conf_barScale, settings->barScale );
             }
             if ( settings->iconTheme == TEXT_THEME && settings->iconFont != QFontDatabase::systemFont( QFontDatabase::GeneralFont ) )
             {
                 interfaceGroup.writeEntry( conf_iconFont, settings->iconFont );
             }
             if ( settings->dynamicColor ||
                  ( settings->iconTheme == NETLOAD_THEME && settings->barScale )
                )
             {
                 interfaceGroup.writeEntry( conf_inMaxRate, settings->inMaxRate );
                 interfaceGroup.writeEntry( conf_outMaxRate, settings->outMaxRate );
             }
         }
         interfaceGroup.writeEntry( conf_activateStatistics, settings->activateStatistics );
         interfaceGroup.writeEntry( conf_calendarSystem, static_cast<int>(settings->calendarSystem) );
         interfaceGroup.writeEntry( conf_statsRules, settings->statsRules.count() );
         for ( int i = 0; i < settings->statsRules.count(); i++ )
         {
             QString group = QString::fromLatin1( "%1%2 #%3" ).arg( confg_statsRule ).arg( it ).arg( i );
             KConfigGroup statsGroup( config, group );
             statsGroup.writeEntry( conf_statsStartDate, settings->statsRules[i].startDate );
             statsGroup.writeEntry( conf_statsPeriodUnits, settings->statsRules[i].periodUnits );
             statsGroup.writeEntry( conf_statsPeriodCount, settings->statsRules[i].periodCount );
             statsGroup.writeEntry( conf_logOffpeak, settings->statsRules[i].logOffpeak );
             if ( settings->statsRules[i].logOffpeak )
             {
                 statsGroup.writeEntry( conf_offpeakStartTime, settings->statsRules[i].offpeakStartTime.toString( Qt::ISODate ) );
                 statsGroup.writeEntry( conf_offpeakEndTime, settings->statsRules[i].offpeakEndTime.toString( Qt::ISODate ) );
                 statsGroup.writeEntry( conf_weekendIsOffpeak, settings->statsRules[i].weekendIsOffpeak );
                 if ( settings->statsRules[i].weekendIsOffpeak )
                 {
                     statsGroup.writeEntry( conf_weekendDayStart, settings->statsRules[i].weekendDayStart );
                     statsGroup.writeEntry( conf_weekendDayEnd, settings->statsRules[i].weekendDayEnd );
                     statsGroup.writeEntry( conf_weekendTimeStart, settings->statsRules[i].weekendTimeStart.toString( Qt::ISODate ) );
                     statsGroup.writeEntry( conf_weekendTimeEnd, settings->statsRules[i].weekendTimeEnd.toString( Qt::ISODate ) );
                 }
             }
         }
         interfaceGroup.writeEntry( conf_warnRules, settings->warnRules.count() );
         for ( int i = 0; i < settings->warnRules.count(); i++ )
         {
             QString group = QString::fromLatin1( "%1%2 #%3" ).arg( confg_warnRule ).arg( it ).arg( i );
             KConfigGroup warnGroup( config, group );
             if ( settings->statsRules.count() == 0 && settings->warnRules[i].periodUnits == KNemoStats::BillPeriod )
             {
                 warnGroup.writeEntry( conf_warnPeriodUnits, static_cast<int>(KNemoStats::Month) );
             }
             else
             {
                 warnGroup.writeEntry( conf_warnPeriodUnits, settings->warnRules[i].periodUnits );
             }
             warnGroup.writeEntry( conf_warnPeriodCount, settings->warnRules[i].periodCount );
             warnGroup.writeEntry( conf_warnTrafficType, settings->warnRules[i].trafficType );
             warnGroup.writeEntry( conf_warnTrafficDirection, settings->warnRules[i].trafficDirection );
             warnGroup.writeEntry( conf_warnTrafficUnits, settings->warnRules[i].trafficUnits );
             warnGroup.writeEntry( conf_warnThreshold, settings->warnRules[i].threshold );
             warnGroup.writeEntry( conf_warnCustomText, settings->warnRules[i].customText.trimmed() );
         }
 
         interfaceGroup.writeEntry( conf_numCommands, settings->commands.size() );
         for ( int i = 0; i < settings->commands.size(); i++ )
         {
             QString entry;
             entry = QString::fromLatin1( "%1%2" ).arg( conf_runAsRoot ).arg( i + 1 );
             interfaceGroup.writeEntry( entry, settings->commands[i].runAsRoot );
             entry = QString::fromLatin1( "%1%2" ).arg( conf_command ).arg( i + 1 );
             interfaceGroup.writeEntry( entry, settings->commands[i].command );
             entry = QString::fromLatin1( "%1%2" ).arg( conf_menuText ).arg( i + 1 );
             interfaceGroup.writeEntry( entry, settings->commands[i].menuText );
         }
     }
 
     KConfigGroup generalGroup( config, confg_general );
     generalGroup.writeEntry( conf_firstStart, false );
     generalGroup.writeEntry( conf_autoStart, mDlg->checkBoxStartKNemo->isChecked() );
     generalGroup.writeEntry( conf_pollInterval, mDlg->comboBoxPoll->itemData( mDlg->comboBoxPoll->currentIndex() ).value<double>() );
     generalGroup.writeEntry( conf_saveInterval, mDlg->numInputSaveInterval->value() );
     generalGroup.writeEntry( conf_useBitrate, mDlg->useBitrate->isChecked() );
     generalGroup.writeEntry( conf_toolTipContent, mToolTipContent );
     generalGroup.writeEntry( conf_interfaces, list );
 
     config->sync();
     QDBusMessage reply = QDBusInterface(QLatin1String("org.kde.knemo"), QLatin1String("/knemo"), QLatin1String("org.kde.knemo")).call(QLatin1String("reparseConfiguration"));
 }
 
 void ConfigDialog::defaults()
 {
     // Set these values before we check for default interfaces
     mSettingsMap.clear();
     mDlg->listBoxInterfaces->clear();
     mDlg->pushButtonDelete->setEnabled( false );
 
     InterfaceSettings emptySettings;
     updateControls( &emptySettings );
 
     // Default interface
     void *cache = NULL;
 
 #ifdef __linux__
 	struct nl_sock *rtsock = nl_socket_alloc();
 	int c = nl_connect(rtsock, NETLINK_ROUTE);
     if ( c >= 0 )
     {
 	    rtnl_route_alloc_cache( rtsock, AF_UNSPEC, NL_AUTO_PROVIDE, reinterpret_cast<nl_cache**>(&cache) );
     }
 #endif
 
     QString interface = getDefaultRoute( AF_INET, NULL, cache );
     if ( interface.isEmpty() )
         interface = getDefaultRoute( AF_INET6, NULL, cache );
 #ifdef __linux__
     nl_cache_free( static_cast<nl_cache*>(cache) );
     nl_close( rtsock );
     nl_socket_free( rtsock );
 #endif
 
     if ( interface.isEmpty() )
     {
         mDlg->aliasLabel->setEnabled( false );
         mDlg->lineEditAlias->setEnabled( false );
         mDlg->ifaceTab->setEnabled( false );
         mDlg->pixmapError->clear();
         mDlg->pixmapDisconnected->clear();
         mDlg->pixmapConnected->clear();
         mDlg->pixmapIncoming->clear();
         mDlg->pixmapOutgoing->clear();
         mDlg->pixmapTraffic->clear();
     }
     else
     {
         InterfaceSettings* settings = new InterfaceSettings();
         KColorScheme scheme(QPalette::Active, KColorScheme::View);
         settings->colorDisabled = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->colorUnavailable = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->iconFont = QFontDatabase::systemFont( QFontDatabase::GeneralFont );
         mSettingsMap.insert( interface, settings );
         mDlg->listBoxInterfaces->addItem( interface );
         mDlg->listBoxInterfaces->setCurrentRow( 0 );
         mDlg->pushButtonDelete->setEnabled( true );
         mDlg->aliasLabel->setEnabled( true );
         mDlg->lineEditAlias->setEnabled( true );
         mDlg->ifaceTab->setEnabled( true );
     }
 
     // Default general settings
     GeneralSettings g;
     int index = mDlg->comboBoxPoll->findData( g.pollInterval );
     if ( index >= 0 )
         mDlg->comboBoxPoll->setCurrentIndex( index );
     mDlg->numInputSaveInterval->setValue( g.saveInterval );
     mDlg->useBitrate->setChecked( g.useBitrate );
 
     // Default tool tips
     mToolTipContent = g.toolTipContent;
     setupToolTipTab();
 
     changed( true );
 }
 
 void ConfigDialog::checkBoxStartKNemoToggled( bool on )
 {
     if ( on )
     {
-        KConfig *config = mConfig.data();
+        KSharedConfig::Ptr config = KSharedConfig::openConfig( QLatin1String("knemorc") );
         KConfigGroup generalGroup( config, confg_general );
         if ( generalGroup.readEntry( conf_firstStart, true ) )
         {
             // Populate the dialog with some default values if the user starts
             // KNemo for the very first time.
             defaults();
         }
     }
 
     if (!mLock) changed( true );
 }
 
 
 
 /******************************************
  *                                        *
  * Interface tab                          *
  *                                        *
  ******************************************/
 
 InterfaceSettings * ConfigDialog::getItemSettings()
 {
     if ( !mDlg->listBoxInterfaces->currentItem() )
         return NULL;
 
     QListWidgetItem* selected = mDlg->listBoxInterfaces->currentItem();
 
     return mSettingsMap[selected->text()];
 }
 
 QString ConfigDialog::findNameFromIndex( int index )
 {
     KNemoTheme theme = mDlg->comboBoxIconTheme->itemData( index ).value<KNemoTheme>();
     return theme.internalName;
 }
 
 int ConfigDialog::findIndexFromName( const QString& internalName )
 {
     for( int i = 0; i < mDlg->comboBoxIconTheme->count(); i++ )
     {
         KNemoTheme theme = mDlg->comboBoxIconTheme->itemData( i ).value<KNemoTheme>();
         if ( theme.internalName == internalName )
             return i;
     }
     return -1;
 }
 
 void ConfigDialog::updateWarnText( int oldCount )
 {
     // If the billing periods go away, the warn period will change to months
     // This only changes the text displayed in the model, so it can change
     // back if a billing period reappears.
     if ( ! statsModel->rowCount() )
     {
         QList<WarnRule> warnRules = warnModel->getRules();
         for ( int i = 0; i < warnRules.count(); ++i )
         {
             if ( warnRules[i].periodUnits == KNemoStats::BillPeriod )
             {
                 warnModel->item( i, 1 )->setData( periodText( warnRules[i].periodCount, KNemoStats::Month ), Qt::DisplayRole );
             }
         }
     }
     else if ( oldCount == 0 )
     {
         QList<WarnRule> warnRules = warnModel->getRules();
         for ( int i = 0; i < warnRules.count(); ++i )
         {
             if ( warnRules[i].periodUnits == KNemoStats::BillPeriod )
                 warnModel->item( i, 1 )->setData( periodText( warnRules[i].periodCount, warnRules[i].periodUnits ), Qt::DisplayRole );
         }
     }
 }
 
 void ConfigDialog::updateControls( InterfaceSettings *settings )
 {
     mLock = true;
     mDlg->lineEditAlias->setText( settings->alias );
     int index = findIndexFromName( settings->iconTheme );
     if ( index < 0 )
         index = findIndexFromName( TEXT_THEME );
     mDlg->comboBoxIconTheme->setCurrentIndex( index );
     mDlg->colorIncoming->setColor( settings->colorIncoming );
     mDlg->colorOutgoing->setColor( settings->colorOutgoing );
     mDlg->colorDisabled->setColor( settings->colorDisabled );
     mDlg->colorUnavailable->setColor( settings->colorUnavailable );
     mDlg->iconFont->setCurrentFont( settings->iconFont );
     iconThemeChanged( index );
     if ( settings->hideWhenDisconnected )
         index = 1;
     else if ( settings->hideWhenUnavailable )
         index = 2;
     else
         index = 0;
     mDlg->comboHiding->setCurrentIndex( index );
     comboHidingChanged( index );
     mDlg->checkBoxStatistics->setChecked( settings->activateStatistics );
 
     if ( !mCalendar || mCalendar->calendarSystem() != settings->calendarSystem )
         mCalendar = KCalendarSystem::create( settings->calendarSystem );
 
     statsModel->removeRows(0, statsModel->rowCount() );
     statsModel->setCalendar( mCalendar );
     foreach( StatsRule s, settings->statsRules )
     {
         statsModel->addRule( s );
     }
     if ( statsModel->rowCount() )
     {
         QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
         QModelIndex index = statsModel->indexFromItem( statsModel->item( 0, 0 ) );
         mDlg->statsView->setCurrentIndex( proxy->mapFromSource( index ) );
     }
     mDlg->modifyStats->setEnabled( statsModel->rowCount() );
     mDlg->removeStats->setEnabled( statsModel->rowCount() );
 
     warnModel->removeRows(0, warnModel->rowCount() );
     foreach( WarnRule warn, settings->warnRules )
     {
         warnModel->addWarn( warn );
     }
     updateWarnText( statsModel->rowCount() );
 
     mDlg->modifyWarn->setEnabled( warnModel->rowCount() );
     mDlg->removeWarn->setEnabled( warnModel->rowCount() );
     if ( warnModel->rowCount() )
     {
         mDlg->warnView->setCurrentIndex( warnModel->indexFromItem ( warnModel->item( 0, 0 ) ) );
     }
 
     mDlg->listViewCommands->clear();
     QList<QTreeWidgetItem *>items;
     foreach ( InterfaceCommand command, settings->commands )
     {
         QTreeWidgetItem* item = new QTreeWidgetItem();
         enum Qt::CheckState checkState = Qt::Unchecked;
         if ( command.runAsRoot )
             checkState = Qt::Checked;
         item->setCheckState( 0, checkState );
         item->setFlags( item->flags() | Qt::ItemIsEditable );
         item->setText( 1, command.menuText );
         item->setText( 2, command.command );
         items << item;
     }
     if ( items.count() > 0 )
     {
         mDlg->listViewCommands->addTopLevelItems( items );
         mDlg->listViewCommands->setCurrentItem( items[0] );
         mDlg->pushButtonRemoveCommand->setEnabled( true );
         setUpDownButtons( items[0] );
     }
     else
     {
         mDlg->pushButtonRemoveCommand->setEnabled( false );
         setUpDownButtons( NULL );
     }
     mLock = false;
 }
 
 void ConfigDialog::interfaceSelected( int row )
 {
     if ( row < 0 )
         return;
     QString interface = mDlg->listBoxInterfaces->item( row )->text();
     InterfaceSettings* settings = mSettingsMap[interface];
     mDlg->ifaceTab->setEnabled( true );
     mDlg->aliasLabel->setEnabled( true );
     mDlg->lineEditAlias->setEnabled( true );
     updateControls( settings );
 }
 
 void ConfigDialog::buttonNewSelected()
 {
     bool ok = false;
     QString ifname = QInputDialog::getText( this, i18n( "Add new interface" ),
                                             i18n( "Please enter the name of the interface to be monitored.\nIt should be something like 'eth1', 'wlan2' or 'ppp0'." ),
                                             QLineEdit::Normal,
                                             QString::null,
                                             &ok );
 
     if ( ok )
     {
         QListWidgetItem *item = new QListWidgetItem( ifname );
         mDlg->listBoxInterfaces->addItem( item );
         InterfaceSettings *settings = new InterfaceSettings();
         KColorScheme scheme(QPalette::Active, KColorScheme::View);
         settings->colorDisabled = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->colorUnavailable = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->iconFont = QFontDatabase::systemFont( QFontDatabase::GeneralFont );
         mSettingsMap.insert( ifname, settings );
         mDlg->listBoxInterfaces->setCurrentRow( mDlg->listBoxInterfaces->row( item ) );
         mDlg->pushButtonDelete->setEnabled( true );
         changed( true );
     }
 }
 
 void ConfigDialog::buttonAllSelected()
 {
     QStringList ifaces;
 
 #ifdef __linux__
     nl_cache * linkCache = NULL;
     nl_sock *rtsock = nl_socket_alloc();
     int c = nl_connect(rtsock, NETLINK_ROUTE);
     if ( c >= 0 )
     {
         rtnl_link_alloc_cache( rtsock, AF_UNSPEC, &linkCache );
 
         struct rtnl_link * rtlink;
         for ( rtlink = reinterpret_cast<struct rtnl_link *>(nl_cache_get_first( linkCache ));
               rtlink != NULL;
               rtlink = reinterpret_cast<struct rtnl_link *>(nl_cache_get_next( reinterpret_cast<struct nl_object *>(rtlink) ))
             )
         {
             QString ifname( QLatin1String(rtnl_link_get_name( rtlink )) );
             ifaces << ifname;
         }
     }
     nl_cache_free( linkCache );
     nl_close( rtsock );
     nl_socket_free( rtsock );
 #else
     struct ifaddrs *ifaddr;
     struct ifaddrs *ifa;
     getifaddrs( &ifaddr );
     for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
     {
         QString ifname( ifa->ifa_name );
         ifaces << ifname;
     }
     freeifaddrs( ifaddr );
 #endif
 
     ifaces.removeAll( QLatin1String("lo") );
     ifaces.removeAll( QLatin1String("lo0") );
 
     const KColorScheme scheme(QPalette::Active, KColorScheme::View);
     foreach ( QString ifname, ifaces )
     {
         if ( mSettingsMap.contains( ifname ) )
             continue;
         InterfaceSettings* settings = new InterfaceSettings();
         settings->colorDisabled = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->colorUnavailable = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
         settings->iconFont = QFontDatabase::systemFont( QFontDatabase::GeneralFont );
         mSettingsMap.insert( ifname, settings );
         mDlg->listBoxInterfaces->addItem( ifname );
     }
 
     if ( mDlg->listBoxInterfaces->count() > 0 )
     {
         mDlg->listBoxInterfaces->setCurrentRow( 0 );
         mDlg->pushButtonDelete->setEnabled( true );
         mDlg->ifaceTab->setEnabled( true );
         QString iface = mDlg->listBoxInterfaces->item( 0 )->text();
     }
     changed( true );
 }
 
 void ConfigDialog::buttonDeleteSelected()
 {
     if ( !mDlg->listBoxInterfaces->currentItem() )
         return;
 
     QListWidgetItem* selected = mDlg->listBoxInterfaces->currentItem();
 
     // To prevent bloat when we save
     if ( !mDeletedIfaces.contains( selected->text() ) )
         mDeletedIfaces << selected->text();
     mSettingsMap.remove( selected->text() );
 
     QListWidgetItem *taken = mDlg->listBoxInterfaces->takeItem( mDlg->listBoxInterfaces->row( selected ) );
     delete taken;
 
     if ( mDlg->listBoxInterfaces->count() < 1 )
     {
         InterfaceSettings emptySettings;
         updateControls( &emptySettings );
         mDlg->pushButtonDelete->setEnabled( false );
         mDlg->aliasLabel->setEnabled( false );
         mDlg->lineEditAlias->setEnabled( false );
         mDlg->ifaceTab->setEnabled( false );
         mDlg->pixmapError->clear();
         mDlg->pixmapDisconnected->clear();
         mDlg->pixmapConnected->clear();
         mDlg->pixmapIncoming->clear();
         mDlg->pixmapOutgoing->clear();
         mDlg->pixmapTraffic->clear();
     }
     changed( true );
 }
 
 void ConfigDialog::aliasChanged( const QString& text )
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     settings->alias = text;
     if (!mLock) changed( true );
 }
 
 
 /******************************************
  *                                        *
  * Interface tab - Icon Appearance        *
  *                                        *
  ******************************************/
 
 QPixmap ConfigDialog::textIcon( QString incomingText, QString outgoingText, int status )
 {
     QPixmap sampleIcon( 22, 22 );
     sampleIcon.fill( Qt::transparent );
     QRect topRect( 0, 0, 22, 11 );
     QRect bottomRect( 0, 11, 22, 11 );
     QPainter p( &sampleIcon );
     p.setBrush( Qt::NoBrush );
     p.setOpacity( 1.0 );
     QFont rxFont = setIconFont( incomingText, mDlg->iconFont->currentFont(), 22 );
     QFont txFont = setIconFont( outgoingText, mDlg->iconFont->currentFont(), 22 );
     if ( rxFont.pointSizeF() > txFont.pointSizeF() )
         rxFont.setPointSizeF( txFont.pointSizeF() );
     p.setFont( rxFont );
     if ( status >= KNemoIface::Connected )
         p.setPen( mDlg->colorIncoming->color() );
     else if ( status == KNemoIface::Available )
         p.setPen( mDlg->colorDisabled->color() );
     else
         p.setPen( mDlg->colorUnavailable->color() );
     p.drawText( topRect, Qt::AlignCenter | Qt::AlignRight, incomingText );
     p.setFont( rxFont );
     if ( status >= KNemoIface::Connected )
         p.setPen( mDlg->colorOutgoing->color() );
     p.drawText( bottomRect, Qt::AlignCenter | Qt::AlignRight, outgoingText );
     return sampleIcon;
 }
 
 QPixmap ConfigDialog::barIcon( int status )
 {
     int barIncoming = 0;
     int barOutgoing = 0;
     QPixmap barIcon( 22, 22 );
     barIcon.fill( Qt::transparent );
     QPainter p( &barIcon );
 
     QLinearGradient inGrad( 12, 0, 19, 0 );
     QLinearGradient topInGrad( 12, 0, 19, 0 );
     QLinearGradient outGrad( 3, 0, 10, 0 );
     QLinearGradient topOutGrad( 3, 0, 10, 0 );
 
     QColor topColor = getItemSettings()->colorBackground;
     QColor topColorD = getItemSettings()->colorBackground.darker();
     topColor.setAlpha( 128 );
     topColorD.setAlpha( 128 );
     topInGrad.setColorAt(0, topColorD);
     topInGrad.setColorAt(1, topColor );
     topOutGrad.setColorAt(0, topColorD);
     topOutGrad.setColorAt(1, topColor );
 
     if ( status & KNemoIface::Connected )
     {
         inGrad.setColorAt(0, mDlg->colorIncoming->color() );
         inGrad.setColorAt(1, mDlg->colorIncoming->color().darker() );
         outGrad.setColorAt(0, mDlg->colorOutgoing->color() );
         outGrad.setColorAt(1, mDlg->colorOutgoing->color().darker() );
     }
     else if ( status & KNemoIface::Available )
     {
         inGrad.setColorAt(0, mDlg->colorDisabled->color());
         inGrad.setColorAt(1, mDlg->colorDisabled->color().darker() );
         outGrad.setColorAt(0, mDlg->colorDisabled->color() );
         outGrad.setColorAt(1, mDlg->colorDisabled->color().darker() );
     }
     else
     {
         inGrad.setColorAt(0, mDlg->colorUnavailable->color() );
         inGrad.setColorAt(1, mDlg->colorUnavailable->color().darker() );
         outGrad.setColorAt(0, mDlg->colorUnavailable->color() );
         outGrad.setColorAt(1, mDlg->colorUnavailable->color().darker() );
     }
     if ( status & KNemoIface::Available || status & KNemoIface::Unavailable )
     {
         barIncoming = 22;
         barOutgoing = 22;
     }
     if ( status & KNemoIface::RxTraffic )
         barIncoming = 17;
     if ( status & KNemoIface::TxTraffic )
         barOutgoing = 17;
 
     int top = 22 - barOutgoing;
     QRect topLeftRect( 3, 0, 7, top );
     QRect leftRect( 3, top, 7, 22 );
     top = 22 - barIncoming;
     QRect topRightRect( 12, 0, 7, top );
     QRect rightRect( 12, top, 7, 22 );
 
     QBrush brush( inGrad );
     p.setBrush( brush );
     p.fillRect( rightRect, inGrad );
     brush = QBrush( topInGrad );
     p.fillRect( topRightRect, topInGrad );
     brush = QBrush( outGrad );
     p.fillRect( leftRect, outGrad );
     brush = QBrush( topOutGrad );
     p.fillRect( topLeftRect, topOutGrad );
     return barIcon;
 }
 
 void ConfigDialog::comboHidingChanged( int val )
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     switch ( val )
     {
         case 0:
             settings->hideWhenDisconnected = false;
             settings->hideWhenUnavailable = false;
             break;
         case 1:
             settings->hideWhenDisconnected = true;
             settings->hideWhenUnavailable = true;
             break;
         case 2:
             settings->hideWhenDisconnected = false;
             settings->hideWhenUnavailable = true;
             break;
     }
 
     if (!mLock) changed( true );
 }
 
 void ConfigDialog::iconThemeChanged( int set )
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     KNemoTheme curTheme = mDlg->comboBoxIconTheme->itemData( mDlg->comboBoxIconTheme->currentIndex() ).value<KNemoTheme>();
 
     if ( curTheme.internalName != TEXT_THEME )
     {
         mDlg->iconFontLabel->setEnabled( false );
         mDlg->iconFont->setEnabled( false );
     }
 
     if ( curTheme.internalName == TEXT_THEME ||
          curTheme.internalName == NETLOAD_THEME )
     {
         if ( curTheme.internalName == TEXT_THEME )
         {
             QString f1 = QStringLiteral("0.0K");
             QString f2 = QStringLiteral("123K");
             QString f3 = QStringLiteral("12K");
 
             settings->iconTheme = TEXT_THEME;
             mDlg->pixmapError->setPixmap( textIcon( f1, f1, KNemoIface::Unavailable ) );
             mDlg->pixmapDisconnected->setPixmap( textIcon( f1, f1, KNemoIface::Available ) );
             mDlg->pixmapConnected->setPixmap( textIcon( f1, f1, KNemoIface::Connected ) );
             mDlg->pixmapIncoming->setPixmap( textIcon( f2, f1, KNemoIface::Connected ) );
             mDlg->pixmapOutgoing->setPixmap( textIcon( f1, f3, KNemoIface::Connected ) );
             mDlg->pixmapTraffic->setPixmap( textIcon( f2, f3, KNemoIface::Connected ) );
             mDlg->iconFontLabel->setEnabled( true );
             mDlg->iconFont->setEnabled( true );
         }
         else
         {
             settings->iconTheme = NETLOAD_THEME;
             mDlg->pixmapError->setPixmap( barIcon( KNemoIface::Unavailable ) );
             mDlg->pixmapDisconnected->setPixmap( barIcon( KNemoIface::Available ) );
             mDlg->pixmapConnected->setPixmap( barIcon( KNemoIface::Connected ) );
             mDlg->pixmapIncoming->setPixmap( barIcon( KNemoIface::Connected | KNemoIface::RxTraffic ) );
             mDlg->pixmapOutgoing->setPixmap( barIcon( KNemoIface::Connected | KNemoIface::TxTraffic ) );
             mDlg->pixmapTraffic->setPixmap( barIcon( KNemoIface::Connected | KNemoIface::RxTraffic | KNemoIface::TxTraffic ) );
         }
 
         mDlg->themeColorBox->setEnabled( true );
     }
     else
     {
         settings->iconTheme = findNameFromIndex( set );
         QString iconName;
         if ( settings->iconTheme == SYSTEM_THEME )
             iconName = QLatin1String("network-");
         else
             iconName = QLatin1String("knemo-") + settings->iconTheme + QLatin1Char('-');
         mDlg->pixmapError->setPixmap( QIcon::fromTheme( iconName + ICON_ERROR ).pixmap( 22 ) );
         mDlg->pixmapDisconnected->setPixmap( QIcon::fromTheme( iconName + ICON_OFFLINE ).pixmap( 22 ) );
         mDlg->pixmapConnected->setPixmap( QIcon::fromTheme( iconName + ICON_IDLE ).pixmap( 22 ) );
         mDlg->pixmapIncoming->setPixmap( QIcon::fromTheme( iconName + ICON_RX ).pixmap( 22 ) );
         mDlg->pixmapOutgoing->setPixmap( QIcon::fromTheme( iconName + ICON_TX ).pixmap( 22 ) );
         mDlg->pixmapTraffic->setPixmap( QIcon::fromTheme( iconName + ICON_RX_TX ).pixmap( 22 ) );
         mDlg->themeColorBox->setEnabled( false );
     }
     if (!mLock) changed( true );
 }
 
 void ConfigDialog::colorButtonChanged()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     if ( mDlg->colorIncoming->color().isValid() )
         settings->colorIncoming = mDlg->colorIncoming->color();
     if ( mDlg->colorOutgoing->color().isValid() )
         settings->colorOutgoing = mDlg->colorOutgoing->color();
     if ( mDlg->colorDisabled->color().isValid() )
         settings->colorDisabled = mDlg->colorDisabled->color();
     if ( mDlg->colorUnavailable->color().isValid() )
         settings->colorUnavailable = mDlg->colorUnavailable->color();
 
     KNemoTheme curTheme = mDlg->comboBoxIconTheme->itemData( mDlg->comboBoxIconTheme->currentIndex() ).value<KNemoTheme>();
     if ( curTheme.internalName == TEXT_THEME ||
          curTheme.internalName == NETLOAD_THEME )
         iconThemeChanged( mDlg->comboBoxIconTheme->currentIndex() );
     if ( !mLock) changed( true );
 }
 
 void ConfigDialog::iconFontChanged( const QFont &font )
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     if ( font != settings->iconFont )
     {
         settings->iconFont = font;
         iconThemeChanged( mDlg->comboBoxIconTheme->currentIndex() );
     }
     if ( !mLock ) changed( true );
 }
 
 void ConfigDialog::advancedButtonClicked()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     ThemeConfig dlg( *settings );
     if ( dlg.exec() )
     {
         InterfaceSettings s = dlg.settings();
         settings->trafficThreshold = s.trafficThreshold;
         settings->dynamicColor = s.dynamicColor;
         settings->colorIncomingMax = s.colorIncomingMax;
         settings->colorOutgoingMax = s.colorOutgoingMax;
 
         settings->barScale = s.barScale;
         settings->inMaxRate = s.inMaxRate;
         settings->outMaxRate = s.outMaxRate;
 
         changed( true );
     }
 }
 
 void ConfigDialog::addStatsClicked()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     StatsRule rule;
     int oldRuleCount = statsModel->rowCount();
     StatsConfig dlg( settings, mCalendar, rule, true );
     if ( dlg.exec() )
     {
         rule = dlg.settings();
         QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
         QModelIndex index = statsModel->addRule( rule );
         mDlg->statsView->setCurrentIndex( proxy->mapFromSource( index ) );
         settings->statsRules = statsModel->getRules();
         mDlg->modifyStats->setEnabled( true );
         mDlg->removeStats->setEnabled( true );
         updateWarnText( oldRuleCount );
         changed( true );
     }
 }
 
 void ConfigDialog::modifyStatsClicked()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings || mDlg->statsView->model()->rowCount() < 1 )
         return;
 
     QModelIndex index = mDlg->statsView->selectionModel()->currentIndex();
     if ( !index.isValid() )
         return;
     QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
     index = proxy->mapToSource( index );
     StatsRule s = statsModel->item( index.row(), 0 )->data( Qt::UserRole ).value<StatsRule>();
     StatsConfig dlg( settings, mCalendar, s, false );
     if ( dlg.exec() )
     {
         s = dlg.settings();
         statsModel->modifyRule( index, s );
         settings->statsRules = statsModel->getRules();
         changed( true );
     }
 }
 
 void ConfigDialog::removeStatsClicked()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings || mDlg->statsView->model()->rowCount() < 1 )
         return;
 
     QModelIndex index = mDlg->statsView->selectionModel()->currentIndex();
     if ( !index.isValid() )
         return;
     QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
     index = proxy->mapToSource( index );
     statsModel->removeRow( index.row() );
     settings->statsRules = statsModel->getRules();
     mDlg->modifyStats->setEnabled( statsModel->rowCount() );
     mDlg->removeStats->setEnabled( statsModel->rowCount() );
     updateWarnText( statsModel->rowCount() );
     changed( true );
 }
 
 void ConfigDialog::addWarnClicked()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     WarnRule warn;
     WarnConfig dlg( settings, warn, true );
     if ( dlg.exec() )
     {
         warn = dlg.settings();
         QModelIndex index = warnModel->addWarn( warn );
         mDlg->warnView->setCurrentIndex( index );
         settings->warnRules = warnModel->getRules();
         changed( true );
         mDlg->modifyWarn->setEnabled( true );
         mDlg->removeWarn->setEnabled( true );
     }
 }
 
 void ConfigDialog::modifyWarnClicked()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings || mDlg->warnView->model()->rowCount() < 1 )
         return;
 
     const QModelIndex index = mDlg->warnView->selectionModel()->currentIndex();
     if ( !index.isValid() )
         return;
     WarnRule warn = mDlg->warnView->model()->data( index.sibling( index.row(), 0 ), Qt::UserRole ).value<WarnRule>();
     WarnConfig dlg( settings, warn, false );
     if ( dlg.exec() )
     {
         warn = dlg.settings();
         warnModel->modifyWarn( index, warn );
         settings->warnRules = warnModel->getRules();
         changed( true );
     }
 }
 
 void ConfigDialog::removeWarnClicked()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings || mDlg->warnView->model()->rowCount() < 1 )
         return;
 
     const QModelIndex index = mDlg->warnView->selectionModel()->currentIndex();
     if ( !index.isValid() )
         return;
     warnModel->removeRow( index.row() );
     settings->warnRules = warnModel->getRules();
     mDlg->modifyWarn->setEnabled( warnModel->rowCount() );
     mDlg->removeWarn->setEnabled( warnModel->rowCount() );
     changed( true );
 }
 
 
 
 /******************************************
  *                                        *
  * Interface tab - Statistics             *
  *                                        *
  ******************************************/
 
 void ConfigDialog::checkBoxStatisticsToggled( bool on )
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     settings->activateStatistics = on;
     if (!mLock) changed( true );
 }
 
 
 
 /******************************************
  *                                        *
  * Interface tab - Context Menu           *
  *                                        *
  ******************************************/
 
 void ConfigDialog::buttonAddCommandSelected()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     InterfaceCommand cmd;
     cmd.runAsRoot = false;
     cmd.menuText = QString();
     cmd.command = QString();
     settings->commands.append( cmd );
 
     QTreeWidgetItem* item = new QTreeWidgetItem();
     item->setCheckState( 0, Qt::Unchecked );
     item->setFlags( item->flags() | Qt::ItemIsEditable );
     mDlg->listViewCommands->addTopLevelItem( item );
     mDlg->listViewCommands->setCurrentItem( item );
 
     if (!mLock) changed( true );
 }
 
 void ConfigDialog::buttonRemoveCommandSelected()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     if ( !mDlg->listViewCommands->currentItem() )
         return;
 
     QTreeWidgetItem *item = mDlg->listViewCommands->currentItem();
     int index = mDlg->listViewCommands->indexOfTopLevelItem( item );
     mDlg->listViewCommands->takeTopLevelItem( index );
     delete item;
 
     QList<InterfaceCommand> cmds;
     QTreeWidgetItemIterator i( mDlg->listViewCommands );
     while ( QTreeWidgetItem * item = *i )
     {
         InterfaceCommand cmd;
         cmd.runAsRoot = item->checkState( 0 );
         cmd.menuText = item->text( 1 );
         cmd.command = item->text( 2 );
         cmds.append( cmd );
         ++i;
     }
 
     settings->commands = cmds;
     if (!mLock) changed( true );
 }
 
 void ConfigDialog::setUpDownButtons( QTreeWidgetItem* item )
 {
     if ( !item )
     {
         mDlg->pushButtonUp->setEnabled( false );
         mDlg->pushButtonDown->setEnabled( false );
         return;
     }
 
     if (mDlg->listViewCommands->indexOfTopLevelItem( item ) == 0 )
         mDlg->pushButtonUp->setEnabled( false );
     else
         mDlg->pushButtonUp->setEnabled( true );
 
     if (mDlg->listViewCommands->indexOfTopLevelItem( item ) == mDlg->listViewCommands->topLevelItemCount() - 1 )
         mDlg->pushButtonDown->setEnabled( false );
     else
         mDlg->pushButtonDown->setEnabled( true );
 }
 
 void ConfigDialog::buttonCommandUpSelected()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     if ( !mDlg->listViewCommands->currentItem() )
         return;
 
     QTreeWidgetItem* item = mDlg->listViewCommands->currentItem();
     int index = mDlg->listViewCommands->indexOfTopLevelItem( item );
     if ( index == 0 )
         return;
 
     mDlg->listViewCommands->takeTopLevelItem( index );
     mDlg->listViewCommands->insertTopLevelItem( index - 1, item );
     mDlg->listViewCommands->setCurrentItem( item );
     setUpDownButtons( item );
 
     QList<InterfaceCommand> cmds;
     QTreeWidgetItemIterator i( mDlg->listViewCommands );
     while ( QTreeWidgetItem * item = *i )
     {
         InterfaceCommand cmd;
         cmd.runAsRoot = item->checkState( 0 );
         cmd.menuText = item->text( 1 );
         cmd.command = item->text( 2 );
         cmds.append( cmd );
         ++i;
     }
 
     settings->commands = cmds;
     if (!mLock) changed( true );
 }
 
 void ConfigDialog::buttonCommandDownSelected()
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     if ( !mDlg->listViewCommands->currentItem() )
         return;
 
     QTreeWidgetItem* item = mDlg->listViewCommands->currentItem();
     int index = mDlg->listViewCommands->indexOfTopLevelItem( item );
     if ( index == mDlg->listViewCommands->topLevelItemCount() - 1 )
         return;
 
     mDlg->listViewCommands->takeTopLevelItem( index );
     mDlg->listViewCommands->insertTopLevelItem( index + 1, item );
     mDlg->listViewCommands->setCurrentItem( item );
     setUpDownButtons( item );
 
     QList<InterfaceCommand> cmds;
     QTreeWidgetItemIterator i( mDlg->listViewCommands );
     while ( QTreeWidgetItem * item = *i )
     {
         InterfaceCommand cmd;
         cmd.runAsRoot = item->checkState( 0 );
         cmd.menuText = item->text( 1 );
         cmd.command = item->text( 2 );
         cmds.append( cmd );
         ++i;
     }
 
     settings->commands = cmds;
     if (!mLock) changed( true );
 }
 
 void ConfigDialog::listViewCommandsSelectionChanged( QTreeWidgetItem* item, QTreeWidgetItem* )
 {
     mDlg->pushButtonRemoveCommand->setEnabled( item != NULL );
     setUpDownButtons( item );
 }
 
 void ConfigDialog::listViewCommandsChanged( QTreeWidgetItem* item, int column )
 {
     InterfaceSettings* settings = getItemSettings();
     if ( !settings )
         return;
 
     int row = mDlg->listViewCommands->indexOfTopLevelItem( item );
     InterfaceCommand& cmd = settings->commands[row];
     switch ( column )
     {
         case 0:
             cmd.runAsRoot = item->checkState( 0 );
             break;
         case 1:
             cmd.menuText = item->text( 1 );
             break;
         case 2:
             cmd.command = item->text( 2 );
     }
 
     if (!mLock) changed( true );
 }
 
 
 
 /******************************************
  *                                        *
  * ToolTip tab                            *
  *                                        *
  ******************************************/
 
 void ConfigDialog::setupToolTipMap()
 {
     // Cannot make this data static as the i18n macro doesn't seem
     // to work when called to early i.e. before setting the catalogue.
     mToolTips.insert( INTERFACE, i18n( "Interface" ) );
     mToolTips.insert( STATUS, i18n( "Status" ) );
     mToolTips.insert( UPTIME, i18n( "Connection Time" ) );
     mToolTips.insert( IP_ADDRESS, i18n( "IP Address" ) );
     mToolTips.insert( SCOPE, i18n( "Scope & Flags" ) );
     mToolTips.insert( HW_ADDRESS, i18n( "MAC Address" ) );
     mToolTips.insert( BCAST_ADDRESS, i18n( "Broadcast Address" ) );
     mToolTips.insert( GATEWAY, i18n( "Default Gateway" ) );
     mToolTips.insert( PTP_ADDRESS, i18n( "PtP Address" ) );
     mToolTips.insert( RX_PACKETS, i18n( "Packets Received" ) );
     mToolTips.insert( TX_PACKETS, i18n( "Packets Sent" ) );
     mToolTips.insert( RX_BYTES, i18n( "Bytes Received" ) );
     mToolTips.insert( TX_BYTES, i18n( "Bytes Sent" ) );
     mToolTips.insert( DOWNLOAD_SPEED, i18n( "Download Speed" ) );
     mToolTips.insert( UPLOAD_SPEED, i18n( "Upload Speed" ) );
     mToolTips.insert( ESSID, i18n( "ESSID" ) );
     mToolTips.insert( MODE, i18n( "Mode" ) );
     mToolTips.insert( FREQUENCY, i18n( "Frequency" ) );
     mToolTips.insert( BIT_RATE, i18n( "Bit Rate" ) );
     mToolTips.insert( ACCESS_POINT, i18n( "Access Point" ) );
     mToolTips.insert( LINK_QUALITY, i18n( "Link Quality" ) );
 #ifndef __linux__
     mToolTips.insert( NICK_NAME, i18n( "Nickname" ) );
 #endif
     mToolTips.insert( ENCRYPTION, i18n( "Encryption" ) );
 }
 
 void ConfigDialog::setupToolTipTab()
 {
     mDlg->listBoxDisplay->clear();
     mDlg->listBoxAvailable->clear();
 
     foreach ( QString tip, mToolTips )
     {
         if ( mToolTipContent & mToolTips.key( tip ) )
             mDlg->listBoxDisplay->addItem( tip );
         else
             mDlg->listBoxAvailable->addItem( tip );
     }
 
     if ( mDlg->listBoxDisplay->count() > 0 )
         mDlg->listBoxDisplay->item( 0 )->setSelected( true );
 
     if ( mDlg->listBoxAvailable->count() > 0 )
         mDlg->listBoxAvailable->item( 0 )->setSelected( true );
 
     mDlg->pushButtonRemoveToolTip->setEnabled( (mDlg->listBoxDisplay->count() > 0) );
     mDlg->pushButtonAddToolTip->setEnabled( (mDlg->listBoxAvailable->count() > 0) );
 }
 
 void ConfigDialog::moveTips( QListWidget *from, QListWidget* to )
 {
     QList<QListWidgetItem *> selectedItems = from->selectedItems();
 
     foreach ( QListWidgetItem *selected, selectedItems )
     {
         quint32 key = mToolTips.key( selected->text() );
 
         int newIndex = -1;
         int count = to->count();
         for ( int i = 0; i < count; i++ )
         {
             QListWidgetItem *item = to->item( i );
             if ( mToolTips.key( item->text() ) > key )
             {
                 newIndex = i;
                 break;
             }
         }
         if ( newIndex < 0 )
             newIndex = count;
 
         selected->setSelected( false );
         from->takeItem( from->row( selected ) );
         to->insertItem( newIndex, selected );
         mDlg->pushButtonAddToolTip->setEnabled( (mDlg->listBoxAvailable->count() > 0) );
         mDlg->pushButtonRemoveToolTip->setEnabled( (mDlg->listBoxDisplay->count() > 0) );
         changed( true );
     }
     mToolTipContent = 0;
     for ( int i = 0; i < mDlg->listBoxDisplay->count(); i++ )
         mToolTipContent += mToolTips.key( mDlg->listBoxDisplay->item( i )->text() );
 }
 
 void ConfigDialog::buttonAddToolTipSelected()
 {
     // Support extended selection
     if ( mDlg->listBoxAvailable->count() == 0 )
         return;
 
     moveTips( mDlg->listBoxAvailable, mDlg->listBoxDisplay );
 }
 
 void ConfigDialog::buttonRemoveToolTipSelected()
 {
     // Support extended selection
     if ( mDlg->listBoxDisplay->count() == 0 )
         return;
 
     moveTips( mDlg->listBoxDisplay, mDlg->listBoxAvailable );
 }
 
 
 
 /******************************************
  *                                        *
  * General tab                            *
  *                                        *
  ******************************************/
 
 void ConfigDialog::buttonNotificationsSelected()
 {
     KNotifyConfigWidget::configure( this, QLatin1String("knemo") );
 }
 
 #include "configdialog.moc"
diff --git a/src/kcm/configdialog.h b/src/kcm/configdialog.h
index 1af4f4b..9fcbd20 100644
--- a/src/kcm/configdialog.h
+++ b/src/kcm/configdialog.h
@@ -1,147 +1,145 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2005, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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.
 */
 
 #ifndef CONFIGDIALOG_H
 #define CONFIGDIALOG_H
 
 #include <KCModule>
 
 #include "data.h"
 #include "ui_configdlg.h"
 #include <QStandardItemModel>
-#include <KSharedConfig>
 
 class QTreeWidgetItem;
 class KCalendarSystem;
 
 /**
  * This is the configuration dialog for KNemo
  * It is implemented as a control center module so that it is still
  * possible to configure KNemo even when there is no icon visible
  * in the system tray.
  *
  * @short Configuration dialog for KNemo
  * @author Percy Leonhardt <percy@eris23.de>
  */
 
 class StatsRuleModel : public QStandardItemModel
 {
     Q_OBJECT
     public:
         StatsRuleModel( QObject *parent = 0 ) :
             QStandardItemModel( parent ) {}
         virtual ~StatsRuleModel() {}
         void setCalendar( const KCalendarSystem *cal );
         QModelIndex addRule( const StatsRule &s );
         void modifyRule( const QModelIndex &index, const StatsRule &s );
         QList<StatsRule> getRules();
     private:
         QString dateText( const StatsRule &s );
         const KCalendarSystem *mCalendar;
 };
 
 class WarnModel : public QStandardItemModel
 {
     Q_OBJECT
     public:
         WarnModel( QObject *parent = 0 ) : QStandardItemModel( parent ) {}
         virtual ~WarnModel() {}
         QModelIndex addWarn( const WarnRule &w );
         void modifyWarn( const QModelIndex &index, const WarnRule &warn );
         QList<WarnRule> getRules();
     private:
         QString ruleText( const WarnRule &warn );
 };
 
 class ConfigDialog : public KCModule
 {
     Q_OBJECT
 public:
     /**
      * Default Constructor
      */
     ConfigDialog( QWidget *parent, const QVariantList &args );
 
     /**
      * Default Destructor
      */
     virtual ~ConfigDialog();
 
     void load();
     void save();
     void defaults();
 
 private Q_SLOTS:
     void buttonNewSelected();
     void buttonAllSelected();
     void buttonDeleteSelected();
     void buttonAddCommandSelected();
     void buttonRemoveCommandSelected();
     void setUpDownButtons( QTreeWidgetItem* item );
     void buttonCommandUpSelected();
     void buttonCommandDownSelected();
     void buttonAddToolTipSelected();
     void buttonRemoveToolTipSelected();
     void buttonNotificationsSelected();
     void interfaceSelected( int row );
     void aliasChanged( const QString& text );
     void iconThemeChanged( int set );
     void comboHidingChanged( int val );
     void checkBoxStatisticsToggled( bool on );
     void checkBoxStartKNemoToggled( bool on );
     void colorButtonChanged();
     void iconFontChanged( const QFont &font );
     void advancedButtonClicked();
     void addStatsClicked();
     void modifyStatsClicked();
     void removeStatsClicked();
     void addWarnClicked();
     void modifyWarnClicked();
     void removeWarnClicked();
     void listViewCommandsSelectionChanged( QTreeWidgetItem *current, QTreeWidgetItem *previous );
     void listViewCommandsChanged( QTreeWidgetItem* item, int column );
     void moveTips( QListWidget *from, QListWidget *to );
 
 private:
     void setupToolTipTab();
     void setupToolTipMap();
     void updateControls( InterfaceSettings *settings );
     InterfaceSettings * getItemSettings();
     int findIndexFromName( const QString& internalName );
     QString findNameFromIndex( int index );
     QPixmap textIcon( QString incomingText, QString outgoingText, int status );
     QPixmap barIcon( int status );
     void updateWarnText( int oldCount );
 
     int mToolTipContent;
     bool mLock;
     Ui::ConfigDlg* mDlg;
     const KCalendarSystem* mCalendar;
     int mMaxDay;
     StatsRuleModel *statsModel;
     WarnModel *warnModel;
 
-    KSharedConfig::Ptr mConfig;
     QMap<QString, InterfaceSettings *> mSettingsMap;
     QMap<quint32, QString> mToolTips;
     QList<QString> mDeletedIfaces;
 };
 
 #endif // CONFIGDIALOG_H
diff --git a/src/knemod/interfaceplotterdialog.cpp b/src/knemod/interfaceplotterdialog.cpp
index 648e530..c6f28c5 100644
--- a/src/knemod/interfaceplotterdialog.cpp
+++ b/src/knemod/interfaceplotterdialog.cpp
@@ -1,523 +1,523 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    Portions adapted from FancyPlotter.cpp in KSysGuard
    Copyright (c) 1999 - 2002 Chris Schlaeger <cs@kde.org>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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 <QMenu>
 #include <QMouseEvent>
 #include <QApplication>
 #include <KConfigGroup>
+#include <KSharedConfig>
 
 #include "global.h"
 #include "interfaceplotterdialog.h"
 #include "utils.h"
 #include <ksysguard/ksignalplotter.h>
 #include "plotterconfigdialog.h"
 #include <math.h>
 
 static const char plot_pixel[] = "Pixel";
 static const char plot_distance[] = "Distance";
 static const char plot_fontSize[] = "FontSize";
 static const char plot_minimumValue[] = "MinimumValue";
 static const char plot_maximumValue[] = "MaximumValue";
 static const char plot_labels[] = "Labels";
 static const char plot_verticalLines[] = "VerticalLines";
 static const char plot_horizontalLines[] = "HorizontalLines";
 static const char plot_showIncoming[] = "ShowIncoming";
 static const char plot_showOutgoing[] = "ShowOutgoing";
 static const char plot_automaticDetection[] = "AutomaticDetection";
 static const char plot_verticalLinesScroll[] = "VerticalLinesScroll";
 static const char plot_colorIncoming[] = "ColorIncoming";
 static const char plot_colorOutgoing[] = "ColorOutgoing";
 
 class FancyPlotterLabel : public QLabel {
   public:
     FancyPlotterLabel(QWidget *parent) : QLabel(parent) {
         setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
         longHeadingWidth = 0;
         shortHeadingWidth = 0;
         textMargin = 0;
         setLayoutDirection(Qt::LeftToRight); //We do this because we organise the strings ourselves.. is this going to muck it up though for RTL languages?
     }
     ~FancyPlotterLabel() {
     }
     void setLabel(const QString &name, const QColor &color) {
         labelName = name;
 
         if(indicatorSymbol.isNull()) {
             if(fontMetrics().inFont(QChar(0x25CF)))
                 indicatorSymbol = QChar(0x25CF);
             else
                 indicatorSymbol = QLatin1Char('#');
         }
         changeLabel(color);
 
     }
     void setValueText(const QString &value) {
         //value can have multiple strings, separated with the 0x9c character
         valueText = value.split(QChar(0x9c));
         resizeEvent(NULL);
         update();
     }
     virtual void resizeEvent( QResizeEvent * ) {
         QFontMetrics fm = fontMetrics();
 
         if(valueText.isEmpty()) {
             if(longHeadingWidth < width())
                 setText(longHeadingText);
             else
                 setText(shortHeadingText);
             return;
         }
         QString value = valueText.first();
 
         int textWidth = fm.boundingRect(value).width();
         if(textWidth + longHeadingWidth < width())
             setBothText(longHeadingText, value);
         else if(textWidth + shortHeadingWidth < width())
             setBothText(shortHeadingText, value);
         else {
             int valueTextCount = valueText.count();
             int i;
             for(i = 1; i < valueTextCount; ++i) {
                 textWidth = fm.boundingRect(valueText.at(i)).width();
                 if(textWidth + shortHeadingWidth <= width()) {
                     break;
                 }
             }
             if(i < valueTextCount)
                 setBothText(shortHeadingText, valueText.at(i));
             else
                 setText(noHeadingText + valueText.last()); //This just sets the color of the text
         }
     }
     void changeLabel(const QColor &_color) {
         color = _color;
 
         if ( qApp->layoutDirection() == Qt::RightToLeft )
             longHeadingText = QLatin1String(": ") + labelName + QLatin1String(" <font color=\"") + color.name() + QLatin1String("\">") + indicatorSymbol + QLatin1String("</font>");
         else
             longHeadingText = QLatin1String("<qt><font color=\"") + color.name() + QLatin1String("\">") + indicatorSymbol + QLatin1String("</font> ") + labelName + QLatin1String(" :");
         shortHeadingText = QLatin1String("<qt><font color=\"") + color.name() + QLatin1String("\">") + indicatorSymbol + QLatin1String("</font>");
         noHeadingText = QLatin1String("<qt><font color=\"") + color.name() + QLatin1String("\">");
 
         textMargin = fontMetrics().width(QLatin1Char('x')) + margin()*2 + frameWidth()*2;
         longHeadingWidth = fontMetrics().boundingRect(labelName + QLatin1String(" :") + indicatorSymbol + QLatin1String(" x")).width() + textMargin;
         shortHeadingWidth = fontMetrics().boundingRect(indicatorSymbol).width() + textMargin;
         setMinimumWidth(shortHeadingWidth);
         update();
     }
   private:
     void setBothText(const QString &heading, const QString & value) {
         if(QApplication::layoutDirection() == Qt::LeftToRight)
             setText(heading + QLatin1Char(' ') + value);
         else
             setText(QLatin1String("<qt>") + value + QLatin1Char(' ') + heading);
     }
     int textMargin;
     QString longHeadingText;
     QString shortHeadingText;
     QString noHeadingText;
     int longHeadingWidth;
     int shortHeadingWidth;
     QList<QString> valueText;
     QString labelName;
     QColor color;
     static QChar indicatorSymbol;
 };
 
 QChar FancyPlotterLabel::indicatorSymbol;
 
 
 InterfacePlotterDialog::InterfacePlotterDialog( QString name )
     : QDialog(),
-      mConfig( KSharedConfig::openConfig() ),
       mConfigDlg( 0 ),
       mLabelsWidget( NULL ),
       mSetPos( true ),
       mWasShown( false ),
       mUseBitrate( generalSettings->useBitrate ),
       mMultiplier( 1024 ),
       mOutgoingVisible( false ),
       mIncomingVisible( false ),
       mName( name )
 {
     setWindowTitle( i18nc( "interface name", "%1 Traffic", mName ) );
     setContextMenuPolicy( Qt::DefaultContextMenu );
 
     mByteUnits << ki18n( "%1 B/s" ) << ki18n( "%1 KiB/s" ) << ki18n( "%1 MiB/s" ) << ki18n( "%1 GiB/s" );
     mBitUnits << ki18n( "%1 bit/s" ) << ki18n( "%1 kbit/s" ) << ki18n( "%1 Mbit/s" ) << ki18n( "%1 Gbit/s" );
 
     mIndicatorSymbol = QLatin1Char('#');
     QFontMetrics fm(font());
     if (fm.inFont(QChar(0x25CF)))
         mIndicatorSymbol = QChar(0x25CF);
     
     QBoxLayout *layout = new QVBoxLayout(this);
     layout->setContentsMargins(0,0,0,0);
     layout->setSpacing(0);
     setLayout( layout );
     mPlotter = new KSignalPlotter( this );
     int axisTextWidth = fontMetrics().width(i18nc("Largest axis title", "99999 XXXX"));
     mPlotter->setMaxAxisTextWidth( axisTextWidth );
     mPlotter->setShowAxis( true );
     mPlotter->setUseAutoRange( true );
     layout->addWidget(mPlotter);
 
     /* Create a set of labels underneath the graph. */
     mLabelsWidget = new QWidget;
     layout->addWidget(mLabelsWidget);
     QBoxLayout *outerLabelLayout = new QHBoxLayout(mLabelsWidget);
     outerLabelLayout->setSpacing(0);
     outerLabelLayout->setContentsMargins(0,0,0,0);
 
     /* create a spacer to fill up the space up to the start of the graph */
     outerLabelLayout->addItem(new QSpacerItem(axisTextWidth + 10, 0, QSizePolicy::Preferred));
 
     mLabelLayout = new QHBoxLayout;
     outerLabelLayout->addLayout(mLabelLayout);
     mReceivedLabel = new FancyPlotterLabel( this );
     mSentLabel = new FancyPlotterLabel( this );
 
     mLabelLayout->addWidget( mSentLabel );
     mLabelLayout->addWidget( mReceivedLabel );
 
     // Restore window size and position.
-    KConfig *config = mConfig.data();
+    KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup interfaceGroup( config, confg_interface + mName );
     if ( interfaceGroup.hasKey( conf_plotterPos ) )
     {
         QPoint p = interfaceGroup.readEntry( conf_plotterPos, QPoint() );
         // See comment in event()
         mSetPos = false;
         move( p );
     }
     if ( interfaceGroup.hasKey( conf_plotterSize ) )
     {
         QSize s = interfaceGroup.readEntry( conf_plotterSize, QSize() );
         // A little hack so the plotter's data isn't chopped off the first time
         // the dialog appears
         mPlotter->resize( s );
         resize( s );
     }
     else
     {
         // HACK
         mPlotter->resize( 500, 350 );
         // Improve the chance that we have a decent sized dialog
         // the first time it's shown
         resize( 500, 350 );
     }
     connect( mPlotter, SIGNAL(axisScaleChanged()), this, SLOT(setPlotterUnits()) );
     loadConfig();
 }
 
 InterfacePlotterDialog::~InterfacePlotterDialog()
 {
     if ( mWasShown )
     {
         // If the dialog was never shown, then the position
         // will be wrong
-        KConfig *config = mConfig.data();
+        KSharedConfig::Ptr config = KSharedConfig::openConfig();
         KConfigGroup interfaceGroup( config, confg_interface + mName );
         interfaceGroup.writeEntry( conf_plotterSize, size() );
         interfaceGroup.writeEntry( conf_plotterPos, pos() );
         config->sync();
     }
 }
 
 bool InterfacePlotterDialog::event( QEvent *e )
 {
     /* If we do not explicitly call size() and move() at least once then
      * hiding and showing the dialog will cause it to forget its previous
      * size and position. */
     switch ( e->type() )
     {
         case QEvent::Move:
             if ( mSetPos && !pos().isNull() )
             {
                 mSetPos = false;
                 move( pos() );
             }
             break;
         case QEvent::Show:
             mWasShown = true;
             break;
         case QEvent::MouseButtonPress:
             {
                 QMouseEvent *m = static_cast<QMouseEvent *>(e);
                 if ( m->button() == Qt::RightButton )
                 {
                     showContextMenu( m->pos() );
                     return true;
                 }
             }
         default:
             ;;
     }
 
     return QDialog::event( e );
 }
 
 void InterfacePlotterDialog::resizeEvent( QResizeEvent* )
 {
     bool showLabels = true;;
 
     if( this->height() <= mLabelsWidget->sizeHint().height() + mPlotter->minimumHeight() )
         showLabels = false;
     mLabelsWidget->setVisible(showLabels);
 }
 
 void InterfacePlotterDialog::showContextMenu( const QPoint &pos )
 {
     QMenu pm;
     QAction *action = 0;
 
     action = pm.addAction( i18n( "&Properties" ) );
     action->setData( 1 );
     action = pm.exec( mapToGlobal(pos) );
 
     if ( action )
     {
         switch ( action->data().toInt() )
         {
             case 1:
                 configPlotter();
                 break;
         }
     }
 }
 
 void InterfacePlotterDialog::configPlotter()
 {
     if ( mConfigDlg )
         return;
 
     mConfigDlg = new PlotterConfigDialog( this, mName, &mSettings );
     connect( mConfigDlg, SIGNAL( finished(int) ), this, SLOT( configFinished() ) );
     connect( mConfigDlg, SIGNAL( saved() ), this, SLOT( saveConfig() ) );
     mConfigDlg->show();
 }
 
 void InterfacePlotterDialog::configFinished()
 {
     // FIXME
     mConfigDlg->close();
     mConfigDlg = 0;
 }
 
 void InterfacePlotterDialog::setPlotterUnits()
 {
     // Prevent this being called recursively
     disconnect( mPlotter, SIGNAL(axisScaleChanged()), this, SLOT(setPlotterUnits()) );
     qreal value = mPlotter->currentMaximumRangeValue();
     int units = 0;
 
     if (value >= pow( mMultiplier, 3)*0.7) //If it's over 0.7GiB, then set the scale to gigabytes
     {
         units = 3;
     }
     else if (value > pow(mMultiplier,2))
     {
         units = 2;
     }
     else if (value > mMultiplier)
     {
         units = 1;
     }
     mPlotter->setScaleDownBy( pow(mMultiplier, units ) );
     if ( mUseBitrate )
         mPlotter->setUnit( mBitUnits[units] );
     else
         mPlotter->setUnit( mByteUnits[units] );
     // reconnect
     connect( mPlotter, SIGNAL(axisScaleChanged()), this, SLOT(setPlotterUnits()) );
 }
 
 void InterfacePlotterDialog::useBitrate( bool useBits )
 {
     // Have to wipe the plotters if we change units
     if ( mUseBitrate != useBits )
     {
         int nb = mPlotter->numBeams();
         for ( int i = 0; i < nb; i++ )
         {
             mPlotter->removeBeam(0);
         }
         mOutgoingVisible = false;
         mIncomingVisible = false;
     }
 
     mUseBitrate = useBits;
     if ( mUseBitrate )
         mMultiplier = 1000;
     else
         mMultiplier = 1024;
     addBeams();
     for ( int beamId = 0; beamId < mPlotter->numBeams(); beamId++ )
     {
         QString lastValue = formattedRate( mPlotter->lastValue(beamId), mUseBitrate );
         static_cast<FancyPlotterLabel *>((static_cast<QWidgetItem *>(mLabelLayout->itemAt(beamId)))->widget())->setText(lastValue);
     }
     setPlotterUnits();
 }
 
 void InterfacePlotterDialog::updatePlotter( const double incomingBytes, const double outgoingBytes )
 {
     QList<qreal> trafficList;
     if ( mOutgoingVisible )
        trafficList.append( outgoingBytes );
     if ( mIncomingVisible )
         trafficList.append( incomingBytes );
     mPlotter->addSample( trafficList );
 
     for ( int beamId = 0; beamId < mPlotter->numBeams(); beamId++ )
     {
         QString lastValue = formattedRate( mPlotter->lastValue(beamId), mUseBitrate );
         static_cast<FancyPlotterLabel *>((static_cast<QWidgetItem *>(mLabelLayout->itemAt(beamId)))->widget())->setValueText(lastValue);
     }
 }
 
 void InterfacePlotterDialog::loadConfig()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     // Set the plotter widgets
     QString group = confg_plotter + mName;
     // Plotter
     PlotterSettings s;
     KConfigGroup plotterGroup( config, group );
     mSettings.pixel = clamp<int>(plotterGroup.readEntry( plot_pixel, s.pixel ), 1, 50 );
     mSettings.distance = clamp<int>(plotterGroup.readEntry( plot_distance, s.distance ), 10, 120 );
     mSettings.fontSize = clamp<int>(plotterGroup.readEntry( plot_fontSize, s.fontSize ), 5, 24 );
     mSettings.minimumValue = clamp<double>(plotterGroup.readEntry( plot_minimumValue, s.minimumValue ), 0.0, pow(1024.0, 3) - 1 );
     mSettings.maximumValue = clamp<double>(plotterGroup.readEntry( plot_maximumValue, s.maximumValue ), 0.0, pow(1024.0, 3) );
     mSettings.labels = plotterGroup.readEntry( plot_labels, s.labels );
     mSettings.showIncoming = plotterGroup.readEntry( plot_showIncoming, s.showIncoming );
     mSettings.showOutgoing = plotterGroup.readEntry( plot_showOutgoing, s.showOutgoing );
     mSettings.verticalLines = plotterGroup.readEntry( plot_verticalLines, s.verticalLines );
     mSettings.horizontalLines = plotterGroup.readEntry( plot_horizontalLines, s.horizontalLines );
     mSettings.automaticDetection = plotterGroup.readEntry( plot_automaticDetection, s.automaticDetection );
     mSettings.verticalLinesScroll = plotterGroup.readEntry( plot_verticalLinesScroll, s.verticalLinesScroll );
     mSettings.colorIncoming = plotterGroup.readEntry( plot_colorIncoming, s.colorIncoming );
     mSettings.colorOutgoing = plotterGroup.readEntry( plot_colorOutgoing, s.colorOutgoing );
     configChanged();
 }
 
 void InterfacePlotterDialog::saveConfig()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     // Set the plotter widgets
     QString group = confg_plotter + mName;
     // Plotter
     KConfigGroup plotterGroup( config, group );
     plotterGroup.writeEntry( plot_pixel, mSettings.pixel );
     plotterGroup.writeEntry( plot_distance, mSettings.distance );
     plotterGroup.writeEntry( plot_fontSize, mSettings.fontSize );
     plotterGroup.writeEntry( plot_minimumValue, mSettings.minimumValue );
     plotterGroup.writeEntry( plot_maximumValue, mSettings.maximumValue );
     plotterGroup.writeEntry( plot_labels, mSettings.labels );
     plotterGroup.writeEntry( plot_verticalLines, mSettings.verticalLines );
     plotterGroup.writeEntry( plot_horizontalLines, mSettings.horizontalLines );
     plotterGroup.writeEntry( plot_showIncoming, mSettings.showIncoming );
     plotterGroup.writeEntry( plot_showOutgoing, mSettings.showOutgoing );
     plotterGroup.writeEntry( plot_automaticDetection, mSettings.automaticDetection );
     plotterGroup.writeEntry( plot_verticalLinesScroll, mSettings.verticalLinesScroll );
     plotterGroup.writeEntry( plot_colorIncoming, mSettings.colorIncoming );
     plotterGroup.writeEntry( plot_colorOutgoing, mSettings.colorOutgoing );
     config->sync();
     configChanged();
 }
 
 void InterfacePlotterDialog::configChanged()
 {
     QFont pfont = mPlotter->font();
     pfont.setPointSize( mSettings.fontSize );
     QFontMetrics fm( pfont );
     int axisTextWidth = fm.width(i18nc("Largest axis title", "99999 XXXX"));
     mPlotter->setMaxAxisTextWidth( axisTextWidth );
     mPlotter->setFont( pfont );
     if ( !mSettings.automaticDetection )
     {
         mPlotter->setMinimumValue( mSettings.minimumValue * mMultiplier );
         mPlotter->setMaximumValue( mSettings.maximumValue * mMultiplier );
     }
     else
     {
         // Don't want the disabled settings to be used as hints
         mPlotter->setMinimumValue( 0 );
         mPlotter->setMaximumValue( 1 );
     }
     mPlotter->setHorizontalScale( mSettings.pixel );
     mPlotter->setVerticalLinesDistance( mSettings.distance );
     mPlotter->setShowAxis( mSettings.labels );
     mPlotter->setShowVerticalLines( mSettings.verticalLines );
     mPlotter->setShowHorizontalLines( mSettings.horizontalLines );
     mPlotter->setUseAutoRange( mSettings.automaticDetection );
     mPlotter->setVerticalLinesScroll( mSettings.verticalLinesScroll );
 
     mSentLabel->setLabel( i18nc( "network traffic", "Sending" ), mSettings.colorOutgoing);
     mReceivedLabel->setLabel( i18nc( "network traffic", "Receiving" ), mSettings.colorIncoming);
 
     addBeams();
 }
 
 void InterfacePlotterDialog::addBeams()
 {
     if ( mSettings.showOutgoing )
     {
         if ( !mOutgoingVisible )
         {
             mPlotter->addBeam( mSettings.colorOutgoing );
             mSentLabel->show();
             mOutgoingVisible = true;
             if ( mIncomingVisible )
             {
                 QList<int> newOrder;
                 newOrder << 1 << 0;
                 mPlotter->reorderBeams( newOrder );
             }
         }
     }
     else if ( mOutgoingVisible == true )
     {
         mPlotter->removeBeam( 0 );
         mSentLabel->hide();
         mOutgoingVisible = false;
     }
 
     if ( mSettings.showIncoming )
     {
         if ( !mIncomingVisible )
         {
             mPlotter->addBeam( mSettings.colorIncoming );
             mReceivedLabel->show();
             mIncomingVisible = true;
         }
     }
     else if ( mIncomingVisible == true )
     {
         mPlotter->removeBeam( mPlotter->numBeams() - 1 );
         mReceivedLabel->hide();
         mIncomingVisible = false;
     }
 }
 
 #include "moc_interfaceplotterdialog.cpp"
diff --git a/src/knemod/interfaceplotterdialog.h b/src/knemod/interfaceplotterdialog.h
index 88f3278..235c158 100644
--- a/src/knemod/interfaceplotterdialog.h
+++ b/src/knemod/interfaceplotterdialog.h
@@ -1,82 +1,80 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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.
 */
 
 #ifndef INTERFACEPLOTTERDIALOG_H
 #define INTERFACEPLOTTERDIALOG_H
 
 #include <QDialog>
-#include <KSharedConfig>
 
 #include "plotterconfigdialog.h"
 
 class FancyPlotterLabel;
 class KSignalPlotter;
 class QBoxLayout;
 
 class InterfacePlotterDialog : public QDialog
 {
 Q_OBJECT
 public:
     InterfacePlotterDialog( QString );
     virtual ~InterfacePlotterDialog();
 
     /**
      * Update the signal plotter with new data
      */
     void updatePlotter( const double, const double );
     void useBitrate( bool );
 
 protected:
     bool event( QEvent *e );
     void resizeEvent( QResizeEvent* );
 
 private Q_SLOTS:
     void configFinished();
     void saveConfig();
     void setPlotterUnits();
 
 private:
     void showContextMenu( const QPoint& );
     void loadConfig();
     void configChanged();
     void configPlotter();
     void addBeams();
 
-    KSharedConfig::Ptr mConfig;
     PlotterConfigDialog *mConfigDlg;
     QWidget *mLabelsWidget;
     bool mSetPos;
     bool mWasShown;
     bool mUseBitrate;
     int mMultiplier;
     bool mOutgoingVisible;
     bool mIncomingVisible;
     PlotterSettings mSettings;
     QString mName;
     KSignalPlotter *mPlotter;
     FancyPlotterLabel *mReceivedLabel;
     FancyPlotterLabel *mSentLabel;
     QBoxLayout *mLabelLayout;
     QChar mIndicatorSymbol;
     QList<KLocalizedString> mByteUnits;
     QList<KLocalizedString> mBitUnits;
 };
 
 #endif
diff --git a/src/knemod/interfacestatisticsdialog.cpp b/src/knemod/interfacestatisticsdialog.cpp
index 4b06784..4d4706a 100644
--- a/src/knemod/interfacestatisticsdialog.cpp
+++ b/src/knemod/interfacestatisticsdialog.cpp
@@ -1,217 +1,216 @@
 /* This file is part of KNemo
    Copyright (C) 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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 <QStandardItemModel>
 
 #include <kio/global.h>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <QPushButton>
 #include <QSortFilterProxyModel>
 
 #include "data.h"
 #include "interface.h"
 #include "interfacestatistics.h"
 #include "interfacestatisticsdialog.h"
 #include "statisticsmodel.h"
 
 
 InterfaceStatisticsDialog::InterfaceStatisticsDialog( Interface* interface, QWidget* parent )
     : QDialog( parent ),
       mWasShown( false ),
       mSetPos( true ),
-      mConfig( KSharedConfig::openConfig() ),
       mInterface( interface )
 {
     setWindowTitle( i18n( "%1 Statistics", interface->ifaceName() ) );
 
     ui.setupUi( this );
 
     mBillingWidget = new QWidget();
     QVBoxLayout *bl = new QVBoxLayout( mBillingWidget );
     mBillingView = new StatisticsView( mBillingWidget );
     mBillingView->setEditTriggers( QAbstractItemView::NoEditTriggers );
     mBillingView->setSortingEnabled( true );
     mBillingView->horizontalHeader()->setStretchLastSection( true );
     mBillingView->verticalHeader()->setVisible( false );
     bl->addWidget( mBillingView );
 
     mStateKeys.insert( ui.tableHourly, conf_hourState );
     mStateKeys.insert( ui.tableDaily, conf_dayState );
     mStateKeys.insert( ui.tableWeekly, conf_weekState );
     mStateKeys.insert( ui.tableMonthly, conf_monthState );
     mStateKeys.insert( ui.tableYearly, conf_yearState );
     mStateKeys.insert( mBillingView, conf_billingState );
 
     configChanged();
 
-    KConfig *config = mConfig.data();
+    KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup interfaceGroup( config, confg_interface + mInterface->ifaceName() );
 
     InterfaceStatistics *stat = mInterface->ifaceStatistics();
     setupTable( &interfaceGroup, ui.tableHourly,  stat->getStatistics( KNemoStats::Hour ) );
     setupTable( &interfaceGroup, ui.tableDaily,   stat->getStatistics( KNemoStats::Day ) );
     setupTable( &interfaceGroup, ui.tableWeekly,  stat->getStatistics( KNemoStats::Week ) );
     setupTable( &interfaceGroup, ui.tableMonthly, stat->getStatistics( KNemoStats::Month ) );
     setupTable( &interfaceGroup, ui.tableYearly,  stat->getStatistics( KNemoStats::Year ) );
     setupTable( &interfaceGroup, mBillingView,    stat->getStatistics( KNemoStats::BillPeriod ) );
 
     connect( ui.buttonBox, SIGNAL( rejected() ), SLOT( reject() ) );
     connect( ui.buttonBox, SIGNAL( clicked( QAbstractButton* ) ), SLOT( confirmReset( QAbstractButton* ) ) );
 
     if ( interfaceGroup.hasKey( conf_statisticsPos ) )
     {
         QPoint p = interfaceGroup.readEntry( conf_statisticsPos, QPoint() );
         // See comment in event()
         mSetPos = false;
         move( p );
     }
     if ( interfaceGroup.hasKey( conf_statisticsSize ) )
     {
         QSize s = interfaceGroup.readEntry( conf_statisticsSize, QSize() );
         resize( s );
     }
     else
     {
         // Improve the chance that we have a decent sized dialog
         // the first time it's shown
         resize( 600, 450 );
     }
 }
 
 InterfaceStatisticsDialog::~InterfaceStatisticsDialog()
 {
     if ( mWasShown )
     {
-        KConfig *config = mConfig.data();
+        KSharedConfig::Ptr config = KSharedConfig::openConfig();
         KConfigGroup interfaceGroup( config, confg_interface + mInterface->ifaceName() );
 
         interfaceGroup.writeEntry( conf_statisticsPos, pos() );
         interfaceGroup.writeEntry( conf_statisticsSize, size() );
 
         QHashIterator<QTableView*, QString> i( mStateKeys );
         while ( i.hasNext() )
         {
             i.next();
             interfaceGroup.writeEntry( i.value(), i.key()->horizontalHeader()->saveState() );
         }
 
         config->sync();
     }
 }
 
 void InterfaceStatisticsDialog::configChanged()
 {
     bool billingTab = false;
     bool logOffpeak = false;
     KCalendarSystem *cal = mInterface->ifaceStatistics()->calendar();
     foreach ( StatsRule rule, mInterface->settings().statsRules )
     {
         if ( rule.periodCount != 1 ||
              rule.periodUnits != KNemoStats::Month ||
              cal->day( rule.startDate ) != 1 )
         {
             billingTab = true;
         }
         if ( rule.logOffpeak )
             logOffpeak = true;
     }
 
     ui.tableHourly->haveOffpeak( logOffpeak );
     ui.tableDaily->haveOffpeak( logOffpeak );
     ui.tableWeekly->haveOffpeak( logOffpeak );
     ui.tableMonthly->haveOffpeak( logOffpeak );
     ui.tableYearly->haveOffpeak( logOffpeak );
     mBillingView->haveOffpeak( logOffpeak );
 
     if ( billingTab && ui.tabWidget->count() < 6 )
     {
         ui.tabWidget->insertTab( 4, mBillingWidget, i18n( "Billing Periods" ) );
     }
     else if ( !billingTab && ui.tabWidget->count() > 5 )
        ui.tabWidget->removeTab( 4 );
 }
 
 void InterfaceStatisticsDialog::setupTable( KConfigGroup* group, QTableView *view, StatisticsModel *model )
 {
     QSortFilterProxyModel *proxy = new QSortFilterProxyModel( view );
     proxy->setSourceModel( model );
     proxy->setSortRole( StatisticsModel::DataRole );
     view->setModel( proxy );
     view->sortByColumn( 0, Qt::AscendingOrder );
 
     QModelIndex sourceIndex = proxy->sourceModel()->index( proxy->rowCount() - 1, 0 );
     view->selectionModel()->setCurrentIndex( proxy->mapFromSource( sourceIndex ), QItemSelectionModel::NoUpdate );
 
     connect( model, SIGNAL( itemChanged( QStandardItem * ) ), view->viewport(), SLOT( update() ) );
     connect( proxy, SIGNAL( rowsInserted( const QModelIndex&, int, int ) ), this, SLOT( setCurrentSel() ) );
 
     QByteArray state = group->readEntry( mStateKeys.value( view ), QByteArray() );
     if ( state.isNull() )
         view->resizeColumnsToContents();
     else
         view->horizontalHeader()->restoreState( state );
     proxy->setDynamicSortFilter( true );
 }
 
 bool InterfaceStatisticsDialog::event( QEvent *e )
 {
     /* If we do not explicitly call size() and move() at least once then
      * hiding and showing the dialog will cause it to forget its previous
      * size and position. */
     if ( e->type() == QEvent::Move )
     {
         if ( mSetPos && !pos().isNull() )
         {
             mSetPos = false;
             move( pos() );
         }
     }
     if ( e->type() == QEvent::Show && !mWasShown )
     {
         mWasShown = true;
         // Set this here!  For some reason the QTableView in the first tab
         // will become ridiculously wide if we set this earlier.
         ui.tableHourly->horizontalHeader()->setStretchLastSection( true );
     }
 
     return QDialog::event( e );
 }
 
 void InterfaceStatisticsDialog::confirmReset( QAbstractButton* button)
 {
     if (static_cast<QPushButton*>(button) == ui.buttonBox->button(QDialogButtonBox::Reset) ) {
         if ( KMessageBox::questionYesNo( this, i18n( "Do you want to reset all statistics?" ) ) == KMessageBox::Yes )
             emit clearStatistics();
     }
 }
 
 void InterfaceStatisticsDialog::setCurrentSel()
 {
     QSortFilterProxyModel *proxy = static_cast<QSortFilterProxyModel*>( sender() );
     QTableView *tv = static_cast<QTableView*>( sender()->parent() );
     QModelIndex sourceIndex = proxy->sourceModel()->index( proxy->rowCount() - 1, 0 );
 
     tv->selectionModel()->setCurrentIndex( proxy->mapFromSource( sourceIndex ), QItemSelectionModel::NoUpdate );
 }
 
 
 #include "moc_interfacestatisticsdialog.cpp"
diff --git a/src/knemod/interfacestatisticsdialog.h b/src/knemod/interfacestatisticsdialog.h
index 02e03be..18c529c 100644
--- a/src/knemod/interfacestatisticsdialog.h
+++ b/src/knemod/interfacestatisticsdialog.h
@@ -1,81 +1,80 @@
 /* This file is part of KNemo
    Copyright (C) 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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.
 */
 
 #ifndef INTERFACESTATISTICSDIALOG_H
 #define INTERFACESTATISTICSDIALOG_H
 
 #include <QDialog>
 #include "ui_interfacestatisticsdlg.h"
 
 class StatisticsModel;
 class Interface;
 
 
 /**
  * This class shows the statistics dialog. It contains the tables for the
  * different statistics.
  *
  * @short Statistics dialog
  * @author Percy Leonhardt <percy@eris23.de>
  */
 
 class InterfaceStatisticsDialog : public QDialog
 {
     Q_OBJECT
 public:
     /**
      * Default Constructor
      */
     InterfaceStatisticsDialog( Interface* interface,
                                QWidget* parent = 0L );
 
     /**
      * Default Destructor
      */
     virtual ~InterfaceStatisticsDialog();
 
     void configChanged();
 
 Q_SIGNALS:
     void clearStatistics();
 
 public Q_SLOTS:
     void confirmReset(QAbstractButton* button);
 
 protected:
     bool event( QEvent *e );
 
 private:
     void setupTable( KConfigGroup* group, QTableView * view, StatisticsModel* model );
 
     Ui::InterfaceStatisticsDlg ui;
     bool mWasShown;
     bool mSetPos;
     QWidget *mBillingWidget;
     StatisticsView *mBillingView;
-    KSharedConfig::Ptr mConfig;
     Interface* mInterface;
     QHash<QTableView*, QString> mStateKeys;
 
 private Q_SLOTS:
     void setCurrentSel();
 };
 
 #endif // INTERFACESTATISTICSDIALOG_H
diff --git a/src/knemod/interfacestatusdialog.cpp b/src/knemod/interfacestatusdialog.cpp
index df51216..e78eb9a 100644
--- a/src/knemod/interfacestatusdialog.cpp
+++ b/src/knemod/interfacestatusdialog.cpp
@@ -1,413 +1,413 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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 <kio/global.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <QAbstractItemView>
 #include <KConfigGroup>
+#include <KSharedConfig>
 
 #ifdef __linux__
   #include <netlink/netlink.h>
 #endif
 
 #include "global.h"
 #include "interface.h"
 #include "interfacestatistics.h"
 #include "interfacestatusdialog.h"
 #include "statisticsmodel.h"
 
 InterfaceStatusDialog::InterfaceStatusDialog( Interface* interface, QWidget* parent )
     : QDialog( parent ),
       mWasShown( false ),
       mSetPos( true ),
-      mConfig( KSharedConfig::openConfig() ),
       mInterface( interface )
 {
     setWindowTitle( i18nc( "interface name", "%1 Interface Status", interface->ifaceName() ) );
 
     ui.setupUi( this );
     configChanged();
 
     // FreeBSD doesn't have these
 #ifndef __linux__
     ui.addrLabel->hide();
     ui.textLabelAddrLabel->hide();
     ui.textLabelNickNameL->hide();
     ui.textLabelNickName->hide();
 #endif
 
     connect( ui.comboBoxIP, SIGNAL( currentIndexChanged(int) ), this, SLOT( updateDialog() ) );
 
     updateDialog();
     const BackendData * data = mInterface->backendData();
     if ( !data )
         return;
     if ( !data->isWireless )
     {
         QWidget* wirelessTab = ui.tabWidget->widget( 2 );
         ui.tabWidget->removeTab( 2 );
         delete wirelessTab;
     }
 
     // Restore window size and position.
-    KConfig *config = mConfig.data();
+    KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup interfaceGroup( config, confg_interface + mInterface->ifaceName() );
     if ( interfaceGroup.hasKey( conf_statusPos ) )
     {
         QPoint p = interfaceGroup.readEntry( conf_statusPos, QPoint() );
         // See comment in event()
         mSetPos = false;
         move( p );
     }
     if ( interfaceGroup.hasKey( conf_statusSize ) )
     {
         QSize s = interfaceGroup.readEntry( conf_statusSize, QSize() );
         resize( s );
     }
     else
         resize( sizeHint() );
 
     statisticsChanged();
 }
 
 InterfaceStatusDialog::~InterfaceStatusDialog()
 {
     if ( mWasShown )
     {
-        KConfig *config = mConfig.data();
+        KSharedConfig::Ptr config = KSharedConfig::openConfig();
         KConfigGroup interfaceGroup( config, confg_interface + mInterface->ifaceName() );
         interfaceGroup.writeEntry( conf_statusPos, pos() );
         interfaceGroup.writeEntry( conf_statusSize, size() );
         config->sync();
     }
 }
 
 bool InterfaceStatusDialog::event( QEvent *e )
 {
     /* If we do not explicitly call size() and move() at least once then
      * hiding and showing the dialog will cause it to forget its previous
      * size and position. */
     if ( e->type() == QEvent::Move )
     {
         if ( mSetPos && !pos().isNull() )
         {
             mSetPos = false;
             move( pos() );
         }
     }
     else if ( e->type() == QEvent::Show )
     {
         mWasShown = true;
         updateDialog();
     }
 
     return QDialog::event( e );
 }
 
 void InterfaceStatusDialog::updateDialog()
 {
     if ( isHidden() )
         return;
 
     const BackendData* data = mInterface->backendData();
     if ( !data )
         return;
     InterfaceSettings& settings = mInterface->settings();
 
     // connection tab
     ui.textLabelInterface->setText( mInterface->ifaceName() );
     ui.textLabelAlias->setText( settings.alias );
     ui.textLabelUptime->setText( mInterface->uptimeString() );
 
     if ( data->status & KNemoIface::Connected )
         ui.textLabelStatus->setText( i18n( "Connected" ) );
     else if ( data->status & KNemoIface::Up )
         ui.textLabelStatus->setText( i18n( "Disconnected" ) );
     else if ( data->status & KNemoIface::Available )
         ui.textLabelStatus->setText( i18n( "Down" ) );
     else
         ui.textLabelStatus->setText( i18n( "Unavailable" ) );
 
     ui.groupBoxStatistics->setEnabled( mInterface->settings().activateStatistics );
 
     if ( data->status & KNemoIface::Available )
     {
         doAvailable( data );
         if ( data->status & KNemoIface::Up )
         {
             doUp( data );
             if ( data->status & KNemoIface::Connected )
                 doConnected( data );
         }
     }
 
     if ( data->status < KNemoIface::Connected )
     {
         doDisconnected( data );
         if ( data->status < KNemoIface::Up )
         {
             doDown();
             if ( data->status < KNemoIface::Available )
                 doUnavailable();
         }
     }
 }
 
 void InterfaceStatusDialog::doAvailable( const BackendData* data )
 {
     if ( data->interfaceType == KNemoIface::Ethernet )
     {
         ui.macText->setText( data->hwAddress );
         ui.macLabel->show();
         ui.macText->show();
     }
     else
     {
         ui.gatewayLabel->hide();
         ui.gatewayText->hide();
         ui.macLabel->hide();
         ui.macText->hide();
     }
 
     ui.textLabelPacketsSend->setText( QString::number( data->txPackets ) );
     ui.textLabelPacketsReceived->setText( QString::number( data->rxPackets ) );
     ui.textLabelBytesSend->setText( data->txString );
     ui.textLabelBytesReceived->setText( data->rxString );
     ui.textLabelSpeedSend->setText( mInterface->txRateStr() );
     ui.textLabelSpeedReceived->setText( mInterface->rxRateStr() );
 }
 
 void InterfaceStatusDialog::doConnected( const BackendData *data )
 {
     ui.groupBoxCurrentConnection->setEnabled( true );
     if ( data->isWireless )
     {
         // wireless tab
         ui.textLabelESSID->setText( data->essid );
         ui.textLabelAccessPoint->setText( data->accessPoint );
         ui.textLabelNickName->setText( data->nickName );
         ui.textLabelMode->setText( data->mode );
         ui.textLabelFreqChannel->setText( data->frequency + QLatin1String(" [") + data->channel + QLatin1Char(']') );
         ui.textLabelBitRate->setText( data->bitRate );
         ui.textLabelLinkQuality->setText( data->linkQuality );
         if ( data->isEncrypted == true )
         {
             ui.textLabelEncryption->setText( i18n( "active" ) );
         }
         else
         {
             ui.textLabelEncryption->setText( i18n( "off" ) );
         }
     }
 }
 
 void InterfaceStatusDialog::doUp( const BackendData *data )
 {
     // ip tab
 
     // Simpler to just clear and re-insert items in the combo box.
     // But then if we're selecting, the highlighted item would get
     // cleared each poll period.
     int i = 0;
     QStringList keys = data->addrData.keys();
     while ( i < ui.comboBoxIP->count() )
     {
         if ( keys.contains( ui.comboBoxIP->itemText( i ) ) )
             i++;
         else
             ui.comboBoxIP->removeItem( i );
     }
     QFont f = QFontDatabase::systemFont( QFontDatabase::GeneralFont );
     QFontMetrics fm( f );
     int w = 0;
     int keyCounter = 0;
     foreach( QString key, keys )
     {
         // Combo box preserves order in map
         if ( ui.comboBoxIP->findText( key ) < 0 )
             ui.comboBoxIP->insertItem( keyCounter, key );
         keyCounter++;
         if ( fm.width( key ) > w )
             w = fm.width( key );
     }
     ui.comboBoxIP->setMinimumWidth( w + 35 );
 
     AddrData addrData = data->addrData.value( ui.comboBoxIP->currentText() );
 
 #ifdef __linux__
     if ( addrData.label.isEmpty() )
         ui.textLabelAddrLabel->clear();
     else
         ui.textLabelAddrLabel->setText( addrData.label );
 #endif
 
     if ( ui.comboBoxIP->count() > 0 )
     {
         QString scope;
         switch ( addrData.scope )
         {
             case RT_SCOPE_UNIVERSE:
                 scope = i18nc( "ipv6 address scope", "global" );
                 break;
             case RT_SCOPE_SITE:
                 scope = i18nc( "ipv6 address scope", "site" );
                 break;
             case RT_SCOPE_LINK:
                 scope = i18nc( "ipv6 address scope", "link" );
                 break;
             case RT_SCOPE_HOST:
                 scope = i18nc( "ipv6 address scope", "host" );
                 break;
             case RT_SCOPE_NOWHERE:
                 scope = i18nc( "ipv6 address scope", "none" );
                 break;
         }
         scope += addrData.ipv6Flags;
         ui.textLabelScope->setText( scope );
 
         if ( data->interfaceType == KNemoIface::Ethernet )
         {
             if ( addrData.scope != RT_SCOPE_HOST )
             {
                 if ( addrData.afType == AF_INET )
                     ui.gatewayText->setText( data->ip4DefaultGateway );
                 else
                     ui.gatewayText->setText( data->ip6DefaultGateway );
                 ui.gatewayLabel->show();
                 ui.gatewayText->show();
             }
             else
             {
                 ui.gatewayLabel->hide();
                 ui.gatewayText->hide();
             }
         }
 
         ui.broadcastLabel->setText( i18n( "Broadcast Address:" ) );
         if ( addrData.scope != RT_SCOPE_HOST )
         {
             ui.broadcastText->setText( addrData.broadcastAddress );
             if ( addrData.hasPeer )
                 ui.broadcastLabel->setText( i18n( "PtP Address:" ) );
             ui.broadcastLabel->show();
             ui.broadcastText->show();
         }
         else
         {
             ui.broadcastLabel->hide();
             ui.broadcastText->hide();
         }
     }
     ui.groupBoxIP->setEnabled( (ui.comboBoxIP->count() > 0) );
 
     // traffic tab
 }
 
 void InterfaceStatusDialog::doDisconnected( const BackendData *data )
 {
     ui.groupBoxCurrentConnection->setEnabled( false );
     if ( data->isWireless )
     {
         ui.textLabelESSID->setText( QString::null );
         ui.textLabelAccessPoint->setText( QString::null );
         ui.textLabelNickName->setText( QString::null );
         ui.textLabelMode->setText( QString::null );
         ui.textLabelFreqChannel->setText( QString::null );
         ui.textLabelBitRate->setText( QString::null );
         ui.textLabelLinkQuality->setText( QString::null );
         ui.textLabelEncryption->setText( QString::null );
     }
 }
 
 void InterfaceStatusDialog::doDown()
 {
     // clear IP group
     ui.groupBoxIP->setEnabled( false );
     ui.comboBoxIP->clear();
     ui.textLabelAddrLabel->setText( QString::null );
     ui.textLabelScope->setText( QString::null );
     ui.broadcastText->setText( QString::null );
     ui.gatewayText->setText( QString::null );
 }
 
 void InterfaceStatusDialog::doUnavailable()
 {
     ui.macText->setText( QString::null );
 
     // clear current connection group
     ui.textLabelPacketsSend->setText( QString::null );
     ui.textLabelPacketsReceived->setText( QString::null );
     ui.textLabelBytesSend->setText( QString::null );
     ui.textLabelBytesReceived->setText( QString::null );
     ui.textLabelSpeedSend->setText( QString::null );
     ui.textLabelSpeedReceived->setText( QString::null );
 }
 
 void InterfaceStatusDialog::configChanged()
 {
     bool billText = false;
     if ( mInterface->settings().activateStatistics )
     {
         foreach ( StatsRule rule, mInterface->settings().statsRules )
         {
             if ( rule.periodCount != 1 ||
                  rule.periodUnits != KNemoStats::Month ||
                  mInterface->ifaceStatistics()->calendar()->day( rule.startDate ) != 1 )
             {
                 billText = true;
             }
         }
     }
 
     ui.textLabelBill->setVisible( billText );
     ui.textLabelBillSent->setVisible( billText );
     ui.textLabelBillReceived->setVisible( billText );
     ui.textLabelBillTotal->setVisible( billText );
 }
 
 void InterfaceStatusDialog::statisticsChanged()
 {
     InterfaceStatistics *stat = mInterface->ifaceStatistics();
     if ( stat == 0 )
         return;
 
     StatisticsModel * statistics = stat->getStatistics( KNemoStats::Day );
     ui.textLabelTodaySent->setText( statistics->txText() );
     ui.textLabelTodayReceived->setText( statistics->rxText() );
     ui.textLabelTodayTotal->setText( statistics->totalText() );
 
     statistics = stat->getStatistics( KNemoStats::Month );
     ui.textLabelMonthSent->setText( statistics->txText() );
     ui.textLabelMonthReceived->setText( statistics->rxText() );
     ui.textLabelMonthTotal->setText( statistics->totalText() );
 
     statistics = stat->getStatistics( KNemoStats::BillPeriod );
     ui.textLabelBillSent->setText( statistics->txText() );
     ui.textLabelBillReceived->setText( statistics->rxText() );
     ui.textLabelBillTotal->setText( statistics->totalText() );
 
     statistics = stat->getStatistics( KNemoStats::Year );
     ui.textLabelYearSent->setText( statistics->txText() );
     ui.textLabelYearReceived->setText( statistics->rxText() );
     ui.textLabelYearTotal->setText( statistics->totalText() );
 }
 
 #include "moc_interfacestatusdialog.cpp"
diff --git a/src/knemod/interfacestatusdialog.h b/src/knemod/interfacestatusdialog.h
index f2dbc1b..62d9f54 100644
--- a/src/knemod/interfacestatusdialog.h
+++ b/src/knemod/interfacestatusdialog.h
@@ -1,82 +1,80 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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.
 */
 
 #ifndef INTERFACESTATUSDIALOG_H
 #define INTERFACESTATUSDIALOG_H
 
 #include <QDialog>
-#include <KSharedConfig>
 
 #include "ui_interfacestatusdlg.h"
 
 class Interface;
 
 /**
  * This class serves as the main window for KNemo.  It handles the
  * menus, toolbars, and status bars.
  *
  * @short Main window class
  * @author Percy Leonhardt <percy@eris23.de>
  */
 
 class InterfaceStatusDialog : public QDialog
 {
     Q_OBJECT
 public:
     /**
      * Default Constructor
      */
     InterfaceStatusDialog( Interface* interface,
                            QWidget* parent = 0L );
 
     /**
      * Default Destructor
      */
     virtual ~InterfaceStatusDialog();
 
 public Q_SLOTS:
     /**
      * Update the statistics tab when data changed
      */
     void statisticsChanged();
     void updateDialog();
     void configChanged();
 
 protected:
     bool event( QEvent *e );
 
 private:
     void doAvailable( const BackendData* data );
     void doConnected( const BackendData *data );
     void doUp( const BackendData *data );
     void doDisconnected( const BackendData *data );
     void doDown();
     void doUnavailable();
 
 
     Ui::InterfaceStatusDlg ui;
     bool mWasShown;
     bool mSetPos;
 
-    KSharedConfig::Ptr mConfig;
     Interface* mInterface;
 };
 
 #endif // INTERFACESTATUSDIALOG_H
diff --git a/src/knemod/knemodaemon.cpp b/src/knemod/knemodaemon.cpp
index 0c3a944..d9ac8c0 100644
--- a/src/knemod/knemodaemon.cpp
+++ b/src/knemod/knemodaemon.cpp
@@ -1,217 +1,217 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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 <QSqlDatabase>
 #include <QtDBus/QDBusConnection>
 #include <QTimer>
 
 #include <QAction>
 #include <KActionCollection>
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KMessageBox>
+#include <KSharedConfig>
 
 #include "global.h"
 #include "knemodaemon.h"
 #include "interface.h"
 #include "backends/backendfactory.h"
 #include "utils.h"
 
 QString KNemoDaemon::sSelectedInterface = QString::null;
 
 BackendBase *backend = NULL;
 GeneralSettings *generalSettings = NULL;
 
 KNemoDaemon::KNemoDaemon()
     : QObject(),
-      mConfig( KSharedConfig::openConfig() ),
       mHaveInterfaces( false )
 {
     migrateKde4Conf();
 
     generalSettings = new GeneralSettings();
     backend = BackendFactory::backend();
     QDBusConnection::sessionBus().registerObject(QLatin1String("/knemo"), this, QDBusConnection::ExportScriptableSlots);
     mPollTimer = new QTimer();
     connect( mPollTimer, SIGNAL( timeout() ), this, SLOT( updateInterfaces() ) );
 
     KActionCollection* ac = new KActionCollection( this );
     QAction* action = new QAction( i18n( "Toggle Traffic Plotters" ), this );
     ac->addAction( QLatin1String("toggleTrafficPlotters"), action );
     connect( action, SIGNAL( triggered() ), SLOT( togglePlotters() ) );
     KGlobalAccel::setGlobalShortcut( action, QKeySequence() );
 
     readConfig();
 }
 
 KNemoDaemon::~KNemoDaemon()
 {
     mPollTimer->stop();
     delete mPollTimer;
 
     foreach ( QString key, mInterfaceHash.keys() )
     {
         Interface *interface = mInterfaceHash.take( key );
         delete interface;
     }
     delete generalSettings;
 }
 
 void KNemoDaemon::readConfig()
 {
     mPollTimer->stop();
-    KConfig *config = mConfig.data();
 
+    KSharedConfig::Ptr config = KSharedConfig::openConfig();
     // For when reparseConfiguration() is called
     config->reparseConfiguration();
 
     // General
     GeneralSettings g;
     KConfigGroup generalGroup( config, confg_general );
     generalSettings->pollInterval = clamp<double>(generalGroup.readEntry( conf_pollInterval, g.pollInterval ), 0.1, 2.0 );
     generalSettings->pollInterval = validatePoll( generalSettings->pollInterval );
     generalSettings->useBitrate = generalGroup.readEntry( conf_useBitrate, g.useBitrate );
     generalSettings->saveInterval = clamp<int>(generalGroup.readEntry( conf_saveInterval, g.saveInterval ), 0, 300 );
     generalSettings->statisticsDir = g.statisticsDir;
     generalSettings->toolTipContent = generalGroup.readEntry( conf_toolTipContent, g.toolTipContent );
     // If we already have an Interfaces key--even if its empty--then we
     // shouldn't try to set up a default interface
     if ( generalGroup.hasKey( conf_interfaces ) )
         mHaveInterfaces = true;
     QStringList interfaceList = generalGroup.readEntry( conf_interfaces, QStringList() );
 
     // Remove interfaces that are no longer monitored
     foreach ( QString key, mInterfaceHash.keys() )
     {
         if ( !interfaceList.contains( key ) )
         {
             Interface *interface = mInterfaceHash.take( key );
             delete interface;
             backend->removeIface( key );
 
             // If knemo is running while config removes an interface to monitor,
             // it will keep the interface and plotter groups. Delete them here.
             KConfigGroup interfaceGroup( config, QString( confg_interface + key ) );
             KConfigGroup plotterGroup( config, QString( confg_plotter + key ) );
             interfaceGroup.deleteGroup();
             plotterGroup.deleteGroup();
             config->sync();
         }
     }
 
     if ( !mHaveInterfaces )
     {
         QString ifaceName = backend->defaultRouteIface( AF_INET );
         if ( ifaceName.isEmpty() )
             ifaceName = backend->defaultRouteIface( AF_INET6 );
         if ( !ifaceName.isEmpty() )
         {
             interfaceList << ifaceName;
             mHaveInterfaces = true;
         }
     }
 
     // Add/update those that do need to be monitored
     QStringList newIfaces;
     foreach ( QString key, interfaceList )
     {
         if ( !mInterfaceHash.contains( key ) )
         {
             const BackendData * data = backend->addIface( key );
             Interface *iface = new Interface( key, data );
             mInterfaceHash.insert( key, iface );
             newIfaces << key;
         }
     }
 
     // Now (re)config interfaces, but new interfaces need extra work so
     // they don't show bogus icon traffic states on startup.
     updateInterfaces();
     foreach( QString key, interfaceList )
     {
         Interface *iface = mInterfaceHash.value( key );
         iface->configChanged();
 
         if ( newIfaces.contains( key ) )
         {
             backend->updatePackets( key );
             iface->processUpdate();
             connect( backend, SIGNAL( updateComplete() ), iface, SLOT( processUpdate() ) );
         }
     }
 
     bool statsActivated = false;
     foreach ( Interface *iface, mInterfaceHash )
     {
         if ( iface->settings().activateStatistics )
             statsActivated = true;
     }
     if ( statsActivated )
     {
         QStringList drivers = QSqlDatabase::drivers();
         if ( !drivers.contains( QLatin1String("QSQLITE") ) )
         {
             KMessageBox::sorry( 0, i18n( "The Qt4 SQLite database plugin is not available.\n"
                                          "Please install it to store traffic statistics." ) );
         }
     }
 
     mPollTimer->start( generalSettings->pollInterval * 1000 );
 }
 
 void KNemoDaemon::reparseConfiguration()
 {
     readConfig();
 }
 
 QString KNemoDaemon::getSelectedInterface()
 {
     // Reset the variable to avoid preselecting an interface when
     // the user opens the control center module from the control
     // center afterwards.
     QString tmp = sSelectedInterface;
     sSelectedInterface = QString::null;
 
     return tmp;
 }
 
 void KNemoDaemon::updateInterfaces()
 {
     backend->update();
 }
 
 void KNemoDaemon::togglePlotters()
 {
     bool showPlotters = false;
     foreach ( QString key, mInterfaceHash.keys() )
     {
         // If only some of the plotters are visible, show them all
         if ( !mInterfaceHash.value( key )->plotterVisible() )
             showPlotters = true;
     }
 
     foreach ( QString key, mInterfaceHash.keys() )
     {
         mInterfaceHash.value( key )->toggleSignalPlotter( showPlotters );
     }
 }
 
 #include "moc_knemodaemon.cpp"
diff --git a/src/knemod/knemodaemon.h b/src/knemod/knemodaemon.h
index fd44185..3dec208 100644
--- a/src/knemod/knemodaemon.h
+++ b/src/knemod/knemodaemon.h
@@ -1,103 +1,101 @@
 /* This file is part of KNemo
    Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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.
 */
 
 #ifndef KNEMODAEMON_H
 #define KNEMODAEMON_H
 
 #include <QHash>
 #include <QApplication>
-#include <KSharedConfig>
 
 class QTimer;
 class Interface;
 class BackendBase;
 
 /**
  * This class is the main entry point of KNemo. It reads the configuration,
  * creates the logical interfaces and starts an interface updater. It also
  * takes care of configuration changes by the user.
  *
  * @short KNemos main entry point
  * @author Percy Leonhardt <percy@eris23.de>
  */
 //class KNemoDaemon : public KDEDModule
 class KNemoDaemon : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO( "D-Bus Interface", "org.kde.knemo" )
 public:
     /**
      * Default Constructor
      */
     KNemoDaemon();
 
     /**
      * Default Destructor
      */
     virtual ~KNemoDaemon();
 
     // tell the control center module which interface the user selected
     static QString sSelectedInterface;
 
 
 public Q_SLOTS:
     /*
      * Called from the control center module when the user changed
      * the settings. It updates the internal list of interfaces
      * that should be monitored.
      */
     Q_SCRIPTABLE void reparseConfiguration();
 
     /* When the user selects 'Configure KNemo...' from the context
      * menus this functions gets called from the control center
      * module. This way the module knows for which interface the
      * user opened the dialog and can preselect the appropriate
      * interface in the list.
      */
     Q_SCRIPTABLE QString getSelectedInterface();
 
 private:
     /*
      * Read the configuration on startup
      */
     void readConfig();
 
 private Q_SLOTS:
     /**
      * trigger the backend to update the interface informations
      */
     void updateInterfaces();
 
     void togglePlotters();
 
 private:
-    KSharedConfig::Ptr mConfig;
     bool mHaveInterfaces;
 
     // every time this timer expires we will
     // gather new informations from the backend
     QTimer* mPollTimer;
     // the name of backend we currently use
     QString mBackendName;
     // a list of all interfaces the user wants to monitor
     QHash<QString, Interface *> mInterfaceHash;
 };
 
 #endif // KNEMODAEMON_H
diff --git a/src/knemod/plotterconfigdialog.cpp b/src/knemod/plotterconfigdialog.cpp
index b2928a5..326a0ff 100644
--- a/src/knemod/plotterconfigdialog.cpp
+++ b/src/knemod/plotterconfigdialog.cpp
@@ -1,158 +1,156 @@
 /* This file is part of KNemo
    Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
 
    KNemo is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    KNemo 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 "plotterconfigdialog.h"
 #include "global.h"
 
-#include <KConfig>
-
 PlotterConfigDialog::PlotterConfigDialog( QWidget * parent, const QString& iface, PlotterSettings* settings ) : QDialog( parent ),
       mName( iface ),
       mSettings( settings )
 {
     QString suffix;
     if ( generalSettings->useBitrate )
     {
         suffix = i18n( " kbit/s" );
     }
     else
     {
         suffix = i18n( " KiB/s" );
     }
     ui.setupUi( this );
     ui.spinBoxMinValue->setSuffix( suffix );
     ui.spinBoxMaxValue->setSuffix( suffix );
     load();
     ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
     //enableButtonDefault( true );
 
     connect( ui.buttonBox, SIGNAL( accepted() ), SLOT( save() ) );
     connect( ui.buttonBox, SIGNAL( clicked( QAbstractButton* ) ), SLOT( defaults( QAbstractButton* ) ) );
 
     // connect the plotter widgets
     connect( ui.checkBoxLabels, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
     connect( ui.checkBoxVLines, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
     connect( ui.checkBoxHLines, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
     connect( ui.checkBoxIncoming, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
     connect( ui.checkBoxOutgoing, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
     connect( ui.checkBoxVLinesScroll, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
     connect( ui.checkBoxAutoDetection, SIGNAL( toggled( bool ) ),
              this, SLOT( changed() ) );
     connect( ui.spinBoxPixel, SIGNAL( valueChanged( int ) ),
              this, SLOT( changed() ) );
     connect( ui.spinBoxDistance, SIGNAL( valueChanged( int ) ),
              this, SLOT( changed() ) );
     connect( ui.spinBoxFontSize, SIGNAL( valueChanged( int ) ),
              this, SLOT( changed() ) );
     connect( ui.spinBoxMinValue, SIGNAL( valueChanged( double ) ),
              this, SLOT( changed() ) );
     connect( ui.spinBoxMaxValue, SIGNAL( valueChanged( double ) ),
              this, SLOT( changed() ) );
     connect( ui.kColorButtonIncoming, SIGNAL( changed( const QColor& ) ),
              this, SLOT( changed() ) );
     connect( ui.kColorButtonOutgoing, SIGNAL( changed( const QColor& ) ),
              this, SLOT( changed() ) );
 }
 
 PlotterConfigDialog::~PlotterConfigDialog()
 {
 }
 
 void PlotterConfigDialog::load()
 {
     ui.spinBoxPixel->setValue( mSettings->pixel );
     ui.spinBoxDistance->setValue( mSettings->distance );
     ui.spinBoxFontSize->setValue( mSettings->fontSize );
     ui.spinBoxMinValue->setValue( mSettings->minimumValue );
     ui.spinBoxMaxValue->setValue( mSettings->maximumValue );
     ui.checkBoxLabels->setChecked( mSettings->labels );
     ui.checkBoxVLines->setChecked( mSettings->verticalLines );
     ui.checkBoxHLines->setChecked( mSettings->horizontalLines );
     ui.checkBoxIncoming->setChecked( mSettings->showIncoming );
     ui.checkBoxOutgoing->setChecked( mSettings->showOutgoing );
     ui.checkBoxAutoDetection->setChecked( !mSettings->automaticDetection );
     ui.checkBoxVLinesScroll->setChecked( mSettings->verticalLinesScroll );
     ui.kColorButtonIncoming->setColor( mSettings->colorIncoming );
     ui.kColorButtonOutgoing->setColor( mSettings->colorOutgoing );
 }
 
 void PlotterConfigDialog::save()
 {
     mSettings->pixel = ui.spinBoxPixel->value();
     mSettings->distance = ui.spinBoxDistance->value();
     mSettings->fontSize = ui.spinBoxFontSize->value();
     mSettings->minimumValue = ui.spinBoxMinValue->value();
     mSettings->maximumValue = ui.spinBoxMaxValue->value();
     mSettings->labels = ui.checkBoxLabels->isChecked();
     mSettings->verticalLines = ui.checkBoxVLines->isChecked();
     mSettings->horizontalLines = ui.checkBoxHLines->isChecked();
     mSettings->showIncoming = ui.checkBoxIncoming->isChecked();
     mSettings->showOutgoing = ui.checkBoxOutgoing->isChecked();
     mSettings->automaticDetection = !ui.checkBoxAutoDetection->isChecked();
     mSettings->verticalLinesScroll = ui.checkBoxVLinesScroll->isChecked();
     mSettings->colorIncoming = ui.kColorButtonIncoming->color();
     mSettings->colorOutgoing = ui.kColorButtonOutgoing->color();
     ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
     emit saved();
 }
 
 void PlotterConfigDialog::defaults( QAbstractButton* button )
 {
     if (static_cast<QPushButton*>(button) == ui.buttonBox->button(QDialogButtonBox::RestoreDefaults) ) {
         ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
         PlotterSettings s;
         // Default plotter settings
         ui.spinBoxPixel->setValue( s.pixel );
         ui.spinBoxDistance->setValue( s.distance );
         ui.spinBoxFontSize->setValue( s.fontSize );
         ui.spinBoxMinValue->setValue( s.minimumValue );
         ui.spinBoxMaxValue->setValue( s.maximumValue );
         ui.checkBoxLabels->setChecked( s.labels );
         ui.checkBoxVLines->setChecked( s.verticalLines );
         ui.checkBoxHLines->setChecked( s.horizontalLines );
         ui.checkBoxIncoming->setChecked( s.showIncoming );
         ui.checkBoxOutgoing->setChecked( s.showOutgoing );
         ui.checkBoxAutoDetection->setChecked( !s.automaticDetection );
         ui.checkBoxVLinesScroll->setChecked( s.verticalLinesScroll );
         ui.kColorButtonIncoming->setColor( s.colorIncoming );
         ui.kColorButtonOutgoing->setColor( s.colorOutgoing );
     } else if (static_cast<QPushButton*>(button) == ui.buttonBox->button(QDialogButtonBox::Ok) ) {
         QDialog::accept();
     } else if (static_cast<QPushButton*>(button) == ui.buttonBox->button(QDialogButtonBox::Apply) ) {
         save();
     } else if (static_cast<QPushButton*>(button) == ui.buttonBox->button(QDialogButtonBox::Cancel) ) {
         QDialog::reject();
     }
 
 }
 
 void PlotterConfigDialog::changed()
 {
     ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 }
 
 #include "moc_plotterconfigdialog.cpp"