project/projectmodel.cpp

   1 /* This file is part of KDevelop
   2     Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
   3     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
   4     Copyright 2007 Aleix Pol <aleixpol@gmail.com>
   5
   6     This library is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU Library General Public
   8     License as published by the Free Software Foundation; either
   9     version 2 of the License, or (at your option) any later version.
  10
  11     This library is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14     Library General Public License for more details.
  15
  16     You should have received a copy of the GNU Library General Public License
  17     along with this library; see the file COPYING.LIB.  If not, write to
  18     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19     Boston, MA 02110-1301, USA.
  20 */
  21
  22 #include "projectmodel.h"
  23
  24 #include <kmimetype.h>
  25 #include <kiconloader.h>
  26 #include <kicon.h>
  27 #include <kio/global.h>
  28
  29 #include <QApplication>
  30 #include <QPalette>
  31 #include <QBrush>
  32 #include <QColor>
  33 #include <QFileInfo>
  34 #include <kdebug.h>
  35
  36 #include <interfaces/iproject.h>
  37
  38 namespace KDevelop
  39 {
  40
  41 class ProjectBaseItemPrivate
  42 {
  43 public:
  44     ProjectBaseItemPrivate() : project(0) {}
  45     IProject* project;
  46 };
  47
  48 class ProjectFolderItemPrivate : public ProjectBaseItemPrivate
  49 {
  50 public:
  51     KUrl m_url;
  52     QString m_folderName;
  53     bool m_isProjectRoot;
  54 };
  55
  56 class ProjectBuildFolderItemPrivate : public ProjectFolderItemPrivate
  57 {
  58 public:
  59 };
  60
  61 class ProjectFileItemPrivate : public ProjectBaseItemPrivate
  62 {
  63 public:
  64     KUrl m_url;
  65     QString m_fileName;
  66 };
  67
  68 class ProjectTargetItemPrivate : public ProjectBaseItemPrivate
  69 {
  70 };
  71
  72 class WorkspaceItemPrivate
  73 {
  74 public:
  75     QString name;
  76     KSharedConfig::Ptr metadataConfig;
  77     QString metadataDir;
  78 };
  79
  80 class ProjectModelPrivate
  81 {
  82 };
  83
  84 ProjectBaseItem::ProjectBaseItem( IProject* project, const QString &name, QStandardItem *parent )
  85         : QStandardItem( name ), d_ptr(new ProjectBaseItemPrivate)
  86 {
  87     Q_D(ProjectBaseItem);
  88     d->project = project;
  89     setParent( parent );
  90     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
  91 }
  92
  93 ProjectBaseItem::ProjectBaseItem( ProjectBaseItemPrivate& dd)
  94     : d_ptr(&dd)
  95 {
  96     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
  97 }
  98
  99 ProjectBaseItem::~ProjectBaseItem()
 100 {
 101     Q_D(ProjectBaseItem);
 102     delete d;
 103 }
 104
 105 IProject* ProjectBaseItem::project() const
 106 {
 107     Q_D(const ProjectBaseItem);
 108     return d->project;
 109 }
 110
 111 void ProjectBaseItem::setParent( QStandardItem* parent )
 112 {
 113     if( parent )
 114         parent->setChild( parent->rowCount(), this );
 115 }
 116
 117 void ProjectBaseItem::setIcon()
 118 {
 119 }
 120
 121 void ProjectBaseItem::add( ProjectBaseItem* item )
 122 {
 123     appendRow( item );
 124 }
 125
 126 ProjectFolderItem *ProjectBaseItem::folder() const
 127 {
 128     return 0;
 129 }
 130
 131 ProjectTargetItem *ProjectBaseItem::target() const
 132 {
 133     return 0;
 134 }
 135
 136 ProjectExecutableTargetItem *ProjectBaseItem::executable() const
 137 {
 138     return 0;
 139 }
 140
 141 ProjectFileItem *ProjectBaseItem::file() const
 142 {
 143     return 0;
 144 }
 145
 146 QList<ProjectFolderItem*> ProjectBaseItem::folderList() const
 147 {
 148     QList<ProjectFolderItem*> lst;
 149     for ( int i = 0; i < rowCount(); ++i )
 150     {
 151         QStandardItem* item = child( i );
 152         if ( item->type() == Folder || item->type() == BuildFolder )
 153         {
 154             ProjectFolderItem *kdevitem = dynamic_cast<ProjectFolderItem*>( item );
 155             if ( kdevitem )
 156                 lst.append( kdevitem );
 157         }
 158     }
 159
 160     return lst;
 161 }
 162
 163 QList<ProjectTargetItem*> ProjectBaseItem::targetList() const
 164 {
 165     QList<ProjectTargetItem*> lst;
 166     for ( int i = 0; i < rowCount(); ++i )
 167     {
 168         QStandardItem* item = child( i );
 169         if ( item->type() == Target || item->type() == LibraryTarget ||
 170              item->type() == ExecutableTarget)
 171         {
 172             ProjectTargetItem *kdevitem = dynamic_cast<ProjectTargetItem*>( item );
 173             if ( kdevitem )
 174                 lst.append( kdevitem );
 175         }
 176     }
 177
 178     return lst;
 179 }
 180
 181 QList<ProjectFileItem*> ProjectBaseItem::fileList() const
 182 {
 183     QList<ProjectFileItem*> lst;
 184     for ( int i = 0; i < rowCount(); ++i )
 185     {
 186         QStandardItem* item = child( i );
 187         if ( item->type() == File )
 188         {
 189             ProjectFileItem *kdevitem = dynamic_cast<ProjectFileItem*>( item );
 190             if ( kdevitem )
 191                 lst.append( kdevitem );
 192         }
 193
 194     }
 195     return lst;
 196 }
 197
 198 ProjectModel::ProjectModel( QObject *parent )
 199         : QStandardItemModel( parent ), d(0)
 200 {
 201 }
 202
 203 ProjectModel::~ProjectModel()
 204 {}
 205
 206
 207 ProjectBaseItem *ProjectModel::item( const QModelIndex &index ) const
 208 {
 209     return dynamic_cast<ProjectBaseItem*>( itemFromIndex( index ) );
 210 }
 211
 212 void ProjectModel::resetModel()
 213 {
 214     reset();
 215 }
 216
 217 void ProjectModel::fetchMore( const QModelIndex &parent )
 218 {
 219     QStandardItem *parentItem = itemFromIndex( parent );
 220     if( !parentItem )
 221         return;
 222     int rowcount = parentItem->rowCount();
 223     for( int i=0; i<rowcount; i++ )
 224     {
 225         ProjectBaseItem *childItem = dynamic_cast<ProjectBaseItem*>(parentItem->child(i));
 226         if( childItem && childItem->icon().isNull() )
 227             childItem->setIcon();
 228     }
 229 }
 230
 231 bool ProjectModel::canFetchMore( const QModelIndex & parent ) const
 232 {
 233     QStandardItem *parentItem = itemFromIndex( parent );
 234     if( !parentItem )
 235         return false;
 236     return true;
 237 }
 238
 239
 240 ProjectFolderItem::ProjectFolderItem( IProject* project, const KUrl & dir, QStandardItem * parent )
 241         : ProjectBaseItem( *new ProjectFolderItemPrivate )
 242 {
 243     Q_D(ProjectFolderItem);
 244     d->project = project;
 245     d->m_url = dir;
 246     setParent(parent);
 247     setText( dir.fileName() );
 248 }
 249
 250 ProjectFolderItem::ProjectFolderItem( ProjectFolderItemPrivate& dd)
 251     : ProjectBaseItem( dd )
 252 {
 253 }
 254
 255 ProjectFolderItem::~ProjectFolderItem()
 256 {
 257 }
 258
 259 ProjectFolderItem *ProjectFolderItem::folder() const
 260 {
 261     return const_cast<ProjectFolderItem*>(this);
 262 }
 263
 264 int ProjectFolderItem::type() const
 265 {
 266     return ProjectBaseItem::Folder;
 267 }
 268
 269 const KUrl& ProjectFolderItem::url( ) const
 270 {
 271     Q_D(const ProjectFolderItem);
 272     return d->m_url;
 273 }
 274
 275 const QString& ProjectFolderItem::folderName() const
 276 {
 277     Q_D(const ProjectFolderItem);
 278     return d->m_folderName;
 279 }
 280
 281 void ProjectFolderItem::setUrl( const KUrl& url )
 282 {
 283     Q_D(ProjectFolderItem);
 284     d->m_url = url;
 285     d->m_folderName = d->m_url.fileName();
 286     setText( d->m_folderName );
 287 }
 288
 289 void ProjectFolderItem::setIcon()
 290 {
 291     QStandardItem::setIcon( KIO::pixmapForUrl( url(), 0, KIconLoader::Small ) );
 292 }
 293
 294 bool ProjectFolderItem::hasFileOrFolder(const QString& name) const
 295 {
 296     for ( int i = 0; i < rowCount(); ++i )
 297     {
 298         QStandardItem* item = child( i );
 299         if ( ProjectFileItem* file = dynamic_cast<ProjectFileItem*>(item))
 300             if (file->fileName() == name)
 301                 return true;
 302
 303         if ( ProjectFolderItem* folder = dynamic_cast<ProjectFolderItem*>(item))
 304             if (folder->folderName() == name)
 305                 return true;
 306     }
 307     return false;
 308 }
 309
 310 ProjectBuildFolderItem::ProjectBuildFolderItem( ProjectBuildFolderItemPrivate& dd )
 311     : ProjectFolderItem( dd )
 312 {
 313 }
 314
 315 ProjectBuildFolderItem::ProjectBuildFolderItem( IProject* project, const KUrl &dir, QStandardItem *parent)
 316     : ProjectFolderItem( *new ProjectBuildFolderItemPrivate )
 317 {
 318     Q_D(ProjectBuildFolderItem);
 319     d->project = project;
 320     setUrl( dir );
 321     setParent( parent );
 322 }
 323
 324 int ProjectBuildFolderItem::type() const
 325 {
 326     return ProjectBaseItem::BuildFolder;
 327 }
 328
 329 void ProjectBuildFolderItem::setIcon()
 330 {
 331     QStandardItem::setIcon( KIcon("folder-development") );
 332 }
 333
 334 void ProjectFolderItem::setProjectRoot(bool isRoot)
 335 {
 336         Q_D(ProjectFolderItem);
 337         d->m_isProjectRoot=isRoot;
 338         setText(project()->name());
 339 }
 340
 341 bool ProjectFolderItem::isProjectRoot() const
 342 {
 343         Q_D(const ProjectFolderItem);
 344         return d->m_isProjectRoot;
 345 }
 346
 347 ProjectFileItem::ProjectFileItem( ProjectFileItemPrivate& dd)
 348     : ProjectBaseItem(dd)
 349 {
 350     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
 351 }
 352
 353 ProjectFileItem::ProjectFileItem( IProject* project, const KUrl & file, QStandardItem * parent )
 354         : ProjectBaseItem( *new ProjectFileItemPrivate )
 355 {
 356     Q_D(ProjectFileItem);
 357     d->project = project;
 358     d->m_url = file;
 359     setText( file.fileName() );
 360     setParent( parent );
 361     setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable );
 362 }
 363
 364 const KUrl & ProjectFileItem::url( ) const
 365 {
 366     Q_D(const ProjectFileItem);
 367     return d->m_url;
 368 }
 369
 370 const QString& ProjectFileItem::fileName() const
 371 {
 372     Q_D(const ProjectFileItem);
 373     return d->m_fileName;
 374 }
 375
 376 void ProjectFileItem::setUrl( const KUrl& url )
 377 {
 378     Q_D(ProjectFileItem);
 379     d->m_url = url;
 380     d->m_fileName = d->m_url.fileName();
 381 }
 382
 383 int ProjectFileItem::type() const
 384 {
 385     return ProjectBaseItem::File;
 386 }
 387
 388 ProjectFileItem *ProjectFileItem::file() const
 389 {
 390     return const_cast<ProjectFileItem*>( this );
 391 }
 392
 393 void ProjectFileItem::setIcon()
 394 {
 395     QStandardItem::setIcon( KIO::pixmapForUrl( url(), 0, KIconLoader::Small ) );
 396 }
 397
 398 ProjectTargetItem::ProjectTargetItem( ProjectTargetItemPrivate& dd)
 399     : ProjectBaseItem( dd )
 400 {
 401 }
 402
 403 ProjectTargetItem::ProjectTargetItem( IProject* project, const QString &name, QStandardItem *parent )
 404                 : ProjectBaseItem( *new ProjectTargetItemPrivate )
 405 {
 406     Q_D(ProjectTargetItem);
 407     d->project = project;
 408     setText( name );
 409     setParent( parent );
 410 }
 411
 412 int ProjectTargetItem::type() const
 413 {
 414     return ProjectBaseItem::Target;
 415 }
 416
 417 ProjectTargetItem *ProjectTargetItem::target() const
 418 {
 419     return const_cast<ProjectTargetItem*>( this );
 420 }
 421
 422 void ProjectTargetItem::setIcon()
 423 {
 424     QStandardItem::setIcon( KIcon("system-run") );
 425 }
 426
 427 ProjectExecutableTargetItem::ProjectExecutableTargetItem( IProject* project, const QString &name, QStandardItem *parent )
 428     : ProjectTargetItem(project, name, parent)
 429 {}
 430
 431 ProjectExecutableTargetItem *ProjectExecutableTargetItem::executable() const
 432 {
 433     return const_cast<ProjectExecutableTargetItem*>( this );
 434 }
 435
 436 int ProjectExecutableTargetItem::type() const
 437 {
 438     return ProjectBaseItem::ExecutableTarget;
 439 }
 440
 441 ProjectLibraryTargetItem::ProjectLibraryTargetItem( IProject* project, const QString &name, QStandardItem *parent )
 442     : ProjectTargetItem(project, name, parent)
 443 {}
 444
 445 int ProjectLibraryTargetItem::type() const
 446 {
 447     return ProjectBaseItem::LibraryTarget;
 448 }
 449
 450
 451 }
 452 #include "projectmodel.moc"