cpptoolseditorsupport.h 7.47 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
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
/**
 * \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
86
87
88
{
    Q_OBJECT

89
90
    typedef TextEditor::BlockRange BlockRange;

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

95
    QString fileName() const;
con's avatar
con committed
96

97
    QString contents() const;
98
    unsigned editorRevision() const;
con's avatar
con committed
99

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

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

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

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

118
119
120
121
signals:
    void documentUpdated();
    void diagnosticsChanged();
    void semanticInfoUpdated(CppTools::SemanticInfo);
Orgad Shaneh's avatar
Orgad Shaneh committed
122
    void highlighterStarted(QFuture<TextEditor::HighlightingResult> *, unsigned revision);
123
124

private slots:
125
126
    void onMimeTypeChanged();

127
128
129
    void onAboutToReload();
    void onReloadFinished();

con's avatar
con committed
130
131
132
    void updateDocument();
    void updateDocumentNow();

133
134
135
136
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
    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
163
private:
164
165
166
167
168
169
170
171
172
173
    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;
174
    bool m_fileIsBeingReloaded;
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

    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;
con's avatar
con committed
192
193
};

hjk's avatar
hjk committed
194
} // namespace CppTools
con's avatar
con committed
195
196

#endif // CPPTOOLSEDITORSUPPORT_H