scintilla/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  **/
   5 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
   6 // The License.txt file describes the conditions under which this software may be distributed.
   7
   8 #ifndef DOCUMENT_H
   9 #define DOCUMENT_H
  10
  11 #ifdef SCI_NAMESPACE
  12 namespace Scintilla {
  13 #endif
  14
  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;
  21
  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;
  32
  33         Range(Position pos=0) :
  34                 start(pos), end(pos) {
  35         };
  36         Range(Position start_, Position end_) :
  37                 start(start_), end(end_) {
  38         };
  39
  40         bool Valid() const {
  41                 return (start != invalidPosition) && (end != invalidPosition);
  42         }
  43
  44         // Is the position within the range?
  45         bool Contains(Position pos) const {
  46                 if (start < end) {
  47                         return (pos >= start && pos <= end);
  48                 } else {
  49                         return (pos <= start && pos >= end);
  50                 }
  51         }
  52
  53         // Is the character after pos within the range?
  54         bool ContainsCharacter(Position pos) const {
  55                 if (start < end) {
  56                         return (pos >= start && pos < end);
  57                 } else {
  58                         return (pos < start && pos >= end);
  59                 }
  60         }
  61
  62         bool Contains(Range other) const {
  63                 return Contains(other.start) && Contains(other.end);
  64         }
  65
  66         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 };
  74
  75 class DocWatcher;
  76 class DocModification;
  77 class Document;
  78
  79 /**
  80  * Interface class for regular expression searching
  81  */
  82 class RegexSearchBase {
  83 public:
  84         virtual ~RegexSearchBase(){}
  85
  86         virtual long FindText(Document* doc, int minPos, int maxPos, const char *s,
  87                         bool caseSensitive, bool word, bool wordStart, int flags, int *length) = 0;
  88
  89         ///@return String with the substitutions, must remain valid until the next call or destruction
  90         virtual const char *SubstituteByPosition(Document* doc, const char *text, int *length) = 0;
  91 };
  92
  93 /// Factory function for RegexSearchBase
  94 extern RegexSearchBase* CreateRegexSearch(CharClassify *charClassTable);
  95
  96 struct StyledText {
  97         size_t length;
  98         const char *text;
  99         bool multipleStyles;
 100         size_t style;
 101         const unsigned char *styles;
 102         StyledText(     size_t length_, const char *text_, bool multipleStyles_, int style_, const unsigned char *styles_) :
 103                 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
 107         size_t LineLength(size_t start) const {
 108                 size_t cur = start;
 109                 while ((cur < length) && (text[cur] != '\n'))
 110                         cur++;
 111                 return cur-start;
 112         }
 113         size_t StyleAt(size_t i) const {
 114                 return multipleStyles ? styles[i] : style;
 115         }
 116 };
 117
 118 /**
 119  */
 120 class Document : PerLine {
 121
 122 public:
 123         /** Used to pair watcher pointer with user data. */
 124         class WatcherWithUserData {
 125         public:
 126                 DocWatcher *watcher;
 127                 void *userData;
 128                 WatcherWithUserData() {
 129                         watcher = 0;
 130                         userData = 0;
 131                 }
 132         };
 133
 134         enum charClassification { ccSpace, ccNewLine, ccWord, ccPunctuation };
 135 private:
 136         int refCount;
 137         CellBuffer cb;
 138         CharClassify charClass;
 139         char stylingMask;
 140         int endStyled;
 141         int styleClock;
 142         int enteredModification;
 143         int enteredStyling;
 144         int enteredReadOnlyCount;
 145
 146         WatcherWithUserData *watchers;
 147         int lenWatchers;
 148
 149         // ldSize is not real data - it is for dimensions and loops
 150         enum lineData { ldMarkers, ldLevels, ldState, ldMargin, ldAnnotation, ldSize };
 151         PerLine *perLineData[ldSize];
 152
 153         bool matchesValid;
 154         RegexSearchBase* regex;
 155
 156 public:
 157         int stylingBits;
 158         int stylingBitsMask;
 159
 160         int eolMode;
 161         /// Can also be SC_CP_UTF8 to enable UTF-8 mode
 162         int dbcsCodePage;
 163         int tabInChars;
 164         int indentInChars;
 165         int actualIndentInChars;
 166         bool useTabs;
 167         bool tabIndents;
 168         bool backspaceUnindents;
 169
 170         DecorationList decorations;
 171
 172         Document();
 173         virtual ~Document();
 174
 175         int AddRef();
 176         int Release();
 177
 178         virtual void Init();
 179         virtual void InsertLine(int line);
 180         virtual void RemoveLine(int line);
 181
 182         int LineFromPosition(int pos) const;
 183         int ClampPositionIntoDocument(int pos);
 184         bool IsCrLf(int pos);
 185         int LenChar(int pos);
 186         bool InGoodUTF8(int pos, int &start, int &end);
 187         int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);
 188
 189         // Gateways to modifying document
 190         void ModifiedAt(int pos);
 191         void CheckReadOnly();
 192         bool DeleteChars(int pos, int len);
 193         bool InsertString(int position, const char *s, int insertLength);
 194         int Undo();
 195         int Redo();
 196         bool CanUndo() { return cb.CanUndo(); }
 197         bool CanRedo() { return cb.CanRedo(); }
 198         void DeleteUndoHistory() { cb.DeleteUndoHistory(); }
 199         bool SetUndoCollection(bool collectUndo) {
 200                 return cb.SetUndoCollection(collectUndo);
 201         }
 202         bool IsCollectingUndo() { return cb.IsCollectingUndo(); }
 203         void BeginUndoAction() { cb.BeginUndoAction(); }
 204         void EndUndoAction() { cb.EndUndoAction(); }
 205         void AddUndoAction(int token, bool mayCoalesce) { cb.AddUndoAction(token, mayCoalesce); }
 206         void SetSavePoint();
 207         bool IsSavePoint() { return cb.IsSavePoint(); }
 208         const char *BufferPointer() { return cb.BufferPointer(); }
 209
 210         int GetLineIndentation(int line);
 211         void SetLineIndentation(int line, int indent);
 212         int GetLineIndentPosition(int line) const;
 213         int GetColumn(int position);
 214         int FindColumn(int line, int column);
 215         void Indent(bool forwards, int lineBottom, int lineTop);
 216         static char *TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolMode);
 217         void ConvertLineEnds(int eolModeSet);
 218         void SetReadOnly(bool set) { cb.SetReadOnly(set); }
 219         bool IsReadOnly() { return cb.IsReadOnly(); }
 220
 221         bool InsertChar(int pos, char ch);
 222         bool InsertCString(int position, const char *s);
 223         void ChangeChar(int pos, char ch);
 224         void DelChar(int pos);
 225         void DelCharBack(int pos);
 226
 227         char CharAt(int position) { return cb.CharAt(position); }
 228         void GetCharRange(char *buffer, int position, int lengthRetrieve) {
 229                 cb.GetCharRange(buffer, position, lengthRetrieve);
 230         }
 231         char StyleAt(int position) { return cb.StyleAt(position); }
 232         int GetMark(int line);
 233         int AddMark(int line, int markerNum);
 234         void AddMarkSet(int line, int valueSet);
 235         void DeleteMark(int line, int markerNum);
 236         void DeleteMarkFromHandle(int markerHandle);
 237         void DeleteAllMarks(int markerNum);
 238         int LineFromHandle(int markerHandle);
 239         int LineStart(int line) const;
 240         int LineEnd(int line) const;
 241         int LineEndPosition(int position) const;
 242         bool IsLineEndPosition(int position) const;
 243         int VCHomePosition(int position) const;
 244
 245         int SetLevel(int line, int level);
 246         int GetLevel(int line);
 247         void ClearLevels();
 248         int GetLastChild(int lineParent, int level=-1);
 249         int GetFoldParent(int line);
 250
 251         void Indent(bool forwards);
 252         int ExtendWordSelect(int pos, int delta, bool onlyWordCharacters=false);
 253         int NextWordStart(int pos, int delta);
 254         int NextWordEnd(int pos, int delta);
 255         int Length() const { return cb.Length(); }
 256         void Allocate(int newSize) { cb.Allocate(newSize); }
 257         long FindText(int minPos, int maxPos, const char *s,
 258                 bool caseSensitive, bool word, bool wordStart, bool regExp, int flags, int *length);
 259         long FindText(int iMessage, unsigned long wParam, long lParam);
 260         const char *SubstituteByPosition(const char *text, int *length);
 261         int LinesTotal() const;
 262
 263         void ChangeCase(Range r, bool makeUpperCase);
 264
 265         void SetDefaultCharClasses(bool includeWordClass);
 266         void SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass);
 267         void SetStylingBits(int bits);
 268         void StartStyling(int position, char mask);
 269         bool SetStyleFor(int length, char style);
 270         bool SetStyles(int length, const char *styles);
 271         int GetEndStyled() { return endStyled; }
 272         void EnsureStyledTo(int pos);
 273         int GetStyleClock() { return styleClock; }
 274         void IncrementStyleClock();
 275         void DecorationFillRange(int position, int value, int fillLength);
 276
 277         int SetLineState(int line, int state);
 278         int GetLineState(int line);
 279         int GetMaxLineState();
 280
 281         StyledText MarginStyledText(int line);
 282         void MarginSetStyle(int line, int style);
 283         void MarginSetStyles(int line, const unsigned char *styles);
 284         void MarginSetText(int line, const char *text);
 285         int MarginLength(int line) const;
 286         void MarginClearAll();
 287
 288         bool AnnotationAny() const;
 289         StyledText AnnotationStyledText(int line);
 290         void AnnotationSetText(int line, const char *text);
 291         void AnnotationSetStyle(int line, int style);
 292         void AnnotationSetStyles(int line, const unsigned char *styles);
 293         int AnnotationLength(int line) const;
 294         int AnnotationLines(int line) const;
 295         void AnnotationClearAll();
 296
 297         bool AddWatcher(DocWatcher *watcher, void *userData);
 298         bool RemoveWatcher(DocWatcher *watcher, void *userData);
 299         const WatcherWithUserData *GetWatchers() const { return watchers; }
 300         int GetLenWatchers() const { return lenWatchers; }
 301
 302         bool IsWordPartSeparator(char ch);
 303         int WordPartLeft(int pos);
 304         int WordPartRight(int pos);
 305         int ExtendStyleRange(int pos, int delta, bool singleLine = false);
 306         bool IsWhiteLine(int line) const;
 307         int ParaUp(int pos);
 308         int ParaDown(int pos);
 309         int IndentSize() { return actualIndentInChars; }
 310         int BraceMatch(int position, int maxReStyle);
 311
 312 private:
 313         CharClassify::cc WordCharClass(unsigned char ch);
 314         bool IsWordStartAt(int pos);
 315         bool IsWordEndAt(int pos);
 316         bool IsWordAt(int start, int end);
 317
 318         void NotifyModifyAttempt();
 319         void NotifySavePoint(bool atSavePoint);
 320         void NotifyModified(DocModification mh);
 321 };
 322
 323 class UndoGroup {
 324         Document *pdoc;
 325         bool groupNeeded;
 326 public:
 327         UndoGroup(Document *pdoc_, bool groupNeeded_=true) :
 328                 pdoc(pdoc_), groupNeeded(groupNeeded_) {
 329                 if (groupNeeded) {
 330                         pdoc->BeginUndoAction();
 331                 }
 332         }
 333         ~UndoGroup() {
 334                 if (groupNeeded) {
 335                         pdoc->EndUndoAction();
 336                 }
 337         }
 338         bool Needed() const {
 339                 return groupNeeded;
 340         }
 341 };
 342
 343
 344 /**
 345  * To optimise processing of document modifications by DocWatchers, a hint is passed indicating the
 346  * scope of the change.
 347  * If the DocWatcher is a document view then this can be used to optimise screen updating.
 348  */
 349 class DocModification {
 350 public:
 351         int modificationType;
 352         int position;
 353         int length;
 354         int linesAdded; /**< Negative if lines deleted. */
 355         const char *text;       /**< Only valid for changes to text, not for changes to style. */
 356         int line;
 357         int foldLevelNow;
 358         int foldLevelPrev;
 359         int annotationLinesAdded;
 360         int token;
 361
 362         DocModification(int modificationType_, int position_=0, int length_=0,
 363                 int linesAdded_=0, const char *text_=0, int line_=0) :
 364                 modificationType(modificationType_),
 365                 position(position_),
 366                 length(length_),
 367                 linesAdded(linesAdded_),
 368                 text(text_),
 369                 line(line_),
 370                 foldLevelNow(0),
 371                 foldLevelPrev(0),
 372                 annotationLinesAdded(0),
 373                 token(0) {}
 374
 375         DocModification(int modificationType_, const Action &act, int linesAdded_=0) :
 376                 modificationType(modificationType_),
 377                 position(act.position),
 378                 length(act.lenData),
 379                 linesAdded(linesAdded_),
 380                 text(act.data),
 381                 line(0),
 382                 foldLevelNow(0),
 383                 foldLevelPrev(0),
 384                 annotationLinesAdded(0),
 385                 token(0) {}
 386 };
 387
 388 /**
 389  * A class that wants to receive notifications from a Document must be derived from DocWatcher
 390  * and implement the notification methods. It can then be added to the watcher list with AddWatcher.
 391  */
 392 class DocWatcher {
 393 public:
 394         virtual ~DocWatcher() {}
 395
 396         virtual void NotifyModifyAttempt(Document *doc, void *userData) = 0;
 397         virtual void NotifySavePoint(Document *doc, void *userData, bool atSavePoint) = 0;
 398         virtual void NotifyModified(Document *doc, DocModification mh, void *userData) = 0;
 399         virtual void NotifyDeleted(Document *doc, void *userData) = 0;
 400         virtual void NotifyStyleNeeded(Document *doc, void *userData, int endPos) = 0;
 401 };
 402
 403 #ifdef SCI_NAMESPACE
 404 }
 405 #endif
 406
 407 #endif