cpptoolsplugin.cpp 13 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
con's avatar
con committed
2
**
3
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
hjk's avatar
hjk committed
4
** Contact: http://www.qt-project.org/legal
con's avatar
con committed
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
con's avatar
con committed
7
**
hjk's avatar
hjk committed
8 9 10 11 12 13 14
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
15
**
16
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17 18 19 20 21 22 23 24 25
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
con's avatar
con committed
26 27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
28
****************************************************************************/
hjk's avatar
hjk committed
29

30
#include "cpptoolsconstants.h"
31
#include "cpptoolsplugin.h"
32
#include "cppfilesettingspage.h"
33
#include "cppcodestylesettingspage.h"
34
#include "cppclassesfilter.h"
35
#include "cppfunctionsfilter.h"
36
#include "cppcurrentdocumentfilter.h"
con's avatar
con committed
37
#include "cppmodelmanager.h"
con's avatar
con committed
38
#include "cpplocatorfilter.h"
39
#include "symbolsfindfilter.h"
40
#include "cpptoolssettings.h"
41
#include "cpptoolsreuse.h"
42
#include "cppprojectfile.h"
con's avatar
con committed
43

44
#include <coreplugin/actionmanager/actioncontainer.h>
45 46 47 48
#include <coreplugin/actionmanager/actionmanager.h>
#include <coreplugin/coreconstants.h>
#include <coreplugin/documentmanager.h>
#include <coreplugin/icore.h>
49
#include <coreplugin/vcsmanager.h>
con's avatar
con committed
50
#include <cppeditor/cppeditorconstants.h>
51

52
#include <utils/hostosinfo.h>
53
#include <utils/qtcassert.h>
54

55 56 57 58 59 60
#include <QtPlugin>
#include <QFileInfo>
#include <QDir>
#include <QDebug>
#include <QMenu>
#include <QAction>
61 62

using namespace CPlusPlus;
con's avatar
con committed
63

64 65 66
namespace CppTools {
namespace Internal {

con's avatar
con committed
67 68
enum { debug = 0 };

69
static CppToolsPlugin *m_instance = 0;
70
static QHash<QString, QString> m_headerSourceMapping;
con's avatar
con committed
71

72 73
CppToolsPlugin::CppToolsPlugin() :
    m_fileSettings(new CppFileSettings)
con's avatar
con committed
74 75 76 77 78 79 80
{
    m_instance = this;
}

CppToolsPlugin::~CppToolsPlugin()
{
    m_instance = 0;
81
    delete CppModelManager::instance();
con's avatar
con committed
82 83
}

84 85 86 87 88
CppToolsPlugin *CppToolsPlugin::instance()
{
    return m_instance;
}

89
bool CppToolsPlugin::initialize(const QStringList &arguments, QString *error)
con's avatar
con committed
90
{
91 92
    Q_UNUSED(arguments)
    Q_UNUSED(error)
93

94 95
    m_settings = new CppToolsSettings(this); // force registration of cpp tools settings

con's avatar
con committed
96
    // Objects
97
    CppModelManager *modelManager = CppModelManager::instance();
hjk's avatar
hjk committed
98
    Core::VcsManager *vcsManager = Core::ICore::vcsManager();
99
    connect(vcsManager, SIGNAL(repositoryChanged(QString)),
100
            modelManager, SLOT(updateModifiedSourceFiles()));
101
    connect(Core::DocumentManager::instance(), SIGNAL(filesChangedInternally(QStringList)),
102
            modelManager, SLOT(updateSourceFiles(QStringList)));
Roberto Raggi's avatar
Roberto Raggi committed
103

104 105 106
    addAutoReleasedObject(new CppLocatorFilter(modelManager));
    addAutoReleasedObject(new CppClassesFilter(modelManager));
    addAutoReleasedObject(new CppFunctionsFilter(modelManager));
107
    addAutoReleasedObject(new CppCurrentDocumentFilter(modelManager));
108
    addAutoReleasedObject(new CppFileSettingsPage(m_fileSettings));
109
    addAutoReleasedObject(new SymbolsFindFilter(modelManager));
110 111
    addAutoReleasedObject(new CppCodeStyleSettingsPage);

con's avatar
con committed
112
    // Menus
Eike Ziller's avatar
Eike Ziller committed
113 114
    Core::ActionContainer *mtools = Core::ActionManager::actionContainer(Core::Constants::M_TOOLS);
    Core::ActionContainer *mcpptools = Core::ActionManager::createMenu(CppTools::Constants::M_TOOLS_CPP);
con's avatar
con committed
115 116 117 118 119 120
    QMenu *menu = mcpptools->menu();
    menu->setTitle(tr("&C++"));
    menu->setEnabled(true);
    mtools->addMenu(mcpptools);

    // Actions
121
    Core::Context context(CppEditor::Constants::C_CPPEDITOR);
con's avatar
con committed
122 123

    QAction *switchAction = new QAction(tr("Switch Header/Source"), this);
Eike Ziller's avatar
Eike Ziller committed
124
    Core::Command *command = Core::ActionManager::registerAction(switchAction, Constants::SWITCH_HEADER_SOURCE, context, true);
con's avatar
con committed
125 126 127 128
    command->setDefaultKeySequence(QKeySequence(Qt::Key_F4));
    mcpptools->addAction(command);
    connect(switchAction, SIGNAL(triggered()), this, SLOT(switchHeaderSource()));

129
    QAction *openInNextSplitAction = new QAction(tr("Open Corresponding Header/Source in Next Split"), this);
130
    command = Core::ActionManager::registerAction(openInNextSplitAction, Constants::OPEN_HEADER_SOURCE_IN_NEXT_SPLIT, context, true);
131 132 133
    command->setDefaultKeySequence(QKeySequence(Utils::HostOsInfo::isMacHost()
                                                ? tr("Meta+E, F4")
                                                : tr("Ctrl+E, F4")));
134 135 136
    mcpptools->addAction(command);
    connect(openInNextSplitAction, SIGNAL(triggered()), this, SLOT(switchHeaderSourceInNextSplit()));

con's avatar
con committed
137 138 139 140 141
    return true;
}

void CppToolsPlugin::extensionsInitialized()
{
142 143
    // The Cpp editor plugin, which is loaded later on, registers the Cpp mime types,
    // so, apply settings here
hjk's avatar
hjk committed
144
    m_fileSettings->fromSettings(Core::ICore::settings());
145 146
    if (!m_fileSettings->applySuffixesToMimeDB())
        qWarning("Unable to apply cpp suffixes to mime database (cpp mime types not found).\n");
con's avatar
con committed
147 148
}

149
ExtensionSystem::IPlugin::ShutdownFlag CppToolsPlugin::aboutToShutdown()
150
{
151
    return SynchronousShutdown;
152 153
}

con's avatar
con committed
154 155
void CppToolsPlugin::switchHeaderSource()
{
156
    QString otherFile = correspondingHeaderOrSource(
157
                Core::EditorManager::currentDocument()->filePath());
158 159 160 161 162 163 164
    if (!otherFile.isEmpty())
        Core::EditorManager::openEditor(otherFile);
}

void CppToolsPlugin::switchHeaderSourceInNextSplit()
{
    QString otherFile = correspondingHeaderOrSource(
165
                Core::EditorManager::currentDocument()->filePath());
166
    if (!otherFile.isEmpty())
Eike Ziller's avatar
Eike Ziller committed
167
        Core::EditorManager::openEditor(otherFile, Core::Id(), Core::EditorManager::OpenInOtherSplit);
con's avatar
con committed
168 169
}

170
static QStringList findFilesInProject(const QString &name,
171
                                   const ProjectExplorer::Project *project)
con's avatar
con committed
172 173
{
    if (debug)
174 175 176
        qDebug() << Q_FUNC_INFO << name << project;

    if (!project)
177
        return QStringList();
178 179 180 181 182

    QString pattern = QString(1, QLatin1Char('/'));
    pattern += name;
    const QStringList projectFiles = project->files(ProjectExplorer::Project::AllFiles);
    const QStringList::const_iterator pcend = projectFiles.constEnd();
183
    QStringList candidateList;
184 185
    for (QStringList::const_iterator it = projectFiles.constBegin(); it != pcend; ++it) {
        if (it->endsWith(pattern))
186
            candidateList.append(*it);
con's avatar
con committed
187
    }
188
    return candidateList;
con's avatar
con committed
189 190 191 192
}

// Return the suffixes that should be checked when trying to find a
// source belonging to a header and vice versa
193
static QStringList matchingCandidateSuffixes(ProjectFile::Kind kind)
con's avatar
con committed
194
{
195 196 197 198 199 200 201 202 203
    Core::MimeDatabase *md = Core::ICore::instance()->mimeDatabase();
    switch (kind) {
     // Note that C/C++ headers are undistinguishable
    case ProjectFile::CHeader:
    case ProjectFile::CXXHeader:
    case ProjectFile::ObjCHeader:
    case ProjectFile::ObjCXXHeader:
        return md->findByType(QLatin1String(Constants::C_SOURCE_MIMETYPE)).suffixes()
                + md->findByType(QLatin1String(Constants::CPP_SOURCE_MIMETYPE)).suffixes()
204
                + md->findByType(QLatin1String(Constants::OBJECTIVE_C_SOURCE_MIMETYPE)).suffixes()
205 206 207 208 209 210 211 212 213 214 215
                + md->findByType(QLatin1String(Constants::OBJECTIVE_CPP_SOURCE_MIMETYPE)).suffixes();
    case ProjectFile::CSource:
    case ProjectFile::ObjCSource:
        return md->findByType(QLatin1String(Constants::C_HEADER_MIMETYPE)).suffixes();
    case ProjectFile::CXXSource:
    case ProjectFile::ObjCXXSource:
    case ProjectFile::CudaSource:
    case ProjectFile::OpenCLSource:
        return md->findByType(QLatin1String(Constants::CPP_HEADER_MIMETYPE)).suffixes();
    default:
        return QStringList();
con's avatar
con committed
216 217 218
    }
}

219 220 221 222 223 224 225 226 227 228 229 230 231
static QStringList baseNameWithAllSuffixes(const QString &baseName, const QStringList &suffixes)
{
    QStringList result;
    const QChar dot = QLatin1Char('.');
    foreach (const QString &suffix, suffixes) {
        QString fileName = baseName;
        fileName += dot;
        fileName += suffix;
        result += fileName;
    }
    return result;
}

232 233 234 235 236 237 238 239 240
static int commonStringLength(const QString &s1, const QString &s2)
{
    int length = qMin(s1.length(), s2.length());
    for (int i = 0; i < length; ++i)
        if (s1[i] != s2[i])
            return i;
    return length;
}

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
static QString correspondingHeaderOrSourceInProject(const QFileInfo &fileInfo,
                                                    const QStringList &candidateFileNames,
                                                    const ProjectExplorer::Project *project)
{
    QString bestFileName;
    int compareValue = 0;
    const QString filePath = fileInfo.filePath();
    foreach (const QString &candidateFileName, candidateFileNames) {
        const QStringList projectFiles = findFilesInProject(candidateFileName, project);
        // Find the file having the most common path with fileName
        foreach (const QString &projectFile, projectFiles) {
            int value = commonStringLength(filePath, projectFile);
            if (value > compareValue) {
                compareValue = value;
                bestFileName = projectFile;
            }
        }
    }
    if (!bestFileName.isEmpty()) {
        const QFileInfo candidateFi(bestFileName);
        QTC_ASSERT(candidateFi.isFile(), return QString());
        m_headerSourceMapping[fileInfo.absoluteFilePath()] = candidateFi.absoluteFilePath();
        m_headerSourceMapping[candidateFi.absoluteFilePath()] = fileInfo.absoluteFilePath();
        return candidateFi.absoluteFilePath();
    }

    return QString();
}

270 271 272
} // namespace Internal

QString correspondingHeaderOrSource(const QString &fileName, bool *wasHeader)
con's avatar
con committed
273
{
274
    using namespace Internal;
275

276
    const QFileInfo fi(fileName);
277 278
    ProjectFile::Kind kind = ProjectFile::classify(fileName);
    const bool isHeader = ProjectFile::isHeader(kind);
279
    if (wasHeader)
280 281
        *wasHeader = isHeader;
    if (m_headerSourceMapping.contains(fi.absoluteFilePath()))
282
        return m_headerSourceMapping.value(fi.absoluteFilePath());
con's avatar
con committed
283 284

    if (debug)
285
        qDebug() << Q_FUNC_INFO << fileName <<  kind;
con's avatar
con committed
286

287
    if (kind == ProjectFile::Unclassified)
con's avatar
con committed
288 289
        return QString();

290
    const QString baseName = fi.completeBaseName();
291
    const QString privateHeaderSuffix = QLatin1String("_p");
292
    const QStringList suffixes = matchingCandidateSuffixes(kind);
con's avatar
con committed
293

294
    QStringList candidateFileNames = baseNameWithAllSuffixes(baseName, suffixes);
295
    if (isHeader) {
con's avatar
con committed
296 297 298
        if (baseName.endsWith(privateHeaderSuffix)) {
            QString sourceBaseName = baseName;
            sourceBaseName.truncate(sourceBaseName.size() - privateHeaderSuffix.size());
299
            candidateFileNames += baseNameWithAllSuffixes(sourceBaseName, suffixes);
con's avatar
con committed
300 301
        }
    } else {
302 303 304 305 306 307 308 309
        QString privateHeaderBaseName = baseName;
        privateHeaderBaseName.append(privateHeaderSuffix);
        candidateFileNames += baseNameWithAllSuffixes(privateHeaderBaseName, suffixes);
    }

    const QDir absoluteDir = fi.absoluteDir();

    // Try to find a file in the same directory first
310 311
    foreach (const QString &candidateFileName, candidateFileNames) {
        const QFileInfo candidateFi(absoluteDir, candidateFileName);
312 313
        if (candidateFi.isFile()) {
            m_headerSourceMapping[fi.absoluteFilePath()] = candidateFi.absoluteFilePath();
314
            if (!isHeader || !baseName.endsWith(privateHeaderSuffix))
315
                m_headerSourceMapping[candidateFi.absoluteFilePath()] = fi.absoluteFilePath();
316
            return candidateFi.absoluteFilePath();
317
        }
318 319
    }

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
    // Find files in the current project
    ProjectExplorer::Project *currentProject = ProjectExplorer::ProjectExplorerPlugin::currentProject();
    if (currentProject) {
        const QString path = correspondingHeaderOrSourceInProject(fi, candidateFileNames,
                                                                  currentProject);
        if (!path.isEmpty())
            return path;
    }

    // Find files in other projects
    CppModelManager *modelManager = CppModelManager::instance();
    QList<CppModelManagerInterface::ProjectInfo> projectInfos = modelManager->projectInfos();
    foreach (const CppModelManagerInterface::ProjectInfo &projectInfo, projectInfos) {
        const ProjectExplorer::Project *project = projectInfo.project().data();
        if (project == currentProject)
            continue; // We have already checked the current project.

        const QString path = correspondingHeaderOrSourceInProject(fi, candidateFileNames, project);
        if (!path.isEmpty())
            return path;
con's avatar
con committed
340
    }
341

con's avatar
con committed
342 343 344
    return QString();
}

345
} // namespace CppTools
con's avatar
con committed
346

347
Q_EXPORT_PLUGIN(CppTools::Internal::CppToolsPlugin)