cpptoolseditorsupport.h 7.66 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

con's avatar
con committed
30
31
32
#ifndef CPPTOOLSEDITORSUPPORT_H
#define CPPTOOLSEDITORSUPPORT_H

33
34
35
36
37
38
39
#include "cpphighlightingsupport.h"
#include "cppmodelmanager.h"
#include "cppsemanticinfo.h"

#include <cplusplus/CppDocument.h>

#include <QFuture>
40
41
#include <QObject>
#include <QPointer>
42
#include <QTimer>
con's avatar
con committed
43

44
namespace CPlusPlus { class AST; }
Roberto Raggi's avatar
Roberto Raggi committed
45

con's avatar
con committed
46
namespace TextEditor {
47
class BaseTextEditor;
48
class ITextMark;
49
} // namespace TextEditor
con's avatar
con committed
50
51
52

namespace CppTools {

53
54
class CppCompletionAssistProvider;

55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/**
 * \brief The CppEditorSupport class oversees the actions that happen when a C++ text editor updates
 *        its document.
 *
 * The following steps are taken:
 * 1. the text editor fires a contentsChanged() signal that triggers updateDocument
 * 2. update document will start a timer, or reset the timer if it was already running. This way
 *    subsequent updates (e.g. keypresses) get bunched together instead of running the subsequent
 *    actions for every key press
 * 3. when the timer from step 2 fires, updateDocumentNow() is triggered. That tells the
 *    model-manager to update the CPlusPlus::Document by re-indexing it.
 * 4. when the model-manager finishes, it fires a documentUpdated(CPlusPlus::Document::Ptr) signal,
 *    that is connected to onDocumentUpdated(CPlusPlus::Document::Ptr), which does 4 things:
 *    a) updates the ifdeffed-out blocks in the EditorUpdate
 *    b) calls setExtraDiagnostics with the diagnostics from the parser, which in turn calls
 *       onDiagnosticsChanged on the UI thread, and that schedules an editor update timer. When this
 *       timer fires, updateEditorNow() is called, which will apply the updates to the editor.
 *    c) a semantic-info recalculation is started in a future
 *    d) the documentUpdated() signal is emitted, which can be used by a widget to do things
 * 5. semantic-info calculation from 4c is done by a future that calls recalculateSemanticInfoNow(),
 *    which emits semanticInfoUpdated() when it is finished. Editors can also listen in on this
 *    signal to do things like highlighting the local usages.
 * 6. the semanticInfoUpdated() is connected to the startHighlighting() slot, which will start
 *    another future for doing the semantic highlighting. The highlighterStarted signal is emitted,
 *    with the highlighting future as a parameter, so editors can hook it up to a QFutureWatcher
 *    and get notifications.
 *
 * Both the semantic info calculation and the highlighting calculation will cancel an already running
 * future. They will also check that the result of a previous step is not already outdated, meaning
 * that they check the revision of the editor document to see if a user changed the document while
 * the calculation was running.
 */
class CPPTOOLS_EXPORT CppEditorSupport: public QObject
con's avatar
con committed
88
89
90
{
    Q_OBJECT

91
92
    typedef TextEditor::BlockRange BlockRange;

con's avatar
con committed
93
public:
94
    CppEditorSupport(Internal::CppModelManager *modelManager, TextEditor::BaseTextEditor *textEditor);
con's avatar
con committed
95
96
    virtual ~CppEditorSupport();

97
    QString fileName() const;
con's avatar
con committed
98

99
    QString contents() const;
100
    unsigned editorRevision() const;
con's avatar
con committed
101

102
103
    void setExtraDiagnostics(const QString &key,
                             const QList<CPlusPlus::Document::DiagnosticMessage> &messages);
104
    void setIfdefedOutBlocks(const QList<BlockRange> &ifdefedOutBlocks);
105

106
107
108
109
    /// True after the document was parsed/updated for the first time
    /// and the first semantic info calculation was started.
    bool initialized();

110
111
112
113
    /// Retrieve the semantic info, which will get recalculated on the current
    /// thread if it is outdate.
    SemanticInfo recalculateSemanticInfo(bool emitSignalWhenFinished = true);

114
115
116
    /// Recalculates the semantic info in a future, and will emit the
    /// semanticInfoUpdated() signal when finished.
    /// Requires that initialized() is true.
117
118
    /// \param force do not check if the old semantic info is still valid
    void recalculateSemanticInfoDetached(bool force = false);
119

120
121
    CppCompletionAssistProvider *completionAssistProvider() const;

122
123
124
125
signals:
    void documentUpdated();
    void diagnosticsChanged();
    void semanticInfoUpdated(CppTools::SemanticInfo);
Orgad Shaneh's avatar
Orgad Shaneh committed
126
    void highlighterStarted(QFuture<TextEditor::HighlightingResult> *, unsigned revision);
127
128

private slots:
129
130
    void onMimeTypeChanged();

131
132
133
    void onAboutToReload();
    void onReloadFinished();

con's avatar
con committed
134
135
136
    void updateDocument();
    void updateDocumentNow();

137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
    void onDocumentUpdated(CPlusPlus::Document::Ptr doc);
    void startHighlighting();

    void onDiagnosticsChanged();

    void updateEditor();
    void updateEditorNow();

private:
    struct EditorUpdates {
        EditorUpdates()
            : revision(-1)
        {}
        int revision;
        QList<QTextEdit::ExtraSelection> selections;
        QList<BlockRange> ifdefedOutBlocks;
    };

    enum {
        UpdateDocumentDefaultInterval = 150,
        UpdateEditorInterval = 300
    };

private:
    SemanticInfo::Source currentSource(bool force);
    void recalculateSemanticInfoNow(const SemanticInfo::Source &source, bool emitSignalWhenFinished,
                                    CPlusPlus::TopLevelDeclarationProcessor *processor = 0);
    void recalculateSemanticInfoDetached_helper(QFutureInterface<void> &future,
                                                SemanticInfo::Source source);

con's avatar
con committed
167
private:
168
169
170
171
172
173
174
175
176
177
    Internal::CppModelManager *m_modelManager;
    QPointer<TextEditor::BaseTextEditor> m_textEditor;
    QTimer *m_updateDocumentTimer;
    int m_updateDocumentInterval;
    unsigned m_revision;
    QFuture<void> m_documentParser;

    // content caching
    mutable QString m_cachedContents;
    mutable int m_cachedContentsEditorRevision;
178
    bool m_fileIsBeingReloaded;
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

    QTimer *m_updateEditorTimer;
    EditorUpdates m_editorUpdates;

    QMutex m_diagnosticsMutex;
    QHash<QString, QList<CPlusPlus::Document::DiagnosticMessage> > m_allDiagnostics;

    // Semantic info:
    bool m_initialized;
    mutable QMutex m_lastSemanticInfoLock;
    SemanticInfo m_lastSemanticInfo;
    QFuture<void> m_futureSemanticInfo;

    // Highlighting:
    unsigned m_lastHighlightRevision;
    QFuture<TextEditor::HighlightingResult> m_highlighter;
    QScopedPointer<CppTools::CppHighlightingSupport> m_highlightingSupport;
196
197
198

    // Completion:
    QScopedPointer<CppCompletionAssistProvider> m_completionAssistProvider;
con's avatar
con committed
199
200
};

hjk's avatar
hjk committed
201
} // namespace CppTools
con's avatar
con committed
202
203

#endif // CPPTOOLSEDITORSUPPORT_H