diff options
Diffstat (limited to 'qt/qextscintilla.cpp')
| -rw-r--r-- | qt/qextscintilla.cpp | 3031 |
1 files changed, 3031 insertions, 0 deletions
diff --git a/qt/qextscintilla.cpp b/qt/qextscintilla.cpp new file mode 100644 index 0000000..7d3290c --- /dev/null +++ b/qt/qextscintilla.cpp @@ -0,0 +1,3031 @@ +// This module implements the "official" high-level API of the Qt port of +// Scintilla. It is modelled on QTextEdit - a method of the same name should +// behave in the same way. +// +// Copyright (c) 2006 +// Riverbank Computing Limited <info@riverbankcomputing.co.uk> +// +// This file is part of QScintilla. +// +// This copy of QScintilla is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2, or (at your option) any +// later version. +// +// QScintilla is supplied 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 General Public License for more +// details. +// +// You should have received a copy of the GNU General Public License along with +// QScintilla; see the file LICENSE. If not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +#include <string.h> +#include <qapplication.h> +#include <qcolor.h> + +#include "qextscintilla.h" +#include "qextscintillalexer.h" +#include "qextscintillaapis.h" +#include "qextscintillacommandset.h" + + +// Make sure these match the values in Scintilla.h. We don't #include that +// file because it just causes more clashes. +#define KEYWORDSET_MAX 8 +#define MARKER_MAX 31 + + +// The default fold margin width. +static const int defaultFoldMarginWidth = 14; + +// The default set of characters that make up a word. +static const char *defaultWordChars = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; + + +// The ctor. +QextScintilla::QextScintilla(QWidget *parent,const char *name,WFlags f) + : QextScintillaBase(parent,name,f), allocatedMarkers(0), oldPos(-1), + selText(FALSE), fold(NoFoldStyle), autoInd(FALSE), + braceMode(NoBraceMatch), acSource(AcsDocument), acThresh(-1), + acStart(""), acAPIs(0), ctAPIs(0), maxCallTips(-1), + showSingle(FALSE), modified(FALSE), explicit_fillups(FALSE), + fillups_enabled(FALSE), saved_fillups("") +{ + connect(this,SIGNAL(SCN_MODIFYATTEMPTRO()), + SIGNAL(modificationAttempted())); + + connect(this,SIGNAL(SCN_MODIFIED(int,int,const char *,int,int,int,int,int)), + SLOT(handleModified(int,int,const char *,int,int,int,int,int))); + connect(this,SIGNAL(SCN_CALLTIPCLICK(int)), + SLOT(handleCallTipClick(int))); + connect(this,SIGNAL(SCN_CHARADDED(int)), + SLOT(handleCharAdded(int))); + connect(this,SIGNAL(SCN_MARGINCLICK(int,int,int)), + SLOT(handleMarginClick(int,int,int))); + connect(this,SIGNAL(SCN_SAVEPOINTREACHED()), + SLOT(handleSavePointReached())); + connect(this,SIGNAL(SCN_SAVEPOINTLEFT()), + SLOT(handleSavePointLeft())); + connect(this,SIGNAL(SCN_UPDATEUI()), + SLOT(handleUpdateUI())); + connect(this,SIGNAL(QSCN_SELCHANGED(bool)), + SLOT(handleSelectionChanged(bool))); + connect(this,SIGNAL(SCN_USERLISTSELECTION(const char *,int)), + SLOT(handleUserListSelection(const char *,int))); + + // Set the default font. + setFont(QApplication::font()); + + // Set the default fore and background colours. + QColorGroup cg = QApplication::palette().active(); + setColor(cg.text()); + setPaper(cg.base()); + +#if defined(Q_OS_WIN) + setEolMode(EolWindows); +#elif defined(Q_OS_MAC) + setEolMode(EolMac); +#else + setEolMode(EolUnix); +#endif + + // Capturing the mouse seems to cause problems on multi-head systems. + // Qt should do the right thing anyway. + SendScintilla(SCI_SETMOUSEDOWNCAPTURES,0UL); + + SendScintilla(SCI_SETPROPERTY,"fold","1"); + + setMatchedBraceForegroundColor(blue); + setUnmatchedBraceForegroundColor(red); + + setLexer(); + + // Set the visible policy. These are the same as SciTE's defaults + // which, presumably, are sensible. + SendScintilla(SCI_SETVISIBLEPOLICY,VISIBLE_STRICT|VISIBLE_SLOP,4); + + // Create the standard command set. + stdCmds = new QextScintillaCommandSet(this); + + doc.display(this,0); +} + + +// The dtor. +QextScintilla::~QextScintilla() +{ + doc.undisplay(this); + delete stdCmds; +} + + +// Return the current text colour. +QColor QextScintilla::color() const +{ + return nl_text_colour; +} + + +// Set the text colour. +void QextScintilla::setColor(const QColor &c) +{ + if (lex.isNull()) + { + // Assume style 0 applies to everything so that we don't need to use + // SCI_STYLECLEARALL which clears everything. + SendScintilla(SCI_STYLESETFORE, 0, c); + nl_text_colour = c; + } +} + + +// Return the current paper colour. +QColor QextScintilla::paper() const +{ + return nl_paper_colour; +} + + +// Set the paper colour. +void QextScintilla::setPaper(const QColor &c) +{ + if (lex.isNull()) + { + // Assume style 0 applies to everything so that we don't need to use + // SCI_STYLECLEARALL which clears everything. We still have to set the + // default style as well for the background without any text. + SendScintilla(SCI_STYLESETBACK, 0, c); + SendScintilla(SCI_STYLESETBACK, STYLE_DEFAULT, c); + nl_paper_colour = c; + } +} + + +// Set the default font. +void QextScintilla::setFont(const QFont &f) +{ + if (lex.isNull()) + { + // Assume style 0 applies to everything so that we don't need to use + // SCI_STYLECLEARALL which clears everything. + setStylesFont(f, 0); + nl_font = f; + } +} + + +// Enable/disable auto-indent. +void QextScintilla::setAutoIndent(bool autoindent) +{ + autoInd = autoindent; +} + + +// Set the brace matching mode. +void QextScintilla::setBraceMatching(BraceMatch bm) +{ + braceMode = bm; +} + + +// Handle the addition of a character. +void QextScintilla::handleCharAdded(int ch) +{ + // Ignore if there is a selection. + long pos = SendScintilla(SCI_GETSELECTIONSTART); + + if (pos != SendScintilla(SCI_GETSELECTIONEND) || pos == 0) + return; + + // If auto-completion is already active then see if this character is a + // start character. If it is then create a new list which will be a + // subset of the current one. The case where it isn't a start + // character seem to be handled correctly elsewhere. + if (isListActive()) + { + if (isAutoCStartChar(ch)) + { + cancelList(); + startAutoCompletion(acSource, FALSE, FALSE); + } + + return; + } + + // Handle call tips. + if (strchr("(),", ch) != NULL) + callTip(); + + // Handle auto-indentation. + if (autoInd) + if (lex.isNull() || (lex -> autoIndentStyle() & AiMaintain)) + maintainIndentation(ch,pos); + else + autoIndentation(ch,pos); + + // See if we might want to start auto-completion. + if (!isCallTipActive()) + if (isAutoCStartChar(ch)) + startAutoCompletion(acSource, FALSE, FALSE); + else if (acThresh >= 1 && isWordChar(ch)) + startAutoCompletion(acSource, TRUE, FALSE); +} + + +// See if a call tip is active. +bool QextScintilla::isCallTipActive() +{ + return SendScintilla(SCI_CALLTIPACTIVE); +} + + +// Handle a possible change to any current call tip. +void QextScintilla::callTip() +{ + if (!ctAPIs) + return; + + long pos = SendScintilla(SCI_GETCURRENTPOS); + long linenr = SendScintilla(SCI_LINEFROMPOSITION,pos); + long linelen = SendScintilla(SCI_LINELENGTH,linenr); + + char *lbuf = new char[linelen + 1]; + + int loff = SendScintilla(SCI_GETCURLINE,linelen + 1,lbuf); + + int commas = 0, start = -1; + + // Move backwards through the line looking for the start of the current + // call tip and working out which argument it is. + while (loff > 0) + { + char ch = lbuf[--loff]; + + if (ch == ',') + ++commas; + else if (ch == ')') + { + int depth = 1; + + // Ignore everything back to the start of the + // corresponding parenthesis. + while (loff > 0) + { + ch = lbuf[--loff]; + + if (ch == ')') + ++depth; + else if (ch == '(' && --depth == 0) + break; + } + } + else if (ch == '(' && loff > 0) + { + if (isWordChar(lbuf[loff - 1])) + { + // The parenthesis is preceded by a word so + // find the start of that word. + lbuf[loff--] = '\0'; + + while (loff >= 0) + { + if (!isWordChar(lbuf[loff]) && !isAutoCStartChar(lbuf[loff])) + break; + + --loff; + } + + start = loff + 1; + break; + } + + // We are between parentheses that do not correspond to + // a call tip, so reset the argument count. + commas = 0; + } + } + + // Cancel any existing call tip. + SendScintilla(SCI_CALLTIPCANCEL); + + // Done if there is no new call tip to set. + if (start < 0) + { + delete []lbuf; + return; + } + + QString ct = ctAPIs -> callTips(&lbuf[start],maxCallTips,commas); + + delete []lbuf; + + if (ct.isEmpty()) + return; + + ctpos = SendScintilla(SCI_POSITIONFROMLINE,linenr) + start; + + SendScintilla(SCI_CALLTIPSHOW,ctpos,ct.latin1()); + + // Done if there is more than one line in the call tip or there isn't a + // down arrow at the start. + if (ct[0] == '\002' || ct.find('\n') >= 0) + return; + + // Highlight the current argument. + int astart; + + if (commas == 0) + astart = ct.find('('); + else + { + astart = -1; + + do + astart = ct.find(',',astart + 1); + while (astart >= 0 && --commas > 0); + } + + int len = ct.length(); + + if (astart < 0 || ++astart == len) + return; + + // The end is at the next comma or unmatched closing parenthesis. + int aend, depth = 0; + + for (aend = astart; aend < len; ++aend) + { + QChar ch = ct.at(aend); + + if (ch == ',' && depth == 0) + break; + else if (ch == '(') + ++depth; + else if (ch == ')') + { + if (depth == 0) + break; + + --depth; + } + } + + if (astart != aend) + SendScintilla(SCI_CALLTIPSETHLT,astart,aend); +} + + +// Handle a call tip click. +void QextScintilla::handleCallTipClick(int dir) +{ + if (!ctAPIs) + return; + + QString ct = ctAPIs -> callTipsNextPrev(dir); + + if (ct.isNull()) + return; + + SendScintilla(SCI_CALLTIPSHOW,ctpos,ct.latin1()); +} + + +// Possibly start auto-completion. +void QextScintilla::startAutoCompletion(AutoCompletionSource acs, + bool checkThresh, bool single) +{ + // Get the current line. + long len = SendScintilla(SCI_GETCURLINE) + 1; + + char *line = new char[len]; + + int wend = SendScintilla(SCI_GETCURLINE, len, line); + + // Find the start of the auto-completion text. + int wstart = wend; + bool numeric = true; + + while (wstart > 0) + { + char ch = line[wstart - 1]; + + // Don't auto-complete numbers. + if (ch < '0' || ch > '9') + numeric = false; + + if (!isWordChar(ch) && !isAutoCStartChar(ch)) + break; + + --wstart; + } + + int wlen = wend - wstart; + + if (numeric || wlen == 0 || (checkThresh && wlen < acThresh)) + return; + + // Isolate the auto-completion text. + char *word = &line[wstart]; + line[wend] = '\0'; + + // Generate the string representing the valid words to select from. + QStringList wlist; + bool cs = !SendScintilla(SCI_AUTOCGETIGNORECASE); + + if (acs == AcsAll || acs == AcsDocument) + { + SendScintilla(SCI_SETSEARCHFLAGS,SCFIND_WORDSTART | (cs ? SCFIND_MATCHCASE : 0)); + + long pos = 0; + long dlen = SendScintilla(SCI_GETLENGTH); + long caret = SendScintilla(SCI_GETCURRENTPOS); + QString root(word); + + for (;;) + { + long fstart; + + SendScintilla(SCI_SETTARGETSTART,pos); + SendScintilla(SCI_SETTARGETEND,dlen); + + if ((fstart = SendScintilla(SCI_SEARCHINTARGET,wlen,word)) < 0) + break; + + // Move past the root part. + pos = fstart + wlen; + + // Skip if this is the word we are auto-completing. + if (pos == caret) + continue; + + // Get the rest of this word. + QString w(root); + + while (pos < dlen) + { + char ch = SendScintilla(SCI_GETCHARAT,pos); + + if (!isWordChar(ch)) + break; + + w += ch; + + ++pos; + } + + // Add the word if it isn't already there. + if (wlist.findIndex(w) < 0) + wlist.append(w); + } + } + + if ((acs == AcsAll || acs == AcsAPIs) && acAPIs) + acAPIs->autoCompletionList(word, cs, wlist); + + delete []line; + + if (wlist.isEmpty()) + return; + + wlist.sort(); + + const char sep = '\x03'; + + SendScintilla(SCI_AUTOCSETCHOOSESINGLE,single); + SendScintilla(SCI_AUTOCSETSEPARATOR, sep); + SendScintilla(SCI_AUTOCSHOW, wlen, wlist.join(QChar(sep)).latin1()); +} + + +// Check if a character is an auto-completion start character. +bool QextScintilla::isAutoCStartChar(char ch) const +{ + const char *start_chars = 0; + + if (!lex.isNull()) + start_chars = lex->autoCompletionStartCharacters(); + + if (!start_chars) + start_chars = acStart; + + return (strchr(start_chars, ch) != NULL); +} + + +// Maintain the indentation of the previous line. +void QextScintilla::maintainIndentation(char ch,long pos) +{ + if (ch != '\r' && ch != '\n') + return; + + int curr_line = SendScintilla(SCI_LINEFROMPOSITION,pos); + + // Get the indentation of the preceding non-zero length line. + int ind = 0; + + for (int line = curr_line - 1; line >= 0; --line) + { + if (SendScintilla(SCI_GETLINEENDPOSITION,line) > + SendScintilla(SCI_POSITIONFROMLINE,line)) + { + ind = indentation(line); + break; + } + } + + if (ind > 0) + autoIndentLine(pos,curr_line,ind); +} + + +// Implement auto-indentation. +void QextScintilla::autoIndentation(char ch,long pos) +{ + int curr_line = SendScintilla(SCI_LINEFROMPOSITION,pos); + int ind_width = indentationWidth(); + long curr_line_start = SendScintilla(SCI_POSITIONFROMLINE,curr_line); + + const char *block_start = lex -> blockStart(); + bool start_single = (block_start && strlen(block_start) == 1); + + const char *block_end = lex -> blockEnd(); + bool end_single = (block_end && strlen(block_end) == 1); + + if (end_single && block_end[0] == ch) + { + if ((lex -> autoIndentStyle() & AiClosing) && rangeIsWhitespace(curr_line_start,pos - 1)) + autoIndentLine(pos,curr_line,blockIndent(curr_line - 1) - indentationWidth()); + } + else if (start_single && block_start[0] == ch) + { + // De-indent if we have already indented because the previous + // line was a start of block keyword. + if ((lex->autoIndentStyle() & AiOpening) && curr_line > 0 && getIndentState(curr_line - 1) == isKeywordStart && rangeIsWhitespace(curr_line_start, pos - 1)) + autoIndentLine(pos,curr_line,blockIndent(curr_line - 1) - indentationWidth()); + } + else if (ch == '\r' || ch == '\n') + autoIndentLine(pos,curr_line,blockIndent(curr_line - 1)); +} + + +// Set the indentation for a line. +void QextScintilla::autoIndentLine(long pos,int line,int indent) +{ + if (indent < 0) + return; + + long pos_before = SendScintilla(SCI_GETLINEINDENTPOSITION,line); + SendScintilla(SCI_SETLINEINDENTATION,line,indent); + long pos_after = SendScintilla(SCI_GETLINEINDENTPOSITION,line); + long new_pos = -1; + + if (pos_after > pos_before) + new_pos = pos + (pos_after - pos_before); + else if (pos_after < pos_before && pos >= pos_after) + if (pos >= pos_before) + new_pos = pos + (pos_after - pos_before); + else + new_pos = pos_after; + + if (new_pos >= 0) + SendScintilla(SCI_SETSEL,new_pos,new_pos); +} + + +// Return the indentation of the block defined by the given line (or something +// significant before). +int QextScintilla::blockIndent(int line) +{ + if (line < 0) + return 0; + + // Handle the trvial case. + if (!lex -> blockStartKeyword() && !lex -> blockStart() && !lex -> blockEnd()) + return indentation(line); + + int line_limit = line - lex -> blockLookback(); + + if (line_limit < 0) + line_limit = 0; + + for (int l = line; l >= line_limit; --l) + { + IndentState istate = getIndentState(l); + + if (istate != isNone) + { + int ind_width = indentationWidth(); + int ind = indentation(l); + + if (istate == isBlockStart) + { + if (lex -> autoIndentStyle() & AiOpening) + ind += ind_width; + } + else if (istate == isBlockEnd) + { + if (!(lex -> autoIndentStyle() & AiClosing)) + ind -= ind_width; + + if (ind < 0) + ind = 0; + } + else if (line == l) + ind += ind_width; + + return ind; + } + } + + return indentation(line); +} + + +// Return TRUE if all characters starting at spos up to, but not including +// epos, are spaces or tabs. +bool QextScintilla::rangeIsWhitespace(long spos,long epos) +{ + while (spos < epos) + { + char ch = SendScintilla(SCI_GETCHARAT,spos); + + if (ch != ' ' && ch != '\t') + return FALSE; + + ++spos; + } + + return TRUE; +} + + +// Returns the indentation state of a line. +QextScintilla::IndentState QextScintilla::getIndentState(int line) +{ + IndentState istate; + + // Get the styled text. + long spos = SendScintilla(SCI_POSITIONFROMLINE,line); + long epos = SendScintilla(SCI_POSITIONFROMLINE,line + 1); + + char *text = new char[(epos - spos + 1) * 2]; + + SendScintilla(SCI_GETSTYLEDTEXT,spos,epos,text); + + int style, bstart_off, bend_off; + + // Block start/end takes precedence over keywords. + const char *bstart_words = lex->blockStart(&style); + bstart_off = findStyledWord(text, style, bstart_words); + + const char *bend_words = lex->blockEnd(&style); + bend_off = findStyledWord(text, style, bend_words); + + // If there is a block start but no block end characters then ignore it + // unless the block start is the last significant thing on the line, + // ie. assume Python-like blocking. + if (bstart_off >= 0 && !bend_words) + for (int i = bstart_off * 2; text[i] != '\0'; i += 2) + if (!QChar(text[i]).isSpace()) + return isNone; + + if (bstart_off > bend_off) + istate = isBlockStart; + else if (bend_off > bstart_off) + istate = isBlockEnd; + else + { + const char *words = lex->blockStartKeyword(&style); + + istate = (findStyledWord(text,style,words) >= 0) ? isKeywordStart : isNone; + } + + delete[] text; + + return istate; +} + + +// text is a pointer to some styled text (ie. a character byte followed by a +// style byte). style is a style number. words is a space separated list of +// words. Returns the position in the text immediately after the last one of +// the words with the style. The reason we are after the last, and not the +// first, occurance is that we are looking for words that start and end a block +// where the latest one is the most significant. +int QextScintilla::findStyledWord(const char *text,int style,const char *words) +{ + if (!words) + return -1; + + // Find the range of text with the style we are looking for. + const char *stext; + + for (stext = text; stext[1] != style; stext += 2) + if (stext[0] == '\0') + return -1; + + // Move to the last character. + const char *etext = stext; + + while (etext[2] != '\0') + etext += 2; + + // Backtrack until we find the style. There will be one. + while (etext[1] != style) + etext -= 2; + + // Look for each word in turn. + while (words[0] != '\0') + { + // Find the end of the word. + const char *eword = words; + + while (eword[1] != ' ' && eword[1] != '\0') + ++eword; + + // Now search the text backwards. + const char *wp = eword; + + for (const char *tp = etext; tp >= stext; tp -= 2) + { + if (tp[0] != wp[0] || tp[1] != style) + { + // Reset the search. + wp = eword; + continue; + } + + // See if all the word has matched. + if (wp-- == words) + return ((tp - text) / 2) + (eword - words) + 1; + } + + // Move to the start of the next word if there is one. + words = eword + 1; + + if (words[0] == ' ') + ++words; + } + + return -1; +} + + +// Return TRUE if the code page is UTF8. +bool QextScintilla::isUtf8() +{ + return (SendScintilla(SCI_GETCODEPAGE) == SC_CP_UTF8); +} + + +// Set the code page. +void QextScintilla::setUtf8(bool cp) +{ + SendScintilla(SCI_SETCODEPAGE,(cp ? SC_CP_UTF8 : 0)); +} + + +// Return the end-of-line mode. +QextScintilla::EolMode QextScintilla::eolMode() +{ + return (EolMode)SendScintilla(SCI_GETEOLMODE); +} + + +// Set the end-of-line mode. +void QextScintilla::setEolMode(EolMode mode) +{ + SendScintilla(SCI_SETEOLMODE,mode); +} + + +// Convert the end-of-lines to a particular mode. +void QextScintilla::convertEols(EolMode mode) +{ + SendScintilla(SCI_CONVERTEOLS,mode); +} + + +// Return the edge colour. +QColor QextScintilla::edgeColor() +{ + long res = SendScintilla(SCI_GETEDGECOLOUR); + + return QColor((int)res, ((int)(res >> 8)) & 0x00ff, ((int)(res >> 16)) & 0x00ff); +} + + +// Set the edge colour. +void QextScintilla::setEdgeColor(const QColor &col) +{ + SendScintilla(SCI_SETEDGECOLOUR,col); +} + + +// Return the edge column. +int QextScintilla::edgeColumn() +{ + return SendScintilla(SCI_GETEDGECOLUMN); +} + + +// Set the edge column. +void QextScintilla::setEdgeColumn(int colnr) +{ + SendScintilla(SCI_SETEDGECOLUMN,colnr); +} + + +// Return the edge mode. +QextScintilla::EdgeMode QextScintilla::edgeMode() +{ + return (EdgeMode)SendScintilla(SCI_GETEDGEMODE); +} + + +// Set the edge mode. +void QextScintilla::setEdgeMode(EdgeMode mode) +{ + SendScintilla(SCI_SETEDGEMODE,mode); +} + + +// Return the end-of-line visibility. +bool QextScintilla::eolVisibility() +{ + return SendScintilla(SCI_GETVIEWEOL); +} + + +// Set the end-of-line visibility. +void QextScintilla::setEolVisibility(bool visible) +{ + SendScintilla(SCI_SETVIEWEOL,visible); +} + + +// Return the whitespace visibility. +QextScintilla::WhitespaceVisibility QextScintilla::whitespaceVisibility() +{ + return (WhitespaceVisibility)SendScintilla(SCI_GETVIEWWS); +} + + +// Set the whitespace visibility. +void QextScintilla::setWhitespaceVisibility(WhitespaceVisibility mode) +{ + SendScintilla(SCI_SETVIEWWS,mode); +} + + +// Return the line wrap mode. +QextScintilla::WrapMode QextScintilla::wrapMode() +{ + return (WrapMode)SendScintilla(SCI_GETWRAPMODE); +} + + +// Set the line wrap mode. +void QextScintilla::setWrapMode(WrapMode mode) +{ + SendScintilla(SCI_SETLAYOUTCACHE, (mode == WrapNone ? SC_CACHE_CARET : SC_CACHE_DOCUMENT)); + SendScintilla(SCI_SETWRAPMODE, mode); +} + + +// Set the line wrap visual flags. +void QextScintilla::setWrapVisualFlags(WrapVisualFlag eflag, + WrapVisualFlag sflag, int sindent) +{ + int flags = SC_WRAPVISUALFLAG_NONE; + int loc = SC_WRAPVISUALFLAGLOC_DEFAULT; + + if (eflag == WrapFlagByText) + { + flags |= SC_WRAPVISUALFLAG_END; + loc |= SC_WRAPVISUALFLAGLOC_END_BY_TEXT; + } + else if (eflag == WrapFlagByBorder) + flags |= SC_WRAPVISUALFLAG_END; + + if (sflag == WrapFlagByText) + { + flags |= SC_WRAPVISUALFLAG_START; + loc |= SC_WRAPVISUALFLAGLOC_START_BY_TEXT; + } + else if (sflag == WrapFlagByBorder) + flags |= SC_WRAPVISUALFLAG_START; + + SendScintilla(SCI_SETWRAPVISUALFLAGS, flags); + SendScintilla(SCI_SETWRAPVISUALFLAGSLOCATION, loc); + SendScintilla(SCI_SETWRAPSTARTINDENT, sindent); +} + + +// Set the folding style. +void QextScintilla::setFolding(FoldStyle folding) +{ + fold = folding; + + if (folding == NoFoldStyle) + { + SendScintilla(SCI_SETMARGINWIDTHN,2,0L); + return; + } + + int mask = SendScintilla(SCI_GETMODEVENTMASK); + SendScintilla(SCI_SETMODEVENTMASK,mask | SC_MOD_CHANGEFOLD); + + SendScintilla(SCI_SETFOLDFLAGS,SC_FOLDFLAG_LINEAFTER_CONTRACTED); + + SendScintilla(SCI_SETMARGINTYPEN,2,(long)SC_MARGIN_SYMBOL); + SendScintilla(SCI_SETMARGINMASKN,2,SC_MASK_FOLDERS); + SendScintilla(SCI_SETMARGINSENSITIVEN,2,1); + + // Set the marker symbols to use. + switch (folding) + { + case PlainFoldStyle: + setFoldMarker(SC_MARKNUM_FOLDEROPEN,SC_MARK_MINUS); + setFoldMarker(SC_MARKNUM_FOLDER,SC_MARK_PLUS); + setFoldMarker(SC_MARKNUM_FOLDERSUB); + setFoldMarker(SC_MARKNUM_FOLDERTAIL); + setFoldMarker(SC_MARKNUM_FOLDEREND); + setFoldMarker(SC_MARKNUM_FOLDEROPENMID); + setFoldMarker(SC_MARKNUM_FOLDERMIDTAIL); + + break; + + case CircledFoldStyle: + setFoldMarker(SC_MARKNUM_FOLDEROPEN,SC_MARK_CIRCLEMINUS); + setFoldMarker(SC_MARKNUM_FOLDER,SC_MARK_CIRCLEPLUS); + setFoldMarker(SC_MARKNUM_FOLDERSUB); + setFoldMarker(SC_MARKNUM_FOLDERTAIL); + setFoldMarker(SC_MARKNUM_FOLDEREND); + setFoldMarker(SC_MARKNUM_FOLDEROPENMID); + setFoldMarker(SC_MARKNUM_FOLDERMIDTAIL); + + break; + + case BoxedFoldStyle: + setFoldMarker(SC_MARKNUM_FOLDEROPEN,SC_MARK_BOXMINUS); + setFoldMarker(SC_MARKNUM_FOLDER,SC_MARK_BOXPLUS); + setFoldMarker(SC_MARKNUM_FOLDERSUB); + setFoldMarker(SC_MARKNUM_FOLDERTAIL); + setFoldMarker(SC_MARKNUM_FOLDEREND); + setFoldMarker(SC_MARKNUM_FOLDEROPENMID); + setFoldMarker(SC_MARKNUM_FOLDERMIDTAIL); + + break; + + case CircledTreeFoldStyle: + setFoldMarker(SC_MARKNUM_FOLDEROPEN,SC_MARK_CIRCLEMINUS); + setFoldMarker(SC_MARKNUM_FOLDER,SC_MARK_CIRCLEPLUS); + setFoldMarker(SC_MARKNUM_FOLDERSUB,SC_MARK_VLINE); + setFoldMarker(SC_MARKNUM_FOLDERTAIL,SC_MARK_LCORNERCURVE); + setFoldMarker(SC_MARKNUM_FOLDEREND,SC_MARK_CIRCLEPLUSCONNECTED); + setFoldMarker(SC_MARKNUM_FOLDEROPENMID,SC_MARK_CIRCLEMINUSCONNECTED); + setFoldMarker(SC_MARKNUM_FOLDERMIDTAIL,SC_MARK_TCORNERCURVE); + + break; + + case BoxedTreeFoldStyle: + setFoldMarker(SC_MARKNUM_FOLDEROPEN,SC_MARK_BOXMINUS); + setFoldMarker(SC_MARKNUM_FOLDER,SC_MARK_BOXPLUS); + setFoldMarker(SC_MARKNUM_FOLDERSUB,SC_MARK_VLINE); + setFoldMarker(SC_MARKNUM_FOLDERTAIL,SC_MARK_LCORNER); + setFoldMarker(SC_MARKNUM_FOLDEREND,SC_MARK_BOXPLUSCONNECTED); + setFoldMarker(SC_MARKNUM_FOLDEROPENMID,SC_MARK_BOXMINUSCONNECTED); + setFoldMarker(SC_MARKNUM_FOLDERMIDTAIL,SC_MARK_TCORNER); + + break; + } + + SendScintilla(SCI_SETMARGINWIDTHN,2,defaultFoldMarginWidth); +} + + +// Set up a folder marker. +void QextScintilla::setFoldMarker(int marknr,int mark) +{ + SendScintilla(SCI_MARKERDEFINE,marknr,mark); + + if (mark != SC_MARK_EMPTY) + { + SendScintilla(SCI_MARKERSETFORE,marknr,white); + SendScintilla(SCI_MARKERSETBACK,marknr,black); + } +} + + +// Handle a click in the fold margin. This is mostly taken from SciTE. +void QextScintilla::foldClick(int lineClick,int bstate) +{ + if ((bstate & ShiftButton) && (bstate & ControlButton)) + { + foldAll(); + return; + } + + int levelClick = SendScintilla(SCI_GETFOLDLEVEL,lineClick); + + if (levelClick & SC_FOLDLEVELHEADERFLAG) + { + if (bstate & ShiftButton) + { + // Ensure all children are visible. + SendScintilla(SCI_SETFOLDEXPANDED,lineClick,1); + foldExpand(lineClick,TRUE,TRUE,100,levelClick); + } + else if (bstate & ControlButton) + { + if (SendScintilla(SCI_GETFOLDEXPANDED,lineClick)) + { + // Contract this line and all its children. + SendScintilla(SCI_SETFOLDEXPANDED,lineClick,0L); + foldExpand(lineClick,FALSE,TRUE,0,levelClick); + } + else + { + // Expand this line and all its children. + SendScintilla(SCI_SETFOLDEXPANDED,lineClick,1); + foldExpand(lineClick,TRUE,TRUE,100,levelClick); + } + } + else + { + // Toggle this line. + SendScintilla(SCI_TOGGLEFOLD,lineClick); + } + } +} + + +// Do the hard work of hiding and showing lines. This is mostly taken from +// SciTE. +void QextScintilla::foldExpand(int &line,bool doExpand,bool force, + int visLevels,int level) +{ + int lineMaxSubord = SendScintilla(SCI_GETLASTCHILD,line,level & SC_FOLDLEVELNUMBERMASK); + + line++; + + while (line <= lineMaxSubord) + { + if (force) + { + if (visLevels > 0) + SendScintilla(SCI_SHOWLINES,line,line); + else + SendScintilla(SCI_HIDELINES,line,line); + } + else if (doExpand) + SendScintilla(SCI_SHOWLINES,line,line); + + int levelLine = level; + + if (levelLine == -1) + levelLine = SendScintilla(SCI_GETFOLDLEVEL,line); + + if (levelLine & SC_FOLDLEVELHEADERFLAG) + { + if (force) + { + if (visLevels > 1) + SendScintilla(SCI_SETFOLDEXPANDED,line,1); + else + SendScintilla(SCI_SETFOLDEXPANDED,line,0L); + + foldExpand(line,doExpand,force,visLevels - 1); + } + else if (doExpand) + { + if (!SendScintilla(SCI_GETFOLDEXPANDED,line)) + SendScintilla(SCI_SETFOLDEXPANDED,line,1); + + foldExpand(line,TRUE,force,visLevels - 1); + } + else + foldExpand(line,FALSE,force,visLevels - 1); + } + else + line++; + } +} + + +// Fully expand (if there is any line currently folded) all text. Otherwise, +// fold all text. This is mostly taken from SciTE. +void QextScintilla::foldAll(bool children) +{ + recolor(); + + int maxLine = SendScintilla(SCI_GETLINECOUNT); + bool expanding = TRUE; + + for (int lineSeek = 0; lineSeek < maxLine; lineSeek++) + { + if (SendScintilla(SCI_GETFOLDLEVEL,lineSeek) & SC_FOLDLEVELHEADERFLAG) + { + expanding = !SendScintilla(SCI_GETFOLDEXPANDED,lineSeek); + break; + } + } + + for (int line = 0; line < maxLine; line++) + { + int level = SendScintilla(SCI_GETFOLDLEVEL,line); + + if (!(level & SC_FOLDLEVELHEADERFLAG)) + continue; + + if (children || + (SC_FOLDLEVELBASE == (level & SC_FOLDLEVELNUMBERMASK))) + { + if (expanding) + { + SendScintilla(SCI_SETFOLDEXPANDED,line,1); + foldExpand(line,TRUE,FALSE,0,level); + line--; + } + else + { + int lineMaxSubord = SendScintilla(SCI_GETLASTCHILD,line,-1); + + SendScintilla(SCI_SETFOLDEXPANDED,line,0L); + + if (lineMaxSubord > line) + SendScintilla(SCI_HIDELINES,line + 1,lineMaxSubord); + } + } + } +} + + +// Handle a fold change. This is mostly taken from SciTE. +void QextScintilla::foldChanged(int line,int levelNow,int levelPrev) +{ + if (levelNow & SC_FOLDLEVELHEADERFLAG) + { + if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) + SendScintilla(SCI_SETFOLDEXPANDED,line,1); + } + else if (levelPrev & SC_FOLDLEVELHEADERFLAG) + { + if (!SendScintilla(SCI_GETFOLDEXPANDED,line)) + { + // Removing the fold from one that has been contracted + // so should expand. Otherwise lines are left + // invisible with no way to make them visible. + foldExpand(line,TRUE,FALSE,0,levelPrev); + } + } +} + + +// Toggle the fold for a line if it contains a fold marker. +void QextScintilla::foldLine(int line) +{ + SendScintilla(SCI_TOGGLEFOLD,line); +} + + +// Handle the SCN_MODIFIED notification. +void QextScintilla::handleModified(int pos,int mtype,const char *text,int len, + int added,int line,int foldNow,int foldPrev) +{ + if (mtype & SC_MOD_CHANGEFOLD) + { + if (fold) + foldChanged(line,foldNow,foldPrev); + } + else if (mtype & (SC_MOD_INSERTTEXT | SC_MOD_DELETETEXT)) + emit textChanged(); +} + + +// Zoom in a number of points. +void QextScintilla::zoomIn(int range) +{ + zoomTo(SendScintilla(SCI_GETZOOM) + range); +} + + +// Zoom in a single point. +void QextScintilla::zoomIn() +{ + SendScintilla(SCI_ZOOMIN); +} + + +// Zoom out a number of points. +void QextScintilla::zoomOut(int range) +{ + zoomTo(SendScintilla(SCI_GETZOOM) - range); +} + + +// Zoom out a single point. +void QextScintilla::zoomOut() +{ + SendScintilla(SCI_ZOOMOUT); +} + + +// Set the zoom to a number of points. +void QextScintilla::zoomTo(int size) +{ + if (size < -10) + size = -10; + else if (size > 20) + size = 20; + + SendScintilla(SCI_SETZOOM,size); +} + + +// Find the first occurrence of a string. +bool QextScintilla::findFirst(const QString &expr,bool re,bool cs,bool wo, + bool wrap,bool forward,int line,int index, + bool show) +{ + findState.inProgress = FALSE; + + if (expr.isEmpty()) + return FALSE; + + findState.expr = expr; + findState.wrap = wrap; + findState.forward = forward; + + findState.flags = (cs ? SCFIND_MATCHCASE : 0) | + (wo ? SCFIND_WHOLEWORD : 0) | + (re ? SCFIND_REGEXP : 0); + + if (line < 0 || index < 0) + findState.startpos = SendScintilla(SCI_GETCURRENTPOS); + else + findState.startpos = posFromLineIndex(line,index); + + if (forward) + findState.endpos = SendScintilla(SCI_GETLENGTH); + else + findState.endpos = 0; + + findState.show = show; + + return doFind(); +} + + +// Find the next occurrence of a string. +bool QextScintilla::findNext() +{ + if (!findState.inProgress) + return FALSE; + + return doFind(); +} + + +// Do the hard work of findFirst() and findNext(). +bool QextScintilla::doFind() +{ + SendScintilla(SCI_SETSEARCHFLAGS,findState.flags); + + long pos = simpleFind(); + + // See if it was found. If not and wraparound is wanted, try again. + if (pos == -1 && findState.wrap) + { + if (findState.forward) + { + findState.startpos = 0; + findState.endpos = SendScintilla(SCI_GETLENGTH); + } + else + { + findState.startpos = SendScintilla(SCI_GETLENGTH); + findState.endpos = 0; + } + + pos = simpleFind(); + } + + if (pos == -1) + { + findState.inProgress = FALSE; + return FALSE; + } + + // It was found. + long targstart = SendScintilla(SCI_GETTARGETSTART); + long targend = SendScintilla(SCI_GETTARGETEND); + + // Ensure the text found is visible if required. + if (findState.show) + { + int startLine = SendScintilla(SCI_LINEFROMPOSITION,targstart); + int endLine = SendScintilla(SCI_LINEFROMPOSITION,targend); + + for (int i = startLine; i <= endLine; ++i) + SendScintilla(SCI_ENSUREVISIBLEENFORCEPOLICY,i); + } + + // Now set the selection. + SendScintilla(SCI_SETSEL,targstart,targend); + + // Finally adjust the start position so that we don't find the same one + // again. + if (findState.forward) + findState.startpos = targend; + else if ((findState.startpos = targstart - 1) < 0) + findState.startpos = 0; + + findState.inProgress = TRUE; + return TRUE; +} + + +// Do a simple find between the start and end positions. +long QextScintilla::simpleFind() +{ + if (findState.startpos == findState.endpos) + return -1; + + SendScintilla(SCI_SETTARGETSTART,findState.startpos); + SendScintilla(SCI_SETTARGETEND,findState.endpos); + + long pos; + + if (isUtf8()) + { + QCString s = findState.expr.utf8(); + + pos = SendScintilla(SCI_SEARCHINTARGET,s.length(),s.data()); + } + else + { + const char *s = findState.expr.latin1(); + + pos = SendScintilla(SCI_SEARCHINTARGET,strlen(s),s); + } + + return pos; +} + + +// Replace the text found with the previous findFirst() or findNext(). +void QextScintilla::replace(const QString &replaceStr) +{ + if (!findState.inProgress) + return; + + long start = SendScintilla(SCI_GETSELECTIONSTART); + + SendScintilla(SCI_TARGETFROMSELECTION); + + long len; + int cmd = (findState.flags & SCFIND_REGEXP) ? SCI_REPLACETARGETRE : SCI_REPLACETARGET; + + if (isUtf8()) + len = SendScintilla(cmd,-1,replaceStr.utf8().data()); + else + len = SendScintilla(cmd,-1,replaceStr.latin1()); + + // Reset the selection. + SendScintilla(SCI_SETSELECTIONSTART,start); + SendScintilla(SCI_SETSELECTIONEND,start + len); + + if (findState.forward) + findState.startpos = start + len; +} + + +// Query the modified state. +bool QextScintilla::isModified() +{ + // We don't use SCI_GETMODIFY as it seems to be buggy in Scintilla + // v1.61. + return modified; +} + + +// Set the modified state. +void QextScintilla::setModified(bool m) +{ + if (!m) + SendScintilla(SCI_SETSAVEPOINT); +} + + +// Handle the SCN_MARGINCLICK notification. +void QextScintilla::handleMarginClick(int pos,int modifiers,int margin) +{ + int state = 0; + + if (modifiers & SCMOD_SHIFT) + state |= ShiftButton; + + if (modifiers & SCMOD_CTRL) + state |= ControlButton; + + if (modifiers & SCMOD_ALT) + state |= AltButton; + + int line = SendScintilla(SCI_LINEFROMPOSITION,pos); + + if (fold && margin == 2) + foldClick(line,state); + else + emit marginClicked(margin,line,(ButtonState)state); +} + + +// Handle the SCN_SAVEPOINTREACHED notification. +void QextScintilla::handleSavePointReached() +{ + if (modified) + { + modified = FALSE; + emit modificationChanged(FALSE); + } +} + + +// Handle the SCN_SAVEPOINTLEFT notification. +void QextScintilla::handleSavePointLeft() +{ + if (!modified) + { + modified = TRUE; + emit modificationChanged(TRUE); + } +} + + +// Handle the QSCN_SELCHANGED signal. +void QextScintilla::handleSelectionChanged(bool yes) +{ + selText = yes; + + emit copyAvailable(yes); + emit selectionChanged(); +} + + +// Get the current selection. +void QextScintilla::getSelection(int *lineFrom,int *indexFrom, + int *lineTo,int *indexTo) +{ + if (selText) + { + lineIndexFromPos(SendScintilla(SCI_GETSELECTIONSTART), + lineFrom,indexFrom); + lineIndexFromPos(SendScintilla(SCI_GETSELECTIONEND), + lineTo,indexTo); + } + else + *lineFrom = *indexFrom = *lineTo = *indexTo = -1; +} + + +// Sets the current selection. +void QextScintilla::setSelection(int lineFrom,int indexFrom, + int lineTo,int indexTo) +{ + SendScintilla(SCI_SETSELECTIONSTART,posFromLineIndex(lineFrom,indexFrom)); + SendScintilla(SCI_SETSELECTIONEND,posFromLineIndex(lineTo,indexTo)); +} + + +// Set the background colour of selected text. +void QextScintilla::setSelectionBackgroundColor(const QColor &col) +{ + SendScintilla(SCI_SETSELBACK,1,col); + + int alpha = qAlpha(col.rgb()); + + if (alpha < 255) + SendScintilla(SCI_SETSELALPHA, alpha); +} + + +// Set the foreground colour of selected text. +void QextScintilla::setSelectionForegroundColor(const QColor &col) +{ + SendScintilla(SCI_SETSELFORE,1,col); +} + + +// Reset the background colour of selected text to the default. +void QextScintilla::resetSelectionBackgroundColor() +{ + SendScintilla(SCI_SETSELALPHA, SC_ALPHA_NOALPHA); + SendScintilla(SCI_SETSELBACK,0UL); +} + + +// Reset the foreground colour of selected text to the default. +void QextScintilla::resetSelectionForegroundColor() +{ + SendScintilla(SCI_SETSELFORE,0UL); +} + + +// Set the width of the caret. +void QextScintilla::setCaretWidth(int width) +{ + SendScintilla(SCI_SETCARETWIDTH,width); +} + + +// Set the foreground colour of the caret. +void QextScintilla::setCaretForegroundColor(const QColor &col) +{ + SendScintilla(SCI_SETCARETFORE,col); +} + + +// Set the background colour of the line containing the caret. +void QextScintilla::setCaretLineBackgroundColor(const QColor &col) +{ + SendScintilla(SCI_SETCARETLINEBACK,col); + + int alpha = qAlpha(col.rgb()); + + if (alpha < 255) + SendScintilla(SCI_SETCARETLINEBACKALPHA, alpha); +} + + +// Set the state of the background colour of the line containing the caret. +void QextScintilla::setCaretLineVisible(bool enable) +{ + SendScintilla(SCI_SETCARETLINEVISIBLE,enable); +} + + +// Query the read-only state. +bool QextScintilla::isReadOnly() +{ + return SendScintilla(SCI_GETREADONLY); +} + + +// Set the read-only state. +void QextScintilla::setReadOnly(bool ro) +{ + SendScintilla(SCI_SETREADONLY,ro); +} + + +// Append the given text. +void QextScintilla::append(const QString &text) +{ + bool ro = ensureRW(); + + if (isUtf8()) + { + QCString s = text.utf8(); + + SendScintilla(SCI_APPENDTEXT,s.length(),s.data()); + } + else + { + const char *s = text.latin1(); + + SendScintilla(SCI_APPENDTEXT,strlen(s),s); + } + + SendScintilla(SCI_EMPTYUNDOBUFFER); + + setReadOnly(ro); +} + + +// Insert the given text at the current position. +void QextScintilla::insert(const QString &text) +{ + bool ro = ensureRW(); + + SendScintilla(SCI_BEGINUNDOACTION); + + if (isUtf8()) + SendScintilla(SCI_INSERTTEXT,-1,text.utf8().data()); + else + SendScintilla(SCI_INSERTTEXT,-1,text.latin1()); + + SendScintilla(SCI_ENDUNDOACTION); + + setReadOnly(ro); +} + + +// Insert the given text at the given position. +void QextScintilla::insertAt(const QString &text,int line,int index) +{ + bool ro = ensureRW(); + long position = posFromLineIndex(line,index); + + SendScintilla(SCI_BEGINUNDOACTION); + + if (isUtf8()) + SendScintilla(SCI_INSERTTEXT,position,text.utf8().data()); + else + SendScintilla(SCI_INSERTTEXT,position,text.latin1()); + + SendScintilla(SCI_ENDUNDOACTION); + + setReadOnly(ro); +} + + +// Begin a sequence of undoable actions. +void QextScintilla::beginUndoAction() +{ + SendScintilla(SCI_BEGINUNDOACTION); +} + + +// End a sequence of undoable actions. +void QextScintilla::endUndoAction() +{ + SendScintilla(SCI_ENDUNDOACTION); +} + + +// Redo a sequence of actions. +void QextScintilla::redo() +{ + SendScintilla(SCI_REDO); +} + + +// Undo a sequence of actions. +void QextScintilla::undo() +{ + SendScintilla(SCI_UNDO); +} + + +// See if there is something to redo. +bool QextScintilla::isRedoAvailable() +{ + return SendScintilla(SCI_CANREDO); +} + + +// See if there is something to undo. +bool QextScintilla::isUndoAvailable() +{ + return SendScintilla(SCI_CANUNDO); +} + + +// Return the number of lines. +int QextScintilla::lines() +{ + return SendScintilla(SCI_GETLINECOUNT); +} + + +// Return the line at a position. +int QextScintilla::lineAt(const QPoint &pos) +{ + long chpos = SendScintilla(SCI_POSITIONFROMPOINTCLOSE,pos.x(),pos.y()); + + if (chpos < 0) + return -1; + + return SendScintilla(SCI_LINEFROMPOSITION,chpos); +} + + +// Return the length of a line. +int QextScintilla::lineLength(int line) +{ + if (line < 0 || line >= SendScintilla(SCI_GETLINECOUNT)) + return -1; + + return SendScintilla(SCI_LINELENGTH,line); +} + + +// Return the length of the current text. +int QextScintilla::length() +{ + return SendScintilla(SCI_GETTEXTLENGTH); +} + + +// Remove any selected text. +void QextScintilla::removeSelectedText() +{ + SendScintilla(SCI_REPLACESEL,""); +} + + +// Return the current selected text. +QString QextScintilla::selectedText() +{ + if (!selText) + return QString(); + + // Scintilla doesn't tell us the length of the selected text so we use + // the length of the whole document. + char *buf = new char[length() + 1]; + + SendScintilla(SCI_GETSELTEXT,buf); + + QString qs = convertText(buf); + delete[] buf; + + return qs; +} + + +// Return the current text. +QString QextScintilla::text() +{ + int buflen = length() + 1; + char *buf = new char[buflen]; + + SendScintilla(SCI_GETTEXT,buflen,buf); + + QString qs = convertText(buf); + delete[] buf; + + return qs; +} + + +// Return the text of a line. +QString QextScintilla::text(int line) +{ + int line_len = lineLength(line); + + if (line_len < 1) + return QString(); + + char *buf = new char[line_len + 1]; + + SendScintilla(SCI_GETLINE,line,buf); + buf[line_len] = '\0'; + + QString qs = convertText(buf); + delete[] buf; + + return qs; +} + + +// Set the given text. +void QextScintilla::setText(const QString &text) +{ + bool ro = ensureRW(); + + if (isUtf8()) + SendScintilla(SCI_SETTEXT,text.utf8().data()); + else + SendScintilla(SCI_SETTEXT,text.latin1()); + + SendScintilla(SCI_EMPTYUNDOBUFFER); + + setReadOnly(ro); +} + + +// Get the cursor position +void QextScintilla::getCursorPosition(int *line,int *index) +{ + long pos = SendScintilla(SCI_GETCURRENTPOS); + long lin = SendScintilla(SCI_LINEFROMPOSITION,pos); + long linpos = SendScintilla(SCI_POSITIONFROMLINE,lin); + + *line = lin; + *index = pos - linpos; +} + + +// Set the cursor position +void QextScintilla::setCursorPosition(int line,int index) +{ + SendScintilla(SCI_GOTOPOS,posFromLineIndex(line,index)); +} + + +// Ensure the cursor is visible. +void QextScintilla::ensureCursorVisible() +{ + SendScintilla(SCI_SCROLLCARET); +} + + +// Ensure a line is visible. +void QextScintilla::ensureLineVisible(int line) +{ + SendScintilla(SCI_ENSUREVISIBLEENFORCEPOLICY,line); +} + + +// Copy text to the clipboard. +void QextScintilla::copy() +{ + SendScintilla(SCI_COPY); +} + + +// Cut text to the clipboard. +void QextScintilla::cut() +{ + SendScintilla(SCI_CUT); +} + + +// Paste text from the clipboard. +void QextScintilla::paste() +{ + SendScintilla(SCI_PASTE); +} + + +// Select all text, or deselect any selected text. +void QextScintilla::selectAll(bool select) +{ + if (selText) + SendScintilla(SCI_SETANCHOR,SendScintilla(SCI_GETCURRENTPOS)); + else + SendScintilla(SCI_SELECTALL); +} + + +// Delete all text. +void QextScintilla::clear() +{ + bool ro = ensureRW(); + + SendScintilla(SCI_BEGINUNDOACTION); + SendScintilla(SCI_CLEARALL); + SendScintilla(SCI_ENDUNDOACTION); + + setReadOnly(ro); +} + + +// Return the indentation of a line. +int QextScintilla::indentation(int line) +{ + return SendScintilla(SCI_GETLINEINDENTATION,line); +} + + +// Set the indentation of a line. +void QextScintilla::setIndentation(int line,int indentation) +{ + SendScintilla(SCI_BEGINUNDOACTION); + SendScintilla(SCI_SETLINEINDENTATION,line,indentation); + SendScintilla(SCI_ENDUNDOACTION); +} + + +// Indent a line. +void QextScintilla::indent(int line) +{ + setIndentation(line,indentation(line) + indentWidth()); +} + + +// Unindent a line. +void QextScintilla::unindent(int line) +{ + int newIndent = indentation(line) - indentWidth(); + + if (newIndent < 0) + newIndent = 0; + + setIndentation(line,newIndent); +} + + +// Return the indentation of the current line. +int QextScintilla::currentIndent() +{ + return indentation(SendScintilla(SCI_LINEFROMPOSITION,SendScintilla(SCI_GETCURRENTPOS))); +} + + +// Return the current indentation width. +int QextScintilla::indentWidth() +{ + int w = indentationWidth(); + + if (w == 0) + w = tabWidth(); + + return w; +} + + +// Return the state of indentation guides. +bool QextScintilla::indentationGuides() +{ + return SendScintilla(SCI_GETINDENTATIONGUIDES); +} + + +// Enable and disable indentation guides. +void QextScintilla::setIndentationGuides(bool enable) +{ + SendScintilla(SCI_SETINDENTATIONGUIDES,enable); +} + + +// Set the background colour of indentation guides. +void QextScintilla::setIndentationGuidesBackgroundColor(const QColor &col) +{ + SendScintilla(SCI_STYLESETBACK,STYLE_INDENTGUIDE,col); +} + + +// Set the foreground colour of indentation guides. +void QextScintilla::setIndentationGuidesForegroundColor(const QColor &col) +{ + SendScintilla(SCI_STYLESETFORE,STYLE_INDENTGUIDE,col); +} + + +// Return the indentation width. +int QextScintilla::indentationWidth() +{ + return SendScintilla(SCI_GETINDENT); +} + + +// Set the indentation width. +void QextScintilla::setIndentationWidth(int width) +{ + SendScintilla(SCI_SETINDENT,width); +} + + +// Return the tab width. +int QextScintilla::tabWidth() +{ + return SendScintilla(SCI_GETTABWIDTH); +} + + +// Set the tab width. +void QextScintilla::setTabWidth(int width) +{ + SendScintilla(SCI_SETTABWIDTH,width); +} + + +// Return the effect of the backspace key. +bool QextScintilla::backspaceUnindents() +{ + return SendScintilla(SCI_GETBACKSPACEUNINDENTS); +} + + +// Set the effect of the backspace key. +void QextScintilla::setBackspaceUnindents(bool unindents) +{ + SendScintilla(SCI_SETBACKSPACEUNINDENTS,unindents); +} + + +// Return the effect of the tab key. +bool QextScintilla::tabIndents() +{ + return SendScintilla(SCI_GETTABINDENTS); +} + + +// Set the effect of the tab key. +void QextScintilla::setTabIndents(bool indents) +{ + SendScintilla(SCI_SETTABINDENTS,indents); +} + + +// Return the indentation use of tabs. +bool QextScintilla::indentationsUseTabs() +{ + return SendScintilla(SCI_GETUSETABS); +} + + +// Set the indentation use of tabs. +void QextScintilla::setIndentationsUseTabs(bool tabs) +{ + SendScintilla(SCI_SETUSETABS,tabs); +} + + +// Return the state of line numbers in a margin. +bool QextScintilla::marginLineNumbers(int margin) +{ + return SendScintilla(SCI_GETMARGINTYPEN,margin); +} + + +// Enable and disable line numbers in a margin. +void QextScintilla::setMarginLineNumbers(int margin,bool lnrs) +{ + SendScintilla(SCI_SETMARGINTYPEN,margin,lnrs ? SC_MARGIN_NUMBER : 0); +} + + +// Return the marker mask of a margin. +int QextScintilla::marginMarkerMask(int margin) +{ + return SendScintilla(SCI_GETMARGINMASKN,margin); +} + + +// Set the marker mask of a margin. +void QextScintilla::setMarginMarkerMask(int margin,int mask) +{ + SendScintilla(SCI_SETMARGINMASKN,margin,mask); +} + + +// Return the state of a margin's sensitivity. +bool QextScintilla::marginSensitivity(int margin) +{ + return SendScintilla(SCI_GETMARGINSENSITIVEN,margin); +} + + +// Enable and disable a margin's sensitivity. +void QextScintilla::setMarginSensitivity(int margin,bool sens) +{ + SendScintilla(SCI_SETMARGINSENSITIVEN,margin,sens); +} + + +// Return the width of a margin. +int QextScintilla::marginWidth(int margin) +{ + return SendScintilla(SCI_GETMARGINWIDTHN,margin); +} + + +// Set the width of a margin. +void QextScintilla::setMarginWidth(int margin,int width) +{ + SendScintilla(SCI_SETMARGINWIDTHN,margin,width); +} + + +// Set the width of a margin to the width of some text. +void QextScintilla::setMarginWidth(int margin,const QString &s) +{ + int width; + + if (isUtf8()) + width = SendScintilla(SCI_TEXTWIDTH,STYLE_LINENUMBER,s.utf8().data()); + else + width = SendScintilla(SCI_TEXTWIDTH,STYLE_LINENUMBER,s.latin1()); + + setMarginWidth(margin,width); +} + + +// Set the background colour of all margins. +void QextScintilla::setMarginsBackgroundColor(const QColor &col) +{ + handleStylePaperChange(col,STYLE_LINENUMBER); +} + + +// Set the foreground colour of all margins. +void QextScintilla::setMarginsForegroundColor(const QColor &col) +{ + handleStyleColorChange(col,STYLE_LINENUMBER); +} + + +// Set the font of all margins. +void QextScintilla::setMarginsFont(const QFont &f) +{ + setStylesFont(f,STYLE_LINENUMBER); +} + + +// Define a marker based on a symbol. +int QextScintilla::markerDefine(MarkerSymbol sym,int mnr) +{ + checkMarker(mnr); + + if (mnr >= 0) + SendScintilla(SCI_MARKERDEFINE,mnr,static_cast<long>(sym)); + + return mnr; +} + + +// Define a marker based on a character. +int QextScintilla::markerDefine(char ch,int mnr) +{ + checkMarker(mnr); + + if (mnr >= 0) + SendScintilla(SCI_MARKERDEFINE,mnr,static_cast<long>(SC_MARK_CHARACTER) + ch); + + return mnr; +} + + +// Define a marker based on a QPixmap. +int QextScintilla::markerDefine(const QPixmap *pm,int mnr) +{ + checkMarker(mnr); + + if (mnr >= 0) + SendScintilla(SCI_MARKERDEFINEPIXMAP,mnr,pm); + + return mnr; +} + + +// Add a marker to a line. +int QextScintilla::markerAdd(int linenr,int mnr) +{ + if (mnr < 0 || mnr > MARKER_MAX || (allocatedMarkers & (1 << mnr)) == 0) + return -1; + + return SendScintilla(SCI_MARKERADD,linenr,mnr); +} + + +// Get the marker mask for a line. +unsigned QextScintilla::markersAtLine(int linenr) +{ + return SendScintilla(SCI_MARKERGET,linenr); +} + + +// Delete a marker from a line. +void QextScintilla::markerDelete(int linenr,int mnr) +{ + if (mnr <= MARKER_MAX) + { + if (mnr < 0) + { + unsigned am = allocatedMarkers; + + for (int m = 0; m <= MARKER_MAX; ++m) + { + if (am & 1) + SendScintilla(SCI_MARKERDELETE,linenr,m); + + am >>= 1; + } + } + else if (allocatedMarkers & (1 << mnr)) + SendScintilla(SCI_MARKERDELETE,linenr,mnr); + } +} + + +// Delete a marker from the text. +void QextScintilla::markerDeleteAll(int mnr) +{ + if (mnr <= MARKER_MAX) + { + if (mnr < 0) + SendScintilla(SCI_MARKERDELETEALL,-1); + else if (allocatedMarkers & (1 << mnr)) + SendScintilla(SCI_MARKERDELETEALL,mnr); + } +} + + +// Delete a marker handle from the text. +void QextScintilla::markerDeleteHandle(int mhandle) +{ + SendScintilla(SCI_MARKERDELETEHANDLE,mhandle); +} + + +// Return the line containing a marker instance. +int QextScintilla::markerLine(int mhandle) +{ + return SendScintilla(SCI_MARKERLINEFROMHANDLE,mhandle); +} + + +// Search forwards for a marker. +int QextScintilla::markerFindNext(int linenr,unsigned mask) +{ + return SendScintilla(SCI_MARKERNEXT,linenr,mask); +} + + +// Search backwards for a marker. +int QextScintilla::markerFindPrevious(int linenr,unsigned mask) +{ + return SendScintilla(SCI_MARKERPREVIOUS,linenr,mask); +} + + +// Set the marker background colour. +void QextScintilla::setMarkerBackgroundColor(const QColor &col,int mnr) +{ + if (mnr <= MARKER_MAX) + { + int alpha = qAlpha(col.rgb()); + + if (mnr < 0) + { + unsigned am = allocatedMarkers; + + for (int m = 0; m <= MARKER_MAX; ++m) + { + if (am & 1) + { + SendScintilla(SCI_MARKERSETBACK,m,col); + + if (alpha < 255) + SendScintilla(SCI_MARKERSETALPHA, m, alpha); + } + + am >>= 1; + } + } + else if (allocatedMarkers & (1 << mnr)) + { + SendScintilla(SCI_MARKERSETBACK,mnr,col); + + if (alpha < 255) + SendScintilla(SCI_MARKERSETALPHA, mnr, alpha); + } + } +} + + +// Set the marker foreground colour. +void QextScintilla::setMarkerForegroundColor(const QColor &col,int mnr) +{ + if (mnr <= MARKER_MAX) + { + if (mnr < 0) + { + unsigned am = allocatedMarkers; + + for (int m = 0; m <= MARKER_MAX; ++m) + { + if (am & 1) + SendScintilla(SCI_MARKERSETFORE,m,col); + + am >>= 1; + } + } + else if (allocatedMarkers & (1 << mnr)) + SendScintilla(SCI_MARKERSETFORE,mnr,col); + } +} + + +// Check a marker, allocating a marker number if necessary. +void QextScintilla::checkMarker(int &mnr) +{ + if (mnr >= 0) + { + // Check the explicit marker number isn't already allocated. + if (mnr > MARKER_MAX || allocatedMarkers & (1 << mnr)) + mnr = -1; + } + else + { + unsigned am = allocatedMarkers; + + // Find the smallest unallocated marker number. + for (mnr = 0; mnr <= MARKER_MAX; ++mnr) + { + if ((am & 1) == 0) + break; + + am >>= 1; + } + } + + // Define the marker if it is valid. + if (mnr >= 0) + allocatedMarkers |= (1 << mnr); +} + + +// Reset the fold margin colours. +void QextScintilla::resetFoldMarginColors() +{ + SendScintilla(SCI_SETFOLDMARGINHICOLOUR,0,0L); + SendScintilla(SCI_SETFOLDMARGINCOLOUR,0,0L); +} + + +// Set the fold margin colours. +void QextScintilla::setFoldMarginColors(const QColor &fore,const QColor &back) +{ + SendScintilla(SCI_SETFOLDMARGINHICOLOUR,1,fore); + SendScintilla(SCI_SETFOLDMARGINCOLOUR,1,back); +} + + +// Set the call tips background colour. +void QextScintilla::setCallTipsBackgroundColor(const QColor &col) +{ + SendScintilla(SCI_CALLTIPSETBACK,col); +} + + +// Set the call tips foreground colour. +void QextScintilla::setCallTipsForegroundColor(const QColor &col) +{ + SendScintilla(SCI_CALLTIPSETFORE,col); +} + + +// Set the call tips highlight colour. +void QextScintilla::setCallTipsHighlightColor(const QColor &col) +{ + SendScintilla(SCI_CALLTIPSETFOREHLT,col); +} + + +// Set the matched brace background colour. +void QextScintilla::setMatchedBraceBackgroundColor(const QColor &col) +{ + SendScintilla(SCI_STYLESETBACK,STYLE_BRACELIGHT,col); +} + + +// Set the matched brace foreground colour. +void QextScintilla::setMatchedBraceForegroundColor(const QColor &col) +{ + SendScintilla(SCI_STYLESETFORE,STYLE_BRACELIGHT,col); +} + + +// Set the unmatched brace background colour. +void QextScintilla::setUnmatchedBraceBackgroundColor(const QColor &col) +{ + SendScintilla(SCI_STYLESETBACK,STYLE_BRACEBAD,col); +} + + +// Set the unmatched brace foreground colour. +void QextScintilla::setUnmatchedBraceForegroundColor(const QColor &col) +{ + SendScintilla(SCI_STYLESETFORE,STYLE_BRACEBAD,col); +} + + +// Set the lexer. +void QextScintilla::setLexer(QextScintillaLexer *lexer) +{ + // Disconnect any previous lexer. + if (!lex.isNull()) + { + lex -> disconnect(this); + + SendScintilla(SCI_STYLERESETDEFAULT); + } + + // Connect up the new lexer. + lex = lexer; + + if (lex) + { + int bits = SendScintilla(SCI_GETSTYLEBITSNEEDED); + int nrStyles = 1 << bits; + + SendScintilla(SCI_SETSTYLEBITS,bits); + + connect(lex,SIGNAL(colorChanged(const QColor &,int)), + SLOT(handleStyleColorChange(const QColor &,int))); + connect(lex,SIGNAL(eolFillChanged(bool,int)), + SLOT(handleStyleEolFillChange(bool,int))); + connect(lex,SIGNAL(fontChanged(const QFont &,int)), + SLOT(handleStyleFontChange(const QFont &,int))); + connect(lex,SIGNAL(paperChanged(const QColor &,int)), + SLOT(handleStylePaperChange(const QColor &,int))); + connect(lex,SIGNAL(propertyChanged(const char *,const char *)), + SLOT(handlePropertyChange(const char *,const char *))); + + SendScintilla(SCI_SETLEXERLANGUAGE,lex -> lexer()); + + // Set the keywords. Scintilla allows for sets numbered 0 to + // KEYWORDSET_MAX (although the lexers only seem to exploit 0 + // to KEYWORDSET_MAX - 1). We number from 1 in line with + // SciTE's property files. + for (int k = 0; k <= KEYWORDSET_MAX; ++k) + { + const char *kw = lex -> keywords(k + 1); + + if (kw) + SendScintilla(SCI_SETKEYWORDS,k,kw); + } + + // Initialise each style. + for (int s = 0; s < nrStyles; ++s) + { + if (lex -> description(s).isNull()) + continue; + + handleStyleColorChange(lex -> color(s),s); + handleStyleEolFillChange(lex -> eolFill(s),s); + handleStyleFontChange(lex -> font(s),s); + handleStylePaperChange(lex -> paper(s),s); + } + + // Initialise the properties. + lex -> refreshProperties(); + + // Set the auto-completion fillups if they haven't been + // explcitly set. + if (fillups_enabled && !explicit_fillups) + SendScintilla(SCI_AUTOCSETFILLUPS, lex->autoCompletionFillups()); + } + else + { + SendScintilla(SCI_SETLEXER,SCLEX_NULL); + + setColor(nl_text_colour); + setPaper(nl_paper_colour); + setFont(nl_font); + } +} + + +// Get the current lexer. +QextScintillaLexer *QextScintilla::lexer() const +{ + return lex; +} + + +// Handle a change in lexer style foreground colour. +void QextScintilla::handleStyleColorChange(const QColor &c,int style) +{ + SendScintilla(SCI_STYLESETFORE,style,c); +} + + +// Handle a change in lexer style end-of-line fill. +void QextScintilla::handleStyleEolFillChange(bool eolfill,int style) +{ + SendScintilla(SCI_STYLESETEOLFILLED,style,eolfill); +} + + +// Handle a change in lexer style font. +void QextScintilla::handleStyleFontChange(const QFont &f,int style) +{ + setStylesFont(f,style); + + if (style == lex->defaultStyle()) + setStylesFont(f, STYLE_DEFAULT); + + if (style == lex -> braceStyle()) + { + setStylesFont(f,STYLE_BRACELIGHT); + setStylesFont(f,STYLE_BRACEBAD); + } +} + + +// Set the font for a style. +void QextScintilla::setStylesFont(const QFont &f,int style) +{ + SendScintilla(SCI_STYLESETFONT,style,f.family().latin1()); + SendScintilla(SCI_STYLESETSIZE,style,f.pointSize()); + SendScintilla(SCI_STYLESETBOLD,style,f.bold()); + SendScintilla(SCI_STYLESETITALIC,style,f.italic()); + SendScintilla(SCI_STYLESETUNDERLINE,style,f.underline()); +} + + +// Handle a change in lexer style background colour. +void QextScintilla::handleStylePaperChange(const QColor &c,int style) +{ + SendScintilla(SCI_STYLESETBACK,style,c); +} + + +// Handle a change in lexer property. +void QextScintilla::handlePropertyChange(const char *prop,const char *val) +{ + SendScintilla(SCI_SETPROPERTY,prop,val); +} + + +// Handle a change to the user visible user interface. +void QextScintilla::handleUpdateUI() +{ + long newPos = SendScintilla(SCI_GETCURRENTPOS); + + if (newPos != oldPos) + { + oldPos = newPos; + + int line = SendScintilla(SCI_LINEFROMPOSITION,newPos); + int col = SendScintilla(SCI_GETCOLUMN,newPos); + + emit cursorPositionChanged(line,col); + } + + if (braceMode != NoBraceMatch) + braceMatch(); +} + + +// Handle brace matching. +void QextScintilla::braceMatch() +{ + long braceAtCaret, braceOpposite; + + findMatchingBrace(braceAtCaret,braceOpposite,braceMode); + + if (braceAtCaret >= 0 && braceOpposite < 0) + { + SendScintilla(SCI_BRACEBADLIGHT,braceAtCaret); + SendScintilla(SCI_SETHIGHLIGHTGUIDE,0UL); + } + else + { + char chBrace = SendScintilla(SCI_GETCHARAT,braceAtCaret); + + SendScintilla(SCI_BRACEHIGHLIGHT,braceAtCaret,braceOpposite); + + long columnAtCaret = SendScintilla(SCI_GETCOLUMN,braceAtCaret); + long columnOpposite = SendScintilla(SCI_GETCOLUMN,braceOpposite); + + if (chBrace == ':') + { + long lineStart = SendScintilla(SCI_LINEFROMPOSITION,braceAtCaret); + long indentPos = SendScintilla(SCI_GETLINEINDENTPOSITION,lineStart); + long indentPosNext = SendScintilla(SCI_GETLINEINDENTPOSITION,lineStart + 1); + + columnAtCaret = SendScintilla(SCI_GETCOLUMN,indentPos); + + long columnAtCaretNext = SendScintilla(SCI_GETCOLUMN,indentPosNext); + long indentSize = SendScintilla(SCI_GETINDENT); + + if (columnAtCaretNext - indentSize > 1) + columnAtCaret = columnAtCaretNext - indentSize; + + if (columnOpposite == 0) + columnOpposite = columnAtCaret; + } + + long column = columnAtCaret; + + if (column > columnOpposite) + column = columnOpposite; + + SendScintilla(SCI_SETHIGHLIGHTGUIDE,column); + } +} + + +// Check if the character at a position is a brace. +long QextScintilla::checkBrace(long pos,int brace_style,bool &colonMode) +{ + long brace_pos = -1; + char ch = SendScintilla(SCI_GETCHARAT,pos); + + if (ch == ':') + { + // A bit of a hack. + if (!lex.isNull() && strcmp(lex -> lexer(),"python") == 0) + { + brace_pos = pos; + colonMode = TRUE; + } + } + else if (ch && strchr("[](){}<>",ch)) + { + if (brace_style < 0) + brace_pos = pos; + else + { + int style = SendScintilla(SCI_GETSTYLEAT,pos) & 0x1f; + + if (style == brace_style) + brace_pos = pos; + } + } + + return brace_pos; +} + + +// Find a brace and it's match. Return TRUE if the current position is inside +// a pair of braces. +bool QextScintilla::findMatchingBrace(long &brace,long &other,BraceMatch mode) +{ + bool colonMode = FALSE; + int brace_style = (lex.isNull() ? -1 : lex -> braceStyle()); + + brace = -1; + other = -1; + + long caretPos = SendScintilla(SCI_GETCURRENTPOS); + + if (caretPos > 0) + brace = checkBrace(caretPos - 1,brace_style,colonMode); + + bool isInside = FALSE; + + if (brace < 0 && mode == SloppyBraceMatch) + { + brace = checkBrace(caretPos,brace_style,colonMode); + + if (brace >= 0 && !colonMode) + isInside = TRUE; + } + + if (brace >= 0) + { + if (colonMode) + { + // Find the end of the Python indented block. + long lineStart = SendScintilla(SCI_LINEFROMPOSITION,brace); + long lineMaxSubord = SendScintilla(SCI_GETLASTCHILD,lineStart,-1); + + other = SendScintilla(SCI_GETLINEENDPOSITION,lineMaxSubord); + } + else + other = SendScintilla(SCI_BRACEMATCH,brace); + + if (other > brace) + isInside = !isInside; + } + + return isInside; +} + + +// Move to the matching brace. +void QextScintilla::moveToMatchingBrace() +{ + gotoMatchingBrace(FALSE); +} + + +// Select to the matching brace. +void QextScintilla::selectToMatchingBrace() +{ + gotoMatchingBrace(TRUE); +} + + +// Move to the matching brace and optionally select the text. +void QextScintilla::gotoMatchingBrace(bool select) +{ + long braceAtCaret; + long braceOpposite; + + bool isInside = findMatchingBrace(braceAtCaret,braceOpposite,SloppyBraceMatch); + + if (braceOpposite >= 0) + { + // Convert the character positions into caret positions based + // on whether the caret position was inside or outside the + // braces. + if (isInside) + { + if (braceOpposite > braceAtCaret) + braceAtCaret++; + else + braceOpposite++; + } + else + { + if (braceOpposite > braceAtCaret) + braceOpposite++; + else + braceAtCaret++; + } + + ensureLineVisible(SendScintilla(SCI_LINEFROMPOSITION,braceOpposite)); + + if (select) + SendScintilla(SCI_SETSEL,braceAtCaret,braceOpposite); + else + SendScintilla(SCI_SETSEL,braceOpposite,braceOpposite); + } +} + + +// Return a position from a line number and an index within the line. +long QextScintilla::posFromLineIndex(int line,int index) +{ + long pos = SendScintilla(SCI_POSITIONFROMLINE,line); + + // Allow for multi-byte characters. + for(int i = 0; i < index; i++) + pos = SendScintilla(SCI_POSITIONAFTER,pos); + + return pos; +} + + +// Return a line number and an index within the line from a position. +void QextScintilla::lineIndexFromPos(long pos,int *line,int *index) +{ + long lin = SendScintilla(SCI_LINEFROMPOSITION,pos); + long linpos = SendScintilla(SCI_POSITIONFROMLINE,lin); + + *line = lin; + *index = pos - linpos; +} + + +// Convert a Scintilla string to a Qt Unicode string. +QString QextScintilla::convertText(const char *s) +{ + if (isUtf8()) + return QString::fromUtf8(s); + + QString qs; + + qs.setLatin1(s); + + return qs; +} + + +// Set the source of the auto-completion list. +void QextScintilla::setAutoCompletionSource(AutoCompletionSource source) +{ + acSource = source; +} + + +// Set the threshold for automatic auto-completion. +void QextScintilla::setAutoCompletionThreshold(int thresh) +{ + acThresh = thresh; +} + + +// Set the auto-completion start characters. +void QextScintilla::setAutoCompletionStartCharacters(const char *start) +{ + acStart = start; +} + + +// Set the APIs for auto-completion. +void QextScintilla::setAutoCompletionAPIs(QextScintillaAPIs *apis) +{ + acAPIs = apis; +} + + +// Explicitly auto-complete from all sources. +void QextScintilla::autoCompleteFromAll() +{ + startAutoCompletion(AcsAll, FALSE, showSingle); +} + + +// Explicitly auto-complete from the APIs. +void QextScintilla::autoCompleteFromAPIs() +{ + startAutoCompletion(AcsAPIs, FALSE, showSingle); +} + + +// Explicitly auto-complete from the document. +void QextScintilla::autoCompleteFromDocument() +{ + // If we are not in a word then ignore. + if (currentCharInWord()) + startAutoCompletion(AcsDocument, FALSE, showSingle); +} + + +// Return TRUE if the current character (ie. the one before the carat) is part +// of a word. +bool QextScintilla::currentCharInWord() +{ + long pos = SendScintilla(SCI_GETCURRENTPOS); + + if (pos <= 0) + return FALSE; + + return isWordChar(SendScintilla(SCI_GETCHARAT,pos - 1)); +} + + +// Check if a character can be in a word. +bool QextScintilla::isWordChar(char ch) const +{ + const char *word_chars = 0; + + if (!lex.isNull()) + word_chars = lex->wordCharacters(); + + if (!word_chars) + word_chars = defaultWordChars; + + return (strchr(word_chars, ch) != NULL); +} + + +// Recolour the document. +void QextScintilla::recolor(int start,int end) +{ + SendScintilla(SCI_COLOURISE,start,end); +} + + +// Registered an image. +void QextScintilla::registerImage(int id,const QPixmap *pm) +{ + SendScintilla(SCI_REGISTERIMAGE,id,pm); +} + + +// Clear all registered images. +void QextScintilla::clearRegisteredImages() +{ + SendScintilla(SCI_CLEARREGISTEREDIMAGES); +} + + +// Set the fill-up characters for auto-completion. +void QextScintilla::setAutoCompletionFillups(const char *fillups) +{ + if (!fillups) + fillups = ""; + + SendScintilla(SCI_AUTOCSETFILLUPS, fillups); + fillups_enabled = explicit_fillups = TRUE; + + // Save them in case we need to reenable them at some point. + saved_fillups = fillups; +} + + +// Enable/disable fill-ups for auto-completion. +void QextScintilla::setAutoCompletionFillupsEnabled(bool enabled) +{ + const char *fillups; + + if (!enabled) + fillups = ""; + else if (!explicit_fillups && !lex.isNull()) + fillups = lex->autoCompletionFillups(); + else + fillups = saved_fillups.data(); + + SendScintilla(SCI_AUTOCSETFILLUPS, fillups); + fillups_enabled = enabled; +} + + +// Return the state of fill-ups for auto-completion. +bool QextScintilla::autoCompletionFillupsEnabled() +{ + return fillups_enabled; +} + + +// Set the case sensitivity for auto-completion. +void QextScintilla::setAutoCompletionCaseSensitivity(bool cs) +{ + SendScintilla(SCI_AUTOCSETIGNORECASE,!cs); +} + + +// Return the case sensitivity for auto-completion. +bool QextScintilla::autoCompletionCaseSensitivity() +{ + return !SendScintilla(SCI_AUTOCGETIGNORECASE); +} + + +// Set the replace word mode for auto-completion. +void QextScintilla::setAutoCompletionReplaceWord(bool replace) +{ + SendScintilla(SCI_AUTOCSETDROPRESTOFWORD,replace); +} + + +// Return the replace word mode for auto-completion. +bool QextScintilla::autoCompletionReplaceWord() +{ + return SendScintilla(SCI_AUTOCGETDROPRESTOFWORD); +} + + +// Set the single item mode for auto-completion. +void QextScintilla::setAutoCompletionShowSingle(bool single) +{ + showSingle = single; +} + + +// Return the single item mode for auto-completion. +bool QextScintilla::autoCompletionShowSingle() +{ + return showSingle; +} + + +// Set the APIs for call tips. +void QextScintilla::setCallTipsAPIs(QextScintillaAPIs *apis) +{ + ctAPIs = apis; +} + + +// Set maximum number of call tips displayed. +void QextScintilla::setCallTipsVisible(int nr) +{ + maxCallTips = nr; +} + + +// Set the document to display. +void QextScintilla::setDocument(const QextScintillaDocument &document) +{ + if (doc.pdoc != document.pdoc) + { + doc.undisplay(this); + doc.attach(document); + doc.display(this,&document); + } +} + + +// Ensure the document is read-write and return True if was was read-only. +bool QextScintilla::ensureRW() +{ + bool ro = isReadOnly(); + + if (ro) + setReadOnly(FALSE); + + return ro; +} + + +// Return the number of the first visible line. +int QextScintilla::firstVisibleLine() +{ + return SendScintilla(SCI_GETFIRSTVISIBLELINE); +} + + +// Return the height in pixels of the text in a particular line. +int QextScintilla::textHeight(int linenr) +{ + return SendScintilla(SCI_TEXTHEIGHT, linenr); +} + + +// See if auto-completion or user list is active. +bool QextScintilla::isListActive() +{ + return SendScintilla(SCI_AUTOCACTIVE); +} + + +// Cancel any current auto-completion or user list. +void QextScintilla::cancelList() +{ + SendScintilla(SCI_AUTOCCANCEL); +} + + +// Display a user list. +void QextScintilla::showUserList(int id, const QStringList &list) +{ + // Sanity check to make sure auto-completion doesn't get confused. + if (id <= 0) + return; + + const char sep = '\x03'; + + SendScintilla(SCI_AUTOCSETSEPARATOR, sep); + SendScintilla(SCI_USERLISTSHOW, id, list.join(QChar(sep)).latin1()); +} + + +// Translate the SCN_USERLISTSELECTION notification into something more useful. +void QextScintilla::handleUserListSelection(const char *text, int id) +{ + emit userListActivated(id, QString(text)); +} |