← Back to branch summary

~ubuntu-branches/ubuntu/wily/geany/wily-proposed

« back to all changes in this revision

Viewing changes to scintilla/ViewStyle.cxx

  • Committer: Package Import Robot
  • Author(s): Evgeni Golov
  • Date: 2011-11-17 12:59:57 UTC
  • mfrom: (1.1.16)
  • Revision ID: package-import@ubuntu.com-20111117125957-nv48s8qkd2clcmr1
Tags: 0.21-1
* Imported Upstream version 0.21
* Refresh filetypes patch against 0.21
* Fix Description (thanks lintian!)
* Standards-Version: 3.9.2
* dpatch → 3.0 (quilt)
* Switch to new dh-style debian/rules
* Add a patch to search for plugins in both, multiarch and
  non-multiarch folders
* Add misc:Pre-Depends to Pre-Depends for multiarch
* Generate geany:Provides with GEANY_ABI_VERSION and GEANY_API_VERSION
* Split arch independent parts into geany-common
* Set maintainer to pkg-geany
* Set Vcs-* headers for pkg-geany
* Drop README.source, we're using standard 3.0 quilt now

Show diffs side-by-side

added added

removed removed

Lines of Context:
scintilla/ViewStyle.cxx
1
 
// Scintilla source code edit control
2
 
/** @file ViewStyle.cxx
3
 
 ** Store information on how the document is to be viewed.
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
 
#include <string.h>
9
 
 
10
 
#include "Platform.h"
11
 
 
12
 
#include "Scintilla.h"
13
 
#include "SplitVector.h"
14
 
#include "Partitioning.h"
15
 
#include "RunStyles.h"
16
 
#include "Indicator.h"
17
 
#include "XPM.h"
18
 
#include "LineMarker.h"
19
 
#include "Style.h"
20
 
#include "ViewStyle.h"
21
 
 
22
 
#ifdef SCI_NAMESPACE
23
 
using namespace Scintilla;
24
 
#endif
25
 
 
26
 
MarginStyle::MarginStyle() :
27
 
        style(SC_MARGIN_SYMBOL), width(0), mask(0), sensitive(false) {
28
 
}
29
 
 
30
 
// A list of the fontnames - avoids wasting space in each style
31
 
FontNames::FontNames() {
32
 
        size = 8;
33
 
        names = new char *[size];
34
 
        max = 0;
35
 
}
36
 
 
37
 
FontNames::~FontNames() {
38
 
        Clear();
39
 
        delete []names;
40
 
        names = 0;
41
 
}
42
 
 
43
 
void FontNames::Clear() {
44
 
        for (int i=0; i<max; i++) {
45
 
                delete []names[i];
46
 
        }
47
 
        max = 0;
48
 
}
49
 
 
50
 
const char *FontNames::Save(const char *name) {
51
 
        if (!name)
52
 
                return 0;
53
 
        for (int i=0; i<max; i++) {
54
 
                if (strcmp(names[i], name) == 0) {
55
 
                        return names[i];
56
 
                }
57
 
        }
58
 
        if (max >= size) {
59
 
                // Grow array
60
 
                int sizeNew = size * 2;
61
 
                char **namesNew = new char *[sizeNew];
62
 
                for (int j=0; j<max; j++) {
63
 
                        namesNew[j] = names[j];
64
 
                }
65
 
                delete []names;
66
 
                names = namesNew;
67
 
                size = sizeNew;
68
 
        }
69
 
        names[max] = new char[strlen(name) + 1];
70
 
        strcpy(names[max], name);
71
 
        max++;
72
 
        return names[max-1];
73
 
}
74
 
 
75
 
ViewStyle::ViewStyle() {
76
 
        Init();
77
 
}
78
 
 
79
 
ViewStyle::ViewStyle(const ViewStyle &source) {
80
 
        Init(source.stylesSize);
81
 
        for (unsigned int sty=0; sty<source.stylesSize; sty++) {
82
 
                styles[sty] = source.styles[sty];
83
 
                // Can't just copy fontname as its lifetime is relative to its owning ViewStyle
84
 
                styles[sty].fontName = fontNames.Save(source.styles[sty].fontName);
85
 
        }
86
 
        for (int mrk=0; mrk<=MARKER_MAX; mrk++) {
87
 
                markers[mrk] = source.markers[mrk];
88
 
        }
89
 
        for (int ind=0; ind<=INDIC_MAX; ind++) {
90
 
                indicators[ind] = source.indicators[ind];
91
 
        }
92
 
 
93
 
        selforeset = source.selforeset;
94
 
        selforeground.desired = source.selforeground.desired;
95
 
        selAdditionalForeground.desired = source.selAdditionalForeground.desired;
96
 
        selbackset = source.selbackset;
97
 
        selbackground.desired = source.selbackground.desired;
98
 
        selAdditionalBackground.desired = source.selAdditionalBackground.desired;
99
 
        selbackground2.desired = source.selbackground2.desired;
100
 
        selAlpha = source.selAlpha;
101
 
        selAdditionalAlpha = source.selAdditionalAlpha;
102
 
        selEOLFilled = source.selEOLFilled;
103
 
 
104
 
        foldmarginColourSet = source.foldmarginColourSet;
105
 
        foldmarginColour.desired = source.foldmarginColour.desired;
106
 
        foldmarginHighlightColourSet = source.foldmarginHighlightColourSet;
107
 
        foldmarginHighlightColour.desired = source.foldmarginHighlightColour.desired;
108
 
 
109
 
        hotspotForegroundSet = source.hotspotForegroundSet;
110
 
        hotspotForeground.desired = source.hotspotForeground.desired;
111
 
        hotspotBackgroundSet = source.hotspotBackgroundSet;
112
 
        hotspotBackground.desired = source.hotspotBackground.desired;
113
 
        hotspotUnderline = source.hotspotUnderline;
114
 
        hotspotSingleLine = source.hotspotSingleLine;
115
 
 
116
 
        whitespaceForegroundSet = source.whitespaceForegroundSet;
117
 
        whitespaceForeground.desired = source.whitespaceForeground.desired;
118
 
        whitespaceBackgroundSet = source.whitespaceBackgroundSet;
119
 
        whitespaceBackground.desired = source.whitespaceBackground.desired;
120
 
        selbar.desired = source.selbar.desired;
121
 
        selbarlight.desired = source.selbarlight.desired;
122
 
        caretcolour.desired = source.caretcolour.desired;
123
 
        additionalCaretColour.desired = source.additionalCaretColour.desired;
124
 
        showCaretLineBackground = source.showCaretLineBackground;
125
 
        caretLineBackground.desired = source.caretLineBackground.desired;
126
 
        caretLineAlpha = source.caretLineAlpha;
127
 
        edgecolour.desired = source.edgecolour.desired;
128
 
        edgeState = source.edgeState;
129
 
        caretStyle = source.caretStyle;
130
 
        caretWidth = source.caretWidth;
131
 
        someStylesProtected = false;
132
 
        leftMarginWidth = source.leftMarginWidth;
133
 
        rightMarginWidth = source.rightMarginWidth;
134
 
        for (int i=0; i < margins; i++) {
135
 
                ms[i] = source.ms[i];
136
 
        }
137
 
        symbolMargin = source.symbolMargin;
138
 
        maskInLine = source.maskInLine;
139
 
        fixedColumnWidth = source.fixedColumnWidth;
140
 
        zoomLevel = source.zoomLevel;
141
 
        viewWhitespace = source.viewWhitespace;
142
 
        whitespaceSize = source.whitespaceSize;
143
 
        viewIndentationGuides = source.viewIndentationGuides;
144
 
        viewEOL = source.viewEOL;
145
 
        showMarkedLines = source.showMarkedLines;
146
 
        extraFontFlag = source.extraFontFlag;
147
 
        extraAscent = source.extraAscent;
148
 
        extraDescent = source.extraDescent;
149
 
        marginStyleOffset = source.marginStyleOffset;
150
 
        annotationVisible = source.annotationVisible;
151
 
        annotationStyleOffset = source.annotationStyleOffset;
152
 
}
153
 
 
154
 
ViewStyle::~ViewStyle() {
155
 
        delete []styles;
156
 
        styles = NULL;
157
 
}
158
 
 
159
 
void ViewStyle::Init(size_t stylesSize_) {
160
 
        stylesSize = 0;
161
 
        styles = NULL;
162
 
        AllocStyles(stylesSize_);
163
 
        fontNames.Clear();
164
 
        ResetDefaultStyle();
165
 
 
166
 
        indicators[0].style = INDIC_SQUIGGLE;
167
 
        indicators[0].under = false;
168
 
        indicators[0].fore = ColourDesired(0, 0x7f, 0);
169
 
        indicators[1].style = INDIC_TT;
170
 
        indicators[1].under = false;
171
 
        indicators[1].fore = ColourDesired(0, 0, 0xff);
172
 
        indicators[2].style = INDIC_PLAIN;
173
 
        indicators[2].under = false;
174
 
        indicators[2].fore = ColourDesired(0xff, 0, 0);
175
 
 
176
 
        lineHeight = 1;
177
 
        maxAscent = 1;
178
 
        maxDescent = 1;
179
 
        aveCharWidth = 8;
180
 
        spaceWidth = 8;
181
 
 
182
 
        selforeset = false;
183
 
        selforeground.desired = ColourDesired(0xff, 0, 0);
184
 
        selAdditionalForeground.desired = ColourDesired(0xff, 0, 0);
185
 
        selbackset = true;
186
 
        selbackground.desired = ColourDesired(0xc0, 0xc0, 0xc0);
187
 
        selAdditionalBackground.desired = ColourDesired(0xd7, 0xd7, 0xd7);
188
 
        selbackground2.desired = ColourDesired(0xb0, 0xb0, 0xb0);
189
 
        selAlpha = SC_ALPHA_NOALPHA;
190
 
        selAdditionalAlpha = SC_ALPHA_NOALPHA;
191
 
        selEOLFilled = false;
192
 
 
193
 
        foldmarginColourSet = false;
194
 
        foldmarginColour.desired = ColourDesired(0xff, 0, 0);
195
 
        foldmarginHighlightColourSet = false;
196
 
        foldmarginHighlightColour.desired = ColourDesired(0xc0, 0xc0, 0xc0);
197
 
 
198
 
        whitespaceForegroundSet = false;
199
 
        whitespaceForeground.desired = ColourDesired(0, 0, 0);
200
 
        whitespaceBackgroundSet = false;
201
 
        whitespaceBackground.desired = ColourDesired(0xff, 0xff, 0xff);
202
 
        selbar.desired = Platform::Chrome();
203
 
        selbarlight.desired = Platform::ChromeHighlight();
204
 
        styles[STYLE_LINENUMBER].fore.desired = ColourDesired(0, 0, 0);
205
 
        styles[STYLE_LINENUMBER].back.desired = Platform::Chrome();
206
 
        caretcolour.desired = ColourDesired(0, 0, 0);
207
 
        additionalCaretColour.desired = ColourDesired(0x7f, 0x7f, 0x7f);
208
 
        showCaretLineBackground = false;
209
 
        caretLineBackground.desired = ColourDesired(0xff, 0xff, 0);
210
 
        caretLineAlpha = SC_ALPHA_NOALPHA;
211
 
        edgecolour.desired = ColourDesired(0xc0, 0xc0, 0xc0);
212
 
        edgeState = EDGE_NONE;
213
 
        caretStyle = CARETSTYLE_LINE;
214
 
        caretWidth = 1;
215
 
        someStylesProtected = false;
216
 
 
217
 
        hotspotForegroundSet = false;
218
 
        hotspotForeground.desired = ColourDesired(0, 0, 0xff);
219
 
        hotspotBackgroundSet = false;
220
 
        hotspotBackground.desired = ColourDesired(0xff, 0xff, 0xff);
221
 
        hotspotUnderline = true;
222
 
        hotspotSingleLine = true;
223
 
 
224
 
        leftMarginWidth = 1;
225
 
        rightMarginWidth = 1;
226
 
        ms[0].style = SC_MARGIN_NUMBER;
227
 
        ms[0].width = 0;
228
 
        ms[0].mask = 0;
229
 
        ms[1].style = SC_MARGIN_SYMBOL;
230
 
        ms[1].width = 16;
231
 
        ms[1].mask = ~SC_MASK_FOLDERS;
232
 
        ms[2].style = SC_MARGIN_SYMBOL;
233
 
        ms[2].width = 0;
234
 
        ms[2].mask = 0;
235
 
        fixedColumnWidth = leftMarginWidth;
236
 
        symbolMargin = false;
237
 
        maskInLine = 0xffffffff;
238
 
        for (int margin=0; margin < margins; margin++) {
239
 
                fixedColumnWidth += ms[margin].width;
240
 
                symbolMargin = symbolMargin || (ms[margin].style != SC_MARGIN_NUMBER);
241
 
                if (ms[margin].width > 0)
242
 
                        maskInLine &= ~ms[margin].mask;
243
 
        }
244
 
        zoomLevel = 0;
245
 
        viewWhitespace = wsInvisible;
246
 
        whitespaceSize = 1;
247
 
        viewIndentationGuides = ivNone;
248
 
        viewEOL = false;
249
 
        showMarkedLines = true;
250
 
        extraFontFlag = 0;
251
 
        extraAscent = 0;
252
 
        extraDescent = 0;
253
 
        marginStyleOffset = 0;
254
 
        annotationVisible = ANNOTATION_HIDDEN;
255
 
        annotationStyleOffset = 0;
256
 
}
257
 
 
258
 
void ViewStyle::RefreshColourPalette(Palette &pal, bool want) {
259
 
        unsigned int i;
260
 
        for (i=0; i<stylesSize; i++) {
261
 
                pal.WantFind(styles[i].fore, want);
262
 
                pal.WantFind(styles[i].back, want);
263
 
        }
264
 
        for (i=0; i<(sizeof(indicators)/sizeof(indicators[0])); i++) {
265
 
                pal.WantFind(indicators[i].fore, want);
266
 
        }
267
 
        for (i=0; i<(sizeof(markers)/sizeof(markers[0])); i++) {
268
 
                markers[i].RefreshColourPalette(pal, want);
269
 
        }
270
 
        pal.WantFind(selforeground, want);
271
 
        pal.WantFind(selAdditionalForeground, want);
272
 
        pal.WantFind(selbackground, want);
273
 
        pal.WantFind(selAdditionalBackground, want);
274
 
        pal.WantFind(selbackground2, want);
275
 
 
276
 
        pal.WantFind(foldmarginColour, want);
277
 
        pal.WantFind(foldmarginHighlightColour, want);
278
 
 
279
 
        pal.WantFind(whitespaceForeground, want);
280
 
        pal.WantFind(whitespaceBackground, want);
281
 
        pal.WantFind(selbar, want);
282
 
        pal.WantFind(selbarlight, want);
283
 
        pal.WantFind(caretcolour, want);
284
 
        pal.WantFind(additionalCaretColour, want);
285
 
        pal.WantFind(caretLineBackground, want);
286
 
        pal.WantFind(edgecolour, want);
287
 
        pal.WantFind(hotspotForeground, want);
288
 
        pal.WantFind(hotspotBackground, want);
289
 
}
290
 
 
291
 
void ViewStyle::Refresh(Surface &surface) {
292
 
        selbar.desired = Platform::Chrome();
293
 
        selbarlight.desired = Platform::ChromeHighlight();
294
 
        styles[STYLE_DEFAULT].Realise(surface, zoomLevel, NULL, extraFontFlag);
295
 
        maxAscent = styles[STYLE_DEFAULT].ascent;
296
 
        maxDescent = styles[STYLE_DEFAULT].descent;
297
 
        someStylesProtected = false;
298
 
        for (unsigned int i=0; i<stylesSize; i++) {
299
 
                if (i != STYLE_DEFAULT) {
300
 
                        styles[i].Realise(surface, zoomLevel, &styles[STYLE_DEFAULT], extraFontFlag);
301
 
                        if (maxAscent < styles[i].ascent)
302
 
                                maxAscent = styles[i].ascent;
303
 
                        if (maxDescent < styles[i].descent)
304
 
                                maxDescent = styles[i].descent;
305
 
                }
306
 
                if (styles[i].IsProtected()) {
307
 
                        someStylesProtected = true;
308
 
                }
309
 
        }
310
 
        maxAscent += extraAscent;
311
 
        maxDescent += extraDescent;
312
 
 
313
 
        lineHeight = maxAscent + maxDescent;
314
 
        aveCharWidth = styles[STYLE_DEFAULT].aveCharWidth;
315
 
        spaceWidth = styles[STYLE_DEFAULT].spaceWidth;
316
 
 
317
 
        fixedColumnWidth = leftMarginWidth;
318
 
        symbolMargin = false;
319
 
        maskInLine = 0xffffffff;
320
 
        for (int margin=0; margin < margins; margin++) {
321
 
                fixedColumnWidth += ms[margin].width;
322
 
                symbolMargin = symbolMargin || (ms[margin].style != SC_MARGIN_NUMBER);
323
 
                if (ms[margin].width > 0)
324
 
                        maskInLine &= ~ms[margin].mask;
325
 
        }
326
 
}
327
 
 
328
 
void ViewStyle::AllocStyles(size_t sizeNew) {
329
 
        Style *stylesNew = new Style[sizeNew];
330
 
        size_t i=0;
331
 
        for (; i<stylesSize; i++) {
332
 
                stylesNew[i] = styles[i];
333
 
                stylesNew[i].fontName = styles[i].fontName;
334
 
        }
335
 
        if (stylesSize > STYLE_DEFAULT) {
336
 
                for (; i<sizeNew; i++) {
337
 
                        if (i != STYLE_DEFAULT) {
338
 
                                stylesNew[i].ClearTo(styles[STYLE_DEFAULT]);
339
 
                        }
340
 
                }
341
 
        }
342
 
        delete []styles;
343
 
        styles = stylesNew;
344
 
        stylesSize = sizeNew;
345
 
}
346
 
 
347
 
void ViewStyle::EnsureStyle(size_t index) {
348
 
        if (index >= stylesSize) {
349
 
                size_t sizeNew = stylesSize * 2;
350
 
                while (sizeNew <= index)
351
 
                        sizeNew *= 2;
352
 
                AllocStyles(sizeNew);
353
 
        }
354
 
}
355
 
 
356
 
void ViewStyle::ResetDefaultStyle() {
357
 
        styles[STYLE_DEFAULT].Clear(ColourDesired(0,0,0),
358
 
                ColourDesired(0xff,0xff,0xff),
359
 
                Platform::DefaultFontSize(), fontNames.Save(Platform::DefaultFont()),
360
 
                SC_CHARSET_DEFAULT,
361
 
                false, false, false, false, Style::caseMixed, true, true, false);
362
 
}
363
 
 
364
 
void ViewStyle::ClearStyles() {
365
 
        // Reset all styles to be like the default style
366
 
        for (unsigned int i=0; i<stylesSize; i++) {
367
 
                if (i != STYLE_DEFAULT) {
368
 
                        styles[i].ClearTo(styles[STYLE_DEFAULT]);
369
 
                }
370
 
        }
371
 
        styles[STYLE_LINENUMBER].back.desired = Platform::Chrome();
372
 
 
373
 
        // Set call tip fore/back to match the values previously set for call tips
374
 
        styles[STYLE_CALLTIP].back.desired = ColourDesired(0xff, 0xff, 0xff);
375
 
        styles[STYLE_CALLTIP].fore.desired = ColourDesired(0x80, 0x80, 0x80);
376
 
}
377
 
 
378
 
void ViewStyle::SetStyleFontName(int styleIndex, const char *name) {
379
 
        styles[styleIndex].fontName = fontNames.Save(name);
380
 
}
381
 
 
382
 
bool ViewStyle::ProtectionActive() const {
383
 
        return someStylesProtected;
384
 
}
385
 
 
386
 
bool ViewStyle::ValidStyle(size_t styleIndex) const {
387
 
        return styleIndex < stylesSize;
388
 
}
389