main.cpp 37 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.h>

32 33
#include "urlinfo.h"

34
#include <KLocalizedString>
Kevin Funk's avatar
Kevin Funk committed
35
#include <Kdelibs4ConfigMigrator>
36
#include <kaboutdata.h>
37
#include <ktexteditor/cursor.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
    KLocalizedString::setApplicationDomain("kdevelop");
318
    QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
319

René J.V. Bertin's avatar
OS X:  
René J.V. Bertin committed
320 321 322 323 324 325 326 327 328 329 330 331 332 333
#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

334 335 336 337 338 339 340 341 342 343 344
    //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
345 346
            } else if ((qstrcmp(argv[i], "--debug") == 0) || (qstrcmp(argv[i], "-d") == 0)) {
                if (argc > (i + 1)) {
347 348
                    i++;
                }
Friedrich W. H. Kossebau's avatar
Friedrich W. H. Kossebau committed
349
                argc = i + 1;
350
                debugFound = true;
Friedrich W. H. Kossebau's avatar
Friedrich W. H. Kossebau committed
351
            } else if (QString(argv[i]).startsWith(QLatin1String("--debug="))) {
352 353 354 355 356 357 358 359
                argc = i + 1;
                debugFound = true;
            }
        }
    }

    KDevelopApplication app(argc, argv);

360
    static const char description[] = I18N_NOOP( "The KDevelop Integrated Development Environment" );
361 362
    KAboutData aboutData( QStringLiteral("kdevelop"), i18n( "KDevelop" ), QByteArray(VERSION), i18n(description), KAboutLicense::GPL,
                          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{"p", "project"}, i18n("Open KDevelop and load the given project."), QStringLiteral("project")});
455 456
    parser.addOption(QCommandLineOption{QStringList{"d", "debug"},
                     i18n("Start debugging an application in KDevelop with the given debugger.\n"
457
                     "The executable that should be debugged must follow - including arguments.\n"
458
                     "Example: kdevelop --debug gdb myapp --foo bar"), QStringLiteral("debugger")});
459

460 461 462 463 464 465 466
    // 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.
467 468
    parser.addOption(QCommandLineOption{QStringList{"pid"}});

469
    parser.addPositionalArgument(QStringLiteral("files"), i18n( "Files to load" ), QStringLiteral("[FILE...]"));
470

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

474 475 476
    parser.process(app);
    aboutData.processCommandLine(&parser);

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

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

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

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

509 510
    const auto availableSessionInfos = KDevelop::SessionController::availableSessionInfos();

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

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

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

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

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

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

564
        if(candidates.size() == 1 && parser.isSet(QStringLiteral("pid")))
565 566 567 568 569
        {
            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
570

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

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

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

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

608 609
        debugArgs.first() = executableFileInfo.absoluteFilePath();
        debugeeName = i18n("Debug %1", executableFileInfo.fileName());
610
        session = debugeeName;
611
    } else if ( parser.isSet(QStringLiteral("new-session")) )
612
    {
613
        session = parser.value(QStringLiteral("new-session"));
614
        foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
615 616 617 618 619 620 621 622
        {
            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
623 624
    } else if ( parser.isSet(QStringLiteral("open-session")) ) {
        session = findSessionId(availableSessionInfos, parser.value(QStringLiteral("open-session")));
625 626
        if (session.isEmpty()) {
            return 1;
627
        }
628
    } else if ( parser.isSet(QStringLiteral("remove-session")) )
629
    {
630
        session = parser.value(QStringLiteral("remove-session"));
631
        auto si = findSessionInList(availableSessionInfos, session);
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
        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;
648
    }
649

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

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

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

675
    KDevIDEExtension::init();
676

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

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

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

688
    QStringList projectNames = parser.values(QStringLiteral("project"));
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
689
    foreach(const QString& projectName, projectNames)
690
    {
Tomaz  Canabrava's avatar
Tomaz Canabrava committed
691
        QFileInfo info( projectName );
692
        if( info.suffix() == QLatin1String("kdev4") ) {
693 694 695
            // 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
696 697
            foreach(KDevelop::IProject* project, core->projectController()->projects()) {
                if (project->projectFile() == path) {
698 699
                    shouldOpen = false;
                    break;
700 701
                }
            }
702 703 704
            if (shouldOpen) {
                core->projectController()->openProject( path.toUrl() );
            }
Manuel Breugelmans's avatar
Manuel Breugelmans committed
705
        }
706
    }
707

Tomaz  Canabrava's avatar
Tomaz Canabrava committed
708 709
    const QString debugStr = QStringLiteral("debug");
    if ( parser.isSet(debugStr) ) {
710 711
        Q_ASSERT( !debugeeName.isEmpty() );
        QString launchName = debugeeName;
712

713
        KDevelop::LaunchConfiguration* launch = nullptr;
Dāvis Mosāns's avatar
Dāvis Mosāns committed
714
        qCDebug(APP) << launchName;
715
        foreach (KDevelop::LaunchConfiguration *l, core->runControllerInternal()->launchConfigurationsInternal()) {
Dāvis Mosāns's avatar
Dāvis Mosāns committed
716
            qCDebug(APP) << l->name();
717 718 719 720 721
            if (l->name() == launchName) {
                launch = l;
            }
        }

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

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

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

Tomaz  Canabrava's avatar
Tomaz Canabrava committed
762
        core->runControllerInternal()->execute(debugStr, launch);
763
    } else {
764
        openFiles(initialFiles);
765 766 767

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

770 771 772 773 774 775 776 777 778 779
#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


780 781 782
    qCDebug(APP) << "Done startup" << "- took:" << timer.elapsed() << "ms";
    timer.invalidate();

783
    return app.exec();
784
}