diff --git a/project/projectmodel.cpp b/project/projectmodel.cpp
index 9f9d3a4345..4c3d54aa42 100644
--- a/project/projectmodel.cpp
+++ b/project/projectmodel.cpp
@@ -1,496 +1,474 @@
 /* This file is part of KDevelop
     Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2007 Aleix Pol <aleixpol@gmail.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 "projectmodel.h"
 
 #include <kmimetype.h>
 #include <kiconloader.h>
 #include <kicon.h>
 #include <kio/global.h>
 
 #include <QApplication>
 #include <QPalette>
 #include <QBrush>
 #include <QColor>
 #include <QFileInfo>
 #include <kdebug.h>
 
 #include <interfaces/iproject.h>
 
 namespace KDevelop
 {
 
 class ProjectBaseItemPrivate
 {
 public:
     ProjectBaseItemPrivate() : project(0) {}
     IProject* project;
 };
 
 class ProjectFolderItemPrivate : public ProjectBaseItemPrivate
 {
 public:
     KUrl m_url;
     QString m_folderName;
     bool m_isProjectRoot;
 };
 
 class ProjectBuildFolderItemPrivate : public ProjectFolderItemPrivate
 {
 public:
 };
 
 class ProjectFileItemPrivate : public ProjectBaseItemPrivate
 {
 public:
     KUrl m_url;
     QString m_fileName;
 };
 
 class ProjectTargetItemPrivate : public ProjectBaseItemPrivate
 {
 };
 
 class WorkspaceItemPrivate
 {
 public:
     QString name;
     KSharedConfig::Ptr metadataConfig;
     QString metadataDir;
 };
 
 class ProjectModelPrivate
 {
 };
 
 ProjectBaseItem::ProjectBaseItem( IProject* project, const QString &name, QStandardItem *parent )
         : QStandardItem( name ), d_ptr(new ProjectBaseItemPrivate)
 {
     Q_D(ProjectBaseItem);
     d->project = project;
     setParent( parent );
     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
 }
 
 ProjectBaseItem::ProjectBaseItem( ProjectBaseItemPrivate& dd)
     : d_ptr(&dd)
 {
     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
 }
 
 ProjectBaseItem::~ProjectBaseItem()
 {
     Q_D(ProjectBaseItem);
     delete d;
 }
 
 IProject* ProjectBaseItem::project() const
 {
     Q_D(const ProjectBaseItem);
     return d->project;
 }
 
 void ProjectBaseItem::setParent( QStandardItem* parent )
 {
     if( parent )
         parent->setChild( parent->rowCount(), this );
 }
 
 void ProjectBaseItem::setIcon()
 {
 }
 
 void ProjectBaseItem::add( ProjectBaseItem* item )
 {
     appendRow( item );
 }
 
 ProjectFolderItem *ProjectBaseItem::folder() const
 {
     return 0;
 }
 
 ProjectTargetItem *ProjectBaseItem::target() const
 {
     return 0;
 }
 
 ProjectExecutableTargetItem *ProjectBaseItem::executable() const
 {
     return 0;
 }
 
 ProjectFileItem *ProjectBaseItem::file() const
 {
     return 0;
 }
 
 QList<ProjectFolderItem*> ProjectBaseItem::folderList() const
 {
     QList<ProjectFolderItem*> lst;
     for ( int i = 0; i < rowCount(); ++i )
     {
         QStandardItem* item = child( i );
         if ( item->type() == Folder || item->type() == BuildFolder )
         {
             ProjectFolderItem *kdevitem = dynamic_cast<ProjectFolderItem*>( item );
             if ( kdevitem )
                 lst.append( kdevitem );
         }
     }
 
     return lst;
 }
 
 QList<ProjectTargetItem*> ProjectBaseItem::targetList() const
 {
     QList<ProjectTargetItem*> lst;
     for ( int i = 0; i < rowCount(); ++i )
     {
         QStandardItem* item = child( i );
         if ( item->type() == Target || item->type() == LibraryTarget ||
              item->type() == ExecutableTarget)
         {
             ProjectTargetItem *kdevitem = dynamic_cast<ProjectTargetItem*>( item );
             if ( kdevitem )
                 lst.append( kdevitem );
         }
     }
 
     return lst;
 }
 
 QList<ProjectFileItem*> ProjectBaseItem::fileList() const
 {
     QList<ProjectFileItem*> lst;
     for ( int i = 0; i < rowCount(); ++i )
     {
         QStandardItem* item = child( i );
         if ( item->type() == File )
         {
             ProjectFileItem *kdevitem = dynamic_cast<ProjectFileItem*>( item );
             if ( kdevitem )
                 lst.append( kdevitem );
         }
 
     }
     return lst;
 }
 
-QList< KDevelop::ProjectFileItem* > ProjectBaseItem::allFiles() const
-{
-    QList<ProjectFileItem*> lst;
-    for ( int i = 0; i < rowCount(); ++i )
-    {
-        QStandardItem* item = child( i );
-        if ( item->type() == File )
-        {
-            ProjectFileItem *kdevitem = dynamic_cast<ProjectFileItem*>( item );
-            if ( kdevitem )
-                lst.append( kdevitem );
-        }
-        else if ( item->type() == Folder )
-        {
-            ProjectBaseItem *kdevitem = dynamic_cast<ProjectBaseItem*>( item );
-            if ( kdevitem )
-                lst += kdevitem->allFiles();
-        }
-    }
-    return lst;
-}
-
 ProjectModel::ProjectModel( QObject *parent )
         : QStandardItemModel( parent ), d(0)
 {
 }
 
 ProjectModel::~ProjectModel()
 {}
 
 
 ProjectBaseItem *ProjectModel::item( const QModelIndex &index ) const
 {
     return dynamic_cast<ProjectBaseItem*>( itemFromIndex( index ) );
 }
 
 void ProjectModel::resetModel()
 {
     reset();
 }
 
 void ProjectModel::fetchMore( const QModelIndex &parent )
 {
     QStandardItem *parentItem = itemFromIndex( parent );
     if( !parentItem )
         return;
     int rowcount = parentItem->rowCount();
     for( int i=0; i<rowcount; i++ )
     {
         ProjectBaseItem *childItem = dynamic_cast<ProjectBaseItem*>(parentItem->child(i));
         if( childItem && childItem->icon().isNull() )
             childItem->setIcon();
     }
 }
 
 bool ProjectModel::canFetchMore( const QModelIndex & parent ) const
 {
     QStandardItem *parentItem = itemFromIndex( parent );
     if( !parentItem )
         return false;
     return true;
 }
 
 
 ProjectFolderItem::ProjectFolderItem( IProject* project, const KUrl & dir, QStandardItem * parent )
         : ProjectBaseItem( *new ProjectFolderItemPrivate )
 {
     Q_D(ProjectFolderItem);
     d->project = project;
     d->m_url = dir;
     setParent(parent);
     setText( dir.fileName() );
 }
 
 ProjectFolderItem::ProjectFolderItem( ProjectFolderItemPrivate& dd)
     : ProjectBaseItem( dd )
 {
 }
 
 ProjectFolderItem::~ProjectFolderItem()
 {
 }
 
 ProjectFolderItem *ProjectFolderItem::folder() const
 {
     return const_cast<ProjectFolderItem*>(this);
 }
 
 int ProjectFolderItem::type() const
 {
     return ProjectBaseItem::Folder;
 }
 
 const KUrl& ProjectFolderItem::url( ) const
 {
     Q_D(const ProjectFolderItem);
     return d->m_url;
 }
 
 const QString& ProjectFolderItem::folderName() const
 {
     Q_D(const ProjectFolderItem);
     return d->m_folderName;
 }
 
 void ProjectFolderItem::setUrl( const KUrl& url )
 {
     Q_D(ProjectFolderItem);
     d->m_url = url;
     d->m_folderName = d->m_url.fileName();
     setText( d->m_folderName );
 }
 
 void ProjectFolderItem::setIcon()
 {
     QStandardItem::setIcon( KIO::pixmapForUrl( url(), 0, KIconLoader::Small ) );
 }
 
 bool ProjectFolderItem::hasFileOrFolder(const QString& name) const
 {
     for ( int i = 0; i < rowCount(); ++i )
     {
         QStandardItem* item = child( i );
         if ( ProjectFileItem* file = dynamic_cast<ProjectFileItem*>(item))
             if (file->fileName() == name)
                 return true;
 
         if ( ProjectFolderItem* folder = dynamic_cast<ProjectFolderItem*>(item))
             if (folder->folderName() == name)
                 return true;
     }
     return false;
 }
 
 ProjectBuildFolderItem::ProjectBuildFolderItem( ProjectBuildFolderItemPrivate& dd )
     : ProjectFolderItem( dd )
 {
 }
 
 ProjectBuildFolderItem::ProjectBuildFolderItem( IProject* project, const KUrl &dir, QStandardItem *parent)
     : ProjectFolderItem( *new ProjectBuildFolderItemPrivate )
 {
     Q_D(ProjectBuildFolderItem);
     d->project = project;
     setUrl( dir );
     setParent( parent );
 }
 
 int ProjectBuildFolderItem::type() const
 {
     return ProjectBaseItem::BuildFolder;
 }
 
 void ProjectBuildFolderItem::setIcon()
 {
     QStandardItem::setIcon( KIcon("folder-development") );
 }
 
 void ProjectFolderItem::setProjectRoot(bool isRoot)
 {
 	Q_D(ProjectFolderItem);
 	d->m_isProjectRoot=isRoot;
 	setText(project()->name());
 }
 
 bool ProjectFolderItem::isProjectRoot() const
 {
 	Q_D(const ProjectFolderItem);
 	return d->m_isProjectRoot;
 }
 
 ProjectFileItem::ProjectFileItem( ProjectFileItemPrivate& dd)
     : ProjectBaseItem(dd)
 {
     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
 }
 
 ProjectFileItem::ProjectFileItem( IProject* project, const KUrl & file, QStandardItem * parent )
         : ProjectBaseItem( *new ProjectFileItemPrivate )
 {
     Q_D(ProjectFileItem);
     d->project = project;
     d->m_url = file;
     setText( file.fileName() );
     setParent( parent );
     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
 }
 
 const KUrl & ProjectFileItem::url( ) const
 {
     Q_D(const ProjectFileItem);
     return d->m_url;
 }
 
 const QString& ProjectFileItem::fileName() const
 {
     Q_D(const ProjectFileItem);
     return d->m_fileName;
 }
 
 void ProjectFileItem::setUrl( const KUrl& url )
 {
     Q_D(ProjectFileItem);
     d->m_url = url;
     d->m_fileName = d->m_url.fileName();
 }
 
 int ProjectFileItem::type() const
 {
     return ProjectBaseItem::File;
 }
 
 ProjectFileItem *ProjectFileItem::file() const
 {
     return const_cast<ProjectFileItem*>( this );
 }
 
 void ProjectFileItem::setIcon()
 {
     QStandardItem::setIcon( KIO::pixmapForUrl( url(), 0, KIconLoader::Small ) );
 }
 
 ProjectTargetItem::ProjectTargetItem( ProjectTargetItemPrivate& dd)
     : ProjectBaseItem( dd )
 {
 }
 
 ProjectTargetItem::ProjectTargetItem( IProject* project, const QString &name, QStandardItem *parent )
                 : ProjectBaseItem( *new ProjectTargetItemPrivate )
 {
     Q_D(ProjectTargetItem);
     d->project = project;
     setText( name );
     setParent( parent );
 }
 
 int ProjectTargetItem::type() const
 {
     return ProjectBaseItem::Target;
 }
 
 ProjectTargetItem *ProjectTargetItem::target() const
 {
     return const_cast<ProjectTargetItem*>( this );
 }
 
 void ProjectTargetItem::setIcon()
 {
     QStandardItem::setIcon( KIcon("system-run") );
 }
 
 ProjectExecutableTargetItem::ProjectExecutableTargetItem( IProject* project, const QString &name, QStandardItem *parent )
     : ProjectTargetItem(project, name, parent)
 {}
 
 ProjectExecutableTargetItem *ProjectExecutableTargetItem::executable() const
 {
     return const_cast<ProjectExecutableTargetItem*>( this );
 }
 
 int ProjectExecutableTargetItem::type() const
 {
     return ProjectBaseItem::ExecutableTarget;
 }
 
 ProjectLibraryTargetItem::ProjectLibraryTargetItem( IProject* project, const QString &name, QStandardItem *parent )
     : ProjectTargetItem(project, name, parent)
 {}
 
 int ProjectLibraryTargetItem::type() const
 {
     return ProjectBaseItem::LibraryTarget;
 }
 
 QModelIndex ProjectModel::pathToIndex(const QAbstractItemModel* model, const QStringList& tofetch)
 {
     if(tofetch.isEmpty())
         return QModelIndex();
 
     QModelIndex current=model->index(0,0, QModelIndex());
 
     QModelIndex ret;
     foreach(const QString& currentName, tofetch)
     {
         QModelIndexList l = model->match(current, Qt::EditRole, currentName, 1, Qt::MatchExactly);
         if(l.count()>0) {
             ret=l.first();
             current = model->index(0,0, ret);
         } else
             current = QModelIndex();
     }
     
     Q_ASSERT(model->data(ret).toString()==tofetch.last() || !ret.isValid());
     return ret;
 }
 
 
 }
 #include "projectmodel.moc"
diff --git a/project/projectmodel.h b/project/projectmodel.h
index f3f277aa90..3665c486f0 100644
--- a/project/projectmodel.h
+++ b/project/projectmodel.h
@@ -1,290 +1,287 @@
 /* This file is part of KDevelop
     Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2007 Aleix Pol <aleixpol@gmail.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 KDEVPROJECTMODEL_H
 #define KDEVPROJECTMODEL_H
 
 #include <QtGui/QStandardItem>
 #include <QtGui/QStandardItemModel>
 #include "projectexport.h"
 #include <KDE/KUrl>
 #include <KDE/KSharedConfig>
 
 template<typename T1,typename T2> class QPair;
 template<typename T> class QList;
 
 namespace KDevelop
 {
 
 class IProject;
 class ProjectFolderItem;
 class ProjectBuildFolderItem;
 class ProjectFileItem;
 class ProjectTargetItem;
 class ProjectExecutableTargetItem;
 class ProjectLibraryTargetItem;
 
 /**
  * Interface that allows a developer to implement the three basic types of
  * items you would see in a multi-project
  * \li Folder
  * \li Project
  * \li Custom Target
  * \li Library Target
  * \li Executable Target
  * \li File
  */
 class KDEVPLATFORMPROJECT_EXPORT ProjectBaseItem: public QStandardItem
 {
     public:
         ProjectBaseItem( IProject*, const QString &name, QStandardItem *parent = 0 );
         virtual ~ProjectBaseItem();
 
         /**
          * add the item @p item to the list of children for this item
          * do not use this function if you gave the item a parent when you
          * created it
          */
         void add( ProjectBaseItem* item );
 
         enum ProjectItemType
         {
             BuildFolder = QStandardItem::UserType         /** item is a buildable folder */,
             Folder = QStandardItem::UserType+1            /** item is a folder */,
             ExecutableTarget = QStandardItem::UserType+2  /** item is an executable target */,
             LibraryTarget = QStandardItem::UserType+3     /** item is a library target */,
             Target = QStandardItem::UserType+5            /** item is a target */,
             File = QStandardItem::UserType+6              /** item is a file */
         };
 
         /** @returns Returns the project that the item belongs to.  */
         IProject* project() const;
 
         /** @returns If this item is a folder, it returns a pointer to the folder, otherwise returns a 0 pointer. */
         virtual ProjectFolderItem *folder() const;
 
         /** @returns If this item is a target, it returns a pointer to the target, otherwise returns a 0 pointer. */
         virtual ProjectTargetItem *target() const;
 
         /** @returns If this item is a file, it returns a pointer to the file, otherwise returns a 0 pointer. */
         virtual ProjectFileItem *file() const;
         
         /** @returns If this item is a file, it returns a pointer to the file, otherwise returns a 0 pointer. */
         virtual ProjectExecutableTargetItem *executable() const;
 
         /**  @param parent sets the item parent to @p parent */
         void setParent( QStandardItem* parent);
         virtual void setIcon();
 
         /** @returns Returns a list of the folders that have this object as the parent. */
         QList<ProjectFolderItem*> folderList() const;
 
         /** @returns Returns a list of the targets that have this object as the parent. */
         QList<ProjectTargetItem*> targetList() const;
 
         /** @returns Returns a list of the files that have this object as the parent. */
         QList<ProjectFileItem*> fileList() const;
 
-        /** @returns Returns a list of all files that have this object as a parent, whether directly or indirectly. */
-        QList<ProjectFileItem*> allFiles() const;
-
     protected:
         class ProjectBaseItemPrivate* const d_ptr;
         ProjectBaseItem( ProjectBaseItemPrivate& dd );
     private:
         Q_DECLARE_PRIVATE(ProjectBaseItem)
 };
 
 /**
  * Implementation of the ProjectBaseItem interface that is specific to a
  * folder
  */
 class ProjectFolderItemPrivate;
 class KDEVPLATFORMPROJECT_EXPORT ProjectFolderItem: public ProjectBaseItem
 {
 public:
     ProjectFolderItem( IProject*, const KUrl &dir, QStandardItem *parent = 0 );
 
     virtual ~ProjectFolderItem();
 
     virtual ProjectFolderItem *folder() const;
 
     ///Reimplemented from QStandardItem
     virtual int type() const;
 
     /** Get the url of this folder */
     const KUrl& url() const;
 
     /** Get the folder name, equal to url().fileName() but faster (precomputed) */
     const QString& folderName() const;
 
     /** Set the url of this folder */
     void setUrl( const KUrl& );
 
     virtual void setIcon();
 
     /** Returns whether it is the project root folder */
     bool isProjectRoot() const;
 
     /** Sets whether it is the project root folder and sets the project name to the item */
     void setProjectRoot(bool isRoot);
 
     /** @returns Returns whether this folder directly contains the specified file or folder. */
     bool hasFileOrFolder(const QString& name) const;
 
 protected:
     ProjectFolderItem( ProjectFolderItemPrivate& );
 private:
     Q_DECLARE_PRIVATE(ProjectFolderItem)
 };
 
 
 /**
  * Folder which contains buildable targets as part of a buildable project
  */
 class ProjectBuildFolderItemPrivate;
 class KDEVPLATFORMPROJECT_EXPORT ProjectBuildFolderItem: public ProjectFolderItem
 {
 public:
     ProjectBuildFolderItem( IProject*, const KUrl &dir, QStandardItem *parent = 0 );
 
     ///Reimplemented from QStandardItem
     virtual int type() const;
 
     virtual void setIcon();
 
 protected:
     ProjectBuildFolderItem( ProjectBuildFolderItemPrivate& );
 private:
     Q_DECLARE_PRIVATE(ProjectBuildFolderItem)
 };
 
 /**
  * Object which represents a target in a build system.
  *
  * This object contains all properties specific to a target.
  */
 class ProjectTargetItemPrivate;
 class KDEVPLATFORMPROJECT_EXPORT ProjectTargetItem: public ProjectBaseItem
 {
 public:
     ProjectTargetItem( IProject*, const QString &name, QStandardItem *parent = 0 );
 
     ///Reimplemented from QStandardItem
     virtual int type() const;
 
     virtual ProjectTargetItem *target() const;
     virtual void setIcon();
 protected:
     ProjectTargetItem( ProjectTargetItemPrivate& );
 private:
     Q_DECLARE_PRIVATE(ProjectTargetItem)
 };
 
 /**
  * Object which represents an executable target in a build system.
  *
  * This object contains all properties specific to an executable.
  */
 class KDEVPLATFORMPROJECT_EXPORT ProjectExecutableTargetItem: public ProjectTargetItem
 {
     public:
         ProjectExecutableTargetItem( IProject*, const QString &name, QStandardItem *parent = 0 );
 
         virtual ProjectExecutableTargetItem *executable() const;
         virtual int type() const;
         virtual KUrl builtUrl() const=0;
         virtual KUrl installedUrl() const=0;
 };
 
 
 /**
  * Object which represents a library target in a build system.
  *
  * This object contains all properties specific to a library.
  */
 class KDEVPLATFORMPROJECT_EXPORT ProjectLibraryTargetItem: public ProjectTargetItem
 {
     public:
         ProjectLibraryTargetItem(IProject* project, const QString &name, QStandardItem *parent = 0 );
 
         virtual int type() const;
 };
 
 /**
  * Object which represents a file.
  */
 class ProjectFileItemPrivate;
 class KDEVPLATFORMPROJECT_EXPORT ProjectFileItem: public ProjectBaseItem
 {
 public:
     ProjectFileItem( IProject*, const KUrl& file, QStandardItem *parent = 0 );
 
     ///Reimplemented from QStandardItem
     virtual int type() const;
 
     virtual ProjectFileItem *file() const;
 
     /** Get the url of this file. */
     const KUrl& url() const;
 
     /** Get the file name, equal to url().fileName() but faster (precomputed) */
     const QString& fileName() const;
 
     /** Set the url of this file. */
     void setUrl( const KUrl& );
 
     virtual void setIcon();
 
 protected:
     ProjectFileItem( ProjectFileItemPrivate& );
 private:
     Q_DECLARE_PRIVATE(ProjectFileItem)
 };
 
 /**
  * Class providing some convenience methods for accessing the project model
  * @todo: maybe switch to QAbstractItemModel, would make the implementation
  *        for at least the checkbox-behaviour easier
  */
 class KDEVPLATFORMPROJECT_EXPORT ProjectModel: public QStandardItemModel
 {
     Q_OBJECT
 public:
     ProjectModel( QObject *parent = 0 );
     virtual ~ProjectModel();
 
     using QStandardItemModel::item;
     ProjectBaseItem *item( const QModelIndex &index ) const;
 
     void resetModel();
 
     virtual void fetchMore( const QModelIndex &parent );
     virtual bool canFetchMore( const QModelIndex & parent ) const;
     
     static QModelIndex pathToIndex(const QAbstractItemModel* model, const QStringList& tofetch);
 private:
     class ProjectModelPrivate* const d;
 };
 
 }
 
 #endif // KDEVPROJECTMODEL_H