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