mirrors/OB-Xd
2
0
Fork 0
Code Activity
OB-Xd/Modules/gin/components/singlelinetexteditor.cpp

2215 lines
65 KiB
C++
Raw Normal View History

Added gin module
2020-05-21 07:14:57 +00:00
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2015 - ROLI Ltd.
Permission is granted to use this software under the terms of either:
a) the GPL v2 (or any later version)
b) the Affero GPL v3
Details of these licenses can be found at: www.gnu.org/licenses
JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
------------------------------------------------------------------------------
To release a closed-source product which uses JUCE, commercial licenses are
available: visit www.juce.com for more information.
==============================================================================
*/
#include "singlelinetexteditor.h"
// a word or space that can't be broken down any further
struct TextAtom
{
//==============================================================================
String atomText;
float width;
int numChars;
//==============================================================================
bool isWhitespace() const noexcept { return CharacterFunctions::isWhitespace (atomText[0]); }
bool isNewLine() const noexcept { return atomText[0] == '\r' || atomText[0] == '\n'; }
String getText () const
{
return atomText;
}
String getTrimmedText () const
{
return atomText.substring (0, numChars);
}
JUCE_LEAK_DETECTOR (TextAtom)
};
//==============================================================================
// a run of text with a single font and colour
class SingleLineTextEditor::UniformTextSection
{
public:
UniformTextSection (const String& text, const Font& f, Colour col)
: font (f), colour (col)
{
initialiseAtoms (text);
}
UniformTextSection (const UniformTextSection& other)
: font (other.font), colour (other.colour)
{
atoms.addCopiesOf (other.atoms);
}
void append (UniformTextSection& other)
{
if (other.atoms.size() > 0)
{
int i = 0;
if (TextAtom* const lastAtom = atoms.getLast())
{
if (! CharacterFunctions::isWhitespace (lastAtom->atomText.getLastCharacter()))
{
TextAtom* const first = other.atoms.getUnchecked(0);
if (! CharacterFunctions::isWhitespace (first->atomText[0]))
{
lastAtom->atomText += first->atomText;
lastAtom->numChars = (uint16) (lastAtom->numChars + first->numChars);
lastAtom->width = font.getStringWidthFloat (lastAtom->getText());
delete first;
++i;
}
}
}
atoms.ensureStorageAllocated (atoms.size() + other.atoms.size() - i);
while (i < other.atoms.size())
{
atoms.add (other.atoms.getUnchecked(i));
++i;
}
other.atoms.clear (false);
}
}
UniformTextSection* split (const int indexToBreakAt)
{
UniformTextSection* const section2 = new UniformTextSection (String(), font, colour);
int index = 0;
for (int i = 0; i < atoms.size(); ++i)
{
TextAtom* const atom = atoms.getUnchecked(i);
const int nextIndex = index + atom->numChars;
if (index == indexToBreakAt)
{
for (int j = i; j < atoms.size(); ++j)
section2->atoms.add (atoms.getUnchecked (j));
atoms.removeRange (i, atoms.size(), false);
break;
}
else if (indexToBreakAt >= index && indexToBreakAt < nextIndex)
{
TextAtom* const secondAtom = new TextAtom();
secondAtom->atomText = atom->atomText.substring (indexToBreakAt - index);
secondAtom->width = font.getStringWidthFloat (secondAtom->getText());
secondAtom->numChars = (uint16) secondAtom->atomText.length();
section2->atoms.add (secondAtom);
atom->atomText = atom->atomText.substring (0, indexToBreakAt - index);
atom->width = font.getStringWidthFloat (atom->getText());
atom->numChars = (uint16) (indexToBreakAt - index);
for (int j = i + 1; j < atoms.size(); ++j)
section2->atoms.add (atoms.getUnchecked (j));
atoms.removeRange (i + 1, atoms.size(), false);
break;
}
index = nextIndex;
}
return section2;
}
void appendAllText (MemoryOutputStream& mo) const
{
for (int i = 0; i < atoms.size(); ++i)
mo << atoms.getUnchecked(i)->atomText;
}
void appendSubstring (MemoryOutputStream& mo, const Range<int> range) const
{
int index = 0;
for (int i = 0; i < atoms.size(); ++i)
{
const TextAtom* const atom = atoms.getUnchecked (i);
const int nextIndex = index + atom->numChars;
if (range.getStart() < nextIndex)
{
if (range.getEnd() <= index)
break;
const Range<int> r ((range - index).getIntersectionWith (Range<int> (0, (int) atom->numChars)));
if (! r.isEmpty())
mo << atom->atomText.substring (r.getStart(), r.getEnd());
}
index = nextIndex;
}
}
int getTotalLength() const noexcept
{
int total = 0;
for (int i = atoms.size(); --i >= 0;)
total += atoms.getUnchecked(i)->numChars;
return total;
}
void setFont (const Font& newFont)
{
if (font != newFont)
{
font = newFont;
for (int i = atoms.size(); --i >= 0;)
{
TextAtom* const atom = atoms.getUnchecked(i);
atom->width = newFont.getStringWidthFloat (atom->getText());
}
}
}
//==============================================================================
Font font;
Colour colour;
OwnedArray<TextAtom> atoms;
private:
void initialiseAtoms (const String& textToParse)
{
String::CharPointerType text (textToParse.getCharPointer());
while (! text.isEmpty())
{
size_t numChars = 0;
String::CharPointerType start (text);
// create a whitespace atom unless it starts with non-ws
if (text.isWhitespace() && *text != '\r' && *text != '\n')
{
do
{
++text;
++numChars;
}
while (text.isWhitespace() && *text != '\r' && *text != '\n');
}
else
{
if (*text == '\r')
{
++text;
++numChars;
if (*text == '\n')
{
++start;
++text;
}
}
else if (*text == '\n')
{
++text;
++numChars;
}
else
{
while (! (text.isEmpty() || text.isWhitespace()))
{
++text;
++numChars;
}
}
}
TextAtom* const atom = atoms.add (new TextAtom());
atom->atomText = String (start, numChars);
atom->width = font.getStringWidthFloat (atom->getText());
atom->numChars = (uint16) numChars;
}
}
UniformTextSection& operator= (const UniformTextSection&);
JUCE_LEAK_DETECTOR (UniformTextSection)
};
//==============================================================================
class SingleLineTextEditor::Iterator
{
public:
Iterator (const OwnedArray<UniformTextSection>& sectionList,
const float wrapWidth, Justification j)
: indexInText (0),
lineY (0),
lineHeight (0),
maxDescent (0),
atomX (0),
atomRight (0),
atom (nullptr),
currentSection (nullptr),
justification (j),
sections (sectionList),
sectionIndex (0),
atomIndex (0),
wordWrapWidth (wrapWidth)
{
jassert (wordWrapWidth > 0);
if (sections.size() > 0)
{
currentSection = sections.getUnchecked (sectionIndex);
if (currentSection != nullptr)
beginNewLine();
}
}
Iterator (const Iterator& other)
: indexInText (other.indexInText),
lineY (other.lineY),
lineHeight (other.lineHeight),
maxDescent (other.maxDescent),
atomX (other.atomX),
atomRight (other.atomRight),
atom (other.atom),
currentSection (other.currentSection),
justification (other.justification),
sections (other.sections),
sectionIndex (other.sectionIndex),
atomIndex (other.atomIndex),
wordWrapWidth (other.wordWrapWidth),
tempAtom (other.tempAtom)
{
}
//==============================================================================
bool next()
{
if (atom == &tempAtom)
{
const int numRemaining = tempAtom.atomText.length() - tempAtom.numChars;
if (numRemaining > 0)
{
tempAtom.atomText = tempAtom.atomText.substring (tempAtom.numChars);
atomX = 0;
if (tempAtom.numChars > 0)
lineY += lineHeight;
indexInText += tempAtom.numChars;
GlyphArrangement g;
g.addLineOfText (currentSection->font, atom->getText(), 0.0f, 0.0f);
int split;
for (split = 0; split < g.getNumGlyphs(); ++split)
if (shouldWrap (g.getGlyph (split).getRight()))
break;
if (split > 0 && split <= numRemaining)
{
tempAtom.numChars = (uint16) split;
tempAtom.width = g.getGlyph (split - 1).getRight();
atomRight = atomX + tempAtom.width;
return true;
}
}
}
bool forceNewLine = false;
if (sectionIndex >= sections.size())
{
moveToEndOfLastAtom();
return false;
}
else if (atomIndex >= currentSection->atoms.size() - 1)
{
if (atomIndex >= currentSection->atoms.size())
{
if (++sectionIndex >= sections.size())
{
moveToEndOfLastAtom();
return false;
}
atomIndex = 0;
currentSection = sections.getUnchecked (sectionIndex);
}
else
{
const TextAtom* const lastAtom = currentSection->atoms.getUnchecked (atomIndex);
if (! lastAtom->isWhitespace())
{
// handle the case where the last atom in a section is actually part of the same
// word as the first atom of the next section...
float right = atomRight + lastAtom->width;
float lineHeight2 = lineHeight;
float maxDescent2 = maxDescent;
for (int section = sectionIndex + 1; section < sections.size(); ++section)
{
const UniformTextSection* const s = sections.getUnchecked (section);
if (s->atoms.size() == 0)
break;
const TextAtom* const nextAtom = s->atoms.getUnchecked (0);
if (nextAtom->isWhitespace())
break;
right += nextAtom->width;
lineHeight2 = jmax (lineHeight2, s->font.getHeight());
maxDescent2 = jmax (maxDescent2, s->font.getDescent());
if (shouldWrap (right))
{
lineHeight = lineHeight2;
maxDescent = maxDescent2;
forceNewLine = true;
break;
}
if (s->atoms.size() > 1)
break;
}
}
}
}
if (atom != nullptr)
{
atomX = atomRight;
indexInText += atom->numChars;
if (atom->isNewLine())
beginNewLine();
}
atom = currentSection->atoms.getUnchecked (atomIndex);
atomRight = atomX + atom->width;
++atomIndex;
if (shouldWrap (atomRight) || forceNewLine)
{
if (atom->isWhitespace())
{
// leave whitespace at the end of a line, but truncate it to avoid scrolling
atomRight = jmin (atomRight, wordWrapWidth);
}
else
{
atomRight = atom->width;
if (shouldWrap (atomRight)) // atom too big to fit on a line, so break it up..
{
tempAtom = *atom;
tempAtom.width = 0;
tempAtom.numChars = 0;
atom = &tempAtom;
if (atomX > 0)
beginNewLine();
return next();
}
beginNewLine();
return true;
}
}
return true;
}
void beginNewLine()
{
atomX = 0;
lineY += lineHeight;
int tempSectionIndex = sectionIndex;
int tempAtomIndex = atomIndex;
const UniformTextSection* section = sections.getUnchecked (tempSectionIndex);
lineHeight = section->font.getHeight();
maxDescent = section->font.getDescent();
float x = (atom != nullptr) ? atom->width : 0;
while (! shouldWrap (x))
{
if (tempSectionIndex >= sections.size())
break;
bool checkSize = false;
if (tempAtomIndex >= section->atoms.size())
{
if (++tempSectionIndex >= sections.size())
break;
tempAtomIndex = 0;
section = sections.getUnchecked (tempSectionIndex);
checkSize = true;
}
const TextAtom* const nextAtom = section->atoms.getUnchecked (tempAtomIndex);
if (nextAtom == nullptr)
break;
x += nextAtom->width;
if (shouldWrap (x) || nextAtom->isNewLine())
break;
if (checkSize)
{
lineHeight = jmax (lineHeight, section->font.getHeight());
maxDescent = jmax (maxDescent, section->font.getDescent());
}
++tempAtomIndex;
}
}
//==============================================================================
void draw (Graphics& g, const UniformTextSection*& lastSection) const
{
if (! atom->isWhitespace())
{
if (lastSection != currentSection)
{
lastSection = currentSection;
g.setColour (currentSection->colour);
g.setFont (currentSection->font);
}
jassert (atom->getTrimmedText().isNotEmpty());
GlyphArrangement ga;
ga.addJustifiedText (currentSection->font, atom->getTrimmedText(),
atomX, lineY + lineHeight - maxDescent, 100.0f, justification);
ga.draw (g);
}
}
void addSelection (RectangleList<float>& area, const Range<int> selected) const
{
const float startX = indexToX (selected.getStart());
const float endX = indexToX (selected.getEnd());
area.add (startX, lineY, endX - startX, lineHeight);
}
void drawUnderline (Graphics& g, const Range<int> underline, const Colour colour) const
{
const int startX = roundToInt (indexToX (underline.getStart()));
const int endX = roundToInt (indexToX (underline.getEnd()));
const int baselineY = roundToInt (lineY + currentSection->font.getAscent() + 0.5f);
Graphics::ScopedSaveState state (g);
g.reduceClipRegion (Rectangle<int> (startX, baselineY, endX - startX, 1));
g.fillCheckerBoard (Rectangle<int> (endX, baselineY + 1).toFloat(), 3, 1, colour, Colours::transparentBlack);
}
void drawSelectedText (Graphics& g,
const Range<int> selected,
const Colour selectedTextColour) const
{
if (! atom->isWhitespace())
{
GlyphArrangement ga;
ga.addLineOfText (currentSection->font,
atom->getTrimmedText(),
atomX, (float) roundToInt (lineY + lineHeight - maxDescent));
if (selected.getEnd() < indexInText + atom->numChars)
{
GlyphArrangement ga2 (ga);
ga2.removeRangeOfGlyphs (0, selected.getEnd() - indexInText);
ga.removeRangeOfGlyphs (selected.getEnd() - indexInText, -1);
g.setColour (currentSection->colour);
ga2.draw (g);
}
if (selected.getStart() > indexInText)
{
GlyphArrangement ga2 (ga);
ga2.removeRangeOfGlyphs (selected.getStart() - indexInText, -1);
ga.removeRangeOfGlyphs (0, selected.getStart() - indexInText);
g.setColour (currentSection->colour);
ga2.draw (g);
}
g.setColour (selectedTextColour);
ga.draw (g);
}
}
//==============================================================================
float indexToX (const int indexToFind) const
{
if (indexToFind <= indexInText)
return atomX;
if (indexToFind >= indexInText + atom->numChars)
return atomRight;
GlyphArrangement g;
g.addLineOfText (currentSection->font,
atom->getText(),
atomX, 0.0f);
if (indexToFind - indexInText >= g.getNumGlyphs())
return atomRight;
return jmin (atomRight, g.getGlyph (indexToFind - indexInText).getLeft());
}
int xToIndex (const float xToFind) const
{
if (xToFind <= atomX || atom->isNewLine())
return indexInText;
if (xToFind >= atomRight)
return indexInText + atom->numChars;
GlyphArrangement g;
g.addLineOfText (currentSection->font,
atom->getText(),
atomX, 0.0f);
const int numGlyphs = g.getNumGlyphs();
int j;
for (j = 0; j < numGlyphs; ++j)
{
const PositionedGlyph& pg = g.getGlyph(j);
if ((pg.getLeft() + pg.getRight()) / 2 > xToFind)
break;
}
return indexInText + j;
}
//==============================================================================
bool getCharPosition (const int index, float& cx, float& cy, float& lineHeightFound)
{
while (next())
{
if (indexInText + atom->numChars > index)
{
cx = indexToX (index);
cy = lineY;
lineHeightFound = lineHeight;
return true;
}
}
cx = atomX;
cy = lineY;
lineHeightFound = lineHeight;
return false;
}
//==============================================================================
int indexInText;
float lineY, lineHeight, maxDescent;
float atomX, atomRight;
const TextAtom* atom;
const UniformTextSection* currentSection;
Justification justification;
private:
const OwnedArray<UniformTextSection>& sections;
int sectionIndex, atomIndex;
const float wordWrapWidth;
TextAtom tempAtom;
Iterator& operator= (const Iterator&);
void moveToEndOfLastAtom()
{
if (atom != nullptr)
{
atomX = atomRight;
if (atom->isNewLine())
{
atomX = 0.0f;
lineY += lineHeight;
}
}
}
bool shouldWrap (const float x) const noexcept
{
return (x - 0.0001f) >= wordWrapWidth;
}
JUCE_LEAK_DETECTOR (Iterator)
};
//==============================================================================
class SingleLineTextEditor::InsertAction : public UndoableAction
{
public:
InsertAction (SingleLineTextEditor& ed,
const String& newText,
const int insertPos,
const Font& newFont,
const Colour newColour,
const int oldCaret,
const int newCaret)
: owner (ed),
text (newText),
insertIndex (insertPos),
oldCaretPos (oldCaret),
newCaretPos (newCaret),
font (newFont),
colour (newColour)
{
}
bool perform() override
{
owner.insert (text, insertIndex, font, colour, nullptr, newCaretPos);
return true;
}
bool undo() override
{
owner.remove (Range<int> (insertIndex, insertIndex + text.length()), nullptr, oldCaretPos);
return true;
}
int getSizeInUnits() override
{
return text.length() + 16;
}
private:
SingleLineTextEditor& owner;
const String text;
const int insertIndex, oldCaretPos, newCaretPos;
const Font font;
const Colour colour;
JUCE_DECLARE_NON_COPYABLE (InsertAction)
};
//==============================================================================
class SingleLineTextEditor::RemoveAction : public UndoableAction
{
public:
RemoveAction (SingleLineTextEditor& ed,
const Range<int> rangeToRemove,
const int oldCaret,
const int newCaret,
const Array<UniformTextSection*>& oldSections)
: owner (ed),
range (rangeToRemove),
oldCaretPos (oldCaret),
newCaretPos (newCaret)
{
removedSections.addArray (oldSections);
}
bool perform() override
{
owner.remove (range, nullptr, newCaretPos);
return true;
}
bool undo() override
{
owner.reinsert (range.getStart(), removedSections);
owner.moveCaretTo (oldCaretPos, false);
return true;
}
int getSizeInUnits() override
{
int n = 16;
for (int i = removedSections.size(); --i >= 0;)
n += removedSections.getUnchecked (i)->getTotalLength();
return n;
}
private:
SingleLineTextEditor& owner;
const Range<int> range;
const int oldCaretPos, newCaretPos;
OwnedArray<UniformTextSection> removedSections;
JUCE_DECLARE_NON_COPYABLE (RemoveAction)
};
//==============================================================================
class SingleLineTextEditor::TextHolderComponent : public Component,
public Timer,
public Value::Listener
{
public:
TextHolderComponent (SingleLineTextEditor& ed) : owner (ed)
{
setWantsKeyboardFocus (false);
setInterceptsMouseClicks (false, true);
setMouseCursor (MouseCursor::ParentCursor);
owner.getTextValue().addListener (this);
}
~TextHolderComponent() override
{
owner.getTextValue().removeListener (this);
}
void paint (Graphics& g) override
{
owner.drawContent (g);
}
void restartTimer()
{
startTimer (350);
}
void timerCallback() override
{
owner.timerCallbackInt();
}
void valueChanged (Value&) override
{
owner.textWasChangedByValue();
}
private:
SingleLineTextEditor& owner;
JUCE_DECLARE_NON_COPYABLE (TextHolderComponent)
};
//==============================================================================
namespace TextEditorDefs
{
const int textChangeMessageId = 0x10003001;
const int returnKeyMessageId = 0x10003002;
const int escapeKeyMessageId = 0x10003003;
const int focusLossMessageId = 0x10003004;
const int maxActionsPerTransaction = 100;
static int getCharacterCategory (const juce_wchar character)
{
return CharacterFunctions::isLetterOrDigit (character)
? 2 : (CharacterFunctions::isWhitespace (character) ? 0 : 1);
}
}
//==============================================================================
SingleLineTextEditor::SingleLineTextEditor (const String& name)
: Component (name),
readOnly (false),
caretVisible (true),
popupMenuEnabled (true),
selectAllTextWhenFocused (false),
wasFocused (false),
tabKeyUsed (false),
menuActive (false),
valueTextNeedsUpdating (false),
consumeEscAndReturnKeys (true),
lastTransactionTime (0),
currentFont (14.0f),
totalNumChars (0),
caretPosition (0),
keyboardType (TextInputTarget::textKeyboard),
dragType (notDragging)
{
setOpaque (true);
setMouseCursor (MouseCursor::IBeamCursor);
textHolder = std::make_unique<TextHolderComponent> (*this);
addAndMakeVisible (*textHolder);
setWantsKeyboardFocus (true);
recreateCaret();
}
SingleLineTextEditor::~SingleLineTextEditor()
{
if (wasFocused)
if (ComponentPeer* const peer = getPeer())
peer->dismissPendingTextInput();
textValue.removeListener (textHolder.get());
textValue.referTo (Value());
textHolder = nullptr;
}
//==============================================================================
void SingleLineTextEditor::newTransaction()
{
lastTransactionTime = Time::getApproximateMillisecondCounter();
undoManager.beginNewTransaction();
}
bool SingleLineTextEditor::undoOrRedo (const bool shouldUndo)
{
if (! isReadOnly())
{
newTransaction();
if (shouldUndo ? undoManager.undo()
: undoManager.redo())
{
repaint();
textChanged();
return true;
}
}
return false;
}
bool SingleLineTextEditor::undo() { return undoOrRedo (true); }
bool SingleLineTextEditor::redo() { return undoOrRedo (false); }
//==============================================================================
bool SingleLineTextEditor::isReadOnly() const noexcept
{
return readOnly || ! isEnabled();
}
bool SingleLineTextEditor::isTextInputActive() const
{
return ! isReadOnly();
}
void SingleLineTextEditor::setTabKeyUsedAsCharacter (const bool shouldTabKeyBeUsed)
{
tabKeyUsed = shouldTabKeyBeUsed;
}
void SingleLineTextEditor::setPopupMenuEnabled (const bool b)
{
popupMenuEnabled = b;
}
void SingleLineTextEditor::setSelectAllWhenFocused (const bool b)
{
selectAllTextWhenFocused = b;
}
//==============================================================================
void SingleLineTextEditor::setFont (const Font& newFont)
{
currentFont = newFont;
}
void SingleLineTextEditor::applyFontToAllText (const Font& newFont)
{
currentFont = newFont;
const Colour overallColour (findColour (textColourId));
for (int i = sections.size(); --i >= 0;)
{
UniformTextSection* const uts = sections.getUnchecked (i);
uts->setFont (newFont);
uts->colour = overallColour;
}
coalesceSimilarSections();
repaint();
}
void SingleLineTextEditor::colourChanged()
{
setOpaque (findColour (backgroundColourId).isOpaque());
repaint();
}
void SingleLineTextEditor::lookAndFeelChanged()
{
caret = nullptr;
recreateCaret();
repaint();
}
void SingleLineTextEditor::enablementChanged()
{
recreateCaret();
repaint();
}
void SingleLineTextEditor::setCaretVisible (const bool shouldCaretBeVisible)
{
if (caretVisible != shouldCaretBeVisible)
{
caretVisible = shouldCaretBeVisible;
recreateCaret();
}
}
void SingleLineTextEditor::recreateCaret()
{
if (isCaretVisible())
{
if (caret == nullptr)
{
caret.reset (getLookAndFeel().createCaretComponent (this));
textHolder->addChildComponent (*caret);
updateCaretPosition();
}
}
else
{
caret = nullptr;
}
}
void SingleLineTextEditor::updateCaretPosition()
{
if (caret != nullptr)
caret->setCaretPosition (getCaretRectangle());
}
SingleLineTextEditor::LengthAndCharacterRestriction::LengthAndCharacterRestriction (int maxLen, const String& chars)
: allowedCharacters (chars), maxLength (maxLen)
{}
String SingleLineTextEditor::LengthAndCharacterRestriction::filterNewText (SingleLineTextEditor& ed, const String& newInput)
{
String t (newInput);
if (allowedCharacters.isNotEmpty())
t = t.retainCharacters (allowedCharacters);
if (maxLength > 0)
t = t.substring (0, maxLength - (ed.getTotalNumChars() - ed.getHighlightedRegion().getLength()));
return t;
}
void SingleLineTextEditor::setInputFilter (InputFilter* newFilter, bool takeOwnership)
{
inputFilter.set (newFilter, takeOwnership);
}
void SingleLineTextEditor::setInputRestrictions (const int maxLen, const String& chars)
{
setInputFilter (new LengthAndCharacterRestriction (maxLen, chars), true);
}
void SingleLineTextEditor::setTextToShowWhenEmpty (const String& text, Colour colourToUse)
{
textToShowWhenEmpty = text;
colourForTextWhenEmpty = colourToUse;
}
//==============================================================================
void SingleLineTextEditor::clear()
{
clearInternal (nullptr);
undoManager.clearUndoHistory();
}
void SingleLineTextEditor::setText (const String& newText,
const bool sendTextChangeMessage)
{
const int newLength = newText.length();
if (newLength != getTotalNumChars() || getText() != newText)
{
textValue = newText;
int oldCursorPos = caretPosition;
const bool cursorWasAtEnd = oldCursorPos >= getTotalNumChars();
clearInternal (nullptr);
insert (newText, 0, currentFont, findColour (textColourId), nullptr, caretPosition);
if (cursorWasAtEnd)
oldCursorPos = getTotalNumChars();
moveCaretTo (oldCursorPos, false);
if (sendTextChangeMessage)
textChanged();
undoManager.clearUndoHistory();
repaint();
}
}
//==============================================================================
void SingleLineTextEditor::updateValueFromText()
{
if (valueTextNeedsUpdating)
{
valueTextNeedsUpdating = false;
textValue = getText();
}
}
Value& SingleLineTextEditor::getTextValue()
{
updateValueFromText();
return textValue;
}
void SingleLineTextEditor::textWasChangedByValue()
{
if (textValue.getValueSource().getReferenceCount() > 1)
setText (textValue.getValue());
}
//==============================================================================
void SingleLineTextEditor::textChanged()
{
if (listeners.size() > 0)
postCommandMessage (TextEditorDefs::textChangeMessageId);
if (textValue.getValueSource().getReferenceCount() > 1)
{
valueTextNeedsUpdating = false;
textValue = getText();
}
}
void SingleLineTextEditor::returnPressed() { postCommandMessage (TextEditorDefs::returnKeyMessageId); }
void SingleLineTextEditor::escapePressed() { postCommandMessage (TextEditorDefs::escapeKeyMessageId); }
void SingleLineTextEditor::addListener (SingleLineTextEditor::Listener* const l) { listeners.add (l); }
void SingleLineTextEditor::removeListener (SingleLineTextEditor::Listener* const l) { listeners.remove (l); }
//==============================================================================
void SingleLineTextEditor::timerCallbackInt()
{
if (hasKeyboardFocus (false) && ! isCurrentlyBlockedByAnotherModalComponent())
wasFocused = true;
const unsigned int now = Time::getApproximateMillisecondCounter();
if (now > lastTransactionTime + 200)
newTransaction();
}
void SingleLineTextEditor::repaintText (const Range<int> range)
{
if (! range.isEmpty())
{
float x = 0, y = 0, lh = currentFont.getHeight();
const float wordWrapWidth = getWordWrapWidth();
if (wordWrapWidth > 0)
{
Iterator i (sections, wordWrapWidth, justification);
i.getCharPosition (range.getStart(), x, y, lh);
const int y1 = (int) y;
int y2;
if (range.getEnd() >= getTotalNumChars())
{
y2 = textHolder->getHeight();
}
else
{
i.getCharPosition (range.getEnd(), x, y, lh);
y2 = (int) (y + lh * 2.0f);
}
textHolder->repaint (0, y1, textHolder->getWidth(), y2 - y1);
}
}
}
//==============================================================================
void SingleLineTextEditor::moveCaret (int newCaretPos)
{
if (newCaretPos < 0)
newCaretPos = 0;
else
newCaretPos = jmin (newCaretPos, getTotalNumChars());
if (newCaretPos != getCaretPosition())
{
caretPosition = newCaretPos;
textHolder->restartTimer();
updateCaretPosition();
}
}
int SingleLineTextEditor::getCaretPosition() const
{
return caretPosition;
}
void SingleLineTextEditor::setCaretPosition (const int newIndex)
{
moveCaretTo (newIndex, false);
}
void SingleLineTextEditor::moveCaretToEnd()
{
moveCaretTo (std::numeric_limits<int>::max(), false);
}
Rectangle<int> SingleLineTextEditor::getCaretRectangle()
{
float cursorX, cursorY;
float cursorHeight = currentFont.getHeight(); // (in case the text is empty and the call below doesn't set this value)
getCharPosition (caretPosition, cursorX, cursorY, cursorHeight);
return Rectangle<int> (roundToInt (cursorX), roundToInt (cursorY), 2, roundToInt (cursorHeight));
}
//==============================================================================
enum { rightEdgeSpace = 2 };
float SingleLineTextEditor::getWordWrapWidth() const
{
return std::numeric_limits<float>::max();
}
int SingleLineTextEditor::getTextWidth() const { return textHolder->getWidth(); }
int SingleLineTextEditor::getTextHeight() const { return textHolder->getHeight(); }
void SingleLineTextEditor::moveCaretTo (const int newPosition, const bool isSelecting)
{
if (isSelecting)
{
moveCaret (newPosition);
const Range<int> oldSelection (selection);
if (dragType == notDragging)
{
if (abs (getCaretPosition() - selection.getStart()) < abs (getCaretPosition() - selection.getEnd()))
dragType = draggingSelectionStart;
else
dragType = draggingSelectionEnd;
}
if (dragType == draggingSelectionStart)
{
if (getCaretPosition() >= selection.getEnd())
dragType = draggingSelectionEnd;
selection = Range<int>::between (getCaretPosition(), selection.getEnd());
}
else
{
if (getCaretPosition() < selection.getStart())
dragType = draggingSelectionStart;
selection = Range<int>::between (getCaretPosition(), selection.getStart());
}
repaintText (selection.getUnionWith (oldSelection));
}
else
{
dragType = notDragging;
repaintText (selection);
moveCaret (newPosition);
selection = Range<int>::emptyRange (getCaretPosition());
}
}
int SingleLineTextEditor::getTextIndexAt (const int x, const int y)
{
return indexAtPosition ((float) x, (float) y);
}
void SingleLineTextEditor::insertTextAtCaret (const String& t)
{
String newText (inputFilter != nullptr ? inputFilter->filterNewText (*this, t) : t);
newText = newText.replaceCharacters ("\r\n", " ");
const int insertIndex = selection.getStart();
const int newCaretPos = insertIndex + newText.length();
remove (selection, getUndoManager(),
newText.isNotEmpty() ? newCaretPos - 1 : newCaretPos);
insert (newText, insertIndex, currentFont, findColour (textColourId),
getUndoManager(), newCaretPos);
textChanged();
}
void SingleLineTextEditor::setHighlightedRegion (const Range<int>& newSelection)
{
moveCaretTo (newSelection.getStart(), false);
moveCaretTo (newSelection.getEnd(), true);
}
//==============================================================================
void SingleLineTextEditor::copy()
{
const String selectedText (getHighlightedText());
if (selectedText.isNotEmpty())
SystemClipboard::copyTextToClipboard (selectedText);
}
void SingleLineTextEditor::paste()
{
if (! isReadOnly())
{
const String clip (SystemClipboard::getTextFromClipboard());
if (clip.isNotEmpty())
insertTextAtCaret (clip);
}
}
void SingleLineTextEditor::cut()
{
if (! isReadOnly())
{
moveCaret (selection.getEnd());
insertTextAtCaret (String());
}
}
//==============================================================================
void SingleLineTextEditor::drawContent (Graphics& g)
{
Rectangle<int> r = getLocalBounds();
GlyphArrangement ga;
ga.addFittedText (getFont(), getText(),
float (r.getX()), float (r.getY()),
float (r.getWidth()), float (r.getHeight()), justification, 1);
Colour selectedTextColour = findColour (highlightedTextColourId);
Colour normalTextColour = findColour (textColourId);
if (! selection.isEmpty())
{
g.setColour (findColour (highlightColourId).withMultipliedAlpha (hasKeyboardFocus (true) ? 1.0f : 0.5f));
auto s = selection.getStart();
auto e = selection.getEnd();
float x1, y1, x2, y2, h1, h2;
getCharPosition (s, x1, y1, h1);
getCharPosition (e, x2, y2, h2);
if (x2 - x1 > 0)
g.fillRect (x1, y1, x2 - x1, h1);
}
for (int i = 0; i < ga.getNumGlyphs(); i++)
{
if (selection.contains (i))
g.setColour (selectedTextColour);
else
g.setColour (normalTextColour);
ga.getGlyph (i).draw (g);
}
}
void SingleLineTextEditor::paint (Graphics& g)
{
if (LookAndFeelMethods* lfm = dynamic_cast<LookAndFeelMethods*> (&getLookAndFeel()))
lfm->fillSingleLineTextEditorBackground (g, getWidth(), getHeight(), *this);
}
void SingleLineTextEditor::paintOverChildren (Graphics& g)
{
if (textToShowWhenEmpty.isNotEmpty()
&& (! hasKeyboardFocus (false))
&& getTotalNumChars() == 0)
{
g.setColour (colourForTextWhenEmpty);
g.setFont (getFont());
g.drawText (textToShowWhenEmpty,
0, 0, getWidth(), getHeight(),
justification, true);
}
if (LookAndFeelMethods* lfm = dynamic_cast<LookAndFeelMethods*> (&getLookAndFeel()))
lfm->drawSingleLineTextEditorOutline (g, getWidth(), getHeight(), *this);
}
//==============================================================================
void SingleLineTextEditor::addPopupMenuItems (PopupMenu& m, const MouseEvent*)
{
const bool writable = ! isReadOnly();
m.addItem (StandardApplicationCommandIDs::cut, TRANS("Cut"), writable);
m.addItem (StandardApplicationCommandIDs::copy, TRANS("Copy"), ! selection.isEmpty());
m.addItem (StandardApplicationCommandIDs::paste, TRANS("Paste"), writable);
m.addItem (StandardApplicationCommandIDs::del, TRANS("Delete"), writable);
m.addSeparator();
m.addItem (StandardApplicationCommandIDs::selectAll, TRANS("Select All"));
m.addSeparator();
if (getUndoManager() != nullptr)
{
m.addItem (StandardApplicationCommandIDs::undo, TRANS("Undo"), undoManager.canUndo());
m.addItem (StandardApplicationCommandIDs::redo, TRANS("Redo"), undoManager.canRedo());
}
}
void SingleLineTextEditor::performPopupMenuAction (const int menuItemID)
{
switch (menuItemID)
{
case StandardApplicationCommandIDs::cut: cutToClipboard(); break;
case StandardApplicationCommandIDs::copy: copyToClipboard(); break;
case StandardApplicationCommandIDs::paste: pasteFromClipboard(); break;
case StandardApplicationCommandIDs::del: cut(); break;
case StandardApplicationCommandIDs::selectAll: selectAll(); break;
case StandardApplicationCommandIDs::undo: undo(); break;
case StandardApplicationCommandIDs::redo: redo(); break;
default: break;
}
}
static void textEditorMenuCallback (int menuResult, SingleLineTextEditor* editor)
{
if (editor != nullptr && menuResult != 0)
editor->performPopupMenuAction (menuResult);
}
//==============================================================================
void SingleLineTextEditor::mouseDown (const MouseEvent& e)
{
beginDragAutoRepeat (100);
newTransaction();
if (wasFocused || ! selectAllTextWhenFocused)
{
if (! (popupMenuEnabled && e.mods.isPopupMenu()))
{
moveCaretTo (getTextIndexAt (e.x, e.y),
e.mods.isShiftDown());
}
else
{
PopupMenu m;
m.setLookAndFeel (&getLookAndFeel());
addPopupMenuItems (m, &e);
m.showMenuAsync (PopupMenu::Options(),
ModalCallbackFunction::forComponent (textEditorMenuCallback, this));
}
}
}
void SingleLineTextEditor::mouseDrag (const MouseEvent& e)
{
if (wasFocused || ! selectAllTextWhenFocused)
if (! (popupMenuEnabled && e.mods.isPopupMenu()))
moveCaretTo (getTextIndexAt (e.x, e.y), true);
}
void SingleLineTextEditor::mouseUp (const MouseEvent& e)
{
newTransaction();
textHolder->restartTimer();
if (wasFocused || ! selectAllTextWhenFocused)
if (e.mouseWasClicked() && ! (popupMenuEnabled && e.mods.isPopupMenu()))
moveCaret (getTextIndexAt (e.x, e.y));
wasFocused = true;
}
void SingleLineTextEditor::mouseDoubleClick (const MouseEvent& e)
{
int tokenEnd = getTextIndexAt (e.x, e.y);
int tokenStart = 0;
if (e.getNumberOfClicks() > 3)
{
tokenEnd = getTotalNumChars();
}
else
{
const String t (getText());
const int totalLength = getTotalNumChars();
while (tokenEnd < totalLength)
{
// (note the slight bodge here - it's because iswalnum only checks for alphabetic chars in the current locale)
const juce_wchar c = t [tokenEnd];
if (CharacterFunctions::isLetterOrDigit (c) || c > 128)
++tokenEnd;
else
break;
}
tokenStart = tokenEnd;
while (tokenStart > 0)
{
// (note the slight bodge here - it's because iswalnum only checks for alphabetic chars in the current locale)
const juce_wchar c = t [tokenStart - 1];
if (CharacterFunctions::isLetterOrDigit (c) || c > 128)
--tokenStart;
else
break;
}
if (e.getNumberOfClicks() > 2)
{
while (tokenEnd < totalLength)
{
const juce_wchar c = t [tokenEnd];
if (c != '\r' && c != '\n')
++tokenEnd;
else
break;
}
while (tokenStart > 0)
{
const juce_wchar c = t [tokenStart - 1];
if (c != '\r' && c != '\n')
--tokenStart;
else
break;
}
}
}
moveCaretTo (tokenEnd, false);
moveCaretTo (tokenStart, true);
}
void SingleLineTextEditor::mouseWheelMove (const MouseEvent& e, const MouseWheelDetails& wheel)
{
Component::mouseWheelMove (e, wheel);
}
//==============================================================================
bool SingleLineTextEditor::moveCaretWithTransaction (const int newPos, const bool selecting)
{
newTransaction();
moveCaretTo (newPos, selecting);
return true;
}
bool SingleLineTextEditor::moveCaretLeft (bool moveInWholeWordSteps, bool selecting)
{
int pos = getCaretPosition();
if (moveInWholeWordSteps)
pos = findWordBreakBefore (pos);
else
--pos;
return moveCaretWithTransaction (pos, selecting);
}
bool SingleLineTextEditor::moveCaretRight (bool moveInWholeWordSteps, bool selecting)
{
int pos = getCaretPosition();
if (moveInWholeWordSteps)
pos = findWordBreakAfter (pos);
else
++pos;
return moveCaretWithTransaction (pos, selecting);
}
bool SingleLineTextEditor::moveCaretUp (bool selecting)
{
return moveCaretToStartOfLine (selecting);
}
bool SingleLineTextEditor::moveCaretDown (bool selecting)
{
return moveCaretToEndOfLine (selecting);
}
bool SingleLineTextEditor::pageUp (bool selecting)
{
return moveCaretToStartOfLine (selecting);
}
bool SingleLineTextEditor::pageDown (bool selecting)
{
return moveCaretToEndOfLine (selecting);
}
bool SingleLineTextEditor::moveCaretToTop (bool selecting)
{
return moveCaretWithTransaction (0, selecting);
}
bool SingleLineTextEditor::moveCaretToStartOfLine (bool selecting)
{
const Rectangle<float> caretPos (getCaretRectangle().toFloat());
return moveCaretWithTransaction (indexAtPosition (0.0f, caretPos.getY()), selecting);
}
bool SingleLineTextEditor::moveCaretToEnd (bool selecting)
{
return moveCaretWithTransaction (getTotalNumChars(), selecting);
}
bool SingleLineTextEditor::moveCaretToEndOfLine (bool selecting)
{
const Rectangle<float> caretPos (getCaretRectangle().toFloat());
return moveCaretWithTransaction (indexAtPosition ((float) textHolder->getWidth(), caretPos.getY()), selecting);
}
bool SingleLineTextEditor::deleteBackwards (bool moveInWholeWordSteps)
{
if (moveInWholeWordSteps)
moveCaretTo (findWordBreakBefore (getCaretPosition()), true);
else if (selection.isEmpty() && selection.getStart() > 0)
selection = Range<int> (selection.getEnd() - 1, selection.getEnd());
cut();
return true;
}
bool SingleLineTextEditor::deleteForwards (bool /*moveInWholeWordSteps*/)
{
if (selection.isEmpty() && selection.getStart() < getTotalNumChars())
selection = Range<int> (selection.getStart(), selection.getStart() + 1);
cut();
return true;
}
bool SingleLineTextEditor::copyToClipboard()
{
newTransaction();
copy();
return true;
}
bool SingleLineTextEditor::cutToClipboard()
{
newTransaction();
copy();
cut();
return true;
}
bool SingleLineTextEditor::pasteFromClipboard()
{
newTransaction();
paste();
return true;
}
bool SingleLineTextEditor::selectAll()
{
newTransaction();
moveCaretTo (0, false);
moveCaretTo (getTotalNumChars(), true);
return true;
}
//==============================================================================
void SingleLineTextEditor::setEscapeAndReturnKeysConsumed (bool shouldBeConsumed) noexcept
{
consumeEscAndReturnKeys = shouldBeConsumed;
}
bool SingleLineTextEditor::keyPressed (const KeyPress& key)
{
if (isReadOnly() && key != KeyPress ('c', ModifierKeys::commandModifier, 0))
return false;
if (! TextEditorKeyMapper<SingleLineTextEditor>::invokeKeyFunction (*this, key))
{
if (key == KeyPress::returnKey)
{
newTransaction();
returnPressed();
return consumeEscAndReturnKeys;
}
else if (key.isKeyCode (KeyPress::escapeKey))
{
newTransaction();
moveCaretTo (getCaretPosition(), false);
escapePressed();
return consumeEscAndReturnKeys;
}
else if (key.getTextCharacter() >= ' '
|| (tabKeyUsed && (key.getTextCharacter() == '\t')))
{
insertTextAtCaret (String::charToString (key.getTextCharacter()));
lastTransactionTime = Time::getApproximateMillisecondCounter();
}
else
{
return false;
}
}
return true;
}
bool SingleLineTextEditor::keyStateChanged (const bool isKeyDown)
{
if (! isKeyDown)
return false;
#if JUCE_WINDOWS
if (KeyPress (KeyPress::F4Key, ModifierKeys::altModifier, 0).isCurrentlyDown())
return false; // We need to explicitly allow alt-F4 to pass through on Windows
#endif
if ((! consumeEscAndReturnKeys)
&& (KeyPress (KeyPress::escapeKey).isCurrentlyDown()
|| KeyPress (KeyPress::returnKey).isCurrentlyDown()))
return false;
// (overridden to avoid forwarding key events to the parent)
return ! ModifierKeys::getCurrentModifiers().isCommandDown();
}
//==============================================================================
void SingleLineTextEditor::focusGained (FocusChangeType)
{
newTransaction();
if (selectAllTextWhenFocused)
{
moveCaretTo (0, false);
moveCaretTo (getTotalNumChars(), true);
}
repaint();
updateCaretPosition();
if (ComponentPeer* const peer = getPeer())
if (! isReadOnly())
peer->textInputRequired (peer->globalToLocal (getScreenPosition()), *this);
}
void SingleLineTextEditor::focusLost (FocusChangeType)
{
newTransaction();
wasFocused = false;
textHolder->stopTimer();
underlinedSections.clear();
if (ComponentPeer* const peer = getPeer())
peer->dismissPendingTextInput();
updateCaretPosition();
postCommandMessage (TextEditorDefs::focusLossMessageId);
repaint();
}
//==============================================================================
void SingleLineTextEditor::resized()
{
textHolder->setBounds (getLocalBounds());
updateCaretPosition();
}
void SingleLineTextEditor::handleCommandMessage (const int commandId)
{
Component::BailOutChecker checker (this);
switch (commandId)
{
case TextEditorDefs::textChangeMessageId:
listeners.callChecked (checker, &SingleLineTextEditor::Listener::sltextEditorTextChanged, (SingleLineTextEditor&) *this);
break;
case TextEditorDefs::returnKeyMessageId:
listeners.callChecked (checker, &SingleLineTextEditor::Listener::sltextEditorReturnKeyPressed, (SingleLineTextEditor&) *this);
break;
case TextEditorDefs::escapeKeyMessageId:
listeners.callChecked (checker, &SingleLineTextEditor::Listener::sltextEditorEscapeKeyPressed, (SingleLineTextEditor&) *this);
break;
case TextEditorDefs::focusLossMessageId:
updateValueFromText();
listeners.callChecked (checker, &SingleLineTextEditor::Listener::sltextEditorFocusLost, (SingleLineTextEditor&) *this);
break;
default:
jassertfalse;
break;
}
}
void SingleLineTextEditor::setTemporaryUnderlining (const Array<Range<int> >& newUnderlinedSections)
{
underlinedSections = newUnderlinedSections;
repaint();
}
//==============================================================================
UndoManager* SingleLineTextEditor::getUndoManager() noexcept
{
return readOnly ? nullptr : &undoManager;
}
void SingleLineTextEditor::clearInternal (UndoManager* const um)
{
remove (Range<int> (0, getTotalNumChars()), um, caretPosition);
}
void SingleLineTextEditor::insert (const String& text,
const int insertIndex,
const Font& font,
const Colour colour,
UndoManager* const um,
const int caretPositionToMoveTo)
{
if (text.isNotEmpty())
{
if (um != nullptr)
{
if (um->getNumActionsInCurrentTransaction() > TextEditorDefs::maxActionsPerTransaction)
newTransaction();
um->perform (new InsertAction (*this, text, insertIndex, font, colour,
caretPosition, caretPositionToMoveTo));
}
else
{
repaintText (Range<int> (insertIndex, getTotalNumChars())); // must do this before and after changing the data, in case
// a line gets moved due to word wrap
int index = 0;
int nextIndex = 0;
for (int i = 0; i < sections.size(); ++i)
{
nextIndex = index + sections.getUnchecked (i)->getTotalLength();
if (insertIndex == index)
{
sections.insert (i, new UniformTextSection (text, font, colour));
break;
}
else if (insertIndex > index && insertIndex < nextIndex)
{
splitSection (i, insertIndex - index);
sections.insert (i + 1, new UniformTextSection (text, font, colour));
break;
}
index = nextIndex;
}
if (nextIndex == insertIndex)
sections.add (new UniformTextSection (text, font, colour));
coalesceSimilarSections();
totalNumChars = -1;
valueTextNeedsUpdating = true;
moveCaretTo (caretPositionToMoveTo, false);
repaintText (Range<int> (insertIndex, getTotalNumChars()));
}
}
}
void SingleLineTextEditor::reinsert (const int insertIndex, const OwnedArray<UniformTextSection>& sectionsToInsert)
{
int index = 0;
int nextIndex = 0;
for (int i = 0; i < sections.size(); ++i)
{
nextIndex = index + sections.getUnchecked (i)->getTotalLength();
if (insertIndex == index)
{
for (int j = sectionsToInsert.size(); --j >= 0;)
sections.insert (i, new UniformTextSection (*sectionsToInsert.getUnchecked(j)));
break;
}
else if (insertIndex > index && insertIndex < nextIndex)
{
splitSection (i, insertIndex - index);
for (int j = sectionsToInsert.size(); --j >= 0;)
sections.insert (i + 1, new UniformTextSection (*sectionsToInsert.getUnchecked(j)));
break;
}
index = nextIndex;
}
if (nextIndex == insertIndex)
{
for (int j = 0; j < sectionsToInsert.size(); ++j)
sections.add (new UniformTextSection (*sectionsToInsert.getUnchecked(j)));
}
coalesceSimilarSections();
totalNumChars = -1;
valueTextNeedsUpdating = true;
}
void SingleLineTextEditor::remove (Range<int> range, UndoManager* const um, const int caretPositionToMoveTo)
{
if (! range.isEmpty())
{
int index = 0;
for (int i = 0; i < sections.size(); ++i)
{
const int nextIndex = index + sections.getUnchecked(i)->getTotalLength();
if (range.getStart() > index && range.getStart() < nextIndex)
{
splitSection (i, range.getStart() - index);
--i;
}
else if (range.getEnd() > index && range.getEnd() < nextIndex)
{
splitSection (i, range.getEnd() - index);
--i;
}
else
{
index = nextIndex;
if (index > range.getEnd())
break;
}
}
index = 0;
if (um != nullptr)
{
Array<UniformTextSection*> removedSections;
for (int i = 0; i < sections.size(); ++i)
{
if (range.getEnd() <= range.getStart())
break;
UniformTextSection* const section = sections.getUnchecked (i);
const int nextIndex = index + section->getTotalLength();
if (range.getStart() <= index && range.getEnd() >= nextIndex)
removedSections.add (new UniformTextSection (*section));
index = nextIndex;
}
if (um->getNumActionsInCurrentTransaction() > TextEditorDefs::maxActionsPerTransaction)
newTransaction();
um->perform (new RemoveAction (*this, range, caretPosition,
caretPositionToMoveTo, removedSections));
}
else
{
Range<int> remainingRange (range);
for (int i = 0; i < sections.size(); ++i)
{
UniformTextSection* const section = sections.getUnchecked (i);
const int nextIndex = index + section->getTotalLength();
if (remainingRange.getStart() <= index && remainingRange.getEnd() >= nextIndex)
{
sections.remove (i);
remainingRange.setEnd (remainingRange.getEnd() - (nextIndex - index));
if (remainingRange.isEmpty())
break;
--i;
}
else
{
index = nextIndex;
}
}
coalesceSimilarSections();
totalNumChars = -1;
valueTextNeedsUpdating = true;
moveCaretTo (caretPositionToMoveTo, false);
repaintText (Range<int> (range.getStart(), getTotalNumChars()));
}
}
}
//==============================================================================
String SingleLineTextEditor::getText() const
{
MemoryOutputStream mo;
mo.preallocate ((size_t) getTotalNumChars());
for (int i = 0; i < sections.size(); ++i)
sections.getUnchecked (i)->appendAllText (mo);
return mo.toUTF8();
}
String SingleLineTextEditor::getTextInRange (const Range<int>& range) const
{
if (range.isEmpty())
return String();
MemoryOutputStream mo;
mo.preallocate ((size_t) jmin (getTotalNumChars(), range.getLength()));
int index = 0;
for (int i = 0; i < sections.size(); ++i)
{
const UniformTextSection* const s = sections.getUnchecked (i);
const int nextIndex = index + s->getTotalLength();
if (range.getStart() < nextIndex)
{
if (range.getEnd() <= index)
break;
s->appendSubstring (mo, range - index);
}
index = nextIndex;
}
return mo.toUTF8();
}
String SingleLineTextEditor::getHighlightedText() const
{
return getTextInRange (selection);
}
int SingleLineTextEditor::getTotalNumChars() const
{
if (totalNumChars < 0)
{
totalNumChars = 0;
for (int i = sections.size(); --i >= 0;)
totalNumChars += sections.getUnchecked (i)->getTotalLength();
}
return totalNumChars;
}
bool SingleLineTextEditor::isEmpty() const
{
return getTotalNumChars() == 0;
}
void SingleLineTextEditor::getCharPosition (const int index, float& cx, float& cy, float& lineHeight) const
{
Rectangle<int> r = getLocalBounds();
GlyphArrangement ga;
ga.addFittedText (getFont(), getText(),
float (r.getX()), float (r.getY()),
float (r.getWidth()), float (r.getHeight()), justification, 1);
const int numGlyphs = ga.getNumGlyphs();
if (numGlyphs == 0)
{
cx = float (r.getCentreX());
cy = 1;
}
else if (index >= 0 && index < numGlyphs)
{
PositionedGlyph& pg = ga.getGlyph (index);
cx = pg.getLeft();
cy = pg.getTop();
lineHeight = pg.getBottom() - pg.getTop();
}
else if (numGlyphs > 0 && numGlyphs == index)
{
PositionedGlyph& pg = ga.getGlyph (index - 1);
cx = pg.getRight();
cy = pg.getTop();
lineHeight = pg.getBottom() - pg.getTop();
}
else
{
cx = 0;
cy = 0;
lineHeight = 0;
}
}
int SingleLineTextEditor::indexAtPosition (const float x, const float)
{
Rectangle<int> r = getLocalBounds();
GlyphArrangement ga;
ga.addFittedText (getFont(), getText(),
float (r.getX()), float (r.getY()),
float (r.getWidth()), float (r.getHeight()), justification, 1);
const int numGlyphs = ga.getNumGlyphs();
if (numGlyphs > 0)
{
PositionedGlyph& pg = ga.getGlyph (numGlyphs - 1);
if (x >= pg.getRight())
return numGlyphs;
}
for (int i = numGlyphs; --i >= 0;)
{
PositionedGlyph& pg = ga.getGlyph (i);
if (x >= pg.getLeft())
return i;
}
return getTotalNumChars();
}
//==============================================================================
int SingleLineTextEditor::findWordBreakAfter (const int position) const
{
const String t (getTextInRange (Range<int> (position, position + 512)));
const int totalLength = t.length();
int i = 0;
while (i < totalLength && CharacterFunctions::isWhitespace (t[i]))
++i;
const int type = TextEditorDefs::getCharacterCategory (t[i]);
while (i < totalLength && type == TextEditorDefs::getCharacterCategory (t[i]))
++i;
while (i < totalLength && CharacterFunctions::isWhitespace (t[i]))
++i;
return position + i;
}
int SingleLineTextEditor::findWordBreakBefore (const int position) const
{
if (position <= 0)
return 0;
const int startOfBuffer = jmax (0, position - 512);
const String t (getTextInRange (Range<int> (startOfBuffer, position)));
int i = position - startOfBuffer;
while (i > 0 && CharacterFunctions::isWhitespace (t [i - 1]))
--i;
if (i > 0)
{
const int type = TextEditorDefs::getCharacterCategory (t [i - 1]);
while (i > 0 && type == TextEditorDefs::getCharacterCategory (t [i - 1]))
--i;
}
jassert (startOfBuffer + i >= 0);
return startOfBuffer + i;
}
//==============================================================================
void SingleLineTextEditor::splitSection (const int sectionIndex, const int charToSplitAt)
{
jassert (sections[sectionIndex] != nullptr);
sections.insert (sectionIndex + 1,
sections.getUnchecked (sectionIndex)->split (charToSplitAt));
}
void SingleLineTextEditor::coalesceSimilarSections()
{
for (int i = 0; i < sections.size() - 1; ++i)
{
UniformTextSection* const s1 = sections.getUnchecked (i);
UniformTextSection* const s2 = sections.getUnchecked (i + 1);
if (s1->font == s2->font
&& s1->colour == s2->colour)
{
s1->append (*s2);
sections.remove (i + 1);
--i;
}
}
}
Copy permalink