diff --git a/plan/kptmaindocument.cpp b/plan/kptmaindocument.cpp
index 4951ad40bf2..7c82a042bc5 100644
--- a/plan/kptmaindocument.cpp
+++ b/plan/kptmaindocument.cpp
@@ -1,1486 +1,1496 @@
 /* This file is part of the KDE project
  Copyright (C) 1998, 1999, 2000 Torben Weis <weis@kde.org>
  Copyright (C) 2004, 2010, 2012 Dag Andersen <danders@get2net.dk>
  Copyright (C) 2006 Raphael Langerhorst <raphael.langerhorst@kdemail.net>
  Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.
 
  You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to
  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #include "kptmaindocument.h"
 #include "kptpart.h"
 #include "kptview.h"
 #include "kptfactory.h"
 #include "kptproject.h"
 #include "kptlocale.h"
 #include "kptresource.h"
 #include "kptcontext.h"
 #include "kptschedulerpluginloader.h"
 #include "kptschedulerplugin.h"
 #include "kptbuiltinschedulerplugin.h"
 #include "kptcommand.h"
 #include "calligraplansettings.h"
 #include "kpttask.h"
 #include "KPlatoXmlLoader.h"
 #include "kptpackage.h"
 #include "kptworkpackagemergedialog.h"
 #include "kptdebug.h"
 
 #include <KoZoomHandler.h>
 #include <KoStore.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 #include <KoOdfReadStore.h>
 #include <KoUpdater.h>
 #include <KoProgressUpdater.h>
 #include <KoDocumentInfo.h>
 
 #include <QApplication>
 #include <QPainter>
 #include <QDir>
 #include <QMutableMapIterator>
 #include <QTemporaryFile>
 
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 #include <KIO/CopyJob>
 
 #include <kundo2command.h>
 
 #ifdef HAVE_KHOLIDAYS
 #include <KHolidays/HolidayRegion>
 #endif
 
 namespace KPlato
 {
 
 MainDocument::MainDocument(KoPart *part)
         : KoDocument(part),
         m_project( 0 ),
         m_context( 0 ), m_xmlLoader(),
         m_loadingTemplate( false ),
         m_loadingSharedResourcesTemplate( false ),
         m_viewlistModified( false ),
         m_checkingForWorkPackages( false ),
-        m_loadingSharedProject(false)
+        m_loadingSharedProject(false),
+        m_isTaskModule(false)
 {
     Q_ASSERT(part);
     setAlwaysAllowSaving(true);
     m_config.setReadWrite( true );
 
     loadSchedulerPlugins();
 
     setProject( new Project( m_config ) ); // after config & plugins are loaded
     m_project->setId( m_project->uniqueNodeId() );
     m_project->registerNodeId( m_project ); // register myself
 
     connect(this, &MainDocument::insertSharedProject, this, &MainDocument::slotInsertSharedProject);
 
     QTimer::singleShot ( 5000, this, SLOT(autoCheckForWorkPackages()) );
 }
 
 
 MainDocument::~MainDocument()
 {
     qDeleteAll( m_schedulerPlugins );
     if ( m_project ) {
         m_project->deref(); // deletes if last user
     }
     qDeleteAll( m_mergedPackages );
     delete m_context;
 }
 
 void MainDocument::setReadWrite( bool rw )
 {
     m_config.setReadWrite( rw );
     KoDocument::setReadWrite( rw );
 }
 
 void MainDocument::loadSchedulerPlugins()
 {
     // Add built-in scheduler
     addSchedulerPlugin( "Built-in", new BuiltinSchedulerPlugin( this ) );
 
     // Add all real scheduler plugins
     SchedulerPluginLoader *loader = new SchedulerPluginLoader(this);
     connect(loader, SIGNAL(pluginLoaded(QString,SchedulerPlugin*)), this, SLOT(addSchedulerPlugin(QString,SchedulerPlugin*)));
     loader->loadAllPlugins();
 }
 
 void MainDocument::addSchedulerPlugin( const QString &key, SchedulerPlugin *plugin)
 {
     debugPlan<<plugin;
     m_schedulerPlugins[key] = plugin;
 }
 
 void MainDocument::configChanged()
 {
     //m_project->setConfig( m_config );
 }
 
 void MainDocument::setProject( Project *project )
 {
     if ( m_project ) {
         disconnect( m_project, SIGNAL(projectChanged()), this, SIGNAL(changed()) );
         delete m_project;
     }
     m_project = project;
     if ( m_project ) {
         connect( m_project, SIGNAL(projectChanged()), this, SIGNAL(changed()) );
 //        m_project->setConfig( config() );
         m_project->setSchedulerPlugins( m_schedulerPlugins );
     }
     m_aboutPage.setProject( project );
     emit changed();
 }
 
 bool MainDocument::loadOdf( KoOdfReadStore &odfStore )
 {
     warnPlan<< "OpenDocument not supported, let's try native xml format";
     return loadXML( odfStore.contentDoc(), 0 ); // We have only one format, so try to load that!
 }
 
 bool MainDocument::loadXML( const KoXmlDocument &document, KoStore* )
 {
     QPointer<KoUpdater> updater;
     if (progressUpdater()) {
         updater = progressUpdater()->startSubtask(1, "Plan::Part::loadXML");
         updater->setProgress(0);
         m_xmlLoader.setUpdater( updater );
     }
 
     QString value;
     KoXmlElement plan = document.documentElement();
 
     // Check if this is the right app
     value = plan.attribute( "mime", QString() );
     if ( value.isEmpty() ) {
         errorPlan << "No mime type specified!";
         setErrorMessage( i18n( "Invalid document. No mimetype specified." ) );
         return false;
     }
     if ( value == "application/x-vnd.kde.kplato" ) {
         if (updater) {
             updater->setProgress(5);
         }
         m_xmlLoader.setMimetype( value );
         QString message;
         Project *newProject = new Project( m_config );
         KPlatoXmlLoader loader( m_xmlLoader, newProject );
         bool ok = loader.load( plan );
         if ( ok ) {
             setProject( newProject );
             setModified( false );
             debugPlan<<newProject->schedules();
             // Cleanup after possible bug:
             // There should *not* be any deleted schedules (or with parent == 0)
             foreach ( Node *n, newProject->nodeDict()) {
                 foreach ( Schedule *s, n->schedules()) {
                     if ( s->isDeleted() ) { // true also if parent == 0
                         errorPlan<<n->name()<<s;
                         n->takeSchedule( s );
                         delete s;
                     }
                 }
             }
         } else {
             setErrorMessage( loader.errorMessage() );
             delete newProject;
         }
         if (updater) {
             updater->setProgress(100); // the rest is only processing, not loading
         }
         emit changed();
         return ok;
     }
     if ( value != "application/x-vnd.kde.plan" ) {
         errorPlan << "Unknown mime type " << value;
         setErrorMessage( i18n( "Invalid document. Expected mimetype application/x-vnd.kde.plan, got %1", value ) );
         return false;
     }
     QString syntaxVersion = plan.attribute( "version", PLAN_FILE_SYNTAX_VERSION );
     m_xmlLoader.setVersion( syntaxVersion );
     if ( syntaxVersion > PLAN_FILE_SYNTAX_VERSION ) {
         KMessageBox::ButtonCode ret = KMessageBox::warningContinueCancel(
                       0, i18n( "This document was created with a newer version of Plan (syntax version: %1)\n"
                                "Opening it in this version of Plan will lose some information.", syntaxVersion ),
                       i18n( "File-Format Mismatch" ), KGuiItem( i18n( "Continue" ) ) );
         if ( ret == KMessageBox::Cancel ) {
             setErrorMessage( "USER_CANCELED" );
             return false;
         }
     }
     if (updater) updater->setProgress(5);
 /*
 #ifdef KOXML_USE_QDOM
     int numNodes = plan.childNodes().count();
 #else
     int numNodes = plan.childNodesCount();
 #endif
 */
 #if 0
 This test does not work any longer. KoXml adds a couple of elements not present in the file!!
     if ( numNodes > 2 ) {
         //TODO: Make a proper bitching about this
         debugPlan <<"*** Error ***";
         debugPlan <<"  Children count should be maximum 2, but is" << numNodes;
         return false;
     }
 #endif
     m_xmlLoader.startLoad();
     KoXmlNode n = plan.firstChild();
     for ( ; ! n.isNull(); n = n.nextSibling() ) {
         if ( ! n.isElement() ) {
             continue;
         }
         KoXmlElement e = n.toElement();
         if ( e.tagName() == "project" ) {
             Project *newProject = new Project( m_config );
             m_xmlLoader.setProject( newProject );
             if ( newProject->load( e, m_xmlLoader ) ) {
                 if ( newProject->id().isEmpty() ) {
                     newProject->setId( newProject->uniqueNodeId() );
                     newProject->registerNodeId( newProject );
                 }
                 // The load went fine. Throw out the old project
                 setProject( newProject );
                 // Cleanup after possible bug:
                 // There should *not* be any deleted schedules (or with parent == 0)
                 foreach ( Node *n, newProject->nodeDict()) {
                     foreach ( Schedule *s, n->schedules()) {
                         if ( s->isDeleted() ) { // true also if parent == 0
                             errorPlan<<n->name()<<s;
                             n->takeSchedule( s );
                             delete s;
                         }
                     }
                 }
             } else {
                 delete newProject;
                 m_xmlLoader.addMsg( XMLLoaderObject::Errors, "Loading of project failed" );
                 //TODO add some ui here
             }
         }
     }
     m_xmlLoader.stopLoad();
 
     if (updater) updater->setProgress(100); // the rest is only processing, not loading
 
     setModified( false );
     emit changed();
     return true;
 }
 
 QDomDocument MainDocument::saveXML()
 {
     debugPlan;
     QDomDocument document( "plan" );
 
     document.appendChild( document.createProcessingInstruction(
                               "xml",
                               "version=\"1.0\" encoding=\"UTF-8\"" ) );
 
     QDomElement doc = document.createElement( "plan" );
     doc.setAttribute( "editor", "Plan" );
     doc.setAttribute( "mime", "application/x-vnd.kde.plan" );
     doc.setAttribute( "version", PLAN_FILE_SYNTAX_VERSION );
     document.appendChild( doc );
 
     // Save the project
     m_project->save( doc );
 
     return document;
 }
 
 QDomDocument MainDocument::saveWorkPackageXML( const Node *node, long id, Resource *resource )
 {
     debugPlan;
     QDomDocument document( "plan" );
 
     document.appendChild( document.createProcessingInstruction(
                 "xml",
     "version=\"1.0\" encoding=\"UTF-8\"" ) );
 
     QDomElement doc = document.createElement( "planwork" );
     doc.setAttribute( "editor", "Plan" );
     doc.setAttribute( "mime", "application/x-vnd.kde.plan.work" );
     doc.setAttribute( "version", PLANWORK_FILE_SYNTAX_VERSION );
     doc.setAttribute( "plan-version", PLAN_FILE_SYNTAX_VERSION );
     document.appendChild( doc );
 
     // Work package info
     QDomElement wp = document.createElement( "workpackage" );
     if ( resource ) {
         wp.setAttribute( "owner", resource->name() );
         wp.setAttribute( "owner-id", resource->id() );
     }
     wp.setAttribute( "time-tag", QDateTime::currentDateTime().toString( Qt::ISODate ) );
     doc.appendChild( wp );
 
     // Save the project
     m_project->saveWorkPackageXML( doc, node, id );
 
     return document;
 }
 
 bool MainDocument::saveWorkPackageToStream( QIODevice *dev, const Node *node, long id, Resource *resource )
 {
     QDomDocument doc = saveWorkPackageXML( node, id, resource );
     // Save to buffer
     QByteArray s = doc.toByteArray(); // utf8 already
     dev->open( QIODevice::WriteOnly );
     int nwritten = dev->write( s.data(), s.size() );
     if ( nwritten != (int)s.size() ) {
         warnPlan<<"wrote:"<<nwritten<<"- expected:"<< s.size();
     }
     return nwritten == (int)s.size();
 }
 
 bool MainDocument::saveWorkPackageFormat( const QString &file, const Node *node, long id, Resource *resource  )
 {
     debugPlan <<"Saving to store";
 
     KoStore::Backend backend = KoStore::Zip;
 #ifdef QCA2
 /*    if ( d->m_specialOutputFlag == SaveEncrypted ) {
         backend = KoStore::Encrypted;
         debugPlan <<"Saving using encrypted backend.";
     }*/
 #endif
 
     QByteArray mimeType = "application/x-vnd.kde.plan.work";
     debugPlan <<"MimeType=" << mimeType;
 
     KoStore *store = KoStore::createStore( file, KoStore::Write, mimeType, backend );
 /*    if ( d->m_specialOutputFlag == SaveEncrypted && !d->m_password.isNull( ) ) {
         store->setPassword( d->m_password );
     }*/
     if ( store->bad() ) {
         setErrorMessage( i18n( "Could not create the workpackage file for saving: %1", file ) ); // more details needed?
         delete store;
         return false;
     }
     // Tell KoStore not to touch the file names
 
 
     if ( ! store->open( "root" ) ) {
         setErrorMessage( i18n( "Not able to write '%1'. Partition full?", QString( "maindoc.xml") ) );
         delete store;
         return false;
     }
     KoStoreDevice dev( store );
     if ( !saveWorkPackageToStream( &dev, node, id, resource ) || !store->close() ) {
         debugPlan <<"saveToStream failed";
         delete store;
         return false;
     }
     node->documents().saveToStore( store );
 
     debugPlan <<"Saving done of url:" << file;
     if ( !store->finalize() ) {
         delete store;
         return false;
     }
     // Success
     delete store;
 
     return true;
 }
 
 bool MainDocument::saveWorkPackageUrl( const QUrl &_url, const Node *node, long id, Resource *resource )
 {
     //debugPlan<<_url;
     QApplication::setOverrideCursor( Qt::WaitCursor );
     emit statusBarMessage( i18n("Saving...") );
     bool ret = false;
     ret = saveWorkPackageFormat( _url.path(), node, id, resource ); // kzip don't handle file://
     QApplication::restoreOverrideCursor();
     emit clearStatusBarMessage();
     return ret;
 }
 
 bool MainDocument::loadWorkPackage( Project &project, const QUrl &url )
 {
     debugPlan<<url;
     if ( ! url.isLocalFile() ) {
         debugPlan<<"TODO: download if url not local";
         return false;
     }
     KoStore *store = KoStore::createStore( url.path(), KoStore::Read, "", KoStore::Auto );
     if ( store->bad() ) {
 //        d->lastErrorMessage = i18n( "Not a valid Calligra file: %1", file );
         debugPlan<<"bad store"<<url.toDisplayString();
         delete store;
 //        QApplication::restoreOverrideCursor();
         return false;
     }
     if ( ! store->open( "root" ) ) { // "old" file format (maindoc.xml)
         // i18n( "File does not have a maindoc.xml: %1", file );
         debugPlan<<"No root"<<url.toDisplayString();
         delete store;
 //        QApplication::restoreOverrideCursor();
         return false;
     }
     Package *package = 0;
     KoXmlDocument doc;
     QString errorMsg; // Error variables for QDomDocument::setContent
     int errorLine, errorColumn;
     bool ok = doc.setContent( store->device(), &errorMsg, &errorLine, &errorColumn );
     if ( ! ok ) {
         errorPlan << "Parsing error in " << url.url() << "! Aborting!" << endl
                 << " In line: " << errorLine << ", column: " << errorColumn << endl
                 << " Error message: " << errorMsg;
         //d->lastErrorMessage = i18n( "Parsing error in %1 at line %2, column %3\nError message: %4",filename  ,errorLine, errorColumn , QCoreApplication::translate("QXml", errorMsg.toUtf8(), 0, QCoreApplication::UnicodeUTF8));
     } else {
         package = loadWorkPackageXML( project, store->device(), doc, url );
         if ( package ) {
             package->url = url;
             m_workpackages.insert( package->timeTag, package );
         } else {
             ok = false;
         }
     }
     store->close();
     //###
     if ( ok && package && package->settings.documents ) {
         ok = extractFiles( store, package );
     }
     delete store;
     if ( ! ok ) {
 //        QApplication::restoreOverrideCursor();
         return false;
     }
     return true;
 }
 
 Package *MainDocument::loadWorkPackageXML( Project &project, QIODevice *, const KoXmlDocument &document, const QUrl &/*url*/ )
 {
     QString value;
     bool ok = true;
     Project *proj = 0;
     Package *package = 0;
     KoXmlElement plan = document.documentElement();
 
     // Check if this is the right app
     value = plan.attribute( "mime", QString() );
     if ( value.isEmpty() ) {
         debugPlan << "No mime type specified!";
         setErrorMessage( i18n( "Invalid document. No mimetype specified." ) );
         return 0;
     } else if ( value == "application/x-vnd.kde.kplato.work" ) {
         m_xmlLoader.setMimetype( value );
         m_xmlLoader.setWorkVersion( plan.attribute( "version", "0.0.0" ) );
         proj = new Project( m_config );
         KPlatoXmlLoader loader( m_xmlLoader, proj );
         ok = loader.loadWorkpackage( plan );
         if ( ! ok ) {
             setErrorMessage( loader.errorMessage() );
             delete proj;
             return 0;
         }
         package = loader.package();
         package->timeTag = QDateTime::fromString( loader.timeTag(), Qt::ISODate );
     } else if ( value != "application/x-vnd.kde.plan.work" ) {
         debugPlan << "Unknown mime type " << value;
         setErrorMessage( i18n( "Invalid document. Expected mimetype application/x-vnd.kde.plan.work, got %1", value ) );
         return 0;
     } else {
         QString syntaxVersion = plan.attribute( "version", "0.0.0" );
         m_xmlLoader.setWorkVersion( syntaxVersion );
         if ( syntaxVersion > PLANWORK_FILE_SYNTAX_VERSION ) {
             KMessageBox::ButtonCode ret = KMessageBox::warningContinueCancel(
                     0, i18n( "This document was created with a newer version of PlanWork (syntax version: %1)\n"
                     "Opening it in this version of PlanWork will lose some information.", syntaxVersion ),
                     i18n( "File-Format Mismatch" ), KGuiItem( i18n( "Continue" ) ) );
             if ( ret == KMessageBox::Cancel ) {
                 setErrorMessage( "USER_CANCELED" );
                 return 0;
             }
         }
         m_xmlLoader.setVersion( plan.attribute( "plan-version", PLAN_FILE_SYNTAX_VERSION ) );
         m_xmlLoader.startLoad();
         proj = new Project();
         package = new Package();
         package->project = proj;
         KoXmlNode n = plan.firstChild();
         for ( ; ! n.isNull(); n = n.nextSibling() ) {
             if ( ! n.isElement() ) {
                 continue;
             }
             KoXmlElement e = n.toElement();
             if ( e.tagName() == "project" ) {
                 m_xmlLoader.setProject( proj );
                 ok = proj->load( e, m_xmlLoader );
                 if ( ! ok ) {
                     m_xmlLoader.addMsg( XMLLoaderObject::Errors, "Loading of work package failed" );
                     //TODO add some ui here
                 }
             } else if ( e.tagName() == "workpackage" ) {
                 package->timeTag = QDateTime::fromString( e.attribute( "time-tag" ), Qt::ISODate );
                 package->ownerId = e.attribute( "owner-id" );
                 package->ownerName = e.attribute( "owner" );
                 debugPlan<<"workpackage:"<<package->timeTag<<package->ownerId<<package->ownerName;
                 KoXmlElement elem;
                 forEachElement( elem, e ) {
                     if ( elem.tagName() != "settings" ) {
                         continue;
                     }
                     package->settings.usedEffort = (bool)elem.attribute( "used-effort" ).toInt();
                     package->settings.progress = (bool)elem.attribute( "progress" ).toInt();
                     package->settings.documents = (bool)elem.attribute( "documents" ).toInt();
                 }
             }
         }
         if ( proj->numChildren() > 0 ) {
             package->task = static_cast<Task*>( proj->childNode( 0 ) );
             package->toTask = qobject_cast<Task*>( m_project->findNode( package->task->id() ) );
             WorkPackage &wp = package->task->workPackage();
             if ( wp.ownerId().isEmpty() ) {
                 wp.setOwnerId( package->ownerId );
                 wp.setOwnerName( package->ownerName );
             }
             debugPlan<<"Task set:"<<package->task->name();
         }
         m_xmlLoader.stopLoad();
     }
     if ( ok && proj->id() == project.id() && proj->childNode( 0 ) ) {
         ok = project.nodeDict().contains( proj->childNode( 0 )->id() );
         if ( ok && m_mergedPackages.contains( package->timeTag ) ) {
             ok = false; // already merged
         }
         if ( ok && package->timeTag.isValid() && ! m_mergedPackages.contains( package->timeTag ) ) {
             m_mergedPackages[ package->timeTag ] = proj; // register this for next time
         }
         if ( ok && ! package->timeTag.isValid() ) {
             warnPlan<<"Work package is not time tagged:"<<proj->childNode( 0 )->name()<<package->url;
             ok = false;
         }
     }
     if ( ! ok ) {
         delete proj;
         delete package;
         return 0;
     }
     Q_ASSERT( package );
     return package;
 }
 
 bool MainDocument::extractFiles( KoStore *store, Package *package )
 {
     if ( package->task == 0 ) {
         errorPlan<<"No task!";
         return false;
     }
     foreach ( Document *doc, package->task->documents().documents() ) {
         if ( ! doc->isValid() || doc->type() != Document::Type_Product || doc->sendAs() != Document::SendAs_Copy ) {
             continue;
         }
         if ( ! extractFile( store, package, doc ) ) {
             return false;
         }
     }
     return true;
 }
 
 bool MainDocument::extractFile( KoStore *store, Package *package, const Document *doc )
 {
     QTemporaryFile tmpfile;
     if ( ! tmpfile.open() ) {
         errorPlan<<"Failed to open temporary file";
         return false;
     }
     if ( ! store->extractFile( doc->url().fileName(), tmpfile.fileName() ) ) {
         errorPlan<<"Failed to extract file:"<<doc->url().fileName()<<"to:"<<tmpfile.fileName();
         return false;
     }
     package->documents.insert( tmpfile.fileName(), doc->url() );
     tmpfile.setAutoRemove( false );
     debugPlan<<"extracted:"<<doc->url().fileName()<<"->"<<tmpfile.fileName();
     return true;
 }
 
 void MainDocument::autoCheckForWorkPackages()
 {
     if ( m_config.checkForWorkPackages() ) {
         checkForWorkPackages( true );
     }
     QTimer::singleShot ( 10000, this, SLOT(autoCheckForWorkPackages()) );
 }
 
 void MainDocument::checkForWorkPackages( bool keep )
 {
     if ( m_checkingForWorkPackages || m_config.retrieveUrl().isEmpty() || m_project == 0 || m_project->numChildren() == 0 ) {
         return;
     }
     m_checkingForWorkPackages = true;
     if ( ! keep ) {
         qDeleteAll( m_mergedPackages );
         m_mergedPackages.clear();
     }
     QDir dir( m_config.retrieveUrl().path(), "*.planwork" );
     m_infoList = dir.entryInfoList( QDir::Files | QDir::Readable, QDir::Time );
     checkForWorkPackage();
     return;
 }
 
 void MainDocument::checkForWorkPackage()
 {
     if ( ! m_infoList.isEmpty() ) {
         loadWorkPackage( *m_project, QUrl::fromLocalFile( m_infoList.takeLast().absoluteFilePath() ) );
         if ( ! m_infoList.isEmpty() ) {
             QTimer::singleShot ( 0, this, SLOT(checkForWorkPackage()) );
             return;
         }
         // all files read
         // remove other projects
         QMutableMapIterator<QDateTime, Package*> it( m_workpackages );
         while ( it.hasNext() ) {
             it.next();
             Package *package = it.value();
             if ( package->project->id() != m_project->id() ) {
                 delete package->project;
                 delete package;
                 it.remove();
             }
         }
         // Merge our workpackages
         if ( ! m_workpackages.isEmpty() ) {
             WorkPackageMergeDialog *dlg = new WorkPackageMergeDialog( i18n( "New work packages detected. Merge data with existing tasks?" ), m_workpackages );
             connect(dlg, SIGNAL(finished(int)), SLOT(workPackageMergeDialogFinished(int)));
             dlg->show();
             dlg->raise();
             dlg->activateWindow();
         }
     }
 }
 
 void MainDocument::workPackageMergeDialogFinished( int result )
 {
     WorkPackageMergeDialog *dlg = qobject_cast<WorkPackageMergeDialog*>( sender() );
     if ( dlg == 0 ) {
         return;
     }
     if ( result == KoDialog::Yes ) {
         // merge the oldest first
         foreach( int i, dlg->checkedList() ) {
             mergeWorkPackage( m_workpackages.values().at( i ) );
         }
         // 'Yes' was hit so terminate all packages
         foreach( const Package *p, m_workpackages.values() ) {
             terminateWorkPackage( p );
         }
     }
     qDeleteAll( m_workpackages );
     m_workpackages.clear();
     m_checkingForWorkPackages = false;
     dlg->deleteLater();
 }
 
 void MainDocument::mergeWorkPackages()
 {
     foreach ( Package *package, m_workpackages ) {
         mergeWorkPackage( package );
     }
 }
 
 void MainDocument::terminateWorkPackage( const Package *package )
 {
     QFile file( package->url.path() );
     if ( ! file.exists() ) {
         return;
     }
     if ( KPlatoSettings::deleteFile() || KPlatoSettings::saveUrl().isEmpty() ) {
         file.remove();
     } else if ( KPlatoSettings::saveFile() && ! KPlatoSettings::saveUrl().isEmpty() ) {
         QDir dir( KPlatoSettings::saveUrl().path() );
         if ( ! dir.exists() ) {
             if ( ! dir.mkpath( dir.path() ) ) {
                 //TODO message
                 debugPlan<<"Could not create directory:"<<dir.path();
                 return;
             }
         }
         QFileInfo from( file );
         QString name = KPlatoSettings::saveUrl().path() + '/' + from.fileName();
         if ( file.rename( name ) ) {
             return;
         }
         name = KPlatoSettings::saveUrl().path() + '/';
         name += from.completeBaseName() + "-%1";
         if ( ! from.suffix().isEmpty() ) {
             name += '.' + from.suffix();
         }
         int i = 0;
         bool ok = false;
         while ( ! ok && i < 1000 ) {
             ++i;
             ok = QFile::rename( file.fileName(), name.arg( i ) );
         }
         if ( ! ok ) {
             //TODO message
             debugPlan<<"terminateWorkPackage: Failed to save"<<file.fileName();
         }
     }
 }
 
 void MainDocument::mergeWorkPackage( const Package *package )
 {
     const Project &proj = *(package->project);
     if ( proj.id() == m_project->id() && proj.childNode( 0 ) ) {
         const Task *from = package->task;
         Task *to = package->toTask;
         if ( to && from ) {
             mergeWorkPackage( to, from, package );
         }
     }
 }
 
 void MainDocument::mergeWorkPackage( Task *to, const Task *from, const Package *package )
 {
     Resource *resource = m_project->findResource( package->ownerId );
     if ( resource == 0 ) {
         KMessageBox::error( 0, i18n( "The package owner '%1' is not a resource in this project. You must handle this manually.", package->ownerName ) );
         return;
     }
 
     MacroCommand *cmd = new MacroCommand( kundo2_noi18n("Merge workpackage") );
     Completion &org = to->completion();
     const Completion &curr = from->completion();
 
     if ( package->settings.progress ) {
         if ( org.isStarted() != curr.isStarted() ) {
             cmd->addCommand( new ModifyCompletionStartedCmd(org, curr.isStarted() ) );
         }
         if ( org.isFinished() != curr.isFinished() ) {
             cmd->addCommand( new ModifyCompletionFinishedCmd( org, curr.isFinished() ) );
         }
         if ( org.startTime() != curr.startTime() ) {
             cmd->addCommand( new ModifyCompletionStartTimeCmd( org, curr.startTime() ) );
         }
         if ( org.finishTime() != curr.finishTime() ) {
             cmd->addCommand( new ModifyCompletionFinishTimeCmd( org, curr.finishTime() ) );
         }
         // TODO: review how/if to merge data from different resources
         // remove entries
         foreach ( const QDate &d, org.entries().keys() ) {
             if ( ! curr.entries().contains( d ) ) {
                 debugPlan<<"remove entry "<<d;
                 cmd->addCommand( new RemoveCompletionEntryCmd( org, d ) );
             }
         }
         // add new entries / modify existing
         foreach ( const QDate &d, curr.entries().keys() ) {
             if ( org.entries().contains( d ) && curr.entry( d ) == org.entry( d ) ) {
                 continue;
             }
             Completion::Entry *e = new Completion::Entry( *( curr.entry( d ) ) );
             cmd->addCommand( new ModifyCompletionEntryCmd( org, d, e ) );
         }
     }
     if ( package->settings.usedEffort ) {
         Completion::UsedEffort *ue = new Completion::UsedEffort();
         Completion::Entry prev;
         Completion::EntryList::ConstIterator entriesIt = curr.entries().constBegin();
         const Completion::EntryList::ConstIterator entriesEnd = curr.entries().constEnd();
         for (; entriesIt != entriesEnd; ++entriesIt) {
             const QDate &d = entriesIt.key();
             const Completion::Entry &e = *entriesIt.value();
             // set used effort from date entry and remove used effort from date entry
             Completion::UsedEffort::ActualEffort effort( e.totalPerformed - prev.totalPerformed );
             ue->setEffort( d, effort );
             prev = e;
         }
         cmd->addCommand( new AddCompletionUsedEffortCmd( org, resource, ue ) );
     }
     bool docsaved = false;
     if ( package->settings.documents ) {
         //TODO: handle remote files
         QMap<QString, QUrl>::const_iterator it = package->documents.constBegin();
         QMap<QString, QUrl>::const_iterator end = package->documents.constEnd();
         for ( ; it != end; ++it ) {
             const QUrl src = QUrl::fromLocalFile(it.key());
             KIO::CopyJob *job = KIO::move( src, it.value(), KIO::Overwrite );
             if ( job->exec() ) {
                 docsaved = true;
                 //TODO: async
                 debugPlan<<"Moved file:"<<src<<it.value();
             }
         }
     }
     if ( ! docsaved && cmd->isEmpty() ) {
         KMessageBox::information( 0, i18n( "Nothing to save from this package" ) );
     }
     // add a copy to our tasks list of transmitted packages
     WorkPackage *wp = new WorkPackage( from->workPackage() );
     wp->setParentTask( to );
     if ( ! wp->transmitionTime().isValid() ) {
         wp->setTransmitionTime( package->timeTag );
     }
     wp->setTransmitionStatus( WorkPackage::TS_Receive );
     cmd->addCommand( new WorkPackageAddCmd( m_project, to, wp ) );
     addCommand( cmd );
 }
 
 void MainDocument::paintContent( QPainter &, const QRect &)
 {
     // Don't embed this app!!!
 }
 
 void MainDocument::slotViewDestroyed()
 {
 }
 
 void MainDocument::setLoadingTemplate(bool loading)
 {
     m_loadingTemplate = loading;
 }
 
 void MainDocument::setLoadingSharedResourcesTemplate(bool loading)
 {
     m_loadingSharedResourcesTemplate = loading;
 }
 
 bool MainDocument::completeLoading( KoStore *store )
 {
     // If we get here the new project is loaded and set
     if (m_loadingSharedProject) {
         // this file is loaded by another project
         // to read resource appointments,
         // so we must not load any extra stuff
         return true;
     }
     if ( m_loadingTemplate ) {
         //debugPlan<<"Loading template, generate unique ids";
         m_project->generateUniqueIds();
         m_project->setConstraintStartTime( QDateTime(QDate::currentDate(), QTime(0, 0, 0), Qt::LocalTime) );
         m_project->setConstraintEndTime( m_project->constraintStartTime().addYears( 2 ) );
         m_project->locale()->setCurrencyLocale(QLocale::AnyLanguage, QLocale::AnyCountry);
         m_project->locale()->setCurrencySymbol(QString());
     } else if ( isImporting() ) {
         // NOTE: I don't think this is a good idea.
         // Let the filter generate ids for non-plan files.
         // If the user wants to create a new project from an old one,
         // he should use Tools -> Insert Project File
 
         //m_project->generateUniqueNodeIds();
     }
     if (m_loadingSharedResourcesTemplate && m_project->calendarCount() > 0) {
         Calendar *c = m_project->calendarAt(0);
         c->setTimeZone(QTimeZone::systemTimeZone());
     }
     if (m_project->useSharedResources() && !m_project->sharedResourcesFile().isEmpty()) {
         QUrl url = QUrl::fromLocalFile(m_project->sharedResourcesFile());
         if (url.isValid()) {
             insertResourcesFile(url, m_project->loadProjectsAtStartup() ? m_project->sharedProjectsUrl() : QUrl());
         }
     }
     if ( store == 0 ) {
         // can happen if loading a template
         debugPlan<<"No store";
         return true; // continue anyway
     }
     delete m_context;
     m_context = new Context();
     KoXmlDocument doc;
     if ( loadAndParse( store, "context.xml", doc ) ) {
         store->close();
         m_context->load( doc );
     } else warnPlan<<"No context";
     return true;
 }
 
 // TODO:
 // Due to splitting of KoDocument into a document and a part,
 // we simmulate the old behaviour by registering all views in the document.
 // Find a better solution!
 void MainDocument::registerView( View* view )
 {
     if ( view && ! m_views.contains( view ) ) {
         m_views << QPointer<View>( view );
     }
 }
 
 bool MainDocument::completeSaving( KoStore *store )
 {
     foreach ( View *view, m_views ) {
         if ( view ) {
             if ( store->open( "context.xml" ) ) {
                 if ( m_context == 0 ) m_context = new Context();
                 QDomDocument doc = m_context->save( view );
 
                 KoStoreDevice dev( store );
                 QByteArray s = doc.toByteArray(); // this is already Utf8!
                 (void)dev.write( s.data(), s.size() );
                 (void)store->close();
 
                 m_viewlistModified = false;
                 emit viewlistModified( false );
             }
             break;
         }
     }
     return true;
 }
 
 bool MainDocument::loadAndParse(KoStore *store, const QString &filename, KoXmlDocument &doc)
 {
     //debugPlan << "oldLoadAndParse: Trying to open " << filename;
 
     if (!store->open(filename))
     {
         warnPlan << "Entry " << filename << " not found!";
 //        d->lastErrorMessage = i18n( "Could not find %1",filename );
         return false;
     }
     // Error variables for QDomDocument::setContent
     QString errorMsg;
     int errorLine, errorColumn;
     bool ok = doc.setContent( store->device(), &errorMsg, &errorLine, &errorColumn );
     if ( !ok )
     {
         errorPlan << "Parsing error in " << filename << "! Aborting!" << endl
             << " In line: " << errorLine << ", column: " << errorColumn << endl
             << " Error message: " << errorMsg;
 /*        d->lastErrorMessage = i18n( "Parsing error in %1 at line %2, column %3\nError message: %4"
                               ,filename  ,errorLine, errorColumn ,
                               QCoreApplication::translate("QXml", errorMsg.toUtf8(), 0,
                                   QCoreApplication::UnicodeUTF8));*/
         store->close();
         return false;
     }
     debugPlan << "File " << filename << " loaded and parsed";
     return true;
 }
 
 void MainDocument::insertFile( const QUrl &url, Node *parent, Node *after )
 {
     Part *part = new Part( this );
     MainDocument *doc = new MainDocument( part );
     part->setDocument( doc );
     doc->disconnect(); // doc shall not handle feedback from openUrl()
     doc->setAutoSave( 0 ); //disable
     doc->m_insertFileInfo.url = url;
     doc->m_insertFileInfo.parent = parent;
     doc->m_insertFileInfo.after = after;
     connect(doc, SIGNAL(completed()), SLOT(insertFileCompleted()));
     connect(doc, SIGNAL(canceled(QString)), SLOT(insertFileCancelled(QString)));
 
     doc->openUrl( url );
 }
 
 void MainDocument::insertFileCompleted()
 {
     debugPlan<<sender();
     MainDocument *doc = qobject_cast<MainDocument*>( sender() );
     if ( doc ) {
         Project &p = doc->getProject();
         insertProject( p, doc->m_insertFileInfo.parent, doc->m_insertFileInfo.after );
         doc->documentPart()->deleteLater(); // also deletes document
     } else {
         KMessageBox::error( 0, i18n("Internal error, failed to insert file.") );
     }
 }
 
 void MainDocument::insertResourcesFile(const QUrl &url, const QUrl &projects)
 {
     insertSharedProjects(projects); // prepare for insertion after shared resources
     m_sharedProjectsFiles.removeAll(url); // resource file is not a project
 
     Part *part = new Part( this );
     MainDocument *doc = new MainDocument( part );
     part->setDocument( doc );
     doc->disconnect(); // doc shall not handle feedback from openUrl()
     doc->setAutoSave( 0 ); //disable
     connect(doc, SIGNAL(completed()), SLOT(insertResourcesFileCompleted()));
     connect(doc, SIGNAL(canceled(QString)), SLOT(insertFileCancelled(QString)));
 
     doc->openUrl( url );
 
 }
 
 void MainDocument::insertResourcesFileCompleted()
 {
     debugPlan<<sender();
     MainDocument *doc = qobject_cast<MainDocument*>( sender() );
     if (doc) {
         Project &p = doc->getProject();
         mergeResources(p);
         m_project->setSharedResourcesLoaded(true);
         doc->documentPart()->deleteLater(); // also deletes document
         slotInsertSharedProject(); // insert shared bookings
     } else {
         KMessageBox::error( 0, i18n("Internal error, failed to insert file.") );
     }
 }
 
 void MainDocument::insertFileCancelled( const QString &error )
 {
     debugPlan<<sender()<<"error="<<error;
     if ( ! error.isEmpty() ) {
         KMessageBox::error( 0, error );
     }
     MainDocument *doc = qobject_cast<MainDocument*>( sender() );
     if ( doc ) {
         doc->documentPart()->deleteLater(); // also deletes document
     }
 }
 
 void MainDocument::clearResourceAssignments()
 {
     for (Resource *r : m_project->resourceList()) {
         r->clearExternalAppointments();
     }
 }
 
 void MainDocument::loadResourceAssignments(QUrl url)
 {
     insertSharedProjects(url);
     slotInsertSharedProject();
 }
 
 void MainDocument::insertSharedProjects(const QUrl &url)
 {
     m_sharedProjectsFiles.clear();
     QFileInfo fi(url.path());
     if (!fi.exists()) {
         return;
     }
     if (fi.isFile()) {
         m_sharedProjectsFiles = QList<QUrl>() << url;
         debugPlan<<"Get all projects in file:"<<url;
     } else if (fi.isDir()) {
         // Get all plan files in this directory
         debugPlan<<"Get all projects in dir:"<<url;
         QDir dir = fi.dir();
         for (const QString &f : dir.entryList(QStringList()<<"*.plan")) {
             QString path = dir.canonicalPath();
             if (path.isEmpty()) {
                 continue;
             }
             path += '/' + f;
             QUrl u(path);
             u.setScheme("file");
             m_sharedProjectsFiles << u;
         }
     } else {
         warnPlan<<"Unknown url:"<<url<<url.path()<<url.fileName();
         return;
     }
     clearResourceAssignments();
 }
 
 void MainDocument::slotInsertSharedProject()
 {
     debugPlan<<m_sharedProjectsFiles;
     if (m_sharedProjectsFiles.isEmpty()) {
         return;
     }
     Part *part = new Part( this );
     MainDocument *doc = new MainDocument( part );
     part->setDocument( doc );
     doc->disconnect(); // doc shall not handle feedback from openUrl()
     doc->setAutoSave( 0 ); //disable
     doc->m_loadingSharedProject = true;
     connect(doc, SIGNAL(completed()), SLOT(insertSharedProjectCompleted()));
     connect(doc, SIGNAL(canceled(QString)), SLOT(insertSharedProjectCancelled(QString)));
 
     doc->openUrl(m_sharedProjectsFiles.takeFirst());
 }
 
 void MainDocument::insertSharedProjectCompleted()
 {
     debugPlan<<sender();
     MainDocument *doc = qobject_cast<MainDocument*>( sender() );
     if (doc) {
         Project &p = doc->getProject();
         debugPlan<<m_project->id()<<"Loaded project:"<<p.id()<<p.name();
         if (p.id() != m_project->id() && p.isScheduled(ANYSCHEDULED)) {
             // FIXME: improve!
             // find a suitable schedule
             ScheduleManager *sm = 0;
             for (ScheduleManager *m : p.allScheduleManagers()) {
                 if (m->isBaselined()) {
                     sm = m;
                     break;
                 }
                 if (m->isScheduled()) {
                     sm = m; // take the last one, more likely to be subschedule
                 }
             }
             if (sm) {
                 for (Resource *r : p.resourceList()) {
                     Resource *res = m_project->resource(r->id());
                     if (res && res->isShared()) {
                         for (const Appointment *a : r->appointments(sm->scheduleId())) {
                             Appointment *app = new Appointment(*a);
                             app->setAuxcilliaryInfo(p.name());
                             res->addExternalAppointment(p.id(), app);
                             debugPlan<<res->name()<<"added:"<<app->auxcilliaryInfo()<<app;
                         }
                     }
                 }
             }
         }
         doc->documentPart()->deleteLater(); // also deletes document
         emit insertSharedProject(); // do next file
     } else {
         KMessageBox::error( 0, i18n("Internal error, failed to insert file.") );
     }
 }
 
 void MainDocument::insertSharedProjectCancelled( const QString &error )
 {
     debugPlan<<sender()<<"error="<<error;
     if ( ! error.isEmpty() ) {
         KMessageBox::error( 0, error );
     }
     MainDocument *doc = qobject_cast<MainDocument*>( sender() );
     if ( doc ) {
         doc->documentPart()->deleteLater(); // also deletes document
     }
 }
 
 bool MainDocument::insertProject( Project &project, Node *parent, Node *after )
 {
     debugPlan<<&project;
     // make sure node ids in new project is unique also in old project
     QList<QString> existingIds = m_project->nodeDict().keys();
     foreach ( Node *n, project.allNodes() ) {
         QString oldid = n->id();
         n->setId( project.uniqueNodeId( existingIds ) );
         project.removeId( oldid ); // remove old id
         project.registerNodeId( n ); // register new id
     }
     MacroCommand *m = new InsertProjectCmd( project, parent==0?m_project:parent, after, kundo2_i18n( "Insert project" ) );
     if ( m->isEmpty() ) {
         delete m;
     } else {
         addCommand( m );
     }
     return true;
 }
 
 // check if calendar 'c' has children that will not be removed (normally 'Local' calendars)
 bool canRemoveCalendar(const Calendar *c, const QList<Calendar*> &lst)
 {
     for (Calendar *cc : c->calendars()) {
         if (!lst.contains(cc)) {
             return false;
         }
         if (!canRemoveCalendar(cc, lst)) {
             return false;
         }
     }
     return true;
 }
 
 // sort parent calendars before children
 QList<Calendar*> sortedRemoveCalendars(Project &shared, const QList<Calendar*> &lst) {
     QList<Calendar*> result;
     for (Calendar *c : lst) {
         if (c->isShared() && !shared.calendar(c->id())) {
             result << c;
         }
         result += sortedRemoveCalendars(shared, c->calendars());
     }
     return result;
 }
 
 bool MainDocument::mergeResources(Project &project)
 {
     debugPlan<<&project;
     // Just in case, remove stuff not related to resources
     for (Node *n :  project.childNodeIterator()) {
         delete n;
     }
     for (ScheduleManager *m :  project.allScheduleManagers()) {
         delete m;
     }
     // Mark all resources / groups as shared
     for (ResourceGroup *g : project.resourceGroups()) {
         g->setShared(true);
     }
     for (Resource *r : project.resourceList()) {
         r->setShared(true);
     }
     // Mark all calendars shared
     for (Calendar *c : project.allCalendars()) {
         c->setShared(true);
     }
     // check if any shared stuff has been removed
     QList<ResourceGroup*> removedGroups;
     QList<Resource*> removedResources;
     QList<Calendar*> removedCalendars;
     QStringList removed;
     for (ResourceGroup *g : m_project->resourceGroups()) {
         if (g->isShared() && !project.findResourceGroup(g->id())) {
             removedGroups << g;
             removed << i18n("Group: %1", g->name());
         }
     }
     for (Resource *r : m_project->resourceList()) {
         if (r->isShared() && !project.findResource(r->id())) {
             removedResources << r;
             removed << i18n("Resource: %1", r->name());
         }
     }
     removedCalendars = sortedRemoveCalendars(project, m_project->calendars());
     for (Calendar *c : removedCalendars) {
         removed << i18n("Calendar: %1", c->name());
     }
     if (!removed.isEmpty()) {
         KMessageBox::ButtonCode result = KMessageBox::warningYesNoCancelList(
                     0,
                     i18n("Shared resources has been removed from the shared resources file."
                          "\nSelect how they shall be treated in this project."),
                     removed,
                     xi18nc("@title:window", "Shared resources"),
                     KStandardGuiItem::remove(),
                     KGuiItem(i18n("Convert")),
                     KGuiItem(i18n("Keep"))
                     );
         switch (result) {
         case KMessageBox::Yes: // Remove
             for (Resource *r : removedResources) {
                 RemoveResourceCmd cmd(r->parentGroup(), r);
                 cmd.redo();
             }
             for (ResourceGroup *g : removedGroups) {
                 if (g->resources().isEmpty()) {
                     RemoveResourceGroupCmd cmd(m_project, g);
                     cmd.redo();
                 } else {
                     // we may have put local resource(s) in this group
                     // so we need to keep it
                     g->setShared(false);
                     m_project->removeResourceGroupId(g->id());
                     g->setId(m_project->uniqueResourceGroupId());
                     m_project->insertResourceGroupId(g->id(), g);
                 }
             }
             for (Calendar *c : removedCalendars) {
                 CalendarRemoveCmd cmd(m_project, c);
                 cmd.redo();
             }
             break;
         case KMessageBox::No: // Convert
             for (Resource *r : removedResources) {
                 r->setShared(false);
                 m_project->removeResourceId(r->id());
                 r->setId(m_project->uniqueResourceId());
                 m_project->insertResourceId(r->id(), r);
             }
             for (ResourceGroup *g : removedGroups) {
                 g->setShared(false);
                 m_project->removeResourceGroupId(g->id());
                 g->setId(m_project->uniqueResourceGroupId());
                 m_project->insertResourceGroupId(g->id(), g);
             }
             for (Calendar *c : removedCalendars) {
                 c->setShared(false);
                 m_project->removeCalendarId(c->id());
                 c->setId(m_project->uniqueCalendarId());
                 m_project->insertCalendarId(c->id(), c);
             }
             break;
         case KMessageBox::Cancel: // Keep
             break;
         default:
             break;
         }
     }
     // update values of already existsing objects
     for (ResourceGroup *g : project.resourceGroups()) {
         ResourceGroup *group = m_project->findResourceGroup(g->id());
         if (group) {
             group->setName(g->name());
             group->setType(g->type());
         }
     }
     for (Resource *r : project.resourceList()) {
         Resource *resource = m_project->findResource(r->id());
         if (resource) {
             resource->setName(r->name());
             resource->setInitials(r->initials());
             resource->setEmail(r->email());
             resource->setType(r->type());
             resource->setAutoAllocate(r->autoAllocate());
             resource->setAvailableFrom(r->availableFrom());
             resource->setAvailableUntil(r->availableUntil());
             resource->setUnits(r->units());
             resource->setNormalRate(r->normalRate());
             resource->setOvertimeRate(r->overtimeRate());
 
             QString id = r->calendar(true) ? r->calendar(true)->id() : QString();
             resource->setCalendar(m_project->findCalendar(id));
 
             id = r->account() ? r->account()->name() : QString();
             resource->setAccount(m_project->accounts().findAccount(id));
 
             resource->setRequiredIds(r->requiredIds());
 
             resource->setTeamMemberIds(r->teamMemberIds());
         }
     }
     for (Calendar *c : project.allCalendars()) {
         Calendar *calendar = m_project->findCalendar(c->id());
         if (calendar) {
             *calendar = *c;
         }
     }
     // insert new objects
     InsertProjectCmd cmd(project, m_project, 0);
     cmd.execute();
     return true;
 }
 
 void MainDocument::insertViewListItem( View */*view*/, const ViewListItem *item, const ViewListItem *parent, int index )
 {
     // FIXME callers should take care that they now get a signal even if originating from themselves
     emit viewListItemAdded(item, parent, index);
     setModified( true );
     m_viewlistModified = true;
 }
 
 void MainDocument::removeViewListItem( View */*view*/, const ViewListItem *item )
 {
     // FIXME callers should take care that they now get a signal even if originating from themselves
     emit viewListItemRemoved(item);
     setModified( true );
     m_viewlistModified = true;
 }
 
 void MainDocument::setModified( bool mod )
 {
     debugPlan<<mod<<m_viewlistModified;
     KoDocument::setModified( mod || m_viewlistModified ); // Must always call to activate autosave
 }
 
 void MainDocument::viewlistModified()
 {
     if ( ! m_viewlistModified ) {
         m_viewlistModified = true;
     }
     setModified( true );  // Must always call to activate autosave
 }
 
 // called after user has created a new project in welcome view
 void MainDocument::slotProjectCreated()
 {
     Calendar *week = 0;
 
     if (KPlatoSettings::generateWeek()) {
         bool always = KPlatoSettings::generateWeekChoice() == KPlatoSettings::EnumGenerateWeekChoice::Always;
         bool ifnone = KPlatoSettings::generateWeekChoice() == KPlatoSettings::EnumGenerateWeekChoice::NoneExists;
         if (always || (ifnone && m_project->calendarCount() == 0)) {
             // create a calendar
             week = new Calendar(i18nc("Base calendar name", "Base"));
             m_project->addCalendar(week);
 
             CalendarDay vd(CalendarDay::NonWorking);
 
             for (int i = Qt::Monday; i <= Qt::Sunday; ++i) {
                 if (m_config.isWorkingday(i)) {
                     CalendarDay wd(CalendarDay::Working);
                     TimeInterval ti(m_config.dayStartTime(i), m_config.dayLength(i));
                     wd.addInterval(ti);
                     week->setWeekday(i, wd);
                 } else {
                     week->setWeekday(i, vd);
                 }
             }
         }
     }
 #ifdef HAVE_KHOLIDAYS
     if (KPlatoSettings::generateHolidays()) {
         bool inweek = week != 0 && KPlatoSettings::generateHolidaysChoice() == KPlatoSettings::EnumGenerateHolidaysChoice::InWeekCalendar;
         bool subcalendar = week != 0 && KPlatoSettings::generateHolidaysChoice() == KPlatoSettings::EnumGenerateHolidaysChoice::AsSubCalendar;
         bool separate = week == 0 || KPlatoSettings::generateHolidaysChoice() == KPlatoSettings::EnumGenerateHolidaysChoice::AsSeparateCalendar;
 
         Calendar *c = 0;
         if (inweek) {
             c = week;
             qDebug()<<Q_FUNC_INFO<<"in week";
         } else if (subcalendar) {
             c = new Calendar(i18n("Holidays"));
             m_project->addCalendar(c, week);
             qDebug()<<Q_FUNC_INFO<<"subcalendar";
         } else if (separate) {
             c = new Calendar(i18n("Holidays"));
             m_project->addCalendar(c);
             qDebug()<<Q_FUNC_INFO<<"separate";
         } else {
             Q_ASSERT(false); // something wrong
         }
         qDebug()<<Q_FUNC_INFO<<KPlatoSettings::region();
         if (c == 0) {
             warnPlan<<Q_FUNC_INFO<<"Failed to generate holidays. Bad option:"<<KPlatoSettings::generateHolidaysChoice();
             return;
         }
         c->setHolidayRegion(KPlatoSettings::region());
     }
 #endif
 }
 
 // creates a "new" project from current project (new ids etc)
 void MainDocument::createNewProject()
 {
     setEmpty();
     clearUndoHistory();
     setModified( false );
     resetURL();
     KoDocumentInfo *info = documentInfo();
     info->resetMetaData();
     info->setProperty( "title", "" );
     setTitleModified();
 
     m_project->generateUniqueIds();
     Duration dur = m_project->constraintEndTime() - m_project->constraintStartTime();
     m_project->setConstraintStartTime( QDateTime(QDate::currentDate(), QTime(0, 0, 0), Qt::LocalTime) );
     m_project->setConstraintEndTime( m_project->constraintStartTime() +  dur );
 
     while ( m_project->numScheduleManagers() > 0 ) {
         foreach ( ScheduleManager *sm, m_project->allScheduleManagers() ) {
             if ( sm->childCount() > 0 ) {
                 continue;
             }
             if ( sm->expected() ) {
                 sm->expected()->setDeleted( true );
                 sm->setExpected( 0 );
             }
             m_project->takeScheduleManager( sm );
             delete sm;
         }
     }
     foreach ( Schedule *s, m_project->schedules() ) {
         m_project->takeSchedule( s );
         delete s;
     }
     foreach ( Node *n, m_project->allNodes() ) {
         foreach ( Schedule *s, n->schedules() ) {
             n->takeSchedule( s );
             delete s;
         }
     }
     foreach ( Resource *r, m_project->resourceList() ) {
         foreach ( Schedule *s, r->schedules().values() ) {
             r->takeSchedule( s );
             delete s;
         }
     }
 }
 
+void MainDocument::setIsTaskModule(bool value)
+{
+    m_isTaskModule = value;
+}
+
+bool MainDocument::isTaskModule() const
+{
+    return m_isTaskModule;
+}
 }  //KPlato namespace
diff --git a/plan/kptmaindocument.h b/plan/kptmaindocument.h
index c4f72ce55dc..9725315f130 100644
--- a/plan/kptmaindocument.h
+++ b/plan/kptmaindocument.h
@@ -1,243 +1,248 @@
 /* This file is part of the KDE project
   Copyright (C) 1998, 1999, 2000 Torben Weis <weis@kde.org>
   Copyright (C) 2004 - 2010 Dag Andersen <danders@get2net.dk>
   Copyright (C) 2006 Raphael Langerhorst <raphael.langerhorst@kdemail.net>
   Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KPTMAINDOCUMENT_H
 #define KPTMAINDOCUMENT_H
 
 #include "kplato_export.h"
 
 #include "kpttask.h"
 #include "kptconfig.h"
 #include "kptwbsdefinition.h"
 #include "kptxmlloaderobject.h"
 #include "about/aboutpage.h"
 
 #include "KoDocument.h"
 
 #include <QFileInfo>
 #include <QDomDocument>
 
 
 #define PLAN_MIME_TYPE "application/x-vnd.kde.plan"
 
 /// The main namespace.
 namespace KPlato
 {
 
 class DocumentChild;
 class Project;
 class Context;
 class SchedulerPlugin;
 class ViewListItem;
 class View;
 
 class Package;
 
 class KPLATO_EXPORT MainDocument : public KoDocument
 {
     Q_OBJECT
 
 public:
     explicit MainDocument(KoPart *part);
     ~MainDocument();
 
 
     /// reimplemented from KoDocument
     virtual QByteArray nativeFormatMimeType() const { return PLAN_MIME_TYPE; }
     /// reimplemented from KoDocument
     virtual QByteArray nativeOasisMimeType() const { return ""; }
     /// reimplemented from KoDocument
     virtual QStringList extraNativeMimeTypes() const
     {
         return QStringList() << PLAN_MIME_TYPE;
     }
 
     void setReadWrite( bool rw );
     void configChanged();
 
     virtual void paintContent( QPainter& painter, const QRect& rect);
 
     void setProject( Project *project );
     Project &getProject() { return *m_project; }
     const Project &getProject() const { return * m_project; }
 
     /**
      * Return the set of SupportedSpecialFormats that the kplato wants to
      * offer in the "Save" file dialog.
      * Note: SaveEncrypted is not supported.
      */
     virtual int supportedSpecialFormats() const { return SaveAsDirectoryStore; }
 
     // The load and save functions. Look in the file kplato.dtd for info
     virtual bool loadXML( const KoXmlDocument &document, KoStore *store );
     virtual QDomDocument saveXML();
     /// Save a workpackage file containing @p node with schedule identity @p id, owned by @p resource
     QDomDocument saveWorkPackageXML( const Node *node, long id, Resource *resource = 0 );
 
     bool saveOdf( SavingContext &/*documentContext */) { return false; }
     bool loadOdf( KoOdfReadStore & odfStore );
 
     Config &config() { return m_config; }
     Context *context() const { return m_context; }
 
     WBSDefinition &wbsDefinition() { return m_project->wbsDefinition(); }
 
     const XMLLoaderObject &xmlLoader() const { return m_xmlLoader; }
 
     DocumentChild *createChild( KoDocument *doc, const QRect &geometry = QRect() );
 
     bool saveWorkPackageToStream( QIODevice * dev, const Node *node, long id, Resource *resource = 0 );
     bool saveWorkPackageFormat( const QString &file, const Node *node, long id, Resource *resource = 0 );
     bool saveWorkPackageUrl( const QUrl & _url, const Node *node, long id, Resource *resource = 0  );
     void mergeWorkPackages();
     void mergeWorkPackage( const Package *package );
     void terminateWorkPackage( const Package *package );
 
     /// Load the workpackage from @p url into @p project. Return true if successful, else false.
     bool loadWorkPackage( Project &project, const QUrl &url );
     Package *loadWorkPackageXML( Project& project, QIODevice*, const KoXmlDocument& document, const QUrl& url );
     QMap<QDateTime, Package*> workPackages() const { return m_workpackages; }
 
     void insertFile( const QUrl &url, Node *parent, Node *after = 0 );
     bool insertProject( Project &project, Node *parent, Node *after );
     bool mergeResources(Project &project);
 
     KPlatoAboutPage &aboutPage() { return m_aboutPage; }
 
     bool extractFiles( KoStore *store, Package *package );
     bool extractFile( KoStore *store, Package *package, const Document *doc );
 
     void registerView( View *view );
 
     /// Create a new project from this project
     /// Generates new project id and task ids
     /// Keeps resource- and calendar ids
     void createNewProject();
 
     using KoDocument::setModified;
 public Q_SLOTS:
     void setModified( bool mod );
 
     /// Inserts an item into all other views than @p view
     void insertViewListItem( View *view, const ViewListItem *item, const ViewListItem *parent, int index );
     /// Removes the view list item from all other views than @p view
     void removeViewListItem( View *view, const ViewListItem *item );
     /// View selector has been modified
     void viewlistModified();
     /// Check for workpackages
     /// If @p keep is true, packages that has been refused will not be checked for again
     void checkForWorkPackages( bool keep = false );
 
     void setLoadingTemplate( bool );
     void setLoadingSharedResourcesTemplate( bool );
 
     void insertResourcesFile(const QUrl &url, const QUrl &projects = QUrl());
     void slotProjectCreated();
 
     /// Prepare for insertion of resource assignments of shared resources from the project(s) in @p url
     void insertSharedProjects(const QUrl &url);
 
     /// Clear resource assignments of shared resources
     void clearResourceAssignments();
     /// Load resource assignments of shared resources from the project(s) in @p url
     void loadResourceAssignments(QUrl url);
 
+    void setIsTaskModule(bool value);
+    bool isTaskModule() const;
+
 Q_SIGNALS:
     void changed();
     void workPackageLoaded();
     void viewlistModified( bool );
     void viewListItemAdded(const ViewListItem *item, const ViewListItem *parent, int index);
     void viewListItemRemoved(const ViewListItem *item);
 
     void insertSharedProject();
 
 protected:
     /// Load kplato specific files
     virtual bool completeLoading( KoStore* store );
     /// Save kplato specific files
     virtual bool completeSaving( KoStore* store );
 
     void mergeWorkPackage( Task *to, const Task *from, const Package *package );
 
     // used by insert file
     struct InsertFileInfo {
         QUrl url;
         Node *parent;
         Node *after;
     } m_insertFileInfo;
 
 
 protected Q_SLOTS:
     void slotViewDestroyed();
     void addSchedulerPlugin( const QString&, SchedulerPlugin *plugin );
 
     void autoCheckForWorkPackages();
     void checkForWorkPackage();
 
     void insertFileCompleted();
     void insertResourcesFileCompleted();
     void insertFileCancelled( const QString& );
 
     void slotInsertSharedProject();
     void insertSharedProjectCompleted();
     void insertSharedProjectCancelled( const QString& );
 
     void workPackageMergeDialogFinished( int result );
 
 private:
     bool loadAndParse(KoStore* store, const QString& filename, KoXmlDocument& doc);
 
     void loadSchedulerPlugins();
 
 private:
     Project *m_project;
     QWidget* m_parentWidget;
 
     Config m_config;
     Context *m_context;
 
     XMLLoaderObject m_xmlLoader;
     bool m_loadingTemplate;
     bool m_loadingSharedResourcesTemplate;
 
     QMap<QString, SchedulerPlugin*> m_schedulerPlugins;
     QMap<QDateTime, Package*> m_workpackages;
     QFileInfoList m_infoList;
     QMap<QDateTime, Project*> m_mergedPackages;
 
     KPlatoAboutPage m_aboutPage;
 
     QDomDocument m_reports;
 
     bool m_viewlistModified;
     bool m_checkingForWorkPackages;
 
     QList<QPointer<View> > m_views;
 
     bool m_loadingSharedProject;
     QList<QUrl> m_sharedProjectsFiles;
+
+    bool m_isTaskModule;
 };
 
 
 }  //KPlato namespace
 
 #endif
diff --git a/plan/kptpart.cpp b/plan/kptpart.cpp
index 67e5e5f7080..d392fa32594 100644
--- a/plan/kptpart.cpp
+++ b/plan/kptpart.cpp
@@ -1,188 +1,197 @@
 /* This file is part of the KDE project
    Copyright (C) 2012 C. Boemann <cbo@kogmbh.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "kptpart.h"
 
 #include "kptview.h"
 #include "kptmaindocument.h"
 #include "kptfactory.h"
 #include "welcome/WelcomeView.h"
 #include "kpthtmlview.h"
 #include <kptdebug.h>
 
 #include <KoComponentData.h>
 #include <KoOpenPane.h>
 
 #include <KRecentFilesAction>
 #include <KXMLGUIFactory>
 #include <KConfigGroup>
 #include <KHelpClient>
 #include <KRun>
 
 #include <QStackedWidget>
 
 Part::Part(QObject *parent)
     : KoPart(Factory::global(), parent)
     , startUpWidget(0)
 {
     setTemplatesResourcePath(QLatin1String("calligraplan/templates/"));
 }
 
 Part::~Part()
 {
 }
 
 void Part::setDocument(KPlato::MainDocument *document)
 {
     KoPart::setDocument(document);
     m_document = document;
 }
 
 KoView *Part::createViewInstance(KoDocument *document, QWidget *parent)
 {
     // synchronize view selector
     View *view = dynamic_cast<View*>(views().value(0));
     /*FIXME
     if (view && m_context) {
         QDomDocument doc = m_context->save(view);
         m_context->setContent(doc.toString());
     }*/
     view = new View(this, qobject_cast<MainDocument*>(document), parent);
 //    connect(view, SIGNAL(destroyed()), this, SLOT(slotViewDestroyed()));
 //    connect(document, SIGNAL(viewListItemAdded(const ViewListItem*,const ViewListItem*,int)), view, SLOT(addViewListItem(const ViewListItem*,const ViewListItem*,int)));
 //    connect(document, SIGNAL(viewListItemRemoved(const ViewListItem*)), view, SLOT(removeViewListItem(const ViewListItem*)));
     return view;
 }
 
 KoMainWindow *Part::createMainWindow()
 {
     return new KoMainWindow(PLAN_MIME_TYPE, componentData());
 }
 
 void Part::showStartUpWidget(KoMainWindow *parent, bool alwaysShow)
 {
     Q_UNUSED(alwaysShow);
 
     m_toolbarVisible = parent->factory()->container("mainToolBar", parent)->isVisible();
     if (m_toolbarVisible) {
         parent->factory()->container("mainToolBar", parent)->hide();
     }
 
     if (startUpWidget) {
         startUpWidget->show();
     } else {
         createStarUpWidget(parent);
         parent->setCentralWidget(startUpWidget);
     }
 
     parent->setPartToOpen(this);
 
 }
 
 void Part::openTemplate(const QUrl &url)
 {
     debugPlan<<"Open shared resources template:"<<url;
     m_document->setLoadingTemplate(true);
     m_document->setLoadingSharedResourcesTemplate(url.fileName() == "SharedResources.plant");
     KoPart::openTemplate(url);
     m_document->setLoadingTemplate(false);
 }
 
+void Part::openTaskModule(const QUrl &url)
+{
+    Part *part = new Part(0);
+    MainDocument *doc = new MainDocument(part);
+    part->setDocument(doc);
+    doc->setIsTaskModule(true);
+    mainWindows().first()->openDocument(part, url);
+}
+
 void Part::createStarUpWidget(KoMainWindow *parent)
 {
     startUpWidget = new QStackedWidget(parent);
 
     startUpWidget->addWidget(createWelcomeView(parent));
     startUpWidget->addWidget(createIntroductionView());
 }
 
 void Part::finish()
 {
     mainWindows().first()->setRootDocument(document(), this);
     if (m_toolbarVisible) {
         KoPart::mainWindows().first()->factory()->container("mainToolBar", mainWindows().first())->show();
     }
 }
 
 QWidget *Part::createWelcomeView(KoMainWindow *mw)
 {
     MainDocument *doc = static_cast<MainDocument*>(document());
 
     WelcomeView *v = new WelcomeView(this, doc, startUpWidget);
     v->setProject(&(doc->getProject()));
 
     KSharedConfigPtr configPtr = Factory::global().config();
     KRecentFilesAction recent("x", 0);
     recent.loadEntries(configPtr->group("RecentFiles"));
     v->setRecentFiles(recent.items());
 
     connect(v, SIGNAL(loadSharedResources(const QUrl&, const QUrl&)), doc, SLOT(insertResourcesFile(const QUrl&, const QUrl&)));
     connect(v, SIGNAL(recentProject(const QUrl&)), mw, SLOT(slotFileOpenRecent(const QUrl&)));
     connect(v, SIGNAL(showIntroduction()), this, SLOT(slotShowIntroduction()));
     connect(v, SIGNAL(projectCreated()), doc, SLOT(slotProjectCreated()));
     connect(v, SIGNAL(finished()), this, SLOT(finish()));
 
     connect(v, SIGNAL(openTemplate(QUrl)), this, SLOT(openTemplate(QUrl)));
 
     return v;
 }
 
 void Part::slotShowIntroduction()
 {
     startUpWidget->setCurrentIndex(1);
     slotOpenUrlRequest(static_cast<HtmlView*>(startUpWidget->currentWidget()), QUrl("about:plan/main"));
 }
 
 void Part::slotOpenUrlRequest( HtmlView *v, const QUrl &url )
 {
     debugPlan<<url;
     if ( url.scheme() == QLatin1String("about") ) {
         if ( url.url() == QLatin1String("about:close") ) {
             startUpWidget->setCurrentIndex(0);
             return;
         }
         if ( url.url().startsWith( QLatin1String( "about:plan" ) ) ) {
             MainDocument *doc = static_cast<MainDocument*>(document());
             doc->aboutPage().generatePage( v->htmlPart(), url );
             return;
         }
     }
     if ( url.scheme() == QLatin1String("help") ) {
         KHelpClient::invokeHelp( "", url.fileName() );
         return;
     }
     // try to open the url
     debugPlan<<url<<"is external, discard";
     new KRun( url,  currentMainwindow() );
 }
 
 QWidget *Part::createIntroductionView()
 {
     HtmlView *v = new HtmlView(this, document(), startUpWidget );
     v->htmlPart().setJScriptEnabled(false);
     v->htmlPart().setJavaEnabled(false);
     v->htmlPart().setMetaRefreshEnabled(false);
     v->htmlPart().setPluginsEnabled(false);
 
     slotOpenUrlRequest( v, QUrl( "about:plan/main" ) );
 
     connect( v, SIGNAL(openUrlRequest(HtmlView*,QUrl)), SLOT(slotOpenUrlRequest(HtmlView*,QUrl)) );
 
     return v;
 }
diff --git a/plan/kptpart.h b/plan/kptpart.h
index ac754c679f8..2714142bbe2 100644
--- a/plan/kptpart.h
+++ b/plan/kptpart.h
@@ -1,75 +1,76 @@
 /* This file is part of the KDE project
    Copyright (C) 2012 C. Boemann <cbo@kogmbh.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KPTPART_H
 #define KPTPART_H
 
 #include <KoPart.h>
 
 #include "kplato_export.h"
 
 #include <QPointer>
 
 class KoView;
 class QStackedWidget;
 
 /// The main namespace.
 namespace KPlato
 {
 class MainDocument;
 class HtmlView;
 
 class KPLATO_EXPORT Part : public KoPart
 {
     Q_OBJECT
 
 public:
     explicit Part(QObject *parent);
 
     virtual ~Part();
 
     void setDocument(KPlato::MainDocument *document);
 
     /// reimplemented
     virtual KoView *createViewInstance(KoDocument *document, QWidget *parent);
 
     /// reimplemented
     virtual KoMainWindow *createMainWindow();
 
     virtual void showStartUpWidget(KoMainWindow *parent, bool alwaysShow = false);
 
 protected Q_SLOTS:
     void finish();
     void slotShowIntroduction();
     void slotOpenUrlRequest( HtmlView *v, const QUrl &url );
     virtual void openTemplate( const QUrl& url );
+    void openTaskModule(const QUrl& url);
 
 protected:
     void createStarUpWidget(KoMainWindow *parent);
     QWidget *createWelcomeView(KoMainWindow *parent);
     QWidget *createIntroductionView();
 
 private:
     KPlato::MainDocument *m_document;
     QPointer<QStackedWidget> startUpWidget;
     bool m_toolbarVisible;
 };
 
 }  //KPlato namespace
 #endif
diff --git a/plan/kptview.cpp b/plan/kptview.cpp
index 5e43c3adff1..029c4d96419 100644
--- a/plan/kptview.cpp
+++ b/plan/kptview.cpp
@@ -1,3227 +1,3257 @@
 /* This file is part of the KDE project
   Copyright (C) 1998, 1999, 2000 Torben Weis <weis@kde.org>
   Copyright (C) 2002 - 2011 Dag Andersen <danders@get2net.dk>
   Copyright (C) 2012 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #include "kptview.h"
 
 #include <kmessagebox.h>
 #include <KRecentFilesAction>
 
 #include "KoDocumentInfo.h"
 #include "KoMainWindow.h"
 #include <KoIcon.h>
 #include <KoResourcePaths.h>
 
 #include <QAction>
 #include <QApplication>
 #include <QLabel>
 #include <QString>
 #include <QStringList>
 #include <QStackedWidget>
 #include <QVBoxLayout>
 #include <QPrintDialog>
 #include <QDomDocument>
 #include <QDomElement>
 #include <kundo2command.h>
 #include <QTimer>
 #include <QDockWidget>
 #include <QMenu>
 #include <QTemporaryFile>
 #include <QFileDialog>
 
 #include <kactioncollection.h>
 #include <kactionmenu.h>
 #include <kstandardaction.h>
 #include <ktoolbar.h>
 #include <kconfigdialogmanager.h>
 #include <kxmlguifactory.h>
 #include <ktoggleaction.h>
 #include <kconfigdialog.h>
 #include <ktoolinvocation.h>
 #include <krun.h>
 #include <khelpclient.h>
 
 #include <KoTemplateCreateDia.h>
 #include <KoPart.h>
 #include <KoComponentData.h>
 #include <KoPluginLoader.h>
 
 #include "kptlocale.h"
 #include "kptviewbase.h"
 #include "kptaccountsview.h"
 #include "kptaccountseditor.h"
 #include "kptcalendareditor.h"
 #include "kptfactory.h"
 #include "kptmilestoneprogressdialog.h"
 #include "kpttaskdescriptiondialog.h"
 #include "kptnode.h"
 #include "kptmaindocument.h"
 #include "kptproject.h"
 #include "kptmainprojectdialog.h"
 #include "kpttask.h"
 #include "kptsummarytaskdialog.h"
 #include "kpttaskdialog.h"
 #include "kpttaskprogressdialog.h"
 #include "kptganttview.h"
 #include "kpttaskeditor.h"
 #include "kptdependencyeditor.h"
 #include "kptperteditor.h"
 #include "kptdatetime.h"
 #include "kptcommand.h"
 #include "kptrelation.h"
 #include "kptrelationdialog.h"
 #include "kptresourceappointmentsview.h"
 #include "kptresourceeditor.h"
 #include "kptscheduleeditor.h"
 #include "kptresourcedialog.h"
 #include "kptresource.h"
 #include "kptstandardworktimedialog.h"
 #include "kptwbsdefinitiondialog.h"
 #include "kptresourceassignmentview.h"
 #include "kpttaskstatusview.h"
 #include "kptsplitterview.h"
 #include "kptpertresult.h"
 #include "ConfigProjectPanel.h"
 #include "ConfigWorkVacationPanel.h"
 #include "kpttaskdefaultpanel.h"
 #include "kptworkpackageconfigpanel.h"
 #include "kptcolorsconfigpanel.h"
 #include "kptinsertfiledlg.h"
 #include "kpthtmlview.h"
 #include "about/aboutpage.h"
 #include "kptlocaleconfigmoneydialog.h"
 #include "kptflatproxymodel.h"
 #include "kpttaskstatusmodel.h"
 
 #include "reportsgenerator/ReportsGeneratorView.h"
 
 #ifdef PLAN_USE_KREPORT
 #include "reports/reportview.h"
 #include "reports/reportdata.h"
 #endif
 
 #include "kptviewlistdialog.h"
 #include "kptviewlistdocker.h"
 #include "kptviewlist.h"
 #include "kptschedulesdocker.h"
 #include "kptpart.h"
 #include "kptdebug.h"
 
 #include "calligraplansettings.h"
 #include "kptprintingcontrolprivate.h"
 
 // #include "KPtViewAdaptor.h"
 
 #include <assert.h>
 
 namespace KPlato
 {
 
 //-------------------------------
 ConfigDialog::ConfigDialog(QWidget *parent, const QString& name, KConfigSkeleton *config )
     : KConfigDialog( parent, name, config ),
     m_config( config )
 {
     KConfigDialogManager::changedMap()->insert("KRichTextWidget", SIGNAL(textChanged()) );
 }
 
 bool ConfigDialog::hasChanged()
 {
     QRegExp kcfg( "kcfg_*" );
     foreach ( KRichTextWidget *w, findChildren<KRichTextWidget*>( kcfg ) ) {
         KConfigSkeletonItem *item = m_config->findItem( w->objectName().mid(5) );
         if (  ! item->isEqual( w->toHtml() ) ) {
             return true;
         }
     }
     return false;
 }
 
 void ConfigDialog::updateSettings()
 {
     bool changed = false;
     QRegExp kcfg( "kcfg_*" );
     foreach ( KRichTextWidget *w, findChildren<KRichTextWidget*>( kcfg ) ) {
         KConfigSkeletonItem *item = m_config->findItem( w->objectName().mid(5) );
         if ( ! item ) {
             warnPlan << "The setting '" <<  w->objectName().mid(5)  << "' has disappeared!";
             continue;
         }
         if ( ! item->isEqual( QVariant( w->toHtml() ) ) ) {
             item->setProperty( QVariant( w->toHtml() ) );
             changed = true;
         }
     }
     if ( changed ) {
         m_config->save();
     }
 }
 
 void ConfigDialog::updateWidgets()
 {
     QRegExp kcfg( "kcfg_*" );
     foreach ( KRichTextWidget *w, findChildren<KRichTextWidget*>( kcfg ) ) {
         KConfigSkeletonItem *item = m_config->findItem( w->objectName().mid(5) );
         if ( ! item ) {
             warnPlan << "The setting '" <<  w->objectName().mid(5)  << "' has disappeared!";
             continue;
         }
         if ( ! item->isEqual( QVariant( w->toHtml() ) ) ) {
             w->setHtml( item->property().toString() );
         }
     }
 }
 
 void ConfigDialog::updateWidgetsDefault()
 {
     bool usedefault = m_config->useDefaults( true );
     updateWidgets();
     m_config->useDefaults( usedefault );
 }
 
 bool ConfigDialog::isDefault()
 {
     bool bUseDefaults = m_config->useDefaults(true);
     bool result = !hasChanged();
     m_config->useDefaults(bUseDefaults);
     return result;
 }
 
 //------------------------------------
 View::View(KoPart *part, MainDocument *doc, QWidget *parent)
         : KoView(part, doc, parent),
         m_currentEstimateType( Estimate::Use_Expected ),
         m_scheduleActionGroup( new QActionGroup( this ) ),
         m_trigged( false ),
         m_nextScheduleManager( 0 ),
         m_readWrite( false ),
         m_defaultView(1),
         m_partpart (part)
 {
     //debugPlan;
 
     doc->registerView( this );
 
     setComponentName(Factory::global().componentName(), Factory::global().componentDisplayName());
     if ( !doc->isReadWrite() )
         setXMLFile( "calligraplan_readonly.rc" );
     else
         setXMLFile( "calligraplan.rc" );
 
 //     new ViewAdaptor( this );
 
     m_sp = new QSplitter( this );
     QVBoxLayout *layout = new QVBoxLayout( this );
     layout->setMargin(0);
     layout->addWidget( m_sp );
 
     ViewListDocker *docker = 0;
     if ( mainWindow() == 0 ) {
         // Don't use docker if embedded
         m_viewlist = new ViewListWidget(doc, m_sp);
         m_viewlist->setProject( &( getProject() ) );
         connect( m_viewlist, SIGNAL(selectionChanged(ScheduleManager*)), SLOT(slotSelectionChanged(ScheduleManager*)) );
         connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), m_viewlist, SLOT(setSelectedSchedule(ScheduleManager*)) );
         connect( m_viewlist, SIGNAL(updateViewInfo(ViewListItem*)), SLOT(slotUpdateViewInfo(ViewListItem*)) );
     } else {
         ViewListDockerFactory vl(this);
         docker = static_cast<ViewListDocker *>(mainWindow()->createDockWidget(&vl));
         if (docker->view() != this) {
             docker->setView(this);
         }
         m_viewlist = docker->viewList();
 #if 0        //SchedulesDocker
         SchedulesDockerFactory sdf;
         SchedulesDocker *sd = dynamic_cast<SchedulesDocker*>( createDockWidget( &sdf ) );
         Q_ASSERT( sd );
 
         sd->setProject( &getProject() );
         connect( sd, SIGNAL(selectionChanged(ScheduleManager*)), SLOT(slotSelectionChanged(ScheduleManager*)) );
         connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), sd, SLOT(setSelectedSchedule(ScheduleManager*)) );
 #endif
     }
 
     m_tab = new QStackedWidget( m_sp );
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
     // Add sub views
     createIntroductionView();
 
     // The menu items
     // ------ File
     actionCreateTemplate = new QAction( i18n( "&Create Template From Document..." ), this );
     actionCollection()->addAction("file_createtemplate", actionCreateTemplate );
     connect( actionCreateTemplate, SIGNAL(triggered(bool)), SLOT(slotCreateTemplate()) );
 
     actionCreateNewProject = new QAction( i18n( "&Create New Project..." ), this );
     actionCollection()->addAction("file_createnewproject", actionCreateNewProject );
     connect( actionCreateNewProject, SIGNAL(triggered(bool)), SLOT(slotCreateNewProject()) );
 
     // ------ Edit
     actionCut = actionCollection()->addAction(KStandardAction::Cut,  "edit_cut", this, SLOT(slotEditCut()));
     actionCopy = actionCollection()->addAction(KStandardAction::Copy,  "edit_copy", this, SLOT(slotEditCopy()));
     actionPaste = actionCollection()->addAction(KStandardAction::Paste,  "edit_paste", this, SLOT(slotEditPaste()));
 
     // ------ View
     actionCollection()->addAction( KStandardAction::Redisplay, "view_refresh" , this, SLOT(slotRefreshView()) );
 
     actionViewSelector  = new KToggleAction(i18n("Show Selector"), this);
     actionCollection()->addAction("view_show_selector", actionViewSelector );
     connect( actionViewSelector, SIGNAL(triggered(bool)), SLOT(slotViewSelector(bool)) );
 
     // ------ Insert
 
     // ------ Project
     actionEditMainProject  = new QAction(koIcon("view-time-schedule-edit"), i18n("Edit Main Project..."), this);
     actionCollection()->addAction("project_edit", actionEditMainProject );
     connect( actionEditMainProject, SIGNAL(triggered(bool)), SLOT(slotProjectEdit()) );
 
     actionEditStandardWorktime  = new QAction(koIcon("configure"), i18n("Define Estimate Conversions..."), this);
     actionCollection()->addAction("project_worktime", actionEditStandardWorktime );
     connect( actionEditStandardWorktime, SIGNAL(triggered(bool)), SLOT(slotProjectWorktime()) );
 
 
     // ------ Tools
     actionDefineWBS  = new QAction(koIcon("configure"), i18n("Define WBS Pattern..."), this);
     actionCollection()->addAction("tools_define_wbs", actionDefineWBS );
     connect( actionDefineWBS, SIGNAL(triggered(bool)), SLOT(slotDefineWBS()) );
 
     actionInsertFile  = new QAction(koIcon("document-import"), i18n("Insert Project File..."), this);
     actionCollection()->addAction("insert_file", actionInsertFile );
     connect( actionInsertFile, SIGNAL(triggered(bool)), SLOT(slotInsertFile()) );
 
     // ------ Settings
     actionConfigure  = new QAction(koIcon("configure"), i18n("Configure Plan..."), this);
     actionCollection()->addAction("configure", actionConfigure );
     connect( actionConfigure, SIGNAL(triggered(bool)), SLOT(slotConfigure()) );
 
     actionCurrencyConfig  = new QAction(koIcon("configure"), i18n("Define Currency..."), this);
     actionCollection()->addAction( "config_currency", actionCurrencyConfig );
     connect( actionCurrencyConfig, SIGNAL(triggered(bool)), SLOT(slotCurrencyConfig()) );
 
 #ifdef PLAN_USE_KREPORT
     actionOpenReportFile  = new QAction(koIcon("document-open"), i18n("Open Report Definition File..."), this);
     actionCollection()->addAction( "reportdesigner_open_file", actionOpenReportFile );
     connect( actionOpenReportFile, SIGNAL(triggered(bool)), SLOT(slotOpenReportFile()) );
 #endif
 
     // ------ Help
     actionIntroduction  = new QAction(koIcon("dialog-information"), i18n("Introduction to Plan"), this);
     actionCollection()->addAction("plan_introduction", actionIntroduction );
     connect( actionIntroduction, SIGNAL(triggered(bool)), SLOT(slotIntroduction()) );
 
     // ------ Popup
     actionOpenNode  = new QAction(koIcon("document-edit"), i18n("Edit..."), this);
     actionCollection()->addAction("node_properties", actionOpenNode );
     connect( actionOpenNode, SIGNAL(triggered(bool)), SLOT(slotOpenNode()) );
     actionTaskProgress  = new QAction(koIcon("document-edit"), i18n("Progress..."), this);
     actionCollection()->addAction("task_progress", actionTaskProgress );
     connect( actionTaskProgress, SIGNAL(triggered(bool)), SLOT(slotTaskProgress()) );
     actionDeleteTask  = new QAction(koIcon("edit-delete"), i18n("Delete Task"), this);
     actionCollection()->addAction("delete_task", actionDeleteTask );
     connect( actionDeleteTask, SIGNAL(triggered(bool)), SLOT(slotDeleteTask()) );
     actionTaskDescription  = new QAction(koIcon("document-edit"), i18n("Description..."), this);
     actionCollection()->addAction("task_description", actionTaskDescription );
     connect( actionTaskDescription, SIGNAL(triggered(bool)), SLOT(slotTaskDescription()) );
     actionIndentTask = new QAction(koIcon("format-indent-more"), i18n("Indent Task"), this);
     actionCollection()->addAction("indent_task", actionIndentTask );
     connect( actionIndentTask, SIGNAL(triggered(bool)), SLOT(slotIndentTask()) );
     actionUnindentTask= new QAction(koIcon("format-indent-less"), i18n("Unindent Task"), this);
     actionCollection()->addAction("unindent_task", actionUnindentTask );
     connect( actionUnindentTask, SIGNAL(triggered(bool)), SLOT(slotUnindentTask()) );
     actionMoveTaskUp = new QAction(koIcon("arrow-up"), i18n("Move Task Up"), this);
     actionCollection()->addAction("move_task_up", actionMoveTaskUp );
     connect( actionMoveTaskUp, SIGNAL(triggered(bool)), SLOT(slotMoveTaskUp()) );
     actionMoveTaskDown = new QAction(koIcon("arrow-down"), i18n("Move Task Down"), this);
     actionCollection()->addAction("move_task_down", actionMoveTaskDown );
     connect( actionMoveTaskDown, SIGNAL(triggered(bool)), SLOT(slotMoveTaskDown()) );
 
     actionEditResource  = new QAction(koIcon("document-edit"), i18n("Edit Resource..."), this);
     actionCollection()->addAction("edit_resource", actionEditResource );
     connect( actionEditResource, SIGNAL(triggered(bool)), SLOT(slotEditResource()) );
 
     actionEditRelation  = new QAction(koIcon("document-edit"), i18n("Edit Dependency..."), this);
     actionCollection()->addAction("edit_dependency", actionEditRelation );
     connect( actionEditRelation, SIGNAL(triggered(bool)), SLOT(slotModifyRelation()) );
     actionDeleteRelation  = new QAction(koIcon("edit-delete"), i18n("Delete Dependency"), this);
     actionCollection()->addAction("delete_dependency", actionDeleteRelation );
     connect( actionDeleteRelation, SIGNAL(triggered(bool)), SLOT(slotDeleteRelation()) );
 
     // Viewlist popup
     connect( m_viewlist, SIGNAL(createView()), SLOT(slotCreateView()) );
 
     m_estlabel = new QLabel( "", 0 );
     if ( statusBar() ) {
         addStatusBarItem( m_estlabel, 0, true );
     }
 
     connect( &getProject(), SIGNAL(scheduleChanged(MainSchedule*)), SLOT(slotScheduleChanged(MainSchedule*)) );
 
     connect( &getProject(), SIGNAL(scheduleAdded(const MainSchedule*)), SLOT(slotScheduleAdded(const MainSchedule*)) );
     connect( &getProject(), SIGNAL(scheduleRemoved(const MainSchedule*)), SLOT(slotScheduleRemoved(const MainSchedule*)) );
     slotPlugScheduleActions();
 
     connect( doc, SIGNAL(changed()), SLOT(slotUpdate()) );
 
     connect( m_scheduleActionGroup, SIGNAL(triggered(QAction*)), SLOT(slotViewSchedule(QAction*)) );
 
 
     connect( getPart(), SIGNAL(workPackageLoaded()), SLOT(slotWorkPackageLoaded()) );
 
     // hide unused dockers
     QTimer::singleShot( 0, this, SLOT(hideToolDocker()) );
     // create views after dockers hidden, views take time for large projects
     QTimer::singleShot( 100, this, SLOT(initiateViews()) );
 
     const QList<KPluginFactory *> pluginFactories =
         KoPluginLoader::instantiatePluginFactories(QStringLiteral("calligraplan/extensions"));
 
     foreach (KPluginFactory* factory, pluginFactories) {
         QObject *object = factory->create<QObject>(this, QVariantList());
         KXMLGUIClient *clientPlugin = dynamic_cast<KXMLGUIClient*>(object);
         if (clientPlugin) {
             insertChildClient(clientPlugin);
         } else {
             // not our/valid plugin, so delete the created object
             object->deleteLater();
         }
     }
+    // do not watch task module changes if we are editing one
+    if (!doc->isTaskModule()) {
+        QString dir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
+        if (!dir.isEmpty()) {
+            dir += "/taskmodules";
+            m_dirwatch.addDir(dir, KDirWatch::WatchFiles);
+            QStringList modules = KoResourcePaths::findAllResources( "calligraplan_taskmodules", "*.plan", KoResourcePaths::NoDuplicates|KoResourcePaths::Recursive );
+            for (const QString &f : modules) {
+                m_dirwatch.addFile(f);
+            }
+            connect(&m_dirwatch, SIGNAL(created(QString)), this, SLOT(taskModuleFileChanged(QString)));
+            connect(&m_dirwatch, SIGNAL(deleted(QString)), this, SLOT(taskModuleFileChanged(QString)));
+        }
+    }
     //debugPlan<<" end";
 }
 
 View::~View()
 {
     ViewBase *view = currentView();
     if (view) {
         // deactivate view to remove dockers etc
         slotGuiActivated(view, false);
     }
     /*    removeStatusBarItem( m_estlabel );
     delete m_estlabel;*/
 }
 
 // hackish way to get rid of unused dockers, but as long as no official way exists...
 void View::hideToolDocker()
 {
     if ( mainWindow() ) {
         QStringList lst; lst << "KPlatoViewList" << "Scripting";
         QStringList names;
         foreach ( QDockWidget *w, mainWindow()->dockWidgets() ) {
             if ( ! lst.contains( w->objectName() ) ) {
                 names << w->windowTitle();
                 w->setFeatures( QDockWidget::DockWidgetClosable );
                 w->hide();
             }
         }
         foreach(const KActionCollection *c, KActionCollection::allCollections()) {
             KActionMenu *a = qobject_cast<KActionMenu*>(c->action("settings_dockers_menu"));
             if ( a ) {
                 QList<QAction*> actions = a->menu()->actions();
                 foreach ( QAction *act, actions ) {
                     if ( names.contains( act->text() ) ) {
                         a->removeAction( act );
                     }
                 }
                 a->addSeparator();
                 break;
             }
         }
     }
 }
 
 void View::initiateViews()
 {
     QApplication::setOverrideCursor( Qt::WaitCursor );
     createViews();
 
     connect( m_viewlist, SIGNAL(activated(ViewListItem*,ViewListItem*)), SLOT(slotViewActivated(ViewListItem*,ViewListItem*)) );
     // after createViews() !!
     connect( m_viewlist, SIGNAL(viewListItemRemoved(ViewListItem*)), SLOT(slotViewListItemRemoved(ViewListItem*)) );
     // after createViews() !!
     connect( m_viewlist, SIGNAL(viewListItemInserted(ViewListItem*,ViewListItem*,int)), SLOT(slotViewListItemInserted(ViewListItem*,ViewListItem*,int)) );
 
     QDockWidget *docker = qobject_cast<QDockWidget*>( m_viewlist->parent() );
     if ( docker ) {
         // after createViews() !!
         connect( m_viewlist, SIGNAL(modified()), docker, SLOT(slotModified()));
         connect( m_viewlist, SIGNAL(modified()), getPart(), SLOT(viewlistModified()));
         connect(getPart(), SIGNAL(viewlistModified(bool)), docker, SLOT(updateWindowTitle(bool)));
     }
     connect( m_tab, SIGNAL(currentChanged(int)), this, SLOT(slotCurrentChanged(int)) );
 
     slotSelectDefaultView();
 
     loadContext();
 
     QApplication::restoreOverrideCursor();
 }
 
 void View::slotCreateTemplate()
 {
     KoTemplateCreateDia::createTemplate(koDocument()->documentPart()->templatesResourcePath(), ".plant",
                                         getPart(), this);
 }
 
 void View::slotCreateNewProject()
 {
     debugPlan;
     if ( KMessageBox::Continue == KMessageBox::warningContinueCancel( this,
                       xi18nc( "@info",
                              "<note>This action cannot be undone.</note><nl/><nl/>"
                              "Create a new Project from the current project "
                              "with new project- and task identities.<nl/>"
                              "Resource- and calendar identities are not changed.<nl/>"
                              "All scheduling information is removed.<nl/>"
                              "<nl/>Do you want to continue?" ) ) )
     {
         emit currentScheduleManagerChanged(0);
         getPart()->createNewProject();
         slotOpenNode( &getProject() );
     }
 }
 
 void View::createViews()
 {
     Context *ctx = getPart()->context();
     if ( ctx && ctx->isLoaded() ) {
         debugPlan<<"isLoaded";
         KoXmlNode n = ctx->context().namedItem( "categories" );
         if ( n.isNull() ) {
             warnPlan<<"No categories";
         } else {
             n = n.firstChild();
             for ( ; ! n.isNull(); n = n.nextSibling() ) {
                 if ( ! n.isElement() ) {
                     continue;
                 }
                 KoXmlElement e = n.toElement();
                 if (e.tagName() != "category") {
                     continue;
                 }
                 debugPlan<<"category: "<<e.attribute( "tag" );
                 ViewListItem *cat;
                 QString cn = e.attribute( "name" );
                 QString ct = e.attribute( "tag" );
                 if ( cn.isEmpty() ) {
                     cn = defaultCategoryInfo( ct ).name;
                 }
                 cat = m_viewlist->addCategory( ct, cn );
                 KoXmlNode n1 = e.firstChild();
                 for ( ; ! n1.isNull(); n1 = n1.nextSibling() ) {
                     if ( ! n1.isElement() ) {
                         continue;
                     }
                     KoXmlElement e1 = n1.toElement();
                     if (e1.tagName() != "view") {
                         continue;
                     }
                     ViewBase *v = 0;
                     QString type = e1.attribute( "viewtype" );
                     QString tag = e1.attribute( "tag" );
                     QString name = e1.attribute( "name" );
                     QString tip = e1.attribute( "tooltip" );
                     v = createView( cat, type, tag, name, tip );
                     //KoXmlNode settings = e1.namedItem( "settings " ); ????
                     KoXmlNode settings = e1.firstChild();
                     for ( ; ! settings.isNull(); settings = settings.nextSibling() ) {
                         if ( settings.nodeName() == "settings" ) {
                             break;
                         }
                     }
                     if ( v && settings.isElement() ) {
                         debugPlan<<" settings";
                         v->loadContext( settings.toElement() );
                     }
                 }
             }
         }
     } else {
         debugPlan<<"Default";
         ViewListItem *cat;
         QString ct = "Editors";
         cat = m_viewlist->addCategory( ct, defaultCategoryInfo( ct ).name );
 
         createCalendarEditor( cat, "CalendarEditor", QString(), TIP_USE_DEFAULT_TEXT );
 
         createAccountsEditor( cat, "AccountsEditor", QString(), TIP_USE_DEFAULT_TEXT );
 
         createResourceEditor( cat, "ResourceEditor", QString(), TIP_USE_DEFAULT_TEXT );
 
         createTaskEditor( cat, "TaskEditor", QString(), TIP_USE_DEFAULT_TEXT );
 
         createDependencyEditor( cat, "DependencyEditor", QString(), TIP_USE_DEFAULT_TEXT );
 
         createPertEditor( cat, "PertEditor", QString(), TIP_USE_DEFAULT_TEXT );
 
         createScheduleHandler( cat, "ScheduleHandlerView", QString(), TIP_USE_DEFAULT_TEXT );
 
         ct = "Views";
         cat = m_viewlist->addCategory( ct, defaultCategoryInfo( ct ).name );
 
         createGanttView( cat, "GanttView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createMilestoneGanttView( cat, "MilestoneGanttView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createResourceAppointmentsView( cat, "ResourceAppointmentsView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createResourceAppointmentsGanttView( cat, "ResourceAppointmentsGanttView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createAccountsView( cat, "AccountsView", QString(), TIP_USE_DEFAULT_TEXT );
 
         ct = "Execution";
         cat = m_viewlist->addCategory( ct, defaultCategoryInfo( ct ).name );
 
         createProjectStatusView( cat, "ProjectStatusView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createPerformanceStatusView( cat, "PerformanceStatusView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createTaskStatusView( cat, "TaskStatusView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createTaskView( cat, "TaskView", QString(), TIP_USE_DEFAULT_TEXT );
 
         createTaskWorkPackageView( cat, "TaskWorkPackageView", QString(), TIP_USE_DEFAULT_TEXT );
 
         ct = "Reports";
         cat = m_viewlist->addCategory(ct, defaultCategoryInfo(ct).name);
 
         createReportsGeneratorView(cat, "ReportsGeneratorView", i18n("Generate reports"), TIP_USE_DEFAULT_TEXT);
 
 #ifdef PLAN_USE_KREPORT
         // A little hack to get the user started...
         ReportView *rv = qobject_cast<ReportView*>( createReportView( cat, "ReportView", i18n( "Task Status Report" ), TIP_USE_DEFAULT_TEXT ) );
         if ( rv ) {
             QDomDocument doc;
             doc.setContent( standardTaskStatusReport() );
             rv->loadXML( doc );
         }
 #endif
     }
 }
 
 ViewBase *View::createView( ViewListItem *cat, const QString &type, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ViewBase *v = 0;
     //NOTE: type is the same as classname (so if it is changed...)
     if ( type == "CalendarEditor" ) {
         v = createCalendarEditor( cat, tag, name, tip, index );
     } else if ( type == "AccountsEditor" ) {
         v = createAccountsEditor( cat, tag, name, tip, index );
     } else if ( type == "ResourceEditor" ) {
         v = createResourceEditor( cat, tag, name, tip, index );
     } else if ( type == "TaskEditor" ) {
         v = createTaskEditor( cat, tag, name, tip, index );
     } else if ( type == "DependencyEditor" ) {
         v = createDependencyEditor( cat, tag, name, tip, index );
     } else if ( type == "PertEditor" ) {
         v = createPertEditor( cat, tag, name, tip, index );
     } else if ( type == "ScheduleEditor" ) {
         v = createScheduleEditor( cat, tag, name, tip, index );
     } else if ( type == "ScheduleHandlerView" ) {
         v = createScheduleHandler( cat, tag, name, tip, index );
     } else if ( type == "ProjectStatusView" ) {
         v = createProjectStatusView( cat, tag, name, tip, index );
     } else if ( type == "TaskStatusView" ) {
         v = createTaskStatusView( cat, tag, name, tip, index );
     } else if ( type == "TaskView" ) {
         v = createTaskView( cat, tag, name, tip, index );
     } else if ( type == "TaskWorkPackageView" ) {
         v = createTaskWorkPackageView( cat, tag, name, tip, index );
     } else if ( type == "GanttView" ) {
         v = createGanttView( cat, tag, name, tip, index );
     } else if ( type == "MilestoneGanttView" ) {
         v = createMilestoneGanttView( cat, tag, name, tip, index );
     } else if ( type == "ResourceAppointmentsView" ) {
         v = createResourceAppointmentsView( cat, tag, name, tip, index );
     } else if ( type == "ResourceAppointmentsGanttView" ) {
         v = createResourceAppointmentsGanttView( cat, tag, name, tip, index );
     } else if ( type == "AccountsView" ) {
         v = createAccountsView( cat, tag, name, tip, index );
     } else if ( type == "PerformanceStatusView" ) {
         v = createPerformanceStatusView( cat, tag, name, tip, index );
     } else if ( type == "ReportsGeneratorView" ) {
         v = createReportsGeneratorView(cat, tag, name, tip, index);
     } else if ( type == "ReportView" ) {
 #ifdef PLAN_USE_KREPORT
         v = createReportView( cat, tag, name, tip, index );
 #endif
     } else  {
         warnPlan<<"Unknown viewtype: "<<type;
     }
     return v;
 }
 
 void View::slotUpdateViewInfo( ViewListItem *itm )
 {
     if ( itm->type() == ViewListItem::ItemType_SubView ) {
         itm->setViewInfo( defaultViewInfo( itm->viewType() ) );
     } else if ( itm->type() == ViewListItem::ItemType_Category ) {
         ViewInfo vi = defaultCategoryInfo( itm->tag() );
         itm->setViewInfo( vi );
     }
 }
 
 ViewInfo View::defaultViewInfo( const QString &type ) const
 {
     ViewInfo vi;
     if ( type == "CalendarEditor" ) {
         vi.name = i18n( "Work & Vacation" );
         vi.tip = xi18nc( "@info:tooltip", "Edit working- and vacation days for resources" );
     } else if ( type == "AccountsEditor" ) {
         vi.name = i18n( "Cost Breakdown Structure" );
         vi.tip = xi18nc( "@info:tooltip", "Edit cost breakdown structure." );
     } else if ( type == "ResourceEditor" ) {
         vi.name = i18n( "Resources" );
         vi.tip = xi18nc( "@info:tooltip", "Edit resource breakdown structure" );
     } else if ( type == "TaskEditor" ) {
         vi.name = i18n( "Tasks" );
         vi.tip = xi18nc( "@info:tooltip", "Edit work breakdown structure" );
     } else if ( type == "DependencyEditor" ) {
         vi.name = i18n( "Dependencies (Graphic)" );
         vi.tip = xi18nc( "@info:tooltip", "Edit task dependencies" );
     } else if ( type == "PertEditor" ) {
         vi.name = i18n( "Dependencies (List)" );
         vi.tip = xi18nc( "@info:tooltip", "Edit task dependencies" );
     } else if ( type == "ScheduleEditor" ) {
         // This view is not used stand-alone atm
         vi.name = i18n( "Schedules" );
     } else if ( type == "ScheduleHandlerView" ) {
         vi.name = i18n( "Schedules" );
         vi.tip = xi18nc( "@info:tooltip", "Calculate and analyze project schedules" );
     } else if ( type == "ProjectStatusView" ) {
         vi.name = i18n( "Project Performance Chart" );
         vi.tip = xi18nc( "@info:tooltip", "View project status information" );
     } else if ( type == "TaskStatusView" ) {
         vi.name = i18n( "Task Status" );
         vi.tip = xi18nc( "@info:tooltip", "View task progress information" );
     } else if ( type == "TaskView" ) {
         vi.name = i18n( "Task Execution" );
         vi.tip = xi18nc( "@info:tooltip", "View task execution information" );
     } else if ( type == "TaskWorkPackageView" ) {
         vi.name = i18n( "Work Package View" );
         vi.tip = xi18nc( "@info:tooltip", "View task work package information" );
     } else if ( type == "GanttView" ) {
         vi.name = i18n( "Gantt" );
         vi.tip = xi18nc( "@info:tooltip", "View Gantt chart" );
     } else if ( type == "MilestoneGanttView" ) {
         vi.name = i18n( "Milestone Gantt" );
         vi.tip = xi18nc( "@info:tooltip", "View milestone Gantt chart" );
     } else if ( type == "ResourceAppointmentsView" ) {
         vi.name = i18n( "Resource Assignments" );
         vi.tip = xi18nc( "@info:tooltip", "View resource assignments in a table" );
     } else if ( type == "ResourceAppointmentsGanttView" ) {
         vi.name = i18n( "Resource Assignments (Gantt)" );
         vi.tip = xi18nc( "@info:tooltip", "View resource assignments in Gantt chart" );
     } else if ( type == "AccountsView" ) {
         vi.name = i18n( "Cost Breakdown" );
         vi.tip = xi18nc( "@info:tooltip", "View planned and actual cost" );
     } else if ( type == "PerformanceStatusView" ) {
         vi.name = i18n( "Tasks Performance Chart" );
         vi.tip = xi18nc( "@info:tooltip", "View tasks performance status information" );
     } else if ( type == "ReportsGeneratorView" ) {
         vi.name = i18n( "Reports Generator" );
         vi.tip = xi18nc( "@info:tooltip", "Generate reports" );
     } else if ( type == "ReportView" ) {
         vi.name = i18n( "Report" );
         vi.tip = xi18nc( "@info:tooltip", "View report" );
     } else  {
         warnPlan<<"Unknown viewtype: "<<type;
     }
     return vi;
 }
 
 ViewInfo View::defaultCategoryInfo( const QString &type ) const
 {
     ViewInfo vi;
     if ( type == "Editors" ) {
         vi.name = i18n( "Editors" );
     } else if ( type == "Views" ) {
         vi.name = i18n( "Views" );
     } else if ( type == "Execution" ) {
         vi.name = i18nc( "Project execution views", "Execution" );
     } else if ( type == "Reports" ) {
         vi.name = i18n( "Reports" );
     }
     return vi;
 }
 
 void View::slotOpenUrlRequest( HtmlView *v, const QUrl &url )
 {
     debugPlan<<url;
     if ( url.scheme() == QLatin1String("about") ) {
         if ( url.url() == QLatin1String("about:close") ) {
             int view = m_visitedViews.count() < 2 ? qMin(m_defaultView, m_tab->count()-1) : m_visitedViews.at(m_visitedViews.count() - 2);
             debugPlan<<"Prev:"<<view<<m_visitedViews;
             m_tab->setCurrentIndex(view);
             return;
         }
         if ( url.url().startsWith( QLatin1String( "about:plan" ) ) ) {
             getPart()->aboutPage().generatePage( v->htmlPart(), url );
             return;
         }
     }
     if ( url.scheme() == QLatin1String("help") ) {
         KHelpClient::invokeHelp( "", url.fileName() );
         return;
     }
     // try to open the url
     debugPlan<<url<<"is external, try to open";
     new KRun( url, mainWindow() );
 }
 
 ViewBase *View::createIntroductionView()
 {
     HtmlView *v = new HtmlView(getKoPart(), getPart(), m_tab );
     v->htmlPart().setJScriptEnabled(false);
     v->htmlPart().setJavaEnabled(false);
     v->htmlPart().setMetaRefreshEnabled(false);
     v->htmlPart().setPluginsEnabled(false);
 
     slotOpenUrlRequest( v, QUrl( "about:plan/main" ) );
 
     connect( v, SIGNAL(openUrlRequest(HtmlView*,QUrl)), SLOT(slotOpenUrlRequest(HtmlView*,QUrl)) );
 
     m_tab->addWidget( v );
     return v;
 }
 
 ViewBase *View::createResourceAppointmentsGanttView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ResourceAppointmentsGanttView *v = new ResourceAppointmentsGanttView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ResourceAppointmentsGanttView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
 
     v->setProject( &( getProject() ) );
     v->setScheduleManager( currentScheduleManager() );
     v->updateReadWrite( m_readWrite );
     return v;
 }
 
 
 ViewBase *View::createResourceAppointmentsView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ResourceAppointmentsView *v = new ResourceAppointmentsView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ResourceAppointmentsView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
 
     v->setProject( &( getProject() ) );
     v->setScheduleManager( currentScheduleManager() );
     v->updateReadWrite( m_readWrite );
     return v;
 }
 
 ViewBase *View::createResourceEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ResourceEditor *resourceeditor = new ResourceEditor(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( resourceeditor );
     resourceeditor->setProject( &(getProject()) );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, resourceeditor, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ResourceEditor" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     connect( resourceeditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( resourceeditor, SIGNAL(deleteObjectList(QObjectList)), SLOT(slotDeleteResourceObjects(QObjectList)) );
 
     connect( resourceeditor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     resourceeditor->updateReadWrite( m_readWrite );
     return resourceeditor;
 }
 
 ViewBase *View::createTaskEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     TaskEditor *taskeditor = new TaskEditor(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( taskeditor );
     m_defaultView = m_tab->count() - 1;
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, taskeditor, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "TaskEditor" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     taskeditor->setProject( &(getProject()) );
     taskeditor->setScheduleManager( currentScheduleManager() );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), taskeditor, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( taskeditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( taskeditor, SIGNAL(addTask()), SLOT(slotAddTask()) );
     connect( taskeditor, SIGNAL(addMilestone()), SLOT(slotAddMilestone()) );
     connect( taskeditor, SIGNAL(addSubtask()), SLOT(slotAddSubTask()) );
     connect( taskeditor, SIGNAL(addSubMilestone()), SLOT(slotAddSubMilestone()) );
     connect( taskeditor, SIGNAL(deleteTaskList(QList<Node*>)), SLOT(slotDeleteTask(QList<Node*>)) );
     connect( taskeditor, SIGNAL(moveTaskUp()), SLOT(slotMoveTaskUp()) );
     connect( taskeditor, SIGNAL(moveTaskDown()), SLOT(slotMoveTaskDown()) );
     connect( taskeditor, SIGNAL(indentTask()), SLOT(slotIndentTask()) );
     connect( taskeditor, SIGNAL(unindentTask()), SLOT(slotUnindentTask()) );
 
     connect(taskeditor, SIGNAL(saveTaskModule(QUrl,Project*)), SLOT(saveTaskModule(QUrl,Project*)));
     connect(taskeditor, SIGNAL(removeTaskModule(QUrl)), SLOT(removeTaskModule(QUrl)));
+    connect(taskeditor, SIGNAL(openDocument(QUrl)), static_cast<Part*>(m_partpart), SLOT(openTaskModule(QUrl)));
+    connect(this, SIGNAL(taskModulesChanged(QStringList)), taskeditor, SLOT(setTaskModules(QStringList)));
 
     connect( taskeditor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     taskeditor->updateReadWrite( m_readWrite );
 
     // last:
     QStringList modules = KoResourcePaths::findAllResources( "calligraplan_taskmodules", "*.plan", KoResourcePaths::NoDuplicates|KoResourcePaths::Recursive );
     debugPlan<<modules;
     taskeditor->setTaskModules( modules );
     return taskeditor;
 }
 
 ViewBase *View::createAccountsEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     AccountsEditor *ae = new AccountsEditor(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( ae );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, ae, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "AccountsEditor" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     ae->draw( getProject() );
 
     connect( ae, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
     ae->updateReadWrite( m_readWrite );
     return ae;
 }
 
 ViewBase *View::createCalendarEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     CalendarEditor *calendareditor = new CalendarEditor(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( calendareditor );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, calendareditor, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "CalendarEditor" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     calendareditor->draw( getProject() );
 
     connect( calendareditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( calendareditor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     calendareditor->updateReadWrite( m_readWrite );
     return calendareditor;
 }
 
 ViewBase *View::createScheduleHandler( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ScheduleHandlerView *handler = new ScheduleHandlerView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( handler );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, handler, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ScheduleHandlerView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     connect( handler->scheduleEditor(), SIGNAL(addScheduleManager(Project*)), SLOT(slotAddScheduleManager(Project*)) );
     connect( handler->scheduleEditor(), SIGNAL(deleteScheduleManager(Project*,ScheduleManager*)), SLOT(slotDeleteScheduleManager(Project*,ScheduleManager*)) );
     connect( handler->scheduleEditor(), SIGNAL(moveScheduleManager(ScheduleManager*,ScheduleManager*,int)), SLOT(slotMoveScheduleManager(ScheduleManager*,ScheduleManager*,int)));
 
     connect( handler->scheduleEditor(), SIGNAL(calculateSchedule(Project*,ScheduleManager*)), SLOT(slotCalculateSchedule(Project*,ScheduleManager*)) );
 
     connect( handler->scheduleEditor(), SIGNAL(baselineSchedule(Project*,ScheduleManager*)), SLOT(slotBaselineSchedule(Project*,ScheduleManager*)) );
 
 
     connect( handler, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), handler, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)) );
 
     connect( handler, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
 
     connect(handler, SIGNAL(editNode(Node*)), this, SLOT(slotOpenNode(Node*)));
     connect(handler, SIGNAL(editResource(Resource*)), this, SLOT(slotEditResource(Resource*)));
 
     handler->draw( getProject() );
     handler->updateReadWrite( m_readWrite );
     return handler;
 }
 
 ScheduleEditor *View::createScheduleEditor( QWidget *parent )
 {
     ScheduleEditor *scheduleeditor = new ScheduleEditor(getKoPart(), getPart(), parent );
 
     connect( scheduleeditor, SIGNAL(addScheduleManager(Project*)), SLOT(slotAddScheduleManager(Project*)) );
     connect( scheduleeditor, SIGNAL(deleteScheduleManager(Project*,ScheduleManager*)), SLOT(slotDeleteScheduleManager(Project*,ScheduleManager*)) );
 
     connect( scheduleeditor, SIGNAL(calculateSchedule(Project*,ScheduleManager*)), SLOT(slotCalculateSchedule(Project*,ScheduleManager*)) );
 
     connect( scheduleeditor, SIGNAL(baselineSchedule(Project*,ScheduleManager*)), SLOT(slotBaselineSchedule(Project*,ScheduleManager*)) );
 
     scheduleeditor->updateReadWrite( m_readWrite );
     return scheduleeditor;
 }
 
 ViewBase *View::createScheduleEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ScheduleEditor *scheduleeditor = new ScheduleEditor(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( scheduleeditor );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, scheduleeditor, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ScheduleEditor" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     scheduleeditor->setProject( &( getProject() ) );
 
     connect( scheduleeditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( scheduleeditor, SIGNAL(addScheduleManager(Project*)), SLOT(slotAddScheduleManager(Project*)) );
 
     connect( scheduleeditor, SIGNAL(deleteScheduleManager(Project*,ScheduleManager*)), SLOT(slotDeleteScheduleManager(Project*,ScheduleManager*)) );
 
     connect( scheduleeditor, SIGNAL(calculateSchedule(Project*,ScheduleManager*)), SLOT(slotCalculateSchedule(Project*,ScheduleManager*)) );
 
     connect( scheduleeditor, SIGNAL(baselineSchedule(Project*,ScheduleManager*)), SLOT(slotBaselineSchedule(Project*,ScheduleManager*)) );
 
     scheduleeditor->updateReadWrite( m_readWrite );
     return scheduleeditor;
 }
 
 
 ViewBase *View::createDependencyEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     DependencyEditor *editor = new DependencyEditor(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( editor );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, editor, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "DependencyEditor" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     editor->draw( getProject() );
 
     connect( editor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( editor, SIGNAL(addRelation(Node*,Node*,int)), SLOT(slotAddRelation(Node*,Node*,int)) );
     connect( editor, SIGNAL(modifyRelation(Relation*,int)), SLOT(slotModifyRelation(Relation*,int)) );
     connect( editor, SIGNAL(modifyRelation(Relation*)), SLOT(slotModifyRelation(Relation*)) );
 
     connect( editor, SIGNAL(editNode(Node*)), SLOT(slotOpenNode(Node*)) );
     connect( editor, SIGNAL(addTask()), SLOT(slotAddTask()) );
     connect( editor, SIGNAL(addMilestone()), SLOT(slotAddMilestone()) );
     connect( editor, SIGNAL(addSubMilestone()), SLOT(slotAddSubMilestone()) );
     connect( editor, SIGNAL(addSubtask()), SLOT(slotAddSubTask()) );
     connect( editor, SIGNAL(deleteTaskList(QList<Node*>)), SLOT(slotDeleteTask(QList<Node*>)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), editor, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( editor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     editor->updateReadWrite( m_readWrite );
     editor->setScheduleManager( currentScheduleManager() );
     return editor;
 }
 
 ViewBase *View::createPertEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     PertEditor *perteditor = new PertEditor(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( perteditor );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, perteditor, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "PertEditor" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     perteditor->draw( getProject() );
 
     connect( perteditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
     m_updatePertEditor = true;
     perteditor->updateReadWrite( m_readWrite );
     return perteditor;
 }
 
 ViewBase *View::createProjectStatusView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ProjectStatusView *v = new ProjectStatusView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ProjectStatusView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
 
     v->updateReadWrite( m_readWrite );
     v->setProject( &getProject() );
     v->setScheduleManager( currentScheduleManager() );
     return v;
 }
 
 ViewBase *View::createPerformanceStatusView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     PerformanceStatusView *v = new PerformanceStatusView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "PerformanceStatusView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
 
     v->updateReadWrite( m_readWrite );
     v->setProject( &getProject() );
     v->setScheduleManager( currentScheduleManager() );
     return v;
 }
 
 
 ViewBase *View::createTaskStatusView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     TaskStatusView *taskstatusview = new TaskStatusView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( taskstatusview );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, taskstatusview, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "TaskStatusView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     connect( taskstatusview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), taskstatusview, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( taskstatusview, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
 
     taskstatusview->updateReadWrite( m_readWrite );
     taskstatusview->draw( getProject() );
     taskstatusview->setScheduleManager( currentScheduleManager() );
     return taskstatusview;
 }
 
 ViewBase *View::createTaskView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     TaskView *v = new TaskView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "TaskView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     v->draw( getProject() );
     v->setScheduleManager( currentScheduleManager() );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     v->updateReadWrite( m_readWrite );
     return v;
 }
 
 ViewBase *View::createTaskWorkPackageView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     TaskWorkPackageView *v = new TaskWorkPackageView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "TaskWorkPackageView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     v->setProject( &getProject() );
     v->setScheduleManager( currentScheduleManager() );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
 
     connect( v, SIGNAL(mailWorkpackage(Node*,Resource*)), SLOT(slotMailWorkpackage(Node*,Resource*)) );
     connect( v, SIGNAL(mailWorkpackages(QList<Node*>,Resource*)), SLOT(slotMailWorkpackages(QList<Node*>,Resource*)) );
 
     connect(v, SIGNAL(checkForWorkPackages()), getPart(), SLOT(checkForWorkPackages()));
     v->updateReadWrite( m_readWrite );
     return v;
 }
 
 ViewBase *View::createGanttView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     GanttView *ganttview = new GanttView(getKoPart(), getPart(), m_tab, koDocument()->isReadWrite() );
     m_tab->addWidget( ganttview );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, ganttview, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "GanttView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     ganttview->setProject( &( getProject() ) );
     ganttview->setScheduleManager( currentScheduleManager() );
 
     connect( ganttview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 /*  TODO: Review these
     connect( ganttview, SIGNAL(addRelation(Node*,Node*,int)), SLOT(slotAddRelation(Node*,Node*,int)) );
     connect( ganttview, SIGNAL(modifyRelation(Relation*,int)), SLOT(slotModifyRelation(Relation*,int)) );
     connect( ganttview, SIGNAL(modifyRelation(Relation*)), SLOT(slotModifyRelation(Relation*)) );
     connect( ganttview, SIGNAL(itemDoubleClicked()), SLOT(slotOpenNode()) );
     connect( ganttview, SIGNAL(itemRenamed(Node*,QString)), this, SLOT(slotRenameNode(Node*,QString)) );*/
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), ganttview, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( ganttview, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     ganttview->updateReadWrite( m_readWrite );
     return ganttview;
 }
 
 ViewBase *View::createMilestoneGanttView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     MilestoneGanttView *ganttview = new MilestoneGanttView(getKoPart(), getPart(), m_tab, koDocument()->isReadWrite() );
     m_tab->addWidget( ganttview );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, ganttview, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "MilestoneGanttView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     ganttview->setProject( &( getProject() ) );
     ganttview->setScheduleManager( currentScheduleManager() );
 
     connect( ganttview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), ganttview, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( ganttview, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     ganttview->updateReadWrite( m_readWrite );
     return ganttview;
 }
 
 
 ViewBase *View::createAccountsView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     AccountsView *accountsview = new AccountsView(getKoPart(), &getProject(), getPart(), m_tab );
     m_tab->addWidget( accountsview );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, accountsview, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "AccountsView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     accountsview->setScheduleManager( currentScheduleManager() );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), accountsview, SLOT(setScheduleManager(ScheduleManager*)) );
 
     connect( accountsview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
     accountsview->updateReadWrite( m_readWrite );
     return accountsview;
 }
 
 ViewBase *View::createResourceAssignmentView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
     ResourceAssignmentView *resourceAssignmentView = new ResourceAssignmentView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( resourceAssignmentView );
     m_updateResourceAssignmentView = true;
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, resourceAssignmentView, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ResourceAssignmentView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     resourceAssignmentView->draw( getProject() );
 
     connect( resourceAssignmentView, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
 
     connect( resourceAssignmentView, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
     resourceAssignmentView->updateReadWrite( m_readWrite );
     return resourceAssignmentView;
 }
 
 ViewBase *View::createReportsGeneratorView(ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index)
 {
     ReportsGeneratorView *v = new ReportsGeneratorView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView(cat, tag, name, v, getPart(), "", index);
     ViewInfo vi = defaultViewInfo( "ReportsGeneratorView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     v->setProject( &getProject() );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(slotRefreshView()));
     v->setScheduleManager( currentScheduleManager() );
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
     connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) );
 
     v->updateReadWrite( m_readWrite );
     return v;
 }
 
 ViewBase *View::createReportView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index )
 {
 #ifdef PLAN_USE_KREPORT
     ReportView *v = new ReportView(getKoPart(), getPart(), m_tab );
     m_tab->addWidget( v );
 
     ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "", index );
     ViewInfo vi = defaultViewInfo( "ReportView" );
     if ( name.isEmpty() ) {
         i->setText( 0, vi.name );
     }
     if ( tip == TIP_USE_DEFAULT_TEXT ) {
         i->setToolTip( 0, vi.tip );
     } else {
         i->setToolTip( 0, tip );
     }
 
     v->setProject( &getProject() );
 
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) );
     connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(slotRefreshView()));
     v->setScheduleManager( currentScheduleManager() );
 
     connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) );
     v->updateReadWrite( m_readWrite );
     return v;
 #else
     return 0;
 #endif
 }
 
 Project& View::getProject() const
 {
     return getPart() ->getProject();
 }
 
 KoPrintJob * View::createPrintJob()
 {
     KoView *v = qobject_cast<KoView*>( canvas() );
     if ( v == 0 ) {
         return 0;
     }
     return v->createPrintJob();
 }
 
 ViewBase *View::currentView() const
 {
     return qobject_cast<ViewBase*>( m_tab->currentWidget() );
 }
 
 void View::slotEditCut()
 {
     ViewBase *v = currentView();
     if ( v ) {
         v->slotEditCut();
     }
 }
 
 void View::slotEditCopy()
 {
     ViewBase *v = currentView();
     if ( v ) {
         v->slotEditCopy();
     }
 }
 
 void View::slotEditPaste()
 {
     ViewBase *v = currentView();
     if ( v ) {
         v->slotEditPaste();
     }
 }
 
 void View::slotRefreshView()
 {
     ViewBase *v = currentView();
     if ( v ) {
         debugPlan<<v;
         v->slotRefreshView();
     }
 }
 
 void View::slotViewSelector( bool show )
 {
     //debugPlan;
     m_viewlist->setVisible( show );
 }
 
 void View::slotInsertResourcesFile(const QString &file, const QUrl &projects)
 {
     getPart()->insertResourcesFile(QUrl(file), projects);
 }
 
 void View::slotInsertFile()
 {
     InsertFileDialog *dlg = new InsertFileDialog( getProject(), currentTask(), this );
     connect(dlg, SIGNAL(finished(int)), SLOT(slotInsertFileFinished(int)));
     dlg->show();
     dlg->raise();
     dlg->activateWindow();
 }
 
 void View::slotInsertFileFinished( int result )
 {
     InsertFileDialog *dlg = qobject_cast<InsertFileDialog*>( sender() );
     if ( dlg == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted ) {
         getPart()->insertFile( dlg->url(), dlg->parentNode(), dlg->afterNode() );
     }
     dlg->deleteLater();
 }
 
 void View::slotProjectEdit()
 {
     slotOpenNode( &getProject() );
 }
 
 void View::slotProjectWorktime()
 {
     StandardWorktimeDialog *dia = new StandardWorktimeDialog( getProject(), this );
     connect(dia, SIGNAL(finished(int)), this, SLOT(slotProjectWorktimeFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotProjectWorktimeFinished( int result )
 {
     StandardWorktimeDialog *dia = qobject_cast<StandardWorktimeDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * cmd = dia->buildCommand();
         if ( cmd ) {
             //debugPlan<<"Modifying calendar(s)";
             getPart() ->addCommand( cmd ); //also executes
         }
     }
     dia->deleteLater();
 }
 
 void View::slotSelectionChanged( ScheduleManager *sm ) {
     debugPlan<<sm;
     if ( sm == 0 ) {
         return;
     }
     int idx = m_scheduleActions.values().indexOf( sm->expected() );
     if ( idx < 0 ) {
         debugPlan<<sm<<"could not find schedule"<<sm->expected();
         return;
     }
     QAction *a = m_scheduleActions.keys().at( idx );
     Q_ASSERT( a );
     a->setChecked( true ); // this doesn't trigger QActionGroup
     slotViewSchedule( a );
 }
 
 QList<QAction*> View::sortedActionList()
 {
     QMap<QString, QAction*> lst;
     foreach ( QAction *a, m_scheduleActions.keys() ) {
         lst.insert( a->objectName(), a );
     }
     return lst.values();
 }
 
 void View::slotScheduleRemoved( const MainSchedule *sch )
 {
     debugPlan<<sch<<sch->name();
     QAction *a = 0;
     QAction *checked = m_scheduleActionGroup->checkedAction();
     QMapIterator<QAction*, Schedule*> i( m_scheduleActions );
     while (i.hasNext()) {
         i.next();
         if ( i.value() == sch ) {
             a = i.key();
             break;
         }
     }
     if ( a ) {
         unplugActionList( "view_schedule_list" );
         delete a;
         plugActionList( "view_schedule_list", sortedActionList() );
         if ( checked && checked != a ) {
             checked->setChecked( true );
         } else if ( ! m_scheduleActions.isEmpty() ) {
             m_scheduleActions.keys().first()->setChecked( true );
         }
     }
     slotViewSchedule( m_scheduleActionGroup->checkedAction() );
 }
 
 void View::slotScheduleAdded( const MainSchedule *sch )
 {
     if ( sch->type() != Schedule::Expected ) {
         return; // Only view expected
     }
     MainSchedule *s = const_cast<MainSchedule*>( sch );
 //     debugPlan<<sch->name()<<" deleted="<<sch->isDeleted()<<"scheduled="<<sch->isScheduled();
     QAction *checked = m_scheduleActionGroup->checkedAction();
     if ( ! sch->isDeleted() && sch->isScheduled() ) {
         unplugActionList( "view_schedule_list" );
         QAction *act = addScheduleAction( s );
         plugActionList( "view_schedule_list", sortedActionList() );
         if ( checked ) {
             checked->setChecked( true );
         } else if ( act ) {
             act->setChecked( true );
         } else if ( ! m_scheduleActions.isEmpty() ) {
             m_scheduleActions.keys().first()->setChecked( true );
         }
     }
     slotViewSchedule( m_scheduleActionGroup->checkedAction() );
 }
 
 void View::slotScheduleChanged( MainSchedule *sch )
 {
 //     debugPlan<<sch->name()<<" deleted="<<sch->isDeleted()<<"scheduled="<<sch->isScheduled();
     if ( sch->isDeleted() || ! sch->isScheduled() ) {
         slotScheduleRemoved( sch );
         return;
     }
     if ( m_scheduleActions.values().contains( sch ) ) {
         slotScheduleRemoved( sch ); // hmmm, how to avoid this?
     }
     slotScheduleAdded( sch );
 }
 
 QAction *View::addScheduleAction( Schedule *sch )
 {
     QAction *act = 0;
     if ( ! sch->isDeleted() && sch->isScheduled() ) {
         QString n = sch->name();
         act = new KToggleAction( n, this);
         actionCollection()->addAction(n, act );
         m_scheduleActions.insert( act, sch );
         m_scheduleActionGroup->addAction( act );
         //debugPlan<<"Add:"<<n;
         connect( act, SIGNAL(destroyed(QObject*)), SLOT(slotActionDestroyed(QObject*)) );
     }
     return act;
 }
 
 void View::slotViewScheduleManager()
 {
     QApplication::setOverrideCursor( Qt::WaitCursor );
     setLabel( m_nextScheduleManager );
     emit currentScheduleManagerChanged( m_nextScheduleManager );
     m_nextScheduleManager = 0;
     m_trigged = false;
     QApplication::restoreOverrideCursor();
 }
 
 void View::slotViewSchedule( QAction *act )
 {
     //debugPlan<<act;
     ScheduleManager *sm = 0;
     if ( act != 0 ) {
         Schedule *sch = m_scheduleActions.value( act, 0 );
         sm = sch->manager();
     }
     //emit currentScheduleManagerChanged( 0 );
     setLabel( 0 );
     m_nextScheduleManager = sm;
     // Performance is very dependent on schedule manager change since a lot is recalculated
     // In case of multiple changes, only issue the last change
     if ( ! m_trigged ) {
         m_trigged = true;
         //emit currentScheduleManagerChanged( 0 );
         QTimer::singleShot( 0, this, SLOT(slotViewScheduleManager()) );
     }
 }
 
 void View::slotActionDestroyed( QObject *o )
 {
     //debugPlan<<o->name();
     m_scheduleActions.remove( static_cast<QAction*>( o ) );
 //    slotViewSchedule( m_scheduleActionGroup->checkedAction() );
 }
 
 void View::slotPlugScheduleActions()
 {
     //debugPlan<<activeScheduleId();
     long id = activeScheduleId();
     unplugActionList( "view_schedule_list" );
     foreach( QAction *act, m_scheduleActions.keys() ) {
         m_scheduleActionGroup->removeAction( act );
         delete act;
     }
     m_scheduleActions.clear();
     QAction *ca = 0;
     foreach( ScheduleManager *sm, getProject().allScheduleManagers() ) {
         Schedule *sch = sm->expected();
         if ( sch == 0 ) {
             continue;
         }
         QAction *act = addScheduleAction( sch );
         if ( act && id == sch->id() ) {
             ca = act;
         }
     }
     plugActionList( "view_schedule_list", sortedActionList() );
     if ( ca == 0 && m_scheduleActionGroup->actions().count() > 0 ) {
         ca = m_scheduleActionGroup->actions().first();
     }
     if ( ca ) {
         ca->setChecked( true );
     }
     slotViewSchedule( ca );
 }
 
 void View::slotProjectCalculated( ScheduleManager *sm )
 {
     // we only get here if current schedule was calculated
     if ( sm->isScheduled() ) {
         slotSelectionChanged( sm );
     }
 }
 
 void View::slotCalculateSchedule( Project *project, ScheduleManager *sm )
 {
     if ( project == 0 || sm == 0 ) {
         return;
     }
     if ( sm->parentManager() && ! sm->parentManager()->isScheduled() ) {
         // the parent must be scheduled
         return;
     }
     if ( sm == currentScheduleManager() ) {
         connect( project, SIGNAL(projectCalculated(ScheduleManager*)), this, SLOT(slotProjectCalculated(ScheduleManager*)) );
     }
     CalculateScheduleCmd *cmd =  new CalculateScheduleCmd( *project, sm, kundo2_i18nc("@info:status 1=schedule name", "Calculate %1", sm->name() ) );
     getPart() ->addCommand( cmd );
     slotUpdate();
 }
 
 void View::slotRemoveCommands()
 {
     while ( ! m_undocommands.isEmpty() ) {
         m_undocommands.last()->undo();
         delete m_undocommands.takeLast();
     }
 }
 
 void View::slotBaselineSchedule( Project *project, ScheduleManager *sm )
 {
     if ( project == 0 || sm == 0 ) {
         return;
     }
     if ( ! sm->isBaselined() && project->isBaselined() ) {
         KMessageBox::sorry( this, i18n( "Cannot baseline. The project is already baselined." ) );
         return;
     }
     KUndo2Command *cmd;
     if ( sm->isBaselined() ) {
         KMessageBox::ButtonCode res = KMessageBox::warningContinueCancel( this, i18n( "This schedule is baselined. Do you want to remove the baseline?" ) );
         if ( res == KMessageBox::Cancel ) {
             return;
         }
         cmd = new ResetBaselineScheduleCmd( *sm, kundo2_i18n( "Reset baseline %1", sm->name() ) );
     } else {
         cmd = new BaselineScheduleCmd( *sm, kundo2_i18n( "Baseline %1", sm->name() ) );
     }
     getPart() ->addCommand( cmd );
 }
 
 void View::slotAddScheduleManager( Project *project )
 {
     if ( project == 0 ) {
         return;
     }
     ScheduleManager *sm = project->createScheduleManager();
     AddScheduleManagerCmd *cmd =  new AddScheduleManagerCmd( *project, sm, -1, kundo2_i18n( "Add schedule %1", sm->name() ) );
     getPart() ->addCommand( cmd );
 }
 
 void View::slotDeleteScheduleManager( Project *project, ScheduleManager *sm )
 {
     if ( project == 0 || sm == 0) {
         return;
     }
     DeleteScheduleManagerCmd *cmd =  new DeleteScheduleManagerCmd( *project, sm, kundo2_i18n( "Delete schedule %1", sm->name() ) );
     getPart() ->addCommand( cmd );
 }
 
 void View::slotMoveScheduleManager( ScheduleManager *sm, ScheduleManager *parent, int index )
 {
     if ( sm == 0 ) {
         return;
     }
     MoveScheduleManagerCmd *cmd =  new MoveScheduleManagerCmd( sm, parent, index, kundo2_i18n( "Move schedule %1", sm->name() ) );
     getPart() ->addCommand( cmd );
 }
 
 void View::slotAddSubTask()
 {
     Task * node = getProject().createTask( getPart() ->config().taskDefaults() );
     SubTaskAddDialog *dia = new SubTaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotAddSubTaskFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotAddSubTaskFinished( int result )
 {
     SubTaskAddDialog *dia = qobject_cast<SubTaskAddDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result  == QDialog::Accepted) {
         KUndo2Command *m = dia->buildCommand();
         getPart() ->addCommand( m ); // add task to project
     }
     dia->deleteLater();
 }
 
 void View::slotAddTask()
 {
     Task * node = getProject().createTask( getPart() ->config().taskDefaults() );
     TaskAddDialog *dia = new TaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotAddTaskFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotAddTaskFinished( int result )
 {
     TaskAddDialog *dia = qobject_cast<TaskAddDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command *m = dia->buildCommand();
         getPart() ->addCommand( m ); // add task to project
     }
     dia->deleteLater();
 }
 
 void View::slotAddMilestone()
 {
     Task * node = getProject().createTask();
     node->estimate() ->clear();
 
     TaskAddDialog *dia = new TaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotAddMilestoneFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotAddMilestoneFinished( int result )
 {
     TaskAddDialog *dia = qobject_cast<TaskAddDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         MacroCommand *c = new MacroCommand( kundo2_i18n( "Add milestone" ) );
         c->addCommand( dia->buildCommand() );
         getPart() ->addCommand( c ); // add task to project
     }
     dia->deleteLater();
 }
 
 void View::slotAddSubMilestone()
 {
     Task * node = getProject().createTask();
     node->estimate() ->clear();
 
     SubTaskAddDialog *dia = new SubTaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotAddSubMilestoneFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotAddSubMilestoneFinished( int result )
 {
     SubTaskAddDialog *dia = qobject_cast<SubTaskAddDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         MacroCommand *c = new MacroCommand( kundo2_i18n( "Add sub-milestone" ) );
         c->addCommand( dia->buildCommand() );
         getPart() ->addCommand( c ); // add task to project
     }
     dia->deleteLater();
 }
 
 void View::slotDefineWBS()
 {
     //debugPlan;
     Project &p = getProject();
     WBSDefinitionDialog *dia = new WBSDefinitionDialog( p, p.wbsDefinition(), this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotDefineWBSFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotDefineWBSFinished( int result )
 {
     //debugPlan;
     WBSDefinitionDialog *dia = qobject_cast<WBSDefinitionDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted ) {
         KUndo2Command *cmd = dia->buildCommand();
         if ( cmd ) {
             getPart()->addCommand( cmd );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotConfigure()
 {
     //debugPlan;
     if( KConfigDialog::showDialog("Plan Settings") ) {
         return;
     }
     ConfigDialog *dialog = new ConfigDialog( this, "Plan Settings", KPlatoSettings::self() );
     dialog->addPage(new ConfigProjectPanel(), i18n("Project Defaults"), koIconName("calligraplan") );
     dialog->addPage(new ConfigWorkVacationPanel(), i18n("Work & Vacation"), koIconName("view-calendar") );
     dialog->addPage(new TaskDefaultPanel(), i18n("Task Defaults"), koIconName("view-task") );
     dialog->addPage(new ColorsConfigPanel(), i18n("Task Colors"), koIconName("fill-color") );
     dialog->addPage(new WorkPackageConfigPanel(), i18n("Work Package"), koIconName("calligraplanwork") );
     dialog->show();
 
 }
 
 void View::slotIntroduction()
 {
     m_tab->setCurrentIndex(0);
 }
 
 
 Calendar *View::currentCalendar()
 {
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v == 0 ) {
         return 0;
     }
     return v->currentCalendar();
 }
 
 Node *View::currentNode() const
 {
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v == 0 ) {
         return 0;
     }
     Node * task = v->currentNode();
     if ( 0 != task ) {
         return task;
     }
     return &( getProject() );
 }
 
 Task *View::currentTask() const
 {
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v == 0 ) {
         return 0;
     }
     Node * task = v->currentNode();
     if ( task ) {
         return dynamic_cast<Task*>( task );
     }
     return 0;
 }
 
 Resource *View::currentResource()
 {
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v == 0 ) {
         return 0;
     }
     return v->currentResource();
 }
 
 ResourceGroup *View::currentResourceGroup()
 {
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v == 0 ) {
         return 0;
     }
     return v->currentResourceGroup();
 }
 
 
 void View::slotOpenNode()
 {
     //debugPlan;
     Node * node = currentNode();
     slotOpenNode( node );
 }
 
 void View::slotOpenNode( Node *node )
 {
     //debugPlan;
     if ( !node )
         return ;
 
     switch ( node->type() ) {
         case Node::Type_Project: {
                 Project * project = static_cast<Project *>( node );
                 MainProjectDialog *dia = new MainProjectDialog( *project, this );
                 connect(dia, SIGNAL(dialogFinished(int)), SLOT(slotProjectEditFinished(int)));
                 connect(dia, SIGNAL(sigLoadSharedResources(const QString&, const QUrl&, bool)), this, SLOT(slotInsertResourcesFile(const QString&, const QUrl&)));
                 connect(dia, &MainProjectDialog::loadResourceAssignments, getPart(), &MainDocument::loadResourceAssignments);
                 connect(dia, &MainProjectDialog::clearResourceAssignments, getPart(), &MainDocument::clearResourceAssignments);
                 dia->show();
                 dia->raise();
                 dia->activateWindow();
                 break;
             }
         case Node::Type_Subproject:
             //TODO
             break;
         case Node::Type_Task: {
                 Task *task = static_cast<Task *>( node );
                 TaskDialog *dia = new TaskDialog( getProject(), *task, getProject().accounts(), this );
                 connect(dia, SIGNAL(finished(int)), SLOT(slotTaskEditFinished(int)));
                 dia->show();
                 dia->raise();
                 dia->activateWindow();
                 break;
             }
         case Node::Type_Milestone: {
                 // Use the normal task dialog for now.
                 // Maybe milestone should have it's own dialog, but we need to be able to
                 // enter a duration in case we accidentally set a tasks duration to zero
                 // and hence, create a milestone
                 Task *task = static_cast<Task *>( node );
                 TaskDialog *dia = new TaskDialog( getProject(), *task, getProject().accounts(), this );
                 connect(dia, SIGNAL(finished(int)), SLOT(slotTaskEditFinished(int)));
                 dia->show();
                 dia->raise();
                 dia->activateWindow();
                 break;
             }
         case Node::Type_Summarytask: {
                 Task *task = dynamic_cast<Task *>( node );
                 Q_ASSERT( task );
                 SummaryTaskDialog *dia = new SummaryTaskDialog( *task, this );
                 connect(dia, SIGNAL(finished(int)), SLOT(slotSummaryTaskEditFinished(int)));
                 dia->show();
                 dia->raise();
                 dia->activateWindow();
                 break;
             }
         default:
             break; // avoid warnings
     }
 }
 
 void View::slotProjectEditFinished( int result )
 {
     MainProjectDialog *dia = qobject_cast<MainProjectDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * cmd = dia->buildCommand();
         if ( cmd ) {
             getPart() ->addCommand( cmd );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotTaskEditFinished( int result )
 {
     TaskDialog *dia = qobject_cast<TaskDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * cmd = dia->buildCommand();
         if ( cmd ) {
             getPart() ->addCommand( cmd );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotSummaryTaskEditFinished( int result )
 {
     SummaryTaskDialog *dia = qobject_cast<SummaryTaskDialog*>( sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * cmd = dia->buildCommand();
         if ( cmd ) {
             getPart() ->addCommand( cmd );
         }
     }
     dia->deleteLater();
 }
 
 ScheduleManager *View::currentScheduleManager() const
 {
     Schedule *s = m_scheduleActions.value( m_scheduleActionGroup->checkedAction() );
     return s == 0 ? 0 : s->manager();
 }
 
 long View::activeScheduleId() const
 {
     Schedule *s = m_scheduleActions.value( m_scheduleActionGroup->checkedAction() );
     return s == 0 ? -1 : s->id();
 }
 
 void View::setActiveSchedule( long id )
 {
     if ( id != -1 ) {
         QMap<QAction*, Schedule*>::const_iterator it = m_scheduleActions.constBegin();
         for (; it != m_scheduleActions.constEnd(); ++it ) {
             if ( it.value()->id() == id ) {
                 it.key()->setChecked( true );
                 slotViewSchedule( it.key() ); // signal not emitted from group, so trigger it here
                 break;
             }
         }
     }
 }
 
 void View::slotTaskProgress()
 {
     //debugPlan;
     Node * node = currentNode();
     if ( !node )
         return ;
 
     switch ( node->type() ) {
         case Node::Type_Project: {
                 break;
             }
         case Node::Type_Subproject:
             //TODO
             break;
         case Node::Type_Task: {
                 Task *task = dynamic_cast<Task *>( node );
                 Q_ASSERT( task );
                 TaskProgressDialog *dia = new TaskProgressDialog( *task, currentScheduleManager(),  getProject().standardWorktime(), this );
                 connect(dia, SIGNAL(finished(int)), SLOT(slotTaskProgressFinished(int)));
                 dia->show();
                 dia->raise();
                 dia->activateWindow();
                 break;
             }
         case Node::Type_Milestone: {
                 Task *task = dynamic_cast<Task *>( node );
                 Q_ASSERT( task );
                 MilestoneProgressDialog *dia = new MilestoneProgressDialog( *task, this );
                 connect(dia, SIGNAL(finished(int)), SLOT(slotMilestoneProgressFinished(int)));
                 dia->show();
                 dia->raise();
                 dia->activateWindow();
                 break;
             }
         case Node::Type_Summarytask: {
                 // TODO
                 break;
             }
         default:
             break; // avoid warnings
     }
 }
 
 void View::slotTaskProgressFinished( int result )
 {
     TaskProgressDialog *dia = qobject_cast<TaskProgressDialog*>(sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * m = dia->buildCommand();
         if ( m ) {
             getPart() ->addCommand( m );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotMilestoneProgressFinished( int result )
 {
     MilestoneProgressDialog *dia = qobject_cast<MilestoneProgressDialog*>(sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * m = dia->buildCommand();
         if ( m ) {
             getPart() ->addCommand( m );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotTaskDescription()
 {
     //debugPlan;
     Node * node = currentNode();
     if ( !node )
         return ;
 
     switch ( node->type() ) {
         case Node::Type_Project: {
                 break;
             }
         case Node::Type_Subproject:
             //TODO
             break;
         case Node::Type_Task:
         case Node::Type_Milestone:
         case Node::Type_Summarytask: {
                 Task *task = dynamic_cast<Task *>( node );
                 Q_ASSERT( task );
                 TaskDescriptionDialog *dia = new TaskDescriptionDialog( *task, this );
                 connect(dia, SIGNAL(finished(int)), SLOT(slotTaskDescriptionFinished(int)));
                 dia->show();
                 dia->raise();
                 dia->activateWindow();
                 break;
             }
         default:
             break; // avoid warnings
     }
 }
 
 void View::slotTaskDescriptionFinished( int result )
 {
     TaskDescriptionDialog *dia = qobject_cast<TaskDescriptionDialog*>(sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * m = dia->buildCommand();
         if ( m ) {
             getPart() ->addCommand( m );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotDeleteTask( QList<Node*> lst )
 {
     //debugPlan;
     foreach ( Node *n, lst ) {
         if ( n->isScheduled() ) {
             KMessageBox::ButtonCode res = KMessageBox::warningContinueCancel( this, i18n( "A task that has been scheduled will be deleted. This will invalidate the schedule." ) );
             if ( res == KMessageBox::Cancel ) {
                 return;
             }
             break;
         }
     }
     if ( lst.count() == 1 ) {
         getPart()->addCommand( new NodeDeleteCmd( lst.takeFirst(), kundo2_i18n( "Delete task" ) ) );
         return;
     }
     int num = 0;
     MacroCommand *cmd = new MacroCommand( kundo2_i18np( "Delete task", "Delete tasks", lst.count() ) );
     while ( !lst.isEmpty() ) {
         Node *node = lst.takeFirst();
         if ( node == 0 || node->parentNode() == 0 ) {
             debugPlan << ( node ?"Task is main project" :"No current task" );
             continue;
         }
         bool del = true;
         foreach ( Node *n, lst ) {
             if ( node->isChildOf( n ) ) {
                 del = false; // node is going to be deleted when we delete n
                 break;
             }
         }
         if ( del ) {
             //debugPlan<<num<<": delete:"<<node->name();
             cmd->addCommand( new NodeDeleteCmd( node, kundo2_i18n( "Delete task" ) ) );
             num++;
         }
     }
     if ( num > 0 ) {
         getPart()->addCommand( cmd );
     } else {
         delete cmd;
     }
 }
 
 void View::slotDeleteTask( Node *node )
 {
     //debugPlan;
     if ( node == 0 || node->parentNode() == 0 ) {
         debugPlan << ( node ?"Task is main project" :"No current task" );
         return ;
     }
     if ( node->isScheduled() ) {
         KMessageBox::ButtonCode res = KMessageBox::warningContinueCancel( this, i18n( "This task has been scheduled. This will invalidate the schedule." ) );
         if ( res == KMessageBox::Cancel ) {
             return;
         }
     }
     NodeDeleteCmd *cmd = new NodeDeleteCmd( node, kundo2_i18n( "Delete task" ) );
     getPart() ->addCommand( cmd );
 }
 
 void View::slotDeleteTask()
 {
     //debugPlan;
     return slotDeleteTask( currentNode() );
 }
 
 void View::slotIndentTask()
 {
     //debugPlan;
     Node * node = currentNode();
     if ( node == 0 || node->parentNode() == 0 ) {
         debugPlan << ( node ?"Task is main project" :"No current task" );
         return ;
     }
     if ( getProject().canIndentTask( node ) ) {
         NodeIndentCmd * cmd = new NodeIndentCmd( *node, kundo2_i18n( "Indent task" ) );
         getPart() ->addCommand( cmd );
     }
 }
 
 void View::slotUnindentTask()
 {
     //debugPlan;
     Node * node = currentNode();
     if ( node == 0 || node->parentNode() == 0 ) {
         debugPlan << ( node ?"Task is main project" :"No current task" );
         return ;
     }
     if ( getProject().canUnindentTask( node ) ) {
         NodeUnindentCmd * cmd = new NodeUnindentCmd( *node, kundo2_i18n( "Unindent task" ) );
         getPart() ->addCommand( cmd );
     }
 }
 
 void View::slotMoveTaskUp()
 {
     //debugPlan;
 
     Node * task = currentNode();
     if ( 0 == task ) {
         // is always != 0. At least we would get the Project, but you never know who might change that
         // so better be careful
         errorPlan << "No current task" << endl;
         return ;
     }
 
     if ( Node::Type_Project == task->type() ) {
         debugPlan <<"The root node cannot be moved up";
         return ;
     }
     if ( getProject().canMoveTaskUp( task ) ) {
         NodeMoveUpCmd * cmd = new NodeMoveUpCmd( *task, kundo2_i18n( "Move task up" ) );
         getPart() ->addCommand( cmd );
     }
 }
 
 void View::slotMoveTaskDown()
 {
     //debugPlan;
 
     Node * task = currentNode();
     if ( 0 == task ) {
         // is always != 0. At least we would get the Project, but you never know who might change that
         // so better be careful
         return ;
     }
 
     if ( Node::Type_Project == task->type() ) {
         debugPlan <<"The root node cannot be moved down";
         return ;
     }
     if ( getProject().canMoveTaskDown( task ) ) {
         NodeMoveDownCmd * cmd = new NodeMoveDownCmd( *task, kundo2_i18n( "Move task down" ) );
         getPart() ->addCommand( cmd );
     }
 }
 
 void View::slotAddRelation( Node *par, Node *child )
 {
     //debugPlan;
     Relation * rel = new Relation( par, child );
     AddRelationDialog *dia = new AddRelationDialog( getProject(), rel, this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotAddRelationFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotAddRelationFinished( int result )
 {
     AddRelationDialog *dia = qobject_cast<AddRelationDialog*>(sender() );
     if ( dia == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * m = dia->buildCommand();
         if ( m ) {
             getPart() ->addCommand( m );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotAddRelation( Node *par, Node *child, int linkType )
 {
     //debugPlan;
     if ( linkType == Relation::FinishStart ||
             linkType == Relation::StartStart ||
             linkType == Relation::FinishFinish ) {
         Relation * rel = new Relation( par, child, static_cast<Relation::Type>( linkType ) );
         getPart() ->addCommand( new AddRelationCmd( getProject(), rel, kundo2_i18n( "Add task dependency" ) ) );
     } else {
         slotAddRelation( par, child );
     }
 }
 
 void View::slotModifyRelation( Relation *rel )
 {
     //debugPlan;
     ModifyRelationDialog *dia = new ModifyRelationDialog( getProject(), rel, this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotModifyRelationFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotModifyRelationFinished( int result )
 {
     ModifyRelationDialog *dia = qobject_cast<ModifyRelationDialog*>( sender() );
     if ( dia == 0 ) {
         return ;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command *cmd = dia->buildCommand();
         if ( cmd ) {
             getPart() ->addCommand( cmd );
         }
     }
     dia->deleteLater();
 }
 
 void View::slotModifyRelation( Relation *rel, int linkType )
 {
     //debugPlan;
     if ( linkType == Relation::FinishStart ||
             linkType == Relation::StartStart ||
             linkType == Relation::FinishFinish ) {
         getPart() ->addCommand( new ModifyRelationTypeCmd( rel, static_cast<Relation::Type>( linkType ) ) );
     } else {
         slotModifyRelation( rel );
     }
 }
 
 void View::slotModifyRelation()
 {
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v == 0 ) {
         return;
     }
     Relation *rel = v->currentRelation();
     if ( rel ) {
         slotModifyRelation( rel );
     }
 }
 
 void View::slotDeleteRelation()
 {
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v == 0 ) {
         return;
     }
     Relation *rel = v->currentRelation();
     if ( rel ) {
         getPart()->addCommand( new DeleteRelationCmd( getProject(), rel, kundo2_i18n( "Delete task dependency" ) ) );
     }
 }
 
 void View::slotEditResource()
 {
     //debugPlan;
     slotEditResource( currentResource() );
 }
 
 void View::slotEditResource( Resource *resource )
 {
     if ( resource == 0 ) {
         return ;
     }
     ResourceDialog *dia = new ResourceDialog( getProject(), resource, this );
     connect(dia, SIGNAL(finished(int)), SLOT(slotEditResourceFinished(int)));
     dia->show();
     dia->raise();
     dia->activateWindow();
 }
 
 void View::slotEditResourceFinished( int result )
 {
     //debugPlan;
     ResourceDialog *dia = qobject_cast<ResourceDialog*>( sender() );
     if ( dia == 0 ) {
         return ;
     }
     if ( result == QDialog::Accepted) {
         KUndo2Command * cmd = dia->buildCommand();
         if ( cmd )
             getPart() ->addCommand( cmd );
     }
     dia->deleteLater();
 }
 
 void View::slotDeleteResource( Resource *resource )
 {
     getPart()->addCommand( new RemoveResourceCmd( resource->parentGroup(), resource, kundo2_i18n( "Delete resource" ) ) );
 }
 
 void View::slotDeleteResourceGroup( ResourceGroup *group )
 {
     getPart()->addCommand( new RemoveResourceGroupCmd( group->project(), group, kundo2_i18n( "Delete resourcegroup" ) ) );
 }
 
 void View::slotDeleteResourceObjects( QObjectList lst )
 {
     //debugPlan;
     foreach ( QObject *o, lst ) {
         Resource *r = qobject_cast<Resource*>( o );
         if ( r && r->isScheduled() ) {
             KMessageBox::ButtonCode res = KMessageBox::warningContinueCancel( this, i18n( "A resource that has been scheduled will be deleted. This will invalidate the schedule." ) );
             if ( res == KMessageBox::Cancel ) {
                 return;
             }
             break;
         }
         ResourceGroup *g = qobject_cast<ResourceGroup*>( o );
         if ( g && g->isScheduled() ) {
             KMessageBox::ButtonCode res = KMessageBox::warningContinueCancel( this, i18n( "A resource that has been scheduled will be deleted. This will invalidate the schedule." ) );
             if ( res == KMessageBox::Cancel ) {
                 return;
             }
             break;
         }
     }
     if ( lst.count() == 1 ) {
         Resource *r = qobject_cast<Resource*>( lst.first() );
         if ( r ) {
             slotDeleteResource( r );
         } else {
             ResourceGroup *g = qobject_cast<ResourceGroup*>( lst.first() );
             if ( g ) {
                 slotDeleteResourceGroup( g );
             }
         }
         return;
     }
 //    int num = 0;
     MacroCommand *cmd = 0, *rc = 0, *gc = 0;
     foreach ( QObject *o, lst ) {
         Resource *r = qobject_cast<Resource*>( o );
         if ( r ) {
             if ( rc == 0 )  rc = new MacroCommand( KUndo2MagicString() );
             rc->addCommand( new RemoveResourceCmd( r->parentGroup(), r ) );
             continue;
         }
         ResourceGroup *g = qobject_cast<ResourceGroup*>( o );
         if ( g ) {
             if ( gc == 0 )  gc = new MacroCommand( KUndo2MagicString() );
             gc->addCommand( new RemoveResourceGroupCmd( g->project(), g ) );
         }
     }
     if ( rc || gc ) {
         KUndo2MagicString s;
         if ( rc && gc ) {
             s = kundo2_i18n( "Delete resourcegroups and resources" );
         } else if ( rc ) {
             s = kundo2_i18np( "Delete resource", "Delete resources", lst.count() );
         } else {
             s = kundo2_i18np( "Delete resourcegroup", "Delete resourcegroups", lst.count() );
         }
         cmd = new MacroCommand( s );
     }
     if ( rc )
         cmd->addCommand( rc );
     if ( gc )
         cmd->addCommand( gc );
     if ( cmd )
         getPart()->addCommand( cmd );
 }
 
 
 void View::updateReadWrite( bool readwrite )
 {
     m_readWrite = readwrite;
     m_viewlist->setReadWrite( readwrite );
 }
 
 MainDocument *View::getPart() const
 {
     return ( MainDocument * ) koDocument();
 }
 
 KoPart *View::getKoPart() const
 {
     return m_partpart;
 }
 
 void View::slotConnectNode()
 {
     //debugPlan;
     /*    NodeItem *curr = ganttview->currentItem();
         if (curr) {
             debugPlan<<"node="<<curr->getNode().name();
         }*/
 }
 
 QMenu * View::popupMenu( const QString& name )
 {
     //debugPlan;
     if ( factory() ) {
         return ( ( QMenu* ) factory() ->container( name, this ) );
     }
     debugPlan<<"No factory";
     return 0L;
 }
 
 void View::slotUpdate()
 {
     //debugPlan<<"calculate="<<calculate;
 
 //    m_updateResourceview = true;
     m_updateResourceAssignmentView = true;
     m_updatePertEditor = true;
     updateView( m_tab->currentWidget() );
 }
 
 void View::slotGuiActivated( ViewBase *view, bool activate )
 {
     //FIXME: Avoid unplug if possible, it flashes the gui
     // always unplug, in case they already are plugged
     foreach( const QString &name, view->actionListNames() ) {
         unplugActionList( name );
     }
     if ( activate ) {
         foreach( const QString &name, view->actionListNames() ) {
             plugActionList( name, view->actionList( name ) );
         }
         foreach ( DockWidget *ds, view->dockers() ) {
             m_dockers.append( ds );
             ds->activate( mainWindow() );
         }
         if (!m_dockers.isEmpty()) {debugPlan<<"Added dockers:"<<view<<m_dockers;}
     } else {
         if (!m_dockers.isEmpty()) {debugPlan<<"Remove dockers:"<<view<<m_dockers;}
         while ( ! m_dockers.isEmpty() ) {
             m_dockers.takeLast()->deactivate( mainWindow() );
         }
     }
 }
 
 void View::guiActivateEvent( bool activated )
 {
     if ( activated ) {
         // plug my own actionlists, they may be gone
         slotPlugScheduleActions();
     }
     // propagate to sub-view
     ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
     if ( v ) {
         v->setGuiActive( activated );
     }
 }
 
 void View::slotViewListItemRemoved( ViewListItem *item )
 {
     getPart()->removeViewListItem( this, item );
 }
 
 void View::removeViewListItem( const ViewListItem *item )
 {
     if ( item == 0 ) {
         return;
     }
     ViewListItem *itm = m_viewlist->findItem( item->tag() );
     if ( itm == 0 ) {
         return;
     }
     m_viewlist->removeViewListItem( itm );
     return;
 }
 
 void View::slotViewListItemInserted( ViewListItem *item, ViewListItem *parent, int index )
 {
     getPart()->insertViewListItem( this, item, parent, index );
 }
 
 void View::addViewListItem( const ViewListItem *item, const ViewListItem *parent, int index )
 {
     if ( item == 0 ) {
         return;
     }
     if ( parent == 0 ) {
         if ( item->type() != ViewListItem::ItemType_Category ) {
             return;
         }
         m_viewlist->blockSignals( true );
         ViewListItem *cat = m_viewlist->addCategory( item->tag(), item->text( 0 ) );
         cat->setToolTip( 0, item->toolTip( 0 ) );
         m_viewlist->blockSignals( false );
         return;
     }
     ViewListItem *cat = m_viewlist->findCategory( parent->tag() );
     if ( cat == 0 ) {
         return;
     }
     m_viewlist->blockSignals( true );
     createView( cat, item->viewType(), item->tag(), item->text( 0 ), item->toolTip( 0 ), index );
     m_viewlist->blockSignals( false );
 }
 
 void View::createReportView(const QDomDocument &doc)
 {
 #ifdef PLAN_USE_KREPORT
     QPointer<ViewListReportsDialog> vd = new ViewListReportsDialog( this, *m_viewlist, doc, this );
     vd->exec(); // FIXME  make non-crash
     delete vd;
 #endif
 }
 
 void View::slotOpenReportFile()
 {
 #ifdef PLAN_USE_KREPORT
     QFileDialog *dlg = new QFileDialog(this);
     connect(dlg, SIGNAL(finished(int)), SLOT(slotOpenReportFileFinished(int)));
     dlg->show();
     dlg->raise();
     dlg->activateWindow();
 #endif
 }
 
 void View::slotOpenReportFileFinished( int result )
 {
 #ifdef PLAN_USE_KREPORT
     QFileDialog *fdlg = qobject_cast<QFileDialog*>( sender() );
     if ( fdlg == 0 || result != QDialog::Accepted ) {
         return;
     }
     QString fn = fdlg->selectedFiles().value(0);
     if ( fn.isEmpty() ) {
         return;
     }
     QFile file( fn );
     if ( ! file.open( QIODevice::ReadOnly | QIODevice::Text ) ) {
         KMessageBox::sorry( this, xi18nc( "@info", "Cannot open file:<br/><filename>%1</filename>", fn ) );
         return;
     }
     QDomDocument doc;
     doc.setContent( &file );
     createReportView(doc);
 #endif
 }
 
 void View::slotReportDesignFinished( int /*result */)
 {
 #ifdef PLAN_USE_KREPORT
     if ( sender() ) {
         sender()->deleteLater();
     }
 #endif
 }
 
 void View::slotCreateView()
 {
     ViewListDialog *dlg = new ViewListDialog( this, *m_viewlist, this );
     connect(dlg, SIGNAL(finished(int)), SLOT(slotCreateViewFinished(int)));
     dlg->show();
     dlg->raise();
     dlg->activateWindow();
 }
 
 void View::slotCreateViewFinished( int )
 {
     if ( sender() ) {
         sender()->deleteLater();
     }
 }
 
 void View::slotViewActivated( ViewListItem *item, ViewListItem *prev )
 {
     QApplication::setOverrideCursor( Qt::WaitCursor );
     if ( prev && prev->type() == ViewListItem::ItemType_Category && m_viewlist->previousViewItem() ) {
         // A view is shown anyway...
         ViewBase *v = qobject_cast<ViewBase*>( m_viewlist->previousViewItem()->view() );
         if ( v ) {
             v->setGuiActive( false );
         }
     } else if ( prev && prev->type() == ViewListItem::ItemType_SubView ) {
         ViewBase *v = qobject_cast<ViewBase*>( prev->view() );
         if ( v ) {
             v->setGuiActive( false );
         }
     }
     if ( item && item->type() == ViewListItem::ItemType_SubView ) {
         //debugPlan<<"Activate:"<<item;
         m_tab->setCurrentWidget( item->view() );
         // Add sub-view specific gui
         ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() );
         if ( v ) {
             v->setGuiActive( true );
         }
     }
     QApplication::restoreOverrideCursor();
 }
 
 QWidget *View::canvas() const
 {
     return m_tab->currentWidget();//KoView::canvas();
 }
 
 KoPageLayout View::pageLayout() const
 {
     return currentView()->pageLayout();
 }
 
 QPrintDialog *View::createPrintDialog( KoPrintJob *printJob, QWidget *parent )
 {
     debugPlan<<printJob;
     KoPrintingDialog *job = dynamic_cast<KoPrintingDialog*>( printJob );
     if ( ! job ) {
         return 0;
     }
     QPrintDialog *dia = KoView::createPrintDialog( job, parent );
 
     PrintingDialog *j = dynamic_cast<PrintingDialog*>( job );
     if ( j ) {
         new PrintingControlPrivate( j, dia );
     }
     return dia;
 }
 
 void View::slotCurrentChanged( int view )
 {
     m_visitedViews << view;
     ViewListItem *item = m_viewlist->findItem( qobject_cast<ViewBase*>( m_tab->currentWidget() ) );
     m_viewlist->setCurrentItem( item );
 }
 
 void View::slotSelectDefaultView()
 {
     m_tab->setCurrentIndex(qMin(m_defaultView, m_tab->count()-1));
 }
 
 void View::updateView( QWidget * )
 {
     QApplication::setOverrideCursor( Qt::WaitCursor );
     //setScheduleActionsEnabled();
 
     QWidget *widget2;
 
     widget2 = m_viewlist->findView( "ResourceAssignmentView" );
     if ( widget2 && m_updateResourceAssignmentView )
         static_cast<ViewBase*>( widget2 ) ->draw( getProject() );
     m_updateResourceAssignmentView = false;
 
     QApplication::restoreOverrideCursor();
 }
 
 void View::slotRenameNode( Node *node, const QString& name )
 {
     //debugPlan<<name;
     if ( node ) {
         KUndo2MagicString s = kundo2_i18n( "Modify name" );
         switch( node->type() ) {
             case Node::Type_Task: s = kundo2_i18n( "Modify task name" ); break;
             case Node::Type_Milestone: s = kundo2_i18n( "Modify milestone name" ); break;
             case Node::Type_Summarytask: s = kundo2_i18n( "Modify summarytask name" ); break;
             case Node::Type_Project: s = kundo2_i18n( "Modify project name" ); break;
         }
         NodeModifyNameCmd * cmd = new NodeModifyNameCmd( *node, name, s );
         getPart() ->addCommand( cmd );
     }
 }
 
 void View::slotPopupMenu( const QString& menuname, const QPoint & pos )
 {
     QMenu * menu = this->popupMenu( menuname );
     if ( menu ) {
         //debugPlan<<menu<<":"<<menu->actions().count();
         ViewBase *v = qobject_cast<ViewBase*>( m_tab->currentWidget() );
         //debugPlan<<v<<menuname;
         QList<QAction*> lst;
         if ( v ) {
             lst = v->contextActionList();
             debugPlan<<lst;
             if ( ! lst.isEmpty() ) {
                 menu->addSeparator();
                 foreach ( QAction *a, lst ) {
                     menu->addAction( a );
                 }
             }
         }
         menu->exec( pos );
         foreach ( QAction *a, lst ) {
             menu->removeAction( a );
         }
     }
 }
 
 void View::slotPopupMenu( const QString& menuname, const QPoint &pos, ViewListItem *item )
 {
     //debugPlan<<menuname;
     m_viewlistItem = item;
     slotPopupMenu( menuname, pos );
 }
 
 bool View::loadContext()
 {
     Context *ctx = getPart()->context();
     if ( ctx == 0 || ! ctx->isLoaded() ) {
         return false;
     }
     KoXmlElement n = ctx->context();
     QString cv = n.attribute( "current-view" );
     if ( ! cv.isEmpty() ) {
         m_viewlist->setSelected( m_viewlist->findItem( cv ) );
     } else debugPlan<<"No current view";
 
     long id = n.attribute( "current-schedule", "-1" ).toLong();
     if ( id != -1 ) {
         setActiveSchedule( id );
     } else debugPlan<<"No current schedule";
 
     return true;
 }
 
 void View::saveContext( QDomElement &me ) const
 {
     //debugPlan;
     long id = activeScheduleId();
     if ( id != -1 ) {
         me.setAttribute( "current-schedule", QString::number((qlonglong)id) );
     }
     ViewListItem *item = m_viewlist->findItem( qobject_cast<ViewBase*>( m_tab->currentWidget() ) );
     if ( item ) {
         me.setAttribute("current-view", item->tag() );
     }
     m_viewlist->save( me );
 }
 
 bool View::loadWorkPackage( Project &project, const QUrl &url )
 {
     return getPart()->loadWorkPackage( project, url );
 }
 
 void View::setLabel( ScheduleManager *sm )
 {
     //debugPlan;
     Schedule *s = sm == 0 ? 0 : sm->expected();
     if ( s && !s->isDeleted() && s->isScheduled() ) {
         m_estlabel->setText( sm->name() );
         return;
     }
     m_estlabel->setText( xi18nc( "@info:status", "Not scheduled" ) );
 }
 
 void View::slotWorkPackageLoaded()
 {
     debugPlan<<getPart()->workPackages();
 }
 
 void View::slotMailWorkpackage( Node *node, Resource *resource )
 {
     debugPlan;
     QTemporaryFile tmpfile(QDir::tempPath() + QLatin1String("/calligraplanwork_XXXXXX") + QLatin1String( ".planwork" ));
     tmpfile.setAutoRemove( false );
     if ( ! tmpfile.open() ) {
         debugPlan<<"Failed to open file";
         KMessageBox::error(0, i18n("Failed to open temporary file" ) );
         return;
     }
     QUrl url = QUrl::fromLocalFile( tmpfile.fileName() );
     if ( ! getPart()->saveWorkPackageUrl( url, node, activeScheduleId(), resource ) ) {
         debugPlan<<"Failed to save to file";
         KMessageBox::error(0, xi18nc( "@info", "Failed to save to temporary file:<br/> <filename>%1</filename>", url.url() ) );
         return;
     }
     QStringList attachURLs;
     attachURLs << url.url();
     QString to = resource == 0 ? node->leader() : ( resource->name() + " <" + resource->email() + '>' );
     QString cc;
     QString bcc;
     QString subject = i18n( "Work Package: %1", node->name() );
     QString body = i18nc( "1=project name, 2=task name", "%1\n%2", getProject().name(), node->name() );
     QString messageFile;
 
     KToolInvocation::invokeMailer( to, cc, bcc, subject, body, messageFile, attachURLs );
 }
 
 void View::slotMailWorkpackages( const QList<Node*> &nodes, Resource *resource )
 {
     debugPlan;
     if ( resource == 0 ) {
         warnPlan<<"No resource, we don't handle node->leader() yet";
         return;
     }
     QString to = resource->name() + " <" + resource->email() + '>';
     QString subject = i18n( "Work Package for project: %1", getProject().name() );
     QString body;
     QStringList attachURLs;
 
     foreach ( Node *n, nodes ) {
         QTemporaryFile tmpfile(QDir::tempPath() + QLatin1String("/calligraplanwork_XXXXXX") + QLatin1String( ".planwork" ));
         tmpfile.setAutoRemove( false );
         if ( ! tmpfile.open() ) {
             debugPlan<<"Failed to open file";
             KMessageBox::error(0, i18n("Failed to open temporary file" ) );
             return;
         }
         QUrl url = QUrl::fromLocalFile( tmpfile.fileName() );
         if ( ! getPart()->saveWorkPackageUrl( url, n, activeScheduleId(), resource ) ) {
             debugPlan<<"Failed to save to file";
             KMessageBox::error(0, xi18nc( "@info", "Failed to save to temporary file:<br/><filename>%1</filename>", url.url() ) );
             return;
         }
         attachURLs << url.url();
         body += n->name() + '\n';
     }
 
     QString cc;
     QString bcc;
     QString messageFile;
 
     KToolInvocation::invokeMailer( to, cc, bcc, subject, body, messageFile, attachURLs );
 }
 
 void View::slotCurrencyConfig()
 {
     LocaleConfigMoneyDialog *dlg = new LocaleConfigMoneyDialog( getProject().locale(), this );
     connect(dlg, SIGNAL(finished(int)), SLOT(slotCurrencyConfigFinished(int)));
     dlg->show();
     dlg->raise();
     dlg->activateWindow();
 }
 
 void View::slotCurrencyConfigFinished( int result )
 {
     LocaleConfigMoneyDialog *dlg = qobject_cast<LocaleConfigMoneyDialog*>( sender() );
     if ( dlg == 0 ) {
         return;
     }
     if ( result == QDialog::Accepted ) {
         KUndo2Command *c = dlg->buildCommand( getProject() );
         if ( c ) {
             getPart()->addCommand( c );
         }
     }
     dlg->deleteLater();
 }
 
 void View::saveTaskModule( const QUrl &url, Project *project )
 {
     // NOTE: workaround: KoResourcePaths::saveLocation( "calligraplan_taskmodules" ); does not work
     const QString dir = KoResourcePaths::saveLocation( "appdata", "taskmodules/" );
     debugPlan<<"dir="<<dir;
     if ( ! dir.isEmpty() ) {
         Part *part = new Part( this );
         MainDocument *doc = new MainDocument( part );
         part->setDocument( doc );
         doc->disconnect(); // doc shall not handle feedback from openUrl()
         doc->setAutoSave( 0 ); //disable
         doc->insertProject( *project, 0, 0 ); // FIXME: destroys project, find better way
         doc->getProject().setName( project->name() );
         doc->getProject().setLeader( project->leader() );
         doc->getProject().setDescription( project->description() );
         doc->saveNativeFormat( dir + url.fileName() );
         part->deleteLater(); // also deletes document
         debugPlan<<dir + url.fileName();
     } else {
         debugPlan<<"Could not find a location";
     }
 }
 
 void View::removeTaskModule( const QUrl &url )
 {
     debugPlan<<url;
 }
 
+void View::taskModuleFileChanged(const QString &path)
+{
+    if (!path.endsWith(".plan")) {
+        return;
+    }
+    m_dirwatch.stopScan();
+    int result = QMessageBox::question(this, xi18nc("@title", "Task module changed"), i18n("Do you want to reload task modules?"));
+    if (result == QMessageBox::Yes) {
+        QStringList modules = KoResourcePaths::findAllResources( "calligraplan_taskmodules", "*.plan", KoResourcePaths::NoDuplicates|KoResourcePaths::Recursive );
+        emit taskModulesChanged(modules);
+    }
+    m_dirwatch.startScan();
+}
+
 QString View::standardTaskStatusReport() const
 {
     QString s;
 #ifdef PLAN_USE_KREPORT
     s = QString::fromLatin1(
         "<planreportdefinition version=\"1.0\" mime=\"application/x-vnd.kde.plan.report.definition\" editor=\"Plan\" >"
         "<data-source select-from=\"taskstatus\" ></data-source>"
         "<report:content xmlns:report=\"http://kexi-project.org/report/2.0\" xmlns:fo=\"urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0\" xmlns:svg=\"urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0\" >"
         "<report:title>%1</report:title>"
         "<report:script report:script-interpreter=\"javascript\" ></report:script>"
         "<report:grid report:grid-divisions=\"4\" report:grid-snap=\"1\" report:page-unit=\"cm\" report:grid-visible=\"1\" />"
         "<report:page-style report:print-orientation=\"portrait\" fo:margin-bottom=\"1cm\" fo:margin-top=\"1cm\" fo:margin-left=\"1cm\" fo:margin-right=\"1cm\" report:page-size=\"A4\" >predefined</report:page-style>"
         "<report:body>"
         "<report:section svg:height=\"1.75cm\" fo:background-color=\"#ffffff\" report:section-type=\"header-page-any\" >"
         "<report:field report:name=\"field16\" report:horizontal-align=\"left\" report:item-data-source=\"#project.manager\" svg:x=\"13cm\" svg:width=\"5.9714cm\" svg:y=\"0.4cm\" report:vertical-align=\"bottom\" svg:height=\"0.6cm\" report:z-index=\"0\" >"
         "<report:text-style fo:font-weight=\"bold\" fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"10\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:field>"
         "<report:label report:name=\"label16\" report:horizontal-align=\"left\" svg:x=\"13cm\" svg:width=\"5.9714cm\" svg:y=\"0cm\" report:caption=\"%2\" report:vertical-align=\"center\" svg:height=\"0.4cm\" report:z-index=\"1\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:label>"
         "<report:field report:name=\"field17\" report:horizontal-align=\"left\" report:item-data-source=\"#project.name\" svg:x=\"0cm\" svg:width=\"13cm\" svg:y=\"0.4cm\" report:vertical-align=\"bottom\" svg:height=\"0.6cm\" report:z-index=\"1\" >"
         "<report:text-style fo:font-weight=\"bold\" fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"10\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"0%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:field>"
         "<report:label report:name=\"label18\" report:horizontal-align=\"left\" svg:x=\"0cm\" svg:width=\"13cm\" svg:y=\"0cm\" report:caption=\"%3\" report:vertical-align=\"center\" svg:height=\"0.4cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:label>"
         "<report:line report:name=\"line15\" svg:y1=\"1.2229cm\" svg:x1=\"0cm\" svg:y2=\"1.2229cm\" svg:x2=\"18.9715cm\" report:z-index=\"0\" >"
         "<report:line-style report:line-style=\"solid\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:line>"
         "</report:section>"
         "<report:section svg:height=\"1.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"header-report\" >"
         "<report:label report:name=\"label17\" report:horizontal-align=\"left\" svg:x=\"0cm\" svg:width=\"18.97cm\" svg:y=\"0cm\" report:caption=\"%4\" report:vertical-align=\"center\" svg:height=\"1.25cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"10\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:label>"
         "</report:section>"
         "<report:section svg:height=\"2.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"footer-page-any\" >"
         "<report:field report:name=\"field10\" report:horizontal-align=\"right\" report:item-data-source=\"=constants.PageNumber()\" svg:x=\"6.75cm\" svg:width=\"0.75cm\" svg:y=\"0.25cm\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:field>"
         "<report:field report:name=\"field11\" report:horizontal-align=\"left\" report:item-data-source=\"=constants.PageTotal()\" svg:x=\"8.25cm\" svg:width=\"3cm\" svg:y=\"0.25cm\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:field>"
         "<report:label report:name=\"label12\" report:horizontal-align=\"center\" svg:x=\"7.5cm\" svg:width=\"0.75cm\" svg:y=\"0.25cm\" report:caption=\"%5\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:label>"
         "<report:label report:name=\"label13\" report:horizontal-align=\"right\" svg:x=\"5.75cm\" svg:width=\"1cm\" svg:y=\"0.25cm\" report:caption=\"%6\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:label>"
         "<report:line report:name=\"line14\" svg:y1=\"0.2195cm\" svg:x1=\"0cm\" svg:y2=\"0.2195cm\" svg:x2=\"18.9715cm\" report:z-index=\"0\" >"
         "<report:line-style report:line-style=\"solid\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:line>"
         "</report:section>"
         "<report:detail>"
         "<report:group report:group-sort=\"ascending\" report:group-column=\"Parent\" >"
         "<report:section svg:height=\"2.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"group-header\" >"
         "<report:label report:name=\"label6\" report:horizontal-align=\"left\" svg:x=\"0.5cm\" svg:width=\"3.75cm\" svg:y=\"1.75cm\" report:caption=\"%7\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:label>"
         "<report:field report:name=\"field8\" report:horizontal-align=\"left\" report:item-data-source=\"Parent\" svg:x=\"0.5cm\" svg:width=\"8cm\" svg:y=\"1cm\" report:vertical-align=\"center\" svg:height=\"0.689cm\" report:z-index=\"0\" >"
         "<report:text-style fo:font-weight=\"bold\" fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:field>"
         "<report:label report:name=\"label8\" report:horizontal-align=\"center\" svg:x=\"4.25cm\" svg:width=\"4.25cm\" svg:y=\"1.75cm\" report:caption=\"%8\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:label>"
         "</report:section>"
         "</report:group>"
         "<report:section svg:height=\"0.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"detail\" >"
         "<report:field report:name=\"field7\" report:horizontal-align=\"left\" report:item-data-source=\"NodeName\" svg:x=\"0.5cm\" svg:width=\"3.75cm\" svg:y=\"0cm\" report:vertical-align=\"center\" svg:height=\"0.5cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:field>"
         "<report:field report:name=\"field9\" report:horizontal-align=\"center\" report:item-data-source=\"NodeCompleted\" svg:x=\"4.25cm\" svg:width=\"4.25cm\" svg:y=\"0cm\" report:vertical-align=\"center\" svg:height=\"0.5cm\" report:z-index=\"0\" >"
         "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />"
         "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />"
         "</report:field>"
         "</report:section>"
         "</report:detail>"
         "</report:body>"
         "</report:content>"
         "</planreportdefinition>")
         .arg(
             i18n( "Report" ),
             i18nc( "Project manager", "Manager:" ),
             i18n( "Project:" ),
             i18n( "Task Status Report" ),
             i18nc( "As in: Page 1 of 2", "of" ),
             i18n( "Page" ),
             i18nc( "Task name", "Name" ),
             i18nc( "Task completion", "Completion (%)" )
         );
 #endif
     return s;
 }
 
 }  //KPlato namespace
diff --git a/plan/kptview.h b/plan/kptview.h
index 4fa03a83199..6645080d10d 100644
--- a/plan/kptview.h
+++ b/plan/kptview.h
@@ -1,453 +1,458 @@
 /* This file is part of the KDE project
   Copyright (C) 1998, 1999, 2000 Torben Weis <weis@kde.org>
   Copyright (C) 2002 - 2010 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KPTVIEW_H
 #define KPTVIEW_H
 
 #include "kplato_export.h"
 
 #include <KoView.h>
 
 #include "kptcontext.h"
 #include "kptviewbase.h"
 
 #include <QDockWidget>
 #include <QMap>
 
 #include <kconfigdialog.h>
+#include <KDirWatch>
 
 class QMenu;
 class QPrintDialog;
 class QStackedWidget;
 class QSplitter;
 class QUrl;
 class KUndo2Command;
 class QAction;
 
 class KToggleAction;
 class QLabel;
 class KConfigSkeleton;
 class KConfigSkeletonItem;
 
 class KoView;
 
 namespace KPlato
 {
 
 class View;
 class ViewBase;
 class ViewListItem;
 class ViewListWidget;
 struct ViewInfo;
 class AccountsView;
 class GanttView;
 class PertEditor;
 class AccountsEditor;
 class TaskEditor;
 class CalendarEditor;
 class ScheduleEditor;
 class ScheduleManager;
 class CalculateScheduleCmd;
 class ResourceAssignmentView;
 class TaskStatusView;
 class Calendar;
 class MainDocument;
 class Part;
 class Node;
 class Project;
 class Task;
 class MainSchedule;
 class Schedule;
 class Resource;
 class ResourceGroup;
 class Relation;
 class Context;
 class ViewAdaptor;
 class HtmlView;
 class ReportView;
 
 class ReportDesignDialog;
 
 class DockWidget;
 
 class ConfigDialog : public KConfigDialog
 {
     Q_OBJECT
 public:
     ConfigDialog( QWidget *parent, const QString &name, KConfigSkeleton *config );
 
 protected Q_SLOTS:
     /// Return true if any widget has changed
     virtual bool hasChanged();
     /**
     * Update the settings from the dialog.
     * Virtual function for custom additions.
     *
     * Example use: User clicks Ok or Apply button in a configure dialog.
     */
     virtual void updateSettings();
 
     /**
     * Update the dialog based on the settings.
     * Virtual function for custom additions.
     *
     * Example use: Initialisation of dialog.
     * Example use: User clicks Reset button in a configure dialog.
     */
     virtual void updateWidgets();
 
     /**
     * Update the dialog based on the default settings.
     * Virtual function for custom additions.
     *
     * Example use: User clicks Defaults button in a configure dialog.
     */
     virtual void updateWidgetsDefault();
 
   /**
    * Returns whether the current state of the dialog is
    * the same as the default configuration.
    */
   virtual bool isDefault();
 
 private:
     KConfigSkeleton *m_config;
     QMap<QString, QByteArray> m_signalsmap;
     QMap<QWidget*, KConfigSkeletonItem*> m_itemmap;
     QMap<QString, QByteArray> m_propertymap;
 };
 
 //-------------
 class KPLATO_EXPORT View : public KoView
 {
     Q_OBJECT
 
 public:
     explicit View(KoPart *part, MainDocument *doc, QWidget *parent = 0);
     ~View();
 
     MainDocument *getPart() const;
 
     KoPart *getKoPart() const;
 
     Project& getProject() const;
 
     QMenu *popupMenu( const QString& name );
 
     virtual bool loadContext();
     virtual void saveContext( QDomElement &context ) const;
 
     /// Load the workpackage from @p url into @p project. Return true if successful, else false.
     bool loadWorkPackage( Project &project, const QUrl &url );
 
     QWidget *canvas() const;
 
     KoPageLayout pageLayout() const;
 
     ScheduleManager *currentScheduleManager() const;
     long activeScheduleId() const;
     void setActiveSchedule( long id );
 
     /// Returns the default view information like standard name and tooltip for view type @p type
     ViewInfo defaultViewInfo( const QString &type ) const;
     /// Returns the default category information like standard name and tooltip for category type @p type
     ViewInfo defaultCategoryInfo( const QString &type ) const;
 
     ViewBase *createTaskEditor( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createResourceEditor( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createAccountsEditor( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createCalendarEditor( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createScheduleHandler( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ScheduleEditor *createScheduleEditor( QWidget *parent );
     ViewBase *createScheduleEditor( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createDependencyEditor( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createPertEditor( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createProjectStatusView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createPerformanceStatusView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createTaskStatusView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createTaskView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createTaskWorkPackageView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createGanttView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createMilestoneGanttView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createResourceAppointmentsView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createResourceAppointmentsGanttView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createAccountsView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createResourceAssignmentView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createChartView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createReportView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
     ViewBase *createReportsGeneratorView( ViewListItem *cat, const QString &tag, const QString &name = QString(), const QString &tip = QString(), int index = -1 );
 
     KoPrintJob * createPrintJob();
     QPrintDialog* createPrintDialog(KoPrintJob*, QWidget*);
 
     virtual KoZoomController *zoomController() const {
         return 0;
     }
 
 Q_SIGNALS:
     void currentScheduleManagerChanged( ScheduleManager *sm );
+    void taskModulesChanged(const QStringList &modules);
 
 public Q_SLOTS:
     void slotUpdate();
     void slotCreateTemplate();
     void slotCreateNewProject();
     void slotEditResource();
     void slotEditResource( Resource *resource );
     void slotEditCut();
     void slotEditCopy();
     void slotEditPaste();
     void slotRefreshView();
     void slotViewSelector( bool show );
 
     void slotAddTask();
     void slotAddSubTask();
     void slotAddMilestone();
     void slotAddSubMilestone();
     void slotProjectEdit();
     void slotDefineWBS();
     void slotCurrencyConfig();
 
     void slotCreateView();
 
     void slotConfigure();
     void slotIntroduction();
 
     void slotAddRelation( Node *par, Node *child );
     void slotModifyRelation( Relation *rel );
     void slotAddRelation( Node *par, Node *child, int linkType );
     void slotModifyRelation( Relation *rel, int linkType );
     void slotModifyRelation();
     void slotDeleteRelation();
 
     void slotRenameNode( Node *node, const QString& name );
 
     void slotPopupMenu( const QString& menuname, const QPoint &pos );
     void slotPopupMenu( const QString& menuname, const QPoint &pos, ViewListItem *item );
 
     void addViewListItem( const ViewListItem *item, const ViewListItem *parent, int index );
     void removeViewListItem( const ViewListItem *item );
 
     void slotOpenReportFile();
 
 protected Q_SLOTS:
     void slotGuiActivated( ViewBase *view, bool );
     void slotViewActivated( ViewListItem*, ViewListItem* );
     void slotPlugScheduleActions();
     void slotViewSchedule( QAction *act );
     void slotScheduleChanged( MainSchedule* );
     void slotScheduleAdded( const MainSchedule * );
     void slotScheduleRemoved( const MainSchedule * );
     void slotSelectionChanged( ScheduleManager *sm );
 
     void slotAddScheduleManager( Project *project );
     void slotDeleteScheduleManager( Project *project, ScheduleManager *sm );
     void slotMoveScheduleManager( ScheduleManager *sm, ScheduleManager *parent, int index );
     void slotCalculateSchedule( Project*, ScheduleManager* );
     void slotBaselineSchedule( Project *project, ScheduleManager *sm );
 
     void slotProjectWorktime();
 
     void slotOpenNode();
     void slotOpenNode( Node *node );
     void slotTaskProgress();
     void slotTaskDescription();
     void slotDeleteTask( QList<Node*> lst );
     void slotDeleteTask( Node *node );
     void slotDeleteTask();
     void slotIndentTask();
     void slotUnindentTask();
     void slotMoveTaskUp();
     void slotMoveTaskDown();
 
     void slotConnectNode();
 
     void slotDeleteResource( Resource *resource );
     void slotDeleteResourceGroup( ResourceGroup *group );
     void slotDeleteResourceObjects( QObjectList );
 
     void slotCurrentChanged( int );
     void slotSelectDefaultView();
 
     void slotInsertResourcesFile(const QString&, const QUrl &projects);
     void slotInsertFile();
 
     void slotWorkPackageLoaded();
     void slotMailWorkpackage( Node *node, Resource *resource = 0 );
     void slotMailWorkpackages( const QList<Node*> &nodes, Resource *resource = 0 );
 
     void slotOpenUrlRequest( HtmlView *v, const QUrl &url );
 
     void slotProjectCalculated( ScheduleManager *sm );
 
     void slotUpdateViewInfo( ViewListItem *itm );
 
     void createReportView(const QDomDocument &doc);
 
     void saveTaskModule( const QUrl &url, Project *project );
     void removeTaskModule( const QUrl &url );
 
+    void taskModuleFileChanged(const QString &path);
+
 protected:
     virtual void guiActivateEvent( bool activated );
     virtual void updateReadWrite( bool readwrite );
 
     QList<QAction*> sortedActionList();
     QAction *addScheduleAction( Schedule *sch );
     void setLabel( ScheduleManager *sm = 0 );
     Task *currentTask() const;
     Node *currentNode() const;
     Resource *currentResource();
     ResourceGroup *currentResourceGroup();
     Calendar *currentCalendar();
     void updateView( QWidget *widget );
 
     ViewBase *currentView() const;
 
     ViewBase *createIntroductionView();
 
 private Q_SLOTS:
     void slotActionDestroyed( QObject *o );
     void slotViewListItemRemoved( ViewListItem *item );
     void slotViewListItemInserted( ViewListItem *item, ViewListItem *parent, int index );
 
     void slotProjectEditFinished( int result );
     void slotTaskEditFinished( int result );
     void slotSummaryTaskEditFinished( int result );
     void slotEditResourceFinished( int result );
     void slotProjectWorktimeFinished( int result );
     void slotDefineWBSFinished( int result );
     void slotCurrencyConfigFinished( int result );
     void slotInsertFileFinished( int result );
     void slotAddSubTaskFinished( int result );
     void slotAddTaskFinished( int result );
     void slotAddSubMilestoneFinished( int result );
     void slotAddMilestoneFinished( int result );
     void slotTaskProgressFinished( int result );
     void slotMilestoneProgressFinished( int result );
     void slotTaskDescriptionFinished( int result );
     void slotAddRelationFinished( int result );
     void slotModifyRelationFinished( int result );
     void slotReportDesignFinished( int result );
     void slotOpenReportFileFinished( int result );
     void slotCreateViewFinished( int result );
 
     void slotRemoveCommands();
 
     void hideToolDocker();
     void initiateViews();
     void slotViewScheduleManager();
 
 private:
     void createViews();
     ViewBase *createView( ViewListItem *cat, const QString &type, const QString &tag, const QString &name, const QString &tip, int index = -1 );
 
     QString standardTaskStatusReport() const;
 
 private:
     QSplitter *m_sp;
     QStackedWidget *m_tab;
 
     ViewListWidget *m_viewlist;
     ViewListItem *m_viewlistItem; // requested popupmenu item
 
     //QDockWidget *m_toolbox;
 
     int m_viewGrp;
     int m_defaultFontSize;
     int m_currentEstimateType;
 
     bool m_updateAccountsview;
     bool m_updateResourceAssignmentView;
     bool m_updatePertEditor;
 
     QLabel *m_estlabel;
 
     ViewAdaptor* m_dbus;
 
     QActionGroup *m_scheduleActionGroup;
     QMap<QAction*, Schedule*> m_scheduleActions;
     // if multiple changes occur, only issue the last change
     bool m_trigged;
     ScheduleManager *m_nextScheduleManager;
 
     QMultiMap<ScheduleManager*, CalculateScheduleCmd*> m_calculationcommands;
     QList<KUndo2Command*> m_undocommands;
 
     bool m_readWrite;
     int m_defaultView;
     QList<int> m_visitedViews;
 
     QList<DockWidget*> m_dockers;
 
     // ------ File
     QAction *actionCreateTemplate;
     QAction *actionCreateNewProject;
 
     // ------ Edit
     QAction *actionCut;
     QAction *actionCopy;
     QAction *actionPaste;
 
     // ------ View
     KToggleAction *actionViewSelector;
 
     // ------ Insert
     // ------ Project
     QAction *actionEditMainProject;
 
     // ------ Tools
     QAction *actionEditStandardWorktime;
     QAction *actionDefineWBS;
     QAction *actionInsertFile;
     QAction *actionCurrencyConfig;
 
     QAction *actionOpenReportFile;
 
     // ------ Settings
     QAction *actionConfigure;
 
     // ------ Help
     QAction *actionIntroduction;
 
     // ------ Popup
     QAction *actionOpenNode;
     QAction *actionTaskProgress;
     QAction *actionTaskDescription;
     QAction *actionDeleteTask;
     QAction *actionIndentTask;
     QAction *actionUnindentTask;
     QAction *actionMoveTaskUp;
     QAction *actionMoveTaskDown;
 
     QAction *actionEditResource;
     QAction *actionEditRelation;
     QAction *actionDeleteRelation;
 
     //Test
     QAction *actNoInformation;
 
     QMap<ViewListItem*, QAction*> m_reportActionMap;
 
     KoPart *m_partpart;
+    KDirWatch m_dirwatch;
 };
 
 
 } //Kplato namespace
 
 #endif
diff --git a/plan/libs/models/kptnodeitemmodel.cpp b/plan/libs/models/kptnodeitemmodel.cpp
index 17c485dc0a6..9a202363346 100644
--- a/plan/libs/models/kptnodeitemmodel.cpp
+++ b/plan/libs/models/kptnodeitemmodel.cpp
@@ -1,5197 +1,5206 @@
 /* This file is part of the KDE project
   Copyright (C) 2007 - 2009, 2012 Dag Andersen <danders@get2net.dk>
   Copyright (C) 2016 Dag Andersen <danders@get2net.dk>
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #include "kptnodeitemmodel.h"
 
 #include "kptglobal.h"
 #include "kptlocale.h"
 #include "kptcommonstrings.h"
 #include "kptcommand.h"
 #include "kptduration.h"
 #include "kptproject.h"
 #include "kptnode.h"
 #include "kpttaskcompletedelegate.h"
 #include "kptxmlloaderobject.h"
 #include "kptdebug.h"
 
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoOdf.h>
 #include <KoOdfWriteStore.h>
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 #include <KoXmlNS.h>
 #include <KoIcon.h>
 
 #include <QMimeData>
 #include <QMimeDatabase>
 #include <QModelIndex>
 #include <QByteArray>
 
 #include <krichtextwidget.h>
 
 #include <KGanttGlobal>
 
 #include <math.h>
 
 
 namespace KPlato
 {
 
 
 //--------------------------------------
 NodeModel::NodeModel()
     : QObject(),
     m_project( 0 ),
     m_manager( 0 ),
     m_now( QDate::currentDate() ),
     m_prec( 1 )
 {
 }
 
 const QMetaEnum NodeModel::columnMap() const
 {
     return metaObject()->enumerator( metaObject()->indexOfEnumerator("Properties") );
 }
 
 void NodeModel::setProject( Project *project )
 {
     debugPlan<<m_project<<"->"<<project;
     m_project = project;
 }
 
 void NodeModel::setManager( ScheduleManager *sm )
 {
     debugPlan<<m_manager<<"->"<<sm;
     m_manager = sm;
 }
 
 QVariant NodeModel::name( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
         case Qt::ToolTipRole:
             return node->name();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Qt::DecorationRole:
             if ( node->isBaselined() ) {
                 return koIcon("view-time-schedule-baselined");
             }
             break;
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task:
                     return static_cast<const Task*>( node )->completion().isFinished() ? m_project->config().taskFinishedColor() : m_project->config().taskNormalColor();
                 case Node::Type_Milestone:
                     return static_cast<const Task*>( node )->completion().isFinished() ? m_project->config().milestoneFinishedColor() : m_project->config().milestoneNormalColor();
                 case Node::Type_Summarytask:
                     return m_project->config().summaryTaskLevelColor( node->level() );
                 default:
                     break;
             }
             break;
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::leader( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
         case Qt::ToolTipRole:
             return node->leader();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::allocation( const Node *node, int role ) const
 {
     if ( node->type() == Node::Type_Task ) {
         switch ( role ) {
             case Qt::DisplayRole:
             case Qt::EditRole:
                 return node->requests().requestNameList().join( "," );
             case Qt::ToolTipRole: {
                 QMap<QString, QStringList> lst;
                 foreach ( ResourceRequest *rr, node->requests().resourceRequests( false ) ) {
                     QStringList sl;
                     foreach( Resource *r, rr->requiredResources() ) {
                         sl << r->name();
                     }
                     lst.insert( rr->resource()->name(), sl );
                 }
                 if ( lst.isEmpty() ) {
                     return xi18nc( "@info:tooltip", "No resources has been allocated" );
                 }
                 QStringList sl;
                 for ( QMap<QString, QStringList>::ConstIterator it = lst.constBegin(); it != lst.constEnd(); ++it ) {
                     if ( it.value().isEmpty() ) {
                         sl << it.key();
                     } else {
                         sl << xi18nc( "@info:tooltip 1=resource name, 2=list of required resources", "%1 (%2)", it.key(), it.value().join(", ") );
                     }
                 }
                 if ( sl.count() == 1 ) {
                     return xi18nc( "@info:tooltip 1=resource name", "Allocated resource:<nl/>%1", sl.first() );
                 }
                 return xi18nc( "@info:tooltip 1=list of resources", "Allocated resources:<nl/>%1", sl.join( "<nl/>" ) );
             }
             case Qt::StatusTipRole:
             case Qt::WhatsThisRole:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::description( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             KRichTextWidget w( node->description(), 0 );
             w.switchToPlainText();
             QString s = w.textOrHtml();
             int i = s.indexOf( '\n' );
             s = s.left( i );
             if ( i > 0 ) {
                 s += "...";
             }
             return s;
         }
         case Qt::ToolTipRole: {
             KRichTextWidget w( node->description(), 0 );
             w.switchToPlainText();
             if ( w.textOrHtml().isEmpty() ) {
                 return QVariant();
             }
             return node->description();
         }
         case Qt::EditRole:
             return node->description();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::type( const Node *node, int role ) const
 {
     //debugPlan<<node->name()<<", "<<role;
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::ToolTipRole:
             return node->typeToString( true );
         case Qt::EditRole:
             return node->type();
         case Qt::TextAlignmentRole:
             return (int)(Qt::AlignLeft|Qt::AlignVCenter);
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::constraint( const Node *node, int role ) const
 {
     if ( node->type() == Node::Type_Project ) {
         switch ( role ) {
             case Qt::DisplayRole:
                 return i18n( "Target times" );
             case Qt::ToolTipRole:
                 return xi18nc( "@info:tooltip", "Earliest start and latest finish" );
             case Role::EnumList:
             case Qt::EditRole:
             case Role::EnumListValue:
                 return QVariant();
             case Qt::TextAlignmentRole:
                 return Qt::AlignCenter;
             case Qt::StatusTipRole:
             case Qt::WhatsThisRole:
                 return QVariant();
         }
     } else if ( node->type() != Node::Type_Summarytask ) {
         switch ( role ) {
             case Qt::DisplayRole:
             case Qt::ToolTipRole:
                 return node->constraintToString( true );
             case Role::EnumList:
                 return Node::constraintList( true );
             case Qt::EditRole:
                 return node->constraint();
             case Role::EnumListValue:
                 return (int)node->constraint();
             case Qt::TextAlignmentRole:
                 return Qt::AlignCenter;
             case Qt::StatusTipRole:
             case Qt::WhatsThisRole:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::constraintStartTime( const Node *node, int role ) const
 {
     if ( node->type() == Node::Type_Project ) {
         switch ( role ) {
             case Qt::DisplayRole: {
                 return QLocale().toString( node->constraintStartTime(), QLocale::ShortFormat );
             }
             case Qt::ToolTipRole: {
                 return QLocale().toString( node->constraintStartTime(), QLocale::LongFormat );
             }
             case Qt::EditRole:
                 return node->constraintStartTime();
             case Qt::StatusTipRole:
             case Qt::WhatsThisRole:
                 return QVariant();
         }
         return QVariant();
     } else if ( node->type() != Node::Type_Summarytask ) {
         switch ( role ) {
             case Qt::DisplayRole: {
                 QString s = QLocale().toString( node->constraintStartTime(), QLocale::ShortFormat );
                 switch ( node->constraint() ) {
                     case Node::StartNotEarlier:
                     case Node::MustStartOn:
                     case Node::FixedInterval:
                         return s;
                     default:
                         break;
                 }
                 return QString( "(%1)" ).arg( s );
         }
             case Qt::ToolTipRole: {
                 int c = node->constraint();
                 if ( c == Node::MustStartOn || c == Node::StartNotEarlier || c == Node::FixedInterval  ) {
                     return QLocale().toString( node->constraintStartTime(), QLocale::LongFormat );
                 }
                 break;
             }
             case Qt::EditRole:
                 return node->constraintStartTime();
             case Qt::StatusTipRole:
             case Qt::WhatsThisRole:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::constraintEndTime( const Node *node, int role ) const
 {
     if ( node->type() == Node::Type_Project ) {
         switch ( role ) {
             case Qt::DisplayRole: {
                 return QLocale().toString( node->constraintEndTime(), QLocale::ShortFormat );
             }
             case Qt::ToolTipRole: {
                 return QLocale().toString( node->constraintEndTime(), QLocale::LongFormat );
             }
             case Qt::EditRole:
                 return node->constraintEndTime();
             case Qt::StatusTipRole:
             case Qt::WhatsThisRole:
                 return QVariant();
         }
         return QVariant();
     } else if ( node->type() != Node::Type_Summarytask ) {
         switch ( role ) {
             case Qt::DisplayRole: {
                 QString s = QLocale().toString( node->constraintEndTime(), QLocale::ShortFormat );
                 switch ( node->constraint() ) {
                     case Node::FinishNotLater:
                     case Node::MustFinishOn:
                     case Node::FixedInterval:
                         return s;
                     default:
                         break;
                 }
                 return QString( "(%1)" ).arg( s );
             }
             case Qt::ToolTipRole: {
                 int c = node->constraint();
                 if ( c == Node::FinishNotLater || c == Node::MustFinishOn || c == Node::FixedInterval ) {
                     return QLocale().toString( node->constraintEndTime(), QLocale::LongFormat );
                 }
                 break;
             }
             case Qt::EditRole:
                 return node->constraintEndTime();
             case Qt::StatusTipRole:
             case Qt::WhatsThisRole:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::estimateType( const Node *node, int role ) const
 {
     if ( node->estimate() == 0 ) {
         return QVariant();
     }
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 return node->estimate()->typeToString( true );
             }
             return QString();
         case Role::EnumList:
             return Estimate::typeToStringList( true );
         case Qt::EditRole:
             if ( node->type() == Node::Type_Task ) {
                 return node->estimate()->typeToString();
             }
             return QString();
         case Role::EnumListValue:
             return (int)node->estimate()->type();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::estimateCalendar( const Node *node, int role ) const
 {
     if ( node->estimate() == 0 ) {
         return QVariant();
     }
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task ) {
                 if ( node->estimate()->calendar() ) {
                     return node->estimate()->calendar()->name();
                 }
                 return i18n( "None" );
             }
             return QString();
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 if ( node->estimate()->type() == Estimate::Type_Effort ) {
                     return xi18nc( "@info:tooltip", "Not applicable, estimate type is Effort" );
                 }
                 if ( node->estimate()->calendar() ) {
                     return node->estimate()->calendar()->name();
                 }
                 return QVariant();
             }
             return QString();
         case Role::EnumList:
         {
             QStringList lst; lst << i18n( "None" );
             const Node *n = const_cast<Node*>( node )->projectNode();
             if ( n ) {
                 lst += static_cast<const Project*>( n )->calendarNames();
             }
             return lst;
         }
         case Qt::EditRole:
             if ( node->type() == Node::Type_Task ) {
                 if ( node->estimate()->calendar() == 0 ) {
                     return i18n( "None" );
                 }
                 return node->estimate()->calendar()->name();
             }
             return QString();
         case Role::EnumListValue:
         {
             if ( node->estimate()->calendar() == 0 ) {
                 return 0;
             }
             QStringList lst;
             const Node *n = const_cast<Node*>( node )->projectNode();
             if ( n ) {
                 lst = static_cast<const Project*>( n )->calendarNames();
             }
             return lst.indexOf( node->estimate()->calendar()->name() ) + 1;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::estimate( const Node *node, int role ) const
 {
     if ( node->estimate() == 0 ) {
         return QVariant();
     }
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task  || node->type() == Node::Type_Milestone ) {
                 Duration::Unit unit = node->estimate()->unit();
                 QString s = QLocale().toString( node->estimate()->expectedEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true );
                 if ( node->constraint() == Node::FixedInterval && node->estimate()->type() == Estimate::Type_Duration ) {
                     s = '(' + s + ')';
                 }
                 return s;
             }
             break;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 QString s = QLocale().toString( node->estimate()->expectedEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true );
                 Estimate::Type t = node->estimate()->type();
                 if ( node->constraint() == Node::FixedInterval && t == Estimate::Type_Duration ) {
                     s = xi18nc( "@info:tooltip", "Not applicable, constraint is Fixed Interval" );
                 } else if ( t == Estimate::Type_Effort ) {
                     s = xi18nc( "@info:tooltip", "Estimated effort: %1", s );
                 } else {
                     s = xi18nc( "@info:tooltip", "Estimated duration: %1", s );
                 }
                 return s;
             }
             break;
         case Qt::EditRole:
             return node->estimate()->expectedEstimate();
         case Role::DurationUnit:
             return static_cast<int>( node->estimate()->unit() );
         case Role::Minimum:
             return m_project->config().minimumDurationUnit();
         case Role::Maximum:
             return m_project->config().maximumDurationUnit();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::optimisticRatio( const Node *node, int role ) const
 {
     if ( node->estimate() == 0 || node->type() == Node::Type_Summarytask || node->type() == Node::Type_Milestone ) {
         return QVariant();
     }
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task && node->constraint() == Node::FixedInterval && node->estimate()->type() == Estimate::Type_Duration ) {
                 QString s = QString::number( node->estimate()->optimisticRatio() );
                 s = '(' + s + ')';
                 return s;
             }
             if ( node->estimate() ) {
                 return node->estimate()->optimisticRatio();
             }
             break;
         case Qt::EditRole:
             if ( node->estimate() ) {
                 return node->estimate()->optimisticRatio();
             }
             break;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 QString s = QLocale().toString( node->estimate()->optimisticEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true );
                 Estimate::Type t = node->estimate()->type();
                 if ( node->constraint() == Node::FixedInterval && t == Estimate::Type_Duration ) {
                     s = xi18nc( "@info:tooltip", "Not applicable, constraint is Fixed Interval" );
                 } else if ( t == Estimate::Type_Effort ) {
                     s = xi18nc( "@info:tooltip", "Optimistic effort: %1", s );
                 } else {
                     s = xi18nc( "@info:tooltip", "Optimistic duration: %1", s );
                 }
                 return s;
             }
             break;
         case Role::Minimum:
             return -99;
         case Role::Maximum:
             return 0;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::pessimisticRatio( const Node *node, int role ) const
 {
     if ( node->estimate() == 0 || node->type() == Node::Type_Summarytask || node->type() == Node::Type_Milestone ) {
         return QVariant();
     }
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task && node->constraint() == Node::FixedInterval && node->estimate()->type() == Estimate::Type_Duration ) {
                 QString s = QString::number( node->estimate()->pessimisticRatio() );
                 s = '(' + s + ')';
                 return s;
             }
             if ( node->estimate() ) {
                 return node->estimate()->pessimisticRatio();
             }
             break;
         case Qt::EditRole:
             if ( node->estimate() ) {
                 return node->estimate()->pessimisticRatio();
             }
             break;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 QString s = QLocale().toString( node->estimate()->pessimisticEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true );
                 Estimate::Type t = node->estimate()->type();
                 if ( node->constraint() == Node::FixedInterval && t == Estimate::Type_Duration ) {
                     s = xi18nc( "@info:tooltip", "Not applicable, constraint is Fixed Interval" );
                 } else if ( t == Estimate::Type_Effort ) {
                     s = xi18nc( "@info:tooltip", "Pessimistic effort: %1", s );
                 } else {
                     s = xi18nc( "@info:tooltip", "Pessimistic duration: %1", s );
                 }
                 return s;
             }
             break;
         case Role::Minimum:
             return 0;
         case Role::Maximum:
             return INT_MAX;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::riskType( const Node *node, int role ) const
 {
     if ( node->estimate() == 0 ) {
         return QVariant();
     }
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 return node->estimate()->risktypeToString( true );
             }
             return QString();
         case Role::EnumList:
             return Estimate::risktypeToStringList( true );
         case Qt::EditRole:
             if ( node->type() == Node::Type_Task ) {
                 return node->estimate()->risktypeToString();
             }
             return QString();
         case Role::EnumListValue:
             return (int)node->estimate()->risktype();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::runningAccount( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task ) {
                 Account *a = node->runningAccount();
                 return a == 0 ? i18n( "None" ) : a->name();
             }
             break;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 Account *a = node->runningAccount();
                 return a ? xi18nc( "@info:tooltip", "Account for resource cost: %1", a->name() )
                          : xi18nc( "@info:tooltip", "Account for resource cost" );
             }
             break;
         case Role::EnumListValue:
         case Qt::EditRole: {
             Account *a = node->runningAccount();
             return a == 0 ? 0 : ( m_project->accounts().costElements().indexOf( a->name() ) + 1 );
         }
         case Role::EnumList: {
             QStringList lst;
             lst << i18n("None");
             lst += m_project->accounts().costElements();
             return lst;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::startupAccount( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task  || node->type() == Node::Type_Milestone ) {
                 Account *a = node->startupAccount();
                 //debugPlan<<node->name()<<": "<<a;
                 return a == 0 ? i18n( "None" ) : a->name();
             }
             break;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task  || node->type() == Node::Type_Milestone ) {
                 Account *a = node->startupAccount();
                 //debugPlan<<node->name()<<": "<<a;
                 return a ? xi18nc( "@info:tooltip", "Account for task startup cost: %1", a->name() )
                          : xi18nc( "@info:tooltip", "Account for task startup cost" );
             }
             break;
         case Role::EnumListValue:
         case Qt::EditRole: {
             Account *a = node->startupAccount();
             return a == 0 ? 0 : ( m_project->accounts().costElements().indexOf( a->name() ) + 1 );
         }
         case Role::EnumList: {
             QStringList lst;
             lst << i18n("None");
             lst += m_project->accounts().costElements();
             return lst;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::startupCost( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) {
                 return m_project->locale()->formatMoney( node->startupCost() );
             }
             break;
         case Qt::EditRole:
             return node->startupCost();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::shutdownAccount( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) {
                 Account *a = node->shutdownAccount();
                 return a == 0 ? i18n( "None" ) : a->name();
             }
             break;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) {
                 Account *a = node->shutdownAccount();
                 return a ? xi18nc( "@info:tooltip", "Account for task shutdown cost: %1", a->name() )
                          : xi18nc( "@info:tooltip", "Account for task shutdown cost" );
             }
             break;
         case Role::EnumListValue:
         case Qt::EditRole: {
             Account *a = node->shutdownAccount();
             return a == 0 ? 0 : ( m_project->accounts().costElements().indexOf( a->name() ) + 1 );
         }
         case Role::EnumList: {
             QStringList lst;
             lst << i18n("None");
             lst += m_project->accounts().costElements();
             return lst;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::shutdownCost( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) {
                 return m_project->locale()->formatMoney( node->shutdownCost() );
             }
             break;
         case Qt::EditRole:
             return node->shutdownCost();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::startTime( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return QLocale().toString( node->startTime( id() ), QLocale::ShortFormat );
         case Qt::ToolTipRole:
             //debugPlan<<node->name()<<", "<<role;
             return xi18nc( "@info:tooltip", "Scheduled start: %1", QLocale().toString( node->startTime( id() ), QLocale::LongFormat ) );
         case Qt::EditRole:
             return node->startTime( id() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::endTime( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return QLocale().toString( node->endTime( id() ), QLocale::ShortFormat );
         case Qt::ToolTipRole:
             //debugPlan<<node->name()<<", "<<role;
             return xi18nc( "@info:tooltip", "Scheduled finish: %1", QLocale().toString( node->endTime( id() ), QLocale::LongFormat ) );
         case Qt::EditRole:
             return node->endTime( id() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::duration( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 double v = node->duration( id() ).toDouble( unit );
                 return QVariant(QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ));
             } else if ( node->type() == Node::Type_Project ) {
                 Duration::Unit unit = Duration::Unit_d;
                 double v = node->duration( id() ).toDouble( unit );
                 return QVariant(QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ));
             }
             break;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 double v = node->duration( id() ).toDouble( unit );
                 return xi18nc( "@info:tooltip", "Scheduled duration: %1", QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ) );
             } else if ( node->type() == Node::Type_Project ) {
                 Duration::Unit unit = Duration::Unit_d;
                 double v = node->duration( id() ).toDouble( unit );
                 return xi18nc( "@info:tooltip", "Scheduled duration: %1", QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ) );
             }
             break;
         case Qt::EditRole: {
             return node->duration( id() ).toDouble( Duration::Unit_h );
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::varianceDuration( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 double v = node->variance( id(), unit );
                 return QLocale().toString( v, 'f', 2 );
             }
             break;
         case Qt::EditRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 return node->variance( id(), unit );
             }
             return 0.0;
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 Duration::Unit unit = node->estimate()->unit();
                 double v = node->variance( id(), unit );
                 return xi18nc( "@info:tooltip", "PERT duration variance: %1", QLocale().toString( v ,'f', 2 ) );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::varianceEstimate( const Estimate *est, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             double v = est->variance( unit );
             //debugPlan<<node->name()<<": "<<v<<" "<<unit<<" : "<<scales;
             return QLocale().toString( v, 'f', 2 );
         }
         case Qt::EditRole: {
             if ( est == 0 ) {
                 return 0.0;
             }
             return est->variance( est->unit() );
         }
         case Qt::ToolTipRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             double v = est->variance( unit );
             return xi18nc( "@info:tooltip", "PERT estimate variance: %1", QLocale().toString( v, 'f', 2 ) + Duration::unitToString( unit, true ) );
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::optimisticDuration( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             if ( node->type() != Node::Type_Task ) {
                 return QVariant();
             }
             Duration d = node->duration( id() );
             d = ( d * ( 100 + node->estimate()->optimisticRatio() ) ) / 100;
             Duration::Unit unit = node->estimate()->unit();
             double v = d.toDouble( unit );
                 //debugPlan<<node->name()<<": "<<v<<" "<<unit<<" : "<<scales;
             return QVariant(QLocale().toString( v,'f', m_prec ) +  Duration::unitToString( unit, true ));
             break;
         }
         case Qt::EditRole: {
             if ( node->type() != Node::Type_Task ) {
                 return 0.0;
             }
             Duration d = node->duration( id() );
             d = ( d * ( 100 + node->estimate()->optimisticRatio() ) ) / 100;
             Duration::Unit unit = node->estimate()->unit();
             return d.toDouble( unit );
         }
         case Qt::ToolTipRole: {
             if ( node->type() != Node::Type_Task ) {
                 return QVariant();
             }
             Duration d = node->duration( id() );
             d = ( d * ( 100 + node->estimate()->optimisticRatio() ) ) / 100;
             Duration::Unit unit = node->estimate()->unit();
             double v = d.toDouble( unit );
             //debugPlan<<node->name()<<": "<<v<<" "<<unit<<" : "<<scales;
             return xi18nc( "@info:tooltip", "PERT optimistic duration: %1", QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ) );
             break;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::optimisticEstimate( const Estimate *est, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             return QVariant(QLocale().toString( est->optimisticEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true ));
             break;
         }
         case Qt::EditRole: {
             if ( est == 0 ) {
                 return 0.0;
             }
             return est->optimisticEstimate();
         }
         case Qt::ToolTipRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             return xi18nc( "@info:tooltip", "Optimistic estimate: %1", QLocale().toString( est->optimisticEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true ) );
             break;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::pertExpected( const Estimate *est, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             double v = Estimate::scale( est->pertExpected(), unit, est->scales() );
             return QVariant(QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ));
         }
         case Qt::EditRole: {
             if ( est == 0 ) {
                 return 0.0;
             }
             return Estimate::scale( est->pertExpected(), est->unit(), est->scales() );
         }
         case Qt::ToolTipRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             double v = Estimate::scale( est->pertExpected(), unit, est->scales() );
             return xi18nc( "@info:tooltip", "PERT expected estimate: %1", QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ) );
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::pessimisticDuration( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             if ( node->type() != Node::Type_Task ) {
                 return QVariant();
             }
             Duration d = node->duration( id() );
             d = ( d * ( 100 + node->estimate()->pessimisticRatio() ) ) / 100;
             Duration::Unit unit = node->estimate()->unit();
             double v = d.toDouble( unit );
             //debugPlan<<node->name()<<": "<<v<<" "<<unit<<" : "<<scales;
             return QVariant(QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ));
             break;
         }
         case Qt::EditRole: {
             if ( node->type() != Node::Type_Task ) {
                 return 0.0;
             }
             Duration d = node->duration( id() );
             d = ( d * ( 100 + node->estimate()->pessimisticRatio() ) ) / 100;
             return d.toDouble( node->estimate()->unit() );
         }
         case Qt::ToolTipRole: {
             if ( node->type() != Node::Type_Task ) {
                 return QVariant();
             }
             Duration d = node->duration( id() );
             d = ( d * ( 100 + node->estimate()->pessimisticRatio() ) ) / 100;
             Duration::Unit unit = node->estimate()->unit();
             double v = d.toDouble( unit );
             //debugPlan<<node->name()<<": "<<v<<" "<<unit<<" : "<<scales;
             return xi18nc( "@info:tooltip", "PERT pessimistic duration: %1", QLocale().toString( v, 'f', m_prec ) +  Duration::unitToString( unit, true ) );
             break;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::pessimisticEstimate( const Estimate *est, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             return QVariant(QLocale().toString( est->pessimisticEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true ));
             break;
         }
         case Qt::EditRole: {
             if ( est == 0 ) {
                 return 0.0;
             }
             return est->pessimisticEstimate();
         }
         case Qt::ToolTipRole: {
             if ( est == 0 ) {
                 return QVariant();
             }
             Duration::Unit unit = est->unit();
             return xi18nc( "@info:tooltip", "Pessimistic estimate: %1", QLocale().toString( est->pessimisticEstimate(), 'f', m_prec ) +  Duration::unitToString( unit, true ) );
             break;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::earlyStart( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return QLocale().toString( t->earlyStart( id() ), QLocale::ShortFormat );
         case Qt::ToolTipRole:
             return QLocale().toString( t->earlyStart( id() ).date(), QLocale::ShortFormat );
         case Qt::EditRole:
             return t->earlyStart( id() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::earlyFinish( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return QLocale().toString( t->earlyFinish( id() ), QLocale::ShortFormat );
         case Qt::ToolTipRole:
             return QLocale().toString( t->earlyFinish( id() ).date(), QLocale::ShortFormat );
         case Qt::EditRole:
             return t->earlyFinish( id() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::lateStart( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return QLocale().toString( t->lateStart( id() ), QLocale::ShortFormat );
         case Qt::ToolTipRole:
             return QLocale().toString( t->lateStart( id() ).date(), QLocale::ShortFormat );
         case Qt::EditRole:
             return t->lateStart( id() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::lateFinish( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return QLocale().toString( t->lateFinish( id() ), QLocale::ShortFormat );
         case Qt::ToolTipRole:
             return QLocale().toString( t->lateFinish( id() ).date(), QLocale::ShortFormat );
         case Qt::EditRole:
             return t->lateFinish( id() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::positiveFloat( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return t->positiveFloat( id() ).toString( Duration::Format_i18nHourFraction );
         case Qt::ToolTipRole:
             return t->positiveFloat( id() ).toString( Duration::Format_i18nDayTime );
         case Qt::EditRole:
             return t->positiveFloat( id() ).toDouble( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::freeFloat( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return t->freeFloat( id() ).toString( Duration::Format_i18nHourFraction );
         case Qt::ToolTipRole:
             return t->freeFloat( id() ).toString( Duration::Format_i18nDayTime );
         case Qt::EditRole:
             return t->freeFloat( id() ).toDouble( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::negativeFloat( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return t->negativeFloat( id() ).toString( Duration::Format_i18nHourFraction );
         case Qt::ToolTipRole:
             return t->negativeFloat( id() ).toString( Duration::Format_i18nDayTime );
         case Qt::EditRole:
             return t->negativeFloat( id() ).toDouble( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::startFloat( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return t->startFloat( id() ).toString( Duration::Format_i18nHourFraction );
         case Qt::ToolTipRole:
             return t->startFloat( id() ).toString( Duration::Format_i18nDayTime );
         case Qt::EditRole:
             return t->startFloat( id() ).toDouble( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::finishFloat( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return t->finishFloat( id() ).toString( Duration::Format_i18nHourFraction );
         case Qt::ToolTipRole:
             return t->finishFloat( id() ).toString( Duration::Format_i18nDayTime );
         case Qt::EditRole:
             return t->finishFloat( id() ).toDouble( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::assignedResources( const Node *node, int role ) const
 {
     if ( node->type() != Node::Type_Task ) {
         return QVariant();
     }
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
             return node->assignedNameList( id() ).join(",");
         case Qt::ToolTipRole: {
             QStringList lst = node->assignedNameList( id() );
             if ( ! lst.isEmpty() ) {
                 return xi18nc( "@info:tooltip 1=list of resources", "Assigned resources:<nl/>%1", node->assignedNameList( id() ).join("<nl/>") );
             }
             break;
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 
 QVariant NodeModel::completed( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             return t->completion().percentFinished();
         case Qt::EditRole:
             return t->completion().percentFinished();
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Task is %1% completed", t->completion().percentFinished() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::status( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole: {
             int st = t->state( id() );
             if ( st & Node::State_NotScheduled ) {
                 return SchedulingState::notScheduled();
             }
             if ( st & Node::State_Finished ) {
                 if ( st & Node::State_FinishedLate ) {
                     return i18n( "Finished late" );
                 }
                 if ( st & Node::State_FinishedEarly ) {
                     return i18n( "Finished early" );
                 }
                 return i18n( "Finished" );
             }
             if ( st & Node::State_Running ) {
                 if ( st & Node::State_Late ) {
                     return i18n( "Running late" );
                 }
                 return i18n( "Running" );
             }
             if ( st & Node::State_Started ) {
                 if ( st & Node::State_StartedLate ) {
                     return i18n( "Started late" );
                 }
                 if ( st & Node::State_StartedEarly ) {
                     return i18n( "Started early" );
                 }
                 if ( st & Node::State_Late ) {
                     return i18n( "Running late" );
                 }
                 return i18n( "Started" );
             }
             if ( st & Node::State_ReadyToStart ) {
                 if ( st & Node::State_Late ) {
                     return i18n( "Not started" );
                 }
                 return i18n( "Can start" );
             }
             if ( st & Node::State_NotReadyToStart ) {
                 if ( st & Node::State_Late ) {
                     return i18n( "Delayed" );
                 }
                 return i18n( "Cannot start" );
             }
             return i18n( "Not started" );
             break;
         }
         case Qt::ToolTipRole: {
             int st = t->state( id() );
             if ( st & Node::State_NotScheduled ) {
                 return SchedulingState::notScheduled();
             }
             if ( st & Node::State_Finished ) {
                 if ( st & Node::State_FinishedLate ) {
                     Duration d = t->completion().finishTime() - t->endTime( id() );
                     return xi18nc( "@info:tooltip", "Finished %1 late", d.toString( Duration::Format_i18nDay ) );
                 }
                 if ( st & Node::State_FinishedEarly ) {
                     Duration d = t->endTime( id() ) - t->completion().finishTime();
                     return xi18nc( "@info:tooltip", "Finished %1 early", d.toString( Duration::Format_i18nDay ) );
                 }
                 return xi18nc( "@info:tooltip", "Finished" );
             }
             if ( st & Node::State_Started ) {
                 if ( st & Node::State_StartedLate ) {
                     Duration d = t->completion().startTime() - t->startTime( id() );
                     return xi18nc( "@info:tooltip", "Started %1 late", d.toString( Duration::Format_i18nDay ) );
                 }
                 if ( st & Node::State_StartedEarly ) {
                     Duration d = t->startTime( id() ) - t->completion().startTime();
                     return xi18nc( "@info:tooltip", "Started %1 early", d.toString( Duration::Format_i18nDay ) );
                 }
                 return xi18nc( "@info:tooltip", "Started" );
             }
             if ( st & Node::State_Running ) {
                 return xi18nc( "@info:tooltip", "Running" );
             }
             if ( st & Node::State_ReadyToStart ) {
                 return xi18nc( "@info:tooltip", "Can start" );
             }
             if ( st & Node::State_NotReadyToStart ) {
                 QStringList names;
                 // TODO: proxy relations
                 foreach ( Relation *r, node->dependParentNodes() ) {
                     switch ( r->type() ) {
                         case Relation::FinishFinish:
                         case Relation::FinishStart:
                             if ( ! static_cast<Task*>( r->parent() )->completion().isFinished() ) {
                                 if ( ! names.contains( r->parent()->name() ) ) {
                                     names << r->parent()->name();
                                 }
                             }
                             break;
                         case Relation::StartStart:
                             if ( ! static_cast<Task*>( r->parent() )->completion().isStarted() ) {
                                 if ( ! names.contains( r->parent()->name() ) ) {
                                     names << r->parent()->name();
                                 }
                             }
                             break;
                     }
                 }
                 return names.isEmpty()
                     ? xi18nc( "@info:tooltip", "Cannot start" )
                     : xi18nc( "@info:tooltip 1=list of task names", "Cannot start, waiting for:<nl/>%1", names.join( "<nl/>" ) );
             }
             return xi18nc( "@info:tooltip", "Not started" );
             break;
         }
         case Qt::EditRole:
             return t->state( id() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::startedTime( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             if ( t->completion().isStarted() ) {
                 return QLocale().toString( t->completion().startTime(), QLocale::ShortFormat );
             }
             break;
         case Qt::ToolTipRole:
             if ( t->completion().isStarted() ) {
                 return xi18nc( "@info:tooltip", "Actual start: %1", QLocale().toString( t->completion().startTime().date(), QLocale::LongFormat ) );
             }
             break;
         case Qt::EditRole:
             if ( t->completion().isStarted() ) {
                 return t->completion().startTime();
             }
             return QDateTime::currentDateTime();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::isStarted( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
             return t->completion().isStarted();
         case Qt::ToolTipRole:
             if ( t->completion().isStarted() ) {
                 return xi18nc( "@info:tooltip", "The task started at: %1", QLocale().toString( t->completion().startTime().date(), QLocale::LongFormat ) );
             }
             return xi18nc( "@info:tooltip", "The task is not started" );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::finishedTime( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
             if ( t->completion().isFinished() ) {
                 return QLocale().toString( t->completion().finishTime(), QLocale::ShortFormat );
             }
             break;
         case Qt::ToolTipRole:
             if ( t->completion().isFinished() ) {
                 return xi18nc( "@info:tooltip", "Actual finish: %1", QLocale().toString( t->completion().finishTime(), QLocale::LongFormat ) );
             }
             break;
         case Qt::EditRole:
             if ( t->completion().isFinished() ) {
                 return t->completion().finishTime();
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::isFinished( const Node *node, int role ) const
 {
     if ( ! ( node->type() == Node::Type_Task || node->type() == Node::Type_Milestone ) ) {
         return QVariant();
     }
     const Task *t = static_cast<const Task*>( node );
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
             return t->completion().isFinished();
         case Qt::ToolTipRole:
             if ( t->completion().isFinished() ) {
                 return xi18nc( "@info:tooltip", "The task finished at: %1", QLocale().toString( t->completion().finishTime().date(), QLocale::LongFormat ) );
             }
             return xi18nc( "@info:tooltip", "The task is not finished" );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::plannedEffortTo( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return node->plannedEffortTo( m_now, id() ).format();
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Planned effort until %1: %2", QLocale().toString( m_now, QLocale::ShortFormat ), node->plannedEffortTo( m_now, id() ).toString( Duration::Format_i18nHour ) );
         case Qt::EditRole:
             return node->plannedEffortTo( m_now, id() ).toDouble( Duration::Unit_h );
         case Role::DurationUnit:
             return static_cast<int>( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::actualEffortTo( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return node->actualEffortTo( m_now ).format();
         case Qt::ToolTipRole:
             //debugPlan<<m_now<<node;
             return xi18nc( "@info:tooltip", "Actual effort used up to %1: %2", QLocale().toString( m_now, QLocale::ShortFormat ), node->actualEffortTo( m_now ).toString( Duration::Format_i18nHour ) );
         case Qt::EditRole:
             return node->actualEffortTo( m_now ).toDouble( Duration::Unit_h );
         case Role::DurationUnit:
             return static_cast<int>( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::remainingEffort( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             const Task *t = dynamic_cast<const Task*>( node );
             if ( t ) {
                 return t->completion().remainingEffort().format();
             }
             break;
         }
         case Qt::ToolTipRole: {
             const Task *t = dynamic_cast<const Task*>( node );
             if ( t ) {
                 return xi18nc( "@info:tooltip", "Remaining effort: %1", t->completion().remainingEffort().toString( Duration::Format_i18nHour ) );
             }
             break;
         }
         case Qt::EditRole: {
             const Task *t = dynamic_cast<const Task*>( node );
             if ( t == 0 ) {
                 return QVariant();
             }
             return t->completion().remainingEffort().toDouble( Duration::Unit_h );
         }
         case Role::DurationUnit:
             return static_cast<int>( Duration::Unit_h );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::plannedCostTo( const Node *node, int role ) const
 {
     Locale *l = m_project->locale();
     switch ( role ) {
         case Qt::DisplayRole:
             return l->formatMoney( node->plannedCostTo( m_now, id() ) );
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Planned cost until %1: %2", QLocale().toString( m_now, QLocale::ShortFormat ), l->formatMoney( node->plannedCostTo( m_now, id() ) ) );
         case Qt::EditRole:
             return node->plannedCostTo( m_now );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::actualCostTo( const Node *node, int role ) const
 {
     Locale *l = m_project->locale();
     switch ( role ) {
         case Qt::DisplayRole:
             return l->formatMoney( node->actualCostTo( id(), m_now ).cost() );
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Actual cost until %1: %2", QLocale().toString( m_now, QLocale::ShortFormat ), l->formatMoney( node->actualCostTo( id(), m_now ).cost() ) );
         case Qt::EditRole:
             return node->actualCostTo( id(), m_now ).cost();
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::note( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
         case Qt::ToolTipRole:
             if ( node->type() == Node::Type_Task ) {
                 Node *n = const_cast<Node*>( node );
                 return static_cast<Task*>( n )->completion().note();
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeSchedulingStatus( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return node->schedulingStatus( id(), true ).value( 0 );
         case Qt::EditRole:
             return node->schedulingStatus( id(), false ).value( 0 );
         case Qt::ToolTipRole:
             return node->schedulingStatus( id(), true ).join( "\n" );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::resourceIsMissing( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->resourceError( id() ) ) {
                 return i18n( "Error" );
             }
             break;
         case Qt::EditRole:
             return node->resourceError( id() );
         case Qt::ToolTipRole:
             if ( node->resourceError( id() ) ) {
                 return xi18nc( "@info:tooltip", "Resource allocation is expected when the task estimate type is  <emphasis>Effort</emphasis>" );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskErrorColor();
                 case Node::Type_Milestone: return m_project->config().milestoneErrorColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::resourceIsOverbooked( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->resourceOverbooked( id() ) ) {
                 return i18n( "Error" );
             }
             break;
         case Qt::EditRole:
             return node->resourceOverbooked( id() );
         case Qt::ToolTipRole:
             if ( node->resourceOverbooked( id() ) ) {
                 return xi18nc( "@info:tooltip", "A resource has been overbooked" );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskErrorColor();
                 case Node::Type_Milestone: return m_project->config().milestoneErrorColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::resourceIsNotAvailable( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->resourceNotAvailable( id() ) ) {
                 return i18n( "Error" );
             }
             break;
         case Qt::EditRole:
             return node->resourceNotAvailable( id() );
         case Qt::ToolTipRole:
             if ( node->resourceNotAvailable( id() ) ) {
                 return xi18nc( "@info:tooltip", "No resource is available for this task" );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskErrorColor();
                 case Node::Type_Milestone: return m_project->config().milestoneErrorColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::schedulingConstraintsError( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->constraintError( id() ) ) {
                 return i18n( "Error" );
             }
             break;
         case Qt::EditRole:
             return node->constraintError( id() );
         case Qt::ToolTipRole:
             if ( node->constraintError( id() ) ) {
                 return xi18nc( "@info:tooltip", "Failed to comply with a timing constraint" );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskErrorColor();
                 case Node::Type_Milestone: return m_project->config().milestoneErrorColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeIsNotScheduled( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->notScheduled( id() ) ) {
                 return i18n( "Error" );
             }
             break;
         case Qt::EditRole:
             return node->notScheduled( id() );
         case Qt::ToolTipRole:
             if ( node->notScheduled( id() ) ) {
                 return xi18nc( "@info:tooltip", "This task has not been scheduled" );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskErrorColor();
                 case Node::Type_Milestone: return m_project->config().milestoneErrorColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::effortNotMet( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->effortMetError( id() ) ) {
                 return i18n( "Error" );
             }
             break;
         case Qt::EditRole:
             return node->effortMetError( id() );
         case Qt::ToolTipRole:
             if ( node->effortMetError( id() ) ) {
                 return xi18nc( "@info:tooltip", "The assigned resources cannot deliver the required estimated effort" );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskErrorColor();
                 case Node::Type_Milestone: return m_project->config().milestoneErrorColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::schedulingError( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             if ( node->schedulingError( id() ) ) {
                 return i18n( "Error" );
             }
             break;
         case Qt::EditRole:
             return node->schedulingError( id() );
         case Qt::ToolTipRole:
             if ( node->schedulingError( id() ) ) {
                 return xi18nc( "@info:tooltip", "Scheduling error" );
             }
             break;
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskErrorColor();
                 case Node::Type_Milestone: return m_project->config().milestoneErrorColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::wbsCode( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
             return node->wbsCode();
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Work breakdown structure code: %1", node->wbsCode() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case SortableRole:
             return node->wbsCode(true);
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeLevel( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
             return node->level();
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Task level: %1", node->level() );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeBCWS( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return m_project->locale()->formatMoney( node->bcws( m_now, id() ), QString(), 0 );
         case Qt::EditRole:
             return node->bcws( m_now, id() );
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Budgeted Cost of Work Scheduled at %1: %2", QLocale().toString( m_now, QLocale::ShortFormat ), m_project->locale()->formatMoney( node->bcws( m_now, id() ), QString(), 0 ) );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeBCWP( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return m_project->locale()->formatMoney( node->bcwp( id() ), QString(), 0 );
         case Qt::EditRole:
             return node->bcwp( id() );
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Budgeted Cost of Work Performed at %1: %2", QLocale().toString( m_now, QLocale::ShortFormat ), m_project->locale()->formatMoney( node->bcwp( id() ), QString(), 0 ) );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeACWP( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return m_project->locale()->formatMoney( node->acwp( m_now, id() ).cost(), QString(), 0 );
         case Qt::EditRole:
             return node->acwp( m_now, id() ).cost();
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Actual Cost of Work Performed at %1: %2", QLocale().toString( m_now, QLocale::ShortFormat ), m_project->locale()->formatMoney( node->acwp( m_now, id() ).cost() ) );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodePerformanceIndex( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
             return QLocale().toString( node->schedulePerformanceIndex( m_now, id() ), 'f', 2 );
         case Qt::EditRole:
             return node->schedulePerformanceIndex( m_now, id() );
         case Qt::ToolTipRole:
             return xi18nc( "@info:tooltip", "Schedule Performance Index at %1: %2", m_now.toString(), QLocale().toString( node->schedulePerformanceIndex( m_now, id() ), 'f', 2 ) );
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Qt::ForegroundRole:
             return QColor(node->schedulePerformanceIndex( m_now, id() ) < 1.0 ? Qt::red : Qt::black);
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeIsCritical( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
             return node->isCritical( id() );
         case Qt::ToolTipRole:
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskNormalColor();
                 case Node::Type_Milestone: return m_project->config().milestoneNormalColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::nodeInCriticalPath( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole:
             return node->inCriticalPath( id() );
         case Qt::ToolTipRole:
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::Foreground: {
             if ( ! m_project ) {
                 break;
             }
             switch ( node->type() ) {
                 case Node::Type_Task: return m_project->config().taskNormalColor();
                 case Node::Type_Milestone: return m_project->config().milestoneNormalColor();
                 default:
                     break;
             }
         }
     }
     return QVariant();
 }
 
 QVariant NodeModel::wpOwnerName( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole: {
             const Task *t = dynamic_cast<const Task*>( node );
             if ( t == 0 ) {
                 return QVariant();
             }
             if ( t->wpTransmitionStatus() == WorkPackage::TS_None ) {
                 return xi18nc( "Not available", "NA" );
             }
             return t->wpOwnerName();
         }
         case Qt::ToolTipRole: {
             const Task *task = dynamic_cast<const Task*>( node );
             if ( task == 0 ) {
                 return QVariant();
             }
             int sts = task->wpTransmitionStatus();
             QString t = wpTransmitionTime( node, Qt::DisplayRole ).toString();
             if ( sts == WorkPackage::TS_Send ) {
                 return xi18nc( "@info:tooltip", "Latest work package sent to %1 at %2", static_cast<const Task*>( node )->wpOwnerName(), t );
             }
             if ( sts == WorkPackage::TS_Receive ) {
                 return xi18nc( "@info:tooltip", "Latest work package received from %1 at %2", static_cast<const Task*>( node )->wpOwnerName(), t );
             }
             return xi18nc( "@info:tooltip", "Not available" );
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::wpTransmitionStatus( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             const Task *t = dynamic_cast<const Task*>( node );
             if ( t == 0 ) {
                 return QVariant();
             }
             if ( t->wpTransmitionStatus() == WorkPackage::TS_None ) {
                 return xi18nc( "Not available", "NA" );
             }
             return WorkPackage::transmitionStatusToString( t->wpTransmitionStatus(), true );
         }
         case Qt::EditRole: {
             const Task *t = dynamic_cast<const Task*>( node );
             if ( t == 0 ) {
                 return QVariant();
             }
             return WorkPackage::transmitionStatusToString( t->wpTransmitionStatus(), false );
         }
         case Qt::ToolTipRole:
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::wpTransmitionTime( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole:
         case Qt::EditRole: {
             const Task *t = dynamic_cast<const Task*>( node );
             if ( t == 0 ) {
                 return QVariant();
             }
             if ( t->wpTransmitionStatus() == WorkPackage::TS_None ) {
                 return xi18nc( "Not available", "NA" );
             }
             return QLocale().toString( t->wpTransmitionTime(), QLocale::ShortFormat );
         }
         case Qt::ToolTipRole: {
             const Task *task = dynamic_cast<const Task*>( node );
             if ( task == 0 ) {
                 return QVariant();
             }
             int sts = task->wpTransmitionStatus();
             QString t = wpTransmitionTime( node, Qt::DisplayRole ).toString();
             if ( sts == WorkPackage::TS_Send ) {
                 return xi18nc( "@info:tooltip", "Latest work package sent: %1", t );
             }
             if ( sts == WorkPackage::TS_Receive ) {
                 return xi18nc( "@info:tooltip", "Latest work package received: %1", t );
             }
             return xi18nc( "@info:tooltip", "Not available" );
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
     }
     return QVariant();
 }
 
 QVariant NodeModel::data( const Node *n, int property, int role ) const
 {
     QVariant result;
     switch ( property ) {
         // Edited by user
         case NodeName: result = name( n, role ); break;
         case NodeType: result = type( n, role ); break;
         case NodeResponsible: result = leader( n, role ); break;
         case NodeAllocation: result = allocation( n, role ); break;
         case NodeEstimateType: result = estimateType( n, role ); break;
         case NodeEstimateCalendar: result = estimateCalendar( n, role ); break;
         case NodeEstimate: result = estimate( n, role ); break;
         case NodeOptimisticRatio: result = optimisticRatio( n, role ); break;
         case NodePessimisticRatio: result = pessimisticRatio( n, role ); break;
         case NodeRisk: result = riskType( n, role ); break;
         case NodeConstraint: result = constraint( n, role ); break;
         case NodeConstraintStart: result = constraintStartTime( n, role ); break;
         case NodeConstraintEnd: result = constraintEndTime( n, role ); break;
         case NodeRunningAccount: result = runningAccount( n, role ); break;
         case NodeStartupAccount: result = startupAccount( n, role ); break;
         case NodeStartupCost: result = startupCost( n, role ); break;
         case NodeShutdownAccount: result = shutdownAccount( n, role ); break;
         case NodeShutdownCost: result = shutdownCost( n, role ); break;
         case NodeDescription: result = description( n, role ); break;
 
         // Based on edited values
         case NodeExpected: result = pertExpected( n->estimate(), role ); break;
         case NodeVarianceEstimate: result = varianceEstimate( n->estimate(), role ); break;
         case NodeOptimistic: result = optimisticEstimate( n->estimate(), role ); break;
         case NodePessimistic: result = pessimisticEstimate( n->estimate(), role ); break;
 
         // After scheduling
         case NodeStartTime: result = startTime( n, role ); break;
         case NodeEndTime: result = endTime( n, role ); break;
         case NodeEarlyStart: result = earlyStart( n, role ); break;
         case NodeEarlyFinish: result = earlyFinish( n, role ); break;
         case NodeLateStart: result = lateStart( n, role ); break;
         case NodeLateFinish: result = lateFinish( n, role ); break;
         case NodePositiveFloat: result = positiveFloat( n, role ); break;
         case NodeFreeFloat: result = freeFloat( n, role ); break;
         case NodeNegativeFloat: result = negativeFloat( n, role ); break;
         case NodeStartFloat: result = startFloat( n, role ); break;
         case NodeFinishFloat: result = finishFloat( n, role ); break;
         case NodeAssignments: result = assignedResources( n, role ); break;
 
         // Based on scheduled values
         case NodeDuration: result = duration( n, role ); break;
         case NodeVarianceDuration: result = varianceDuration( n, role ); break;
         case NodeOptimisticDuration: result = optimisticDuration( n, role ); break;
         case NodePessimisticDuration: result = pessimisticDuration( n, role ); break;
 
         // Completion
         case NodeStatus: result = status( n, role ); break;
         case NodeCompleted: result = completed( n, role ); break;
         case NodePlannedEffort: result = plannedEffortTo( n, role ); break;
         case NodeActualEffort: result = actualEffortTo( n, role ); break;
         case NodeRemainingEffort: result = remainingEffort( n, role ); break;
         case NodePlannedCost: result = plannedCostTo( n, role ); break;
         case NodeActualCost: result = actualCostTo( n, role ); break;
         case NodeActualStart: result = startedTime( n, role ); break;
         case NodeStarted: result = isStarted( n, role ); break;
         case NodeActualFinish: result = finishedTime( n, role ); break;
         case NodeFinished: result = isFinished( n, role ); break;
         case NodeStatusNote: result = note( n, role ); break;
 
         // Scheduling errors
         case NodeSchedulingStatus: result = nodeSchedulingStatus( n, role ); break;
         case NodeNotScheduled: result = nodeIsNotScheduled( n, role ); break;
         case NodeAssignmentMissing: result = resourceIsMissing( n, role ); break;
         case NodeResourceOverbooked: result = resourceIsOverbooked( n, role ); break;
         case NodeResourceUnavailable: result = resourceIsNotAvailable( n, role ); break;
         case NodeConstraintsError: result = schedulingConstraintsError( n, role ); break;
         case NodeEffortNotMet: result = effortNotMet( n, role ); break;
         case NodeSchedulingError: result = schedulingError( n, role ); break;
 
         case NodeWBSCode: result = wbsCode( n, role ); break;
         case NodeLevel: result = nodeLevel( n, role ); break;
 
         // Performance
         case NodeBCWS: result = nodeBCWS( n, role ); break;
         case NodeBCWP: result = nodeBCWP( n, role ); break;
         case NodeACWP: result = nodeACWP( n, role ); break;
         case NodePerformanceIndex: result = nodePerformanceIndex( n, role ); break;
         case NodeCritical: result = nodeIsCritical( n, role ); break;
         case NodeCriticalPath: result = nodeInCriticalPath( n, role ); break;
 
         case WPOwnerName: result = wpOwnerName( n, role ); break;
         case WPTransmitionStatus: result = wpTransmitionStatus( n, role ); break;
         case WPTransmitionTime: result = wpTransmitionTime( n, role ); break;
 
         default:
             //debugPlan<<"Invalid property number: "<<property;
             return result;
     }
     return result;
 }
 
 int NodeModel::propertyCount() const
 {
     return columnMap().keyCount();
 }
 
 KUndo2Command *NodeModel::setData( Node *node, int property, const QVariant & value, int role )
 {
     switch ( property ) {
         case NodeModel::NodeName: return setName( node, value, role );
         case NodeModel::NodeType: return setType( node, value, role );
         case NodeModel::NodeResponsible: return setLeader( node, value, role );
         case NodeModel::NodeAllocation: return setAllocation( node, value, role );
         case NodeModel::NodeEstimateType: return setEstimateType( node, value, role );
         case NodeModel::NodeEstimateCalendar: return setEstimateCalendar( node, value, role );
         case NodeModel::NodeEstimate: return setEstimate( node, value, role );
         case NodeModel::NodeOptimisticRatio: return setOptimisticRatio( node, value, role );
         case NodeModel::NodePessimisticRatio: return setPessimisticRatio( node, value, role );
         case NodeModel::NodeRisk: return setRiskType( node, value, role );
         case NodeModel::NodeConstraint: return setConstraint( node, value, role );
         case NodeModel::NodeConstraintStart: return setConstraintStartTime( node, value, role );
         case NodeModel::NodeConstraintEnd: return setConstraintEndTime( node, value, role );
         case NodeModel::NodeRunningAccount: return setRunningAccount( node, value, role );
         case NodeModel::NodeStartupAccount: return setStartupAccount( node, value, role );
         case NodeModel::NodeStartupCost: return setStartupCost( node, value, role );
         case NodeModel::NodeShutdownAccount: return setShutdownAccount( node, value, role );
         case NodeModel::NodeShutdownCost: return setShutdownCost( node, value, role );
         case NodeModel::NodeDescription: return setDescription( node, value, role );
         case NodeModel::NodeCompleted: return setCompletion( node, value, role );
         case NodeModel::NodeActualEffort: return setActualEffort( node, value, role );
         case NodeModel::NodeRemainingEffort: return setRemainingEffort( node, value, role );
         case NodeModel::NodeActualStart: return setStartedTime( node, value, role );
         case NodeModel::NodeActualFinish: return setFinishedTime( node, value, role );
         default:
             qWarning("data: invalid display value column %d", property);
             return 0;
     }
     return 0;
 }
 
 QVariant NodeModel::headerData( int section, int role )
 {
     if ( role == Qt::DisplayRole ) {
         switch ( section ) {
             case NodeName: return xi18nc( "@title:column", "Name" );
             case NodeType: return xi18nc( "@title:column", "Type" );
             case NodeResponsible: return xi18nc( "@title:column", "Responsible" );
             case NodeAllocation: return xi18nc( "@title:column", "Allocation" );
             case NodeEstimateType: return xi18nc( "@title:column", "Estimate Type" );
             case NodeEstimateCalendar: return xi18nc( "@title:column", "Calendar" );
             case NodeEstimate: return xi18nc( "@title:column", "Estimate" );
             case NodeOptimisticRatio: return xi18nc( "@title:column", "Optimistic" ); // Ratio
             case NodePessimisticRatio: return xi18nc( "@title:column", "Pessimistic" ); // Ratio
             case NodeRisk: return xi18nc( "@title:column", "Risk" );
             case NodeConstraint: return xi18nc( "@title:column", "Constraint" );
             case NodeConstraintStart: return xi18nc( "@title:column", "Constraint Start" );
             case NodeConstraintEnd: return xi18nc( "@title:column", "Constraint End" );
             case NodeRunningAccount: return xi18nc( "@title:column", "Running Account" );
             case NodeStartupAccount: return xi18nc( "@title:column", "Startup Account" );
             case NodeStartupCost: return xi18nc( "@title:column", "Startup Cost" );
             case NodeShutdownAccount: return xi18nc( "@title:column", "Shutdown Account" );
             case NodeShutdownCost: return xi18nc( "@title:column", "Shutdown Cost" );
             case NodeDescription: return xi18nc( "@title:column", "Description" );
 
             // Based on edited values
             case NodeExpected: return xi18nc( "@title:column", "Expected" );
             case NodeVarianceEstimate: return xi18nc( "@title:column", "Variance (Est)" );
             case NodeOptimistic: return xi18nc( "@title:column", "Optimistic" );
             case NodePessimistic: return xi18nc( "@title:column", "Pessimistic" );
 
             // After scheduling
             case NodeStartTime: return xi18nc( "@title:column", "Start Time" );
             case NodeEndTime: return xi18nc( "@title:column", "End Time" );
             case NodeEarlyStart: return xi18nc( "@title:column", "Early Start" );
             case NodeEarlyFinish: return xi18nc( "@title:column", "Early Finish" );
             case NodeLateStart: return xi18nc( "@title:column", "Late Start" );
             case NodeLateFinish: return xi18nc( "@title:column", "Late Finish" );
             case NodePositiveFloat: return xi18nc( "@title:column", "Positive Float" );
             case NodeFreeFloat: return xi18nc( "@title:column", "Free Float" );
             case NodeNegativeFloat: return xi18nc( "@title:column", "Negative Float" );
             case NodeStartFloat: return xi18nc( "@title:column", "Start Float" );
             case NodeFinishFloat: return xi18nc( "@title:column", "Finish Float" );
             case NodeAssignments: return xi18nc( "@title:column", "Assignments" );
 
             // Based on scheduled values
             case NodeDuration: return xi18nc( "@title:column", "Duration" );
             case NodeVarianceDuration: return xi18nc( "@title:column", "Variance (Dur)" );
             case NodeOptimisticDuration: return xi18nc( "@title:column", "Optimistic (Dur)" );
             case NodePessimisticDuration: return xi18nc( "@title:column", "Pessimistic (Dur)" );
 
             // Completion
             case NodeStatus: return xi18nc( "@title:column", "Status" );
             // xgettext: no-c-format
             case NodeCompleted: return xi18nc( "@title:column", "% Completed" );
             case NodePlannedEffort: return xi18nc( "@title:column", "Planned Effort" );
             case NodeActualEffort: return xi18nc( "@title:column", "Actual Effort" );
             case NodeRemainingEffort: return xi18nc( "@title:column", "Remaining Effort" );
             case NodePlannedCost: return xi18nc( "@title:column", "Planned Cost" );
             case NodeActualCost: return xi18nc( "@title:column", "Actual Cost" );
             case NodeActualStart: return xi18nc( "@title:column", "Actual Start" );
             case NodeStarted: return xi18nc( "@title:column", "Started" );
             case NodeActualFinish: return xi18nc( "@title:column", "Actual Finish" );
             case NodeFinished: return xi18nc( "@title:column", "Finished" );
             case NodeStatusNote: return xi18nc( "@title:column", "Status Note" );
 
             // Scheduling errors
             case NodeSchedulingStatus: return xi18nc( "@title:column", "Scheduling Status" );
             case NodeNotScheduled: return xi18nc( "@title:column", "Not Scheduled" );
             case NodeAssignmentMissing: return xi18nc( "@title:column", "Assignment Missing" );
             case NodeResourceOverbooked: return xi18nc( "@title:column", "Resource Overbooked" );
             case NodeResourceUnavailable: return xi18nc( "@title:column", "Resource Unavailable" );
             case NodeConstraintsError: return xi18nc( "@title:column", "Constraints Error" );
             case NodeEffortNotMet: return xi18nc( "@title:column", "Effort Not Met" );
             case NodeSchedulingError: return xi18nc( "@title:column", "Scheduling Error" );
 
             case NodeWBSCode: return xi18nc( "@title:column", "WBS Code" );
             case NodeLevel: return xi18nc( "@title:column Node level", "Level" );
 
             // Performance
             case NodeBCWS: return xi18nc( "@title:column Budgeted Cost of Work Scheduled", "BCWS" );
             case NodeBCWP: return xi18nc( "@title:column Budgeted Cost of Work Performed", "BCWP" );
             case NodeACWP: return xi18nc( "@title:column Actual Cost of Work Performed", "ACWP" );
             case NodePerformanceIndex: return xi18nc( "@title:column Schedule Performance Index", "SPI" );
             case NodeCritical: return xi18nc( "@title:column", "Critical" );
             case NodeCriticalPath: return xi18nc( "@title:column", "Critical Path" );
 
             // Work package handling
             case WPOwnerName: return xi18nc( "@title:column", "Owner" );
             case WPTransmitionStatus: return xi18nc( "@title:column", "Status" );
             case WPTransmitionTime: return xi18nc( "@title:column", "Time" );
 
             default: return QVariant();
         }
     }
     if ( role == Qt::EditRole ) {
         switch ( section ) {
             case NodeName: return "Name";
             case NodeType: return "Type";
             case NodeResponsible: return "Responsible";
             case NodeAllocation: return "Allocation";
             case NodeEstimateType: return "Estimate Type";
             case NodeEstimateCalendar: return "Calendar";
             case NodeEstimate: return "Estimate";
             case NodeOptimisticRatio: return "Optimistic"; // Ratio
             case NodePessimisticRatio: return "Pessimistic"; // Ratio
             case NodeRisk: return "Risk";
             case NodeConstraint: return "Constraint";
             case NodeConstraintStart: return "Constraint Start";
             case NodeConstraintEnd: return "Constraint End";
             case NodeRunningAccount: return "Running Account";
             case NodeStartupAccount: return "Startup Account";
             case NodeStartupCost: return "Startup Cost";
             case NodeShutdownAccount: return "Shutdown Account";
             case NodeShutdownCost: return "Shutdown Cost";
             case NodeDescription: return "Description";
 
             // Based on edited values
             case NodeExpected: return "Expected";
             case NodeVarianceEstimate: return "Variance (Est)";
             case NodeOptimistic: return "Optimistic";
             case NodePessimistic: return "Pessimistic";
 
             // After scheduling
             case NodeStartTime: return "Start Time";
             case NodeEndTime: return "End Time";
             case NodeEarlyStart: return "Early Start";
             case NodeEarlyFinish: return "Early Finish";
             case NodeLateStart: return "Late Start";
             case NodeLateFinish: return "Late Finish";
             case NodePositiveFloat: return "Positive Float";
             case NodeFreeFloat: return "Free Float";
             case NodeNegativeFloat: return "Negative Float";
             case NodeStartFloat: return "Start Float";
             case NodeFinishFloat: return "Finish Float";
             case NodeAssignments: return "Assignments";
 
             // Based on scheduled values
             case NodeDuration: return "Duration";
             case NodeVarianceDuration: return "Variance (Dur)";
             case NodeOptimisticDuration: return "Optimistic (Dur)";
             case NodePessimisticDuration: return "Pessimistic (Dur)";
 
             // Completion
             case NodeStatus: return "Status";
             // xgettext: no-c-format
             case NodeCompleted: return "% Completed";
             case NodePlannedEffort: return "Planned Effort";
             case NodeActualEffort: return "Actual Effort";
             case NodeRemainingEffort: return "Remaining Effort";
             case NodePlannedCost: return "Planned Cost";
             case NodeActualCost: return "Actual Cost";
             case NodeActualStart: return "Actual Start";
             case NodeStarted: return "Started";
             case NodeActualFinish: return "Actual Finish";
             case NodeFinished: return "Finished";
             case NodeStatusNote: return "Status Note";
 
             // Scheduling errors
             case NodeSchedulingStatus: return "Scheduling Status";
             case NodeNotScheduled: return "Not Scheduled";
             case NodeAssignmentMissing: return "Assignment Missing";
             case NodeResourceOverbooked: return "Resource Overbooked";
             case NodeResourceUnavailable: return "Resource Unavailable";
             case NodeConstraintsError: return "Constraints Error";
             case NodeEffortNotMet: return "Effort Not Met";
             case NodeSchedulingError: return "Scheduling Error";
 
             case NodeWBSCode: return "WBS Code";
             case NodeLevel: return "Level";
 
             // Performance
             case NodeBCWS: return "BCWS";
             case NodeBCWP: return "BCWP";
             case NodeACWP: return "ACWP";
             case NodePerformanceIndex: return "SPI";
             case NodeCritical: return "Critical";
             case NodeCriticalPath: return "Critical Path";
 
             // Work package handling
             case WPOwnerName: return "Owner";
             case WPTransmitionStatus: return "Status";
             case WPTransmitionTime: return "Time";
 
             default: return QVariant();
         }
     }
     if ( role == Qt::ToolTipRole ) {
         switch ( section ) {
             case NodeName: return ToolTip::nodeName();
             case NodeType: return ToolTip::nodeType();
             case NodeResponsible: return ToolTip::nodeResponsible();
             case NodeAllocation: return ToolTip::allocation();
             case NodeEstimateType: return ToolTip::estimateType();
             case NodeEstimateCalendar: return ToolTip::estimateCalendar();
             case NodeEstimate: return ToolTip::estimate();
             case NodeOptimisticRatio: return ToolTip::optimisticRatio();
             case NodePessimisticRatio: return ToolTip::pessimisticRatio();
             case NodeRisk: return ToolTip::riskType();
             case NodeConstraint: return ToolTip::nodeConstraint();
             case NodeConstraintStart: return ToolTip::nodeConstraintStart();
             case NodeConstraintEnd: return ToolTip::nodeConstraintEnd();
             case NodeRunningAccount: return ToolTip::nodeRunningAccount();
             case NodeStartupAccount: return ToolTip::nodeStartupAccount();
             case NodeStartupCost: return ToolTip::nodeStartupCost();
             case NodeShutdownAccount: return ToolTip::nodeShutdownAccount();
             case NodeShutdownCost: return ToolTip::nodeShutdownCost();
             case NodeDescription: return ToolTip::nodeDescription();
 
             // Based on edited values
             case NodeExpected: return ToolTip::estimateExpected();
             case NodeVarianceEstimate: return ToolTip::estimateVariance();
             case NodeOptimistic: return ToolTip::estimateOptimistic();
             case NodePessimistic: return ToolTip::estimatePessimistic();
 
             // After scheduling
             case NodeStartTime: return ToolTip::nodeStartTime();
             case NodeEndTime: return ToolTip::nodeEndTime();
             case NodeEarlyStart: return ToolTip::nodeEarlyStart();
             case NodeEarlyFinish: return ToolTip::nodeEarlyFinish();
             case NodeLateStart: return ToolTip::nodeLateStart();
             case NodeLateFinish: return ToolTip::nodeLateFinish();
             case NodePositiveFloat: return ToolTip::nodePositiveFloat();
             case NodeFreeFloat: return ToolTip::nodeFreeFloat();
             case NodeNegativeFloat: return ToolTip::nodeNegativeFloat();
             case NodeStartFloat: return ToolTip::nodeStartFloat();
             case NodeFinishFloat: return ToolTip::nodeFinishFloat();
             case NodeAssignments: return ToolTip::nodeAssignment();
 
             // Based on scheduled values
             case NodeDuration: return ToolTip::nodeDuration();
             case NodeVarianceDuration: return ToolTip::nodeVarianceDuration();
             case NodeOptimisticDuration: return ToolTip::nodeOptimisticDuration();
             case NodePessimisticDuration: return ToolTip::nodePessimisticDuration();
 
             // Completion
             case NodeStatus: return ToolTip::nodeStatus();
             case NodeCompleted: return ToolTip::nodeCompletion();
             case NodePlannedEffort: return ToolTip::nodePlannedEffortTo();
             case NodeActualEffort: return ToolTip::nodeActualEffortTo();
             case NodeRemainingEffort: return ToolTip::nodeRemainingEffort();
             case NodePlannedCost: return ToolTip::nodePlannedCostTo();
             case NodeActualCost: return ToolTip::nodeActualCostTo();
             case NodeActualStart: return ToolTip::completionStartedTime();
             case NodeStarted: return ToolTip::completionStarted();
             case NodeActualFinish: return ToolTip::completionFinishedTime();
             case NodeFinished: return ToolTip::completionFinished();
             case NodeStatusNote: return ToolTip::completionStatusNote();
 
             // Scheduling errors
             case NodeSchedulingStatus: return ToolTip::nodeSchedulingStatus();
             case NodeNotScheduled: return ToolTip::nodeNotScheduled();
             case NodeAssignmentMissing: return ToolTip::nodeAssignmentMissing();
             case NodeResourceOverbooked: return ToolTip::nodeResourceOverbooked();
             case NodeResourceUnavailable: return ToolTip::nodeResourceUnavailable();
             case NodeConstraintsError: return ToolTip::nodeConstraintsError();
             case NodeEffortNotMet: return ToolTip::nodeEffortNotMet();
             case NodeSchedulingError: return ToolTip::nodeSchedulingError();
 
             case NodeWBSCode: return ToolTip::nodeWBS();
             case NodeLevel: return ToolTip::nodeLevel();
 
             // Performance
             case NodeBCWS: return ToolTip::nodeBCWS();
             case NodeBCWP: return ToolTip::nodeBCWP();
             case NodeACWP: return ToolTip::nodeACWP();
             case NodePerformanceIndex: return ToolTip::nodePerformanceIndex();
 
             // Work package handling FIXME
             case WPOwnerName: return xi18nc( "@info:tooltip", "Work package owner" );
             case WPTransmitionStatus: return xi18nc( "@info:tooltip", "Work package status" );
             case WPTransmitionTime: return xi18nc( "@info:tooltip", "Work package send/receive time" );
 
             default: return QVariant();
         }
     }
     if ( role == Qt::TextAlignmentRole ) {
         switch (section) {
             case NodeName:
             case NodeType:
             case NodeResponsible:
             case NodeAllocation:
             case NodeEstimateType:
             case NodeEstimateCalendar:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             case NodeEstimate:
             case NodeOptimisticRatio:
             case NodePessimisticRatio:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
             case NodeRisk:
             case NodeConstraint:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             case NodeConstraintStart:
             case NodeConstraintEnd:
             case NodeRunningAccount:
             case NodeStartupAccount:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             case NodeStartupCost:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
             case NodeShutdownAccount:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             case NodeShutdownCost:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
             case NodeDescription:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
 
             // Based on edited values
             case NodeExpected:
             case NodeVarianceEstimate:
             case NodeOptimistic:
             case NodePessimistic:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
 
             // After scheduling
             case NodeStartTime:
             case NodeEndTime:
             case NodeEarlyStart:
             case NodeEarlyFinish:
             case NodeLateStart:
             case NodeLateFinish:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             case NodePositiveFloat:
             case NodeFreeFloat:
             case NodeNegativeFloat:
             case NodeStartFloat:
             case NodeFinishFloat:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
             case NodeAssignments:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
 
             // Based on scheduled values
             case NodeDuration:
             case NodeVarianceDuration:
             case NodeOptimisticDuration:
             case NodePessimisticDuration:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
 
             // Completion
             case NodeStatus:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             case NodeCompleted:
                 return (int)(Qt::AlignCenter); // special, presented as a bar
             case NodePlannedEffort:
             case NodeActualEffort:
             case NodeRemainingEffort:
             case NodePlannedCost:
             case NodeActualCost:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
             case NodeActualStart:
             case NodeStarted:
             case NodeActualFinish:
             case NodeFinished:
             case NodeStatusNote:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
 
             // Scheduling errors
             case NodeSchedulingStatus:
             case NodeNotScheduled:
             case NodeAssignmentMissing:
             case NodeResourceOverbooked:
             case NodeResourceUnavailable:
             case NodeConstraintsError:
             case NodeEffortNotMet:
             case NodeSchedulingError:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
 
             case NodeWBSCode:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             case NodeLevel:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
 
             // Performance
             case NodeBCWS:
             case NodeBCWP:
             case NodeACWP:
             case NodePerformanceIndex:
                 return (int)(Qt::AlignRight|Qt::AlignVCenter); // number
             case NodeCritical:
             case NodeCriticalPath:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
 
             case WPOwnerName:
             case WPTransmitionStatus:
             case WPTransmitionTime:
                 return (int)(Qt::AlignLeft|Qt::AlignVCenter);
             default:
                 return QVariant();
         }
     }
     if ( role == Qt::WhatsThisRole ) {
         switch ( section ) {
             case NodeNegativeFloat: return WhatsThis::nodeNegativeFloat();
 
             default: return QVariant();
         }
     }
     return QVariant();
 }
 
 KUndo2Command *NodeModel::setName( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             if ( value.toString() == node->name() ) {
                 return 0;
             }
             KUndo2MagicString s = kundo2_i18n( "Modify name" );
             switch ( node->type() ) {
                 case Node::Type_Task: s = kundo2_i18n( "Modify task name" ); break;
                 case Node::Type_Milestone: s = kundo2_i18n( "Modify milestone name" ); break;
                 case Node::Type_Summarytask: s = kundo2_i18n( "Modify summarytask name" ); break;
                 case Node::Type_Project: s = kundo2_i18n( "Modify project name" ); break;
             }
             return new NodeModifyNameCmd( *node, value.toString(), s );
         }
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setLeader( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             if ( value.toString() != node->leader() ) {
                 return new NodeModifyLeaderCmd( *node, value.toString(), kundo2_i18n( "Modify responsible" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setAllocation( Node */*node*/, const QVariant &/*value*/, int /*role*/ )
 {
     return 0;
 }
 
 KUndo2Command *NodeModel::setDescription( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole:
             if ( value.toString() == node->description() ) {
                 return 0;
             }
             return new NodeModifyDescriptionCmd( *node, value.toString(), kundo2_i18n( "Modify task description" ) );
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setType( Node *, const QVariant &, int )
 {
     return 0;
 }
 
 KUndo2Command *NodeModel::setConstraint( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             Node::ConstraintType v;
             QStringList lst = node->constraintList( false );
             if ( lst.contains( value.toString() ) ) {
                 v = Node::ConstraintType( lst.indexOf( value.toString() ) );
             } else {
                 v = Node::ConstraintType( value.toInt() );
             }
             //debugPlan<<v;
             if ( v != node->constraint() ) {
                 return new NodeModifyConstraintCmd( *node, v, kundo2_i18n( "Modify constraint type" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setConstraintStartTime( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             QDateTime dt = value.toDateTime();
             dt.setTime( QTime( dt.time().hour(), dt.time().minute(), 0 ) ); // reset possible secs/msecs
             if ( dt != node->constraintStartTime() ) {
                 return new NodeModifyConstraintStartTimeCmd( *node, dt, kundo2_i18n( "Modify constraint start time" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setConstraintEndTime( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             QDateTime dt = value.toDateTime();
             dt.setTime( QTime( dt.time().hour(), dt.time().minute(), 0 ) ); // reset possible secs/msecs
             if ( dt != node->constraintEndTime() ) {
                 return new NodeModifyConstraintEndTimeCmd( *node, dt, kundo2_i18n( "Modify constraint end time" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setEstimateType( Node *node, const QVariant &value, int role )
 {
     if ( node->estimate() == 0 ) {
         return 0;
     }
     switch ( role ) {
         case Qt::EditRole: {
             Estimate::Type v;
             QStringList lst = node->estimate()->typeToStringList( false );
             if ( lst.contains( value.toString() ) ) {
                 v = Estimate::Type( lst.indexOf( value.toString() ) );
             } else {
                 v = Estimate::Type( value.toInt() );
             }
             if ( v != node->estimate()->type() ) {
                 return new ModifyEstimateTypeCmd( *node, node->estimate()->type(), v, kundo2_i18n( "Modify estimate type" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setEstimateCalendar( Node *node, const QVariant &value, int role )
 {
     if ( node->estimate() == 0 ) {
         return 0;
     }
     switch ( role ) {
         case Qt::EditRole: {
             Calendar *c = 0;
             Calendar *old = node->estimate()->calendar();
             if ( value.toInt() > 0 ) {
                 QStringList lst = estimateCalendar( node, Role::EnumList ).toStringList();
                 if ( value.toInt() < lst.count() ) {
                     c = m_project->calendarByName( lst.at( value.toInt() ) );
                 }
             }
             if ( c != old ) {
                 return new ModifyEstimateCalendarCmd( *node, old, c, kundo2_i18n( "Modify estimate calendar" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setEstimate( Node *node, const QVariant &value, int role )
 {
     if ( node->estimate() == 0 ) {
         return 0;
     }
     switch ( role ) {
         case Qt::EditRole: {
             double d;
             Duration::Unit unit;
             if ( value.toList().count() == 2 ) {
                 d =  value.toList()[0].toDouble();
                 unit = static_cast<Duration::Unit>( value.toList()[1].toInt() );
             } else if ( value.canConvert<QString>() ) {
                 bool ok = Duration::valueFromString( value.toString(), d, unit );
                 if ( ! ok ) {
                     return 0;
                 }
             } else {
                 return 0;
             }
             //debugPlan<<d<<","<<unit<<" ->"<<value.toList()[1].toInt();
             MacroCommand *cmd = 0;
             if ( d != node->estimate()->expectedEstimate() ) {
                 if ( cmd == 0 ) cmd = new MacroCommand( kundo2_i18n( "Modify estimate" ) );
                 cmd->addCommand( new ModifyEstimateCmd( *node, node->estimate()->expectedEstimate(), d ) );
             }
             if ( unit != node->estimate()->unit() ) {
                 if ( cmd == 0 ) cmd = new MacroCommand( kundo2_i18n( "Modify estimate" ) );
                 cmd->addCommand( new ModifyEstimateUnitCmd( *node, node->estimate()->unit(), unit ) );
             }
             if ( cmd ) {
                 return cmd;
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setOptimisticRatio( Node *node, const QVariant &value, int role )
 {
     if ( node->estimate() == 0 ) {
         return 0;
     }
     switch ( role ) {
         case Qt::EditRole:
             if ( value.toInt() != node->estimate()->optimisticRatio() ) {
                 return new EstimateModifyOptimisticRatioCmd( *node, node->estimate()->optimisticRatio(), value.toInt(), kundo2_i18n( "Modify optimistic estimate" ) );
             }
             break;
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setPessimisticRatio( Node *node, const QVariant &value, int role )
 {
     if ( node->estimate() == 0 ) {
         return 0;
     }
     switch ( role ) {
         case Qt::EditRole:
             if ( value.toInt() != node->estimate()->pessimisticRatio() ) {
                 return new EstimateModifyPessimisticRatioCmd( *node, node->estimate()->pessimisticRatio(), value.toInt(), kundo2_i18n( "Modify pessimistic estimate" ) );
             }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setRiskType( Node *node, const QVariant &value, int role )
 {
     if ( node->estimate() == 0 ) {
         return 0;
     }
     switch ( role ) {
         case Qt::EditRole: {
             int val = 0;
             QStringList lst = node->estimate()->risktypeToStringList( false );
             if ( lst.contains( value.toString() ) ) {
                 val = lst.indexOf( value.toString() );
             } else {
                 val = value.toInt();
             }
             if ( val != node->estimate()->risktype() ) {
                 Estimate::Risktype v = Estimate::Risktype( val );
                 return new EstimateModifyRiskCmd( *node, node->estimate()->risktype(), v, kundo2_i18n( "Modify risk type" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setRunningAccount( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             //debugPlan<<node->name();
             QStringList lst = runningAccount( node, Role::EnumList ).toStringList();
             if ( value.toInt() < lst.count() ) {
                 Account *a = m_project->accounts().findAccount( lst.at( value.toInt() ) );
                 Account *old = node->runningAccount();
                 if ( old != a ) {
                     return new NodeModifyRunningAccountCmd( *node, old, a, kundo2_i18n( "Modify running account" ) );
                 }
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setStartupAccount( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             //debugPlan<<node->name();
             QStringList lst = startupAccount( node, Role::EnumList ).toStringList();
             if ( value.toInt() < lst.count() ) {
                 Account *a = m_project->accounts().findAccount( lst.at( value.toInt() ) );
                 Account *old = node->startupAccount();
                 //debugPlan<<(value.toInt())<<";"<<(lst.at( value.toInt()))<<":"<<a;
                 if ( old != a ) {
                     return new NodeModifyStartupAccountCmd( *node, old, a, kundo2_i18n( "Modify startup account" ) );
                 }
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setStartupCost( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             double v = value.toDouble();
             if ( v != node->startupCost() ) {
                 return new NodeModifyStartupCostCmd( *node, v, kundo2_i18n( "Modify startup cost" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setShutdownAccount( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             //debugPlan<<node->name();
             QStringList lst = shutdownAccount( node, Role::EnumList ).toStringList();
             if ( value.toInt() < lst.count() ) {
                 Account *a = m_project->accounts().findAccount( lst.at( value.toInt() ) );
                 Account *old = node->shutdownAccount();
                 if ( old != a ) {
                     return new NodeModifyShutdownAccountCmd( *node, old, a, kundo2_i18n( "Modify shutdown account" ) );
                 }
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setShutdownCost( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             double v = value.toDouble();
             if ( v != node->shutdownCost() ) {
                 return new NodeModifyShutdownCostCmd( *node, v, kundo2_i18n( "Modify shutdown cost" ) );
             }
             break;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setCompletion( Node */*node*/, const QVariant &/*value*/, int /*role*/ )
 {
     return 0;
 }
 
 KUndo2Command *NodeModel::setRemainingEffort( Node *node, const QVariant &value, int role )
 {
     if ( role == Qt::EditRole && node->type() == Node::Type_Task ) {
         Task *t = static_cast<Task*>( node );
         double d( value.toList()[0].toDouble() );
         Duration::Unit unit = static_cast<Duration::Unit>( value.toList()[1].toInt() );
         Duration dur( d, unit );
         return new ModifyCompletionRemainingEffortCmd( t->completion(), QDate::currentDate(), dur, kundo2_i18n( "Modify remaining effort" ) );
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setActualEffort( Node *node, const QVariant &value, int role )
 {
     if ( role == Qt::EditRole && node->type() == Node::Type_Task ) {
         Task *t = static_cast<Task*>( node );
         double d( value.toList()[0].toDouble() );
         Duration::Unit unit = static_cast<Duration::Unit>( value.toList()[1].toInt() );
         Duration dur( d, unit );
         return new ModifyCompletionActualEffortCmd( t->completion(), QDate::currentDate(), dur, kundo2_i18n( "Modify actual effort" ) );
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setStartedTime( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             Task *t = qobject_cast<Task*>( node );
             if ( t == 0 ) {
                 return 0;
             }
             MacroCommand *m = new MacroCommand( kundo2_i18n( "Modify actual start time" ) );
             if ( ! t->completion().isStarted() ) {
                 m->addCommand( new ModifyCompletionStartedCmd( t->completion(), true ) );
             }
             m->addCommand( new ModifyCompletionStartTimeCmd( t->completion(), value.toDateTime() ) );
             if ( t->type() == Node::Type_Milestone ) {
                 m->addCommand( new ModifyCompletionFinishedCmd( t->completion(), true ) );
                 m->addCommand( new ModifyCompletionFinishTimeCmd( t->completion(), value.toDateTime() ) );
                 if ( t->completion().percentFinished() < 100 ) {
                     Completion::Entry *e = new Completion::Entry( 100, Duration::zeroDuration, Duration::zeroDuration );
                     m->addCommand( new AddCompletionEntryCmd( t->completion(), value.toDate(), e ) );
                 }
             }
             return m;
         }
         default:
             break;
     }
     return 0;
 }
 
 KUndo2Command *NodeModel::setFinishedTime( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             Task *t = qobject_cast<Task*>( node );
             if ( t == 0 ) {
                 return 0;
             }
             MacroCommand *m = new MacroCommand( kundo2_i18n( "Modify actual finish time" ) );
             if ( ! t->completion().isFinished() ) {
                 m->addCommand( new ModifyCompletionFinishedCmd( t->completion(), true ) );
                 if ( t->completion().percentFinished() < 100 ) {
                     Completion::Entry *e = new Completion::Entry( 100, Duration::zeroDuration, Duration::zeroDuration );
                     m->addCommand( new AddCompletionEntryCmd( t->completion(), value.toDate(), e ) );
                 }
             }
             m->addCommand( new ModifyCompletionFinishTimeCmd( t->completion(), value.toDateTime() ) );
             if ( t->type() == Node::Type_Milestone ) {
                 m->addCommand( new ModifyCompletionStartedCmd( t->completion(), true ) );
                 m->addCommand( new ModifyCompletionStartTimeCmd( t->completion(), value.toDateTime() ) );
             }
             return m;
         }
         default:
             break;
     }
     return 0;
 }
 
 //----------------------------
 NodeItemModel::NodeItemModel( QObject *parent )
     : ItemModelBase( parent ),
     m_node( 0 ),
     m_projectshown( false )
 {
     setReadOnly( NodeModel::NodeDescription, true );
 }
 
 NodeItemModel::~NodeItemModel()
 {
 }
 
 void NodeItemModel::setShowProject( bool on )
 {
     m_projectshown = on;
     reset();
     emit projectShownChanged( on );
 }
 
 void NodeItemModel::slotNodeToBeInserted( Node *parent, int row )
 {
     //debugPlan<<parent->name()<<"; "<<row;
     Q_ASSERT( m_node == 0 );
     m_node = parent;
     beginInsertRows( index( parent ), row, row );
 }
 
 void NodeItemModel::slotNodeInserted( Node *node )
 {
     //debugPlan<<node->parentNode()->name()<<"-->"<<node->name();
     Q_ASSERT( node->parentNode() == m_node );
     endInsertRows();
     m_node = 0;
     emit nodeInserted( node );
 }
 
 void NodeItemModel::slotNodeToBeRemoved( Node *node )
 {
     //debugPlan<<node->name();
     Q_ASSERT( m_node == 0 );
     m_node = node;
     int row = index( node ).row();
     beginRemoveRows( index( node->parentNode() ), row, row );
 }
 
 void NodeItemModel::slotNodeRemoved( Node *node )
 {
     //debugPlan<<node->name();
     Q_ASSERT( node == m_node );
 #ifdef NDEBUG
     Q_UNUSED(node)
 #endif
     endRemoveRows();
     m_node = 0;
 }
 
 void NodeItemModel::slotNodeToBeMoved( Node *node, int pos, Node *newParent, int newPos )
 {
     //debugPlan<<node->parentNode()->name()<<pos<<":"<<newParent->name()<<newPos;
     beginMoveRows( index( node->parentNode() ), pos, pos, index( newParent ), newPos );
 }
 
 void NodeItemModel::slotNodeMoved( Node *node )
 {
     Q_UNUSED( node );
     //debugPlan<<node->parentNode()->name()<<node->parentNode()->indexOf( node );
     endMoveRows();
 }
 
 void NodeItemModel::slotLayoutChanged()
 {
     //debugPlan<<node->name();
     emit layoutAboutToBeChanged();
     emit layoutChanged();
 }
 
 void NodeItemModel::slotProjectCalculated(ScheduleManager *sm)
 {
     debugPlan<<m_manager<<sm;
     if ( sm && sm == m_manager ) {
         slotLayoutChanged();
     }
 }
 
 void NodeItemModel::slotWbsDefinitionChanged()
 {
     debugPlan;
     if ( m_project == 0 ) {
         return;
     }
     if ( m_projectshown ) {
         QModelIndex idx = createIndex( 0, NodeModel::NodeWBSCode, m_project );
         emit dataChanged( idx, idx );
     }
     foreach ( Node *n, m_project->allNodes() ) {
         int row = n->parentNode()->indexOf( n );
         QModelIndex idx = createIndex( row, NodeModel::NodeWBSCode, n );
         emit dataChanged( idx, idx );
     }
 }
 
 
 void NodeItemModel::setProject( Project *project )
 {
     if ( m_project ) {
         disconnect(m_project, SIGNAL(aboutToBeDeleted()), this, SLOT(projectDeleted()));
         disconnect( m_project, SIGNAL(localeChanged()), this, SLOT(slotLayoutChanged()) );
         disconnect( m_project, SIGNAL(wbsDefinitionChanged()), this, SLOT(slotWbsDefinitionChanged()) );
         disconnect( m_project, SIGNAL(nodeChanged(Node*)), this, SLOT(slotNodeChanged(Node*)) );
         disconnect( m_project, SIGNAL(nodeToBeAdded(Node*,int)), this, SLOT(slotNodeToBeInserted(Node*,int)) );
         disconnect( m_project, SIGNAL(nodeToBeRemoved(Node*)), this, SLOT(slotNodeToBeRemoved(Node*)) );
 
         disconnect( m_project, SIGNAL(nodeToBeMoved(Node*,int,Node*,int)), this, SLOT(slotNodeToBeMoved(Node*,int,Node*,int)) );
         disconnect( m_project, SIGNAL(nodeMoved(Node*)), this, SLOT(slotNodeMoved(Node*)) );
 
         disconnect( m_project, SIGNAL(nodeAdded(Node*)), this, SLOT(slotNodeInserted(Node*)) );
         disconnect( m_project, SIGNAL(nodeRemoved(Node*)), this, SLOT(slotNodeRemoved(Node*)) );
         disconnect( m_project, SIGNAL(projectCalculated(ScheduleManager*)), this, SLOT(slotProjectCalculated(ScheduleManager*)));
     }
     m_project = project;
     debugPlan<<this<<m_project<<"->"<<project;
     m_nodemodel.setProject( project );
     if ( project ) {
         connect(m_project, SIGNAL(aboutToBeDeleted()), this, SLOT(projectDeleted()));
         connect( m_project, SIGNAL(localeChanged()), this, SLOT(slotLayoutChanged()) );
         connect( m_project, SIGNAL(wbsDefinitionChanged()), this, SLOT(slotWbsDefinitionChanged()) );
         connect( m_project, SIGNAL(nodeChanged(Node*)), this, SLOT(slotNodeChanged(Node*)) );
         connect( m_project, SIGNAL(nodeToBeAdded(Node*,int)), this, SLOT(slotNodeToBeInserted(Node*,int)) );
         connect( m_project, SIGNAL(nodeToBeRemoved(Node*)), this, SLOT(slotNodeToBeRemoved(Node*)) );
 
         connect( m_project, SIGNAL(nodeToBeMoved(Node*,int,Node*,int)), this, SLOT(slotNodeToBeMoved(Node*,int,Node*,int)) );
         connect( m_project, SIGNAL(nodeMoved(Node*)), this, SLOT(slotNodeMoved(Node*)) );
 
         connect( m_project, SIGNAL(nodeAdded(Node*)), this, SLOT(slotNodeInserted(Node*)) );
         connect( m_project, SIGNAL(nodeRemoved(Node*)), this, SLOT(slotNodeRemoved(Node*)) );
         connect( m_project, SIGNAL(projectCalculated(ScheduleManager*)), this, SLOT(slotProjectCalculated(ScheduleManager*)));
     }
     reset();
 }
 
 void NodeItemModel::setScheduleManager( ScheduleManager *sm )
 {
     if (sm == m_nodemodel.manager()) {
         return;
     }
     if ( m_nodemodel.manager() ) {
     }
     m_nodemodel.setManager( sm );
     ItemModelBase::setScheduleManager( sm );
     if ( sm ) {
     }
     debugPlan<<this<<sm;
     reset();
 }
 
 Qt::ItemFlags NodeItemModel::flags( const QModelIndex &index ) const
 {
     Qt::ItemFlags flags = QAbstractItemModel::flags( index );
     if ( !index.isValid() ) {
         if ( m_readWrite ) {
             flags |= Qt::ItemIsDropEnabled;
         }
         return flags;
     }
     if ( isColumnReadOnly( index.column() ) ) {
         //debugPlan<<"Column is readonly:"<<index.column();
         return flags;
     }
     Node *n = node( index );
     if ( m_readWrite && n != 0 ) {
         bool baselined = n->isBaselined();
         flags |= Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
         switch ( index.column() ) {
             case NodeModel::NodeName: // name
                 flags |= Qt::ItemIsEditable;
                 break;
             case NodeModel::NodeType: break; // Node type
             case NodeModel::NodeResponsible: // Responsible
                 flags |= Qt::ItemIsEditable;
                 break;
             case NodeModel::NodeAllocation: // allocation
                 if ( n->type() == Node::Type_Task ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             case NodeModel::NodeEstimateType: // estimateType
             {
                 if ( ! baselined && ( n->type() == Node::Type_Task || n->type() == Node::Type_Milestone ) ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeEstimate: // estimate
             {
                 if ( ! baselined && ( n->type() == Node::Type_Task || n->type() == Node::Type_Milestone ) ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeOptimisticRatio: // optimisticRatio
             case NodeModel::NodePessimisticRatio: // pessimisticRatio
             {
                 if ( ! baselined && n->type() == Node::Type_Task ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeEstimateCalendar:
             {
                 if ( ! baselined && n->type() == Node::Type_Task )
                 {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeRisk: // risktype
             {
                 if ( ! baselined && n->type() == Node::Type_Task ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeConstraint: // constraint type
                 if ( ! baselined && ( n->type() == Node::Type_Task || n->type() == Node::Type_Milestone ) ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             case NodeModel::NodeConstraintStart: { // constraint start
                 if ( ! baselined && n->type() == Node::Type_Project ) {
                     flags |= Qt::ItemIsEditable;
                     break;
                 }
                 if ( ! baselined && ! ( n->type() == Node::Type_Task || n->type() == Node::Type_Milestone ) ) {
                     break;
                 }
                 flags |= Qt::ItemIsEditable;
                 break;
             }
             case NodeModel::NodeConstraintEnd: { // constraint end
                 if ( ! baselined && n->type() == Node::Type_Project ) {
                     flags |= Qt::ItemIsEditable;
                     break;
                 }
                 if ( ! baselined && ! ( n->type() == Node::Type_Task || n->type() == Node::Type_Milestone ) ) {
                     break;
                 }
                 flags |= Qt::ItemIsEditable;
                 break;
             }
             case NodeModel::NodeRunningAccount: // running account
                 if ( ! baselined && n->type() == Node::Type_Task ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             case NodeModel::NodeStartupAccount: // startup account
             case NodeModel::NodeStartupCost: // startup cost
             case NodeModel::NodeShutdownAccount: // shutdown account
             case NodeModel::NodeShutdownCost: { // shutdown cost
                 if ( ! baselined && ( n->type() == Node::Type_Task || n->type() == Node::Type_Milestone ) ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeDescription: // description
                 flags |= Qt::ItemIsEditable;
                 break;
             default:
                 break;
         }
         Task *t = static_cast<Task*>( n );
         if ( manager() && t->isScheduled( id() ) ) {
             if ( ! t->completion().isStarted() ) {
                 switch ( index.column() ) {
                     case NodeModel::NodeActualStart:
                         flags |= Qt::ItemIsEditable;
                         break;
                     case NodeModel::NodeActualFinish:
                         if ( t->type() == Node::Type_Milestone ) {
                             flags |= Qt::ItemIsEditable;
                         }
                         break;
                     case NodeModel::NodeCompleted:
                         if ( t->state() & Node::State_ReadyToStart ) {
                             flags |= Qt::ItemIsEditable;
                         }
                         break;
 
                     default: break;
                 }
             } else if ( ! t->completion().isFinished() ) {
                 switch ( index.column() ) {
                     case NodeModel::NodeActualFinish:
                     case NodeModel::NodeCompleted:
                     case NodeModel::NodeRemainingEffort:
                         flags |= Qt::ItemIsEditable;
                         break;
                     case NodeModel::NodeActualEffort:
                         if ( t->completion().entrymode() == Completion::EnterEffortPerTask || t->completion().entrymode() == Completion::EnterEffortPerResource ) {
                             flags |= Qt::ItemIsEditable;
                         }
                         break;
                     default: break;
                 }
             }
         }
     }
     return flags;
 }
 
 
 QModelIndex NodeItemModel::parent( const QModelIndex &index ) const
 {
     if ( ! index.isValid() ) {
         return QModelIndex();
     }
     Node *n = node( index );
     if ( n == 0 || n == m_project ) {
         return QModelIndex();
     }
     Node *p = n->parentNode();
     if ( p == m_project ) {
         return m_projectshown ? createIndex( 0, 0, p ) : QModelIndex();
     }
     int row = p->parentNode()->indexOf( p );
     if ( row == -1 ) {
         return QModelIndex();
     }
     return createIndex( row, 0, p );
 }
 
 QModelIndex NodeItemModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( parent.isValid() ) {
         Q_ASSERT( parent.model() == this );
     }
     //debugPlan<<parent<<row<<column;
     if ( m_project == 0 || column < 0 || column >= columnCount() || row < 0 ) {
         //debugPlan<<m_project<<parent<<"No index for"<<row<<","<<column;
         return QModelIndex();
     }
     if ( m_projectshown && ! parent.isValid() ) {
         return createIndex( row, column, m_project );
     }
     Node *p = node( parent );
     if ( row >= p->numChildren() ) {
         errorPlan<<p->name()<<" row too high"<<row<<","<<column;
         return QModelIndex();
     }
     // now get the internal pointer for the index
     Node *n = p->childNode( row );
     QModelIndex idx = createIndex(row, column, n);
     //debugPlan<<idx;
     return idx;
 }
 
 QModelIndex NodeItemModel::index( const Node *node, int column ) const
 {
     if ( m_project == 0 || node == 0 ) {
         return QModelIndex();
     }
     Node *par = node->parentNode();
     if ( par ) {
         //debugPlan<<par<<"-->"<<node;
         return createIndex( par->indexOf( node ), column, const_cast<Node*>(node) );
     }
     if ( m_projectshown && node == m_project ) {
         return createIndex( 0, column, m_project );
     }
     //debugPlan<<node;
     return QModelIndex();
 }
 
 bool NodeItemModel::setType( Node *, const QVariant &, int )
 {
     return false;
 }
 
 bool NodeItemModel::setAllocation( Node *node, const QVariant &value, int role )
 {
     Task *task = qobject_cast<Task*>( node );
     if ( task == 0 ) {
         return false;
     }
     switch ( role ) {
         case Qt::EditRole:
         {
             MacroCommand *cmd = 0;
             QStringList res = m_project->resourceNameList();
             QStringList req = node->requestNameList();
             QStringList alloc;
             foreach ( const QString &s, value.toString().split( QRegExp(" *, *"), QString::SkipEmptyParts ) ) {
                 alloc << s.trimmed();
             }
             // first add all new resources (to "default" group)
             ResourceGroup *pargr = m_project->groupByName( i18n( "Resources" ) );
             foreach ( const QString &s, alloc ) {
                 Resource *r = m_project->resourceByName( s.trimmed() );
                 if ( r != 0 ) {
                     continue;
                 }
                 if ( cmd == 0 ) cmd = new MacroCommand( kundo2_i18n( "Add resource" ) );
                 if ( pargr == 0 ) {
                     pargr = new ResourceGroup();
                     pargr->setName( i18n( "Resources" ) );
                     cmd->addCommand( new AddResourceGroupCmd( m_project, pargr ) );
                     //debugPlan<<"add group:"<<pargr->name();
                 }
                 r = new Resource();
                 r->setName( s.trimmed() );
                 cmd->addCommand( new AddResourceCmd( pargr, r ) );
                 //debugPlan<<"add resource:"<<r->name();
                 emit executeCommand( cmd );
                 cmd = 0;
             }
 
             KUndo2MagicString c = kundo2_i18n( "Modify resource allocations" );
             // Handle deleted requests
             foreach ( const QString &s, req ) {
                 // if a request is not in alloc, it must have been be removed by the user
                 if ( alloc.indexOf( s ) == -1 ) {
                     // remove removed resource request
                     ResourceRequest *r = node->resourceRequest( s );
                     if ( r ) {
                         if ( cmd == 0 ) cmd = new MacroCommand( c );
                         //debugPlan<<"delete request:"<<r->resource()->name()<<" group:"<<r->parent()->group()->name();
                         cmd->addCommand( new RemoveResourceRequestCmd( r->parent(), r ) );
                     }
                 }
             }
             // Handle new requests
             QMap<ResourceGroup*, ResourceGroupRequest*> groupmap;
             foreach ( const QString &s, alloc ) {
                 // if an allocation is not in req, it must be added
                 if ( req.indexOf( s ) == -1 ) {
                     ResourceGroup *pargr = 0;
                     Resource *r = m_project->resourceByName( s );
                     if ( r == 0 ) {
                         // Handle request to non exixting resource
                         pargr = m_project->groupByName( i18n( "Resources" ) );
                         if ( pargr == 0 ) {
                             pargr = new ResourceGroup();
                             pargr->setName( i18n( "Resources" ) );
                             cmd->addCommand( new AddResourceGroupCmd( m_project, pargr ) );
                             //debugPlan<<"add group:"<<pargr->name();
                         }
                         r = new Resource();
                         r->setName( s );
                         cmd->addCommand( new AddResourceCmd( pargr, r ) );
                         //debugPlan<<"add resource:"<<r->name();
                         emit executeCommand( cmd );
                         cmd = 0;
                     } else {
                         pargr = r->parentGroup();
                         //debugPlan<<"add '"<<r->name()<<"' to group:"<<pargr;
                     }
                     // add request
                     ResourceGroupRequest *g = node->resourceGroupRequest( pargr );
                     if ( g == 0 ) {
                         g = groupmap.value( pargr );
                     }
                     if ( g == 0 ) {
                         // create a group request
                         if ( cmd == 0 ) cmd = new MacroCommand( c );
                         g = new ResourceGroupRequest( pargr );
                         cmd->addCommand( new AddResourceGroupRequestCmd( *task, g ) );
                         groupmap.insert( pargr, g );
                         //debugPlan<<"add group request:"<<g;
                     }
                     if ( cmd == 0 ) cmd = new MacroCommand( c );
                     cmd->addCommand( new AddResourceRequestCmd( g, new ResourceRequest( r, r->units() ) ) );
                     //debugPlan<<"add request:"<<r->name()<<" group:"<<g;
                 }
             }
             if ( cmd ) {
                 emit executeCommand( cmd );
                 return true;
             }
         }
     }
     return false;
 }
 
 bool NodeItemModel::setCompletion( Node *node, const QVariant &value, int role )
 {
     debugPlan<<node->name()<<value<<role;
     if ( role != Qt::EditRole ) {
         return 0;
     }
     if ( node->type() == Node::Type_Task ) {
         Completion &c = static_cast<Task*>( node )->completion();
         QDateTime dt = QDateTime::currentDateTime();
         QDate date = dt.date();
         MacroCommand *m = new MacroCommand( kundo2_i18n( "Modify completion" ) );
         if ( ! c.isStarted() ) {
             m->addCommand( new ModifyCompletionStartTimeCmd( c, dt ) );
             m->addCommand( new ModifyCompletionStartedCmd( c, true ) );
         }
         m->addCommand( new ModifyCompletionPercentFinishedCmd( c, date, value.toInt() ) );
         if ( value.toInt() == 100 ) {
             m->addCommand( new ModifyCompletionFinishTimeCmd( c, dt ) );
             m->addCommand( new ModifyCompletionFinishedCmd( c, true ) );
         }
         emit executeCommand( m ); // also adds a new entry if necessary
         if ( c.entrymode() == Completion::EnterCompleted ) {
             Duration planned = static_cast<Task*>( node )->plannedEffort( m_nodemodel.id() );
             Duration actual = ( planned * value.toInt() ) / 100;
             debugPlan<<planned.toString()<<value.toInt()<<actual.toString();
             NamedCommand *cmd = new ModifyCompletionActualEffortCmd( c, date, actual );
             cmd->execute();
             m->addCommand( cmd );
             cmd = new ModifyCompletionRemainingEffortCmd( c, date, planned - actual  );
             cmd->execute();
             m->addCommand( cmd );
         }
         return true;
     }
     if ( node->type() == Node::Type_Milestone ) {
         Completion &c = static_cast<Task*>( node )->completion();
         if ( value.toInt() > 0 ) {
             QDateTime dt = QDateTime::currentDateTime();
             QDate date = dt.date();
             MacroCommand *m = new MacroCommand( kundo2_i18n( "Set finished" ) );
             m->addCommand( new ModifyCompletionStartTimeCmd( c, dt ) );
             m->addCommand( new ModifyCompletionStartedCmd( c, true ) );
             m->addCommand( new ModifyCompletionFinishTimeCmd( c, dt ) );
             m->addCommand( new ModifyCompletionFinishedCmd( c, true ) );
             m->addCommand( new ModifyCompletionPercentFinishedCmd( c, date, 100 ) );
             emit executeCommand( m ); // also adds a new entry if necessary
             return true;
         }
         return false;
     }
     return false;
 }
 
 QVariant NodeItemModel::data( const QModelIndex &index, int role ) const
 {
     if ( role == Qt::TextAlignmentRole ) {
         return headerData( index.column(), Qt::Horizontal, role );
     }
     Node *n = node( index );
     if ( role == Role::Object ) {
         return n ? QVariant::fromValue( static_cast<QObject*>( n ) ) : QVariant();
     }
     QVariant result;
     if ( n != 0 ) {
         result = m_nodemodel.data( n, index.column(), role );
         //debugPlan<<n->name()<<": "<<index.column()<<", "<<role<<result;
     }
     if ( role == Qt::EditRole ) {
         switch ( index.column() ) {
             case NodeModel::NodeActualStart:
             case NodeModel::NodeActualFinish:
                 if ( ! result.isValid() ) {
                     return QDateTime::currentDateTime();
                 }
             break;
         }
     }
     return result;
 }
 
 bool NodeItemModel::setData( const QModelIndex &index, const QVariant &value, int role )
 {
     if ( ! index.isValid() ) {
         return ItemModelBase::setData( index, value, role );
     }
     if ( ( flags(index) &Qt::ItemIsEditable ) == 0 || role != Qt::EditRole ) {
         warnPlan<<index<<value<<role;
         return false;
     }
     Node *n = node( index );
     if ( n ) {
         switch ( index.column() ) {
             case NodeModel::NodeCompleted: return setCompletion( n, value, role );
             case NodeModel::NodeAllocation: return setAllocation( n, value, role );
             default: {
                 KUndo2Command *c = m_nodemodel.setData( n, index.column(), value, role );
                 if ( c ) {
                     emit executeCommand( c );
                     return true;
                 }
                 break;
             }
         }
     }
     return false;
 }
 
 QVariant NodeItemModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
     if ( orientation == Qt::Horizontal ) {
         if  (role == Qt::DisplayRole || role == Qt::TextAlignmentRole || role == Qt::EditRole) {
             return m_nodemodel.headerData(section, role);
         }
     }
     if ( role == Qt::ToolTipRole ) {
         return NodeModel::headerData( section, role );
     } else if ( role == Qt::WhatsThisRole ) {
         return NodeModel::headerData( section, role );
     }
     return ItemModelBase::headerData(section, orientation, role);
 }
 
 QAbstractItemDelegate *NodeItemModel::createDelegate( int column, QWidget *parent ) const
 {
     switch ( column ) {
         //case NodeModel::NodeAllocation: return new ??Delegate( parent );
         case NodeModel::NodeEstimateType: return new EnumDelegate( parent );
         case NodeModel::NodeEstimateCalendar: return new EnumDelegate( parent );
         case NodeModel::NodeEstimate: return new DurationSpinBoxDelegate( parent );
         case NodeModel::NodeOptimisticRatio: return new SpinBoxDelegate( parent );
         case NodeModel::NodePessimisticRatio: return new SpinBoxDelegate( parent );
         case NodeModel::NodeRisk: return new EnumDelegate( parent );
         case NodeModel::NodeConstraint: return new EnumDelegate( parent );
         case NodeModel::NodeConstraintStart: return new DateTimeCalendarDelegate( parent );
         case NodeModel::NodeConstraintEnd: return new DateTimeCalendarDelegate( parent );
         case NodeModel::NodeRunningAccount: return new EnumDelegate( parent );
         case NodeModel::NodeStartupAccount: return new EnumDelegate( parent );
 //         case NodeModel::NodeStartupCost: return new MoneyDelegate( parent );
         case NodeModel::NodeShutdownAccount: return new EnumDelegate( parent );
 //         case NodeModel::NodeShutdownCost: return new MoneyDelegate( parent );
 
         case NodeModel::NodeCompleted: return new TaskCompleteDelegate( parent );
         case NodeModel::NodeRemainingEffort: return new DurationSpinBoxDelegate( parent );
         case NodeModel::NodeActualEffort: return new DurationSpinBoxDelegate( parent );
 
         default: return 0;
     }
     return 0;
 }
 
 int NodeItemModel::columnCount( const QModelIndex &/*parent*/ ) const
 {
     return m_nodemodel.propertyCount();
 }
 
 int NodeItemModel::rowCount( const QModelIndex &parent ) const
 {
     if ( m_projectshown && ! parent.isValid() ) {
         return m_project == 0 ? 0 : 1;
     }
     Node *p = node( parent );
     return p == 0 ? 0 : p->numChildren();
 }
 
 Qt::DropActions NodeItemModel::supportedDropActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 
 QStringList NodeItemModel::mimeTypes() const
 {
     return QStringList() << "application/x-vnd.kde.plan.nodeitemmodel.internal"
                         << "application/x-vnd.kde.plan.resourceitemmodel.internal"
                         << "application/x-vnd.kde.plan.project"
                         << "text/uri-list";
 }
 
 QMimeData *NodeItemModel::mimeData( const QModelIndexList & indexes ) const
 {
     QMimeData *m = new QMimeData();
     QByteArray encodedData;
     QDataStream stream(&encodedData, QIODevice::WriteOnly);
     QList<int> rows;
     foreach (const QModelIndex &index, indexes) {
         if ( index.isValid() && !rows.contains( index.row() ) ) {
             //debugPlan<<index.row();
             Node *n = node( index );
             if ( n ) {
                 rows << index.row();
                 stream << n->id();
             }
         }
     }
     m->setData("application/x-vnd.kde.plan.nodeitemmodel.internal", encodedData);
 
     return m;
 }
 
 bool NodeItemModel::dropAllowed( const QModelIndex &index, int dropIndicatorPosition, const QMimeData *data )
 {
     debugPlan;
     if ( m_projectshown && ! index.isValid() ) {
         return false;
     }
     Node *dn = node( index ); // returns project if ! index.isValid()
     if ( dn == 0 ) {
         errorPlan<<"no node (or project) to drop on!";
         return false; // hmmm
     }
     if ( data->hasFormat("application/x-vnd.kde.plan.resourceitemmodel.internal") ) {
         switch ( dropIndicatorPosition ) {
             case ItemModelBase::OnItem:
                 if ( index.column() == NodeModel::NodeAllocation ) {
                     debugPlan<<"resource:"<<index<<(dn->type() == Node::Type_Task);
                     return dn->type() == Node::Type_Task;
                 } else if ( index.column() == NodeModel::NodeResponsible ) {
                     debugPlan<<"resource:"<<index<<true;
                     return true;
                 }
                 break;
             default:
                 break;
         }
     } else if ( data->hasFormat( "application/x-vnd.kde.plan.nodeitemmodel.internal")
                 || data->hasFormat( "application/x-vnd.kde.plan.project" )
                 || data->hasUrls() )
     {
         switch ( dropIndicatorPosition ) {
             case ItemModelBase::AboveItem:
             case ItemModelBase::BelowItem:
                 // dn == sibling, if not project
                 if ( dn == m_project ) {
                     return dropAllowed( dn, data );
                 }
                 return dropAllowed( dn->parentNode(), data );
             case ItemModelBase::OnItem:
                 // dn == new parent
                 return dropAllowed( dn, data );
             default:
                 break;
         }
     } else {
         debugPlan<<"Unknown mimetype";
     }
     return false;
 }
 
 QList<Resource*> NodeItemModel::resourceList( QDataStream &stream )
 {
     QList<Resource*> lst;
     while (!stream.atEnd()) {
         QString id;
         stream >> id;
         debugPlan<<"id"<<id;
         Resource *r = m_project->findResource( id );
         if ( r ) {
             lst << r;
         }
     }
     debugPlan<<lst;
     return lst;
 }
 
 bool NodeItemModel::dropAllowed( Node *on, const QMimeData *data )
 {
     if ( ! m_projectshown && on == m_project ) {
         return true;
     }
     if ( on->isBaselined() && on->type() != Node::Type_Summarytask ) {
         return false;
     }
     if ( data->hasFormat( "application/x-vnd.kde.plan.nodeitemmodel.internal" ) ) {
         QByteArray encodedData = data->data( "application/x-vnd.kde.plan.nodeitemmodel.internal" );
         QDataStream stream(&encodedData, QIODevice::ReadOnly);
         QList<Node*> lst = nodeList( stream );
         foreach ( Node *n, lst ) {
             if ( n->type() == Node::Type_Project || on == n || on->isChildOf( n ) ) {
                 return false;
             }
         }
         lst = removeChildNodes( lst );
         foreach ( Node *n, lst ) {
             if ( ! m_project->canMoveTask( n, on ) ) {
                 return false;
             }
         }
     }
     return true;
 }
 
 QList<Node*> NodeItemModel::nodeList( QDataStream &stream )
 {
     QList<Node*> lst;
     while (!stream.atEnd()) {
         QString id;
         stream >> id;
         Node *node = m_project->findNode( id );
         if ( node ) {
             lst << node;
         }
     }
     return lst;
 }
 
 QList<Node*> NodeItemModel::removeChildNodes( const QList<Node*> &nodes )
 {
     QList<Node*> lst;
     foreach ( Node *node, nodes ) {
         bool ins = true;
         foreach ( Node *n, lst ) {
             if ( node->isChildOf( n ) ) {
                 //debugPlan<<node->name()<<" is child of"<<n->name();
                 ins = false;
                 break;
             }
         }
         if ( ins ) {
             //debugPlan<<" insert"<<node->name();
             lst << node;
         }
     }
     QList<Node*> nl = lst;
     QList<Node*> nlst = lst;
     foreach ( Node *node, nl ) {
         foreach ( Node *n, nlst ) {
             if ( n->isChildOf( node ) ) {
                 //debugPlan<<n->name()<<" is child of"<<node->name();
                 int i = nodes.indexOf( n );
                 lst.removeAt( i );
             }
         }
     }
     return lst;
 }
 
 bool NodeItemModel::dropResourceMimeData( const QMimeData *data, Qt::DropAction action, int /*row*/, int /*column*/, const QModelIndex &parent )
 {
     QByteArray encodedData = data->data( "application/x-vnd.kde.plan.resourceitemmodel.internal" );
     QDataStream stream(&encodedData, QIODevice::ReadOnly);
     Node *n = node( parent );
     debugPlan<<n<<parent;
     if ( n == 0 ) {
         return true;
     }
     debugPlan<<n->name();
     if ( parent.column() == NodeModel::NodeResponsible ) {
         QString s;
         foreach ( Resource *r, resourceList( stream ) ) {
             s += r->name();
         }
         if ( ! s.isEmpty() ) {
             if ( action == Qt::CopyAction && ! n->leader().isEmpty() ) {
                 s += ',' + n->leader();
             }
             KUndo2Command *cmd = m_nodemodel.setLeader( n, s, Qt::EditRole );
             if ( cmd ) {
                 emit executeCommand( cmd );
             }
             debugPlan<<s;
         }
         return true;
     }
     if ( n->type() == Node::Type_Task ) {
         QList<Resource*> lst = resourceList( stream );
         if ( action == Qt::CopyAction ) {
             lst += static_cast<Task*>( n )->requestedResources();
         }
         KUndo2Command *cmd = createAllocationCommand( static_cast<Task&>( *n ), lst );
         if ( cmd ) {
             emit executeCommand( cmd );
         }
         return true;
     }
     return true;
 }
 
 bool NodeItemModel::dropProjectMimeData( const QMimeData *data, Qt::DropAction action, int row, int /*column*/, const QModelIndex &parent )
 {
     Node *n = node( parent );
     if ( n == 0 ) {
         n = m_project;
     }
     debugPlan<<n<<action<<row<<parent;
 
     KoXmlDocument doc;
     doc.setContent( data->data( "application/x-vnd.kde.plan.project" ) );
     KoXmlElement element = doc.documentElement().namedItem( "project" ).toElement();
     Project project;
     XMLLoaderObject status;
     status.setVersion( doc.documentElement().attribute( "version", PLAN_FILE_SYNTAX_VERSION ) );
     status.setProject( &project );
     if ( ! project.load( element, status ) ) {
         debugPlan<<"Failed to load project";
         return false;
     }
     project.generateUniqueNodeIds();
     KUndo2Command *cmd = new InsertProjectCmd( project, n, n->childNode( row - 1 ), kundo2_i18nc("1=project or task name", "Insert %1", project.name() ) );
     emit executeCommand( cmd );
     return true;
 }
 
 bool NodeItemModel::dropUrlMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent )
 {
     if ( data->hasUrls() ) {
         QList<QUrl> urls = data->urls();
         debugPlan<<urls;
         foreach ( const QUrl &url, urls ) {
             const QMimeType mime = QMimeDatabase().mimeTypeForUrl( url );
             debugPlan<<url<<mime.name();
             if ( mime.inherits( "application/x-vnd.kde.plan" ) ) {
                 importProjectFile( url, action, row, column, parent );
             }
         }
         return true;
     }
     return false;
 }
 
 bool NodeItemModel::importProjectFile( const QUrl &url, Qt::DropAction /*action*/, int row, int /*column*/, const QModelIndex &parent )
 {
     if ( ! url.isLocalFile() ) {
         debugPlan<<"TODO: download if url not local";
         return false;
     }
     KoStore *store = KoStore::createStore( url.path(), KoStore::Read, "", KoStore::Auto );
     if ( store->bad() ) {
         //        d->lastErrorMessage = i18n( "Not a valid Calligra file: %1", file );
         debugPlan<<"bad store"<<url.toDisplayString();
         delete store;
         //        QApplication::restoreOverrideCursor();
         return false;
     }
     if ( ! store->open( "root" ) ) { // maindoc.xml
         debugPlan<<"No root"<<url.toDisplayString();
         delete store;
         return false;
     }
     KoXmlDocument doc;
     doc.setContent( store->device() );
     KoXmlElement element = doc.documentElement().namedItem( "project" ).toElement();
     Project project;
     XMLLoaderObject status;
     status.setVersion( doc.documentElement().attribute( "version", PLAN_FILE_SYNTAX_VERSION ) );
     status.setProject( &project );
     if ( ! project.load( element, status ) ) {
         debugPlan<<"Failed to load project from:"<<url;
         return false;
     }
     project.generateUniqueNodeIds();
     Node *n = node( parent );
     debugPlan<<n<<parent;
     if ( n == 0 ) {
         n = m_project;
     }
     KUndo2Command *cmd = new InsertProjectCmd( project, n, n->childNode( row - 1 ), kundo2_i18n( "Insert %1", url.fileName() ) );
     emit executeCommand( cmd );
     return true;
 }
 
 KUndo2Command *NodeItemModel::createAllocationCommand( Task &task, const QList<Resource*> &lst )
 {
     MacroCommand *cmd = new MacroCommand( kundo2_i18n( "Modify resource allocations" ) );
     QMap<ResourceGroup*, ResourceGroupRequest*> groups;
     foreach ( Resource *r, lst ) {
         if ( ! groups.contains( r->parentGroup() ) && task.resourceGroupRequest( r->parentGroup() ) == 0 ) {
             ResourceGroupRequest *gr = new ResourceGroupRequest( r->parentGroup() );
             groups[ r->parentGroup() ] = gr;
             cmd->addCommand( new AddResourceGroupRequestCmd( task, gr ) );
         }
     }
     QList<Resource*> resources = task.requestedResources();
     foreach ( Resource *r, lst ) {
         if ( resources.contains( r ) ) {
             continue;
         }
         ResourceGroupRequest *gr = groups.value( r->parentGroup() );
         if ( gr == 0 ) {
             gr = task.resourceGroupRequest( r->parentGroup() );
         }
         if ( gr == 0 ) {
             errorPlan<<"No group request found, cannot add resource request:"<<r->name();
             continue;
         }
         cmd->addCommand( new AddResourceRequestCmd( gr, new ResourceRequest( r, 100 ) ) );
     }
     foreach ( Resource *r, resources ) {
         if ( ! lst.contains( r ) ) {
             ResourceGroupRequest *gr = task.resourceGroupRequest( r->parentGroup() );
             ResourceRequest *rr = task.requests().find( r );
             if ( gr && rr ) {
                 cmd->addCommand( new RemoveResourceRequestCmd( gr, rr ) );
             }
         }
     }
     if ( cmd->isEmpty() ) {
         delete cmd;
         return 0;
     }
     return cmd;
 }
 
 bool NodeItemModel::dropMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent )
 {
     debugPlan<<action;
     if (action == Qt::IgnoreAction) {
         return true;
     }
     if ( data->hasFormat( "application/x-vnd.kde.plan.resourceitemmodel.internal" ) ) {
         return dropResourceMimeData( data, action, row, column, parent );
     }
     if ( data->hasFormat( "application/x-vnd.kde.plan.nodeitemmodel.internal" ) ) {
         if ( action == Qt::MoveAction ) {
             //debugPlan<<"MoveAction";
 
             QByteArray encodedData = data->data( "application/x-vnd.kde.plan.nodeitemmodel.internal" );
             QDataStream stream(&encodedData, QIODevice::ReadOnly);
             Node *par = 0;
             if ( parent.isValid() ) {
                 par = node( parent );
             } else {
                 par = m_project;
             }
             QList<Node*> lst = nodeList( stream );
             QList<Node*> nodes = removeChildNodes( lst ); // children goes with their parent
             foreach ( Node *n, nodes ) {
                 if ( ! m_project->canMoveTask( n, par ) ) {
                     //debugPlan<<"Can't move task:"<<n->name();
                     return false;
                 }
             }
             int offset = 0;
             MacroCommand *cmd = 0;
             foreach ( Node *n, nodes ) {
                 if ( cmd == 0 ) cmd = new MacroCommand( kundo2_i18n( "Move tasks" ) );
                 // append nodes if dropped *on* another node, insert if dropped *after*
                 int pos = row == -1 ? -1 : row + offset;
                 if ( pos >= 0 && n->parentNode() == par && par->indexOf( n ) < pos ) {
                     --pos;
                 }
                 if ( n->parentNode() == par ) {
                     // avoid drop into the same position, QAbstractItemModel does not like it
                     int crow = par->indexOf( n );
                     if ( ( ( pos == -1 ) && ( crow == par->numChildren() - 1 ) ) || ( pos == crow ) ) {
                         delete cmd;
                         cmd = 0;
                         continue;
                     }
                 }
                 cmd->addCommand( new NodeMoveCmd( m_project, n, par, pos ) );
                 offset++;
             }
             if ( cmd ) {
                 emit executeCommand( cmd );
             }
             //debugPlan<<row<<","<<column<<" parent="<<parent.row()<<","<<parent.column()<<":"<<par->name();
             return true;
         }
     }
     if ( data->hasFormat( "application/x-vnd.kde.plan.project" ) ) {
         debugPlan;
         return dropProjectMimeData( data, action, row, column, parent );
 
     }
     if ( data->hasUrls() ) {
         return dropUrlMimeData( data, action, row, column, parent );
     }
     return false;
 }
 
 Node *NodeItemModel::node( const QModelIndex &index ) const
 {
     Node *n = m_project;
     if ( index.isValid() ) {
         //debugPlan<<index.internalPointer()<<":"<<index.row()<<","<<index.column();
         n = static_cast<Node*>( index.internalPointer() );
         Q_ASSERT( n );
     }
     return n;
 }
 
 void NodeItemModel::slotNodeChanged( Node *node )
 {
     if ( node == 0 || ( ! m_projectshown && node->type() == Node::Type_Project ) ) {
         return;
     }
     if ( node->type() == Node::Type_Project ) {
         emit dataChanged( createIndex( 0, 0, node ), createIndex( 0, columnCount()-1, node ) );
         return;
     }
     int row = node->parentNode()->findChildNode( node );
     Q_ASSERT( row >= 0 );
     emit dataChanged( createIndex( row, 0, node ), createIndex( row, columnCount()-1, node ) );
 }
 
 QModelIndex NodeItemModel::insertTask( Node *node, Node *after )
 {
     MacroCommand *cmd = new MacroCommand( kundo2_i18n( "Add task" ) );
     cmd->addCommand( new TaskAddCmd( m_project, node, after ) );
     if ( m_project && node->type() == Node::Type_Task ) {
         QMap<ResourceGroup*, ResourceGroupRequest*> groups;
         foreach ( Resource *r, m_project->autoAllocateResources() ) {
             if ( ! groups.contains( r->parentGroup() ) ) {
                 ResourceGroupRequest *gr = new ResourceGroupRequest( r->parentGroup() );
                 cmd->addCommand( new AddResourceGroupRequestCmd( static_cast<Task&>(*node), gr ) );
                 groups[ r->parentGroup() ] = gr;
             }
             ResourceRequest *rr = new ResourceRequest( r, 100 );
             cmd->addCommand( new AddResourceRequestCmd( groups[ r->parentGroup() ], rr ) );
         }
     }
     emit executeCommand( cmd );
     int row = -1;
     if ( node->parentNode() ) {
         row = node->parentNode()->indexOf( node );
     }
     if ( row != -1 ) {
         //debugPlan<<"Inserted: "<<node->name()<<"; "<<row;
         return createIndex( row, 0, node );
     }
     //debugPlan<<"Can't find "<<node->name();
     return QModelIndex();
 }
 
 QModelIndex NodeItemModel::insertSubtask( Node *node, Node *parent )
 {
     emit executeCommand( new SubtaskAddCmd( m_project, node, parent, kundo2_i18n( "Add sub-task" ) ) );
     int row = -1;
     if ( node->parentNode() ) {
         row = node->parentNode()->indexOf( node );
     }
     if ( row != -1 ) {
         //debugPlan<<node->parentNode()<<" inserted: "<<node->name()<<"; "<<row;
         return createIndex( row, 0, node );
     }
     //debugPlan<<"Can't find "<<node->name();
     return QModelIndex();
 }
 
 int NodeItemModel::sortRole( int column ) const
 {
     int v = Qt::DisplayRole;
     switch ( column ) {
         case NodeModel::NodeStartTime:
         case NodeModel::NodeEndTime:
         case NodeModel::NodeActualStart:
         case NodeModel::NodeActualFinish:
         case NodeModel::NodeEarlyStart:
         case NodeModel::NodeEarlyFinish:
         case NodeModel::NodeLateStart:
         case NodeModel::NodeLateFinish:
         case NodeModel::NodeConstraintStart:
         case NodeModel::NodeConstraintEnd:
             v = Qt::EditRole;
             break;
         case NodeModel::NodeWBSCode:
             v = NodeModel::SortableRole;
             break;
         default:
             break;
     }
     debugPlan<<column<<v;
     return v;
 }
 
 //------------------------------------------------
 GanttItemModel::GanttItemModel( QObject *parent )
     : NodeItemModel( parent ),
     m_showSpecial( false )
 {
 }
 
 GanttItemModel::~GanttItemModel()
 {
     QList<void*> lst = parentmap.values();
     while ( ! lst.isEmpty() )
         delete (int*)(lst.takeFirst());
 }
 
 int GanttItemModel::rowCount( const QModelIndex &parent ) const
 {
     if ( m_showSpecial ) {
         if ( parentmap.values().contains( parent.internalPointer() ) ) {
             return 0;
         }
         Node *n = node( parent );
         if ( n && n->type() == Node::Type_Task ) {
             return 5; // the task + early start + late finish ++
         }
     }
     return NodeItemModel::rowCount( parent );
 }
 
 QModelIndex GanttItemModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( m_showSpecial && parent.isValid()  ) {
         Node *p = node( parent );
         if ( p->type() == Node::Type_Task ) {
             void *v = 0;
             foreach ( void *i, parentmap.values( p ) ) {
                 if ( *( (int*)( i ) ) == row ) {
                     v = i;
                     break;
                 }
             }
             if ( v == 0 ) {
                 v = new int( row );
                 const_cast<GanttItemModel*>( this )->parentmap.insertMulti( p, v );
             }
             return createIndex( row, column, v );
         }
     }
     return NodeItemModel::index( row, column, parent );
 }
 
 QModelIndex GanttItemModel::parent( const QModelIndex &idx ) const
 {
     if ( m_showSpecial ) {
         QList<Node*> lst = parentmap.keys( idx.internalPointer() );
         if ( ! lst.isEmpty() ) {
             Q_ASSERT( lst.count() == 1 );
             return index( lst.first() );
         }
     }
     return NodeItemModel::parent( idx );
 }
 
 QVariant GanttItemModel::data( const QModelIndex &index, int role ) const
 {
     if ( ! index.isValid() ) {
         return QVariant();
     }
     if ( role == Qt::TextAlignmentRole ) {
         return headerData( index.column(), Qt::Horizontal, role );
     }
     QModelIndex idx = index;
     QList<Node*> lst;
     if ( m_showSpecial ) {
         lst = parentmap.keys( idx.internalPointer() );
     }
     if ( ! lst.isEmpty() ) {
         Q_ASSERT( lst.count() == 1 );
         int row = *((int*)(idx.internalPointer()));
         Node *n = lst.first();
         if ( role == SpecialItemTypeRole ) {
             return row; // 0=task, 1=early start, 2=late finish...
         }
         switch ( row ) {
             case 0:  // the task
                 if ( idx.column() == NodeModel::NodeType && role == KGantt::ItemTypeRole ) {
                     switch ( n->type() ) {
                         case Node::Type_Task: return KGantt::TypeTask;
                         default: break;
                     }
                 }
                 break;
             case 1: { // early start
                 if ( role != Qt::DisplayRole && role != Qt::EditRole && role != KGantt::ItemTypeRole ) {
                     return QVariant();
                 }
                 switch ( idx.column() ) {
                     case NodeModel::NodeName: return "Early Start";
                     case NodeModel::NodeType: return KGantt::TypeEvent;
                     case NodeModel::NodeStartTime:
                     case NodeModel::NodeEndTime: return n->earlyStart( id() );
                     default: break;
                 }
             }
             case 2: { // late finish
                 if ( role != Qt::DisplayRole && role != Qt::EditRole && role != KGantt::ItemTypeRole ) {
                     return QVariant();
                 }
                 switch ( idx.column() ) {
                     case NodeModel::NodeName: return "Late Finish";
                     case NodeModel::NodeType: return KGantt::TypeEvent;
                     case NodeModel::NodeStartTime:
                     case NodeModel::NodeEndTime: return n->lateFinish( id() );
                     default: break;
                 }
             }
             case 3: { // late start
                 if ( role != Qt::DisplayRole && role != Qt::EditRole && role != KGantt::ItemTypeRole ) {
                     return QVariant();
                 }
                 switch ( idx.column() ) {
                     case NodeModel::NodeName: return "Late Start";
                     case NodeModel::NodeType: return KGantt::TypeEvent;
                     case NodeModel::NodeStartTime:
                     case NodeModel::NodeEndTime: return n->lateStart( id() );
                     default: break;
                 }
             }
             case 4: { // early finish
                 if ( role != Qt::DisplayRole && role != Qt::EditRole && role != KGantt::ItemTypeRole ) {
                     return QVariant();
                 }
                 switch ( idx.column() ) {
                     case NodeModel::NodeName: return "Early Finish";
                     case NodeModel::NodeType: return KGantt::TypeEvent;
                     case NodeModel::NodeStartTime:
                     case NodeModel::NodeEndTime: return n->earlyFinish( id() );
                     default: break;
                 }
             }
             default: return QVariant();
         }
         idx = createIndex( idx.row(), idx.column(), n );
     } else {
         if ( role == SpecialItemTypeRole ) {
             return 0; // task of some type
         }
         if ( idx.column() == NodeModel::NodeType && role == KGantt::ItemTypeRole ) {
             QVariant result = NodeItemModel::data( idx, Qt::EditRole );
             switch ( result.toInt() ) {
                 case Node::Type_Project: return KGantt::TypeSummary;
                 case Node::Type_Summarytask: return KGantt::TypeSummary;
                 case Node::Type_Milestone: return KGantt::TypeEvent;
                 default: return m_showSpecial ? KGantt::TypeMulti : KGantt::TypeTask;
             }
         }
     }
     return NodeItemModel::data( idx, role );
 }
 
 //----------------------------
 MilestoneItemModel::MilestoneItemModel( QObject *parent )
     : ItemModelBase( parent )
 {
 }
 
 MilestoneItemModel::~MilestoneItemModel()
 {
 }
 
 QList<Node*> MilestoneItemModel::mileStones() const
 {
     QList<Node*> lst;
     foreach( Node* n, m_nodemap ) {
         if ( n->type() == Node::Type_Milestone ) {
             lst << n;
         }
     }
     return lst;
 }
 
 void MilestoneItemModel::slotNodeToBeInserted( Node *parent, int row )
 {
     Q_UNUSED(parent);
     Q_UNUSED(row);
 }
 
 void MilestoneItemModel::slotNodeInserted( Node *node )
 {
     Q_UNUSED(node);
     resetModel();
 }
 
 void MilestoneItemModel::slotNodeToBeRemoved( Node *node )
 {
     Q_UNUSED(node);
     //debugPlan<<node->name();
 /*    int row = m_nodemap.values().indexOf( node );
     if ( row != -1 ) {
         Q_ASSERT( m_nodemap.contains( node->wbsCode() ) );
         Q_ASSERT( m_nodemap.keys().indexOf( node->wbsCode() ) == row );
         beginRemoveRows( QModelIndex(), row, row );
         m_nodemap.remove( node->wbsCode() );
         endRemoveRows();
     }*/
 }
 
 void MilestoneItemModel::slotNodeRemoved( Node *node )
 {
     Q_UNUSED(node);
     resetModel();
     //endRemoveRows();
 }
 
 void MilestoneItemModel::slotLayoutChanged()
 {
     //debugPlan<<node->name();
     emit layoutAboutToBeChanged();
     emit layoutChanged();
 }
 
 void MilestoneItemModel::slotNodeToBeMoved( Node *node, int pos, Node *newParent, int newPos )
 {
     Q_UNUSED( node );
     Q_UNUSED( pos );
     Q_UNUSED( newParent );
     Q_UNUSED( newPos );
 }
 
 void MilestoneItemModel::slotNodeMoved( Node *node )
 {
     Q_UNUSED( node );
     resetModel();
 }
 
 void MilestoneItemModel::setProject( Project *project )
 {
     if ( m_project ) {
         disconnect(m_project, SIGNAL(aboutToBeDeleted()), this, SLOT(projectDeleted()));
         disconnect( m_project, SIGNAL(localeChanged()), this, SLOT(slotLayoutChanged()) );
         disconnect( m_project, SIGNAL(wbsDefinitionChanged()), this, SLOT(slotWbsDefinitionChanged()) );
         disconnect( m_project, SIGNAL(nodeChanged(Node*)), this, SLOT(slotNodeChanged(Node*)) );
         disconnect( m_project, SIGNAL(nodeToBeAdded(Node*,int)), this, SLOT(slotNodeToBeInserted(Node*,int)) );
         disconnect( m_project, SIGNAL(nodeToBeRemoved(Node*)), this, SLOT(slotNodeToBeRemoved(Node*)) );
 
         disconnect(m_project, SIGNAL(nodeToBeMoved(Node*,int,Node*,int)), this, SLOT(slotNodeToBeMoved(Node*,int,Node*,int)));
         disconnect(m_project, SIGNAL(nodeMoved(Node*)), this, SLOT(slotNodeMoved(Node*)));
 
         disconnect( m_project, SIGNAL(nodeAdded(Node*)), this, SLOT(slotNodeInserted(Node*)) );
         disconnect( m_project, SIGNAL(nodeRemoved(Node*)), this, SLOT(slotNodeRemoved(Node*)) );
     }
     m_project = project;
     //debugPlan<<m_project<<"->"<<project;
     m_nodemodel.setProject( project );
     if ( project ) {
         connect(m_project, SIGNAL(aboutToBeDeleted()), this, SLOT(projectDeleted()));
         connect( m_project, SIGNAL(localeChanged()), this, SLOT(slotLayoutChanged()) );
         connect( m_project, SIGNAL(wbsDefinitionChanged()), this, SLOT(slotWbsDefinitionChanged()) );
         connect( m_project, SIGNAL(nodeChanged(Node*)), this, SLOT(slotNodeChanged(Node*)) );
         connect( m_project, SIGNAL(nodeToBeAdded(Node*,int)), this, SLOT(slotNodeToBeInserted(Node*,int)) );
         connect( m_project, SIGNAL(nodeToBeRemoved(Node*)), this, SLOT(slotNodeToBeRemoved(Node*)) );
 
         connect(m_project, SIGNAL(nodeToBeMoved(Node*,int,Node*,int)), this, SLOT(slotNodeToBeMoved(Node*,int,Node*,int)));
         connect(m_project, SIGNAL(nodeMoved(Node*)), this, SLOT(slotNodeMoved(Node*)));
 
         connect( m_project, SIGNAL(nodeAdded(Node*)), this, SLOT(slotNodeInserted(Node*)) );
         connect( m_project, SIGNAL(nodeRemoved(Node*)), this, SLOT(slotNodeRemoved(Node*)) );
     }
     resetModel();
 }
 
 void MilestoneItemModel::setScheduleManager( ScheduleManager *sm )
 {
     if ( m_nodemodel.manager() ) {
     }
     m_nodemodel.setManager( sm );
     ItemModelBase::setScheduleManager( sm );
     if ( sm ) {
     }
     //debugPlan<<sm;
     resetModel();
 }
 
 bool MilestoneItemModel::resetData()
 {
     int cnt = m_nodemap.count();
     m_nodemap.clear();
     if ( m_project != 0 ) {
         foreach ( Node *n, m_project->allNodes() ) {
             m_nodemap.insert( n->wbsCode(true), n );
         }
     }
     return cnt != m_nodemap.count();
 }
 
 void MilestoneItemModel::resetModel()
 {
     resetData();
     reset();
 }
 
 Qt::ItemFlags MilestoneItemModel::flags( const QModelIndex &index ) const
 {
     Qt::ItemFlags flags = QAbstractItemModel::flags( index );
     if ( !index.isValid() ) {
         if ( m_readWrite ) {
             flags |= Qt::ItemIsDropEnabled;
         }
         return flags;
     }
     if ( m_readWrite ) {
         flags |= Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
         switch ( index.column() ) {
             case NodeModel::NodeName: // name
                 flags |= Qt::ItemIsEditable;
                 break;
             case NodeModel::NodeType: break; // Node type
             case NodeModel::NodeResponsible: // Responsible
                 flags |= Qt::ItemIsEditable;
                 break;
             case NodeModel::NodeConstraint: // constraint type
                 flags |= Qt::ItemIsEditable;
                 break;
             case NodeModel::NodeConstraintStart: { // constraint start
                 Node *n = node( index );
                 if ( n == 0 )
                     break;
                 int c = n->constraint();
                 if ( c == Node::MustStartOn || c == Node::StartNotEarlier || c == Node::FixedInterval ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeConstraintEnd: { // constraint end
                 Node *n = node( index );
                 if ( n == 0 )
                     break;
                 int c = n->constraint();
                 if ( c == Node::MustFinishOn || c == Node::FinishNotLater || c ==  Node::FixedInterval ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeStartupAccount: // startup account
             case NodeModel::NodeStartupCost: // startup cost
             case NodeModel::NodeShutdownAccount: // shutdown account
             case NodeModel::NodeShutdownCost: { // shutdown cost
                 Node *n = node( index );
                 if ( n && (n->type() == Node::Type_Task || n->type() == Node::Type_Milestone) ) {
                     flags |= Qt::ItemIsEditable;
                 }
                 break;
             }
             case NodeModel::NodeDescription: // description
                 break;
             default:
                 flags &= ~Qt::ItemIsEditable;
         }
     }
     return flags;
 }
 
 QModelIndex MilestoneItemModel::parent( const QModelIndex &index ) const
 {
     Q_UNUSED(index);
     return QModelIndex();
 }
 
 QModelIndex MilestoneItemModel::index( int row, int column, const QModelIndex &parent ) const
 {
     //debugPlan<<parent<<row<<", "<<m_nodemap.count();
     if ( m_project == 0 || row < 0 || column < 0 ) {
         //debugPlan<<"No project"<<m_project<<" or illegal row, column"<<row<<column;
         return QModelIndex();
     }
     if ( parent.isValid() || row >= m_nodemap.count() ) {
         //debugPlan<<"No index for"<<parent<<row<<","<<column;
         return QModelIndex();
     }
     return createIndex( row, column, m_nodemap.values().at( row ) );
 }
 
 QModelIndex MilestoneItemModel::index( const Node *node ) const
 {
     if ( m_project == 0 || node == 0 ) {
         return QModelIndex();
     }
     return createIndex( m_nodemap.values().indexOf( const_cast<Node*>( node ) ), 0, const_cast<Node*>(node) );
 }
 
 
 QVariant MilestoneItemModel::data( const QModelIndex &index, int role ) const
 {
     QVariant result;
     if ( role == Qt::TextAlignmentRole ) {
         return headerData( index.column(), Qt::Horizontal, role );
     }
     Node *n = node( index );
     if ( n != 0 ) {
         if ( index.column() == NodeModel::NodeType && role == KGantt::ItemTypeRole ) {
             result = m_nodemodel.data( n, index.column(), Qt::EditRole );
             switch ( result.toInt() ) {
                 case Node::Type_Summarytask: return KGantt::TypeSummary;
                 case Node::Type_Milestone: return KGantt::TypeEvent;
                 default: return KGantt::TypeTask;
             }
             return result;
         }
     }
     result = m_nodemodel.data( n, index.column(), role );
     return result;
 }
 
 bool MilestoneItemModel::setData( const QModelIndex &index, const QVariant &/*value*/, int role )
 {
     if ( ( flags(index) &Qt::ItemIsEditable ) == 0 || role != Qt::EditRole ) {
         return false;
     }
 //     Node *n = node( index );
     switch (index.column()) {
         default:
             qWarning("data: invalid display value column %d", index.column());
             return false;
     }
     return false;
 }
 
 QVariant MilestoneItemModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
     if ( orientation == Qt::Horizontal ) {
         if (role == Qt::DisplayRole || role == Qt::TextAlignmentRole || role == Qt::EditRole) {
             return m_nodemodel.headerData(section, role);
         }
     }
     if ( role == Qt::ToolTipRole ) {
         return NodeModel::headerData( section, role );
     }
     return ItemModelBase::headerData(section, orientation, role);
 }
 
 QAbstractItemDelegate *MilestoneItemModel::createDelegate( int column, QWidget *parent ) const
 {
     switch ( column ) {
         case NodeModel::NodeEstimateType: return new EnumDelegate( parent );
         case NodeModel::NodeEstimateCalendar: return new EnumDelegate( parent );
         case NodeModel::NodeEstimate: return new DurationSpinBoxDelegate( parent );
         case NodeModel::NodeOptimisticRatio: return new SpinBoxDelegate( parent );
         case NodeModel::NodePessimisticRatio: return new SpinBoxDelegate( parent );
         case NodeModel::NodeRisk: return new EnumDelegate( parent );
         case NodeModel::NodeConstraint: return new EnumDelegate( parent );
         case NodeModel::NodeRunningAccount: return new EnumDelegate( parent );
         case NodeModel::NodeStartupAccount: return new EnumDelegate( parent );
         case NodeModel::NodeStartupCost: return new MoneyDelegate( parent );
         case NodeModel::NodeShutdownAccount: return new EnumDelegate( parent );
         case NodeModel::NodeShutdownCost: return new MoneyDelegate( parent );
 
         case NodeModel::NodeCompleted: return new TaskCompleteDelegate( parent );
         case NodeModel::NodeRemainingEffort: return new DurationSpinBoxDelegate( parent );
         case NodeModel::NodeActualEffort: return new DurationSpinBoxDelegate( parent );
 
         default: return 0;
     }
     return 0;
 }
 
 int MilestoneItemModel::columnCount( const QModelIndex &/*parent*/ ) const
 {
     return m_nodemodel.propertyCount();
 }
 
 int MilestoneItemModel::rowCount( const QModelIndex &parent ) const
 {
     //debugPlan<<parent;
     if ( parent.isValid() ) {
         return 0;
     }
     //debugPlan<<m_nodemap.count();
     return m_nodemap.count();
 }
 
 Qt::DropActions MilestoneItemModel::supportedDropActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 
 QStringList MilestoneItemModel::mimeTypes() const
 {
     return QStringList();
 }
 
 QMimeData *MilestoneItemModel::mimeData( const QModelIndexList & indexes ) const
 {
     QMimeData *m = new QMimeData();
     QByteArray encodedData;
     QDataStream stream(&encodedData, QIODevice::WriteOnly);
     QList<int> rows;
     foreach (const QModelIndex &index, indexes) {
         if ( index.isValid() && !rows.contains( index.row() ) ) {
             //debugPlan<<index.row();
             Node *n = node( index );
             if ( n ) {
                 rows << index.row();
                 stream << n->id();
             }
         }
     }
     m->setData("application/x-vnd.kde.plan.nodeitemmodel.internal", encodedData);
     return m;
 }
 
 bool MilestoneItemModel::dropAllowed( const QModelIndex &index, int dropIndicatorPosition, const QMimeData *data )
 {
     //debugPlan;
     Node *dn = node( index );
     if ( dn == 0 ) {
         errorPlan<<"no node to drop on!";
         return false; // hmmm
     }
     switch ( dropIndicatorPosition ) {
         case ItemModelBase::AboveItem:
         case ItemModelBase::BelowItem:
             // dn == sibling
             return dropAllowed( dn->parentNode(), data );
         case ItemModelBase::OnItem:
             // dn == new parent
             return dropAllowed( dn, data );
         default:
             break;
     }
     return false;
 }
 
 bool MilestoneItemModel::dropAllowed( Node *on, const QMimeData *data )
 {
     if ( !data->hasFormat("application/x-vnd.kde.plan.nodeitemmodel.internal") ) {
         return false;
     }
     if ( on == m_project ) {
         return true;
     }
     QByteArray encodedData = data->data( "application/x-vnd.kde.plan.nodeitemmodel.internal" );
     QDataStream stream(&encodedData, QIODevice::ReadOnly);
     QList<Node*> lst = nodeList( stream );
     foreach ( Node *n, lst ) {
         if ( on == n || on->isChildOf( n ) ) {
             return false;
         }
     }
     lst = removeChildNodes( lst );
     foreach ( Node *n, lst ) {
         if ( ! m_project->canMoveTask( n, on ) ) {
             return false;
         }
     }
     return true;
 }
 
 QList<Node*> MilestoneItemModel::nodeList( QDataStream &stream )
 {
     QList<Node*> lst;
     while (!stream.atEnd()) {
         QString id;
         stream >> id;
         Node *node = m_project->findNode( id );
         if ( node ) {
             lst << node;
         }
     }
     return lst;
 }
 
 QList<Node*> MilestoneItemModel::removeChildNodes( const QList<Node*> &nodes )
 {
     QList<Node*> lst;
     foreach ( Node *node, nodes ) {
         bool ins = true;
         foreach ( Node *n, lst ) {
             if ( node->isChildOf( n ) ) {
                 //debugPlan<<node->name()<<" is child of"<<n->name();
                 ins = false;
                 break;
             }
         }
         if ( ins ) {
             //debugPlan<<" insert"<<node->name();
             lst << node;
         }
     }
     QList<Node*> nl = lst;
     QList<Node*> nlst = lst;
     foreach ( Node *node, nl ) {
         foreach ( Node *n, nlst ) {
             if ( n->isChildOf( node ) ) {
                 //debugPlan<<n->name()<<" is child of"<<node->name();
                 int i = nodes.indexOf( n );
                 lst.removeAt( i );
             }
         }
     }
     return lst;
 }
 
 bool MilestoneItemModel::dropMimeData( const QMimeData *data, Qt::DropAction action, int row, int /*column*/, const QModelIndex &parent )
 {
     //debugPlan<<action;
     if (action == Qt::IgnoreAction) {
         return true;
     }
     if ( !data->hasFormat( "application/x-vnd.kde.plan.nodeitemmodel.internal" ) ) {
         return false;
     }
     if ( action == Qt::MoveAction ) {
         //debugPlan<<"MoveAction";
 
         QByteArray encodedData = data->data( "application/x-vnd.kde.plan.nodeitemmodel.internal" );
         QDataStream stream(&encodedData, QIODevice::ReadOnly);
         Node *par = 0;
         if ( parent.isValid() ) {
             par = node( parent );
         } else {
             par = m_project;
         }
         QList<Node*> lst = nodeList( stream );
         QList<Node*> nodes = removeChildNodes( lst ); // children goes with their parent
         foreach ( Node *n, nodes ) {
             if ( ! m_project->canMoveTask( n, par ) ) {
                 //debugPlan<<"Can't move task:"<<n->name();
                 return false;
             }
         }
         int offset = 0;
         MacroCommand *cmd = 0;
         foreach ( Node *n, nodes ) {
             if ( cmd == 0 ) cmd = new MacroCommand( kundo2_i18n( "Move tasks" ) );
             // append nodes if dropped *on* another node, insert if dropped *after*
             int pos = row == -1 ? -1 : row + offset;
             cmd->addCommand( new NodeMoveCmd( m_project, n, par, pos ) );
             offset++;
         }
         if ( cmd ) {
             emit executeCommand( cmd );
         }
         //debugPlan<<row<<","<<column<<" parent="<<parent.row()<<","<<parent.column()<<":"<<par->name();
         return true;
     }
     return false;
 }
 
 Node *MilestoneItemModel::node( const QModelIndex &index ) const
 {
     Node *n = 0;
     if ( index.isValid() ) {
         //debugPlan<<index;
         n = static_cast<Node*>( index.internalPointer() );
     }
     return n;
 }
 
 void MilestoneItemModel::slotNodeChanged( Node *node )
 {
     //debugPlan<<node->name();
     if ( node == 0 ) {
         return;
     }
 //    if ( ! m_nodemap.contains( node->wbsCode() ) || m_nodemap.value( node->wbsCode() ) != node ) {
         emit layoutAboutToBeChanged();
         if ( resetData() ) {
             reset();
         } else {
             emit layoutChanged();
         }
         return;
 /*    }
     int row = m_nodemap.values().indexOf( node );
     debugPlan<<node->name()<<": "<<node->typeToString()<<row;
     emit dataChanged( createIndex( row, 0, node ), createIndex( row, columnCount()-1, node ) );*/
 }
 
 void MilestoneItemModel::slotWbsDefinitionChanged()
 {
     //debugPlan;
     if ( m_project == 0 ) {
         return;
     }
     if ( ! m_nodemap.isEmpty() ) {
         emit layoutAboutToBeChanged();
         resetData();
         emit layoutChanged();
     }
 }
 
 int MilestoneItemModel::sortRole( int column ) const
 {
     int v = Qt::DisplayRole;
     switch ( column ) {
         case NodeModel::NodeStartTime:
         case NodeModel::NodeEndTime:
         case NodeModel::NodeActualStart:
         case NodeModel::NodeActualFinish:
         case NodeModel::NodeEarlyStart:
         case NodeModel::NodeEarlyFinish:
         case NodeModel::NodeLateStart:
         case NodeModel::NodeLateFinish:
         case NodeModel::NodeConstraintStart:
         case NodeModel::NodeConstraintEnd:
             v = Qt::EditRole;
             break;
         case NodeModel::NodeWBSCode:
             v = NodeModel::SortableRole;
             break;
         default:
             break;
     }
     return v;
 }
 
 //--------------
 NodeSortFilterProxyModel::NodeSortFilterProxyModel( ItemModelBase* model, QObject *parent, bool filterUnscheduled )
     : QSortFilterProxyModel( parent ),
     m_filterUnscheduled( filterUnscheduled )
 {
     setSourceModel( model );
     setDynamicSortFilter( true );
 }
 
 ItemModelBase *NodeSortFilterProxyModel::itemModel() const
 {
     return static_cast<ItemModelBase *>( sourceModel() );
 }
 
 void NodeSortFilterProxyModel::setFilterUnscheduled( bool on ) {
     m_filterUnscheduled = on;
     invalidateFilter();
 }
 
 bool NodeSortFilterProxyModel::filterAcceptsRow ( int row, const QModelIndex & parent ) const
 {
     //debugPlan<<sourceModel()<<row<<parent;
     if ( itemModel()->project() == 0 ) {
         //debugPlan<<itemModel()->project();
         return false;
     }
     if ( m_filterUnscheduled ) {
         QString s = sourceModel()->data( sourceModel()->index( row, NodeModel::NodeNotScheduled, parent ), Qt::EditRole ).toString();
         if ( s == "true" ) {
             //debugPlan<<"Filtered unscheduled:"<<sourceModel()->index( row, 0, parent );
             return false;
         }
     }
     bool accepted = QSortFilterProxyModel::filterAcceptsRow( row, parent );
     //debugPlan<<this<<sourceModel()->index( row, 0, parent )<<"accepted ="<<accepted<<filterRegExp()<<filterRegExp().isEmpty()<<filterRegExp().capturedTexts();
     return accepted;
 }
 
 void NodeSortFilterProxyModel::sort(int column, Qt::SortOrder order)
 {
     setSortRole(itemModel()->sortRole(column));
     QSortFilterProxyModel::sort(column, order);
 }
 
 //------------------
 TaskModuleModel::TaskModuleModel( QObject *parent )
     : QAbstractItemModel( parent )
 {
 }
 
-void TaskModuleModel::addTaskModule( Project *project )
+void TaskModuleModel::addTaskModule( Project *project, const QUrl &url )
 {
     beginInsertRows( QModelIndex(), m_modules.count(), m_modules.count() );
     m_modules << project;
+    m_urls << url;
     endInsertRows();
 }
 
 Qt::ItemFlags TaskModuleModel::flags( const QModelIndex &idx ) const
 {
     Qt::ItemFlags f = QAbstractItemModel::flags( idx ) | Qt::ItemIsDropEnabled;
     if ( idx.isValid() ) {
         f |=  Qt::ItemIsDragEnabled;
     }
     return f;
 }
 
 int TaskModuleModel::columnCount (const QModelIndex &/*idx*/ ) const
 {
     return 1;
 }
 
 int TaskModuleModel::rowCount( const QModelIndex &idx ) const
 {
     return idx.isValid() ? 0 : m_modules.count();
 }
 
 QVariant TaskModuleModel::data( const QModelIndex& idx, int role ) const
 {
+    if (!idx.isValid() || idx.row() >= m_modules.count()) {
+        return QVariant();
+    }
     switch ( role ) {
         case Qt::DisplayRole: return m_modules.value( idx.row() )->name();
         case Qt::ToolTipRole: return m_modules.value( idx.row() )->description();
         case Qt::WhatsThisRole: return m_modules.value( idx.row() )->description();
+        case Qt::UserRole: return m_urls.value(idx.row());
         default: break;
     }
     return QVariant();
 }
 
 QVariant TaskModuleModel::headerData( int /*section*/, Qt::Orientation orientation , int role ) const
 {
     if ( orientation == Qt::Horizontal ) {
         switch ( role ) {
             case Qt::DisplayRole: return xi18nc( "@title:column", "Name" );
             default: break;
         }
     }
     return QVariant();
 }
 
 QModelIndex TaskModuleModel::parent( const QModelIndex& /*idx*/ ) const
 {
     return QModelIndex();
 }
 
 QModelIndex TaskModuleModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( parent.isValid() ) {
         return QModelIndex();
     }
     return createIndex( row, column, m_modules.value( row ) );
 }
 
 QStringList TaskModuleModel::mimeTypes() const
 {
     return QStringList() << "application/x-vnd.kde.plan" << "text/uri-list";
 }
 
 bool TaskModuleModel::dropMimeData( const QMimeData *data, Qt::DropAction /*action*/, int /*row*/, int /*column*/, const QModelIndex &/*parent*/ )
 {
     if ( data->hasUrls() ) {
         QList<QUrl> urls = data->urls();
         debugPlan<<urls;
         foreach ( const QUrl &url, urls ) {
             const QMimeType mime = QMimeDatabase().mimeTypeForUrl( url );
             debugPlan<<url<<mime.name();
             if ( mime.inherits(QStringLiteral("application/x-vnd.kde.plan")) || mime.inherits(QStringLiteral("application/xml")) ) {
                 importProject( url );
             }
         }
         return true;
     }
     return false;
 }
 
 bool TaskModuleModel::importProject( const QUrl &url, bool emitsignal )
 {
     if ( ! url.isLocalFile() ) {
         debugPlan<<"TODO: download if url not local";
         return false;
     }
     KoStore *store = KoStore::createStore( url.path(), KoStore::Read, "", KoStore::Auto );
     if ( store->bad() ) {
         //        d->lastErrorMessage = i18n( "Not a valid Calligra file: %1", file );
         debugPlan<<"bad store"<<url.toDisplayString();
         delete store;
         //        QApplication::restoreOverrideCursor();
         return false;
     }
     if ( ! store->open( "root" ) ) { // maindoc.xml
         debugPlan<<"No root"<<url.toDisplayString();
         delete store;
         return false;
     }
     KoXmlDocument doc;
     doc.setContent( store->device() );
     KoXmlElement element = doc.documentElement().namedItem( "project" ).toElement();
     Project *project = new Project();
     XMLLoaderObject status;
     status.setVersion( doc.documentElement().attribute( "version", PLAN_FILE_SYNTAX_VERSION ) );
     status.setProject( project );
     if ( project->load( element, status ) ) {
         stripProject( project );
-        addTaskModule( project );
+        addTaskModule( project, url );
         if ( emitsignal ) {
             // FIXME: save destroys the project, so give it a copy (see kptview.cpp)
             Project p;
             status.setProject( &p );
             p.load( element, status );
             emit saveTaskModule( url, &p );
         }
     } else {
         debugPlan<<"Failed to load project from:"<<url;
         delete project;
         return false;
     }
     return true;
 }
 
 QMimeData* TaskModuleModel::mimeData( const QModelIndexList &lst ) const
 {
     QMimeData *mime = new QMimeData();
     if ( lst.count() == 1 ) {
         QModelIndex idx = lst.at( 0 );
         if ( idx.isValid() ) {
             Project *project = m_modules.value( idx.row() );
             QDomDocument document( "plan" );
             document.appendChild( document.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
             QDomElement doc = document.createElement( "plan" );
             doc.setAttribute( "editor", "Plan" );
             doc.setAttribute( "mime", "application/x-vnd.kde.plan" );
             doc.setAttribute( "version", PLAN_FILE_SYNTAX_VERSION );
             document.appendChild( doc );
             project->save( doc );
             mime->setData( "application/x-vnd.kde.plan.project", document.toByteArray() );
         }
     }
     return mime;
 }
 
 void TaskModuleModel::stripProject( Project *project ) const
 {
     foreach ( ScheduleManager *sm, project->scheduleManagers() ) {
         DeleteScheduleManagerCmd c( *project, sm );
     }
 }
 
 void TaskModuleModel::loadTaskModules( const QStringList &files )
 {
     debugPlan<<files;
+    beginResetModel();
+    m_modules.clear();
+    m_urls.clear();
     foreach ( const QString &file, files ) {
         importProject( QUrl::fromLocalFile(file), false );
     }
+    endResetModel();
 }
 
 
 } //namespace KPlato
diff --git a/plan/libs/models/kptnodeitemmodel.h b/plan/libs/models/kptnodeitemmodel.h
index 27608785acd..5a75623011a 100644
--- a/plan/libs/models/kptnodeitemmodel.h
+++ b/plan/libs/models/kptnodeitemmodel.h
@@ -1,531 +1,532 @@
 /* This file is part of the KDE project
   Copyright (C) 2007 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version..
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #ifndef NODEITEMMODEL_H
 #define NODEITEMMODEL_H
 
 #include "kptitemmodelbase.h"
 #include "kptschedule.h"
 #include "kptworkpackagemodel.h"
 
 #include <QDate>
 #include <QMetaEnum>
 #include <QSortFilterProxyModel>
+#include <QUrl>
 
-class QUrl;
 class QMimeData;
 class KUndo2Command;
 class KoXmlWriter;
 class KoStore;
 class KoOdfWriteStore;
 
 namespace KPlato
 {
 
 class Project;
 class Node;
 class Estimate;
 
 class KPLATOMODELS_EXPORT NodeModel : public QObject
 {
     Q_OBJECT
     Q_ENUMS( Properties )
 public:
     NodeModel();
     ~NodeModel() {}
     
     enum SpecialRoles {
         SortableRole = Qt::UserRole + 5024 // unlikely high number
     };
 
     enum Properties {
         NodeName = 0,
         NodeType,
         NodeResponsible,
         NodeAllocation,
         NodeEstimateType,
         NodeEstimateCalendar,
         NodeEstimate,
         NodeOptimisticRatio,
         NodePessimisticRatio,
         NodeRisk,
         NodeConstraint,
         NodeConstraintStart,
         NodeConstraintEnd,
         NodeRunningAccount,
         NodeStartupAccount,
         NodeStartupCost,
         NodeShutdownAccount,
         NodeShutdownCost,
         NodeDescription,
 
         // Based on edited values
         NodeExpected,
         NodeVarianceEstimate,
         NodeOptimistic,
         NodePessimistic,
 
         // After scheduling
         NodeStartTime,
         NodeEndTime,
         NodeEarlyStart,
         NodeEarlyFinish,
         NodeLateStart,
         NodeLateFinish,
         NodePositiveFloat,
         NodeFreeFloat,
         NodeNegativeFloat,
         NodeStartFloat,
         NodeFinishFloat,
         NodeAssignments,
 
         // Based on scheduled values
         NodeDuration,
         NodeVarianceDuration,
         NodeOptimisticDuration,
         NodePessimisticDuration,
 
         // Completion
         NodeStatus,
         NodeCompleted,
         NodePlannedEffort,
         NodeActualEffort,
         NodeRemainingEffort,
         NodePlannedCost,
         NodeActualCost,
         NodeActualStart,
         NodeStarted,
         NodeActualFinish,
         NodeFinished,
         NodeStatusNote,
             
         // Scheduling errors
         NodeSchedulingStatus,
         NodeNotScheduled,
         NodeAssignmentMissing,
         NodeResourceOverbooked,
         NodeResourceUnavailable,
         NodeConstraintsError,
         NodeEffortNotMet,
         NodeSchedulingError,
 
         NodeWBSCode,
         NodeLevel,
         
         // Performance
         NodeBCWS,
         NodeBCWP,
         NodeACWP,
         NodePerformanceIndex,
         //
         NodeCritical,
         NodeCriticalPath,
 
         // Info from latest work package transmission
         WPOwnerName,
         WPTransmitionStatus,
         WPTransmitionTime
     };
     const QMetaEnum columnMap() const;
     
     void setProject( Project *project );
     void setManager( ScheduleManager *sm );
     Project *project() const { return m_project; }
     ScheduleManager *manager() const { return m_manager; }
     long id() const { return m_manager == 0 ? -1 : m_manager->scheduleId(); }
     
     QVariant data( const Node *node, int property, int role = Qt::DisplayRole ) const; 
     KUndo2Command *setData( Node *node, int property, const QVariant & value, int role = Qt::EditRole );
     
     static QVariant headerData( int section, int role = Qt::DisplayRole );
 
     int propertyCount() const;
     
     void setNow( const QDate &now ) { m_now = now; }
     QDate now() const { return m_now; }
     
     QVariant name( const Node *node, int role ) const;
     QVariant leader( const Node *node, int role ) const;
     QVariant allocation( const Node *node, int role ) const;
     QVariant description( const Node *node, int role ) const;
     QVariant type( const Node *node, int role ) const;
     QVariant constraint( const Node *node, int role ) const;
     QVariant constraintStartTime( const Node *node, int role ) const;
     QVariant constraintEndTime( const Node *node, int role ) const;
     QVariant estimateType( const Node *node, int role ) const;
     QVariant estimateCalendar( const Node *node, int role ) const;
     QVariant estimate( const Node *node, int role ) const;
     QVariant optimisticRatio( const Node *node, int role ) const;
     QVariant pessimisticRatio( const Node *node, int role ) const;
     QVariant riskType( const Node *node, int role ) const;
     QVariant runningAccount( const Node *node, int role ) const;
     QVariant startupAccount( const Node *node, int role ) const;
     QVariant startupCost( const Node *node, int role ) const;
     QVariant shutdownAccount( const Node *node, int role ) const;
     QVariant shutdownCost( const Node *node, int role ) const;
     
     QVariant startTime( const Node *node, int role ) const;
     QVariant endTime( const Node *node, int role ) const;
 
     QVariant duration( const Node *node, int role ) const;
     QVariant varianceDuration( const Node *node, int role ) const;
     QVariant varianceEstimate( const Estimate *est, int role ) const;
     QVariant optimisticDuration( const Node *node, int role ) const;
     QVariant optimisticEstimate( const Estimate *est, int role ) const;
     QVariant pertExpected( const Estimate *est, int role ) const;
     QVariant pessimisticDuration( const Node *node, int role ) const;
     QVariant pessimisticEstimate( const Estimate *est, int role ) const;
 
     QVariant earlyStart( const Node *node, int role ) const;
     QVariant earlyFinish( const Node *node, int role ) const;
     QVariant lateStart( const Node *node, int role ) const;
     QVariant lateFinish( const Node *node, int role ) const;
     QVariant positiveFloat( const Node *node, int role ) const;
     QVariant freeFloat( const Node *node, int role ) const;
     QVariant negativeFloat( const Node *node, int role ) const;
     QVariant startFloat( const Node *node, int role ) const;
     QVariant finishFloat( const Node *node, int role ) const;
     QVariant assignedResources( const Node *node, int role ) const;
     
     QVariant status( const Node *node, int role ) const;
     QVariant completed( const Node *node, int role ) const;
     QVariant startedTime( const Node *node, int role ) const;
     QVariant isStarted( const Node *node, int role ) const;
     QVariant finishedTime( const Node *node, int role ) const;
     QVariant isFinished( const Node *node, int role ) const;
     QVariant plannedEffortTo( const Node *node, int role ) const;
     QVariant actualEffortTo( const Node *node, int role ) const;
     QVariant remainingEffort( const Node *node, int role ) const;
     QVariant plannedCostTo( const Node *node, int role ) const;
     QVariant actualCostTo( const Node *node, int role ) const;
     QVariant note( const Node *node, int role ) const;
 
     /// The nodes scheduling status
     QVariant nodeSchedulingStatus( const Node *node, int role ) const;
     /// Set if the node has not been scheduled
     QVariant nodeIsNotScheduled( const Node *node, int role ) const;
     /// Set if EffortType == Effort, but no resource is requested
     QVariant resourceIsMissing( const Node *node, int role ) const;
     /// Set if the assigned resource is overbooked
     QVariant resourceIsOverbooked( const Node *node, int role ) const;
     /// Set if the requested resource is not available
     QVariant resourceIsNotAvailable( const Node *node, int role ) const;
     /// Set if the task cannot be scheduled to fullfil all the constraints
     QVariant schedulingConstraintsError( const Node *node, int role ) const;
     /// Resources could not fullfil estimate
     QVariant effortNotMet( const Node *node, int role ) const;
     /// Other scheduling error occurred
     QVariant schedulingError( const Node *node, int role ) const;
 
     QVariant wbsCode( const Node *node, int role ) const;
     QVariant nodeLevel( const Node *node, int role ) const;
     
     QVariant nodeBCWS( const Node *node, int role ) const;
     QVariant nodeBCWP( const Node *node, int role ) const;
     QVariant nodeACWP( const Node *node, int role ) const;
     QVariant nodePerformanceIndex( const Node *node, int role ) const;
 
     QVariant nodeIsCritical( const Node *node, int role ) const;
     QVariant nodeInCriticalPath( const Node *node, int role ) const;
 
     QVariant wpOwnerName( const Node *node, int role ) const;
     QVariant wpTransmitionStatus( const Node *node, int role ) const;
     QVariant wpTransmitionTime( const Node *node, int role ) const;
 
     KUndo2Command *setName( Node *node, const QVariant &value, int role );
     KUndo2Command *setLeader( Node *node, const QVariant &value, int role );
     KUndo2Command *setAllocation( Node *node, const QVariant &value, int role );
     KUndo2Command *setDescription( Node *node, const QVariant &value, int role );
     KUndo2Command *setType( Node *node, const QVariant &value, int role );
     KUndo2Command *setConstraint( Node *node, const QVariant &value, int role );
     KUndo2Command *setConstraintStartTime( Node *node, const QVariant &value, int role );
     KUndo2Command *setConstraintEndTime( Node *node, const QVariant &value, int role );
     KUndo2Command *setEstimateType( Node *node, const QVariant &value, int role );
     KUndo2Command *setEstimateCalendar( Node *node, const QVariant &value, int role );
     KUndo2Command *setEstimate( Node *node, const QVariant &value, int role );
     KUndo2Command *setOptimisticRatio( Node *node, const QVariant &value, int role );
     KUndo2Command *setPessimisticRatio( Node *node, const QVariant &value, int role );
     KUndo2Command *setRiskType( Node *node, const QVariant &value, int role );
     KUndo2Command *setRunningAccount( Node *node, const QVariant &value, int role );
     KUndo2Command *setStartupAccount( Node *node, const QVariant &value, int role );
     KUndo2Command *setStartupCost( Node *node, const QVariant &value, int role );
     KUndo2Command *setShutdownAccount( Node *node, const QVariant &value, int role );
     KUndo2Command *setShutdownCost( Node *node, const QVariant &value, int role );
     KUndo2Command *setCompletion( Node *node, const QVariant &value, int role );
     KUndo2Command *setActualEffort( Node *node, const QVariant &value, int role );
     KUndo2Command *setRemainingEffort( Node *node, const QVariant &value, int role );
     KUndo2Command *setStartedTime( Node *node, const QVariant &value, int role );
     KUndo2Command *setFinishedTime( Node *node, const QVariant &value, int role );
 
 private:
     Project *m_project;
     ScheduleManager *m_manager;
     QDate m_now;
     int m_prec;
 };
 
 class KPLATOMODELS_EXPORT NodeItemModel : public ItemModelBase
 {
     Q_OBJECT
 public:
     explicit NodeItemModel( QObject *parent = 0 );
     ~NodeItemModel();
     
     /// Returns a column number/- name map for this model
     virtual const QMetaEnum columnMap() const { return m_nodemodel.columnMap(); }
     
     ScheduleManager *manager() const { return m_nodemodel.manager(); }
     long id() const { return m_nodemodel.id(); }
 
     virtual Qt::ItemFlags flags( const QModelIndex & index ) const;
     
     virtual QModelIndex parent( const QModelIndex & index ) const;
     virtual QModelIndex index( int row, int column, const QModelIndex & parent = QModelIndex() ) const;
     virtual QModelIndex index( const Node *node, int column = 0 ) const;
     
     virtual int columnCount( const QModelIndex & parent = QModelIndex() ) const; 
     virtual int rowCount( const QModelIndex & parent = QModelIndex() ) const; 
     
     virtual QVariant data( const QModelIndex & index, int role = Qt::DisplayRole ) const; 
     virtual bool setData( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole );
 
     
     virtual QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
     
     virtual QMimeData * mimeData( const QModelIndexList & indexes ) const;
     virtual QStringList mimeTypes () const;
     virtual Qt::DropActions supportedDropActions() const;
     virtual bool dropMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
 
     Node *node( const QModelIndex &index ) const;
     QAbstractItemDelegate *createDelegate( int column, QWidget *parent ) const;
 
     QModelIndex insertTask( Node *node, Node *after );
     QModelIndex insertSubtask( Node *node, Node *parent );
     
     QList<Node*> nodeList( QDataStream &stream );
     QList<Resource*> resourceList( QDataStream &stream );
     static QList<Node*> removeChildNodes( const QList<Node*> &nodes );
     bool dropAllowed( Node *on, const QMimeData *data );
     
     virtual bool dropAllowed( const QModelIndex &index, int dropIndicatorPosition, const QMimeData *data );
     
     bool projectShown() const { return m_projectshown; }
 
     /// Return the sortorder to be used for @p column
     virtual int sortRole( int column ) const;
 
 Q_SIGNALS:
     void nodeInserted( Node *node );
     void projectShownChanged( bool );
 
 public Q_SLOTS:
     virtual void setProject( Project *project );
     virtual void setScheduleManager( ScheduleManager *sm );
     void setShowProject( bool on );
 
 protected Q_SLOTS:
     virtual void slotWbsDefinitionChanged();
     virtual void slotNodeChanged( Node* );
     virtual void slotNodeToBeInserted( Node *node, int row );
     virtual void slotNodeInserted( Node *node );
     virtual void slotNodeToBeRemoved( Node *node );
     virtual void slotNodeRemoved( Node *node );
 
     virtual void slotNodeToBeMoved( Node *node, int pos, Node *newParent, int newPos );
     virtual void slotNodeMoved( Node *node );
 
     virtual void slotLayoutChanged();
     virtual void slotProjectCalculated( ScheduleManager *sm );
 
 protected:
     virtual bool setType( Node *node, const QVariant &value, int role );
     bool setCompletion( Node *node, const QVariant &value, int role );
     bool setAllocation( Node *node, const QVariant &value, int role );
 
     bool dropResourceMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
     bool dropProjectMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
     KUndo2Command *createAllocationCommand( Task &task, const QList<Resource*> &lst );
     bool dropUrlMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
     bool importProjectFile( const QUrl &url, Qt::DropAction action, int row, int column, const QModelIndex &parent );
 
 protected:
     Node *m_node; // for sanety check
     NodeModel m_nodemodel;
     bool m_projectshown;
 };
 
 //--------------------------------------
 class KPLATOMODELS_EXPORT GanttItemModel : public NodeItemModel
 {
     Q_OBJECT
 public:
     enum GanttModelRoles { SpecialItemTypeRole = Qt::UserRole + 123 }; //FIXME
 
     explicit GanttItemModel(QObject *parent = 0);
     ~GanttItemModel();
 
     virtual int rowCount( const QModelIndex &parent ) const;
     using NodeItemModel::index;
     virtual QModelIndex index( int row, int column, const QModelIndex &parent ) const;
     QModelIndex parent( const QModelIndex &idx ) const;
     virtual QVariant data( const QModelIndex & index, int role = Qt::DisplayRole ) const;
 
     void setShowSpecial( bool on ) { m_showSpecial = on; }
     bool showSpecial() const { return m_showSpecial; }
 
 private:
     bool m_showSpecial;
     QMap<Node*, void*> parentmap;
 };
 
 // TODO: Rename, this is now a flat node item model
 class KPLATOMODELS_EXPORT MilestoneItemModel : public ItemModelBase
 {
     Q_OBJECT
 public:
     explicit MilestoneItemModel( QObject *parent = 0 );
     ~MilestoneItemModel();
 
     /// Returns a column number/- name map for this model
     virtual const QMetaEnum columnMap() const { return m_nodemodel.columnMap(); }
 
     ScheduleManager *manager() const { return m_nodemodel.manager(); }
     long id() const { return m_nodemodel.id(); }
 
     virtual Qt::ItemFlags flags( const QModelIndex & index ) const;
 
     virtual QModelIndex parent( const QModelIndex & index ) const;
     virtual QModelIndex index( int row, int column, const QModelIndex & parent = QModelIndex() ) const;
     virtual QModelIndex index( const Node *node ) const;
 
     virtual int columnCount( const QModelIndex & parent = QModelIndex() ) const; 
     virtual int rowCount( const QModelIndex & parent = QModelIndex() ) const; 
 
     virtual QVariant data( const QModelIndex & index, int role = Qt::DisplayRole ) const; 
     virtual bool setData( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole );
 
 
     virtual QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
 
     virtual QMimeData * mimeData( const QModelIndexList & indexes ) const;
     virtual QStringList mimeTypes () const;
     virtual Qt::DropActions supportedDropActions() const;
     virtual bool dropMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
 
     Node *node( const QModelIndex &index ) const;
     virtual QAbstractItemDelegate *createDelegate( int column, QWidget *parent ) const;
 
     QModelIndex insertTask( Node *node, Node *after );
     QModelIndex insertSubtask( Node *node, Node *parent );
 
     QList<Node*> nodeList( QDataStream &stream );
     static QList<Node*> removeChildNodes( const QList<Node*> &nodes );
     bool dropAllowed( Node *on, const QMimeData *data );
 
     virtual bool dropAllowed( const QModelIndex &index, int dropIndicatorPosition, const QMimeData *data );
 
     QList<Node*> mileStones() const;
 
     int sortRole(int column) const;
 
 public Q_SLOTS:
     virtual void setProject( Project *project );
     virtual void setScheduleManager( ScheduleManager *sm );
 
 protected Q_SLOTS:
     void slotNodeChanged( Node* );
     void slotNodeToBeInserted( Node *node, int row );
     void slotNodeInserted( Node *node );
     void slotNodeToBeRemoved( Node *node );
     void slotNodeRemoved( Node *node );
     void slotNodeToBeMoved( Node *node, int pos, Node *newParent, int newPos );
     void slotNodeMoved( Node *node );
 
     void slotLayoutChanged();
     void slotWbsDefinitionChanged();
 
 protected:
     bool resetData();
     void resetModel();
     
 private:
     NodeModel m_nodemodel;
     QMap<QString, Node*> m_nodemap;
 };
 
 class KPLATOMODELS_EXPORT NodeSortFilterProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 public:
     NodeSortFilterProxyModel( ItemModelBase* model, QObject *parent, bool filterUnscheduled = true );
 
     ItemModelBase *itemModel() const;
     void setFilterUnscheduled( bool on );
     bool filterUnscheduled() const { return m_filterUnscheduled; }
 
     void sort(int column, Qt::SortOrder order = Qt::AscendingOrder);
 
 protected:
     bool filterAcceptsRow ( int source_row, const QModelIndex & source_parent ) const;
 
 private:
     NodeItemModel *m_model;
     bool m_filterUnscheduled;
 };
 
 class KPLATOMODELS_EXPORT TaskModuleModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit TaskModuleModel(QObject *parent = 0);
 
-    void addTaskModule( Project *project );
+    void addTaskModule(Project *project , const QUrl &url);
 
     Qt::ItemFlags flags( const QModelIndex &idx ) const;
     int columnCount( const QModelIndex &idx = QModelIndex() ) const;
     int rowCount( const QModelIndex &idx = QModelIndex() ) const;
     QVariant data( const QModelIndex &idx, int role = Qt::DisplayRole ) const;
     QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
     QModelIndex parent( const QModelIndex &idx ) const;
     QModelIndex index( int row, int column, const QModelIndex &parent ) const;
     QStringList mimeTypes() const;
     bool dropMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
     QMimeData *mimeData( const QModelIndexList &idx ) const;
 
     bool importProject( const QUrl &url, bool emitsignal = true );
 
 public Q_SLOTS:
     void loadTaskModules( const QStringList &files );
 
 Q_SIGNALS:
     void executeCommand( KUndo2Command *cmd );
     void saveTaskModule( const QUrl &url, Project *project );
     void removeTaskModule( const QUrl &url );
 
 protected:
     void stripProject( Project *project ) const;
 
 private:
     QList<Project*> m_modules;
+    QList<QUrl> m_urls;
 };
 
 } //namespace KPlato
 
 #endif //NODEITEMMODEL_H
diff --git a/plan/libs/ui/kpttaskeditor.cpp b/plan/libs/ui/kpttaskeditor.cpp
index 5ecbd340760..ba3eb3debef 100644
--- a/plan/libs/ui/kpttaskeditor.cpp
+++ b/plan/libs/ui/kpttaskeditor.cpp
@@ -1,1674 +1,1687 @@
 /* This file is part of the KDE project
   Copyright (C) 2006 - 2010, 2012 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #include "kpttaskeditor.h"
 
 #include "kptglobal.h"
 #include "kptcommonstrings.h"
 #include "kptnodeitemmodel.h"
 #include "kptcommand.h"
 #include "kptproject.h"
 #include "kptitemviewsettup.h"
 #include "kptworkpackagesenddialog.h"
 #include "kptworkpackagesendpanel.h"
 #include "kptdatetime.h"
 #include "kptdebug.h"
 #include "kptresourcemodel.h"
 #include "kptresourceallocationmodel.h"
 #include "ResourceAllocationView.h"
 #include "kpttaskdialog.h"
 #include "TasksEditController.h"
 
 #include <KoXmlReader.h>
 #include <KoDocument.h>
 #include <KoIcon.h>
 
 #include <QItemSelectionModel>
 #include <QModelIndex>
 #include <QVBoxLayout>
 #include <QDragMoveEvent>
 #include <QAction>
 #include <QMenu>
 
 #include <kactionmenu.h>
 #include <KLocalizedString>
 #include <ktoggleaction.h>
 #include <kactioncollection.h>
 
 
 namespace KPlato
 {
 
 //--------------------
 TaskEditorItemModel::TaskEditorItemModel( QObject *parent )
 : NodeItemModel( parent )
 {
 }
 
 Qt::ItemFlags TaskEditorItemModel::flags( const QModelIndex &index ) const
 {
     if ( index.column() == NodeModel::NodeType ) {
         if ( ! m_readWrite || isColumnReadOnly( index.column() ) ) {
             return QAbstractItemModel::flags( index );
         }
         Node *n = node( index );
         bool baselined = n ? n->isBaselined() : false;
         if ( n && ! baselined && ( n->type() == Node::Type_Task || n->type() == Node::Type_Milestone ) ) {
             return QAbstractItemModel::flags( index ) | Qt::ItemIsEditable | Qt::ItemIsDropEnabled;
         }
         return QAbstractItemModel::flags( index ) | Qt::ItemIsDropEnabled;
     }
     return NodeItemModel::flags( index );
 }
 
 QVariant TaskEditorItemModel::headerData( int section, Qt::Orientation orientation, int role ) const
 {
     if ( orientation == Qt::Horizontal && section == NodeModel::NodeType ) {
         if ( role == Qt::ToolTipRole ) {
             return xi18nc( "@info:tooltip", "The type of task or the estimate type of the task" );
         } else if ( role == Qt::WhatsThisRole ) {
             return xi18nc( "@info:whatsthis",
                           "<p>Indicates the type of task or the estimate type of the task.</p>"
                           "The type can be set to <emphasis>Milestone</emphasis>, <emphasis>Effort</emphasis> or <emphasis>Duration</emphasis>.<nl/>"
                           "<note>If the type is <emphasis>Summary</emphasis> or <emphasis>Project</emphasis> the type is not editable.</note>");
         }
     }
     return NodeItemModel::headerData(section, orientation, role);
 }
 
 QVariant TaskEditorItemModel::data( const QModelIndex &index, int role ) const
 {
     if ( role == Qt::TextAlignmentRole ) {
         return NodeItemModel::data( index, role );
     }
     Node *n = node( index );
     if ( n != 0 && index.column() == NodeModel::NodeType ) {
         return type( n, role );
     }
     return NodeItemModel::data( index, role );
 }
 
 bool TaskEditorItemModel::setData( const QModelIndex &index, const QVariant &value, int role )
 {
     Node *n = node( index );
     if ( n != 0 && role == Qt::EditRole && index.column() == NodeModel::NodeType ) {
         return setType( n, value, role );
     }
     return NodeItemModel::setData( index, value, role );
 }
 
 QVariant TaskEditorItemModel::type( const Node *node, int role ) const
 {
     switch ( role ) {
         case Qt::DisplayRole: {
             if ( node->type() == Node::Type_Task ) {
                 return node->estimate()->typeToString( true );
             }
             return node->typeToString( true );
         }
         case Qt::EditRole:
             return node->type();
         case Qt::TextAlignmentRole:
             return Qt::AlignCenter;
         case Qt::ToolTipRole: {
             if ( node->type() == Node::Type_Task ) {
                 return xi18nc( "@info:tooltip", "Task with estimate type: %1", node->estimate()->typeToString( true ) );
             }
             return xi18nc( "@info:tooltip", "Task type: %1", node->typeToString( true ) );
         }
         case Qt::StatusTipRole:
         case Qt::WhatsThisRole:
             return QVariant();
         case Role::EnumListValue: {
             if ( node->type() == Node::Type_Milestone ) {
                 return 0;
             }
             if ( node->type() == Node::Type_Task ) {
                 return node->estimate()->type() + 1;
             }
             return -1;
         }
         case Role::EnumList: {
             QStringList lst;
             lst << Node::typeToString( Node::Type_Milestone, true );
             lst += Estimate::typeToStringList( true );
             return lst;
         }
     }
     return QVariant();
 }
 
 bool TaskEditorItemModel::setType( Node *node, const QVariant &value, int role )
 {
     switch ( role ) {
         case Qt::EditRole: {
             if ( node->type() == Node::Type_Summarytask ) {
                 return false;
             }
             int v = value.toInt();
             switch ( v ) {
                 case 0: { // Milestone
                     NamedCommand *cmd = 0;
                     if ( node->constraint() == Node::FixedInterval ) {
                         cmd = new NodeModifyConstraintEndTimeCmd( *node, node->constraintStartTime(), kundo2_i18n( "Set type to Milestone" ) );
                     } else {
                         cmd =  new ModifyEstimateCmd( *node, node->estimate()->expectedEstimate(), 0.0, kundo2_i18n( "Set type to Milestone" ) );
                     }
                     emit executeCommand( cmd );
                     return true;
                 }
                 default: { // Estimate
                     --v;
                     MacroCommand *m = new MacroCommand( kundo2_i18n( "Set type to %1", Estimate::typeToString( (Estimate::Type)v, true ) ) );
                     m->addCommand( new ModifyEstimateTypeCmd( *node, node->estimate()->type(), v ) );
                     if ( node->type() == Node::Type_Milestone ) {
                         if ( node->constraint() == Node::FixedInterval ) {
                             m->addCommand( new NodeModifyConstraintEndTimeCmd( *node, node->constraintStartTime().addDays( 1 ) ) );
                         } else {
                             m->addCommand( new ModifyEstimateUnitCmd( *node, node->estimate()->unit(), Duration::Unit_d ) );
                             m->addCommand( new ModifyEstimateCmd( *node, node->estimate()->expectedEstimate(), 1.0 ) );
                         }
                     }
                     emit executeCommand( m );
                     return true;
                 }
             }
             break;
         }
         default: break;
     }
     return false;
 }
 
 //--------------------
 TaskEditorTreeView::TaskEditorTreeView( QWidget *parent )
     : DoubleTreeViewBase( parent )
 {
     TaskEditorItemModel *m = new TaskEditorItemModel( this );
     setModel( m );
     //setSelectionBehavior( QAbstractItemView::SelectItems );
     setSelectionMode( QAbstractItemView::ExtendedSelection );
     setSelectionBehavior( QAbstractItemView::SelectRows );
 
     createItemDelegates( m );
     setItemDelegateForColumn( NodeModel::NodeType, new EnumDelegate( this ) );
 
     connect( this, SIGNAL(dropAllowed(QModelIndex,int,QDragMoveEvent*)), SLOT(slotDropAllowed(QModelIndex,int,QDragMoveEvent*)) );
 }
 
 NodeItemModel *TaskEditorTreeView::baseModel() const
 {
     NodeSortFilterProxyModel *pr = proxyModel();
     if ( pr ) {
         return static_cast<NodeItemModel*>( pr->sourceModel() );
     }
     return static_cast<NodeItemModel*>( model() );
 }
 
 void TaskEditorTreeView::slotDropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event )
 {
     QModelIndex idx = index;
     NodeSortFilterProxyModel *pr = proxyModel();
     if ( pr ) {
         idx = pr->mapToSource( index );
     }
     event->ignore();
     if ( baseModel()->dropAllowed( idx, dropIndicatorPosition, event->mimeData() ) ) {
         event->accept();
     }
 }
 
 //--------------------
 NodeTreeView::NodeTreeView( QWidget *parent )
     : DoubleTreeViewBase( parent )
 {
     NodeItemModel *m = new NodeItemModel( this );
     setModel( m );
     //setSelectionBehavior( QAbstractItemView::SelectItems );
     setSelectionMode( QAbstractItemView::ExtendedSelection );
     setSelectionBehavior( QAbstractItemView::SelectRows );
 
     createItemDelegates( m );
 
     connect( this, SIGNAL(dropAllowed(QModelIndex,int,QDragMoveEvent*)), SLOT(slotDropAllowed(QModelIndex,int,QDragMoveEvent*)) );
 }
 
 NodeItemModel *NodeTreeView::baseModel() const
 {
     NodeSortFilterProxyModel *pr = proxyModel();
     if ( pr ) {
         return static_cast<NodeItemModel*>( pr->sourceModel() );
     }
     return static_cast<NodeItemModel*>( model() );
 }
 
 void NodeTreeView::slotDropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event )
 {
     QModelIndex idx = index;
     NodeSortFilterProxyModel *pr = proxyModel();
     if ( pr ) {
         idx = pr->mapToSource( index );
     }
     event->ignore();
     if ( baseModel()->dropAllowed( idx, dropIndicatorPosition, event->mimeData() ) ) {
         event->accept();
     }
 }
 
 
 //-----------------------------------
 TaskEditor::TaskEditor(KoPart *part, KoDocument *doc, QWidget *parent)
     : ViewBase(part, doc, parent )
 {
     debugPlan<<"----------------- Create TaskEditor ----------------------";
     QVBoxLayout * l = new QVBoxLayout( this );
     l->setMargin( 0 );
     m_view = new TaskEditorTreeView( this );
     connect(this, SIGNAL(expandAll()), m_view, SLOT(slotExpand()));
     connect(this, SIGNAL(collapseAll()), m_view, SLOT(slotCollapse()));
 
     l->addWidget( m_view );
     debugPlan<<m_view->actionSplitView();
     setupGui();
 
     m_view->setEditTriggers( m_view->editTriggers() | QAbstractItemView::EditKeyPressed );
 
     m_view->setDragDropMode( QAbstractItemView::DragDrop );
     m_view->setDropIndicatorShown( true );
     m_view->setDragEnabled ( true );
     m_view->setAcceptDrops( true );
     m_view->setAcceptDropsOnView( true );
 
     QList<int> lst1; lst1 << 1 << -1; // only display column 0 (NodeName) in left view
     QList<int> show;
     show << NodeModel::NodeResponsible
             << NodeModel::NodeAllocation
             << NodeModel::NodeType
             << NodeModel::NodeEstimateCalendar
             << NodeModel::NodeEstimate
             << NodeModel::NodeOptimisticRatio
             << NodeModel::NodePessimisticRatio
             << NodeModel::NodeRisk
             << NodeModel::NodeConstraint
             << NodeModel::NodeConstraintStart
             << NodeModel::NodeConstraintEnd
             << NodeModel::NodeRunningAccount
             << NodeModel::NodeStartupAccount
             << NodeModel::NodeStartupCost
             << NodeModel::NodeShutdownAccount
             << NodeModel::NodeShutdownCost
             << NodeModel::NodeDescription;
 
     QList<int> lst2;
     for ( int i = 0; i < model()->columnCount(); ++i ) {
         if ( ! show.contains( i ) ) {
             lst2 << i;
         }
     }
     for ( int i = 0; i < show.count(); ++i ) {
         int sec = m_view->slaveView()->header()->visualIndex( show[ i ] );
         //debugPlan<<"move section:"<<i<<show[i]<<sec;
         if ( i != sec ) {
             m_view->slaveView()->header()->moveSection( sec, i );
         }
     }
     m_view->hideColumns( lst1, lst2 );
     m_view->masterView()->setDefaultColumns( QList<int>() << NodeModel::NodeName );
     m_view->slaveView()->setDefaultColumns( show );
 
     connect( model(), SIGNAL(executeCommand(KUndo2Command*)), doc, SLOT(addCommand(KUndo2Command*)) );
 
     connect( m_view, SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(slotCurrentChanged(QModelIndex,QModelIndex)) );
 
     connect( m_view, SIGNAL(selectionChanged(QModelIndexList)), this, SLOT(slotSelectionChanged(QModelIndexList)) );
 
     connect( m_view, SIGNAL(contextMenuRequested(QModelIndex,QPoint,QModelIndexList)), SLOT(slotContextMenuRequested(QModelIndex,QPoint,QModelIndexList)) );
 
     connect( m_view, SIGNAL(headerContextMenuRequested(QPoint)), SLOT(slotHeaderContextMenuRequested(QPoint)) );
 
     connect(baseModel(), SIGNAL(projectShownChanged(bool)), SLOT(slotProjectShown(bool)));
     connect(model(), SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), this, SLOT(slotEnableActions()));
 }
 
 void TaskEditor::slotProjectShown( bool on )
 {
     debugPlan<<proxyModel();
     QModelIndex idx;
     if ( proxyModel() ) {
         if ( proxyModel()->rowCount() > 0 ) {
             idx = proxyModel()->index( 0, 0 );
             m_view->selectionModel()->setCurrentIndex( idx, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows );
         }
     } else if ( baseModel() && baseModel()->rowCount() > 0 ) {
         idx = baseModel()->index( 0, 0 );
         m_view->selectionModel()->setCurrentIndex( idx, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows );
     }
     if ( on && idx.isValid() ) {
         m_view->masterView()->expand( idx );
     }
     slotEnableActions();
 }
 
 void TaskEditor::updateReadWrite( bool rw )
 {
     m_view->setReadWrite( rw );
     ViewBase::updateReadWrite( rw );
 }
 
 void TaskEditor::setProject( Project *project )
 {
     debugPlan<<project;
     m_view->setProject( project );
     ViewBase::setProject( project );
 }
 
 void TaskEditor::createDockers()
 {
     // Add dockers
     DockWidget *ds = 0;
     {
         ds = new DockWidget( this, "Allocations", xi18nc( "@title resource allocations", "Allocations" ) );
         QTreeView *x = new QTreeView( ds );
         AllocatedResourceItemModel *m1 = new AllocatedResourceItemModel( x );
         x->setModel( m1 );
         m1->setProject( project() );
     //     x->setHeaderHidden( true );
         x->setSelectionBehavior( QAbstractItemView::SelectRows );
         x->setSelectionMode( QAbstractItemView::ExtendedSelection );
         x->expandAll();
         x->resizeColumnToContents( 0 );
         x->setDragDropMode( QAbstractItemView::DragOnly );
         x->setDragEnabled ( true );
         ds->setWidget( x );
         connect(this, SIGNAL(projectChanged(Project*)), m1, SLOT(setProject(Project*)));
         connect(this, SIGNAL(taskSelected(Task*)), m1, SLOT(setTask(Task*)));
         connect(m1, SIGNAL(expandAll()), x, SLOT(expandAll()));
         connect(m1, SIGNAL(resizeColumnToContents(int)), x, SLOT(resizeColumnToContents(int)));
         addDocker( ds );
     }
 
     {
         ds = new DockWidget( this, "Resources", xi18nc( "@title", "Resources" ) );
         ds->setToolTip( xi18nc( "@info:tooltip",
                             "Drag resources into the Task Editor"
                             " and drop into the allocations- or responsible column" ) );
         ResourceAllocationView *e = new ResourceAllocationView(part(), ds );
         ResourceItemModel *m = new ResourceItemModel( e );
         e->setModel( m );
         m->setProject( project() );
         m->setReadWrite( isReadWrite() );
         QList<int> show; show << ResourceModel::ResourceName;
         for ( int i = m->columnCount() - 1; i >= 0; --i ) {
             e->setColumnHidden( i, ! show.contains( i ) );
         }
         e->setHeaderHidden( true );
         e->setSelectionBehavior( QAbstractItemView::SelectRows );
         e->setSelectionMode( QAbstractItemView::ExtendedSelection );
         e->expandAll();
         e->resizeColumnToContents( ResourceModel::ResourceName );
         e->setDragDropMode( QAbstractItemView::DragOnly );
         e->setDragEnabled ( true );
         ds->setWidget( e );
         connect(m_view->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), e, SLOT(setSelectedTasks(const QItemSelection&, const QItemSelection&)));
         connect(this, SIGNAL(projectChanged(Project*)), m, SLOT(setProject(Project*)));
         connect(this, SIGNAL(readWriteChanged(bool)), m, SLOT(setReadWrite(bool)));
         connect(m, SIGNAL(executeCommand(KUndo2Command*)), part(), SLOT(addCommand(KUndo2Command*)));
         addDocker( ds );
     }
 
     {
         ds = new DockWidget( this, "Taskmodules", xi18nc( "@title", "Task Modules" ) );
         ds->setToolTip( xi18nc( "@info:tooltip", "Drag a task module into the <emphasis>Task Editor</emphasis> to add it to the project" ) );
         ds->setLocation( Qt::LeftDockWidgetArea );
         QTreeView *e = new QTreeView( ds );
-        TaskModuleModel *m = new TaskModuleModel( e );
-        e->setModel( m );
+        QSortFilterProxyModel *sf = new QSortFilterProxyModel(e);
+        TaskModuleModel *m = new TaskModuleModel(sf);
+        sf->setSourceModel(m);
+        e->setModel(sf);
+        e->sortByColumn(0, Qt::AscendingOrder);
+        e->setSortingEnabled(true);
         e->setHeaderHidden( true );
         e->setRootIsDecorated( false );
         e->setSelectionBehavior( QAbstractItemView::SelectRows );
         e->setSelectionMode( QAbstractItemView::SingleSelection );
 //         e->resizeColumnToContents( 0 );
         e->setDragDropMode( QAbstractItemView::DragDrop );
         e->setAcceptDrops( true );
         e->setDragEnabled ( true );
         ds->setWidget( e );
+        connect(e, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(taskModuleDoubleClicked(QModelIndex)));
         connect(this, SIGNAL(loadTaskModules(QStringList)), m, SLOT(loadTaskModules(QStringList)));
         connect(m, SIGNAL(saveTaskModule(QUrl,Project*)), this, SIGNAL(saveTaskModule(QUrl,Project*)));
         connect(m, SIGNAL(removeTaskModule(QUrl)), this, SIGNAL(removeTaskModule(QUrl)));
         addDocker( ds );
     }
 }
 
+void TaskEditor::taskModuleDoubleClicked(QModelIndex idx)
+{
+    QUrl url = idx.data(Qt::UserRole).toUrl();
+    if (url.isValid()) {
+        emit openDocument(url);
+    }
+}
+
 void TaskEditor::setTaskModules(const QStringList& files)
 {
     emit loadTaskModules( files );
 }
 
 void TaskEditor::setGuiActive( bool activate )
 {
     debugPlan<<activate;
     updateActionsEnabled( true );
     ViewBase::setGuiActive( activate );
     if ( activate && !m_view->selectionModel()->currentIndex().isValid() && m_view->model()->rowCount() > 0 ) {
         m_view->selectionModel()->setCurrentIndex(m_view->model()->index( 0, 0 ), QItemSelectionModel::NoUpdate);
     }
 }
 
 void TaskEditor::slotCurrentChanged( const QModelIndex &curr, const QModelIndex & )
 {
     debugPlan<<curr.row()<<","<<curr.column();
     slotEnableActions();
 }
 
 void TaskEditor::slotSelectionChanged( const QModelIndexList &list)
 {
     debugPlan<<list.count();
     slotEnableActions();
     emit taskSelected( dynamic_cast<Task*>( selectedNode() ) );
 }
 
 QModelIndexList TaskEditor::selectedRows() const
 {
 #if 0
 // Qt bug?
     return m_view->selectionModel()->selectedRows();
 #else
     QModelIndexList lst;
     foreach ( QModelIndex i, m_view->selectionModel()->selectedIndexes() ) {
         if ( i.column() == 0 ) {
             lst << i;
         }
     }
     return lst;
 #endif
 }
 
 int TaskEditor::selectedRowCount() const
 {
     return selectedRows().count();
 }
 
 QList<Node*> TaskEditor::selectedNodes() const {
     QList<Node*> lst;
     foreach ( const QModelIndex &i, selectedRows() ) {
         Node * n = m_view->baseModel()->node( i );
         if ( n != 0 && n->type() != Node::Type_Project ) {
             lst.append( n );
         }
     }
     return lst;
 }
 
 Node *TaskEditor::selectedNode() const
 {
     QList<Node*> lst = selectedNodes();
     if ( lst.count() != 1 ) {
         return 0;
     }
     return lst.first();
 }
 
 Node *TaskEditor::currentNode() const {
     Node * n = m_view->baseModel()->node( m_view->selectionModel()->currentIndex() );
     if ( n == 0 || n->type() == Node::Type_Project ) {
         return 0;
     }
     return n;
 }
 
 void TaskEditor::slotContextMenuRequested( const QModelIndex& index, const QPoint& pos, const QModelIndexList &rows )
 {
     QString name;
     if (rows.count() > 1) {
         debugPlan<<rows;
         QList<Task*> summarytasks;
         QList<Task*> tasks;
         QList<Task*> milestones;
         for (const QModelIndex &idx : rows) {
             Node *node = m_view->baseModel()->node( idx );
             if (node) {
                 switch ( node->type() ) {
                     case Node::Type_Task:
                         tasks << static_cast<Task*>(node); break;
                     case Node::Type_Milestone:
                         milestones << static_cast<Task*>(node); break;
                     case Node::Type_Summarytask:
                         summarytasks << static_cast<Task*>(node); break;
                     default: break;
                 }
             }
         }
         if (!tasks.isEmpty()) {
             editTasks(tasks, pos);
             return;
         }
         return;
     }
     Node *node = m_view->baseModel()->node( index );
     if ( node == 0 ) {
         return;
     }
     debugPlan<<node->name()<<" :"<<pos;
     switch ( node->type() ) {
     case Node::Type_Project:
         name = "task_edit_popup";
         break;
     case Node::Type_Task:
         name = node->isScheduled( baseModel()->id() ) ? "task_popup" : "task_edit_popup";
         break;
     case Node::Type_Milestone:
         name = node->isScheduled( baseModel()->id() ) ? "taskeditor_milestone_popup" : "task_edit_popup";
         break;
     case Node::Type_Summarytask:
         name = "summarytask_popup";
         break;
     default:
         name = "node_popup";
         break;
     }
     m_view->setContextMenuIndex(index);
     if ( name.isEmpty() ) {
         slotHeaderContextMenuRequested( pos );
         m_view->setContextMenuIndex(QModelIndex());
         return;
     }
     debugPlan<<name;
     emit requestPopupMenu( name, pos );
     m_view->setContextMenuIndex(QModelIndex());
 }
 
 void TaskEditor::editTasks(const QList<Task*> &tasks, const QPoint &pos)
 {
     QList<QAction*> lst;
     QAction tasksEdit("Edit...");
     if (!tasks.isEmpty()) {
         TasksEditController *ted = new TasksEditController(*project(), tasks, this);
         connect(&tasksEdit, SIGNAL(triggered(bool)), ted, SLOT(activate()));
         connect(ted, SIGNAL(addCommand(KUndo2Command*)), koDocument(), SLOT(addCommand(KUndo2Command*)));
         lst << &tasksEdit;
     }
     lst += contextActionList();
     if (!lst.isEmpty()) {
         QMenu::exec( lst, pos, lst.first() );
     }
 
 }
 
 void TaskEditor::setScheduleManager( ScheduleManager *sm )
 {
     if (!sm && scheduleManager()) {
         // we should only get here if the only schedule manager is scheduled,
         // or when last schedule manager is deleted
         m_domdoc.clear();
         QDomElement element = m_domdoc.createElement("expanded");
         m_domdoc.appendChild(element);
         m_view->masterView()->saveExpanded(element);
     }
     bool tryexpand = sm && !scheduleManager();
     QDomDocument doc;
     bool expand = sm && scheduleManager();
     if (expand) {
         m_view->masterView()->setObjectName("TaskEditor");
         QDomElement element = doc.createElement("expanded");
         doc.appendChild(element);
         m_view->masterView()->saveExpanded(element);
     }
     ViewBase::setScheduleManager(sm);
     m_view->baseModel()->setScheduleManager( sm );
 
     if (expand) {
         m_view->masterView()->doExpand(doc);
     } else if (tryexpand) {
         m_view->masterView()->doExpand(m_domdoc);
     }
 }
 
 void TaskEditor::slotEnableActions()
 {
     updateActionsEnabled( isReadWrite() );
 }
 
 void TaskEditor::updateActionsEnabled( bool on )
 {
 //     debugPlan<<selectedRowCount()<<selectedNode()<<currentNode();
     if ( ! on ) {
         menuAddTask->setEnabled( false );
         actionAddTask->setEnabled( false );
         actionAddMilestone->setEnabled( false );
         menuAddSubTask->setEnabled( false );
         actionAddSubtask->setEnabled( false );
         actionAddSubMilestone->setEnabled( false );
         actionDeleteTask->setEnabled( false );
         actionMoveTaskUp->setEnabled( false );
         actionMoveTaskDown->setEnabled( false );
         actionIndentTask->setEnabled( false );
         actionUnindentTask->setEnabled( false );
         return;
     }
         
     int selCount = selectedRowCount();
     if ( selCount == 0 ) {
         if ( currentNode() ) {
             // there are tasks but none is selected
             menuAddTask->setEnabled( false );
             actionAddTask->setEnabled( false );
             actionAddMilestone->setEnabled( false );
             menuAddSubTask->setEnabled( false );
             actionAddSubtask->setEnabled( false );
             actionAddSubMilestone->setEnabled( false );
             actionDeleteTask->setEnabled( false );
             actionMoveTaskUp->setEnabled( false );
             actionMoveTaskDown->setEnabled( false );
             actionIndentTask->setEnabled( false );
             actionUnindentTask->setEnabled( false );
         } else {
             // we need to be able to add the first task
             menuAddTask->setEnabled( true );
             actionAddTask->setEnabled( true );
             actionAddMilestone->setEnabled( true );
             menuAddSubTask->setEnabled( false );
             actionAddSubtask->setEnabled( false );
             actionAddSubMilestone->setEnabled( false );
             actionDeleteTask->setEnabled( false );
             actionMoveTaskUp->setEnabled( false );
             actionMoveTaskDown->setEnabled( false );
             actionIndentTask->setEnabled( false );
             actionUnindentTask->setEnabled( false );
         }
         return;
     }
     Node *n = selectedNode(); // 0 if not a single task, summarytask or milestone
     if ( selCount == 1 && n == 0 ) {
         // only project selected
         menuAddTask->setEnabled( true );
         actionAddTask->setEnabled( true );
         actionAddMilestone->setEnabled( true );
         menuAddSubTask->setEnabled( true );
         actionAddSubtask->setEnabled( true );
         actionAddSubMilestone->setEnabled( true );
         actionDeleteTask->setEnabled( false );
         actionMoveTaskUp->setEnabled( false );
         actionMoveTaskDown->setEnabled( false );
         actionIndentTask->setEnabled( false );
         actionUnindentTask->setEnabled( false );
         return;
     }
     if ( selCount == 1 && n != currentNode() ) {
         // multi selection in progress
         menuAddTask->setEnabled( false );
         actionAddTask->setEnabled( false );
         actionAddMilestone->setEnabled( false );
         menuAddSubTask->setEnabled( false );
         actionAddSubtask->setEnabled( false );
         actionAddSubMilestone->setEnabled( false );
         actionDeleteTask->setEnabled( false );
         actionMoveTaskUp->setEnabled( false );
         actionMoveTaskDown->setEnabled( false );
         actionIndentTask->setEnabled( false );
         actionUnindentTask->setEnabled( false );
         return;
     }
 
     bool baselined = false;
     Project *p = m_view->project();
     if ( p && p->isBaselined() ) {
         foreach ( Node *n, selectedNodes() ) {
             if ( n->isBaselined() ) {
                 baselined = true;
                 break;
             }
         }
     }
     if ( selCount == 1 ) {
         menuAddTask->setEnabled( true );
         actionAddTask->setEnabled( true );
         actionAddMilestone->setEnabled( true );
         menuAddSubTask->setEnabled( ! baselined || n->type() == Node::Type_Summarytask );
         actionAddSubtask->setEnabled( ! baselined || n->type() == Node::Type_Summarytask );
         actionAddSubMilestone->setEnabled( ! baselined || n->type() == Node::Type_Summarytask );
         actionDeleteTask->setEnabled( ! baselined );
         Node *s = n->siblingBefore();
         actionMoveTaskUp->setEnabled( s );
         actionMoveTaskDown->setEnabled( n->siblingAfter() );
         s = n->siblingBefore();
         actionIndentTask->setEnabled( ! baselined && s && ! s->isBaselined() );
         actionUnindentTask->setEnabled( ! baselined && n->level() > 1 );
         return;
     }
     // selCount > 1
     menuAddTask->setEnabled( false );
     actionAddTask->setEnabled( false );
     actionAddMilestone->setEnabled( false );
     menuAddSubTask->setEnabled( false );
     actionAddSubtask->setEnabled( false );
     actionAddSubMilestone->setEnabled( false );
     actionDeleteTask->setEnabled( ! baselined );
     actionMoveTaskUp->setEnabled( false );
     actionMoveTaskDown->setEnabled( false );
     actionIndentTask->setEnabled( false );
     actionUnindentTask->setEnabled( false );
 }
 
 void TaskEditor::setupGui()
 {
     QString name = "taskeditor_add_list";
 
     menuAddTask = new KActionMenu(koIcon("view-task-add"), i18n("Add Task"), this);
     actionCollection()->addAction("add_task", menuAddTask );
     connect( menuAddTask, SIGNAL(triggered(bool)), SLOT(slotAddTask()) );
     addAction( name, menuAddTask );
 
     actionAddTask  = new QAction( i18n( "Add Task" ), this);
     actionAddTask->setShortcut( Qt::CTRL + Qt::Key_I );
     connect( actionAddTask, SIGNAL(triggered(bool)), SLOT(slotAddTask()) );
     menuAddTask->addAction( actionAddTask );
 
     actionAddMilestone  = new QAction( i18n( "Add Milestone" ), this );
     actionAddMilestone->setShortcut( Qt::CTRL + Qt::ALT + Qt::Key_I );
     connect( actionAddMilestone, SIGNAL(triggered(bool)), SLOT(slotAddMilestone()) );
     menuAddTask->addAction( actionAddMilestone );
 
 
     menuAddSubTask = new KActionMenu(koIcon("view-task-child-add"), i18n("Add Sub-Task"), this);
     actionCollection()->addAction("add_subtask", menuAddTask );
     connect( menuAddSubTask, SIGNAL(triggered(bool)), SLOT(slotAddSubtask()) );
     addAction( name, menuAddSubTask );
 
     actionAddSubtask  = new QAction( i18n( "Add Sub-Task" ), this );
     actionAddSubtask->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::Key_I );
     connect( actionAddSubtask, SIGNAL(triggered(bool)), SLOT(slotAddSubtask()) );
     menuAddSubTask->addAction( actionAddSubtask );
 
     actionAddSubMilestone = new QAction( i18n( "Add Sub-Milestone" ), this );
     actionAddSubMilestone->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::ALT + Qt::Key_I );
     connect( actionAddSubMilestone, SIGNAL(triggered(bool)), SLOT(slotAddSubMilestone()) );
     menuAddSubTask->addAction( actionAddSubMilestone );
 
     actionDeleteTask  = new QAction(koIcon("edit-delete"), xi18nc("@action", "Delete"), this);
     actionCollection()->setDefaultShortcut( actionDeleteTask, Qt::Key_Delete );
     actionCollection()->addAction("delete_task", actionDeleteTask );
     connect( actionDeleteTask, SIGNAL(triggered(bool)), SLOT(slotDeleteTask()) );
     addAction( name, actionDeleteTask );
 
 
     name = "taskeditor_move_list";
     actionIndentTask  = new QAction(koIcon("format-indent-more"), i18n("Indent Task"), this);
     actionCollection()->addAction("indent_task", actionIndentTask );
     connect(actionIndentTask, SIGNAL(triggered(bool)), SLOT(slotIndentTask()));
     addAction( name, actionIndentTask );
 
     actionUnindentTask  = new QAction(koIcon("format-indent-less"), i18n("Unindent Task"), this);
     actionCollection()->addAction("unindent_task", actionUnindentTask );
     connect(actionUnindentTask, SIGNAL(triggered(bool)), SLOT(slotUnindentTask()));
     addAction( name, actionUnindentTask );
 
     actionMoveTaskUp  = new QAction(koIcon("arrow-up"), i18n("Move Up"), this);
     actionCollection()->addAction("move_task_up", actionMoveTaskUp );
     connect(actionMoveTaskUp, SIGNAL(triggered(bool)), SLOT(slotMoveTaskUp()));
     addAction( name, actionMoveTaskUp );
 
     actionMoveTaskDown  = new QAction(koIcon("arrow-down"), i18n("Move Down"), this);
     actionCollection()->addAction("move_task_down", actionMoveTaskDown );
     connect(actionMoveTaskDown, SIGNAL(triggered(bool)), SLOT(slotMoveTaskDown()));
     addAction( name, actionMoveTaskDown );
 
     // Add the context menu actions for the view options
     actionShowProject = new KToggleAction( i18n( "Show Project" ), this );
     connect(actionShowProject, SIGNAL(triggered(bool)), baseModel(), SLOT(setShowProject(bool)));
     addContextAction( actionShowProject );
 
     connect(m_view->actionSplitView(), SIGNAL(triggered(bool)), SLOT(slotSplitView()));
     addContextAction( m_view->actionSplitView() );
 
     createOptionAction();
 
     createDockers();
 }
 
 void TaskEditor::slotSplitView()
 {
     debugPlan;
     m_view->setViewSplitMode( ! m_view->isViewSplit() );
     emit optionsModified();
 }
 
 
 void TaskEditor::slotOptions()
 {
     debugPlan;
     SplitItemViewSettupDialog *dlg = new SplitItemViewSettupDialog( this, m_view, this );
     dlg->addPrintingOptions();
     connect(dlg, SIGNAL(finished(int)), SLOT(slotOptionsFinished(int)));
     dlg->show();
     dlg->raise();
     dlg->activateWindow();
 }
 
 void TaskEditor::slotAddTask()
 {
     debugPlan;
     if ( selectedRowCount() == 0 || ( selectedRowCount() == 1 && selectedNode() == 0 ) ) {
         m_view->closePersistentEditor( m_view->selectionModel()->currentIndex() );
         Task *t = m_view->project()->createTask( m_view->project()->taskDefaults() );
         QModelIndex idx = m_view->baseModel()->insertSubtask( t, m_view->project() );
         Q_ASSERT( idx.isValid() );
         edit( idx );
         return;
     }
     Node *sib = selectedNode();
     if ( sib == 0 ) {
         return;
     }
     m_view->closePersistentEditor( m_view->selectionModel()->currentIndex() );
     Task *t = m_view->project()->createTask( m_view->project()->taskDefaults() );
     QModelIndex idx = m_view->baseModel()->insertTask( t, sib );
     Q_ASSERT( idx.isValid() );
     edit( idx );
 }
 
 void TaskEditor::slotAddMilestone()
 {
     debugPlan;
     if ( selectedRowCount() == 0  || ( selectedRowCount() == 1 && selectedNode() == 0 ) ) {
         // None selected or only project selected: insert under main project
         m_view->closePersistentEditor( m_view->selectionModel()->currentIndex() );
         Task *t = m_view->project()->createTask();
         t->estimate()->clear();
         QModelIndex idx = m_view->baseModel()->insertSubtask( t, m_view->project() );
         Q_ASSERT( idx.isValid() );
         edit( idx );
         return;
     }
     Node *sib = selectedNode(); // sibling
     if ( sib == 0 ) {
         return;
     }
     m_view->closePersistentEditor( m_view->selectionModel()->currentIndex() );
     Task *t = m_view->project()->createTask();
     t->estimate()->clear();
     QModelIndex idx = m_view->baseModel()->insertTask( t, sib );
     Q_ASSERT( idx.isValid() );
     edit( idx );
 }
 
 void TaskEditor::slotAddSubMilestone()
 {
     debugPlan;
     Node *parent = selectedNode();
     if ( parent == 0 && selectedRowCount() == 1 ) {
         // project selected
         parent = m_view->project();
     }
     if ( parent == 0 ) {
         return;
     }
     m_view->closePersistentEditor( m_view->selectionModel()->currentIndex() );
     Task *t = m_view->project()->createTask( m_view->project()->taskDefaults() );
     t->estimate()->clear();
     QModelIndex idx = m_view->baseModel()->insertSubtask( t, parent );
     Q_ASSERT( idx.isValid() );
     edit( idx );
 }
 
 void TaskEditor::slotAddSubtask()
 {
     debugPlan;
     Node *parent = selectedNode();
     if ( parent == 0 && selectedRowCount() == 1 ) {
         // project selected
         parent = m_view->project();
     }
     if ( parent == 0 ) {
         return;
     }
     m_view->closePersistentEditor( m_view->selectionModel()->currentIndex() );
     Task *t = m_view->project()->createTask( m_view->project()->taskDefaults() );
     QModelIndex idx = m_view->baseModel()->insertSubtask( t, parent );
     Q_ASSERT( idx.isValid() );
     edit( idx );
 }
 
 void TaskEditor::edit( const QModelIndex &i )
 {
     if ( i.isValid() ) {
         m_view->selectionModel()->setCurrentIndex( i, QItemSelectionModel::Rows | QItemSelectionModel::ClearAndSelect );
         m_view->setParentsExpanded( i, true ); // in case treeview does not have focus
         m_view->edit( i );
     }
 }
 
 void TaskEditor::slotDeleteTask()
 {
     //debugPlan;
     QList<Node*> lst = selectedNodes();
     while ( true ) {
         // remove children of selected tasks, as parents delete their children
         Node *ch = 0;
         foreach ( Node *n1, lst ) {
             foreach ( Node *n2, lst ) {
                 if ( n2->isChildOf( n1 ) ) {
                     ch = n2;
                     break;
                 }
             }
             if ( ch != 0 ) {
                 break;
             }
         }
         if ( ch == 0 ) {
             break;
         }
         lst.removeAt( lst.indexOf( ch ) );
     }
     //foreach ( Node* n, lst ) { debugPlan<<n->name(); }
     emit deleteTaskList( lst );
     QModelIndex i = m_view->selectionModel()->currentIndex();
     if ( i.isValid() ) {
         m_view->selectionModel()->select( i, QItemSelectionModel::Rows | QItemSelectionModel::ClearAndSelect );
         m_view->selectionModel()->setCurrentIndex( i, QItemSelectionModel::NoUpdate );
     }
 }
 
 void TaskEditor::slotIndentTask()
 {
     debugPlan;
     Node *n = selectedNode();
     if ( n ) {
         emit indentTask();
         QModelIndex i = baseModel()->index( n );
         m_view->selectionModel()->select( i, QItemSelectionModel::Rows | QItemSelectionModel::Current | QItemSelectionModel::ClearAndSelect );
         m_view->selectionModel()->setCurrentIndex( i, QItemSelectionModel::NoUpdate );
         m_view->setParentsExpanded( i, true );
     }
 }
 
 void TaskEditor::slotUnindentTask()
 {
     debugPlan;
     Node *n = selectedNode();
     if ( n ) {
         emit unindentTask();
         QModelIndex i = baseModel()->index( n );
         m_view->selectionModel()->select( i, QItemSelectionModel::Rows | QItemSelectionModel::Current | QItemSelectionModel::ClearAndSelect );
         m_view->selectionModel()->setCurrentIndex( i, QItemSelectionModel::NoUpdate );
     }
 }
 
 void TaskEditor::slotMoveTaskUp()
 {
     debugPlan;
     Node *n = selectedNode();
     if ( n ) {
         emit moveTaskUp();
         QModelIndex i = baseModel()->index( n );
         m_view->selectionModel()->select( i, QItemSelectionModel::Rows | QItemSelectionModel::Current | QItemSelectionModel::ClearAndSelect );
         m_view->selectionModel()->setCurrentIndex( i, QItemSelectionModel::NoUpdate );
     }
 }
 
 void TaskEditor::slotMoveTaskDown()
 {
     debugPlan;
     Node *n = selectedNode();
     if ( n ) {
         emit moveTaskDown();
         QModelIndex i = baseModel()->index( n );
         m_view->selectionModel()->select( i, QItemSelectionModel::Rows | QItemSelectionModel::Current | QItemSelectionModel::ClearAndSelect );
          m_view->selectionModel()->setCurrentIndex( i, QItemSelectionModel::NoUpdate );
    }
 }
 
 bool TaskEditor::loadContext( const KoXmlElement &context )
 {
     ViewBase::loadContext( context );
     bool show = (bool)(context.attribute( "show-project", "0" ).toInt() );
     actionShowProject->setChecked( show );
     baseModel()->setShowProject( show ); // why is this not called by the action?
     bool res = m_view->loadContext( baseModel()->columnMap(), context );
     return res;
 }
 
 void TaskEditor::saveContext( QDomElement &context ) const
 {
     ViewBase::saveContext( context );
     context.setAttribute( "show-project", QString::number(baseModel()->projectShown()) );
     m_view->saveContext( baseModel()->columnMap(), context );
 }
 
 KoPrintJob *TaskEditor::createPrintJob()
 {
     return m_view->createPrintJob( this );
 }
 
 
 //-----------------------------------
 TaskView::TaskView(KoPart *part, KoDocument *doc, QWidget *parent)
     : ViewBase(part, doc, parent)
 {
     QVBoxLayout * l = new QVBoxLayout( this );
     l->setMargin( 0 );
     m_view = new NodeTreeView( this );
     connect(this, SIGNAL(expandAll()), m_view, SLOT(slotExpand()));
     connect(this, SIGNAL(collapseAll()), m_view, SLOT(slotCollapse()));
 
     NodeSortFilterProxyModel *p = new NodeSortFilterProxyModel( m_view->baseModel(), m_view );
     m_view->setModel( p );
     l->addWidget( m_view );
     setupGui();
 
     //m_view->setEditTriggers( m_view->editTriggers() | QAbstractItemView::EditKeyPressed );
     m_view->setDragDropMode( QAbstractItemView::InternalMove );
     m_view->setDropIndicatorShown( false );
     m_view->setDragEnabled ( true );
     m_view->setAcceptDrops( false );
     m_view->setAcceptDropsOnView( false );
 
     QList<int> readonly;
     readonly << NodeModel::NodeName
             << NodeModel::NodeResponsible
             << NodeModel::NodeAllocation
             << NodeModel::NodeEstimateType
             << NodeModel::NodeEstimateCalendar
             << NodeModel::NodeEstimate
             << NodeModel::NodeOptimisticRatio
             << NodeModel::NodePessimisticRatio
             << NodeModel::NodeRisk
             << NodeModel::NodeConstraint
             << NodeModel::NodeConstraintStart
             << NodeModel::NodeConstraintEnd
             << NodeModel::NodeRunningAccount
             << NodeModel::NodeStartupAccount
             << NodeModel::NodeStartupCost
             << NodeModel::NodeShutdownAccount
             << NodeModel::NodeShutdownCost
             << NodeModel::NodeDescription;
     foreach ( int c, readonly ) {
         m_view->baseModel()->setReadOnly( c, true );
     }
 
     QList<int> lst1; lst1 << 1 << -1;
     QList<int> show;
     show << NodeModel::NodeStatus
             << NodeModel::NodeCompleted
             << NodeModel::NodeResponsible
             << NodeModel::NodeAssignments
             << NodeModel::NodePerformanceIndex
             << NodeModel::NodeBCWS
             << NodeModel::NodeBCWP
             << NodeModel::NodeACWP
             << NodeModel::NodeDescription;
 
     for ( int s = 0; s < show.count(); ++s ) {
         m_view->slaveView()->mapToSection( show[s], s );
     }
     QList<int> lst2;
     for ( int i = 0; i < m_view->model()->columnCount(); ++i ) {
         if ( ! show.contains( i ) ) {
             lst2 << i;
         }
     }
     m_view->hideColumns( lst1, lst2 );
     m_view->masterView()->setDefaultColumns( QList<int>() << 0 );
     m_view->slaveView()->setDefaultColumns( show );
 
     connect( m_view->baseModel(), SIGNAL(executeCommand(KUndo2Command*)), doc, SLOT(addCommand(KUndo2Command*)) );
 
     connect( m_view, SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(slotCurrentChanged(QModelIndex,QModelIndex)) );
 
     connect( m_view, SIGNAL(selectionChanged(QModelIndexList)), this, SLOT(slotSelectionChanged(QModelIndexList)) );
 
     connect( m_view, SIGNAL(contextMenuRequested(QModelIndex,QPoint,QModelIndexList)), SLOT(slotContextMenuRequested(QModelIndex,QPoint)) );
 
     connect( m_view, SIGNAL(headerContextMenuRequested(QPoint)), SLOT(slotHeaderContextMenuRequested(QPoint)) );
 }
 
 void TaskView::updateReadWrite( bool rw )
 {
     m_view->setReadWrite( rw );
     ViewBase::updateReadWrite( rw );
 }
 
 void TaskView::draw( Project &project )
 {
     m_view->setProject( &project );
 }
 
 void TaskView::draw()
 {
 }
 
 void TaskView::setGuiActive( bool activate )
 {
     debugPlan<<activate;
     updateActionsEnabled( true );
     ViewBase::setGuiActive( activate );
     if ( activate && !m_view->selectionModel()->currentIndex().isValid() && m_view->model()->rowCount() > 0 ) {
         m_view->selectionModel()->setCurrentIndex(m_view->model()->index( 0, 0 ), QItemSelectionModel::NoUpdate);
     }
 }
 
 void TaskView::slotCurrentChanged(  const QModelIndex &curr, const QModelIndex & )
 {
     debugPlan<<curr.row()<<","<<curr.column();
     slotEnableActions();
 }
 
 void TaskView::slotSelectionChanged( const QModelIndexList &list)
 {
     debugPlan<<list.count();
     slotEnableActions();
 }
 
 int TaskView::selectedNodeCount() const
 {
     QItemSelectionModel* sm = m_view->selectionModel();
     return sm->selectedRows().count();
 }
 
 QList<Node*> TaskView::selectedNodes() const {
     QList<Node*> lst;
     QItemSelectionModel* sm = m_view->selectionModel();
     if ( sm == 0 ) {
         return lst;
     }
     foreach ( const QModelIndex &i, sm->selectedRows() ) {
         Node * n = m_view->baseModel()->node( proxyModel()->mapToSource( i ) );
         if ( n != 0 && n->type() != Node::Type_Project ) {
             lst.append( n );
         }
     }
     return lst;
 }
 
 Node *TaskView::selectedNode() const
 {
     QList<Node*> lst = selectedNodes();
     if ( lst.count() != 1 ) {
         return 0;
     }
     return lst.first();
 }
 
 Node *TaskView::currentNode() const {
     Node * n = m_view->baseModel()->node( proxyModel()->mapToSource( m_view->selectionModel()->currentIndex() ) );
     if ( n == 0 || n->type() == Node::Type_Project ) {
         return 0;
     }
     return n;
 }
 
 void TaskView::slotContextMenuRequested( const QModelIndex& index, const QPoint& pos )
 {
     QString name;
     Node *node = m_view->baseModel()->node( proxyModel()->mapToSource( index ) );
     if ( node ) {
         switch ( node->type() ) {
             case Node::Type_Task:
                 name = "taskview_popup";
                 break;
             case Node::Type_Milestone:
                 name = "taskview_milestone_popup";
                 break;
             case Node::Type_Summarytask:
                 name = "taskview_summary_popup";
                 break;
             default:
                 break;
         }
     } else debugPlan<<"No node: "<<index;
     if ( name.isEmpty() ) {
         debugPlan<<"No menu";
         slotHeaderContextMenuRequested( pos );
         return;
     }
     m_view->setContextMenuIndex(index);
     emit requestPopupMenu( name, pos );
     m_view->setContextMenuIndex(QModelIndex());
 }
 
 void TaskView::setScheduleManager( ScheduleManager *sm )
 {
     //debugPlan<<endl;
     if (!sm && scheduleManager()) {
         // we should only get here if the only schedule manager is scheduled,
         // or when last schedule manager is deleted
         m_domdoc.clear();
         QDomElement element = m_domdoc.createElement("expanded");
         m_domdoc.appendChild(element);
         m_view->masterView()->saveExpanded(element);
     }
     bool tryexpand = sm && !scheduleManager();
     QDomDocument doc;
     bool expand = sm && scheduleManager() && sm != scheduleManager();
     if (expand) {
         m_view->masterView()->setObjectName("TaskEditor");
         QDomElement element = doc.createElement("expanded");
         doc.appendChild(element);
         m_view->masterView()->saveExpanded(element);
     }
     ViewBase::setScheduleManager(sm);
     m_view->baseModel()->setScheduleManager( sm );
 
     if (expand) {
         m_view->masterView()->doExpand(doc);
     } else if (tryexpand) {
         m_view->masterView()->doExpand(m_domdoc);
     }
 }
 
 void TaskView::slotEnableActions()
 {
     updateActionsEnabled( true );
 }
 
 void TaskView::updateActionsEnabled( bool /*on*/ )
 {
 
 }
 
 void TaskView::setupGui()
 {
 //    KActionCollection *coll = actionCollection();
 
     // Add the context menu actions for the view options
     actionShowProject = new KToggleAction( i18n( "Show Project" ), this );
     connect(actionShowProject, SIGNAL(triggered(bool)), baseModel(), SLOT(setShowProject(bool)));
     addContextAction( actionShowProject );
 
     connect(m_view->actionSplitView(), SIGNAL(triggered(bool)), SLOT(slotSplitView()));
     addContextAction( m_view->actionSplitView() );
 
     createOptionAction();
 }
 
 void TaskView::slotSplitView()
 {
     debugPlan;
     m_view->setViewSplitMode( ! m_view->isViewSplit() );
     emit optionsModified();
 }
 
 void TaskView::slotOptions()
 {
     debugPlan;
     SplitItemViewSettupDialog *dlg = new SplitItemViewSettupDialog( this, m_view, this );
     dlg->addPrintingOptions();
     connect(dlg, SIGNAL(finished(int)), SLOT(slotOptionsFinished(int)));
     dlg->show();
     dlg->raise();
     dlg->activateWindow();
 }
 
 bool TaskView::loadContext( const KoXmlElement &context )
 {
     ViewBase::loadContext( context );
     bool show = (bool)(context.attribute( "show-project", "0" ).toInt() );
     actionShowProject->setChecked( show );
     baseModel()->setShowProject( show ); // why is this not called by the action?
     return m_view->loadContext( m_view->baseModel()->columnMap(), context );
 }
 
 void TaskView::saveContext( QDomElement &context ) const
 {
     ViewBase::saveContext( context );
     context.setAttribute( "show-project", QString::number(baseModel()->projectShown()) );
     m_view->saveContext( m_view->baseModel()->columnMap(), context );
 }
 
 KoPrintJob *TaskView::createPrintJob()
 {
     return m_view->createPrintJob( this );
 }
 
 //---------------------------------
 WorkPackageTreeView::WorkPackageTreeView( QWidget *parent )
     : DoubleTreeViewBase( parent )
 {
     debugPlan<<"----------"<<this<<"----------";
     m = new WorkPackageProxyModel( this );
     setModel( m );
     //setSelectionBehavior( QAbstractItemView::SelectItems );
     setSelectionMode( QAbstractItemView::ExtendedSelection );
     setSelectionBehavior( QAbstractItemView::SelectRows );
 
     createItemDelegates( baseModel() );
 
     setSortingEnabled( true );
     sortByColumn( NodeModel::NodeWBSCode, Qt::AscendingOrder );
 
     connect( this, SIGNAL(dropAllowed(QModelIndex,int,QDragMoveEvent*)), SLOT(slotDropAllowed(QModelIndex,int,QDragMoveEvent*)) );
 }
 
 NodeItemModel *WorkPackageTreeView::baseModel() const
 {
     return m->baseModel();
 }
 
 void WorkPackageTreeView::slotDropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event )
 {
     Q_UNUSED(index);
     Q_UNUSED(dropIndicatorPosition);
     Q_UNUSED(event);
 /*    QModelIndex idx = index;
     NodeSortFilterProxyModel *pr = proxyModel();
     if ( pr ) {
         idx = pr->mapToSource( index );
     }
     event->ignore();
     if ( baseModel()->dropAllowed( idx, dropIndicatorPosition, event->mimeData() ) ) {
         event->accept();
     }*/
 }
 
 //--------------------------------
 TaskWorkPackageView::TaskWorkPackageView(KoPart *part, KoDocument *doc, QWidget *parent)
     : ViewBase(part, doc, parent ),
     m_cmd( 0 )
 {
     QVBoxLayout * l = new QVBoxLayout( this );
     l->setMargin( 0 );
     m_view = new WorkPackageTreeView( this );
     connect(this, SIGNAL(expandAll()), m_view, SLOT(slotExpand()));
     connect(this, SIGNAL(collapseAll()), m_view, SLOT(slotCollapse()));
 
     l->addWidget( m_view );
     setupGui();
 
     //m_view->setEditTriggers( m_view->editTriggers() | QAbstractItemView::EditKeyPressed );
     m_view->setDragDropMode( QAbstractItemView::InternalMove );
     m_view->setDropIndicatorShown( false );
     m_view->setDragEnabled ( true );
     m_view->setAcceptDrops( false );
     m_view->setAcceptDropsOnView( false );
 
     QList<int> readonly;
     readonly << NodeModel::NodeName
             << NodeModel::NodeResponsible
             << NodeModel::NodeAllocation
             << NodeModel::NodeEstimateType
             << NodeModel::NodeEstimateCalendar
             << NodeModel::NodeEstimate
             << NodeModel::NodeOptimisticRatio
             << NodeModel::NodePessimisticRatio
             << NodeModel::NodeRisk
             << NodeModel::NodeConstraint
             << NodeModel::NodeConstraintStart
             << NodeModel::NodeConstraintEnd
             << NodeModel::NodeRunningAccount
             << NodeModel::NodeStartupAccount
             << NodeModel::NodeStartupCost
             << NodeModel::NodeShutdownAccount
             << NodeModel::NodeShutdownCost
             << NodeModel::NodeDescription;
     foreach ( int c, readonly ) {
         m_view->baseModel()->setReadOnly( c, true );
     }
 
     QList<int> lst1; lst1 << 1 << -1;
     QList<int> show;
     show << NodeModel::NodeStatus
             << NodeModel::NodeCompleted
             << NodeModel::NodeResponsible
             << NodeModel::NodeAssignments
             << NodeModel::NodeDescription;
 
     for ( int s = 0; s < show.count(); ++s ) {
         m_view->slaveView()->mapToSection( show[s], s );
     }
     QList<int> lst2;
     for ( int i = 0; i < m_view->model()->columnCount(); ++i ) {
         if ( ! show.contains( i ) ) {
             lst2 << i;
         }
     }
     m_view->hideColumns( lst1, lst2 );
     m_view->masterView()->setDefaultColumns( QList<int>() << 0 );
     m_view->slaveView()->setDefaultColumns( show );
 
     connect( m_view->baseModel(), SIGNAL(executeCommand(KUndo2Command*)), doc, SLOT(addCommand(KUndo2Command*)) );
 
     connect( m_view, SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(slotCurrentChanged(QModelIndex,QModelIndex)) );
 
     connect( m_view, SIGNAL(selectionChanged(QModelIndexList)), this, SLOT(slotSelectionChanged(QModelIndexList)) );
 
     connect( m_view, SIGNAL(contextMenuRequested(QModelIndex,QPoint,QModelIndexList)), SLOT(slotContextMenuRequested(QModelIndex,QPoint)) );
 
     connect( m_view, SIGNAL(headerContextMenuRequested(QPoint)), SLOT(slotHeaderContextMenuRequested(QPoint)) );
 }
 
 Project *TaskWorkPackageView::project() const
 {
     return m_view->project();
 }
 
 void TaskWorkPackageView::setProject( Project *project )
 {
     m_view->setProject( project );
 }
 
 WorkPackageProxyModel *TaskWorkPackageView::proxyModel() const
 {
     return m_view->proxyModel();
 }
 
 void TaskWorkPackageView::updateReadWrite( bool rw )
 {
     m_view->setReadWrite( rw );
     ViewBase::updateReadWrite( rw );
 }
 
 void TaskWorkPackageView::setGuiActive( bool activate )
 {
     debugPlan<<activate;
     updateActionsEnabled( true );
     ViewBase::setGuiActive( activate );
     if ( activate && !m_view->selectionModel()->currentIndex().isValid() && m_view->model()->rowCount() > 0 ) {
         m_view->selectionModel()->setCurrentIndex(m_view->model()->index( 0, 0 ), QItemSelectionModel::NoUpdate);
     }
 }
 
 void TaskWorkPackageView::slotRefreshView()
 {
     emit checkForWorkPackages();
 }
 
 void TaskWorkPackageView::slotCurrentChanged(  const QModelIndex &curr, const QModelIndex & )
 {
     debugPlan<<curr.row()<<","<<curr.column();
     slotEnableActions();
 }
 
 void TaskWorkPackageView::slotSelectionChanged( const QModelIndexList &list)
 {
     debugPlan<<list.count();
     slotEnableActions();
 }
 
 int TaskWorkPackageView::selectedNodeCount() const
 {
     QItemSelectionModel* sm = m_view->selectionModel();
     return sm->selectedRows().count();
 }
 
 QList<Node*> TaskWorkPackageView::selectedNodes() const {
     QList<Node*> lst;
     QItemSelectionModel* sm = m_view->selectionModel();
     if ( sm == 0 ) {
         return lst;
     }
     foreach ( const QModelIndex &i, sm->selectedRows() ) {
         Node * n = proxyModel()->taskFromIndex( i );
         if ( n != 0 && n->type() != Node::Type_Project ) {
             lst.append( n );
         }
     }
     return lst;
 }
 
 Node *TaskWorkPackageView::selectedNode() const
 {
     QList<Node*> lst = selectedNodes();
     if ( lst.count() != 1 ) {
         return 0;
     }
     return lst.first();
 }
 
 Node *TaskWorkPackageView::currentNode() const {
     Node * n = proxyModel()->taskFromIndex( m_view->selectionModel()->currentIndex() );
     if ( n == 0 || n->type() == Node::Type_Project ) {
         return 0;
     }
     return n;
 }
 
 void TaskWorkPackageView::slotContextMenuRequested( const QModelIndex& index, const QPoint& pos )
 {
     QString name;
     Node *node = proxyModel()->taskFromIndex( index );
     if ( node ) {
         switch ( node->type() ) {
             case Node::Type_Task:
                 name = "workpackage_popup";
                 break;
             case Node::Type_Milestone:
                 name = "taskview_milestone_popup";
                 break;
             case Node::Type_Summarytask:
                 name = "taskview_summary_popup";
                 break;
             default:
                 break;
         }
     } else debugPlan<<"No node: "<<index;
     if ( name.isEmpty() ) {
         debugPlan<<"No menu";
         slotHeaderContextMenuRequested( pos );
         return;
     }
     m_view->setContextMenuIndex(index);
     emit requestPopupMenu( name, pos );
     m_view->setContextMenuIndex(QModelIndex());
 }
 
 void TaskWorkPackageView::setScheduleManager( ScheduleManager *sm )
 {
     //debugPlan<<endl;
     m_view->baseModel()->setScheduleManager( sm );
 }
 
 void TaskWorkPackageView::slotEnableActions()
 {
     updateActionsEnabled( true );
 }
 
 void TaskWorkPackageView::updateActionsEnabled( bool on )
 {
     bool o = ! selectedNodes().isEmpty();
     actionMailWorkpackage->setEnabled( o && on );
 }
 
 void TaskWorkPackageView::setupGui()
 {
 //    KActionCollection *coll = actionCollection();
 
     QString name = "workpackage_list";
     actionMailWorkpackage  = new QAction(koIcon("mail-send"), i18n("Send..."), this);
     actionCollection()->setDefaultShortcut( actionMailWorkpackage, Qt::CTRL + Qt::Key_M );
     actionCollection()->addAction("send_workpackage", actionMailWorkpackage );
     connect( actionMailWorkpackage, SIGNAL(triggered(bool)), SLOT(slotMailWorkpackage()) );
     addAction( name, actionMailWorkpackage );
 
     // Add the context menu actions for the view options
     connect(m_view->actionSplitView(), SIGNAL(triggered(bool)), SLOT(slotSplitView()));
     addContextAction( m_view->actionSplitView() );
 
     createOptionAction();
 }
 
 void TaskWorkPackageView::slotMailWorkpackage()
 {
     QList<Node*> lst = selectedNodes();
     if ( ! lst.isEmpty() ) {
         // TODO find a better way to log to avoid undo/redo
         m_cmd = new MacroCommand( kundo2_i18n( "Log Send Workpackage" ) );
         QPointer<WorkPackageSendDialog> dlg = new WorkPackageSendDialog( lst, scheduleManager(), this );
         connect ( dlg->panel(), SIGNAL(sendWorkpackages(QList<Node*>,Resource*)), this, SIGNAL(mailWorkpackages(QList<Node*>,Resource*)) );
 
         connect ( dlg->panel(), SIGNAL(sendWorkpackages(QList<Node*>,Resource*)), this, SLOT(slotWorkPackageSent(QList<Node*>,Resource*)) );
         dlg->exec();
         delete dlg;
         if ( ! m_cmd->isEmpty() ) {
             part()->addCommand( m_cmd );
             m_cmd = 0;
         }
         delete m_cmd;
         m_cmd = 0;
     }
 }
 
 void TaskWorkPackageView::slotWorkPackageSent( const QList<Node*> &nodes, Resource *resource )
 {
     foreach ( Node *n, nodes ) {
         WorkPackage *wp = new WorkPackage( static_cast<Task*>( n )->workPackage() );
         wp->setOwnerName( resource->name() );
         wp->setOwnerId( resource->id() );
         wp->setTransmitionTime( DateTime::currentDateTime() );
         wp->setTransmitionStatus( WorkPackage::TS_Send );
         m_cmd->addCommand( new WorkPackageAddCmd( static_cast<Project*>( n->projectNode() ), n, wp ) );
     }
 }
 
 void TaskWorkPackageView::slotSplitView()
 {
     debugPlan;
     m_view->setViewSplitMode( ! m_view->isViewSplit() );
     emit optionsModified();
 }
 
 void TaskWorkPackageView::slotOptions()
 {
     debugPlan;
     SplitItemViewSettupDialog *dlg = new SplitItemViewSettupDialog( this, m_view, this );
     dlg->addPrintingOptions();
     connect(dlg, SIGNAL(finished(int)), SLOT(slotOptionsFinished(int)));
     dlg->show();
     dlg->raise();
     dlg->activateWindow();
 }
 
 bool TaskWorkPackageView::loadContext( const KoXmlElement &context )
 {
     debugPlan;
     ViewBase::loadContext( context );
     return m_view->loadContext( m_view->baseModel()->columnMap(), context );
 }
 
 void TaskWorkPackageView::saveContext( QDomElement &context ) const
 {
     ViewBase::saveContext( context );
     m_view->saveContext( m_view->baseModel()->columnMap(), context );
 }
 
 KoPrintJob *TaskWorkPackageView::createPrintJob()
 {
     return m_view->createPrintJob( this );
 }
 
 } // namespace KPlato
diff --git a/plan/libs/ui/kpttaskeditor.h b/plan/libs/ui/kpttaskeditor.h
index 29705b2296d..c27c22662fc 100644
--- a/plan/libs/ui/kpttaskeditor.h
+++ b/plan/libs/ui/kpttaskeditor.h
@@ -1,354 +1,356 @@
 /* This file is part of the KDE project
   Copyright (C) 2006 -20010 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version..
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KPTTASKEDITOR_H
 #define KPTTASKEDITOR_H
 
 #include "kplatoui_export.h"
 
 #include "kptglobal.h"
 #include "kptnodeitemmodel.h"
 #include "kptviewbase.h"
 
 class KoDocument;
 
 class KActionMenu;
 
 namespace KPlato
 {
 
 class Project;
 class Node;
 class NodeItemModel;
 class MacroCommand;
 
 class KPLATOUI_EXPORT TaskEditorItemModel : public NodeItemModel
 {
     Q_OBJECT
 public:
     explicit TaskEditorItemModel( QObject *parent = 0 );
     
     virtual Qt::ItemFlags flags( const QModelIndex & index ) const;
     virtual QVariant headerData( int section, Qt::Orientation orientation, int role ) const;
     virtual QVariant data( const QModelIndex & index, int role = Qt::DisplayRole ) const; 
     virtual bool setData( const QModelIndex & index, const QVariant &value, int role = Qt::EditRole );
 
 protected:
     QVariant type( const Node *node, int role ) const;
     virtual bool setType( Node *node, const QVariant &value, int role );
 
 };
 
 class KPLATOUI_EXPORT TaskEditorTreeView : public DoubleTreeViewBase
 {
     Q_OBJECT
 public:
     explicit TaskEditorTreeView(QWidget *parent);
 
     //void setSelectionModel( QItemSelectionModel *selectionModel );
 
     NodeItemModel *baseModel() const;
     NodeSortFilterProxyModel *proxyModel() const { return qobject_cast<NodeSortFilterProxyModel*>( model() ); }
 
     Project *project() const { return baseModel()->project(); }
     void setProject( Project *project ) { baseModel()->setProject( project ); }
     
 Q_SIGNALS:
     void currentColumnChanged( const QModelIndex&, const QModelIndex& );
 
 protected Q_SLOTS:
     void slotDropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event );
 };
 
 class KPLATOUI_EXPORT NodeTreeView : public DoubleTreeViewBase
 {
     Q_OBJECT
 public:
     explicit NodeTreeView(QWidget *parent);
 
     //void setSelectionModel( QItemSelectionModel *selectionModel );
 
     NodeItemModel *baseModel() const;
     NodeSortFilterProxyModel *proxyModel() const { return qobject_cast<NodeSortFilterProxyModel*>( model() ); }
 
     Project *project() const { return baseModel()->project(); }
     void setProject( Project *project ) { baseModel()->setProject( project ); }
     
 Q_SIGNALS:
     void currentColumnChanged( const QModelIndex&, const QModelIndex& );
 
 protected Q_SLOTS:
     void slotDropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event );
 };
 
 class KPLATOUI_EXPORT TaskEditor : public ViewBase
 {
     Q_OBJECT
 public:
     TaskEditor(KoPart *part, KoDocument *doc, QWidget *parent);
     
     void setupGui();
     void setProject( Project *project );
     Project *project() const { return m_view->project(); }
     virtual void createDockers();
 
     virtual Node *currentNode() const;
     QList<Node*> selectedNodes() const ;
     Node *selectedNode() const;
 
     virtual void updateReadWrite( bool readwrite );
 
     NodeItemModel *baseModel() const { return m_view->baseModel(); }
     NodeSortFilterProxyModel *proxyModel() const { return m_view->proxyModel(); }
     QAbstractItemModel *model() const { return m_view->model(); }
 
     /// Loads context info into this view. Reimplement.
     virtual bool loadContext( const KoXmlElement &/*context*/ );
     /// Save context info from this view. Reimplement.
     virtual void saveContext( QDomElement &/*context*/ ) const;
 
     virtual KoPrintJob *createPrintJob();
 
-    void setTaskModules( const QStringList &files );
-
 Q_SIGNALS:
     void taskSelected( Task *task );
     void openNode();
     void addTask();
     void addMilestone();
     void addSubtask();
     void addSubMilestone();
     void deleteTaskList( const QList<Node*>& );
     void moveTaskUp();
     void moveTaskDown();
     void indentTask();
     void unindentTask();
 
     void loadTaskModules( const QStringList &files );
     void saveTaskModule( const QUrl &url, Project *project );
     void removeTaskModule( const QUrl &url );
 
 public Q_SLOTS:
     /// Activate/deactivate the gui
     virtual void setGuiActive( bool activate );
 
     void setScheduleManager( ScheduleManager *sm );
     
+    void setTaskModules( const QStringList &files );
+
 protected:
     void updateActionsEnabled( bool on );
     int selectedRowCount() const;
     QModelIndexList selectedRows() const;
     void editTasks(const QList<Task*> &tasks, const QPoint &pos);
 
 protected Q_SLOTS:
     virtual void slotOptions();
 
 private Q_SLOTS:
     void slotSelectionChanged( const QModelIndexList& );
     void slotCurrentChanged( const QModelIndex&, const QModelIndex& );
     void slotContextMenuRequested(const QModelIndex &index, const QPoint& pos , const QModelIndexList &rows);
 
     void slotEnableActions();
 
     void slotAddTask();
     void slotAddSubtask();
     void slotAddMilestone();
     void slotAddSubMilestone();
     void slotDeleteTask();
     void slotIndentTask();
     void slotUnindentTask();
     void slotMoveTaskUp();
     void slotMoveTaskDown();
 
     void slotSplitView();
     void slotProjectShown( bool );
 
+    void taskModuleDoubleClicked(QModelIndex idx);
+
 private:
     void edit( const QModelIndex &index );
 
 private:
     TaskEditorTreeView *m_view;
 
     KActionMenu *menuAddTask;
     KActionMenu *menuAddSubTask;
     QAction *actionAddTask;
     QAction *actionAddMilestone;
     QAction *actionAddSubtask;
     QAction *actionAddSubMilestone;
     QAction *actionDeleteTask;
     QAction *actionMoveTaskUp;
     QAction *actionMoveTaskDown;
     QAction *actionIndentTask;
     QAction *actionUnindentTask;
 
     QAction *actionShowProject;
     QDomDocument m_domdoc;
 };
 
 class KPLATOUI_EXPORT TaskView : public ViewBase
 {
     Q_OBJECT
 public:
     TaskView(KoPart *part, KoDocument *doc, QWidget *parent);
 
     void setupGui();
     Project *project() const { return m_view->project(); }
     virtual void draw( Project &project );
     virtual void draw();
 
     NodeItemModel *baseModel() const { return m_view->baseModel(); }
     NodeSortFilterProxyModel *proxyModel() const { return m_view->proxyModel(); }
 
     virtual Node *currentNode() const;
     QList<Node*> selectedNodes() const ;
     Node *selectedNode() const;
 
     virtual void updateReadWrite( bool readwrite );
 
     /// Loads context info into this view. Reimplement.
     virtual bool loadContext( const KoXmlElement &/*context*/ );
     /// Save context info from this view. Reimplement.
     virtual void saveContext( QDomElement &/*context*/ ) const;
 
     KoPrintJob *createPrintJob();
     
 Q_SIGNALS:
     void openNode();
 
 public Q_SLOTS:
     /// Activate/deactivate the gui
     virtual void setGuiActive( bool activate );
 
     void setScheduleManager( ScheduleManager *sm );
 
 protected:
     void updateActionsEnabled( bool on );
     int selectedNodeCount() const;
 
 protected Q_SLOTS:
     virtual void slotOptions();
 
 private Q_SLOTS:
     void slotSelectionChanged( const QModelIndexList& );
     void slotCurrentChanged( const QModelIndex&, const QModelIndex& );
     void slotContextMenuRequested( const QModelIndex &index, const QPoint& pos );
 
     void slotEnableActions();
 
     void slotSplitView();
 
 private:
     NodeTreeView *m_view;
     QAction *actionShowProject;
     QDomDocument m_domdoc;
 };
 
 //-----------------------------------
 class WorkPackageTreeView : public DoubleTreeViewBase
 {
     Q_OBJECT
 public:
     explicit WorkPackageTreeView(QWidget *parent);
 
     //void setSelectionModel( QItemSelectionModel *selectionModel );
 
     NodeItemModel *baseModel() const;
     WorkPackageProxyModel *proxyModel() const { return m; }
 
     Project *project() const { return baseModel()->project(); }
     void setProject( Project *project ) { m->setProject( project ); }
 
     ScheduleManager *scheduleManager() const { return baseModel()->manager(); }
 
 Q_SIGNALS:
     void currentColumnChanged( const QModelIndex&, const QModelIndex& );
 
 protected Q_SLOTS:
     void slotDropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event );
 protected:
     WorkPackageProxyModel *m;
 };
 
 class KPLATOUI_EXPORT TaskWorkPackageView : public ViewBase
 {
     Q_OBJECT
 public:
     TaskWorkPackageView(KoPart *part, KoDocument *doc, QWidget *parent);
 
     void setupGui();
     Project *project() const;
     void setProject( Project *project );
     ScheduleManager *scheduleManager() const { return m_view->scheduleManager(); }
 
     WorkPackageProxyModel *proxyModel() const;
 
     virtual Node *currentNode() const;
     QList<Node*> selectedNodes() const ;
     Node *selectedNode() const;
 
     virtual void updateReadWrite( bool readwrite );
 
     /// Loads context info into this view. Reimplement.
     virtual bool loadContext( const KoXmlElement &/*context*/ );
     /// Save context info from this view. Reimplement.
     virtual void saveContext( QDomElement &/*context*/ ) const;
 
     KoPrintJob *createPrintJob();
     
 Q_SIGNALS:
     void mailWorkpackage( Node *n, Resource *r = 0 );
     void mailWorkpackages( const QList<Node*> &nodes, Resource *r );
     void checkForWorkPackages();
 
 public Q_SLOTS:
     /// Activate/deactivate the gui
     virtual void setGuiActive( bool activate );
     void slotRefreshView();
     void setScheduleManager( ScheduleManager *sm );
 
 protected:
     void updateActionsEnabled( bool on );
     int selectedNodeCount() const;
 
 protected Q_SLOTS:
     virtual void slotOptions();
     void slotMailWorkpackage();
     void slotWorkPackageSent( const QList<Node*> &nodes, Resource *resource );
 
 private Q_SLOTS:
     void slotSelectionChanged( const QModelIndexList& );
     void slotCurrentChanged( const QModelIndex&, const QModelIndex& );
     void slotContextMenuRequested( const QModelIndex &index, const QPoint& pos );
 
     void slotEnableActions();
 
     void slotSplitView();
 
 private:
     WorkPackageTreeView *m_view;
     MacroCommand *m_cmd;
 
     QAction *actionMailWorkpackage;
 
 };
 
 } //namespace KPlato
 
 
 #endif
diff --git a/plan/libs/ui/kptviewbase.h b/plan/libs/ui/kptviewbase.h
index 6d5579f94b8..126c3f804aa 100644
--- a/plan/libs/ui/kptviewbase.h
+++ b/plan/libs/ui/kptviewbase.h
@@ -1,672 +1,673 @@
 /* This file is part of the KDE project
   Copyright (C) 2006 -2010 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef KPTVIEWBASE_H
 #define KPTVIEWBASE_H
 
 #include "kplatoui_export.h"
 #include "kptitemmodelbase.h"
 
 #include "ui_kptprintingheaderfooter.h"
 
 
 #include <KoView.h>
 #include <KoPrintingDialog.h>
 #include <KoPageLayout.h>
 #include <KoDockFactoryBase.h>
 
 #include <QMap>
 #include <QTreeView>
 #include <QSplitter>
 #include <QList>
 #include <QDockWidget>
 #include <QDomDocument>
 
 class QMetaEnum;
 class QAbstractItemModel;
 class QDomElement;
 class QModelIndex;
 
 class KoDocument;
 class KoPrintJob;
 class KoPart;
 
 /// The main namespace
 namespace KPlato
 {
 
 class Project;
 class Node;
 class Resource;
 class ResourceGroup;
 class Relation;
 class Calendar;
 
 class ViewBase;
 class TreeViewBase;
 class DoubleTreeViewBase;
 
 //------------------
 
 class KPLATOUI_EXPORT DockWidget : public QDockWidget
 {
     Q_OBJECT
 public:
     DockWidget( ViewBase *v, const QString &identity, const QString &title );
 
     void activate( KoMainWindow *mainWindow );
     void deactivate( KoMainWindow *mainWindow );
     bool shown() const;
 
     bool saveXml( QDomElement &context ) const;
     void loadXml( const KoXmlElement &context );
 
     const ViewBase *view;        /// The view this docker belongs to
     QString id;                  /// Docker identity
     Qt::DockWidgetArea location; /// The area the docker should go when visible
     bool editor;                 /// Editor dockers will not be shown in read only mode
 
 public Q_SLOTS:
     void setShown( bool show );
     void setLocation( Qt::DockWidgetArea area );
 
 private:
     bool m_shown;                /// The dockers visivbility when the view is active
 };
 
 //------------------
 class KPLATOUI_EXPORT PrintingOptions
 {
 public:
     PrintingOptions() {
         headerOptions.group = true;
         headerOptions.project = Qt::Checked;
         headerOptions.date = Qt::Checked;
         headerOptions.manager = Qt::Checked;
         headerOptions.page = Qt::Checked;
         
         footerOptions.group = false;
         footerOptions.project = Qt::Checked;
         footerOptions.date = Qt::Checked;
         footerOptions.manager = Qt::Checked;
         footerOptions.page = Qt::Checked;
     }
     ~PrintingOptions() {}
 
     bool loadXml( KoXmlElement &element );
     void saveXml( QDomElement &element ) const;
 
     struct Data {
         bool group;
         Qt::CheckState project;
         Qt::CheckState date;
         Qt::CheckState manager;
         Qt::CheckState page;
     };
     struct Data headerOptions;
     struct Data footerOptions;
 };
 
 //------------------
 class KPLATOUI_EXPORT PrintingHeaderFooter : public QWidget, public Ui::PrintingHeaderFooter
 {
     Q_OBJECT
 public:
     explicit PrintingHeaderFooter( const PrintingOptions &opt, QWidget *parent = 0 );
     ~PrintingHeaderFooter();
     
     void setOptions( const PrintingOptions &options );
     PrintingOptions options() const;
 
 Q_SIGNALS:
     void changed(const PrintingOptions&);
 
 protected Q_SLOTS:
     void slotChanged();
 
 private:
     PrintingOptions m_options;
 };
 
 //------------------
 class KPLATOUI_EXPORT PrintingDialog : public KoPrintingDialog
 {
     Q_OBJECT
 public:
     explicit PrintingDialog(ViewBase *view);
     ~PrintingDialog();
 
     virtual QList<QWidget*> createOptionWidgets() const;
     virtual QList<KoShape*> shapesOnPage(int);
 
     QRect headerRect() const;
     QRect footerRect() const;
     void paintHeaderFooter( QPainter &p, const PrintingOptions &options, int pageNumber, const Project &project );
     
     PrintingOptions printingOptions() const;
     
     QWidget *createPageLayoutWidget() const;
     QAbstractPrintDialog::PrintDialogOptions printDialogOptions() const;
 
 Q_SIGNALS:
     void changed( const PrintingOptions &opt );
     void changed();
     
 public Q_SLOTS:
     void setPrintingOptions( const PrintingOptions &opt);
     void setPrinterPageLayout( const KoPageLayout &pagelayout );
     virtual void startPrinting(RemovePolicy removePolicy = DoNotDelete);
 
 protected:
     virtual void paint( QPainter &p, const PrintingOptions::Data &options, const QRect &rect,  int pageNumber, const Project &project );
     int headerFooterHeight( const PrintingOptions::Data &options ) const;
     void drawRect( QPainter &p, const QRect &r, Qt::Edges edges = Qt::LeftEdge | Qt::RightEdge | Qt::BottomEdge );
 
 
 protected:
     ViewBase *m_view;
     PrintingHeaderFooter *m_widget;
     int m_textheight;
 };
 
 class KPLATOUI_EXPORT ViewActionLists
 {
 public:
     ViewActionLists() : actionOptions( 0 ) {}
     virtual ~ViewActionLists() {}
 
     /// Returns the list of action lists that shall be plugged/unplugged
     virtual QStringList actionListNames() const { return m_actionListMap.keys(); }
     /// Returns the list of actions associated with the action list name
     virtual QList<QAction*> actionList( const QString &name ) const { return m_actionListMap[name]; }
     /// Add an action to the specified action list
     void addAction( const QString &list, QAction *action ) { m_actionListMap[list].append( action ); }
 
     virtual QList<QAction*> viewlistActionList() const { return m_viewlistActionList; }
     void addViewlistAction( QAction *action ) { m_viewlistActionList.append( action ); }
 
     QList<QAction*> contextActionList() const { return m_contextActionList; }
     void addContextAction( QAction *action ) { m_contextActionList.append( action ); }
 
 protected:
     /// List of all menu/toolbar actions (used for plug/unplug)
     QMap<QString, QList<QAction*> > m_actionListMap;
 
     /// List of actions that will be shown in the viewlist context menu
     QList<QAction*> m_viewlistActionList;
     
     /// List of actions that will be shown in the views header context menu
     QList<QAction*> m_contextActionList;
     
     // View options context menu
     QAction *actionOptions;
 };
 
 /** 
  ViewBase is the baseclass of all sub-views to View.
 
 */
 class KPLATOUI_EXPORT ViewBase : public KoView, public ViewActionLists
 {
     Q_OBJECT
 public:
     /// Contructor
     ViewBase(KoPart *part, KoDocument *doc, QWidget *parent);
     /// Destructor
     virtual ~ViewBase();
     /// Return the part (document) this view handles
     KoDocument *part() const;
 
     /// Return the page layout used for printing this view
     virtual KoPageLayout pageLayout() const;
 
     /// Return the type of view this is (class name)
     QString viewType() const { return metaObject()->className(); }
     
     /// Returns true if this view or any child widget has focus
     bool isActive() const;
     
     /// Set the project this view shall handle.
     virtual void setProject( Project *project );
     /// Return the project
     virtual Project *project() const { return m_proj; }
     /// Return the schedule manager
     virtual ScheduleManager *scheduleManager() const { return m_schedulemanager; }
     /// Draw data from current part / project
     virtual void draw() {}
     /// Draw data from project.
     virtual void draw(Project &/*project*/) {}
     /// Draw changed data from project.
     virtual void drawChanges(Project &project) { draw(project); }
     /// Set readWrite mode
     virtual void updateReadWrite( bool );
     bool isReadWrite() const { return m_readWrite; }
 
     /// Reimplement if your view handles nodes
     virtual Node* currentNode() const { return 0; }
     /// Reimplement if your view handles resources
     virtual Resource* currentResource() const { return 0; }
     /// Reimplement if your view handles resource groups
     virtual ResourceGroup* currentResourceGroup() const { return 0; }
     /// Reimplement if your view handles calendars
     virtual Calendar* currentCalendar() const { return 0; }
     /// Reimplement if your view handles relations
     virtual Relation *currentRelation() const { return 0; }
     /// Reimplement if your view handles zoom
     virtual KoZoomController *zoomController() const { return 0; }
 
     /// Loads context info (printer settings) into this view.
     virtual bool loadContext( const KoXmlElement &context );
     /// Save context info (printer settings) from this view.
     virtual void saveContext( QDomElement &context ) const;
 
     virtual KoPrintJob *createPrintJob();
     PrintingOptions printingOptions() const { return m_printingOptions; }
     static QWidget *createPageLayoutWidget( ViewBase *view );
     static PrintingHeaderFooter *createHeaderFooterWidget( ViewBase *view );
     void addAction( const QString &list, QAction *action ) { ViewActionLists::addAction( list, action );  }
 
     virtual void createDockers() {}
     void addDocker( DockWidget *ds );
     QList<DockWidget*> dockers() const;
     DockWidget *findDocker( const QString &id ) const;
 
 public Q_SLOTS:
     void setPrintingOptions( const PrintingOptions &opt ) { m_printingOptions = opt; }
     /// Activate/deactivate the gui
     virtual void setGuiActive( bool activate );
     virtual void setScheduleManager( ScheduleManager *sm ) { m_schedulemanager = sm; }
     void slotUpdateReadWrite( bool );
     virtual void slotHeaderContextMenuRequested( const QPoint &pos );
 
     virtual void slotEditCopy() {}
     virtual void slotEditCut() {}
     virtual void slotEditPaste() {}
     virtual void slotRefreshView() {}
     
     void setPageLayout( const KoPageLayout &layout );
 
 Q_SIGNALS:
     /// Emitted when the gui has been activated or deactivated
     void guiActivated( ViewBase*, bool );
     /// Request for a context menu popup
     void requestPopupMenu( const QString&, const QPoint & );
     
     /// Emitted when options are modified
     void optionsModified();
 
     void projectChanged( Project *project );
     void readWriteChanged( bool );
 
     void expandAll();
     void collapseAll();
 
+    void openDocument(const QUrl &url);
 protected Q_SLOTS:
     virtual void slotOptions() {}
     virtual void slotOptionsFinished( int result );
 
 protected:
     void createOptionAction();
     
     bool m_readWrite;
     PrintingOptions m_printingOptions;
     
     Project *m_proj;
     ScheduleManager *m_schedulemanager;
     
     KoPageLayout m_pagelayout;
 
     QList<DockWidget*> m_dockers;
 };
 
 //------------------
 class KPLATOUI_EXPORT TreeViewPrintingDialog : public PrintingDialog
 {
     Q_OBJECT
 public:
     TreeViewPrintingDialog( ViewBase *view, TreeViewBase *treeview, Project *project = 0 );
     ~TreeViewPrintingDialog() {}
 
     virtual int documentFirstPage() const { return 1; }
     virtual int documentLastPage() const;
 
     QList<QWidget*> createOptionWidgets() const;
 
 protected:
     virtual void printPage( int pageNumber, QPainter &painter );
 
     int firstRow( int page ) const;
 
 private:
     TreeViewBase *m_tree;
     Project *m_project;
     int m_firstRow;
 };
 
 //-----------------
 class KPLATOUI_EXPORT TreeViewBase : public QTreeView
 {
     Q_OBJECT
 public:
     explicit TreeViewBase( QWidget *parent = 0 );
 
     void setReadWrite( bool rw );
     virtual void createItemDelegates( ItemModelBase *model );
     void setArrowKeyNavigation( bool on ) { m_arrowKeyNavigation = on; }
     bool arrowKeyNavigation() const { return m_arrowKeyNavigation; }
 
     /// Move move to first visual
     QModelIndex firstColumn( int row, const QModelIndex &parent );
     /// Move move to last visual
     QModelIndex lastColumn( int row, const QModelIndex &parent );
     /// Move from @p current to next item
     QModelIndex nextColumn( const QModelIndex &current );
     /// Move from @p current to next item
     QModelIndex previousColumn( const QModelIndex &current );
     /// Move to first editable index in @p row with @p parent
     QModelIndex firstEditable( int row, const QModelIndex &parent );
     /// Move to last editable index in @p row with @p parent
     QModelIndex lastEditable( int row, const QModelIndex &parent );
 
     void setAcceptDropsOnView( bool mode ) { m_acceptDropsOnView = mode; }
 
     virtual void setModel( QAbstractItemModel *model );
 
     virtual void setSelectionModel( QItemSelectionModel *model );
 
     void setStretchLastSection( bool );
 
     void mapToSection( int column, int section );
     int section( int col ) const;
 
     void setColumnsHidden( const QList<int> &list );
 
     /// Loads context info into this view. Reimplement.
     virtual bool loadContext(const QMetaEnum &map, const KoXmlElement &element, bool expand = true);
     /// Save context info from this view. Reimplement.
     virtual void saveContext(const QMetaEnum &map, QDomElement &context , bool expand = true) const;
 
     /**
       Reimplemented to fix qt bug 160083: Doesn't scroll horisontally.
     
       Scroll the contents of the tree view until the given model item
       \a index is visible. The \a hint parameter specifies more
       precisely where the item should be located after the
       operation.
       If any of the parents of the model item are collapsed, they will
       be expanded to ensure that the model item is visible.
     */
     void scrollTo(const QModelIndex &index, ScrollHint hint = EnsureVisible);
 
     void setDefaultColumns( const QList<int> &lst ) { m_defaultColumns = lst; }
     QList<int> defaultColumns() const { return m_defaultColumns; }
 
     KoPrintJob *createPrintJob( ViewBase *parent );
 
     QModelIndex firstVisibleIndex( const QModelIndex &idx ) const;
 
     ItemModelBase *itemModel() const;
 
     void setContextMenuIndex(const QModelIndex &idx);
 
     void loadExpanded(const KoXmlElement &element);
     void saveExpanded(QDomElement &element, const QModelIndex &parent = QModelIndex()) const;
     void expandRecursivly(QDomElement element, const QModelIndex &parent = QModelIndex());
     void doExpand(QDomDocument &doc);
 
 public Q_SLOTS:
     void slotExpand();
     void slotCollapse();
 
 Q_SIGNALS:
     /// Context menu requested from viewport at global position @p pos
     void contextMenuRequested( const QModelIndex&, const QPoint &pos, const QModelIndexList& );
     /// Context menu requested from header at global position @p pos
     void headerContextMenuRequested( const QPoint &pos );
 
     void moveAfterLastColumn( const QModelIndex & );
     void moveBeforeFirstColumn( const QModelIndex & );
     void editAfterLastColumn( const QModelIndex & );
     void editBeforeFirstColumn( const QModelIndex & );
 
     void dropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event );
 
 protected:
     void keyPressEvent(QKeyEvent *event);
     void mousePressEvent( QMouseEvent *event );
     /**
       Reimplemented from QTreeView to make tab/backtab in editor work reasonably well.
       Move the cursor in the way described by \a cursorAction, *not* using the
       information provided by the button \a modifiers.
     */
     QModelIndex moveCursor( CursorAction cursorAction, Qt::KeyboardModifiers modifiers );
     /// Move cursor from @p index in direction @p cursorAction. @p modifiers is not used.
     QModelIndex moveCursor(  const QModelIndex &index, CursorAction cursorAction, Qt::KeyboardModifiers = Qt::NoModifier );
     /// Move from @p index to next editable item, in direction @p cursorAction.
     QModelIndex moveToEditable( const QModelIndex &index, CursorAction cursorAction );
     
     void contextMenuEvent ( QContextMenuEvent * event );
 
     void dragMoveEvent(QDragMoveEvent *event);
     void dropEvent( QDropEvent *e );
     void updateSelection( const QModelIndex &oldidx, const QModelIndex &newidx, QKeyEvent *event );
 
     void expandRecursive(const QModelIndex &parent, bool xpand);
 
 protected Q_SLOTS:
     /// Close the @p editor, using sender()->endEditHint().
     /// Use @p hint if sender is not of type ItemDelegate.
     virtual void closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint);
     
     virtual void slotCurrentChanged ( const QModelIndex & current, const QModelIndex & previous );
     void slotHeaderContextMenuRequested( const QPoint& );
 
     //Copied from QAbstractItemView
     inline QItemSelectionModel::SelectionFlags selectionBehaviorFlags() const
     {
         switch (selectionBehavior()) {
             case QAbstractItemView::SelectRows: return QItemSelectionModel::Rows;
             case QAbstractItemView::SelectColumns: return QItemSelectionModel::Columns;
             case QAbstractItemView::SelectItems: default: return QItemSelectionModel::NoUpdate;
         }
     }
 
     void doContextExpanded();
     void doExpanded();
 
 protected:
     virtual void focusInEvent(QFocusEvent *event);
     
     bool m_arrowKeyNavigation;
     bool m_acceptDropsOnView;
     QList<int> m_hideList;
     bool m_readWrite;
     QList<int> m_defaultColumns;
 
     QPersistentModelIndex m_contextMenuIndex;
     QDomDocument m_loadContextDoc;
     QDomDocument m_expandDoc;
 };
 
 //------------------
 class KPLATOUI_EXPORT DoubleTreeViewPrintingDialog : public PrintingDialog
 {
     Q_OBJECT
 public:
     DoubleTreeViewPrintingDialog( ViewBase *view, DoubleTreeViewBase *treeview, Project *project );
     ~DoubleTreeViewPrintingDialog() {}
 
     virtual int documentFirstPage() const { return 1; }
     virtual int documentLastPage() const;
 
     QList<QWidget*> createOptionWidgets() const;
 
 protected:
     virtual void printPage( int pageNumber, QPainter &painter );
     
     int firstRow( int page ) const;
     
 private:
     DoubleTreeViewBase *m_tree;
     Project *m_project;
     int m_firstRow;
 };
 
 class KPLATOUI_EXPORT DoubleTreeViewBase : public QSplitter
 {
     Q_OBJECT
 public:
     explicit DoubleTreeViewBase( QWidget *parent );
     DoubleTreeViewBase( bool mode, QWidget *parent );
     ~DoubleTreeViewBase();
 
     void setReadWrite( bool rw );
     void closePersistentEditor( const QModelIndex &index );
 
     void setModel( QAbstractItemModel *model );
     QAbstractItemModel *model() const;
 
     void setArrowKeyNavigation( bool on ) { m_arrowKeyNavigation = on; }
     bool arrowKeyNavigation() const { return m_arrowKeyNavigation; }
 
     QItemSelectionModel *selectionModel() const { return m_selectionmodel; }
     void setSelectionModel( QItemSelectionModel *model );
     void setSelectionMode( QAbstractItemView::SelectionMode mode );
     void setSelectionBehavior( QAbstractItemView::SelectionBehavior mode );
     virtual void createItemDelegates( ItemModelBase *model );
     void setItemDelegateForColumn( int col, QAbstractItemDelegate * delegate );
     void setEditTriggers ( QAbstractItemView::EditTriggers );
     QAbstractItemView::EditTriggers editTriggers() const;
 
     void setAcceptDrops( bool );
     void setAcceptDropsOnView( bool );
     void setDropIndicatorShown( bool );
     void setDragDropMode( QAbstractItemView::DragDropMode mode );
     void setDragDropOverwriteMode( bool mode );
     void setDragEnabled ( bool mode );
     void setDefaultDropAction( Qt::DropAction action );
 
     void setStretchLastSection( bool );
     
     /// Hide columns in the @p hideList, show all other columns.
     /// If the hideList.last() == -1, the rest of the columns are hidden.
     void hideColumns( TreeViewBase *view, const QList<int> &hideList );
     void hideColumns( const QList<int> &masterList, const QList<int> &slaveList = QList<int>() );
     void hideColumn( int col ) {
         m_leftview->hideColumn( col ); 
         if ( m_rightview ) m_rightview->hideColumn( col );
     }
     void showColumn( int col ) { 
         if ( col == 0 || m_rightview == 0 ) m_leftview->showColumn( col );
         else m_rightview->showColumn( col );
     }
     bool isColumnHidden( int col ) const {
         return m_rightview ? m_rightview->isColumnHidden( col ) : m_leftview->isColumnHidden( col );
     }
 
     TreeViewBase *masterView() const { return m_leftview; }
     TreeViewBase *slaveView() const { return m_rightview; }
 
     /// Loads context info into this view. Reimplement.
     virtual bool loadContext( const QMetaEnum &map, const KoXmlElement &element );
     /// Save context info from this view. Reimplement.
     virtual void saveContext( const QMetaEnum &map, QDomElement &context ) const;
     
     void setViewSplitMode( bool split );
     bool isViewSplit() const { return m_mode; }
     QAction *actionSplitView() const { return m_actionSplitView; }
     
     void setRootIsDecorated ( bool show );
 
     KoPrintJob *createPrintJob( ViewBase *parent );
 
     void setStretchFactors();
     
     QModelIndex indexAt( const QPoint &pos ) const;
 
     void setParentsExpanded( const QModelIndex &idx, bool expanded );
 
     void setSortingEnabled( bool on ) {
         m_leftview->setSortingEnabled( on );
         m_rightview->setSortingEnabled( on );
     }
     void sortByColumn( int col, Qt::SortOrder order = Qt::AscendingOrder ) {
         if ( ! m_leftview->isColumnHidden( col ) || 
              ! m_rightview->isVisible() ||
              m_rightview->isColumnHidden( col ) )
         {
             m_leftview->sortByColumn( col, order );
         } else {
             m_rightview->sortByColumn( col, order );
         }
     }
 
     void setContextMenuIndex(const QModelIndex &idx);
 
 Q_SIGNALS:
     /// Context menu requested from the viewport, pointer over @p index at global position @p pos
     void contextMenuRequested( const QModelIndex &index, const QPoint& pos, const QModelIndexList& );
     /// Context menu requested from master- or slave header at global position @p pos
     void headerContextMenuRequested( const QPoint &pos );
     /// Context menu requested from master header at global position @p pos
     void masterHeaderContextMenuRequested( const QPoint &pos );
     /// Context menu requested from slave header at global position @p pos
     void slaveHeaderContextMenuRequested( const QPoint &pos );
 
     void currentChanged ( const QModelIndex & current, const QModelIndex & previous );
     void selectionChanged( const QModelIndexList& );
 
     void dropAllowed( const QModelIndex &index, int dropIndicatorPosition, QDragMoveEvent *event );
 
 public Q_SLOTS:
     void edit( const QModelIndex &index );
     void slotExpand();
     void slotCollapse();
 
 protected Q_SLOTS:
     void slotSelectionChanged( const QItemSelection &sel, const QItemSelection & );
     void slotToRightView( const QModelIndex &index );
     void slotToLeftView( const QModelIndex &index );
     void slotEditToRightView( const QModelIndex &index );
     void slotEditToLeftView( const QModelIndex &index );
 
     void slotRightHeaderContextMenuRequested( const QPoint &pos );
     void slotLeftHeaderContextMenuRequested( const QPoint &pos );
 
     void slotLeftSortIndicatorChanged( int logicalIndex, Qt::SortOrder order );
     void slotRightSortIndicatorChanged( int logicalIndex, Qt::SortOrder order );
 
 protected:
     void init();
     QList<int> expandColumnList( const QList<int> &lst ) const;
 
 protected:
     TreeViewBase *m_leftview;
     TreeViewBase *m_rightview;
     QItemSelectionModel *m_selectionmodel;
     bool m_arrowKeyNavigation;
     bool m_readWrite;
     bool m_mode;
     
     QAction *m_actionSplitView;
 };
 
 } // namespace KPlato
 
 #endif