diff --git a/engine/departureinfo.cpp b/engine/departureinfo.cpp
index 5fdccd7..674e9f8 100644
--- a/engine/departureinfo.cpp
+++ b/engine/departureinfo.cpp
@@ -1,369 +1,369 @@
 /*
  *   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 "departureinfo.h"
 
 // Own includes
 #include "global.h"
 
 // Qt includes
 #include <QDebug>
 
 PublicTransportInfo::PublicTransportInfo(QObject* parent): QObject(parent)
 {
 }
 
 PublicTransportInfo::~PublicTransportInfo()
 {
 }
 
 PublicTransportInfo::PublicTransportInfo( const QHash< Enums::TimetableInformation, QVariant >& data,
                                           Corrections corrections, QObject *parent )
     : QObject(parent), m_data(data)
 {
     m_isValid = false;
 
     // Insert -1 as Delay if none is given (-1 means "no delay information available")
     if ( !contains(Enums::Delay) ) {
         insert( Enums::Delay, -1 );
     }
 
     if ( corrections.testFlag(DeduceMissingValues) ) {
         // Guess date value if none is given,
         // this could produce wrong dates (better give DepartureDate in scripts)
         if ( !contains(Enums::DepartureDate) && contains(Enums::DepartureTime) ) {
             QTime departureTime = value( Enums::DepartureTime ).toTime();
             if ( departureTime < QTime::currentTime().addSecs(-5 * 60) ) {
                 qDebug() << "Guessed DepartureDate as tomorrow";
                 insert( Enums::DepartureDate, QDate::currentDate().addDays(1) );
             } else {
                 qDebug() << "Guessed DepartureDate as today";
                 insert( Enums::DepartureDate, QDate::currentDate() );
             }
         }
     }
 
     if ( corrections.testFlag(CombineToPreferredValueType) ) {
         // Convert date value from string if not given as date
         if ( !contains(Enums::DepartureDateTime) ) {
             if ( contains(Enums::DepartureTime) ) {
                 const QTime time = value( Enums::DepartureTime ).toTime();
                 QDate date;
                 if ( contains(Enums::DepartureDate) ) {
                     date = value( Enums::DepartureDate ).toDate();
                 } else if ( time < QTime::currentTime().addSecs(-5 * 60) ) {
                     qDebug() << "Guessed DepartureDate as tomorrow";
                     date = QDate::currentDate().addDays( 1 );
                 } else {
                     qDebug() << "Guessed DepartureDate as today";
                     date = QDate::currentDate();
                 }
                 insert( Enums::DepartureDateTime, QDateTime(date, time) );
                 remove( Enums::DepartureDate );
                 remove( Enums::DepartureTime );
             } else {
                 qDebug() << "No DepartureDateTime or DepartureTime information given";
             }
         }
     }
 
     if ( corrections.testFlag(TestValuesForCorrectFormat) ) {
         // Check RouteTimes values
         if ( contains(Enums::RouteTimes) ) {
             if ( value(Enums::RouteTimes).canConvert(QVariant::List) ) {
                 QVariantList vars = value( Enums::RouteTimes ).toList();
                 foreach ( const QVariant &var, vars ) {
                     // Convert from QVariant to QTime
                     if ( !var.canConvert(QVariant::DateTime) || !var.toDateTime().isValid() ) {
                         // Value for DepartureTime is not QDateTime
-                        kWarning() << "Invalid time in RouteTimes:" << var;
+                        qWarning() << "Invalid time in RouteTimes:" << var;
                         remove( Enums::RouteTimes );
                         break;
                     }
                 }
             } else {
                 // No list of values given for RouteTimes, remove the invalid value
-                kWarning() << "RouteTimes value is invalid (not a list of values): "
+                qWarning() << "RouteTimes value is invalid (not a list of values): "
                            << value(Enums::RouteTimes);
                 remove( Enums::RouteTimes );
             }
         }
     }
 }
 
 JourneyInfo::JourneyInfo( const TimetableData &data, Corrections corrections, QObject *parent )
         : PublicTransportInfo( data, corrections, parent )
 {
     if ( corrections.testFlag(DeduceMissingValues) ) {
         // Guess arrival date value if none is given,
         // this could produce wrong dates (better give ArrivalDate eg. in scripts)
         if ( !contains(Enums::ArrivalDateTime) &&
              !contains(Enums::ArrivalDate) && contains(Enums::ArrivalTime) )
         {
             QTime arrivalTime = value(Enums::ArrivalTime).toTime();
             if ( arrivalTime < QTime::currentTime().addSecs(-5 * 60) ) {
                 insert( Enums::ArrivalDate, QDate::currentDate().addDays(1) );
             } else {
                 insert( Enums::ArrivalDate, QDate::currentDate() );
             }
         }
 
         // Deduce Duration from DepartureDateTime and ArrivalDateTime
         if ( value(Enums::Duration).toInt() <= 0 && contains(Enums::DepartureDateTime) &&
              contains(Enums::ArrivalDateTime) )
         {
             QDateTime departure = value( Enums::DepartureDateTime ).toDateTime();
             QDateTime arrival = value( Enums::ArrivalDateTime ).toDateTime();
             int minsDuration = departure.secsTo( arrival ) / 60;
             if ( minsDuration < 0 ) {
-                kWarning() << "Calculated duration is negative" << minsDuration
+                qWarning() << "Calculated duration is negative" << minsDuration
                            << "departure" << departure << "arrival" << arrival;
                 insert( Enums::Duration, -1 );
             } else {
                 insert( Enums::Duration, minsDuration );
             }
         }
     }
 
 //     TODO Move to PublicTransportInfo? ...or is it already in there?
     if ( corrections.testFlag(TestValuesForCorrectFormat) ) {
         // Test departure time format
         if ( contains(Enums::DepartureTime) &&
              !value(Enums::DepartureTime).canConvert(QVariant::Time) )
         {
             // Value for DepartureTime is not QTime
-            kWarning() << "DepartureTime needs to be convertable to QTime:"
+            qWarning() << "DepartureTime needs to be convertable to QTime:"
                        << value(Enums::DepartureTime);
             remove( Enums::DepartureTime );
         }
 
         // Test departure date format
         if ( contains(Enums::DepartureDate) &&
              (!value(Enums::DepartureDate).canConvert(QVariant::Date) ||
               !value(Enums::DepartureDate).toDate().isValid()) )
         {
-            kWarning() << "DepartureDate needs to be convertable to QDate:"
+            qWarning() << "DepartureDate needs to be convertable to QDate:"
                        << value( Enums::DepartureDate );
             remove( Enums::DepartureDate );
         }
 
         // Check ArrivalDate value
         if ( contains(Enums::ArrivalDate) &&
              (!value(Enums::ArrivalDate).canConvert(QVariant::Date) ||
               !value(Enums::ArrivalDate).toDate().isValid()) )
         {
-            kWarning() << "ArrivalDate needs to be convertable to QDate:"
+            qWarning() << "ArrivalDate needs to be convertable to QDate:"
                        << value(Enums::ArrivalDate);
             remove( Enums::ArrivalDate );
         }
 
         // Check Duration value
         if ( contains(Enums::Duration) && value(Enums::Duration).toInt() <= 0 &&
              value(Enums::Duration).canConvert(QVariant::String) )
         {
-            kWarning() << "Duration needs to be convertable to int:" << value(Enums::Duration);
+            qWarning() << "Duration needs to be convertable to int:" << value(Enums::Duration);
             remove( Enums::Duration );
         }
 
         // Check RouteTimesDeparture values
         if ( contains(Enums::RouteTimesDeparture) ) {
             if ( !value(Enums::RouteTimesDeparture).canConvert(QVariant::List) ) {
-                kWarning() << "Value for RouteTimesDeparture needs to be a list"
+                qWarning() << "Value for RouteTimesDeparture needs to be a list"
                            << value(Enums::RouteTimesDeparture);
                 remove( Enums::RouteTimesDeparture );
             } else {
                 QVariantList vars = value( Enums::RouteTimesDeparture ).toList();
                 foreach( const QVariant &var, vars ) {
                     if ( !var.canConvert(QVariant::DateTime) ) {
-                        kWarning() << "Invalid time in RouteTimesDeparture" << var;
+                        qWarning() << "Invalid time in RouteTimesDeparture" << var;
                         remove( Enums::RouteTimesDeparture );
                         break;
                     }
                 }
             }
         }
 
         // Check RouteTimesArrival values
         if ( contains(Enums::RouteTimesArrival) ) {
             if ( !value(Enums::RouteTimesArrival).canConvert(QVariant::List) ) {
-                kWarning() << "Value for RouteTimesArrival needs to be a list"
+                qWarning() << "Value for RouteTimesArrival needs to be a list"
                            << value(Enums::RouteTimesArrival);
                 remove( Enums::RouteTimesArrival );
             } else {
                 QVariantList vars = value( Enums::RouteTimesArrival ).toList();
                 foreach( const QVariant &var, vars ) {
                     if ( !var.canConvert(QVariant::DateTime) ) {
-                        kWarning() << "Invalid time in RouteTimesArrival" << var;
+                        qWarning() << "Invalid time in RouteTimesArrival" << var;
                         remove( Enums::RouteTimesArrival );
                         break;
                     }
                 }
             }
         }
     }
 
     if ( corrections.testFlag(CombineToPreferredValueType) ) {
         // If the duration value is invalid, but there are departure and arrival date and time
         // values available, calculate the duration between departure and arrival
         if ( value(Enums::Duration).toInt() <= 0 && contains(Enums::DepartureDate) &&
              contains(Enums::DepartureTime) && contains(Enums::ArrivalDate) &&
              contains(Enums::ArrivalTime) )
         {
             QDateTime departure( value(Enums::DepartureDate).toDate(), value(Enums::ArrivalTime).toTime() );
             QDateTime arrival( value(Enums::ArrivalDate).toDate(), value(Enums::ArrivalTime).toTime() );
             int minsDuration = departure.secsTo( arrival ) / 60;
             if ( minsDuration < 0 ) {
                 qDebug() << "Calculated duration is negative" << minsDuration
                         << "departure" << departure << "arrival" << arrival;
                 insert( Enums::Duration, -1 );
             } else {
                 insert( Enums::Duration, minsDuration );
             }
         }
 
         // Combine ArrivalTime and ArrivalDate to ArrivalDateTime
         if ( !contains(Enums::ArrivalDateTime) ) {
             if ( contains(Enums::ArrivalTime) ) {
                 const QTime time = value( Enums::ArrivalTime ).toTime();
                 QDate date;
                 if ( contains(Enums::ArrivalDate) ) {
                     date = value( Enums::ArrivalDate ).toDate();
                 } else if ( time < QTime::currentTime().addSecs(-5 * 60) ) {
                     qDebug() << "Guessed ArrivalDate as tomorrow";
                     date = QDate::currentDate().addDays( 1 );
                 } else {
                     qDebug() << "Guessed ArrivalDate as today";
                     date = QDate::currentDate();
                 }
                 insert( Enums::ArrivalDateTime, QDateTime(date, time) );
                 remove( Enums::ArrivalDate );
                 remove( Enums::ArrivalTime );
             } else {
-                kWarning() << "No ArrivalDateTime or ArrivalTime information given";
+                qWarning() << "No ArrivalDateTime or ArrivalTime information given";
             }
         }
     }
 
     m_isValid = contains(Enums::DepartureDateTime) && contains(Enums::ArrivalDateTime) &&
                 contains(Enums::StartStopName) && contains(Enums::TargetStopName);
 }
 
 StopInfo::StopInfo( QObject *parent ) : PublicTransportInfo(parent)
 {
     m_isValid = false;
 }
 
 StopInfo::StopInfo( const QHash< Enums::TimetableInformation, QVariant >& data, QObject *parent )
     : PublicTransportInfo(parent)
 {
     m_data.unite( data );
     m_isValid = contains( Enums::StopName );
 }
 
 StopInfo::StopInfo( const QString &name, const QString& id, int weight,
                     qreal longitude, qreal latitude, const QString &city,
                     const QString &countryCode, QObject *parent ) : PublicTransportInfo(parent)
 {
     insert( Enums::StopName, name );
     if ( !id.isNull() ) {
         insert( Enums::StopID, id );
     }
     if ( longitude != 0.0 ) {
         insert( Enums::StopLongitude, longitude );
     }
     if ( latitude != 0.0 ) {
         insert( Enums::StopLatitude, latitude );
     }
     if ( !city.isNull() ) {
         insert( Enums::StopCity, city );
     }
     if ( !countryCode.isNull() ) {
         insert( Enums::StopCountryCode, countryCode );
     }
     if ( weight != -1 ) {
         insert( Enums::StopWeight, weight );
     }
 
     m_isValid = !name.isEmpty();
 }
 
 DepartureInfo::DepartureInfo( QObject *parent ) : PublicTransportInfo(parent)
 {
     m_isValid = false;
 }
 
 DepartureInfo::DepartureInfo( const TimetableData &data, Corrections corrections, QObject *parent )
         : PublicTransportInfo( data, corrections, parent )
 {
     if ( (contains(Enums::RouteStops) || contains(Enums::RouteTimes)) &&
          value(Enums::RouteTimes).toList().count() != value(Enums::RouteStops).toStringList().count() )
     {
         int difference = value(Enums::RouteStops).toList().count() -
                          value(Enums::RouteTimes).toList().count();
         if ( difference > 0 ) {
             // More route stops than times, add invalid times
             qDebug() << "The script stored" << difference << "more route stops than route times "
                         "for a departure, invalid route times will be added";
             QVariantList routeTimes = value( Enums::RouteTimes ).toList();
             while ( difference > 0 ) {
                 routeTimes << QDateTime();
                 --difference;
             }
         } else {
             // More route times than stops, add empty stops
             qDebug() << "The script stored" << -difference << "more route times than route "
                         "stops for a departure, empty route stops will be added";
             QStringList routeStops = value( Enums::RouteStops ).toStringList();
             while ( difference < 0 ) {
                 routeStops << QString();
                 ++difference;
             }
         }
     }
 
     m_isValid = contains( Enums::TransportLine ) && contains( Enums::Target ) &&
                 contains( Enums::DepartureDateTime );
 }
 
 QStringList JourneyInfo::vehicleIconNames() const
 {
     if ( !contains(Enums::TypesOfVehicleInJourney) ) {
         return QStringList();
     }
     QVariantList vehicles = value( Enums::TypesOfVehicleInJourney ).toList();
     QStringList iconNames;
     foreach( QVariant vehicle, vehicles ) {
         iconNames << Global::vehicleTypeToIcon( static_cast<Enums::VehicleType>( vehicle.toInt() ) );
     }
     return iconNames;
 }
 
 QStringList JourneyInfo::vehicleNames( bool plural ) const
 {
     if ( !contains( Enums::TypesOfVehicleInJourney ) ) {
         return QStringList();
     }
     QVariantList vehicles = value( Enums::TypesOfVehicleInJourney ).toList();
     QStringList names;
     foreach( QVariant vehicle, vehicles ) {
         names << Global::vehicleTypeToString( static_cast<Enums::VehicleType>( vehicle.toInt() ), plural );
     }
     return names;
 }
diff --git a/engine/global.cpp b/engine/global.cpp
index c098048..00ab5f3 100644
--- a/engine/global.cpp
+++ b/engine/global.cpp
@@ -1,439 +1,439 @@
 /*
 *   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 "global.h"
 
 // KDE includes
 #include <KLocalizedString>
 
 // Qt includes
 #include <QRegExp>
 #include <QDebug>
 #include <QTextCodec>
 
 Enums::VehicleType Global::vehicleTypeFromString( QString sVehicleType )
 {
     return Enums::stringToVehicleType( sVehicleType.toAscii().data() );
 }
 
 QString Global::vehicleTypeToString( const Enums::VehicleType& vehicleType, bool plural )
 {
     switch ( vehicleType ) {
     case Enums::Tram:
         return plural ? i18nc( "@info/plain", "trams" )
                : i18nc( "@info/plain", "tram" );
     case Enums::Bus:
         return plural ? i18nc( "@info/plain", "buses" )
                : i18nc( "@info/plain", "bus" );
     case Enums::Subway:
         return plural ? i18nc( "@info/plain", "subways" )
                : i18nc( "@info/plain", "subway" );
     case Enums::InterurbanTrain:
         return plural ? i18nc( "@info/plain", "interurban trains" )
                : i18nc( "@info/plain", "interurban train" );
     case Enums::Metro:
         return plural ? i18nc( "@info/plain", "metros" )
                : i18nc( "@info/plain", "metro" );
     case Enums::TrolleyBus:
         return plural ? i18nc( "@info/plain", "trolley buses" )
                : i18nc( "@info/plain", "trolley bus" );
 
     case Enums::RegionalTrain:
         return plural ? i18nc( "@info/plain", "regional trains" )
                : i18nc( "@info/plain", "regional train" );
     case Enums::RegionalExpressTrain:
         return plural ? i18nc( "@info/plain", "regional express trains" )
                : i18nc( "@info/plain", "regional express train" );
     case Enums::InterregionalTrain:
         return plural ? i18nc( "@info/plain", "interregional trains" )
                : i18nc( "@info/plain", "interregional train" );
     case Enums::IntercityTrain:
         return plural ? i18nc( "@info/plain", "intercity / eurocity trains" )
                : i18nc( "@info/plain", "intercity / eurocity train" );
     case Enums::HighSpeedTrain:
         return plural ? i18nc( "@info/plain", "intercity express trains" )
                : i18nc( "@info/plain", "intercity express train" );
 
     case Enums::Feet:
         return i18nc( "@info/plain", "Footway" );
 
     case Enums::Ferry:
         return plural ? i18nc( "@info/plain", "ferries" )
                : i18nc( "@info/plain", "ferry" );
     case Enums::Ship:
         return plural ? i18nc( "@info/plain", "ships" )
                : i18nc( "@info/plain", "ship" );
     case Enums::Plane:
         return plural ? i18nc( "@info/plain airplanes", "planes" )
                : i18nc( "@info/plain an airplane", "plane" );
 
     case Enums::UnknownVehicleType:
     default:
         return i18nc( "@info/plain Unknown type of vehicle", "Unknown" );
     }
 }
 
 QString Global::vehicleTypeToIcon( const Enums::VehicleType& vehicleType )
 {
     switch ( vehicleType ) {
     case Enums::Tram:
         return "vehicle_type_tram";
     case Enums::Bus:
         return "vehicle_type_bus";
     case Enums::Subway:
         return "vehicle_type_subway";
     case Enums::Metro:
         return "vehicle_type_metro";
     case Enums::TrolleyBus:
         return "vehicle_type_trolleybus";
     case Enums::Feet:
         return "vehicle_type_feet";
     case Enums::InterurbanTrain:
         return "vehicle_type_train_interurban";
     case Enums::RegionalTrain: // aIcon not done yet, using this for now
     case Enums::RegionalExpressTrain:
         return "vehicle_type_train_regional";
     case Enums::InterregionalTrain:
         return "vehicle_type_train_interregional";
     case Enums::IntercityTrain:
         return "vehicle_type_train_intercity";
     case Enums::HighSpeedTrain:
         return "vehicle_type_train_highspeed";
 
     case Enums::Ferry:
     case Enums::Ship:
         return "vehicle_type_ferry";
     case Enums::Plane:
         return "vehicle_type_plane";
 
     case Enums::UnknownVehicleType:
     default:
         return "status_unknown";
     }
 }
 
 Enums::TimetableInformation Global::timetableInformationFromString(
         const QString& sTimetableInformation )
 {
     const QString sInfo = sTimetableInformation.toLower();
     if ( sInfo == QLatin1String("nothing") ) {
         return Enums::Nothing;
     } else if ( sInfo == QLatin1String("departuredatetime") ) {
         return Enums::DepartureDateTime;
     } else if ( sInfo == QLatin1String("departuredate") ) {
         return Enums::DepartureDate;
     } else if ( sInfo == QLatin1String("departuretime") ) {
         return Enums::DepartureTime;
     } else if ( sInfo == QLatin1String("typeofvehicle") ) {
         return Enums::TypeOfVehicle;
     } else if ( sInfo == QLatin1String("transportline") ) {
         return Enums::TransportLine;
     } else if ( sInfo == QLatin1String("flightnumber") ) {
         return Enums::FlightNumber;
     } else if ( sInfo == QLatin1String("target") ) {
         return Enums::Target;
     } else if ( sInfo == QLatin1String("targetshortened") ) {
         return Enums::TargetShortened;
     } else if ( sInfo == QLatin1String("platform") ) {
         return Enums::Platform;
     } else if ( sInfo == QLatin1String("delay") ) {
         return Enums::Delay;
     } else if ( sInfo == QLatin1String("delayreason") ) {
         return Enums::DelayReason;
     } else if ( sInfo == QLatin1String("journeynews") ) {
         return Enums::JourneyNews;
     } else if ( sInfo == QLatin1String("journeynewsother") ) { // DEPRECATED
-        kWarning() << "JourneyNewsOther is deprecated, use JourneyNews instead";
+        qWarning() << "JourneyNewsOther is deprecated, use JourneyNews instead";
         return Enums::JourneyNewsOther;
     } else if ( sInfo == QLatin1String("journeynewslink") ) { // DEPRECATED
-        kWarning() << "JourneyNewsLink is deprecated, use JourneyNewsUrl instead";
+        qWarning() << "JourneyNewsLink is deprecated, use JourneyNewsUrl instead";
         return Enums::JourneyNewsUrl;
     } else if ( sInfo == QLatin1String("journeynewsurl") ) {
         return Enums::JourneyNewsUrl;
     } else if ( sInfo == QLatin1String("status") ) {
         return Enums::Status;
     } else if ( sInfo == QLatin1String("routestops") ) {
         return Enums::RouteStops;
     } else if ( sInfo == QLatin1String("routestopsshortened") ) {
         return Enums::RouteStopsShortened;
     } else if ( sInfo == QLatin1String("routetimes") ) {
         return Enums::RouteTimes;
     } else if ( sInfo == QLatin1String("routetimesdeparture") ) {
         return Enums::RouteTimesDeparture;
     } else if ( sInfo == QLatin1String("routetimesarrival") ) {
         return Enums::RouteTimesArrival;
     } else if ( sInfo == QLatin1String("routeexactstops") ) {
         return Enums::RouteExactStops;
     } else if ( sInfo == QLatin1String("routetypesofvehicles") ) {
         return Enums::RouteTypesOfVehicles;
     } else if ( sInfo == QLatin1String("routetransportlines") ) {
         return Enums::RouteTransportLines;
     } else if ( sInfo == QLatin1String("routeplatformsdeparture") ) {
         return Enums::RoutePlatformsDeparture;
     } else if ( sInfo == QLatin1String("routeplatformsarrival") ) {
         return Enums::RoutePlatformsArrival;
     } else if ( sInfo == QLatin1String("routetimesdeparturedelay") ) {
         return Enums::RouteTimesDepartureDelay;
     } else if ( sInfo == QLatin1String("routetimesarrivaldelay") ) {
         return Enums::RouteTimesArrivalDelay;
     } else if ( sInfo == QLatin1String("routenews") ) {
         return Enums::RouteNews;
     } else if ( sInfo == QLatin1String("routesubjourneys") ) {
         return Enums::RouteSubJourneys;
     } else if ( sInfo == QLatin1String("routedataurl") ) {
         return Enums::RouteDataUrl;
     } else if ( sInfo == QLatin1String("operator") ) {
         return Enums::Operator;
     } else if ( sInfo == QLatin1String("duration") ) {
         return Enums::Duration;
     } else if ( sInfo == QLatin1String("startstopname") ) {
         return Enums::StartStopName;
     } else if ( sInfo == QLatin1String("startstopid") ) {
         return Enums::StartStopID;
     } else if ( sInfo == QLatin1String("targetstopname") ) {
         return Enums::TargetStopName;
     } else if ( sInfo == QLatin1String("targetstopid") ) {
         return Enums::TargetStopID;
     } else if ( sInfo == QLatin1String("arrivaldatetime") ) {
         return Enums::ArrivalDateTime;
     } else if ( sInfo == QLatin1String("arrivaldate") ) {
         return Enums::ArrivalDate;
     } else if ( sInfo == QLatin1String("arrivaltime") ) {
         return Enums::ArrivalTime;
     } else if ( sInfo == QLatin1String("changes") ) {
         return Enums::Changes;
     } else if ( sInfo == QLatin1String("typesofvehicleinjourney") ) {
         return Enums::TypesOfVehicleInJourney;
     } else if ( sInfo == QLatin1String("pricing") ) {
         return Enums::Pricing;
     } else if ( sInfo == QLatin1String("isnightline") ) {
         return Enums::IsNightLine;
     } else if ( sInfo == QLatin1String("stopname") ) {
         return Enums::StopName;
     } else if ( sInfo == QLatin1String("stopid") ) {
         return Enums::StopID;
     } else if ( sInfo == QLatin1String("stopweight") ) {
         return Enums::StopWeight;
     } else if ( sInfo == QLatin1String("stopcity") ) {
         return Enums::StopCity;
     } else if ( sInfo == QLatin1String("stopcountrycode") ) {
         return Enums::StopCountryCode;
     } else if ( sInfo == QLatin1String("stoplongitude") ) {
         return Enums::StopLongitude;
     } else if ( sInfo == QLatin1String("stoplatitude") ) {
         return Enums::StopLatitude;
     } else if ( sInfo == QLatin1String("requestdata") ) {
         return Enums::RequestData;
     } else {
         qDebug() << sTimetableInformation
                  << "is an unknown timetable information value! Assuming value Nothing.";
         return Enums::Nothing;
     }
 }
 
 QString Global::timetableInformationToString( Enums::TimetableInformation timetableInformation )
 {
     return Enums::toString( timetableInformation );
 }
 
 bool Global::checkTimetableInformation( Enums::TimetableInformation info, const QVariant &value )
 {
     if ( !value.isValid() ) {
         return false;
     }
 
     switch ( info ) {
     case Enums::DepartureDateTime:
     case Enums::ArrivalDateTime:
         return value.toDateTime().isValid();
     case Enums::DepartureDate:
     case Enums::ArrivalDate:
         return value.toDate().isValid();
     case Enums::DepartureTime:
     case Enums::ArrivalTime:
         return value.toTime().isValid();
     case Enums::TypeOfVehicle:
         return vehicleTypeFromString( value.toString() ) != Enums::UnknownVehicleType;
     case Enums::TransportLine:
     case Enums::Target:
     case Enums::TargetShortened:
     case Enums::Platform:
     case Enums::DelayReason:
     case Enums::JourneyNews:
     case Enums::JourneyNewsOther: // DEPRECATED
     case Enums::JourneyNewsUrl:
     case Enums::Operator:
     case Enums::Status:
     case Enums::StartStopName:
     case Enums::StartStopID:
     case Enums::StopCity:
     case Enums::StopCountryCode:
     case Enums::TargetStopName:
     case Enums::TargetStopID:
     case Enums::Pricing:
     case Enums::StopName:
     case Enums::StopID:
     case Enums::RouteDataUrl:
         return !value.toString().trimmed().isEmpty();
     case Enums::StopLongitude:
     case Enums::StopLatitude:
         if ( !value.canConvert(QVariant::Double) ) {
             return false;
         } else {
             bool ok;
             (void) value.toReal( &ok );
             return ok;
         }
     case Enums::Delay:
         return value.canConvert( QVariant::Int ) && value.toInt() >= -1;
     case Enums::Duration:
     case Enums::StopWeight:
     case Enums::Changes:
     case Enums::RouteExactStops:
         return value.canConvert( QVariant::Int ) && value.toInt() >= 0;
     case Enums::TypesOfVehicleInJourney:
     case Enums::RouteTimes:
     case Enums::RouteTimesDeparture:
     case Enums::RouteTimesArrival:
     case Enums::RouteTypesOfVehicles:
     case Enums::RouteTimesDepartureDelay:
     case Enums::RouteTimesArrivalDelay:
     case Enums::RouteSubJourneys:
         return !value.toList().isEmpty();
     case Enums::IsNightLine:
         return value.canConvert( QVariant::Bool );
     case Enums::RouteStops:
     case Enums::RouteStopsShortened:
     case Enums::RouteTransportLines:
     case Enums::RoutePlatformsDeparture:
     case Enums::RoutePlatformsArrival:
     case Enums::RouteNews:
         return !value.toStringList().isEmpty();
 
     case Enums::RequestData:
     default:
         return true;
     }
 }
 
 QString Global::decodeHtmlEntities( const QString& html )
 {
     if ( html.isEmpty() ) {
         return html;
     }
 
     QString ret = html;
     QRegExp rx( "(?:&#)([0-9]+)(?:;)" );
     rx.setMinimal( true );
     int pos = 0;
     while ( (pos = rx.indexIn(ret, pos)) != -1 ) {
         const int charCode = rx.cap( 1 ).toInt();
         ret.replace( QString("&#%1;").arg(charCode), QChar(charCode) );
     }
 
     return ret.replace( QLatin1String("&nbsp;"), QLatin1String(" ") )
               .replace( QLatin1String("&amp;"), QLatin1String("&") )
               .replace( QLatin1String("&lt;"), QLatin1String("<") )
               .replace( QLatin1String("&gt;"), QLatin1String(">") )
               .replace( QLatin1String("&szlig;"), QLatin1String("ß") )
               .replace( QLatin1String("&auml;"), QLatin1String("ä") )
               .replace( QLatin1String("&Auml;"), QLatin1String("Ä") )
               .replace( QLatin1String("&ouml;"), QLatin1String("ö") )
               .replace( QLatin1String("&Ouml;"), QLatin1String("Ö") )
               .replace( QLatin1String("&uuml;"), QLatin1String("ü") )
               .replace( QLatin1String("&Uuml;"), QLatin1String("Ü") );
 }
 
 QString Global::encodeHtmlEntities( const QString &html, HtmlEntityEncodeFlags flags )
 {
     if ( html.isEmpty() ) {
         return html;
     }
 
     QString ret = html;
     if ( flags.testFlag(EncodeLessThan) ) {
         ret.replace( QLatin1String("<"), QLatin1String("&lt;") );
     }
     if ( flags.testFlag(EncodeGreaterThan) ) {
         ret.replace( QLatin1String(">"), QLatin1String("&gt;") );
     }
     if ( flags.testFlag(EncodeAmpersand) ) {
         ret.replace( QLatin1String("&"), QLatin1String("&amp;") );
     }
     if ( flags.testFlag(EncodeUmlauts) ) {
         ret.replace( QLatin1String("ß"), QLatin1String("&szlig;") )
            .replace( QLatin1String("ä"), QLatin1String("&auml;") )
            .replace( QLatin1String("Ä"), QLatin1String("&Auml;") )
            .replace( QLatin1String("ö"), QLatin1String("&ouml;") )
            .replace( QLatin1String("Ö"), QLatin1String("&Ouml;") )
            .replace( QLatin1String("ü"), QLatin1String("&uuml;") )
            .replace( QLatin1String("Ü"), QLatin1String("&Uuml;") );
     }
     if ( flags.testFlag(EncodeSpace) ) {
         ret.replace( QLatin1String(" "), QLatin1String("&nbsp;") );
     }
     return ret;
 }
 
 QString Global::decodeHtml( const QByteArray& document, const QByteArray& fallbackCharset )
 {
     // Get charset of the received document and convert it to a unicode QString
     // First parse the charset with a regexp to get a fallback charset
     // if QTextCodec::codecForHtml doesn't find the charset
     QTextCodec *textCodec = QTextCodec::codecForHtml( document, 0 );
     if ( textCodec ) {
         return textCodec->toUnicode( document );
     } else {
         if ( !fallbackCharset.isEmpty() ) {
             textCodec = QTextCodec::codecForName( fallbackCharset );
             if ( !textCodec ) {
                 qDebug() << "Fallback charset" << fallbackCharset << "not found! Using utf8 now.";
                 textCodec = QTextCodec::codecForName( "UTF-8" );
             }
         } else {
             QString sDocument = QString( document );
             QRegExp rxCharset( "(?:<head>.*<meta http-equiv=\"Content-Type\" "
                     "content=\"text/html; charset=)([^\"]*)(?:\"[^>]*>)", Qt::CaseInsensitive );
             rxCharset.setMinimal( true );
             if ( rxCharset.indexIn(sDocument) != -1 ) {
                 textCodec = QTextCodec::codecForName( rxCharset.cap(1).trimmed().toUtf8() );
             } else {
                 qDebug() << "No fallback charset specified and manual codec search failed, using utf8";
                 textCodec = QTextCodec::codecForName( "UTF-8" );
             }
         }
         return textCodec ? textCodec->toUnicode(document) : QString::fromUtf8(document);
     }
 }
 
 QString Global::decode( const QByteArray &document, const QByteArray &charset )
 {
     if ( !charset.isEmpty() ) {
         QTextCodec *textCodec = QTextCodec::codecForName( charset );
         if ( !textCodec ) {
             qDebug() << "Charset" << charset << "not found! Using utf8 now.";
             textCodec = QTextCodec::codecForName( "UTF-8" );
         }
 
         return textCodec->toUnicode( document );
     } else {
         return QString::fromUtf8( document );
     }
 }
diff --git a/engine/gtfs/gtfsimporter.cpp b/engine/gtfs/gtfsimporter.cpp
index 338bdc1..eacb4a1 100644
--- a/engine/gtfs/gtfsimporter.cpp
+++ b/engine/gtfs/gtfsimporter.cpp
@@ -1,790 +1,790 @@
 /*
  *   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.
  */
 
 #include "gtfsimporter.h"
 #include "gtfsdatabase.h"
 #include "serviceproviderdatareader.h"
 #include "serviceproviderdata.h"
 
 #include <KZip>
 #include <KStandardDirs>
 #include <KDebug>
 #include <KLocalizedString>
 
 #include <QDir>
 #include <QVariant>
 #include <QSqlDatabase>
 #include <QSqlQuery>
 #include <QSqlError>
 #include <QSqlRecord>
 #include <QSqlDriver>
 
 GtfsImporter::GtfsImporter( const QString &providerName )
         : m_state(Initializing), m_providerName(providerName), m_quit(false)
 {
     // Register state enum to be able to use it in queued connections
     qRegisterMetaType< GtfsImporter::State >( "GtfsImporter::State" );
 
     QMutexLocker locker( &m_mutex );
 
     // Delete already existing database, if any, to prevent failure due to a corrupted database
     const QString databasePath = GtfsDatabase::databasePath( m_providerName );
     if ( QFile::exists(databasePath) ) {
         // Remove the database file and the connection to it
         GtfsDatabase::closeDatabase( m_providerName );
         if ( !QFile::remove(databasePath) ) {
-            kWarning() << "Already existing GTFS database for" << m_providerName
+            qWarning() << "Already existing GTFS database for" << m_providerName
                        << "could not be removed" << databasePath;
         }
     }
 
     if ( !GtfsDatabase::initDatabase(providerName, &m_errorString) ) {
         m_state = FatalError;
         kDebug() << m_errorString;
     } else {
         m_state = Initialized;
     }
 }
 
 GtfsImporter::~GtfsImporter()
 {
     QMutexLocker locker( &m_mutex );
     m_quit = true;
 }
 
 void GtfsImporter::quit()
 {
     QMutexLocker locker( &m_mutex );
     if ( m_state == Importing ) {
         kDebug() << "Quits at next checkpoint";
     }
     m_quit = true;
 }
 
 void GtfsImporter::suspend()
 {
     QMutexLocker locker( &m_mutex );
     if ( m_state == Importing ) {
         m_state = ImportingSuspended;
         kDebug() << "Suspend";
     }
 }
 
 void GtfsImporter::resume()
 {
     QMutexLocker locker( &m_mutex );
     if ( m_state == ImportingSuspended ) {
         m_state = Importing;
     }
 }
 
 void GtfsImporter::startImport( const QString &fileName )
 {
     m_mutex.lock();
     m_fileName = fileName;
     m_mutex.unlock();
 
     start( LowPriority );
 }
 
 void GtfsImporter::setError( GtfsImporter::State errorState,
                                            const QString &errorText )
 {
     m_mutex.lock();
     if ( errorState <= m_state ) {
         // A more or equally fatal error is already recorded
         m_mutex.unlock();
         return;
     }
     m_state = errorState;
     m_errorString = errorText;
     m_mutex.unlock();
 
     kDebug() << errorText;
     if ( errorState == FatalError ) {
         emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                                "Fatal error: <message>%1</message>", errorText) );
         emit finished( errorState, errorText );
     } else {
         emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                                "Error: <message>%1</message>", errorText) );
     }
 }
 
 bool GtfsImporter::checkFileList( const QStringList &requiredFiles,
                                   const QStringList &availableFiles,
                                   QStringList *missingFiles )
 {
     *missingFiles = requiredFiles;
     foreach ( const QString &file, availableFiles ) {
         missingFiles->removeOne( file );
     }
     return missingFiles->isEmpty();
 }
 
 const KArchiveDirectory *GtfsImporter::findFeedDataDirectory(
         const KArchiveDirectory *directory, const QStringList &requiredFiles,
         QStringList *missingFiles, int level )
 {
     // Do not recurse too deep
     if ( level > 10 ) {
         return 0;
     }
 
     // Test if the current directory is the GTFS feed data directory
     QStringList directoryEntries = directory->entries();
     if ( checkFileList(requiredFiles, directoryEntries, missingFiles) ) {
         // The given directory contains all required files
         return directory;
     } else if ( missingFiles->count() < requiredFiles.count() ) {
         // At least one required field has been found,
         // most probably this is the data directory, but some files are missing
         return directory;
     }
 
     // Test subdirectories
     foreach ( const QString &directoryEntry, directoryEntries ) {
         const KArchiveEntry *entry = directory->entry( directoryEntry );
         if ( entry->isDirectory() ) {
             kDebug() << "Search GTFS feed data directory in level" << level << entry->name();
             const KArchiveDirectory *subDirectory =
                     dynamic_cast< const KArchiveDirectory* >( entry );
             const KArchiveDirectory *foundDirectory =
                     findFeedDataDirectory( subDirectory, requiredFiles, missingFiles, level + 1 );
             if ( foundDirectory ) {
                 // The GTFS data files have been found inside this directory
                 return foundDirectory;
             }
         }
     }
 
     // Did not find the GTFS feed data directory
     return 0;
 }
 
 void GtfsImporter::run()
 {
     m_mutex.lock();
     m_state = Importing;
     const QString fileName = m_fileName;
     const QString providerName = m_providerName;
     QSqlDatabase database = GtfsDatabase::database( m_providerName );
     m_mutex.unlock();
 
     emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                          "Start import of GTFS feed for %1", providerName) );
 
     // stop_times.txt is the biggest, importing it takes most time
     QStringList requiredFiles;
     requiredFiles << "agency.txt" << "stops.txt" << "routes.txt" << "trips.txt" << "stop_times.txt";
 
     KZip gtfsZipFile( fileName );
     if ( !gtfsZipFile.open(QIODevice::ReadOnly) ) {
         setError( FatalError, "Can not open file " + fileName + ": " +
                               gtfsZipFile.device()->errorString() );
         return;
     }
     const QString tmpGtfsDir = KGlobal::dirs()->saveLocation( "tmp",
             QFileInfo(fileName).fileName() + "_dir/" );
 
     // Find the GTFS feed data directory, containing the .txt files, eg. stop_times.txt
     QStringList missingFiles;
     const KArchiveDirectory *feedDataDirectory = findFeedDataDirectory(
             gtfsZipFile.directory(), requiredFiles, &missingFiles );
     if ( !missingFiles.isEmpty() ) {
         kDebug() << "Required file(s) missing in GTFS feed: " << missingFiles.join(", ");
         setError( FatalError, i18ncp("@info/plain",
                                      "Required file missing in GTFS feed: <filename>%1</filename>",
                                      "Required files missing in GTFS feed: <filename>%1</filename>",
                                      missingFiles.join(", ")) );
         return;
     }
     Q_ASSERT( feedDataDirectory );
 
     // Extract data directory of the GTFS feed
     feedDataDirectory->copyTo( tmpGtfsDir );
     gtfsZipFile.close();
 
     // Calculate total file size (for progress calculations)
     QFileInfoList fileInfos = QDir( tmpGtfsDir ).entryInfoList( QDir::Files | QDir::NoDotAndDotDot );
     qint64 totalFileSize = 0;
     foreach ( const QFileInfo &fileInfo, fileInfos ) {
         totalFileSize += fileInfo.size();
     }
 
     QString errorText;
     if ( !GtfsDatabase::createDatabaseTables(&errorText, database) ) {
         setError( FatalError, "Error initializing tables in the database: " + errorText );
         return;
     }
 
     bool errors = false;
     qint64 totalFilePosition = 0;
     foreach ( const QFileInfo &fileInfo, fileInfos ) {
         QStringList requiredFields;
         int minimalRecordCount = 0;
         if ( fileInfo.fileName() == "agency.txt" ) {
             requiredFields << "agency_name" << "agency_url" << "agency_timezone";
         } else if ( fileInfo.fileName() == "stops.txt" ) {
             requiredFields << "stop_id" << "stop_name" << "stop_lat" << "stop_lon";
             minimalRecordCount = 1;
         } else if ( fileInfo.fileName() == "routes.txt" ) {
             requiredFields << "route_id" << "route_short_name" << "route_long_name" << "route_type";
             minimalRecordCount = 1;
         } else if ( fileInfo.fileName() == "trips.txt" ) {
             requiredFields << "trip_id" << "route_id" << "service_id";
             minimalRecordCount = 1;
         } else if ( fileInfo.fileName() == "stop_times.txt" ) {
             requiredFields << "trip_id" << "arrival_time" << "departure_time" << "stop_id"
                            << "stop_sequence";
             minimalRecordCount = 1;
         } else if ( fileInfo.fileName() == "calendar.txt" ) {
             requiredFields << "service_id" << "monday" << "tuesday" << "wednesday" << "thursday"
                            << "friday" << "saturday" << "sunday" << "start_date" << "end_date";
         } else if ( fileInfo.fileName() == "calendar_dates.txt" ) {
             requiredFields << "service_id" << "date" << "exception_type";
         } else if ( fileInfo.fileName() == "fare_attributes.txt" ) {
             requiredFields << "fare_id" << "price" << "currency_type" << "payment_method"
                            << "transfers";
         } else if ( fileInfo.fileName() == "fare_rules.txt" ) {
             requiredFields << "fare_id";
         } else if ( fileInfo.fileName() == "shapes.txt" ) {
             emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                                  "Skip <filename>shapes.txt</filename>, data is unused") );
             // requiredFields << "shape_id" << "shape_pt_lat" << "shape_pt_lon" << "shape_pt_sequence";
             totalFilePosition += fileInfo.size();
             continue;
         } else if ( fileInfo.fileName() == "frequencies.txt" ) {
             requiredFields << "trip_id" << "start_time" << "end_time" << "headway_secs";
         } else if ( fileInfo.fileName() == "transfers.txt" ) {
             requiredFields << "from_stop_id" << "to_stop_id" << "transfer_type";
         } else {
             kDebug() << "Unexpected filename:" << fileInfo.fileName();
             emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                                  "Unexpected filename: %1</filename>", fileInfo.fileName()) );
             totalFilePosition += fileInfo.size();
             continue;
         }
 
         if ( !writeGtfsDataToDatabase(database, fileInfo.filePath(), requiredFields,
                                       minimalRecordCount, totalFilePosition, totalFileSize) )
         {
             errors = true;
         }
         totalFilePosition += fileInfo.size();
         emit progress( qreal(totalFilePosition) / qreal(totalFileSize), fileInfo.baseName() );
 
         m_mutex.lock();
         if ( m_quit ) {
             m_mutex.unlock();
             setError( FatalError, "Importing was cancelled" );
             return;
         }
         m_mutex.unlock();
     }
 
     m_mutex.lock();
     m_state = errors ? FinishedWithErrors : FinishedSuccessfully;
     kDebug() << "Importer finished" << m_providerName;
     if ( errors ) {
         emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                              "Import finished with error <message>%1</message>", m_errorString) );
     } else {
         emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                              "Import finished successfully") );
     }
     const QString errorString = m_errorString;
     m_mutex.unlock();
 
     emit finished( errors ? FinishedWithErrors : FinishedSuccessfully, errorString );
     return;
 }
 
 bool GtfsImporter::writeGtfsDataToDatabase( QSqlDatabase database,
         const QString &fileName, const QStringList &requiredFields, int minimalRecordCount,
         qint64 totalFilePosition, qint64 totalFileSize )
 {
     // Open the file
     QFile file( fileName );
     if ( !file.open(QIODevice::ReadOnly) ) {
         setError( FatalError, "Cannot open file " + fileName );
         return false;
     }
 
     // Check if the file is empty
     if ( file.atEnd() ) {
         file.close();
         if ( minimalRecordCount == 0 ) {
             return true;
         } else {
             setError( FatalError, "Empty file " + fileName );
             return false;
         }
     }
 
     // Open the database
     if ( !database.isValid() || !database.isOpen() ) {
         file.close();
         setError( FatalError, "Can not open database" );
         return false;
     }
 
     const QString tableName = QFileInfo(file).baseName();
     emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                          "Import GTFS data for table %1", tableName) );
 
     // Read first line from file (header with used field names)
     QStringList fieldNames;
     if ( file.atEnd() || !readHeader(decode(file.readLine()), &fieldNames, requiredFields) ) {
         file.close();
         return false; // Error in header
     }
     // Get types of the fields
     QList<GtfsDatabase::FieldType> fieldTypes;
     foreach ( const QString &fieldName, fieldNames ) {
         fieldTypes << GtfsDatabase::typeOfField( fieldName );
     }
 
     QSqlRecord table = database.record( tableName );
     QStringList unavailableFieldNames; // Field names not used in the database
     QList<int> unavailableFieldIndices;
     for ( int i = fieldNames.count() - 1; i >= 0; --i ) {
         const QString fieldName = fieldNames[i];
         if ( !table.contains(fieldName) && fieldName != "monday" && fieldName != "tuesday" &&
              fieldName != "wednesday" && fieldName != "thursday" && fieldName != "friday" &&
              fieldName != "saturday" && fieldName != "sunday" )
         {
             // The current field name is not available in the database, skip it's value in each row
             unavailableFieldNames << fieldNames[i];
             unavailableFieldIndices << i;
             fieldNames.removeAt( i );
         }
     }
     if ( !unavailableFieldNames.isEmpty() ) {
         kDebug() << "Not all used fields are available in the database:" << unavailableFieldNames
                  << "table:" << tableName;
         emit logMessage( i18nc("@info/plain GTFS feed import logbook entry",
                              "Not all used fields are available in table %1: %2",
                              tableName, unavailableFieldNames.join(", ")) );
     }
 
     QStringList dbFieldNames = fieldNames;
     QStringList missingRequiredFields; // Fields that are required and missing, but available in provider data
     if ( tableName == QLatin1String("calendar") ) {
         // All day fields in GTFS feeds get combined into "weekdays" in the database
         // (a string with "1" or "0" for each day)
         dbFieldNames.removeOne( "monday" );
         dbFieldNames.removeOne( "tuesday" );
         dbFieldNames.removeOne( "wednesday" );
         dbFieldNames.removeOne( "thursday" );
         dbFieldNames.removeOne( "friday" );
         dbFieldNames.removeOne( "saturday" );
         dbFieldNames.removeOne( "sunday" );
         dbFieldNames.append( "weekdays" );
     } else if ( tableName == QLatin1String("agency") ) {
         const QStringList requiredAgencyFields = QStringList()
                 << "agency_name" << "agency_url" << "agency_timezone";
         foreach ( const QString &requiredAgencyField, requiredAgencyFields ) {
             if ( !fieldNames.contains(requiredAgencyField) ) {
                 missingRequiredFields << requiredAgencyField;
             }
         }
         if ( !missingRequiredFields.isEmpty() ) {
             dbFieldNames = QStringList()
                     << "agency_id" << "agency_name" << "agency_url" << "agency_timezone";
         }
     }
 
     QString placeholder( '?' );
     for ( int i = 1; i < dbFieldNames.count(); ++i ) {
         placeholder += ",?";
     }
 
     // Simple benchmark, prints the time it took until the Block got destructed
     KDebug::Block insertBlock( ("Import GTFS table " + tableName).toUtf8() );
 
     // Create a query for the database
     QSqlQuery query( database );
 
     // Performance optimization
     if( !query.exec("PRAGMA synchronous=OFF;") ) {
         qDebug() << query.lastError();
         emit logMessage( query.lastError().text() );
     }
 
     // Disable journal completely, because it's much faster
     // and there is nothing to loose, if the import crashes the database will
     // very likely go corrupt, but the import can be simply restarted
     if( !query.exec("PRAGMA journal_mode=OFF;") ) {
         qDebug() << query.lastError();
         emit logMessage( query.lastError().text() );
     }
 
     // Begin transaction
     if ( !database.driver()->beginTransaction() ) {
         qDebug() << database.lastError();
         emit logMessage( database.lastError().text() );
     }
 
     // Prepare an INSERT query to be used for each dataset to be inserted
     query.prepare( QString("INSERT OR REPLACE INTO %1 (%2) VALUES (%3)")
                    .arg(tableName, dbFieldNames.join(","), placeholder) );
 
     int counter = 0;
     while ( missingRequiredFields.isEmpty() && !file.atEnd() ) {
         const QByteArray line = file.readLine().trimmed();
         QVariantList fieldValues;
         if ( readFields(line, &fieldValues, fieldTypes, fieldNames.count()) ) {
             // Remove values for fields that do not exist in the database, but in the GTFS feed,
             // eg. when multiple values of the feed get combined into a single value in the
             // database, for example "monday", "tuesday", ... get combined to "weekdays".
             for ( int i = 0; i < unavailableFieldIndices.count(); ++i ) {
                 fieldValues.removeAt( unavailableFieldIndices[i] );
             }
 
             // Add current field values to the prepared query and execute it
             if ( tableName == "calendar" ) {
                 QString weekdays = "0000000";
                 for ( int i = 0; i < fieldNames.count(); ++i ) {
                     const QString fieldName = fieldNames[i];
                     if ( fieldValues[i].toInt() > 0 ) {
                         if ( fieldName == "sunday" ) {
                             weekdays[0] = '1';
                         } else if ( fieldName == "monday" ) {
                             weekdays[1] = '1';
                         } else if ( fieldName == "tuesday" ) {
                             weekdays[2] = '1';
                         } else if ( fieldName == "wednesday" ) {
                             weekdays[3] = '1';
                         } else if ( fieldName == "thursday" ) {
                             weekdays[4] = '1';
                         } else if ( fieldName == "friday" ) {
                             weekdays[5] = '1';
                         } else if ( fieldName == "saturday" ) {
                             weekdays[6] = '1';
                         } else {
                             query.addBindValue( fieldValues[i] );
                         }
                     } else if ( fieldName != "monday" && fieldName != "tuesday" &&
                         fieldName != "wednesday" && fieldName != "thursday" &&
                         fieldName != "friday" && fieldName != "saturday" && fieldName != "sunday" )
                     {
                         query.addBindValue( fieldValues[i] );
                     }
                 }
                 query.addBindValue( weekdays );
             } else if ( tableName == "stop_times" ) {
                 // If only one of "departure_time" and "arrival_time" is set,
                 // copy the value to both fields
                 int departureTime = -1;
                 int arrivalTime = -1;
                 int departureTimeIndex = -1;
                 int arrivalTimeIndex = -1;
                 for ( int i = 0; i < fieldNames.count(); ++i ) {
                     if ( fieldNames[i] == "departure_time" ) {
                         departureTime = fieldValues[i].toInt();
                         departureTimeIndex = i;
                     } else if ( fieldNames[i] == "arrival_time" ) {
                         arrivalTime = fieldValues[i].toInt();
                         arrivalTimeIndex = i;
                     }
                 }
                 if ( departureTimeIndex >= 0 ) {
                     arrivalTime = departureTime;
                     fieldValues[ arrivalTimeIndex ] = departureTime;
                 } else if ( departureTime < 0 ) {
                     departureTime = arrivalTime;
                     fieldValues[ departureTimeIndex ] = arrivalTime;
                 }
                 foreach ( const QVariant &fieldValue, fieldValues ) {
                     query.addBindValue( fieldValue );
                 }
             } else {
                 foreach ( const QVariant &fieldValue, fieldValues ) {
                     query.addBindValue( fieldValue );
                 }
             }
             if ( !query.exec() ) {
                 QMutexLocker locker( &m_mutex );
                 emit logMessage( query.lastError().text() );
                 kDebug() << query.lastError();
                 kDebug() << "With this query:" << query.lastQuery();
                 const int error = query.lastError().number();
                 if ( error == 10 || error == 11 ) {
                     // SQLite error codes for malformed database files
                     setError( FatalError, "Database is corrupted" );
                     return false;
                 }
                 continue;
             }
 
             // New row has been inserted into the DB successfully
             ++counter; // counter is now >= 1
 
             // Start a new transaction after 50000 INSERTs
             if ( counter % 50000 == 0 ) {
                 if ( !database.driver()->commitTransaction() ) {
                     qDebug() << database.lastError();
                     emit logMessage( database.lastError().text() );
                 }
                 if ( !database.driver()->beginTransaction() ) {
                     qDebug() << database.lastError();
                     emit logMessage( database.lastError().text() );
                 }
             }
 
             // Report progress and check for quit/suspend after each 500 INSERTs
             if ( counter % 500 == 0 ) {
                 // Report progress
                 emit progress( qreal(totalFilePosition + file.pos()) / qreal(totalFileSize),
                                 tableName );
 
                 // Check if the job should be cancelled
                 m_mutex.lock();
                 if ( m_quit ) {
                     m_mutex.unlock();
                     setError( FatalError, "Importer was cancelled" );
                     return false;
                 }
 
                 // Check if the job should be suspended
                 if ( m_state == ImportingSuspended ) {
                     // Commit before going to sleep for suspension
                     if ( !database.driver()->commitTransaction() ) {
                         qDebug() << database.lastError();
                         emit logMessage( database.lastError().text() );
                     }
 
                     do {
                         // Do not lock while sleeping, otherwise ::resume() results in a deadlock
                         m_mutex.unlock();
 
                         // Suspend import for one second
                         sleep( 1 );
 
                         // Lock mutex again, to check if m_state is still ImportingSuspended
                         m_mutex.lock();
                         kDebug() << "Next check for suspended state" << m_state;
                     } while ( m_state == ImportingSuspended );
 
                     // Start a new transaction
                     if ( !database.driver()->beginTransaction() ) {
                         qDebug() << database.lastError();
                         emit logMessage( database.lastError().text() );
                     }
                 }
 
                 // Unlock mutex again
                 m_mutex.unlock();
             }
         }
     }
 
     if ( !missingRequiredFields.isEmpty() ) {
         // Only insert one row into the database, because the GTFS feed did not include this data
         // Currently only used for the "agency" table
         Q_ASSERT( tableName == QLatin1String("agency") );
         const ServiceProviderData *providerData =
                 ServiceProviderDataReader::read( m_providerName, &m_errorString );
         if ( !providerData ) {
             m_state = FatalError;
             kDebug() << m_errorString;
         } else {
             kDebug() << "Missing required fields, that get filled with data of the provider plugin"
                     << missingRequiredFields;
             QVariantList fieldValues = QVariantList() << 0 // agency_id
                     << providerData->name() << providerData->url() << providerData->timeZone();
             foreach ( const QVariant &fieldValue, fieldValues ) {
                 query.addBindValue( fieldValue );
             }
 
             if ( query.exec() ) {
                 ++counter;
             } else {
                 QMutexLocker locker( &m_mutex );
                 emit logMessage( query.lastError().text() );
                 kDebug() << query.lastError();
                 kDebug() << "With this query:" << query.lastQuery();
                 const int error = query.lastError().number();
                 if ( error == 10 || error == 11 ) {
                     // SQLite error codes for malformed database files
                     setError( FatalError, "Database is corrupted" );
                 }
             }
         }
     }
 
     // End transaction, restore synchronous=FULL
     if ( !database.driver()->commitTransaction() ) {
         qDebug() << database.lastError();
         emit logMessage( database.lastError().text() );
     }
     if( !query.exec("PRAGMA synchronous=FULL;") ) {
         qDebug() << query.lastError();
         emit logMessage( query.lastError().text() );
     }
 
     // Close the file again
     file.close();
 
     // Return true (success) if at least one stop has been read
     if ( counter >= minimalRecordCount ) {
         return true;
     } else {
         setError( FatalError, "Not enough records found in " + tableName );
         kDebug() << "Minimal record count is" << minimalRecordCount << "but only" << counter
                  << "records were added";
         return false;
     }
 }
 
 bool GtfsImporter::readHeader( const QString &header, QStringList *fieldNames,
                                              const QStringList &requiredFields )
 {
     QStringList names = header.simplified().split(',');
     *fieldNames = QStringList();
     if ( names.isEmpty() ) {
         setError( FatalError, "No field names found in header: " + header );
         return false;
     }
 
     // Only allow alphanumerical characters as field names (and prevent SQL injection).
     QRegExp regExp( "[^A-Z0-9_]", Qt::CaseInsensitive );
     foreach ( const QString &fieldName, names ) {
         QString name = fieldName.trimmed();
         if ( (name.startsWith('"') && name.endsWith('"')) ||
              (name.startsWith('\'') && name.endsWith('\'')) )
         {
             name = name.mid( 1, name.length() - 2 );
         }
         if ( regExp.indexIn(name) != -1 ) {
             emit logMessage( i18nc("@info", "Field name <emphasis>%1</emphasis> contains "
                                    "a disallowed character <emphasis>%2</emphasis>' at %3",
                                    fieldName, regExp.cap(), regExp.pos()) );
-            kWarning() << "Field name" << fieldName << "contains a disallowed character"
+            qWarning() << "Field name" << fieldName << "contains a disallowed character"
                        << regExp.cap() << "at" << regExp.pos();
         } else {
             fieldNames->append( name );
         }
     }
 
     // Check required fields
     foreach ( const QString &requiredField, requiredFields ) {
         if ( !fieldNames->contains(requiredField) ) {
             emit logMessage( i18nc("@info", "Required field '%1' is missing", requiredField) );
             kDebug() << "Required field missing:" << requiredField << *fieldNames;
 
             if ( requiredField == QLatin1String("agency_name") ) {
                 kDebug() << "Will use agency name from plugin data";
             } else if ( requiredField == QLatin1String("agency_url") ) {
                 kDebug() << "Will use agency URL from plugin data";
             } else if ( requiredField == QLatin1String("agency_timezone") ) {
                 kDebug() << "Will use timezone from plugin data";
             } else {
                 setError( FatalError, "Required field missing: " + requiredField );
                 kDebug() << "in this header line:" << header;
                 return false;
             }
         }
     }
 
     return true;
 }
 
 bool GtfsImporter::readFields( const QByteArray &line, QVariantList *fieldValues,
         const QList<GtfsDatabase::FieldType> &fieldTypes, int expectedFieldCount )
 {
     int pos = 0;
     QList<GtfsDatabase::FieldType>::ConstIterator fieldType = fieldTypes.constBegin();
     while ( pos < line.length() && fieldType != fieldTypes.constEnd() ) {
         int endPos = pos;
         QByteArray newField;
         if ( line[pos] == '"' ) {
             // A field with a quotation mark in it must start and end with a quotation mark,
             // all other quotation marks must be preceded with another quotation mark
             ++endPos;
             while ( endPos < line.length() ) {
                 if ( line[endPos] == '"' ) {
                     if ( endPos + 1 >= line.length() || line[endPos + 1] == ',' ) {
                         break; // At the end of the field / line
                     }
 
                     if ( line[endPos + 1] == '"' ) {
                         ++endPos; // Two quotation marks read, skip them
                     }
                 }
                 ++endPos;
             }
 
             if ( endPos >= line.length() || line[endPos] != '"' ) {
-                kWarning() << "No field end delimiter found in line" << line;
-                kWarning() << "for field starting with a delimiter at position" << pos;
-                kWarning() << "Read until the end of the line";
+                qWarning() << "No field end delimiter found in line" << line;
+                qWarning() << "for field starting with a delimiter at position" << pos;
+                qWarning() << "Read until the end of the line";
                 // Do not remove 1, because it gets done below,
                 // there is no delimiter to remove at the end
                 endPos = line.length();
             }
 
             // Add field value without the quotation marks around it
             // and doubled quotation marks replaced with single ones
             newField = line.mid( pos + 1, endPos - pos - 1 )
                     .replace( QByteArray("\"\""), QByteArray("\"") );
             pos = endPos + 2;
         } else if ( line[pos] == ',' ) {
             // Empty field, newField stays empty
             ++pos;
 
         } else {
             // Field without quotation marks, read until the next ','
             endPos = line.indexOf( ',', pos );
             if ( endPos < 0 ) {
                 endPos = line.length();
             }
 
             // Add field value
             newField = line.mid( pos, endPos - pos );
             pos = endPos + 1;
         }
 
         // Append the new field value
         fieldValues->append( GtfsDatabase::convertFieldValue(newField.trimmed(), *fieldType) );
         ++fieldType;
 
         if ( pos == line.length() && line[pos - 1] == ',' && fieldType != fieldTypes.constEnd() ) {
             // The current line ends after a ','. Add another empty field:
             fieldValues->append( GtfsDatabase::convertFieldValue(QByteArray(), *fieldType) );
             ++fieldType;
         }
     }
 
     if ( fieldValues->isEmpty() ) {
         return false;
     } else if ( fieldValues->count() < expectedFieldCount ) {
-        kWarning() << "Header contains" << expectedFieldCount << "fields, but a line was read "
+        qWarning() << "Header contains" << expectedFieldCount << "fields, but a line was read "
                 "with only" << fieldValues->count() << "field values. Using empty/default values:";
-        kWarning() << "Values: " << *fieldValues;
+        qWarning() << "Values: " << *fieldValues;
         while ( fieldValues->count() < expectedFieldCount ) {
             fieldValues->append( QVariant() );
         }
     }
 
     return true;
 }
 
 #include "gtfsimporter.moc"
diff --git a/engine/gtfs/gtfsservice.cpp b/engine/gtfs/gtfsservice.cpp
index 931c970..f156819 100644
--- a/engine/gtfs/gtfsservice.cpp
+++ b/engine/gtfs/gtfsservice.cpp
@@ -1,676 +1,676 @@
 /*
  *   Copyright 2013 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 "gtfsservice.h"
 #include "serviceprovider.h"
 #include "serviceproviderdata.h"
 #include "serviceproviderglobal.h"
 #include "serviceprovidergtfs.h"
 
 // KDE includes
 #include <KTemporaryFile>
 #include <KMimeType>
 #include <KDebug>
 #include <KFileItem>
 #include <KIO/Job>
 #include <Plasma/DataEngine>
 #include <kjobtrackerinterface.h>
 
 // Qt includes
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QTimer>
 
 const qreal ImportGtfsToDatabaseJob::PROGRESS_PART_FOR_FEED_DOWNLOAD = 0.1;
 
 AbstractGtfsDatabaseJob::AbstractGtfsDatabaseJob( const QString &destination,
         const QString &operation, const QMap< QString, QVariant > &parameters, QObject *parent )
         : ServiceJob(destination, operation, parameters, parent)
 {
     Q_ASSERT( qobject_cast<GtfsService*>(parent) );
     Q_ASSERT( qobject_cast<Plasma::DataEngine*>(parent->parent()) );
 }
 
 ImportGtfsToDatabaseJob::ImportGtfsToDatabaseJob( const QString &destination,
         const QString &operation, const QMap< QString, QVariant > &parameters, QObject *parent )
         : AbstractGtfsDatabaseJob(destination, operation, parameters, parent),
           m_state(Initializing), m_data(0), m_importer(0), m_onlyGetInformation(false)
 {
     setCapabilities( Suspendable | Killable );
 
     QString errorMessage;
     m_data = ServiceProviderDataReader::read( parameters["serviceProviderId"].toString(),
                                               &errorMessage );
     if ( !m_data ) {
         setError( GtfsErrorInvalidProviderId );
         setErrorText( errorMessage );
         return;
     }
 
     if ( m_data->type() != Enums::GtfsProvider ) {
         setError( GtfsErrorWrongProviderType );
         setErrorText( i18nc("@info/plain", "Not a GTFS provider") );
     }
 }
 
 UpdateGtfsToDatabaseJob::UpdateGtfsToDatabaseJob( const QString& destination,
         const QString &operation, const QMap< QString, QVariant > &parameters, QObject *parent )
         : ImportGtfsToDatabaseJob(destination, operation, parameters, parent)
 {
 }
 
 ImportGtfsToDatabaseJob::~ImportGtfsToDatabaseJob()
 {
     if ( m_importer ) {
         m_importer->quit();
         kDebug() << "Wait 10 second for the import thread to quit...";
         m_importer->wait( 10000 );
         delete m_importer;
     }
 }
 
 DeleteGtfsDatabaseJob::DeleteGtfsDatabaseJob( const QString &destination,
         const QString &operation, const QMap< QString, QVariant > &parameters, QObject *parent )
         : AbstractGtfsDatabaseJob(destination, operation, parameters, parent)
 {
     m_serviceProviderId = parameters["serviceProviderId"].toString();
 }
 
 bool AbstractGtfsDatabaseJob::canImportGtfsFeed()
 {
     GtfsService *service = qobject_cast< GtfsService* >( parent() );
     Plasma::DataEngine *engine = qobject_cast< Plasma::DataEngine* >( service->parent() );
     Q_ASSERT( engine );
 
     // Get the QMetaObject of the engine
     const QMetaObject *meta = engine->metaObject();
 
     // Find the slot of the engine to start the request
     const int slotIndex = meta->indexOfSlot( "tryToStartGtfsFeedImportJob(Plasma::ServiceJob*)" );
     Q_ASSERT( slotIndex != -1 );
 
     meta->method( slotIndex ).invoke( engine, Qt::DirectConnection,
                                       Q_RETURN_ARG(bool, m_canAccessGtfsDatabase),
                                       Q_ARG(const Plasma::ServiceJob*, this) );
 
     // If an import is already running for the provider, the operation cannot be executed now,
     // only updateGtfsFeedInfo can be executed while importing a GTFS feed
     if ( !m_canAccessGtfsDatabase ) {
-        kWarning() << "The GTFS feed already gets imported";
+        qWarning() << "The GTFS feed already gets imported";
         return false;
     }
 
     return true;
 }
 
 void AbstractGtfsDatabaseJob::start()
 {
     QTimer::singleShot( 0, this, SLOT(tryToWork()) );
 }
 
 void AbstractGtfsDatabaseJob::tryToWork()
 {
     if ( error() != NoGtfsError ) {
         kDebug() << error();
         // Error found in constructor, eg. no provider with the given ID found or no GTFS provider
         setResult( false );
         return;
     }
 
     if ( isAccessingGtfsDatabase() && !canImportGtfsFeed() ) {
         // Cannot start another GTFS database accessing job
         kDebug() << "Import is already running";
         setError( GtfsErrorFeedImportAlreadyRunning );
         setErrorText( i18nc("@info/plain", "The GTFS feed already gets imported.") );
         setResult( false );
         return;
     }
 
     // No problems, do the work now
     work();
 }
 
 void ImportGtfsToDatabaseJob::registerAtJobTracker()
 {
     KIO::getJobTracker()->registerJob( this );
     emitDescription();
 }
 
 void ImportGtfsToDatabaseJob::emitDescription()
 {
     if ( error() != NoGtfsError || !data() ) {
         kDebug() << error();
         // Error found in constructor, eg. no provider with the given ID found or no GTFS provider
         emit description( this, errorString() );
         return;
     }
 
     // Emit a description about what's done in this job
     const QPair< QString, QString > field1 =
             qMakePair( i18nc("@info/plain Label for GTFS service provider", "Service Provider"),
                        data()->name() );
     const QPair< QString, QString > field2 =
             qMakePair( i18nc("@info/plain Label for GTFS feed source URLs", "Source"),
                        m_data->feedUrl() );
     if ( m_onlyGetInformation ) {
         emit description( this, i18nc("@info", "Update GTFS feed info"), field1, field2 );
     } else {
         emit description( this, i18nc("@info", "Import GTFS feed"), field1, field2 );
     }
 }
 
 void UpdateGtfsToDatabaseJob::emitDescription()
 {
     if ( error() != NoGtfsError || !data() ) {
         kDebug() << error();
         // Error found in constructor, eg. no provider with the given ID found or no GTFS provider
         emit description( this, errorString() );
         return;
     }
 
     emit description( this, i18nc("@info", "Updating GTFS feed"),
                       qMakePair(i18nc("@info/plain Label for GTFS service provider",
                                       "Service Provider"), data()->name()),
                       qMakePair(i18nc("@info/plain Label for GTFS feed source URLs", 
                                       "Source"), data()->feedUrl()) );
 }
 
 void ImportGtfsToDatabaseJob::work()
 {
     Q_ASSERT( m_data );
 
     emitDescription();
 
     // Start the job by first requesting GTFS feed information
     statFeed();
 }
 
 void UpdateGtfsToDatabaseJob::tryToWork()
 {
     QString errorMessage;
     if ( ServiceProviderGtfs::isGtfsFeedImportFinished(data()->id(), data()->feedUrl(),
                 ServiceProviderGlobal::cache(), &errorMessage) )
     {
         AbstractGtfsDatabaseJob::tryToWork();
     } else {
         setError( GtfsErrorFeedImportRequired );
         setErrorText( errorMessage );
         setResult( false );
     }
 }
 
 void UpdateGtfsToDatabaseJob::work()
 {
     QString errorMessage;
     if ( ServiceProviderGtfs::isGtfsFeedImportFinished(data()->id(), data()->feedUrl(),
                 ServiceProviderGlobal::cache(), &errorMessage) )
     {
         // Emit a description about what's done in this job
         emitDescription();
         setCapabilities( Suspendable | Killable );
 
         // Start the job by first requesting GTFS feed information
         statFeed();
     } else {
         setError( GtfsErrorFeedImportRequired );
         setErrorText( errorMessage );
         setResult( false );
     }
 }
 
 void DeleteGtfsDatabaseJob::work()
 {
     // Close the database before deleting it,
     // otherwise a newly created database won't get opened,
     // because the already opened database connection gets used instead
     GtfsDatabase::closeDatabase( m_serviceProviderId );
 
     // Delete the database file
     const QString databasePath = GtfsDatabase::databasePath( m_serviceProviderId );
     if ( !QFile::remove(databasePath) ) {
         kDebug() << "Failed to delete GTFS database";
         setError( GtfsErrorCannotDeleteDatabase );
         setErrorText( i18nc("@info/plain", "The GTFS database could not be deleted.") );
         setResult( false );
         return;
     }
     kDebug() << "Finished deleting GTFS database of" << m_serviceProviderId;
 
     // Update the accessor cache file to indicate that the GTFS feed needs to be imported again
     KConfig config( ServiceProviderGlobal::cacheFileName(), KConfig::SimpleConfig );
     KConfigGroup group = config.group( m_serviceProviderId );
     KConfigGroup gtfsGroup = group.group( "gtfs" );
     gtfsGroup.writeEntry( "feedImportFinished", false );
 
     // Write to disk now, important for the data engine to get the correct state
     // directly after this job has finished
     gtfsGroup.sync();
 
     // Finished successfully
     setResult( true );
 }
 
 bool ImportGtfsToDatabaseJob::doKill()
 {
     if ( m_state == ReadingFeed ) {
         m_importer->quit();
     }
     m_state = KillingJob;
     return true;
 }
 
 bool ImportGtfsToDatabaseJob::doSuspend()
 {
     if ( m_state == ReadingFeed ) {
         m_importer->suspend();
     }
     return true;
 }
 
 bool ImportGtfsToDatabaseJob::doResume()
 {
     if ( m_state == ReadingFeed ) {
         m_importer->resume();
     }
     return true;
 }
 
 void ImportGtfsToDatabaseJob::statFeed()
 {
     if ( m_state == DownloadingFeed || m_state == ReadingFeed || m_state == StatingFeed ) {
         kDebug() << "Feed already gets downloaded / was downloaded and gets imported / gets stated";
         return;
     }
 
     if ( !m_data ) {
         // There was an error in the constructor, error already set
         setResult( false );
         return;
     }
 
     kDebug() << "Request GTFS feed information for" << m_data->id();
     emit infoMessage( this, i18nc("@info/plain", "Checking GTFS feed source") );
     m_state = StatingFeed;
     QNetworkAccessManager *manager = new QNetworkAccessManager( this );
     connect( manager, SIGNAL(finished(QNetworkReply*)),
              this, SLOT(statFeedFinished(QNetworkReply*)) );
     QNetworkRequest request( m_data->feedUrl() );
     manager->head( request );
 }
 
 void ImportGtfsToDatabaseJob::statFeedFinished( QNetworkReply *reply )
 {
     if ( m_state == KillingJob || isSuspended() ) {
         return;
     }
 
     // Check if there is a valid redirection
     QString redirectUrl = reply->attribute( QNetworkRequest::RedirectionTargetAttribute ).toString();
     if ( reply->error() != QNetworkReply::NoError &&
          reply->header(QNetworkRequest::ContentLengthHeader).toInt() == 0 &&
          reply->url() != m_lastRedirectUrl )
     {
         // Headers were requested, empty result
         // Now download completely, using get instead of head
         kDebug() << "Possible redirection, requesting headers lead to an error reply" << reply->url();
         m_lastRedirectUrl = reply->url().toString();
         reply->manager()->get( QNetworkRequest(reply->url()) );
         reply->deleteLater();
         return;
     } else if( !redirectUrl.isEmpty() && redirectUrl != m_lastRedirectUrl ) {
         // Redirect to redirectUrl, store last redirection
         kDebug() << "Redirecting to" << redirectUrl;
         m_lastRedirectUrl = redirectUrl;
         reply->manager()->head( QNetworkRequest(redirectUrl) );
         reply->deleteLater();
         return;
     }
 
     // Not redirected anymore
     m_lastRedirectUrl.clear();
 
     if ( reply->error() == QNetworkReply::NoError ) {
         QString contentType = reply->header( QNetworkRequest::ContentTypeHeader ).toString();
         // If ';' is not included in contentType, QString::left() returns the whole string
         const KMimeType::Ptr mimeType =
                 KMimeType::mimeType( contentType.left(contentType.indexOf(';')) );
         if ( mimeType && mimeType->isValid() ) {
             if ( !mimeType->is("application/zip") && !mimeType->is("application/octet-stream") ) {
                 kDebug() << "Invalid mime type:" << reply->header(QNetworkRequest::ContentTypeHeader).toString();
                 setError( GtfsErrorWrongFeedFormat );
                 setErrorText( i18nc("@info/plain", "Wrong GTFS feed format: %1", mimeType->name()) );
                 setResult( false );
                 return;
             }
         } else {
             kDebug() << "Could not create KMimeType object for" << reply->header(QNetworkRequest::ContentTypeHeader).toString();
         }
 
         // Use KDateTime and UTC time to not get confused with different locales
         KDateTime newLastModified = KDateTime::fromString(
                 reply->header(QNetworkRequest::LastModifiedHeader).toString() ).toUtc();
         qulonglong newSizeInBytes = reply->header( QNetworkRequest::ContentLengthHeader ).toULongLong();
 //         emit size and lastModified?
 //         qDebug() << ">>>>> GTFS feed was last modified (UTC):" << newLastModified
 //                  << "and it's size is:" << (newSizeInBytes/qreal(1024*1024)) << "MB";
         // Read accessor information cache
         QSharedPointer<KConfig> cache = ServiceProviderGlobal::cache();
         QString errorMessage;
         const bool importFinished = ServiceProviderGtfs::isGtfsFeedImportFinished(
                 data()->id(), data()->feedUrl(), cache, &errorMessage );
         KConfigGroup group = cache->group( data()->id() );
         KConfigGroup gtfsGroup = group.group( "gtfs" );
         KDateTime lastModified = KDateTime::fromString(
                 gtfsGroup.readEntry("feedModifiedTime", QString()) );
         qulonglong sizeInBytes = gtfsGroup.readEntry( "feedSizeInBytes", qulonglong(-1) );
 
         gtfsGroup.writeEntry( "feedModifiedTime", newLastModified.toString() );
         gtfsGroup.writeEntry( "feedSizeInBytes", newSizeInBytes );
         gtfsGroup.writeEntry( "feedUrl", data()->feedUrl() );
 
         // Needed to have the GTFS feed information available directly after this job is finished
         gtfsGroup.sync();
 
         // Stop here for "updateGtfsFeedInfo" operation
         if ( m_onlyGetInformation ) {
             m_state = Ready;
             setResult( importFinished );
             return;
         }
 
         if ( !importFinished ) {
             qDebug() << errorMessage << m_data->id();
         }
 //         qDebug() << "Old last modified:" << lastModified
 //                  << "new size:" << (sizeInBytes/qreal(1024*1024)) << "MB";
         if ( !importFinished // GTFS import not finished or never started?
              || (newLastModified.isValid() && lastModified.isValid() && // GTFS feed modified?
                  newLastModified != lastModified)
              || (newSizeInBytes > 0 && newSizeInBytes != sizeInBytes) // Size changed?
              || (newSizeInBytes == 0 && !newLastModified.isValid() && // If both are not available...
                  lastModified.daysTo(KDateTime::currentUtcDateTime()) > 7) ) // ...upate weekly
         {
             kDebug() << "Download new GTFS feed version for" << m_data->id();
 
             // A newer GTFS feed is available or it was not imported / import did not finish
             m_state = Initializing;
             downloadFeed();
         } else {
             // Newest version of the GTFS feed is already downloaded and completely imported
             m_state = Ready;
             setResult( true );
         }
     } else {
         // Track this job to show the error
         registerAtJobTracker();
 
         kDebug() << "GTFS feed not available: " << m_data->feedUrl() << reply->errorString();
         m_state = ErrorDownloadingFeed;
         setError( GtfsErrorDownloadFailed );
         setErrorText( reply->errorString() ); // TODO
         setResult( false );
     }
 
     reply->manager()->deleteLater();
     reply->deleteLater();
 }
 
 void ImportGtfsToDatabaseJob::slotSpeed( KJob *job, ulong speed )
 {
     Q_UNUSED( job );
     emitSpeed( speed );
 }
 
 void ImportGtfsToDatabaseJob::downloadFeed()
 {
     if ( m_state == DownloadingFeed || m_state == ReadingFeed || m_state == StatingFeed ) {
         kDebug() << "Feed already gets downloaded / was downloaded and gets imported / gets stated";
         return;
     }
     if ( m_state == KillingJob || isSuspended() ) {
         return;
     }
 
     // Track this job at least from now on,
     // because the download/import can take some time
     registerAtJobTracker();
 
     kDebug() << "Start GTFS feed import for" << m_data->id();
     KTemporaryFile tmpFile;
     if ( tmpFile.open() ) {
         kDebug() << "Downloading GTFS feed from" << m_data->feedUrl() << "to" << tmpFile.fileName();
         emit infoMessage( this, i18nc("@info/plain", "Downloading GTFS feed") );
         m_state = DownloadingFeed;
         tmpFile.setAutoRemove( false ); // Do not remove the target file while downloading
 
         // Set progress to 0
         m_progress = 0.0;
         emitPercent( 0, 1000 );
 
 //         KFileItem gtfsFeed( m_info->feedUrl(), QString(), S_IFREG | S_IFSOCK );
 //         kDebug() << "LAST MODIFIED:" << gtfsFeed.timeString( KFileItem::ModificationTime );
 
         // Update provider cache
         KConfig config( ServiceProviderGlobal::cacheFileName(), KConfig::SimpleConfig );
         KConfigGroup group = config.group( data()->id() );
         KConfigGroup gtfsGroup = group.group( "gtfs" );
         gtfsGroup.writeEntry( "feedImportFinished", false );
 
         KIO::FileCopyJob *job = KIO::file_copy( m_data->feedUrl(), QUrl(tmpFile.fileName()), -1,
                                                 KIO::Overwrite | KIO::HideProgressInfo );
         connect( job, SIGNAL(result(KJob*)), this, SLOT(feedReceived(KJob*)) );
         connect( job, SIGNAL(percent(KJob*,ulong)), this, SLOT(downloadProgress(KJob*,ulong)) );
         connect( job, SIGNAL(mimetype(KIO::Job*,QString)), this, SLOT(mimeType(KIO::Job*,QString)) );
         connect( job, SIGNAL(totalSize(KJob*,qulonglong)), this, SLOT(totalSize(KJob*,qulonglong)) );
         connect( job, SIGNAL(speed(KJob*,ulong)), this, SLOT(slotSpeed(KJob*,ulong)) );
     } else {
         kDebug() << "Could not create a temporary file to download the GTFS feed";
 //         TODO emit error...
     }
 }
 
 void ImportGtfsToDatabaseJob::mimeType( KIO::Job *job, const QString &type )
 {
     Q_UNUSED( job );
     const KMimeType::Ptr mimeType = KMimeType::mimeType( type );
     if ( mimeType && mimeType->isValid() ) {
         if ( !mimeType->is("application/zip") && !mimeType->is("application/octet-stream") ) {
             kDebug() << "Invalid mime type:" << type;
             setError( GtfsErrorWrongFeedFormat );
             setErrorText( i18nc("@info/plain", "Wrong GTFS feed format: %1", mimeType->name()) );
             setResult( false );
             return;
         }
     } else {
         kDebug() << "Could not create KMimeType object for" << type;
     }
 }
 
 void ImportGtfsToDatabaseJob::totalSize( KJob* job, qulonglong size )
 {
     Q_UNUSED( job );
     KConfig config( ServiceProviderGlobal::cacheFileName(), KConfig::SimpleConfig );
     KConfigGroup group = config.group( data()->id() );
     KConfigGroup gtfsGroup = group.group( "gtfs" );
     gtfsGroup.writeEntry( "feedSizeInBytes", size );
 }
 
 void ImportGtfsToDatabaseJob::downloadProgress( KJob *job, ulong percent )
 {
     Q_UNUSED( job );
     m_progress = (qreal(percent) / 100.0) * PROGRESS_PART_FOR_FEED_DOWNLOAD; // TODO Remove m_progress
     emitPercent( percent * 10 * PROGRESS_PART_FOR_FEED_DOWNLOAD, 1000 );
 }
 
 void ImportGtfsToDatabaseJob::feedReceived( KJob *job )
 {
     if ( m_state == KillingJob || isSuspended() ) {
         return;
     }
 
     // Emit progress for finished download
     m_progress = PROGRESS_PART_FOR_FEED_DOWNLOAD;
     emitPercent( 1000 * PROGRESS_PART_FOR_FEED_DOWNLOAD, 1000 );
 
     KIO::FileCopyJob *fileCopyJob = qobject_cast<KIO::FileCopyJob*>( job );
     QString tmpFilePath = fileCopyJob->destUrl().path();
     if ( job->error() != 0 ) {
         kDebug() << "Error downloading GTFS feed:" << job->errorString();
         emit infoMessage( this, i18nc("@info/plain", "Error downloading GTFS feed: "
                           "<message>%1</message>", job->errorString()) );
         m_state = ErrorDownloadingFeed;
         if ( !QFile::remove(tmpFilePath) ) {
             kDebug() << "Could not remove the temporary GTFS feed file";
         }
 
         setError( GtfsErrorDownloadFailed );
         setErrorText( job->errorString() ); // TODO
         setResult( false );
         return;
     }
 
     kDebug() << "GTFS feed received at" << tmpFilePath;
 
     // Read feed and write data into the DB
     m_state = ReadingFeed;
     emit infoMessage( this, i18nc("@info/plain", "Importing GTFS feed") );
     m_importer = new GtfsImporter( m_data->id() );
     connect( m_importer, SIGNAL(logMessage(QString)), this, SLOT(logMessage(QString)) );
     connect( m_importer, SIGNAL(progress(qreal,QString)),
              this, SLOT(importerProgress(qreal,QString)) );
     connect( m_importer, SIGNAL(finished(GtfsImporter::State,QString)),
              this, SLOT(importerFinished(GtfsImporter::State,QString)) );
     m_importer->startImport( tmpFilePath );
 }
 
 void ImportGtfsToDatabaseJob::logMessage( const QString &message )
 {
     emit warning( this, message );
 }
 
 void ImportGtfsToDatabaseJob::importerProgress( qreal importerProgress,
                                                 const QString &currentTableName )
 {
     m_progress = PROGRESS_PART_FOR_FEED_DOWNLOAD * (1.0 - importerProgress) + importerProgress;
     emitPercent( m_progress * 1000, 1000 );
 
     if ( currentTableName != m_lastTableName ) {
         emit infoMessage( this, i18nc("@info/plain", "Importing GTFS feed (%1)",
                                       currentTableName) );
         m_lastTableName = currentTableName;
     }
 }
 
 void ImportGtfsToDatabaseJob::importerFinished(
         GtfsImporter::State state, const QString &errorText )
 {
     // Remove temporary file
     if ( m_importer && !QFile::remove(m_importer->sourceFileName()) ) {
-        kWarning() << "Could not remove the temporary GTFS feed file";
+        qWarning() << "Could not remove the temporary GTFS feed file";
     }
 
     // Update 'feedImportFinished' field in the cache
     KConfig config( ServiceProviderGlobal::cacheFileName(), KConfig::SimpleConfig );
     KConfigGroup group = config.group( data()->id() );
     KConfigGroup gtfsGroup = group.group( "gtfs" );
     gtfsGroup.writeEntry( "feedImportFinished", state != GtfsImporter::FatalError );
 
     // Write to disk now, important for the data engine to get the correct state
     // directly after this job has finished
     gtfsGroup.sync();
 
     // Emit progress with 1.0, ie. finsihed
     m_progress = 1.0;
     emitPercent( 1000, 1000 );
     kDebug() << "Finished" << state << errorText;
 
     // Ignore GtfsImporter::FinishedWithErrors
     if ( state == GtfsImporter::FatalError ) {
         m_state = ErrorReadingFeed;
         kDebug() << "There was an error importing the GTFS feed into the database" << errorText;
         emit infoMessage( this, errorText );
     } else {
         m_state = Ready;
         emit infoMessage( this, i18nc("@info/plain", "GTFS feed has been successfully imported") );
     }
 
     if ( m_importer ) {
         m_importer->quit();
         m_importer->wait();
         delete m_importer;
         m_importer = 0;
     }
 
     if ( m_state == Ready ) {
         // Update accessor information cache
         setResult( true );
     } else {
         setError( GtfsErrorImportFailed );
         setErrorText( errorText );
         setResult( false );
     }
 }
 
 QString ImportGtfsToDatabaseJob::serviceProviderId() const
 {
     return m_data ? m_data->id() : QString();
 }
 
 GtfsService::GtfsService( const QString &name, QObject *parent )
         : Service(parent), m_name(name)
 {
     // This associates the service with the "publictransport.operations" file
     setName( "publictransport" );
 }
 
 Plasma::ServiceJob* GtfsService::createJob(
         const QString &operation, QMap< QString, QVariant > &parameters )
 {
     // Check if a valid provider ID is available in the parameters
     const QString providerId = parameters["serviceProviderId"].toString();
     if ( providerId.isEmpty() ) {
-        kWarning() << "No 'serviceProviderId' parameter given to GTFS service operation";
+        qWarning() << "No 'serviceProviderId' parameter given to GTFS service operation";
         return 0;
     }
 
     if ( operation == QLatin1String("updateGtfsDatabase") ) {
         UpdateGtfsToDatabaseJob *updateJob =
                 new UpdateGtfsToDatabaseJob( "PublicTransport", operation, parameters, this );
         return updateJob;
     } else if ( operation == QLatin1String("importGtfsFeed") ) {
         ImportGtfsToDatabaseJob *importJob =
                 new ImportGtfsToDatabaseJob( "PublicTransport", operation, parameters, this );
         // Directly register import jobs, ie. also show "Check Feed Source"
         importJob->registerAtJobTracker();
         return importJob;
     } else if ( operation == QLatin1String("deleteGtfsDatabase") ) {
         DeleteGtfsDatabaseJob *deleteJob =
                 new DeleteGtfsDatabaseJob( "PublicTransport", operation, parameters, this );
         return deleteJob;
     } else if ( operation == QLatin1String("updateGtfsFeedInfo") ) {
         ImportGtfsToDatabaseJob *updateFeedInfoJob =
                 new ImportGtfsToDatabaseJob( "PublicTransport", operation, parameters, this );
         updateFeedInfoJob->setOnlyGetInformation( true );
         return updateFeedInfoJob;
     } else {
-        kWarning() << "Operation" << operation << "not supported";
+        qWarning() << "Operation" << operation << "not supported";
         return 0;
     }
 }
diff --git a/engine/gtfs/serviceprovidergtfs.cpp b/engine/gtfs/serviceprovidergtfs.cpp
index 8ee7cd9..0cd8804 100644
--- a/engine/gtfs/serviceprovidergtfs.cpp
+++ b/engine/gtfs/serviceprovidergtfs.cpp
@@ -1,908 +1,908 @@
 /*
  *   Copyright 2013 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 "serviceprovidergtfs.h"
 
 // Own includes
 #include "serviceproviderdata.h"
 #include "serviceproviderglobal.h"
 #include "departureinfo.h"
 #include "gtfsservice.h"
 #include "gtfsrealtime.h"
 #include "request.h"
 
 // KDE includes
 #include <Plasma/Service>
 #include <KTimeZone>
 #include <KDateTime>
 #include <KStandardDirs>
 #include <KDebug>
 #include <KTemporaryFile>
 #include <KLocalizedString>
 #include <KLocale>
 #include <KCurrencyCode>
 #include <KConfigGroup>
 #include <KIO/Job>
 #include <Plasma/DataEngine>
 
 // Qt includes
 #include <QSqlQuery>
 #include <QSqlError>
 #include <QSqlRecord>
 #include <QFileInfo>
 #include <QEventLoop>
 #include <QTimer>
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <qmath.h>
 
 const qreal ServiceProviderGtfs::PROGRESS_PART_FOR_FEED_DOWNLOAD = 0.1;
 
 ServiceProviderGtfs::ServiceProviderGtfs(
         const ServiceProviderData *data, QObject *parent, const QSharedPointer<KConfig> &cache )
         : ServiceProvider(data, parent, cache), m_state(Initializing), m_service(0)
 #ifdef BUILD_GTFS_REALTIME
           , m_tripUpdates(0), m_alerts(0)
 #endif
 {
     // Ensure that the GTFS feed was imported and the database is valid
     if ( updateGtfsDatabaseState(data->id(), data->feedUrl(), cache) == QLatin1String("ready") ) {
         m_state = Ready;
 
         // Load agency information from database and request GTFS-realtime data
         loadAgencyInformation();
 #ifdef BUILD_GTFS_REALTIME
         updateRealtimeData();
 #endif
     } else {
         m_state = Error;
     }
 
     // Update database, if a new version of the GTFS feed is available
     // and an initial import has finished successfully
     updateGtfsDatabase();
 }
 
 ServiceProviderGtfs::~ServiceProviderGtfs()
 {
     // Free all agency objects
     qDeleteAll( m_agencyCache );
 
 #ifdef BUILD_GTFS_REALTIME
     delete m_tripUpdates;
     delete m_alerts;
 #endif
 }
 
 QString ServiceProviderGtfs::updateGtfsDatabaseState( const QString &providerId,
                                                       const QString &feedUrl,
                                                       const QSharedPointer< KConfig > &_cache,
                                                       QVariantHash *stateData )
 {
     // Read 'feedImportFinished' value from provider cache
     QSharedPointer< KConfig > cache = _cache.isNull() ? ServiceProviderGlobal::cache() : _cache;
     KConfigGroup group = cache->group( providerId );
     KConfigGroup gtfsGroup = group.group( "gtfs" );
     QString errorMessage;
     bool importFinished = isGtfsFeedImportFinished( providerId, feedUrl, cache, &errorMessage );
 
     // Update GTFS feed state fields that do not need the import to be finished already
     if ( stateData ) {
         // Data might not be available,
         // the "updateGtfsFeedInfo" operation of the GTFS service can be run to get the data
         qlonglong sizeInBytes = gtfsGroup.readEntry( "feedSizeInBytes", qlonglong(-1) );
         QDateTime lastModified = QDateTime::fromString(
                 gtfsGroup.readEntry("feedModifiedTime", QString()), Qt::ISODate );
         stateData->insert( "gtfsFeedSize", sizeInBytes );
         stateData->insert( "gtfsFeedModifiedTime", lastModified );
     }
 
     // GTFS feed was successfully imported from the currently used feed URL
     if ( importFinished ) {
         // Import was marked as finished, test if the database file still exists and
         // is not empty (some space is needed for the tables also if they are empty)
         QFileInfo fi( GtfsDatabase::databasePath(providerId) );
         if ( fi.exists() && fi.size() > 10000 ) {
             // Try to initialize the database
             if ( !GtfsDatabase::initDatabase(providerId, &errorMessage) ) {
-                kWarning() << "Error initializing the database" << errorMessage;
+                qWarning() << "Error initializing the database" << errorMessage;
 
                 // Update 'feedImportFinished' field in the cache
                 gtfsGroup.writeEntry( "feedImportFinished", false );
 
                 // Write to disk now if someone wants to read the value directly after this function
                 gtfsGroup.sync();
 
                 if ( stateData ) {
                     stateData->insert( "gtfsFeedImported", false );
                     stateData->insert( "statusMessage", errorMessage );
                 }
                 return "gtfs_feed_import_pending";
             }
 
             // Database exists, feed marked as imported and feed URL did not change
             // since the import, set state data and return state "ready"
             if ( stateData ) {
                 stateData->insert( "gtfsFeedImported", true );
 
                 // Insert a status message
                 stateData->insert( "statusMessage",
                                    i18nc("@info/plain", "GTFS feed succesfully imported") );
 
                 // Update GTFS database state fields
                 const QString databasePath = GtfsDatabase::databasePath( providerId );
                 const QFileInfo databaseInfo( databasePath );
                 stateData->insert( "gtfsDatabasePath", databasePath );
                 stateData->insert( "gtfsDatabaseSize", databaseInfo.size() );
                 stateData->insert( "gtfsDatabaseModifiedTime",
                                    databaseInfo.lastModified().toString(Qt::ISODate) );
 
                 // Add an 'updatable' field to the state data
                 const bool updatable =
                         ServiceProviderGtfs::isUpdateAvailable( providerId, feedUrl, cache );
                 stateData->insert( "updatable", updatable );
             }
             return "ready";
         } else {
-            kWarning() << "GTFS database file not found or empty database" << fi.filePath();
+            qWarning() << "GTFS database file not found or empty database" << fi.filePath();
 
             // The provider cache says the import has been finished,
             // but the database file does not exist any longer or is empty
             gtfsGroup.writeEntry( "feedImportFinished", false );
 
             // Write to disk now if someone wants to read the value directly after this function
             gtfsGroup.sync();
 
             // The GTFS feed has not been imported successfully yet
             // or the database file was deleted/corrupted
             if ( stateData ) {
                 stateData->insert( "gtfsFeedImported", false );
                 stateData->insert( "statusMessage", i18nc("@info/plain", "GTFS feed not imported") );
             }
             return "gtfs_feed_import_pending";
         }
     } else {
         // GTFS feed was not imported or the feed URL has changed since the import
         if ( stateData ) {
             stateData->insert( "gtfsFeedImported", false );
             stateData->insert( "statusMessage", errorMessage );
         }
         return "gtfs_feed_import_pending";
     }
 }
 
 bool ServiceProviderGtfs::isTestResultUnchanged( const QString &providerId, const QString &feedUrl,
                                                  const QSharedPointer< KConfig > &cache )
 {
     // The test result changes when the GTFS feed was updated
     return isUpdateAvailable( providerId, feedUrl, cache );
 }
 
 bool ServiceProviderGtfs::isTestResultUnchanged( const QSharedPointer<KConfig> &cache ) const
 {
     return isTestResultUnchanged( data()->id(), data()->feedUrl(), cache );
 }
 
 bool ServiceProviderGtfs::runTests( QString *errorMessage ) const
 {
     Q_UNUSED( errorMessage );
     if ( m_state == Ready ) {
         // The GTFS feed was successfully imported
         return true;
     }
 
     const QUrl feedUrl( m_data->feedUrl() );
     if ( feedUrl.isEmpty() || !feedUrl.isValid() ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "Invalid GTFS feed URL: %1", m_data->feedUrl());
         }
         return false;
     }
 
     // No errors found
     return true;
 }
 
 void ServiceProviderGtfs::updateGtfsDatabase()
 {
     if ( m_service ) {
         kDebug() << "Is already updating, please wait";
         return;
     }
 
     Plasma::DataEngine *engine = qobject_cast< Plasma::DataEngine* >( parent() );
     Q_ASSERT( engine );
     m_service = engine->serviceForSource( "GTFS" );
     KConfigGroup op = m_service->operationDescription("updateGtfsDatabase");
     op.writeEntry( "serviceProviderId", m_data->id() );
     m_service->startOperationCall( op );
 }
 
 #ifdef BUILD_GTFS_REALTIME
 bool ServiceProviderGtfs::isRealtimeDataAvailable() const
 {
     return !m_data->realtimeTripUpdateUrl().isEmpty() || !m_data->realtimeAlertsUrl().isEmpty();
 }
 
 void ServiceProviderGtfs::updateRealtimeData()
 {
 //         m_state = DownloadingFeed;
     if ( !m_data->realtimeTripUpdateUrl().isEmpty() ) {
         KIO::StoredTransferJob *tripUpdatesJob = KIO::storedGet( m_data->realtimeTripUpdateUrl(),
                 KIO::Reload, KIO::Overwrite | KIO::HideProgressInfo );
         connect( tripUpdatesJob, SIGNAL(result(KJob*)), this, SLOT(realtimeTripUpdatesReceived(KJob*)) );
         kDebug() << "Updating GTFS-realtime trip update data" << m_data->realtimeTripUpdateUrl();
     }
 
     if ( !m_data->realtimeAlertsUrl().isEmpty() ) {
         KIO::StoredTransferJob *alertsJob = KIO::storedGet( m_data->realtimeAlertsUrl(),
                 KIO::Reload, KIO::Overwrite | KIO::HideProgressInfo );
         connect( alertsJob, SIGNAL(result(KJob*)), this, SLOT(realtimeAlertsReceived(KJob*)) );
         kDebug() << "Updating GTFS-realtime alerts data" << m_data->realtimeAlertsUrl();
     }
 
     if ( m_data->realtimeTripUpdateUrl().isEmpty() && m_data->realtimeAlertsUrl().isEmpty() ) {
         m_state = Ready;
     }
 }
 
 void ServiceProviderGtfs::realtimeTripUpdatesReceived( KJob *job )
 {
     KIO::StoredTransferJob *transferJob = qobject_cast<KIO::StoredTransferJob*>( job );
     if ( job->error() != 0 ) {
         kDebug() << "Error downloading GTFS-realtime trip updates:" << job->errorString();
         return;
     }
 
     delete m_tripUpdates;
     m_tripUpdates = GtfsRealtimeTripUpdate::fromProtocolBuffer( transferJob->data() );
 
     if ( m_alerts || m_data->realtimeAlertsUrl().isEmpty() ) {
         m_state = Ready;
     }
 }
 
 void ServiceProviderGtfs::realtimeAlertsReceived( KJob *job )
 {
     KIO::StoredTransferJob *transferJob = qobject_cast<KIO::StoredTransferJob*>( job );
     if ( job->error() != 0 ) {
         kDebug() << "Error downloading GTFS-realtime alerts:" << job->errorString();
         return;
     }
 
     delete m_alerts;
     m_alerts = GtfsRealtimeAlert::fromProtocolBuffer( transferJob->data() );
 
     if ( m_tripUpdates || m_data->realtimeTripUpdateUrl().isEmpty() ) {
         m_state = Ready;
     }
 }
 #endif // BUILD_GTFS_REALTIME
 
 void ServiceProviderGtfs::loadAgencyInformation()
 {
     if ( m_state != Ready ) {
         return;
     }
 
     QSqlQuery query( QSqlDatabase::database(m_data->id()) );
     if ( !query.exec("SELECT * FROM agency") ) {
         kDebug() << "Could not load agency information from database:" << query.lastError();
         return;
     }
 
     // Clear previously loaded agency data
     qDeleteAll( m_agencyCache );
     m_agencyCache.clear();
 
     // Read agency records from the database
     QSqlRecord record = query.record();
     const int agencyIdColumn = record.indexOf( "agency_id" );
     const int agencyNameColumn = record.indexOf( "agency_name" );
     const int agencyUrlColumn = record.indexOf( "agency_url" );
     const int agencyTimezoneColumn = record.indexOf( "agency_timezone" );
     const int agencyLanguageColumn = record.indexOf( "agency_lang" );
     const int agencyPhoneColumn = record.indexOf( "agency_phone" );
     while ( query.next() ) {
         AgencyInformation *agency = new AgencyInformation;
         agency->name = query.value( agencyNameColumn ).toString();
         agency->url = query.value( agencyUrlColumn ).toString();
         agency->language = query.value( agencyLanguageColumn ).toString();
         agency->phone = query.value( agencyPhoneColumn ).toString();
 
         const QString timeZone = query.value(agencyTimezoneColumn).toString();
         agency->timezone = new KTimeZone( timeZone.isEmpty() ? m_data->timeZone() : timeZone );
 
         const uint id = query.value( agencyIdColumn ).toUInt();
         m_agencyCache.insert( id, agency );
     }
 }
 
 int ServiceProviderGtfs::AgencyInformation::timeZoneOffset() const
 {
     return timezone && timezone->isValid() ? timezone->currentOffset( Qt::LocalTime ) : 0;
 }
 
 qint64 ServiceProviderGtfs::databaseSize() const
 {
     QFileInfo fi( GtfsDatabase::databasePath(m_data->id()) );
     return fi.size();
 }
 
 ServiceProviderGtfs::AgencyInformation::~AgencyInformation()
 {
     delete timezone;
 }
 
 // NOTE When changing this function, also update ProjectPrivate::gtfsProviderFeatures()
 //      in TimetableMate!
 QList<Enums::ProviderFeature> ServiceProviderGtfs::features() const
 {
     QList<Enums::ProviderFeature> features;
     features << Enums::ProvidesDepartures << Enums::ProvidesArrivals
              << Enums::ProvidesStopSuggestions << Enums::ProvidesRouteInformation
              << Enums::ProvidesStopID << Enums::ProvidesStopGeoPosition;
              // Enums::ProvidesStopsByGeoPosition TODO
 #ifdef BUILD_GTFS_REALTIME
     if ( !m_data->realtimeAlertsUrl().isEmpty() ) {
         features << Enums::ProvidesNews;
     }
     if ( !m_data->realtimeTripUpdateUrl().isEmpty() ) {
         features << Enums::ProvidesDelays;
     }
 #endif
     return features;
 }
 
 QDateTime ServiceProviderGtfs::timeFromSecondsSinceMidnight(
         const QDate &dateAtMidnight, int secondsSinceMidnight, QDate *date ) const
 {
     const int secondsInOneDay = 60 * 60 * 24;
     QDate resultDate = dateAtMidnight;
     while ( secondsSinceMidnight >= secondsInOneDay ) {
         secondsSinceMidnight -= secondsInOneDay;
         resultDate.addDays( 1 );
         if ( date ) {
             date->addDays( 1 );
         }
     }
     return QDateTime( resultDate, QTime(secondsSinceMidnight / (60 * 60),
                                         (secondsSinceMidnight / 60) % 60,
                                         secondsSinceMidnight % 60) );
 }
 
 bool ServiceProviderGtfs::isGtfsFeedImportFinished( const QString &providerId,
                                                     const QString &feedUrl,
                                                     const QSharedPointer<KConfig> &_cache,
                                                     QString *errorMessage )
 {
     const QSharedPointer<KConfig> &cache = _cache.isNull() ? ServiceProviderGlobal::cache() : _cache;
 
     // Check if the GTFS feed import is marked as finished in the cache
     KConfigGroup group = cache->group( providerId );
     KConfigGroup gtfsGroup = group.group( "gtfs" );
     if ( gtfsGroup.readEntry("feedImportFinished", false) ) {
         // GTFS feed import is marked as finished, check if the feed URL has changed since
         if ( feedUrl.isEmpty() ) {
             // Feed URL not given, no change expected here (eg. directly after a finished import)
             return true;
         }
 
         const QString importedGtfsFeedUrl = gtfsGroup.readEntry( "feedUrl", QString() );
         if ( importedGtfsFeedUrl == feedUrl ) {
             // Feed URL did not change, import is finished
             return true;
         } else {
             // Feed URL was modified, re-import needed,
             // update "feedImportFinished" field in the cache
             gtfsGroup.writeEntry( "feedImportFinished", false );
             gtfsGroup.sync();
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "GTFS feed was imported, but the feed URL "
                                       "has changed. Please re-import the feed from the new URL.");
             }
             return false;
         }
     }
 
     // GTFS feed import is marked as not finished or was not found in the cache
     if ( errorMessage ) {
         *errorMessage = i18nc("@info/plain", "GTFS feed not imported. "
                               "Please import it explicitly first.");
     }
     return false;
 }
 
 bool ServiceProviderGtfs::isUpdateAvailable( const QString &providerId, const QString &feedUrl,
                                              const QSharedPointer<KConfig> &_cache )
 {
     const QSharedPointer<KConfig> cache = _cache.isNull() ? ServiceProviderGlobal::cache() : _cache;
     KConfigGroup group = cache->group( providerId );
     KConfigGroup gtfsGroup = group.group( "gtfs" );
     const bool importFinished = isGtfsFeedImportFinished( providerId, feedUrl, cache );
     const QString databasePath = GtfsDatabase::databasePath( providerId );
     const QFileInfo databaseInfo( databasePath );
     const bool databaseReady = importFinished && databaseInfo.exists();
 
     if ( databaseReady ) {
         // Check if an update is available
         const QString feedModifiedTimeString =
                 gtfsGroup.readEntry( "feedModifiedTime", QString() );
         const QDateTime gtfsFeedModifiedTime =
                 QDateTime::fromString( feedModifiedTimeString, Qt::ISODate );
         const QDateTime gtfsDatabaseModifiedTime = databaseInfo.lastModified();
         return gtfsFeedModifiedTime.isValid() && gtfsFeedModifiedTime > gtfsDatabaseModifiedTime;
     }
 
     // GTFS feed not imported or database deleted
     return false;
 }
 
 uint ServiceProviderGtfs::stopIdFromName( const QString &stopName, bool *ok )
 {
     // Try to get the ID for the given stop name. Only select stops, no stations (with one or
     // more sub stops) by requiring 'location_type=0', location_type 1 is for stations.
     // It's fast, because 'stop_name' is part of a compound index in the database.
     QString stopValue = stopName;
     stopValue.replace( '\'', "\'\'" );
 
     QSqlQuery query( QSqlDatabase::database(m_data->id()) );
     query.setForwardOnly( true ); // Don't cache records
     if ( !query.exec("SELECT stops.stop_id FROM stops WHERE stop_name='" + stopValue + "' "
                      "AND (location_type IS NULL OR location_type=0)") )
     {
-        kWarning() << query.lastError();
+        qWarning() << query.lastError();
         kDebug() << query.executedQuery();
         if ( ok ) {
             *ok = false;
         }
         return 0;
     }
 
     QSqlRecord stopRecord = query.record();
     if ( query.next() ) {
         if ( ok ) {
             *ok = true;
         }
         return query.value( query.record().indexOf("stop_id") ).toUInt();
     } else {
         bool _ok;
         const uint stopId = stopName.toUInt( &_ok );
         if ( ok ) {
             *ok = _ok;
         }
         if ( !_ok ) {
             kDebug() << "No stop with the given name found (needs the exact name):" << stopName;
             return 0;
         }
         return stopId;
     }
 }
 
 void ServiceProviderGtfs::requestDepartures( const DepartureRequest &request )
 {
     requestDeparturesOrArrivals( &request );
 }
 
 void ServiceProviderGtfs::requestArrivals( const ArrivalRequest &request )
 {
     requestDeparturesOrArrivals( &request );
 }
 
 void ServiceProviderGtfs::requestDeparturesOrArrivals( const DepartureRequest *request )
 {
     uint stopId;
     if ( !request->stopId().isEmpty() ) {
         // A stop ID is available, testing for it's ID in stop_times is not necessary
         bool ok;
         stopId = request->stopId().toUInt( &ok );
         if ( !ok ) {
-            kWarning() << "Invalid stop ID" << request->stopId() << "only numeric IDs allowed";
+            qWarning() << "Invalid stop ID" << request->stopId() << "only numeric IDs allowed";
             return;
         }
     } else {
         // Try to get the ID for the given stop name.
         bool ok;
         stopId = stopIdFromName( request->stop(), &ok );
         if ( !ok ) {
             emit requestFailed( this, ErrorParsingFailed /*TODO*/,
                     "No stop with the given name found (needs the exact name or an ID): "
                     + request->stop(),
                     QUrl(), request );
             return;
         }
     }
 
     QSqlQuery query( QSqlDatabase::database(m_data->id()) );
     query.setForwardOnly( true ); // Don't cache records
 
 // This creates a temporary table to calculate min/max fares for departures.
 // These values should be added into the db while importing, doing it here takes too long
 //     const QString createJoinedFareTable = "CREATE TEMPORARY TABLE IF NOT EXISTS tmp_fares AS "
 //             "SELECT * FROM fare_rules JOIN fare_attributes USING (fare_id);";
 //     if ( !query.prepare(createJoinedFareTable) || !query.exec() ) {
 //         kDebug() << "Error while creating a temporary table fore min/max fare calculation:"
 //                  << query.lastError();
 //         kDebug() << query.executedQuery();
 //         return;
 //     }
 
     // Query the needed departure info from the database.
     // It's fast, because all JOINs are done using INTEGER PRIMARY KEYs and
     // because 'stop_id' and 'departure_time' are part of a compound index in the database.
     // Sorting by 'arrival_time' may be a bit slower because is has no index in the database,
     // but if arrival_time values do not differ too much from the deaprture_time values, they
     // are also already sorted.
     // The tables 'calendar' and 'calendar_dates' are also fully implemented by the query below.
     // TODO: Create a new (temporary) table for each connected departure/arrival source and use
     //       that (much smaller) table here for performance reasons
     const QString routeSeparator = "||";
     const QTime time = request->dateTime().time();
     const QString queryString = QString(
             "SELECT times.departure_time, times.arrival_time, times.stop_headsign, "
                    "routes.route_type, routes.route_short_name, routes.route_long_name, "
                    "trips.trip_headsign, routes.agency_id, stops.stop_id, trips.trip_id, "
                    "routes.route_id, times.stop_sequence, "
                    "( SELECT group_concat(route_stop.stop_name, '%5') AS route_stops "
                      "FROM stop_times AS route_times INNER JOIN stops AS route_stop USING (stop_id) "
                      "WHERE route_times.trip_id=times.trip_id AND route_times.stop_sequence %4= times.stop_sequence "
                      "ORDER BY departure_time ) AS route_stops, "
                    "( SELECT group_concat(route_times.departure_time, '%5') AS route_times "
                      "FROM stop_times AS route_times "
                      "WHERE route_times.trip_id=times.trip_id AND route_times.stop_sequence %4= times.stop_sequence "
                      "ORDER BY departure_time ) AS route_times "
 //                    "( SELECT min(price) FROM tmp_fares WHERE origin_id=stops.zone_id AND price>0 ) AS min_price, "
 //                    "( SELECT max(price) FROM tmp_fares WHERE origin_id=stops.zone_id ) AS max_price, "
 //                    "( SELECT currency_type FROM tmp_fares WHERE origin_id=stops.zone_id LIMIT 1 ) AS currency_type "
             "FROM stops INNER JOIN stop_times AS times USING (stop_id) "
                        "INNER JOIN trips USING (trip_id) "
                        "INNER JOIN routes USING (route_id) "
                        "LEFT JOIN calendar USING (service_id) "
                        "LEFT JOIN calendar_dates ON (trips.service_id=calendar_dates.service_id "
                                                     "AND strftime('%Y%m%d') LIKE calendar_dates.date) "
             "WHERE stop_id=%1 AND departure_time>%2 "
                   "AND (calendar_dates.date IS NULL " // No matching record in calendar_dates table for today
                        "OR NOT (calendar_dates.exception_type=2)) " // Journey is not removed today
                   "AND (calendar.weekdays IS NULL " // No matching record in calendar table => always available
                        "OR (strftime('%Y%m%d') BETWEEN calendar.start_date " // Current date is in the range...
                                               "AND calendar.end_date " // ...where the service is available...
                            "AND substr(calendar.weekdays, strftime('%w') + 1, 1)='1') " // ...and it's available at the current weekday
                        "OR (calendar_dates.date IS NOT NULL " // Or there is a matching record in calendar_dates for today...
                            "AND calendar_dates.exception_type=1)) " // ...and this record adds availability of the service for today
             "ORDER BY departure_time "
             "LIMIT %3" )
             .arg( stopId )
             .arg( time.hour() * 60 * 60 + time.minute() * 60 + time.second() )
             .arg( request->count() )
             .arg( request->parseMode() == ParseForArrivals ? '<' : '>' ) // For arrivals route_stops/route_times need stops before the home stop
             .arg( routeSeparator );
     if ( !query.prepare(queryString) || !query.exec() ) {
         kDebug() << "Error while querying for departures:" << query.lastError();
         kDebug() << query.executedQuery();
         return;
     }
     if ( query.size() == 0 ) {
         kDebug() << "Got an empty record";
         return;
     }
     kDebug() << "Query executed";
     kDebug() << query.executedQuery();
 
     QSqlRecord record = query.record();
     const int agencyIdColumn = record.indexOf( "agency_id" );
     const int tripIdColumn = record.indexOf( "trip_id" );
     const int routeIdColumn = record.indexOf( "route_id" );
     const int stopIdColumn = record.indexOf( "stop_id" );
     const int arrivalTimeColumn = record.indexOf( "arrival_time" );
     const int departureTimeColumn = record.indexOf( "departure_time" );
     const int routeShortNameColumn = record.indexOf( "route_short_name" );
     const int routeLongNameColumn = record.indexOf( "route_long_name" );
     const int routeTypeColumn = record.indexOf( "route_type" );
     const int tripHeadsignColumn = record.indexOf( "trip_headsign" );
     const int stopSequenceColumn = record.indexOf( "stop_sequence" );
     const int stopHeadsignColumn = record.indexOf( "stop_headsign" );
     const int routeStopsColumn = record.indexOf( "route_stops" );
     const int routeTimesColumn = record.indexOf( "route_times" );
 //     const int fareMinPriceColumn = record.indexOf( "min_price" );
 //     const int fareMaxPriceColumn = record.indexOf( "max_price" );
 //     const int fareCurrencyColumn  = record.indexOf( "currency_type" );
 
     // Prepare agency information, if only one is given, it is used for all records
     AgencyInformation *agency = 0;
     if ( m_agencyCache.count() == 1 ) {
         agency = m_agencyCache.values().first();
     }
 
     // Create a list of DepartureInfo objects from the query result
     DepartureInfoList departures;
     while ( query.next() ) {
         const QDate dateAtMidnight = request->dateTime().date();
 
         // Load agency information from cache
         const QVariant agencyIdValue = query.value( agencyIdColumn );
         if ( m_agencyCache.count() > 1 ) {
             Q_ASSERT( agencyIdValue.isValid() ); // GTFS says, that agency_id can only be null, if there is only one agency
             agency = m_agencyCache[ agencyIdValue.toUInt() ];
         }
 
         // Time values are stored as seconds since midnight of the associated date
         int arrivalTimeValue = query.value(arrivalTimeColumn).toInt();
         int departureTimeValue = query.value(departureTimeColumn).toInt();
 
         QDateTime arrivalTime = timeFromSecondsSinceMidnight( dateAtMidnight, arrivalTimeValue );
         QDateTime departureTime = timeFromSecondsSinceMidnight( dateAtMidnight, departureTimeValue );
 
         // Apply timezone offset
         int offsetSeconds = agency ? agency->timeZoneOffset() : 0;
         if ( offsetSeconds != 0 ) {
             arrivalTime.addSecs( offsetSeconds );
             departureTime.addSecs( offsetSeconds );
         }
 
         TimetableData data;
         data[ Enums::DepartureDateTime ] = request->parseMode() == ParseForArrivals ? arrivalTime : departureTime;
         data[ Enums::TypeOfVehicle ] = vehicleTypeFromGtfsRouteType( query.value(routeTypeColumn).toInt() );
         data[ Enums::Operator ] = agency ? agency->name : QString();
 
         const QString transportLine = query.value(routeShortNameColumn).toString();
         data[ Enums::TransportLine ] = !transportLine.isEmpty() ? transportLine
                          : query.value(routeLongNameColumn).toString();
 
         const QStringList routeStops = query.value(routeStopsColumn).toString().split( routeSeparator );
         if ( routeStops.isEmpty() ) {
             // This happens, if the current departure is actually no departure, but an arrival at
             // the target station and vice versa for arrivals.
             continue;
         }
         data[ Enums::RouteStops ] = routeStops;
         data[ Enums::RouteExactStops ] = routeStops.count();
 
         const QString tripHeadsign = query.value(tripHeadsignColumn).toString();
         const QString stopHeadsign = query.value(stopHeadsignColumn).toString();
         data[ Enums::Target ] = !tripHeadsign.isEmpty() ? tripHeadsign
                 : (!stopHeadsign.isEmpty() ? stopHeadsign
                    : (request->parseMode() == ParseForArrivals
                       ? routeStops.first() : routeStops.last()));
 
         const QStringList routeTimeValues = query.value(routeTimesColumn).toString().split( routeSeparator );
         QVariantList routeTimes;
         foreach ( const QString routeTimeValue, routeTimeValues ) {
             routeTimes << timeFromSecondsSinceMidnight( dateAtMidnight, routeTimeValue.toInt() );
         }
         data[ Enums::RouteTimes ] = routeTimes;
 
 //         const QString symbol = KCurrencyCode( query.value(fareCurrencyColumn).toString() ).defaultSymbol();
 //         data[ Pricing ] = KGlobal::locale()->formatMoney(
 //                 query.value(fareMinPriceColumn).toDouble(), symbol ) + " - " +
 //                 KGlobal::locale()->formatMoney( query.value(fareMaxPriceColumn).toDouble(), symbol );
 
 #ifdef BUILD_GTFS_REALTIME
         if ( m_alerts ) {
             QStringList journeyNews;
             QString journeyNewsLink;
             foreach ( const GtfsRealtimeAlert &alert, *m_alerts ) {
                 if ( alert.isActiveAt(QDateTime::currentDateTime()) ) {
                     journeyNews << alert.description;
                     journeyNewsLink = alert.url;
                 }
             }
             if ( !journeyNews.isEmpty() ) {
                 data[ Enums::JourneyNews ] = journeyNews.join( ", " );
                 data[ Enums::JourneyNewsLink ] = journeyNewsLink;
             }
         }
 
         if ( m_tripUpdates ) {
             uint tripId = query.value(tripIdColumn).toUInt();
             uint routeId = query.value(routeIdColumn).toUInt();
             uint stopId = query.value(stopIdColumn).toUInt();
             uint stopSequence = query.value(stopSequenceColumn).toUInt();
             foreach ( const GtfsRealtimeTripUpdate &tripUpdate, *m_tripUpdates ) {
                 if ( (tripUpdate.tripId > 0 && tripId == tripUpdate.tripId) ||
                      (tripUpdate.routeId > 0 && routeId == tripUpdate.routeId) ||
                      (tripUpdate.tripId <= 0 && tripUpdate.routeId <= 0) )
                 {
                     kDebug() << "tripId or routeId matched or not queried!";
                     foreach ( const GtfsRealtimeStopTimeUpdate &stopTimeUpdate,
                               tripUpdate.stopTimeUpdates )
                     {
                         if ( (stopTimeUpdate.stopId > 0 && stopId == stopTimeUpdate.stopId) ||
                              (stopTimeUpdate.stopSequence > 0 &&
                               stopSequence == stopTimeUpdate.stopSequence) ||
                              (stopTimeUpdate.stopId <= 0 && stopTimeUpdate.stopSequence <= 0) )
                         {
                             kDebug() << "stopId matched or stopsequence matched or not queried!";
                             // Found a matching stop time update
                             kDebug() << "Delays:" << stopTimeUpdate.arrivalDelay << stopTimeUpdate.departureDelay;
                         }
                     }
                 }
             }
         }
 #endif
 
         // Create new departure information object and add it to the departure list.
         // Do not use any corrections in the DepartureInfo constructor, because all values
         // from the database are already in the correct format
         departures << DepartureInfoPtr( new DepartureInfo(data, PublicTransportInfo::NoCorrection) );
     }
 
     // TODO Do not use a list of pointers here, maybe use data sharing for PublicTransportInfo/StopInfo?
     // The objects in departures are deleted in a connected slot in the data engine...
     const ArrivalRequest *arrivalRequest = dynamic_cast< const ArrivalRequest* >( request );
     if ( arrivalRequest ) {
         emit arrivalsReceived( this, QUrl(), departures, GlobalTimetableInfo(), *arrivalRequest );
     } else {
         emit departuresReceived( this, QUrl(), departures, GlobalTimetableInfo(), *request );
     }
 }
 
 void ServiceProviderGtfs::requestStopSuggestions( const StopSuggestionRequest &request )
 {
     QSqlQuery query( QSqlDatabase::database(m_data->id()) );
     query.setForwardOnly( true );
     QString stopValue = request.stop();
     stopValue.replace( '\'', "\'\'" );
     if ( !query.prepare(QString("SELECT * FROM stops WHERE stop_name LIKE '%%2%' LIMIT %1")
                         .arg(STOP_SUGGESTION_LIMIT).arg(stopValue))
          || !query.exec() )
     {
         // Check of the error is a "disk I/O error", ie. the database file may have been deleted
         checkForDiskIoError( query.lastError(), &request );
         kDebug() << query.lastError();
         kDebug() << query.executedQuery();
         return;
     }
     emit stopsReceived( this, QUrl(), stopsFromQuery(&query, &request), request );
 }
 
 void ServiceProviderGtfs::requestStopsByGeoPosition( const StopsByGeoPositionRequest &request )
 {
     QSqlQuery query( QSqlDatabase::database(m_data->id()) );
     query.setForwardOnly( true );
     kDebug() << "Get stops near:" << request.distance() << "meters ==" << (request.distance() * 0.009 / 2);
     if ( !query.prepare(QString("SELECT * FROM stops "
                                 "WHERE stop_lon between (%2-%4) and (%2+%4) "
                                 "AND stop_lat between (%3-%4) and (%3+%4) LIMIT %1")
                         .arg(STOP_SUGGESTION_LIMIT).arg(request.longitude()).arg(request.latitude())
                         .arg(request.distance() * 0.000009 / 2)) // Calculate degree from meters = 360/40,070,000
          || !query.exec() )
     {
         // Check of the error is a "disk I/O error", ie. the database file may have been deleted
         checkForDiskIoError( query.lastError(), &request );
         kDebug() << query.lastError();
         kDebug() << query.executedQuery();
         return;
     }
     emit stopsReceived( this, QUrl(), stopsFromQuery(&query, &request), request );
 }
 
 StopInfoList ServiceProviderGtfs::stopsFromQuery( QSqlQuery *query,
                                                   const StopSuggestionRequest *request ) const {
     QSqlRecord record = query->record();
     const int stopIdColumn = record.indexOf( "stop_id" );
     const int stopNameColumn = record.indexOf( "stop_name" );
     const int stopLongitudeColumn = record.indexOf( "stop_lon" );
     const int stopLatitudeColumn = record.indexOf( "stop_lat" );
 
     StopInfoList stops;
     while ( query->next() ) {
         const QString stopName = query->value(stopNameColumn).toString();
         const QString id = query->value(stopIdColumn).toString();
         const qreal longitude = query->value(stopLongitudeColumn).toReal();
         const qreal latitude = query->value(stopLatitudeColumn).toReal();
         int weight = -1;
 
         if ( !dynamic_cast<const StopsByGeoPositionRequest*>(request) ) {
             // Compute a weight value for the found stop name.
             // The less different the found stop name is compared to the search string, the higher
             // it's weight gets. If the found name equals the search string, the weight becomes 100.
             // Use 84 as maximal starting weight value (if stopName doesn't equal the search string),
             // because maximally 15 bonus points are added which makes 99, less than total equality 100.
             weight = stopName == request->stop() ? 100
                     : 84 - qMin( 84, qAbs(stopName.length() - request->stop().length()) );
 
             if ( weight < 100 && stopName.startsWith(request->stop()) ) {
                 // 15 weight points bonus if the found stop name starts with the search string
                 weight = qMin( 100, weight + 15 );
             }
             if ( weight < 100 ) {
                 // Test if the search string is the start of a new word in stopName
                 // Start at 2, because startsWith is already tested above and at least a space must
                 // follow to start a new word
                 int pos = stopName.indexOf( request->stop(), 2, Qt::CaseInsensitive );
 
                 if ( pos != -1 && stopName[pos - 1].isSpace() ) {
                     // 10 weight points bonus if a word in the found stop name
                     // starts with the search string
                     weight = qMin( 100, weight + 10 );
                 }
             }
         }
 
         stops << StopInfoPtr( new StopInfo(stopName, id, weight,
                                            longitude, latitude, request->city()) );
     }
 
     if ( stops.isEmpty() ) {
         kDebug() << "No stops found";
     }
     return stops;
 }
 
 bool ServiceProviderGtfs::checkForDiskIoError( const QSqlError &error,
                                                          const AbstractRequest *request )
 {
     Q_UNUSED( request );
 
     // Check if the error is a "disk I/O" error or a "no such table" error,
     // ie. the database file may have been deleted/corrupted.
     // The error numbers (1, 10) are database dependend and work with SQLite
     if ( error.number() == 10 || error.number() == 1 ) {
-        kWarning() << "Disk I/O error reported from database, reimport the GTFS feed"
+        qWarning() << "Disk I/O error reported from database, reimport the GTFS feed"
                    << error.text();
         emit requestFailed( this, ErrorParsingFailed,
                 i18nc("@info/plain", "The GTFS database is corrupted, please reimport "
                       "the GTFS feed"), QUrl(), request );
 
         m_state = Initializing;
         QString errorText;
         if ( !GtfsDatabase::initDatabase(m_data->id(), &errorText) ) {
             kDebug() << "Error initializing the database" << errorText;
             m_state = Error;
             return true;
         }
 
         QFileInfo fi( GtfsDatabase::databasePath(m_data->id()) );
         if ( fi.exists() && fi.size() > 10000 ) {
             loadAgencyInformation();
 #ifdef BUILD_GTFS_REALTIME
             updateRealtimeData();
 #endif
         }
         return true;
     } else {
         return false;
     }
 }
 
 Enums::VehicleType ServiceProviderGtfs::vehicleTypeFromGtfsRouteType( int gtfsRouteType )
 {
     switch ( gtfsRouteType ) {
     case 0: // Tram, Streetcar, Light rail. Any light rail or street level system within a metropolitan area.
         return Enums::Tram;
     case 1: // Subway, Metro. Any underground rail system within a metropolitan area.
         return Enums::Subway;
     case 2: // Rail. Used for intercity or long-distance travel.
         return Enums::IntercityTrain;
     case 3: // Bus. Used for short- and long-distance bus routes.
         return Enums::Bus;
     case 4: // Ferry. Used for short- and long-distance boat service.
         return Enums::Ferry;
     case 5: // Cable car. Used for street-level cable cars where the cable runs beneath the car.
         return Enums::TrolleyBus;
     case 6: // Gondola, Suspended cable car. Typically used for aerial cable cars where the car is suspended from the cable.
         return Enums::UnknownVehicleType; // TODO Add new type to VehicleType: eg. Gondola
     case 7: // Funicular. Any rail system designed for steep inclines.
         return Enums::UnknownVehicleType; // TODO Add new type to VehicleType: eg. Funicular
     default:
         return Enums::UnknownVehicleType;
     }
 }
diff --git a/engine/publictransportdataengine.cpp b/engine/publictransportdataengine.cpp
index 8fe024f..7af437e 100644
--- a/engine/publictransportdataengine.cpp
+++ b/engine/publictransportdataengine.cpp
@@ -1,2744 +1,2744 @@
 /*
  *   Copyright 2013 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 "publictransportdataengine.h"
 
 // Own includes
 #include "serviceprovider.h"
 #include "serviceproviderdata.h"
 #include "serviceprovidertestdata.h"
 #include "serviceproviderglobal.h"
 #include "global.h"
 #include "request.h"
 #include "timetableservice.h"
 #include "datasource.h"
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     #include "script/serviceproviderscript.h"
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     #include "gtfs/serviceprovidergtfs.h"
     #include "gtfs/gtfsservice.h"
 #endif
 
 // KDE/Plasma includes
 #include <Plasma/DataContainer>
 #include <KStandardDirs>
 
 // Qt includes
 #include <QFileSystemWatcher>
 #include <QFileInfo>
 #include <QTimer>
 #include <QDebug>
 #include <QDBusConnection>
 
 const int PublicTransportEngine::DEFAULT_TIME_OFFSET = 0;
 const int PublicTransportEngine::PROVIDER_CLEANUP_TIMEOUT = 10000; // 10 seconds
 
 Plasma::Service* PublicTransportEngine::serviceForSource( const QString &name )
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     // Return the GTFS service for "GTFS" or "gtfs" names
     if ( name.toLower() == QLatin1String("gtfs") ) {
         GtfsService *service = new GtfsService( name, this );
         service->setDestination( name );
         connect( service, SIGNAL(finished(Plasma::ServiceJob*)),
                  this, SLOT(gtfsServiceJobFinished(Plasma::ServiceJob*)) );
         return service;
     }
 #endif
 
     // If the name of a data requesting source is given, return the timetable service
     const SourceType type = sourceTypeFromName( name );
     if ( isDataRequestingSourceType(type) ) {
         const QString nonAmbiguousName = disambiguateSourceName( name );
         if ( m_dataSources.contains(nonAmbiguousName) ) {
             // Data source exists
             TimetableService *service = new TimetableService( this, name, this );
             service->setDestination( name );
             return service;
         }
     }
 
     // No service for the given name found
     return 0;
 }
 
 void PublicTransportEngine::publishData( DataSource *dataSource,
                                          const QString &newlyRequestedProviderId )
 {
     Q_ASSERT( dataSource );
     TimetableDataSource *timetableDataSource = dynamic_cast< TimetableDataSource* >( dataSource );
     if ( timetableDataSource ) {
         foreach ( const QString &usingDataSource, timetableDataSource->usingDataSources() ) {
             setData( usingDataSource, timetableDataSource->data() );
         }
         return;
     }
 
     setData( dataSource->name(), dataSource->data() );
 
     ProvidersDataSource *providersSource = dynamic_cast< ProvidersDataSource* >( dataSource );
     if ( providersSource ) {
         // Update "ServiceProvider <id>" sources, which are also contained in the
         // DataSource object for the "ServiceProviders" data source.
         // Check which data sources of changed providers of that type are connected
         QStringList sources = Plasma::DataEngine::sources();
         const QStringList changedProviders = providersSource->takeChangedProviders();
         foreach ( const QString changedProviderId, changedProviders ) {
             const QString providerSource =
                     sourceTypeKeyword(ServiceProviderSource) + ' ' + changedProviderId;
             if ( sources.contains(providerSource) ) {
                 // Found a data source for the current changed provider, clear it and set new data
                 removeAllData( providerSource );
                 setData( providerSource, providersSource->providerData(changedProviderId) );
             }
         }
 
         if ( !newlyRequestedProviderId.isEmpty() ) {
             const QString providerSource =
                     sourceTypeKeyword(ServiceProviderSource) + ' ' + newlyRequestedProviderId;
             removeAllData( providerSource );
             setData( providerSource, providersSource->providerData(newlyRequestedProviderId) );
         }
     }
 }
 
 ProvidersDataSource *PublicTransportEngine::providersDataSource() const
 {
     const QString name = sourceTypeKeyword( ServiceProvidersSource );
     ProvidersDataSource *dataSource = dynamic_cast< ProvidersDataSource* >( m_dataSources[name] );
     Q_ASSERT_X( dataSource, "PublicTransportEngine::providersDataSource()",
                 "ProvidersDataSource is not available in m_dataSources!" );
     return dataSource;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
 bool PublicTransportEngine::tryToStartGtfsFeedImportJob( Plasma::ServiceJob *job )
 {
     Q_ASSERT( job );
     updateServiceProviderSource();
     ProvidersDataSource *dataSource = providersDataSource();
     Q_ASSERT( dataSource );
     const QString providerId = job->property( "serviceProviderId" ).toString();
     if ( dataSource->providerState(providerId) == QLatin1String("importing_gtfs_feed") ) {
         // GTFS feed already gets imported, cannot start another import job
         return false;
     }
 
     // Update provider state in service provider data source(s)
     QVariantHash stateData = dataSource->providerStateData( providerId );
     const QString databasePath = GtfsDatabase::databasePath( providerId );
     stateData[ "gtfsDatabasePath" ] = databasePath;
     stateData[ "gtfsDatabaseSize" ] = 0;
     stateData[ "progress" ] = 0;
 
     QString state;
     if ( job->operationName() == QLatin1String("importGtfsFeed") ) {
         state = "importing_gtfs_feed";
     } else if ( job->operationName() == QLatin1String("deleteGtfsDatabase") ) {
         state = "gtfs_feed_import_pending";
     } else {
         // The operations "updateGtfsDatabase" and "updateGtfsFeedInfo" can run in the background
         state = "ready";
     }
     dataSource->setProviderState( providerId, state, stateData );
 
     // Store the state in the cache
     QSharedPointer< KConfig > cache = ServiceProviderGlobal::cache();
     KConfigGroup group = cache->group( providerId );
     group.writeEntry( "state", state );
     KConfigGroup stateGroup = group.group( "stateData" );
     for ( QVariantHash::ConstIterator it = stateData.constBegin();
           it != stateData.constEnd(); ++it )
     {
         if ( isStateDataCached(it.key()) ) {
             stateGroup.writeEntry( it.key(), it.value() );
         }
     }
 
     publishData( dataSource );
 
     // Connect to messages of the job to update the provider state
     connect( job, SIGNAL(infoMessage(KJob*,QString,QString)),
              this, SLOT(gtfsImportJobInfoMessage(KJob*,QString,QString)) );
     connect( job, SIGNAL(percent(KJob*,ulong)),
              this, SLOT(gtfsImportJobPercent(KJob*,ulong)) );
 
     // The import job can be started
     return true;
 }
 
 void PublicTransportEngine::gtfsServiceJobFinished( Plasma::ServiceJob *job )
 {
     // Disconnect messages of the job
     disconnect( job, SIGNAL(infoMessage(KJob*,QString,QString)),
                 this, SLOT(gtfsImportJobInfoMessage(KJob*,QString,QString)) );
     disconnect( job, SIGNAL(percent(KJob*,ulong)),
                 this, SLOT(gtfsImportJobPercent(KJob*,ulong)) );
 
     // Check that the job was not canceled because another database job was already running
     const bool canAccessGtfsDatabase = job->property("canAccessGtfsDatabase").toBool();
     const bool isAccessingGtfsDatabase = job->property("isAccessingGtfsDatabase").toBool();
     const QString providerId = job->property( "serviceProviderId" ).toString();
     if ( (!canAccessGtfsDatabase && isAccessingGtfsDatabase) || providerId.isEmpty() ) {
         // Invalid job or cancelled, because another import job is already running
         // for the provider
         return;
     }
 
     // Reset state in "ServiceProviders", "ServiceProvider <id>" data sources
     // Do not read and give the current feed URL for the provider to updateProviderState(),
     // because the feed URL should not have changed since the beginning of the feed import
     QVariantHash stateData;
     const QString state = updateProviderState( providerId, &stateData, "GTFS", QString(), false );
     ProvidersDataSource *dataSource = providersDataSource();
     dataSource->setProviderState( providerId, state, stateData );
 
     publishData( dataSource );
 }
 
 void PublicTransportEngine::gtfsImportJobInfoMessage( KJob *job, const QString &plain,
                                                       const QString &rich )
 {
     // Update "ServiceProviders", "ServiceProvider <id>" data sources
     const QString providerId = job->property( "serviceProviderId" ).toString();
     ProvidersDataSource *dataSource = providersDataSource();
     QVariantHash stateData = dataSource->providerStateData( providerId );
     stateData[ "statusMessage" ] = plain;
     if ( rich.isEmpty() ) {
         stateData.remove( "statusMessageRich" );
     } else {
         stateData[ "statusMessageRich" ] = rich;
     }
     dataSource->setProviderStateData( providerId, stateData );
     publishData( dataSource );
 }
 
 void PublicTransportEngine::gtfsImportJobPercent( KJob *job, ulong percent )
 {
     // Update "ServiceProviders", "ServiceProvider <id>" data sources
     const QString providerId = job->property( "serviceProviderId" ).toString();
     ProvidersDataSource *dataSource = providersDataSource();
     QVariantHash stateData = dataSource->providerStateData( providerId );
     stateData[ "progress" ] = int( percent );
     dataSource->setProviderStateData( providerId, stateData );
     publishData( dataSource );
 }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
 PublicTransportEngine::PublicTransportEngine( QObject* parent, const QVariantList& args )
         : Plasma::DataEngine( parent, args ),
         m_fileSystemWatcher(0), m_providerUpdateDelayTimer(0), m_cleanupTimer(0)
 {
     // We ignore any arguments - data engines do not have much use for them
     Q_UNUSED( args )
 
     // This prevents applets from setting an unnecessarily high update interval
     // and using too much CPU.
     // 60 seconds should be enough, departure / arrival times have minute precision (except for GTFS).
     setMinimumPollingInterval( 60000 );
 
     // Cleanup the cache from obsolete data for providers that were uninstalled
     // while the engine was not running
     ServiceProviderGlobal::cleanupCache();
 
     // Get notified when data sources are no longer used
     connect( this, SIGNAL(sourceRemoved(QString)), this, SLOT(slotSourceRemoved(QString)) );
 
     // Get notified when the network state changes to update data sources,
     // which update timers were missed because of missing network connection
     QDBusConnection::sessionBus().connect( "org.kde.kded", "/modules/networkstatus",
                                            "org.kde.Solid.Networking.Client", "statusChanged",
                                            this, SLOT(networkStateChanged(uint)) );
 
     // Create "ServiceProviders" and "ServiceProvider [providerId]" data source object
     const QString name = sourceTypeKeyword( ServiceProvidersSource );
     m_dataSources.insert( name, new ProvidersDataSource(name) );
     updateServiceProviderSource();
 
     // Ensure the local provider installation directory exists in the users HOME and will not
     // get removed, by creating a small file in it so that the directory is never empty.
     // If an installation directory gets removed, the file system watcher would need to watch the
     // parent directory instead to get notified when it gets created again.
     const QString installationSubDirectory = ServiceProviderGlobal::installationSubDirectory();
     const QString saveDir = KGlobal::dirs()->saveLocation( "data", installationSubDirectory );
     QFile saveDirKeeper( saveDir + "Do not remove this directory" );
     saveDirKeeper.open( QIODevice::WriteOnly );
     saveDirKeeper.write( "If this directory gets removed, PublicTransport will not get notified "
             "about installed provider files in that directory." );
     saveDirKeeper.close();
 
     // Create a file system watcher for the provider plugin installation directories
     // to get notified about new/modified/removed providers
     const QStringList directories = KGlobal::dirs()->findDirs( "data", installationSubDirectory );
     m_fileSystemWatcher = new QFileSystemWatcher( directories );
     connect( m_fileSystemWatcher, SIGNAL(directoryChanged(QString)),
              this, SLOT(serviceProviderDirChanged(QString)) );
 }
 
 PublicTransportEngine::~PublicTransportEngine()
 {
     if ( !m_runningSources.isEmpty() || !m_providers.isEmpty() ) {
         qDebug() << m_runningSources.count() << "data sources are still being updated,"
                  << m_providers.count() << "providers used, abort and delete all providers";
         QStringList providerIds = m_providers.keys();
         foreach ( const QString &providerId, providerIds ) {
             deleteProvider( providerId, false );
         }
     }
 
     delete m_fileSystemWatcher;
     delete m_providerUpdateDelayTimer;
     qDeleteAll( m_dataSources );
     m_dataSources.clear();
 
     // Providers cached in m_cachedProviders get deleted automatically (QSharedPointer)
     // and need no special handling, since they are not used currently
 }
 
 QStringList PublicTransportEngine::sources() const
 {
     QStringList sources = Plasma::DataEngine::sources();
     sources << sourceTypeKeyword(LocationsSource)
             << sourceTypeKeyword(ServiceProvidersSource)
             << sourceTypeKeyword(ErroneousServiceProvidersSource)
             << sourceTypeKeyword(VehicleTypesSource);
     sources.removeDuplicates();
     return sources;
 }
 
 void PublicTransportEngine::networkStateChanged( uint state )
 {
     if ( state != 4 ) {
         // 4 => Connected, see Solid::Networking::Status
         return;
     }
 
     // Network is connected again, check for missed update timers in connected data sources
     for ( QHash<QString, DataSource*>::ConstIterator it = m_dataSources.constBegin();
           it != m_dataSources.constEnd(); ++it )
     {
         // Check if the current data source is a timetable data source, without running update
         TimetableDataSource *dataSource = dynamic_cast< TimetableDataSource* >( *it );
         if ( !dataSource || m_runningSources.contains(it.key()) ) {
             continue;
         }
 
         // Check if the next automatic update time was missed (stored in the data source)
         const QDateTime nextAutomaticUpdate = dataSource->value("nextAutomaticUpdate").toDateTime();
         if ( nextAutomaticUpdate <= QDateTime::currentDateTime() ) {
             // Found a timetable data source that should have been updated already and
             // is not currently being updated (not in m_runningSources).
             // This happens if there was no network connection while an automatic update
             // was triggered. If the system is suspended the QTimer's for automatic updates
             // are not triggered at all.
             // Do now manually request updates for all connected sources, ie. do what should
             // have been done in updateTimeout().
             foreach ( const QString &sourceName, dataSource->usingDataSources() ) {
                 updateTimetableDataSource( SourceRequestData(sourceName) );
             }
         }
     }
 }
 
 bool PublicTransportEngine::isProviderUsed( const QString &providerId )
 {
     // Check if a request is currently running for the provider
     foreach ( const QString &runningSource, m_runningSources ) {
         if ( runningSource.contains(providerId) ) {
             return true;
         }
     }
 
     // Check if a data source is connected that uses the provider
     for ( QHash< QString, DataSource* >::ConstIterator it = m_dataSources.constBegin();
           it != m_dataSources.constEnd(); ++it )
     {
         Q_ASSERT( *it );
         TimetableDataSource *dataSource = dynamic_cast< TimetableDataSource* >( *it );
         if ( dataSource && dataSource->providerId() == providerId ) {
             return true;
         }
     }
 
     // The provider is not used any longer by the engine
     return false;
 }
 
 void PublicTransportEngine::slotSourceRemoved( const QString &sourceName )
 {
     const QString nonAmbiguousName = disambiguateSourceName( sourceName );
     if ( m_dataSources.contains(nonAmbiguousName) ) {
         // If this is a timetable data source, which might be associated with multiple
         // ambiguous source names, check if this data source is still connected under other names
         TimetableDataSource *timetableDataSource =
                 dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
         if ( timetableDataSource ) {
             timetableDataSource->removeUsingDataSource( sourceName );
             if ( timetableDataSource->usageCount() > 0 ) {
                 // The TimetableDataSource object is still used by other connected data sources
                 return;
             }
         }
 
         if ( sourceName == sourceTypeKeyword(ServiceProvidersSource) ) {
             // Do not remove ServiceProviders data source
             return;
         }
 
         // If a provider was used by the source,
         // remove the provider if it is not used by another source
         const DataSource *dataSource = m_dataSources.take( nonAmbiguousName );
         Q_ASSERT( dataSource );
         if ( dataSource->data().contains("serviceProvider") ) {
             const QString providerId = dataSource->value("serviceProvider").toString();
             if ( !providerId.isEmpty() && !isProviderUsed(providerId) ) {
                 // Move provider from the list of used providers to the list of cached providers
                 m_cachedProviders.insert( providerId, m_providers.take(providerId) );
             }
         }
 
         // Start the cleanup timer, will delete cached providers after a timeout
         startCleanupLater();
 
         // The data source is no longer used, delete it
         delete dataSource;
     } else if ( nonAmbiguousName.startsWith(sourceTypeKeyword(ServiceProviderSource)) ) {
         // A "ServiceProvider xx_xx" data source was removed, data for these sources
         // is stored in the "ServiceProviders" data source object in m_dataSources.
         // Remove not installed providers also from the "ServiceProviders" data source.
         const QString providerId = nonAmbiguousName.mid(
                 QString(sourceTypeKeyword(ServiceProviderSource)).length() + 1 );
         if ( !providerId.isEmpty() && !isProviderUsed(providerId) ) {
             // Test if the provider is installed
             const QStringList providerPaths = ServiceProviderGlobal::installedProviders();
             bool isInstalled = false;
             foreach ( const QString &providerPath, providerPaths ) {
                 const QString &installedProviderId =
                         ServiceProviderGlobal::idFromFileName( providerPath );
                 if ( providerId == installedProviderId ) {
                     isInstalled = true;
                     break;
                 }
             }
             if ( !isInstalled ) {
                 qDebug() << "Remove provider" << providerId;
                 // Provider is not installed, remove it from the "ServiceProviders" data source
                 providersDataSource()->removeProvider( providerId );
                 removeData( sourceTypeKeyword(ServiceProvidersSource), providerId );
             }
         }
     }
 }
 
 void PublicTransportEngine::startCleanupLater()
 {
     // Create the timer if it is not currently running
     if ( !m_cleanupTimer ) {
         m_cleanupTimer = new QTimer( this );
         m_cleanupTimer->setInterval( PROVIDER_CLEANUP_TIMEOUT );
         connect( m_cleanupTimer, SIGNAL(timeout()), this, SLOT(cleanup()) );
     }
 
     // (Re)start the timer
     m_cleanupTimer->start();
 }
 
 void PublicTransportEngine::cleanup()
 {
     // Delete the timer
     delete m_cleanupTimer;
     m_cleanupTimer = 0;
 
     // Remove all shared pointers of unused cached providers,
     // ie. delete the provider objects
     m_cachedProviders.clear();
 }
 
 QVariantHash PublicTransportEngine::serviceProviderData( const ServiceProvider *provider )
 {
     Q_ASSERT( provider );
     return serviceProviderData( *(provider->data()), provider );
 }
 
 QVariantHash PublicTransportEngine::serviceProviderData( const ServiceProviderData &data,
                                                          const ServiceProvider *provider )
 {
     QVariantHash dataServiceProvider;
     dataServiceProvider.insert( "id", data.id() );
     dataServiceProvider.insert( "fileName", data.fileName() );
     dataServiceProvider.insert( "type", ServiceProviderGlobal::typeName(data.type()) );
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     if ( data.type() == Enums::GtfsProvider ) {
         dataServiceProvider.insert( "feedUrl", data.feedUrl() );
     }
 #endif
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     if ( data.type() == Enums::ScriptedProvider ) {
         dataServiceProvider.insert( "scriptFileName", data.scriptFileName() );
     }
 #endif
     dataServiceProvider.insert( "name", data.name() );
     dataServiceProvider.insert( "url", data.url() );
     dataServiceProvider.insert( "shortUrl", data.shortUrl() );
     dataServiceProvider.insert( "country", data.country() );
     dataServiceProvider.insert( "cities", data.cities() );
     dataServiceProvider.insert( "credit", data.credit() );
     dataServiceProvider.insert( "useSeparateCityValue", data.useSeparateCityValue() );
     dataServiceProvider.insert( "onlyUseCitiesInList", data.onlyUseCitiesInList() );
     dataServiceProvider.insert( "author", data.author() );
     dataServiceProvider.insert( "shortAuthor", data.shortAuthor() );
     dataServiceProvider.insert( "email", data.email() );
     dataServiceProvider.insert( "description", data.description() );
     dataServiceProvider.insert( "version", data.version() );
 
     QStringList changelog;
     foreach ( const ChangelogEntry &entry, data.changelog() ) {
         changelog << QString( "%2 (%1): %3" ).arg( entry.version ).arg( entry.author ).arg( entry.description );
     }
     dataServiceProvider.insert( "changelog", changelog );
 
     // To get the list of features, ServiceProviderData is not enough
     // A given ServiceProvider or cached data gets used if available. Otherwise the ServiceProvider
     // gets created just to get the list of features
     const QSharedPointer<KConfig> cache = ServiceProviderGlobal::cache();
     KConfigGroup providerGroup = cache->group( data.id() );
     if ( provider ) {
         // Write features to the return value
         const QList< Enums::ProviderFeature > features = provider->features();
         const QStringList featureStrings = ServiceProviderGlobal::featureStrings( features );
         dataServiceProvider.insert( "features", featureStrings );
         dataServiceProvider.insert( "featureNames", ServiceProviderGlobal::featureNames(features) );
 
         // Make sure, features have been written to the cache
         providerGroup.writeEntry( "features", featureStrings );
     } else {
         // Check stored feature strings and re-read features if an invalid string was found
         bool ok;
         QStringList featureStrings = providerGroup.readEntry("features", QStringList());
         const bool featureListIsEmpty = featureStrings.removeOne("(none)");
         QList< Enums::ProviderFeature > features =
                 ServiceProviderGlobal::featuresFromFeatureStrings( featureStrings, &ok );
 
         if ( (featureListIsEmpty || !featureStrings.isEmpty()) && ok ) {
             // Feature list could be read from cache
             dataServiceProvider.insert( "features", featureStrings );
             dataServiceProvider.insert( "featureNames",
                                         ServiceProviderGlobal::featureNames(features) );
         } else {
             qDebug() << "No cached feature data was found for provider" << data.id();
             // No cached feature data was found for the provider,
             // create the provider to get the feature list and store it in the cache
             bool newlyCreated;
             ProviderPointer _provider = providerFromId( data.id(), &newlyCreated );
             features = _provider->features();
             featureStrings = ServiceProviderGlobal::featureStrings( features );
             const QStringList featuresNames = ServiceProviderGlobal::featureNames( features );
 
             // Remove provider from the list again to delete it
             if ( newlyCreated ) {
                 m_providers.remove( data.id() );
             }
 
             // If no features are supported write "(none)" to the cache
             // to indicate that features have been written to the cache
             if ( featureStrings.isEmpty() ) {
                 featureStrings.append( "(none)" );
             }
 
             // Write features to the return value
             dataServiceProvider.insert( "features", featureStrings );
             dataServiceProvider.insert( "featureNames", featuresNames );
 
             // Write features to cache
             providerGroup.writeEntry( "features", featureStrings );
         }
     }
 
     return dataServiceProvider;
 }
 
 QVariantHash PublicTransportEngine::locations()
 {
     QVariantHash ret;
     const QStringList providers = ServiceProviderGlobal::installedProviders();
 
     // Update ServiceProviders source to fill m_erroneousProviders
     updateServiceProviderSource();
 
     foreach( const QString &provider, providers ) {
         if ( QFileInfo(provider).isSymLink() ) {
             // Service provider XML file is a symlink for a default service provider, skip it
             continue;
         }
 
         const QString providerFileName = QFileInfo( provider ).fileName();
         const QString providerId = ServiceProviderGlobal::idFromFileName( providerFileName );
         if ( m_erroneousProviders.contains(providerId) ) {
             // Service provider is erroneous
             continue;
         }
 
         const int pos = providerFileName.indexOf('_');
         if ( pos > 0 ) {
             // Found an underscore (not the first character)
             // Cut location code from the service providers XML filename
             const QString location = providerFileName.mid( 0, pos ).toLower();
             if ( !ret.contains(location) ) {
                 // Location is not already added to [ret]
                 // Get the filename of the default provider for the current location
                 const QString defaultProviderFileName =
                         ServiceProviderGlobal::defaultProviderForLocation( location );
 
                 // Extract service provider ID from the filename
                 const QString defaultProviderId =
                         ServiceProviderGlobal::idFromFileName( defaultProviderFileName );
 
                 // Store location values in a hash and insert it into [ret]
                 QVariantHash locationHash;
                 locationHash.insert( "name", location );
                 if ( location == "international" ) {
                     locationHash.insert( "description", i18n("International providers. "
                                          "There is one for getting flight departures/arrivals.") );
                 } else {
                     locationHash.insert( "description", i18n("Service providers for %1.",
                             KGlobal::locale()->countryCodeToName(location)) );
                 }
                 locationHash.insert( "defaultProvider", defaultProviderId );
                 ret.insert( location, locationHash );
             }
         }
     }
 
     return ret;
 }
 
 PublicTransportEngine::ProviderPointer PublicTransportEngine::providerFromId(
         const QString &id, bool *newlyCreated )
 {
     if ( m_providers.contains(id) ) {
         // The provider was already created and is currently used by the engine
         if ( newlyCreated ) {
             *newlyCreated = false;
         }
         return m_providers[ id ];
     } else if ( m_cachedProviders.contains(id) ) {
         // The provider was already created, is now unused by the engine,
         // but is still cached (cleanup timeout not reached yet)
         if ( newlyCreated ) {
             *newlyCreated = false;
         }
 
         // Move provider back from the list of cached providers to the list of used providers
         const ProviderPointer provider = m_cachedProviders.take( id );
         m_providers.insert( id, provider );
         return provider;
     } else {
         // Provider not currently used or cached
         if ( newlyCreated ) {
             *newlyCreated = true;
         }
 
         // Try to create the provider
         ServiceProvider *provider = createProvider( id, this );
         if ( !provider ) {
             // Return an invalid ProviderPointer, when the provider could not be created
             return ProviderPointer::create();
         }
 
         // Check the state of the provider, it needs to be "ready"
         ProvidersDataSource *dataSource = providersDataSource();
         if ( dataSource ) {
             const QString state = dataSource->providerState( id );
             if ( state != QLatin1String("ready") ) {
-                kWarning() << "Provider" << id << "is not ready, state is" << state;
+                qWarning() << "Provider" << id << "is not ready, state is" << state;
                 return ProviderPointer::create();
             }
         }
 
         // Connect provider, when it was created successfully
         connect( provider, SIGNAL(departuresReceived(ServiceProvider*,QUrl,DepartureInfoList,GlobalTimetableInfo,DepartureRequest)),
                  this, SLOT(departuresReceived(ServiceProvider*,QUrl,DepartureInfoList,GlobalTimetableInfo,DepartureRequest)) );
         connect( provider, SIGNAL(arrivalsReceived(ServiceProvider*,QUrl,ArrivalInfoList,GlobalTimetableInfo,ArrivalRequest)),
                  this, SLOT(arrivalsReceived(ServiceProvider*,QUrl,ArrivalInfoList,GlobalTimetableInfo,ArrivalRequest)) );
         connect( provider, SIGNAL(journeysReceived(ServiceProvider*,QUrl,JourneyInfoList,GlobalTimetableInfo,JourneyRequest)),
                  this, SLOT(journeysReceived(ServiceProvider*,QUrl,JourneyInfoList,GlobalTimetableInfo,JourneyRequest)) );
         connect( provider, SIGNAL(stopsReceived(ServiceProvider*,QUrl,StopInfoList,StopSuggestionRequest)),
                  this, SLOT(stopsReceived(ServiceProvider*,QUrl,StopInfoList,StopSuggestionRequest)) );
         connect( provider, SIGNAL(additionalDataReceived(ServiceProvider*,QUrl,TimetableData,AdditionalDataRequest)),
                  this, SLOT(additionalDataReceived(ServiceProvider*,QUrl,TimetableData,AdditionalDataRequest)) );
         connect( provider, SIGNAL(requestFailed(ServiceProvider*,ErrorCode,QString,QUrl,const AbstractRequest*)),
                  this, SLOT(requestFailed(ServiceProvider*,ErrorCode,QString,QUrl,const AbstractRequest*)) );
 
         // Create a ProviderPointer for the created provider and
         // add it to the list of currently used providers
         const ProviderPointer pointer( provider );
         m_providers.insert( id, pointer );
         return pointer;
     }
 }
 
 bool PublicTransportEngine::updateServiceProviderForCountrySource( const SourceRequestData &data )
 {
     QString providerId;
     if ( data.defaultParameter.contains('_') ) {
         // Seems that a service provider ID is given
         providerId = data.defaultParameter;
     } else {
         // Assume a country code in name
         if ( !updateServiceProviderSource() || !updateLocationSource() ) {
             return false;
         }
 
         // The defaultParameter stored in data is a location code
         // (ie. "international" or a two letter country code)
         QVariantHash locations = m_dataSources[ sourceTypeKeyword(LocationsSource) ]->data();
         QVariantHash locationCountry = locations[ data.defaultParameter.toLower() ].toHash();
         QString defaultProvider = locationCountry[ "defaultProvider" ].toString();
         if ( defaultProvider.isEmpty() ) {
             // No provider for the location found
             return false;
         }
 
         providerId = defaultProvider;
     }
 
     updateProviderData( providerId );
     publishData( providersDataSource(), providerId );
     return true;
 }
 
 bool PublicTransportEngine::updateProviderData( const QString &providerId,
                                                 const QSharedPointer<KConfig> &cache )
 {
     QVariantHash providerData;
     QString errorMessage;
     ProvidersDataSource *providersSource = providersDataSource();
 
     // Test if the provider is valid
     if ( testServiceProvider(providerId, &providerData, &errorMessage, cache) ) {
         QVariantHash stateData;
         const QString state = updateProviderState( providerId, &stateData,
                 providerData["type"].toString(), providerData.value("feedUrl").toString() );
         providerData["error"] = false;
         providersSource->addProvider( providerId,
                 ProvidersDataSource::ProviderData(providerData, state, stateData) );
         return true;
     } else {
         // Invalid provider
         providerData["id"] = providerId;
         providerData["error"] = true;
         providerData["errorMessage"] = errorMessage;
 
         // Prepare state data with the error message and a boolean whether or not the provider
         // is installed or could not be found (only possible if the provider data source was
         // manually requested)
         QVariantHash stateData;
         stateData["statusMessage"] = errorMessage;
         stateData["isInstalled"] = ServiceProviderGlobal::isProviderInstalled( providerId );
 
         providersSource->addProvider( providerId,
                 ProvidersDataSource::ProviderData(providerData, "error", stateData) );
         return false;
     }
 }
 
 bool PublicTransportEngine::updateServiceProviderSource()
 {
     const QString name = sourceTypeKeyword( ServiceProvidersSource );
     ProvidersDataSource *providersSource = providersDataSource();
     if ( providersSource->isDirty() ) {
         const QStringList providers = ServiceProviderGlobal::installedProviders();
         if ( providers.isEmpty() ) {
-            kWarning() << "Could not find any service provider plugins";
+            qWarning() << "Could not find any service provider plugins";
         } else {
             QStringList loadedProviders;
             m_erroneousProviders.clear();
             QSharedPointer<KConfig> cache = ServiceProviderGlobal::cache();
             foreach( const QString &provider, providers ) {
                 const QString providerId =
                         ServiceProviderGlobal::idFromFileName( QUrl(provider).fileName() );
                 if ( updateProviderData(providerId, cache) ) {
                     loadedProviders << providerId;
                 }
             }
 
             // Print information about loaded/erroneous providers
             qDebug() << "Loaded" << loadedProviders.count() << "service providers";
             if ( !m_erroneousProviders.isEmpty() ) {
-                kWarning() << "Erroneous service provider plugins, that could not be loaded:"
+                qWarning() << "Erroneous service provider plugins, that could not be loaded:"
                            << m_erroneousProviders;
             }
         }
 
         // Mark and update all providers that are no longer installed
         QSharedPointer< KConfig > cache = ServiceProviderGlobal::cache();
         const QStringList uninstalledProviderIDs = providersSource->markUninstalledProviders();
         foreach ( const QString &uninstalledProviderID, uninstalledProviderIDs ) {
             // Clear all values stored in the cache for the provider
             ServiceProviderGlobal::clearCache( uninstalledProviderID, cache );
 
             // Delete the provider and update it's state and other data
             deleteProvider( uninstalledProviderID );
             updateProviderData( uninstalledProviderID, cache );
         }
 
         // Insert the data source
         m_dataSources.insert( name, providersSource );
     }
 
     // Remove all old data, some service providers may have been updated and are now erroneous
     removeAllData( name );
     publishData( providersSource );
 
     return true;
 }
 
 QString PublicTransportEngine::updateProviderState( const QString &providerId,
                                                     QVariantHash *stateData,
                                                     const QString &providerType,
                                                     const QString &feedUrl,
                                                     bool readFromCache )
 {
     Q_ASSERT( stateData );
     QSharedPointer< KConfig > cache = ServiceProviderGlobal::cache();
     KConfigGroup group = cache->group( providerId );
     const QString cachedState = readFromCache ? group.readEntry("state", QString()) : QString();
 #ifdef BUILD_PROVIDER_TYPE_GTFS // Currently type is only used for GTFS
     const Enums::ServiceProviderType type = ServiceProviderGlobal::typeFromString( providerType );
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
     // Test if there is an error
     if ( m_erroneousProviders.contains(providerId) ) {
         stateData->insert( "statusMessage", m_erroneousProviders[providerId].toString() );
         return "error";
     }
 
     if ( !cachedState.isEmpty() ) {
         // State is stored in the cache,
         // also read state data from cache
         KConfigGroup stateGroup = group.group( "stateData" );
         foreach ( const QString &key, stateGroup.keyList() ) {
             stateData->insert( key, stateGroup.readEntry(key) );
         }
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         if ( type == Enums::GtfsProvider ) {
             // Update state and add dynamic state data
             const QString state = ServiceProviderGtfs::updateGtfsDatabaseState(
                     providerId, feedUrl, cache, stateData );
             if ( state != QLatin1String("ready") ) {
                 // The database is invalid/deleted, but the cache says the import was finished
                 deleteProvider( providerId );
             }
             return state;
         } else
 #endif // BUILD_PROVIDER_TYPE_GTFS
         {
             if ( cachedState != QLatin1String("ready") ) {
                 // Provider not ready, cannot use it
                 deleteProvider( providerId );
             }
 
             // State of non-GTFS providers does not need more tests,
             // if there is an error only the fields "error" and "errorMessage" are available
             // in the data source, no fields "state" or "stateData"
             return cachedState;
         }
     } // !state.isEmpty()
 
     // State is not stored in the cache or is out of date
     QString state = "ready";
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     if ( type == Enums::GtfsProvider ) {
         state = ServiceProviderGtfs::updateGtfsDatabaseState( providerId, feedUrl,
                                                               cache, stateData );
     }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
     // Ensure a status message is given (or at least warn if not)
     if ( stateData->value("statusMessage").toString().isEmpty() ) {
         if ( state == QLatin1String("ready") ) {
             stateData->insert( "statusMessage",
                                 i18nc("@info/plain", "The provider is ready to use") );
         } else {
-            kWarning() << "Missing status message explaining why the provider" << providerId
+            qWarning() << "Missing status message explaining why the provider" << providerId
                         << "is not ready";
         }
     }
 
     // Store the state in the cache
     group.writeEntry( "state", state );
 
     // Write state data to the cache
     KConfigGroup stateGroup = group.group( "stateData" );
     for ( QVariantHash::ConstIterator it = stateData->constBegin();
         it != stateData->constEnd(); ++it )
     {
         if ( isStateDataCached(it.key()) ) {
             stateGroup.writeEntry( it.key(), it.value() );
         }
     }
     return state;
 }
 
 bool PublicTransportEngine::isStateDataCached( const QString &stateDataKey )
 {
     return stateDataKey != QLatin1String("progress") &&
            stateDataKey != QLatin1String("gtfsDatabasePath") &&
            stateDataKey != QLatin1String("gtfsDatabaseSize") &&
            stateDataKey != QLatin1String("gtfsDatabaseModifiedTime") &&
            stateDataKey != QLatin1String("gtfsFeedImported") &&
            stateDataKey != QLatin1String("gtfsFeedSize") &&
            stateDataKey != QLatin1String("gtfsFeedModifiedTime");
 }
 
 bool PublicTransportEngine::testServiceProvider( const QString &providerId,
                                                  QVariantHash *providerData, QString *errorMessage,
                                                  const QSharedPointer<KConfig> &_cache )
 {
     const bool providerUsed = m_providers.contains( providerId );
     const bool providerCached = m_cachedProviders.contains( providerId );
     if ( providerUsed || providerCached ) {
         // The provider is cached in the engine, ie. it is valid,
         // use it's ServiceProviderData object
         const ProviderPointer provider = providerUsed
                 ? m_providers[providerId] : m_cachedProviders[providerId];
         *providerData = serviceProviderData( provider.data() );
         errorMessage->clear();
         return true;
     }
 
     // Read cached data for the provider
     QSharedPointer<KConfig> cache = _cache.isNull() ? ServiceProviderGlobal::cache() : _cache;
     ServiceProviderTestData testData = ServiceProviderTestData::read( providerId, cache );
 
     // TODO Needs to be done for each provider sub class here
     foreach ( Enums::ServiceProviderType type, ServiceProviderGlobal::availableProviderTypes() ) {
         switch ( type ) {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         case Enums::ScriptedProvider:
             if ( !ServiceProviderScript::isTestResultUnchanged(providerId, cache) ) {
                 qDebug() << "Script changed" << providerId;
                 testData.setSubTypeTestStatus( ServiceProviderTestData::Pending );
                 testData.write( providerId, cache );
             }
             break;
 #endif
         case Enums::GtfsProvider:
             break;
         case Enums::InvalidProvider:
         default:
-            kWarning() << "Provider type unknown" << type;
+            qWarning() << "Provider type unknown" << type;
             break;
         }
     }
 
     // Check the cache if the provider plugin .pts file can be read
     if ( testData.xmlStructureTestStatus() == ServiceProviderTestData::Failed ) {
         // The XML structure of the provider plugin .pts file is marked as failed in the cache
         // Cannot add provider data to data sources, the file needs to be fixed first
-        kWarning() << "Provider plugin" << providerId << "is invalid.";
+        qWarning() << "Provider plugin" << providerId << "is invalid.";
         qDebug() << "Fix the provider file at" << ServiceProviderGlobal::fileNameFromId(providerId);
         qDebug() << testData.errorMessage();
         qDebug() << "************************************";
 
         providerData->clear();
         *errorMessage = testData.errorMessage();
         m_erroneousProviders.insert( providerId, testData.errorMessage() );
         updateErroneousServiceProviderSource();
         return false;
     }
     // The sub type test may already be marked as failed in the cache,
     // but when provider data can be read it should be added to provider data source
     // also when the provider plugin is invalid
 
     // Read provider data from the XML file
     QString _errorMessage;
     const QScopedPointer<ServiceProviderData> data(
             ServiceProviderDataReader::read(providerId, &_errorMessage) );
     if ( data.isNull() ) {
         // Could not read provider data
         if ( testData.isXmlStructureTestPending() ) {
             // Store error message in cache and do not reread unchanged XMLs everytime
             testData.setXmlStructureTestStatus( ServiceProviderTestData::Failed, _errorMessage );
             testData.write( providerId, cache );
         }
 
         providerData->clear();
         *errorMessage = _errorMessage;
         m_erroneousProviders.insert( providerId, _errorMessage );
         updateErroneousServiceProviderSource();
         return false;
     }
 
     // Check if support for the used provider type has been build into the engine
     if ( !ServiceProviderGlobal::isProviderTypeAvailable(data->type()) ) {
         providerData->clear();
         _errorMessage = i18nc("@info/plain", "Support for provider type %1 is not available",
                               ServiceProviderGlobal::typeName(data->type(),
                                     ServiceProviderGlobal::ProviderTypeNameWithoutUnsupportedHint));
         *errorMessage = _errorMessage;
         m_erroneousProviders.insert( providerId, _errorMessage );
         updateErroneousServiceProviderSource();
         return false;
     }
 
     // Mark the XML test as passed if not done already
     if ( testData.isXmlStructureTestPending() ) {
         testData.setXmlStructureTestStatus( ServiceProviderTestData::Passed );
         testData.write( providerId, cache );
     }
 
     // XML file structure test is passed, run provider type test if not done already
     switch ( testData.subTypeTestStatus() ) {
     case ServiceProviderTestData::Pending: {
         // Need to create the provider to run tests in derived classes (in the constructor)
         const QScopedPointer<ServiceProvider> provider(
                 createProviderForData(data.data(), this, cache) );
         data->setParent( 0 ); // Prevent deletion of data when the provider gets deleted
 
         // Read test data again, because it may have been changed in the provider constructor
         testData = ServiceProviderTestData::read( providerId, cache );
 
         // Run the sub type test if it is still pending
         testData = provider->runSubTypeTest( testData, cache );
 
         // Read test data again, updated in the ServiceProvider constructor
         if ( testData.results().testFlag(ServiceProviderTestData::SubTypeTestFailed) ) {
             // Sub-type test failed
-            kWarning() << "Test failed for" << providerId << testData.errorMessage();
+            qWarning() << "Test failed for" << providerId << testData.errorMessage();
             providerData->clear();
             *errorMessage = testData.errorMessage();
             m_erroneousProviders.insert( providerId, testData.errorMessage() );
             updateErroneousServiceProviderSource();
             return false;
         }
 
         // The provider is already created, use it in serviceProviderData(), if needed
         *providerData = serviceProviderData( provider.data() );
         break;
     }
 
     case ServiceProviderTestData::Failed:
         // Test is marked as failed in the cache
         *errorMessage = testData.errorMessage();
         m_erroneousProviders.insert( providerId, testData.errorMessage() );
         updateErroneousServiceProviderSource();
         *providerData = serviceProviderData( *data );
         return false;
 
     case ServiceProviderTestData::Passed:
         // Test is marked as passed in the cache
         *providerData = serviceProviderData( *data );
         break;
     }
 
     m_erroneousProviders.remove( providerId );
     const QLatin1String name = sourceTypeKeyword( ErroneousServiceProvidersSource );
     removeData( name, providerId );
 
     errorMessage->clear();
     return true;
 }
 
 bool PublicTransportEngine::updateErroneousServiceProviderSource()
 {
     const QLatin1String name = sourceTypeKeyword( ErroneousServiceProvidersSource );
     setData( name, static_cast<Data>(m_erroneousProviders) );
     return true;
 }
 
 bool PublicTransportEngine::updateLocationSource()
 {
     const QLatin1String name = sourceTypeKeyword( LocationsSource );
     if ( m_dataSources.contains(name) ) {
         setData( name, m_dataSources[name]->data() );
     } else {
         SimpleDataSource *dataSource = new SimpleDataSource( name, locations() );
         m_dataSources.insert( name, dataSource );
         setData( name, dataSource->data() );
     }
     return true;
 }
 
 QString PublicTransportEngine::providerIdFromSourceName( const QString &sourceName )
 {
     const int pos = sourceName.indexOf( ' ' );
     if ( pos == -1 ) { //|| pos = sourceName.length() - 1 ) {
         return QString();
     }
 
     const int endPos = sourceName.indexOf( '|', pos + 1 );
     return fixProviderId( sourceName.mid(pos + 1, endPos - pos - 1).trimmed() );
 }
 
 ParseDocumentMode PublicTransportEngine::parseModeFromSourceType(
         PublicTransportEngine::SourceType type )
 {
     switch ( type ) {
     case DeparturesSource:
         return ParseForDepartures;
     case ArrivalsSource:
         return ParseForArrivals;
     case StopsSource:
         return ParseForStopSuggestions;
     case JourneysDepSource:
         return ParseForJourneysByDepartureTime;
     case JourneysArrSource:
         return ParseForJourneysByArrivalTime;
     case JourneysSource:
         return ParseForJourneysByDepartureTime;
     default:
         return ParseInvalid;
     }
 }
 
 bool PublicTransportEngine::enoughDataAvailable( DataSource *dataSource,
                                                  const SourceRequestData &sourceData ) const
 {
     TimetableDataSource *timetableDataSource = dynamic_cast< TimetableDataSource* >( dataSource );
     if ( !timetableDataSource ) {
         return true;
     }
 
     AbstractTimetableItemRequest *request = sourceData.request;
     return timetableDataSource->enoughDataAvailable( request->dateTime(), request->count() );
 }
 
 bool PublicTransportEngine::updateTimetableDataSource( const SourceRequestData &data )
 {
     const QString nonAmbiguousName = disambiguateSourceName( data.name );
     bool containsDataSource = m_dataSources.contains( nonAmbiguousName );
     if ( containsDataSource && isSourceUpToDate(nonAmbiguousName) &&
          enoughDataAvailable(m_dataSources[nonAmbiguousName], data) )
     { // Data is stored in the map and up to date
         TimetableDataSource *dataSource =
                 dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
         dataSource->addUsingDataSource( QSharedPointer<AbstractRequest>(data.request->clone()),
                                         data.name, data.request->dateTime(), data.request->count() );
         setData( data.name, dataSource->data() );
     } else if ( m_runningSources.contains(nonAmbiguousName) ) {
         // Source gets already processed
         qDebug() << "Source already gets processed, please wait" << data.name;
     } else if ( data.parseMode == ParseInvalid || !data.request ) {
-        kWarning() << "Invalid source" << data.name;
+        qWarning() << "Invalid source" << data.name;
         return false;
     } else { // Request new data
         TimetableDataSource *dataSource = containsDataSource
                 ? dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] )
                 : new TimetableDataSource(nonAmbiguousName);
         dataSource->clear();
         dataSource->addUsingDataSource( QSharedPointer<AbstractRequest>(data.request->clone()),
                                         data.name, data.request->dateTime(), data.request->count() );
         m_dataSources[ nonAmbiguousName ] = dataSource;
 
         // Start the request
         request( data );
     }
 
     return true;
 }
 
 void PublicTransportEngine::requestAdditionalData( const QString &sourceName,
                                                    int updateItem, int count )
 {
     TimetableDataSource *dataSource = testDataSourceForAdditionalDataRequests( sourceName );
     if ( dataSource ) {
         // Start additional data requests
         bool dataChanged = false;
         for ( int itemNumber = updateItem; itemNumber < updateItem + count; ++itemNumber ) {
             dataChanged = requestAdditionalData(sourceName, itemNumber, dataSource) || dataChanged;
         }
 
         if ( dataChanged ) {
             // Publish changes to "additionalDataState" fields
             publishData( dataSource );
         }
     }
 }
 
 TimetableDataSource *PublicTransportEngine::testDataSourceForAdditionalDataRequests(
         const QString &sourceName )
 {
     // Try to get a pointer to the provider with the provider ID from the source name
     const QString providerId = providerIdFromSourceName( sourceName );
     const ProviderPointer provider = providerFromId( providerId );
     if ( provider.isNull() || provider->type() == Enums::InvalidProvider ) {
         emit additionalDataRequestFinished( sourceName, -1, false,
                 QString("Service provider %1 could not be created").arg(providerId) );
         return 0; // Service provider couldn't be created
     }
 
     // Test if the provider supports additional data
     if ( !provider->features().contains(Enums::ProvidesAdditionalData) ) {
         emit additionalDataRequestFinished( sourceName, -1, false,
                 i18nc("@info/plain", "Additional data not supported") );
-        kWarning() << "Additional data not supported by" << provider->id();
+        qWarning() << "Additional data not supported by" << provider->id();
         return 0; // Service provider does not support additional data
     }
 
     // Test if the source with the given name is cached
     const QString nonAmbiguousName = disambiguateSourceName( sourceName );
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
         emit additionalDataRequestFinished( sourceName, -1, false,
                 "Data source to update not found: " + sourceName );
         return 0;
     }
 
     // Get the data list, currently only for departures/arrivals TODO: journeys
     TimetableDataSource *dataSource =
             dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
     if ( !dataSource ) {
         emit additionalDataRequestFinished( sourceName, -1, false,
                 "Data source is not a timetable data source: " + sourceName );
         return 0;
     }
 
     return dataSource;
 }
 
 bool PublicTransportEngine::requestAdditionalData( const QString &sourceName,
                                                    int itemNumber, TimetableDataSource *dataSource )
 {
     QVariantList items = dataSource->timetableItems();
     if ( itemNumber >= items.count() || itemNumber < 0 ) {
         emit additionalDataRequestFinished( sourceName, itemNumber, false,
                 QString("Item to update (%1) not found in data source").arg(itemNumber) );
         return false;
     }
 
     // Get the timetable item stored in the data source at the given index
     QVariantHash item = items[ itemNumber ].toHash();
 
     // Check if additional data is already included or was already requested
     const QString additionalDataState = item["additionalDataState"].toString();
     if ( additionalDataState == QLatin1String("included") ) {
         emit additionalDataRequestFinished( sourceName, itemNumber, false,
                 QString("Additional data is already included for item %1").arg(itemNumber) );
         return false;
     } else if ( additionalDataState == QLatin1String("busy") ) {
         qDebug() << "Additional data for item" << itemNumber << "already requested, please wait";
         emit additionalDataRequestFinished( sourceName, itemNumber, false,
                 QString("Additional data was already requested for item %1, please wait")
                 .arg(itemNumber) );
         return false;
     }
 
     // Check if the timetable item is valid,
     // extract values needed for the additional data request job
     const QDateTime dateTime = item[ "DepartureDateTime" ].toDateTime();
     const QString transportLine = item[ "TransportLine" ].toString();
     const QString target = item[ "Target" ].toString();
     const QString routeDataUrl = item[ "RouteDataUrl" ].toString();
     if ( routeDataUrl.isEmpty() &&
          (!dateTime.isValid() || transportLine.isEmpty() || target.isEmpty()) )
     {
         emit additionalDataRequestFinished( sourceName, itemNumber, false,
                                             QString("Item to update is invalid: %1, %2, %3")
                                             .arg(dateTime.toString()).arg(transportLine, target) );
         return false;
     }
 
     // Store state of additional data in the timetable item
     item["additionalDataState"] = "busy";
     items[ itemNumber ] = item;
     dataSource->setTimetableItems( items );
 
     // Found data of the timetable item to update
     const SourceRequestData sourceData( dataSource->name() );
     const ProviderPointer provider = providerFromId( dataSource->providerId() );
     Q_ASSERT( provider );
     provider->requestAdditionalData( AdditionalDataRequest(dataSource->name(), itemNumber,
             sourceData.request->stop(), sourceData.request->stopId(), dateTime, transportLine,
             target, sourceData.request->city(), routeDataUrl) );
     return true;
 }
 
 QString PublicTransportEngine::fixProviderId( const QString &providerId )
 {
     if ( !providerId.isEmpty() ) {
         return providerId;
     }
 
     // No service provider ID given, use the default one for the users country
     const QString country = KGlobal::locale()->country();
 
     // Try to find the XML filename of the default accessor for [country]
     const QString filePath = ServiceProviderGlobal::defaultProviderForLocation( country );
     if ( filePath.isEmpty() ) {
         return 0;
     }
 
     // Extract service provider ID from filename
     const QString defaultProviderId = ServiceProviderGlobal::idFromFileName( filePath );
     qDebug() << "No service provider ID given, using the default one for country"
              << country << "which is" << defaultProviderId;
     return defaultProviderId;
 }
 
 QString PublicTransportEngine::disambiguateSourceName( const QString &sourceName )
 {
     // Remove count argument
     QString ret = sourceName;
     ret.remove( QRegExp("(count=[^\\|]+)") );
 
     // Round time parameter values to 15 minutes precision
     QRegExp rx( "(time=[^\\|]+|datetime=[^\\|]+)" );
     if ( rx.indexIn(ret) != -1 ) {
         // Get the time value
         const QString timeParameter = rx.cap( 1 );
         QDateTime time;
         if ( timeParameter.startsWith(QLatin1String("time=")) ) {
             time = QDateTime( QDate::currentDate(),
                               QTime::fromString(timeParameter.mid(5), "hh:mm") );
         } else { // startsWith "datetime="
             time = QDateTime::fromString( timeParameter.mid(9), Qt::ISODate );
             if ( !time.isValid() ) {
                 time = QDateTime::fromString( timeParameter.mid(9) );
             }
         }
 
         // Round 15 minutes
         qint64 msecs = time.toMSecsSinceEpoch();
         time = QDateTime::fromMSecsSinceEpoch( msecs - msecs % (1000 * 60 * 15) );
 
         // Replace old time parameter with a new one
         ret.replace( rx.pos(), rx.matchedLength(),
                      QLatin1String("datetime=") + time.toString(Qt::ISODate) );
     }
 
     // Read parameters to reorder them afterwards
     const SourceType type = sourceTypeFromName( ret );
     const QString typeKeyword = sourceTypeKeyword( type );
     const QStringList parameterPairs = ret.mid( typeKeyword.length() )
             .trimmed().split( '|', QString::SkipEmptyParts );
     QString defaultParameter;
     QHash< QString, QString > parameters;
     for ( int i = 0; i < parameterPairs.length(); ++i ) {
         const QString parameter = parameterPairs.at( i ).trimmed();
         const int pos = parameter.indexOf( '=' );
         if ( pos == -1 ) {
             // No parameter name given, this is the default parameter, eg. the provider ID
             defaultParameter = fixProviderId( parameter );
         } else {
             // Only add parameters with non-empty parameter name and value,
             // make parameter value lower case (eg. stop names)
             const QString parameterName = parameter.left( pos );
             const QString parameterValue = parameter.mid( pos + 1 ).trimmed();
             if ( !parameterName.isEmpty() && !parameterValue.isEmpty() ) {
                 parameters[ parameterName ] = parameterValue;
             }
         }
     }
 
     // Build non-ambiguous source name with standardized parameter order
     ret = typeKeyword + ' ' + defaultParameter;
     if ( parameters.contains(QLatin1String("city")) ) {
         ret += "|city=" + parameters["city"].toLower();
     }
     if ( parameters.contains(QLatin1String("stop")) ) {
         ret += "|stop=" + parameters["stop"].toLower();
     }
     if ( parameters.contains(QLatin1String("stopid")) ) {
         ret += "|stopid=" + parameters["stopid"];
     }
     if ( parameters.contains(QLatin1String("originstop")) ) {
         ret += "|originstop=" + parameters["originstop"].toLower();
     }
     if ( parameters.contains(QLatin1String("originstopid")) ) {
         ret += "|originstopid=" + parameters["originstopid"];
     }
     if ( parameters.contains(QLatin1String("targetstop")) ) {
         ret += "|targetstop=" + parameters["targetstop"].toLower();
     }
     if ( parameters.contains(QLatin1String("targetstopid")) ) {
         ret += "|targetstopid=" + parameters["targetstopid"];
     }
     if ( parameters.contains(QLatin1String("timeoffset")) ) {
         ret += "|timeoffset=" + parameters["timeoffset"];
     }
     if ( parameters.contains(QLatin1String("time")) ) {
         ret += "|time=" + parameters["time"];
     }
     if ( parameters.contains(QLatin1String("datetime")) ) {
         ret += "|datetime=" + parameters["datetime"];
     }
     if ( parameters.contains(QLatin1String("count")) ) {
         ret += "|count=" + parameters["count"];
     }
     if ( parameters.contains(QLatin1String("longitude")) ) {
         ret += "|longitude=" + parameters["longitude"];
     }
     if ( parameters.contains(QLatin1String("latitude")) ) {
         ret += "|latitude=" + parameters["latitude"];
     }
     return ret;
 }
 
 void PublicTransportEngine::serviceProviderDirChanged( const QString &path )
 {
     Q_UNUSED( path )
 
     // Use a timer to prevent loading all service providers again and again, for every changed file
     // in a possibly big list of files. It reloads the providers maximally every 250ms.
     // Otherwise it can freeze plasma for a while if eg. all provider files are changed at once.
     if ( !m_providerUpdateDelayTimer ) {
         m_providerUpdateDelayTimer = new QTimer( this );
         connect( m_providerUpdateDelayTimer, SIGNAL(timeout()), this, SLOT(reloadChangedProviders()) );
     }
 
     m_providerUpdateDelayTimer->start( 250 );
 }
 
 void PublicTransportEngine::deleteProvider( const QString &providerId,
                                             bool keepProviderDataSources )
 {
     // Clear all cached data
     const QStringList cachedSources = m_dataSources.keys();
     foreach( const QString &cachedSource, cachedSources ) {
         const QString currentProviderId = providerIdFromSourceName( cachedSource );
         if ( currentProviderId == providerId ) {
             // Disconnect provider and abort all running requests,
             // take provider from the provider list without caching it
             ProviderPointer provider = m_providers.take( providerId );
             if ( provider ) {
                 disconnect( provider.data(), 0, this, 0 );
                 provider->abortAllRequests();
             }
             m_runningSources.removeOne( cachedSource );
 
             if ( keepProviderDataSources ) {
                 // Update data source for the provider
                 TimetableDataSource *timetableSource =
                         dynamic_cast< TimetableDataSource* >( m_dataSources[cachedSource] );
                 if ( timetableSource ) {
                     // Stop automatic updates
                     timetableSource->stopUpdateTimer();
 
                     // Update manually
                     foreach ( const QString &sourceName, timetableSource->usingDataSources() ) {
                         updateTimetableDataSource( SourceRequestData(sourceName) );
                     }
                 }
             } else {
                 // Delete data source for the provider
                 delete m_dataSources.take( cachedSource );
             }
         }
     }
 }
 
 void PublicTransportEngine::reloadChangedProviders()
 {
     qDebug() << "Reload service providers (the service provider dir changed)";
 
     delete m_providerUpdateDelayTimer;
     m_providerUpdateDelayTimer = 0;
 
     // Notify the providers data source about the changed provider directory.
     // Do not remove it here, so that it can track which providers have changed
     ProvidersDataSource *providersSource = providersDataSource();
     if ( providersSource ) {
         providersSource->providersHaveChanged();
     }
 
     // Remove cached locations source to have it updated
     delete m_dataSources.take( sourceTypeKeyword(LocationsSource) );
 
     // Clear all cached data (use the new provider to parse the data again)
     const QStringList cachedSources = m_dataSources.keys();
     const QSharedPointer< KConfig > cache = ServiceProviderGlobal::cache();
     foreach( const QString &cachedSource, cachedSources ) {
         const QString providerId = providerIdFromSourceName( cachedSource );
         if ( !providerId.isEmpty() &&
              (ServiceProviderGlobal::isSourceFileModified(providerId, cache)
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
              || !ServiceProviderScript::isTestResultUnchanged(providerId, cache)
 #endif
             ) )
         {
             m_providers.remove( providerId );
             m_cachedProviders.remove( providerId );
             m_erroneousProviders.remove( providerId );
 
             updateProviderData( providerId, cache );
 
             TimetableDataSource *timetableSource =
                     dynamic_cast< TimetableDataSource* >( m_dataSources[cachedSource] );
             if ( timetableSource ) {
                 // Stop automatic updates
                 timetableSource->stopUpdateTimer();
 
                 // Update manually
                 foreach ( const QString &sourceName, timetableSource->usingDataSources() ) {
                     updateTimetableDataSource( SourceRequestData(sourceName) );
                 }
             }
         }
     }
 
     updateLocationSource();
     updateServiceProviderSource();
     updateErroneousServiceProviderSource();
 }
 
 const QLatin1String PublicTransportEngine::sourceTypeKeyword( SourceType sourceType )
 {
     switch ( sourceType ) {
     case ServiceProviderSource:
         return QLatin1String("ServiceProvider");
     case ServiceProvidersSource:
         return QLatin1String("ServiceProviders");
     case ErroneousServiceProvidersSource:
         return QLatin1String("ErroneousServiceProviders");
     case LocationsSource:
         return QLatin1String("Locations");
     case VehicleTypesSource:
         return QLatin1String("VehicleTypes");
     case DeparturesSource:
         return QLatin1String("Departures");
     case ArrivalsSource:
         return QLatin1String("Arrivals");
     case StopsSource:
         return QLatin1String("Stops");
     case JourneysSource:
         return QLatin1String("Journeys");
     case JourneysDepSource:
         return QLatin1String("JourneysDep");
     case JourneysArrSource:
         return QLatin1String("JourneysArr");
 
     default:
         return QLatin1String("");
     }
 }
 
 PublicTransportEngine::SourceType PublicTransportEngine::sourceTypeFromName(
         const QString &sourceName )
 {
     // Get type of the source, do not match case insensitive, otherwise there can be multiple
     // sources with the same data but only different case
     if ( sourceName.startsWith(sourceTypeKeyword(ServiceProviderSource) + ' ') ) {
         return ServiceProviderSource;
     } else if ( sourceName.compare(sourceTypeKeyword(ServiceProvidersSource)) == 0 ) {
         return ServiceProvidersSource;
     } else if ( sourceName.compare(sourceTypeKeyword(ErroneousServiceProvidersSource)) == 0 ) {
         return ErroneousServiceProvidersSource;
     } else if ( sourceName.compare(sourceTypeKeyword(LocationsSource)) == 0 ) {
         return LocationsSource;
     } else if ( sourceName.compare(sourceTypeKeyword(VehicleTypesSource)) == 0 ) {
         return VehicleTypesSource;
     } else if ( sourceName.startsWith(sourceTypeKeyword(DeparturesSource)) ) {
         return DeparturesSource;
     } else if ( sourceName.startsWith(sourceTypeKeyword(ArrivalsSource)) ) {
         return ArrivalsSource;
     } else if ( sourceName.startsWith(sourceTypeKeyword(StopsSource)) ) {
         return StopsSource;
     } else if ( sourceName.startsWith(sourceTypeKeyword(JourneysDepSource)) ) {
         return JourneysDepSource;
     } else if ( sourceName.startsWith(sourceTypeKeyword(JourneysArrSource)) ) {
         return JourneysArrSource;
     } else if ( sourceName.startsWith(sourceTypeKeyword(JourneysSource)) ) {
         return JourneysSource;
     } else {
         return InvalidSourceName;
     }
 }
 
 PublicTransportEngine::SourceRequestData::SourceRequestData( const QString &name )
         : name(name), type(sourceTypeFromName(name)), parseMode(parseModeFromSourceType(type)),
           request(0)
 {
     if ( isDataRequestingSourceType(type) ) {
         // Extract parameters, which follow after the source type keyword in name
         // and are delimited with '|'
         QStringList parameters = name.mid( QString(sourceTypeKeyword(type)).length() )
                 .trimmed().split( '|', QString::SkipEmptyParts );
 
         switch ( parseMode ) {
         case ParseForDepartures:
             request = new DepartureRequest( name, parseMode );
             break;
         case ParseForArrivals:
             request = new ArrivalRequest( name, parseMode );
             break;
         case ParseForStopSuggestions: {
             bool hasLongitude = false, hasLatitude = false;
             for ( int i = 0; i < parameters.length(); ++i ) {
                 const QString parameter = parameters.at( i ).trimmed();
                 const QString parameterName = parameter.left( parameter.indexOf('=') );
                 if ( parameterName == QLatin1String("longitude") ) {
                     hasLongitude = true;
                 } else if ( parameterName == QLatin1String("latitude") ) {
                     hasLatitude = true;
                 }
             }
             if ( hasLongitude && hasLatitude ) {
                 request = new StopsByGeoPositionRequest( name, parseMode );
             } else {
                 request = new StopSuggestionRequest( name, parseMode );
             }
             break;
         }
         case ParseForJourneysByDepartureTime:
         case ParseForJourneysByArrivalTime:
             request = new JourneyRequest( name, parseMode );
             break;
         default:
-            kWarning() << "Cannot create a request for parse mode" << parseMode;
+            qWarning() << "Cannot create a request for parse mode" << parseMode;
             return;
         }
 
         // Read parameters
         for ( int i = 0; i < parameters.length(); ++i ) {
             const QString parameter = parameters.at( i ).trimmed();
             const int pos = parameter.indexOf( '=' );
             if ( pos == -1 ) {
                 if ( !defaultParameter.isEmpty() ) {
-                    kWarning() << "More than one parameters without name given:"
+                    qWarning() << "More than one parameters without name given:"
                                << defaultParameter << parameter;
                 }
 
                 // No parameter name given, assume the service provider ID
                 defaultParameter = parameter;
             } else {
                 const QString parameterName = parameter.left( pos );
                 const QString parameterValue = parameter.mid( pos + 1 ).trimmed();
                 if ( parameterValue.isEmpty() ) {
-                    kWarning() << "Empty parameter value for parameter" << parameterName;
+                    qWarning() << "Empty parameter value for parameter" << parameterName;
                 } else if ( parameterName == QLatin1String("city") ) {
                     request->setCity( parameterValue );
                 } else if ( parameterName == QLatin1String("stop") ) {
                     request->setStop( parameterValue );
                 } else if ( parameterName == QLatin1String("stopid") ) {
                     request->setStopId( parameterValue );
                 } else if ( parameterName == QLatin1String("targetstop") ) {
                     JourneyRequest *journeyRequest = dynamic_cast< JourneyRequest* >( request );
                     if ( !journeyRequest ) {
-                        kWarning() << "The 'targetstop' parameter is only used for journey requests";
+                        qWarning() << "The 'targetstop' parameter is only used for journey requests";
                     } else {
                         journeyRequest->setTargetStop( parameterValue );
                     }
                 } else if ( parameterName == QLatin1String("targetstopid") ) {
                     JourneyRequest *journeyRequest = dynamic_cast< JourneyRequest* >( request );
                     if ( !journeyRequest ) {
-                        kWarning() << "The 'targetstopId' parameter is only used for journey requests";
+                        qWarning() << "The 'targetstopId' parameter is only used for journey requests";
                     } else {
                         journeyRequest->setTargetStopId( parameterValue );
                     }
                 } else if ( parameterName == QLatin1String("originstop") ) {
                     JourneyRequest *journeyRequest = dynamic_cast< JourneyRequest* >( request );
                     if ( !journeyRequest ) {
-                        kWarning() << "The 'originstop' parameter is only used for journey requests";
+                        qWarning() << "The 'originstop' parameter is only used for journey requests";
                     } else {
                         journeyRequest->setStop( parameterValue );
                     }
                 } else if ( parameterName == QLatin1String("originstopid") ) {
                     JourneyRequest *journeyRequest = dynamic_cast< JourneyRequest* >( request );
                     if ( !journeyRequest ) {
-                        kWarning() << "The 'originstopId' parameter is only used for journey requests";
+                        qWarning() << "The 'originstopId' parameter is only used for journey requests";
                     } else {
                         journeyRequest->setStopId( parameterValue );
                     }
                 } else if ( parameterName == QLatin1String("timeoffset") ) {
                     request->setDateTime(
                             QDateTime::currentDateTime().addSecs(parameterValue.toInt() * 60) );
                 } else if ( parameterName == QLatin1String("time") ) {
                     request->setDateTime( QDateTime(QDate::currentDate(),
                                                     QTime::fromString(parameterValue, "hh:mm")) );
                 } else if ( parameterName == QLatin1String("datetime") ) {
                     request->setDateTime( QDateTime::fromString(parameterValue, Qt::ISODate) );
                     if ( !request->dateTime().isValid() ) {
                         request->setDateTime( QDateTime::fromString(parameterValue) );
                     }
                 } else if ( parameterName == QLatin1String("count") ) {
                     bool ok;
                     request->setCount( parameterValue.toInt(&ok) );
                     if ( !ok ) {
-                        kWarning() << "Bad value for 'count' in source name:" << parameterValue;
+                        qWarning() << "Bad value for 'count' in source name:" << parameterValue;
                         request->setCount( 20 );
                     }
                 } else if ( dynamic_cast<StopsByGeoPositionRequest*>(request) ) {
                     StopsByGeoPositionRequest *stopRequest =
                             dynamic_cast< StopsByGeoPositionRequest* >( request );
                     bool ok;
                     if ( parameterName == QLatin1String("longitude") ) {
                         stopRequest->setLongitude( parameterValue.toFloat(&ok) );
                         if ( !ok ) {
-                            kWarning() << "Bad value for 'longitude' in source name:" << parameterValue;
+                            qWarning() << "Bad value for 'longitude' in source name:" << parameterValue;
                         }
                     } else if ( parameterName == QLatin1String("latitude") ) {
                         stopRequest->setLatitude( parameterValue.toFloat(&ok) );
                         if ( !ok ) {
-                            kWarning() << "Bad value for 'latitude' in source name:" << parameterValue;
+                            qWarning() << "Bad value for 'latitude' in source name:" << parameterValue;
                         }
                     } else if ( parameterName == QLatin1String("distance") ) {
                         stopRequest->setDistance( parameterValue.toInt(&ok) );
                         if ( !ok ) {
-                            kWarning() << "Bad value for 'distance' in source name:" << parameterValue;
+                            qWarning() << "Bad value for 'distance' in source name:" << parameterValue;
                         }
                     } else {
-                        kWarning() << "Unknown argument" << parameterName;
+                        qWarning() << "Unknown argument" << parameterName;
                     }
                 } else {
-                    kWarning() << "Unknown argument" << parameterName;
+                    qWarning() << "Unknown argument" << parameterName;
                 }
             }
         }
 
         if ( !request->dateTime().isValid() ) {
             // No date/time value given, use default offset from now
             request->setDateTime( QDateTime::currentDateTime().addSecs(DEFAULT_TIME_OFFSET * 60) );
         }
 
         // The default parameter is the provider ID for data requesting sources,
         // use the default provider for the users country if no ID is given
         defaultParameter = PublicTransportEngine::fixProviderId( defaultParameter );
     } else {
         // Extract provider ID or country code, which follow after the source type keyword in name
         defaultParameter = name.mid( QString(sourceTypeKeyword(type)).length() ).trimmed();
     }
 }
 
 PublicTransportEngine::SourceRequestData::~SourceRequestData()
 {
     delete request;
 }
 
 bool PublicTransportEngine::SourceRequestData::isValid() const
 {
     if ( type == InvalidSourceName ) {
-        kWarning() << "Invalid source name" << name;
+        qWarning() << "Invalid source name" << name;
         return false;
     }
 
     if ( isDataRequestingSourceType(type) ) {
         if ( parseMode == ParseForDepartures || parseMode == ParseForArrivals ) {
             // Check if the stop name/ID is missing
             if ( !request || (request->stop().isEmpty() && request->stopId().isEmpty()) ) {
-                kWarning() << "No stop ID or name in data source name" << name;
+                qWarning() << "No stop ID or name in data source name" << name;
                 return false;
             }
         } else if ( parseMode == ParseForStopSuggestions ) {
             // Check if the stop name or geo coordinates are missing
             if ( !request || (!dynamic_cast<StopsByGeoPositionRequest*>(request) &&
                               request->stop().isEmpty()) )
             {
-                kWarning() << "Stop name (part) is missing in data source name" << name;
+                qWarning() << "Stop name (part) is missing in data source name" << name;
                 return false;
             }
         } else if ( parseMode == ParseForJourneysByArrivalTime ||
                     parseMode == ParseForJourneysByDepartureTime )
         {
             // Make sure non empty originstop(id) and targetstop(id) parameters are available
             JourneyRequest *journeyRequest = dynamic_cast< JourneyRequest* >( request );
             if ( !journeyRequest ) {
-                kWarning() << "Internal error: Not a JourneyRequest object but parseMode is"
+                qWarning() << "Internal error: Not a JourneyRequest object but parseMode is"
                            << parseMode;
                 return false;
             }
             if ( journeyRequest->stop().isEmpty() && journeyRequest->stopId().isEmpty() ) {
-                kWarning() << "No stop ID or name for the origin stop in data source name" << name;
+                qWarning() << "No stop ID or name for the origin stop in data source name" << name;
                 return false;
             }
             if ( journeyRequest->targetStop().isEmpty() &&
                  journeyRequest->targetStopId().isEmpty() )
             {
-                kWarning() << "No stop ID or name for the target stop in data source name" << name;
+                qWarning() << "No stop ID or name for the target stop in data source name" << name;
                 return false;
             }
         }
     }
 
     return true;
 }
 
 bool PublicTransportEngine::sourceRequestEvent( const QString &name )
 {
     // If name is associated with a data source that runs asynchronously,
     // create the source first with empty data, gets updated once the request has finished
     SourceRequestData data( name );
     if ( data.isValid() && isDataRequestingSourceType(data.type) ) {
         setData( name, DataEngine::Data() );
     }
 
     return requestOrUpdateSourceEvent( data );
 }
 
 bool PublicTransportEngine::updateSourceEvent( const QString &name )
 {
     return requestOrUpdateSourceEvent( SourceRequestData(name), true );
 }
 
 bool PublicTransportEngine::requestOrUpdateSourceEvent( const SourceRequestData &sourceData,
                                                         bool update )
 {
     if ( !sourceData.isValid() ) {
         return false;
     }
 
     switch ( sourceData.type ) {
     case ServiceProviderSource:
         return updateServiceProviderForCountrySource( sourceData );
     case ServiceProvidersSource:
         return updateServiceProviderSource();
     case ErroneousServiceProvidersSource:
         return updateErroneousServiceProviderSource();
     case LocationsSource:
         return updateLocationSource();
     case DeparturesSource:
     case ArrivalsSource:
     case StopsSource:
     case JourneysSource:
     case JourneysArrSource:
     case JourneysDepSource: {
         return updateTimetableDataSource( sourceData );
     }
 
     // This data source never changes, ie. needs no updates
     case VehicleTypesSource:
         if ( !update ) {
             initVehicleTypesSource();
         }
         return true;
 
     case InvalidSourceName:
     default:
         qDebug() << "Source name incorrect" << sourceData.name;
         return false;
     }
 }
 
 void PublicTransportEngine::initVehicleTypesSource()
 {
     QVariantHash vehicleTypes;
     const int index = Enums::staticMetaObject.indexOfEnumerator("VehicleType");
     const QMetaEnum enumerator = Enums::staticMetaObject.enumerator( index );
     // Start at i = 1 to skip Enums::InvalidVehicleType
     for ( int i = 1; i < enumerator.keyCount(); ++i ) {
         Enums::VehicleType vehicleType = static_cast< Enums::VehicleType >( enumerator.value(i) );
         QVariantHash vehicleTypeData;
         vehicleTypeData.insert( "id", enumerator.key(i) );
         vehicleTypeData.insert( "name", Global::vehicleTypeToString(vehicleType) );
         vehicleTypeData.insert( "namePlural", Global::vehicleTypeToString(vehicleType, true) );
         vehicleTypeData.insert( "iconName", Global::vehicleTypeToIcon(vehicleType) );
         vehicleTypes.insert( QString::number(enumerator.value(i)), vehicleTypeData );
     }
     setData( sourceTypeKeyword(VehicleTypesSource), vehicleTypes );
 }
 
 void PublicTransportEngine::timetableDataReceived( ServiceProvider *provider,
         const QUrl &requestUrl, const DepartureInfoList &items,
         const GlobalTimetableInfo &globalInfo, const DepartureRequest &request,
         bool deleteDepartureInfos, bool isDepartureData )
 {
     Q_UNUSED( requestUrl );
     Q_UNUSED( provider );
     Q_UNUSED( deleteDepartureInfos );
     const QString sourceName = request.sourceName();
     DEBUG_ENGINE_JOBS( items.count() << (isDepartureData ? "departures" : "arrivals")
                        << "received" << sourceName );
 
     const QString nonAmbiguousName = disambiguateSourceName( sourceName );
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
-        kWarning() << "Data source already removed";
+        qWarning() << "Data source already removed";
         return;
     }
     TimetableDataSource *dataSource =
             dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
     Q_ASSERT( dataSource );
     m_runningSources.removeOne( nonAmbiguousName );
     QVariantList departuresData;
     const QString itemKey = isDepartureData ? "departures" : "arrivals";
 
     foreach( const DepartureInfoPtr &departureInfo, items ) {
         QVariantHash departureData;
         TimetableData departure = departureInfo->data();
         for ( TimetableData::ConstIterator it = departure.constBegin();
               it != departure.constEnd(); ++it )
         {
             if ( it.value().isValid() ) {
                 departureData.insert( Global::timetableInformationToString(it.key()), it.value() );
             }
         }
 
         departureData.insert( "Nightline", departureInfo->isNightLine() );
         departureData.insert( "Expressline", departureInfo->isExpressLine() );
 
         // Add existing additional data
         const uint hash = TimetableDataSource::hashForDeparture( departure, isDepartureData );
         if ( dataSource->additionalData().contains(hash) ) {
             // Found already downloaded additional data, add it to the updated departure data
             const TimetableData additionalData = dataSource->additionalData( hash );
             if ( !additionalData.isEmpty() ) {
                 bool hasAdditionalData = false;
                 for ( TimetableData::ConstIterator it = additionalData.constBegin();
                       it != additionalData.constEnd(); ++it )
                 {
                     if ( it.key() != Enums::RouteDataUrl ) {
                         hasAdditionalData = true;
                     }
                     departureData.insert( Global::timetableInformationToString(it.key()), it.value() );
                 }
                 departureData[ "additionalDataState" ] = hasAdditionalData ? "included" : "error";
             }
         }
 
         if ( !departureData.contains("additionalDataState") ) {
             departureData[ "additionalDataState" ] =
                     provider->features().contains(Enums::ProvidesAdditionalData)
                     ? "notrequested" : "notsupported";
         }
 
         departuresData << departureData;
     }
 
     // Cleanup the data source later
     startDataSourceCleanupLater( dataSource );
 
     dataSource->setValue( itemKey, departuresData );
 
 //     if ( deleteDepartureInfos ) {
 //         qDebug() << "Delete" << items.count() << "departures/arrivals";
 //         qDeleteAll( departures );
 //     }
 
     // Fill the data source with general information
     const QDateTime dateTime = QDateTime::currentDateTime();
     dataSource->setValue( "serviceProvider", provider->id() );
     dataSource->setValue( "delayInfoAvailable", globalInfo.delayInfoAvailable );
     dataSource->setValue( "requestUrl", requestUrl );
     dataSource->setValue( "parseMode", request.parseModeName() );
     dataSource->setValue( "error", false );
     dataSource->setValue( "updated", dateTime );
 
     // Store a proposal for the next download time
     QDateTime last = items.isEmpty() ? dateTime
             : items.last()->value(Enums::DepartureDateTime).toDateTime();
     dataSource->setNextDownloadTimeProposal( dateTime.addSecs(dateTime.secsTo(last) / 3) );
     const QDateTime nextUpdateTime = provider->nextUpdateTime( dataSource->updateFlags(),
             dateTime, dataSource->nextDownloadTimeProposal(), dataSource->data() );
     const QDateTime minManualUpdateTime = provider->nextUpdateTime(
             dataSource->updateFlags() | UpdateWasRequestedManually,
             dateTime, dataSource->nextDownloadTimeProposal(), dataSource->data() );
 
     // Store update times in the data source
     dataSource->setValue( "nextAutomaticUpdate", nextUpdateTime );
     dataSource->setValue( "minManualUpdateTime", minManualUpdateTime );
 
     // Publish the data source and cache it
     publishData( dataSource );
     m_dataSources[ nonAmbiguousName ] = dataSource;
 
     int msecsUntilUpdate = dateTime.msecsTo( nextUpdateTime );
     Q_ASSERT( msecsUntilUpdate >= 10000 ); // Make sure to not produce too many updates by mistake
     DEBUG_ENGINE_JOBS( "Update data source in"
                        << KGlobal::locale()->prettyFormatDuration(msecsUntilUpdate) );
     if ( !dataSource->updateTimer() ) {
         QTimer *updateTimer = new QTimer( this );
         connect( updateTimer, SIGNAL(timeout()), this, SLOT(updateTimeout()) );
         dataSource->setUpdateTimer( updateTimer );
     }
     dataSource->updateTimer()->start( msecsUntilUpdate );
 }
 
 void PublicTransportEngine::startDataSourceCleanupLater( TimetableDataSource *dataSource )
 {
     if ( !dataSource->cleanupTimer() ) {
         QTimer *cleanupTimer = new QTimer( this );
         cleanupTimer->setInterval( 2500 );
         connect( cleanupTimer, SIGNAL(timeout()), this, SLOT(cleanupTimeout()) );
         dataSource->setCleanupTimer( cleanupTimer );
     }
     dataSource->cleanupTimer()->start();
 }
 
 void PublicTransportEngine::updateTimeout()
 {
     // Find the timetable data source to which the timer belongs which timeout() signal was emitted
     QTimer *timer = qobject_cast< QTimer* >( sender() );
     TimetableDataSource *dataSource = dataSourceFromTimer( timer );
     if ( !dataSource ) {
         // No data source found that started the timer,
         // should not happen the data source should have deleted the timer on destruction
-        kWarning() << "Timeout received from an unknown update timer";
+        qWarning() << "Timeout received from an unknown update timer";
         return;
     }
 
     // Found the timetable data source of the timer,
     // requests updates for all connected sources (possibly multiple combined stops)
     foreach ( const QString &sourceName, dataSource->usingDataSources() ) {
         updateTimetableDataSource( SourceRequestData(sourceName) );
     }  // TODO FIXME Do not update while running additional data requests?
 }
 
 void PublicTransportEngine::cleanupTimeout()
 {
     // Find the timetable data source to which the timer belongs which timeout() signal was emitted
     QTimer *timer = qobject_cast< QTimer* >( sender() );
     TimetableDataSource *dataSource = dataSourceFromTimer( timer );
     if ( !dataSource ) {
         // No data source found that started the timer,
         // should not happen the data source should have deleted the timer on destruction
-        kWarning() << "Timeout received from an unknown cleanup timer";
+        qWarning() << "Timeout received from an unknown cleanup timer";
         return;
     }
 
     // Found the timetable data source of the timer
     dataSource->cleanup();
     dataSource->setCleanupTimer( 0 ); // Deletes the timer
 }
 
 void PublicTransportEngine::additionalDataReceived( ServiceProvider *provider,
         const QUrl &requestUrl, const TimetableData &data, const AdditionalDataRequest &request )
 {
     Q_UNUSED( provider );
     Q_UNUSED( requestUrl );
 
     // Check if the destination data source exists
     const QString nonAmbiguousName = disambiguateSourceName( request.sourceName() );
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
-        kWarning() << "Additional data received for a source that was already removed:"
+        qWarning() << "Additional data received for a source that was already removed:"
                    << nonAmbiguousName;
         emit additionalDataRequestFinished( request.sourceName(), request.itemNumber(), false,
                                             "Data source to update was already removed" );
         return;
     }
 
     // Get the list of timetable items from the existing data source
     TimetableDataSource *dataSource =
             dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
     Q_ASSERT( dataSource );
     QVariantList items = dataSource->timetableItems();
     if ( request.itemNumber() >= items.count() ) {
         emit additionalDataRequestFinished( request.sourceName(), request.itemNumber(), false,
                 QString("Item %1 not found in the data source (with %2 items)")
                 .arg(request.itemNumber()).arg(items.count()) );
         return;
     }
 
     // Get the timetable item for which additional data was received
     // and insert the new data into it
     bool newDataInserted = false;
     TimetableData _data = data;
     QVariantHash item = items[ request.itemNumber() ].toHash();
     for ( TimetableData::ConstIterator it = data.constBegin(); it != data.constEnd(); ++it ) {
         // Check if there already is data in the current additional data field
         const QString key = Global::timetableInformationToString( it.key() );
         const bool isRouteDataUrl = key == Enums::toString(Enums::RouteDataUrl);
         if ( item.contains(key) && item[key].isValid() && !isRouteDataUrl ) {
             // The timetable item already contains data for the current field,
             // do not allow updates here, only additional data
-            kWarning() << "Cannot update timetable data in additional data requests";
-            kWarning() << "Tried to update field" << key << "to value" << it.value()
+            qWarning() << "Cannot update timetable data in additional data requests";
+            qWarning() << "Tried to update field" << key << "to value" << it.value()
                        << "from value" << item[key] << "in data source" << request.sourceName();
         } else {
             // Allow to add the additional data field
             item.insert( key, it.value() );
             if ( !isRouteDataUrl ) {
                 newDataInserted = true;
 
                 if ( key == Enums::toString(Enums::RouteStops) ) {
                     // Added a RouteStops field, automatically generate RouteStopsShortened
                     const QString routeStopsShortenedKey =
                             Global::timetableInformationToString( Enums::RouteStopsShortened );
                     if ( !item.contains(routeStopsShortenedKey) ) {
                         const QStringList routeStopsShortened =
                                 removeCityNameFromStops( it.value().toStringList() );
                         item.insert( routeStopsShortenedKey, routeStopsShortened );
                         _data.insert( Enums::RouteStopsShortened, routeStopsShortened );
                     }
                 }
             }
         }
     }
 
     if ( !newDataInserted ) {
         const QString errorMessage = i18nc("@info/plain", "No additional data found");
         emit additionalDataRequestFinished( request.sourceName(), request.itemNumber(),
                                             false, errorMessage );
         item[ "additionalDataState" ] = "error";
         item[ "additionalDataError" ] = errorMessage;
         items[ request.itemNumber() ] = item;
         dataSource->setTimetableItems( items );
         return;
     }
 
     item[ "additionalDataState" ] = "included";
 
     // Store the changed item back into the item list of the data source
     items[ request.itemNumber() ] = item;
     dataSource->setTimetableItems( items );
 
     // Also store received additional data separately
     // to not loose additional data after updating the data source
     const uint hash = TimetableDataSource::hashForDeparture( item,
             dataSource->timetableItemKey() != QLatin1String("arrivals") );
     dataSource->setAdditionalData( hash, _data );
     startDataSourceCleanupLater( dataSource );
 
     QTimer *updateDelayTimer;
     if ( dataSource->updateAdditionalDataDelayTimer() ) {
         // Use existing timer, restart it with a longer interval and
         // publish the new data of the data source after the timeout
         updateDelayTimer = dataSource->updateAdditionalDataDelayTimer();
         updateDelayTimer->setInterval( 250 );
     } else {
         // Create timer with a shorter interval, but directly publish the new data of the
         // data source. The timer is used here to delay further publishing of new data,
         // ie. combine multiple updates and publish them at once.
         publishData( dataSource );
         updateDelayTimer = new QTimer( this );
         updateDelayTimer->setInterval( 150 );
         connect( updateDelayTimer, SIGNAL(timeout()),
                  this, SLOT(updateDataSourcesWithNewAdditionData()) );
         dataSource->setUpdateAdditionalDataDelayTimer( updateDelayTimer );
     }
 
     // (Re-)start the additional data update timer
     updateDelayTimer->start();
 
     // Emit result
     emit additionalDataRequestFinished( request.sourceName(), request.itemNumber(), true );
 }
 
 TimetableDataSource *PublicTransportEngine::dataSourceFromTimer( QTimer *timer ) const
 {
     for ( QHash< QString, DataSource* >::ConstIterator it = m_dataSources.constBegin();
           it != m_dataSources.constEnd(); ++it )
     {
         TimetableDataSource *dataSource = dynamic_cast< TimetableDataSource* >( *it );
         if ( dataSource && (dataSource->updateAdditionalDataDelayTimer() == timer ||
                             dataSource->updateTimer() == timer ||
                             dataSource->cleanupTimer() == timer) )
         {
             return dataSource;
         }
     }
 
     // The timer is not used any longer
     return 0;
 }
 
 void PublicTransportEngine::updateDataSourcesWithNewAdditionData()
 {
     QTimer *updateDelayTimer = qobject_cast< QTimer* >( sender() );
     Q_ASSERT( updateDelayTimer );
     TimetableDataSource *dataSource = dataSourceFromTimer( updateDelayTimer );
     if ( !dataSource ) {
-        kWarning() << "Data source was already removed";
+        qWarning() << "Data source was already removed";
         return;
     }
 
     const int interval = updateDelayTimer->interval();
     dataSource->setUpdateAdditionalDataDelayTimer( 0 ); // Deletes the timer
 
     // Do the upate, but only after long delays,
     // because the update is already done before short delays
     if ( interval > 150 ) {
         // Was delayed for a longer time
         publishData( dataSource );
     }
 }
 
 void PublicTransportEngine::departuresReceived( ServiceProvider *provider,
         const QUrl &requestUrl, const DepartureInfoList &departures,
         const GlobalTimetableInfo &globalInfo, const DepartureRequest &request,
         bool deleteDepartureInfos )
 {
     timetableDataReceived( provider, requestUrl, departures, globalInfo, request,
                            deleteDepartureInfos, true );
 }
 
 void PublicTransportEngine::arrivalsReceived( ServiceProvider *provider, const QUrl &requestUrl,
         const ArrivalInfoList &arrivals, const GlobalTimetableInfo &globalInfo,
         const ArrivalRequest &request, bool deleteDepartureInfos )
 {
     timetableDataReceived( provider, requestUrl, arrivals, globalInfo, request,
                            deleteDepartureInfos, false );
 }
 
 void PublicTransportEngine::journeysReceived( ServiceProvider* provider,
         const QUrl &requestUrl, const JourneyInfoList &journeys,
         const GlobalTimetableInfo &globalInfo,
         const JourneyRequest &request,
         bool deleteJourneyInfos )
 {
     Q_UNUSED( provider );
     Q_UNUSED( deleteJourneyInfos );
     const QString sourceName = request.sourceName();
     DEBUG_ENGINE_JOBS( journeys.count() << "journeys received" << sourceName );
 
     const QString nonAmbiguousName = disambiguateSourceName( sourceName );
     m_runningSources.removeOne( nonAmbiguousName );
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
-        kWarning() << "Data source already removed" << nonAmbiguousName;
+        qWarning() << "Data source already removed" << nonAmbiguousName;
         return;
     }
     TimetableDataSource *dataSource =
             dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
     if ( !dataSource ) {
-        kWarning() << "Data source already deleted" << nonAmbiguousName;
+        qWarning() << "Data source already deleted" << nonAmbiguousName;
         return;
     }
     dataSource->clear();
     QVariantList journeysData;
     foreach( const JourneyInfoPtr &journeyInfo, journeys ) {
         if ( !journeyInfo->isValid() ) {
             continue;
         }
 
         QVariantHash journeyData;
         TimetableData journey = journeyInfo->data();
         for ( TimetableData::ConstIterator it = journey.constBegin();
               it != journey.constEnd(); ++it )
         {
             if ( it.value().isValid() ) {
                 journeyData.insert( Global::timetableInformationToString(it.key()), it.value() );
             }
         }
 
         journeysData << journeyData;
     }
 
     dataSource->setValue( "journeys", journeysData );
 
     int journeyCount = journeys.count();
     QDateTime first, last;
     if ( journeyCount > 0 ) {
         first = journeys.first()->value(Enums::DepartureDateTime).toDateTime();
         last = journeys.last()->value(Enums::DepartureDateTime).toDateTime();
     } else {
         first = last = QDateTime::currentDateTime();
     }
 //     if ( deleteJourneyInfos ) {
 //         qDeleteAll( journeys ); TODO
 //     }
 
     // Store a proposal for the next download time
     int secs = ( journeyCount / 3 ) * first.secsTo( last );
     QDateTime downloadTime = QDateTime::currentDateTime().addSecs( secs );
     dataSource->setNextDownloadTimeProposal( downloadTime );
 
     // Store received data in the data source map
     dataSource->setValue( "serviceProvider", provider->id() );
     dataSource->setValue( "delayInfoAvailable", globalInfo.delayInfoAvailable );
     dataSource->setValue( "requestUrl", requestUrl );
     dataSource->setValue( "parseMode", request.parseModeName() );
     dataSource->setValue( "error", false );
     dataSource->setValue( "updated", QDateTime::currentDateTime() );
     dataSource->setValue( "nextAutomaticUpdate", downloadTime );
     dataSource->setValue( "minManualUpdateTime", downloadTime ); // TODO
     setData( sourceName, dataSource->data() );
     m_dataSources[ nonAmbiguousName ] = dataSource;
 }
 
 void PublicTransportEngine::stopsReceived( ServiceProvider *provider,
         const QUrl &requestUrl, const StopInfoList &stops,
         const StopSuggestionRequest &request, bool deleteStopInfos )
 {
     Q_UNUSED( provider );
     Q_UNUSED( deleteStopInfos );
 
     const QString sourceName = request.sourceName();
     m_runningSources.removeOne( disambiguateSourceName(sourceName) );
     DEBUG_ENGINE_JOBS( stops.count() << "stop suggestions received" << sourceName );
 
     QVariantList stopsData;
     foreach( const StopInfoPtr &stopInfo, stops ) {
         QVariantHash stopData;
         TimetableData stop = stopInfo->data();
         for ( TimetableData::ConstIterator it = stop.constBegin();
               it != stop.constEnd(); ++it )
         {
             if ( it.value().isValid() ) {
                 stopData.insert( Global::timetableInformationToString(it.key()), it.value() );
             }
         }
         stopsData << stopData;
     }
     setData( sourceName, "stops", stopsData );
     setData( sourceName, "serviceProvider", provider->id() );
     setData( sourceName, "requestUrl", requestUrl );
     setData( sourceName, "parseMode", request.parseModeName() );
     setData( sourceName, "error", false );
     setData( sourceName, "updated", QDateTime::currentDateTime() );
 
 //     if ( deleteStopInfos ) {
 //         qDeleteAll( stops ); TODO
 //     }
 }
 
 void PublicTransportEngine::requestFailed( ServiceProvider *provider,
         ErrorCode errorCode, const QString &errorMessage,
         const QUrl &requestUrl, const AbstractRequest *request )
 {
     Q_UNUSED( provider );
     qDebug() << errorCode << errorMessage << "- Requested URL:" << requestUrl;
 
     const AdditionalDataRequest *additionalDataRequest =
             dynamic_cast< const AdditionalDataRequest* >( request );
     if ( additionalDataRequest ) {
         // A request for additional data failed
         emit additionalDataRequestFinished( request->sourceName(),
                 additionalDataRequest->itemNumber(), false, errorMessage );
 
         // Check if the destination data source exists
         const QString nonAmbiguousName = disambiguateSourceName( request->sourceName() );
         if ( m_dataSources.contains(nonAmbiguousName) ) {
             // Get the list of timetable items from the existing data source
             TimetableDataSource *dataSource =
                     dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
             Q_ASSERT( dataSource );
             QVariantList items = dataSource->timetableItems();
             if ( additionalDataRequest->itemNumber() < items.count() ) {
                 // Found the item for which the request failed,
                 // reset additional data included/waiting fields
                 QVariantHash item = items[ additionalDataRequest->itemNumber() ].toHash();
                 item[ "additionalDataState" ] = "error";
                 item[ "additionalDataError" ] = errorMessage;
 
                 items[ additionalDataRequest->itemNumber() ] = item;
                 dataSource->setTimetableItems( items );
 
                 // Publish updated fields
                 publishData( dataSource );
             } else {
-                kWarning() << "Timetable item" << additionalDataRequest->itemNumber()
+                qWarning() << "Timetable item" << additionalDataRequest->itemNumber()
                            << "not found in data source" << request->sourceName()
                            << "additional data error discarded";
             }
         } else {
-            kWarning() << "Data source" << request->sourceName()
+            qWarning() << "Data source" << request->sourceName()
                        << "not found, additional data error discarded";
         }
 
         // Do not mark the whole timetable data source as erroneous
         // when a request for additional data has failed
         return;
     }
 
     // Remove erroneous source from running sources list
     m_runningSources.removeOne( disambiguateSourceName(request->sourceName()) );
 
     const QString sourceName = request->sourceName();
     setData( sourceName, "serviceProvider", provider->id() );
     setData( sourceName, "requestUrl", requestUrl );
     setData( sourceName, "parseMode", request->parseModeName() );
     setData( sourceName, "receivedData", "nothing" );
     setData( sourceName, "error", true );
     setData( sourceName, "errorCode", errorCode );
     setData( sourceName, "errorMessage", errorMessage );
     setData( sourceName, "updated", QDateTime::currentDateTime() );
 }
 
 bool PublicTransportEngine::requestUpdate( const QString &sourceName )
 {
     // Find the TimetableDataSource object for sourceName
     const QString nonAmbiguousName = disambiguateSourceName( sourceName );
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
-        kWarning() << "Not an existing timetable data source:" << sourceName;
+        qWarning() << "Not an existing timetable data source:" << sourceName;
         emit updateRequestFinished( sourceName, false,
                 i18nc("@info", "Data source is not an existing timetable data source: %1",
                       sourceName) );
         return false;
     }
     TimetableDataSource *dataSource =
             dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
     if ( !dataSource ) {
-        kWarning() << "Internal error: Invalid pointer to the data source stored";
+        qWarning() << "Internal error: Invalid pointer to the data source stored";
         emit updateRequestFinished( sourceName, false,
                                     "Internal error: Invalid pointer to the data source stored" );
         return false;
     }
 
     // Check if updates are blocked to prevent to many useless updates
     const QDateTime nextUpdateTime = sourceUpdateTime( dataSource, UpdateWasRequestedManually );
     if ( QDateTime::currentDateTime() < nextUpdateTime ) {
         qDebug() << "Too early to update again, update request rejected" << nextUpdateTime;
         emit updateRequestFinished( sourceName, false,
                 i18nc("@info", "Update request rejected, earliest update time: %1",
                       nextUpdateTime.toString()) );
         return false;
     }
 
     // Stop automatic updates
     dataSource->stopUpdateTimer();
 
     // Start the request
     const bool result = request( sourceName );
     if ( result ) {
         emit updateRequestFinished( sourceName );
     } else {
         emit updateRequestFinished( sourceName, false, i18nc("@info", "Request failed") );
     }
     return result;
 }
 
 bool PublicTransportEngine::requestMoreItems( const QString &sourceName,
                                               Enums::MoreItemsDirection direction )
 {
     // Find the TimetableDataSource object for sourceName
     const QString nonAmbiguousName = disambiguateSourceName( sourceName );
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
-        kWarning() << "Not an existing timetable data source:" << sourceName;
+        qWarning() << "Not an existing timetable data source:" << sourceName;
         emit moreItemsRequestFinished( sourceName, direction, false,
                 i18nc("@info", "Data source is not an existing timetable data source: %1",
                       sourceName) );
         return false;
     } else if ( m_runningSources.contains(nonAmbiguousName) ) {
         // The data source currently gets processed or updated, including requests for more items
         qDebug() << "Source currently gets processed, please wait" << sourceName;
         emit moreItemsRequestFinished( sourceName, direction, false,
                 i18nc("@info", "Source currently gets processed, please try again later") );
         return false;
     }
 
     TimetableDataSource *dataSource =
             dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
     if ( !dataSource ) {
-        kWarning() << "Internal error: Invalid pointer to the data source stored";
+        qWarning() << "Internal error: Invalid pointer to the data source stored";
         emit moreItemsRequestFinished( sourceName, direction, false, "Internal error" );
         return false;
     }
 
     const SourceRequestData data( sourceName );
     qDebug() << data.defaultParameter;
     const ProviderPointer provider = providerFromId( data.defaultParameter );
     if ( provider.isNull() ) {
         // Service provider couldn't be created, should only happen after provider updates,
         // where the provider worked to get timetable items, but the new provider version
         // does not work any longer and no more items can be requested
         emit moreItemsRequestFinished( sourceName, direction, false,
                                        "Provider could not be created" );
         return false;
     }
 
     // Start the request
     QSharedPointer< AbstractRequest > request = dataSource->request( sourceName );
     const QVariantList items = dataSource->timetableItems();
     if ( items.isEmpty() ) {
         // TODO
-        kWarning() << "No timetable items in data source" << sourceName;
+        qWarning() << "No timetable items in data source" << sourceName;
         emit moreItemsRequestFinished( sourceName, direction, false,
                 i18nc("@info", "No timetable items in data source") );
         return false;
     }
     const QVariantHash item =
             (direction == Enums::EarlierItems ? items.first() : items.last()).toHash();
     const QVariantMap _requestData = item[Enums::toString(Enums::RequestData)].toMap();
 
     // TODO Convert to hash from map..
     QVariantHash requestData;
     for ( QVariantMap::ConstIterator it = _requestData.constBegin(); it != _requestData.constEnd(); ++it ) {
         requestData.insert( it.key(), it.value() );
     }
 
     // Start the request
     m_runningSources << nonAmbiguousName;
     provider->requestMoreItems( MoreItemsRequest(sourceName, request, requestData, direction) );
     emit moreItemsRequestFinished( sourceName, direction );
     return true;
 }
 
 ErrorCode PublicTransportEngine::errorCodeFromState( const QString &stateId )
 {
     if ( stateId == QLatin1String("ready") ) {
         return NoError;
     } else if ( stateId == QLatin1String("gtfs_feed_import_pending") ||
                 stateId == QLatin1String("importing_gtfs_feed") )
     {
         return ErrorNeedsImport;
     } else {
         return ErrorParsingFailed;
     }
 }
 
 bool PublicTransportEngine::request( const SourceRequestData &data )
 {
     // Try to get the specific provider from m_providers (if it's not in there it is created)
     const ProviderPointer provider = providerFromId( data.defaultParameter );
     if ( provider.isNull() || provider->type() == Enums::InvalidProvider ) {
         // Service provider couldn't be created
         // Remove erroneous source from running sources list
         const QString sourceName = data.request->sourceName();
         m_runningSources.removeOne( disambiguateSourceName(sourceName) );
 
         ProvidersDataSource *dataSource = providersDataSource();
         const QString state = dataSource->providerState( data.defaultParameter );
         if ( state != QLatin1String("ready") ) {
             const QVariantHash stateData = dataSource->providerStateData( data.defaultParameter );
             setData( sourceName, "serviceProvider", data.defaultParameter );
             setData( sourceName, "parseMode", data.request->parseModeName() );
             setData( sourceName, "receivedData", "nothing" );
             setData( sourceName, "error", true );
             setData( sourceName, "errorCode", errorCodeFromState(state) );
             setData( sourceName, "errorMessage", stateData["statusMessage"].toString() );
             setData( sourceName, "updated", QDateTime::currentDateTime() );
         }
         return false;
     } else if ( provider->useSeparateCityValue() && data.request->city().isEmpty() &&
                 !dynamic_cast<StopsByGeoPositionRequest*>(data.request) )
     {
         qDebug() << QString("Service provider %1 needs a separate city value. Add to source name "
                             "'|city=X', where X stands for the city name.")
                     .arg( data.defaultParameter );
         return false; // Service provider needs a separate city value
     } else if ( !provider->features().contains(Enums::ProvidesJourneys) &&
                 (data.parseMode == ParseForJourneysByDepartureTime ||
                  data.parseMode == ParseForJourneysByArrivalTime) )
     {
         qDebug() << QString("Service provider %1 doesn't support journey searches.")
                     .arg( data.defaultParameter );
         return false; // Service provider doesn't support journey searches
     }
 
     // Store source name as currently being processed, to not start another
     // request if there is already a running one
     m_runningSources << disambiguateSourceName( data.name );
 
     // Start the request
     provider->request( data.request );
     return true;
 }
 
 int PublicTransportEngine::secsUntilUpdate( const QString &sourceName, QString *errorMessage )
 {
     return getSecsUntilUpdate( sourceName, errorMessage );
 }
 
 int PublicTransportEngine::minSecsUntilUpdate( const QString &sourceName, QString *errorMessage )
 {
     return getSecsUntilUpdate( sourceName, errorMessage, UpdateWasRequestedManually );
 }
 
 int PublicTransportEngine::getSecsUntilUpdate( const QString &sourceName, QString *errorMessage,
                                                UpdateFlags updateFlags )
 {
     const QString nonAmbiguousName = disambiguateSourceName( sourceName );
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
         // The data source is not a timetable data source or does not exist
         if ( errorMessage ) {
             *errorMessage = i18nc("@info", "Data source is not an existing timetable "
                                   "data source: %1", sourceName);
         }
         return -1;
     }
     TimetableDataSource *dataSource = dynamic_cast< TimetableDataSource* >(
             m_dataSources[nonAmbiguousName] );
     if ( !dataSource ) {
-        kWarning() << "Internal error: Invalid pointer to the data source stored";
+        qWarning() << "Internal error: Invalid pointer to the data source stored";
         return -1;
     }
 
     const QDateTime time = sourceUpdateTime( dataSource, updateFlags );
     return qMax( -1, QDateTime::currentDateTime().secsTo(time) );
 }
 
 QDateTime PublicTransportEngine::sourceUpdateTime( TimetableDataSource *dataSource,
                                                    UpdateFlags updateFlags )
 {
     const QString providerId = fixProviderId( dataSource->providerId() );
     const ProviderPointer provider = providerFromId( providerId );
     if ( provider.isNull() || provider->type() == Enums::InvalidProvider ) {
         return QDateTime();
     }
 
     return provider->nextUpdateTime( dataSource->updateFlags() | updateFlags,
                                      dataSource->lastUpdate(),
                                      dataSource->nextDownloadTimeProposal(), dataSource->data() );
 }
 
 bool PublicTransportEngine::isSourceUpToDate( const QString &nonAmbiguousName,
                                               UpdateFlags updateFlags )
 {
     if ( !m_dataSources.contains(nonAmbiguousName) ) {
         return false;
     }
 
     TimetableDataSource *dataSource =
             dynamic_cast< TimetableDataSource* >( m_dataSources[nonAmbiguousName] );
     if ( !dataSource ) {
         // The data source is not a timetable data source, no periodic updates needed
         return true;
     }
 
     const QDateTime nextUpdateTime = sourceUpdateTime( dataSource, updateFlags );
     DEBUG_ENGINE_JOBS( "Wait time until next download:" << KGlobal::locale()->prettyFormatDuration(
                        (QDateTime::currentDateTime().msecsTo(nextUpdateTime))) );
     return QDateTime::currentDateTime() < nextUpdateTime;
 }
 
 ServiceProvider *PublicTransportEngine::createProvider( const QString &serviceProviderId,
         QObject *parent, const QSharedPointer<KConfig> &cache )
 {
     ServiceProviderData *data = ServiceProviderDataReader::read( serviceProviderId );
     return data ? createProviderForData(data, parent, cache) : 0;
 }
 
 ServiceProvider *PublicTransportEngine::createProviderForData( const ServiceProviderData *data,
         QObject *parent, const QSharedPointer<KConfig> &cache )
 {
     if ( !ServiceProviderGlobal::isProviderTypeAvailable(data->type()) ) {
-        kWarning() << "Cannot create provider of type" << data->typeName() << "because the engine "
+        qWarning() << "Cannot create provider of type" << data->typeName() << "because the engine "
                       "has been built without support for that provider type";
         return 0;
     }
 
     // Warn if the format of the provider plugin is unsupported
     if ( data->fileFormatVersion() != QLatin1String("1.1") ) {
-        kWarning() << "The Provider" << data->id() << "was designed for an unsupported "
+        qWarning() << "The Provider" << data->id() << "was designed for an unsupported "
                 "provider plugin format version, update to version 1.1";
         return 0;
     }
 
     switch ( data->type() ) {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Enums::ScriptedProvider:
         return new ServiceProviderScript( data, parent, cache );
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case Enums::GtfsProvider:
         return new ServiceProviderGtfs( data, parent, cache );
 #endif
     case Enums::InvalidProvider:
     default:
-        kWarning() << "Invalid/unknown provider type" << data->type();
+        qWarning() << "Invalid/unknown provider type" << data->type();
         return 0;
     }
 }
 
 QStringList PublicTransportEngine::removeCityNameFromStops( const QStringList &stopNames )
 {
     // Find words at the beginning/end of target and route stop names that have many
     // occurrences. These words are most likely the city names where the stops are in.
     // But the timetable becomes easier to read and looks nicer, if not each stop name
     // includes the same city name.
     QHash< QString, int > firstWordCounts; // Counts occurrences of words at the beginning
     QHash< QString, int > lastWordCounts; // Counts occurrences of words at the end
 
     // minWordOccurrence is the minimum occurence count of a word in stop names to have the word
     // removed. maxWordOccurrence is the maximum number of occurences to count, if this number
     // of occurences has been found, just remove that word.
     const int minWordOccurrence = qMax( 2, stopNames.count() );
     const int maxWordOccurrence = qMax( 3, stopNames.count() / 2 );
 
     // This regular expression gets used to search for word at the end, possibly including
     // a colon before the last word
     QRegExp rxLastWord( ",?\\s+\\S+$" );
 
     // These strings store the words with the most occurrences in stop names at the beginning/end
     QString removeFirstWord;
     QString removeLastWord;
 
     // Analyze stop names
     foreach ( const QString &stopName, stopNames ) {
         // Find word to remove from beginning/end of stop names, if not already found
         if ( !removeFirstWord.isEmpty() || !removeLastWord.isEmpty() ) {
             break;
         }
 
         int pos = stopName.indexOf( ' ' );
         const QString newFirstWord = stopName.left( pos );
         if ( pos > 0 && ++firstWordCounts[newFirstWord] >= maxWordOccurrence ) {
             removeFirstWord = newFirstWord;
         }
         if ( rxLastWord.indexIn(stopName) != -1 &&
              ++lastWordCounts[rxLastWord.cap()] >= maxWordOccurrence )
         {
             removeLastWord = rxLastWord.cap();
         }
     }
 
     // Remove word with most occurrences from beginning/end of stop names
     if ( removeFirstWord.isEmpty() && removeLastWord.isEmpty() ) {
         // If no first/last word with at least maxWordOccurrence occurrences was found,
         // find the word with the most occurrences
         int max = 0;
 
         // Find word at the beginning with most occurrences
         for ( QHash< QString, int >::ConstIterator it = firstWordCounts.constBegin();
               it != firstWordCounts.constEnd(); ++it )
         {
             if ( it.value() > max ) {
                 max = it.value();
                 removeFirstWord = it.key();
             }
         }
 
         // Find word at the end with more occurrences
         for ( QHash< QString, int >::ConstIterator it = lastWordCounts.constBegin();
               it != lastWordCounts.constEnd(); ++it )
         {
             if ( it.value() > max ) {
                 max = it.value();
                 removeLastWord = it.key();
             }
         }
 
         if ( max < minWordOccurrence ) {
             // The first/last word with the most occurrences has too few occurrences
             // Do not remove any word
             removeFirstWord.clear();
             removeLastWord.clear();
         } else if ( !removeLastWord.isEmpty() ) {
             // removeLastWord has more occurrences than removeFirstWord
             removeFirstWord.clear();
         }
     }
 
     if ( !removeFirstWord.isEmpty() ) {
         // Remove removeFirstWord from all stop names
         QStringList returnStopNames;
         foreach ( const QString &stopName, stopNames ) {
             if ( stopName.startsWith(removeFirstWord) ) {
                 returnStopNames << stopName.mid( removeFirstWord.length() + 1 );
             } else {
                 returnStopNames << stopName;
             }
         }
         return returnStopNames;
     } else if ( !removeLastWord.isEmpty() ) {
         // Remove removeLastWord from all stop names
         QStringList returnStopNames;
         foreach ( const QString &stopName, stopNames ) {
             if ( stopName.endsWith(removeLastWord) ) {
                 returnStopNames << stopName.left( stopName.length() - removeLastWord.length() );
             } else {
                 returnStopNames << stopName;
             }
         }
         return returnStopNames;
     } else {
         // Nothing to remove found
         return stopNames;
     }
 }
 
 // This does the magic that allows Plasma to load
 // this plugin.  The first argument must match
 // the X-Plasma-EngineName in the .desktop file.
 K_EXPORT_PLASMA_DATAENGINE( publictransport, PublicTransportEngine )
 
 // this is needed since PublicTransportEngine is a QObject
 #include "build/publictransportdataengine.moc"
diff --git a/engine/script/script_thread.cpp b/engine/script/script_thread.cpp
index bcae49c..290a4fa 100644
--- a/engine/script/script_thread.cpp
+++ b/engine/script/script_thread.cpp
@@ -1,907 +1,907 @@
 /*
  *   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 "script_thread.h"
 
 // Own includes
 #include "config.h"
 #include "scriptapi.h"
 #include "script/serviceproviderscript.h"
 #include "serviceproviderdata.h"
 #include "request.h"
 #include "serviceproviderglobal.h"
 
 // KDE includes
 #include <ThreadWeaver/Thread>
 #include <ThreadWeaver/Weaver>
 #include <KLocalizedString>
 #include <KDebug>
 #include <KGlobal>
 #include <KStandardDirs>
 #include <KLocale>
 
 // Qt includes
 #include <QScriptEngine>
 #include <QScriptEngineAgent>
 #include <QScriptValueIterator>
 #include <QScriptContextInfo>
 #include <QFile>
 #include <QTimer>
 #include <QEventLoop>
 #include <QFileInfo>
 #include <QApplication>
 
 ScriptJob::ScriptJob( const ScriptData &data, const QSharedPointer< Storage > &scriptStorage,
                       QObject* parent )
     : ThreadWeaver::Job(parent), m_engine(0), m_mutex(new QMutex(QMutex::Recursive)),
       m_data(data), m_eventLoop(0), m_published(0), m_quit(false), m_success(true)
 {
     Q_ASSERT_X( data.isValid(), "ScriptJob constructor", "Needs valid script data" );
 
     // Use global storage, may contain non-persistent data from earlier requests.
     // Does not need to live in this thread, it does not create any new QObjects.
     QMutexLocker locker( m_mutex );
     m_objects.storage = scriptStorage;
 
     qRegisterMetaType<DepartureRequest>( "DepartureRequest" );
     qRegisterMetaType<ArrivalRequest>( "ArrivalRequest" );
     qRegisterMetaType<JourneyRequest>( "JourneyRequest" );
     qRegisterMetaType<StopSuggestionRequest>( "StopSuggestionRequest" );
     qRegisterMetaType<StopsByGeoPositionRequest>( "StopsByGeoPositionRequest" );
     qRegisterMetaType<AdditionalDataRequest>( "AdditionalDataRequest" );
 }
 
 ScriptJob::~ScriptJob()
 {
     // Abort, if still running
     requestAbort();
 
     // Do some cleanup if not done already
     cleanup();
 
     delete m_mutex;
 }
 
 void ScriptJob::requestAbort()
 {
     m_mutex->lock();
     if ( !m_engine ) {
         // Is already finished
         m_mutex->unlock();
         return;
     } else if ( m_quit ) {
         // Is already aborting, wait for the script engine to get destroyed
         QEventLoop loop;
         connect( m_engine, SIGNAL(destroyed(QObject*)), &loop, SLOT(quit()) );
         m_mutex->unlock();
 
         // Run the event loop, waiting for the engine to get destroyed or a 1 second timeout
         QTimer::singleShot( 1000, &loop, SLOT(quit()) );
         loop.exec();
         return;
     }
 
     // Is still running, remember to abort
     m_quit = true;
 
     // Abort running network requests, if any
     if ( m_objects.network->hasRunningRequests() ) {
         m_objects.network->abortAllRequests();
     }
 
     // Abort script evaluation
     if ( m_engine ) {
         m_engine->abortEvaluation();
     }
 
     // Wake waiting event loops
     if ( m_eventLoop ) {
         QEventLoop *loop = m_eventLoop;
         m_eventLoop = 0;
         loop->quit();
     }
     m_mutex->unlock();
 
     // Wait until signals are processed
     qApp->processEvents();
 }
 
 ScriptAgent::ScriptAgent( QScriptEngine* engine, QObject *parent )
         : QObject(parent), QScriptEngineAgent(engine)
 {
 }
 
 void ScriptAgent::functionExit( qint64 scriptId, const QScriptValue& returnValue )
 {
     Q_UNUSED( scriptId );
     Q_UNUSED( returnValue );
     QTimer::singleShot( 250, this, SLOT(checkExecution()) );
 }
 
 void ScriptAgent::checkExecution()
 {
     if ( !engine()->isEvaluating() ) {
         emit scriptFinished();
     }
 }
 
 void ScriptJob::run()
 {
     m_mutex->lock();
     if ( !loadScript(m_data.program) ) {
         kDebug() << "Script could not be loaded correctly";
         m_mutex->unlock();
         return;
     }
 
     QScriptEngine *engine = m_engine;
     ScriptObjects objects = m_objects;
     const QString scriptFileName = m_data.provider.scriptFileName();
     const QScriptValueList arguments = QScriptValueList() << request()->toScriptValue( engine );
     const ParseDocumentMode parseMode = request()->parseMode();
     m_mutex->unlock();
 
     // Add call to the appropriate function
     QString functionName;
     switch ( parseMode ) {
     case ParseForDepartures:
     case ParseForArrivals:
         functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETTIMETABLE;
         break;
     case ParseForJourneysByDepartureTime:
     case ParseForJourneysByArrivalTime:
         functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETJOURNEYS;
         break;
     case ParseForStopSuggestions:
         functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETSTOPSUGGESTIONS;
         break;
     case ParseForAdditionalData:
         functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETADDITIONALDATA;
         break;
     default:
         kDebug() << "Parse mode unsupported:" << parseMode;
         break;
     }
 
     if ( functionName.isEmpty() ) {
         // This should never happen, therefore no i18n
         handleError( "Unknown parse mode" );
         return;
     }
 
     // Check if the script function is implemented
     QScriptValue function = engine->globalObject().property( functionName );
     if ( !function.isFunction() ) {
         handleError( i18nc("@info/plain", "Function <icode>%1</icode> not implemented by "
                            "the script <filename>%1</filename>", functionName, scriptFileName) );
         return;
     }
 
     // Store start time of the script
     QElapsedTimer timer;
     timer.start();
 
     // Call script function
     QScriptValue result = function.call( QScriptValue(), arguments );
     if ( engine->hasUncaughtException() ) {
         // TODO Get filename where the exception occured, maybe use ScriptAgent for that
         handleError( i18nc("@info/plain", "Error in script function <icode>%1</icode>, "
                            "line %2: <message>%3</message>.",
                            functionName, engine->uncaughtExceptionLineNumber(),
                            engine->uncaughtException().toString()) );
         return;
     }
 
     // Inform about script run time
     DEBUG_ENGINE_JOBS( "Script finished in" << (timer.elapsed() / 1000.0)
                        << "seconds: " << scriptFileName << parseMode );
 
     GlobalTimetableInfo globalInfo;
     globalInfo.requestDate = QDate::currentDate();
     globalInfo.delayInfoAvailable = !objects.result->isHintGiven( ResultObject::NoDelaysForStop );
 
     // The called function returned, but asynchronous network requests may have been started.
     // Slots in the script may be connected to those requests and start script execution again.
     // In the execution new network requests may get started and so on.
     //
     // Wait until all network requests are finished and the script is not evaluating at the same
     // time. Define a global timeout, each waitFor() call subtracts the elapsed time.
     //
     // NOTE Network requests by default use a 30 seconds timeout, the global timeout should
     //   be bigger. Synchronous requests that were started by signals of running asynchronous
     //   requests are accounted as script execution time here. Synchronous requests that were
     //   started before are already done.
     const int startTimeout = 60000;
     int timeout = startTimeout;
     while ( objects.network->hasRunningRequests() || engine->isEvaluating() ) {
         // Wait until all asynchronous network requests are finished
         if ( !waitFor(objects.network.data(), SIGNAL(allRequestsFinished()),
                       WaitForNetwork, &timeout) )
         {
             if ( timeout <= 0 ) {
                 // Timeout expired while waiting for network requests to finish,
                 // abort all requests that are still running
                 objects.network->abortAllRequests();
 
                 QMutexLocker locker( m_mutex );
                 m_success = false;
                 m_errorString = i18nc("@info", "Timeout expired after %1 while waiting for "
                                       "network requests to finish",
                                       KGlobal::locale()->prettyFormatDuration(startTimeout));
             }
 
             cleanup();
             return;
         }
 
         // Wait for script execution to finish, ie. slots connected to the last finished request(s)
         ScriptAgent agent( engine );
         if ( !waitFor(&agent, SIGNAL(scriptFinished()), WaitForScriptFinish, &timeout) ) {
             if ( timeout <= 0 ) {
                 // Timeout expired while waiting for script execution to finish, abort evaluation
                 engine->abortEvaluation();
 
                 QMutexLocker locker( m_mutex );
                 m_success = false;
                 m_errorString = i18nc("@info", "Timeout expired after %1 while waiting for script "
                                       "execution to finish",
                                       KGlobal::locale()->prettyFormatDuration(startTimeout));
             }
 
             cleanup();
             return;
         }
 
         // Check for new exceptions after waiting for script execution to finish (again)
         if ( engine->hasUncaughtException() ) {
             // TODO Get filename where the exception occured, maybe use ScriptAgent for that
             handleError( i18nc("@info/plain", "Error in script function <icode>%1</icode>, "
                                 "line %2: <message>%3</message>.",
                                 functionName, engine->uncaughtExceptionLineNumber(),
                                 engine->uncaughtException().toString()) );
             return;
         }
     }
 
     // Publish remaining items, if any
     publish();
 
     // Cleanup
     cleanup();
 }
 
 void ScriptJob::cleanup()
 {
     QMutexLocker locker( m_mutex );
     if ( !m_objects.storage.isNull() ) {
         m_objects.storage->checkLifetime();
     }
     if ( !m_objects.result.isNull() ) {
         disconnect( m_objects.result.data(), 0, this, 0 );
     }
     if ( m_engine ) {
         m_engine->deleteLater();
         m_engine = 0;
     }
 }
 
 void ScriptJob::handleError( const QString &errorMessage )
 {
     QMutexLocker locker( m_mutex );
     kDebug() << "Error:" << errorMessage;
     kDebug() << "Backtrace:" << m_engine->uncaughtExceptionBacktrace().join("\n");
     m_errorString = errorMessage;
     m_success = false;
     cleanup();
 }
 
 QScriptValue networkRequestToScript( QScriptEngine *engine, const NetworkRequestPtr &request )
 {
     return engine->newQObject( const_cast<NetworkRequest*>(request), QScriptEngine::QtOwnership,
                                QScriptEngine::PreferExistingWrapperObject );
 }
 
 void networkRequestFromScript( const QScriptValue &object, NetworkRequestPtr &request )
 {
     request = qobject_cast<NetworkRequest*>( object.toQObject() );
 }
 
 bool importExtension( QScriptEngine *engine, const QString &extension )
 {
     if ( !ServiceProviderScript::allowedExtensions().contains(extension, Qt::CaseInsensitive) ) {
         if ( engine->availableExtensions().contains(extension, Qt::CaseInsensitive) ) {
             kDebug() << "Extension" << extension << "is not allowed currently";
         } else {
             kDebug() << "Extension" << extension << "could not be found";
             kDebug() << "Available extensions:" << engine->availableExtensions();
         }
         kDebug() << "Allowed extensions:" << ServiceProviderScript::allowedExtensions();
         return false;
     } else {
         if ( engine->importExtension(extension).isUndefined() ) {
             return true;
         } else {
             if ( engine->hasUncaughtException() ) {
                 kDebug() << "Could not import extension" << extension
                          << engine->uncaughtExceptionLineNumber()
                          << engine->uncaughtException().toString();
                 kDebug() << "Backtrace:" << engine->uncaughtExceptionBacktrace().join("\n");
             }
             return false;
         }
     }
 }
 
 bool ScriptJob::waitFor( QObject *sender, const char *signal, WaitForType type, int *timeout )
 {
     if ( *timeout <= 0 ) {
         return false;
     }
 
     // Do not wait if the job was aborted or failed
     QMutexLocker locker( m_mutex );
     if ( !m_success || m_quit ) {
         return false;
     }
 
     QScriptEngine *engine = m_engine;
     ScriptObjects objects = m_objects;
 
     // Test if the target condition is already met
     if ( (type == WaitForNetwork && objects.network->hasRunningRequests()) ||
          (type == WaitForScriptFinish && engine->isEvaluating()) )
     {
         // Not finished yet, wait for the given signal,
         // that should get emitted when the target condition is met
         QEventLoop loop;
         connect( sender, signal, &loop, SLOT(quit()) );
 
         // Add a timeout to not wait forever (eg. because of an infinite loop in the script).
         // Use a QTimer variable to be able to check if the timeout caused the event loop to quit
         // rather than the given signal
         QTimer timer;
         timer.setSingleShot( true );
         connect( &timer, SIGNAL(timeout()), &loop, SLOT(quit()) );
 
         // Store a pointer to the event loop, to be able to quit it on abort.
         // Then start the timeout.
         m_eventLoop = &loop;
         QElapsedTimer elapsedTimer;
         elapsedTimer.start();
         timer.start( *timeout );
         m_mutex->unlock();
 
         // Start the event loop waiting for the given signal / timeout.
         // QScriptEngine continues execution here or network requests continue to get handled and
         // may call script slots on finish.
         loop.exec();
 
         // Test if the timeout has expired, ie. if the timer is no longer running (single shot)
         m_mutex->lock();
         const bool timeoutExpired = !timer.isActive();
 
         // Update remaining time of the timeout
         if ( timeoutExpired ) {
             *timeout = 0;
         } else {
             *timeout -= elapsedTimer.elapsed();
         }
 
         // Test if the job was aborted while waiting
         if ( !m_eventLoop || m_quit ) {
             // Job was aborted
             m_eventLoop = 0;
             return false;
         }
         m_eventLoop = 0;
 
         // Generate errors if the timeout has expired and abort network requests / script execution
         if ( timeoutExpired ) {
             return false;
         }
     }
 
     // The target condition was met in time or was already met
     return true;
 }
 
 QScriptValue include( QScriptContext *context, QScriptEngine *engine )
 {
     // Check argument count, include() call in global context?
     const QScriptContextInfo contextInfo( context->parentContext() );
     if ( context->argumentCount() < 1 ) {
         context->throwError( i18nc("@info/plain", "One argument expected for <icode>include()</icode>") );
         return engine->undefinedValue();
     } else if ( context->parentContext() && context->parentContext()->parentContext() ) {
         QScriptContext *parentContext = context->parentContext()->parentContext();
         bool error = false;
         while ( parentContext ) {
             const QScriptContextInfo parentContextInfo( parentContext );
             if ( !parentContextInfo.fileName().isEmpty() &&
                  parentContextInfo.fileName() == contextInfo.fileName() )
             {
                 // Parent context is in the same file, error
                 error = true;
                 break;
             }
             parentContext = parentContext->parentContext();
         }
 
         if ( error ) {
             context->throwError( i18nc("@info/plain", "<icode>include()</icode> calls must be in global context") );
             return engine->undefinedValue();
         }
     }
 
     // Check if this include() call is before all other statements
     QVariantHash includeData = context->callee().data().toVariant().toHash();
     if ( includeData.contains(contextInfo.fileName()) ) {
         const quint16 maxIncludeLine = includeData[ contextInfo.fileName() ].toInt();
         if ( contextInfo.lineNumber() > maxIncludeLine ) {
             context->throwError( i18nc("@info/plain", "<icode>include()</icode> calls must be the first statements") );
             return engine->undefinedValue();
         }
     }
 
     // Get argument and check that it's not pointing to another directory
     const QString fileName = context->argument(0).toString();
     if ( fileName.contains('/') ) {
         context->throwError( i18nc("@info/plain", "Cannot include files from other directories") );
         return engine->undefinedValue();
     }
 
     // Find the script to be included
     const QString subDirectory = ServiceProviderGlobal::installationSubDirectory();
     const QString filePath = KGlobal::dirs()->findResource( "data", subDirectory + fileName );
 
     // Check if the script was already included
     QStringList includedFiles =
             engine->globalObject().property( "includedFiles" ).toVariant().toStringList();
     if ( includedFiles.contains(filePath) ) {
-        kWarning() << "File already included" << filePath;
+        qWarning() << "File already included" << filePath;
         return engine->undefinedValue();
     }
 
     // Try to open the file to be included
     QFile scriptFile( filePath );
     if ( !scriptFile.open(QIODevice::ReadOnly) ) {
         context->throwError( i18nc("@info/plain", "Cannot find file to be included: "
                                    "<filename>%1</filename>", fileName) );
         return engine->undefinedValue();
     }
 
     // Read the file
     QTextStream stream( &scriptFile );
     const QString program = stream.readAll();
     scriptFile.close();
 
     if ( !includeData.contains(scriptFile.fileName()) ) {
         includeData[ scriptFile.fileName() ] = maxIncludeLine( program );
 
         QScriptValue includeFunction = engine->globalObject().property("include");
         Q_ASSERT( includeFunction.isValid() );
         includeFunction.setData( qScriptValueFromValue(engine, includeData) );
         engine->globalObject().setProperty( "include", includeFunction,
                                             QScriptValue::KeepExistingFlags );
     }
 
     // Set script context
     QScriptContext *parent = context->parentContext();
     if ( parent ) {
         context->setActivationObject( parent->activationObject() );
         context->setThisObject( parent->thisObject() );
     }
 
     // Store included files in global property "includedFiles"
     includedFiles << filePath;
     includedFiles.removeDuplicates();
     QScriptValue::PropertyFlags flags = QScriptValue::ReadOnly | QScriptValue::Undeletable;
     engine->globalObject().setProperty( "includedFiles", engine->newVariant(includedFiles), flags );
 
     // Evaluate script
     return engine->evaluate( program, filePath );
 }
 
 quint16 maxIncludeLine( const QString &program )
 {
     // Get first lines of script code until the first statement which is not an include() call
     // The regular expression matches in blocks: Multiline comments (needs non-greedy regexp),
     // one line comments, whitespaces & newlines, include("...") calls and semi-colons (needed,
     // because the regexp is non-greedy)
     QRegExp programRegExp( "\\s*(?:\\s*//[^\\n]*\\n|/\\*.*\\*/|[\\s\\n]+|include\\s*\\(\\s*\"[^\"]*\"\\s*\\)|;)+" );
     programRegExp.setMinimal( true );
     int pos = 0, nextPos = 0;
     QString programBegin;
     while ( (pos = programRegExp.indexIn(program, pos)) == nextPos ) {
         const QString capture = programRegExp.cap();
         programBegin.append( capture );
         pos += programRegExp.matchedLength();
         nextPos = pos;
     }
     return programBegin.count( '\n' );
 }
 
 bool ScriptJob::loadScript( const QSharedPointer< QScriptProgram > &script )
 {
     if ( !script ) {
         kDebug() << "Invalid script data";
         return false;
     }
 
     // Create script engine
     QMutexLocker locker( m_mutex );
     m_engine = new QScriptEngine();
     foreach ( const QString &extension, m_data.provider.scriptExtensions() ) {
         if ( !importExtension(m_engine, extension) ) {
             m_errorString = i18nc("@info/plain", "Could not load script extension "
                                   "<resource>%1</resource>.", extension);
             m_success = false;
             cleanup();
             return false;
         }
     }
 
     // Create and attach script objects.
     // The Storage object is already created and will not be replaced by a new instance.
     // It lives in the GUI thread and gets used in all thread jobs to not erase non-persistently
     // stored data after each request.
     m_objects.createObjects( m_data );
     m_objects.attachToEngine( m_engine, m_data );
 
     // Connect the publish() signal directly (the result object lives in the thread that gets
     // run by this job, this job itself lives in the GUI thread). Connect directly to ensure
     // the script objects and the request are still valid (prevent crashes).
     connect( m_objects.result.data(), SIGNAL(publish()), this, SLOT(publish()),
              Qt::DirectConnection );
 
     // Load the script program
     m_mutex->unlock();
     m_engine->evaluate( *script );
     m_mutex->lock();
 
     if ( m_engine->hasUncaughtException() ) {
         kDebug() << "Error in the script" << m_engine->uncaughtExceptionLineNumber()
                  << m_engine->uncaughtException().toString();
         kDebug() << "Backtrace:" << m_engine->uncaughtExceptionBacktrace().join("\n");
         m_errorString = i18nc("@info/plain", "Error in script, line %1: <message>%2</message>.",
                               m_engine->uncaughtExceptionLineNumber(),
                               m_engine->uncaughtException().toString());
         m_success = false;
         cleanup();
         return false;
     } else {
         return true;
     }
 }
 
 bool ScriptJob::hasDataToBePublished() const
 {
     QMutexLocker locker( m_mutex );
     return !m_objects.isValid() ? false : m_objects.result->count() > m_published;
 }
 
 void ScriptJob::publish()
 {
     // This slot gets run in the thread of this job
     // Only publish, if there is data which is not already published
     if ( hasDataToBePublished() ) {
         m_mutex->lock();
         GlobalTimetableInfo globalInfo;
         const QList< TimetableData > data = m_objects.result->data().mid( m_published );
         const ResultObject::Features features = m_objects.result->features();
         const ResultObject::Hints hints = m_objects.result->hints();
         const QString lastUserUrl = m_objects.network->lastUserUrl();
         const bool couldNeedForcedUpdate = m_published > 0;
         const MoreItemsRequest *moreItemsRequest = dynamic_cast<const MoreItemsRequest*>(request());
         const AbstractRequest *_request =
                 moreItemsRequest ? moreItemsRequest->request().data() : request();
         const ParseDocumentMode parseMode = request()->parseMode();
 
         m_lastUrl = m_objects.network->lastUrl(); // TODO Store all URLs
         m_lastUserUrl = m_objects.network->lastUserUrl();
         m_published += data.count();
 
         // Unlock mutex after copying the request object, then emit it with an xxxReady() signal
         switch ( parseMode ) {
         case ParseForDepartures: {
             Q_ASSERT(dynamic_cast<const DepartureRequest*>(_request));
             const DepartureRequest departureRequest =
                     *dynamic_cast<const DepartureRequest*>(_request);
             m_mutex->unlock();
             emit departuresReady( data, features, hints, lastUserUrl, globalInfo,
                                   departureRequest, couldNeedForcedUpdate );
             break;
         }
         case ParseForArrivals: {
             Q_ASSERT(dynamic_cast<const ArrivalRequest*>(_request));
             const ArrivalRequest arrivalRequest = *dynamic_cast<const ArrivalRequest*>(_request);
             m_mutex->unlock();
             emit arrivalsReady( data, features, hints, lastUserUrl, globalInfo,
                                 arrivalRequest, couldNeedForcedUpdate );
             break;
         }
         case ParseForJourneysByDepartureTime:
         case ParseForJourneysByArrivalTime: {
             Q_ASSERT(dynamic_cast<const JourneyRequest*>(_request));
             const JourneyRequest journeyRequest = *dynamic_cast<const JourneyRequest*>(_request);
             m_mutex->unlock();
             emit journeysReady( data, features, hints, lastUserUrl, globalInfo,
                                 journeyRequest, couldNeedForcedUpdate );
             break;
         }
         case ParseForStopSuggestions: {
             Q_ASSERT(dynamic_cast<const StopSuggestionRequest*>(_request));
             const StopSuggestionRequest stopSuggestionRequest =
                     *dynamic_cast< const StopSuggestionRequest* >( _request );
             m_mutex->unlock();
             emit stopSuggestionsReady( data, features, hints, lastUserUrl, globalInfo,
                                        stopSuggestionRequest, couldNeedForcedUpdate );
             break;
         }
         case ParseForAdditionalData: {
             if ( data.count() > 1 ) {
-                kWarning() << "The script added more than one result in an additional data request";
+                qWarning() << "The script added more than one result in an additional data request";
                 kDebug() << "All received additional data for item"
                          << dynamic_cast<const AdditionalDataRequest*>(_request)->itemNumber()
                          << ':' << data;
                 m_errorString = i18nc("@info/plain", "The script added more than one result in "
                                       "an additional data request.");
                 m_success = false;
                 cleanup();
                 m_mutex->unlock();
                 return;
             }
 
             // Additional data gets requested per timetable item, only one result expected
             const TimetableData additionalData = data.first();
             if ( additionalData.isEmpty() ) {
-                kWarning() << "Did not find any additional data.";
+                qWarning() << "Did not find any additional data.";
                 m_errorString = i18nc("@info/plain", "TODO."); // TODO
                 m_success = false;
                 cleanup();
                 m_mutex->unlock();
                 return;
             }
 
             Q_ASSERT(dynamic_cast<const AdditionalDataRequest*>(_request));
             const AdditionalDataRequest additionalDataRequest =
                     *dynamic_cast< const AdditionalDataRequest* >( _request );
             m_mutex->unlock();
 
             emit additionalDataReady( additionalData, features, hints, lastUserUrl, globalInfo,
                                       additionalDataRequest, couldNeedForcedUpdate );
             break;
         }
 
         default:
             m_mutex->unlock();
             kDebug() << "Parse mode unsupported:" << parseMode;
             break;
         }
     }
 }
 
 class DepartureJobPrivate {
 public:
     DepartureJobPrivate( const DepartureRequest &request ) : request(request) {};
     DepartureRequest request;
 };
 
 DepartureJob::DepartureJob( const ScriptData &data, const QSharedPointer< Storage > &scriptStorage,
                             const DepartureRequest& request, QObject* parent )
         : ScriptJob(data, scriptStorage, parent), d(new DepartureJobPrivate(request))
 {
 }
 
 DepartureJob::~DepartureJob()
 {
     delete d;
 }
 
 
 const AbstractRequest *DepartureJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return &d->request;
 }
 
 QString ScriptJob::sourceName() const
 {
     QMutexLocker locker( m_mutex );
     return request()->sourceName();
 }
 
 const AbstractRequest *ScriptJob::cloneRequest() const
 {
     QMutexLocker locker( m_mutex );
     return request()->clone();
 }
 
 class ArrivalJobPrivate {
 public:
     ArrivalJobPrivate( const ArrivalRequest &request ) : request(request) {};
     ArrivalRequest request;
 };
 
 ArrivalJob::ArrivalJob( const ScriptData &data, const QSharedPointer< Storage > &scriptStorage,
                         const ArrivalRequest& request, QObject* parent )
         : ScriptJob(data, scriptStorage, parent), d(new ArrivalJobPrivate(request))
 {
 }
 
 ArrivalJob::~ArrivalJob()
 {
     delete d;
 }
 
 
 const AbstractRequest *ArrivalJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return &d->request;
 }
 
 class JourneyJobPrivate {
 public:
     JourneyJobPrivate( const JourneyRequest &request ) : request(request) {};
     JourneyRequest request;
 };
 
 JourneyJob::JourneyJob( const ScriptData &data, const QSharedPointer< Storage > &scriptStorage,
                         const JourneyRequest& request, QObject* parent )
         : ScriptJob(data, scriptStorage, parent), d(new JourneyJobPrivate(request))
 {
 }
 
 JourneyJob::~JourneyJob()
 {
     delete d;
 }
 
 const AbstractRequest *JourneyJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return &d->request;
 }
 
 class StopSuggestionsJobPrivate {
 public:
     StopSuggestionsJobPrivate( const StopSuggestionRequest &request ) : request(request) {};
     StopSuggestionRequest request;
 };
 
 StopSuggestionsJob::StopSuggestionsJob( const ScriptData &data,
                                         const QSharedPointer< Storage > &scriptStorage,
                                         const StopSuggestionRequest& request, QObject* parent )
         : ScriptJob(data, scriptStorage, parent), d(new StopSuggestionsJobPrivate(request))
 {
 }
 
 StopSuggestionsJob::~StopSuggestionsJob()
 {
     delete d;
 }
 
 const AbstractRequest *StopSuggestionsJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return &d->request;
 }
 
 class StopsByGeoPositionJobPrivate {
 public:
     StopsByGeoPositionJobPrivate( const StopsByGeoPositionRequest &request )
             : request(request) {};
     StopsByGeoPositionRequest request;
 };
 
 StopsByGeoPositionJob::StopsByGeoPositionJob(
         const ScriptData &data, const QSharedPointer< Storage > &scriptStorage,
         const StopsByGeoPositionRequest& request, QObject* parent )
         : ScriptJob(data, scriptStorage, parent), d(new StopsByGeoPositionJobPrivate(request))
 {
 }
 
 StopsByGeoPositionJob::~StopsByGeoPositionJob()
 {
     delete d;
 }
 
 const AbstractRequest *StopsByGeoPositionJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return &d->request;
 }
 
 class AdditionalDataJobPrivate {
 public:
     AdditionalDataJobPrivate( const AdditionalDataRequest &request ) : request(request) {};
     AdditionalDataRequest request;
 };
 
 AdditionalDataJob::AdditionalDataJob( const ScriptData &data,
                                       const QSharedPointer< Storage > &scriptStorage,
                                       const AdditionalDataRequest &request, QObject *parent )
         : ScriptJob(data, scriptStorage, parent), d(new AdditionalDataJobPrivate(request))
 {
 }
 
 AdditionalDataJob::~AdditionalDataJob()
 {
     delete d;
 }
 
 const AbstractRequest *AdditionalDataJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return &d->request;
 }
 
 class MoreItemsJobPrivate {
 public:
     MoreItemsJobPrivate( const MoreItemsRequest &request ) : request(request) {};
     MoreItemsRequest request;
 };
 
 MoreItemsJob::MoreItemsJob( const ScriptData &data, const QSharedPointer< Storage > &scriptStorage,
                             const MoreItemsRequest &request, QObject *parent )
         : ScriptJob(data, scriptStorage, parent), d(new MoreItemsJobPrivate(request))
 {
 }
 
 MoreItemsJob::~MoreItemsJob()
 {
     delete d;
 }
 
 const AbstractRequest *MoreItemsJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return &d->request;
 }
 
 bool ScriptJob::success() const
 {
     QMutexLocker locker( m_mutex );
     return m_success;
 }
 
 int ScriptJob::publishedItems() const
 {
     QMutexLocker locker( m_mutex );
     return m_published;
 }
 QString ScriptJob::errorString() const
 {
     QMutexLocker locker( m_mutex );
     return m_errorString;
 }
 
 QString ScriptJob::lastDownloadUrl() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastUrl;
 }
 
 QString ScriptJob::lastUserUrl() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastUserUrl;
 }
diff --git a/engine/script/scriptapi.cpp b/engine/script/scriptapi.cpp
index ab0288d..37a7f69 100644
--- a/engine/script/scriptapi.cpp
+++ b/engine/script/scriptapi.cpp
@@ -1,2378 +1,2379 @@
 /*
 *   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 "scriptapi.h"
 
 // Own includes
 #include "config.h"
 #include "global.h"
 #include "serviceproviderglobal.h"
 
 // KDE includes
 #include <KStandardDirs>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KDebug>
 #include <KLocalizedString>
 
 // Qt includes
 #include <QFile>
 #include <QScriptContextInfo>
 #include <QNetworkAccessManager>
 #include <QNetworkRequest>
 #include <QNetworkReply>
 #include <QEventLoop>
 #include <QTimer>
 #include <QTextCodec>
 #include <QWaitCondition>
 #include <QReadLocker>
 #include <QWriteLocker>
 #include <QMutex>
 #include <QFileInfo>
 #include <QBuffer>
 #include <QApplication>
 
 // Other includes
 #include <zlib.h>
 
 namespace ScriptApi {
 
 NetworkRequest::NetworkRequest( QObject *parent )
         : QObject(parent), m_mutex(new QMutex(QMutex::Recursive)), m_network(0),
           m_isFinished(false), m_request(0), m_reply(0)
 {
 }
 
 NetworkRequest::NetworkRequest( const QString &url, const QString &userUrl,
                                 Network *network, QObject* parent )
         : QObject(parent), m_mutex(new QMutex(QMutex::Recursive)), m_url(url),
           m_userUrl(userUrl.isEmpty() ? url : userUrl), m_network(network),
           m_isFinished(false), m_request(new QNetworkRequest(url)), m_reply(0)
 {
 }
 
 NetworkRequest::~NetworkRequest()
 {
     abort();
 
     delete m_request;
     delete m_mutex;
 }
 
 void NetworkRequest::abort()
 {
     const bool timedOut = qobject_cast< QTimer* >( sender() );
     if ( !isRunning() ) {
         if ( timedOut ) {
             kDebug() << "Timeout, but request already finished";
         }
         return;
     }
 
     // isRunning() returned true => m_reply != 0
     m_mutex->lockInline();
     disconnect( m_reply, 0, this, 0 );
     m_reply->abort();
     m_reply->deleteLater();
     m_reply = 0;
     const QString url = m_url;
     const QVariant userData = m_userData;
     m_mutex->unlockInline();
 
     emit aborted( timedOut );
     emit finished( QByteArray(), true, i18nc("@info/plain", "The request was aborted"),
                    -1, 0, url, userData );
 }
 
 void NetworkRequest::slotReadyRead()
 {
     m_mutex->lockInline();
     if ( !m_reply ) {
         // Prevent crashes on exit
         m_mutex->unlockInline();
-        kWarning() << "Reply object already deleted, aborted?";
+        qWarning() << "Reply object already deleted, aborted?";
         return;
     }
 
     // Read all data, decode it and give it to the script
     QByteArray data = m_reply->readAll();
     m_data.append( data );
 
     if ( data.isEmpty() ) {
-        kWarning() << "Error downloading" << m_url << m_reply->errorString();
+        qWarning() << "Error downloading" << m_url << m_reply->errorString();
     }
     m_mutex->unlockInline();
 
     emit readyRead( data );
 }
 
 QByteArray gzipDecompress( QByteArray compressData )
 {
     // Strip header and trailer
     compressData.remove( 0, 10 );
     compressData.chop( 12 );
 
     // FIXME Decompress in one chunk, because otherwise it fails with error -3 "distance too far back",
     // estimate size of uncompressed data, expect that the data was compressed at best to 20% size,
     // limit to 512KB
     const int chunkSize = qMin( int(compressData.size() / 0.2), 512 * 1024 );
     kDebug() << "Chunk size:" << chunkSize;
     if ( chunkSize == 512 * 1024 ) {
-        kWarning() << "Maximum chunk size for decompression reached, may fail";
+        qWarning() << "Maximum chunk size for decompression reached, may fail";
     }
 
     unsigned char buffer[ chunkSize ];
     z_stream stream;
     stream.next_in = (Bytef*)(compressData.data());
     stream.avail_in = compressData.size();
     stream.total_in = 0;
     stream.total_out = 0;
     stream.zalloc = Z_NULL;
     stream.zfree = Z_NULL;
     stream.opaque = Z_NULL;
 
     if ( inflateInit2(&stream, -8) != Z_OK ) {
         kDebug() << "cmpr_stream error!";
         return QByteArray();
     }
 
     QByteArray uncompressed;
     do {
         stream.next_out = buffer;
         stream.avail_out = chunkSize;
         int status = inflate( &stream, Z_SYNC_FLUSH );
         if ( status == Z_OK || status == Z_STREAM_END ) {
             uncompressed.append( QByteArray::fromRawData(
                     (char*)buffer, chunkSize - stream.avail_out) );
             if ( status == Z_STREAM_END ) {
                 break;
             }
         } else {
-            kWarning() << "Error while decompressing" << status << stream.msg;
+            qWarning() << "Error while decompressing" << status << stream.msg;
             if ( status == Z_NEED_DICT || status == Z_DATA_ERROR || status == Z_MEM_ERROR ) {
                 inflateEnd( &stream );
             }
             return QByteArray();
         }
     } while( stream.avail_out == 0 );
     inflateEnd( &stream );
     return uncompressed;
 }
 
 void NetworkRequest::slotFinished()
 {
     m_mutex->lockInline();
     if ( !m_reply ) {
         // Prevent crashes on exit
         m_mutex->unlockInline();
-        kWarning() << "Reply object already deleted, aborted?";
+        qWarning() << "Reply object already deleted, aborted?";
         return;
     }
 
     if ( m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute).isValid() ) {
         if ( m_redirectUrl.isValid() ) {
-            kWarning() << "Only one redirection allowed, from" << m_url << "to" << m_redirectUrl;
-            kWarning() << "New redirection to"
+            qWarning() << "Only one redirection allowed, from" << m_url << "to" << m_redirectUrl;
+            qWarning() << "New redirection to"
                        << m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
         } else {
             m_redirectUrl = m_reply->attribute( QNetworkRequest::RedirectionTargetAttribute ).toUrl();
             DEBUG_NETWORK("Redirection to" << m_redirectUrl);
 
             // Delete the reply
             m_reply->deleteLater();
             m_reply = 0;
 
             delete m_request;
             m_request = new QNetworkRequest( m_redirectUrl );
             const QUrl redirectUrl = m_redirectUrl;
             m_mutex->unlockInline();
 
             emit redirected( redirectUrl );
             return;
         }
     }
 
     const int size = m_reply->size();
     const int statusCode = m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 
     // Read all data, decode it and give it to the script
     m_data.append( m_reply->readAll() );
 
     if ( m_data.isEmpty() ) {
-        kWarning() << "Error downloading" << m_url
+        qWarning() << "Error downloading" << m_url
                    << (m_reply ? m_reply->errorString() : "Reply already deleted");
     }
 
     // Check if the data is compressed and was not decompressed by QNetworkAccessManager
     if ( m_data.length() >= 2 && quint8(m_data[0]) == 0x1f && quint8(m_data[1]) == 0x8b ) {
         // Data is compressed, uncompress it
         // NOTE qUncompress() did not work here, "invalid zip"
         m_data = gzipDecompress( m_data );
         DEBUG_NETWORK("Uncompressed data from" << size << "Bytes to" << m_data.size()
                 << "Bytes, ratio:" << (100 - (m_data.isEmpty() ? 100 : qRound(100 * size / m_data.size()))) << '%');
     }
 
     DEBUG_NETWORK("Request finished" << m_reply->url());
     if ( m_reply->url().isEmpty() ) {
-        kWarning() << "Empty URL in QNetworkReply!";
+        qWarning() << "Empty URL in QNetworkReply!";
     }
     const bool hasError = m_reply->error() != QNetworkReply::NoError;
     const QString errorString = m_reply->errorString();
     m_reply->deleteLater();
     m_reply = 0;
 
     m_isFinished = true;
     const QByteArray data = m_data;
     const QString url = m_url;
     const QVariant userData = m_userData;
     m_mutex->unlockInline();
 
     emit finished( data, hasError, errorString, statusCode, size, url, userData );
 }
 
 void NetworkRequest::started( QNetworkReply* reply, int timeout )
 {
     m_mutex->lockInline();
     if ( !m_network ) {
-        kWarning() << "Can't decode, no m_network given...";
+        qWarning() << "Can't decode, no m_network given...";
         m_mutex->unlockInline();
         return;
     }
     m_data.clear();
     m_reply = reply;
 
     if ( timeout > 0 ) {
         QTimer::singleShot( timeout, this, SLOT(abort()) );
     }
 
     // Connect to signals of reply only when the associated signals of this class are connected
     if ( receivers(SIGNAL(readyRead(QByteArray))) > 0 ) {
         connect( m_reply, SIGNAL(readyRead()), this, SLOT(slotReadyRead()) );
     }
     connect( m_reply, SIGNAL(finished()), this, SLOT(slotFinished()) );
     m_mutex->unlockInline();
 
     emit started();
 }
 
 bool NetworkRequest::isValid() const
 {
     QMutexLocker locker( m_mutex );
     if ( m_request ) {
         return true;
     } else {
         // Default constructor used, not available to scripts
         kDebug() << "Request is invalid";
         return false;
     }
 }
 
 QByteArray NetworkRequest::getCharset( const QString& charset ) const
 {
     QMutexLocker locker( m_mutex );
     QByteArray baCharset;
     if ( charset.isEmpty() ) {
         // No charset given, use the one specified in the ContentType header
         baCharset = m_request->header( QNetworkRequest::ContentTypeHeader ).toByteArray();
 
         // No ContentType header, use utf8
         if ( baCharset.isEmpty() ) {
             baCharset = "utf8";
         }
     } else {
         baCharset = charset.toUtf8();
     }
     return baCharset;
 }
 
 QByteArray NetworkRequest::postDataByteArray() const
 {
     QMutexLocker locker( m_mutex );
     return m_postData;
 }
 
 void NetworkRequest::setPostData( const QString& postData, const QString& charset )
 {
     if ( !isValid() ) {
         return;
     }
     if ( isRunning() ) {
         kDebug() << "Cannot set POST data for an already running request!";
         return;
     }
 
     QByteArray baCharset = getCharset( charset );
     QTextCodec *codec = QTextCodec::codecForName( baCharset );
     QMutexLocker locker( m_mutex );
     if ( codec ) {
         m_request->setHeader( QNetworkRequest::ContentTypeHeader, baCharset );
         m_postData = codec->fromUnicode( postData );
     } else {
         kDebug() << "Codec" << baCharset << "couldn't be found to encode the data "
                 "to post, now using UTF-8";
         m_request->setHeader( QNetworkRequest::ContentTypeHeader, "utf8" );
         m_postData = postData.toUtf8();
     }
 }
 
 QString NetworkRequest::header( const QString &header, const QString& charset ) const
 {
     if ( !isValid() ) {
         return QString();
     }
     QByteArray baCharset = getCharset( charset );
     QTextCodec *codec = QTextCodec::codecForName( baCharset );
 
     QMutexLocker locker( m_mutex );
     return m_request->rawHeader( codec ? codec->fromUnicode(header) : header.toUtf8() );
 }
 
 void NetworkRequest::setHeader( const QString& header, const QString& value,
                                 const QString& charset )
 {
     if ( !isValid() ) {
         return;
     }
     if ( isRunning() ) {
         kDebug() << "Cannot set headers for an already running request!";
         return;
     }
 
     QByteArray baCharset = getCharset( charset );
     QTextCodec *codec = QTextCodec::codecForName( baCharset );
     QMutexLocker locker( m_mutex );
     if ( codec ) {
         m_request->setRawHeader( codec->fromUnicode(header), codec->fromUnicode(value) );
     } else {
         kDebug() << "Codec" << baCharset << "couldn't be found to encode the data "
                 "to post, now using UTF-8";
         m_request->setRawHeader( header.toUtf8(), value.toUtf8() );
     }
 }
 
 QNetworkRequest* NetworkRequest::request() const
 {
     QMutexLocker locker( m_mutex );
     return m_request;
 }
 
 Network::Network( const QByteArray &fallbackCharset, QObject* parent )
         : QObject(parent), m_mutex(new QMutex(QMutex::Recursive)),
           m_fallbackCharset(fallbackCharset), m_manager(new QNetworkAccessManager()),
           m_quit(false), m_synchronousRequestCount(0), m_lastDownloadAborted(false)
 {
     qRegisterMetaType< NetworkRequest* >( "NetworkRequest*" );
     qRegisterMetaType< NetworkRequest::Ptr >( "NetworkRequest::Ptr" );
 }
 
 Network::~Network()
 {
     // Quit event loop of possibly running synchronous requests
     m_mutex->lock();
     m_quit = true;
     m_mutex->unlock();
 
     // Notify about the abort request to abort running synchronous requests
     abortSynchronousRequests();
     qApp->processEvents(); // Handle the signal
 
     const QList< NetworkRequest::Ptr > _runningRequests = runningRequests();
     if ( !_runningRequests.isEmpty() ) {
-        kWarning() << "Deleting Network object with" << _runningRequests.count()
+        qWarning() << "Deleting Network object with" << _runningRequests.count()
                    << "running requests";
         foreach ( const NetworkRequest::Ptr &request, _runningRequests ) {
             request->abort();
         }
     }
 
     delete m_mutex;
     m_manager->deleteLater();
 }
 
 NetworkRequest* Network::createRequest( const QString& url, const QString &userUrl )
 {
     NetworkRequest *request = new NetworkRequest( url, userUrl, this, parent() );
     NetworkRequest::Ptr requestPtr( request );
 
     m_mutex->lock();
     m_requests << requestPtr;
     m_mutex->unlock();
 
     connect( request, SIGNAL(started()), this, SLOT(slotRequestStarted()) );
     connect( request, SIGNAL(finished(QByteArray,bool,QString,int,int)),
              this, SLOT(slotRequestFinished(QByteArray,bool,QString,int,int)) );
     connect( request, SIGNAL(aborted()), this, SLOT(slotRequestAborted()) );
     connect( request, SIGNAL(redirected(QUrl)), this, SLOT(slotRequestRedirected(QUrl)) );
     return request;
 }
 
 NetworkRequest::Ptr Network::getSharedRequest( NetworkRequest *request ) const
 {
     QMutexLocker locker( m_mutex );
     foreach ( const NetworkRequest::Ptr &sharedRequest, m_requests ) {
         if ( sharedRequest.data() == request ) {
             return sharedRequest;
         }
     }
     return NetworkRequest::Ptr();
 }
 
 void Network::slotRequestStarted()
 {
     NetworkRequest *request = qobject_cast< NetworkRequest* >( sender() );
     NetworkRequest::Ptr sharedRequest = getSharedRequest( request );
     Q_ASSERT( sharedRequest ); // This slot should only be connected to signals of NetworkRequest
 
     m_mutex->lockInline();
     m_lastDownloadAborted = false;
     m_mutex->unlockInline();
 
     emit requestStarted( sharedRequest );
 }
 
 void Network::slotRequestFinished( const QByteArray &data, bool error, const QString &errorString, 
                                    int statusCode, int size )
 {
     NetworkRequest *request = qobject_cast< NetworkRequest* >( sender() );
     NetworkRequest::Ptr sharedRequest = getSharedRequest( request );
     Q_ASSERT( sharedRequest ); // This slot should only be connected to signals of NetworkRequest
 
     // Remove finished request from request list and add it to the list of finished requests
     // to not have it deleted here. The script might try to use the request object later,
     // eg. because of connected slots, and will crash if the request object was already deleted.
     // This way NetworkRequest objects stay alive at least as long as the Network object does.
     m_mutex->lockInline();
     const QDateTime timestamp = QDateTime::currentDateTime();
     m_requests.removeOne( sharedRequest );
     m_finishedRequests << sharedRequest;
     m_mutex->unlockInline();
 
     emit requestFinished( sharedRequest, data, error, errorString, timestamp, statusCode, size );
 
     if ( !hasRunningRequests() ) {
         emit allRequestsFinished();
     }
 }
 
 void Network::slotRequestRedirected( const QUrl &newUrl )
 {
     NetworkRequest *request = qobject_cast< NetworkRequest* >( sender() );
     NetworkRequest::Ptr sharedRequest = getSharedRequest( request );
     Q_ASSERT( sharedRequest ); // This slot should only be connected to signals of NetworkRequest
 
     m_mutex->lockInline();
     QNetworkReply *reply = m_manager->get( *request->request() );
     m_lastUrl = newUrl.toString();
     m_mutex->unlockInline();
 
     request->started( reply );
 
     DEBUG_NETWORK("Redirected to" << newUrl);
     emit requestRedirected( sharedRequest, newUrl );
 }
 
 void Network::slotRequestAborted()
 {
     m_mutex->lockInline();
     if ( m_quit ) {
         m_mutex->unlockInline();
         return;
     }
 
     NetworkRequest *request = qobject_cast< NetworkRequest* >( sender() );
     NetworkRequest::Ptr sharedRequest = getSharedRequest( request );
     if ( !sharedRequest ) {
-        kWarning() << "Network object already deleted?";
+        qWarning() << "Network object already deleted?";
     }
 //     Q_ASSERT( sharedRequest ); // This slot should only be connected to signals of NetworkRequest
 
     DEBUG_NETWORK("Aborted" << request->url());
     m_lastDownloadAborted = true;
     m_mutex->unlockInline();
 
     emit requestAborted( sharedRequest );
 }
 
 bool Network::checkRequest( NetworkRequest* request )
 {
     // Wrong argument type from script or no argument
     if ( !request ) {
         kDebug() << "Need a NetworkRequest object as argument, create it with "
                     "'network.createRequest(url)'";
         return false;
     }
 
     // The same request can not be executed more than once at a time
     if ( request->isRunning() ) {
         kDebug() << "Request is currently running" << request->url();
         return false;
     } else if ( request->isFinished() ) {
         kDebug() << "Request is already finished" << request->url();
         return false;
     }
 
     return request->isValid();
 }
 
 void Network::get( NetworkRequest* request, int timeout )
 {
     if ( !checkRequest(request) ) {
         return;
     }
 
     // Create a get request
     m_mutex->lockInline();
     QNetworkReply *reply = m_manager->get( *request->request() );
     m_lastUrl = request->url();
     m_lastUserUrl = request->userUrl();
     m_mutex->unlockInline();
 
     request->started( reply, timeout );
 }
 
 void Network::head( NetworkRequest* request, int timeout )
 {
     if ( !checkRequest(request) ) {
         return;
     }
 
     // Create a head request
     m_mutex->lockInline();
     QNetworkReply *reply = m_manager->head( *request->request() );
     m_lastUrl = request->url();
     m_lastUserUrl = request->userUrl();
     m_mutex->unlockInline();
 
     request->started( reply, timeout );
 }
 
 void Network::post( NetworkRequest* request, int timeout )
 {
     if ( !checkRequest(request) ) {
         return;
     }
 
     // Create a head request
     m_mutex->lockInline();
     QNetworkReply *reply = m_manager->post( *request->request(), request->postDataByteArray() );
     m_lastUrl = request->url();
     m_lastUserUrl = request->userUrl();
     m_mutex->unlockInline();
 
     request->started( reply, timeout );
 }
 
 void Network::abortAllRequests()
 {
     const QList< NetworkRequest::Ptr > requests = runningRequests();
     DEBUG_NETWORK("Abort" << requests.count() << "request(s)");
     for ( int i = requests.count() - 1; i >= 0; --i ) {
         // Calling abort automatically removes the aborted request from m_createdRequests
         requests[i]->abort();
     }
 
     // Notify about the abort request to abort running synchronous requests
     abortSynchronousRequests();
 }
 
 void Network::abortSynchronousRequests()
 {
     emit doAbortSynchronousRequests();
 }
 
 QByteArray Network::getSynchronous( const QString &url, const QString &userUrl, int timeout )
 {
     // Create a get request
     QNetworkRequest request( url );
     DEBUG_NETWORK("Start synchronous request" << url);
 
     m_mutex->lockInline();
     QNetworkReply *reply = m_manager->get( request );
     ++m_synchronousRequestCount;
     m_lastUrl = url;
     m_lastUserUrl = userUrl.isEmpty() ? url : userUrl;
     m_lastDownloadAborted = false;
     m_mutex->unlockInline();
 
     emit synchronousRequestStarted( url );
     const QTime start = QTime::currentTime();
 
     int redirectCount = 0;
     const int maxRedirections = 3;
     forever {
         // Use an event loop to wait for execution of the request,
         // ie. make netAccess.download() synchronous for scripts
         QEventLoop eventLoop;
         connect( reply, SIGNAL(finished()), &eventLoop, SLOT(quit()) );
         connect( this, SIGNAL(doAbortSynchronousRequests()), &eventLoop, SLOT(quit()) );
         if ( timeout > 0 ) {
             QTimer::singleShot( timeout, &eventLoop, SLOT(quit()) );
         }
         if ( !reply->isFinished() ) {
             eventLoop.exec( QEventLoop::ExcludeUserInputEvents );
         }
 
         m_mutex->lock();
         const bool quit = m_quit || m_lastDownloadAborted || reply->isRunning();
         m_mutex->unlock();
 
         // Check if the timeout occured before the request finished
         if ( quit ) {
             DEBUG_NETWORK("Cancelled, destroyed or timeout while downloading" << url);
             emitSynchronousRequestFinished( url, QByteArray(), true );
             return QByteArray();
         }
 
         if ( reply->attribute(QNetworkRequest::RedirectionTargetAttribute).isValid() ) {
             ++redirectCount;
             if ( redirectCount > maxRedirections ) {
                 reply->deleteLater();
                 emitSynchronousRequestFinished( url, QByteArray("Too many redirections"), true,
                                                 200, start.msecsTo(QTime::currentTime()) );
                 return QByteArray();
             }
 
             // Request the redirection target
             const QUrl redirectUrl =
                     reply->attribute( QNetworkRequest::RedirectionTargetAttribute ).toUrl();
             request.setUrl( redirectUrl );
             DEBUG_NETWORK("Redirected to" << redirectUrl);
 
             m_mutex->lock();
             delete reply;
             reply = m_manager->get( request );
             m_lastUrl = redirectUrl.toString();
             m_mutex->unlock();
 
             emit synchronousRequestRedirected( redirectUrl.toEncoded() );
         } else {
             // No (more) redirection
             break;
         }
     }
 
     const int time = start.msecsTo( QTime::currentTime() );
     const int statusCode = reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ).toInt();
     DEBUG_NETWORK("Waited" << (time / 1000.0) << "seconds for download of"
                   << url << "Status:" << statusCode);
 
     // Read all data, decode it and give it to the script
     QByteArray data = reply->readAll();
     reply->deleteLater();
     if ( data.isEmpty() ) {
-        kWarning() << "Error downloading" << url << reply->errorString();
+        qWarning() << "Error downloading" << url << reply->errorString();
         emitSynchronousRequestFinished( url, QByteArray(), true, statusCode, time );
         return QByteArray();
     } else {
         emitSynchronousRequestFinished( url, data, false, statusCode, time, data.size() );
         return data;
     }
 }
 
 void Network::emitSynchronousRequestFinished( const QString &url, const QByteArray &data,
                                               bool cancelled, int statusCode, int waitTime,
                                               int size )
 {
     m_mutex->lock();
     --m_synchronousRequestCount;
     m_mutex->unlock();
 
     emit synchronousRequestFinished( url, data, cancelled, statusCode, waitTime, size );
 
     if ( !hasRunningRequests() ) {
         emit allRequestsFinished();
     }
 }
 
 ResultObject::ResultObject( QObject* parent )
         : QObject(parent), m_mutex(new QMutex()), m_features(DefaultFeatures), m_hints(NoHint)
 {
 }
 
 ResultObject::~ResultObject()
 {
     delete m_mutex;
 }
 
 bool ResultObject::isHintGiven( ResultObject::Hint hint ) const
 {
     QMutexLocker locker( m_mutex );
     return m_hints.testFlag( hint );
 }
 
 void ResultObject::giveHint( ResultObject::Hint hint, bool enable )
 {
     QMutexLocker locker( m_mutex );
     if ( enable ) {
         // Remove incompatible flags of hint if any
         if ( hint == CityNamesAreLeft && m_hints.testFlag(CityNamesAreRight) ) {
             m_hints &= ~CityNamesAreRight;
         } else if ( hint == CityNamesAreRight && m_hints.testFlag(CityNamesAreLeft) ) {
             m_hints &= ~CityNamesAreLeft;
         }
         m_hints |= hint;
     } else {
         m_hints &= ~hint;
     }
 }
 
 bool ResultObject::isFeatureEnabled( ResultObject::Feature feature ) const
 {
     QMutexLocker locker( m_mutex );
     return m_features.testFlag( feature );
 }
 
 void ResultObject::enableFeature( ResultObject::Feature feature, bool enable )
 {
     QMutexLocker locker( m_mutex );
     if ( enable ) {
         m_features |= feature;
     } else {
         m_features &= ~feature;
     }
 }
 
 void ResultObject::dataList( const QList< TimetableData > &dataList,
                              PublicTransportInfoList *infoList, ParseDocumentMode parseMode,
                              Enums::VehicleType defaultVehicleType, const GlobalTimetableInfo *globalInfo,
                              ResultObject::Features features, ResultObject::Hints hints )
 {                               // TODO Use features and hints
     QDate curDate;
     QTime lastTime;
     int dayAdjustment = hints.testFlag(DatesNeedAdjustment)
             ? QDate::currentDate().daysTo(globalInfo->requestDate) : 0;
     if ( dayAdjustment != 0 ) {
         kDebug() << "Dates get adjusted by" << dayAdjustment << "days";
     }
 
     // Find words at the beginning/end of target and route stop names that have many
     // occurrences. These words are most likely the city names where the stops are in.
     // But the timetable becomes easier to read and looks nicer, if not each stop name
     // includes the same city name.
     QHash< QString, int > firstWordCounts; // Counts occurrences of words at the beginning
     QHash< QString, int > lastWordCounts; // Counts occurrences of words at the end
 
     // This is the range of occurrences of one word in stop names,
     // that causes that word to be removed
     const int minWordOccurrence = qMax( 2, dataList.count() );
     const int maxWordOccurrence = qMax( 3, dataList.count() / 2 );
 
     // This regular expression gets used to search for word at the end, possibly including
     // a colon before the last word
     QRegExp rxLastWord( ",?\\s+\\S+$" );
 
     // These strings store the words with the most occurrences in stop names at the beginning/end
     QString removeFirstWord;
     QString removeLastWord;
 
     // Read timetable data from the script
     for ( int i = 0; i < dataList.count(); ++i ) {
         TimetableData timetableData = dataList[ i ];
 
         // Set default vehicle type if none is set
         if ( !timetableData.contains(Enums::TypeOfVehicle) ||
              timetableData[Enums::TypeOfVehicle].toString().isEmpty() )
         {
             timetableData[ Enums::TypeOfVehicle ] = static_cast<int>( defaultVehicleType );
         }
 
         if ( parseMode != ParseForStopSuggestions ) {
             QDateTime dateTime = timetableData[ Enums::DepartureDateTime ].toDateTime();
             QDate departureDate = timetableData[ Enums::DepartureDate ].toDate();
             QTime departureTime = timetableData[ Enums::DepartureTime ].toTime();
 
             if ( !dateTime.isValid() && !departureTime.isValid() ) {
                 kDebug() << "No departure time given!" << timetableData[Enums::DepartureTime];
                 kDebug() << "Use eg. helper.matchTime() to convert a string to a time object";
             }
 
             if ( !dateTime.isValid() ) {
                 if ( departureDate.isValid() ) {
                     dateTime = QDateTime( departureDate, departureTime );
                 } else if ( curDate.isNull() ) {
                     // First departure
                     if ( QTime::currentTime().hour() < 3 && departureTime.hour() > 21 ) {
                         dateTime.setDate( QDate::currentDate().addDays(-1) );
                     } else if ( QTime::currentTime().hour() > 21 && departureTime.hour() < 3 ) {
                         dateTime.setDate( QDate::currentDate().addDays(1) );
                     } else {
                         dateTime.setDate( QDate::currentDate() );
                     }
                 } else if ( lastTime.secsTo(departureTime) < -5 * 60 ) {
                     // Time too much ealier than last time, estimate it's tomorrow
                     dateTime.setDate( curDate.addDays(1) );
                 } else {
                     dateTime.setDate( curDate );
                 }
                 timetableData[ Enums::DepartureDateTime ] = dateTime;
             }
 
             if ( dayAdjustment != 0 ) {
                 dateTime.setDate( dateTime.date().addDays(dayAdjustment) );
                 timetableData[ Enums::DepartureDateTime ] = dateTime;
             }
             curDate = dateTime.date();
             lastTime = departureTime;
         }
 
         // Create info object for the timetable data
         PublicTransportInfoPtr info;
         if ( parseMode == ParseForJourneysByDepartureTime ||
              parseMode == ParseForJourneysByArrivalTime )
         {
             info = QSharedPointer<JourneyInfo>( new JourneyInfo(timetableData) );
         } else if ( parseMode == ParseForDepartures || parseMode == ParseForArrivals ) {
             info = QSharedPointer<DepartureInfo>( new DepartureInfo(timetableData) );
         } else if ( parseMode == ParseForStopSuggestions ) {
             info = QSharedPointer<StopInfo>( new StopInfo(timetableData) );
         }
 
         if ( !info->isValid() ) {
             info.clear();
             continue;
         }
 
         // Find word to remove from beginning/end of stop names, if not already found
         // TODO Use hint from the data engine..
         if ( features.testFlag(AutoRemoveCityFromStopNames) &&
              removeFirstWord.isEmpty() && removeLastWord.isEmpty() )
         {
             // First count the first/last word of the target stop name
             const QString target = info->value( Enums::Target ).toString();
             int pos = target.indexOf( ' ' );
             if ( pos > 0 && ++firstWordCounts[target.left(pos)] >= maxWordOccurrence ) {
                 removeFirstWord = target.left(pos);
             }
             if ( rxLastWord.indexIn(target) != -1 &&
                  ++lastWordCounts[rxLastWord.cap()] >= maxWordOccurrence )
             {
                 removeLastWord = rxLastWord.cap();
             }
 
             // Check if route stop names are available
             if ( info->contains(Enums::RouteStops) ) {
                 QStringList stops = info->value( Enums::RouteStops ).toStringList();
                 QString target = info->value( Enums::Target ).toString();
 
                 // TODO Break if 70% or at least three of the route stop names
                 // begin/end with the same word
 //                 int minCount = qMax( 3, int(stops.count() * 0.7) );
                 foreach ( const QString &stop, stops ) {
                     // Test first word
                     pos = stop.indexOf( ' ' );
                     const QString newFirstWord = stop.left( pos );
                     if ( pos > 0 && ++firstWordCounts[newFirstWord] >= maxWordOccurrence ) {
                         removeFirstWord = newFirstWord;
                         break;
                     }
 
                     // Test last word
                     if ( rxLastWord.indexIn(stop) != -1 &&
                          ++lastWordCounts[rxLastWord.cap()] >= maxWordOccurrence )
                     {
                         removeLastWord = rxLastWord.cap();
                         break;
                     }
                 }
             }
         }
 
         infoList->append( info );
     }
 
     // Remove word with most occurrences from beginning/end of stop names
     if ( features.testFlag(AutoRemoveCityFromStopNames) ) {
         if ( removeFirstWord.isEmpty() && removeLastWord.isEmpty() ) {
             // If no first/last word with at least maxWordOccurrence occurrences was found,
             // find the word with the most occurrences
             int max = 0;
 
             // Find word at the beginning with most occurrences
             for ( QHash< QString, int >::ConstIterator it = firstWordCounts.constBegin();
                 it != firstWordCounts.constEnd(); ++it )
             {
                 if ( it.value() > max ) {
                     max = it.value();
                     removeFirstWord = it.key();
                 }
             }
 
             // Find word at the end with more occurrences
             for ( QHash< QString, int >::ConstIterator it = lastWordCounts.constBegin();
                 it != lastWordCounts.constEnd(); ++it )
             {
                 if ( it.value() > max ) {
                     max = it.value();
                     removeLastWord = it.key();
                 }
             }
 
             if ( max < minWordOccurrence ) {
                 // The first/last word with the most occurrences has too few occurrences
                 // Do not remove any word
                 removeFirstWord.clear();
                 removeLastWord.clear();
             } else if ( !removeLastWord.isEmpty() ) {
                 // removeLastWord has more occurrences than removeFirstWord
                 removeFirstWord.clear();
             }
         }
 
         if ( !removeFirstWord.isEmpty() ) {
             // Remove removeFirstWord from all stop names
             for ( int i = 0; i < infoList->count(); ++i ) {
                 QSharedPointer<PublicTransportInfo> info = infoList->at( i );
                 QString target = info->value( Enums::Target ).toString();
                 if ( target.startsWith(removeFirstWord) ) {
                     target = target.mid( removeFirstWord.length() + 1 );
                     info->insert( Enums::TargetShortened, target );
                 }
 
                 QStringList stops = info->value( Enums::RouteStops ).toStringList();
                 for ( int i = 0; i < stops.count(); ++i ) {
                     if ( stops[i].startsWith(removeFirstWord) ) {
                         stops[i] = stops[i].mid( removeFirstWord.length() + 1 );
                     }
                 }
                 info->insert( Enums::RouteStopsShortened, stops );
             }
         } else if ( !removeLastWord.isEmpty() ) {
             // Remove removeLastWord from all stop names
             for ( int i = 0; i < infoList->count(); ++i ) {
                 QSharedPointer<PublicTransportInfo> info = infoList->at( i );
                 QString target = info->value( Enums::Target ).toString();
                 if ( target.endsWith(removeLastWord) ) {
                     target = target.left( target.length() - removeLastWord.length() );
                     info->insert( Enums::TargetShortened, target );
                 }
 
                 QStringList stops = info->value( Enums::RouteStops ).toStringList();
                 for ( int i = 0; i < stops.count(); ++i ) {
                     if ( stops[i].endsWith(removeLastWord) ) {
                         stops[i] = stops[i].left( stops[i].length() - removeLastWord.length() );
                     }
                 }
                 info->insert( Enums::RouteStopsShortened, stops );
             }
         }
     }
 }
 
 QString Helper::decodeHtmlEntities( const QString& html )
 {
     return Global::decodeHtmlEntities( html );
 }
 
 QString Helper::encodeHtmlEntities( const QString &html )
 {
     return Global::encodeHtmlEntities( html );
 }
 
 QString Helper::decodeHtml( const QByteArray &document, const QByteArray &fallbackCharset )
 {
     return Global::decodeHtml( document, fallbackCharset );
 }
 
 QString Helper::decode( const QByteArray &document, const QByteArray &charset )
 {
     return Global::decode( document, charset );
 }
 
 Helper::Helper( const QString &serviceProviderId, QObject *parent )
         : QObject(parent), m_mutex(new QMutex()), m_serviceProviderId(serviceProviderId),
           m_errorMessageRepetition(0)
 {
 }
 
 Helper::~Helper()
 {
     emitRepeatedMessageWarning();
     delete m_mutex;
 }
 
 void Helper::emitRepeatedMessageWarning()
 {
     QMutexLocker locker( m_mutex );
     if ( m_errorMessageRepetition > 0 ) {
         kDebug() << "(Last error message repeated" << m_errorMessageRepetition << "times)";
         m_errorMessageRepetition = 0;
         emit messageReceived( i18nc("@info/plain", "Last error message repeated %1 times",
                                     m_errorMessageRepetition), QScriptContextInfo() );
     }
 }
 
 void Helper::messageReceived( const QString &message, const QString &failedParseText,
                               ErrorSeverity severity )
 {
     m_mutex->lock();
     if ( message == m_lastErrorMessage ) {
         ++m_errorMessageRepetition;
         m_mutex->unlock();
         return;
     }
     m_lastErrorMessage = message;
     QScriptContextInfo info( context()->parentContext() );
     const QString serviceProviderId = m_serviceProviderId;
     m_mutex->unlock();
 
     emitRepeatedMessageWarning();
     emit messageReceived( message, info, failedParseText, severity );
 
     // Output debug message and a maximum count of 200 characters of the text where the parsing failed
     QString shortParseText = failedParseText.trimmed().left(350);
     int diff = failedParseText.length() - shortParseText.length();
     if ( diff > 0 ) {
         shortParseText.append(QString("... <%1 more chars>").arg(diff));
     }
     shortParseText = shortParseText.replace('\n', "\n    "); // Indent
 
 #ifdef ENABLE_DEBUG_SCRIPT_ERROR
     m_mutex->lock();
     const QString name = severity == Information ? "Information"
             : (severity == Warning ? "Warning" : "Fatal error");
     DEBUG_SCRIPT_ERROR( QString("%1 in %2-script, function %3(), file %4, line %5")
             .arg(name)
             .arg(m_serviceProviderId)
             .arg(info.functionName().isEmpty() ? "[anonymous]" : info.functionName())
             .arg(QFileInfo(info.fileName()).fileName())
             .arg(info.lineNumber()) );
     m_mutex->unlock();
     DEBUG_SCRIPT_ERROR( message );
     if ( !shortParseText.isEmpty() ) {
         DEBUG_SCRIPT_ERROR( QString("The text of the document where parsing failed is: \"%1\"")
                             .arg(shortParseText) );
     }
 #endif
 
     // Log the complete message to the log file.
     QString logFileName = KGlobal::dirs()->saveLocation( "data", "plasma_engine_publictransport" );
     logFileName.append( "serviceproviders.log" );
 
     if ( !logFileName.isEmpty() ) {
         QFile logFile(logFileName);
         if ( logFile.size() > 1024 * 512 ) { // == 0.5 MB
             if ( !logFile.remove() ) {
                 kDebug() << "Error: Couldn't delete old log file.";
             } else {
                 kDebug() << "Deleted old log file, because it was getting too big.";
             }
         }
 
         if ( !logFile.open(QIODevice::Append | QIODevice::Text) ) {
             kDebug() << "Couldn't open the log file in append mode" << logFileName << logFile.errorString();
             return;
         }
 
-        logFile.write( QString("%1 (%2, in function %3(), file %4, line %5):\n   \"%6\"\n   Failed while reading this text: \"%7\"\n-------------------------------------\n\n")
+        logFile.write( QString("%1 (%2, in function %3(), file %4, line %5):\n   \"%6\"\n   Failed while reading this text: 
+\"%7\"\n-------------------------------------\n\n")
                 .arg(serviceProviderId)
                 .arg(QDateTime::currentDateTime().toString())
                 .arg(info.functionName().isEmpty() ? "[anonymous]" : info.functionName())
                 .arg(QFileInfo(info.fileName()).fileName())
                 .arg(info.lineNumber())
                 .arg(message)
                 .arg(failedParseText.trimmed()).toUtf8() );
         logFile.close();
     }
 }
 
 void ResultObject::addData( const QVariantMap &item )
 {
     m_mutex->lockInline();
     TimetableData data;
     for ( QVariantMap::ConstIterator it = item.constBegin(); it != item.constEnd(); ++it ) {
         bool ok;
         Enums::TimetableInformation info =
                 static_cast< Enums::TimetableInformation >( it.key().toInt(&ok) );
         if ( !ok || info == Enums::Nothing ) {
             info = Global::timetableInformationFromString( it.key() );
         }
         const QVariant value = it.value();
         if ( info == Enums::Nothing ) {
-            kWarning() << "Invalid property name" << it.key() << "with value" << value;
+            qWarning() << "Invalid property name" << it.key() << "with value" << value;
             QString message;
             if ( it.key() == QLatin1String("length") && value.canConvert(QVariant::Int) &&
                  item.count() == value.toInt() + 1 ) // +1 for the "length" property
             {
                 // Seems like a list was given and autoconverted to QVariantMap in this way
                 message = i18nc("@info/plain", "Invalid property name \"%1\" "
                                 "with value \"%2\", seems like a list was passed to "
                                 "result.addData() instead of an object with properties.",
                                 it.key(), value.toString());
                 context()->throwError( message );
             } else {
                 message = i18nc("@info/plain", "Invalid property name \"%1\" with value \"%2\"",
                                 it.key(), value.toString());
             }
             const int count = m_timetableData.count();
             m_mutex->unlockInline();
             emit invalidDataReceived( info, message, context()->parentContext(), count, item );
             m_mutex->lockInline();
             continue;
         } else if ( value.isNull() ) {
             // Null value received, simply leave the data empty
             continue;
         } else if ( !value.isValid() ) {
-            kWarning() << "Value for" << info << "is invalid or null" << value;
+            qWarning() << "Value for" << info << "is invalid or null" << value;
             const QString message = i18nc("@info/plain", "Invalid value received for \"%1\"",
                                           it.key());
             const int count = m_timetableData.count();
             m_mutex->unlockInline();
             emit invalidDataReceived( info, message, context()->parentContext(), count, item );
             m_mutex->lockInline();
             continue;
         } else if ( info == Enums::TypeOfVehicle &&
                     static_cast<Enums::VehicleType>(value.toInt()) == Enums::InvalidVehicleType &&
                     Global::vehicleTypeFromString(value.toString()) == Enums::InvalidVehicleType )
         {
-            kWarning() << "Invalid type of vehicle value" << value;
+            qWarning() << "Invalid type of vehicle value" << value;
             const QString message = i18nc("@info/plain",
                     "Invalid type of vehicle received: \"%1\"", value.toString());
             const int count = m_timetableData.count();
             m_mutex->unlockInline();
             emit invalidDataReceived( info, message, context()->parentContext(), count, item );
             m_mutex->lockInline();
         } else if ( info == Enums::TypesOfVehicleInJourney || info == Enums::RouteTypesOfVehicles ) {
             const QVariantList types = value.toList();
             foreach ( const QVariant &type, types ) {
                 if ( static_cast<Enums::VehicleType>(type.toInt()) == Enums::InvalidVehicleType &&
                      Global::vehicleTypeFromString(type.toString()) == Enums::InvalidVehicleType )
                 {
                     kDebug() << "Invalid type of vehicle value in"
                              << Global::timetableInformationToString(info) << value;
                     const QString message = i18nc("@info/plain",
                             "Invalid type of vehicle received in \"%1\": \"%2\"",
                             Global::timetableInformationToString(info), type.toString());
                     const int count = m_timetableData.count();
                     m_mutex->unlockInline();
                     emit invalidDataReceived( info, message, context()->parentContext(),
                                               count, item );
                     m_mutex->lockInline();
                 }
             }
         } else if ( info == Enums::JourneyNewsUrl ) {
             QString url = value.toString();
             if ( url.startsWith('/') ) {
                 // Prepend provider URL to relative URLs
-                kWarning() << "Prepending provider URL to relative JourneyNewsUrls is not implemented";
+                qWarning() << "Prepending provider URL to relative JourneyNewsUrls is not implemented";
 //                 url.prepend( m_ ); TODO
             }
         } else if ( info == Enums::JourneyNewsOther ) {
             // DEPRECATED
-            kWarning() << "JourneyNewsOther is deprecated, use JourneyNews instead";
+            qWarning() << "JourneyNewsOther is deprecated, use JourneyNews instead";
             info = Enums::JourneyNews;
         }
 
         if ( m_features.testFlag(AutoDecodeHtmlEntities) ) {
             if ( value.canConvert(QVariant::String) &&
                  (info == Enums::StopName || info == Enums::Target || info == Enums::StartStopName ||
                   info == Enums::TargetStopName || info == Enums::Operator ||
                   info == Enums::TransportLine || info == Enums::Platform ||
                   info == Enums::DelayReason || info == Enums::Status || info == Enums::Pricing) )
             {
                 // Decode HTML entities in string values
                 data[ info ] = Global::decodeHtmlEntities( value.toString() ).trimmed();
             } else if ( value.canConvert(QVariant::StringList) &&
                  (info == Enums::RouteStops || info == Enums::RoutePlatformsDeparture ||
                   info == Enums::RoutePlatformsArrival) )
             {
                 // Decode HTML entities in string list values
                 QStringList stops = value.toStringList();
                 for ( QStringList::Iterator it = stops.begin(); it != stops.end(); ++it ) {
                     *it = Helper::trim( Global::decodeHtmlEntities(*it) );
                 }
                 data[ info ] = stops;
             } else {
                 // Other values don't need decoding
                 data[ info ] = value;
             }
         } else {
             data[ info ] = value;
         }
     }
     m_timetableData << data;
 
     if ( m_features.testFlag(AutoPublish) && m_timetableData.count() == 10 ) {
         // Publish the first 10 data items automatically
         m_mutex->unlockInline();
         emit publish();
     } else {
         m_mutex->unlockInline();
     }
 }
 
 QString Helper::trim( const QString& str )
 {
     return QString(str).trimmed()
                        .replace( QRegExp("^(&nbsp;)+|(&nbsp;)+$", Qt::CaseInsensitive), QString() )
                        .trimmed();
 }
 
 QString Helper::simplify( const QString &str )
 {
     return QString(str).replace( QRegExp("(&nbsp;)+", Qt::CaseInsensitive), QString() )
                        .simplified();
 }
 
 QString Helper::stripTags( const QString& str )
 {
     const QString attributePattern = "\\w+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\"'>\\s]+))?";
     QRegExp rx( QString("<\\/?\\w+(?:\\s+%1)*(?:\\s*/)?>").arg(attributePattern) );
     rx.setMinimal( true );
     return QString( str ).remove( rx );
 }
 
 QString Helper::camelCase( const QString& str )
 {
     QString ret = str.toLower();
     QRegExp rx( "(^\\w)|\\W(\\w)" );
     int pos = 0;
     while ( (pos = rx.indexIn(ret, pos)) != -1 ) {
         if ( rx.pos(2) == -1 || rx.pos(2) >= ret.length() ) {
             ret[ rx.pos(1) ] = ret[ rx.pos(1) ].toUpper();
         } else {
             ret[ rx.pos(2) ] = ret[ rx.pos(2) ].toUpper();
         }
         pos += rx.matchedLength();
     }
     return ret;
 }
 
 QString Helper::extractBlock( const QString& str, const QString& beginString,
                               const QString& endString )
 {
     int pos = str.indexOf( beginString );
     if ( pos == -1 ) {
         return "";
     }
 
     int end = str.indexOf( endString, pos + 1 );
     return str.mid( pos, end - pos );
 }
 
 QVariantMap Helper::matchTime( const QString& str, const QString& format )
 {
     QString pattern = QRegExp::escape( format );
     pattern = pattern.replace( "hh", "\\d{2}" )
               .replace( "h", "\\d{1,2}" )
               .replace( "mm", "\\d{2}" )
               .replace( "m", "\\d{1,2}" )
               .replace( "AP", "(AM|PM)" )
               .replace( "ap", "(am|pm)" );
 
     QVariantMap ret;
     QRegExp rx( pattern );
     if ( rx.indexIn(str) != -1 ) {
         QTime time = QTime::fromString( rx.cap(), format );
         ret.insert( "hour", time.hour() );
         ret.insert( "minute", time.minute() );
     } else if ( format != "hh:mm" ) {
         // Try default format if the one specified doesn't work
         QRegExp rx2( "\\d{1,2}:\\d{2}" );
         if ( rx2.indexIn(str) != -1 ) {
             QTime time = QTime::fromString( rx2.cap(), "hh:mm" );
             ret.insert( "hour", time.hour() );
             ret.insert( "minute", time.minute() );
         } else {
             ret.insert( "error", true );
             DEBUG_SCRIPT_HELPER("Couldn't match time in" << str << pattern);
         }
     } else {
         ret.insert( "error", true );
         DEBUG_SCRIPT_HELPER("Couldn't match time in" << str << pattern);
     }
     return ret;
 }
 
 QDate Helper::matchDate( const QString& str, const QString& format )
 {
     QString pattern = QRegExp::escape( format ).replace( "d", "D" );
     pattern = pattern.replace( "DD", "\\d{2}" )
               .replace( "D", "\\d{1,2}" )
               .replace( "MM", "\\d{2}" )
               .replace( "M", "\\d{1,2}" )
               .replace( "yyyy", "\\d{4}" )
               .replace( "yy", "\\d{2}" );
 
     QRegExp rx( pattern );
     QDate date;
     if ( rx.indexIn(str) != -1 ) {
         date = QDate::fromString( rx.cap(), format );
     } else if ( format != "yyyy-MM-dd" ) {
         // Try default format if the one specified doesn't work
         QRegExp rx2( "\\d{2,4}-\\d{2}-\\d{2}" );
         if ( rx2.indexIn(str) != -1 ) {
             date = QDate::fromString( rx2.cap(), "yyyy-MM-dd" );
         }
     }
     if ( !date.isValid() ) {
         DEBUG_SCRIPT_HELPER("Couldn't match date in" << str << pattern);
     }
 
     // Adjust date, needed for formats with only two "yy" for year matching
     // A year 12 means 2012, not 1912
     if ( date.year() < 1970 ) {
         date.setDate( date.year() + 100, date.month(), date.day() );
     }
     return date;
 }
 
 QString Helper::formatTime( int hour, int minute, const QString& format )
 {
     return QTime( hour, minute ).toString( format );
 }
 
 QString Helper::formatDate( int year, int month, int day, const QString& format )
 {
     return QDate( year, month, day ).toString( format );
 }
 
 QString Helper::formatDateTime( const QDateTime& dateTime, const QString& format )
 {
     return dateTime.toString( format );
 }
 
 int Helper::duration( const QString& sTime1, const QString& sTime2, const QString& format )
 {
     QTime time1 = QTime::fromString( sTime1, format );
     QTime time2 = QTime::fromString( sTime2, format );
     if ( !time1.isValid() || !time2.isValid() ) {
         return -1;
     }
     return time1.secsTo( time2 ) / 60;
 }
 
 QString Helper::addMinsToTime( const QString& sTime, int minsToAdd, const QString& format )
 {
     QTime time = QTime::fromString( sTime, format );
     if ( !time.isValid() ) {
         DEBUG_SCRIPT_HELPER("Couldn't parse the given time" << sTime << format);
         return "";
     }
     return time.addSecs( minsToAdd * 60 ).toString( format );
 }
 
 QString Helper::addDaysToDate( const QString& sDate, int daysToAdd, const QString& format )
 {
     QDate date = QDate::fromString( sDate, format ).addDays( daysToAdd );
     if ( !date.isValid() ) {
         DEBUG_SCRIPT_HELPER("Couldn't parse the given date" << sDate << format);
         return sDate;
     }
     return date.toString( format );
 }
 
 QDateTime Helper::addDaysToDate( const QDateTime& dateTime, int daysToAdd )
 {
     return dateTime.addDays( daysToAdd );
 }
 
 QStringList Helper::splitSkipEmptyParts( const QString& str, const QString& sep )
 {
     return str.split( sep, QString::SkipEmptyParts );
 }
 
 QVariantMap Helper::findFirstHtmlTag( const QString &str, const QString &tagName,
                                       const QVariantMap &options )
 {
     // Set/overwrite maxCount option to match only the first tag using findHtmlTags()
     QVariantMap _options = options;
     _options[ "maxCount" ] = 1;
     QVariantList tags = findHtmlTags( str, tagName, _options );
 
     // Copy values of first matched tag (if any) to the result object
     QVariantMap result;
     result.insert( "found", !tags.isEmpty() );
     if ( !tags.isEmpty() ) {
         const QVariantMap firstTag = tags.first().toMap();
         result.insert( "contents", firstTag["contents"] );
         result.insert( "position", firstTag["position"] );
         result.insert( "endPosition", firstTag["endPosition"] );
         result.insert( "attributes", firstTag["attributes"] );
         result.insert( "name", firstTag["name"] );
     }
     return result;
 }
 
 QVariantList Helper::findHtmlTags( const QString &str, const QString &tagName,
                                    const QVariantMap &options )
 {
     const QVariantMap &attributes = options[ "attributes" ].toMap();
     const int maxCount = options.value( "maxCount", 0 ).toInt();
     const bool noContent = options.value( "noContent", false ).toBool();
     const bool noNesting = options.value( "noNesting", false ).toBool();
     const bool debug = options.value( "debug", false ).toBool();
     const QString contentsRegExpPattern = options.value( "contentsRegExp", QString() ).toString();
     const QVariantMap namePosition = options[ "namePosition" ].toMap();
     int position = options.value( "position", 0 ).toInt();
 
     const bool namePositionIsAttribute = namePosition["type"].toString().toLower().compare(
             QLatin1String("attribute"), Qt::CaseInsensitive ) == 0;
     const QString namePositionRegExpPattern = namePosition.contains("regexp")
             ? namePosition["regexp"].toString() : QString();
 
     // Create regular expression that matches HTML elements with or without attributes.
     // Since QRegExp offers no way to retreive multiple matches of the same capture group
     // the whole attribute string gets matched here and then analyzed in another loop
     // using attributeRegExp.
     // Matching the attributes with all details here is required to prevent eg. having a match
     // end after a ">" character in a string in an attribute.
     const QString attributePattern = "\\w+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\"'>\\s]+))?";
     QRegExp htmlTagRegExp( noContent
             ? QString("<%1((?:\\s+%2)*)(?:\\s*/)?>").arg(tagName).arg(attributePattern)
             : QString("<%1((?:\\s+%2)*)>").arg(tagName).arg(attributePattern),
                            // TODO TEST does this need a "\\s*" before the ">"?
 //             : QString("<%1((?:\\s+%2)*)>%3</%1\\s*>").arg(tagName).arg(attributePattern)
 //                     .arg(contentsRegExpPattern),
             Qt::CaseInsensitive );
     QRegExp htmlCloseTagRegExp( QString("</%1\\s*>").arg(tagName), Qt::CaseInsensitive );
     QRegExp contentsRegExp( contentsRegExpPattern, Qt::CaseInsensitive );
     htmlTagRegExp.setMinimal( true );
 
     // Match attributes with or without value, with single/double/not quoted value
     QRegExp attributeRegExp( "(\\w+)(?:\\s*=\\s*(?:\"([^\"]*)\"|'([^']*)'|([^\"'>\\s]+)))?",
                              Qt::CaseInsensitive );
 
     QVariantList foundTags;
     while ( (foundTags.count() < maxCount || maxCount <= 0) &&
             (position = htmlTagRegExp.indexIn(str, position)) != -1 )
     {
         if ( debug ) {
             kDebug() << "Test match at" << position << htmlTagRegExp.cap().left(500);
         }
         const QString attributeString = htmlTagRegExp.cap( 1 );
         QString tagContents; // = noContent ? QString() : htmlTagRegExp.cap( 2 );
 
         QVariantMap foundAttributes;
         int attributePos = 0;
         while ( (attributePos = attributeRegExp.indexIn(attributeString, attributePos)) != -1 ) {
             const int valueCap = attributeRegExp.cap(2).isEmpty() ?
                     (attributeRegExp.cap(3).isEmpty() ? 4 : 3) : 2;
             foundAttributes.insert( attributeRegExp.cap(1), attributeRegExp.cap(valueCap) );
             attributePos += attributeRegExp.matchedLength();
         }
         if ( debug ) {
             kDebug() << "Found attributes" << foundAttributes << "in" << attributeString;
         }
 
         // Test if the attributes match
         bool attributesMatch = true;
         for ( QVariantMap::ConstIterator it = attributes.constBegin();
               it != attributes.constEnd(); ++it )
         {
             if ( !foundAttributes.contains(it.key()) ) {
                 // Did not find exact attribute name, try to use it as regular expression pattern
                 attributesMatch = false;
                 QRegExp attributeNameRegExp( it.key(), Qt::CaseInsensitive );
                 foreach ( const QString &attributeName, foundAttributes.keys() ) {
                     if ( attributeNameRegExp.indexIn(attributeName) != -1 ) {
                         // Matched the attribute name
                         attributesMatch = true;
                         break;
                     }
                 }
 
                 if ( !attributesMatch ) {
                     if ( debug ) {
                         kDebug() << "Did not find attribute" << it.key();
                     }
                     break;
                 }
             }
 
             // Attribute exists, test it's value
             const QString value = foundAttributes[ it.key() ].toString();
             const QString valueRegExpPattern = it.value().toString();
             if ( !(value.isEmpty() && valueRegExpPattern.isEmpty()) ) {
                 QRegExp valueRegExp( valueRegExpPattern, Qt::CaseInsensitive );
                 if ( valueRegExp.indexIn(value) == -1 ) {
                     // Attribute value regexp did not matched
                     attributesMatch = false;
                     if ( debug ) {
                         kDebug() << "Value" << value << "did not match pattern" << valueRegExpPattern;
                     }
                     break;
                 } else if ( valueRegExp.captureCount() > 0 ) {
                     // Attribute value regexp matched, store captures
                     foundAttributes[ it.key() ] = valueRegExp.capturedTexts();
                 }
             }
         }
 
         // Search for new opening HTML tags (with same tag name) before the closing HTML tag
         int endPosition = htmlTagRegExp.pos() + htmlTagRegExp.matchedLength();
         if ( !attributesMatch ) {
             position = endPosition;
             continue;
         }
         if ( !noContent ) {
             if ( noNesting ) {
                 // "noNesting" option set, simply search for next closing tag, no matter if it is
                 // a nested tag or not
                 const int posClosing = htmlCloseTagRegExp.indexIn( str, endPosition );
                 const int contentsBegin = htmlTagRegExp.pos() + htmlTagRegExp.matchedLength();
                 tagContents = str.mid( contentsBegin, posClosing - contentsBegin );
                 endPosition = htmlCloseTagRegExp.pos() + htmlCloseTagRegExp.matchedLength();
             } else {
                 // Find next closing tag, skipping nested tags.
                 // Get string after the opening HTML tag
                 const QString rest = str.mid( htmlTagRegExp.pos() + htmlTagRegExp.matchedLength() );
 
                 int posClosing = htmlCloseTagRegExp.indexIn( rest );
                 if ( posClosing == -1 ) {
                     position = htmlTagRegExp.pos() + htmlTagRegExp.matchedLength();
                     if ( debug ) {
                         kDebug() << "Closing tag" << tagName << "could not be found";
                     }
                     position = endPosition;
                     continue;
                 }
 
                 // Search for nested opening tags in between the main opening tag and the
                 // next closing tag
                 int posOpening = htmlTagRegExp.indexIn( rest.left(posClosing) );
                 while ( posOpening != -1 ) {
                     // Found a nested tag, find the next closing tag
                     posClosing = htmlCloseTagRegExp.indexIn( rest,
                             posClosing + htmlCloseTagRegExp.matchedLength() );
                     if ( posClosing == -1 ) {
                         position = htmlTagRegExp.pos() + htmlTagRegExp.matchedLength();
                         if ( debug ) {
                             kDebug() << "Closing tag" << tagName << "could not be found";
                         }
                         break;
                     }
 
                     // Search for more nested opening tags
                     posOpening = htmlTagRegExp.indexIn( rest.left(posClosing),
                             posOpening + htmlTagRegExp.matchedLength() );
                 }
 
                 tagContents = rest.left( posClosing );
                 endPosition += htmlCloseTagRegExp.pos() + htmlCloseTagRegExp.matchedLength();
             }
         }
 
         // Match contents, only use regular expression if one was given in the options argument
         if ( !contentsRegExpPattern.isEmpty() ) {
             if ( contentsRegExp.indexIn(tagContents) == -1 ) {
                 if ( debug ) {
                     kDebug() << "Did not match tag contents" << tagContents.left(500);
                 }
                 position = endPosition;
                 continue;
             } else {
                 // Use first matched group as contents string, if any
                 // Otherwise use the whole match as contents string
                 tagContents = contentsRegExp.cap( contentsRegExp.captureCount() <= 1 ? 0 : 1 );
             }
         } else {
             // No regexp pattern for contents, use complete contents, but trimmed
             tagContents = tagContents.trimmed();
         }
 
         // Construct a result object
         QVariantMap result;
         result.insert( "contents", tagContents );
         result.insert( "position", position );
         result.insert( "endPosition", endPosition );
         result.insert( "attributes", foundAttributes );
 
         // Find name if a "namePosition" option is given
         if ( !namePosition.isEmpty() ) {
             const QString name = getTagName( result, namePosition["type"].toString(),
                     namePositionRegExpPattern,
                     namePositionIsAttribute ? namePosition["name"].toString() : QString() );
             result.insert( "name", name );
         }
 
         if ( debug ) {
             kDebug() << "Found HTML tag" << tagName << "at" << position << foundAttributes;
         }
         foundTags << result;
         position = endPosition;
     }
 
     if ( debug ) {
         if ( foundTags.isEmpty() ) {
             kDebug() << "Found no" << tagName << "HTML tags in HTML" << str;
         } else {
             kDebug() << "Found" << foundTags.count() << tagName << "HTML tags";
         }
     }
     return foundTags;
 }
 
 QString Helper::getTagName( const QVariantMap &searchResult, const QString &type,
                             const QString &regExp, const QString attributeName )
 {
     const bool namePositionIsAttribute = type.toLower().compare(
             QLatin1String("attribute"), Qt::CaseInsensitive ) == 0;
     QString name = trim( namePositionIsAttribute
             ? searchResult["attributes"].toMap()[ attributeName ].toString()
             : searchResult["contents"].toString() );
     if ( !regExp.isEmpty() ) {
         // Use "regexp" property of namePosition to match the header name
         QRegExp namePositionRegExp( regExp, Qt::CaseInsensitive );
         if ( namePositionRegExp.indexIn(name) != -1 ) {
             name = namePositionRegExp.cap( qMin(1, namePositionRegExp.captureCount()) );
         }
     }
     return name;
 }
 
 QVariantMap Helper::findNamedHtmlTags( const QString &str, const QString &tagName,
                                        const QVariantMap &options )
 {
     QVariantMap namePosition;
     if ( !options.contains("namePosition") ) {
         namePosition[ "type" ] = "contents"; // Can be "attribute", "contents"
     } else {
         namePosition = options[ "namePosition" ].toMap();
     }
     const bool namePositionIsAttribute = namePosition["type"].toString().toLower().compare(
             QLatin1String("attribute"), Qt::CaseInsensitive ) == 0;
     const QString namePositionRegExpPattern = namePosition.contains("regexp")
             ? namePosition["regexp"].toString() : QString();
     const QString ambiguousNameResolution = options.contains("ambiguousNameResolution")
             ? options["ambiguousNameResolution"].toString().toLower() : "replace";
     const bool debug = options.value( "debug", false ).toBool();
 
     const QVariantList foundTags = findHtmlTags( str, tagName, options );
     QVariantMap foundTagsMap;
     foreach ( const QVariant &foundTag, foundTags ) {
         QString name = getTagName( foundTag.toMap(), namePosition["type"].toString(),
                 namePositionRegExpPattern,
                 namePositionIsAttribute ? namePosition["name"].toString() : QString() );
         if ( name.isEmpty() ) {
             if ( debug ) {
                 kDebug() << "Empty name in" << str;
             }
             continue;
         }
 
         // Check if the newly found name was already found
         // and decide what to do based on the "ambiguousNameResolution" option
         if ( ambiguousNameResolution == QLatin1String("addnumber") && foundTagsMap.contains(name) ) {
             QRegExp rx( "(\\d+)$" );
             if ( rx.indexIn(name) != -1 ) {
                 name += QString::number( rx.cap(1).toInt() + 1 );
             } else {
                 name += "2";
             }
         }
         foundTagsMap[ name ] = foundTag; // TODO Use lists here? The same name could be found multiply times
     }
 
     // Store list of names in the "names" property, therefore "names" should not be a found tag name
     if ( !foundTagsMap.contains("names") ) {
         foundTagsMap[ "names" ] = QVariant::fromValue<QStringList>( foundTagsMap.keys() );
     } else if ( debug ) {
         kDebug() << "A tag with the name 'names' was found. Normally a property 'names' gets "
                     "added to the object returned by this functionm, which lists all found "
                     "names in a list.";
     }
     return foundTagsMap;
 }
 
 const char* Storage::LIFETIME_ENTRYNAME_SUFFIX = "__expires__";
 
 class StoragePrivate {
 public:
     StoragePrivate( const QString &serviceProvider )
             : readWriteLock(new QReadWriteLock(QReadWriteLock::Recursive)),
               readWriteLockPersistent(new QReadWriteLock(QReadWriteLock::Recursive)),
               serviceProvider(serviceProvider), lastLifetimeCheck(0), config(0) {
     };
 
     ~StoragePrivate() {
         delete readWriteLock;
         delete readWriteLockPersistent;
         delete config;
     };
 
     void readPersistentData() {
         // Delete already read config object
         if ( config ) {
             delete config;
         }
 
         config = new KConfig( ServiceProviderGlobal::cacheFileName(), KConfig::SimpleConfig );
     };
 
     KConfigGroup persistentGroup() {
         if ( !config ) {
             readPersistentData();
         }
         return config->group( serviceProvider ).group( QLatin1String("storage") );
     };
 
     quint16 checkLength( const QByteArray &data ) {
         if ( data.length() > 65535 ) {
             kDebug() << "Data is too long, only 65535 bytes are supported" << data.length();
         }
 
         return static_cast<quint16>( data.length() );
     };
 
     QReadWriteLock *readWriteLock;
     QReadWriteLock *readWriteLockPersistent;
     QVariantMap data;
     const QString serviceProvider;
     uint lastLifetimeCheck; // as time_t
     KConfig *config;
     KConfigGroup lastPersistentGroup;
 };
 
 Storage::Storage( const QString &serviceProviderId, QObject *parent )
         : QObject(parent), d(new StoragePrivate(serviceProviderId))
 {
     // Delete persistently stored data which lifetime has expired
     checkLifetime();
 }
 
 Storage::~Storage()
 {
     delete d;
 }
 
 void Storage::write( const QVariantMap& data )
 {
     for ( QVariantMap::ConstIterator it = data.constBegin(); it != data.constEnd(); ++it ) {
         write( it.key(), it.value() );
     }
 }
 
 void Storage::write( const QString& name, const QVariant& data )
 {
     QWriteLocker locker( d->readWriteLock );
     d->data.insert( name, data );
 }
 
 QVariantMap Storage::read()
 {
     QReadLocker locker( d->readWriteLock );
     return d->data;
 }
 
 QVariant Storage::read( const QString& name, const QVariant& defaultData )
 {
     QReadLocker locker( d->readWriteLock );
     return d->data.contains(name) ? d->data[name] : defaultData;
 }
 
 void Storage::remove( const QString& name )
 {
     QWriteLocker locker( d->readWriteLock );
     d->data.remove( name );
 }
 
 void Storage::clear()
 {
     QWriteLocker locker( d->readWriteLock );
     d->data.clear();
 }
 
 int Storage::lifetime( const QString& name )
 {
     QReadLocker locker( d->readWriteLockPersistent );
     return lifetime( name, d->persistentGroup() );
 }
 
 int Storage::lifetime( const QString& name, const KConfigGroup& group )
 {
     QReadLocker locker( d->readWriteLockPersistent );
     return lifetimeNoLock( name, group );
 }
 
 int Storage::lifetimeNoLock( const QString &name, const KConfigGroup &group )
 {
     const uint lifetimeTime_t = group.readEntry( name + LIFETIME_ENTRYNAME_SUFFIX, 0 );
     return QDateTime::currentDateTime().daysTo( QDateTime::fromTime_t(lifetimeTime_t) );
 }
 
 void Storage::checkLifetime()
 {
     QWriteLocker locker( d->readWriteLockPersistent );
     if ( QDateTime::currentDateTime().toTime_t() - d->lastLifetimeCheck <
          MIN_LIFETIME_CHECK_INTERVAL * 60 )
     {
         // Last lifetime check was less than 15 minutes ago
         return;
     }
 
     // Try to load script features from a cache file
     KConfigGroup group = d->persistentGroup();
     QMap< QString, QString > data = group.entryMap();
     for ( QMap< QString, QString >::ConstIterator it = data.constBegin();
           it != data.constEnd(); ++it )
     {
         if ( it.key().endsWith(LIFETIME_ENTRYNAME_SUFFIX) ) {
             // Do not check lifetime of entries which store the lifetime of the real data entries
             continue;
         }
         const int remainingLifetime = lifetimeNoLock( it.key(), group );
         if ( remainingLifetime <= 0 ) {
             // Lifetime has expired
             kDebug() << "Lifetime of storage data" << it.key() << "for" << d->serviceProvider
                      << "has expired" << remainingLifetime;
             removePersistent( it.key(), group );
         }
     }
 
     d->lastLifetimeCheck = QDateTime::currentDateTime().toTime_t();
 }
 
 bool Storage::hasData( const QString &name ) const
 {
     QReadLocker locker( d->readWriteLock );
     return d->data.contains( name );
 }
 
 bool Storage::hasPersistentData( const QString &name ) const
 {
     QReadLocker locker( d->readWriteLockPersistent );
     KConfigGroup group = d->persistentGroup();
     return group.hasKey( name );
 }
 
 QByteArray Storage::encodeData( const QVariant &data ) const
 {
     // Store the type of the variant, because it is needed to read the QVariant with the correct
     // type using KConfigGroup::readEntry()
     const uchar type = static_cast<uchar>( data.type() );
     if ( type >= QVariant::LastCoreType ) {
         kDebug() << "Invalid data type, only QVariant core types are supported" << data.type();
         return QByteArray();
     }
 
     // Write type into the first byte
     QByteArray encodedData;
     encodedData[0] = type;
 
     // Write data
     if ( data.canConvert(QVariant::ByteArray) ) {
         encodedData += data.toByteArray();
     } else if ( data.canConvert(QVariant::String) ) {
         encodedData += data.toString().toUtf8();
     } else {
         switch ( data.type() ) {
         case QVariant::StringList:
         case QVariant::List: {
             // Lists are stored like this (one entry after the other):
             // "<2 Bytes: Value length><Value>"
             const QVariantList list = data.toList();
             foreach ( const QVariant &item, list ) {
                 // Encode current list item
                 QByteArray encodedItem = encodeData( item );
 
                 // Construct a QByteArray which contains the length in two bytes (0 .. 65535)
                 const quint16 length = d->checkLength( encodedItem );
                 const QByteArray baLength( (const char*)&length, sizeof(length) );
 
                 // Use 2 bytes for the length of the data, append data
                 encodedData += baLength;
                 encodedData += encodedItem;
             }
             break;
         }
         case QVariant::Map: {
             // Maps are stored like this (one entry after the other):
             // "<2 Bytes: Key length><Key><2 Bytes: Value length><Value>"
             const QVariantMap map = data.toMap();
             for ( QVariantMap::ConstIterator it = map.constBegin(); it != map.constEnd(); ++it ) {
                 // Encode current key and value
                 QByteArray encodedKey = it.key().toUtf8();
                 QByteArray encodedValue = encodeData( it.value() );
 
                 // Construct QByteArrays which contain the lengths in two bytes each (0 .. 65535)
                 const quint16 lengthKey = d->checkLength( encodedKey );
                 const quint16 lengthValue = d->checkLength( encodedValue );
                 const QByteArray baLengthKey( (const char*)&lengthKey, sizeof(lengthKey) );
                 const QByteArray baLengthValue( (const char*)&lengthValue, sizeof(lengthValue) );
 
                 // Use 2 bytes for the length of the key, append key
                 encodedData += baLengthKey;
                 encodedData += encodedKey;
 
                 // Use 2 bytes for the length of the value, append value
                 encodedData += baLengthValue;
                 encodedData += encodedValue;
             }
             break;
         }
         default:
             kDebug() << "Cannot convert from type" << data.type();
             return QByteArray();
         }
     }
 
     return encodedData;
 }
 
 QVariant Storage::decodeData( const QByteArray &data ) const
 {
     const QVariant::Type type = static_cast<QVariant::Type>( data[0] );
     if ( type >= QVariant::LastCoreType ) {
         kDebug() << "Invalid encoding for data" << data;
         return QVariant();
     }
 
     const QByteArray encodedValue = data.mid( 1 );
     QVariant value( type );
     value.setValue( encodedValue );
     if ( value.canConvert( type ) ) {
         value.convert( type );
         return value;
     } else {
         switch ( type ) {
         case QVariant::Date:
             // QVariant::toString() uses Qt::ISODate to convert QDate to string
             return QDate::fromString( value.toString(), Qt::ISODate );
         case QVariant::Time:
             return QTime::fromString( value.toString() );
         case QVariant::DateTime:
             // QVariant::toString() uses Qt::ISODate to convert QDateTime to string
             return QDateTime::fromString( value.toString(), Qt::ISODate );
         case QVariant::StringList:
         case QVariant::List: {
             // Lists are stored like this (one entry after the other):
             // "<2 Bytes: Value length><Value>"
             QVariantList decoded;
             QByteArray encoded = value.toByteArray();
             int pos = 0;
             while ( pos + 2 < encoded.length() ) {
                 const quint16 length = *reinterpret_cast<quint16*>( encoded.mid(pos, 2).data() );
                 if ( pos + 2 + length > encoded.length() ) {
                     kDebug() << "Invalid list data" << encoded;
                     return QVariant();
                 }
                 const QByteArray encodedValue = encoded.mid( pos + 2, length );
                 const QVariant decodedValue = decodeData( encodedValue );
                 decoded << decodedValue;
 
                 pos += 2 + length;
             }
             return decoded;
         }
         case QVariant::Map: {
             // Maps are stored like this (one entry after the other):
             // "<2 Bytes: Key length><Key><2 Bytes: Value length><Value>"
             QVariantMap decoded;
             const QByteArray encoded = value.toByteArray();
             int pos = 0;
             while ( pos + 4 < encoded.length() ) {
                 // Decode two bytes to quint16, this is the key length
                 const quint16 keyLength = *reinterpret_cast<quint16*>( encoded.mid(pos, 2).data() );
                 if ( pos + 4 + keyLength > encoded.length() ) { // + 4 => 2 Bytes for keyLength + 2 Bytes for valueLength
                     kDebug() << "Invalid map data" << encoded;
                     return QVariant();
                 }
 
                 // Extract key, starting after the two bytes for the key length
                 const QString key = encoded.mid( pos + 2, keyLength );
                 pos += 2 + keyLength;
 
                 // Decode two bytes to quint16, this is the value length
                 const quint16 valueLength = *reinterpret_cast<quint16*>( encoded.mid(pos, 2).data() );
                 if ( pos + 2 + valueLength > encoded.length() ) {
                     kDebug() << "Invalid map data" << encoded;
                     return QVariant();
                 }
 
                 // Extract and decode value, starting after the two bytes for the value length
                 const QByteArray encodedValue = encoded.mid( pos + 2, valueLength );
                 const QVariant decodedValue = decodeData( encodedValue );
                 pos += 2 + valueLength;
 
                 // Insert decoded value into the result map
                 decoded.insert( key, decodedValue );
             }
             return decoded;
         }
         default:
             kDebug() << "Cannot convert to type" << type;
             return QVariant();
         }
     }
 }
 
 void Storage::writePersistent( const QVariantMap& data, uint lifetime )
 {
     QWriteLocker locker( d->readWriteLockPersistent );
     for ( QVariantMap::ConstIterator it = data.constBegin(); it != data.constEnd(); ++it ) {
         writePersistent( it.key(), it.value(), lifetime );
     }
 }
 
 void Storage::writePersistent( const QString& name, const QVariant& data, uint lifetime )
 {
     if ( lifetime > MAX_LIFETIME ) {
         lifetime = MAX_LIFETIME;
     }
 
     // Try to load script features from a cache file
     QWriteLocker locker( d->readWriteLockPersistent );
     KConfigGroup group = d->persistentGroup();
     group.writeEntry( name + LIFETIME_ENTRYNAME_SUFFIX,
                       QDateTime::currentDateTime().addDays(lifetime).toTime_t() );
     group.writeEntry( name, encodeData(data) );
 }
 
 QVariant Storage::readPersistent( const QString& name, const QVariant& defaultData )
 {
     // Try to load script features from a cache file
     QWriteLocker locker( d->readWriteLockPersistent );
     const QByteArray data = d->persistentGroup().readEntry( name, QByteArray() );
     return data.isEmpty() ? defaultData : decodeData(data);
 }
 
 void Storage::removePersistent( const QString& name, KConfigGroup& group )
 {
     QWriteLocker locker( d->readWriteLockPersistent );
     group.deleteEntry( name + LIFETIME_ENTRYNAME_SUFFIX );
     group.deleteEntry( name );
 }
 
 void Storage::removePersistent( const QString& name )
 {
     // Try to load script features from a cache file
     QWriteLocker locker( d->readWriteLockPersistent );
     KConfigGroup group = d->persistentGroup();
     removePersistent( name, group );
 }
 
 void Storage::clearPersistent()
 {
     // Try to load script features from a cache file
     QWriteLocker locker( d->readWriteLockPersistent );
     d->persistentGroup().deleteGroup();
 }
 
 QString Network::lastUrl() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastUrl;
 }
 
 QString Network::lastUserUrl() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastUserUrl;
 }
 
 void Network::clear()
 {
     QMutexLocker locker( m_mutex );
     m_lastUrl.clear();
     m_lastUserUrl.clear();
 }
 
 bool Network::lastDownloadAborted() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastDownloadAborted;
 }
 
 bool Network::hasRunningRequests() const
 {
     QMutexLocker locker( m_mutex );
     if ( m_synchronousRequestCount > 0 ) {
         // There is a synchronous request running
         return true;
     }
 
     foreach ( const NetworkRequest::Ptr &request, m_requests ) {
         if ( request->isRunning() ) {
             // Found a running asynchronous request
             return true;
         }
     }
 
     // No running request found
     return false;
 }
 
 QList< NetworkRequest::Ptr > Network::runningRequests() const
 {
     QMutexLocker locker( m_mutex );
     QList< NetworkRequest::Ptr > requests;
     foreach ( const NetworkRequest::Ptr &request, m_requests ) {
         if ( request->isRunning() ) {
             requests << request;
         }
     }
     return requests;
 }
 
 int Network::runningRequestCount() const
 {
     QMutexLocker locker( m_mutex );
     return runningRequests().count() + m_synchronousRequestCount;
 }
 
 QByteArray Network::fallbackCharset() const
 {
     QMutexLocker locker( m_mutex );
     return m_fallbackCharset;
 }
 
 QList< TimetableData > ResultObject::data() const
 {
     QMutexLocker locker( m_mutex );
     return m_timetableData;
 }
 
 QVariant ResultObject::data( int index, Enums::TimetableInformation information ) const
 {
     QMutexLocker locker( m_mutex );
     if ( index < 0 || index >= m_timetableData.count() ) {
         context()->throwError( QScriptContext::RangeError, "Index out of range" );
         return QVariant();
     }
     return m_timetableData[ index ][ information ];
 }
 
 bool ResultObject::hasData() const
 {
     QMutexLocker locker( m_mutex );
     return !m_timetableData.isEmpty();
 }
 
 int ResultObject::count() const
 {
     QMutexLocker locker( m_mutex );
     return m_timetableData.count();
 }
 
 ResultObject::Features ResultObject::features() const
 {
     QMutexLocker locker( m_mutex );
     return m_features;
 }
 
 ResultObject::Hints ResultObject::hints() const
 {
     QMutexLocker locker( m_mutex );
     return m_hints;
 }
 
 void ResultObject::clear()
 {
     QMutexLocker locker( m_mutex );
     m_timetableData.clear();
 }
 
 QScriptValue constructStream( QScriptContext *context, QScriptEngine *engine )
 {
     QScriptValue argument = context->argument(0);
     DataStreamPrototype *object;
     if ( argument.instanceOf(context->callee()) ) {
         object = new DataStreamPrototype( qscriptvalue_cast<DataStreamPrototype*>(argument) );
     } else if ( argument.isQObject() && qscriptvalue_cast<QIODevice*>(argument) ) {
         object = new DataStreamPrototype( qscriptvalue_cast<QIODevice*>(argument) );
     } else if ( argument.isVariant() ) {
         const QVariant variant = argument.toVariant();
         object = new DataStreamPrototype( variant.toByteArray() );
     } else {
         return engine->undefinedValue();
     }
     return engine->newQObject( object, QScriptEngine::ScriptOwnership );
 }
 
 QScriptValue dataStreamToScript( QScriptEngine *engine, const DataStreamPrototypePtr &stream )
 {
     return engine->newQObject( const_cast<DataStreamPrototype*>(stream), QScriptEngine::QtOwnership,
                                QScriptEngine::PreferExistingWrapperObject );
 }
 
 void dataStreamFromScript( const QScriptValue &object, DataStreamPrototypePtr &stream )
 {
     stream = qobject_cast< DataStreamPrototype* >( object.toQObject() );
 }
 
 DataStreamPrototype::DataStreamPrototype( QObject *parent )
         : QObject( parent )
 {
 }
 
 DataStreamPrototype::DataStreamPrototype( const QByteArray &byteArray, QObject *parent )
         : QObject( parent )
 {
     QBuffer *buffer = new QBuffer( const_cast<QByteArray*>(&byteArray), this );
     buffer->open( QIODevice::ReadOnly );
     m_dataStream = QSharedPointer< QDataStream >( new QDataStream(buffer) );
 }
 
 DataStreamPrototype::DataStreamPrototype( QIODevice *device, QObject *parent )
         : QObject( parent )
 {
     if ( !device->isOpen() ) {
-        kWarning() << "Device not opened";
+        qWarning() << "Device not opened";
     }
     m_dataStream = QSharedPointer< QDataStream >( new QDataStream(device) );
 }
 
 DataStreamPrototype::DataStreamPrototype( DataStreamPrototype *other )
         : QObject(), m_dataStream(other->stream())
 {
 }
 
 QDataStream *DataStreamPrototype::thisDataStream() const
 {
     return m_dataStream.data();
 }
 
 qint8 DataStreamPrototype::readInt8()
 {
     qint8 i;
     thisDataStream()->operator >>( i );
     return i;
 }
 
 quint8 DataStreamPrototype::readUInt8()
 {
     quint8 i;
     thisDataStream()->operator >>( i );
     return i;
 }
 
 quint16 DataStreamPrototype::readUInt16()
 {
     quint16 i;
     thisDataStream()->operator >>( i );
     return i;
 }
 
 qint32 DataStreamPrototype::readInt32()
 {
     qint32 i;
     thisDataStream()->operator >>( i );
     return i;
 }
 
 qint16 DataStreamPrototype::readInt16()
 {
     qint16 i;
     thisDataStream()->operator >>( i );
     return i;
 }
 
 quint32 DataStreamPrototype::readUInt32()
 {
     quint32 i;
     thisDataStream()->operator >>( i );
     return i;
 }
 
 QString DataStreamPrototype::readString()
 {
     QString string;
     char character;
     while ( thisDataStream()->device()->getChar(&character) && character != 0 ) {
         string.append( character );
     }
     return string;
 }
 
 QByteArray DataStreamPrototype::readBytes( uint byteCount )
 {
     char *chars = new char[ byteCount ];
     const uint bytesRead = thisDataStream()->readRawData( chars, byteCount );
     if ( bytesRead != byteCount ) {
-        kWarning() << "Did not read all requested bytes, read" << bytesRead << "of" << byteCount;
+        qWarning() << "Did not read all requested bytes, read" << bytesRead << "of" << byteCount;
     }
     QByteArray bytes( chars );
     delete[] chars;
     return bytes;
 }
 
 QByteArray DataStreamPrototype::readBytesUntilZero()
 {
     QByteArray bytes;
     char character;
     while ( thisDataStream()->device()->getChar(&character) && character != 0 ) {
         bytes.append( character );
     }
     return bytes;
 }
 
 QString NetworkRequest::url() const
 {
     QMutexLocker locker( m_mutex );
     return m_url;
 }
 
 QString NetworkRequest::userUrl() const
 {
     QMutexLocker locker( m_mutex );
     return m_userUrl;
 }
 
 bool NetworkRequest::isRunning() const
 {
     QMutexLocker locker( m_mutex );
     return m_reply;
 }
 
 bool NetworkRequest::isFinished() const
 {
     QMutexLocker locker( m_mutex );
     return m_isFinished;
 }
 
 bool NetworkRequest::isRedirected() const
 {
     QMutexLocker locker( m_mutex );
     return m_redirectUrl.isValid();
 }
 
 QUrl NetworkRequest::redirectedUrl() const
 {
     QMutexLocker locker( m_mutex );
     return m_redirectUrl;
 }
 
 QString NetworkRequest::postData() const
 {
     QMutexLocker locker( m_mutex );
     return m_postData;
 }
 
 quint64 NetworkRequest::uncompressedSize() const
 {
     QMutexLocker locker( m_mutex );
     return m_uncompressedSize;
 }
 
 void NetworkRequest::setUserData( const QVariant &userData )
 {
     QMutexLocker locker( m_mutex );
     m_userData = userData;
 }
 
 QVariant NetworkRequest::userData() const
 {
     QMutexLocker locker( m_mutex );
     return m_userData;
 }
 
 #include "scriptapi.moc"
 
 } // namespace ScriptApi
diff --git a/engine/script/scriptobjects.cpp b/engine/script/scriptobjects.cpp
index dfeda38..b555adc 100644
--- a/engine/script/scriptobjects.cpp
+++ b/engine/script/scriptobjects.cpp
@@ -1,209 +1,209 @@
 /*
 *   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 "scriptobjects.h"
 
 // Own includes
 #include "script_thread.h"
 
 // KDE includes
 #include <KLocalizedString>
 #include <KDebug>
 
 // Qt includes
 #include <QMutex>
 #include <QApplication>
 #include <QNetworkAccessManager>
 
 ScriptObjects::ScriptObjects()
         : storage(0), network(0), result(0), helper(0)
 {
 }
 
 ScriptObjects::ScriptObjects( const ScriptObjects &other )
         : storage(other.storage), network(other.network), result(other.result),
           helper(other.helper), lastError(other.lastError)
 {
 }
 
 ScriptData::ScriptData()
 {
 }
 
 ScriptData::ScriptData( const ScriptData &scriptData )
         : provider(scriptData.provider), program(scriptData.program)
 {
 }
 
 ScriptData::ScriptData( const ServiceProviderData *data,
                         const QSharedPointer< QScriptProgram > &scriptProgram )
         : provider(data ? *data : ServiceProviderData()), program(scriptProgram)
 {
 }
 
 void ScriptObjects::clear()
 {
     storage = QSharedPointer< Storage >( 0 );
     helper = QSharedPointer< Helper >( 0 );
     network = QSharedPointer< Network >( 0 );
     result = QSharedPointer< ResultObject >( 0 );
 }
 
 void ScriptObjects::createObjects( const ServiceProviderData *data,
                                    const QSharedPointer< QScriptProgram > &scriptProgram )
 {
     createObjects( ScriptData(data, scriptProgram) );
 }
 
 void ScriptObjects::createObjects( const ScriptData &data )
 {
     if ( !storage ) {
         storage = QSharedPointer< Storage >( new Storage(data.provider.id()) );
     }
     if ( !network ) {
         network = QSharedPointer< Network >( new Network(data.provider.fallbackCharset()) );
     }
     if ( !result ) {
         result = QSharedPointer< ResultObject >( new ResultObject() );
     }
     if ( !helper ) {
         helper = QSharedPointer< Helper >( new Helper(data.provider.id()) );
     }
 }
 
 ScriptData ScriptData::fromEngine( QScriptEngine *engine,
                                    const QSharedPointer< QScriptProgram > &scriptProgram )
 {
     ServiceProviderData *data = qobject_cast< ServiceProviderData* >(
             engine->globalObject().property("provider").toQObject() );
     return ScriptData( data, scriptProgram );
 }
 
 ScriptObjects ScriptObjects::fromEngine( QScriptEngine *engine )
 {
     ScriptObjects objects;
     objects.helper = QSharedPointer< Helper >( qobject_cast< Helper* >(
             engine->globalObject().property("helper").toQObject() ) );
     objects.network = QSharedPointer< Network >( qobject_cast< Network* >(
             engine->globalObject().property("network").toQObject() ) );
     objects.result = QSharedPointer< ResultObject >( qobject_cast< ResultObject* >(
             engine->globalObject().property("result").toQObject() ) );
     objects.storage = QSharedPointer< Storage >( qobject_cast< Storage* >(
             engine->globalObject().property("storage").toQObject() ) );
     return objects;
 }
 
 void ScriptObjects::moveToThread( QThread *thread )
 {
     if ( helper ) {
         helper->moveToThread( thread );
     }
     if ( network ) {
         network->moveToThread( thread );
     }
     if ( result ) {
         result->moveToThread( thread );
     }
     if ( storage ) {
         storage->moveToThread( thread );
     }
 }
 
 QThread *ScriptObjects::currentThread() const
 {
     return helper ? helper->thread() : 0;
 }
 
 bool ScriptObjects::attachToEngine( QScriptEngine *engine, const ScriptData &data )
 {
     if ( !isValid() ) {
         kDebug() << "Attaching invalid objects" << helper << network << result << storage;
     } else if ( !data.program ) {
         kDebug() << "Attaching invalid data";
     }
 
     if ( engine->isEvaluating() ) {
-        kWarning() << "Cannot attach objects while evaluating";
+        qWarning() << "Cannot attach objects while evaluating";
         return false;
     }
 
     // Register classes for use in the script
     qScriptRegisterMetaType< DataStreamPrototypePtr >( engine,
             dataStreamToScript, dataStreamFromScript );
     qScriptRegisterMetaType< NetworkRequestPtr >( engine,
             networkRequestToScript, networkRequestFromScript );
 
     const QScriptValue::PropertyFlags flags = QScriptValue::ReadOnly | QScriptValue::Undeletable;
 
     // Add a 'provider' object, clone a new ServiceProviderData object
     // for the case that the ScriptData instance gets deleted
     engine->globalObject().setProperty( "provider",
                                         engine->newQObject(data.provider.clone(engine)), flags );
 
     // Add an include() function
     QScriptValue includeFunction = engine->globalObject().property("include");
     if ( !includeFunction.isValid() ) {
         includeFunction = engine->newFunction( include, 1 );
     }
     if ( data.program ) {
         QVariantHash includeData;
         includeData[ data.program->fileName() ] = maxIncludeLine( data.program->sourceCode() );
         includeFunction.setData( qScriptValueFromValue(engine, includeData) );
     }
     engine->globalObject().setProperty( "include", includeFunction, flags );
 
     QScriptValue streamConstructor = engine->newFunction( constructStream );
     QScriptValue streamMeta = engine->newQMetaObject(
             &DataStreamPrototype::staticMetaObject, streamConstructor );
     engine->globalObject().setProperty( "DataStream", streamMeta, flags );
 
     // Make the objects available to the script
     engine->globalObject().setProperty( "helper", helper.isNull()
             ? engine->undefinedValue() : engine->newQObject(helper.data()), flags );
     engine->globalObject().setProperty( "network", network.isNull()
             ? engine->undefinedValue() : engine->newQObject(network.data()), flags );
     engine->globalObject().setProperty( "storage", storage.isNull()
             ? engine->undefinedValue() : engine->newQObject(storage.data()), flags );
     engine->globalObject().setProperty( "result", result.isNull()
             ? engine->undefinedValue() : engine->newQObject(result.data()), flags );
     engine->globalObject().setProperty( "enums",
             engine->newQMetaObject(&ResultObject::staticMetaObject), flags );
     engine->globalObject().setProperty( "PublicTransport",
             engine->newQMetaObject(&Enums::staticMetaObject), flags );
 
     if ( !engine->globalObject().property("DataStream").isValid() ) {
         DataStreamPrototype *dataStream = new DataStreamPrototype( engine );
         QScriptValue stream = engine->newQObject( dataStream );
         QScriptValue streamConstructor = engine->newFunction( constructStream );
         engine->setDefaultPrototype( qMetaTypeId<DataStreamPrototype*>(), stream );
         engine->globalObject().setProperty( "DataStream", streamConstructor, flags );
     }
 
     // Import extensions (from XML file, <script extensions="...">)
     lastError.clear();
     foreach ( const QString &extension, data.provider.scriptExtensions() ) {
         if ( !importExtension(engine, extension) ) {
             lastError = i18nc("@info/plain", "Could not import extension %1", extension);
             return false;
         }
     }
 
     return true;
 }
diff --git a/engine/script/serviceproviderscript.cpp b/engine/script/serviceproviderscript.cpp
index 540f43d..bdeb3d4 100644
--- a/engine/script/serviceproviderscript.cpp
+++ b/engine/script/serviceproviderscript.cpp
@@ -1,689 +1,689 @@
 /*
  *   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 "serviceproviderscript.h"
 
 // Own includes
 #include "scriptapi.h"
 #include "script_thread.h"
 #include "serviceproviderglobal.h"
 #include "serviceproviderdata.h"
 #include "serviceprovidertestdata.h"
 #include "departureinfo.h"
 #include "request.h"
 
 // KDE includes
 #include <KLocalizedString>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KStandardDirs>
 #include <KDebug>
 #include <ThreadWeaver/Weaver>
 #include <ThreadWeaver/Job>
 
 // Qt includes
 #include <QTextCodec>
 #include <QFile>
 #include <QFileInfo>
 #include <QPointer>
 #include <QMutex>
 #include <QTimer>
 #include <QEventLoop>
 #include <QScriptProgram>
 #include <QScriptEngine>
 #include <QScriptContextInfo>
 
 const char *ServiceProviderScript::SCRIPT_FUNCTION_FEATURES = "features";
 const char *ServiceProviderScript::SCRIPT_FUNCTION_GETTIMETABLE = "getTimetable";
 const char *ServiceProviderScript::SCRIPT_FUNCTION_GETJOURNEYS = "getJourneys";
 const char *ServiceProviderScript::SCRIPT_FUNCTION_GETSTOPSUGGESTIONS = "getStopSuggestions";
 const char *ServiceProviderScript::SCRIPT_FUNCTION_GETADDITIONALDATA = "getAdditionalData";
 
 ServiceProviderScript::ServiceProviderScript( const ServiceProviderData *data, QObject *parent,
                                               const QSharedPointer<KConfig> &cache )
         : ServiceProvider(data, parent),
           m_scriptStorage(QSharedPointer<Storage>(new Storage(data->id())))
 {
     m_scriptState = WaitingForScriptUsage;
     m_scriptFeatures = readScriptFeatures( cache.isNull() ? ServiceProviderGlobal::cache() : cache );
 
     qRegisterMetaType< QList<ChangelogEntry> >( "QList<ChangelogEntry>" );
     qRegisterMetaType< TimetableData >( "TimetableData" );
     qRegisterMetaType< QList<TimetableData> >( "QList<TimetableData>" );
     qRegisterMetaType< GlobalTimetableInfo >( "GlobalTimetableInfo" );
     qRegisterMetaType< ParseDocumentMode >( "ParseDocumentMode" );
     qRegisterMetaType< NetworkRequest* >( "NetworkRequest*" );
     qRegisterMetaType< NetworkRequest::Ptr >( "NetworkRequest::Ptr" );
     qRegisterMetaType< QIODevice* >( "QIODevice*" );
     qRegisterMetaType< DataStreamPrototype* >( "DataStreamPrototype*" );
     qRegisterMetaType< ResultObject::Features >( "ResultObject::Features" ); // TEST, now done using Q_DECLARE_METATYPE?
     qRegisterMetaType< ResultObject::Hints >( "ResultObject::Hints" );
 }
 
 ServiceProviderScript::~ServiceProviderScript()
 {
     abortAllRequests();
 }
 
 void ServiceProviderScript::abortAllRequests()
 {
     // Abort all running jobs and wait for them to finish for proper cleanup
     foreach ( ScriptJob *job, m_runningJobs ) {
         kDebug() << "Abort job" << job;
 
         // Create an event loop to wait for the job to finish,
         // quit the loop when the done() signal gets emitted by the job
         QEventLoop loop;
         connect( job, SIGNAL(done(ThreadWeaver::Job*)), &loop, SLOT(quit()) );
 
         // Disconnect all slots connected to the job and then abort it
         disconnect( job, 0, this, 0 );
         job->requestAbort();
 
         // Wait for the job to get aborted
         if ( !job->isFinished() ) {
             // The job is not finished, wait for it, maximally one second
             QTimer::singleShot( 1000, &loop, SLOT(quit()) );
             loop.exec();
         }
 
         // The job has finished or the timeout was reached
         if ( !job->isFinished() ) {
             // The job is still not finished, the timeout was reached before
-            kWarning() << "Job not aborted before timeout, delete it" << job;
+            qWarning() << "Job not aborted before timeout, delete it" << job;
         }
         job->deleteLater();
     }
     m_runningJobs.clear();
 }
 
 QStringList ServiceProviderScript::allowedExtensions()
 {
     return QStringList() << "kross" << "qt" << "qt.core" << "qt.xml";
 }
 
 bool ServiceProviderScript::lazyLoadScript()
 {
     // Read script
     QFile scriptFile( m_data->scriptFileName() );
     if ( !scriptFile.open(QIODevice::ReadOnly) ) {
         kDebug() << "Script could not be opened for reading"
                  << m_data->scriptFileName() << scriptFile.errorString();
         return false;
     }
     const QByteArray ba = scriptFile.readAll();
     scriptFile.close();
     const QString scriptContents = QString::fromUtf8( ba );
 
     // Initialize the script
     m_scriptData = ScriptData( m_data, QSharedPointer< QScriptProgram >(
             new QScriptProgram(scriptContents, m_data->scriptFileName())) );
 
     return true;
 }
 
 bool ServiceProviderScript::runTests( QString *errorMessage ) const
 {
     if ( !QFile::exists(m_data->scriptFileName()) ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "Script file not found: <filename>%1</filename>",
                                   m_data->scriptFileName());
         }
         return false;
     }
 
     QFile scriptFile( m_data->scriptFileName() );
     if ( !scriptFile.open(QIODevice::ReadOnly) ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "Could not open script file: <filename>%1</filename>",
                                   m_data->scriptFileName());
         }
         return false;
     }
 
     QTextStream stream( &scriptFile );
     const QString program = stream.readAll();
     scriptFile.close();
 
     if ( program.isEmpty() ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "Script file is empty: %1", m_data->scriptFileName());
         }
         return false;
     }
 
     const QScriptSyntaxCheckResult syntax = QScriptEngine::checkSyntax( program );
     if ( syntax.state() != QScriptSyntaxCheckResult::Valid ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain",
                                   "Syntax error in script file, line %1: <message>%2</message>",
                                   syntax.errorLineNumber(), syntax.errorMessage().isEmpty()
                                   ? i18nc("@info/plain", "Syntax error") : syntax.errorMessage());
         }
         return false;
     }
 
     // No errors found
     return true;
 }
 
 bool ServiceProviderScript::isTestResultUnchanged( const QString &providerId,
                                                    const QSharedPointer< KConfig > &cache )
 {
     const KConfigGroup providerGroup = cache->group( providerId );
     if ( !providerGroup.hasGroup("script") ) {
         // Not a scripted provider or modified time not stored yet
         return true;
     }
 
     // Check if included files have been marked as modified since the cache was last updated
     const KConfigGroup providerScriptGroup = providerGroup.group( "script" );
     const bool includesUpToDate = providerScriptGroup.readEntry( "includesUpToDate", false );
     if ( !includesUpToDate ) {
         // An included file was modified
         return false;
     }
 
     // Check if the script file was modified since the cache was last updated
     const QDateTime scriptModifiedTime = providerScriptGroup.readEntry("modifiedTime", QDateTime());
     const QString scriptFilePath = providerScriptGroup.readEntry( "scriptFileName", QString() );
     const QFileInfo scriptFileInfo( scriptFilePath );
     if ( scriptFileInfo.lastModified() != scriptModifiedTime ) {
         kDebug() << "Script was modified:" << scriptFileInfo.fileName();
         return false;
     }
 
     // Check all included files and update "includesUpToDate" fields in using providers
     if ( checkIncludedFiles(cache, providerId) ) {
         // An included file of the provider was modified
         return false;
     }
 
     return true;
 }
 
 bool ServiceProviderScript::isTestResultUnchanged( const QSharedPointer<KConfig> &cache ) const
 {
     return isTestResultUnchanged( id(), cache );
 }
 
 QList<Enums::ProviderFeature> ServiceProviderScript::readScriptFeatures(
         const QSharedPointer<KConfig> &cache )
 {
     // Check if the script file was modified since the cache was last updated
     KConfigGroup providerGroup = cache->group( m_data->id() );
     if ( providerGroup.hasGroup("script") && isTestResultUnchanged(cache) &&
          providerGroup.hasKey("features") )
     {
         // Return feature list stored in the cache
         bool ok;
         QStringList featureStrings = providerGroup.readEntry("features", QStringList());
         featureStrings.removeOne("(none)");
         QList<Enums::ProviderFeature> features =
                 ServiceProviderGlobal::featuresFromFeatureStrings( featureStrings, &ok );
         if ( ok ) {
             // The stored feature list only contains valid strings
             return features;
         } else {
-            kWarning() << "Invalid feature string stored for provider" << m_data->id();
+            qWarning() << "Invalid feature string stored for provider" << m_data->id();
         }
     }
 
     // No actual cached information about the service provider
     kDebug() << "No up-to-date cache information for service provider" << m_data->id();
     QList<Enums::ProviderFeature> features;
     QStringList includedFiles;
     bool ok = lazyLoadScript();
     QString errorMessage;
     if ( !ok ) {
         errorMessage = i18nc("@info/plain", "Cannot open script file <filename>%1</filename>",
                              m_data->scriptFileName());
     } else {
         // Create script engine
         QScriptEngine engine;
         foreach ( const QString &import, m_data->scriptExtensions() ) {
             if ( !importExtension(&engine, import) ) {
                 ok = false;
                 errorMessage = i18nc("@info/plain", "Cannot import script extension %1", import);
                 break;
             }
         }
         if ( ok ) {
             ScriptObjects objects;
             objects.createObjects( m_scriptData );
             objects.attachToEngine( &engine, m_scriptData );
 
             engine.evaluate( *m_scriptData.program );
             QVariantList result;
             if ( !engine.hasUncaughtException() ) {
                 result = engine.globalObject().property(
                         SCRIPT_FUNCTION_FEATURES ).call().toVariant().toList();
             }
             if ( engine.hasUncaughtException() ) {
                 kDebug() << "Error in the script" << engine.uncaughtExceptionLineNumber()
                          << engine.uncaughtException().toString();
                 kDebug() << "Backtrace:" << engine.uncaughtExceptionBacktrace().join("\n");
                 ok = false;
                 errorMessage = i18nc("@info/plain", "Uncaught exception in script "
                                      "<filename>%1</filename>, line %2: <message>%3</message>",
                                      QFileInfo(QScriptContextInfo(engine.currentContext()).fileName()).fileName(),
                                      engine.uncaughtExceptionLineNumber(),
                                      engine.uncaughtException().toString());
             } else {
                 includedFiles = engine.globalObject().property( "includedFiles" )
                                                      .toVariant().toStringList();
 
                 // Test if specific functions exist in the script
                 if ( engine.globalObject().property(SCRIPT_FUNCTION_GETSTOPSUGGESTIONS).isValid() ) {
                     features << Enums::ProvidesStopSuggestions;
                 }
                 if ( engine.globalObject().property(SCRIPT_FUNCTION_GETJOURNEYS).isValid() ) {
                     features << Enums::ProvidesJourneys;
                 }
                 if ( engine.globalObject().property(SCRIPT_FUNCTION_GETADDITIONALDATA).isValid() ) {
                     features << Enums::ProvidesAdditionalData;
                 }
 
                 // Test if features() script function is available
                 if ( !engine.globalObject().property(SCRIPT_FUNCTION_FEATURES).isValid() ) {
                     kDebug() << "The script has no" << SCRIPT_FUNCTION_FEATURES << "function";
                 } else {
                     // Use values returned by features() script functions
                     // to get additional features of the service provider
                     foreach ( const QVariant &value, result ) {
                         features << static_cast<Enums::ProviderFeature>( value.toInt() );
                     }
                 }
             }
         }
     }
 
     // Update script modified time in cache
     KConfigGroup scriptGroup = providerGroup.group( "script" );
     scriptGroup.writeEntry( "scriptFileName", m_data->scriptFileName() );
     scriptGroup.writeEntry( "modifiedTime", QFileInfo(m_data->scriptFileName()).lastModified() );
 
     // Remove provider from cached data for include file(s) no longer used by the provider
     KConfigGroup globalScriptGroup = cache->group( "script" );
     const QStringList globalScriptGroupNames = globalScriptGroup.groupList();
     foreach ( const QString &globalScriptGroupName, globalScriptGroupNames ) {
         if ( !globalScriptGroupName.startsWith(QLatin1String("include_")) ) {
             continue;
         }
 
         QString includedFile = globalScriptGroupName;
         includedFile.remove( 0, 8 ); // Remove "include_" from beginning
         const QFileInfo fileInfo( includedFile );
 
         KConfigGroup includeFileGroup = globalScriptGroup.group( "include_" + fileInfo.filePath() );
         QStringList usingProviders = includeFileGroup.readEntry( "usingProviders", QStringList() );
         if ( usingProviders.contains(m_data->id()) && !includedFiles.contains(includedFile) ) {
             // This provider is marked as using the include file, but it no longer uses that file
             usingProviders.removeOne( m_data->id() );
             includeFileGroup.writeEntry( "usingProviders", usingProviders );
         }
     }
 
     // Check if included file(s) were modified
     foreach ( const QString &includedFile, includedFiles ) {
         // Add this provider to the list of providers using the current include file
         const QFileInfo fileInfo( includedFile );
         KConfigGroup includeFileGroup = globalScriptGroup.group( "include_" + fileInfo.filePath() );
         QStringList usingProviders = includeFileGroup.readEntry( "usingProviders", QStringList() );
         if ( !usingProviders.contains(m_data->id()) ) {
             usingProviders << m_data->id();
             includeFileGroup.writeEntry( "usingProviders", usingProviders );
         }
 
         // Check if the include file was modified
         checkIncludedFile( cache, fileInfo );
     }
 
     // Update modified times of included files
     scriptGroup.writeEntry( "includesUpToDate", true ); // Was just updated
 
     // Set error in default cache group
     if ( !ok ) {
         ServiceProviderTestData newTestData = ServiceProviderTestData::read( id(), cache );
         newTestData.setSubTypeTestStatus( ServiceProviderTestData::Failed, errorMessage );
         newTestData.write( id(), cache );
     }
 
     return features;
 }
 
 bool ServiceProviderScript::checkIncludedFile( const QSharedPointer<KConfig> &cache,
                                                const QFileInfo &fileInfo, const QString &providerId )
 {
     // Use a config group in the global script group for each included file.
     // It stores the last modified time and a list of IDs of providers using the include file
     KConfigGroup globalScriptGroup = cache->group( "script" );
     KConfigGroup includeFileGroup = globalScriptGroup.group( "include_" + fileInfo.filePath() );
     const QDateTime lastModified = includeFileGroup.readEntry( "modifiedTime", QDateTime() );
 
     // Update "includesUpToDate" field of using providers, if the include file was modified
     if ( lastModified != fileInfo.lastModified() ) {
         // The include file was modified, update all using providers (later).
         // isTestResultUnchanged() returns false if "includesUpToDate" is false
         const QStringList usingProviders = includeFileGroup.readEntry( "usingProviders", QStringList() );
         foreach ( const QString &usingProvider, usingProviders ) {
             if ( cache->hasGroup(usingProvider) ) {
                 KConfigGroup usingProviderScriptGroup =
                         cache->group( usingProvider ).group( "script" );
                 usingProviderScriptGroup.writeEntry( "includesUpToDate", false );
             }
         }
 
         includeFileGroup.writeEntry( "modifiedTime", fileInfo.lastModified() );
         return providerId.isEmpty() || usingProviders.contains(providerId);
     } else {
         return false;
     }
 }
 
 bool ServiceProviderScript::checkIncludedFiles( const QSharedPointer<KConfig> &cache,
                                                 const QString &providerId )
 {
     bool modified = false;
     KConfigGroup globalScriptGroup = cache->group( "script" );
     const QStringList globalScriptGroups = globalScriptGroup.groupList();
     foreach ( const QString &globalScriptGroup, globalScriptGroups ) {
         if ( !globalScriptGroup.startsWith(QLatin1String("include_")) ) {
             continue;
         }
 
         QString includedFile = globalScriptGroup;
         includedFile.remove( 0, 8 ); // Remove "include_" from beginning
 
         const QFileInfo fileInfo( includedFile );
         if ( checkIncludedFile(cache, fileInfo, providerId) ) {
             // The include file was modified and is used by this provider
             modified = true;
         }
     }
 
     return modified;
 }
 
 QList<Enums::ProviderFeature> ServiceProviderScript::features() const
 {
     return m_scriptFeatures;
 }
 
 void ServiceProviderScript::departuresReady( const QList<TimetableData> &data,
         ResultObject::Features features, ResultObject::Hints hints, const QString &url,
         const GlobalTimetableInfo &globalInfo, const DepartureRequest &request,
         bool couldNeedForcedUpdate )
 {
 //     TODO use hints
     if ( data.isEmpty() ) {
         kDebug() << "The script didn't find any departures" << request.sourceName();
         emit requestFailed( this, ErrorParsingFailed,
                            i18n("Error while parsing the departure document."), url, &request );
     } else {
         // Create PublicTransportInfo objects for new data and combine with already published data
         PublicTransportInfoList newResults;
         ResultObject::dataList( data, &newResults, request.parseMode(),
                                 m_data->defaultVehicleType(), &globalInfo, features, hints );
         PublicTransportInfoList results = (m_publishedData[request.sourceName()] << newResults);
         DepartureInfoList departures;
         foreach( const PublicTransportInfoPtr &info, results ) {
             departures << info.dynamicCast<DepartureInfo>();
         }
 
         emit departuresReceived( this, url, departures, globalInfo, request );
         if ( couldNeedForcedUpdate ) {
             emit forceUpdate();
         }
     }
 }
 
 void ServiceProviderScript::arrivalsReady( const QList< TimetableData > &data,
         ResultObject::Features features, ResultObject::Hints hints, const QString &url,
         const GlobalTimetableInfo &globalInfo, const ArrivalRequest &request,
         bool couldNeedForcedUpdate )
 {
 //     TODO use hints
     if ( data.isEmpty() ) {
         kDebug() << "The script didn't find any arrivals" << request.sourceName();
         emit requestFailed( this, ErrorParsingFailed,
                            i18n("Error while parsing the arrival document."), url, &request );
     } else {
         // Create PublicTransportInfo objects for new data and combine with already published data
         PublicTransportInfoList newResults;
         ResultObject::dataList( data, &newResults, request.parseMode(),
                                 m_data->defaultVehicleType(), &globalInfo, features, hints );
         PublicTransportInfoList results = (m_publishedData[request.sourceName()] << newResults);
         ArrivalInfoList arrivals;
         foreach( const PublicTransportInfoPtr &info, results ) {
             arrivals << info.dynamicCast<ArrivalInfo>();
         }
 
         emit arrivalsReceived( this, url, arrivals, globalInfo, request );
         if ( couldNeedForcedUpdate ) {
             emit forceUpdate();
         }
     }
 }
 
 void ServiceProviderScript::journeysReady( const QList<TimetableData> &data,
         ResultObject::Features features, ResultObject::Hints hints, const QString &url,
         const GlobalTimetableInfo &globalInfo, const JourneyRequest &request,
         bool couldNeedForcedUpdate )
 {
     Q_UNUSED( couldNeedForcedUpdate );
 //     TODO use hints
     if ( data.isEmpty() ) {
         kDebug() << "The script didn't find any journeys" << request.sourceName();
         emit requestFailed( this, ErrorParsingFailed,
                            i18n("Error while parsing the journey document."), url, &request );
     } else {
         // Create PublicTransportInfo objects for new data and combine with already published data
         PublicTransportInfoList newResults;
         ResultObject::dataList( data, &newResults, request.parseMode(),
                                 m_data->defaultVehicleType(), &globalInfo, features, hints );
         PublicTransportInfoList results =
                 (m_publishedData[request.sourceName()] << newResults);
         JourneyInfoList journeys;
         foreach( const PublicTransportInfoPtr &info, results ) {
             journeys << info.dynamicCast<JourneyInfo>();
         }
 
         emit journeysReceived( this, url, journeys, globalInfo, request );
     }
 }
 
 void ServiceProviderScript::stopSuggestionsReady( const QList<TimetableData> &data,
         ResultObject::Features features, ResultObject::Hints hints, const QString &url,
         const GlobalTimetableInfo &globalInfo, const StopSuggestionRequest &request,
         bool couldNeedForcedUpdate )
 {
     Q_UNUSED( couldNeedForcedUpdate );
 //     TODO use hints
     kDebug() << "Received" << data.count() << "items";
 
     // Create PublicTransportInfo objects for new data and combine with already published data
     PublicTransportInfoList newResults;
     ResultObject::dataList( data, &newResults, request.parseMode(),
                             m_data->defaultVehicleType(), &globalInfo, features, hints );
     PublicTransportInfoList results( m_publishedData[request.sourceName()] << newResults );
     kDebug() << "Results:" << results;
 
     StopInfoList stops;
     foreach( const PublicTransportInfoPtr &info, results ) {
         stops << info.dynamicCast<StopInfo>();
     }
 
     emit stopsReceived( this, url, stops, request );
 }
 
 void ServiceProviderScript::additionalDataReady( const TimetableData &data,
         ResultObject::Features features, ResultObject::Hints hints, const QString &url,
         const GlobalTimetableInfo &globalInfo, const AdditionalDataRequest &request,
         bool couldNeedForcedUpdate )
 {
     Q_UNUSED( features );
     Q_UNUSED( hints );
     Q_UNUSED( globalInfo );
     Q_UNUSED( couldNeedForcedUpdate );
     if ( data.isEmpty() ) {
         kDebug() << "The script didn't find any new data" << request.sourceName();
         emit requestFailed( this, ErrorParsingFailed,
                            i18nc("@info/plain", "No additional data found."),
                            url, &request );
     } else {
         emit additionalDataReceived( this, url, data, request );
     }
 }
 
 void ServiceProviderScript::jobStarted( ThreadWeaver::Job* job )
 {
     ScriptJob *scriptJob = qobject_cast< ScriptJob* >( job );
     Q_ASSERT( scriptJob );
 
     // Warn if there is published data for the request,
     // but not for additional data requests because they point to existing departure data sources.
     // There may be multiple AdditionalDataJob requests for the same data source but different
     // timetable items in the source.
     const QString sourceName = scriptJob->sourceName();
     if ( !qobject_cast<AdditionalDataJob*>(scriptJob) &&
          m_publishedData.contains(sourceName) && !m_publishedData[sourceName].isEmpty() )
     {
-        kWarning() << "Data source already exists for job" << scriptJob << sourceName;
+        qWarning() << "Data source already exists for job" << scriptJob << sourceName;
     }
 }
 
 void ServiceProviderScript::jobDone( ThreadWeaver::Job* job )
 {
     ScriptJob *scriptJob = qobject_cast< ScriptJob* >( job );
     Q_ASSERT( scriptJob );
 
     m_publishedData.remove( scriptJob->sourceName() );
     m_runningJobs.removeOne( scriptJob );
     scriptJob->deleteLater();
 }
 
 void ServiceProviderScript::jobFailed( ThreadWeaver::Job* job )
 {
     ScriptJob *scriptJob = qobject_cast< ScriptJob* >( job );
     Q_ASSERT( scriptJob );
 
     emit requestFailed( this, ErrorParsingFailed, scriptJob->errorString(),
                         scriptJob->lastDownloadUrl(), scriptJob->cloneRequest() );
 }
 
 void ServiceProviderScript::requestDepartures( const DepartureRequest &request )
 {
     if ( lazyLoadScript() ) {
         DepartureJob *job = new DepartureJob( m_scriptData, m_scriptStorage, request, this );
         connect( job, SIGNAL(departuresReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,DepartureRequest,bool)),
                 this, SLOT(departuresReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,DepartureRequest,bool)) );
         enqueue( job );
     }
 }
 
 void ServiceProviderScript::requestArrivals( const ArrivalRequest &request )
 {
     if ( lazyLoadScript() ) {
         ArrivalJob *job = new ArrivalJob( m_scriptData, m_scriptStorage, request, this );
         connect( job, SIGNAL(arrivalsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,ArrivalRequest,bool)),
                  this, SLOT(arrivalsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,ArrivalRequest,bool)) );
         enqueue( job );
     }
 }
 
 void ServiceProviderScript::requestJourneys( const JourneyRequest &request )
 {
     if ( lazyLoadScript() ) {
         JourneyJob *job = new JourneyJob( m_scriptData, m_scriptStorage, request, this );
         connect( job, SIGNAL(journeysReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,JourneyRequest,bool)),
                  this, SLOT(journeysReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,JourneyRequest,bool)) );
         enqueue( job );
     }
 }
 
 void ServiceProviderScript::requestStopSuggestions( const StopSuggestionRequest &request )
 {
     if ( lazyLoadScript() ) {
         StopSuggestionsJob *job = new StopSuggestionsJob( m_scriptData, m_scriptStorage, request, this );
         connect( job, SIGNAL(stopSuggestionsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,StopSuggestionRequest,bool)),
                  this, SLOT(stopSuggestionsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,StopSuggestionRequest,bool)) );
         enqueue( job );
     }
 }
 
 void ServiceProviderScript::requestStopsByGeoPosition(
         const StopsByGeoPositionRequest &request )
 {
     if ( lazyLoadScript() ) {
         StopsByGeoPositionJob *job = new StopsByGeoPositionJob(
                 m_scriptData, m_scriptStorage, request, this );
         connect( job, SIGNAL(stopSuggestionsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,StopSuggestionRequest,bool)),
                  this, SLOT(stopSuggestionsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,StopSuggestionRequest,bool)) );
         enqueue( job );
     }
 }
 
 void ServiceProviderScript::requestAdditionalData( const AdditionalDataRequest &request )
 {
     if ( lazyLoadScript() ) {
         AdditionalDataJob *job = new AdditionalDataJob( m_scriptData, m_scriptStorage, request, this );
         connect( job, SIGNAL(additionalDataReady(TimetableData,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,AdditionalDataRequest,bool)),
                  this, SLOT(additionalDataReady(TimetableData,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,AdditionalDataRequest,bool)) );
         enqueue( job );
     }
 }
 
 void ServiceProviderScript::requestMoreItems( const MoreItemsRequest &moreItemsRequest )
 {
     if ( lazyLoadScript() ) {
         // Create a MoreItemsJob and connect ready signals for more departures/arrivals/journeys
         MoreItemsJob *job = new MoreItemsJob( m_scriptData, m_scriptStorage, moreItemsRequest, this );
         connect( job, SIGNAL(departuresReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,DepartureRequest,bool)),
                 this, SLOT(departuresReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,DepartureRequest,bool)) );
         connect( job, SIGNAL(arrivalsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,ArrivalRequest,bool)),
                  this, SLOT(arrivalsReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,ArrivalRequest,bool)) );
         connect( job, SIGNAL(journeysReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,JourneyRequest,bool)),
                  this, SLOT(journeysReady(QList<TimetableData>,ResultObject::Features,ResultObject::Hints,QString,GlobalTimetableInfo,JourneyRequest,bool)) );
         enqueue( job );
     }
 }
 
 void ServiceProviderScript::enqueue( ScriptJob *job )
 {
     m_runningJobs << job;
     connect( job, SIGNAL(started(ThreadWeaver::Job*)), this, SLOT(jobStarted(ThreadWeaver::Job*)) );
     connect( job, SIGNAL(done(ThreadWeaver::Job*)), this, SLOT(jobDone(ThreadWeaver::Job*)) );
     connect( job, SIGNAL(failed(ThreadWeaver::Job*)), this, SLOT(jobFailed(ThreadWeaver::Job*)) );
     ThreadWeaver::Weaver::instance()->enqueue( job );
 }
 
 void ServiceProviderScript::import( const QString &import, QScriptEngine *engine )
 {
     engine->importExtension( import );
 }
 
 int ServiceProviderScript::minFetchWait( UpdateFlags updateFlags ) const
 {
     // If an update was requested manually wait minimally one minute,
     // otherwise wait minimally 15 minutes between automatic updates
     return qMax( updateFlags.testFlag(UpdateWasRequestedManually) ? 60 : 15 * 60,
                  ServiceProvider::minFetchWait() );
 }
diff --git a/engine/serviceproviderdatareader.cpp b/engine/serviceproviderdatareader.cpp
index 4d77beb..3802acf 100644
--- a/engine/serviceproviderdatareader.cpp
+++ b/engine/serviceproviderdatareader.cpp
@@ -1,571 +1,571 @@
 /*
 *   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 "serviceproviderdatareader.h"
 
 // Own includes
 #include "config.h"
 #include "serviceprovider.h"
 #include "serviceproviderdata.h"
 #include "serviceproviderglobal.h"
 #include "script/serviceproviderscript.h"
 #include "global.h"
 
 // KDE includes
 #include <KLocalizedString>
 #include <KGlobal>
 #include <KLocale>
 #include <KDebug>
 #include <KStandardDirs>
 
 // Qt includes
 #include <QFile>
 #include <QFileInfo>
 
 ServiceProviderData *ServiceProviderDataReader::read( const QString &providerId,
                                                       QString *errorMessage, QString *comments )
 {
     QString filePath;
     QString country = "international";
     QString _serviceProviderId = providerId;
     if ( _serviceProviderId.isEmpty() ) {
         // No service provider ID given, use the default one for the users country
         country = KGlobal::locale()->country();
 
         // Try to find the XML filename of the default accessor for [country]
         filePath = ServiceProviderGlobal::defaultProviderForLocation( country );
         if ( filePath.isEmpty() ) {
             return 0;
         }
 
         // Extract service provider ID from filename
         _serviceProviderId = ServiceProviderGlobal::idFromFileName( filePath );
         kDebug() << "No service provider ID given, using the default one for country"
                  << country << "which is" << _serviceProviderId;
     } else {
         foreach ( const QString &extension, ServiceProviderGlobal::fileExtensions() ) {
             filePath = KGlobal::dirs()->findResource( "data",
                     ServiceProviderGlobal::installationSubDirectory() +
                     _serviceProviderId + '.' + extension );
             if ( !filePath.isEmpty() ) {
                 break;
             }
         }
         if ( filePath.isEmpty() ) {
             kDebug() << "Could not find a service provider plugin XML named" << _serviceProviderId;
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "Could not find a service provider "
                                       "plugin with the ID %1", _serviceProviderId);
             }
             return 0;
         }
 
         // Get country code from filename
         QRegExp rx( "^([^_]+)" );
         if ( rx.indexIn(_serviceProviderId) != -1 &&
              KGlobal::locale()->allCountriesList().contains(rx.cap()) )
         {
             country = rx.cap();
         }
     }
 
     QFile file( filePath );
     ServiceProviderDataReader reader;
     ServiceProviderData *data = reader.read( &file, providerId, filePath, country,
                                              ServiceProviderDataReader::OnlyReadCorrectFiles,
                                              0, comments );
     if ( !data && errorMessage ) {
         *errorMessage = i18nc("@info/plain", "Error in line %1: <message>%2</message>",
                               reader.lineNumber(), reader.errorString());
     }
     return data;
 }
 
 ServiceProviderData *ServiceProviderDataReader::read( QIODevice *device, const QString &fileName,
         ErrorAcceptance errorAcceptance, QObject *parent, QString *comments, QString *errorMessage )
 {
     const QString serviceProvider = ServiceProviderGlobal::idFromFileName( fileName );
 
     // Get country code from filename
     QString country;
     QRegExp rx( "^([^_]+)" );
     if ( rx.indexIn(serviceProvider) != -1 &&
          KGlobal::locale()->allCountriesList().contains(rx.cap()) )
     {
         country = rx.cap();
     } else {
         country = "international";
     }
 
     return read( device, serviceProvider, fileName, country,
                  errorAcceptance, parent, comments, errorMessage );
 }
 
 bool ServiceProviderDataReader::handleError( const QString &errorMessage,
                                              ErrorAcceptance errorAcceptance,
                                              QString *errorMessageOutput )
 {
     if ( errorMessageOutput ) {
         *errorMessageOutput = errorMessage;
     }
     if ( errorAcceptance == OnlyReadCorrectFiles ) {
         raiseError( errorMessage );
         return false;
     } else {
         return true;
     }
 }
 
 ServiceProviderData* ServiceProviderDataReader::read( QIODevice* device,
         const QString &serviceProvider, const QString &fileName, const QString &country,
         ErrorAcceptance errorAcceptance, QObject *parent, QString *comments, QString *errorMessage )
 {
     Q_ASSERT( device );
 
     bool closeAfterRead; // Only close after reading if it wasn't open before
     if ( (closeAfterRead = !device->isOpen()) && !device->open(QIODevice::ReadOnly) ) {
         if ( !handleError("Couldn't read the file \"" + fileName + "\".",
                           errorAcceptance, errorMessage) ) 
         {
             return 0;
         }
     }
     setDevice( device );
 
     ServiceProviderData *data = 0;
     while ( !atEnd() ) {
         readNext();
 
         if ( isComment() ) {
             if ( comments ) {
                 addComments( comments, text() );
             }
         } else if ( isStartElement() ) {
             if ( name().compare("serviceProvider", Qt::CaseInsensitive) != 0 ) {
                 if ( !handleError(QString("Wrong root element for %1, should be <serviceProvider>, "
                                   "is <%2>.").arg(serviceProvider, name().toString()),
                                   errorAcceptance, errorMessage) )
                 {
                     return 0;
                 }
             } else if ( attributes().value("fileVersion") != QLatin1String("1.1") ) {
                 const QString message = QString("Service provider plugin format version '%1' "
                         "specified by %2 is not supported. Currently only 1.1 is supported. "
                         "Please make sure the plugin complies with that version and update the "
                         "'fileVersion' attribute of the root <serviceProvider> tag.")
                         .arg(attributes().value("fileVersion").toString(), serviceProvider);
                 if ( !handleError(message, errorAcceptance, errorMessage) )
                 {
                     return 0;
                 }
             }
 
             data = readProviderData( serviceProvider, fileName, country, errorAcceptance,
                                      parent, comments, errorMessage );
             break;
         }
     }
 
     if ( comments ) {
         while ( !atEnd() ) {
             readNext();
 
             if ( isComment() ) {
                 addComments( comments, text() );
             }
         }
     }
 
     if ( closeAfterRead ) {
         device->close();
     }
 
     if ( error() != NoError ) {
         kDebug() << "Error reading provider" << serviceProvider << errorString();
     }
     return error() == NoError && data ? data : 0;
 }
 
 void ServiceProviderDataReader::readUnknownElement( QString *comments )
 {
     Q_ASSERT( isStartElement() );
     if ( comments ) {
         addComments( comments, readStartElementString(), false );
     }
 
     while ( !atEnd() ) {
         TokenType type = readNext();
         switch ( type ) {
         case EndElement:
             if ( comments ) {
                 addComments( comments, QString("</%1>").arg(name().toString()), false );
             }
             return;
         case Comment:
         case Characters:
         case EntityReference:
             if ( comments ) {
                 addComments( comments, text(), false );
             }
             break;
         case StartElement:
             readUnknownElement( comments );
             break;
         default:
             break;
         }
     }
 }
 
 QString ServiceProviderDataReader::readStartElementString() const
 {
     QString elementString( '<' );
     elementString.append( name() );
     const QXmlStreamAttributes attr = attributes();
     for ( QXmlStreamAttributes::ConstIterator it = attr.constBegin();
           it != attr.constEnd(); ++it )
     {
         elementString.append( QString(" %1=\"%2\"")
                 .arg(it->name().toString(), it->value().toString()) );
     }
     elementString.append( '>' );
     return elementString;
 }
 
 void ServiceProviderDataReader::addComments( QString *comments, const QString &newComments,
                                              bool newLine )
 {
     if ( newComments.isEmpty() ) {
         return;
     }
     if ( newLine && !comments->isEmpty() ) {
         comments->append( '\n' );
     }
     comments->append( newComments );
 }
 
 ServiceProviderData *ServiceProviderDataReader::readProviderData( const QString &serviceProviderId,
         const QString &fileName, const QString &country, ErrorAcceptance errorAcceptance,
         QObject *parent, QString *comments, QString *errorMessage )
 {
     const QString lang = KGlobal::locale()->country();
     QString langRead, url, shortUrl;
     QHash<QString, QString> names, descriptions;
     Enums::ServiceProviderType serviceProviderType;
     QString serviceProviderTypeString;
     const QString fileVersion = attributes().value("fileVersion").toString();
 
     if ( attributes().hasAttribute(QLatin1String("type")) ) {
         serviceProviderTypeString = attributes().value( QLatin1String("type") ).toString();
         serviceProviderType = ServiceProviderGlobal::typeFromString( serviceProviderTypeString );
         if ( serviceProviderType == Enums::InvalidProvider && errorAcceptance == OnlyReadCorrectFiles ) {
             if ( !handleError(QString("The service provider type %1 used for %2 is invalid. "
                               "Currently there are two values allowed: Script or GTFS.")
                               .arg(serviceProviderTypeString, serviceProviderId),
                               errorAcceptance, errorMessage) )
             {
                 return 0;
             }
             return 0;
         }
     } else {
         // No provider type in the XML file, use a default one
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         serviceProviderType = Enums::ScriptedProvider;
         serviceProviderTypeString = ServiceProviderGlobal::typeToString( serviceProviderType );
 #else
     #ifdef BUILD_PROVIDER_TYPE_GTFS
         serviceProviderType = Enums::GtfsProvider;
         serviceProviderTypeString = ServiceProviderGlobal::typeToString( serviceProviderType );
     #else
         kFatal() << "Internal error: No known provider type is supported, "
                     "tried ScriptedProvider and GtfsProvider";
     #endif
 #endif
-        kWarning() << "No provider type in the provider plugin file, using default type"
+        qWarning() << "No provider type in the provider plugin file, using default type"
                    << ServiceProviderGlobal::typeName(serviceProviderType);
     }
 
     ServiceProviderData *serviceProviderData =
             new ServiceProviderData( serviceProviderType, serviceProviderId, parent );
     serviceProviderData->setFileName( fileName );
     serviceProviderData->setCountry( country );
     serviceProviderData->setFileFormatVersion( fileVersion );
 
     if ( attributes().hasAttribute(QLatin1String("version")) ) {
         serviceProviderData->setVersion( attributes().value(QLatin1String("version")).toString() );
     }
 
     while ( !atEnd() ) {
         readNext();
 
         if ( isEndElement() && name().compare(QLatin1String("serviceProvider"), Qt::CaseInsensitive) == 0 ) {
             break;
         }
 
         if ( isComment() ) {
             if ( comments ) {
                 addComments( comments, text() );
             }
         } else if ( isStartElement() ) {
             if ( name().compare(QLatin1String("name"), Qt::CaseInsensitive) == 0 ) {
                 const QString nameRead = readLocalizedTextElement( &langRead );
                 names[ langRead ] = nameRead;
             } else if ( name().compare(QLatin1String("description"), Qt::CaseInsensitive) == 0 ) {
                 const QString descriptionRead = readLocalizedTextElement( &langRead );
                 descriptions[ langRead ] = descriptionRead;
             } else if ( name().compare(QLatin1String("author"), Qt::CaseInsensitive) == 0 ) {
                 QString authorName, shortName, authorEmail;
                 readAuthor( &authorName, &shortName, &authorEmail );
                 serviceProviderData->setAuthor( authorName, shortName, authorEmail );
             } else if ( name().compare(QLatin1String("cities"), Qt::CaseInsensitive) == 0 ) {
                 QStringList cities;
                 QHash<QString, QString> cityNameReplacements;
                 readCities( &cities, &cityNameReplacements );
                 serviceProviderData->setCities( cities );
                 serviceProviderData->setCityNameToValueReplacementHash( cityNameReplacements );
             } else if ( name().compare(QLatin1String("useSeperateCityValue"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setUseSeparateCityValue( readBooleanElement() );
             } else if ( name().compare(QLatin1String("onlyUseCitiesInList"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setOnlyUseCitiesInList( readBooleanElement() );
             } else if ( name().compare(QLatin1String("defaultVehicleType"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setDefaultVehicleType(
                         Global::vehicleTypeFromString(readElementText()) );
             } else if ( name().compare(QLatin1String("url"), Qt::CaseInsensitive) == 0 ) {
                 url = readElementText();
             } else if ( name().compare(QLatin1String("shortUrl"), Qt::CaseInsensitive) == 0 ) {
                 shortUrl = readElementText();
             } else if ( name().compare(QLatin1String("minFetchWait"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setMinFetchWait( readElementText().toInt() );
             } else if ( name().compare(QLatin1String("charsetForUrlEncoding"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setCharsetForUrlEncoding( readElementText().toAscii() );
             } else if ( name().compare(QLatin1String("fallbackCharset"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setFallbackCharset( readElementText().toAscii() ); // TODO Implement as attributes in the url tags?
             } else if ( name().compare(QLatin1String("changelog"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setChangelog( readChangelog() );
             } else if ( name().compare(QLatin1String("credit"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setCredit( readElementText() );
 #ifdef BUILD_PROVIDER_TYPE_GTFS
             } else if ( name().compare("feedUrl", Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setFeedUrl( readElementText() );
             } else if ( name().compare("realtimeTripUpdateUrl", Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setRealtimeTripUpdateUrl( readElementText() );
             } else if ( name().compare("realtimeAlertsUrl", Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setRealtimeAlertsUrl( readElementText() );
             } else if ( name().compare("timeZone", Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setTimeZone( readElementText() );
 #endif
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             } else if ( serviceProviderType == Enums::ScriptedProvider &&
                         name().compare(QLatin1String("script"), Qt::CaseInsensitive) == 0 )
             {
                 const QStringList extensions = attributes().value( QLatin1String("extensions") )
                         .toString().split( ',', QString::SkipEmptyParts );
                 const QString scriptFile = QFileInfo( fileName ).path() + '/' + readElementText();
                 if ( !QFile::exists(scriptFile) ) {
                     if ( !handleError(QString("The script file %1 referenced by the service "
                                       "provider plugin %2 was not found")
                                       .arg(scriptFile, serviceProviderId),
                                       errorAcceptance, errorMessage) )
                     {
                         delete serviceProviderData;
                         return 0;
                     }
                 }
                 serviceProviderData->setScriptFile( scriptFile, extensions );
 #endif
             } else if ( name().compare(QLatin1String("samples"), Qt::CaseInsensitive) == 0 ) {
                 QStringList stops;
                 QString city;
                 qreal longitude, latitude;
                 readSamples( &stops, &city, &longitude, &latitude );
                 serviceProviderData->setSampleStops( stops );
                 serviceProviderData->setSampleCity( city );
                 serviceProviderData->setSampleCoordinates( longitude, latitude );
             } else if ( name().compare(QLatin1String("notes"), Qt::CaseInsensitive) == 0 ) {
                 serviceProviderData->setNotes( readElementText() );
             } else {
                 readUnknownElement( comments );
             }
         }
     }
 
     if ( url.isEmpty() ) {
-        kWarning() << "No <url> tag in service provider plugin XML";
+        qWarning() << "No <url> tag in service provider plugin XML";
     }
 
     serviceProviderData->setNames( names );
     serviceProviderData->setDescriptions( descriptions );
     serviceProviderData->setUrl( url, shortUrl );
     serviceProviderData->finish();
 
     return serviceProviderData;
 }
 
 QString ServiceProviderDataReader::readLocalizedTextElement( QString *lang )
 {
     if ( attributes().hasAttribute(QLatin1String("lang")) ) {
         *lang = attributes().value(QLatin1String("lang")).toString();
     } else {
         *lang = "en";
     }
 
     return readElementText();
 }
 
 bool ServiceProviderDataReader::readBooleanElement()
 {
     const QString content = readElementText().trimmed();
     if ( content.compare( "true", Qt::CaseInsensitive ) == 0 || content == QLatin1String("1") ) {
         return true;
     } else {
         return false;
     }
 }
 
 void ServiceProviderDataReader::readAuthor( QString *fullname, QString *shortName, QString *email,
                                             QString *comments )
 {
     while ( !atEnd() ) {
         readNext();
 
         if ( isEndElement() && name().compare( "author", Qt::CaseInsensitive ) == 0 ) {
             break;
         }
 
         if ( isComment() ) {
             if ( comments ) {
                 addComments( comments, text() );
             }
         } else if ( isStartElement() ) {
             if ( name().compare(QLatin1String("fullName"), Qt::CaseInsensitive) == 0 ) {
                 *fullname = readElementText().trimmed();
             } else if ( name().compare(QLatin1String("short"), Qt::CaseInsensitive) == 0 ) {
                 *shortName = readElementText().trimmed();
             } else if ( name().compare(QLatin1String("email"), Qt::CaseInsensitive) == 0 ) {
                 *email = readElementText().trimmed();
             } else {
                 readUnknownElement();
             }
         }
     }
 }
 
 void ServiceProviderDataReader::readCities( QStringList *cities,
                                             QHash< QString, QString > *cityNameReplacements,
                                             QString *comments )
 {
     while ( !atEnd() ) {
         readNext();
 
         if ( isEndElement() && name().compare(QLatin1String("cities"), Qt::CaseInsensitive) == 0 ) {
             break;
         }
 
         if ( isComment() ) {
             if ( comments ) {
                 addComments( comments, text() );
             }
         } else if ( isStartElement() ) {
             if ( name().compare(QLatin1String("city"), Qt::CaseInsensitive ) == 0 ) {
                 if ( attributes().hasAttribute(QLatin1String("replaceWith")) ) {
                     QString replacement = attributes().value(QLatin1String("replaceWith")).toString().toLower();
                     QString city = readElementText();
                     cityNameReplacements->insert( city.toLower(), replacement );
                     cities->append( city );
                 } else {
                     QString city = readElementText();
                     cities->append( city );
                 }
             } else {
                 readUnknownElement();
             }
         }
     }
 }
 
 void ServiceProviderDataReader::readSamples( QStringList *stops, QString *city,
                                              qreal *longitude, qreal *latitude, QString *comments )
 {
     while ( !atEnd() ) {
         readNext();
 
         if ( isEndElement() && name().compare(QLatin1String("samples"), Qt::CaseInsensitive) == 0 ) {
             break;
         }
 
         if ( isComment() ) {
             if ( comments ) {
                 addComments( comments, text() );
             }
         } else if ( isStartElement() ) {
             if ( name().compare(QLatin1String("stop"), Qt::CaseInsensitive ) == 0 ) {
                 stops->append( readElementText() );
             } else if ( name().compare(QLatin1String("city"), Qt::CaseInsensitive ) == 0 ) {
                 *city = readElementText();
             } else if ( name().compare(QLatin1String("longitude"), Qt::CaseInsensitive ) == 0 ) {
                 *longitude = readElementText().toDouble();
             } else if ( name().compare(QLatin1String("latitude"), Qt::CaseInsensitive ) == 0 ) {
                 *latitude = readElementText().toDouble();
             } else {
                 readUnknownElement();
             }
         }
     }
 }
 
 QList<ChangelogEntry> ServiceProviderDataReader::readChangelog( QString *comments )
 {
     QList<ChangelogEntry> changelog;
     while ( !atEnd() ) {
         readNext();
         if ( isEndElement() && name().compare("changelog", Qt::CaseInsensitive) == 0 ) {
             break;
         }
 
         if ( isComment() ) {
             if ( comments ) {
                 addComments( comments, text() );
             }
         } else if ( isStartElement() ) {
             if ( name().compare("entry", Qt::CaseInsensitive) == 0 ) {
                 ChangelogEntry currentEntry;
                 if ( attributes().hasAttribute(QLatin1String("version")) ) {
                     currentEntry.version = attributes().value( QLatin1String("version") ).toString();
                 } else if ( attributes().hasAttribute(QLatin1String("since")) ) { // DEPRECATED
                     currentEntry.version = attributes().value( QLatin1String("since") ).toString();
                 }
                 if( attributes().hasAttribute(QLatin1String("releasedWith")) ) {
                     currentEntry.engineVersion = attributes().value( QLatin1String("releasedWith") ).toString();
                 } else if ( attributes().hasAttribute(QLatin1String("engineVersion")) ) { // DEPRECATED
                     currentEntry.engineVersion = attributes().value( QLatin1String("engineVersion") ).toString();
                 }
                 if ( attributes().hasAttribute(QLatin1String("author")) ) {
                     currentEntry.author = attributes().value( QLatin1String("author") ).toString();
                 }
                 currentEntry.description = readElementText();
                 changelog.append( currentEntry );
             } else {
                 readUnknownElement();
             }
         }
     }
     return changelog;
 }
diff --git a/engine/serviceproviderglobal.cpp b/engine/serviceproviderglobal.cpp
index b338046..e788dad 100644
--- a/engine/serviceproviderglobal.cpp
+++ b/engine/serviceproviderglobal.cpp
@@ -1,384 +1,384 @@
 /*
  *   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 "serviceproviderglobal.h"
 
 // Own includes
 #include "config.h"
 
 // KDE includes
 #include <KGlobal>
 #include <KStandardDirs>
 #include <KDebug>
 #include <KMimeType>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 // Qt includes
 #include <QFile>
 #include <QFileInfo>
 
 QList< Enums::ServiceProviderType > ServiceProviderGlobal::availableProviderTypes()
 {
     QList< Enums::ServiceProviderType > types;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     types << Enums::ScriptedProvider;
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     types << Enums::GtfsProvider;
 #endif
     return types;
 }
 
 bool ServiceProviderGlobal::isProviderTypeAvailable( Enums::ServiceProviderType type )
 {
     switch ( type ) {
     case Enums::ScriptedProvider:
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         return true;
 #else
         return false;
 #endif
 
     case Enums::GtfsProvider:
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         return true;
 #else
         return false;
 #endif
 
     case Enums::InvalidProvider:
     default:
         return false;
     }
 }
 
 QString ServiceProviderGlobal::defaultProviderForLocation( const QString &location )
 {
     QStringList locationProviders;
     const QString subDirectory = installationSubDirectory();
     foreach ( const QString &pattern, filePatterns() ) {
         locationProviders << KGlobal::dirs()->findAllResources(
                 "data", subDirectory + location + '_' + pattern );
     }
     if ( locationProviders.isEmpty() ) {
-        kWarning() << "Couldn't find any providers for location" << location;
+        qWarning() << "Couldn't find any providers for location" << location;
         return QString();
     }
 
     // Simply return first found provider as default provider
     return locationProviders.first();
 }
 
 QString ServiceProviderGlobal::cacheFileName()
 {
     return KGlobal::dirs()->saveLocation("data", "plasma_engine_publictransport/")
             .append( QLatin1String("datacache") );
 }
 
 QSharedPointer< KConfig > ServiceProviderGlobal::cache()
 {
     return QSharedPointer< KConfig >( new KConfig(cacheFileName(), KConfig::SimpleConfig) );
 }
 
 void ServiceProviderGlobal::cleanupCache( const QSharedPointer< KConfig > &_cache )
 {
     QSharedPointer< KConfig > cache = _cache.isNull() ? ServiceProviderGlobal::cache() : _cache;
     const QStringList installedProviderPaths = ServiceProviderGlobal::installedProviders();
     QStringList installedProviderIDs;
     foreach ( const QString &installedProviderPath, installedProviderPaths ) {
         installedProviderIDs << idFromFileName( installedProviderPath );
     }
 
     foreach ( const QString &group, cache->groupList() ) {
         if ( group != QLatin1String("script") && group != QLatin1String("gtfs") &&
              !installedProviderIDs.contains(group) )
         {
             // Found a group for a provider that is no longer installed
             kDebug() << "Cleanup cache data for no longer installed provider" << group;
             clearCache( group, cache, false );
         }
     }
     cache->sync();
 }
 
 void ServiceProviderGlobal::clearCache( const QString &providerId,
                                         const QSharedPointer< KConfig > &_cache, bool syncCache )
 {
     QSharedPointer< KConfig > cache = _cache.isNull() ? ServiceProviderGlobal::cache() : _cache;
     if ( !cache->hasGroup(providerId) ) {
         // No data cached for the provider
         return;
     }
 
     // Remove all data for the provider from the cache
     cache->deleteGroup( providerId );
 
     // Remove provider from "usingProviders" lists for included script files
     KConfigGroup globalScriptGroup = cache->group( "script" );
     const QStringList globalScriptGroupNames = globalScriptGroup.groupList();
     foreach ( const QString &globalScriptGroupName, globalScriptGroupNames ) {
         if ( !globalScriptGroupName.startsWith(QLatin1String("include_")) ) {
             continue;
         }
 
         // Check if the provider to remove from the cache is listed as using the current include
         KConfigGroup includeFileGroup = globalScriptGroup.group( globalScriptGroupName );
         QStringList usingProviders = includeFileGroup.readEntry( "usingProviders", QStringList() );
         if ( usingProviders.contains(providerId) ) {
             // Remove provider from the list of providers using the current include script file
             usingProviders.removeOne( providerId );
             includeFileGroup.writeEntry( "usingProviders", usingProviders );
         }
     }
 
     if ( syncCache ) {
         cache->sync();
     }
 }
 
 QString ServiceProviderGlobal::idFromFileName( const QString &serviceProviderFileName )
 {
     // Get the service provider substring from the XML filename, ie. "/path/to/xml/<id>.pts/xml"
     return QFileInfo( serviceProviderFileName ).baseName();
 }
 
 QString ServiceProviderGlobal::fileNameFromId( const QString &serviceProviderId )
 {
     const QString subDirectory = installationSubDirectory();
     foreach ( const QString &extension, fileExtensions() ) {
         const QString fileName = KGlobal::dirs()->findResource(
                 "data", subDirectory + serviceProviderId + '.' + extension );
         if ( !fileName.isEmpty() ) {
             return fileName;
         }
     }
 
     // File not found
     kDebug() << "No service provider plugin found with this ID:" << serviceProviderId;
     return QString();
 }
 
 Enums::ServiceProviderType ServiceProviderGlobal::typeFromString(
         const QString &serviceProviderType )
 {
     QString s = serviceProviderType.toLower();
     if ( s == QLatin1String("script") ||
          s == QLatin1String("html") ) // DEPRECATED
     {
         return Enums::ScriptedProvider;
     } else if ( s == QLatin1String("gtfs") ) {
         return Enums::GtfsProvider;
     } else {
         return Enums::InvalidProvider;
     }
 }
 
 QString ServiceProviderGlobal::typeToString( Enums::ServiceProviderType type )
 {
     switch ( type ) {
     case Enums::ScriptedProvider:
         return "script";
     case Enums::GtfsProvider:
         return "gtfs";
     case Enums::InvalidProvider:
     default:
         return "invalid";
     }
 }
 
 QString ServiceProviderGlobal::typeName( Enums::ServiceProviderType type, ProviderTypeNameOptions options )
 {
     QString name;
     switch ( type ) {
     case Enums::ScriptedProvider:
         name = i18nc("@info/plain Name of a service provider plugin type", "Scripted");
         break;
     case Enums::GtfsProvider:
         name = i18nc("@info/plain Name of a service provider plugin type", "GTFS");
         break;
     case Enums::InvalidProvider:
     default:
-        kWarning() << "Invalid provider type" << type;
+        qWarning() << "Invalid provider type" << type;
         return i18nc("@info/plain Name of the invalid service provider plugin type", "Invalid");
     }
 
     // Append "(unsupported)" if the engine gets build without support for the provider type
     if ( options == AppendHintForUnsupportedProviderTypes && !isProviderTypeAvailable(type) ) {
         name += ' ' + i18nc("@info/plain Gets appended to service provider plugin type names, "
                             "if the engine gets build without support for that type",
                             "(unsupported)");
     }
     return name;
 }
 
 QStringList ServiceProviderGlobal::filePatterns()
 {
     const KMimeType::Ptr mimeType =
             KMimeType::mimeType("application/x-publictransport-serviceprovider");
     if ( mimeType.isNull() ) {
-        kWarning() << "The application/x-publictransport-serviceprovider mime type was not found!";
-        kWarning() << "No provider plugins will get loaded.";
+        qWarning() << "The application/x-publictransport-serviceprovider mime type was not found!";
+        qWarning() << "No provider plugins will get loaded.";
         kDebug() << "Solution: Make sure 'serviceproviderplugin.xml' is installed correctly "
                     "and run kbuildsycoca4.";
         return QStringList();
     } else {
         return mimeType->patterns();
     }
 }
 
 QStringList ServiceProviderGlobal::fileExtensions()
 {
     QStringList extensions = filePatterns();
     for ( QStringList::Iterator it = extensions.begin(); it != extensions.end(); ++it ) {
         const int pos = it->lastIndexOf( '.' );
         if ( pos == -1 || pos == it->length() - 1 ) {
-            kWarning() << "Could not extract file extension from mime type pattern!\n"
+            qWarning() << "Could not extract file extension from mime type pattern!\n"
                           "Check the \"application/x-publictransport-serviceprovider\" mime type.";
             continue;
         }
 
         // Cut away everything but the file name extension
         *it = it->mid( pos + 1 );
     }
     return extensions;
 }
 
 QStringList ServiceProviderGlobal::installedProviders()
 {
     QStringList providers;
     const QString subDirectory = installationSubDirectory();
     foreach ( const QString &pattern, filePatterns() ) {
         providers << KGlobal::dirs()->findAllResources( "data", subDirectory + pattern );
     }
     return providers;
 }
 
 bool ServiceProviderGlobal::isProviderInstalled( const QString &providerId )
 {
     const QString subDirectory = installationSubDirectory();
     foreach ( const QString &extension, fileExtensions() ) {
         const QString providerFile = KGlobal::dirs()->findResource(
                 "data", subDirectory + providerId + '.' + extension );
         if ( !providerFile.isEmpty() ) {
             // Found the provider plugin source file in an installation directory
             return true;
         }
     }
 
     // Provider is not installed
     return false;
 }
 
 bool ServiceProviderGlobal::isSourceFileModified( const QString &providerId,
                                                   const QSharedPointer<KConfig> &cache )
 {
     // Check if the script file was modified since the cache was last updated
     const KConfigGroup group = cache->group( providerId );
     const QDateTime modifiedTime = group.readEntry( "modifiedTime", QDateTime() );
     const QString fileName = fileNameFromId( providerId );
     return fileName.isEmpty() ? true : QFileInfo(fileName).lastModified() != modifiedTime;
 }
 
 QString ServiceProviderGlobal::featureName( Enums::ProviderFeature feature )
 {
     switch ( feature ) {
     case Enums::ProvidesDepartures:
         return i18nc("@info/plain A short string indicating support for departure from a stop",
                      "Departures");
     case Enums::ProvidesArrivals:
         return i18nc("@info/plain A short string indicating support for arrivals to a stop.",
                      "Arrivals");
     case Enums::ProvidesJourneys:
         return i18nc("@info/plain A short string indicating support for journeys",
                      "Journey search");
     case Enums::ProvidesAdditionalData:
         return i18nc("@info/plain A short string indicating support for additional data",
                      "Get additional data later");
     case Enums::ProvidesDelays:
         return i18nc("@info/plain A short string indicating that delay information can be provided",
                      "Delays");
     case Enums::ProvidesNews:
         return i18nc("@info/plain A short string indicating that news about timetable items can be provided",
                      "News");
     case Enums::ProvidesPlatform:
         return i18nc("@info/plain A short string indicating that platform information can be provided",
                      "Platform");
     case Enums::ProvidesStopSuggestions:
         return i18nc("@info/plain A short string indicating support for stop suggestions",
                      "Stop suggestions");
     case Enums::ProvidesStopsByGeoPosition:
         return i18nc("@info/plain A short string indicating support for querying stops by geo position",
                      "Stops by geolocation");
     case Enums::ProvidesStopID:
         return i18nc("@info/plain A short string indicating that stop IDs can be provided",
                      "Stop ID");
     case Enums::ProvidesStopGeoPosition:
         return i18nc("@info/plain A short string indicating that stop geographical positions can be provided",
                      "Stop geolocation");
     case Enums::ProvidesPricing:
         return i18nc("@info/plain A short string indicating that pricing information can be provided",
                      "Pricing");
     case Enums::ProvidesRouteInformation:
         return i18nc("@info/plain A short string indicating that route information can be provided",
                      "Route information");
     case Enums::ProvidesMoreJourneys:
         return i18nc("@info/plain A short string indicating that earlier later journeys can be "
                      "provided for existing journey data sources",
                      "Get earlier/later journeys");
     default:
-        kWarning() << "Unexpected feature value" << feature;
+        qWarning() << "Unexpected feature value" << feature;
         return QString();
     }
 }
 
 QStringList ServiceProviderGlobal::featureNames( const QList<Enums::ProviderFeature> &features )
 {
     QStringList names;
     foreach ( Enums::ProviderFeature feature, features ) {
         names << featureName( feature );
     }
     return names;
 }
 
 QStringList ServiceProviderGlobal::featureStrings( const QList<Enums::ProviderFeature> &features )
 {
     QStringList names;
     foreach ( Enums::ProviderFeature feature, features ) {
         names << Enums::toString( feature );
     }
     return names;
 }
 
 QList< Enums::ProviderFeature > ServiceProviderGlobal::featuresFromFeatureStrings(
         const QStringList &featureNames, bool *ok )
 {
     QList< Enums::ProviderFeature > features;
     if ( ok ) *ok = true;
     foreach ( const QString &featureName, featureNames ) {
         Enums::ProviderFeature feature = Enums::stringToFeature( featureName.toAscii().data() );
         if ( feature == Enums::InvalidProviderFeature ) {
             if ( ok ) *ok = false;
         } else {
             features << feature;
         }
     }
     return features;
 }
diff --git a/engine/serviceprovidertestdata.cpp b/engine/serviceprovidertestdata.cpp
index bb94af3..967aa55 100644
--- a/engine/serviceprovidertestdata.cpp
+++ b/engine/serviceprovidertestdata.cpp
@@ -1,157 +1,157 @@
 /*
  *   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 "serviceprovidertestdata.h"
 
 // Own includes
 #include "serviceprovider.h"
 #include "serviceproviderglobal.h"
 
 // KDE includes
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KDebug>
 
 // Qt includes
 #include <QSharedPointer>
 #include <QFileInfo>
 
 
 ServiceProviderTestData::ServiceProviderTestData( Results results, const QString &errorMessage )
         : m_results(results)
 {
     setErrorMessage( errorMessage );
 }
 
 void ServiceProviderTestData::setResults( Results testResults, const QString &errorMessage )
 {
     m_results = testResults;
     setErrorMessage( errorMessage );
 }
 
 void ServiceProviderTestData::setErrorMessage( const QString &errorMessage )
 {
     if ( m_results == AllTestsPassed ) {
         // Do not store error message if there is no error
         m_errorMessage.clear();
     } else if ( errorMessage.isEmpty() ) {
         const Status status = statusFromResults( m_results );
         switch ( status ) {
         case Failed:
             m_errorMessage = i18nc("@info/plain", "Provider plugin is invalid");
             break;
         case Passed:
             m_errorMessage.clear();
             break;
         case Pending:
             m_errorMessage = i18nc("@info/plain", "Provider plugin test is pending");
             break;
         }
     } else {
         m_errorMessage = errorMessage;
     }
 }
 
 ServiceProviderTestData::Status ServiceProviderTestData::statusFromResults( Results testResults )
 {
     if ( testResults == AllTestsPassed ) {
         // All tests passed
         return Passed;
     } else if ( testResults.testFlag(XmlStructureTestFailed) ||
                 testResults.testFlag(SubTypeTestFailed) )
     {
         // A test failed
         return Failed;
     } else {
         // Not all tests were run (no test failed and not all tests passed)
         return Pending;
     }
 }
 
 ServiceProviderTestData ServiceProviderTestData::read( const QString &providerId,
                                                        const QSharedPointer< KConfig > &cache )
 {
     // Check if the source XML file was modified since the cache was last updated
     if ( ServiceProviderGlobal::isSourceFileModified(providerId, cache) ) {
         // Source file modified, all tests need to be rerun
         return ServiceProviderTestData( NoTestWasRun );
     } else {
         // Source file not modified, read test data from config or use defaults
         const KConfigGroup group = cache->group( providerId );
         const Results testResults = static_cast<Results>(
                 group.readEntry("testResults", static_cast<int>(NoTestWasRun)) );
         return ServiceProviderTestData( testResults, group.readEntry("errorMessage", QString()) );
     }
 }
 
 void ServiceProviderTestData::write( const QString &providerId,
                                      const ServiceProviderTestData &testData,
                                      const QSharedPointer<KConfig> &cache )
 {
     if ( providerId.isEmpty() ) {
-        kWarning() << "No provider plugin ID given!";
+        qWarning() << "No provider plugin ID given!";
         return;
     }
 
     KConfigGroup group = cache->group( providerId );
     const QString fileName = ServiceProviderGlobal::fileNameFromId(providerId);
     group.writeEntry( "modifiedTime", QFileInfo(fileName).lastModified() );
     group.writeEntry( "testResults", static_cast<int>(testData.results()) );
     if ( !testData.errorMessage().isEmpty() ) {
         group.writeEntry( "errorMessage", testData.errorMessage() );
     } else if ( group.hasKey("errorMessage") ) {
         // Do not keep old error messages in the cache
         group.deleteEntry( "errorMessage" );
     }
     group.sync();
 }
 
 void ServiceProviderTestData::setXmlStructureTestStatus( Status status, const QString &errorMessage )
 {
     switch ( status ) {
     case Pending:
         setResults( m_results & ~(XmlStructureTestPassed | XmlStructureTestFailed) );
         break;
     case Passed:
         setResults( (m_results | XmlStructureTestPassed ) & (~XmlStructureTestFailed) );
         break;
     case Failed:
         setResults( (m_results | XmlStructureTestFailed) & (~XmlStructureTestPassed),
                     errorMessage );
         break;
     }
 }
 
 void ServiceProviderTestData::setSubTypeTestStatus( Status status, const QString &errorMessage )
 {
     switch ( status ) {
     case Pending:
         setResults( m_results & ~(SubTypeTestPassed | SubTypeTestFailed) );
         break;
     case Passed:
         setResults( (m_results | SubTypeTestPassed) & (~SubTypeTestFailed) );
         break;
     case Failed:
         setResults( (m_results | SubTypeTestFailed) & (~SubTypeTestPassed),
                     errorMessage );
         break;
     }
 }
diff --git a/engine/timetablemate/src/debugger/backtracemodel.cpp b/engine/timetablemate/src/debugger/backtracemodel.cpp
index b8b456f..43f901e 100644
--- a/engine/timetablemate/src/debugger/backtracemodel.cpp
+++ b/engine/timetablemate/src/debugger/backtracemodel.cpp
@@ -1,245 +1,245 @@
 /*
 *   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 "backtracemodel.h"
 
 // Own includes
 #include "debuggerstructures.h"
 #include "debugger.h"
 
 // KDE includes
 #include <KDebug>
 #include <KLocalizedString>
 
 using namespace Debugger;
 
 BacktraceModel::BacktraceModel( QObject *parent )
         : QAbstractListModel( parent )
 {
 }
 
 BacktraceModel::~BacktraceModel()
 {
     qDeleteAll( m_frames );
 }
 
 QVariant BacktraceModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
     if ( orientation == Qt::Horizontal && role == Qt::DisplayRole ) {
         switch ( static_cast<Column>(section) ) {
         case DepthColumn:
             return i18nc("@title:column", "Depth");
         case FunctionColumn:
             return i18nc("@title:column", "Function");
         case SourceColumn:
             return i18nc("@title:column", "Source");
         default:
             return QVariant();
         }
     }
 
     return QVariant();
 }
 
 QVariant BacktraceModel::data( const QModelIndex &index, int role ) const
 {
     if ( !index.isValid() || index.row() >= m_frames.count() ) {
         return QVariant();
     }
 
     Frame *frame = m_frames[ rowToIndex(index.row()) ];
     switch ( role ) {
     case Qt::DisplayRole:
         switch ( index.column() ) {
         case DepthColumn:
             return rowToIndex( m_frames.indexOf(frame) );
         case FunctionColumn:
             return frame->contextString();
         case SourceColumn: {
             const int lineNumber = frame->lineNumber() == -1
                     ? frame->contextInfo().functionStartLineNumber() : frame->lineNumber();
             if ( lineNumber == -1 ) {
                 if ( frame->fileName().isEmpty() ) {
                     return "??";
                 } else {
                     return frame->fileName();
                 }
             } else {
                 return QString("%0: %1").arg(frame->fileName()).arg(lineNumber);
             }
         } break;
         default:
-            kWarning() << "Unknown backtrace model column" << index.column();
+            qWarning() << "Unknown backtrace model column" << index.column();
             break;
         }
     }
 
     return QVariant();
 }
 
 Qt::ItemFlags BacktraceModel::flags( const QModelIndex &index ) const
 {
     return !index.isValid() ? Qt::NoItemFlags : Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 }
 
 void BacktraceModel::applyChange( const BacktraceChange &change )
 {
     switch ( change.type ) {
     case PushBacktraceFrame:
         pushFrame( new Frame() );
         break;
     case PopBacktraceFrame:
         popFrame();
         break;
     case UpdateBacktraceFrame: {
         if( m_frames.isEmpty() ) {
-            kWarning() << "Trying to update current backtrace frame, but the model is empty";
+            qWarning() << "Trying to update current backtrace frame, but the model is empty";
             pushFrame( new Frame() );
         }
 
         m_frames.top()->setValuesOf( change.frame );
     } break;
     default:
-        kWarning() << "BacktraceChange type not implemented" << change.type;
+        qWarning() << "BacktraceChange type not implemented" << change.type;
         break;
     }
 }
 
 void BacktraceModel::frameChanged( Frame *frame )
 {
     QModelIndex frameIndex = indexFromFrame( frame );
     if ( !frameIndex.isValid() ) {
-        kWarning() << "Frame not found" << frame;
+        qWarning() << "Frame not found" << frame;
         return;
     }
 
     dataChanged( frameIndex, index(frameIndex.row(), ColumnCount - 1) );
 }
 
 FrameStack BacktraceModel::frameStack() const
 {
     return m_frames;
 }
 
 void BacktraceModel::pushFrame( Frame *frame )
 {
     beginInsertRows( QModelIndex(), m_frames.count(), m_frames.count() );
     frame->setModel( this );
     m_frames.push( frame );
     endInsertRows();
 }
 
 void BacktraceModel::popFrame()
 {
     if ( m_frames.isEmpty() ) {
         kDebug() << "Model is empty!";
         return;
     }
 
     removeRow( 0 );
 }
 
 Frame *Debugger::BacktraceModel::topFrame()
 {
     return m_frames.isEmpty() ? 0 : m_frames.top();
 }
 
 bool BacktraceModel::removeRows( int row, int count, const QModelIndex &parent )
 {
     if ( count == 0 ) {
         return true;
     }
 
     // Remove the frames from the model
     row = rowToIndex( row );
     beginRemoveRows( parent, row, row + count - 1 );
     if ( row == 0 ) {
         for ( int i = 0; i < count; ++i ) {
             delete m_frames.pop();
         }
     } else {
         // Remove frames from the middle or beginning of the backtrace
         for ( int i = row - count + 1; i >= row; --i ) {
             // Remove frame and delete it
             Frame *frame = m_frames[ i ];
             m_frames.remove( i );
             delete frame;
         }
     }
     endRemoveRows();
     return true;
 }
 
 void BacktraceModel::clear()
 {
     removeRows( 0, m_frames.count() );
 }
 
 bool BacktraceModel::isEmpty()
 {
     return m_frames.isEmpty();
 }
 
 QModelIndex BacktraceModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( parent.isValid() || row < 0 || row >= m_frames.count() ||
          column < 0 || column >= ColumnCount )
     {
         return QModelIndex();
     } else {
         return createIndex( row, column, m_frames[rowToIndex(row)] );
     }
 }
 
 QModelIndex BacktraceModel::indexFromFrame( Frame *frame ) const
 {
     const int row = m_frames.indexOf( frame );
     return row == -1 ? QModelIndex() : createIndex( row, 0, m_frames[rowToIndex(row)] );
 }
 
 
 QModelIndex BacktraceModel::indexFromRow( int row ) const
 {
     if ( row < 0 || row >= m_frames.count() ) {
         return QModelIndex();
     } else {
         return createIndex( row, 0, m_frames[rowToIndex(row)] );
     }
 }
 
 Frame *BacktraceModel::frameFromRow( int row ) const
 {
     return m_frames[ rowToIndex(row) ];
 }
 
 Frame *BacktraceModel::frameFromIndex( const QModelIndex &index ) const
 {
     return static_cast< Frame* >( index.internalPointer() );
 }
 
 int BacktraceModel::rowCount( const QModelIndex &parent ) const
 {
     return parent.isValid() ? 0 : m_frames.count();
 }
 
 int BacktraceModel::columnCount( const QModelIndex &parent ) const
 {
     return parent.isValid() ? 0 : ColumnCount;
 }
diff --git a/engine/timetablemate/src/debugger/breakpointmodel.cpp b/engine/timetablemate/src/debugger/breakpointmodel.cpp
index 497904e..a09f22a 100644
--- a/engine/timetablemate/src/debugger/breakpointmodel.cpp
+++ b/engine/timetablemate/src/debugger/breakpointmodel.cpp
@@ -1,569 +1,569 @@
 /*
 *   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 "breakpointmodel.h"
 
 // Own includes
 #include "debuggerstructures.h"
 #include "debugger.h"
 
 // KDE includes
 #include <KDebug>
 #include <KLocalizedString>
 
 // Qt includes
 #include <QCheckBox>
 #include <QApplication>
 #include <QAbstractItemView>
 #include <QTreeView>
 #include <QHeaderView>
 #include <QFileInfo>
 
 using namespace Debugger;
 
 BreakpointModel::BreakpointModel( QObject *parent )
         : QAbstractListModel( parent )
 {
 }
 
 BreakpointModel::~BreakpointModel()
 {
     for ( QHash<QString, BreakpointData>::Iterator it = m_breakpointsByFile.begin();
           it != m_breakpointsByFile.end(); ++it )
     {
         qDeleteAll( it->breakpoints );
     }
 }
 
 void BreakpointModel::slotBreakpointChanged( Breakpoint *breakpoint )
 {
     const QModelIndex index = indexFromBreakpoint( breakpoint );
     if ( index.isValid() ) {
         emit dataChanged( index, index );
         emit breakpointModified( *breakpoint );
     } else {
         kDebug() << "Could not find breakpoint at line" << breakpoint->lineNumber() << "in the model";
     }
 }
 
 QVariant BreakpointModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
     if ( orientation == Qt::Horizontal && role == Qt::DisplayRole ) {
         switch ( static_cast<Column>(section) ) {
         case EnableColumn:
             return i18nc("@title:column", "Enabled");
         case SourceColumn:
             return i18nc("@title:column", "Address");
         case ConditionColumn:
             return i18nc("@title:column", "Condition");
         case HitCountColumn:
             return i18nc("@title:column", "Hits");
         case LastConditionResultColumn:
             return i18nc("@title:column", "Last Condition Result");
         default:
             return QVariant();
         }
     }
 
     return QVariant();
 }
 
 QVariant BreakpointModel::data( const QModelIndex &index, int role ) const
 {
     if ( !index.isValid() || index.row() >= rowCount(index.parent()) ) {
         return QVariant();
     }
 
     Breakpoint *breakpoint = breakpointFromRow( index.row() );
     switch ( role ) {
     case Qt::DisplayRole:
         switch ( index.column() ) {
         case EnableColumn:
             return breakpoint->isEnabled();
         case SourceColumn:
             return QString("%1:%2").arg( QFileInfo(breakpoint->fileName()).fileName() )
                                    .arg( breakpoint->lineNumber() );
         case HitCountColumn:
             return breakpoint->hitCount();
         case ConditionColumn:
             return breakpoint->condition();
         case LastConditionResultColumn:
             return breakpoint->lastConditionResult().toString();
         default:
-            kWarning() << "Unknown breakpoint model column" << index.column();
+            qWarning() << "Unknown breakpoint model column" << index.column();
             break;
         }
 
     case Qt::EditRole:
         switch ( index.column() ) {
         case EnableColumn:
             return breakpoint->isEnabled();
         case ConditionColumn:
             return breakpoint->condition();
         default:
             break;
         }
     }
 
     return QVariant();
 }
 
 bool BreakpointModel::setData( const QModelIndex &index, const QVariant &value, int role )
 {
     if ( !index.isValid() || index.row() >= rowCount(index.parent()) ) {
         return false;
     }
 
     Breakpoint *breakpoint = breakpointFromRow( index.row() );
     switch ( role ) {
     case Qt::EditRole:
         switch ( index.column() ) {
         case EnableColumn:
             kDebug() << "Update enabled state from" << breakpoint->isEnabled() << "to" << value.toBool();
             breakpoint->setEnabled( value.toBool() ); // Automatically emits dataChanged() / breakpointModified()
             return true;
         case ConditionColumn:
             breakpoint->setCondition( value.toString() );
             return true;
         }
     }
 
     return false;
 }
 
 Qt::ItemFlags BreakpointModel::flags( const QModelIndex &index ) const
 {
     if ( !index.isValid() ) {
         return Qt::NoItemFlags;
     }
 
     const Column column = static_cast< Column >( index.column() );
     if ( column == EnableColumn ||  column == ConditionColumn ) {
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
     } else {
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
     }
 }
 
 QList< Breakpoint * > BreakpointModel::breakpoints( const QString &fileName ) const
 {
     return m_breakpointsByFile[ fileName ].breakpoints;
 }
 
 QHash< uint, Breakpoint * > BreakpointModel::breakpointsByLineNumber( const QString &fileName ) const
 {
     return m_breakpointsByFile[ fileName ].breakpointsByLineNumber;
 }
 
 void BreakpointModel::applyChange( const BreakpointChange &change )
 {
     switch ( change.type ) {
     case AddBreakpoint:
         addBreakpoint( new Breakpoint(change.breakpoint) );
         break;
     case RemoveBreakpoint:
         removeBreakpoint( breakpointFromLineNumber(change.breakpoint.fileName(),
                                                    change.breakpoint.lineNumber()) );
         break;
     case UpdateBreakpoint:
         updateBreakpoint( change.breakpoint );
         break;
 
     case NoOpBreakpointChange:
     default:
         break;
     }
 }
 
 bool BreakpointModel::hasBreakpoint( int lineNumber ) const
 {
     for ( QHash<QString, BreakpointData>::ConstIterator it = m_breakpointsByFile.constBegin();
           it != m_breakpointsByFile.constEnd(); ++it )
     {
         if ( it->breakpointsByLineNumber.contains(lineNumber) ) {
             return true;
         }
     }
     return false;
 }
 
 bool BreakpointModel::hasBreakpoint( const QString &fileName, int lineNumber ) const
 {
     return m_breakpointsByFile[ fileName ].breakpointsByLineNumber.contains( lineNumber );
 }
 
 void BreakpointModel::updateBreakpoint( const Breakpoint &breakpoint )
 {
     if ( !breakpoint.isValid() ) {
         kDebug() << "Breakpoint is invalid" << breakpoint.lineNumber() << breakpoint.condition();
         return;
     }
 
     // Check if there already is a Breakpoint object for the line number
     if ( !hasBreakpoint(breakpoint.fileName(), breakpoint.lineNumber()) ) {
         kDebug() << "No breakpoint found to update at line" << breakpoint.lineNumber();
         return;
     }
 
     Breakpoint *foundBreakpoint = breakpointFromLineNumber( breakpoint.fileName(),
                                                             breakpoint.lineNumber() );
     const QModelIndex index = indexFromBreakpoint( foundBreakpoint );
     foundBreakpoint->setValuesOf( breakpoint );
     emit dataChanged( index, index );
     emit breakpointModified( *foundBreakpoint );
 }
 
 void BreakpointModel::addBreakpoint( Breakpoint *breakpoint )
 {
     kDebug() << "Add breakpoint in" << QFileInfo(breakpoint->fileName()).fileName()
              << "at line" << breakpoint->lineNumber();
     if ( !breakpoint->isValid() ) {
         kDebug() << "Breakpoint is invalid" << breakpoint->lineNumber() << breakpoint->condition();
         return;
     }
 
     // Check if there already is a Breakpoint object for the line number
     if ( hasBreakpoint(breakpoint->fileName(), breakpoint->lineNumber()) ) {
         updateBreakpoint( *breakpoint );
         return;
     }
 
     const int count = rowCount();
     beginInsertRows( QModelIndex(), count, count );
     if ( breakpoint->model() ) {
-        kWarning() << "Breakpoint already used in another model";
+        qWarning() << "Breakpoint already used in another model";
     }
     breakpoint->setModel( this );
     BreakpointData &data = m_breakpointsByFile[ breakpoint->fileName() ];
     data.breakpoints << breakpoint;
     data.breakpointsByLineNumber.insert( breakpoint->lineNumber(), breakpoint );
     endInsertRows();
 
     emit breakpointAdded( *breakpoint );
     if ( count == 0 ) {
         emit emptinessChanged( false );
     }
 }
 
 void BreakpointModel::removeBreakpoint( Breakpoint *breakpoint )
 {
     kDebug() << "Remove breakpoint in" << QFileInfo(breakpoint->fileName()).fileName()
              << "at line" << breakpoint->lineNumber();
     int row = indexFromBreakpoint( breakpoint ).row();
     if ( row == -1 ) {
-        kWarning() << "Breakpoint not found";
+        qWarning() << "Breakpoint not found";
         return;
     }
 
     removeRow( row );
 }
 
 bool BreakpointModel::removeRows( int row, int count, const QModelIndex &parent )
 {
     if ( isEmpty() || parent.isValid() ) {
         return false;
     }
 
     // Collect breakpoints to be removed
     QList< Breakpoint* > removeBreakpoints;
     int _row = row;
     int _count = count;
     for ( QHash<QString, BreakpointData>::ConstIterator it = m_breakpointsByFile.constBegin();
           it != m_breakpointsByFile.constEnd(); ++it )
     {
         if ( _row < it->breakpoints.count() ) {
             QList< Breakpoint* > newRemoveBreakpoints = it->breakpoints.mid( _row, _count );
             _count -= newRemoveBreakpoints.count();
             _row = 0;
             removeBreakpoints << newRemoveBreakpoints;
 
             if ( _count == 0 ) {
                 break;
             }
         } else if ( _row > 0 ) {
             _row -= it->breakpoints.count();
         }
     }
 
     // Emit signals for breakpoints that get removed (before they get deleted)
     foreach ( Breakpoint *breakpoint, removeBreakpoints ) {
         emit breakpointAboutToBeRemoved( *breakpoint );
     }
 
     // Remove the breakpoints from the model
     beginRemoveRows( parent, row, row + count - 1 );
     BreakpointData *data = 0;
     foreach ( Breakpoint *breakpoint, removeBreakpoints ) {
         if ( !data || data->breakpoints.first()->fileName() != breakpoint->fileName() ) {
             data = &m_breakpointsByFile[ breakpoint->fileName() ];
         }
 
         data->breakpoints.removeOne( breakpoint );
         data->breakpointsByLineNumber.remove( breakpoint->lineNumber() );
         delete breakpoint;
     }
     endRemoveRows();
 
     if ( isEmpty() ) {
         emit emptinessChanged( true );
     }
     return true;
 }
 
 void BreakpointModel::clear()
 {
     removeRows( 0, rowCount() );
 }
 
 QModelIndex BreakpointModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( parent.isValid() || row < 0 || row >= rowCount(parent) ||
          column < 0 || column >= ColumnCount )
     {
         return QModelIndex();
     } else {
         return createIndex( row, column, breakpointFromRow(row) );
     }
 }
 
 QModelIndex BreakpointModel::indexFromBreakpoint( Breakpoint *breakpoint ) const
 {
     int row = 0;
     for ( QHash<QString, BreakpointData>::ConstIterator it = m_breakpointsByFile.constBegin();
           it != m_breakpointsByFile.constEnd(); ++it )
     {
         int r = it->breakpoints.indexOf( breakpoint );
         if ( r != -1 ) {
             row += r;
             break;
         } else {
             row += it->breakpoints.count();
         }
     }
 
     return row == -1 ? QModelIndex() : createIndex( row, 0, breakpoint );
 }
 
 
 QModelIndex BreakpointModel::indexFromRow( int row ) const
 {
     Breakpoint *breakpoint = breakpointFromRow( row );
     if ( !breakpoint ) {
         return QModelIndex();
     } else {
         return createIndex( row, 0, breakpoint );
     }
 }
 
 Breakpoint *BreakpointModel::breakpointFromLineNumber( const QString &fileName, int lineNumber ) const
 {
     if ( !m_breakpointsByFile.contains(fileName) ) {
         return 0;
     }
 
     const BreakpointData &data = m_breakpointsByFile[ fileName ];
     if ( data.breakpointsByLineNumber.contains(lineNumber) ) {
         return data.breakpointsByLineNumber[ lineNumber ];
     } else {
         return 0;
     }
 }
 
 Breakpoint *BreakpointModel::breakpointFromRow( int row ) const
 {
     for ( QHash<QString, BreakpointData>::ConstIterator it = m_breakpointsByFile.constBegin();
           it != m_breakpointsByFile.constEnd(); ++it )
     {
         if ( row < it->breakpoints.count() ) {
             return it->breakpoints[ row ];
         } else {
             row -= it->breakpoints.count();
         }
     }
     return 0;
 }
 
 Breakpoint *BreakpointModel::breakpointFromIndex( const QModelIndex &index ) const
 {
     return static_cast< Breakpoint* >( index.internalPointer() );
 }
 
 QList< uint > BreakpointModel::breakpointLineNumbers( const QString &fileName ) const
 {
     return m_breakpointsByFile[ fileName ].breakpointsByLineNumber.keys();
 }
 
 Breakpoint *BreakpointModel::setBreakpoint( const QString &fileName, int lineNumber, bool enable )
 {
     kDebug() << "setBreakpoint(" << QFileInfo(fileName).fileName() << ","
              << lineNumber << "," << enable << ")";
     if ( lineNumber < 0 ) {
         return 0;
     }
 
     // Find a valid breakpoint line number near lineNumber (may be lineNumber itself)
 //     lineNumber = getNextBreakableLineNumber( lineNumber );
 
     Breakpoint *breakpoint = 0;
     Breakpoint *foundBreakpoint = breakpointFromLineNumber( fileName, lineNumber );
     if ( foundBreakpoint && !enable ) {
         removeBreakpoint( foundBreakpoint );
     } else if ( !foundBreakpoint && enable ) {
         breakpoint = new Breakpoint( fileName, lineNumber, enable );
         addBreakpoint( breakpoint );
     }
 
     return breakpoint;
 }
 
 Breakpoint *BreakpointModel::toggleBreakpoint( const QString &fileName, int lineNumber )
 {
     kDebug() << "toggleBreakpoint(" << QFileInfo(fileName).fileName() << "," << lineNumber << ")";
     Breakpoint::State breakpoint = breakpointState( fileName, lineNumber );
     return setBreakpoint( fileName, lineNumber, breakpoint == Breakpoint::NoBreakpoint );
 }
 
 Breakpoint::State BreakpointModel::breakpointState( const QString &fileName, int lineNumber ) const
 {
     Breakpoint *foundBreakpoint = breakpointFromLineNumber( fileName, lineNumber );
     return !foundBreakpoint ? Breakpoint::NoBreakpoint
            : ( foundBreakpoint->isEnabled() ? Breakpoint::EnabledBreakpoint
                                             : Breakpoint::DisabledBreakpoint );
 }
 
 int BreakpointModel::rowCount( const QModelIndex &parent ) const
 {
     if ( parent.isValid() ) {
         return 0;
     } else {
         int count = 0;
         for ( QHash<QString, BreakpointData>::ConstIterator it = m_breakpointsByFile.constBegin();
             it != m_breakpointsByFile.constEnd(); ++it )
         {
             count += it->breakpoints.count();
         }
         return count;
     }
 }
 
 int BreakpointModel::columnCount( const QModelIndex &parent ) const
 {
     return parent.isValid() ? 0 : ColumnCount;
 }
 
 CheckboxDelegate::CheckboxDelegate( QAbstractItemView *itemView, QObject *parent )
         : KWidgetItemDelegate( itemView, parent )
 {
     QTreeView *treeView = qobject_cast< QTreeView* >( itemView );
     if ( treeView ) {
         connect( treeView->header(), SIGNAL(sectionResized(int,int,int)),
                  this, SLOT(updateGeometry()) );
         connect( treeView->header(), SIGNAL(sectionMoved(int,int,int)),
                  this, SLOT(updateGeometry()) );
     }
 }
 
 CheckboxDelegate::~CheckboxDelegate()
 {
 }
 
 void CheckboxDelegate::updateGeometry()
 {
     // Make KWidgetItemDelegate call updateItemWidgets() when a section was resized or moved
     // by making it process resize events (the size needs to really change,
     // sending a QResizeEvent with the same size does not work)
     const QSize size = itemView()->size();
     itemView()->resize( size.width() + 1, size.height() );
     itemView()->resize( size );
 }
 
 QList< QWidget * > CheckboxDelegate::createItemWidgets() const
 {
     QCheckBox *checkbox = new QCheckBox();
     setBlockedEventTypes( checkbox, QList<QEvent::Type>() << QEvent::MouseButtonPress
                             << QEvent::MouseButtonRelease << QEvent::MouseButtonDblClick );
     connect( checkbox, SIGNAL(toggled(bool)), this, SLOT(checkboxToggled(bool)) );
     return QList<QWidget*>() << checkbox;
 }
 
 void CheckboxDelegate::checkboxToggled( bool checked )
 {
     const QModelIndex index = focusedIndex();
     if ( index.isValid() ) {
         emit checkedStateChanged( index, checked );
     }
 }
 
 void CheckboxDelegate::updateItemWidgets( const QList< QWidget * > widgets,
                                           const QStyleOptionViewItem &option,
                                           const QPersistentModelIndex &index ) const
 {
     if ( widgets.isEmpty() ) {
         kDebug() << "No widgets";
         return;
     }
 
     QCheckBox *checkbox = qobject_cast< QCheckBox* >( widgets.first() );
     if ( itemView()->itemDelegate(index) != this ) {
         checkbox->hide();
         return;
     }
 
     const QVariant editData = index.data( Qt::EditRole );
     if ( !option.rect.isEmpty() && editData.isValid() && editData.canConvert(QVariant::Bool) ) {
         // Initialize checkbox
         checkbox->setChecked( editData.toBool() );
 
         // Align checkbox on the left and in the middle
         checkbox->move( (option.rect.width() - checkbox->width()) / 2,
                         (option.rect.height() - checkbox->height()) / 2 );
 
         // Resize checkbox to fit into option.rect and have maximally the size hint of the checkbox as size
         const QSize size = checkbox->sizeHint();
         checkbox->resize( qMin(size.width(), option.rect.width()),
                           qMin(size.height(), option.rect.height()) );
 
         checkbox->show();
     } else {
         checkbox->hide();
     }
 }
 
 QSize CheckboxDelegate::sizeHint( const QStyleOptionViewItem &option, const QModelIndex &index ) const
 {
     Q_UNUSED( index );
     return QApplication::style()->subElementRect( QStyle::SE_CheckBoxIndicator, &option ).size();
 }
 
 void CheckboxDelegate::paint( QPainter *painter, const QStyleOptionViewItem &option,
                               const QModelIndex &index ) const
 {
     QStyle* style = QApplication::style();
     const QVariant background = index.data( Qt::BackgroundRole );
     const QVariant foreground = index.data( Qt::ForegroundRole );
     QStyleOptionViewItemV4 opt( option );
     if ( background.isValid() ) {
         opt.backgroundBrush = background.value<QBrush>();
     }
     if ( foreground.isValid() ) {
         opt.palette.setColor( QPalette::Text, foreground.value<QBrush>().color() );
     }
     style->drawPrimitive( QStyle::PE_PanelItemViewItem, &opt, painter );
 }
diff --git a/engine/timetablemate/src/debugger/debugger.cpp b/engine/timetablemate/src/debugger/debugger.cpp
index 8c13dd9..64f0538 100644
--- a/engine/timetablemate/src/debugger/debugger.cpp
+++ b/engine/timetablemate/src/debugger/debugger.cpp
@@ -1,990 +1,990 @@
 /*
  *   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 "debugger.h"
 
 // Own includes
 #include "debuggerjobs.h"
 #include "variablemodel.h"
 #include "backtracemodel.h"
 #include "breakpointmodel.h"
 #include "timetabledatarequestjob.h"
 
 // PublicTransport engine includes
 #include <engine/serviceproviderdata.h>
 #include <engine/request.h>
 
 // KDE includes
 #include <KDebug>
 #include <KLocalizedString>
 #include <ThreadWeaver/Weaver>
 #include <ThreadWeaver/WeaverInterface>
 #include <ThreadWeaver/DependencyPolicy>
 #include <ThreadWeaver/ResourceRestrictionPolicy>
 #include <ThreadWeaver/Thread>
 #include <KGlobal>
 #include <KLocale>
 #include <threadweaver/DebuggingAids.h>
 
 // Qt includes
 #include <QScriptContextInfo>
 #include <QTimer>
 #include <QEventLoop>
 #include <QApplication>
 
 namespace Debugger {
 
 Debugger::Debugger( const WeaverInterfacePointer &weaver, QObject *parent )
         : QObject(parent), m_state(Initializing), m_weaver(weaver),
           m_mutex(new QMutex(QMutex::Recursive)),
           m_loadScriptJob(0), m_lastScriptError(InitializingScript),
           m_variableModel(new VariableModel(this)),
           m_backtraceModel(new BacktraceModel(this)),
           m_breakpointModel(new BreakpointModel(this)),
           m_debuggerRestrictionPolicy(0), m_evaluateInContextRestrictionPolicy(0),
           m_running(false), m_runData(0), m_timeout(0)
 {
     initialize();
 }
 
 Debugger::Debugger( QObject *parent )
         : QObject(parent), m_state(Initializing), m_weaver(new ThreadWeaver::Weaver()),//ThreadWeaver::Weaver::instance()),
           m_mutex(new QMutex(QMutex::Recursive)),
           m_loadScriptJob(0), m_lastScriptError(InitializingScript),
           m_variableModel(new VariableModel(this)),
           m_backtraceModel(new BacktraceModel(this)),
           m_breakpointModel(new BreakpointModel(this)),
           m_debuggerRestrictionPolicy(0), m_evaluateInContextRestrictionPolicy(0),
           m_running(false), m_runData(0), m_timeout(0)
 {
     initialize();
 }
 
 void Debugger::initialize()
 {
     QMutexLocker locker( m_mutex );
     qRegisterMetaType< QScriptContextInfo >( "QScriptContextInfo" );
     qRegisterMetaType< EvaluationResult >( "EvaluationResult" );
     qRegisterMetaType< Frame >( "Frame" );
     qRegisterMetaType< FrameStack >( "FrameStack" );
     qRegisterMetaType< Breakpoint >( "Breakpoint" );
     qRegisterMetaType< ConsoleCommand >( "ConsoleCommand" );
     qRegisterMetaType< DebuggerState >( "DebuggerState" );
     qRegisterMetaType< ScriptStoppedFlags >( "ScriptStoppedFlags" );
     qRegisterMetaType< NetworkRequest* >( "NetworkRequest*" );
     qRegisterMetaType< NetworkRequest::Ptr >( "NetworkRequest::Ptr" );
     qRegisterMetaType< QIODevice* >( "QIODevice*" );
     qRegisterMetaType< DataStreamPrototype* >( "DataStreamPrototype*" );
 
     connect( m_breakpointModel, SIGNAL(breakpointAdded(Breakpoint)),
              this, SIGNAL(breakpointAdded(Breakpoint)) );
     connect( m_breakpointModel, SIGNAL(breakpointAboutToBeRemoved(Breakpoint)),
              this, SIGNAL(breakpointAboutToBeRemoved(Breakpoint)) );
 }
 
 Debugger::~Debugger()
 {
     // Abort all running jobs, wait for them to finish and then delete them.
     // When there are undeleted jobs with queue policies assigned, deleting m_weaver would crash
     m_mutex->lock();
     if ( hasRunningJobs() ) {
         m_weaver->requestAbort();
         m_weaver->finish();
         qApp->processEvents();
     }
     foreach ( const QPointer<DebuggerJob> &job, m_runningJobs ) {
         if ( job ) {
             job->finish();
             if ( job ) {
                 QEventLoop loop;
                 connect( job, SIGNAL(destroyed(QObject*)), &loop, SLOT(quit()) );
                 loop.exec();
                 delete job.data();
             }
         }
     }
     m_runningJobs.clear();
 
     delete m_debuggerRestrictionPolicy;
     delete m_evaluateInContextRestrictionPolicy;
     delete m_runData;
     m_runData = 0;
     m_mutex->unlock();
 
     delete m_mutex;
 }
 
 void Debugger::finish()
 {
     QMutexLocker locker( m_mutex );
     if ( hasRunningJobs() ) {
         m_weaver->finish();
         qApp->processEvents();
     }
     while ( hasRunningJobs() ) {
         const QPointer< DebuggerJob > job = currentJob();
         Q_ASSERT( job );
         job->finish();
 
         if ( job && m_runningJobs.contains(job) ) {
             QEventLoop loop;
             connect( job, SIGNAL(destroyed(QObject*)), &loop, SLOT(quit()) );
             loop.exec();
 
             if ( m_runningJobs.contains(job) ) {
                 kDebug() << "Manually remove done job";
                 m_runningJobs.remove( m_runningJobs.indexOf(job) );
             }
         }
     }
     qApp->processEvents();
 }
 
 void Debugger::slotStarted( const QDateTime &timestamp )
 {
     stopTimeout();
     QMutexLocker locker( m_mutex );
     if ( !m_runData ) {
-        kWarning() << "ScriptRunData already deleted / not yet created";
+        qWarning() << "ScriptRunData already deleted / not yet created";
         return;
     }
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStarted(): Execution started/continued" );
 
     if ( m_runData->isWaitingForSignal() ) {
         // Was waiting for a signal, script execution continues
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStarted(): Woke up from signal" );
         const int waitingTime = m_runData->wokeUpFromSignal( timestamp );
         emit wokeUpFromSignal( waitingTime );
     } else if ( m_runData->isScriptLoaded() || !m_runData->isExecuting() ) {
         // The current job started executing the script
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStarted(): Start execution timer" );
         m_runData->executionStarted( timestamp );
     } else {
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStarted(): Is already executing and not waiting for a signal" );
     }
 }
 
 void Debugger::slotStopped( const QDateTime &timestamp, ScriptStoppedFlags flags,
                             int uncaughtExceptionLineNumber, const QString &uncaughtException )
 {
     Q_UNUSED( uncaughtExceptionLineNumber );
     Q_UNUSED( uncaughtException );
     QMutexLocker locker( m_mutex );
     if ( !m_runData ) {
-        kWarning() << "ScriptRunData already deleted";
+        qWarning() << "ScriptRunData already deleted";
         return;
     }
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStopped(): Execution stopped" );
     Q_ASSERT( m_runData );
     if ( flags.testFlag(ScriptWasAborted) ) {
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStopped(): "
                                    "Execution was aborted" );
         m_runData->executionStopped( timestamp );
     } else if ( flags.testFlag(ScriptHasRunningRequests) ) {
         // Script execution gets suspended, waiting for a signal
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStopped(): "
                                    "Script execution gets suspended, waiting for a signal" );
         startTimeout();
         m_runData->waitingForSignal( timestamp );
         emit waitingForSignal();
         return;
     } else {
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotStopped(): "
                                    "No running requests, job should get stopped now" );
         m_runData->executionStopped( timestamp );
     }
 
     Q_ASSERT( m_runData->job() );
     m_runData->job()->setJobDone();
 }
 
 void Debugger::slotAborted()
 {
     QMutexLocker locker( m_mutex );
     foreach ( const QPointer<DebuggerJob> &job, m_runningJobs ) {
         job->requestAbort();
     }
 
     stopTimeout();
     emit aborted();
 }
 
 void Debugger::slotInterrupted( int lineNumber, const QString &fileName,
                                 const QDateTime &timestamp )
 {
     QMutexLocker locker( m_mutex );
     if ( !m_runData ) {
-        kWarning() << "No ScriptRunData available";
+        qWarning() << "No ScriptRunData available";
         return;
     }
     m_runData->interrupted( timestamp );
 
     emit interrupted( lineNumber, fileName, timestamp );
 }
 
 void Debugger::slotContinued( const QDateTime &timestamp, bool willInterruptAfterNextStatement )
 {
     QMutexLocker locker( m_mutex );
     if ( !m_runData ) {
-        kWarning() << "No ScriptRunData available";
+        qWarning() << "No ScriptRunData available";
         return;
     }
     m_runData->continued( timestamp );
 
     emit continued( timestamp, willInterruptAfterNextStatement );
 }
 
 void Debugger::slotJobStarted( ThreadWeaver::Job *job )
 {
     DebuggerJob *debuggerJob = qobject_cast< DebuggerJob* >( job );
     Q_ASSERT( debuggerJob );
     m_mutex->lock();
     m_runningJobs.push( QPointer<DebuggerJob>(debuggerJob) );
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( debuggerJob, QString("Debugger::slotJobStarted(): Job started, now %1 jobs running")
                                             .arg(m_runningJobs.count()) );
     m_mutex->unlock();
     ExecuteConsoleCommandJob *consoleCommandJob = qobject_cast< ExecuteConsoleCommandJob* >( job );
     EvaluateInContextJob *evaluateInContextJob = qobject_cast< EvaluateInContextJob* >( job );
     emit jobStarted( debuggerJob->type(), debuggerJob->useCase(), debuggerJob->objectName() );
 
     stopTimeout();
     if ( !evaluateInContextJob && !consoleCommandJob ) {
         // Script execution gets started
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( debuggerJob, "Debugger::slotJobStarted(): Start script execution, was not running" );
 
         m_mutex->lock();
         m_running = true;
         m_runData = new ScriptRunData( debuggerJob );
         m_mutex->unlock();
 
         emit started();
     }
 }
 
 void Debugger::slotJobDone( ThreadWeaver::Job *job )
 {
     DebuggerJob *debuggerJob = qobject_cast< DebuggerJob* >( job );
     Q_ASSERT( debuggerJob );
     if ( !hasRunningJobs() ) {
-        kWarning() << "Job done signal received, but no running jobs, exiting?";
+        qWarning() << "Job done signal received, but no running jobs, exiting?";
         job->deleteLater();
         return;
     }
 
     m_mutex->lock();
     if ( debuggerJob != m_runningJobs.top() ) {
-        kWarning() << "Unknown job done" << debuggerJob;
+        qWarning() << "Unknown job done" << debuggerJob;
         kDebug() << "Current job is" << m_runningJobs.top();
         m_mutex->unlock();
         return;
     }
     m_runningJobs.pop();
 
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( debuggerJob, QString("Debugger::slotJobDone(): Job done, now %1 running")
                                             .arg(m_runningJobs.count()) );
     ExecuteConsoleCommandJob *consoleCommandJob = qobject_cast< ExecuteConsoleCommandJob* >( job );
     EvaluateInContextJob *evaluateInContextJob = qobject_cast< EvaluateInContextJob* >( job );
 
     if ( job == m_loadScriptJob ) {
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_loadScriptJob, "LoadScriptJob is done" );
         m_loadScriptJob = 0;
     }
     m_mutex->unlock();
     stopTimeout();
 
     switch ( debuggerJob->type() ) {
     case LoadScript:
         loadScriptJobDone( debuggerJob );
         break;
     case TimetableDataRequest:
         timetableDataRequestJobDone( debuggerJob );
         break;
     case ExecuteConsoleCommand:
         executeConsoleCommandJobDone( debuggerJob );
         break;
     case EvaluateInContext:
         evaluateInContextJobDone( debuggerJob );
         break;
     case CallScriptFunction:
         callScriptFunctionJobDone( debuggerJob );
         break;
     case TestFeatures:
         testFeaturesJobDone( debuggerJob );
         break;
     default:
-        kWarning() << "Unknown job type" << debuggerJob->type();
+        qWarning() << "Unknown job type" << debuggerJob->type();
         break;
     }
 
     DebuggerJobResult result( debuggerJob->success(), debuggerJob->wasAborted(),
                               debuggerJob->returnValue(), debuggerJob->explanation() );
     CallScriptFunctionJob *callFunctionJob = qobject_cast< CallScriptFunctionJob* >( job );
     TimetableDataRequestJob *requestJob = qobject_cast< TimetableDataRequestJob* >( job );
     if ( callFunctionJob ) {
         result.messages = callFunctionJob->additionalMessages();
 
         if ( requestJob ) {
             result.request = requestJob->request();
             result.resultData = requestJob->timetableData();
         } else {
             TestFeaturesJob *featuresJob = qobject_cast< TestFeaturesJob* >( job );
             if ( featuresJob ) {
                 TimetableData featuresData;
                 QVariantList features;
                 foreach ( Enums::ProviderFeature feature, featuresJob->features() ) {
                     features << feature;
                 }
 
                 // Insert as "Nothing", it's no TimetableInformation normally used by the engine
                 featuresData.insert( Enums::Nothing, features );
                 result.resultData << featuresData;
             }
         }
     }
 
     // To not crash with queued connections, no pointer to the job gets emitted here,
     // as it may already be deleted when the signal gets received, copy all data
     emit jobDone( debuggerJob->type(), debuggerJob->useCase(), debuggerJob->objectName(), result );
 
     if ( !evaluateInContextJob && !consoleCommandJob ) {
         // Script execution has finished
         stopTimeout();
 
         m_mutex->lock();
         m_running = false;
         if ( !m_runData ) {
-            kWarning() << "ScriptRunData already deleted";
+            qWarning() << "ScriptRunData already deleted";
             m_mutex->unlock();
 
             emit stopped( ScriptRunData() );
         } else {
             if ( m_runData->isExecuting() ) {
                 DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_runData->job(), "Debugger::slotJobDone(): Stopped() "
                                            "signal not correctly received for job" );
                 m_runData->executionStopped( QDateTime::currentDateTime() );
             }
             const ScriptRunData runData = *m_runData;
             delete m_runData;
             m_runData = 0;
             m_mutex->unlock();
 
             emit stopped( runData );
         }
     }
 
     job->deleteLater();
 }
 
 void Debugger::startTimeout( int milliseconds )
 {
     QMutexLocker locker( m_mutex );
     if ( !m_timeout ) {
         m_timeout = new QTimer( this );
         connect( m_timeout, SIGNAL(timeout()), this, SLOT(timeout()) );
     }
     m_timeout->start( milliseconds );
 }
 
 void Debugger::stopTimeout()
 {
     QMutexLocker locker( m_mutex );
     if ( m_timeout ) {
         m_timeout->deleteLater();
         m_timeout = 0;
     }
 }
 
 void Debugger::timeout()
 {
     QMutexLocker locker( m_mutex );
     if ( m_timeout ) {
         kDebug() << "Timeout, execution took longer than" << m_timeout->interval() << "ms";
         emit errorMessage( i18nc("@info/plain", "Execution timed out after %1",
                                  KGlobal::locale()->prettyFormatDuration(m_timeout->interval())) );
         m_timeout->deleteLater();
         m_timeout = 0;
     } else {
         kDebug() << "Timeout, execution took too long";
         emit errorMessage( i18nc("@info/plain", "Execution timed out") );
     }
 
     abortDebugger();
 }
 
 void Debugger::removeAllBreakpoints()
 {
     QMutexLocker locker( m_mutex );
     m_breakpointModel->clear();
 }
 
 void Debugger::executeCommand( const ConsoleCommand &command )
 {
     if ( command.command() == ConsoleCommand::ClearCommand ) {
-        kWarning() << "The clear command is not implemented in Debugger/DebuggerAgent, "
+        qWarning() << "The clear command is not implemented in Debugger/DebuggerAgent, "
                       "should be implemented in the console to clear it's history";
     } else {
         enqueueJob( createExecuteConsoleCommandJob(command) );
     }
 }
 
 void Debugger::evaluateInContext( const QString &program, const QString &contextName )
 {
     enqueueJob( createEvaluateInContextJob(program, contextName) );
 }
 
 LoadScriptJob *Debugger::createLoadScriptJob( DebugFlags debugFlags )
 {
     QMutexLocker locker( m_mutex );
     return new LoadScriptJob( m_data, QString(), debugFlags, this );
 }
 
 bool Debugger::isLoadScriptJobRunning() const
 {
     QMutexLocker locker( m_mutex );
     return m_loadScriptJob && !m_loadScriptJob->isFinished();
 }
 
 LoadScriptJob *Debugger::getLoadScriptJob( const QString &program, const ServiceProviderData *data,
                                            DebugFlags debugFlags )
 {
     QMutexLocker locker( m_mutex );
     if ( isLoadScriptJobRunning() ) {
         // Script already gets loaded, return the running job
         return m_loadScriptJob;
     }
 
     if ( m_lastScriptError == NoScriptError &&
          m_data.program && m_data.program->sourceCode() == program &&
          (!m_data.provider.isValid() || m_data.provider == *data) )
     {
         // Script code and provider data unchanged
         return 0;
     }
 
     // The script was modified or not loaded before
     m_state = ScriptModified;
     m_data = ScriptData( data, QSharedPointer< QScriptProgram >(
                 new QScriptProgram(program, data->scriptFileName())) );
     m_lastScriptError = InitializingScript;
     return createLoadScriptJob( debugFlags );
 }
 
 LoadScriptJob *Debugger::loadScript( const QString &program, const ServiceProviderData *data,
                                      DebugFlags debugFlags )
 {
     if ( m_loadScriptJob ) {
         // Script already gets loaded, return the running job
         QMutexLocker locker( m_mutex );
         return m_loadScriptJob;
     }
 
     LoadScriptJob *loadScriptJob = getLoadScriptJob( program, data, debugFlags );
     if ( !loadScriptJob ) {
         return 0;
     }
 
     enqueueJob( loadScriptJob );
     return loadScriptJob;
 }
 
 TimetableDataRequestJob *Debugger::createTimetableDataRequestJob(
         const AbstractRequest *request, const QString &useCase, DebugFlags debugFlags )
 {
     QMutexLocker locker( m_mutex );
     return new TimetableDataRequestJob( m_data, request, useCase, debugFlags, this );
 }
 
 ExecuteConsoleCommandJob *Debugger::createExecuteConsoleCommandJob( const ConsoleCommand &command,
                                                                     const QString &useCase )
 {
     QMutexLocker locker( m_mutex );
     return new ExecuteConsoleCommandJob( m_data, command, useCase,
                                          hasRunningJobs() ? currentJob() : 0, this );
 }
 
 EvaluateInContextJob *Debugger::createEvaluateInContextJob( const QString &program,
                                                             const QString &context,
                                                             const QString &useCase )
 {
     QMutexLocker locker( m_mutex );
     return new EvaluateInContextJob( m_data, program, context, useCase,
                                      hasRunningJobs() ? currentJob() : 0, this );
 }
 
 CallScriptFunctionJob *Debugger::createCallScriptFunctionJob( const QString &functionName,
         const QVariantList &arguments, const QString &useCase, DebugFlags debugFlags )
 {
     QMutexLocker locker( m_mutex );
     return new CallScriptFunctionJob( m_data, functionName, arguments, useCase, debugFlags, this );
 }
 
 TestFeaturesJob *Debugger::createTestFeaturesJob( const QString &useCase, DebugFlags debugFlags )
 {
     QMutexLocker locker( m_mutex );
     return new TestFeaturesJob( m_data, useCase, debugFlags, this );
 }
 
 bool Debugger::canEvaluate( const QString &program ) const
 {
     if ( !hasRunningJobs() ) {
-        kWarning() << "Not running";
+        qWarning() << "Not running";
         return false;
     }
 
     return currentJob()->canEvaluate( program );
 }
 
 bool Debugger::requestTimetableData( const AbstractRequest *request, const QString &useCase,
                                      DebugFlags debugFlags )
 {
     QMutexLocker locker( m_mutex );
     if ( m_lastScriptError != NoScriptError && m_lastScriptError != InitializingScript ) {
-        kWarning() << "Script could not be loaded correctly";
+        qWarning() << "Script could not be loaded correctly";
         emit requestTimetableDataResult( QSharedPointer< AbstractRequest >(request->clone()),
                 false, i18nc("@info", "Script could not be loaded correctly") );
         return false;
     }
 
     TimetableDataRequestJob *runScriptJob =
             createTimetableDataRequestJob( request, useCase, debugFlags );
     enqueueJob( runScriptJob );
     return true;
 }
 
 void Debugger::connectJob( DebuggerJob *debuggerJob )
 {
     connect( debuggerJob, SIGNAL(started(ThreadWeaver::Job*)),
              this, SLOT(slotJobStarted(ThreadWeaver::Job*)) );
     connect( debuggerJob, SIGNAL(done(ThreadWeaver::Job*)),
              this, SLOT(slotJobDone(ThreadWeaver::Job*)) );
 
     switch ( debuggerJob->type() ) {
     case TimetableDataRequest:
     case CallScriptFunction:
     case TestFeatures:
         connect( qobject_cast<CallScriptFunctionJob*>(debuggerJob), SIGNAL(asynchronousRequestWaitFinished(QDateTime,int,int)),
                  this, SLOT(asynchronousRequestWaitFinished(QDateTime,int,int)) );
         connect( qobject_cast<CallScriptFunctionJob*>(debuggerJob), SIGNAL(synchronousRequestWaitFinished(int,int,int)),
                  this, SLOT(synchronousRequestWaitFinished(int,int,int)) );
         break;
     default:
         break;
     }
 
     // Connect signals of the job, the job lives in the same thread as this debugger
     // (the GUI thread), the connections are direct. The job itself emits these signals after
     // receiving the associated signals of the used DebuggerAgent instance using queued connections.
     connect( debuggerJob, SIGNAL(positionChanged(int,int,int,int)),
              this, SIGNAL(positionChanged(int,int,int,int)) );
     connect( debuggerJob, SIGNAL(stateChanged(DebuggerState,DebuggerState)),
              this, SIGNAL(stateChanged(DebuggerState,DebuggerState)) );
     connect( debuggerJob, SIGNAL(aborted()), this, SLOT(slotAborted()) );
     connect( debuggerJob, SIGNAL(interrupted(int,QString,QDateTime)),
              this, SLOT(slotInterrupted(int,QString,QDateTime)) );
     connect( debuggerJob, SIGNAL(continued(QDateTime,bool)), this, SLOT(slotContinued(QDateTime,bool)) );
     connect( debuggerJob, SIGNAL(started(QDateTime)), this, SLOT(slotStarted(QDateTime)) );
     connect( debuggerJob, SIGNAL(stopped(QDateTime,ScriptStoppedFlags,int,QString)),
              this, SLOT(slotStopped(QDateTime,ScriptStoppedFlags,int,QString)) );
     connect( debuggerJob, SIGNAL(exception(int,QString,QString)),
              this, SIGNAL(exception(int,QString,QString)) );
     connect( debuggerJob, SIGNAL(output(QString,QScriptContextInfo)),
              this, SIGNAL(output(QString,QScriptContextInfo)) );
     connect( debuggerJob, SIGNAL(informationMessage(QString)),
              this, SIGNAL(informationMessage(QString)) );
     connect( debuggerJob, SIGNAL(errorMessage(QString)),
              this, SIGNAL(errorMessage(QString)) );
     connect( debuggerJob, SIGNAL(breakpointReached(Breakpoint)),
              this, SIGNAL(breakpointReached(Breakpoint)) );
     connect( debuggerJob, SIGNAL(scriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)),
              this, SIGNAL(scriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)) );
 
     debuggerJob->attachDebugger( this );
 }
 
 bool Debugger::enqueueJob( DebuggerJob *debuggerJob )
 {
     QMutexLocker locker( m_mutex );
     if ( m_loadScriptJob == debuggerJob ) {
         kDebug() << "Gets loaded, wait...";
         return true;
     }
 
     connectJob( debuggerJob );
 
     // Mark job as not done, wait until the stopped() signal of the job was processed
     // in slotStopped() before marking it as done, allowing it to destroy the agent/engine then
     debuggerJob->setJobDone( false );
 
     // Check job type to decide how to enqueue the new job
     switch ( debuggerJob->type() ) {
     case LoadScript:
         // Allow only one LoadScriptJob in all Debugger instances at a time
         static ThreadWeaver::ResourceRestrictionPolicy *loadScriptRestrictionPolicy =
                 new ThreadWeaver::ResourceRestrictionPolicy(1);
         debuggerJob->assignQueuePolicy( loadScriptRestrictionPolicy );
 
         // A new version of the script can only be loaded into the engine, when no other job
         // currently accesses the engine (with an old version of the script loaded).
         assignDebuggerQueuePolicy( debuggerJob );
 
         if ( m_loadScriptJob ) {
             // A LoadScriptJob exists already, maybe still running, most probably another
             // LoadScriptJob gets enqueued because the provider has changed.
             // Add the running LoadScriptJob as dependency for the new one.
             ThreadWeaver::DependencyPolicy::instance().addDependency( debuggerJob, m_loadScriptJob );
             m_loadScriptJob->assignQueuePolicy( &ThreadWeaver::DependencyPolicy::instance() );
             debuggerJob->assignQueuePolicy( &ThreadWeaver::DependencyPolicy::instance() );
         }
         m_loadScriptJob = qobject_cast< LoadScriptJob* >( debuggerJob );
         Q_ASSERT( m_loadScriptJob );
         m_weaver->enqueue( debuggerJob );
         break;
     case ExecuteConsoleCommand: {
         // Console commands need different queue policies
         ExecuteConsoleCommandJob *consoleJob =
                 qobject_cast< ExecuteConsoleCommandJob* >( debuggerJob );
         if ( consoleJob->command().commandExecutesScriptCode() ) {
             // Console command executes script code, assign evaluate in context restriction policy,
             // ie. allow only one job at a time to run script code in the script context
             // of another job
             assignEvaluateInContextQueuePolicy( debuggerJob );
             runAfterScriptIsLoaded( debuggerJob );
         } else if ( consoleJob->command().command() == ConsoleCommand::BreakpointCommand ) {
             // First load the script in the debugger because it needs to have the code available
             // to check if execution can be interrupted at a given line number
             runAfterScriptIsLoaded( debuggerJob );
         } else {
             // Console command does not execute script code, no queue policies needed
             m_weaver->enqueue( debuggerJob );
         }
     } break;
     case EvaluateInContext:
         // Evaluate in context means that script code gets executed in the script context of
         // another job. Use restriction policy to only allow one job at a time to evaluate
         // injected code. Do not wait for the script to be loaded, it is already loaded in the
         // running job or gets loaded automatically by the EvaluateInContextJob.
         assignEvaluateInContextQueuePolicy( debuggerJob );
         m_weaver->enqueue( debuggerJob );
         break;
     case TimetableDataRequest:
     case CallScriptFunction:
     case TestFeatures:
     default:
         // Other jobs that access the engine and need the script to be loaded
         assignDebuggerQueuePolicy( debuggerJob );
         runAfterScriptIsLoaded( debuggerJob );
         break;
     }
     return true;
 }
 
 void Debugger::assignDebuggerQueuePolicy( DebuggerJob *job )
 {
     // Assign a resource restriction policy,
     // that ensures that only one job at a time uses the debugger
     QMutexLocker locker( m_mutex );
     if ( !m_debuggerRestrictionPolicy ) {
         m_debuggerRestrictionPolicy = new ThreadWeaver::ResourceRestrictionPolicy( 1 );
     }
     job->assignQueuePolicy( m_debuggerRestrictionPolicy );
 }
 
 void Debugger::assignEvaluateInContextQueuePolicy( DebuggerJob *job )
 {
     QMutexLocker locker( m_mutex );
     if ( !m_evaluateInContextRestrictionPolicy ) {
         m_evaluateInContextRestrictionPolicy = new ThreadWeaver::ResourceRestrictionPolicy( 1 );
     }
     job->assignQueuePolicy( m_evaluateInContextRestrictionPolicy );
 }
 
 void Debugger::runAfterScriptIsLoaded( ThreadWeaver::Job *dependendJob )
 {
     QMutexLocker locker( m_mutex );
     if ( m_state != ScriptLoaded ) {
         // If the script is not loaded (still in initializing mode, error or modified)
         // create a job to load it and make the run script job dependend
         if ( !isLoadScriptJobRunning() ) {
             TimetableDataRequestJob *job = qobject_cast< TimetableDataRequestJob* >( dependendJob );
             enqueueJob( createLoadScriptJob(job ? job->debugFlags() : NeverInterrupt) );
         }
 
         // Add the LoadScriptJob as dependency
         ThreadWeaver::DependencyPolicy::instance().addDependency( dependendJob, m_loadScriptJob );
         m_loadScriptJob->assignQueuePolicy( &ThreadWeaver::DependencyPolicy::instance() );
         dependendJob->assignQueuePolicy( &ThreadWeaver::DependencyPolicy::instance() );
     }
 
     m_weaver->enqueue( dependendJob );
 }
 
 void Debugger::loadScriptJobDone( ThreadWeaver::Job *job )
 {
     LoadScriptJob *loadScriptJob = qobject_cast< LoadScriptJob* >( job );
     Q_ASSERT( loadScriptJob );
     QMutexLocker locker( m_mutex );
     if ( loadScriptJob->success() ) {
 
         m_state = ScriptLoaded;
         m_lastScriptError = NoScriptError;
         m_lastScriptErrorString.clear();
     } else {
         m_state = ScriptError;
         m_lastScriptError = ScriptLoadFailed;
         m_lastScriptErrorString = loadScriptJob->explanation();
     }
 
     const QStringList globalFunctions = loadScriptJob->globalFunctions();
     const QStringList includedFiles = loadScriptJob->includedFiles();
     ThreadWeaver::DependencyPolicy::instance().free( loadScriptJob );
 
     emit loadScriptResult( m_lastScriptError, m_lastScriptErrorString,
                            globalFunctions, includedFiles );
 }
 
 void Debugger::timetableDataRequestJobDone( ThreadWeaver::Job *job )
 {
     // To not crash with queued connections, no pointer to the job gets emitted here
     TimetableDataRequestJob *runScriptJob = qobject_cast< TimetableDataRequestJob* >( job );
     Q_ASSERT( runScriptJob );
     emit requestTimetableDataResult( runScriptJob->request(), runScriptJob->success(),
                                      runScriptJob->explanation(), runScriptJob->timetableData(),
                                      runScriptJob->returnValue() );
 }
 
 void Debugger::executeConsoleCommandJobDone( ThreadWeaver::Job *job )
 {
     // To not crash with queued connections, no pointer to the job gets emitted here
     ExecuteConsoleCommandJob *consoleCommandJob = qobject_cast< ExecuteConsoleCommandJob* >( job );
     Q_ASSERT( consoleCommandJob );
     emit commandExecutionResult( consoleCommandJob->returnValue().toString(),
                                  !consoleCommandJob->success() );
 }
 
 void Debugger::evaluateInContextJobDone( ThreadWeaver::Job *job )
 {
     // To not crash with queued connections, no pointer to the job gets emitted here
     EvaluateInContextJob *evaluateInContextJob = qobject_cast< EvaluateInContextJob* >( job );
     Q_ASSERT( evaluateInContextJob );
     emit evaluationResult( evaluateInContextJob->result() );
 }
 
 void Debugger::callScriptFunctionJobDone( ThreadWeaver::Job *job )
 {
     // To not crash with queued connections, no pointer to the job gets emitted here
     CallScriptFunctionJob *callFunctionJob = qobject_cast< CallScriptFunctionJob* >( job );
     Q_ASSERT( callFunctionJob );
     emit callScriptFunctionResult( callFunctionJob->functionName(), callFunctionJob->returnValue() );
 }
 
 void Debugger::testFeaturesJobDone( ThreadWeaver::Job *job )
 {
     // To not crash with queued connections, no pointer to the job gets emitted here
     TestFeaturesJob *testJob = qobject_cast< TestFeaturesJob* >( job );
     Q_ASSERT( testJob );
     emit testFeaturesResult( testJob->features() );
 }
 
 void Debugger::asynchronousRequestWaitFinished( const QDateTime &timestamp,
                                                 int statusCode, int size )
 {
     Q_UNUSED( statusCode )
     QMutexLocker locker( m_mutex );
     if ( m_runData ) {
         m_runData->asynchronousDownloadFinished( timestamp, size );
     } else {
-        kWarning() << "ScriptRunData object already deleted";
+        qWarning() << "ScriptRunData object already deleted";
     }
 }
 
 void Debugger::synchronousRequestWaitFinished( int statusCode, int waitingTime, int size )
 {
     Q_UNUSED( statusCode )
     if ( m_runData ) {
         m_runData->synchronousDownloadFinished( waitingTime, size );
     } else {
-        kWarning() << "ScriptRunData object already deleted";
+        qWarning() << "ScriptRunData object already deleted";
     }
 }
 
 void ScriptRunData::executionStopped( const QDateTime &timestamp )
 {
     if ( m_state != Running && m_state != LoadingScript ) {
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "ERROR: Is not executing!" );
         return;
     } else if ( m_job->type() != LoadScript && !isScriptLoaded() ) {
         m_state = ScriptLoaded;
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: Script Loaded" );
     } else {
         if ( m_state == WaitingForSignal ) {
             DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "Error: Was still waiting for a signal" );
         }
         m_state = Finished;
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: Finished" );
     }
     m_executionTime += m_executionStartTimestamp.msecsTo( timestamp );
     m_executionStartTimestamp = QDateTime();
 }
 
 void ScriptRunData::executionStarted( const QDateTime &timestamp )
 {
     /*if ( m_state == Finished ) { // m_executionTime != 0 ) {
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "ERROR: Execution was already stopped" );
         return;
     } else*/ if ( m_state == Running || m_state == LoadingScript ) {
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "ERROR: Is already executing!" );
         kDebug() << "Error state:" << m_state;
         return;
     }
     if ( m_job->type() != LoadScript && !isScriptLoaded() ) {
         m_state = LoadingScript;
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: LoadingScript" );
     } else {
         m_state = Running;
         DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: Running" );
     }
     m_executionStartTimestamp = timestamp;
 }
 
 ScriptRunData::ScriptRunData( DebuggerJob *job )
         : m_job(job), m_executionTime(0), m_signalWaitingTime(0), m_interruptTime(0),
           m_synchronousDownloadTime(0), m_asynchronousDownloadSize(0),
           m_synchronousDownloadSize(0), m_state(Initializing)
 {
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: Initializing" );
 }
 
 void ScriptRunData::waitingForSignal( const QDateTime &timestamp )
 {
     switch( m_state ) {
     case WaitingForSignal:
         qWarning() << "ERROR: Is already waiting for a signal!";
         return;
     case Finished:
         qWarning() << "ERROR: Is already finished!";
         return;
     case Initializing:
         qWarning() << "ERROR: Was not started!";
         return;
     default:
         break;
     }
     m_state = WaitingForSignal;
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: WaitingForSignal" );
     m_waitForSignalTimestamp = timestamp;
 }
 
 int ScriptRunData::wokeUpFromSignal( const QDateTime &timestamp )
 {
     if( m_state != WaitingForSignal ) {
         qWarning() << "ERROR: Is not waiting for a signal!";
         return 0;
     }
     m_state = Running;
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: Running" );
     const int waitingTime = m_waitForSignalTimestamp.msecsTo( timestamp );
     m_waitForSignalTimestamp = QDateTime();
     m_signalWaitingTime += waitingTime;
     return waitingTime;
 }
 
 void ScriptRunData::interrupted( const QDateTime &timestamp )
 {
     Q_ASSERT( m_state == Running || m_state == LoadingScript );
     m_state = Interrupted;
     m_interruptTimestamp = timestamp;
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: Interrupted" );
 }
 
 void ScriptRunData::continued( const QDateTime &timestamp )
 {
     Q_ASSERT( m_state == Interrupted );
     m_state = Running;
     m_interruptTime += m_interruptTimestamp.msecsTo( timestamp );
     m_interruptTimestamp = QDateTime();
     DEBUGGER_JOB_SYNCHRONIZATION_JOB( m_job, "New state: Running" );
 }
 
 bool Debugger::hasRunningJobs() const
 {
     QMutexLocker locker( m_mutex );
     return !m_runningJobs.isEmpty();
 }
 
 QStack< QPointer< DebuggerJob > > Debugger::runningJobs() const
 {
     QMutexLocker locker( m_mutex );
     return m_runningJobs;
 }
 
 Debugger::ScriptState Debugger::scriptState() const
 {
     QMutexLocker locker( m_mutex );
     return m_state;
 }
 
 ScriptErrorType Debugger::lastScriptError() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastScriptError;
 }
 
 QString Debugger::lastScriptErrorString() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastScriptErrorString;
 }
 
 VariableModel *Debugger::variableModel() const
 {
     QMutexLocker locker( m_mutex );
     return m_variableModel;
 }
 
 BacktraceModel *Debugger::backtraceModel() const
 {
     QMutexLocker locker( m_mutex );
     return m_backtraceModel;
 }
 
 BreakpointModel *Debugger::breakpointModel() const
 {
     QMutexLocker locker( m_mutex );
     return m_breakpointModel;
 }
 
 WeaverInterfacePointer Debugger::weaver() const
 {
     QMutexLocker locker( m_mutex );
     return m_weaver;
 }
 
 const QPointer< DebuggerJob > Debugger::currentJob() const
 {
     QMutexLocker locker( m_mutex );
     QPointer<DebuggerJob> job = m_runningJobs.top();
     if ( ( job->type() == EvaluateInContext || job->type() == ExecuteConsoleCommand ) &&
             m_runningJobs.count() > 1 ) {
         job = m_runningJobs[ m_runningJobs.count() - 2 ];
     }
     return job;
 }
 
 } // namespace Debugger
diff --git a/engine/timetablemate/src/debugger/debuggeragent.cpp b/engine/timetablemate/src/debugger/debuggeragent.cpp
index 5862e05..1d24d0a 100644
--- a/engine/timetablemate/src/debugger/debuggeragent.cpp
+++ b/engine/timetablemate/src/debugger/debuggeragent.cpp
@@ -1,1685 +1,1685 @@
 /*
  *   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 "debuggeragent.h"
 
 // Own includes
 #include "backtracemodel.h"
 #include "breakpointmodel.h"
 #include "variablemodel.h"
 
 // PublicTransport engine includes
 #include <engine/script/scriptapi.h>
 
 // KDE includes
 #include <KDebug>
 #include <KLocalizedString>
 
 // Qt includes
 #include <QScriptEngine>
 #include <QScriptContextInfo>
 #include <QScriptValueIterator>
 #include <QTimer>
 #include <QMutex>
 #include <QSemaphore>
 #include <QWaitCondition>
 #include <QEventLoop>
 #include <QFileInfo> // Only used for debugging
 
 namespace Debugger {
 
 // In milliseconds
 const int DebuggerAgent::CHECK_RUNNING_INTERVAL = 1000;
 const int DebuggerAgent::CHECK_RUNNING_WHILE_INTERRUPTED_INTERVAL = 5000;
 
 QScriptValue debugPrintFunction( QScriptContext *context, QScriptEngine *engine )
 {
     QString result;
     for ( int i = 0; i < context->argumentCount(); ++i ) {
         if ( i > 0 ) {
             result.append(" ");
         }
         result.append( context->argument(i).toString() );
     }
 
     QScriptValue calleeData = context->callee().data();
     DebuggerAgent *debugger = qobject_cast<DebuggerAgent*>( calleeData.toQObject() );
     debugger->slotOutput( result, QScriptContextInfo(context->parentContext()) );
     return engine->undefinedValue();
 }
 
 DebuggerAgent::DebuggerAgent( QScriptEngine *engine, QSemaphore *engineSemaphore, bool mutexIsLocked )
         : QObject(engine), QScriptEngineAgent(engine),
           m_mutex(new QMutex(QMutex::Recursive)), m_interruptWaiter(new QWaitCondition()),
           m_interruptMutex(new QMutex()), m_engineSemaphore(engineSemaphore),
           m_checkRunningTimer(new QTimer(this)), m_lastRunAborted(false), m_runUntilLineNumber(-1),
           m_debugFlags(DefaultDebugFlags), m_currentContext(0), m_interruptContext(0)
 {
     qRegisterMetaType< VariableChange >( "VariableChange" );
     qRegisterMetaType< BacktraceChange >( "BacktraceChange" );
     qRegisterMetaType< BreakpointChange >( "BreakpointChange" );
     qRegisterMetaType< Breakpoint >( "Breakpoint" );
 
     m_mutex->lockInline();
     m_lineNumber = -1;
     m_columnNumber = -1;
     m_currentScriptId = -1;
     m_state = NotRunning;
     m_injectedScriptState = InjectedScriptNotRunning;
     m_injectedScriptId = -1;
     m_executionControl = ExecuteRun;
     m_previousExecutionControl = ExecuteRun;
     m_hasUncaughtException = false;
     m_uncaughtExceptionLineNumber = -1;
     m_interruptFunctionLevel = -2;
     m_functionDepth = 0;
     m_mutex->unlockInline();
 
     // Install custom print function (overwriting the builtin print function)
     if ( !mutexIsLocked ) {
         m_engineSemaphore->acquire();
     }
     QScriptValue printFunction = engine->newFunction( debugPrintFunction );
     printFunction.setData( engine->newQObject(this) );
     QScriptValue::PropertyFlags flags = QScriptValue::ReadOnly | QScriptValue::Undeletable;
     engine->globalObject().setProperty( "print", printFunction, flags );
     if ( !mutexIsLocked ) {
         m_engineSemaphore->release();
     }
 }
 
 DebuggerAgent::~DebuggerAgent()
 {
     abortDebugger();
 
     delete m_mutex;
     delete m_interruptMutex;
     delete m_interruptWaiter;
 }
 
 bool DebuggerAgent::isInterrupted() const
 {
     QMutexLocker locker( m_mutex );
     if ( m_state == Interrupted ) {
         return true;
     }
 
     const bool canLock = m_interruptMutex->tryLock();
     if ( canLock ) {
         m_interruptMutex->unlockInline();
     }
     return !canLock;
 }
 
 bool DebuggerAgent::isRunning() const
 {
     QMutexLocker locker( m_mutex );
     return m_state == Running;
 }
 
 bool DebuggerAgent::isAborting() const
 {
     QMutexLocker locker( m_mutex );
     return m_state == Aborting;
 }
 
 bool DebuggerAgent::wasLastRunAborted() const
 {
     QMutexLocker locker( m_mutex );
     return m_lastRunAborted;
 }
 
 bool DebuggerAgent::isInjectedScriptEvaluating() const
 {
     QMutexLocker locker( m_mutex );
     return m_injectedScriptState != InjectedScriptNotRunning &&
            m_injectedScriptState != InjectedScriptAborting;
 }
 
 void DebuggerAgent::finish() const
 {
     m_mutex->lockInline();
     if ( m_state != NotRunning ) {
         DEBUGGER_EVENT("Wait until script execution finishes...");
         QEventLoop loop;
         connect( this, SIGNAL(stopped(QDateTime,bool,bool,int,QString,QStringList)),
                  &loop, SLOT(quit()) );
         m_mutex->unlockInline();
 
         loop.exec();
         DEBUGGER_EVENT("...Script execution has finished");
     } else {
         m_mutex->unlockInline();
     }
 }
 
 NextEvaluatableLineHint DebuggerAgent::canBreakAt( int lineNumber, const QStringList &programLines )
 {
     kDebug() << "canBreakAt(" << lineNumber << "), code lines:" << programLines.count();
     const int scriptLineCount = programLines.count();
     if ( lineNumber < 1 || lineNumber > scriptLineCount ) {
         return CannotFindNextEvaluatableLine;
     }
 
     QString line = programLines[ lineNumber - 1 ].trimmed();
     if ( line.isEmpty() || line.startsWith("//") ) {
         return NextEvaluatableLineBelow;
     } else if ( line.startsWith("/**") ) {
         return NextEvaluatableLineAbove;
     }
 
     // Test if the line can be evaluated
     // If not, try if appending more lines makes the text evaluatable (multiline statement)
     for ( int lines = 1; lines < 20 && lineNumber + lines <= scriptLineCount; ++lines ) {
         QScriptSyntaxCheckResult result = QScriptEngine::checkSyntax( line );
         if ( result.state() == QScriptSyntaxCheckResult::Valid ) {
             return FoundEvaluatableLine;
         }
         line.append( '\n' + programLines[lineNumber - 1 + lines] );
     }
 
     return NextEvaluatableLineAbove;
 }
 
 int DebuggerAgent::getNextBreakableLineNumber( int lineNumber, const QStringList &programLines )
 {
     kDebug() << "getNextBreakableLineNumber(" << lineNumber << "), code lines:" << programLines.count();
     for ( int distance = 0; distance < 15; ++distance ) {
         const int lineNumber1 = lineNumber + distance;
         if ( canBreakAt(lineNumber1, programLines) == FoundEvaluatableLine ) {
             return lineNumber1;
         }
 
         const int lineNumber2 = lineNumber - distance;
         if ( lineNumber1 != lineNumber2 &&
              canBreakAt(lineNumber2, programLines) == FoundEvaluatableLine )
         {
             return lineNumber2;
         }
     }
 
     return -1;
 }
 
 NextEvaluatableLineHint DebuggerAgent::canBreakAt( const QString &fileName, int lineNumber ) const
 {
     kDebug() << "canBreakAt(" << QFileInfo(fileName).fileName() << "," << lineNumber << ")";
     QMutexLocker locker( m_mutex );
     return canBreakAt( lineNumber, m_scriptLines[fileName] );
 }
 
 int DebuggerAgent::getNextBreakableLineNumber( const QString &fileName, int lineNumber ) const
 {
     kDebug() << "getNextBreakableLineNumber(" << QFileInfo(fileName).fileName() << ","
              << lineNumber << ")";
     QMutexLocker locker( m_mutex );
     return getNextBreakableLineNumber( lineNumber, m_scriptLines[fileName] );
 }
 
 QString DebuggerAgent::stateToString( DebuggerState state )
 {
     switch ( state ) {
     case NotRunning:
         return i18nc("@info/plain Debugger state", "Not running");
     case Running:
         return i18nc("@info/plain Debugger state", "Running");
     case Interrupted:
         return i18nc("@info/plain Debugger state", "Interrupted");
     case Aborting:
         return i18nc("@info/plain Debugger state", "Aborting");
     default:
         return "Unknown";
     }
 }
 
 bool DebuggerAgent::executeCommand( const ConsoleCommand &command, QString *returnValue )
 {
     if ( !command.isValid() ) {
         return false;
     }
 
     switch ( command.command() ) {
     case ConsoleCommand::HelpCommand:
         if ( returnValue ) {
             if ( !command.arguments().isEmpty() ) {
                 // "help" command with at least one argument
                 const ConsoleCommand::Command commandType =
                         ConsoleCommand::commandFromName( command.argument() );
                 *returnValue = i18nc("@info", "Command <emphasis>%1</emphasis>: %2<nl />"
                                               "Syntax: %3",
                         command.argument(), ConsoleCommand::commandDescription(commandType),
                         ConsoleCommand::commandSyntax(commandType));
             } else {
                 // "help" command without arguments
                 *returnValue = i18nc("@info", "Type a command beginning with a point ('.') or "
                         "JavaScript code. Available commands: %1<nl />"
                         "Use <emphasis>.help</emphasis> with an argument to get more information "
                         "about individual commands<nl />"
                         "Syntax: %2", ConsoleCommand::availableCommands().join(", "),
                         ConsoleCommand::commandSyntax(command.command()) );
             }
         }
         return true;
     case ConsoleCommand::ClearCommand:
-        kWarning() << "ClearCommand needs to be implemented outside of DebuggerAgent";
+        qWarning() << "ClearCommand needs to be implemented outside of DebuggerAgent";
         return true;
     case ConsoleCommand::LineNumberCommand:
         if ( returnValue ) {
             *returnValue = QString::number( lineNumber() );
         }
         return true;
     case ConsoleCommand::BreakpointCommand: {
         bool ok;
         int lineNumber = command.argument().toInt( &ok );
         if ( !ok ) {
             *returnValue = i18nc("@info", "Invalid argument '%1', expected a line number",
                                  command.argument());
             return false;
         }
 
         // TODO: Add argument to control breakpoints in external scripts
         m_mutex->lock();
         const QString mainScriptFileName = m_mainScriptFileName;
         m_mutex->unlock();
 
         lineNumber = getNextBreakableLineNumber( mainScriptFileName, lineNumber );
         ok = lineNumber >= 0;
         if ( !ok ) {
             *returnValue = i18nc("@info", "Cannot interrupt script execution at line %1",
                                  lineNumber);
             return false;
         }
 
         // TODO Use filename from a new argument
         const QHash< uint, Breakpoint > &breakpoints = breakpointsForFile( mainScriptFileName );
         const bool breakpointExists = breakpoints.contains( lineNumber );
         kDebug() << "Breakpoint exists" << breakpointExists;
         Breakpoint breakpoint = breakpointExists ? breakpoints[lineNumber]
                 : Breakpoint( mainScriptFileName, lineNumber );
         if ( command.arguments().count() == 1 ) {
             // Only ".break <lineNumber>", no command to execute
             // Return information about the breakpoint
             if ( breakpointExists ) {
                 *returnValue = i18nc("@info", "Breakpoint at line %1: %2 hits, %3, %4",
                                      lineNumber, breakpoint.hitCount(),
                                      breakpoint.isEnabled() ? i18nc("@info", "enabled")
                                                             : i18nc("@info", "disabled"),
                                      breakpoint.condition().isEmpty()
                                         ? i18nc("@info", "No condition")
                                         : i18nc("@info", "Condition: %1", breakpoint.condition())
                                     );
             } else {
                 *returnValue = i18nc("@info", "No breakpoint found at line %1", lineNumber);
             }
             return breakpointExists;
         }
 
         // More than one argument given, ie. more than ".break <lineNumber> ..."
         const QString &argument = command.arguments().count() == 1
                 ? QString() : command.argument( 1 );
         bool errorNotFound = false;
         QRegExp maxhitRegExp( "^maxhits(?:=|:)(\\d+)$", Qt::CaseInsensitive );
         if ( command.arguments().count() == 1 || argument.compare(QLatin1String("add")) == 0 ) {
             emit breakpointsChanged( BreakpointChange(AddBreakpoint, breakpoint) );
             *returnValue = ok ? i18nc("@info", "Breakpoint added at line %1", lineNumber)
                               : i18nc("@info", "Cannot add breakpoint at line %1", lineNumber);
         } else if ( argument.compare(QLatin1String("remove")) == 0 ) {
             if ( !breakpointExists ) {
                 errorNotFound = true;
             } else {
                 emit breakpointsChanged( BreakpointChange(RemoveBreakpoint, breakpoint) );
                 *returnValue = ok ? i18nc("@info", "Breakpoint at line %1 removed", lineNumber)
                                   : i18nc("@info", "Cannot remove breakpoint at line %1", lineNumber);
             }
         } else if ( argument.compare(QLatin1String("toggle")) == 0 ) {
             if ( !breakpointExists ) {
                 errorNotFound = true;
             } else {
                 breakpoint.setEnabled( !breakpoint.isEnabled() );
                 emit breakpointsChanged( BreakpointChange(UpdateBreakpoint, breakpoint) );
                 *returnValue = ok ? i18nc("@info", "Breakpoint toggled at line %1", lineNumber)
                                   : i18nc("@info", "Cannot toggle breakpoint at line %1", lineNumber);
             }
         } else if ( argument.compare(QLatin1String("enable")) == 0 ) {
             if ( !breakpointExists ) {
                 errorNotFound = true;
             } else {
                 breakpoint.setEnabled();
                 emit breakpointsChanged( BreakpointChange(UpdateBreakpoint, breakpoint) );
                 *returnValue = ok ? i18nc("@info", "Breakpoint enabled at line %1", lineNumber)
                                   : i18nc("@info", "Cannot enable breakpoint at line %1", lineNumber);
             }
         } else if ( argument.compare(QLatin1String("disable")) == 0 ) {
             if ( !breakpointExists ) {
                 errorNotFound = true;
             } else {
                 breakpoint.setEnabled( false );
                 emit breakpointsChanged( BreakpointChange(UpdateBreakpoint, breakpoint) );
                 *returnValue = ok ? i18nc("@info", "Breakpoint disabled at line %1", lineNumber)
                                   : i18nc("@info", "Cannot disable breakpoint at line %1", lineNumber);
             }
         } else if ( argument.compare(QLatin1String("reset")) == 0 ) {
             if ( !breakpointExists ) {
                 errorNotFound = true;
             } else {
                 breakpoint.reset();
                 emit breakpointsChanged( BreakpointChange(UpdateBreakpoint, breakpoint) );
                 *returnValue = ok ? i18nc("@info", "Breakpoint reset at line %1", lineNumber)
                                   : i18nc("@info", "Cannot reset breakpoint at line %1", lineNumber);
             }
         } else if ( argument.compare(QLatin1String("condition")) == 0 ) {
             if ( !breakpointExists ) {
                 errorNotFound = true;
             } else if ( command.arguments().count() < 3 ) {
                 // Needs at least 3 arguments: ".break <lineNumber> condition <conditionCode>"
                 *returnValue = i18nc("@info", "Condition code missing");
             } else {
                 breakpoint.setCondition( QStringList(command.arguments().mid(2)).join(" ") );
                 emit breakpointsChanged( BreakpointChange(UpdateBreakpoint, breakpoint) );
                 *returnValue = ok ? i18nc("@info", "Breakpoint condition set to <emphasis>%1"
                                                    "</emphasis> at line %2",
                                           breakpoint.condition(), lineNumber)
                                   : i18nc("@info", "Cannot set breakpoint condition to <emphasis>%1"
                                                    "</emphasis> at line %1",
                                           breakpoint.condition(), lineNumber);
             }
         } else if ( maxhitRegExp.indexIn(argument) != -1 ) {
             if ( !breakpointExists ) {
                 errorNotFound = true;
             } else {
                 breakpoint.setMaximumHitCount( maxhitRegExp.cap(1).toInt() );
                 emit breakpointsChanged( BreakpointChange(UpdateBreakpoint, breakpoint) );
                 *returnValue = ok ? i18nc("@info", "Breakpoint changed at line %1", lineNumber)
                                   : i18nc("@info", "Cannot change breakpoint at line %1", lineNumber);
             }
         } else {
             kDebug() << "Unexcepted argument:" << argument;
             ok = false;
             if ( returnValue ) {
                 *returnValue = i18nc("@info", "Unexcepted argument: %1<nl />Excepted: "
                                      "<emphasis>add</emphasis> (default), "
                                      "<emphasis>remove</emphasis>, "
                                      "<emphasis>toggle</emphasis>, "
                                      "<emphasis>enable</emphasis>, "
                                      "<emphasis>disable</emphasis>, "
                                      "<emphasis>reset</emphasis>, "
                                      "<emphasis>condition=&lt;conditionCode&gt;</emphasis>, "
                                      "<emphasis>maxhits=&lt;number&gt;</emphasis>",
                                      argument);
             }
         }
 
         if ( errorNotFound ) {
             ok = false;
             if ( returnValue ) {
                 *returnValue = i18nc("@info", "No breakpoint found at line %1",
                                         lineNumber );
             }
         }
         return ok;
     }
     case ConsoleCommand::DebuggerControlCommand: {
         const QString argument = command.argument();
         if ( argument == QLatin1String("status") && returnValue ) {
             m_mutex->lockInline();
             *returnValue = i18nc("@info", "Debugger status: %1", stateToString(m_state));
             if ( m_state != NotRunning ) {
                 *returnValue += ", " + i18nc("@info", "line %1", m_lineNumber);
             }
             if ( m_hasUncaughtException ) {
                 *returnValue += ", " + i18nc("@info",
                         "uncaught exception in line %1: <message>%2</message>",
                         m_uncaughtExceptionLineNumber, m_uncaughtException.toString());
             }
             m_mutex->unlockInline();
             return true;
         } else {
             ConsoleCommandExecutionControl executionControl =
                     consoleCommandExecutionControlFromString( argument );
             if ( executionControl != InvalidControlExecution ) {
                 QString errorMessage;
                 const bool ok = debugControl( executionControl, command.argument(1), &errorMessage );
                 if ( returnValue ) {
                     if ( ok ) {
                         *returnValue = i18nc("@info", "Command successfully executed");
                     } else {
                         *returnValue = i18nc("@info",
                                 "Cannot execute command: <message>%1</message>", errorMessage);
                     }
                 }
                 return ok;
             } else if ( returnValue ) {
                 *returnValue = i18nc("@info", "Unexcepted argument <emphasis>%1</emphasis><nl />"
                                     "Expected one of these: "
                                     "<emphasis>status</emphasis>, "
                                     "<emphasis>continue</emphasis>, "
                                     "<emphasis>interrupt</emphasis>, "
                                     "<emphasis>abort</emphasis>, "
                                     "<emphasis>stepinto &lt;count = 1&gt;</emphasis>, "
                                     "<emphasis>stepover &lt;count = 1&gt;</emphasis>, "
                                     "<emphasis>stepout &lt;count = 1&gt;</emphasis>, "
                                     "<emphasis>rununtil &lt;lineNumber&gt;</emphasis>",
                                     command.argument());
                 return false;
             }
         }
     }
     case ConsoleCommand::DebugCommand: {
         bool error;
         int errorLineNumber;
         QString errorMessage;
         QStringList backtrace;
 
         QScriptValue result = evaluateInContext( command.arguments().join(" "),
                 i18nc("@info/plain", "Console Debug Command"), &error, &errorLineNumber,
                 &errorMessage, &backtrace, InterruptAtStart );
 
         if ( error ) {
             if ( returnValue ) {
                 *returnValue = i18nc("@info", "Error: <message>%1</message><nl />"
                                               "Backtrace: <message>%2</message>",
                                      errorMessage, backtrace.join("<br />"));
             }
         } else if ( returnValue ) {
             *returnValue = result.toString();
         }
         return !error;
     }
 
     default:
         kDebug() << "Command execution not implemented" << command.command();
         return false;
     }
 }
 
 void DebuggerAgent::continueToDoSomething()
 {
     QMutexLocker locker( m_mutex );
     if ( m_state != Interrupted ) {
         kDebug() << "Debugger is not interrupted" << m_state;
         return;
     }
 
     // Wake from interrupt, then emit doSomething() and directly interrupt again
     m_executionControl = ExecuteInterrupt;
     m_interruptWaiter->wakeAll();
 }
 
 QScriptValue DebuggerAgent::evaluateInContext( const QString &program, const QString &contextName,
         bool *hadUncaughtException, int *errorLineNumber, QString *errorMessage,
         QStringList *backtrace, DebugFlags debugFlags )
 {
     // Use new context for program evaluation
     QScriptContext *context = engine()->pushContext();
 
     // Store current execution type/debug flags, to restore it later
     m_mutex->lockInline();
     const ExecutionControl executionType = m_executionControl;
     const DebugFlags oldDebugFlags = m_debugFlags;
     m_debugFlags = debugFlags;
     m_mutex->unlockInline();
 
     QTimer timer;
     if ( debugFlags.testFlag(InterruptAtStart) ) {
         debugStepIntoInjectedProgram();
     } else {
         debugRunInjectedProgram();
 
         // Start a countdown, if evaluation does not finish within this countdown, it gets aborted
         timer.setSingleShot( true );
         connect( &timer, SIGNAL(timeout()), this, SLOT(cancelInjectedCodeExecution()) );
         timer.start( 3000 ); // 3 seconds time for the evaluation
     }
 
     // Evaluate program
     QScriptValue result = engine()->evaluate( program,
             contextName.isEmpty() ? "<Injected Code>" : contextName );
     timer.stop(); // Stop cancel timeout
 
     // Restore previous execution type (if not interrupted)
     if ( debugFlags.testFlag(InterruptAtStart) ) {
         m_mutex->lockInline();
         m_executionControl = executionType;
         m_mutex->unlockInline();
     }
 
     // Restore previous debug flags
     if ( debugFlags != oldDebugFlags ) {
         m_mutex->lockInline();
         m_debugFlags = oldDebugFlags;
         m_mutex->unlockInline();
     }
 
     DEBUGGER_EVENT("Evaluate-in-context result" << result.toString() << program);
     if ( hadUncaughtException ) {
         *hadUncaughtException = engine()->hasUncaughtException();
     }
     if ( errorLineNumber ) {
         *errorLineNumber = engine()->uncaughtExceptionLineNumber();
     }
     if ( errorMessage ) {
         *errorMessage = engine()->uncaughtException().toString();
     }
     if ( backtrace ) {
         *backtrace = engine()->uncaughtExceptionBacktrace();
     }
     if ( engine()->hasUncaughtException() ) {
         kDebug() << "Uncaught exception in program:"
                  << engine()->uncaughtExceptionBacktrace();
         engine()->clearExceptions();
     }
 
     engine()->popContext();
 
     // Transfer values from evaluation context to script context
     QScriptValueIterator it( context->activationObject() );
     QScriptValue scriptContext = engine()->currentContext()->activationObject();
     if ( it.hasNext() ) {
         it.next();
         scriptContext.setProperty( it.name(), it.value() );
     }
 
     return result;
 }
 
 void DebuggerAgent::cancelInjectedCodeExecution()
 {
     QMutexLocker locker( m_mutex );
     if ( m_injectedScriptState == InjectedScriptEvaluating ) {
         DEBUGGER_EVENT("Evaluation did not finish in time or was cancelled");
         m_executionControl = ExecuteAbortInjectedProgram;
     } else {
         // Is not running injected code
         checkHasExited();
     }
 
     wakeFromInterrupt();
 }
 
 void DebuggerAgent::addBreakpoint( const Breakpoint &breakpoint )
 {
     QHash< uint, Breakpoint > &breakpoints = breakpointsForFile( breakpoint.fileName() );
     breakpoints.insert( breakpoint.lineNumber(), breakpoint );
 }
 
 void DebuggerAgent::removeBreakpoint( const Breakpoint &breakpoint )
 {
     QHash< uint, Breakpoint > &breakpoints = breakpointsForFile( breakpoint.fileName() );
     breakpoints.remove( breakpoint.lineNumber() );
 }
 
 bool DebuggerAgent::debugControl( DebuggerAgent::ConsoleCommandExecutionControl controlType,
                                   const QVariant &argument, QString *errorMessage )
 {
     switch ( controlType ) {
     case ControlExecutionContinue:
         if ( !isInterrupted() ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Debugger is not interrupted!");
             }
             return false;
         }
         debugContinue();
         break;
     case ControlExecutionInterrupt:
         if ( !isRunning() ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Debugger is not running! Start the debugger first.");
             }
             return false;
         }
         debugInterrupt();
         break;
     case ControlExecutionAbort:
         if ( !isRunning() && !isInterrupted() ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Debugger is not running or interrupted! Start the debugger first.");
             }
             return false;
         }
         abortDebugger();
         break;
     case ControlExecutionStepInto:
         if ( !isInterrupted() ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Debugger is not interrupted!");
             }
             return false;
         }
         debugStepInto( qMax(0, argument.toInt() - 1) );
         break;
     case ControlExecutionStepOver:
         if ( !isInterrupted() ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Debugger is not interrupted!");
             }
             return false;
         }
         debugStepOver( qMax(0, argument.toInt() - 1) );
         break;
     case ControlExecutionStepOut:
         if ( !isInterrupted() ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Debugger is not interrupted!");
             }
             return false;
         }
         debugStepOut( qMax(0, argument.toInt() - 1) );
         break;
     case ControlExecutionRunUntil: {
         bool ok;
         int lineNumber = argument.toInt( &ok );
 
         m_mutex->lockInline();
         const int scriptLineCount = m_scriptLines[m_mainScriptFileName].count();
         const QString mainScriptFileName = m_mainScriptFileName;
         m_mutex->unlockInline();
 
         if ( !argument.isValid() || !ok ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Invalid argument '%1', expected line number!",
                                       argument.toString() );
             }
             return false;
         } else if ( lineNumber < 1 || lineNumber > scriptLineCount ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Invalid line number %1! Must be between 1 and %2",
                                       lineNumber, scriptLineCount);
             }
             return false;
         }
 
         // TODO: Add argument to run until a line in an external script
         lineNumber = getNextBreakableLineNumber( mainScriptFileName, lineNumber );
         if ( lineNumber < 0 ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info", "Cannot interrupt script execution at line %!",
                                       lineNumber);
             }
             return false;
         }
 
         debugRunUntilLineNumber( mainScriptFileName, lineNumber );
         break;
     }
     case InvalidControlExecution:
         kDebug() << "Invalid control execution type";
         break;
     default:
         kDebug() << "Unknown Debugger::ExecutionControl" << controlType;
         if ( errorMessage ) {
             *errorMessage = i18nc("@info", "Debugger command %1 not implemented!", controlType );
         }
         return false;
     }
 
     return true;
 }
 
 DebuggerAgent::ConsoleCommandExecutionControl DebuggerAgent::consoleCommandExecutionControlFromString( const QString &str )
 {
     const QString _str = str.trimmed().toLower();
     if ( _str == QLatin1String("continue") ) {
         return ControlExecutionContinue;
     } else if ( _str == QLatin1String("interrupt") ) {
         return ControlExecutionInterrupt;
     } else if ( _str == QLatin1String("abort") ) {
         return ControlExecutionAbort;
     } else if ( _str == QLatin1String("stepinto") ) {
         return ControlExecutionStepInto;
     } else if ( _str == QLatin1String("stepover") ) {
         return ControlExecutionStepOver;
     } else if ( _str == QLatin1String("stepout") ) {
         return ControlExecutionStepOut;
     } else if ( _str == QLatin1String("rununtil") ) {
         return ControlExecutionRunUntil;
     } else {
         return InvalidControlExecution;
     }
 }
 
 void DebuggerAgent::setExecutionControlType( ExecutionControl executionType )
 {
     QMutexLocker locker( m_mutex );
     m_executionControl = executionType;
     m_repeatExecutionTypeCount = 0; // If execution type is repeatable, ie. stepInto/stepOver/stepOut
 }
 
 void DebuggerAgent::abortDebugger()
 {
     DEBUGGER_CONTROL("abortDebugger");
     QMutexLocker locker( m_mutex );
     const DebuggerState state = m_state;
     switch ( state ) {
     case Aborting:
         DEBUGGER_EVENT("Is already aborting");
         return;
     case NotRunning:
         if ( m_injectedScriptState == InjectedScriptEvaluating ) {
             cancelInjectedCodeExecution();
         }
         return;
     case Running:
     case Interrupted:
     default:
         DEBUGGER_EVENT("Abort");
         m_lastRunAborted = true;
         m_executionControl = ExecuteAbort;
         setState( Aborting );
         engine()->abortEvaluation();
         if ( m_injectedScriptState == InjectedScriptEvaluating ) {
             cancelInjectedCodeExecution();
         }
         break;
     }
 
     wakeFromInterrupt( state );
 }
 
 void DebuggerAgent::debugInterrupt()
 {
     QMutexLocker locker( m_mutex );
     DEBUGGER_CONTROL( "debugInterrupt" );
     if ( m_state != Running ) {
         kDebug() << "Debugger is not running" << m_state;
         return;
     }
 
     m_executionControl = ExecuteInterrupt;
 }
 
 void DebuggerAgent::debugContinue()
 {
     QMutexLocker locker( m_mutex );
     DEBUGGER_CONTROL( "debugContinue" );
     if ( m_state != Interrupted ) {
         kDebug() << "Debugger is not interrupted" << m_state;
         return;
     }
 
     m_executionControl = ExecuteRun;
     m_interruptWaiter->wakeAll();
 }
 
 void DebuggerAgent::debugStepInto( int repeat )
 {
     DEBUGGER_CONTROL2( "debugStepInto", repeat );
     QMutexLocker locker( m_mutex );
     if ( m_state != Interrupted ) {
         kDebug() << "Debugger is not interrupted" << m_state;
         return;
     }
 
     // Wake from interrupt and run until the next statement
     m_repeatExecutionTypeCount = repeat;
     m_executionControl = ExecuteStepInto;
     m_interruptWaiter->wakeAll();
 }
 
 void DebuggerAgent::debugStepOver( int repeat )
 {
     DEBUGGER_CONTROL2( "debugStepOver", repeat );
     QMutexLocker locker( m_mutex );
     if ( m_state != Interrupted ) {
         kDebug() << "Debugger is not interrupted" << m_state;
         return;
     }
 
     // Wake from interrupt and run until the next statement in the function level
     m_interruptFunctionLevel = 0;
     m_repeatExecutionTypeCount = repeat;
     m_executionControl = ExecuteStepOver;
     m_interruptWaiter->wakeAll();
 }
 
 void DebuggerAgent::debugStepOut( int repeat )
 {
     DEBUGGER_CONTROL2( "debugStepOut", repeat );
     QMutexLocker locker( m_mutex );
     if ( m_state != Interrupted) {
         kDebug() << "Debugger is not interrupted" << m_state;
         return;
     }
 
     // Wake from interrupt and run until the current function gets exited
     m_interruptFunctionLevel = 0;
     m_repeatExecutionTypeCount = repeat;
     m_executionControl = ExecuteStepOut;
     m_interruptWaiter->wakeAll();
 }
 
 void DebuggerAgent::debugRunUntilLineNumber( const QString &fileName, int lineNumber )
 {
     DEBUGGER_CONTROL3( "debugRunUntilLineNumber", QFileInfo(fileName).fileName(), lineNumber );
     int runUntilLineNumber = getNextBreakableLineNumber( fileName, lineNumber );
 
     QMutexLocker locker( m_mutex );
     m_runUntilLineNumber = runUntilLineNumber;
     if ( runUntilLineNumber != -1 ) {
         m_executionControl = ExecuteRun;
         wakeFromInterrupt();
     }
 }
 
 void DebuggerAgent::debugRunInjectedProgram()
 {
     QMutexLocker locker( m_mutex );
     DEBUGGER_CONTROL("debugRunInjectedProgram");
     m_repeatExecutionTypeCount = 0;
     m_injectedScriptState = InjectedScriptInitializing; // Update in next scriptLoad()
     m_previousExecutionControl = m_executionControl;
     m_executionControl = ExecuteRunInjectedProgram;
     // Do not wake from interrupt here, because the script should stay interrupted,
     // while the injected program runs in another thread
 }
 
 void DebuggerAgent::debugStepIntoInjectedProgram()
 {
     QMutexLocker locker( m_mutex );
     DEBUGGER_CONTROL("debugStepIntoInjectedProgram");
     m_repeatExecutionTypeCount = 0;
     m_injectedScriptState = InjectedScriptInitializing; // Update in next scriptLoad()
     m_previousExecutionControl = m_executionControl;
     m_executionControl = ExecuteStepIntoInjectedProgram;
     // Do not wake from interrupt here, because the script should stay interrupted,
     // while the injected program runs in another thread
 }
 
 DebuggerState DebuggerAgent::state() const
 {
     QMutexLocker locker( m_mutex );
     return m_state;
 }
 
 QString DebuggerAgent::mainScriptFileName() const
 {
     QMutexLocker locker( m_mutex );
     return m_mainScriptFileName;
 }
 
 void DebuggerAgent::setMainScriptFileName( const QString &mainScriptFileName )
 {
     QMutexLocker locker( m_mutex );
     m_mainScriptFileName = mainScriptFileName;
 }
 
 void DebuggerAgent::setScriptText( const QString &fileName, const QString &program )
 {
     QMutexLocker locker( m_mutex );
     m_scriptLines[ fileName ] = program.split( '\n', QString::KeepEmptyParts );
 }
 
 void DebuggerAgent::scriptLoad( qint64 id, const QString &program, const QString &fileName,
                                 int baseLineNumber )
 {
     Q_UNUSED( baseLineNumber );
     if ( id != -1 ) {
         QMutexLocker locker( m_mutex );
         if ( m_state != Running && !isInjectedScriptEvaluating() ) {
             // Call fireup() in case a script was evaluated
             fireup();
         }
         m_scriptIdToFileName.insert( id, fileName );
         m_currentScriptId = id;
         if ( m_injectedScriptState == InjectedScriptInitializing ) {
             // The new script is code that should be executed in the current scripts context
             // while the main script is interrupted
             m_injectedScriptId = id;
             m_injectedScriptState = InjectedScriptEvaluating;
         } else if ( m_executionControl != ExecuteRunInjectedProgram &&
                     m_executionControl != ExecuteStepIntoInjectedProgram )
         {
             DEBUGGER_EVENT( "Load script" << QFileInfo(fileName).fileName() << "with id" << id
                             << "for provider" << QFileInfo(m_mainScriptFileName ).baseName());
             setScriptText( fileName, program );
         }
     }
 }
 
 void DebuggerAgent::scriptUnload( qint64 id )
 {
     Q_UNUSED( id );
     QMutexLocker locker( m_mutex );
     if ( m_injectedScriptState == InjectedScriptUpdateVariablesInParentContext ) {
         m_injectedScriptState = InjectedScriptNotRunning;
         QTimer::singleShot( 0, this, SLOT(wakeFromInterrupt()) );
     }
     DEBUGGER_EVENT( "Unload script" << m_scriptIdToFileName[id] << "with id" << id );
     m_scriptIdToFileName.remove( id );
     if ( m_currentScriptId == id ) {
         m_currentScriptId = -1;
         if ( m_lineNumber == -1 && m_state == Running ) {
             shutdown();
         }
     }
 }
 
 void DebuggerAgent::wakeFromInterrupt( DebuggerState unmodifiedState )
 {
     QMutexLocker locker( m_mutex );
     if ( unmodifiedState == Interrupted ) {
         m_interruptWaiter->wakeAll();
     }
 }
 
 void DebuggerAgent::contextPush()
 {
 }
 
 void DebuggerAgent::contextPop()
 {
 }
 
 void DebuggerAgent::functionEntry( qint64 scriptId )
 {
     if ( scriptId != -1 ) {
         QMutexLocker locker( m_mutex );
         ++m_functionDepth;
         if ( m_interruptFunctionLevel >= -1 &&
             (m_executionControl == ExecuteStepOver || m_executionControl == ExecuteStepOut) )
         {
             ++m_interruptFunctionLevel;
         }
 
         emit variablesChanged( VariableChange(PushVariableStack) );
         emit backtraceChanged( BacktraceChange(PushBacktraceFrame) );
     }
 }
 
 
 void DebuggerAgent::functionExit( qint64 scriptId, const QScriptValue& returnValue )
 {
     if ( scriptId != -1 ) {
         emit variablesChanged( VariableChange(PopVariableStack) );
         emit backtraceChanged( BacktraceChange(PopBacktraceFrame) );
     }
 
     QMutexLocker locker( m_mutex );
     if ( scriptId != -1 && m_injectedScriptId == scriptId ) {
         DEBUGGER_EVENT( "Evaluation in context finished with" << returnValue.toString() );
         m_executionControl = m_previousExecutionControl;
         emit evaluationInContextFinished( returnValue );
 
         // Interrupts again if it was interrupted before,
         // but variables can be updated in the script context
         m_injectedScriptState = InjectedScriptUpdateVariablesInParentContext;
     } else {
         if ( scriptId != -1 && m_interruptFunctionLevel >= 0 ) {
             if ( m_executionControl == ExecuteStepOver ) {
                 // m_interruptFunctionLevel may be 0 here, if the script exits in one function,
                 // waiting for a signal to continue script execution at a connected slot
                 --m_interruptFunctionLevel;
             } else if ( m_executionControl == ExecuteStepOut ) {
                 --m_interruptFunctionLevel;
             }
         }
     }
 
     if ( scriptId != -1 ) {
         if ( m_executionControl == ExecuteAbort || m_state == Aborting ) {
             // Do nothing when aborting, changing m_functionDepth when aborting
             // leads to problems when starting the script again
             return;
         }
 
         --m_functionDepth;
         const int functionDepth = m_functionDepth;
 
         if ( functionDepth == 0 ) {
             // Engine mutex is still locked here to protect the engine while it is executing,
             // unlock after execution has ended here
             shutdown();
         }
     }
 }
 
 ExecutionControl DebuggerAgent::applyExecutionControl( ExecutionControl executionControl,
                                                        QScriptContext *currentContext )
 {
     QMutexLocker locker( m_mutex );
     Q_UNUSED( currentContext );
     switch ( executionControl ) {
         case ExecuteStepInto:
         case ExecuteStepIntoInjectedProgram:
             // Decrease repeation counter, if it is at 0 interrupt
             if ( m_repeatExecutionTypeCount > 0 ) {
                 --m_repeatExecutionTypeCount;
             } else if ( m_repeatExecutionTypeCount == 0 ) {
                 if ( m_executionControl != ExecuteAbort &&
                      m_executionControl != ExecuteAbortInjectedProgram )
                 {
                     m_executionControl = executionControl = ExecuteInterrupt;
                 }
             }
             break;
         case ExecuteStepOver:
             if ( m_interruptFunctionLevel == 0 ) {
                 if ( m_repeatExecutionTypeCount > 0 ) {
                     --m_repeatExecutionTypeCount;
                 } else if ( m_repeatExecutionTypeCount == 0 ) {
                     m_interruptFunctionLevel = -2;
                     if ( m_executionControl != ExecuteAbort &&
                          m_executionControl != ExecuteAbortInjectedProgram )
                     {
                         m_executionControl = executionControl = ExecuteInterrupt;
                     }
                 }
             }
             break;
         case ExecuteStepOut:
             if ( m_interruptFunctionLevel == -1 ) {
                 if ( m_repeatExecutionTypeCount > 0 ) {
                     --m_repeatExecutionTypeCount;
                 } else if ( m_repeatExecutionTypeCount == 0 ) {
                     m_interruptFunctionLevel = -2;
                     if ( m_executionControl != ExecuteAbort &&
                          m_executionControl != ExecuteAbortInjectedProgram )
                     {
                         m_executionControl = executionControl = ExecuteInterrupt;
                     }
                 }
             }
             break;
         case ExecuteRun:
 //         case ExecuteNotRunning:
         case ExecuteInterrupt:
         case ExecuteRunInjectedProgram:
         default:
             break;
     }
     return executionControl;
 }
 
 void DebuggerAgent::emitChanges() {
     m_engineSemaphore->acquire();
     QMutexLocker locker( m_mutex );
 
     QScriptContext *context = engine()->currentContext();
     m_currentContext = context;
     if ( context ) {
         // Construct backtrace/variable change objects
         // The Frame object is already created and added to the model with empty values
         // (in DebuggerAgent::functionEntry())
         const bool isGlobal = context->thisObject().equals( engine()->globalObject() );
         const Frame frame( QScriptContextInfo(context), isGlobal );
         const BacktraceChange backtraceChange( UpdateBacktraceFrame, frame );
         const VariableChange variableChange = VariableChange::fromContext( context );
 
         // Emit changes
         emit variablesChanged( variableChange );
         emit backtraceChanged( backtraceChange );
     }
     m_engineSemaphore->release();
 }
 
 void DebuggerAgent::positionChange( qint64 scriptId, int lineNumber, int columnNumber )
 {
     Q_UNUSED( scriptId );
 
     // Lock the engine if not already locked (should normally be locked before script execution,
     // but it may get unlocked before the script is really done, eg. waiting idle for network
     // requests to finish)
     QScriptContext *currentContext = engine()->currentContext();
     // Unlock now, maybe trying to lock above was successful or the engine was already locked
     m_engineSemaphore->release();
 
     // Lock member variables and initialize
     m_mutex->lockInline();
     ExecutionControl executionControl = m_executionControl;
     const bool isAborting = executionControl == ExecuteAbort || m_state == Aborting;
     DEBUGGER_EVENT_POS_CHANGED("Position changed to line" << lineNumber << "colum" << columnNumber
         << "in file" << m_scriptIdToFileName[scriptId] << "- Execution type:" << executionControl);
     const bool injectedProgram = isInjectedScriptEvaluating();
     if ( !injectedProgram && m_state == NotRunning ) {
         // Execution has just started
         m_mutex->unlockInline();
         fireup();
         m_mutex->lockInline();
     }
 
     const int oldLineNumber = m_lineNumber;
     const int oldColumnNumber = m_columnNumber;
     DebuggerState state = m_state;
 
     // Decide if execution should be interrupted (breakpoints, execution control value, eg. step into).
     if ( !injectedProgram && !isAborting ) {
         // Update current execution position,
         // before emitting breakpointReached() and positionChanged()
         m_currentScriptId = scriptId;
         m_lineNumber = lineNumber;
         m_columnNumber = columnNumber;
 
         // Check if execution should be interrupted at the current line, because of a
         // runUntilLineNumber command
         if ( m_runUntilLineNumber == lineNumber ) {
             if ( executionControl != ExecuteAbort &&
                  executionControl != ExecuteAbortInjectedProgram )
             {
                 m_executionControl = executionControl = ExecuteInterrupt;
                 m_runUntilLineNumber = -1;
             }
         }
 
         // Check for breakpoints at the current line
         if ( m_debugFlags.testFlag(InterruptOnBreakpoints) ) {
             Breakpoint *breakpoint = 0;
             bool conditionError = false;
             if ( findActiveBreakpoint(lineNumber, breakpoint, &conditionError) ) {
                 // Reached a breakpoint, applyBreakpoints() may have written
                 // a new value in m_executionControl (ExecuteInterrupt)
                 if ( executionControl != ExecuteAbort &&
                     executionControl != ExecuteAbortInjectedProgram )
                 {
                     m_executionControl = executionControl = ExecuteInterrupt;
                 }
                 m_mutex->unlockInline();
 
                 emit breakpointReached( *breakpoint );
             } else if ( conditionError ) {
                 // There was an error with the condition of the breakpoint
                 // Interrupt to let the user fix the condition code
                 m_executionControl = executionControl = ExecuteInterrupt;
                 m_mutex->unlockInline();
             } else {
                 // No breakpoint reached
                 m_executionControl = executionControl =
                         applyExecutionControl( executionControl, currentContext );
                 m_mutex->unlockInline();
             }
         } else {
             m_executionControl = executionControl =
                     applyExecutionControl( executionControl, currentContext );
             m_mutex->unlockInline();
         }
 
         if ( executionControl == ExecuteInterrupt ) {
             emit positionChanged( lineNumber, columnNumber, oldLineNumber, oldColumnNumber );
 
             // Interrupt script execution
             DEBUGGER_EVENT("Interrupt now");
             doInterrupt( injectedProgram );
 
             // Script execution continued, update values
             m_mutex->lockInline();
             executionControl = m_executionControl;
             state = m_state;
             m_mutex->unlockInline();
         }
     } else {
         // Do not update execution position or check for breakpoints,
         // if in an injected program or aborting
         m_mutex->unlockInline();
     }
 
     // Check if debugging should be aborted
     if ( executionControl == ExecuteAbort ) {
         m_mutex->lockInline();
         m_injectedScriptId = -1;
         m_injectedScriptState = InjectedScriptNotRunning;
         m_mutex->unlockInline();
 
         // TODO
         const bool locked = m_engineSemaphore->tryAcquire( 1, 250 );
         engine()->abortEvaluation();
         if ( !locked ) {
-            kWarning() << "Could not lock the engine";
+            qWarning() << "Could not lock the engine";
         }
 
         shutdown();
     } else if ( executionControl == ExecuteAbortInjectedProgram ) {
         // Restore member variables
         m_mutex->lockInline();
         DEBUGGER_EVENT("Abort injected program");
         m_injectedScriptState = InjectedScriptAborting; // Handled in doInterrupt
         m_executionControl = m_previousExecutionControl;
         m_mutex->unlockInline();
 
         // TEST
         // Interrupt execution of injected script code,
         // it should be aborted by terminating the executing thread
         doInterrupt( true );
     } else if ( state != NotRunning && state != Aborting ) {
         // Protect further script execution
         m_engineSemaphore->acquire();
     }
 }
 
 QScriptContextInfo DebuggerAgent::contextInfo() {
     if ( m_engineSemaphore->tryAcquire(1, 200) ) {
         const QScriptContextInfo info( engine()->currentContext() );
         m_engineSemaphore->release();
 
         return info;
     } else {
         kDebug() << "Engine is locked (not interrupted), cannot get context info";
         return QScriptContextInfo();
     }
 }
 
 bool DebuggerAgent::findActiveBreakpoint( int lineNumber, Breakpoint *&foundBreakpoint,
                                           bool *conditionError )
 {
     QMutexLocker locker( m_mutex );
     if ( m_currentScriptId == -1 ) {
         kDebug() << "scriptId == -1";
         return false;
     }
 
     // Test for a breakpoint at the new line number
     QHash< uint, Breakpoint > &breakpoints = currentBreakpoints();
     if ( !breakpoints.contains(lineNumber) ) {
         // No breakpoint at the current execution position
         return false;
     }
 
     Breakpoint &breakpoint = breakpoints[ lineNumber ];
     if ( !breakpoint.isValid() ) {
         // No breakpoint for the current file found
         return false;
     } else if ( breakpoint.isEnabled() ) {
         // Found a breakpoint, test breakpoint condition if any
         if ( !breakpoint.condition().isEmpty() ) {
             if ( !breakpoint.testCondition(this, conditionError) ) {
                 // Breakpoint reached but it's condition was not satisfied
                 return false;
             }
         }
 
         // The found breakpoint is enabled
         DEBUGGER_EVENT( "Breakpoint reached:" << lineNumber << breakpoint.fileName() );
         breakpoint.reached(); // Increase hit count, etc.
 
         // Condition satisfied or no condition, active breakpoint found
         foundBreakpoint = &breakpoint;
         return true;
     } else {
         DEBUGGER_EVENT( "Breakpoint at" << lineNumber << "reached but it is disabled"
                         << breakpoint.fileName() );
         return false;
     }
 }
 
 void DebuggerAgent::setState( DebuggerState newState )
 {
     QMutexLocker locker( m_mutex );
     if ( newState == m_state ) {
         return;
     }
 
     const DebuggerState oldState = m_state;
     DEBUGGER_STATE_CHANGE( oldState, newState );
     m_state = newState;
     emit stateChanged( newState, oldState );
 }
 
 void DebuggerAgent::doInterrupt( bool injectedProgram ) {
     m_mutex->lockInline();
     DEBUGGER_EVENT("Interrupt");
     if ( m_injectedScriptState == InjectedScriptAborting ) {
         DEBUGGER_EVENT("Abort evaluation of injected script");
         m_injectedScriptState = InjectedScriptNotRunning;
         m_injectedScriptId = -1;
         m_mutex->unlockInline();
 
         // Emit signal to inform that the evaluation was aborted
         emit evaluationInContextAborted( i18nc("@info", "Evaluation did not finish in time. "
                                                "Maybe there is an infinite loop?") );
     } else {
         m_checkRunningTimer->start( CHECK_RUNNING_WHILE_INTERRUPTED_INTERVAL );
         setState( Interrupted );
         const QDateTime timestamp = QDateTime::currentDateTime();
         const int lineNumber = m_lineNumber;
         const QString fileName = m_scriptIdToFileName[ m_currentScriptId ];
         m_mutex->unlockInline();
 
         // Emit changes in the backtrace/variables
         emitChanges();
 
         if ( !injectedProgram ) {
             emit interrupted( lineNumber, fileName, timestamp );
         }
     }
 
     forever {
         // Wait here until the debugger gets continued
         m_interruptMutex->lockInline();
         m_interruptWaiter->wait( m_interruptMutex/*, 500*/ );
         m_interruptMutex->unlockInline();
 
         // Continued, update the execution control value, which might have changed
         m_mutex->lockInline();
         ExecutionControl executionControl = m_executionControl;
         DEBUGGER_EVENT("Woke up from interrupt, to do now:" << executionControl);
         m_mutex->unlockInline();
 
         bool continueExecution = false;
         switch ( executionControl ) {
         case ExecuteAbort: {
             // Continued to be aborted
             const bool locked = m_engineSemaphore->tryAcquire( 1, 250 );
             engine()->abortEvaluation();
             if ( !locked ) {
-                kWarning() << "Could not lock the engine";
+                qWarning() << "Could not lock the engine";
             }
 
             // Shut the debugger down
             shutdown();
             return;
         }
         case ExecuteAbortInjectedProgram:
             // Restore member variables
             m_mutex->lockInline();
             DEBUGGER_EVENT("Abort injected program");
             m_injectedScriptState = InjectedScriptAborting; // Handled in doInterrupt
             m_executionControl = m_previousExecutionControl;
             m_mutex->unlockInline();
 
             // Interrupt execution of injected script code,
             // it should be aborted by terminating the executing thread
             doInterrupt( true );
             return;
 
         // Check if execution should be interrupted again, ie. if it was just woken to do something
         case ExecuteInterrupt: {
             m_mutex->lockInline();
             DEBUGGER_EVENT("Still interrupted");
 
             // A hint was set in functionExit() to trigger a call to emitChanges() after script
             // code was evaluated in the script context (in another thread) and might have changed
             // variables. In scriptUnload() a 0-timer gets started to call wakeFromInterrupt() so
             // that the variables in the script context and in the script execution thread are
             // available here. TODO
             if ( m_injectedScriptState == InjectedScriptUpdateVariablesInParentContext ) {
                 m_injectedScriptId = -1;
             }
             setState( Interrupted );
             m_mutex->unlockInline();
 
             // Update variables/backtrace
             emitChanges();
 
             // Let directly connected slots be executed in this agent's thread,
             // while execution is interrupted
             emit doSomething();
             break;
         }
         default:
             // Continue script execution
             continueExecution = true;
             break;
         }
 
         if ( continueExecution ) {
             break;
         }
     }
 
     m_mutex->lockInline();
     ExecutionControl executionControl = m_executionControl;
     m_checkRunningTimer->start( CHECK_RUNNING_INTERVAL );
     const QDateTime timestamp = QDateTime::currentDateTime();
     m_mutex->unlockInline();
 
     setState( Running );
 
     if ( executionControl != ExecuteRunInjectedProgram ) {
         emit continued( timestamp,
                         executionControl != ExecuteContinue && executionControl != ExecuteRun );
     }
 }
 
 int DebuggerAgent::currentFunctionLineNumber() const
 {
     QMutexLocker locker( m_mutex );
     if ( !m_currentContext ) {
         return -1;
     }
     QScriptContext *context = m_currentContext;
     while ( context ) {
         if ( context->thisObject().isFunction() ) {
             return QScriptContextInfo( context ).lineNumber();
         }
         context = context->parentContext();
     }
     return -1;
 }
 
 // TODO Remove?
 void DebuggerAgent::checkExecution()
 {
     checkHasExited();
 }
 
 bool DebuggerAgent::checkHasExited()
 {
     QMutexLocker locker( m_mutex );
     if ( m_state == NotRunning ) {
         return true;
     } else if ( isInterrupted() ) {
         // If script execution is interrupted it is not finished
         return false;
     }
 
     bool isEvaluating;
     if ( m_engineSemaphore->tryAcquire(1, 500) ) {
         isEvaluating = engine()->isEvaluating();
         m_engineSemaphore->release();
     } else {
-        kWarning() << "Cannot lock the engine";
+        qWarning() << "Cannot lock the engine";
         if ( m_state == Aborting ) {
             engine()->abortEvaluation();
         }
         shutdown();
         return false;
     }
 
     if ( m_state != NotRunning && !isEvaluating ) {
         shutdown();
         return true;
     } else {
         return false;
     }
 }
 
 void DebuggerAgent::fireup()
 {
     QMutexLocker locker( m_mutex );
     DEBUGGER_EVENT("Execution started");
     // First store start time
     const QDateTime timestamp = QDateTime::currentDateTime();
 
     setState( Running );
     m_lastRunAborted = false;
     m_hasUncaughtException = false;
     m_uncaughtExceptionLineNumber = -1;
     m_checkRunningTimer->start( CHECK_RUNNING_INTERVAL );
 
     emit started( timestamp );
 }
 
 void DebuggerAgent::shutdown()
 {
     QMutexLocker locker( m_mutex );
     m_checkRunningTimer->stop();
     if ( m_state == NotRunning ) {
         kDebug() << "Not running";
         return;
     }
     DEBUGGER_EVENT("Execution stopped");
 
     // First store end time
     const QDateTime timestamp = QDateTime::currentDateTime();
 
     m_functionDepth = 0;
     const bool isPositionChanged = m_lineNumber != -1 || m_columnNumber != -1;
 
     // Context will be invalid
     m_currentContext = 0;
 
     const DebuggerState oldState = m_state;
 
     // Engine mutex is still locked here
     if ( oldState == Aborting ) {
         if ( engine()->isEvaluating() ) {
             kDebug() << "Still evaluating, abort";
             engine()->abortEvaluation();
         }
 
         DEBUGGER_EVENT("Was aborted");
         m_engineSemaphore->release();
         emit aborted();
         m_engineSemaphore->acquire();
     }
 
     engine()->clearExceptions();
 
     setState( NotRunning );
 
     ScriptApi::Network *scriptNetwork = qobject_cast< ScriptApi::Network* >(
             engine()->globalObject().property("network").toQObject() );
     Q_ASSERT( scriptNetwork );
     const bool hasRunningRequests = scriptNetwork->hasRunningRequests();
     m_engineSemaphore->release();
 
     if ( isPositionChanged ) {
         const int oldLineNumber = m_lineNumber;
         const int oldColumnNumber = m_columnNumber;
         m_lineNumber = -1;
         m_columnNumber = -1;
 
         emit positionChanged( -1, -1, oldLineNumber, oldColumnNumber );
     }
 
     const int uncaughtExceptionLineNumber = m_uncaughtExceptionLineNumber;
     const QString uncaughtException = m_uncaughtException.toString();
     const QStringList backtrace = m_uncaughtExceptionBacktrace;
 
     emit stopped( timestamp, oldState == Aborting, hasRunningRequests,
                   uncaughtExceptionLineNumber, uncaughtException, backtrace );
 
     // Restore locked state of the engine mutex after execution ends
     // (needs to be locked before execution starts with eg. QScriptEngine::evaluate())
     m_engineSemaphore->acquire();
 }
 
 void DebuggerAgent::exceptionCatch( qint64 scriptId, const QScriptValue &exception )
 {
     kDebug() << scriptId << exception.toString();
 }
 
 void DebuggerAgent::exceptionThrow( qint64 scriptId, const QScriptValue &exceptionValue,
                                     bool hasHandler )
 {
     Q_UNUSED( scriptId );
     if ( !hasHandler ) {
         m_mutex->lockInline();
         if ( m_injectedScriptState == InjectedScriptEvaluating ) {
             // Exception was thrown from injected code
             m_mutex->unlockInline();
         } else {
             int uncaughtExceptionLineNumber = m_lineNumber;
             m_hasUncaughtException = true;
             m_uncaughtExceptionLineNumber = uncaughtExceptionLineNumber;
             m_uncaughtException = exceptionValue;
             m_uncaughtExceptionBacktrace = engine()->uncaughtExceptionBacktrace();
             const DebugFlags debugFlags = m_debugFlags;
             const QString fileName = m_scriptIdToFileName[scriptId];
             DEBUGGER_EVENT("Uncatched exception in" << QFileInfo(fileName).fileName()
                            << "line" << uncaughtExceptionLineNumber << exceptionValue.toString());
             m_mutex->unlockInline();
 
             emit exception( uncaughtExceptionLineNumber, exceptionValue.toString(), fileName );
 
             if ( debugFlags.testFlag(InterruptOnExceptions) ) {
                 // Interrupt at the exception
                 doInterrupt();
             }
 
             abortDebugger();
         }
     }
 }
 
 QVariant DebuggerAgent::extension( QScriptEngineAgent::Extension extension,
                                    const QVariant &argument )
 {
     return QScriptEngineAgent::extension( extension, argument );
 }
 
 QString DebuggerAgent::currentSourceFile() const
 {
     QMutexLocker locker( m_mutex );
     return m_currentScriptId == -1 ? QString() : m_scriptIdToFileName[m_currentScriptId];
 }
 
 int DebuggerAgent::lineNumber() const
 {
     QMutexLocker locker( m_mutex );
     return m_lineNumber;
 }
 
 int DebuggerAgent::columnNumber() const
 {
     QMutexLocker locker( m_mutex );
     return m_columnNumber;
 }
 
 bool DebuggerAgent::hasUncaughtException() const
 {
     QMutexLocker locker( m_mutex );
     return m_hasUncaughtException;
 }
 
 int DebuggerAgent::uncaughtExceptionLineNumber() const
 {
     QMutexLocker locker( m_mutex );
     return m_uncaughtExceptionLineNumber;
 }
 
 QScriptValue DebuggerAgent::uncaughtException() const
 {
     QMutexLocker locker( m_mutex );
     return m_uncaughtException;
 }
 
 ExecutionControl DebuggerAgent::currentExecutionControlType() const
 {
     QMutexLocker locker( m_mutex );
     return m_executionControl;
 }
 
 DebugFlags DebuggerAgent::debugFlags() const
 {
     QMutexLocker locker( m_mutex );
     return m_debugFlags;
 }
 
 void DebuggerAgent::setDebugFlags( DebugFlags debugFlags )
 {
     QMutexLocker locker( m_mutex );
     m_debugFlags = debugFlags;
 }
 
 void DebuggerAgent::slotOutput( const QString &outputString, const QScriptContextInfo &contextInfo )
 {
     emit output( outputString, contextInfo );
 }
 
 } // namespace Debugger
diff --git a/engine/timetablemate/src/debugger/debuggerjobs.cpp b/engine/timetablemate/src/debugger/debuggerjobs.cpp
index 5d86347..3be25b5 100644
--- a/engine/timetablemate/src/debugger/debuggerjobs.cpp
+++ b/engine/timetablemate/src/debugger/debuggerjobs.cpp
@@ -1,1296 +1,1296 @@
 /*
  *   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 "debuggerjobs.h"
 
 // Own includes
 #include "debugger.h"
 #include "debuggeragent.h"
 #include "breakpointmodel.h"
 #include "variablemodel.h"
 #include "backtracemodel.h"
 
 // PublicTransport engine includes
 #include <engine/script/serviceproviderscript.h> // For ServiceProviderScript::SCRIPT_FUNCTION_...
 
 // KDE includes
 #include <KLocalizedString>
 #include <KDebug>
 #include <ThreadWeaver/DependencyPolicy>
 #include <ThreadWeaver/Thread>
 
 // Qt includes
 #include <QMutex>
 #include <QSemaphore>
 #include <QTimer>
 #include <QEventLoop>
 #include <QFile>
 #include <QApplication>
 
 namespace Debugger {
 
 DebuggerJob::DebuggerJob( const ScriptData &scriptData, const QString &useCase, QObject *parent )
         : ThreadWeaver::Job(parent), m_agent(0), m_data(scriptData), m_debugger(0),
           m_success(true), m_aborted(false), m_mutex(new QMutex(QMutex::Recursive)),
           m_waitLoop(0), m_engineSemaphore(new QSemaphore(1)),
           m_useCase(useCase), m_quit(false), m_scriptObjectTargetThread(0), m_currentLoop(0),
           m_stoppedSignalWasProcessed(true)
 {
     Q_ASSERT_X( scriptData.isValid(), "DebuggerJob constructor",
                 "ScriptData contains invalid data, no provider data and/or script code loaded" );
 
     QMutexLocker locker( m_mutex );
     if ( m_useCase.isEmpty() ) {
         QTimer::singleShot( 0, this, SLOT(setDefaultUseCase()) );
     }
 }
 
 DebuggerJob::DebuggerJob( DebuggerAgent *debugger, QSemaphore *engineSemaphore,
                           const ScriptData &scriptData, const ScriptObjects &objects,
                           const QString &useCase, QObject *parent )
         : ThreadWeaver::Job(parent), m_agent(debugger), m_data(scriptData), m_objects(objects),
           m_success(true), m_aborted(false), m_mutex(new QMutex(QMutex::Recursive)),
           m_waitLoop(0), m_engineSemaphore(engineSemaphore),
           m_useCase(useCase), m_quit(false), m_scriptObjectTargetThread(0),
           m_stoppedSignalWasProcessed(true)
 {
     Q_ASSERT_X( scriptData.isValid(), "DebuggerJob constructor",
                 "ScriptData contains invalid data, no provider data and/or script code loaded" );
     Q_ASSERT_X( objects.isValid(), "DebuggerJob constructor",
                 "ScriptObjects contains invalid objects, use ScriptObjects::createObjects()" );
 
     QMutexLocker locker( m_mutex );
     if ( m_useCase.isEmpty() ) {
         QTimer::singleShot( 0, this, SLOT(setDefaultUseCase()) );
     }
 }
 
 DebuggerJob::~DebuggerJob()
 {
     if ( !isFinished() ) {
         requestAbort();
     }
 
     m_mutex->lockInline();
     if ( m_agent ) {
         DEBUG_JOBS("Wait for the debugger to finish");
         m_agent->finish();
     }
     m_mutex->unlockInline();
 
     delete m_mutex;
     delete m_engineSemaphore;
 }
 
 void DebuggerJob::connectScriptObjects( bool doConnect )
 {
     QMutexLocker locker( m_mutex );
     if ( doConnect ) {
         connect( m_objects.helper.data(), SIGNAL(messageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)),
                  this, SIGNAL(scriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)) );
     } else {
         disconnect( m_objects.helper.data(), SIGNAL(messageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)),
                     this, SIGNAL(scriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)) );
     }
 }
 
 void DebuggerJob::disconnectScriptObjects()
 {
     QMutexLocker locker( m_mutex );
     // Disconnect all signals of script objects from this job
     // to prevent crashes after execution was aborted
     if ( !m_objects.helper.isNull() ) {
         disconnect( m_objects.helper.data(), 0, this, 0 );
     }
     if ( !m_objects.network.isNull() ) {
         disconnect( m_objects.network.data(), 0, this, 0 );
     }
     if ( !m_objects.result.isNull() ) {
         disconnect( m_objects.result.data(), 0, this, 0 );
     }
 
     m_objects.clear();
     m_agent = 0;
 }
 
 LoadScriptJob::~LoadScriptJob()
 {
 }
 
 EvaluateInContextJob::~EvaluateInContextJob()
 {
 }
 
 ExecuteConsoleCommandJob::~ExecuteConsoleCommandJob()
 {
 }
 
 void DebuggerJob::setDefaultUseCase()
 {
     QMutexLocker locker( m_mutex );
     if ( m_useCase.isEmpty() ) {
         // Do not change use case, if it was already set using setUseCase()
         m_useCase = defaultUseCase();
     }
 }
 
 bool DebuggerJob::success() const
 {
     QMutexLocker locker( m_mutex );
     return m_success;
 }
 
 ScriptObjects DebuggerJob::objects() const
 {
     QMutexLocker locker( m_mutex );
     return m_objects;
 }
 
 void DebuggerJob::requestAbort()
 {
     QMutexLocker locker( m_mutex );
     if ( m_quit || !m_agent ) {
         DEBUG_JOBS("Is already aborting/finished");
         return;
     }
 
     DEBUG_JOBS("Request abort");
     m_quit = true;
     if ( m_currentLoop ) {
         QEventLoop *loop = m_currentLoop;
         m_currentLoop = 0;
         loop->quit();
     }
 
     if ( !isFinished() && m_objects.network->hasRunningRequests() ) {
         m_objects.network->abortAllRequests();
     }
 
     if ( m_agent ) {
         m_agent->abortDebugger();
     }
 }
 
 QString DebuggerJob::typeToString( JobType type )
 {
     switch ( type ) {
     case LoadScript:
         return "LoadScriptJob";
     case EvaluateInContext:
         return "EvaluateInContextJob";
     case ExecuteConsoleCommand:
         return "ExecuteConsoleCommandJob";
     case CallScriptFunction:
         return "CallScriptFunctionJob";
     case TestFeatures:
         return "TestFeaturesJob";
     case TimetableDataRequest:
         return "TimetableDataRequestJob";
     default:
         return QString("Unknown job type %1").arg(type);
     }
 }
 
 QString EvaluateInContextJob::toString() const
 {
     QMutexLocker locker( m_mutex );
     QString programString = m_program;
     if ( programString.length() > 100 ) {
         programString = programString.left(100) + "...";
     }
     return QString("%1 (%2)").arg( DebuggerJob::toString() ).arg( programString );
 }
 
 QString ExecuteConsoleCommandJob::toString() const
 {
     QMutexLocker locker( m_mutex );
     return QString("%1 (%2)").arg( DebuggerJob::toString() ).arg( m_command.toString() );
 }
 
 void DebuggerJob::run()
 {
 #ifdef DEBUG_JOB_START_END
     kDebug() << "\nDebuggerJob::run(): Start" << toString();
 #endif
 
     debuggerRun();
     disconnectScriptObjects();
 
 #ifdef DEBUG_JOB_START_END
     debugJobEnd();
 #endif
 }
 
 #ifdef DEBUG_JOB_START_END
 void DebuggerJob::debugJobEnd() const
 {
     QMutexLocker locker( m_mutex );
     kDebug() << "DebuggerJob::run():" << (m_success ? "Success" : "Fail") << toString();
 }
 #endif
 
 void DebuggerJob::attachAgent( DebuggerAgent *agent )
 {
     // Initialize and connect the new agent.
     // The agent lives in the thread of this job, while the job itself lives in the GUI thread.
     // Therefore the connections below are queued connections.
     m_mutex->lock();
     m_agent = agent;
     agent->setMainScriptFileName( m_data.provider.scriptFileName() );
     agent->setDebugFlags( NeverInterrupt );
     Debugger *debugger = m_debugger;
     m_mutex->unlock();
 
     connectAgent( agent );
 
     // Add existing breakpoints
     if ( debugger ) {
         BreakpointModel *breakpointModel = debugger->breakpointModel();
         for ( int i = 0; i < breakpointModel->rowCount(); ++i ) {
             agent->addBreakpoint( *breakpointModel->breakpointFromRow(i) );
         }
     }
 }
 
 void DebuggerJob::connectAgent( DebuggerAgent *agent, bool doConnect, bool connectModels )
 {
     QMutexLocker locker( m_mutex );
     if ( doConnect ) {
         connect( agent, SIGNAL(started(QDateTime)), this, SIGNAL(started(QDateTime)) );
         connect( agent, SIGNAL(stopped(QDateTime,bool,bool,int,QString,QStringList)),
                  this, SLOT(slotStopped(QDateTime,bool,bool,int,QString,QStringList)) );
         connect( agent, SIGNAL(aborted()), this, SIGNAL(aborted()) );
         connect( agent, SIGNAL(positionChanged(int,int,int,int)),
                  this, SIGNAL(positionChanged(int,int,int,int)) );
         connect( agent, SIGNAL(stateChanged(DebuggerState,DebuggerState)),
                  this, SIGNAL(stateChanged(DebuggerState,DebuggerState)) );
         connect( agent, SIGNAL(breakpointReached(Breakpoint)),
                  this, SIGNAL(breakpointReached(Breakpoint)) );
         connect( agent, SIGNAL(exception(int,QString,QString)),
                  this, SIGNAL(exception(int,QString,QString)) );
         connect( agent, SIGNAL(interrupted(int,QString,QDateTime)),
                  this, SIGNAL(interrupted(int,QString,QDateTime)) );
         connect( agent, SIGNAL(continued(QDateTime,bool)), this, SIGNAL(continued(QDateTime,bool)) );
         connect( agent, SIGNAL(output(QString,QScriptContextInfo)),
                  this, SIGNAL(output(QString,QScriptContextInfo)) );
         connect( agent, SIGNAL(informationMessage(QString)),
                  this, SIGNAL(informationMessage(QString)) );
         connect( agent, SIGNAL(errorMessage(QString)),
                  this, SIGNAL(errorMessage(QString)) );
         connect( agent, SIGNAL(evaluationInContextFinished(QScriptValue)),
                  this, SIGNAL(evaluationInContextFinished(QScriptValue)) );
         connect( agent, SIGNAL(evaluationInContextAborted(QString)),
                  this, SIGNAL(evaluationInContextAborted(QString)) );
         if ( connectModels ) {
             connect( agent, SIGNAL(variablesChanged(VariableChange)),
                     this, SIGNAL(variablesChanged(VariableChange)) );
             connect( agent, SIGNAL(backtraceChanged(BacktraceChange)),
                     this, SIGNAL(backtraceChanged(BacktraceChange)) );
             connect( agent, SIGNAL(breakpointReached(Breakpoint)),
                     this, SIGNAL(breakpointReached(Breakpoint)) );
         }
     } else {
         disconnect( agent, SIGNAL(started(QDateTime)), this, SIGNAL(started(QDateTime)) );
         disconnect( agent, SIGNAL(stopped(QDateTime,bool,bool,int,QString,QStringList)),
                     this, SLOT(slotStopped(QDateTime,bool,bool,int,QString,QStringList)) );
         disconnect( agent, SIGNAL(aborted()), this, SIGNAL(aborted()) );
         disconnect( agent, SIGNAL(positionChanged(int,int,int,int)),
                     this, SIGNAL(positionChanged(int,int,int,int)) );
         disconnect( agent, SIGNAL(stateChanged(DebuggerState,DebuggerState)),
                     this, SIGNAL(stateChanged(DebuggerState,DebuggerState)) );
         disconnect( agent, SIGNAL(breakpointReached(Breakpoint)),
                     this, SIGNAL(breakpointReached(Breakpoint)) );
         disconnect( agent, SIGNAL(exception(int,QString,QString)),
                     this, SIGNAL(exception(int,QString,QString)) );
         disconnect( agent, SIGNAL(interrupted(int,QString,QDateTime)),
                     this, SIGNAL(interrupted(int,QString,QDateTime)) );
         disconnect( agent, SIGNAL(continued(QDateTime,bool)), this, SIGNAL(continued(QDateTime,bool)) );
         disconnect( agent, SIGNAL(output(QString,QScriptContextInfo)),
                     this, SIGNAL(output(QString,QScriptContextInfo)) );
         disconnect( agent, SIGNAL(informationMessage(QString)),
                     this, SIGNAL(informationMessage(QString)) );
         disconnect( agent, SIGNAL(errorMessage(QString)),
                     this, SIGNAL(errorMessage(QString)) );
         disconnect( agent, SIGNAL(evaluationInContextFinished(QScriptValue)),
                     this, SIGNAL(evaluationInContextFinished(QScriptValue)) );
         disconnect( agent, SIGNAL(evaluationInContextAborted(QString)),
                     this, SIGNAL(evaluationInContextAborted(QString)) );
         if ( connectModels ) {
             disconnect( agent, SIGNAL(variablesChanged(VariableChange)),
                         this, SIGNAL(variablesChanged(VariableChange)) );
             disconnect( agent, SIGNAL(backtraceChanged(BacktraceChange)),
                         this, SIGNAL(backtraceChanged(BacktraceChange)) );
             disconnect( agent, SIGNAL(breakpointReached(Breakpoint)),
                         this, SIGNAL(breakpointReached(Breakpoint)) );
         }
     }
 }
 
 void DebuggerJob::slotStopped( const QDateTime &timestamp, bool aborted, bool hasRunningRequests,
                                int uncaughtExceptionLineNumber, const QString &uncaughtException,
                                const QStringList &backtrace )
 {
     ScriptStoppedFlags flags = aborted ? ScriptWasAborted : ScriptStopped;
     if ( hasRunningRequests ) {
         flags |= ScriptHasRunningRequests;
     }
     emit stopped( timestamp, flags, uncaughtExceptionLineNumber, uncaughtException, backtrace );
 }
 
 DebuggerAgent *DebuggerJob::createAgent() {
     // m_engineSemaphore is expected to be locked here
     // Create engine and agent and connect them
     m_mutex->lock();
     QScriptEngine *engine = new QScriptEngine();
     DebuggerAgent *agent = new DebuggerAgent( engine, m_engineSemaphore, true );
     m_mutex->unlock();
 
     engine->setAgent( agent );
     attachAgent( agent );
 
     // Initialize the script
     QMutexLocker locker( m_mutex );
     const ScriptData data = m_data;
     m_objects.createObjects( data );
     if ( !m_objects.attachToEngine(engine, data) ) {
         kDebug() << "Cannot attach script objects to engine" << m_objects.lastError;
         engine->setAgent( 0 );
         delete agent;
         delete engine;
         m_explanation = m_objects.lastError;
         m_success = false;
         return 0;
     }
     Q_ASSERT( m_objects.isValid() );
 
     // Make this job responsive while running the script
     engine->setProcessEventsInterval( 50 );
     return agent;
 }
 
 void DebuggerJob::destroyAgent()
 {
     // m_engineSemaphore is expected to be locked here
     m_mutex->lock();
     DebuggerAgent *agent = m_agent;
     QScriptEngine *engine = agent->engine();
     m_mutex->unlock();
 
     m_mutex->lock();
     if ( !m_stoppedSignalWasProcessed ) {
-        kWarning() << "No stopped() signal was processed, aborted?";
+        qWarning() << "No stopped() signal was processed, aborted?";
         setJobDone( true );
         m_agent->engine()->abortEvaluation();
     }
     DEBUG_JOBS( "Destroying agent" << m_data.provider.id() << agent << engine );
     if ( engine->isEvaluating() ) {
-        kWarning() << "Still evaluating..." << engine;
+        qWarning() << "Still evaluating..." << engine;
     }
     m_agent = 0;
     engine->setAgent( 0 );
     m_objects.clear();
     delete agent;
     engine->deleteLater();
     m_mutex->unlock();
 }
 
 void DebuggerJob::setJobDone( bool done )
 {
     // The stopped() signal was processed in a connected Debugger instance
     QMutexLocker locker( m_mutex );
     m_stoppedSignalWasProcessed = done;
     if ( done && m_waitLoop ) {
         m_waitLoop->exit();
     }
 }
 
 bool DebuggerJob::waitFor( QObject *sender, const char *signal, WaitForType type )
 {
     // The called function returned, but asynchronous network requests may have been started.
     // Wait for all network requests to finish, because slots in the script may get called
     const int finishWaitTime = 1000;
     int finishWaitCounter = 0;
 
     m_mutex->lockInline();
     bool success = m_success;
     bool quit = m_quit;
     if ( !success || quit ) {
         m_mutex->unlockInline();
         return true;
     }
 
     DebuggerAgent *agent = m_agent;
     ScriptObjects objects = m_objects;
     bool stoppedSignalWasProcessed = m_stoppedSignalWasProcessed;
     m_mutex->unlockInline();
 
     while ( !agent->wasLastRunAborted() && finishWaitCounter < 50 && sender ) {
         if ( (type == WaitForNetwork && !objects.network->hasRunningRequests()) ||
              (type == WaitForScriptFinish &&
               !agent->engine()->isEvaluating() && stoppedSignalWasProcessed) ||
              (type == WaitForInjectedScriptFinish && !agent->isInjectedScriptEvaluating()) ||
              (type == WaitForInterrupt && agent->isInterrupted()) ||
              (type == WaitForNothing && finishWaitCounter > 0) )
         {
             break;
         }
 
         QEventLoop loop;
         connect( sender, signal, &loop, SLOT(quit()) );
         QTimer::singleShot( finishWaitTime, &loop, SLOT(quit()) );
 
         // Store a pointer to the event loop, to be able to quit it from the destructor
         m_mutex->lockInline();
         m_currentLoop = &loop;
         m_mutex->unlockInline();
 
         // Engine continues execution here / waits for a signal
         loop.exec();
         qApp->processEvents();
 
         m_mutex->lockInline();
         if ( !m_currentLoop || m_quit ) {
             m_mutex->unlockInline();
             // Job was aborted
             destroyAgent();
             return false;
         }
         m_currentLoop = 0;
         stoppedSignalWasProcessed = m_stoppedSignalWasProcessed;
         m_mutex->unlockInline();
 
         ++finishWaitCounter;
     }
 
     if ( finishWaitCounter >= 50 ) {
         DEBUG_JOBS("Timeout");
         if ( type == WaitForScriptFinish ) {
             // Script not finished
             DEBUG_JOBS("Script not finished, abort");
             agent->engine()->abortEvaluation();
         } else if ( type == WaitForNetwork ) {
             objects.network->abortAllRequests();
         }
     }
     return finishWaitCounter < 50;
 }
 
 void LoadScriptJob::debuggerRun()
 {
     m_mutex->lockInline();
     QScriptSyntaxCheckResult syntax = QScriptEngine::checkSyntax( m_data.program->sourceCode() );
     if ( syntax.state() == QScriptSyntaxCheckResult::Error ) {
         DEBUG_JOBS("Syntax error at" << syntax.errorLineNumber() << syntax.errorColumnNumber()
                    << syntax.errorMessage());
         if ( syntax.errorColumnNumber() < 0 ) {
             m_explanation = i18nc("@info/plain", "Syntax error at line %1: <message>%2</message>",
                                   syntax.errorLineNumber(), syntax.errorMessage());
         } else {
             m_explanation = i18nc("@info/plain", "Syntax error at line %1, column %2: <message>%3</message>",
                                   syntax.errorLineNumber(), syntax.errorColumnNumber(),
                                   syntax.errorMessage());
         }
         m_success = false;
         m_mutex->unlockInline();
         return;
     }
 
     // Create new engine and agent
     m_mutex->unlockInline();
     m_engineSemaphore->acquire();
     DebuggerAgent *agent = createAgent();
     m_mutex->lockInline();
     if ( !agent || m_quit ) {
         m_mutex->unlockInline();
         if ( agent ) {
             destroyAgent();
         }
         m_engineSemaphore->release();
         return;
     }
     const ScriptData data = m_data;
     const ScriptObjects objects = m_objects;
     const DebugFlags debugFlags = m_debugFlags;
     m_mutex->unlockInline();
 
     agent->setDebugFlags( debugFlags );
     agent->setExecutionControlType( debugFlags.testFlag(InterruptAtStart)
                                     ? ExecuteInterrupt : ExecuteRun );
     agent->engine()->evaluate( *data.program );
     Q_ASSERT_X( !objects.network->hasRunningRequests() || !agent->engine()->isEvaluating(),
                 "LoadScriptJob::debuggerRun()",
                 "Evaluating the script should not start any asynchronous requests, bad script" );
 
     // Wait for the stopped signal
     const bool aborted = agent->wasLastRunAborted();
     if ( aborted ) {
         kDebug() << "Aborted" << m_data.provider.id();
         m_stoppedSignalWasProcessed = true; // Do not crash on assert in destroyAgent()
         destroyAgent();
         QMutexLocker locker( m_mutex );
         m_explanation = i18nc("@info/plain", "Was aborted");
         m_success = false;
         m_aborted = true;
         m_engineSemaphore->release();
         return;
     }
 
     m_mutex->lock();
     if ( !m_stoppedSignalWasProcessed ) {
         // Wait for the stopped() signal to be processed by the connected Debugger instance
         m_waitLoop = new QEventLoop();
         m_mutex->unlock();
         m_waitLoop->exec();
 
         // The stopped() signal was processed
         m_mutex->lock();
         delete m_waitLoop;
         m_waitLoop = 0;
         Q_ASSERT( m_stoppedSignalWasProcessed );
         m_mutex->unlock();
     } else {
         m_mutex->unlock();
     }
 
 
     // Check that the getTimetable() function is implemented in the script
     const QString functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETTIMETABLE;
     const QScriptValue function = agent->engine()->globalObject().property( functionName );
     if ( !function.isFunction() ) {
         QMutexLocker locker( m_mutex );
         DEBUG_JOBS("Did not find" << functionName << "function in the script!");
         m_explanation = i18nc("@info/plain", "Did not find required '%1' function in the script.",
                               functionName);
         m_success = false;
     }
 
     const QStringList functions = QStringList()
             << ServiceProviderScript::SCRIPT_FUNCTION_FEATURES
             << ServiceProviderScript::SCRIPT_FUNCTION_GETTIMETABLE
             << ServiceProviderScript::SCRIPT_FUNCTION_GETJOURNEYS
             << ServiceProviderScript::SCRIPT_FUNCTION_GETSTOPSUGGESTIONS
             << ServiceProviderScript::SCRIPT_FUNCTION_GETADDITIONALDATA;
     QStringList globalFunctions;
     foreach ( const QString &function, functions ) {
         const QScriptValue value = agent->engine()->globalObject().property( function );
         if ( value.isFunction() ) {
             globalFunctions << function;
         }
     }
     const QStringList includedFiles =
             agent->engine()->globalObject().property( "includedFiles" ).toVariant().toStringList();
     m_engineSemaphore->release();
 
     m_mutex->lock();
     if ( !m_success || m_quit ) {
         m_success = false;
     } else if ( agent->hasUncaughtException() ) {
         m_engineSemaphore->acquire();
         const QString uncaughtException = agent->uncaughtException().toString();
         DEBUG_JOBS("Error in the script" << agent->uncaughtExceptionLineNumber()
                    << uncaughtException);
         m_engineSemaphore->release();
 
         m_includedFiles = includedFiles;
         m_globalFunctions = globalFunctions;
         m_explanation = i18nc("@info/plain", "Error in the script: "
                               "<message>%1</message>.", uncaughtException);
         m_success = false;
     } else if ( agent->wasLastRunAborted() ) {
         // Script was aborted
         m_explanation = i18nc("@info/plain", "Aborted");
         m_success = false;
     } else {
         m_includedFiles = includedFiles;
         m_globalFunctions = globalFunctions;
         m_success = true;
     }
     m_mutex->unlock();
 
     m_engineSemaphore->acquire();
     destroyAgent();
     m_engineSemaphore->release();
 }
 
 bool ExecuteConsoleCommandJob::runInForeignAgent( DebuggerAgent *agent )
 {
     // Execute the command
     m_mutex->lockInline();
     const ConsoleCommand command = m_command;
     m_mutex->unlockInline();
 
     QString returnValue;
     bool success = agent->executeCommand( command, &returnValue );
 
     QMutexLocker locker( m_mutex );
     m_success = success;
     m_returnValue = returnValue;
     return true;
 }
 
 bool ForeignAgentJob::waitForFinish( DebuggerAgent *agent, const ScriptObjects &objects )
 {
     // Wait for the evaluation to finish,
     // does not include waiting for running asynchronous network requests to finish
     if ( !waitFor(agent, SIGNAL(evaluationInContextFinished(QScriptValue)),
                   WaitForInjectedScriptFinish) )
     {
         return false;
     }
 
     // The called function returned, but asynchronous network requests may have been started.
     // Wait for all network requests to finish, because slots in the script may get called
     if ( !waitFor(objects.network.data(), SIGNAL(allRequestsFinished()), WaitForNetwork) ) {
         return false;
     }
 
     // Wait for the evaluation to finish after having received network data,
     // ie. wait until execution gets interrupted again in the parent thread, if any
     if ( m_parentJob &&
          !waitFor(agent, SIGNAL(interrupted(int,QString,QDateTime)), WaitForInterrupt) )
     {
         return false;
     }
 
     return true;
 }
 
 void ForeignAgentJob::debuggerRun()
 {
     m_mutex->lockInline();
     const ScriptData data = m_data;
     DebuggerAgent *agent = m_agent;
     QScriptEngine *engine = 0;
     ScriptObjects objects = m_objects;
     m_success = true;
     const QPointer< DebuggerJob > parentJob = m_parentJob;
     m_mutex->unlockInline();
 
     const bool useExistingEngine = agent;
     QThread *scriptObjectThread = 0;
     DebugFlags previousDebugFlags = NeverInterrupt;
     ExecutionControl previousExecutionControl = ExecuteInterrupt;
     if ( useExistingEngine ) {
         engine = agent->engine();
 
         // Let the running job move script objects to this thread
         QEventLoop loop;
         connect( parentJob, SIGNAL(movedScriptObjectsToThread(QThread*)),
                  &loop, SLOT(quit()) );
         scriptObjectThread = objects.currentThread();
         parentJob->moveScriptObjectsToThread( QThread::currentThread() );
         loop.exec();
 
         // Do not interrupt in injected script code,
         // store previous debug flags set by the parent job
         previousDebugFlags = agent->debugFlags();
         previousExecutionControl = agent->currentExecutionControlType();
         agent->setDebugFlags( NeverInterrupt );
         agent->setExecutionControlType( ExecuteRun );
 
         connectAgent( agent );
     } else {
         // Create new engine and agent
         m_engineSemaphore->acquire();
         m_mutex->lockInline();
         agent = createAgent();
         objects = m_objects;
         m_mutex->unlockInline();
 
         if ( !agent ) {
             m_engineSemaphore->release();
             return;
         }
         engine = agent->engine();
 
         // Load script
         engine->evaluate( *data.program );
         Q_ASSERT_X( !engine->isEvaluating(), "CallScriptFunctionJob::debuggerRun()",
                     "Evaluating the script should not start any asynchronous requests, bad script" );
         m_engineSemaphore->release();
     }
 
     m_engineSemaphore->acquire();
     connect( agent, SIGNAL(evaluationInContextAborted(QString)),
              this, SLOT(evaluationAborted(QString)) );
 
     // Start the job in the foreign agent, implemented by derived classes
     // and wait until it has finished (this includes waiting for running network requests)
     if ( !runInForeignAgent(agent) || !waitForFinish(agent, objects) ) {
         destroyAgent();
         m_engineSemaphore->release();
         return;
     }
 
     disconnect( agent, SIGNAL(evaluationInContextAborted(QString)),
                 this, SLOT(evaluationAborted(QString)) );
 
     // Handle uncaught exceptions
     if ( agent->hasUncaughtException() ) {
         handleUncaughtException( agent );
     }
     m_engineSemaphore->release();
 
     // Cleanup
     if ( useExistingEngine ) {
         QMutexLocker locker( m_mutex );
         // Move script objects back to the parent thread
         DEBUG_JOBS("Move script objects back to the parent thread");
         m_engineSemaphore->acquire();
         objects.moveToThread( scriptObjectThread );
         connectAgent( agent, false );
         m_engineSemaphore->release();
 
         // Restore previous debug flags, interrupts were disabled for this job
         agent->setDebugFlags( previousDebugFlags );
         agent->setExecutionControlType( previousExecutionControl );
         m_agent = 0;
         m_objects.clear();
         m_engineSemaphore = 0; // Do not delete, used by the other thread
 
         parentJob->gotScriptObjectsBack();
     } else {
         m_engineSemaphore->acquire();
         destroyAgent();
         m_engineSemaphore->release();
     }
 }
 
 void EvaluateInContextJob::handleUncaughtException( DebuggerAgent *agent )
 {
     QMutexLocker locker( m_mutex );
     const QString program = m_program;
     const QString context = m_context;
     EvaluationResult result = m_result;
     handleError( agent->engine(), i18nc("@info/plain", "Error in the script when evaluating '%1' "
                  "with code <icode>%2</icode>: <message>%3</message>",
                  context, program, agent->uncaughtException().toString()),
                  &result );
     m_result = result;
 }
 
 bool EvaluateInContextJob::runInForeignAgent( DebuggerAgent *agent )
 {
     m_mutex->lockInline();
     const QString program = m_program;
     const QString context = m_context;
     m_result.error = false;
     m_mutex->unlockInline();
 
     // m_engineSemaphore is locked
     // Check syntax of the program to run
     DEBUG_JOBS("Evaluate in context" << context << program);
     QScriptSyntaxCheckResult syntax = QScriptEngine::checkSyntax( program );
     if ( syntax.state() == QScriptSyntaxCheckResult::Error ) {
         DEBUG_JOBS("Error in script code:" << syntax.errorLineNumber() << syntax.errorMessage());
 
         QMutexLocker locker( m_mutex );
         m_explanation = syntax.errorMessage().isEmpty() ? i18nc("@info/plain", "Syntax error")
                 : i18nc("@info/plain", "Syntax error: <message>%1</message>.", syntax.errorMessage());
         m_success = false;
         m_result.error = true;
         m_result.errorLineNumber = syntax.errorLineNumber();
         m_result.errorMessage = m_explanation;
         return false;
     }
 
     // Evaluate script code
     EvaluationResult result;
     result.returnValue = agent->evaluateInContext( /*'{' + */program/* + '}'*/, context,
             &(result.error), &(result.errorLineNumber),
             &(result.errorMessage), &(result.backtrace), NeverInterrupt ).toString();
     DEBUG_JOBS("Evaluate in context result:" << result.returnValue);
 
     QMutexLocker locker( m_mutex );
     m_result = result;
     return true;
 }
 
 void DebuggerJob::evaluationAborted( const QString &errorMessage )
 {
     QMutexLocker locker( m_mutex );
     m_explanation = errorMessage;
     m_success = false;
     _evaluationAborted( errorMessage );
     DebuggerAgent *agent = m_agent;
 
     agent->abortDebugger();
 }
 
 void EvaluateInContextJob::_evaluationAborted( const QString &errorMessage )
 {
     QMutexLocker locker( m_mutex );
     m_result.error = true;
     m_result.errorMessage = errorMessage;
 }
 
 void DebuggerJob::handleError( QScriptEngine *engine, const QString &message,
                                EvaluationResult *result )
 {
     // m_engineSemaphore is locked
     handleError( engine->uncaughtExceptionLineNumber(), engine->uncaughtException().toString(),
                  engine->uncaughtExceptionBacktrace(), message, result );
 }
 
 void DebuggerJob::handleError( int uncaughtExceptionLineNumber, const QString &uncaughtException,
                                const QStringList &backtrace, const QString &message,
                                EvaluationResult *result )
 {
     if ( result ) {
         result->error = true;
         result->errorMessage = uncaughtException;
         result->errorLineNumber = uncaughtExceptionLineNumber;
         result->backtrace = backtrace;
     }
     DEBUG_JOBS((!message.isEmpty() ? message : "Script error")
                << uncaughtExceptionLineNumber << uncaughtException << backtrace);
 
     QMutexLocker locker( m_mutex );
     m_explanation = !message.isEmpty() ? message
             : i18nc("@info/plain", "Error in the script: <message>%1</message>.",
                     uncaughtException);
     m_success = false;
 }
 
 void DebuggerJob::attachDebugger( Debugger *debugger )
 {
     // Connect models
     BreakpointModel *breakpointModel = debugger->breakpointModel();
     connect( this, SIGNAL(variablesChanged(VariableChange)),
              debugger->variableModel(), SLOT(applyChange(VariableChange)) );
     connect( this, SIGNAL(backtraceChanged(BacktraceChange)),
              debugger->backtraceModel(), SLOT(applyChange(BacktraceChange)) );
     connect( this, SIGNAL(breakpointsChanged(BreakpointChange)),
              breakpointModel, SLOT(applyChange(BreakpointChange)) );
     connect( this, SIGNAL(breakpointReached(Breakpoint)),
              breakpointModel, SLOT(updateBreakpoint(Breakpoint)) );
     connect( breakpointModel, SIGNAL(breakpointModified(Breakpoint)),
              this, SLOT(updateBreakpoint(Breakpoint)) );
     connect( breakpointModel, SIGNAL(breakpointAdded(Breakpoint)),
              this, SLOT(addBreakpoint(Breakpoint)) );
     connect( breakpointModel, SIGNAL(breakpointAboutToBeRemoved(Breakpoint)),
              this, SLOT(removeBreakpoint(Breakpoint)) );
 
     QMutexLocker locker( m_mutex );
     m_debugger = debugger;
 }
 
 const ConsoleCommand ExecuteConsoleCommandJob::command() const
 {
     QMutexLocker locker( m_mutex );
     return m_command;
 }
 
 QVariant ExecuteConsoleCommandJob::returnValue() const
 {
     QMutexLocker locker( m_mutex );
     return m_returnValue;
 }
 
 EvaluationResult EvaluateInContextJob::result() const
 {
     QMutexLocker locker( m_mutex );
     return m_result;
 }
 
 QVariant EvaluateInContextJob::returnValue() const
 {
     QMutexLocker locker( m_mutex );
     return m_result.returnValue;
 }
 
 QString LoadScriptJob::defaultUseCase() const
 {
     return i18nc("@info", "Load script");
 }
 
 QString EvaluateInContextJob::defaultUseCase() const
 {
     QMutexLocker locker( m_mutex );
     return i18nc("@info", "Evaluate <icode>%1</icode>", m_program.left(50));
 }
 
 QString ExecuteConsoleCommandJob::defaultUseCase() const
 {
     QMutexLocker locker( m_mutex );
     return i18nc("@info", "Execute command <icode>%1</icode>", m_command.toString());
 }
 
 QStringList LoadScriptJob::globalFunctions() const
 {
     QMutexLocker locker( m_mutex );
     return m_globalFunctions;
 }
 
 QStringList LoadScriptJob::includedFiles() const
 {
     QMutexLocker locker( m_mutex );
     return m_includedFiles;
 }
 
 DebugFlags LoadScriptJob::debugFlags() const
 {
     QMutexLocker locker( m_mutex );
     return m_debugFlags;
 }
 
 void DebuggerJob::setUseCase( const QString &useCase )
 {
     QMutexLocker locker( m_mutex );
     m_useCase = useCase;
 }
 
 QString DebuggerJob::useCase() const
 {
     QMutexLocker locker( m_mutex );
     return m_useCase;
 }
 
 QString DebuggerJob::toString() const
 {
     QMutexLocker locker( m_mutex );
     return typeToString( type() ) + ", " + m_data.provider.id();
 }
 
 DebuggerAgent *DebuggerJob::debuggerAgent() const
 {
     QMutexLocker locker( m_mutex );
     return m_agent;
 }
 
 QSemaphore *DebuggerJob::engineSemaphore() const
 {
     QMutexLocker locker( m_mutex );
     return m_engineSemaphore;
 }
 
 bool DebuggerJob::wasAborted() const
 {
     QMutexLocker locker( m_mutex );
     return m_aborted;
 }
 
 QString DebuggerJob::explanation() const
 {
     QMutexLocker locker( m_mutex );
     return m_explanation;
 }
 
 const ServiceProviderData DebuggerJob::providerData() const
 {
     QMutexLocker locker( m_mutex );
     return m_data.provider;
 }
 
 void DebuggerJob::debugStepInto( int repeat )
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->debugStepInto( repeat );
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::abortDebugger()
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->abortDebugger();
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::addBreakpoint( const Breakpoint &breakpoint )
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->addBreakpoint( breakpoint );
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::checkExecution()
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->checkExecution();
     }
 }
 
 void DebuggerJob::debugContinue()
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->debugContinue();
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::debugInterrupt()
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->debugInterrupt();
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::debugRunUntilLineNumber( const QString &fileName, int lineNumber )
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->debugRunUntilLineNumber( fileName, lineNumber );
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::debugStepOut( int repeat )
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->debugStepOut( repeat );
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::debugStepOver( int repeat )
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->debugStepOver( repeat );
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::removeBreakpoint( const Breakpoint &breakpoint )
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->removeBreakpoint( breakpoint );
     } else {
-        kWarning() << "Debugger already deleted";
+        qWarning() << "Debugger already deleted";
     }
 }
 
 void DebuggerJob::slotOutput( const QString &outputString, const QScriptContextInfo &contextInfo )
 {
     QMutexLocker locker( m_mutex );
     if ( m_agent ) {
         m_agent->slotOutput( outputString, contextInfo );
     }
 }
 
 NextEvaluatableLineHint DebuggerJob::canBreakAt( const QString &fileName, int lineNumber ) const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? CannotFindNextEvaluatableLine
                        : m_agent->canBreakAt(fileName, lineNumber);
 }
 
 int DebuggerJob::getNextBreakableLineNumber( const QString &fileName, int lineNumber ) const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? -1 : m_agent->getNextBreakableLineNumber(fileName, lineNumber);
 }
 
 void DebuggerJob::finish() const
 {
     DEBUG_JOBS("Wait for the job to finish...");
     m_mutex->lockInline();
     if ( m_agent ) {
         m_agent->finish();
     }
 
     if ( !isFinished() ) {
         QEventLoop loop;
         connect( this, SIGNAL(done(ThreadWeaver::Job*)), &loop, SLOT(quit()) );
         m_mutex->unlockInline();
 
         loop.exec();
     } else {
         m_mutex->unlockInline();
     }
     DEBUG_JOBS("...job finished");
 }
 
 bool DebuggerJob::isAborting() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? false : m_agent->isAborting();
 }
 
 bool DebuggerJob::isInterrupted() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? false : m_agent->isInterrupted();
 }
 
 bool DebuggerJob::isRunning() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? false : m_agent->isRunning();
 }
 
 bool DebuggerJob::isEvaluating() const
 {
     QMutexLocker locker( m_mutex );
     if ( !m_agent ) {
         return false;
     }
 
     m_engineSemaphore->acquire();
     const bool result = !m_agent || !m_agent->engine() ? false : m_agent->engine()->isEvaluating();
     m_engineSemaphore->release();
     return result;
 }
 
 bool DebuggerJob::canEvaluate( const QString &program ) const
 {
     QMutexLocker locker( m_mutex );
     m_engineSemaphore->acquire();
     const bool result = m_agent->engine()->canEvaluate( program );
     m_engineSemaphore->release();
     return result;
 }
 
 DebuggerState DebuggerJob::state() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? NotRunning : m_agent->state();
 }
 
 QString DebuggerJob::currentSourceFile() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? QString() : m_agent->currentSourceFile();
 }
 
 int DebuggerJob::lineNumber() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? -1 : m_agent->lineNumber();
 }
 
 int DebuggerJob::columnNumber() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? -1 : m_agent->columnNumber();
 }
 
 bool DebuggerJob::hasUncaughtException() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? false : m_agent->hasUncaughtException();
 }
 
 int DebuggerJob::uncaughtExceptionLineNumber() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? -1 : m_agent->uncaughtExceptionLineNumber();
 }
 
 QScriptValue DebuggerJob::uncaughtException() const
 {
     QMutexLocker locker( m_mutex );
     return !m_agent ? QScriptValue() : m_agent->uncaughtException();
 }
 
 ForeignAgentJob::ForeignAgentJob( const ScriptData &scriptData, const QString &useCase,
                                   DebuggerJob *parentJob, QObject *parent )
         : DebuggerJob(scriptData, useCase, parent), m_parentJob(QPointer<DebuggerJob>(parentJob))
 {
     if ( parentJob ) {
         QMutexLocker locker( m_mutex );
         if ( m_engineSemaphore ) {
             delete m_engineSemaphore;
         }
         m_engineSemaphore = parentJob->engineSemaphore();
         m_agent = parentJob->debuggerAgent();
         m_objects = parentJob->objects();
     }
 }
 
 ExecuteConsoleCommandJob::ExecuteConsoleCommandJob( const ScriptData &data,
         const ConsoleCommand &command, const QString &useCase, DebuggerJob *parentJob,
         QObject *parent )
         : ForeignAgentJob(data, useCase, parentJob, parent), m_command(command)
 {
 }
 
 EvaluateInContextJob::EvaluateInContextJob( const ScriptData &data, const QString &program,
         const QString &context, const QString &useCase, DebuggerJob *parentJob, QObject *parent )
         : ForeignAgentJob(data, useCase, parentJob, parent),
           m_program(program), m_context(QString(context).replace('\n', ' '))
 {
 }
 
 void DebuggerJob::moveScriptObjectsToThread( QThread *thread )
 {
     QMutexLocker locker( m_mutex );
     m_scriptObjectTargetThread = thread;
     // The agent lives in the thread that gets executed by this job,
     // connect directly to do something in the thread of the agent
     connect( m_agent, SIGNAL(doSomething()), this, SLOT(doSomething()), Qt::DirectConnection );
     m_agent->continueToDoSomething();
 }
 
 void DebuggerJob::doSomething()
 {
     QMutexLocker locker( m_mutex );
     Q_ASSERT( QThread::currentThread() == m_agent->thread() );
     disconnect( m_agent, SIGNAL(doSomething()), this, SLOT(doSomething()) );
     QThread *targetThread = m_scriptObjectTargetThread;
     if ( !targetThread ) {
         // Nothing to do
         return;
     }
 
     // Move script objects to thread
     m_engineSemaphore->acquire();
     connectScriptObjects( false );
     connectAgent( m_agent, false, false );
 
     Q_ASSERT( m_objects.isValid() );
     m_objects.moveToThread( targetThread );
     m_scriptObjectTargetThread = 0;
     m_engineSemaphore->release();
 
     emit movedScriptObjectsToThread( targetThread );
 }
 
 void DebuggerJob::gotScriptObjectsBack()
 {
     QMutexLocker locker( m_mutex );
     connectScriptObjects();
     connectAgent( m_agent, true, false );
 
     // Continue to update variables
     m_agent->continueToDoSomething();
 }
 
 } // namespace Debugger
diff --git a/engine/timetablemate/src/debugger/timetabledatarequestjob.cpp b/engine/timetablemate/src/debugger/timetabledatarequestjob.cpp
index 1a325ac..fcd0fb3 100644
--- a/engine/timetablemate/src/debugger/timetabledatarequestjob.cpp
+++ b/engine/timetablemate/src/debugger/timetabledatarequestjob.cpp
@@ -1,1126 +1,1126 @@
 /*
  *   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 "timetabledatarequestjob.h"
 
 // Own includes
 #include "debuggeragent.h"
 
 // Public Transport engine includes
 #include <engine/script/serviceproviderscript.h>
 #include <engine/global.h>
 #include <engine/serviceprovider.h>
 #include <engine/request.h>
 
 // KDE includes
 #include <KDebug>
 #include <KLocalizedString>
 #include <KGlobal>
 #include <KLocale>
 #include <KGlobalSettings>
 #include <ThreadWeaver/Thread>
 
 // Qt includes
 #include <QEventLoop>
 #include <QTimer>
 #include <QFileInfo>
 #include <QWaitCondition>
 #include <QSemaphore>
 #include <QApplication>
 
 namespace Debugger {
 
 CallScriptFunctionJob::CallScriptFunctionJob( const ScriptData &scriptData,
         const QString &functionName, const QVariantList &arguments, const QString &useCase,
         DebugFlags debugFlags, QObject *parent )
         : DebuggerJob(scriptData, useCase, parent), m_debugFlags(debugFlags),
           m_functionName(functionName), m_arguments(arguments)
 {
 }
 
 CallScriptFunctionJob::CallScriptFunctionJob( const ScriptData &scriptData, const QString &useCase,
                                               DebugFlags debugFlags, QObject *parent )
         : DebuggerJob(scriptData, useCase, parent), m_debugFlags(debugFlags)
 {
 }
 
 TestFeaturesJob::TestFeaturesJob( const ScriptData &scriptData, const QString &useCase,
                                   DebugFlags debugFlags, QObject *parent )
         : CallScriptFunctionJob(scriptData, ServiceProviderScript::SCRIPT_FUNCTION_FEATURES,
                                 QVariantList(), useCase, debugFlags, parent)
 {
 }
 
 TimetableDataRequestJob::TimetableDataRequestJob( const ScriptData &scriptData,
         const AbstractRequest *request, const QString &useCase, DebugFlags debugFlags,
         QObject *parent )
         : CallScriptFunctionJob(scriptData, useCase, debugFlags, parent), m_request(request->clone())
 {
     QMutexLocker locker( m_mutex );
     switch ( request->parseMode() ) {
     case ParseForDepartures:
     case ParseForArrivals:
         m_functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETTIMETABLE;
         break;
     case ParseForAdditionalData:
         m_functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETADDITIONALDATA;
         break;
     case ParseForJourneysByDepartureTime:
     case ParseForJourneysByArrivalTime:
         m_functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETJOURNEYS;
         break;
     case ParseForStopSuggestions:
         m_functionName = ServiceProviderScript::SCRIPT_FUNCTION_GETSTOPSUGGESTIONS;
         break;
     default:
         // This should never happen, therefore no i18n
         m_explanation = "Unknown parse mode";
         m_success = false;
         return;
     }
 }
 
 QScriptValueList CallScriptFunctionJob::createArgumentScriptValues( DebuggerAgent *debugger ) const
 {
     // m_engineSemaphore is locked
     QMutexLocker locker( m_mutex );
     if ( !debugger ) {
         debugger = m_agent;
     }
 
     QScriptValueList args;
     QScriptEngine *engine = debugger->engine();
     foreach ( const QVariant &argument, m_arguments ) {
         args << engine->toScriptValue( argument );
     }
     return args;
 }
 
 QScriptValueList TimetableDataRequestJob::createArgumentScriptValues( DebuggerAgent *debugger ) const
 {
     // m_engineSemaphore is locked
     QMutexLocker locker( m_mutex );
     if ( !debugger ) {
         debugger = m_agent;
     }
     return QScriptValueList() << m_request->toScriptValue( debugger->engine() );
 }
 
 void TimetableDataRequestJob::finish( const QList<TimetableData> &data )
 {
     QMutexLocker locker( m_mutex );
     m_timetableData = data;
 }
 
 CallScriptFunctionJob::~CallScriptFunctionJob()
 {
 }
 
 TimetableDataRequestJob::~TimetableDataRequestJob()
 {
     QMutexLocker locker( m_mutex );
     delete m_request;
 }
 
 QVariant CallScriptFunctionJob::returnValue() const
 {
     QMutexLocker locker( m_mutex );
     return m_returnValue;
 }
 
 QList< Enums::ProviderFeature > TestFeaturesJob::features() const
 {
     QMutexLocker locker( m_mutex );
     return m_features;
 }
 
 QList<TimetableData> TimetableDataRequestJob::timetableData() const
 {
     QMutexLocker locker( m_mutex );
     return m_timetableData;
 }
 
 QSharedPointer< AbstractRequest > TimetableDataRequestJob::request() const
 {
     QMutexLocker locker( m_mutex );
     return QSharedPointer< AbstractRequest >( m_request->clone() );
 }
 
 QList< TimetableDataRequestMessage > CallScriptFunctionJob::additionalMessages() const
 {
     QMutexLocker locker( m_mutex );
     return m_additionalMessages;
 }
 
 QString CallScriptFunctionJob::functionName() const
 {
     QMutexLocker locker( m_mutex );
     return m_functionName;
 }
 
 DebugFlags CallScriptFunctionJob::debugFlags() const
 {
     QMutexLocker locker( m_mutex );
     return m_debugFlags;
 }
 
 QString CallScriptFunctionJob::toString() const
 {
     QMutexLocker locker( m_mutex );
     if ( m_returnValue.isValid() ) {
         QString valueString = m_returnValue.toString();
         if ( valueString.length() > 100 ) {
             valueString = valueString.left(100) + "...";
         } else if ( valueString.isEmpty() ) {
             valueString = "undefined";
         }
         return QString("%1 (%2() = %3)").arg( DebuggerJob::toString() )
                 .arg( m_functionName ).arg( valueString );
     } else {
         return QString("%1 (%2())").arg( DebuggerJob::toString() ).arg( m_functionName );
     }
 }
 
 QString CallScriptFunctionJob::defaultUseCase() const
 {
     QMutexLocker locker( m_mutex );
     return i18nc("@info", "Call function <icode>%1()</icode>", m_functionName);
 }
 
 QString TimetableDataRequestJob::defaultUseCase() const
 {
     QMutexLocker locker( m_mutex );
     return i18nc("@info", "Call function <icode>%1( %2 )</icode>",
                  m_functionName, m_request->argumentsString());
 }
 
 bool TestFeaturesJob::testResults()
 {
     QMutexLocker locker( m_mutex );
     if ( !m_returnValue.isValid() ) {
         return false;
     }
 
     const QVariantList items = m_returnValue.toList();
     if ( items.isEmpty() ) {
         m_additionalMessages << TimetableDataRequestMessage(
                 i18nc("@info/plain", "No provider features returned"),
                 TimetableDataRequestMessage::Warning );
     } else {
         int i = 1;
         foreach ( const QVariant &item, items ) {
             const Enums::ProviderFeature feature =
                     static_cast< Enums::ProviderFeature >( item.toInt() );
             if ( feature == Enums::InvalidProviderFeature ) {
                 m_additionalMessages << TimetableDataRequestMessage(
                         i18nc("@info/plain", "Invalid ProviderFeature: '%1'",
                               item.toString()),
                         TimetableDataRequestMessage::Error );
             } else {
                 m_features << feature;
                 m_additionalMessages << TimetableDataRequestMessage(
                         QString("%1: %2").arg(i).arg(Enums::toString(feature)),
                         TimetableDataRequestMessage::Information );
             }
             ++i;
         }
     }
 
     return true;
 }
 
 void CallScriptFunctionJob::connectScriptObjects( bool doConnect )
 {
     DebuggerJob::connectScriptObjects( doConnect );
 
     QMutexLocker locker( m_mutex );
     if ( doConnect ) {
         // Connect to request finished signals to store the time spent for network requests
         connect( m_objects.network.data(), SIGNAL(requestFinished(NetworkRequest::Ptr,QByteArray,bool,QString,QDateTime,int,int)),
                  this, SLOT(requestFinished(NetworkRequest::Ptr,QByteArray,bool,QString,QDateTime,int,int)) );
         connect( m_objects.network.data(), SIGNAL(synchronousRequestFinished(QString,QByteArray,bool,int,int,int)),
                  this, SLOT(synchronousRequestFinished(QString,QByteArray,bool,int,int,int)) );
 
         // Connect to the messageReceived() signal of the "helper" script object to collect
         // messages sent to "helper.error()", "helper.warning()" or "helper.information()"
         connect( m_objects.helper.data(), SIGNAL(messageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)),
                  this, SLOT(slotScriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)) );
 
         connect( m_objects.result.data(), SIGNAL(invalidDataReceived(Enums::TimetableInformation,QString,QScriptContextInfo,int,QVariantMap)),
                  this, SLOT(invalidDataReceived(Enums::TimetableInformation,QString,QScriptContextInfo,int,QVariantMap)) );
 
         // Connect to the stopped() signal of the agent to get notified when execution gets aborted
         connect( m_agent, SIGNAL(stopped(QDateTime,bool,bool,int,QString,QStringList)),
                  this, SLOT(scriptStopped(QDateTime,bool,bool,int,QString,QStringList)) );
     } else {
         disconnect( m_objects.network.data(), SIGNAL(requestFinished(NetworkRequest::Ptr,QByteArray,bool,QString,QDateTime,int,int)),
                     this, SLOT(requestFinished(NetworkRequest::Ptr,QByteArray,bool,QString,QDateTime,int,int)) );
         disconnect( m_objects.network.data(), SIGNAL(synchronousRequestFinished(QString,QByteArray,bool,int,int,int)),
                     this, SLOT(synchronousRequestFinished(QString,QByteArray,bool,int,int,int)) );
         disconnect( m_objects.helper.data(), SIGNAL(messageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)),
                     this, SLOT(slotScriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)) );
         disconnect( m_objects.result.data(), SIGNAL(invalidDataReceived(Enums::TimetableInformation,QString,QScriptContextInfo,int,QVariantMap)),
                     this, SLOT(invalidDataReceived(Enums::TimetableInformation,QString,QScriptContextInfo,int,QVariantMap)) );
         disconnect( m_agent, SIGNAL(stopped(QDateTime,bool,bool,int,QString,QStringList)),
                     this, SLOT(scriptStopped(QDateTime,bool,bool,int,QString,QStringList)) );
     }
 }
 
 void CallScriptFunctionJob::debuggerRun()
 {
     m_mutex->lock();
     if ( !m_success ) {
         // Job already marked as not successful, a derived class may have set it to false
         m_mutex->unlock();
         return;
     }
     m_mutex->unlock();
 
     // Create new engine and agent
     m_engineSemaphore->acquire();
     DebuggerAgent *agent = createAgent();
     if ( !agent ) {
         m_engineSemaphore->release();
         return;
     }
     QScriptEngine *engine = agent->engine();
     m_mutex->lock();
     ScriptObjects objects = m_objects;
     const ScriptData data = m_data;
     const QString functionName = m_functionName;
     const DebugFlags debugFlags = m_debugFlags;
     m_mutex->unlock();
 
     // Load script
     engine->evaluate( *data.program );
     Q_ASSERT_X( !objects.network->hasRunningRequests() || !agent->engine()->isEvaluating(),
                 "LoadScriptJob::debuggerRun()",
                 "Evaluating the script should not start any asynchronous requests, bad script" );
 
     QScriptValue function = engine->globalObject().property( functionName );
     if ( !function.isFunction() ) {
         QMutexLocker locker( m_mutex );
         destroyAgent();
         m_engineSemaphore->release();
 
         m_explanation = i18nc("@info/plain", "Did not find a '%1' function in the script.",
                                functionName);
         m_success = false;
         return;
     }
 
     connectScriptObjects();
     agent->setExecutionControlType( debugFlags.testFlag(InterruptAtStart)
                                        ? ExecuteInterrupt : ExecuteRun );
     agent->setDebugFlags( debugFlags );
 
     // Make this job responsive while running the script
     engine->setProcessEventsInterval( 50 );
 
     // Call script function while the engine mutex is still locked
     const QScriptValueList arguments = createArgumentScriptValues( agent );
     const QVariant returnValue = function.call( QScriptValue(), arguments ).toVariant();
 
     // The called function returned, but asynchronous network requests may have been started.
     // Wait for all network requests to finish, because slots in the script may get called
     if ( !waitFor(objects.network.data(), SIGNAL(allRequestsFinished()), WaitForNetwork) ) {
         m_engineSemaphore->release();
         return;
     }
 
     // Wait for script execution to finish
     if ( !waitFor(this, SIGNAL(stopped(QDateTime,ScriptStoppedFlags,int,QString,QStringList)),
                   WaitForScriptFinish) )
     {
-        kWarning() << "Stopped signal not received";
+        qWarning() << "Stopped signal not received";
         m_engineSemaphore->release();
         return;
     }
     qApp->processEvents();
 
     const bool allNetworkRequestsFinished = !objects.network->hasRunningRequests();
     const bool finishedSuccessfully = !agent->wasLastRunAborted();
 
 //     GlobalTimetableInfo globalInfo;
 //     globalInfo.requestDate = QDate::currentDate();
 //     globalInfo.delayInfoAvailable =
 //             !m_scriptResult->isHintGiven( ResultObject::NoDelaysForStop );
 
     // Check for exceptions
     if ( finishedSuccessfully && agent->hasUncaughtException() ) {
         const QString uncaughtException = agent->uncaughtException().toString();
         handleError( engine, i18nc("@info/plain", "Error in the script at line %1"
                      "in function '%2': <message>%3</message>.",
                      agent->uncaughtExceptionLineNumber(), functionName, uncaughtException) );
         m_mutex->lockInline();
         destroyAgent();
         m_mutex->unlockInline();
         m_engineSemaphore->release();
         return;
     }
 
     // Unlock engine mutex after execution was finished
     m_engineSemaphore->release();
 
     m_mutex->lockInline();
     m_returnValue = returnValue;
     m_aborted = agent->wasLastRunAborted();
     bool quit = m_quit;
     m_mutex->unlockInline();
 
     if ( !quit ) {
         if ( functionName == ServiceProviderScript::SCRIPT_FUNCTION_GETADDITIONALDATA ) {
             const QVariantMap map = returnValue.toMap();
             TimetableData data;
             for ( QVariantMap::ConstIterator it = map.constBegin(); it != map.constEnd(); ++it ) {
                 data[ Global::timetableInformationFromString(it.key()) ] = it.value();
             }
             if ( !data.isEmpty() ) {
                 finish( QList<TimetableData>() << data );
             }
         } else {
             finish( objects.result->data() );
         }
     }
 
     // Process signals from the debugger before it gets deleted
     qApp->processEvents();
 
     QMutexLocker locker( m_mutex );
     m_engineSemaphore->acquire();
     destroyAgent();
     m_engineSemaphore->release();
 
     if ( !m_success || m_quit ) {
         m_success = false;
     } else if ( allNetworkRequestsFinished && finishedSuccessfully ) {
         // No uncaught exceptions, all network requests finished
         if ( m_aborted ) {
             m_success = false;
             m_explanation = i18nc("@info/plain", "Execution was aborted");
         } else {
             m_success = testResults();
         }
     } else if ( finishedSuccessfully ) {
         // The script finish successfully, but not all network requests finished
         m_explanation = i18nc("@info/plain", "Not all network requests were finished in time");
         m_success = false;
     } else if ( m_aborted ) {
         // Script was aborted
         m_explanation = i18nc("@info/plain", "Aborted");
         m_success = false;
     } else {
         // The script did not finish successfully,
         // ignore if not all network requests were finished here
         m_explanation = i18nc("@info/plain", "The script did not finish in time, "
                                "there may be an infinite loop.");
         m_success = false;
     }
 
 }
 
 void CallScriptFunctionJob::scriptStopped( const QDateTime &timestamp, bool aborted,
                                            bool hasRunningRequests, int uncaughtExceptionLineNumber,
                                            const QString &uncaughtException,
                                            const QStringList &backtrace )
 {
     Q_UNUSED( timestamp );
     Q_UNUSED( hasRunningRequests );
     if ( aborted ) {
         handleError( uncaughtExceptionLineNumber, uncaughtException, backtrace,
                      i18nc("@info/plain", "Aborted") );
     }
 }
 
 void CallScriptFunctionJob::slotScriptMessageReceived( const QString &message,
                                                      const QScriptContextInfo &context,
                                                      const QString &failedParseText,
                                                      Helper::ErrorSeverity severity )
 {
     Q_UNUSED( failedParseText );
     TimetableDataRequestMessage::Type type;
     switch ( severity ) {
     case Helper::Warning:
         type = TimetableDataRequestMessage::Warning;
         break;
     case Helper::Fatal:
         type = TimetableDataRequestMessage::Error;
         break;
     default:
     case Helper::Information:
         type = TimetableDataRequestMessage::Information;
         break;
     }
 
     QMutexLocker locker( m_mutex );
     const TimetableDataRequestMessage newMessage(
             i18nc("@info/plain", "Error in file <filename>%1</filename>, line %2: "
                   "<message>%3</message>",
                   QFileInfo(context.fileName()).fileName(), context.lineNumber(), message),
             type, context.fileName(), context.lineNumber() );
     if ( !m_additionalMessages.isEmpty() && m_additionalMessages.last() == newMessage ) {
         ++m_additionalMessages.last().repetitions;
     } else {
         m_additionalMessages << newMessage;
     }
 }
 
 void CallScriptFunctionJob::invalidDataReceived( Enums::TimetableInformation information,
                                                  const QString &message,
                                                  const QScriptContextInfo &context,
                                                  int index, const QVariantMap& map )
 {
     Q_UNUSED( information );
     Q_UNUSED( map );
 
     QMutexLocker locker( m_mutex );
     m_additionalMessages << TimetableDataRequestMessage(
             i18nc("@info/plain", "Invalid data in result %1, line %2: <message>%3</message>",
                   index + 1, context.lineNumber(), message),
             TimetableDataRequestMessage::Error, context.fileName(), context.lineNumber() );
 }
 
 void CallScriptFunctionJob::requestFinished( const NetworkRequest::Ptr &request,
                                              const QByteArray &data,
                                              bool error, const QString &errorString,
                                              const QDateTime &timestamp, int statusCode, int size )
 {
     Q_UNUSED( data );
     emit asynchronousRequestWaitFinished( timestamp, statusCode, size );
 
     QMutexLocker locker( m_mutex );
     if ( error ) {
         m_additionalMessages << TimetableDataRequestMessage(
                 i18nc("@info/plain", "Download failed (<message>%1</message>): <link>%2</link>",
                       errorString, request->url()),
                 TimetableDataRequestMessage::Information, QString(), -1,
                 TimetableDataRequestMessage::OpenLink, request->url() );
     } else {
         m_additionalMessages << TimetableDataRequestMessage(
                 i18nc("@info/plain", "Download finished (status %1): %2, <link>%3</link>",
                       statusCode, KGlobal::locale()->formatByteSize(size), request->url()),
                 TimetableDataRequestMessage::Information, QString(), -1,
                 TimetableDataRequestMessage::OpenLink, request->url() );
     }
 }
 
 void CallScriptFunctionJob::synchronousRequestFinished( const QString &url, const QByteArray &data,
                                                         bool cancelled, int statusCode,
                                                         int waitingTime, int size )
 {
     Q_UNUSED(data);
     emit synchronousRequestWaitFinished( statusCode, waitingTime, size );
 
     QMutexLocker locker( m_mutex );
     if ( cancelled ) {
         m_additionalMessages << TimetableDataRequestMessage(
                 i18nc("@info/plain", "Download cancelled/failed (status %1): <link>%2</link>",
                       statusCode, url),
                 TimetableDataRequestMessage::Warning, QString(), -1,
                 TimetableDataRequestMessage::OpenLink, url );
     } else {
         m_additionalMessages << TimetableDataRequestMessage(
                 i18nc("@info/plain", "Download finished (status %1): %2, <link>%3</link>",
                       statusCode, KGlobal::locale()->formatByteSize(size), url),
                 TimetableDataRequestMessage::Information, QString(), -1,
                 TimetableDataRequestMessage::OpenLink, url );
     }
 }
 
 bool TimetableDataRequestJob::testResults()
 {
     QMutexLocker locker( m_mutex );
     const AbstractRequest *request = m_request;
     const DepartureRequest *departureRequest =
             dynamic_cast< const DepartureRequest* >( request );
     if ( departureRequest ) {
         return testDepartureData( departureRequest );
     }
 
     const StopSuggestionRequest *stopSuggestionRequest =
             dynamic_cast< const StopSuggestionRequest* >( request );
     if ( stopSuggestionRequest ) {
         return testStopSuggestionData( stopSuggestionRequest );
     }
 
     const StopsByGeoPositionRequest *stopsByGeoPositionRequest =
             dynamic_cast< const StopsByGeoPositionRequest* >( request );
     if ( stopsByGeoPositionRequest ) {
         return testStopSuggestionData( stopsByGeoPositionRequest );
     }
 
     const JourneyRequest *journeyRequest =
             dynamic_cast< const JourneyRequest* >( request );
     if ( journeyRequest ) {
         return testJourneyData( journeyRequest );
     }
 
     const AdditionalDataRequest *additinalDataRequest =
             dynamic_cast< const AdditionalDataRequest* >( request );
     if ( additinalDataRequest ) {
         return testAdditionalData( additinalDataRequest );
     }
 
     return false;
 }
 
 TimetableDataRequestMessage CallScriptFunctionJob::message( MessageType messageType,
         Enums::TimetableInformation info1, Enums::TimetableInformation info2, int count1, int count2,
         TimetableDataRequestMessage::Type type, const QString &fileName, int lineNumber )
 {
     QString msg;
     switch ( messageType ) {
     case NotSameNumberOfItems:
         msg = i18nc("@info/plain", "'%1' should contain the same number of elements like '%3'. "
                     "Found %2 values for '%1' and %4 values for '%3'",
                     Global::timetableInformationToString(info1), count1,
                     Global::timetableInformationToString(info2), count2);
         break;
     case NotOneItemLessThan:
         msg = i18nc("@info/plain", "'%1' should contain one element less than '%3'. "
                     "Found %2 values for '%1' and %4 values for '%3'",
                     Global::timetableInformationToString(info1), count1,
                     Global::timetableInformationToString(info2), count2);
         break;
     default:
-        kWarning() << "Unknown message type" << messageType;
+        qWarning() << "Unknown message type" << messageType;
         break;
     }
 
     return TimetableDataRequestMessage( msg, type, fileName, lineNumber );
 }
 
 bool TimetableDataRequestJob::testAdditionalData( const AdditionalDataRequest *request )
 {
     Q_UNUSED(request);
 
     QMutexLocker locker( m_mutex );
     if ( m_timetableData.isEmpty() ) {
         m_explanation = i18nc("@info/plain", "No additional data found");
         return false;
     }
 
     const TimetableData timetableData = m_timetableData.first();
     for ( TimetableData::ConstIterator it = timetableData.constBegin();
           it != timetableData.constEnd(); ++it )
     {
         const bool isValid = Global::checkTimetableInformation( it.key(), it.value() );
         QString info;
         if ( it->canConvert(QVariant::List) ) {
             const QVariantList list = it->toList();
             QStringList elements;
             foreach ( const QVariant &item, list ) {
                 elements << item.toString();
             }
             info = "[" + elements.join(", ") + "]";
         } else {
             info = it->toString();
         }
         m_additionalMessages << TimetableDataRequestMessage(
                 QString("%1%2: %3")
                 .arg(Global::timetableInformationToString(it.key()))
                 .arg(isValid ? QString() : (' ' + i18nc("@info/plain", "(invalid)")))
                 .arg(info),
                 isValid ? TimetableDataRequestMessage::Information
                         : TimetableDataRequestMessage::Warning );
     }
     return true;
 }
 
 bool TimetableDataRequestJob::testDepartureData( const DepartureRequest *request )
 {
     QMutexLocker locker( m_mutex );
     if ( m_timetableData.isEmpty() ) {
         if ( request->parseMode() == ParseForArrivals ) {
             m_explanation = i18nc("@info/plain", "No arrivals found");
         } else {
             m_explanation = i18nc("@info/plain", "No departures found");
         }
         return false;
     }
 
     // Get global information
     QStringList globalInfos;
     if ( m_returnValue.isValid() ) {
         globalInfos = m_returnValue.toStringList();
     }
 
     // Get result set
     int countInvalid = 0;
     QDate curDate;
     QTime lastTime;
     for ( int i = 0; i < m_timetableData.count(); ++ i ) {
         TimetableData timetableData = m_timetableData[ i ];
         QDateTime departureDateTime = timetableData.value( Enums::DepartureDateTime ).toDateTime();
         if ( !departureDateTime.isValid() ) {
             QDate date = timetableData.value( Enums::DepartureDate ).toDate();
             QTime departureTime;
             if ( timetableData.values().contains(departureTime) ) {
                 QVariant timeValue = timetableData.value( Enums::DepartureTime );
                 if ( timeValue.canConvert(QVariant::Time) ) {
                     departureTime = timeValue.toTime();
                 } else {
                     departureTime = QTime::fromString( timeValue.toString(), "hh:mm:ss" );
                     if ( !departureTime.isValid() ) {
                         departureTime = QTime::fromString( timeValue.toString(), "hh:mm" );
                     }
                 }
             }
             if ( !date.isValid() ) {
                 if ( curDate.isNull() ) {
                     // First departure
                     if ( QTime::currentTime().hour() < 3 && departureTime.hour() > 21 )
                         date = QDate::currentDate().addDays( -1 );
                     else if ( QTime::currentTime().hour() > 21 && departureTime.hour() < 3 )
                         date = QDate::currentDate().addDays( 1 );
                     else
                         date = QDate::currentDate();
                 } else if ( lastTime.secsTo(departureTime) < -5 * 60 ) {
                     // Time too much ealier than last time, estimate it's tomorrow
                     date = curDate.addDays( 1 );
                 } else {
                     date = curDate;
                 }
             }
 
             departureDateTime = QDateTime( date, departureTime );
             timetableData.insert( Enums::DepartureDateTime, departureDateTime );
         }
 
         curDate = departureDateTime.date();
         lastTime = departureDateTime.time();
 
         const bool isValid = timetableData.contains(Enums::TransportLine) &&
                              timetableData.contains(Enums::Target) &&
                              timetableData.contains(Enums::DepartureDateTime);
         if ( !isValid ) {
             ++countInvalid;
             m_additionalMessages << TimetableDataRequestMessage(
                     i18nc("@info/plain", "Data missing in result %1, required are TransportLine, "
                           "Target and at least a departure time (better also a date)", i),
                     TimetableDataRequestMessage::Error );
         }
 
         m_additionalMessages << TimetableDataRequestMessage(
                 QString("%1: %2 (%3, %4), %5").arg(i + 1)
                 .arg(timetableData[Enums::TransportLine].toString())
                 .arg(Enums::toString(static_cast<Enums::VehicleType>(timetableData[Enums::TypeOfVehicle].toInt())))
                 .arg(timetableData[Enums::DepartureDateTime].toDateTime().time().toString(Qt::DefaultLocaleShortDate))
                 .arg(timetableData[Enums::Target].toString()),
                 isValid ? TimetableDataRequestMessage::Information
                         : TimetableDataRequestMessage::Warning );
     }
 
     bool success = true;
     for ( int i = 0; i < m_timetableData.count(); ++i ) {
         TimetableData values = m_timetableData[i];
 
         // If RouteStops data is available test it and associated TimetableInformation values
         if ( values.contains(Enums::RouteStops) && !values[Enums::RouteStops].toStringList().isEmpty() ) {
             // Check if RouteTimesDeparture has one element less than RouteStops
             // and if RouteTimesDepartureDelay has the same number of elements as RouteStops (if set)
             const QStringList routeStops = values[Enums::RouteStops].toStringList();
             if ( values.contains(Enums::RouteTimes) && !values[Enums::RouteTimes].toList().isEmpty() ) {
                 const QVariantList routeTimes = values[Enums::RouteTimes].toList();
                 if ( routeTimes.count() != routeStops.count() ) {
                     m_additionalMessages << message( NotSameNumberOfItems, Enums::RouteTimes, Enums::RouteStops,
                                                      routeTimes.count(), routeStops.count() );
                     success = false;
                 }
 
                 if ( values.contains(Enums::RouteTimesDepartureDelay) &&
                      !values[Enums::RouteTimesDepartureDelay].toStringList().isEmpty() )
                 {
                     const QStringList routeTimesDepartureDelay =
                         values[Enums::RouteTimesDepartureDelay].toStringList();
                     if ( routeTimesDepartureDelay.count() != routeTimes.count() ) {
                         m_additionalMessages << message( NotSameNumberOfItems,
                                 Enums::RouteTimesDepartureDelay, Enums::RouteTimes,
                                 routeTimesDepartureDelay.count(), routeTimes.count() );
                         success = false;
                     }
                 }
             }
 
             if ( values.contains(Enums::RouteTypesOfVehicles) &&
                  !values[Enums::RouteTypesOfVehicles].toList().isEmpty() )
             {
                 const QVariantList routeTypesOfVehicles = values[Enums::RouteTypesOfVehicles].toList();
                 if ( routeTypesOfVehicles.count() != routeStops.count() - 1 ) {
                     m_additionalMessages << message( NotOneItemLessThan, Enums::RouteTypesOfVehicles,
                             Enums::RouteStops, routeTypesOfVehicles.count(), routeStops.count() );
                     success = false;
                 }
             }
 
             // Check if RoutePlatformsDeparture has one element less than RouteStops
             if ( values.contains(Enums::RoutePlatformsDeparture) &&
                  !values[Enums::RoutePlatformsDeparture].toStringList().isEmpty() )
             {
                 const QStringList routePlatformsDeparture =
                         values[Enums::RoutePlatformsDeparture].toStringList();
                 if ( routePlatformsDeparture.count() != routeStops.count() - 1 ) {
                     m_additionalMessages << message( NotOneItemLessThan, Enums::RoutePlatformsDeparture,
                             Enums::RouteStops, routePlatformsDeparture.count(), routeStops.count() );
                     success = false;
                 }
             }
 
             // Check if RoutePlatformsArrival has one element less than RouteStops
             if ( values.contains(Enums::RoutePlatformsArrival) &&
                  !values[Enums::RoutePlatformsArrival].toStringList().isEmpty() )
             {
                 const QStringList routePlatformsArrival =
                         values[Enums::RoutePlatformsArrival].toStringList();
                 if ( routePlatformsArrival.count() != routeStops.count() - 1 ) {
                     m_additionalMessages << message( NotOneItemLessThan, Enums::RoutePlatformsArrival,
                             Enums::RouteStops, routePlatformsArrival.count(), routeStops.count() );
                     success = false;
                 }
             }
         } else { // values does not contain RouteStops
             QList< Enums::TimetableInformation > infos;
             infos << Enums::RouteTimes << Enums::RoutePlatformsDeparture << Enums::RoutePlatformsArrival
                   << Enums::RouteExactStops << Enums::RouteStopsShortened << Enums::RouteTypesOfVehicles
                   << Enums::RouteTransportLines;
             foreach ( Enums::TimetableInformation info, infos ) {
                 if ( values.contains(info) ) {
                     m_additionalMessages << TimetableDataRequestMessage( i18nc("@info/plain",
                             "'%1' data ignored, because data for 'RouteStops' is missing.",
                             Global::timetableInformationToString(info)),
                             TimetableDataRequestMessage::Warning );
                     success = false;
                 }
             }
         }
     }
 
     // Show results
     if ( request->parseMode() == ParseForArrivals ) {
         m_explanation = i18ncp("@info/plain", "Got %1 arrival",
                                               "Got %1 arrivals", m_timetableData.count());
     } else {
         m_explanation = i18ncp("@info/plain", "Got %1 departure",
                                               "Got %1 departures", m_timetableData.count());
     }
 
     if ( countInvalid > 0 ) {
         if ( request->parseMode() == ParseForArrivals ) {
             m_explanation += ", " +
                     i18ncp("@info/plain", "<warning>%1 arrival is invalid</warning>",
                            "<warning>%1 arrivals are invalid</warning>",
                            countInvalid);
         } else {
             m_explanation += ", " +
                     i18ncp("@info/plain", "<warning>%1 departure is invalid</warning>",
                            "<warning>%1 departures are invalid</warning>",
                            countInvalid);
         }
         return false;
     }
     if ( globalInfos.contains("no delays", Qt::CaseInsensitive) ) {
         // No delay information available for the given stop
         m_explanation += ", " +
                 i18nc("@info/plain", "Got the information from the script that there "
                       "is no delay information available for the given stop.");
     }
 
     return success;
 }
 
 bool TimetableDataRequestJob::testStopSuggestionData(
         const StopSuggestionRequest *request )
 {
     Q_UNUSED( request );
     QMutexLocker locker( m_mutex );
     if ( m_timetableData.isEmpty() ) {
         m_explanation = i18nc("@info/plain", "No stop suggestions found");
         return false;
     }
 
     // Get global information
     QStringList globalInfos;
     if ( m_returnValue.isValid() ) {
         globalInfos = m_returnValue.toStringList();
     }
 
     // Test timetable data
     int countInvalid = 0;
     int i = 1;
     foreach ( const TimetableData &timetableData, m_timetableData ) {
         const bool isValid = !timetableData[Enums::StopName].toString().isEmpty();
         if ( !isValid ) {
             ++countInvalid;
         }
 
         QString info = timetableData[Enums::StopName].toString();
         if ( info.length() > 50 ) {
             info = info.left(50) + "...";
         }
         if ( timetableData.contains(Enums::StopID) ) {
             info += ", ID: " + timetableData[Enums::StopID].toString();
         }
         if ( timetableData.contains(Enums::StopWeight) ) {
             info += ", weight: " + timetableData[Enums::StopWeight].toString();
         }
         if ( timetableData.contains(Enums::StopCity) ) {
             info += ", city: " + timetableData[Enums::StopCity].toString();
         }
         if ( timetableData.contains(Enums::StopLongitude) ) {
             info += ", longitude: " + timetableData[Enums::StopLongitude].toString();
         }
         if ( timetableData.contains(Enums::StopLatitude) ) {
             info += ", latitude: " + timetableData[Enums::StopLatitude].toString();
         }
         m_additionalMessages << TimetableDataRequestMessage(
                 QString("%1%2: %3").arg(i)
                 .arg(isValid ? QString() : (' ' + i18nc("@info/plain", "(invalid)")))
                 .arg(info),
                 isValid ? TimetableDataRequestMessage::Information
                         : TimetableDataRequestMessage::Warning );
         ++i;
     }
 
     // Show results
     m_explanation = i18ncp("@info/plain", "Got %1 stop suggestion",
                                           "Got %1 stop suggestions", m_timetableData.count());
     if ( countInvalid > 0 ) {
         m_explanation += ", " +
                 i18ncp("@info/plain", "<warning>%1 stop suggestion is invalid</warning>",
                                       "<warning>%1 stop suggestions are invalid</warning>",
                                       countInvalid);
         return false;
     }
 
     return true;
 }
 
 bool TimetableDataRequestJob::testJourneyData( const JourneyRequest *request )
 {
     Q_UNUSED( request );
     QMutexLocker locker( m_mutex );
     if ( m_timetableData.isEmpty() ) {
         m_explanation = i18nc("@info/plain", "No journeys found");
         return false;
     }
 
     // Get global information
     QStringList globalInfos;
     if ( m_returnValue.isValid() ) {
         globalInfos = m_returnValue.toStringList();
     }
 
     m_explanation = i18ncp("@info/plain", "Got %1 journey",
                                           "Got %1 journeys", m_timetableData.count());
 
     // Get result set
     int countInvalid = 0;
     QDate curDate;
     QTime lastTime;
     for ( int i = 0; i < m_timetableData.count(); ++ i ) {
         TimetableData timetableData = m_timetableData[ i ];
         QDateTime departureDateTime = timetableData.value( Enums::DepartureDateTime ).toDateTime();
         if ( !departureDateTime.isValid() ) {
             QDate date = timetableData.value( Enums::DepartureDate ).toDate();
             QTime departureTime;
             if ( timetableData.values().contains(Enums::DepartureTime) ) {
                 QVariant timeValue = timetableData[ Enums::DepartureTime ];
                 if ( timeValue.canConvert(QVariant::Time) ) {
                     departureTime = timeValue.toTime();
                 } else {
                     departureTime = QTime::fromString( timeValue.toString(), "hh:mm:ss" );
                     if ( !departureTime.isValid() ) {
                         departureTime = QTime::fromString( timeValue.toString(), "hh:mm" );
                     }
                 }
             }
             if ( !date.isValid() ) {
                 if ( curDate.isNull() ) {
                     // First departure
                     if ( QTime::currentTime().hour() < 3 && departureTime.hour() > 21 )
                         date = QDate::currentDate().addDays( -1 );
                     else if ( QTime::currentTime().hour() > 21 && departureTime.hour() < 3 )
                         date = QDate::currentDate().addDays( 1 );
                     else
                         date = QDate::currentDate();
                 } else if ( lastTime.secsTo(departureTime) < -5 * 60 ) {
                     // Time too much ealier than last time, estimate it's tomorrow
                     date = curDate.addDays( 1 );
                 } else {
                     date = curDate;
                 }
             }
 
             departureDateTime = QDateTime( date, departureTime );
             timetableData.insert( Enums::DepartureDateTime, departureDateTime );
         }
 
         QDateTime arrivalDateTime = timetableData[ Enums::ArrivalDateTime ].toDateTime();
         if ( !departureDateTime.isValid() ) {
             QDate date = timetableData[ Enums::ArrivalDate ].toDate();
             QTime arrivalTime;
             if ( timetableData.contains(Enums::ArrivalTime) ) {
                 QVariant timeValue = timetableData[ Enums::ArrivalTime ];
                 if ( timeValue.canConvert(QVariant::Time) ) {
                     arrivalTime = timeValue.toTime();
                 } else {
                     arrivalTime = QTime::fromString( timeValue.toString(), "hh:mm:ss" );
                     if ( !arrivalTime.isValid() ) {
                         arrivalTime = QTime::fromString( timeValue.toString(), "hh:mm" );
                     }
                 }
             }
             if ( !date.isValid() ) {
                 date = departureDateTime.date();
             }
 
             arrivalDateTime = QDateTime( date, arrivalTime );
             if ( arrivalDateTime < departureDateTime ) {
                 arrivalDateTime = arrivalDateTime.addDays( 1 );
             }
             timetableData.insert( Enums::ArrivalDateTime, arrivalDateTime );
         }
 
         curDate = departureDateTime.date();
         lastTime = departureDateTime.time();
 
         bool isValid = timetableData.contains(Enums::StartStopName) &&
                        timetableData.contains(Enums::TargetStopName) &&
                        timetableData.contains(Enums::DepartureDateTime) &&
                        timetableData.contains(Enums::ArrivalDateTime);
         if ( !isValid ) {
             ++countInvalid;
         }
 
         m_additionalMessages << TimetableDataRequestMessage(
                 QString("%1: %2 (%3) - %4 (%5), %6 route stops").arg(i + 1)
                 .arg(timetableData[Enums::StartStopName].toString())
                 .arg(timetableData[Enums::DepartureDateTime].toDateTime().time().toString(Qt::DefaultLocaleShortDate))
                 .arg(timetableData[Enums::TargetStopName].toString())
                 .arg(timetableData[Enums::ArrivalDateTime].toDateTime().time().toString(Qt::DefaultLocaleShortDate))
                 .arg(timetableData[Enums::RouteStops].toStringList().count()),
                 isValid ? TimetableDataRequestMessage::Information
                         : TimetableDataRequestMessage::Error );
     }
 
     bool success = true;
     for ( int i = 0; i < m_timetableData.count(); ++i ) {
         TimetableData values = m_timetableData[i];
         if ( values.contains(Enums::RouteStops) && !values[Enums::RouteStops].toStringList().isEmpty() ) {
             // Check if RouteTimesDeparture has one element less than RouteStops
             // and if RouteTimesDepartureDelay has the same number of elements as RouteStops (if set)
             const QStringList routeStops = values[Enums::RouteStops].toStringList();
             if ( values.contains(Enums::RouteTimesDeparture) &&
                  !values[Enums::RouteTimesDeparture].toStringList().isEmpty() )
             {
                 const QStringList routeTimesDeparture = values[Enums::RouteTimesDeparture].toStringList();
                 if ( routeTimesDeparture.count() != routeStops.count() - 1 ) {
                     m_additionalMessages << message( NotOneItemLessThan, Enums::RouteTimesDeparture,
                             Enums::RouteStops, routeTimesDeparture.count(), routeStops.count() );
                     success = false;
                 }
 
                 if ( values.contains(Enums::RouteTimesDepartureDelay) &&
                      !values[Enums::RouteTimesDepartureDelay].toStringList().isEmpty() )
                 {
                     const QStringList routeTimesDepartureDelay =
                         values[Enums::RouteTimesDepartureDelay].toStringList();
                     if ( routeTimesDepartureDelay.count() != routeTimesDeparture.count() ) {
                         m_additionalMessages << message( NotSameNumberOfItems,
                                 Enums::RouteTimesDepartureDelay, Enums::RouteTimesDeparture,
                                 routeTimesDepartureDelay.count(), routeTimesDeparture.count() );
                         success = false;
                     }
                 }
             }
 
             // Check if RoutePlatformsDeparture has one element less than RouteStops
             if ( values.contains(Enums::RoutePlatformsDeparture)
                     && !values[Enums::RoutePlatformsDeparture].toStringList().isEmpty() )
             {
                 const QStringList routePlatformsArrival =
                         values[Enums::RoutePlatformsArrival].toStringList();
                 if ( routePlatformsArrival.count() != routeStops.count() - 1 ) {
                     m_additionalMessages << message( NotOneItemLessThan, Enums::RoutePlatformsArrival,
                             Enums::RouteStops, routePlatformsArrival.count(), routeStops.count() );
                     success = false;
                 }
             }
 
             // Check if RouteTimesArrival has one element less than RouteStops
             // and if RouteTimesArrivalDelay has the same number of elements as RouteStops (if set)
             if ( values.contains(Enums::RouteTimesArrival)
                     && !values[Enums::RouteTimesArrival].toStringList().isEmpty() )
             {
                 const QStringList routeTimesArrival = values[Enums::RouteTimesArrival].toStringList();
                 if ( routeTimesArrival.count() != routeStops.count() - 1 ) {
                     m_additionalMessages << message( NotOneItemLessThan, Enums::RouteTimesArrival,
                             Enums::RouteStops, routeTimesArrival.count(), routeStops.count() );
                     success = false;
                 }
 
                 if ( values.contains(Enums::RouteTimesArrivalDelay)
                         && !values[Enums::RouteTimesArrivalDelay].toStringList().isEmpty() )
                 {
                     const QStringList routeTimesArrivalDelay =
                         values[Enums::RouteTimesArrivalDelay].toStringList();
                     if ( routeTimesArrivalDelay.count() != routeTimesArrival.count() ) {
                         m_additionalMessages << message( NotSameNumberOfItems,
                                 Enums::RouteTimesArrivalDelay, Enums::RouteTimesArrival,
                                 routeTimesArrivalDelay.count(), routeTimesArrival.count() );
                         success = false;
                     }
                 }
             }
 
             // Check if RoutePlatformsArrival has one element less than RouteStops
             if ( values.contains(Enums::RoutePlatformsArrival)
                     && !values[Enums::RoutePlatformsArrival].toStringList().isEmpty() )
             {
                 const QStringList routePlatformsArrival =
                         values[Enums::RoutePlatformsArrival].toStringList();
                 if ( routePlatformsArrival.count() != routeStops.count() - 1 ) {
                     m_additionalMessages << message( NotOneItemLessThan, Enums::RoutePlatformsArrival,
                             Enums::RouteStops, routePlatformsArrival.count(), routeStops.count() );
                     success = false;
                 }
             }
         } else { // values does not contain RouteStops else { // values does not contain RouteStops
             QList< Enums::TimetableInformation > infos;
             infos << Enums::RouteTimes << Enums::RoutePlatformsDeparture << Enums::RoutePlatformsArrival
                   << Enums::RouteTimesArrival << Enums::RouteTimesArrivalDelay << Enums::RouteTimesDeparture
                   << Enums::RouteTimesDepartureDelay << Enums::RouteStopsShortened << Enums::RouteTypesOfVehicles
                   << Enums::RouteTransportLines;
             foreach ( Enums::TimetableInformation info, infos ) {
                 if ( values.contains(info) ) {
                     m_additionalMessages << TimetableDataRequestMessage( i18nc("@info/plain",
                             "'%1' data ignored, because data for 'RouteStops' is missing.",
                             Global::timetableInformationToString(info)),
                             TimetableDataRequestMessage::Warning  );
                     success = false;
                 }
             }
         }
     }
 
     return success;
 }
 
 } // namespace Debugger
diff --git a/engine/timetablemate/src/debugger/variablemodel.cpp b/engine/timetablemate/src/debugger/variablemodel.cpp
index 29af88f..b23cb0e 100644
--- a/engine/timetablemate/src/debugger/variablemodel.cpp
+++ b/engine/timetablemate/src/debugger/variablemodel.cpp
@@ -1,1317 +1,1317 @@
 /*
 *   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 "variablemodel.h"
 
 // Own includes
 #include "debuggerstructures.h"
 #include "debugger.h"
 
 // Public Transport engine includes
 #include <engine/script/serviceproviderscript.h>
 #include <engine/global.h>
 
 // KDE includes
 #include <KDebug>
 #include <KLocalizedString>
 #include <KColorScheme>
 #include <KGlobalSettings>
 #include <KStringHandler>
 
 // Qt includes
 #include <QScriptValueIterator>
 
 namespace Debugger
 {
 
 void VariableItemList::remove( const QString &name )
 {
     if ( !nameToVariable.contains(name) ) {
         kDebug() << "Name not contained" << name;
         return;
     }
 
     VariableItem *item = nameToVariable.take( name );
     variables.removeOne( item );
 }
 
 void VariableItemList::remove( const QStringList &names )
 {
     foreach ( const QString &name, names ) {
         remove( name );
     }
 }
 
 void VariableItemList::append( VariableItem *item )
 {
     const QString name = item->name();
     if ( nameToVariable.contains(name) ) {
         const int index = variables.indexOf( nameToVariable[name] );
         variables[ index ]->setValuesOf( item );
     } else {
         variables.append( item );
     }
     nameToVariable.insert( name, item );
 }
 
 void VariableItemList::append( const QList< VariableItem * >& items )
 {
     foreach ( VariableItem *item, items ) {
         append( item );
     }
 }
 
 void VariableItemList::append( const VariableItemList &items )
 {
     for( int i = 0; i < items.count(); ++i ) {
         append( items[i] );
     }
 }
 
 VariableItem *VariableItemList::takeAt( int index )
 {
     VariableItem *item = variables.takeAt( index );
     nameToVariable.remove( item->name() );
     return item;
 }
 
 bool VariableItem::isSimpleValueType() const
 {
     switch ( type() ) {
     case BooleanVariable:
     case NumberVariable:
     case StringVariable:
     case RegExpVariable:
         return true;
     case InvalidVariable:
     case NullVariable:
     case ErrorVariable:
     case FunctionVariable:
     case ArrayVariable:
     case ObjectVariable:
     case DateVariable:
     case SpecialVariable:
     default:
         return false;
     }
 }
 
 VariableModel::VariableModel( QObject *parent )
         : QAbstractItemModel( parent ), m_depthIndex(-1)
 {
 }
 
 VariableModel::~VariableModel()
 {
     while ( !m_variableStack.isEmpty() ) {
         popVariableStack();
     }
 }
 
 VariableItem::~VariableItem()
 {
     qDeleteAll( m_children.variables );
 }
 
 VariableItemList::~VariableItemList()
 {
 }
 
 QVariant VariableModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
     if ( orientation == Qt::Horizontal && role == Qt::DisplayRole ) {
         switch ( static_cast<Column>(section) ) {
         case NameColumn:
             return i18nc("@title:column", "Name");
         case ValueColumn:
             return i18nc("@title:column", "Value");
         default:
             return QVariant();
         }
     }
 
     return QVariant();
 }
 
 QString VariableItem::displayValueString() const
 {
     if ( !valueString().isEmpty() ) {
         return valueString();
     } else if ( !value().toString().isEmpty() ) {
         return value().toString();
     } else {
         return QString();
     }
 }
 
 QVariant VariableModel::data( const QModelIndex &index, int role ) const
 {
     if ( !index.isValid() ) {
         return QVariant();
     }
     if ( index.model() != this ) {
-        kWarning() << "Invalid model";
+        qWarning() << "Invalid model";
         return QVariant();
     }
 
     VariableItem *item = variableFromIndex( index );
     switch ( role ) {
     case Qt::DisplayRole:
         switch ( index.column() ) {
         case NameColumn:
             return item->name();
         case ValueColumn:
             return item->displayValueString();
         default:
-            kWarning() << "Unknown variable model column" << index.column();
+            qWarning() << "Unknown variable model column" << index.column();
             break;
         }
         break;
     case Qt::EditRole:
         switch ( index.column() ) {
         case ValueColumn:
             return item->completeValueString();
         default:
             break;
         }
         break;
     case Qt::DecorationRole:
         switch ( index.column() ) {
         case NameColumn:
             return item->icon();
         case ValueColumn:
         default:
             break;
         }
         break;
     case Qt::BackgroundRole:
         switch ( index.column() ) {
         case NameColumn:
         case ValueColumn: {
             KColorScheme::BackgroundRole role;
             switch ( item->type() ) {
             case NullVariable:
                 role = KColorScheme::NormalBackground;
                 break;
             case ErrorVariable:
                 role = KColorScheme::NegativeBackground;
                 break;
             default:
                 if ( item->isHelperObject() ) {
                     role = KColorScheme::ActiveBackground;
                 } else if ( item->isDefinedInParentContext() ) {
                     // Use alternate background for variables from a parent context
                     role = KColorScheme::AlternateBackground;
                 } else if ( item->hasErroneousValue() ) {
                     role = KColorScheme::NegativeBackground;
                 } else if ( item->isChanged() ) {
                     role = KColorScheme::ActiveBackground;
                 } else {
                     role = KColorScheme::NormalBackground;
                 }
                 break;
             }
             return KColorScheme( QPalette::Active ).background( role );
         }
         default:
             break;
         }
         break;
     case Qt::ForegroundRole:
         switch ( index.column() ) {
         case NameColumn:
         case ValueColumn: {
             KColorScheme::ForegroundRole role;
             switch ( item->type() ) {
             case NullVariable:
                 role = KColorScheme::InactiveText;
                 break;
             case ErrorVariable:
                 role = KColorScheme::NegativeText;
                 break;
             default:
                 if ( item->hasErroneousValue() ) {
                     role = KColorScheme::NegativeText;
                 } else if ( item->isChanged() ) {
                     role = KColorScheme::ActiveText;
                 } else {
                     role = KColorScheme::NormalText;
                 }
                 break;
             }
             return KColorScheme( QPalette::Active ).foreground( role );
         }
         default:
             break;
         }
         break;
     case Qt::ToolTipRole:
         switch ( index.column() ) {
         case ValueColumn:
             return item->description();
         case NameColumn:
         default:
             break;
         }
         break;
     case CompleteValueRole:
         if ( item->scriptValue().isVariant() && !item->value().toByteArray().isNull() ) {
             return item->value().toByteArray();
         } else {
             return item->completeValueString();
         }
     case ContainsBinaryDataRole:
         return item->scriptValue().isVariant() && !item->value().toByteArray().isNull();
     }
 
     return QVariant();
 }
 
 bool VariableModel::setData( const QModelIndex &index, const QVariant &value, int role )
 {
     Q_UNUSED( index );
     Q_UNUSED( value );
     Q_UNUSED( role );
     return false; // TODO
 //     if ( !index.isValid() || index.column() == ValueColumn || role != Qt::EditRole ) {
 //         return false;
 //     }
 //
 //     VariableItem *item = variableFromIndex( index );
 //     item->setValue( value );
 // //     emit updateVariable( VariableChange(
 //     return true;
 }
 
 Qt::ItemFlags VariableModel::flags( const QModelIndex &index ) const
 {
     if ( !index.isValid() ) {
         return Qt::NoItemFlags;
     }
 
     const Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 //     if ( rowCount(index) == 0 ) { TODO
 //         // Leaf items are editable
 //         VariableItem *variable = variableFromIndex( index );
 //         if ( variable->isSimpleValueType() ) {
 //             flags |= Qt::ItemIsEditable;
 //         }
 //     }
     return flags;
 }
 
 int VariableModel::depthToIndex( int depth ) const
 {
     if ( depth > m_variableStack.count() - 1 ) {
         // Cannot go to the wanted depth, -1 is used as index to a virtual empty variable list
         return -1;
     }
     return m_variableStack.count() - 1 - depth;
 }
 
 void VariableModel::switchToVariableStack( int depth )
 {
     const int depthIndex = depthToIndex( depth );
     const int oldDepthIndex = m_depthIndex;
 
     if ( depthIndex == oldDepthIndex ) {
         // Depth was not changed
         return;
     }
 
     // Tell views that the model changed and all items are removed
     const int oldVariableCount = isIndexValid( oldDepthIndex )
             ? m_variableStack.at(oldDepthIndex).count() : 0;
     const int newVariableCount = isIndexValid( depthIndex )
             ? m_variableStack.at(depthIndex).count() : 0;
 
     if ( oldVariableCount > 0 ) {
         // Tell views to remove all variables of the old depth,
         // by switching to the virtual empty variable list
         beginRemoveRows( QModelIndex(), 0, oldVariableCount - 1 );
         m_depthIndex = -1;
         endRemoveRows();
     }
 
     // Go to the new depth and inform views if variables get inserted
     if ( newVariableCount > 0 ) {
         // There are variables in the new stack depth, tell views how many variables get added
         beginInsertRows( QModelIndex(), 0, newVariableCount - 1 );
         m_depthIndex = depthIndex;
         endInsertRows();
     } else {
         // The model is already empty and is still empty in the new stack depth
         m_depthIndex = depthIndex;
     }
 }
 
 int VariableModel::variableStackCount() const
 {
     return m_variableStack.count();
 }
 
 void VariableModel::pushVariableStack()
 {
     m_variableStack.push( VariableItemList() );
     switchToVariableStack( 0 );
 }
 
 void VariableModel::popVariableStack()
 {
     if ( m_variableStack.isEmpty() ) {
-        kWarning() << "Cannot pop, variable stack is empty";
+        qWarning() << "Cannot pop, variable stack is empty";
         return;
     }
 
     switchToVariableStack( 1 );
     qDeleteAll( m_variableStack.pop().variables );
 }
 
 VariableTreeData::operator VariableData() const
 {
     VariableData data( type, name, scriptValue, icon, flags );
     data.value = value;
     data.valueString = valueString;
     data.description = description;
     data.completeValueString = completeValueString;
     return data;
 }
 
 VariableChange VariableChange::fromContext( QScriptContext *context ) {
     QStack< QList<VariableTreeData> > newVariableStack;
     while ( context ) {
         const QScriptValue &activationObject = context->activationObject();
         newVariableStack.append( VariableModel::variablesFromScriptValue(activationObject) );
         context = context->parentContext();
     }
     return VariableChange( UpdateVariables, newVariableStack );
 }
 
 typedef QPair<VariableItem*, VariableTreeData> VariableItemPair;
 
 void VariableModel::updateVariableStack( const QStack< QList<VariableTreeData> > &newVariableStack,
                                          VariableItem *parent )
 {
 
     for ( int currentIndex = 0; currentIndex < newVariableStack.count(); ++currentIndex ) {
         // Update variables
         // kDebug() << "Update variables at" << currentIndex << "current depth:" << m_depthIndex;
         updateVariables( newVariableStack.at(currentIndex), parent,
                          newVariableStack.count() - 1 - currentIndex != m_depthIndex );
     }
 
     // Sort by variable names
     sort( 0 );
 }
 
 void VariableItem::setChanged( bool changed )
 {
     if ( changed ) {
         m_data.flags | VariableIsChanged;
     } else {
         m_data.flags &= ~VariableIsChanged;
     }
 
     foreach ( VariableItem *child, m_children.variables ) {
         child->setChanged( changed );
     }
 }
 
 bool VariableData::operator==( const VariableData &other ) const
 {
     return type == other.type && name == other.name && value == other.value &&
            completeValueString == other.completeValueString &&
            description == other.description;
 }
 
 bool VariableModel::updateVariables( const QList<VariableTreeData> &variables,
                                      VariableItem *parent, bool currentDepth )
 {
     VariableItemList *currentVariables;
     if ( parent ) {
         currentVariables = parent->childrenPointer();
     } else if ( isIndexValid(m_depthIndex) ) {
         currentVariables = &m_variableStack[ m_depthIndex ];
     } else {
         kDebug() << "Invalid depth" << m_depthIndex;
         return false;
     }
 
     if ( currentVariables->isEmpty() && variables.isEmpty() ) {
         return false;
     }
 
     bool hasChanges = false;
     QHash< QString, VariableTreeData > newVariables;
     foreach ( const VariableTreeData &item, variables ) {
         newVariables.insert( item.name, item );
     }
 
     QList< VariableItemPair > newItems, changedItems;
     QStringList removedNames;
     if ( currentVariables ) {
         foreach ( VariableItem *item, currentVariables->variables ) {
             // Do not remove helper objects or special type variables
             // Only remove variables from the current depth
             if ( !item->isHelperObject() && item->type() != SpecialVariable &&
                  (item->isDefinedInParentContext() ^ currentDepth) )
             {
                 removedNames << item->name();
             }
         }
     }
 
     for ( QHash< QString, VariableTreeData >::ConstIterator it = newVariables.constBegin();
           it != newVariables.constEnd(); ++it )
     {
         VariableTreeData data = it.value();
         if ( !currentDepth ) {
             data.flags |= VariableIsDefinedInParentContext;
         }
         removedNames.removeOne( it.key() );
 
         if ( currentVariables && currentVariables->nameToVariable.contains(it.key()) ) {
             VariableItem *variable = currentVariables->nameToVariable[ it.key() ];
             const bool childrenChanged = updateVariables( data.children, variable )
                     && (!data.scriptValue.isFunction() || data.scriptValue.isRegExp());
 
             const bool changed = !data.scriptValue.isVariant() &&
                     (!data.scriptValue.isFunction() || data.scriptValue.isRegExp()) &&
                     variable->data() != data;
             if ( !changed && !childrenChanged ) {
                 if ( !data.flags.testFlag(VariableIsChanged) ) {
                     // Nothing changed
                     continue;
                 }
 
                 // Remove change mark,
                 // do not set hasChanges to true, because only the change mark gets removed
                 data.flags &= ~VariableIsChanged;
             } else {
                 // Mark as changed
                 data.flags |= VariableIsChanged;
                 hasChanges = true;
             }
             changedItems << qMakePair( variable, data ); // Change values of variable to values of it.value()
         } else {
             VariableItem *variable = new VariableItem( this, data, parent );
             newItems << qMakePair( variable, data );
         }
     }
 
     // Remove old variables, if any
     if ( !removedNames.isEmpty() ) {
         foreach ( const QString &removedName, removedNames ) {
             VariableItem *item = currentVariables->nameToVariable[ removedName ];
             const QModelIndex index = item->index();
             beginRemoveRows( index.parent(), index.row(), index.row() );
             currentVariables->remove( removedName );
             endRemoveRows();
         }
     }
 
     // Insert new variables, if any
     if ( !newItems.isEmpty() ) {
         // No parent for the new items
         const int count = currentVariables->count();
         const QModelIndex parentIndex = indexFromVariable( parent );
 
         // Append copied variable item
         beginInsertRows( parentIndex, count, count + newItems.count() - 1 );
         foreach ( const VariableItemPair &newItem, newItems ) {
             currentVariables->append( newItem.first );
         }
         endInsertRows();
 
         // Recursively add children
         foreach ( const VariableItemPair &newItemPair, newItems ) {
             updateVariables( newItemPair.second.children, newItemPair.first );
         }
     }
 
     // Change changed variables, if any
     // (delete items in changedItems after applying changes to the existing items)
     if ( !changedItems.isEmpty() ) {
         QModelIndexList indexes;
         foreach ( const VariableItemPair &changedItemPair, changedItems ) {
             VariableItem *modelItem = changedItemPair.first;
             const VariableTreeData &changedItem = changedItemPair.second;
 
             modelItem->setData( changedItem );
             currentVariables->append( modelItem );
             QModelIndex index = indexFromVariableAlreadyLocked( modelItem );
             indexes << indexFromVariableAlreadyLocked( modelItem );
         }
 
         foreach ( const QModelIndex &index, indexes ) {
             dataChanged( index, index );
         }
     }
 
     // Return true, if changes have been made
     return hasChanges || !removedNames.isEmpty() || !newItems.isEmpty();
 }
 
 void VariableModel::applyChange( const VariableChange &change )
 {
     switch ( change.type ) {
     case PushVariableStack:
         pushVariableStack();
         break;
     case PopVariableStack:
         popVariableStack();
         break;
     case UpdateVariables:
         updateVariableStack( change.variableStack );
         break;
     default:
-        kWarning() << "VariableChange type not implemented" << change.type;
+        qWarning() << "VariableChange type not implemented" << change.type;
         break;
     }
 }
 
 void VariableItem::setValuesOf( const VariableItem *other )
 {
     m_data = other->m_data;
 }
 
 void VariableItem::setData( const VariableTreeData &changedItem )
 {
     m_data = changedItem;
 }
 
 void VariableItem::setValue( const QVariant &value )
 {
     m_data.value = value;
 
     const QString valueString = value.toString();
     const int cutPos = qMin( 200, valueString.indexOf('\n') );
     if ( cutPos != -1 ) {
         m_data.valueString = valueString.left( cutPos ) + " ...";
     } else {
         m_data.valueString = value.toString().left( 200 ) + " ...";
     }
 }
 
 int variableTypeSort( VariableType type ) {
     switch ( type ) {
     case SpecialVariable:
         return 0;
     case ErrorVariable:
         return 1;
     case ObjectVariable:
     case RegExpVariable:
     case DateVariable:
     case ArrayVariable:
     case BooleanVariable:
     case StringVariable:
     case NumberVariable:
         return 5;
     case NullVariable:
         return 9;
     case InvalidVariable:
     case FunctionVariable:
     default:
         return 10;
     }
 }
 
 bool variableItemLessThan( VariableItem *item1, VariableItem *item2 ) {
     if ( item1->isHelperObject() != item2->isHelperObject() ) {
         return item1->isHelperObject();
     }
 
     const int s1 = variableTypeSort( item1->type() );
     const int s2 = variableTypeSort( item2->type() );
     if ( s1 != s2 ) {
         return s1 < s2;
     } else if ( item1->isDefinedInParentContext() != item2->isDefinedInParentContext() ) {
         return item1->isDefinedInParentContext(); // Sort variables from parent context to the beginning
     } else {
         // Sort by variable name
         if ( KGlobalSettings::naturalSorting() ) {
             return KStringHandler::naturalCompare( item1->name(), item2->name(),
                                                    Qt::CaseInsensitive ) < 0;
         } else {
             return QString::localeAwareCompare( item1->name(), item2->name() ) < 0;
         }
     }
 }
 
 bool variableItemSortLessThan( const QPair<VariableItem*, int> &item1,
                                const QPair<VariableItem*, int> &item2 )
 {
     return variableItemLessThan( item1.first, item2.first );
 }
 
 void VariableModel::sort( int column, Qt::SortOrder order )
 {
     Q_UNUSED( column );
 
     const int depthIndex = m_depthIndex;
     if ( !isIndexValid(depthIndex) ) {
         return;
     }
 
     // Store old persistent indexes
     emit layoutAboutToBeChanged();
     const QModelIndexList persistentIndexes = persistentIndexList();
 
     QModelIndexList oldPersistentIndexes, newPersistentIndexes;
     VariableItemList *variables = &m_variableStack[m_depthIndex];
     sortVariableItemList( variables, &oldPersistentIndexes, &newPersistentIndexes,
                           persistentIndexes, order );
 
     changePersistentIndexList( oldPersistentIndexes, newPersistentIndexes );
     emit layoutChanged();
 }
 
 void VariableModel::sortVariableItemList( VariableItemList *variables,
         QModelIndexList *oldPersistentIndexes, QModelIndexList *newPersistentIndexes,
         const QModelIndexList &persistentIndexes, Qt::SortOrder order )
 {
     Q_ASSERT( variables );
 
     // TODO Create a function for this "childVariableList( VariableItem *parent )"
 //     QList< VariableItem* > *variables = parent
 //             ? &parent->childrenPointer()->variables : &(m_variableStack[m_depthIndex].variables);
     const int count = variables->count();
     if ( count == 0 ) {
         // There are no children to sort
         return;
     }
 
     QVector< QPair<VariableItem*, int> > sortable( count );
     for ( int row = 0; row < count; ++row ) {
         sortable[ row ] = qMakePair( variables->operator[](row), row );
     }
 
     qStableSort( sortable.begin(), sortable.end(), variableItemSortLessThan );
 
     // Clear unsorted old variable list
     variables->clear();
 
     // And fill it again in sorted order
     for ( int newRow = 0; newRow < count; ++newRow ) {
         const QPair<VariableItem*, int> sortableItem = sortable[ newRow ];
         VariableItem *item = sortableItem.first;
         const int oldRow = sortableItem.second;
         variables->append( item );
 
         for ( int column = 0; column < columnCount(); ++column ) {
             const QModelIndex oldIndex = createIndex( oldRow, column, item );
             if ( persistentIndexes.contains(oldIndex) && oldRow != newRow ) {
                 const QModelIndex newIndex = createIndex( newRow, column, item );
                 oldPersistentIndexes->append( oldIndex );
                 newPersistentIndexes->append( newIndex );
             }
         }
     }
 
     // Sort children of the children
     foreach ( VariableItem *childVariable, variables->variables ) {
         sortVariableItemList( childVariable->childrenPointer(),
                               oldPersistentIndexes, newPersistentIndexes, persistentIndexes, order );
     }
 }
 
 QList<VariableTreeData> VariableModel::variablesFromScriptValue( const QScriptValue &value,
         int maxDepth, const QList<QScriptValue> &parents )
 {
     QScriptValueIterator it( value );
 
     // Limit depth of variable children
     if ( it.hasNext() && maxDepth <= 0 ) {
-        kWarning() << "Maximum variable depth reached";
+        qWarning() << "Maximum variable depth reached";
         return QList<VariableTreeData>();
     }
 
     // Prevent recursively adding the same child
     foreach ( const QScriptValue &parent, parents ) {
         if ( parent.strictlyEquals(value) ) {
             // Recursive variable found
             return QList<VariableTreeData>()
                     << VariableTreeData( i18nc("@info/plain", "(Recursive variable)") );
         }
     }
 
     QList<VariableTreeData> variables;
     while ( it.hasNext() ) {
         if ( variables.count() >= 500 ) {
             // Add a dummy variable instead of adding more than 500 variables
-            kWarning() << "Only show up to 500 variables per level";
+            qWarning() << "Only show up to 500 variables per level";
             variables << VariableTreeData( "..." );
             break;
         }
 
         it.next();
 
         const QString childName = it.name();
         const QScriptValue childValue = it.value();
 //         if ( (childValue.isFunction() && childValue.property("prototype").isValid()) || // Constructors
         if ( it.flags().testFlag(QScriptValue::SkipInEnumeration) ||
              childName == QLatin1String("Qt")|| // Too many enumerables in there, bad performance
              childName == QLatin1String("QtConcurrent")|| // Unused
              childName == QLatin1String("NaN") || childName == QLatin1String("undefined") ||
              childName == QLatin1String("Infinity") || childName == QLatin1String("objectName") ||
              childName == QLatin1String("callee") ||
              childName.startsWith(QLatin1String("__")) ) // Hide variables starting with "__"
         {
             continue;
         }
 
         // Create variable item
         VariableTreeData item = VariableTreeData::fromScripValue( childName, childValue );
 
         // Recursively add children
         item.children << variablesFromScriptValue( childValue, maxDepth - 1,
                                                    QList<QScriptValue>() << parents << value );
 
         // Add variable item to the return list
         variables << item;
     }
 
     return variables;
 }
 
 VariableItem &VariableItem::operator=( const VariableItem &item )
 {
     // The model to which the item belongs cannot be changed and shouldn't
     m_parent = item.m_parent;
     m_children = item.m_children;
     m_data = item.m_data;
     return *this;
 }
 
 VariableTreeData VariableTreeData::fromScripValue( const QString &name, const QScriptValue &value )
 {
     VariableTreeData data;
     if ( name == QLatin1String("helper") || name == QLatin1String("network") ||
          name == QLatin1String("storage") || name == QLatin1String("result") ||
          name == QLatin1String("provider") ||
          name == QLatin1String("PublicTransport") || name == QLatin1String("enum") )
     {
         data.flags |= VariableIsHelperObject;
     }
 
     bool encodeValue = false;
     QChar endCharacter;
     if ( value.isArray() ) {
         data.description = data.completeValueString = data.valueString =
                 QString("[%0]").arg( value.toVariant().toStringList().join(", ") );
         endCharacter = ']';
     } else if ( value.isString() ) {
         data.description = data.completeValueString = value.toString();
         data.valueString = QString("\"%1\"").arg( value.toString() );
         encodeValue = true;
         endCharacter = '\"';
     } else if ( value.isRegExp() ) {
         data.description = data.completeValueString = data.valueString =
                 QString("/%1/%2").arg( value.toRegExp().pattern() )
                 .arg( value.toRegExp().caseSensitivity() == Qt::CaseSensitive ? "" : "i" );
         encodeValue = true;
     } else if ( value.isFunction() ) {
         data.valueString = QString(); //QString("function %1").arg( name ); // it.value() is the function definition
     } else if ( value.isVariant() && !value.toVariant().toByteArray().isNull() ) {
         const QByteArray hex = value.toVariant().toByteArray().toHex();
         const int rowLength = 32;
         int pos = 0;
         while ( pos < hex.length() ) {
             // Get next part of the byte array
             const QString hexPart = hex.mid( pos, rowLength );
             QString row;
             int i = 0;
             do {
                 if ( !row.isEmpty() ) {
                     row += ' ';
                 }
                 row += hexPart.mid( i, 2 );
                 i += 2;
             } while ( i + 2 <= hexPart.length() );
 
             if ( !data.completeValueString.isEmpty() ) {
                 data.description += "<br />";
                 data.completeValueString += ' ';
                 data.valueString += ' ';
             }
             data.description += QString("<i>%1:</i> %2").arg(pos).arg(row);
             data.completeValueString += row;
             data.valueString += row;
             pos += row.length();
         }
     } else {
         data.description = data.completeValueString = data.valueString = value.toString();
     }
 
     const int cutPos = qMin( 200, data.valueString.indexOf('\n') );
     if ( cutPos != -1 ) {
         data.valueString = data.valueString.left( cutPos ) + " ...";
     }
 
     data.name = name;
     data.scriptValue = value;
     data.value = value.toVariant();
     data.description = VariableItem::variableValueTooltip( data.description,
                                                            encodeValue, endCharacter );
 
     if ( value.isRegExp() ) {
         data.icon = KIcon("code-variable");
         data.type = RegExpVariable;
     } else if ( value.isFunction() ) {
         data.icon = KIcon("code-function");
         data.type = FunctionVariable;
     } else if ( value.isArray() || value.isBool() || value.isBoolean() ||
                 value.isDate() || value.isNull() || value.isNumber() ||
                 value.isString() || value.isUndefined() )
     {
         data.icon = KIcon("code-variable");
         if ( value.isDate() ) {
             data.type = DateVariable;
         } else if ( value.isNumber() ) {
             data.type = NumberVariable;
         } else if ( value.isNull() || value.isUndefined() ) {
             data.type = NullVariable;
         } else if ( value.isArray() ) {
             data.type = ArrayVariable;
         } else if ( value.isBool() ) {
             data.type = BooleanVariable;
         } else if ( value.isString() ) {
             data.type = StringVariable;
         }
     } else if ( value.isObject() || value.isQMetaObject() ) {
         data.icon = KIcon("code-class");
         data.type = ObjectVariable;
     } else if ( value.isError() ) {
         data.icon = KIcon("dialog-error");
         data.type = ErrorVariable;
     } else {
         data.icon = KIcon("code-context");
     }
 
     if ( name == QLatin1String("result") ) {
         // Add special items for the "result" script object, which is an exposed ResultObject object
         ResultObject *result = qobject_cast< ResultObject* >( value.toQObject() );
         if ( !result ) {
             data.description = i18nc("@info/plain", "(invalid)");
         } else {
             data.description = i18ncp("@info/plain", "%1 result", "%1 results", result->count());
 
             VariableTreeData dataItem( SpecialVariable, i18nc("@info/plain", "Data"),
                                     data.description, KIcon("documentinfo") );
             int i = 1;
             QList<Enums::TimetableInformation> shortInfoTypes = QList<Enums::TimetableInformation>()
                     << Enums::Target << Enums::TargetStopName << Enums::DepartureDateTime
                     << Enums::DepartureTime << Enums::StopName;
             foreach ( const TimetableData &timetableData, result->data() ) {
                 QString shortInfo;
                 foreach ( Enums::TimetableInformation infoType, shortInfoTypes) {
                     if ( timetableData.contains(infoType) ) {
                         shortInfo = timetableData[ infoType ].toString();
                         break;
                     }
                 }
                 VariableTreeData resultItem( SpecialVariable,
                         i18nc("@info/plain", "Result %1", i), QString("<%1>").arg(shortInfo),
                         KIcon("code-class") );
                 for ( TimetableData::ConstIterator it = timetableData.constBegin();
                       it != timetableData.constEnd(); ++it )
                 {
                     VariableTreeData timetableInformationItem =
                             VariableTreeData::fromTimetableData( it.key(), it.value() );
                     resultItem.children << timetableInformationItem;
                 }
                 ++i;
                 dataItem.children << resultItem;
             }
             data.children << dataItem;
         }
         data.value = data.description;
         data.valueString = data.description;
     } else if ( name == QLatin1String("network") ) {
         // Add special items for the "network" script object, which is an exposed Network object
         Network *network = qobject_cast< Network* >( value.toQObject() );
         if ( !network ) {
             data.description = i18nc("@info/plain", "(invalid)");
         } else {
             data.description = i18ncp("@info/plain", "%1 request", "%1 requests",
                                       network->runningRequests().count());
 
             VariableTreeData requestsItem( SpecialVariable,  i18nc("@info/plain", "Running Requests"),
                                         data.description, KIcon("documentinfo") );
             int i = 1;
             foreach ( const QSharedPointer< NetworkRequest > &networkRequest,
                       network->runningRequests() )
             {
                 VariableTreeData requestItem( SpecialVariable,
                         i18nc("@info/plain", "Request %1", i), networkRequest->url(),
                         KIcon("code-class") );
                 requestsItem.children << requestItem;
                 ++i;
             }
             data.children << requestsItem;
         }
         data.value = data.description;
         data.valueString = data.description;
     } else if ( name == QLatin1String("storage") ) {
         // Add special items for the "storage" script object, which is an exposed Storage object
         Storage *storage = qobject_cast< Storage* >( value.toQObject() );
         if ( !storage ) {
             data.description = i18nc("@info/plain", "(invalid)");
         } else {
             const QVariantMap memory = storage->read();
             data.description = i18ncp("@info/plain", "%1 value", "%1 values", memory.count());
 
             VariableTreeData memoryItem( SpecialVariable,
                     i18nc("@info/plain", "Memory"), data.description, KIcon("documentinfo") );
             int i = 1;
             for ( QVariantMap::ConstIterator it = memory.constBegin(); it != memory.constEnd(); ++it ) {
                 VariableTreeData valueItem( SpecialVariable, it.key(), it.value().toString(),
                                             KIcon("code-variable") );
                 memoryItem.children << valueItem;
                 ++i;
             }
             data.children << memoryItem;
         }
         data.value = data.description;
         data.valueString = data.description;
     } else if ( name == QLatin1String("helper") ) {
         data.description = i18nc("@info/plain", "Offers helper functions to scripts");
         data.value = data.description;
         data.valueString = data.description;
     } else if ( name == QLatin1String("provider") ) {
         data.description = i18nc("@info/plain", "Exposes service provider information to scripts, "
                                  "which got read from the XML file");
         data.value = data.description;
         data.valueString = data.description;
     }
 
     return data;
 }
 
 VariableTreeData VariableTreeData::fromTimetableData( Enums::TimetableInformation info,
                                                       const QVariant &data )
 {
     QString subValueString;
     const bool isList = data.isValid() && data.canConvert( QVariant::List );
     if ( isList ) {
         const bool isVehicleTypeList = info == Enums::TypesOfVehicleInJourney ||
                                         info == Enums::RouteTypesOfVehicles;
         const bool isSubJourneyList = info == Enums::RouteSubJourneys;
         const QVariantList list = data.toList();
         QStringList stringList;
         int count = 0;
         for ( int i = 0; i < list.count(); ++i ) {
             QString str;
             if ( isVehicleTypeList ) {
                 Enums::VehicleType vehicleType =
                         static_cast<Enums::VehicleType>( list[i].toInt() );
                 str = "PublicTransport." + Enums::toString( vehicleType );
             } else if ( isSubJourneyList ) {
                 str = i18nc("@info/plain", "%1 sub journeys",
                             list[i].toMap()[Global::timetableInformationToString(Enums::RouteStops)]
                             .toList().count());
             } else {
                 str = list[i].toString();
             }
             count += str.length();
             if ( count > 100 ) {
                 stringList << "...";
                 break;
             }
             stringList << str;
         }
         subValueString = '[' + stringList.join(", ") + ']';
     } else if ( info == Enums::TypeOfVehicle ) {
         Enums::VehicleType vehicleType =
                 static_cast<Enums::VehicleType>( data.toInt() );
         subValueString = "PublicTransport." + Enums::toString( vehicleType );
     } else {
         subValueString = data.toString();
     }
 
     VariableTreeData treeData( SpecialVariable, Global::timetableInformationToString(info),
                                subValueString, KIcon("code-variable") );
     if ( !Global::checkTimetableInformation(info, data) ) {
         treeData.flags |= VariableHasErroneousValue;
     }
 
     if ( data.canConvert(QVariant::List) ) {
         const QVariantList list = data.toList();
         for ( int i = 0; i < list.count(); ++i ) {
             VariableTreeData listItem( StringVariable,
                     QString::number(i + 1), list[i].toString(), KIcon("code-variable") );
             if ( list[i].isValid() && list[i].canConvert(QVariant::Map) ) {
                 const QVariantMap map = list[i].toMap();
                 for ( QVariantMap::ConstIterator subIt = map.constBegin();
                         subIt != map.constEnd(); ++subIt )
                 {
                     Enums::TimetableInformation subInfo =
                             Global::timetableInformationFromString(subIt.key());
                     VariableTreeData hashItem =
                             VariableTreeData::fromTimetableData(subInfo, subIt.value());
                     if ( info == Enums::RouteSubJourneys &&
                          subInfo != Enums::RouteStops &&
                          subInfo != Enums::RouteStopsShortened &&
                          subInfo != Enums::RouteTimes &&
                          subInfo != Enums::RouteTimesArrival &&
                          subInfo != Enums::RouteTimesDeparture &&
                          subInfo != Enums::RoutePlatformsArrival &&
                          subInfo != Enums::RoutePlatformsDeparture &&
                          subInfo != Enums::RouteExactStops &&
                          subInfo != Enums::RouteNews )
                     {
                         hashItem.flags |= VariableHasErroneousValue;
                     }
                     listItem.children << hashItem;
                 }
             }
             treeData.children << listItem;
         }
     }
     return treeData;
 }
 
 QString VariableItem::variableValueTooltip( const QString &completeValueString,
                                             bool encodeHtml, const QChar &endCharacter )
 {
     if ( completeValueString.isEmpty() ) {
         return QString();
     }
 
     QString tooltip = completeValueString.left( 1000 );
     if ( encodeHtml ) {
         if ( !endCharacter.isNull() ) {
             tooltip += endCharacter; // Add end character (eg. a quotation mark), which got cut off
         }
         tooltip = Global::encodeHtmlEntities( tooltip );
     }
     if ( tooltip.length() < completeValueString.length() ) {
         tooltip.prepend( i18nc("@info Always plural",
                          "<emphasis strong='1'>First %1 characters:</emphasis><nl />", 1000) )
                .append( QLatin1String("...") );
     }
     return tooltip.prepend( QLatin1String("<p>") ).append( QLatin1String("</p>") );
 }
 
 QModelIndex VariableItem::index()
 {
     return m_model ? m_model->indexFromVariable(this) : QModelIndex();
 }
 
 void VariableItem::addChild( VariableItem *item )
 {
     m_model->addChild( this, item );
 }
 
 void VariableItem::addChildren( const VariableItemList &items )
 {
     m_model->addChildren( this, items );
 }
 
 void VariableModel::addChild( VariableItem *parentItem, VariableItem *item )
 {
     addChildren( parentItem, VariableItemList() << item );
 }
 
 void VariableModel::addChildren( VariableItem *parentItem, const VariableItemList &items )
 {
     const QModelIndex index = parentItem->index();
     const int childCount = parentItem->children().count();
     beginInsertRows( index, childCount, childCount + items.count() - 1 );
 
     foreach ( VariableItem *item, items.variables ) {
         parentItem->childrenPointer()->append( item );
         item->setParent( parentItem );
     }
 
     endInsertRows();
 }
 
 void VariableModel::addChildrenAlreadyLocked( VariableItem *parentItem, const VariableItemList &items )
 {
     foreach ( VariableItem *item, items.variables ) {
         parentItem->childrenPointer()->append( item );
         item->setParent( parentItem );
     }
 }
 
 bool VariableModel::removeRows( int row, int count, const QModelIndex &parent )
 {
     // Remove the frames from the model
     beginRemoveRows( parent, row, row + count - 1 );
     VariableItemList *variables = 0;
     if ( parent.isValid() ) {
         VariableItem *parentItem = variableFromIndex( parent );
         variables = parentItem->childrenPointer();
     } else {
         variables = &m_variableStack[ m_depthIndex ];
     }
 
     for ( int i = row + count - 1; i >= row; --i ) {
         // Remove frame and delete it
         delete variables->takeAt( i );
     }
     endRemoveRows();
     return true;
 }
 
 void VariableModel::clear()
 {
     if ( !isIndexValid(m_depthIndex) ) {
         return;
     }
 
     const int variableCount = m_variableStack.at( m_depthIndex ).count();
     beginRemoveRows( QModelIndex(), 0, variableCount - 1 );
     while ( !m_variableStack.isEmpty() ) {
         qDeleteAll( m_variableStack.pop().variables );
     }
     endRemoveRows();
 }
 
 bool VariableModel::isEmpty() const
 {
     return isIndexValid(m_depthIndex) ? m_variableStack.at(m_depthIndex).isEmpty() : true;
 }
 
 QModelIndex VariableModel::parent( const QModelIndex &child ) const
 {
     if ( !child.isValid() ) {
         return QModelIndex();
     }
 
     VariableItem *childItem = variableFromIndex( child );
     VariableItem *parentItem = childItem->parent();
     if ( !parentItem ) {
         return QModelIndex();
     }
 
     if ( parentItem->parent() ) {
         // parentItem has a parent, get index of parentItem in it's parent's children
         return createIndex( parentItem->parent()->children().indexOf(parentItem), 0, parentItem );
     } else if ( isIndexValid(m_depthIndex) ) {
         // parentItem has no parent, get index of parentItem in the current top level variable list
         return createIndex( m_variableStack.at(m_depthIndex).indexOf(parentItem), 0, parentItem );
     } else {
         return QModelIndex();
     }
 }
 
 bool VariableModel::isIndexValid( int index ) const
 {
     return index >= 0 && index < m_variableStack.count();
 }
 
 QModelIndex VariableModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( column < 0 || column >= ColumnCount || row < 0 ) {
         return QModelIndex();
     }
 
     if ( parent.isValid() ) {
         if ( parent.column() != 0 ) {
             // Only the first column has children
             return QModelIndex();
         }
 
         VariableItem *parentItem = variableFromIndex( parent );
         return row >= parentItem->children().count() ? QModelIndex()
                 : createIndex(row, column, parentItem->children()[row]);
     } else {
         if ( isIndexValid(m_depthIndex) ) {
             const VariableItemList &variables = m_variableStack[ m_depthIndex ];
             return row < 0 || row >= variables.count()
                     ? QModelIndex() : createIndex(row, column, variables[row]);
         } else {
             return QModelIndex();
         }
     }
 }
 
 QModelIndex VariableModel::indexFromVariable( VariableItem *variable, int column ) const
 {
     return indexFromVariableAlreadyLocked( variable, column );
 }
 
 QModelIndex VariableModel::indexFromVariableAlreadyLocked( VariableItem *variable, int column ) const
 {
     if ( !variable ) {
         return QModelIndex();
     }
     Q_ASSERT( column >= 0 && column < ColumnCount );
 
     const VariableItemList *variables;
     if ( variable->parent() ) {
         variables = variable->parent()->childrenPointer();
     } else if ( isIndexValid(m_depthIndex) ) {
         variables = &m_variableStack[ m_depthIndex ];
     } else {
         return QModelIndex();
     }
     return createIndex( variables->indexOf(variable), column, variable );
 }
 
 VariableItem *VariableModel::variableFromIndex( const QModelIndex &index ) const
 {
     return !index.isValid() ? 0 : static_cast< VariableItem* >( index.internalPointer() );
 }
 
 int VariableModel::rowCount( const QModelIndex &parent ) const
 {
     if ( !isIndexValid(m_depthIndex) ) {
         // Model is currently at an invalid depth index, ie. -1
         return 0;
     } else if ( parent.isValid() ) {
         // Child item
         if ( parent.column() == 0 ) {
             const VariableItem *parentItem = variableFromIndex( parent );
             return parentItem->children().count();
         } else {
             // Only the first column has children
             return 0;
         }
     } else {
         // Top level item
         return m_variableStack.at( m_depthIndex ).count();
     }
 }
 
 bool VariableFilterProxyModel::filterAcceptsRow( int sourceRow,
                                                  const QModelIndex &sourceParent ) const
 {
     if ( sourceParent.isValid() &&
          sourceModel()->data(sourceParent).toString().contains(filterRegExp()) )
     {
         return true;
     }
 
     const QModelIndex sourceIndex = sourceModel()->index( sourceRow, 0, sourceParent );
     const QString data = sourceModel()->data( sourceIndex ).toString();
     bool ret = data.contains( filterRegExp() );
 
     if ( sourceIndex.isValid() ) {
         for ( int i = 0; i < sourceModel()->rowCount(sourceIndex); ++i ) {
             ret = ret || filterAcceptsRow(i, sourceIndex );
         }
     }
     return ret;
 }
 
 } // namespace Debugger
diff --git a/engine/timetablemate/src/docks/breakpointdockwidget.cpp b/engine/timetablemate/src/docks/breakpointdockwidget.cpp
index 662b687..9f759ca 100644
--- a/engine/timetablemate/src/docks/breakpointdockwidget.cpp
+++ b/engine/timetablemate/src/docks/breakpointdockwidget.cpp
@@ -1,191 +1,191 @@
 /*
 *   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 "breakpointdockwidget.h"
 
 // Own includes
 #include "../debugger/debugger.h"
 #include "../debugger/debuggerstructures.h"
 #include "../debugger/breakpointmodel.h"
 #include "../project.h"
 #include "../projectmodel.h"
 #include "../tabs/scripttab.h"
 
 // KDE includes
 #include <KToggleAction>
 #include <KLocalizedString>
 #include <KDebug>
 #include <KTextEditor/View>
 #include <KTextEditor/Document>
 
 // Qt includes
 #include <QTreeView>
 #include <QStandardItemModel>
 #include <QApplication>
 #include <QPainter>
 #include <QMenu>
 #include <QHeaderView>
 
 BreakpointDockWidget::BreakpointDockWidget( ProjectModel *projectModel,
                                             KActionMenu *showDocksAction, QWidget *parent )
         : AbstractDockWidget( i18nc("@title:window Dock title", "Breakpoints"),
                              showDocksAction, parent ),
           m_projectModel(projectModel), m_breakpointWidget(new QTreeView(this))
 {
     setObjectName( "breakpoints" );
 
     setWhatsThis( i18nc("@info:whatsthis", "<title>Shows a list of all breakpoints</title>"
                         "<para>Breakpoints can be enabled/disabled here and it's condition can "
                         "be edited.</para>") );
 
     // Create a widget to visualize the model
     m_breakpointWidget->setAllColumnsShowFocus( true );
     m_breakpointWidget->setRootIsDecorated( false );
     CheckboxDelegate *delegate = new CheckboxDelegate( m_breakpointWidget, this );
     m_breakpointWidget->setItemDelegateForColumn( 0, delegate );
     connect( delegate, SIGNAL(checkedStateChanged(QModelIndex,bool)),
              this, SLOT(checkedStateChanged(QModelIndex,bool)) );
     m_breakpointWidget->setContextMenuPolicy( Qt::CustomContextMenu );
     connect( m_breakpointWidget, SIGNAL(customContextMenuRequested(QPoint)),
              this, SLOT(contextMenu(QPoint)) );
 
     m_breakpointWidget->setMinimumSize( 150, 100 );
     setWidget( m_breakpointWidget );
 
     connect( projectModel, SIGNAL(activeProjectAboutToChange(Project*,Project*)),
              this, SLOT(activeProjectAboutToChange(Project*,Project*)) );
     connect( m_breakpointWidget, SIGNAL(clicked(QModelIndex)),
              this, SLOT(clickedBreakpointItem(QModelIndex)) );
 
     activeProjectAboutToChange( projectModel->activeProject(), 0 );
 }
 
 void BreakpointDockWidget::activeProjectAboutToChange( Project *project, Project *previousProject )
 {
     Q_UNUSED( previousProject );
 
     QAbstractItemModel *oldModel = m_breakpointWidget->model();
     if ( project ) {
         setEnabled( true );
         Debugger::BreakpointModel *breakpointModel = project->debugger()->breakpointModel();
         m_breakpointWidget->setModel( breakpointModel );
 
         // Initialize header
         QHeaderView *header = m_breakpointWidget->header();
         header->setDefaultSectionSize( 150 );
         header->setResizeMode( static_cast<int>(BreakpointModel::EnableColumn),
                                QHeaderView::ResizeToContents );
         header->setResizeMode( static_cast<int>(BreakpointModel::SourceColumn),
                                QHeaderView::Interactive );
         header->setResizeMode( static_cast<int>(BreakpointModel::ConditionColumn),
                                QHeaderView::Interactive );
         header->setResizeMode( static_cast<int>(BreakpointModel::HitCountColumn),
                                QHeaderView::ResizeToContents );
         header->setResizeMode( static_cast<int>(BreakpointModel::LastConditionResultColumn),
                                QHeaderView::Stretch );
     } else {
         setEnabled( false );
         m_breakpointWidget->setModel( new BreakpointModel(this) );
     }
 
     if ( oldModel && oldModel->QObject::parent() == this ) {
         delete oldModel;
     }
 }
 
 Debugger::BreakpointModel *BreakpointDockWidget::model() const
 {
     if ( m_projectModel->activeProject() ) {
         return m_projectModel->activeProject()->debugger()->breakpointModel();
     } else {
-        kWarning() << "No breakpoint model available";
+        qWarning() << "No breakpoint model available";
         return 0;
     }
 }
 
 void BreakpointDockWidget::contextMenu( const QPoint &pos )
 {
     const QModelIndex index = m_breakpointWidget->indexAt( pos );
     if ( !index.isValid() ) {
         return;
     }
 
     Debugger::BreakpointModel *breakpointModel = model();
     if ( !breakpointModel ) {
         return;
     }
 
     Breakpoint *breakpoint = breakpointModel->breakpointFromIndex( index );
 
     QPointer<QMenu> menu( new QMenu(this) );
     KToggleAction *enableAction = new KToggleAction( i18nc("@info/plain", "Enable"), menu );
     QAction *resetAction = new QAction( KIcon("edit-undo"), i18nc("@info/plain", "Reset"), menu );
     QAction *deleteAction = new QAction( KIcon("edit-delete"), i18nc("@info/plain", "Delete"), menu );
     enableAction->setChecked( breakpoint->isEnabled() );
     menu->addActions( QList<QAction*>() << enableAction << resetAction << deleteAction );
 
     QAction *action = menu->exec( m_breakpointWidget->mapToGlobal(pos) );
     if ( action == deleteAction ) {
         breakpointModel->removeBreakpoint( breakpoint );
     } else if ( action == enableAction ) {
         breakpoint->setEnabled( enableAction->isChecked() );
     } else if ( action == resetAction ) {
         breakpoint->reset();
     }
     delete menu.data();
 }
 
 void BreakpointDockWidget::checkedStateChanged( const QModelIndex &index, bool checked )
 {
     Debugger::BreakpointModel *breakpointModel = model();
     if ( !index.isValid() || !breakpointModel ) {
         return;
     }
 
     Debugger::Breakpoint *breakpoint = breakpointModel->breakpointFromIndex( index );
     if ( breakpoint ) {
         breakpoint->setEnabled( checked );
     }
 }
 
 void BreakpointDockWidget::clickedBreakpointItem( const QModelIndex &index )
 {
     Debugger::BreakpointModel *breakpointModel = model();
     if ( !index.isValid() || !breakpointModel ) {
         return;
     }
 
     const Debugger::Breakpoint *breakpoint = breakpointModel->breakpointFromIndex( index );
 
     // Set cursor to breakpoint position
     Project *project = m_projectModel->activeProject();
     if ( !project ) {
         kDebug() << "TODO";
         return;
     }
     ScriptTab *tab = project->scriptTab();
     if ( tab ) {
         tab->goToLine( breakpoint->lineNumber() );
     }
 }
 
 QWidget *BreakpointDockWidget::mainWidget() const {
     return m_breakpointWidget;
 }
diff --git a/engine/timetablemate/src/docks/docktoolbar.cpp b/engine/timetablemate/src/docks/docktoolbar.cpp
index f4930ad..3ec339b 100644
--- a/engine/timetablemate/src/docks/docktoolbar.cpp
+++ b/engine/timetablemate/src/docks/docktoolbar.cpp
@@ -1,302 +1,302 @@
 /*
  *   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 "docktoolbar.h"
 
 // KDE includes
 #include <KAction>
 #include <KActionMenu>
 #include <KMenu>
 #include <KDebug>
 
 // Qt includes
 #include <QBoxLayout>
 #include <QDockWidget>
 #include <QDropEvent>
 #include <QStyleOption>
 #include <QStylePainter>
 #include <QEvent>
 
 DockToolButtonAction::DockToolButtonAction( QDockWidget *dockWidget, const KIcon &icon,
                                             const QString &text, QObject *parent )
         : KToggleAction(parent), m_dockWidget(dockWidget)
 {
     setText( text );
     setIcon( icon );
 
     // No docking to the top area
     dockWidget->setAllowedAreas(
             Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea );
 
     connect( dockWidget, SIGNAL(visibilityChanged(bool)), this, SLOT(setChecked(bool)) );
     connect( this, SIGNAL(toggled(bool)), this, SLOT(slotToggled(bool)) );
 }
 
 void DockToolButtonAction::slotToggled( bool checked )
 {
     KToggleAction::slotToggled( checked );
 
     const bool wasBlocked = m_dockWidget->blockSignals( true );
     m_dockWidget->setVisible( checked );
     m_dockWidget->blockSignals( wasBlocked );
 }
 
 QWidget *DockToolButtonAction::createWidget( QWidget *parent )
 {
     DockToolBar *toolBar = qobject_cast< DockToolBar* >( parent );
     if ( !toolBar ) {
         // Only create a DockToolButton when inserting the widget into a DockToolBar
         return 0;
     }
 
     // Create a DockToolButton when inserting the widget into a DockToolBar
     DockToolButton *toolButton = new DockToolButton( toolBar->area(), parent );
     toolButton->setEnabled( isEnabled() );
     toolButton->setText( text() );
     toolButton->setIcon( icon() );
     toolButton->setCheckable( true );
     toolButton->setChecked( dockWidget()->isVisible() );
     toolButton->setIconSize( toolBar->iconSize() );
     toolButton->setToolButtonStyle( toolBar->toolButtonStyle() );
 
     // Use vertical title bar with horizontal orientation and vice versa
     if ( toolBar->orientation() == Qt::Horizontal ) {
         dockWidget()->setFeatures( dockWidget()->features() | QDockWidget::DockWidgetVerticalTitleBar );
     } else {
         dockWidget()->setFeatures( dockWidget()->features() & ~QDockWidget::DockWidgetVerticalTitleBar );
     }
 
     connect( this, SIGNAL(toggled(bool)), toolButton, SLOT(setChecked(bool)) );
     connect( toolButton, SIGNAL(toggled(bool)), this, SLOT(setChecked(bool)) );
     return toolButton;
 }
 
 DockToolButton::DockToolButton( Qt::DockWidgetArea area, QWidget *parent )
         : QToolButton(parent), m_area(area)
 {
 }
 
 void DockToolButton::setArea( Qt::DockWidgetArea area )
 {
     m_area = area;
     update();
 }
 
 Qt::Orientation DockToolButton::orientation() const
 {
     if ( m_area == Qt::LeftDockWidgetArea || m_area == Qt::RightDockWidgetArea ) {
         return Qt::Vertical;
     } else {
         return Qt::Horizontal;
     }
 }
 
 QSize DockToolButton::sizeHint() const
 {
     ensurePolished();
 
     QStyleOptionToolButton opt;
     initStyleOption( &opt );
 
     QFontMetrics fm = fontMetrics();
     const int charWidth = fm.width( QLatin1Char('x') );
     QSize textSize;
 
     // No text size if we're having icon-only button
     if( toolButtonStyle() != Qt::ToolButtonIconOnly ) {
         textSize = fm.size( Qt::TextShowMnemonic, opt.text );
         textSize.rwidth() += 2 * charWidth;
     }
 
     const int spacing = 2;
     int iconwidth = 0, iconheight = 0;
 
     // No icon size if we're drawing text only
     if( toolButtonStyle() != Qt::ToolButtonTextOnly ) {
         if( orientation() == Qt::Horizontal ) {
             iconwidth = opt.iconSize.width();
             iconheight = opt.iconSize.height();
         } else {
             iconwidth = opt.iconSize.height();
             iconheight = opt.iconSize.width();
         }
     }
 
     int width = 4 + textSize.width() + iconwidth + spacing;
     int height = 4 + qMax( textSize.height(), iconheight ) + spacing;
     if( orientation() == Qt::Vertical ) {
         return QSize( height, width );
     } else {
         return QSize( width, height );
     }
 }
 
 void DockToolButton::paintEvent( QPaintEvent *event )
 {
     if ( orientation() == Qt::Horizontal ) {
         QToolButton::paintEvent(event);
     } else {
         // Paint button rotated
         QStylePainter painter( this );
         QStyleOptionToolButton option;
         initStyleOption( &option );
 
         // First draw normal frame and not text/icon
         option.text = QString();
         option.icon = QIcon();
         painter.drawComplexControl( QStyle::CC_ToolButton, option );
 
         // Rotate the options
         QSize size( option.rect.size() );
         size.transpose();
         option.rect.setSize( size );
 
         // Rotate the painter
         if( m_area == Qt::LeftDockWidgetArea ) {
             painter.translate( 0, height() );
             painter.rotate( -90 );
         } else {
             painter.translate( width(), 0 );
             painter.rotate( 90 );
         }
 
         // Paint text and icon
         option.text = text();
         QIcon::Mode iconMode = ( option.state & QStyle::State_MouseOver )
                 ? QIcon::Active : QIcon::Normal;
         QPixmap ic = icon().pixmap( option.iconSize, iconMode, QIcon::On );
         QTransform tf;
         if ( m_area == Qt::LeftDockWidgetArea ) {
             tf = tf.rotate( 90 );
         } else {
             tf = tf.rotate(-90);
         }
         option.icon = ic.transformed( tf, Qt::SmoothTransformation );
         painter.drawControl( QStyle::CE_ToolButtonLabel, option );
         painter.end();
     }
 }
 
 DockToolBar::DockToolBar( Qt::DockWidgetArea area, const QString &objectName,
                           KActionMenu *showDocksAction, QWidget *parent )
         : QToolBar(parent), m_area(area), m_group(new QActionGroup(this)),
           m_showDocksAction(showDocksAction)
 {
     Q_ASSERT( showDocksAction );
     setObjectName( objectName );
     m_group->setExclusive( true );
     setAllowedAreas( toolBarAreaFromDockWidgetArea(area) );
     setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
     setMovable( false );
     setFloatable( false );
     setIconSize( QSize(KIconLoader::SizeSmall, KIconLoader::SizeSmall) );
     connect( this, SIGNAL(orientationChanged(Qt::Orientation)),
              this, SLOT(slotOrientationChanged(Qt::Orientation)) );
 }
 
 void DockToolBar::contextMenuEvent( QContextMenuEvent *event )
 {
     m_showDocksAction->menu()->exec( event->globalPos() );
     event->accept();
 }
 
 void DockToolBar::hideCurrentDock()
 {
     if ( m_group->checkedAction() ) {
         m_group->checkedAction()->setChecked( false );
     }
 }
 
 void DockToolBar::slotOrientationChanged( Qt::Orientation orientation )
 {
     foreach ( QAction *action, actions() ) {
         DockToolButtonAction *dockAction = qobject_cast< DockToolButtonAction* >( action );
         QDockWidget *dockWidget = dockAction->dockWidget();
         if ( orientation == Qt::Horizontal ) {
             dockWidget->setFeatures( dockWidget->features() | QDockWidget::DockWidgetVerticalTitleBar );
         } else {
             dockWidget->setFeatures( dockWidget->features() & ~QDockWidget::DockWidgetVerticalTitleBar );
         }
     }
 }
 
 Qt::ToolBarArea DockToolBar::toolBarAreaFromDockWidgetArea( Qt::DockWidgetArea dockWidgetArea )
 {
     switch ( dockWidgetArea ) {
     case Qt::LeftDockWidgetArea:
         return Qt::LeftToolBarArea;
     case Qt::RightDockWidgetArea:
         return Qt::RightToolBarArea;
     case Qt::TopDockWidgetArea:
         return Qt::TopToolBarArea;
     case Qt::BottomDockWidgetArea:
         return Qt::BottomToolBarArea;
 
     case Qt::AllDockWidgetAreas:
         return Qt::AllToolBarAreas;
     case Qt::NoDockWidgetArea:
     default:
         return Qt::NoToolBarArea;
     }
 }
 
 DockToolButtonAction *DockToolBar::actionForDockWidget( QDockWidget *dockWidget )
 {
     foreach ( QAction *action, actions() ) {
         DockToolButtonAction *dockAction = qobject_cast< DockToolButtonAction* >( action );
         if ( dockAction ) {
             if ( dockAction->dockWidget() == dockWidget ) {
                 return dockAction;
             }
         } else {
-            kWarning() << "Wrong action type in DockToolBar" << action;
+            qWarning() << "Wrong action type in DockToolBar" << action;
         }
     }
 
     // No action found for dockWidget
     return 0;
 }
 
 void DockToolBar::actionEvent( QActionEvent *event )
 {
     DockToolButtonAction *action = qobject_cast< DockToolButtonAction* >( event->action() );
     if ( !action ) {
         return;
     }
 
     switch ( event->type() ) {
     case QEvent::ActionAdded:
         if ( m_group->checkedAction() && action->isChecked() ) {
             // If there is a checked action and the new action is also checked,
             // uncheck the previously checked action,
             // ie. only allow one QDockWidget per area to be shown
             m_group->checkedAction()->setChecked( false );
         }
         m_group->addAction( action );
         break;
     case QEvent::ActionRemoved:
         m_group->removeAction( action );
         break;
     default:
         break;
     }
 
     QToolBar::actionEvent( event );
 }
diff --git a/engine/timetablemate/src/docks/documentationdockwidget.cpp b/engine/timetablemate/src/docks/documentationdockwidget.cpp
index 8757f88..aa01fd3 100644
--- a/engine/timetablemate/src/docks/documentationdockwidget.cpp
+++ b/engine/timetablemate/src/docks/documentationdockwidget.cpp
@@ -1,148 +1,148 @@
 /*
 *   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 "documentationdockwidget.h"
 
 // KDE includes
 #include <KComboBox>
 #include <KWebView>
 #include <KToolBar>
 #include <KIcon>
 #include <KStandardAction>
 #include <KLocalizedString>
 #include <KGlobal>
 #include <KDebug>
 #include <KStandardDirs>
 #include <KAction>
 
 // Qt includes
 #include <QBoxLayout>
 #include <QMouseEvent>
 #include <QWebFrame>
 #include <QWebElement>
 
 DocumentationDockWidget::DocumentationDockWidget( KActionMenu *showDocksAction, QWidget *parent )
         : AbstractDockWidget( i18nc("@title:window Dock title", "Documentation"),
                              showDocksAction, parent )
 {
     setObjectName( "documentation" );
 
     setWhatsThis( i18nc("@info:whatsthis", "<title>Documentation</title>"
                         "<para>Provides documentation for Public Transport engine scripts.</para>") );
 
     QWidget *container = new QWidget( this );
     container->setMinimumSize( 150, 150 );
     m_documentationChooser = new KComboBox( container );
     KIcon classIcon( "code-class" );
     m_documentationChooser->addItem( KIcon("go-home"), "Documentation Home", "index" );
     m_documentationChooser->addItem( KIcon("code-variable"), "Enumerations", "enums" );
     m_documentationChooser->addItem( classIcon, "Helper Object", "helper" );
     m_documentationChooser->addItem( classIcon, "Result Object", "resultobject" );
     m_documentationChooser->addItem( classIcon, "Network Object", "network" );
     m_documentationChooser->addItem( classIcon, "NetworkRequest Objects", "networkrequest" );
     m_documentationChooser->addItem( classIcon, "Storage Object", "storage" );
     m_documentationChooser->addItem( classIcon, "DataStream Object", "datastreamprototype" );
     m_documentationWidget = new KWebView( container );
     m_documentationWidget->pageAction( QWebPage::OpenLinkInNewWindow )->setVisible( false );
     m_documentationWidget->pageAction( QWebPage::OpenFrameInNewWindow )->setVisible( false );
     m_documentationWidget->pageAction( QWebPage::OpenImageInNewWindow )->setVisible( false );
     KToolBar *toolBar = new KToolBar( "DocumentationToolBar", container );
     toolBar->setToolButtonStyle( Qt::ToolButtonIconOnly );
     toolBar->addAction( m_documentationWidget->pageAction(QWebPage::Back) );
     toolBar->addAction( m_documentationWidget->pageAction(QWebPage::Forward) );
     toolBar->addWidget( m_documentationChooser );
     connect( m_documentationWidget, SIGNAL(urlChanged(QUrl)),
              this, SLOT(documentationUrlChanged(QUrl)) );
     QVBoxLayout *dockLayout = new QVBoxLayout( container );
     dockLayout->setSpacing( 0 );
     dockLayout->setContentsMargins( 0, 0, 0, 0 );
     dockLayout->addWidget( toolBar );
     dockLayout->addWidget( m_documentationWidget );
     setWidget( container );
     connect( m_documentationChooser, SIGNAL(currentIndexChanged(int)),
              this, SLOT(documentationChosen(int)) );
 }
 
 void DocumentationDockWidget::showEvent( QShowEvent *event )
 {
     if ( !m_documentationWidget->url().isValid() ) {
         // Load documentation HTML when the dock widget gets shown for the first time
         documentationChosen( 0 );
     }
     QWidget::showEvent( event );
 }
 
 void DocumentationDockWidget::showDocumentation( const QString &key )
 {
     const int pos = key.indexOf( '|' );
     if ( pos == -1 ) {
-        kWarning() << "Invalid documentation key:" << key;
+        qWarning() << "Invalid documentation key:" << key;
         return;
     }
     QString className = key.left( pos ).toLower();
     if ( className.isEmpty() ) {
         className = "index";
     }
     const QString scriptClassName =
             className == QLatin1String("resultobject") ? "result" : className;
     const QString name = key.mid( pos + 1 ).toLower();
     const QString anchor = '#' +
             (className == QLatin1String("index") ? "script_functions_" + name
                                                  : scriptClassName + '-' + name);
 
     const QString documentationFileName = KGlobal::dirs()->findResource(
             "data", QString("timetablemate/doc/%1.html").arg(className) );
     if ( documentationFileName.isEmpty() ) {
-        kWarning() << "Documentation for" << className << "not found";
+        qWarning() << "Documentation for" << className << "not found";
         return;
     }
 
     m_documentationWidget->setUrl( QUrl("file://" + documentationFileName + anchor) );
 }
 
 void DocumentationDockWidget::documentationChosen( int index )
 {
     const QString page = m_documentationChooser->itemData( index ).toString();
     const QString documentationFileName = KGlobal::dirs()->findResource(
             "data", QString("timetablemate/doc/%1.html").arg(page) );
     m_documentationWidget->load( QUrl("file://" + documentationFileName) );
 }
 
 void DocumentationDockWidget::documentationUrlChanged( const QUrl &url )
 {
     QRegExp regExp("/doc/(.*)\\.html(?:#.*)?$");
     if ( regExp.indexIn(url.toString()) != -1 ) {
         const QString page = regExp.cap( 1 );
         const int index = m_documentationChooser->findData( page );
         if ( index != -1 ) {
             const bool wasBlocked = m_documentationChooser->blockSignals( true );
             m_documentationChooser->setCurrentIndex( index );
             m_documentationChooser->blockSignals( wasBlocked );
         } else {
             kDebug() << "Documentation page not found:" << page;
         }
     } else {
         kDebug() << "Unexpected url format:" << url;
     }
 }
 
 QWidget *DocumentationDockWidget::mainWidget() const {
     return m_documentationWidget;
 }
diff --git a/engine/timetablemate/src/docks/projectsdockwidget.cpp b/engine/timetablemate/src/docks/projectsdockwidget.cpp
index ac86698..2b6f32c 100644
--- a/engine/timetablemate/src/docks/projectsdockwidget.cpp
+++ b/engine/timetablemate/src/docks/projectsdockwidget.cpp
@@ -1,309 +1,309 @@
 /*
 *   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 "projectsdockwidget.h"
 
 // Own includes
 #include "config.h"
 #include "../projectmodel.h"
 #include "../tabs/projectsourcetab.h"
 #include "../project.h"
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     #include "../tabs/scripttab.h"
 #endif
 
 // KDE includes
 #include <KLocalizedString>
 #include <KIconLoader>
 #include <KDebug>
 #include <KIcon>
 #include <KMenu>
 #include <KFileDialog>
 #include <KLineEdit>
 
 // Qt includes
 #include <QLabel>
 #include <QBoxLayout>
 #include <QTreeView>
 #include <QFormLayout>
 #include <QSortFilterProxyModel>
 
 ProjectsDockWidget::ProjectsDockWidget( ProjectModel *model, KActionMenu *showDocksAction,
                                         QWidget *parent )
         : AbstractDockWidget( i18nc("@title:window Dock title", "Projects"),
                              showDocksAction, parent ),
           m_model(model), m_projectsWidget(0), m_searchLine(0),
           m_proxyModel(new QSortFilterProxyModel(this))
 {
     setObjectName( "projects" );
 
     setWhatsThis( i18nc("@info:whatsthis", "<title>Opened projects</title>"
                         "<para>Shows a list of all opened projects. For each project a set of "
                         "tabs can be opened using the child items. There are handy context menus "
                         "available.</para>"
                         "<para>One project is always the <interface>Active Project</interface> "
                         "(if at least one is loaded). Menu and toolbar actions get connected to "
                         "the active project and the other docks show data for or control the "
                         "active project.</para>") );
 
     QWidget *container = new QWidget( this );
     container->setMinimumSize( 150, 150 );
 
     m_searchLine = new KLineEdit( container );
     m_searchLine->setClickMessage(
             i18nc("@info/plain A KLineEdit click message to filter projects", "Type to search") );
     m_searchLine->setClearButtonShown( true );
 
     m_proxyModel->setSourceModel( model );
     m_proxyModel->setFilterCaseSensitivity( Qt::CaseInsensitive );
     connect( m_searchLine, SIGNAL(textChanged(QString)),
              m_proxyModel, SLOT(setFilterFixedString(QString)) );
 
     m_projectsWidget = new QTreeView( container );
     m_projectsWidget->setModel( m_proxyModel );
     m_projectsWidget->setHeaderHidden( true );
     m_projectsWidget->setIndentation( 10 );
     m_projectsWidget->setAnimated( true );
     m_projectsWidget->setExpandsOnDoubleClick( true );
     m_projectsWidget->setEditTriggers( QAbstractItemView::NoEditTriggers );
     m_projectsWidget->setContextMenuPolicy( Qt::CustomContextMenu );
     QSizePolicy sizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
     sizePolicy.setVerticalStretch( 1 );
     m_projectsWidget->setSizePolicy( sizePolicy );
 
     QFormLayout *projectsLayout = new QFormLayout( container );
     projectsLayout->setContentsMargins( 0, 0, 0, 0 );
     projectsLayout->setVerticalSpacing( 0 );
     projectsLayout->setRowWrapPolicy( QFormLayout::WrapLongRows );
     projectsLayout->addRow( m_searchLine );
     projectsLayout->addRow( m_projectsWidget );
     setWidget( container );
     connect( m_projectsWidget, SIGNAL(doubleClicked(QModelIndex)),
              this, SLOT(projectItemDoubleClicked(QModelIndex)) );
     connect( m_projectsWidget, SIGNAL(customContextMenuRequested(QPoint)),
              this, SLOT(projectItemContextMenuRequested(QPoint)) );
 }
 
 void ProjectsDockWidget::projectItemDoubleClicked( const QModelIndex &proxyIndex )
 {
     const QModelIndex index = ( proxyIndex.model() != m_model)
             ? m_proxyModel->mapToSource(proxyIndex) : proxyIndex;
     if ( !m_model->flags(index).testFlag(Qt::ItemIsEnabled) ) {
         // A disabled item was double clicked
         return;
     }
 
     ProjectModelItem *projectItem = m_model->projectItemFromIndex( index );
     Project *project = projectItem->project();
     if ( index.parent().isValid() ) {
         // Is a child of the project root
         switch ( projectItem->type() ) {
         case ProjectModelItem::DashboardItem:
             project->showDashboardTab( this );
             break;
         case ProjectModelItem::ProjectSourceItem:
             project->showProjectSourceTab( this );
             break;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         case ProjectModelItem::ScriptItem:
             project->showScriptTab( this );
             break;
         case ProjectModelItem::IncludedScriptItem: {
             ProjectModelIncludedScriptItem *includedScriptItem =
                     dynamic_cast< ProjectModelIncludedScriptItem* >( projectItem );
             project->showExternalScriptTab( includedScriptItem->filePath(), this );
             break;
         }
         case ProjectModelItem::CodeItem: {
             ProjectModelCodeItem *codeItem = dynamic_cast< ProjectModelCodeItem* >( projectItem );
             ProjectModelIncludedScriptItem *includedScriptItem = // TODO
                     dynamic_cast< ProjectModelIncludedScriptItem* >( codeItem->parent() );
             if ( includedScriptItem ) {
                 Q_ASSERT( !includedScriptItem->filePath().isEmpty() );
             }
             ScriptTab *scriptTab = includedScriptItem
                     ? project->showExternalScriptTab(includedScriptItem->filePath(), this)
                     : project->showScriptTab(this);
             Q_ASSERT( scriptTab );
             scriptTab->goToLine( codeItem->node()->line() );
             break;
         }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         case ProjectModelItem::GtfsDatabaseItem:
             project->showGtfsDatabaseTab( this );
             break;
 #endif // BUILD_PROVIDER_TYPE_GTFS
         case ProjectModelItem::PlasmaPreviewItem:
             project->showPlasmaPreviewTab( this );
             break;
         case ProjectModelItem::WebItem:
             project->showWebTab( this );
             break;
         case ProjectModelItem::ProjectItem:
             // Project root item double clicked, do nothing
             break;
         default:
-            kWarning() << "Project model item type unknown" << projectItem->type();
+            qWarning() << "Project model item type unknown" << projectItem->type();
             return;
         }
     }
 }
 
 void ProjectsDockWidget::projectItemContextMenuRequested( const QPoint &pos )
 {
     const QModelIndex proxyIndex = m_projectsWidget->indexAt( pos );
     if ( !proxyIndex.isValid() ) {
         return; // No item clicked
     }
 
     const QModelIndex index = ( proxyIndex.model() != m_model)
             ? m_proxyModel->mapToSource(proxyIndex) : proxyIndex;
     ProjectModelItem *projectItem = m_model->projectItemFromIndex( index );
     Project *project = projectItem->project();
     if ( index.parent().isValid() ) {
         // Show context menu for child item
         KMenu *projectMenu = new KMenu( this );
         const TabType tabType = ProjectModelItem::tabTypeFromProjectItemType( projectItem->type() );
         QAction *openInTabAction = 0;
         QAction *closeTabAction = 0;
         QAction *documentSaveAction = 0;
         ProjectSourceTab *projectSourceTab = project->projectSourceTab();
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         QAction *showCodeNodeAction = 0;
         ProjectModelCodeItem *codeItem = dynamic_cast< ProjectModelCodeItem* >( projectItem );
         ProjectModelIncludedScriptItem *includedScriptItem =
                 dynamic_cast< ProjectModelIncludedScriptItem* >( projectItem );
         ScriptTab *scriptTab = projectItem->isIncludedScriptItem()
                 ? project->scriptTab(includedScriptItem->filePath()) : project->scriptTab();
         AbstractTab *tab = includedScriptItem ? project->scriptTab(includedScriptItem->filePath())
                                               : project->tab(tabType);
 #else
         AbstractTab *scriptTab = 0; // Dummy for less #ifdefs
         bool includedScriptItem = false;
         AbstractTab *tab = project->tab( tabType );
 #endif
 
         if ( tab ) {
             projectMenu->addTitle( tab->icon(), tab->title() );
         } else {
             projectMenu->addTitle( m_model->data(index, Qt::DecorationRole).value<QIcon>(),
                                    m_model->data(index, Qt::DisplayRole).toString() );
         }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         // Add an action to open the associated tab / create the document and open it in a tab
         if ( codeItem ) {
             showCodeNodeAction = projectMenu->addAction( KIcon("arrow-right"),
                                            i18nc("@item:inmenu", "Show in Script Tab"));
         } else
 #endif
         {
             const bool tabOpened = includedScriptItem
                     ? bool(scriptTab) : project->isTabOpened(tabType);
             if ( !tabOpened ) {
                 // Tab for the project item is not opened, add an open/create action
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                 const QString fileName = includedScriptItem
                         ? includedScriptItem->filePath() : project->scriptFileName();
 #else
                 const QString fileName = project->scriptFileName();
 #endif
                 openInTabAction =
                         fileName.isEmpty() && project->data()->type() == Enums::ScriptedProvider
                         ? projectMenu->addAction(KIcon("document-new"),
                                                  i18nc("@item:inmenu", "Create From Template"))
                         : projectMenu->addAction(KIcon("document-open"),
                                                  i18nc("@item:inmenu", "Open in Tab"));
             }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             // Add an action to open external script files for the script item
             if ( projectItem->isScriptItem() ) {
                 QAction *openExternalAction = project->projectAction( Project::ShowExternalScript );
                 projectMenu->addAction( openExternalAction );
             }
 #endif
 
             // Add a save action for document items
             if ( projectItem->isProjectSourceItem() || projectItem->isScriptItem() ||
                  projectItem->isIncludedScriptItem() )
             {
                 documentSaveAction = projectMenu->addAction( KIcon("document-save"),
                                                             i18nc("@item:inmenu", "Save Document") );
                 documentSaveAction->setEnabled(
                         (projectItem->isProjectSourceItem() && projectSourceTab && projectSourceTab->isModified()) ||
                         ((projectItem->isScriptItem() || projectItem->isIncludedScriptItem()) &&
                          scriptTab && scriptTab->isModified()) );
             }
 
             // Add a tab close action
             if ( tabOpened ) {
                 // Tab for the project item is already opened
                 closeTabAction = projectMenu->addAction(KIcon("tab-close"),
                         i18nc("@item:inmenu", "Close Tab"));
             }
         }
 
         // Add a title "Project" and context menu actions of the project
         projectMenu->addTitle( KIcon("project-development"),
                                i18nc("@title:menu In-menu title", "Project") );
         projectMenu->addActions( project->contextMenuActions(this) );
 
         // Show the context menu
         QAction *triggeredAction = projectMenu->exec( m_projectsWidget->mapToGlobal(pos) );
         delete projectMenu;
 
         if ( triggeredAction == 0 ) {
             return;
         } else if ( triggeredAction == openInTabAction ) {
             // Open project item in a tab
             projectItemDoubleClicked( index );
         } else if ( triggeredAction == closeTabAction ) {
             // Close the tab
             project->closeTab( tab );
         } else if ( triggeredAction == documentSaveAction ) {
             // Save project item
             if ( projectItem->isProjectSourceItem() && projectSourceTab ) {
                 projectSourceTab->save();
             } else if ( scriptTab &&
                         (projectItem->isScriptItem() || projectItem->isIncludedScriptItem()) )
             {
                 scriptTab->save();
             }
         }
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         else if ( triggeredAction == showCodeNodeAction ) {
             ScriptTab *scriptTab = projectItem->isIncludedScriptItem()
                     ? project->showExternalScriptTab(includedScriptItem->filePath(), this)
                     : project->showScriptTab( this );
             scriptTab->goToLine( codeItem->node()->line() );
         }
 #endif
     } else {
         // A project item was clicked, open the project context menu
         project->showProjectContextMenu( m_projectsWidget->mapToGlobal(pos) );
     }
 }
 
 QWidget *ProjectsDockWidget::mainWidget() const {
     return m_projectsWidget;
 }
 
diff --git a/engine/timetablemate/src/javascriptmodel.cpp b/engine/timetablemate/src/javascriptmodel.cpp
index d3b1697..cd59218 100644
--- a/engine/timetablemate/src/javascriptmodel.cpp
+++ b/engine/timetablemate/src/javascriptmodel.cpp
@@ -1,482 +1,482 @@
 /*
 *   Copyright 2012 Friedrich Pülz <fieti1983@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.
 */
 
 #include "javascriptmodel.h"
 #include "javascriptparser.h"
 #include "javascriptcompletionmodel.h"
 
 #include <KDebug>
 #include <KLocalizedString>
 #include <KIcon>
 #include <KTextEditor/Cursor>
 
 JavaScriptModel::JavaScriptModel( QObject* parent ) : QAbstractItemModel( parent ),
         m_javaScriptCompletionModel(0)
 {
 }
 
 JavaScriptModel::~JavaScriptModel()
 {
     clear();
 }
 
 QString JavaScriptModel::nodeTypeName( NodeType nodeType )
 {
     switch ( nodeType ) {
     case NoNodeType:
     case UnknownNodeType:
         return i18nc("info", "Unknown code element");
     case Block:
         return i18nc("info", "Code block");
     case Function:
         return i18nc("info", "Function");
     case Argument:
         return i18nc("info", "Argument");
     case Statement:
         return i18nc("info", "Statement");
     case Comment:
         return i18nc("info", "Comment");
     case String:
         return i18nc("info", "String");
     case FunctionCall:
         return i18nc("info", "Function call");
     case Bracketed:
         return i18nc("info", "Bracketed region");
     default:
-        kWarning() << "Unknown NodeType" << nodeType;
+        qWarning() << "Unknown NodeType" << nodeType;
         return "- not implemented -";
     }
 }
 
 void JavaScriptModel::needTextHint( const KTextEditor::Cursor &position, QString &text )
 {
     if ( !m_javaScriptCompletionModel ) {
         kDebug() << "No completion model created";
         return;
     }
 
     CodeNode::Ptr node = nodeFromLineNumber( position.line() + 1, position.column(), MatchChildren );
     if ( !node /*|| node->line() != position.line() + 1*/ ) {
         return;
     }
 
     QList<CompletionItem> items = m_javaScriptCompletionModel->completionItemsFromId( node->id() );
     if ( items.isEmpty() || !items.first().isValid() || items.first().description.isEmpty() ) {
         // Show what information is available for the code node
         text.clear();
         CodeNode *currentNode = node.data();
         int level = 0;
         while ( currentNode ) {
             if ( text.isEmpty() ) {
                 text.append( "<nobr>" );
             } else {
                 text.append( "<br /><nobr>" + i18nc("@info", "Parent %1 (line %2): ",
                                                     level, currentNode->line()) );
             }
             text.append( "<b>" + nodeTypeName(currentNode->type()) + "</b>" );
             if ( !currentNode->text().isEmpty() && currentNode->text().length() < 60 ) {
                 text.append( " (<tt>" +
                         currentNode->text().replace("<", "&lt;").replace(">", "&gt;") + "</tt>)" );
             }
             if ( !currentNode->children().isEmpty() ) {
                 text.append( ", " + i18ncp("@info", "%1 child element", "%1 child elements",
                                            currentNode->children().count()) );
             }
             text.append( "</nobr>" );
             currentNode = currentNode->parent();
             ++level;
         }
         emit showTextHint( position, text );
         return;
     }
 
     text = QString("<table style='margin: 3px;'><tr><td style='font-size:large;'>"
             "<nobr>%1<b>%2</b></nobr><hr></td></tr><tr><td>%3</td></tr>")
             .arg(node->type() == Function ? i18n("Function: ") : QString(),
             items.first().name, items.first().description);
 
     // The KatePart only prints a debug message...
     emit showTextHint( position, text );
 }
 
 QModelIndex JavaScriptModel::indexFromNode( const CodeNode::Ptr &node ) const
 {
     if ( !m_nodes.contains(node) ) {
         return QModelIndex();
     } else {
         return createIndex( m_nodes.indexOf(node), 0, node.data() );
     }
 }
 
 QModelIndex JavaScriptModel::indexFromNodePointer( CodeNode *nodePointer,
                                                    const CodeNode::Ptr &parent ) const
 {
     if ( parent ) {
         const QList< CodeNode::Ptr > children = parent->children();
         for ( int row = 0; row < children.count(); ++row ) {
             const CodeNode::Ptr &node = children[ row ];
             if ( node.data() == nodePointer ) {
                 return createIndex( row, 0, nodePointer );
             }
 
             const QModelIndex index = indexFromNodePointer( nodePointer, node );
             if ( index.isValid() ) {
                 return index;
             }
         }
     } else {
         for ( int row = 0; row < m_nodes.count(); ++row ) {
             const CodeNode::Ptr &node = m_nodes[ row ];
             if ( node.data() == nodePointer ) {
                 return createIndex( row, 0, nodePointer );
             }
 
             const QModelIndex index = indexFromNodePointer( nodePointer, node );
             if ( index.isValid() ) {
                 return index;
             }
         }
     }
 
     // Node not found
     return QModelIndex();
 }
 
 CodeNode::Ptr JavaScriptModel::nodeFromNodePointer( CodeNode *nodePointer,
                                                     const CodeNode::Ptr &parent ) const
 {
     if ( parent ) {
         const QList< CodeNode::Ptr > children = parent->children();
         foreach ( const CodeNode::Ptr &node, children ) {
             if ( node.data() == nodePointer ) {
                 return node;
             }
 
             const CodeNode::Ptr childNode = nodeFromNodePointer( nodePointer, node );
             if ( childNode ) {
                 return childNode;
             }
         }
     } else {
         foreach ( const CodeNode::Ptr &node, m_nodes ) {
             if ( node.data() == nodePointer ) {
                 return node;
             }
 
             const CodeNode::Ptr childNode = nodeFromNodePointer( nodePointer, node );
             if ( childNode ) {
                 return childNode;
             }
         }
     }
 
     // Node not found
     return CodeNode::Ptr( 0 );
 }
 
 CodeNode::Ptr JavaScriptModel::nodeFromIndex( const QModelIndex &index ) const
 {
     if ( !index.isValid() ) {
         return CodeNode::Ptr( 0 );
     }
 
     if ( index.parent().isValid() ) {
         CodeNode *nodePointer = nodePointerFromIndex( index );
         CodeNode *parent = nodePointerFromIndex( index.parent() );
         const QList< CodeNode::Ptr > children = parent->children();
         for ( int row = 0; row < children.count(); ++row ) {
             const CodeNode::Ptr &node = children[ row ];
             if ( node.data() == nodePointer ) {
                 return node;
             }
         }
         // Invalid index
         return CodeNode::Ptr( 0 );
     } else if ( index.row() >= m_nodes.count() ) {
         // Invalid index
         return CodeNode::Ptr( 0 );
     } else {
         return m_nodes[ index.row() ];
     }
 }
 
 CodeNode *JavaScriptModel::nodePointerFromIndex( const QModelIndex& index ) const
 {
     return static_cast< CodeNode* >( index.internalPointer() );
 }
 
 CodeNode::Ptr JavaScriptModel::nodeFromRow( int row ) const
 {
     return m_nodes.at( row );
 }
 
 CodeNode::Ptr JavaScriptModel::nodeFromLineNumber( int lineNumber, int column,
                                                MatchOptions matchOptions )
 {
     foreach ( const CodeNode::Ptr &node, m_nodes ) {
         if ( /* !matchOptions.testFlag(MatchOnlyFirstRowOfSpanned) TODO Remove flag
             && */ node->isInRange(lineNumber, column) )
         {
             if ( matchOptions.testFlag(MatchChildren) ) {
                 return nodeFromNodePointer( node->childFromPosition(lineNumber, column) );
             } else {
                 return node;
             }
         }
     }
 
     return createAndAddEmptyNode();
 }
 
 CodeNode::Ptr JavaScriptModel::nodeBeforeLineNumber( int lineNumber, NodeTypes nodeTypes )
 {
     CodeNode::Ptr lastFoundNode( 0 );
     foreach ( const CodeNode::Ptr &node, m_nodes ) {
         if ( node->type() == NoNodeType || !nodeTypes.testFlag(node->type()) ) {
             continue;
         }
 
         if ( node->line() < lineNumber ) {
             lastFoundNode = node;
         } else if ( node->line() > lineNumber ) {
             break;
         }
 
         if ( lineNumber >= node->line() && lineNumber <= node->endLine() ) {
             return node;
         }
     }
 
     return lastFoundNode ? lastFoundNode : createAndAddEmptyNode().dynamicCast<CodeNode>();
 }
 
 CodeNode::Ptr JavaScriptModel::nodeAfterLineNumber( int lineNumber, NodeTypes nodeTypes )
 {
     CodeNode::Ptr lastFoundNode( 0 );
     for ( int i = m_nodes.count() - 1; i >= 0; --i ) {
         CodeNode::Ptr node = m_nodes.at( i );
         if ( node->type() == NoNodeType || !nodeTypes.testFlag(node->type()) ) {
             continue;
         }
 
         if ( node->line() > lineNumber ) {
             lastFoundNode = node;
         } else if ( node->line() < lineNumber ) {
             break;
         }
 
         if ( lineNumber >= node->line() && lineNumber <= node->endLine() ) {
             return node;
         }
     }
     return lastFoundNode ? lastFoundNode : createAndAddEmptyNode().dynamicCast<CodeNode>();
 }
 
 EmptyNode::Ptr JavaScriptModel::createAndAddEmptyNode()
 {
     EmptyNode::Ptr node( 0 );
     if ( !m_nodes.isEmpty() ) {
         node = m_nodes.first().dynamicCast<EmptyNode>();
     }
     if ( !node ) {
         node = EmptyNode::Ptr( new EmptyNode );
         beginInsertRows( QModelIndex(), 0, 0 );
         m_nodes.prepend( node );
         updateFirstEmptyNodeName();
         endInsertRows();
     }
 
     return node;
 }
 
 QModelIndex JavaScriptModel::index( int row, int column, const QModelIndex& parent ) const
 {
     if ( row < 0 || column < 0 ) {
         return QModelIndex();
     }
 
     if ( parent.isValid() ) {
         CodeNode *parentNode = nodePointerFromIndex( parent );
         if ( row >= parentNode->children().count() ) {
             return QModelIndex();
         }
         return createIndex( row, column, parentNode );
     } else {
         if ( row >= m_nodes.count() ) {
             return QModelIndex();
         }
         return createIndex( row, column, m_nodes[row].data() );
     }
 }
 
 int JavaScriptModel::rowCount( const QModelIndex &parent ) const
 {
     if ( parent.isValid() ) {
         CodeNode *node = nodePointerFromIndex( parent );
         return node->children().count();
     } else {
         return m_nodes.count();
     }
 }
 
 QModelIndex JavaScriptModel::parent( const QModelIndex &child ) const
 {
     CodeNode *childNode = nodePointerFromIndex( child );
     if ( childNode->parent() ) {
         return indexFromNodePointer( childNode->parent() );
     } else {
         return QModelIndex();
     }
 }
 
 QVariant JavaScriptModel::data( const QModelIndex& index, int role ) const
 {
     CodeNode *item = nodePointerFromIndex( index );
 
     if ( role == Qt::UserRole ) {
         return item->type();
     }
 
     FunctionNode *function = dynamic_cast< FunctionNode* >( item );
     if ( function ) {
         switch ( role ) {
         case Qt::DisplayRole: {
             QString indentation;
             CodeNode *parent = function->parent();
             while ( parent ) {
                 if ( dynamic_cast<FunctionNode*>(parent) ) {
                     indentation += "    ";
                 }
                 parent = parent->parent();
             }
             return indentation + function->toStringSignature();
         }
         case Qt::DecorationRole:
             return KIcon("code-function");
         }
     } else {
         EmptyNode *empty = dynamic_cast< EmptyNode* >( item );
         if ( empty && role == Qt::DisplayRole ) {
             return empty->text();
         }
     }
 
     return QVariant();
 }
 
 bool JavaScriptModel::removeRows( int row, int count, const QModelIndex& parent )
 {
     beginRemoveRows( parent, row, row + count - 1 );
     for ( int i = 0; i < count; ++i ) {
         delete m_nodes.takeAt( row ).data();
     }
     endRemoveRows();
 
     updateFirstEmptyNodeName();
     return true;
 }
 
 void JavaScriptModel::clear()
 {
     beginRemoveRows( QModelIndex(), 0, m_nodes.count() - 1 );
     foreach ( const CodeNode::Ptr &node, m_nodes ) {
         if ( node->parent() ) {
             kDebug() << "Toplevel node had a parent set!" << node << node->parent();
         }
     }
     m_nodes.clear();
     endRemoveRows();
 }
 
 void JavaScriptModel::appendNodes( const QList< CodeNode::Ptr > nodes )
 {
     beginInsertRows( QModelIndex(), m_nodes.count(), m_nodes.count() + nodes.count() - 1 );
     m_nodes << nodes;
     endInsertRows();
 
     updateFirstEmptyNodeName();
 }
 
 QList< CodeNode::Ptr > JavaScriptModel::childFunctions( const CodeNode::Ptr &node )
 {
     QList< CodeNode::Ptr > flatNodes;
     foreach ( const CodeNode::Ptr &child, node->children() ) {
         FunctionNode::Ptr function = child.dynamicCast< FunctionNode >();
         if ( function && function->isAnonymous() ) {
             flatNodes << function;
         }
 
         flatNodes << childFunctions( child );
     }
     return flatNodes;
 }
 
 void JavaScriptModel::setNodes( const QList< CodeNode::Ptr > nodes )
 {
     clear();
 
     QList< CodeNode::Ptr > flatNodes = QList< CodeNode::Ptr >() << nodes;
     foreach ( const CodeNode::Ptr &node, nodes ) {
         flatNodes << childFunctions( node );
     }
 
     beginInsertRows( QModelIndex(), 0, flatNodes.count() - 1 );
     m_nodes = flatNodes;
     endInsertRows();
 
     updateFirstEmptyNodeName();
 }
 
 QStringList JavaScriptModel::functionNames() const
 {
     QStringList functions;
     foreach ( const CodeNode::Ptr &node, m_nodes ) {
         FunctionNode::Ptr function = node.dynamicCast< FunctionNode >();
         if ( function ) {
             functions << function->name();
         } else {
             // Also add anynomous function declarations, they may be childs of StatementNode's,
             // eg. "var test = function(){};"
             foreach ( const CodeNode::Ptr &child, node->children() ) {
                 FunctionNode::Ptr childFunction = child.dynamicCast< FunctionNode >();
                 if ( childFunction ) {
                     functions << childFunction->name();
                 }
             }
         }
     }
     return functions;
 }
 
 void JavaScriptModel::updateFirstEmptyNodeName()
 {
     if ( m_nodes.isEmpty() ) {
         return;
     }
 
     EmptyNode::Ptr node = m_nodes.first().dynamicCast< EmptyNode >();
     if ( node ) {
         if ( m_nodes.count() == 1 ) {
             node->setText( i18nc("@info/plain", "(no functions)") );
         } else {
             node->setText( i18ncp("@info/plain", "%1 function:",
                                   "%1 functions:", m_nodes.count() - 1) );
         }
     }
 }
diff --git a/engine/timetablemate/src/javascriptparser.cpp b/engine/timetablemate/src/javascriptparser.cpp
index 00ebe3a..908d6cc 100644
--- a/engine/timetablemate/src/javascriptparser.cpp
+++ b/engine/timetablemate/src/javascriptparser.cpp
@@ -1,974 +1,974 @@
 /*
  *   Copyright 2012 Friedrich Pülz <fieti1983@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.
  */
 
 #include "javascriptparser.h"
 #include "javascriptcompletiongeneric.h"
 
 #include <QHash>
 #include <KLocalizedString>
 
 CodeNode::CodeNode( const QString& text, int line, int colStart, int colEnd ) : m_parent( 0 )
 {
     m_text = text;
     m_line = line;
     m_col = colStart;
     m_colEnd = colEnd;
 
     m_id = text;
 }
 
 CodeNode* CodeNode::topLevelParent() const
 {
     CodeNode *node = const_cast<CodeNode*>( this );
     while ( node->parent() ) {
         node = node->parent();
     }
     return node;
 }
 
 bool CodeNode::isInRange( int lineNumber, int column ) const
 {
     if ( lineNumber == m_line && lineNumber == endLine() ) {
         // lineNumber is in a one line node
         return column == -1 || (column >= m_col && column <= m_colEnd);
     } else if ( lineNumber == m_line ) {
         // lineNumber is at the beginning of a multiline node
         return column == -1 || column >= m_col;
     } else if ( lineNumber == endLine() )  {
         // lineNumber is at the end of a multiline node
         return column == -1 || column <= m_colEnd;
     } else if ( lineNumber > m_line && lineNumber < endLine() ) {
         // lineNumber is inside a multiline node
         return true;
     } else {
         return false;
     }
 }
 
 CodeNode *CodeNode::childFromPosition( int lineNumber, int column ) const
 {
     QList< CodeNode::Ptr > childList = children();
     foreach ( const CodeNode::Ptr &child, childList ) {
         if ( child->isInRange(lineNumber, column) ) {
             return child->childFromPosition( lineNumber, column );
         }
     }
 
     if ( isInRange(lineNumber, column) ) {
         return const_cast< CodeNode* >( this );
     } else {
         return 0;
     }
 }
 
 JavaScriptParser::JavaScriptParser( const QString &code )
 {
     m_code = code;
     m_error = NoError;
     m_errorLine = -1;
     m_errorColumn = 0;
     m_nodes = parse();
 }
 
 JavaScriptParser::~JavaScriptParser()
 {
     qDeleteAll( m_token );
 }
 
 QString JavaScriptParser::Token::whitespacesBetween( const JavaScriptParser::Token* token1,
                                                      const JavaScriptParser::Token* token2 )
 {
     if ( !token1 || !token2 ) {
-        kWarning() << "Null token given" << token1 << token2;
+        qWarning() << "Null token given" << token1 << token2;
         return QString();
     }
 
     // WARNING It is important that this function returns an empty string if there actually is no
     // whitespace between the two tokens in the document and a non-empty string if there is
     // whitespace. Otherwise parsing may fail, because it falsely thinks that eg. "//" is not the
     // beginning of a comment (two tokens "/").
     // If there is whitespace it is less important what it exactly looks like. This is only used to
     // get the original document text back from the parser result.
     const int newLines = token2->line - token1->line;
     if ( newLines > 0 ) {
         // Return newlines and spaces until token2
         // (spaces after token1 but before the newline are ignored)
         return QString( newLines, '\n' ) + QString( token2->posStart, ' ' );
     } else {
         // Both tokens are on the same line, return spaces between them
         return QString( token2->posStart - token1->posEnd - 1, ' ' );
     }
 }
 
 bool JavaScriptParser::tryMoveToNextToken()
 {
     moveToNextToken();
     if ( atEnd() ) {
         setErrorState( i18nc("@info/plain", "Unexpected end of file."),
                        m_lastToken->line, m_lastToken->posEnd );
         return false;
     } else {
         return true;
     }
 }
 
 void JavaScriptParser::moveToNextToken()
 {
     Q_ASSERT( !atEnd() );
     m_lastToken = currentToken();
     ++m_it;
 }
 
 CodeNode::Ptr JavaScriptParser::parseComment()
 {
     if ( atEnd() ) {
         return CommentNode::Ptr( 0 );
     }
     Token *curToken = currentToken();
     if ( !curToken->isChar('/') || !tryMoveToNextToken() ) {
         return CommentNode::Ptr( 0 );
     }
 
     QString text;
     if ( Token::whitespacesBetween(curToken, currentToken()).length() == 0 ) {
         if ( currentToken()->isChar('/') ) {
             for ( moveToNextToken(); !atEnd() && currentToken()->line == curToken->line;
                   moveToNextToken() )
             {
                 text += whitespaceSinceLastToken();
                 text += currentToken()->text;
             }
             return CommentNode::Ptr(
                     new CommentNode(text.trimmed(), curToken->line, curToken->posStart,
                                     m_lastToken->line, m_lastToken->posEnd) );
         } else if ( currentToken()->isChar('*') ) {
             // TODO: Remove '*' from the beginning of comment lines for [text]
             moveToNextToken();
             while ( !atEnd() ) {
                 Token *nextCommentToken = currentToken();
                 if ( nextCommentToken->isChar('*') ) {
                     moveToNextToken();
                     if ( atEnd() ) {
                         text += Token::whitespacesBetween( m_lastToken, nextCommentToken );
                         text += '*';
                         setErrorState( i18nc("@info/plain", "Unclosed multiline comment"),
                                        nextCommentToken->line, nextCommentToken->posEnd );
                         break;
                     } else if ( currentToken()->isChar('/') ) {
                         moveToNextToken();
                         return CommentNode::Ptr(
                                 new CommentNode(text.trimmed(), curToken->line, curToken->posStart,
                                                 m_lastToken->line, m_lastToken->posEnd) );
                     } else {
                         text += Token::whitespacesBetween( m_lastToken, nextCommentToken );
                         text += '*';
                     }
                 } else {
                     text += Token::whitespacesBetween( m_lastToken, currentToken() );
                     text += currentToken()->text;
                     moveToNextToken();
                 }
             } // while ( it != token.constEnd() )
         } else {
             --m_it; // go back to the first '/' that wasn't part of a comment, ie. '//' or '/*'
         }
     } else {
         --m_it; // go back to the first '/' that wasn't part of a comment, ie. '//' or '/*'
     }
 
     // No comment found
     return CommentNode::Ptr( 0 );
 }
 
 CodeNode::Ptr JavaScriptParser::parseBracketed()
 {
     if ( atEnd() ) {
         return CodeNode::Ptr( 0 );
     }
     Token *beginToken = currentToken();
 //     m_lastToken = beginToken;
     // '{' is matched by parseBlock
     if ( !beginToken->isChar('(') && !beginToken->isChar('[') ) {
         return CodeNode::Ptr( 0 );
     }
 
     // Get the end character (closing bracket)
     QChar endChar = beginToken->text.at( 0 ) == '(' ? ')' : ']';
 
     Token *lastCommaToken = beginToken;
     moveToNextToken();
     QList< CodeNode::Ptr > children;
     QString text, textSinceLastComma;
     while ( !atEnd() ) {
         CodeNode::Ptr node( 0 );
         text += Token::whitespacesBetween( m_lastToken, currentToken() );
         // Check for end character
         if ( currentToken()->isChar(endChar) ) {
             if ( !textSinceLastComma.isEmpty() ) {
                 children << CodeNode::Ptr(
                         new UnknownNode(textSinceLastComma, lastCommaToken->line,
                                         lastCommaToken->posStart, m_lastToken->posEnd) );
             }
             moveToNextToken();
             return BracketedNode::Ptr(
                     new BracketedNode(beginToken->text.at(0), text, beginToken->line,
                                       beginToken->posStart, m_lastToken->line, m_lastToken->posEnd,
                                       children) );
         } else if ( currentToken()->isChar('}') ) {
 //             qDeleteAll( children );
             setErrorState( i18nc("@info/plain", "Unclosed bracket, expected '%1'.", endChar),
                 beginToken->line, beginToken->posEnd );
             return CodeNode::Ptr( 0 );
         } else if ( (node = parseComment()) || (node = parseString()) || (node = parseBracketed())
             || (node = parseBlock()) || (node = parseFunction()) )
         {
             text += node->toString();
             children << node;
         } else if ( !atEnd() ) { // Could be at the end after the last else block (parse...)
             text += currentToken()->text;
             if ( currentToken()->isChar(',') ) {
                 lastCommaToken = currentToken();
                 textSinceLastComma.clear();
                 children << CodeNode::Ptr( new UnknownNode(",", currentToken()->line,
                             currentToken()->posStart, currentToken()->posEnd) );
             } else {
                 textSinceLastComma += currentToken()->text;
                 children << CodeNode::Ptr( new UnknownNode(textSinceLastComma, lastCommaToken->line,
                                 lastCommaToken->posStart, currentToken()->posEnd) );
             }
             moveToNextToken();
         }
     }
 
 //     qDeleteAll( children );
     setErrorState( i18nc("@info/plain", "Unclosed bracket, expected '%1'.", endChar),
            beginToken->line, beginToken->posEnd );
     return CodeNode::Ptr( 0 );
 }
 
 CodeNode::Ptr JavaScriptParser::parseString()
 {
     if ( atEnd() ) {
         return CodeNode::Ptr( 0 );
     }
     Token *beginToken = currentToken();
 //     m_lastToken = beginToken;
     if ( !beginToken->isChar('\"') && !beginToken->isChar('\'') ) {
         if ( !beginToken->isChar('/') ) {
             return CodeNode::Ptr( 0 ); // Not a reg exp and not a string
         }
 
         // Get the previous token
         if ( m_it != m_token.constBegin() ) {
             --m_it;
             Token *prevToken = currentToken();
             ++m_it;
 
             // If one of these comes before '/', it's the start of a regular expression
             QString allowed("=(:?");
             if ( prevToken->text.length() != 1 || !allowed.contains(prevToken->text) ) {
                 // Not a reg exp and not a string
                 return CodeNode::Ptr( 0 );
             }
         } else {
             return CodeNode::Ptr( 0 );
         }
     }
     // The end character is the same as the beginning character (", ' or / for reg exps)
     QChar endChar = beginToken->text.at( 0 );
 
     moveToNextToken();
     QString text;
     while ( !atEnd() ) {
         text += whitespaceSinceLastToken();
         // Check for non-escaped end character
         if ( currentToken()->isChar(endChar) && !m_lastToken->isChar('\\') ) {
             int columnEnd = currentToken()->posEnd;
             moveToNextToken();
             return CodeNode::Ptr( new StringNode(text, beginToken->line,
                                                  beginToken->posStart, columnEnd) );
         } else if ( (*m_it)->line != beginToken->line ) {
             if ( endChar == '/' ) {
                 setErrorState( i18nc("@info/plain", "Unclosed regular expression, "
                                      "missing %1 at end.", endChar),
                                m_lastToken->line, m_lastToken->posEnd );
             } else {
                 setErrorState( i18nc("@info/plain", "Unclosed string, "
                                      "missing %1 at end.", endChar),
                                m_lastToken->line, m_lastToken->posEnd );
             }
             return CodeNode::Ptr( 0 );
         } else {
             text += currentToken()->text;
             moveToNextToken();
         }
     }
 
     setErrorState( i18nc("@info/plain", "Unexpected end of file."),
                    m_lastToken->line, m_lastToken->posEnd );
     return CodeNode::Ptr( 0 );
 }
 
 void JavaScriptParser::checkFunctionCall( const QString &object, const QString &function,
         const BracketedNode::Ptr &bracketedNode, int line, int column )
 {
     Q_UNUSED( bracketedNode );
 //     QStringList timetableInfoStrings;
 //     timetableInfoStrings << "DepartureDateTime" << "DepartureDate" << "DepartureTime"
 //             << "TypeOfVehicle" << "TransportLine" << "FlightNumber" << "Target"
 //             << "Platform" << "Delay" << "DelayReason" << "JourneyNews"
 //             << "JourneyNewsOther" << "JourneyNewsLink" << "Operator" << "Status"
 //             << "RouteStops" << "RouteTimes" << "RouteTimesDeparture"
 //             << "RouteTimesArrival" << "RouteExactStops" << "RouteTypesOfVehicles"
 //             << "RouteTransportLines" << "RoutePlatformsDeparture" << "IsNightLine"
 //             << "RoutePlatformsArrival" << "RouteTimesDepartureDelay"
 //             << "RouteTimesArrivalDelay" << "Duration" << "StartStopName"
 //             << "StartStopID" << "TargetStopName" << "TargetStopID"
 //             << "ArrivalDateTime" << "ArrivalDate" << "ArrivalTime" << "Changes"
 //             << "TypesOfVehicleInJourney" << "Pricing" << "StopName" << "StopID"
 //             << "StopWeight";
 //
 //     if ( !timetableInfoStrings.contains(string->content()) ) {
 //         setErrorState( i18nc("@info/plain", "'%1' is not a valid info name.",
 //                                 string->content()), string->line(), string->column() );
 //     }
 
     QHash< QString, QStringList > methods;
     JavaScriptCompletionGeneric::addAvailableMethods( &methods );
     if ( methods.contains(object) && !methods[object].contains(function) ) {
         setErrorState( i18nc("@info/plain", "The object '%1' has no method '%2' "
                              "(available methods: %3).",
                        object, function, methods[object].join(", ")), line, column );
     }
 }
 
 bool JavaScriptParser::isKeyword( const QString &text )
 {
     return QRegExp("(?:null|true|false|case|catch|default|finally|for|instanceof|new|var|continue|"
                    "function|return|void|delete|if|this|do|while|else|in|switch|throw|try|typeof|"
                    "with)").exactMatch(text.toLower());
 }
 
 CodeNode::Ptr JavaScriptParser::parseStatement( bool calledFromParseBlock )
 {
     if ( atEnd() ) {
         return CodeNode::Ptr( 0 );
     }
     Token *firstToken = currentToken();
 //     if ( m_lastToken == firstToken ) {
 //         moveToNextToken();
 //         if ( atEnd() ) {
 //             return CodeNode::Ptr( 0 );
 //         }
 //         firstToken = currentToken();
 //     }
     m_lastToken = firstToken;
 
     QString text;
     QList<Token*> lastTokenList;
     QList< CodeNode::Ptr > children;
     while ( !atEnd() ) {
         if ( currentToken()->isChar(';') ) {
             // End of statement found
             if ( !lastTokenList.isEmpty() ) {
                 text += Token::whitespacesBetween( lastTokenList.last(), currentToken() );
             }
             text += currentToken()->text;
             moveToNextToken();
             return CodeNode::Ptr(
                     new StatementNode(text, firstToken->line, firstToken->posStart,
                                       m_lastToken->line, m_lastToken->posEnd, children) );
         } else if ( currentToken()->isChar('}') ) {
             // '}' without previous '{' found in statement => ';' is missing
 //             Token *errorToken = lastTokenList.isEmpty() ? currentToken() : lastTokenList.last();
 //             setErrorState( i18nc("@info/plain", "Missing ';' at the end of the statement."),
 //                 errorToken->line, errorToken->posEnd );
 //             m_lastToken = errorToken;
 //             if ( m_it != m_token.constBegin() ) {
 //                 --m_it; // Go before the '}'
 //             }
             // Found a closing '}', should be part of a block, parsed in parseBlock(),
             // which called this function to parse the block contents
             if ( !lastTokenList.isEmpty() ) {
                 text += Token::whitespacesBetween( lastTokenList.last(), currentToken() );
             }
             // TODO Do not go to next token, because the current '}'-token should be read by a
             // calling function
             if ( !calledFromParseBlock ) {
                 moveToNextToken();
             }
             return CodeNode::Ptr(
                     new StatementNode(text, firstToken->line, firstToken->posStart,
                                       m_lastToken->line, m_lastToken->posEnd, children) );
         }
 
         CodeNode::Ptr node( 0 );
         if ( (node = parseComment()) || (node = parseString()) ) {
             text += node->toString();
             children << node;
             lastTokenList << m_lastToken;
         } else if ( (node = parseBracketed()) ) {
             text += node->toString();
             BracketedNode::Ptr bracketedNode = node.dynamicCast<BracketedNode>();
             if ( bracketedNode->openingBracketChar() == '(' ) {
                 if ( lastTokenList.count() == 1 && lastTokenList.at(0)->isName &&
                      !isKeyword(lastTokenList.at(0)->text) )
                 {
                     // Is a function call "function(...)"
                     Token *functionToken = lastTokenList.at(0);
                     QString function = functionToken->text;
                     node = CodeNode::Ptr( new FunctionCallNode(QString(), function, functionToken->line,
                             functionToken->posStart, currentToken()->posStart, bracketedNode) );
                     children << node;
                 } else if ( lastTokenList.count() == 3 && lastTokenList.at(0)->isName &&
                             lastTokenList.at(1)->isChar('.') && lastTokenList.at(2)->isName )
                 {
                     // Is a member function call "object.function(...)"
                     Token *objectToken = lastTokenList.at(0);
                     Token *pointToken = lastTokenList.at(1);
                     Token *functionToken = lastTokenList.at(2);
 
                     QString object = objectToken->text;
                     QString function = functionToken->text;
                     checkFunctionCall( object, function, bracketedNode,
                             objectToken->line, objectToken->posStart );
                     // TODO This UnknownNode could be replaced by an ObjectNode or VariableNode
                     CodeNode::Ptr objectNode( new UnknownNode(object + ".",
                         objectToken->line, objectToken->posStart, pointToken->posEnd) );
                     children << objectNode;
                     node = CodeNode::Ptr( new FunctionCallNode(object, function, functionToken->line,
                             functionToken->posStart, currentToken()->posStart, bracketedNode) );
                     children << node;
                 }
             }
             children << node;
             lastTokenList << m_lastToken;
         } else if ( (node = parseBlock()) || (node = parseFunction()) ) {
             text += node->toString();
             children << node;
             lastTokenList << m_lastToken;
 
             if ( !atEnd() && currentToken()->isChar(';') ) {
                 lastTokenList << currentToken();
                 text += ';';
                 moveToNextToken();
             }
 
             return CodeNode::Ptr( new StatementNode(text, firstToken->line, firstToken->posStart,
                     lastTokenList.last()->line, lastTokenList.last()->posEnd, children) );
         } else if ( atEnd() ) {
             setErrorState( i18nc("@info/plain", "Unexpected end of file.") );
         } else {
             if ( !lastTokenList.isEmpty() ) {
                 text += Token::whitespacesBetween( lastTokenList.last(), currentToken() );
             }
             text += currentToken()->text;
             lastTokenList << currentToken();
             moveToNextToken();
         }
     }
 
     if ( !lastTokenList.isEmpty() ) {
         m_lastToken = lastTokenList.last();
         setErrorState( i18nc("@info/plain", "Unexpected end of file."),
                        lastTokenList.last()->line, lastTokenList.last()->posEnd );
     } else if ( m_lastToken ) {
         setErrorState( i18nc("@info/plain", "Unexpected end of file."),
                        m_lastToken->line, m_lastToken->posEnd );
     } else {
         setErrorState( i18nc("@info/plain", "Unexpected end of file."), -1, -1 );
     }
     return CodeNode::Ptr( 0 );
 }
 
 CodeNode::Ptr JavaScriptParser::parseFunction()
 {
     if ( atEnd() ) {
         return CodeNode::Ptr( 0 );
     }
 
     QList<Token*>::ConstIterator lastIt = m_it;
     Token *firstToken = currentToken();
     bool isAnonymous = false;
     QString name;
     if ( firstToken->text != "function" ) {
         if ( firstToken->text == QLatin1String("var") ) {
             if ( !tryMoveToNextToken() || !currentToken()->isName ) {
                 m_it = lastIt;
                 return CodeNode::Ptr( 0 );
             }
             name = currentToken()->text;
 
             if ( !tryMoveToNextToken() || currentToken()->text != QLatin1String("=") ) {
                 m_it = lastIt;
                 return CodeNode::Ptr( 0 );
             }
             if ( !tryMoveToNextToken() || currentToken()->text != QLatin1String("function") ) {
                 m_it = lastIt;
                 return CodeNode::Ptr( 0 );
             }
             isAnonymous = true;
         } else if ( firstToken->isName ) {
             name = currentToken()->text;
 
             if ( !tryMoveToNextToken() || (currentToken()->text != QLatin1String("=") &&
                                            currentToken()->text != QLatin1String(":")) )
             {
                 m_it = lastIt;
                 return CodeNode::Ptr( 0 );
             }
             if ( !tryMoveToNextToken() || currentToken()->text != QLatin1String("function") ) {
                 m_it = lastIt;
                 return CodeNode::Ptr( 0 );
             }
             isAnonymous = true;
         } else {
             return CodeNode::Ptr( 0 );
         }
     }
     if ( !tryMoveToNextToken() ) {
         m_it = lastIt;
         return CodeNode::Ptr( 0 );
     }
 
     // Parse function name if any
     if ( currentToken()->isChar('(') ) {
         // Is an anonymous function declaration
         if ( !isAnonymous ) {
             name = "<anonymous>";
             isAnonymous = true;
         }
     } else if ( !isAnonymous ) {
         name = currentToken()->text;
         if ( !tryMoveToNextToken() ) {
             m_it = lastIt;
             return CodeNode::Ptr( 0 );
         }
         isAnonymous = false;
     }
 
     // Parse arguments
     if ( currentToken()->isChar('(') ) {
         QList< ArgumentNode::Ptr > arguments;
         bool argumentNameExpected = true;
         bool isComma = false;
         if ( !tryMoveToNextToken() ) {
             m_it = lastIt;
             return CodeNode::Ptr( 0 );
         }
 
         // Parse until a ')' is read or EOF
         while ( !atEnd() && !currentToken()->isChar(')') ) {
             isComma = currentToken()->isChar(',');
             if ( argumentNameExpected ) {
                 if ( isComma ) {
                     setErrorState( i18nc("@info/plain", "Expected argument or ')'."),
                                 currentToken()->line, currentToken()->posStart );
                     break;
                 }
 
                 arguments << ArgumentNode::Ptr(
                         new ArgumentNode(currentToken()->text, currentToken()->line,
                                          currentToken()->posStart, currentToken()->posEnd) );
             } else if ( !isComma ) {
                 setErrorState( i18nc("@info/plain", "Expected ',' or ')'."),
                             currentToken()->line, currentToken()->posStart );
                 break;
             }
 
             argumentNameExpected = !argumentNameExpected;
             if ( !tryMoveToNextToken() ) {
                 m_it = lastIt;
                 return CodeNode::Ptr( 0 );
             }
         }
 
         if ( isComma ) { // argument list ended with ','
             setErrorState( i18nc("@info/plain", "Expected argument or ')'."),
                     m_lastToken->line, m_lastToken->posStart );
         }
 
         // Read definition block
         BlockNode::Ptr definition( 0 );
         if ( !tryMoveToNextToken() ) {
                 m_it = lastIt;
             return CodeNode::Ptr( 0 );
         }
         if ( /*tryMoveToNextToken() &&*/ !(definition = parseBlock()) ) {
             setErrorState( i18nc("@info/plain", "Function definition is missing."),
                     m_lastToken->line, m_lastToken->posStart );
         }
 
         return FunctionNode::Ptr( new FunctionNode(name, firstToken->line, firstToken->posStart,
                                         m_lastToken->posEnd, arguments, definition, isAnonymous) );
     } else {
         setErrorState( i18nc("@info/plain", "Expected '('."),
                 currentToken()->line, currentToken()->posStart );
         moveToNextToken();
 
         m_it = lastIt;
         return CodeNode::Ptr( 0 );
     }
 }
 
 BlockNode::Ptr JavaScriptParser::parseBlock()
 {
     if ( atEnd() ) {
         return BlockNode::Ptr( 0 );
     }
 
     if ( currentToken()->isChar('{') ) {
         Token *firstToken = currentToken();
         QList< CodeNode::Ptr > children;
     //     moveToNextToken();
         if ( !tryMoveToNextToken() ) {
             return BlockNode::Ptr( 0 );
         }
         while ( !atEnd() ) {
             CodeNode::Ptr node( 0 );
             Token *previousToken = currentToken();
             if ( (node = parseComment())
                 || (!hasError() && (node = parseString()))
                 || (!hasError() && (node = parseBracketed()))
                 || (!hasError() && (node = parseFunction()))
                 || (!hasError() && (node = parseBlock())) )
             {
                 if ( !atEnd() && previousToken == currentToken() ) {
-                    kWarning() << "JavaScript parser locked down at line" << previousToken->line
+                    qWarning() << "JavaScript parser locked down at line" << previousToken->line
                                << "at token" << previousToken->text;
                     m_error = InternalParserError;
                     m_errorLine = node->line();
                     m_errorColumn = node->column();
                     m_errorMessage = i18nc("@info/plain", "Internal JavaScript parser error" );
                     break;
                 }
                 children << node;
             } else if ( !atEnd() && currentToken()->isChar('}') ) {
                 moveToNextToken(); // Move to next token, ie. first token after the function definition (or EOF)
                 return BlockNode::Ptr( new BlockNode(firstToken->line, firstToken->posEnd,
                         m_lastToken->line, m_lastToken->posEnd, children) );
             } else if ( (node = parseStatement(true)) ) {
                 children << node;
             } else if ( !atEnd() ) {
                 moveToNextToken();
             }
         }
 
         setErrorState( i18nc("@info/plain", "Unclosed block, missing '}'. Block started "
                              "at line %1.", firstToken->line),
                        m_lastToken->line, m_lastToken->posEnd );
     }
 
     return BlockNode::Ptr( 0 );
 }
 
 QList< CodeNode::Ptr > JavaScriptParser::parse()
 {
     clearError();
 
     // Get token from the code, with line number and column begin/end
     m_token.clear();
     const QString alphaNumeric( "abcdefghijklmnopqrstuvwxyz0123456789_" );
     QRegExp rxTokenBegin( "\\S" );
     QRegExp rxTokenEnd( "\\s|[-=#!$%&~;:,<>^`´/\\.\\+\\*\\\\\\(\\)\\{\\}\\[\\]'\"\\?\\|]" );
     const QStringList lines = m_code.split( '\n' );
     for ( int lineNr = 0; lineNr < lines.count(); ++lineNr ) {
         const QString line = lines.at( lineNr );
         QStringList words;
 
         int posStart = 0;
         while ( (posStart = rxTokenBegin.indexIn(line, posStart)) != -1 ) {
             int posEnd;
             bool isName;
             // Only words beginning with a letter ([a-z]) may be concatenated
             if ( alphaNumeric.contains(line.at(posStart).toLower()) ) {
                 posEnd = rxTokenEnd.indexIn( line, posStart + 1 );
                 isName = true;
             } else {
                 posEnd = posStart + 1;
                 isName = false;
             }
             if ( posEnd == -1 ) {
                 posEnd = line.length();
             }
 
             QString word;
             word = line.mid( posStart, posEnd - posStart );
             if ( !word.isEmpty() ) {
                 m_token << new Token( word, lineNr + 1, posStart, posEnd - 1, isName );
             }
 
             // Set minimal next start position
             posStart = posEnd;
         }
     }
 
     // Get nodes from the token
     QList< CodeNode::Ptr > nodes;
     m_it = m_token.constBegin();
     while ( !atEnd() ) {
         CodeNode::Ptr node( 0 );
         if ( (node = parseComment())
             || (!hasError() && (node = parseString()))
             || (!hasError() && (node = parseBracketed()))
             || (!hasError() && (node = parseFunction()))
             || (!hasError() && (node = parseBlock()))
             || (!hasError() && (node = parseStatement())) )
         {
             if ( !atEnd() && currentToken() == m_lastToken ) {
                 m_error = InternalParserError;
                 m_errorLine = node->line();
                 m_errorColumn = node->column();
                 m_errorMessage = i18nc("@info/plain", "Internal JavaScript parser error");
                 break;
             }
 
             nodes << CodeNode::Ptr(node);
 
             if ( hasError() ) {
                 break;
             }
         } else if ( !atEnd() ) {
             moveToNextToken();
         }
     } // for ( ...all tokens... )
 
     // Done with the tokens, delete them
     qDeleteAll( m_token );
     m_token.clear();
 
     // Check for multiple definitions
     QHash< QString, FunctionNode::Ptr > functions;
     foreach ( const CodeNode::Ptr &node, nodes ) {
         FunctionNode::Ptr function = node.dynamicCast<FunctionNode>();
         if ( function ) {
             QString newFunctionName = function->toString( true );
             if ( functions.contains(newFunctionName) ) {
                 FunctionNode::Ptr previousImpl = functions.value( newFunctionName );
                 setErrorState( i18nc("@info/plain", "Multiple definitions of function '%1', "
                                      "previously defined at line %2",
                                      function->text(), previousImpl->line()),
                                function->line(), function->column(), previousImpl->line() );
             } else {
                 functions.insert( newFunctionName, function );
             }
         }
     }
 
     return nodes;
 }
 
 void JavaScriptParser::setErrorState( const QString& errorMessage, int errorLine,
                       int errorColumn, int affectedLine )
 {
     if ( hasError() ) {
         return; // Don't override existing errors
     }
 
     m_error = SyntaxError;
     m_errorLine = errorLine;
     m_errorAffectedLine = affectedLine;
 
     m_errorColumn = errorColumn;
     m_errorMessage = errorMessage;
 }
 
 void JavaScriptParser::clearError() {
     m_error = NoError;
     m_errorLine = -1;
     m_errorAffectedLine = -1;
     m_errorColumn = 0;
     m_errorMessage.clear();
 }
 
 MultilineNode::MultilineNode( const QString& text, int line, int colStart, int lineEnd, int colEnd )
         : CodeNode( text, line, colStart, colEnd )
 {
     m_endLine = lineEnd;
 }
 
 ChildListNode::ChildListNode( const QString& text, int line, int colStart,
                               int lineEnd, int colEnd, const QList< CodeNode::Ptr > &children )
         : MultilineNode( text, line, colStart, lineEnd, colEnd ), m_children(children)
 {
     foreach ( const CodeNode::Ptr &child, children ) {
         child->m_parent = this;
     }
 }
 
 EmptyNode::EmptyNode() : CodeNode( QString(), -1, 0, 0 )
 {
 }
 
 StatementNode::StatementNode( const QString &text, int line, int colStart, int lineEnd, int colEnd,
                               const QList< CodeNode::Ptr > &children )
         : ChildListNode( text, line, colStart, lineEnd, colEnd, children )
 {
 }
 
 BracketedNode::BracketedNode( const QChar &openingBracketChar, const QString &text,
                               int line, int colStart, int lineEnd, int colEnd,
                               const QList< CodeNode::Ptr > &children )
         : ChildListNode( text, line, colStart, lineEnd, colEnd, children )
 {
     m_bracketChar = openingBracketChar;
 }
 
 QChar BracketedNode::closingBracketChar() const
 {
     if ( m_bracketChar == '(' ) {
         return ')';
     } else if ( m_bracketChar == '[' ) {
         return ']';
     } else {
         return ' '; // should not happen
     }
 }
 
 int BracketedNode::commaSeparatedCount() const
 {
     int count = 1;
     foreach ( const CodeNode::Ptr &child, m_children ) {
         if ( child->type() == UnknownNodeType && child->text() == QLatin1String(",") ) {
             ++count;
         }
     }
     return count;
 }
 
 QList< CodeNode::Ptr > BracketedNode::commaSeparated( int pos ) const
 {
     QList< CodeNode::Ptr > separated;
 
     int curPos = 0;
     foreach ( const CodeNode::Ptr &child, m_children ) {
     if ( child->type() == UnknownNodeType && child->text() == QLatin1String(",") ) {
         ++curPos;
         if ( curPos > pos ) {
             return separated;
         }
     }
 
     if ( curPos == pos )
         separated << child;
     }
 
     return separated;
 }
 
 FunctionCallNode::FunctionCallNode( const QString &object, const QString &function, int line,
                                     int colStart, int colEnd, const BracketedNode::Ptr &arguments )
         : CodeNode( object.isEmpty() ? function : object + '.' + function, line, colStart, colEnd )
 {
     m_object = object;
     m_function = function;
     m_arguments = arguments;
     arguments->m_parent = this;
 }
 
 FunctionNode::FunctionNode( const QString& text, int line, int colStart, int colEnd,
                             const QList< ArgumentNode::Ptr > &arguments,
                             const BlockNode::Ptr &definition, bool isAnonymous )
         : MultilineNode( text, line, colStart, definition ? definition->endLine() : line, colEnd ),
         m_arguments(arguments), m_definition(definition), m_anonymous(isAnonymous)
 {
     if ( m_text.isEmpty() ) {
         m_text = i18nc("@info/plain Display name for anonymous JavaScript functions", "[anonymous]");
     }
 
     foreach ( const CodeNode::Ptr &child, arguments ) {
         child->m_parent = this;
     }
     if ( definition ) {
         definition->m_parent = this;
     }
 }
 
 QList< CodeNode::Ptr > FunctionNode::children() const
 {
     QList< CodeNode::Ptr > ret;
     for ( QList<ArgumentNode::Ptr>::const_iterator it = m_arguments.constBegin();
           it != m_arguments.constEnd(); ++it )
     {
         ret << it->dynamicCast< CodeNode >();
     }
     if ( m_definition ) {
         ret << m_definition.dynamicCast< CodeNode >();
     }
     return ret;
 }
 
 BlockNode::BlockNode( int line, int colStart, int lineEnd, int colEnd,
                       const QList< CodeNode::Ptr > &children )
         : ChildListNode( QString(), line, colStart, lineEnd, colEnd, children )
 {
 }
 
 QString BlockNode::toString( bool shortString ) const
 {
     QString s( '{' );
     foreach ( const CodeNode::Ptr &child, m_children ) {
         s += child->toString(shortString) + '\n';
     }
     return s + '}';
 }
 
 QString BlockNode::content() const
 {
     QString s;
     foreach ( const CodeNode::Ptr &child, m_children ) {
         s += child->toString() + '\n';
     }
     return s.trimmed();
 }
 
 QString FunctionNode::id() const
 {
     QStringList arguments;
     foreach ( const CodeNode::Ptr &node, m_arguments ) {
         ArgumentNode::Ptr argument = node.dynamicCast< ArgumentNode >();
         if ( argument ) {
             arguments << argument->text();
         }
     }
 
     return QString("func:%1()").arg( m_text ); //, arguments.join(",") );
 }
 
 QString FunctionNode::toStringSignature() const
 {
     QStringList arguments;
     foreach ( const CodeNode::Ptr &node, m_arguments ) {
         ArgumentNode::Ptr argument = node.dynamicCast< ArgumentNode >();
         if ( argument ) {
             arguments << argument->text();
         }
     }
 
     return QString("%1( %2 )").arg( m_text, arguments.join(", ") );
 }
 
 QString FunctionNode::toString( bool shortString ) const
 {
     if ( shortString ) {
         return toStringSignature();
     } else {
         return toStringSignature() + ' ' + (m_definition ? m_definition->toString() : QString());
     }
 }
diff --git a/engine/timetablemate/src/networkmonitormodel.cpp b/engine/timetablemate/src/networkmonitormodel.cpp
index 7d55837..31430b7 100644
--- a/engine/timetablemate/src/networkmonitormodel.cpp
+++ b/engine/timetablemate/src/networkmonitormodel.cpp
@@ -1,786 +1,786 @@
 /*
 *   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 "networkmonitormodel.h"
 
 // Public Transport engine includes
 #include <engine/global.h>
 
 // KDE includes
 #include <KLocalizedString>
 #include <KDebug>
 #include <KGlobal>
 #include <KLocale>
 #include <QUrl>
 #include <KMimeType>
 #include <KIO/NetAccess>
 #include <KIO/Job>
 #include <KIcon>
 #include <KTemporaryFile>
 #include <KGlobalSettings>
 
 // Qt includes
 #include <QNetworkRequest>
 #include <QNetworkReply>
 #include <qnetworkdiskcache.h>
 #include <QTimer>
 #include <QBuffer>
 #include <QTextCodec>
 #include <QImageReader>
 
 NetworkMonitorModel::NetworkMonitorModel( QObject *parent ) : QAbstractListModel( parent )
 {
 }
 
 NetworkMonitorModel::~NetworkMonitorModel()
 {
     qDeleteAll( m_data );
 }
 
 bool NetworkMonitorModel::removeRows( int row, int count, const QModelIndex &parent )
 {
     if ( parent.isValid() || row < 0 || row + count > m_data.count() ) {
         return false;
     }
 
     beginRemoveRows( parent, row, row + count - 1 );
     for ( int i = row + count - 1; i >= row; --i ) {
         delete m_data.takeAt( i );
     }
     endRemoveRows();
     return true;
 }
 
 int NetworkMonitorModel::rowCount( const QModelIndex &parent ) const
 {
     if ( parent.isValid() ) {
         return 0;
     } else {
         return m_data.count();
     }
 }
 
 void NetworkMonitorModel::clear()
 {
     beginRemoveRows( QModelIndex(), 0, rowCount() );
     m_data.clear();
     endRemoveRows();
 }
 
 QModelIndex NetworkMonitorModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( column < 0 || column >= ColumnCount || row < 0 ) {
         return QModelIndex();
     }
 
     if ( parent.isValid() ) {
         return QModelIndex();
     } else {
         return row >= m_data.count() ? QModelIndex() : createIndex(row, column, m_data[row]);
     }
 }
 
 QModelIndex NetworkMonitorModel::indexFromMonitorData( NetworkMonitorModelItem *data, int column ) const
 {
     const int row = m_data.indexOf( data );
     if ( row == -1 ) {
         return QModelIndex();
     } else {
         return index( row, column );
     }
 }
 
 NetworkMonitorModelItem *NetworkMonitorModel::monitorDataFromIndex( const QModelIndex &index ) const
 {
     return static_cast< NetworkMonitorModelItem* >( index.internalPointer() );
 }
 
 QString NetworkMonitorModel::encodeHtml( const QString &html )
 {
     return QString(html).replace( "<", "&lt;" ).replace( ">", "&gt;" );
 }
 
 QString NetworkMonitorModel::limitLineCount( const QString &string, bool htmlFormat,
                                              int maxLineCount, int maxCharactersPerLine )
 {
     QString result;
     QStringList lines = string.split( '\n' );
     foreach ( const QString &line, lines ) {
         if ( maxCharactersPerLine > 0 && line.length() > maxCharactersPerLine ) {
             QString currentLine = line;
             while ( !currentLine.isEmpty() ) {
                 if ( !result.isEmpty() ) {
                     result += '\n';
                 }
                 result += currentLine.left( maxCharactersPerLine );
                 currentLine = currentLine.mid( maxCharactersPerLine );
                 if ( !currentLine.isEmpty() && !htmlFormat ) {
                     // Append a return symbol
                     result += QString::fromUtf8( "\342\217\216" );
                 }
             }
         } else {
             if ( !result.isEmpty() ) {
                 result += '\n';
             }
             result += line;
         }
 
         int lineCount = 0;
         int pos = -1;
         while ( (pos = result.indexOf('\n', pos + 1)) != -1 ) {
             ++lineCount;
             if ( lineCount >= maxLineCount ) {
                 return result.left( pos ) + "...";
             }
         }
     }
     return result;
 }
 
 QVariant NetworkMonitorModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
     switch ( role ) {
     case Qt::DisplayRole:
         if ( orientation == Qt::Horizontal && role == Qt::DisplayRole ) {
             switch ( static_cast<Column>(section) ) {
             case TypeColumn:
                 return i18nc("@title:column", "Type");
             case ContentTypeColumn:
                 return i18nc("@title:column", "Content");
             case TimeColumn:
                 return i18nc("@title:column", "Time");
             case UrlColumn:
                 return i18nc("@title:column", "URL");
             case DataColumn:
                 return i18nc("@title:column", "Data");
             default:
                 return QVariant();
             }
         } else {
             return QVariant();
         }
 
     default:
         return QVariant();
     }
 }
 
 QString NetworkMonitorModel::decodeHtml( const QByteArray &data ) const
 {
     QTextCodec *textCodec = QTextCodec::codecForHtml( data,
             QTextCodec::codecForUtfText(data, QTextCodec::codecForName("UTF-8")) );
     return textCodec ? textCodec->toUnicode(data) : data;
 }
 
 QVariant NetworkMonitorModel::data( const QModelIndex &index, int role ) const
 {
     if ( !index.isValid() ) {
         return QVariant();
     }
 
     NetworkMonitorModelItem *data = monitorDataFromIndex( index );
     if ( !data ) {
         return QVariant();
     }
 
     switch ( role ) {
     case Qt::DisplayRole:
         switch ( index.column() ) {
         case TypeColumn:
             return NetworkMonitorModelItem::nameFromType( data->type() );
         case ContentTypeColumn:
             return NetworkMonitorModelItem::nameFromContentType( data->contentType() );
         case TimeColumn:
             return KGlobal::locale()->formatLocaleTime( data->time() );
         case UrlColumn:
             return data->url();
         case DataColumn: {
             const bool htmlFormat = data->type() == NetworkMonitorModelItem::Reply &&
                     (data->contentType() == NetworkMonitorModelItem::HtmlData ||
                      data->contentType() == NetworkMonitorModelItem::XmlData);
             const bool textData = htmlFormat || data->contentType() == NetworkMonitorModelItem::CssData ||
                      data->contentType() == NetworkMonitorModelItem::ScriptData ||
                      data->contentType() == NetworkMonitorModelItem::UnknownTextData;
             if ( data->type() == NetworkMonitorModelItem::Reply && !textData ) {
                 return data->mimeType();
             }
 
             QString result = data->type() == NetworkMonitorModelItem::Reply
                     ? decodeHtml(data->data()) : data->data(); // TODO fallback charset in ServiceProviderData
             // Remove carriage return characters, they would get drawn in views for some reason
             result = result.replace( '\r', QString() );
             return limitLineCount( result.trimmed() );
         }
         default:
             return QVariant();
         }
 
     case Qt::EditRole:
         switch ( index.column() ) {
         case UrlColumn:
             return data->url();
         case DataColumn:
             if ( data->contentType() == NetworkMonitorModelItem::ImageData && data->imageData() ) {
                 // Read image from temporary file and convert to a pixmap
                 // Shouldn't be used to often, eg. for copy to clipboard actions
                 // The pixmap isn't stored in memory to save space
                 return QPixmap::fromImage( QImage(data->imageData()->tempFile->fileName()) );
             } else if ( data->type() == NetworkMonitorModelItem::Reply ) {
                 return decodeHtml( data->data() ); // TODO fallback charset in ServiceProviderData
             } else {
                 return data->data();
             }
         default:
             return QVariant();
         }
 
     case Qt::ToolTipRole:
         switch ( index.column() ) {
         case UrlColumn:
             return data->url();
         case DataColumn: {
             const QString limited = limitLineCount( data->data(), true, 15 );
             switch ( data->contentType() ) {
             case NetworkMonitorModelItem::ImageData:
                 if ( data->imageData() && data->imageData()->tempFile ) {
                     const int maxImageDimension =
                             KGlobalSettings::desktopGeometry(QPoint(0, 0)).height() / 2;
                     int width = data->imageData()->size.width();
                     int height = data->imageData()->size.height();
                     if ( width > height ) {
                         if ( width > maxImageDimension ) {
                             height *= maxImageDimension / width;
                             width = maxImageDimension;
                         }
                     } else {
                         if ( height > maxImageDimension ) {
                             width *= maxImageDimension / height;
                             height = maxImageDimension;
                         }
                     }
                     return QString("%6, %2x%3:<br />"
                             "<img src='%1' width='%4' height='%5' style='padding:2px;' />")
                             .arg(data->imageData()->tempFile->fileName())
                             .arg(data->imageData()->size.width())
                             .arg(data->imageData()->size.height())
                             .arg(width).arg(height).arg(data->mimeType());
                 } else {
                     return QVariant();
                 }
             case NetworkMonitorModelItem::HtmlData:
             case NetworkMonitorModelItem::XmlData:
                 return encodeHtml( limited );
             default:
                 return limited;
             }
         }
         default:
             return QVariant();
         }
 
     case Qt::DecorationRole:
         switch ( index.column() ) {
         case TypeColumn:
             switch ( data->type() ) {
             case NetworkMonitorModelItem::GetRequest:
             case NetworkMonitorModelItem::PostRequest:
                 return KIcon("download");
             case NetworkMonitorModelItem::Reply:
                 return KIcon("go-up");
             default:
                 return QVariant();
             }
 
         case ContentTypeColumn:
             switch ( data->contentType() ) {
             case NetworkMonitorModelItem::HtmlData:
                 return KIcon("text-html");
             case NetworkMonitorModelItem::XmlData:
                 return KIcon("text-xml");
             case NetworkMonitorModelItem::CssData:
                 return KIcon("text-css");
             case NetworkMonitorModelItem::ScriptData:
                 return KIcon("text-x-script");
             case NetworkMonitorModelItem::UnknownTextData:
                 return KIcon("text-plain");
             case NetworkMonitorModelItem::ImageData:
                 return KIcon("image-x-generic");
             case NetworkMonitorModelItem::RetrievingContentType:
                 return KIcon("task-ongoing");
             default:
                 return QVariant();
             }
 
         case DataColumn:
             switch ( data->contentType() ) {
             case NetworkMonitorModelItem::ImageData:
                 return data->imageData() ? data->imageData()->icon : QVariant();
             default:
                 return QVariant();
             }
 
         default:
             return QVariant();
         }
 
     case DataTypeRole:
         return data->type();
     case ContentTypeRole:
         return data->contentType();
 
     default:
         return QVariant();
     }
 }
 
 Qt::ItemFlags NetworkMonitorModel::flags( const QModelIndex &index ) const
 {
     return index.isValid() ? Qt::ItemIsEnabled | Qt::ItemIsSelectable : Qt::NoItemFlags;
 }
 
 NetworkMonitorModelItem::NetworkMonitorModelItem( NetworkMonitorModelItem::Type type, const QString &url,
                                         const QByteArray &data, QObject *parent )
             : QObject(parent), m_model(0), m_type(type),
               m_contentType(NetworkMonitorModelItem::RetrievingContentType),
               m_time(QTime::currentTime()), m_url(url), m_data(data), m_imageData(0)
 {
     const QUrl _url( url );
     if ( !data.isEmpty() ) {
         m_contentType = contentTypeFromContent( data, _url );
         if ( m_contentType == NetworkMonitorModelItem::UnknownData ) {
             if ( type == Reply ) {
                 m_contentType = contentTypeFromUrl( _url );
             } else {
                 m_contentType = UnknownTextData;
             }
         }
 
         if ( m_contentType == ImageData ) {
             prepareAdditionalImageData();
         }
     } else {
         m_contentType = contentTypeFromUrl( _url );
     }
 }
 
 NetworkMonitorModelItem::~NetworkMonitorModelItem()
 {
     delete m_imageData;
 }
 
 void NetworkMonitorModelItem::prepareAdditionalImageData()
 {
     // Delete old image data, if any
     if ( m_imageData ) {
         delete m_imageData;
     }
 
     // Read image data
     QImage image = QImage::fromData( m_data );
     if ( image.isNull() ) {
         // Cannot read image from data, maybe empty data
         return;
     }
 
     // Create new object with additional data for items containing image data
     m_imageData = new AdditionalImageData();
     m_imageData->size = image.size();
     QPixmap smallPixmap = QPixmap::fromImage( image.scaledToHeight(32, Qt::SmoothTransformation) );
     if ( smallPixmap.isNull() ) {
         // Scaling produced an empty pixmap (very high and narrow or very wide and little height)
         // Create an empty 16x16 pixmap
         smallPixmap = QPixmap( 32, 32 );
         smallPixmap.fill( Qt::transparent );
     }
     m_imageData->icon = KIcon( smallPixmap );
 
     // Write image data to a temporary file, for display in a QToolTip using an HTML <img> tag
     m_imageData->tempFile = new KTemporaryFile();
     m_imageData->tempFile->setAutoRemove( true );
     m_imageData->tempFile->setPrefix( QUrl(m_url).fileName() );
     if ( m_imageData->tempFile->open() ) {
         m_imageData->tempFile->write( m_data );
         m_imageData->tempFile->close();
     }
 }
 
 NetworkMonitorModelItem::ContentType NetworkMonitorModelItem::contentTypeFromUrl( const QUrl &url )
 {
     KMimeType::Ptr mimeType = KMimeType::findByUrl( url );
     if ( mimeType == KMimeType::defaultMimeTypePtr() ) {
         // Mime type not found, use KIO to get the mime type asynchronously
         KIO::MimetypeJob *job = KIO::mimetype( url, KIO::HideProgressInfo );
         connect( job, SIGNAL(mimetype(KIO::Job*,QString)), this, SLOT(mimetype(KIO::Job*,QString)) );
         connect( job, SIGNAL(finished(KJob*)), this, SLOT(mimetypeJobFinished(KJob*)) );
         job->start();
         return RetrievingContentType;
     } else {
         // Mime type found
         m_mimeType = mimeType->name();
         return contentTypeFromMimeType( mimeType->name() );
     }
 }
 
 NetworkMonitorModelItem::ContentType NetworkMonitorModelItem::contentTypeFromContent(
         const QByteArray &content, const QUrl &url )
 {
     int accuracy;
     KMimeType::Ptr mimeType = KMimeType::findByContent( content, &accuracy );
     if ( (mimeType == KMimeType::defaultMimeTypePtr() || accuracy < 70) && url.isValid() ) {
         // No accurate mime type found, find mime type from URL
         mimeType = KMimeType::findByUrl( url );
     }
     m_mimeType = mimeType->name();
     return contentTypeFromMimeType( mimeType->name() );
 }
 
 QString NetworkMonitorModelItem::nameFromType( NetworkMonitorModelItem::Type type )
 {
     switch ( type ) {
     case GetRequest:
         return i18nc("@info/plain", "Request (GET)");
     case PostRequest:
         return i18nc("@info/plain", "Request (POST)");
     case Reply:
         return i18nc("@info/plain", "Reply");
     default:
         kDebug() << "Unknown type" << type;
         return QString();
     }
 }
 
 QString NetworkMonitorModelItem::nameFromContentType( NetworkMonitorModelItem::ContentType contentType )
 {
     switch ( contentType ) {
     case HtmlData:
         return i18nc("@info/plain", "HTML");
     case XmlData:
         return i18nc("@info/plain", "XML");
     case ImageData:
         return i18nc("@info/plain", "Image");
     case CssData:
         return i18nc("@info/plain", "CSS");
     case ScriptData:
         return i18nc("@info/plain", "Script");
     case UnknownTextData:
         return i18nc("@info/plain", "Text");
     case RetrievingContentType:
         return i18nc("@info/plain", "(wait)");
     case UnknownData:
     default:
         return i18nc("@info/plain", "Unknown");
     }
 }
 
 NetworkMonitorModelItem::Type NetworkMonitorModelItem::typeFromOperation(
             QNetworkAccessManager::Operation operation )
 {
     switch ( operation ) {
     case QNetworkAccessManager::HeadOperation:
     case QNetworkAccessManager::GetOperation:
         return GetRequest;
     case QNetworkAccessManager::PostOperation:
         return PostRequest;
     default:
         return Invalid;
     }
 }
 
 NetworkMonitorModelItem::ContentType NetworkMonitorModelItem::contentTypeFromMimeType( const QString &type )
 {
     if ( type.startsWith(QLatin1String("image")) ) {
         return ImageData;
     } else if ( type.contains(QLatin1String("html")) ) {
         return HtmlData;
     } else if ( type.endsWith(QLatin1String("/xml")) ) {
         return XmlData;
     } else if ( type == QLatin1String("text/css") ) {
         return CssData;
     } else if ( type.endsWith(QLatin1String("script")) ) {
         return ScriptData;
     } else if ( type.startsWith(QLatin1String("text/")) ) {
         return UnknownTextData;
     } else {
         return UnknownData;
     }
 }
 
 void NetworkMonitorModelItem::mimetype( KIO::Job *job, const QString &type )
 {
     Q_UNUSED( job );
     m_mimeType = type;
     m_contentType = contentTypeFromMimeType( type );
     if ( m_contentType == ImageData ) {
         prepareAdditionalImageData();
     }
     if ( m_model ) {
         m_model->slotDataChanged( this );
     }
 }
 
 void NetworkMonitorModelItem::mimetypeJobFinished( KJob *job )
 {
     Q_UNUSED( job );
     if ( m_contentType == RetrievingContentType ) {
         // Mimetype not found
         kDebug() << "Mimetype not found";
         m_contentType = UnknownData;
         if ( m_model ) {
             m_model->slotDataChanged( this );
         }
     }
 }
 
 void NetworkMonitorModel::slotDataChanged( NetworkMonitorModelItem *data )
 {
     emit dataChanged( indexFromMonitorData(data, 0), indexFromMonitorData(data, ColumnCount - 1) );
 }
 
 void NetworkMonitorModel::requestCreated( NetworkMonitorModelItem::Type type, const QString &url,
                                           const QByteArray &data, QNetworkReply *reply )
 {
     // Create new item for the request
     NetworkMonitorModelItem *requestItem = new NetworkMonitorModelItem( type, url, data, this );
     requestItem->setModel( this );
 
     // Insert request item
     beginInsertRows( QModelIndex(), 0, 0 );
     m_data.prepend( requestItem );
     endInsertRows();
 
     if ( reply ) {
         // Connect to the finished signal to add a reply item when the reply has finished
         connect( reply, SIGNAL(finished()), this, SLOT(replyFinished()) );
     }
 }
 
 void NetworkMonitorModel::replyFinished()
 {
     QNetworkReply *reply = qobject_cast< QNetworkReply* >( sender() );
     if ( reply ) {
         // Get data from cache
         QAbstractNetworkCache *cache = reply->manager()->cache();
         QIODevice *cachedData = cache->data( reply->request().url() );
         if ( !cachedData ) {
             cachedData = cache->data( reply->url() );
         }
         QByteArray data;
         if ( cachedData ) {
             data = cachedData->readAll();
             delete cachedData;
         }
 
         // Insert reply item
         beginInsertRows( QModelIndex(), 0, 0 );
         NetworkMonitorModelItem *newData = new NetworkMonitorModelItem(
                 NetworkMonitorModelItem::Reply, reply->url().toString(), data, this );
         newData->setModel( this );
         m_data.prepend( newData );
         endInsertRows();
     }
 }
 
 bool NetworkMonitorFilterModel::filterAcceptsRow( int sourceRow, const QModelIndex &sourceParent ) const
 {
     if ( sourceParent.isValid() ) {
         return false;
     }
 
     // Filter by type
     const QModelIndex sourceIndex = sourceModel()->index( sourceRow, 0, sourceParent );
     const NetworkMonitorModelItem::Type type = static_cast< NetworkMonitorModelItem::Type >(
             sourceModel()->data(sourceIndex, NetworkMonitorModel::DataTypeRole).toInt() );
     if ( !m_types.testFlag(type) ) {
         return false;
     }
 
     // Filter by content type
     const NetworkMonitorModelItem::ContentType contentType = static_cast< NetworkMonitorModelItem::ContentType >(
             sourceModel()->data(sourceIndex, NetworkMonitorModel::ContentTypeRole).toInt() );
     return m_contentTypes.testFlag( contentType );
 }
 
 void NetworkMonitorFilterModel::setTypeFilter( NetworkMonitorModelItem::Types types )
 {
     m_types = types;
     invalidateFilter();
 }
 
 void NetworkMonitorFilterModel::setContentTypeFilter( NetworkMonitorModelItem::ContentTypes contentTypes )
 {
     m_contentTypes = contentTypes;
     invalidateFilter();
 }
 
 NetworkMemoryCache::~NetworkMemoryCache()
 {
     clear();
 }
 
 void NetworkMemoryCache::clear()
 {
     qDeleteAll( m_orderedData );
     m_orderedData.clear();
     m_data.clear();
 }
 
 QIODevice *NetworkMemoryCache::prepare( const QNetworkCacheMetaData &metaData )
 {
     if ( !metaData.isValid() || !metaData.url().isValid() ) {
         return 0;
     }
 
     QBuffer *buffer = new QBuffer( this );
     if ( !buffer->open(QIODevice::ReadWrite) ) {
         delete buffer;
         return 0;
     }
     m_prepared.insert( buffer, metaData );
     return buffer;
 }
 
 void NetworkMemoryCache::insert( QIODevice *device )
 {
     if ( !m_prepared.contains(device) ) {
-        kWarning() << "Call prepare() first";
+        qWarning() << "Call prepare() first";
         return;
     }
 
     // Get prepared meta data object and insert it with the data read from device
     const QNetworkCacheMetaData metaData = m_prepared.take( device );
     device->reset(); // Go to beginning (after writing to device it is at the end)
     const QByteArray data = device->readAll();
     CacheData *cacheData = new CacheData( metaData, data );
     m_data.insert( metaData.url(), cacheData );
     m_orderedData << cacheData;
     device->close();
     delete device;
 
     QTimer::singleShot( TIMEOUT, this, SLOT(removeOldestCacheData()) );
 }
 
 void NetworkMemoryCache::removeOldestCacheData()
 {
     if ( m_orderedData.isEmpty() ) {
         return;
     }
 
     CacheData *cacheData = m_orderedData.first();
     if ( !remove(cacheData->metaData.url()) ) {
-        kWarning() << "Could not remove old cache item" << cacheData->metaData.url();
+        qWarning() << "Could not remove old cache item" << cacheData->metaData.url();
         m_orderedData.removeFirst();
     }
 }
 
 bool NetworkMemoryCache::remove( const QUrl &url )
 {
     if ( m_data.contains(url) ) {
         // Data cached for url, remove it
         CacheData *cacheData = m_data.take( url );
         m_orderedData.removeOne( cacheData );
         delete cacheData;
         return true;
     } else {
         return false;
     }
 }
 
 void NetworkMemoryCache::updateMetaData( const QNetworkCacheMetaData &metaData )
 {
     if ( !m_data.contains(metaData.url()) ) {
         return;
     }
 
     CacheData *data = m_data[ metaData.url() ];
     data->metaData = metaData;
 }
 
 QIODevice *NetworkMemoryCache::data( const QUrl &url )
 {
     if ( !m_data.contains(url) ) {
         return 0;
     }
 
     CacheData *data = m_data[ url ];
     QBuffer *buffer = new QBuffer( this );
     buffer->setData( data->data );
     if ( !buffer->open(QIODevice::ReadOnly) ) {
         delete buffer;
         return 0;
     } else {
         return buffer;
     }
 }
 
 QNetworkCacheMetaData NetworkMemoryCache::metaData( const QUrl &url )
 {
     if ( !m_data.contains(url) ) {
         return QNetworkCacheMetaData();
     }
 
     CacheData *data = m_data[ url ];
     return data->metaData;
 }
 
 NetworkMemoryCache::CacheData::CacheData( const QNetworkCacheMetaData &metaData,
                                           const QByteArray &data )
         : metaData(metaData), data(data)
 {
 }
 
 QNetworkReply *MonitorNetworkAccessManager::createRequest( QNetworkAccessManager::Operation op,
                                                            const QNetworkRequest &request,
                                                            QIODevice *outgoingData )
 {
     QByteArray data;
     QNetworkReply *reply;
     QNetworkRequest _request( request );
     _request.setAttribute( QNetworkRequest::CacheSaveControlAttribute, true );
     if ( outgoingData ) {
         QBuffer *buffer = qobject_cast< QBuffer* >( outgoingData );
         if ( buffer ) {
             // Read from buffer without changing the position in outgoingData
             data = buffer->buffer();
             reply = QNetworkAccessManager::createRequest( op, _request, outgoingData );
         } else if ( !outgoingData->isSequential() ) {
             // Read from random access device and reset to the start position
             data = outgoingData->readAll();
             outgoingData->reset();
             reply = QNetworkAccessManager::createRequest( op, _request, outgoingData );
         } else {
             // Read from sequential device and create a new device after reading,
             // because sequential devices can only be read once and would be empty when send to
             // QNetworkAccessManager::createRequest()
             buffer = new QBuffer( outgoingData->parent() );
             buffer->setData( outgoingData->readAll() );
             data = buffer->buffer();
             outgoingData->close();
             outgoingData->deleteLater();
             reply = QNetworkAccessManager::createRequest( op, _request, buffer );
         }
     } else {
         reply = QNetworkAccessManager::createRequest( op, _request );
     }
 
     emit requestCreated( NetworkMonitorModelItem::typeFromOperation(op),
                          _request.url().toString(), data, reply );
     return reply;
 }
diff --git a/engine/timetablemate/src/project.cpp b/engine/timetablemate/src/project.cpp
index d85a41a..428b640 100644
--- a/engine/timetablemate/src/project.cpp
+++ b/engine/timetablemate/src/project.cpp
@@ -1,6487 +1,6487 @@
 /*
 *   Copyright 2013 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 "project.h"
 
 // Own includes
 #include "debug_config.h"
 #include "projectmodel.h"
 #include "projectsettingsdialog.h"
 #include "serviceproviderdatawriter.h"
 #include "serviceproviderdatatester.h"
 #include "testmodel.h"
 #include "linkchecker.h"
 #include "tabs/abstracttab.h"
 #include "tabs/dashboardtab.h"
 #include "tabs/projectsourcetab.h"
 #include "tabs/webtab.h"
 #include "tabs/plasmapreviewtab.h"
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     #include "tabs/scripttab.h"
     #include "../../script/scriptapi.h" // For Q_DECLARE_METATYPE's (eg. Helper::ErrorSeverity used in connections)
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     #include "tabs/gtfsdatabasetab.h"
 #endif
 #include "debugger/debugger.h"
 #include "debugger/backtracemodel.h"
 #include "debugger/breakpointmodel.h"
 #include "debugger/debuggerjobs.h"
 #include "debugger/timetabledatarequestjob.h"
 
 // PublicTransport engine includes
 #include <engine/serviceprovider.h>
 #include <engine/serviceproviderdata.h>
 #include <engine/serviceproviderglobal.h>
 #include <engine/request.h>
 #include <engine/global.h>
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     #include <engine/script/serviceproviderscript.h>
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     #include <engine/gtfs/gtfsdatabase.h>
 #endif
 
 // KDE includes
 #include <KUrlComboBox>
 #include <KLineEdit>
 #include <KDoubleNumInput>
 #include <KDateTimeWidget>
 #include <KWebView>
 #include <KMessageBox>
 #include <KFileDialog>
 #include <KInputDialog>
 #include <KIcon>
 #include <KMenu>
 #include <KAction>
 #include <KActionMenu>
 #include <KStandardDirs>
 #include <KColorScheme>
 #include <KLocale>
 #include <KLocalizedString>
 #include <KZip>
 #include <KTemporaryFile>
 #include <Plasma/Corona>
 #include <knewstuff3/uploaddialog.h>
 #include <KAuth/ActionReply>
 #include <KAuth/Action>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <KTextEditor/TemplateInterface>
 #include <KTextEditor/MarkInterface>
 #include <ThreadWeaver/WeaverInterface>
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     #include <Plasma/DataEngineManager>
     #include <Plasma/ServiceJob>
 #endif
 
 #ifdef MARBLE_FOUND
     #include <marble/LatLonEdit.h>
 #endif
 
 // Qt includes
 #include <QWidget>
 #include <QToolTip>
 #include <QSortFilterProxyModel>
 #include <QStandardItemModel>
 #include <QMenu>
 #include <QFormLayout>
 #include <QApplication>
 #include <QFile>
 #include <QTextCodec>
 #include <QBuffer>
 #include <QFileInfo>
 #include <QMutex>
 #include <QTimer>
 
 class ProjectPrivate
 {
 public:
     enum ConnectProjectActionFlag {
         NoConnectionFlags       = 0x0000,
         AutoUpdateEnabledState  = 0x0001,  /**< If this flag is set, the enabled state of the
                 * connected project action gets updated in updateProjectActions().
                 * Do not use this flag, if the action is always enabled or if its enabled state
                 * gets updated in another way, eg. by connecting to its setEnabled()/setDisabled()
                 * slots. */
         UseQueuedConnection     = 0x0002
     };
     Q_DECLARE_FLAGS( ConnectProjectActionFlags, ConnectProjectActionFlag )
 
     enum TestState {
         NoTestRunning,
         TestsRunning,
         TestsGetAborted
     };
 
     enum ScriptState {
         InitializingScript = 0,
         ScriptNotLoaded,
         ScriptLoaded
     };
 
     ProjectPrivate( Enums::ServiceProviderType providerType,
                     const WeaverInterfacePointer &weaver, Project *project )
         : state(Project::Uninitialized), projectModel(0), mutex(new QMutex(QMutex::Recursive)),
           projectSourceBufferModified(false),
           dashboardTab(0), projectSourceTab(0), plasmaPreviewTab(0), webTab(0),
 #ifdef BUILD_PROVIDER_TYPE_GTFS
           gtfsDatabaseTab(0), gtfsDatabaseState(Project::InitializingGtfsDatabase),
           gtfsFeedImportProgress(0), gtfsDatabaseSize(0),
 #endif
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
           scriptState(InitializingScript), scriptTab(0),
           debugger(new Debugger::Debugger(weaver, project)),
 #endif
           provider(ServiceProvider::createProvider(providerType, project)),
           testModel(new TestModel(project)), testState(NoTestRunning),
           lastScriptError(NoScriptError), suppressMessages(false), enableQuestions(true),
           q_ptr(project)
     {
     };
 
     ~ProjectPrivate() {
         delete mutex;
     };
 
     static inline QString serviceProviderIdFromProjectFileName( const QString &fileName ) {
         return fileName.left( fileName.lastIndexOf('.') );
     };
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     static QString scriptTemplateText( Project::ScriptTemplateType templateType
                                        = Project::DefaultScriptTemplate,
                                        const ServiceProviderData *data = 0 )
     {
         // Insert provider ID and author if available, otherwise insert template placeholders
         const QString providerId = data && !data->id().isEmpty()
                 ? data->url() : "${Service Provider}";
         const QString author = data && !data->author().isEmpty() ? data->author() : "${Author}";
         QString templateText = QString::fromUtf8(
                 "/** Service provider plugin for %1\n"
                 "  * © %2, %3 */\n"
                 "\n").arg(providerId).arg(QDate::currentDate().year()).arg(author);
 
         switch ( templateType ) {
         case Project::ScriptRubyTemplate:
             templateText +=
                     "\n// Create Kross action"
                     "var action = Kross.action( \"RubyScript\" );\n"
                     "\n"
                     "// Propagate action to the Python script\n"
                     "action.addQObject( action, \"MyAction\" );\n"
                     "\n"
                     "// Set the interpreter to use, eg. \"python\", \"ruby\"\n"
                     "action.setInterpreter( \"ruby\" );\n"
                     "\n"
                     "// Set the code to execute and trigger execution\n"
                     "action.setCode( \"${cursor}\" /* TODO: Insert ruby code here */ );\n"
                     "action.trigger();\n";
             break;
         case Project::ScriptPythonTemplate:
             templateText +=
                     "\n// Create Kross action"
                     "var action = Kross.action( \"PythonScript\" );\n"
                     "\n"
                     "// Propagate action to the Python script\n"
                     "action.addQObject( action, \"MyAction\" );\n"
                     "\n"
                     "// Set the interpreter to use, eg. \"python\", \"ruby\"\n"
                     "action.setInterpreter( \"python\" );\n"
                     "\n"
                     "// Set the code to execute and trigger execution\n"
                     "action.setCode( \"import MyAction; print 'This is Python. name=>', MyAction.interpreter()\"${cursor} );\n"
                     "action.trigger();\n";
             break;
         case Project::ScriptQtScriptTemplate:
             templateText +=
                     "\n// This function gets called to determine the features of the service provider\n"
                     "function features() {\n"
                     "    // Return a list of ProviderFeature's, that are supported by this script.\n"
                     "    // Some features like ProvidesDepartures are recognized automatically\n"
                     "    // by implementing the associated script function\n"
                     "    return [ PublicTransport.ProvidesArrivals,\n"
                     "             PublicTransport.ProvidesDelays,\n"
                     "             PublicTransport.ProvidesNews,\n"
                     "             PublicTransport.ProvidesPlatform,\n"
                     "             PublicTransport.ProvidesStopID,\n"
                     "             PublicTransport.ProvidesStopGeoPosition,\n"
                     "             PublicTransport.ProvidesStopsByGeoPosition,\n"
                     "             PublicTransport.ProvidesPricing,\n"
                     "             PublicTransport.ProvidesRouteInformation,\n"
                     "             PublicTransport.ProvidesMoreJourneys ];\n"
                     "}\n"
                     "\n"
                     "// This function gets called when departures/arrivals are requested\n"
                     "function getTimetable( values ) {\n"
                     "    // Construct an URL from the given values\n"
                     "    var url = \"http://www.page.com\" +\n"
                     "            \"?stop=\" + values.stop + \"!\" +\n"
                     "            \"&boardType=\" + (values.dataType == \"arrivals\" ? \"arr\" : \"dep\") +\n"
                     "            \"&date=\" + helper.formatDateTime(values.dateTime, \"dd.MM.yy\") +\n"
                     "            \"&time=\" + helper.formatDateTime(values.dateTime, \"hh:mm\") +\n"
                     "            \"&maxJourneys=\" + values.count;\n"
                     "\n"
                     "    // Create a NetworkRequest object for the URL\n"
                     "    var request = network.createRequest( url );\n"
                     "\n"
                     "    // Connect to the finished signal,\n"
                     "    // an alternative is the readyRead signal to parse iteratively\n"
                     "    request.finished.connect( parseTimetable );\n"
                     "\n"
                     "    // Start the download,\n"
                     "    // the parseTimetable() function will be called when it is finished\n"
                     "    network.get( request );\n"
                     "}\n"
                     "\n"
                     "// This function is connected to the finished signal of network requests\n"
                     "// started in getTimetable()\n"
                     "function parseTimetable( html, hasError, errorString ) {\n"
                     "    if ( hasError ) {\n"
                     "        // The network request failed,\n"
                     "        // if the script has no other way to get the timetable data\n"
                     "        // an error should be thrown like here:\n"
                     "        throw Error( errorString );\n"
                     "    }\n"
                     "\n"
                     "    // Decode the received document\n"
                     "    html = helper.decode( html, \"utf8\" );\n"
                     "\n"
                     "    // TODO: Parse the contents of the document and add found timetable items\n"
                     "    // to the result set using result.addData()\n"
                     "    // Use helper.findHtmlTags(), helper.findFirstHtmlTag() or \n"
                     "    // helper.findNamedHtmlTags() to parse HTML documents (see documentation)\n"
                     "    ${cursor}\n"
                     "}\n"
                     "\n"
                     "// This function gets called when stop suggestions are requested\n"
                     "function getStopSuggestions( values ) {\n"
                     "    // Construct an URL from the given values\n"
                     "    var url = \"http://www.page.com?stop=\" + values.stop;\n"
                     "\n"
                     "    // Download the document synchronously\n"
                     "    var json = network.getSynchronous( url );\n"
                     "\n"
                     "    // Check if the download was completed successfully\n"
                     "    if ( !network.lastDownloadAborted ) {\n"
                     "        // Decode the received document\n"
                     "        html = helper.decode( html, \"utf8\" );\n"
                     "\n"
                     "        // TODO: Find all stop suggestions\n"
                     "        result.addData({ StopName: \"Test-Stop\",\n"
                     "                         StopID: \"123\",\n"
                     "                         StopWeight: stop[3] });\n"
                     "        return result.hasData();\n"
                     "    } else {\n"
                     "        return false;\n"
                     "    }\n"
                     "}\n"
                     "\n"
                     "// TODO: To parse journeys implement getJourneys()\n";
             break;
         case Project::ScriptQtScriptHafasTemplate:
             templateText +=
                     "\n// Include the base script for HAFAS providers\n"
                     "include(\"base_hafas.js\");\n"
                     "\n"
                     "// Create instance of the Hafas class (from the base HAFAS script).\n"
                     "// Some available options are shown below, but are commented, because they\n"
                     "// are optional and use the default values. Uncomment and change the values\n"
                     "// to use those options. See \"base_hafas.js\" for more information.\n"
                     "var hafas = Hafas({\n"
                     "    baseUrl: \"${Base URL}\", // The base HAFAS API URL excluding '/bin/...'\n"
                     "//    binDir: \"bin\", // The relative path to add to baseUrl to get the \n"
                     "            // binary API URL, \"bin\" is the default.\n"
                     "//    programExtension: \"exe\", // The extension to add to HAFAS programs\n"
                     "            // eg. 'stboard', \"exe\" is the default.'\n"
                     "//    language: \"d\", // One character identifying the language to request,\n"
                     "            // the default is 'd' for german, as most HAFAS providers are\n"
                     "            // for germany. Use eg. 'e' for english, 's' for swedish, etc.\n"
                     "//    urlDateFormat: \"dd.MM.yy\", // Format of dates in URLs,\n"
                     "            // 'dd.MM.yy' is the default.'\n"
                     "//    urlTimeFormat: \"hh:mm\", // Format of times in URLs,\n"
                     "            // 'hh:mm' is the default.'\n"
                     "//    xmlDateFormat: \"dd.MM.yy\", // Format of dates in received XML\n"
                     "            // documents, 'dd.MM.yy' is the default.'\n"
                     "//    xmlTimeFormat: \"hh:mm\", // Format of times in received XML documents,\n"
                     "            // 'hh:mm' is the default.'\n"
                     "//    format: Hafas.XmlFormat // Default format of received documents,\n"
                     "            // this determines the parser function to use\n"
                     "});\n"
                     "\n"
                     "// To remove a feature from eg. the departure/arrival processor, because the\n"
                     "// provider does not support the required parts of the HAFAS API\n"
                     "// use code like this:\n"
                     "// hafas.timetable.removeFeature( PublicTransport.ProvidesArrivals );\n"
                     "\n"
                     "// This function gets called to determine the features of the service provider.\n"
                     "// The features supported by the HAFAS base script can be concatenated like\n"
                     "// shown below.\n"
                     "function features() {\n"
                     "    return hafas.stopSuggestions.features.concat(\n"
                     "            hafas.timetable.features,\n"
                     "            hafas.timetable.additionalData.features,\n"
                     "            hafas.journeys.features );\n"
                     "}\n"
                     "\n"
                     "// The script functions can directly use implementations from the base HAFAS\n"
                     "// script. These get() functions will generate an URL, download it and then\n"
                     "// parse the received document using the parser specified by the 'format'\n"
                     "// option. The get() functions also accept an options argument, which will\n"
                     "// overwrite global options given in the Hafas constructor.\n"
                     "var getStopSuggestions = hafas.stopSuggestions.get;\n"
                     "var getTimetable = hafas.timetable.get;\n"
                     "var getAdditionalData = hafas.timetable.additionalData.get;\n"
                     "var getJourneys = hafas.journeys.get;\n"
                     "\n"
                     "// The default format for additional timetable data, that can be downloaded\n"
                     "// later is Hafas.HtmlMobileFormat (hafas.timetable.additionalData.format).\n"
                     "// Uncomment the following line to change the format to eg. plain text:\n"
                     "//   hafas.timetable.additionalData.format = Hafas.TextFormat;\n"
                     "// You can implement a parser function for each available format, eg.\n"
                     "// parseText() for TextFormat, parseXml() for XmlFormat, parseHtml() for \n"
                     "// HtmlFormat, etc.\n"
                     "// Standard formats like XML are supported by the base HAFAS script.\n"
                     "// Add implementations of route data parser functions for non-standard formats\n"
                     "// to hafas.routeData.parser. It gets used to parse the document at the found\n"
                     "// RouteDataUrl.\n"
                     "hafas.timetable.parser.parseHtmlMobile = function( html, hasError, errorString ) {\n"
                     "    if ( hasError ) {\n"
                     "        throw Error( errorString );\n"
                     "    }\n"
                     "    if ( html.length == 0 ) {\n"
                     "        throw Error(\"parseTimetableMobile(): Received HTML document is empty\");\n"
                     "    }\n"
                     "\n"
                     "    Decode the received document, TODO: Use correct encoding\n"
                     "    html = helper.decode( html, \"latin1\" );\n"
                     "\n"
                     "    // Initialize return value\n"
                     "    var departures = [];\n"
                     "\n"
                     "    // TODO: Implement code that parses the (mobile) HTML document,\n"
                     "    // only the shown data needs to be added, but it must equal the data\n"
                     "    // that was read from the XML HAFAS format, because the RouteDataUrl\n"
                     "    // gets associated with the already received timetable item that matches\n"
                     "    // the data found here:\n"
                     "    var departure = { RouteDataUrl: \"traininfo.exe-URL\",\n"
                     "                      TransportLine: \"Test-Line\",\n"
                     "                      Target: \"Test-Target\",\n"
                     "                      DepartureDateTime: new Date() };\n"
                     "\n"
                     "    departures.push( departure );\n"
                     "    return departures;\n"
                     "}\n"
                     "\n";
             break;
         default:
             break;
         }
 
         return templateText;
     };
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
     // Initialize member variables, connect slots
     bool initialize()
     {
         Q_ASSERT( state == Project::Uninitialized );
 
         qRegisterMetaType< Project::ProjectActionData >( "ProjectActionData" );
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         // Load publictransport engine only if GTFS is available (but if it is load it also for
         // scripted providers), used to access the GTFS service of the engine
         Plasma::DataEngineManager::self()->loadEngine("publictransport");
 #endif
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         Q_Q( Project );
 
         // Connect to signals of the debugger
         q->connect( debugger, SIGNAL(interrupted(int,QString,QDateTime)),
                     q, SLOT(debugInterrupted(int,QString,QDateTime)) );
         q->connect( debugger, SIGNAL(continued(QDateTime,bool)), q, SLOT(debugContinued()) );
         q->connect( debugger, SIGNAL(started()), q, SLOT(debugStarted()) );
         q->connect( debugger, SIGNAL(stopped(ScriptRunData)), q, SLOT(debugStopped(ScriptRunData)) );
         q->connect( debugger, SIGNAL(aborted()), q, SLOT(debugAborted()) );
 
         q->connect( debugger, SIGNAL(jobStarted(JobType,QString,QString)),
                     q, SLOT(jobStarted(JobType,QString,QString)) );
         q->connect( debugger, SIGNAL(jobDone(JobType,QString,QString,DebuggerJobResult)),
                     q, SLOT(jobDone(JobType,QString,QString,DebuggerJobResult)) );
         q->connect( debugger, SIGNAL(loadScriptResult(ScriptErrorType,QString,QStringList,QStringList)),
                     q, SLOT(loadScriptResult(ScriptErrorType,QString,QStringList,QStringList)) );
         q->connect( debugger, SIGNAL(requestTimetableDataResult(QSharedPointer<AbstractRequest>,bool,QString,QList<TimetableData>,QVariant)),
                     q, SLOT(functionCallResult(QSharedPointer<AbstractRequest>,bool,QString,QList<TimetableData>,QVariant)) );
 
         q->connect( debugger, SIGNAL(informationMessage(QString)),
                     q, SLOT(slotDebugInformationMessage(QString)) );
         q->connect( debugger, SIGNAL(errorMessage(QString)),
                     q, SLOT(slotDebugErrorMessage(QString)) );
         q->connect( debugger, SIGNAL(output(QString,QScriptContextInfo)),
                     q, SLOT(scriptOutput(QString,QScriptContextInfo)) );
         q->connect( debugger, SIGNAL(scriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)),
                     q, SLOT(scriptMessageReceived(QString,QScriptContextInfo,QString,Helper::ErrorSeverity)) );
         q->connect( debugger, SIGNAL(exception(int,QString,QString)),
                     q, SLOT(scriptException(int,QString,QString)) );
         q->connect( debugger, SIGNAL(evaluationResult(EvaluationResult)),
                     q, SLOT(evaluationResult(EvaluationResult)) );
         q->connect( debugger, SIGNAL(commandExecutionResult(QString)),
                     q, SLOT(commandExecutionResult(QString)) );
         q->connect( debugger, SIGNAL(waitingForSignal()), q, SLOT(waitingForSignal()) );
         q->connect( debugger, SIGNAL(wokeUpFromSignal(int)), q, SLOT(wokeUpFromSignal(int)) );
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
         state = Project::NoProjectLoaded;
         return true;
     };
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     void setGtfsDatabaseState( Project::GtfsDatabaseState state ) {
         Q_Q( Project );
         if ( gtfsDatabaseState == state ) {
             return;
         }
 
         if ( state != Project::GtfsDatabaseError && !gtfsDatabaseErrorString.isEmpty() ) {
             // Clear old error strings
             gtfsDatabaseErrorString.clear();
             q->emit gtfsDatabaseErrorStringChanged( gtfsDatabaseErrorString );
         }
         if ( state != Project::GtfsDatabaseImportFinished && gtfsDatabaseSize != 0 ) {
             gtfsDatabaseSize = 0;
             gtfsDatabaseModifiedTime = QDateTime();
             q->emit gtfsDatabaseSizeChanged( 0 );
         }
         if ( state != Project::GtfsDatabaseImportRunning && !gtfsFeedImportInfoMessage.isEmpty() ) {
             gtfsFeedImportInfoMessage.clear();
             q->emit gtfsFeedImportInfoMessageChanged( gtfsFeedImportInfoMessage );
         }
 
         switch ( state ) {
         case Project::GtfsDatabaseImportPending:
         case Project::GtfsDatabaseError:
             if ( gtfsFeedImportProgress != 0 ) {
                 gtfsFeedImportProgress = 0;
                 q->emit gtfsFeedImportProgressChanged( 0 );
             }
             q->emit gtfsDatabasePathChanged( QString() );
             break;
         case Project::GtfsDatabaseImportFinished:
         case Project::GtfsDatabaseUpdateAvailable: {
             if ( gtfsFeedImportProgress != 100 ) {
                 gtfsFeedImportProgress = 100;
                 q->emit gtfsFeedImportProgressChanged( 100 );
             }
 
             // Update GTFS database size
             const QString databasePath = GtfsDatabase::databasePath( data()->id() );
             const QFileInfo databaseInfo( databasePath );
             quint64 newGtfsDatabaseSize = databaseInfo.size();
             if ( gtfsDatabaseSize != newGtfsDatabaseSize ) {
                 gtfsDatabaseSize = newGtfsDatabaseSize;
                 gtfsDatabaseModifiedTime = databaseInfo.lastModified();
                 q->emit gtfsDatabaseSizeChanged( newGtfsDatabaseSize );
             }
             q->emit gtfsDatabasePathChanged( databasePath );
             break;
         }
         default:
             break;
         }
 
         gtfsDatabaseState = state;
         updateProjectActions( Project::GtfsDatabaseActionGroup );
         q->emit gtfsDatabaseStateChanged( state );
     };
 
     void updateGtfsDatabaseState( bool calledByFinishedUpdateInfoJob = false ) {
         Q_Q( Project );
         if ( provider->type() != Enums::GtfsProvider ) {
             return;
         }
 
         // Read provider information cache
         KConfig config( ServiceProviderGlobal::cacheFileName(), KConfig::SimpleConfig );
         KConfigGroup group = config.group( data()->id() );
         KConfigGroup gtfsGroup = group.group( "gtfs" );
 
         Project::GtfsDatabaseState state;
         if ( !GtfsDatabase::initDatabase(data()->id(), &gtfsDatabaseErrorString) ) {
-            kWarning() << "Error initializing the database" << gtfsDatabaseErrorString;
+            qWarning() << "Error initializing the database" << gtfsDatabaseErrorString;
             state = Project::GtfsDatabaseError;
         } else if ( gtfsGroup.readEntry("feedImportFinished", false) ) {
             state = Project::GtfsDatabaseImportFinished;
         } else {
             state = Project::GtfsDatabaseImportPending;
         }
 
         const QString feedModifiedTimeString =
                 gtfsGroup.readEntry( "feedModifiedTime", QString() );
         gtfsFeedModifiedTime = QDateTime::fromString( feedModifiedTimeString, Qt::ISODate );
         gtfsFeedSize = gtfsGroup.readEntry( "feedSizeInBytes", 0 );
 
         // Update size/modified time of the GTFS database
         if ( gtfsDatabaseSize <= 0 || !gtfsDatabaseModifiedTime.isValid() ) {
             // Update GTFS database size/last modified time
             const QString databasePath = GtfsDatabase::databasePath( data()->id() );
             const QFileInfo databaseInfo( databasePath );
             quint64 newGtfsDatabaseSize = databaseInfo.size();
             if ( gtfsDatabaseSize != newGtfsDatabaseSize ) {
                 gtfsDatabaseSize = newGtfsDatabaseSize;
                 gtfsDatabaseModifiedTime = databaseInfo.lastModified();
                 q->emit gtfsDatabaseSizeChanged( newGtfsDatabaseSize );
             }
         }
 
         // Check if a new version is available
         if ( state == Project::GtfsDatabaseImportFinished &&
              gtfsDatabaseModifiedTime.isValid() &&
              gtfsFeedModifiedTime > gtfsDatabaseModifiedTime )
         {
             state = Project::GtfsDatabaseUpdateAvailable;
         }
         setGtfsDatabaseState( state );
 
         if ( !calledByFinishedUpdateInfoJob && gtfsFeedSize <= 0 ) {
             Plasma::DataEngine *engine = Plasma::DataEngineManager::self()->engine("publictransport");
             Plasma::Service *gtfsService = engine->serviceForSource("GTFS");
             KConfigGroup op = gtfsService->operationDescription("updateGtfsFeedInfo");
             op.writeEntry( "serviceProviderId", data()->id() );
             Plasma::ServiceJob *updateJob = gtfsService->startOperationCall( op );
             q->connect( updateJob, SIGNAL(result(KJob*)), q, SLOT(updateGtfsDatabaseState()) );
             q->connect( updateJob, SIGNAL(finished(KJob*)), gtfsService, SLOT(deleteLater()) );
         }
     };
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
     // Load project from service provider XML document at @p projectSourceFile
     bool loadProject( const QString &projectSourceFile )
     {
         Q_Q( Project );
 
         // Try to open the XML in the Kate part in the "Project Source" tab
         if ( !QFile::exists(projectSourceFile) ) {
             // Project file not found, create a new one from template
             errorHappened( Project::ProjectFileNotFound, i18nc("@info", "The project file <filename>"
                         "%1</filename> could not be found.", projectSourceFile) );
             insertProjectSourceTemplate();
             return false;
         }
 
         if ( isModified() ) {
-            kWarning() << "Loading another project, discarding changes in the previously "
+            qWarning() << "Loading another project, discarding changes in the previously "
                           "loaded project";
         }
 
         // Cleanup
         if ( projectSourceTab ) {
             projectSourceTab->document()->closeUrl( false );
         }
         lastError.clear();
         output.clear();
         consoleText.clear();
         projectSourceBufferModified = false;
         filePath.clear();
         serviceProviderID.clear();
         abortTests();
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         unsavedScriptContents.clear();
         if ( scriptTab ) {
             scriptTab->document()->closeUrl( false );
             scriptTab->setExecutionPosition( -1 );
         }
         debugger->abortDebugger();
 #endif
         testModel->clear();
         q->emit outputCleared();
         q->emit outputChanged();
         q->emit consoleTextChanged( QString() );
 
         QUrl url( projectSourceFile );
         if ( projectSourceTab ) {
             if ( !projectSourceTab->document()->openUrl(url) ) {
                 errorHappened( Project::ProjectFileNotReadable,
                                i18nc("@info", "Could not open project source document "
                                      "<filename>%1</filename>.", url.url()) );
             }
             projectSourceTab->document()->setModified( false );
         }
 
         if ( !readProjectSourceDocumentFromTabOrFile(projectSourceFile) ) {
             insertProjectSourceTemplate();
             return false;
         }
 
         setXmlFilePath( projectSourceFile );
         state = Project::ProjectSuccessfullyLoaded;
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         scriptState = InitializingScript;
 
         // Load script file referenced by the XML
         loadScript();
 
         q->scriptSaved();
 #endif
 
         return true;
     };
 
     bool isActiveProject() const
     {
         Q_Q( const Project );
         return projectModel ? projectModel->activeProject() == q : false;
     };
 
     bool isProjectSourceModified() const
     {
         return (projectSourceTab && projectSourceTab->isModified()) || projectSourceBufferModified;
     };
 
     bool isScriptModified() const
     {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         return (scriptTab && scriptTab->isModified()) || !unsavedScriptContents.isEmpty();
 #else
         return false; // No script support
 #endif
     };
 
     bool isModified() const
     {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         foreach ( ScriptTab *tab, externalScriptTabs ) {
             if ( tab->isModified() ) {
                 return true;
             }
         }
 #endif
 
         return isScriptModified() || isProjectSourceModified() ||
             (plasmaPreviewTab && plasmaPreviewTab->isModified()) ||
             (webTab && webTab->isModified());
     };
 
     inline bool isTestRunning() const
     {
         return testState != NoTestRunning;
     };
 
     inline bool isDebuggerRunning() const
     {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         return debugger->isRunning();
 #else
         return false; // No script support, no debugger
 #endif
     };
 
     QString projectName() const
     {
         QString name = provider->data()->names()[ KGlobal::locale()->country() ];
         if ( name.isEmpty() ) {
             // No translated name
             name = provider->data()->name();
         }
 
         if ( name.isEmpty()) {
             // No name given, use service provider ID if available
             name = serviceProviderID.isEmpty()
                     ? i18nc("@info/plain", "New Project") : serviceProviderID;
         } else {
             // Add service provider ID to the name
             name += " (" + serviceProviderID + ')';
         }
         return name;
     };
 
     inline const ServiceProviderData *data() const
     {
         return provider->data();
     };
 
     QString iconName() const
     {
         if ( serviceProviderID.isEmpty() ) {
             // New unsaved project
             return "folder-development";
         } else {
             // Project file is stored on disk
             Project::InstallType installType = saveType();
             switch ( installType ) {
             case Project::LocalInstallation:
                 return "folder-orange";
             case Project::GlobalInstallation:
                 return "folder-red";
             case Project::NoInstallation:
             default:
                 return "folder-development";
             }
         }
     };
 
     inline QIcon projectIcon() const
     {
         return KIcon( iconName() );
     };
 
     bool isInstalledLocally() const
     {
         if ( filePath.isEmpty() ) {
             return false;
         }
         const QString localSaveDir = KGlobal::dirs()->saveLocation( "data",
                 ServiceProviderGlobal::installationSubDirectory() );
         const QString fileName = QFileInfo( filePath ).fileName();
         return QFile::exists( localSaveDir + '/' + fileName );
     };
 
     bool isInstalledGlobally() const
     {
         if ( filePath.isEmpty() ) {
             return false;
         }
         const QString globalSaveDir = KGlobal::dirs()->findDirs( "data",
                 ServiceProviderGlobal::installationSubDirectory() ).last();
         const QString fileName = QFileInfo( filePath ).fileName();
         return QFile::exists( globalSaveDir + '/' + fileName );
     };
 
     inline Project::InstallType saveType() const
     {
         return Project::installationTypeFromFilePath( filePath );
     };
 
     Project::InstallTypes installationTypes() const
     {
         Project::InstallTypes ret = Project::NoInstallation;
         if ( isInstalledLocally() ) {
             ret |= Project::LocalInstallation;
         }
         if ( isInstalledGlobally() ) {
             ret |= Project::GlobalInstallation;
         }
         return ret;
     };
 
     inline QString savePathInfoString() const
     {
         QString message = Project::savePathInfoStringFromFilePath( filePath );
         const Project::InstallType installType = saveType();
         switch ( installType ) {
         case Project::LocalInstallation:
             if ( isInstalledGlobally() ) {
                 message += ", " + i18nc("@info:tooltip", "also installed globally");
             }
             break;
         case Project::GlobalInstallation:
             if ( isInstalledLocally() ) {
                 message += ", " + i18nc("@info:tooltip", "also installed locally");
             }
             break;
         case Project::NoInstallation:
         default:
             if ( isInstalledLocally() && isInstalledGlobally() ) {
                 message += ", " + i18nc("@info:tooltip", "installed locally and globally");
             } else if ( isInstalledLocally() ) {
                 message += ", " + i18nc("@info:tooltip", "installed locally");
             } else if ( isInstalledGlobally() ) {
                 message += ", " + i18nc("@info:tooltip", "installed globally");
             }
             break;
         }
         return message;
     };
 
     // Read service provider plugin XML document from file or from opened project source document tab
     bool readProjectSourceDocumentFromTabOrFile( const QString &xmlFilePath )
     {
         Q_Q( Project );
         if ( xmlFilePath.isEmpty() ) {
             kDebug() << "No xml file path given, insert template";
             insertProjectSourceTemplate();
             return true;
         }
 
         // Try to read the XML contents
         if ( projectSourceTab ) {
             // Use text in already loaded project source document
             QTextCodec *codec = QTextCodec::codecForName( projectSourceTab->document()->encoding().isEmpty()
                                 ? "UTF-8" : projectSourceTab->document()->encoding().toLatin1() );
             QByteArray text = codec->fromUnicode( projectSourceTab->document()->text() );
             QBuffer buffer( &text, q );
             return readProjectSourceDocument( &buffer, xmlFilePath );
         } else {
             // Read text from file, service provider document not loaded
             QFile file( xmlFilePath );
             return readProjectSourceDocument( &file, xmlFilePath );
         }
     };
 
     // Read project source XML document from file
     bool readProjectSourceDocument( const QString &fileName )
     {
         QFile file( fileName );
         return readProjectSourceDocument( &file, fileName );
     };
 
     // Read service provider plugin XML document from @p device, set file name to @p fileName
     bool readProjectSourceDocument( QIODevice *device, const QString &fileName )
     {
         Q_Q( Project );
 
         ServiceProviderDataReader reader;
         QString errorMessage;
         ServiceProviderData *readData = reader.read(
                 device, fileName, ServiceProviderDataReader::ReadErrorneousFiles,
                 q, &xmlComments, &errorMessage );
 
         // Recreate service provider from the contents of device
         xmlComments.clear();
         provider->deleteLater();
         if ( readData ) {
             Enums::ServiceProviderType oldType = provider ? provider->type() : Enums::InvalidProvider;
             switch ( readData->type() ) {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             case Enums::ScriptedProvider:
                 provider = new ServiceProviderScript( readData, q );
                 break;
 #endif
 // NOTE Cannot create ServiceProviderGtfs instance, because the GTFS-realtime protocol buffer
 // classes can only be used once with the same name, otherwise there will be crashes when using
 // ServiceProviderGtfs from libprotobuf. Since GTFS-realtime features are not used by TimetableMate
 // and only ServiceProviderGtfs::features() gets actually used, simply copy that function
 // into TimetableMate.
             default:
                 // Do not create sub class instance for unknown types,
                 // this leads to eg. empty feature lists being inserted into the upload dialog
-                kWarning() << "Unknown provider type" << readData->type();
+                qWarning() << "Unknown provider type" << readData->type();
                 provider = new ServiceProvider( readData, q );
                 break;
             }
 
             if ( provider->type() != oldType ) {
                 q->emit providerTypeChanged( provider->type(), oldType );
             }
 
             if ( !errorMessage.isEmpty() ) {
                 kDebug() << "Service provider plugin has errors" << errorMessage << fileName;
                 errorHappened( Project::ErrorWhileLoadingProject, errorMessage );
             }
         } else {
             kDebug() << "Service provider plugin is invalid" << reader.errorString() << fileName;
             provider = ServiceProvider::createInvalidProvider( q );
             errorHappened( Project::ErrorWhileLoadingProject, reader.errorString() );
             insertProjectSourceTemplate();
             return false;
         }
 
         q->emit nameChanged( projectName() );
         q->emit iconNameChanged( iconName() );
         q->emit iconChanged( projectIcon() );
         q->emit dataChanged( data() );
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         updateGtfsDatabaseState();
 #endif
         return true;
     };
 
     // Write service provider plugin XML document to @p fileName
     bool writeProjectSourceDocument( const QString &fileName )
     {
         if ( !provider ) {
             kDebug() << "No service provider loaded";
             return false;
         }
 
         ServiceProviderDataWriter writer;
         QFile file( fileName );
         return writer.write( &file, provider, xmlComments );
     };
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     // Load the script into the script tab,
     // if no script has been created yet the given @p templateType gets inserted
     bool loadScript( Project::ScriptTemplateType templateType = Project::DefaultScriptTemplate )
     {
         Q_Q( Project );
         if ( !scriptTab ) {
             // No script tab opened
             return true;
         }
 
         scriptTab->document()->closeUrl( false );
         scriptTab->document()->setModified( false );
 
         const QString scriptFile = provider->data()->scriptFileName();
         if ( scriptFile.isEmpty() ) {
             insertScriptTemplate( templateType );
             scriptTab->document()->setReadWrite( true );
             return false;
         } else {
             if ( !QFile::exists(scriptFile) ) {
                 errorHappened( Project::ScriptFileNotFound,
                                i18nc("@info", "The script file <filename>%1</filename> "
                                      "could not be found.", scriptFile) );
                 return false;
             }
             if ( !scriptTab->document()->openUrl(QUrl(scriptFile)) ) {
                 return false;
             }
             scriptTab->document()->setModified( false );
         }
 
         q->emit tabTitleChanged( scriptTab, scriptTab->title(), scriptTab->icon() );
         return true;
     };
 
     bool checkSyntax( const QString &scriptText )
     {
         Q_Q( Project );
         QScriptSyntaxCheckResult syntax = QScriptEngine::checkSyntax( scriptText );
         if ( syntax.state() == QScriptSyntaxCheckResult::Error ) {
             // Open script tab and set the cursor position to the error position
             ScriptTab *tab = q->showScriptTab();
             if ( tab ) {
                 tab->goToLine( syntax.errorLineNumber() );
             }
 
             // Emit an information message about the syntax error
             q->emit informationMessage(
                     i18nc("@info", "Syntax error at line %1: <message>%2</message>",
                     syntax.errorLineNumber(), syntax.errorMessage()),
                     KMessageWidget::Error, 10000 );
 
             return false;
         } else {
             return true;
         }
     };
 #endif
 
     // Set the contents of the service provider plugin XML document to @p text
     // in the project source document tab
     bool setProjectSourceDocumentText( const QString &text )
     {
         if ( !projectSourceTab ) {
             kDebug() << "No project source tab opened";
             return true;
         }
 
         projectSourceTab->document()->closeUrl( false );
         projectSourceTab->document()->setModified( false );
 
         if ( text.isEmpty() ) {
             insertProjectSourceTemplate();
             return false;
         } else {
             // Open file if already stored to have the correct url set in KTextEditor::Document
             if ( !filePath.isEmpty() &&
                 !projectSourceTab->document()->openUrl(QUrl(filePath)) )
             {
                 errorHappened( Project::ProjectFileNotReadable,
                                i18nc("@info", "Could not open project source document "
                                      "<filename>%1</filename> could not be found.", filePath) );
                 return false;
             }
 
             // Update document contents with current project settings
             if ( !projectSourceTab->document()->setText(text) ) {
                 return false;
             }
         }
 
         return true;
     };
 
     // Set the xml file path to a canonical version of @p fileName
     // Should always be used instead of setting the value of xmlFilePath directly
     void setXmlFilePath( const QString &fileName )
     {
         Q_Q( Project );
         const QString oldXmlFilePath = filePath;
         filePath = QFileInfo( fileName ).canonicalFilePath();
 
         if ( oldXmlFilePath != filePath ) {
             // Update member variables
             QUrl url( filePath );
             const QString oldServiceProviderId = serviceProviderID;
             serviceProviderID = serviceProviderIdFromProjectFileName( url.fileName() );
 
             // Notify about changes
             q->emit saveLocationChanged( filePath, oldXmlFilePath );
 
             const Project::InstallType oldInstallType =
                     Project::installationTypeFromFilePath( oldXmlFilePath );
             const Project::InstallType newInstallType = saveType();
             if ( oldInstallType != newInstallType ) {
                 // The "save path info string" changes with the installation type
                 q->emit saveTypeChanged( newInstallType );
                 q->emit savePathInfoStringChanged( savePathInfoString() );
             }
 
             if ( oldServiceProviderId != serviceProviderID ) {
                 // Read again to update the provider ID in provider->data->id()
                 readProjectSourceDocument( filePath );
             }
         }
     };
 
     void insertProjectSourceTemplate()
     {
         Q_Q( Project );
         Enums::ServiceProviderType oldType = provider ? provider->type() : Enums::InvalidProvider;
         delete provider;
         provider = ServiceProvider::createProvider( oldType, q );
         xmlComments.clear();
 
         if ( provider->type() != oldType ) {
             q->emit providerTypeChanged( provider->type(), oldType );
         }
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         updateGtfsDatabaseState();
 #endif
         q->emit nameChanged( projectName() );
         q->emit iconNameChanged( iconName() );
         q->emit iconChanged( projectIcon() );
         q->emit dataChanged( data() );
     };
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     void insertScriptTemplate( Project::ScriptTemplateType templateType
                                = Project::DefaultScriptTemplate )
     {
         if ( templateType == Project::NoScriptTemplate ) {
             // Do nothing
             return;
         }
         if ( !scriptTab ) {
-            kWarning() << "No script tab created";
+            qWarning() << "No script tab created";
             return;
         }
 
         // Get the template interface
         KTextEditor::View *scriptView = scriptTab->document()->views().first();
         KTextEditor::TemplateInterface *templateInterface =
                 qobject_cast<KTextEditor::TemplateInterface*>( scriptView );
 
         if ( templateInterface ) {
             // Insert a template with author information
             templateInterface->insertTemplateText( KTextEditor::Cursor(),
                     scriptTemplateText(templateType, data()), QMap<QString, QString>() );
         }
     };
 #endif
 
     void errorHappened( Project::Error error, const QString &errorString )
     {
         Q_Q( Project );
         if ( !errorString.isEmpty() ) {
             // Store last error message
             lastError = errorString;
         }
         if ( state == Project::ProjectError ) {
             kDebug() << "Following Error:" << error << errorString;
             return;
         }
 
         kDebug() << "Error:" << error << errorString;
         state = Project::ProjectError;
         q->emitInformationMessage( errorString, KMessageWidget::Error, -1 );
     };
 
     void connectTab( AbstractTab *tab )
     {
         Q_Q( Project );
         q->connect( tab, SIGNAL(titleChanged(QString)), q, SLOT(slotTabTitleChanged(QString)) );
         q->connect( tab, SIGNAL(modifiedStatusChanged(bool)), q, SLOT(slotModifiedStateChanged()) );
     };
 
     inline QWidget *parentWidget( QWidget *parentToUse = 0 ) const
     {
         Q_Q( const Project );
         return parentToUse ? parentToUse : qobject_cast<QWidget*>(q->parent());
     };
 
     bool isActionEnabled( Project::ProjectAction projectAction ) const
     {
         switch ( projectAction ) {
         case Project::SaveAs:
         case Project::Install:
         case Project::Uninstall:
         case Project::InstallGlobally:
         case Project::UninstallGlobally:
         case Project::Publish:
         case Project::Close:
         case Project::ShowProjectSettings:
         case Project::ShowDashboard:
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         case Project::ShowScript:
         case Project::ShowExternalScript:
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         case Project::ShowGtfsDatabase:
 #endif
         case Project::ShowProjectSource:
         case Project::ShowPlasmaPreview:
             // Always enabled actions
             return true;
 
         case Project::Save:
             // Enable save action only when the project is modified
             return isModified();
 
         case Project::ShowHomepage:
             // Only enable "Open Homepage" action if an URL is available
             return !provider->data()->url().isEmpty();
 
         case Project::SetAsActiveProject:
             // Only enable "Set as Active Project" action if the project isn't already active
             return !isActiveProject();
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         case Project::StepInto:
         case Project::StepOver:
         case Project::StepOut:
         case Project::Continue:
             // Only enabled if the debugger is interrupted
             return debugger->isInterrupted();
 
         case Project::Interrupt:
             // Only enabled if the debugger is running, but not interrupted
             return debugger->state() == Running;
 
         case Project::RunToCursor:
             // Only enabled if the debugger is interrupted or not running
             return debugger->state() != Running &&
                     debugger->scriptState() == Debugger::Debugger::ScriptLoaded;
 
         case Project::AbortDebugger:
             // Only enabled if the debugger is running or interrupted
             return debugger->state() != NotRunning;
 
         case Project::ToggleBreakpoint:
             // Only enabled if a script tab is opened
             return scriptTab;
 
         case Project::RemoveAllBreakpoints:
             // Only enabled if the breakpoint model isn't empty
             return debugger->breakpointModel()->rowCount() > 0;
 #endif
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         case Project::ImportGtfsFeed:
             return gtfsDatabaseState == Project::GtfsDatabaseError ||
                    gtfsDatabaseState == Project::GtfsDatabaseImportPending;
         case Project::UpdateGtfsDatabase:
             return gtfsDatabaseState == Project::GtfsDatabaseUpdateAvailable;
         case Project::DeleteGtfsDatabase:
             return gtfsDatabaseState == Project::GtfsDatabaseImportFinished ||
                    gtfsDatabaseState == Project::GtfsDatabaseUpdateAvailable;
 #endif
 
         case Project::ClearTestResults:
             // Only enabled if there are test results
             // and the debugger and the test are both currently not running
             return !testModel->isEmpty() && !isTestRunning() && !isDebuggerRunning();
 
         case Project::AbortRunningTests:
             // Only enabled if tests are currently running
             return isTestRunning();
 
         case Project::RunAllTests:
         case Project::RunSpecificTest:
         case Project::RunSpecificTestCase:
         case Project::SpecificTestCaseMenuAction:
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         case Project::RunMenuAction:
         case Project::RunGetTimetable:
         case Project::RunGetStopSuggestions:
         case Project::RunGetStopsByGeoPosition:
         case Project::RunGetJourneys:
         case Project::DebugMenuAction:
         case Project::DebugGetTimetable:
         case Project::DebugGetStopSuggestions:
         case Project::DebugGetStopsByGeoPosition:
         case Project::DebugGetJourneys:
             return !isTestRunning() && !isDebuggerRunning() &&
                    (data()->type() != Enums::ScriptedProvider || scriptState != InitializingScript);
 #else
             // Only enabled if the debugger and the test are both currently not running
             return !isTestRunning() && !isDebuggerRunning();
 #endif
 
         default:
             kDebug() << "Unknown project action" << projectAction;
             return false;
         }
     };
 
     // @param autoUpdateEnabledState Set to true, if the enabled state of the action should be
     //   updated in updateProjectActions(). Leave false, if the action is always enabled or if
     //   its enabled state gets updated in another way, eg. by connecting to the
     //   setEnabled()/setDisabled() slots
     void connectProjectAction( Project::ProjectAction actionType, QAction *action,
                                bool doConnect, QObject *receiver, const char *slot,
                                ConnectProjectActionFlags flags = NoConnectionFlags )
     {
         Q_Q( Project );
        if ( doConnect ) {
             action->setEnabled( isActionEnabled(actionType) );
             if ( receiver ) {
                 q->connect( action, SIGNAL(triggered(bool)), receiver, slot,
                             flags.testFlag(UseQueuedConnection)
                             ? Qt::QueuedConnection : Qt::AutoConnection );
             }
             if ( flags.testFlag(ProjectPrivate::AutoUpdateEnabledState) &&
                 !(externProjectActions.contains(actionType) &&
                 externProjectActions.values(actionType).contains(action)) )
             {
                 externProjectActions.insert( actionType, action );
             }
         } else {
             action->setEnabled( false );
             if ( receiver ) {
                 q->disconnect( action, SIGNAL(triggered(bool)), receiver, slot );
             }
             if ( flags.testFlag(ProjectPrivate::AutoUpdateEnabledState) ) {
                 externProjectActions.remove( actionType, action );
             }
         }
     };
 
     // Enable/disable project actions of the given @p actionTypes (also external actions)
     void updateProjectActions( const QList< Project::ProjectAction > &actionTypes )
     {
         foreach ( Project::ProjectAction actionType, actionTypes ) {
             const bool enabled = isActionEnabled( actionType );
             QList< QPointer<QAction> > actions = externProjectActions.values( actionType );
             foreach ( QAction *action, actions ) {
                 if ( action ) {
                     action->setEnabled( enabled );
                 }
             }
         }
     };
 
     inline void updateProjectActions( Project::ProjectActionGroup group,
                                       const QList< Project::ProjectAction > &additionalActionTypes
                                             = QList< Project::ProjectAction >() )
     {
         updateProjectActions(Project::actionsFromGroup(group) << additionalActionTypes);
     };
 
     inline void updateProjectActions( const QList< Project::ProjectActionGroup > &groups,
                                       const QList< Project::ProjectAction > &additionalActionTypes
                                             = QList< Project::ProjectAction >() )
     {
         updateProjectActions(actionsFromGroups(groups) << additionalActionTypes);
     };
 
     QList< Project::ProjectAction > actionsFromGroups(
             const QList<Project::ProjectActionGroup> &groups )
     {
         QList< Project::ProjectAction > actionTypes;
         foreach ( Project::ProjectActionGroup group, groups ) {
             actionTypes << Project::actionsFromGroup( group );
         }
         return actionTypes;
     };
 
     enum ProjectActivationReason {
         ActivateProjectForTests,
         ActivateProjectForDebugging
     };
 
     // Asks if the project should be activated (if disableQuestions is false)
     bool askForProjectActivation( ProjectActivationReason reason )
     {
         Q_Q( Project );
         if ( isActiveProject() || !enableQuestions ) {
             return true;
         }
 
         QString message, dontAskAgainName;
         switch ( reason ) {
         case ActivateProjectForTests:
             message = i18nc("@info", "Test results cannot be seen for non-active projects.<nl />"
                             "Do you want to make this project active now?");
             dontAskAgainName = "make_project_active_for_tests";
             break;
         case ActivateProjectForDebugging:
             message = i18nc("@info", "Docks like <interface>Variables</interface>, "
                             "<interface>Backtrace</interface> or <interface>Output</interface> "
                             "only show data for the active project. Toolbar/menu actions only "
                             "control the active project, but the project context menu can be used "
                             "to eg. control the debugger of an inactive project.<nl />"
                             "Do you want to make this project active now?");
             dontAskAgainName = "make_project_active_for_debugging";
             break;
         default:
-            kWarning() << "Unknown project activation reason";
+            qWarning() << "Unknown project activation reason";
             return false;
         }
 
         const int result = KMessageBox::questionYesNoCancel( parentWidget(),
                 message, i18nc("@title:window", "Activate Project?"), KStandardGuiItem::yes(),
                 KStandardGuiItem::no(), KStandardGuiItem::cancel(), dontAskAgainName );
         if ( result == KMessageBox::Yes ) {
             q->setAsActiveProject();
         } else if ( result == KMessageBox::Cancel ) {
             return false;
         }
         return true;
     };
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     // Call script function @p functionName using @p request in the given @p debugMode
     void callScriptFunction( AbstractRequest *request,
                              Debugger::DebugFlags debugFlags = Debugger::InterruptOnExceptions )
     {
         if ( askForProjectActivation(ActivateProjectForDebugging) ) {
             debugger->requestTimetableData( request, QString(), debugFlags );
         }
     };
 
     // Call script function getTimetable() in the given @p debugMode
     void callGetTimetable( Debugger::DebugFlags debugFlags = Debugger::InterruptOnExceptions )
     {
         Q_Q( Project );
         bool cancelled = false;
         DepartureRequest request = q->getDepartureRequest( parentWidget(), &cancelled );
         if ( !cancelled ) {
             callScriptFunction( &request, debugFlags );
         }
     };
 
     // Call script function getStopSuggestions() in the given @p debugMode
     void callGetStopSuggestions( Debugger::DebugFlags debugFlags = Debugger::InterruptOnExceptions )
     {
         Q_Q( Project );
         bool cancelled = false;
         StopSuggestionRequest request = q->getStopSuggestionRequest( parentWidget(), &cancelled );
         if ( !cancelled ) {
             callScriptFunction( &request, debugFlags );
         }
     };
 
     // Call script function getStopSuggestions() in the given @p debugMode with a geo position
     void callGetStopsByGeoPosition(
             Debugger::DebugFlags debugFlags = Debugger::InterruptOnExceptions )
     {
         Q_Q( Project );
         bool cancelled = false;
         StopsByGeoPositionRequest request =
                 q->getStopsByGeoPositionRequest( parentWidget(), &cancelled );
         if ( !cancelled ) {
             callScriptFunction( &request, debugFlags );
         }
     };
 
     // Call script function getJourneys() in the given @p debugMode
     void callGetJourneys( Debugger::DebugFlags debugFlags = Debugger::InterruptOnExceptions )
     {
         Q_Q( Project );
         bool cancelled = false;
         JourneyRequest request = q->getJourneyRequest( parentWidget(), &cancelled );
         if ( !cancelled ) {
             callScriptFunction( &request, debugFlags );
         }
     };
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
     // Called before testing starts
     bool beginTesting( const QList< TestModel::Test > &tests )
     {
         Q_Q( Project );
         if ( isTestRunning() ) {
             // Test is already running
-            kWarning() << "Test is already running" << data()->id();
+            qWarning() << "Test is already running" << data()->id();
             return true;
         }
 
         DEBUGGER_JOB_SYNCHRONIZATION("Testing begins" << data()->id());
         pendingTests.clear();
         testState = TestsRunning;
         finishedTests.clear();
         startedTests = tests;
         updateProjectActions( QList<Project::ProjectActionGroup>() << Project::TestActionGroup
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                                                                    << Project::RunActionGroup,
                               QList<Project::ProjectAction>() << Project::RunToCursor
 #endif
                             );
 
         // Disable inforamtion messages while testing, results are shown in the test tab
         suppressMessages = true;
 
         q->emit testStarted();
         q->emit testRunningChanged( true );
         q->emit informationMessage( i18nc("@info", "Test started") );
         return true;
     };
 
     // Called after testing has ended
     void endTesting()
     {
         Q_Q( Project );
         if ( !isTestRunning() ) {
             return;
         }
 
         const TestModel::TestState state = testModel->completeState();
         DEBUGGER_JOB_SYNCHRONIZATION("Testing finished" << data()->id());
         pendingTests.clear();
         testState = NoTestRunning;
         updateProjectActions( QList<Project::ProjectActionGroup>() << Project::TestActionGroup
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                                                                    << Project::RunActionGroup,
                               QList<Project::ProjectAction>() << Project::RunToCursor
 #endif
                             );
 
         // Re-enable information messages from the debugger
         suppressMessages = false;
 
         switch ( state ) {
         case TestModel::TestFinishedSuccessfully:
             q->emit informationMessage( i18nc("@info", "Test of %1 finished successfully",
                                               data()->id()),
                     KMessageWidget::Positive, 4000, QString(), QString(),
                     QList<QAction*>() << q->projectAction(Project::ShowPlasmaPreview) );
             break;
         case TestModel::TestFinishedWithErrors:
             q->emit informationMessage( i18nc("@info", "Test of %1 finished with errors",
                                               data()->id()),
                                         KMessageWidget::Error, 4000 );
             break;
         case TestModel::TestFinishedWithWarnings:
             q->emit informationMessage( i18nc("@info", "Test of %1 finished with warnings",
                                               data()->id()),
                                         KMessageWidget::Warning, 4000 );
             break;
         case TestModel::TestCouldNotBeStarted:
             q->emit informationMessage( i18nc("@info", "Test of %1 could not be started",
                                               data()->id()),
                                         KMessageWidget::Error, 4000 );
             break;
         case TestModel::TestAborted:
             q->emit informationMessage( i18nc("@info", "Test of %1 was aborted", data()->id()),
                                         KMessageWidget::Error, 4000 );
             break;
         case TestModel::TestCaseNotFinished:
             q->emit informationMessage( i18nc("@info", "Test of %1 case not finished",
                                               data()->id()),
                                         KMessageWidget::Information, 4000 );
             break;
         default:
-            kWarning() << "Unexpected test state" << state;
+            qWarning() << "Unexpected test state" << state;
             break;
         }
         q->emit testRunningChanged( false );
         q->emit testFinished( state == TestModel::TestFinishedSuccessfully );
 
         finishedTests.clear();
         startedTests.clear();
     };
 
     // Cancels all running/pending tests
     void abortTests()
     {
         Q_Q( Project );
         if ( !isTestRunning() ) {
             return;
         }
 
         testState = TestsGetAborted;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         DEBUGGER_JOB_SYNCHRONIZATION("Abort tests" << data()->id());
         for ( QHash<TestModel::Test, ThreadWeaver::Job*>::ConstIterator it = pendingTests.constBegin();
               it != pendingTests.constEnd(); ++it )
         {
             if ( !debugger->weaver()->dequeue(*it) ) {
                 (*it)->requestAbort();
             }
         }
 
         debugger->abortDebugger();
         debugger->finish();
 #endif
         QList< TestModel::Test >::ConstIterator it = dependendTests.constBegin();
         while ( it != dependendTests.constEnd() ) {
             testModel->setTestState( *it,
                     TestModel::TestAborted,
                     i18nc("@info/plain", "Test was aborted"),
                     i18nc("@info", "<title>Test was aborted</title> "
                         "<para>The test was aborted while it was running, no results available.</para>"),
                     q->projectAction(Project::ShowProjectSettings) );
             ++it;
         }
         dependendTests.clear();
 
         endTesting();
     };
 
     bool testForCoordinatesSampleData()
     {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         Q_Q( Project );
         const ServiceProviderData *data = provider->data();
         if ( !data->hasSampleCoordinates() ) {
             testModel->setTestState( TestModel::StopsByGeoPositionTest,
                     TestModel::TestCouldNotBeStarted,
                     i18nc("@info/plain", "Missing sample coordinates"),
                     i18nc("@info", "<title>Missing sample stop coordinates</title> "
                         "<para>Cannot run script execution tests for stops by geo "
                         "position. Open the project settings and add one or more "
                         "<interface>Sample Stop Coordinates</interface></para>"),
                     q->projectAction(Project::ShowProjectSettings) );
             testFinished( TestModel::StopsByGeoPositionTest );
             return false;
         }
 #endif
 
         return true;
     };
 
     bool testForSampleData()
     {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         Q_Q( Project );
         const ServiceProviderData *data = provider->data();
         QList< TestModel::Test > tests = QList< TestModel::Test >() << TestModel::DepartureTest
                 << TestModel::ArrivalTest << TestModel::StopSuggestionTest;
         if ( data->sampleStopNames().isEmpty() ) {
             foreach ( TestModel::Test test, tests ) {
                 testModel->setTestState( test, TestModel::TestCouldNotBeStarted,
                         i18nc("@info/plain", "Missing sample stop name"),
                         i18nc("@info", "<title>Missing sample stop name</title> "
                               "<para>Cannot run the test without sample data. Open the project "
                               "settings and add one or more <interface>Sample Stop Names</interface>"
                               "</para>"),
                         q->projectAction(Project::ShowProjectSettings) );
             }
             return false;
         } else if ( data->useSeparateCityValue() && data->sampleCity().isEmpty() ) {
             foreach ( TestModel::Test test, tests ) {
                 testModel->setTestState( test, TestModel::TestCouldNotBeStarted,
                     i18nc("@info/plain", "Missing sample city"),
                     i18nc("@info", "<title>Missing sample city</title> "
                           "<para>Cannot run the test without sample data. Open the project "
                           "settings and add a <interface>Sample City</interface></para>"),
                     q->projectAction(Project::ShowProjectSettings) );
             }
             return false;
         }
 #endif
 
         return true;
     };
 
     bool testForJourneySampleData()
     {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         Q_Q( Project );
         const ServiceProviderData *data = provider->data();
         if ( data->sampleStopNames().count() < 2 ) {
             testModel->setTestState( TestModel::JourneyTest, TestModel::TestCouldNotBeStarted,
                     i18nc("@info/plain", "To test journeys at least two sample stop names are needed"),
                     i18nc("@info", "<title>To test journeys at least two sample stop names are needed</title> "
                         "<para>Cannot run journey test. Open the project settings and add "
                         "another stop name to the <interface>Sample Stop Names</interface></para>"),
                     q->projectAction(Project::ShowProjectSettings) );
             testFinished( TestModel::JourneyTest );
             return false;
         }
 #endif
 
         return true;
     };
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     bool startScriptExecutionTest( TestModel::Test test )
     {
         Q_Q( Project );
         if ( pendingTests.contains(test) ) {
             // Test was already enqueued
             return true;
         }
 
         // Check that the test is applicable for the type of the provider to test
         QString errorMessage, tooltip;
         if ( !TestModel::isTestApplicableTo(test, data(), &errorMessage, &tooltip) ) {
             testModel->setTestState( test, TestModel::TestNotApplicable, errorMessage, tooltip );
             testFinished( test );
             return false;
         }
 
         // Check that required tests are finished successfully
         const QList< TestModel::Test > requiredTests = TestModel::testIsDependedOf( test );
         for ( int i = 0; i < requiredTests.count(); ++i ) {
             TestModel::Test requiredTest = requiredTests[ i ];
             if ( !testModel->isTestFinished(requiredTest) ) {
                 // A required test is not finished, add it to the dependend test list
                 // and start it when all required tests are done
                 dependendTests << test;
 
                 // Required test is not finished
                 testModel->setTestState( test, TestModel::TestDelegated,
                         i18nc("@info/plain", "Waiting for required test \"%1\"",
                               TestModel::nameForTest(requiredTest)),
                         QString(), q->projectAction(Project::ShowScript) );
 
                 // Start all unfinished required tests, if not planned already
                 QList< TestModel::Test > unfinishedRequiredTests;
                 for ( int n = i; n < requiredTests.count(); ++n ) {
                     TestModel::Test unfinishedRequiredTest = requiredTests[ n ];
                     if ( !testModel->isTestFinished(requiredTest) &&
                          !startedTests.contains(requiredTest) )
                     {
                         unfinishedRequiredTests << unfinishedRequiredTest;
                     }
                 }
                 startTests( unfinishedRequiredTests );
                 return true;
             } else if ( testModel->testState(requiredTest) == TestModel::TestFinishedWithErrors ) {
                 // Required test is finished, but was unsuccessful
                 testModel->setTestState( test, TestModel::TestCouldNotBeStarted,
                         i18nc("@info/plain", "Required test \"%1\" was not successful",
                               TestModel::nameForTest(requiredTest)),
                         i18nc("@info", "<title>Dependency not met</title> "
                               "<para>This test depends on the \"%1\" test, but it was not "
                               "successful.</para>", TestModel::nameForTest(requiredTest)),
                         q->projectAction(Project::ShowScript) );
                 testFinished( test );
                 return false;
             }
         }
 
         // Test if enough sample data is available
         // and get the name of the script function to run
         QString function, message, shortMessage;
         quint8 testSampleData = 0; // 1 => testForSampleData(), 2 => testForJourneySampleData(),
                                    // 3 => testForCoordinatesSampleData()
         switch ( test ) {
         case TestModel::DepartureTest:
         case TestModel::ArrivalTest:
             if ( test == TestModel::ArrivalTest ) {
                 if ( !isTestFinishedOrPending(TestModel::FeaturesTest) ) {
-                    kWarning() << "First start the features test";
+                    qWarning() << "First start the features test";
                     return false;
                 }
                 if ( !hasFeature(test, Enums::ProvidesArrivals) ) {
                     testFinished( test );
                     return false;
                 }
             }
             testSampleData = 1;
             function = ServiceProviderScript::SCRIPT_FUNCTION_GETTIMETABLE;
             shortMessage = i18nc("@info/plain", "You need to implement a '%1' script function", function);
             message = i18nc("@info", "<title>You need to implement a '%1' script function</title> "
                             "<para>Service provider plugins that only support journeys are "
                             "currently not accepted by the data engine, but that may change."
                             "</para>", function);
             break;
         case TestModel::AdditionalDataTest: {
             if ( !isTestFinishedOrPending(TestModel::DepartureTest) ) {
-                kWarning() << "First start the departure test";
+                qWarning() << "First start the departure test";
                 return false;
             }
 
             const QList< TimetableData > results =
                     testModel->testResults( TestModel::DepartureTest );
             if ( results.isEmpty() ) {
                 testModel->setTestState( test, TestModel::TestCouldNotBeStarted,
                         i18nc("@info/plain", "No results in departure test") );
                 testFinished( test );
                 return false;
             }
 
             testSampleData = 1;
             function = ServiceProviderScript::SCRIPT_FUNCTION_GETADDITIONALDATA;
             shortMessage = i18nc("@info/plain", "'%1' script function not implemented", function);
             message = i18nc("@info", "<title>You can implement a '%1' script function</title> "
                             "<para>This can be used to load additional data for single departures "
                             "or arrivals.</para>", function);
             break;
         }
         case TestModel::StopSuggestionTest:
         case TestModel::StopsByGeoPositionTest:
             if ( test == TestModel::StopsByGeoPositionTest ) {
                 if ( !isTestFinishedOrPending(TestModel::FeaturesTest) ) {
-                    kWarning() << "First start the features test";
+                    qWarning() << "First start the features test";
                     return false;
                 }
                 if ( !hasFeature(test, Enums::ProvidesStopsByGeoPosition) ) {
                     testFinished( test );
                     return false;
                 }
             }
             testSampleData = test == TestModel::StopSuggestionTest ? 1 : 3;
             function = ServiceProviderScript::SCRIPT_FUNCTION_GETSTOPSUGGESTIONS;
             shortMessage = i18nc("@info/plain", "You need to implement a '%1' script function", function);
             message = i18nc("@info", "<title>You need to implement a '%1' script function</title> "
                             "<para>Without stop suggestions it can be very hard for users to find a "
                             "valid stop name. Therefore this function is needed.</para>", function);
             break;
         case TestModel::JourneyTest:
             testSampleData = 2;
             function = ServiceProviderScript::SCRIPT_FUNCTION_GETJOURNEYS;
             shortMessage = i18nc("@info/plain", "For journeys, you need to implement a '%1' script function", function);
             message = i18nc("@info", "<title>For journeys, you need to implement a '%1' script function</title> "
                             "<para>If you do not implement the function, journeys will not work with "
                             "the plugin.</para>", function);
             break;
         case TestModel::FeaturesTest:
             function = ServiceProviderScript::SCRIPT_FUNCTION_FEATURES;
             shortMessage = i18nc("@info/plain", "You should implement a '%1' script function", function);
             message = i18nc("@info", "<title>You should implement a '%1' script function</title> "
                             "<para>This function is used to know what information the plugin parses "
                             "from documents. Without adding the appropriate TimetableInformation names "
                             "to the return value of this function, the associated data will be unused "
                             "or associated features will be disabled.</para>"
                             "<para>If, for example, the script can parse Arrivals, 'Arrivals' should "
                             "be added to the return value. If the script parses route stops or "
                             "stop IDs, add 'RouteStops' or 'StopID' to the return value, etc.</para>",
                             function);
             break;
         case TestModel::LoadScriptTest:
             break;
         default:
-            kWarning() << "Invalid test" << test;
+            qWarning() << "Invalid test" << test;
             testFinished( test );
             return false;
         }
 
         // Check if the function that should be run is implemented in the script
         const QStringList functions = q->scriptFunctions();
         const bool hasRequiredFunction = function.isEmpty() || functions.contains(function);
         if ( !hasRequiredFunction ) {
             // Function is not implemented
             TestModel::TestState state = test == TestModel::DepartureTest
                     ? TestModel::TestCouldNotBeStarted : TestModel::TestDisabled;
             testModel->setTestState( test, state, shortMessage, message,
                                      q->projectAction(Project::ShowScript) );
             testFinished( test );
             return false;
         } else {
             switch ( testSampleData ) {
             case 1:
                 if ( !testForSampleData() ) {
                     testFinished( test );
                     return false;
                 }
                 break;
             case 2:
                 if ( !testForJourneySampleData() ) {
                     testFinished( test );
                     return false;
                 }
                 break;
             case 3:
                 if ( !testForCoordinatesSampleData() ) {
                     testFinished( test );
                     return false;
                 }
                 break;
             case 0:
             default:
                 break;
             }
 
             // Create job, QPointer for LoadScriptJob
             QPointer<DebuggerJob> job;
             if ( test == TestModel::LoadScriptTest ) {
                 job = debugger->getLoadScriptJob( q->scriptText(), data() );
                 if ( !job ) {
                     // LoadScriptJob already finished and the script was not changed
                     lastScriptError = debugger->lastScriptError();
                     lastScriptErrorString = debugger->lastScriptErrorString();
                     if ( lastScriptError == Debugger::NoScriptError ) {
                         testModel->setTestState( test, TestModel::TestFinishedSuccessfully,
                                                  i18nc("@info/plain", "Script successfully loaded") );
                     } else {
                         testModel->setTestState( test, TestModel::TestFinishedWithErrors,
                                                  lastScriptErrorString );
                     }
                     testFinished( test );
                     return lastScriptError == Debugger::NoScriptError;
                 } else if ( debugger->isLoadScriptJobRunning() && !job->isFinished() ) {
                     // A LoadScriptJob has already been started
                     job->setObjectName( "TEST_LOAD" );
 
                     // The started signal of the LoadScriptJob was already sent, update test model
                     pendingTests.insert( test, job );
                     job->setUseCase( TestModel::nameForTest(test) );
                     q->testJobStarted( test, job->type(), job->useCase() );
                     return true;
                 } else {
                     // New LoadScriptJob was created, the script was changed since the last
                     // LoadScriptJob or none has been started yet
                     job->setObjectName( "TEST_LOAD" );
                 }
             } else if ( test == TestModel::FeaturesTest ) {
                 job = debugger->createTestFeaturesJob( QString(), NeverInterrupt );
                 job->setObjectName( "TEST_FEATURES" );
             } else {
                 // The number of items to request for testing, lower values mean higher performance,
                 // higher values can mean better test results, eg. showing rare errors
                 const int testItemCount = 30;
 
                 // Create request object
                 AbstractRequest *request = 0;
                 switch ( test ) {
                 case TestModel::DepartureTest:
                     request = new DepartureRequest( "TEST_DEPARTURES",
                             data()->sampleStopNames().first(), QString(),
                             QDateTime::currentDateTime(), testItemCount, data()->sampleCity() );
                     break;
                 case TestModel::ArrivalTest: {
                     request = new ArrivalRequest( "TEST_ARRIVALS",
                             data()->sampleStopNames().first(), QString(),
                             QDateTime::currentDateTime(), testItemCount, data()->sampleCity() );
                     break;
                 }
                 case TestModel::AdditionalDataTest: {
                     const QList< TimetableData > results =
                             testModel->testResults( TestModel::DepartureTest );
                     QSharedPointer< AbstractTimetableItemRequest > departureRequest =
                                 testModel->testRequest( TestModel::DepartureTest )
                                 .dynamicCast< AbstractTimetableItemRequest >();
                     Q_ASSERT( departureRequest );
                     const TimetableData result = results.first();
                     request = new AdditionalDataRequest( "TEST_ADDITIONAL_DATA",
                             0, departureRequest->stop(), QString(),
                             result[Enums::DepartureDateTime].toDateTime(),
                             result[Enums::TransportLine].toString(),
                             result[Enums::Target].toString(),
                             departureRequest->city(), result[Enums::RouteDataUrl].toString() );
                 }   break;
                 case TestModel::StopSuggestionTest:
                     request = new StopSuggestionRequest( "TEST_STOP_SUGGESTIONS",
                             data()->sampleStopNames().first().left(4), testItemCount,
                             data()->sampleCity() );
                     break;
                 case TestModel::StopsByGeoPositionTest:
                     request = new StopsByGeoPositionRequest(
                             "TEST_STOP_SUGGESTIONS_BYGEOPOSITION",
                             data()->sampleLongitude(), data()->sampleLatitude(), testItemCount );
                     break;
                 case TestModel::JourneyTest:
                     request = new JourneyRequest( "TEST_JOURNEYS",
                             data()->sampleStopNames().first(), QString(),
                             data()->sampleStopNames()[1], QString(),
                             QDateTime::currentDateTime(), testItemCount, QString(),
                             data()->sampleCity() );
                     break;
                 default:
-                    kWarning() << "Invalid test" << test;
+                    qWarning() << "Invalid test" << test;
                     testFinished( test );
                     return false;
                 }
 
                 // Create job
                 job = debugger->createTimetableDataRequestJob( request, QString(), NeverInterrupt );
                 job->setObjectName( request->sourceName() );
                 delete request;
             }
 
             Q_ASSERT( job );
             job->setUseCase( TestModel::nameForTest(test) );
 
             // Try to enqueue the job
             if ( !debugger->enqueueJob(job) ) {
                 // The job could not be enqueued
                 delete job;
                 testModel->markTestCaseAsUnstartable( TestModel::ScriptExecutionTestCase );
                 endTesting();
                 return false;
             } else {
                 // The job was successfully enqueued
                 pendingTests.insert( test, job );
                 return true;
             }
         }
     };
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     bool startGtfsTest( TestModel::Test test )
     {
         Q_Q( Project );
 
         QString errorMessage, tooltip;
         if ( !TestModel::isTestApplicableTo(test, data(), &errorMessage, &tooltip) ) {
             testModel->setTestState( test, TestModel::TestNotApplicable, errorMessage, tooltip );
             testFinished( test );
             return false;
         }
 
         testModel->markTestAsStarted( test );
         qApp->processEvents();
 
         switch ( test ) {
         case TestModel::GtfsFeedExistsTest:
         case TestModel::GtfsRealtimeAlertsTest:
         case TestModel::GtfsRealtimeUpdatesTest: {
             QEventLoop loop;
             QString url;
             if ( test == TestModel::GtfsFeedExistsTest ) {
                 url = data()->feedUrl();
             } else if ( test == TestModel::GtfsRealtimeUpdatesTest ) {
                 url = data()->realtimeTripUpdateUrl();
             } else if ( test == TestModel::GtfsRealtimeAlertsTest ) {
                 url = data()->realtimeAlertsUrl();
             }
 
             if ( url.isEmpty() ) {
                 if ( test == TestModel::GtfsFeedExistsTest ) {
                     testModel->setTestState( test, TestModel::TestFinishedWithErrors,
                                              i18nc("@info/plain", "No GTFS feed URL given") );
                     testFinished( test );
                     return false;
                 }
 
                 // GTFS-realtime URL(s) not given, but not required
                 testModel->setTestState( test, TestModel::TestDisabled,
                                          i18nc("@info/plain", "Not used") );
                 testFinished( test );
                 return true;
             }
 
             LinkChecker checker( url );
             q->connect( &checker, SIGNAL(finished(QDateTime,qulonglong,Error,QString)),
                         &loop, SLOT(quit()) );
             checker.start();
             loop.exec();
 
             if ( checker.hasError() ) {
                 testModel->setTestState( test, TestModel::TestFinishedWithErrors,
                                          checker.errorString() );
                 return false;
             }
 
             QList< TimetableDataRequestMessage > childrenExplanations;
             if ( !checker.redirectedUrl().isEmpty() ) {
                 childrenExplanations << TimetableDataRequestMessage(
                         i18nc("@info/plain", "Redirected to: <link>%1</link>",
                               checker.redirectedUrl()) );
             }
             childrenExplanations << TimetableDataRequestMessage(
                     i18nc("@info/plain", "Size: %1",
                           KGlobal::locale()->formatByteSize(checker.size())) );
             if ( checker.lastModificationTime().isValid() ) {
                 childrenExplanations << TimetableDataRequestMessage(
                         i18nc("@info/plain", "Modified: %1",
                               KGlobal::locale()->formatDateTime(checker.lastModificationTime(),
                                                                 KLocale::FancyShortDate)) );
             }
             testModel->setTestState( test, TestModel::TestFinishedSuccessfully,
                                      QString(), QString(), 0, childrenExplanations );
             testFinished( test );
             return true;
         }
 
         default:
-            kWarning() << "Unknown GTFS test" << test;
+            qWarning() << "Unknown GTFS test" << test;
             return false;
         }
     };
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
     void startTests( const QList< TestModel::Test > &tests )
     {
         foreach ( TestModel::Test test, tests ) {
             startTest( test );
             if ( testState == ProjectPrivate::TestsGetAborted ) {
                 break;
             }
         }
     };
 
     bool startTest( TestModel::Test test )
     {
         bool finishedAfterThisTest = false;
         if ( !isTestRunning() ) {
             if ( !beginTesting(QList<TestModel::Test>() << test) ) {
                 // Test could not be started
                 return false;
             }
 
             // Test started, only running one test
             finishedAfterThisTest = true;
         }
 
         bool success;
         const TestModel::TestCase testCase = TestModel::testCaseOfTest( test );
         bool testIsAsynchronous = false;
         switch ( testCase ) {
         case TestModel::ServiceProviderDataTestCase: {
             testModel->markTestAsStarted( test );
             QString errorMessage, tooltip;
             QList< TimetableDataRequestMessage > childrenExplanations;
             TestModel::TestState state = ServiceProviderDataTester::runServiceProviderDataTest(
                     test, provider->data(), &errorMessage, &tooltip, &childrenExplanations );
             success = state == TestModel::TestFinishedSuccessfully ? true : false;
             testModel->setTestState( test, state, errorMessage, tooltip, 0, childrenExplanations );
             testFinished( test );
         } break;
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         case TestModel::GtfsTestCase:
             success = startGtfsTest( test );
             break;
 #endif
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         case TestModel::ScriptExecutionTestCase:
             success = startScriptExecutionTest( test );
             testIsAsynchronous = true;
             break;
 #endif
 
         default:
-            kWarning() << "Unknown test" << test;
+            qWarning() << "Unknown test" << test;
             success = false;
             break;
         }
 
         if ( finishedAfterThisTest && !testIsAsynchronous ) {
             endTesting();
         } else if ( !success ) {
             // Test could not be started
             startTests( takeStartableDependentTests(test) );
         }
 
         return success;
     };
 
     bool save( QWidget *parent, const QString &xmlFilePath,
                Project::InstallType installType = Project::NoInstallation )
     {
         Q_Q( Project );
         parent = parentWidget( parent );
         const QString _filePath = xmlFilePath.isEmpty() ? filePath : xmlFilePath;
         if ( _filePath.isEmpty() ) {
             return q->saveAs( parent );
         }
 
         // Save the project
         kDebug() << "Save to" << _filePath;
         if ( !writeProjectSourceDocument(_filePath) ) {
             return false;
         }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         // Save script file, if any
         // Only save if the script was modified or if it should be saved somewhere else
         if ( data()->type() == Enums::ScriptedProvider ) {
             QString scriptFile = QFileInfo( provider->data()->scriptFileName() ).fileName();
             const QString savedScriptFile =
                     QFileInfo(filePath).absolutePath() + '/' + scriptFile;
             const QString targetScriptFile =
                     QFileInfo(_filePath).absolutePath() + '/' + scriptFile;
             if ( !scriptFile.isEmpty() &&
                 (isScriptModified() || targetScriptFile != savedScriptFile) )
             {
                 kDebug() << "Save script to" << targetScriptFile;
                 QFile file( targetScriptFile );
                 if ( !file.open(QIODevice::WriteOnly) ) {
                     q->emit informationMessage( i18nc("@info", "Could not write the script file to "
                                                     "<filename>%1</filename>: <message>%2</message>",
                                                     targetScriptFile, file.errorString() ),
                                                 KMessageWidget::Error );
                     return false;
                 }
 
                 file.write( q->scriptText().toUtf8() );
                 file.close();
             }
 
             foreach ( ScriptTab *tab, externalScriptTabs ) {
                 tab->save();
             }
         }
 #endif
 
         if ( installType == Project::NoInstallation ) {
             const bool wasModified = isModified();
             const bool wasProjectSourceModified = isProjectSourceModified();
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             const bool wasScriptModified = isScriptModified();
             unsavedScriptContents.clear();
 #endif
 
             projectSourceBufferModified = false;
             updateProjectActions( QList<Project::ProjectAction>() << Project::Save );
             setXmlFilePath( _filePath );
 
             if ( projectSourceTab ) {
                 projectSourceTab->document()->setModified( false );
             }
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             if ( scriptTab ) {
                 scriptTab->document()->setModified( false );
             }
 #endif
             if ( wasModified ) {
                 q->emit modifiedStateChanged( false );
                 if ( wasProjectSourceModified ) {
                     q->emit projectSourceModifiedStateChanged( false );
                 }
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                 if ( wasScriptModified ) {
                     q->emit scriptModifiedStateChanged( false );
                 }
 #endif
             }
         }
         return true;
     };
 
     bool saveAs( QWidget *parent )
     {
         parent = parentWidget( parent );
         KFileDialog saveDialog( filePath.isEmpty() ? KGlobalSettings::documentPath() : filePath,
                                 QString(), parent );
         saveDialog.setOperationMode( KFileDialog::Saving );
         saveDialog.setWindowTitle( i18nc("@title:window", "Save Project") );
         saveDialog.setMimeFilter( QStringList() << "application/x-publictransport-serviceprovider"
                                                 << "application/xml",
                                   "application/x-publictransport-serviceprovider" );
         if ( saveDialog.exec() != KFileDialog::Accepted || saveDialog.selectedFile().isEmpty() ) {
             return false; // Cancel clicked
         }
 
         // Got a file name, save the project
         return save( parent, saveDialog.selectedFile() );
     };
 
     bool install( QWidget *parent, bool install, Project::InstallType installType )
     {
         Q_Q( Project );
         const QString xmlFileName = provider->data()->id() + ".pts";
         if ( installType == Project::LocalInstallation ) {
             // Local installation, find a writable location for Public Transport engine plugins
             const QString saveDir = KGlobal::dirs()->saveLocation( "data",
                     ServiceProviderGlobal::installationSubDirectory() );
             const QString savePath = saveDir + xmlFileName;
 
             if ( install ) {
                 // Install by saving into the found writable location
                 if ( save(parent, savePath, installType) ) {
                     // Installation successful
                     q->emit informationMessage( i18nc("@info", "Project successfully installed locally"),
                                                 KMessageWidget::Positive );
                     q->emit savePathInfoStringChanged( savePathInfoString() );
                     q->emit localInstallationStateChanged( true );
                 } else {
                     // Could not install
                     q->emit informationMessage( i18nc("@info", "Project could not be installed locally "
                                                       "as <filename>%1</filename>", savePath),
                                                 KMessageWidget::Error, 10000 );
                     return false;
                 }
             } else if ( QFile::exists(savePath) ) {
                 // Uninstall by deleting the project files from the found writable location
                 const QString scriptSavePath = saveDir + '/' + QFileInfo(q->scriptFileName()).fileName();
                 if ( QFile::exists(scriptSavePath) && !QFile::remove(scriptSavePath) ) {
                     // Could not uninstall script file
                     q->emit informationMessage( i18nc("@info", "Project could not be uninstalled locally, "
                                                       "file <filename>%1</filename>", scriptSavePath),
                                                 KMessageWidget::Error, 10000 );
                     return false;
                 } else if ( !QFile::remove(savePath) ) {
                     // Could not uninstall project XML file
                     q->emit informationMessage( i18nc("@info", "Project could not be uninstalled locally, "
                                                       "file <filename>%1</filename>", saveDir),
                                                 KMessageWidget::Error, 10000 );
                     return false;
                 } else {
                     // Uninstallation successful
                     q->emit informationMessage( i18nc("@info", "Project successfully uninstalled locally"),
                                                 KMessageWidget::Positive );
                     if ( filePath == savePath ) {
                         // The project was opened from a local install path, which was just deleted
                         setXmlFilePath( QString() );
                     } else {
                         q->emit savePathInfoStringChanged( savePathInfoString() );
                     }
                     q->emit localInstallationStateChanged( false );
                 }
             } else {
                 q->emit informationMessage( i18nc("@info", "Project is not installed locally"),
                                             KMessageWidget::Information );
             }
         } else if ( installType == Project::GlobalInstallation ) {
             // Global insallation, find all directories for Public Transport engine plugins
             const QStringList saveDirs = KGlobal::dirs()->findDirs( "data",
                     ServiceProviderGlobal::installationSubDirectory() );
             if ( saveDirs.isEmpty() ) {
                 kDebug() << "No save directory found. Is the PublicTransport data engine installed?";
                 return false;
             }
 
             // Use the most global directory (see KStandardDirs::findDirs()
             const QString saveDir = saveDirs.last();
             const QString savePath = saveDir + '/' + xmlFileName;
 
             // Use KAuth for installation
             KAuth::Action action( "org.kde.timetablemate.install" );
             action.setHelperID( "org.kde.timetablemate" );
             QVariantMap args;
             args["path"] = saveDir;
             args["operation"] = install ? "install" : "uninstall";
             args["filenameProvider"] = xmlFileName;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             args["filenameScript"] = provider->data()->scriptFileName();
 #endif
             if ( install ) {
                 args["contentsProvider"] = q->projectSourceText();
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                 args["contentsScript"] = q->scriptText();
 #endif
             }
             action.setArguments( args );
             KAuth::ActionReply reply = action.execute();
 
             // Check if the installation was successful
             if ( reply.failed() ) {
                 kDebug() << reply.type() << reply.data();
                 kDebug() << reply.errorCode() << reply.errorDescription();
                 if ( reply.type() == KAuth::ActionReply::HelperError ) {
                     KMessageBox::error( parent,
                             install ? i18nc("@info", "Service provider plugin could not be installed globally "
                                             "in <filename>%1</filename>: %2 <message>%3</message>",
                                             saveDir, reply.errorCode(), reply.errorDescription())
                                     : i18nc("@info", "Service provider plugin could not be uninstalled globally "
                                             "from <filename>%1</filename>: %2 <message>%3</message>",
                                             saveDir, reply.errorCode(), reply.errorDescription()) );
                 } else {
                     switch ( reply.errorCode() ) {
                     case KAuth::ActionReply::UserCancelled:
                     case KAuth::ActionReply::AuthorizationDenied:
                         // Do nothing
                         break;
 
                     case KAuth::ActionReply::NoSuchAction:
                         KMessageBox::error( parent, i18nc("@info", "Could not find the authentication "
                                 "action. If you just installed TimetableMate, you might need to "
                                 "restart D-Bus.") );
                         break;
 
                     case KAuth::ActionReply::HelperBusy:
                         KMessageBox::error( parent, i18nc("@info", "The action is currently being "
                                 "performed. Please try again later.") );
                         break;
 
                     default:
                         KMessageBox::error( parent, i18nc("@info", "Unable to authenticate the action: "
                                 "%1 <message>%2</message>", reply.errorCode(), reply.errorDescription()) );
                         break;
                     }
                 }
                 return false;
             } else if ( install ) {
                 // Installation successful
                 q->emit informationMessage( i18nc("@info", "Service provider plugin successfully installed globally"),
                                             KMessageWidget::Positive );
                 q->emit savePathInfoStringChanged( savePathInfoString() );
                 q->emit globalInstallationStateChanged( true );
             } else {
                 // Uninstallation successful
                 q->emit informationMessage( i18nc("@info", "Service provider plugin successfully uninstalled globally"),
                                             KMessageWidget::Positive );
                 if ( xmlFileName == savePath ) {
                     // The project was opened from a global install path, which was just deleted
                     setXmlFilePath( QString() );
                 } else {
                     q->emit savePathInfoStringChanged( savePathInfoString() );
                 }
                 q->emit globalInstallationStateChanged( false );
             }
         } else {
             kDebug() << "Install type not implemented:" << installType;
             return false;
         }
 
         return true;
     };
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     // Get the currently shown script tab, if any.
     // Otherwise any of the currently opened script tabs gets returned.
     ScriptTab *currentScriptTab()
     {
         // First try to find an active tab
         if ( scriptTab && scriptTab->isVisible() ) {
             return scriptTab;
         }
         foreach ( ScriptTab *tab, externalScriptTabs ) {
             if ( tab->isVisible() ) {
                 return tab;
             }
         }
 
         // No active script tab, find any script tab
         if ( scriptTab ) {
             return scriptTab;
         } else if ( !externalScriptTabs.isEmpty() ) {
             return externalScriptTabs.first();
         } else {
             return 0;
         }
     };
 #endif
 
     // Check if the features test result contains all given features,
     // and add error test results for the given test if a feature is not available
     bool hasFeatures( TestModel::Test test, const QList< Enums::ProviderFeature > &features ) {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         Q_Q( Project );
         const QList< TimetableData > featuresResults =
                 testModel->testResults( TestModel::FeaturesTest );
         if ( featuresResults.isEmpty() ) {
-            kWarning() << "No results in features test";
+            qWarning() << "No results in features test";
             QStringList featureStrings;
             foreach ( Enums::ProviderFeature feature, features ) {
                 featureStrings << Enums::toString( feature );
             }
             testModel->setTestState( test, TestModel::TestFinishedWithWarnings,
                     i18nc("@info/plain", "Feature function needed"),
                     i18nc("@info", "<title>Feature function needed</title> "
                     "<para>The <icode>features()</icode> function is needed to indicate support "
                     "for this test. It should return at least these features for this test to run: "
                     "%1.</para>", featureStrings.join(", ")),
                     q->projectAction(Project::ShowScript) );
             return false;
         }
 
         // Read features from the test result
         // and remove available features from the list of features to check
         QList< Enums::ProviderFeature > featuresToCheck = features;
         const QVariantList featuresList =
                 featuresResults.first()[Enums::Nothing].toList();
         foreach ( const QVariant &featureVariant, featuresList ) {
             const Enums::ProviderFeature feature =
                     static_cast< Enums::ProviderFeature >( featureVariant.toInt() );
             if ( featuresToCheck.removeOne(feature) && featuresToCheck.isEmpty() ) {
                 break;
             }
         }
 
         // Remaining features are not available
         if ( !featuresToCheck.isEmpty() ) {
             const Enums::ProviderFeature feature = featuresToCheck.first();
             testModel->setTestState( test, TestModel::TestDisabled,
                     i18nc("@info/plain", "Feature \"%1\" not supported", Enums::toString(feature)),
                     i18nc("@info", "<title>Feature \"%1\" not supported</title> "
                     "<para>The <icode>features()</icode> function did not return "
                     "<icode>PublicTransport.%1</icode>.</para>", Enums::toString(feature)),
                     q->projectAction(Project::ShowScript) );
             return false;
         }
 
         return true;
 #else
         Q_UNUSED( test );
         Q_UNUSED( features );
         return false;
 #endif
     };
 
     inline bool hasFeature( TestModel::Test test, Enums::ProviderFeature feature ) {
         return hasFeatures( test, QList<Enums::ProviderFeature>() << feature );
     };
 
     bool isTestFinishedOrPending( TestModel::Test test ) const {
         return testModel->isTestFinished(test) || // Test is finished
                testModel->testState(test) == TestModel::TestIsRunning || // Test is running
                pendingTests.contains(test); // Test waits to be started
     };
 
     QList< TestModel::Test > takeStartableDependentTests(
             TestModel::Test finishedTest = TestModel::InvalidTest )
     {
         QList< TestModel::Test > tests;
         QList<TestModel::Test>::Iterator it = dependendTests.begin();
         while ( it != dependendTests.end() ) {
             const QList< TestModel::Test > requiredTests = TestModel::testIsDependedOf( *it );
             if ( requiredTests.contains(finishedTest) ) {
                 // A required test was finished
                 bool allFinished = true;
                 foreach ( TestModel::Test requiredTest, requiredTests ) {
                     if ( !testModel->isTestFinished(requiredTest) && finishedTest != requiredTest ) {
                         // A required test in the list is not finished
                         // and it's not the job that has just finished
                         allFinished = false;
                         break;
                     }
                 }
                 if ( allFinished ) {
                     tests << *it;
                     it = dependendTests.erase( it );
                     continue;
                 }
             }
             ++it;
         }
         if ( !tests.isEmpty() ) {
             DEBUGGER_JOB_SYNCHRONIZATION("All requirements for tests" << tests
                                          << "are finished with test" << finishedTest << data()->id());
         }
         return tests;
     };
 
     void testFinished( TestModel::Test test )
     {
         Q_Q( Project );
         if ( finishedTests.contains(test) ) {
             // Test already marked as finished
             return;
         }
 
         finishedTests << test;
         q->emit testProgress( finishedTests, startedTests );
 
         if ( finishedTests.count() >= startedTests.count() &&
              pendingTests.isEmpty() && dependendTests.isEmpty()
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
              && !debugger->isRunning()
 #endif
            )
         {
             // The last pending test has finished
             DEBUGGER_JOB_SYNCHRONIZATION("The last pending test has finished" << data()->id());
             endTesting();
         } else {
             startTests( takeStartableDependentTests(test) );
         }
     };
 
     // NOTE This function only exists to automatically use gtfsProviderFeatures() for GTFS providers
     inline QList< Enums::ProviderFeature > features() const {
         return data()->type() == Enums::GtfsProvider
                 ? gtfsProviderFeatures() : provider->features();
     };
 
     // WARNING This function copies ServiceProviderGtfs::features() and needs to stay in sync.
     // This is because the ServiceProviderGtfs instances cannot be created by TimetableMate
     // because of problems with libprotobuf.
     QList< Enums::ProviderFeature > gtfsProviderFeatures() const {
         QList<Enums::ProviderFeature> features;
         features << Enums::ProvidesDepartures << Enums::ProvidesArrivals
                 << Enums::ProvidesStopSuggestions << Enums::ProvidesRouteInformation
                 << Enums::ProvidesStopID << Enums::ProvidesStopGeoPosition;
                 // Enums::ProvidesStopsByGeoPosition TODO
         if ( !data()->realtimeAlertsUrl().isEmpty() ) {
             features << Enums::ProvidesNews;
         }
         if ( !data()->realtimeTripUpdateUrl().isEmpty() ) {
             features << Enums::ProvidesDelays;
         }
         return features;
     };
 
     Project::State state;
     ProjectModel *projectModel;
     QMutex *mutex;
 
     // This is needed to know when the project source was updated with new settings using
     // setProviderData() but no ProjectSourceTab is opened
     bool projectSourceBufferModified;
 
     QString filePath;
     QString serviceProviderID;
 
     DashboardTab *dashboardTab;
     ProjectSourceTab *projectSourceTab;
     PlasmaPreviewTab *plasmaPreviewTab;
     WebTab *webTab;
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     GtfsDatabaseTab *gtfsDatabaseTab;
     Project::GtfsDatabaseState gtfsDatabaseState;
     int gtfsFeedImportProgress;
     QString gtfsFeedImportInfoMessage;
     QDateTime gtfsFeedModifiedTime;
     QDateTime gtfsDatabaseModifiedTime;
     quint64 gtfsFeedSize;
     quint64 gtfsDatabaseSize;
     QString gtfsDatabaseErrorString;
 #endif
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     ScriptState scriptState;
     ScriptTab *scriptTab;
     QList< ScriptTab* > externalScriptTabs;
 
     QString unsavedScriptContents;
     Debugger::Debugger *debugger;
 #endif
 
     ServiceProvider *provider;
     QString xmlComments;
 
     // Get created when needed, multi for actions of the same type with different data
     QMultiHash< Project::ProjectAction, QAction* > projectActions;
 
     // Store pointers to project actions, to update their enabled state on changes
     QMultiHash< Project::ProjectAction, QPointer<QAction> > externProjectActions;
 
     TestModel *testModel;
     TestState testState;
     QHash< TestModel::Test, ThreadWeaver::Job* > pendingTests;
     QList< TestModel::Test > dependendTests;
     QList< TestModel::Test > finishedTests;
     QList< TestModel::Test > startedTests;
 
     // Collects output/console text for the project
     QString output;
     QString consoleText;
 
     QString lastError;
     QString lastScriptErrorString;
     ScriptErrorType lastScriptError;
     QStringList globalFunctions;
     QStringList includedFiles;
     bool suppressMessages;
     bool enableQuestions;
 
 private:
     Project *q_ptr;
     Q_DECLARE_PUBLIC( Project )
 };
 
 Project::Project( const WeaverInterfacePointer &weaver, QWidget *parent )
         : QObject(parent), d_ptr(new ProjectPrivate(Enums::InvalidProvider, weaver, this))
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->initialize();
 }
 
 Project::Project( Enums::ServiceProviderType providerType,
                   const WeaverInterfacePointer &weaver, QWidget *parent )
         : QObject(parent), d_ptr(new ProjectPrivate(providerType, weaver, this))
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->initialize();
 }
 
 Project::~Project()
 {
     Q_D( Project );
     if ( isModified() ) {
-        kWarning() << "Destroying project with modifications";
+        qWarning() << "Destroying project with modifications";
     }
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     // Unload publictransport engine again
     Plasma::DataEngineManager::self()->unloadEngine("publictransport");
 #endif
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     disconnect( d->debugger, 0, this, 0 );
     d->debugger->weaver()->requestAbort();
     d->debugger->abortDebugger();
     d->debugger->finish();
 #endif
 
     delete d_ptr;
 }
 
 bool Project::loadProject( const QString &projectSoureFile )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( projectSoureFile.isEmpty() ) {
         d->insertProjectSourceTemplate();
         return true;
     } else {
         return d->loadProject( projectSoureFile );
     }
 }
 
 QString Project::output() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->output;
 }
 
 void Project::clearOutput()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->output.clear();
     emit outputCleared();
     emit outputChanged();
 }
 
 void Project::appendOutput( const QString &output, const QColor &color )
 {
     Q_D( Project );
     d->mutex->lock();
     if ( output.isEmpty() ) {
         d->mutex->unlock();
         return;
     }
     if ( !d->output.isEmpty() ) {
         d->output.append( "<br />" );
     }
 
     const QString colorString = QString("rgb(%1,%2,%3)")
             .arg(color.red()).arg(color.green()).arg(color.blue());
     if ( color.isValid() ) {
         QString colorizedOutput = output;
         colorizedOutput.prepend("<span style='color:" + colorString + ";'>").append("</span>");
         d->output.append( colorizedOutput );
         d->mutex->unlock();
 
         emit outputAppended( colorizedOutput );
     } else {
         d->output.append( output );
         d->mutex->unlock();
 
         emit outputAppended( output );
     }
     emit outputChanged();
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void Project::scriptOutput( const QString &message, const QScriptContextInfo &context )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( context.fileName() != scriptFileName() ) {
         appendOutput( i18nc("@info %2 is the script file name",
                             "<emphasis strong='1'>Line %1 (%2):</emphasis> <message>%3</message>",
                             context.lineNumber(), QFileInfo(context.fileName()).fileName(),
                             message),
                       KColorScheme(QPalette::Active).foreground(KColorScheme::InactiveText).color() );
     } else {
         appendOutput( i18nc("@info", "<emphasis strong='1'>Line %1:</emphasis> <message>%2</message>",
                             context.lineNumber(), message),
                       KColorScheme(QPalette::Active).foreground(KColorScheme::InactiveText).color() );
     }
 }
 
 void Project::scriptMessageReceived( const QString &errorMessage,
                                      const QScriptContextInfo &context,
                                      const QString &failedParseText,
                                      Helper::ErrorSeverity severity )
 {
     Q_UNUSED( failedParseText );
     QColor color;
     QString type;
     switch ( severity ) {
     case Helper::Warning:
         color = KColorScheme( QPalette::Active ).foreground( KColorScheme::NeutralText ).color();
         type = i18nc("@info/plain", "Warning");
         break;
     case Helper::Fatal:
         color = KColorScheme( QPalette::Active ).foreground( KColorScheme::NegativeText ).color();
         type = i18nc("@info/plain", "Error");
         break;
     case Helper::Information:
     default:
         type = i18nc("@info/plain", "Information");
         color = KColorScheme( QPalette::Active ).foreground( KColorScheme::InactiveText ).color();
         break;
     }
     if ( context.lineNumber() < 0 ) {
         // Received a message about repeated messages
         appendOutput( errorMessage, color );
     } else if ( !context.fileName().isEmpty() && context.fileName() != scriptFileName() ) {
         appendOutput( i18nc("@info %1 is the translation of 'Error'/'Warning'/'Information', "
                             "%3 is the script file name",
                             "<emphasis strong='1'>%1 in line %2 (%3):</emphasis> <message>%4</message>",
                             type, context.lineNumber(), QFileInfo(context.fileName()).fileName(),
                             errorMessage), color );
     } else {
         appendOutput( i18nc("@info %1 is the translation of 'Error'/'Warning'/'Information'",
                             "<emphasis strong='1'>%1 in line %2:</emphasis> <message>%3</message>",
                             type, context.lineNumber(), errorMessage), color );
     }
 }
 #endif
 
 QString Project::consoleText() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->consoleText;
 }
 
 void Project::clearConsoleText()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->consoleText.clear();
     emit consoleTextChanged( QString() );
 }
 
 void Project::appendToConsole( const QString &text )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( text.isEmpty() ) {
         return;
     }
     if ( !d->consoleText.isEmpty() ) {
         d->consoleText.append( "<br />" );
     }
     d->consoleText.append( text );
     emit consoleTextChanged( d->consoleText );
 }
 
 Project::State Project::state() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->state;
 }
 
 QString Project::lastError() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->lastError;
 }
 
 ProjectModel *Project::projectModel() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->projectModel;
 }
 
 DashboardTab *Project::dashboardTab() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->dashboardTab;
 }
 
 ProjectSourceTab *Project::projectSourceTab() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->projectSourceTab;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 ScriptTab *Project::scriptTab() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->scriptTab;
 }
 
 ScriptTab *Project::scriptTab( const QString &filePath ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     foreach ( ScriptTab *externalScriptTab, d->externalScriptTabs ) {
         if ( externalScriptTab->fileName() == filePath ) {
             return externalScriptTab;
         }
     }
 
     // External script is not opened in a tab
     return 0;
 }
 
 QList< ScriptTab * > Project::externalScriptTabs() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->externalScriptTabs;
 }
 
 ScriptTab *Project::externalScriptTab( const QString &filePath ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     foreach ( ScriptTab *tab, d->externalScriptTabs ) {
         if ( tab->fileName() == filePath ) {
             return tab;
         }
     }
 
     // No script tab with the given filePath found
     return 0;
 }
 #endif
 
 PlasmaPreviewTab *Project::plasmaPreviewTab() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->plasmaPreviewTab;
 }
 
 WebTab *Project::webTab() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->webTab;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 Debugger::Debugger *Project::debugger() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->debugger;
 }
 #endif
 
 QString Project::path() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return QFileInfo( d->filePath ).path();
 }
 
 QString Project::filePath() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->filePath;
 }
 
 QString Project::serviceProviderId() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->serviceProviderID;
 }
 
 TestModel *Project::testModel() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->testModel;
 }
 
 Project::InstallType Project::saveType() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->saveType();
 }
 
 Project::InstallTypes Project::installationTypes() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->installationTypes();
 }
 
 QString Project::savePathInfoString() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->savePathInfoString();
 }
 
 void Project::setProjectModel( ProjectModel *projectModel )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->projectModel = projectModel;
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     scriptSaved();
 #endif
 }
 
 const char *Project::projectActionName( Project::ProjectAction actionType )
 {
     switch ( actionType ) {
     case Save:
         return "project_save";
     case SaveAs:
         return "project_save_as";
     case Install:
         return "project_install";
     case Uninstall:
         return "project_uninstall";
     case InstallGlobally:
         return "project_install_global";
     case UninstallGlobally:
         return "project_uninstall_global";
     case Publish:
         return "project_publish";
     case Close:
         return "project_close";
     case ShowProjectSettings:
         return "project_settings";
     case ShowDashboard:
         return "project_show_dashboard";
     case ShowHomepage:
         return "project_show_homepage";
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case ShowScript:
         return "project_show_script";
     case ShowExternalScript:
         return "project_show_external_script";
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case ShowGtfsDatabase:
         return "project_show_gtfs_database";
     case Project::ImportGtfsFeed:
         return "project_import_gtfs_feed";
     case Project::UpdateGtfsDatabase:
         return "project_update_gtfs_database";
     case Project::DeleteGtfsDatabase:
         return "project_delete_gtfs_database";
 #endif
     case ShowProjectSource:
         return "project_show_source";
     case ShowPlasmaPreview:
         return "view_plasma_preview_show";
     case RunAllTests:
         return "test_all";
     case AbortRunningTests:
         return "test_abort";
     case ClearTestResults:
         return "test_clear";
     case RunSpecificTest:
         return "test_specific_test";
     case RunSpecificTestCase:
         return "test_specific_testcase";
     case SpecificTestCaseMenuAction:
         return "test_specific_testcase_menu";
     case SetAsActiveProject:
         return "project_set_active";
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case StepInto:
         return "debug_step_into";
     case StepOver:
         return "debug_step_over";
     case StepOut:
         return "debug_step_out";
     case Interrupt:
         return "debug_interrupt";
     case RunToCursor:
         return "debug_run_to_cursor";
     case Continue:
         return "debug_continue";
     case AbortDebugger:
         return "debug_abort";
     case ToggleBreakpoint:
         return "debug_toggle_breakpoint";
     case RemoveAllBreakpoints:
         return "debug_remove_all_breakpoints";
 
     case RunMenuAction:
         return "run_menu_action";
     case RunGetTimetable:
         return "run_departures";
     case RunGetStopSuggestions:
         return "run_stop_suggestions";
     case RunGetStopsByGeoPosition:
         return "run_stop_suggestions_geo_position";
     case RunGetJourneys:
         return "run_journeys";
 
     case DebugMenuAction:
         return "debug_menu_action";
     case DebugGetTimetable:
         return "debug_departures";
     case DebugGetStopSuggestions:
         return "debug_stop_suggestions";
     case DebugGetStopsByGeoPosition:
         return "debug_stops_by_geo_position";
     case DebugGetJourneys:
         return "debug_journeys";
 #endif
 
     default:
-        kWarning() << "Unknown project action" << actionType;
+        qWarning() << "Unknown project action" << actionType;
         return "";
     }
 }
 
 Project::ProjectActionData Project::projectActionData( QAction *action )
 {
     return action->data().value< ProjectActionData >();
 }
 
 void Project::setProjectActionData( QAction *projectAction, const QVariant &data )
 {
     ProjectActionData actionData = projectActionData( projectAction );
     actionData.data = data;
     projectAction->setData( QVariant::fromValue(actionData) );
     projectAction->setText( projectActionText(actionData.actionType, data) );
 }
 
 bool Project::isProjectAction( QAction *action )
 {
     return projectActionData( action ).isValid();
 }
 
 void Project::showProjectContextMenu( const QPoint &globalPos )
 {
     Q_D( Project );
     // Show context menu for this tab
     QScopedPointer<QMenu> contextMenu( new QMenu(d->parentWidget()) );
     contextMenu->addActions( contextMenuActions(contextMenu.data()) );
     contextMenu->exec( globalPos );
 }
 
 QList< QAction* > Project::contextMenuActions( QWidget *parent )
 {
     Q_D( Project );
     parent = d->parentWidget( parent );
 
     // Create a list of actions that should be used for context menus for the project
     QList< QAction* > actions;
     KAction *separator1 = new KAction( parent );
     separator1->setSeparator( true );
     KAction *separator2 = new KAction( parent );
     separator2->setSeparator( true );
     KAction *separator3 = new KAction( parent );
     separator3->setSeparator( true );
     actions << projectAction(Save) << projectAction(SaveAs)
             << projectAction(Install) << projectAction(InstallGlobally)
             << projectAction(Publish)
             << separator1
             << projectAction(Uninstall) << projectAction(UninstallGlobally)
             << separator2
             << projectAction(SetAsActiveProject)
             << projectAction(ShowDashboard);
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     if ( d->provider->type() == Enums::ScriptedProvider ) {
         actions << debuggerSubMenuAction(parent);
     }
 #endif
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     if ( d->provider->type() == Enums::GtfsProvider ) {
         actions << gtfsSubMenuAction(parent);
     }
 #endif
 
     actions << testSubMenuAction(parent)
             << separator3
             << projectAction(ShowProjectSettings)
             << projectAction(Close);
     return actions;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 QPointer< KActionMenu > Project::debuggerSubMenuAction( QWidget *parent )
 {
     Q_D( Project );
     parent = d->parentWidget( parent );
 
     // Create a KActionMenu containing debug actions
     QPointer<KActionMenu> debuggerMenuAction( new KActionMenu(KIcon("debugger"),
                                               i18nc("@action", "Run"), parent) );
     debuggerMenuAction->setObjectName( "debuggerMenuAction" );
     debuggerMenuAction->addAction( projectAction(RunMenuAction)  );
     debuggerMenuAction->addAction( projectAction(DebugMenuAction)  );
     debuggerMenuAction->addAction( projectAction(RunToCursor)  );
     debuggerMenuAction->addAction( projectAction(Continue)  );
     debuggerMenuAction->addAction( projectAction(Interrupt)  );
     debuggerMenuAction->addAction( projectAction(AbortDebugger)  );
     debuggerMenuAction->addSeparator();
     debuggerMenuAction->addAction( projectAction(StepOver)  );
     debuggerMenuAction->addAction( projectAction(StepInto)  );
     debuggerMenuAction->addAction( projectAction(StepOut)  );
     return debuggerMenuAction;
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
 QPointer< KActionMenu > Project::gtfsSubMenuAction( QWidget *parent )
 {
     Q_D( Project );
     parent = d->parentWidget( parent );
 
     // Create a KActionMenu containing debug actions
     // TODO GTFS icon?
     QPointer<KActionMenu> gtfsMenuAction( new KActionMenu(KIcon("application-zip"),
                                           i18nc("@action", "GTFS"), parent) );
     gtfsMenuAction->setObjectName( "debuggerMenuAction" );
     gtfsMenuAction->addAction( projectAction(ShowGtfsDatabase) );
     gtfsMenuAction->addSeparator();
     gtfsMenuAction->addAction( projectAction(ImportGtfsFeed) );
     gtfsMenuAction->addAction( projectAction(UpdateGtfsDatabase) );
     gtfsMenuAction->addAction( projectAction(DeleteGtfsDatabase) );
     return gtfsMenuAction;
 }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
 QPointer< KActionMenu > Project::testSubMenuAction( QWidget *parent )
 {
     Q_D( Project );
     parent = d->parentWidget( parent );
 
     // Create a KActionMenu containing test actions
     QPointer<KActionMenu> testMenuAction( new KActionMenu(KIcon("task-complete"),
                                           i18nc("@action", "Test"), parent) );
     testMenuAction->setObjectName( "testMenuAction" );
     testMenuAction->addAction( projectAction(RunAllTests) );
     testMenuAction->addAction( projectAction(AbortRunningTests) );
     testMenuAction->addAction( projectAction(ClearTestResults) );
     testMenuAction->addSeparator();
 
     // Fill test action list
     for ( int i = 0; i < TestModel::TestCaseCount; ++i ) {
         // Only add test cases that contain applicable tests
         const TestModel::TestCase testCase = static_cast<TestModel::TestCase>( i );
         if ( TestModel::isTestCaseApplicableTo(testCase, d->data()) ) {
             testMenuAction->addAction( projectAction(
                     SpecificTestCaseMenuAction, QVariant::fromValue(static_cast<int>(testCase))) );
         }
     }
     return testMenuAction;
 }
 
 QPointer< KActionMenu > Project::projectSubMenuAction( QWidget *parent )
 {
     Q_D( Project );
     parent = d->parentWidget( parent );
 
     // Create a KActionMenu containing all context menu actions for the project
     QPointer<KActionMenu> projectMenuAction( new KActionMenu(KIcon("project-development"),
                                        i18nc("@action", "Project"), parent) );
     projectMenuAction->setObjectName( "projectMenuAction" );
     QList< QAction* > projectActions = contextMenuActions( parent );
     foreach ( QAction *projectAction, projectActions ) {
         projectMenuAction->addAction( projectAction );
     }
     return projectMenuAction;
 }
 
 void Project::testActionTriggered()
 {
     QAction *action = qobject_cast< QAction* >( sender() );
     const ProjectActionData data = projectActionData( action );
     startTest( static_cast<TestModel::Test>(data.data.toInt()) );
 }
 
 void Project::testCaseActionTriggered()
 {
     QAction *action = qobject_cast< QAction* >( sender() );
     const ProjectActionData data = projectActionData( action );
     startTestCase( static_cast<TestModel::TestCase>(data.data.toInt()) );
 }
 
 bool Project::isActiveProject() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isActiveProject();
 }
 
 void Project::slotActiveProjectChanged( Project *project, Project *previousProject )
 {
     Q_D( Project );
     if ( project == this ) {
         emit activeProjectStateChanged( true );
 
         QMutexLocker locker( d->mutex );
         d->updateProjectActions( QList<ProjectActionGroup>()
                 << TestActionGroup << FileActionGroup << OtherActionGroup
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                 << RunActionGroup << DebuggerActionGroup
 #endif
                 );
     } else if ( previousProject == this ) {
         emit activeProjectStateChanged( false );
     }
 }
 
 QAction *Project::projectAction( Project::ProjectAction actionType, const QVariant &data )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     QAction *action = 0;
     if ( d->projectActions.contains(actionType) ) {
         // Find action in d->projectActions
         QList< QAction* > actions = d->projectActions.values( actionType );
         foreach ( QAction *currentAction, actions ) {
             const ProjectActionData actionData = projectActionData( currentAction );
             if ( !actionData.data.isValid() && !data.isValid() ) {
                 // No data wanted and an action without data was found
                 action = currentAction;
                 break;
             } else if ( actionData.data == data ) {
                 // An action with the given data was found
                 action = currentAction;
                 break;
             }
         }
     }
 
     if ( !action ) {
         // Create and connect action and store it in d->projectActions
         action = createAndConnectProjectAction( actionType, data, this );
         d->projectActions.insert( actionType, action );
     }
     return action;
 }
 
 void Project::connectProjectAction( Project::ProjectAction actionType, QAction *action,
                                     bool doConnect, bool useQueuedConnection )
 {
     Q_D( Project );
     ProjectPrivate::ConnectProjectActionFlags flags = useQueuedConnection
             ? ProjectPrivate::UseQueuedConnection : ProjectPrivate::NoConnectionFlags;
     switch ( actionType ) {
     case Save:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(save()), flags );
         if ( doConnect ) {
             connect( this, SIGNAL(modifiedStateChanged(bool)), action, SLOT(setEnabled(bool)) );
         } else {
             disconnect( this, SIGNAL(modifiedStateChanged(bool)), action, SLOT(setEnabled(bool)) );
         }
         break;
     case SaveAs:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(saveAs()), flags );
         break;
     case Install:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(installLocally()), flags );
         break;
     case Uninstall:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(uninstallLocally()), flags );
         break;
     case InstallGlobally:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(installGlobally()), flags );
         break;
     case UninstallGlobally:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(uninstallGlobally()), flags );
         break;
     case Publish:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(publish()), flags );
         break;
     case Close:
         d->connectProjectAction( actionType, action, doConnect, this, SIGNAL(closeRequest()), flags );
         break;
     case ShowProjectSettings:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showSettingsDialog()), flags );
         break;
     case ShowDashboard:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showDashboardTab()), flags );
         break;
     case ShowHomepage:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showWebTab()), flags );
         break;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case ShowScript:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showScriptTab()), flags );
         break;
     case ShowExternalScript:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showExternalScriptActionTriggered()), flags );
         break;
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case ShowGtfsDatabase:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showGtfsDatabaseTab()), flags );
         break;
     case Project::ImportGtfsFeed:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(importGtfsFeed()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case Project::UpdateGtfsDatabase:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(updateGtfsDatabase()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case Project::DeleteGtfsDatabase:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(deleteGtfsDatabase()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
 #endif
     case ShowProjectSource:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showProjectSourceTab()), flags );
         break;
     case ShowPlasmaPreview:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(showPlasmaPreviewTab()), flags );
         break;
 
     case RunAllTests:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(testProject()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case AbortRunningTests:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(abortTests()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case ClearTestResults:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(clearTestResults()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case RunSpecificTest:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(testActionTriggered()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case RunSpecificTestCase:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(testCaseActionTriggered()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
 
     case SetAsActiveProject:
         d->connectProjectAction( actionType, action, doConnect,
                                  this, SIGNAL(setAsActiveProjectRequest()), flags );
         if ( doConnect ) {
             connect( this, SIGNAL(activeProjectStateChanged(bool)), action, SLOT(setDisabled(bool)) );
             connect( this, SIGNAL(activeProjectStateChanged(bool)), action, SLOT(setChecked(bool)) );
             action->setChecked( isActiveProject() );
         } else {
             disconnect( this, SIGNAL(activeProjectStateChanged(bool)), action, SLOT(setDisabled(bool)) );
             disconnect( this, SIGNAL(activeProjectStateChanged(bool)), action, SLOT(setChecked(bool)) );
         }
         break;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case StepInto:
         d->connectProjectAction( actionType, action, doConnect, d->debugger, SLOT(debugStepInto()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case StepOver:
         d->connectProjectAction( actionType, action, doConnect, d->debugger, SLOT(debugStepOver()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case StepOut:
         d->connectProjectAction( actionType, action, doConnect, d->debugger, SLOT(debugStepOut()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case Interrupt:
         d->connectProjectAction( actionType, action, doConnect, d->debugger, SLOT(debugInterrupt()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case Continue:
         d->connectProjectAction( actionType, action, doConnect, d->debugger, SLOT(debugContinue()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case AbortDebugger:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(abortDebugger()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case ToggleBreakpoint:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(toggleBreakpoint()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case RemoveAllBreakpoints:
         d->connectProjectAction( actionType, action, doConnect,
                                  d->debugger, SLOT(removeAllBreakpoints()), flags );
         if ( doConnect ) {
             connect( d->debugger->breakpointModel(), SIGNAL(emptinessChanged(bool)),
                      action, SLOT(setDisabled(bool)) );
         } else {
             disconnect( d->debugger->breakpointModel(), SIGNAL(emptinessChanged(bool)),
                         action, SLOT(setDisabled(bool)) );
         }
         break;
     case RunToCursor:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(runToCursor()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
 
     case SpecificTestCaseMenuAction:
     case RunMenuAction:
     case DebugMenuAction: {
         // Nothing to do for this action, it opens a menu with other actions
         // Connect these other actions instead
         KActionMenu *menuAction = qobject_cast< KActionMenu* >( action );
         Q_ASSERT( menuAction );
         QList<QAction*> actions = menuAction->menu()->actions();
         foreach ( QAction *action, actions ) {
             if ( action->isSeparator() ) {
                 continue;
             }
             connectProjectAction( projectActionData(action).actionType, action, doConnect );
         }
         d->connectProjectAction( actionType, action, doConnect, 0, "",
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
     } break;
 
     case RunGetTimetable:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(runGetTimetable()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case RunGetStopSuggestions:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(runGetStopSuggestions()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case RunGetStopsByGeoPosition:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(runGetStopsByGeoPosition()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case RunGetJourneys:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(runGetJourneys()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
 
     case DebugGetTimetable:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(debugGetTimetable()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case DebugGetStopSuggestions:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(debugGetStopSuggestions()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case DebugGetStopsByGeoPosition:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(debugGetStopsByGeoPosition()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
     case DebugGetJourneys:
         d->connectProjectAction( actionType, action, doConnect, this, SLOT(debugGetJourneys()),
                                  flags | ProjectPrivate::AutoUpdateEnabledState );
         break;
 #endif
 
     default:
-        kWarning() << "Unknown project action" << actionType;
+        qWarning() << "Unknown project action" << actionType;
         return;
     }
 }
 
 QString Project::projectActionText( Project::ProjectAction actionType, const QVariant &data )
 {
     switch ( actionType ) {
     case Save:
         return i18nc("@action", "Save Project");
     case SaveAs:
         return i18nc("@action", "Save Project As...");
     case Install:
         return i18nc("@action", "&Install");
     case Uninstall:
         return i18nc("@action", "&Uninstall");
     case InstallGlobally:
         return i18nc("@action", "Install &Globally");
     case UninstallGlobally:
         return i18nc("@action", "Uninstall &Globally");
     case Publish:
         return i18nc("@action", "&Publish...");
     case Close:
         return i18nc("@action", "Close Project");
     case ShowProjectSettings:
         return i18nc("@action", "Project Settings...");
     case ShowDashboard:
         return i18nc("@action", "Show &Dashboard");
     case ShowHomepage:
         return i18nc("@action", "Show &Web Page");
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case ShowScript:
         return i18nc("@action", "Open &Script");
     case ShowExternalScript: {
         const QString filePath = data.toString();
         return filePath.isEmpty() ? i18nc("@action", "Open External Script...")
                                   : i18nc("@action", "Open External Script <filename>%1</filename>",
                                           QFileInfo(filePath).fileName());
     }
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case ShowGtfsDatabase:
         return i18nc("@action", "Open GTFS &Database");
     case Project::ImportGtfsFeed:
         return i18nc("@action", "&Import GTFS Feed");
     case Project::UpdateGtfsDatabase:
         return i18nc("@action", "&Update GTFS Database");
     case Project::DeleteGtfsDatabase:
         return i18nc("@action", "&Delete GTFS Database");
 #endif
     case ShowProjectSource:
         return i18nc("@action", "Open Project &Source");
     case ShowPlasmaPreview:
         return i18nc("@action", "Show &Plasma Preview");
 
     case RunAllTests:
         return i18nc("@action", "&Run All Tests");
     case AbortRunningTests:
         return i18nc("@action", "&Abort Running Tests");
     case ClearTestResults:
         return i18nc("@action", "&Clear All Test Results");
     case RunSpecificTest: {
         TestModel::Test test = static_cast< TestModel::Test >( data.toInt() );
         if ( test == TestModel::InvalidTest ) {
-            kWarning() << "No test specified for project action RunSpecificTest";
+            qWarning() << "No test specified for project action RunSpecificTest";
             return QString();
         }
         return i18nc("@action", "Run %1", TestModel::nameForTest(test));
     }
     case RunSpecificTestCase:
         return i18nc("@action", "&Run Complete Test Case");
     case SpecificTestCaseMenuAction: {
         TestModel::TestCase testCase = static_cast< TestModel::TestCase >( data.toInt() );
         if ( testCase == TestModel::InvalidTestCase ) {
-            kWarning() << "No test case specified for project action SpecificTestCaseMenuAction";
+            qWarning() << "No test case specified for project action SpecificTestCaseMenuAction";
             return QString();
         }
 
         // Create menu action
         return TestModel::nameForTestCase( testCase );
     }
     case SetAsActiveProject:
         return i18nc("@action", "Set as Active Project");
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case StepInto:
         return i18nc("@action", "Step &Into");
     case StepOver:
         return i18nc("@action", "Step &Over");
     case StepOut:
         return i18nc("@action", "Step Ou&t");
     case Interrupt:
         return i18nc("@action", "&Interrupt");
     case RunToCursor:
         return i18nc("@action", "Run to &Cursor");
     case Continue:
         return i18nc("@action", "&Continue");
     case AbortDebugger:
         return i18nc("@action", "&Abort Debugger");
     case ToggleBreakpoint:
         return i18nc("@action", "Toggle &Breakpoint");
     case RemoveAllBreakpoints:
         return i18nc("@action", "&Remove all Breakpoints");
 
     case RunMenuAction:
         return i18nc("@action", "&Run");
     case RunGetTimetable:
         return i18nc("@action", "Run get&Timetable()");
     case RunGetStopSuggestions:
         return i18nc("@action", "Run get&StopSuggestions()");
     case RunGetStopsByGeoPosition:
         return i18nc("@action", "Run get&StopSuggestions(), Geo Position");
     case RunGetJourneys:
         return i18nc("@action", "Run get&Journeys()");
 
     case DebugMenuAction:
         return i18nc("@action", "&Debug");
     case DebugGetTimetable:
         return i18nc("@action", "Debug get&Timetable()");
     case DebugGetStopSuggestions:
         return i18nc("@action", "Debug get&StopSuggestions()");
     case DebugGetStopsByGeoPosition:
         return i18nc("@action", "Debug get&StopSuggestions(), Geo Position");
     case DebugGetJourneys:
         return i18nc("@action", "Debug get&Journeys()");
 #endif
 
     default:
         kDebug() << "Unknown project action" << actionType;
         return QString();
     }
 }
 
 QAction *Project::createProjectAction( Project::ProjectAction actionType, const QVariant &data,
                                        QObject *parent )
 {
     KAction *action = 0;
     const QString text = projectActionText( actionType, data );
     switch ( actionType ) {
     case Save:
         action = new KAction( KIcon("document-save"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Save changes in the project") );
         action->setEnabled( false );
         break;
     case SaveAs:
         action = new KAction( KIcon("document-save-as"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Save changes in the project under a new file name") );
         break;
     case Install:
         action = new KAction( KIcon("run-build-install"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Install the project locally") );
         break;
     case Uninstall:
         action = new KAction( KIcon("edit-delete"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                                   "Uninstall a locally installed version of the project") );
         break;
     case InstallGlobally:
         action = new KAction( KIcon("run-build-install-root"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Install the project globally") );
         break;
     case UninstallGlobally:
         action = new KAction( KIcon("edit-delete"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                                   "Uninstall a globally installed version of the project") );
         break;
     case Publish:
         action = new KAction( KIcon("svn-commit"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                                   "Publish the plugin project at openDesktop.org") );
         break;
     case Close:
         action = new KAction( KIcon("project-development-close"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Close this project") );
         break;
     case ShowProjectSettings:
         action = new KAction( KIcon("configure"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Opens a dialog to modify the projects settings") );
         break;
     case ShowDashboard:
         action = new KAction( KIcon("dashboard-show"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Shows the dashboard tab of the project.") );
         break;
     case ShowHomepage:
         action = new KAction( KIcon("document-open-remote"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Opens the <emphasis>home page</emphasis> of the service provider in a tab.") );
         break;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case ShowScript:
         action = new KAction( KIcon("document-open"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Opens the main <emphasis>script</emphasis> in a tab.") );
         break;
     case ShowExternalScript:
         action = new KAction( KIcon("document-open"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Opens an external <emphasis>script</emphasis> in a tab.") );
         break;
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case ShowGtfsDatabase:
         action = new KAction( KIcon("server-database"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Opens the <emphasis>GTFS database</emphasis> in a tab.") );
         break;
     case ImportGtfsFeed:
         action = new KAction( KIcon("document-import"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Downloads the GTFS feed and imports it into the GTFS database.") );
         break;
     case UpdateGtfsDatabase:
         action = new KAction( KIcon("view-refresh"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Updates the GTFS database by downloading and "
                                   "importing a new version of the GTFS feed.") );
         break;
     case DeleteGtfsDatabase:
         action = new KAction( KIcon("edit-delete"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Deletes the GTFS database.") );
         break;
 #endif
     case ShowProjectSource:
         action = new KAction( KIcon("document-open"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Opens the <emphasis>project source</emphasis> "
                                   "document in a tab.") );
         break;
     case ShowPlasmaPreview:
         action = new KAction( KIcon("plasma"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Opens the project in a PublicTransport applet "
                                   "in a <emphasis>Plasma preview</emphasis> tab.") );
         break;
 
     case RunAllTests:
         action = new KAction( KIcon("task-complete"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Runs all tests for the active project, eg. syntax errors, correct results.") );
         break;
     case AbortRunningTests:
         action = new KAction( KIcon("dialog-cancel"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Aborts all currently running tests.") );
         break;
     case ClearTestResults:
         action = new KAction( KIcon("edit-clear"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Clears all results of a previous test run.") );
         break;
     case RunSpecificTest: {
         TestModel::Test test = static_cast< TestModel::Test >( data.toInt() );
         if ( test == TestModel::InvalidTest ) {
-            kWarning() << "No test specified for project action RunSpecificTest";
+            qWarning() << "No test specified for project action RunSpecificTest";
             return 0;
         }
         action = new KAction( KIcon("arrow-right"), i18nc("@action:inmenu", "Run %1",
                                                           TestModel::nameForTest(test)), parent );
         action->setToolTip( TestModel::descriptionForTest(test) );
     } break;
     case RunSpecificTestCase: {
         TestModel::TestCase testCase = static_cast< TestModel::TestCase >( data.toInt() );
         if ( testCase == TestModel::InvalidTestCase ) {
-            kWarning() << "No test case specified for project action RunSpecificTestCase";
+            qWarning() << "No test case specified for project action RunSpecificTestCase";
             return 0;
         }
         action = new KAction( KIcon("arrow-right-double"),
                               i18nc("@action:inmenu", "&Run Complete Test Case"), parent );
         action->setToolTip( TestModel::descriptionForTestCase(testCase) );
     } break;
     case SpecificTestCaseMenuAction: {
         TestModel::TestCase testCase = static_cast< TestModel::TestCase >( data.toInt() );
         if ( testCase == TestModel::InvalidTestCase ) {
-            kWarning() << "No test case specified for project action SpecificTestCaseMenuAction";
+            qWarning() << "No test case specified for project action SpecificTestCaseMenuAction";
             return 0;
         }
 
         // Create menu action
         KActionMenu *runTestCase = new KActionMenu( TestModel::nameForTestCase(testCase), parent );
         runTestCase->setToolTip( TestModel::descriptionForTestCase(testCase) );
         runTestCase->setDelayed( false );
 
         // Add RunSpecificTestCase action, a separator
         // and RunSpeficTest actions for each test of the test case
         runTestCase->addAction( createProjectAction(RunSpecificTestCase, testCase, parent) );
         runTestCase->addSeparator();
         const QList< TestModel::Test > tests = TestModel::testsOfTestCase( testCase );
         foreach ( TestModel::Test test, tests ) {
             runTestCase->addAction( createProjectAction(RunSpecificTest, test, parent) );
         }
         action = runTestCase;
     } break;
 
     case SetAsActiveProject:
         action = new KAction( KIcon("edit-select"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Use this project as the active project") );
         action->setCheckable( true );
         action->setEnabled( false );
         break;
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case StepInto:
         action = new KAction( KIcon("debug-step-into"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Continue script execution until the next statement") );
         action->setEnabled( false );
         action->setPriority( QAction::LowPriority );
         break;
     case StepOver:
         action = new KAction( KIcon("debug-step-over"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Continue script execution until the next statement in the same context.") );
         action->setEnabled( false );
         action->setPriority( QAction::LowPriority );
         break;
     case StepOut:
         action = new KAction( KIcon("debug-step-out"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Continue script execution until the current function gets left.") );
         action->setEnabled( false );
         action->setPriority( QAction::LowPriority );
         break;
     case Interrupt:
         action = new KAction( KIcon("media-playback-pause"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Interrupt script execution.") );
         action->setEnabled( false );
         action->setEnabled( false );
         action->setPriority( QAction::LowPriority );
         break;
     case RunToCursor:
         action = new KAction( KIcon("debug-execute-to-cursor"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Continue script execution until the current cursor position is reached") );
         action->setEnabled( false );
         action->setPriority( QAction::LowPriority );
         break;
     case Continue:
         action = new KAction( KIcon("media-playback-start"), text, parent );
         action->setToolTip( i18nc("@info:tooltip",
                 "Continue script execution, only interrupt on breakpoints or uncaught exceptions.") );
         action->setEnabled( false );
         action->setPriority( QAction::LowPriority );
         break;
     case AbortDebugger:
         action = new KAction( KIcon("process-stop"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Abort script execution") );
         action->setEnabled( false );
         action->setPriority( QAction::LowPriority );
         break;
     case ToggleBreakpoint:
         action = new KAction( KIcon("tools-report-bug"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Toggle breakpoint for the current line") );
         action->setEnabled( false );
         break;
     case RemoveAllBreakpoints:
         action = new KAction( KIcon("tools-report-bug"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Removes all breakpoints") );
         action->setEnabled( false );
         break;
 
     case RunMenuAction: {
         KActionMenu *debugScript = new KActionMenu( KIcon("system-run"), text, parent );
         debugScript->setToolTip( i18nc("@info:tooltip", "Runs a function of the script.") );
         debugScript->setDelayed( false );
         debugScript->addAction( createProjectAction(Project::RunGetTimetable, parent) );
         debugScript->addAction( createProjectAction(Project::RunGetStopSuggestions, parent) );
         debugScript->addAction( createProjectAction(Project::RunGetStopsByGeoPosition, parent) );
         debugScript->addAction( createProjectAction(Project::RunGetJourneys, parent) );
         action = debugScript;
     } break;
     case RunGetTimetable:
         action = new KAction( KIcon("system-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getTimetable()'") );
         action->setEnabled( false );
         break;
     case RunGetStopSuggestions:
         action = new KAction( KIcon("system-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getStopSuggestions()'") );
         action->setEnabled( false );
         break;
     case RunGetStopsByGeoPosition:
         action = new KAction( KIcon("system-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getStopSuggestions()' "
                                                    "with a geo position as argument") );
         action->setEnabled( false );
         break;
     case RunGetJourneys:
         action = new KAction( KIcon("system-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getJourneys()'") );
         action->setEnabled( false );
         break;
 
     case DebugMenuAction: {
         KActionMenu *debugScript = new KActionMenu( KIcon("debug-run"), text, parent );
         debugScript->setToolTip( i18nc("@info:tooltip", "Runs a function of the script in a debugger.") );
         debugScript->setDelayed( false );
         debugScript->addAction( createProjectAction(Project::DebugGetTimetable, parent) );
         debugScript->addAction( createProjectAction(Project::DebugGetStopSuggestions, parent) );
         debugScript->addAction( createProjectAction(Project::DebugGetStopsByGeoPosition, parent) );
         debugScript->addAction( createProjectAction(Project::DebugGetJourneys, parent) );
         action = debugScript;
     } break;
     case DebugGetTimetable:
         action = new KAction( KIcon("debug-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getTimetable()' "
                                                    "in a debugger") );
         action->setEnabled( false );
         break;
     case DebugGetStopSuggestions:
         action = new KAction( KIcon("debug-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getStopSuggestions()' "
                                                    "in a debugger") );
         action->setEnabled( false );
         break;
     case DebugGetStopsByGeoPosition:
         action = new KAction( KIcon("debug-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getStopSuggestions()' "
                                                    "in a debugger with a geo position as argument") );
         action->setEnabled( false );
         break;
     case DebugGetJourneys:
         action = new KAction( KIcon("debug-run"), text, parent );
         action->setToolTip( i18nc("@info:tooltip", "Runs the script function 'getJourneys()' "
                                                    "in a debugger") );
         action->setEnabled( false );
         break;
 #endif
 
     default:
         kDebug() << "Unknown project action" << actionType;
         break;
     }
 
     // Store action type
     action->setData( QVariant::fromValue(ProjectActionData(actionType, data)) );
     return action;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void Project::showScriptLineNumber( const QString &fileName, int lineNumber )
 {
     Q_D( Project );
     if ( lineNumber < 0 ) {
         return;
     }
 
     QMutexLocker locker( d->mutex );
     ScriptTab *tab = fileName.isEmpty() ? showScriptTab() : showExternalScriptTab(fileName);
     if ( tab ) {
         tab->goToLine( lineNumber );
     }
 }
 #endif
 
 DashboardTab *Project::showDashboardTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->dashboardTab ) {
         emit tabGoToRequest( d->dashboardTab );
     } else {
         d->dashboardTab = createDashboardTab( d->parentWidget(parent) );
         if ( d->dashboardTab ) {
             emit tabOpenRequest( d->dashboardTab );
         }
     }
     return d->dashboardTab;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 ScriptTab *Project::showScriptTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->scriptTab ) {
         emit tabGoToRequest( d->scriptTab );
     } else {
         d->scriptTab = createScriptTab( d->parentWidget(parent) );
         if ( d->scriptTab ) {
             connect( d->scriptTab->document(), SIGNAL(documentSavedOrUploaded(KTextEditor::Document*,bool)),
                      this, SLOT(scriptSaved()) );
             emit tabOpenRequest( d->scriptTab );
         } else {
-            kWarning() << "Could not create script tab";
+            qWarning() << "Could not create script tab";
         }
     }
     return d->scriptTab;
 }
 
 ScriptTab *Project::showExternalScriptTab( const QString &_filePath, QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     QString filePath = _filePath;
     if ( filePath.isEmpty() ) {
         // Get external script file name (from the same directory)
         QScopedPointer<KFileDialog> dialog( new KFileDialog(path(), QString(), parent) );
         dialog->setMimeFilter( QStringList() << "application/javascript" );
         if ( dialog->exec() == KFileDialog::Accepted ) {
             filePath = dialog->selectedFile();
         } else {
             return 0;
         }
     } else if ( !filePath.contains('/') ) {
         filePath.prepend( path() + '/' );
     }
 
     ScriptTab *tab = externalScriptTab( filePath );
     if ( tab ) {
         emit tabGoToRequest( tab );
     } else {
         tab = createExternalScriptTab( filePath, d->parentWidget(parent) );
         if ( tab ) {
             connect( tab->document(), SIGNAL(documentSavedOrUploaded(KTextEditor::Document*,bool)),
                      this, SLOT(scriptSaved()) );
             d->externalScriptTabs << tab;
             emit tabOpenRequest( tab );
         }
     }
     return tab;
 }
 
 void Project::scriptSaved()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->data()->isValid() && d->data()->type() == Enums::ScriptedProvider ) {
         d->debugger->loadScript( scriptText(), d->data() );
         d->testModel->markTestsAsOutdated(
                 TestModel::testsOfTestCase(TestModel::ScriptExecutionTestCase) );
     }
 }
 
 ScriptTab *Project::showExternalScriptActionTriggered( QWidget *parent )
 {
     QAction *action = qobject_cast< QAction* >( sender() );
     const QString filePath = projectActionData(action).data.toString();
     return showExternalScriptTab( filePath, parent );
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
 GtfsDatabaseTab *Project::showGtfsDatabaseTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->gtfsDatabaseTab ) {
         emit tabGoToRequest( d->gtfsDatabaseTab );
     } else {
         d->gtfsDatabaseTab = createGtfsDatabaseTab( d->parentWidget(parent) );
         if ( d->gtfsDatabaseTab ) {
             emit tabOpenRequest( d->gtfsDatabaseTab );
         }
     }
     return d->gtfsDatabaseTab;
 }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
 ProjectSourceTab *Project::showProjectSourceTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->projectSourceTab ) {
         emit tabGoToRequest( d->projectSourceTab );
     } else {
         d->projectSourceTab = createProjectSourceTab( d->parentWidget(parent) );
         if ( d->projectSourceTab ) {
             emit tabOpenRequest( d->projectSourceTab );
         }
     }
     return d->projectSourceTab;
 }
 
 PlasmaPreviewTab *Project::showPlasmaPreviewTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->plasmaPreviewTab ) {
         emit tabGoToRequest( d->plasmaPreviewTab );
     } else {
         d->plasmaPreviewTab = createPlasmaPreviewTab( d->parentWidget(parent) );
         if ( d->plasmaPreviewTab ) {
             emit tabOpenRequest( d->plasmaPreviewTab );
         }
     }
     return d->plasmaPreviewTab;
 }
 
 WebTab *Project::showWebTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->webTab ) {
         emit tabGoToRequest( d->webTab );
     } else {
         d->webTab = createWebTab( d->parentWidget(parent) );
         if ( d->webTab ) {
             emit tabOpenRequest( d->webTab );
         }
     }
     return d->webTab;
 }
 
 Project::ProjectActionGroup Project::actionGroupFromType( Project::ProjectAction actionType )
 {
     switch ( actionType ) {
     case Save:
     case SaveAs:
     case Install:
     case Uninstall:
     case InstallGlobally:
     case UninstallGlobally:
     case Publish:
         return FileActionGroup;
 
     case ShowProjectSettings:
     case ShowDashboard:
     case ShowHomepage:
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case ShowScript:
     case ShowExternalScript:
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case ShowGtfsDatabase:
 #endif
     case ShowProjectSource:
     case ShowPlasmaPreview:
         return UiActionGroup;
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Interrupt:
     case Continue:
     case AbortDebugger:
     case RunToCursor:
     case StepInto:
     case StepOver:
     case StepOut:
     case ToggleBreakpoint:
     case RemoveAllBreakpoints:
         return DebuggerActionGroup;
 
     case RunMenuAction:
     case RunGetTimetable:
     case RunGetStopSuggestions:
     case RunGetStopsByGeoPosition:
     case RunGetJourneys:
     case DebugMenuAction:
     case DebugGetTimetable:
     case DebugGetStopSuggestions:
     case DebugGetStopsByGeoPosition:
     case DebugGetJourneys:
         return RunActionGroup;
 #endif
 
     case RunAllTests:
     case AbortRunningTests:
     case ClearTestResults:
     case RunSpecificTest:
     case RunSpecificTestCase:
     case SpecificTestCaseMenuAction:
         return TestActionGroup;
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case ImportGtfsFeed:
     case UpdateGtfsDatabase:
     case DeleteGtfsDatabase:
         return GtfsDatabaseActionGroup;
 #endif
 
     case Close:
     case SetAsActiveProject:
         return OtherActionGroup;
 
     default:
         return InvalidProjectActionGroup;
     }
 }
 
 QList< Project::ProjectAction > Project::actionsFromGroup( Project::ProjectActionGroup group )
 {
     QList< Project::ProjectAction > actionTypes;
     switch ( group ) {
     case FileActionGroup:
         actionTypes << Save << SaveAs << Install << Uninstall
                     << InstallGlobally << UninstallGlobally << Publish;
         break;
     case UiActionGroup:
         actionTypes << ShowProjectSettings << ShowDashboard << ShowHomepage
                     << ShowProjectSource << ShowPlasmaPreview
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                     << ShowScript << ShowExternalScript
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
                     << ShowGtfsDatabase
 #endif
                     ;
         break;
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case DebuggerActionGroup:
         actionTypes << Interrupt << Continue << AbortDebugger << RunToCursor << StepInto << StepOver
                     << StepOut << ToggleBreakpoint << RemoveAllBreakpoints;
         break;
     case RunActionGroup:
         actionTypes << RunMenuAction << RunGetTimetable << RunGetStopSuggestions
                     << RunGetStopsByGeoPosition << RunGetJourneys
                     << DebugMenuAction << DebugGetTimetable << DebugGetStopSuggestions
                     << DebugGetStopsByGeoPosition << DebugGetJourneys;
         break;
 #endif
 
     case TestActionGroup:
         actionTypes << RunAllTests << AbortRunningTests << ClearTestResults << RunSpecificTest
                     << RunSpecificTestCase << SpecificTestCaseMenuAction;
         break;
     case OtherActionGroup:
         actionTypes << Close << SetAsActiveProject;
         break;
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case GtfsDatabaseActionGroup:
         actionTypes << ImportGtfsFeed << UpdateGtfsDatabase << DeleteGtfsDatabase;
         break;
 #endif
     case InvalidProjectActionGroup:
     default:
-        kWarning() << "Invalid group" << group;
+        qWarning() << "Invalid group" << group;
         break;
     }
     return actionTypes;
 }
 
 Project::GtfsDatabaseState Project::gtfsDatabaseState() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsDatabaseState;
 #else
     return InitializingGtfsDatabase;
 #endif
 }
 
 QString Project::gtfsDatabaseErrorString() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsDatabaseErrorString;
 #else
     return QString();
 #endif
 }
 
 int Project::gtfsFeedImportProgress() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsFeedImportProgress;
 #else
     return 0;
 #endif
 }
 
 QString Project::gtfsFeedImportInfoMessage() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsFeedImportInfoMessage;
 #else
     return QString();
 #endif
 }
 
 QDateTime Project::gtfsFeedLastModified() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsFeedModifiedTime;
 #else
     return QDateTime();
 #endif
 }
 
 QDateTime Project::gtfsDatabaseLastModified() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsDatabaseModifiedTime;
 #else
     return QDateTime();
 #endif
 }
 
 quint64 Project::gtfsFeedSize() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsFeedSize;
 #else
     return 0;
 #endif
 }
 
 QString Project::gtfsFeedSizeString() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return KGlobal::locale()->formatByteSize( d->gtfsFeedSize );
 #else
     return QString();
 #endif
 }
 
 quint64 Project::gtfsDatabaseSize() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsDatabaseSize;
 #else
     return 0;
 #endif
 }
 
 QString Project::gtfsDatabaseSizeString() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return KGlobal::locale()->formatByteSize( d->gtfsDatabaseSize );
 #else
     return QString();
 #endif
 }
 
 QString Project::gtfsDatabasePath() const
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return GtfsDatabase::databasePath( d->data()->id() );
 #else
     return QString();
 #endif
 }
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
 void Project::importGtfsFeed()
 {
     Q_D( Project );
     if ( d->provider->type() != Enums::GtfsProvider ) {
         return;
     }
 
     if ( !isInstalledGlobally() && !isInstalledLocally() ) {
         emit informationMessage( i18nc("@ịnfo", "The provider must be installed before "
                                        "the GTFS feed can be imported."), KMessageWidget::Error );
         return;
     }
 
     d->updateGtfsDatabaseState();
     if ( d->gtfsDatabaseState == GtfsDatabaseError ) {
-        kWarning() << "Cannot import GTFS feed" << d->gtfsDatabaseErrorString;
+        qWarning() << "Cannot import GTFS feed" << d->gtfsDatabaseErrorString;
         return;
     }
 
     d->setGtfsDatabaseState( GtfsDatabaseImportRunning );
     Plasma::DataEngine *engine = Plasma::DataEngineManager::self()->engine("publictransport");
     Plasma::Service *gtfsService = engine->serviceForSource("GTFS");
     KConfigGroup op = gtfsService->operationDescription("importGtfsFeed");
     op.writeEntry( "serviceProviderId", d->data()->id() );
     Plasma::ServiceJob *importJob = gtfsService->startOperationCall( op );
     connect( importJob, SIGNAL(result(KJob*)), this, SLOT(gtfsDatabaseImportFinished(KJob*)) );
     connect( importJob, SIGNAL(percent(KJob*,ulong)),
              this, SLOT(gtfsDatabaseImportProgress(KJob*,ulong)) );
     connect( importJob, SIGNAL(infoMessage(KJob*,QString,QString)),
              this, SLOT(gtfsDatabaseImportInfoMessage(KJob*,QString,QString)) );
     connect( importJob, SIGNAL(finished(KJob*)), gtfsService, SLOT(deleteLater()) );
 }
 
 void Project::updateGtfsDatabase()
 {
     Q_D( Project );
     if ( d->provider->type() != Enums::GtfsProvider ) {
         return;
     }
 
     d->updateGtfsDatabaseState();
     if ( d->gtfsDatabaseState == GtfsDatabaseError ) {
-        kWarning() << "Cannot update GTFS feed" << d->gtfsDatabaseErrorString;
+        qWarning() << "Cannot update GTFS feed" << d->gtfsDatabaseErrorString;
         return;
     }
 
     d->setGtfsDatabaseState( GtfsDatabaseImportRunning );
     Plasma::DataEngine *engine = Plasma::DataEngineManager::self()->engine("publictransport");
     Plasma::Service *gtfsService = engine->serviceForSource("GTFS");
     KConfigGroup op = gtfsService->operationDescription("updateGtfsDatabase");
     op.writeEntry( "serviceProviderId", d->data()->id() );
     Plasma::ServiceJob *updateJob = gtfsService->startOperationCall( op );
     connect( updateJob, SIGNAL(result(KJob*)), this, SLOT(gtfsDatabaseImportFinished(KJob*)) );
     connect( updateJob, SIGNAL(percent(KJob*,ulong)),
              this, SLOT(gtfsDatabaseImportProgress(KJob*,ulong)) );
     connect( updateJob, SIGNAL(infoMessage(KJob*,QString,QString)),
              this, SLOT(gtfsDatabaseImportInfoMessage(KJob*,QString,QString)) );
     connect( updateJob, SIGNAL(finished(KJob*)), gtfsService, SLOT(deleteLater()) );
 }
 
 void Project::deleteGtfsDatabase()
 {
     Q_D( Project );
     if ( d->provider->type() != Enums::GtfsProvider ) {
         return;
     }
 
     d->updateGtfsDatabaseState();
     if ( d->gtfsDatabaseState != GtfsDatabaseImportFinished ) {
-        kWarning() << "Cannot delete GTFS feed" << d->gtfsDatabaseErrorString;
+        qWarning() << "Cannot delete GTFS feed" << d->gtfsDatabaseErrorString;
         return;
     }
 
     const QString databasePath = GtfsDatabase::databasePath( d->data()->id() );
     qint64 feedSizeInBytes = QFileInfo( databasePath ).size();
     if ( KMessageBox::warningContinueCancel(d->parentWidget(), 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(feedSizeInBytes))) == KMessageBox::Continue )
     {
         d->setGtfsDatabaseState( GtfsDatabaseImportPending );
 
         Plasma::DataEngine *engine = Plasma::DataEngineManager::self()->engine("publictransport");
         Plasma::Service *gtfsService = engine->serviceForSource("GTFS");
         KConfigGroup op = gtfsService->operationDescription("deleteGtfsDatabase");
         op.writeEntry( "serviceProviderId", d->data()->id() );
         Plasma::ServiceJob *deleteJob = gtfsService->startOperationCall( op );
         connect( deleteJob, SIGNAL(finished(KJob*)), gtfsService, SLOT(deleteLater()) );
     }
 }
 
 void Project::updateGtfsDatabaseState()
 {
     Q_D( Project );
     Plasma::ServiceJob *updateJob = qobject_cast< Plasma::ServiceJob* >( sender() );
     d->updateGtfsDatabaseState( updateJob != 0 );
 }
 
 void Project::gtfsDatabaseImportFinished( KJob *importJob )
 {
     Q_D( Project );
     if ( importJob->error() == 0 ) {
         d->setGtfsDatabaseState( GtfsDatabaseImportFinished );
     } else {
         d->gtfsDatabaseErrorString = importJob->errorString();
         d->setGtfsDatabaseState( GtfsDatabaseError );
         emit gtfsDatabaseErrorStringChanged( d->gtfsDatabaseErrorString );
     }
 }
 
 void Project::gtfsDatabaseImportProgress( KJob *importJob, ulong percent )
 {
     Q_UNUSED( importJob );
     Q_D( Project );
     d->gtfsFeedImportProgress = percent;
     emit gtfsFeedImportProgressChanged( percent );
 }
 
 void Project::gtfsDatabaseImportInfoMessage( KJob *importJob, const QString &plain,
                                              const QString &rich )
 {
     Q_UNUSED( importJob );
     Q_UNUSED( rich );
     Q_D( Project );
     d->gtfsFeedImportInfoMessage = plain;
     emit gtfsFeedImportInfoMessageChanged( d->gtfsFeedImportInfoMessage );
 }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
 bool Project::isTestRunning() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isTestRunning();
 }
 
 bool Project::isDebuggerRunning() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isDebuggerRunning();
 }
 
 QStringList Project::scriptFunctions()
 {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->globalFunctions;
 #else
     return QStringList();
 #endif
 }
 
 QStringList Project::includedFiles()
 {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->includedFiles;
 #else
     return QStringList();
 #endif
 }
 
 void Project::startTests( const QList< TestModel::Test > &tests )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->startTests( tests );
 }
 
 bool Project::startTest( TestModel::Test test )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->startTest( test );
 }
 
 bool Project::startTestCase( TestModel::TestCase testCase )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     bool finishedAfterThisTestCase = false;
     if ( !isTestRunning() ) {
         if ( !d->beginTesting(TestModel::testsOfTestCase(testCase)) ) {
             // Test could not be started
             return false;
         } else {
             // Test started, only running one test
             finishedAfterThisTestCase = true;
         }
     }
 
     const QList< TestModel::Test > tests = TestModel::testsOfTestCase( testCase );
     bool success = tests.isEmpty();
     foreach ( TestModel::Test test, tests ) {
         if ( startTest(test)  ) {
             success = true;
         }
 
         if ( d->testState == ProjectPrivate::TestsGetAborted ) {
             break;
         }
     }
 
     if ( finishedAfterThisTestCase
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         && testCase != TestModel::ScriptExecutionTestCase
 #endif
     ) {
         d->endTesting();
     }
     return success;
 }
 
 void Project::testProject()
 {
     Q_D( Project );
     d->mutex->lock();
     if ( !d->askForProjectActivation(ProjectPrivate::ActivateProjectForTests) ||
          !d->beginTesting(TestModel::allTests()) )
     {
         d->mutex->unlock();
         return;
     }
     d->testModel->clear();
     d->mutex->unlock();
 
     startTestCase( TestModel::ServiceProviderDataTestCase ); // This test case runs synchronously
     startTestCase( TestModel::GtfsTestCase ); // TODO This test case runs synchronously
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     // Run the script and check the results
     if ( !startTestCase(TestModel::ScriptExecutionTestCase) ) {
         QMutexLocker locker( d->mutex );
         d->endTesting();
         return;
     }
 
     QMutexLocker locker( d->mutex );
     if ( d->testState == ProjectPrivate::TestsGetAborted ) {
         d->endTesting();
     }
 #endif
 }
 
 QList< TestModel::Test > Project::startedTests() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->startedTests;
 }
 
 QList< TestModel::Test > Project::finishedTests() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->finishedTests;
 }
 
 void Project::abortTests()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->abortTests();
 }
 
 void Project::clearTestResults()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->testModel->clear();
     d->updateProjectActions( QList< ProjectAction >() << ClearTestResults );
 }
 
 TestModel::Test Project::testFromObjectName( const QString &objectName )
 {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     if ( objectName == QLatin1String("TEST_LOAD") ) {
         return TestModel::LoadScriptTest;
     } else if ( objectName == QLatin1String("TEST_DEPARTURES") ) {
         return TestModel::DepartureTest;
     } else if ( objectName == QLatin1String("TEST_ARRIVALS") ) {
         return TestModel::ArrivalTest;
     } else if ( objectName == QLatin1String("TEST_ADDITIONAL_DATA") ) {
         return TestModel::AdditionalDataTest;
     } else if ( objectName == QLatin1String("TEST_STOP_SUGGESTIONS") ) {
         return TestModel::StopSuggestionTest;
     } else if ( objectName == QLatin1String("TEST_STOP_SUGGESTIONS_BYGEOPOSITION") ) {
         return TestModel::StopsByGeoPositionTest;
     } else if ( objectName == QLatin1String("TEST_JOURNEYS") ) {
         return TestModel::JourneyTest;
     } else if ( objectName == QLatin1String("TEST_FEATURES") ) {
         return TestModel::FeaturesTest;
     }
 #else
     Q_UNUSED( objectName );
 #endif
 
     return TestModel::InvalidTest;
 }
 
 void Project::testJobStarted( TestModel::Test test, JobType type, const QString &useCase )
 {
     Q_UNUSED(type)
     Q_UNUSED(useCase);
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( test == TestModel::InvalidTest ) {
-        kWarning() << "Unknown test job was started";
+        qWarning() << "Unknown test job was started";
         return;
     }
 
     d->testModel->markTestAsStarted( test );
 #else
     Q_UNUSED(test);
 #endif
 }
 
 void Project::testJobDone( TestModel::Test test, JobType type, const QString &useCase,
                            const DebuggerJobResult &result )
 {
     Q_UNUSED(type);
     Q_UNUSED(useCase);
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( test == TestModel::InvalidTest ) {
-        kWarning() << "Unknown test" << test;
+        qWarning() << "Unknown test" << test;
     } else {
         d->pendingTests.remove( test );
     }
 
     TestModel::TestState testState = d->testModel->setTestState( test,
             TestModel::testStateFromBool(result.success),
             result.explanation, QString(), projectAction(ShowScript),
             result.messages, result.resultData, result.request );
     if ( result.aborted ) {
         appendOutput( i18nc("@info", "Test \"%1\" was aborted for %2.",
                             TestModel::nameForTest(test), d->data()->id()),
                 KColorScheme(QPalette::Active).foreground(KColorScheme::NeutralText).color() );
     } else if ( result.success && testState != TestModel::TestFinishedWithErrors ) {
         if ( testState == TestModel::TestFinishedWithWarnings ) {
             appendOutput( i18nc("@info", "Test \"%1\" finished with warnings for %2.",
                                 TestModel::nameForTest(test), d->data()->id()),
                     KColorScheme(QPalette::Active).foreground(KColorScheme::NeutralText).color() );
         } else {
             appendOutput( i18nc("@info", "Test \"%1\" was successful for %2.",
                                 TestModel::nameForTest(test), d->data()->id()),
                     KColorScheme(QPalette::Active).foreground(KColorScheme::PositiveText).color() );
         }
     } else {
         appendOutput( i18nc("@info", "Test \"%1\" failed for %2.",
                             TestModel::nameForTest(test), d->data()->id()),
                 KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color() );
     }
 
     d->testFinished( test );
 #else
     // Test jobs are (currently) only used by script execution tests
     Q_UNUSED( test );
     Q_UNUSED( result );
 #endif
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void Project::jobStarted( JobType type, const QString &useCase,
                           const QString &objectName )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( type == Debugger::EvaluateInContext && d->debugger->runningJobs().count() > 1 ) {
         appendOutput( i18nc("@info",
                 "<para><emphasis>Begin child job:</emphasis> %1 (%2)</para>",
                 useCase, QTime::currentTime().toString()) );
     } else {
         appendOutput( (d->output.isEmpty() ? QString() : "<div style='height:10px;'>&nbsp;</div>")
                 + i18nc("@info", "<para><emphasis strong='1'>Begin:</emphasis> %1 (%2)</para>",
                         useCase, QTime::currentTime().toString()) );
     }
 
     TestModel::Test test = testFromObjectName( objectName );
     if ( test != TestModel::InvalidTest ) {
         testJobStarted( test, type, useCase );
     }
 }
 
 void Project::jobDone( JobType type, const QString &useCase, const QString &objectName,
                        const DebuggerJobResult &result )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     QString returnValue = Global::encodeHtmlEntities( result.returnValue.toString(),
                                                       Global::EncodeLessAndGreaterThan );
     if ( returnValue.isEmpty() ) {
         returnValue = "undefined";
     }
     TestModel::Test test = testFromObjectName( objectName );
     if ( test == TestModel::InvalidTest && type == Debugger::LoadScript && d->isTestRunning() ) {
-        kWarning() << "LoadScriptJob done while testing without objectName set to TEST_LOAD";
+        qWarning() << "LoadScriptJob done while testing without objectName set to TEST_LOAD";
         test = TestModel::LoadScriptTest;
     }
 
     if ( test != TestModel::InvalidTest ) {
         testJobDone( test, type, useCase, result );
     }
     if ( type == Debugger::EvaluateInContext && d->debugger->hasRunningJobs() ) {
         appendOutput( i18nc("@info",
                 "<para><emphasis>End child job:</emphasis> %1, result: %2 (%3)</para>",
                 useCase, returnValue, QTime::currentTime().toString()) );
     } else {
         appendOutput( i18nc("@info",
                 "<para><emphasis strong='1'>End:</emphasis> %1, result: %2 (%3)</para>",
                 useCase, returnValue, QTime::currentTime().toString()) );
     }
 }
 
 void Project::evaluationResult( const EvaluationResult &result )
 {
     if ( result.error ) {
         if ( result.backtrace.isEmpty() ) {
             appendToConsole( i18nc("@info", "Error: <message>%1</message>", result.errorMessage) );
         } else {
             appendToConsole( i18nc("@info", "Error: <message>%1</message><nl />"
                                    "Backtrace: <message>%2</message>",
                                    result.errorMessage, result.backtrace.join("<br />")) );
         }
     } else {
         appendToConsole( Global::encodeHtmlEntities(result.returnValue,
                                                     Global::EncodeLessAndGreaterThan) );
     }
 }
 
 void Project::commandExecutionResult( const QString &returnValue, bool error )
 {
     Q_UNUSED( error );
     appendToConsole( returnValue );
 }
 
 void Project::functionCallResult( const QSharedPointer< AbstractRequest > &request,
                                   bool success, const QString &explanation,
                                   const QList< TimetableData >& timetableData,
                                   const QVariant &returnValue )
 {
     Q_UNUSED( request );
     if ( timetableData.isEmpty() ) {
         if ( !returnValue.toString().isEmpty() ) {
             appendOutput( i18nc("@info", "Script execution has finished without results and "
                                 "returned <icode>%1</icode>.", returnValue.toString()),
                     KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color() );
         } else {
             appendOutput( i18nc("@info", "Script execution has finished without results."),
                     KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color() );
         }
     } else if ( !returnValue.toString().isEmpty() ) {
         appendOutput( i18ncp("@info",
                 "Script execution has finished with %1 result and returned <icode>%2</icode>.",
                 "Script execution has finished with %1 results and returned <icode>%2</icode>.",
                 timetableData.count(), returnValue.toString()),
                 KColorScheme(QPalette::Active).foreground(
                     success ? KColorScheme::PositiveText : KColorScheme::NegativeText).color() );
     } else {
         appendOutput( i18ncp("@info", "Script execution has finished with %1 result.",
                 "Script execution has finished with %1 results.", timetableData.count()),
                 KColorScheme(QPalette::Active).foreground(
                     success ? KColorScheme::PositiveText : KColorScheme::NegativeText).color() );
     }
 
     if ( !success ) {
         // Emit an information message about the error (no syntax errors here)
         emit informationMessage( explanation, KMessageWidget::Error, 10000 );
     }
 }
 
 bool Project::suppressMessages() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->suppressMessages || d->isTestRunning();
 }
 
 void Project::setQuestionsEnabled( bool enable )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->enableQuestions = enable;
 }
 
 void Project::loadScriptResult( ScriptErrorType lastScriptError,
                                 const QString &lastScriptErrorString,
                                 const QStringList &globalFunctions,
                                 const QStringList &includedFiles )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->suppressMessages = false;
     if ( lastScriptError != NoScriptError ) {
         // Emit an information message about the error (eg. a syntax error)
         d->globalFunctions.clear();
         d->includedFiles.clear();
         d->lastScriptError = lastScriptError;
         d->lastScriptErrorString = lastScriptErrorString;
         d->scriptState = ProjectPrivate::ScriptNotLoaded;
         if ( !d->suppressMessages ) {
             emit informationMessage( lastScriptErrorString, KMessageWidget::Error, 10000 );
         }
     } else {
         d->globalFunctions = globalFunctions;
         d->includedFiles = includedFiles;
         d->lastScriptError = Debugger::NoScriptError;
         d->lastScriptErrorString.clear();
         d->scriptState = ProjectPrivate::ScriptLoaded;
     }
     d->updateProjectActions( QList<ProjectActionGroup>() << RunActionGroup << TestActionGroup
                                                          << DebuggerActionGroup );
 
     emit debuggerReady();
 }
 
 void Project::runGetTimetable()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetTimetable( Debugger::InterruptOnExceptions );
 }
 
 void Project::debugGetTimetable()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetTimetable( InterruptOnExceptionsAndBreakpoints );
 }
 
 void Project::runGetStopSuggestions()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetStopSuggestions( Debugger::InterruptOnExceptions );
 }
 
 void Project::runGetStopsByGeoPosition()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetStopsByGeoPosition( Debugger::InterruptOnExceptions );
 }
 
 void Project::debugGetStopSuggestions()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetStopSuggestions( InterruptOnExceptionsAndBreakpoints );
 }
 
 void Project::debugGetStopsByGeoPosition()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetStopsByGeoPosition( InterruptOnExceptionsAndBreakpoints );
 }
 
 void Project::runGetJourneys()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetJourneys( Debugger::InterruptOnExceptions );
 }
 
 void Project::debugGetJourneys()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->callGetJourneys( InterruptOnExceptionsAndBreakpoints );
 }
 #endif
 
 DepartureRequest Project::getDepartureRequest( QWidget *parent, bool* cancelled ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     parent = d->parentWidget( parent );
 
     QPointer<KDialog> dialog = new KDialog( parent );
     QWidget *w = new QWidget( dialog );
     QFormLayout *l = new QFormLayout( w );
     KLineEdit *city = 0;
     const QStringList stops = d->provider->data()->sampleStopNames();
     KLineEdit *stop = new KLineEdit( stops.isEmpty() ? QString() : stops.first(), w );
     KComboBox *dataType = new KComboBox( w );
     KDateTimeWidget *dateTime = new KDateTimeWidget( QDateTime::currentDateTime(), w );
     dataType->addItem( i18nc("@info/plain", "Departures"), "departures" );
     dataType->addItem( i18nc("@info/plain", "Arrivals"), "arrivals" );
     if ( d->provider->data()->useSeparateCityValue() ) {
         city = new KLineEdit( w );
         l->addRow( i18nc("@info", "City:"), city );
     }
     l->addRow( i18nc("@info", "Stop Name:"), stop );
     l->addRow( i18nc("@info", "Data Type:"), dataType );
     l->addRow( i18nc("@info", "Time:"), dateTime );
     dialog->setMainWidget( w );
     if ( d->provider && !d->provider->data()->sampleStopNames().isEmpty() ) {
         // Use first sample stop name by default
         stop->setText( d->provider->data()->sampleStopNames().first() );
         if ( city ) {
             city->setText( d->provider->data()->sampleCity() );
         }
     }
     stop->setFocus();
 
     // Show the dialog
     int result = dialog->exec();
     DepartureRequest request;
     if ( result == KDialog::Accepted ) {
         request.setCity( city ? city->text() : QString() );
         request.setStop( stop->text() );
         request.setDateTime( dateTime->dateTime() );
         request.setParseMode( dataType->itemData( dataType->currentIndex() ).toString()
                 == QLatin1String("arrivals") ? ParseForArrivals : ParseForDepartures );
     }
     if ( cancelled ) {
         *cancelled = result != KDialog::Accepted;
     }
 
     delete dialog;
     return request;
 }
 
 StopSuggestionRequest Project::getStopSuggestionRequest( QWidget *parent,
                                                          bool* cancelled ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     parent = d->parentWidget( parent );
 
     QPointer<KDialog> dialog = new KDialog( parent );
     QWidget *w = new QWidget( dialog );
     QFormLayout *l = new QFormLayout( w );
     KLineEdit *city = 0;
     KLineEdit *stop = new KLineEdit( w );
     if ( d->provider->data()->useSeparateCityValue() ) {
         city = new KLineEdit( w );
         l->addRow( i18nc("@info", "City:"), city );
     }
     l->addRow( i18nc("@info", "Partial Stop Name:"), stop );
     dialog->setMainWidget( w );
     stop->setFocus();
 
     StopSuggestionRequest request;
     int result = dialog->exec();
     if ( result == KDialog::Accepted ) {
         request.setCity( city ? city->text() : QString() );
         request.setStop( stop->text() );
     }
     if ( cancelled ) {
         *cancelled = result != KDialog::Accepted;
     }
 
     delete dialog;
     return request;
 }
 
 StopsByGeoPositionRequest Project::getStopsByGeoPositionRequest(
         QWidget *parent, bool *cancelled ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     parent = d->parentWidget( parent );
 
 #ifdef MARBLE_FOUND
     QPointer<KDialog> dialog = new KDialog( parent );
     QWidget *w = new QWidget( dialog );
     QFormLayout *l = new QFormLayout( w );
     Marble::LatLonEdit *longitude = new Marble::LatLonEdit( w, Marble::Longitude );
     Marble::LatLonEdit *latitude = new Marble::LatLonEdit( w, Marble::Latitude );
     KIntSpinBox *distance = new KIntSpinBox( 500, 50000, 1, 5000, w );
     distance->setSuffix( "m" ); // meters
     longitude->setValue( d->provider->data()->sampleLongitude() );
     latitude->setValue( d->provider->data()->sampleLatitude() );
     l->addRow( i18nc("@info", "Longitude:"), longitude );
     l->addRow( i18nc("@info", "Latitude:"), latitude );
     l->addRow( i18nc("@info", "Distance:"), distance );
     dialog->setMainWidget( w );
     longitude->setFocus();
 
     StopsByGeoPositionRequest request;
     int result = dialog->exec();
     if ( result == KDialog::Accepted ) {
         request.setLongitude( longitude->value() );
         request.setLatitude( latitude->value() );
         request.setDistance( distance->value() );
     }
     if ( cancelled ) {
         *cancelled = result != KDialog::Accepted;
     }
 
     delete dialog;
     return request;
 #else
     // Marble was not found
     KMessageBox::information( parent, i18nc("@info", "Cannot use Marble widgets for "
                                                      "latitude/longitude input.") );
     return StopsByGeoPositionRequest();
 #endif
 }
 
 JourneyRequest Project::getJourneyRequest( QWidget *parent, bool* cancelled ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     parent = d->parentWidget( parent );
     QPointer<KDialog> dialog = new KDialog( parent );
     QWidget *w = new QWidget( dialog );
     QFormLayout *l = new QFormLayout( w );
     KLineEdit *city = 0;
     const QStringList stops = d->provider->data()->sampleStopNames();
     KLineEdit *originStop = new KLineEdit( stops.isEmpty() ? QString() : stops.first(), w );
     KLineEdit *targetStop = new KLineEdit( stops.count() < 2 ? QString() : stops[1], w );
     KComboBox *dataType = new KComboBox( w );
     KDateTimeWidget *dateTime = new KDateTimeWidget( QDateTime::currentDateTime(), w );
     dataType->addItem( i18nc("@info/plain", "Departing at Given Time"), "dep" );
     dataType->addItem( i18nc("@info/plain", "Arriving at Given Time"), "arr" );
     if ( d->provider->data()->useSeparateCityValue() ) {
         city = new KLineEdit( w );
         l->addRow( i18nc("@info", "City:"), city );
     }
     l->addRow( i18nc("@info", "Start Stop Name:"), originStop );
     l->addRow( i18nc("@info", "Target Stop Name:"), targetStop );
     l->addRow( i18nc("@info", "Time:"), dateTime );
     l->addRow( i18nc("@info", "Meaning of Time:"), dataType );
     dialog->setMainWidget( w );
     if ( d->provider && !d->provider->data()->sampleStopNames().isEmpty() ) {
         // Use sample stop names by default
         originStop->setText( d->provider->data()->sampleStopNames().first() );
         if ( d->provider->data()->sampleStopNames().count() >= 2 ) {
             targetStop->setText( d->provider->data()->sampleStopNames()[1] );
         }
         if ( city ) {
             city->setText( d->provider->data()->sampleCity() );
         }
     }
     originStop->setFocus();
 
     JourneyRequest request;
     int result = dialog->exec();
     if ( result == KDialog::Accepted ) {
         request.setCity( city ? city->text() : QString() );
         request.setStop( originStop->text() );
         request.setTargetStop( targetStop->text() );
         request.setDateTime( dateTime->dateTime() );
         request.setParseMode( dataType->itemData( dataType->currentIndex() ).toString()
                 == QLatin1String("arr") ? ParseForJourneysByArrivalTime
                                         : ParseForJourneysByDepartureTime );
     }
     if ( cancelled ) {
         *cancelled = result != KDialog::Accepted;
     }
 
     delete dialog;
     return request;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void Project::abortDebugger()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( !d->debugger->isRunning() && !d->debugger->isInterrupted() ) {
         // The abort action should have been disabled,
         // no stopped signal received? Update UI state to debugger state
         kDebug() << "Internal error, debugger not running, update UI state";
         d->updateProjectActions( QList<ProjectActionGroup>() << RunActionGroup << TestActionGroup
                                                              << DebuggerActionGroup );
     } else {
         d->debugger->abortDebugger();
     }
 }
 
 void Project::toggleBreakpoint( int lineNumber )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     ScriptTab *scriptTab = d->currentScriptTab();
     if ( !scriptTab ) {
         kDebug() << "No script tab opened";
         return;
     }
 
     scriptTab->toggleBreakpoint( lineNumber );
 }
 
 void Project::runToCursor()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     ScriptTab *scriptTab = d->currentScriptTab();
     if ( !scriptTab ) {
         kError() << "No script tab opened";
         return;
     }
 
     const KTextEditor::View *view = scriptTab->document()->activeView();
     d->debugger->debugRunUntilLineNumber( scriptTab->fileName(), view->cursorPosition().line() + 1 );
 }
 
 void Project::debugInterrupted( int lineNumber, const QString &fileName,
                                 const QDateTime &timestamp )
 {
     Q_UNUSED( timestamp );
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( !d->debugger->hasUncaughtException() ) {
         // Show script tab and ask to activate the project if it's not already active
         ScriptTab *tab = fileName == scriptFileName() || fileName.isEmpty()
                 ? showScriptTab() : showExternalScriptTab(fileName);
         d->askForProjectActivation( ProjectPrivate::ActivateProjectForDebugging );
         d->updateProjectActions( QList<ProjectActionGroup>() << RunActionGroup << TestActionGroup
                                                             << DebuggerActionGroup );
 
         tab->setExecutionPosition( lineNumber );
     }
 
     // Update title of all script tabs
     if ( d->scriptTab ) {
         d->scriptTab->slotTitleChanged();
     }
     foreach ( ScriptTab *externalTab, d->externalScriptTabs ) {
         externalTab->slotTitleChanged();
     }
 }
 
 void Project::debugContinued()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->updateProjectActions( QList<ProjectActionGroup>() << RunActionGroup << TestActionGroup
                                                       << DebuggerActionGroup );
 }
 
 void Project::debugStarted()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->updateProjectActions( QList<ProjectActionGroup>() << RunActionGroup << TestActionGroup
                                                       << DebuggerActionGroup );
     if ( d->scriptTab ) {
         d->scriptTab->slotTitleChanged();
     }
     emit debuggerRunningChanged( true );
 }
 
 void Project::debugStopped( const ScriptRunData &scriptRunData )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->updateProjectActions( QList<ProjectActionGroup>() << RunActionGroup << TestActionGroup
                                                          << DebuggerActionGroup );
 
     QString message = i18nc("@info Shown in project output, %1: Current time",
                             "<emphasis>Statistics:</emphasis>");
     message.append( "<br />" );
     message.append( i18nc("@info %1 is a formatted duration string",
                             "- %1 spent for script execution",
                             KGlobal::locale()->formatDuration(scriptRunData.executionTime())) );
     if ( scriptRunData.interruptTime() > 0 ) {
         message.append( "<br />" );
         message.append( i18nc("@info %1 is a formatted duration string",
                               "- %1 interrupted",
                               KGlobal::locale()->formatDuration(scriptRunData.interruptTime())) );
     }
     if ( scriptRunData.signalWaitingTime() > 0 ) {
         message.append( "<br />" );
         message.append( i18nc("@info %1 is a formatted duration string",
                               "- %1 spent waiting for signals (eg. asynchronous network requests)",
                               KGlobal::locale()->formatDuration(scriptRunData.signalWaitingTime())) );
     }
     if ( scriptRunData.synchronousDownloadTime() > 0 ) {
         message.append( "<br />" );
         message.append( i18nc("@info %1 is a formatted duration string",
                               "- %1 spent for synchronous downloads",
                               KGlobal::locale()->formatDuration(scriptRunData.synchronousDownloadTime())) );
     }
     if ( scriptRunData.asynchronousDownloadSize() > 0 ||
          scriptRunData.synchronousDownloadSize() > 0 )
     {
         message.append( "<br />" );
         if ( scriptRunData.asynchronousDownloadSize() == scriptRunData.totalDownloadSize() ) {
             message.append( i18nc("@info %1 is a formatted byte size string",
                                 "- %1 downloaded in asynchronous requests",
                                 KGlobal::locale()->formatByteSize(scriptRunData.asynchronousDownloadSize())) );
         } else if ( scriptRunData.synchronousDownloadSize() == scriptRunData.totalDownloadSize() ) {
             message.append( i18nc("@info %1 is a formatted byte size string",
                                 "- %1 downloaded in synchronous requests",
                                 KGlobal::locale()->formatByteSize(scriptRunData.synchronousDownloadSize())) );
         } else {
             QString details;
             if ( scriptRunData.asynchronousDownloadSize() > 0 ) {
                 details.append( i18nc("@info %1 is a formatted byte size string",
                         "%1 in asynchronous requests",
                         KGlobal::locale()->formatByteSize(scriptRunData.asynchronousDownloadSize())) );
             }
             if ( scriptRunData.synchronousDownloadSize() > 0 ) {
                 if ( !details.isEmpty() ) {
                     details.append( ", " );
                 }
                 details.append( i18nc("@info 1 is a formatted byte size string",
                         "%1 in synchronous requests",
                         KGlobal::locale()->formatByteSize(scriptRunData.synchronousDownloadSize())) );
             }
             message.append( i18nc("@info %1 is a formatted byte size string, %2 a translated details "
                                 "string (how much was downloaded in synchronous/asynchronous requests)",
                                 "- %1 downloaded (%2)",
                                 KGlobal::locale()->formatByteSize(scriptRunData.asynchronousDownloadSize()),
                                 details) );
         }
     }
     appendOutput( message );
 
     if ( d->scriptTab ) {
         d->scriptTab->slotTitleChanged();
     }
 
     emit debuggerRunningChanged( false );
     emit debuggerReady();
 }
 
 void Project::debugAborted()
 {
     appendOutput( i18nc("@info", "(Debugger aborted)"),
                   KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color() );
 }
 
 void Project::waitingForSignal()
 {
     appendOutput( i18nc("@info", "Waiting for a signal (%1)",
                         QTime::currentTime().toString()) );
 }
 
 void Project::wokeUpFromSignal( int time )
 {
     appendOutput( i18nc("@info", "Signal received, waiting time: %1 (%2)",
                         KGlobal::locale()->formatDuration(time), QTime::currentTime().toString()) );
 }
 
 void Project::scriptException( int lineNumber, const QString &errorMessage, const QString &fileName )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     ScriptTab *tab;
     if ( fileName == d->provider->data()->scriptFileName() || fileName.isEmpty() ) {
         appendOutput( i18nc("@info For the script output dock",
                             "<emphasis strong='1'>Uncaught exception at %1:</emphasis> <message>%2</message>",
                             lineNumber, errorMessage),
                       KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color() );
         tab = showScriptTab();
     } else {
         appendOutput( i18nc("@info For the script output dock",
                             "<emphasis strong='1'>Uncaught exception in script <filename>%1</filename> "
                             "at %2:</emphasis> <message>%3</message>",
                             QFileInfo(fileName).fileName(), lineNumber, errorMessage),
                       KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color() );
         tab = showExternalScriptTab( fileName );
     }
 
     if ( !d->suppressMessages && tab ) {
         tab->goToLine( lineNumber );
     }
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 QString Project::scriptFileName() const
 {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->provider->data()->scriptFileName();
 #else
     return QString();
 #endif
 }
 
 QIcon Project::scriptIcon() const
 {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     if ( d->scriptTab ) {
         return KIcon( d->scriptTab->document()->mimeType().replace('/', '-') );
     } else
 #endif
     {
         return KIcon("application-javascript");
     }
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 QString Project::scriptTemplateText( ScriptTemplateType templateType,
                                      const ServiceProviderData *data )
 {
     return ProjectPrivate::scriptTemplateText( templateType, data );
 }
 
 void Project::scriptAdded( const QString &fileName )
 {
     kDebug() << fileName;
 }
 
 void Project::scriptFileChanged( const QString &fileName )
 {
     kDebug() << fileName;
 }
 #endif
 
 void Project::slotTabTitleChanged( const QString &title )
 {
     AbstractTab *tab = qobject_cast< AbstractTab* >( sender() );
     Q_ASSERT( tab );
 
     emit tabTitleChanged( tab, title, tab->icon() );
 }
 
 void Project::slotModifiedStateChanged()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     const bool modified = isModified();
     d->updateProjectActions( QList<ProjectAction>() << Save );
     emit modifiedStateChanged( modified );
 }
 
 void Project::slotTabCloseRequest()
 {
     AbstractTab *tab = qobject_cast< AbstractTab* >( sender() );
     Q_ASSERT( tab );
     emit tabCloseRequest( tab );
 }
 
 void Project::slotOtherTabsCloseRequest()
 {
     AbstractTab *tab = qobject_cast< AbstractTab* >( sender() );
     Q_ASSERT( tab );
     emit otherTabsCloseRequest( tab );
 }
 
 AbstractTab *Project::tab( TabType type ) const
 {
     switch ( type ) {
     case Tabs::Dashboard:
         return dashboardTab();
     case Tabs::ProjectSource:
         return projectSourceTab();
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Tabs::Script:
         return scriptTab();
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case Tabs::GtfsDatabase:
         return gtfsDatabaseTab();
 #endif
     case Tabs::Web:
         return webTab();
     case Tabs::PlasmaPreview:
         return plasmaPreviewTab();
     default:
-        kWarning() << "Unknown tab type" << type;
+        qWarning() << "Unknown tab type" << type;
         return 0;
     }
 }
 
 AbstractTab *Project::showTab( TabType type, QWidget *parent )
 {
     switch ( type ) {
     case Tabs::Dashboard:
         return showDashboardTab( parent );
     case Tabs::ProjectSource:
         return showProjectSourceTab( parent );
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Tabs::Script:
         return showScriptTab( parent );
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case Tabs::GtfsDatabase:
         return showGtfsDatabaseTab( parent );
 #endif
     case Tabs::Web:
         return showWebTab( parent );
     case Tabs::PlasmaPreview:
         return showPlasmaPreviewTab( parent );
     default:
-        kWarning() << "Unknown tab type" << type;
+        qWarning() << "Unknown tab type" << type;
         return 0;
     }
 }
 
 bool Project::isTabOpened( TabType type ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     switch ( type ) {
     case Tabs::Dashboard:
         return d->dashboardTab;
     case Tabs::ProjectSource:
         return d->projectSourceTab;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Tabs::Script:
         return d->scriptTab;
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case Tabs::GtfsDatabase:
         return d->gtfsDatabaseTab;
 #endif
     case Tabs::Web:
         return d->webTab;
     case Tabs::PlasmaPreview:
         return d->plasmaPreviewTab;
     default:
         return false;
     }
 }
 
 AbstractTab *Project::createTab( TabType type, QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     parent = d->parentWidget( parent );
     switch ( type ) {
     case Tabs::Dashboard:
         return createDashboardTab( parent );
     case Tabs::ProjectSource:
         return createProjectSourceTab( parent );
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Tabs::Script:
         return createScriptTab( parent );
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case Tabs::GtfsDatabase:
         return createGtfsDatabaseTab( parent );
 #endif
     case Tabs::Web:
         return createWebTab( parent );
     case Tabs::PlasmaPreview:
         return createPlasmaPreviewTab( parent );
     default:
         return 0;
     }
 }
 
 void Project::closeTab( TabType type )
 {
     AbstractTab *tabOfType = tab( type );
     if ( tabOfType ) {
         emit tabCloseRequest( tabOfType );
     }
 }
 
 void Project::closeTab( AbstractTab *tab )
 {
     emit tabCloseRequest( tab );
 }
 
 PlasmaPreviewTab *Project::createPlasmaPreviewTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
 
     // Create plasma preview tab
     parent = d->parentWidget( parent );
     d->plasmaPreviewTab = PlasmaPreviewTab::create( this, parent );
     if ( d->plasmaPreviewTab ) {
         // Connect default tab slots with the tab
         connect( d->plasmaPreviewTab, SIGNAL(destroyed(QObject*)),
                  this, SLOT(plasmaPreviewTabDestroyed()) );
         d->connectTab( d->plasmaPreviewTab );
         return d->plasmaPreviewTab;
     } else {
         d->errorHappened( PlasmaPreviewError, i18nc("@info", "Cannot create Plasma preview") );
         return 0;
     }
 }
 
 WebTab *Project::createWebTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
 
     // Create web widget
     parent = d->parentWidget( parent );
     d->webTab = WebTab::create( this, parent );
     if ( d->webTab ) {
         // Connect default tab slots with the tab
         connect( d->webTab, SIGNAL(destroyed(QObject*)),
                  this, SLOT(webTabDestroyed()) );
         d->connectTab( d->webTab );
 
         // Load the service providers home page
         qApp->processEvents();
         d->webTab->webView()->setUrl( d->provider->data()->url() );
         return d->webTab;
     } else {
         d->errorHappened( WebError, i18nc("@info", "Cannot create web widget") );
         return 0;
     }
 }
 
 DashboardTab *Project::createDashboardTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
 
     // Create dashboard widget
     parent = d->parentWidget( parent );
     d->dashboardTab = DashboardTab::create( this, parent );
     if ( d->dashboardTab ) {
         // Connect default tab slots with the tab
         connect( d->dashboardTab, SIGNAL(destroyed(QObject*)),
                  this, SLOT(dashboardTabDestroyed()) );
         d->connectTab( d->dashboardTab );
 
         return d->dashboardTab;
     } else {
         d->errorHappened( WebError, i18nc("@info", "Cannot create dashboard widget") );
         return 0;
     }
 }
 
 ProjectSourceTab *Project::createProjectSourceTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
 
     if ( d->projectSourceTab ) {
-        kWarning() << "Project source tab already created";
+        qWarning() << "Project source tab already created";
         return d->projectSourceTab;
     }
 
     // Get project source text
     const QString text = projectSourceText( ReadProjectDocumentFromBuffer );
 
     // Try to create a project source document tab
     parent = d->parentWidget( parent );
     d->projectSourceTab = ProjectSourceTab::create( this, parent );
     if ( !d->projectSourceTab ) {
         d->errorHappened( KatePartError, i18nc("@info", "Service katepart.desktop not found") );
         return 0;
     }
 
     // Connect slots with the document
     KTextEditor::Document *document = d->projectSourceTab->document();
     connect( document, SIGNAL(setStatusBarText(QString)),
              this, SIGNAL(informationMessage(QString)) );
     connect( document, SIGNAL(textChanged(KTextEditor::Document*)),
              this, SLOT(projectSourceDocumentChanged(KTextEditor::Document*)));
 
     // Connect slots with the view
     KTextEditor::View *projectSourceView = document->views().first();
     connect( projectSourceView, SIGNAL(informationMessage(KTextEditor::View*,QString)),
              this, SLOT(slotInformationMessage(KTextEditor::View*,QString)) );
 
     // Connect default tab slots with the tab
     d->connectTab( d->projectSourceTab );
     connect( d->projectSourceTab, SIGNAL(destroyed(QObject*)),
              this, SLOT(projectSourceTabDestroyed()) );
     connect( d->projectSourceTab, SIGNAL(modifiedStatusChanged(bool)),
              this, SIGNAL(projectSourceModifiedStateChanged(bool)) );
 
     if ( d->setProjectSourceDocumentText(text) ) {
         d->projectSourceTab->document()->setModified( false );
     }
     return d->projectSourceTab;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
 GtfsDatabaseTab *Project::createGtfsDatabaseTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
 
     if ( d->gtfsDatabaseTab ) {
-        kWarning() << "GTFS database tab already created";
+        qWarning() << "GTFS database tab already created";
         return d->gtfsDatabaseTab;
     }
 
     // Try to create a GTFS database tab
     parent = d->parentWidget( parent );
     d->gtfsDatabaseTab = GtfsDatabaseTab::create( this, parent );
     if ( !d->gtfsDatabaseTab ) {
         d->errorHappened( OtherError, i18nc("@info", "Could not create GTFS database tab") );
         return 0;
     }
 
     // Connect default tab slots with the tab
     d->connectTab( d->gtfsDatabaseTab );
     connect( d->gtfsDatabaseTab, SIGNAL(destroyed(QObject*)),
              this, SLOT(gtfsDatabaseTabDestroyed()) );
 
     return d->gtfsDatabaseTab;
 }
 
 GtfsDatabaseTab *Project::gtfsDatabaseTab() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->gtfsDatabaseTab;
 }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 ScriptTab *Project::createScriptTab( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->scriptTab ) {
-        kWarning() << "Script tab already created";
+        qWarning() << "Script tab already created";
         return d->scriptTab;
     }
 
     // Create script tab
     parent = d->parentWidget( parent );
     d->scriptTab = ScriptTab::create( this, parent );
     if ( !d->scriptTab ) {
-        kWarning() << "Service katepart.desktop not found";
+        qWarning() << "Service katepart.desktop not found";
         d->errorHappened( KatePartError, i18nc("@info", "Service katepart.desktop not found") );
         return 0;
     }
 
     // Try to load the script
     if ( !d->loadScript(NoScriptTemplate) ) {
         // Script not created yet, create the script from a template,
         // ask the user which template to use
         ScriptTemplateType templateType = getScriptTemplateTypeInput( parent );
         if ( templateType == NoScriptTemplate ) {
             delete d->scriptTab;
             d->scriptTab = 0;
             return 0;
         }
 
         d->insertScriptTemplate( templateType );
     }
 
     d->updateProjectActions( QList< ProjectAction >() << ToggleBreakpoint );
 
     // Connect default tab slots with the tab
     d->connectTab( d->scriptTab );
     connect( d->scriptTab, SIGNAL(destroyed(QObject*)),
              this, SLOT(scriptTabDestroyed()) );
     connect( d->scriptTab, SIGNAL(modifiedStatusChanged(bool)),
              this, SIGNAL(scriptModifiedStateChanged(bool)) );
     connect( d->scriptTab, SIGNAL(showDocumentation(QString)),
              this, SIGNAL(showDocumentationRequest(QString)) );
     connect( d->scriptTab, SIGNAL(syntaxErrorFound(QString,QString)),
              this, SLOT(syntaxErrorFound(QString,QString)) );
     return d->scriptTab;
 }
 
 ScriptTab *Project::createExternalScriptTab( const QString &filePath, QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     foreach ( ScriptTab *externalScriptTab, d->externalScriptTabs ) {
         if ( externalScriptTab->fileName() == filePath ) {
-            kWarning() << "Script tab already created";
+            qWarning() << "Script tab already created";
             return externalScriptTab;
         }
     }
 
     // Create script tab
     parent = d->parentWidget( parent );
     ScriptTab *externalScriptTab = ScriptTab::create( this, parent );
     if ( !externalScriptTab ) {
         d->errorHappened( KatePartError, i18nc("@info", "Service katepart.desktop not found") );
         return 0;
     } else if ( !QFile::exists(filePath) ) {
         d->errorHappened( Project::ScriptFileNotFound,
                           i18nc("@info", "The external script file <filename>%1</filename> "
                                 "could not be found.", filePath) );
         delete externalScriptTab;
         return 0;
     } else if ( !externalScriptTab->document()->openUrl(QUrl(filePath)) ) {
         d->errorHappened( Project::ScriptFileNotFound,
                           i18nc("@info", "The external script file <filename>%1</filename> "
                                 "could not be opened.", filePath) );
         delete externalScriptTab;
         return 0;
     }
     externalScriptTab->document()->setModified( false );
 
     emit tabTitleChanged( externalScriptTab, externalScriptTab->title(), externalScriptTab->icon() );
 
     d->updateProjectActions( QList< ProjectAction >() << ToggleBreakpoint );
 
     // Connect default tab slots with the tab
     d->connectTab( externalScriptTab );
     connect( externalScriptTab, SIGNAL(destroyed(QObject*)),
              this, SLOT(externalScriptTabDestroyed(QObject*)) );
 //     connect( externalScriptTab, SIGNAL(modifiedStatusChanged(bool)),
 //              this, SIGNAL(externalScriptModifiedStateChanged(bool)) );
     connect( externalScriptTab, SIGNAL(showDocumentation(QString)),
              this, SIGNAL(showDocumentationRequest(QString)) );
     connect( externalScriptTab, SIGNAL(syntaxErrorFound(QString,QString)),
              this, SLOT(syntaxErrorFound(QString,QString)) );
     return externalScriptTab;
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 ServiceProvider *Project::provider() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     Q_ASSERT( d->provider );
     return d->provider;
 }
 
 Enums::ServiceProviderType Project::providerType() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     Q_ASSERT( d->provider );
     return d->provider->type();
 }
 
 void Project::setProviderData( const ServiceProviderData *providerData )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
 
     // Recreate service provider plugin with new info
     Enums::ServiceProviderType oldType = d->provider ? d->provider->type() : Enums::InvalidProvider;
     if ( providerData == d->provider->data() ) {
         // If the ServiceProviderData object belongs to the old provider,
         // create a clone before deleting it with the provider
         providerData = providerData->clone( this );
     }
     delete d->provider;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     if ( providerData->type() == Enums::ScriptedProvider ) {
         d->provider = new ServiceProviderScript( providerData, this );
     } else
 #endif
     {
         d->provider = new ServiceProvider( providerData, this );
     }
 
     if ( d->provider->type() != oldType ) {
         emit providerTypeChanged( d->provider->type(), oldType );
     }
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     d->updateGtfsDatabaseState();
 #endif
     emit nameChanged( projectName() );
     emit iconNameChanged( iconName() );
     emit iconChanged( projectIcon() );
     emit dataChanged( data() );
     d->testModel->markTestsAsOutdated(
             TestModel::testsOfTestCase(TestModel::ServiceProviderDataTestCase) );
 
     if ( d->projectSourceTab ) {
         // Update service provider plugin document
         d->projectSourceTab->document()->setText( projectSourceText(ReadProjectDocumentFromBuffer) );
     } else {
         const bool wasModified = isModified();
         const bool wasProjectSourceModified = isProjectSourceModified();
         d->projectSourceBufferModified = true;
         if ( !wasModified ) {
             d->updateProjectActions( QList<ProjectAction>() << Save );
             emit modifiedStateChanged( true );
         }
         if ( !wasProjectSourceModified ) {
             emit projectSourceModifiedStateChanged( true );
         }
     }
 }
 
 void Project::showSettingsDialog( QWidget *parent )
 {
     Q_D( Project );
     d->mutex->lock();
 
     // Check if a modified project source tab is opened and ask to save it before
     // editing the file in the settings dialog
     parent = d->parentWidget( parent );
 
     // Create settings dialog
     QPointer< ProjectSettingsDialog > dialog( new ProjectSettingsDialog(parent) );
     dialog->setProviderData( d->provider->data(), d->filePath );
     d->mutex->unlock();
 
     if ( dialog->exec() == KDialog::Accepted ) {
         setProviderData( dialog->providerData(this) );
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         if ( dialog->newScriptTemplateType() != Project::NoScriptTemplate ) {
             // A new script file was set in the dialog
             // Load the chosen template
             setScriptText( Project::scriptTemplateText(dialog->newScriptTemplateType(), d->data()) );
         }
 #endif
     }
     delete dialog.data();
 }
 
 void Project::projectSourceDocumentChanged( KTextEditor::Document *projectSourceDocument )
 {
     Q_D( Project );
     Q_UNUSED( projectSourceDocument );
     QMutexLocker locker( d->mutex );
 
     // Recreate service provider plugin with new XML content
     d->readProjectSourceDocumentFromTabOrFile( d->filePath );
 
     // Update other tabs
     if ( d->webTab ) {
         d->webTab->webView()->setUrl( provider()->data()->url() );
     }
 }
 
 void Project::dashboardTabDestroyed()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->dashboardTab = 0;
 }
 
 void Project::projectSourceTabDestroyed()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->projectSourceTab = 0;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
 void Project::gtfsDatabaseTabDestroyed()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->gtfsDatabaseTab = 0;
 }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void Project::scriptTabDestroyed()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->scriptTab = 0;
     d->updateProjectActions( QList< ProjectAction >() << ToggleBreakpoint );
 }
 
 void Project::externalScriptTabDestroyed( QObject *tab )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     // qobject_cast does not work here, but only the address gets compared in removeOne(),
     // which needs to be casted to the list element type
     for ( int i = 0; i < d->externalScriptTabs.count(); ++i ) {
         if ( qobject_cast<QObject*>(d->externalScriptTabs[i]) == tab ) {
             d->externalScriptTabs.removeAt( i );
             return;
         }
     }
     qWarning() << "Internal error: Script tab destroyed but not found in the list";
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 void Project::plasmaPreviewTabDestroyed()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->plasmaPreviewTab = 0;
 }
 
 void Project::webTabDestroyed()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     d->webTab = 0;
 }
 
 QString Project::projectSourceText( ProjectDocumentSource source) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     if ( !d->provider ) {
         kDebug() << "No service provider plugin loaded";
         return QString();
     }
 
     if ( d->projectSourceTab && (source == ReadProjectDocumentFromTab ||
                             source == ReadProjectDocumentFromTabIfOpened) )
     {
         // Service provider plugin XML file opened in a tab
         return d->projectSourceTab->document()->text();
     } else if ( source == ReadProjectDocumentFromBuffer ||
                 source == ReadProjectDocumentFromTabIfOpened )
     {
         // No project source tab opened, read XML text from file to buffer
         ServiceProviderDataWriter writer;
         QBuffer buffer;
         if( writer.write(&buffer, d->provider, d->xmlComments) ) {
             return QString::fromUtf8( buffer.data() );
         }
     } else if ( source == ReadProjectDocumentFromFile ) {
         if ( d->filePath.isEmpty() ) {
             return QString();
         }
 
         // Open project file
         QFile file( d->filePath );
         if ( !file.open(QIODevice::ReadOnly) ) {
             kDebug() << "Could not open project file" << d->filePath;
             return QString();
         }
 
         // Read and close project file
         const QByteArray ba = file.readAll();
         file.close();
         return QString( ba );
     }
 
     return QString();
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 QString Project::scriptText( const QString &includedScriptFilePath ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     if ( includedScriptFilePath.isEmpty() ) {
         if ( d->scriptTab ) {
             // Script file opened in a tab
             return d->scriptTab->document()->text();
         } else if ( !d->unsavedScriptContents.isEmpty() ) {
             // Unsaved script contents available
             return d->unsavedScriptContents;
         }
     }
 
     // No script tab opened, read script text from file
     const QString fileName = !includedScriptFilePath.isEmpty()
             ? includedScriptFilePath : d->provider->data()->scriptFileName();
     if ( !QFile::exists(fileName) ) {
         return QString();
     }
 
     // Open script file
     QFile file( fileName );
     if ( !file.open(QIODevice::ReadOnly) ) {
         return QString();
     }
 
     // Read and close script file
     const QByteArray ba = file.readAll();
     file.close();
     return QString::fromUtf8( ba );
 }
 
 void Project::setScriptText( const QString &text )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     if ( d->scriptTab ) {
         d->unsavedScriptContents.clear();
         d->scriptTab->document()->setText( text );
     } else {
         const bool wasModified = isModified();
         const bool wasScriptModified = isScriptModified();
 
         d->unsavedScriptContents = text;
         d->updateProjectActions( QList<ProjectAction>() << Save );
 
         if ( !wasModified ) {
             emit modifiedStateChanged( true );
         }
         if ( !wasScriptModified ) {
             emit scriptModifiedStateChanged( true );
         }
     }
 }
 
 Project::ScriptTemplateType Project::getScriptTemplateTypeInput( QWidget *parent ) const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     bool ok;
     QStringList templates;
     parent = d->parentWidget( parent );
     templates << i18nc("@info/plain", "JavaScript Template")
               << i18nc("@info/plain", "JavaScript HAFAS Template")
               << i18nc("@info/plain", "Simple Ruby Template")
               << i18nc("@info/plain", "Simple Python Template");
     const QString scriptType = KInputDialog::getItem(
             i18nc("@title:window", "Script Template"),
             i18nc("@info", "Choose a template for the new script"),
             templates, 0, false, &ok, parent );
     if ( !ok ) {
         return NoScriptTemplate;
     }
 
     const int selectedTemplate = templates.indexOf( scriptType );
     if( selectedTemplate == 0 ) {
         return ScriptQtScriptTemplate;
     } else if( selectedTemplate == 1 ) {
         return ScriptQtScriptHafasTemplate;
     } else if( selectedTemplate == 2 ) {
         return ScriptRubyTemplate;
     } else if( selectedTemplate == 3 ) {
         return ScriptPythonTemplate;
     } else {
-        kWarning() << "Unexpected script type" << scriptType;
+        qWarning() << "Unexpected script type" << scriptType;
         return NoScriptTemplate;
     }
 }
 #endif
 
 bool Project::isProjectSourceModified() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isProjectSourceModified();
 }
 
 bool Project::isScriptModified() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isScriptModified();
 }
 
 bool Project::isModified() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isModified();
 }
 
 void Project::showTextHint( const KTextEditor::Cursor &position, QString &text ) {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     KTextEditor::View *activeView = d->scriptTab->document()->activeView();
     const QPoint pointInView = activeView->cursorToCoordinate( position );
     const QPoint pointGlobal = activeView->mapToGlobal( pointInView );
     QToolTip::showText( pointGlobal, text );
 #else
     Q_UNUSED( position )
     Q_UNUSED( text )
 #endif
 }
 
 bool Project::save( QWidget *parent, const QString &xmlFilePath )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->save( parent, xmlFilePath );
 }
 
 bool Project::saveAs( QWidget *parent )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->saveAs( parent );
 }
 
 bool Project::install( QWidget *parent, InstallType installType )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->install( parent, true, installType );
 }
 
 bool Project::uninstall( QWidget *parent, Project::InstallType installType )
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     return d->install( parent, false, installType );
 }
 
 bool Project::isInstalledLocally() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isInstalledLocally();
 }
 
 bool Project::isInstalledGlobally() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->isInstalledGlobally();
 }
 
 QPixmap Project::renderAppletPreview()
 {
     Q_D( Project );
 
     // Inform the user about what is going on
     emit informationMessage( i18nc("@info", "Rendering Provider Preview..."),
                              KMessageWidget::Information, 1500 );
 
     // Create the applet in a planar containment (no background)
     Plasma::Corona corona;
     Plasma::Containment *containment = corona.addContainment( "planar" );
     Plasma::Applet *applet = containment->addApplet( "publictransport" );
     corona.setSceneRect( 0, 0, applet->preferredWidth(), applet->preferredHeight() );
     containment->setGeometry( 0, 0, applet->preferredWidth(), applet->preferredHeight() );
     containment->show();
 
     // Initialize an event loop to wait for departures to be received by the applet
     QEventLoop loop;
     connect( applet, SIGNAL(validDepartureDataReceived()), &loop, SLOT(quit()) );
     connect( applet, SIGNAL(invalidDepartureDataReceived()), &loop, SLOT(quit()) );
 
     // Set settings of the PublicTransport applet using a specific slot
     int index = applet->metaObject()->indexOfSlot( "setSettings(QString,QString)" );
     if( index == -1 ) {
         kDebug() << "Could not find a slot with signature setSettings(QString,QString) "
                     "in the PublicTransport applet.";
         return QPixmap();
     }
     bool success = applet->metaObject()->method( index ).invoke( applet,
             Q_ARG(QString, d->data()->id()),
             Q_ARG(QString, d->data()->sampleStopNames().isEmpty()
                            ? QString() : d->data()->sampleStopNames().first()) );
     if( !success ) {
         kDebug() << "A call to setSettings in the publicTransport applet wasn't successful.";
         return QPixmap();
     }
 
     // Wait for departures to be received by the applet, maximally one second
     QTimer::singleShot( 1000, &loop, SLOT(quit()) );
     loop.exec();
 
     // Wait another 300ms to finish fade in animations of departure items (250ms duration by default)
     // Use a new event loop to not get finished by the 1s timeout started above
     QEventLoop loop2;
     QTimer::singleShot( 300, &loop2, SLOT(quit()) );
     loop2.exec();
     qApp->processEvents();
 
     // Render to the pixmap
     QPixmap previewPixmap( applet->size().toSize() );
     previewPixmap.fill( Qt::white );
     QPainter painter( &previewPixmap );
     corona.render( &painter );
     painter.end();
 
     // Cleanup
     containment->clearApplets();
     delete applet;
     delete containment;
 
     // Return the pixmap with the rendered applet preview
     return previewPixmap;
 }
 
 void Project::publish()
 {
     Q_D( Project );
 
     if ( !isInstalledGlobally() && !isInstalledLocally() ) {
         emit informationMessage( i18nc("@ịnfo", "The provider must be installed before "
                                        "publishing it."), KMessageWidget::Error );
         return;
     }
 
     if ( d->isTestRunning() ) {
         emit informationMessage( i18nc("@ịnfo", "Cannot publish while tests are running"),
                                  KMessageWidget::Error );
         return;
     }
 
     if ( d->data()->type() == Enums::GtfsProvider ) {
         switch ( d->gtfsDatabaseState ) {
             case GtfsDatabaseImportFinished:
                 break;
             case GtfsDatabaseUpdateAvailable:
                 emit informationMessage( i18nc("@ịnfo", "An updated version of the GTFS feed is "
                         "available. Please import the new version into the database before "
                         "publishing your plugin."), KMessageWidget::Error, -1, QString(), QString(),
                         QList<QAction*>() << projectAction(ImportGtfsFeed)
                                           << projectAction(ShowGtfsDatabase) );
                 return;
             case GtfsDatabaseImportRunning:
                 emit informationMessage( i18nc("@ịnfo", "Wait for the GTFS feed import to finish "
                         "before publishing your plugin (%1%).", d->gtfsFeedImportProgress),
                         KMessageWidget::Error, -1, QString(), QString(),
                         QList<QAction*>() << projectAction(ShowGtfsDatabase) );
                 return;
             case GtfsDatabaseError:
                 emit informationMessage( i18nc("@ịnfo", "There was an error importing the GTFS "
                         "feed: <message>%1</message>. Fix this before publishing your plugin.",
                         d->gtfsDatabaseErrorString), KMessageWidget::Error, -1, QString(), QString(),
                         QList<QAction*>() << projectAction(ShowGtfsDatabase) );
                 return;
             case GtfsDatabaseImportPending:
             default:
                 emit informationMessage( i18nc("@ịnfo", "Please import the GTFS feed before "
                         "publishing your plugin."), KMessageWidget::Error, -1, QString(), QString(),
                         QList<QAction*>() << projectAction(ImportGtfsFeed)
                                           << projectAction(ShowGtfsDatabase) );
                 return;
         }
     }
 
     // Ensure that at least the provider data tests finish successfully
     d->startTests( TestModel::testsOfTestCase(TestModel::ServiceProviderDataTestCase) );
 
     // The started test case should run synchronously
     Q_ASSERT( !d->isTestRunning() );
 
     // Check the result of the test
     TestModel::TestState testState =
             d->testModel->testCaseState( TestModel::ServiceProviderDataTestCase );
     switch ( testState ) {
     case TestModel::TestFinishedSuccessfully:
     case TestModel::TestFinishedWithWarnings:
         break;
     case TestModel::TestFinishedWithErrors:
     default:
         emit informationMessage(
                 i18nc("@ịnfo", "The %1 test case did not finish successfully. "
                       "Please fix it using the <interface>Project Settings</interface> dialog "
                       "before publishing your plugin.",
                       TestModel::nameForTestCase(TestModel::ServiceProviderDataTestCase)),
                 KMessageWidget::Error, -1, QString(), QString(),
                 QList<QAction*>() << projectAction(ShowProjectSettings) );
         return;
     }
 
     // Make sure a sample stop name is available
     // because this is needed for the preview image
     if ( d->data()->sampleStopNames().isEmpty() ) {
         emit informationMessage(
                 i18nc("@ịnfo", "A sample stop is needed to generate a preview image of the "
                       "provider being used in the PublicTransport applet. "
                       "Please add at least one sample stop using the "
                       "<interface>Project Settings</interface> dialog before publishing "
                       "your plugin."), KMessageWidget::Error, -1, QString(), QString(),
                 QList<QAction*>() << projectAction(ShowProjectSettings) );
         return;
     }
 
     // Save a preview image of the PublicTransport applet using this provider plugin
     KTemporaryFile previewImageFile;
     previewImageFile.setSuffix( ".png" );
     if ( !previewImageFile.open() ) {
-        kWarning() << "Could not open temporary file to write Plasma preview image";
+        qWarning() << "Could not open temporary file to write Plasma preview image";
     } else {
         QPixmap previewPixmap = renderAppletPreview();
         if ( !previewPixmap.isNull() ) {
             previewPixmap.save( &previewImageFile );
         }
         previewImageFile.close();
     }
 
     // Tell the user to only publish tested provider plugins
     // and what to use as preview images
     if ( KMessageBox::warningContinueCancel(d->parentWidget(), i18nc("@info",
             "<title>Publish Your Provider Plugin</title>"
             "<para>Please make sure your plugin is working and run all tests with it "
             "before publishing your plugin.</para>"
             "<para>The first preview image should be a map showing supported regions. "
             "The second preview should have been generated automatically and show the "
             "PublicTransport applet using this provider plugin. "
             "<warning>You need to install the provider and make it ready (eg. import the "
             "GTFS feed) for the preview image to be generated correctly.</warning></para>"),
             QString(), KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
             "publish_information") != KMessageBox::Continue )
     {
         return;
     }
 
     // Create the upload dialog,
     // to not use "Kate Part" (which might currently be the active component)
     // for the dialog title/icon, switch to the main component (TimetableMate)
     // for the UploadDialog constructor
     const KComponentData activeComponent = KGlobal::activeComponent();
     KGlobal::setActiveComponent( KGlobal::mainComponent() );
     KNS3::UploadDialog dialog( "timetablemate.knsrc", d->parentWidget() );
     KGlobal::setActiveComponent( activeComponent );
 
     // Compress all project files into one and use it for the upload
     const QString providerId = d->data()->id();
     const QString sourcePath = QFileInfo( d->filePath ).path();
     const QString uploadFileName = sourcePath + '/' + providerId + ".zip";
     KZip zip( uploadFileName );
     zip.setCompression( KZip::DeflateCompression );
     if ( !zip.open(QIODevice::WriteOnly) ) {
         emit informationMessage( i18nc("@info", "Could not create upload file "
                                        "<filename>%1</filename>", uploadFileName),
                                  KMessageWidget::Error );
         return;
     }
 
     // Add provider plugin file
     zip.addLocalFile( d->filePath, providerId + ".pts" );
 
     // Add other files, eg. scripts
     switch ( d->data()->type() ) {
     case Enums::ScriptedProvider:
         zip.addLocalFile( d->data()->scriptFileName(),
                           QFileInfo(d->data()->scriptFileName()).fileName() );
         break;
     default:
-        kWarning() << "Invalid provider" << d->data()->type();
+        qWarning() << "Invalid provider" << d->data()->type();
         break;
     }
 
     if ( !zip.close() ) {
         emit informationMessage( i18nc("@info", "Could not create upload file "
                                        "<filename>%1</filename>", uploadFileName),
                                  KMessageWidget::Error );
         return;
     }
 
     // Prepare plugin meta data, no i18n, only use english for openDesktop.org
     QString countryName = d->data()->country() == QLatin1String("international")
             ? "International" : KGlobal::locale()->countryCodeToName(d->data()->country());
     if ( countryName.isEmpty() ) {
         // Unknown country code given
         countryName = d->data()->country();
     }
     QString description = d->data()->descriptions()["en"];
     if ( !description.isEmpty() ) {
         description.append( "\n\n" );
     }
     const QStringList featureNames = ServiceProviderGlobal::featureNames( d->features() );
     description.append( "Supported Features: " + featureNames.join(", ") );
     description.append( "\nProvider Type: " + d->data()->typeName() );
 
     switch ( d->data()->type() ) {
     case Enums::GtfsProvider:
         description.append( "\nGTFS Feed Size (download): " +
                             KGlobal::locale()->formatByteSize(d->gtfsFeedSize) );
         description.append( QString("\nGTFS Database Size After Import: %1 (as of %2)")
                             .arg(KGlobal::locale()->formatByteSize(d->gtfsDatabaseSize))
                             .arg(KGlobal::locale()->formatDate(d->gtfsDatabaseModifiedTime.date(),
                                                                KLocale::ShortDate)) );
         break;
     case Enums::ScriptedProvider:
         description.append( "\nScript Size: " + KGlobal::locale()->formatByteSize(
                             QFileInfo(d->data()->scriptFileName()).size()) );
         if ( !d->includedFiles.isEmpty() ) {
             // Add required/included scripts, but without the path
             QString requiredScriptText;
             foreach ( const QString &includedFile, d->includedFiles ) {
                 const QFileInfo info( includedFile );
                 if ( !requiredScriptText.isEmpty() ) {
                     requiredScriptText.append( ", " );
                 }
                 requiredScriptText.append( info.fileName() );
             }
             description.append( "\nRequired Scripts: " + requiredScriptText );
         }
         if ( !d->data()->scriptExtensions().isEmpty() ) {
             description.append( "\nUsed Script Extensions: " +
                                 d->data()->scriptExtensions().join(", ") );
         }
         break;
     default:
-        kWarning() << "Unknown provider type" << d->data()->type();
+        qWarning() << "Unknown provider type" << d->data()->type();
         break;
     }
 
     // Set the file to upload and some meta data of the plugin
     dialog.setUploadFile( uploadFileName );
     dialog.setUploadName( countryName + ", " + d->data()->names()["en"] );
     dialog.setDescription( description );
     dialog.setVersion( d->data()->version() );
     dialog.setChangelog( d->data()->changelogString() );
     dialog.setPreviewImageFile( 1, QUrl(previewImageFile.fileName()) );
 
     // Show the dialog
     dialog.exec();
 }
 
 QString Project::iconName() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->iconName();
 }
 
 QIcon Project::projectIcon() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->projectIcon();
 }
 
 QString Project::projectName() const
 {
     Q_D( const Project );
     QMutexLocker locker( d->mutex );
     return d->projectName();
 }
 
 ServiceProviderData *Project::data()
 {
     Q_D( Project );
     QMutexLocker locker( d->mutex );
     // Return as non const, because QML cannot use it otherwise
     return const_cast< ServiceProviderData* >( d->data() );
 }
 
 Project::InstallType Project::Project::installationTypeFromFilePath( const QString &filePath )
 {
     if ( filePath.isEmpty() ) {
         return NoInstallation;
     }
 
     const QString saveDir = QFileInfo( filePath ).path() + '/';
     const QString localSaveDir = KGlobal::dirs()->saveLocation( "data",
             ServiceProviderGlobal::installationSubDirectory() );
     if ( saveDir == localSaveDir ) {
         return LocalInstallation;
     }
 
     const QStringList allSaveDirs = KGlobal::dirs()->findDirs( "data",
             ServiceProviderGlobal::installationSubDirectory() );
     if ( allSaveDirs.contains(saveDir) ) {
         return GlobalInstallation;
     }
 
     return NoInstallation;
 }
 
 QString Project::savePathInfoStringFromFilePath( const QString &filePath )
 {
     if ( filePath.isEmpty() ) {
         // Project not saved
         return i18nc("@info:tooltip", "Project not saved");
     } else {
         // Project is saved
         InstallType installType = installationTypeFromFilePath( filePath );
         switch ( installType ) {
         case Project::LocalInstallation:
             return i18nc("@info:tooltip", "Project is opened from local installation directory at "
                          "<filename>%1</filename>", filePath);
         case Project::GlobalInstallation:
             return i18nc("@info:tooltip", "Project is opened from global installation directory at "
                          "<filename>%1</filename>", filePath);
         case Project::NoInstallation:
         default:
             return i18nc("@info:tooltip", "Project saved at <filename>%1</filename>", filePath);
         }
     }
 }
 
 void Project::slotDebugInformationMessage( const QString &message )
 {
     QColor color = KColorScheme( QPalette::Active ).foreground( KColorScheme::InactiveText ).color();
     appendOutput( message, color );
     emit informationMessage( message, KMessageWidget::Information, -1 );
 }
 
 void Project::slotDebugErrorMessage( const QString &message )
 {
     QColor color = KColorScheme( QPalette::Active ).foreground( KColorScheme::NegativeText ).color();
     appendOutput( message, color );
     emit informationMessage( message, KMessageWidget::Error, -1 );
 }
 
 void Project::syntaxErrorFound( const QString &errorMessage, const QString &fileName )
 {
     Q_D( Project );
     ScriptTab *tab = fileName == d->provider->data()->scriptFileName()
             ? scriptTab() : scriptTab( fileName );
     if ( tab && tab->isVisible() ) {
         // Show syntax errors only if the associated script tab is opened and visible,
         // use KMessageWidget::Error, because for less severe errors the project needs
         // to be active for the message to be shown
         emit informationMessage( errorMessage, KMessageWidget::Error, 7000,
                                  d->provider->id() + "syntax",
                                  i18nc("@info", "Syntax errors resolved") );
     }
 }
diff --git a/engine/timetablemate/src/projectmodel.cpp b/engine/timetablemate/src/projectmodel.cpp
index 610eeaa..78cb98c 100644
--- a/engine/timetablemate/src/projectmodel.cpp
+++ b/engine/timetablemate/src/projectmodel.cpp
@@ -1,978 +1,978 @@
 /*
 *   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 "projectmodel.h"
 
 // Own includes
 #include "project.h"
 #include "tabs/projectsourcetab.h"
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     #include "tabs/scripttab.h"
     #include "debugger/debugger.h"
     #include "javascriptparser.h"
     #include "javascriptmodel.h"
 #endif
 
 // Public Transport engine includes
 #include <engine/serviceprovider.h>
 #include <engine/serviceproviderdata.h>
 #include <serviceproviderglobal.h>
 
 // KDE includes
 #include <KLocalizedString>
 #include <KIcon>
 #include <KGlobalSettings>
 #include <KDebug>
 #include <KDialog>
 #include <KColorScheme>
 #include <ThreadWeaver/Weaver>
 
 // Qt includes
 #include <QFileInfo>
 #include <QTimer>
 #include <QFont>
 
 ProjectModel::ProjectModel( QObject *parent )
         : QAbstractItemModel(parent), m_activeProject(0), m_updateProjectsTimer(0),
           m_weaver(WeaverInterfacePointer(new ThreadWeaver::Weaver())), m_idle(true)
 {
 }
 
 ProjectModel::~ProjectModel()
 {
     clear();
 }
 
 void ProjectModel::setActiveProject( Project *activeProject )
 {
     if ( activeProject == m_activeProject ) {
         return;
     }
 
     Project *previousProject = m_activeProject;
     emit activeProjectAboutToChange( activeProject, previousProject );
     if ( previousProject ) {
         const QModelIndex index = indexFromProject( previousProject );
         m_activeProject = activeProject;
 
         // Notify that the current debug project is no longer the debug project
         dataChanged( index, index );
     } else {
         m_activeProject = activeProject;
     }
     emit activeProjectChanged( activeProject, previousProject );
 
     // Notify about the new active project
     const QModelIndex index = indexFromProject( m_activeProject );
     dataChanged( index, index );
 }
 
 QModelIndex ProjectModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( parent.isValid() ) {
         if ( parent.column() != 0 ) {
             // Only the first column has children
             return QModelIndex();
         }
 
         // Child item
         ProjectModelItem *parentItem = projectItemFromIndex( parent );
         if ( row >= 0 && row < parentItem->children().count() ) {
             // Valid row for the child
             return createIndex( row, column, parentItem->children()[row] );
         }
     } else if ( row >= 0 && row < m_projects.count() ) {
         // Top level item
         return createIndex( row, column, m_projects[row] );
     }
 
     return QModelIndex();
 }
 
 int ProjectModel::rowCount( const QModelIndex &parent ) const
 {
     if ( parent.isValid() ) {
         // Child item
         if ( parent.column() == 0 ) {
             ProjectModelItem *projectItem = projectItemFromIndex( parent );
             return projectItem->children().count();
         } else {
             return 0;
         }
     } else {
         // Top level item
         return m_projects.count();
     }
 }
 
 QModelIndex ProjectModel::parent( const QModelIndex &child ) const
 {
     if ( !child.isValid() ) {
         return QModelIndex();
     }
 
     ProjectModelItem *projectItem = projectItemFromIndex( child );
     if ( projectItem->parent() ) {
         return indexFromProjectItem( projectItem->parent() );
     } else {
         return QModelIndex();
     }
 }
 
 QList< Project* > ProjectModel::projects() const
 {
     QList< Project* > projects;
     foreach ( ProjectModelItem *projectItem, m_projects ) {
         projects << projectItem->project();
     }
     return projects;
 }
 
 QString ProjectModelItem::text() const
 {
     switch ( m_type ) {
     case ProjectModelItem::DashboardItem:
         return i18nc("@info/plain", "Dashboard");
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case ProjectModelItem::ScriptItem: {
         QString name = m_project->scriptFileName().isEmpty()
                 ? i18nc("@info/plain", "Script File")
                 : QFileInfo(m_project->scriptFileName()).fileName();
         return KDialog::makeStandardCaption( name, 0,
                 m_project->scriptTab() && m_project->scriptTab()->isModified()
                 ? KDialog::ModifiedCaption : KDialog::NoCaptionFlags );
     }
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case ProjectModelItem::GtfsDatabaseItem:
         return i18nc("@info/plain", "GTFS database");
 #endif
     case ProjectModelItem::ProjectSourceItem: {
         QString name = m_project->filePath().isEmpty()
                 ? i18nc("@info/plain", "Project Source XML File (experts)")
                 : i18nc("@info/plain", "%1 (experts)",
                         QFileInfo(m_project->filePath()).fileName());
         return KDialog::makeStandardCaption( name, 0, m_project->isProjectSourceModified()
                 ? KDialog::ModifiedCaption : KDialog::NoCaptionFlags );
     }
     case ProjectModelItem::PlasmaPreviewItem:
         return i18nc("@info/plain", "Plasma Preview");
     case ProjectModelItem::WebItem:
         return i18nc("@info/plain", "Service Provider Home Page");
     default:
-        kWarning() << "Unknown project item type" << m_type;
+        qWarning() << "Unknown project item type" << m_type;
         return QString();
     }
 }
 
 QVariant ProjectModel::data( const QModelIndex &index, int role ) const
 {
     ProjectModelItem *projectItem = static_cast< ProjectModelItem* >( index.internalPointer() );
     Project *project = projectItem->project();
 
     if ( index.parent().isValid() ) {
         // Child item of a project item
         switch ( role ) {
         case Qt::DisplayRole:
             return projectItem->text();
         case Qt::DecorationRole:
             switch ( projectItem->type() ) {
             case ProjectModelItem::DashboardItem:
                 return KIcon("dashboard-show");
             case ProjectModelItem::ProjectSourceItem:
                 return KIcon("application-x-publictransport-serviceprovider");
             case ProjectModelItem::ScriptItem:
             case ProjectModelItem::IncludedScriptItem:
                 return project->scriptIcon();
             case ProjectModelItem::CodeItem:
                 return KIcon("code-function");
             case ProjectModelItem::GtfsDatabaseItem:
                 return KIcon("server-database");
             case ProjectModelItem::PlasmaPreviewItem:
                 return KIcon("plasma");
             case ProjectModelItem::WebItem:
                 return KIcon("text-html");
             default:
-                kWarning() << "Unknown project item type" << projectItem->type();
+                qWarning() << "Unknown project item type" << projectItem->type();
                 break;
             }
             break;
         case Qt::ToolTipRole:
             switch ( projectItem->type() ) {
             case ProjectModelItem::DashboardItem:
                 return i18nc("@info:tooltip", "The dashboard of the project %1.",
                              project->projectName());
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             case ProjectModelItem::ScriptItem:
                 return i18nc("@info:tooltip", "Create/edit the projects script.");
             case ProjectModelItem::IncludedScriptItem:
                 return i18nc("@info:tooltip", "View/edit included script <filename>%1</filename>.",
                              dynamic_cast<ProjectModelIncludedScriptItem*>(projectItem)->fileName() );
 #else
             case ProjectModelItem::ScriptItem:
             case ProjectModelItem::IncludedScriptItem:
                 return QString();
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
             case ProjectModelItem::GtfsDatabaseItem:
                 return i18nc("@info:tooltip", "Shows the GTFS database and allows to start its "
                              "import from the GTFS feed.");
 #else
             case ProjectModelItem::GtfsDatabaseItem:
                 return QString();
 #endif
             case ProjectModelItem::ProjectSourceItem:
                 return i18nc("@info:tooltip", "Edit project settings directly in the XML "
                                               "source document. Intended for experts, normally "
                                               "the settings dialog should be used instead.");
             case ProjectModelItem::PlasmaPreviewItem:
                 return i18nc("@info:tooltip", "Test the project in a PublicTransport applet in a "
                                               "Plasma preview");
             case ProjectModelItem::WebItem:
                 if ( project->provider()->data()->url().isEmpty() ) {
                     return i18nc("@info:tooltip", "Show the service providers home page.");
                 } else {
                     return project->provider()->data()->url();
                 }
             default:
-                kWarning() << "Unknown project item type" << projectItem->type();
+                qWarning() << "Unknown project item type" << projectItem->type();
                 break;
             }
             break;
         case Qt::FontRole:
             switch ( projectItem->type() ) {
             case ProjectModelItem::ProjectSourceItem:
                 if ( project->projectSourceTab() &&
                      project->projectSourceTab()->isModified() )
                 {
                     QFont font = KGlobalSettings::generalFont();
                     font.setItalic( true );
                     return font;
                 }
                 break;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             case ProjectModelItem::ScriptItem:
                 if ( project->scriptTab() &&
                      project->scriptTab()->isModified() )
                 {
                     QFont font = KGlobalSettings::generalFont();
                     font.setItalic( true );
                     return font;
                 }
                 break;
             case ProjectModelItem::IncludedScriptItem: {
                 ProjectModelIncludedScriptItem *includedScriptItem =
                         dynamic_cast< ProjectModelIncludedScriptItem* >( projectItem );
                 ScriptTab *scriptTab = project->scriptTab( includedScriptItem->filePath() );
                 if ( scriptTab && scriptTab->isModified() ) {
                     QFont font = KGlobalSettings::generalFont();
                     font.setItalic( true );
                     return font;
                 }
             } break;
 
             case ProjectModelItem::CodeItem:
 #else
             case ProjectModelItem::ScriptItem:
             case ProjectModelItem::IncludedScriptItem:
             case ProjectModelItem::CodeItem:
 #endif
             case ProjectModelItem::GtfsDatabaseItem:
             case ProjectModelItem::PlasmaPreviewItem:
             case ProjectModelItem::WebItem:
             case ProjectModelItem::DashboardItem:
             default:
                 return QVariant();
             }
         }
     } else {
         // Top level project item
         switch ( role ) {
         case Qt::DisplayRole: {
             return KDialog::makeStandardCaption( project->projectName(), 0, project->isModified()
                     ? KDialog::ModifiedCaption : KDialog::NoCaptionFlags );
         }
         case Qt::DecorationRole:
             return project->projectIcon();
         case Qt::ToolTipRole:
             return project->savePathInfoString();
         case Qt::FontRole:
             // Use italic font for modified projects and bold font for active projects
             if ( project->isModified() || project == m_activeProject ) {
                 QFont font = KGlobalSettings::generalFont();
                 font.setItalic( project->isModified() );
                 font.setBold( project == m_activeProject );
                 return font;
             }
             break;
         case Qt::ForegroundRole:
             switch ( project->testModel()->completeState() ) {
             case TestModel::TestFinishedSuccessfully:
                 return KColorScheme(QPalette::Active).foreground(KColorScheme::PositiveText);
             case TestModel::TestFinishedWithWarnings:
                 return KColorScheme(QPalette::Active).foreground(KColorScheme::NeutralText);
             case TestModel::TestFinishedWithErrors:
             case TestModel::TestCouldNotBeStarted:
                 return KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText);
             case TestModel::TestNotStarted:
             case TestModel::TestIsRunning:
             default:
                 return QVariant();
             }
         }
     }
 
     return QVariant();
 }
 
 Qt::ItemFlags ProjectModel::flags( const QModelIndex &index ) const
 {
     if ( !index.isValid() ) {
         return Qt::NoItemFlags;
     }
 
     ProjectModelItem *projectItem = static_cast< ProjectModelItem* >( index.internalPointer() );
     Project *project = projectItem->project();
 
     if ( index.parent().isValid() ) {
         // Child item of a project item
         switch ( projectItem->type() ) {
         case ProjectModelItem::DashboardItem:
         case ProjectModelItem::ProjectSourceItem:
         case ProjectModelItem::PlasmaPreviewItem:
         case ProjectModelItem::ScriptItem:
         case ProjectModelItem::IncludedScriptItem:
         case ProjectModelItem::CodeItem:
         case ProjectModelItem::GtfsDatabaseItem:
             return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
         case ProjectModelItem::WebItem:
             if ( project->provider()->data()->url().isEmpty() ) {
                 // Disable web item if no home page URL has been specified
                 return Qt::ItemIsSelectable;
             } else {
                 return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
             }
         default:
             return Qt::NoItemFlags;
         }
     } else {
         // Top level project item
         return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     }
 }
 
 ProjectModelItem::ProjectModelItem( Project *project, Type type, ProjectModelItem *parent )
         : m_project(project), m_parent(parent), m_type(type)
 {
     if ( parent ) {
         parent->addChild( this );
     }
 }
 
 ProjectModelItem::~ProjectModelItem()
 {
     qDeleteAll( m_children );
 
     if ( !m_parent ) {
         // Use deleteLater(), because otherwise using project action Project::Close causes a crash
         m_project->deleteLater();
     }
 }
 
 QList< ProjectModelItem* > ProjectModelItem::childrenFromType( ProjectModelItem::Type type ) const
 {
     QList< ProjectModelItem* > children;
     foreach ( ProjectModelItem *child, m_children ) {
         if ( child->type() == type ) {
             // Found a child of the given type
             children << child;
         }
     }
     return children;
 }
 
 ProjectModelItem *ProjectModelItem::firstChildFromType( ProjectModelItem::Type type ) const
 {
     foreach ( ProjectModelItem *child, m_children ) {
         if ( child->type() == type ) {
             // Found a child of the given type
             return child;
         }
     }
 
     // No child of the given type found
     return 0;
 }
 
 void ProjectModelItem::addChild( ProjectModelItem *item )
 {
     if ( m_children.contains(item) ) {
         kDebug() << "Child item already added" << item->text();
         return;
     }
 
     item->m_parent = this;
     m_children << item;
 }
 
 void ProjectModelItem::insertChild( int index, ProjectModelItem *item )
 {
     if ( m_children.contains(item) ) {
         kDebug() << "Child item already added" << item->text();
         return;
     }
 
     item->m_parent = this;
     m_children.insert( index, item );
 }
 
 void ProjectModelItem::removeChildren( const QList< ProjectModelItem* > &items )
 {
     foreach ( ProjectModelItem *item, items ) {
         m_children.removeOne( item );
         delete item;
     }
 }
 
 void ProjectModelItem::clearChildren()
 {
     qDeleteAll( m_children );
     m_children.clear();
 }
 
 Project *ProjectModel::projectFromFilePath( const QString &filePath ) const
 {
     foreach ( ProjectModelItem *projectItem, m_projects ) {
         if ( filePath == projectItem->project()->filePath() ) {
             return projectItem->project();
         }
     }
 
     return 0L;
 }
 
 void ProjectModel::appendProject( Project *project )
 {
     // Create project root item
     beginInsertRows( QModelIndex(), m_projects.count(), m_projects.count() );
     ProjectModelItem *projectItem = new ProjectModelItem( project );
     m_projects << projectItem;
     endInsertRows();
 
     // Create child items
     const QModelIndex projectIndex = indexFromProjectItem( projectItem );
     int itemNumber = 3;
     switch ( project->data()->type() ) {
     case Enums::ScriptedProvider:
     case Enums::GtfsProvider:
         // If support for the projects provider type was build into the engine,
         // another item will get added
         if ( ServiceProviderGlobal::isProviderTypeAvailable(project->data()->type()) ) {
             ++itemNumber;
         }
         break;
     default:
         break;
     }
     beginInsertRows( projectIndex, 0, itemNumber );
     projectItem->addChild( ProjectModelItem::createDashboardtItem(project) );
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     if ( project->data()->type() == Enums::ScriptedProvider ) {
         projectItem->addChild( ProjectModelItem::createScriptItem(project) );
     }
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     if ( project->data()->type() == Enums::GtfsProvider ) {
         projectItem->addChild( ProjectModelItem::createGtfsDatabaseItem(project) );
     }
 #endif
     projectItem->addChild( ProjectModelItem::createProjectSourceDocumentItem(project) );
     projectItem->addChild( ProjectModelItem::createWebItem(project) );
     projectItem->addChild( ProjectModelItem::createPlasmaPreviewItem(project) );
     endInsertRows();
 
     connect( project, SIGNAL(providerTypeChanged(Enums::ServiceProviderType,Enums::ServiceProviderType)),
              this, SLOT(providerTypeChanged(Enums::ServiceProviderType,Enums::ServiceProviderType)) );
     connect( project, SIGNAL(modifiedStateChanged(bool)), this, SLOT(slotProjectModified()) );
     connect( project, SIGNAL(debuggerReady()), this, SLOT(scriptSaved()) );
     connect( project->testModel(), SIGNAL(testResultsChanged()), this, SLOT(slotProjectModified()) );
     connect( this, SIGNAL(activeProjectChanged(Project*,Project*)),
              project, SLOT(slotActiveProjectChanged(Project*,Project*)) );
     connect( project, SIGNAL(setAsActiveProjectRequest()), this, SLOT(setAsActiveProjectRequest()) );
     connect( project, SIGNAL(testProgress(QList<TestModel::Test>,QList<TestModel::Test>)),
              this, SLOT(projectTestProgress(QList<TestModel::Test>,QList<TestModel::Test>)) );
     connect( project, SIGNAL(debuggerRunningChanged(bool)), this, SLOT(updateIsIdle()) );
     connect( project, SIGNAL(testRunningChanged(bool)), this, SLOT(updateIsIdle()) );
     project->setProjectModel( this );
     emit projectAdded( project );
 
     if ( !m_activeProject ) {
         // Make new project the active project if no other project is set
         setActiveProject( project );
     }
 }
 
 void ProjectModel::providerTypeChanged( Enums::ServiceProviderType newType,
                                         Enums::ServiceProviderType oldType )
 {
     Project *project = qobject_cast< Project* >( sender() );
     Q_ASSERT( project );
     ProjectModelItem *projectItem = projectItemFromProject( project );
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     if ( oldType == Enums::ScriptedProvider ) {
         QList< ProjectModelItem* > items;
         items << projectItem->firstChildFromType( ProjectModelItem::ScriptItem );
         items << projectItem->childrenFromType( ProjectModelItem::IncludedScriptItem );
         items << projectItem->childrenFromType( ProjectModelItem::CodeItem );
         projectItem->removeChildren( items );
     } else if ( newType == Enums::ScriptedProvider ) {
         projectItem->insertChild( 1, ProjectModelItem::createScriptItem(project) );
     }
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     if ( oldType == Enums::GtfsProvider ) {
         QList< ProjectModelItem* > items;
         items << projectItem->firstChildFromType( ProjectModelItem::GtfsDatabaseItem );
         projectItem->removeChildren( items );
     } else if ( newType == Enums::GtfsProvider ) {
         projectItem->insertChild( 1, ProjectModelItem::createGtfsDatabaseItem(project) );
     }
 #endif
 }
 
 void ProjectModel::updateIsIdle()
 {
     bool newIdle = isIdle();
     if ( m_idle != newIdle ) {
         m_idle = newIdle;
         emit idleChanged( newIdle );
     }
 }
 
 bool ProjectModel::isIdle() const
 {
     foreach ( ProjectModelItem *projectItem, m_projects ) {
         Project *project = projectItem->project();
         if ( project->isTestRunning() || project->isDebuggerRunning() ) {
             return false;
         }
     }
 
     return true;
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 QString ProjectModelIncludedScriptItem::fileName() const
 {
     return QFileInfo( m_filePath ).fileName();
 }
 
 void ProjectModel::updateProjects()
 {
     if ( !isIdle() ) {
         // Too busy, try again later
         m_updateProjectsTimer->start( 500 );
         return;
     }
 
     delete m_updateProjectsTimer;
     m_updateProjectsTimer = 0;
 
     foreach ( Project *project, m_changedScriptProjects ) {
         if ( project->data()->type() != Enums::ScriptedProvider ) {
             continue;
         }
 
         // Remove all items for previously included files
         QList< ProjectModelItem* > itemsToRemove;
         const QModelIndex projectIndex = indexFromProject( project );
         ProjectModelItem *projectItem = projectItemFromIndex( projectIndex );
         ProjectModelItem *scriptItem = projectItemChildFromProject( project, ProjectModelItem::ScriptItem );
         int scriptItemIndex = indexFromProjectItem( scriptItem ).row();
         int firstIncludedScriptItemIndex = scriptItemIndex + 1;
         foreach ( ProjectModelItem *childItem, projectItem->children() ) {
             if ( childItem->type() == ProjectModelItem::IncludedScriptItem ) {
                 itemsToRemove << childItem;
             }
         }
         if ( !itemsToRemove.isEmpty() ) {
             beginRemoveRows( projectIndex, firstIncludedScriptItemIndex,
                             firstIncludedScriptItemIndex + itemsToRemove.count() - 1 );
             projectItem->removeChildren( itemsToRemove );
             itemsToRemove.clear();
             endRemoveRows();
         }
 
         // Insert items for now included files
         if ( !project->includedFiles().isEmpty() ) {
             beginInsertRows( projectIndex, scriptItemIndex + 1,
                             scriptItemIndex + project->includedFiles().count() );
             foreach ( const QString &includedFile, project->includedFiles() ) {
                 ProjectModelIncludedScriptItem *includedScriptItem =
                         new ProjectModelIncludedScriptItem( project, includedFile );
                 projectItem->insertChild( ++scriptItemIndex, includedScriptItem );
                 insertCodeNodes( includedScriptItem, false );
             }
             endInsertRows();
         }
 
         insertCodeNodes( scriptItem );
     }
 
     m_changedScriptProjects.clear();
 }
 
 void ProjectModel::insertCodeNodes( ProjectModelItem *scriptItem, bool emitSignals )
 {
     // Parse script
     Project *project = scriptItem->project();
     ProjectModelIncludedScriptItem *includedScriptItem =
             dynamic_cast< ProjectModelIncludedScriptItem* >( scriptItem );
     JavaScriptParser parser( project->scriptText(
             includedScriptItem ? includedScriptItem->filePath() : QString()) );
     const QList< CodeNode::Ptr > nodes = parser.nodes();
     QList< CodeNode::Ptr > flatNodes = QList< CodeNode::Ptr >() << nodes;
     foreach ( const CodeNode::Ptr &node, nodes ) {
         flatNodes << JavaScriptModel::childFunctions( node );
     }
 
     // Remove old script child items
     const QModelIndex index = indexFromProjectItem( scriptItem );
     if ( !scriptItem->children().isEmpty() ) {
         if ( emitSignals ) {
             beginRemoveRows( index, 0, rowCount(index) );
             scriptItem->clearChildren();
             endRemoveRows();
         } else {
             scriptItem->clearChildren();
         }
     }
 
     // Insert new script child items
     QList< FunctionNode::Ptr > functionNodes;
     foreach ( const CodeNode::Ptr &node, flatNodes ) {
         const FunctionNode::Ptr functionNode = node.dynamicCast<FunctionNode>();
         if ( functionNode ) {
             functionNodes << functionNode;
         }
     }
     if ( emitSignals ) {
         beginInsertRows( index, 0, functionNodes.count() - 1 );
     }
     foreach ( const FunctionNode::Ptr &functionNode, functionNodes ) {
         scriptItem->addChild( new ProjectModelCodeItem(project, functionNode) );
     }
     if ( emitSignals ) {
         endInsertRows();
     }
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 void ProjectModel::scriptSaved()
 {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     Project *project = qobject_cast< Project* >( sender() );
     Q_ASSERT( project );
     if ( !m_changedScriptProjects.contains(project) ) {
         m_changedScriptProjects << project;
     }
 
     if ( project->suppressMessages() ) {
         return;
     }
     if ( !m_updateProjectsTimer ) {
         m_updateProjectsTimer = new QTimer( this );
         connect( m_updateProjectsTimer, SIGNAL(timeout()), this, SLOT(updateProjects()) );
     }
     m_updateProjectsTimer->start( 250 );
 #endif
 }
 
 void ProjectModel::setAsActiveProjectRequest()
 {
     Project *project = qobject_cast< Project* >( sender() );
     if ( project ) {
         setActiveProject( project );
     } else {
-        kWarning() << "Slot setAsActiveProjectRequest() not called from Project";
+        qWarning() << "Slot setAsActiveProjectRequest() not called from Project";
     }
 }
 
 TabType ProjectModelItem::tabTypeFromProjectItemType( ProjectModelItem::Type projectItemType )
 {
     switch ( projectItemType ) {
     case DashboardItem:
         return Tabs::Dashboard;
     case ProjectSourceItem:
         return Tabs::ProjectSource;
     case PlasmaPreviewItem:
         return Tabs::PlasmaPreview;
     case WebItem:
         return Tabs::Web;
     case GtfsDatabaseItem:
         return Tabs::GtfsDatabase;
     case ScriptItem:
     case IncludedScriptItem:
         return Tabs::Script;
 
     case CodeItem:
     case ProjectItem:
     default:
         return Tabs::NoTab;
     }
 }
 
 ProjectModelItem::Type ProjectModelItem::projectItemTypeFromTabType( TabType tabType )
 {
     switch ( tabType ) {
     case Tabs::Dashboard:
         return DashboardItem;
     case Tabs::ProjectSource:
         return ProjectSourceItem;
     case Tabs::Script:
         return ScriptItem;
     case Tabs::GtfsDatabase:
         return GtfsDatabaseItem;
     case Tabs::PlasmaPreview:
         return PlasmaPreviewItem;
     case Tabs::Web:
         return WebItem;
     case Tabs::NoTab:
     default:
         return ProjectItem;
     }
 }
 
 void ProjectModel::slotProjectModified()
 {
     Project *project = qobject_cast< Project* >( sender() );
     if ( !project ) {
         TestModel *testModel = qobject_cast< TestModel* >( sender() );
         Q_ASSERT( testModel );
 
         project = testModel->project();
     }
     Q_ASSERT( project );
 
     // Inform about changes in the project root item
     const QModelIndex index = indexFromProject( project );
     emit dataChanged( index, index );
 
     // Inform about changes in the children of the project item
     ProjectModelItem *projectItem = projectItemFromIndex( index );
     if ( !projectItem->children().isEmpty() ) {
         const QModelIndex beginChild = createIndex( 0, 0,  projectItem->children().first() );
         const QModelIndex endChild = createIndex( m_projects.count() - 1, 0,
                                                   projectItem->children().last() );
         emit dataChanged( beginChild, endChild );
     }
 
     // Notify about changes in the project
     emit projectModified( project );
 }
 
 void ProjectModel::removeProject( Project *project )
 {
     const QModelIndex index = indexFromProject( project );
     if ( !index.isValid() ) {
         kDebug() << "Project not found" << project->projectName();
         return;
     }
 
     removeRows( index.row(), 1 );
 }
 
 bool ProjectModel::removeRows( int row, int count, const QModelIndex &parent )
 {
     beginRemoveRows( parent, row, row + count - 1 );
     for ( int i = 0; i < count; ++i ) {
         ProjectModelItem *projectItem = m_projects.takeAt( row );
         emit projectAboutToBeRemoved( projectItem->project() );
 
         if ( m_activeProject == projectItem->project() ) {
             // The active project gets removed, find another project to use as active project
             const int newRow = row <= 0 ? 1 : row - 1;
             if ( newRow >= rowCount() ) {
                 // No other project found
                 if ( m_activeProject ) {
                     setActiveProject( 0 );
                 }
             } else {
                 setActiveProject( m_projects[newRow]->project() );
 
                 const QModelIndex index = indexFromRow( newRow );
                 dataChanged( index, index );
             }
         }
 
         delete projectItem;
     }
     endRemoveRows();
     return true;
 }
 
 void ProjectModel::clear()
 {
     foreach ( ProjectModelItem *projectItem, m_projects ) {
         emit projectAboutToBeRemoved( projectItem->project() );
     }
 
     setActiveProject( 0 );
 
     beginRemoveRows( QModelIndex(), 0, m_projects.count() );
     qDeleteAll( m_projects );
     m_projects.clear();
     endRemoveRows();
 }
 
 QModelIndex ProjectModel::indexFromRow( int row ) const
 {
     if ( row < 0 || row >= m_projects.count() ) {
         return QModelIndex();
     } else {
         return createIndex( row, 0, m_projects[row] );
     }
 }
 
 QModelIndex ProjectModel::indexFromProject( Project *project ) const
 {
     for ( int row = 0; row < m_projects.count(); ++row ) {
         ProjectModelItem *projectItem = m_projects[ row ];
         if ( projectItem->project() == project ) {
             return createIndex( row, 0, projectItem );
         }
     }
 
     // Project not found
     return QModelIndex();
 }
 
 QModelIndex ProjectModel::indexFromProjectItem( ProjectModelItem *projectItem ) const
 {
     if ( projectItem->parent() ) {
         return createIndex( projectItem->parent()->children().indexOf(projectItem), 0, projectItem );
     } else {
         return createIndex( m_projects.indexOf(projectItem), 0, projectItem );
     }
 }
 
 ProjectModelItem *ProjectModel::projectItemFromIndex( const QModelIndex &index ) const
 {
     Q_ASSERT( index.model() == this );
     return static_cast< ProjectModelItem* >( index.internalPointer() );
 }
 
 ProjectModelItem *ProjectModel::projectItemFromRow( int row ) const
 {
     if ( row < 0 || row >= m_projects.count() ) {
         return 0;
     } else {
         return m_projects[ row ];
     }
 }
 
 ProjectModelItem *ProjectModel::projectItemChildFromProject( Project *project,
                                                              ProjectModelItem::Type type ) const
 {
     ProjectModelItem *projectItem = projectItemFromProject( project );
     if ( !projectItem ) {
         return 0;
     }
 
     foreach ( ProjectModelItem *item, projectItem->children() ) {
         if ( item->type() == type ) {
             return item;
         }
     }
 
     // Not found
-    kWarning() << "Project" << project->data()->id() << "has no child of type" << type;
+    qWarning() << "Project" << project->data()->id() << "has no child of type" << type;
     return 0;
 }
 
 void ProjectModel::testAllProjects()
 {
     // First store all tests of all projects in the list of started tests,
     // otherwise the total number of tests isn't ready when testing starts
     foreach ( ProjectModelItem *projectItem, m_projects ) {
         m_startedTests.insert( projectItem->project(), TestModel::allTests() );
     }
 
     // Start the tests
     foreach ( ProjectModelItem *projectItem, m_projects ) {
         projectItem->project()->testProject();
     }
 }
 
 void ProjectModel::projectTestProgress( const QList< TestModel::Test > &projectFinishedTests,
                                         const QList< TestModel::Test > &projectStartedTests )
 {
     Project *progressProject = qobject_cast< Project* >( sender() );
     Q_ASSERT( progressProject );
 
     QHash< Project*, QList< TestModel::Test > > finishedTests = m_finishedTests;
     QHash< Project*, QList< TestModel::Test > > startedTests;
     int finishedTestCount = 0, startedTestCount = 0;
     foreach ( ProjectModelItem *projectItem, m_projects ) {
         Project *project = projectItem->project();
         const QList< TestModel::Test > finishedTestsOfProject =
                 project == progressProject ? projectFinishedTests : project->finishedTests();
         const QList< TestModel::Test > startedTestsOfProject =
                 project == progressProject ? projectStartedTests : project->startedTests();
 
         if ( finishedTestsOfProject.isEmpty() ) {
             // Finished tests are not available from Project
             // after the test was finished for the project, add number of finished tests
             // stored in m_finishedTests
             finishedTestCount += m_finishedTests[ project ].count();
         } else {
             finishedTests.insert( project, finishedTestsOfProject );
             finishedTestCount += finishedTestsOfProject.count();
         }
         if ( !startedTestsOfProject.isEmpty() ) {
             startedTests.insert( project, startedTestsOfProject );
             startedTestCount += startedTestsOfProject.count();
         }
     }
 
     // Store finished tests and use stored list of started tests, if any
     m_finishedTests = finishedTests;
     if ( m_startedTests.isEmpty() ) {
         m_startedTests = startedTests;
     } else {
         startedTests = m_startedTests;
 
         startedTestCount = 0;
         for ( QHash< Project*, QList< TestModel::Test > >::ConstIterator it = startedTests.constBegin();
               it != startedTests.constEnd(); ++it )
         {
             startedTestCount += it->count();
         }
     }
 
     emit testProgress( finishedTestCount, startedTestCount );
     emit testProgress( finishedTests, startedTests );
 
     if ( finishedTestCount == startedTestCount ) {
         m_startedTests.clear();
         m_finishedTests.clear();
     }
 }
diff --git a/engine/timetablemate/src/projectsettingsdialog.cpp b/engine/timetablemate/src/projectsettingsdialog.cpp
index 022bbc2..d777c6d 100644
--- a/engine/timetablemate/src/projectsettingsdialog.cpp
+++ b/engine/timetablemate/src/projectsettingsdialog.cpp
@@ -1,979 +1,979 @@
 /*
 *   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 "projectsettingsdialog.h"
 
 // Own includes
 #include "ui_timetablemateview_base.h"
 #include "project.h"
 #include "settings.h"
 #include "changelogwidget.h"
 #include "serviceproviderdatawriter.h"
 #include "serviceproviderdatatester.h"
 
 // PublicTransport engine includes
 #include <engine/serviceprovider.h>
 #include <engine/serviceproviderglobal.h>
 #include <engine/serviceproviderdata.h>
 #include <engine/serviceproviderdatareader.h>
 #include <engine/global.h>
 
 // KDE includes
 #include <KUser>
 #include <KEMailSettings>
 #include <KFileDialog>
 #include <KMessageBox>
 #include <KInputDialog>
 #include <KColorScheme>
 #include <KLocale>
 #include <KMessageWidget>
 #include <KLineEdit>
 #include <KActionCollection>
 
 #ifdef MARBLE_FOUND
     #include <marble/LatLonEdit.h>
 #endif
 
 // Qt includes
 #include <QtGui/QLabel>
 #include <QMenu>
 #include <QBuffer>
 #include <QFile>
 #include <QSignalMapper>
 #include <QTimer>
 #include <QEvent>
 #include <QScrollArea>
 #include <QValidator>
 #include <QLayout>
 #include <QFormLayout>
 #include <QToolBar>
 
 ProjectSettingsDialog::ProjectSettingsDialog( QWidget *parent )
         : KDialog(parent), ui_provider(new Ui::timetablemateview_base()), m_providerData(0),
           m_shortAuthorAutoFilled(false), m_shortUrlAutoFilled(false),
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
           m_newScriptTemplateType(Project::NoScriptTemplate),
 #endif
           m_cityName(0), m_cityReplacement(0), m_changelog(0),
           m_actions(new KActionCollection(this)), m_mapper(0)
 {
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     KGlobal::locale()->insertCatalog( "timezones4" );
 #endif
 
     QWidget *widget = new QWidget( this );
     widget->setAutoFillBackground( false );
     ui_provider->setupUi( widget );
     setMainWidget( widget );
     setCaption( i18nc("@title:window", "Project Settings") );
     setButtons( KDialog::Ok | KDialog::Cancel | KDialog::User1 );
     setButtonIcon( KDialog::User1, KIcon("dialog-ok-apply") );
     setButtonText( KDialog::User1, i18nc("@info/plain", "Check") );
 
     QToolBar *notesToolBar = new QToolBar( "notesToolBar", ui_provider->tabNotes );
     QToolBar *notesToolBar2 = new QToolBar( "notesToolBar2", ui_provider->tabNotes );
     ui_provider->notesLayout->insertWidget( 0, notesToolBar );
     ui_provider->notesLayout->insertWidget( 1, notesToolBar2 );
     ui_provider->notes->createActions( m_actions );
     QAction *separator1 = new QAction( this ), *separator2 = new QAction( this );
     separator1->setSeparator( true );
     separator2->setSeparator( true );
     notesToolBar->addActions( QList<QAction*>()
             << m_actions->action("format_text_bold")
             << m_actions->action("format_text_italic")
             << m_actions->action("format_text_underline")
             << m_actions->action("format_text_strikeout")
             << separator1
             << m_actions->action("format_align_left")
             << m_actions->action("format_align_center")
             << m_actions->action("format_align_right")
             << m_actions->action("format_align_justify")
             << separator2
             << m_actions->action("insert_horizontal_rule")
             << m_actions->action("manage_link")
             << m_actions->action("format_painter") );
     notesToolBar2->addActions( QList<QAction*>()
             << m_actions->action("format_font_family")
             << m_actions->action("format_font_size")
             << m_actions->action("format_list_style") );
 
     settingsChanged();
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     // Initialize script file buttons
     ui_provider->btnBrowseForScriptFile->setIcon( KIcon("document-open") );
     ui_provider->btnCreateScriptFile->setIcon( KIcon("document-new") );
     ui_provider->btnDetachScriptFile->setIcon( KIcon("list-remove") );
     ui_provider->btnDetachScriptFile->setVisible( false );
     connect( ui_provider->btnBrowseForScriptFile, SIGNAL(clicked(bool)),
              this, SLOT(browseForScriptFile()) );
     connect( ui_provider->btnCreateScriptFile, SIGNAL(clicked(bool)),
              this, SLOT(createScriptFile()) );
     connect( ui_provider->btnDetachScriptFile, SIGNAL(clicked(bool)),
              this, SLOT(detachScriptFile()) );
 #endif
 
     // Initialize the language button
     ui_provider->currentLanguage->loadAllLanguages();
     ui_provider->currentLanguage->insertLanguage( "en", QString(), 0 );
     ui_provider->currentLanguage->insertSeparator( 1 );
     connect( ui_provider->currentLanguage, SIGNAL(activated(QString)),
              this, SLOT(languageActivated(QString)) );
 
     // Autofill short author/URL fields, if they are empty
     // while editing the full author/URL fields
     connect( ui_provider->author, SIGNAL(textEdited(QString)),
              this, SLOT(authorEdited(QString)) );
     connect( ui_provider->shortAuthor, SIGNAL(textEdited(QString)),
              this, SLOT(shortAuthorEdited(QString)) );
     connect( ui_provider->url, SIGNAL(textEdited(QString)),
              this, SLOT(urlEdited(QString)) );
     connect( ui_provider->shortUrl, SIGNAL(textEdited(QString)),
              this, SLOT(shortUrlEdited(QString)) );
 
     // Initialize the KEditListWidget for predefined cities
     QWidget *repWidget = new QWidget( this );
     QHBoxLayout *customEditorLayout = new QHBoxLayout( repWidget );
     m_cityName = new KLineEdit( this );
     m_cityReplacement = new KLineEdit( this );
     QLabel *lblCityReplacement = new QLabel( i18nc("@info", "Replace with:"), this );
     lblCityReplacement->setAlignment( Qt::AlignRight | Qt::AlignVCenter );
     customEditorLayout->addWidget( m_cityName );
     customEditorLayout->addWidget( lblCityReplacement );
     customEditorLayout->addWidget( m_cityReplacement );
     KLineEdit *defaultLineEdit = new KLineEdit();
     m_predefinedCitiesCustomEditor.setLineEdit( defaultLineEdit );
     defaultLineEdit->hide();
 
     m_predefinedCitiesCustomEditor.setRepresentationWidget( repWidget );
     ui_provider->predefinedCities->setCustomEditor( m_predefinedCitiesCustomEditor );
     connect( m_cityName, SIGNAL(textChanged(QString)),
              this, SLOT(predefinedCityNameChanged(QString)) );
     connect( m_cityReplacement, SIGNAL(textChanged(QString)),
              this, SLOT(predefinedCityReplacementChanged(QString)) );
     connect( defaultLineEdit, SIGNAL(textChanged(QString)),
              this, SLOT(currentPredefinedCityChanged(QString)) );
 
     // Set a validator for version line edits, allow major, minor and path version
     QRegExpValidator *versionValidator =
             new QRegExpValidator( QRegExp("\\d+(\\.\\d+)?(\\.\\d+)?"), this );
     ui_provider->version->setValidator( versionValidator );
 
     // Set a validator for the email line edit
     // The reg exp is "inspired" by http://www.regular-expressions.info/email.html
     QRegExp rx( "[a-z0-9!#$%&\\._-]+@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z]{2,4}",
                 Qt::CaseInsensitive );
     QRegExpValidator *emailValidator = new QRegExpValidator( rx, this );
     ui_provider->email->setValidator( emailValidator );
 
     // Install event filters to filter out focus out events
     // if the line edit's text cannot be validated
     ui_provider->version->installEventFilter( this );
     ui_provider->name->installEventFilter( this );
     ui_provider->description->installEventFilter( this );
     ui_provider->author->installEventFilter( this );
     ui_provider->shortAuthor->installEventFilter( this );
     ui_provider->email->installEventFilter( this );
     ui_provider->url->installEventFilter( this );
     ui_provider->shortUrl->installEventFilter( this );
 
     // Set icons and connections for the "open url buttons"
     ui_provider->btnUrlOpen->setIcon( KIcon("document-open-remote") );
     connect( ui_provider->btnUrlOpen, SIGNAL(clicked(bool)),
              this, SLOT(openUrlClicked()) );
 
     // Add changelog widget into a scroll area
     QVBoxLayout *changelogAreaLayout = new QVBoxLayout( ui_provider->tabChangelog );
     QScrollArea *changelogArea = new QScrollArea( ui_provider->tabChangelog );
     changelogArea->setFrameStyle( QFrame::NoFrame );
     changelogArea->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
     changelogArea->setWidgetResizable( true );
     changelogAreaLayout->addWidget( changelogArea );
 
     QWidget *changelogAreaWidget = new QWidget( changelogArea );
     changelogArea->setWidget( changelogAreaWidget );
     QVBoxLayout *changelogLayout = new QVBoxLayout( changelogAreaWidget );
     m_changelog = new ChangelogWidget( changelogAreaWidget );
     m_changelog->clear();
     changelogLayout->addWidget( m_changelog );
     changelogLayout->addStretch();
 
     connect( m_changelog, SIGNAL(changelogEntryWidgetAdded(ChangelogEntryWidget*)),
              this, SLOT(changelogEntryWidgetAdded(ChangelogEntryWidget*)) );
 
     // Add vehicle types with icons to the default vehicle type combo box
     ui_provider->defaultVehicleType->addItem( KIcon("status_unknown"),
             i18nc("@item:listbox", "Unknown"), Enums::toString(Enums::UnknownVehicleType) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_tram"),
             i18nc("@item:listbox", "Tram"), Enums::toString(Enums::Tram) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_bus"),
             i18nc("@item:listbox", "Bus"), Enums::toString(Enums::Bus) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_subway"),
             i18nc("@item:listbox", "Subway"), Enums::toString(Enums::Subway) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_train_interurban"),
             i18nc("@item:listbox", "Interurban Train"), Enums::toString(Enums::InterurbanTrain) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_metro"),
             i18nc("@item:listbox", "Metro"), Enums::toString(Enums::Metro) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_trolleybus"),
             i18nc( "@item:listbox", "Trolley Bus"), Enums::toString(Enums::TrolleyBus) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_train_regional"), // TODO: Currently no special icon
             i18nc("@item:listbox", "Regional Train"), Enums::toString(Enums::RegionalTrain) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_train_regional"),
             i18nc("@item:listbox", "Regional Express Train"),
             Enums::toString(Enums::RegionalExpressTrain) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_train_interregional"),
             i18nc("@item:listbox", "Interregional Train"),
             Enums::toString(Enums::InterregionalTrain) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_train_intercity"),
             i18nc("@item:listbox", "Intercity/Eurocity Train"),
             Enums::toString(Enums::IntercityTrain) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_train_highspeed"),
             i18nc("@item:listbox", "Intercity Express Train"),
             Enums::toString(Enums::HighSpeedTrain) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_ferry"),
             i18nc("@item:listbox", "Ferry"), Enums::toString(Enums::Ferry) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_ferry"),
             i18nc("@item:listbox", "Ship"), Enums::toString(Enums::Ship) );
     ui_provider->defaultVehicleType->addItem( KIcon("vehicle_type_plane"),
             i18nc("@item:listbox", "Plane"), Enums::toString(Enums::Plane) );
 
 #ifdef MARBLE_FOUND
     // Create and insert Marble::LatLonEdit widgets
     ui_sampleLongitude = new Marble::LatLonEdit( widget, Marble::Longitude );
     ui_sampleLatitude = new Marble::LatLonEdit( widget, Marble::Latitude );
     QFormLayout *layout = qobject_cast< QFormLayout* >( ui_provider->tabSamples->layout() );
     layout->addRow( i18nc("@info", "Sample &Longitude:"), ui_sampleLongitude );
     layout->addRow( i18nc("@info", "Sample &Latitude:"), ui_sampleLatitude );
 #endif
 
     // Connect all change signals of the widgets to the changed() signal
     m_mapper = new QSignalMapper( this );
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     connect( ui_provider->scriptFile, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->scriptExtensions, SIGNAL(itemChanged(QListWidgetItem*)), m_mapper, SLOT(map()) );
     m_mapper->setMapping( ui_provider->scriptFile, ui_provider->scriptFile );
     m_mapper->setMapping( ui_provider->scriptExtensions, ui_provider->scriptExtensions );
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     connect( ui_provider->gtfsFeed, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->gtfsTripUpdates, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->gtfsAlerts, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->timeZone, SIGNAL(itemSelectionChanged()), m_mapper, SLOT(map()) );
     m_mapper->setMapping( ui_provider->gtfsFeed, ui_provider->gtfsFeed );
     m_mapper->setMapping( ui_provider->gtfsTripUpdates, ui_provider->gtfsTripUpdates );
     m_mapper->setMapping( ui_provider->gtfsAlerts, ui_provider->gtfsAlerts );
     m_mapper->setMapping( ui_provider->timeZone, ui_provider->timeZone );
 #endif
 #ifdef MARBLE_FOUND
     connect( ui_sampleLongitude, SIGNAL(valueChanged(qreal)), m_mapper, SLOT(map()) );
     connect( ui_sampleLatitude, SIGNAL(valueChanged(qreal)), m_mapper, SLOT(map()) );
     m_mapper->setMapping( ui_sampleLongitude, ui_sampleLongitude );
     m_mapper->setMapping( ui_sampleLatitude, ui_sampleLatitude );
 #endif
     connect( ui_provider->name, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->description, SIGNAL(textChanged()), m_mapper, SLOT(map()) );
     connect( ui_provider->version, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->useCityValue, SIGNAL(stateChanged(int)), m_mapper, SLOT(map()) );
     connect( ui_provider->onlyAllowPredefinedCities, SIGNAL(stateChanged(int)), m_mapper, SLOT(map()) );
     connect( ui_provider->url, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->shortUrl, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->credit, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->minFetchWait, SIGNAL(valueChanged(int)), m_mapper, SLOT(map()) );
     connect( ui_provider->author, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->shortAuthor, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->email, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( ui_provider->defaultVehicleType, SIGNAL(currentIndexChanged(int)), m_mapper, SLOT(map()) );
     connect( ui_provider->predefinedCities, SIGNAL(changed()), m_mapper, SLOT(map()) );
     connect( ui_provider->sampleStopNames, SIGNAL(changed()), m_mapper, SLOT(map()) );
     connect( ui_provider->sampleCity, SIGNAL(textChanged(QString)), m_mapper, SLOT(map()) );
     connect( m_changelog, SIGNAL(added(QWidget*)), m_mapper, SLOT(map()) );
     connect( m_changelog, SIGNAL(removed(QWidget*,int)), m_mapper, SLOT(map()) );
     connect( m_changelog, SIGNAL(changed()), m_mapper, SLOT(map()) );
     // TODO Map changes in the changelog, ie. changing the version or message text
     m_mapper->setMapping( ui_provider->name, ui_provider->name );
     m_mapper->setMapping( ui_provider->description, ui_provider->description );
     m_mapper->setMapping( ui_provider->version, ui_provider->version );
     m_mapper->setMapping( ui_provider->useCityValue, ui_provider->useCityValue );
     m_mapper->setMapping( ui_provider->onlyAllowPredefinedCities, ui_provider->onlyAllowPredefinedCities );
     m_mapper->setMapping( ui_provider->url, ui_provider->url );
     m_mapper->setMapping( ui_provider->shortUrl, ui_provider->shortUrl );
     m_mapper->setMapping( ui_provider->credit, ui_provider->credit );
     m_mapper->setMapping( ui_provider->minFetchWait, ui_provider->minFetchWait );
     m_mapper->setMapping( ui_provider->author, ui_provider->author );
     m_mapper->setMapping( ui_provider->shortAuthor, ui_provider->shortAuthor );
     m_mapper->setMapping( ui_provider->email, ui_provider->email );
     m_mapper->setMapping( ui_provider->defaultVehicleType, ui_provider->defaultVehicleType );
     m_mapper->setMapping( ui_provider->predefinedCities, ui_provider->predefinedCities );
     m_mapper->setMapping( ui_provider->sampleStopNames, ui_provider->sampleStopNames );
     m_mapper->setMapping( ui_provider->sampleCity, ui_provider->sampleCity );
     m_mapper->setMapping( m_changelog, m_changelog );
     connect( m_mapper, SIGNAL(mapped(QWidget*)), this, SLOT(slotChanged(QWidget*)) );
 }
 
 ProjectSettingsDialog::~ProjectSettingsDialog()
 {
     delete ui_provider;
 }
 
 void ProjectSettingsDialog::slotChanged( QWidget *changedWidget )
 {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     if( changedWidget == ui_provider->scriptFile ) {
         // Script file changed
         const QString fileName = ui_provider->scriptFile->text();
         ui_provider->btnCreateScriptFile->setVisible( fileName.isEmpty() );
         ui_provider->btnDetachScriptFile->setVisible( !fileName.isEmpty() );
         emit scriptFileChanged( fileName );
     } else
 #endif
     if( changedWidget == ui_provider->url ) {
         // Home page URL changed
         ui_provider->btnUrlOpen->setDisabled( ui_provider->url->text().isEmpty() );
     } else if( changedWidget == ui_provider->shortAuthor ) {
         // Short author name changed, update changed log click messages
         QList<ChangelogEntryWidget *> entryWidgets = m_changelog->entryWidgets();
         foreach( const ChangelogEntryWidget * entryWidget, entryWidgets ) {
             entryWidget->authorLineEdit()->setClickMessage( m_providerData->shortAuthor() );
         }
     }
 
     fillValuesFromWidgets();
     emit changed();
 }
 
 bool ProjectSettingsDialog::check()
 {
     bool result = testWidget( ui_provider->email );
     result = testWidget( ui_provider->version ) && result;
     result = testWidget( ui_provider->name ) && result;
     result = testWidget( ui_provider->description ) && result;
     result = testWidget( ui_provider->author ) && result;
     result = testWidget( ui_provider->shortAuthor ) && result;
     result = testWidget( ui_provider->url ) && result;
     result = testWidget( ui_provider->shortUrl ) && result;
     return result;
 }
 
 void ProjectSettingsDialog::slotButtonClicked( int button )
 {
     if ( button == KDialog::Ok ) {
         fillValuesFromWidgets();
         accept();
     } else if ( button == KDialog::User1 ) {
         if ( check() ) {
             KMessageWidget *messageWidget = new KMessageWidget(
                     i18nc("@info", "All settings are valid"), this );
             messageWidget->setMessageType( KMessageWidget::Positive );
             mainWidget()->layout()->addWidget( messageWidget );
             messageWidget->animatedShow();
 
             // Install an event filter to delete the message widget after the widget was hidden
             messageWidget->installEventFilter( this );
 
             // Hide after 4 seconds
             QTimer::singleShot( 4000, messageWidget, SLOT(animatedHide()) );
         }
     } else {
         KDialog::slotButtonClicked( button );
     }
 }
 
 void ProjectSettingsDialog::accept()
 {
 //     if ( check() ) {
         QDialog::accept();
 //     }
 }
 
 bool ProjectSettingsDialog::eventFilter( QObject *object, QEvent *event )
 {
     QWidget *widget = qobject_cast< QWidget* >( object );
     if ( widget && event->type() == QEvent::FocusOut ) {
         testWidget( widget );
     }
 
     KMessageWidget *messageWidget = qobject_cast< KMessageWidget*> ( object );
     if ( messageWidget && event->type() == QEvent::Hide ) {
         // Delete message widgets after they are hidden
         messageWidget->deleteLater();
     }
 
     return QDialog::eventFilter( object, event );
 }
 
 TestModel::Test testFromWidget( Ui::timetablemateview_base *ui, QWidget *widget )
 {
     if ( widget == ui->email ) {
         return TestModel::ServiceProviderDataEmailTest;
     } else if ( widget == ui->name ) {
         return TestModel::ServiceProviderDataNameTest;
     } else if ( widget == ui->version ) {
         return TestModel::ServiceProviderDataVersionTest;
     } else if ( widget == ui->author ) {
         return TestModel::ServiceProviderDataAuthorNameTest;
     } else if ( widget == ui->shortAuthor ) {
         return TestModel::ServiceProviderDataShortAuthorNameTest;
     } else if ( widget == ui->url ) {
         return TestModel::ServiceProviderDataUrlTest;
     } else if ( widget == ui->shortUrl ) {
         return TestModel::ServiceProviderDataShortUrlTest;
     } else if ( widget == ui->scriptFile ) {
         return TestModel::ServiceProviderDataScriptFileNameTest;
     } else if ( widget == ui->gtfsFeed ) {
         return TestModel::ServiceProviderDataGtfsFeedUrlTest;
     } else if ( widget == ui->description ) {
         return TestModel::ServiceProviderDataDescriptionTest;
     } else {
-        kWarning() << "Unknown widget";
+        qWarning() << "Unknown widget";
         return TestModel::InvalidTest;
     }
 }
 
 bool ProjectSettingsDialog::testWidget( QWidget *widget )
 {
     TestModel::Test test = testFromWidget( ui_provider, widget );
     if ( test == TestModel::InvalidTest ) {
         // Unknown widget
         return true;
     }
 
     QString text;
     KLineEdit *lineEdit = qobject_cast< KLineEdit* >( widget );
     if ( lineEdit ) {
         text = lineEdit->text();
     } else {
         KRichTextWidget *richText = qobject_cast< KRichTextWidget* >( widget );
         if ( richText ) {
             text = richText->textOrHtml();
         } else {
-            kWarning() << "Unknown widget type";
+            qWarning() << "Unknown widget type";
             return false;
         }
     }
 
     QString errorMessage;
     if ( !ServiceProviderDataTester::runServiceProviderDataTest(test, text, &errorMessage) ) {
         appendMessageWidgetAfter( widget, errorMessage );
         return false;
     }
 
     return true;
 }
 
 void ProjectSettingsDialog::appendMessageWidgetAfter( QWidget *after, const QString &errorMessage )
 {
     if ( !after || !after->isVisible() ) {
         // The widget after which the error message should be shown is not visible,
         // ie. it is not in the current tab, use the last widget of the current tab instead
         QWidget *tab = ui_provider->tabWidget->currentWidget();
         after = tab->layout()->itemAt( tab->layout()->count() - 1 )->widget();
         if ( !after ) {
-            kWarning() << "Could not find last widget in current tab to show this error message:"
+            qWarning() << "Could not find last widget in current tab to show this error message:"
                        << errorMessage;
             return;
         }
     }
 
     QFormLayout *formLayout = qobject_cast< QFormLayout* >( after->parentWidget()->layout() );
     Q_ASSERT( formLayout );
 
     // Get the position of the QWidget after which the message widget should be inserted
     int row;
     QFormLayout::ItemRole role;
     formLayout->getWidgetPosition( after, &row, &role );
 
     // Check if there already is a KMessageWidget
     QLayoutItem *item = row == -1 ? 0 : formLayout->itemAt(row + 1, QFormLayout::FieldRole);
     KMessageWidget *messageWidget = !item ? 0 : qobject_cast< KMessageWidget* >( item->widget() );
 
     // Check if a message was already shown
     if ( messageWidget ) {
         // Found an existing KMessageWidget after the widget,
         // update it instead of creating a new one
         messageWidget->setText( errorMessage );
     } else {
         // Create a message widget showing where the error is
         messageWidget = new KMessageWidget( errorMessage, after->parentWidget() );
         messageWidget->setMessageType( KMessageWidget::Error );
 
         // Insert the message widget after the widget with the erroneous content
         formLayout->insertRow( row + 1, messageWidget );
         messageWidget->animatedShow();
 
         // Install an event filter to delete the message widget after the widget was hidden
         messageWidget->installEventFilter( this );
 
         // Hide after 4 seconds
         QTimer::singleShot( 4000, messageWidget, SLOT(animatedHide()) );
     }
 }
 
 void ProjectSettingsDialog::fillValuesFromWidgets()
 {
     // Fill struct with current values of the widgets
     QString lang = ui_provider->currentLanguage->current();
     if( lang == QLatin1String("en_US") ) {
         lang = "en";
     }
 
     QHash< QString, QString > names = m_providerData->names();
     QHash< QString, QString > descriptions = m_providerData->descriptions();
     names[lang] = ui_provider->name->text();
     descriptions[lang] = ui_provider->description->toPlainText();
     const Enums::VehicleType defaultVehicleType = Global::vehicleTypeFromString(
             ui_provider->defaultVehicleType->itemData(
             ui_provider->defaultVehicleType->currentIndex()).toString() );
 
     QStringList cities;
     QHash< QString, QString > cityNameReplacements;
     const QStringList cityReplacements = ui_provider->predefinedCities->items();
     foreach( const QString & cityReplacement, cityReplacements ) {
         QStringList values = cityReplacement.split( "   ->   " );
         if( values.count() == 2 ) {
             cities << values.at( 0 );
             cityNameReplacements.insert( values.at(0).toLower(), values.at(1) );
         } else {
             cities << cityReplacement;
         }
     }
 
     // Update values that can be edited in this dialog
     m_providerData->setNames( names );
     m_providerData->setDescriptions( descriptions );
     m_providerData->setVersion( ui_provider->version->text() );
     m_providerData->setFileFormatVersion( "1.1" ); // Update to current format version
     m_providerData->setUseSeparateCityValue( ui_provider->useCityValue->isChecked() );
     m_providerData->setOnlyUseCitiesInList( ui_provider->onlyAllowPredefinedCities->isChecked() );
     m_providerData->setUrl( ui_provider->url->text(), ui_provider->shortUrl->text() );
     m_providerData->setCredit( ui_provider->credit->text() );
     m_providerData->setMinFetchWait( ui_provider->minFetchWait->value() );
     m_providerData->setAuthor( ui_provider->author->text(), ui_provider->shortAuthor->text(),
                                ui_provider->email->text() );
     m_providerData->setDefaultVehicleType( defaultVehicleType );
     m_providerData->setChangelog( m_changelog->changelog() );
     m_providerData->setCities( cities );
     m_providerData->setCityNameToValueReplacementHash( cityNameReplacements );
     m_providerData->setSampleCity( ui_provider->sampleCity->text() );
     m_providerData->setSampleStops( ui_provider->sampleStopNames->items() );
 #ifdef MARBLE_FOUND
     m_providerData->setSampleCoordinates( ui_sampleLongitude->value(),
                                           ui_sampleLatitude->value() );
 #endif
     m_providerData->setNotes( ui_provider->notes->textOrHtml() );
 
     switch ( m_providerData->type() ) {
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Enums::ScriptedProvider:
         m_providerData->setScriptFile( ui_provider->scriptFile->text(),
                                        scriptExtensionsFromWidget() );
         break;
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case Enums::GtfsProvider:
         m_providerData->setFeedUrl( ui_provider->gtfsFeed->text() );
         m_providerData->setRealtimeTripUpdateUrl( ui_provider->gtfsTripUpdates->text() );
         m_providerData->setRealtimeAlertsUrl( ui_provider->gtfsAlerts->text() );
         m_providerData->setTimeZone( ui_provider->timeZone->selection().isEmpty()
                                      ? QString() : ui_provider->timeZone->selection().first() );
         break;
 #endif
     default:
         break;
     }
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 QStringList ProjectSettingsDialog::scriptExtensionsFromWidget() const
 {
     QStringList scriptExtensions;
     for ( int i = 0; i < ui_provider->scriptExtensions->count(); ++i ) {
         QListWidgetItem *item = ui_provider->scriptExtensions->item( i );
         if ( item->checkState() == Qt::Checked ) {
             scriptExtensions << item->text();
         }
     }
     return scriptExtensions;
 }
 
 void ProjectSettingsDialog::checkScriptExtensionsInWidget( const QStringList &scriptExtensions ) const
 {
     for ( int i = 0; i < ui_provider->scriptExtensions->count(); ++i ) {
         QListWidgetItem *item = ui_provider->scriptExtensions->item( i );
         item->setCheckState( scriptExtensions.contains(item->text()) ? Qt::Checked : Qt::Unchecked );
     }
 }
 #endif
 
 void ProjectSettingsDialog::changelogEntryWidgetAdded( ChangelogEntryWidget *entryWidget )
 {
     const int comparison = ServiceProviderData::compareVersions(
             entryWidget->version(), ui_provider->version->text());
     if ( comparison > 0 ) {
         int result = KMessageBox::questionYesNo( this,
                 i18nc("@info", "The new changelog entry references a newer version than the "
                       "current project version. Do you want to update the project version to %1?",
                       entryWidget->version()) );
         if ( result == KMessageBox::Yes ) {
             // Yes clicked, update version value
             ui_provider->version->setText( entryWidget->version() );
         }
     }
 
     // Use short author name as author is none is set
     if ( entryWidget->author().isEmpty() ) {
         entryWidget->setAuthor( ui_provider->shortAuthor->text() );
     }
 
     // Use "Initial version" as default changelog text for the first entry
     if ( m_changelog->entryWidgets().count() == 1 ) {
         entryWidget->setDescription( i18nc("@info/plain Default changelog entry for the "
                                            "first version", "Initial version") );
     }
 }
 
 void ProjectSettingsDialog::authorEdited( const QString &newAuthor )
 {
     if ( ui_provider->shortAuthor->text().isEmpty() || m_shortAuthorAutoFilled ) {
         // Update short author value if it is empty
         m_shortAuthorAutoFilled = true; // Set to auto filled
         ui_provider->shortAuthor->setText( ServiceProviderData::shortAuthorFromAuthor(newAuthor) );
     }
 }
 
 void ProjectSettingsDialog::urlEdited( const QString &newUrl )
 {
     if ( ui_provider->shortUrl->text().isEmpty() || m_shortUrlAutoFilled ) {
         // Update short URL value if it is empty
         m_shortUrlAutoFilled = true; // Set to auto filled
         ui_provider->shortUrl->setText( ServiceProviderData::shortUrlFromUrl(newUrl) );
     }
 }
 
 void ProjectSettingsDialog::shortAuthorEdited( const QString &shortAuthor )
 {
     Q_UNUSED( shortAuthor );
     m_shortAuthorAutoFilled = false;
 }
 
 void ProjectSettingsDialog::shortUrlEdited( const QString &shortUrl )
 {
     Q_UNUSED( shortUrl );
     m_shortUrlAutoFilled = false;
 }
 
 void ProjectSettingsDialog::currentPredefinedCityChanged( const QString &currentCityText )
 {
     QStringList values = currentCityText.split( "   ->   " );
     if( values.count() == 2 ) {
         m_cityName->blockSignals( true );
         m_cityReplacement->blockSignals( true );
 
         m_cityName->setText( values.at( 0 ) );
         m_cityReplacement->setText( values.at( 1 ) );
 
         m_cityName->blockSignals( false );
         m_cityReplacement->blockSignals( false );
     } else {
         m_cityName->blockSignals( true );
         m_cityReplacement->blockSignals( true );
 
         m_cityName->setText( currentCityText );
         m_cityReplacement->setText( QString() );
 
         m_cityName->blockSignals( false );
         m_cityReplacement->blockSignals( false );
     }
 }
 
 void ProjectSettingsDialog::predefinedCityNameChanged( const QString &newCityName )
 {
     QString text = newCityName;
     if( !m_cityReplacement->text().isEmpty() ) {
         text += "   ->   " + m_cityReplacement->text();
     }
 
     m_predefinedCitiesCustomEditor.lineEdit()->setText( text );
 }
 
 void ProjectSettingsDialog::predefinedCityReplacementChanged( const QString &newReplacement )
 {
     QString text = m_cityName->text();
     if( !newReplacement.isEmpty() ) {
         text += "   ->   " + newReplacement;
     }
 
     m_predefinedCitiesCustomEditor.lineEdit()->setText( text );
 }
 
 void ProjectSettingsDialog::languageActivated( const QString &languageCode )
 {
     QString code = languageCode == QLatin1String("en_US") ? "en" : languageCode;
 
     ui_provider->name->blockSignals( true );
     ui_provider->name->setText( m_providerData->names()[code] );
     ui_provider->name->blockSignals( false );
 
     ui_provider->description->blockSignals( true );
     ui_provider->description->setText( m_providerData->descriptions()[code] );
     ui_provider->description->blockSignals( false );
 }
 
 void ProjectSettingsDialog::openUrlClicked()
 {
     emit urlShouldBeOpened( ui_provider->url->text() );
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void ProjectSettingsDialog::createScriptFile()
 {
     if( m_openedPath.isEmpty() ) {
         KMessageBox::information( this, i18nc("@info/plain", "Please save the XML file first. "
                                               "The script file needs to be in the same folder.") );
         return;
     }
 
     // Get a name for the new script file based on the current country code
     // and the current service provider ID
     QString scriptFile = m_providerData->id() + ".js";
 
     // Get fileName for the new script file
     QString scriptFilePath = QUrl( m_openedPath ).directory( QUrl::AppendTrailingSlash ) + scriptFile;
 
     // Check if the file already exists
     QFile file( scriptFilePath );
     if( file.exists() ) {
         int result = KMessageBox::questionYesNoCancel( this,
                      i18nc("@info/plain", "The script file <filename>%1</filename> already exists.<nl/>"
                            "Do you want to overwrite it or open and use it as script file?", scriptFile),
                      i18nc("@title:window", "File Already Exists"),
                      KStandardGuiItem::overwrite(), KStandardGuiItem::open() );
         if( result == KMessageBox::No ) {  // open
             ui_provider->scriptFile->setText( scriptFile );
             return;
         } else if( result == KMessageBox::Cancel ) {
             return;
         }
     }
 
     // Create the file
     if( !file.open( QIODevice::WriteOnly ) ) {
         KMessageBox::information( this, i18nc("@info/plain", "A new script file with the name "
                                               "<filename>%1</filename> could not be created.",
                                               scriptFilePath) );
         return;
     }
     file.close();
 
     const QString scriptType = KInputDialog::getItem(
             i18nc("@title:window", "Choose Script Type"), i18nc("@info", "Script Type"),
             QStringList() << "JavaScript" << "Ruby" << "Python", 0, false, 0, this );
     if( scriptType == QLatin1String("JavaScript") ) {
         m_newScriptTemplateType = Project::ScriptQtScriptTemplate;
     } else if( scriptType == QLatin1String("Ruby") ) {
         m_newScriptTemplateType = Project::ScriptRubyTemplate;
     } else if( scriptType == QLatin1String("Python") ) {
         m_newScriptTemplateType = Project::ScriptPythonTemplate;
     } else {
-        kWarning() << "Unexpected script type" << scriptType;
+        qWarning() << "Unexpected script type" << scriptType;
         return;
     }
 
     ui_provider->scriptFile->setText( scriptFile );
     emit scriptAdded( scriptFilePath );
 }
 
 void ProjectSettingsDialog::detachScriptFile()
 {
     ui_provider->scriptFile->setText( QString() );
     ui_provider->scriptExtensions->clear();
     m_newScriptTemplateType = Project::NoScriptTemplate;
 }
 
 void ProjectSettingsDialog::browseForScriptFile()
 {
     if( m_openedPath.isEmpty() ) {
         KMessageBox::information( this, i18nc( "@info/plain", "Please save the "
                                                "XML file first. The script file needs to be in the same folder." ) );
         return;
     }
 
     QUrl openedUrl( m_openedPath );
 
     // Get a list of all script files in the directory of the XML file
     QStringList scriptFiles;
     int current = -1;
     QDir dir( openedUrl.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() );
     QStringList fileNames = dir.entryList();
     for( int i = 0; i < fileNames.count(); ++i ) {
         QString fileName = fileNames.at( i );
         KMimeType::Ptr mimeType = KMimeType::findByUrl( QUrl( fileName ) );
         if( mimeType->is("application/javascript") ||
             mimeType->is("application/x-ruby") ||
             mimeType->is("text/x-python") )
         {
             scriptFiles << fileName;
             if( fileName == ui_provider->scriptFile->text() ) {
                 current = i;
             }
         }
     }
 
     bool ok;
     QString selectedFile = KInputDialog::getItem( i18nc( "@title:window", "Choose Script File" ),
                            i18nc( "@info", "Script File for Parsing Documents" ),
                            scriptFiles, current, false, &ok, this );
     if( ok ) {
         ui_provider->scriptFile->setText( selectedFile );
     }
 }
 
 void ProjectSettingsDialog::setScriptFile( const QString &scriptFile )
 {
     ui_provider->scriptFile->setText( scriptFile );
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 const ServiceProviderData *ProjectSettingsDialog::providerData( QObject *parent ) const
 {
     return m_providerData->clone(parent);
 }
 
 void ProjectSettingsDialog::setProviderData( const ServiceProviderData *data,
                                              const QString &fileName )
 {
     // Disable changed signals from widgets while setting the read values
     m_mapper->blockSignals( true );
 
     m_shortAuthorAutoFilled = false;
     m_shortUrlAutoFilled = false;
 
     m_providerData = data->clone( data->parent() );
     m_openedPath = fileName;
 
     // Show settings widgets specific to the provider type
     ui_provider->scriptSettingsWidget->setVisible( data->type() == Enums::ScriptedProvider );
     ui_provider->gtfsSettingsWidget->setVisible( data->type() == Enums::GtfsProvider );
 
     if ( data->fileFormatVersion() != QLatin1String("1.1") ) {
         KMessageBox::information( this, i18nc("@info",
                 "<title>Invalid Provider Plugin Format Version</title>"
                 "<para>The provider plugin format version has been set to "
                 "<emphasize strong='1'>1.1</emphasize>, because the specified version "
                 "<emphasize strong='1'>%1</emphasize> is not supported.</para>"
                 "<para>Please make sure that the plugin complies with that version "
                 "and update it if necessary.</para>"
                 "<para><note>You can cancel the settings dialog to not change anything."
                 "</note></para>",
                 data->fileFormatVersion()) );
     }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     ui_provider->scriptFile->setText( data->scriptFileName() );
     checkScriptExtensionsInWidget( data->scriptExtensions() );
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     ui_provider->gtfsFeed->setText( data->feedUrl() );
     ui_provider->gtfsTripUpdates->setText( data->realtimeTripUpdateUrl() );
     ui_provider->gtfsAlerts->setText( data->realtimeAlertsUrl() );
 
     QString errorMessage;
     if ( ServiceProviderDataTester::isTimeZoneValid(data->timeZone(), &errorMessage)
          == TestModel::TestFinishedSuccessfully )
     {
         // Valid time zone name
         ui_provider->timeZone->setSelected( data->timeZone(), true );
     } else {
         // No time zone with that name found
         appendMessageWidgetAfter( ui_provider->timeZone, errorMessage );
     }
 #endif
 
     ui_provider->savePath->setText( fileName );
     ui_provider->currentLanguage->setCurrentItem( "en" );
     ui_provider->name->setText( data->names()["en"] );
     ui_provider->description->setText( data->descriptions()["en"] );
     ui_provider->version->setText( data->version() );
     ui_provider->useCityValue->setChecked( data->useSeparateCityValue() );
     ui_provider->onlyAllowPredefinedCities->setChecked( data->onlyUseCitiesInList() );
     ui_provider->url->setText( data->url() );
     ui_provider->shortUrl->setText( data->shortUrl() );
     ui_provider->credit->setText( data->credit() );
     ui_provider->minFetchWait->setValue( data->minFetchWait() );
     ui_provider->shortAuthor->setText( data->shortAuthor() );
     if ( data->author().isEmpty() ) {
         // Insert user name if empty (and if set in global KDE settings)
         ui_provider->author->setText( KUser().property(KUser::FullName).toString() );
 
         // If no short author string was chosen create one from the full name
         if ( data->shortAuthor().isEmpty() ) {
             ui_provider->shortAuthor->setText(
                     ServiceProviderData::shortAuthorFromAuthor(ui_provider->author->text()) );
         }
     } else {
         ui_provider->author->setText( data->author() );
     }
     if ( data->email().isEmpty() ) {
         // Insert user email if empty (and if set in global KDE settings)
         ui_provider->email->setText( KEMailSettings().getSetting(KEMailSettings::EmailAddress) );
     } else {
         ui_provider->email->setText( data->email() );
     }
     int defaultVehicleTypeIndex =
             ui_provider->defaultVehicleType->findData( Enums::toString(data->defaultVehicleType()) );
     ui_provider->defaultVehicleType->setCurrentIndex(
             defaultVehicleTypeIndex > 0 ? defaultVehicleTypeIndex : 0 );
     m_changelog->clear();
     m_changelog->addChangelog( data->changelog(), data->shortAuthor() );
 
     ui_provider->predefinedCities->clear();
     foreach( const QString & city, data->cities() ) {
         QString lowerCity = city.toLower();
         if( data->cityNameToValueReplacementHash().contains( lowerCity ) ) {
             ui_provider->predefinedCities->insertItem( city + "   ->   " +
                     data->cityNameToValueReplacementHash()[lowerCity] );
         } else {
             ui_provider->predefinedCities->insertItem( city );
         }
     }
 
     ui_provider->sampleStopNames->setItems( data->sampleStopNames() );
     ui_provider->sampleCity->setText( data->sampleCity() );
 #ifdef MARBLE_FOUND
     ui_sampleLongitude->setValue( data->sampleLongitude() );
     ui_sampleLatitude->setValue( data->sampleLatitude() );
 #endif
 
     ui_provider->notes->setText( data->notes() );
 
     // Enable changed signals from widgets again and emit changed signals once
     m_mapper->blockSignals( false );
     emit changed();
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     emit scriptFileChanged( fileName );
 #endif
 }
 
 void ProjectSettingsDialog::settingsChanged()
 {
     emit signalChangeStatusbar( i18n("Settings changed") );
 }
 
 #include "projectsettingsdialog.moc"
 // kate: indent-mode cstyle; indent-width 4; replace-tabs on;
diff --git a/engine/timetablemate/src/serviceproviderdatatester.cpp b/engine/timetablemate/src/serviceproviderdatatester.cpp
index b63e819..7af01f1 100644
--- a/engine/timetablemate/src/serviceproviderdatatester.cpp
+++ b/engine/timetablemate/src/serviceproviderdatatester.cpp
@@ -1,480 +1,480 @@
 /*
 *   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 "serviceproviderdatatester.h"
 
 // Own includes
 #include "testmodel.h"
 #include "project.h"
 
 // Public Transport engine includes
 #include <engine/serviceproviderdata.h>
 
 // KDE includes
 #include <KLocalizedString>
 #include <KDebug>
 #include <QUrl>
 #include <KSystemTimeZones>
 
 // Qt includes
 #include <QFile>
 
 TestModel::TestState  ServiceProviderDataTester::runServiceProviderDataTest( TestModel::Test test,
         const QString &text, QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     switch ( test ) {
     case TestModel::ServiceProviderDataNameTest:
         return isNameValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataVersionTest:
         return isVersionValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataFileFormatVersionTest:
         return isFileVersionValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataAuthorNameTest:
         return isAuthorNameValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataShortAuthorNameTest:
         return isShortAuthorNameValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataEmailTest:
         return isEmailValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataUrlTest:
         return isUrlValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataShortUrlTest:
         return isShortUrlValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataDescriptionTest:
         return isDescriptionValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataScriptFileNameTest:
         return isScriptFileNameValid( text, errorMessage, tooltip, childrenExplanations );
 
     case TestModel::ServiceProviderDataGtfsFeedUrlTest:
         return isGtfsFeedUrlValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataGtfsRealtimeUpdatesUrlTest:
     case TestModel::ServiceProviderDataGtfsRealtimeAlertsTest:
         return isGtfsRealtimeUrlValid( text, errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataTimeZoneTest:
         return isTimeZoneValid( text, errorMessage, tooltip, childrenExplanations );
 
     default:
-        kWarning() << "Unknown test";
+        qWarning() << "Unknown test";
         return TestModel::TestFinishedSuccessfully;
     }
 }
 
 TestModel::TestState ServiceProviderDataTester::runServiceProviderDataTest( TestModel::Test test,
         const ServiceProviderData *data, QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     if ( !TestModel::isTestApplicableTo(test, data, errorMessage, tooltip) ) {
         return TestModel::TestNotApplicable;
     }
 
     switch ( test ) {
     case TestModel::ServiceProviderDataNameTest:
         return isNameValid( data->name(), errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataVersionTest:
         return isVersionValid( data->version(), errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataFileFormatVersionTest:
         return isFileVersionValid( data->fileFormatVersion(), errorMessage, tooltip,
                                    childrenExplanations );
     case TestModel::ServiceProviderDataAuthorNameTest:
         return isAuthorNameValid( data->author(), errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataShortAuthorNameTest:
         return isShortAuthorNameValid( data->shortAuthor(), errorMessage, tooltip,
                                        childrenExplanations );
     case TestModel::ServiceProviderDataEmailTest:
         return isEmailValid( data->email(), errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataUrlTest:
         return isUrlValid( data->url(), errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataShortUrlTest:
         return isShortUrlValid( data->shortUrl(), errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataDescriptionTest:
         return isDescriptionValid( data->description(), errorMessage, tooltip,
                                    childrenExplanations );
     case TestModel::ServiceProviderDataScriptFileNameTest:
         return isScriptFileNameValid( data->scriptFileName(), errorMessage, tooltip,
                                       childrenExplanations );
     case TestModel::ServiceProviderDataGtfsFeedUrlTest:
         return isGtfsFeedUrlValid( data->feedUrl(), errorMessage, tooltip, childrenExplanations );
     case TestModel::ServiceProviderDataGtfsRealtimeUpdatesUrlTest:
     case TestModel::ServiceProviderDataGtfsRealtimeAlertsTest: {
         QString url = test == TestModel::ServiceProviderDataGtfsRealtimeUpdatesUrlTest
                 ? data->realtimeTripUpdateUrl() : data->realtimeAlertsUrl();
         return isGtfsRealtimeUrlValid( url, errorMessage, tooltip, childrenExplanations );
     }
     case TestModel::ServiceProviderDataTimeZoneTest:
         return isTimeZoneValid( data->timeZone(), errorMessage, tooltip, childrenExplanations );
 
     default:
-        kWarning() << "Unknown test";
+        qWarning() << "Unknown test";
         return TestModel::TestFinishedSuccessfully;
     }
 }
 
 TestModel::TestState ServiceProviderDataTester::isNameValid( const QString &name,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( name.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You need to specify a name for your project");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info",
                         "<title>You need to specify a name for your project in the project settings</title> "
                         "<para>Applets show this name in a service provider selector widget.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isVersionValid( const QString &version,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( version.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You should specify a version of your project");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info", "<title>Project Version Missing</title>"
                         "<para>This helps to distinguish between different versions and makes it "
                         "possible to say for example: \"You need at least version 1.3 of that "
                         "service provider plugin for that feature to work\". "
                         "Open the project settings to add a <interface>Version</interface>.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     // Check if version contains a valid version string
     QRegExp rx( "\\d+(\\.\\d+)?(\\.\\d+)?" );
     if ( rx.indexIn(version) == -1 ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "The version string is invalid");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info", "<title>The version string is invalid</title>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isFileVersionValid( const QString &fileVersion,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
 
     // Only file format version 1.1 is currently supported
     if ( fileVersion.isEmpty() || fileVersion != QLatin1String("1.1") ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "Only provider plugin format version 1.1 is "
                                       "currently supported.");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info", "<title>Unsupported Plugin Format Version</title>"
                         "<para>The only currently supported provider plugin format version is 1.1."
                         "</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     // Check if fileVersion contains a valid version string
     QRegExp rx( "\\d+(\\.\\d+)?(\\.\\d+)?" );
     if ( rx.indexIn(fileVersion) == -1 ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "The version string is invalid");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info", "<title>The version string is invalid</title>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isEmailValid( const QString &email,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( email.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You should provide your email address as author "
                         "of the project");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info",
                         "<title>You should provide your email address as author of the project</title> "
                         "<para>You may create a new address if you do not want to use your private one. "
                         "Without an email address, no one can contact you if something is wrong "
                         "with your project. Open the project settings and specify your "
                         "<interface>E-Mail</interface> address.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     // Check if email contains a valid email address
     QRegExp rx( "^[a-z0-9!#$%&\\._-]+@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z]{2,4}$",
                 Qt::CaseInsensitive );
     if ( rx.indexIn(email) == -1 ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "The email address is invalid");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info", "<title>The email address is invalid</title>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isAuthorNameValid( const QString &authorName,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( authorName.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You should provide your name as author "
                         "of the project");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info",
                         "<title>You should provide your name as author of the project</title> "
                         "<para>Open the project settings and specify an "
                         "<interface>Author</interface>.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isShortAuthorNameValid(
         const QString &shortAuthorName, QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( shortAuthorName.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You should provide a short version of your name "
                         "as author of the project");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info",
                         "<title>You should provide a short version of your name as author of the project"
                         "</title> <para>Open the project settings and specify a "
                         "<interface>Short Author Name</interface>.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isUrlValid( const QString &url,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( url.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You should provide the URL to the home page "
                         "of the service provider");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info",
                         "<title>You should provide the URL to the home page of the service provider</title> "
                         "<para>Since the service providers are running servers for the timetable service "
                         "they will want to get some credit. Applets should show a link to the home page. "
                         "Open the project settings and add a <interface>Home Page URL</interface>.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isShortUrlValid( const QString &shortUrl,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( shortUrl.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You should provide a short version of the URL "
                         "to the home page of the service provider");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info",
                         "<title>You should provide a short version of the URL to the home page of the "
                         "service provider</title> "
                         "<para>Applets may want to show the short URL as display text for the home "
                         "page link, to save space. The result would be that nothing is shown. "
                         "Open the project settings to add a <interface>Short URL</interface>.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isDescriptionValid( const QString &description,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( description.isEmpty() ) {
         if ( errorMessage ) {
             if ( errorMessage ) {
                 *errorMessage = i18nc("@info/plain", "You should give a description for your project");
             }
             if ( tooltip ) {
                 *tooltip = i18nc("@info/plain",
                         "<title>You should give a description for your project</title> "
                         "<para>Describe what cities/countries/vehicles are supported and what "
                         "limitations there possibly are when using the service provider. Open the "
                         "project settings to add a <interface>Description</interface>.</para>");
             }
         }
         return TestModel::TestFinishedWithErrors;
     }
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isScriptFileNameValid(
         const QString &scriptFileName, QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( childrenExplanations )
     if ( scriptFileName.isEmpty() ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "No script file created for the project");
         }
         if ( tooltip ) {
             *tooltip = i18nc("@info/plain",
                     "<title>No script file created for the project</title> "
                     "<para>The script does the actual work of the project, ie. it requests and parses "
                     "documents from the service provider. Open the script tab to create a new script "
                     "from a template, implement the functions and save it.</para>");
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     // Test if the script file exists
     if ( !QFile::exists(scriptFileName) ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "Script file does not exist: <filename>%1</filename>",
                                   scriptFileName);
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isGtfsFeedUrlValid( const QString &gtfsFeedUrl,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( tooltip )
     Q_UNUSED( childrenExplanations )
     if ( gtfsFeedUrl.isEmpty() ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "No GTFS feed URL set for the project");
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     const QUrl url( gtfsFeedUrl );
     if ( !url.isValid() ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "GTFS feed URL is invalid");
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isGtfsRealtimeUrlValid(
         const QString &gtfsRealtimeUrl, QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( tooltip )
     Q_UNUSED( childrenExplanations )
     if ( gtfsRealtimeUrl.isEmpty() ) {
         // GTFS-realtime is optional
         return TestModel::TestFinishedSuccessfully;
     }
 
     const QUrl url( gtfsRealtimeUrl );
     if ( !url.isValid() ) {
         if ( errorMessage ) {
             *errorMessage = i18nc("@info/plain", "GTFS-realtime URL is invalid");
         }
         return TestModel::TestFinishedWithErrors;
     }
 
     return TestModel::TestFinishedSuccessfully;
 }
 
 TestModel::TestState ServiceProviderDataTester::isTimeZoneValid( const QString &timeZone,
         QString *errorMessage, QString *tooltip,
         QList< TimetableDataRequestMessage > *childrenExplanations )
 {
     Q_UNUSED( tooltip )
     Q_UNUSED( childrenExplanations )
     if ( timeZone.isEmpty() || KSystemTimeZones::zones().contains(timeZone) ) {
         // Time zone is optional
         return TestModel::TestFinishedSuccessfully;
     }
 
     if ( errorMessage ) {
         *errorMessage = i18nc("@info/plain", "No such time zone found: %1", timeZone);
     }
     return TestModel::TestFinishedWithErrors;
 }
diff --git a/engine/timetablemate/src/tabs/abstracttab.cpp b/engine/timetablemate/src/tabs/abstracttab.cpp
index 216d9c9..431e6d4 100644
--- a/engine/timetablemate/src/tabs/abstracttab.cpp
+++ b/engine/timetablemate/src/tabs/abstracttab.cpp
@@ -1,313 +1,313 @@
 /*
  *   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 "abstracttab.h"
 
 // Own includes
 #include "project.h"
 #include "parserenums.h"
 #include "javascriptmodel.h"
 #include "javascriptparser.h"
 #include "javascriptcompletionmodel.h"
 #include "../debugger/debugger.h"
 #include <debugger/backtracemodel.h>
 
 // Public Transport engine include
 #include <engine/serviceproviderdata.h>
 #include <engine/serviceprovider.h>
 
 // KDE includes
 #include <KUrlComboBox>
 #include <KAction>
 #include <KActionMenu>
 #include <KLocalizedString>
 #include <KService>
 #include <KStandardDirs>
 #include <KTextEditor/Editor>
 #include <KTextEditor/EditorChooser>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <KTextEditor/ConfigInterface>
 #include <KTextEditor/TextHintInterface>
 #include <KTextEditor/MarkInterface>
 #include <KTextEditor/CodeCompletionInterface>
 
 // Qt includes
 #include <QVBoxLayout>
 #include <QSplitter>
 #include <QSortFilterProxyModel>
 #include <QMenu>
 #include <QWebInspector>
 #include <QTimer>
 #include <QFileInfo>
 
 AbstractTab::AbstractTab( Project *project, TabType type, QWidget *parent )
         : QWidget(parent), m_project(project), m_widget(0), m_modified(false)
 {
     // Cannot call typeName() here, because it uses type(), which is virtual
     setObjectName( Tabs::nameForType(type) );
 
     QVBoxLayout *layout = new QVBoxLayout( this );
     layout->setContentsMargins( 0, 0, 0, 0 );
 
     connect( this, SIGNAL(tabCloseRequest()), project, SLOT(slotTabCloseRequest()) );
     connect( this, SIGNAL(otherTabsCloseRequest()), project, SLOT(slotOtherTabsCloseRequest()) );
 }
 
 AbstractTab::~AbstractTab()
 {
     if ( isModified() ) {
-        kWarning() << "Destroying tab with modifications";
+        qWarning() << "Destroying tab with modifications";
     }
 }
 
 AbstractDocumentTab::AbstractDocumentTab( Project *project, TabType type, QWidget *parent )
         : AbstractTab(project, type, parent), m_document(createDocument(this))
 {
     connect( m_document, SIGNAL(modifiedChanged(KTextEditor::Document*)),
              this, SLOT(slotModifiedChanged(KTextEditor::Document*)) );
     connect( m_document, SIGNAL(viewCreated(KTextEditor::Document*,KTextEditor::View*)),
              this, SLOT(viewCreated(KTextEditor::Document*,KTextEditor::View*)) );
 }
 
 AbstractDocumentTab::~AbstractDocumentTab()
 {
     KTextEditor::Editor *editor = KTextEditor::EditorChooser::editor();
     if ( editor ) {
         // Write editor configuration
         editor->writeConfig();
     }
 
     delete m_document;
 }
 
 void AbstractTab::setWidget( QWidget *widget )
 {
     if ( m_widget ) {
         layout()->removeWidget( m_widget );
     }
     layout()->addWidget( widget );
     m_widget = widget;
     connect( m_widget, SIGNAL(destroyed(QObject*)), this, SLOT(deleteLater()) );
 }
 
 KTextEditor::Document *AbstractDocumentTab::createDocument( QWidget *parent )
 {
     KService::Ptr service = KService::serviceByStorageId( "katepart" );
     if ( !service ) {
-        kWarning() << "Could not find the kate part";
+        qWarning() << "Could not find the kate part";
         return 0;
     }
 
     // Create text editor part
     return qobject_cast<KTextEditor::Document*>(
             service->createInstance<KParts::ReadWritePart>(parent) );
 }
 
 KTextEditor::View *AbstractDocumentTab::defaultView()
 {
     // Ensure a view gets created
     m_document->widget();
 
     if ( m_document->views().isEmpty() ) {
-        kWarning() << "No view created";
+        qWarning() << "No view created";
         return m_document->createView( this );
     } else {
         return m_document->views().first();
     }
 }
 
 void AbstractDocumentTab::viewCreated( KTextEditor::Document *document, KTextEditor::View *view )
 {
     Q_UNUSED( document );
     // The following code is copied from KDevelop (shell/textdocument.cpp), with a little change:
     // It merges with the the default katepartui.rc file. The only purpose of this code here is to
     // remove shortcuts which are also defined in timetablemateui.rc
 
     // in KDE >= 4.4 we can use KXMLGuiClient::replaceXMLFile to provide
     // katepart with our own restructured UI configuration
     const QString uiFile = KGlobal::mainComponent().componentName() + "/katepartui.rc";
     QStringList katePartUIs = KGlobal::mainComponent().dirs()->findAllResources("data", uiFile);
     if ( !katePartUIs.isEmpty() ) {
         const QString katePartUI = katePartUIs.last();
         const QString katePartLocalUI = KStandardDirs::locateLocal( "data", uiFile );
         if ( !QFile::exists(katePartLocalUI) ) {
             // prevent warning: No such XML file ".../.kde/share/apps/timetablemate/katepartui.rc"
             QFile::copy( katePartUI, katePartLocalUI );
         }
         view->replaceXMLFile( katePartUI, katePartLocalUI, true ); // Merge with global XML file
     }
 }
 
 void AbstractDocumentTab::slotModifiedChanged( KTextEditor::Document *document )
 {
     setModified( document->isModified() );
 }
 
 void AbstractTab::setModified( bool modified )
 {
     kDebug() << "Set Modified" << modified << m_project->projectName();
     if ( modified ) {
         emit changed();
     }
 
     if ( modified != m_modified ) {
         m_modified = modified;
         emit modifiedStatusChanged( modified );
         emit titleChanged( title() );
     }
 }
 
 QLatin1String AbstractTab::typeName() const
 {
     return Tabs::nameForType( type() );
 }
 
 QString AbstractTab::fileName() const
 {
     return i18nc("@info/plain", "Unsaved Document");
 }
 
 QString AbstractDocumentTab::fileName() const
 {
     const QUrl url = document()->url();
     return url.isValid() ? url.path() : AbstractTab::fileName();
 }
 
 QIcon AbstractTab::icon() const
 {
     if ( m_modified ) {
         return KIcon("document-save");
     } else {
         switch ( type() ) {
         case Tabs::Dashboard:
             return KIcon("dashboard-show");
         case Tabs::ProjectSource:
             return KIcon("application-x-publictransport-serviceprovider");
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         case Tabs::Script:
             return KIcon("application-javascript");
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
         case Tabs::GtfsDatabase:
             return KIcon("server-database");
 #endif
         case Tabs::Web:
             return KIcon("applications-internet");
         case Tabs::PlasmaPreview:
             return KIcon("plasma");
         default:
             return KIcon();
         }
     }
 }
 
 QString AbstractTab::title() const
 {
     switch ( type() ) {
     case Tabs::Dashboard: {
         const QString name = m_project->projectName();
         return name.length() > 25 ? name.left(25) + QString::fromUtf8("…") : name;
     }
     case Tabs::ProjectSource: {
         const QString xmlFileName = m_project->filePath();
         return !xmlFileName.isEmpty() ? QFileInfo(xmlFileName).fileName()
                 : i18nc("@title:tab", "Project Source %1", m_project->serviceProviderId());
     }
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Tabs::Script: {
         const QString mainScriptFile = m_project->provider()->data()->scriptFileName();
         const QString scriptFileName = fileName();
         const bool isMainScript = mainScriptFile == scriptFileName;
         QString title;
         if ( !scriptFileName.isEmpty() ) {
             title = QFileInfo( scriptFileName ).fileName();
         } else if ( isMainScript ) {
             title = i18nc("@title:tab", "Script %1", m_project->serviceProviderId());
         } else {
             title = i18nc("@title:tab", "External Script %1", m_project->serviceProviderId());
         }
 
         Debugger::Debugger *debugger = project()->debugger();
         if ( debugger->isRunning() ) {
             const bool isDebuggerInTab = debugger->backtraceModel()->isEmpty() ? false
                     : debugger->backtraceModel()->topFrame()->fileName() == scriptFileName;
             if ( isDebuggerInTab ) {
                 if ( debugger->hasUncaughtException() ) { //m_engine->hasUncaughtException() ) {
                     title += " - " + i18nc("@info/plain", "Exception in Line %1",
                                         debugger->uncaughtExceptionLineNumber());
                 } else if ( debugger->isInterrupted() ) {
                     title += " - " + i18nc("@info/plain", "Interrupted at Line %1",
                                         debugger->lineNumber());
                 } else if ( debugger->isRunning() ) {
                     title += " - " + i18nc("@info/plain", "Running");
                 }
             }
         }
         return title;
     }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     case Tabs::GtfsDatabase:
         return i18nc("@title:tab", "GTFS database %1", m_project->serviceProviderId());
 #endif // BUILD_PROVIDER_TYPE_GTFS
     case Tabs::Web:
         return i18nc("@title:tab", "Web %1", m_project->serviceProviderId());
     case Tabs::PlasmaPreview:
         return i18nc("@title:tab", "Plasma Preview %1", m_project->serviceProviderId());
     default:
         return "Unknown " + m_project->serviceProviderId();
     }
 }
 
 void AbstractTab::showTabContextMenu( const QPoint &globalPos )
 {
     // Show context menu for this tab
     QPointer<QMenu> contextMenu( new QMenu(this) );
     contextMenu->addActions( contextMenuActions(contextMenu.data()) );
 
     contextMenu->exec( globalPos );
     delete contextMenu.data();
 }
 
 QList< QAction* > AbstractTab::contextMenuActions( QWidget *parent ) const
 {
     KAction *closeTab = new KAction( KIcon("tab-close"), i18nc("@action", "Close Tab"), parent );
     connect( closeTab, SIGNAL(triggered(bool)), this, SIGNAL(tabCloseRequest()) );
     KAction *closeOtherTabs = new KAction( KIcon("tab-close-other"),
                                            i18nc("@action", "Close Other Tabs"), parent );
     connect( closeOtherTabs, SIGNAL(triggered(bool)), this, SIGNAL(otherTabsCloseRequest()) );
 
     KAction *separator = new KAction( parent );
     separator->setSeparator( true );
 
     return QList< QAction* >() << closeTab << closeOtherTabs
                                << separator << project()->projectSubMenuAction(parent);
 }
 
 QList< QAction* > AbstractDocumentTab::contextMenuActions( QWidget *parent ) const
 {
     KAction *saveTabAction = new KAction( KIcon("document-save"),
                                           i18nc("@action", "Save Document"), parent );
     saveTabAction->setEnabled( isModified() );
     connect( saveTabAction, SIGNAL(triggered(bool)), this, SLOT(save()) );
     return QList< QAction* >() << saveTabAction << AbstractTab::contextMenuActions( parent );
 }
 
diff --git a/engine/timetablemate/src/tabs/dashboardtab.cpp b/engine/timetablemate/src/tabs/dashboardtab.cpp
index bad0a9c..8c429e3 100644
--- a/engine/timetablemate/src/tabs/dashboardtab.cpp
+++ b/engine/timetablemate/src/tabs/dashboardtab.cpp
@@ -1,110 +1,110 @@
 /*
 *   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 "dashboardtab.h"
 #include "../project.h"
 
 // PublicTransport engine includes
 #include <engine/serviceprovider.h>
 #include <engine/serviceproviderdata.h>
 
 // KDE includes
 #include <KStandardDirs>
 #include <KDebug>
 #include <kdeclarative.h>
 
 // Qt includes
 #include <QDeclarativeView>
 #include <qdeclarative.h>
 #include <QDeclarativeContext>
 #include <QDeclarativeEngine>
 #include <QBoxLayout>
 #include <QToolButton>
 #include <QAction>
 #include <QGraphicsEffect>
 #include <QContextMenuEvent>
 
 DashboardTab::DashboardTab( Project *project, QWidget *parent )
         : AbstractTab(project, type(), parent), m_qmlView(0)
 {
     // Find the QML file used for the dashboard tab
     const QString fileName = KGlobal::dirs()->findResource( "data", "timetablemate/dashboard.qml" );
     if ( fileName.isEmpty() ) {
-        kWarning() << "dashboard.qml not found! Check installation";
+        qWarning() << "dashboard.qml not found! Check installation";
         return;
     }
     const QString svgFileName = KGlobal::dirs()->findResource( "data", "timetablemate/dashboard.svg" );
 
     // Register classes in Qt's meta object system and for QML
     qRegisterMetaType< const ServiceProviderData* >( "const ServiceProviderData*" );
     qRegisterMetaType< Project* >( "Project*" );
 //     qRegisterMetaType< TestModel* >( "TestModel*" );
     qmlRegisterType< ServiceProviderData, 1 >( "TimetableMate", 1, 0, "ServiceProviderData" );
     qmlRegisterUncreatableType< Project >( "TimetableMate", 1, 0, "Project",
                                            "Cannot create new projects" );
     qmlRegisterUncreatableType< Tabs >( "TimetableMate", 1, 0, "Tabs", "Only for enumerables" );
     qmlRegisterUncreatableType< Enums >( "TimetableMate", 1, 0, "PublicTransport",
                                          "Only for enumerables" );
 
     // Create dashboard widget
     QWidget *container = new QWidget( parent );
     m_qmlView = new QDeclarativeView( container );
 
     // Install a KDeclarative instance to allow eg. QIcon("icon"), i18n("translate")
     KDeclarative *kdeclarative = new KDeclarative();
     kdeclarative->setDeclarativeEngine( m_qmlView->engine() );
     kdeclarative->initialize();
     kdeclarative->setupBindings();
 
     m_qmlView->setResizeMode( QDeclarativeView::SizeRootObjectToView );
 
     // Expose the project itself to QML,
     // because the declarative engine runs in another thread, Project needs to be thread safe
     m_qmlView->rootContext()->setContextProperty( "project", project );
 
     // Expose the name of the SVG to use
     m_qmlView->rootContext()->setContextProperty( "svgFileName", svgFileName );
 
     // Add Plasma QML import paths
     const QStringList importPaths = KGlobal::dirs()->findDirs( "module", "imports" );
     foreach( const QString &importPath, importPaths ) {
         m_qmlView->engine()->addImportPath( importPath );
     }
 
     m_qmlView->setSource( fileName );
     QVBoxLayout *layout = new QVBoxLayout( container );
     layout->addWidget( m_qmlView );
     setWidget( container );
 }
 
 DashboardTab::~DashboardTab()
 {
 }
 
 DashboardTab *DashboardTab::create( Project *project, QWidget *parent )
 {
     DashboardTab *tab = new DashboardTab( project, parent );
     return tab;
 }
 
 void DashboardTab::contextMenuEvent( QContextMenuEvent *event )
 {
     project()->showProjectContextMenu( event->globalPos() );
 }
diff --git a/engine/timetablemate/src/tabs/gtfsdatabasetab.cpp b/engine/timetablemate/src/tabs/gtfsdatabasetab.cpp
index 3e1b6e1..b9ad987 100644
--- a/engine/timetablemate/src/tabs/gtfsdatabasetab.cpp
+++ b/engine/timetablemate/src/tabs/gtfsdatabasetab.cpp
@@ -1,286 +1,286 @@
 /*
 *   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 "gtfsdatabasetab.h"
 
 // Own includes
 #include "../project.h"
 
 // Public Transport engine includes
 #include <engine/serviceproviderglobal.h>
 #include <engine/gtfs/gtfsdatabase.h>
 
 // KDE includes
 #include <KIcon>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KDebug>
 #include <KComboBox>
 #include <KLocalizedString>
 #include <KTabWidget>
 #include <KGlobal>
 #include <KLocale>
 #include <KPushButton>
 #include <KMessageBox>
 #include <Plasma/DataEngineManager>
 #include <Plasma/ServiceJob>
 #include <KStandardDirs>
 #include <KTextEdit>
 #include <kdeclarative.h>
 
 // Qt includes
 #include <QTableView>
 #include <QBoxLayout>
 #include <QFormLayout>
 #include <QLabel>
 #include <QProgressBar>
 #include <QToolButton>
 #include <QSqlTableModel>
 #include <QSqlQuery>
 #include <QFileInfo>
 #include <qdeclarative.h>
 #include <QDeclarativeView>
 #include <QDeclarativeContext>
 #include <QDeclarativeEngine>
 
 GtfsDatabaseTab::GtfsDatabaseTab( Project *project, QWidget *parent )
         : AbstractTab(project, type(), parent), m_model(0), m_queryModel(0), m_tabWidget(0),
           m_qmlView(0), m_tableChooser(0), m_tableView(0), m_queryTableView(0), m_query(0)
 {
     // Create a tab widget with tabs at the left, because it gets shown in a tab in timetablemate
     m_tabWidget = new KTabWidget( parent );
     m_tabWidget->setTabPosition( QTabWidget::West );
     m_tabWidget->setIconSize( QSize(24, 24) );
     setWidget( m_tabWidget );
 
     // Find the QML file used for the dashboard tab
     const QString fileName = KGlobal::dirs()->findResource( "data", "timetablemate/gtfs_dashboard.qml" );
     if ( fileName.isEmpty() ) {
-        kWarning() << "gtfs_dashboard.qml not found! Check installation";
+        qWarning() << "gtfs_dashboard.qml not found! Check installation";
         return;
     }
     const QString svgFileName = KGlobal::dirs()->findResource( "data", "timetablemate/dashboard.svg" );
 
     // Register classes in Qt's meta object system and for QML
     qRegisterMetaType< const ServiceProviderData* >( "const ServiceProviderData*" );
     qRegisterMetaType< Project* >( "Project*" );
     qmlRegisterType< ServiceProviderData, 1 >( "TimetableMate", 1, 0, "ServiceProviderData" );
     qmlRegisterUncreatableType< Project >( "TimetableMate", 1, 0, "Project",
                                            "Cannot create new projects" );
     qmlRegisterUncreatableType< Tabs >( "TimetableMate", 1, 0, "Tabs", "Only for enumerables" );
     qmlRegisterUncreatableType< Enums >( "TimetableMate", 1, 0, "PublicTransport",
                                          "Only for enumerables" );
 
     // Create dashboard widget
     QWidget *container = new QWidget( parent );
     m_qmlView = new QDeclarativeView( container );
 
     // Install a KDeclarative instance to allow eg. QIcon("icon"), i18n("translate")
     KDeclarative *kdeclarative = new KDeclarative();
     kdeclarative->setDeclarativeEngine( m_qmlView->engine() );
     kdeclarative->initialize();
     kdeclarative->setupBindings();
 
     m_qmlView->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
     m_qmlView->setResizeMode( QDeclarativeView::SizeRootObjectToView );
 
     // Expose the project itself to QML,
     // because the declarative engine runs in another thread, Project needs to be thread safe
     m_qmlView->rootContext()->setContextProperty( "project", project );
 
     // Expose the name of the SVG to use
     m_qmlView->rootContext()->setContextProperty( "svgFileName", svgFileName );
 
     // Add Plasma QML import paths
     const QStringList importPaths = KGlobal::dirs()->findDirs( "module", "imports" );
     foreach( const QString &importPath, importPaths ) {
         m_qmlView->engine()->addImportPath( importPath );
     }
 
     m_qmlView->setSource( fileName );
 
     // Create tab showing database tables
     QWidget *tableTab = new QWidget( m_tabWidget );
     m_tableView = new QTableView( tableTab );
     m_tableView->setEditTriggers( QAbstractItemView::NoEditTriggers );
     m_tableView->setSortingEnabled( true );
 
     m_tableChooser = new KComboBox( tableTab );
     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Agency(s)"), "agency" );
     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Stops"), "stops" );
     m_tableChooser->addItem( KIcon("table"),
             i18nc("@info/plain", "Routes (groups of trips)"), "routes" );
     m_tableChooser->addItem( KIcon("table"),
             i18nc("@info/plain", "Trips (sequences of two or more stops"), "trips" );
     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Stop Times"), "stop_times" );
     m_tableChooser->addItem( KIcon("table"),
             i18nc("@info/plain", "Calendar (service dates with weekly schedule)"), "calendar" );
     m_tableChooser->addItem( KIcon("table"),
             i18nc("@info/plain", "Calendar Dates (exceptions for weekly schedules services)"),
             "calendar_dates" );
     m_tableChooser->addItem( KIcon("table"),
             i18nc("@info/plain", "Fare Attributes"), "fare_attributes" );
     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Fare Rules"), "fare_rules" );
 //     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Shapes"), "shapes" ); // Not used
     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Frequencies"), "frequencies" );
     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Transfers"), "transfers" );
 //     m_tableChooser->addItem( KIcon("table"), i18nc("@info/plain", "Feed Info"), "feed_info" ); // Not used
 
     // These strings are taken from https://developers.google.com/transit/gtfs/reference?hl=de
     // (Feed Files), feed file names are replaced by the names used by the table chooser combobox
     m_tableChooser->setToolTip( i18nc("@info:tooltip",
             "<title>Choose a table of the GTFS database</title>"
             "<para><list>"
             "<item><interface>Agency(s)</interface>: "
                 "One or more transit agencies that provide the data in this feed.</item>"
             "<item><interface>Stops</interface>: "
                 "Individual locations where vehicles pick up or drop off passengers.</item>"
             "<item><interface>Routes</interface>: "
                 "Transit routes. A route is a group of trips that are displayed to riders "
                 "as a single service.</item>"
             "<item><interface>Trips</interface>: "
                 "Trips for each route. A trip is a sequence of two or more stops that occurs "
                 "at specific time.</item>"
             "<item><interface>Stop Times</interface>: "
                 "Times that a vehicle arrives at and departs from individual stops "
                 "for each trip.</item>"
             "<item><interface>Calendar</interface>: "
                 "Dates for service IDs using a weekly schedule. Specify when service starts "
                 "and ends, as well as days of the week where service is available.</item>"
             "<item><interface>Calendar Dates</interface>: "
                 "Exceptions for the service IDs defined in the calendar.txt file. "
                 "If <interface>Calendar Dates</interface> includes <emphasize>all</emphasize> "
                 "dates of service, this file may be specified instead of "
                 "<interface>Calendar</interface>.</item>"
             "<item><interface>Fare Attributes</interface>: "
                 "Fare information for a transit organization's routes.</item>"
             "<item><interface>Fare Rules</interface>: "
                 "Rules for applying fare information for a transit organization's routes.</item>"
             "<item><interface>Shapes</interface> (not used): "
                 "Rules for drawing lines on a map to represent "
                 "a transit organization's routes.</item>"
             "<item><interface>Frequencies</interface>: "
                 "Headway (time between trips) for routes with variable frequency of service.</item>"
             "<item><interface>Transfers</interface>: "
                 "Rules for making connections at transfer points between routes.</item>"
             "<item><interface>Feed Info</interface> (not used): "
                 "Additional information about the feed itself, including publisher, version, "
                 "and expiration information.</item>"
             "</list></para>") );
     connect( m_tableChooser, SIGNAL(currentIndexChanged(int)), this, SLOT(tableChosen(int)) );
 
     QVBoxLayout *vboxLayout = new QVBoxLayout( tableTab );
     vboxLayout->addWidget( m_tableChooser );
     vboxLayout->addWidget( m_tableView );
 
     // Create tab to execute database queries
     QWidget *queryTab = new QWidget( m_tabWidget );
     m_query = new KTextEdit( queryTab );
     m_query->setClickMessage( i18nc("@info/plain", "Enter an SQLite database query...") );
     m_query->setFixedHeight( m_query->fontMetrics().height() * 4 );
     QToolButton *runQueryButton = new QToolButton( queryTab );
     runQueryButton->setIcon( KIcon("system-run") );
     runQueryButton->setText( i18nc("@info/plain", "&Execute Query") );
     runQueryButton->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
     connect( runQueryButton, SIGNAL(clicked(bool)), this, SLOT(executeQuery()) );
 
     m_queryTableView = new QTableView( queryTab );
     m_queryTableView->setEditTriggers( QAbstractItemView::NoEditTriggers );
     m_queryTableView->setSortingEnabled( true );
 
     QHBoxLayout *hboxLayoutQuery = new QHBoxLayout();
     hboxLayoutQuery->addWidget( m_query );
     hboxLayoutQuery->addWidget( runQueryButton );
     QVBoxLayout *vboxLayoutQuery = new QVBoxLayout( queryTab );
     vboxLayoutQuery->addLayout( hboxLayoutQuery );
     vboxLayoutQuery->addWidget( m_queryTableView );
 
     m_tabWidget->addTab( m_qmlView, KIcon("dashboard-show"), i18nc("@title:tab", "Overview") );
     m_tabWidget->addTab( tableTab, KIcon("server-database"), i18nc("@title:tab", "Database") );
     m_tabWidget->addTab( queryTab, KIcon("system-run"), i18nc("@title:tab", "Query") );
 
     // Disable database tab, until m_state changes to ImportFinished
     m_tabWidget->setTabEnabled( 1, false );
     gtfsDatabaseStateChanged( project->gtfsDatabaseState() );
     connect( project, SIGNAL(gtfsDatabaseStateChanged(Project::GtfsDatabaseState)),
              this, SLOT(gtfsDatabaseStateChanged(Project::GtfsDatabaseState)) );
 }
 
 GtfsDatabaseTab::~GtfsDatabaseTab()
 {
 }
 
 GtfsDatabaseTab *GtfsDatabaseTab::create( Project *project, QWidget *parent )
 {
     // Create GTFS database tab
     return new GtfsDatabaseTab( project, parent );
 }
 
 void GtfsDatabaseTab::executeQuery()
 {
     if ( !m_queryModel ) {
-        kWarning() << "No database connection";
+        qWarning() << "No database connection";
         return;
     }
 
     const QString query = m_query->toPlainText();
     m_queryModel->setQuery( query, GtfsDatabase::database(project()->data()->id()) );
 }
 
 void GtfsDatabaseTab::tableChosen( int index )
 {
     if ( !m_model ) {
-        kWarning() << "No database connection";
+        qWarning() << "No database connection";
         return;
     }
 
     const QString tableName = m_tableChooser->itemData( index ).toString();
     m_model->setTable( tableName );
     m_model->select();
 }
 
 void GtfsDatabaseTab::gtfsDatabaseStateChanged( Project::GtfsDatabaseState state )
 {
     kDebug() << "GTFS state changed to" << state;
     switch ( state ) {
     case Project::GtfsDatabaseImportFinished:
         m_tableView->setModel( 0 );
         m_queryTableView->setModel( 0 );
         delete m_model;
         delete m_queryModel;
         m_model = new QSqlTableModel( this,
                 GtfsDatabase::database(project()->data()->id()) );
         m_queryModel = new QSqlQueryModel( this );
         tableChosen( m_tableChooser->currentIndex() );
         m_tableView->setModel( m_model );
         m_queryTableView->setModel( m_queryModel );
         m_tabWidget->setTabEnabled( 1, true );
         m_tabWidget->setTabEnabled( 2, true );
         break;
     case Project::GtfsDatabaseError:
     case Project::GtfsDatabaseImportPending:
     case Project::GtfsDatabaseImportRunning:
         m_tabWidget->setTabEnabled( 1, false );
         m_tabWidget->setTabEnabled( 2, false );
         break;
     default:
         break;
     }
 }
diff --git a/engine/timetablemate/src/timetablemate.cpp b/engine/timetablemate/src/timetablemate.cpp
index 474ed82..f3ff9d0 100644
--- a/engine/timetablemate/src/timetablemate.cpp
+++ b/engine/timetablemate/src/timetablemate.cpp
@@ -1,2339 +1,2339 @@
 /*
 *   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 "timetablemate.h"
 
 // Own includes
 #include "project.h"
 #include "projectmodel.h"
 #include "ui_preferences.h"
 #include "settings.h"
 
 // Debugger includes
 #include "debugger/debugger.h"
 #include "debugger/variablemodel.h"
 
 // Tab widgets
 #include "tabs/abstracttab.h"
 #include "tabs/dashboardtab.h"
 #include "tabs/projectsourcetab.h"
 #include "tabs/webtab.h"
 #include "tabs/plasmapreviewtab.h"
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     #include "tabs/scripttab.h"
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     #include "tabs/gtfsdatabasetab.h"
 #endif
 
 // Dock widgets
 #include "docks/docktoolbar.h"
 #include "docks/projectsdockwidget.h"
 #include "docks/consoledockwidget.h"
 #include "docks/documentationdockwidget.h"
 #include "docks/variablesdockwidget.h"
 #include "docks/outputdockwidget.h"
 #include "docks/breakpointdockwidget.h"
 #include "docks/backtracedockwidget.h"
 #include "docks/consoledockwidget.h"
 #include "docks/testdockwidget.h"
 #include "docks/webinspectordockwidget.h"
 #include "docks/networkmonitordockwidget.h"
 
 // PublicTransport engine includes
 #include <engine/serviceprovider.h>
 #include <engine/serviceproviderdata.h>
 #include <engine/serviceproviderglobal.h>
 
 // KDE includes
 #include <KGlobalSettings>
 #include <KStandardDirs>
 #include <KMenu>
 #include <KMenuBar>
 #include <KToolBar>
 #include <KFileDialog>
 #include <KInputDialog>
 #include <KConfigDialog>
 #include <KMessageBox>
 #include <KMessageWidget>
 #include <KTabWidget>
 #include <KWebView>
 #include <KUrlComboBox>
 #include <KLocale>
 #include <KLocalizedString>
 #include <KStandardShortcut>
 #include <KActionCollection>
 #include <KAction>
 #include <KActionMenu>
 #include <KStandardAction>
 #include <KRecentFilesAction>
 #include <KToggleAction>
 #include <KNS3/DownloadDialog>
 #include <KParts/PartManager>
 #include <KParts/MainWindow>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <ThreadWeaver/WeaverInterface>
 #include <kdeclarative.h>
 
 // Qt includes
 #include <QtDeclarative/QDeclarativeView>
 #include <QtDeclarative/QDeclarativeContext>
 #include <QtDeclarative/QDeclarativeEngine>
 #include <QtDeclarative/qdeclarative.h>
 #include <QtGui/QFormLayout>
 #include <QtGui/QTreeView>
 #include <QtGui/QBoxLayout>
 #include <QtGui/QKeyEvent>
 #include <QtGui/QProgressBar>
 #include <QtCore/QTimer>
 #include <QtWebKit/QWebInspector>
 
 #include <unistd.h> // For KStandardDirs::checkAccess(), W_OK, in TimetableMate::fileOpenInstalled()
 
 // This function returns all actions that get connected to the currently active project
 // in TimetableMate::activeProjectAboutToChange(). These actions are proxy actions for the actions
 // inside the different projects and are added to the main TimetableMate UI (extern to the
 // projects). They are stored in the KActionCollection as Project::projectActionName().
 const QList< Project::ProjectAction > externProjectActions() {
     return QList< Project::ProjectAction >()
             << Project::Save << Project::SaveAs << Project::Install << Project::InstallGlobally
             << Project::Publish
             << Project::ShowProjectSettings << Project::Close << Project::ShowHomepage
             << Project::RunAllTests << Project::AbortRunningTests << Project::ClearTestResults
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             << Project::RunMenuAction << Project::DebugMenuAction << Project::StepInto
             << Project::StepOver << Project::StepOut << Project::RunToCursor << Project::Interrupt
             << Project::Continue << Project::AbortDebugger
             << Project::ToggleBreakpoint << Project::RemoveAllBreakpoints
 #endif
             ;
 }
 
 void moveContainer( KXMLGUIClient *client, const QString &tagname, const QString &name,
                     const QString &to_name, bool recursive )
 {
     QDomDocument doc = client->xmlguiBuildDocument ();
     if  (doc.documentElement ().isNull ()) doc = client->domDocument ();
 
     // find the given elements
     QDomElement e = doc.documentElement ();
 
     QDomElement from_elem;
     QDomElement to_elem;
 
     QDomNodeList list = e.elementsByTagName (tagname);
     int count = list.count ();
     for (int i = 0; i < count; ++i) {
         QDomElement elem = list.item (i).toElement ();
         if (elem.isNull ()) continue;
         if (elem.attribute ("name") == name) {
             from_elem = elem;
         } else if (elem.attribute ("name") == to_name) {
             to_elem = elem;
         }
     }
 
     // move
     from_elem.parentNode ().removeChild (from_elem);
     to_elem.appendChild (from_elem);
 
     // set result
     client->setXMLGUIBuildDocument (doc);
 
     // recurse
     if (recursive) {
         QList<KXMLGUIClient*> children = client->childClients ();
         QList<KXMLGUIClient*>::const_iterator it;
         for (it = children.constBegin (); it != children.constEnd (); ++it) {
             moveContainer (*it, tagname, name, to_name, true);
         }
     }
 }
 
 TimetableMate::TimetableMate() : KParts::MainWindow( 0, Qt::WindowContextHelpButtonHint ),
         ui_preferences(0), m_projectModel(0), m_partManager(0),
         m_tabWidget(new KTabWidget(this)), m_qmlView(0),
         m_leftDockBar(0), m_rightDockBar(0), m_bottomDockBar(0), m_progressBar(0),
         m_documentationDock(0), m_projectsDock(0), m_testDock(0),
         m_webInspectorDock(0), m_networkMonitorDock(0),
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         m_backtraceDock(0), m_consoleDock(0), m_outputDock(0), m_breakpointDock(0),
         m_variablesDock(0),
 #endif
         m_showDocksAction(0), m_toolbarAction(0), m_recentFilesAction(0),
         m_currentTab(0), m_messageWidgetLayout(new QVBoxLayout()), m_downloadDialog(0)
 {
     m_partManager = new KParts::PartManager( this );
     m_tabWidget->setDocumentMode( true );
     m_tabWidget->setAutomaticResizeTabs( true );
     m_tabWidget->setMovable( true );
     m_tabWidget->setTabsClosable( true );
 
     QWidget *widget = new QWidget( this );
     widget->setMinimumSize( 220, 200 );
     m_mainLayout = new QVBoxLayout( widget );
     m_mainLayout->setContentsMargins( 0, 0, 0, 0 );
     m_messageWidgetLayout->setContentsMargins( 0, 0, 0, 0 );
     m_mainLayout->addWidget( m_tabWidget );
     m_mainLayout->addLayout( m_messageWidgetLayout );
     setCentralWidget( widget );
 
     // Connect signals
     connect( m_partManager, SIGNAL(activePartChanged(KParts::Part*)),
              this, SLOT(activePartChanged(KParts::Part*)) );
     connect( m_tabWidget, SIGNAL(tabCloseRequested(int)),
              this, SLOT(tabCloseRequested(int)) );
     connect( m_tabWidget, SIGNAL(currentChanged(int)),
              this, SLOT(currentTabChanged(int)) );
     connect( m_tabWidget, SIGNAL(contextMenu(QWidget*,QPoint)),
              this, SLOT(tabContextMenu(QWidget*,QPoint)) );
 
     // Create project model
     m_projectModel = new ProjectModel( this );
     connect( m_projectModel, SIGNAL(activeProjectAboutToChange(Project*,Project*)),
              this, SLOT(activeProjectAboutToChange(Project*,Project*)) );
     connect( m_projectModel, SIGNAL(activeProjectChanged(Project*,Project*)),
              this, SLOT(activeProjectChanged(Project*,Project*)) );
     connect( m_projectModel, SIGNAL(projectAdded(Project*)), this, SLOT(projectAdded(Project*)) );
     connect( m_projectModel, SIGNAL(projectAboutToBeRemoved(Project*)),
              this, SLOT(projectAboutToBeRemoved(Project*)) );
     connect( m_projectModel, SIGNAL(testProgress(int,int)), this, SLOT(updateProgress(int,int)) );
 
     Settings::self()->readConfig();
     setupActions();
     setupDockWidgets();
     setupGUI();
     if ( !fixMenus() ) {
         int result = KMessageBox::warningContinueCancel( this,
                 i18nc("@info", "<title>Initialization Error</title>"
                       "<para>There seems to be a problem with your installation. The UI will not "
                       "be complete and there may be errors if you continue now.</para>"
                       "<para><emphasis strong='1'>Possible Solution:</emphasis> "
                       "Please reinstall TimetableMate and try again.</para>"),
                 i18nc("@title:window", "Error"), KStandardGuiItem::cont(), KStandardGuiItem::quit(),
                 QString(), KMessageBox::Notify | KMessageBox::Dangerous );
         if ( result != KMessageBox::Continue ) {
             QApplication::quit();
             deleteLater();
             return;
         }
     }
     populateTestMenu();
 
     // Create fixed dock overview toolbars after setupGUI()
     m_leftDockBar = new DockToolBar(
             Qt::LeftDockWidgetArea, "leftDockBar", m_showDocksAction, this );
     m_rightDockBar = new DockToolBar(
             Qt::RightDockWidgetArea, "rightDockBar", m_showDocksAction, this );
     m_bottomDockBar = new DockToolBar(
             Qt::BottomDockWidgetArea, "bottomDockBar", m_showDocksAction, this );
 
     QList<QAction*> dockToggleActions;
     dockToggleActions << action("toggle_dock_projects")     << action("toggle_dock_variables")
                       << action("toggle_dock_test")         << action("toggle_dock_console")
                       << action("toggle_dock_breakpoints")  << action("toggle_dock_backtrace")
                       << action("toggle_dock_output")       << action("toggle_dock_documentation")
                       << action("toggle_dock_webinspector") << action("toggle_dock_networkmonitor");
     foreach ( QAction *action, dockToggleActions ) {
         DockToolButtonAction *dockAction = qobject_cast< DockToolButtonAction* >( action );
         if ( !dockAction ) {
             continue;
         }
 
         Qt::DockWidgetArea area = dockWidgetArea( dockAction->dockWidget() );
         switch ( area ) {
         case Qt::LeftDockWidgetArea:
             m_leftDockBar->addAction( dockAction );
             break;
         case Qt::RightDockWidgetArea:
             m_rightDockBar->addAction( dockAction );
             break;
         case Qt::BottomDockWidgetArea:
             m_bottomDockBar->addAction( dockAction );
             break;
         default:
-            kWarning() << "Top dock widget area is not supported";
+            qWarning() << "Top dock widget area is not supported";
             break;
         }
 
         connect( dockAction->dockWidget(), SIGNAL(dockLocationChanged(Qt::DockWidgetArea)),
                  this, SLOT(dockLocationChanged(Qt::DockWidgetArea)) );
     }
 
     addToolBar( Qt::LeftToolBarArea, m_leftDockBar );
     addToolBar( Qt::RightToolBarArea, m_rightDockBar );
     addToolBar( Qt::BottomToolBarArea, m_bottomDockBar );
 
     // Ensure the projects dock is visible on program start (if it was created)
     if ( m_projectsDock && !m_projectsDock->isVisible() ) {
         m_projectsDock->show();
     }
 
     // Set initial states
     stateChanged( "script_tab_is_active", StateReverse );
 
     QTimer::singleShot( 0, this, SLOT(initialize()) );
 }
 
 TimetableMate::~TimetableMate() {
     delete m_downloadDialog;
     delete ui_preferences;
     delete m_progressBar;
 }
 
 void TimetableMate::updateProgress( int finishedTests, int totalTests ) {
     if ( !m_progressBar ) {
         QWidget *widget = new QWidget( this );
 
         // Create a progress bar, use the same height as the bottom DockToolBar
         QProgressBar *progressBar = new QProgressBar( widget );
         progressBar->setMaximumSize( 250, KIconLoader::SizeSmall );
         progressBar->setFormat( "%v of %m tests" );
 
         // Create a fixed toolbar for the progress bar
         QToolBar *progressToolBar = new QToolBar( this );
         progressToolBar->setObjectName( "progress" );
         progressToolBar->setMovable( false );
         progressToolBar->setFloatable( false );
 
         // Add the progress bar to it's tool bar
         // and put a spacer before it to align it to the right
         QHBoxLayout *layout = new QHBoxLayout( widget );
         layout->setContentsMargins( 0, 0, 0, 0 );
         layout->addSpacerItem( new QSpacerItem(5, 5, QSizePolicy::Expanding) );
         layout->addWidget( progressBar );
         progressToolBar->addWidget( widget );
         addToolBar( Qt::BottomToolBarArea, progressToolBar );
 
         // Create a new object with data for the progress bar
         m_progressBar = new ProgressBarData( progressToolBar, progressBar );
     }
 
     // Set values for the progress bar
     m_progressBar->progressBar->setMaximum( totalTests );
     m_progressBar->progressBar->setValue( finishedTests );
 
     // Stop running timers to hide the progress bar
     delete m_progressBar->progressBarTimer;
     m_progressBar->progressBarTimer = 0;
 
     if ( finishedTests == totalTests ) {
         // When all tests are finished start a timer to hide the progress bar again
         m_progressBar->progressBarTimer = new QTimer( this );
         connect( m_progressBar->progressBarTimer, SIGNAL(timeout()), this, SLOT(hideProgress()) );
         m_progressBar->progressBarTimer->start( 5000 );
     }
 }
 
 TimetableMate::ProgressBarData::~ProgressBarData()
 {
     if ( progressBarTimer ) {
         progressBarTimer->stop();
         delete progressBarTimer;
         progressBarTimer = 0;
     }
 
     if ( progressToolBar ) {
         delete progressToolBar;
         progressToolBar = 0;
         progressBar = 0; // Got deleted with m_progressToolBar
     }
 }
 
 void TimetableMate::hideProgress()
 {
     if ( m_progressBar ) {
         if ( m_progressBar->progressToolBar ) {
             removeToolBar( m_progressBar->progressToolBar );
         }
         delete m_progressBar;
         m_progressBar = 0;
     }
 }
 
 void TimetableMate::saveProperties( KConfigGroup &config )
 {
     m_recentFilesAction->saveEntries( config );
 
     QStringList openedProjects;
     for ( int row = 0; row < m_projectModel->rowCount(); ++ row ) {
         Project *project = m_projectModel->projectItemFromRow( row )->project();
         const QString filePath = project->filePath();
         if ( !filePath.isEmpty() ) {
             QStringList openedTabs;
             const QList< TabType > allTabs = QList< TabType >()
                     << Tabs::Dashboard << Tabs::ProjectSource
                     << Tabs::PlasmaPreview << Tabs::Web
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
                     << Tabs::Script
 #endif
 #ifdef BUILD_PROVIDER_TYPE_GTFS
                     << Tabs::GtfsDatabase
 #endif
                     ;
             foreach ( TabType tab, allTabs ) {
                 if ( project->isTabOpened(tab) ) {
                     openedTabs << QString::number(static_cast<int>(tab));
                 }
             }
             QString projectString = QString("%1 ::%2%3")
                     .arg( filePath ).arg( openedTabs.join(",") )
                     .arg( project->isActiveProject() ? " ::active" : QString() );
             openedProjects << projectString;
         }
     }
     config.writeEntry( "lastOpenedProjects", openedProjects );
 }
 
 void TimetableMate::readProperties( const KConfigGroup &config )
 {
     const QStringList lastOpenedProjects = config.readEntry( "lastOpenedProjects", QStringList() );
     QStringList failedToOpenProjects;
     foreach ( const QString &lastOpenedProject, lastOpenedProjects ) {
         // For each project that was opened in the last session a string is stored,
         // if no tabs of that project were opened, the string only contains the .pts file name.
         // Otherwise previously opened tabs are encoded after a " ::"
         const int pos = lastOpenedProject.indexOf( QLatin1String(" ::") );
         QString xmlFilePath;
         QList< TabType > openedTabs;
         bool isActive = false;
         if ( pos == -1 ) {
             xmlFilePath = lastOpenedProject;
         } else {
             xmlFilePath = lastOpenedProject.left( pos );
 
             // Get the part of the string that encodes the previously opened projects
             QString openedTabsCode = lastOpenedProject.mid( pos + 3 );
             if ( openedTabsCode.endsWith(QLatin1String(" ::active")) ) {
                 // The current project was the active project
                 isActive = true;
                 openedTabsCode.chop( 9 ); // Cut " ::active"
             }
             if ( !openedTabsCode.isEmpty() ) {
                 // The rest of the string contains the indexes of the previously opened tab types
                 const QStringList openedTabStrings = openedTabsCode.split(',');
                 foreach ( const QString &openedTabString, openedTabStrings ) {
                     openedTabs << static_cast< TabType >( openedTabString.toInt() );
                 }
             }
         }
 
         // Open the project
         Project *project = openProject( xmlFilePath );
         if ( project ) {
             // Restore active state and open previously opened tabs of the project
             if ( isActive ) {
                 project->setAsActiveProject();
             }
             foreach ( TabType tab, openedTabs ) {
                 project->showTab( tab );
             }
         } else {
             failedToOpenProjects << xmlFilePath;
         }
     }
 
     // Show an information message box, if projects failed to open
     if ( !failedToOpenProjects.isEmpty() ) {
         KMessageBox::informationList( this,
                 i18nc("@info", "The following projects could not be opened"),
                 failedToOpenProjects, i18nc("@title:window", "Failed to Open"),
                 "couldNotOpenLastProjects" );
     }
 
     if ( m_projectModel->activeProject() && m_projectsDock ) {
         // Expand active project item
         m_projectsDock->projectsWidget()->expand(
                 m_projectModel->indexFromProject(m_projectModel->activeProject()) );
     }
 }
 
 void TimetableMate::initialize()
 {
     Settings *settings = Settings::self();
     const int threadCount = settings->maximumThreadCount();
     m_projectModel->weaver()->setMaximumNumberOfThreads( threadCount < 1 ? 32 : threadCount );
 
     KConfig *config = settings->config();
     if ( !config->hasGroup("Kate Document Defaults") ) {
         // Kate document settings not written yet,
         // write default values for TimetableMate to have consistent indentation
         // with 4 spaces and no tabulators by default, also make removing spaces the default
         KConfigGroup group = config->group("Kate Document Defaults");
         group.writeEntry( "Indentation Width", 4 );
         group.writeEntry( "ReplaceTabsDyn", true ); // Indent with (4) spaces, no tabs
         group.writeEntry( "Remove Spaces", true );
         group.writeEntry( "RemoveTrailingDyn", true );
         group.sync();
     }
 
     bool restoreProjects = settings->restoreProjects();
     if ( settings->lastSessionCrashed() ) {
         // The last session has crashed
         if ( restoreProjects ) {
             // Restoring projects is enabled, check if there are any projects to restore
             // before asking whether restoration should be disabled
             if ( settings->config()->hasGroup("last_session") ) {
                 KConfigGroup config = settings->config()->group("last_session");
                 const QStringList lastOpenedProjects = config.readEntry( "lastOpenedProjects", QStringList() );
                 if ( !lastOpenedProjects.isEmpty() ) {
                     // There are projects to restore, ask the user what to do
                     int result = KMessageBox::warningContinueCancel( this,
                             i18nc("@info", "<title>Last Session Crashed - Sorry</title>"
                                 "<para><warning>Restoring previously opened projects and tabs "
                                 "might result in another crash.</warning></para>"
                                 "<para>Do you want to nevertheless restore projects?</para>"),
                             i18nc("@title:window", "Crash Protection"),
                             KGuiItem(i18nc("@info/plain", "&Restore Projects"), KIcon("security-medium")),
                             KGuiItem(i18nc("@info/plain", "Do &not Restore Projects"), KIcon("security-high")),
                             "crash_protection" );
                     if ( result != KMessageBox::Continue ) {
                         restoreProjects = false;
                     }
                 }
             }
         }
     } else {
         // No last session or the last session did finish successfully.
         // Store true for the "lastSessionCrashed" setting while TimetableMate is running.
         // When it exits successfully it sets it to false again. If TimetableMate crashes before
         // a successful exit, true is still stored for "lastSessionCrashed".
         // This requires the use of KUniqueApplication to work properly.
         settings->setLastSessionCrashed( true );
         settings->writeConfig();
     }
 
     updateShownDocksAction();
 
     if ( settings->config()->hasGroup("last_session") ) {
         KConfigGroup config = settings->config()->group("last_session");
         m_recentFilesAction->loadEntries( config );
         currentTabChanged( -1 );
         if ( restoreProjects ) {
             readProperties( config );
         }
     } else {
         currentTabChanged( -1 );
     }
 }
 
 void TimetableMate::populateTestMenu()
 {
     // Fill test action list with menu actions for each test case
     m_testCaseActions.clear();
     if ( m_projectModel->activeProject() ) {
         for ( int i = 0; i < TestModel::TestCaseCount; ++i ) {
             // Only add test cases that contain applicable tests
             const TestModel::TestCase testCase = static_cast<TestModel::TestCase>( i );
             if ( TestModel::isTestCaseApplicableTo(testCase,
                                                    m_projectModel->activeProject()->data()) )
             {
                 QAction *action = Project::createProjectAction( Project::SpecificTestCaseMenuAction,
                         QVariant::fromValue(static_cast<int>(testCase)), this );
                 m_testCaseActions << action;
             }
         }
     }
     unplugActionList( "test_list" );
     plugActionList( "test_list", m_testCaseActions );
 }
 
 void TimetableMate::connectTestMenuWithProject( Project *project, bool doConnect )
 {
     if ( !project ) {
         return;
     }
 
     foreach ( QAction *action, m_testCaseActions ) {
         const Project::ProjectActionData data = project->projectActionData( action );
         project->connectProjectAction( data.actionType, action, doConnect );
     }
 }
 
 QAction *TimetableMate::createCustomElement( QWidget *parent, int index, const QDomElement &element )
 {
     QAction* before = 0L;
     if ( index > 0 && index < parent->actions().count() ) {
         before = parent->actions().at( index );
     }
 
     // Copied from KDevelop, menubar separators need to be defined as <Separator style="visible" />
     // and to be always shown in the menubar. For those, we create special disabled actions
     // instead of calling QMenuBar::addSeparator() because menubar separators are ignored
     if ( element.tagName().toLower() == QLatin1String("separator") &&
          element.attribute("style") == QLatin1String("visible") )
     {
         if ( QMenuBar* bar = qobject_cast<QMenuBar*>(parent) ) {
             QAction *separatorAction = new QAction( "|", this );
             bar->insertAction( before, separatorAction );
             separatorAction->setDisabled( true );
             separatorAction->setObjectName( element.attribute("name") );
             return separatorAction;
         }
     }
 
     return KXMLGUIBuilder::createCustomElement( parent, index, element );
 }
 
 bool TimetableMate::fixMenus()
 {
     const QList< QAction* > menuBarActions = menuBar()->actions();
     QHash< QString, QAction* > menus;
     foreach ( QAction *menuBarAction, menuBarActions ) {
         menus.insert( menuBarAction->objectName(), menuBarAction );
     }
 
     // Show the file menu only when it is not empty
     QAction *fileMenu = menus["file"];
     if ( fileMenu ) {
         fileMenu->setVisible( !fileMenu->menu()->isEmpty() );
     }
 
 #ifndef BUILD_PROVIDER_TYPE_SCRIPT
     // Hide the run menu if the script provider type is disabled
     // (and the run menu is actually empty)
     QAction *runMenu = menus["run"];
     if ( runMenu ) {
         runMenu->setVisible( !runMenu->menu()->isEmpty() );
     }
 #endif
 
     // Show the separator after the part menus only when part menus are there
     QAction *separatorPartMenusEnd = menus["separator_part_menus_end"];
     if ( separatorPartMenusEnd ) {
         separatorPartMenusEnd->setVisible( fileMenu->isVisible() && menus["edit"] &&
                                            menus["view"] && menus["tools"] && menus["bookmarks"] );
     } else {
-        kWarning() << "Missing separator_part_menus_end, timetablemateui.rc not installed?";
+        qWarning() << "Missing separator_part_menus_end, timetablemateui.rc not installed?";
     }
 
     QAction *editMenu = menus["edit"];
     if ( editMenu ) {
         const QList< QAction* > actions = editMenu->menu()->actions();
         foreach ( QAction *action, actions ) {
             if ( action->objectName() == QLatin1String("edit_undo") ||
                  action->objectName() == QLatin1String("edit_redo") )
             {
                 action->setPriority( QAction::LowPriority );
             }
         }
     }
 
     // If the "separator_part_menus_end" menu bar item cannot be found, assume that
     // timetablemateui.rc was not installed and return false
     return separatorPartMenusEnd;
 }
 
 void TimetableMate::testActionTriggered()
 {
     if ( m_projectModel->activeProject() ) {
         QAction *action = qobject_cast< QAction* >( sender() );
         const TestModel::Test test = static_cast< TestModel::Test >( action->data().toInt() );
         m_projectModel->activeProject()->startTest( test );
     }
 }
 
 void TimetableMate::testCaseActionTriggered()
 {
     if ( m_projectModel->activeProject() ) {
         QAction *action = qobject_cast< QAction* >( sender() );
         const TestModel::TestCase testCase = static_cast< TestModel::TestCase >( action->data().toInt() );
         m_projectModel->activeProject()->startTestCase( testCase );
     }
 }
 
 void TimetableMate::dockLocationChanged( Qt::DockWidgetArea area )
 {
     QDockWidget *dockWidget = qobject_cast< QDockWidget* >( sender() );
     Q_ASSERT( dockWidget );
 
     // Find the action to toggle the dock widget in one of the three dock bars and remove it
     QAction *toggleAction = m_leftDockBar->actionForDockWidget( dockWidget );
     if ( toggleAction ) {
         m_leftDockBar->removeAction( toggleAction );
     } else {
         toggleAction = m_rightDockBar->actionForDockWidget( dockWidget );
         if ( toggleAction ) {
             m_rightDockBar->removeAction( toggleAction );
         } else {
             toggleAction = m_bottomDockBar->actionForDockWidget( dockWidget );
             if ( toggleAction ) {
                 m_bottomDockBar->removeAction( toggleAction );
             } else {
                 kDebug() << "Action not found for dock widget" << dockWidget;
                 return;
             }
         }
     }
 
     // Add the found dock widget toggle action to the dock bar for the new area
     if ( area == Qt::LeftDockWidgetArea ) {
         m_leftDockBar->addAction( toggleAction );
     } else if ( area == Qt::RightDockWidgetArea ) {
         m_rightDockBar->addAction( toggleAction );
     } else if ( area == Qt::BottomDockWidgetArea ) {
         m_bottomDockBar->addAction( toggleAction );
     } else {
         kDebug() << "Area is not allowed" << area;
     }
 
     updateShownDocksAction();
 }
 
 void TimetableMate::updateShownDocksAction()
 {
     // Remove all actions, they will be inserted in new order below
     m_showDocksAction->removeAction( action("toggle_dock_projects") );
     m_showDocksAction->removeAction( action("toggle_dock_variables") );
     m_showDocksAction->removeAction( action("toggle_dock_documentation") );
     m_showDocksAction->removeAction( action("toggle_dock_console") );
     m_showDocksAction->removeAction( action("toggle_dock_breakpoints") );
     m_showDocksAction->removeAction( action("toggle_dock_backtrace") );
     m_showDocksAction->removeAction( action("toggle_dock_output") );
     m_showDocksAction->removeAction( action("toggle_dock_test") );
     m_showDocksAction->removeAction( action("toggle_dock_webinspector") );
     m_showDocksAction->removeAction( action("toggle_dock_networkmonitor") );
 
     // Delete remaining actions (titles, separators, hide actions)
     QList< QAction* > separators = m_showDocksAction->menu()->actions();
     foreach ( QAction *action, separators ) {
         m_showDocksAction->removeAction( action );
         delete action;
     }
 
     // Insert actions for the left dock area
     KMenu *menu = m_showDocksAction->menu();
     if ( !m_leftDockBar->actions().isEmpty() ) {
         menu->addTitle( i18nc("@title:menu In-menu title", "Left Dock Area") );
         menu->addActions( m_leftDockBar->actions() );
 
         // Add another action to the radio group to hide the dock area
         QAction *hideDockAction = menu->addAction( KIcon("edit-clear"),
                                                    i18nc("@action:inmenu", "&Hide Left Dock"),
                                                    m_leftDockBar, SLOT(hideCurrentDock()) );
         hideDockAction->setCheckable( true );
         if ( !m_leftDockBar->actionGroup()->checkedAction() ) {
             hideDockAction->setChecked( true );
         }
         m_leftDockBar->actionGroup()->addAction( hideDockAction );
     }
 
     // Insert actions for the bottom dock area
     if ( !m_bottomDockBar->actions().isEmpty() ) {
         menu->addTitle( i18nc("@title:menu In-menu title", "Bottom Dock Area") );
         menu->addActions( m_bottomDockBar->actions() );
 
         // Add another action to the radio group to hide the dock area
         QAction *hideDockAction = menu->addAction( KIcon("edit-clear"),
                                                    i18nc("@action:inmenu", "&Hide Bottom Dock"),
                                                    m_bottomDockBar, SLOT(hideCurrentDock()) );
         hideDockAction->setCheckable( true );
         if ( !m_bottomDockBar->actionGroup()->checkedAction() ) {
             hideDockAction->setChecked( true );
         }
         m_bottomDockBar->actionGroup()->addAction( hideDockAction );
     }
 
     // Insert actions for the right dock area (after a separator)
     if ( !m_rightDockBar->actions().isEmpty() ) {
         menu->addTitle( i18nc("@title:menu In-menu title", "Right Dock Area") );
         menu->addActions( m_rightDockBar->actions() );
 
         // Add another action to the radio group to hide the dock area
         QAction *hideDockAction = menu->addAction( KIcon("edit-clear"),
                                                    i18nc("@action:inmenu", "&Hide Right Dock"),
                                                    m_rightDockBar, SLOT(hideCurrentDock()) );
         hideDockAction->setCheckable( true );
         if ( !m_rightDockBar->actionGroup()->checkedAction() ) {
             hideDockAction->setChecked( true );
         }
         m_rightDockBar->actionGroup()->addAction( hideDockAction );
     }
 }
 
 void TimetableMate::setupDockWidgets()
 {
     m_showDocksAction = new KActionMenu( i18nc("@action", "&Docks Shown"), this );
     actionCollection()->addAction( QLatin1String("options_show_docks"), m_showDocksAction );
 
     // Create dock widgets
     m_projectsDock = new ProjectsDockWidget( m_projectModel, m_showDocksAction, this );
     m_testDock = new TestDockWidget( m_projectModel, m_showDocksAction, this );
     m_documentationDock = new DocumentationDockWidget( m_showDocksAction, this );
     m_webInspectorDock = new WebInspectorDockWidget( m_showDocksAction, this );
     m_networkMonitorDock = new NetworkMonitorDockWidget( m_projectModel, m_showDocksAction, this );
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     m_backtraceDock = new BacktraceDockWidget( m_projectModel, m_showDocksAction, this );
     m_breakpointDock = new BreakpointDockWidget( m_projectModel, m_showDocksAction, this );
     m_outputDock = new OutputDockWidget( m_projectModel, m_showDocksAction, this );
     m_consoleDock = new ConsoleDockWidget( m_projectModel, m_showDocksAction, this );
     m_variablesDock = new VariablesDockWidget( m_projectModel, m_showDocksAction, this );
 #endif
 
     const QList< AbstractDockWidget* > allDockWidgets = QList< AbstractDockWidget* >()
             << m_projectsDock << m_testDock << m_documentationDock
             << m_webInspectorDock << m_networkMonitorDock
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
             << m_backtraceDock << m_breakpointDock << m_outputDock << m_consoleDock << m_variablesDock
 #endif
             ;
     foreach ( AbstractDockWidget *dockWidget, allDockWidgets ) {
         DockToolButtonAction *toggleAction = new DockToolButtonAction(
                 dockWidget, dockWidget->icon(), dockWidget->windowTitle(), this );
         actionCollection()->addAction( "toggle_dock_" + dockWidget->objectName(), toggleAction );
 
         // Add dock widgets to default areas (stored changes to the areas are restored later)
         addDockWidget( dockWidget->defaultDockArea(), dockWidget );
     }
 }
 
 void TimetableMate::activeProjectAboutToChange( Project *project, Project *previousProject )
 {
     // Enable "Save All" action only when at least one project is opened
     action("project_save_all")->setEnabled( project );
 
     if ( previousProject ) {
         // Disconnect previously active project
         foreach ( Project::ProjectAction projectAction, externProjectActions() ) {
             QAction *qaction = action( Project::projectActionName(projectAction) );
             previousProject->connectProjectAction( projectAction, qaction, false );
         }
 
         connectTestMenuWithProject( previousProject, false );
 
         disconnect( previousProject, SIGNAL(testStarted()), this, SLOT(testStarted()) );
         disconnect( previousProject, SIGNAL(testFinished(bool)), this, SLOT(testFinished(bool)) );
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         Debugger::Debugger *debugger = previousProject->debugger();
         disconnect( debugger, SIGNAL(aborted()), this, SLOT(updateWindowTitle()) );
         disconnect( debugger, SIGNAL(interrupted(int,QString,QDateTime)),
                     this, SLOT(updateWindowTitle()) );
         disconnect( debugger, SIGNAL(continued(QDateTime,bool)), this, SLOT(updateWindowTitle()) );
         disconnect( debugger, SIGNAL(started()), this, SLOT(updateWindowTitle()) );
         disconnect( debugger, SIGNAL(stopped()), this, SLOT(updateWindowTitle()) );
         disconnect( debugger, SIGNAL(exception(int,QString,QString)),
                     this, SLOT(uncaughtException(int,QString,QString)) );
         disconnect( debugger, SIGNAL(breakpointReached(Breakpoint)),
                     this, SLOT(breakpointReached(Breakpoint)) );
 
         if ( m_backtraceDock ) {
             disconnect( m_backtraceDock, SIGNAL(activeFrameDepthChanged(int)),
                         debugger->variableModel(), SLOT(switchToVariableStack(int)) );
         }
         if ( m_testDock ) {
             disconnect( m_testDock, SIGNAL(clickedTestErrorItem(QString,int,QString)),
                         previousProject, SLOT(showScriptLineNumber(QString,int)) );
         }
 #endif
     }
 
     if ( project ) {
         // Connect the new active project
         foreach ( Project::ProjectAction projectAction, externProjectActions() ) {
             QAction *qaction = action( Project::projectActionName(projectAction) );
             project->connectProjectAction( projectAction, qaction );
         }
 
         connectTestMenuWithProject( project );
 
         connect( project, SIGNAL(testStarted()), this, SLOT(testStarted()) );
         connect( project, SIGNAL(testFinished(bool)), this, SLOT(testFinished(bool)) );
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         Debugger::Debugger *debugger = project->debugger();
         connect( debugger, SIGNAL(aborted()), this, SLOT(updateWindowTitle()) );
         connect( debugger, SIGNAL(interrupted(int,QString,QDateTime)),
                  this, SLOT(updateWindowTitle()) );
         connect( debugger, SIGNAL(continued(QDateTime,bool)), this, SLOT(updateWindowTitle()) );
         connect( debugger, SIGNAL(started()), this, SLOT(updateWindowTitle()) );
         connect( debugger, SIGNAL(stopped()), this, SLOT(updateWindowTitle()) );
         connect( debugger, SIGNAL(exception(int,QString,QString)),
                  this, SLOT(uncaughtException(int,QString,QString)) );
         connect( debugger, SIGNAL(breakpointReached(Breakpoint)),
                  this, SLOT(breakpointReached(Breakpoint)) );
         if ( m_backtraceDock ) {
             connect( m_backtraceDock, SIGNAL(activeFrameDepthChanged(int)),
                      debugger->variableModel(), SLOT(switchToVariableStack(int)) );
         }
         if ( m_testDock ) {
             connect( m_testDock, SIGNAL(clickedTestErrorItem(QString,int,QString)),
                      project, SLOT(showScriptLineNumber(QString,int)) );
         }
 #endif
         stateChanged( "project_opened" );
 
         // Update text of the choose active project action
         QAction *chooseActiveProject = action("project_choose_active");
         if ( chooseActiveProject ) {
             chooseActiveProject->setText( project->projectName() );
         }
     } else {
         stateChanged( "no_project_opened" );
         stateChanged( "project_opened", StateReverse );
 
         // Update text of the choose active project action
         QAction *chooseActiveProject = action("project_choose_active");
         if ( chooseActiveProject ) {
             chooseActiveProject->setText( i18nc("@action", "&Active Project") );
         }
     }
 }
 
 void TimetableMate::activeProjectChanged( Project *project, Project *previousProject )
 {
     Q_UNUSED( project );
     Q_UNUSED( previousProject );
     populateTestMenu();
 }
 
 bool TimetableMate::queryClose()
 {
     // Save session properties into a special group in the configuration
     KConfigGroup config = Settings::self()->config()->group("last_session");
     saveProperties( config );
 
     // Close projects and ask to save if modified
     const bool close = closeAllProjects();
     if ( close ) {
         // TimetableMate will close, no crash so far,
         // store that the last program exit was successful, ie. did not crash
         Settings *settings = Settings::self();
         settings->setLastSessionCrashed( false );
         settings->writeConfig();
     }
     return close;
 }
 
 Project *TimetableMate::currentProject()
 {
     // Get project of the currently shown tab
     AbstractTab *tab = projectTabAt( m_tabWidget->currentIndex() );
     return tab ? tab->project() : 0;
 }
 
 void TimetableMate::updateWindowTitle() {
     AbstractTab *tab = 0;
     QString caption;
     Project *activeProject = m_projectModel->activeProject();
 
     // Start caption with the name of the current tab, if any
     if ( m_tabWidget->currentIndex() != -1 ) {
         tab = projectTabAt( m_tabWidget->currentIndex() );
         Project *tabProject = tab->project();
         const ProjectModelItem::Type type =
                 ProjectModelItem::projectItemTypeFromTabType( tab->type() );
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         if ( tabProject->data()->type() == Enums::ScriptedProvider ) {
             if ( type != ProjectModelItem::ScriptItem ||
                  tab->fileName() == tabProject->scriptFileName() )
             {
                 // Get caption from the model by tab type, but not for external script tabs
                 caption = m_projectModel->projectItemChildFromProject( tabProject, type )->text();
             } else {
                 // External script tab, manually construct caption
                 QString name = tab->fileName().isEmpty()
                         ? i18nc("@info/plain", "External Script File")
                         : QFileInfo(tab->fileName()).fileName();
                 caption = KDialog::makeStandardCaption( name, 0,
                         tab && tab->isModified() ? KDialog::ModifiedCaption : KDialog::NoCaptionFlags );
             }
         } else {
             caption = m_projectModel->projectItemChildFromProject( tabProject, type )->text();
         }
 #else
         caption = m_projectModel->projectItemChildFromProject( tabProject, type )->text();
 #endif
 
         // Add project name
         caption += " - " + tabProject->projectName();
     }
 
     // Add information about the test state
     if ( activeProject ) {
         if ( activeProject->isTestRunning() ) {
             caption += " - " + i18nc("@info/plain", "Testing");
         }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
         // Add information about the debugger state
         Debugger::Debugger *debugger = activeProject->debugger();
         if ( debugger ) {
             if ( debugger->hasUncaughtException() ) {
                 caption += " - " + i18nc("@info/plain", "Debugging (Exception in Line %1)",
                                         debugger->uncaughtExceptionLineNumber());
             } else if ( debugger->isInterrupted() ) {
                 caption += " - " + i18nc("@info/plain", "Debugger Interrupted at Line %1", debugger->lineNumber());
             } else if ( debugger->isRunning() ) {
                 caption += " - " + i18nc("@info/plain", "Debugger Running");
             }
         }
 #endif
     }
 
     setCaption( caption, tab ? tab->isModified() : false );
 }
 
 void TimetableMate::activePartChanged( KParts::Part *part ) {
     // Merge the GUI of the part, do not update while merging to avoid flicker
     setUpdatesEnabled( false );
     createGUI( part );
     setUpdatesEnabled( true );
 
     if ( part ) {
         // Manually hide actions of the part
         QStringList actionsToHide;
         actionsToHide << "tools_mode" << "tools_highlighting" << "tools_indentation";
         foreach ( QAction *action, menuBar()->actions() ) {
             KActionMenu *menuAction = static_cast<KActionMenu*>( action );
             const QList< QAction* > actions = menuAction->menu()->actions();
             for ( int i = actions.count() - 1; i >= 0; --i ) {
                 QAction *curAction = actions.at( i );
                 if ( curAction->parent() == actionCollection() )
                     continue; // Don't hide own actions
 
                 if ( actionsToHide.contains(curAction->objectName()) ) {
                     curAction->setVisible( false );
 
                     actionsToHide.removeAt( i );
                     if ( actionsToHide.isEmpty() )
                         break;
                 }
             }
 
             if ( actionsToHide.isEmpty() ) {
                 break;
             }
         }
     }
 
     fixMenus();
 }
 
 AbstractTab *TimetableMate::projectTabAt( int index )
 {
     return qobject_cast< AbstractTab* >( m_tabWidget->widget(index) );
 }
 
 bool TimetableMate::closeProject( Project *project )
 {
     if ( closeAllTabs(project) ) {
         if ( project->isModified() ) {
             const QString message = i18nc("@info", "The project '%1' was modified. "
                                           "Do you want to save it now?", project->projectName());
             const int result = KMessageBox::warningYesNoCancel( this, message, QString(),
                     KStandardGuiItem::save(), KStandardGuiItem::close() );
             if ( result == KMessageBox::Yes ) {
                 // Save clicked
                 project->save( this );
                 m_projectModel->removeProject( project );
                 return !project->isModified();
             } else if ( result == KMessageBox::No ) {
                 // Close clicked
                 m_projectModel->removeProject( project );
                 return true;
             } else {
                 // Cancel clicked
                 return false;
             }
         } else {
             m_projectModel->removeProject( project );
         }
         return true;
     } else {
         return false;
     }
 }
 
 bool TimetableMate::closeAllProjects()
 {
     QStringList modifiedProjects;
     QList<ProjectModelItem*> projects = m_projectModel->projectItems();
     foreach ( const ProjectModelItem *project, projects ) {
         if ( project->project()->isModified() ) {
             modifiedProjects << project->project()->projectName();
         }
     }
 
     if ( modifiedProjects.isEmpty() ) {
         // No modified projects
         return true;
     }
 
     const QString message = i18nc("@info", "The following projects were modified. "
                                   "Do you want to save them now?");
     const int result = KMessageBox::warningYesNoCancelList( this, message, modifiedProjects,
             i18nc("@title:window", "Modified Projects"),
             KStandardGuiItem::save(), KStandardGuiItem::close() );
     if ( result == KMessageBox::Yes ) {
         // Save clicked
         foreach ( const ProjectModelItem *projectItem, projects ) {
             if ( projectItem->project()->isModified() ) {
                 projectItem->project()->save( this );
                 if ( projectItem->project()->isModified() ) {
                     // Still modified, error while saving
                     return false;
                 }
             }
             closeAllTabs( projectItem->project(), false );
             m_projectModel->removeProject( projectItem->project() );
         }
         return true;
     } else if ( result == KMessageBox::No ) {
         // Close clicked
         closeAllTabs( 0, false );
         foreach ( const ProjectModelItem *projectItem, projects ) {
             m_projectModel->removeProject( projectItem->project() );
         }
         return true;
     } else {
         // Cancel clicked
         return false;
     }
 }
 
 void TimetableMate::contextMenuEvent( QContextMenuEvent *event )
 {
     // Show "Shown Docks" action menu for context menus in empty menu bar space
     // and in main window splitters
     m_showDocksAction->menu()->exec( event->globalPos() );
 }
 
 void TimetableMate::tabContextMenu( QWidget *widget, const QPoint &pos )
 {
     AbstractTab *tab = qobject_cast< AbstractTab* >( widget );
     tab->showTabContextMenu( pos );
 }
 
 void TimetableMate::closeCurrentTab()
 {
     closeTab( projectTabAt(m_tabWidget->currentIndex()) );
 }
 
 void TimetableMate::closeTab( AbstractTab *tab )
 {
     if ( !tab ) {
         kDebug() << "Tab was already closed";
         return;
     }
 
     if ( tab->isModified() ) {
         // Ask if modifications should be saved
         AbstractDocumentTab *documentTab = qobject_cast< AbstractDocumentTab* >( tab );
         const QString message = documentTab
                 ? i18nc("@info", "The document was modified. Do you want to save it now?")
                 : i18nc("@info", "Tab contents were modified. Do you want to save it now?");
         int result = KMessageBox::warningYesNoCancel( this, message, QString(),
                 KStandardGuiItem::save(),
                 documentTab ? KStandardGuiItem::closeDocument() : KStandardGuiItem::close() );
         if ( result == KMessageBox::Yes ) {
             if ( !tab->save() ) {
                 // Do not close the tab if modifications could not be saved
                 return;
             }
         } else if ( result == KMessageBox::Cancel ) {
             // Cancel clicked, do not close the tab
             return;
         } // else: No clicked, ie. do not save, but close the tab
     }
 
     switch ( tab->type() ) {
     case Tabs::Dashboard:
         dashboardTabAction( qobject_cast<DashboardTab*>(tab), CloseTab );
         break;
     case Tabs::ProjectSource:
         projectSourceTabAction( qobject_cast<ProjectSourceTab*>(tab), CloseTab );
         break;
     case Tabs::PlasmaPreview:
         plasmaPreviewTabAction( qobject_cast<PlasmaPreviewTab*>(tab), CloseTab );
         break;
     case Tabs::Web:
         webTabAction( qobject_cast<WebTab*>(tab), CloseTab );
         break;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     case Tabs::Script:
         scriptTabAction( qobject_cast<ScriptTab*>(tab), CloseTab );
         break;
 #endif
     case Tabs::NoTab:
     default:
         break;
     }
 
     // Close the tab
     m_tabWidget->removeTab( m_tabWidget->indexOf(tab) );
     tab->deleteLater();
 }
 
 bool TimetableMate::closeAllTabsExcept( AbstractTab *tab, bool ask )
 {
     return closeAllTabsExcept( 0, tab, ask );
 }
 
 bool TimetableMate::closeAllTabs( Project *project, bool ask )
 {
     return closeAllTabsExcept( project, 0, ask );
 }
 
 bool TimetableMate::closeAllTabsExcept( Project *project, AbstractTab *except, bool ask )
 {
     // Check for tabs with modified content documents
     QHash< QString, AbstractTab* > modifiedDocuments;
     for ( int i = 0; i < m_tabWidget->count(); ++i ) {
         AbstractTab *tab = projectTabAt( i );
         if ( (project && tab->project() != project) || (except && except == tab) ) {
             // If a project is given as argument only close tabs of that project and skip others
             // If a tab is given do not close that close
             continue;
         }
 
         if ( tab->isModified() ) {
             // Tab contents are modified, get a unique name
             const QString baseDocumentName = tab->fileName();
             QString documentName = baseDocumentName;
             int i = 1;
             if ( modifiedDocuments.contains(documentName) ) {
                 documentName = QString("%1 (%2)").arg(baseDocumentName).arg(i);
             }
             modifiedDocuments.insert( documentName, tab );
         } else {
             // Tab contents unchanged, just close it
             m_tabWidget->removeTab( i );
 
             // Use deleteLater() because otherwise closing a tab from inside itself would cause
             // crash (also closing the project from inside a tab, because that closes the tab, too)
             tab->deleteLater();
             --i;
         }
     }
 
     // Unmodified tabs are now closed, check if modified tabs were found
     if ( modifiedDocuments.isEmpty() ) {
         return true;
     } else if ( ask ) {
         // Ask the user if modified documents should be saved
         const QString message = i18nc("@info", "The following documents were modified. "
                                       "Do you want to save them now?");
         KGuiItem saveAllItem( i18nc("@info/plain", "Save All"), KIcon("document-save-all") );
         KGuiItem doNotSaveItem( i18nc("@info/plain", "Do not Save"), KIcon("user-trash") );
         KGuiItem doNotCloseItem( i18nc("@info/plain", "Do not Close"), KIcon("dialog-cancel") );
         KDialog dialog( this );
         int result = KMessageBox::warningYesNoCancelList( this, message, modifiedDocuments.keys(),
                 QString(), saveAllItem, doNotSaveItem, doNotCloseItem );
 
         if ( result == KMessageBox::Cancel ) {
             // "Do not Close" clicked
             return false;
         } else if ( result == KMessageBox::Yes ) {
             // "Save All" clicked
             bool allTabsClosed = true;
             for ( QHash<QString, AbstractTab*>::ConstIterator it = modifiedDocuments.constBegin();
                   it != modifiedDocuments.constEnd(); ++it )
             {
                 if ( !(*it)->save() ) {
                     // Document could not be saved (eg. cancelled by the user),
                     // do not close the associated tab and return false at the end
                     allTabsClosed = false;
                     continue;
                 }
 
                 // Document successfully saved, close the tab
                 m_tabWidget->removeTab( m_tabWidget->indexOf(*it) );
                 delete *it;
             }
 
             // Return if all tabs are now closed
             return allTabsClosed;
         } else {
             // "Do not Save" clicked, close all tabs without saving
             for ( QHash<QString, AbstractTab*>::ConstIterator it = modifiedDocuments.constBegin();
                   it != modifiedDocuments.constEnd(); ++it )
             {
                 // Close the tab
                 m_tabWidget->removeTab( m_tabWidget->indexOf(*it) );
                 delete *it;
             }
             return true;
         }
     } else {
         return false;
     }
 }
 
 QAction *TimetableMate::qmlAction( const QString &name ) const
 {
     return action( name.toAscii().constData() );
 }
 
 QStringList TimetableMate::recentProjects() const
 {
     QStringList projects;
     foreach ( const QUrl &url, m_recentFilesAction->urls() ) {
         // Make filenames more pretty
         QString prettyName;
         const QString fileName = url.fileName();
         if ( KStandardDirs::checkAccess(url.path(), W_OK) ) {
             // File is writable, ie. locally installed
             prettyName = QFileInfo( url.path() ).baseName();
         } else {
             // File isn't writable, ie. globally installed
             prettyName = i18nc("@info/plain This string is displayed instead of the full path for "
                             "globally installed service provider plugins.",
                             "Global: %1", QFileInfo(url.path()).baseName());
         }
 
         projects << prettyName;
     }
     return projects;
 }
 
 QStringList TimetableMate::recentUrls() const
 {
     QStringList urls;
     foreach ( const QUrl &url, m_recentFilesAction->urls() ) {
         urls << url.path();
     }
     return urls;
 }
 
 bool TimetableMate::hasOpenedProjects() const
 {
     return m_projectModel->rowCount() > 0;
 }
 
 void TimetableMate::showDock( const QString &dockName, bool show )
 {
     AbstractDockWidget *dock;
     if ( dockName == m_documentationDock->objectName() ) {
         dock = m_documentationDock;
     } else if ( dockName == m_projectsDock->objectName() ) {
         dock = m_projectsDock;
     } else if ( dockName == m_testDock->objectName() ) {
         dock = m_testDock;
     } else if ( dockName == m_webInspectorDock->objectName() ) {
         dock = m_webInspectorDock;
     } else if ( dockName == m_networkMonitorDock->objectName() ) {
         dock = m_networkMonitorDock;
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     } else if ( dockName == m_backtraceDock->objectName() ) {
         dock = m_backtraceDock;
     } else if ( dockName == m_consoleDock->objectName() ) {
         dock = m_consoleDock;
     } else if ( dockName == m_outputDock->objectName() ) {
         dock = m_outputDock;
     } else if ( dockName == m_breakpointDock->objectName() ) {
         dock = m_breakpointDock;
     } else if ( dockName == m_variablesDock->objectName() ) {
         dock = m_variablesDock;
 #endif
     } else {
-        kWarning() << "Unknown dock" << dockName;
+        qWarning() << "Unknown dock" << dockName;
         return;
     }
 
     dock->setVisible( show );
     if ( show ) {
         dock->mainWidget()->setFocus();
     }
 }
 
 void TimetableMate::showDocumentation( const QString &key )
 {
     m_documentationDock->showDocumentation( key );
     m_documentationDock->show();
     m_documentationDock->mainWidget()->setFocus();
 }
 
 void TimetableMate::currentTabChanged( int index ) {
     AbstractTab *tab = index == -1 ? 0 : qobject_cast<AbstractTab*>(m_tabWidget->widget(index));
     if ( tab ) {
         // Go to project source or script tab
         if ( tab->isProjectSourceTab() || tab->isScriptTab() ) {
             AbstractDocumentTab *documentTab = qobject_cast< AbstractDocumentTab* >( tab );
             Q_ASSERT( documentTab );
             if ( documentTab ) {
                 if ( !m_partManager->parts().contains(documentTab->document()) ) {
                     m_partManager->addPart( documentTab->document() );
                 }
                 documentTab->document()->activeView()->setFocus();
             }
         }
 
         // Remove QML view
         if ( m_qmlView ) {
             m_mainLayout->removeWidget( m_qmlView );
             m_mainLayout->removeItem( m_messageWidgetLayout );
             m_mainLayout->addWidget( m_tabWidget );
             m_mainLayout->addLayout( m_messageWidgetLayout );
             m_qmlView->deleteLater();
             m_qmlView = 0;
         }
     } else {
         m_partManager->setActivePart( 0 );
 
         if ( index == -1 && !m_qmlView ) {
             m_qmlView = new QDeclarativeView( this );
             m_qmlView->setResizeMode( QDeclarativeView::SizeRootObjectToView );
 
             // Install a KDeclarative instance to allow eg. QIcon("icon"), i18n("translate")
             KDeclarative *kdeclarative = new KDeclarative();
             kdeclarative->setDeclarativeEngine( m_qmlView->engine() );
             kdeclarative->initialize();
             kdeclarative->setupBindings();
 
             m_qmlView->rootContext()->setContextProperty( "timetableMate", this );
 
             // Expose the name of the SVG to use
             const QString svgFileName = KGlobal::dirs()->findResource( "data", "timetablemate/dashboard.svg" );
             m_qmlView->rootContext()->setContextProperty( "svgFileName", svgFileName );
 
             // Add Plasma QML import paths
             const QStringList importPaths = KGlobal::dirs()->findDirs( "module", "imports" );
             foreach( const QString &importPath, importPaths ) {
                 m_qmlView->engine()->addImportPath( importPath );
             }
 
             // Find the QML file used for the timetablemate dashboard
             const QString fileName = KGlobal::dirs()->findResource( "data", "timetablemate/timetablemate.qml" );
             if ( fileName.isEmpty() ) {
-                kWarning() << "timetablemate.qml not found! Check installation";
+                qWarning() << "timetablemate.qml not found! Check installation";
             } else {
                 m_qmlView->setSource( fileName );
             }
 
             m_mainLayout->removeWidget( m_tabWidget );
             m_mainLayout->removeItem( m_messageWidgetLayout );
             m_mainLayout->addWidget( m_qmlView );
             m_mainLayout->addLayout( m_messageWidgetLayout );
         }
     }
 
     // Adjust if a dashboard tab was left or newly shown
     const bool leftDashboardTab = m_currentTab && m_currentTab->isDashboardTab();
     const bool movedToDashboardTab = tab && tab->isDashboardTab();
     if ( leftDashboardTab && !movedToDashboardTab ) {
         dashboardTabAction( qobject_cast<DashboardTab*>(m_currentTab), LeaveTab );
     } else if ( movedToDashboardTab && !leftDashboardTab ) {
         dashboardTabAction( qobject_cast<DashboardTab*>(tab), MoveToTab );
     }
 
     // Adjust if a project source tab was left or newly shown
     const bool leftProjectSourceTab = m_currentTab && m_currentTab->isProjectSourceTab();
     const bool movedToProjectSourceTab = tab && tab->isProjectSourceTab();
     if ( leftProjectSourceTab && !movedToProjectSourceTab ) {
         projectSourceTabAction( qobject_cast<ProjectSourceTab*>(m_currentTab), LeaveTab );
     } else if ( movedToProjectSourceTab && !leftProjectSourceTab ) {
         projectSourceTabAction( qobject_cast<ProjectSourceTab*>(tab), MoveToTab );
     }
 
     // Adjust if a plasma preview tab was left or newly shown
     const bool leftPlasmaPreviewTab = m_currentTab && m_currentTab->isPlasmaPreviewTab();
     const bool movedToPlasmaPreviewTab = tab && tab->isPlasmaPreviewTab();
     if ( leftPlasmaPreviewTab && !movedToPlasmaPreviewTab ) {
         plasmaPreviewTabAction( qobject_cast<PlasmaPreviewTab*>(m_currentTab), LeaveTab );
     } else if ( movedToPlasmaPreviewTab && !leftPlasmaPreviewTab ) {
         plasmaPreviewTabAction( qobject_cast<PlasmaPreviewTab*>(tab), MoveToTab );
     }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     // Adjust if a script tab was left or newly shown
     const bool leftScriptTab = m_currentTab && m_currentTab->isScriptTab();
     const bool movedToScriptTab = tab && tab->isScriptTab();
     if ( leftScriptTab && !movedToScriptTab ) {
         scriptTabAction( qobject_cast<ScriptTab*>(m_currentTab), LeaveTab );
     } else if ( movedToScriptTab && !leftScriptTab ) {
         scriptTabAction( qobject_cast<ScriptTab*>(tab), MoveToTab );
     }
 #endif
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
     // Adjust if a GTFS database tab was left or newly shown
     const bool leftGtfsDatabaseTab = m_currentTab && m_currentTab->isGtfsDatabaseTab();
     const bool movedToGtfsDatabaseTab = tab && tab->isGtfsDatabaseTab();
     if ( leftGtfsDatabaseTab && !movedToGtfsDatabaseTab ) {
         gtfsDatabaseTabAction( qobject_cast<GtfsDatabaseTab*>(m_currentTab), LeaveTab );
     } else if ( movedToGtfsDatabaseTab && !leftGtfsDatabaseTab ) {
         gtfsDatabaseTabAction( qobject_cast<GtfsDatabaseTab*>(tab), MoveToTab );
     }
 #endif
 
     // Adjust if a web tab was left or newly shown
     const bool leftWebTab = m_currentTab && m_currentTab->isWebTab();
     const bool movedToWebTab = tab && tab->isWebTab();
     if ( leftWebTab && !movedToWebTab ) {
         webTabAction( qobject_cast<WebTab*>(m_currentTab), LeaveTab );
     } else if ( movedToWebTab && !leftWebTab ) {
         webTabAction( qobject_cast<WebTab*>(tab), MoveToTab );
     }
 
     if ( movedToWebTab ) {
         WebTab *webTab = qobject_cast< WebTab* >( tab );
         if ( m_webInspectorDock ) {
             m_webInspectorDock->setWebTab( webTab );
         }
     } else if ( leftWebTab ) {
         WebTab *webTab = qobject_cast< WebTab* >( m_currentTab );
         if ( m_webInspectorDock &&
              m_webInspectorDock->webInspector()->page() == webTab->webView()->page() )
         {
             // The web tab that was closed was connected to the web inspector dock widget
             m_webInspectorDock->setWebTab( 0 );
         }
     }
 
     // Store new tab and update window title
     m_currentTab = tab;
     updateWindowTitle();
 }
 
 void TimetableMate::dashboardTabAction( DashboardTab *dashboardTab, TimetableMate::TabAction tabAction )
 {
     Q_UNUSED( dashboardTab );
     Q_UNUSED( tabAction );
 }
 
 void TimetableMate::projectSourceTabAction( ProjectSourceTab *projectSourceTab,
                                             TimetableMate::TabAction tabAction )
 {
     if ( tabAction == CloseTab ) {
         m_partManager->removePart( projectSourceTab->document() );
     }
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void TimetableMate::scriptTabAction( ScriptTab *scriptTab, TimetableMate::TabAction tabAction )
 {
     if ( tabAction == MoveToTab ) {
         stateChanged( "script_tab_is_active" );
         connect( scriptTab, SIGNAL(canGoToPreviousFunctionChanged(bool)),
                  action("script_previous_function"), SLOT(setEnabled(bool)) );
         connect( scriptTab, SIGNAL(canGoToNextFunctionChanged(bool)),
                  action("script_next_function"), SLOT(setEnabled(bool)) );
     } else if ( tabAction == LeaveTab ) {
         stateChanged( "script_tab_is_active", StateReverse );
         disconnect( scriptTab, SIGNAL(canGoToPreviousFunctionChanged(bool)),
                     action("script_previous_function"), SLOT(setEnabled(bool)) );
         disconnect( scriptTab, SIGNAL(canGoToNextFunctionChanged(bool)),
                     action("script_next_function"), SLOT(setEnabled(bool)) );
     } else if ( tabAction == CloseTab ) {
         m_partManager->removePart( scriptTab->document() );
     }
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 #ifdef BUILD_PROVIDER_TYPE_GTFS
 void TimetableMate::gtfsDatabaseTabAction( GtfsDatabaseTab *gtfsDatabaseTab,
                                            TimetableMate::TabAction tabAction )
 {
     Q_UNUSED( tabAction );
     Q_ASSERT( gtfsDatabaseTab );
 }
 #endif // BUILD_PROVIDER_TYPE_GTFS
 
 void TimetableMate::plasmaPreviewTabAction( PlasmaPreviewTab *plasmaPreviewTab,
                                             TimetableMate::TabAction tabAction )
 {
     Q_UNUSED( tabAction );
     Q_ASSERT( plasmaPreviewTab );
 }
 
 void TimetableMate::webTabAction( WebTab *webTab, TimetableMate::TabAction tabAction )
 {
     if ( m_webInspectorDock ) {
         if ( tabAction == MoveToTab ) {
             m_webInspectorDock->setWebTab( webTab );
             webTab->urlBar()->setFocus();
         } else if ( tabAction == CloseTab ) {
             if ( m_webInspectorDock->webInspector()->page() == webTab->webView()->page() ) {
                 // The web tab that was closed was connected to the web inspector dock widget
                 m_webInspectorDock->setWebTab( 0 );
             }
         }
     }
 }
 
 void TimetableMate::setupActions() {
     KAction *newProject = new KAction( KIcon("project-development-new-template"),
                                        i18nc("@action", "New Project"), this );
     newProject->setPriority( QAction::LowPriority );
     KAction *openProject = new KAction( KIcon("project-open"),
                                         i18nc("@action", "Open Project"), this );
     openProject->setPriority( QAction::LowPriority );
     actionCollection()->addAction( QLatin1String("project_new"), newProject );
     actionCollection()->addAction( QLatin1String("project_open"), openProject );
     connect( newProject, SIGNAL(triggered(bool)), this, SLOT(fileNew()) );
     connect( openProject, SIGNAL(triggered(bool)), this, SLOT(fileOpen()) );
 
     KAction *saveAllProjects = new KAction( KIcon("document-save-all"),
                                             i18nc("@action", "Save All"), this );
     actionCollection()->addAction( QLatin1String("project_save_all"), saveAllProjects );
     connect( saveAllProjects, SIGNAL(triggered(bool)), this, SLOT(fileSaveAll()) );
 
     KStandardAction::quit( qApp, SLOT(closeAllWindows()), actionCollection() );
     KStandardAction::preferences( this, SLOT(optionsPreferences()), actionCollection() );
     m_recentFilesAction = KStandardAction::openRecent( this, SLOT(open(QUrl)), actionCollection() );
     actionCollection()->addAction( QLatin1String("project_open_recent"), m_recentFilesAction );
 
     KAction *openInstalled = new KAction( KIcon("document-open"), i18nc("@action",
                                           "Open I&nstalled..."), this );
     actionCollection()->addAction( QLatin1String("project_open_installed"), openInstalled );
     connect( openInstalled, SIGNAL(triggered(bool)), this, SLOT(fileOpenInstalled()) );
 
     KAction *fetch = new KAction( KIcon("svn-update"),
                                   i18nc("@action", "&Fetch Project..."), this );
     actionCollection()->addAction( QLatin1String("project_fetch"), fetch );
     connect( fetch, SIGNAL(triggered(bool)), this, SLOT(fetchProject()) );
 
     KSelectAction *chooseActiveProject = new KSelectAction(
             KIcon("edit-select"), i18nc("@action", "&Active Project"), this );
     actionCollection()->addAction( QLatin1String("project_choose_active"), chooseActiveProject );
 
     QToolButton *activeProjectButton = new QToolButton( this );
     activeProjectButton->setDefaultAction( chooseActiveProject );
     activeProjectButton->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
     activeProjectButton->setPopupMode( QToolButton::InstantPopup );
     menuBar()->setCornerWidget( activeProjectButton );
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
     // TODO Move to Project? => Project::ProjectAction
     KAction *scriptNextFunction = ScriptTab::createNextFunctionAction( this );
     actionCollection()->addAction( QLatin1String("script_next_function"), scriptNextFunction );
     scriptNextFunction->setVisible( false );
     connect( scriptNextFunction, SIGNAL(triggered(bool)),
              this, SLOT(scriptNextFunction()) );
 
     KAction *scriptPreviousFunction = ScriptTab::createPreviousFunctionAction( this );
     actionCollection()->addAction( QLatin1String("script_previous_function"), scriptPreviousFunction );
     scriptPreviousFunction->setVisible( false );
     connect( scriptPreviousFunction, SIGNAL(triggered(bool)),
              this, SLOT(scriptPreviousFunction()) );
 #endif
 
     // Add project actions, they get connected to the currently active project
     // in activeProjectAboutToChange()
     foreach ( Project::ProjectAction projectAction, externProjectActions() ) {
         actionCollection()->addAction( Project::projectActionName(projectAction),
                                        Project::createProjectAction(projectAction, this) );
     }
 
     KAction *tabNext = new KAction( KIcon("go-next"), i18nc("@action", "Go to &Next Tab"), this );
     tabNext->setShortcut( KStandardShortcut::tabNext() );
     connect( tabNext, SIGNAL(triggered()), this, SLOT(tabNextActionTriggered()) );
     actionCollection()->addAction( QLatin1String("tab_next"), tabNext );
 
     KAction *tabPrevious = new KAction( KIcon("go-previous"), i18nc("@action", "Go to &Previous Tab"), this );
     tabPrevious->setShortcut( KStandardShortcut::tabPrev() );
     connect( tabPrevious, SIGNAL(triggered()), this, SLOT(tabPreviousActionTriggered()) );
     actionCollection()->addAction( QLatin1String("tab_previous"), tabPrevious );
 
     KAction *tabClose = new KAction( KIcon("tab-close"), i18nc("@action", "&Close Tab"), this );
     tabClose->setShortcut( KStandardShortcut::close() );
     connect( tabClose, SIGNAL(triggered()), this, SLOT(closeCurrentTab()) );
     actionCollection()->addAction( QLatin1String("tab_close"), tabClose );
 
     KAction *runAllTestsAction = new KAction( KIcon("task-complete"),
             i18nc("@action", "Test all &Projects"), this );
     connect( m_projectModel, SIGNAL(idleChanged(bool)), runAllTestsAction, SLOT(setEnabled(bool)) );
     connect( runAllTestsAction, SIGNAL(triggered()), m_projectModel, SLOT(testAllProjects()) );
     actionCollection()->addAction( QLatin1String("test_all_projects"), runAllTestsAction );
 }
 
 void TimetableMate::tabNextActionTriggered()
 {
     if ( m_tabWidget->currentIndex() + 1 < m_tabWidget->count() ) {
         m_tabWidget->setCurrentIndex( m_tabWidget->currentIndex() + 1 );
     } else if ( m_tabWidget->count() > 1 ) {
         // Was at last tab, go to the first tab
         m_tabWidget->setCurrentIndex( 0 );
     }
 }
 
 void TimetableMate::tabPreviousActionTriggered()
 {
     if ( m_tabWidget->currentIndex() - 1 >= 0 ) {
         m_tabWidget->setCurrentIndex( m_tabWidget->currentIndex() - 1 );
     } else if ( m_tabWidget->count() > 1 ) {
         // Was at first tab, go to the last tab
         m_tabWidget->setCurrentIndex( m_tabWidget->count() - 1 );
     }
 }
 
 #ifdef BUILD_PROVIDER_TYPE_SCRIPT
 void TimetableMate::toggleBreakpoint()
 {
     ScriptTab *scriptTab = qobject_cast< ScriptTab* >( m_currentTab );
     if ( scriptTab ) {
         scriptTab->toggleBreakpoint();
     }
 }
 
 void TimetableMate::scriptPreviousFunction()
 {
     ScriptTab *scriptTab = qobject_cast< ScriptTab* >( m_currentTab );
     if ( scriptTab ) {
         scriptTab->goToPreviousFunction();
     }
 }
 
 void TimetableMate::scriptNextFunction()
 {
     ScriptTab *scriptTab = qobject_cast< ScriptTab* >( m_currentTab );
     if ( scriptTab ) {
         scriptTab->goToNextFunction();
     }
 }
 
 void TimetableMate::breakpointReached( const Breakpoint &breakpoint )
 {
     infoMessage( i18nc("@info/plain", "Reached breakpoint at %1", breakpoint.lineNumber()),
                  KMessageWidget::Information );
 }
 
 void TimetableMate::uncaughtException( int lineNumber, const QString &errorMessage,
                                        const QString &fileName )
 {
     // Do not show messages while testing, results are shown in the test dock
     if ( m_projectModel->activeProject()->suppressMessages() ) {
         return;
     }
 
     infoMessage( i18nc("@info", "Uncaught exception in <filename>%1</filename> at %2: "
                        "<message>%3</message>",
                        QFileInfo(fileName).fileName(), lineNumber, errorMessage),
                  KMessageWidget::Error, -1 );
 }
 #endif // BUILD_PROVIDER_TYPE_SCRIPT
 
 void TimetableMate::testStarted()
 {
     if ( m_testDock ) {
         m_testDock->show();
     }
     updateWindowTitle();
 }
 
 void TimetableMate::testFinished( bool success )
 {
     Q_UNUSED( success );
     updateWindowTitle();
 }
 
 void TimetableMate::fileNew()
 {
     const Enums::ServiceProviderType providerType = chooseProviderPluginType();
     if ( providerType == Enums::InvalidProvider ) {
         return; // Canceled
     }
 
     // Create the new project
     Project *newProject = new Project( providerType, m_projectModel->weaver(), this );
     newProject->loadProject();
     m_projectModel->appendProject( newProject );
     connect( newProject, SIGNAL(showDocumentationRequest(QString)),
              this, SLOT(showDocumentation(QString)) );
 
     // Make the new project the currently active one
     newProject->setAsActiveProject();
 
     // Show settings of the project
     newProject->showSettingsDialog( this );
 
     // Show the dashboard of the new project
     newProject->showDashboardTab();
 
     // Expand new project item in the projects dock
     m_projectsDock->projectsWidget()->expand( m_projectModel->indexFromProject(newProject) );
 }
 
 Enums::ServiceProviderType TimetableMate::chooseProviderPluginType()
 {
     if ( ServiceProviderGlobal::availableProviderTypes().count() == 1 ) {
         // Only one provider plugin type is available, no need to ask the user
         return ServiceProviderGlobal::availableProviderTypes().first();
     }
 
     // Create a dialog with a combo box to choose a provider plugin type
     QPointer< KDialog > dialog = new KDialog( this );
     QWidget *container = new QWidget( dialog );
     KComboBox *pluginType = new KComboBox( container );
     foreach ( Enums::ServiceProviderType type, ServiceProviderGlobal::availableProviderTypes() ) {
         pluginType->addItem( ServiceProviderGlobal::typeName(type), static_cast<int>(type) );
     }
     QLabel *infoLabel = new QLabel( container );
     infoLabel->setWordWrap( true );
     infoLabel->setText( i18nc("@info:whatsthis", "<title>Create New Provider Plugin</title>"
         "<para>To create a new provider plugin first choose the type of the plugin. "
         "Currently <emphasize>Scripted</emphasize> and <emphasize>GTFS</emphasize> "
         "(since version 0.11) types are available. Your version of TimetableMate may be "
         "compiled without support for one of these types.</para>"
         "<para>The <emphasize>Scripted</emphasize> type can be used for a variety of providers "
         "publishing their timetable data in web sites. Helper functions are provided to easily "
         "parse HTML sites for timetable data in the script (QtScript, ie. JavaScript, by using "
         "the Kross script extension Python and Ruby are also available). The script extension "
         "\"qt.xml\" helps parsing XML data sources. For providers using the HAFAS API there "
         "is a base script available, use <icode>include( \"base_hafas.js\" );</icode></para>"
         "<para>If a <emphasize>GTFS</emphasize> feed is available a provider plugin can be "
         "created much easier, ie. without writing a script. Only the URL to the GTFS feed is "
         "needed. <emphasize>GTFS-realtime</emphasize> TripUpdates and Alerts URLs can also be "
         "specified.</para>") );
     QFormLayout *layout = new QFormLayout( container );
     layout->setContentsMargins( 4, 4, 4, 48 );
     layout->addRow( infoLabel );
     layout->addItem( new QSpacerItem(12, 12, QSizePolicy::Preferred, QSizePolicy::Preferred) );
     layout->addRow( pluginType );
     layout->addItem( new QSpacerItem(12, 12, QSizePolicy::Preferred, QSizePolicy::Preferred) );
     dialog->setMainWidget( container );
     dialog->setWindowTitle( i18nc("@info/plain", "Choose Provider Plugin Type") );
     dialog->setButtonText( KDialog::Ok, i18nc("@info/plain", "Create Provider Plugin") );
 
     // Show the dialog
     const int result = dialog->exec();
 
     // Get selected provider type
     const Enums::ServiceProviderType type = static_cast< Enums::ServiceProviderType >(
             pluginType->itemData(pluginType->currentIndex()).toInt() );
 
     // Cleanup
     delete dialog.data();
     return result == KDialog::Accepted ? type : Enums::InvalidProvider;
 }
 
 void TimetableMate::projectAdded( Project *project )
 {
     // Connect new project
     connect( project, SIGNAL(tabTitleChanged(QWidget*,QString,QIcon)),
              this, SLOT(tabTitleChanged(QWidget*,QString,QIcon)) );
     connect( project, SIGNAL(testStarted()), this, SLOT(removeAllMessageWidgets()) );
     connect( project, SIGNAL(informationMessage(QString,KMessageWidget::MessageType,int,QString,QString,QList<QAction*>)),
              this, SLOT(infoMessage(QString,KMessageWidget::MessageType,int,QString,QString,QList<QAction*>)) );
     connect( project, SIGNAL(closeRequest()), this, SLOT(projectCloseRequest()) );
     connect( project, SIGNAL(tabCloseRequest(AbstractTab*)), this, SLOT(closeTab(AbstractTab*)) );
     connect( project, SIGNAL(otherTabsCloseRequest(AbstractTab*)),
              this, SLOT(closeAllTabsExcept(AbstractTab*)) );
     connect( project, SIGNAL(tabOpenRequest(AbstractTab*)), this, SLOT(tabOpenRequest(AbstractTab*)) );
     connect( project, SIGNAL(tabGoToRequest(AbstractTab*)), this, SLOT(tabGoToRequest(AbstractTab*)) );
     connect( project, SIGNAL(saveLocationChanged(QString,QString)),
              this, SLOT(projectSaveLocationChanged(QString,QString)) );
 
     KSelectAction *chooseActiveProject =
             qobject_cast< KSelectAction* >( action("project_choose_active") );
     if ( chooseActiveProject ) {
         // Create "Set as Active Project" action and use the project name/icon for it
         // instead of the default, which would mean that the chooseActiveProject action would
         // contain multiple actions with the same text/icon
         QAction *action = project->createProjectAction(
                 Project::SetAsActiveProject, chooseActiveProject );
         action->setText( project->projectName() );
         action->setIcon( project->projectIcon() );
 
         // Store a pointer to the project in the action,
         // to be able to find the action for a specific project in the select action
         action->setData( QVariant::fromValue(static_cast<void*>(project)) );
 
         // Connect action with the project
         project->connectProjectAction( Project::SetAsActiveProject, action );
 
         // Add action to make the project active to the select action
         chooseActiveProject->addAction( action );
     }
 
     emit hasOpenedProjectsChanged( true );
 }
 
 void TimetableMate::projectAboutToBeRemoved( Project *project )
 {
     KSelectAction *chooseActiveProject =
             qobject_cast< KSelectAction* >( action("project_choose_active") );
     if ( chooseActiveProject ) {
         // Search for the action associated with the given project
         foreach ( QAction *action, chooseActiveProject->actions() ) {
             // Read pointer to the associated project from the action's data
             Project *associatedProject = static_cast< Project* >( action->data().value<void*>() );
             if ( associatedProject == project ) {
                 // Found the action associated with the given project, remove it
                 chooseActiveProject->removeAction( action );
                 break;
             }
         }
     }
 
     if ( m_projectModel->rowCount() == 0 ) {
         emit hasOpenedProjectsChanged( false );
     }
 }
 
 void TimetableMate::projectSaveLocationChanged( const QString &newXmlFilePath,
                                                 const QString &oldXmlFilePath )
 {
     Q_UNUSED( oldXmlFilePath );
     if ( newXmlFilePath.isEmpty() ) {
         m_recentFilesAction->addUrl( newXmlFilePath );
     }
 }
 
 void TimetableMate::removeAllMessageWidgets()
 {
     // Hide the widget and then delete it (give 1 second for the hide animation)
     while ( !m_messageWidgets.isEmpty() ) {
         QPointer< KMessageWidget > messageWidget = m_messageWidgets.dequeue();
         if ( messageWidget.data() ) {
             messageWidget->animatedHide();
             QTimer::singleShot( 1000, messageWidget, SLOT(deleteLater()) );
         }
     }
 }
 
 void TimetableMate::infoMessage( const QString &message, KMessageWidget::MessageType type,
                                  int timeout, const QString &messageGroup,
                                  const QString &resolveMessage, QList<QAction*> actions )
 {
     // Do not show messages from inactive projects, except for error messages
     Project *project = qobject_cast< Project* >( sender() );
     if ( project && !project->isActiveProject() && type != KMessageWidget::Error ) {
         return;
     }
 
     if ( !m_messageWidgets.isEmpty() ) {
         QPointer< KMessageWidget > messageWidget = m_messageWidgets.last();
         while ( !messageWidget.data() ) {
             m_messageWidgets.removeOne( messageWidget );
             if ( m_messageWidgets.isEmpty() ) {
                 messageWidget = 0;
                 break;
             }
             messageWidget = m_messageWidgets.last();
         }
 
         if ( messageWidget && messageWidget->messageType() == type &&
              messageWidget->text() == message )
         {
             // The same message was just added
             return;
         }
     }
 
     if ( !replaceMessage(messageGroup, message, resolveMessage) ) {
         // Create a new KMessageWidget
         QPointer< KMessageWidget > messageWidget( new KMessageWidget(message, this) );
         messageWidget->setObjectName( messageGroup );
         messageWidget->hide();
         messageWidget->setCloseButtonVisible( true );
         messageWidget->setMessageType( type );
         messageWidget->addActions( actions );
         if ( message.length() > 60 ) {
             messageWidget->setWordWrap( true );
         }
 
         // Install event filter to delete the message widget when it gets hidden
         messageWidget->installEventFilter( this );
 
         // Add new message widget
         m_messageWidgetLayout->addWidget( messageWidget );
         m_messageWidgets.enqueue( messageWidget );
         messageWidget->animatedShow();
 
         // Add a timer to remove the message widget again
         if ( timeout > 0 ) {
             hideMessageWidgetLater( messageWidget, timeout );
         }
 
         // Clear up the message widget queue, if there are too many messages shown
         const int maxMessageWidgetCount = 3;
         while ( m_messageWidgets.length() > maxMessageWidgetCount ) {
             QPointer< KMessageWidget > messageWidget = m_messageWidgets.dequeue();
             if ( messageWidget.data() ) {
                 messageWidget.data()->deleteLater();
             }
         }
     }
 }
 
 uint qHash( const QPointer< KMessageWidget > &messageWidget )
 {
     return qHash( messageWidget.data() );
 }
 
 void TimetableMate::hideMessageWidgetLater( const QPointer< KMessageWidget > &messageWidget,
                                             int timeout )
 {
     QTimer *timer = timerFromMessageWidget( messageWidget );
     if ( !timer ) {
         timer = new QTimer( this );
         connect( timer, SIGNAL(timeout()), this, SLOT(removeMessageWidget()) );
         timer->setSingleShot( true );
         m_autoRemoveMessageWidgets.insert( messageWidget, timer );
     }
     timer->start( timeout );
 }
 
 QTimer *TimetableMate::timerFromMessageWidget( const QPointer<KMessageWidget> &messageWidget )
 {
     return m_autoRemoveMessageWidgets.value( messageWidget, 0 );
 }
 
 QPointer<KMessageWidget> TimetableMate::messageWidgetFromTimer( QTimer *timer )
 {
     return m_autoRemoveMessageWidgets.key( timer );
 }
 
 bool TimetableMate::hasMessagesOfGroup( const QString &messageGroup ) const
 {
     QQueue< QPointer<KMessageWidget> >::ConstIterator it = m_messageWidgets.constBegin();
     while ( it != m_messageWidgets.constEnd() ) {
         if ( (*it)->objectName() == messageGroup ) {
             return true;
         }
         ++it;
     }
     return false;
 }
 
 void TimetableMate::removeMessages( const QString &messageGroup, const QString &resolveMessage )
 {
     if ( messageGroup.isEmpty() ) {
         return;
     }
 
     for ( int i = 0; i < m_messageWidgets.count(); ++i ) {
         const QPointer<KMessageWidget> &messageWidget = m_messageWidgets[i];
         if ( messageWidget->objectName() == messageGroup ) {
             messageWidget->animatedHide();
             m_messageWidgets.removeAt( i );
 
             if ( !resolveMessage.isEmpty() ) {
                 infoMessage( resolveMessage, KMessageWidget::Positive, 1000, messageGroup );
             }
             break; // Only one message widget per group
         }
     }
 }
 
 bool TimetableMate::replaceMessage( const QString &messageGroup, const QString &newMessage,
                                     const QString &resolveMessage )
 {
     if ( newMessage.isEmpty() ) {
         // No new message text, remove old messages of the group
         removeMessages( messageGroup, resolveMessage );
         return true;
     }
 
     // Update the text shown in the message group
     QQueue< QPointer<KMessageWidget> >::ConstIterator it = m_messageWidgets.constBegin();
     while ( it != m_messageWidgets.constEnd() ) {
         if ( (*it)->objectName() == messageGroup ) {
             (*it)->setText( newMessage );
 
             // Restart the timer to hide the message widget
             hideMessageWidgetLater( *it );
             return true;
         }
         ++it;
     }
 
     return false;
 }
 
 void TimetableMate::removeMessageWidget()
 {
     if ( m_autoRemoveMessageWidgets.isEmpty() ) {
         return;
     }
 
     // Hide the widget and then delete it (give 1 second for the hide animation)
     QTimer *timer = qobject_cast< QTimer* >( sender() );
     QPointer<KMessageWidget> messageWidget = messageWidgetFromTimer( timer );
     if ( !messageWidget ) {
-        kWarning() << "Cannot find message widget associated to timer" << timer;
+        qWarning() << "Cannot find message widget associated to timer" << timer;
         return;
     }
 
     m_messageWidgets.removeOne( messageWidget );
     if ( messageWidget.data() ) {
         messageWidget->animatedHide();
     }
 }
 
 bool TimetableMate::eventFilter( QObject *object, QEvent *event )
 {
     KMessageWidget *messageWidget = qobject_cast< KMessageWidget*> ( object );
     if ( messageWidget && event->type() == QEvent::Hide ) {
         // Delete message widgets after they are hidden
         messageWidget->deleteLater();
     }
 
     return QObject::eventFilter( object, event );
 }
 
 void TimetableMate::projectCloseRequest() {
     Project *project = qobject_cast< Project* >( sender() );
     if ( !project ) {
-        kWarning() << "Slot projectCloseRequest() called from wrong sender, "
+        qWarning() << "Slot projectCloseRequest() called from wrong sender, "
                       "only class Project is allowed";
         return;
     }
 
     closeProject( project );
 }
 
 void TimetableMate::tabTitleChanged( QWidget *tabWidget, const QString &title, const QIcon &icon )
 {
     const int index = m_tabWidget->indexOf( tabWidget );
     if ( index != -1 ) {
         // Tab widget was already inserted into the main tab bar
         m_tabWidget->setTabText( index, title );
         m_tabWidget->setTabIcon( index, icon );
     }
 }
 
 void TimetableMate::closeProject()
 {
     closeProject( m_projectModel->activeProject() );
 }
 
 AbstractTab *TimetableMate::showProjectTab( bool addTab, AbstractTab *tab )
 {
     if ( !tab ) {
         kDebug() << "No tab object";
         return 0;
     }
 
     if ( addTab ) {
         // Add the tab
         m_tabWidget->addTab( tab, tab->icon(), tab->title() );
     }
 
     // Switch to the tab
     m_tabWidget->setCurrentWidget( tab );
     return tab;
 }
 
 void TimetableMate::open( const QUrl &url ) {
     kDebug() << "OPEN" << url;
     Project *project = openProject( url.path() );
     if ( project ) {
         project->showDashboardTab( this );
     }
 }
 
 Project *TimetableMate::openProject( const QString &filePath )
 {
     Project *openedProject = m_projectModel->projectFromFilePath( filePath );
     if ( openedProject ) {
         return openedProject;
     }
 
     // Create project and try to load it,
     // before loading it connect to the info message signal for error messages while reading
     Project *project = new Project( m_projectModel->weaver(), this );
     connect( project, SIGNAL(informationMessage(QString,KMessageWidget::MessageType,int,QString,QString,QList<QAction*>)),
              this, SLOT(infoMessage(QString,KMessageWidget::MessageType,int,QString,QString,QList<QAction*>)) );
     project->loadProject( filePath );
     disconnect( project, SIGNAL(informationMessage(QString,KMessageWidget::MessageType,int,QString,QString,QList<QAction*>)),
                 this, SLOT(infoMessage(QString,KMessageWidget::MessageType,int,QString,QString,QList<QAction*>)) );
     if ( project->state() == Project::ProjectSuccessfullyLoaded ) {
         if ( !project->filePath().isEmpty() ) {
             m_recentFilesAction->addUrl( project->filePath() );
         }
         m_projectModel->appendProject( project );
         connect( project, SIGNAL(showDocumentationRequest(QString)),
                  this, SLOT(showDocumentation(QString)) );
         return project;
     } else if ( project->state() == Project::ProjectError ) {
         // The error message was emitted from the constructor of Project
         infoMessage( project->lastError(), KMessageWidget::Error );
         delete project;
         return 0;
     }
 
     return project;
 }
 
 void TimetableMate::fileOpen() {
     const QStringList fileNames = KFileDialog::getOpenFileNames( QUrl("kfiledialog:///serviceprovider"),
             "application/x-publictransport-serviceprovider application/xml",
             this, i18nc("@title:window", "Open Service Provider Plugin") );
     if ( fileNames.isEmpty() )
         return; // Cancel clicked
 
     foreach ( const QString &fileName, fileNames ) {
         open( QUrl(fileName) );
 
         // Expand manually opened project item
         m_projectsDock->projectsWidget()->expand(
                 m_projectModel->index(m_projectModel->rowCount() - 1, 0) );
     }
 }
 
 void TimetableMate::fileOpenInstalled() {
     // Get a list of all service provider plugin files in the directory of the XML file
     QStringList pluginFiles = ServiceProviderGlobal::installedProviders();
     if ( pluginFiles.isEmpty() ) {
         KMessageBox::information( this, i18nc("@info/plain", "There are no installed "
                 "service provider plugins. You need to install the PublicTransport data engine.") );
         return;
     }
     qSort( pluginFiles );
 
     // Make filenames more pretty and create a hash to map from the pretty names to the full paths
     QHash< QString, QString > map;
     for ( QStringList::iterator it = pluginFiles.begin(); it != pluginFiles.end(); ++it ) {
         QString prettyName;
         if ( KStandardDirs::checkAccess(*it, W_OK) ) {
             // File is writable, ie. locally installed
             prettyName = QUrl( *it ).fileName();
         } else {
             // File isn't writable, ie. globally installed
             prettyName = i18nc("@info/plain This string is displayed instead of the full path for "
                                "globally installed service provider plugins.",
                                "Global: %1", QUrl(*it).fileName());
         }
 
         map.insert( prettyName, *it );
         *it = prettyName;
     }
 
     bool ok;
     QStringList selectedPrettyNames = KInputDialog::getItemList(
             i18nc("@title:window", "Open Installed Service Provider Plugin"),
             i18nc("@info", "Installed service provider plugin"),
             pluginFiles, QStringList(), true, &ok, this );
     if ( ok ) {
         foreach ( const QString &selectedPrettyName, selectedPrettyNames ) {
             QString selectedFilePath = map[ selectedPrettyName ];
             Project *project = openProject( selectedFilePath );
             if ( project ) {
                 project->showDashboardTab( this );
             }
         }
     }
 }
 
 void TimetableMate::fetchProject()
 {
     // Show the GHNS download dialog, downloads to .../timetablemate/serviceProviders
     if ( !m_downloadDialog ) {
         m_downloadDialog = new KNS3::DownloadDialog( "timetablemate.knsrc", this );
         connect( m_downloadDialog, SIGNAL(accepted()), this, SLOT(fetchProjectFinished()) );
     }
     m_downloadDialog->show();
 }
 
 void TimetableMate::fetchProjectFinished()
 {
     if ( !m_downloadDialog ) {
-        kWarning() << "Download dialog already destroyed";
+        qWarning() << "Download dialog already destroyed";
         return;
     }
 
     // Dialog is done
     if ( !m_downloadDialog->installedEntries().isEmpty() ) {
         // At least one project has been newly installed
         // Get all provider plugin .pts files that have been installed (not eg. the script files)
         QStringList installedProviderNames;
         QStringList installedProviderFiles;
         foreach ( const KNS3::Entry &installedEntry, m_downloadDialog->installedEntries() ) {
             // Find the provider plugin .pts file
             const QStringList installedFiles = installedEntry.installedFiles();
             QString providerFile;
             foreach ( const QString &installedFile, installedFiles ) {
                 if ( installedFile.endsWith(QLatin1String(".pts")) ||
                      installedFile.endsWith(QLatin1String(".xml")) )
                 {
                     providerFile = installedFile;
                     break;
                 }
             }
             if ( providerFile.isEmpty() ) {
-                kWarning() << "No provider plugin file found in installed entry"
+                qWarning() << "No provider plugin file found in installed entry"
                            << installedEntry.name();
                 continue;
             }
 
             installedProviderNames << installedEntry.name();
             installedProviderFiles << providerFile;
         }
 
         // Ask if the just installed provider plugins should get opened now
         const int result = KMessageBox::questionYesNoList( this,
                 i18nc("@info", "The following provider plugins have been fetched. "
                       "Do you want to open them now?"), installedProviderNames );
         if ( result == KMessageBox::Yes ) {
             // Open clicked, open the installed provider plugins
             foreach ( const QString &providerFile, installedProviderFiles ) {
                 openProject( providerFile );
             }
         }
 
         // Inform about fetched providers and show the target directory
         const QString saveDirectory =
                 KGlobal::dirs()->saveLocation( "data", "timetablemate/serviceProviders");
         infoMessage( i18ncp("@info", "%1 provider plugin has been fetched to %2",
                                      "%1 provider plugins have been fetched to %2",
                             installedProviderFiles.count(), saveDirectory) );
     }
 
     delete m_downloadDialog;
     m_downloadDialog = 0;
 }
 
 void TimetableMate::fileSaveAll() {
     for ( int row = 0; row < m_projectModel->rowCount(); ++row ) {
         Project *project = m_projectModel->projectItemFromRow( row )->project();
         project->save( this );
     }
 }
 
 void TimetableMate::optionsPreferences() {
     // Avoid to have two dialogs shown
     if ( !KConfigDialog::showDialog("settings") )  {
         // Create a new preferences dialog and show it
         KConfigDialog *dialog = new KConfigDialog( this, "settings", Settings::self() );
         QWidget *generalSettings = new QWidget( dialog );
         ui_preferences = new Ui::preferences;
         ui_preferences->setupUi( generalSettings );
         dialog->addPage( generalSettings, i18n("General"), "package_settings" );
         dialog->setAttribute( Qt::WA_DeleteOnClose );
         connect( dialog, SIGNAL(finished()), this, SLOT(preferencesDialogFinished()) );
         dialog->show();
     }
 }
 
 void TimetableMate::preferencesDialogFinished()
 {
     delete ui_preferences;
     ui_preferences = 0;
 
     const int threadCount = Settings::self()->maximumThreadCount();
     m_projectModel->weaver()->setMaximumNumberOfThreads( threadCount < 1 ? 32 : threadCount );
 }
 
 bool TimetableMate::hasHomePageURL( const ServiceProviderData *data ) {
     if ( data->url().isEmpty() ) {
         KMessageBox::information( this, i18nc("@info",
                 "The <interface>Home Page URL</interface> is empty.<nl/>"
                 "Please set it in the project settings dialog first.") );
         return false;
     } else
         return true;
 }
 
 #include "timetablemate.moc"
diff --git a/engine/timetableservice.cpp b/engine/timetableservice.cpp
index 6ac6900..c44623d 100644
--- a/engine/timetableservice.cpp
+++ b/engine/timetableservice.cpp
@@ -1,219 +1,219 @@
 /*
  *   Copyright 2013 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 "timetableservice.h"
 
 // KDE includes
 #include <Plasma/DataEngine>
 
 // Qt incluse
 #include <QMetaMethod>
 #include <qmath.h>
 #include <QDebug>
 
 RequestAdditionalDataJob::RequestAdditionalDataJob( Plasma::DataEngine *engine,
         const QString &destination, const QString &operation,
         const QMap< QString, QVariant > &parameters, QObject *parent )
         : TimetableServiceJob(engine, destination, operation, parameters, parent),
           m_itemsDone(0), m_itemsFailed(0)
 {
     if ( parameters.contains("itemnumberbegin") && parameters.contains("itemnumberend") ) {
         m_updateItem = parameters["itemnumberbegin"].toInt();
         m_updateItemEnd = parameters["itemnumberend"].toInt();
         Q_ASSERT( m_updateItemEnd >= m_updateItem );
     } else {
         m_updateItem = m_updateItemEnd = parameters["itemnumber"].toInt();
     }
 }
 
 void RequestAdditionalDataJob::start()
 {
     // Find the slot of the engine to start the request
     const QMetaObject *meta = m_engine->metaObject();
     const int slotIndex = meta->indexOfSlot( "requestAdditionalData(QString,int,int)" );
     Q_ASSERT( slotIndex != -1 );
 
     // Connect to the finished signal of the engine for finished additional data requests
     // NOTE This signal is emitted for each finished request, not for all requests,
     //   if there are multiple requests
     connect( m_engine, SIGNAL(additionalDataRequestFinished(QString,int,bool,QString)),
              this, SLOT(additionalDataRequestFinished(QString,int,bool,QString)) );
 
     // Invoke the slot to request additional data for each item
     meta->method( slotIndex ).invoke( m_engine, Qt::QueuedConnection,
                                       Q_ARG(QString, destination()),
                                       Q_ARG(int, m_updateItem),
                                       Q_ARG(int, m_updateItemEnd - m_updateItem + 1) );
 }
 
 void RequestAdditionalDataJob::additionalDataRequestFinished( const QString &sourceName,
                                                               int item, bool success,
                                                               const QString &errorMessage )
 {
     if ( sourceName != destination() || item < m_updateItem || item > m_updateItemEnd ) {
         // The finished() signal from the data engine was emitted for another service job
         return;
     }
 
     ++m_itemsDone;
     if ( !success ) {
         ++m_itemsFailed;
         if ( m_errorMessage.isEmpty() ) {
             m_errorMessage = errorMessage;
         }
     }
     const int totalItemsToUpdate = m_updateItemEnd - m_updateItem + 1;
     const int itemsFailed = m_itemsFailed;
     const bool isFinished = m_itemsDone == totalItemsToUpdate;
     const long unsigned int percent = qCeil((100 * m_itemsDone) / qreal(totalItemsToUpdate));
     QString firstErrorMessage = m_errorMessage;
     Q_ASSERT( totalItemsToUpdate > 0 );
 
     // Set the current percentage of requests that are done
     setPercent( percent );
 
     if ( isFinished ) {
         // Last item is done set error message, if any
         if ( itemsFailed >= 1 ) {
             // Use a simple error message if multiple items were requested, otherwise use the error
             // message for the failed item. The error messages for all failed items are set in the
             // target data source in "additionalDataError" fields.
             if ( totalItemsToUpdate > 1 ) {
                 firstErrorMessage = i18nc("@info/plain", "%1 of %2 items failed",
                                           itemsFailed, totalItemsToUpdate);
             }
             setError( KJob::UserDefinedError );
             setErrorText( firstErrorMessage );
         }
 
         // Set the result and emit finished(). This should only be done when the job is really
         // finished, it. there should be no more requests of multiple requests to be done for
         // this job. It will not crash in the service
         // NOTE The finished() signal may be connected to the deleteLater() slot of the service,
         // which is the parent of this job, ie. this may delete this job (later)
         setResult( success );
     }
 }
 
 UpdateRequestJob::UpdateRequestJob( Plasma::DataEngine *engine, const QString &destination,
         const QString &operation, const QMap< QString, QVariant > &parameters, QObject *parent )
         : TimetableServiceJob( engine, destination, operation, parameters, parent )
 {
 }
 
 void UpdateRequestJob::start()
 {
     // Find the slot of the engine to start the request
     const QMetaObject *meta = m_engine->metaObject();
     const int slotIndex = meta->indexOfMethod( "requestUpdate(QString)" );
     Q_ASSERT( slotIndex != -1 );
 
     // Connect to the finished signal of the engine for finished update requests
     connect( m_engine, SIGNAL(updateRequestFinished(QString,bool,QString)),
              this, SLOT(updateRequestFinished(QString,bool,QString)) );
 
     // Invoke the slot to request the update
     meta->method( slotIndex ).invoke( m_engine, Qt::QueuedConnection,
                                       Q_ARG(QString, destination()) );
 }
 
 void UpdateRequestJob::updateRequestFinished( const QString &sourceName, bool success,
                                               const QString &errorMessage)
 {
     if ( sourceName != destination() ) {
         // The finished() signal from the data engine was emitted for another service job
         return;
     }
 
     setResult( success );
     if ( !success ) {
         setError( TimetableService::UnknownError );
         setErrorText( errorMessage );
     }
 }
 
 RequestMoreItemsJob::RequestMoreItemsJob( Plasma::DataEngine *engine,
         const QString &destination, Enums::MoreItemsDirection direction, const QString &operation,
         const QMap< QString, QVariant > &parameters, QObject *parent )
         : TimetableServiceJob(engine, destination, operation, parameters, parent),
           m_direction(direction)
 {
     qRegisterMetaType< Enums::MoreItemsDirection >( "Enums::MoreItemsDirection" );
 }
 
 void RequestMoreItemsJob::start()
 {
     // Find the slot of the engine to start the request
     const QMetaObject *meta = m_engine->metaObject();
     const int slotIndex = meta->indexOfMethod( "requestMoreItems(QString,Enums::MoreItemsDirection)" );
     Q_ASSERT( slotIndex != -1 );
 
     // Connect to the finished signal of the engine for finished requests for more items
     connect( m_engine, SIGNAL(moreItemsRequestFinished(QString,Enums::MoreItemsDirection,bool,QString)),
              this, SLOT(moreItemsRequestFinished(QString,Enums::MoreItemsDirection,bool,QString)) );
 
     // Invoke the slot to request more items
     meta->method( slotIndex ).invoke( m_engine, Qt::QueuedConnection,
                                       Q_ARG(QString, destination()),
                                       Q_ARG(Enums::MoreItemsDirection, m_direction) );
 }
 
 void RequestMoreItemsJob::moreItemsRequestFinished( const QString &sourceName,
         Enums::MoreItemsDirection direction, bool success, const QString &errorMessage)
 {
     if ( sourceName != destination() || direction == m_direction ) {
         // The finished() signal from the data engine was emitted for another service job
         return;
     }
 
     if ( !success ) {
         setError( TimetableService::UnknownError );
         setErrorText( errorMessage );
     }
     setResult( success );
 }
 
 TimetableService::TimetableService( Plasma::DataEngine *engine, const QString &name,
                                     QObject *parent )
         : Service(parent), m_engine(engine)
 {
     // This associates the service with the "timetable.operations" file
     setName( "timetable" );
     setDestination( name );
 }
 
 Plasma::ServiceJob* TimetableService::createJob(
         const QString &operation, QMap< QString, QVariant > &parameters )
 {
     if ( operation == "requestAdditionalData" || operation == "requestAdditionalDataRange" ) {
         return new RequestAdditionalDataJob( m_engine, destination(), operation, parameters, this );
     } else if ( operation == "requestUpdate" ) {
         return new UpdateRequestJob( m_engine, destination(), operation, parameters, this );
     } else if ( operation == "requestEarlierItems" ) {
         return new RequestMoreItemsJob( m_engine, destination(), Enums::EarlierItems,
                                         operation, parameters, this );
     } else if ( operation == "requestLaterItems" ) {
         return new RequestMoreItemsJob( m_engine, destination(), Enums::LaterItems,
                                         operation, parameters, this );
     } else {
-        kWarning() << "Operation" << operation << "not supported";
+        qWarning() << "Operation" << operation << "not supported";
         return 0;
     }
 }