git.saurik.com Git - wxWidgets.git/blob - src/stc/scintilla/src/Document.h

1 // Scintilla source code edit control

2 /** @file Document.h

3 ** Text document that handles notifications, DBCS, styling, words and end of line.

4 **/

6 // The License.txt file describes the conditions under which this software may be distributed.

8 #ifndef DOCUMENT_H

9 #define DOCUMENT_H

11 #ifdef SCI_NAMESPACE

12 namespace Scintilla {

13 #endif

15 /**

16 * A Position is a position within a document between two characters or at the beginning or end.

17 * Sometimes used as a character index where it identifies the character after the position.

18 */

19 typedef int Position;

20 const Position invalidPosition = -1;

22 /**

23 * The range class represents a range of text in a document.

24 * The two values are not sorted as one end may be more significant than the other

25 * as is the case for the selection where the end position is the position of the caret.

26 * If either position is invalidPosition then the range is invalid and most operations will fail.

27 */

28 class Range {

29 public:

30 Position start;

31 Position end;

         Range(Position pos=0) :

                 start(pos), end(pos) {

35 }

36 Range(Position start_, Position end_) :

                 start(start_), end(end_) {

38 }

         bool Valid() const {

                 return (start != invalidPosition) && (end != invalidPosition);

42 }

44 // Is the position within the range?

         bool Contains(Position pos) const {

46 if (start < end) {

                         return (pos >= start && pos <= end);

48 } else {

                         return (pos <= start && pos >= end);

50 }

51 }

53 // Is the character after pos within the range?

         bool ContainsCharacter(Position pos) const {

55 if (start < end) {

                         return (pos >= start && pos < end);

57 } else {

                         return (pos < start && pos >= end);

59 }

60 }

         bool Contains(Range other) const {

                 return Contains(other.start) && Contains(other.end);

64 }

         bool Overlaps(Range other) const {

67 return

68 Contains(other.start) ||

69 Contains(other.end) ||

70 other.Contains(start) ||

71 other.Contains(end);

72 }

73 };

75 class DocWatcher;

76 class DocModification;

77 class Document;

79 /**

80 * Interface class for regular expression searching

81 */

82 class RegexSearchBase {

83 public:

84 virtual ~RegexSearchBase() {}

         virtual long FindText(Document *doc, int minPos, int maxPos, const char *s,

                         bool caseSensitive, bool word, bool wordStart, int flags, int *length) = 0;

89 ///@return String with the substitutions, must remain valid until the next call or destruction

         virtual const char *SubstituteByPosition(Document *doc, const char *text, int *length) = 0;

91 };

93 /// Factory function for RegexSearchBase

 extern RegexSearchBase *CreateRegexSearch(CharClassify *charClassTable);

96 struct StyledText {

97 size_t length;

98 const char *text;

99 bool multipleStyles;

100 size_t style;

101 const unsigned char *styles;

         StyledText(size_t length_, const char *text_, bool multipleStyles_, int style_, const unsigned char *styles_) :

                 length(length_), text(text_), multipleStyles(multipleStyles_), style(style_), styles(styles_) {

104 }

105 // Return number of bytes from start to before '\n' or end of text.

106 // Return 1 when start is outside text

         size_t LineLength(size_t start) const {

108 size_t cur = start;

                 while ((cur < length) && (text[cur] != '\n'))

110 cur++;

111 return cur-start;

112 }

         size_t StyleAt(size_t i) const {

                 return multipleStyles ? styles[i] : style;

115 }

116 };

117

118 class HighlightDelimiter {

119 public:

         HighlightDelimiter() : isEnabled(false) {

121 Clear();

122 }

123

124 void Clear() {

125 beginFoldBlock = -1;

126 endFoldBlock = -1;

127 firstChangeableLineBefore = -1;

128 firstChangeableLineAfter = -1;

129 }

130

         bool NeedsDrawing(int line) {

                 return isEnabled && (line <= firstChangeableLineBefore || line >= firstChangeableLineAfter);

133 }

134

         bool IsFoldBlockHighlighted(int line) {

                 return isEnabled && beginFoldBlock != -1 && beginFoldBlock <= line && line <= endFoldBlock;

137 }

138

         bool IsHeadOfFoldBlock(int line) {

                 return beginFoldBlock == line && line < endFoldBlock;

141 }

142

         bool IsBodyOfFoldBlock(int line) {

                 return beginFoldBlock != -1 && beginFoldBlock < line && line < endFoldBlock;

145 }

146

         bool IsTailOfFoldBlock(int line) {

                 return beginFoldBlock != -1 && beginFoldBlock < line && line == endFoldBlock;

149 }

150

151 int beginFoldBlock; // Begin of current fold block

152 int endFoldBlock; // End of current fold block

153 int firstChangeableLineBefore; // First line that triggers repaint before starting line that determined current fold block

154 int firstChangeableLineAfter; // First line that triggers repaint after starting line that determined current fold block

155 bool isEnabled;

156 };

157

158 class CaseFolder {

159 public:

160 virtual ~CaseFolder() {

161 }

         virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) = 0;

163 };

164

165 class CaseFolderTable : public CaseFolder {

166 protected:

167 char mapping[256];

168 public:

169 CaseFolderTable();

170 virtual ~CaseFolderTable();

         virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed);

         void SetTranslation(char ch, char chTranslation);

173 void StandardASCII();

174 };

175

176 class Document;

177

178 class LexInterface {

179 protected:

180 Document *pdoc;

181 ILexer *instance;

182 bool performingStyle; ///< Prevent reentrance

183 public:

         LexInterface(Document *pdoc_) : pdoc(pdoc_), instance(0), performingStyle(false) {

185 }

186 virtual ~LexInterface() {

187 }

         void Colourise(int start, int end);

         bool UseContainerLexing() const {

190 return instance == 0;

191 }

192 };

193

194 /**

195 */

 class Document : PerLine, public IDocument, public ILoader {

197

198 public:

199 /** Used to pair watcher pointer with user data. */

200 class WatcherWithUserData {

201 public:

202 DocWatcher *watcher;

203 void *userData;

204 WatcherWithUserData() {

205 watcher = 0;

206 userData = 0;

207 }

208 };

209

         enum charClassification { ccSpace, ccNewLine, ccWord, ccPunctuation };

211 private:

212 int refCount;

213 CellBuffer cb;

214 CharClassify charClass;

215 char stylingMask;

216 int endStyled;

217 int styleClock;

218 int enteredModification;

219 int enteredStyling;

220 int enteredReadOnlyCount;

221

222 WatcherWithUserData *watchers;

223 int lenWatchers;

224

225 // ldSize is not real data - it is for dimensions and loops

         enum lineData { ldMarkers, ldLevels, ldState, ldMargin, ldAnnotation, ldSize };

227 PerLine *perLineData[ldSize];

228

229 bool matchesValid;

230 RegexSearchBase *regex;

231

232 public:

233

234 LexInterface *pli;

235

236 int stylingBits;

237 int stylingBitsMask;

238

239 int eolMode;

240 /// Can also be SC_CP_UTF8 to enable UTF-8 mode

241 int dbcsCodePage;

242 int tabInChars;

243 int indentInChars;

244 int actualIndentInChars;

245 bool useTabs;

246 bool tabIndents;

247 bool backspaceUnindents;

248

249 DecorationList decorations;

250

251 Document();

252 virtual ~Document();

253

254 int AddRef();

255 int SCI_METHOD Release();

256

257 virtual void Init();

         virtual void InsertLine(int line);

         virtual void RemoveLine(int line);

260

         int SCI_METHOD Version() const {

262 return dvOriginal;

263 }

264

         void SCI_METHOD SetErrorStatus(int status);

266

         int SCI_METHOD LineFromPosition(int pos) const;

         int ClampPositionIntoDocument(int pos);

         bool IsCrLf(int pos);

         int LenChar(int pos);

         bool InGoodUTF8(int pos, int &start, int &end) const;

         int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);

         int NextPosition(int pos, int moveDir) const;

         bool NextCharacter(int &pos, int moveDir);      // Returns true if pos changed

         int SCI_METHOD CodePage() const;

         bool SCI_METHOD IsDBCSLeadByte(char ch) const;

         int SafeSegment(const char *text, int length, int lengthSegment);

278

279 // Gateways to modifying document

         void ModifiedAt(int pos);

281 void CheckReadOnly();

         bool DeleteChars(int pos, int len);

         bool InsertString(int position, const char *s, int insertLength);

         int SCI_METHOD AddData(char *data, int length);

285 void * SCI_METHOD ConvertToDocument();

286 int Undo();

287 int Redo();

         bool CanUndo() { return cb.CanUndo(); }

         bool CanRedo() { return cb.CanRedo(); }

         void DeleteUndoHistory() { cb.DeleteUndoHistory(); }

         bool SetUndoCollection(bool collectUndo) {

                 return cb.SetUndoCollection(collectUndo);

293 }

         bool IsCollectingUndo() { return cb.IsCollectingUndo(); }

         void BeginUndoAction() { cb.BeginUndoAction(); }

         void EndUndoAction() { cb.EndUndoAction(); }

         void AddUndoAction(int token, bool mayCoalesce) { cb.AddUndoAction(token, mayCoalesce); }

298 void SetSavePoint();

         bool IsSavePoint() { return cb.IsSavePoint(); }

         const char * SCI_METHOD BufferPointer() { return cb.BufferPointer(); }

         const char *RangePointer(int position, int rangeLength) { return cb.RangePointer(position, rangeLength); }

         int GapPosition() const { return cb.GapPosition(); }

303

         int SCI_METHOD GetLineIndentation(int line);

         void SetLineIndentation(int line, int indent);

         int GetLineIndentPosition(int line) const;

         int GetColumn(int position);

         int CountCharacters(int startPos, int endPos);

         int FindColumn(int line, int column);

         void Indent(bool forwards, int lineBottom, int lineTop);

         static char *TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolModeWanted);

         void ConvertLineEnds(int eolModeSet);

         void SetReadOnly(bool set) { cb.SetReadOnly(set); }

         bool IsReadOnly() { return cb.IsReadOnly(); }

315

         bool InsertChar(int pos, char ch);

         bool InsertCString(int position, const char *s);

         void ChangeChar(int pos, char ch);

         void DelChar(int pos);

         void DelCharBack(int pos);

321

         char CharAt(int position) { return cb.CharAt(position); }

         void SCI_METHOD GetCharRange(char *buffer, int position, int lengthRetrieve) const {

                 cb.GetCharRange(buffer, position, lengthRetrieve);

325 }

         char SCI_METHOD StyleAt(int position) const { return cb.StyleAt(position); }

         void GetStyleRange(unsigned char *buffer, int position, int lengthRetrieve) const {

                 cb.GetStyleRange(buffer, position, lengthRetrieve);

329 }

         int GetMark(int line);

         int MarkerNext(int lineStart, int mask) const;

         int AddMark(int line, int markerNum);

         void AddMarkSet(int line, int valueSet);

         void DeleteMark(int line, int markerNum);

         void DeleteMarkFromHandle(int markerHandle);

         void DeleteAllMarks(int markerNum);

         int LineFromHandle(int markerHandle);

         int SCI_METHOD LineStart(int line) const;

         int LineEnd(int line) const;

         int LineEndPosition(int position) const;

         bool IsLineEndPosition(int position) const;

         int VCHomePosition(int position) const;

343

         int SCI_METHOD SetLevel(int line, int level);

         int SCI_METHOD GetLevel(int line) const;

346 void ClearLevels();

         int GetLastChild(int lineParent, int level=-1, int lastLine=-1);

         int GetFoldParent(int line);

         void GetHighlightDelimiters(HighlightDelimiter &hDelimiter, int line, int lastLine);

350

         void Indent(bool forwards);

         int ExtendWordSelect(int pos, int delta, bool onlyWordCharacters=false);

         int NextWordStart(int pos, int delta);

         int NextWordEnd(int pos, int delta);

         int SCI_METHOD Length() const { return cb.Length(); }

         void Allocate(int newSize) { cb.Allocate(newSize); }

         bool MatchesWordOptions(bool word, bool wordStart, int pos, int length);

         long FindText(int minPos, int maxPos, const char *search, bool caseSensitive, bool word,

                 bool wordStart, bool regExp, int flags, int *length, CaseFolder *pcf);

         const char *SubstituteByPosition(const char *text, int *length);

         int LinesTotal() const;

362

         void ChangeCase(Range r, bool makeUpperCase);

364

         void SetDefaultCharClasses(bool includeWordClass);

         void SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass);

         int GetCharsOfClass(CharClassify::cc charClass, unsigned char *buffer);

         void SetStylingBits(int bits);

         void SCI_METHOD StartStyling(int position, char mask);

         bool SCI_METHOD SetStyleFor(int length, char style);

         bool SCI_METHOD SetStyles(int length, const char *styles);

         int GetEndStyled() { return endStyled; }

         void EnsureStyledTo(int pos);

374 void LexerChanged();

         int GetStyleClock() { return styleClock; }

376 void IncrementStyleClock();

         void SCI_METHOD DecorationSetCurrentIndicator(int indicator) {

378 decorations.SetCurrentIndicator(indicator);

379 }

         void SCI_METHOD DecorationFillRange(int position, int value, int fillLength);

381

         int SCI_METHOD SetLineState(int line, int state);

         int SCI_METHOD GetLineState(int line) const;

384 int GetMaxLineState();

         void SCI_METHOD ChangeLexerState(int start, int end);

386

387 StyledText MarginStyledText(int line);

         void MarginSetStyle(int line, int style);

         void MarginSetStyles(int line, const unsigned char *styles);

         void MarginSetText(int line, const char *text);

         int MarginLength(int line) const;

392 void MarginClearAll();

393

         bool AnnotationAny() const;

395 StyledText AnnotationStyledText(int line);

         void AnnotationSetText(int line, const char *text);

         void AnnotationSetStyle(int line, int style);

         void AnnotationSetStyles(int line, const unsigned char *styles);

         int AnnotationLength(int line) const;

         int AnnotationLines(int line) const;

401 void AnnotationClearAll();

402

         bool AddWatcher(DocWatcher *watcher, void *userData);

         bool RemoveWatcher(DocWatcher *watcher, void *userData);

         const WatcherWithUserData *GetWatchers() const { return watchers; }

         int GetLenWatchers() const { return lenWatchers; }

407

         CharClassify::cc WordCharClass(unsigned char ch);

         bool IsWordPartSeparator(char ch);

         int WordPartLeft(int pos);

         int WordPartRight(int pos);

         int ExtendStyleRange(int pos, int delta, bool singleLine = false);

         bool IsWhiteLine(int line) const;

         int ParaUp(int pos);

         int ParaDown(int pos);

         int IndentSize() { return actualIndentInChars; }

         int BraceMatch(int position, int maxReStyle);

418

419 private:

         bool IsWordStartAt(int pos);

         bool IsWordEndAt(int pos);

         bool IsWordAt(int start, int end);

423

424 void NotifyModifyAttempt();

         void NotifySavePoint(bool atSavePoint);

426 void NotifyModified(DocModification mh);

427 };

428

429 class UndoGroup {

430 Document *pdoc;

431 bool groupNeeded;

432 public:

         UndoGroup(Document *pdoc_, bool groupNeeded_=true) :

                 pdoc(pdoc_), groupNeeded(groupNeeded_) {

435 if (groupNeeded) {

436 pdoc->BeginUndoAction();

437 }

438 }

439 ~UndoGroup() {

440 if (groupNeeded) {

441 pdoc->EndUndoAction();

442 }

443 }

         bool Needed() const {

445 return groupNeeded;

446 }

447 };

448

449

450 /**

451 * To optimise processing of document modifications by DocWatchers, a hint is passed indicating the

452 * scope of the change.

453 * If the DocWatcher is a document view then this can be used to optimise screen updating.

454 */

455 class DocModification {

456 public:

457 int modificationType;

458 int position;

459 int length;

460 int linesAdded; /**< Negative if lines deleted. */

461 const char *text; /**< Only valid for changes to text, not for changes to style. */

462 int line;

463 int foldLevelNow;

464 int foldLevelPrev;

465 int annotationLinesAdded;

466 int token;

467

         DocModification(int modificationType_, int position_=0, int length_=0,

                 int linesAdded_=0, const char *text_=0, int line_=0) :

470 modificationType(modificationType_),

471 position(position_),

472 length(length_),

473 linesAdded(linesAdded_),

474 text(text_),

475 line(line_),

476 foldLevelNow(0),

477 foldLevelPrev(0),

478 annotationLinesAdded(0),

479 token(0) {}

480

         DocModification(int modificationType_, const Action &act, int linesAdded_=0) :

482 modificationType(modificationType_),

483 position(act.position),

484 length(act.lenData),

485 linesAdded(linesAdded_),

486 text(act.data),

487 line(0),

488 foldLevelNow(0),

489 foldLevelPrev(0),

490 annotationLinesAdded(0),

491 token(0) {}

492 };

493

494 /**

495 * A class that wants to receive notifications from a Document must be derived from DocWatcher

496 * and implement the notification methods. It can then be added to the watcher list with AddWatcher.

497 */

498 class DocWatcher {

499 public:

500 virtual ~DocWatcher() {}

501

         virtual void NotifyModifyAttempt(Document *doc, void *userData) = 0;

         virtual void NotifySavePoint(Document *doc, void *userData, bool atSavePoint) = 0;

         virtual void NotifyModified(Document *doc, DocModification mh, void *userData) = 0;

         virtual void NotifyDeleted(Document *doc, void *userData) = 0;

         virtual void NotifyStyleNeeded(Document *doc, void *userData, int endPos) = 0;

         virtual void NotifyLexerChanged(Document *doc, void *userData) = 0;

         virtual void NotifyErrorOccurred(Document *doc, void *userData, int status) = 0;

509 };

510

511 #ifdef SCI_NAMESPACE

512 }

513 #endif

514

515 #endif