TDE
/
tqscintilla
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tqscintilla
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '32e60eb3ba'
${ noResults }
tqscintilla/qt/qextscintilla.cpp

3032 lines
72 KiB
Raw Blame History

// This module implements the "official" high-level API of the TQt port of
// Scintilla. It is modelled on TQTextEdit - 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 TQScintilla.
//
// This copy of TQScintilla 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.
//
// TQScintilla 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
// TQScintilla; 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 <tqapplication.h>
#include <tqcolor.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(TQWidget *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,TQT_SIGNAL(SCN_MODIFYATTEMPTRO()),
TQT_SIGNAL(modificationAttempted()));
connect(this,TQT_SIGNAL(SCN_MODIFIED(int,int,const char *,int,int,int,int,int)),
TQT_SLOT(handleModified(int,int,const char *,int,int,int,int,int)));
connect(this,TQT_SIGNAL(SCN_CALLTIPCLICK(int)),
TQT_SLOT(handleCallTipClick(int)));
connect(this,TQT_SIGNAL(SCN_CHARADDED(int)),
TQT_SLOT(handleCharAdded(int)));
connect(this,TQT_SIGNAL(SCN_MARGINCLICK(int,int,int)),
TQT_SLOT(handleMarginClick(int,int,int)));
connect(this,TQT_SIGNAL(SCN_SAVEPOINTREACHED()),
TQT_SLOT(handleSavePointReached()));
connect(this,TQT_SIGNAL(SCN_SAVEPOINTLEFT()),
TQT_SLOT(handleSavePointLeft()));
connect(this,TQT_SIGNAL(SCN_UPDATEUI()),
TQT_SLOT(handleUpdateUI()));
connect(this,TQT_SIGNAL(TQSCN_SELCHANGED(bool)),
TQT_SLOT(handleSelectionChanged(bool)));
connect(this,TQT_SIGNAL(SCN_USERLISTSELECTION(const char *,int)),
TQT_SLOT(handleUserListSelection(const char *,int)));
// Set the default font.
setFont(TQApplication::font());
// Set the default fore and background colours.
TQColorGroup cg = TQApplication::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.
// TQt 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.
TQColor QextScintilla::color() const
{
return nl_text_colour;
}
// Set the text colour.
void QextScintilla::setColor(const TQColor &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.
TQColor QextScintilla::paper() const
{
return nl_paper_colour;
}
// Set the paper colour.
void QextScintilla::setPaper(const TQColor &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 TQFont &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;
}
TQString 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)
{
TQChar 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;
TQString 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.
TQStringList 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);
TQString 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.
TQString 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(TQChar(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 (!TQChar(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.
TQColor QextScintilla::edgeColor()
{
long res = SendScintilla(SCI_GETEDGECOLOUR);
return TQColor((int)res, ((int)(res >> 8)) & 0x00ff, ((int)(res >> 16)) & 0x00ff);
}
// Set the edge colour.
void QextScintilla::setEdgeColor(const TQColor &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 TQString &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())
{
TQCString 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 TQString &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 TQSCN_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 TQColor &col)
{
SendScintilla(SCI_SETSELBACK,1,col);
int alpha = tqAlpha(col.rgb());
if (alpha < 255)
SendScintilla(SCI_SETSELALPHA, alpha);
}
// Set the foreground colour of selected text.
void QextScintilla::setSelectionForegroundColor(const TQColor &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 TQColor &col)
{
SendScintilla(SCI_SETCARETFORE,col);
}
// Set the background colour of the line containing the caret.
void QextScintilla::setCaretLineBackgroundColor(const TQColor &col)
{
SendScintilla(SCI_SETCARETLINEBACK,col);
int alpha = tqAlpha(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 TQString &text)
{
bool ro = ensureRW();
if (isUtf8())
{
TQCString 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 TQString &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 TQString &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 TQPoint &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.
TQString QextScintilla::selectedText()
{
if (!selText)
return TQString();
// 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);
TQString qs = convertText(buf);
delete[] buf;
return qs;
}
// Return the current text.
TQString QextScintilla::text()
{
int buflen = length() + 1;
char *buf = new char[buflen];
SendScintilla(SCI_GETTEXT,buflen,buf);
TQString qs = convertText(buf);
delete[] buf;
return qs;
}
// Return the text of a line.
TQString QextScintilla::text(int line)
{
int line_len = lineLength(line);
if (line_len < 1)
return TQString();
char *buf = new char[line_len + 1];
SendScintilla(SCI_GETLINE,line,buf);
buf[line_len] = '\0';
TQString qs = convertText(buf);
delete[] buf;
return qs;
}
// Set the given text.
void QextScintilla::setText(const TQString &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 TQColor &col)
{
SendScintilla(SCI_STYLESETBACK,STYLE_INDENTGUIDE,col);
}
// Set the foreground colour of indentation guides.
void QextScintilla::setIndentationGuidesForegroundColor(const TQColor &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 TQString &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 TQColor &col)
{
handleStylePaperChange(col,STYLE_LINENUMBER);
}
// Set the foreground colour of all margins.
void QextScintilla::setMarginsForegroundColor(const TQColor &col)
{
handleStyleColorChange(col,STYLE_LINENUMBER);
}
// Set the font of all margins.
void QextScintilla::setMarginsFont(const TQFont &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 TQPixmap.
int QextScintilla::markerDefine(const TQPixmap *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 TQColor &col,int mnr)
{
if (mnr <= MARKER_MAX)
{
int alpha = tqAlpha(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 TQColor &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 TQColor &fore,const TQColor &back)
{
SendScintilla(SCI_SETFOLDMARGINHICOLOUR,1,fore);
SendScintilla(SCI_SETFOLDMARGINCOLOUR,1,back);
}
// Set the call tips background colour.
void QextScintilla::setCallTipsBackgroundColor(const TQColor &col)
{
SendScintilla(SCI_CALLTIPSETBACK,col);
}
// Set the call tips foreground colour.
void QextScintilla::setCallTipsForegroundColor(const TQColor &col)
{
SendScintilla(SCI_CALLTIPSETFORE,col);
}
// Set the call tips highlight colour.
void QextScintilla::setCallTipsHighlightColor(const TQColor &col)
{
SendScintilla(SCI_CALLTIPSETFOREHLT,col);
}
// Set the matched brace background colour.
void QextScintilla::setMatchedBraceBackgroundColor(const TQColor &col)
{
SendScintilla(SCI_STYLESETBACK,STYLE_BRACELIGHT,col);
}
// Set the matched brace foreground colour.
void QextScintilla::setMatchedBraceForegroundColor(const TQColor &col)
{
SendScintilla(SCI_STYLESETFORE,STYLE_BRACELIGHT,col);
}
// Set the unmatched brace background colour.
void QextScintilla::setUnmatchedBraceBackgroundColor(const TQColor &col)
{
SendScintilla(SCI_STYLESETBACK,STYLE_BRACEBAD,col);
}
// Set the unmatched brace foreground colour.
void QextScintilla::setUnmatchedBraceForegroundColor(const TQColor &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,TQT_SIGNAL(colorChanged(const TQColor &,int)),
TQT_SLOT(handleStyleColorChange(const TQColor &,int)));
connect(lex,TQT_SIGNAL(eolFillChanged(bool,int)),
TQT_SLOT(handleStyleEolFillChange(bool,int)));
connect(lex,TQT_SIGNAL(fontChanged(const TQFont &,int)),
TQT_SLOT(handleStyleFontChange(const TQFont &,int)));
connect(lex,TQT_SIGNAL(paperChanged(const TQColor &,int)),
TQT_SLOT(handleStylePaperChange(const TQColor &,int)));
connect(lex,TQT_SIGNAL(propertyChanged(const char *,const char *)),
TQT_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 TQColor &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 TQFont &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 TQFont &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 TQColor &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 TQt Unicode string.
TQString QextScintilla::convertText(const char *s)
{
if (isUtf8())
return TQString::fromUtf8(s);
TQString 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 TQPixmap *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 TQStringList &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(TQChar(sep)).latin1());
}
// Translate the SCN_USERLISTSELECTION notification into something more useful.
void QextScintilla::handleUserListSelection(const char *text, int id)
{
emit userListActivated(id, TQString(text));
}
View Git Blame Copy Permalink