shell/projectcontroller.cpp

   1 /* This file is part of KDevelop
   2 Copyright 2006 Adam Treat <treat@kde.org>
   3 Copyright 2007 Anreas Pakulat <apaku@gmx.de>
   4
   5 This library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Library General Public
   7 License as published by the Free Software Foundation; either
   8 version 2 of the License, or (at your option) any later version.
   9
  10 This library is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public License
  16 along with this library; see the file COPYING.LIB.  If not, write to
  17 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18 Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include "projectcontroller.h"
  22
  23 #include <QtCore/QDir>
  24 #include <QtCore/QSignalMapper>
  25 #include <QtGui/QAction>
  26 #include <QSet>
  27 #include <QList>
  28 #include <QMap>
  29 #include <QItemSelectionModel>
  30
  31 #include <kaction.h>
  32 #include <kconfig.h>
  33 #include <klocale.h>
  34 #include <kservice.h>
  35 #include <kstandardaction.h>
  36 #include <kmessagebox.h>
  37 #include <kxmlguiwindow.h>
  38 #include <kfiledialog.h>
  39 #include <kactioncollection.h>
  40 #include <kservicetypetrader.h>
  41 #include <krecentfilesaction.h>
  42 #include <kactionmenu.h>
  43 #include <ksettings/dialog.h>
  44 #include <kstandarddirs.h>
  45
  46 #include "sublime/area.h"
  47 #include <interfaces/iplugin.h>
  48 #include <project/interfaces/iprojectfilemanager.h>
  49 #include <project/projectmodel.h>
  50 #include <interfaces/ilanguagecontroller.h>
  51 #include <language/backgroundparser/backgroundparser.h>
  52
  53 #include "core.h"
  54 #include "project.h"
  55 #include "mainwindow.h"
  56 #include "shellextension.h"
  57 #include "plugincontroller.h"
  58 #include "uicontroller.h"
  59 #include "documentcontroller.h"
  60
  61 namespace KDevelop
  62 {
  63
  64 class ProjectControllerPrivate
  65 {
  66 public:
  67     QList<IProject*> m_projects;
  68     QMap< IProject*, QList<IPlugin*> > m_projectPlugins;
  69     QMap< IProject*, QPointer<QAction> > m_configActions;
  70     QPointer<KRecentFilesAction> m_recentAction;
  71     KActionMenu *m_projectConfigAction;
  72     QSignalMapper *m_signalMapper;
  73     Core* m_core;
  74 //     IProject* m_currentProject;
  75     ProjectModel* model;
  76     QItemSelectionModel* selectionModel;
  77     QMap<IProject*, QPointer<KSettings::Dialog> > m_cfgDlgs;
  78     QPointer<QAction> m_closeAllProjects;
  79     IProjectDialogProvider* dialog;
  80     QList<KUrl> m_currentlyOpening; // project-file urls that are being opened
  81
  82     bool reopenProjectsOnStartup;
  83     bool parseAllProjectSources;
  84
  85     void unloadAllProjectPlugins()
  86     {
  87         if( m_projects.isEmpty() )
  88             m_core->pluginController()->unloadPlugins( IPluginController::Project );
  89     }
  90
  91     void projectConfig( QObject * obj )
  92     {
  93         if( !obj )
  94             return;
  95         Project* proj = qobject_cast<Project*>(obj);
  96         if( !proj )
  97             return;
  98         if( !m_cfgDlgs.contains( proj ) )
  99         {
 100             //@FIXME: compute a blacklist, based on a query for all KDevelop
 101             //plugins implementing IProjectManager, removing from that the
 102             //plugin that manages this project. Set this as blacklist on the
 103             //dialog
 104             //@FIXME: Currently its important to set a parentApp on the kcm's
 105             //thats different from the component name of the application, else
 106             //the plugin will show up on all projects settings dialogs.
 107
 108             QStringList pluginsForPrj = findPluginsForProject( proj );
 109             kDebug() << "Using pluginlist:" << pluginsForPrj;
 110             pluginsForPrj << "kdevplatformproject"; // for project-wide env settings.
 111             m_cfgDlgs[proj] = new KSettings::Dialog( pluginsForPrj,
 112                                                      m_core->uiController()->activeMainWindow() );
 113             m_cfgDlgs[proj]->setKCMArguments( QStringList()
 114                                               << proj->developerTempFile()
 115                                               << proj->projectTempFile()
 116                                               << proj->projectFileUrl().url()
 117                                               << proj->developerFileUrl().url() );
 118         }
 119         m_cfgDlgs[proj]->show();
 120     }
 121     QStringList findPluginsForProject( IProject* project )
 122     {
 123         QList<IPlugin*> plugins = m_core->pluginController()->loadedPlugins();
 124         QStringList pluginnames;
 125         kDebug() << "managerplugin:" << project->managerPlugin();
 126         for( QList<IPlugin*>::iterator it = plugins.begin(); it != plugins.end(); it++ )
 127         {
 128             IPlugin* plugin = *it;
 129             IProjectFileManager* iface = plugin->extension<KDevelop::IProjectFileManager>();
 130             kDebug() << "Checking plugin:" << plugin << "with iface" << iface;
 131             if( !iface || plugin == project->managerPlugin() )
 132                 pluginnames << m_core->pluginController()->pluginInfo( plugin ).pluginName();
 133         }
 134
 135         return pluginnames;
 136     }
 137 };
 138
 139 IProjectDialogProvider::IProjectDialogProvider()
 140 {}
 141
 142 IProjectDialogProvider::~IProjectDialogProvider()
 143 {}
 144
 145 ProjectDialogProvider::ProjectDialogProvider(ProjectControllerPrivate* const p) : d(p)
 146 {}
 147
 148 ProjectDialogProvider::~ProjectDialogProvider()
 149 {}
 150
 151 KUrl ProjectDialogProvider::askProjectConfigLocation()
 152 {
 153     Q_ASSERT(d);
 154     KSharedConfig * config = KGlobal::config().data();
 155     KConfigGroup group = config->group( "General Options" );
 156     QString dir = group.readEntry( "DefaultProjectsDirectory",
 157                                      QDir::homePath() );
 158
 159     QString projectFileInfo = ShellExtension::getInstance()->projectFileExtension()
 160         + "|" + ShellExtension::getInstance()->projectFileDescription()
 161         + "\n";
 162     KUrl response = KFileDialog::getOpenUrl( dir, projectFileInfo,
 163         d->m_core->uiControllerInternal()->defaultMainWindow(),
 164         i18n( "Open Project" ) );
 165     return response;
 166     }
 167
 168 bool ProjectDialogProvider::userWantsReopen()
 169 {
 170     Q_ASSERT(d);
 171     return (KMessageBox::questionYesNo( d->m_core->uiControllerInternal()->defaultMainWindow(),
 172                             i18n( "Reopen the current project?" ) )
 173                 == KMessageBox::No) ? false : true;
 174 }
 175
 176 void ProjectController::setDialogProvider(IProjectDialogProvider* dialog)
 177 {
 178     Q_ASSERT(d->dialog);
 179     delete d->dialog;
 180     d->dialog = dialog;
 181 }
 182
 183 ProjectController::ProjectController( Core* core )
 184         : IProjectController( core ), d( new ProjectControllerPrivate )
 185 {
 186     d->reopenProjectsOnStartup = false;
 187     d->parseAllProjectSources = false;
 188     d->m_core = core;
 189     d->m_signalMapper = new QSignalMapper( this );
 190     connect( d->m_signalMapper, SIGNAL( mapped( QObject* ) ),
 191             this, SLOT( projectConfig( QObject* ) ) );
 192 //     d->m_currentProject = 0;
 193     d->model = new ProjectModel();
 194     d->selectionModel = new QItemSelectionModel(d->model);
 195     if(!(Core::self()->setupFlags() & Core::NoUi)) setupActions();
 196
 197     loadSettings(false);
 198     d->dialog = new ProjectDialogProvider(d);
 199 }
 200
 201 void ProjectController::setupActions()
 202 {
 203     KActionCollection * ac =
 204         d->m_core->uiControllerInternal()->defaultMainWindow()->actionCollection();
 205
 206     QAction *action;
 207
 208     action = ac->addAction( "project_open" );
 209     action->setText(i18n( "&Open Project..." ) );
 210     connect( action, SIGNAL( triggered( bool ) ), SLOT( openProject() ) );
 211     action->setToolTip( i18n( "Open project" ) );
 212     action->setWhatsThis( i18n( "<b>Open project</b><p>Opens a KDevelop 4 project.</p>" ) );
 213     action->setIcon(KIcon("project-open"));
 214
 215 //    action = ac->addAction( "project_close" );
 216 //    action->setText( i18n( "C&lose Project" ) );
 217 //    connect( action, SIGNAL( triggered( bool ) ), SLOT( closeProject() ) );
 218 //    action->setToolTip( i18n( "Close project" ) );
 219 //    action->setWhatsThis( i18n( "<b>Close project</b><p>Closes the current project." ) );
 220 //    action->setEnabled( false );
 221
 222     d->m_closeAllProjects = action = ac->addAction( "project_close_all" );
 223     action->setText( i18n( "Close All Projects" ) );
 224     connect( action, SIGNAL( triggered( bool ) ), SLOT( closeAllProjects() ) );
 225     action->setToolTip( i18n( "Close all currently open projects" ) );
 226     action->setWhatsThis( i18n( "<b>Close all projects</b><p>Closes all of the currently open projects." ) );
 227     action->setEnabled( false );
 228     action->setIcon(KIcon("window-close"));
 229
 230     KSharedConfig * config = KGlobal::config().data();
 231 //     KConfigGroup group = config->group( "General Options" );
 232
 233     d->m_recentAction = new KRecentFilesAction( this );
 234     connect( d->m_recentAction, SIGNAL(urlSelected(const KUrl&)), SLOT(
 235                             openProject( const KUrl& ) ));
 236     ac->addAction( "project_open_recent", d->m_recentAction );
 237     d->m_recentAction->setText( i18n( "Open Recent" ) );
 238     d->m_recentAction->setToolTip( i18n( "Open recent project" ) );
 239     d->m_recentAction->setWhatsThis(
 240         i18n( "<b>Open recent project</b><p>Opens recently opened project.</p>" ) );
 241     d->m_recentAction->loadEntries( KConfigGroup(config, "RecentProjects") );
 242
 243     d->m_projectConfigAction = new KActionMenu( i18n("Configure Project"), ac );
 244     ac->addAction( "project_config_menu", d->m_projectConfigAction );
 245     d->m_projectConfigAction->setIcon(KIcon("configure"));
 246 }
 247
 248 ProjectController::~ProjectController()
 249 {
 250     delete d->model;
 251     delete d->dialog;
 252     delete d;
 253 }
 254
 255 void ProjectController::cleanup()
 256 {
 257     KSharedConfig * config = KGlobal::config().data();
 258     KConfigGroup group = config->group( "General Options" );
 259
 260     KUrl::List openProjects;
 261
 262     foreach( IProject* project, d->m_projects ) {
 263         openProjects.append(project->projectFileUrl());
 264         closeProject( project );
 265     }
 266
 267     group.writeEntry( "Open Projects", openProjects.toStringList() );
 268 }
 269
 270 void ProjectController::initialize()
 271 {
 272     if (d->reopenProjectsOnStartup) {
 273         KSharedConfig * config = KGlobal::config().data();
 274         KConfigGroup group = config->group( "General Options" );
 275         KUrl::List openProjects = group.readEntry( "Open Projects", QStringList() );
 276
 277         foreach (const KUrl& url, openProjects)
 278             openProject(url);
 279     }
 280 }
 281
 282 void ProjectController::loadSettings( bool projectIsLoaded )
 283 {
 284     Q_UNUSED(projectIsLoaded)
 285
 286     KConfigGroup config(KGlobal::config(), "Project Manager");
 287
 288     d->reopenProjectsOnStartup = config.readEntry("Reopen Projects On Startup", false);
 289     d->parseAllProjectSources = config.readEntry("Parse All Project Sources", false);
 290 }
 291
 292 void ProjectController::saveSettings( bool projectIsLoaded )
 293 {
 294     Q_UNUSED( projectIsLoaded );
 295 }
 296
 297
 298 int ProjectController::projectCount() const
 299 {
 300     return d->m_projects.count();
 301 }
 302
 303 IProject* ProjectController::projectAt( int num ) const
 304 {
 305     if( !d->m_projects.isEmpty() && num >= 0 && num < d->m_projects.count() )
 306         return d->m_projects.at( num );
 307     return 0;
 308 }
 309
 310 QList<IProject*> ProjectController::projects() const
 311 {
 312     return d->m_projects;
 313 }
 314
 315 bool ProjectController::openProject( const KUrl &projectFile )
 316 {
 317     KUrl url = projectFile;
 318
 319     if ( url.isEmpty() )
 320     {
 321         url = d->dialog->askProjectConfigLocation();
 322     }
 323
 324     if ( !url.isValid() )
 325     {
 326         return false;
 327     }
 328     if ( d->m_currentlyOpening.contains(url))
 329     {
 330         kDebug() << "Already opening " << url << ". Aborting.";
 331         return false;
 332     }
 333
 334     foreach( IProject* project, d->m_projects )
 335     {
 336         if ( url == project->projectFileUrl() )
 337         {
 338             if ( d->dialog->userWantsReopen() )
 339             { // close first, then open again by falling through
 340                 closeProject(project);
 341             } else { // abort
 342                 return false;
 343             }
 344         }
 345     }
 346
 347     //FIXME Create the hidden directory if it doesn't exist
 348     if ( loadProjectPart() )
 349     {
 350         //The project file has been opened.
 351         //Now we can load settings for all of the Core objects including this one!!
 352 //         Core::loadSettings();
 353         d->m_core->pluginController()->loadPlugins( IPluginController::Project );
 354     }
 355     else
 356         return false;
 357
 358     Project* project = new Project();
 359     if ( !project->open( url ) )
 360     {
 361         delete project;
 362         return false;
 363     }
 364
 365     d->m_currentlyOpening << url;
 366     d->m_closeAllProjects->setEnabled(true);
 367     return true;
 368 }
 369
 370 bool ProjectController::projectImportingFinished( IProject* project )
 371 {
 372     IPlugin *managerPlugin = project->managerPlugin();
 373     QList<IPlugin*> pluglist;
 374     pluglist.append( managerPlugin );
 375     d->m_projectPlugins.insert( project, pluglist );
 376
 377     ProjectFolderItem *topItem = project->projectItem();
 378     d->model->insertRow( d->model->rowCount(), topItem );
 379
 380     d->m_projects.append( project );
 381
 382 //     KActionCollection * ac = d->m_core->uiController()->defaultMainWindow()->actionCollection();
 383 //     QAction * action;
 384
 385     //action = ac->action( "project_close" );
 386     //action->setEnabled( true );
 387
 388     d->m_recentAction->addUrl( project->projectFileUrl() );
 389     KSharedConfig * config = KGlobal::config().data();
 390     KConfigGroup recentGroup = config->group("RecentProjects");
 391     d->m_recentAction->saveEntries( recentGroup );
 392
 393     config->sync();
 394     QAction* qa = new QAction( project->name(), d->m_projectConfigAction );
 395     d->m_configActions.insert( project, qa );
 396     connect( qa, SIGNAL( triggered() ), d->m_signalMapper, SLOT( map() ) );
 397     d->m_signalMapper->setMapping( qa, project );
 398     d->m_projectConfigAction->addAction( qa );
 399
 400     d->m_currentlyOpening.removeAll(project->projectFileUrl());
 401     emit projectOpened( project );
 402
 403     KUrl::List parseList;
 404     if (d->parseAllProjectSources)
 405     {
 406         // Add the project files to the background parser to be parsed.
 407         QList<ProjectFileItem*> files = project->files();
 408         foreach ( ProjectFileItem* file, files )
 409         {
 410             parseList.append( file->url() );
 411         }
 412     } else
 413     {
 414         // Add all currently open files that belong to the project to the background-parser,
 415         // since more information may be available for parsing them now(Like include-paths).
 416         foreach(IDocument* document, Core::self()->documentController()->openDocuments())
 417         {
 418             if(!project->filesForUrl(document->url()).isEmpty())
 419             {
 420                 parseList.append(document->url());
 421             }
 422         }
 423     }
 424     //Add low-priority parse jobs, with only the minimum parsed information
 425     Core::self()->languageController()->backgroundParser()->addDocumentList( parseList, KDevelop::TopDUContext::VisibleDeclarationsAndContexts, 10000 );
 426
 427     return true;
 428 }
 429
 430 // helper method for closeProject()
 431 void ProjectController::unloadUnusedProjectPlugins(IProject* proj)
 432 {
 433     QList<IPlugin*> pluginsForProj = d->m_projectPlugins.value( proj );
 434     d->m_projectPlugins.remove( proj );
 435
 436     QList<IPlugin*> otherProjectPlugins;
 437     Q_FOREACH( QList<IPlugin*> _list, d->m_projectPlugins )
 438     {
 439         otherProjectPlugins << _list;
 440     }
 441
 442     QSet<IPlugin*> pluginsForProjSet = QSet<IPlugin*>::fromList( pluginsForProj );
 443     QSet<IPlugin*> otherPrjPluginsSet = QSet<IPlugin*>::fromList( otherProjectPlugins );
 444     // loaded - target = tobe unloaded.
 445     QSet<IPlugin*> tobeRemoved = pluginsForProjSet.subtract( otherPrjPluginsSet );
 446     Q_FOREACH( IPlugin* _plugin, tobeRemoved )
 447     {
 448         KPluginInfo _plugInfo = Core::self()->pluginController()->pluginInfo( _plugin );
 449         if( _plugInfo.isValid() )
 450         {
 451             QString _plugName = _plugInfo.pluginName();
 452             kDebug() << "about to unloading :" << _plugName;
 453             Core::self()->pluginController()->unloadPlugin( _plugName );
 454         }
 455     }
 456 }
 457
 458 // helper method for closeProject()
 459 void ProjectController::disableProjectCloseAction()
 460 {
 461     MainWindow *mw = d->m_core->uiControllerInternal()->defaultMainWindow();
 462     if (!mw) return;
 463     KActionCollection * ac = mw->actionCollection();
 464     QAction *action = ac->action("project_close");
 465     if (action) action->setEnabled(false);
 466 }
 467
 468 // helper method for closeProject()
 469 void ProjectController::closeAllOpenedFiles(IProject* proj)
 470 {
 471     Q_FOREACH( ProjectFileItem *fileItem, proj->files() )
 472     {
 473         Core::self()->documentControllerInternal()->closeDocument( fileItem->url() );
 474     }
 475 }
 476
 477 // helper method for closeProject()
 478 void ProjectController::deleteProjectSettingsMenu(IProject* proj)
 479 {
 480     QPointer<QAction> configAction = d->m_configActions.take(proj);
 481     delete configAction;
 482     if( d->m_cfgDlgs.contains(proj) )
 483     {
 484         delete d->m_cfgDlgs.take(proj);
 485     }
 486 }
 487
 488 // helper method for closeProject()
 489 void ProjectController::initializePluginCleanup(IProject* proj)
 490 {
 491     // Unloading (and thus deleting) these plugins is not a good idea just yet
 492     // as we're being called by the view part and it gets deleted when we unload the plugin(s)
 493     // TODO: find a better place to unload
 494     connect(proj, SIGNAL(destroyed(QObject*)), this, SLOT(unloadAllProjectPlugins()));
 495     if (d->m_closeAllProjects)
 496     {
 497         d->m_closeAllProjects->setEnabled(false);
 498     }
 499 }
 500
 501 bool ProjectController::closeProject(IProject* proj)
 502 {
 503     if(!proj || d->m_projects.indexOf(proj) == -1)
 504     {
 505         return false;
 506     }
 507     emit projectClosing(proj);
 508     //Core::self()->saveSettings();     // The project file is being closed.
 509                                         // Now we can save settings for all of the Core
 510                                         // objects including this one!!
 511     //disableProjectCloseAction();
 512     unloadUnusedProjectPlugins(proj);
 513     closeAllOpenedFiles(proj);
 514     deleteProjectSettingsMenu(proj);
 515     proj->close();
 516     proj->deleteLater();                //be safe when deleting
 517     d->m_projects.removeAll(proj);
 518     if (d->m_projects.isEmpty())
 519     {
 520         initializePluginCleanup(proj);
 521     }
 522     emit projectClosed(proj);
 523     //PluginController::self() ->changeProfile( m_oldProfileName ); //FIXME
 524     return true;
 525 }
 526
 527 bool ProjectController::loadProjectPart()
 528 {
 529
 530     return true;
 531 }
 532
 533 ProjectModel* ProjectController::projectModel()
 534 {
 535     return d->model;
 536 }
 537
 538 IProject* ProjectController::findProjectForUrl( const KUrl& url ) const
 539 {
 540     Q_FOREACH( IProject* proj, d->m_projects )
 541     {
 542         if( proj->inProject( url ) )
 543             return proj;
 544     }
 545     return 0;
 546 }
 547
 548 IProject* ProjectController::findProjectByName( const QString& name )
 549 {
 550     Q_FOREACH( IProject* proj, d->m_projects )
 551     {
 552         if( proj->name() == name )
 553         {
 554             return proj;
 555         }
 556     }
 557     return 0;
 558 }
 559
 560 bool ProjectController::configureProject( IProject* project )
 561 {
 562     d->projectConfig( project );
 563     return true;
 564 }
 565
 566 void ProjectController::addProject(IProject* project)
 567 {
 568     d->m_projects.append( project );
 569 }
 570
 571
 572
 573 void ProjectController::closeAllProjects()
 574 {
 575     foreach (IProject* project, projects())
 576     {
 577         closeProject(project);
 578     }
 579 }
 580
 581 QItemSelectionModel* ProjectController::projectSelectionModel()
 582 {
 583     return d->selectionModel;
 584 }
 585
 586 }
 587
 588 #include "projectcontroller.moc"