892 lines
33 KiB
C++
892 lines
33 KiB
C++
#include "codecompletionpopup.h"
|
|
#include "../utils.h"
|
|
|
|
#include <QKeyEvent>
|
|
#include <QVBoxLayout>
|
|
#include <QDebug>
|
|
#include <QApplication>
|
|
|
|
CodeCompletionPopup::CodeCompletionPopup(QWidget *parent) :
|
|
QWidget(parent)
|
|
{
|
|
setWindowFlags(Qt::Popup);
|
|
mListView = new CodeCompletionListView(this);
|
|
mModel=new CodeCompletionListModel(&mCompletionStatementList);
|
|
mModel->setColorCallback([this](PStatement statement)->QColor{
|
|
StatementKind kind;
|
|
if (mParser) {
|
|
kind = mParser->getKindOfStatement(statement);
|
|
} else {
|
|
kind = statement->kind;
|
|
}
|
|
return mColors.value(kind,palette().color(QPalette::Text));
|
|
});
|
|
mListView->setModel(mModel);
|
|
setLayout(new QVBoxLayout());
|
|
layout()->addWidget(mListView);
|
|
layout()->setMargin(0);
|
|
|
|
mShowKeywords=true;
|
|
mUseCppKeyword=true;
|
|
mRecordUsage = false;
|
|
mSortByScope = true;
|
|
|
|
mOnlyGlobals = false;
|
|
mShowCount = 1000;
|
|
mShowCodeIns = true;
|
|
|
|
mIgnoreCase = false;
|
|
|
|
}
|
|
|
|
CodeCompletionPopup::~CodeCompletionPopup()
|
|
{
|
|
delete mListView;
|
|
delete mModel;
|
|
}
|
|
|
|
void CodeCompletionPopup::setKeypressedCallback(const KeyPressedCallback &newKeypressedCallback)
|
|
{
|
|
mListView->setKeypressedCallback(newKeypressedCallback);
|
|
}
|
|
|
|
void CodeCompletionPopup::prepareSearch(const QString &phrase, const QString &filename, int line)
|
|
{
|
|
QMutexLocker locker(&mMutex);
|
|
if (!isEnabled())
|
|
return;
|
|
mPhrase = phrase;
|
|
//Screen.Cursor := crHourglass;
|
|
QCursor oldCursor = cursor();
|
|
setCursor(Qt::CursorShape::WaitCursor);
|
|
|
|
mIncludedFiles = mParser->getFileIncludes(filename);
|
|
getCompletionFor(filename,phrase,line);
|
|
|
|
//todo: notify model
|
|
//CodeComplForm.lbCompletion.Font.Size := FontSize;
|
|
//CodeComplForm.lbCompletion.ItemHeight := CodeComplForm.lbCompletion.Canvas.TextHeight('F')+6;
|
|
// Round(2 * FontSize);
|
|
//CodeComplForm.Update;
|
|
setCursor(oldCursor);
|
|
}
|
|
|
|
bool CodeCompletionPopup::search(const QString &phrase, bool autoHideOnSingleResult)
|
|
{
|
|
QMutexLocker locker(&mMutex);
|
|
|
|
mPhrase = phrase;
|
|
|
|
if (phrase.isEmpty()) {
|
|
hide();
|
|
return false;
|
|
}
|
|
if (!isEnabled()) {
|
|
hide();
|
|
return false;
|
|
}
|
|
|
|
QCursor oldCursor = cursor();
|
|
setCursor(Qt::CursorShape::WaitCursor);
|
|
|
|
// Sort here by member
|
|
int i = mParser->findLastOperator(phrase);
|
|
while ((i>=0) && (i<phrase.length()) && (
|
|
phrase[i] == '.'
|
|
|| phrase[i] == ':'
|
|
|| phrase[i] == '-'
|
|
|| phrase[i] == '>'))
|
|
i++;
|
|
|
|
QString symbol = phrase.mid(i);
|
|
// filter fFullCompletionStatementList to fCompletionStatementList
|
|
filterList(symbol);
|
|
mModel->notifyUpdated();
|
|
setCursor(oldCursor);
|
|
|
|
if (!mCompletionStatementList.isEmpty()) {
|
|
// if only one suggestion, and is exactly the symbol to search, hide the frame (the search is over)
|
|
// if only one suggestion and auto hide , don't show the frame
|
|
if(mCompletionStatementList.count() == 1)
|
|
if (autoHideOnSingleResult
|
|
|| (symbol == mCompletionStatementList.front()->command)) {
|
|
return true;
|
|
}
|
|
} else {
|
|
hide();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
PStatement CodeCompletionPopup::selectedStatement()
|
|
{
|
|
if (isEnabled()) {
|
|
int index = mListView->currentIndex().row();
|
|
if (mListView->currentIndex().isValid()
|
|
&& (index<mCompletionStatementList.count()) ) {
|
|
return mCompletionStatementList[index];
|
|
} else {
|
|
if (!mCompletionStatementList.isEmpty())
|
|
return mCompletionStatementList.front();
|
|
else
|
|
return PStatement();
|
|
}
|
|
} else
|
|
return PStatement();
|
|
}
|
|
|
|
void CodeCompletionPopup::addChildren(PStatement scopeStatement, const QString &fileName, int line)
|
|
{
|
|
if (scopeStatement && !isIncluded(scopeStatement->fileName)
|
|
&& !isIncluded(scopeStatement->definitionFileName))
|
|
return;
|
|
const StatementMap& children = mParser->statementList().childrenStatements(scopeStatement);
|
|
if (children.isEmpty())
|
|
return;
|
|
|
|
if (!scopeStatement) { //Global scope
|
|
for (const PStatement& childStatement: children) {
|
|
if (childStatement->fileName.isEmpty()) {
|
|
// hard defines
|
|
addStatement(childStatement,fileName,-1);
|
|
} else if (!( childStatement->kind == StatementKind::skConstructor
|
|
|| childStatement->kind == StatementKind::skDestructor
|
|
|| childStatement->kind == StatementKind::skBlock)
|
|
&& (!mAddedStatements.contains(childStatement->command))
|
|
&& (
|
|
isIncluded(childStatement->fileName)
|
|
|| isIncluded(childStatement->definitionFileName)
|
|
)
|
|
) {
|
|
//we must check if the statement is included by the file
|
|
addStatement(childStatement,fileName,line);
|
|
}
|
|
}
|
|
} else {
|
|
for (const PStatement& childStatement: children) {
|
|
if (!( childStatement->kind == StatementKind::skConstructor
|
|
|| childStatement->kind == StatementKind::skDestructor
|
|
|| childStatement->kind == StatementKind::skBlock)
|
|
&& (!mAddedStatements.contains(childStatement->command)))
|
|
addStatement(childStatement,fileName,line);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CodeCompletionPopup::addStatement(PStatement statement, const QString &fileName, int line)
|
|
{
|
|
if (mAddedStatements.contains(statement->command))
|
|
return;
|
|
if ((line!=-1)
|
|
&& (line < statement->line)
|
|
&& (fileName == statement->fileName))
|
|
return;
|
|
mAddedStatements.insert(statement->command);
|
|
mFullCompletionStatementList.append(statement);
|
|
}
|
|
|
|
static bool defaultComparator(PStatement statement1,PStatement statement2) {
|
|
// Show user template first
|
|
if (statement1->kind == StatementKind::skUserCodeIn) {
|
|
if (statement2->kind != StatementKind::skUserCodeIn)
|
|
return true;
|
|
else
|
|
return statement1->command < statement2->command;
|
|
} else if (statement2->kind == StatementKind::skUserCodeIn) {
|
|
return false;
|
|
// show keywords first
|
|
} else if ((statement1->kind == StatementKind::skKeyword)
|
|
&& (statement2->kind != StatementKind::skKeyword)) {
|
|
return true;
|
|
} else if ((statement1->kind != StatementKind::skKeyword)
|
|
&& (statement2->kind == StatementKind::skKeyword)) {
|
|
return false;
|
|
} else
|
|
return statement1->command < statement2->command;
|
|
}
|
|
|
|
static bool sortByScopeComparator(PStatement statement1,PStatement statement2){
|
|
// Show user template first
|
|
if (statement1->kind == StatementKind::skUserCodeIn) {
|
|
if (statement2->kind != StatementKind::skUserCodeIn)
|
|
return true;
|
|
else
|
|
return statement1->command < statement2->command;
|
|
} else if (statement2->kind == StatementKind::skUserCodeIn) {
|
|
return false;
|
|
// show keywords first
|
|
} else if (statement1->kind == StatementKind::skKeyword) {
|
|
if (statement2->kind != StatementKind::skKeyword)
|
|
return true;
|
|
else
|
|
return statement1->command < statement2->command;
|
|
} else if (statement2->kind == StatementKind::skKeyword) {
|
|
return false;
|
|
// Show stuff from local headers first
|
|
} else if (statement1->inSystemHeader && !(statement2->inSystemHeader)) {
|
|
return true;
|
|
} else if (!(statement1->inSystemHeader) && statement2->inSystemHeader) {
|
|
return false;
|
|
// Show local statements first
|
|
} else if (statement1->scope != StatementScope::ssGlobal
|
|
&& statement2->scope == StatementScope::ssGlobal ) {
|
|
return true;
|
|
} else if (statement1->scope == StatementScope::ssGlobal
|
|
&& statement2->scope != StatementScope::ssGlobal ) {
|
|
return false;
|
|
// otherwise, sort by name
|
|
} else
|
|
return statement1->command < statement2->command;
|
|
}
|
|
|
|
static bool sortWithUsageComparator(PStatement statement1,PStatement statement2) {
|
|
// Show user template first
|
|
if (statement1->kind == StatementKind::skUserCodeIn) {
|
|
if (statement2->kind != StatementKind::skUserCodeIn)
|
|
return true;
|
|
else
|
|
return statement1->command < statement2->command;
|
|
} else if (statement2->kind == StatementKind::skUserCodeIn) {
|
|
return false;
|
|
//show most freq first
|
|
} else if (statement1->freqTop > statement2->freqTop) {
|
|
return true;
|
|
} else if (statement1->freqTop < statement2->freqTop) {
|
|
return false;
|
|
// show keywords first
|
|
} else if ((statement1->kind == StatementKind::skKeyword)
|
|
&& (statement2->kind != StatementKind::skKeyword)) {
|
|
return true;
|
|
} else if ((statement1->kind != StatementKind::skKeyword)
|
|
&& (statement2->kind == StatementKind::skKeyword)) {
|
|
return false;
|
|
} else
|
|
return statement1->command < statement2->command;
|
|
}
|
|
|
|
static bool sortByScopeWithUsageComparator(PStatement statement1,PStatement statement2){
|
|
// Show user template first
|
|
if (statement1->kind == StatementKind::skUserCodeIn) {
|
|
if (statement2->kind != StatementKind::skUserCodeIn)
|
|
return true;
|
|
else
|
|
return statement1->command < statement2->command;
|
|
} else if (statement2->kind == StatementKind::skUserCodeIn) {
|
|
return false;
|
|
//show most freq first
|
|
} else if (statement1->freqTop > statement2->freqTop) {
|
|
return true;
|
|
} else if (statement1->freqTop < statement2->freqTop) {
|
|
return false;
|
|
// show keywords first
|
|
} else if (statement1->kind == StatementKind::skKeyword) {
|
|
if (statement2->kind != StatementKind::skKeyword)
|
|
return true;
|
|
else
|
|
return statement1->command < statement2->command;
|
|
} else if (statement2->kind == StatementKind::skKeyword) {
|
|
return false;
|
|
// Show stuff from local headers first
|
|
} else if (statement1->inSystemHeader && ! (statement2->inSystemHeader)) {
|
|
return true;
|
|
} else if (!(statement1->inSystemHeader) && statement2->inSystemHeader) {
|
|
return false;
|
|
// Show local statements first
|
|
} else if (statement1->scope != StatementScope::ssGlobal
|
|
&& statement2->scope == StatementScope::ssGlobal ) {
|
|
return true;
|
|
} else if (statement1->scope == StatementScope::ssGlobal
|
|
&& statement2->scope != StatementScope::ssGlobal ) {
|
|
return false;
|
|
// otherwise, sort by name
|
|
} else
|
|
return statement1->command < statement2->command;
|
|
}
|
|
|
|
void CodeCompletionPopup::filterList(const QString &member)
|
|
{
|
|
QMutexLocker locker(&mMutex);
|
|
mCompletionStatementList.clear();
|
|
if (!mParser)
|
|
return;
|
|
if (!mParser->enabled())
|
|
return;
|
|
//we don't need to freeze here since we use smart pointers
|
|
// and data have been retrieved from the parser
|
|
// if (!mParser->freeze())
|
|
// return;
|
|
// {
|
|
// auto action = finally([this]{
|
|
// mParser->unFreeze();
|
|
// });
|
|
// if (mParserSerialId!=mParser->serialId()) {
|
|
// return;
|
|
// }
|
|
|
|
mCompletionStatementList.clear();
|
|
if (!member.isEmpty()) { // filter
|
|
mCompletionStatementList.reserve(mFullCompletionStatementList.size());
|
|
foreach (const PStatement& statement, mFullCompletionStatementList) {
|
|
Qt::CaseSensitivity cs = (mIgnoreCase?
|
|
Qt::CaseInsensitive:
|
|
Qt::CaseSensitive);
|
|
if (statement->command.startsWith(member, cs))
|
|
mCompletionStatementList.append(statement);
|
|
}
|
|
} else
|
|
mCompletionStatementList.append(mFullCompletionStatementList);
|
|
if (mRecordUsage) {
|
|
int topCount = 0;
|
|
int secondCount = 0;
|
|
int thirdCount = 0;
|
|
int usageCount;
|
|
foreach (const PStatement& statement,mCompletionStatementList) {
|
|
if (statement->usageCount == 0) {
|
|
usageCount = mSymbolUsage.value(statement->fullName,0);
|
|
if (usageCount == 0)
|
|
continue;
|
|
statement->usageCount = usageCount;
|
|
} else
|
|
usageCount = statement->usageCount;
|
|
if (usageCount>topCount) {
|
|
thirdCount = secondCount;
|
|
secondCount = topCount;
|
|
topCount = usageCount;
|
|
} else if (usageCount == topCount) {
|
|
continue;
|
|
} else if (usageCount > secondCount) {
|
|
thirdCount = secondCount;
|
|
secondCount = usageCount;
|
|
} else if (usageCount == secondCount) {
|
|
continue;
|
|
} else if (usageCount>thirdCount) {
|
|
thirdCount = usageCount;
|
|
}
|
|
}
|
|
foreach (const PStatement& statement, mCompletionStatementList) {
|
|
if (statement->usageCount == 0) {
|
|
statement->freqTop = 0;
|
|
} else if (statement->usageCount == topCount) {
|
|
statement->freqTop = 30;
|
|
} else if (statement->usageCount == secondCount) {
|
|
statement->freqTop = 20;
|
|
} else if (statement->usageCount == thirdCount) {
|
|
statement->freqTop = 10;
|
|
}
|
|
}
|
|
if (mSortByScope) {
|
|
std::sort(mCompletionStatementList.begin(),
|
|
mCompletionStatementList.end(),
|
|
sortByScopeWithUsageComparator);
|
|
} else {
|
|
std::sort(mCompletionStatementList.begin(),
|
|
mCompletionStatementList.end(),
|
|
sortWithUsageComparator);
|
|
}
|
|
} else if (mSortByScope) {
|
|
std::sort(mCompletionStatementList.begin(),
|
|
mCompletionStatementList.end(),
|
|
sortByScopeComparator);
|
|
} else {
|
|
std::sort(mCompletionStatementList.begin(),
|
|
mCompletionStatementList.end(),
|
|
defaultComparator);
|
|
}
|
|
// }
|
|
}
|
|
|
|
void CodeCompletionPopup::getCompletionFor(const QString &fileName, const QString &phrase, int line)
|
|
{
|
|
if(!mParser)
|
|
return;
|
|
if (!mParser->enabled())
|
|
return;
|
|
|
|
if (!mParser->freeze())
|
|
return;
|
|
{
|
|
auto action = finally([this]{
|
|
mParser->unFreeze();
|
|
});
|
|
|
|
//C++ preprocessor directives
|
|
if (phrase.startsWith('#')) {
|
|
if (mShowKeywords) {
|
|
foreach (const QString& keyword, CppDirectives) {
|
|
PStatement statement = std::make_shared<Statement>();
|
|
statement->command = keyword;
|
|
statement->kind = StatementKind::skKeyword;
|
|
statement->fullName = keyword;
|
|
statement->usageCount = 0;
|
|
statement->freqTop = 0;
|
|
mFullCompletionStatementList.append(statement);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
//docstring tags (javadoc style)
|
|
if (phrase.startsWith('@')) {
|
|
if (mShowKeywords) {
|
|
foreach (const QString& keyword,JavadocTags) {
|
|
PStatement statement = std::make_shared<Statement>();
|
|
statement->command = keyword;
|
|
statement->kind = StatementKind::skKeyword;
|
|
statement->fullName = keyword;
|
|
statement->usageCount = 0;
|
|
statement->freqTop = 0;
|
|
mFullCompletionStatementList.append(statement);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// Pulling off the same trick as in TCppParser.FindStatementOf, but ignore everything after last operator
|
|
int i = mParser->findLastOperator(phrase);
|
|
if (i < 0 ) { // don't have any scope prefix
|
|
|
|
if (mShowCodeIns) {
|
|
//add custom code templates
|
|
foreach (const PCodeIns& codeIn,mCodeInsList) {
|
|
PStatement statement = std::make_shared<Statement>();
|
|
statement->command = codeIn->prefix;
|
|
statement->kind = StatementKind::skUserCodeIn;
|
|
statement->fullName = codeIn->prefix;
|
|
statement->usageCount = 0;
|
|
statement->freqTop = 0;
|
|
mFullCompletionStatementList.append(statement);
|
|
}
|
|
}
|
|
|
|
if (mShowKeywords) {
|
|
//add keywords
|
|
if (mUseCppKeyword) {
|
|
foreach (const QString& keyword,CppKeywords.keys()) {
|
|
PStatement statement = std::make_shared<Statement>();
|
|
statement->command = keyword;
|
|
statement->kind = StatementKind::skKeyword;
|
|
statement->fullName = keyword;
|
|
statement->usageCount = 0;
|
|
statement->freqTop = 0;
|
|
mFullCompletionStatementList.append(statement);
|
|
}
|
|
} else {
|
|
foreach (const QString& keyword,CKeywords) {
|
|
PStatement statement = std::make_shared<Statement>();
|
|
statement->command = keyword;
|
|
statement->kind = StatementKind::skKeyword;
|
|
statement->fullName = keyword;
|
|
statement->usageCount = 0;
|
|
statement->freqTop = 0;
|
|
mFullCompletionStatementList.append(statement);
|
|
}
|
|
}
|
|
}
|
|
|
|
PStatement scopeStatement = mCurrentStatement;
|
|
// repeat until reach global
|
|
while (scopeStatement) {
|
|
//add members of current scope that not added before
|
|
if (scopeStatement->kind == StatementKind::skClass) {
|
|
addChildren(scopeStatement, fileName, -1);
|
|
} else {
|
|
addChildren(scopeStatement, fileName, line);
|
|
}
|
|
|
|
// add members of all usings (in current scope ) and not added before
|
|
foreach (const QString& namespaceName,scopeStatement->usingList) {
|
|
PStatementList namespaceStatementsList =
|
|
mParser->findNamespace(namespaceName);
|
|
if (!namespaceStatementsList)
|
|
continue;
|
|
foreach (const PStatement& namespaceStatement,*namespaceStatementsList) {
|
|
addChildren(namespaceStatement, fileName, line);
|
|
}
|
|
}
|
|
scopeStatement=scopeStatement->parentScope.lock();
|
|
}
|
|
|
|
// add all global members and not added before
|
|
addChildren(nullptr, fileName, line);
|
|
|
|
// add members of all fusings
|
|
mUsings = mParser->getFileUsings(fileName);
|
|
foreach (const QString& namespaceName, mUsings) {
|
|
PStatementList namespaceStatementsList =
|
|
mParser->findNamespace(namespaceName);
|
|
if (!namespaceStatementsList)
|
|
continue;
|
|
foreach (const PStatement& namespaceStatement, *namespaceStatementsList) {
|
|
addChildren(namespaceStatement, fileName, line);
|
|
}
|
|
}
|
|
} else { //we are in some statement's scope
|
|
MemberOperatorType opType=getOperatorType(phrase,i);
|
|
QString scopeName = phrase.mid(0,i);
|
|
if (opType == MemberOperatorType::otDColon) {
|
|
if (scopeName.isEmpty()) {
|
|
// start with '::', we only find in global
|
|
// add all global members and not added before
|
|
addChildren(nullptr, fileName, line);
|
|
return;
|
|
} else {
|
|
//assume the scope its a namespace
|
|
PStatementList namespaceStatementsList =
|
|
mParser->findNamespace(scopeName);
|
|
if (namespaceStatementsList) {
|
|
foreach (const PStatement& namespaceStatement, *namespaceStatementsList) {
|
|
addChildren(namespaceStatement, fileName, line);
|
|
}
|
|
return;
|
|
}
|
|
//namespace not found let's go on
|
|
}
|
|
}
|
|
PStatement parentTypeStatement;
|
|
PStatement statement = mParser->findStatementOf(
|
|
fileName, scopeName,mCurrentStatement,parentTypeStatement);
|
|
if (!statement)
|
|
return;
|
|
// find the most inner scope statement that has a name (not a block)
|
|
PStatement scopeTypeStatement = mCurrentStatement;
|
|
while (scopeTypeStatement && !isScopeTypeKind(scopeTypeStatement->kind)) {
|
|
scopeTypeStatement = scopeTypeStatement->parentScope.lock();
|
|
}
|
|
if (
|
|
(opType == MemberOperatorType::otArrow
|
|
|| opType == MemberOperatorType::otDot)
|
|
&& (
|
|
statement->kind == StatementKind::skVariable
|
|
|| statement->kind == StatementKind::skParameter
|
|
|| statement->kind == StatementKind::skFunction)
|
|
) {
|
|
// Get type statement of current (scope) statement
|
|
PStatement classTypeStatement;
|
|
PStatement parentScope = statement->parentScope.lock();
|
|
if ((statement->kind == StatementKind::skFunction)
|
|
&& parentScope
|
|
&& STLContainers.contains(parentScope->fullName)
|
|
&& STLElementMethods.contains(statement->command)){
|
|
// it's an element method of STL container
|
|
// we must find the type in the template parameter
|
|
|
|
// get the function's owner variable's definition
|
|
int lastI = mParser->findLastOperator(scopeName);
|
|
QString lastScopeName = scopeName.mid(0,lastI);
|
|
PStatement lastScopeStatement =
|
|
mParser->findStatementOf(
|
|
fileName, lastScopeName,
|
|
mCurrentStatement,parentTypeStatement);
|
|
if (!lastScopeStatement)
|
|
return;
|
|
|
|
|
|
QString typeName =
|
|
mParser->findFirstTemplateParamOf(
|
|
fileName,lastScopeStatement->type,
|
|
lastScopeStatement->parentScope.lock());
|
|
classTypeStatement = mParser->findTypeDefinitionOf(
|
|
fileName, typeName,
|
|
lastScopeStatement->parentScope.lock());
|
|
} else
|
|
classTypeStatement=mParser->findTypeDefinitionOf(
|
|
fileName, statement->type,parentTypeStatement);
|
|
|
|
if (!classTypeStatement)
|
|
return;
|
|
//is a smart pointer
|
|
if (STLPointers.contains(classTypeStatement->fullName)
|
|
&& (opType == MemberOperatorType::otArrow)) {
|
|
QString typeName= mParser->findFirstTemplateParamOf(
|
|
fileName,
|
|
statement->type,
|
|
parentScope);
|
|
classTypeStatement = mParser->findTypeDefinitionOf(
|
|
fileName,
|
|
typeName,
|
|
parentScope);
|
|
if (!classTypeStatement)
|
|
return;
|
|
}
|
|
//is a stl container operator[]
|
|
if (STLContainers.contains(classTypeStatement->fullName)
|
|
&& scopeName.endsWith(']')) {
|
|
QString typeName= mParser->findFirstTemplateParamOf(
|
|
fileName,
|
|
statement->type,
|
|
parentScope);
|
|
classTypeStatement = mParser->findTypeDefinitionOf(
|
|
fileName,
|
|
typeName,
|
|
parentScope);
|
|
if (!classTypeStatement)
|
|
return;
|
|
}
|
|
if (!isIncluded(classTypeStatement->fileName) &&
|
|
!isIncluded(classTypeStatement->definitionFileName))
|
|
return;
|
|
if ((classTypeStatement == scopeTypeStatement) || (statement->command == "this")) {
|
|
//we can use all members
|
|
addChildren(classTypeStatement,fileName,-1);
|
|
} else { // we can only use public members
|
|
const StatementMap& children = mParser->statementList().childrenStatements(classTypeStatement);
|
|
if (children.isEmpty())
|
|
return;
|
|
foreach (const PStatement& childStatement, children) {
|
|
if ((childStatement->classScope==StatementClassScope::scsPublic)
|
|
&& !(
|
|
childStatement->kind == StatementKind::skConstructor
|
|
|| childStatement->kind == StatementKind::skDestructor)
|
|
&& !mAddedStatements.contains(childStatement->command)) {
|
|
addStatement(childStatement,fileName,-1);
|
|
}
|
|
}
|
|
}
|
|
//todo friend
|
|
} else if ((opType == MemberOperatorType::otDColon)
|
|
&& (statement->kind == StatementKind::skEnumType)
|
|
&& (statement->kind == StatementKind::skEnumClassType)) {
|
|
//we can add all child enum definess
|
|
PStatement classTypeStatement = statement;
|
|
if (!isIncluded(classTypeStatement->fileName) &&
|
|
!isIncluded(classTypeStatement->definitionFileName))
|
|
return;
|
|
const StatementMap& children =
|
|
mParser->statementList().childrenStatements(classTypeStatement);
|
|
foreach (const PStatement& child,children) {
|
|
addStatement(child,fileName,line);
|
|
}
|
|
} else if ((opType == MemberOperatorType::otDColon)
|
|
&& (statement->kind == StatementKind::skClass)) {
|
|
PStatement classTypeStatement = statement;
|
|
if (!isIncluded(classTypeStatement->fileName) &&
|
|
!isIncluded(classTypeStatement->definitionFileName))
|
|
return;
|
|
if (classTypeStatement == scopeTypeStatement) {
|
|
//we can use all static members
|
|
const StatementMap& children =
|
|
mParser->statementList().childrenStatements(classTypeStatement);
|
|
foreach (const PStatement& childStatement, children) {
|
|
if (
|
|
(childStatement->isStatic)
|
|
|| (childStatement->kind == StatementKind::skTypedef
|
|
|| childStatement->kind == StatementKind::skClass
|
|
|| childStatement->kind == StatementKind::skEnum
|
|
|| childStatement->kind == StatementKind::skEnumClassType
|
|
|| childStatement->kind == StatementKind::skEnumType
|
|
)) {
|
|
addStatement(childStatement,fileName,-1);
|
|
}
|
|
}
|
|
} else {
|
|
// we can only use public static members
|
|
const StatementMap& children =
|
|
mParser->statementList().childrenStatements(classTypeStatement);
|
|
foreach (const PStatement& childStatement,children) {
|
|
if (
|
|
(childStatement->isStatic)
|
|
|| (childStatement->kind == StatementKind::skTypedef
|
|
|| childStatement->kind == StatementKind::skClass
|
|
|| childStatement->kind == StatementKind::skEnum
|
|
|| childStatement->kind == StatementKind::skEnumClassType
|
|
|| childStatement->kind == StatementKind::skEnumType
|
|
)) {
|
|
if (childStatement->classScope == StatementClassScope::scsPublic)
|
|
addStatement(childStatement,fileName,-1);
|
|
}
|
|
}
|
|
}
|
|
//todo friend
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CodeCompletionPopup::isIncluded(const QString &fileName)
|
|
{
|
|
return mIncludedFiles.contains(fileName);
|
|
}
|
|
|
|
void CodeCompletionPopup::showEvent(QShowEvent *)
|
|
{
|
|
mListView->setFocus();
|
|
}
|
|
|
|
const PStatement &CodeCompletionPopup::currentStatement() const
|
|
{
|
|
return mCurrentStatement;
|
|
}
|
|
|
|
void CodeCompletionPopup::setCurrentStatement(const PStatement &newCurrentStatement)
|
|
{
|
|
mCurrentStatement = newCurrentStatement;
|
|
}
|
|
|
|
QHash<StatementKind, QColor> &CodeCompletionPopup::colors()
|
|
{
|
|
return mColors;
|
|
}
|
|
|
|
bool CodeCompletionPopup::useCppKeyword() const
|
|
{
|
|
return mUseCppKeyword;
|
|
}
|
|
|
|
void CodeCompletionPopup::setUseCppKeyword(bool newUseCppKeyword)
|
|
{
|
|
mUseCppKeyword = newUseCppKeyword;
|
|
}
|
|
|
|
bool CodeCompletionPopup::sortByScope() const
|
|
{
|
|
return mSortByScope;
|
|
}
|
|
|
|
void CodeCompletionPopup::setSortByScope(bool newSortByScope)
|
|
{
|
|
mSortByScope = newSortByScope;
|
|
}
|
|
|
|
bool CodeCompletionPopup::ignoreCase() const
|
|
{
|
|
return mIgnoreCase;
|
|
}
|
|
|
|
void CodeCompletionPopup::setIgnoreCase(bool newIgnoreCase)
|
|
{
|
|
mIgnoreCase = newIgnoreCase;
|
|
}
|
|
|
|
bool CodeCompletionPopup::showCodeIns() const
|
|
{
|
|
return mShowCodeIns;
|
|
}
|
|
|
|
void CodeCompletionPopup::setShowCodeIns(bool newShowCodeIns)
|
|
{
|
|
mShowCodeIns = newShowCodeIns;
|
|
}
|
|
|
|
bool CodeCompletionPopup::showKeywords() const
|
|
{
|
|
return mShowKeywords;
|
|
}
|
|
|
|
void CodeCompletionPopup::setShowKeywords(bool newShowKeywords)
|
|
{
|
|
mShowKeywords = newShowKeywords;
|
|
}
|
|
|
|
bool CodeCompletionPopup::recordUsage() const
|
|
{
|
|
return mRecordUsage;
|
|
}
|
|
|
|
void CodeCompletionPopup::setRecordUsage(bool newRecordUsage)
|
|
{
|
|
mRecordUsage = newRecordUsage;
|
|
}
|
|
|
|
bool CodeCompletionPopup::onlyGlobals() const
|
|
{
|
|
return mOnlyGlobals;
|
|
}
|
|
|
|
void CodeCompletionPopup::setOnlyGlobals(bool newOnlyGlobals)
|
|
{
|
|
mOnlyGlobals = newOnlyGlobals;
|
|
}
|
|
|
|
int CodeCompletionPopup::showCount() const
|
|
{
|
|
return mShowCount;
|
|
}
|
|
|
|
void CodeCompletionPopup::setShowCount(int newShowCount)
|
|
{
|
|
mShowCount = newShowCount;
|
|
}
|
|
|
|
const PCppParser &CodeCompletionPopup::parser() const
|
|
{
|
|
return mParser;
|
|
}
|
|
|
|
void CodeCompletionPopup::setParser(const PCppParser &newParser)
|
|
{
|
|
mParser = newParser;
|
|
}
|
|
|
|
void CodeCompletionPopup::hideEvent(QHideEvent *event)
|
|
{
|
|
QMutexLocker locker(&mMutex);
|
|
mListView->setKeypressedCallback(nullptr);
|
|
mCompletionStatementList.clear();
|
|
mFullCompletionStatementList.clear();
|
|
mIncludedFiles.clear();
|
|
mUsings.clear();
|
|
mAddedStatements.clear();
|
|
QWidget::hideEvent(event);
|
|
}
|
|
|
|
bool CodeCompletionPopup::event(QEvent *event)
|
|
{
|
|
bool result = QWidget::event(event);
|
|
if (event->type() == QEvent::FontChange) {
|
|
mListView->setFont(font());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
CodeCompletionListModel::CodeCompletionListModel(const StatementList *statements, QObject *parent):
|
|
QAbstractListModel(parent),
|
|
mStatements(statements)
|
|
{
|
|
|
|
}
|
|
|
|
int CodeCompletionListModel::rowCount(const QModelIndex &) const
|
|
{
|
|
return mStatements->count();
|
|
}
|
|
|
|
QVariant CodeCompletionListModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
if (!index.isValid())
|
|
return QVariant();
|
|
if (index.row()>=mStatements->count())
|
|
return QVariant();
|
|
|
|
switch(role) {
|
|
case Qt::DisplayRole: {
|
|
PStatement statement = mStatements->at(index.row());
|
|
return statement->command;
|
|
}
|
|
case Qt::ForegroundRole: {
|
|
PStatement statement = mStatements->at(index.row());
|
|
if (mColorCallback)
|
|
return mColorCallback(statement);
|
|
QApplication *app = dynamic_cast<QApplication *>(QApplication::instance());
|
|
return app->palette().color(QPalette::Text);
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
void CodeCompletionListModel::notifyUpdated()
|
|
{
|
|
beginResetModel();
|
|
endResetModel();
|
|
}
|
|
|
|
const ColorCallback &CodeCompletionListModel::colorCallback() const
|
|
{
|
|
return mColorCallback;
|
|
}
|
|
|
|
void CodeCompletionListModel::setColorCallback(const ColorCallback &newColorCallback)
|
|
{
|
|
mColorCallback = newColorCallback;
|
|
}
|