diff --git a/libpublictransporthelper/serviceproviderdatadialog.cpp b/libpublictransporthelper/serviceproviderdatadialog.cpp
index 83c5983..67e1240 100644
--- a/libpublictransporthelper/serviceproviderdatadialog.cpp
+++ b/libpublictransporthelper/serviceproviderdatadialog.cpp
@@ -1,495 +1,495 @@
 /*
  *   Copyright 2012 Friedrich Pülz <fpuelz@gmx.de>
  *
  *   This program 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 or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 // Header
 #include "serviceproviderdatadialog.h"
 
 // Own includes
 #include "ui_providerData.h"
 
 // KDE includes
 #include <KToolInvocation>
 #include <KMessageBox>
 #include <KDebug>
 #include <KGlobal>
 
 #include <Plasma/Service>
 #include <Plasma/ServiceJob>
 #include <Plasma/DataEngine>
 #include <Plasma/PluginLoader>
 #include <Plasma/DataEngineConsumer>
 
 /** @brief Namespace for the publictransport helper library. */
 namespace PublicTransport {
 
 class ServiceProviderDataWidgetPrivate {
 public:
     ServiceProviderDataWidgetPrivate( const QString &providerId,
                                       ServiceProviderDataWidget::Options _options,
                                       ServiceProviderDataWidget *q )
             : q(q), providerId(providerId), options(_options), feedSizeInBytes(0)
     {
         uiProviderData.setupUi( q );
     };
 
     void updateIcon( const QIcon &icon ) {
         uiProviderData.icon->setPixmap( icon.pixmap( 32 ) );
     }
 
     void update( const Plasma::DataEngine::Data &data ) {
         providerType = data["type"].toString();
         uiProviderData.type->setText( providerType );
 
         state = data["state"].toString();
         stateData = data["stateData"].toHash();
         uiProviderData.state->setText( stateData["statusMessage"].toString() );
 
         // Hide all widgets except for the status message for erroneous providers
         // because the other fields are empty
         const bool hasError = state == QLatin1String("error");
         uiProviderData.icon->setVisible( !hasError );
         uiProviderData.version->setVisible( !hasError );
         uiProviderData.line->setVisible( !hasError );
         uiProviderData.lblUrl->setVisible( !hasError );
         uiProviderData.url->setVisible( !hasError );
         uiProviderData.lblAuthor->setVisible( !hasError );
         uiProviderData.author->setVisible( !hasError );
         uiProviderData.lblType->setVisible( !hasError );
         uiProviderData.type->setVisible( !hasError );
         uiProviderData.lblFileName->setVisible( !hasError );
         uiProviderData.fileName->setVisible( !hasError );
         uiProviderData.lblFeatures->setVisible( !hasError );
         uiProviderData.features->setVisible( !hasError );
         uiProviderData.lblDescription->setVisible( !hasError );
         uiProviderData.description->setVisible( !hasError );
 
         const QString type = data["type"].toString();
         if ( type != QLatin1String("GTFS") ) {
             uiProviderData.lblGtfsFeed->hide();
             uiProviderData.gtfsFeed->hide();
             uiProviderData.importGtfsFeedButton->hide();
             uiProviderData.updateGtfsDatabaseButton->hide();
             uiProviderData.deleteGtfsDatabaseButton->hide();
             uiProviderData.progressBar->hide();
         } else {
             // Is a GTFS provider
             const QString feedUrl = data["feedUrl"].toString();
             uiProviderData.lblGtfsFeed->show();
             uiProviderData.gtfsFeed->show();
             if ( state == QLatin1String("ready") ) {
                 uiProviderData.importGtfsFeedButton->setEnabled( false );
                 uiProviderData.deleteGtfsDatabaseButton->setEnabled( true );
                 feedSizeInBytes = stateData["gtfsDatabaseSize"].toInt();
                 uiProviderData.gtfsFeed->setText( i18nc("@info:label",
                         "<a href='%1'>%1</a>,<nl/>%2 disk space used",
                         feedUrl, KGlobal::locale()->formatByteSize(feedSizeInBytes)) );
             } else {
                 uiProviderData.importGtfsFeedButton->setEnabled(
                         state == QLatin1String("gtfs_feed_import_pending") );
                 uiProviderData.deleteGtfsDatabaseButton->setEnabled( false );
                 uiProviderData.gtfsFeed->setText(
                         i18nc("@info:label", "<a href='%1'>%1</a>", feedUrl) );
             }
 
             if ( state == QLatin1String("importing_gtfs_feed") ) {
                 uiProviderData.progressBar->setValue( stateData["progress"].toInt() );
                 uiProviderData.progressBar->show();
             } else {
                 uiProviderData.progressBar->hide();
             }
         }
 
         // Set the tooltip for the "Delete GTFS Database" button also if it gets hidden,
         // because ServiceProviderDataDialog may use this tooltip for it's own (dialog) button
         uiProviderData.deleteGtfsDatabaseButton->setToolTip(
                 i18nc("@info:tooltip", "<title>Delete GTFS Database</title>"
                     "<para>The GTFS database contains all data imported from the GTFS "
                     "feed. If you delete the database now the GTFS feed needs to be "
                     "imported again to make this service provider usable again.</para>"
                     "<para>By deleting the database %1 disk space get freed.</para>",
                 KGlobal::locale()->formatByteSize(feedSizeInBytes) ) );
         if ( !options.testFlag(ServiceProviderDataWidget::ShowDatabaseControlButtons) ) {
             uiProviderData.lblOperations->hide();
             uiProviderData.importGtfsFeedButton->hide();
             uiProviderData.updateGtfsDatabaseButton->hide();
             uiProviderData.deleteGtfsDatabaseButton->hide();
         }
 
         uiProviderData.serviceProviderName->setText(data["name"].toString() );
         uiProviderData.version->setText( i18nc("@info/plain", "Version %1",
                 data["version"].toString()) );
         uiProviderData.url->setUrl( data["url"].toString() );
         uiProviderData.url->setText( QString("<a href='%1'>%1</a>").arg(
                 data["url"].toString()) );
 
         uiProviderData.fileName->setUrl( data["fileName"].toString() );
         uiProviderData.fileName->setText( QString("<a href='%1'>%1</a>").arg(
                 data["fileName"].toString()) );
 
         QString scriptFileName = data["scriptFileName"].toString();
         if ( scriptFileName.isEmpty() ) {
             uiProviderData.lblScriptFileName->setVisible( false );
             uiProviderData.scriptFileName->setVisible( false );
         } else {
             uiProviderData.lblScriptFileName->setVisible( true );
             uiProviderData.scriptFileName->setVisible( true );
             uiProviderData.scriptFileName->setUrl( scriptFileName );
             uiProviderData.scriptFileName->setText( QString("<a href='%1'>%1</a>")
                     .arg(scriptFileName) );
         }
 
         if ( data["email"].toString().isEmpty() ) {
             uiProviderData.author->setText( data["author"].toString() );
         } else {
             uiProviderData.author->setText( QString("<a href='mailto:%2'>%1</a> (%3)")
                     .arg(data["author"].toString())
                     .arg(data["email"].toString())
                     .arg(data["shortAuthor"].toString()) );
             uiProviderData.author->setToolTip( i18nc("@info",
                     "Write an email to <email address='%2'>%1</email> (%3)",
                     data["author"].toString(),
                     data["email"].toString(),
                     data["shortAuthor"].toString()) );
         }
         uiProviderData.description->setText( data["description"].toString() );
         uiProviderData.features->setText( data["featureNames"].toStringList().join(", ") );
 
         QStringList changelogEntries = data["changelog"].toStringList();
         if ( changelogEntries.isEmpty() ) {
             uiProviderData.lblChangelog->hide();
             uiProviderData.changelog->hide();
         } else {
             QString changelog("<ul style='margin-left:-20;'>");
             foreach ( const QString &entry, changelogEntries ) {
                 int pos = entry.indexOf(':');
                 if ( pos == -1 ) {
                     changelog.append( QString("<li>%1</li>").arg(entry) );
                 } else {
                     QString e = entry;
                     changelog.append( QString("<li><span style='font-style: italic;'>%1</li>")
                             .arg(e.insert(pos + 1, QLatin1String("</span>"))) );
                 }
             }
             changelog.append( QLatin1String("</ul>") );
             uiProviderData.changelog->setHtml( changelog );
         }
 
         q->emit providerStateChanged( state, stateData );
     };
 
     QString providerFileName() const {
         return uiProviderData.fileName->url();
     };
 
     ServiceProviderDataWidget *q;
     Ui::providerData uiProviderData;
     QString providerId;
     ServiceProviderDataWidget::Options options;
     QString providerType;
     QString state;
     QVariantHash stateData;
     qint64 feedSizeInBytes;
 };
 
 ServiceProviderDataWidget::ServiceProviderDataWidget( const QString &providerId,
         ServiceProviderDataWidget::Options options, QWidget *parent )
         : QWidget(parent),
           d_ptr(new ServiceProviderDataWidgetPrivate(providerId, options, this))
 {
     Q_D( ServiceProviderDataWidget );
     Plasma::DataEngineConsumer *consumer;
     Plasma::PluginLoader::self()->loadDataEngine( "publictransport" );
     Plasma::PluginLoader::self()->loadDataEngine( "favicons" );
     Plasma::DataEngine *engine = consumer->dataEngine( "publictransport" );
     engine->connectSource( "ServiceProvider " + providerId, this );
     connect( d->uiProviderData.deleteGtfsDatabaseButton, SIGNAL(pressed()),
              this, SLOT(deleteGtfsDatabase()) );
     connect( d->uiProviderData.importGtfsFeedButton, SIGNAL(pressed()),
              this, SLOT(importGtfsFeed()) );
     connect( d->uiProviderData.updateGtfsDatabaseButton, SIGNAL(pressed()),
              this, SLOT(updateGtfsDatabase()) );
 }
 
 ServiceProviderDataWidget::~ServiceProviderDataWidget()
 {
     Q_D( ServiceProviderDataWidget );
     Plasma::DataEngineConsumer *consumer;
 
     // Disconnect sources to prevent warnings (No such slot QObject::dataUpdated...)
     Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
     engine->disconnectSource( "ServiceProvider " + d->providerId, this );
 
     delete d_ptr;
 
     consumer->~DataEngineConsumer();
 }
 
 void ServiceProviderDataWidget::dataUpdated( const QString &sourceName,
                                              const Plasma::DataEngine::Data &data )
 {
     Q_D( ServiceProviderDataWidget );
     Plasma::DataEngineConsumer *consumer;
 
     if ( sourceName == "ServiceProvider " + d->providerId ) {
         d->update( data );
 
         // Request favicon
         Plasma::DataEngine *favIconEngine = consumer->dataEngine( "favicons" );
         if ( favIconEngine ) {
             QString favIconSource = data["url"].toString();
             favIconEngine->connectSource( favIconSource, this );
         }
     } else {
         // Favicon of a service provider arrived
         QPixmap favicon( QPixmap::fromImage( data["Icon"].value<QImage>() ) );
         if ( favicon.isNull() ) {
             // No favicon found for sourceName;
             favicon = QPixmap( 16, 16 );
             favicon.fill( Qt::transparent );
         }
 
         d->updateIcon( QIcon(favicon) );
     }
 }
 
 QString ServiceProviderDataWidget::providerType() const
 {
     Q_D( const ServiceProviderDataWidget );
     return d->providerType;
 }
 
 QString ServiceProviderDataWidget::providerState() const
 {
     Q_D( const ServiceProviderDataWidget );
     return d->state;
 }
 
 QVariantHash ServiceProviderDataWidget::providerStateData() const
 {
     Q_D( const ServiceProviderDataWidget );
     return d->stateData;
 }
 
 class ServiceProviderDataDialogPrivate {
     friend class ServiceProviderDataWidget;
 
 public:
     ServiceProviderDataDialogPrivate( ServiceProviderDataDialog *q ) : q(q), widget(0) {};
 
     void updateDialogButtons()
     {
         if ( widget->providerType() != QLatin1String("GTFS") ) {
             q->showButton( KDialog::User2, false );
             q->showButton( KDialog::User3, false );
             return;
         }
 
         if ( q->button(KDialog::User2) ) {
             KPushButton *button;
             if ( widget->providerState() == QLatin1String("gtfs_feed_import_pending") ) {
                 button = widget->d_ptr->uiProviderData.importGtfsFeedButton;
                 q->enableButton( KDialog::User2, true );
             } else if ( widget->providerState() == QLatin1String("ready") ) {
                 button = widget->d_ptr->uiProviderData.deleteGtfsDatabaseButton;
                 q->enableButton( KDialog::User2, true );
             } else {
                 button = widget->d_ptr->uiProviderData.importGtfsFeedButton;
                 q->enableButton( KDialog::User2, false );
             }
 
             q->setButtonIcon( KDialog::User2, button->icon() );
             q->setButtonText( KDialog::User2, button->text() );
             q->setButtonToolTip( KDialog::User2, button->toolTip() );
             q->showButton( KDialog::User2, true );
         }
 
         if ( q->button(KDialog::User3) ) {
             const bool isReady = widget->providerState() == QLatin1String("ready");
             const bool updateAvailable =
                     isReady && widget->providerStateData().value("updatable").toBool();
             q->showButton( KDialog::User3, isReady );
             q->enableButton( KDialog::User3, updateAvailable );
         }
     };
 
     ServiceProviderDataDialog *q;
     ServiceProviderDataWidget *widget;
 };
 
 ServiceProviderDataDialog::ServiceProviderDataDialog( const QString &providerId,
         ServiceProviderDataDialog::Options options, QWidget *parent )
         : KDialog(parent), d_ptr(new ServiceProviderDataDialogPrivate(this))
 {
     Q_D( ServiceProviderDataDialog );
 
     d->widget = new ServiceProviderDataWidget(
             providerId, ServiceProviderDataWidget::NoOption, this );
     connect( d->widget, SIGNAL(providerStateChanged(QString,QVariantHash)),
              this, SLOT(providerStateChanged(QString,QVariantHash)) );
 
     setModal( true );
     setButtons( KDialog::Ok );
     setMainWidget( d->widget );
     setWindowTitle( i18nc("@title:window", "Service Provider Information") );
     setWindowIcon( QIcon::fromTheme("help-about") );
 
     ButtonCodes buttonCodes = Ok;
     if ( options.testFlag(ShowOpenInTimetableMateButton) ) {
         buttonCodes |= User1; // Add "Open in TimetableMate..." button
     }
     if ( options.testFlag(ShowDatabaseControlButtons) ) {
         buttonCodes |= User2; // Add delete/import button
         buttonCodes |= User3; // Add update button
     }
 
     setButtons( buttonCodes );
 
     if ( options.testFlag(ShowOpenInTimetableMateButton) ) {
         setButtonIcon( User1, QIcon::fromTheme("document-open") );
         setButtonText( User1, i18nc("@action:button", "Open in TimetableMate...") );
     }
 
     KPushButton *button = d->widget->d_ptr->uiProviderData.updateGtfsDatabaseButton;
     setButtonIcon( User3, button->icon() );
     setButtonText( User3, button->text() );
     setButtonToolTip( User3, button->toolTip() );
 
     d->updateDialogButtons();
 }
 
 ServiceProviderDataDialog::~ServiceProviderDataDialog()
 {
     delete d_ptr;
 }
 
 ServiceProviderDataWidget *ServiceProviderDataDialog::providerDataWidget() const
 {
     Q_D( const ServiceProviderDataDialog );
     return d->widget;
 }
 
 void ServiceProviderDataDialog::providerStateChanged( const QString &state,
                                                       const QVariantHash &stateData )
 {
     Q_UNUSED( state )
     Q_UNUSED( stateData )
     Q_D( ServiceProviderDataDialog );
 
     // TODO Enable the "Delete GTFS Database" button only when the provider is ready,
     // ie. the GTFS feed was imported
     d->updateDialogButtons();
 }
 
 void ServiceProviderDataDialog::slotButtonClicked( int button )
 {
     Q_D( ServiceProviderDataDialog );
     switch ( button ) {
     case User1:
         openInTimetableMate();
         break;
     case User2:
         if ( d->widget->providerState() == QLatin1String("ready") ) {
             d->widget->deleteGtfsDatabase();
         } else {
             d->widget->importGtfsFeed();
         }
         break;
     case User3:
         d->widget->updateGtfsDatabase();
         break;
     default:
         KDialog::slotButtonClicked( button );
         break;
     }
 }
 
 void ServiceProviderDataDialog::openInTimetableMate()
 {
     Q_D( ServiceProviderDataDialog );
     QString error;
     int result = KToolInvocation::startServiceByDesktopName( "timetablemate",
             d->widget->d_ptr->providerFileName(), &error );
     if ( result != 0 ) {
         KMessageBox::error( this, i18nc("@info",
                 "TimetableMate couldn't be started, error message was: '%1'", error) );
     }
 }
 
 void ServiceProviderDataWidget::deleteGtfsDatabase()
 {
     Q_D( ServiceProviderDataWidget );
     Plasma::DataEngineConsumer *consumer;
 
     if ( KMessageBox::warningContinueCancel(this, i18nc("@info",
             "<title>Delete GTFS database</title>"
             "<para>Do you really want to delete the GTFS database? You will need to import the "
             "GTFS feed again to use this service provider again.</para>"
             "<para>By deleting the database %1 disk space get freed.</para>",
             KGlobal::locale()->formatByteSize(d->feedSizeInBytes))) == KMessageBox::Continue )
     {
         Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
         Plasma::Service *gtfsService = engine->serviceForSource("GTFS");
-        KConfigGroup op = gtfsService->operationDescription("deleteGtfsDatabase");
-        op.writeEntry( "serviceProviderId", d->providerId );
-        Plasma::ServiceJob *deleteJob = gtfsService->startOperationCall( op );
+        QVariantMap serviceMap=  gtfsService->operationDescription("deleteGtfsDatabase");
+        serviceMap.insert("serviceProviderId", d->providerId);
+        Plasma::ServiceJob *deleteJob = gtfsService->startOperationCall( serviceMap );
         connect( deleteJob, SIGNAL(result(KJob*)), this, SLOT(deletionFinished(KJob*)) );
         connect( deleteJob, SIGNAL(finished(KJob*)), gtfsService, SLOT(deleteLater()) );
     }
 }
 
 void ServiceProviderDataWidget::importGtfsFeed()
 {
     Q_D( ServiceProviderDataWidget );
     Plasma::DataEngineConsumer *consumer;
 
     Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
     Plasma::Service *gtfsService = engine->serviceForSource("GTFS");
-    KConfigGroup op = gtfsService->operationDescription("importGtfsFeed");
-    op.writeEntry( "serviceProviderId", d->providerId );
-    Plasma::ServiceJob *importJob = gtfsService->startOperationCall( op );
+    QVariantMap serviceMap = gtfsService->operationDescription("importGtfsFeed");
+    serviceMap.insert( "serviceProviderId", d->providerId );
+    Plasma::ServiceJob *importJob = gtfsService->startOperationCall( serviceMap );
     connect( importJob, SIGNAL(finished(KJob*)), gtfsService, SLOT(deleteLater()) );
 }
 
 void ServiceProviderDataWidget::updateGtfsDatabase()
 {
     Q_D( ServiceProviderDataWidget );
     Plasma::DataEngineConsumer *consumer;
 
     Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
     Plasma::Service *gtfsService = engine->serviceForSource("GTFS");
-    KConfigGroup op = gtfsService->operationDescription("updateGtfsDatabase");
-    op.writeEntry( "serviceProviderId", d->providerId );
-    Plasma::ServiceJob *updateJob = gtfsService->startOperationCall( op );
+    QVariantMap serviceMap = gtfsService->operationDescription("updateGtfsDatabase");
+    serviceMap.insert( "serviceProviderId", d->providerId );
+    Plasma::ServiceJob *updateJob = gtfsService->startOperationCall( serviceMap );
     connect( updateJob, SIGNAL(finished(KJob*)), gtfsService, SLOT(deleteLater()) );
 }
 
 void ServiceProviderDataWidget::deletionFinished( KJob *job )
 {
     if ( job->error() != 0 ) {
         KMessageBox::information( this, i18nc("@info", "Deleting the GTFS database failed: "
                                               "<message>%1</message>", job->errorString()) );
     }
 }
 
 void ServiceProviderDataDialog::gtfsDatabaseDeletionFinished() {
     // Disable "Delete GTFS database" button
     enableButton( KDialog::User2, false );
 }
 
 } // namespace Timetable
diff --git a/libpublictransporthelper/stoplineedit.cpp b/libpublictransporthelper/stoplineedit.cpp
index 0f9e754..4ca341e 100644
--- a/libpublictransporthelper/stoplineedit.cpp
+++ b/libpublictransporthelper/stoplineedit.cpp
@@ -1,1084 +1,1085 @@
 /*
  *   Copyright 2012 Friedrich Pülz <fpuelz@gmx.de>
  *
  *   This program 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 or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 // Own includes
 #include "stoplineedit.h"
 #include "stopsettings.h"
 
 #ifdef MARBLE_FOUND
     #include "publictransportmapwidget.h"
     #include "publictransportlayer.h"
     #include "popuphandler.h"
 #endif
 
 // Plasma/KDE includes
 #include <Plasma/DataEngineConsumer>
 #include <Plasma/DataContainer>
 #include <Plasma/PluginLoader>
 #include <Plasma/DataEngine>
 #include <Plasma/ServiceJob>
 #include <KDebug>
 #include <KColorScheme>
 #include <KLocalizedString>
 
 // Qt includes
 #include <QIcon>
 #include <QEvent>
 #include <QPainter>
 #include <QStyle>
 #include <QStyleOption>
 #include <QMouseEvent>
+#include <QVariantMap>
 #include <QTimer>
 #include <qmath.h>
 
 /** @brief Namespace for the publictransport helper library. */
 namespace PublicTransport {
 
 /// Private class of StopLineEdit
 class StopLineEditPrivate
 {
     Q_DECLARE_PUBLIC( StopLineEdit )
 
 public:
     /// Different states of the StopLineEdit
     enum State {
         Ready, ///< Ready to get stop suggestions
         WaitingForImport, ///< Waiting for the first import (eg. of the associated GTFS feed).
                 ///< Later imports are updates and can be done in the background. This StopLineEdit
                 ///< gets put into read only mode and the progress gets visualized by a progress bar.
                 ///< An additional cancel button is shown to cancel the import.
         WaitingForStopSuggestions, ///< Waiting for an answer from the accessor with stop
                 ///< suggestions. This StopLineEdit is in read write mode and is enabled.
                 ///< Completions are added when the stop suggestions arrive.
         AskingToImportGtfsFeed, ///< Currently showing a question whether or not to import the
                 ///< GTFS feed. This StopLineEdit gets put into read only mode, but is enabled
                 ///< to be able to receive events for additional buttons (in this case these are the
                 ///< answer buttons).
         Pause, ///< The import is not finished but suspended.
         Error ///< There has been an error in the data engine / service. The error gets shown and
                 ///< this StopLineEdit gets put into read only mode.
     };
 
     /// Different button types for additional buttons
     enum ButtonType {
         StartButton  = 0x01,
         StopButton   = 0x02,
         PauseButton  = 0x04
     };
     Q_DECLARE_FLAGS( ButtonTypes, ButtonType )
 
     /// Different states for an additional button
     enum ButtonState {
         ButtonNormal  = 0x00, ///< Normal state (not pressed or hovered)
         ButtonPressed = 0x01, ///< Button is currently pressed
         ButtonPressedMouseOutside = 0x02, ///< The mouse button was pressed on the button but
                 ///< then moved outside without releasing the mouse button
         ButtonHovered = 0x04 ///< The mouse is currently over the button. If another button
                 ///< currently has state ButtonPressedMouseOutside only that button may get hovered.
     };
     Q_DECLARE_FLAGS( ButtonStates, ButtonState )
 
     /// Provides information about an additional button to be shown inside the StopLineEdit
     struct Button {
         ButtonType type;
         ButtonStates state;
         QRect rect;
         QIcon icon;
         QString toolTip;
 
         Button( ButtonType type, const QIcon &icon, const QRect &rect,
                 const QString &tooltip = QString() )
                 : type(type), state(ButtonNormal), rect(rect), icon(icon), toolTip(tooltip)
         {
         };
     };
 
     StopLineEditPrivate( const QString &serviceProvider, StopLineEdit *q )
             : importJob(0), q_ptr(q)
     {
         state = Ready;
         progress = 0;
 
         // Load data engine
         Plasma::PluginLoader::self()->loadDataEngine("publictransport");
 
         this->serviceProvider = serviceProvider;
     };
 
     ~StopLineEditPrivate()
     {
         Q_Q( StopLineEdit );
 		Plasma::DataEngineConsumer *consumer;
 
 #ifdef MARBLE_FOUND
         delete mapPopup;
 #endif
 
         // Disconnect sources to prevent warnings (No such slot QObject::dataUpdated...)
         Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
         if ( !sourceName.isEmpty() ) {
             engine->disconnectSource( sourceName, q );
             sourceName.clear();
         }
 
         if ( !serviceProvider.isEmpty() ) {
             engine->disconnectSource( "ServiceProvider " + serviceProvider, q );
         }
 
         consumer->~DataEngineConsumer();
     };
 
     /// Get the additional button at the given @p point. The index of the button gets stored in
     /// @p index, if it is not null.
     Button *buttonAt( const QPoint &point, int *index = 0 )
     {
         for ( int i = 0; i < buttons.count(); ++i ) {
             if ( buttons[i].rect.contains(point) ) {
                 if ( index ) {
                     *index = i;
                 }
                 return &buttons[i];
             }
         }
 
         if ( index ) {
             *index = -1;
         }
         return 0;
     };
 
     /// Get the additional button that is currently hovered or 0, if no button is hovered.
     /// The index of the button gets stored in @p index, if it is not null.
     Button *hoveredButton( int *index = 0 )
     {
         for ( int i = 0; i < buttons.count(); ++i ) {
             if ( buttons[i].state.testFlag(ButtonHovered) ) {
                 if ( index ) {
                     *index = i;
                 }
                 return &buttons[i];
             }
         }
 
         if ( index ) {
             *index = -1;
         }
         return 0;
     };
 
     /// Add the buttons set in @p newButtons.
     /// @note Before adding the buttons all previous buttons are removed.
     void addButtons( ButtonTypes newButtons )
     {
         // Buttons get placed into the StopLineEdit from right to left.
         // That means that the first button added to buttons, gets placed at the right.
         buttons.clear();
         if ( newButtons.testFlag(StopButton) ) {
             Button stopButton( StopButton, QIcon::fromTheme("media-playback-stop"), QRect(),
                     i18nc("@info:tooltip", "<title>Stop import</title>"
                           "<para>Click to cancel the currently running import of the GTFS feed. "
                           "You won't be able to use the service provider without completing the "
                           "import. The import can be started again later, but it will start at "
                           "the beginning.</para>") );
             buttons << stopButton;
         }
         if ( newButtons.testFlag(PauseButton) ) {
             Button pauseButton( PauseButton, QIcon::fromTheme("media-playback-pause"), QRect(),
                     i18nc("@info:tooltip", "<title>Pause/Continue import</title>"
                           "<para>Click to interrupt import. Click again to continue.</para>") );
             buttons << pauseButton;
         }
         if ( newButtons.testFlag(StartButton) ) {
             Button startButton( StartButton, QIcon::fromTheme("media-playback-start"), QRect(),
                     i18nc("@info:tooltip", "<title>Start GTFS feed import</title>"
                           "<para>Click here to download the GTFS feed and import it into the "
                           "database.</para>") );
             buttons << startButton;
         }
     };
 
     /// Called on resize to update the positions of the additional buttons.
     void updateButtonRects( const QRect &contentsRect )
     {
         const int buttonPadding = 4;
         const QSize buttonSize( 16, 16 );
         const int buttonTop = contentsRect.top() + (contentsRect.height() - buttonSize.height()) / 2;
         int lastButtonLeft = contentsRect.right();
         for ( int i = 0; i < buttons.count(); ++i ) {
             const QRect rect( QPoint(lastButtonLeft - buttonPadding - buttonSize.width(),
                                      buttonTop), buttonSize );
             buttons[i].rect = rect;
             lastButtonLeft = rect.left();
         }
     };
 
     /// Draws the additional buttons and returns the horizontal space used.
     int drawAdditionalButtons( QPainter *painter ) {
         int buttonsWidth = buttons.isEmpty() ? 0 : 4;
         foreach ( const StopLineEditPrivate::Button &button, buttons ) {
             painter->drawPixmap( button.state.testFlag(StopLineEditPrivate::ButtonPressed)
                                  ? button.rect.adjusted(1, 1, 1, 1) : button.rect,
                                  button.icon.pixmap(button.rect.size(),
                                  button.state.testFlag(StopLineEditPrivate::ButtonHovered)
                                  ? QIcon::Active : QIcon::Normal) );
             buttonsWidth += 4 + button.rect.width();
         }
         return buttonsWidth;
     };
 
     void connectStopsSource( const QString &stopName ) {
         Q_Q( StopLineEdit );
 		Plasma::DataEngineConsumer *consumer;
         Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
         if ( !sourceName.isEmpty() ) {
             engine->disconnectSource( sourceName, q );
         }
 
         state = StopLineEditPrivate::WaitingForStopSuggestions;
         sourceName = QString("Stops %1|stop=%2").arg( serviceProvider, stopName );
         if ( !city.isEmpty() ) { // m_useSeparateCityValue ) {
             sourceName += QString("|city=%3").arg( city );
         }
         engine->connectSource( sourceName, q );
     };
 
     // Get the index of the stop with the given @p stopName, -1 otherwise
     int stopIndexFromName( const QString &stopName ) {
         for ( int i = 0; i < stops.count(); ++i ) {
             const Stop &stop = stops[i];
             if ( stop.name.compare(stopName, Qt::CaseInsensitive) == 0 ) {
                 // Found a matching suggestion item return stop index
                 return i;
             }
         }
 
         // No matching suggestion found
         return -1;
     };
 
     // Require stop IDs when they are available,
     // ie. only use validated stop names with a corresponding ID
     bool requireStopId() const {
         return providerFeatures.contains( QLatin1String("ProvidesStopID") );
     };
 
     StopList stops;
     Stop selectedStop;
     QString city;
     QString serviceProvider;
     QString providerType;
     QStringList providerFeatures;
     State state;
     int progress; // Progress of the data engine in processing a task (0 .. 100)
     QString sourceName; // Source name used to request stop suggestions at the data engine
     QString errorString;
     QString question;
     QString questionToolTip;
     QString infoMessage;
     QList<Button> buttons;
     Plasma::ServiceJob *importJob; // A currently running import job or 0 if no import is running
 
 #ifdef MARBLE_FOUND
     PublicTransportMapWidget *mapPopup;
 #endif
 
 protected:
     StopLineEdit* const q_ptr;
 };
 Q_DECLARE_OPERATORS_FOR_FLAGS( StopLineEditPrivate::ButtonTypes )
 Q_DECLARE_OPERATORS_FOR_FLAGS( StopLineEditPrivate::ButtonStates )
 
 StopLineEdit::StopLineEdit( QWidget* parent, const QString &serviceProvider,
                             KCompletion::CompletionMode completion )
         : KLineEdit( parent ), d_ptr( new StopLineEditPrivate(serviceProvider, this) )
 {
 #ifdef MARBLE_FOUND
     Q_D( StopLineEdit );
     d->mapPopup = new PublicTransportMapWidget( serviceProvider,
                                                 PublicTransportMapWidget::DefaultFlags, this );
     connect( d->mapPopup, SIGNAL(stopClicked(Stop)), this, SLOT(stopClicked(Stop)) );
     PopupHandler *handler = PopupHandler::installPopup( d->mapPopup, this );
     connect( handler, SIGNAL(popupHidden()), this, SLOT(popupHidden()) );
 #endif
 
     setCompletionMode( completion );
     connect( this, SIGNAL(textEdited(QString)), this, SLOT(edited(QString)) );
     connect( this, SIGNAL(textChanged(QString)), this, SLOT(changed(QString)) );
 }
 
 StopLineEdit::~StopLineEdit()
 {
     delete d_ptr;
 }
 
 Stop StopLineEdit::selectedStop() const
 {
     Q_D( const StopLineEdit );
     return d->selectedStop;
 }
 
 void StopLineEdit::setSelectedStop( const Stop &stop )
 {
     Q_D( StopLineEdit );
     const int stopIndex = d->stopIndexFromName( stop.name );
     if ( stopIndex == -1 ) {
         // Stop unknown, store it
         d->stops << stop;
     }
     d->selectedStop = stop;
     setText( stop.name );
 }
 
 #ifdef MARBLE_FOUND
 void StopLineEdit::popupHidden()
 {
     setFocus( Qt::PopupFocusReason );
 }
 
 void StopLineEdit::stopClicked( const Stop &stop )
 {
     Q_D( StopLineEdit );
     d->selectedStop = stop;
     if ( stop.isValid() ) {
         setText( stop.name );
     }
 }
 #endif
 
 void StopLineEdit::setServiceProvider( const QString& serviceProvider )
 {
     Q_D( StopLineEdit );
 	Plasma::DataEngineConsumer *consumer;
     Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
     if ( !d->serviceProvider.isEmpty() ) {
         engine->disconnectSource( "ServiceProvider " + d->serviceProvider, this );
     }
     d->serviceProvider = serviceProvider;
     d->state = StopLineEditPrivate::Ready;
     if ( !d->sourceName.isEmpty() ) {
         engine->disconnectSource( d->sourceName, this );
     }
 
 #ifdef MARBLE_FOUND
     d->mapPopup->setServiceProvider( serviceProvider );
 #endif
 
     Plasma::DataContainer *container = engine->containerForSource( "ServiceProvider " + d->serviceProvider );
     const Plasma::DataEngine::Data providerData = container->data();
     d->providerType = providerData["type"].toString();
     d->providerFeatures = providerData["features"].toStringList();
     setEnabled( true );
     setClearButtonShown( true ); // Stays enabled and does not get drawn in KLineEdit::paintEvent
     setReadOnly( false );
     completionObject()->clear();
     edited( text() );
 
     // Check and watch the provider state
     if ( providerData["state"] == QLatin1String("gtfs_feed_import_pending") ) {
         askToImportGtfsFeed();
     }
     engine->connectSource( "ServiceProvider " + d->serviceProvider, this );
 }
 
 QString StopLineEdit::serviceProvider() const
 {
     Q_D( const StopLineEdit );
     return d->serviceProvider;
 }
 
 void StopLineEdit::setCity( const QString& city )
 {
     Q_D( StopLineEdit );
 	Plasma::DataEngineConsumer *consumer;
     d->city = city;
     d->state = StopLineEditPrivate::Ready;
     if ( !d->sourceName.isEmpty() ) {
         Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
         engine->disconnectSource( d->sourceName, this );
     }
     setEnabled( true );
     setClearButtonShown( true ); // Stays enabled and does not get drawn in KLineEdit::paintEvent
     setReadOnly( false );
     completionObject()->clear();
     edited( text() );
 }
 
 QString StopLineEdit::city() const
 {
     Q_D( const StopLineEdit );
     return d->city;
 }
 
 void StopLineEdit::importGtfsFeed()
 {
     Q_D( StopLineEdit );
 	Plasma::DataEngineConsumer *consumer;
     if ( d->providerType != QLatin1String("GTFS") ) {
         kWarning() << "Not a GTFS provider";
         return;
     }
 
     kDebug() << "GTFS accessor whithout imported feed data, use service to import using the GTFS feed";
     Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
     Plasma::Service *service = engine->serviceForSource("GTFS");
-    KConfigGroup op = service->operationDescription("importGtfsFeed");
-    op.writeEntry( "serviceProviderId", d->serviceProvider );
+    QVariantMap serviceMap = service->operationDescription("importGtfsFeed");
+    serviceMap.insert("serviceProviderId", d->serviceProvider);
 
     d->state = StopLineEditPrivate::WaitingForImport;
     d->addButtons( StopLineEditPrivate::StopButton | StopLineEditPrivate::PauseButton );
     d->updateButtonRects( contentsRect() );
     d->progress = 0;
     d->infoMessage.clear();
     setEnabled( true );
     setClearButtonShown( false ); // Stays enabled and does not get drawn in KLineEdit::paintEvent
     setReadOnly( true );
 
     // Update the progress bar
     update();
 
-    d->importJob = service->startOperationCall( op );
+    d->importJob = service->startOperationCall( serviceMap );
     connect( d->importJob, SIGNAL(finished(KJob*)), this, SLOT(importFinished(KJob*)) );
 }
 
 bool StopLineEdit::cancelImport()
 {
     Q_D( StopLineEdit );
     if ( d->importJob ) {
         return d->importJob->kill( KJob::EmitResult );
     }
     return false;
 }
 
 void StopLineEdit::changed( const QString &newText )
 {
     Q_D( StopLineEdit );
     if ( newText.isEmpty() ) {
         d->selectedStop.clear();
 #ifdef MARBLE_FOUND
         d->mapPopup->hide();
 #endif
     } else {
         const int stopIndex = d->stopIndexFromName( newText );
         if ( stopIndex == -1 ) {
             // No matching suggestion found
             if ( !d->requireStopId() ) {
                 // No stop ID required, just use the current input text as stop name
                 d->selectedStop = Stop( newText );
             }
         } else {
             // Found a matching suggestion
             d->selectedStop = d->stops[ stopIndex ];
         }
 
 #ifdef MARBLE_FOUND
         if ( d->mapPopup->isVisible() ) {
             d->mapPopup->publicTransportLayer()->setSelectedStop( newText );
         }
 
         if ( stopIndex == -1 ) {
             // The stop is not a suggestion for the line edit but was loaded
             // by the popup map, add data of that stop and use it's stop index
             const Stop stop = d->mapPopup->publicTransportLayer()->selectedStop();
             if ( stop.isValid() ) {
                 // Get stop data from the map
                 d->stops << stop;
                 d->selectedStop = stop;
             }
         }
 #endif
     }
 }
 
 void StopLineEdit::edited( const QString& newText )
 {
     Q_D( StopLineEdit );
 
     // Do not connect new sources, if the data engine indicated that it is currently processing
     // a task (ie. download a GTFS feed or import it into the database)
     if ( d->state == StopLineEditPrivate::WaitingForImport ) {
         return;
     }
 
     // Don't request new suggestions if newText is one of the suggestions, ie. most likely a
     // suggestion was selected. To allow choosing another suggestion with arrow keys the old
     // suggestions shouldn't be removed in this case and no update is needed.
     const int stopIndex = d->stopIndexFromName( newText );
     if ( stopIndex == -1 ) {
         // No matching suggestion found
         if ( !d->requireStopId() ) {
             // No stop ID required, just use the current input text as stop name
             d->selectedStop = Stop( newText );
         }
 
         // Request new suggestions
         d->connectStopsSource( newText );
     } else {
         // Found a matching suggestion, do not update suggestions
         d->selectedStop = d->stops[ stopIndex ];
     }
 }
 
 void StopLineEdit::paintEvent( QPaintEvent *ev )
 {
     Q_D( StopLineEdit );
 
     if ( !paintEngine() ) {
         kDebug() << "No paint engine";
         return;
     }
 
     if ( d->state == StopLineEditPrivate::WaitingForImport ) {
         // Draw a progress bar while waiting for the data engine to complete a task
         QPainter painter( this );
         int buttonsWidth = d->drawAdditionalButtons( &painter );
 
         QStyleOptionProgressBar option;
         option.initFrom( this );
         option.minimum = 0;
         option.maximum = 100;
         option.progress = d->progress;
         option.text = d->infoMessage.isEmpty()
                 ? i18nc("@info/plain", "Loading GTFS feed... %1 %", d->progress)
                 : QString("%1... %2 %").arg(d->infoMessage).arg(d->progress);
         option.textAlignment = Qt::AlignCenter;
         option.textVisible = true;
         option.rect.setWidth( option.rect.width() - buttonsWidth );
         style()->drawControl( QStyle::CE_ProgressBar, &option, &painter );
     } else if ( d->state == StopLineEditPrivate::Error || d->state == StopLineEditPrivate::Pause ) {
         const QColor errorColor = KColorScheme( QPalette::Normal, KColorScheme::View )
                 .foreground( KColorScheme::NegativeText ).color();
         QStyleOptionFrameV3 option;
         option.initFrom( this );
         option.frameShape = QFrame::StyledPanel;
         option.state = QStyle::State_Sunken;
         option.features = QStyleOptionFrameV2::None;
         option.lineWidth = 1;
         option.midLineWidth = 1;
         option.palette.setColor( QPalette::All, QPalette::Base,
                 KColorScheme(QPalette::Normal, KColorScheme::View).background(
                 KColorScheme::NegativeBackground).color()  );
 
         QPainter painter( this );
         style()->drawPrimitive( QStyle::PE_PanelLineEdit, &option, &painter, this );
         style()->drawPrimitive( QStyle::PE_FrameLineEdit, &option, &painter, this );
 
         int buttonsWidth = 0;
         QString errorText;
         if ( d->state == StopLineEditPrivate::Error ) {
             errorText = d->errorString.isEmpty()
                     ? i18nc("@info/plain", "Error loading the Service Provider") : d->errorString;
         } else { // Pause state
             errorText = i18nc("@info/plain", "Import paused");
             buttonsWidth = d->drawAdditionalButtons( &painter );
         }
         painter.setPen( errorColor );
         painter.drawText( contentsRect(), Qt::AlignCenter,
                           fontMetrics().elidedText(errorText, Qt::ElideMiddle,
                                                    option.rect.width() - buttonsWidth - 4) );
     } else if ( d->state == StopLineEditPrivate::AskingToImportGtfsFeed ) {
         const QColor infoColor = KColorScheme( QPalette::Normal, KColorScheme::View )
                 .foreground( KColorScheme::PositiveText ).color();
         QStyleOptionFrameV3 option;
         option.initFrom( this );
         option.frameShape = QFrame::StyledPanel;
         option.state = QStyle::State_Sunken;
         option.features = QStyleOptionFrameV2::None;
         option.lineWidth = 1;
         option.midLineWidth = 1;
         option.palette.setColor( QPalette::All, QPalette::Base,
                 KColorScheme(QPalette::Normal, KColorScheme::View).background(
                 KColorScheme::PositiveBackground).color()  );
 
         QPainter painter( this );
         style()->drawPrimitive( QStyle::PE_PanelLineEdit, &option, &painter, this );
         style()->drawPrimitive( QStyle::PE_FrameLineEdit, &option, &painter, this );
 
         int buttonsWidth = d->drawAdditionalButtons( &painter );
         QRect textRect = option.rect;
         textRect.setWidth( textRect.width() - buttonsWidth );
         painter.setPen( infoColor );
         painter.drawText( textRect, Qt::AlignCenter,
                 fontMetrics().elidedText(d->question, Qt::ElideMiddle, textRect.width() - 4) );
     } else {
         KLineEdit::paintEvent( ev );
     }
 }
 
 void StopLineEdit::resizeEvent( QResizeEvent *ev )
 {
     Q_D( StopLineEdit );
 
     KLineEdit::resizeEvent( ev );
     d->updateButtonRects( contentsRect() );
 }
 
 void StopLineEdit::mousePressEvent(QMouseEvent* ev)
 {
     Q_D( StopLineEdit );
 
     // Handle clicks on the import gtfs feed buttons (ok, cancel)
     if ( ev->button() == Qt::LeftButton ) {
         StopLineEditPrivate::Button *button = d->hoveredButton();
         if ( button ) {
             // Button pressed
             button->state |= StopLineEditPrivate::ButtonPressed;
             update( button->rect.adjusted(0, 0, 1, 1) );
             return;
         }
     }
 
     KLineEdit::mousePressEvent(ev);
 }
 
 void StopLineEdit::mouseReleaseEvent( QMouseEvent *ev )
 {
     Q_D( StopLineEdit );
 
     // Handle clicks on the import gtfs feed buttons (ok, cancel)
     if ( ev->button() == Qt::LeftButton ) {
         for ( int i = 0; i < d->buttons.count(); ++i ) {
             d->buttons[i].state &= ~StopLineEditPrivate::ButtonPressedMouseOutside;
         }
 
         StopLineEditPrivate::Button *button = d->hoveredButton();
         if ( button ) {
             button->state &= ~StopLineEditPrivate::ButtonPressed;
             if ( d->state == StopLineEditPrivate::AskingToImportGtfsFeed &&
                  button->type == StopLineEditPrivate::StartButton )
             {
                 // Start button released
                 d->state = StopLineEditPrivate::Ready;
                 if ( toolTip() == d->questionToolTip ) {
                     // Clear tooltip, if the question was still set as tooltip
                     setToolTip( QString() );
                 }
                 d->question.clear();
                 d->questionToolTip.clear();
 
                 // Start the import
                 importGtfsFeed();
                 return;
             } else if ( d->importJob && (d->state == StopLineEditPrivate::WaitingForImport ||
                         d->state == StopLineEditPrivate::Pause) &&
                         button->type == StopLineEditPrivate::StopButton )
             {
                 // Cancel button released, cancel the import
                 if ( !cancelImport() ) {
                     kWarning() << "Could not cancel the import job";
                     return;
                 }
                 d->question.clear();
                 d->questionToolTip.clear();
                 update();
                 return;
             } else if ( d->importJob && (d->state == StopLineEditPrivate::WaitingForImport ||
                         d->state == StopLineEditPrivate::Pause) &&
                         button->type == StopLineEditPrivate::PauseButton )
             {
                 // Pause button released in importing or pause state. In pause state the button
                 // is used as continue button.
                 if ( d->importJob->isSuspended() ) {
                     // Import job is currently suspended (pause button is a start button)
                     // Try to resume it again
                     if ( !d->importJob->resume() ) {
                         kDebug() << "Could not resume the import job";
                         return;
                     }
                     d->state = StopLineEditPrivate::WaitingForImport; // Back to importing state
                     button->icon = QIcon::fromTheme("media-playback-pause"); // Set icon back to pause
                     setToolTip( i18nc("@info:tooltip Tooltip for StopLineEdits, ie. shown in the "
                                       "stop settings dialog for stop name input. This tooltip is "
                                       "used, when the GTFS feed for the current service provider "
                                       "currently gets imported.",
                                       "Importing the GTFS feed for stop suggestions, %1%% done. "
                                       "Please wait.", d->progress) );
                 } else {
                     // Import job is not currently suspended, try to suspend it
                     if ( !d->importJob->suspend() ) {
                         kDebug() << "Could not suspend the import job";
                         return;
                     }
                     d->state = StopLineEditPrivate::Pause; // Set pause state
                     button->icon = QIcon::fromTheme("media-playback-start"); // Use start icon for continue
                     setToolTip( i18nc("@info:tooltip Tooltip for StopLineEdits, ie. shown in the "
                                       "stop settings dialog for stop name input. This tooltip is "
                                       "used, when a currently running GTFS feed import job is "
                                       "suspended.",
                                       "Importing the GTFS feed for stop suggestions, "
                                       "%1%% done (paused)", d->progress) );
                 }
 
                 update();
             }
         }
     }
 
     KLineEdit::mousePressEvent( ev );
 }
 
 void StopLineEdit::mouseMoveEvent( QMouseEvent *ev )
 {
     Q_D( StopLineEdit );
 
     // Handle clicks on the import gtfs feed buttons (ok, cancel)
     for ( int i = 0; i < d->buttons.count(); ++i ) {
         d->buttons[i].state &= ~StopLineEditPrivate::ButtonHovered;
 
         // Change all pressed button states to pressed (mouse outside)
         if ( d->buttons[i].state.testFlag(StopLineEditPrivate::ButtonPressed) ) {
             d->buttons[i].state &= ~StopLineEditPrivate::ButtonPressed;
             d->buttons[i].state |= StopLineEditPrivate::ButtonPressedMouseOutside;
             update( d->buttons[i].rect.adjusted(0, 0, 1, 1) );
         }
     }
 
     int index;
     StopLineEditPrivate::Button *button = d->buttonAt( ev->pos(), &index );
     if ( button ) {
         // Mouse moved over a button
         if ( !ev->buttons().testFlag(Qt::LeftButton) ) {
             // Remove pressed state
             button->state |= StopLineEditPrivate::ButtonHovered;
             button->state &= ~StopLineEditPrivate::ButtonPressedMouseOutside;
             button->state &= ~StopLineEditPrivate::ButtonPressed;
             update( button->rect.adjusted(0, 0, 1, 1) );
         } else if ( button->state.testFlag(StopLineEditPrivate::ButtonPressedMouseOutside) ) {
             // Change intermediate pressed state (mouse outside button) back to pressed state
             button->state |= StopLineEditPrivate::ButtonHovered;
             button->state &= ~StopLineEditPrivate::ButtonPressedMouseOutside;
             button->state |= StopLineEditPrivate::ButtonPressed;
             update( button->rect.adjusted(0, 0, 1, 1) );
         }
     } else {
         QLineEdit::mouseMoveEvent( ev );
     }
 }
 
 bool StopLineEdit::event( QEvent *ev )
 {
     Q_D( StopLineEdit );
 
     StopLineEditPrivate::Button *button = d->hoveredButton();
     switch ( ev->type() ) {
     case QEvent::ToolTip:
         if ( button ) {
             // Mouse is over a button
             setToolTip( button->toolTip );
         } else if ( d->providerType == QLatin1String("GTFS") && !d->questionToolTip.isEmpty() ) {
             // Reset tooltip to question
             setToolTip( d->questionToolTip );
         }
         break;
     default:
         break;
     }
 
     return KLineEdit::event( ev );
 }
 
 void StopLineEdit::importFinished( KJob *job )
 {
     Q_D( StopLineEdit );
     kDebug() << "Finished GTFS feed import" << job->errorString();
     d->importJob = 0;
     const bool hasError = job->error() < 0 && job->error() != -2; // -2 => Not a GTFS provider
     d->state = hasError ? StopLineEditPrivate::Error : StopLineEditPrivate::Ready;
     d->errorString = job->errorString(); // TODO needed?
     setToolTip( job->errorString() );
     setClearButtonShown( !hasError );
     setReadOnly( hasError );
 
     // TODO Re-request stop suggestions now?
 }
 
 void StopLineEdit::askToImportGtfsFeed()
 {
     Q_D( StopLineEdit );
 
     if ( d->state == StopLineEditPrivate::AskingToImportGtfsFeed ||
          d->providerType != QLatin1String("GTFS") )
     {
         // Is already asking or is not a GTFS provider
         return;
     }
 
     d->state = StopLineEditPrivate::AskingToImportGtfsFeed;
     // Add a button to start the import
     d->addButtons( StopLineEditPrivate::StartButton );
     d->updateButtonRects( contentsRect() );
     d->question = i18nc("@info/plain", "Start GTFS feed import?");
     d->questionToolTip = i18nc("@info:tooltip", "<title>Start GTFS feed import?</title>"
                       "<para>Click the start button to begin to import the timetable data, which may "
                       "take some minutes (depending on the size of the GTFS feed). <nl/>"
                       "The import can be suspended or cancelled at any time. <nl/>"
                       "After the import, updates are only done if the GTFS feed changes. "
                       "Realtime data gets retrieved using GTFS-realtime automatically if "
                       "supported, other than that GTFS data sources can be used offline.</para>");
     setToolTip( d->questionToolTip );
 
     // Do not show the clear button over the start button
     setClearButtonShown( false );
     setReadOnly( true );
 }
 
 void StopLineEdit::showGtfsFeedImportProgress()
 {
     Q_D( StopLineEdit );
 
     if ( d->state == StopLineEditPrivate::WaitingForImport ||
          d->providerType != QLatin1String("GTFS") )
     {
         // Is already showing import progress or is not a GTFS provider
         return;
     }
 
     d->state = StopLineEditPrivate::WaitingForImport;
     d->addButtons( StopLineEditPrivate::StopButton | StopLineEditPrivate::PauseButton );
     d->updateButtonRects( contentsRect() );
     setClearButtonShown( false ); // Stays enabled and does not get drawn in KLineEdit::paintEvent
     setReadOnly( true );
 }
 
 void StopLineEdit::dataUpdated( const QString& sourceName, const Plasma::DataEngine::Data& data )
 {
     Q_D( StopLineEdit );
 	Plasma::DataEngineConsumer *consumer;
 
     if ( sourceName == "ServiceProvider " + d->serviceProvider ) {
         // The service provider state has changed
         const QString state = data[ "state" ].toString();
         if ( state == QLatin1String("ready") ) {
             d->state = StopLineEditPrivate::Ready;
             setClearButtonShown( true );
             setReadOnly( false );
         } else {
             const QVariantHash stateData = data[ "stateData" ].toHash();
             if ( state == QLatin1String("gtfs_feed_import_pending") ) {
                 askToImportGtfsFeed();
             } else if ( state == QLatin1String("importing_gtfs_feed") ) {
                 showGtfsFeedImportProgress();
 
                 // Update the progress bar
                 d->progress = stateData["progress"].toInt();
                 d->infoMessage = stateData["statusMessage"].toString();
                 update();
             } else if ( state == QLatin1String("error") ||
                         data["error"].toBool() || state.isEmpty() )
             {
                 d->state = StopLineEditPrivate::Error;
                 d->errorString = data["errorMessage"].toString();
                 update();
             }
         }
         return;
     }
 
     if ( !sourceName.startsWith(QLatin1String("Stops")) || d->sourceName != sourceName ) {
         kDebug() << "Wrong (old) source" << sourceName;
         return;
     }
 
     kDebug() << "Updated Data For Source" << sourceName;
 
     // Check for a special error code ErrorNeedsImport
     if ( data["error"].toBool() && data["errorCode"].toInt() == 3 ) { // 3 -> ErrorNeedsImport
         askToImportGtfsFeed();
         return;
     }
 
     if ( !d->sourceName.isEmpty() ) {
         Plasma::DataEngine *engine = consumer->dataEngine("publictransport");
         engine->disconnectSource( d->sourceName, this );
         d->sourceName.clear();
     }
 
     if ( data.value("error").toBool() ) {
         kDebug() << "Stop suggestions error" << sourceName;
         d->state = StopLineEditPrivate::Error;
     } else if ( !data.contains("stops") ) {
         kDebug() << "Invalid stop suggestions data received" << sourceName;
         d->state = StopLineEditPrivate::Error;
     } else {
         d->state = StopLineEditPrivate::Ready;
     }
 
     setClearButtonShown( d->state != StopLineEditPrivate::Error );
     setReadOnly( d->state == StopLineEditPrivate::Error );
     if ( d->state == StopLineEditPrivate::Error ) {
         return;
     }
 
     // Delete old stops
     QList<Stop>::Iterator it = d->stops.begin();
     while ( it != d->stops.end() ) {
         if ( it->name.contains(text()) ) {
             ++it;
         } else {
             // The stop name does not contain the text in this StopLineEdit, remove it
             it = d->stops.erase( it );
         }
     }
 
     QStringList weightedStops;
     QHash<Stop, QVariant> stopToStopWeight;
     QVariantList stops = data["stops"].toList();
     foreach ( const QVariant &stopData, stops ) {
         QVariantHash stop = stopData.toHash();
         const QString stopName = stop["StopName"].toString();
         const QString stopID = stop["StopID"].toString();
         const int stopWeight = stop["StopWeight"].toInt();
         const bool coordsAvailable = stop.contains("StopLongitude") && stop.contains("StopLatitude");
         const qreal longitude = coordsAvailable ? stop["StopLongitude"].toReal() : 0;
         const qreal latitude = coordsAvailable? stop["StopLatitude"].toReal() : 0;
 
         const Stop stopItem( stopName, stopID, coordsAvailable, longitude, latitude );
         stopToStopWeight.insert( stopItem, stopWeight );
         d->stops << stopItem;
     }
     // Construct weighted stop list for KCompletion
     bool hasAtLeastOneWeight = false;
     foreach ( const Stop &stop, d->stops ) {
         int stopWeight = stopToStopWeight[ stop.name ].toInt();
         if ( stopWeight <= 0 ) {
             stopWeight = 0;
         } else {
             hasAtLeastOneWeight = true;
         }
 
         weightedStops << QString( "%1:%2" ).arg( stop.name ).arg( stopWeight );
     }
 
     if ( !text().isEmpty() && d->requireStopId() && d->selectedStop.id.isEmpty() ) {
         // Try to find the ID for the current stop name
         const int stopIndex = d->stopIndexFromName( text() );
         if ( stopIndex != -1 ) {
             d->selectedStop = d->stops[ stopIndex ];
         }
     }
 
     // Only add stop suggestions, if the line edit still has focus
     if ( hasFocus() ) {
         kDebug() << "Prepare completion object";
         KCompletion *comp = completionObject();
         comp->setIgnoreCase( true );
         comp->clear();
         if ( hasAtLeastOneWeight ) {
             comp->setOrder( KCompletion::Weighted );
             comp->insertItems( weightedStops );
         } else {
             comp->setOrder( KCompletion::Insertion );
             QStringList stopList;
             foreach ( const Stop &stop, d->stops ) {
                 stopList << stop.name;
             }
             comp->insertItems( stopList );
         }
 
         // Complete manually, because the completions are requested asynchronously.
         // Remove selected text for automatic completion modes, to still show other suggestions
         // when text gets autocompleted
         const bool autoCompletion = completionMode() == KGlobalSettings::CompletionAuto ||
                                     completionMode() == KGlobalSettings::CompletionPopupAuto;
         const QString input = (!autoCompletion || !hasSelectedText()) ? text()
                 : text().remove(selectionStart(), selectedText().length());
         doCompletion( input );
 
 #ifdef MARBLE_FOUND
         const QStringList activeStopNames = completionObject()->substringCompletion( input );
         d->mapPopup->setStops( d->stops, text(), activeStopNames );
         if ( !d->mapPopup->publicTransportLayer()->stops().isEmpty() ) {
             d->mapPopup->show();
         }
 #endif
     } else {
         kDebug() << "The stop line edit doesn't have focus, discard received stops.";
     }
 }
 
 StopLineEditList::StopLineEditList( QWidget* parent,
         AbstractDynamicWidgetContainer::RemoveButtonOptions removeButtonOptions,
         AbstractDynamicWidgetContainer::AddButtonOptions addButtonOptions,
         AbstractDynamicWidgetContainer::SeparatorOptions separatorOptions,
         AbstractDynamicWidgetContainer::NewWidgetPosition newWidgetPosition,
         const QString& labelText )
         : DynamicLabeledLineEditList( parent, removeButtonOptions, addButtonOptions,
                                       separatorOptions, newWidgetPosition, labelText )
 {
 
 }
 
 KLineEdit* StopLineEditList::createLineEdit()
 {
     return new StopLineEdit( this );
 }
 
 QList< Stop > StopLineEditList::selectedStops() const
 {
     QList< Stop > stops;
     foreach ( StopLineEdit *stopLineEdit, stopLineEditWidgets() ) {
         Q_ASSERT( stopLineEdit );
         stops << stopLineEdit->selectedStop();
     }
     return stops;
 }
 
 void StopLineEditList::setSelectedStops( const QList<Stop> &stops )
 {
     QList< StopLineEdit* > lineEdits = stopLineEditWidgets();
     while ( lineEdits.count() > qMax(minimumWidgetCount(), stops.count()) ) {
         // More line edits than stops to select, remove
         removeLastWidget();
     }
     for ( int i = 0; i < stops.count(); ++i ) {
         const Stop &stop = stops[i];
         if ( i < lineEdits.count() ) {
             lineEdits[i]->setSelectedStop( stop );
         } else {
             kDebug() << "Add a StopLineEdit" << stop.name << stop.id;
             StopLineEdit *lineEdit = qobject_cast< StopLineEdit* >( addLineEdit() );
             Q_ASSERT( lineEdit );
             lineEdit->setSelectedStop( stop );
         }
     }
 }
 
 QList< StopLineEdit* > StopLineEditList::stopLineEditWidgets() const
 {
     QList< StopLineEdit* > stopWidgets;
     foreach ( QWidget *widget, lineEditWidgets() ) {
         stopWidgets << qobject_cast< StopLineEdit* >( widget );
     }
     return stopWidgets;
 }
 
 void StopLineEditList::setCity(const QString& city)
 {
     foreach ( DynamicWidget *dynamicWidget, dynamicWidgets() ) {
         dynamicWidget->contentWidget<StopLineEdit*>()->setCity( city );
     }
 }
 
 void StopLineEditList::setServiceProvider(const QString& serviceProvider)
 {
     foreach ( DynamicWidget *dynamicWidget, dynamicWidgets() ) {
         dynamicWidget->contentWidget<StopLineEdit*>()->setServiceProvider( serviceProvider );
     }
 }
 
 } // namespace Timetable