~ubuntu-branches/ubuntu/wily/apparmor/wily
» Revision
1.1.19
: deprecated/management/profile-editor/src/wxStyledTextCtrl/Editor.cxx
« back to all changes in this revision
Viewing changes to deprecated/management/profile-editor/src/wxStyledTextCtrl/Editor.cxx
- browse files at revision 1.1.19
- compare with another revision
- download diff
- download tarball
- view history from revision 1.1.19
- 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
- files added:
- documentation
- kernel-patches/2.6.39
- utils/vim
- files removed:
- deprecated
- deprecated/management
- deprecated/management/apparmor-dbus
- deprecated/management/apparmor-dbus/src
- deprecated/management/profile-editor
- deprecated/management/profile-editor/doc
- deprecated/management/profile-editor/doc/en
- deprecated/management/profile-editor/macros
- deprecated/management/profile-editor/src
- deprecated/management/profile-editor/src/wxStyledTextCtrl
- files modified:
- Makefile
added
removed
deprecated/management/profile-editor/src/wxStyledTextCtrl/Editor.cxx
1
// Scintilla source code edit control
2
/** @file Editor.cxx
3
** Main code for the edit control.
4
**/
5
// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
6
// The License.txt file describes the conditions under which this software may be distributed.
7
8
#include <stdlib.h>
9
#include <string.h>
10
#include <stdio.h>
11
#include <ctype.h>
12
13
#include "Platform.h"
14
15
#ifndef PLAT_QT
16
#define INCLUDE_DEPRECATED_FEATURES
17
#endif
18
#include "Scintilla.h"
19
20
#include "ContractionState.h"
21
#include "SVector.h"
22
#include "CellBuffer.h"
23
#include "KeyMap.h"
24
#include "Indicator.h"
25
#include "XPM.h"
26
#include "LineMarker.h"
27
#include "Style.h"
28
#include "ViewStyle.h"
29
#include "Document.h"
30
#include "Editor.h"
31
32
/*
33
return whether this modification represents an operation that
34
may reasonably be deferred (not done now OR [possibly] at all)
35
*/
36
static bool CanDeferToLastStep(const DocModification& mh) {
37
if (mh.modificationType & (SC_MOD_BEFOREINSERT|SC_MOD_BEFOREDELETE))
38
return true; // CAN skip
39
if (!(mh.modificationType & (SC_PERFORMED_UNDO|SC_PERFORMED_REDO)))
40
return false; // MUST do
41
if (mh.modificationType & SC_MULTISTEPUNDOREDO)
42
return true; // CAN skip
43
return false; // PRESUMABLY must do
44
}
45
46
static bool CanEliminate(const DocModification& mh) {
47
return
48
(mh.modificationType & (SC_MOD_BEFOREINSERT|SC_MOD_BEFOREDELETE)) != 0;
49
}
50
51
/*
52
return whether this modification represents the FINAL step
53
in a [possibly lengthy] multi-step Undo/Redo sequence
54
*/
55
static bool IsLastStep(const DocModification& mh) {
56
return
57
(mh.modificationType & (SC_PERFORMED_UNDO|SC_PERFORMED_REDO)) != 0
58
&& (mh.modificationType & SC_MULTISTEPUNDOREDO) != 0
59
&& (mh.modificationType & SC_LASTSTEPINUNDOREDO) != 0
60
&& (mh.modificationType & SC_MULTILINEUNDOREDO) != 0;
61
}
62
63
Caret::Caret() :
64
active(false), on(false), period(500) {}
65
66
Timer::Timer() :
67
ticking(false), ticksToWait(0), tickerID(0) {}
68
69
Idler::Idler() :
70
state(false), idlerID(0) {}
71
72
LineLayout::LineLayout(int maxLineLength_) :
73
lineStarts(0),
74
lenLineStarts(0),
75
lineNumber(-1),
76
inCache(false),
77
maxLineLength(-1),
78
numCharsInLine(0),
79
validity(llInvalid),
80
xHighlightGuide(0),
81
highlightColumn(0),
82
selStart(0),
83
selEnd(0),
84
containsCaret(false),
85
edgeColumn(0),
86
chars(0),
87
styles(0),
88
styleBitsSet(0),
89
indicators(0),
90
positions(0),
91
hsStart(0),
92
hsEnd(0),
93
widthLine(wrapWidthInfinite),
94
lines(1) {
95
Resize(maxLineLength_);
96
}
97
98
LineLayout::~LineLayout() {
99
Free();
100
}
101
102
void LineLayout::Resize(int maxLineLength_) {
103
if (maxLineLength_ > maxLineLength) {
104
Free();
105
chars = new char[maxLineLength_ + 1];
106
styles = new unsigned char[maxLineLength_ + 1];
107
indicators = new char[maxLineLength_ + 1];
108
// Extra position allocated as sometimes the Windows
109
// GetTextExtentExPoint API writes an extra element.
110
positions = new int[maxLineLength_ + 1 + 1];
111
maxLineLength = maxLineLength_;
112
}
113
}
114
115
void LineLayout::Free() {
116
delete []chars;
117
chars = 0;
118
delete []styles;
119
styles = 0;
120
delete []indicators;
121
indicators = 0;
122
delete []positions;
123
positions = 0;
124
delete []lineStarts;
125
lineStarts = 0;
126
}
127
128
void LineLayout::Invalidate(validLevel validity_) {
129
if (validity > validity_)
130
validity = validity_;
131
}
132
133
void LineLayout::SetLineStart(int line, int start) {
134
if ((line >= lenLineStarts) && (line != 0)) {
135
int newMaxLines = line + 20;
136
int *newLineStarts = new int[newMaxLines];
137
if (!newLineStarts)
138
return;
139
for (int i = 0; i < newMaxLines; i++) {
140
if (i < lenLineStarts)
141
newLineStarts[i] = lineStarts[i];
142
else
143
newLineStarts[i] = 0;
144
}
145
delete []lineStarts;
146
lineStarts = newLineStarts;
147
lenLineStarts = newMaxLines;
148
}
149
lineStarts[line] = start;
150
}
151
152
void LineLayout::SetBracesHighlight(Range rangeLine, Position braces[],
153
char bracesMatchStyle, int xHighlight) {
154
if (rangeLine.ContainsCharacter(braces[0])) {
155
int braceOffset = braces[0] - rangeLine.start;
156
if (braceOffset < numCharsInLine) {
157
bracePreviousStyles[0] = styles[braceOffset];
158
styles[braceOffset] = bracesMatchStyle;
159
}
160
}
161
if (rangeLine.ContainsCharacter(braces[1])) {
162
int braceOffset = braces[1] - rangeLine.start;
163
if (braceOffset < numCharsInLine) {
164
bracePreviousStyles[1] = styles[braceOffset];
165
styles[braceOffset] = bracesMatchStyle;
166
}
167
}
168
if ((braces[0] >= rangeLine.start && braces[1] <= rangeLine.end) ||
169
(braces[1] >= rangeLine.start && braces[0] <= rangeLine.end)) {
170
xHighlightGuide = xHighlight;
171
}
172
}
173
174
void LineLayout::RestoreBracesHighlight(Range rangeLine, Position braces[]) {
175
if (rangeLine.ContainsCharacter(braces[0])) {
176
int braceOffset = braces[0] - rangeLine.start;
177
if (braceOffset < numCharsInLine) {
178
styles[braceOffset] = bracePreviousStyles[0];
179
}
180
}
181
if (rangeLine.ContainsCharacter(braces[1])) {
182
int braceOffset = braces[1] - rangeLine.start;
183
if (braceOffset < numCharsInLine) {
184
styles[braceOffset] = bracePreviousStyles[1];
185
}
186
}
187
xHighlightGuide = 0;
188
}
189
190
LineLayoutCache::LineLayoutCache() :
191
level(0), length(0), size(0), cache(0),
192
allInvalidated(false), styleClock(-1), useCount(0) {
193
Allocate(0);
194
}
195
196
LineLayoutCache::~LineLayoutCache() {
197
Deallocate();
198
}
199
200
void LineLayoutCache::Allocate(int length_) {
201
PLATFORM_ASSERT(cache == NULL);
202
allInvalidated = false;
203
length = length_;
204
size = length;
205
if (size > 1) {
206
size = (size / 16 + 1) * 16;
207
}
208
if (size > 0) {
209
cache = new LineLayout * [size];
210
}
211
for (int i = 0; i < size; i++)
212
cache[i] = 0;
213
}
214
215
void LineLayoutCache::AllocateForLevel(int linesOnScreen, int linesInDoc) {
216
PLATFORM_ASSERT(useCount == 0);
217
int lengthForLevel = 0;
218
if (level == llcCaret) {
219
lengthForLevel = 1;
220
} else if (level == llcPage) {
221
lengthForLevel = linesOnScreen + 1;
222
} else if (level == llcDocument) {
223
lengthForLevel = linesInDoc;
224
}
225
if (lengthForLevel > size) {
226
Deallocate();
227
Allocate(lengthForLevel);
228
} else {
229
if (lengthForLevel < length) {
230
for (int i = lengthForLevel; i < length; i++) {
231
delete cache[i];
232
cache[i] = 0;
233
}
234
}
235
length = lengthForLevel;
236
}
237
PLATFORM_ASSERT(length == lengthForLevel);
238
PLATFORM_ASSERT(cache != NULL || length == 0);
239
}
240
241
void LineLayoutCache::Deallocate() {
242
PLATFORM_ASSERT(useCount == 0);
243
for (int i = 0; i < length; i++)
244
delete cache[i];
245
delete []cache;
246
cache = 0;
247
length = 0;
248
size = 0;
249
}
250
251
void LineLayoutCache::Invalidate(LineLayout::validLevel validity_) {
252
if (cache && !allInvalidated) {
253
for (int i = 0; i < length; i++) {
254
if (cache[i]) {
255
cache[i]->Invalidate(validity_);
256
}
257
}
258
if (validity_ == LineLayout::llInvalid) {
259
allInvalidated = true;
260
}
261
}
262
}
263
264
void LineLayoutCache::SetLevel(int level_) {
265
allInvalidated = false;
266
if ((level_ != -1) && (level != level_)) {
267
level = level_;
268
Deallocate();
269
}
270
}
271
272
LineLayout *LineLayoutCache::Retrieve(int lineNumber, int lineCaret, int maxChars, int styleClock_,
273
int linesOnScreen, int linesInDoc) {
274
AllocateForLevel(linesOnScreen, linesInDoc);
275
if (styleClock != styleClock_) {
276
Invalidate(LineLayout::llCheckTextAndStyle);
277
styleClock = styleClock_;
278
}
279
allInvalidated = false;
280
int pos = -1;
281
LineLayout *ret = 0;
282
if (level == llcCaret) {
283
pos = 0;
284
} else if (level == llcPage) {
285
if (lineNumber == lineCaret) {
286
pos = 0;
287
} else {
288
pos = 1 + (lineNumber % (length - 1));
289
}
290
} else if (level == llcDocument) {
291
pos = lineNumber;
292
}
293
if (pos >= 0) {
294
PLATFORM_ASSERT(useCount == 0);
295
if (cache && (pos < length)) {
296
if (cache[pos]) {
297
if ((cache[pos]->lineNumber != lineNumber) ||
298
(cache[pos]->maxLineLength < maxChars)) {
299
delete cache[pos];
300
cache[pos] = 0;
301
}
302
}
303
if (!cache[pos]) {
304
cache[pos] = new LineLayout(maxChars);
305
}
306
if (cache[pos]) {
307
cache[pos]->lineNumber = lineNumber;
308
cache[pos]->inCache = true;
309
ret = cache[pos];
310
useCount++;
311
}
312
}
313
}
314
315
if (!ret) {
316
ret = new LineLayout(maxChars);
317
ret->lineNumber = lineNumber;
318
}
319
320
return ret;
321
}
322
323
void LineLayoutCache::Dispose(LineLayout *ll) {
324
allInvalidated = false;
325
if (ll) {
326
if (!ll->inCache) {
327
delete ll;
328
} else {
329
useCount--;
330
}
331
}
332
}
333
334
Editor::Editor() {
335
ctrlID = 0;
336
337
stylesValid = false;
338
339
printMagnification = 0;
340
printColourMode = SC_PRINT_NORMAL;
341
printWrapState = eWrapWord;
342
cursorMode = SC_CURSORNORMAL;
343
controlCharSymbol = 0; /* Draw the control characters */
344
345
hasFocus = false;
346
hideSelection = false;
347
inOverstrike = false;
348
errorStatus = 0;
349
mouseDownCaptures = true;
350
351
bufferedDraw = true;
352
twoPhaseDraw = true;
353
354
lastClickTime = 0;
355
dwellDelay = SC_TIME_FOREVER;
356
ticksToDwell = SC_TIME_FOREVER;
357
dwelling = false;
358
ptMouseLast.x = 0;
359
ptMouseLast.y = 0;
360
inDragDrop = false;
361
dropWentOutside = false;
362
posDrag = invalidPosition;
363
posDrop = invalidPosition;
364
selectionType = selChar;
365
366
lastXChosen = 0;
367
lineAnchor = 0;
368
originalAnchorPos = 0;
369
370
selType = selStream;
371
moveExtendsSelection = false;
372
xStartSelect = 0;
373
xEndSelect = 0;
374
primarySelection = true;
375
376
caretXPolicy = CARET_SLOP | CARET_EVEN;
377
caretXSlop = 50;
378
379
caretYPolicy = CARET_EVEN;
380
caretYSlop = 0;
381
382
searchAnchor = 0;
383
384
xOffset = 0;
385
xCaretMargin = 50;
386
horizontalScrollBarVisible = true;
387
scrollWidth = 2000;
388
verticalScrollBarVisible = true;
389
endAtLastLine = true;
390
caretSticky = false;
391
392
pixmapLine = Surface::Allocate();
393
pixmapSelMargin = Surface::Allocate();
394
pixmapSelPattern = Surface::Allocate();
395
pixmapIndentGuide = Surface::Allocate();
396
pixmapIndentGuideHighlight = Surface::Allocate();
397
398
currentPos = 0;
399
anchor = 0;
400
401
targetStart = 0;
402
targetEnd = 0;
403
searchFlags = 0;
404
405
topLine = 0;
406
posTopLine = 0;
407
408
lengthForEncode = -1;
409
410
needUpdateUI = true;
411
braces[0] = invalidPosition;
412
braces[1] = invalidPosition;
413
bracesMatchStyle = STYLE_BRACEBAD;
414
highlightGuideColumn = 0;
415
416
theEdge = 0;
417
418
paintState = notPainting;
419
420
modEventMask = SC_MODEVENTMASKALL;
421
422
pdoc = new Document();
423
pdoc->AddRef();
424
pdoc->AddWatcher(this, 0);
425
426
recordingMacro = false;
427
foldFlags = 0;
428
429
wrapState = eWrapNone;
430
wrapWidth = LineLayout::wrapWidthInfinite;
431
docLineLastWrapped = -1;
432
docLastLineToWrap = -1;
433
backgroundWrapEnabled = true;
434
wrapVisualFlags = 0;
435
wrapVisualFlagsLocation = 0;
436
wrapVisualStartIndent = 0;
437
actualWrapVisualStartIndent = 0;
438
439
convertPastes = true;
440
441
hsStart = -1;
442
hsEnd = -1;
443
444
llc.SetLevel(LineLayoutCache::llcCaret);
445
}
446
447
Editor::~Editor() {
448
pdoc->RemoveWatcher(this, 0);
449
pdoc->Release();
450
pdoc = 0;
451
DropGraphics();
452
delete pixmapLine;
453
delete pixmapSelMargin;
454
delete pixmapSelPattern;
455
delete pixmapIndentGuide;
456
delete pixmapIndentGuideHighlight;
457
}
458
459
void Editor::Finalise() {
460
SetIdle(false);
461
CancelModes();
462
}
463
464
void Editor::DropGraphics() {
465
pixmapLine->Release();
466
pixmapSelMargin->Release();
467
pixmapSelPattern->Release();
468
pixmapIndentGuide->Release();
469
pixmapIndentGuideHighlight->Release();
470
}
471
472
void Editor::InvalidateStyleData() {
473
stylesValid = false;
474
palette.Release();
475
DropGraphics();
476
llc.Invalidate(LineLayout::llInvalid);
477
if (selType == selRectangle) {
478
xStartSelect = XFromPosition(anchor);
479
xEndSelect = XFromPosition(currentPos);
480
}
481
}
482
483
void Editor::InvalidateStyleRedraw() {
484
NeedWrapping();
485
InvalidateStyleData();
486
Redraw();
487
}
488
489
void Editor::RefreshColourPalette(Palette &pal, bool want) {
490
vs.RefreshColourPalette(pal, want);
491
}
492
493
void Editor::RefreshStyleData() {
494
if (!stylesValid) {
495
stylesValid = true;
496
AutoSurface surface(this);
497
if (surface) {
498
vs.Refresh(*surface);
499
RefreshColourPalette(palette, true);
500
palette.Allocate(wMain);
501
RefreshColourPalette(palette, false);
502
}
503
SetScrollBars();
504
}
505
}
506
507
PRectangle Editor::GetClientRectangle() {
508
return wMain.GetClientPosition();
509
}
510
511
PRectangle Editor::GetTextRectangle() {
512
PRectangle rc = GetClientRectangle();
513
rc.left += vs.fixedColumnWidth;
514
rc.right -= vs.rightMarginWidth;
515
return rc;
516
}
517
518
int Editor::LinesOnScreen() {
519
PRectangle rcClient = GetClientRectangle();
520
int htClient = rcClient.bottom - rcClient.top;
521
//Platform::DebugPrintf("lines on screen = %d\n", htClient / lineHeight + 1);
522
return htClient / vs.lineHeight;
523
}
524
525
int Editor::LinesToScroll() {
526
int retVal = LinesOnScreen() - 1;
527
if (retVal < 1)
528
return 1;
529
else
530
return retVal;
531
}
532
533
int Editor::MaxScrollPos() {
534
//Platform::DebugPrintf("Lines %d screen = %d maxScroll = %d\n",
535
//LinesTotal(), LinesOnScreen(), LinesTotal() - LinesOnScreen() + 1);
536
int retVal = cs.LinesDisplayed();
537
if (endAtLastLine) {
538
retVal -= LinesOnScreen();
539
} else {
540
retVal--;
541
}
542
if (retVal < 0) {
543
return 0;
544
} else {
545
return retVal;
546
}
547
}
548
549
static inline bool IsControlCharacter(int ch) {
550
// iscntrl returns true for lots of chars > 127 which are displayable
551
return ch >= 0 && ch < ' ';
552
}
553
554
const char *ControlCharacterString(unsigned char ch) {
555
const char *reps[] = {
556
"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
557
"BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
558
"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
559
"CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
560
};
561
if (ch < (sizeof(reps) / sizeof(reps[0]))) {
562
return reps[ch];
563
} else {
564
return "BAD";
565
}
566
}
567
568
/**
569
* Convenience class to ensure LineLayout objects are always disposed.
570
*/
571
class AutoLineLayout {
572
LineLayoutCache &llc;
573
LineLayout *ll;
574
AutoLineLayout &operator=(const AutoLineLayout &) { return * this; }
575
public:
576
AutoLineLayout(LineLayoutCache &llc_, LineLayout *ll_) : llc(llc_), ll(ll_) {}
577
~AutoLineLayout() {
578
llc.Dispose(ll);
579
ll = 0;
580
}
581
LineLayout *operator->() const {
582
return ll;
583
}
584
operator LineLayout *() const {
585
return ll;
586
}
587
void Set(LineLayout *ll_) {
588
llc.Dispose(ll);
589
ll = ll_;
590
}
591
};
592
593
/**
594
* Allows to iterate through the lines of a selection.
595
* Althought it can be called for a stream selection, in most cases
596
* it is inefficient and it should be used only for
597
* a rectangular or a line selection.
598
*/
599
class SelectionLineIterator {
600
private:
601
Editor *ed;
602
int line; ///< Current line within the iteration.
603
bool forward; ///< True if iterating by increasing line number, false otherwise.
604
int selStart, selEnd; ///< Positions of the start and end of the selection relative to the start of the document.
605
int minX, maxX; ///< Left and right of selection rectangle.
606
607
public:
608
int lineStart, lineEnd; ///< Line numbers, first and last lines of the selection.
609
int startPos, endPos; ///< Positions of the beginning and end of the selection on the current line.
610
611
void Reset() {
612
if (forward) {
613
line = lineStart;
614
} else {
615
line = lineEnd;
616
}
617
}
618
619
SelectionLineIterator(Editor *ed_, bool forward_ = true) : line(0), startPos(0), endPos(0) {
620
ed = ed_;
621
forward = forward_;
622
selStart = ed->SelectionStart();
623
selEnd = ed->SelectionEnd();
624
lineStart = ed->pdoc->LineFromPosition(selStart);
625
lineEnd = ed->pdoc->LineFromPosition(selEnd);
626
// Left of rectangle
627
minX = Platform::Minimum(ed->xStartSelect, ed->xEndSelect);
628
// Right of rectangle
629
maxX = Platform::Maximum(ed->xStartSelect, ed->xEndSelect);
630
Reset();
631
}
632
~SelectionLineIterator() {}
633
634
void SetAt(int line) {
635
if (line < lineStart || line > lineEnd) {
636
startPos = endPos = INVALID_POSITION;
637
} else {
638
if (ed->selType == ed->selRectangle) {
639
// Measure line and return character closest to minX
640
startPos = ed->PositionFromLineX(line, minX);
641
// Measure line and return character closest to maxX
642
endPos = ed->PositionFromLineX(line, maxX);
643
} else if (ed->selType == ed->selLines) {
644
startPos = ed->pdoc->LineStart(line);
645
endPos = ed->pdoc->LineStart(line + 1);
646
} else { // Stream selection, here only for completion
647
if (line == lineStart) {
648
startPos = selStart;
649
} else {
650
startPos = ed->pdoc->LineStart(line);
651
}
652
if (line == lineEnd) {
653
endPos = selEnd;
654
} else {
655
endPos = ed->pdoc->LineStart(line + 1);
656
}
657
}
658
}
659
}
660
bool Iterate() {
661
SetAt(line);
662
if (forward) {
663
line++;
664
} else {
665
line--;
666
}
667
return startPos != INVALID_POSITION;
668
}
669
};
670
671
Point Editor::LocationFromPosition(int pos) {
672
Point pt;
673
RefreshStyleData();
674
if (pos == INVALID_POSITION)
675
return pt;
676
int line = pdoc->LineFromPosition(pos);
677
int lineVisible = cs.DisplayFromDoc(line);
678
//Platform::DebugPrintf("line=%d\n", line);
679
AutoSurface surface(this);
680
AutoLineLayout ll(llc, RetrieveLineLayout(line));
681
if (surface && ll) {
682
// -1 because of adding in for visible lines in following loop.
683
pt.y = (lineVisible - topLine - 1) * vs.lineHeight;
684
pt.x = 0;
685
unsigned int posLineStart = pdoc->LineStart(line);
686
LayoutLine(line, surface, vs, ll, wrapWidth);
687
int posInLine = pos - posLineStart;
688
// In case of very long line put x at arbitrary large position
689
if (posInLine > ll->maxLineLength) {
690
pt.x = ll->positions[ll->maxLineLength] - ll->positions[ll->LineStart(ll->lines)];
691
}
692
693
for (int subLine = 0; subLine < ll->lines; subLine++) {
694
if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) {
695
pt.x = ll->positions[posInLine] - ll->positions[ll->LineStart(subLine)];
696
if (actualWrapVisualStartIndent != 0) {
697
int lineStart = ll->LineStart(subLine);
698
if (lineStart != 0) // Wrapped
699
pt.x += actualWrapVisualStartIndent * vs.aveCharWidth;
700
}
701
}
702
if (posInLine >= ll->LineStart(subLine)) {
703
pt.y += vs.lineHeight;
704
}
705
}
706
pt.x += vs.fixedColumnWidth - xOffset;
707
}
708
return pt;
709
}
710
711
int Editor::XFromPosition(int pos) {
712
Point pt = LocationFromPosition(pos);
713
return pt.x - vs.fixedColumnWidth + xOffset;
714
}
715
716
int Editor::LineFromLocation(Point pt) {
717
return cs.DocFromDisplay(pt.y / vs.lineHeight + topLine);
718
}
719
720
void Editor::SetTopLine(int topLineNew) {
721
topLine = topLineNew;
722
posTopLine = pdoc->LineStart(cs.DocFromDisplay(topLine));
723
}
724
725
static inline bool IsEOLChar(char ch) {
726
return (ch == '\r') || (ch == '\n');
727
}
728
729
int Editor::PositionFromLocation(Point pt) {
730
RefreshStyleData();
731
pt.x = pt.x - vs.fixedColumnWidth + xOffset;
732
int visibleLine = pt.y / vs.lineHeight + topLine;
733
if (pt.y < 0) { // Division rounds towards 0
734
visibleLine = (pt.y - (vs.lineHeight - 1)) / vs.lineHeight + topLine;
735
}
736
if (visibleLine < 0)
737
visibleLine = 0;
738
int lineDoc = cs.DocFromDisplay(visibleLine);
739
if (lineDoc >= pdoc->LinesTotal())
740
return pdoc->Length();
741
unsigned int posLineStart = pdoc->LineStart(lineDoc);
742
int retVal = posLineStart;
743
AutoSurface surface(this);
744
AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
745
if (surface && ll) {
746
LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
747
int lineStartSet = cs.DisplayFromDoc(lineDoc);
748
int subLine = visibleLine - lineStartSet;
749
if (subLine < ll->lines) {
750
int lineStart = ll->LineStart(subLine);
751
int lineEnd = ll->LineStart(subLine + 1);
752
int subLineStart = ll->positions[lineStart];
753
754
if (actualWrapVisualStartIndent != 0) {
755
if (lineStart != 0) // Wrapped
756
pt.x -= actualWrapVisualStartIndent * vs.aveCharWidth;
757
}
758
for (int i = lineStart; i < lineEnd; i++) {
759
if (pt.x < (((ll->positions[i] + ll->positions[i + 1]) / 2) - subLineStart) ||
760
IsEOLChar(ll->chars[i])) {
761
return pdoc->MovePositionOutsideChar(i + posLineStart, 1);
762
}
763
}
764
return lineEnd + posLineStart;
765
}
766
retVal = ll->numCharsInLine + posLineStart;
767
}
768
return retVal;
769
}
770
771
// Like PositionFromLocation but INVALID_POSITION returned when not near any text.
772
int Editor::PositionFromLocationClose(Point pt) {
773
RefreshStyleData();
774
PRectangle rcClient = GetTextRectangle();
775
if (!rcClient.Contains(pt))
776
return INVALID_POSITION;
777
if (pt.x < vs.fixedColumnWidth)
778
return INVALID_POSITION;
779
if (pt.y < 0)
780
return INVALID_POSITION;
781
pt.x = pt.x - vs.fixedColumnWidth + xOffset;
782
int visibleLine = pt.y / vs.lineHeight + topLine;
783
if (pt.y < 0) { // Division rounds towards 0
784
visibleLine = (pt.y - (vs.lineHeight - 1)) / vs.lineHeight + topLine;
785
}
786
int lineDoc = cs.DocFromDisplay(visibleLine);
787
if (lineDoc < 0)
788
return INVALID_POSITION;
789
if (lineDoc >= pdoc->LinesTotal())
790
return INVALID_POSITION;
791
AutoSurface surface(this);
792
AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
793
if (surface && ll) {
794
LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
795
unsigned int posLineStart = pdoc->LineStart(lineDoc);
796
int lineStartSet = cs.DisplayFromDoc(lineDoc);
797
int subLine = visibleLine - lineStartSet;
798
if (subLine < ll->lines) {
799
int lineStart = ll->LineStart(subLine);
800
int lineEnd = ll->LineStart(subLine + 1);
801
int subLineStart = ll->positions[lineStart];
802
803
if (actualWrapVisualStartIndent != 0) {
804
if (lineStart != 0) // Wrapped
805
pt.x -= actualWrapVisualStartIndent * vs.aveCharWidth;
806
}
807
for (int i = lineStart; i < lineEnd; i++) {
808
if (pt.x < (((ll->positions[i] + ll->positions[i + 1]) / 2) - subLineStart) ||
809
IsEOLChar(ll->chars[i])) {
810
return pdoc->MovePositionOutsideChar(i + posLineStart, 1);
811
}
812
}
813
}
814
}
815
816
return INVALID_POSITION;
817
}
818
819
/**
820
* Find the document position corresponding to an x coordinate on a particular document line.
821
* Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
822
*/
823
int Editor::PositionFromLineX(int lineDoc, int x) {
824
RefreshStyleData();
825
if (lineDoc >= pdoc->LinesTotal())
826
return pdoc->Length();
827
//Platform::DebugPrintf("Position of (%d,%d) line = %d top=%d\n", pt.x, pt.y, line, topLine);
828
AutoSurface surface(this);
829
AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
830
int retVal = 0;
831
if (surface && ll) {
832
unsigned int posLineStart = pdoc->LineStart(lineDoc);
833
LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
834
retVal = ll->numCharsInLine + posLineStart;
835
int subLine = 0;
836
int lineStart = ll->LineStart(subLine);
837
int lineEnd = ll->LineStart(subLine + 1);
838
int subLineStart = ll->positions[lineStart];
839
840
if (actualWrapVisualStartIndent != 0) {
841
if (lineStart != 0) // Wrapped
842
x -= actualWrapVisualStartIndent * vs.aveCharWidth;
843
}
844
for (int i = lineStart; i < lineEnd; i++) {
845
if (x < (((ll->positions[i] + ll->positions[i + 1]) / 2) - subLineStart) ||
846
IsEOLChar(ll->chars[i])) {
847
retVal = pdoc->MovePositionOutsideChar(i + posLineStart, 1);
848
break;
849
}
850
}
851
}
852
return retVal;
853
}
854
855
/**
856
* If painting then abandon the painting because a wider redraw is needed.
857
* @return true if calling code should stop drawing.
858
*/
859
bool Editor::AbandonPaint() {
860
if ((paintState == painting) && !paintingAllText) {
861
paintState = paintAbandoned;
862
}
863
return paintState == paintAbandoned;
864
}
865
866
void Editor::RedrawRect(PRectangle rc) {
867
//Platform::DebugPrintf("Redraw %0d,%0d - %0d,%0d\n", rc.left, rc.top, rc.right, rc.bottom);
868
869
// Clip the redraw rectangle into the client area
870
PRectangle rcClient = GetClientRectangle();
871
if (rc.top < rcClient.top)
872
rc.top = rcClient.top;
873
if (rc.bottom > rcClient.bottom)
874
rc.bottom = rcClient.bottom;
875
if (rc.left < rcClient.left)
876
rc.left = rcClient.left;
877
if (rc.right > rcClient.right)
878
rc.right = rcClient.right;
879
880
if ((rc.bottom > rc.top) && (rc.right > rc.left)) {
881
wMain.InvalidateRectangle(rc);
882
}
883
}
884
885
void Editor::Redraw() {
886
//Platform::DebugPrintf("Redraw all\n");
887
PRectangle rcClient = GetClientRectangle();
888
wMain.InvalidateRectangle(rcClient);
889
//wMain.InvalidateAll();
890
}
891
892
void Editor::RedrawSelMargin(int line) {
893
if (!AbandonPaint()) {
894
if (vs.maskInLine) {
895
Redraw();
896
} else {
897
PRectangle rcSelMargin = GetClientRectangle();
898
rcSelMargin.right = vs.fixedColumnWidth;
899
if (line != -1) {
900
int position = pdoc->LineStart(line);
901
PRectangle rcLine = RectangleFromRange(position, position);
902
rcSelMargin.top = rcLine.top;
903
rcSelMargin.bottom = rcLine.bottom;
904
}
905
wMain.InvalidateRectangle(rcSelMargin);
906
}
907
}
908
}
909
910
PRectangle Editor::RectangleFromRange(int start, int end) {
911
int minPos = start;
912
if (minPos > end)
913
minPos = end;
914
int maxPos = start;
915
if (maxPos < end)
916
maxPos = end;
917
int minLine = cs.DisplayFromDoc(pdoc->LineFromPosition(minPos));
918
int lineDocMax = pdoc->LineFromPosition(maxPos);
919
int maxLine = cs.DisplayFromDoc(lineDocMax) + cs.GetHeight(lineDocMax) - 1;
920
PRectangle rcClient = GetTextRectangle();
921
PRectangle rc;
922
rc.left = vs.fixedColumnWidth;
923
rc.top = (minLine - topLine) * vs.lineHeight;
924
if (rc.top < 0)
925
rc.top = 0;
926
rc.right = rcClient.right;
927
rc.bottom = (maxLine - topLine + 1) * vs.lineHeight;
928
// Ensure PRectangle is within 16 bit space
929
rc.top = Platform::Clamp(rc.top, -32000, 32000);
930
rc.bottom = Platform::Clamp(rc.bottom, -32000, 32000);
931
932
return rc;
933
}
934
935
void Editor::InvalidateRange(int start, int end) {
936
RedrawRect(RectangleFromRange(start, end));
937
}
938
939
int Editor::CurrentPosition() {
940
return currentPos;
941
}
942
943
bool Editor::SelectionEmpty() {
944
return anchor == currentPos;
945
}
946
947
int Editor::SelectionStart() {
948
return Platform::Minimum(currentPos, anchor);
949
}
950
951
int Editor::SelectionEnd() {
952
return Platform::Maximum(currentPos, anchor);
953
}
954
955
void Editor::SetRectangularRange() {
956
if (selType == selRectangle) {
957
xStartSelect = XFromPosition(anchor);
958
xEndSelect = XFromPosition(currentPos);
959
}
960
}
961
962
void Editor::InvalidateSelection(int currentPos_, int anchor_) {
963
int firstAffected = anchor;
964
if (firstAffected > currentPos)
965
firstAffected = currentPos;
966
if (firstAffected > anchor_)
967
firstAffected = anchor_;
968
if (firstAffected > currentPos_)
969
firstAffected = currentPos_;
970
int lastAffected = anchor;
971
if (lastAffected < currentPos)
972
lastAffected = currentPos;
973
if (lastAffected < anchor_)
974
lastAffected = anchor_;
975
if (lastAffected < (currentPos_ + 1)) // +1 ensures caret repainted
976
lastAffected = (currentPos_ + 1);
977
needUpdateUI = true;
978
InvalidateRange(firstAffected, lastAffected);
979
}
980
981
void Editor::SetSelection(int currentPos_, int anchor_) {
982
currentPos_ = pdoc->ClampPositionIntoDocument(currentPos_);
983
anchor_ = pdoc->ClampPositionIntoDocument(anchor_);
984
if ((currentPos != currentPos_) || (anchor != anchor_)) {
985
InvalidateSelection(currentPos_, anchor_);
986
currentPos = currentPos_;
987
anchor = anchor_;
988
}
989
SetRectangularRange();
990
ClaimSelection();
991
}
992
993
void Editor::SetSelection(int currentPos_) {
994
currentPos_ = pdoc->ClampPositionIntoDocument(currentPos_);
995
if (currentPos != currentPos_) {
996
InvalidateSelection(currentPos_, currentPos_);
997
currentPos = currentPos_;
998
}
999
SetRectangularRange();
1000
ClaimSelection();
1001
}
1002
1003
void Editor::SetEmptySelection(int currentPos_) {
1004
selType = selStream;
1005
moveExtendsSelection = false;
1006
SetSelection(currentPos_, currentPos_);
1007
}
1008
1009
bool Editor::RangeContainsProtected(int start, int end) const {
1010
if (vs.ProtectionActive()) {
1011
if (start > end) {
1012
int t = start;
1013
start = end;
1014
end = t;
1015
}
1016
int mask = pdoc->stylingBitsMask;
1017
for (int pos = start; pos < end; pos++) {
1018
if (vs.styles[pdoc->StyleAt(pos) & mask].IsProtected())
1019
return true;
1020
}
1021
}
1022
return false;
1023
}
1024
1025
bool Editor::SelectionContainsProtected() {
1026
// DONE, but untested...: make support rectangular selection
1027
bool scp = false;
1028
if (selType == selStream) {
1029
scp = RangeContainsProtected(anchor, currentPos);
1030
} else {
1031
SelectionLineIterator lineIterator(this);
1032
while (lineIterator.Iterate()) {
1033
if (RangeContainsProtected(lineIterator.startPos, lineIterator.endPos)) {
1034
scp = true;
1035
break;
1036
}
1037
}
1038
}
1039
return scp;
1040
}
1041
1042
/**
1043
* Asks document to find a good position and then moves out of any invisible positions.
1044
*/
1045
int Editor::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
1046
pos = pdoc->MovePositionOutsideChar(pos, moveDir, checkLineEnd);
1047
if (vs.ProtectionActive()) {
1048
int mask = pdoc->stylingBitsMask;
1049
if (moveDir > 0) {
1050
if ((pos > 0) && vs.styles[pdoc->StyleAt(pos - 1) & mask].IsProtected()) {
1051
while ((pos < pdoc->Length()) &&
1052
(vs.styles[pdoc->StyleAt(pos) & mask].IsProtected()))
1053
pos++;
1054
}
1055
} else if (moveDir < 0) {
1056
if (vs.styles[pdoc->StyleAt(pos) & mask].IsProtected()) {
1057
while ((pos > 0) &&
1058
(vs.styles[pdoc->StyleAt(pos - 1) & mask].IsProtected()))
1059
pos--;
1060
}
1061
}
1062
}
1063
return pos;
1064
}
1065
1066
int Editor::MovePositionTo(int newPos, selTypes sel, bool ensureVisible) {
1067
int delta = newPos - currentPos;
1068
newPos = pdoc->ClampPositionIntoDocument(newPos);
1069
newPos = MovePositionOutsideChar(newPos, delta);
1070
if (sel != noSel) {
1071
selType = sel;
1072
}
1073
if (sel != noSel || moveExtendsSelection) {
1074
SetSelection(newPos);
1075
} else {
1076
SetEmptySelection(newPos);
1077
}
1078
ShowCaretAtCurrentPosition();
1079
if (ensureVisible) {
1080
EnsureCaretVisible();
1081
}
1082
NotifyMove(newPos);
1083
return 0;
1084
}
1085
1086
int Editor::MovePositionSoVisible(int pos, int moveDir) {
1087
pos = pdoc->ClampPositionIntoDocument(pos);
1088
pos = MovePositionOutsideChar(pos, moveDir);
1089
int lineDoc = pdoc->LineFromPosition(pos);
1090
if (cs.GetVisible(lineDoc)) {
1091
return pos;
1092
} else {
1093
int lineDisplay = cs.DisplayFromDoc(lineDoc);
1094
if (moveDir > 0) {
1095
// lineDisplay is already line before fold as lines in fold use display line of line after fold
1096
lineDisplay = Platform::Clamp(lineDisplay, 0, cs.LinesDisplayed());
1097
return pdoc->LineStart(cs.DocFromDisplay(lineDisplay));
1098
} else {
1099
lineDisplay = Platform::Clamp(lineDisplay - 1, 0, cs.LinesDisplayed());
1100
return pdoc->LineEnd(cs.DocFromDisplay(lineDisplay));
1101
}
1102
}
1103
}
1104
1105
/**
1106
* Choose the x position that the caret will try to stick to
1107
* as it moves up and down.
1108
*/
1109
void Editor::SetLastXChosen() {
1110
Point pt = LocationFromPosition(currentPos);
1111
lastXChosen = pt.x;
1112
}
1113
1114
void Editor::ScrollTo(int line, bool moveThumb) {
1115
int topLineNew = Platform::Clamp(line, 0, MaxScrollPos());
1116
if (topLineNew != topLine) {
1117
// Try to optimise small scrolls
1118
int linesToMove = topLine - topLineNew;
1119
SetTopLine(topLineNew);
1120
ShowCaretAtCurrentPosition();
1121
// Perform redraw rather than scroll if many lines would be redrawn anyway.
1122
#ifndef UNDER_CE
1123
if (abs(linesToMove) <= 10) {
1124
ScrollText(linesToMove);
1125
} else {
1126
Redraw();
1127
}
1128
#else
1129
Redraw();
1130
#endif
1131
if (moveThumb) {
1132
SetVerticalScrollPos();
1133
}
1134
}
1135
}
1136
1137
void Editor::ScrollText(int /* linesToMove */) {
1138
//Platform::DebugPrintf("Editor::ScrollText %d\n", linesToMove);
1139
Redraw();
1140
}
1141
1142
void Editor::HorizontalScrollTo(int xPos) {
1143
//Platform::DebugPrintf("HorizontalScroll %d\n", xPos);
1144
if (xPos < 0)
1145
xPos = 0;
1146
if ((wrapState == eWrapNone) && (xOffset != xPos)) {
1147
xOffset = xPos;
1148
SetHorizontalScrollPos();
1149
RedrawRect(GetClientRectangle());
1150
}
1151
}
1152
1153
void Editor::MoveCaretInsideView(bool ensureVisible) {
1154
PRectangle rcClient = GetTextRectangle();
1155
Point pt = LocationFromPosition(currentPos);
1156
if (pt.y < rcClient.top) {
1157
MovePositionTo(PositionFromLocation(
1158
Point(lastXChosen, rcClient.top)),
1159
noSel, ensureVisible);
1160
} else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) {
1161
int yOfLastLineFullyDisplayed = rcClient.top + (LinesOnScreen() - 1) * vs.lineHeight;
1162
MovePositionTo(PositionFromLocation(
1163
Point(lastXChosen, rcClient.top + yOfLastLineFullyDisplayed)),
1164
noSel, ensureVisible);
1165
}
1166
}
1167
1168
int Editor::DisplayFromPosition(int pos) {
1169
int lineDoc = pdoc->LineFromPosition(pos);
1170
int lineDisplay = cs.DisplayFromDoc(lineDoc);
1171
AutoSurface surface(this);
1172
AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
1173
if (surface && ll) {
1174
LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
1175
unsigned int posLineStart = pdoc->LineStart(lineDoc);
1176
int posInLine = pos - posLineStart;
1177
lineDisplay--; // To make up for first increment ahead.
1178
for (int subLine = 0; subLine < ll->lines; subLine++) {
1179
if (posInLine >= ll->LineStart(subLine)) {
1180
lineDisplay++;
1181
}
1182
}
1183
}
1184
return lineDisplay;
1185
}
1186
1187
/**
1188
* Ensure the caret is reasonably visible in context.
1189
*
1190
Caret policy in SciTE
1191
1192
If slop is set, we can define a slop value.
1193
This value defines an unwanted zone (UZ) where the caret is... unwanted.
1194
This zone is defined as a number of pixels near the vertical margins,
1195
and as a number of lines near the horizontal margins.
1196
By keeping the caret away from the edges, it is seen within its context,
1197
so it is likely that the identifier that the caret is on can be completely seen,
1198
and that the current line is seen with some of the lines following it which are
1199
often dependent on that line.
1200
1201
If strict is set, the policy is enforced... strictly.
1202
The caret is centred on the display if slop is not set,
1203
and cannot go in the UZ if slop is set.
1204
1205
If jumps is set, the display is moved more energetically
1206
so the caret can move in the same direction longer before the policy is applied again.
1207
'3UZ' notation is used to indicate three time the size of the UZ as a distance to the margin.
1208
1209
If even is not set, instead of having symmetrical UZs,
1210
the left and bottom UZs are extended up to right and top UZs respectively.
1211
This way, we favour the displaying of useful information: the begining of lines,
1212
where most code reside, and the lines after the caret, eg. the body of a function.
1213
1214
| | | | |
1215
slop | strict | jumps | even | Caret can go to the margin | When reaching limit�caret going out of
1216
| | | | | visibility or going into the UZ) display is...
1217
-----+--------+-------+------+--------------------------------------------+--------------------------------------------------------------
1218
0 | 0 | 0 | 0 | Yes | moved to put caret on top/on right
1219
0 | 0 | 0 | 1 | Yes | moved by one position
1220
0 | 0 | 1 | 0 | Yes | moved to put caret on top/on right
1221
0 | 0 | 1 | 1 | Yes | centred on the caret
1222
0 | 1 | - | 0 | Caret is always on top/on right of display | -
1223
0 | 1 | - | 1 | No, caret is always centred | -
1224
1 | 0 | 0 | 0 | Yes | moved to put caret out of the asymmetrical UZ
1225
1 | 0 | 0 | 1 | Yes | moved to put caret out of the UZ
1226
1 | 0 | 1 | 0 | Yes | moved to put caret at 3UZ of the top or right margin
1227
1 | 0 | 1 | 1 | Yes | moved to put caret at 3UZ of the margin
1228
1 | 1 | - | 0 | Caret is always at UZ of top/right margin | -
1229
1 | 1 | 0 | 1 | No, kept out of UZ | moved by one position
1230
1 | 1 | 1 | 1 | No, kept out of UZ | moved to put caret at 3UZ of the margin
1231
*/
1232
void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
1233
//Platform::DebugPrintf("EnsureCaretVisible %d %s\n", xOffset, useMargin ? " margin" : " ");
1234
PRectangle rcClient = GetTextRectangle();
1235
//int rcClientFullWidth = rcClient.Width();
1236
int posCaret = currentPos;
1237
if (posDrag >= 0) {
1238
posCaret = posDrag;
1239
}
1240
Point pt = LocationFromPosition(posCaret);
1241
Point ptBottomCaret = pt;
1242
ptBottomCaret.y += vs.lineHeight - 1;
1243
int lineCaret = DisplayFromPosition(posCaret);
1244
bool bSlop, bStrict, bJump, bEven;
1245
1246
// Vertical positioning
1247
if (vert && (pt.y < rcClient.top || ptBottomCaret.y > rcClient.bottom || (caretYPolicy & CARET_STRICT) != 0)) {
1248
int linesOnScreen = LinesOnScreen();
1249
int halfScreen = Platform::Maximum(linesOnScreen - 1, 2) / 2;
1250
int newTopLine = topLine;
1251
bSlop = (caretYPolicy & CARET_SLOP) != 0;
1252
bStrict = (caretYPolicy & CARET_STRICT) != 0;
1253
bJump = (caretYPolicy & CARET_JUMPS) != 0;
1254
bEven = (caretYPolicy & CARET_EVEN) != 0;
1255
1256
// It should be possible to scroll the window to show the caret,
1257
// but this fails to remove the caret on GTK+
1258
if (bSlop) { // A margin is defined
1259
int yMoveT, yMoveB;
1260
if (bStrict) {
1261
int yMarginT, yMarginB;
1262
if (!useMargin) {
1263
// In drag mode, avoid moves
1264
// otherwise, a double click will select several lines.
1265
yMarginT = yMarginB = 0;
1266
} else {
1267
// yMarginT must equal to caretYSlop, with a minimum of 1 and
1268
// a maximum of slightly less than half the heigth of the text area.
1269
yMarginT = Platform::Clamp(caretYSlop, 1, halfScreen);
1270
if (bEven) {
1271
yMarginB = yMarginT;
1272
} else {
1273
yMarginB = linesOnScreen - yMarginT - 1;
1274
}
1275
}
1276
yMoveT = yMarginT;
1277
if (bEven) {
1278
if (bJump) {
1279
yMoveT = Platform::Clamp(caretYSlop * 3, 1, halfScreen);
1280
}
1281
yMoveB = yMoveT;
1282
} else {
1283
yMoveB = linesOnScreen - yMoveT - 1;
1284
}
1285
if (lineCaret < topLine + yMarginT) {
1286
// Caret goes too high
1287
newTopLine = lineCaret - yMoveT;
1288
} else if (lineCaret > topLine + linesOnScreen - 1 - yMarginB) {
1289
// Caret goes too low
1290
newTopLine = lineCaret - linesOnScreen + 1 + yMoveB;
1291
}
1292
} else { // Not strict
1293
yMoveT = bJump ? caretYSlop * 3 : caretYSlop;
1294
yMoveT = Platform::Clamp(yMoveT, 1, halfScreen);
1295
if (bEven) {
1296
yMoveB = yMoveT;
1297
} else {
1298
yMoveB = linesOnScreen - yMoveT - 1;
1299
}
1300
if (lineCaret < topLine) {
1301
// Caret goes too high
1302
newTopLine = lineCaret - yMoveT;
1303
} else if (lineCaret > topLine + linesOnScreen - 1) {
1304
// Caret goes too low
1305
newTopLine = lineCaret - linesOnScreen + 1 + yMoveB;
1306
}
1307
}
1308
} else { // No slop
1309
if (!bStrict && !bJump) {
1310
// Minimal move
1311
if (lineCaret < topLine) {
1312
// Caret goes too high
1313
newTopLine = lineCaret;
1314
} else if (lineCaret > topLine + linesOnScreen - 1) {
1315
// Caret goes too low
1316
if (bEven) {
1317
newTopLine = lineCaret - linesOnScreen + 1;
1318
} else {
1319
newTopLine = lineCaret;
1320
}
1321
}
1322
} else { // Strict or going out of display
1323
if (bEven) {
1324
// Always center caret
1325
newTopLine = lineCaret - halfScreen;
1326
} else {
1327
// Always put caret on top of display
1328
newTopLine = lineCaret;
1329
}
1330
}
1331
}
1332
newTopLine = Platform::Clamp(newTopLine, 0, MaxScrollPos());
1333
if (newTopLine != topLine) {
1334
Redraw();
1335
SetTopLine(newTopLine);
1336
SetVerticalScrollPos();
1337
}
1338
}
1339
1340
// Horizontal positioning
1341
if (horiz && (wrapState == eWrapNone)) {
1342
int halfScreen = Platform::Maximum(rcClient.Width() - 4, 4) / 2;
1343
int xOffsetNew = xOffset;
1344
bSlop = (caretXPolicy & CARET_SLOP) != 0;
1345
bStrict = (caretXPolicy & CARET_STRICT) != 0;
1346
bJump = (caretXPolicy & CARET_JUMPS) != 0;
1347
bEven = (caretXPolicy & CARET_EVEN) != 0;
1348
1349
if (bSlop) { // A margin is defined
1350
int xMoveL, xMoveR;
1351
if (bStrict) {
1352
int xMarginL, xMarginR;
1353
if (!useMargin) {
1354
// In drag mode, avoid moves unless very near of the margin
1355
// otherwise, a simple click will select text.
1356
xMarginL = xMarginR = 2;
1357
} else {
1358
// xMargin must equal to caretXSlop, with a minimum of 2 and
1359
// a maximum of slightly less than half the width of the text area.
1360
xMarginR = Platform::Clamp(caretXSlop, 2, halfScreen);
1361
if (bEven) {
1362
xMarginL = xMarginR;
1363
} else {
1364
xMarginL = rcClient.Width() - xMarginR - 4;
1365
}
1366
}
1367
if (bJump && bEven) {
1368
// Jump is used only in even mode
1369
xMoveL = xMoveR = Platform::Clamp(caretXSlop * 3, 1, halfScreen);
1370
} else {
1371
xMoveL = xMoveR = 0; // Not used, avoid a warning
1372
}
1373
if (pt.x < rcClient.left + xMarginL) {
1374
// Caret is on the left of the display
1375
if (bJump && bEven) {
1376
xOffsetNew -= xMoveL;
1377
} else {
1378
// Move just enough to allow to display the caret
1379
xOffsetNew -= (rcClient.left + xMarginL) - pt.x;
1380
}
1381
} else if (pt.x >= rcClient.right - xMarginR) {
1382
// Caret is on the right of the display
1383
if (bJump && bEven) {
1384
xOffsetNew += xMoveR;
1385
} else {
1386
// Move just enough to allow to display the caret
1387
xOffsetNew += pt.x - (rcClient.right - xMarginR) + 1;
1388
}
1389
}
1390
} else { // Not strict
1391
xMoveR = bJump ? caretXSlop * 3 : caretXSlop;
1392
xMoveR = Platform::Clamp(xMoveR, 1, halfScreen);
1393
if (bEven) {
1394
xMoveL = xMoveR;
1395
} else {
1396
xMoveL = rcClient.Width() - xMoveR - 4;
1397
}
1398
if (pt.x < rcClient.left) {
1399
// Caret is on the left of the display
1400
xOffsetNew -= xMoveL;
1401
} else if (pt.x >= rcClient.right) {
1402
// Caret is on the right of the display
1403
xOffsetNew += xMoveR;
1404
}
1405
}
1406
} else { // No slop
1407
if (bStrict ||
1408
(bJump && (pt.x < rcClient.left || pt.x >= rcClient.right))) {
1409
// Strict or going out of display
1410
if (bEven) {
1411
// Center caret
1412
xOffsetNew += pt.x - rcClient.left - halfScreen;
1413
} else {
1414
// Put caret on right
1415
xOffsetNew += pt.x - rcClient.right + 1;
1416
}
1417
} else {
1418
// Move just enough to allow to display the caret
1419
if (pt.x < rcClient.left) {
1420
// Caret is on the left of the display
1421
if (bEven) {
1422
xOffsetNew -= rcClient.left - pt.x;
1423
} else {
1424
xOffsetNew += pt.x - rcClient.right + 1;
1425
}
1426
} else if (pt.x >= rcClient.right) {
1427
// Caret is on the right of the display
1428
xOffsetNew += pt.x - rcClient.right + 1;
1429
}
1430
}
1431
}
1432
// In case of a jump (find result) largely out of display, adjust the offset to display the caret
1433
if (pt.x + xOffset < rcClient.left + xOffsetNew) {
1434
xOffsetNew = pt.x + xOffset - rcClient.left;
1435
} else if (pt.x + xOffset >= rcClient.right + xOffsetNew) {
1436
xOffsetNew = pt.x + xOffset - rcClient.right + 1;
1437
}
1438
if (xOffsetNew < 0) {
1439
xOffsetNew = 0;
1440
}
1441
if (xOffset != xOffsetNew) {
1442
xOffset = xOffsetNew;
1443
if (xOffsetNew > 0) {
1444
PRectangle rcText = GetTextRectangle();
1445
if (horizontalScrollBarVisible == true &&
1446
rcText.Width() + xOffset > scrollWidth) {
1447
scrollWidth = xOffset + rcText.Width();
1448
SetScrollBars();
1449
}
1450
}
1451
SetHorizontalScrollPos();
1452
Redraw();
1453
}
1454
}
1455
UpdateSystemCaret();
1456
}
1457
1458
void Editor::ShowCaretAtCurrentPosition() {
1459
if (hasFocus) {
1460
caret.active = true;
1461
caret.on = true;
1462
SetTicking(true);
1463
} else {
1464
caret.active = false;
1465
caret.on = false;
1466
}
1467
InvalidateCaret();
1468
}
1469
1470
void Editor::DropCaret() {
1471
caret.active = false;
1472
InvalidateCaret();
1473
}
1474
1475
void Editor::InvalidateCaret() {
1476
if (posDrag >= 0)
1477
InvalidateRange(posDrag, posDrag + 1);
1478
else
1479
InvalidateRange(currentPos, currentPos + 1);
1480
UpdateSystemCaret();
1481
}
1482
1483
void Editor::UpdateSystemCaret() {
1484
}
1485
1486
void Editor::NeedWrapping(int docLineStartWrapping, int docLineEndWrapping) {
1487
docLineStartWrapping = Platform::Minimum(docLineStartWrapping, pdoc->LinesTotal()-1);
1488
docLineEndWrapping = Platform::Minimum(docLineEndWrapping, pdoc->LinesTotal()-1);
1489
bool noWrap = (docLastLineToWrap == docLineLastWrapped);
1490
if (docLineLastWrapped > (docLineStartWrapping - 1)) {
1491
docLineLastWrapped = docLineStartWrapping - 1;
1492
if (docLineLastWrapped < -1)
1493
docLineLastWrapped = -1;
1494
llc.Invalidate(LineLayout::llPositions);
1495
}
1496
if (noWrap) {
1497
docLastLineToWrap = docLineEndWrapping;
1498
} else if (docLastLineToWrap < docLineEndWrapping) {
1499
docLastLineToWrap = docLineEndWrapping + 1;
1500
}
1501
if (docLastLineToWrap < -1)
1502
docLastLineToWrap = -1;
1503
if (docLastLineToWrap >= pdoc->LinesTotal())
1504
docLastLineToWrap = pdoc->LinesTotal()-1;
1505
// Wrap lines during idle.
1506
if ((wrapState != eWrapNone) &&
1507
backgroundWrapEnabled &&
1508
(docLastLineToWrap != docLineLastWrapped)) {
1509
SetIdle(true);
1510
}
1511
}
1512
1513
// Check if wrapping needed and perform any needed wrapping.
1514
// fullwrap: if true, all lines which need wrapping will be done,
1515
// in this single call.
1516
// priorityWrapLineStart: If greater than zero, all lines starting from
1517
// here to 100 lines past will be wrapped (even if there are
1518
// more lines under wrapping process in idle).
1519
// If it is neither fullwrap, nor priorityWrap, then 100 lines will be
1520
// wrapped, if there are any wrapping going on in idle. (Generally this
1521
// condition is called only from idler).
1522
// Return true if wrapping occurred.
1523
bool Editor::WrapLines(bool fullWrap, int priorityWrapLineStart) {
1524
// If there are any pending wraps, do them during idle if possible.
1525
if (wrapState != eWrapNone) {
1526
if (docLineLastWrapped < docLastLineToWrap) {
1527
if (!(backgroundWrapEnabled && SetIdle(true))) {
1528
// Background wrapping is disabled, or idle processing
1529
// not supported. A full wrap is required.
1530
fullWrap = true;
1531
}
1532
}
1533
if (!fullWrap && priorityWrapLineStart >= 0 &&
1534
// .. and if the paint window is outside pending wraps
1535
(((priorityWrapLineStart + 100) < docLineLastWrapped) ||
1536
(priorityWrapLineStart > docLastLineToWrap))) {
1537
// No priority wrap pending
1538
return false;
1539
}
1540
}
1541
int goodTopLine = topLine;
1542
bool wrapOccurred = false;
1543
if (docLineLastWrapped < pdoc->LinesTotal()) {
1544
if (wrapState == eWrapNone) {
1545
if (wrapWidth != LineLayout::wrapWidthInfinite) {
1546
wrapWidth = LineLayout::wrapWidthInfinite;
1547
for (int lineDoc = 0; lineDoc < pdoc->LinesTotal(); lineDoc++) {
1548
cs.SetHeight(lineDoc, 1);
1549
}
1550
wrapOccurred = true;
1551
}
1552
docLineLastWrapped = 0x7ffffff;
1553
} else {
1554
//ElapsedTime et;
1555
int lineDocTop = cs.DocFromDisplay(topLine);
1556
int subLineTop = topLine - cs.DisplayFromDoc(lineDocTop);
1557
PRectangle rcTextArea = GetClientRectangle();
1558
rcTextArea.left = vs.fixedColumnWidth;
1559
rcTextArea.right -= vs.rightMarginWidth;
1560
wrapWidth = rcTextArea.Width();
1561
// Ensure all of the document is styled.
1562
pdoc->EnsureStyledTo(pdoc->Length());
1563
RefreshStyleData();
1564
AutoSurface surface(this);
1565
if (surface) {
1566
bool priorityWrap = false;
1567
int lastLineToWrap = docLastLineToWrap;
1568
int firstLineToWrap = docLineLastWrapped;
1569
if (!fullWrap) {
1570
if (priorityWrapLineStart >= 0) {
1571
// This is a priority wrap.
1572
firstLineToWrap = priorityWrapLineStart;
1573
lastLineToWrap = firstLineToWrap + 100;
1574
priorityWrap = true;
1575
} else {
1576
// This is idle wrap.
1577
lastLineToWrap = docLineLastWrapped + 100;
1578
}
1579
if (lastLineToWrap >= docLastLineToWrap)
1580
lastLineToWrap = docLastLineToWrap;
1581
} // else do a fullWrap.
1582
1583
// printf("Wraplines: full = %d, priorityStart = %d (wrapping: %d to %d)\n", fullWrap, priorityWrapLineStart, firstLineToWrap, lastLineToWrap);
1584
// printf("Pending wraps: %d to %d\n", docLineLastWrapped, docLastLineToWrap);
1585
while (firstLineToWrap < lastLineToWrap) {
1586
firstLineToWrap++;
1587
if (!priorityWrap)
1588
docLineLastWrapped++;
1589
if (firstLineToWrap < pdoc->LinesTotal()) {
1590
AutoLineLayout ll(llc, RetrieveLineLayout(firstLineToWrap));
1591
int linesWrapped = 1;
1592
if (ll) {
1593
LayoutLine(firstLineToWrap, surface, vs, ll, wrapWidth);
1594
linesWrapped = ll->lines;
1595
}
1596
if (cs.SetHeight(firstLineToWrap, linesWrapped)) {
1597
wrapOccurred = true;
1598
}
1599
}
1600
}
1601
// If wrapping is done, bring it to resting position
1602
if (docLineLastWrapped > docLastLineToWrap) {
1603
docLineLastWrapped = -1;
1604
docLastLineToWrap = -1;
1605
}
1606
}
1607
goodTopLine = cs.DisplayFromDoc(lineDocTop);
1608
if (subLineTop < cs.GetHeight(lineDocTop))
1609
goodTopLine += subLineTop;
1610
else
1611
goodTopLine += cs.GetHeight(lineDocTop);
1612
//double durWrap = et.Duration(true);
1613
//Platform::DebugPrintf("Wrap:%9.6g \n", durWrap);
1614
}
1615
}
1616
if (wrapOccurred) {
1617
SetScrollBars();
1618
SetTopLine(Platform::Clamp(goodTopLine, 0, MaxScrollPos()));
1619
SetVerticalScrollPos();
1620
}
1621
return wrapOccurred;
1622
}
1623
1624
void Editor::LinesJoin() {
1625
if (!RangeContainsProtected(targetStart, targetEnd)) {
1626
pdoc->BeginUndoAction();
1627
bool prevNonWS = true;
1628
for (int pos = targetStart; pos < targetEnd; pos++) {
1629
if (IsEOLChar(pdoc->CharAt(pos))) {
1630
targetEnd -= pdoc->LenChar(pos);
1631
pdoc->DelChar(pos);
1632
if (prevNonWS) {
1633
// Ensure at least one space separating previous lines
1634
pdoc->InsertChar(pos, ' ');
1635
}
1636
} else {
1637
prevNonWS = pdoc->CharAt(pos) != ' ';
1638
}
1639
}
1640
pdoc->EndUndoAction();
1641
}
1642
}
1643
1644
const char *StringFromEOLMode(int eolMode) {
1645
if (eolMode == SC_EOL_CRLF) {
1646
return "\r\n";
1647
} else if (eolMode == SC_EOL_CR) {
1648
return "\r";
1649
} else {
1650
return "\n";
1651
}
1652
}
1653
1654
void Editor::LinesSplit(int pixelWidth) {
1655
if (!RangeContainsProtected(targetStart, targetEnd)) {
1656
if (pixelWidth == 0) {
1657
PRectangle rcText = GetTextRectangle();
1658
pixelWidth = rcText.Width();
1659
}
1660
int lineStart = pdoc->LineFromPosition(targetStart);
1661
int lineEnd = pdoc->LineFromPosition(targetEnd);
1662
const char *eol = StringFromEOLMode(pdoc->eolMode);
1663
pdoc->BeginUndoAction();
1664
for (int line = lineStart; line <= lineEnd; line++) {
1665
AutoSurface surface(this);
1666
AutoLineLayout ll(llc, RetrieveLineLayout(line));
1667
if (surface && ll) {
1668
unsigned int posLineStart = pdoc->LineStart(line);
1669
LayoutLine(line, surface, vs, ll, pixelWidth);
1670
for (int subLine = 1; subLine < ll->lines; subLine++) {
1671
pdoc->InsertString(posLineStart + (subLine - 1) * strlen(eol) +
1672
ll->LineStart(subLine), eol);
1673
targetEnd += static_cast<int>(strlen(eol));
1674
}
1675
}
1676
}
1677
pdoc->EndUndoAction();
1678
}
1679
}
1680
1681
int Editor::SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) {
1682
if (vs.markers[markerCheck].markType == SC_MARK_EMPTY)
1683
return markerDefault;
1684
return markerCheck;
1685
}
1686
1687
// Avoid 64 bit compiler warnings.
1688
// Scintilla does not support text buffers larger than 2**31
1689
static int istrlen(const char *s) {
1690
return static_cast<int>(strlen(s));
1691
}
1692
1693
void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
1694
if (vs.fixedColumnWidth == 0)
1695
return;
1696
1697
PRectangle rcMargin = GetClientRectangle();
1698
rcMargin.right = vs.fixedColumnWidth;
1699
1700
if (!rc.Intersects(rcMargin))
1701
return;
1702
1703
Surface *surface;
1704
if (bufferedDraw) {
1705
surface = pixmapSelMargin;
1706
} else {
1707
surface = surfWindow;
1708
}
1709
1710
PRectangle rcSelMargin = rcMargin;
1711
rcSelMargin.right = rcMargin.left;
1712
1713
for (int margin = 0; margin < vs.margins; margin++) {
1714
if (vs.ms[margin].width > 0) {
1715
1716
rcSelMargin.left = rcSelMargin.right;
1717
rcSelMargin.right = rcSelMargin.left + vs.ms[margin].width;
1718
1719
if (vs.ms[margin].symbol) {
1720
/* alternate scheme:
1721
if (vs.ms[margin].mask & SC_MASK_FOLDERS)
1722
surface->FillRectangle(rcSelMargin, vs.styles[STYLE_DEFAULT].back.allocated);
1723
else
1724
// Required because of special way brush is created for selection margin
1725
surface->FillRectangle(rcSelMargin, pixmapSelPattern);
1726
*/
1727
if (vs.ms[margin].mask & SC_MASK_FOLDERS)
1728
// Required because of special way brush is created for selection margin
1729
surface->FillRectangle(rcSelMargin, *pixmapSelPattern);
1730
else
1731
surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back.allocated);
1732
} else {
1733
surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back.allocated);
1734
}
1735
1736
int visibleLine = topLine;
1737
int yposScreen = 0;
1738
1739
// Work out whether the top line is whitespace located after a
1740
// lessening of fold level which implies a 'fold tail' but which should not
1741
// be displayed until the last of a sequence of whitespace.
1742
bool needWhiteClosure = false;
1743
int level = pdoc->GetLevel(cs.DocFromDisplay(topLine));
1744
if (level & SC_FOLDLEVELWHITEFLAG) {
1745
int lineBack = cs.DocFromDisplay(topLine);
1746
int levelPrev = level;
1747
while ((lineBack > 0) && (levelPrev & SC_FOLDLEVELWHITEFLAG)) {
1748
lineBack--;
1749
levelPrev = pdoc->GetLevel(lineBack);
1750
}
1751
if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
1752
if ((level & SC_FOLDLEVELNUMBERMASK) < (levelPrev & SC_FOLDLEVELNUMBERMASK))
1753
needWhiteClosure = true;
1754
}
1755
}
1756
1757
// Old code does not know about new markers needed to distinguish all cases
1758
int folderOpenMid = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEROPENMID,
1759
SC_MARKNUM_FOLDEROPEN);
1760
int folderEnd = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEREND,
1761
SC_MARKNUM_FOLDER);
1762
1763
while ((visibleLine < cs.LinesDisplayed()) && yposScreen < rcMargin.bottom) {
1764
1765
PLATFORM_ASSERT(visibleLine < cs.LinesDisplayed());
1766
1767
int lineDoc = cs.DocFromDisplay(visibleLine);
1768
PLATFORM_ASSERT(cs.GetVisible(lineDoc));
1769
bool firstSubLine = visibleLine == cs.DisplayFromDoc(lineDoc);
1770
1771
// Decide which fold indicator should be displayed
1772
level = pdoc->GetLevel(lineDoc);
1773
int levelNext = pdoc->GetLevel(lineDoc + 1);
1774
int marks = pdoc->GetMark(lineDoc);
1775
if (!firstSubLine)
1776
marks = 0;
1777
int levelNum = level & SC_FOLDLEVELNUMBERMASK;
1778
int levelNextNum = levelNext & SC_FOLDLEVELNUMBERMASK;
1779
if (level & SC_FOLDLEVELHEADERFLAG) {
1780
if (firstSubLine) {
1781
if (cs.GetExpanded(lineDoc)) {
1782
if (levelNum == SC_FOLDLEVELBASE)
1783
marks |= 1 << SC_MARKNUM_FOLDEROPEN;
1784
else
1785
marks |= 1 << folderOpenMid;
1786
} else {
1787
if (levelNum == SC_FOLDLEVELBASE)
1788
marks |= 1 << SC_MARKNUM_FOLDER;
1789
else
1790
marks |= 1 << folderEnd;
1791
}
1792
} else {
1793
marks |= 1 << SC_MARKNUM_FOLDERSUB;
1794
}
1795
needWhiteClosure = false;
1796
} else if (level & SC_FOLDLEVELWHITEFLAG) {
1797
if (needWhiteClosure) {
1798
if (levelNext & SC_FOLDLEVELWHITEFLAG) {
1799
marks |= 1 << SC_MARKNUM_FOLDERSUB;
1800
} else if (levelNum > SC_FOLDLEVELBASE) {
1801
marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
1802
needWhiteClosure = false;
1803
} else {
1804
marks |= 1 << SC_MARKNUM_FOLDERTAIL;
1805
needWhiteClosure = false;
1806
}
1807
} else if (levelNum > SC_FOLDLEVELBASE) {
1808
if (levelNextNum < levelNum) {
1809
if (levelNextNum > SC_FOLDLEVELBASE) {
1810
marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
1811
} else {
1812
marks |= 1 << SC_MARKNUM_FOLDERTAIL;
1813
}
1814
} else {
1815
marks |= 1 << SC_MARKNUM_FOLDERSUB;
1816
}
1817
}
1818
} else if (levelNum > SC_FOLDLEVELBASE) {
1819
if (levelNextNum < levelNum) {
1820
needWhiteClosure = false;
1821
if (levelNext & SC_FOLDLEVELWHITEFLAG) {
1822
marks |= 1 << SC_MARKNUM_FOLDERSUB;
1823
needWhiteClosure = true;
1824
} else if (levelNextNum > SC_FOLDLEVELBASE) {
1825
marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
1826
} else {
1827
marks |= 1 << SC_MARKNUM_FOLDERTAIL;
1828
}
1829
} else {
1830
marks |= 1 << SC_MARKNUM_FOLDERSUB;
1831
}
1832
}
1833
1834
marks &= vs.ms[margin].mask;
1835
PRectangle rcMarker = rcSelMargin;
1836
rcMarker.top = yposScreen;
1837
rcMarker.bottom = yposScreen + vs.lineHeight;
1838
if (!vs.ms[margin].symbol) {
1839
char number[100];
1840
number[0] = '\0';
1841
if (firstSubLine)
1842
sprintf(number, "%d", lineDoc + 1);
1843
if (foldFlags & SC_FOLDFLAG_LEVELNUMBERS) {
1844
int lev = pdoc->GetLevel(lineDoc);
1845
sprintf(number, "%c%c %03X %03X",
1846
(lev & SC_FOLDLEVELHEADERFLAG) ? 'H' : '_',
1847
(lev & SC_FOLDLEVELWHITEFLAG) ? 'W' : '_',
1848
lev & SC_FOLDLEVELNUMBERMASK,
1849
lev >> 16
1850
);
1851
}
1852
PRectangle rcNumber = rcMarker;
1853
// Right justify
1854
int width = surface->WidthText(vs.styles[STYLE_LINENUMBER].font, number, istrlen(number));
1855
int xpos = rcNumber.right - width - 3;
1856
rcNumber.left = xpos;
1857
surface->DrawTextNoClip(rcNumber, vs.styles[STYLE_LINENUMBER].font,
1858
rcNumber.top + vs.maxAscent, number, istrlen(number),
1859
vs.styles[STYLE_LINENUMBER].fore.allocated,
1860
vs.styles[STYLE_LINENUMBER].back.allocated);
1861
}
1862
1863
if (marks) {
1864
for (int markBit = 0; (markBit < 32) && marks; markBit++) {
1865
if (marks & 1) {
1866
vs.markers[markBit].Draw(surface, rcMarker, vs.styles[STYLE_LINENUMBER].font);
1867
}
1868
marks >>= 1;
1869
}
1870
}
1871
1872
visibleLine++;
1873
yposScreen += vs.lineHeight;
1874
}
1875
}
1876
}
1877
1878
PRectangle rcBlankMargin = rcMargin;
1879
rcBlankMargin.left = rcSelMargin.right;
1880
surface->FillRectangle(rcBlankMargin, vs.styles[STYLE_DEFAULT].back.allocated);
1881
1882
if (bufferedDraw) {
1883
surfWindow->Copy(rcMargin, Point(), *pixmapSelMargin);
1884
}
1885
}
1886
1887
void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid) {
1888
int ydiff = (rcTab.bottom - rcTab.top) / 2;
1889
int xhead = rcTab.right - 1 - ydiff;
1890
if (xhead <= rcTab.left) {
1891
ydiff -= rcTab.left - xhead - 1;
1892
xhead = rcTab.left - 1;
1893
}
1894
if ((rcTab.left + 2) < (rcTab.right - 1))
1895
surface->MoveTo(rcTab.left + 2, ymid);
1896
else
1897
surface->MoveTo(rcTab.right - 1, ymid);
1898
surface->LineTo(rcTab.right - 1, ymid);
1899
surface->LineTo(xhead, ymid - ydiff);
1900
surface->MoveTo(rcTab.right - 1, ymid);
1901
surface->LineTo(xhead, ymid + ydiff);
1902
}
1903
1904
static bool IsSpaceOrTab(char ch) {
1905
return ch == ' ' || ch == '\t';
1906
}
1907
1908
LineLayout *Editor::RetrieveLineLayout(int lineNumber) {
1909
int posLineStart = pdoc->LineStart(lineNumber);
1910
int posLineEnd = pdoc->LineStart(lineNumber + 1);
1911
int lineCaret = pdoc->LineFromPosition(currentPos);
1912
return llc.Retrieve(lineNumber, lineCaret,
1913
posLineEnd - posLineStart, pdoc->GetStyleClock(),
1914
LinesOnScreen() + 1, pdoc->LinesTotal());
1915
}
1916
1917
/**
1918
* Fill in the LineLayout data for the given line.
1919
* Copy the given @a line and its styles from the document into local arrays.
1920
* Also determine the x position at which each character starts.
1921
*/
1922
void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll, int width) {
1923
if (!ll)
1924
return;
1925
PLATFORM_ASSERT(line < pdoc->LinesTotal());
1926
int posLineStart = pdoc->LineStart(line);
1927
int posLineEnd = pdoc->LineStart(line + 1);
1928
// If the line is very long, limit the treatment to a length that should fit in the viewport
1929
if (posLineEnd > (posLineStart + ll->maxLineLength)) {
1930
posLineEnd = posLineStart + ll->maxLineLength;
1931
}
1932
if (ll->validity == LineLayout::llCheckTextAndStyle) {
1933
int lineLength = posLineEnd - posLineStart;
1934
if (!vstyle.viewEOL) {
1935
int cid = posLineEnd - 1;
1936
while ((cid > posLineStart) && IsEOLChar(pdoc->CharAt(cid))) {
1937
cid--;
1938
lineLength--;
1939
}
1940
}
1941
if (lineLength == ll->numCharsInLine) {
1942
// See if chars, styles, indicators, are all the same
1943
bool allSame = true;
1944
const int styleMask = pdoc->stylingBitsMask;
1945
// Check base line layout
1946
char styleByte = 0;
1947
int numCharsInLine = 0;
1948
while (numCharsInLine < lineLength) {
1949
int charInDoc = numCharsInLine + posLineStart;
1950
char chDoc = pdoc->CharAt(charInDoc);
1951
styleByte = pdoc->StyleAt(charInDoc);
1952
allSame = allSame &&
1953
(ll->styles[numCharsInLine] == static_cast<unsigned char>(styleByte & styleMask));
1954
allSame = allSame &&
1955
(ll->indicators[numCharsInLine] == static_cast<char>(styleByte & ~styleMask));
1956
if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseMixed)
1957
allSame = allSame &&
1958
(ll->chars[numCharsInLine] == chDoc);
1959
else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
1960
allSame = allSame &&
1961
(ll->chars[numCharsInLine] == static_cast<char>(tolower(chDoc)));
1962
else // Style::caseUpper
1963
allSame = allSame &&
1964
(ll->chars[numCharsInLine] == static_cast<char>(toupper(chDoc)));
1965
numCharsInLine++;
1966
}
1967
allSame = allSame && (ll->styles[numCharsInLine] == styleByte); // For eolFilled
1968
if (allSame) {
1969
ll->validity = LineLayout::llPositions;
1970
} else {
1971
ll->validity = LineLayout::llInvalid;
1972
}
1973
} else {
1974
ll->validity = LineLayout::llInvalid;
1975
}
1976
}
1977
if (ll->validity == LineLayout::llInvalid) {
1978
ll->widthLine = LineLayout::wrapWidthInfinite;
1979
ll->lines = 1;
1980
int numCharsInLine = 0;
1981
if (vstyle.edgeState == EDGE_BACKGROUND) {
1982
ll->edgeColumn = pdoc->FindColumn(line, theEdge);
1983
if (ll->edgeColumn >= posLineStart) {
1984
ll->edgeColumn -= posLineStart;
1985
}
1986
} else {
1987
ll->edgeColumn = -1;
1988
}
1989
1990
char styleByte = 0;
1991
int styleMask = pdoc->stylingBitsMask;
1992
ll->styleBitsSet = 0;
1993
// Fill base line layout
1994
for (int charInDoc = posLineStart; charInDoc < posLineEnd; charInDoc++) {
1995
char chDoc = pdoc->CharAt(charInDoc);
1996
styleByte = pdoc->StyleAt(charInDoc);
1997
ll->styleBitsSet |= styleByte;
1998
if (vstyle.viewEOL || (!IsEOLChar(chDoc))) {
1999
ll->chars[numCharsInLine] = chDoc;
2000
ll->styles[numCharsInLine] = static_cast<char>(styleByte & styleMask);
2001
ll->indicators[numCharsInLine] = static_cast<char>(styleByte & ~styleMask);
2002
if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseUpper)
2003
ll->chars[numCharsInLine] = static_cast<char>(toupper(chDoc));
2004
else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
2005
ll->chars[numCharsInLine] = static_cast<char>(tolower(chDoc));
2006
numCharsInLine++;
2007
}
2008
}
2009
ll->xHighlightGuide = 0;
2010
// Extra element at the end of the line to hold end x position and act as
2011
ll->chars[numCharsInLine] = 0; // Also triggers processing in the loops as this is a control character
2012
ll->styles[numCharsInLine] = styleByte; // For eolFilled
2013
ll->indicators[numCharsInLine] = 0;
2014
2015
// Layout the line, determining the position of each character,
2016
// with an extra element at the end for the end of the line.
2017
int startseg = 0; // Start of the current segment, in char. number
2018
int startsegx = 0; // Start of the current segment, in pixels
2019
ll->positions[0] = 0;
2020
unsigned int tabWidth = vstyle.spaceWidth * pdoc->tabInChars;
2021
bool lastSegItalics = false;
2022
Font &ctrlCharsFont = vstyle.styles[STYLE_CONTROLCHAR].font;
2023
2024
int ctrlCharWidth[32] = {0};
2025
bool isControlNext = IsControlCharacter(ll->chars[0]);
2026
for (int charInLine = 0; charInLine < numCharsInLine; charInLine++) {
2027
bool isControl = isControlNext;
2028
isControlNext = IsControlCharacter(ll->chars[charInLine + 1]);
2029
if ((ll->styles[charInLine] != ll->styles[charInLine + 1]) ||
2030
isControl || isControlNext) {
2031
ll->positions[startseg] = 0;
2032
if (vstyle.styles[ll->styles[charInLine]].visible) {
2033
if (isControl) {
2034
if (ll->chars[charInLine] == '\t') {
2035
ll->positions[charInLine + 1] = ((((startsegx + 2) /
2036
tabWidth) + 1) * tabWidth) - startsegx;
2037
} else if (controlCharSymbol < 32) {
2038
if (ctrlCharWidth[ll->chars[charInLine]] == 0) {
2039
const char *ctrlChar = ControlCharacterString(ll->chars[charInLine]);
2040
// +3 For a blank on front and rounded edge each side:
2041
ctrlCharWidth[ll->chars[charInLine]] =
2042
surface->WidthText(ctrlCharsFont, ctrlChar, istrlen(ctrlChar)) + 3;
2043
}
2044
ll->positions[charInLine + 1] = ctrlCharWidth[ll->chars[charInLine]];
2045
} else {
2046
char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
2047
surface->MeasureWidths(ctrlCharsFont, cc, 1,
2048
ll->positions + startseg + 1);
2049
}
2050
lastSegItalics = false;
2051
} else { // Regular character
2052
int lenSeg = charInLine - startseg + 1;
2053
if ((lenSeg == 1) && (' ' == ll->chars[startseg])) {
2054
lastSegItalics = false;
2055
// Over half the segments are single characters and of these about half are space characters.
2056
ll->positions[charInLine + 1] = vstyle.styles[ll->styles[charInLine]].spaceWidth;
2057
} else {
2058
lastSegItalics = vstyle.styles[ll->styles[charInLine]].italic;
2059
surface->MeasureWidths(vstyle.styles[ll->styles[charInLine]].font, ll->chars + startseg,
2060
lenSeg, ll->positions + startseg + 1);
2061
}
2062
}
2063
} else { // invisible
2064
for (int posToZero = startseg; posToZero <= (charInLine + 1); posToZero++) {
2065
ll->positions[posToZero] = 0;
2066
}
2067
}
2068
for (int posToIncrease = startseg; posToIncrease <= (charInLine + 1); posToIncrease++) {
2069
ll->positions[posToIncrease] += startsegx;
2070
}
2071
startsegx = ll->positions[charInLine + 1];
2072
startseg = charInLine + 1;
2073
}
2074
}
2075
// Small hack to make lines that end with italics not cut off the edge of the last character
2076
if ((startseg > 0) && lastSegItalics) {
2077
ll->positions[startseg] += 2;
2078
}
2079
ll->numCharsInLine = numCharsInLine;
2080
ll->validity = LineLayout::llPositions;
2081
}
2082
// Hard to cope when too narrow, so just assume there is space
2083
if (width < 20) {
2084
width = 20;
2085
}
2086
if ((ll->validity == LineLayout::llPositions) || (ll->widthLine != width)) {
2087
ll->widthLine = width;
2088
if (width == LineLayout::wrapWidthInfinite) {
2089
ll->lines = 1;
2090
} else if (width > ll->positions[ll->numCharsInLine]) {
2091
// Simple common case where line does not need wrapping.
2092
ll->lines = 1;
2093
} else {
2094
if (wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
2095
width -= vstyle.aveCharWidth; // take into account the space for end wrap mark
2096
}
2097
ll->lines = 0;
2098
// Calculate line start positions based upon width.
2099
// For now this is simplistic - wraps on byte rather than character and
2100
// in the middle of words. Should search for spaces or style changes.
2101
int lastGoodBreak = 0;
2102
int lastLineStart = 0;
2103
int startOffset = 0;
2104
int p = 0;
2105
while (p < ll->numCharsInLine) {
2106
if ((ll->positions[p + 1] - startOffset) >= width) {
2107
if (lastGoodBreak == lastLineStart) {
2108
// Try moving to start of last character
2109
if (p > 0) {
2110
lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1)
2111
- posLineStart;
2112
}
2113
if (lastGoodBreak == lastLineStart) {
2114
// Ensure at least one character on line.
2115
lastGoodBreak = pdoc->MovePositionOutsideChar(lastGoodBreak + posLineStart + 1, 1)
2116
- posLineStart;
2117
}
2118
}
2119
lastLineStart = lastGoodBreak;
2120
ll->lines++;
2121
ll->SetLineStart(ll->lines, lastGoodBreak);
2122
startOffset = ll->positions[lastGoodBreak];
2123
// take into account the space for start wrap mark and indent
2124
startOffset -= actualWrapVisualStartIndent * vstyle.aveCharWidth;
2125
p = lastGoodBreak + 1;
2126
continue;
2127
}
2128
if (p > 0) {
2129
if (wrapState == eWrapChar){
2130
lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1)
2131
- posLineStart;
2132
p = pdoc->MovePositionOutsideChar(p + 1 + posLineStart, 1) - posLineStart;
2133
continue;
2134
} else if (ll->styles[p] != ll->styles[p - 1]) {
2135
lastGoodBreak = p;
2136
} else if (IsSpaceOrTab(ll->chars[p - 1]) && !IsSpaceOrTab(ll->chars[p])) {
2137
lastGoodBreak = p;
2138
}
2139
}
2140
p++;
2141
}
2142
ll->lines++;
2143
}
2144
ll->validity = LineLayout::llLines;
2145
}
2146
}
2147
2148
ColourAllocated Editor::TextBackground(ViewStyle &vsDraw, bool overrideBackground,
2149
ColourAllocated background, bool inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) {
2150
if (inSelection) {
2151
if (vsDraw.selbackset) {
2152
if (primarySelection)
2153
return vsDraw.selbackground.allocated;
2154
else
2155
return vsDraw.selbackground2.allocated;
2156
}
2157
} else {
2158
if ((vsDraw.edgeState == EDGE_BACKGROUND) &&
2159
(i >= ll->edgeColumn) &&
2160
!IsEOLChar(ll->chars[i]))
2161
return vsDraw.edgecolour.allocated;
2162
if (inHotspot && vsDraw.hotspotBackgroundSet)
2163
return vsDraw.hotspotBackground.allocated;
2164
if (overrideBackground)
2165
return background;
2166
}
2167
return vsDraw.styles[styleMain].back.allocated;
2168
}
2169
2170
void Editor::DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight) {
2171
Point from(0, ((lineVisible & 1) && (lineHeight & 1)) ? 1 : 0);
2172
PRectangle rcCopyArea(start + 1, rcSegment.top, start + 2, rcSegment.bottom);
2173
surface->Copy(rcCopyArea, from,
2174
highlight ? *pixmapIndentGuideHighlight : *pixmapIndentGuide);
2175
}
2176
2177
void Editor::DrawWrapMarker(Surface *surface, PRectangle rcPlace,
2178
bool isEndMarker, ColourAllocated wrapColour) {
2179
surface->PenColour(wrapColour);
2180
2181
enum { xa = 1 }; // gap before start
2182
int w = rcPlace.right - rcPlace.left - xa - 1;
2183
2184
bool xStraight = isEndMarker; // x-mirrored symbol for start marker
2185
bool yStraight = true;
2186
//bool yStraight= isEndMarker; // comment in for start marker y-mirrowed
2187
2188
int x0 = xStraight ? rcPlace.left : rcPlace.right - 1;
2189
int y0 = yStraight ? rcPlace.top : rcPlace.bottom - 1;
2190
2191
int dy = (rcPlace.bottom - rcPlace.top) / 5;
2192
int y = (rcPlace.bottom - rcPlace.top) / 2 + dy;
2193
2194
struct Relative {
2195
Surface *surface;
2196
int xBase;
2197
int xDir;
2198
int yBase;
2199
int yDir;
2200
void MoveTo(int xRelative, int yRelative) {
2201
surface->MoveTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
2202
}
2203
void LineTo(int xRelative, int yRelative) {
2204
surface->LineTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
2205
}
2206
};
2207
Relative rel = {surface, x0, xStraight?1:-1, y0, yStraight?1:-1};
2208
2209
// arrow head
2210
rel.MoveTo(xa, y);
2211
rel.LineTo(xa + 2*w / 3, y - dy);
2212
rel.MoveTo(xa, y);
2213
rel.LineTo(xa + 2*w / 3, y + dy);
2214
2215
// arrow body
2216
rel.MoveTo(xa, y);
2217
rel.LineTo(xa + w, y);
2218
rel.LineTo(xa + w, y - 2 * dy);
2219
rel.LineTo(xa - 1, // on windows lineto is exclusive endpoint, perhaps GTK not...
2220
y - 2 * dy);
2221
}
2222
2223
void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
2224
int line, int lineEnd, int xStart, int subLine, int subLineStart,
2225
bool overrideBackground, ColourAllocated background,
2226
bool drawWrapMarkEnd, ColourAllocated wrapColour) {
2227
2228
int styleMask = pdoc->stylingBitsMask;
2229
PRectangle rcSegment = rcLine;
2230
2231
// Fill in a PRectangle representing the end of line characters
2232
int xEol = ll->positions[lineEnd] - subLineStart;
2233
rcSegment.left = xEol + xStart;
2234
rcSegment.right = xEol + vsDraw.aveCharWidth + xStart;
2235
int posLineEnd = pdoc->LineStart(line + 1);
2236
bool eolInSelection = (subLine == (ll->lines - 1)) &&
2237
(posLineEnd > ll->selStart) && (posLineEnd <= ll->selEnd) && (ll->selStart != ll->selEnd);
2238
2239
if (eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1)) {
2240
if (primarySelection)
2241
surface->FillRectangle(rcSegment, vsDraw.selbackground.allocated);
2242
else
2243
surface->FillRectangle(rcSegment, vsDraw.selbackground2.allocated);
2244
} else if (overrideBackground) {
2245
surface->FillRectangle(rcSegment, background);
2246
} else {
2247
surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated);
2248
}
2249
2250
rcSegment.left = xEol + vsDraw.aveCharWidth + xStart;
2251
rcSegment.right = rcLine.right;
2252
if (overrideBackground) {
2253
surface->FillRectangle(rcSegment, background);
2254
} else if (vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].eolFilled) {
2255
surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated);
2256
} else {
2257
surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back.allocated);
2258
}
2259
2260
if (drawWrapMarkEnd) {
2261
PRectangle rcPlace = rcSegment;
2262
2263
if (wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_END_BY_TEXT) {
2264
rcPlace.left = xEol + xStart;
2265
rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
2266
} else {
2267
// draw left of the right text margin, to avoid clipping by the current clip rect
2268
rcPlace.right = rcLine.right - vs.rightMarginWidth;
2269
rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
2270
}
2271
DrawWrapMarker(surface, rcPlace, true, wrapColour);
2272
}
2273
}
2274
2275
void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,
2276
PRectangle rcLine, LineLayout *ll, int subLine) {
2277
2278
PRectangle rcSegment = rcLine;
2279
2280
// Using one font for all control characters so it can be controlled independently to ensure
2281
// the box goes around the characters tightly. Seems to be no way to work out what height
2282
// is taken by an individual character - internal leading gives varying results.
2283
Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
2284
2285
// See if something overrides the line background color: Either if caret is on the line
2286
// and background color is set for that, or if a marker is defined that forces its background
2287
// color onto the line, or if a marker is defined but has no selection margin in which to
2288
// display itself (as long as it's not an SC_MARK_EMPTY marker). These are checked in order
2289
// with the earlier taking precedence. When multiple markers cause background override,
2290
// the color for the highest numbered one is used.
2291
bool overrideBackground = false;
2292
ColourAllocated background;
2293
if (caret.active && vsDraw.showCaretLineBackground && ll->containsCaret) {
2294
overrideBackground = true;
2295
background = vsDraw.caretLineBackground.allocated;
2296
}
2297
if (!overrideBackground) {
2298
int marks = pdoc->GetMark(line);
2299
for (int markBit = 0; (markBit < 32) && marks; markBit++) {
2300
if ((marks & 1) && vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND) {
2301
background = vsDraw.markers[markBit].back.allocated;
2302
overrideBackground = true;
2303
}
2304
marks >>= 1;
2305
}
2306
}
2307
if (!overrideBackground) {
2308
if (vsDraw.maskInLine) {
2309
int marks = pdoc->GetMark(line) & vsDraw.maskInLine;
2310
if (marks) {
2311
for (int markBit = 0; (markBit < 32) && marks; markBit++) {
2312
if ((marks & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY)) {
2313
overrideBackground = true;
2314
background = vsDraw.markers[markBit].back.allocated;
2315
}
2316
marks >>= 1;
2317
}
2318
}
2319
}
2320
}
2321
2322
bool drawWhitespaceBackground = (vsDraw.viewWhitespace != wsInvisible) &&
2323
(!overrideBackground) && (vsDraw.whitespaceBackgroundSet);
2324
2325
bool inIndentation = subLine == 0; // Do not handle indentation except on first subline.
2326
int indentWidth = pdoc->IndentSize() * vsDraw.spaceWidth;
2327
2328
int posLineStart = pdoc->LineStart(line);
2329
2330
int startseg = ll->LineStart(subLine);
2331
int subLineStart = ll->positions[startseg];
2332
int lineStart = 0;
2333
int lineEnd = 0;
2334
if (subLine < ll->lines) {
2335
lineStart = ll->LineStart(subLine);
2336
lineEnd = ll->LineStart(subLine + 1);
2337
}
2338
2339
bool drawWrapMarkEnd = false;
2340
2341
if (wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
2342
if (subLine + 1 < ll->lines) {
2343
drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0;
2344
}
2345
}
2346
2347
if (actualWrapVisualStartIndent != 0) {
2348
2349
bool continuedWrapLine = false;
2350
if (subLine < ll->lines) {
2351
continuedWrapLine = ll->LineStart(subLine) != 0;
2352
}
2353
2354
if (continuedWrapLine) {
2355
// draw continuation rect
2356
PRectangle rcPlace = rcSegment;
2357
2358
rcPlace.left = ll->positions[startseg] + xStart - subLineStart;
2359
rcPlace.right = rcPlace.left + actualWrapVisualStartIndent * vsDraw.aveCharWidth;
2360
2361
// default bgnd here..
2362
surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back.allocated);
2363
2364
// main line style would be below but this would be inconsistent with end markers
2365
// also would possibly not be the style at wrap point
2366
//int styleMain = ll->styles[lineStart];
2367
//surface->FillRectangle(rcPlace, vsDraw.styles[styleMain].back.allocated);
2368
2369
if (wrapVisualFlags & SC_WRAPVISUALFLAG_START) {
2370
2371
if (wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_START_BY_TEXT)
2372
rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
2373
else
2374
rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
2375
2376
DrawWrapMarker(surface, rcPlace, false, vsDraw.whitespaceForeground.allocated);
2377
}
2378
2379
xStart += actualWrapVisualStartIndent * vsDraw.aveCharWidth;
2380
}
2381
}
2382
2383
int i;
2384
2385
// Background drawing loop
2386
for (i = lineStart; twoPhaseDraw && (i < lineEnd); i++) {
2387
2388
int iDoc = i + posLineStart;
2389
// If there is the end of a style run for any reason
2390
if ((ll->styles[i] != ll->styles[i + 1]) ||
2391
i == (lineEnd - 1) ||
2392
IsControlCharacter(ll->chars[i]) || IsControlCharacter(ll->chars[i + 1]) ||
2393
((ll->selStart != ll->selEnd) && ((iDoc + 1 == ll->selStart) || (iDoc + 1 == ll->selEnd))) ||
2394
(i == (ll->edgeColumn - 1))) {
2395
rcSegment.left = ll->positions[startseg] + xStart - subLineStart;
2396
rcSegment.right = ll->positions[i + 1] + xStart - subLineStart;
2397
// Only try to draw if really visible - enhances performance by not calling environment to
2398
// draw strings that are completely past the right side of the window.
2399
if ((rcSegment.left <= rcLine.right) && (rcSegment.right >= rcLine.left)) {
2400
int styleMain = ll->styles[i];
2401
bool inSelection = (iDoc >= ll->selStart) && (iDoc < ll->selEnd) && (ll->selStart != ll->selEnd);
2402
bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd);
2403
ColourAllocated textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, i, ll);
2404
if (ll->chars[i] == '\t') {
2405
// Tab display
2406
if (drawWhitespaceBackground &&
2407
(!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
2408
textBack = vsDraw.whitespaceBackground.allocated;
2409
surface->FillRectangle(rcSegment, textBack);
2410
} else if (IsControlCharacter(ll->chars[i])) {
2411
// Control character display
2412
inIndentation = false;
2413
surface->FillRectangle(rcSegment, textBack);
2414
} else {
2415
// Normal text display
2416
surface->FillRectangle(rcSegment, textBack);
2417
if (vsDraw.viewWhitespace != wsInvisible ||
2418
(inIndentation && vsDraw.viewIndentationGuides)) {
2419
for (int cpos = 0; cpos <= i - startseg; cpos++) {
2420
if (ll->chars[cpos + startseg] == ' ') {
2421
if (drawWhitespaceBackground &&
2422
(!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
2423
PRectangle rcSpace(ll->positions[cpos + startseg] + xStart, rcSegment.top,
2424
ll->positions[cpos + startseg + 1] + xStart, rcSegment.bottom);
2425
surface->FillRectangle(rcSpace, vsDraw.whitespaceBackground.allocated);
2426
}
2427
} else {
2428
inIndentation = false;
2429
}
2430
}
2431
}
2432
}
2433
} else if (rcSegment.left > rcLine.right) {
2434
break;
2435
}
2436
startseg = i + 1;
2437
}
2438
}
2439
2440
if (twoPhaseDraw) {
2441
DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
2442
xStart, subLine, subLineStart, overrideBackground, background,
2443
drawWrapMarkEnd, vsDraw.whitespaceForeground.allocated);
2444
}
2445
2446
inIndentation = subLine == 0; // Do not handle indentation except on first subline.
2447
startseg = ll->LineStart(subLine);
2448
// Foreground drawing loop
2449
for (i = lineStart; i < lineEnd; i++) {
2450
2451
int iDoc = i + posLineStart;
2452
// If there is the end of a style run for any reason
2453
if ((ll->styles[i] != ll->styles[i + 1]) ||
2454
i == (lineEnd - 1) ||
2455
IsControlCharacter(ll->chars[i]) || IsControlCharacter(ll->chars[i + 1]) ||
2456
((ll->selStart != ll->selEnd) && ((iDoc + 1 == ll->selStart) || (iDoc + 1 == ll->selEnd))) ||
2457
(i == (ll->edgeColumn - 1))) {
2458
rcSegment.left = ll->positions[startseg] + xStart - subLineStart;
2459
rcSegment.right = ll->positions[i + 1] + xStart - subLineStart;
2460
// Only try to draw if really visible - enhances performance by not calling environment to
2461
// draw strings that are completely past the right side of the window.
2462
if ((rcSegment.left <= rcLine.right) && (rcSegment.right >= rcLine.left)) {
2463
int styleMain = ll->styles[i];
2464
ColourAllocated textFore = vsDraw.styles[styleMain].fore.allocated;
2465
Font &textFont = vsDraw.styles[styleMain].font;
2466
//hotspot foreground
2467
if (ll->hsStart != -1 && iDoc >= ll->hsStart && iDoc < hsEnd) {
2468
if (vsDraw.hotspotForegroundSet)
2469
textFore = vsDraw.hotspotForeground.allocated;
2470
}
2471
bool inSelection = (iDoc >= ll->selStart) && (iDoc < ll->selEnd) && (ll->selStart != ll->selEnd);
2472
if (inSelection && (vsDraw.selforeset)) {
2473
textFore = vsDraw.selforeground.allocated;
2474
}
2475
bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd);
2476
ColourAllocated textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, i, ll);
2477
if (ll->chars[i] == '\t') {
2478
// Tab display
2479
if (!twoPhaseDraw) {
2480
if (drawWhitespaceBackground &&
2481
(!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
2482
textBack = vsDraw.whitespaceBackground.allocated;
2483
surface->FillRectangle(rcSegment, textBack);
2484
}
2485
if ((vsDraw.viewWhitespace != wsInvisible) || ((inIndentation && vsDraw.viewIndentationGuides))) {
2486
if (vsDraw.whitespaceForegroundSet)
2487
textFore = vsDraw.whitespaceForeground.allocated;
2488
surface->PenColour(textFore);
2489
}
2490
if (inIndentation && vsDraw.viewIndentationGuides) {
2491
for (int xIG = ll->positions[i] / indentWidth * indentWidth; xIG < ll->positions[i + 1]; xIG += indentWidth) {
2492
if (xIG >= ll->positions[i] && xIG > 0) {
2493
DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIG + xStart, rcSegment,
2494
(ll->xHighlightGuide == xIG));
2495
}
2496
}
2497
}
2498
if (vsDraw.viewWhitespace != wsInvisible) {
2499
if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
2500
PRectangle rcTab(rcSegment.left + 1, rcSegment.top + 4,
2501
rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent);
2502
DrawTabArrow(surface, rcTab, rcSegment.top + vsDraw.lineHeight / 2);
2503
}
2504
}
2505
} else if (IsControlCharacter(ll->chars[i])) {
2506
// Control character display
2507
inIndentation = false;
2508
if (controlCharSymbol < 32) {
2509
// Draw the character
2510
const char *ctrlChar = ControlCharacterString(ll->chars[i]);
2511
if (!twoPhaseDraw) {
2512
surface->FillRectangle(rcSegment, textBack);
2513
}
2514
int normalCharHeight = surface->Ascent(ctrlCharsFont) -
2515
surface->InternalLeading(ctrlCharsFont);
2516
PRectangle rcCChar = rcSegment;
2517
rcCChar.left = rcCChar.left + 1;
2518
rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight;
2519
rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1;
2520
PRectangle rcCentral = rcCChar;
2521
rcCentral.top++;
2522
rcCentral.bottom--;
2523
surface->FillRectangle(rcCentral, textFore);
2524
PRectangle rcChar = rcCChar;
2525
rcChar.left++;
2526
rcChar.right--;
2527
surface->DrawTextClipped(rcChar, ctrlCharsFont,
2528
rcSegment.top + vsDraw.maxAscent, ctrlChar, istrlen(ctrlChar),
2529
textBack, textFore);
2530
} else {
2531
char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
2532
surface->DrawTextNoClip(rcSegment, ctrlCharsFont,
2533
rcSegment.top + vsDraw.maxAscent,
2534
cc, 1, textBack, textFore);
2535
}
2536
} else {
2537
// Normal text display
2538
if (vsDraw.styles[styleMain].visible) {
2539
if (twoPhaseDraw) {
2540
surface->DrawTextTransparent(rcSegment, textFont,
2541
rcSegment.top + vsDraw.maxAscent, ll->chars + startseg,
2542
i - startseg + 1, textFore);
2543
} else {
2544
surface->DrawTextNoClip(rcSegment, textFont,
2545
rcSegment.top + vsDraw.maxAscent, ll->chars + startseg,
2546
i - startseg + 1, textFore, textBack);
2547
}
2548
}
2549
if (vsDraw.viewWhitespace != wsInvisible ||
2550
(inIndentation && vsDraw.viewIndentationGuides)) {
2551
for (int cpos = 0; cpos <= i - startseg; cpos++) {
2552
if (ll->chars[cpos + startseg] == ' ') {
2553
if (vsDraw.viewWhitespace != wsInvisible) {
2554
if (vsDraw.whitespaceForegroundSet)
2555
textFore = vsDraw.whitespaceForeground.allocated;
2556
if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
2557
int xmid = (ll->positions[cpos + startseg] + ll->positions[cpos + startseg + 1]) / 2;
2558
if (!twoPhaseDraw && drawWhitespaceBackground &&
2559
(!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
2560
textBack = vsDraw.whitespaceBackground.allocated;
2561
PRectangle rcSpace(ll->positions[cpos + startseg] + xStart, rcSegment.top, ll->positions[cpos + startseg + 1] + xStart, rcSegment.bottom);
2562
surface->FillRectangle(rcSpace, textBack);
2563
}
2564
PRectangle rcDot(xmid + xStart - subLineStart, rcSegment.top + vsDraw.lineHeight / 2, 0, 0);
2565
rcDot.right = rcDot.left + 1;
2566
rcDot.bottom = rcDot.top + 1;
2567
surface->FillRectangle(rcDot, textFore);
2568
}
2569
}
2570
if (inIndentation && vsDraw.viewIndentationGuides) {
2571
int startSpace = ll->positions[cpos + startseg];
2572
if (startSpace > 0 && (startSpace % indentWidth == 0)) {
2573
DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, startSpace + xStart, rcSegment,
2574
(ll->xHighlightGuide == ll->positions[cpos + startseg]));
2575
}
2576
}
2577
} else {
2578
inIndentation = false;
2579
}
2580
}
2581
}
2582
}
2583
if (ll->hsStart != -1 && vsDraw.hotspotUnderline && iDoc >= ll->hsStart && iDoc < ll->hsEnd ) {
2584
PRectangle rcUL = rcSegment;
2585
rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
2586
rcUL.bottom = rcUL.top + 1;
2587
if (vsDraw.hotspotForegroundSet)
2588
surface->FillRectangle(rcUL, vsDraw.hotspotForeground.allocated);
2589
else
2590
surface->FillRectangle(rcUL, textFore);
2591
} else if (vsDraw.styles[styleMain].underline) {
2592
PRectangle rcUL = rcSegment;
2593
rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
2594
rcUL.bottom = rcUL.top + 1;
2595
surface->FillRectangle(rcUL, textFore);
2596
}
2597
} else if (rcSegment.left > rcLine.right) {
2598
break;
2599
}
2600
startseg = i + 1;
2601
}
2602
}
2603
2604
// Draw indicators
2605
// foreach indicator...
2606
for (int indicnum = 0, mask = 1 << pdoc->stylingBits; mask < 0x100; indicnum++) {
2607
if (!(mask & ll->styleBitsSet)) {
2608
mask <<= 1;
2609
continue;
2610
}
2611
int startPos = -1;
2612
// foreach style pos in line...
2613
for (int indicPos = lineStart; indicPos <= lineEnd; indicPos++) {
2614
// look for starts...
2615
if (startPos < 0) {
2616
// NOT in indicator run, looking for START
2617
if (indicPos < lineEnd && (ll->indicators[indicPos] & mask))
2618
startPos = indicPos;
2619
}
2620
// ... or ends
2621
if (startPos >= 0) {
2622
// IN indicator run, looking for END
2623
if (indicPos >= lineEnd || !(ll->indicators[indicPos] & mask)) {
2624
// AT end of indicator run, DRAW it!
2625
PRectangle rcIndic(
2626
ll->positions[startPos] + xStart - subLineStart,
2627
rcLine.top + vsDraw.maxAscent,
2628
ll->positions[indicPos] + xStart - subLineStart,
2629
rcLine.top + vsDraw.maxAscent + 3);
2630
vsDraw.indicators[indicnum].Draw(surface, rcIndic, rcLine);
2631
// RESET control var
2632
startPos = -1;
2633
}
2634
}
2635
}
2636
mask <<= 1;
2637
}
2638
// End of the drawing of the current line
2639
if (!twoPhaseDraw) {
2640
DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
2641
xStart, subLine, subLineStart, overrideBackground, background,
2642
drawWrapMarkEnd, vsDraw.whitespaceForeground.allocated);
2643
}
2644
2645
if (vsDraw.edgeState == EDGE_LINE) {
2646
int edgeX = theEdge * vsDraw.spaceWidth;
2647
rcSegment.left = edgeX + xStart;
2648
rcSegment.right = rcSegment.left + 1;
2649
surface->FillRectangle(rcSegment, vsDraw.edgecolour.allocated);
2650
}
2651
}
2652
2653
void Editor::RefreshPixMaps(Surface *surfaceWindow) {
2654
if (!pixmapSelPattern->Initialised()) {
2655
const int patternSize = 8;
2656
pixmapSelPattern->InitPixMap(patternSize, patternSize, surfaceWindow, wMain.GetID());
2657
// This complex procedure is to reproduce the checkerboard dithered pattern used by windows
2658
// for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half
2659
// way between the chrome colour and the chrome highlight colour making a nice transition
2660
// between the window chrome and the content area. And it works in low colour depths.
2661
PRectangle rcPattern(0, 0, patternSize, patternSize);
2662
2663
// Initialize default colours based on the chrome colour scheme. Typically the highlight is white.
2664
ColourAllocated colourFMFill = vs.selbar.allocated;
2665
ColourAllocated colourFMStripes = vs.selbarlight.allocated;
2666
2667
if (!(vs.selbarlight.desired == ColourDesired(0xff, 0xff, 0xff))) {
2668
// User has chosen an unusual chrome colour scheme so just use the highlight edge colour.
2669
// (Typically, the highlight colour is white.)
2670
colourFMFill = vs.selbarlight.allocated;
2671
}
2672
2673
if (vs.foldmarginColourSet) {
2674
// override default fold margin colour
2675
colourFMFill = vs.foldmarginColour.allocated;
2676
}
2677
if (vs.foldmarginHighlightColourSet) {
2678
// override default fold margin highlight colour
2679
colourFMStripes = vs.foldmarginHighlightColour.allocated;
2680
}
2681
2682
pixmapSelPattern->FillRectangle(rcPattern, colourFMFill);
2683
pixmapSelPattern->PenColour(colourFMStripes);
2684
for (int stripe = 0; stripe < patternSize; stripe++) {
2685
// Alternating 1 pixel stripes is same as checkerboard.
2686
pixmapSelPattern->MoveTo(0, stripe * 2);
2687
pixmapSelPattern->LineTo(patternSize, stripe * 2 - patternSize);
2688
}
2689
}
2690
2691
if (!pixmapIndentGuide->Initialised()) {
2692
// 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
2693
pixmapIndentGuide->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID());
2694
pixmapIndentGuideHighlight->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID());
2695
PRectangle rcIG(0, 0, 1, vs.lineHeight);
2696
pixmapIndentGuide->FillRectangle(rcIG, vs.styles[STYLE_INDENTGUIDE].back.allocated);
2697
pixmapIndentGuide->PenColour(vs.styles[STYLE_INDENTGUIDE].fore.allocated);
2698
pixmapIndentGuideHighlight->FillRectangle(rcIG, vs.styles[STYLE_BRACELIGHT].back.allocated);
2699
pixmapIndentGuideHighlight->PenColour(vs.styles[STYLE_BRACELIGHT].fore.allocated);
2700
for (int stripe = 1; stripe < vs.lineHeight + 1; stripe += 2) {
2701
pixmapIndentGuide->MoveTo(0, stripe);
2702
pixmapIndentGuide->LineTo(2, stripe);
2703
pixmapIndentGuideHighlight->MoveTo(0, stripe);
2704
pixmapIndentGuideHighlight->LineTo(2, stripe);
2705
}
2706
}
2707
2708
if (bufferedDraw) {
2709
if (!pixmapLine->Initialised()) {
2710
PRectangle rcClient = GetClientRectangle();
2711
pixmapLine->InitPixMap(rcClient.Width(), vs.lineHeight,
2712
surfaceWindow, wMain.GetID());
2713
pixmapSelMargin->InitPixMap(vs.fixedColumnWidth,
2714
rcClient.Height(), surfaceWindow, wMain.GetID());
2715
}
2716
}
2717
}
2718
2719
void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
2720
//Platform::DebugPrintf("Paint:%1d (%3d,%3d) ... (%3d,%3d)\n",
2721
// paintingAllText, rcArea.left, rcArea.top, rcArea.right, rcArea.bottom);
2722
2723
RefreshStyleData();
2724
2725
RefreshPixMaps(surfaceWindow);
2726
2727
PRectangle rcClient = GetClientRectangle();
2728
//Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d) %d\n",
2729
// rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
2730
2731
surfaceWindow->SetPalette(&palette, true);
2732
pixmapLine->SetPalette(&palette, !hasFocus);
2733
2734
int screenLinePaintFirst = rcArea.top / vs.lineHeight;
2735
// The area to be painted plus one extra line is styled.
2736
// The extra line is to determine when a style change, such as starting a comment flows on to other lines.
2737
int lineStyleLast = topLine + (rcArea.bottom - 1) / vs.lineHeight + 1;
2738
//Platform::DebugPrintf("Paint lines = %d .. %d\n", topLine + screenLinePaintFirst, lineStyleLast);
2739
int endPosPaint = pdoc->Length();
2740
if (lineStyleLast < cs.LinesDisplayed())
2741
endPosPaint = pdoc->LineStart(cs.DocFromDisplay(lineStyleLast + 1));
2742
2743
int xStart = vs.fixedColumnWidth - xOffset;
2744
int ypos = 0;
2745
if (!bufferedDraw)
2746
ypos += screenLinePaintFirst * vs.lineHeight;
2747
int yposScreen = screenLinePaintFirst * vs.lineHeight;
2748
2749
// Ensure we are styled as far as we are painting.
2750
pdoc->EnsureStyledTo(endPosPaint);
2751
bool paintAbandonedByStyling = paintState == paintAbandoned;
2752
if (needUpdateUI) {
2753
NotifyUpdateUI();
2754
needUpdateUI = false;
2755
}
2756
2757
// Call priority lines wrap on a window of lines which are likely
2758
// to rendered with the following paint (that is wrap the visible
2759
// lines first).
2760
int startLineToWrap = cs.DocFromDisplay(topLine) - 5;
2761
if (startLineToWrap < 0)
2762
startLineToWrap = -1;
2763
if (WrapLines(false, startLineToWrap)) {
2764
// The wrapping process has changed the height of some lines so
2765
// abandon this paint for a complete repaint.
2766
if (AbandonPaint()) {
2767
return;
2768
}
2769
RefreshPixMaps(surfaceWindow); // In case pixmaps invalidated by scrollbar change
2770
}
2771
PLATFORM_ASSERT(pixmapSelPattern->Initialised());
2772
2773
PaintSelMargin(surfaceWindow, rcArea);
2774
2775
PRectangle rcRightMargin = rcClient;
2776
rcRightMargin.left = rcRightMargin.right - vs.rightMarginWidth;
2777
if (rcArea.Intersects(rcRightMargin)) {
2778
surfaceWindow->FillRectangle(rcRightMargin, vs.styles[STYLE_DEFAULT].back.allocated);
2779
}
2780
2781
if (paintState == paintAbandoned) {
2782
// Either styling or NotifyUpdateUI noticed that painting is needed
2783
// outside the current painting rectangle
2784
//Platform::DebugPrintf("Abandoning paint\n");
2785
if (wrapState != eWrapNone) {
2786
if (paintAbandonedByStyling) {
2787
// Styling has spilled over a line end, such as occurs by starting a multiline
2788
// comment. The width of subsequent text may have changed, so rewrap.
2789
NeedWrapping(cs.DocFromDisplay(topLine));
2790
}
2791
}
2792
return;
2793
}
2794
//Platform::DebugPrintf("start display %d, offset = %d\n", pdoc->Length(), xOffset);
2795
2796
// Do the painting
2797
if (rcArea.right > vs.fixedColumnWidth) {
2798
2799
Surface *surface = surfaceWindow;
2800
if (bufferedDraw) {
2801
surface = pixmapLine;
2802
PLATFORM_ASSERT(pixmapLine->Initialised());
2803
}
2804
surface->SetUnicodeMode(IsUnicodeMode());
2805
surface->SetDBCSMode(CodePage());
2806
2807
int visibleLine = topLine + screenLinePaintFirst;
2808
2809
int posCaret = currentPos;
2810
if (posDrag >= 0)
2811
posCaret = posDrag;
2812
int lineCaret = pdoc->LineFromPosition(posCaret);
2813
2814
// Remove selection margin from drawing area so text will not be drawn
2815
// on it in unbuffered mode.
2816
PRectangle rcTextArea = rcClient;
2817
rcTextArea.left = vs.fixedColumnWidth;
2818
rcTextArea.right -= vs.rightMarginWidth;
2819
surfaceWindow->SetClip(rcTextArea);
2820
2821
// Loop on visible lines
2822
//double durLayout = 0.0;
2823
//double durPaint = 0.0;
2824
//double durCopy = 0.0;
2825
//ElapsedTime etWhole;
2826
int lineDocPrevious = -1; // Used to avoid laying out one document line multiple times
2827
AutoLineLayout ll(llc, 0);
2828
SelectionLineIterator lineIterator(this);
2829
while (visibleLine < cs.LinesDisplayed() && yposScreen < rcArea.bottom) {
2830
2831
int lineDoc = cs.DocFromDisplay(visibleLine);
2832
// Only visible lines should be handled by the code within the loop
2833
PLATFORM_ASSERT(cs.GetVisible(lineDoc));
2834
int lineStartSet = cs.DisplayFromDoc(lineDoc);
2835
int subLine = visibleLine - lineStartSet;
2836
2837
// Copy this line and its styles from the document into local arrays
2838
// and determine the x position at which each character starts.
2839
//ElapsedTime et;
2840
if (lineDoc != lineDocPrevious) {
2841
ll.Set(0);
2842
// For rectangular selection this accesses the layout cache so should be after layout returned.
2843
lineIterator.SetAt(lineDoc);
2844
ll.Set(RetrieveLineLayout(lineDoc));
2845
LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
2846
lineDocPrevious = lineDoc;
2847
}
2848
//durLayout += et.Duration(true);
2849
2850
if (ll) {
2851
if (selType == selStream) {
2852
ll->selStart = SelectionStart();
2853
ll->selEnd = SelectionEnd();
2854
} else {
2855
ll->selStart = lineIterator.startPos;
2856
ll->selEnd = lineIterator.endPos;
2857
}
2858
ll->containsCaret = lineDoc == lineCaret;
2859
if (hideSelection) {
2860
ll->selStart = -1;
2861
ll->selEnd = -1;
2862
ll->containsCaret = false;
2863
}
2864
2865
GetHotSpotRange(ll->hsStart, ll->hsEnd);
2866
2867
PRectangle rcLine = rcClient;
2868
rcLine.top = ypos;
2869
rcLine.bottom = ypos + vs.lineHeight;
2870
2871
Range rangeLine(pdoc->LineStart(lineDoc), pdoc->LineStart(lineDoc + 1));
2872
// Highlight the current braces if any
2873
ll->SetBracesHighlight(rangeLine, braces, static_cast<char>(bracesMatchStyle),
2874
highlightGuideColumn * vs.spaceWidth);
2875
2876
// Draw the line
2877
DrawLine(surface, vs, lineDoc, visibleLine, xStart, rcLine, ll, subLine);
2878
//durPaint += et.Duration(true);
2879
2880
// Restore the previous styles for the brace highlights in case layout is in cache.
2881
ll->RestoreBracesHighlight(rangeLine, braces);
2882
2883
bool expanded = cs.GetExpanded(lineDoc);
2884
if ((foldFlags & SC_FOLDFLAG_BOX) == 0) {
2885
// Paint the line above the fold
2886
if ((expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_EXPANDED))
2887
||
2888
(!expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_CONTRACTED))) {
2889
if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) {
2890
PRectangle rcFoldLine = rcLine;
2891
rcFoldLine.bottom = rcFoldLine.top + 1;
2892
surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
2893
}
2894
}
2895
// Paint the line below the fold
2896
if ((expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_EXPANDED))
2897
||
2898
(!expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) {
2899
if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) {
2900
PRectangle rcFoldLine = rcLine;
2901
rcFoldLine.top = rcFoldLine.bottom - 1;
2902
surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
2903
}
2904
}
2905
} else {
2906
int FoldLevelCurr = (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELNUMBERMASK) - SC_FOLDLEVELBASE;
2907
int FoldLevelPrev = (pdoc->GetLevel(lineDoc - 1) & SC_FOLDLEVELNUMBERMASK) - SC_FOLDLEVELBASE;
2908
int FoldLevelFlags = (pdoc->GetLevel(lineDoc) & ~SC_FOLDLEVELNUMBERMASK) & ~(0xFFF0000);
2909
int indentationStep = pdoc->IndentSize();
2910
// Draw line above fold
2911
if ((FoldLevelPrev < FoldLevelCurr)
2912
||
2913
(FoldLevelFlags & SC_FOLDLEVELBOXHEADERFLAG
2914
&&
2915
(pdoc->GetLevel(lineDoc - 1) & SC_FOLDLEVELBOXFOOTERFLAG) == 0)) {
2916
PRectangle rcFoldLine = rcLine;
2917
rcFoldLine.bottom = rcFoldLine.top + 1;
2918
rcFoldLine.left += xStart + FoldLevelCurr * vs.spaceWidth * indentationStep - 1;
2919
surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
2920
}
2921
2922
// Line below the fold (or below a contracted fold)
2923
if (FoldLevelFlags & SC_FOLDLEVELBOXFOOTERFLAG
2924
||
2925
(!expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) {
2926
PRectangle rcFoldLine = rcLine;
2927
rcFoldLine.top = rcFoldLine.bottom - 1;
2928
rcFoldLine.left += xStart + (FoldLevelCurr) * vs.spaceWidth * indentationStep - 1;
2929
surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
2930
}
2931
2932
PRectangle rcBoxLine = rcLine;
2933
// Draw vertical line for every fold level
2934
for (int i = 0; i <= FoldLevelCurr; i++) {
2935
rcBoxLine.left = xStart + i * vs.spaceWidth * indentationStep - 1;
2936
rcBoxLine.right = rcBoxLine.left + 1;
2937
surface->FillRectangle(rcBoxLine, vs.styles[STYLE_DEFAULT].fore.allocated);
2938
}
2939
}
2940
2941
// Draw the Caret
2942
if (lineDoc == lineCaret) {
2943
int offset = Platform::Minimum(posCaret - rangeLine.start, ll->maxLineLength);
2944
if ((offset >= ll->LineStart(subLine)) &&
2945
((offset < ll->LineStart(subLine + 1)) || offset == ll->numCharsInLine)) {
2946
int xposCaret = ll->positions[offset] - ll->positions[ll->LineStart(subLine)] + xStart;
2947
2948
if (actualWrapVisualStartIndent != 0) {
2949
int lineStart = ll->LineStart(subLine);
2950
if (lineStart != 0) // Wrapped
2951
xposCaret += actualWrapVisualStartIndent * vs.aveCharWidth;
2952
}
2953
int widthOverstrikeCaret;
2954
if (posCaret == pdoc->Length()) { // At end of document
2955
widthOverstrikeCaret = vs.aveCharWidth;
2956
} else if ((posCaret - rangeLine.start) >= ll->numCharsInLine) { // At end of line
2957
widthOverstrikeCaret = vs.aveCharWidth;
2958
} else {
2959
widthOverstrikeCaret = ll->positions[offset + 1] - ll->positions[offset];
2960
}
2961
if (widthOverstrikeCaret < 3) // Make sure its visible
2962
widthOverstrikeCaret = 3;
2963
if (((caret.active && caret.on) || (posDrag >= 0)) && xposCaret >= 0) {
2964
PRectangle rcCaret = rcLine;
2965
int caretWidthOffset = 0;
2966
if ((offset > 0) && (vs.caretWidth > 1))
2967
caretWidthOffset = 1; // Move back so overlaps both character cells.
2968
if (posDrag >= 0) {
2969
rcCaret.left = xposCaret - caretWidthOffset;
2970
rcCaret.right = rcCaret.left + vs.caretWidth;
2971
} else {
2972
if (inOverstrike) {
2973
rcCaret.top = rcCaret.bottom - 2;
2974
rcCaret.left = xposCaret + 1;
2975
rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1;
2976
} else {
2977
rcCaret.left = xposCaret - caretWidthOffset;
2978
rcCaret.right = rcCaret.left + vs.caretWidth;
2979
}
2980
}
2981
surface->FillRectangle(rcCaret, vs.caretcolour.allocated);
2982
}
2983
}
2984
}
2985
2986
if (bufferedDraw) {
2987
Point from(vs.fixedColumnWidth, 0);
2988
PRectangle rcCopyArea(vs.fixedColumnWidth, yposScreen,
2989
rcClient.right, yposScreen + vs.lineHeight);
2990
surfaceWindow->Copy(rcCopyArea, from, *pixmapLine);
2991
}
2992
//durCopy += et.Duration(true);
2993
}
2994
2995
if (!bufferedDraw) {
2996
ypos += vs.lineHeight;
2997
}
2998
2999
yposScreen += vs.lineHeight;
3000
visibleLine++;
3001
//gdk_flush();
3002
}
3003
ll.Set(0);
3004
//if (durPaint < 0.00000001)
3005
// durPaint = 0.00000001;
3006
3007
// Right column limit indicator
3008
PRectangle rcBeyondEOF = rcClient;
3009
rcBeyondEOF.left = vs.fixedColumnWidth;
3010
rcBeyondEOF.right = rcBeyondEOF.right;
3011
rcBeyondEOF.top = (cs.LinesDisplayed() - topLine) * vs.lineHeight;
3012
if (rcBeyondEOF.top < rcBeyondEOF.bottom) {
3013
surfaceWindow->FillRectangle(rcBeyondEOF, vs.styles[STYLE_DEFAULT].back.allocated);
3014
if (vs.edgeState == EDGE_LINE) {
3015
int edgeX = theEdge * vs.spaceWidth;
3016
rcBeyondEOF.left = edgeX + xStart;
3017
rcBeyondEOF.right = rcBeyondEOF.left + 1;
3018
surfaceWindow->FillRectangle(rcBeyondEOF, vs.edgecolour.allocated);
3019
}
3020
}
3021
//Platform::DebugPrintf(
3022
//"Layout:%9.6g Paint:%9.6g Ratio:%9.6g Copy:%9.6g Total:%9.6g\n",
3023
//durLayout, durPaint, durLayout / durPaint, durCopy, etWhole.Duration());
3024
NotifyPainted();
3025
}
3026
}
3027
3028
// Space (3 space characters) between line numbers and text when printing.
3029
#define lineNumberPrintSpace " "
3030
3031
ColourDesired InvertedLight(ColourDesired orig) {
3032
unsigned int r = orig.GetRed();
3033
unsigned int g = orig.GetGreen();
3034
unsigned int b = orig.GetBlue();
3035
unsigned int l = (r + g + b) / 3; // There is a better calculation for this that matches human eye
3036
unsigned int il = 0xff - l;
3037
if (l == 0)
3038
return ColourDesired(0xff, 0xff, 0xff);
3039
r = r * il / l;
3040
g = g * il / l;
3041
b = b * il / l;
3042
return ColourDesired(Platform::Minimum(r, 0xff), Platform::Minimum(g, 0xff), Platform::Minimum(b, 0xff));
3043
}
3044
3045
// This is mostly copied from the Paint method but with some things omitted
3046
// such as the margin markers, line numbers, selection and caret
3047
// Should be merged back into a combined Draw method.
3048
long Editor::FormatRange(bool draw, RangeToFormat *pfr) {
3049
if (!pfr)
3050
return 0;
3051
3052
AutoSurface surface(pfr->hdc, this);
3053
if (!surface)
3054
return 0;
3055
AutoSurface surfaceMeasure(pfr->hdcTarget, this);
3056
if (!surfaceMeasure) {
3057
return 0;
3058
}
3059
3060
ViewStyle vsPrint(vs);
3061
3062
// Modify the view style for printing as do not normally want any of the transient features to be printed
3063
// Printing supports only the line number margin.
3064
int lineNumberIndex = -1;
3065
for (int margin = 0; margin < ViewStyle::margins; margin++) {
3066
if ((!vsPrint.ms[margin].symbol) && (vsPrint.ms[margin].width > 0)) {
3067
lineNumberIndex = margin;
3068
} else {
3069
vsPrint.ms[margin].width = 0;
3070
}
3071
}
3072
vsPrint.showMarkedLines = false;
3073
vsPrint.fixedColumnWidth = 0;
3074
vsPrint.zoomLevel = printMagnification;
3075
vsPrint.viewIndentationGuides = false;
3076
// Don't show the selection when printing
3077
vsPrint.selbackset = false;
3078
vsPrint.selforeset = false;
3079
vsPrint.whitespaceBackgroundSet = false;
3080
vsPrint.whitespaceForegroundSet = false;
3081
vsPrint.showCaretLineBackground = false;
3082
3083
// Set colours for printing according to users settings
3084
for (int sty = 0;sty <= STYLE_MAX;sty++) {
3085
if (printColourMode == SC_PRINT_INVERTLIGHT) {
3086
vsPrint.styles[sty].fore.desired = InvertedLight(vsPrint.styles[sty].fore.desired);
3087
vsPrint.styles[sty].back.desired = InvertedLight(vsPrint.styles[sty].back.desired);
3088
} else if (printColourMode == SC_PRINT_BLACKONWHITE) {
3089
vsPrint.styles[sty].fore.desired = ColourDesired(0, 0, 0);
3090
vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
3091
} else if (printColourMode == SC_PRINT_COLOURONWHITE) {
3092
vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
3093
} else if (printColourMode == SC_PRINT_COLOURONWHITEDEFAULTBG) {
3094
if (sty <= STYLE_DEFAULT) {
3095
vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
3096
}
3097
}
3098
}
3099
// White background for the line numbers
3100
vsPrint.styles[STYLE_LINENUMBER].back.desired = ColourDesired(0xff, 0xff, 0xff);
3101
3102
vsPrint.Refresh(*surfaceMeasure);
3103
// Ensure colours are set up
3104
vsPrint.RefreshColourPalette(palette, true);
3105
vsPrint.RefreshColourPalette(palette, false);
3106
// Determining width must hapen after fonts have been realised in Refresh
3107
int lineNumberWidth = 0;
3108
if (lineNumberIndex >= 0) {
3109
lineNumberWidth = surfaceMeasure->WidthText(vsPrint.styles[STYLE_LINENUMBER].font,
3110
"99999" lineNumberPrintSpace, 5 + istrlen(lineNumberPrintSpace));
3111
vsPrint.ms[lineNumberIndex].width = lineNumberWidth;
3112
}
3113
3114
int linePrintStart = pdoc->LineFromPosition(pfr->chrg.cpMin);
3115
int linePrintLast = linePrintStart + (pfr->rc.bottom - pfr->rc.top) / vsPrint.lineHeight - 1;
3116
if (linePrintLast < linePrintStart)
3117
linePrintLast = linePrintStart;
3118
int linePrintMax = pdoc->LineFromPosition(pfr->chrg.cpMax);
3119
if (linePrintLast > linePrintMax)
3120
linePrintLast = linePrintMax;
3121
//Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n",
3122
// linePrintStart, linePrintLast, linePrintMax, pfr->rc.top, pfr->rc.bottom, vsPrint.lineHeight,
3123
// surfaceMeasure->Height(vsPrint.styles[STYLE_LINENUMBER].font));
3124
int endPosPrint = pdoc->Length();
3125
if (linePrintLast < pdoc->LinesTotal())
3126
endPosPrint = pdoc->LineStart(linePrintLast + 1);
3127
3128
// Ensure we are styled to where we are formatting.
3129
pdoc->EnsureStyledTo(endPosPrint);
3130
3131
int xStart = vsPrint.fixedColumnWidth + pfr->rc.left + lineNumberWidth;
3132
int ypos = pfr->rc.top;
3133
3134
int lineDoc = linePrintStart;
3135
3136
int nPrintPos = pfr->chrg.cpMin;
3137
int visibleLine = 0;
3138
int widthPrint = pfr->rc.Width() - lineNumberWidth;
3139
if (printWrapState == eWrapNone)
3140
widthPrint = LineLayout::wrapWidthInfinite;
3141
3142
while (lineDoc <= linePrintLast && ypos < pfr->rc.bottom) {
3143
3144
// When printing, the hdc and hdcTarget may be the same, so
3145
// changing the state of surfaceMeasure may change the underlying
3146
// state of surface. Therefore, any cached state is discarded before
3147
// using each surface.
3148
surfaceMeasure->FlushCachedState();
3149
3150
// Copy this line and its styles from the document into local arrays
3151
// and determine the x position at which each character starts.
3152
LineLayout ll(8000);
3153
LayoutLine(lineDoc, surfaceMeasure, vsPrint, &ll, widthPrint);
3154
3155
ll.selStart = -1;
3156
ll.selEnd = -1;
3157
ll.containsCaret = false;
3158
3159
PRectangle rcLine;
3160
rcLine.left = pfr->rc.left + lineNumberWidth;
3161
rcLine.top = ypos;
3162
rcLine.right = pfr->rc.right - 1;
3163
rcLine.bottom = ypos + vsPrint.lineHeight;
3164
3165
// When document line is wrapped over multiple display lines, find where
3166
// to start printing from to ensure a particular position is on the first
3167
// line of the page.
3168
if (visibleLine == 0) {
3169
int startWithinLine = nPrintPos - pdoc->LineStart(lineDoc);
3170
for (int iwl = 0; iwl < ll.lines - 1; iwl++) {
3171
if (ll.LineStart(iwl) <= startWithinLine && ll.LineStart(iwl + 1) >= startWithinLine) {
3172
visibleLine = -iwl;
3173
}
3174
}
3175
3176
if (ll.lines > 1 && startWithinLine >= ll.LineStart(ll.lines - 1)) {
3177
visibleLine = -(ll.lines - 1);
3178
}
3179
}
3180
3181
if (draw && lineNumberWidth &&
3182
(ypos + vsPrint.lineHeight <= pfr->rc.bottom) &&
3183
(visibleLine >= 0)) {
3184
char number[100];
3185
sprintf(number, "%d" lineNumberPrintSpace, lineDoc + 1);
3186
PRectangle rcNumber = rcLine;
3187
rcNumber.right = rcNumber.left + lineNumberWidth;
3188
// Right justify
3189
rcNumber.left -= surfaceMeasure->WidthText(
3190
vsPrint.styles[STYLE_LINENUMBER].font, number, istrlen(number));
3191
surface->FlushCachedState();
3192
surface->DrawTextNoClip(rcNumber, vsPrint.styles[STYLE_LINENUMBER].font,
3193
ypos + vsPrint.maxAscent, number, istrlen(number),
3194
vsPrint.styles[STYLE_LINENUMBER].fore.allocated,
3195
vsPrint.styles[STYLE_LINENUMBER].back.allocated);
3196
}
3197
3198
// Draw the line
3199
surface->FlushCachedState();
3200
3201
for (int iwl = 0; iwl < ll.lines; iwl++) {
3202
if (ypos + vsPrint.lineHeight <= pfr->rc.bottom) {
3203
if (visibleLine >= 0) {
3204
if (draw) {
3205
rcLine.top = ypos;
3206
rcLine.bottom = ypos + vsPrint.lineHeight;
3207
DrawLine(surface, vsPrint, lineDoc, visibleLine, xStart, rcLine, &ll, iwl);
3208
}
3209
ypos += vsPrint.lineHeight;
3210
}
3211
visibleLine++;
3212
if (iwl == ll.lines - 1)
3213
nPrintPos = pdoc->LineStart(lineDoc + 1);
3214
else
3215
nPrintPos += ll.LineStart(iwl + 1) - ll.LineStart(iwl);
3216
}
3217
}
3218
3219
++lineDoc;
3220
}
3221
3222
return nPrintPos;
3223
}
3224
3225
int Editor::TextWidth(int style, const char *text) {
3226
RefreshStyleData();
3227
AutoSurface surface(this);
3228
if (surface) {
3229
return surface->WidthText(vs.styles[style].font, text, istrlen(text));
3230
} else {
3231
return 1;
3232
}
3233
}
3234
3235
// Empty method is overridden on GTK+ to show / hide scrollbars
3236
void Editor::ReconfigureScrollBars() {}
3237
3238
void Editor::SetScrollBars() {
3239
RefreshStyleData();
3240
3241
int nMax = MaxScrollPos();
3242
int nPage = LinesOnScreen();
3243
bool modified = ModifyScrollBars(nMax + nPage - 1, nPage);
3244
if (modified) {
3245
DwellEnd(true);
3246
}
3247
3248
// TODO: ensure always showing as many lines as possible
3249
// May not be, if, for example, window made larger
3250
if (topLine > MaxScrollPos()) {
3251
SetTopLine(Platform::Clamp(topLine, 0, MaxScrollPos()));
3252
SetVerticalScrollPos();
3253
Redraw();
3254
}
3255
if (modified) {
3256
if (!AbandonPaint())
3257
Redraw();
3258
}
3259
//Platform::DebugPrintf("end max = %d page = %d\n", nMax, nPage);
3260
}
3261
3262
void Editor::ChangeSize() {
3263
DropGraphics();
3264
SetScrollBars();
3265
if (wrapState != eWrapNone) {
3266
PRectangle rcTextArea = GetClientRectangle();
3267
rcTextArea.left = vs.fixedColumnWidth;
3268
rcTextArea.right -= vs.rightMarginWidth;
3269
if (wrapWidth != rcTextArea.Width()) {
3270
NeedWrapping();
3271
Redraw();
3272
}
3273
}
3274
}
3275
3276
void Editor::AddChar(char ch) {
3277
char s[2];
3278
s[0] = ch;
3279
s[1] = '\0';
3280
AddCharUTF(s, 1);
3281
}
3282
3283
void Editor::AddCharUTF(char *s, unsigned int len, bool treatAsDBCS) {
3284
bool wasSelection = currentPos != anchor;
3285
ClearSelection();
3286
bool charReplaceAction = false;
3287
if (inOverstrike && !wasSelection && !RangeContainsProtected(currentPos, currentPos + 1)) {
3288
if (currentPos < (pdoc->Length())) {
3289
if (!IsEOLChar(pdoc->CharAt(currentPos))) {
3290
charReplaceAction = true;
3291
pdoc->BeginUndoAction();
3292
pdoc->DelChar(currentPos);
3293
}
3294
}
3295
}
3296
if (pdoc->InsertString(currentPos, s, len)) {
3297
SetEmptySelection(currentPos + len);
3298
}
3299
if (charReplaceAction) {
3300
pdoc->EndUndoAction();
3301
}
3302
EnsureCaretVisible();
3303
// Avoid blinking during rapid typing:
3304
ShowCaretAtCurrentPosition();
3305
if (!caretSticky) {
3306
SetLastXChosen();
3307
}
3308
3309
if (treatAsDBCS) {
3310
NotifyChar((static_cast<unsigned char>(s[0]) << 8) |
3311
static_cast<unsigned char>(s[1]));
3312
} else {
3313
int byte = static_cast<unsigned char>(s[0]);
3314
if ((byte < 0xC0) || (1 == len)) {
3315
// Handles UTF-8 characters between 0x01 and 0x7F and single byte
3316
// characters when not in UTF-8 mode.
3317
// Also treats \0 and naked trail bytes 0x80 to 0xBF as valid
3318
// characters representing themselves.
3319
} else {
3320
// Unroll 1 to 3 byte UTF-8 sequences. See reference data at:
3321
// http://www.cl.cam.ac.uk/~mgk25/unicode.html
3322
// http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
3323
if (byte < 0xE0) {
3324
int byte2 = static_cast<unsigned char>(s[1]);
3325
if ((byte2 & 0xC0) == 0x80) {
3326
// Two-byte-character lead-byte followed by a trail-byte.
3327
byte = (((byte & 0x1F) << 6) | (byte2 & 0x3F));
3328
}
3329
// A two-byte-character lead-byte not followed by trail-byte
3330
// represents itself.
3331
} else if (byte < 0xF0) {
3332
int byte2 = static_cast<unsigned char>(s[1]);
3333
int byte3 = static_cast<unsigned char>(s[2]);
3334
if (((byte2 & 0xC0) == 0x80) && ((byte3 & 0xC0) == 0x80)) {
3335
// Three-byte-character lead byte followed by two trail bytes.
3336
byte = (((byte & 0x0F) << 12) | ((byte2 & 0x3F) << 6) |
3337
(byte3 & 0x3F));
3338
}
3339
// A three-byte-character lead-byte not followed by two trail-bytes
3340
// represents itself.
3341
}
3342
}
3343
NotifyChar(byte);
3344
}
3345
}
3346
3347
void Editor::ClearSelection() {
3348
if (!SelectionContainsProtected()) {
3349
int startPos = SelectionStart();
3350
if (selType == selStream) {
3351
unsigned int chars = SelectionEnd() - startPos;
3352
if (0 != chars) {
3353
pdoc->BeginUndoAction();
3354
pdoc->DeleteChars(startPos, chars);
3355
pdoc->EndUndoAction();
3356
}
3357
} else {
3358
pdoc->BeginUndoAction();
3359
SelectionLineIterator lineIterator(this, false);
3360
while (lineIterator.Iterate()) {
3361
startPos = lineIterator.startPos;
3362
unsigned int chars = lineIterator.endPos - startPos;
3363
if (0 != chars) {
3364
pdoc->DeleteChars(startPos, chars);
3365
}
3366
}
3367
pdoc->EndUndoAction();
3368
selType = selStream;
3369
}
3370
SetEmptySelection(startPos);
3371
}
3372
}
3373
3374
void Editor::ClearAll() {
3375
pdoc->BeginUndoAction();
3376
if (0 != pdoc->Length()) {
3377
pdoc->DeleteChars(0, pdoc->Length());
3378
}
3379
if (!pdoc->IsReadOnly()) {
3380
cs.Clear();
3381
}
3382
pdoc->EndUndoAction();
3383
anchor = 0;
3384
currentPos = 0;
3385
SetTopLine(0);
3386
SetVerticalScrollPos();
3387
InvalidateStyleRedraw();
3388
}
3389
3390
void Editor::ClearDocumentStyle() {
3391
pdoc->StartStyling(0, '\377');
3392
pdoc->SetStyleFor(pdoc->Length(), 0);
3393
cs.ShowAll();
3394
pdoc->ClearLevels();
3395
}
3396
3397
void Editor::Cut() {
3398
if (!pdoc->IsReadOnly() && !SelectionContainsProtected()) {
3399
Copy();
3400
ClearSelection();
3401
}
3402
}
3403
3404
void Editor::PasteRectangular(int pos, const char *ptr, int len) {
3405
if (pdoc->IsReadOnly() || SelectionContainsProtected()) {
3406
return;
3407
}
3408
currentPos = pos;
3409
int xInsert = XFromPosition(currentPos);
3410
int line = pdoc->LineFromPosition(currentPos);
3411
bool prevCr = false;
3412
pdoc->BeginUndoAction();
3413
for (int i = 0; i < len; i++) {
3414
if (IsEOLChar(ptr[i])) {
3415
if ((ptr[i] == '\r') || (!prevCr))
3416
line++;
3417
if (line >= pdoc->LinesTotal()) {
3418
if (pdoc->eolMode != SC_EOL_LF)
3419
pdoc->InsertChar(pdoc->Length(), '\r');
3420
if (pdoc->eolMode != SC_EOL_CR)
3421
pdoc->InsertChar(pdoc->Length(), '\n');
3422
}
3423
// Pad the end of lines with spaces if required
3424
currentPos = PositionFromLineX(line, xInsert);
3425
if ((XFromPosition(currentPos) < xInsert) && (i + 1 < len)) {
3426
for (int i = 0; i < xInsert - XFromPosition(currentPos); i++) {
3427
pdoc->InsertChar(currentPos, ' ');
3428
currentPos++;
3429
}
3430
}
3431
prevCr = ptr[i] == '\r';
3432
} else {
3433
pdoc->InsertString(currentPos, ptr + i, 1);
3434
currentPos++;
3435
prevCr = false;
3436
}
3437
}
3438
pdoc->EndUndoAction();
3439
SetEmptySelection(pos);
3440
}
3441
3442
bool Editor::CanPaste() {
3443
return !pdoc->IsReadOnly() && !SelectionContainsProtected();
3444
}
3445
3446
void Editor::Clear() {
3447
if (currentPos == anchor) {
3448
if (!RangeContainsProtected(currentPos, currentPos + 1)) {
3449
DelChar();
3450
}
3451
} else {
3452
ClearSelection();
3453
}
3454
SetEmptySelection(currentPos);
3455
}
3456
3457
void Editor::SelectAll() {
3458
SetSelection(0, pdoc->Length());
3459
Redraw();
3460
}
3461
3462
void Editor::Undo() {
3463
if (pdoc->CanUndo()) {
3464
InvalidateCaret();
3465
int newPos = pdoc->Undo();
3466
if (newPos >= 0)
3467
SetEmptySelection(newPos);
3468
EnsureCaretVisible();
3469
}
3470
}
3471
3472
void Editor::Redo() {
3473
if (pdoc->CanRedo()) {
3474
int newPos = pdoc->Redo();
3475
if (newPos >= 0)
3476
SetEmptySelection(newPos);
3477
EnsureCaretVisible();
3478
}
3479
}
3480
3481
void Editor::DelChar() {
3482
if (!RangeContainsProtected(currentPos, currentPos + 1)) {
3483
pdoc->DelChar(currentPos);
3484
}
3485
// Avoid blinking during rapid typing:
3486
ShowCaretAtCurrentPosition();
3487
}
3488
3489
void Editor::DelCharBack(bool allowLineStartDeletion) {
3490
if (currentPos == anchor) {
3491
if (!RangeContainsProtected(currentPos - 1, currentPos)) {
3492
int lineCurrentPos = pdoc->LineFromPosition(currentPos);
3493
if (allowLineStartDeletion || (pdoc->LineStart(lineCurrentPos) != currentPos)) {
3494
if (pdoc->GetColumn(currentPos) <= pdoc->GetLineIndentation(lineCurrentPos) &&
3495
pdoc->GetColumn(currentPos) > 0 && pdoc->backspaceUnindents) {
3496
pdoc->BeginUndoAction();
3497
int indentation = pdoc->GetLineIndentation(lineCurrentPos);
3498
int indentationStep = pdoc->IndentSize();
3499
if (indentation % indentationStep == 0) {
3500
pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
3501
} else {
3502
pdoc->SetLineIndentation(lineCurrentPos, indentation - (indentation % indentationStep));
3503
}
3504
SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
3505
pdoc->EndUndoAction();
3506
} else {
3507
pdoc->DelCharBack(currentPos);
3508
}
3509
}
3510
}
3511
} else {
3512
ClearSelection();
3513
SetEmptySelection(currentPos);
3514
}
3515
// Avoid blinking during rapid typing:
3516
ShowCaretAtCurrentPosition();
3517
}
3518
3519
void Editor::NotifyFocus(bool) {}
3520
3521
void Editor::NotifyStyleToNeeded(int endStyleNeeded) {
3522
SCNotification scn = {0};
3523
scn.nmhdr.code = SCN_STYLENEEDED;
3524
scn.position = endStyleNeeded;
3525
NotifyParent(scn);
3526
}
3527
3528
void Editor::NotifyStyleNeeded(Document*, void *, int endStyleNeeded) {
3529
NotifyStyleToNeeded(endStyleNeeded);
3530
}
3531
3532
void Editor::NotifyChar(int ch) {
3533
SCNotification scn = {0};
3534
scn.nmhdr.code = SCN_CHARADDED;
3535
scn.ch = ch;
3536
NotifyParent(scn);
3537
if (recordingMacro) {
3538
char txt[2];
3539
txt[0] = static_cast<char>(ch);
3540
txt[1] = '\0';
3541
NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast<sptr_t>(txt));
3542
}
3543
}
3544
3545
void Editor::NotifySavePoint(bool isSavePoint) {
3546
SCNotification scn = {0};
3547
if (isSavePoint) {
3548
scn.nmhdr.code = SCN_SAVEPOINTREACHED;
3549
} else {
3550
scn.nmhdr.code = SCN_SAVEPOINTLEFT;
3551
}
3552
NotifyParent(scn);
3553
}
3554
3555
void Editor::NotifyModifyAttempt() {
3556
SCNotification scn = {0};
3557
scn.nmhdr.code = SCN_MODIFYATTEMPTRO;
3558
NotifyParent(scn);
3559
}
3560
3561
void Editor::NotifyDoubleClick(Point, bool) {
3562
SCNotification scn = {0};
3563
scn.nmhdr.code = SCN_DOUBLECLICK;
3564
NotifyParent(scn);
3565
}
3566
3567
void Editor::NotifyHotSpotDoubleClicked(int position, bool shift, bool ctrl, bool alt) {
3568
SCNotification scn = {0};
3569
scn.nmhdr.code = SCN_HOTSPOTDOUBLECLICK;
3570
scn.position = position;
3571
scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
3572
(alt ? SCI_ALT : 0);
3573
NotifyParent(scn);
3574
}
3575
3576
void Editor::NotifyHotSpotClicked(int position, bool shift, bool ctrl, bool alt) {
3577
SCNotification scn = {0};
3578
scn.nmhdr.code = SCN_HOTSPOTCLICK;
3579
scn.position = position;
3580
scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
3581
(alt ? SCI_ALT : 0);
3582
NotifyParent(scn);
3583
}
3584
3585
void Editor::NotifyUpdateUI() {
3586
SCNotification scn = {0};
3587
scn.nmhdr.code = SCN_UPDATEUI;
3588
NotifyParent(scn);
3589
}
3590
3591
void Editor::NotifyPainted() {
3592
SCNotification scn = {0};
3593
scn.nmhdr.code = SCN_PAINTED;
3594
NotifyParent(scn);
3595
}
3596
3597
bool Editor::NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt) {
3598
int marginClicked = -1;
3599
int x = 0;
3600
for (int margin = 0; margin < ViewStyle::margins; margin++) {
3601
if ((pt.x > x) && (pt.x < x + vs.ms[margin].width))
3602
marginClicked = margin;
3603
x += vs.ms[margin].width;
3604
}
3605
if ((marginClicked >= 0) && vs.ms[marginClicked].sensitive) {
3606
SCNotification scn = {0};
3607
scn.nmhdr.code = SCN_MARGINCLICK;
3608
scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
3609
(alt ? SCI_ALT : 0);
3610
scn.position = pdoc->LineStart(LineFromLocation(pt));
3611
scn.margin = marginClicked;
3612
NotifyParent(scn);
3613
return true;
3614
} else {
3615
return false;
3616
}
3617
}
3618
3619
void Editor::NotifyNeedShown(int pos, int len) {
3620
SCNotification scn = {0};
3621
scn.nmhdr.code = SCN_NEEDSHOWN;
3622
scn.position = pos;
3623
scn.length = len;
3624
NotifyParent(scn);
3625
}
3626
3627
void Editor::NotifyDwelling(Point pt, bool state) {
3628
SCNotification scn = {0};
3629
scn.nmhdr.code = state ? SCN_DWELLSTART : SCN_DWELLEND;
3630
scn.position = PositionFromLocationClose(pt);
3631
scn.x = pt.x;
3632
scn.y = pt.y;
3633
NotifyParent(scn);
3634
}
3635
3636
void Editor::NotifyZoom() {
3637
SCNotification scn = {0};
3638
scn.nmhdr.code = SCN_ZOOM;
3639
NotifyParent(scn);
3640
}
3641
3642
// Notifications from document
3643
void Editor::NotifyModifyAttempt(Document*, void *) {
3644
//Platform::DebugPrintf("** Modify Attempt\n");
3645
NotifyModifyAttempt();
3646
}
3647
3648
void Editor::NotifyMove(int position) {
3649
SCNotification scn = {0};
3650
scn.nmhdr.code = SCN_POSCHANGED;
3651
scn.position = position;
3652
NotifyParent(scn);
3653
}
3654
3655
void Editor::NotifySavePoint(Document*, void *, bool atSavePoint) {
3656
//Platform::DebugPrintf("** Save Point %s\n", atSavePoint ? "On" : "Off");
3657
NotifySavePoint(atSavePoint);
3658
}
3659
3660
void Editor::CheckModificationForWrap(DocModification mh) {
3661
if (mh.modificationType & (SC_MOD_INSERTTEXT|SC_MOD_DELETETEXT)) {
3662
llc.Invalidate(LineLayout::llCheckTextAndStyle);
3663
if (wrapState != eWrapNone) {
3664
int lineDoc = pdoc->LineFromPosition(mh.position);
3665
if (mh.linesAdded <= 0) {
3666
AutoSurface surface(this);
3667
AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
3668
if (surface && ll) {
3669
LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
3670
if (cs.GetHeight(lineDoc) != ll->lines) {
3671
NeedWrapping(lineDoc - 1, lineDoc + 1);
3672
Redraw();
3673
}
3674
}
3675
} else {
3676
NeedWrapping(lineDoc, lineDoc + 1 + mh.linesAdded);
3677
}
3678
}
3679
}
3680
}
3681
3682
// Move a position so it is still after the same character as before the insertion.
3683
static inline int MovePositionForInsertion(int position, int startInsertion, int length) {
3684
if (position > startInsertion) {
3685
return position + length;
3686
}
3687
return position;
3688
}
3689
3690
// Move a position so it is still after the same character as before the deletion if that
3691
// character is still present else after the previous surviving character.
3692
static inline int MovePositionForDeletion(int position, int startDeletion, int length) {
3693
if (position > startDeletion) {
3694
int endDeletion = startDeletion + length;
3695
if (position > endDeletion) {
3696
return position - length;
3697
} else {
3698
return startDeletion;
3699
}
3700
} else {
3701
return position;
3702
}
3703
}
3704
3705
void Editor::NotifyModified(Document*, DocModification mh, void *) {
3706
needUpdateUI = true;
3707
if (paintState == painting) {
3708
CheckForChangeOutsidePaint(Range(mh.position, mh.position + mh.length));
3709
}
3710
if (mh.modificationType & SC_MOD_CHANGESTYLE) {
3711
pdoc->IncrementStyleClock();
3712
if (paintState == notPainting) {
3713
if (mh.position < pdoc->LineStart(topLine)) {
3714
// Styling performed before this view
3715
Redraw();
3716
} else {
3717
InvalidateRange(mh.position, mh.position + mh.length);
3718
}
3719
}
3720
} else {
3721
// Move selection and brace highlights
3722
if (mh.modificationType & SC_MOD_INSERTTEXT) {
3723
currentPos = MovePositionForInsertion(currentPos, mh.position, mh.length);
3724
anchor = MovePositionForInsertion(anchor, mh.position, mh.length);
3725
braces[0] = MovePositionForInsertion(braces[0], mh.position, mh.length);
3726
braces[1] = MovePositionForInsertion(braces[1], mh.position, mh.length);
3727
} else if (mh.modificationType & SC_MOD_DELETETEXT) {
3728
currentPos = MovePositionForDeletion(currentPos, mh.position, mh.length);
3729
anchor = MovePositionForDeletion(anchor, mh.position, mh.length);
3730
braces[0] = MovePositionForDeletion(braces[0], mh.position, mh.length);
3731
braces[1] = MovePositionForDeletion(braces[1], mh.position, mh.length);
3732
}
3733
if (cs.LinesDisplayed() < cs.LinesInDoc()) {
3734
// Some lines are hidden so may need shown.
3735
// TODO: check if the modified area is hidden.
3736
if (mh.modificationType & SC_MOD_BEFOREINSERT) {
3737
NotifyNeedShown(mh.position, 0);
3738
} else if (mh.modificationType & SC_MOD_BEFOREDELETE) {
3739
NotifyNeedShown(mh.position, mh.length);
3740
}
3741
}
3742
if (mh.linesAdded != 0) {
3743
// Update contraction state for inserted and removed lines
3744
// lineOfPos should be calculated in context of state before modification, shouldn't it
3745
int lineOfPos = pdoc->LineFromPosition(mh.position);
3746
if (mh.linesAdded > 0) {
3747
cs.InsertLines(lineOfPos, mh.linesAdded);
3748
} else {
3749
cs.DeleteLines(lineOfPos, -mh.linesAdded);
3750
}
3751
}
3752
CheckModificationForWrap(mh);
3753
if (mh.linesAdded != 0) {
3754
// Avoid scrolling of display if change before current display
3755
if (mh.position < posTopLine && !CanDeferToLastStep(mh)) {
3756
int newTop = Platform::Clamp(topLine + mh.linesAdded, 0, MaxScrollPos());
3757
if (newTop != topLine) {
3758
SetTopLine(newTop);
3759
SetVerticalScrollPos();
3760
}
3761
}
3762
3763
//Platform::DebugPrintf("** %x Doc Changed\n", this);
3764
// TODO: could invalidate from mh.startModification to end of screen
3765
//InvalidateRange(mh.position, mh.position + mh.length);
3766
if (paintState == notPainting && !CanDeferToLastStep(mh)) {
3767
Redraw();
3768
}
3769
} else {
3770
//Platform::DebugPrintf("** %x Line Changed %d .. %d\n", this,
3771
// mh.position, mh.position + mh.length);
3772
if (paintState == notPainting && mh.length && !CanEliminate(mh)) {
3773
InvalidateRange(mh.position, mh.position + mh.length);
3774
}
3775
}
3776
}
3777
3778
if (mh.linesAdded != 0 && !CanDeferToLastStep(mh)) {
3779
SetScrollBars();
3780
}
3781
3782
if (mh.modificationType & SC_MOD_CHANGEMARKER) {
3783
if ((paintState == notPainting) || !PaintContainsMargin()) {
3784
if (mh.modificationType & SC_MOD_CHANGEFOLD) {
3785
// Fold changes can affect the drawing of following lines so redraw whole margin
3786
RedrawSelMargin();
3787
} else {
3788
RedrawSelMargin(mh.line);
3789
}
3790
}
3791
}
3792
3793
// NOW pay the piper WRT "deferred" visual updates
3794
if (IsLastStep(mh)) {
3795
SetScrollBars();
3796
Redraw();
3797
}
3798
3799
// If client wants to see this modification
3800
if (mh.modificationType & modEventMask) {
3801
if ((mh.modificationType & SC_MOD_CHANGESTYLE) == 0) {
3802
// Real modification made to text of document.
3803
NotifyChange(); // Send EN_CHANGE
3804
}
3805
3806
SCNotification scn = {0};
3807
scn.nmhdr.code = SCN_MODIFIED;
3808
scn.position = mh.position;
3809
scn.modificationType = mh.modificationType;
3810
scn.text = mh.text;
3811
scn.length = mh.length;
3812
scn.linesAdded = mh.linesAdded;
3813
scn.line = mh.line;
3814
scn.foldLevelNow = mh.foldLevelNow;
3815
scn.foldLevelPrev = mh.foldLevelPrev;
3816
NotifyParent(scn);
3817
}
3818
}
3819
3820
void Editor::NotifyDeleted(Document *, void *) {
3821
/* Do nothing */
3822
}
3823
3824
void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
3825
3826
// Enumerates all macroable messages
3827
switch (iMessage) {
3828
case SCI_CUT:
3829
case SCI_COPY:
3830
case SCI_PASTE:
3831
case SCI_CLEAR:
3832
case SCI_REPLACESEL:
3833
case SCI_ADDTEXT:
3834
case SCI_INSERTTEXT:
3835
case SCI_APPENDTEXT:
3836
case SCI_CLEARALL:
3837
case SCI_SELECTALL:
3838
case SCI_GOTOLINE:
3839
case SCI_GOTOPOS:
3840
case SCI_SEARCHANCHOR:
3841
case SCI_SEARCHNEXT:
3842
case SCI_SEARCHPREV:
3843
case SCI_LINEDOWN:
3844
case SCI_LINEDOWNEXTEND:
3845
case SCI_PARADOWN:
3846
case SCI_PARADOWNEXTEND:
3847
case SCI_LINEUP:
3848
case SCI_LINEUPEXTEND:
3849
case SCI_PARAUP:
3850
case SCI_PARAUPEXTEND:
3851
case SCI_CHARLEFT:
3852
case SCI_CHARLEFTEXTEND:
3853
case SCI_CHARRIGHT:
3854
case SCI_CHARRIGHTEXTEND:
3855
case SCI_WORDLEFT:
3856
case SCI_WORDLEFTEXTEND:
3857
case SCI_WORDRIGHT:
3858
case SCI_WORDRIGHTEXTEND:
3859
case SCI_WORDPARTLEFT:
3860
case SCI_WORDPARTLEFTEXTEND:
3861
case SCI_WORDPARTRIGHT:
3862
case SCI_WORDPARTRIGHTEXTEND:
3863
case SCI_WORDLEFTEND:
3864
case SCI_WORDLEFTENDEXTEND:
3865
case SCI_WORDRIGHTEND:
3866
case SCI_WORDRIGHTENDEXTEND:
3867
case SCI_HOME:
3868
case SCI_HOMEEXTEND:
3869
case SCI_LINEEND:
3870
case SCI_LINEENDEXTEND:
3871
case SCI_HOMEWRAP:
3872
case SCI_HOMEWRAPEXTEND:
3873
case SCI_LINEENDWRAP:
3874
case SCI_LINEENDWRAPEXTEND:
3875
case SCI_DOCUMENTSTART:
3876
case SCI_DOCUMENTSTARTEXTEND:
3877
case SCI_DOCUMENTEND:
3878
case SCI_DOCUMENTENDEXTEND:
3879
case SCI_STUTTEREDPAGEUP:
3880
case SCI_STUTTEREDPAGEUPEXTEND:
3881
case SCI_STUTTEREDPAGEDOWN:
3882
case SCI_STUTTEREDPAGEDOWNEXTEND:
3883
case SCI_PAGEUP:
3884
case SCI_PAGEUPEXTEND:
3885
case SCI_PAGEDOWN:
3886
case SCI_PAGEDOWNEXTEND:
3887
case SCI_EDITTOGGLEOVERTYPE:
3888
case SCI_CANCEL:
3889
case SCI_DELETEBACK:
3890
case SCI_TAB:
3891
case SCI_BACKTAB:
3892
case SCI_FORMFEED:
3893
case SCI_VCHOME:
3894
case SCI_VCHOMEEXTEND:
3895
case SCI_VCHOMEWRAP:
3896
case SCI_VCHOMEWRAPEXTEND:
3897
case SCI_DELWORDLEFT:
3898
case SCI_DELWORDRIGHT:
3899
case SCI_DELLINELEFT:
3900
case SCI_DELLINERIGHT:
3901
case SCI_LINECOPY:
3902
case SCI_LINECUT:
3903
case SCI_LINEDELETE:
3904
case SCI_LINETRANSPOSE:
3905
case SCI_LINEDUPLICATE:
3906
case SCI_LOWERCASE:
3907
case SCI_UPPERCASE:
3908
case SCI_LINESCROLLDOWN:
3909
case SCI_LINESCROLLUP:
3910
case SCI_DELETEBACKNOTLINE:
3911
case SCI_HOMEDISPLAY:
3912
case SCI_HOMEDISPLAYEXTEND:
3913
case SCI_LINEENDDISPLAY:
3914
case SCI_LINEENDDISPLAYEXTEND:
3915
case SCI_SETSELECTIONMODE:
3916
case SCI_LINEDOWNRECTEXTEND:
3917
case SCI_LINEUPRECTEXTEND:
3918
case SCI_CHARLEFTRECTEXTEND:
3919
case SCI_CHARRIGHTRECTEXTEND:
3920
case SCI_HOMERECTEXTEND:
3921
case SCI_VCHOMERECTEXTEND:
3922
case SCI_LINEENDRECTEXTEND:
3923
case SCI_PAGEUPRECTEXTEND:
3924
case SCI_PAGEDOWNRECTEXTEND:
3925
case SCI_SELECTIONDUPLICATE:
3926
break;
3927
3928
// Filter out all others like display changes. Also, newlines are redundant
3929
// with char insert messages.
3930
case SCI_NEWLINE:
3931
default:
3932
// printf("Filtered out %ld of macro recording\n", iMessage);
3933
return ;
3934
}
3935
3936
// Send notification
3937
SCNotification scn = {0};
3938
scn.nmhdr.code = SCN_MACRORECORD;
3939
scn.message = iMessage;
3940
scn.wParam = wParam;
3941
scn.lParam = lParam;
3942
NotifyParent(scn);
3943
}
3944
3945
/**
3946
* Force scroll and keep position relative to top of window.
3947
*
3948
* If stuttered = true and not already at first/last row, move to first/last row of window.
3949
* If stuttered = true and already at first/last row, scroll as normal.
3950
*/
3951
void Editor::PageMove(int direction, selTypes sel, bool stuttered) {
3952
int topLineNew, newPos;
3953
3954
// I consider only the caretYSlop, and ignore the caretYPolicy-- is that a problem?
3955
int currentLine = pdoc->LineFromPosition(currentPos);
3956
int topStutterLine = topLine + caretYSlop;
3957
int bottomStutterLine = topLine + LinesToScroll() - caretYSlop;
3958
3959
if (stuttered && (direction < 0 && currentLine > topStutterLine)) {
3960
topLineNew = topLine;
3961
newPos = PositionFromLocation(Point(lastXChosen, vs.lineHeight * caretYSlop));
3962
3963
} else if (stuttered && (direction > 0 && currentLine < bottomStutterLine)) {
3964
topLineNew = topLine;
3965
newPos = PositionFromLocation(Point(lastXChosen, vs.lineHeight * (LinesToScroll() - caretYSlop)));
3966
3967
} else {
3968
Point pt = LocationFromPosition(currentPos);
3969
3970
topLineNew = Platform::Clamp(
3971
topLine + direction * LinesToScroll(), 0, MaxScrollPos());
3972
newPos = PositionFromLocation(
3973
Point(lastXChosen, pt.y + direction * (vs.lineHeight * LinesToScroll())));
3974
}
3975
3976
if (topLineNew != topLine) {
3977
SetTopLine(topLineNew);
3978
MovePositionTo(newPos, sel);
3979
Redraw();
3980
SetVerticalScrollPos();
3981
} else {
3982
MovePositionTo(newPos, sel);
3983
}
3984
}
3985
3986
void Editor::ChangeCaseOfSelection(bool makeUpperCase) {
3987
pdoc->BeginUndoAction();
3988
int startCurrent = currentPos;
3989
int startAnchor = anchor;
3990
if (selType == selStream) {
3991
pdoc->ChangeCase(Range(SelectionStart(), SelectionEnd()),
3992
makeUpperCase);
3993
SetSelection(startCurrent, startAnchor);
3994
} else {
3995
SelectionLineIterator lineIterator(this, false);
3996
while (lineIterator.Iterate()) {
3997
pdoc->ChangeCase(
3998
Range(lineIterator.startPos, lineIterator.endPos),
3999
makeUpperCase);
4000
}
4001
// Would be nicer to keep the rectangular selection but this is complex
4002
SetEmptySelection(startCurrent);
4003
}
4004
pdoc->EndUndoAction();
4005
}
4006
4007
void Editor::LineTranspose() {
4008
int line = pdoc->LineFromPosition(currentPos);
4009
if (line > 0) {
4010
int startPrev = pdoc->LineStart(line - 1);
4011
int endPrev = pdoc->LineEnd(line - 1);
4012
int start = pdoc->LineStart(line);
4013
int end = pdoc->LineEnd(line);
4014
int startNext = pdoc->LineStart(line + 1);
4015
if (end < pdoc->Length()) {
4016
end = startNext;
4017
char *thisLine = CopyRange(start, end);
4018
pdoc->DeleteChars(start, end - start);
4019
if (pdoc->InsertString(startPrev, thisLine, end - start)) {
4020
MovePositionTo(startPrev + end - start);
4021
}
4022
delete []thisLine;
4023
} else {
4024
// Last line so line has no line end
4025
char *thisLine = CopyRange(start, end);
4026
char *prevEnd = CopyRange(endPrev, start);
4027
pdoc->DeleteChars(endPrev, end - endPrev);
4028
pdoc->InsertString(startPrev, thisLine, end - start);
4029
if (pdoc->InsertString(startPrev + end - start, prevEnd, start - endPrev)) {
4030
MovePositionTo(startPrev + end - endPrev);
4031
}
4032
delete []thisLine;
4033
delete []prevEnd;
4034
}
4035
4036
}
4037
}
4038
4039
void Editor::Duplicate(bool forLine) {
4040
int start = SelectionStart();
4041
int end = SelectionEnd();
4042
if (start == end) {
4043
forLine = true;
4044
}
4045
if (forLine) {
4046
int line = pdoc->LineFromPosition(currentPos);
4047
start = pdoc->LineStart(line);
4048
end = pdoc->LineEnd(line);
4049
}
4050
char *text = CopyRange(start, end);
4051
if (forLine) {
4052
const char *eol = StringFromEOLMode(pdoc->eolMode);
4053
pdoc->InsertString(end, eol);
4054
pdoc->InsertString(end + istrlen(eol), text, end - start);
4055
} else {
4056
pdoc->InsertString(end, text, end - start);
4057
}
4058
delete []text;
4059
}
4060
4061
void Editor::CancelModes() {
4062
moveExtendsSelection = false;
4063
}
4064
4065
void Editor::NewLine() {
4066
ClearSelection();
4067
const char *eol = "\n";
4068
if (pdoc->eolMode == SC_EOL_CRLF) {
4069
eol = "\r\n";
4070
} else if (pdoc->eolMode == SC_EOL_CR) {
4071
eol = "\r";
4072
} // else SC_EOL_LF -> "\n" already set
4073
if (pdoc->InsertString(currentPos, eol)) {
4074
SetEmptySelection(currentPos + istrlen(eol));
4075
while (*eol) {
4076
NotifyChar(*eol);
4077
eol++;
4078
}
4079
}
4080
SetLastXChosen();
4081
EnsureCaretVisible();
4082
// Avoid blinking during rapid typing:
4083
ShowCaretAtCurrentPosition();
4084
}
4085
4086
void Editor::CursorUpOrDown(int direction, selTypes sel) {
4087
Point pt = LocationFromPosition(currentPos);
4088
int posNew = PositionFromLocation(
4089
Point(lastXChosen, pt.y + direction * vs.lineHeight));
4090
if (direction < 0) {
4091
// Line wrapping may lead to a location on the same line, so
4092
// seek back if that is the case.
4093
// There is an equivalent case when moving down which skips
4094
// over a line but as that does not trap the user it is fine.
4095
Point ptNew = LocationFromPosition(posNew);
4096
while ((posNew > 0) && (pt.y == ptNew.y)) {
4097
posNew--;
4098
ptNew = LocationFromPosition(posNew);
4099
}
4100
}
4101
MovePositionTo(posNew, sel);
4102
}
4103
4104
void Editor::ParaUpOrDown(int direction, selTypes sel) {
4105
int lineDoc, savedPos = currentPos;
4106
do {
4107
MovePositionTo(direction > 0 ? pdoc->ParaDown(currentPos) : pdoc->ParaUp(currentPos), sel);
4108
lineDoc = pdoc->LineFromPosition(currentPos);
4109
if (direction > 0) {
4110
if (currentPos >= pdoc->Length() && !cs.GetVisible(lineDoc)) {
4111
if (sel == noSel) {
4112
MovePositionTo(pdoc->LineEndPosition(savedPos));
4113
}
4114
break;
4115
}
4116
}
4117
} while (!cs.GetVisible(lineDoc));
4118
}
4119
4120
int Editor::StartEndDisplayLine(int pos, bool start) {
4121
RefreshStyleData();
4122
int line = pdoc->LineFromPosition(pos);
4123
AutoSurface surface(this);
4124
AutoLineLayout ll(llc, RetrieveLineLayout(line));
4125
int posRet = INVALID_POSITION;
4126
if (surface && ll) {
4127
unsigned int posLineStart = pdoc->LineStart(line);
4128
LayoutLine(line, surface, vs, ll, wrapWidth);
4129
int posInLine = pos - posLineStart;
4130
if (posInLine <= ll->maxLineLength) {
4131
for (int subLine = 0; subLine < ll->lines; subLine++) {
4132
if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) {
4133
if (start) {
4134
posRet = ll->LineStart(subLine) + posLineStart;
4135
} else {
4136
if (subLine == ll->lines - 1)
4137
posRet = ll->LineStart(subLine + 1) + posLineStart;
4138
else
4139
posRet = ll->LineStart(subLine + 1) + posLineStart - 1;
4140
}
4141
}
4142
}
4143
}
4144
}
4145
if (posRet == INVALID_POSITION) {
4146
return pos;
4147
} else {
4148
return posRet;
4149
}
4150
}
4151
4152
int Editor::KeyCommand(unsigned int iMessage) {
4153
switch (iMessage) {
4154
case SCI_LINEDOWN:
4155
CursorUpOrDown(1);
4156
break;
4157
case SCI_LINEDOWNEXTEND:
4158
CursorUpOrDown(1, selStream);
4159
break;
4160
case SCI_LINEDOWNRECTEXTEND:
4161
CursorUpOrDown(1, selRectangle);
4162
break;
4163
case SCI_PARADOWN:
4164
ParaUpOrDown(1);
4165
break;
4166
case SCI_PARADOWNEXTEND:
4167
ParaUpOrDown(1, selStream);
4168
break;
4169
case SCI_LINESCROLLDOWN:
4170
ScrollTo(topLine + 1);
4171
MoveCaretInsideView(false);
4172
break;
4173
case SCI_LINEUP:
4174
CursorUpOrDown(-1);
4175
break;
4176
case SCI_LINEUPEXTEND:
4177
CursorUpOrDown(-1, selStream);
4178
break;
4179
case SCI_LINEUPRECTEXTEND:
4180
CursorUpOrDown(-1, selRectangle);
4181
break;
4182
case SCI_PARAUP:
4183
ParaUpOrDown(-1);
4184
break;
4185
case SCI_PARAUPEXTEND:
4186
ParaUpOrDown(-1, selStream);
4187
break;
4188
case SCI_LINESCROLLUP:
4189
ScrollTo(topLine - 1);
4190
MoveCaretInsideView(false);
4191
break;
4192
case SCI_CHARLEFT:
4193
if (SelectionEmpty() || moveExtendsSelection) {
4194
MovePositionTo(MovePositionSoVisible(currentPos - 1, -1));
4195
} else {
4196
MovePositionTo(SelectionStart());
4197
}
4198
SetLastXChosen();
4199
break;
4200
case SCI_CHARLEFTEXTEND:
4201
MovePositionTo(MovePositionSoVisible(currentPos - 1, -1), selStream);
4202
SetLastXChosen();
4203
break;
4204
case SCI_CHARLEFTRECTEXTEND:
4205
MovePositionTo(MovePositionSoVisible(currentPos - 1, -1), selRectangle);
4206
SetLastXChosen();
4207
break;
4208
case SCI_CHARRIGHT:
4209
if (SelectionEmpty() || moveExtendsSelection) {
4210
MovePositionTo(MovePositionSoVisible(currentPos + 1, 1));
4211
} else {
4212
MovePositionTo(SelectionEnd());
4213
}
4214
SetLastXChosen();
4215
break;
4216
case SCI_CHARRIGHTEXTEND:
4217
MovePositionTo(MovePositionSoVisible(currentPos + 1, 1), selStream);
4218
SetLastXChosen();
4219
break;
4220
case SCI_CHARRIGHTRECTEXTEND:
4221
MovePositionTo(MovePositionSoVisible(currentPos + 1, 1), selRectangle);
4222
SetLastXChosen();
4223
break;
4224
case SCI_WORDLEFT:
4225
MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, -1), -1));
4226
SetLastXChosen();
4227
break;
4228
case SCI_WORDLEFTEXTEND:
4229
MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, -1), -1), selStream);
4230
SetLastXChosen();
4231
break;
4232
case SCI_WORDRIGHT:
4233
MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, 1), 1));
4234
SetLastXChosen();
4235
break;
4236
case SCI_WORDRIGHTEXTEND:
4237
MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, 1), 1), selStream);
4238
SetLastXChosen();
4239
break;
4240
4241
case SCI_WORDLEFTEND:
4242
MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, -1), -1));
4243
SetLastXChosen();
4244
break;
4245
case SCI_WORDLEFTENDEXTEND:
4246
MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, -1), -1), selStream);
4247
SetLastXChosen();
4248
break;
4249
case SCI_WORDRIGHTEND:
4250
MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, 1), 1));
4251
SetLastXChosen();
4252
break;
4253
case SCI_WORDRIGHTENDEXTEND:
4254
MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, 1), 1), selStream);
4255
SetLastXChosen();
4256
break;
4257
4258
case SCI_HOME:
4259
MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)));
4260
SetLastXChosen();
4261
break;
4262
case SCI_HOMEEXTEND:
4263
MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)), selStream);
4264
SetLastXChosen();
4265
break;
4266
case SCI_HOMERECTEXTEND:
4267
MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)), selRectangle);
4268
SetLastXChosen();
4269
break;
4270
case SCI_LINEEND:
4271
MovePositionTo(pdoc->LineEndPosition(currentPos));
4272
SetLastXChosen();
4273
break;
4274
case SCI_LINEENDEXTEND:
4275
MovePositionTo(pdoc->LineEndPosition(currentPos), selStream);
4276
SetLastXChosen();
4277
break;
4278
case SCI_LINEENDRECTEXTEND:
4279
MovePositionTo(pdoc->LineEndPosition(currentPos), selRectangle);
4280
SetLastXChosen();
4281
break;
4282
case SCI_HOMEWRAP: {
4283
int homePos = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
4284
if (currentPos <= homePos)
4285
homePos = pdoc->LineStart(pdoc->LineFromPosition(currentPos));
4286
MovePositionTo(homePos);
4287
SetLastXChosen();
4288
}
4289
break;
4290
case SCI_HOMEWRAPEXTEND: {
4291
int homePos = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
4292
if (currentPos <= homePos)
4293
homePos = pdoc->LineStart(pdoc->LineFromPosition(currentPos));
4294
MovePositionTo(homePos, selStream);
4295
SetLastXChosen();
4296
}
4297
break;
4298
case SCI_LINEENDWRAP: {
4299
int endPos = MovePositionSoVisible(StartEndDisplayLine(currentPos, false), 1);
4300
int realEndPos = pdoc->LineEndPosition(currentPos);
4301
if (endPos > realEndPos // if moved past visible EOLs
4302
|| currentPos >= endPos) // if at end of display line already
4303
endPos = realEndPos;
4304
MovePositionTo(endPos);
4305
SetLastXChosen();
4306
}
4307
break;
4308
case SCI_LINEENDWRAPEXTEND: {
4309
int endPos = MovePositionSoVisible(StartEndDisplayLine(currentPos, false), 1);
4310
int realEndPos = pdoc->LineEndPosition(currentPos);
4311
if (endPos > realEndPos // if moved past visible EOLs
4312
|| currentPos >= endPos) // if at end of display line already
4313
endPos = realEndPos;
4314
MovePositionTo(endPos, selStream);
4315
SetLastXChosen();
4316
}
4317
break;
4318
case SCI_DOCUMENTSTART:
4319
MovePositionTo(0);
4320
SetLastXChosen();
4321
break;
4322
case SCI_DOCUMENTSTARTEXTEND:
4323
MovePositionTo(0, selStream);
4324
SetLastXChosen();
4325
break;
4326
case SCI_DOCUMENTEND:
4327
MovePositionTo(pdoc->Length());
4328
SetLastXChosen();
4329
break;
4330
case SCI_DOCUMENTENDEXTEND:
4331
MovePositionTo(pdoc->Length(), selStream);
4332
SetLastXChosen();
4333
break;
4334
case SCI_STUTTEREDPAGEUP:
4335
PageMove(-1, noSel, true);
4336
break;
4337
case SCI_STUTTEREDPAGEUPEXTEND:
4338
PageMove(-1, selStream, true);
4339
break;
4340
case SCI_STUTTEREDPAGEDOWN:
4341
PageMove(1, noSel, true);
4342
break;
4343
case SCI_STUTTEREDPAGEDOWNEXTEND:
4344
PageMove(1, selStream, true);
4345
break;
4346
case SCI_PAGEUP:
4347
PageMove(-1);
4348
break;
4349
case SCI_PAGEUPEXTEND:
4350
PageMove(-1, selStream);
4351
break;
4352
case SCI_PAGEUPRECTEXTEND:
4353
PageMove(-1, selRectangle);
4354
break;
4355
case SCI_PAGEDOWN:
4356
PageMove(1);
4357
break;
4358
case SCI_PAGEDOWNEXTEND:
4359
PageMove(1, selStream);
4360
break;
4361
case SCI_PAGEDOWNRECTEXTEND:
4362
PageMove(1, selRectangle);
4363
break;
4364
case SCI_EDITTOGGLEOVERTYPE:
4365
inOverstrike = !inOverstrike;
4366
DropCaret();
4367
ShowCaretAtCurrentPosition();
4368
NotifyUpdateUI();
4369
break;
4370
case SCI_CANCEL: // Cancel any modes - handled in subclass
4371
// Also unselect text
4372
CancelModes();
4373
break;
4374
case SCI_DELETEBACK:
4375
DelCharBack(true);
4376
if (!caretSticky) {
4377
SetLastXChosen();
4378
}
4379
EnsureCaretVisible();
4380
break;
4381
case SCI_DELETEBACKNOTLINE:
4382
DelCharBack(false);
4383
if (!caretSticky) {
4384
SetLastXChosen();
4385
}
4386
EnsureCaretVisible();
4387
break;
4388
case SCI_TAB:
4389
Indent(true);
4390
if (!caretSticky) {
4391
SetLastXChosen();
4392
}
4393
EnsureCaretVisible();
4394
break;
4395
case SCI_BACKTAB:
4396
Indent(false);
4397
if (!caretSticky) {
4398
SetLastXChosen();
4399
}
4400
EnsureCaretVisible();
4401
break;
4402
case SCI_NEWLINE:
4403
NewLine();
4404
break;
4405
case SCI_FORMFEED:
4406
AddChar('\f');
4407
break;
4408
case SCI_VCHOME:
4409
MovePositionTo(pdoc->VCHomePosition(currentPos));
4410
SetLastXChosen();
4411
break;
4412
case SCI_VCHOMEEXTEND:
4413
MovePositionTo(pdoc->VCHomePosition(currentPos), selStream);
4414
SetLastXChosen();
4415
break;
4416
case SCI_VCHOMERECTEXTEND:
4417
MovePositionTo(pdoc->VCHomePosition(currentPos), selRectangle);
4418
SetLastXChosen();
4419
break;
4420
case SCI_VCHOMEWRAP: {
4421
int homePos = pdoc->VCHomePosition(currentPos);
4422
int viewLineStart = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
4423
if ((viewLineStart < currentPos) && (viewLineStart > homePos))
4424
homePos = viewLineStart;
4425
4426
MovePositionTo(homePos);
4427
SetLastXChosen();
4428
}
4429
break;
4430
case SCI_VCHOMEWRAPEXTEND: {
4431
int homePos = pdoc->VCHomePosition(currentPos);
4432
int viewLineStart = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
4433
if ((viewLineStart < currentPos) && (viewLineStart > homePos))
4434
homePos = viewLineStart;
4435
4436
MovePositionTo(homePos, selStream);
4437
SetLastXChosen();
4438
}
4439
break;
4440
case SCI_ZOOMIN:
4441
if (vs.zoomLevel < 20) {
4442
vs.zoomLevel++;
4443
InvalidateStyleRedraw();
4444
NotifyZoom();
4445
}
4446
break;
4447
case SCI_ZOOMOUT:
4448
if (vs.zoomLevel > -10) {
4449
vs.zoomLevel--;
4450
InvalidateStyleRedraw();
4451
NotifyZoom();
4452
}
4453
break;
4454
case SCI_DELWORDLEFT: {
4455
int startWord = pdoc->NextWordStart(currentPos, -1);
4456
pdoc->DeleteChars(startWord, currentPos - startWord);
4457
SetLastXChosen();
4458
}
4459
break;
4460
case SCI_DELWORDRIGHT: {
4461
int endWord = pdoc->NextWordStart(currentPos, 1);
4462
pdoc->DeleteChars(currentPos, endWord - currentPos);
4463
}
4464
break;
4465
case SCI_DELLINELEFT: {
4466
int line = pdoc->LineFromPosition(currentPos);
4467
int start = pdoc->LineStart(line);
4468
pdoc->DeleteChars(start, currentPos - start);
4469
SetLastXChosen();
4470
}
4471
break;
4472
case SCI_DELLINERIGHT: {
4473
int line = pdoc->LineFromPosition(currentPos);
4474
int end = pdoc->LineEnd(line);
4475
pdoc->DeleteChars(currentPos, end - currentPos);
4476
}
4477
break;
4478
case SCI_LINECOPY: {
4479
int lineStart = pdoc->LineFromPosition(SelectionStart());
4480
int lineEnd = pdoc->LineFromPosition(SelectionEnd());
4481
CopyRangeToClipboard(pdoc->LineStart(lineStart),
4482
pdoc->LineStart(lineEnd + 1));
4483
}
4484
break;
4485
case SCI_LINECUT: {
4486
int lineStart = pdoc->LineFromPosition(SelectionStart());
4487
int lineEnd = pdoc->LineFromPosition(SelectionEnd());
4488
int start = pdoc->LineStart(lineStart);
4489
int end = pdoc->LineStart(lineEnd + 1);
4490
SetSelection(start, end);
4491
Cut();
4492
SetLastXChosen();
4493
}
4494
break;
4495
case SCI_LINEDELETE: {
4496
int line = pdoc->LineFromPosition(currentPos);
4497
int start = pdoc->LineStart(line);
4498
int end = pdoc->LineStart(line + 1);
4499
pdoc->DeleteChars(start, end - start);
4500
}
4501
break;
4502
case SCI_LINETRANSPOSE:
4503
LineTranspose();
4504
break;
4505
case SCI_LINEDUPLICATE:
4506
Duplicate(true);
4507
break;
4508
case SCI_SELECTIONDUPLICATE:
4509
Duplicate(false);
4510
break;
4511
case SCI_LOWERCASE:
4512
ChangeCaseOfSelection(false);
4513
break;
4514
case SCI_UPPERCASE:
4515
ChangeCaseOfSelection(true);
4516
break;
4517
case SCI_WORDPARTLEFT:
4518
MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(currentPos), -1));
4519
SetLastXChosen();
4520
break;
4521
case SCI_WORDPARTLEFTEXTEND:
4522
MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(currentPos), -1), selStream);
4523
SetLastXChosen();
4524
break;
4525
case SCI_WORDPARTRIGHT:
4526
MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(currentPos), 1));
4527
SetLastXChosen();
4528
break;
4529
case SCI_WORDPARTRIGHTEXTEND:
4530
MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(currentPos), 1), selStream);
4531
SetLastXChosen();
4532
break;
4533
case SCI_HOMEDISPLAY:
4534
MovePositionTo(MovePositionSoVisible(
4535
StartEndDisplayLine(currentPos, true), -1));
4536
SetLastXChosen();
4537
break;
4538
case SCI_HOMEDISPLAYEXTEND:
4539
MovePositionTo(MovePositionSoVisible(
4540
StartEndDisplayLine(currentPos, true), -1), selStream);
4541
SetLastXChosen();
4542
break;
4543
case SCI_LINEENDDISPLAY:
4544
MovePositionTo(MovePositionSoVisible(
4545
StartEndDisplayLine(currentPos, false), 1));
4546
SetLastXChosen();
4547
break;
4548
case SCI_LINEENDDISPLAYEXTEND:
4549
MovePositionTo(MovePositionSoVisible(
4550
StartEndDisplayLine(currentPos, false), 1), selStream);
4551
SetLastXChosen();
4552
break;
4553
}
4554
return 0;
4555
}
4556
4557
int Editor::KeyDefault(int, int) {
4558
return 0;
4559
}
4560
4561
int Editor::KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed) {
4562
DwellEnd(false);
4563
int modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
4564
(alt ? SCI_ALT : 0);
4565
int msg = kmap.Find(key, modifiers);
4566
if (msg) {
4567
if (consumed)
4568
*consumed = true;
4569
return WndProc(msg, 0, 0);
4570
} else {
4571
if (consumed)
4572
*consumed = false;
4573
return KeyDefault(key, modifiers);
4574
}
4575
}
4576
4577
void Editor::SetWhitespaceVisible(int view) {
4578
vs.viewWhitespace = static_cast<WhiteSpaceVisibility>(view);
4579
}
4580
4581
int Editor::GetWhitespaceVisible() {
4582
return vs.viewWhitespace;
4583
}
4584
4585
void Editor::Indent(bool forwards) {
4586
//Platform::DebugPrintf("INdent %d\n", forwards);
4587
int lineOfAnchor = pdoc->LineFromPosition(anchor);
4588
int lineCurrentPos = pdoc->LineFromPosition(currentPos);
4589
if (lineOfAnchor == lineCurrentPos) {
4590
if (forwards) {
4591
pdoc->BeginUndoAction();
4592
ClearSelection();
4593
if (pdoc->GetColumn(currentPos) <= pdoc->GetColumn(pdoc->GetLineIndentPosition(lineCurrentPos)) &&
4594
pdoc->tabIndents) {
4595
int indentation = pdoc->GetLineIndentation(lineCurrentPos);
4596
int indentationStep = pdoc->IndentSize();
4597
pdoc->SetLineIndentation(lineCurrentPos, indentation + indentationStep - indentation % indentationStep);
4598
SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
4599
} else {
4600
if (pdoc->useTabs) {
4601
pdoc->InsertChar(currentPos, '\t');
4602
SetEmptySelection(currentPos + 1);
4603
} else {
4604
int numSpaces = (pdoc->tabInChars) -
4605
(pdoc->GetColumn(currentPos) % (pdoc->tabInChars));
4606
if (numSpaces < 1)
4607
numSpaces = pdoc->tabInChars;
4608
for (int i = 0; i < numSpaces; i++) {
4609
pdoc->InsertChar(currentPos + i, ' ');
4610
}
4611
SetEmptySelection(currentPos + numSpaces);
4612
}
4613
}
4614
pdoc->EndUndoAction();
4615
} else {
4616
if (pdoc->GetColumn(currentPos) <= pdoc->GetLineIndentation(lineCurrentPos) &&
4617
pdoc->tabIndents) {
4618
pdoc->BeginUndoAction();
4619
int indentation = pdoc->GetLineIndentation(lineCurrentPos);
4620
int indentationStep = pdoc->IndentSize();
4621
pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
4622
SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
4623
pdoc->EndUndoAction();
4624
} else {
4625
int newColumn = ((pdoc->GetColumn(currentPos) - 1) / pdoc->tabInChars) *
4626
pdoc->tabInChars;
4627
if (newColumn < 0)
4628
newColumn = 0;
4629
int newPos = currentPos;
4630
while (pdoc->GetColumn(newPos) > newColumn)
4631
newPos--;
4632
SetEmptySelection(newPos);
4633
}
4634
}
4635
} else {
4636
int anchorPosOnLine = anchor - pdoc->LineStart(lineOfAnchor);
4637
int currentPosPosOnLine = currentPos - pdoc->LineStart(lineCurrentPos);
4638
// Multiple lines selected so indent / dedent
4639
int lineTopSel = Platform::Minimum(lineOfAnchor, lineCurrentPos);
4640
int lineBottomSel = Platform::Maximum(lineOfAnchor, lineCurrentPos);
4641
if (pdoc->LineStart(lineBottomSel) == anchor || pdoc->LineStart(lineBottomSel) == currentPos)
4642
lineBottomSel--; // If not selecting any characters on a line, do not indent
4643
pdoc->BeginUndoAction();
4644
pdoc->Indent(forwards, lineBottomSel, lineTopSel);
4645
pdoc->EndUndoAction();
4646
if (lineOfAnchor < lineCurrentPos) {
4647
if (currentPosPosOnLine == 0)
4648
SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor));
4649
else
4650
SetSelection(pdoc->LineStart(lineCurrentPos + 1), pdoc->LineStart(lineOfAnchor));
4651
} else {
4652
if (anchorPosOnLine == 0)
4653
SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor));
4654
else
4655
SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor + 1));
4656
}
4657
}
4658
}
4659
4660
/**
4661
* Search of a text in the document, in the given range.
4662
* @return The position of the found text, -1 if not found.
4663
*/
4664
long Editor::FindText(
4665
uptr_t wParam, ///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD,
4666
///< @c SCFIND_WORDSTART, @c SCFIND_REGEXP or @c SCFIND_POSIX.
4667
sptr_t lParam) { ///< @c TextToFind structure: The text to search for in the given range.
4668
4669
TextToFind *ft = reinterpret_cast<TextToFind *>(lParam);
4670
int lengthFound = istrlen(ft->lpstrText);
4671
int pos = pdoc->FindText(ft->chrg.cpMin, ft->chrg.cpMax, ft->lpstrText,
4672
(wParam & SCFIND_MATCHCASE) != 0,
4673
(wParam & SCFIND_WHOLEWORD) != 0,
4674
(wParam & SCFIND_WORDSTART) != 0,
4675
(wParam & SCFIND_REGEXP) != 0,
4676
(wParam & SCFIND_POSIX) != 0,
4677
&lengthFound);
4678
if (pos != -1) {
4679
ft->chrgText.cpMin = pos;
4680
ft->chrgText.cpMax = pos + lengthFound;
4681
}
4682
return pos;
4683
}
4684
4685
/**
4686
* Relocatable search support : Searches relative to current selection
4687
* point and sets the selection to the found text range with
4688
* each search.
4689
*/
4690
/**
4691
* Anchor following searches at current selection start: This allows
4692
* multiple incremental interactive searches to be macro recorded
4693
* while still setting the selection to found text so the find/select
4694
* operation is self-contained.
4695
*/
4696
void Editor::SearchAnchor() {
4697
searchAnchor = SelectionStart();
4698
}
4699
4700
/**
4701
* Find text from current search anchor: Must call @c SearchAnchor first.
4702
* Used for next text and previous text requests.
4703
* @return The position of the found text, -1 if not found.
4704
*/
4705
long Editor::SearchText(
4706
unsigned int iMessage, ///< Accepts both @c SCI_SEARCHNEXT and @c SCI_SEARCHPREV.
4707
uptr_t wParam, ///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD,
4708
///< @c SCFIND_WORDSTART, @c SCFIND_REGEXP or @c SCFIND_POSIX.
4709
sptr_t lParam) { ///< The text to search for.
4710
4711
const char *txt = reinterpret_cast<char *>(lParam);
4712
int pos;
4713
int lengthFound = istrlen(txt);
4714
if (iMessage == SCI_SEARCHNEXT) {
4715
pos = pdoc->FindText(searchAnchor, pdoc->Length(), txt,
4716
(wParam & SCFIND_MATCHCASE) != 0,
4717
(wParam & SCFIND_WHOLEWORD) != 0,
4718
(wParam & SCFIND_WORDSTART) != 0,
4719
(wParam & SCFIND_REGEXP) != 0,
4720
(wParam & SCFIND_POSIX) != 0,
4721
&lengthFound);
4722
} else {
4723
pos = pdoc->FindText(searchAnchor, 0, txt,
4724
(wParam & SCFIND_MATCHCASE) != 0,
4725
(wParam & SCFIND_WHOLEWORD) != 0,
4726
(wParam & SCFIND_WORDSTART) != 0,
4727
(wParam & SCFIND_REGEXP) != 0,
4728
(wParam & SCFIND_POSIX) != 0,
4729
&lengthFound);
4730
}
4731
4732
if (pos != -1) {
4733
SetSelection(pos, pos + lengthFound);
4734
}
4735
4736
return pos;
4737
}
4738
4739
/**
4740
* Search for text in the target range of the document.
4741
* @return The position of the found text, -1 if not found.
4742
*/
4743
long Editor::SearchInTarget(const char *text, int length) {
4744
int lengthFound = length;
4745
int pos = pdoc->FindText(targetStart, targetEnd, text,
4746
(searchFlags & SCFIND_MATCHCASE) != 0,
4747
(searchFlags & SCFIND_WHOLEWORD) != 0,
4748
(searchFlags & SCFIND_WORDSTART) != 0,
4749
(searchFlags & SCFIND_REGEXP) != 0,
4750
(searchFlags & SCFIND_POSIX) != 0,
4751
&lengthFound);
4752
if (pos != -1) {
4753
targetStart = pos;
4754
targetEnd = pos + lengthFound;
4755
}
4756
return pos;
4757
}
4758
4759
void Editor::GoToLine(int lineNo) {
4760
if (lineNo > pdoc->LinesTotal())
4761
lineNo = pdoc->LinesTotal();
4762
if (lineNo < 0)
4763
lineNo = 0;
4764
SetEmptySelection(pdoc->LineStart(lineNo));
4765
ShowCaretAtCurrentPosition();
4766
EnsureCaretVisible();
4767
}
4768
4769
static bool Close(Point pt1, Point pt2) {
4770
if (abs(pt1.x - pt2.x) > 3)
4771
return false;
4772
if (abs(pt1.y - pt2.y) > 3)
4773
return false;
4774
return true;
4775
}
4776
4777
char *Editor::CopyRange(int start, int end) {
4778
char *text = 0;
4779
if (start < end) {
4780
int len = end - start;
4781
text = new char[len + 1];
4782
if (text) {
4783
for (int i = 0; i < len; i++) {
4784
text[i] = pdoc->CharAt(start + i);
4785
}
4786
text[len] = '\0';
4787
}
4788
}
4789
return text;
4790
}
4791
4792
void Editor::CopySelectionFromRange(SelectionText *ss, int start, int end) {
4793
ss->Set(CopyRange(start, end), end - start + 1,
4794
pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false);
4795
}
4796
4797
void Editor::CopySelectionRange(SelectionText *ss) {
4798
if (selType == selStream) {
4799
CopySelectionFromRange(ss, SelectionStart(), SelectionEnd());
4800
} else {
4801
char *text = 0;
4802
int size = 0;
4803
SelectionLineIterator lineIterator(this);
4804
while (lineIterator.Iterate()) {
4805
size += lineIterator.endPos - lineIterator.startPos;
4806
if (selType != selLines) {
4807
size++;
4808
if (pdoc->eolMode == SC_EOL_CRLF) {
4809
size++;
4810
}
4811
}
4812
}
4813
if (size > 0) {
4814
text = new char[size + 1];
4815
if (text) {
4816
int j = 0;
4817
lineIterator.Reset();
4818
while (lineIterator.Iterate()) {
4819
for (int i = lineIterator.startPos;
4820
i < lineIterator.endPos;
4821
i++) {
4822
text[j++] = pdoc->CharAt(i);
4823
}
4824
if (selType != selLines) {
4825
if (pdoc->eolMode != SC_EOL_LF) {
4826
text[j++] = '\r';
4827
}
4828
if (pdoc->eolMode != SC_EOL_CR) {
4829
text[j++] = '\n';
4830
}
4831
}
4832
}
4833
text[size] = '\0';
4834
}
4835
}
4836
ss->Set(text, size + 1, pdoc->dbcsCodePage,
4837
vs.styles[STYLE_DEFAULT].characterSet, selType == selRectangle);
4838
}
4839
}
4840
4841
void Editor::CopyRangeToClipboard(int start, int end) {
4842
start = pdoc->ClampPositionIntoDocument(start);
4843
end = pdoc->ClampPositionIntoDocument(end);
4844
SelectionText selectedText;
4845
selectedText.Set(CopyRange(start, end), end - start + 1,
4846
pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false);
4847
CopyToClipboard(selectedText);
4848
}
4849
4850
void Editor::CopyText(int length, const char *text) {
4851
SelectionText selectedText;
4852
selectedText.Copy(text, length,
4853
pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false);
4854
CopyToClipboard(selectedText);
4855
}
4856
4857
void Editor::SetDragPosition(int newPos) {
4858
if (newPos >= 0) {
4859
newPos = MovePositionOutsideChar(newPos, 1);
4860
posDrop = newPos;
4861
}
4862
if (posDrag != newPos) {
4863
caret.on = true;
4864
SetTicking(true);
4865
InvalidateCaret();
4866
posDrag = newPos;
4867
InvalidateCaret();
4868
}
4869
}
4870
4871
void Editor::DisplayCursor(Window::Cursor c) {
4872
if (cursorMode == SC_CURSORNORMAL)
4873
wMain.SetCursor(c);
4874
else
4875
wMain.SetCursor(static_cast<Window::Cursor>(cursorMode));
4876
}
4877
4878
void Editor::StartDrag() {
4879
// Always handled by subclasses
4880
//SetMouseCapture(true);
4881
//DisplayCursor(Window::cursorArrow);
4882
}
4883
4884
void Editor::DropAt(int position, const char *value, bool moving, bool rectangular) {
4885
//Platform::DebugPrintf("DropAt %d\n", inDragDrop);
4886
if (inDragDrop)
4887
dropWentOutside = false;
4888
4889
int positionWasInSelection = PositionInSelection(position);
4890
4891
bool positionOnEdgeOfSelection =
4892
(position == SelectionStart()) || (position == SelectionEnd());
4893
4894
if ((!inDragDrop) || !(0 == positionWasInSelection) ||
4895
(positionOnEdgeOfSelection && !moving)) {
4896
4897
int selStart = SelectionStart();
4898
int selEnd = SelectionEnd();
4899
4900
pdoc->BeginUndoAction();
4901
4902
int positionAfterDeletion = position;
4903
if (inDragDrop && moving) {
4904
// Remove dragged out text
4905
if (rectangular || selType == selLines) {
4906
SelectionLineIterator lineIterator(this);
4907
while (lineIterator.Iterate()) {
4908
if (position >= lineIterator.startPos) {
4909
if (position > lineIterator.endPos) {
4910
positionAfterDeletion -= lineIterator.endPos - lineIterator.startPos;
4911
} else {
4912
positionAfterDeletion -= position - lineIterator.startPos;
4913
}
4914
}
4915
}
4916
} else {
4917
if (position > selStart) {
4918
positionAfterDeletion -= selEnd - selStart;
4919
}
4920
}
4921
ClearSelection();
4922
}
4923
position = positionAfterDeletion;
4924
4925
if (rectangular) {
4926
PasteRectangular(position, value, istrlen(value));
4927
pdoc->EndUndoAction();
4928
// Should try to select new rectangle but it may not be a rectangle now so just select the drop position
4929
SetEmptySelection(position);
4930
} else {
4931
position = MovePositionOutsideChar(position, currentPos - position);
4932
if (pdoc->InsertString(position, value)) {
4933
SetSelection(position + istrlen(value), position);
4934
}
4935
pdoc->EndUndoAction();
4936
}
4937
} else if (inDragDrop) {
4938
SetEmptySelection(position);
4939
}
4940
}
4941
4942
/**
4943
* @return -1 if given position is before the selection,
4944
* 1 if position is after the selection,
4945
* 0 if position is inside the selection,
4946
*/
4947
int Editor::PositionInSelection(int pos) {
4948
pos = MovePositionOutsideChar(pos, currentPos - pos);
4949
if (pos < SelectionStart()) {
4950
return -1;
4951
}
4952
if (pos > SelectionEnd()) {
4953
return 1;
4954
}
4955
if (selType == selStream) {
4956
return 0;
4957
} else {
4958
SelectionLineIterator lineIterator(this);
4959
lineIterator.SetAt(pdoc->LineFromPosition(pos));
4960
if (pos < lineIterator.startPos) {
4961
return -1;
4962
} else if (pos > lineIterator.endPos) {
4963
return 1;
4964
} else {
4965
return 0;
4966
}
4967
}
4968
}
4969
4970
bool Editor::PointInSelection(Point pt) {
4971
int pos = PositionFromLocation(pt);
4972
if (0 == PositionInSelection(pos)) {
4973
// Probably inside, but we must make a finer test
4974
int selStart, selEnd;
4975
if (selType == selStream) {
4976
selStart = SelectionStart();
4977
selEnd = SelectionEnd();
4978
} else {
4979
SelectionLineIterator lineIterator(this);
4980
lineIterator.SetAt(pdoc->LineFromPosition(pos));
4981
selStart = lineIterator.startPos;
4982
selEnd = lineIterator.endPos;
4983
}
4984
if (pos == selStart) {
4985
// see if just before selection
4986
Point locStart = LocationFromPosition(pos);
4987
if (pt.x < locStart.x) {
4988
return false;
4989
}
4990
}
4991
if (pos == selEnd) {
4992
// see if just after selection
4993
Point locEnd = LocationFromPosition(pos);
4994
if (pt.x > locEnd.x) {
4995
return false;
4996
}
4997
}
4998
return true;
4999
}
5000
return false;
5001
}
5002
5003
bool Editor::PointInSelMargin(Point pt) {
5004
// Really means: "Point in a margin"
5005
if (vs.fixedColumnWidth > 0) { // There is a margin
5006
PRectangle rcSelMargin = GetClientRectangle();
5007
rcSelMargin.right = vs.fixedColumnWidth - vs.leftMarginWidth;
5008
return rcSelMargin.Contains(pt);
5009
} else {
5010
return false;
5011
}
5012
}
5013
5014
void Editor::LineSelection(int lineCurrent_, int lineAnchor_) {
5015
if (lineAnchor_ < lineCurrent_) {
5016
SetSelection(pdoc->LineStart(lineCurrent_ + 1),
5017
pdoc->LineStart(lineAnchor_));
5018
} else if (lineAnchor_ > lineCurrent_) {
5019
SetSelection(pdoc->LineStart(lineCurrent_),
5020
pdoc->LineStart(lineAnchor_ + 1));
5021
} else { // Same line, select it
5022
SetSelection(pdoc->LineStart(lineAnchor_ + 1),
5023
pdoc->LineStart(lineAnchor_));
5024
}
5025
}
5026
5027
void Editor::DwellEnd(bool mouseMoved) {
5028
if (mouseMoved)
5029
ticksToDwell = dwellDelay;
5030
else
5031
ticksToDwell = SC_TIME_FOREVER;
5032
if (dwelling && (dwellDelay < SC_TIME_FOREVER)) {
5033
dwelling = false;
5034
NotifyDwelling(ptMouseLast, dwelling);
5035
}
5036
}
5037
5038
void Editor::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
5039
//Platform::DebugPrintf("Scintilla:ButtonDown %d %d = %d alt=%d\n", curTime, lastClickTime, curTime - lastClickTime, alt);
5040
ptMouseLast = pt;
5041
int newPos = PositionFromLocation(pt);
5042
newPos = MovePositionOutsideChar(newPos, currentPos - newPos);
5043
inDragDrop = false;
5044
moveExtendsSelection = false;
5045
5046
bool processed = NotifyMarginClick(pt, shift, ctrl, alt);
5047
if (processed)
5048
return;
5049
5050
bool inSelMargin = PointInSelMargin(pt);
5051
if (shift & !inSelMargin) {
5052
SetSelection(newPos);
5053
}
5054
if (((curTime - lastClickTime) < Platform::DoubleClickTime()) && Close(pt, lastClick)) {
5055
//Platform::DebugPrintf("Double click %d %d = %d\n", curTime, lastClickTime, curTime - lastClickTime);
5056
SetMouseCapture(true);
5057
SetEmptySelection(newPos);
5058
bool doubleClick = false;
5059
// Stop mouse button bounce changing selection type
5060
if (!Platform::MouseButtonBounce() || curTime != lastClickTime) {
5061
if (selectionType == selChar) {
5062
selectionType = selWord;
5063
doubleClick = true;
5064
} else if (selectionType == selWord) {
5065
selectionType = selLine;
5066
} else {
5067
selectionType = selChar;
5068
originalAnchorPos = currentPos;
5069
}
5070
}
5071
5072
if (selectionType == selWord) {
5073
if (currentPos >= originalAnchorPos) { // Moved forward
5074
SetSelection(pdoc->ExtendWordSelect(currentPos, 1),
5075
pdoc->ExtendWordSelect(originalAnchorPos, -1));
5076
} else { // Moved backward
5077
SetSelection(pdoc->ExtendWordSelect(currentPos, -1),
5078
pdoc->ExtendWordSelect(originalAnchorPos, 1));
5079
}
5080
} else if (selectionType == selLine) {
5081
lineAnchor = LineFromLocation(pt);
5082
SetSelection(pdoc->LineStart(lineAnchor + 1), pdoc->LineStart(lineAnchor));
5083
//Platform::DebugPrintf("Triple click: %d - %d\n", anchor, currentPos);
5084
} else {
5085
SetEmptySelection(currentPos);
5086
}
5087
//Platform::DebugPrintf("Double click: %d - %d\n", anchor, currentPos);
5088
if (doubleClick) {
5089
NotifyDoubleClick(pt, shift);
5090
if (PositionIsHotspot(newPos))
5091
NotifyHotSpotDoubleClicked(newPos, shift, ctrl, alt);
5092
}
5093
} else { // Single click
5094
if (inSelMargin) {
5095
selType = selStream;
5096
if (ctrl) {
5097
SelectAll();
5098
lastClickTime = curTime;
5099
return;
5100
}
5101
if (!shift) {
5102
lineAnchor = LineFromLocation(pt);
5103
// Single click in margin: select whole line
5104
LineSelection(lineAnchor, lineAnchor);
5105
SetSelection(pdoc->LineStart(lineAnchor + 1),
5106
pdoc->LineStart(lineAnchor));
5107
} else {
5108
// Single shift+click in margin: select from line anchor to clicked line
5109
if (anchor > currentPos)
5110
lineAnchor = pdoc->LineFromPosition(anchor - 1);
5111
else
5112
lineAnchor = pdoc->LineFromPosition(anchor);
5113
int lineStart = LineFromLocation(pt);
5114
LineSelection(lineStart, lineAnchor);
5115
//lineAnchor = lineStart; // Keep the same anchor for ButtonMove
5116
}
5117
5118
SetDragPosition(invalidPosition);
5119
SetMouseCapture(true);
5120
selectionType = selLine;
5121
} else {
5122
if (PointIsHotspot(pt)) {
5123
NotifyHotSpotClicked(newPos, shift, ctrl, alt);
5124
}
5125
if (!shift) {
5126
inDragDrop = PointInSelection(pt) && !SelectionEmpty();
5127
}
5128
if (inDragDrop) {
5129
SetMouseCapture(false);
5130
SetDragPosition(newPos);
5131
CopySelectionRange(&drag);
5132
StartDrag();
5133
} else {
5134
SetDragPosition(invalidPosition);
5135
SetMouseCapture(true);
5136
if (!shift) {
5137
SetEmptySelection(newPos);
5138
}
5139
selType = alt ? selRectangle : selStream;
5140
selectionType = selChar;
5141
originalAnchorPos = currentPos;
5142
SetRectangularRange();
5143
}
5144
}
5145
}
5146
lastClickTime = curTime;
5147
lastXChosen = pt.x;
5148
ShowCaretAtCurrentPosition();
5149
}
5150
5151
bool Editor::PositionIsHotspot(int position) {
5152
return vs.styles[pdoc->StyleAt(position) & pdoc->stylingBitsMask].hotspot;
5153
}
5154
5155
bool Editor::PointIsHotspot(Point pt) {
5156
int pos = PositionFromLocationClose(pt);
5157
if (pos == INVALID_POSITION)
5158
return false;
5159
return PositionIsHotspot(pos);
5160
}
5161
5162
void Editor::SetHotSpotRange(Point *pt) {
5163
if (pt) {
5164
int pos = PositionFromLocation(*pt);
5165
5166
// If we don't limit this to word characters then the
5167
// range can encompass more than the run range and then
5168
// the underline will not be drawn properly.
5169
int hsStart_ = pdoc->ExtendStyleRange(pos, -1, vs.hotspotSingleLine);
5170
int hsEnd_ = pdoc->ExtendStyleRange(pos, 1, vs.hotspotSingleLine);
5171
5172
// Only invalidate the range if the hotspot range has changed...
5173
if (hsStart_ != hsStart || hsEnd_ != hsEnd) {
5174
if (hsStart != -1) {
5175
InvalidateRange(hsStart, hsEnd);
5176
}
5177
hsStart = hsStart_;
5178
hsEnd = hsEnd_;
5179
InvalidateRange(hsStart, hsEnd);
5180
}
5181
} else {
5182
if (hsStart != -1) {
5183
int hsStart_ = hsStart;
5184
int hsEnd_ = hsEnd;
5185
hsStart = -1;
5186
hsEnd = -1;
5187
InvalidateRange(hsStart_, hsEnd_);
5188
} else {
5189
hsStart = -1;
5190
hsEnd = -1;
5191
}
5192
}
5193
}
5194
5195
void Editor::GetHotSpotRange(int& hsStart_, int& hsEnd_) {
5196
hsStart_ = hsStart;
5197
hsEnd_ = hsEnd;
5198
}
5199
5200
void Editor::ButtonMove(Point pt) {
5201
if ((ptMouseLast.x != pt.x) || (ptMouseLast.y != pt.y)) {
5202
DwellEnd(true);
5203
}
5204
ptMouseLast = pt;
5205
//Platform::DebugPrintf("Move %d %d\n", pt.x, pt.y);
5206
if (HaveMouseCapture()) {
5207
5208
// Slow down autoscrolling/selection
5209
autoScrollTimer.ticksToWait -= timer.tickSize;
5210
if (autoScrollTimer.ticksToWait > 0)
5211
return;
5212
autoScrollTimer.ticksToWait = autoScrollDelay;
5213
5214
// Adjust selection
5215
int movePos = PositionFromLocation(pt);
5216
movePos = MovePositionOutsideChar(movePos, currentPos - movePos);
5217
if (posDrag >= 0) {
5218
SetDragPosition(movePos);
5219
} else {
5220
if (selectionType == selChar) {
5221
SetSelection(movePos);
5222
} else if (selectionType == selWord) {
5223
// Continue selecting by word
5224
if (movePos == originalAnchorPos) { // Didn't move
5225
// No need to do anything. Previously this case was lumped
5226
// in with "Moved forward", but that can be harmful in this
5227
// case: a handler for the NotifyDoubleClick re-adjusts
5228
// the selection for a fancier definition of "word" (for
5229
// example, in Perl it is useful to include the leading
5230
// '$', '%' or '@' on variables for word selection). In this
5231
// the ButtonMove() called via Tick() for auto-scrolling
5232
// could result in the fancier word selection adjustment
5233
// being unmade.
5234
} else if (movePos > originalAnchorPos) { // Moved forward
5235
SetSelection(pdoc->ExtendWordSelect(movePos, 1),
5236
pdoc->ExtendWordSelect(originalAnchorPos, -1));
5237
} else { // Moved backward
5238
SetSelection(pdoc->ExtendWordSelect(movePos, -1),
5239
pdoc->ExtendWordSelect(originalAnchorPos, 1));
5240
}
5241
} else {
5242
// Continue selecting by line
5243
int lineMove = LineFromLocation(pt);
5244
LineSelection(lineMove, lineAnchor);
5245
}
5246
}
5247
// While dragging to make rectangular selection, we don't want the current
5248
// position to jump to the end of smaller or empty lines.
5249
//xEndSelect = pt.x - vs.fixedColumnWidth + xOffset;
5250
xEndSelect = XFromPosition(movePos);
5251
5252
// Autoscroll
5253
PRectangle rcClient = GetClientRectangle();
5254
if (pt.y > rcClient.bottom) {
5255
int lineMove = cs.DisplayFromDoc(LineFromLocation(pt));
5256
if (lineMove < 0) {
5257
lineMove = cs.DisplayFromDoc(pdoc->LinesTotal() - 1);
5258
}
5259
ScrollTo(lineMove - LinesOnScreen() + 5);
5260
Redraw();
5261
} else if (pt.y < rcClient.top) {
5262
int lineMove = cs.DisplayFromDoc(LineFromLocation(pt));
5263
ScrollTo(lineMove - 5);
5264
Redraw();
5265
}
5266
EnsureCaretVisible(false, false, true);
5267
5268
if (hsStart != -1 && !PositionIsHotspot(movePos))
5269
SetHotSpotRange(NULL);
5270
5271
} else {
5272
if (vs.fixedColumnWidth > 0) { // There is a margin
5273
if (PointInSelMargin(pt)) {
5274
DisplayCursor(Window::cursorReverseArrow);
5275
return; // No need to test for selection
5276
}
5277
}
5278
// Display regular (drag) cursor over selection
5279
if (PointInSelection(pt) && !SelectionEmpty()) {
5280
DisplayCursor(Window::cursorArrow);
5281
} else if (PointIsHotspot(pt)) {
5282
DisplayCursor(Window::cursorHand);
5283
SetHotSpotRange(&pt);
5284
} else {
5285
DisplayCursor(Window::cursorText);
5286
SetHotSpotRange(NULL);
5287
}
5288
}
5289
}
5290
5291
void Editor::ButtonUp(Point pt, unsigned int curTime, bool ctrl) {
5292
//Platform::DebugPrintf("ButtonUp %d\n", HaveMouseCapture());
5293
if (HaveMouseCapture()) {
5294
if (PointInSelMargin(pt)) {
5295
DisplayCursor(Window::cursorReverseArrow);
5296
} else {
5297
DisplayCursor(Window::cursorText);
5298
SetHotSpotRange(NULL);
5299
}
5300
ptMouseLast = pt;
5301
SetMouseCapture(false);
5302
int newPos = PositionFromLocation(pt);
5303
newPos = MovePositionOutsideChar(newPos, currentPos - newPos);
5304
if (inDragDrop) {
5305
int selStart = SelectionStart();
5306
int selEnd = SelectionEnd();
5307
if (selStart < selEnd) {
5308
if (drag.len) {
5309
if (ctrl) {
5310
if (pdoc->InsertString(newPos, drag.s, drag.len)) {
5311
SetSelection(newPos, newPos + drag.len);
5312
}
5313
} else if (newPos < selStart) {
5314
pdoc->DeleteChars(selStart, drag.len);
5315
if (pdoc->InsertString(newPos, drag.s, drag.len)) {
5316
SetSelection(newPos, newPos + drag.len);
5317
}
5318
} else if (newPos > selEnd) {
5319
pdoc->DeleteChars(selStart, drag.len);
5320
newPos -= drag.len;
5321
if (pdoc->InsertString(newPos, drag.s, drag.len)) {
5322
SetSelection(newPos, newPos + drag.len);
5323
}
5324
} else {
5325
SetEmptySelection(newPos);
5326
}
5327
drag.Free();
5328
}
5329
selectionType = selChar;
5330
}
5331
} else {
5332
if (selectionType == selChar) {
5333
SetSelection(newPos);
5334
}
5335
}
5336
SetRectangularRange();
5337
lastClickTime = curTime;
5338
lastClick = pt;
5339
lastXChosen = pt.x;
5340
if (selType == selStream) {
5341
SetLastXChosen();
5342
}
5343
inDragDrop = false;
5344
EnsureCaretVisible(false);
5345
}
5346
}
5347
5348
// Called frequently to perform background UI including
5349
// caret blinking and automatic scrolling.
5350
void Editor::Tick() {
5351
if (HaveMouseCapture()) {
5352
// Auto scroll
5353
ButtonMove(ptMouseLast);
5354
}
5355
if (caret.period > 0) {
5356
timer.ticksToWait -= timer.tickSize;
5357
if (timer.ticksToWait <= 0) {
5358
caret.on = !caret.on;
5359
timer.ticksToWait = caret.period;
5360
if (caret.active) {
5361
InvalidateCaret();
5362
}
5363
}
5364
}
5365
if ((dwellDelay < SC_TIME_FOREVER) &&
5366
(ticksToDwell > 0) &&
5367
(!HaveMouseCapture())) {
5368
ticksToDwell -= timer.tickSize;
5369
if (ticksToDwell <= 0) {
5370
dwelling = true;
5371
NotifyDwelling(ptMouseLast, dwelling);
5372
}
5373
}
5374
}
5375
5376
bool Editor::Idle() {
5377
5378
bool idleDone;
5379
5380
bool wrappingDone = (wrapState == eWrapNone) || (!backgroundWrapEnabled);
5381
5382
if (!wrappingDone) {
5383
// Wrap lines during idle.
5384
WrapLines(false, -1);
5385
// No more wrapping
5386
if (docLineLastWrapped == docLastLineToWrap)
5387
wrappingDone = true;
5388
}
5389
5390
// Add more idle things to do here, but make sure idleDone is
5391
// set correctly before the function returns. returning
5392
// false will stop calling this idle funtion until SetIdle() is
5393
// called again.
5394
5395
idleDone = wrappingDone; // && thatDone && theOtherThingDone...
5396
5397
return !idleDone;
5398
}
5399
5400
void Editor::SetFocusState(bool focusState) {
5401
hasFocus = focusState;
5402
NotifyFocus(hasFocus);
5403
if (hasFocus) {
5404
ShowCaretAtCurrentPosition();
5405
} else {
5406
CancelModes();
5407
DropCaret();
5408
}
5409
}
5410
5411
bool Editor::PaintContains(PRectangle rc) {
5412
return rcPaint.Contains(rc);
5413
}
5414
5415
bool Editor::PaintContainsMargin() {
5416
PRectangle rcSelMargin = GetClientRectangle();
5417
rcSelMargin.right = vs.fixedColumnWidth;
5418
return PaintContains(rcSelMargin);
5419
}
5420
5421
void Editor::CheckForChangeOutsidePaint(Range r) {
5422
if (paintState == painting && !paintingAllText) {
5423
//Platform::DebugPrintf("Checking range in paint %d-%d\n", r.start, r.end);
5424
if (!r.Valid())
5425
return;
5426
5427
PRectangle rcRange = RectangleFromRange(r.start, r.end);
5428
PRectangle rcText = GetTextRectangle();
5429
if (rcRange.top < rcText.top) {
5430
rcRange.top = rcText.top;
5431
}
5432
if (rcRange.bottom > rcText.bottom) {
5433
rcRange.bottom = rcText.bottom;
5434
}
5435
5436
if (!PaintContains(rcRange)) {
5437
AbandonPaint();
5438
}
5439
}
5440
}
5441
5442
void Editor::SetBraceHighlight(Position pos0, Position pos1, int matchStyle) {
5443
if ((pos0 != braces[0]) || (pos1 != braces[1]) || (matchStyle != bracesMatchStyle)) {
5444
if ((braces[0] != pos0) || (matchStyle != bracesMatchStyle)) {
5445
CheckForChangeOutsidePaint(Range(braces[0]));
5446
CheckForChangeOutsidePaint(Range(pos0));
5447
braces[0] = pos0;
5448
}
5449
if ((braces[1] != pos1) || (matchStyle != bracesMatchStyle)) {
5450
CheckForChangeOutsidePaint(Range(braces[1]));
5451
CheckForChangeOutsidePaint(Range(pos1));
5452
braces[1] = pos1;
5453
}
5454
bracesMatchStyle = matchStyle;
5455
if (paintState == notPainting) {
5456
Redraw();
5457
}
5458
}
5459
}
5460
5461
void Editor::SetDocPointer(Document *document) {
5462
//Platform::DebugPrintf("** %x setdoc to %x\n", pdoc, document);
5463
pdoc->RemoveWatcher(this, 0);
5464
pdoc->Release();
5465
if (document == NULL) {
5466
pdoc = new Document();
5467
} else {
5468
pdoc = document;
5469
}
5470
pdoc->AddRef();
5471
5472
// Ensure all positions within document
5473
selType = selStream;
5474
currentPos = 0;
5475
anchor = 0;
5476
targetStart = 0;
5477
targetEnd = 0;
5478
5479
braces[0] = invalidPosition;
5480
braces[1] = invalidPosition;
5481
5482
// Reset the contraction state to fully shown.
5483
cs.Clear();
5484
cs.InsertLines(0, pdoc->LinesTotal() - 1);
5485
llc.Deallocate();
5486
NeedWrapping();
5487
5488
pdoc->AddWatcher(this, 0);
5489
SetScrollBars();
5490
Redraw();
5491
}
5492
5493
/**
5494
* Recursively expand a fold, making lines visible except where they have an unexpanded parent.
5495
*/
5496
void Editor::Expand(int &line, bool doExpand) {
5497
int lineMaxSubord = pdoc->GetLastChild(line);
5498
line++;
5499
while (line <= lineMaxSubord) {
5500
if (doExpand)
5501
cs.SetVisible(line, line, true);
5502
int level = pdoc->GetLevel(line);
5503
if (level & SC_FOLDLEVELHEADERFLAG) {
5504
if (doExpand && cs.GetExpanded(line)) {
5505
Expand(line, true);
5506
} else {
5507
Expand(line, false);
5508
}
5509
} else {
5510
line++;
5511
}
5512
}
5513
}
5514
5515
void Editor::ToggleContraction(int line) {
5516
if (line >= 0) {
5517
if ((pdoc->GetLevel(line) & SC_FOLDLEVELHEADERFLAG) == 0) {
5518
line = pdoc->GetFoldParent(line);
5519
if (line < 0)
5520
return;
5521
}
5522
5523
if (cs.GetExpanded(line)) {
5524
int lineMaxSubord = pdoc->GetLastChild(line);
5525
cs.SetExpanded(line, 0);
5526
if (lineMaxSubord > line) {
5527
cs.SetVisible(line + 1, lineMaxSubord, false);
5528
5529
int lineCurrent = pdoc->LineFromPosition(currentPos);
5530
if (lineCurrent > line && lineCurrent <= lineMaxSubord) {
5531
// This does not re-expand the fold
5532
EnsureCaretVisible();
5533
}
5534
5535
SetScrollBars();
5536
Redraw();
5537
}
5538
5539
} else {
5540
if (!(cs.GetVisible(line))) {
5541
EnsureLineVisible(line, false);
5542
GoToLine(line);
5543
}
5544
cs.SetExpanded(line, 1);
5545
Expand(line, true);
5546
SetScrollBars();
5547
Redraw();
5548
}
5549
}
5550
}
5551
5552
/**
5553
* Recurse up from this line to find any folds that prevent this line from being visible
5554
* and unfold them all.
5555
*/
5556
void Editor::EnsureLineVisible(int lineDoc, bool enforcePolicy) {
5557
5558
// In case in need of wrapping to ensure DisplayFromDoc works.
5559
WrapLines(true, -1);
5560
5561
if (!cs.GetVisible(lineDoc)) {
5562
int lineParent = pdoc->GetFoldParent(lineDoc);
5563
if (lineParent >= 0) {
5564
if (lineDoc != lineParent)
5565
EnsureLineVisible(lineParent, enforcePolicy);
5566
if (!cs.GetExpanded(lineParent)) {
5567
cs.SetExpanded(lineParent, 1);
5568
Expand(lineParent, true);
5569
}
5570
}
5571
SetScrollBars();
5572
Redraw();
5573
}
5574
if (enforcePolicy) {
5575
int lineDisplay = cs.DisplayFromDoc(lineDoc);
5576
if (visiblePolicy & VISIBLE_SLOP) {
5577
if ((topLine > lineDisplay) || ((visiblePolicy & VISIBLE_STRICT) && (topLine + visibleSlop > lineDisplay))) {
5578
SetTopLine(Platform::Clamp(lineDisplay - visibleSlop, 0, MaxScrollPos()));
5579
SetVerticalScrollPos();
5580
Redraw();
5581
} else if ((lineDisplay > topLine + LinesOnScreen() - 1) ||
5582
((visiblePolicy & VISIBLE_STRICT) && (lineDisplay > topLine + LinesOnScreen() - 1 - visibleSlop))) {
5583
SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() + 1 + visibleSlop, 0, MaxScrollPos()));
5584
SetVerticalScrollPos();
5585
Redraw();
5586
}
5587
} else {
5588
if ((topLine > lineDisplay) || (lineDisplay > topLine + LinesOnScreen() - 1) || (visiblePolicy & VISIBLE_STRICT)) {
5589
SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() / 2 + 1, 0, MaxScrollPos()));
5590
SetVerticalScrollPos();
5591
Redraw();
5592
}
5593
}
5594
}
5595
}
5596
5597
int Editor::ReplaceTarget(bool replacePatterns, const char *text, int length) {
5598
pdoc->BeginUndoAction();
5599
if (length == -1)
5600
length = istrlen(text);
5601
if (replacePatterns) {
5602
text = pdoc->SubstituteByPosition(text, &length);
5603
if (!text)
5604
return 0;
5605
}
5606
if (targetStart != targetEnd)
5607
pdoc->DeleteChars(targetStart, targetEnd - targetStart);
5608
targetEnd = targetStart;
5609
pdoc->InsertString(targetStart, text, length);
5610
targetEnd = targetStart + length;
5611
pdoc->EndUndoAction();
5612
return length;
5613
}
5614
5615
bool Editor::IsUnicodeMode() const {
5616
return pdoc && (SC_CP_UTF8 == pdoc->dbcsCodePage);
5617
}
5618
5619
int Editor::CodePage() const {
5620
if (pdoc)
5621
return pdoc->dbcsCodePage;
5622
else
5623
return 0;
5624
}
5625
5626
int Editor::WrapCount(int line) {
5627
AutoSurface surface(this);
5628
AutoLineLayout ll(llc, RetrieveLineLayout(line));
5629
5630
if (surface && ll) {
5631
LayoutLine(line, surface, vs, ll, wrapWidth);
5632
return ll->lines;
5633
} else {
5634
return 1;
5635
}
5636
}
5637
5638
static bool ValidMargin(unsigned long wParam) {
5639
return wParam < ViewStyle::margins;
5640
}
5641
5642
static char *CharPtrFromSPtr(sptr_t lParam) {
5643
return reinterpret_cast<char *>(lParam);
5644
}
5645
5646
sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
5647
//Platform::DebugPrintf("S start wnd proc %d %d %d\n",iMessage, wParam, lParam);
5648
5649
// Optional macro recording hook
5650
if (recordingMacro)
5651
NotifyMacroRecord(iMessage, wParam, lParam);
5652
5653
switch (iMessage) {
5654
5655
case SCI_GETTEXT: {
5656
if (lParam == 0)
5657
return pdoc->Length() + 1;
5658
if (wParam == 0)
5659
return 0;
5660
char *ptr = CharPtrFromSPtr(lParam);
5661
unsigned int iChar = 0;
5662
for (; iChar < wParam - 1; iChar++)
5663
ptr[iChar] = pdoc->CharAt(iChar);
5664
ptr[iChar] = '\0';
5665
return iChar;
5666
}
5667
5668
case SCI_SETTEXT: {
5669
if (lParam == 0)
5670
return 0;
5671
pdoc->BeginUndoAction();
5672
pdoc->DeleteChars(0, pdoc->Length());
5673
SetEmptySelection(0);
5674
pdoc->InsertString(0, CharPtrFromSPtr(lParam));
5675
pdoc->EndUndoAction();
5676
return 1;
5677
}
5678
5679
case SCI_GETTEXTLENGTH:
5680
return pdoc->Length();
5681
5682
case SCI_CUT:
5683
Cut();
5684
SetLastXChosen();
5685
break;
5686
5687
case SCI_COPY:
5688
Copy();
5689
break;
5690
5691
case SCI_COPYRANGE:
5692
CopyRangeToClipboard(wParam, lParam);
5693
break;
5694
5695
case SCI_COPYTEXT:
5696
CopyText(wParam, CharPtrFromSPtr(lParam));
5697
break;
5698
5699
case SCI_PASTE:
5700
Paste();
5701
if (!caretSticky) {
5702
SetLastXChosen();
5703
}
5704
EnsureCaretVisible();
5705
break;
5706
5707
case SCI_CLEAR:
5708
Clear();
5709
SetLastXChosen();
5710
EnsureCaretVisible();
5711
break;
5712
5713
case SCI_UNDO:
5714
Undo();
5715
SetLastXChosen();
5716
break;
5717
5718
case SCI_CANUNDO:
5719
return (pdoc->CanUndo() && !pdoc->IsReadOnly()) ? 1 : 0;
5720
5721
case SCI_EMPTYUNDOBUFFER:
5722
pdoc->DeleteUndoHistory();
5723
return 0;
5724
5725
case SCI_GETFIRSTVISIBLELINE:
5726
return topLine;
5727
5728
case SCI_GETLINE: { // Risk of overwriting the end of the buffer
5729
int lineStart = pdoc->LineStart(wParam);
5730
int lineEnd = pdoc->LineStart(wParam + 1);
5731
if (lParam == 0) {
5732
return lineEnd - lineStart;
5733
}
5734
char *ptr = CharPtrFromSPtr(lParam);
5735
int iPlace = 0;
5736
for (int iChar = lineStart; iChar < lineEnd; iChar++) {
5737
ptr[iPlace++] = pdoc->CharAt(iChar);
5738
}
5739
return iPlace;
5740
}
5741
5742
case SCI_GETLINECOUNT:
5743
if (pdoc->LinesTotal() == 0)
5744
return 1;
5745
else
5746
return pdoc->LinesTotal();
5747
5748
case SCI_GETMODIFY:
5749
return !pdoc->IsSavePoint();
5750
5751
case SCI_SETSEL: {
5752
int nStart = static_cast<int>(wParam);
5753
int nEnd = static_cast<int>(lParam);
5754
if (nEnd < 0)
5755
nEnd = pdoc->Length();
5756
if (nStart < 0)
5757
nStart = nEnd; // Remove selection
5758
selType = selStream;
5759
SetSelection(nEnd, nStart);
5760
EnsureCaretVisible();
5761
}
5762
break;
5763
5764
case SCI_GETSELTEXT: {
5765
if (lParam == 0) {
5766
if (selType == selStream) {
5767
return 1 + SelectionEnd() - SelectionStart();
5768
} else {
5769
// TODO: why is selLines handled the slow way?
5770
int size = 0;
5771
int extraCharsPerLine = 0;
5772
if (selType != selLines)
5773
extraCharsPerLine = (pdoc->eolMode == SC_EOL_CRLF) ? 2 : 1;
5774
SelectionLineIterator lineIterator(this);
5775
while (lineIterator.Iterate()) {
5776
size += lineIterator.endPos + extraCharsPerLine - lineIterator.startPos;
5777
}
5778
5779
return 1 + size;
5780
}
5781
}
5782
SelectionText selectedText;
5783
CopySelectionRange(&selectedText);
5784
char *ptr = CharPtrFromSPtr(lParam);
5785
int iChar = 0;
5786
if (selectedText.len) {
5787
for (; iChar < selectedText.len; iChar++)
5788
ptr[iChar] = selectedText.s[iChar];
5789
} else {
5790
ptr[0] = '\0';
5791
}
5792
return iChar;
5793
}
5794
5795
case SCI_LINEFROMPOSITION:
5796
if (static_cast<int>(wParam) < 0)
5797
return 0;
5798
return pdoc->LineFromPosition(wParam);
5799
5800
case SCI_POSITIONFROMLINE:
5801
if (static_cast<int>(wParam) < 0)
5802
wParam = pdoc->LineFromPosition(SelectionStart());
5803
if (wParam == 0)
5804
return 0; // Even if there is no text, there is a first line that starts at 0
5805
if (static_cast<int>(wParam) > pdoc->LinesTotal())
5806
return -1;
5807
//if (wParam > pdoc->LineFromPosition(pdoc->Length())) // Useful test, anyway...
5808
// return -1;
5809
return pdoc->LineStart(wParam);
5810
5811
// Replacement of the old Scintilla interpretation of EM_LINELENGTH
5812
case SCI_LINELENGTH:
5813
if ((static_cast<int>(wParam) < 0) ||
5814
(static_cast<int>(wParam) > pdoc->LineFromPosition(pdoc->Length())))
5815
return 0;
5816
return pdoc->LineStart(wParam + 1) - pdoc->LineStart(wParam);
5817
5818
case SCI_REPLACESEL: {
5819
if (lParam == 0)
5820
return 0;
5821
pdoc->BeginUndoAction();
5822
ClearSelection();
5823
char *replacement = CharPtrFromSPtr(lParam);
5824
pdoc->InsertString(currentPos, replacement);
5825
pdoc->EndUndoAction();
5826
SetEmptySelection(currentPos + istrlen(replacement));
5827
EnsureCaretVisible();
5828
}
5829
break;
5830
5831
case SCI_SETTARGETSTART:
5832
targetStart = wParam;
5833
break;
5834
5835
case SCI_GETTARGETSTART:
5836
return targetStart;
5837
5838
case SCI_SETTARGETEND:
5839
targetEnd = wParam;
5840
break;
5841
5842
case SCI_GETTARGETEND:
5843
return targetEnd;
5844
5845
case SCI_TARGETFROMSELECTION:
5846
if (currentPos < anchor) {
5847
targetStart = currentPos;
5848
targetEnd = anchor;
5849
} else {
5850
targetStart = anchor;
5851
targetEnd = currentPos;
5852
}
5853
break;
5854
5855
case SCI_REPLACETARGET:
5856
PLATFORM_ASSERT(lParam);
5857
return ReplaceTarget(false, CharPtrFromSPtr(lParam), wParam);
5858
5859
case SCI_REPLACETARGETRE:
5860
PLATFORM_ASSERT(lParam);
5861
return ReplaceTarget(true, CharPtrFromSPtr(lParam), wParam);
5862
5863
case SCI_SEARCHINTARGET:
5864
PLATFORM_ASSERT(lParam);
5865
return SearchInTarget(CharPtrFromSPtr(lParam), wParam);
5866
5867
case SCI_SETSEARCHFLAGS:
5868
searchFlags = wParam;
5869
break;
5870
5871
case SCI_GETSEARCHFLAGS:
5872
return searchFlags;
5873
5874
case SCI_POSITIONBEFORE:
5875
return pdoc->MovePositionOutsideChar(wParam-1, -1, true);
5876
5877
case SCI_POSITIONAFTER:
5878
return pdoc->MovePositionOutsideChar(wParam+1, 1, true);
5879
5880
case SCI_LINESCROLL:
5881
ScrollTo(topLine + lParam);
5882
HorizontalScrollTo(xOffset + wParam * vs.spaceWidth);
5883
return 1;
5884
5885
case SCI_SETXOFFSET:
5886
xOffset = wParam;
5887
SetHorizontalScrollPos();
5888
Redraw();
5889
break;
5890
5891
case SCI_GETXOFFSET:
5892
return xOffset;
5893
5894
case SCI_CHOOSECARETX:
5895
SetLastXChosen();
5896
break;
5897
5898
case SCI_SCROLLCARET:
5899
EnsureCaretVisible();
5900
break;
5901
5902
case SCI_SETREADONLY:
5903
pdoc->SetReadOnly(wParam != 0);
5904
return 1;
5905
5906
case SCI_GETREADONLY:
5907
return pdoc->IsReadOnly();
5908
5909
case SCI_CANPASTE:
5910
return CanPaste();
5911
5912
case SCI_POINTXFROMPOSITION:
5913
if (lParam < 0) {
5914
return 0;
5915
} else {
5916
Point pt = LocationFromPosition(lParam);
5917
return pt.x;
5918
}
5919
5920
case SCI_POINTYFROMPOSITION:
5921
if (lParam < 0) {
5922
return 0;
5923
} else {
5924
Point pt = LocationFromPosition(lParam);
5925
return pt.y;
5926
}
5927
5928
case SCI_FINDTEXT:
5929
return FindText(wParam, lParam);
5930
5931
case SCI_GETTEXTRANGE: {
5932
if (lParam == 0)
5933
return 0;
5934
TextRange *tr = reinterpret_cast<TextRange *>(lParam);
5935
int cpMax = tr->chrg.cpMax;
5936
if (cpMax == -1)
5937
cpMax = pdoc->Length();
5938
PLATFORM_ASSERT(cpMax <= pdoc->Length());
5939
int len = cpMax - tr->chrg.cpMin; // No -1 as cpMin and cpMax are referring to inter character positions
5940
pdoc->GetCharRange(tr->lpstrText, tr->chrg.cpMin, len);
5941
// Spec says copied text is terminated with a NUL
5942
tr->lpstrText[len] = '\0';
5943
return len; // Not including NUL
5944
}
5945
5946
case SCI_HIDESELECTION:
5947
hideSelection = wParam != 0;
5948
Redraw();
5949
break;
5950
5951
case SCI_FORMATRANGE:
5952
return FormatRange(wParam != 0, reinterpret_cast<RangeToFormat *>(lParam));
5953
5954
case SCI_GETMARGINLEFT:
5955
return vs.leftMarginWidth;
5956
5957
case SCI_GETMARGINRIGHT:
5958
return vs.rightMarginWidth;
5959
5960
case SCI_SETMARGINLEFT:
5961
vs.leftMarginWidth = lParam;
5962
InvalidateStyleRedraw();
5963
break;
5964
5965
case SCI_SETMARGINRIGHT:
5966
vs.rightMarginWidth = lParam;
5967
InvalidateStyleRedraw();
5968
break;
5969
5970
// Control specific mesages
5971
5972
case SCI_ADDTEXT: {
5973
if (lParam == 0)
5974
return 0;
5975
pdoc->InsertString(CurrentPosition(), CharPtrFromSPtr(lParam), wParam);
5976
SetEmptySelection(currentPos + wParam);
5977
return 0;
5978
}
5979
5980
case SCI_ADDSTYLEDTEXT: {
5981
if (lParam == 0)
5982
return 0;
5983
pdoc->InsertStyledString(CurrentPosition() * 2, CharPtrFromSPtr(lParam), wParam);
5984
SetEmptySelection(currentPos + wParam / 2);
5985
return 0;
5986
}
5987
5988
case SCI_INSERTTEXT: {
5989
if (lParam == 0)
5990
return 0;
5991
int insertPos = wParam;
5992
if (static_cast<int>(wParam) == -1)
5993
insertPos = CurrentPosition();
5994
int newCurrent = CurrentPosition();
5995
char *sz = CharPtrFromSPtr(lParam);
5996
pdoc->InsertString(insertPos, sz);
5997
if (newCurrent > insertPos)
5998
newCurrent += istrlen(sz);
5999
SetEmptySelection(newCurrent);
6000
return 0;
6001
}
6002
6003
case SCI_APPENDTEXT:
6004
pdoc->InsertString(pdoc->Length(), CharPtrFromSPtr(lParam), wParam);
6005
return 0;
6006
6007
case SCI_CLEARALL:
6008
ClearAll();
6009
return 0;
6010
6011
case SCI_CLEARDOCUMENTSTYLE:
6012
ClearDocumentStyle();
6013
return 0;
6014
6015
case SCI_SETUNDOCOLLECTION:
6016
pdoc->SetUndoCollection(wParam != 0);
6017
return 0;
6018
6019
case SCI_GETUNDOCOLLECTION:
6020
return pdoc->IsCollectingUndo();
6021
6022
case SCI_BEGINUNDOACTION:
6023
pdoc->BeginUndoAction();
6024
return 0;
6025
6026
case SCI_ENDUNDOACTION:
6027
pdoc->EndUndoAction();
6028
return 0;
6029
6030
case SCI_GETCARETPERIOD:
6031
return caret.period;
6032
6033
case SCI_SETCARETPERIOD:
6034
caret.period = wParam;
6035
break;
6036
6037
case SCI_SETWORDCHARS: {
6038
pdoc->SetDefaultCharClasses(false);
6039
if (lParam == 0)
6040
return 0;
6041
pdoc->SetCharClasses(reinterpret_cast<unsigned char *>(lParam), Document::ccWord);
6042
}
6043
break;
6044
6045
case SCI_SETWHITESPACECHARS: {
6046
if (lParam == 0)
6047
return 0;
6048
pdoc->SetCharClasses(reinterpret_cast<unsigned char *>(lParam), Document::ccSpace);
6049
}
6050
break;
6051
6052
case SCI_SETCHARSDEFAULT:
6053
pdoc->SetDefaultCharClasses(true);
6054
break;
6055
6056
case SCI_GETLENGTH:
6057
return pdoc->Length();
6058
6059
case SCI_ALLOCATE:
6060
pdoc->Allocate(wParam);
6061
break;
6062
6063
case SCI_GETCHARAT:
6064
return pdoc->CharAt(wParam);
6065
6066
case SCI_SETCURRENTPOS:
6067
SetSelection(wParam, anchor);
6068
break;
6069
6070
case SCI_GETCURRENTPOS:
6071
return currentPos;
6072
6073
case SCI_SETANCHOR:
6074
SetSelection(currentPos, wParam);
6075
break;
6076
6077
case SCI_GETANCHOR:
6078
return anchor;
6079
6080
case SCI_SETSELECTIONSTART:
6081
SetSelection(Platform::Maximum(currentPos, wParam), wParam);
6082
break;
6083
6084
case SCI_GETSELECTIONSTART:
6085
return Platform::Minimum(anchor, currentPos);
6086
6087
case SCI_SETSELECTIONEND:
6088
SetSelection(wParam, Platform::Minimum(anchor, wParam));
6089
break;
6090
6091
case SCI_GETSELECTIONEND:
6092
return Platform::Maximum(anchor, currentPos);
6093
6094
case SCI_SETPRINTMAGNIFICATION:
6095
printMagnification = wParam;
6096
break;
6097
6098
case SCI_GETPRINTMAGNIFICATION:
6099
return printMagnification;
6100
6101
case SCI_SETPRINTCOLOURMODE:
6102
printColourMode = wParam;
6103
break;
6104
6105
case SCI_GETPRINTCOLOURMODE:
6106
return printColourMode;
6107
6108
case SCI_SETPRINTWRAPMODE:
6109
printWrapState = (wParam == SC_WRAP_WORD) ? eWrapWord : eWrapNone;
6110
break;
6111
6112
case SCI_GETPRINTWRAPMODE:
6113
return printWrapState;
6114
6115
case SCI_GETSTYLEAT:
6116
if (static_cast<int>(wParam) >= pdoc->Length())
6117
return 0;
6118
else
6119
return pdoc->StyleAt(wParam);
6120
6121
case SCI_REDO:
6122
Redo();
6123
break;
6124
6125
case SCI_SELECTALL:
6126
SelectAll();
6127
break;
6128
6129
case SCI_SETSAVEPOINT:
6130
pdoc->SetSavePoint();
6131
break;
6132
6133
case SCI_GETSTYLEDTEXT: {
6134
if (lParam == 0)
6135
return 0;
6136
TextRange *tr = reinterpret_cast<TextRange *>(lParam);
6137
int iPlace = 0;
6138
for (int iChar = tr->chrg.cpMin; iChar < tr->chrg.cpMax; iChar++) {
6139
tr->lpstrText[iPlace++] = pdoc->CharAt(iChar);
6140
tr->lpstrText[iPlace++] = pdoc->StyleAt(iChar);
6141
}
6142
tr->lpstrText[iPlace] = '\0';
6143
tr->lpstrText[iPlace + 1] = '\0';
6144
return iPlace;
6145
}
6146
6147
case SCI_CANREDO:
6148
return (pdoc->CanRedo() && !pdoc->IsReadOnly()) ? 1 : 0;
6149
6150
case SCI_MARKERLINEFROMHANDLE:
6151
return pdoc->LineFromHandle(wParam);
6152
6153
case SCI_MARKERDELETEHANDLE:
6154
pdoc->DeleteMarkFromHandle(wParam);
6155
break;
6156
6157
case SCI_GETVIEWWS:
6158
return vs.viewWhitespace;
6159
6160
case SCI_SETVIEWWS:
6161
vs.viewWhitespace = static_cast<WhiteSpaceVisibility>(wParam);
6162
Redraw();
6163
break;
6164
6165
case SCI_POSITIONFROMPOINT:
6166
return PositionFromLocation(Point(wParam, lParam));
6167
6168
case SCI_POSITIONFROMPOINTCLOSE:
6169
return PositionFromLocationClose(Point(wParam, lParam));
6170
6171
case SCI_GOTOLINE:
6172
GoToLine(wParam);
6173
break;
6174
6175
case SCI_GOTOPOS:
6176
SetEmptySelection(wParam);
6177
EnsureCaretVisible();
6178
Redraw();
6179
break;
6180
6181
case SCI_GETCURLINE: {
6182
int lineCurrentPos = pdoc->LineFromPosition(currentPos);
6183
int lineStart = pdoc->LineStart(lineCurrentPos);
6184
unsigned int lineEnd = pdoc->LineStart(lineCurrentPos + 1);
6185
if (lParam == 0) {
6186
return 1 + lineEnd - lineStart;
6187
}
6188
PLATFORM_ASSERT(wParam > 0);
6189
char *ptr = CharPtrFromSPtr(lParam);
6190
unsigned int iPlace = 0;
6191
for (unsigned int iChar = lineStart; iChar < lineEnd && iPlace < wParam - 1; iChar++) {
6192
ptr[iPlace++] = pdoc->CharAt(iChar);
6193
}
6194
ptr[iPlace] = '\0';
6195
return currentPos - lineStart;
6196
}
6197
6198
case SCI_GETENDSTYLED:
6199
return pdoc->GetEndStyled();
6200
6201
case SCI_GETEOLMODE:
6202
return pdoc->eolMode;
6203
6204
case SCI_SETEOLMODE:
6205
pdoc->eolMode = wParam;
6206
break;
6207
6208
case SCI_STARTSTYLING:
6209
pdoc->StartStyling(wParam, static_cast<char>(lParam));
6210
break;
6211
6212
case SCI_SETSTYLING:
6213
pdoc->SetStyleFor(wParam, static_cast<char>(lParam));
6214
break;
6215
6216
case SCI_SETSTYLINGEX: // Specify a complete styling buffer
6217
if (lParam == 0)
6218
return 0;
6219
pdoc->SetStyles(wParam, CharPtrFromSPtr(lParam));
6220
break;
6221
6222
case SCI_SETBUFFEREDDRAW:
6223
bufferedDraw = wParam != 0;
6224
break;
6225
6226
case SCI_GETBUFFEREDDRAW:
6227
return bufferedDraw;
6228
6229
case SCI_GETTWOPHASEDRAW:
6230
return twoPhaseDraw;
6231
6232
case SCI_SETTWOPHASEDRAW:
6233
twoPhaseDraw = wParam != 0;
6234
InvalidateStyleRedraw();
6235
break;
6236
6237
case SCI_SETTABWIDTH:
6238
if (wParam > 0) {
6239
pdoc->tabInChars = wParam;
6240
if (pdoc->indentInChars == 0)
6241
pdoc->actualIndentInChars = pdoc->tabInChars;
6242
}
6243
InvalidateStyleRedraw();
6244
break;
6245
6246
case SCI_GETTABWIDTH:
6247
return pdoc->tabInChars;
6248
6249
case SCI_SETINDENT:
6250
pdoc->indentInChars = wParam;
6251
if (pdoc->indentInChars != 0)
6252
pdoc->actualIndentInChars = pdoc->indentInChars;
6253
else
6254
pdoc->actualIndentInChars = pdoc->tabInChars;
6255
InvalidateStyleRedraw();
6256
break;
6257
6258
case SCI_GETINDENT:
6259
return pdoc->indentInChars;
6260
6261
case SCI_SETUSETABS:
6262
pdoc->useTabs = wParam != 0;
6263
InvalidateStyleRedraw();
6264
break;
6265
6266
case SCI_GETUSETABS:
6267
return pdoc->useTabs;
6268
6269
case SCI_SETLINEINDENTATION:
6270
pdoc->SetLineIndentation(wParam, lParam);
6271
break;
6272
6273
case SCI_GETLINEINDENTATION:
6274
return pdoc->GetLineIndentation(wParam);
6275
6276
case SCI_GETLINEINDENTPOSITION:
6277
return pdoc->GetLineIndentPosition(wParam);
6278
6279
case SCI_SETTABINDENTS:
6280
pdoc->tabIndents = wParam != 0;
6281
break;
6282
6283
case SCI_GETTABINDENTS:
6284
return pdoc->tabIndents;
6285
6286
case SCI_SETBACKSPACEUNINDENTS:
6287
pdoc->backspaceUnindents = wParam != 0;
6288
break;
6289
6290
case SCI_GETBACKSPACEUNINDENTS:
6291
return pdoc->backspaceUnindents;
6292
6293
case SCI_SETMOUSEDWELLTIME:
6294
dwellDelay = wParam;
6295
ticksToDwell = dwellDelay;
6296
break;
6297
6298
case SCI_GETMOUSEDWELLTIME:
6299
return dwellDelay;
6300
6301
case SCI_WORDSTARTPOSITION:
6302
return pdoc->ExtendWordSelect(wParam, -1, lParam != 0);
6303
6304
case SCI_WORDENDPOSITION:
6305
return pdoc->ExtendWordSelect(wParam, 1, lParam != 0);
6306
6307
case SCI_SETWRAPMODE:
6308
switch(wParam){
6309
case SC_WRAP_WORD:
6310
wrapState = eWrapWord;
6311
break;
6312
case SC_WRAP_CHAR:
6313
wrapState = eWrapChar;
6314
break;
6315
default:
6316
wrapState = eWrapNone;
6317
break;
6318
}
6319
xOffset = 0;
6320
InvalidateStyleRedraw();
6321
ReconfigureScrollBars();
6322
break;
6323
6324
case SCI_GETWRAPMODE:
6325
return wrapState;
6326
6327
case SCI_SETWRAPVISUALFLAGS:
6328
wrapVisualFlags = wParam;
6329
actualWrapVisualStartIndent = wrapVisualStartIndent;
6330
if ((wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (actualWrapVisualStartIndent == 0))
6331
actualWrapVisualStartIndent = 1; // must indent to show start visual
6332
InvalidateStyleRedraw();
6333
ReconfigureScrollBars();
6334
break;
6335
6336
case SCI_GETWRAPVISUALFLAGS:
6337
return wrapVisualFlags;
6338
6339
case SCI_SETWRAPVISUALFLAGSLOCATION:
6340
wrapVisualFlagsLocation = wParam;
6341
InvalidateStyleRedraw();
6342
break;
6343
6344
case SCI_GETWRAPVISUALFLAGSLOCATION:
6345
return wrapVisualFlagsLocation;
6346
6347
case SCI_SETWRAPSTARTINDENT:
6348
wrapVisualStartIndent = wParam;
6349
actualWrapVisualStartIndent = wrapVisualStartIndent;
6350
if ((wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (actualWrapVisualStartIndent == 0))
6351
actualWrapVisualStartIndent = 1; // must indent to show start visual
6352
InvalidateStyleRedraw();
6353
ReconfigureScrollBars();
6354
break;
6355
6356
case SCI_GETWRAPSTARTINDENT:
6357
return wrapVisualStartIndent;
6358
6359
case SCI_SETLAYOUTCACHE:
6360
llc.SetLevel(wParam);
6361
break;
6362
6363
case SCI_GETLAYOUTCACHE:
6364
return llc.GetLevel();
6365
6366
case SCI_SETSCROLLWIDTH:
6367
PLATFORM_ASSERT(wParam > 0);
6368
if ((wParam > 0) && (wParam != static_cast<unsigned int >(scrollWidth))) {
6369
scrollWidth = wParam;
6370
SetScrollBars();
6371
}
6372
break;
6373
6374
case SCI_GETSCROLLWIDTH:
6375
return scrollWidth;
6376
6377
case SCI_LINESJOIN:
6378
LinesJoin();
6379
break;
6380
6381
case SCI_LINESSPLIT:
6382
LinesSplit(wParam);
6383
break;
6384
6385
case SCI_TEXTWIDTH:
6386
PLATFORM_ASSERT(wParam <= STYLE_MAX);
6387
PLATFORM_ASSERT(lParam);
6388
return TextWidth(wParam, CharPtrFromSPtr(lParam));
6389
6390
case SCI_TEXTHEIGHT:
6391
return vs.lineHeight;
6392
6393
case SCI_SETENDATLASTLINE:
6394
PLATFORM_ASSERT((wParam == 0) || (wParam == 1));
6395
if (endAtLastLine != (wParam != 0)) {
6396
endAtLastLine = wParam != 0;
6397
SetScrollBars();
6398
}
6399
break;
6400
6401
case SCI_GETENDATLASTLINE:
6402
return endAtLastLine;
6403
6404
case SCI_SETCARETSTICKY:
6405
PLATFORM_ASSERT((wParam == 0) || (wParam == 1));
6406
if (caretSticky != (wParam != 0)) {
6407
caretSticky = wParam != 0;
6408
}
6409
break;
6410
6411
case SCI_GETCARETSTICKY:
6412
return caretSticky;
6413
6414
case SCI_TOGGLECARETSTICKY:
6415
caretSticky = !caretSticky;
6416
break;
6417
6418
case SCI_GETCOLUMN:
6419
return pdoc->GetColumn(wParam);
6420
6421
case SCI_FINDCOLUMN:
6422
return pdoc->FindColumn(wParam, lParam);
6423
6424
case SCI_SETHSCROLLBAR :
6425
if (horizontalScrollBarVisible != (wParam != 0)) {
6426
horizontalScrollBarVisible = wParam != 0;
6427
SetScrollBars();
6428
ReconfigureScrollBars();
6429
}
6430
break;
6431
6432
case SCI_GETHSCROLLBAR:
6433
return horizontalScrollBarVisible;
6434
6435
case SCI_SETVSCROLLBAR:
6436
if (verticalScrollBarVisible != (wParam != 0)) {
6437
verticalScrollBarVisible = wParam != 0;
6438
SetScrollBars();
6439
ReconfigureScrollBars();
6440
}
6441
break;
6442
6443
case SCI_GETVSCROLLBAR:
6444
return verticalScrollBarVisible;
6445
6446
case SCI_SETINDENTATIONGUIDES:
6447
vs.viewIndentationGuides = wParam != 0;
6448
Redraw();
6449
break;
6450
6451
case SCI_GETINDENTATIONGUIDES:
6452
return vs.viewIndentationGuides;
6453
6454
case SCI_SETHIGHLIGHTGUIDE:
6455
if ((highlightGuideColumn != static_cast<int>(wParam)) || (wParam > 0)) {
6456
highlightGuideColumn = wParam;
6457
Redraw();
6458
}
6459
break;
6460
6461
case SCI_GETHIGHLIGHTGUIDE:
6462
return highlightGuideColumn;
6463
6464
case SCI_GETLINEENDPOSITION:
6465
return pdoc->LineEnd(wParam);
6466
6467
case SCI_SETCODEPAGE:
6468
pdoc->dbcsCodePage = wParam;
6469
InvalidateStyleRedraw();
6470
break;
6471
6472
case SCI_GETCODEPAGE:
6473
return pdoc->dbcsCodePage;
6474
6475
case SCI_SETUSEPALETTE:
6476
palette.allowRealization = wParam != 0;
6477
InvalidateStyleRedraw();
6478
break;
6479
6480
case SCI_GETUSEPALETTE:
6481
return palette.allowRealization;
6482
6483
// Marker definition and setting
6484
case SCI_MARKERDEFINE:
6485
if (wParam <= MARKER_MAX)
6486
vs.markers[wParam].markType = lParam;
6487
InvalidateStyleData();
6488
RedrawSelMargin();
6489
break;
6490
case SCI_MARKERSETFORE:
6491
if (wParam <= MARKER_MAX)
6492
vs.markers[wParam].fore.desired = ColourDesired(lParam);
6493
InvalidateStyleData();
6494
RedrawSelMargin();
6495
break;
6496
case SCI_MARKERSETBACK:
6497
if (wParam <= MARKER_MAX)
6498
vs.markers[wParam].back.desired = ColourDesired(lParam);
6499
InvalidateStyleData();
6500
RedrawSelMargin();
6501
break;
6502
case SCI_MARKERADD: {
6503
int markerID = pdoc->AddMark(wParam, lParam);
6504
return markerID;
6505
}
6506
case SCI_MARKERADDSET:
6507
if (lParam != 0)
6508
pdoc->AddMarkSet(wParam, lParam);
6509
break;
6510
6511
case SCI_MARKERDELETE:
6512
pdoc->DeleteMark(wParam, lParam);
6513
break;
6514
6515
case SCI_MARKERDELETEALL:
6516
pdoc->DeleteAllMarks(static_cast<int>(wParam));
6517
break;
6518
6519
case SCI_MARKERGET:
6520
return pdoc->GetMark(wParam);
6521
6522
case SCI_MARKERNEXT: {
6523
int lt = pdoc->LinesTotal();
6524
for (int iLine = wParam; iLine < lt; iLine++) {
6525
if ((pdoc->GetMark(iLine) & lParam) != 0)
6526
return iLine;
6527
}
6528
}
6529
return -1;
6530
6531
case SCI_MARKERPREVIOUS: {
6532
for (int iLine = wParam; iLine >= 0; iLine--) {
6533
if ((pdoc->GetMark(iLine) & lParam) != 0)
6534
return iLine;
6535
}
6536
}
6537
return -1;
6538
6539
case SCI_MARKERDEFINEPIXMAP:
6540
if (wParam <= MARKER_MAX) {
6541
vs.markers[wParam].SetXPM(CharPtrFromSPtr(lParam));
6542
};
6543
InvalidateStyleData();
6544
RedrawSelMargin();
6545
break;
6546
6547
case SCI_SETMARGINTYPEN:
6548
if (ValidMargin(wParam)) {
6549
vs.ms[wParam].symbol = (lParam == SC_MARGIN_SYMBOL);
6550
InvalidateStyleRedraw();
6551
}
6552
break;
6553
6554
case SCI_GETMARGINTYPEN:
6555
if (ValidMargin(wParam))
6556
return vs.ms[wParam].symbol ? SC_MARGIN_SYMBOL : SC_MARGIN_NUMBER;
6557
else
6558
return 0;
6559
6560
case SCI_SETMARGINWIDTHN:
6561
if (ValidMargin(wParam)) {
6562
// Short-circuit if the width is unchanged, to avoid unnecessary redraw.
6563
if (vs.ms[wParam].width != lParam) {
6564
vs.ms[wParam].width = lParam;
6565
InvalidateStyleRedraw();
6566
}
6567
}
6568
break;
6569
6570
case SCI_GETMARGINWIDTHN:
6571
if (ValidMargin(wParam))
6572
return vs.ms[wParam].width;
6573
else
6574
return 0;
6575
6576
case SCI_SETMARGINMASKN:
6577
if (ValidMargin(wParam)) {
6578
vs.ms[wParam].mask = lParam;
6579
InvalidateStyleRedraw();
6580
}
6581
break;
6582
6583
case SCI_GETMARGINMASKN:
6584
if (ValidMargin(wParam))
6585
return vs.ms[wParam].mask;
6586
else
6587
return 0;
6588
6589
case SCI_SETMARGINSENSITIVEN:
6590
if (ValidMargin(wParam)) {
6591
vs.ms[wParam].sensitive = lParam != 0;
6592
InvalidateStyleRedraw();
6593
}
6594
break;
6595
6596
case SCI_GETMARGINSENSITIVEN:
6597
if (ValidMargin(wParam))
6598
return vs.ms[wParam].sensitive ? 1 : 0;
6599
else
6600
return 0;
6601
6602
case SCI_STYLECLEARALL:
6603
vs.ClearStyles();
6604
InvalidateStyleRedraw();
6605
break;
6606
6607
case SCI_STYLESETFORE:
6608
if (wParam <= STYLE_MAX) {
6609
vs.styles[wParam].fore.desired = ColourDesired(lParam);
6610
InvalidateStyleRedraw();
6611
}
6612
break;
6613
case SCI_STYLESETBACK:
6614
if (wParam <= STYLE_MAX) {
6615
vs.styles[wParam].back.desired = ColourDesired(lParam);
6616
InvalidateStyleRedraw();
6617
}
6618
break;
6619
case SCI_STYLESETBOLD:
6620
if (wParam <= STYLE_MAX) {
6621
vs.styles[wParam].bold = lParam != 0;
6622
InvalidateStyleRedraw();
6623
}
6624
break;
6625
case SCI_STYLESETITALIC:
6626
if (wParam <= STYLE_MAX) {
6627
vs.styles[wParam].italic = lParam != 0;
6628
InvalidateStyleRedraw();
6629
}
6630
break;
6631
case SCI_STYLESETEOLFILLED:
6632
if (wParam <= STYLE_MAX) {
6633
vs.styles[wParam].eolFilled = lParam != 0;
6634
InvalidateStyleRedraw();
6635
}
6636
break;
6637
case SCI_STYLESETSIZE:
6638
if (wParam <= STYLE_MAX) {
6639
vs.styles[wParam].size = lParam;
6640
InvalidateStyleRedraw();
6641
}
6642
break;
6643
case SCI_STYLESETFONT:
6644
if (lParam == 0)
6645
return 0;
6646
if (wParam <= STYLE_MAX) {
6647
vs.SetStyleFontName(wParam, CharPtrFromSPtr(lParam));
6648
InvalidateStyleRedraw();
6649
}
6650
break;
6651
case SCI_STYLESETUNDERLINE:
6652
if (wParam <= STYLE_MAX) {
6653
vs.styles[wParam].underline = lParam != 0;
6654
InvalidateStyleRedraw();
6655
}
6656
break;
6657
case SCI_STYLESETCASE:
6658
if (wParam <= STYLE_MAX) {
6659
vs.styles[wParam].caseForce = static_cast<Style::ecaseForced>(lParam);
6660
InvalidateStyleRedraw();
6661
}
6662
break;
6663
case SCI_STYLESETCHARACTERSET:
6664
if (wParam <= STYLE_MAX) {
6665
vs.styles[wParam].characterSet = lParam;
6666
InvalidateStyleRedraw();
6667
}
6668
break;
6669
case SCI_STYLESETVISIBLE:
6670
if (wParam <= STYLE_MAX) {
6671
vs.styles[wParam].visible = lParam != 0;
6672
InvalidateStyleRedraw();
6673
}
6674
break;
6675
case SCI_STYLESETCHANGEABLE:
6676
if (wParam <= STYLE_MAX) {
6677
vs.styles[wParam].changeable = lParam != 0;
6678
InvalidateStyleRedraw();
6679
}
6680
break;
6681
case SCI_STYLESETHOTSPOT:
6682
if (wParam <= STYLE_MAX) {
6683
vs.styles[wParam].hotspot = lParam != 0;
6684
InvalidateStyleRedraw();
6685
}
6686
break;
6687
6688
case SCI_STYLERESETDEFAULT:
6689
vs.ResetDefaultStyle();
6690
InvalidateStyleRedraw();
6691
break;
6692
case SCI_SETSTYLEBITS:
6693
pdoc->SetStylingBits(wParam);
6694
break;
6695
6696
case SCI_GETSTYLEBITS:
6697
return pdoc->stylingBits;
6698
6699
case SCI_SETLINESTATE:
6700
return pdoc->SetLineState(wParam, lParam);
6701
6702
case SCI_GETLINESTATE:
6703
return pdoc->GetLineState(wParam);
6704
6705
case SCI_GETMAXLINESTATE:
6706
return pdoc->GetMaxLineState();
6707
6708
case SCI_GETCARETLINEVISIBLE:
6709
return vs.showCaretLineBackground;
6710
case SCI_SETCARETLINEVISIBLE:
6711
vs.showCaretLineBackground = wParam != 0;
6712
InvalidateStyleRedraw();
6713
break;
6714
case SCI_GETCARETLINEBACK:
6715
return vs.caretLineBackground.desired.AsLong();
6716
case SCI_SETCARETLINEBACK:
6717
vs.caretLineBackground.desired = wParam;
6718
InvalidateStyleRedraw();
6719
break;
6720
6721
// Folding messages
6722
6723
case SCI_VISIBLEFROMDOCLINE:
6724
return cs.DisplayFromDoc(wParam);
6725
6726
case SCI_DOCLINEFROMVISIBLE:
6727
return cs.DocFromDisplay(wParam);
6728
6729
case SCI_WRAPCOUNT:
6730
return WrapCount(wParam);
6731
6732
case SCI_SETFOLDLEVEL: {
6733
int prev = pdoc->SetLevel(wParam, lParam);
6734
if (prev != lParam)
6735
RedrawSelMargin();
6736
return prev;
6737
}
6738
6739
case SCI_GETFOLDLEVEL:
6740
return pdoc->GetLevel(wParam);
6741
6742
case SCI_GETLASTCHILD:
6743
return pdoc->GetLastChild(wParam, lParam);
6744
6745
case SCI_GETFOLDPARENT:
6746
return pdoc->GetFoldParent(wParam);
6747
6748
case SCI_SHOWLINES:
6749
cs.SetVisible(wParam, lParam, true);
6750
SetScrollBars();
6751
Redraw();
6752
break;
6753
6754
case SCI_HIDELINES:
6755
cs.SetVisible(wParam, lParam, false);
6756
SetScrollBars();
6757
Redraw();
6758
break;
6759
6760
case SCI_GETLINEVISIBLE:
6761
return cs.GetVisible(wParam);
6762
6763
case SCI_SETFOLDEXPANDED:
6764
if (cs.SetExpanded(wParam, lParam != 0)) {
6765
RedrawSelMargin();
6766
}
6767
break;
6768
6769
case SCI_GETFOLDEXPANDED:
6770
return cs.GetExpanded(wParam);
6771
6772
case SCI_SETFOLDFLAGS:
6773
foldFlags = wParam;
6774
Redraw();
6775
break;
6776
6777
case SCI_TOGGLEFOLD:
6778
ToggleContraction(wParam);
6779
break;
6780
6781
case SCI_ENSUREVISIBLE:
6782
EnsureLineVisible(wParam, false);
6783
break;
6784
6785
case SCI_ENSUREVISIBLEENFORCEPOLICY:
6786
EnsureLineVisible(wParam, true);
6787
break;
6788
6789
case SCI_SEARCHANCHOR:
6790
SearchAnchor();
6791
break;
6792
6793
case SCI_SEARCHNEXT:
6794
case SCI_SEARCHPREV:
6795
return SearchText(iMessage, wParam, lParam);
6796
6797
#ifdef INCLUDE_DEPRECATED_FEATURES
6798
case SCI_SETCARETPOLICY: // Deprecated
6799
caretXPolicy = caretYPolicy = wParam;
6800
caretXSlop = caretYSlop = lParam;
6801
break;
6802
#endif
6803
6804
case SCI_SETXCARETPOLICY:
6805
caretXPolicy = wParam;
6806
caretXSlop = lParam;
6807
break;
6808
6809
case SCI_SETYCARETPOLICY:
6810
caretYPolicy = wParam;
6811
caretYSlop = lParam;
6812
break;
6813
6814
case SCI_SETVISIBLEPOLICY:
6815
visiblePolicy = wParam;
6816
visibleSlop = lParam;
6817
break;
6818
6819
case SCI_LINESONSCREEN:
6820
return LinesOnScreen();
6821
6822
case SCI_SETSELFORE:
6823
vs.selforeset = wParam != 0;
6824
vs.selforeground.desired = ColourDesired(lParam);
6825
InvalidateStyleRedraw();
6826
break;
6827
6828
case SCI_SETSELBACK:
6829
vs.selbackset = wParam != 0;
6830
vs.selbackground.desired = ColourDesired(lParam);
6831
InvalidateStyleRedraw();
6832
break;
6833
6834
case SCI_SETWHITESPACEFORE:
6835
vs.whitespaceForegroundSet = wParam != 0;
6836
vs.whitespaceForeground.desired = ColourDesired(lParam);
6837
InvalidateStyleRedraw();
6838
break;
6839
6840
case SCI_SETWHITESPACEBACK:
6841
vs.whitespaceBackgroundSet = wParam != 0;
6842
vs.whitespaceBackground.desired = ColourDesired(lParam);
6843
InvalidateStyleRedraw();
6844
break;
6845
6846
case SCI_SETCARETFORE:
6847
vs.caretcolour.desired = ColourDesired(wParam);
6848
InvalidateStyleRedraw();
6849
break;
6850
6851
case SCI_GETCARETFORE:
6852
return vs.caretcolour.desired.AsLong();
6853
6854
case SCI_SETCARETWIDTH:
6855
if (wParam <= 0)
6856
vs.caretWidth = 0;
6857
else if (wParam >= 3)
6858
vs.caretWidth = 3;
6859
else
6860
vs.caretWidth = wParam;
6861
InvalidateStyleRedraw();
6862
break;
6863
6864
case SCI_GETCARETWIDTH:
6865
return vs.caretWidth;
6866
6867
case SCI_ASSIGNCMDKEY:
6868
kmap.AssignCmdKey(Platform::LowShortFromLong(wParam),
6869
Platform::HighShortFromLong(wParam), lParam);
6870
break;
6871
6872
case SCI_CLEARCMDKEY:
6873
kmap.AssignCmdKey(Platform::LowShortFromLong(wParam),
6874
Platform::HighShortFromLong(wParam), SCI_NULL);
6875
break;
6876
6877
case SCI_CLEARALLCMDKEYS:
6878
kmap.Clear();
6879
break;
6880
6881
case SCI_INDICSETSTYLE:
6882
if (wParam <= INDIC_MAX) {
6883
vs.indicators[wParam].style = lParam;
6884
InvalidateStyleRedraw();
6885
}
6886
break;
6887
6888
case SCI_INDICGETSTYLE:
6889
return (wParam <= INDIC_MAX) ? vs.indicators[wParam].style : 0;
6890
6891
case SCI_INDICSETFORE:
6892
if (wParam <= INDIC_MAX) {
6893
vs.indicators[wParam].fore.desired = ColourDesired(lParam);
6894
InvalidateStyleRedraw();
6895
}
6896
break;
6897
6898
case SCI_INDICGETFORE:
6899
return (wParam <= INDIC_MAX) ? vs.indicators[wParam].fore.desired.AsLong() : 0;
6900
6901
case SCI_LINEDOWN:
6902
case SCI_LINEDOWNEXTEND:
6903
case SCI_PARADOWN:
6904
case SCI_PARADOWNEXTEND:
6905
case SCI_LINEUP:
6906
case SCI_LINEUPEXTEND:
6907
case SCI_PARAUP:
6908
case SCI_PARAUPEXTEND:
6909
case SCI_CHARLEFT:
6910
case SCI_CHARLEFTEXTEND:
6911
case SCI_CHARRIGHT:
6912
case SCI_CHARRIGHTEXTEND:
6913
case SCI_WORDLEFT:
6914
case SCI_WORDLEFTEXTEND:
6915
case SCI_WORDRIGHT:
6916
case SCI_WORDRIGHTEXTEND:
6917
case SCI_WORDLEFTEND:
6918
case SCI_WORDLEFTENDEXTEND:
6919
case SCI_WORDRIGHTEND:
6920
case SCI_WORDRIGHTENDEXTEND:
6921
case SCI_HOME:
6922
case SCI_HOMEEXTEND:
6923
case SCI_LINEEND:
6924
case SCI_LINEENDEXTEND:
6925
case SCI_HOMEWRAP:
6926
case SCI_HOMEWRAPEXTEND:
6927
case SCI_LINEENDWRAP:
6928
case SCI_LINEENDWRAPEXTEND:
6929
case SCI_DOCUMENTSTART:
6930
case SCI_DOCUMENTSTARTEXTEND:
6931
case SCI_DOCUMENTEND:
6932
case SCI_DOCUMENTENDEXTEND:
6933
6934
case SCI_STUTTEREDPAGEUP:
6935
case SCI_STUTTEREDPAGEUPEXTEND:
6936
case SCI_STUTTEREDPAGEDOWN:
6937
case SCI_STUTTEREDPAGEDOWNEXTEND:
6938
6939
case SCI_PAGEUP:
6940
case SCI_PAGEUPEXTEND:
6941
case SCI_PAGEDOWN:
6942
case SCI_PAGEDOWNEXTEND:
6943
case SCI_EDITTOGGLEOVERTYPE:
6944
case SCI_CANCEL:
6945
case SCI_DELETEBACK:
6946
case SCI_TAB:
6947
case SCI_BACKTAB:
6948
case SCI_NEWLINE:
6949
case SCI_FORMFEED:
6950
case SCI_VCHOME:
6951
case SCI_VCHOMEEXTEND:
6952
case SCI_VCHOMEWRAP:
6953
case SCI_VCHOMEWRAPEXTEND:
6954
case SCI_ZOOMIN:
6955
case SCI_ZOOMOUT:
6956
case SCI_DELWORDLEFT:
6957
case SCI_DELWORDRIGHT:
6958
case SCI_DELLINELEFT:
6959
case SCI_DELLINERIGHT:
6960
case SCI_LINECOPY:
6961
case SCI_LINECUT:
6962
case SCI_LINEDELETE:
6963
case SCI_LINETRANSPOSE:
6964
case SCI_LINEDUPLICATE:
6965
case SCI_LOWERCASE:
6966
case SCI_UPPERCASE:
6967
case SCI_LINESCROLLDOWN:
6968
case SCI_LINESCROLLUP:
6969
case SCI_WORDPARTLEFT:
6970
case SCI_WORDPARTLEFTEXTEND:
6971
case SCI_WORDPARTRIGHT:
6972
case SCI_WORDPARTRIGHTEXTEND:
6973
case SCI_DELETEBACKNOTLINE:
6974
case SCI_HOMEDISPLAY:
6975
case SCI_HOMEDISPLAYEXTEND:
6976
case SCI_LINEENDDISPLAY:
6977
case SCI_LINEENDDISPLAYEXTEND:
6978
case SCI_LINEDOWNRECTEXTEND:
6979
case SCI_LINEUPRECTEXTEND:
6980
case SCI_CHARLEFTRECTEXTEND:
6981
case SCI_CHARRIGHTRECTEXTEND:
6982
case SCI_HOMERECTEXTEND:
6983
case SCI_VCHOMERECTEXTEND:
6984
case SCI_LINEENDRECTEXTEND:
6985
case SCI_PAGEUPRECTEXTEND:
6986
case SCI_PAGEDOWNRECTEXTEND:
6987
case SCI_SELECTIONDUPLICATE:
6988
return KeyCommand(iMessage);
6989
6990
case SCI_BRACEHIGHLIGHT:
6991
SetBraceHighlight(static_cast<int>(wParam), lParam, STYLE_BRACELIGHT);
6992
break;
6993
6994
case SCI_BRACEBADLIGHT:
6995
SetBraceHighlight(static_cast<int>(wParam), -1, STYLE_BRACEBAD);
6996
break;
6997
6998
case SCI_BRACEMATCH:
6999
// wParam is position of char to find brace for,
7000
// lParam is maximum amount of text to restyle to find it
7001
return pdoc->BraceMatch(wParam, lParam);
7002
7003
case SCI_GETVIEWEOL:
7004
return vs.viewEOL;
7005
7006
case SCI_SETVIEWEOL:
7007
vs.viewEOL = wParam != 0;
7008
InvalidateStyleRedraw();
7009
break;
7010
7011
case SCI_SETZOOM:
7012
vs.zoomLevel = wParam;
7013
InvalidateStyleRedraw();
7014
NotifyZoom();
7015
break;
7016
7017
case SCI_GETZOOM:
7018
return vs.zoomLevel;
7019
7020
case SCI_GETEDGECOLUMN:
7021
return theEdge;
7022
7023
case SCI_SETEDGECOLUMN:
7024
theEdge = wParam;
7025
InvalidateStyleRedraw();
7026
break;
7027
7028
case SCI_GETEDGEMODE:
7029
return vs.edgeState;
7030
7031
case SCI_SETEDGEMODE:
7032
vs.edgeState = wParam;
7033
InvalidateStyleRedraw();
7034
break;
7035
7036
case SCI_GETEDGECOLOUR:
7037
return vs.edgecolour.desired.AsLong();
7038
7039
case SCI_SETEDGECOLOUR:
7040
vs.edgecolour.desired = ColourDesired(wParam);
7041
InvalidateStyleRedraw();
7042
break;
7043
7044
case SCI_GETDOCPOINTER:
7045
return reinterpret_cast<sptr_t>(pdoc);
7046
7047
case SCI_SETDOCPOINTER:
7048
CancelModes();
7049
SetDocPointer(reinterpret_cast<Document *>(lParam));
7050
return 0;
7051
7052
case SCI_CREATEDOCUMENT: {
7053
Document *doc = new Document();
7054
if (doc) {
7055
doc->AddRef();
7056
}
7057
return reinterpret_cast<sptr_t>(doc);
7058
}
7059
7060
case SCI_ADDREFDOCUMENT:
7061
(reinterpret_cast<Document *>(lParam))->AddRef();
7062
break;
7063
7064
case SCI_RELEASEDOCUMENT:
7065
(reinterpret_cast<Document *>(lParam))->Release();
7066
break;
7067
7068
case SCI_SETMODEVENTMASK:
7069
modEventMask = wParam;
7070
return 0;
7071
7072
case SCI_GETMODEVENTMASK:
7073
return modEventMask;
7074
7075
case SCI_CONVERTEOLS:
7076
pdoc->ConvertLineEnds(wParam);
7077
SetSelection(currentPos, anchor); // Ensure selection inside document
7078
return 0;
7079
7080
case SCI_SETLENGTHFORENCODE:
7081
lengthForEncode = wParam;
7082
return 0;
7083
7084
case SCI_SELECTIONISRECTANGLE:
7085
return selType == selRectangle ? 1 : 0;
7086
7087
case SCI_SETSELECTIONMODE: {
7088
switch (wParam) {
7089
case SC_SEL_STREAM:
7090
moveExtendsSelection = !moveExtendsSelection || (selType != selStream);
7091
selType = selStream;
7092
break;
7093
case SC_SEL_RECTANGLE:
7094
moveExtendsSelection = !moveExtendsSelection || (selType != selRectangle);
7095
selType = selRectangle;
7096
break;
7097
case SC_SEL_LINES:
7098
moveExtendsSelection = !moveExtendsSelection || (selType != selLines);
7099
selType = selLines;
7100
break;
7101
default:
7102
moveExtendsSelection = !moveExtendsSelection || (selType != selStream);
7103
selType = selStream;
7104
}
7105
InvalidateSelection(currentPos, anchor);
7106
}
7107
case SCI_GETSELECTIONMODE:
7108
switch (selType) {
7109
case selStream:
7110
return SC_SEL_STREAM;
7111
case selRectangle:
7112
return SC_SEL_RECTANGLE;
7113
case selLines:
7114
return SC_SEL_LINES;
7115
default: // ?!
7116
return SC_SEL_STREAM;
7117
}
7118
case SCI_GETLINESELSTARTPOSITION: {
7119
SelectionLineIterator lineIterator(this);
7120
lineIterator.SetAt(wParam);
7121
return lineIterator.startPos;
7122
}
7123
case SCI_GETLINESELENDPOSITION: {
7124
SelectionLineIterator lineIterator(this);
7125
lineIterator.SetAt(wParam);
7126
return lineIterator.endPos;
7127
}
7128
7129
case SCI_SETOVERTYPE:
7130
inOverstrike = wParam != 0;
7131
break;
7132
7133
case SCI_GETOVERTYPE:
7134
return inOverstrike ? 1 : 0;
7135
7136
case SCI_SETFOCUS:
7137
SetFocusState(wParam != 0);
7138
break;
7139
7140
case SCI_GETFOCUS:
7141
return hasFocus;
7142
7143
case SCI_SETSTATUS:
7144
errorStatus = wParam;
7145
break;
7146
7147
case SCI_GETSTATUS:
7148
return errorStatus;
7149
7150
case SCI_SETMOUSEDOWNCAPTURES:
7151
mouseDownCaptures = wParam != 0;
7152
break;
7153
7154
case SCI_GETMOUSEDOWNCAPTURES:
7155
return mouseDownCaptures;
7156
7157
case SCI_SETCURSOR:
7158
cursorMode = wParam;
7159
DisplayCursor(Window::cursorText);
7160
break;
7161
7162
case SCI_GETCURSOR:
7163
return cursorMode;
7164
7165
case SCI_SETCONTROLCHARSYMBOL:
7166
controlCharSymbol = wParam;
7167
break;
7168
7169
case SCI_GETCONTROLCHARSYMBOL:
7170
return controlCharSymbol;
7171
7172
case SCI_STARTRECORD:
7173
recordingMacro = true;
7174
return 0;
7175
7176
case SCI_STOPRECORD:
7177
recordingMacro = false;
7178
return 0;
7179
7180
case SCI_MOVECARETINSIDEVIEW:
7181
MoveCaretInsideView();
7182
break;
7183
7184
case SCI_SETFOLDMARGINCOLOUR:
7185
vs.foldmarginColourSet = wParam != 0;
7186
vs.foldmarginColour.desired = ColourDesired(lParam);
7187
InvalidateStyleRedraw();
7188
break;
7189
7190
case SCI_SETFOLDMARGINHICOLOUR:
7191
vs.foldmarginHighlightColourSet = wParam != 0;
7192
vs.foldmarginHighlightColour.desired = ColourDesired(lParam);
7193
InvalidateStyleRedraw();
7194
break;
7195
7196
case SCI_SETHOTSPOTACTIVEFORE:
7197
vs.hotspotForegroundSet = wParam != 0;
7198
vs.hotspotForeground.desired = ColourDesired(lParam);
7199
InvalidateStyleRedraw();
7200
break;
7201
7202
case SCI_SETHOTSPOTACTIVEBACK:
7203
vs.hotspotBackgroundSet = wParam != 0;
7204
vs.hotspotBackground.desired = ColourDesired(lParam);
7205
InvalidateStyleRedraw();
7206
break;
7207
7208
case SCI_SETHOTSPOTACTIVEUNDERLINE:
7209
vs.hotspotUnderline = wParam != 0;
7210
InvalidateStyleRedraw();
7211
break;
7212
7213
case SCI_SETHOTSPOTSINGLELINE:
7214
vs.hotspotSingleLine = wParam != 0;
7215
InvalidateStyleRedraw();
7216
break;
7217
7218
case SCI_SETPASTECONVERTENDINGS:
7219
convertPastes = wParam != 0;
7220
break;
7221
7222
case SCI_GETPASTECONVERTENDINGS:
7223
return convertPastes ? 1 : 0;
7224
7225
default:
7226
return DefWndProc(iMessage, wParam, lParam);
7227
}
7228
//Platform::DebugPrintf("end wnd proc\n");
7229
return 0l;
7230
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1