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  **/
   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 /**
  12  * A Position is a position within a document between two characters or at the beginning or end.
  13  * Sometimes used as a character index where it identifies the character after the position.
  14  */
  15 typedef int Position;
  16 const Position invalidPosition = -1;
  17
  18 /**
  19  * The range class represents a range of text in a document.
  20  * The two values are not sorted as one end may be more significant than the other
  21  * as is the case for the selection where the end position is the position of the caret.
  22  * If either position is invalidPosition then the range is invalid and most operations will fail.
  23  */
  24 class Range {
  25 public:
  26         Position start;
  27         Position end;
  28
  29         Range(Position pos=0) :
  30                 start(pos), end(pos) {
  31         };
  32         Range(Position start_, Position end_) :
  33                 start(start_), end(end_) {
  34         };
  35
  36         bool Valid() const {
  37                 return (start != invalidPosition) && (end != invalidPosition);
  38         }
  39
  40         // Is the position within the range?
  41         bool Contains(Position pos) const {
  42                 if (start < end) {
  43                         return (pos >= start && pos <= end);
  44                 } else {
  45                         return (pos <= start && pos >= end);
  46                 }
  47         }
  48
  49         // Is the character after pos within the range?
  50         bool ContainsCharacter(Position pos) const {
  51                 if (start < end) {
  52                         return (pos >= start && pos < end);
  53                 } else {
  54                         return (pos < start && pos >= end);
  55                 }
  56         }
  57
  58         bool Contains(Range other) const {
  59                 return Contains(other.start) && Contains(other.end);
  60         }
  61
  62         bool Overlaps(Range other) const {
  63                 return
  64                 Contains(other.start) ||
  65                 Contains(other.end) ||
  66                 other.Contains(start) ||
  67                 other.Contains(end);
  68         }
  69 };
  70
  71 class DocWatcher;
  72 class DocModification;
  73 class RESearch;
  74
  75 /**
  76  */
  77 class Document {
  78
  79 public:
  80         /** Used to pair watcher pointer with user data. */
  81         class WatcherWithUserData {
  82         public:
  83                 DocWatcher *watcher;
  84                 void *userData;
  85                 WatcherWithUserData() {
  86                         watcher = 0;
  87                         userData = 0;
  88                 }
  89         };
  90
  91         enum charClassification { ccSpace, ccNewLine, ccWord, ccPunctuation };
  92
  93 private:
  94         int refCount;
  95         CellBuffer cb;
  96         charClassification charClass[256];
  97         char stylingMask;
  98         int endStyled;
  99         int styleClock;
 100         int enteredCount;
 101         int enteredReadOnlyCount;
 102
 103         WatcherWithUserData *watchers;
 104         int lenWatchers;
 105
 106         bool matchesValid;
 107         RESearch *pre;
 108         char *substituted;
 109
 110 public:
 111         int stylingBits;
 112         int stylingBitsMask;
 113
 114         int eolMode;
 115         /// Can also be SC_CP_UTF8 to enable UTF-8 mode
 116         int dbcsCodePage;
 117         int tabInChars;
 118         int indentInChars;
 119         int actualIndentInChars;
 120         bool useTabs;
 121         bool tabIndents;
 122         bool backspaceUnindents;
 123
 124         Document();
 125         virtual ~Document();
 126
 127         int AddRef();
 128         int Release();
 129
 130         int LineFromPosition(int pos);
 131         int ClampPositionIntoDocument(int pos);
 132         bool IsCrLf(int pos);
 133         int LenChar(int pos);
 134         int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);
 135
 136         // Gateways to modifying document
 137         void ModifiedAt(int pos);
 138         bool DeleteChars(int pos, int len);
 139         bool InsertStyledString(int position, char *s, int insertLength);
 140         int Undo();
 141         int Redo();
 142         bool CanUndo() { return cb.CanUndo(); }
 143         bool CanRedo() { return cb.CanRedo(); }
 144         void DeleteUndoHistory() { cb.DeleteUndoHistory(); }
 145         bool SetUndoCollection(bool collectUndo) {
 146                 return cb.SetUndoCollection(collectUndo);
 147         }
 148         bool IsCollectingUndo() { return cb.IsCollectingUndo(); }
 149         void BeginUndoAction() { cb.BeginUndoAction(); }
 150         void EndUndoAction() { cb.EndUndoAction(); }
 151         void SetSavePoint();
 152         bool IsSavePoint() { return cb.IsSavePoint(); }
 153
 154         int GetLineIndentation(int line);
 155         void SetLineIndentation(int line, int indent);
 156         int GetLineIndentPosition(int line);
 157         int GetColumn(int position);
 158         int FindColumn(int line, int column);
 159         void Indent(bool forwards, int lineBottom, int lineTop);
 160         static char *TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolMode);
 161         void ConvertLineEnds(int eolModeSet);
 162         void SetReadOnly(bool set) { cb.SetReadOnly(set); }
 163         bool IsReadOnly() { return cb.IsReadOnly(); }
 164
 165         bool InsertChar(int pos, char ch);
 166         bool InsertString(int position, const char *s);
 167         bool InsertString(int position, const char *s, size_t insertLength);
 168         void ChangeChar(int pos, char ch);
 169         void DelChar(int pos);
 170         void DelCharBack(int pos);
 171
 172         char CharAt(int position) { return cb.CharAt(position); }
 173         void GetCharRange(char *buffer, int position, int lengthRetrieve) {
 174                 cb.GetCharRange(buffer, position, lengthRetrieve);
 175         }
 176         char StyleAt(int position) { return cb.StyleAt(position); }
 177         int GetMark(int line) { return cb.GetMark(line); }
 178         int AddMark(int line, int markerNum);
 179         void AddMarkSet(int line, int valueSet);
 180         void DeleteMark(int line, int markerNum);
 181         void DeleteMarkFromHandle(int markerHandle);
 182         void DeleteAllMarks(int markerNum);
 183         int LineFromHandle(int markerHandle) { return cb.LineFromHandle(markerHandle); }
 184         int LineStart(int line);
 185         int LineEnd(int line);
 186         int LineEndPosition(int position);
 187         int VCHomePosition(int position);
 188
 189         int SetLevel(int line, int level);
 190         int GetLevel(int line) { return cb.GetLevel(line); }
 191         void ClearLevels() { cb.ClearLevels(); }
 192         int GetLastChild(int lineParent, int level=-1);
 193         int GetFoldParent(int line);
 194
 195         void Indent(bool forwards);
 196         int ExtendWordSelect(int pos, int delta, bool onlyWordCharacters=false);
 197         int NextWordStart(int pos, int delta);
 198         int NextWordEnd(int pos, int delta);
 199         int Length() { return cb.Length(); }
 200         void Allocate(int newSize) { cb.Allocate(newSize*2); }
 201         long FindText(int minPos, int maxPos, const char *s,
 202                 bool caseSensitive, bool word, bool wordStart, bool regExp, bool posix, int *length);
 203         long FindText(int iMessage, unsigned long wParam, long lParam);
 204         const char *SubstituteByPosition(const char *text, int *length);
 205         int LinesTotal();
 206
 207         void ChangeCase(Range r, bool makeUpperCase);
 208
 209         void SetDefaultCharClasses(bool includeWordClass);
 210         void SetCharClasses(const unsigned char *chars, charClassification newCharClass);
 211         void SetStylingBits(int bits);
 212         void StartStyling(int position, char mask);
 213         bool SetStyleFor(int length, char style);
 214         bool SetStyles(int length, char *styles);
 215         int GetEndStyled() { return endStyled; }
 216         bool EnsureStyledTo(int pos);
 217         int GetStyleClock() { return styleClock; }
 218         void IncrementStyleClock();
 219
 220         int SetLineState(int line, int state) { return cb.SetLineState(line, state); }
 221         int GetLineState(int line) { return cb.GetLineState(line); }
 222         int GetMaxLineState() { return cb.GetMaxLineState(); }
 223
 224         bool AddWatcher(DocWatcher *watcher, void *userData);
 225         bool RemoveWatcher(DocWatcher *watcher, void *userData);
 226         const WatcherWithUserData *GetWatchers() const { return watchers; }
 227         int GetLenWatchers() const { return lenWatchers; }
 228
 229         bool IsWordPartSeparator(char ch);
 230         int WordPartLeft(int pos);
 231         int WordPartRight(int pos);
 232         int ExtendStyleRange(int pos, int delta, bool singleLine = false);
 233         bool IsWhiteLine(int line);
 234         int ParaUp(int pos);
 235         int ParaDown(int pos);
 236         int IndentSize() { return actualIndentInChars; }
 237         int BraceMatch(int position, int maxReStyle);
 238
 239 private:
 240         void CheckReadOnly();
 241
 242         charClassification WordCharClass(unsigned char ch);
 243         bool IsWordStartAt(int pos);
 244         bool IsWordEndAt(int pos);
 245         bool IsWordAt(int start, int end);
 246
 247         void NotifyModifyAttempt();
 248         void NotifySavePoint(bool atSavePoint);
 249         void NotifyModified(DocModification mh);
 250 };
 251
 252 /**
 253  * To optimise processing of document modifications by DocWatchers, a hint is passed indicating the
 254  * scope of the change.
 255  * If the DocWatcher is a document view then this can be used to optimise screen updating.
 256  */
 257 class DocModification {
 258 public:
 259         int modificationType;
 260         int position;
 261         int length;
 262         int linesAdded; /**< Negative if lines deleted. */
 263         const char *text;       /**< Only valid for changes to text, not for changes to style. */
 264         int line;
 265         int foldLevelNow;
 266         int foldLevelPrev;
 267
 268         DocModification(int modificationType_, int position_=0, int length_=0,
 269                 int linesAdded_=0, const char *text_=0, int line_=0) :
 270                 modificationType(modificationType_),
 271                 position(position_),
 272                 length(length_),
 273                 linesAdded(linesAdded_),
 274                 text(text_),
 275                 line(line_),
 276                 foldLevelNow(0),
 277                 foldLevelPrev(0) {}
 278
 279         DocModification(int modificationType_, const Action &act, int linesAdded_=0) :
 280                 modificationType(modificationType_),
 281                 position(act.position),
 282                 length(act.lenData),
 283                 linesAdded(linesAdded_),
 284                 text(act.data),
 285                 line(0),
 286                 foldLevelNow(0),
 287                 foldLevelPrev(0) {}
 288 };
 289
 290 /**
 291  * A class that wants to receive notifications from a Document must be derived from DocWatcher
 292  * and implement the notification methods. It can then be added to the watcher list with AddWatcher.
 293  */
 294 class DocWatcher {
 295 public:
 296         virtual ~DocWatcher() {}
 297
 298         virtual void NotifyModifyAttempt(Document *doc, void *userData) = 0;
 299         virtual void NotifySavePoint(Document *doc, void *userData, bool atSavePoint) = 0;
 300         virtual void NotifyModified(Document *doc, DocModification mh, void *userData) = 0;
 301         virtual void NotifyDeleted(Document *doc, void *userData) = 0;
 302         virtual void NotifyStyleNeeded(Document *doc, void *userData, int endPos) = 0;
 303 };
 304
 305 #endif