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