Skip to main content :: ::

KDE API Reference

:: Skip to Link Menu

/ API Reference / kate

kateautoindent.cpp /* This file is part of the KDE libraries Copyright (C) 2003 Jesse Yurkovich <yurkjes@iit.edu> Copyright (C) 2004 >Anders Lund <anders@alweb.dk> (KateVarIndent class) Copyright (C) 2005 Dominik Haumann <dhdev@gmx.de> (basic support for config page) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2 as published by the Free Software Foundation. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "kateautoindent.h" #include "kateautoindent.moc" #include "kateconfig.h" #include "katehighlight.h" #include "katefactory.h" #include "katejscript.h" #include "kateview.h" #include <klocale.h> #include <kdebug.h> #include <kpopupmenu.h> #include <cctype> //BEGIN KateAutoIndent KateAutoIndent *KateAutoIndent::createIndenter (KateDocument *doc, uint mode) { if (mode == KateDocumentConfig::imNormal) return new KateNormalIndent (doc); else if (mode == KateDocumentConfig::imCStyle) return new KateCSmartIndent (doc); else if (mode == KateDocumentConfig::imPythonStyle) return new KatePythonIndent (doc); else if (mode == KateDocumentConfig::imXmlStyle) return new KateXmlIndent (doc); else if (mode == KateDocumentConfig::imCSAndS) return new KateCSAndSIndent (doc); else if ( mode == KateDocumentConfig::imVarIndent ) return new KateVarIndent ( doc ); // else if ( mode == KateDocumentConfig::imScriptIndent) // return new KateScriptIndent ( doc ); return new KateAutoIndent (doc); } QStringList KateAutoIndent::listModes () { QStringList l; l << modeDescription(KateDocumentConfig::imNone); l << modeDescription(KateDocumentConfig::imNormal); l << modeDescription(KateDocumentConfig::imCStyle); l << modeDescription(KateDocumentConfig::imPythonStyle); l << modeDescription(KateDocumentConfig::imXmlStyle); l << modeDescription(KateDocumentConfig::imCSAndS); l << modeDescription(KateDocumentConfig::imVarIndent); // l << modeDescription(KateDocumentConfig::imScriptIndent); return l; } QString KateAutoIndent::modeName (uint mode) { if (mode == KateDocumentConfig::imNormal) return QString ("normal"); else if (mode == KateDocumentConfig::imCStyle) return QString ("cstyle"); else if (mode == KateDocumentConfig::imPythonStyle) return QString ("python"); else if (mode == KateDocumentConfig::imXmlStyle) return QString ("xml"); else if (mode == KateDocumentConfig::imCSAndS) return QString ("csands"); else if ( mode == KateDocumentConfig::imVarIndent ) return QString( "varindent" ); // else if ( mode == KateDocumentConfig::imScriptIndent ) // return QString( "scriptindent" ); return QString ("none"); } QString KateAutoIndent::modeDescription (uint mode) { if (mode == KateDocumentConfig::imNormal) return i18n ("Normal"); else if (mode == KateDocumentConfig::imCStyle) return i18n ("C Style"); else if (mode == KateDocumentConfig::imPythonStyle) return i18n ("Python Style"); else if (mode == KateDocumentConfig::imXmlStyle) return i18n ("XML Style"); else if (mode == KateDocumentConfig::imCSAndS) return i18n ("S&S C Style"); else if ( mode == KateDocumentConfig::imVarIndent ) return i18n("Variable Based Indenter"); // else if ( mode == KateDocumentConfig::imScriptIndent ) // return i18n("JavaScript Indenter"); return i18n ("None"); } uint KateAutoIndent::modeNumber (const QString &name) { if (modeName(KateDocumentConfig::imNormal) == name) return KateDocumentConfig::imNormal; else if (modeName(KateDocumentConfig::imCStyle) == name) return KateDocumentConfig::imCStyle; else if (modeName(KateDocumentConfig::imPythonStyle) == name) return KateDocumentConfig::imPythonStyle; else if (modeName(KateDocumentConfig::imXmlStyle) == name) return KateDocumentConfig::imXmlStyle; else if (modeName(KateDocumentConfig::imCSAndS) == name) return KateDocumentConfig::imCSAndS; else if ( modeName( KateDocumentConfig::imVarIndent ) == name ) return KateDocumentConfig::imVarIndent; // else if ( modeName( KateDocumentConfig::imScriptIndent ) == name ) // return KateDocumentConfig::imScriptIndent; return KateDocumentConfig::imNone; } bool KateAutoIndent::hasConfigPage (uint mode) { // if ( mode == KateDocumentConfig::imScriptIndent ) // return true; return false; } IndenterConfigPage* KateAutoIndent::configPage(QWidget *parent, uint mode) { // if ( mode == KateDocumentConfig::imScriptIndent ) // return new ScriptIndentConfigPage(parent, "script_indent_config_page"); return 0; } KateAutoIndent::KateAutoIndent (KateDocument *_doc) : QObject(), doc(_doc) { } KateAutoIndent::~KateAutoIndent () { } //END KateAutoIndent //BEGIN KateViewIndentAction KateViewIndentationAction::KateViewIndentationAction(KateDocument *_doc, const QString& text, QObject* parent, const char* name) : KActionMenu (text, parent, name), doc(_doc) { connect(popupMenu(),SIGNAL(aboutToShow()),this,SLOT(slotAboutToShow())); } void KateViewIndentationAction::slotAboutToShow() { QStringList modes = KateAutoIndent::listModes (); popupMenu()->clear (); for (uint z=0; z<modes.size(); ++z) popupMenu()->insertItem ( '&' + KateAutoIndent::modeDescription(z).replace('&', "&&"), this, SLOT(setMode(int)), 0, z); popupMenu()->setItemChecked (doc->config()->indentationMode(), true); } void KateViewIndentationAction::setMode (int mode) { doc->config()->setIndentationMode((uint)mode); } //END KateViewIndentationAction //BEGIN KateNormalIndent KateNormalIndent::KateNormalIndent (KateDocument *_doc) : KateAutoIndent (_doc) { // if highlighting changes, update attributes connect(_doc, SIGNAL(hlChanged()), this, SLOT(updateConfig())); } KateNormalIndent::~KateNormalIndent () { } void KateNormalIndent::updateConfig () { KateDocumentConfig *config = doc->config(); useSpaces = config->configFlags() & KateDocument::cfSpaceIndent || config->configFlags() & KateDocumentConfig::cfReplaceTabsDyn; mixedIndent = useSpaces && config->configFlags() & KateDocumentConfig::cfMixedIndent; keepProfile = config->configFlags() & KateDocument::cfKeepIndentProfile; tabWidth = config->tabWidth(); indentWidth = useSpaces? config->indentationWidth() : tabWidth; commentAttrib = 255; doxyCommentAttrib = 255; regionAttrib = 255; symbolAttrib = 255; alertAttrib = 255; tagAttrib = 255; wordAttrib = 255; keywordAttrib = 255; normalAttrib = 255; extensionAttrib = 255; preprocessorAttrib = 255; KateHlItemDataList items; doc->highlight()->getKateHlItemDataListCopy (0, items); for (uint i=0; i<items.count(); i++) { QString name = items.at(i)->name; if (name.find("Comment") != -1 && commentAttrib == 255) { commentAttrib = i; } else if (name.find("Region Marker") != -1 && regionAttrib == 255) { regionAttrib = i; } else if (name.find("Symbol") != -1 && symbolAttrib == 255) { symbolAttrib = i; } else if (name.find("Alert") != -1) { alertAttrib = i; } else if (name.find("Comment") != -1 && commentAttrib != 255 && doxyCommentAttrib == 255) { doxyCommentAttrib = i; } else if (name.find("Tags") != -1 && tagAttrib == 255) { tagAttrib = i; } else if (name.find("Word") != -1 && wordAttrib == 255) { wordAttrib = i; } else if (name.find("Keyword") != -1 && keywordAttrib == 255) { keywordAttrib = i; } else if (name.find("Normal") != -1 && normalAttrib == 255) { normalAttrib = i; } else if (name.find("Extensions") != -1 && extensionAttrib == 255) { extensionAttrib = i; } else if (name.find("Preprocessor") != -1 && preprocessorAttrib == 255) { preprocessorAttrib = i; } } } bool KateNormalIndent::isBalanced (KateDocCursor &begin, const KateDocCursor &end, QChar open, QChar close, uint &pos) const { int parenOpen = 0; bool atLeastOne = false; bool getNext = false; pos = doc->plainKateTextLine(begin.line())->firstChar(); // Iterate one-by-one finding opening and closing chars // Assume that open and close are 'Symbol' characters while (begin < end) { QChar c = begin.currentChar(); if (begin.currentAttrib() == symbolAttrib) { if (c == open) { if (!atLeastOne) { atLeastOne = true; getNext = true; pos = measureIndent(begin) + 1; } parenOpen++; } else if (c == close) { parenOpen--; } } else if (getNext && !c.isSpace()) { getNext = false; pos = measureIndent(begin); } if (atLeastOne && parenOpen <= 0) return true; begin.moveForward(1); } return (atLeastOne) ? false : true; } bool KateNormalIndent::skipBlanks (KateDocCursor &cur, KateDocCursor &max, bool newline) const { int curLine = cur.line(); if (newline) cur.moveForward(1); if (cur >= max) return false; do { uchar attrib = cur.currentAttrib(); const QString hlFile = doc->highlight()->hlKeyForAttrib( attrib ); if (attrib != commentAttrib && attrib != regionAttrib && attrib != alertAttrib && attrib != preprocessorAttrib && !hlFile.endsWith("doxygen.xml")) { QChar c = cur.currentChar(); if (!c.isNull() && !c.isSpace()) break; } if (!cur.moveForward(1)) { // not able to move forward, so set cur to max cur = max; break; } // Make sure col is 0 if we spill into next line i.e. count the '\n' as a character if (curLine != cur.line()) { if (!newline) break; curLine = cur.line(); cur.setCol(0); } } while (cur < max); if (cur > max) cur = max; return true; } uint KateNormalIndent::measureIndent (KateDocCursor &cur) const { // We cannot short-cut by checking for useSpaces because there may be // tabs in the line despite this setting. return doc->plainKateTextLine(cur.line())->cursorX(cur.col(), tabWidth); } QString KateNormalIndent::tabString(uint pos) const { QString s; pos = kMin (pos, 80U); // sanity check for large values of pos if (!useSpaces || mixedIndent) { while (pos >= tabWidth) { s += '\t'; pos -= tabWidth; } } while (pos > 0) { s += ' '; pos--; } return s; } void KateNormalIndent::processNewline (KateDocCursor &begin, bool /*needContinue*/) { int line = begin.line() - 1; int pos = begin.col(); while ((line > 0) && (pos < 0)) // search a not empty text line pos = doc->plainKateTextLine(--line)->firstChar(); if (pos > 0) { QString filler = doc->text(line, 0, line, pos); doc->insertText(begin.line(), 0, filler); begin.setCol(filler.length()); } else begin.setCol(0); } //END //BEGIN KateCSmartIndent KateCSmartIndent::KateCSmartIndent (KateDocument *doc) : KateNormalIndent (doc), allowSemi (false), processingBlock (false) { kdDebug(13030)<<"CREATING KATECSMART INTDETER"<<endl; } KateCSmartIndent::~KateCSmartIndent () { } void KateCSmartIndent::processLine (KateDocCursor &line) { kdDebug(13030)<<"PROCESSING LINE "<<line.line()<<endl; KateTextLine::Ptr textLine = doc->plainKateTextLine(line.line()); int firstChar = textLine->firstChar(); // Empty line is worthless ... but only when doing more than 1 line if (firstChar == -1 && processingBlock) return; uint indent = 0; // TODO Here we do not check for beginning and ending comments ... QChar first = textLine->getChar(firstChar); QChar last = textLine->getChar(textLine->lastChar()); if (first == '}') { indent = findOpeningBrace(line); } else if (first == ')') { indent = findOpeningParen(line); } else if (first == '{') { // If this is the first brace, we keep the indent at 0 KateDocCursor temp(line.line(), firstChar, doc); if (!firstOpeningBrace(temp)) indent = calcIndent(temp, false); } else if (first == ':') { // Initialization lists (handle c++ and c#) int pos = findOpeningBrace(line); if (pos == 0) indent = indentWidth; else indent = pos + (indentWidth * 2); } else if (last == ':') { if (textLine->stringAtPos (firstChar, "case") || textLine->stringAtPos (firstChar, "default") || textLine->stringAtPos (firstChar, "public") || textLine->stringAtPos (firstChar, "private") || textLine->stringAtPos (firstChar, "protected") || textLine->stringAtPos (firstChar, "signals") || textLine->stringAtPos (firstChar, "Q_SIGNALS") || textLine->stringAtPos (firstChar, "Q_SLOTS") || textLine->stringAtPos (firstChar, "slots")) { indent = findOpeningBrace(line) + indentWidth; } } else if (first == '*') { if (last == '/') { int lineEnd = textLine->lastChar(); if (lineEnd > 0 && textLine->getChar(lineEnd - 1) == '*') { indent = findOpeningComment(line); if (textLine->attribute(firstChar) == doxyCommentAttrib) indent++; } else return; } else { KateDocCursor temp = line; if (textLine->attribute(firstChar) == doxyCommentAttrib) indent = calcIndent(temp, false) + 1; else indent = calcIndent(temp, true); } } else if (first == '#') { // c# regions if (textLine->stringAtPos (firstChar, "#region") || textLine->stringAtPos (firstChar, "#endregion")) { KateDocCursor temp = line; indent = calcIndent(temp, true); } } else { // Everything else ... if (first == '/' && last != '/') return; KateDocCursor temp = line; indent = calcIndent(temp, true); if (indent == 0) { KateNormalIndent::processNewline(line, true); return; } } // Slightly faster if we don't indent what we don't have to if (indent != measureIndent(line) || first == '}' || first == '{' || first == '#') { doc->removeText(line.line(), 0, line.line(), firstChar); QString filler = tabString(indent); if (indent > 0) doc->insertText(line.line(), 0, filler); if (!processingBlock) line.setCol(filler.length()); } } void KateCSmartIndent::processSection (const KateDocCursor &begin, const KateDocCursor &end) { kdDebug(13030)<<"PROCESS SECTION"<<endl; KateDocCursor cur = begin; QTime t; t.start(); processingBlock = (end.line() - cur.line() > 0) ? true : false; while (cur.line() <= end.line()) { processLine (cur); if (!cur.gotoNextLine()) break; } processingBlock = false; kdDebug(13030) << "+++ total: " << t.elapsed() << endl; } bool KateCSmartIndent::handleDoxygen (KateDocCursor &begin) { // Factor out the rather involved Doxygen stuff here ... int line = begin.line(); int first = -1; while ((line > 0) && (first < 0)) first = doc->plainKateTextLine(--line)->firstChar(); if (first >= 0) { KateTextLine::Ptr textLine = doc->plainKateTextLine(line); bool insideDoxygen = false; bool justAfterDoxygen = false; if (textLine->attribute(first) == doxyCommentAttrib || textLine->attribute(textLine->lastChar()) == doxyCommentAttrib) { const int last = textLine->lastChar(); if (last <= 0 || !(justAfterDoxygen = textLine->stringAtPos(last-1, "*/"))) insideDoxygen = true; if (justAfterDoxygen) justAfterDoxygen &= textLine->string().find("/**") < 0; while (textLine->attribute(first) != doxyCommentAttrib && first <= textLine->lastChar()) first++; if (textLine->stringAtPos(first, "//")) return false; } // Align the *'s and then go ahead and insert one too ... if (insideDoxygen) { textLine = doc->plainKateTextLine(begin.line()); first = textLine->firstChar(); int indent = findOpeningComment(begin); QString filler = tabString (indent); bool doxygenAutoInsert = doc->config()->configFlags() & KateDocumentConfig::cfDoxygenAutoTyping; if ( doxygenAutoInsert && ((first < 0) || (!textLine->stringAtPos(first, "*/") && !textLine->stringAtPos(first, "*")))) { filler = filler + " * "; } doc->removeText (begin.line(), 0, begin.line(), first); doc->insertText (begin.line(), 0, filler); begin.setCol(filler.length()); return true; } // Align position with beginning of doxygen comment. Otherwise the // indentation is one too much. else if (justAfterDoxygen) { textLine = doc->plainKateTextLine(begin.line()); first = textLine->firstChar(); int indent = findOpeningComment(begin); QString filler = tabString (indent); doc->removeText (begin.line(), 0, begin.line(), first); doc->insertText (begin.line(), 0, filler); begin.setCol(filler.length()); return true; } } return false; } void KateCSmartIndent::processNewline (KateDocCursor &begin, bool needContinue) { if (!handleDoxygen (begin)) { KateTextLine::Ptr textLine = doc->plainKateTextLine(begin.line()); bool inMiddle = textLine->firstChar() > -1; int indent = calcIndent (begin, needContinue); if (indent > 0 || inMiddle) { QString filler = tabString (indent); doc->insertText (begin.line(), 0, filler); begin.setCol(filler.length()); // Handles cases where user hits enter at the beginning or middle of text if (inMiddle) { processLine(begin); begin.setCol(textLine->firstChar()); } } else { KateNormalIndent::processNewline (begin, needContinue); } if (begin.col() < 0) begin.setCol(0); } } void KateCSmartIndent::processChar(QChar c) { // You may be curious about 'n' among the triggers: // It is used to discriminate C#'s #region/#endregion which are indented // against normal preprocessing statements which aren't indented. static const QString triggers("}{)/:#n"); static const QString firstTriggers("}{)/:#"); static const QString lastTriggers(":n"); if (triggers.find(c) < 0) return; KateView *view = doc->activeView(); KateDocCursor begin(view->cursorLine(), 0, doc); KateTextLine::Ptr textLine = doc->plainKateTextLine(begin.line()); const int first = textLine->firstChar(); const QChar firstChar = textLine->getChar(first); if (c == 'n') { if (firstChar != '#') return; } if ( c == '/' ) { // dominik: if line is "* /", change it to "*/" if ( textLine->attribute( begin.col() ) == doxyCommentAttrib ) { // if the first char exists and is a '*', and the next non-space-char // is already the just typed '/', concatenate it to "*/". if ( first != -1 && firstChar == '*' && textLine->nextNonSpaceChar( first+1 ) == view->cursorColumnReal()-1 ) doc->removeText( view->cursorLine(), first+1, view->cursorLine(), view->cursorColumnReal()-1); } // ls: never have comments change the indentation. return; } // ls: only reindent line if the user actually expects it // I. e. take action on single braces on line or last colon, but inhibit // any reindentation if any of those characters appear amidst some section // of the line const QChar lastChar = textLine->getChar(textLine->lastChar()); if ((c == firstChar && firstTriggers.find(firstChar) >= 0) || (c == lastChar && lastTriggers.find(lastChar) >= 0)) processLine(begin); } uint KateCSmartIndent::calcIndent(KateDocCursor &begin, bool needContinue) { KateTextLine::Ptr textLine; KateDocCursor cur = begin; uint anchorIndent = 0; int anchorPos = 0; int parenCount = 0; // Possibly in a multiline for stmt. Used to skip ';' ... bool found = false; bool isSpecial = false; bool potentialAnchorSeen = false; //kdDebug(13030) << "calcIndent begin line:" << begin.line() << " col:" << begin.col() << endl; // Find Indent Anchor Point while (cur.gotoPreviousLine()) { isSpecial = found = false; textLine = doc->plainKateTextLine(cur.line()); // Skip comments and handle cases like if (...) { stmt; int pos = textLine->lastChar(); int openCount = 0; int otherAnchor = -1; do { if (textLine->attribute(pos) == symbolAttrib) { QChar tc = textLine->getChar (pos); if ((tc == ';' || tc == ':' || tc == ',') && otherAnchor == -1 && parenCount <= 0) otherAnchor = pos, potentialAnchorSeen = true; else if (tc == ')') parenCount++; else if (tc == '(') parenCount--; else if (tc == '}') openCount--; else if (tc == '{') { openCount++, potentialAnchorSeen = true; if (openCount == 1) break; } } } while (--pos >= textLine->firstChar()); if (openCount != 0 || otherAnchor != -1) { found = true; QChar c; if (openCount > 0) c = '{'; else if (openCount < 0) c = '}'; else if (otherAnchor >= 0) c = textLine->getChar (otherAnchor); int specialIndent = 0; if (c == ':' && needContinue) { QChar ch; specialIndent = textLine->firstChar(); if (textLine->stringAtPos(specialIndent, "case")) ch = textLine->getChar(specialIndent + 4); else if (textLine->stringAtPos(specialIndent, "default")) ch = textLine->getChar(specialIndent + 7); else if (textLine->stringAtPos(specialIndent, "public")) ch = textLine->getChar(specialIndent + 6); else if (textLine->stringAtPos(specialIndent, "private")) ch = textLine->getChar(specialIndent + 7); else if (textLine->stringAtPos(specialIndent, "protected")) ch = textLine->getChar(specialIndent + 9); else if (textLine->stringAtPos(specialIndent, "signals")) ch = textLine->getChar(specialIndent + 7); else if (textLine->stringAtPos(specialIndent, "Q_SIGNALS")) ch = textLine->getChar(specialIndent + 9); else if (textLine->stringAtPos(specialIndent, "slots")) ch = textLine->getChar(specialIndent + 5); else if (textLine->stringAtPos(specialIndent, "Q_SLOTS")) ch = textLine->getChar(specialIndent + 7); if (ch.isNull() || (!ch.isSpace() && ch != '(' && ch != ':')) continue; KateDocCursor lineBegin = cur; lineBegin.setCol(specialIndent); specialIndent = measureIndent(lineBegin); isSpecial = true; } // Move forward past blank lines KateDocCursor skip = cur; skip.setCol(textLine->lastChar()); bool result = skipBlanks(skip, begin, true); anchorPos = skip.col(); anchorIndent = measureIndent(skip); //kdDebug(13030) << "calcIndent anchorPos:" << anchorPos << " anchorIndent:" << anchorIndent << " at line:" << skip.line() << endl; // Accept if it's before requested position or if it was special if (result && skip < begin) { cur = skip; break; } else if (isSpecial) { anchorIndent = specialIndent; break; } // Are these on a line by themselves? (i.e. both last and first char) if ((c == '{' || c == '}') && textLine->getChar(textLine->firstChar()) == c) { cur.setCol(anchorPos = textLine->firstChar()); anchorIndent = measureIndent (cur); break; } } } // treat beginning of document as anchor position if (cur.line() == 0 && cur.col() == 0 && potentialAnchorSeen) found = true; if (!found) return 0; uint continueIndent = (needContinue) ? calcContinue (cur, begin) : 0; //kdDebug(13030) << "calcIndent continueIndent:" << continueIndent << endl; // Move forward from anchor and determine last known reference character // Braces take precedance over others ... textLine = doc->plainKateTextLine(cur.line()); QChar lastChar = textLine->getChar (anchorPos); int lastLine = cur.line(); if (lastChar == '#' || lastChar == '[') { // Never continue if # or [ is encountered at this point here // A fail-safe really... most likely an #include, #region, or a c# attribute continueIndent = 0; } int openCount = 0; while (cur.validPosition() && cur < begin) { if (!skipBlanks(cur, begin, true)) return 0; QChar tc = cur.currentChar(); //kdDebug(13030) << " cur.line:" << cur.line() << " cur.col:" << cur.col() << " currentChar '" << tc << "' " << textLine->attribute(cur.col()) << endl; if (cur == begin || tc.isNull()) break; if (!tc.isSpace() && cur < begin) { uchar attrib = cur.currentAttrib(); if (tc == '{' && attrib == symbolAttrib) openCount++; else if (tc == '}' && attrib == symbolAttrib) openCount--; lastChar = tc; lastLine = cur.line(); } } if (openCount > 0) // Open braces override lastChar = '{'; uint indent = 0; //kdDebug(13030) << "calcIndent lastChar '" << lastChar << "'" << endl; if (lastChar == '{' || (lastChar == ':' && isSpecial && needContinue)) { indent = anchorIndent + indentWidth; } else if (lastChar == '}') { indent = anchorIndent; } else if (lastChar == ';') { indent = anchorIndent + ((allowSemi && needContinue) ? continueIndent : 0); } else if (lastChar == ',') { textLine = doc->plainKateTextLine(lastLine); KateDocCursor start(lastLine, textLine->firstChar(), doc); KateDocCursor finish(lastLine, textLine->lastChar(), doc); uint pos = 0; if (isBalanced(start, finish, QChar('('), QChar(')'), pos)) indent = anchorIndent; else { // TODO: Config option. If we're below 48, go ahead and line them up indent = ((pos < 48) ? pos : anchorIndent + (indentWidth * 2)); } } else if (!lastChar.isNull()) { if (anchorIndent != 0) indent = anchorIndent + continueIndent; else indent = continueIndent; } return indent; } uint KateCSmartIndent::calcContinue(KateDocCursor &start, KateDocCursor &end) { KateDocCursor cur = start; bool needsBalanced = true; bool isFor = false; allowSemi = false; KateTextLine::Ptr textLine = doc->plainKateTextLine(cur.line()); // Handle cases such as } while (s ... by skipping the leading symbol if (textLine->attribute(cur.col()) == symbolAttrib) { cur.moveForward(1); skipBlanks(cur, end, false); } if (textLine->getChar(cur.col()) == '}') { skipBlanks(cur, end, true); if (cur.line() != start.line()) textLine = doc->plainKateTextLine(cur.line()); if (textLine->stringAtPos(cur.col(), "else")) cur.setCol(cur.col() + 4); else return indentWidth * 2; needsBalanced = false; } else if (textLine->stringAtPos(cur.col(), "else")) { cur.setCol(cur.col() + 4); needsBalanced = false; int next = textLine->nextNonSpaceChar(cur.col()); if (next >= 0 && textLine->stringAtPos(next, "if")) { cur.setCol(next + 2); needsBalanced = true; } } else if (textLine->stringAtPos(cur.col(), "if")) { cur.setCol(cur.col() + 2); } else if (textLine->stringAtPos(cur.col(), "do")) { cur.setCol(cur.col() + 2); needsBalanced = false; } else if (textLine->stringAtPos(cur.col(), "for")) { cur.setCol(cur.col() + 3); isFor = true; } else if (textLine->stringAtPos(cur.col(), "while")) { cur.setCol(cur.col() + 5); } else if (textLine->stringAtPos(cur.col(), "switch")) { cur.setCol(cur.col() + 6); } else if (textLine->stringAtPos(cur.col(), "using")) { cur.setCol(cur.col() + 5); } else { return indentWidth * 2; } uint openPos = 0; if (needsBalanced && !isBalanced (cur, end, QChar('('), QChar(')'), openPos)) { allowSemi = isFor; if (openPos > 0) return (openPos - textLine->firstChar()); else return indentWidth * 2; } // Check if this statement ends a line now skipBlanks(cur, end, false); if (cur == end) return indentWidth; if (skipBlanks(cur, end, true)) { if (cur == end) return indentWidth; else return indentWidth + calcContinue(cur, end); } return 0; } uint KateCSmartIndent::findOpeningBrace(KateDocCursor &start) { KateDocCursor cur = start; int count = 1; // Move backwards 1 by 1 and find the opening brace // Return the indent of that line while (cur.moveBackward(1)) { if (cur.currentAttrib() == symbolAttrib) { QChar ch = cur.currentChar(); if (ch == '{') count--; else if (ch == '}') count++; if (count == 0) { KateDocCursor temp(cur.line(), doc->plainKateTextLine(cur.line())->firstChar(), doc); return measureIndent(temp); } } } return 0; } bool KateCSmartIndent::firstOpeningBrace(KateDocCursor &start) { KateDocCursor cur = start; // Are we the first opening brace at this level? while(cur.moveBackward(1)) { if (cur.currentAttrib() == symbolAttrib) { QChar ch = cur.currentChar(); if (ch == '{') return false; else if (ch == '}' && cur.col() == 0) break; } }