← 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/ContractionState.cxx

  • 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/ContractionState.cxx
1
 
// Scintilla source code edit control
2
 
/** @file ContractionState.cxx
3
 
 ** Manages visibility of lines for folding.
4
 
 **/
5
 
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
6
 
// The License.txt file describes the conditions under which this software may be distributed.
7
 
 
8
 
#include "Platform.h"
9
 
 
10
 
#include "ContractionState.h"
11
 
 
12
 
OneLine::OneLine() {
13
 
        displayLine = 0;
14
 
        //docLine = 0;
15
 
        visible = true;
16
 
        height = 1;
17
 
        expanded = true;
18
 
}
19
 
 
20
 
ContractionState::ContractionState() {
21
 
        lines = 0;
22
 
        size = 0;
23
 
        linesInDoc = 1;
24
 
        linesInDisplay = 1;
25
 
        valid = false;
26
 
        docLines = 0;
27
 
        sizeDocLines = 0;
28
 
}
29
 
 
30
 
ContractionState::~ContractionState() {
31
 
        Clear();
32
 
}
33
 
 
34
 
void ContractionState::MakeValid() const {
35
 
        if (!valid) {
36
 
                // Could be cleverer by keeping the index of the last still valid entry
37
 
                // rather than invalidating all.
38
 
                linesInDisplay = 0;
39
 
                for (int lineInDoc=0; lineInDoc<linesInDoc; lineInDoc++) {
40
 
                        lines[lineInDoc].displayLine = linesInDisplay;
41
 
                        if (lines[lineInDoc].visible) {
42
 
                                linesInDisplay += lines[lineInDoc].height;
43
 
                        }
44
 
                }
45
 
                if (sizeDocLines < linesInDisplay) {
46
 
                        delete []docLines;
47
 
                        int *docLinesNew = new int[linesInDisplay + growSize];
48
 
                        if (!docLinesNew) {
49
 
                                docLines = 0;
50
 
                                sizeDocLines = 0;
51
 
                                return;
52
 
                        }
53
 
                        docLines = docLinesNew;
54
 
                        sizeDocLines = linesInDisplay + growSize;
55
 
                }
56
 
 
57
 
                int lineInDisplay=0;
58
 
                for (int line=0; line<linesInDoc; line++) {
59
 
                        if (lines[line].visible) {
60
 
                                for (int linePiece=0; linePiece<lines[line].height; linePiece++) {
61
 
                                        docLines[lineInDisplay] = line;
62
 
                                        lineInDisplay++;
63
 
                                }
64
 
                        }
65
 
                }
66
 
                valid = true;
67
 
        }
68
 
}
69
 
 
70
 
void ContractionState::Clear() {
71
 
        delete []lines;
72
 
        lines = 0;
73
 
        size = 0;
74
 
        linesInDoc = 1;
75
 
        linesInDisplay = 1;
76
 
        delete []docLines;
77
 
        docLines = 0;
78
 
        sizeDocLines = 0;
79
 
}
80
 
 
81
 
int ContractionState::LinesInDoc() const {
82
 
        return linesInDoc;
83
 
}
84
 
 
85
 
int ContractionState::LinesDisplayed() const {
86
 
        if (size != 0) {
87
 
                MakeValid();
88
 
        }
89
 
        return linesInDisplay;
90
 
}
91
 
 
92
 
int ContractionState::DisplayFromDoc(int lineDoc) const {
93
 
        if (size == 0) {
94
 
                return lineDoc;
95
 
        }
96
 
        MakeValid();
97
 
        if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
98
 
                return lines[lineDoc].displayLine;
99
 
        }
100
 
        return -1;
101
 
}
102
 
 
103
 
int ContractionState::DocFromDisplay(int lineDisplay) const {
104
 
        if (lineDisplay <= 0)
105
 
                return 0;
106
 
        if (lineDisplay >= linesInDisplay)
107
 
                return linesInDoc;
108
 
        if (size == 0)
109
 
                return lineDisplay;
110
 
        MakeValid();
111
 
        if (docLines) { // Valid allocation
112
 
                return docLines[lineDisplay];
113
 
        } else {
114
 
                return 0;
115
 
        }
116
 
}
117
 
 
118
 
void ContractionState::Grow(int sizeNew) {
119
 
        OneLine *linesNew = new OneLine[sizeNew];
120
 
        if (linesNew) {
121
 
                int i = 0;
122
 
                for (; i < size; i++) {
123
 
                        linesNew[i] = lines[i];
124
 
                }
125
 
                for (; i < sizeNew; i++) {
126
 
                        linesNew[i].displayLine = i;
127
 
                }
128
 
                delete []lines;
129
 
                lines = linesNew;
130
 
                size = sizeNew;
131
 
                valid = false;
132
 
        } else {
133
 
                Platform::DebugPrintf("No memory available\n");
134
 
                // TODO: Blow up
135
 
        }
136
 
}
137
 
 
138
 
void ContractionState::InsertLines(int lineDoc, int lineCount) {
139
 
        if (size == 0) {
140
 
                linesInDoc += lineCount;
141
 
                linesInDisplay += lineCount;
142
 
                return;
143
 
        }
144
 
        //Platform::DebugPrintf("InsertLine[%d] = %d\n", lineDoc);
145
 
        if ((linesInDoc + lineCount + 2) >= size) {
146
 
                Grow(linesInDoc + lineCount + growSize);
147
 
        }
148
 
        linesInDoc += lineCount;
149
 
        for (int i = linesInDoc; i >= lineDoc + lineCount; i--) {
150
 
                lines[i].visible = lines[i - lineCount].visible;
151
 
                lines[i].height = lines[i - lineCount].height;
152
 
                linesInDisplay += lines[i].height;
153
 
                lines[i].expanded = lines[i - lineCount].expanded;
154
 
        }
155
 
        for (int d=0;d<lineCount;d++) {
156
 
                lines[lineDoc+d].visible = true;        // Should inherit visibility from context ?
157
 
                lines[lineDoc+d].height = 1;
158
 
                lines[lineDoc+d].expanded = true;
159
 
        }
160
 
        valid = false;
161
 
}
162
 
 
163
 
void ContractionState::DeleteLines(int lineDoc, int lineCount) {
164
 
        if (size == 0) {
165
 
                linesInDoc -= lineCount;
166
 
                linesInDisplay -= lineCount;
167
 
                return;
168
 
        }
169
 
        int deltaDisplayed = 0;
170
 
        for (int d=0;d<lineCount;d++) {
171
 
                if (lines[lineDoc+d].visible)
172
 
                        deltaDisplayed -= lines[lineDoc+d].height;
173
 
        }
174
 
        for (int i = lineDoc; i < linesInDoc-lineCount; i++) {
175
 
                if (i != 0) // Line zero is always visible
176
 
                        lines[i].visible = lines[i + lineCount].visible;
177
 
                lines[i].expanded = lines[i + lineCount].expanded;
178
 
                lines[i].height = lines[i + lineCount].height;
179
 
        }
180
 
        linesInDoc -= lineCount;
181
 
        linesInDisplay += deltaDisplayed;
182
 
        valid = false;
183
 
}
184
 
 
185
 
bool ContractionState::GetVisible(int lineDoc) const {
186
 
        if (size == 0)
187
 
                return true;
188
 
        if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
189
 
                return lines[lineDoc].visible;
190
 
        } else {
191
 
                return false;
192
 
        }
193
 
}
194
 
 
195
 
bool ContractionState::SetVisible(int lineDocStart, int lineDocEnd, bool visible) {
196
 
        if (lineDocStart == 0)
197
 
                lineDocStart++;
198
 
        if (lineDocStart > lineDocEnd)
199
 
                return false;
200
 
        if (size == 0) {
201
 
                Grow(linesInDoc + growSize);
202
 
        }
203
 
        // TODO: modify docLine members to mirror displayLine
204
 
        int delta = 0;
205
 
        // Change lineDocs
206
 
        if ((lineDocStart <= lineDocEnd) && (lineDocStart >= 0) && (lineDocEnd < linesInDoc)) {
207
 
                for (int line=lineDocStart; line <= lineDocEnd; line++) {
208
 
                        if (lines[line].visible != visible) {
209
 
                                delta += visible ? lines[line].height : -lines[line].height;
210
 
                                lines[line].visible = visible;
211
 
                        }
212
 
                }
213
 
        }
214
 
        linesInDisplay += delta;
215
 
        valid = false;
216
 
        return delta != 0;
217
 
}
218
 
 
219
 
bool ContractionState::GetExpanded(int lineDoc) const {
220
 
        if (size == 0)
221
 
                return true;
222
 
        if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
223
 
                return lines[lineDoc].expanded;
224
 
        } else {
225
 
                return false;
226
 
        }
227
 
}
228
 
 
229
 
bool ContractionState::SetExpanded(int lineDoc, bool expanded) {
230
 
        if (size == 0) {
231
 
                if (expanded) {
232
 
                        // If in completely expanded state then setting
233
 
                        // one line to expanded has no effect.
234
 
                        return false;
235
 
                }
236
 
                Grow(linesInDoc + growSize);
237
 
        }
238
 
        if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
239
 
                if (lines[lineDoc].expanded != expanded) {
240
 
                        lines[lineDoc].expanded = expanded;
241
 
                        return true;
242
 
                }
243
 
        }
244
 
        return false;
245
 
}
246
 
 
247
 
int ContractionState::GetHeight(int lineDoc) const {
248
 
        if (size == 0)
249
 
                return 1;
250
 
        if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
251
 
                return lines[lineDoc].height;
252
 
        } else {
253
 
                return 1;
254
 
        }
255
 
}
256
 
 
257
 
// Set the number of display lines needed for this line.
258
 
// Return true if this is a change.
259
 
bool ContractionState::SetHeight(int lineDoc, int height) {
260
 
        if (lineDoc > linesInDoc)
261
 
                return false;
262
 
        if (size == 0) {
263
 
                if (height == 1) {
264
 
                        // If in completely expanded state then all lines
265
 
                        // assumed to have height of one so no effect here.
266
 
                        return false;
267
 
                }
268
 
                Grow(linesInDoc + growSize);
269
 
        }
270
 
        if (lines[lineDoc].height != height) {
271
 
                lines[lineDoc].height = height;
272
 
                valid = false;
273
 
                return true;
274
 
        } else {
275
 
                return false;
276
 
        }
277
 
}
278
 
 
279
 
void ContractionState::ShowAll() {
280
 
        delete []lines;
281
 
        lines = 0;
282
 
        size = 0;
283
 
}