juce/source/src/gui/components/controls/juce_TextEditor.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_TextEditor.h"
  31 #include "../windows/juce_ComponentPeer.h"
  32 #include "../../graphics/fonts/juce_GlyphArrangement.h"
  33 #include "../../../utilities/juce_SystemClipboard.h"
  34 #include "../../../core/juce_Time.h"
  35 #include "../../../text/juce_LocalisedStrings.h"
  36 #include "../../../io/streams/juce_MemoryOutputStream.h"
  37 #include "../lookandfeel/juce_LookAndFeel.h"
  38 #include "../keyboard/juce_TextEditorKeyMapper.h"
  39
  40
  41 //==============================================================================
  42 // a word or space that can't be broken down any further
  43 struct TextAtom
  44 {
  45     //==============================================================================
  46     String atomText;
  47     float width;
  48     int numChars;
  49
  50     //==============================================================================
  51     bool isWhitespace() const       { return CharacterFunctions::isWhitespace (atomText[0]); }
  52     bool isNewLine() const          { return atomText[0] == '\r' || atomText[0] == '\n'; }
  53
  54     String getText (const juce_wchar passwordCharacter) const
  55     {
  56         if (passwordCharacter == 0)
  57             return atomText;
  58         else
  59             return String::repeatedString (String::charToString (passwordCharacter),
  60                                            atomText.length());
  61     }
  62
  63     String getTrimmedText (const juce_wchar passwordCharacter) const
  64     {
  65         if (passwordCharacter == 0)
  66             return atomText.substring (0, numChars);
  67         else if (isNewLine())
  68             return String::empty;
  69         else
  70             return String::repeatedString (String::charToString (passwordCharacter), numChars);
  71     }
  72 };
  73
  74 //==============================================================================
  75 // a run of text with a single font and colour
  76 class TextEditor::UniformTextSection
  77 {
  78 public:
  79     //==============================================================================
  80     UniformTextSection (const String& text,
  81                         const Font& font_,
  82                         const Colour& colour_,
  83                         const juce_wchar passwordCharacter)
  84       : font (font_),
  85         colour (colour_)
  86     {
  87         initialiseAtoms (text, passwordCharacter);
  88     }
  89
  90     UniformTextSection (const UniformTextSection& other)
  91       : font (other.font),
  92         colour (other.colour)
  93     {
  94         atoms.ensureStorageAllocated (other.atoms.size());
  95
  96         for (int i = 0; i < other.atoms.size(); ++i)
  97             atoms.add (new TextAtom (*other.atoms.getUnchecked(i)));
  98     }
  99
 100     ~UniformTextSection()
 101     {
 102         // (no need to delete the atoms, as they're explicitly deleted by the caller)
 103     }
 104
 105     void clear()
 106     {
 107         for (int i = atoms.size(); --i >= 0;)
 108             delete getAtom(i);
 109
 110         atoms.clear();
 111     }
 112
 113     int getNumAtoms() const
 114     {
 115         return atoms.size();
 116     }
 117
 118     TextAtom* getAtom (const int index) const noexcept
 119     {
 120         return atoms.getUnchecked (index);
 121     }
 122
 123     void append (const UniformTextSection& other, const juce_wchar passwordCharacter)
 124     {
 125         if (other.atoms.size() > 0)
 126         {
 127             TextAtom* const lastAtom = atoms.getLast();
 128             int i = 0;
 129
 130             if (lastAtom != nullptr)
 131             {
 132                 if (! CharacterFunctions::isWhitespace (lastAtom->atomText.getLastCharacter()))
 133                 {
 134                     TextAtom* const first = other.getAtom(0);
 135
 136                     if (! CharacterFunctions::isWhitespace (first->atomText[0]))
 137                     {
 138                         lastAtom->atomText += first->atomText;
 139                         lastAtom->numChars = (uint16) (lastAtom->numChars + first->numChars);
 140                         lastAtom->width = font.getStringWidthFloat (lastAtom->getText (passwordCharacter));
 141                         delete first;
 142                         ++i;
 143                     }
 144                 }
 145             }
 146
 147             atoms.ensureStorageAllocated (atoms.size() + other.atoms.size() - i);
 148
 149             while (i < other.atoms.size())
 150             {
 151                 atoms.add (other.getAtom(i));
 152                 ++i;
 153             }
 154         }
 155     }
 156
 157     UniformTextSection* split (const int indexToBreakAt,
 158                                const juce_wchar passwordCharacter)
 159     {
 160         UniformTextSection* const section2 = new UniformTextSection (String::empty,
 161                                                                      font, colour,
 162                                                                      passwordCharacter);
 163         int index = 0;
 164
 165         for (int i = 0; i < atoms.size(); ++i)
 166         {
 167             TextAtom* const atom = getAtom(i);
 168
 169             const int nextIndex = index + atom->numChars;
 170
 171             if (index == indexToBreakAt)
 172             {
 173                 int j;
 174                 for (j = i; j < atoms.size(); ++j)
 175                     section2->atoms.add (getAtom (j));
 176
 177                 for (j = atoms.size(); --j >= i;)
 178                     atoms.remove (j);
 179
 180                 break;
 181             }
 182             else if (indexToBreakAt >= index && indexToBreakAt < nextIndex)
 183             {
 184                 TextAtom* const secondAtom = new TextAtom();
 185
 186                 secondAtom->atomText = atom->atomText.substring (indexToBreakAt - index);
 187                 secondAtom->width = font.getStringWidthFloat (secondAtom->getText (passwordCharacter));
 188                 secondAtom->numChars = (uint16) secondAtom->atomText.length();
 189
 190                 section2->atoms.add (secondAtom);
 191
 192                 atom->atomText = atom->atomText.substring (0, indexToBreakAt - index);
 193                 atom->width = font.getStringWidthFloat (atom->getText (passwordCharacter));
 194                 atom->numChars = (uint16) (indexToBreakAt - index);
 195
 196                 int j;
 197                 for (j = i + 1; j < atoms.size(); ++j)
 198                     section2->atoms.add (getAtom (j));
 199
 200                 for (j = atoms.size(); --j > i;)
 201                     atoms.remove (j);
 202
 203                 break;
 204             }
 205
 206             index = nextIndex;
 207         }
 208
 209         return section2;
 210     }
 211
 212     void appendAllText (MemoryOutputStream& mo) const
 213     {
 214         for (int i = 0; i < atoms.size(); ++i)
 215             mo << getAtom(i)->atomText;
 216     }
 217
 218     void appendSubstring (MemoryOutputStream& mo, const Range<int>& range) const
 219     {
 220         int index = 0;
 221         for (int i = 0; i < atoms.size(); ++i)
 222         {
 223             const TextAtom* const atom = getAtom (i);
 224             const int nextIndex = index + atom->numChars;
 225
 226             if (range.getStart() < nextIndex)
 227             {
 228                 if (range.getEnd() <= index)
 229                     break;
 230
 231                 const Range<int> r ((range - index).getIntersectionWith (Range<int> (0, (int) atom->numChars)));
 232
 233                 if (! r.isEmpty())
 234                     mo << atom->atomText.substring (r.getStart(), r.getEnd());
 235             }
 236
 237             index = nextIndex;
 238         }
 239     }
 240
 241     int getTotalLength() const
 242     {
 243         int total = 0;
 244
 245         for (int i = atoms.size(); --i >= 0;)
 246             total += getAtom(i)->numChars;
 247
 248         return total;
 249     }
 250
 251     void setFont (const Font& newFont,
 252                   const juce_wchar passwordCharacter)
 253     {
 254         if (font != newFont)
 255         {
 256             font = newFont;
 257
 258             for (int i = atoms.size(); --i >= 0;)
 259             {
 260                 TextAtom* const atom = atoms.getUnchecked(i);
 261                 atom->width = newFont.getStringWidthFloat (atom->getText (passwordCharacter));
 262             }
 263         }
 264     }
 265
 266     //==============================================================================
 267     Font font;
 268     Colour colour;
 269
 270 private:
 271     Array <TextAtom*> atoms;
 272
 273     //==============================================================================
 274     void initialiseAtoms (const String& textToParse,
 275                           const juce_wchar passwordCharacter)
 276     {
 277         String::CharPointerType text (textToParse.getCharPointer());
 278
 279         while (! text.isEmpty())
 280         {
 281             int numChars = 0;
 282             String::CharPointerType start (text);
 283
 284             // create a whitespace atom unless it starts with non-ws
 285             if (text.isWhitespace() && *text != '\r' && *text != '\n')
 286             {
 287                 do
 288                 {
 289                     ++text;
 290                     ++numChars;
 291                 }
 292                 while (text.isWhitespace() && *text != '\r' && *text != '\n');
 293             }
 294             else
 295             {
 296                 if (*text == '\r')
 297                 {
 298                     ++text;
 299                     ++numChars;
 300
 301                     if (*text == '\n')
 302                     {
 303                         ++start;
 304                         ++text;
 305                     }
 306                 }
 307                 else if (*text == '\n')
 308                 {
 309                     ++text;
 310                     ++numChars;
 311                 }
 312                 else
 313                 {
 314                     while (! (text.isEmpty() || text.isWhitespace()))
 315                     {
 316                         ++text;
 317                         ++numChars;
 318                     }
 319                 }
 320             }
 321
 322             TextAtom* const atom = new TextAtom();
 323             atom->atomText = String (start, numChars);
 324
 325             atom->width = font.getStringWidthFloat (atom->getText (passwordCharacter));
 326             atom->numChars = (uint16) numChars;
 327
 328             atoms.add (atom);
 329         }
 330     }
 331
 332     UniformTextSection& operator= (const UniformTextSection& other);
 333     JUCE_LEAK_DETECTOR (UniformTextSection);
 334 };
 335
 336 //==============================================================================
 337 class TextEditor::Iterator
 338 {
 339 public:
 340     //==============================================================================
 341     Iterator (const Array <UniformTextSection*>& sections_,
 342               const float wordWrapWidth_,
 343               const juce_wchar passwordCharacter_)
 344       : indexInText (0),
 345         lineY (0),
 346         lineHeight (0),
 347         maxDescent (0),
 348         atomX (0),
 349         atomRight (0),
 350         atom (0),
 351         currentSection (nullptr),
 352         sections (sections_),
 353         sectionIndex (0),
 354         atomIndex (0),
 355         wordWrapWidth (wordWrapWidth_),
 356         passwordCharacter (passwordCharacter_)
 357     {
 358         jassert (wordWrapWidth_ > 0);
 359
 360         if (sections.size() > 0)
 361         {
 362             currentSection = sections.getUnchecked (sectionIndex);
 363
 364             if (currentSection != nullptr)
 365                 beginNewLine();
 366         }
 367     }
 368
 369     Iterator (const Iterator& other)
 370       : indexInText (other.indexInText),
 371         lineY (other.lineY),
 372         lineHeight (other.lineHeight),
 373         maxDescent (other.maxDescent),
 374         atomX (other.atomX),
 375         atomRight (other.atomRight),
 376         atom (other.atom),
 377         currentSection (other.currentSection),
 378         sections (other.sections),
 379         sectionIndex (other.sectionIndex),
 380         atomIndex (other.atomIndex),
 381         wordWrapWidth (other.wordWrapWidth),
 382         passwordCharacter (other.passwordCharacter),
 383         tempAtom (other.tempAtom)
 384     {
 385     }
 386
 387     //==============================================================================
 388     bool next()
 389     {
 390         if (atom == &tempAtom)
 391         {
 392             const int numRemaining = tempAtom.atomText.length() - tempAtom.numChars;
 393
 394             if (numRemaining > 0)
 395             {
 396                 tempAtom.atomText = tempAtom.atomText.substring (tempAtom.numChars);
 397
 398                 atomX = 0;
 399
 400                 if (tempAtom.numChars > 0)
 401                     lineY += lineHeight;
 402
 403                 indexInText += tempAtom.numChars;
 404
 405                 GlyphArrangement g;
 406                 g.addLineOfText (currentSection->font, atom->getText (passwordCharacter), 0.0f, 0.0f);
 407
 408                 int split;
 409                 for (split = 0; split < g.getNumGlyphs(); ++split)
 410                     if (shouldWrap (g.getGlyph (split).getRight()))
 411                         break;
 412
 413                 if (split > 0 && split <= numRemaining)
 414                 {
 415                     tempAtom.numChars = (uint16) split;
 416                     tempAtom.width = g.getGlyph (split - 1).getRight();
 417                     atomRight = atomX + tempAtom.width;
 418                     return true;
 419                 }
 420             }
 421         }
 422
 423         bool forceNewLine = false;
 424
 425         if (sectionIndex >= sections.size())
 426         {
 427             moveToEndOfLastAtom();
 428             return false;
 429         }
 430         else if (atomIndex >= currentSection->getNumAtoms() - 1)
 431         {
 432             if (atomIndex >= currentSection->getNumAtoms())
 433             {
 434                 if (++sectionIndex >= sections.size())
 435                 {
 436                     moveToEndOfLastAtom();
 437                     return false;
 438                 }
 439
 440                 atomIndex = 0;
 441                 currentSection = sections.getUnchecked (sectionIndex);
 442             }
 443             else
 444             {
 445                 const TextAtom* const lastAtom = currentSection->getAtom (atomIndex);
 446
 447                 if (! lastAtom->isWhitespace())
 448                 {
 449                     // handle the case where the last atom in a section is actually part of the same
 450                     // word as the first atom of the next section...
 451                     float right = atomRight + lastAtom->width;
 452                     float lineHeight2 = lineHeight;
 453                     float maxDescent2 = maxDescent;
 454
 455                     for (int section = sectionIndex + 1; section < sections.size(); ++section)
 456                     {
 457                         const UniformTextSection* const s = sections.getUnchecked (section);
 458
 459                         if (s->getNumAtoms() == 0)
 460                             break;
 461
 462                         const TextAtom* const nextAtom = s->getAtom (0);
 463
 464                         if (nextAtom->isWhitespace())
 465                             break;
 466
 467                         right += nextAtom->width;
 468
 469                         lineHeight2 = jmax (lineHeight2, s->font.getHeight());
 470                         maxDescent2 = jmax (maxDescent2, s->font.getDescent());
 471
 472                         if (shouldWrap (right))
 473                         {
 474                             lineHeight = lineHeight2;
 475                             maxDescent = maxDescent2;
 476
 477                             forceNewLine = true;
 478                             break;
 479                         }
 480
 481                         if (s->getNumAtoms() > 1)
 482                             break;
 483                     }
 484                 }
 485             }
 486         }
 487
 488         if (atom != nullptr)
 489         {
 490             atomX = atomRight;
 491             indexInText += atom->numChars;
 492
 493             if (atom->isNewLine())
 494                 beginNewLine();
 495         }
 496
 497         atom = currentSection->getAtom (atomIndex);
 498         atomRight = atomX + atom->width;
 499         ++atomIndex;
 500
 501         if (shouldWrap (atomRight) || forceNewLine)
 502         {
 503             if (atom->isWhitespace())
 504             {
 505                 // leave whitespace at the end of a line, but truncate it to avoid scrolling
 506                 atomRight = jmin (atomRight, wordWrapWidth);
 507             }
 508             else
 509             {
 510                 atomRight = atom->width;
 511
 512                 if (shouldWrap (atomRight))  // atom too big to fit on a line, so break it up..
 513                 {
 514                     tempAtom = *atom;
 515                     tempAtom.width = 0;
 516                     tempAtom.numChars = 0;
 517                     atom = &tempAtom;
 518
 519                     if (atomX > 0)
 520                         beginNewLine();
 521
 522                     return next();
 523                 }
 524
 525                 beginNewLine();
 526                 return true;
 527             }
 528         }
 529
 530         return true;
 531     }
 532
 533     void beginNewLine()
 534     {
 535         atomX = 0;
 536         lineY += lineHeight;
 537
 538         int tempSectionIndex = sectionIndex;
 539         int tempAtomIndex = atomIndex;
 540         const UniformTextSection* section = sections.getUnchecked (tempSectionIndex);
 541
 542         lineHeight = section->font.getHeight();
 543         maxDescent = section->font.getDescent();
 544
 545         float x = (atom != nullptr) ? atom->width : 0;
 546
 547         while (! shouldWrap (x))
 548         {
 549             if (tempSectionIndex >= sections.size())
 550                 break;
 551
 552             bool checkSize = false;
 553
 554             if (tempAtomIndex >= section->getNumAtoms())
 555             {
 556                 if (++tempSectionIndex >= sections.size())
 557                     break;
 558
 559                 tempAtomIndex = 0;
 560                 section = sections.getUnchecked (tempSectionIndex);
 561                 checkSize = true;
 562             }
 563
 564             const TextAtom* const nextAtom = section->getAtom (tempAtomIndex);
 565
 566             if (nextAtom == nullptr)
 567                 break;
 568
 569             x += nextAtom->width;
 570
 571             if (shouldWrap (x) || nextAtom->isNewLine())
 572                 break;
 573
 574             if (checkSize)
 575             {
 576                 lineHeight = jmax (lineHeight, section->font.getHeight());
 577                 maxDescent = jmax (maxDescent, section->font.getDescent());
 578             }
 579
 580             ++tempAtomIndex;
 581         }
 582     }
 583
 584     //==============================================================================
 585     void draw (Graphics& g, const UniformTextSection*& lastSection) const
 586     {
 587         if (passwordCharacter != 0 || ! atom->isWhitespace())
 588         {
 589             if (lastSection != currentSection)
 590             {
 591                 lastSection = currentSection;
 592                 g.setColour (currentSection->colour);
 593                 g.setFont (currentSection->font);
 594             }
 595
 596             jassert (atom->getTrimmedText (passwordCharacter).isNotEmpty());
 597
 598             GlyphArrangement ga;
 599             ga.addLineOfText (currentSection->font,
 600                               atom->getTrimmedText (passwordCharacter),
 601                               atomX,
 602                               (float) roundToInt (lineY + lineHeight - maxDescent));
 603             ga.draw (g);
 604         }
 605     }
 606
 607     void drawSelection (Graphics& g, const Range<int>& selection) const
 608     {
 609         const int startX = roundToInt (indexToX (selection.getStart()));
 610         const int endX   = roundToInt (indexToX (selection.getEnd()));
 611
 612         const int y = roundToInt (lineY);
 613         const int nextY = roundToInt (lineY + lineHeight);
 614
 615         g.fillRect (startX, y, endX - startX, nextY - y);
 616     }
 617
 618     void drawUnderline (Graphics& g, const Range<int>& underline, const Colour& colour) const
 619     {
 620         const int startX    = roundToInt (indexToX (underline.getStart()));
 621         const int endX      = roundToInt (indexToX (underline.getEnd()));
 622         const int baselineY = roundToInt (lineY + currentSection->font.getAscent() + 0.5f);
 623
 624         Graphics::ScopedSaveState state (g);
 625         g.reduceClipRegion (Rectangle<int> (startX, baselineY, endX - startX, 1));
 626         g.fillCheckerBoard (Rectangle<int> (0, 0, endX, baselineY + 1), 3, 1, colour, Colours::transparentBlack);
 627     }
 628
 629     void drawSelectedText (Graphics& g,
 630                            const Range<int>& selection,
 631                            const Colour& selectedTextColour) const
 632     {
 633         if (passwordCharacter != 0 || ! atom->isWhitespace())
 634         {
 635             GlyphArrangement ga;
 636             ga.addLineOfText (currentSection->font,
 637                               atom->getTrimmedText (passwordCharacter),
 638                               atomX,
 639                               (float) roundToInt (lineY + lineHeight - maxDescent));
 640
 641             if (selection.getEnd() < indexInText + atom->numChars)
 642             {
 643                 GlyphArrangement ga2 (ga);
 644                 ga2.removeRangeOfGlyphs (0, selection.getEnd() - indexInText);
 645                 ga.removeRangeOfGlyphs (selection.getEnd() - indexInText, -1);
 646
 647                 g.setColour (currentSection->colour);
 648                 ga2.draw (g);
 649             }
 650
 651             if (selection.getStart() > indexInText)
 652             {
 653                 GlyphArrangement ga2 (ga);
 654                 ga2.removeRangeOfGlyphs (selection.getStart() - indexInText, -1);
 655                 ga.removeRangeOfGlyphs (0, selection.getStart() - indexInText);
 656
 657                 g.setColour (currentSection->colour);
 658                 ga2.draw (g);
 659             }
 660
 661             g.setColour (selectedTextColour);
 662             ga.draw (g);
 663         }
 664     }
 665
 666     //==============================================================================
 667     float indexToX (const int indexToFind) const
 668     {
 669         if (indexToFind <= indexInText)
 670             return atomX;
 671
 672         if (indexToFind >= indexInText + atom->numChars)
 673             return atomRight;
 674
 675         GlyphArrangement g;
 676         g.addLineOfText (currentSection->font,
 677                          atom->getText (passwordCharacter),
 678                          atomX, 0.0f);
 679
 680         if (indexToFind - indexInText >= g.getNumGlyphs())
 681             return atomRight;
 682
 683         return jmin (atomRight, g.getGlyph (indexToFind - indexInText).getLeft());
 684     }
 685
 686     int xToIndex (const float xToFind) const
 687     {
 688         if (xToFind <= atomX || atom->isNewLine())
 689             return indexInText;
 690
 691         if (xToFind >= atomRight)
 692             return indexInText + atom->numChars;
 693
 694         GlyphArrangement g;
 695         g.addLineOfText (currentSection->font,
 696                          atom->getText (passwordCharacter),
 697                          atomX, 0.0f);
 698
 699         int j;
 700         for (j = 0; j < g.getNumGlyphs(); ++j)
 701             if ((g.getGlyph(j).getLeft() + g.getGlyph(j).getRight()) / 2 > xToFind)
 702                 break;
 703
 704         return indexInText + j;
 705     }
 706
 707     //==============================================================================
 708     bool getCharPosition (const int index, float& cx, float& cy, float& lineHeight_)
 709     {
 710         while (next())
 711         {
 712             if (indexInText + atom->numChars > index)
 713             {
 714                 cx = indexToX (index);
 715                 cy = lineY;
 716                 lineHeight_ = lineHeight;
 717                 return true;
 718             }
 719         }
 720
 721         cx = atomX;
 722         cy = lineY;
 723         lineHeight_ = lineHeight;
 724         return false;
 725     }
 726
 727     //==============================================================================
 728     int indexInText;
 729     float lineY, lineHeight, maxDescent;
 730     float atomX, atomRight;
 731     const TextAtom* atom;
 732     const UniformTextSection* currentSection;
 733
 734 private:
 735     const Array <UniformTextSection*>& sections;
 736     int sectionIndex, atomIndex;
 737     const float wordWrapWidth;
 738     const juce_wchar passwordCharacter;
 739     TextAtom tempAtom;
 740
 741     Iterator& operator= (const Iterator&);
 742
 743     void moveToEndOfLastAtom()
 744     {
 745         if (atom != nullptr)
 746         {
 747             atomX = atomRight;
 748
 749             if (atom->isNewLine())
 750             {
 751                 atomX = 0.0f;
 752                 lineY += lineHeight;
 753             }
 754         }
 755     }
 756
 757     bool shouldWrap (const float x) const
 758     {
 759         return (x - 0.0001f) >= wordWrapWidth;
 760     }
 761
 762     JUCE_LEAK_DETECTOR (Iterator);
 763 };
 764
 765
 766 //==============================================================================
 767 class TextEditor::InsertAction  : public UndoableAction
 768 {
 769 public:
 770     InsertAction (TextEditor& owner_,
 771                   const String& text_,
 772                   const int insertIndex_,
 773                   const Font& font_,
 774                   const Colour& colour_,
 775                   const int oldCaretPos_,
 776                   const int newCaretPos_)
 777         : owner (owner_),
 778           text (text_),
 779           insertIndex (insertIndex_),
 780           oldCaretPos (oldCaretPos_),
 781           newCaretPos (newCaretPos_),
 782           font (font_),
 783           colour (colour_)
 784     {
 785     }
 786
 787     bool perform()
 788     {
 789         owner.insert (text, insertIndex, font, colour, 0, newCaretPos);
 790         return true;
 791     }
 792
 793     bool undo()
 794     {
 795         owner.remove (Range<int> (insertIndex, insertIndex + text.length()), 0, oldCaretPos);
 796         return true;
 797     }
 798
 799     int getSizeInUnits()
 800     {
 801         return text.length() + 16;
 802     }
 803
 804 private:
 805     TextEditor& owner;
 806     const String text;
 807     const int insertIndex, oldCaretPos, newCaretPos;
 808     const Font font;
 809     const Colour colour;
 810
 811     JUCE_DECLARE_NON_COPYABLE (InsertAction);
 812 };
 813
 814 //==============================================================================
 815 class TextEditor::RemoveAction  : public UndoableAction
 816 {
 817 public:
 818     RemoveAction (TextEditor& owner_,
 819                   const Range<int> range_,
 820                   const int oldCaretPos_,
 821                   const int newCaretPos_,
 822                   const Array <UniformTextSection*>& removedSections_)
 823         : owner (owner_),
 824           range (range_),
 825           oldCaretPos (oldCaretPos_),
 826           newCaretPos (newCaretPos_),
 827           removedSections (removedSections_)
 828     {
 829     }
 830
 831     ~RemoveAction()
 832     {
 833         for (int i = removedSections.size(); --i >= 0;)
 834         {
 835             UniformTextSection* const section = removedSections.getUnchecked (i);
 836             section->clear();
 837             delete section;
 838         }
 839     }
 840
 841     bool perform()
 842     {
 843         owner.remove (range, 0, newCaretPos);
 844         return true;
 845     }
 846
 847     bool undo()
 848     {
 849         owner.reinsert (range.getStart(), removedSections);
 850         owner.moveCaretTo (oldCaretPos, false);
 851         return true;
 852     }
 853
 854     int getSizeInUnits()
 855     {
 856         int n = 0;
 857
 858         for (int i = removedSections.size(); --i >= 0;)
 859             n += removedSections.getUnchecked (i)->getTotalLength();
 860
 861         return n + 16;
 862     }
 863
 864 private:
 865     TextEditor& owner;
 866     const Range<int> range;
 867     const int oldCaretPos, newCaretPos;
 868     Array <UniformTextSection*> removedSections;
 869
 870     JUCE_DECLARE_NON_COPYABLE (RemoveAction);
 871 };
 872
 873 //==============================================================================
 874 class TextEditor::TextHolderComponent  : public Component,
 875                                          public Timer,
 876                                          public ValueListener
 877 {
 878 public:
 879     TextHolderComponent (TextEditor& owner_)
 880         : owner (owner_)
 881     {
 882         setWantsKeyboardFocus (false);
 883         setInterceptsMouseClicks (false, true);
 884
 885         owner.getTextValue().addListener (this);
 886     }
 887
 888     ~TextHolderComponent()
 889     {
 890         owner.getTextValue().removeListener (this);
 891     }
 892
 893     void paint (Graphics& g)
 894     {
 895         owner.drawContent (g);
 896     }
 897
 898     void restartTimer()
 899     {
 900         startTimer (350);
 901     }
 902
 903     void timerCallback()
 904     {
 905         owner.timerCallbackInt();
 906     }
 907
 908     const MouseCursor getMouseCursor()
 909     {
 910         return owner.getMouseCursor();
 911     }
 912
 913     void valueChanged (Value&)
 914     {
 915         owner.textWasChangedByValue();
 916     }
 917
 918 private:
 919     TextEditor& owner;
 920
 921     JUCE_DECLARE_NON_COPYABLE (TextHolderComponent);
 922 };
 923
 924 //==============================================================================
 925 class TextEditorViewport  : public Viewport
 926 {
 927 public:
 928     TextEditorViewport (TextEditor& owner_)
 929         : owner (owner_), lastWordWrapWidth (0), rentrant (false)
 930     {
 931     }
 932
 933     void visibleAreaChanged (const Rectangle<int>&)
 934     {
 935         if (! rentrant) // it's rare, but possible to get into a feedback loop as the viewport's scrollbars
 936                         // appear and disappear, causing the wrap width to change.
 937         {
 938             const float wordWrapWidth = owner.getWordWrapWidth();
 939
 940             if (wordWrapWidth != lastWordWrapWidth)
 941             {
 942                 lastWordWrapWidth = wordWrapWidth;
 943
 944                 rentrant = true;
 945                 owner.updateTextHolderSize();
 946                 rentrant = false;
 947             }
 948         }
 949     }
 950
 951 private:
 952     TextEditor& owner;
 953     float lastWordWrapWidth;
 954     bool rentrant;
 955
 956     JUCE_DECLARE_NON_COPYABLE (TextEditorViewport);
 957 };
 958
 959 //==============================================================================
 960 namespace TextEditorDefs
 961 {
 962     const int textChangeMessageId = 0x10003001;
 963     const int returnKeyMessageId  = 0x10003002;
 964     const int escapeKeyMessageId  = 0x10003003;
 965     const int focusLossMessageId  = 0x10003004;
 966
 967     const int maxActionsPerTransaction = 100;
 968
 969     int getCharacterCategory (const juce_wchar character)
 970     {
 971         return CharacterFunctions::isLetterOrDigit (character)
 972                     ? 2 : (CharacterFunctions::isWhitespace (character) ? 0 : 1);
 973     }
 974 }
 975
 976 //==============================================================================
 977 TextEditor::TextEditor (const String& name,
 978                         const juce_wchar passwordCharacter_)
 979     : Component (name),
 980       borderSize (1, 1, 1, 3),
 981       readOnly (false),
 982       multiline (false),
 983       wordWrap (false),
 984       returnKeyStartsNewLine (false),
 985       popupMenuEnabled (true),
 986       selectAllTextWhenFocused (false),
 987       scrollbarVisible (true),
 988       wasFocused (false),
 989       keepCaretOnScreen (true),
 990       tabKeyUsed (false),
 991       menuActive (false),
 992       valueTextNeedsUpdating (false),
 993       maxTextLength (0),
 994       leftIndent (4),
 995       topIndent (4),
 996       lastTransactionTime (0),
 997       currentFont (14.0f),
 998       totalNumChars (0),
 999       caretPosition (0),
1000       passwordCharacter (passwordCharacter_),
1001       dragType (notDragging)
1002 {
1003     setOpaque (true);
1004
1005     addAndMakeVisible (viewport = new TextEditorViewport (*this));
1006     viewport->setViewedComponent (textHolder = new TextHolderComponent (*this));
1007     viewport->setWantsKeyboardFocus (false);
1008     viewport->setScrollBarsShown (false, false);
1009
1010     setWantsKeyboardFocus (true);
1011     setCaretVisible (true);
1012 }
1013
1014 TextEditor::~TextEditor()
1015 {
1016     if (wasFocused)
1017     {
1018         ComponentPeer* const peer = getPeer();
1019         if (peer != nullptr)
1020             peer->dismissPendingTextInput();
1021     }
1022
1023     textValue.referTo (Value());
1024     clearInternal (0);
1025     viewport = nullptr;
1026     textHolder = nullptr;
1027 }
1028
1029 //==============================================================================
1030 void TextEditor::newTransaction()
1031 {
1032     lastTransactionTime = Time::getApproximateMillisecondCounter();
1033     undoManager.beginNewTransaction();
1034 }
1035
1036 bool TextEditor::undoOrRedo (const bool shouldUndo)
1037 {
1038     if (! isReadOnly())
1039     {
1040         newTransaction();
1041
1042         if (shouldUndo ? undoManager.undo()
1043                        : undoManager.redo())
1044         {
1045             scrollToMakeSureCursorIsVisible();
1046             repaint();
1047             textChanged();
1048             return true;
1049         }
1050     }
1051
1052     return false;
1053 }
1054
1055 bool TextEditor::undo()     { return undoOrRedo (true); }
1056 bool TextEditor::redo()     { return undoOrRedo (false); }
1057
1058 //==============================================================================
1059 void TextEditor::setMultiLine (const bool shouldBeMultiLine,
1060                                const bool shouldWordWrap)
1061 {
1062     if (multiline != shouldBeMultiLine
1063          || wordWrap != (shouldWordWrap && shouldBeMultiLine))
1064     {
1065         multiline = shouldBeMultiLine;
1066         wordWrap = shouldWordWrap && shouldBeMultiLine;
1067
1068         viewport->setScrollBarsShown (scrollbarVisible && multiline,
1069                                       scrollbarVisible && multiline);
1070         viewport->setViewPosition (0, 0);
1071         resized();
1072         scrollToMakeSureCursorIsVisible();
1073     }
1074 }
1075
1076 bool TextEditor::isMultiLine() const
1077 {
1078     return multiline;
1079 }
1080
1081 void TextEditor::setScrollbarsShown (bool shown)
1082 {
1083     if (scrollbarVisible != shown)
1084     {
1085         scrollbarVisible = shown;
1086         shown = shown && isMultiLine();
1087         viewport->setScrollBarsShown (shown, shown);
1088     }
1089 }
1090
1091 void TextEditor::setReadOnly (const bool shouldBeReadOnly)
1092 {
1093     if (readOnly != shouldBeReadOnly)
1094     {
1095         readOnly = shouldBeReadOnly;
1096         enablementChanged();
1097     }
1098 }
1099
1100 bool TextEditor::isReadOnly() const
1101 {
1102     return readOnly || ! isEnabled();
1103 }
1104
1105 bool TextEditor::isTextInputActive() const
1106 {
1107     return ! isReadOnly();
1108 }
1109
1110 void TextEditor::setReturnKeyStartsNewLine (const bool shouldStartNewLine)
1111 {
1112     returnKeyStartsNewLine = shouldStartNewLine;
1113 }
1114
1115 void TextEditor::setTabKeyUsedAsCharacter (const bool shouldTabKeyBeUsed)
1116 {
1117     tabKeyUsed = shouldTabKeyBeUsed;
1118 }
1119
1120 void TextEditor::setPopupMenuEnabled (const bool b)
1121 {
1122     popupMenuEnabled = b;
1123 }
1124
1125 void TextEditor::setSelectAllWhenFocused (const bool b)
1126 {
1127     selectAllTextWhenFocused = b;
1128 }
1129
1130 //==============================================================================
1131 const Font& TextEditor::getFont() const
1132 {
1133     return currentFont;
1134 }
1135
1136 void TextEditor::setFont (const Font& newFont)
1137 {
1138     currentFont = newFont;
1139     scrollToMakeSureCursorIsVisible();
1140 }
1141
1142 void TextEditor::applyFontToAllText (const Font& newFont)
1143 {
1144     currentFont = newFont;
1145
1146     const Colour overallColour (findColour (textColourId));
1147
1148     for (int i = sections.size(); --i >= 0;)
1149     {
1150         UniformTextSection* const uts = sections.getUnchecked (i);
1151         uts->setFont (newFont, passwordCharacter);
1152         uts->colour = overallColour;
1153     }
1154
1155     coalesceSimilarSections();
1156     updateTextHolderSize();
1157     scrollToMakeSureCursorIsVisible();
1158     repaint();
1159 }
1160
1161 void TextEditor::colourChanged()
1162 {
1163     setOpaque (findColour (backgroundColourId).isOpaque());
1164     repaint();
1165 }
1166
1167 void TextEditor::lookAndFeelChanged()
1168 {
1169     if (isCaretVisible())
1170     {
1171         setCaretVisible (false);
1172         setCaretVisible (true);
1173     }
1174 }
1175
1176 void TextEditor::setCaretVisible (const bool shouldCaretBeVisible)
1177 {
1178     if (shouldCaretBeVisible && ! isReadOnly())
1179     {
1180         if (caret == nullptr)
1181             textHolder->addChildComponent (caret = getLookAndFeel().createCaretComponent (this));
1182     }
1183     else
1184     {
1185         caret = nullptr;
1186     }
1187
1188     setMouseCursor (shouldCaretBeVisible ? MouseCursor::IBeamCursor
1189                                          : MouseCursor::NormalCursor);
1190 }
1191
1192 void TextEditor::updateCaretPosition()
1193 {
1194     if (caret != nullptr)
1195         caret->setCaretPosition (getCaretRectangle().translated (leftIndent, topIndent));
1196 }
1197
1198 void TextEditor::setInputRestrictions (const int maxLen,
1199                                        const String& chars)
1200 {
1201     maxTextLength = jmax (0, maxLen);
1202     allowedCharacters = chars;
1203 }
1204
1205 void TextEditor::setTextToShowWhenEmpty (const String& text, const Colour& colourToUse)
1206 {
1207     textToShowWhenEmpty = text;
1208     colourForTextWhenEmpty = colourToUse;
1209 }
1210
1211 void TextEditor::setPasswordCharacter (const juce_wchar newPasswordCharacter)
1212 {
1213     if (passwordCharacter != newPasswordCharacter)
1214     {
1215         passwordCharacter = newPasswordCharacter;
1216         resized();
1217         repaint();
1218     }
1219 }
1220
1221 void TextEditor::setScrollBarThickness (const int newThicknessPixels)
1222 {
1223     viewport->setScrollBarThickness (newThicknessPixels);
1224 }
1225
1226 void TextEditor::setScrollBarButtonVisibility (const bool buttonsVisible)
1227 {
1228     viewport->setScrollBarButtonVisibility (buttonsVisible);
1229 }
1230
1231 //==============================================================================
1232 void TextEditor::clear()
1233 {
1234     clearInternal (0);
1235     updateTextHolderSize();
1236     undoManager.clearUndoHistory();
1237 }
1238
1239 void TextEditor::setText (const String& newText,
1240                           const bool sendTextChangeMessage)
1241 {
1242     const int newLength = newText.length();
1243
1244     if (newLength != getTotalNumChars() || getText() != newText)
1245     {
1246         const int oldCursorPos = caretPosition;
1247         const bool cursorWasAtEnd = oldCursorPos >= getTotalNumChars();
1248
1249         clearInternal (0);
1250         insert (newText, 0, currentFont, findColour (textColourId), 0, caretPosition);
1251
1252         // if you're adding text with line-feeds to a single-line text editor, it
1253         // ain't gonna look right!
1254         jassert (multiline || ! newText.containsAnyOf ("\r\n"));
1255
1256         if (cursorWasAtEnd && ! isMultiLine())
1257             moveCaretTo (getTotalNumChars(), false);
1258         else
1259             moveCaretTo (oldCursorPos, false);
1260
1261         if (sendTextChangeMessage)
1262             textChanged();
1263
1264         updateTextHolderSize();
1265         scrollToMakeSureCursorIsVisible();
1266         undoManager.clearUndoHistory();
1267
1268         repaint();
1269     }
1270 }
1271
1272 //==============================================================================
1273 void TextEditor::updateValueFromText()
1274 {
1275     if (valueTextNeedsUpdating)
1276     {
1277         valueTextNeedsUpdating = false;
1278         textValue = getText();
1279     }
1280 }
1281
1282 Value& TextEditor::getTextValue()
1283 {
1284     updateValueFromText();
1285     return textValue;
1286 }
1287
1288 void TextEditor::textWasChangedByValue()
1289 {
1290     if (textValue.getValueSource().getReferenceCount() > 1)
1291         setText (textValue.getValue());
1292 }
1293
1294 //==============================================================================
1295 void TextEditor::textChanged()
1296 {
1297     updateTextHolderSize();
1298     postCommandMessage (TextEditorDefs::textChangeMessageId);
1299
1300     if (textValue.getValueSource().getReferenceCount() > 1)
1301     {
1302         valueTextNeedsUpdating = false;
1303         textValue = getText();
1304     }
1305 }
1306
1307 void TextEditor::returnPressed()
1308 {
1309     postCommandMessage (TextEditorDefs::returnKeyMessageId);
1310 }
1311
1312 void TextEditor::escapePressed()
1313 {
1314     postCommandMessage (TextEditorDefs::escapeKeyMessageId);
1315 }
1316
1317 void TextEditor::addListener (TextEditorListener* const newListener)
1318 {
1319     listeners.add (newListener);
1320 }
1321
1322 void TextEditor::removeListener (TextEditorListener* const listenerToRemove)
1323 {
1324     listeners.remove (listenerToRemove);
1325 }
1326
1327 //==============================================================================
1328 void TextEditor::timerCallbackInt()
1329 {
1330     if (hasKeyboardFocus (false) && ! isCurrentlyBlockedByAnotherModalComponent())
1331         wasFocused = true;
1332
1333     const unsigned int now = Time::getApproximateMillisecondCounter();
1334
1335     if (now > lastTransactionTime + 200)
1336         newTransaction();
1337 }
1338
1339 void TextEditor::repaintText (const Range<int>& range)
1340 {
1341     if (! range.isEmpty())
1342     {
1343         float x = 0, y = 0, lh = currentFont.getHeight();
1344
1345         const float wordWrapWidth = getWordWrapWidth();
1346
1347         if (wordWrapWidth > 0)
1348         {
1349             Iterator i (sections, wordWrapWidth, passwordCharacter);
1350
1351             i.getCharPosition (range.getStart(), x, y, lh);
1352
1353             const int y1 = (int) y;
1354             int y2;
1355
1356             if (range.getEnd() >= getTotalNumChars())
1357             {
1358                 y2 = textHolder->getHeight();
1359             }
1360             else
1361             {
1362                 i.getCharPosition (range.getEnd(), x, y, lh);
1363                 y2 = (int) (y + lh * 2.0f);
1364             }
1365
1366             textHolder->repaint (0, y1, textHolder->getWidth(), y2 - y1);
1367         }
1368     }
1369 }
1370
1371 //==============================================================================
1372 void TextEditor::moveCaret (int newCaretPos)
1373 {
1374     if (newCaretPos < 0)
1375         newCaretPos = 0;
1376     else if (newCaretPos > getTotalNumChars())
1377         newCaretPos = getTotalNumChars();
1378
1379     if (newCaretPos != getCaretPosition())
1380     {
1381         caretPosition = newCaretPos;
1382         textHolder->restartTimer();
1383         scrollToMakeSureCursorIsVisible();
1384         updateCaretPosition();
1385     }
1386 }
1387
1388 void TextEditor::setCaretPosition (const int newIndex)
1389 {
1390     moveCaretTo (newIndex, false);
1391 }
1392
1393 int TextEditor::getCaretPosition() const
1394 {
1395     return caretPosition;
1396 }
1397
1398 void TextEditor::scrollEditorToPositionCaret (const int desiredCaretX,
1399                                               const int desiredCaretY)
1400
1401 {
1402     updateCaretPosition();
1403
1404     const Rectangle<int> caretPos (getCaretRectangle());
1405
1406     int vx = caretPos.getX() - desiredCaretX;
1407     int vy = caretPos.getY() - desiredCaretY;
1408
1409     if (desiredCaretX < jmax (1, proportionOfWidth (0.05f)))
1410         vx += desiredCaretX - proportionOfWidth (0.2f);
1411     else if (desiredCaretX > jmax (0, viewport->getMaximumVisibleWidth() - (wordWrap ? 2 : 10)))
1412         vx += desiredCaretX + (isMultiLine() ? proportionOfWidth (0.2f) : 10) - viewport->getMaximumVisibleWidth();
1413
1414     vx = jlimit (0, jmax (0, textHolder->getWidth() + 8 - viewport->getMaximumVisibleWidth()), vx);
1415
1416     if (! isMultiLine())
1417     {
1418         vy = viewport->getViewPositionY();
1419     }
1420     else
1421     {
1422         vy = jlimit (0, jmax (0, textHolder->getHeight() - viewport->getMaximumVisibleHeight()), vy);
1423
1424         if (desiredCaretY < 0)
1425             vy = jmax (0, desiredCaretY + vy);
1426         else if (desiredCaretY > jmax (0, viewport->getMaximumVisibleHeight() - topIndent - caretPos.getHeight()))
1427             vy += desiredCaretY + 2 + caretPos.getHeight() + topIndent - viewport->getMaximumVisibleHeight();
1428     }
1429
1430     viewport->setViewPosition (vx, vy);
1431 }
1432
1433 const Rectangle<int> TextEditor::getCaretRectangle()
1434 {
1435     float cursorX, cursorY;
1436     float cursorHeight = currentFont.getHeight(); // (in case the text is empty and the call below doesn't set this value)
1437     getCharPosition (caretPosition, cursorX, cursorY, cursorHeight);
1438
1439     return Rectangle<int> (roundToInt (cursorX), roundToInt (cursorY), 2, roundToInt (cursorHeight));
1440 }
1441
1442 //==============================================================================
1443 float TextEditor::getWordWrapWidth() const
1444 {
1445     return wordWrap ? (float) (viewport->getMaximumVisibleWidth() - leftIndent - leftIndent / 2)
1446                     : std::numeric_limits<float>::max();
1447 }
1448
1449 void TextEditor::updateTextHolderSize()
1450 {
1451     const float wordWrapWidth = getWordWrapWidth();
1452
1453     if (wordWrapWidth > 0)
1454     {
1455         float maxWidth = 0.0f;
1456
1457         Iterator i (sections, wordWrapWidth, passwordCharacter);
1458
1459         while (i.next())
1460             maxWidth = jmax (maxWidth, i.atomRight);
1461
1462         const int w = leftIndent + roundToInt (maxWidth);
1463         const int h = topIndent + roundToInt (jmax (i.lineY + i.lineHeight,
1464                                                     currentFont.getHeight()));
1465
1466         textHolder->setSize (w + 2, h + 1); // (the +2 allows a bit of space for the cursor to be at the right-hand-edge)
1467     }
1468 }
1469
1470 int TextEditor::getTextWidth() const
1471 {
1472     return textHolder->getWidth();
1473 }
1474
1475 int TextEditor::getTextHeight() const
1476 {
1477     return textHolder->getHeight();
1478 }
1479
1480 void TextEditor::setIndents (const int newLeftIndent,
1481                              const int newTopIndent)
1482 {
1483     leftIndent = newLeftIndent;
1484     topIndent = newTopIndent;
1485 }
1486
1487 void TextEditor::setBorder (const BorderSize<int>& border)
1488 {
1489     borderSize = border;
1490     resized();
1491 }
1492
1493 const BorderSize<int> TextEditor::getBorder() const
1494 {
1495     return borderSize;
1496 }
1497
1498 void TextEditor::setScrollToShowCursor (const bool shouldScrollToShowCursor)
1499 {
1500     keepCaretOnScreen = shouldScrollToShowCursor;
1501 }
1502
1503 void TextEditor::scrollToMakeSureCursorIsVisible()
1504 {
1505     updateCaretPosition();
1506
1507     if (keepCaretOnScreen)
1508     {
1509         int x = viewport->getViewPositionX();
1510         int y = viewport->getViewPositionY();
1511
1512         const Rectangle<int> caretPos (getCaretRectangle());
1513
1514         const int relativeCursorX = caretPos.getX() - x;
1515         const int relativeCursorY = caretPos.getY() - y;
1516
1517         if (relativeCursorX < jmax (1, proportionOfWidth (0.05f)))
1518         {
1519             x += relativeCursorX - proportionOfWidth (0.2f);
1520         }
1521         else if (relativeCursorX > jmax (0, viewport->getMaximumVisibleWidth() - (wordWrap ? 2 : 10)))
1522         {
1523             x += relativeCursorX + (isMultiLine() ? proportionOfWidth (0.2f) : 10) - viewport->getMaximumVisibleWidth();
1524         }
1525
1526         x = jlimit (0, jmax (0, textHolder->getWidth() + 8 - viewport->getMaximumVisibleWidth()), x);
1527
1528         if (! isMultiLine())
1529         {
1530             y = (getHeight() - textHolder->getHeight() - topIndent) / -2;
1531         }
1532         else
1533         {
1534             if (relativeCursorY < 0)
1535             {
1536                 y = jmax (0, relativeCursorY + y);
1537             }
1538             else if (relativeCursorY > jmax (0, viewport->getMaximumVisibleHeight() - topIndent - caretPos.getHeight()))
1539             {
1540                 y += relativeCursorY + 2 + caretPos.getHeight() + topIndent - viewport->getMaximumVisibleHeight();
1541             }
1542         }
1543
1544         viewport->setViewPosition (x, y);
1545     }
1546 }
1547
1548 void TextEditor::moveCaretTo (const int newPosition,
1549                               const bool isSelecting)
1550 {
1551     if (isSelecting)
1552     {
1553         moveCaret (newPosition);
1554
1555         const Range<int> oldSelection (selection);
1556
1557         if (dragType == notDragging)
1558         {
1559             if (abs (getCaretPosition() - selection.getStart()) < abs (getCaretPosition() - selection.getEnd()))
1560                 dragType = draggingSelectionStart;
1561             else
1562                 dragType = draggingSelectionEnd;
1563         }
1564
1565         if (dragType == draggingSelectionStart)
1566         {
1567             if (getCaretPosition() >= selection.getEnd())
1568                 dragType = draggingSelectionEnd;
1569
1570             selection = Range<int>::between (getCaretPosition(), selection.getEnd());
1571         }
1572         else
1573         {
1574             if (getCaretPosition() < selection.getStart())
1575                 dragType = draggingSelectionStart;
1576
1577             selection = Range<int>::between (getCaretPosition(), selection.getStart());
1578         }
1579
1580         repaintText (selection.getUnionWith (oldSelection));
1581     }
1582     else
1583     {
1584         dragType = notDragging;
1585
1586         repaintText (selection);
1587
1588         moveCaret (newPosition);
1589         selection = Range<int>::emptyRange (getCaretPosition());
1590     }
1591 }
1592
1593 int TextEditor::getTextIndexAt (const int x,
1594                                 const int y)
1595 {
1596     return indexAtPosition ((float) (x + viewport->getViewPositionX() - leftIndent),
1597                             (float) (y + viewport->getViewPositionY() - topIndent));
1598 }
1599
1600 void TextEditor::insertTextAtCaret (const String& newText_)
1601 {
1602     String newText (newText_);
1603
1604     if (allowedCharacters.isNotEmpty())
1605         newText = newText.retainCharacters (allowedCharacters);
1606
1607     if (! isMultiLine())
1608         newText = newText.replaceCharacters ("\r\n", "  ");
1609     else
1610         newText = newText.replace ("\r\n", "\n");
1611
1612     const int newCaretPos = selection.getStart() + newText.length();
1613     const int insertIndex = selection.getStart();
1614
1615     remove (selection, getUndoManager(),
1616             newText.isNotEmpty() ? newCaretPos - 1 : newCaretPos);
1617
1618     if (maxTextLength > 0)
1619         newText = newText.substring (0, maxTextLength - getTotalNumChars());
1620
1621     if (newText.isNotEmpty())
1622         insert (newText,
1623                 insertIndex,
1624                 currentFont,
1625                 findColour (textColourId),
1626                 getUndoManager(),
1627                 newCaretPos);
1628
1629     textChanged();
1630 }
1631
1632 void TextEditor::setHighlightedRegion (const Range<int>& newSelection)
1633 {
1634     moveCaretTo (newSelection.getStart(), false);
1635     moveCaretTo (newSelection.getEnd(), true);
1636 }
1637
1638 //==============================================================================
1639 void TextEditor::copy()
1640 {
1641     if (passwordCharacter == 0)
1642     {
1643         const String selectedText (getHighlightedText());
1644
1645         if (selectedText.isNotEmpty())
1646             SystemClipboard::copyTextToClipboard (selectedText);
1647     }
1648 }
1649
1650 void TextEditor::paste()
1651 {
1652     if (! isReadOnly())
1653     {
1654         const String clip (SystemClipboard::getTextFromClipboard());
1655
1656         if (clip.isNotEmpty())
1657             insertTextAtCaret (clip);
1658     }
1659 }
1660
1661 void TextEditor::cut()
1662 {
1663     if (! isReadOnly())
1664     {
1665         moveCaret (selection.getEnd());
1666         insertTextAtCaret (String::empty);
1667     }
1668 }
1669
1670 //==============================================================================
1671 void TextEditor::drawContent (Graphics& g)
1672 {
1673     const float wordWrapWidth = getWordWrapWidth();
1674
1675     if (wordWrapWidth > 0)
1676     {
1677         g.setOrigin (leftIndent, topIndent);
1678         const Rectangle<int> clip (g.getClipBounds());
1679         Colour selectedTextColour;
1680
1681         Iterator i (sections, wordWrapWidth, passwordCharacter);
1682
1683         while (i.lineY + 200.0 < clip.getY() && i.next())
1684         {}
1685
1686         if (! selection.isEmpty())
1687         {
1688             g.setColour (findColour (highlightColourId).withMultipliedAlpha (hasKeyboardFocus (true) ? 1.0f : 0.5f));
1689
1690             selectedTextColour = findColour (highlightedTextColourId);
1691
1692             Iterator i2 (i);
1693
1694             while (i2.next() && i2.lineY < clip.getBottom())
1695             {
1696                 if (i2.lineY + i2.lineHeight >= clip.getY()
1697                      && selection.intersects (Range<int> (i2.indexInText, i2.indexInText + i2.atom->numChars)))
1698                 {
1699                     i2.drawSelection (g, selection);
1700                 }
1701             }
1702         }
1703
1704         const UniformTextSection* lastSection = nullptr;
1705
1706         while (i.next() && i.lineY < clip.getBottom())
1707         {
1708             if (i.lineY + i.lineHeight >= clip.getY())
1709             {
1710                 if (selection.intersects (Range<int> (i.indexInText, i.indexInText + i.atom->numChars)))
1711                 {
1712                     i.drawSelectedText (g, selection, selectedTextColour);
1713                     lastSection = nullptr;
1714                 }
1715                 else
1716                 {
1717                     i.draw (g, lastSection);
1718                 }
1719             }
1720         }
1721
1722         for (int j = underlinedSections.size(); --j >= 0;)
1723         {
1724             const Range<int>& underlinedSection = underlinedSections.getReference (j);
1725
1726             Iterator i2 (sections, wordWrapWidth, passwordCharacter);
1727
1728             while (i2.next() && i2.lineY < clip.getBottom())
1729             {
1730                 if (i2.lineY + i2.lineHeight >= clip.getY()
1731                      && underlinedSection.intersects (Range<int> (i2.indexInText, i2.indexInText + i2.atom->numChars)))
1732                 {
1733                     i2.drawUnderline (g, underlinedSection, findColour (textColourId));
1734                 }
1735             }
1736         }
1737     }
1738 }
1739
1740 void TextEditor::paint (Graphics& g)
1741 {
1742     getLookAndFeel().fillTextEditorBackground (g, getWidth(), getHeight(), *this);
1743 }
1744
1745 void TextEditor::paintOverChildren (Graphics& g)
1746 {
1747     if (textToShowWhenEmpty.isNotEmpty()
1748          && (! hasKeyboardFocus (false))
1749          && getTotalNumChars() == 0)
1750     {
1751         g.setColour (colourForTextWhenEmpty);
1752         g.setFont (getFont());
1753
1754         if (isMultiLine())
1755         {
1756             g.drawText (textToShowWhenEmpty,
1757                         0, 0, getWidth(), getHeight(),
1758                         Justification::centred, true);
1759         }
1760         else
1761         {
1762             g.drawText (textToShowWhenEmpty,
1763                         leftIndent, topIndent,
1764                         viewport->getWidth() - leftIndent,
1765                         viewport->getHeight() - topIndent,
1766                         Justification::centredLeft, true);
1767         }
1768     }
1769
1770     getLookAndFeel().drawTextEditorOutline (g, getWidth(), getHeight(), *this);
1771 }
1772
1773 //==============================================================================
1774 static void textEditorMenuCallback (int menuResult, TextEditor* editor)
1775 {
1776     if (editor != nullptr && menuResult != 0)
1777         editor->performPopupMenuAction (menuResult);
1778 }
1779
1780 void TextEditor::mouseDown (const MouseEvent& e)
1781 {
1782     beginDragAutoRepeat (100);
1783     newTransaction();
1784
1785     if (wasFocused || ! selectAllTextWhenFocused)
1786     {
1787         if (! (popupMenuEnabled && e.mods.isPopupMenu()))
1788         {
1789             moveCaretTo (getTextIndexAt (e.x, e.y),
1790                          e.mods.isShiftDown());
1791         }
1792         else
1793         {
1794             PopupMenu m;
1795             m.setLookAndFeel (&getLookAndFeel());
1796             addPopupMenuItems (m, &e);
1797
1798             m.showMenuAsync (PopupMenu::Options(),
1799                              ModalCallbackFunction::forComponent (textEditorMenuCallback, this));
1800         }
1801     }
1802 }
1803
1804 void TextEditor::mouseDrag (const MouseEvent& e)
1805 {
1806     if (wasFocused || ! selectAllTextWhenFocused)
1807     {
1808         if (! (popupMenuEnabled && e.mods.isPopupMenu()))
1809         {
1810             moveCaretTo (getTextIndexAt (e.x, e.y), true);
1811         }
1812     }
1813 }
1814
1815 void TextEditor::mouseUp (const MouseEvent& e)
1816 {
1817     newTransaction();
1818     textHolder->restartTimer();
1819
1820     if (wasFocused || ! selectAllTextWhenFocused)
1821     {
1822         if (e.mouseWasClicked() && ! (popupMenuEnabled && e.mods.isPopupMenu()))
1823         {
1824             moveCaret (getTextIndexAt (e.x, e.y));
1825         }
1826     }
1827
1828     wasFocused = true;
1829 }
1830
1831 void TextEditor::mouseDoubleClick (const MouseEvent& e)
1832 {
1833     int tokenEnd = getTextIndexAt (e.x, e.y);
1834     int tokenStart = tokenEnd;
1835
1836     if (e.getNumberOfClicks() > 3)
1837     {
1838         tokenStart = 0;
1839         tokenEnd = getTotalNumChars();
1840     }
1841     else
1842     {
1843         const String t (getText());
1844         const int totalLength = getTotalNumChars();
1845
1846         while (tokenEnd < totalLength)
1847         {
1848             // (note the slight bodge here - it's because iswalnum only checks for alphabetic chars in the current locale)
1849             const juce_wchar c = t [tokenEnd];
1850             if (CharacterFunctions::isLetterOrDigit (c) || c > 128)
1851                 ++tokenEnd;
1852             else
1853                 break;
1854         }
1855
1856         tokenStart = tokenEnd;
1857
1858         while (tokenStart > 0)
1859         {
1860             // (note the slight bodge here - it's because iswalnum only checks for alphabetic chars in the current locale)
1861             const juce_wchar c = t [tokenStart - 1];
1862             if (CharacterFunctions::isLetterOrDigit (c) || c > 128)
1863                 --tokenStart;
1864             else
1865                 break;
1866         }
1867
1868         if (e.getNumberOfClicks() > 2)
1869         {
1870             while (tokenEnd < totalLength)
1871             {
1872                 const juce_wchar c = t [tokenEnd];
1873                 if (c != '\r' && c != '\n')
1874                     ++tokenEnd;
1875                 else
1876                     break;
1877             }
1878
1879             while (tokenStart > 0)
1880             {
1881                 const juce_wchar c = t [tokenStart - 1];
1882                 if (c != '\r' && c != '\n')
1883                     --tokenStart;
1884                 else
1885                     break;
1886             }
1887         }
1888     }
1889
1890     moveCaretTo (tokenEnd, false);
1891     moveCaretTo (tokenStart, true);
1892 }
1893
1894 void TextEditor::mouseWheelMove (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
1895 {
1896     if (! viewport->useMouseWheelMoveIfNeeded (e, wheelIncrementX, wheelIncrementY))
1897         Component::mouseWheelMove (e, wheelIncrementX, wheelIncrementY);
1898 }
1899
1900 //==============================================================================
1901 bool TextEditor::moveCaretWithTransation (const int newPos, const bool selecting)
1902 {
1903     newTransaction();
1904     moveCaretTo (newPos, selecting);
1905     return true;
1906 }
1907
1908 bool TextEditor::moveCaretLeft (bool moveInWholeWordSteps, bool selecting)
1909 {
1910     int pos = getCaretPosition();
1911
1912     if (moveInWholeWordSteps)
1913         pos = findWordBreakBefore (pos);
1914     else
1915         --pos;
1916
1917     return moveCaretWithTransation (pos, selecting);
1918 }
1919
1920 bool TextEditor::moveCaretRight (bool moveInWholeWordSteps, bool selecting)
1921 {
1922     int pos = getCaretPosition();
1923
1924     if (moveInWholeWordSteps)
1925         pos = findWordBreakAfter (pos);
1926     else
1927         ++pos;
1928
1929     return moveCaretWithTransation (pos, selecting);
1930 }
1931
1932 bool TextEditor::moveCaretUp (bool selecting)
1933 {
1934     if (! isMultiLine())
1935         return moveCaretToStartOfLine (selecting);
1936
1937     const Rectangle<float> caretPos (getCaretRectangle().toFloat());
1938     return moveCaretWithTransation (indexAtPosition (caretPos.getX(), caretPos.getY() - 1.0f), selecting);
1939 }
1940
1941 bool TextEditor::moveCaretDown (bool selecting)
1942 {
1943     if (! isMultiLine())
1944         return moveCaretToEndOfLine (selecting);
1945
1946     const Rectangle<float> caretPos (getCaretRectangle().toFloat());
1947     return moveCaretWithTransation (indexAtPosition (caretPos.getX(), caretPos.getBottom() + 1.0f), selecting);
1948 }
1949
1950 bool TextEditor::pageUp (bool selecting)
1951 {
1952     if (! isMultiLine())
1953         return moveCaretToStartOfLine (selecting);
1954
1955     const Rectangle<float> caretPos (getCaretRectangle().toFloat());
1956     return moveCaretWithTransation (indexAtPosition (caretPos.getX(), caretPos.getY() - viewport->getViewHeight()), selecting);
1957 }
1958
1959 bool TextEditor::pageDown (bool selecting)
1960 {
1961     if (! isMultiLine())
1962         return moveCaretToEndOfLine (selecting);
1963
1964     const Rectangle<float> caretPos (getCaretRectangle().toFloat());
1965     return moveCaretWithTransation (indexAtPosition (caretPos.getX(), caretPos.getBottom() + viewport->getViewHeight()), selecting);
1966 }
1967
1968 void TextEditor::scrollByLines (int deltaLines)
1969 {
1970     ScrollBar* scrollbar = viewport->getVerticalScrollBar();
1971
1972     if (scrollbar != nullptr)
1973         scrollbar->moveScrollbarInSteps (deltaLines);
1974 }
1975
1976 bool TextEditor::scrollDown()
1977 {
1978     scrollByLines (-1);
1979     return true;
1980 }
1981
1982 bool TextEditor::scrollUp()
1983 {
1984     scrollByLines (1);
1985     return true;
1986 }
1987
1988 bool TextEditor::moveCaretToTop (bool selecting)
1989 {
1990     return moveCaretWithTransation (0, selecting);
1991 }
1992
1993 bool TextEditor::moveCaretToStartOfLine (bool selecting)
1994 {
1995     const Rectangle<float> caretPos (getCaretRectangle().toFloat());
1996     return moveCaretWithTransation (indexAtPosition (0.0f, caretPos.getY()), selecting);
1997 }
1998
1999 bool TextEditor::moveCaretToEnd (bool selecting)
2000 {
2001     return moveCaretWithTransation (getTotalNumChars(), selecting);
2002 }
2003
2004 bool TextEditor::moveCaretToEndOfLine (bool selecting)
2005 {
2006     const Rectangle<float> caretPos (getCaretRectangle().toFloat());
2007     return moveCaretWithTransation (indexAtPosition ((float) textHolder->getWidth(), caretPos.getY()), selecting);
2008 }
2009
2010 bool TextEditor::deleteBackwards (bool moveInWholeWordSteps)
2011 {
2012     if (moveInWholeWordSteps)
2013         moveCaretTo (findWordBreakBefore (getCaretPosition()), true);
2014     else if (selection.isEmpty() && selection.getStart() > 0)
2015         selection.setStart (selection.getEnd() - 1);
2016
2017     cut();
2018     return true;
2019 }
2020
2021 bool TextEditor::deleteForwards (bool /*moveInWholeWordSteps*/)
2022 {
2023     if (selection.isEmpty() && selection.getStart() < getTotalNumChars())
2024         selection.setEnd (selection.getStart() + 1);
2025
2026     cut();
2027     return true;
2028 }
2029
2030 bool TextEditor::copyToClipboard()
2031 {
2032     newTransaction();
2033     copy();
2034     return true;
2035 }
2036
2037 bool TextEditor::cutToClipboard()
2038 {
2039     newTransaction();
2040     copy();
2041     cut();
2042     return true;
2043 }
2044
2045 bool TextEditor::pasteFromClipboard()
2046 {
2047     newTransaction();
2048     paste();
2049     return true;
2050 }
2051
2052 bool TextEditor::selectAll()
2053 {
2054     newTransaction();
2055     moveCaretTo (getTotalNumChars(), false);
2056     moveCaretTo (0, true);
2057     return true;
2058 }
2059
2060 //==============================================================================
2061 bool TextEditor::keyPressed (const KeyPress& key)
2062 {
2063     if (isReadOnly() && key != KeyPress ('c', ModifierKeys::commandModifier, 0))
2064         return false;
2065
2066     if (! TextEditorKeyMapper<TextEditor>::invokeKeyFunction (*this, key))
2067     {
2068         if (key == KeyPress::returnKey)
2069         {
2070             newTransaction();
2071
2072             if (returnKeyStartsNewLine)
2073                 insertTextAtCaret ("\n");
2074             else
2075                 returnPressed();
2076         }
2077         else if (key.isKeyCode (KeyPress::escapeKey))
2078         {
2079             newTransaction();
2080             moveCaretTo (getCaretPosition(), false);
2081             escapePressed();
2082         }
2083         else if (key.getTextCharacter() >= ' '
2084                   || (tabKeyUsed && (key.getTextCharacter() == '\t')))
2085         {
2086             insertTextAtCaret (String::charToString (key.getTextCharacter()));
2087
2088             lastTransactionTime = Time::getApproximateMillisecondCounter();
2089         }
2090         else
2091         {
2092             return false;
2093         }
2094     }
2095
2096     return true;
2097 }
2098
2099 bool TextEditor::keyStateChanged (const bool isKeyDown)
2100 {
2101     if (! isKeyDown)
2102         return false;
2103
2104    #if JUCE_WINDOWS
2105     if (KeyPress (KeyPress::F4Key, ModifierKeys::altModifier, 0).isCurrentlyDown())
2106         return false;  // We need to explicitly allow alt-F4 to pass through on Windows
2107    #endif
2108
2109     // (overridden to avoid forwarding key events to the parent)
2110     return ! ModifierKeys::getCurrentModifiers().isCommandDown();
2111 }
2112
2113 //==============================================================================
2114 const int baseMenuItemID = 0x7fff0000;
2115
2116 void TextEditor::addPopupMenuItems (PopupMenu& m, const MouseEvent*)
2117 {
2118     const bool writable = ! isReadOnly();
2119
2120     if (passwordCharacter == 0)
2121     {
2122         m.addItem (baseMenuItemID + 1, TRANS("cut"), writable);
2123         m.addItem (baseMenuItemID + 2, TRANS("copy"), ! selection.isEmpty());
2124         m.addItem (baseMenuItemID + 3, TRANS("paste"), writable);
2125     }
2126
2127     m.addItem (baseMenuItemID + 4, TRANS("delete"), writable);
2128     m.addSeparator();
2129     m.addItem (baseMenuItemID + 5, TRANS("select all"));
2130     m.addSeparator();
2131
2132     if (getUndoManager() != nullptr)
2133     {
2134         m.addItem (baseMenuItemID + 6, TRANS("undo"), undoManager.canUndo());
2135         m.addItem (baseMenuItemID + 7, TRANS("redo"), undoManager.canRedo());
2136     }
2137 }
2138
2139 void TextEditor::performPopupMenuAction (const int menuItemID)
2140 {
2141     switch (menuItemID)
2142     {
2143         case baseMenuItemID + 1:    cutToClipboard(); break;
2144         case baseMenuItemID + 2:    copyToClipboard(); break;
2145         case baseMenuItemID + 3:    pasteFromClipboard(); break;
2146         case baseMenuItemID + 4:    cut(); break;
2147         case baseMenuItemID + 5:    selectAll(); break;
2148         case baseMenuItemID + 6:    undo(); break;
2149         case baseMenuItemID + 7:    redo(); break;
2150         default: break;
2151     }
2152 }
2153
2154 //==============================================================================
2155 void TextEditor::focusGained (FocusChangeType)
2156 {
2157     newTransaction();
2158
2159     if (selectAllTextWhenFocused)
2160     {
2161         moveCaretTo (0, false);
2162         moveCaretTo (getTotalNumChars(), true);
2163     }
2164
2165     repaint();
2166     updateCaretPosition();
2167
2168     ComponentPeer* const peer = getPeer();
2169     if (peer != nullptr && ! isReadOnly())
2170         peer->textInputRequired (getScreenPosition() - peer->getScreenPosition());
2171 }
2172
2173 void TextEditor::focusLost (FocusChangeType)
2174 {
2175     newTransaction();
2176
2177     wasFocused = false;
2178     textHolder->stopTimer();
2179
2180     underlinedSections.clear();
2181
2182     ComponentPeer* const peer = getPeer();
2183     if (peer != nullptr)
2184         peer->dismissPendingTextInput();
2185
2186     updateCaretPosition();
2187
2188     postCommandMessage (TextEditorDefs::focusLossMessageId);
2189     repaint();
2190 }
2191
2192 //==============================================================================
2193 void TextEditor::resized()
2194 {
2195     viewport->setBoundsInset (borderSize);
2196     viewport->setSingleStepSizes (16, roundToInt (currentFont.getHeight()));
2197
2198     updateTextHolderSize();
2199
2200     if (! isMultiLine())
2201     {
2202         scrollToMakeSureCursorIsVisible();
2203     }
2204     else
2205     {
2206         updateCaretPosition();
2207     }
2208 }
2209
2210 void TextEditor::handleCommandMessage (const int commandId)
2211 {
2212     Component::BailOutChecker checker (this);
2213
2214     switch (commandId)
2215     {
2216     case TextEditorDefs::textChangeMessageId:
2217         listeners.callChecked (checker, &TextEditorListener::textEditorTextChanged, (TextEditor&) *this);
2218         break;
2219
2220     case TextEditorDefs::returnKeyMessageId:
2221         listeners.callChecked (checker, &TextEditorListener::textEditorReturnKeyPressed, (TextEditor&) *this);
2222         break;
2223
2224     case TextEditorDefs::escapeKeyMessageId:
2225         listeners.callChecked (checker, &TextEditorListener::textEditorEscapeKeyPressed, (TextEditor&) *this);
2226         break;
2227
2228     case TextEditorDefs::focusLossMessageId:
2229         updateValueFromText();
2230         listeners.callChecked (checker, &TextEditorListener::textEditorFocusLost, (TextEditor&) *this);
2231         break;
2232
2233     default:
2234         jassertfalse;
2235         break;
2236     }
2237 }
2238
2239 void TextEditor::enablementChanged()
2240 {
2241     setMouseCursor (isReadOnly() ? MouseCursor::NormalCursor
2242                                  : MouseCursor::IBeamCursor);
2243     repaint();
2244 }
2245
2246 void TextEditor::setTemporaryUnderlining (const Array <Range<int> >& newUnderlinedSections)
2247 {
2248     underlinedSections = newUnderlinedSections;
2249     repaint();
2250 }
2251
2252 //==============================================================================
2253 UndoManager* TextEditor::getUndoManager() noexcept
2254 {
2255     return isReadOnly() ? 0 : &undoManager;
2256 }
2257
2258 void TextEditor::clearInternal (UndoManager* const um)
2259 {
2260     remove (Range<int> (0, getTotalNumChars()), um, caretPosition);
2261 }
2262
2263 void TextEditor::insert (const String& text,
2264                          const int insertIndex,
2265                          const Font& font,
2266                          const Colour& colour,
2267                          UndoManager* const um,
2268                          const int caretPositionToMoveTo)
2269 {
2270     if (text.isNotEmpty())
2271     {
2272         if (um != nullptr)
2273         {
2274             if (um->getNumActionsInCurrentTransaction() > TextEditorDefs::maxActionsPerTransaction)
2275                 newTransaction();
2276
2277             um->perform (new InsertAction (*this, text, insertIndex, font, colour,
2278                                            caretPosition, caretPositionToMoveTo));
2279         }
2280         else
2281         {
2282             repaintText (Range<int> (insertIndex, getTotalNumChars())); // must do this before and after changing the data, in case
2283                                                                         // a line gets moved due to word wrap
2284
2285             int index = 0;
2286             int nextIndex = 0;
2287
2288             for (int i = 0; i < sections.size(); ++i)
2289             {
2290                 nextIndex = index + sections.getUnchecked (i)->getTotalLength();
2291
2292                 if (insertIndex == index)
2293                 {
2294                     sections.insert (i, new UniformTextSection (text,
2295                                                                 font, colour,
2296                                                                 passwordCharacter));
2297                     break;
2298                 }
2299                 else if (insertIndex > index && insertIndex < nextIndex)
2300                 {
2301                     splitSection (i, insertIndex - index);
2302                     sections.insert (i + 1, new UniformTextSection (text,
2303                                                                     font, colour,
2304                                                                     passwordCharacter));
2305                     break;
2306                 }
2307
2308                 index = nextIndex;
2309             }
2310
2311             if (nextIndex == insertIndex)
2312                 sections.add (new UniformTextSection (text,
2313                                                       font, colour,
2314                                                       passwordCharacter));
2315
2316             coalesceSimilarSections();
2317             totalNumChars = -1;
2318             valueTextNeedsUpdating = true;
2319
2320             updateTextHolderSize();
2321             moveCaretTo (caretPositionToMoveTo, false);
2322
2323             repaintText (Range<int> (insertIndex, getTotalNumChars()));
2324         }
2325     }
2326 }
2327
2328 void TextEditor::reinsert (const int insertIndex,
2329                            const Array <UniformTextSection*>& sectionsToInsert)
2330 {
2331     int index = 0;
2332     int nextIndex = 0;
2333
2334     for (int i = 0; i < sections.size(); ++i)
2335     {
2336         nextIndex = index + sections.getUnchecked (i)->getTotalLength();
2337
2338         if (insertIndex == index)
2339         {
2340             for (int j = sectionsToInsert.size(); --j >= 0;)
2341                 sections.insert (i, new UniformTextSection (*sectionsToInsert.getUnchecked(j)));
2342
2343             break;
2344         }
2345         else if (insertIndex > index && insertIndex < nextIndex)
2346         {
2347             splitSection (i, insertIndex - index);
2348
2349             for (int j = sectionsToInsert.size(); --j >= 0;)
2350                 sections.insert (i + 1, new UniformTextSection (*sectionsToInsert.getUnchecked(j)));
2351
2352             break;
2353         }
2354
2355         index = nextIndex;
2356     }
2357
2358     if (nextIndex == insertIndex)
2359     {
2360         for (int j = 0; j < sectionsToInsert.size(); ++j)
2361             sections.add (new UniformTextSection (*sectionsToInsert.getUnchecked(j)));
2362     }
2363
2364     coalesceSimilarSections();
2365     totalNumChars = -1;
2366     valueTextNeedsUpdating = true;
2367 }
2368
2369 void TextEditor::remove (const Range<int>& range,
2370                          UndoManager* const um,
2371                          const int caretPositionToMoveTo)
2372 {
2373     if (! range.isEmpty())
2374     {
2375         int index = 0;
2376
2377         for (int i = 0; i < sections.size(); ++i)
2378         {
2379             const int nextIndex = index + sections.getUnchecked(i)->getTotalLength();
2380
2381             if (range.getStart() > index && range.getStart() < nextIndex)
2382             {
2383                 splitSection (i, range.getStart() - index);
2384                 --i;
2385             }
2386             else if (range.getEnd() > index && range.getEnd() < nextIndex)
2387             {
2388                 splitSection (i, range.getEnd() - index);
2389                 --i;
2390             }
2391             else
2392             {
2393                 index = nextIndex;
2394
2395                 if (index > range.getEnd())
2396                     break;
2397             }
2398         }
2399
2400         index = 0;
2401
2402         if (um != nullptr)
2403         {
2404             Array <UniformTextSection*> removedSections;
2405
2406             for (int i = 0; i < sections.size(); ++i)
2407             {
2408                 if (range.getEnd() <= range.getStart())
2409                     break;
2410
2411                 UniformTextSection* const section = sections.getUnchecked (i);
2412
2413                 const int nextIndex = index + section->getTotalLength();
2414
2415                 if (range.getStart() <= index && range.getEnd() >= nextIndex)
2416                     removedSections.add (new UniformTextSection (*section));
2417
2418                 index = nextIndex;
2419             }
2420
2421             if (um->getNumActionsInCurrentTransaction() > TextEditorDefs::maxActionsPerTransaction)
2422                 newTransaction();
2423
2424             um->perform (new RemoveAction (*this, range, caretPosition,
2425                                            caretPositionToMoveTo, removedSections));
2426         }
2427         else
2428         {
2429             Range<int> remainingRange (range);
2430
2431             for (int i = 0; i < sections.size(); ++i)
2432             {
2433                 UniformTextSection* const section = sections.getUnchecked (i);
2434
2435                 const int nextIndex = index + section->getTotalLength();
2436
2437                 if (remainingRange.getStart() <= index && remainingRange.getEnd() >= nextIndex)
2438                 {
2439                     sections.remove(i);
2440                     section->clear();
2441                     delete section;
2442
2443                     remainingRange.setEnd (remainingRange.getEnd() - (nextIndex - index));
2444                     if (remainingRange.isEmpty())
2445                         break;
2446
2447                     --i;
2448                 }
2449                 else
2450                 {
2451                     index = nextIndex;
2452                 }
2453             }
2454
2455             coalesceSimilarSections();
2456             totalNumChars = -1;
2457             valueTextNeedsUpdating = true;
2458
2459             moveCaretTo (caretPositionToMoveTo, false);
2460
2461             repaintText (Range<int> (range.getStart(), getTotalNumChars()));
2462         }
2463     }
2464 }
2465
2466 //==============================================================================
2467 String TextEditor::getText() const
2468 {
2469     MemoryOutputStream mo;
2470     mo.preallocate (getTotalNumChars());
2471
2472     for (int i = 0; i < sections.size(); ++i)
2473         sections.getUnchecked (i)->appendAllText (mo);
2474
2475     return mo.toString();
2476 }
2477
2478 const String TextEditor::getTextInRange (const Range<int>& range) const
2479 {
2480     if (range.isEmpty())
2481         return String::empty;
2482
2483     MemoryOutputStream mo;
2484     mo.preallocate (jmin (getTotalNumChars(), range.getLength()));
2485
2486     int index = 0;
2487
2488     for (int i = 0; i < sections.size(); ++i)
2489     {
2490         const UniformTextSection* const s = sections.getUnchecked (i);
2491         const int nextIndex = index + s->getTotalLength();
2492
2493         if (range.getStart() < nextIndex)
2494         {
2495             if (range.getEnd() <= index)
2496                 break;
2497
2498             s->appendSubstring (mo, range - index);
2499         }
2500
2501         index = nextIndex;
2502     }
2503
2504     return mo.toString();
2505 }
2506
2507 String TextEditor::getHighlightedText() const
2508 {
2509     return getTextInRange (selection);
2510 }
2511
2512 int TextEditor::getTotalNumChars() const
2513 {
2514     if (totalNumChars < 0)
2515     {
2516         totalNumChars = 0;
2517
2518         for (int i = sections.size(); --i >= 0;)
2519             totalNumChars += sections.getUnchecked (i)->getTotalLength();
2520     }
2521
2522     return totalNumChars;
2523 }
2524
2525 bool TextEditor::isEmpty() const
2526 {
2527     return getTotalNumChars() == 0;
2528 }
2529
2530 void TextEditor::getCharPosition (const int index, float& cx, float& cy, float& lineHeight) const
2531 {
2532     const float wordWrapWidth = getWordWrapWidth();
2533
2534     if (wordWrapWidth > 0 && sections.size() > 0)
2535     {
2536         Iterator i (sections, wordWrapWidth, passwordCharacter);
2537
2538         i.getCharPosition (index, cx, cy, lineHeight);
2539     }
2540     else
2541     {
2542         cx = cy = 0;
2543         lineHeight = currentFont.getHeight();
2544     }
2545 }
2546
2547 int TextEditor::indexAtPosition (const float x, const float y)
2548 {
2549     const float wordWrapWidth = getWordWrapWidth();
2550
2551     if (wordWrapWidth > 0)
2552     {
2553         Iterator i (sections, wordWrapWidth, passwordCharacter);
2554
2555         while (i.next())
2556         {
2557             if (i.lineY + i.lineHeight > y)
2558             {
2559                 if (i.lineY > y)
2560                     return jmax (0, i.indexInText - 1);
2561
2562                 if (i.atomX >= x)
2563                     return i.indexInText;
2564
2565                 if (x < i.atomRight)
2566                     return i.xToIndex (x);
2567             }
2568         }
2569     }
2570
2571     return getTotalNumChars();
2572 }
2573
2574 //==============================================================================
2575 int TextEditor::findWordBreakAfter (const int position) const
2576 {
2577     const String t (getTextInRange (Range<int> (position, position + 512)));
2578     const int totalLength = t.length();
2579     int i = 0;
2580
2581     while (i < totalLength && CharacterFunctions::isWhitespace (t[i]))
2582         ++i;
2583
2584     const int type = TextEditorDefs::getCharacterCategory (t[i]);
2585
2586     while (i < totalLength && type == TextEditorDefs::getCharacterCategory (t[i]))
2587         ++i;
2588
2589     while (i < totalLength && CharacterFunctions::isWhitespace (t[i]))
2590         ++i;
2591
2592     return position + i;
2593 }
2594
2595 int TextEditor::findWordBreakBefore (const int position) const
2596 {
2597     if (position <= 0)
2598         return 0;
2599
2600     const int startOfBuffer = jmax (0, position - 512);
2601     const String t (getTextInRange (Range<int> (startOfBuffer, position)));
2602
2603     int i = position - startOfBuffer;
2604
2605     while (i > 0 && CharacterFunctions::isWhitespace (t [i - 1]))
2606         --i;
2607
2608     if (i > 0)
2609     {
2610         const int type = TextEditorDefs::getCharacterCategory (t [i - 1]);
2611
2612         while (i > 0 && type == TextEditorDefs::getCharacterCategory (t [i - 1]))
2613             --i;
2614     }
2615
2616     jassert (startOfBuffer + i >= 0);
2617     return startOfBuffer + i;
2618 }
2619
2620
2621 //==============================================================================
2622 void TextEditor::splitSection (const int sectionIndex,
2623                                const int charToSplitAt)
2624 {
2625     jassert (sections[sectionIndex] != nullptr);
2626
2627     sections.insert (sectionIndex + 1,
2628                      sections.getUnchecked (sectionIndex)->split (charToSplitAt, passwordCharacter));
2629 }
2630
2631 void TextEditor::coalesceSimilarSections()
2632 {
2633     for (int i = 0; i < sections.size() - 1; ++i)
2634     {
2635         UniformTextSection* const s1 = sections.getUnchecked (i);
2636         UniformTextSection* const s2 = sections.getUnchecked (i + 1);
2637
2638         if (s1->font == s2->font
2639              && s1->colour == s2->colour)
2640         {
2641             s1->append (*s2, passwordCharacter);
2642             sections.remove (i + 1);
2643             delete s2;
2644             --i;
2645         }
2646     }
2647 }
2648
2649 void TextEditor::Listener::textEditorTextChanged (TextEditor&) {}
2650 void TextEditor::Listener::textEditorReturnKeyPressed (TextEditor&) {}
2651 void TextEditor::Listener::textEditorEscapeKeyPressed (TextEditor&) {}
2652 void TextEditor::Listener::textEditorFocusLost (TextEditor&) {}
2653
2654 END_JUCE_NAMESPACE