← Back to branch summary

~ubuntu-branches/ubuntu/wily/apparmor/wily

« back to all changes in this revision

Viewing changes to deprecated/management/profile-editor/src/wxStyledTextCtrl/Document.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2011-08-10 18:12:34 UTC
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: james.westby@ubuntu.com-20110810181234-b6obckg60cp99crg
Tags: upstream-2.7.0~beta1+bzr1774
Import upstream version 2.7.0~beta1+bzr1774

Show diffs side-by-side

added added

removed removed

Lines of Context:
deprecated/management/profile-editor/src/wxStyledTextCtrl/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