main.cpp 37.5 KB
Newer Older
Andreas Pakulat's avatar
Andreas Pakulat committed
1
/***************************************************************************
2
 *   Copyright 2003-2009 Alexander Dymo <adymo@kdevelop.org>               *
Manuel Breugelmans's avatar
Manuel Breugelmans committed
3 4 5 6 7 8 9 10
 *   Copyright 2007 Ralf Habacker  <Ralf.Habacker@freenet.de>              *
 *   Copyright 2006-2007 Matt Rogers  <mattr@kde.org>                      *
 *   Copyright 2006-2007 Hamish Rodda <rodda@kde.org>                      *
 *   Copyright 2005-2007 Adam Treat <treat@kde.org>                        *
 *   Copyright 2003-2007 Jens Dagerbo <jens.dagerbo@swipnet.se>            *
 *   Copyright 2001-2002 Bernd Gehrmann <bernd@mail.berlios.de>            *
 *   Copyright 2001-2002 Matthias Hoelzer-Kluepfel <hoelzer@kde.org>       *
 *   Copyright 2003 Roberto Raggi <roberto@kdevelop.org>                   *
11
 *   Copyright 2010 Niko Sams <niko.sams@gmail.com>                        *
Kevin Funk's avatar
Kevin Funk committed
12
 *   Copyright 2015 Kevin Funk <kfunk@kde.org>                             *
Andreas Pakulat's avatar
Andreas Pakulat committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
 ***************************************************************************/

30 31
#include "config-kdevelop.h"
#include "kdevelop_version.h"
32

33 34
#include "urlinfo.h"

35
#include <KLocalizedString>
Kevin Funk's avatar
Kevin Funk committed
36
#include <Kdelibs4ConfigMigrator>
37
#include <kaboutdata.h>
38
#include <kcrash.h>
39

40
#include <QApplication>
41
#include <QElapsedTimer>
42 43
#include <QCommandLineParser>
#include <QCommandLineOption>
44
#include <QFileInfo>
45
#include <QProcessEnvironment>
46
#include <QSessionManager>
47
#include <QTextStream>
48 49
#include <QDBusInterface>
#include <QDBusReply>
50

51 52 53 54 55
#include <shell/core.h>
#include <shell/mainwindow.h>
#include <shell/projectcontroller.h>
#include <shell/documentcontroller.h>
#include <shell/plugincontroller.h>
56
#include <shell/sessioncontroller.h>
57 58 59 60 61
#include <shell/runcontroller.h>
#include <shell/launchconfiguration.h>
#include <shell/session.h>
#include <interfaces/ilauncher.h>
#include <interfaces/iproject.h>
Kevin Funk's avatar
Kevin Funk committed
62
#include <interfaces/launchconfigurationtype.h>
Milian Wolff's avatar
Milian Wolff committed
63
#include <util/path.h>
64
#include <debug.h>
65 66

#include "kdevideextension.h"
67 68 69
#if KDEVELOP_SINGLE_APP
#include "qtsingleapplication.h"
#endif
70

Milian Wolff's avatar
Milian Wolff committed
71
#include <iostream>
72

René J.V. Bertin's avatar
OS X:  
René J.V. Bertin committed
73 74 75 76
#ifdef Q_OS_MAC
#include <CoreFoundation/CoreFoundation.h>
#endif

Milian Wolff's avatar
Milian Wolff committed
77
using namespace KDevelop;
78

79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
namespace {

#if KDEVELOP_SINGLE_APP
QString serializeOpenFilesMessage(const QVector<UrlInfo> &infos)
{
    QByteArray message;
    QDataStream stream(&message, QIODevice::WriteOnly);
    stream << QByteArrayLiteral("open");
    stream << infos;
    return QString::fromLatin1(message.toHex());
}
#endif

void openFiles(const QVector<UrlInfo>& infos)
{
94 95 96
    foreach (const UrlInfo& info, infos) {
        if (!ICore::self()->documentController()->openDocument(info.url, info.cursor)) {
            qWarning() << i18n("Could not open %1", info.url.toDisplayString(QUrl::PreferLocalFile));
97 98 99 100 101 102 103
        }
    }
}

}

class KDevelopApplication:
104 105 106 107 108
#if KDEVELOP_SINGLE_APP
    public SharedTools::QtSingleApplication
#else
    public QApplication
#endif
109
{
110
public:
111
    explicit KDevelopApplication(int &argc, char **argv, bool GUIenabled = true)
112 113 114
#if KDEVELOP_SINGLE_APP
        : SharedTools::QtSingleApplication(QStringLiteral("KDevelop"), argc, argv)
#else
115
        : QApplication(argc, argv, GUIenabled)
116
#endif
117
        {
118
            Q_UNUSED(GUIenabled);
119 120
            connect(this, &QGuiApplication::saveStateRequest, this, &KDevelopApplication::saveState);
        }
121

122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
#if KDEVELOP_SINGLE_APP
public Q_SLOTS:
    void remoteArguments(const QString &message, QObject *socket)
    {
        Q_UNUSED(socket);

        QByteArray ba = QByteArray::fromHex(message.toLatin1());
        QDataStream stream(ba);
        QByteArray command;
        stream >> command;

        qCDebug(APP) << "Received remote command: " << command;

        if (command == "open") {
            QVector<UrlInfo> infos;
            stream >> infos;
138 139 140 141 142 143 144 145 146 147 148

            QVector<UrlInfo> files, directories;
            for (const auto& info : infos)
                if (info.isDirectory())
                    directories << info;
                else
                    files << info;

            openFiles(files);
            for(const auto &urlinfo : directories)
                ICore::self()->projectController()->openProjectForUrl(urlinfo.url);
149 150 151 152 153 154 155 156 157 158 159
        } else {
            qCWarning(APP) << "Unknown remote command: " << command;
        }
    }

    void fileOpenRequested(const QString &file)
    {
        openFiles({UrlInfo(file)});
    }
#endif

160
private Q_SLOTS:
161
    void saveState( QSessionManager& sm ) {
162
        if (KDevelop::Core::self() && KDevelop::Core::self()->sessionController()) {
163
            QString x11SessionId = QStringLiteral("%1_%2").arg(sm.sessionId()).arg(sm.sessionKey());
164 165 166 167 168
            const auto activeSession = KDevelop::Core::self()->sessionController()->activeSession();
            if (!activeSession) {
                qWarning() << "No active session, can't save state";
                return;
            }
169

170
            QString kdevelopSessionId = activeSession->id().toString();
171
            sm.setRestartCommand({QCoreApplication::applicationFilePath(), "-session", x11SessionId, "-s", kdevelopSessionId});
172
        }
173 174 175
    }
};

176 177 178
/// Tries to find a session identified by @p data in @p sessions.
/// The @p data may be either a session's name or a string-representation of its UUID.
/// @return pointer to the session or NULL if nothing appropriate has been found
179
static const KDevelop::SessionInfo* findSessionInList( const SessionInfos& sessions, const QString& data )
180 181 182 183
{
    // We won't search a session without input data, since that could lead to false-positives
    // with unnamed sessions
    if( data.isEmpty() )
184
        return nullptr;
185

186
    for( auto it = sessions.constBegin(); it != sessions.constEnd(); ++it ) {
187 188 189 190 191
        if ( ( it->name == data ) || ( it->uuid.toString() == data ) ) {
            const KDevelop::SessionInfo& sessionRef = *it;
            return &sessionRef;
        }
    }
192
    return nullptr;
193 194
}

195 196
/// Performs a DBus call to open the given @p files in the running kdev instance identified by @p pid
/// Returns the exit status
197
static int openFilesInRunningInstance(const QVector<UrlInfo>& files, qint64 pid)
198
{
199 200
    const QString service = QStringLiteral("org.kdevelop.kdevelop-%1").arg(pid);
    QDBusInterface iface(service, QStringLiteral("/org/kdevelop/DocumentController"), QStringLiteral("org.kdevelop.DocumentController"));
201 202

    QStringList urls;
203
    bool errors_occured = false;
204
    foreach ( const UrlInfo& file, files ) {
205
        QDBusReply<bool> result = iface.call(QStringLiteral("openDocumentSimple"), file.url.toString(), file.cursor.line(), file.cursor.column());
206 207
        if ( ! result.value() ) {
            QTextStream err(stderr);
208
            err << i18n("Could not open file '%1'.", file.url.toDisplayString(QUrl::PreferLocalFile)) << "\n";
209 210
            errors_occured = true;
        }
211
    }
212
    // make the window visible
213 214
    QDBusMessage makeVisible = QDBusMessage::createMethodCall( service, QStringLiteral("/kdevelop/MainWindow"), QStringLiteral("org.kdevelop.MainWindow"),
                                                               QStringLiteral("ensureVisible") );
215
    QDBusConnection::sessionBus().asyncCall( makeVisible );
patrick pereira's avatar
patrick pereira committed
216
    return errors_occured;
217 218
}

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
/// Performs a DBus call to open the given @p files in the running kdev instance identified by @p pid
/// Returns the exit status
static int openProjectInRunningInstance(const QVector<UrlInfo>& paths, qint64 pid)
{
    const QString service = QStringLiteral("org.kdevelop.kdevelop-%1").arg(pid);
    QDBusInterface iface(service, QStringLiteral("/org/kdevelop/ProjectController"), QStringLiteral("org.kdevelop.ProjectController"));
    int errors = 0;

    foreach ( const UrlInfo& path, paths ) {
        QDBusReply<void> result = iface.call(QStringLiteral("openProjectForUrl"), path.url.toString());
        if ( !result.isValid() ) {
            QTextStream err(stderr);
            err << i18n("Could not open project '%1': %2", path.url.toDisplayString(QUrl::PreferLocalFile), result.error().message()) << "\n";
            ++errors;
        }
    }
    // make the window visible
    QDBusMessage makeVisible = QDBusMessage::createMethodCall( service, QStringLiteral("/kdevelop/MainWindow"), QStringLiteral("org.kdevelop.MainWindow"),
                                                               QStringLiteral("ensureVisible") );
    QDBusConnection::sessionBus().asyncCall( makeVisible );
    return errors;
}

242 243
/// Gets the PID of a running KDevelop instance, eventually asking the user if there is more than one.
/// Returns -1 in case there are no running sessions.
244
static qint64 getRunningSessionPid()
245
{
246 247
    SessionInfos candidates;
    foreach( const KDevelop::SessionInfo& si, KDevelop::SessionController::availableSessionInfos() ) {
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
        if( KDevelop::SessionController::isSessionRunning(si.uuid.toString()) ) {
            candidates << si;
        }
    }
    if ( candidates.isEmpty() ) {
        return -1;
    }

    QString sessionUuid;
    if ( candidates.size() == 1 ) {
        sessionUuid = candidates.first().uuid.toString();
    }
    else {
        const QString title = i18n("Select the session to open the document in");
        sessionUuid = KDevelop::SessionController::showSessionChooserDialog(title, true);
    }
    return KDevelop::SessionController::sessionRunInfo(sessionUuid).holderPid;
}

267
static QString findSessionId(const SessionInfos& availableSessionInfos, const QString& session)
268 269 270 271
{
    //If there is a session and a project with the same name, always open the session
    //regardless of the order encountered
    QString projectAsSession;
272
    foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
    {
        if ( session == si.name || session == si.uuid.toString() ) {
            return si.uuid.toString();
        } else if (projectAsSession.isEmpty()) {
            foreach(const QUrl& k, si.projects) {
                QString fn(k.fileName());
                fn = fn.left(fn.indexOf('.'));
                if ( session == fn ) {
                    projectAsSession = si.uuid.toString();
                }
            }
        }
    }

    if (projectAsSession.isEmpty())  {
        QTextStream qerr(stderr);
289
        qerr << endl << i18n("Cannot open unknown session %1. See `--list-sessions` switch for available sessions or use `-n` to create a new one.",
290 291 292 293 294 295 296 297 298 299 300
                             session) << endl;
    }
    return projectAsSession;
}

static qint64 findSessionPid(const QString &sessionId)
{
    KDevelop::SessionRunInfo sessionInfo = KDevelop::SessionController::sessionRunInfo( sessionId );
    return sessionInfo.holderPid;
}

Adam Treat's avatar
Adam Treat committed
301
int main( int argc, char *argv[] )
302
{
303 304 305
    QElapsedTimer timer;
    timer.start();

306 307
    // TODO: Maybe generalize, add KDEVELOP_STANDALONE build option
#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
Kevin Funk's avatar
Kevin Funk committed
308 309 310
    qputenv("KDE_FORK_SLAVES", "1"); // KIO slaves will be forked off instead of being started via DBus
#endif

Kevin Funk's avatar
Kevin Funk committed
311 312 313 314 315 316
    // Useful for valgrind runs, just `export KDEV_DISABLE_JIT=1`
    if (qEnvironmentVariableIsSet("KDEV_DISABLE_JIT")) {
        qputenv("KDEV_DISABLE_WELCOMEPAGE", "1");
        qputenv("QT_ENABLE_REGEXP_JIT", "0");
    }

317
    QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
318

René J.V. Bertin's avatar
OS X:  
René J.V. Bertin committed
319 320 321 322 323 324 325 326 327 328 329 330 331 332
#ifdef Q_OS_MAC
    CFBundleRef mainBundle = CFBundleGetMainBundle();
    if (mainBundle) {
        // get the application's Info Dictionary. For app bundles this would live in the bundle's Info.plist,
        // for regular executables it is obtained in another way.
        CFMutableDictionaryRef infoDict = (CFMutableDictionaryRef) CFBundleGetInfoDictionary(mainBundle);
        if (infoDict) {
            // Try to prevent App Nap on OS X. This can be tricky in practice, at least in 10.9 .
            CFDictionarySetValue(infoDict, CFSTR("NSAppSleepDisabled"), kCFBooleanTrue);
            CFDictionarySetValue(infoDict, CFSTR("NSSupportsAutomaticTermination"), kCFBooleanFalse);
        }
    }
#endif

333 334 335 336 337 338 339 340 341 342 343
    //we can't use KCmdLineArgs as it doesn't allow arguments for the debugee
    //so lookup the --debug switch and eat everything behind by decrementing argc
    //debugArgs is filled with args after --debug <debuger>
    QStringList debugArgs;
    QString debugeeName;
    {
        bool debugFound = false;
        int c = argc;
        for (int i=0; i < c; ++i) {
            if (debugFound) {
                debugArgs << argv[i];
Friedrich W. H. Kossebau's avatar
Friedrich W. H. Kossebau committed
344 345
            } else if ((qstrcmp(argv[i], "--debug") == 0) || (qstrcmp(argv[i], "-d") == 0)) {
                if (argc > (i + 1)) {
346 347
                    i++;
                }
Friedrich W. H. Kossebau's avatar
Friedrich W. H. Kossebau committed
348
                argc = i + 1;
349
                debugFound = true;
Friedrich W. H. Kossebau's avatar
Friedrich W. H. Kossebau committed
350
            } else if (QString(argv[i]).startsWith(QLatin1String("--debug="))) {
351 352 353 354 355 356 357
                argc = i + 1;
                debugFound = true;
            }
        }
    }

    KDevelopApplication app(argc, argv);
358
    KLocalizedString::setApplicationDomain("kdevelop");
359

360
    static const char description[] = I18N_NOOP( "The KDevelop Integrated Development Environment" );
361
    KAboutData aboutData( QStringLiteral("kdevelop"), i18n( "KDevelop" ), QByteArray(KDEVELOP_VERSION_STRING), i18n(description), KAboutLicense::GPL,
362
                          i18n("Copyright 1999-2017, The KDevelop developers"), QString(), QStringLiteral("https://www.kdevelop.org/"));
363
    aboutData.setDesktopFileName(QStringLiteral("org.kde.kdevelop"));
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
    aboutData.addAuthor( i18n("Kevin Funk"), i18n( "Co-maintainer, C++/Clang, QA, Windows Support" ), QStringLiteral("kfunk@kde.org") );
    aboutData.addAuthor( i18n("Sven Brauch"), i18n( "Co-maintainer, AppImage, Python Support, User Interface improvements" ), QStringLiteral("svenbrauch@gmail.com") );
    aboutData.addAuthor( i18n("Aleix Pol Gonzalez"), i18n( "CMake Support, Run Support, Kross Support" ), QStringLiteral("aleixpol@gmail.com") );
    aboutData.addAuthor( i18n("Milian Wolff"), i18n( "C++/Clang, Generic manager, Webdevelopment Plugins, Snippets, Performance" ), QStringLiteral("mail@milianw.de") );
    aboutData.addAuthor( i18n("Olivier JG"), i18n( "C++/Clang, DUChain, Bug Fixes" ), QStringLiteral("olivier.jg@gmail.com") );
    aboutData.addAuthor( i18n("Andreas Pakulat"), i18n( "Architecture, VCS Support, Project Management Support, QMake Projectmanager" ), QStringLiteral("apaku@gmx.de") );
    aboutData.addAuthor( i18n("Alexander Dymo"), i18n( "Architecture, Sublime UI, Ruby support" ), QStringLiteral("adymo@kdevelop.org") );
    aboutData.addAuthor( i18n("David Nolden"), i18n( "Definition-Use Chain, C++ Support, Code Navigation, Code Completion, Coding Assistance, Refactoring" ), QStringLiteral("david.nolden.kdevelop@art-master.de") );
    aboutData.addAuthor( i18n("Vladimir Prus"), i18n( "GDB integration" ), QStringLiteral("ghost@cs.msu.su") );
    aboutData.addAuthor( i18n("Hamish Rodda"), i18n( "Text editor integration, definition-use chain" ), QStringLiteral("rodda@kde.org") );
    aboutData.addAuthor( i18n("Amilcar do Carmo Lucas"), i18n( "Website admin, API documentation, Doxygen and autoproject patches" ), QStringLiteral("amilcar@kdevelop.org") );
    aboutData.addAuthor( i18n("Niko Sams"), i18n( "GDB integration, Webdevelopment Plugins" ), QStringLiteral("niko.sams@gmail.com") );

    aboutData.addCredit( i18n("Matt Rogers"), QString(), QStringLiteral("mattr@kde.org"));
    aboutData.addCredit( i18n("Cédric Pasteur"), i18n("astyle and indent support"), QStringLiteral("cedric.pasteur@free.fr") );
    aboutData.addCredit( i18n("Evgeniy Ivanov"), i18n("Distributed VCS, Git, Mercurial"), QStringLiteral("powerfox@kde.ru") );
380
    // QTest integration is separate in playground currently.
381
    //aboutData.addCredit( i18n("Manuel Breugelmanns"), i18n( "Veritas, QTest integration"), "mbr.nxi@gmail.com" );
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
    aboutData.addCredit( i18n("Robert Gruber") , i18n( "SnippetPart, debugger and usability patches" ), QStringLiteral("rgruber@users.sourceforge.net") );
    aboutData.addCredit( i18n("Dukju Ahn"), i18n( "Subversion plugin, Custom Make Manager, Overall improvements" ), QStringLiteral("dukjuahn@gmail.com") );
    aboutData.addCredit( i18n("Harald Fernengel"), i18n( "Ported to Qt 3, patches, valgrind, diff and perforce support" ), QStringLiteral("harry@kdevelop.org") );
    aboutData.addCredit( i18n("Roberto Raggi"), i18n( "C++ parser" ), QStringLiteral("roberto@kdevelop.org") );
    aboutData.addCredit( i18n("The KWrite authors"), i18n( "Kate editor component" ), QStringLiteral("kwrite-devel@kde.org") );
    aboutData.addCredit( i18n("Nokia Corporation/Qt Software"), i18n( "Designer code" ), QStringLiteral("qt-info@nokia.com") );

    aboutData.addCredit( i18n("Contributors to older versions:"), QString(), QLatin1String("") );
    aboutData.addCredit( i18n("Bernd Gehrmann"), i18n( "Initial idea, basic architecture, much initial source code" ), QStringLiteral("bernd@kdevelop.org") );
    aboutData.addCredit( i18n("Caleb Tennis"), i18n( "KTabBar, bugfixes" ), QStringLiteral("caleb@aei-tech.com") );
    aboutData.addCredit( i18n("Richard Dale"), i18n( "Java & Objective C support" ), QStringLiteral("Richard_Dale@tipitina.demon.co.uk") );
    aboutData.addCredit( i18n("John Birch"), i18n( "Debugger frontend" ), QStringLiteral("jbb@kdevelop.org") );
    aboutData.addCredit( i18n("Sandy Meier"), i18n( "PHP support, context menu stuff" ), QStringLiteral("smeier@kdevelop.org") );
    aboutData.addCredit( i18n("Kurt Granroth"), i18n( "KDE application templates" ), QStringLiteral("kurth@granroth.org") );
    aboutData.addCredit( i18n("Ian Reinhart Geiser"), i18n( "Dist part, bash support, application templates" ), QStringLiteral("geiseri@yahoo.com") );
    aboutData.addCredit( i18n("Matthias Hoelzer-Kluepfel"), i18n( "Several components, htdig indexing" ), QStringLiteral("hoelzer@kde.org") );
    aboutData.addCredit( i18n("Victor Roeder"), i18n( "Help with Automake manager and persistent class store" ), QStringLiteral("victor_roeder@gmx.de") );
    aboutData.addCredit( i18n("Simon Hausmann"), i18n( "Help with KParts infrastructure" ), QStringLiteral("hausmann@kde.org") );
    aboutData.addCredit( i18n("Oliver Kellogg"), i18n( "Ada support" ), QStringLiteral("okellogg@users.sourceforge.net") );
    aboutData.addCredit( i18n("Jakob Simon-Gaarde"), i18n( "QMake projectmanager" ), QStringLiteral("jsgaarde@tdcspace.dk") );
    aboutData.addCredit( i18n("Falk Brettschneider"), i18n( "MDI modes, QEditor, bugfixes" ), QStringLiteral("falkbr@kdevelop.org") );
    aboutData.addCredit( i18n("Mario Scalas"), i18n( "PartExplorer, redesign of CvsPart, patches, bugs(fixes)" ), QStringLiteral("mario.scalas@libero.it") );
    aboutData.addCredit( i18n("Jens Dagerbo"), i18n( "Replace, Bookmarks, FileList and CTags2 plugins. Overall improvements and patches" ), QStringLiteral("jens.dagerbo@swipnet.se") );
    aboutData.addCredit( i18n("Julian Rockey"), i18n( "Filecreate part and other bits and patches" ), QStringLiteral("linux@jrockey.com") );
    aboutData.addCredit( i18n("Ajay Guleria"), i18n( "ClearCase support" ), QStringLiteral("ajay_guleria@yahoo.com") );
    aboutData.addCredit( i18n("Marek Janukowicz"), i18n( "Ruby support" ), QStringLiteral("child@t17.ds.pwr.wroc.pl") );
    aboutData.addCredit( i18n("Robert Moniot"), i18n( "Fortran documentation" ), QStringLiteral("moniot@fordham.edu") );
    aboutData.addCredit( i18n("Ka-Ping Yee"), i18n( "Python documentation utility" ), QStringLiteral("ping@lfw.org") );
    aboutData.addCredit( i18n("Dimitri van Heesch"), i18n( "Doxygen wizard" ), QStringLiteral("dimitri@stack.nl") );
    aboutData.addCredit( i18n("Hugo Varotto"), i18n( "Fileselector component" ), QStringLiteral("hugo@varotto-usa.com") );
    aboutData.addCredit( i18n("Matt Newell"), i18n( "Fileselector component" ), QStringLiteral("newellm@proaxis.com") );
    aboutData.addCredit( i18n("Daniel Engelschalt"), i18n( "C++ code completion, persistent class store" ), QStringLiteral("daniel.engelschalt@gmx.net") );
    aboutData.addCredit( i18n("Stephane Ancelot"), i18n( "Patches" ), QStringLiteral("sancelot@free.fr") );
    aboutData.addCredit( i18n("Jens Zurheide"), i18n( "Patches" ), QStringLiteral("jens.zurheide@gmx.de") );
    aboutData.addCredit( i18n("Luc Willems"), i18n( "Help with Perl support" ), QStringLiteral("Willems.luc@pandora.be") );
    aboutData.addCredit( i18n("Marcel Turino"), i18n( "Documentation index view" ), QStringLiteral("M.Turino@gmx.de") );
    aboutData.addCredit( i18n("Yann Hodique"), i18n( "Patches" ), QStringLiteral("Yann.Hodique@lifl.fr") );
    aboutData.addCredit( i18n("Tobias Gl\303\244\303\237er") , i18n( "Documentation Finder,  qmake projectmanager patches, usability improvements, bugfixes ... " ), QStringLiteral("tobi.web@gmx.de") );
    aboutData.addCredit( i18n("Andreas Koepfle") , i18n( "QMake project manager patches" ), QStringLiteral("koepfle@ti.uni-mannheim.de") );
    aboutData.addCredit( i18n("Sascha Cunz") , i18n( "Cleanup and bugfixes for qEditor, AutoMake and much other stuff" ), QStringLiteral("mail@sacu.de") );
    aboutData.addCredit( i18n("Zoran Karavla"), i18n( "Artwork for the ruby language" ), QStringLiteral("webmaster@the-error.net"), QStringLiteral("http://the-error.net") );
Adam Treat's avatar
Adam Treat committed
423

424 425
    KAboutData::setApplicationData(aboutData);
    // set icon for shells which do not use desktop file metadata
426 427
    // but without setting replacing an existing icon with an empty one!
    QApplication::setWindowIcon(QIcon::fromTheme(QStringLiteral("kdevelop"), QApplication::windowIcon()));
Kevin Funk's avatar
Kevin Funk committed
428

429 430
    KCrash::initialize();

431 432 433 434 435
    Kdelibs4ConfigMigrator migrator(QStringLiteral("kdevelop"));
    migrator.setConfigFiles({QStringLiteral("kdeveloprc")});
    migrator.setUiFiles({QStringLiteral("kdevelopui.rc")});
    migrator.migrate();

Kevin Funk's avatar
Kevin Funk committed
436 437 438
    // High DPI support
    app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);

439
    qCDebug(APP) << "Startup";
Kevin Funk's avatar
Kevin Funk committed
440

441 442 443 444 445
    QCommandLineParser parser;
    parser.addVersionOption();
    parser.addHelpOption();
    aboutData.setupCommandLine(&parser);

446
    parser.addOption(QCommandLineOption{QStringList{"n", "new-session"}, i18n("Open KDevelop with a new session using the given name."), QStringLiteral("name")});
447
    parser.addOption(QCommandLineOption{QStringList{"s", "open-session"}, i18n("Open KDevelop with the given session.\n"
448
                     "You can pass either hash or the name of the session." ), QStringLiteral("session")});
449
    parser.addOption(QCommandLineOption{QStringList{"rm", "remove-session"}, i18n("Delete the given session.\n"
450
                     "You can pass either hash or the name of the session." ), QStringLiteral("session")});
451 452 453
    parser.addOption(QCommandLineOption{QStringList{"ps", "pick-session"}, i18n("Shows all available sessions and lets you select one to open.")});
    parser.addOption(QCommandLineOption{QStringList{"pss", "pick-session-shell"}, i18n("List all available sessions on shell and lets you select one to open.")});
    parser.addOption(QCommandLineOption{QStringList{"l", "list-sessions"}, i18n("List available sessions and quit.")});
454
    parser.addOption(QCommandLineOption{QStringList{"f", "fetch"}, i18n("Open KDevelop and fetch the given project."), QStringLiteral("fetch")});
455
    parser.addOption(QCommandLineOption{QStringList{"p", "project"}, i18n("Open KDevelop and load the given project."), QStringLiteral("project")});
456 457
    parser.addOption(QCommandLineOption{QStringList{"d", "debug"},
                     i18n("Start debugging an application in KDevelop with the given debugger.\n"
458
                     "The executable that should be debugged must follow - including arguments.\n"
459
                     "Example: kdevelop --debug gdb myapp --foo bar"), QStringLiteral("debugger")});
460

461 462 463 464 465 466 467
    // this is used by the 'kdevelop!' script to retrieve the pid of a KDEVELOP
    // instance. When this is called, then we should just print the PID on the
    // standard-output. If a session is specified through open-session, then
    // we should return the PID of that session. Otherwise, if only a single
    // session is running, then we should just return the PID of that session.
    // Otherwise, we should print a command-line session-chooser dialog ("--pss"),
    // which only shows the running sessions, and the user can pick one.
468 469
    parser.addOption(QCommandLineOption{QStringList{"pid"}});

470 471
    parser.addPositionalArgument(QStringLiteral("files"),
                     i18n( "Files to load, or directories to load as projects" ), QStringLiteral("[FILE[:line[:column]] | DIRECTORY]..."));
472

473 474
    // The session-controller needs to arguments to eventually pass them to newly opened sessions
    KDevelop::SessionController::setArguments(argc, argv);
475

476 477 478
    parser.process(app);
    aboutData.processCommandLine(&parser);

479
    if(parser.isSet(QStringLiteral("list-sessions")))
Milian Wolff's avatar
Milian Wolff committed
480 481
    {
        QTextStream qout(stdout);
482
        qout << endl << ki18n("Available sessions (use '-s HASH' or '-s NAME' to open a specific one):").toString() << endl << endl;
483
        qout << QStringLiteral("%1").arg(ki18n("Hash").toString(), -38) << '\t' << ki18n("Name: Opened Projects").toString() << endl;
484
        foreach(const KDevelop::SessionInfo& si, KDevelop::SessionController::availableSessionInfos())
Milian Wolff's avatar
Milian Wolff committed
485
        {
486
            if ( si.name.isEmpty() && si.projects.isEmpty() ) {
487 488
                continue;
            }
489
            qout << si.uuid.toString() << '\t' << si.description;
490

491
            if(KDevelop::SessionController::isSessionRunning(si.uuid.toString()))
492
                qout << "     " << i18n("[running]");
493

494
            qout << endl;
Milian Wolff's avatar
Milian Wolff committed
495 496 497
        }
        return 0;
    }
498

499
    // Handle extra arguments, which stand for files to open
500
    QVector<UrlInfo> initialFiles;
501
    QVector<UrlInfo> initialDirectories;
502
    foreach (const QString &file, parser.positionalArguments()) {
503 504 505 506 507 508
        const UrlInfo info(file);
        if (info.isDirectory()) {
            initialDirectories.append(info);
        } else {
            initialFiles.append(info);
        }
509
    }
510

511 512
    const auto availableSessionInfos = KDevelop::SessionController::availableSessionInfos();

513
    if ((!initialFiles.isEmpty() || !initialDirectories.isEmpty()) && !parser.isSet(QStringLiteral("new-session"))) {
514 515
#if KDEVELOP_SINGLE_APP
        if (app.isRunning()) {
516
            bool success = app.sendMessage(serializeOpenFilesMessage(initialFiles << initialDirectories));
517 518 519 520 521
            if (success) {
                return 0;
            }
        }
#else
522
        qint64 pid = -1;
523 524
        if (parser.isSet(QStringLiteral("open-session"))) {
            const QString session = findSessionId(availableSessionInfos, parser.value(QStringLiteral("open-session")));
525 526 527 528 529 530 531 532
            if (session.isEmpty()) {
                return 1;
            } else if (KDevelop::SessionController::isSessionRunning(session)) {
                pid = findSessionPid(session);
            }
        } else {
            pid = getRunningSessionPid();
        }
533

534
        if ( pid > 0 ) {
535
            return openFilesInRunningInstance(initialFiles, pid) + openProjectInRunningInstance(initialDirectories, pid);
536 537
        }
        // else there are no running sessions, and the generated list of files will be opened below.
538
#endif
539 540
    }

541 542
    // if empty, restart kdevelop with last active session, see SessionController::defaultSessionId
    QString session;
543

544
    uint nRunningSessions = 0;
545
    foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
546 547 548 549 550
        if(KDevelop::SessionController::isSessionRunning(si.uuid.toString()))
            ++nRunningSessions;

    // also show the picker dialog when a pid shall be retrieved and multiple
    // sessions are running.
551
    if(parser.isSet(QStringLiteral("pss")) || (parser.isSet(QStringLiteral("pid")) && !parser.isSet(QStringLiteral("open-session")) && !parser.isSet(QStringLiteral("ps")) && nRunningSessions > 1))
552 553
    {
        QTextStream qerr(stderr);
554
        SessionInfos candidates;
555
        foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
556 557
            if( (!si.name.isEmpty() || !si.projects.isEmpty() || parser.isSet(QStringLiteral("pid"))) &&
                (!parser.isSet(QStringLiteral("pid")) || KDevelop::SessionController::isSessionRunning(si.uuid.toString())))
558
                candidates << si;
Dāvis Mosāns's avatar
Dāvis Mosāns committed
559

560 561 562 563 564
        if(candidates.size() == 0)
        {
            qerr << "no session available" << endl;
            return 1;
        }
Dāvis Mosāns's avatar
Dāvis Mosāns committed
565

566
        if(candidates.size() == 1 && parser.isSet(QStringLiteral("pid")))
567 568 569 570 571
        {
            session = candidates[0].uuid.toString();
        }else{
            for(int i = 0; i < candidates.size(); ++i)
                qerr << "[" << i << "]: " << candidates[i].description << endl;
Dāvis Mosāns's avatar
Dāvis Mosāns committed
572

573 574
            int chosen;
            std::cin >> chosen;
575
            if(std::cin.good() && (chosen >= 0 && chosen < candidates.size()))
576 577 578
            {
                session = candidates[chosen].uuid.toString();
            }else{
579
                qerr << "invalid selection" << endl;
580 581 582 583
                return 1;
            }
        }
    }
Dāvis Mosāns's avatar
Dāvis Mosāns committed
584

585
    if(parser.isSet(QStringLiteral("ps")))
586
    {
587
        bool onlyRunning = parser.isSet(QStringLiteral("pid"));
588
        session = KDevelop::SessionController::showSessionChooserDialog(i18n("Select the session you would like to use"), onlyRunning);
589 590 591
        if(session.isEmpty())
            return 1;
    }
592

593
    if ( parser.isSet(QStringLiteral("debug")) ) {
594 595
        if ( debugArgs.isEmpty() ) {
            QTextStream qerr(stderr);
596
            qerr << endl << i18nc("@info:shell", "Specify the executable you want to debug.") << endl;
597 598
            return 1;
        }
599

600 601 602 603
        QFileInfo executableFileInfo(debugArgs.first());
        if (!executableFileInfo.exists()) {
            executableFileInfo = QStandardPaths::findExecutable(debugArgs.first());
            if (!executableFileInfo.exists()) {
604
                QTextStream qerr(stderr);
605
                qerr << endl << i18nc("@info:shell", "Specified executable does not exist.") << endl;
606 607 608 609
                return 1;
            }
        }

610 611
        debugArgs.first() = executableFileInfo.absoluteFilePath();
        debugeeName = i18n("Debug %1", executableFileInfo.fileName());
612
        session = debugeeName;
613
    } else if ( parser.isSet(QStringLiteral("new-session")) )
614
    {
615
        session = parser.value(QStringLiteral("new-session"));
616
        foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
617 618 619 620 621 622 623 624
        {
            if ( session == si.name ) {
                QTextStream qerr(stderr);
                qerr << endl << i18n("A session with the name %1 exists already. Use the -s switch to open it.", session) << endl;
                return 1;
            }
        }
        // session doesn't exist, we can create it
625 626
    } else if ( parser.isSet(QStringLiteral("open-session")) ) {
        session = findSessionId(availableSessionInfos, parser.value(QStringLiteral("open-session")));
627 628
        if (session.isEmpty()) {
            return 1;
629
        }
630
    } else if ( parser.isSet(QStringLiteral("remove-session")) )
631
    {
632
        session = parser.value(QStringLiteral("remove-session"));
633
        auto si = findSessionInList(availableSessionInfos, session);
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
        if (!si) {
            QTextStream qerr(stderr);
            qerr << endl << i18n("No session with the name %1 exists.", session) << endl;
            return 1;
        }

        auto sessionLock = KDevelop::SessionController::tryLockSession(si->uuid.toString());
        if (!sessionLock.lock) {
            QTextStream qerr(stderr);
            qerr << endl << i18n("Could not lock session %1 for deletion.", session) << endl;
            return 1;
        }
        KDevelop::SessionController::deleteSessionFromDisk(sessionLock.lock);
        QTextStream qout(stdout);
        qout << endl << i18n("Session with name %1 was successfully removed.", session) << endl;
        return 0;
650
    }
651

652
    if(parser.isSet(QStringLiteral("pid"))) {
653 654
        if (session.isEmpty())
        {   // just pick the first running session
655
            foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
656 657 658
                if(KDevelop::SessionController::isSessionRunning(si.uuid.toString()))
                    session = si.uuid.toString();
        }
659
        const KDevelop::SessionInfo* sessionData = findSessionInList(availableSessionInfos, session);
660

661
        if( !sessionData ) {
Dāvis Mosāns's avatar
Dāvis Mosāns committed
662
            qCritical() << "session not given or does not exist";
663
            return 5;
664 665
        }

666 667
        const auto pid = findSessionPid(sessionData->uuid.toString());
        if (pid > 0) {
668
            // Print the PID and we're ready
669
            std::cout << pid << std::endl;
670
            return 0;
671 672 673
        } else {
            qCritical() << sessionData->uuid.toString() << sessionData->name << "is not running";
            return 5;
674
        }
675
    }
676

677
    KDevIDEExtension::init();
678

Kevin Funk's avatar
Kevin Funk committed
679
    if(!Core::initialize(Core::Default, session))
680
        return 5;
681

682
    // register a DBUS service for this process, so that we can open files in it from other invocations
683
    QDBusConnection::sessionBus().registerService(QStringLiteral("org.kdevelop.kdevelop-%1").arg(app.applicationPid()));
684

685
    Core* core = Core::self();
686 687
    if (!QProcessEnvironment::systemEnvironment().contains(QStringLiteral("KDEV_DISABLE_WELCOMEPAGE"))) {
        core->pluginController()->loadPlugin(QStringLiteral("KDevWelcomePage"));
688
    }
689

690
    QStringList projectNames = parser.values(QStringLiteral("project"));
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
691
    foreach(const QString& projectName, projectNames)
692
    {
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
693
        QFileInfo info( projectName );
694
        if( info.suffix() == QLatin1String("kdev4") ) {
695 696 697
            // make sure the project is not already opened by the session controller
            bool shouldOpen = true;
            Path path(info.absoluteFilePath());
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
698 699
            foreach(KDevelop::IProject* project, core->projectController()->projects()) {
                if (project->projectFile() == path) {
700 701
                    shouldOpen = false;
                    break;
702 703
                }
            }
704 705 706
            if (shouldOpen) {
                core->projectController()->openProject( path.toUrl() );
            }
Manuel Breugelmans's avatar
Manuel Breugelmans committed
707
        }
708
    }
709

710 711 712 713 714
    const auto fetchUrlStrings = parser.values(QStringLiteral("fetch"));
    for (const auto& fetchUrlString : fetchUrlStrings) {
        core->projectControllerInternal()->fetchProjectFromUrl(QUrl::fromUserInput(fetchUrlString));
    }

Tomaz  Canabrava's avatar
Tomaz Canabrava committed
715 716
    const QString debugStr = QStringLiteral("debug");
    if ( parser.isSet(debugStr) ) {
717 718
        Q_ASSERT( !debugeeName.isEmpty() );
        QString launchName = debugeeName;
719

720
        KDevelop::LaunchConfiguration* launch = nullptr;
Dāvis Mosāns's avatar
Dāvis Mosāns committed
721
        qCDebug(APP) << launchName;
722
        foreach (KDevelop::LaunchConfiguration *l, core->runControllerInternal()->launchConfigurationsInternal()) {
Dāvis Mosāns's avatar
Dāvis Mosāns committed
723
            qCDebug(APP) << l->name();
724 725 726 727 728
            if (l->name() == launchName) {
                launch = l;
            }
        }

729
        KDevelop::LaunchConfigurationType *type = nullptr;
730
        foreach (KDevelop::LaunchConfigurationType *t, core->runController()->launchConfigurationTypes()) {
Dāvis Mosāns's avatar
Dāvis Mosāns committed
731
            qCDebug(APP) << t->id();
732
            if (t->id() == QLatin1String("Native Application")) {
733 734 735 736 737 738 739 740 741 742
                type = t;
                break;
            }
        }
        if (!type) {
            QTextStream qerr(stderr);
            qerr << endl << i18n("Cannot find native launch configuration type") << endl;
            return 1;
        }

743
        if (launch && launch->type()->id() != QLatin1String("Native Application")) launch = nullptr;
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
744
        if (launch && launch->launcherForMode(debugStr) != parser.value(debugStr)) launch = nullptr;
745
        if (!launch) {
Dāvis Mosāns's avatar
Dāvis Mosāns committed
746
            qCDebug(APP) << launchName << "not found, creating a new one";
747
            QPair<QString,QString> launcher;
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
748
            launcher.first = debugStr;
749
            foreach (KDevelop::ILauncher *l, type->launchers()) {
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
750 751
                if (l->id() == parser.value(debugStr)) {
                    if (l->supportedModes().contains(debugStr)) {
752 753 754 755 756 757
                        launcher.second = l->id();
                    }
                }
            }
            if (launcher.second.isEmpty()) {
                QTextStream qerr(stderr);
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
758
                qerr << endl << i18n("Cannot find launcher %1", parser.value(debugStr)) << endl;
759 760
                return 1;
            }
761
            KDevelop::ILaunchConfiguration* ilaunch = core->runController()->createLaunchConfiguration(type, launcher, nullptr, launchName);
762
            launch = static_cast<KDevelop::LaunchConfiguration*>(ilaunch);
763 764 765 766 767 768
        }

        type->configureLaunchFromCmdLineArguments(launch->config(), debugArgs);
        launch->config().writeEntry("Break on Start", true);
        core->runControllerInternal()->setDefaultLaunch(launch);

Tomaz  Canabrava's avatar
Tomaz Canabrava committed
769
        core->runControllerInternal()->execute(debugStr, launch);
770
    } else {
771
        openFiles(initialFiles);
772 773 774

        for(const auto &urlinfo: initialDirectories)
            core->projectController()->openProjectForUrl(urlinfo.url);
775
    }
776

777 778 779 780 781 782 783 784 785 786
#if KDEVELOP_SINGLE_APP
    // Set up remote arguments.
    QObject::connect(&app, &SharedTools::QtSingleApplication::messageReceived,
                     &app, &KDevelopApplication::remoteArguments);

    QObject::connect(&app, &SharedTools::QtSingleApplication::fileOpenRequest,
                     &app, &KDevelopApplication::fileOpenRequested);
#endif


787 788 789
    qCDebug(APP) << "Done startup" << "- took:" << timer.elapsed() << "ms";
    timer.invalidate();

790
    return app.exec();
791
}