Changeset View
Changeset View
Standalone View
Standalone View
src/completion/katecompletionmodel.cpp
| Show First 20 Lines • Show All 367 Lines • ▼ Show 20 Line(s) | |||||
| 368 | KTextEditor::ViewPrivate *KateCompletionModel::view() const | 368 | KTextEditor::ViewPrivate *KateCompletionModel::view() const | ||
| 369 | { | 369 | { | ||
| 370 | return widget()->view(); | 370 | return widget()->view(); | ||
| 371 | } | 371 | } | ||
| 372 | 372 | | |||
| 373 | void KateCompletionModel::setMatchCaseSensitivity(Qt::CaseSensitivity cs) | 373 | void KateCompletionModel::setMatchCaseSensitivity(Qt::CaseSensitivity cs) | ||
| 374 | { | 374 | { | ||
| 375 | m_matchCaseSensitivity = cs; | 375 | m_matchCaseSensitivity = cs; | ||
| 376 | Q_ASSERT(m_exactMatchCaseSensitivity == m_matchCaseSensitivity || m_matchCaseSensitivity == Qt::CaseInsensitive); | ||||
| 377 | } | ||||
| 378 | | ||||
| 379 | void KateCompletionModel::setExactMatchCaseSensitivity(Qt::CaseSensitivity cs) | ||||
| 380 | { | ||||
| 381 | m_exactMatchCaseSensitivity = cs; | ||||
| 382 | Q_ASSERT(m_exactMatchCaseSensitivity == m_matchCaseSensitivity || m_matchCaseSensitivity == Qt::CaseInsensitive); | ||||
| 376 | } | 383 | } | ||
| 377 | 384 | | |||
| 378 | int KateCompletionModel::columnCount(const QModelIndex &) const | 385 | int KateCompletionModel::columnCount(const QModelIndex &) const | ||
| 379 | { | 386 | { | ||
| 380 | return isColumnMergingEnabled() && !m_columnMerges.isEmpty() ? m_columnMerges.count() : KTextEditor::CodeCompletionModel::ColumnCount; | 387 | return isColumnMergingEnabled() && !m_columnMerges.isEmpty() ? m_columnMerges.count() : KTextEditor::CodeCompletionModel::ColumnCount; | ||
| 381 | } | 388 | } | ||
| 382 | 389 | | |||
| 383 | KateCompletionModel::ModelRow KateCompletionModel::modelRowPair(const QModelIndex &index) const | 390 | KateCompletionModel::ModelRow KateCompletionModel::modelRowPair(const QModelIndex &index) const | ||
| ▲ Show 20 Lines • Show All 1155 Lines • ▼ Show 20 Line(s) | 1544 | if (doInitialMatch) { | |||
| 1539 | match(); | 1546 | match(); | ||
| 1540 | } | 1547 | } | ||
| 1541 | } | 1548 | } | ||
| 1542 | 1549 | | |||
| 1543 | bool KateCompletionModel::Item::operator <(const Item &rhs) const | 1550 | bool KateCompletionModel::Item::operator <(const Item &rhs) const | ||
| 1544 | { | 1551 | { | ||
| 1545 | int ret = 0; | 1552 | int ret = 0; | ||
| 1546 | 1553 | | |||
| 1547 | //qCDebug(LOG_KTE) << c1 << " c/w " << c2 << " -> " << (model->isSortingReverse() ? ret > 0 : ret < 0) << " (" << ret << ")"; | 1554 | //qCDebug(LOG_KTE) << c1 << " c/w " << c2 << " -> " << (model->isSortingReverse() ? ret > 0 : ret < 0) << " (" << ret << ")"; | ||
mwolff: unrelated whitespace changes should be fixed in separate commits | |||||
| 1548 | 1555 | | |||
| 1549 | if(m_unimportant && !rhs.m_unimportant){ | 1556 | if(m_unimportant && !rhs.m_unimportant){ | ||
| 1550 | return false; | 1557 | return false; | ||
| 1551 | } | 1558 | } | ||
| 1552 | 1559 | | |||
| 1553 | if(!m_unimportant && rhs.m_unimportant){ | 1560 | if(!m_unimportant && rhs.m_unimportant){ | ||
| 1554 | return true; | 1561 | return true; | ||
| 1555 | } | 1562 | } | ||
| 1556 | 1563 | | |||
| 1557 | if (matchCompletion < rhs.matchCompletion) { | 1564 | if (matchCompletion < rhs.matchCompletion) { | ||
| 1558 | // enums are ordered in the order items should be displayed | 1565 | // enums are ordered in the order items should be displayed | ||
| 1559 | return true; | 1566 | return true; | ||
| 1560 | } | 1567 | } | ||
| 1561 | if (matchCompletion > rhs.matchCompletion) { | 1568 | if (matchCompletion > rhs.matchCompletion) { | ||
| 1562 | return false; | 1569 | return false; | ||
| 1563 | } | 1570 | } | ||
| 1564 | 1571 | | |||
| 1572 | if (ret == 0) { | ||||
| 1573 | const QString& filter = rhs.model->currentCompletion(rhs.m_sourceRow.first); | ||||
| 1574 | bool thisStartWithFilter = m_nameColumn.startsWith(filter, Qt::CaseSensitive); | ||||
| 1575 | bool rhsStartsWithFilter = rhs.m_nameColumn.startsWith(filter, Qt::CaseSensitive); | ||||
mwolff: here and below:remove space after `!` | |||||
| 1576 | | ||||
| 1577 | if( thisStartWithFilter && !rhsStartsWithFilter ) { | ||||
| 1578 | return true; | ||||
| 1579 | } | ||||
| 1580 | if( rhsStartsWithFilter && !thisStartWithFilter ) { | ||||
| 1581 | return false; | ||||
| 1582 | } | ||||
| 1583 | } | ||||
| 1584 | | ||||
| 1565 | if (model->isSortingByInheritanceDepth()) { | 1585 | if (model->isSortingByInheritanceDepth()) { | ||
| 1566 | ret = inheritanceDepth - rhs.inheritanceDepth; | 1586 | ret = inheritanceDepth - rhs.inheritanceDepth; | ||
| 1567 | } | 1587 | } | ||
| 1568 | 1588 | | |||
| 1569 | if (ret == 0 && model->isSortingAlphabetical()) { | 1589 | if (ret == 0 && model->isSortingAlphabetical()) { | ||
| 1570 | // Do not use localeAwareCompare, because it is simply too slow for a list of about 1000 items | 1590 | // Do not use localeAwareCompare, because it is simply too slow for a list of about 1000 items | ||
| 1571 | ret = QString::compare(m_nameColumn, rhs.m_nameColumn, model->sortingCaseSensitivity()); | 1591 | ret = QString::compare(m_nameColumn, rhs.m_nameColumn, model->sortingCaseSensitivity()); | ||
| 1572 | } | 1592 | } | ||
| 1573 | 1593 | | |||
| 1574 | if (ret == 0) { | 1594 | if (ret == 0) { | ||
| 1575 | const QString& filter = rhs.model->currentCompletion(rhs.m_sourceRow.first); | | |||
| 1576 | if( m_nameColumn.startsWith(filter, Qt::CaseSensitive) ) { | | |||
| 1577 | return true; | | |||
| 1578 | } | | |||
| 1579 | if( rhs.m_nameColumn.startsWith(filter, Qt::CaseSensitive) ) { | | |||
| 1580 | return false; | | |||
| 1581 | } | | |||
| 1582 | | ||||
| 1583 | // FIXME need to define a better default ordering for multiple model display | 1595 | // FIXME need to define a better default ordering for multiple model display | ||
| 1584 | ret = m_sourceRow.second.row() - rhs.m_sourceRow.second.row(); | 1596 | ret = m_sourceRow.second.row() - rhs.m_sourceRow.second.row(); | ||
| 1585 | } | 1597 | } | ||
| 1586 | 1598 | | |||
| 1587 | return ret < 0; | 1599 | return ret < 0; | ||
| 1588 | } | 1600 | } | ||
| 1589 | 1601 | | |||
| 1590 | void KateCompletionModel::Group::addItem(Item i, bool notifyModel) | 1602 | void KateCompletionModel::Group::addItem(Item i, bool notifyModel) | ||
| ▲ Show 20 Lines • Show All 277 Lines • ▼ Show 20 Line(s) | 1879 | foreach (const Item &item, group->filtered) | |||
| 1868 | if (item.sourceRow().first != hideModel) { | 1880 | if (item.sourceRow().first != hideModel) { | ||
| 1869 | return false; | 1881 | return false; | ||
| 1870 | } | 1882 | } | ||
| 1871 | } | 1883 | } | ||
| 1872 | 1884 | | |||
| 1873 | return doHide; | 1885 | return doHide; | ||
| 1874 | } | 1886 | } | ||
| 1875 | 1887 | | |||
| 1888 | static inline QChar toLowerIfInsensitive(QChar c, Qt::CaseSensitivity caseSensitive) | ||||
mwolff: static or anon namespace | |||||
| 1889 | { | ||||
| 1890 | return (caseSensitive == Qt::CaseInsensitive) ? c.toLower() : c; | ||||
| 1891 | } | ||||
| 1892 | | ||||
| 1876 | static inline bool matchesAbbreviationHelper(const QString &word, const QString &typed, const QVarLengthArray<int, 32> &offsets, | 1893 | static inline bool matchesAbbreviationHelper(const QString &word, const QString &typed, const QVarLengthArray<int, 32> &offsets, | ||
| 1877 | int &depth, int atWord = -1, int i = 0) | 1894 | Qt::CaseSensitivity caseSensitive, int &depth, int atWord = -1, int i = 0) | ||
| 1878 | { | 1895 | { | ||
| 1879 | int atLetter = 1; | 1896 | int atLetter = 1; | ||
| 1880 | for (; i < typed.size(); i++) { | 1897 | for (; i < typed.size(); i++) { | ||
| 1881 | const QChar c = typed.at(i).toLower(); | 1898 | const QChar c = toLowerIfInsensitive(typed.at(i), caseSensitive); | ||
| 1882 | bool haveNextWord = offsets.size() > atWord + 1; | 1899 | bool haveNextWord = offsets.size() > atWord + 1; | ||
| 1883 | bool canCompare = atWord != -1 && word.size() > offsets.at(atWord) + atLetter; | 1900 | bool canCompare = atWord != -1 && word.size() > offsets.at(atWord) + atLetter; | ||
| 1884 | if (canCompare && c == word.at(offsets.at(atWord) + atLetter).toLower()) { | 1901 | if (canCompare && c == toLowerIfInsensitive(word.at(offsets.at(atWord) + atLetter), caseSensitive)) { | ||
| 1885 | // the typed letter matches a letter after the current word beginning | 1902 | // the typed letter matches a letter after the current word beginning | ||
| 1886 | if (! haveNextWord || c != word.at(offsets.at(atWord + 1)).toLower()) { | 1903 | if (! haveNextWord || c != toLowerIfInsensitive(word.at(offsets.at(atWord + 1)), caseSensitive)) { | ||
| 1887 | // good, simple case, no conflict | 1904 | // good, simple case, no conflict | ||
| 1888 | atLetter += 1; | 1905 | atLetter += 1; | ||
| 1889 | continue; | 1906 | continue; | ||
| 1890 | } | 1907 | } | ||
| 1891 | // For maliciously crafted data, the code used here theoretically can have very high | 1908 | // For maliciously crafted data, the code used here theoretically can have very high | ||
| 1892 | // complexity. Thus ensure we don't run into this case, by limiting the amount of branches | 1909 | // complexity. Thus ensure we don't run into this case, by limiting the amount of branches | ||
| 1893 | // we walk through to 128. | 1910 | // we walk through to 128. | ||
| 1894 | depth++; | 1911 | depth++; | ||
| 1895 | if (depth > 128) { | 1912 | if (depth > 128) { | ||
| 1896 | return false; | 1913 | return false; | ||
| 1897 | } | 1914 | } | ||
| 1898 | // the letter matches both the next word beginning and the next character in the word | 1915 | // the letter matches both the next word beginning and the next character in the word | ||
| 1899 | if (haveNextWord && matchesAbbreviationHelper(word, typed, offsets, depth, atWord + 1, i + 1)) { | 1916 | if (haveNextWord && matchesAbbreviationHelper(word, typed, offsets, caseSensitive, depth, atWord + 1, i + 1)) { | ||
| 1900 | // resolving the conflict by taking the next word's first character worked, fine | 1917 | // resolving the conflict by taking the next word's first character worked, fine | ||
| 1901 | return true; | 1918 | return true; | ||
| 1902 | } | 1919 | } | ||
| 1903 | // otherwise, continue by taking the next letter in the current word. | 1920 | // otherwise, continue by taking the next letter in the current word. | ||
| 1904 | atLetter += 1; | 1921 | atLetter += 1; | ||
| 1905 | continue; | 1922 | continue; | ||
| 1906 | } else if (haveNextWord && c == word.at(offsets.at(atWord + 1)).toLower()) { | 1923 | } else if (haveNextWord && c == toLowerIfInsensitive(word.at(offsets.at(atWord + 1)), caseSensitive)) { | ||
| 1907 | // the typed letter matches the next word beginning | 1924 | // the typed letter matches the next word beginning | ||
| 1908 | atWord++; | 1925 | atWord++; | ||
| 1909 | atLetter = 1; | 1926 | atLetter = 1; | ||
| 1910 | continue; | 1927 | continue; | ||
| 1911 | } | 1928 | } | ||
| 1912 | // no match | 1929 | // no match | ||
| 1913 | return false; | 1930 | return false; | ||
| 1914 | } | 1931 | } | ||
| 1915 | // all characters of the typed word were matched | 1932 | // all characters of the typed word were matched | ||
| 1916 | return true; | 1933 | return true; | ||
| 1917 | } | 1934 | } | ||
| 1918 | 1935 | | |||
| 1919 | bool KateCompletionModel::matchesAbbreviation(const QString &word, const QString &typed) | 1936 | bool KateCompletionModel::matchesAbbreviation(const QString &word, const QString &typed, Qt::CaseSensitivity caseSensitive) | ||
| 1920 | { | 1937 | { | ||
| 1921 | // A mismatch is very likely for random even for the first letter, | 1938 | // A mismatch is very likely for random even for the first letter, | ||
| 1922 | // thus this optimization makes sense. | 1939 | // thus this optimization makes sense. | ||
| 1923 | if (word.at(0).toLower() != typed.at(0).toLower()) { | 1940 | if (toLowerIfInsensitive(word.at(0), caseSensitive) != toLowerIfInsensitive(typed.at(0), caseSensitive)) { | ||
| 1924 | return false; | 1941 | return false; | ||
| 1925 | } | 1942 | } | ||
| 1926 | 1943 | | |||
| 1927 | // First, check if all letters are contained in the word in the right order. | 1944 | // First, check if all letters are contained in the word in the right order. | ||
| 1928 | int atLetter = 0; | 1945 | int atLetter = 0; | ||
| 1929 | foreach (const QChar c, typed) { | 1946 | foreach (const QChar c, typed) { | ||
| 1930 | while (c.toLower() != word.at(atLetter).toLower()) { | 1947 | while (toLowerIfInsensitive(c, caseSensitive) != toLowerIfInsensitive(word.at(atLetter), caseSensitive)) { | ||
| 1931 | atLetter += 1; | 1948 | atLetter += 1; | ||
| 1932 | if (atLetter >= word.size()) { | 1949 | if (atLetter >= word.size()) { | ||
| 1933 | return false; | 1950 | return false; | ||
| 1934 | } | 1951 | } | ||
| 1935 | } | 1952 | } | ||
| 1936 | } | 1953 | } | ||
| 1937 | 1954 | | |||
| 1938 | bool haveUnderscore = true; | 1955 | bool haveUnderscore = true; | ||
| Show All 9 Lines | 1963 | for (int i = 0; i < word.size(); i++) { | |||
| 1948 | if (c == QLatin1Char('_')) { | 1965 | if (c == QLatin1Char('_')) { | ||
| 1949 | haveUnderscore = true; | 1966 | haveUnderscore = true; | ||
| 1950 | } else if (haveUnderscore || c.isUpper()) { | 1967 | } else if (haveUnderscore || c.isUpper()) { | ||
| 1951 | offsets.append(i); | 1968 | offsets.append(i); | ||
| 1952 | haveUnderscore = false; | 1969 | haveUnderscore = false; | ||
| 1953 | } | 1970 | } | ||
| 1954 | } | 1971 | } | ||
| 1955 | int depth = 0; | 1972 | int depth = 0; | ||
| 1956 | return matchesAbbreviationHelper(word, typed, offsets, depth); | 1973 | return matchesAbbreviationHelper(word, typed, offsets, caseSensitive, depth); | ||
| 1957 | } | 1974 | } | ||
| 1958 | 1975 | | |||
| 1959 | static inline bool containsAtWordBeginning(const QString &word, const QString &typed, Qt::CaseSensitivity caseSensitive) | 1976 | static inline bool containsAtWordBeginning(const QString &word, const QString &typed, Qt::CaseSensitivity caseSensitive) | ||
| 1960 | { | 1977 | { | ||
| 1961 | for (int i = 1; i < word.size(); i++) { | 1978 | for (int i = 1; i < word.size(); i++) { | ||
| 1962 | // The current position is a word beginning if the previous character was an underscore | 1979 | // The current position is a word beginning if the previous character was an underscore | ||
| 1963 | // or if the current character is uppercase. Subsequent uppercase characters do not count, | 1980 | // or if the current character is uppercase. Subsequent uppercase characters do not count, | ||
| 1964 | // to handle the special case of UPPER_CASE_VARS properly. | 1981 | // to handle the special case of UPPER_CASE_VARS properly. | ||
| Show All 31 Lines | 2009 | if (matchCompletion == NoMatch) { | |||
| 1996 | // Starting at 1 saves looking at the beginning of the word, that was already checked above. | 2013 | // Starting at 1 saves looking at the beginning of the word, that was already checked above. | ||
| 1997 | if (containsAtWordBeginning(m_nameColumn, match, model->matchCaseSensitivity())) { | 2014 | if (containsAtWordBeginning(m_nameColumn, match, model->matchCaseSensitivity())) { | ||
| 1998 | matchCompletion = ContainsMatch; | 2015 | matchCompletion = ContainsMatch; | ||
| 1999 | } | 2016 | } | ||
| 2000 | } | 2017 | } | ||
| 2001 | 2018 | | |||
| 2002 | if (matchCompletion == NoMatch && !m_nameColumn.isEmpty() && !match.isEmpty()) { | 2019 | if (matchCompletion == NoMatch && !m_nameColumn.isEmpty() && !match.isEmpty()) { | ||
| 2003 | // if still no match, try abbreviation matching | 2020 | // if still no match, try abbreviation matching | ||
| 2004 | if (matchesAbbreviation(m_nameColumn, match)) { | 2021 | if (matchesAbbreviation(m_nameColumn, match, model->matchCaseSensitivity())) { | ||
| 2005 | matchCompletion = AbbreviationMatch; | 2022 | matchCompletion = AbbreviationMatch; | ||
| 2006 | } | 2023 | } | ||
| 2007 | } | 2024 | } | ||
| 2008 | 2025 | | |||
| 2009 | if (matchCompletion && match.length() == m_nameColumn.length()) { | 2026 | if (matchCompletion && match.length() == m_nameColumn.length()) { | ||
maybe simplify this to: if (matchCompletion && m_nameColumn.startsWith(match, model->exactMatchCaseSensitivity())) { matchCompletion = PerfectMatch; m_haveExactMatch = true; } mwolff: maybe simplify this to:
if (matchCompletion && m_nameColumn.startsWith(match, model… | |||||
Hmm, I guess the current version might be a tiny bit faster in general since it only does another startsWith() check if this would be a stricter check than the one done before ... thomassc: Hmm, I guess the current version might be a tiny bit faster in general since it only does… | |||||
| 2027 | if (model->matchCaseSensitivity() == Qt::CaseInsensitive && | ||||
| 2028 | model->exactMatchCaseSensitivity() == Qt::CaseSensitive && | ||||
| 2029 | !m_nameColumn.startsWith(match, Qt::CaseSensitive)) { | ||||
mwolff: remove whitespace after ! | |||||
| 2030 | return matchCompletion; | ||||
| 2031 | } | ||||
| 2010 | matchCompletion = PerfectMatch; | 2032 | matchCompletion = PerfectMatch; | ||
| 2011 | m_haveExactMatch = true; | 2033 | m_haveExactMatch = true; | ||
| 2012 | } | 2034 | } | ||
| 2013 | 2035 | | |||
| 2014 | return matchCompletion; | 2036 | return matchCompletion; | ||
| 2015 | } | 2037 | } | ||
| 2016 | 2038 | | |||
| 2017 | QString KateCompletionModel::propertyName(KTextEditor::CodeCompletionModel::CompletionProperty property) | 2039 | QString KateCompletionModel::propertyName(KTextEditor::CodeCompletionModel::CompletionProperty property) | ||
| ▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Line(s) | 2134 | { | |||
| 2113 | return m_currentMatch.value(model); | 2135 | return m_currentMatch.value(model); | ||
| 2114 | } | 2136 | } | ||
| 2115 | 2137 | | |||
| 2116 | Qt::CaseSensitivity KateCompletionModel::matchCaseSensitivity() const | 2138 | Qt::CaseSensitivity KateCompletionModel::matchCaseSensitivity() const | ||
| 2117 | { | 2139 | { | ||
| 2118 | return m_matchCaseSensitivity; | 2140 | return m_matchCaseSensitivity; | ||
| 2119 | } | 2141 | } | ||
| 2120 | 2142 | | |||
| 2143 | Qt::CaseSensitivity KateCompletionModel::exactMatchCaseSensitivity() const | ||||
| 2144 | { | ||||
| 2145 | return m_exactMatchCaseSensitivity; | ||||
| 2146 | } | ||||
| 2147 | | ||||
| 2121 | void KateCompletionModel::addCompletionModel(KTextEditor::CodeCompletionModel *model) | 2148 | void KateCompletionModel::addCompletionModel(KTextEditor::CodeCompletionModel *model) | ||
| 2122 | { | 2149 | { | ||
| 2123 | if (m_completionModels.contains(model)) { | 2150 | if (m_completionModels.contains(model)) { | ||
| 2124 | return; | 2151 | return; | ||
| 2125 | } | 2152 | } | ||
| 2126 | 2153 | | |||
| 2127 | m_completionModels.append(model); | 2154 | m_completionModels.append(model); | ||
| 2128 | 2155 | | |||
| ▲ Show 20 Lines • Show All 276 Lines • Show Last 20 Lines | |||||
unrelated whitespace changes should be fixed in separate commits