]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/stc/scintilla/src/Editor.cxx
projects / wxWidgets.git / blob
? search:


faba66ef55bac5231ad94c1c501a40ecdffcec0e
[wxWidgets.git] / contrib / src / stc / scintilla / src / Editor.cxx
1 // Scintilla source code edit control
2 /** @file Editor.cxx
3 ** Main code for the edit control.
4 **/
5 // Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
6 // The License.txt file describes the conditions under which this software may be distributed.
7
8 #include <stdlib.h>
9 #include <string.h>
10 #include <stdio.h>
11 #include <ctype.h>
12
13 #include "Platform.h"
14
15 #define INCLUDE_DEPRECATED_FEATURES
16 #include "Scintilla.h"
17
18 #include "ContractionState.h"
19 #include "SVector.h"
20 #include "CellBuffer.h"
21 #include "KeyMap.h"
22 #include "Indicator.h"
23 #include "LineMarker.h"
24 #include "Style.h"
25 #include "ViewStyle.h"
26 #include "Document.h"
27 #include "Editor.h"
28
29 Caret::Caret() :
30 active(false), on(false), period(500) {}
31
32 Timer::Timer() :
33 ticking(false), ticksToWait(0), tickerID(0) {}
34
35 LineLayout::LineLayout(int maxLineLength_) :
36 lineStarts(0),
37 lenLineStarts(0),
38 lineNumber(-1),
39 inCache(false),
40 maxLineLength(-1),
41 numCharsInLine(0),
42 validity(llInvalid),
43 xHighlightGuide(0),
44 highlightColumn(0),
45 selStart(0),
46 selEnd(0),
47 containsCaret(false),
48 edgeColumn(0),
49 chars(0),
50 styles(0),
51 indicators(0),
52 positions(0),
53 widthLine(wrapWidthInfinite),
54 lines(1) {
55 Resize(maxLineLength_);
56 }
57
58 LineLayout::~LineLayout() {
59 Free();
60 }
61
62 void LineLayout::Resize(int maxLineLength_) {
63 if (maxLineLength_ > maxLineLength) {
64 Free();
65 chars = new char[maxLineLength_ + 1];
66 styles = new char[maxLineLength_ + 1];
67 indicators = new char[maxLineLength_ + 1];
68 // Extra position allocated as sometimes the Windows
69 // GetTextExtentExPoint API writes an extra element.
70 positions = new int[maxLineLength_ + 1 + 1];
71 maxLineLength = maxLineLength_;
72 }
73 }
74
75 void LineLayout::Free() {
76 delete []chars;
77 chars = 0;
78 delete []styles;
79 styles = 0;
80 delete []indicators;
81 indicators = 0;
82 delete []positions;
83 positions = 0;
84 delete []lineStarts;
85 lineStarts = 0;
86 }
87
88 void LineLayout::Invalidate(validLevel validity_) {
89 if (validity > validity_)
90 validity = validity_;
91 }
92
93 void LineLayout::SetLineStart(int line, int start) {
94 if ((line >= lenLineStarts) && (line != 0)) {
95 int newMaxLines = line + 20;
96 int *newLineStarts = new int[newMaxLines];
97 if (!newLineStarts)
98 return;
99 for (int i=0; i<newMaxLines; i++) {
100 if (i < lenLineStarts)
101 newLineStarts[i] = lineStarts[i];
102 else
103 newLineStarts[i] = 0;
104 }
105 delete []lineStarts;
106 lineStarts = newLineStarts;
107 lenLineStarts = newMaxLines;
108 }
109 lineStarts[line] = start;
110 }
111
112 void LineLayout::SetBracesHighlight(Range rangeLine, Position braces[],
113 char bracesMatchStyle, int xHighlight) {
114 if (rangeLine.ContainsCharacter(braces[0])) {
115 int braceOffset = braces[0] - rangeLine.start;
116 if (braceOffset < numCharsInLine) {
117 bracePreviousStyles[0] = styles[braceOffset];
118 styles[braceOffset] = bracesMatchStyle;
119 }
120 }
121 if (rangeLine.ContainsCharacter(braces[1])) {
122 int braceOffset = braces[1] - rangeLine.start;
123 if (braceOffset < numCharsInLine) {
124 bracePreviousStyles[1] = styles[braceOffset];
125 styles[braceOffset] = bracesMatchStyle;
126 }
127 }
128 if ((braces[0] >= rangeLine.start && braces[1] <= rangeLine.end) ||
129 (braces[1] >= rangeLine.start && braces[0] <= rangeLine.end)) {
130 xHighlightGuide = xHighlight;
131 }
132 }
133
134 void LineLayout::RestoreBracesHighlight(Range rangeLine, Position braces[]) {
135 if (rangeLine.ContainsCharacter(braces[0])) {
136 int braceOffset = braces[0] - rangeLine.start;
137 if (braceOffset < numCharsInLine) {
138 styles[braceOffset] = bracePreviousStyles[0];
139 }
140 }
141 if (rangeLine.ContainsCharacter(braces[1])) {
142 int braceOffset = braces[1] - rangeLine.start;
143 if (braceOffset < numCharsInLine) {
144 styles[braceOffset] = bracePreviousStyles[1];
145 }
146 }
147 xHighlightGuide = 0;
148 }
149
150 LineLayoutCache::LineLayoutCache() :
151 level(0), length(0), size(0), cache(0),
152 allInvalidated(false), styleClock(-1) {
153 Allocate(0);
154 }
155
156 LineLayoutCache::~LineLayoutCache() {
157 Deallocate();
158 }
159
160 void LineLayoutCache::Allocate(int length_) {
161 allInvalidated = false;
162 length = length_;
163 size = length;
164 if (size > 1) {
165 size = (size / 16 + 1) * 16;
166 }
167 if (size > 0) {
168 cache = new LineLayout *[size];
169 }
170 for (int i=0; i<size; i++)
171 cache[i] = 0;
172 }
173
174 void LineLayoutCache::AllocateForLevel(int linesOnScreen, int linesInDoc) {
175 int lengthForLevel = 0;
176 if (level == llcCaret) {
177 lengthForLevel = 1;
178 } else if (level == llcPage) {
179 lengthForLevel = linesOnScreen + 1;
180 } else if (level == llcDocument) {
181 lengthForLevel = linesInDoc;
182 }
183 if (lengthForLevel > size) {
184 Deallocate();
185 } else if (lengthForLevel < length) {
186 for (int i=lengthForLevel; i<length; i++) {
187 delete cache[i];
188 cache[i] = 0;
189 }
190 }
191 if (!cache) {
192 Allocate(lengthForLevel);
193 }
194 }
195
196 void LineLayoutCache::Deallocate() {
197 for (int i=0; i<length; i++)
198 delete cache[i];
199 delete []cache;
200 cache = 0;
201 length = 0;
202 }
203
204 void LineLayoutCache::Invalidate(LineLayout::validLevel validity_) {
205 if (cache && !allInvalidated) {
206 for (int i=0; i<length; i++) {
207 if (cache[i]) {
208 cache[i]->Invalidate(validity_);
209 }
210 }
211 if (validity_ == LineLayout::llInvalid) {
212 allInvalidated = true;
213 }
214 }
215 }
216
217 void LineLayoutCache::SetLevel(int level_) {
218 allInvalidated = false;
219 if ((level_ != -1) && (level != level_)) {
220 level = level_;
221 Deallocate();
222 }
223 }
224
225 LineLayout *LineLayoutCache::Retrieve(int lineNumber, int lineCaret, int maxChars, int styleClock_,
226 int linesOnScreen, int linesInDoc) {
227 AllocateForLevel(linesOnScreen, linesInDoc);
228 if (styleClock != styleClock_) {
229 Invalidate(LineLayout::llCheckTextAndStyle);
230 styleClock = styleClock_;
231 }
232 allInvalidated = false;
233 int pos = -1;
234 LineLayout *ret = 0;
235 if (((level == llcCaret) || (level == llcPage)) && (lineNumber == lineCaret)) {
236 pos = 0;
237 } else if (level == llcPage) {
238 pos = lineNumber % length;
239 } else if (level == llcDocument) {
240 pos = lineNumber;
241 }
242 if (pos >= 0) {
243 if (cache && (pos < length)) {
244 if (cache[pos]) {
245 if ((cache[pos]->lineNumber != lineNumber) ||
246 (cache[pos]->maxLineLength < maxChars)) {
247 delete cache[pos];
248 cache[pos] = 0;
249 }
250 }
251 if (!cache[pos]) {
252 cache[pos] = new LineLayout(maxChars);
253 }
254 if (cache[pos]) {
255 cache[pos]->lineNumber = lineNumber;
256 cache[pos]->inCache = true;
257 ret = cache[pos];
258 }
259 }
260 }
261
262 if (!ret) {
263 ret = new LineLayout(maxChars);
264 ret->lineNumber = lineNumber;
265 }
266
267 return ret;
268 }
269
270 void LineLayoutCache::Dispose(LineLayout *ll) {
271 allInvalidated = false;
272 if (ll) {
273 if (!ll->inCache) {
274 delete ll;
275 }
276 }
277 }
278
279 Editor::Editor() {
280 ctrlID = 0;
281
282 stylesValid = false;
283
284 printMagnification = 0;
285 printColourMode = SC_PRINT_NORMAL;
286 cursorMode = SC_CURSORNORMAL;
287 controlCharSymbol = 0; /* Draw the control characters */
288
289 hasFocus = false;
290 hideSelection = false;
291 inOverstrike = false;
292 errorStatus = 0;
293 mouseDownCaptures = true;
294
295 bufferedDraw = true;
296
297 lastClickTime = 0;
298 dwellDelay = SC_TIME_FOREVER;
299 ticksToDwell = SC_TIME_FOREVER;
300 dwelling = false;
301 ptMouseLast.x = 0;
302 ptMouseLast.y = 0;
303 inDragDrop = false;
304 dropWentOutside = false;
305 posDrag = invalidPosition;
306 posDrop = invalidPosition;
307 selectionType = selChar;
308
309 lastXChosen = 0;
310 lineAnchor = 0;
311 originalAnchorPos = 0;
312
313 selType = selStream;
314 xStartSelect = 0;
315 xEndSelect = 0;
316 primarySelection = true;
317
318 caretXPolicy = CARET_SLOP | CARET_EVEN;
319 caretXSlop = 50;
320
321 caretYPolicy = CARET_EVEN;
322 caretYSlop = 0;
323
324 searchAnchor = 0;
325
326 xOffset = 0;
327 xCaretMargin = 50;
328 horizontalScrollBarVisible = true;
329 scrollWidth = 2000;
330 endAtLastLine = true;
331
332 pixmapLine = Surface::Allocate();
333 pixmapSelMargin = Surface::Allocate();
334 pixmapSelPattern = Surface::Allocate();
335 pixmapIndentGuide = Surface::Allocate();
336 pixmapIndentGuideHighlight = Surface::Allocate();
337
338 currentPos = 0;
339 anchor = 0;
340
341 targetStart = 0;
342 targetEnd = 0;
343 searchFlags = 0;
344
345 topLine = 0;
346 posTopLine = 0;
347
348 needUpdateUI = true;
349 braces[0] = invalidPosition;
350 braces[1] = invalidPosition;
351 bracesMatchStyle = STYLE_BRACEBAD;
352 highlightGuideColumn = 0;
353
354 theEdge = 0;
355
356 paintState = notPainting;
357
358 modEventMask = SC_MODEVENTMASKALL;
359
360 pdoc = new Document();
361 pdoc ->AddRef();
362 pdoc->AddWatcher(this, 0);
363
364 recordingMacro = false;
365 foldFlags = 0;
366
367 wrapState = eWrapNone;
368 wrapWidth = LineLayout::wrapWidthInfinite;
369 docLineLastWrapped = -1;
370
371 llc.SetLevel(LineLayoutCache::llcDocument);
372 }
373
374 Editor::~Editor() {
375 pdoc->RemoveWatcher(this, 0);
376 pdoc->Release();
377 pdoc = 0;
378 DropGraphics();
379 delete pixmapLine;
380 delete pixmapSelMargin;
381 delete pixmapSelPattern;
382 delete pixmapIndentGuide;
383 delete pixmapIndentGuideHighlight;
384 }
385
386 void Editor::Finalise() {
387 CancelModes();
388 }
389
390 void Editor::DropGraphics() {
391 pixmapLine->Release();
392 pixmapSelMargin->Release();
393 pixmapSelPattern->Release();
394 pixmapIndentGuide->Release();
395 }
396
397 void Editor::InvalidateStyleData() {
398 stylesValid = false;
399 palette.Release();
400 DropGraphics();
401 llc.Invalidate(LineLayout::llInvalid);
402 }
403
404 void Editor::InvalidateStyleRedraw() {
405 InvalidateStyleData();
406 Redraw();
407 }
408
409 void Editor::RefreshColourPalette(Palette &pal, bool want) {
410 vs.RefreshColourPalette(pal, want);
411 }
412
413 void Editor::RefreshStyleData() {
414 if (!stylesValid) {
415 stylesValid = true;
416 AutoSurface surface(IsUnicodeMode());
417 if (surface) {
418 vs.Refresh(*surface);
419 RefreshColourPalette(palette, true);
420 palette.Allocate(wMain);
421 RefreshColourPalette(palette, false);
422 }
423 SetScrollBars();
424 }
425 }
426
427 PRectangle Editor::GetClientRectangle() {
428 return wMain.GetClientPosition();
429 }
430
431 PRectangle Editor::GetTextRectangle() {
432 PRectangle rc = GetClientRectangle();
433 rc.left += vs.fixedColumnWidth;
434 rc.right -= vs.rightMarginWidth;
435 return rc;
436 }
437
438 int Editor::LinesOnScreen() {
439 PRectangle rcClient = GetClientRectangle();
440 int htClient = rcClient.bottom - rcClient.top;
441 //Platform::DebugPrintf("lines on screen = %d\n", htClient / lineHeight + 1);
442 return htClient / vs.lineHeight;
443 }
444
445 int Editor::LinesToScroll() {
446 int retVal = LinesOnScreen() - 1;
447 if (retVal < 1)
448 return 1;
449 else
450 return retVal;
451 }
452
453 int Editor::MaxScrollPos() {
454 //Platform::DebugPrintf("Lines %d screen = %d maxScroll = %d\n",
455 //LinesTotal(), LinesOnScreen(), LinesTotal() - LinesOnScreen() + 1);
456 int retVal = cs.LinesDisplayed();
457 if (endAtLastLine) {
458 retVal -= LinesOnScreen();
459 } else {
460 retVal--;
461 }
462 if (retVal < 0) {
463 return 0;
464 } else {
465 return retVal;
466 }
467 }
468
469 static inline bool IsControlCharacter(char ch) {
470 // iscntrl returns true for lots of chars > 127 which are displayable
471 return ch >= 0 && ch < ' ';
472 }
473
474 const char *ControlCharacterString(unsigned char ch) {
475 const char *reps[] = {
476 "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
477 "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
478 "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
479 "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
480 };
481 if (ch < (sizeof(reps) / sizeof(reps[0]))) {
482 return reps[ch];
483 } else {
484 return "BAD";
485 }
486 }
487
488 Point Editor::LocationFromPosition(int pos) {
489 Point pt;
490 RefreshStyleData();
491 if (pos == INVALID_POSITION)
492 return pt;
493 int line = pdoc->LineFromPosition(pos);
494 int lineVisible = cs.DisplayFromDoc(line);
495 //Platform::DebugPrintf("line=%d\n", line);
496 AutoSurface surface(IsUnicodeMode());
497 LineLayout *ll = RetrieveLineLayout(line);
498 if (surface && ll) {
499 // -1 because of adding in for visible lines in following loop.
500 pt.y = (lineVisible - topLine - 1) * vs.lineHeight;
501 pt.x = 0;
502 unsigned int posLineStart = pdoc->LineStart(line);
503 LayoutLine(line, surface, vs, ll, wrapWidth);
504 int posInLine = pos - posLineStart;
505 // In case of very long line put x at arbitrary large position
506 if (posInLine > ll->maxLineLength) {
507 pt.x = ll->positions[ll->maxLineLength] - ll->positions[ll->LineStart(ll->lines)];
508 }
509 for (int subLine=0; subLine<ll->lines; subLine++) {
510 if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine+1))) {
511 pt.x = ll->positions[posInLine] - ll->positions[ll->LineStart(subLine)];
512 }
513 if (posInLine >= ll->LineStart(subLine)) {
514 pt.y += vs.lineHeight;
515 }
516 }
517 pt.x += vs.fixedColumnWidth - xOffset;
518 }
519 llc.Dispose(ll);
520 return pt;
521 }
522
523 int Editor::XFromPosition(int pos) {
524 Point pt = LocationFromPosition(pos);
525 return pt.x - vs.fixedColumnWidth + xOffset;
526 }
527
528 int Editor::LineFromLocation(Point pt) {
529 return cs.DocFromDisplay(pt.y / vs.lineHeight + topLine);
530 }
531
532 void Editor::SetTopLine(int topLineNew) {
533 topLine = topLineNew;
534 posTopLine = pdoc->LineStart(topLine);
535 }
536
537 int Editor::PositionFromLocation(Point pt) {
538 RefreshStyleData();
539 pt.x = pt.x - vs.fixedColumnWidth + xOffset;
540 int visibleLine = pt.y / vs.lineHeight + topLine;
541 if (pt.y < 0) { // Division rounds towards 0
542 visibleLine = (pt.y - (vs.lineHeight - 1)) / vs.lineHeight + topLine;
543 }
544 if (visibleLine < 0)
545 visibleLine = 0;
546 int lineDoc = cs.DocFromDisplay(visibleLine);
547 if (lineDoc >= pdoc->LinesTotal())
548 return pdoc->Length();
549 AutoSurface surface(IsUnicodeMode());
550 int retVal = 0;
551 LineLayout *ll = RetrieveLineLayout(lineDoc);
552 if (surface && ll) {
553 LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
554 unsigned int posLineStart = pdoc->LineStart(lineDoc);
555 int lineStartSet = cs.DisplayFromDoc(lineDoc);
556 int subLine = visibleLine - lineStartSet;
557 if (subLine < ll->lines) {
558 int lineStart = ll->LineStart(subLine);
559 int lineEnd = ll->LineStart(subLine+1);
560 int subLineStart = ll->positions[lineStart];
561 for (int i = lineStart; i < lineEnd; i++) {
562 if (pt.x < (((ll->positions[i] + ll->positions[i + 1]) / 2) - subLineStart) ||
563 ll->chars[i] == '\r' || ll->chars[i] == '\n') {
564 llc.Dispose(ll);
565 return pdoc->MovePositionOutsideChar(i + posLineStart, 1);
566 }
567 }
568 llc.Dispose(ll);
569 return lineEnd + posLineStart;
570 }
571 retVal = ll->numCharsInLine + posLineStart;
572 }
573 llc.Dispose(ll);
574 return retVal;
575 }
576
577 // Like PositionFromLocation but INVALID_POSITION returned when not near any text.
578 int Editor::PositionFromLocationClose(Point pt) {
579 RefreshStyleData();
580 PRectangle rcClient = GetTextRectangle();
581 if (!rcClient.Contains(pt))
582 return INVALID_POSITION;
583 if (pt.x < vs.fixedColumnWidth)
584 return INVALID_POSITION;
585 if (pt.y < 0)
586 return INVALID_POSITION;
587 pt.x = pt.x - vs.fixedColumnWidth + xOffset;
588 int visibleLine = pt.y / vs.lineHeight + topLine;
589 if (pt.y < 0) { // Division rounds towards 0
590 visibleLine = (pt.y - (vs.lineHeight - 1)) / vs.lineHeight + topLine;
591 }
592 int lineDoc = cs.DocFromDisplay(visibleLine);
593 if (lineDoc < 0)
594 return INVALID_POSITION;
595 if (lineDoc >= pdoc->LinesTotal())
596 return INVALID_POSITION;
597 AutoSurface surface(IsUnicodeMode());
598 LineLayout *ll = RetrieveLineLayout(lineDoc);
599 if (surface && ll) {
600 LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
601 unsigned int posLineStart = pdoc->LineStart(lineDoc);
602 int lineStartSet = cs.DisplayFromDoc(lineDoc);
603 int subLine = visibleLine - lineStartSet;
604 if (subLine < ll->lines) {
605 int lineStart = ll->LineStart(subLine);
606 int lineEnd = ll->LineStart(subLine+1);
607 int subLineStart = ll->positions[lineStart];
608 for (int i = lineStart; i < lineEnd; i++) {
609 if (pt.x < (((ll->positions[i] + ll->positions[i + 1]) / 2) - subLineStart) ||
610 ll->chars[i] == '\r' || ll->chars[i] == '\n') {
611 llc.Dispose(ll);
612 return pdoc->MovePositionOutsideChar(i + posLineStart, 1);
613 }
614 }
615 }
616 }
617 llc.Dispose(ll);
618
619 return INVALID_POSITION;
620 }
621
622 /**
623 * Find the document position corresponding to an x coordinate on a particular document line.
624 * Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
625 */
626 int Editor::PositionFromLineX(int lineDoc, int x) {
627 RefreshStyleData();
628 if (lineDoc >= pdoc->LinesTotal())
629 return pdoc->Length();
630 //Platform::DebugPrintf("Position of (%d,%d) line = %d top=%d\n", pt.x, pt.y, line, topLine);
631 AutoSurface surface(IsUnicodeMode());
632 LineLayout *ll = RetrieveLineLayout(lineDoc);
633 int retVal = 0;
634 if (surface && ll) {
635 unsigned int posLineStart = pdoc->LineStart(lineDoc);
636 LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
637 retVal = ll->numCharsInLine + posLineStart;
638 int subLine = 0;
639 int lineStart = ll->LineStart(subLine);
640 int lineEnd = ll->LineStart(subLine+1);
641 int subLineStart = ll->positions[lineStart];
642 for (int i = lineStart; i < lineEnd; i++) {
643 if (x < (((ll->positions[i] + ll->positions[i + 1]) / 2) - subLineStart) ||
644 ll->chars[i] == '\r' || ll->chars[i] == '\n') {
645 retVal = pdoc->MovePositionOutsideChar(i + posLineStart, 1);
646 break;
647 }
648 }
649 }
650 llc.Dispose(ll);
651 return retVal;
652 }
653
654 // If painting then abandon the painting because a wider redraw is needed.
655 // Return true if calling code should stop drawing
656 bool Editor::AbandonPaint() {
657 if ((paintState == painting) && !paintingAllText) {
658 paintState = paintAbandoned;
659 }
660 return paintState == paintAbandoned;
661 }
662
663 void Editor::RedrawRect(PRectangle rc) {
664 //Platform::DebugPrintf("Redraw %0d,%0d - %0d,%0d\n", rc.left, rc.top, rc.right, rc.bottom);
665
666 // Clip the redraw rectangle into the client area
667 PRectangle rcClient = GetClientRectangle();
668 if (rc.top < rcClient.top)
669 rc.top = rcClient.top;
670 if (rc.bottom > rcClient.bottom)
671 rc.bottom = rcClient.bottom;
672 if (rc.left < rcClient.left)
673 rc.left = rcClient.left;
674 if (rc.right > rcClient.right)
675 rc.right = rcClient.right;
676
677 if ((rc.bottom > rc.top) && (rc.right > rc.left)) {
678 wMain.InvalidateRectangle(rc);
679 }
680 }
681
682 void Editor::Redraw() {
683 //Platform::DebugPrintf("Redraw all\n");
684 wMain.InvalidateAll();
685 }
686
687 void Editor::RedrawSelMargin() {
688 if (!AbandonPaint()) {
689 if (vs.maskInLine) {
690 Redraw();
691 } else {
692 PRectangle rcSelMargin = GetClientRectangle();
693 rcSelMargin.right = vs.fixedColumnWidth;
694 wMain.InvalidateRectangle(rcSelMargin);
695 }
696 }
697 }
698
699 PRectangle Editor::RectangleFromRange(int start, int end) {
700 int minPos = start;
701 if (minPos > end)
702 minPos = end;
703 int maxPos = start;
704 if (maxPos < end)
705 maxPos = end;
706 int minLine = cs.DisplayFromDoc(pdoc->LineFromPosition(minPos));
707 int lineDocMax = pdoc->LineFromPosition(maxPos);
708 int maxLine = cs.DisplayFromDoc(lineDocMax) + cs.GetHeight(lineDocMax) - 1;
709 PRectangle rcClient = GetTextRectangle();
710 PRectangle rc;
711 rc.left = vs.fixedColumnWidth;
712 rc.top = (minLine - topLine) * vs.lineHeight;
713 if (rc.top < 0)
714 rc.top = 0;
715 rc.right = rcClient.right;
716 rc.bottom = (maxLine - topLine + 1) * vs.lineHeight;
717 // Ensure PRectangle is within 16 bit space
718 rc.top = Platform::Clamp(rc.top, -32000, 32000);
719 rc.bottom = Platform::Clamp(rc.bottom, -32000, 32000);
720
721 return rc;
722 }
723
724 void Editor::InvalidateRange(int start, int end) {
725 RedrawRect(RectangleFromRange(start, end));
726 }
727
728 int Editor::CurrentPosition() {
729 return currentPos;
730 }
731
732 bool Editor::SelectionEmpty() {
733 return anchor == currentPos;
734 }
735
736 int Editor::SelectionStart(int line) {
737 if ((line == -1) || (selType == selStream)) {
738 return Platform::Minimum(currentPos, anchor);
739 } else { // selType == selRectangle
740 int selStart = SelectionStart();
741 int selEnd = SelectionEnd();
742 int lineStart = pdoc->LineFromPosition(selStart);
743 int lineEnd = pdoc->LineFromPosition(selEnd);
744 if (line < lineStart || line > lineEnd) {
745 return -1;
746 } else {
747 int minX = Platform::Minimum(xStartSelect, xEndSelect);
748 return PositionFromLineX(line, minX);
749 }
750 }
751 }
752
753 int Editor::SelectionEnd(int line) {
754 if ((line == -1) || (selType == selStream)) {
755 return Platform::Maximum(currentPos, anchor);
756 } else { // selType == selRectangle
757 int selStart = SelectionStart();
758 int selEnd = SelectionEnd();
759 int lineStart = pdoc->LineFromPosition(selStart);
760 int lineEnd = pdoc->LineFromPosition(selEnd);
761 if (line < lineStart || line > lineEnd) {
762 return -1;
763 } else {
764 int maxX = Platform::Maximum(xStartSelect, xEndSelect);
765 // measure line and return character closest to minx
766 return PositionFromLineX(line, maxX);
767 }
768 }
769 }
770
771 void Editor::SetSelection(int currentPos_, int anchor_) {
772 currentPos_ = pdoc->ClampPositionIntoDocument(currentPos_);
773 anchor_ = pdoc->ClampPositionIntoDocument(anchor_);
774 if ((currentPos != currentPos_) || (anchor != anchor_)) {
775 int firstAffected = anchor;
776 if (firstAffected > currentPos)
777 firstAffected = currentPos;
778 if (firstAffected > anchor_)
779 firstAffected = anchor_;
780 if (firstAffected > currentPos_)
781 firstAffected = currentPos_;
782 int lastAffected = anchor;
783 if (lastAffected < currentPos)
784 lastAffected = currentPos;
785 if (lastAffected < anchor_)
786 lastAffected = anchor_;
787 if (lastAffected < (currentPos_ + 1)) // +1 ensures caret repainted
788 lastAffected = (currentPos_ + 1);
789 currentPos = currentPos_;
790 anchor = anchor_;
791 needUpdateUI = true;
792 InvalidateRange(firstAffected, lastAffected);
793 }
794 ClaimSelection();
795 }
796
797 void Editor::SetSelection(int currentPos_) {
798 currentPos_ = pdoc->ClampPositionIntoDocument(currentPos_);
799 if (currentPos != currentPos_) {
800 int firstAffected = anchor;
801 if (firstAffected > currentPos)
802 firstAffected = currentPos;
803 if (firstAffected > currentPos_)
804 firstAffected = currentPos_;
805 int lastAffected = anchor;
806 if (lastAffected < currentPos)
807 lastAffected = currentPos;
808 if (lastAffected < (currentPos_ + 1)) // +1 ensures caret repainted
809 lastAffected = (currentPos_ + 1);
810 currentPos = currentPos_;
811 needUpdateUI = true;
812 InvalidateRange(firstAffected, lastAffected);
813 }
814 ClaimSelection();
815 }
816
817 void Editor::SetEmptySelection(int currentPos_) {
818 selType = selStream;
819 SetSelection(currentPos_, currentPos_);
820 }
821
822 int Editor::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
823 // Asks document to find a good position and then moves out of any invisible positions
824 pos = pdoc->MovePositionOutsideChar(pos, moveDir, checkLineEnd);
825 int mask = pdoc->stylingBitsMask;
826 if (moveDir > 0) {
827 while ((pos < pdoc->Length()) &&
828 (vs.styles[pdoc->StyleAt(pos - 1) & mask].IsProtected()))
829 pos++;
830 } else {
831 while ((pos > 0) &&
832 (vs.styles[pdoc->StyleAt(pos - 1) & mask].IsProtected()))
833 pos--;
834 }
835 return pos;
836 }
837
838 int Editor::MovePositionTo(int newPos, bool extend) {
839 int delta = newPos - currentPos;
840 newPos = pdoc->ClampPositionIntoDocument(newPos);
841 newPos = MovePositionOutsideChar(newPos, delta);
842 if (extend) {
843 SetSelection(newPos);
844 } else {
845 SetEmptySelection(newPos);
846 }
847 EnsureCaretVisible();
848 ShowCaretAtCurrentPosition();
849 NotifyMove(newPos);
850 return 0;
851 }
852
853 int Editor::MovePositionSoVisible(int pos, int moveDir) {
854 pos = pdoc->ClampPositionIntoDocument(pos);
855 pos = MovePositionOutsideChar(pos, moveDir);
856 int lineDoc = pdoc->LineFromPosition(pos);
857 if (cs.GetVisible(lineDoc)) {
858 return pos;
859 } else {
860 int lineDisplay = cs.DisplayFromDoc(lineDoc);
861 if (moveDir > 0) {
862 // lineDisplay is already line before fold as lines in fold use display line of line after fold
863 lineDisplay = Platform::Clamp(lineDisplay, 0, cs.LinesDisplayed());
864 return pdoc->LineStart(cs.DocFromDisplay(lineDisplay));
865 } else {
866 lineDisplay = Platform::Clamp(lineDisplay - 1, 0, cs.LinesDisplayed());
867 return pdoc->LineEnd(cs.DocFromDisplay(lineDisplay));
868 }
869 }
870 }
871
872 // Choose the x position that the caret will try to stick to as it is moves up and down
873 void Editor::SetLastXChosen() {
874 Point pt = LocationFromPosition(currentPos);
875 lastXChosen = pt.x;
876 }
877
878 void Editor::ScrollTo(int line) {
879 int topLineNew = Platform::Clamp(line, 0, MaxScrollPos());
880 if (topLineNew != topLine) {
881 // Try to optimise small scrolls
882 int linesToMove = topLine - topLineNew;
883 SetTopLine(topLineNew);
884 ShowCaretAtCurrentPosition();
885 // Perform redraw rather than scroll if many lines would be redrawn anyway.
886 if (abs(linesToMove) <= 10) {
887 ScrollText(linesToMove);
888 } else {
889 Redraw();
890 }
891 SetVerticalScrollPos();
892 }
893 }
894
895 void Editor::ScrollText(int /* linesToMove */) {
896 //Platform::DebugPrintf("Editor::ScrollText %d\n", linesToMove);
897 Redraw();
898 }
899
900 void Editor::HorizontalScrollTo(int xPos) {
901 //Platform::DebugPrintf("HorizontalScroll %d\n", xPos);
902 if (xPos < 0)
903 xPos = 0;
904 if ((wrapState == eWrapNone) && (xOffset != xPos)) {
905 xOffset = xPos;
906 SetHorizontalScrollPos();
907 RedrawRect(GetClientRectangle());
908 }
909 }
910
911 void Editor::MoveCaretInsideView() {
912 PRectangle rcClient = GetTextRectangle();
913 Point pt = LocationFromPosition(currentPos);
914 if (pt.y < rcClient.top) {
915 MovePositionTo(PositionFromLocation(
916 Point(lastXChosen, rcClient.top)));
917 } else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) {
918 int yOfLastLineFullyDisplayed = rcClient.top + (LinesOnScreen() - 1) * vs.lineHeight;
919 MovePositionTo(PositionFromLocation(
920 Point(lastXChosen, rcClient.top + yOfLastLineFullyDisplayed)));
921 }
922 }
923
924 int Editor::DisplayFromPosition(int pos) {
925 int lineDoc = pdoc->LineFromPosition(pos);
926 int lineDisplay = cs.DisplayFromDoc(lineDoc);
927 AutoSurface surface(IsUnicodeMode());
928 LineLayout *ll = RetrieveLineLayout(lineDoc);
929 if (surface && ll) {
930 LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
931 unsigned int posLineStart = pdoc->LineStart(lineDoc);
932 int posInLine = pos - posLineStart;
933 lineDisplay--; // To make up for first increment ahead.
934 for (int subLine=0; subLine<ll->lines; subLine++) {
935 if (posInLine >= ll->LineStart(subLine)) {
936 lineDisplay++;
937 }
938 }
939 }
940 llc.Dispose(ll);
941 return lineDisplay;
942 }
943
944 /**
945 * Ensure the caret is reasonably visible in context.
946 *
947 Caret policy in SciTE
948
949 If slop is set, we can define a slop value.
950 This value defines an unwanted zone (UZ) where the caret is... unwanted.
951 This zone is defined as a number of pixels near the vertical margins,
952 and as a number of lines near the horizontal margins.
953 By keeping the caret away from the edges, it is seen within its context,
954 so it is likely that the identifier that the caret is on can be completely seen,
955 and that the current line is seen with some of the lines following it which are
956 often dependent on that line.
957
958 If strict is set, the policy is enforced... strictly.
959 The caret is centred on the display if slop is not set,
960 and cannot go in the UZ if slop is set.
961
962 If jumps is set, the display is moved more energetically
963 so the caret can move in the same direction longer before the policy is applied again.
964 '3UZ' notation is used to indicate three time the size of the UZ as a distance to the margin.
965
966 If even is not set, instead of having symmetrical UZs,
967 the left and bottom UZs are extended up to right and top UZs respectively.
968 This way, we favour the displaying of useful information: the begining of lines,
969 where most code reside, and the lines after the caret, eg. the body of a function.
970
971 | | | | |
972 slop | strict | jumps | even | Caret can go to the margin | When reaching limit (caret going out of
973 | | | | | visibility or going into the UZ) display is...
974 -----+--------+-------+------+--------------------------------------------+--------------------------------------------------------------
975 0 | 0 | 0 | 0 | Yes | moved to put caret on top/on right
976 0 | 0 | 0 | 1 | Yes | moved by one position
977 0 | 0 | 1 | 0 | Yes | moved to put caret on top/on right
978 0 | 0 | 1 | 1 | Yes | centred on the caret
979 0 | 1 | - | 0 | Caret is always on top/on right of display | -
980 0 | 1 | - | 1 | No, caret is always centred | -
981 1 | 0 | 0 | 0 | Yes | moved to put caret out of the asymmetrical UZ
982 1 | 0 | 0 | 1 | Yes | moved to put caret out of the UZ
983 1 | 0 | 1 | 0 | Yes | moved to put caret at 3UZ of the top or right margin
984 1 | 0 | 1 | 1 | Yes | moved to put caret at 3UZ of the margin
985 1 | 1 | - | 0 | Caret is always at UZ of top/right margin | -
986 1 | 1 | 0 | 1 | No, kept out of UZ | moved by one position
987 1 | 1 | 1 | 1 | No, kept out of UZ | moved to put caret at 3UZ of the margin
988 */
989 void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
990 //Platform::DebugPrintf("EnsureCaretVisible %d %s\n", xOffset, useMargin ? " margin" : " ");
991 PRectangle rcClient = GetTextRectangle();
992 //int rcClientFullWidth = rcClient.Width();
993 int posCaret = currentPos;
994 if (posDrag >= 0) {
995 posCaret = posDrag;
996 }
997 Point pt = LocationFromPosition(posCaret);
998 Point ptBottomCaret = pt;
999 ptBottomCaret.y += vs.lineHeight - 1;
1000 int lineCaret = DisplayFromPosition(posCaret);
1001 bool bSlop, bStrict, bJump, bEven;
1002
1003 // Vertical positioning
1004 if (vert && (pt.y < rcClient.top || ptBottomCaret.y > rcClient.bottom || (caretYPolicy & CARET_STRICT) != 0)) {
1005 int linesOnScreen = LinesOnScreen();
1006 int halfScreen = Platform::Maximum(linesOnScreen - 1, 2) / 2;
1007 int newTopLine = topLine;
1008 bSlop = (caretYPolicy & CARET_SLOP) != 0;
1009 bStrict = (caretYPolicy & CARET_STRICT) != 0;
1010 bJump = (caretYPolicy & CARET_JUMPS) != 0;
1011 bEven = (caretYPolicy & CARET_EVEN) != 0;
1012
1013 // It should be possible to scroll the window to show the caret,
1014 // but this fails to remove the caret on GTK+
1015 if (bSlop) { // A margin is defined
1016 int yMoveT, yMoveB;
1017 if (bStrict) {
1018 int yMarginT, yMarginB;
1019 if (!useMargin) {
1020 // In drag mode, avoid moves
1021 // otherwise, a double click will select several lines.
1022 yMarginT = yMarginB = 0;
1023 } else {
1024 // yMarginT must equal to caretYSlop, with a minimum of 1 and
1025 // a maximum of slightly less than half the heigth of the text area.
1026 yMarginT = Platform::Clamp(caretYSlop, 1, halfScreen);
1027 if (bEven) {
1028 yMarginB = yMarginT;
1029 } else {
1030 yMarginB = linesOnScreen - yMarginT - 1;
1031 }
1032 }
1033 yMoveT = yMarginT;
1034 if (bEven) {
1035 if (bJump) {
1036 yMoveT = Platform::Clamp(caretYSlop * 3, 1, halfScreen);
1037 }
1038 yMoveB = yMoveT;
1039 } else {
1040 yMoveB = linesOnScreen - yMoveT - 1;
1041 }
1042 if (lineCaret < topLine + yMarginT) {
1043 // Caret goes too high
1044 newTopLine = lineCaret - yMoveT;
1045 } else if (lineCaret > topLine + linesOnScreen - 1 - yMarginB) {
1046 // Caret goes too low
1047 newTopLine = lineCaret - linesOnScreen + 1 + yMoveB;
1048 }
1049 } else { // Not strict
1050 yMoveT = bJump ? caretYSlop * 3 : caretYSlop;
1051 yMoveT = Platform::Clamp(yMoveT, 1, halfScreen);
1052 if (bEven) {
1053 yMoveB = yMoveT;
1054 } else {
1055 yMoveB = linesOnScreen - yMoveT - 1;
1056 }
1057 if (lineCaret < topLine) {
1058 // Caret goes too high
1059 newTopLine = lineCaret - yMoveT;
1060 } else if (lineCaret > topLine + linesOnScreen - 1) {
1061 // Caret goes too low
1062 newTopLine = lineCaret - linesOnScreen + 1 + yMoveB;
1063 }
1064 }
1065 } else { // No slop
1066 if (!bStrict && !bJump) {
1067 // Minimal move
1068 if (lineCaret < topLine) {
1069 // Caret goes too high
1070 newTopLine = lineCaret;
1071 } else if (lineCaret > topLine + linesOnScreen - 1) {
1072 // Caret goes too low
1073 if (bEven) {
1074 newTopLine = lineCaret - linesOnScreen + 1;
1075 } else {
1076 newTopLine = lineCaret;
1077 }
1078 }
1079 } else { // Strict or going out of display
1080 if (bEven) {
1081 // Always center caret
1082 newTopLine = lineCaret - halfScreen;
1083 } else {
1084 // Always put caret on top of display
1085 newTopLine = lineCaret;
1086 }
1087 }
1088 }
1089 newTopLine = Platform::Clamp(newTopLine, 0, MaxScrollPos());
1090 if (newTopLine != topLine) {
1091 SetTopLine(newTopLine);
1092 SetVerticalScrollPos();
1093 Redraw();
1094 }
1095 }
1096
1097 // Horizontal positioning
1098 if (horiz && (wrapState == eWrapNone)) {
1099 int halfScreen = Platform::Maximum(rcClient.Width() - 4, 4) / 2;
1100 int xOffsetNew = xOffset;
1101 bSlop = (caretXPolicy & CARET_SLOP) != 0;
1102 bStrict = (caretXPolicy & CARET_STRICT) != 0;
1103 bJump = (caretXPolicy & CARET_JUMPS) != 0;
1104 bEven = (caretXPolicy & CARET_EVEN) != 0;
1105
1106 if (bSlop) { // A margin is defined
1107 int xMoveL, xMoveR;
1108 if (bStrict) {
1109 int xMarginL, xMarginR;
1110 if (!useMargin) {
1111 // In drag mode, avoid moves unless very near of the margin
1112 // otherwise, a simple click will select text.
1113 xMarginL = xMarginR = 2;
1114 } else {
1115 // xMargin must equal to caretXSlop, with a minimum of 2 and
1116 // a maximum of slightly less than half the width of the text area.
1117 xMarginR = Platform::Clamp(caretXSlop, 2, halfScreen);
1118 if (bEven) {
1119 xMarginL = xMarginR;
1120 } else {
1121 xMarginL = rcClient.Width() - xMarginR - 4;
1122 }
1123 }
1124 if (bJump && bEven) {
1125 // Jump is used only in even mode
1126 xMoveL = xMoveR = Platform::Clamp(caretXSlop * 3, 1, halfScreen);
1127 } else {
1128 xMoveL = xMoveR = 0; // Not used, avoid a warning
1129 }
1130 if (pt.x < rcClient.left + xMarginL) {
1131 // Caret is on the left of the display
1132 if (bJump && bEven) {
1133 xOffsetNew -= xMoveL;
1134 } else {
1135 // Move just enough to allow to display the caret
1136 xOffsetNew -= (rcClient.left + xMarginL) - pt.x;
1137 }
1138 } else if (pt.x >= rcClient.right - xMarginR) {
1139 // Caret is on the right of the display
1140 if (bJump && bEven) {
1141 xOffsetNew += xMoveR;
1142 } else {
1143 // Move just enough to allow to display the caret
1144 xOffsetNew += pt.x - (rcClient.right - xMarginR) + 1;
1145 }
1146 }
1147 } else { // Not strict
1148 xMoveR = bJump ? caretXSlop * 3 : caretXSlop;
1149 xMoveR = Platform::Clamp(xMoveR, 1, halfScreen);
1150 if (bEven) {
1151 xMoveL = xMoveR;
1152 } else {
1153 xMoveL = rcClient.Width() - xMoveR - 4;
1154 }
1155 if (pt.x < rcClient.left) {
1156 // Caret is on the left of the display
1157 xOffsetNew -= xMoveL;
1158 } else if (pt.x >= rcClient.right) {
1159 // Caret is on the right of the display
1160 xOffsetNew += xMoveR;
1161 }
1162 }
1163 } else { // No slop
1164 if (bStrict ||
1165 (bJump && (pt.x < rcClient.left || pt.x >= rcClient.right))) {
1166 // Strict or going out of display
1167 if (bEven) {
1168 // Center caret
1169 xOffsetNew += pt.x - rcClient.left - halfScreen;
1170 } else {
1171 // Put caret on right
1172 xOffsetNew += pt.x - rcClient.right + 1;
1173 }
1174 } else {
1175 // Move just enough to allow to display the caret
1176 if (pt.x < rcClient.left) {
1177 // Caret is on the left of the display
1178 if (bEven) {
1179 xOffsetNew -= rcClient.left - pt.x;
1180 } else {
1181 xOffsetNew += pt.x - rcClient.right + 1;
1182 }
1183 } else if (pt.x >= rcClient.right) {
1184 // Caret is on the right of the display
1185 xOffsetNew += pt.x - rcClient.right + 1;
1186 }
1187 }
1188 }
1189 // In case of a jump (find result) largely out of display, adjust the offset to display the caret
1190 if (pt.x + xOffset < rcClient.left + xOffsetNew) {
1191 xOffsetNew = pt.x + xOffset - rcClient.left;
1192 } else if (pt.x + xOffset >= rcClient.right + xOffsetNew) {
1193 xOffsetNew = pt.x + xOffset - rcClient.right + 1;
1194 }
1195 if (xOffsetNew < 0) {
1196 xOffsetNew = 0;
1197 }
1198 if (xOffset != xOffsetNew) {
1199 xOffset = xOffsetNew;
1200 SetHorizontalScrollPos();
1201 Redraw();
1202 }
1203 }
1204 }
1205
1206 void Editor::ShowCaretAtCurrentPosition() {
1207 if (hasFocus) {
1208 caret.active = true;
1209 caret.on = true;
1210 SetTicking(true);
1211 } else {
1212 caret.active = false;
1213 caret.on = false;
1214 }
1215 InvalidateCaret();
1216 }
1217
1218 void Editor::DropCaret() {
1219 caret.active = false;
1220 InvalidateCaret();
1221 }
1222
1223 void Editor::InvalidateCaret() {
1224 if (posDrag >= 0)
1225 InvalidateRange(posDrag, posDrag + 1);
1226 else
1227 InvalidateRange(currentPos, currentPos + 1);
1228 }
1229
1230 void Editor::NeedWrapping(int docLineStartWrapping) {
1231 if (docLineLastWrapped > (docLineStartWrapping - 1)) {
1232 docLineLastWrapped = docLineStartWrapping - 1;
1233 if (docLineLastWrapped < -1)
1234 docLineLastWrapped = -1;
1235 llc.Invalidate(LineLayout::llPositions);
1236 }
1237 }
1238
1239 // Check if wrapping needed and perform any needed wrapping.
1240 // Return true if wrapping occurred.
1241 bool Editor::WrapLines() {
1242 int goodTopLine = topLine;
1243 bool wrapOccurred = false;
1244 if (docLineLastWrapped < pdoc->LinesTotal()) {
1245 if (wrapState == eWrapNone) {
1246 if (wrapWidth != LineLayout::wrapWidthInfinite) {
1247 wrapWidth = LineLayout::wrapWidthInfinite;
1248 for (int lineDoc=0; lineDoc<pdoc->LinesTotal(); lineDoc++) {
1249 cs.SetHeight(lineDoc, 1);
1250 }
1251 wrapOccurred = true;
1252 }
1253 docLineLastWrapped = 0x7ffffff;
1254 } else {
1255 //ElapsedTime et;
1256 int lineDocTop = cs.DocFromDisplay(topLine);
1257 int subLineTop = topLine - cs.DisplayFromDoc(lineDocTop);
1258 PRectangle rcTextArea = GetClientRectangle();
1259 rcTextArea.left = vs.fixedColumnWidth;
1260 rcTextArea.right -= vs.rightMarginWidth;
1261 wrapWidth = rcTextArea.Width();
1262 // Ensure all of the document is styled.
1263 pdoc->EnsureStyledTo(pdoc->Length());
1264 AutoSurface surface(IsUnicodeMode());
1265 if (surface) {
1266 int lastLineToWrap = pdoc->LinesTotal();
1267 while (docLineLastWrapped <= lastLineToWrap) {
1268 docLineLastWrapped++;
1269 LineLayout *ll = RetrieveLineLayout(docLineLastWrapped);
1270 int linesWrapped = 1;
1271 if (ll) {
1272 LayoutLine(docLineLastWrapped, surface, vs, ll, wrapWidth);
1273 linesWrapped = ll->lines;
1274 }
1275 llc.Dispose(ll);
1276 if (cs.SetHeight(docLineLastWrapped, linesWrapped)) {
1277 wrapOccurred = true;
1278 }
1279 }
1280 }
1281 goodTopLine = cs.DisplayFromDoc(lineDocTop);
1282 if (subLineTop < cs.GetHeight(lineDocTop))
1283 goodTopLine += subLineTop;
1284 else
1285 goodTopLine += cs.GetHeight(lineDocTop);
1286 //double durWrap = et.Duration(true);
1287 //Platform::DebugPrintf("Wrap:%9.6g \n", durWrap);
1288 }
1289 }
1290 if (wrapOccurred) {
1291 SetScrollBars();
1292 SetTopLine(Platform::Clamp(goodTopLine, 0, MaxScrollPos()));
1293 SetVerticalScrollPos();
1294 }
1295 return wrapOccurred;
1296 }
1297
1298 int Editor::SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) {
1299 if (vs.markers[markerCheck].markType == SC_MARK_EMPTY)
1300 return markerDefault;
1301 return markerCheck;
1302 }
1303
1304 void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
1305 if (vs.fixedColumnWidth == 0)
1306 return;
1307
1308 PRectangle rcMargin = GetClientRectangle();
1309 rcMargin.right = vs.fixedColumnWidth;
1310
1311 if (!rc.Intersects(rcMargin))
1312 return;
1313
1314 Surface *surface;
1315 if (bufferedDraw) {
1316 surface = pixmapSelMargin;
1317 } else {
1318 surface = surfWindow;
1319 }
1320
1321 PRectangle rcSelMargin = rcMargin;
1322 rcSelMargin.right = rcMargin.left;
1323
1324 for (int margin = 0; margin < vs.margins; margin++) {
1325 if (vs.ms[margin].width > 0) {
1326
1327 rcSelMargin.left = rcSelMargin.right;
1328 rcSelMargin.right = rcSelMargin.left + vs.ms[margin].width;
1329
1330 if (vs.ms[margin].symbol) {
1331 /* alternate scheme:
1332 if (vs.ms[margin].mask & SC_MASK_FOLDERS)
1333 surface->FillRectangle(rcSelMargin, vs.styles[STYLE_DEFAULT].back.allocated);
1334 else
1335 // Required because of special way brush is created for selection margin
1336 surface->FillRectangle(rcSelMargin, pixmapSelPattern);
1337 */
1338 if (vs.ms[margin].mask & SC_MASK_FOLDERS)
1339 // Required because of special way brush is created for selection margin
1340 surface->FillRectangle(rcSelMargin, *pixmapSelPattern);
1341 else
1342 surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back.allocated);
1343 } else {
1344 surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back.allocated);
1345 }
1346
1347 int visibleLine = topLine;
1348 int yposScreen = 0;
1349
1350 // Work out whether the top line is whitespace located after a
1351 // lessening of fold level which implies a 'fold tail' but which should not
1352 // be displayed until the last of a sequence of whitespace.
1353 bool needWhiteClosure = false;
1354 int level = pdoc->GetLevel(cs.DocFromDisplay(topLine));
1355 if (level & SC_FOLDLEVELWHITEFLAG) {
1356 int lineBack = cs.DocFromDisplay(topLine);
1357 int levelPrev = level;
1358 while ((lineBack > 0) && (levelPrev & SC_FOLDLEVELWHITEFLAG)) {
1359 lineBack--;
1360 levelPrev = pdoc->GetLevel(lineBack);
1361 }
1362 if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
1363 if ((level & SC_FOLDLEVELNUMBERMASK) < (levelPrev & SC_FOLDLEVELNUMBERMASK))
1364 needWhiteClosure = true;
1365 }
1366 }
1367
1368 // Old code does not know about new markers needed to distinguish all cases
1369 int folderOpenMid = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEROPENMID,
1370 SC_MARKNUM_FOLDEROPEN);
1371 int folderEnd = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEREND,
1372 SC_MARKNUM_FOLDER);
1373
1374 while ((visibleLine < cs.LinesDisplayed()) && yposScreen < rcMargin.bottom) {
1375
1376 PLATFORM_ASSERT(visibleLine < cs.LinesDisplayed());
1377
1378 int lineDoc = cs.DocFromDisplay(visibleLine);
1379 PLATFORM_ASSERT(cs.GetVisible(lineDoc));
1380 bool firstSubLine = visibleLine == cs.DisplayFromDoc(lineDoc);
1381
1382 // Decide which fold indicator should be displayed
1383 level = pdoc->GetLevel(lineDoc);
1384 int levelNext = pdoc->GetLevel(lineDoc+1);
1385 int marks = pdoc->GetMark(lineDoc);
1386 if (!firstSubLine)
1387 marks = 0;
1388 int levelNum = level & SC_FOLDLEVELNUMBERMASK;
1389 int levelNextNum = levelNext & SC_FOLDLEVELNUMBERMASK;
1390 if (level & SC_FOLDLEVELHEADERFLAG) {
1391 if (firstSubLine) {
1392 if (cs.GetExpanded(lineDoc)) {
1393 if (levelNum == SC_FOLDLEVELBASE)
1394 marks |= 1 << SC_MARKNUM_FOLDEROPEN;
1395 else
1396 marks |= 1 << folderOpenMid;
1397 } else {
1398 if (levelNum == SC_FOLDLEVELBASE)
1399 marks |= 1 << SC_MARKNUM_FOLDER;
1400 else
1401 marks |= 1 << folderEnd;
1402 }
1403 } else {
1404 marks |= 1 << SC_MARKNUM_FOLDERSUB;
1405 }
1406 needWhiteClosure = false;
1407 } else if (level & SC_FOLDLEVELWHITEFLAG) {
1408 if (needWhiteClosure) {
1409 if (levelNext & SC_FOLDLEVELWHITEFLAG) {
1410 marks |= 1 << SC_MARKNUM_FOLDERSUB;
1411 } else if (levelNum > SC_FOLDLEVELBASE) {
1412 marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
1413 needWhiteClosure = false;
1414 } else {
1415 marks |= 1 << SC_MARKNUM_FOLDERTAIL;
1416 needWhiteClosure = false;
1417 }
1418 } else if (levelNum > SC_FOLDLEVELBASE) {
1419 if (levelNextNum < levelNum) {
1420 if (levelNextNum > SC_FOLDLEVELBASE) {
1421 marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
1422 } else {
1423 marks |= 1 << SC_MARKNUM_FOLDERTAIL;
1424 }
1425 } else {
1426 marks |= 1 << SC_MARKNUM_FOLDERSUB;
1427 }
1428 }
1429 } else if (levelNum > SC_FOLDLEVELBASE) {
1430 if (levelNextNum < levelNum) {
1431 needWhiteClosure = false;
1432 if (levelNext & SC_FOLDLEVELWHITEFLAG) {
1433 marks |= 1 << SC_MARKNUM_FOLDERSUB;
1434 needWhiteClosure = true;
1435 } else if (levelNextNum > SC_FOLDLEVELBASE) {
1436 marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
1437 } else {
1438 marks |= 1 << SC_MARKNUM_FOLDERTAIL;
1439 }
1440 } else {
1441 marks |= 1 << SC_MARKNUM_FOLDERSUB;
1442 }
1443 }
1444
1445 marks &= vs.ms[margin].mask;
1446 PRectangle rcMarker = rcSelMargin;
1447 rcMarker.top = yposScreen;
1448 rcMarker.bottom = yposScreen + vs.lineHeight;
1449 if (!vs.ms[margin].symbol) {
1450 char number[100];
1451 number[0] = '\0';
1452 if (firstSubLine)
1453 sprintf(number, "%d", lineDoc + 1);
1454 if (foldFlags & 64)
1455 sprintf(number, "%X", pdoc->GetLevel(lineDoc));
1456 PRectangle rcNumber = rcMarker;
1457 // Right justify
1458 int width = surface->WidthText(vs.styles[STYLE_LINENUMBER].font, number, strlen(number));
1459 int xpos = rcNumber.right - width - 3;
1460 rcNumber.left = xpos;
1461 surface->DrawTextNoClip(rcNumber, vs.styles[STYLE_LINENUMBER].font,
1462 rcNumber.top + vs.maxAscent, number, strlen(number),
1463 vs.styles[STYLE_LINENUMBER].fore.allocated,
1464 vs.styles[STYLE_LINENUMBER].back.allocated);
1465 }
1466
1467 if (marks) {
1468 for (int markBit = 0; (markBit < 32) && marks; markBit++) {
1469 if (marks & 1) {
1470 vs.markers[markBit].Draw(surface, rcMarker, vs.styles[STYLE_LINENUMBER].font);
1471 }
1472 marks >>= 1;
1473 }
1474 }
1475
1476 visibleLine++;
1477 yposScreen += vs.lineHeight;
1478 }
1479 }
1480 }
1481
1482 PRectangle rcBlankMargin = rcMargin;
1483 rcBlankMargin.left = rcSelMargin.right;
1484 surface->FillRectangle(rcBlankMargin, vs.styles[STYLE_DEFAULT].back.allocated);
1485
1486 if (bufferedDraw) {
1487 surfWindow->Copy(rcMargin, Point(), *pixmapSelMargin);
1488 }
1489 }
1490
1491 void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid) {
1492 int ydiff = (rcTab.bottom - rcTab.top) / 2;
1493 int xhead = rcTab.right - 1 - ydiff;
1494 if (xhead <= rcTab.left) {
1495 ydiff -= rcTab.left - xhead - 1;
1496 xhead = rcTab.left - 1;
1497 }
1498 if ((rcTab.left + 2) < (rcTab.right - 1))
1499 surface->MoveTo(rcTab.left + 2, ymid);
1500 else
1501 surface->MoveTo(rcTab.right - 1, ymid);
1502 surface->LineTo(rcTab.right - 1, ymid);
1503 surface->LineTo(xhead, ymid - ydiff);
1504 surface->MoveTo(rcTab.right - 1, ymid);
1505 surface->LineTo(xhead, ymid + ydiff);
1506 }
1507
1508 static bool IsSpaceOrTab(char ch) {
1509 return ch == ' ' || ch == '\t';
1510 }
1511
1512 LineLayout *Editor::RetrieveLineLayout(int lineNumber) {
1513 int posLineStart = pdoc->LineStart(lineNumber);
1514 int posLineEnd = pdoc->LineStart(lineNumber + 1);
1515 int lineCaret = pdoc->LineFromPosition(currentPos);
1516 return llc.Retrieve(lineNumber, lineCaret,
1517 posLineEnd - posLineStart, pdoc->GetStyleClock(),
1518 LinesOnScreen() + 1, pdoc->LinesTotal());
1519 }
1520
1521 /**
1522 * Fill in the LineLayout data for the given line.
1523 * Copy the given @a line and its styles from the document into local arrays.
1524 * Also determine the x position at which each character starts.
1525 */
1526 void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll, int width) {
1527 if (!ll)
1528 return;
1529 int posLineStart = pdoc->LineStart(line);
1530 int posLineEnd = pdoc->LineStart(line + 1);
1531 // If the line is very long, limit the treatment to a length that should fit in the viewport
1532 if (posLineEnd > (posLineStart + ll->maxLineLength)) {
1533 posLineEnd = posLineStart + ll->maxLineLength;
1534 }
1535 if (ll->validity == LineLayout::llCheckTextAndStyle) {
1536 int lineLength = 0;
1537 for (int cid = posLineStart; cid < posLineEnd; cid++) {
1538 char chDoc = pdoc->CharAt(cid);
1539 if (vstyle.viewEOL || ((chDoc != '\r') && (chDoc != '\n'))) {
1540 lineLength++;
1541 }
1542 }
1543 if (lineLength == ll->numCharsInLine) {
1544 int numCharsInLine = 0;
1545 // See if chars, styles, indicators, are all the same
1546 bool allSame = true;
1547 char styleByte;
1548 int styleMask = pdoc->stylingBitsMask;
1549 // Check base line layout
1550 for (int charInDoc = posLineStart; allSame && (charInDoc < posLineEnd); charInDoc++) {
1551 char chDoc = pdoc->CharAt(charInDoc);
1552 styleByte = pdoc->StyleAt(charInDoc);
1553 if (vstyle.viewEOL || ((chDoc != '\r') && (chDoc != '\n'))) {
1554 allSame = allSame &&
1555 (ll->styles[numCharsInLine] == static_cast<char>(styleByte & styleMask));
1556 allSame = allSame &&
1557 (ll->indicators[numCharsInLine] == static_cast<char>(styleByte & ~styleMask));
1558 if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseUpper)
1559 allSame = allSame &&
1560 (ll->chars[numCharsInLine] == static_cast<char>(toupper(chDoc)));
1561 else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
1562 allSame = allSame &&
1563 (ll->chars[numCharsInLine] == static_cast<char>(tolower(chDoc)));
1564 else
1565 allSame = allSame &&
1566 (ll->chars[numCharsInLine] == chDoc);
1567 numCharsInLine++;
1568 }
1569 }
1570 if (allSame) {
1571 ll->validity = LineLayout::llPositions;
1572 } else {
1573 ll->validity = LineLayout::llInvalid;
1574 }
1575 } else {
1576 ll->validity = LineLayout::llInvalid;
1577 }
1578 }
1579 if (ll->validity == LineLayout::llInvalid) {
1580 ll->widthLine = LineLayout::wrapWidthInfinite;
1581 ll->lines = 1;
1582 int numCharsInLine = 0;
1583 if (vstyle.edgeState == EDGE_BACKGROUND) {
1584 ll->edgeColumn = pdoc->FindColumn(line, theEdge);
1585 if (ll->edgeColumn >= posLineStart) {
1586 ll->edgeColumn -= posLineStart;
1587 }
1588 } else {
1589 ll->edgeColumn = -1;
1590 }
1591
1592 char styleByte = 0;
1593 int styleMask = pdoc->stylingBitsMask;
1594 // Fill base line layout
1595 for (int charInDoc = posLineStart; charInDoc < posLineEnd; charInDoc++) {
1596 char chDoc = pdoc->CharAt(charInDoc);
1597 styleByte = pdoc->StyleAt(charInDoc);
1598 if (vstyle.viewEOL || ((chDoc != '\r') && (chDoc != '\n'))) {
1599 ll->chars[numCharsInLine] = chDoc;
1600 ll->styles[numCharsInLine] = static_cast<char>(styleByte & styleMask);
1601 ll->indicators[numCharsInLine] = static_cast<char>(styleByte & ~styleMask);
1602 if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseUpper)
1603 ll->chars[numCharsInLine] = static_cast<char>(toupper(chDoc));
1604 else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
1605 ll->chars[numCharsInLine] = static_cast<char>(tolower(chDoc));
1606 numCharsInLine++;
1607 }
1608 }
1609 ll->xHighlightGuide = 0;
1610 // Extra element at the end of the line to hold end x position and act as
1611 ll->chars[numCharsInLine] = 0; // Also triggers processing in the loops as this is a control character
1612 ll->styles[numCharsInLine] = styleByte; // For eolFilled
1613 ll->indicators[numCharsInLine] = 0;
1614
1615 // Layout the line, determining the position of each character,
1616 // with an extra element at the end for the end of the line.
1617 int startseg = 0; // Start of the current segment, in char. number
1618 int startsegx = 0; // Start of the current segment, in pixels
1619 ll->positions[0] = 0;
1620 unsigned int tabWidth = vstyle.spaceWidth * pdoc->tabInChars;
1621 bool lastSegItalics = false;
1622 Font &ctrlCharsFont = vstyle.styles[STYLE_CONTROLCHAR].font;
1623
1624 for (int charInLine = 0; charInLine < numCharsInLine; charInLine++) {
1625 if ((ll->styles[charInLine] != ll->styles[charInLine + 1]) ||
1626 IsControlCharacter(ll->chars[charInLine]) || IsControlCharacter(ll->chars[charInLine + 1])) {
1627 ll->positions[startseg] = 0;
1628 if (vstyle.styles[ll->styles[charInLine]].visible) {
1629 if (IsControlCharacter(ll->chars[charInLine])) {
1630 if (ll->chars[charInLine] == '\t') {
1631 ll->positions[charInLine + 1] = ((((startsegx + 2) /
1632 tabWidth) + 1) * tabWidth) - startsegx;
1633 } else if (controlCharSymbol < 32) {
1634 const char *ctrlChar = ControlCharacterString(ll->chars[charInLine]);
1635 // +3 For a blank on front and rounded edge each side:
1636 ll->positions[charInLine + 1] = surface->WidthText(ctrlCharsFont, ctrlChar, strlen(ctrlChar)) + 3;
1637 } else {
1638 char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
1639 surface->MeasureWidths(ctrlCharsFont, cc, 1,
1640 ll->positions + startseg + 1);
1641 }
1642 lastSegItalics = false;
1643 } else { // Regular character
1644 lastSegItalics = vstyle.styles[ll->styles[charInLine]].italic;
1645 int lenSeg = charInLine - startseg + 1;
1646 if ((lenSeg == 1) && (' ' == ll->chars[startseg])) {
1647 // Over half the segments are single characters and of these about half are space characters.
1648 ll->positions[charInLine + 1] = vstyle.styles[ll->styles[charInLine]].spaceWidth;
1649 } else {
1650 surface->MeasureWidths(vstyle.styles[ll->styles[charInLine]].font, ll->chars + startseg,
1651 lenSeg, ll->positions + startseg + 1);
1652 }
1653 }
1654 } else { // invisible
1655 for (int posToZero = startseg; posToZero <= (charInLine + 1); posToZero++) {
1656 ll->positions[posToZero] = 0;
1657 }
1658 }
1659 for (int posToIncrease = startseg; posToIncrease <= (charInLine + 1); posToIncrease++) {
1660 ll->positions[posToIncrease] += startsegx;
1661 }
1662 startsegx = ll->positions[charInLine + 1];
1663 startseg = charInLine + 1;
1664 }
1665 }
1666 // Small hack to make lines that end with italics not cut off the edge of the last character
1667 if ((startseg > 0) && lastSegItalics) {
1668 ll->positions[startseg] += 2;
1669 }
1670 ll->numCharsInLine = numCharsInLine;
1671 ll->validity = LineLayout::llPositions;
1672 }
1673 // Hard to cope when too narrow, so just assume there is space
1674 if (width < 20) {
1675 width = 20;
1676 }
1677 if ((ll->validity == LineLayout::llPositions) || (ll->widthLine != width)) {
1678 ll->widthLine = width;
1679 if (width == LineLayout::wrapWidthInfinite) {
1680 ll->lines = 1;
1681 } else if (width > ll->positions[ll->numCharsInLine]) {
1682 // Simple common case where line does not need wrapping.
1683 ll->lines = 1;
1684 } else {
1685 ll->lines = 0;
1686 // Calculate line start positions based upon width.
1687 // For now this is simplistic - wraps on byte rather than character and
1688 // in the middle of words. Should search for spaces or style changes.
1689 int lastGoodBreak = 0;
1690 int lastLineStart = 0;
1691 int startOffset = 0;
1692 int p=0;
1693 while (p < ll->numCharsInLine) {
1694 if ((ll->positions[p+1] - startOffset) >= width) {
1695 if (lastGoodBreak == lastLineStart) {
1696 // Try moving to start of last character
1697 if (p > 0) {
1698 lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1)
1699 - posLineStart;
1700 }
1701 if (lastGoodBreak == lastLineStart) {
1702 // Ensure at least one character on line.
1703 lastGoodBreak = pdoc->MovePositionOutsideChar(lastGoodBreak + posLineStart +1, 1)
1704 - posLineStart;
1705 }
1706 }
1707 lastLineStart = lastGoodBreak;
1708 ll->lines++;
1709 ll->SetLineStart(ll->lines, lastGoodBreak);
1710 startOffset = ll->positions[lastGoodBreak];
1711 p = lastGoodBreak + 1;
1712 continue;
1713 }
1714 if (p > 0) {
1715 if (ll->styles[p] != ll->styles[p-1]) {
1716 lastGoodBreak = p;
1717 } else if (IsSpaceOrTab(ll->chars[p-1]) && !IsSpaceOrTab(ll->chars[p])) {
1718 lastGoodBreak = p;
1719 }
1720 }
1721 p++;
1722 }
1723 ll->lines++;
1724 }
1725 ll->validity = LineLayout::llLines;
1726 }
1727 }
1728
1729 void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,
1730 PRectangle rcLine, LineLayout *ll, int subLine) {
1731
1732 PRectangle rcSegment = rcLine;
1733
1734 // Using one font for all control characters so it can be controlled independently to ensure
1735 // the box goes around the characters tightly. Seems to be no way to work out what height
1736 // is taken by an individual character - internal leading gives varying results.
1737 Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
1738
1739 // See if something overrides the line background color: Either if caret is on the line
1740 // and background color is set for that, or if a marker is defined that forces its background
1741 // color onto the line, or if a marker is defined but has no selection margin in which to
1742 // display itself. These are checked in order with the earlier taking precedence. When
1743 // multiple markers cause background override, the color for the highest numbered one is used.
1744 bool overrideBackground = false;
1745 ColourAllocated background;
1746 if (caret.active && vsDraw.showCaretLineBackground && ll->containsCaret) {
1747 overrideBackground = true;
1748 background = vsDraw.caretLineBackground.allocated;
1749 }
1750 if (!overrideBackground) {
1751 int marks = pdoc->GetMark(line);
1752 for (int markBit = 0; (markBit < 32) && marks; markBit++) {
1753 if ((marks & 1) && vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND) {
1754 background = vsDraw.markers[markBit].back.allocated;
1755 overrideBackground = true;
1756 }
1757 marks >>= 1;
1758 }
1759 }
1760 if (!overrideBackground) {
1761 if (vsDraw.maskInLine) {
1762 int marks = pdoc->GetMark(line) & vsDraw.maskInLine;
1763 if (marks) {
1764 overrideBackground = true;
1765 for (int markBit = 0; (markBit < 32) && marks; markBit++) {
1766 if (marks & 1) {
1767 background = vsDraw.markers[markBit].back.allocated;
1768 }
1769 marks >>= 1;
1770 }
1771 }
1772 }
1773 }
1774
1775 bool inIndentation = subLine == 0; // Do not handle indentation except on first subline.
1776 int indentWidth = pdoc->indentInChars * vsDraw.spaceWidth;
1777 if (indentWidth == 0)
1778 indentWidth = pdoc->tabInChars * vsDraw.spaceWidth;
1779
1780 int posLineStart = pdoc->LineStart(line);
1781 int posLineEnd = pdoc->LineStart(line + 1);
1782
1783 int styleMask = pdoc->stylingBitsMask;
1784 int startseg = ll->LineStart(subLine);
1785 int subLineStart = ll->positions[startseg];
1786 int lineStart = 0;
1787 int lineEnd = 0;
1788 if (subLine < ll->lines) {
1789 lineStart = ll->LineStart(subLine);
1790 lineEnd = ll->LineStart(subLine+1);
1791 }
1792 for (int i = lineStart; i < lineEnd; i++) {
1793
1794 int iDoc = i + posLineStart;
1795 // If there is the end of a style run for any reason
1796 if ((ll->styles[i] != ll->styles[i + 1]) ||
1797 i == (lineEnd-1) ||
1798 IsControlCharacter(ll->chars[i]) || IsControlCharacter(ll->chars[i + 1]) ||
1799 ((ll->selStart != ll->selEnd) && ((iDoc + 1 == ll->selStart) || (iDoc + 1 == ll->selEnd))) ||
1800 (i == (ll->edgeColumn - 1))) {
1801 rcSegment.left = ll->positions[startseg] + xStart - subLineStart;
1802 rcSegment.right = ll->positions[i + 1] + xStart - subLineStart;
1803 // Only try to draw if really visible - enhances performance by not calling environment to
1804 // draw strings that are completely past the right side of the window.
1805 //if (rcSegment.left <= rcLine.right) {
1806 if ((rcSegment.left <= rcLine.right) && (rcSegment.right >= rcLine.left)) {
1807 int styleMain = ll->styles[i];
1808 ColourAllocated textBack = vsDraw.styles[styleMain].back.allocated;
1809 ColourAllocated textFore = vsDraw.styles[styleMain].fore.allocated;
1810 Font &textFont = vsDraw.styles[styleMain].font;
1811 bool inSelection = (iDoc >= ll->selStart) && (iDoc < ll->selEnd) && (ll->selStart != ll->selEnd);
1812 if (inSelection) {
1813 if (vsDraw.selbackset) {
1814 if (primarySelection)
1815 textBack = vsDraw.selbackground.allocated;
1816 else
1817 textBack = vsDraw.selbackground2.allocated;
1818 }
1819 if (vsDraw.selforeset)
1820 textFore = vsDraw.selforeground.allocated;
1821 } else {
1822 if (overrideBackground)
1823 textBack = background;
1824 if ((vsDraw.edgeState == EDGE_BACKGROUND) && (i >= ll->edgeColumn) && (ll->chars[i] != '\n') && (ll->chars[i] != '\r'))
1825 textBack = vsDraw.edgecolour.allocated;
1826 }
1827 if (ll->chars[i] == '\t') {
1828 // Manage tab display
1829 surface->FillRectangle(rcSegment, textBack);
1830 if ((vsDraw.viewWhitespace != wsInvisible) || ((inIndentation && vsDraw.viewIndentationGuides))) {
1831 surface->PenColour(textFore);
1832 }
1833 if (inIndentation && vsDraw.viewIndentationGuides) {
1834 for (int xIG = ll->positions[i] / indentWidth * indentWidth; xIG < ll->positions[i + 1]; xIG += indentWidth) {
1835 if (xIG >= ll->positions[i] && xIG > 0) {
1836 Point from(0, ((lineVisible & 1) && (vsDraw.lineHeight & 1)) ? 1 : 0);
1837 PRectangle rcCopyArea(xIG + xStart + 1, rcSegment.top, xIG + xStart + 2, rcSegment.bottom);
1838 surface->Copy(rcCopyArea, from, (ll->xHighlightGuide == xIG) ?
1839 *pixmapIndentGuideHighlight : *pixmapIndentGuide);
1840 }
1841 }
1842 }
1843 if (vsDraw.viewWhitespace != wsInvisible) {
1844 if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
1845 PRectangle rcTab(rcSegment.left + 1, rcSegment.top + 4,
1846 rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent);
1847 DrawTabArrow(surface, rcTab, rcSegment.top + vsDraw.lineHeight / 2);
1848 }
1849 }
1850 } else if (IsControlCharacter(ll->chars[i])) {
1851 // Manage control character display
1852 inIndentation = false;
1853 if (controlCharSymbol < 32) {
1854 // Draw the character
1855 const char *ctrlChar = ControlCharacterString(ll->chars[i]);
1856 surface->FillRectangle(rcSegment, textBack);
1857 int normalCharHeight = surface->Ascent(ctrlCharsFont) -
1858 surface->InternalLeading(ctrlCharsFont);
1859 PRectangle rcCChar = rcSegment;
1860 rcCChar.left = rcCChar.left + 1;
1861 rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight;
1862 rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1;
1863 PRectangle rcCentral = rcCChar;
1864 rcCentral.top++;
1865 rcCentral.bottom--;
1866 surface->FillRectangle(rcCentral, textFore);
1867 PRectangle rcChar = rcCChar;
1868 rcChar.left++;
1869 rcChar.right--;
1870 surface->DrawTextClipped(rcChar, ctrlCharsFont,
1871 rcSegment.top + vsDraw.maxAscent, ctrlChar, strlen(ctrlChar),
1872 textBack, textFore);
1873 } else {
1874 char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
1875 surface->DrawTextNoClip(rcSegment, ctrlCharsFont,
1876 rcSegment.top + vsDraw.maxAscent,
1877 cc, 1, textBack, textFore);
1878 }
1879 } else {
1880 // Manage normal display
1881 surface->DrawTextNoClip(rcSegment, textFont,
1882 rcSegment.top + vsDraw.maxAscent, ll->chars + startseg,
1883 i - startseg + 1, textFore, textBack);
1884 if (vsDraw.viewWhitespace != wsInvisible ||
1885 (inIndentation && vsDraw.viewIndentationGuides)) {
1886 for (int cpos = 0; cpos <= i - startseg; cpos++) {
1887 if (ll->chars[cpos + startseg] == ' ') {
1888 if (vsDraw.viewWhitespace != wsInvisible) {
1889 if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
1890 int xmid = (ll->positions[cpos + startseg] + ll->positions[cpos + startseg + 1]) / 2;
1891 PRectangle rcDot(xmid + xStart - subLineStart, rcSegment.top + vsDraw.lineHeight / 2, 0, 0);
1892 rcDot.right = rcDot.left + 1;
1893 rcDot.bottom = rcDot.top + 1;
1894 surface->FillRectangle(rcDot, textFore);
1895 }
1896 }
1897 if (inIndentation && vsDraw.viewIndentationGuides) {
1898 int startSpace = ll->positions[cpos + startseg];
1899 if (startSpace > 0 && (startSpace % indentWidth == 0)) {
1900 Point from(0, ((lineVisible & 1) && (vsDraw.lineHeight & 1)) ? 1 : 0);
1901 PRectangle rcCopyArea(startSpace + xStart + 1, rcSegment.top, startSpace + xStart + 2, rcSegment.bottom);
1902 surface->Copy(rcCopyArea, from, (ll->xHighlightGuide == ll->positions[cpos + startseg]) ?
1903 *pixmapIndentGuideHighlight : *pixmapIndentGuide);
1904 }
1905 }
1906 } else {
1907 inIndentation = false;
1908 }
1909 }
1910 }
1911 }
1912 if (vsDraw.styles[styleMain].underline) {
1913 PRectangle rcUL = rcSegment;
1914 rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
1915 rcUL.bottom = rcUL.top + 1;
1916 surface->FillRectangle(rcUL, textFore);
1917 }
1918 }
1919 startseg = i + 1;
1920 }
1921 }
1922
1923 // Draw indicators
1924 int indStart[INDIC_MAX + 1] = {0};
1925 for (int indica = 0; indica <= INDIC_MAX; indica++)
1926 indStart[indica] = 0;
1927
1928 for (int indicPos = 0; indicPos < ll->numCharsInLine; indicPos++) {
1929 if (ll->indicators[indicPos] != ll->indicators[indicPos + 1]) {
1930 int mask = 1 << pdoc->stylingBits;
1931 for (int indicnum = 0; mask < 0x100; indicnum++) {
1932 if ((ll->indicators[indicPos + 1] & mask) && !(ll->indicators[indicPos] & mask)) {
1933 indStart[indicnum] = ll->positions[indicPos + 1];
1934 }
1935 if (!(ll->indicators[indicPos + 1] & mask) && (ll->indicators[indicPos] & mask)) {
1936 PRectangle rcIndic(
1937 indStart[indicnum] + xStart,
1938 rcLine.top + vsDraw.maxAscent,
1939 ll->positions[indicPos + 1] + xStart,
1940 rcLine.top + vsDraw.maxAscent + 3);
1941 vsDraw.indicators[indicnum].Draw(surface, rcIndic);
1942 }
1943 mask = mask << 1;
1944 }
1945 }
1946 }
1947 // End of the drawing of the current line
1948
1949 // Fill in a PRectangle representing the end of line characters
1950 int xEol = ll->positions[lineEnd] - subLineStart;
1951 rcSegment.left = xEol + xStart;
1952 rcSegment.right = xEol + vsDraw.aveCharWidth + xStart;
1953 bool eolInSelection = (subLine == (ll->lines-1)) &&
1954 (posLineEnd > ll->selStart) && (posLineEnd <= ll->selEnd) && (ll->selStart != ll->selEnd);
1955 if (eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1)) {
1956 if (primarySelection)
1957 surface->FillRectangle(rcSegment, vsDraw.selbackground.allocated);
1958 else
1959 surface->FillRectangle(rcSegment, vsDraw.selbackground2.allocated);
1960 } else if (overrideBackground) {
1961 surface->FillRectangle(rcSegment, background);
1962 } else {
1963 surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated);
1964 }
1965
1966 rcSegment.left = xEol + vsDraw.aveCharWidth + xStart;
1967 rcSegment.right = rcLine.right;
1968 if (overrideBackground) {
1969 surface->FillRectangle(rcSegment, background);
1970 } else if (vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].eolFilled) {
1971 surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated);
1972 } else {
1973 surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back.allocated);
1974 }
1975
1976 if (vsDraw.edgeState == EDGE_LINE) {
1977 int edgeX = theEdge * vsDraw.spaceWidth;
1978 rcSegment.left = edgeX + xStart;
1979 rcSegment.right = rcSegment.left + 1;
1980 surface->FillRectangle(rcSegment, vsDraw.edgecolour.allocated);
1981 }
1982 }
1983
1984 void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
1985 //Platform::DebugPrintf("Paint:%1d (%3d,%3d) ... (%3d,%3d)\n",
1986 // paintingAllText, rcArea.left, rcArea.top, rcArea.right, rcArea.bottom);
1987
1988 RefreshStyleData();
1989
1990 PRectangle rcClient = GetClientRectangle();
1991 //Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d) %d\n",
1992 // rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
1993
1994 if (WrapLines()) {
1995 // The wrapping process has changed the height of some lines so abandon this
1996 // paint for a complete repaint.
1997 if (AbandonPaint()) {
1998 return;
1999 }
2000 }
2001
2002 if (!pixmapSelPattern->Initialised()) {
2003 pixmapSelPattern->InitPixMap(8, 8, surfaceWindow);
2004 // This complex procedure is to reproduce the checker board dithered pattern used by windows
2005 // for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half
2006 // way between the chrome colour and the chrome highlight colour making a nice transition
2007 // between the window chrome and the content area. And it works in low colour depths.
2008 PRectangle rcPattern(0, 0, 8, 8);
2009 if (vs.selbarlight.desired == ColourDesired(0xff, 0xff, 0xff)) {
2010 pixmapSelPattern->FillRectangle(rcPattern, vs.selbar.allocated);
2011 pixmapSelPattern->PenColour(vs.selbarlight.allocated);
2012 for (int stripe = 0; stripe < 8; stripe++) {
2013 pixmapSelPattern->MoveTo(0, stripe * 2);
2014 pixmapSelPattern->LineTo(8, stripe * 2 - 8);
2015 }
2016 } else {
2017 // User has chosen an unusual chrome colour scheme so just use the highlight edge colour.
2018 pixmapSelPattern->FillRectangle(rcPattern, vs.selbarlight.allocated);
2019 }
2020 }
2021 if (!pixmapIndentGuide->Initialised()) {
2022 // 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
2023 pixmapIndentGuide->InitPixMap(1, vs.lineHeight + 1, surfaceWindow);
2024 pixmapIndentGuideHighlight->InitPixMap(1, vs.lineHeight + 1, surfaceWindow);
2025 PRectangle rcIG(0, 0, 1, vs.lineHeight);
2026 pixmapIndentGuide->FillRectangle(rcIG, vs.styles[STYLE_INDENTGUIDE].back.allocated);
2027 pixmapIndentGuide->PenColour(vs.styles[STYLE_INDENTGUIDE].fore.allocated);
2028 pixmapIndentGuideHighlight->FillRectangle(rcIG, vs.styles[STYLE_BRACELIGHT].back.allocated);
2029 pixmapIndentGuideHighlight->PenColour(vs.styles[STYLE_BRACELIGHT].fore.allocated);
2030 for (int stripe = 1; stripe < vs.lineHeight + 1; stripe += 2) {
2031 pixmapIndentGuide->MoveTo(0, stripe);
2032 pixmapIndentGuide->LineTo(2, stripe);
2033 pixmapIndentGuideHighlight->MoveTo(0, stripe);
2034 pixmapIndentGuideHighlight->LineTo(2, stripe);
2035 }
2036 }
2037
2038 if (bufferedDraw) {
2039 if (!pixmapLine->Initialised()) {
2040 pixmapLine->InitPixMap(rcClient.Width(), rcClient.Height(),
2041 surfaceWindow);
2042 pixmapSelMargin->InitPixMap(vs.fixedColumnWidth,
2043 rcClient.Height(), surfaceWindow);
2044 }
2045 }
2046
2047 surfaceWindow->SetPalette(&palette, true);
2048 pixmapLine->SetPalette(&palette, !hasFocus);
2049
2050 int screenLinePaintFirst = rcArea.top / vs.lineHeight;
2051 // The area to be painted plus one extra line is styled.
2052 // The extra line is to determine when a style change, such as starting a comment flows on to other lines.
2053 int lineStyleLast = topLine + (rcArea.bottom - 1) / vs.lineHeight + 1;
2054 //Platform::DebugPrintf("Paint lines = %d .. %d\n", topLine + screenLinePaintFirst, lineStyleLast);
2055 int endPosPaint = pdoc->Length();
2056 if (lineStyleLast < cs.LinesDisplayed())
2057 endPosPaint = pdoc->LineStart(cs.DocFromDisplay(lineStyleLast + 1));
2058
2059 int xStart = vs.fixedColumnWidth - xOffset;
2060 int ypos = 0;
2061 if (!bufferedDraw)
2062 ypos += screenLinePaintFirst * vs.lineHeight;
2063 int yposScreen = screenLinePaintFirst * vs.lineHeight;
2064
2065 // Ensure we are styled as far as we are painting.
2066 pdoc->EnsureStyledTo(endPosPaint);
2067 bool paintAbandonedByStyling = paintState == paintAbandoned;
2068 if (needUpdateUI) {
2069 NotifyUpdateUI();
2070 needUpdateUI = false;
2071 }
2072
2073 PaintSelMargin(surfaceWindow, rcArea);
2074
2075 PRectangle rcRightMargin = rcClient;
2076 rcRightMargin.left = rcRightMargin.right - vs.rightMarginWidth;
2077 if (rcArea.Intersects(rcRightMargin)) {
2078 surfaceWindow->FillRectangle(rcRightMargin, vs.styles[STYLE_DEFAULT].back.allocated);
2079 }
2080
2081 if (paintState == paintAbandoned) {
2082 // Either styling or NotifyUpdateUI noticed that painting is needed
2083 // outside the current painting rectangle
2084 //Platform::DebugPrintf("Abandoning paint\n");
2085 if (wrapState != eWrapNone) {
2086 if (paintAbandonedByStyling) {
2087 // Styling has spilled over a line end, such as occurs by starting a multiline
2088 // comment. The width of subsequent text may have changed, so rewrap.
2089 NeedWrapping(cs.DocFromDisplay(topLine));
2090 }
2091 }
2092 return;
2093 }
2094 //Platform::DebugPrintf("start display %d, offset = %d\n", pdoc->Length(), xOffset);
2095
2096 // Do the painting
2097 if (rcArea.right > vs.fixedColumnWidth) {
2098
2099 Surface *surface = surfaceWindow;
2100 if (bufferedDraw) {
2101 surface = pixmapLine;
2102 }
2103 surface->SetUnicodeMode(IsUnicodeMode());
2104
2105 int visibleLine = topLine + screenLinePaintFirst;
2106
2107 int posCaret = currentPos;
2108 if (posDrag >= 0)
2109 posCaret = posDrag;
2110 int lineCaret = pdoc->LineFromPosition(posCaret);
2111
2112 // Remove selection margin from drawing area so text will not be drawn
2113 // on it in unbuffered mode.
2114 PRectangle rcTextArea = rcClient;
2115 rcTextArea.left = vs.fixedColumnWidth;
2116 rcTextArea.right -= vs.rightMarginWidth;
2117 surfaceWindow->SetClip(rcTextArea);
2118
2119 // Loop on visible lines
2120 //double durLayout = 0.0;
2121 //double durPaint = 0.0;
2122 //double durCopy = 0.0;
2123 //ElapsedTime etWhole;
2124 int lineDocPrevious = -1; // Used to avoid laying out one document line multiple times
2125 LineLayout *ll = 0;
2126 while (visibleLine < cs.LinesDisplayed() && yposScreen < rcArea.bottom) {
2127
2128 int lineDoc = cs.DocFromDisplay(visibleLine);
2129 // Only visible lines should be handled by the code within the loop
2130 PLATFORM_ASSERT(cs.GetVisible(lineDoc));
2131 int lineStartSet = cs.DisplayFromDoc(lineDoc);
2132 int subLine = visibleLine - lineStartSet;
2133
2134 // Copy this line and its styles from the document into local arrays
2135 // and determine the x position at which each character starts.
2136 //ElapsedTime et;
2137 if (lineDoc != lineDocPrevious) {
2138 llc.Dispose(ll);
2139 ll = RetrieveLineLayout(lineDoc);
2140 LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
2141 lineDocPrevious = lineDoc;
2142 }
2143 //durLayout += et.Duration(true);
2144
2145 if (ll) {
2146 ll->selStart = SelectionStart(lineDoc);
2147 ll->selEnd = SelectionEnd(lineDoc);
2148 ll->containsCaret = lineDoc == lineCaret;
2149 if (hideSelection) {
2150 ll->selStart = -1;
2151 ll->selEnd = -1;
2152 ll->containsCaret = false;
2153 }
2154
2155 PRectangle rcLine = rcClient;
2156 rcLine.top = ypos;
2157 rcLine.bottom = ypos + vs.lineHeight;
2158
2159 Range rangeLine(pdoc->LineStart(lineDoc), pdoc->LineStart(lineDoc + 1));
2160 // Highlight the current braces if any
2161 ll->SetBracesHighlight(rangeLine, braces, static_cast<char>(bracesMatchStyle),
2162 highlightGuideColumn * vs.spaceWidth);
2163
2164 // Draw the line
2165 DrawLine(surface, vs, lineDoc, visibleLine, xStart, rcLine, ll, subLine);
2166 //durPaint += et.Duration(true);
2167
2168 // Restore the precvious styles for the brace highlights in case layout is in cache.
2169 ll->RestoreBracesHighlight(rangeLine, braces);
2170
2171 bool expanded = cs.GetExpanded(lineDoc);
2172 if ( (expanded && (foldFlags & 2)) || (!expanded && (foldFlags & 4)) ) {
2173 if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) {
2174 PRectangle rcFoldLine = rcLine;
2175 rcFoldLine.bottom = rcFoldLine.top + 1;
2176 surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
2177 }
2178 }
2179 if ( (expanded && (foldFlags & 8)) || (!expanded && (foldFlags & 16)) ) {
2180 if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) {
2181 PRectangle rcFoldLine = rcLine;
2182 rcFoldLine.top = rcFoldLine.bottom - 1;
2183 surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
2184 }
2185 }
2186
2187 // Draw the Caret
2188 if (lineDoc == lineCaret) {
2189 int offset = Platform::Minimum(posCaret - rangeLine.start, ll->maxLineLength);
2190 if ((offset >= ll->LineStart(subLine)) &&
2191 ((offset < ll->LineStart(subLine+1)) || offset == ll->numCharsInLine)) {
2192 int xposCaret = ll->positions[offset] - ll->positions[ll->LineStart(subLine)] + xStart;
2193 int widthOverstrikeCaret;
2194 if (posCaret == pdoc->Length()) { // At end of document
2195 widthOverstrikeCaret = vs.aveCharWidth;
2196 } else if ((posCaret - rangeLine.start) >= ll->numCharsInLine) { // At end of line
2197 widthOverstrikeCaret = vs.aveCharWidth;
2198 } else {
2199 widthOverstrikeCaret = ll->positions[offset + 1] - ll->positions[offset];
2200 }
2201 if (widthOverstrikeCaret < 3) // Make sure its visible
2202 widthOverstrikeCaret = 3;
2203 if (((caret.active && caret.on) || (posDrag >= 0)) && xposCaret >= 0) {
2204 PRectangle rcCaret = rcLine;
2205 int caretWidthOffset = 0;
2206 if ((offset > 0) && (vs.caretWidth > 1))
2207 caretWidthOffset = 1; // Move back so overlaps both character cells.
2208 if (posDrag >= 0) {
2209 rcCaret.left = xposCaret - caretWidthOffset;
2210 rcCaret.right = rcCaret.left + vs.caretWidth;
2211 } else {
2212 if (inOverstrike) {
2213 rcCaret.top = rcCaret.bottom - 2;
2214 rcCaret.left = xposCaret + 1;
2215 rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1;
2216 } else {
2217 rcCaret.left = xposCaret - caretWidthOffset;
2218 rcCaret.right = rcCaret.left + vs.caretWidth;
2219 }
2220 }
2221 surface->FillRectangle(rcCaret, vs.caretcolour.allocated);
2222 }
2223 }
2224 }
2225
2226 if (bufferedDraw) {
2227 Point from(vs.fixedColumnWidth, 0);
2228 PRectangle rcCopyArea(vs.fixedColumnWidth, yposScreen,
2229 rcClient.right, yposScreen + vs.lineHeight);
2230 surfaceWindow->Copy(rcCopyArea, from, *pixmapLine);
2231 }
2232 //durCopy += et.Duration(true);
2233 }
2234
2235 if (!bufferedDraw) {
2236 ypos += vs.lineHeight;
2237 }
2238
2239 yposScreen += vs.lineHeight;
2240 visibleLine++;
2241 //gdk_flush();
2242 }
2243 llc.Dispose(ll);
2244 //if (durPaint < 0.00000001)
2245 // durPaint = 0.00000001;
2246
2247 // Right column limit indicator
2248 PRectangle rcBeyondEOF = rcClient;
2249 rcBeyondEOF.left = vs.fixedColumnWidth;
2250 rcBeyondEOF.right = rcBeyondEOF.right;
2251 rcBeyondEOF.top = (cs.LinesDisplayed() - topLine) * vs.lineHeight;
2252 if (rcBeyondEOF.top < rcBeyondEOF.bottom) {
2253 surfaceWindow->FillRectangle(rcBeyondEOF, vs.styles[STYLE_DEFAULT].back.allocated);
2254 if (vs.edgeState == EDGE_LINE) {
2255 int edgeX = theEdge * vs.spaceWidth;
2256 rcBeyondEOF.left = edgeX + xStart;
2257 rcBeyondEOF.right = rcBeyondEOF.left + 1;
2258 surfaceWindow->FillRectangle(rcBeyondEOF, vs.edgecolour.allocated);
2259 }
2260 }
2261 //Platform::DebugPrintf(
2262 //"Layout:%9.6g Paint:%9.6g Ratio:%9.6g Copy:%9.6g Total:%9.6g\n",
2263 //durLayout, durPaint, durLayout / durPaint, durCopy, etWhole.Duration());
2264 NotifyPainted();
2265 }
2266 }
2267
2268 // Space (3 space characters) between line numbers and text when printing.
2269 #define lineNumberPrintSpace " "
2270
2271 ColourDesired InvertedLight(ColourDesired orig) {
2272 unsigned int r = orig.GetRed();
2273 unsigned int g = orig.GetGreen();
2274 unsigned int b = orig.GetBlue();
2275 unsigned int l = (r + g + b) / 3; // There is a better calculation for this that matches human eye
2276 unsigned int il = 0xff - l;
2277 if (l == 0)
2278 return ColourDesired(0xff, 0xff, 0xff);
2279 r = r * il / l;
2280 g = g * il / l;
2281 b = b * il / l;
2282 return ColourDesired(Platform::Minimum(r, 0xff), Platform::Minimum(g, 0xff), Platform::Minimum(b, 0xff));
2283 }
2284
2285 // This is mostly copied from the Paint method but with some things omitted
2286 // such as the margin markers, line numbers, selection and caret
2287 // Should be merged back into a combined Draw method.
2288 long Editor::FormatRange(bool draw, RangeToFormat *pfr) {
2289 if (!pfr)
2290 return 0;
2291
2292 AutoSurface surface(pfr->hdc, IsUnicodeMode());
2293 if (!surface)
2294 return 0;
2295 AutoSurface surfaceMeasure(pfr->hdcTarget, IsUnicodeMode());
2296 if (!surfaceMeasure) {
2297 return 0;
2298 }
2299
2300 ViewStyle vsPrint(vs);
2301
2302 // Modify the view style for printing as do not normally want any of the transient features to be printed
2303 // Printing supports only the line number margin.
2304 int lineNumberIndex = -1;
2305 for (int margin = 0; margin < ViewStyle::margins; margin++) {
2306 if ((!vsPrint.ms[margin].symbol) && (vsPrint.ms[margin].width > 0)) {
2307 lineNumberIndex = margin;
2308 } else {
2309 vsPrint.ms[margin].width = 0;
2310 }
2311 }
2312 vsPrint.showMarkedLines = false;
2313 vsPrint.fixedColumnWidth = 0;
2314 vsPrint.zoomLevel = printMagnification;
2315 vsPrint.viewIndentationGuides = false;
2316 // Don't show the selection when printing
2317 vsPrint.selbackset = false;
2318 vsPrint.selforeset = false;
2319 vsPrint.showCaretLineBackground = false;
2320
2321 // Set colours for printing according to users settings
2322 for (int sty = 0;sty <= STYLE_MAX;sty++) {
2323 if (printColourMode == SC_PRINT_INVERTLIGHT) {
2324 vsPrint.styles[sty].fore.desired = InvertedLight(vsPrint.styles[sty].fore.desired);
2325 vsPrint.styles[sty].back.desired = InvertedLight(vsPrint.styles[sty].back.desired);
2326 } else if (printColourMode == SC_PRINT_BLACKONWHITE) {
2327 vsPrint.styles[sty].fore.desired = ColourDesired(0, 0, 0);
2328 vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
2329 } else if (printColourMode == SC_PRINT_COLOURONWHITE) {
2330 vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
2331 } else if (printColourMode == SC_PRINT_COLOURONWHITEDEFAULTBG) {
2332 if (sty <= STYLE_DEFAULT) {
2333 vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
2334 }
2335 }
2336 }
2337 // White background for the line numbers
2338 vsPrint.styles[STYLE_LINENUMBER].back.desired = ColourDesired(0xff, 0xff, 0xff);
2339
2340 vsPrint.Refresh(*surfaceMeasure);
2341 // Ensure colours are set up
2342 vsPrint.RefreshColourPalette(palette, true);
2343 vsPrint.RefreshColourPalette(palette, false);
2344 // Determining width must hapen after fonts have been realised in Refresh
2345 int lineNumberWidth = 0;
2346 if (lineNumberIndex >= 0) {
2347 lineNumberWidth = surface->WidthText(vsPrint.styles[STYLE_LINENUMBER].font,
2348 "99999" lineNumberPrintSpace, 5 + strlen(lineNumberPrintSpace));
2349 vsPrint.ms[lineNumberIndex].width = lineNumberWidth;
2350 }
2351
2352 int linePrintStart = pdoc->LineFromPosition(pfr->chrg.cpMin);
2353 int linePrintLast = linePrintStart + (pfr->rc.bottom - pfr->rc.top) / vsPrint.lineHeight - 1;
2354 if (linePrintLast < linePrintStart)
2355 linePrintLast = linePrintStart;
2356 int linePrintMax = pdoc->LineFromPosition(pfr->chrg.cpMax - 1);
2357 if (linePrintLast > linePrintMax)
2358 linePrintLast = linePrintMax;
2359 //Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n",
2360 // linePrintStart, linePrintLast, linePrintMax, pfr->rc.top, pfr->rc.bottom, vsPrint.lineHeight,
2361 // surfaceMeasure->Height(vsPrint.styles[STYLE_LINENUMBER].font));
2362 int endPosPrint = pdoc->Length();
2363 if (linePrintLast < pdoc->LinesTotal())
2364 endPosPrint = pdoc->LineStart(linePrintLast + 1);
2365
2366 // Ensure we are styled to where we are formatting.
2367 pdoc->EnsureStyledTo(endPosPrint);
2368
2369 int xStart = vsPrint.fixedColumnWidth + pfr->rc.left + lineNumberWidth;
2370 int ypos = pfr->rc.top;
2371 int line = linePrintStart;
2372
2373 if (draw) { // Otherwise just measuring
2374
2375 while (line <= linePrintLast && ypos < pfr->rc.bottom) {
2376
2377 // When printing, the hdc and hdcTarget may be the same, so
2378 // changing the state of surfaceMeasure may change the underlying
2379 // state of surface. Therefore, any cached state is discarded before
2380 // using each surface.
2381 surfaceMeasure->FlushCachedState();
2382
2383 // Copy this line and its styles from the document into local arrays
2384 // and determine the x position at which each character starts.
2385 LineLayout ll(8000);
2386 LayoutLine(line, surfaceMeasure, vsPrint, &ll);
2387 ll.selStart = -1;
2388 ll.selEnd = -1;
2389 ll.containsCaret = false;
2390
2391 PRectangle rcLine;
2392 rcLine.left = pfr->rc.left + lineNumberWidth;
2393 rcLine.top = ypos;
2394 rcLine.right = pfr->rc.right;
2395 rcLine.bottom = ypos + vsPrint.lineHeight;
2396
2397 if (lineNumberWidth) {
2398 char number[100];
2399 sprintf(number, "%d" lineNumberPrintSpace, line + 1);
2400 PRectangle rcNumber = rcLine;
2401 rcNumber.right = rcNumber.left + lineNumberWidth;
2402 // Right justify
2403 rcNumber.left -=
2404 surface->WidthText(vsPrint.styles[STYLE_LINENUMBER].font, number, strlen(number));
2405 surface->DrawTextNoClip(rcNumber, vsPrint.styles[STYLE_LINENUMBER].font,
2406 ypos + vsPrint.maxAscent, number, strlen(number),
2407 vsPrint.styles[STYLE_LINENUMBER].fore.allocated,
2408 vsPrint.styles[STYLE_LINENUMBER].back.allocated);
2409 }
2410
2411 // Draw the line
2412 surface->FlushCachedState();
2413 DrawLine(surface, vsPrint, line, line, xStart, rcLine, &ll);
2414
2415 ypos += vsPrint.lineHeight;
2416 line++;
2417 }
2418 }
2419
2420 return endPosPrint;
2421 }
2422
2423 int Editor::TextWidth(int style, const char *text) {
2424 RefreshStyleData();
2425 AutoSurface surface(IsUnicodeMode());
2426 if (surface) {
2427 return surface->WidthText(vs.styles[style].font, text, strlen(text));
2428 } else {
2429 return 1;
2430 }
2431 }
2432
2433 // Empty method is overridden on GTK+ to show / hide scrollbars
2434 void Editor::ReconfigureScrollBars() {
2435 }
2436
2437 void Editor::SetScrollBars() {
2438 RefreshStyleData();
2439
2440 int nMax = MaxScrollPos();
2441 int nPage = LinesOnScreen();
2442 bool modified = ModifyScrollBars(nMax + nPage - 1, nPage);
2443
2444 // TODO: ensure always showing as many lines as possible
2445 // May not be, if, for example, window made larger
2446 if (topLine > MaxScrollPos()) {
2447 SetTopLine(Platform::Clamp(topLine, 0, MaxScrollPos()));
2448 SetVerticalScrollPos();
2449 Redraw();
2450 }
2451 if (modified) {
2452 if (!AbandonPaint())
2453 Redraw();
2454 }
2455 //Platform::DebugPrintf("end max = %d page = %d\n", nMax, nPage);
2456 }
2457
2458 void Editor::ChangeSize() {
2459 DropGraphics();
2460 SetScrollBars();
2461 if (wrapState != eWrapNone) {
2462 PRectangle rcTextArea = GetClientRectangle();
2463 rcTextArea.left = vs.fixedColumnWidth;
2464 rcTextArea.right -= vs.rightMarginWidth;
2465 if (wrapWidth != rcTextArea.Width()) {
2466 NeedWrapping();
2467 Redraw();
2468 }
2469 }
2470 }
2471
2472 void Editor::AddChar(char ch) {
2473 char s[2];
2474 s[0] = ch;
2475 s[1] = '\0';
2476 AddCharUTF(s, 1);
2477 }
2478
2479 void Editor::AddCharUTF(char *s, unsigned int len, bool treatAsDBCS) {
2480 bool wasSelection = currentPos != anchor;
2481 ClearSelection();
2482 if (inOverstrike && !wasSelection) {
2483 if (currentPos < (pdoc->Length() - 1)) {
2484 if ((pdoc->CharAt(currentPos) != '\r') && (pdoc->CharAt(currentPos) != '\n')) {
2485 pdoc->DelChar(currentPos);
2486 }
2487 }
2488 }
2489 if (pdoc->InsertString(currentPos, s, len)) {
2490 SetEmptySelection(currentPos + len);
2491 }
2492 EnsureCaretVisible();
2493 // Avoid blinking during rapid typing:
2494 ShowCaretAtCurrentPosition();
2495 SetLastXChosen();
2496
2497 if (treatAsDBCS) {
2498 NotifyChar((static_cast<unsigned char>(s[0]) << 8) |
2499 static_cast<unsigned char>(s[1]));
2500 } else {
2501 int byte = static_cast<unsigned char>(s[0]);
2502 if ((byte < 0xC0) || (1 == len)) {
2503 // Handles UTF-8 characters between 0x01 and 0x7F and single byte
2504 // characters when not in UTF-8 mode.
2505 // Also treats \0 and naked trail bytes 0x80 to 0xBF as valid
2506 // characters representing themselves.
2507 } else {
2508 // Unroll 1 to 3 byte UTF-8 sequences. See reference data at:
2509 // http://www.cl.cam.ac.uk/~mgk25/unicode.html
2510 // http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
2511 if (byte < 0xE0) {
2512 int byte2 = static_cast<unsigned char>(s[1]);
2513 if ((byte2 & 0xC0) == 0x80) {
2514 // Two-byte-character lead-byte followed by a trail-byte.
2515 byte = (((byte & 0x1F) << 6) | (byte2 & 0x3F));
2516 }
2517 // A two-byte-character lead-byte not followed by trail-byte
2518 // represents itself.
2519 } else if (byte < 0xF0) {
2520 int byte2 = static_cast<unsigned char>(s[1]);
2521 int byte3 = static_cast<unsigned char>(s[2]);
2522 if (((byte2 & 0xC0) == 0x80) && ((byte3 & 0xC0) == 0x80)) {
2523 // Three-byte-character lead byte followed by two trail bytes.
2524 byte = (((byte & 0x0F) << 12) | ((byte2 & 0x3F) << 6) |
2525 (byte3 & 0x3F));
2526 }
2527 // A three-byte-character lead-byte not followed by two trail-bytes
2528 // represents itself.
2529 }
2530 }
2531 NotifyChar(byte);
2532 }
2533 }
2534
2535 void Editor::ClearSelection() {
2536 if (selType == selRectangle) {
2537 pdoc->BeginUndoAction();
2538 int lineStart = pdoc->LineFromPosition(SelectionStart());
2539 int lineEnd = pdoc->LineFromPosition(SelectionEnd());
2540 int startPos = SelectionStart();
2541 for (int line = lineEnd; line >= lineStart; line--) {
2542 startPos = SelectionStart(line);
2543 unsigned int chars = SelectionEnd(line) - startPos;
2544 if (0 != chars) {
2545 pdoc->DeleteChars(startPos, chars);
2546 }
2547 }
2548 SetEmptySelection(startPos);
2549 pdoc->EndUndoAction();
2550 selType = selStream;
2551 } else {
2552 int startPos = SelectionStart();
2553 unsigned int chars = SelectionEnd() - startPos;
2554 SetEmptySelection(startPos);
2555 if (0 != chars) {
2556 pdoc->BeginUndoAction();
2557 pdoc->DeleteChars(startPos, chars);
2558 pdoc->EndUndoAction();
2559 }
2560 }
2561 }
2562
2563 void Editor::ClearAll() {
2564 pdoc->BeginUndoAction();
2565 if (0 != pdoc->Length()) {
2566 pdoc->DeleteChars(0, pdoc->Length());
2567 }
2568 if (!pdoc->IsReadOnly()) {
2569 cs.Clear();
2570 }
2571 pdoc->EndUndoAction();
2572 anchor = 0;
2573 currentPos = 0;
2574 SetTopLine(0);
2575 SetVerticalScrollPos();
2576 }
2577
2578 void Editor::ClearDocumentStyle() {
2579 pdoc->StartStyling(0, '\377');
2580 pdoc->SetStyleFor(pdoc->Length(), 0);
2581 cs.ShowAll();
2582 pdoc->ClearLevels();
2583 }
2584
2585 void Editor::Cut() {
2586 if (!pdoc->IsReadOnly()) {
2587 Copy();
2588 ClearSelection();
2589 }
2590 }
2591
2592 void Editor::PasteRectangular(int pos, const char *ptr, int len) {
2593 if (pdoc->IsReadOnly()) {
2594 return;
2595 }
2596 currentPos = pos;
2597 int xInsert = XFromPosition(currentPos);
2598 int line = pdoc->LineFromPosition(currentPos);
2599 bool prevCr = false;
2600 pdoc->BeginUndoAction();
2601 for (int i = 0; i < len; i++) {
2602 if ((ptr[i] == '\r') || (ptr[i] == '\n')) {
2603 if ((ptr[i] == '\r') || (!prevCr))
2604 line++;
2605 if (line >= pdoc->LinesTotal()) {
2606 if (pdoc->eolMode != SC_EOL_LF)
2607 pdoc->InsertChar(pdoc->Length(), '\r');
2608 if (pdoc->eolMode != SC_EOL_CR)
2609 pdoc->InsertChar(pdoc->Length(), '\n');
2610 }
2611 // Pad the end of lines with spaces if required
2612 currentPos = PositionFromLineX(line, xInsert);
2613 if ((XFromPosition(currentPos) < xInsert) && (i + 1 < len)) {
2614 for (int i = 0; i < xInsert - XFromPosition(currentPos); i++) {
2615 pdoc->InsertChar(currentPos, ' ');
2616 currentPos++;
2617 }
2618 }
2619 prevCr = ptr[i] == '\r';
2620 } else {
2621 pdoc->InsertString(currentPos, ptr + i, 1);
2622 currentPos++;
2623 prevCr = false;
2624 }
2625 }
2626 pdoc->EndUndoAction();
2627 SetEmptySelection(pos);
2628 }
2629
2630 bool Editor::CanPaste() {
2631 return !pdoc->IsReadOnly();
2632 }
2633
2634 void Editor::Clear() {
2635 if (currentPos == anchor) {
2636 DelChar();
2637 } else {
2638 ClearSelection();
2639 }
2640 SetEmptySelection(currentPos);
2641 }
2642
2643 void Editor::SelectAll() {
2644 SetSelection(0, pdoc->Length());
2645 Redraw();
2646 }
2647
2648 void Editor::Undo() {
2649 if (pdoc->CanUndo()) {
2650 InvalidateCaret();
2651 int newPos = pdoc->Undo();
2652 SetEmptySelection(newPos);
2653 EnsureCaretVisible();
2654 }
2655 }
2656
2657 void Editor::Redo() {
2658 if (pdoc->CanRedo()) {
2659 int newPos = pdoc->Redo();
2660 SetEmptySelection(newPos);
2661 EnsureCaretVisible();
2662 }
2663 }
2664
2665 void Editor::DelChar() {
2666 pdoc->DelChar(currentPos);
2667 // Avoid blinking during rapid typing:
2668 ShowCaretAtCurrentPosition();
2669 }
2670
2671 void Editor::DelCharBack(bool allowLineStartDeletion) {
2672 if (currentPos == anchor) {
2673 int lineCurrentPos = pdoc->LineFromPosition(currentPos);
2674 if (allowLineStartDeletion || (pdoc->LineStart(lineCurrentPos) != currentPos)) {
2675 if (pdoc->GetColumn(currentPos) <= pdoc->GetLineIndentation(lineCurrentPos) &&
2676 pdoc->GetColumn(currentPos) > 0 && pdoc->backspaceUnindents) {
2677 pdoc->BeginUndoAction();
2678 int indentation = pdoc->GetLineIndentation(lineCurrentPos);
2679 int indentationStep = (pdoc->indentInChars ? pdoc->indentInChars : pdoc->tabInChars);
2680 if (indentation % indentationStep == 0) {
2681 pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
2682 } else {
2683 pdoc->SetLineIndentation(lineCurrentPos, indentation - (indentation % indentationStep));
2684 }
2685 SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
2686 pdoc->EndUndoAction();
2687 } else {
2688 pdoc->DelCharBack(currentPos);
2689 }
2690 }
2691 } else {
2692 ClearSelection();
2693 SetEmptySelection(currentPos);
2694 }
2695 // Avoid blinking during rapid typing:
2696 ShowCaretAtCurrentPosition();
2697 }
2698
2699 void Editor::NotifyFocus(bool) {}
2700
2701 void Editor::NotifyStyleToNeeded(int endStyleNeeded) {
2702 SCNotification scn;
2703 scn.nmhdr.code = SCN_STYLENEEDED;
2704 scn.position = endStyleNeeded;
2705 NotifyParent(scn);
2706 }
2707
2708 void Editor::NotifyStyleNeeded(Document*, void *, int endStyleNeeded) {
2709 NotifyStyleToNeeded(endStyleNeeded);
2710 }
2711
2712 void Editor::NotifyChar(int ch) {
2713 SCNotification scn;
2714 scn.nmhdr.code = SCN_CHARADDED;
2715 scn.ch = ch;
2716 NotifyParent(scn);
2717 if (recordingMacro) {
2718 char txt[2];
2719 txt[0] = static_cast<char>(ch);
2720 txt[1] = '\0';
2721 NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast<sptr_t>(txt));
2722 }
2723 }
2724
2725 void Editor::NotifySavePoint(bool isSavePoint) {
2726 SCNotification scn;
2727 if (isSavePoint) {
2728 scn.nmhdr.code = SCN_SAVEPOINTREACHED;
2729 } else {
2730 scn.nmhdr.code = SCN_SAVEPOINTLEFT;
2731 }
2732 NotifyParent(scn);
2733 }
2734
2735 void Editor::NotifyModifyAttempt() {
2736 SCNotification scn;
2737 scn.nmhdr.code = SCN_MODIFYATTEMPTRO;
2738 NotifyParent(scn);
2739 }
2740
2741 void Editor::NotifyDoubleClick(Point, bool) {
2742 SCNotification scn;
2743 scn.nmhdr.code = SCN_DOUBLECLICK;
2744 NotifyParent(scn);
2745 }
2746
2747 void Editor::NotifyUpdateUI() {
2748 SCNotification scn;
2749 scn.nmhdr.code = SCN_UPDATEUI;
2750 NotifyParent(scn);
2751 }
2752
2753 void Editor::NotifyPainted() {
2754 SCNotification scn;
2755 scn.nmhdr.code = SCN_PAINTED;
2756 NotifyParent(scn);
2757 }
2758
2759 bool Editor::NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt) {
2760 int marginClicked = -1;
2761 int x = 0;
2762 for (int margin = 0; margin < ViewStyle::margins; margin++) {
2763 if ((pt.x > x) && (pt.x < x + vs.ms[margin].width))
2764 marginClicked = margin;
2765 x += vs.ms[margin].width;
2766 }
2767 if ((marginClicked >= 0) && vs.ms[marginClicked].sensitive) {
2768 SCNotification scn;
2769 scn.nmhdr.code = SCN_MARGINCLICK;
2770 scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
2771 (alt ? SCI_ALT : 0);
2772 scn.position = pdoc->LineStart(LineFromLocation(pt));
2773 scn.margin = marginClicked;
2774 NotifyParent(scn);
2775 return true;
2776 } else {
2777 return false;
2778 }
2779 }
2780
2781 void Editor::NotifyNeedShown(int pos, int len) {
2782 SCNotification scn;
2783 scn.nmhdr.code = SCN_NEEDSHOWN;
2784 scn.position = pos;
2785 scn.length = len;
2786 NotifyParent(scn);
2787 }
2788
2789 void Editor::NotifyDwelling(Point pt, bool state) {
2790 SCNotification scn;
2791 scn.nmhdr.code = state ? SCN_DWELLSTART : SCN_DWELLEND;
2792 scn.position = PositionFromLocationClose(pt);
2793 scn.x = pt.x;
2794 scn.y = pt.y;
2795 NotifyParent(scn);
2796 }
2797
2798 void Editor::NotifyZoom() {
2799 SCNotification scn;
2800 scn.nmhdr.code = SCN_ZOOM;
2801 NotifyParent(scn);
2802 }
2803
2804 // Notifications from document
2805 void Editor::NotifyModifyAttempt(Document*, void *) {
2806 //Platform::DebugPrintf("** Modify Attempt\n");
2807 NotifyModifyAttempt();
2808 }
2809
2810 void Editor::NotifyMove(int position) {
2811 SCNotification scn;
2812 scn.nmhdr.code = SCN_POSCHANGED;
2813 scn.position = position;
2814 NotifyParent(scn);
2815 }
2816
2817 void Editor::NotifySavePoint(Document*, void *, bool atSavePoint) {
2818 //Platform::DebugPrintf("** Save Point %s\n", atSavePoint ? "On" : "Off");
2819 NotifySavePoint(atSavePoint);
2820 }
2821
2822 void Editor::CheckModificationForWrap(DocModification mh) {
2823 if ((mh.modificationType & SC_MOD_INSERTTEXT) ||
2824 (mh.modificationType & SC_MOD_DELETETEXT)) {
2825 llc.Invalidate(LineLayout::llCheckTextAndStyle);
2826 if (wrapState != eWrapNone) {
2827 int lineDoc = pdoc->LineFromPosition(mh.position);
2828 if (mh.linesAdded == 0) {
2829 AutoSurface surface(IsUnicodeMode());
2830 LineLayout *ll = RetrieveLineLayout(lineDoc);
2831 if (surface && ll) {
2832 LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
2833 if (cs.GetHeight(lineDoc) != ll->lines) {
2834 NeedWrapping(lineDoc-1);
2835 Redraw();
2836 }
2837 } else {
2838 NeedWrapping(lineDoc);
2839 }
2840 llc.Dispose(ll);
2841 } else {
2842 NeedWrapping(lineDoc);
2843 }
2844 }
2845 }
2846 }
2847
2848 // Move a position so it is still after the same character as before the insertion.
2849 static inline int MovePositionForInsertion(int position, int startInsertion, int length) {
2850 if (position > startInsertion) {
2851 return position + length;
2852 }
2853 return position;
2854 }
2855
2856 // Move a position so it is still after the same character as before the deletion if that
2857 // character is still present else after the previous surviving character.
2858 static inline int MovePositionForDeletion(int position, int startDeletion, int length) {
2859 if (position > startDeletion) {
2860 int endDeletion = startDeletion + length;
2861 if (position > endDeletion) {
2862 return position - length;
2863 } else {
2864 return startDeletion;
2865 }
2866 } else {
2867 return position;
2868 }
2869 }
2870
2871 void Editor::NotifyModified(Document*, DocModification mh, void *) {
2872 needUpdateUI = true;
2873 if (paintState == painting) {
2874 CheckForChangeOutsidePaint(Range(mh.position, mh.position + mh.length));
2875 }
2876 CheckModificationForWrap(mh);
2877 if (mh.modificationType & SC_MOD_CHANGESTYLE) {
2878 if (paintState == notPainting) {
2879 if (mh.position < pdoc->LineStart(topLine)) {
2880 // Styling performed before this view
2881 Redraw();
2882 } else {
2883 InvalidateRange(mh.position, mh.position + mh.length);
2884 }
2885 }
2886 } else {
2887 // Move selection and brace highlights
2888 if (mh.modificationType & SC_MOD_INSERTTEXT) {
2889 currentPos = MovePositionForInsertion(currentPos, mh.position, mh.length);
2890 anchor = MovePositionForInsertion(anchor, mh.position, mh.length);
2891 braces[0] = MovePositionForInsertion(braces[0], mh.position, mh.length);
2892 braces[1] = MovePositionForInsertion(braces[1], mh.position, mh.length);
2893 } else if (mh.modificationType & SC_MOD_DELETETEXT) {
2894 currentPos = MovePositionForDeletion(currentPos, mh.position, mh.length);
2895 anchor = MovePositionForDeletion(anchor, mh.position, mh.length);
2896 braces[0] = MovePositionForDeletion(braces[0], mh.position, mh.length);
2897 braces[1] = MovePositionForDeletion(braces[1], mh.position, mh.length);
2898 }
2899 if (cs.LinesDisplayed() < cs.LinesInDoc()) {
2900 // Some lines are hidden so may need shown.
2901 // TODO: check if the modified area is hidden.
2902 if (mh.modificationType & SC_MOD_BEFOREINSERT) {
2903 NotifyNeedShown(mh.position, mh.length);
2904 } else if (mh.modificationType & SC_MOD_BEFOREDELETE) {
2905 NotifyNeedShown(mh.position, mh.length);
2906 }
2907 }
2908 if (mh.linesAdded != 0) {
2909 // Update contraction state for inserted and removed lines
2910 // lineOfPos should be calculated in context of state before modification, shouldn't it
2911 int lineOfPos = pdoc->LineFromPosition(mh.position);
2912 if (mh.linesAdded > 0) {
2913 cs.InsertLines(lineOfPos, mh.linesAdded);
2914 } else {
2915 cs.DeleteLines(lineOfPos, -mh.linesAdded);
2916 }
2917 // Avoid scrolling of display if change before current display
2918 if (mh.position < posTopLine) {
2919 int newTop = Platform::Clamp(topLine + mh.linesAdded, 0, MaxScrollPos());
2920 if (newTop != topLine) {
2921 SetTopLine(newTop);
2922 SetVerticalScrollPos();
2923 }
2924 }
2925
2926 //Platform::DebugPrintf("** %x Doc Changed\n", this);
2927 // TODO: could invalidate from mh.startModification to end of screen
2928 //InvalidateRange(mh.position, mh.position + mh.length);
2929 if (paintState == notPainting) {
2930 Redraw();
2931 }
2932 } else {
2933 //Platform::DebugPrintf("** %x Line Changed %d .. %d\n", this,
2934 // mh.position, mh.position + mh.length);
2935 if (paintState == notPainting) {
2936 InvalidateRange(mh.position, mh.position + mh.length);
2937 }
2938 }
2939 }
2940
2941 if (mh.linesAdded != 0) {
2942 SetScrollBars();
2943 }
2944
2945 if (mh.modificationType & SC_MOD_CHANGEMARKER) {
2946 if (paintState == notPainting) {
2947 RedrawSelMargin();
2948 }
2949 }
2950
2951 // If client wants to see this modification
2952 if (mh.modificationType & modEventMask) {
2953 if ((mh.modificationType & SC_MOD_CHANGESTYLE) == 0) {
2954 // Real modification made to text of document.
2955 NotifyChange(); // Send EN_CHANGE
2956 }
2957
2958 SCNotification scn;
2959 scn.nmhdr.code = SCN_MODIFIED;
2960 scn.position = mh.position;
2961 scn.modificationType = mh.modificationType;
2962 scn.text = mh.text;
2963 scn.length = mh.length;
2964 scn.linesAdded = mh.linesAdded;
2965 scn.line = mh.line;
2966 scn.foldLevelNow = mh.foldLevelNow;
2967 scn.foldLevelPrev = mh.foldLevelPrev;
2968 NotifyParent(scn);
2969 }
2970 }
2971
2972 void Editor::NotifyDeleted(Document *, void *) {
2973 /* Do nothing */
2974 }
2975
2976 void Editor::NotifyMacroRecord(unsigned int iMessage, unsigned long wParam, long lParam) {
2977
2978 // Enumerates all macroable messages
2979 switch (iMessage) {
2980 case SCI_CUT:
2981 case SCI_COPY:
2982 case SCI_PASTE:
2983 case SCI_CLEAR:
2984 case SCI_REPLACESEL:
2985 case SCI_ADDTEXT:
2986 case SCI_INSERTTEXT:
2987 case SCI_CLEARALL:
2988 case SCI_SELECTALL:
2989 case SCI_GOTOLINE:
2990 case SCI_GOTOPOS:
2991 case SCI_SEARCHANCHOR:
2992 case SCI_SEARCHNEXT:
2993 case SCI_SEARCHPREV:
2994 case SCI_LINEDOWN:
2995 case SCI_LINEDOWNEXTEND:
2996 case SCI_LINEUP:
2997 case SCI_LINEUPEXTEND:
2998 case SCI_CHARLEFT:
2999 case SCI_CHARLEFTEXTEND:
3000 case SCI_CHARRIGHT:
3001 case SCI_CHARRIGHTEXTEND:
3002 case SCI_WORDLEFT:
3003 case SCI_WORDLEFTEXTEND:
3004 case SCI_WORDRIGHT:
3005 case SCI_WORDRIGHTEXTEND:
3006 case SCI_WORDPARTLEFT:
3007 case SCI_WORDPARTLEFTEXTEND:
3008 case SCI_WORDPARTRIGHT:
3009 case SCI_WORDPARTRIGHTEXTEND:
3010 case SCI_HOME:
3011 case SCI_HOMEEXTEND:
3012 case SCI_LINEEND:
3013 case SCI_LINEENDEXTEND:
3014 case SCI_DOCUMENTSTART:
3015 case SCI_DOCUMENTSTARTEXTEND:
3016 case SCI_DOCUMENTEND:
3017 case SCI_DOCUMENTENDEXTEND:
3018 case SCI_PAGEUP:
3019 case SCI_PAGEUPEXTEND:
3020 case SCI_PAGEDOWN:
3021 case SCI_PAGEDOWNEXTEND:
3022 case SCI_EDITTOGGLEOVERTYPE:
3023 case SCI_CANCEL:
3024 case SCI_DELETEBACK:
3025 case SCI_TAB:
3026 case SCI_BACKTAB:
3027 case SCI_FORMFEED:
3028 case SCI_VCHOME:
3029 case SCI_VCHOMEEXTEND:
3030 case SCI_DELWORDLEFT:
3031 case SCI_DELWORDRIGHT:
3032 case SCI_DELLINELEFT:
3033 case SCI_DELLINERIGHT:
3034 case SCI_LINECUT:
3035 case SCI_LINEDELETE:
3036 case SCI_LINETRANSPOSE:
3037 case SCI_LOWERCASE:
3038 case SCI_UPPERCASE:
3039 case SCI_LINESCROLLDOWN:
3040 case SCI_LINESCROLLUP:
3041 case SCI_DELETEBACKNOTLINE:
3042 break;
3043
3044 // Filter out all others like display changes. Also, newlines are redundant
3045 // with char insert messages.
3046 case SCI_NEWLINE:
3047 default:
3048 // printf("Filtered out %ld of macro recording\n", iMessage);
3049 return;
3050 }
3051
3052 // Send notification
3053 SCNotification scn;
3054 scn.nmhdr.code = SCN_MACRORECORD;
3055 scn.message = iMessage;
3056 scn.wParam = wParam;
3057 scn.lParam = lParam;
3058 NotifyParent(scn);
3059 }
3060
3061 // Force scroll and keep position relative to top of window
3062 void Editor::PageMove(int direction, bool extend) {
3063 Point pt = LocationFromPosition(currentPos);
3064 int topLineNew = Platform::Clamp(
3065 topLine + direction * LinesToScroll(), 0, MaxScrollPos());
3066 int newPos = PositionFromLocation(
3067 Point(lastXChosen, pt.y + direction * (vs.lineHeight * LinesToScroll())));
3068 if (topLineNew != topLine) {
3069 SetTopLine(topLineNew);
3070 MovePositionTo(newPos, extend);
3071 Redraw();
3072 SetVerticalScrollPos();
3073 } else {
3074 MovePositionTo(newPos, extend);
3075 }
3076 }
3077
3078 void Editor::ChangeCaseOfSelection(bool makeUpperCase) {
3079 pdoc->BeginUndoAction();
3080 int startCurrent = currentPos;
3081 int startAnchor = anchor;
3082 if (selType == selRectangle) {
3083 int lineStart = pdoc->LineFromPosition(SelectionStart());
3084 int lineEnd = pdoc->LineFromPosition(SelectionEnd());
3085 for (int line = lineEnd; line >= lineStart; line--) {
3086 pdoc->ChangeCase(
3087 Range(SelectionStart(line), SelectionEnd(line)),
3088 makeUpperCase);
3089 }
3090 // Would be nicer to keep the rectangular selection but this is complex
3091 selType = selStream;
3092 SetSelection(startCurrent, startCurrent);
3093 } else {
3094 pdoc->ChangeCase(Range(SelectionStart(), SelectionEnd()),
3095 makeUpperCase);
3096 SetSelection(startCurrent, startAnchor);
3097 }
3098 pdoc->EndUndoAction();
3099 }
3100
3101 void Editor::LineTranspose() {
3102 int line = pdoc->LineFromPosition(currentPos);
3103 if (line > 0) {
3104 int startPrev = pdoc->LineStart(line - 1);
3105 int endPrev = pdoc->LineEnd(line - 1);
3106 int start = pdoc->LineStart(line);
3107 int end = pdoc->LineEnd(line);
3108 int startNext = pdoc->LineStart(line + 1);
3109 if (end < pdoc->Length()) {
3110 end = startNext;
3111 char *thisLine = CopyRange(start, end);
3112 pdoc->DeleteChars(start, end - start);
3113 if (pdoc->InsertString(startPrev, thisLine, end - start)) {
3114 MovePositionTo(startPrev + end - start);
3115 }
3116 delete []thisLine;
3117 } else {
3118 // Last line so line has no line end
3119 char *thisLine = CopyRange(start, end);
3120 char *prevEnd = CopyRange(endPrev, start);
3121 pdoc->DeleteChars(endPrev, end - endPrev);
3122 pdoc->InsertString(startPrev, thisLine, end - start);
3123 if (pdoc->InsertString(startPrev + end - start, prevEnd, start - endPrev)) {
3124 MovePositionTo(startPrev + end - endPrev);
3125 }
3126 delete []thisLine;
3127 delete []prevEnd;
3128 }
3129
3130 }
3131 }
3132
3133 void Editor::CancelModes() {}
3134
3135 void Editor::NewLine() {
3136 ClearSelection();
3137 const char *eol = "\n";
3138 if (pdoc->eolMode == SC_EOL_CRLF) {
3139 eol = "\r\n";
3140 } else if (pdoc->eolMode == SC_EOL_CR) {
3141 eol = "\r";
3142 } // else SC_EOL_LF -> "\n" already set
3143 if (pdoc->InsertString(currentPos, eol)) {
3144 SetEmptySelection(currentPos + strlen(eol));
3145 while (*eol) {
3146 NotifyChar(*eol);
3147 eol++;
3148 }
3149 }
3150 SetLastXChosen();
3151 EnsureCaretVisible();
3152 }
3153
3154 void Editor::CursorUpOrDown(int direction, bool extend) {
3155 Point pt = LocationFromPosition(currentPos);
3156 int posNew = PositionFromLocation(
3157 Point(lastXChosen, pt.y + direction * vs.lineHeight));
3158 if (direction < 0) {
3159 // Line wrapping may lead to a location on the same line, so
3160 // seek back if that is the case.
3161 // There is an equivalent case when moving down which skips
3162 // over a line but as that does not trap the user it is fine.
3163 Point ptNew = LocationFromPosition(posNew);
3164 while ((posNew > 0) && (pt.y == ptNew.y)) {
3165 posNew--;
3166 ptNew = LocationFromPosition(posNew);
3167 }
3168 }
3169 MovePositionTo(posNew, extend);
3170 }
3171
3172 int Editor::KeyCommand(unsigned int iMessage) {
3173 switch (iMessage) {
3174 case SCI_LINEDOWN:
3175 CursorUpOrDown(1);
3176 break;
3177 case SCI_LINEDOWNEXTEND:
3178 CursorUpOrDown(1, true);
3179 break;
3180 case SCI_LINESCROLLDOWN:
3181 ScrollTo(topLine + 1);
3182 MoveCaretInsideView();
3183 break;
3184 case SCI_LINEUP:
3185 CursorUpOrDown(-1);
3186 break;
3187 case SCI_LINEUPEXTEND:
3188 CursorUpOrDown(-1, true);
3189 break;
3190 case SCI_LINESCROLLUP:
3191 ScrollTo(topLine - 1);
3192 MoveCaretInsideView();
3193 break;
3194 case SCI_CHARLEFT:
3195 if (SelectionEmpty()) {
3196 MovePositionTo(MovePositionSoVisible(currentPos - 1, -1));
3197 } else {
3198 MovePositionTo(SelectionStart());
3199 }
3200 SetLastXChosen();
3201 break;
3202 case SCI_CHARLEFTEXTEND:
3203 MovePositionTo(MovePositionSoVisible(currentPos - 1, -1), true);
3204 SetLastXChosen();
3205 break;
3206 case SCI_CHARRIGHT:
3207 if (SelectionEmpty()) {
3208 MovePositionTo(MovePositionSoVisible(currentPos + 1, 1));
3209 } else {
3210 MovePositionTo(SelectionEnd());
3211 }
3212 SetLastXChosen();
3213 break;
3214 case SCI_CHARRIGHTEXTEND:
3215 MovePositionTo(MovePositionSoVisible(currentPos + 1, 1), true);
3216 SetLastXChosen();
3217 break;
3218 case SCI_WORDLEFT:
3219 MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, -1), -1));
3220 SetLastXChosen();
3221 break;
3222 case SCI_WORDLEFTEXTEND:
3223 MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, -1), -1), true);
3224 SetLastXChosen();
3225 break;
3226 case SCI_WORDRIGHT:
3227 MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, 1), 1));
3228 SetLastXChosen();
3229 break;
3230 case SCI_WORDRIGHTEXTEND:
3231 MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, 1), 1), true);
3232 SetLastXChosen();
3233 break;
3234 case SCI_HOME:
3235 MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)));
3236 SetLastXChosen();
3237 break;
3238 case SCI_HOMEEXTEND:
3239 MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)), true);
3240 SetLastXChosen();
3241 break;
3242 case SCI_LINEEND:
3243 MovePositionTo(pdoc->LineEndPosition(currentPos));
3244 SetLastXChosen();
3245 break;
3246 case SCI_LINEENDEXTEND:
3247 MovePositionTo(pdoc->LineEndPosition(currentPos), true);
3248 SetLastXChosen();
3249 break;
3250 case SCI_DOCUMENTSTART:
3251 MovePositionTo(0);
3252 SetLastXChosen();
3253 break;
3254 case SCI_DOCUMENTSTARTEXTEND:
3255 MovePositionTo(0, true);
3256 SetLastXChosen();
3257 break;
3258 case SCI_DOCUMENTEND:
3259 MovePositionTo(pdoc->Length());
3260 SetLastXChosen();
3261 break;
3262 case SCI_DOCUMENTENDEXTEND:
3263 MovePositionTo(pdoc->Length(), true);
3264 SetLastXChosen();
3265 break;
3266 case SCI_PAGEUP:
3267 PageMove( -1);
3268 break;
3269 case SCI_PAGEUPEXTEND:
3270 PageMove( -1, true);
3271 break;
3272 case SCI_PAGEDOWN:
3273 PageMove(1);
3274 break;
3275 case SCI_PAGEDOWNEXTEND:
3276 PageMove(1, true);
3277 break;
3278 case SCI_EDITTOGGLEOVERTYPE:
3279 inOverstrike = !inOverstrike;
3280 DropCaret();
3281 ShowCaretAtCurrentPosition();
3282 NotifyUpdateUI();
3283 break;
3284 case SCI_CANCEL: // Cancel any modes - handled in subclass
3285 // Also unselect text
3286 CancelModes();
3287 break;
3288 case SCI_DELETEBACK:
3289 DelCharBack(true);
3290 SetLastXChosen();
3291 EnsureCaretVisible();
3292 break;
3293 case SCI_DELETEBACKNOTLINE:
3294 DelCharBack(false);
3295 SetLastXChosen();
3296 EnsureCaretVisible();
3297 break;
3298 case SCI_TAB:
3299 Indent(true);
3300 SetLastXChosen();
3301 EnsureCaretVisible();
3302 break;
3303 case SCI_BACKTAB:
3304 Indent(false);
3305 SetLastXChosen();
3306 EnsureCaretVisible();
3307 break;
3308 case SCI_NEWLINE:
3309 NewLine();
3310 break;
3311 case SCI_FORMFEED:
3312 AddChar('\f');
3313 break;
3314 case SCI_VCHOME:
3315 MovePositionTo(pdoc->VCHomePosition(currentPos));
3316 SetLastXChosen();
3317 break;
3318 case SCI_VCHOMEEXTEND:
3319 MovePositionTo(pdoc->VCHomePosition(currentPos), true);
3320 SetLastXChosen();
3321 break;
3322 case SCI_ZOOMIN:
3323 if (vs.zoomLevel < 20) {
3324 vs.zoomLevel++;
3325 NeedWrapping();
3326 InvalidateStyleRedraw();
3327 NotifyZoom();
3328 }
3329 break;
3330 case SCI_ZOOMOUT:
3331 if (vs.zoomLevel > -10) {
3332 vs.zoomLevel--;
3333 NeedWrapping();
3334 InvalidateStyleRedraw();
3335 NotifyZoom();
3336 }
3337 break;
3338 case SCI_DELWORDLEFT: {
3339 int startWord = pdoc->NextWordStart(currentPos, -1);
3340 pdoc->DeleteChars(startWord, currentPos - startWord);
3341 SetLastXChosen();
3342 }
3343 break;
3344 case SCI_DELWORDRIGHT: {
3345 int endWord = pdoc->NextWordStart(currentPos, 1);
3346 pdoc->DeleteChars(currentPos, endWord - currentPos);
3347 }
3348 break;
3349 case SCI_DELLINELEFT: {
3350 int line = pdoc->LineFromPosition(currentPos);
3351 int start = pdoc->LineStart(line);
3352 pdoc->DeleteChars(start, currentPos - start);
3353 SetLastXChosen();
3354 }
3355 break;
3356 case SCI_DELLINERIGHT: {
3357 int line = pdoc->LineFromPosition(currentPos);
3358 int end = pdoc->LineEnd(line);
3359 pdoc->DeleteChars(currentPos, end - currentPos);
3360 }
3361 break;
3362 case SCI_LINECUT: {
3363 int lineStart = pdoc->LineFromPosition(currentPos);
3364 int lineEnd = pdoc->LineFromPosition(anchor);
3365 if (lineStart > lineEnd) {
3366 int t = lineEnd;
3367 lineEnd = lineStart;
3368 lineStart = t;
3369 }
3370 int start = pdoc->LineStart(lineStart);
3371 int end = pdoc->LineStart(lineEnd + 1);
3372 SetSelection(start, end);
3373 Cut();
3374 }
3375 break;
3376 case SCI_LINEDELETE: {
3377 int line = pdoc->LineFromPosition(currentPos);
3378 int start = pdoc->LineStart(line);
3379 int end = pdoc->LineStart(line + 1);
3380 pdoc->DeleteChars(start, end - start);
3381 }
3382 break;
3383 case SCI_LINETRANSPOSE:
3384 LineTranspose();
3385 break;
3386 case SCI_LOWERCASE:
3387 ChangeCaseOfSelection(false);
3388 break;
3389 case SCI_UPPERCASE:
3390 ChangeCaseOfSelection(true);
3391 break;
3392 case SCI_WORDPARTLEFT:
3393 MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(currentPos), -1));
3394 SetLastXChosen();
3395 break;
3396 case SCI_WORDPARTLEFTEXTEND:
3397 MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(currentPos), -1), true);
3398 SetLastXChosen();
3399 break;
3400 case SCI_WORDPARTRIGHT:
3401 MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(currentPos), 1));
3402 SetLastXChosen();
3403 break;
3404 case SCI_WORDPARTRIGHTEXTEND:
3405 MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(currentPos), 1), true);
3406 SetLastXChosen();
3407 break;
3408 }
3409 return 0;
3410 }
3411
3412 int Editor::KeyDefault(int, int) {
3413 return 0;
3414 }
3415
3416 int Editor::KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed) {
3417 DwellEnd(false);
3418 int modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
3419 (alt ? SCI_ALT : 0);
3420 int msg = kmap.Find(key, modifiers);
3421 if (msg) {
3422 if (consumed)
3423 *consumed = true;
3424 return WndProc(msg, 0, 0);
3425 } else {
3426 if (consumed)
3427 *consumed = false;
3428 return KeyDefault(key, modifiers);
3429 }
3430 }
3431
3432 void Editor::SetWhitespaceVisible(int view) {
3433 vs.viewWhitespace = static_cast<WhiteSpaceVisibility>(view);
3434 }
3435
3436 int Editor::GetWhitespaceVisible() {
3437 return vs.viewWhitespace;
3438 }
3439
3440 void Editor::Indent(bool forwards) {
3441 //Platform::DebugPrintf("INdent %d\n", forwards);
3442 int lineOfAnchor = pdoc->LineFromPosition(anchor);
3443 int lineCurrentPos = pdoc->LineFromPosition(currentPos);
3444 if (lineOfAnchor == lineCurrentPos) {
3445 if (forwards) {
3446 pdoc->BeginUndoAction();
3447 ClearSelection();
3448 if (pdoc->GetColumn(currentPos) <= pdoc->GetColumn(pdoc->GetLineIndentPosition(lineCurrentPos)) &&
3449 pdoc->tabIndents) {
3450 int indentation = pdoc->GetLineIndentation(lineCurrentPos);
3451 int indentationStep = (pdoc->indentInChars ? pdoc->indentInChars : pdoc->tabInChars);
3452 pdoc->SetLineIndentation(lineCurrentPos, indentation + indentationStep);
3453 SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
3454 } else {
3455 if (pdoc->useTabs) {
3456 pdoc->InsertChar(currentPos, '\t');
3457 SetEmptySelection(currentPos + 1);
3458 } else {
3459 int numSpaces = (pdoc->tabInChars) -
3460 (pdoc->GetColumn(currentPos) % (pdoc->tabInChars));
3461 if (numSpaces < 1)
3462 numSpaces = pdoc->tabInChars;
3463 for (int i = 0; i < numSpaces; i++) {
3464 pdoc->InsertChar(currentPos + i, ' ');
3465 }
3466 SetEmptySelection(currentPos + numSpaces);
3467 }
3468 }
3469 pdoc->EndUndoAction();
3470 } else {
3471 if (pdoc->GetColumn(currentPos) <= pdoc->GetLineIndentation(lineCurrentPos) &&
3472 pdoc->tabIndents) {
3473 pdoc->BeginUndoAction();
3474 int indentation = pdoc->GetLineIndentation(lineCurrentPos);
3475 int indentationStep = (pdoc->indentInChars ? pdoc->indentInChars : pdoc->tabInChars);
3476 pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
3477 SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
3478 pdoc->EndUndoAction();
3479 } else {
3480 int newColumn = ((pdoc->GetColumn(currentPos) - 1) / pdoc->tabInChars) *
3481 pdoc->tabInChars;
3482 if (newColumn < 0)
3483 newColumn = 0;
3484 int newPos = currentPos;
3485 while (pdoc->GetColumn(newPos) > newColumn)
3486 newPos--;
3487 SetEmptySelection(newPos);
3488 }
3489 }
3490 } else {
3491 int anchorPosOnLine = anchor - pdoc->LineStart(lineOfAnchor);
3492 int currentPosPosOnLine = currentPos - pdoc->LineStart(lineCurrentPos);
3493 // Multiple lines selected so indent / dedent
3494 int lineTopSel = Platform::Minimum(lineOfAnchor, lineCurrentPos);
3495 int lineBottomSel = Platform::Maximum(lineOfAnchor, lineCurrentPos);
3496 if (pdoc->LineStart(lineBottomSel) == anchor || pdoc->LineStart(lineBottomSel) == currentPos)
3497 lineBottomSel--; // If not selecting any characters on a line, do not indent
3498 pdoc->BeginUndoAction();
3499 pdoc->Indent(forwards, lineBottomSel, lineTopSel);
3500 pdoc->EndUndoAction();
3501 if (lineOfAnchor < lineCurrentPos) {
3502 if (currentPosPosOnLine == 0)
3503 SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor));
3504 else
3505 SetSelection(pdoc->LineStart(lineCurrentPos + 1), pdoc->LineStart(lineOfAnchor));
3506 } else {
3507 if (anchorPosOnLine == 0)
3508 SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor));
3509 else
3510 SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor + 1));
3511 }
3512 }
3513 }
3514
3515 /**
3516 * Search of a text in the document, in the given range.
3517 * @return The position of the found text, -1 if not found.
3518 */
3519 long Editor::FindText(
3520 uptr_t wParam, ///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD,
3521 ///< @c SCFIND_WORDSTART or @c SCFIND_REGEXP.
3522 sptr_t lParam) { ///< @c TextToFind structure: The text to search for in the given range.
3523
3524 TextToFind *ft = reinterpret_cast<TextToFind *>(lParam);
3525 int lengthFound = strlen(ft->lpstrText);
3526 int pos = pdoc->FindText(ft->chrg.cpMin, ft->chrg.cpMax, ft->lpstrText,
3527 (wParam & SCFIND_MATCHCASE) != 0,
3528 (wParam & SCFIND_WHOLEWORD) != 0,
3529 (wParam & SCFIND_WORDSTART) != 0,
3530 (wParam & SCFIND_REGEXP) != 0,
3531 &lengthFound);
3532 if (pos != -1) {
3533 ft->chrgText.cpMin = pos;
3534 ft->chrgText.cpMax = pos + lengthFound;
3535 }
3536 return pos;
3537 }
3538
3539 /**
3540 * Relocatable search support : Searches relative to current selection
3541 * point and sets the selection to the found text range with
3542 * each search.
3543 */
3544 /**
3545 * Anchor following searches at current selection start: This allows
3546 * multiple incremental interactive searches to be macro recorded
3547 * while still setting the selection to found text so the find/select
3548 * operation is self-contained.
3549 */
3550 void Editor::SearchAnchor() {
3551 searchAnchor = SelectionStart();
3552 }
3553
3554 /**
3555 * Find text from current search anchor: Must call @c SearchAnchor first.
3556 * Used for next text and previous text requests.
3557 * @return The position of the found text, -1 if not found.
3558 */
3559 long Editor::SearchText(
3560 unsigned int iMessage, ///< Accepts both @c SCI_SEARCHNEXT and @c SCI_SEARCHPREV.
3561 uptr_t wParam, ///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD,
3562 ///< @c SCFIND_WORDSTART or @c SCFIND_REGEXP.
3563 sptr_t lParam) { ///< The text to search for.
3564
3565 const char *txt = reinterpret_cast<char *>(lParam);
3566 int pos;
3567 int lengthFound = strlen(txt);
3568 if (iMessage == SCI_SEARCHNEXT) {
3569 pos = pdoc->FindText(searchAnchor, pdoc->Length(), txt,
3570 (wParam & SCFIND_MATCHCASE) != 0,
3571 (wParam & SCFIND_WHOLEWORD) != 0,
3572 (wParam & SCFIND_WORDSTART) != 0,
3573 (wParam & SCFIND_REGEXP) != 0,
3574 &lengthFound);
3575 } else {
3576 pos = pdoc->FindText(searchAnchor, 0, txt,
3577 (wParam & SCFIND_MATCHCASE) != 0,
3578 (wParam & SCFIND_WHOLEWORD) != 0,
3579 (wParam & SCFIND_WORDSTART) != 0,
3580 (wParam & SCFIND_REGEXP) != 0,
3581 &lengthFound);
3582 }
3583
3584 if (pos != -1) {
3585 SetSelection(pos, pos + lengthFound);
3586 }
3587
3588 return pos;
3589 }
3590
3591 /**
3592 * Search for text in the target range of the document.
3593 * @return The position of the found text, -1 if not found.
3594 */
3595 long Editor::SearchInTarget(const char *text, int length) {
3596 int lengthFound = length;
3597 int pos = pdoc->FindText(targetStart, targetEnd, text,
3598 (searchFlags & SCFIND_MATCHCASE) != 0,
3599 (searchFlags & SCFIND_WHOLEWORD) != 0,
3600 (searchFlags & SCFIND_WORDSTART) != 0,
3601 (searchFlags & SCFIND_REGEXP) != 0,
3602 &lengthFound);
3603 if (pos != -1) {
3604 targetStart = pos;
3605 targetEnd = pos + lengthFound;
3606 }
3607 return pos;
3608 }
3609
3610 void Editor::GoToLine(int lineNo) {
3611 if (lineNo > pdoc->LinesTotal())
3612 lineNo = pdoc->LinesTotal();
3613 if (lineNo < 0)
3614 lineNo = 0;
3615 SetEmptySelection(pdoc->LineStart(lineNo));
3616 ShowCaretAtCurrentPosition();
3617 EnsureCaretVisible();
3618 }
3619
3620 static bool Close(Point pt1, Point pt2) {
3621 if (abs(pt1.x - pt2.x) > 3)
3622 return false;
3623 if (abs(pt1.y - pt2.y) > 3)
3624 return false;
3625 return true;
3626 }
3627
3628 char *Editor::CopyRange(int start, int end) {
3629 char *text = 0;
3630 if (start < end) {
3631 int len = end - start;
3632 text = new char[len + 1];
3633 if (text) {
3634 for (int i = 0; i < len; i++) {
3635 text[i] = pdoc->CharAt(start + i);
3636 }
3637 text[len] = '\0';
3638 }
3639 }
3640 return text;
3641 }
3642
3643 void Editor::CopySelectionRange(SelectionText *ss) {
3644 char *text = 0;
3645 int size = 0;
3646 if (selType == selRectangle) {
3647 int lineStart = pdoc->LineFromPosition(SelectionStart());
3648 int lineEnd = pdoc->LineFromPosition(SelectionEnd());
3649 int line;
3650 for (line = lineStart; line <= lineEnd; line++) {
3651 size += SelectionEnd(line) - SelectionStart(line) + 1;
3652 if (pdoc->eolMode == SC_EOL_CRLF)
3653 size++;
3654 }
3655 if (size > 0) {
3656 text = new char[size + 1];
3657 if (text) {
3658 int j = 0;
3659 for (line = lineStart; line <= lineEnd; line++) {
3660 for (int i = SelectionStart(line);i < SelectionEnd(line);i++) {
3661 text[j++] = pdoc->CharAt(i);
3662 }
3663 if (pdoc->eolMode != SC_EOL_LF)
3664 text[j++] = '\r';
3665 if (pdoc->eolMode != SC_EOL_CR)
3666 text[j++] = '\n';
3667 }
3668 text[size] = '\0';
3669 }
3670 }
3671 } else {
3672 size = SelectionEnd() - SelectionStart();
3673 text = CopyRange(SelectionStart(), SelectionEnd());
3674 }
3675 ss->Set(text, size, selType == selRectangle);
3676 }
3677
3678 void Editor::SetDragPosition(int newPos) {
3679 if (newPos >= 0) {
3680 newPos = MovePositionOutsideChar(newPos, 1);
3681 posDrop = newPos;
3682 }
3683 if (posDrag != newPos) {
3684 caret.on = true;
3685 SetTicking(true);
3686 InvalidateCaret();
3687 posDrag = newPos;
3688 InvalidateCaret();
3689 }
3690 }
3691
3692 void Editor::DisplayCursor(Window::Cursor c) {
3693 if (cursorMode == SC_CURSORNORMAL)
3694 wMain.SetCursor(c);
3695 else
3696 wMain.SetCursor(static_cast<Window::Cursor>(cursorMode));
3697 }
3698
3699 void Editor::StartDrag() {
3700 // Always handled by subclasses
3701 //SetMouseCapture(true);
3702 //DisplayCursor(Window::cursorArrow);
3703 }
3704
3705 void Editor::DropAt(int position, const char *value, bool moving, bool rectangular) {
3706 //Platform::DebugPrintf("DropAt %d\n", inDragDrop);
3707 if (inDragDrop)
3708 dropWentOutside = false;
3709
3710 int positionWasInSelection = PositionInSelection(position);
3711
3712 bool positionOnEdgeOfSelection =
3713 (position == SelectionStart()) || (position == SelectionEnd());
3714
3715 if ((!inDragDrop) || !(0 == positionWasInSelection) ||
3716 (positionOnEdgeOfSelection && !moving)) {
3717
3718 int selStart = SelectionStart();
3719 int selEnd = SelectionEnd();
3720
3721 pdoc->BeginUndoAction();
3722
3723 int positionAfterDeletion = position;
3724 if (inDragDrop && moving) {
3725 // Remove dragged out text
3726 if (rectangular) {
3727 int lineStart = pdoc->LineFromPosition(SelectionStart());
3728 int lineEnd = pdoc->LineFromPosition(SelectionEnd());
3729 for (int line = lineStart; line <= lineEnd; line++) {
3730 int startPos = SelectionStart(line);
3731 int endPos = SelectionEnd(line);
3732 if (position >= startPos) {
3733 if (position > endPos) {
3734 positionAfterDeletion -= endPos - startPos;
3735 } else {
3736 positionAfterDeletion -= position - startPos;
3737 }
3738 }
3739 }
3740 } else {
3741 if (position > selStart) {
3742 positionAfterDeletion -= selEnd - selStart;
3743 }
3744 }
3745 ClearSelection();
3746 }
3747 position = positionAfterDeletion;
3748
3749 if (rectangular) {
3750 PasteRectangular(position, value, strlen(value));
3751 pdoc->EndUndoAction();
3752 // Should try to select new rectangle but it may not be a rectangle now so just select the drop position
3753 SetSelection(position, position);
3754 } else {
3755 position = MovePositionOutsideChar(position, currentPos - position);
3756 if (pdoc->InsertString(position, value)) {
3757 SetSelection(position + strlen(value), position);
3758 }
3759 pdoc->EndUndoAction();
3760 }
3761 } else if (inDragDrop) {
3762 SetSelection(position, position);
3763 }
3764 }
3765
3766 static int BeforeInOrAfter(int val, int minim, int maxim) {
3767 if (val < minim)
3768 return -1;
3769 else if (val > maxim)
3770 return 1;
3771 else
3772 return 0;
3773 }
3774
3775 int Editor::PositionInSelection(int pos) {
3776 pos = MovePositionOutsideChar(pos, currentPos - pos);
3777 if (selType == selRectangle) {
3778 if (pos < SelectionStart())
3779 return -1;
3780 if (pos > SelectionEnd())
3781 return 1;
3782 int linePos = pdoc->LineFromPosition(pos);
3783 return BeforeInOrAfter(pos, SelectionStart(linePos), SelectionEnd(linePos));
3784 } else {
3785 if (currentPos > anchor) {
3786 return BeforeInOrAfter(pos, anchor, currentPos);
3787 } else if (currentPos < anchor) {
3788 return BeforeInOrAfter(pos, currentPos, anchor);
3789 }
3790 }
3791 return 1;
3792 }
3793
3794 bool Editor::PointInSelection(Point pt) {
3795 // TODO: fix up for rectangular selection
3796 int pos = PositionFromLocation(pt);
3797 if (0 == PositionInSelection(pos)) {
3798 if (pos == SelectionStart()) {
3799 // see if just before selection
3800 Point locStart = LocationFromPosition(pos);
3801 if (pt.x < locStart.x)
3802 return false;
3803 }
3804 if (pos == SelectionEnd()) {
3805 // see if just after selection
3806 Point locEnd = LocationFromPosition(pos);
3807 if (pt.x > locEnd.x)
3808 return false;
3809 }
3810 return true;
3811 }
3812 return false;
3813 }
3814
3815 bool Editor::PointInSelMargin(Point pt) {
3816 // Really means: "Point in a margin"
3817 if (vs.fixedColumnWidth > 0) { // There is a margin
3818 PRectangle rcSelMargin = GetClientRectangle();
3819 rcSelMargin.right = vs.fixedColumnWidth - vs.leftMarginWidth;
3820 return rcSelMargin.Contains(pt);
3821 } else {
3822 return false;
3823 }
3824 }
3825
3826 void Editor::LineSelection(int lineCurrent_, int lineAnchor_) {
3827 if (lineAnchor_ < lineCurrent_) {
3828 SetSelection(pdoc->LineStart(lineCurrent_ + 1),
3829 pdoc->LineStart(lineAnchor_));
3830 } else if (lineAnchor_ > lineCurrent_) {
3831 SetSelection(pdoc->LineStart(lineCurrent_),
3832 pdoc->LineStart(lineAnchor_ + 1));
3833 } else { // Same line, select it
3834 SetSelection(pdoc->LineStart(lineAnchor_ + 1),
3835 pdoc->LineStart(lineAnchor_));
3836 }
3837 }
3838
3839 void Editor::DwellEnd(bool mouseMoved) {
3840 if (mouseMoved)
3841 ticksToDwell = dwellDelay;
3842 else
3843 ticksToDwell = SC_TIME_FOREVER;
3844 if (dwelling && (dwellDelay < SC_TIME_FOREVER)) {
3845 dwelling = false;
3846 NotifyDwelling(ptMouseLast, dwelling);
3847 }
3848 }
3849
3850 void Editor::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
3851 //Platform::DebugPrintf("Scintilla:ButtonDown %d %d = %d alt=%d\n", curTime, lastClickTime, curTime - lastClickTime, alt);
3852 ptMouseLast = pt;
3853 int newPos = PositionFromLocation(pt);
3854 newPos = MovePositionOutsideChar(newPos, currentPos - newPos);
3855 inDragDrop = false;
3856
3857 bool processed = NotifyMarginClick(pt, shift, ctrl, alt);
3858 if (processed)
3859 return;
3860
3861 bool inSelMargin = PointInSelMargin(pt);
3862 if (shift & !inSelMargin) {
3863 SetSelection(newPos);
3864 }
3865 if (((curTime - lastClickTime) < Platform::DoubleClickTime()) && Close(pt, lastClick)) {
3866 //Platform::DebugPrintf("Double click %d %d = %d\n", curTime, lastClickTime, curTime - lastClickTime);
3867 SetMouseCapture(true);
3868 SetEmptySelection(newPos);
3869 bool doubleClick = false;
3870 // Stop mouse button bounce changing selection type
3871 if (curTime != lastClickTime) {
3872 if (selectionType == selChar) {
3873 selectionType = selWord;
3874 doubleClick = true;
3875 } else if (selectionType == selWord) {
3876 selectionType = selLine;
3877 } else {
3878 selectionType = selChar;
3879 originalAnchorPos = currentPos;
3880 }
3881 }
3882
3883 if (selectionType == selWord) {
3884 if (currentPos >= originalAnchorPos) { // Moved forward
3885 SetSelection(pdoc->ExtendWordSelect(currentPos, 1),
3886 pdoc->ExtendWordSelect(originalAnchorPos, -1));
3887 } else { // Moved backward
3888 SetSelection(pdoc->ExtendWordSelect(currentPos, -1),
3889 pdoc->ExtendWordSelect(originalAnchorPos, 1));
3890 }
3891 } else if (selectionType == selLine) {
3892 lineAnchor = LineFromLocation(pt);
3893 SetSelection(pdoc->LineStart(lineAnchor + 1), pdoc->LineStart(lineAnchor));
3894 //Platform::DebugPrintf("Triple click: %d - %d\n", anchor, currentPos);
3895 }
3896 else {
3897 SetEmptySelection(currentPos);
3898 }
3899 //Platform::DebugPrintf("Double click: %d - %d\n", anchor, currentPos);
3900 if (doubleClick)
3901 NotifyDoubleClick(pt, shift);
3902 } else { // Single click
3903 if (inSelMargin) {
3904 selType = selStream;
3905 if (ctrl) {
3906 SelectAll();
3907 lastClickTime = curTime;
3908 return;
3909 }
3910 if (!shift) {
3911 lineAnchor = LineFromLocation(pt);
3912 // Single click in margin: select whole line
3913 LineSelection(lineAnchor, lineAnchor);
3914 SetSelection(pdoc->LineStart(lineAnchor + 1),
3915 pdoc->LineStart(lineAnchor));
3916 } else {
3917 // Single shift+click in margin: select from line anchor to clicked line
3918 if (anchor > currentPos)
3919 lineAnchor = pdoc->LineFromPosition(anchor - 1);
3920 else
3921 lineAnchor = pdoc->LineFromPosition(anchor);
3922 int lineStart = LineFromLocation(pt);
3923 LineSelection(lineStart, lineAnchor);
3924 //lineAnchor = lineStart; // Keep the same anchor for ButtonMove
3925 }
3926
3927 SetDragPosition(invalidPosition);
3928 SetMouseCapture(true);
3929 selectionType = selLine;
3930 } else {
3931 if (!shift) {
3932 inDragDrop = PointInSelection(pt);
3933 }
3934 if (inDragDrop) {
3935 SetMouseCapture(false);
3936 SetDragPosition(newPos);
3937 CopySelectionRange(&drag);
3938 StartDrag();
3939 } else {
3940 xStartSelect = pt.x - vs.fixedColumnWidth + xOffset;
3941 xEndSelect = pt.x - vs.fixedColumnWidth + xOffset;
3942 SetDragPosition(invalidPosition);
3943 SetMouseCapture(true);
3944 if (!shift)
3945 SetEmptySelection(newPos);
3946 selType = alt ? selRectangle : selStream;
3947 selectionType = selChar;
3948 originalAnchorPos = currentPos;
3949 }
3950 }
3951 }
3952 lastClickTime = curTime;
3953 lastXChosen = pt.x;
3954 ShowCaretAtCurrentPosition();
3955 }
3956
3957 void Editor::ButtonMove(Point pt) {
3958 if ((ptMouseLast.x != pt.x) || (ptMouseLast.y != pt.y)) {
3959 DwellEnd(true);
3960 }
3961 ptMouseLast = pt;
3962 //Platform::DebugPrintf("Move %d %d\n", pt.x, pt.y);
3963 if (HaveMouseCapture()) {
3964
3965 // Slow down autoscrolling/selection
3966 autoScrollTimer.ticksToWait -= timer.tickSize;
3967 if (autoScrollTimer.ticksToWait > 0)
3968 return;
3969 autoScrollTimer.ticksToWait = autoScrollDelay;
3970
3971 // Adjust selection
3972 xEndSelect = pt.x - vs.fixedColumnWidth + xOffset;
3973 int movePos = PositionFromLocation(pt);
3974 movePos = MovePositionOutsideChar(movePos, currentPos - movePos);
3975 if (posDrag >= 0) {
3976 SetDragPosition(movePos);
3977 } else {
3978 if (selectionType == selChar) {
3979 SetSelection(movePos);
3980 } else if (selectionType == selWord) {
3981 // Continue selecting by word
3982 if (movePos >= originalAnchorPos) { // Moved forward
3983 SetSelection(pdoc->ExtendWordSelect(movePos, 1),
3984 pdoc->ExtendWordSelect(originalAnchorPos, -1));
3985 } else { // Moved backward
3986 SetSelection(pdoc->ExtendWordSelect(movePos, -1),
3987 pdoc->ExtendWordSelect(originalAnchorPos, 1));
3988 }
3989 } else {
3990 // Continue selecting by line
3991 int lineMove = LineFromLocation(pt);
3992 LineSelection(lineMove, lineAnchor);
3993 }
3994 }
3995
3996 // Autoscroll
3997 PRectangle rcClient = GetClientRectangle();
3998 if (pt.y > rcClient.bottom) {
3999 int lineMove = cs.DisplayFromDoc(LineFromLocation(pt));
4000 ScrollTo(lineMove - LinesOnScreen() + 5);
4001 Redraw();
4002 } else if (pt.y < rcClient.top) {
4003 int lineMove = cs.DisplayFromDoc(LineFromLocation(pt));
4004 ScrollTo(lineMove - 5);
4005 Redraw();
4006 }
4007 EnsureCaretVisible(false, false, true);
4008
4009 } else {
4010 if (vs.fixedColumnWidth > 0) { // There is a margin
4011 if (PointInSelMargin(pt)) {
4012 DisplayCursor(Window::cursorReverseArrow);
4013 return; // No need to test for selection
4014 }
4015 }
4016 // Display regular (drag) cursor over selection
4017 if (PointInSelection(pt))
4018 DisplayCursor(Window::cursorArrow);
4019 else
4020 DisplayCursor(Window::cursorText);
4021 }
4022
4023 }
4024
4025 void Editor::ButtonUp(Point pt, unsigned int curTime, bool ctrl) {
4026 //Platform::DebugPrintf("ButtonUp %d\n", HaveMouseCapture());
4027 if (HaveMouseCapture()) {
4028 if (PointInSelMargin(pt)) {
4029 DisplayCursor(Window::cursorReverseArrow);
4030 } else {
4031 DisplayCursor(Window::cursorText);
4032 }
4033 xEndSelect = pt.x - vs.fixedColumnWidth + xOffset;
4034 ptMouseLast = pt;
4035 SetMouseCapture(false);
4036 int newPos = PositionFromLocation(pt);
4037 newPos = MovePositionOutsideChar(newPos, currentPos - newPos);
4038 if (inDragDrop) {
4039 int selStart = SelectionStart();
4040 int selEnd = SelectionEnd();
4041 if (selStart < selEnd) {
4042 if (drag.len) {
4043 if (ctrl) {
4044 if (pdoc->InsertString(newPos, drag.s, drag.len)) {
4045 SetSelection(newPos, newPos + drag.len);
4046 }
4047 } else if (newPos < selStart) {
4048 pdoc->DeleteChars(selStart, drag.len);
4049 if (pdoc->InsertString(newPos, drag.s, drag.len)) {
4050 SetSelection(newPos, newPos + drag.len);
4051 }
4052 } else if (newPos > selEnd) {
4053 pdoc->DeleteChars(selStart, drag.len);
4054 newPos -= drag.len;
4055 if (pdoc->InsertString(newPos, drag.s, drag.len)) {
4056 SetSelection(newPos, newPos + drag.len);
4057 }
4058 } else {
4059 SetEmptySelection(newPos);
4060 }
4061 drag.Set(0, 0);
4062 }
4063 selectionType = selChar;
4064 }
4065 } else {
4066 if (selectionType == selChar) {
4067 SetSelection(newPos);
4068 }
4069 }
4070 lastClickTime = curTime;
4071 lastClick = pt;
4072 lastXChosen = pt.x;
4073 if (selType == selStream) {
4074 SetLastXChosen();
4075 }
4076 inDragDrop = false;
4077 EnsureCaretVisible(false);
4078 }
4079 }
4080
4081 // Called frequently to perform background UI including
4082 // caret blinking and automatic scrolling.
4083 void Editor::Tick() {
4084 if (HaveMouseCapture()) {
4085 // Auto scroll
4086 ButtonMove(ptMouseLast);
4087 }
4088 if (caret.period > 0) {
4089 timer.ticksToWait -= timer.tickSize;
4090 if (timer.ticksToWait <= 0) {
4091 caret.on = !caret.on;
4092 timer.ticksToWait = caret.period;
4093 InvalidateCaret();
4094 }
4095 }
4096 if ((dwellDelay < SC_TIME_FOREVER) &&
4097 (ticksToDwell > 0) &&
4098 (!HaveMouseCapture())) {
4099 ticksToDwell -= timer.tickSize;
4100 if (ticksToDwell <= 0) {
4101 dwelling = true;
4102 NotifyDwelling(ptMouseLast, dwelling);
4103 }
4104 }
4105 }
4106
4107 void Editor::SetFocusState(bool focusState) {
4108 hasFocus = focusState;
4109 NotifyFocus(hasFocus);
4110 if (hasFocus) {
4111 ShowCaretAtCurrentPosition();
4112 } else {
4113 DropCaret();
4114 }
4115 }
4116
4117 static bool IsIn(int a, int minimum, int maximum) {
4118 return (a >= minimum) && (a <= maximum);
4119 }
4120
4121 static bool IsOverlap(int mina, int maxa, int minb, int maxb) {
4122 return
4123 IsIn(mina, minb, maxb) ||
4124 IsIn(maxa, minb, maxb) ||
4125 IsIn(minb, mina, maxa) ||
4126 IsIn(maxb, mina, maxa);
4127 }
4128
4129 void Editor::CheckForChangeOutsidePaint(Range r) {
4130 if (paintState == painting && !paintingAllText) {
4131 //Platform::DebugPrintf("Checking range in paint %d-%d\n", r.start, r.end);
4132 if (!r.Valid())
4133 return;
4134
4135 PRectangle rcText = GetTextRectangle();
4136 // Determine number of lines displayed including a possible partially displayed last line
4137 int linesDisplayed = (rcText.bottom - rcText.top - 1) / vs.lineHeight + 1;
4138 int bottomLine = topLine + linesDisplayed - 1;
4139
4140 int lineRangeStart = cs.DisplayFromDoc(pdoc->LineFromPosition(r.start));
4141 int lineRangeEnd = cs.DisplayFromDoc(pdoc->LineFromPosition(r.end));
4142 if (!IsOverlap(topLine, bottomLine, lineRangeStart, lineRangeEnd)) {
4143 //Platform::DebugPrintf("No overlap (%d-%d) with window(%d-%d)\n",
4144 // lineRangeStart, lineRangeEnd, topLine, bottomLine);
4145 return;
4146 }
4147
4148 // Assert rcPaint contained within or equal to rcText
4149 if (rcPaint.top > rcText.top) {
4150 // does range intersect rcText.top .. rcPaint.top
4151 int paintTopLine = ((rcPaint.top - rcText.top - 1) / vs.lineHeight) + topLine;
4152 // paintTopLine is the top line of the paint rectangle or the line just above if that line is completely inside the paint rectangle
4153 if (IsOverlap(topLine, paintTopLine, lineRangeStart, lineRangeEnd)) {
4154 //Platform::DebugPrintf("Change (%d-%d) in top npv(%d-%d)\n",
4155 // lineRangeStart, lineRangeEnd, topLine, paintTopLine);
4156 AbandonPaint();
4157 return;
4158 }
4159 }
4160 if (rcPaint.bottom < rcText.bottom) {
4161 // does range intersect rcPaint.bottom .. rcText.bottom
4162 int paintBottomLine = ((rcPaint.bottom - rcText.top - 1) / vs.lineHeight + 1) + topLine;
4163 // paintTopLine is the bottom line of the paint rectangle or the line just below if that line is completely inside the paint rectangle
4164 if (IsOverlap(paintBottomLine, bottomLine, lineRangeStart, lineRangeEnd)) {
4165 //Platform::DebugPrintf("Change (%d-%d) in bottom npv(%d-%d)\n",
4166 // lineRangeStart, lineRangeEnd, paintBottomLine, bottomLine);
4167 AbandonPaint();
4168 return;
4169 }
4170 }
4171 }
4172 }
4173
4174 char BraceOpposite(char ch) {
4175 switch (ch) {
4176 case '(':
4177 return ')';
4178 case ')':
4179 return '(';
4180 case '[':
4181 return ']';
4182 case ']':
4183 return '[';
4184 case '{':
4185 return '}';
4186 case '}':
4187 return '{';
4188 case '<':
4189 return '>';
4190 case '>':
4191 return '<';
4192 default:
4193 return '\0';
4194 }
4195 }
4196
4197 // TODO: should be able to extend styled region to find matching brace
4198 // TODO: may need to make DBCS safe
4199 // so should be moved into Document
4200 int Editor::BraceMatch(int position, int /*maxReStyle*/) {
4201 char chBrace = pdoc->CharAt(position);
4202 char chSeek = BraceOpposite(chBrace);
4203 if (chSeek == '\0')
4204 return - 1;
4205 char styBrace = static_cast<char>(
4206 pdoc->StyleAt(position) & pdoc->stylingBitsMask);
4207 int direction = -1;
4208 if (chBrace == '(' || chBrace == '[' || chBrace == '{' || chBrace == '<')
4209 direction = 1;
4210 int depth = 1;
4211 position = position + direction;
4212 while ((position >= 0) && (position < pdoc->Length())) {
4213 char chAtPos = pdoc->CharAt(position);
4214 char styAtPos = static_cast<char>(pdoc->StyleAt(position) & pdoc->stylingBitsMask);
4215 if ((position > pdoc->GetEndStyled()) || (styAtPos == styBrace)) {
4216 if (chAtPos == chBrace)
4217 depth++;
4218 if (chAtPos == chSeek)
4219 depth--;
4220 if (depth == 0)
4221 return position;
4222 }
4223 position = position + direction;
4224 }
4225 return - 1;
4226 }
4227
4228 void Editor::SetBraceHighlight(Position pos0, Position pos1, int matchStyle) {
4229 if ((pos0 != braces[0]) || (pos1 != braces[1]) || (matchStyle != bracesMatchStyle)) {
4230 if ((braces[0] != pos0) || (matchStyle != bracesMatchStyle)) {
4231 CheckForChangeOutsidePaint(Range(braces[0]));
4232 CheckForChangeOutsidePaint(Range(pos0));
4233 braces[0] = pos0;
4234 }
4235 if ((braces[1] != pos1) || (matchStyle != bracesMatchStyle)) {
4236 CheckForChangeOutsidePaint(Range(braces[1]));
4237 CheckForChangeOutsidePaint(Range(pos1));
4238 braces[1] = pos1;
4239 }
4240 bracesMatchStyle = matchStyle;
4241 if (paintState == notPainting) {
4242 Redraw();
4243 }
4244 }
4245 }
4246
4247 void Editor::SetDocPointer(Document *document) {
4248 //Platform::DebugPrintf("** %x setdoc to %x\n", pdoc, document);
4249 pdoc->RemoveWatcher(this, 0);
4250 pdoc->Release();
4251 if (document == NULL) {
4252 pdoc = new Document();
4253 } else {
4254 pdoc = document;
4255 }
4256 pdoc->AddRef();
4257 // Reset the contraction state to fully shown.
4258 cs.Clear();
4259 cs.InsertLines(0, pdoc->LinesTotal() - 1);
4260 llc.Deallocate();
4261 NeedWrapping();
4262
4263 pdoc->AddWatcher(this, 0);
4264 Redraw();
4265 SetScrollBars();
4266 }
4267
4268 // Recursively expand a fold, making lines visible except where they have an unexpanded parent
4269 void Editor::Expand(int &line, bool doExpand) {
4270 int lineMaxSubord = pdoc->GetLastChild(line);
4271 line++;
4272 while (line <= lineMaxSubord) {
4273 if (doExpand)
4274 cs.SetVisible(line, line, true);
4275 int level = pdoc->GetLevel(line);
4276 if (level & SC_FOLDLEVELHEADERFLAG) {
4277 if (doExpand && cs.GetExpanded(line)) {
4278 Expand(line, true);
4279 } else {
4280 Expand(line, false);
4281 }
4282 } else {
4283 line++;
4284 }
4285 }
4286 }
4287
4288 void Editor::ToggleContraction(int line) {
4289 if (pdoc->GetLevel(line) & SC_FOLDLEVELHEADERFLAG) {
4290 if (cs.GetExpanded(line)) {
4291 int lineMaxSubord = pdoc->GetLastChild(line);
4292 cs.SetExpanded(line, 0);
4293 if (lineMaxSubord > line) {
4294 cs.SetVisible(line + 1, lineMaxSubord, false);
4295 SetScrollBars();
4296 Redraw();
4297 }
4298 } else {
4299 cs.SetExpanded(line, 1);
4300 Expand(line, true);
4301 SetScrollBars();
4302 Redraw();
4303 }
4304 }
4305 }
4306
4307 // Recurse up from this line to find any folds that prevent this line from being visible
4308 // and unfold them all->
4309 void Editor::EnsureLineVisible(int lineDoc, bool enforcePolicy) {
4310
4311 // In case in need of wrapping to ensure DisplayFromDoc works.
4312 WrapLines();
4313
4314 if (!cs.GetVisible(lineDoc)) {
4315 int lineParent = pdoc->GetFoldParent(lineDoc);
4316 if (lineParent >= 0) {
4317 if (lineDoc != lineParent)
4318 EnsureLineVisible(lineParent, enforcePolicy);
4319 if (!cs.GetExpanded(lineParent)) {
4320 cs.SetExpanded(lineParent, 1);
4321 Expand(lineParent, true);
4322 }
4323 }
4324 SetScrollBars();
4325 Redraw();
4326 }
4327 if (enforcePolicy) {
4328 int lineDisplay = cs.DisplayFromDoc(lineDoc);
4329 if (visiblePolicy & VISIBLE_SLOP) {
4330 if ((topLine > lineDisplay) || ((visiblePolicy & VISIBLE_STRICT) && (topLine + visibleSlop > lineDisplay))) {
4331 SetTopLine(Platform::Clamp(lineDisplay - visibleSlop, 0, MaxScrollPos()));
4332 SetVerticalScrollPos();
4333 Redraw();
4334 } else if ((lineDisplay > topLine + LinesOnScreen() - 1) ||
4335 ((visiblePolicy & VISIBLE_STRICT) && (lineDisplay > topLine + LinesOnScreen() - 1 - visibleSlop))) {
4336 SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() + 1 + visibleSlop, 0, MaxScrollPos()));
4337 SetVerticalScrollPos();
4338 Redraw();
4339 }
4340 } else {
4341 if ((topLine > lineDisplay) || (lineDisplay > topLine + LinesOnScreen() - 1) || (visiblePolicy & VISIBLE_STRICT)) {
4342 SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() / 2 + 1, 0, MaxScrollPos()));
4343 SetVerticalScrollPos();
4344 Redraw();
4345 }
4346 }
4347 }
4348 }
4349
4350 int Editor::ReplaceTarget(bool replacePatterns, const char *text, int length) {
4351 pdoc->BeginUndoAction();
4352 if (length == -1)
4353 length = strlen(text);
4354 if (replacePatterns) {
4355 text = pdoc->SubstituteByPosition(text, &length);
4356 if (!text)
4357 return 0;
4358 }
4359 if (targetStart != targetEnd)
4360 pdoc->DeleteChars(targetStart, targetEnd - targetStart);
4361 targetEnd = targetStart;
4362 pdoc->InsertString(targetStart, text, length);
4363 targetEnd = targetStart + length;
4364 pdoc->EndUndoAction();
4365 return length;
4366 }
4367
4368 bool Editor::IsUnicodeMode() const {
4369 return pdoc && (SC_CP_UTF8 == pdoc->dbcsCodePage);
4370 }
4371
4372 static bool ValidMargin(unsigned long wParam) {
4373 return wParam < ViewStyle::margins;
4374 }
4375
4376 static char *CharPtrFromSPtr(sptr_t lParam) {
4377 return reinterpret_cast<char *>(lParam);
4378 }
4379
4380 sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
4381 //Platform::DebugPrintf("S start wnd proc %d %d %d\n",iMessage, wParam, lParam);
4382
4383 // Optional macro recording hook
4384 if (recordingMacro)
4385 NotifyMacroRecord(iMessage, wParam, lParam);
4386
4387 switch (iMessage) {
4388
4389 case SCI_GETTEXT:
4390 {
4391 if (lParam == 0)
4392 return 0;
4393 if (wParam == 0)
4394 return 0;
4395 char *ptr = CharPtrFromSPtr(lParam);
4396 unsigned int iChar = 0;
4397 for (; iChar < wParam - 1; iChar++)
4398 ptr[iChar] = pdoc->CharAt(iChar);
4399 ptr[iChar] = '\0';
4400 return iChar;
4401 }
4402
4403 case SCI_SETTEXT:
4404 {
4405 if (lParam == 0)
4406 return 0;
4407 pdoc->DeleteChars(0, pdoc->Length());
4408 SetEmptySelection(0);
4409 pdoc->InsertString(0, CharPtrFromSPtr(lParam));
4410 return 1;
4411 }
4412
4413 case SCI_GETTEXTLENGTH:
4414 return pdoc->Length();
4415
4416 case SCI_CUT:
4417 Cut();
4418 SetLastXChosen();
4419 break;
4420
4421 case SCI_COPY:
4422 Copy();
4423 break;
4424
4425 case SCI_PASTE:
4426 Paste();
4427 SetLastXChosen();
4428 EnsureCaretVisible();
4429 break;
4430
4431 case SCI_CLEAR:
4432 Clear();
4433 SetLastXChosen();
4434 EnsureCaretVisible();
4435 break;
4436
4437 case SCI_UNDO:
4438 Undo();
4439 SetLastXChosen();
4440 break;
4441
4442 case SCI_CANUNDO:
4443 return pdoc->CanUndo() ? 1 : 0;
4444
4445 case SCI_EMPTYUNDOBUFFER:
4446 pdoc->DeleteUndoHistory();
4447 return 0;
4448
4449 case SCI_GETFIRSTVISIBLELINE:
4450 return topLine;
4451
4452 case SCI_GETLINE: { // Risk of overwriting the end of the buffer
4453 if (lParam == 0) {
4454 return 0;
4455 }
4456 int lineStart = pdoc->LineStart(wParam);
4457 int lineEnd = pdoc->LineStart(wParam + 1);
4458 char *ptr = CharPtrFromSPtr(lParam);
4459 int iPlace = 0;
4460 for (int iChar = lineStart; iChar < lineEnd; iChar++) {
4461 ptr[iPlace++] = pdoc->CharAt(iChar);
4462 }
4463 return iPlace;
4464 }
4465
4466 case SCI_GETLINECOUNT:
4467 if (pdoc->LinesTotal() == 0)
4468 return 1;
4469 else
4470 return pdoc->LinesTotal();
4471
4472 case SCI_GETMODIFY:
4473 return !pdoc->IsSavePoint();
4474
4475 case SCI_SETSEL: {
4476 int nStart = static_cast<int>(wParam);
4477 int nEnd = static_cast<int>(lParam);
4478 if (nEnd < 0)
4479 nEnd = pdoc->Length();
4480 if (nStart < 0)
4481 nStart = nEnd; // Remove selection
4482 selType = selStream;
4483 SetSelection(nEnd, nStart);
4484 EnsureCaretVisible();
4485 }
4486 break;
4487
4488 case SCI_GETSELTEXT: {
4489 if (lParam == 0)
4490 return 0;
4491 SelectionText selectedText;
4492 CopySelectionRange(&selectedText);
4493 char *ptr = CharPtrFromSPtr(lParam);
4494 int iChar = 0;
4495 if (selectedText.len) {
4496 for (; iChar < selectedText.len; iChar++)
4497 ptr[iChar] = selectedText.s[iChar];
4498 ptr[iChar] = '\0';
4499 } else {
4500 ptr[0] = '\0';
4501 }
4502 return iChar;
4503 }
4504
4505 case SCI_LINEFROMPOSITION:
4506 if (static_cast<int>(wParam) < 0)
4507 return 0;
4508 return pdoc->LineFromPosition(wParam);
4509
4510 case SCI_POSITIONFROMLINE:
4511 if (static_cast<int>(wParam) < 0)
4512 wParam = pdoc->LineFromPosition(SelectionStart());
4513 if (wParam == 0)
4514 return 0; // Even if there is no text, there is a first line that starts at 0
4515 if (static_cast<int>(wParam) > pdoc->LinesTotal())
4516 return -1;
4517 //if (wParam > pdoc->LineFromPosition(pdoc->Length())) // Useful test, anyway...
4518 // return -1;
4519 return pdoc->LineStart(wParam);
4520
4521 // Replacement of the old Scintilla interpretation of EM_LINELENGTH
4522 case SCI_LINELENGTH:
4523 if ((static_cast<int>(wParam) < 0) ||
4524 (static_cast<int>(wParam) > pdoc->LineFromPosition(pdoc->Length())))
4525 return 0;
4526 return pdoc->LineStart(wParam + 1) - pdoc->LineStart(wParam);
4527
4528 case SCI_REPLACESEL: {
4529 if (lParam == 0)
4530 return 0;
4531 pdoc->BeginUndoAction();
4532 ClearSelection();
4533 char *replacement = CharPtrFromSPtr(lParam);
4534 pdoc->InsertString(currentPos, replacement);
4535 pdoc->EndUndoAction();
4536 SetEmptySelection(currentPos + strlen(replacement));
4537 EnsureCaretVisible();
4538 }
4539 break;
4540
4541 case SCI_SETTARGETSTART:
4542 targetStart = wParam;
4543 break;
4544
4545 case SCI_GETTARGETSTART:
4546 return targetStart;
4547
4548 case SCI_SETTARGETEND:
4549 targetEnd = wParam;
4550 break;
4551
4552 case SCI_GETTARGETEND:
4553 return targetEnd;
4554
4555 case SCI_REPLACETARGET:
4556 PLATFORM_ASSERT(lParam);
4557 return ReplaceTarget(false, CharPtrFromSPtr(lParam), wParam);
4558
4559 case SCI_REPLACETARGETRE:
4560 PLATFORM_ASSERT(lParam);
4561 return ReplaceTarget(true, CharPtrFromSPtr(lParam), wParam);
4562
4563 case SCI_SEARCHINTARGET:
4564 PLATFORM_ASSERT(lParam);
4565 return SearchInTarget(CharPtrFromSPtr(lParam), wParam);
4566
4567 case SCI_SETSEARCHFLAGS:
4568 searchFlags = wParam;
4569 break;
4570
4571 case SCI_GETSEARCHFLAGS:
4572 return searchFlags;
4573
4574 case SCI_LINESCROLL:
4575 ScrollTo(topLine + lParam);
4576 HorizontalScrollTo(xOffset + wParam * vs.spaceWidth);
4577 return 1;
4578
4579 case SCI_SETXOFFSET:
4580 xOffset = wParam;
4581 Redraw();
4582 break;
4583
4584 case SCI_GETXOFFSET:
4585 return xOffset;
4586
4587 case SCI_SCROLLCARET:
4588 EnsureCaretVisible();
4589 break;
4590
4591 case SCI_SETREADONLY:
4592 pdoc->SetReadOnly(wParam != 0);
4593 return 1;
4594
4595 case SCI_GETREADONLY:
4596 return pdoc->IsReadOnly();
4597
4598 case SCI_CANPASTE:
4599 return CanPaste();
4600
4601 case SCI_POINTXFROMPOSITION:
4602 if (lParam < 0) {
4603 return 0;
4604 } else {
4605 Point pt = LocationFromPosition(lParam);
4606 return pt.x;
4607 }
4608
4609 case SCI_POINTYFROMPOSITION:
4610 if (lParam < 0) {
4611 return 0;
4612 } else {
4613 Point pt = LocationFromPosition(lParam);
4614 return pt.y;
4615 }
4616
4617 case SCI_FINDTEXT:
4618 return FindText(wParam, lParam);
4619
4620 case SCI_GETTEXTRANGE: {
4621 if (lParam == 0)
4622 return 0;
4623 TextRange *tr = reinterpret_cast<TextRange *>(lParam);
4624 int cpMax = tr->chrg.cpMax;
4625 if (cpMax == -1)
4626 cpMax = pdoc->Length();
4627 int len = cpMax - tr->chrg.cpMin; // No -1 as cpMin and cpMax are referring to inter character positions
4628 pdoc->GetCharRange(tr->lpstrText, tr->chrg.cpMin, len);
4629 // Spec says copied text is terminated with a NUL
4630 tr->lpstrText[len] = '\0';
4631 return len; // Not including NUL
4632 }
4633
4634 case SCI_HIDESELECTION:
4635 hideSelection = wParam != 0;
4636 Redraw();
4637 break;
4638
4639 case SCI_FORMATRANGE:
4640 return FormatRange(wParam != 0, reinterpret_cast<RangeToFormat *>(lParam));
4641
4642 case SCI_GETMARGINLEFT:
4643 return vs.leftMarginWidth;
4644
4645 case SCI_GETMARGINRIGHT:
4646 return vs.rightMarginWidth;
4647
4648 case SCI_SETMARGINLEFT:
4649 vs.leftMarginWidth = lParam;
4650 NeedWrapping();
4651 InvalidateStyleRedraw();
4652 break;
4653
4654 case SCI_SETMARGINRIGHT:
4655 vs.rightMarginWidth = lParam;
4656 NeedWrapping();
4657 InvalidateStyleRedraw();
4658 break;
4659
4660 // Control specific mesages
4661
4662 case SCI_ADDTEXT: {
4663 if (lParam == 0)
4664 return 0;
4665 pdoc->InsertString(CurrentPosition(), CharPtrFromSPtr(lParam), wParam);
4666 SetEmptySelection(currentPos + wParam);
4667 return 0;
4668 }
4669
4670 case SCI_ADDSTYLEDTEXT: {
4671 if (lParam == 0)
4672 return 0;
4673 pdoc->InsertStyledString(CurrentPosition() * 2, CharPtrFromSPtr(lParam), wParam);
4674 SetEmptySelection(currentPos + wParam / 2);
4675 return 0;
4676 }
4677
4678 case SCI_INSERTTEXT: {
4679 if (lParam == 0)
4680 return 0;
4681 int insertPos = wParam;
4682 if (static_cast<short>(wParam) == -1)
4683 insertPos = CurrentPosition();
4684 int newCurrent = CurrentPosition();
4685 char *sz = CharPtrFromSPtr(lParam);
4686 pdoc->InsertString(insertPos, sz);
4687 if (newCurrent > insertPos)
4688 newCurrent += strlen(sz);
4689 SetEmptySelection(newCurrent);
4690 return 0;
4691 }
4692
4693 case SCI_CLEARALL:
4694 ClearAll();
4695 return 0;
4696
4697 case SCI_CLEARDOCUMENTSTYLE:
4698 ClearDocumentStyle();
4699 return 0;
4700
4701 case SCI_SETUNDOCOLLECTION:
4702 pdoc->SetUndoCollection(wParam != 0);
4703 return 0;
4704
4705 case SCI_GETUNDOCOLLECTION:
4706 return pdoc->IsCollectingUndo();
4707
4708 case SCI_BEGINUNDOACTION:
4709 pdoc->BeginUndoAction();
4710 return 0;
4711
4712 case SCI_ENDUNDOACTION:
4713 pdoc->EndUndoAction();
4714 return 0;
4715
4716 case SCI_GETCARETPERIOD:
4717 return caret.period;
4718
4719 case SCI_SETCARETPERIOD:
4720 caret.period = wParam;
4721 break;
4722
4723 case SCI_SETWORDCHARS: {
4724 if (lParam == 0)
4725 return 0;
4726 pdoc->SetWordChars(reinterpret_cast<unsigned char *>(lParam));
4727 }
4728 break;
4729
4730 case SCI_GETLENGTH:
4731 return pdoc->Length();
4732
4733 case SCI_GETCHARAT:
4734 return pdoc->CharAt(wParam);
4735
4736 case SCI_SETCURRENTPOS:
4737 SetSelection(wParam, anchor);
4738 break;
4739
4740 case SCI_GETCURRENTPOS:
4741 return currentPos;
4742
4743 case SCI_SETANCHOR:
4744 SetSelection(currentPos, wParam);
4745 break;
4746
4747 case SCI_GETANCHOR:
4748 return anchor;
4749
4750 case SCI_SETSELECTIONSTART:
4751 SetSelection(Platform::Maximum(currentPos, wParam), wParam);
4752 break;
4753
4754 case SCI_GETSELECTIONSTART:
4755 return Platform::Minimum(anchor, currentPos);
4756
4757 case SCI_SETSELECTIONEND:
4758 SetSelection(wParam, Platform::Minimum(anchor, wParam));
4759 break;
4760
4761 case SCI_GETSELECTIONEND:
4762 return Platform::Maximum(anchor, currentPos);
4763
4764 case SCI_SETPRINTMAGNIFICATION:
4765 printMagnification = wParam;
4766 break;
4767
4768 case SCI_GETPRINTMAGNIFICATION:
4769 return printMagnification;
4770
4771 case SCI_SETPRINTCOLOURMODE:
4772 printColourMode = wParam;
4773 break;
4774
4775 case SCI_GETPRINTCOLOURMODE:
4776 return printColourMode;
4777
4778 case SCI_GETSTYLEAT:
4779 if (static_cast<short>(wParam) >= pdoc->Length())
4780 return 0;
4781 else
4782 return pdoc->StyleAt(wParam);
4783
4784 case SCI_REDO:
4785 Redo();
4786 break;
4787
4788 case SCI_SELECTALL:
4789 SelectAll();
4790 break;
4791
4792 case SCI_SETSAVEPOINT:
4793 pdoc->SetSavePoint();
4794 break;
4795
4796 case SCI_GETSTYLEDTEXT: {
4797 if (lParam == 0)
4798 return 0;
4799 TextRange *tr = reinterpret_cast<TextRange *>(lParam);
4800 int iPlace = 0;
4801 for (int iChar = tr->chrg.cpMin; iChar < tr->chrg.cpMax; iChar++) {
4802 tr->lpstrText[iPlace++] = pdoc->CharAt(iChar);
4803 tr->lpstrText[iPlace++] = pdoc->StyleAt(iChar);
4804 }
4805 tr->lpstrText[iPlace] = '\0';
4806 tr->lpstrText[iPlace + 1] = '\0';
4807 return iPlace;
4808 }
4809
4810 case SCI_CANREDO:
4811 return pdoc->CanRedo() ? 1 : 0;
4812
4813 case SCI_MARKERLINEFROMHANDLE:
4814 return pdoc->LineFromHandle(wParam);
4815
4816 case SCI_MARKERDELETEHANDLE:
4817 pdoc->DeleteMarkFromHandle(wParam);
4818 break;
4819
4820 case SCI_GETVIEWWS:
4821 return vs.viewWhitespace;
4822
4823 case SCI_SETVIEWWS:
4824 vs.viewWhitespace = static_cast<WhiteSpaceVisibility>(wParam);
4825 Redraw();
4826 break;
4827
4828 case SCI_POSITIONFROMPOINT:
4829 return PositionFromLocation(Point(wParam, lParam));
4830
4831 case SCI_POSITIONFROMPOINTCLOSE:
4832 return PositionFromLocationClose(Point(wParam, lParam));
4833
4834 case SCI_GOTOLINE:
4835 GoToLine(wParam);
4836 break;
4837
4838 case SCI_GOTOPOS:
4839 SetEmptySelection(wParam);
4840 EnsureCaretVisible();
4841 Redraw();
4842 break;
4843
4844 case SCI_GETCURLINE: {
4845 if (lParam == 0) {
4846 return 0;
4847 }
4848 int lineCurrentPos = pdoc->LineFromPosition(currentPos);
4849 int lineStart = pdoc->LineStart(lineCurrentPos);
4850 unsigned int lineEnd = pdoc->LineStart(lineCurrentPos + 1);
4851 char *ptr = CharPtrFromSPtr(lParam);
4852 unsigned int iPlace = 0;
4853 for (unsigned int iChar = lineStart; iChar < lineEnd && iPlace < wParam - 1; iChar++) {
4854 ptr[iPlace++] = pdoc->CharAt(iChar);
4855 }
4856 ptr[iPlace] = '\0';
4857 return currentPos - lineStart;
4858 }
4859
4860 case SCI_GETENDSTYLED:
4861 return pdoc->GetEndStyled();
4862
4863 case SCI_GETEOLMODE:
4864 return pdoc->eolMode;
4865
4866 case SCI_SETEOLMODE:
4867 pdoc->eolMode = wParam;
4868 break;
4869
4870 case SCI_STARTSTYLING:
4871 pdoc->StartStyling(wParam, static_cast<char>(lParam));
4872 break;
4873
4874 case SCI_SETSTYLING:
4875 pdoc->SetStyleFor(wParam, static_cast<char>(lParam));
4876 break;
4877
4878 case SCI_SETSTYLINGEX: // Specify a complete styling buffer
4879 if (lParam == 0)
4880 return 0;
4881 pdoc->SetStyles(wParam, CharPtrFromSPtr(lParam));
4882 break;
4883
4884 case SCI_SETBUFFEREDDRAW:
4885 bufferedDraw = wParam != 0;
4886 break;
4887
4888 case SCI_GETBUFFEREDDRAW:
4889 return bufferedDraw;
4890
4891 case SCI_SETTABWIDTH:
4892 if (wParam > 0)
4893 pdoc->tabInChars = wParam;
4894 InvalidateStyleRedraw();
4895 break;
4896
4897 case SCI_GETTABWIDTH:
4898 return pdoc->tabInChars;
4899
4900 case SCI_SETINDENT:
4901 pdoc->indentInChars = wParam;
4902 InvalidateStyleRedraw();
4903 break;
4904
4905 case SCI_GETINDENT:
4906 return pdoc->indentInChars;
4907
4908 case SCI_SETUSETABS:
4909 pdoc->useTabs = wParam != 0;
4910 InvalidateStyleRedraw();
4911 break;
4912
4913 case SCI_GETUSETABS:
4914 return pdoc->useTabs;
4915
4916 case SCI_SETLINEINDENTATION:
4917 pdoc->SetLineIndentation(wParam, lParam);
4918 break;
4919
4920 case SCI_GETLINEINDENTATION:
4921 return pdoc->GetLineIndentation(wParam);
4922
4923 case SCI_GETLINEINDENTPOSITION:
4924 return pdoc->GetLineIndentPosition(wParam);
4925
4926 case SCI_SETTABINDENTS:
4927 pdoc->tabIndents = wParam != 0;
4928 break;
4929
4930 case SCI_GETTABINDENTS:
4931 return pdoc->tabIndents;
4932
4933 case SCI_SETBACKSPACEUNINDENTS:
4934 pdoc->backspaceUnindents = wParam != 0;
4935 break;
4936
4937 case SCI_GETBACKSPACEUNINDENTS:
4938 return pdoc->backspaceUnindents;
4939
4940 case SCI_SETMOUSEDWELLTIME:
4941 dwellDelay = wParam;
4942 ticksToDwell = dwellDelay;
4943 break;
4944
4945 case SCI_GETMOUSEDWELLTIME:
4946 return dwellDelay;
4947
4948 case SCI_WORDSTARTPOSITION:
4949 return pdoc->ExtendWordSelect(wParam, -1, lParam != 0);
4950
4951 case SCI_WORDENDPOSITION:
4952 return pdoc->ExtendWordSelect(wParam, 1, lParam != 0);
4953
4954 case SCI_SETWRAPMODE:
4955 wrapState = (wParam == SC_WRAP_WORD) ? eWrapWord : eWrapNone;
4956 NeedWrapping();
4957 xOffset = 0;
4958 InvalidateStyleRedraw();
4959 ReconfigureScrollBars();
4960 break;
4961
4962 case SCI_GETWRAPMODE:
4963 return wrapState;
4964
4965 case SCI_SETLAYOUTCACHE:
4966 llc.SetLevel(wParam);
4967 break;
4968
4969 case SCI_GETLAYOUTCACHE:
4970 return llc.GetLevel();
4971
4972 case SCI_SETSCROLLWIDTH:
4973 PLATFORM_ASSERT(wParam > 0);
4974 if ((wParam > 0) && (wParam != static_cast<unsigned int >(scrollWidth))) {
4975 scrollWidth = wParam;
4976 SetScrollBars();
4977 }
4978 break;
4979
4980 case SCI_GETSCROLLWIDTH:
4981 return scrollWidth;
4982
4983 case SCI_TEXTWIDTH:
4984 PLATFORM_ASSERT((wParam >= 0) && (wParam <= STYLE_MAX));
4985 PLATFORM_ASSERT(lParam);
4986 return TextWidth(wParam, CharPtrFromSPtr(lParam));
4987
4988 case SCI_TEXTHEIGHT:
4989 return vs.lineHeight;
4990
4991 case SCI_SETENDATLASTLINE:
4992 PLATFORM_ASSERT((wParam == 0) || (wParam ==1));
4993 if (endAtLastLine != (wParam != 0)) {
4994 endAtLastLine = wParam != 0;
4995 SetScrollBars();
4996 }
4997 break;
4998
4999 case SCI_GETENDATLASTLINE:
5000 return endAtLastLine;
5001
5002 case SCI_GETCOLUMN:
5003 return pdoc->GetColumn(wParam);
5004
5005 case SCI_SETHSCROLLBAR :
5006 if (horizontalScrollBarVisible != (wParam != 0)) {
5007 horizontalScrollBarVisible = wParam != 0;
5008 SetScrollBars();
5009 ReconfigureScrollBars();
5010 }
5011 break;
5012
5013 case SCI_GETHSCROLLBAR:
5014 return horizontalScrollBarVisible;
5015
5016 case SCI_SETINDENTATIONGUIDES:
5017 vs.viewIndentationGuides = wParam != 0;
5018 Redraw();
5019 break;
5020
5021 case SCI_GETINDENTATIONGUIDES:
5022 return vs.viewIndentationGuides;
5023
5024 case SCI_SETHIGHLIGHTGUIDE:
5025 if ((highlightGuideColumn != static_cast<int>(wParam)) || (wParam > 0)) {
5026 highlightGuideColumn = wParam;
5027 Redraw();
5028 }
5029 break;
5030
5031 case SCI_GETHIGHLIGHTGUIDE:
5032 return highlightGuideColumn;
5033
5034 case SCI_GETLINEENDPOSITION:
5035 return pdoc->LineEnd(wParam);
5036
5037 case SCI_SETCODEPAGE:
5038 pdoc->dbcsCodePage = wParam;
5039 break;
5040
5041 case SCI_GETCODEPAGE:
5042 return pdoc->dbcsCodePage;
5043
5044 case SCI_SETUSEPALETTE:
5045 palette.allowRealization = wParam != 0;
5046 InvalidateStyleRedraw();
5047 break;
5048
5049 case SCI_GETUSEPALETTE:
5050 return palette.allowRealization;
5051
5052 // Marker definition and setting
5053 case SCI_MARKERDEFINE:
5054 if (wParam <= MARKER_MAX)
5055 vs.markers[wParam].markType = lParam;
5056 InvalidateStyleData();
5057 RedrawSelMargin();
5058 break;
5059 case SCI_MARKERSETFORE:
5060 if (wParam <= MARKER_MAX)
5061 vs.markers[wParam].fore.desired = ColourDesired(lParam);
5062 InvalidateStyleData();
5063 RedrawSelMargin();
5064 break;
5065 case SCI_MARKERSETBACK:
5066 if (wParam <= MARKER_MAX)
5067 vs.markers[wParam].back.desired = ColourDesired(lParam);
5068 InvalidateStyleData();
5069 RedrawSelMargin();
5070 break;
5071 case SCI_MARKERADD: {
5072 int markerID = pdoc->AddMark(wParam, lParam);
5073 return markerID;
5074 }
5075
5076 case SCI_MARKERDELETE:
5077 pdoc->DeleteMark(wParam, lParam);
5078 break;
5079
5080 case SCI_MARKERDELETEALL:
5081 pdoc->DeleteAllMarks(static_cast<int>(wParam));
5082 break;
5083
5084 case SCI_MARKERGET:
5085 return pdoc->GetMark(wParam);
5086
5087 case SCI_MARKERNEXT: {
5088 int lt = pdoc->LinesTotal();
5089 for (int iLine = wParam; iLine < lt; iLine++) {
5090 if ((pdoc->GetMark(iLine) & lParam) != 0)
5091 return iLine;
5092 }
5093 }
5094 return -1;
5095
5096 case SCI_MARKERPREVIOUS: {
5097 for (int iLine = wParam; iLine >= 0; iLine--) {
5098 if ((pdoc->GetMark(iLine) & lParam) != 0)
5099 return iLine;
5100 }
5101 }
5102 return -1;
5103
5104 case SCI_SETMARGINTYPEN:
5105 if (ValidMargin(wParam)) {
5106 vs.ms[wParam].symbol = (lParam == SC_MARGIN_SYMBOL);
5107 InvalidateStyleRedraw();
5108 }
5109 break;
5110
5111 case SCI_GETMARGINTYPEN:
5112 if (ValidMargin(wParam))
5113 return vs.ms[wParam].symbol ? SC_MARGIN_SYMBOL : SC_MARGIN_NUMBER;
5114 else
5115 return 0;
5116
5117 case SCI_SETMARGINWIDTHN:
5118 if (ValidMargin(wParam)) {
5119 vs.ms[wParam].width = lParam;
5120 NeedWrapping();
5121 InvalidateStyleRedraw();
5122 }
5123 break;
5124
5125 case SCI_GETMARGINWIDTHN:
5126 if (ValidMargin(wParam))
5127 return vs.ms[wParam].width;
5128 else
5129 return 0;
5130
5131 case SCI_SETMARGINMASKN:
5132 if (ValidMargin(wParam)) {
5133 vs.ms[wParam].mask = lParam;
5134 InvalidateStyleRedraw();
5135 }
5136 break;
5137
5138 case SCI_GETMARGINMASKN:
5139 if (ValidMargin(wParam))
5140 return vs.ms[wParam].mask;
5141 else
5142 return 0;
5143
5144 case SCI_SETMARGINSENSITIVEN:
5145 if (ValidMargin(wParam)) {
5146 vs.ms[wParam].sensitive = lParam != 0;
5147 InvalidateStyleRedraw();
5148 }
5149 break;
5150
5151 case SCI_GETMARGINSENSITIVEN:
5152 if (ValidMargin(wParam))
5153 return vs.ms[wParam].sensitive ? 1 : 0;
5154 else
5155 return 0;
5156
5157 case SCI_STYLECLEARALL:
5158 vs.ClearStyles();
5159 InvalidateStyleRedraw();
5160 break;
5161
5162 case SCI_STYLESETFORE:
5163 if (wParam <= STYLE_MAX) {
5164 vs.styles[wParam].fore.desired = ColourDesired(lParam);
5165 InvalidateStyleRedraw();
5166 }
5167 break;
5168 case SCI_STYLESETBACK:
5169 if (wParam <= STYLE_MAX) {
5170 vs.styles[wParam].back.desired = ColourDesired(lParam);
5171 InvalidateStyleRedraw();
5172 }
5173 break;
5174 case SCI_STYLESETBOLD:
5175 if (wParam <= STYLE_MAX) {
5176 vs.styles[wParam].bold = lParam != 0;
5177 InvalidateStyleRedraw();
5178 }
5179 break;
5180 case SCI_STYLESETITALIC:
5181 if (wParam <= STYLE_MAX) {
5182 vs.styles[wParam].italic = lParam != 0;
5183 InvalidateStyleRedraw();
5184 }
5185 break;
5186 case SCI_STYLESETEOLFILLED:
5187 if (wParam <= STYLE_MAX) {
5188 vs.styles[wParam].eolFilled = lParam != 0;
5189 InvalidateStyleRedraw();
5190 }
5191 break;
5192 case SCI_STYLESETSIZE:
5193 if (wParam <= STYLE_MAX) {
5194 vs.styles[wParam].size = lParam;
5195 InvalidateStyleRedraw();
5196 }
5197 break;
5198 case SCI_STYLESETFONT:
5199 if (lParam == 0)
5200 return 0;
5201 if (wParam <= STYLE_MAX) {
5202 vs.SetStyleFontName(wParam, CharPtrFromSPtr(lParam));
5203 InvalidateStyleRedraw();
5204 }
5205 break;
5206 case SCI_STYLESETUNDERLINE:
5207 if (wParam <= STYLE_MAX) {
5208 vs.styles[wParam].underline = lParam != 0;
5209 InvalidateStyleRedraw();
5210 }
5211 break;
5212 case SCI_STYLESETCASE:
5213 if (wParam <= STYLE_MAX) {
5214 vs.styles[wParam].caseForce = static_cast<Style::ecaseForced>(lParam);
5215 InvalidateStyleRedraw();
5216 }
5217 break;
5218 case SCI_STYLESETCHARACTERSET:
5219 if (wParam <= STYLE_MAX) {
5220 vs.styles[wParam].characterSet = lParam;
5221 InvalidateStyleRedraw();
5222 }
5223 break;
5224 case SCI_STYLESETVISIBLE:
5225 if (wParam <= STYLE_MAX) {
5226 vs.styles[wParam].visible = lParam != 0;
5227 InvalidateStyleRedraw();
5228 }
5229 break;
5230 case SCI_STYLESETCHANGEABLE:
5231 if (wParam <= STYLE_MAX) {
5232 vs.styles[wParam].changeable = lParam != 0;
5233 InvalidateStyleRedraw();
5234 }
5235 break;
5236
5237 case SCI_STYLERESETDEFAULT:
5238 vs.ResetDefaultStyle();
5239 InvalidateStyleRedraw();
5240 break;
5241 case SCI_SETSTYLEBITS:
5242 pdoc->SetStylingBits(wParam);
5243 break;
5244
5245 case SCI_GETSTYLEBITS:
5246 return pdoc->stylingBits;
5247
5248 case SCI_SETLINESTATE:
5249 return pdoc->SetLineState(wParam, lParam);
5250
5251 case SCI_GETLINESTATE:
5252 return pdoc->GetLineState(wParam);
5253
5254 case SCI_GETMAXLINESTATE:
5255 return pdoc->GetMaxLineState();
5256
5257 case SCI_GETCARETLINEVISIBLE:
5258 return vs.showCaretLineBackground;
5259 case SCI_SETCARETLINEVISIBLE:
5260 vs.showCaretLineBackground = wParam != 0;
5261 InvalidateStyleRedraw();
5262 break;
5263 case SCI_GETCARETLINEBACK:
5264 return vs.caretLineBackground.desired.AsLong();
5265 case SCI_SETCARETLINEBACK:
5266 vs.caretLineBackground.desired = wParam;
5267 InvalidateStyleRedraw();
5268 break;
5269
5270 // Folding messages
5271
5272 case SCI_VISIBLEFROMDOCLINE:
5273 return cs.DisplayFromDoc(wParam);
5274
5275 case SCI_DOCLINEFROMVISIBLE:
5276 return cs.DocFromDisplay(wParam);
5277
5278 case SCI_SETFOLDLEVEL: {
5279 int prev = pdoc->SetLevel(wParam, lParam);
5280 if (prev != lParam)
5281 RedrawSelMargin();
5282 return prev;
5283 }
5284
5285 case SCI_GETFOLDLEVEL:
5286 return pdoc->GetLevel(wParam);
5287
5288 case SCI_GETLASTCHILD:
5289 return pdoc->GetLastChild(wParam, lParam);
5290
5291 case SCI_GETFOLDPARENT:
5292 return pdoc->GetFoldParent(wParam);
5293
5294 case SCI_SHOWLINES:
5295 cs.SetVisible(wParam, lParam, true);
5296 SetScrollBars();
5297 Redraw();
5298 break;
5299
5300 case SCI_HIDELINES:
5301 cs.SetVisible(wParam, lParam, false);
5302 SetScrollBars();
5303 Redraw();
5304 break;
5305
5306 case SCI_GETLINEVISIBLE:
5307 return cs.GetVisible(wParam);
5308
5309 case SCI_SETFOLDEXPANDED:
5310 if (cs.SetExpanded(wParam, lParam != 0)) {
5311 RedrawSelMargin();
5312 }
5313 break;
5314
5315 case SCI_GETFOLDEXPANDED:
5316 return cs.GetExpanded(wParam);
5317
5318 case SCI_SETFOLDFLAGS:
5319 foldFlags = wParam;
5320 Redraw();
5321 break;
5322
5323 case SCI_TOGGLEFOLD:
5324 ToggleContraction(wParam);
5325 break;
5326
5327 case SCI_ENSUREVISIBLE:
5328 EnsureLineVisible(wParam, false);
5329 break;
5330
5331 case SCI_ENSUREVISIBLEENFORCEPOLICY:
5332 EnsureLineVisible(wParam, true);
5333 break;
5334
5335 case SCI_SEARCHANCHOR:
5336 SearchAnchor();
5337 break;
5338
5339 case SCI_SEARCHNEXT:
5340 case SCI_SEARCHPREV:
5341 return SearchText(iMessage, wParam, lParam);
5342
5343 case SCI_SETCARETPOLICY: // Deprecated
5344 caretXPolicy = caretYPolicy = wParam;
5345 caretXSlop = caretYSlop = lParam;
5346 break;
5347
5348 case SCI_SETXCARETPOLICY:
5349 caretXPolicy = wParam;
5350 caretXSlop = lParam;
5351 break;
5352
5353 case SCI_SETYCARETPOLICY:
5354 caretYPolicy = wParam;
5355 caretYSlop = lParam;
5356 break;
5357
5358 case SCI_SETVISIBLEPOLICY:
5359 visiblePolicy = wParam;
5360 visibleSlop = lParam;
5361 break;
5362
5363 case SCI_LINESONSCREEN:
5364 return LinesOnScreen();
5365
5366 case SCI_SETSELFORE:
5367 vs.selforeset = wParam != 0;
5368 vs.selforeground.desired = ColourDesired(lParam);
5369 InvalidateStyleRedraw();
5370 break;
5371
5372 case SCI_SETSELBACK:
5373 vs.selbackset = wParam != 0;
5374 vs.selbackground.desired = ColourDesired(lParam);
5375 InvalidateStyleRedraw();
5376 break;
5377
5378 case SCI_SETCARETFORE:
5379 vs.caretcolour.desired = ColourDesired(wParam);
5380 InvalidateStyleRedraw();
5381 break;
5382
5383 case SCI_GETCARETFORE:
5384 return vs.caretcolour.desired.AsLong();
5385
5386 case SCI_SETCARETWIDTH:
5387 if (wParam <= 1)
5388 vs.caretWidth = 1;
5389 else if (wParam >= 3)
5390 vs.caretWidth = 3;
5391 else
5392 vs.caretWidth = wParam;
5393 InvalidateStyleRedraw();
5394 break;
5395
5396 case SCI_GETCARETWIDTH:
5397 return vs.caretWidth;
5398
5399 case SCI_ASSIGNCMDKEY:
5400 kmap.AssignCmdKey(Platform::LowShortFromLong(wParam),
5401 Platform::HighShortFromLong(wParam), lParam);
5402 break;
5403
5404 case SCI_CLEARCMDKEY:
5405 kmap.AssignCmdKey(Platform::LowShortFromLong(wParam),
5406 Platform::HighShortFromLong(wParam), SCI_NULL);
5407 break;
5408
5409 case SCI_CLEARALLCMDKEYS:
5410 kmap.Clear();
5411 break;
5412
5413 case SCI_INDICSETSTYLE:
5414 if (wParam <= INDIC_MAX) {
5415 vs.indicators[wParam].style = lParam;
5416 InvalidateStyleRedraw();
5417 }
5418 break;
5419
5420 case SCI_INDICGETSTYLE:
5421 return (wParam <= INDIC_MAX) ? vs.indicators[wParam].style : 0;
5422
5423 case SCI_INDICSETFORE:
5424 if (wParam <= INDIC_MAX) {
5425 vs.indicators[wParam].fore.desired = ColourDesired(lParam);
5426 InvalidateStyleRedraw();
5427 }
5428 break;
5429
5430 case SCI_INDICGETFORE:
5431 return (wParam <= INDIC_MAX) ? vs.indicators[wParam].fore.desired.AsLong() : 0;
5432
5433 case SCI_LINEDOWN:
5434 case SCI_LINEDOWNEXTEND:
5435 case SCI_LINEUP:
5436 case SCI_LINEUPEXTEND:
5437 case SCI_CHARLEFT:
5438 case SCI_CHARLEFTEXTEND:
5439 case SCI_CHARRIGHT:
5440 case SCI_CHARRIGHTEXTEND:
5441 case SCI_WORDLEFT:
5442 case SCI_WORDLEFTEXTEND:
5443 case SCI_WORDRIGHT:
5444 case SCI_WORDRIGHTEXTEND:
5445 case SCI_HOME:
5446 case SCI_HOMEEXTEND:
5447 case SCI_LINEEND:
5448 case SCI_LINEENDEXTEND:
5449 case SCI_DOCUMENTSTART:
5450 case SCI_DOCUMENTSTARTEXTEND:
5451 case SCI_DOCUMENTEND:
5452 case SCI_DOCUMENTENDEXTEND:
5453 case SCI_PAGEUP:
5454 case SCI_PAGEUPEXTEND:
5455 case SCI_PAGEDOWN:
5456 case SCI_PAGEDOWNEXTEND:
5457 case SCI_EDITTOGGLEOVERTYPE:
5458 case SCI_CANCEL:
5459 case SCI_DELETEBACK:
5460 case SCI_TAB:
5461 case SCI_BACKTAB:
5462 case SCI_NEWLINE:
5463 case SCI_FORMFEED:
5464 case SCI_VCHOME:
5465 case SCI_VCHOMEEXTEND:
5466 case SCI_ZOOMIN:
5467 case SCI_ZOOMOUT:
5468 case SCI_DELWORDLEFT:
5469 case SCI_DELWORDRIGHT:
5470 case SCI_DELLINELEFT:
5471 case SCI_DELLINERIGHT:
5472 case SCI_LINECUT:
5473 case SCI_LINEDELETE:
5474 case SCI_LINETRANSPOSE:
5475 case SCI_LOWERCASE:
5476 case SCI_UPPERCASE:
5477 case SCI_LINESCROLLDOWN:
5478 case SCI_LINESCROLLUP:
5479 case SCI_WORDPARTLEFT:
5480 case SCI_WORDPARTLEFTEXTEND:
5481 case SCI_WORDPARTRIGHT:
5482 case SCI_WORDPARTRIGHTEXTEND:
5483 case SCI_DELETEBACKNOTLINE:
5484 return KeyCommand(iMessage);
5485
5486 case SCI_BRACEHIGHLIGHT:
5487 SetBraceHighlight(static_cast<int>(wParam), lParam, STYLE_BRACELIGHT);
5488 break;
5489
5490 case SCI_BRACEBADLIGHT:
5491 SetBraceHighlight(static_cast<int>(wParam), -1, STYLE_BRACEBAD);
5492 break;
5493
5494 case SCI_BRACEMATCH:
5495 // wParam is position of char to find brace for,
5496 // lParam is maximum amount of text to restyle to find it
5497 return BraceMatch(wParam, lParam);
5498
5499 case SCI_GETVIEWEOL:
5500 return vs.viewEOL;
5501
5502 case SCI_SETVIEWEOL:
5503 vs.viewEOL = wParam != 0;
5504 InvalidateStyleRedraw();
5505 break;
5506
5507 case SCI_SETZOOM:
5508 vs.zoomLevel = wParam;
5509 NeedWrapping();
5510 InvalidateStyleRedraw();
5511 NotifyZoom();
5512 break;
5513
5514 case SCI_GETZOOM:
5515 return vs.zoomLevel;
5516
5517 case SCI_GETEDGECOLUMN:
5518 return theEdge;
5519
5520 case SCI_SETEDGECOLUMN:
5521 theEdge = wParam;
5522 InvalidateStyleRedraw();
5523 break;
5524
5525 case SCI_GETEDGEMODE:
5526 return vs.edgeState;
5527
5528 case SCI_SETEDGEMODE:
5529 vs.edgeState = wParam;
5530 InvalidateStyleRedraw();
5531 break;
5532
5533 case SCI_GETEDGECOLOUR:
5534 return vs.edgecolour.desired.AsLong();
5535
5536 case SCI_SETEDGECOLOUR:
5537 vs.edgecolour.desired = ColourDesired(wParam);
5538 InvalidateStyleRedraw();
5539 break;
5540
5541 case SCI_GETDOCPOINTER:
5542 return reinterpret_cast<sptr_t>(pdoc);
5543
5544 case SCI_SETDOCPOINTER:
5545 SetDocPointer(reinterpret_cast<Document *>(lParam));
5546 return 0;
5547
5548 case SCI_CREATEDOCUMENT: {
5549 Document *doc = new Document();
5550 doc->AddRef();
5551 return reinterpret_cast<sptr_t>(doc);
5552 }
5553
5554 case SCI_ADDREFDOCUMENT:
5555 (reinterpret_cast<Document *>(lParam))->AddRef();
5556 break;
5557
5558 case SCI_RELEASEDOCUMENT:
5559 (reinterpret_cast<Document *>(lParam))->Release();
5560 break;
5561
5562 case SCI_SETMODEVENTMASK:
5563 modEventMask = wParam;
5564 return 0;
5565
5566 case SCI_GETMODEVENTMASK:
5567 return modEventMask;
5568
5569 case SCI_CONVERTEOLS:
5570 pdoc->ConvertLineEnds(wParam);
5571 SetSelection(currentPos, anchor); // Ensure selection inside document
5572 return 0;
5573
5574 case SCI_SELECTIONISRECTANGLE:
5575 return (selType == selRectangle) ? 1 : 0;
5576
5577 case SCI_SETOVERTYPE:
5578 inOverstrike = wParam != 0;
5579 break;
5580
5581 case SCI_GETOVERTYPE:
5582 return inOverstrike ? 1 : 0;
5583
5584 case SCI_SETFOCUS:
5585 SetFocusState(wParam != 0);
5586 break;
5587
5588 case SCI_GETFOCUS:
5589 return hasFocus;
5590
5591 case SCI_SETSTATUS:
5592 errorStatus = wParam;
5593 break;
5594
5595 case SCI_GETSTATUS:
5596 return errorStatus;
5597
5598 case SCI_SETMOUSEDOWNCAPTURES:
5599 mouseDownCaptures = wParam != 0;
5600 break;
5601
5602 case SCI_GETMOUSEDOWNCAPTURES:
5603 return mouseDownCaptures;
5604
5605 case SCI_SETCURSOR:
5606 cursorMode = wParam;
5607 DisplayCursor(Window::cursorText);
5608 break;
5609
5610 case SCI_GETCURSOR:
5611 return cursorMode;
5612
5613 case SCI_SETCONTROLCHARSYMBOL:
5614 controlCharSymbol = wParam;
5615 break;
5616
5617 case SCI_GETCONTROLCHARSYMBOL:
5618 return controlCharSymbol;
5619
5620 case SCI_STARTRECORD:
5621 recordingMacro = true;
5622 return 0;
5623
5624 case SCI_STOPRECORD:
5625 recordingMacro = false;
5626 return 0;
5627
5628 case SCI_MOVECARETINSIDEVIEW:
5629 MoveCaretInsideView();
5630 break;
5631
5632 default:
5633 return DefWndProc(iMessage, wParam, lParam);
5634 }
5635 //Platform::DebugPrintf("end wnd proc\n");
5636 return 0l;
5637 }
wxWidgets (Impactor)