feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
f753d3328b571ff2d9f1b3683a59e6100a8cdd49
qt-creator/src/plugins/qmljseditor/qmlcodecompletion.cpp

1083 lines
34 KiB
C++
Raw Blame History

/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** 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.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/
#include "qmlcodecompletion.h"
#include "qmljseditor.h"
#include "qmlmodelmanagerinterface.h"
#include "qmllookupcontext.h"
#include <qmljs/parser/qmljsast_p.h>
#include <qmljs/qmljsbind.h>
#include <qmljs/qmljsinterpreter.h>
#include <qmljs/qmljssymbol.h>
#include <qmljs/qmljsscanner.h>
#include <qmljs/qmljscheck.h>
#include <texteditor/basetexteditor.h>
#include <coreplugin/icore.h>
#include <coreplugin/editormanager/editormanager.h>
#include <QtCore/QFile>
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
#include <QtCore/QXmlStreamReader>
#include <QtCore/QDebug>
#include <QtGui/QPainter>
#include <QtGui/QLabel>
#include <QtGui/QStylePainter>
#include <QtGui/QStyleOption>
#include <QtGui/QToolButton>
#include <QtGui/QHBoxLayout>
#include <QtGui/QApplication>
#include <QtGui/QDesktopWidget>
using namespace QmlJSEditor;
using namespace QmlJSEditor::Internal;
using namespace QmlJS;
// Temporary workaround until we have proper icons for QML completion items
static QIcon iconForColor(const QColor &color)
{
QPixmap pix(6, 6);
int pixSize = 20;
QBrush br(color);
QPixmap pm(2 * pixSize, 2 * pixSize);
QPainter pmp(&pm);
pmp.fillRect(0, 0, pixSize, pixSize, Qt::lightGray);
pmp.fillRect(pixSize, pixSize, pixSize, pixSize, Qt::lightGray);
pmp.fillRect(0, pixSize, pixSize, pixSize, Qt::darkGray);
pmp.fillRect(pixSize, 0, pixSize, pixSize, Qt::darkGray);
pmp.fillRect(0, 0, 2 * pixSize, 2 * pixSize, color);
br = QBrush(pm);
QPainter p(&pix);
int corr = 1;
QRect r = pix.rect().adjusted(corr, corr, -corr, -corr);
p.setBrushOrigin((r.width() % pixSize + pixSize) / 2 + corr, (r.height() % pixSize + pixSize) / 2 + corr);
p.fillRect(r, br);
p.fillRect(r.width() / 4 + corr, r.height() / 4 + corr,
r.width() / 2, r.height() / 2,
QColor(color.rgb()));
p.drawRect(pix.rect().adjusted(0, 0, -1, -1));
return pix;
}
static QString qualifiedNameId(AST::UiQualifiedId *it)
{
QString text;
for (; it; it = it->next) {
if (! it->name)
continue;
text += it->name->asString();
if (it->next)
text += QLatin1Char('.');
}
return text;
}
#if 0
static Interpreter::ObjectValue *newComponent(Interpreter::Engine *engine, const QString &name,
const QHash<QString, Document::Ptr> &userComponents,
QSet<QString> *processed)
{
if (Interpreter::ObjectValue *object = engine->newQmlObject(name))
return object;
else if (! processed->contains(name)) {
processed->insert(name);
if (Document::Ptr doc = userComponents.value(name)) {
if (AST::UiProgram *program = doc->qmlProgram()) {
if (program->members) {
if (AST::UiObjectDefinition *def = AST::cast<AST::UiObjectDefinition *>(program->members->member)) {
const QString component = qualifiedNameId(def->qualifiedTypeNameId);
Interpreter::ObjectValue *object = newComponent(engine, component, userComponents, processed);
if (def->initializer) {
for (AST::UiObjectMemberList *it = def->initializer->members; it; it = it->next) {
if (AST::UiPublicMember *prop = AST::cast<AST::UiPublicMember *>(it->member)) {
if (prop->name && prop->memberType) {
const QString propName = prop->name->asString();
const QString propType = prop->memberType->asString();
object->setProperty(propName, engine->defaultValueForBuiltinType(propType));
}
}
}
}
return object;
}
}
}
}
}
return 0;
}
static Interpreter::ObjectValue *newComponent(Interpreter::Engine *engine,
const QString &name,
const QHash<QString, Document::Ptr> &userComponents)
{
QSet<QString> processed;
return newComponent(engine, name, userComponents, &processed);
}
#endif
namespace {
class ExpressionUnderCursor
{
QTextCursor _cursor;
QmlJSScanner scanner;
public:
QString operator()(const QTextCursor &cursor)
{
_cursor = cursor;
QTextBlock block = _cursor.block();
const QString blockText = block.text().left(cursor.columnNumber());
//qDebug() << "block text:" << blockText;
int startState = block.previous().userState();
if (startState == -1)
startState = 0;
else
startState = startState & 0xff;
const QList<Token> originalTokens = scanner(blockText, startState);
QList<Token> tokens;
int skipping = 0;
for (int index = originalTokens.size() - 1; index != -1; --index) {
const Token &tk = originalTokens.at(index);
if (tk.is(Token::Comment) || tk.is(Token::String) || tk.is(Token::Number))
continue;
if (! skipping) {
tokens.append(tk);
if (tk.is(Token::Identifier)) {
if (index > 0 && originalTokens.at(index - 1).isNot(Token::Dot))
break;
}
} else {
//qDebug() << "skip:" << blockText.mid(tk.offset, tk.length);
}
if (tk.is(Token::RightParenthesis) || tk.is(Token::RightBracket))
++skipping;
else if (tk.is(Token::LeftParenthesis) || tk.is(Token::LeftBracket)) {
--skipping;
if (! skipping)
tokens.append(tk);
if (index > 0 && originalTokens.at(index - 1).isNot(Token::Identifier))
break;
}
}
if (! tokens.isEmpty()) {
QString expr;
for (int index = tokens.size() - 1; index >= 0; --index) {
Token tk = tokens.at(index);
expr.append(QLatin1Char(' '));
expr.append(blockText.midRef(tk.offset, tk.length));
}
//qDebug() << "expression under cursor:" << expr;
return expr;
}
//qDebug() << "no expression";
return QString();
}
};
class SearchPropertyDefinitions: protected AST::Visitor
{
QList<AST::UiPublicMember *> _properties;
public:
QList<AST::UiPublicMember *> operator()(Document::Ptr doc)
{
_properties.clear();
if (doc && doc->qmlProgram())
doc->qmlProgram()->accept(this);
return _properties;
}
protected:
using AST::Visitor::visit;
virtual bool visit(AST::UiPublicMember *member)
{
if (member->propertyToken.isValid()) {
_properties.append(member);
}
return true;
}
};
class EnumerateProperties: private Interpreter::MemberProcessor
{
QSet<const Interpreter::ObjectValue *> _processed;
QHash<QString, const Interpreter::Value *> _properties;
bool _globalCompletion;
public:
EnumerateProperties()
: _globalCompletion(false)
{
}
void setGlobalCompletion(bool globalCompletion)
{
_globalCompletion = globalCompletion;
}
QHash<QString, const Interpreter::Value *> operator()(const Interpreter::Value *value,
bool lookAtScope = false)
{
_processed.clear();
_properties.clear();
enumerateProperties(value, lookAtScope);
return _properties;
}
private:
virtual bool processProperty(const QString &name, const Interpreter::Value *value)
{
_properties.insert(name, value);
return true;
}
virtual bool processSignal(const QString &, const Interpreter::Value *)
{
return true;
}
virtual bool processSlot(const QString &name, const Interpreter::Value *value)
{
if (! _globalCompletion)
_properties.insert(name, value);
return true;
}
virtual bool processGeneratedSlot(const QString &name, const Interpreter::Value *value)
{
if (_globalCompletion)
_properties.insert(name, value);
return true;
}
void enumerateProperties(const Interpreter::Value *value, bool lookAtScope)
{
if (! value)
return;
else if (const Interpreter::ObjectValue *object = value->asObjectValue()) {
enumerateProperties(object, lookAtScope);
}
}
void enumerateProperties(const Interpreter::ObjectValue *object, bool lookAtScope)
{
if (! object || _processed.contains(object))
return;
_processed.insert(object);
enumerateProperties(object->prototype(), /* lookAtScope = */ false);
if (lookAtScope)
enumerateProperties(object->scope(), /* lookAtScope = */ true);
object->processMembers(this);
}
};
} // end of anonymous namespace
namespace QmlJSEditor {
namespace Internal {
class FakeToolTipFrame : public QWidget
{
public:
FakeToolTipFrame(QWidget *parent = 0) :
QWidget(parent, Qt::ToolTip | Qt::WindowStaysOnTopHint)
{
setFocusPolicy(Qt::NoFocus);
setAttribute(Qt::WA_DeleteOnClose);
// Set the window and button text to the tooltip text color, since this
// widget draws the background as a tooltip.
QPalette p = palette();
const QColor toolTipTextColor = p.color(QPalette::Inactive, QPalette::ToolTipText);
p.setColor(QPalette::Inactive, QPalette::WindowText, toolTipTextColor);
p.setColor(QPalette::Inactive, QPalette::ButtonText, toolTipTextColor);
setPalette(p);
}
protected:
void paintEvent(QPaintEvent *e);
void resizeEvent(QResizeEvent *e);
};
class FunctionArgumentWidget : public QLabel
{
public:
FunctionArgumentWidget();
void showFunctionHint(const QString &functionName,
const QStringList &signature,
int startPosition);
protected:
bool eventFilter(QObject *obj, QEvent *e);
private:
void updateArgumentHighlight();
void updateHintText();
QString m_functionName;
QStringList m_signature;
int m_minimumArgumentCount;
int m_startpos;
int m_currentarg;
int m_current;
bool m_escapePressed;
TextEditor::ITextEditor *m_editor;
QWidget *m_pager;
QLabel *m_numberLabel;
FakeToolTipFrame *m_popupFrame;
};
void FakeToolTipFrame::paintEvent(QPaintEvent *)
{
QStylePainter p(this);
QStyleOptionFrame opt;
opt.init(this);
p.drawPrimitive(QStyle::PE_PanelTipLabel, opt);
p.end();
}
void FakeToolTipFrame::resizeEvent(QResizeEvent *)
{
QStyleHintReturnMask frameMask;
QStyleOption option;
option.init(this);
if (style()->styleHint(QStyle::SH_ToolTip_Mask, &option, this, &frameMask))
setMask(frameMask.region);
}
FunctionArgumentWidget::FunctionArgumentWidget():
m_minimumArgumentCount(0),
m_startpos(-1),
m_current(0),
m_escapePressed(false)
{
QObject *editorObject = Core::EditorManager::instance()->currentEditor();
m_editor = qobject_cast<TextEditor::ITextEditor *>(editorObject);
m_popupFrame = new FakeToolTipFrame(m_editor->widget());
setParent(m_popupFrame);
setFocusPolicy(Qt::NoFocus);
m_pager = new QWidget;
QHBoxLayout *hbox = new QHBoxLayout(m_pager);
hbox->setMargin(0);
hbox->setSpacing(0);
m_numberLabel = new QLabel;
hbox->addWidget(m_numberLabel);
QHBoxLayout *layout = new QHBoxLayout;
layout->setMargin(0);
layout->setSpacing(0);
layout->addWidget(m_pager);
layout->addWidget(this);
m_popupFrame->setLayout(layout);
setTextFormat(Qt::RichText);
setMargin(1);
qApp->installEventFilter(this);
}
void FunctionArgumentWidget::showFunctionHint(const QString &functionName, const QStringList &signature, int startPosition)
{
if (m_startpos == startPosition)
return;
m_functionName = functionName;
m_signature = signature;
m_minimumArgumentCount = signature.size();
m_startpos = startPosition;
m_current = 0;
m_escapePressed = false;
// update the text
m_currentarg = -1;
updateArgumentHighlight();
m_popupFrame->show();
}
void FunctionArgumentWidget::updateArgumentHighlight()
{
int curpos = m_editor->position();
if (curpos < m_startpos) {
m_popupFrame->close();
return;
}
updateHintText();
QString str = m_editor->textAt(m_startpos, curpos - m_startpos);
int argnr = 0;
int parcount = 0;
QmlJSScanner tokenize;
const QList<Token> tokens = tokenize(str);
for (int i = 0; i < tokens.count(); ++i) {
const Token &tk = tokens.at(i);
if (tk.is(Token::LeftParenthesis))
++parcount;
else if (tk.is(Token::RightParenthesis))
--parcount;
else if (! parcount && tk.is(Token::Colon))
++argnr;
}
if (m_currentarg != argnr) {
// m_currentarg = argnr;
updateHintText();
}
if (parcount < 0)
m_popupFrame->close();
}
bool FunctionArgumentWidget::eventFilter(QObject *obj, QEvent *e)
{
switch (e->type()) {
case QEvent::ShortcutOverride:
if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Escape) {
m_escapePressed = true;
}
break;
case QEvent::KeyPress:
if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Escape) {
m_escapePressed = true;
}
break;
case QEvent::KeyRelease:
if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Escape && m_escapePressed) {
m_popupFrame->close();
return false;
}
updateArgumentHighlight();
break;
case QEvent::WindowDeactivate:
case QEvent::FocusOut:
if (obj != m_editor->widget())
break;
m_popupFrame->close();
break;
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::Wheel: {
QWidget *widget = qobject_cast<QWidget *>(obj);
if (! (widget == this || m_popupFrame->isAncestorOf(widget))) {
m_popupFrame->close();
}
}
break;
default:
break;
}
return false;
}
void FunctionArgumentWidget::updateHintText()
{
QString prettyMethod;
prettyMethod += QString::fromLatin1("function ");
prettyMethod += m_functionName;
prettyMethod += QLatin1Char('(');
for (int i = 0; i < m_minimumArgumentCount; ++i) {
if (i != 0)
prettyMethod += QLatin1String(", ");
prettyMethod += QLatin1String("arg");
if (m_minimumArgumentCount != 1)
prettyMethod += QString::number(i + 1);
}
prettyMethod += QLatin1Char(')');
m_numberLabel->setText(prettyMethod);
m_popupFrame->setFixedWidth(m_popupFrame->minimumSizeHint().width());
const QDesktopWidget *desktop = QApplication::desktop();
#ifdef Q_WS_MAC
const QRect screen = desktop->availableGeometry(desktop->screenNumber(m_editor->widget()));
#else
const QRect screen = desktop->screenGeometry(desktop->screenNumber(m_editor->widget()));
#endif
const QSize sz = m_popupFrame->sizeHint();
QPoint pos = m_editor->cursorRect(m_startpos).topLeft();
pos.setY(pos.y() - sz.height() - 1);
if (pos.x() + sz.width() > screen.right())
pos.setX(screen.right() - sz.width());
m_popupFrame->move(pos);
}
} } // end of namespace QmlJSEditor::Internal
QmlCodeCompletion::QmlCodeCompletion(QmlModelManagerInterface *modelManager, QmlJS::TypeSystem *typeSystem, QObject *parent)
: TextEditor::ICompletionCollector(parent),
m_modelManager(modelManager),
m_editor(0),
m_startPosition(0),
m_caseSensitivity(Qt::CaseSensitive),
m_typeSystem(typeSystem)
{
Q_ASSERT(modelManager);
Q_ASSERT(typeSystem);
}
QmlCodeCompletion::~QmlCodeCompletion()
{ }
Qt::CaseSensitivity QmlCodeCompletion::caseSensitivity() const
{ return m_caseSensitivity; }
void QmlCodeCompletion::setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)
{ m_caseSensitivity = caseSensitivity; }
TextEditor::ITextEditable *QmlCodeCompletion::editor() const
{ return m_editor; }
int QmlCodeCompletion::startPosition() const
{ return m_startPosition; }
bool QmlCodeCompletion::supportsEditor(TextEditor::ITextEditable *editor)
{
if (qobject_cast<QmlJSTextEditor *>(editor->widget()))
return true;
return false;
}
bool QmlCodeCompletion::triggersCompletion(TextEditor::ITextEditable *editor)
{
const QChar ch = editor->characterAt(editor->position() - 1);
if (ch == QLatin1Char('(') || ch == QLatin1Char('.'))
return true;
return false;
}
bool QmlCodeCompletion::isImported(Document::Ptr doc, const QString &currentFilePath) const
{
if (! (doc && doc->qmlProgram()))
return false;
QFileInfo fileInfo(doc->fileName());
const QString absolutePath = fileInfo.absolutePath();
for (AST::UiImportList *it = doc->qmlProgram()->imports; it; it = it->next) {
if (! (it->import && it->import->fileName))
continue;
QString path = absolutePath;
path += QLatin1Char('/');
path += it->import->fileName->asString();
path = QDir::cleanPath(path);
if (path == currentFilePath)
return true;
}
return false;
}
bool QmlCodeCompletion::isDelimiter(const QChar &ch) const
{
switch (ch.unicode()) {
case '{':
case '}':
case '[':
case ']':
case '?':
case ':':
case ';':
case ',':
return true;
default:
return false;
}
}
int QmlCodeCompletion::startCompletion(TextEditor::ITextEditable *editor)
{
m_editor = editor;
QmlJSTextEditor *edit = qobject_cast<QmlJSTextEditor *>(m_editor->widget());
if (! edit)
return -1;
m_startPosition = editor->position();
const QString fileName = editor->file()->fileName();
while (editor->characterAt(m_startPosition - 1).isLetterOrNumber() ||
editor->characterAt(m_startPosition - 1) == QLatin1Char('_'))
--m_startPosition;
m_completions.clear();
QmlJS::Snapshot snapshot = m_modelManager->snapshot();
SemanticInfo semanticInfo = edit->semanticInfo();
Document::Ptr qmlDocument = semanticInfo.document;
if (qmlDocument.isNull())
return -1;
const QFileInfo currentFileInfo(fileName);
const QString currentFilePath = currentFileInfo.absolutePath();
bool isQmlFile = false;
if (currentFileInfo.suffix() == QLatin1String("qml"))
isQmlFile = true;
const QIcon componentIcon = iconForColor(Qt::yellow);
const QIcon symbolIcon = iconForColor(Qt::darkCyan);
Interpreter::Engine interp;
QHash<QString, Document::Ptr> userComponents; // ####
foreach (Document::Ptr doc, snapshot) {
const QFileInfo fileInfo(doc->fileName());
const QString absolutePath = fileInfo.absolutePath();
// ### generalize
if (fileInfo.suffix() != QLatin1String("qml"))
continue;
else if (absolutePath != currentFilePath && ! isImported(qmlDocument, absolutePath))
continue;
const QString typeName = fileInfo.baseName();
if (typeName.isEmpty() || ! typeName.at(0).isUpper())
continue;
userComponents.insert(typeName, doc);
}
foreach (Document::Ptr doc, snapshot) {
const QFileInfo fileInfo(doc->fileName());
const QString absolutePath = fileInfo.absolutePath();
// ### generalize
if (fileInfo.suffix() != QLatin1String("qml"))
continue;
else if (absolutePath != currentFilePath && ! isImported(qmlDocument, absolutePath))
continue;
#if 0
QMapIterator<QString, IdSymbol *> it(doc->ids());
while (it.hasNext()) {
it.next();
if (IdSymbol *symbol = it.value()) {
const QString id = it.key();
if (symbol->parentNode()) {
const QString component = symbol->parentNode()->name();
if (const Interpreter::ObjectValue *object = newComponent(&interp, component, userComponents)) {
interp.globalObject()->setProperty(id, object);
}
}
}
}
#endif
}
// Set up the current scope chain.
Interpreter::ObjectValue *scope = interp.globalObject();
if (isQmlFile) {
scope = interp.newObject(/* prototype = */ 0);
AST::UiObjectMember *declaringMember = 0;
AST::UiObjectMember *parentMember = 0;
const int cursorPosition = editor->position();
foreach (const Range &range, semanticInfo.ranges) {
if (cursorPosition >= range.begin.position() && cursorPosition <= range.end.position()) {
parentMember = declaringMember;
declaringMember = range.ast;
}
}
#if 0
// ### TODO: remove me. This is just a quick and dirty hack to get some completion
// for the property definitions.
SearchPropertyDefinitions searchPropertyDefinitions;
const QList<AST::UiPublicMember *> properties = searchPropertyDefinitions(qmlDocument);
foreach (AST::UiPublicMember *prop, properties) {
if (! (prop->name && prop->memberType))
continue;
const QString propName = prop->name->asString();
const QString propType = prop->memberType->asString();
interp.globalObject()->setProperty(propName, interp.defaultValueForBuiltinType(propType));
}
// Get the name of the declaring item.
QString declaringItemName = QLatin1String("Item");
if (AST::UiObjectDefinition *binding = AST::cast<AST::UiObjectDefinition *>(declaringMember))
declaringItemName = qualifiedNameId(binding->qualifiedTypeNameId);
else if (AST::UiObjectBinding *binding = AST::cast<AST::UiObjectBinding *>(declaringMember))
declaringItemName = qualifiedNameId(binding->qualifiedTypeNameId);
Interpreter::ObjectValue *declaringItem = newComponent(&interp, declaringItemName, userComponents);
if (! declaringItem)
declaringItem = interp.newQmlObject(QLatin1String("Item"));
if (declaringItem) {
scope->setScope(declaringItem);
declaringItem->setScope(interp.globalObject());
}
// Get the name of the parent of the declaring item.
QString parentItemName = QLatin1String("Item");
if (AST::UiObjectDefinition *binding = AST::cast<AST::UiObjectDefinition *>(parentMember))
parentItemName = qualifiedNameId(binding->qualifiedTypeNameId);
else if (AST::UiObjectBinding *binding = AST::cast<AST::UiObjectBinding *>(parentMember))
parentItemName = qualifiedNameId(binding->qualifiedTypeNameId);
Interpreter::ObjectValue *parentItem = newComponent(&interp, parentItemName, userComponents);
if (! parentItem)
parentItem = interp.newQmlObject(QLatin1String("Item"));
if (parentItem)
scope->setProperty(QLatin1String("parent"), parentItem);
#endif
Bind bind;
scope = bind(qmlDocument, snapshot, declaringMember, interp);
}
// Search for the operator that triggered the completion.
QChar completionOperator;
if (m_startPosition > 0)
completionOperator = editor->characterAt(m_startPosition - 1);
if (completionOperator.isSpace() || completionOperator.isNull() || isDelimiter(completionOperator) ||
(completionOperator == QLatin1Char('(') && m_startPosition != editor->position())) {
// It's a global completion.
// Process the visible user defined components.
QHashIterator<QString, Document::Ptr> componentIt(userComponents);
while (componentIt.hasNext()) {
componentIt.next();
TextEditor::CompletionItem item(this);
item.text = componentIt.key();
item.icon = componentIcon;
m_completions.append(item);
}
EnumerateProperties enumerateProperties;
enumerateProperties.setGlobalCompletion(true);
QHashIterator<QString, const Interpreter::Value *> it(enumerateProperties(scope, /* lookAtScope = */ true));
while (it.hasNext()) {
it.next();
TextEditor::CompletionItem item(this);
item.text = it.key();
item.icon = symbolIcon;
m_completions.append(item);
}
}
else if (completionOperator == QLatin1Char('.') || completionOperator == QLatin1Char('(')) {
// Look at the expression under cursor.
QTextCursor tc = edit->textCursor();
tc.setPosition(m_startPosition - 1);
ExpressionUnderCursor expressionUnderCursor;
const QString expression = expressionUnderCursor(tc);
//qDebug() << "expression:" << expression;
// Wrap the expression in a QML document.
QmlJS::Document::Ptr exprDoc = Document::create(QLatin1String("<expression>"));
exprDoc->setSource(expression);
exprDoc->parseExpression();
if (exprDoc->expression() != 0) {
Check evaluate(&interp);
// Evaluate the expression under cursor.
const Interpreter::Value *value = interp.convertToObject(evaluate(exprDoc->expression(), scope));
//qDebug() << "type:" << interp.typeId(value);
if (value && completionOperator == QLatin1Char('.')) { // member completion
EnumerateProperties enumerateProperties;
QHashIterator<QString, const Interpreter::Value *> it(enumerateProperties(value));
while (it.hasNext()) {
it.next();
TextEditor::CompletionItem item(this);
item.text = it.key();
item.icon = symbolIcon;
m_completions.append(item);
}
} else if (value && completionOperator == QLatin1Char('(') && m_startPosition == editor->position()) {
// function completion
if (const Interpreter::FunctionValue *f = value->asFunctionValue()) {
QString functionName = expression;
int indexOfDot = expression.lastIndexOf(QLatin1Char('.'));
if (indexOfDot != -1)
functionName = expression.mid(indexOfDot + 1);
// Recreate if necessary
if (!m_functionArgumentWidget)
m_functionArgumentWidget = new QmlJSEditor::Internal::FunctionArgumentWidget;
QStringList signature;
for (int i = 0; i < f->argumentCount(); ++i)
signature.append(f->argumentName(i));
m_functionArgumentWidget->showFunctionHint(functionName.trimmed(),
signature,
m_startPosition);
}
return -1; // We always return -1 when completing function prototypes.
}
}
if (! m_completions.isEmpty())
return m_startPosition;
return -1;
}
if (isQmlFile && (completionOperator.isNull() || completionOperator.isSpace() || isDelimiter(completionOperator))) {
updateSnippets();
m_completions.append(m_snippets);
}
if (! m_completions.isEmpty())
return m_startPosition;
return -1;
}
void QmlCodeCompletion::completions(QList<TextEditor::CompletionItem> *completions)
{
const int length = m_editor->position() - m_startPosition;
if (length == 0)
*completions = m_completions;
else if (length > 0) {
const QString key = m_editor->textAt(m_startPosition, length);
filter(m_completions, completions, key, FirstLetterCaseSensitive);
}
}
void QmlCodeCompletion::complete(const TextEditor::CompletionItem &item)
{
QString toInsert = item.text;
if (QmlJSTextEditor *edit = qobject_cast<QmlJSTextEditor *>(m_editor->widget())) {
if (item.data.isValid()) {
QTextCursor tc = edit->textCursor();
tc.beginEditBlock();
tc.setPosition(m_startPosition);
tc.setPosition(m_editor->position(), QTextCursor::KeepAnchor);
tc.removeSelectedText();
toInsert = item.data.toString();
edit->insertCodeSnippet(toInsert);
tc.endEditBlock();
return;
}
}
const int length = m_editor->position() - m_startPosition;
m_editor->setCurPos(m_startPosition);
m_editor->replace(length, toInsert);
}
bool QmlCodeCompletion::partiallyComplete(const QList<TextEditor::CompletionItem> &completionItems)
{
if (completionItems.count() == 1) {
const TextEditor::CompletionItem item = completionItems.first();
if (!item.data.canConvert<QString>()) {
complete(item);
return true;
}
}
return TextEditor::ICompletionCollector::partiallyComplete(completionItems);
}
void QmlCodeCompletion::cleanup()
{
m_editor = 0;
m_startPosition = 0;
m_completions.clear();
}
void QmlCodeCompletion::updateSnippets()
{
QString qmlsnippets = Core::ICore::instance()->resourcePath() + QLatin1String("/snippets/qml.xml");
if (!QFile::exists(qmlsnippets))
return;
QDateTime lastModified = QFileInfo(qmlsnippets).lastModified();
if (!m_snippetFileLastModified.isNull() && lastModified == m_snippetFileLastModified)
return;
const QIcon icon = iconForColor(Qt::red);
m_snippetFileLastModified = lastModified;
QFile file(qmlsnippets);
file.open(QIODevice::ReadOnly);
QXmlStreamReader xml(&file);
if (xml.readNextStartElement()) {
if (xml.name() == QLatin1String("snippets")) {
while (xml.readNextStartElement()) {
if (xml.name() == QLatin1String("snippet")) {
TextEditor::CompletionItem item(this);
QString title, data;
QString description = xml.attributes().value("description").toString();
while (!xml.atEnd()) {
xml.readNext();
if (xml.isEndElement()) {
int i = 0;
while (i < data.size() && data.at(i).isLetterOrNumber())
++i;
title = data.left(i);
item.text = title;
if (!description.isEmpty()) {
item.text += QLatin1Char(' ');
item.text += description;
}
item.data = QVariant::fromValue(data);
item.icon = icon;
m_snippets.append(item);
break;
}
if (xml.isCharacters())
data += xml.text();
else if (xml.isStartElement()) {
if (xml.name() != QLatin1String("tab"))
xml.raiseError(QLatin1String("invalid snippets file"));
else {
data += QChar::ObjectReplacementCharacter;
data += xml.readElementText();
data += QChar::ObjectReplacementCharacter;
}
}
}
} else {
xml.skipCurrentElement();
}
}
} else {
xml.skipCurrentElement();
}
}
if (xml.hasError())
qWarning() << qmlsnippets << xml.errorString() << xml.lineNumber() << xml.columnNumber();
file.close();
}
QList<TextEditor::CompletionItem> QmlCodeCompletion::getCompletions()
{
QList<TextEditor::CompletionItem> completionItems;
completions(&completionItems);
qStableSort(completionItems.begin(), completionItems.end(), completionItemLessThan);
// Remove duplicates
QString lastKey;
QList<TextEditor::CompletionItem> uniquelist;
foreach (const TextEditor::CompletionItem &item, completionItems) {
if (item.text != lastKey) {
uniquelist.append(item);
lastKey = item.text;
} else {
if (item.data.canConvert<QString>())
uniquelist.append(item);
}
}
return uniquelist;
}
View Git Blame Copy Permalink