void TextBox::getCaretLocation(Vector2* p)
{
GP_ASSERT(p);
State state = getState();
getFont(state)->getLocationAtIndex(getDisplayedText().c_str(), _textBounds, getFontSize(state), p, _caretLocation, getTextAlignment(state), true, getTextRightToLeft(state));
}
unsigned int TextBox::drawImages(Form* form, const Rectangle& clip)
{
Control::State state = getState();
if (_caretImage && (state == ACTIVE || hasFocus()))
{
// Draw the cursor at its current location.
const Rectangle& region = _caretImage->getRegion();
if (!region.isEmpty())
{
const Theme::UVs& uvs = _caretImage->getUVs();
Vector4 color = _caretImage->getColor();
color.w *= _opacity;
float caretWidth = region.width * _fontSize / region.height;
Font* font = getFont(state);
unsigned int fontSize = getFontSize(state);
Vector2 point;
font->getLocationAtIndex(getDisplayedText().c_str(), _textBounds, fontSize, &point, _caretLocation,
getTextAlignment(state), true, getTextRightToLeft(state));
SpriteBatch* batch = _style->getTheme()->getSpriteBatch();
startBatch(form, batch);
batch->draw(point.x - caretWidth * 0.5f, point.y, caretWidth, fontSize, uvs.u1, uvs.v1, uvs.u2, uvs.v2, color, _viewportClipBounds);
finishBatch(form, batch);
return 1;
}
}
return 0;
}
void TextBox::setCaretLocation(int x, int y)
{
Control::State state = getState();
Vector2 point(x + _absoluteBounds.x, y + _absoluteBounds.y);
// Get index into string and cursor location from the latest touch location.
Font* font = getFont(state);
unsigned int fontSize = getFontSize(state);
Font::Justify textAlignment = getTextAlignment(state);
bool rightToLeft = getTextRightToLeft(state);
const std::string displayedText = getDisplayedText();
int index = font->getIndexAtLocation(displayedText.c_str(), _textBounds, fontSize, point, &point,
textAlignment, true, rightToLeft);
if (index == -1)
{
// Attempt to find the nearest valid caret location.
Rectangle textBounds;
font->measureText(displayedText.c_str(), _textBounds, fontSize, &textBounds, textAlignment, true, true);
if (point.x > textBounds.x + textBounds.width &&
point.y > textBounds.y + textBounds.height)
{
font->getLocationAtIndex(displayedText.c_str(), _textBounds, fontSize, &point, (unsigned int)_text.length(),
textAlignment, true, rightToLeft);
return;
}
if (point.x < textBounds.x)
{
point.x = textBounds.x;
}
else if (point.x > textBounds.x + textBounds.width)
{
point.x = textBounds.x + textBounds.width;
}
if (point.y < textBounds.y)
{
point.y = textBounds.y;
}
else if (point.y > textBounds.y + textBounds.height)
{
Font* font = getFont(state);
GP_ASSERT(font);
unsigned int fontSize = getFontSize(state);
point.y = textBounds.y + textBounds.height - fontSize;
}
index = font->getIndexAtLocation(displayedText.c_str(), _textBounds, fontSize, point, &point,
textAlignment, true, rightToLeft);
}
if (index != -1)
_caretLocation = index;
}
unsigned int TextBox::drawText(Form* form, const Rectangle& clip)
{
if (_text.size() <= 0)
return 0;
// Draw the text.
if (_font)
{
Control::State state = getState();
const std::string displayedText = getDisplayedText();
unsigned int fontSize = getFontSize(state);
SpriteBatch* batch = _font->getSpriteBatch(fontSize);
startBatch(form, batch);
_font->drawText(displayedText.c_str(), _textBounds, _textColor, fontSize, getTextAlignment(state), true, getTextRightToLeft(state), _viewportClipBounds);
finishBatch(form, batch);
return 1;
}
return 0;
}
void UILineEdit::update()
{
std::string text = getDisplayedText();
int textLength = text.length();
// prevent glitches
if(m_rect.isEmpty())
return;
// map glyphs positions
Size textBoxSize;
const std::vector<Point>& glyphsPositions = m_font->calculateGlyphsPositions(text, m_align, &textBoxSize);
const Rect *glyphsTextureCoords = m_font->getGlyphsTextureCoords();
const Size *glyphsSize = m_font->getGlyphsSize();
int glyph;
// resize just on demand
if(textLength > (int)m_glyphsCoords.size()) {
m_glyphsCoords.resize(textLength);
m_glyphsTexCoords.resize(textLength);
}
// readjust start view area based on cursor position
if(m_cursorPos >= 0 && textLength > 0) {
assert(m_cursorPos <= textLength);
if(m_cursorPos < m_startRenderPos) // cursor is before the previuos first rendered glyph, so we need to update
{
m_startInternalPos.x = glyphsPositions[m_cursorPos].x;
m_startInternalPos.y = glyphsPositions[m_cursorPos].y - m_font->getYOffset();
m_startRenderPos = m_cursorPos;
} else if(m_cursorPos > m_startRenderPos || // cursor is after the previuos first rendered glyph
(m_cursorPos == m_startRenderPos && textLength == m_cursorPos)) // cursor is at the previuos rendered element, and is the last text element
{
Rect virtualRect(m_startInternalPos, m_rect.size() - Size(2*m_textHorizontalMargin, 0) ); // previous rendered virtual rect
int pos = m_cursorPos - 1; // element before cursor
glyph = (uchar)text[pos]; // glyph of the element before cursor
Rect glyphRect(glyphsPositions[pos], glyphsSize[glyph]);
// if the cursor is not on the previous rendered virtual rect we need to update it
if(!virtualRect.contains(glyphRect.topLeft()) || !virtualRect.contains(glyphRect.bottomRight())) {
// calculate where is the first glyph visible
Point startGlyphPos;
startGlyphPos.y = std::max(glyphRect.bottom() - virtualRect.height(), 0);
startGlyphPos.x = std::max(glyphRect.right() - virtualRect.width(), 0);
// find that glyph
for(pos = 0; pos < textLength; ++pos) {
glyph = (uchar)text[pos];
glyphRect = Rect(glyphsPositions[pos], glyphsSize[glyph]);
glyphRect.setTop(std::max(glyphRect.top() - m_font->getYOffset() - m_font->getGlyphSpacing().height(), 0));
glyphRect.setLeft(std::max(glyphRect.left() - m_font->getGlyphSpacing().width(), 0));
// first glyph entirely visible found
if(glyphRect.topLeft() >= startGlyphPos) {
m_startInternalPos.x = glyphsPositions[pos].x;
m_startInternalPos.y = glyphsPositions[pos].y - m_font->getYOffset();
m_startRenderPos = pos;
break;
}
}
}
}
} else {
m_startInternalPos = Point(0,0);
}
Rect textScreenCoords = m_rect;
textScreenCoords.addLeft(-m_textHorizontalMargin);
textScreenCoords.addRight(-m_textHorizontalMargin);
m_drawArea = textScreenCoords;
if(m_align & Fw::AlignBottom) {
m_drawArea.translate(0, textScreenCoords.height() - textBoxSize.height());
} else if(m_align & Fw::AlignVerticalCenter) {
m_drawArea.translate(0, (textScreenCoords.height() - textBoxSize.height()) / 2);
} else { // AlignTop
}
if(m_align & Fw::AlignRight) {
m_drawArea.translate(textScreenCoords.width() - textBoxSize.width(), 0);
} else if(m_align & Fw::AlignHorizontalCenter) {
m_drawArea.translate((textScreenCoords.width() - textBoxSize.width()) / 2, 0);
} else { // AlignLeft
}
for(int i = 0; i < textLength; ++i) {
glyph = (uchar)text[i];
m_glyphsCoords[i].clear();
// skip invalid glyphs
if(glyph < 32)
continue;
// calculate initial glyph rect and texture coords
Rect glyphScreenCoords(glyphsPositions[i], glyphsSize[glyph]);
Rect glyphTextureCoords = glyphsTextureCoords[glyph];
// first translate to align position
if(m_align & Fw::AlignBottom) {
glyphScreenCoords.translate(0, textScreenCoords.height() - textBoxSize.height());
} else if(m_align & Fw::AlignVerticalCenter) {
glyphScreenCoords.translate(0, (textScreenCoords.height() - textBoxSize.height()) / 2);
} else { // AlignTop
// nothing to do
}
if(m_align & Fw::AlignRight) {
glyphScreenCoords.translate(textScreenCoords.width() - textBoxSize.width(), 0);
} else if(m_align & Fw::AlignHorizontalCenter) {
glyphScreenCoords.translate((textScreenCoords.width() - textBoxSize.width()) / 2, 0);
} else { // AlignLeft
// nothing to do
}
// only render glyphs that are after startRenderPosition
if(glyphScreenCoords.bottom() < m_startInternalPos.y || glyphScreenCoords.right() < m_startInternalPos.x)
continue;
// bound glyph topLeft to startRenderPosition
if(glyphScreenCoords.top() < m_startInternalPos.y) {
glyphTextureCoords.setTop(glyphTextureCoords.top() + (m_startInternalPos.y - glyphScreenCoords.top()));
glyphScreenCoords.setTop(m_startInternalPos.y);
}
if(glyphScreenCoords.left() < m_startInternalPos.x) {
glyphTextureCoords.setLeft(glyphTextureCoords.left() + (m_startInternalPos.x - glyphScreenCoords.left()));
glyphScreenCoords.setLeft(m_startInternalPos.x);
}
// subtract startInternalPos
glyphScreenCoords.translate(-m_startInternalPos);
// translate rect to screen coords
glyphScreenCoords.translate(textScreenCoords.topLeft());
// only render if glyph rect is visible on screenCoords
if(!textScreenCoords.intersects(glyphScreenCoords))
continue;
// bound glyph bottomRight to screenCoords bottomRight
if(glyphScreenCoords.bottom() > textScreenCoords.bottom()) {
glyphTextureCoords.setBottom(glyphTextureCoords.bottom() + (textScreenCoords.bottom() - glyphScreenCoords.bottom()));
glyphScreenCoords.setBottom(textScreenCoords.bottom());
}
if(glyphScreenCoords.right() > textScreenCoords.right()) {
glyphTextureCoords.setRight(glyphTextureCoords.right() + (textScreenCoords.right() - glyphScreenCoords.right()));
glyphScreenCoords.setRight(textScreenCoords.right());
}
// render glyph
m_glyphsCoords[i] = glyphScreenCoords;
m_glyphsTexCoords[i] = glyphTextureCoords;
}
}
void UITextEdit::update(bool focusCursor)
{
if(!m_updatesEnabled)
return;
std::string text = getDisplayedText();
m_drawText = text;
int textLength = text.length();
// prevent glitches
if(m_rect.isEmpty())
return;
// map glyphs positions
Size textBoxSize;
const std::vector<Point>& glyphsPositions = m_font->calculateGlyphsPositions(text, m_textAlign, &textBoxSize);
const Rect *glyphsTextureCoords = m_font->getGlyphsTextureCoords();
const Size *glyphsSize = m_font->getGlyphsSize();
int glyph;
// update rect size
if(!m_rect.isValid() || m_textHorizontalAutoResize || m_textVerticalAutoResize) {
textBoxSize += Size(m_padding.left + m_padding.right, m_padding.top + m_padding.bottom) + m_textOffset.toSize();
Size size = getSize();
if(size.width() <= 0 || (m_textHorizontalAutoResize && !m_textWrap))
size.setWidth(textBoxSize.width());
if(size.height() <= 0 || m_textVerticalAutoResize)
size.setHeight(textBoxSize.height());
setSize(size);
}
// resize just on demand
if(textLength > (int)m_glyphsCoords.size()) {
m_glyphsCoords.resize(textLength);
m_glyphsTexCoords.resize(textLength);
}
Point oldTextAreaOffset = m_textVirtualOffset;
if(textBoxSize.width() <= getPaddingRect().width())
m_textVirtualOffset.x = 0;
if(textBoxSize.height() <= getPaddingRect().height())
m_textVirtualOffset.y = 0;
// readjust start view area based on cursor position
m_cursorInRange = false;
if(focusCursor && m_autoScroll) {
if(m_cursorPos > 0 && textLength > 0) {
assert(m_cursorPos <= textLength);
Rect virtualRect(m_textVirtualOffset, m_rect.size() - Size(m_padding.left+m_padding.right, 0)); // previous rendered virtual rect
int pos = m_cursorPos - 1; // element before cursor
glyph = (uchar)text[pos]; // glyph of the element before cursor
Rect glyphRect(glyphsPositions[pos], glyphsSize[glyph]);
// if the cursor is not on the previous rendered virtual rect we need to update it
if(!virtualRect.contains(glyphRect.topLeft()) || !virtualRect.contains(glyphRect.bottomRight())) {
// calculate where is the first glyph visible
Point startGlyphPos;
startGlyphPos.y = std::max(glyphRect.bottom() - virtualRect.height(), 0);
startGlyphPos.x = std::max(glyphRect.right() - virtualRect.width(), 0);
// find that glyph
for(pos = 0; pos < textLength; ++pos) {
glyph = (uchar)text[pos];
glyphRect = Rect(glyphsPositions[pos], glyphsSize[glyph]);
glyphRect.setTop(std::max(glyphRect.top() - m_font->getYOffset() - m_font->getGlyphSpacing().height(), 0));
glyphRect.setLeft(std::max(glyphRect.left() - m_font->getGlyphSpacing().width(), 0));
// first glyph entirely visible found
if(glyphRect.topLeft() >= startGlyphPos) {
m_textVirtualOffset.x = glyphsPositions[pos].x;
m_textVirtualOffset.y = glyphsPositions[pos].y - m_font->getYOffset();
break;
}
}
}
} else {
m_textVirtualOffset = Point(0,0);
}
m_cursorInRange = true;
} else {
if(m_cursorPos > 0 && textLength > 0) {
Rect virtualRect(m_textVirtualOffset, m_rect.size() - Size(2*m_padding.left+m_padding.right, 0) ); // previous rendered virtual rect
int pos = m_cursorPos - 1; // element before cursor
glyph = (uchar)text[pos]; // glyph of the element before cursor
Rect glyphRect(glyphsPositions[pos], glyphsSize[glyph]);
if(virtualRect.contains(glyphRect.topLeft()) && virtualRect.contains(glyphRect.bottomRight()))
m_cursorInRange = true;
} else {
m_cursorInRange = true;
}
}
bool fireAreaUpdate = false;
if(oldTextAreaOffset != m_textVirtualOffset)
fireAreaUpdate = true;
Rect textScreenCoords = m_rect;
textScreenCoords.expandLeft(-m_padding.left);
textScreenCoords.expandRight(-m_padding.right);
textScreenCoords.expandBottom(-m_padding.bottom);
textScreenCoords.expandTop(-m_padding.top);
m_drawArea = textScreenCoords;
if(textScreenCoords.size() != m_textVirtualSize) {
m_textVirtualSize = textScreenCoords.size();
fireAreaUpdate = true;
}
Size totalSize = textBoxSize;
if(totalSize.width() < m_textVirtualSize.width())
totalSize.setWidth(m_textVirtualSize.height());
if(totalSize.height() < m_textVirtualSize.height())
totalSize.setHeight(m_textVirtualSize.height());
if(m_textTotalSize != totalSize) {
m_textTotalSize = totalSize;
fireAreaUpdate = true;
}
if(m_textAlign & Fw::AlignBottom) {
m_drawArea.translate(0, textScreenCoords.height() - textBoxSize.height());
} else if(m_textAlign & Fw::AlignVerticalCenter) {
m_drawArea.translate(0, (textScreenCoords.height() - textBoxSize.height()) / 2);
} else { // AlignTop
}
if(m_textAlign & Fw::AlignRight) {
m_drawArea.translate(textScreenCoords.width() - textBoxSize.width(), 0);
} else if(m_textAlign & Fw::AlignHorizontalCenter) {
m_drawArea.translate((textScreenCoords.width() - textBoxSize.width()) / 2, 0);
} else { // AlignLeft
}
for(int i = 0; i < textLength; ++i) {
glyph = (uchar)text[i];
m_glyphsCoords[i].clear();
// skip invalid glyphs
if(glyph < 32 && glyph != (uchar)'\n')
continue;
// calculate initial glyph rect and texture coords
Rect glyphScreenCoords(glyphsPositions[i], glyphsSize[glyph]);
Rect glyphTextureCoords = glyphsTextureCoords[glyph];
// first translate to align position
if(m_textAlign & Fw::AlignBottom) {
glyphScreenCoords.translate(0, textScreenCoords.height() - textBoxSize.height());
} else if(m_textAlign & Fw::AlignVerticalCenter) {
glyphScreenCoords.translate(0, (textScreenCoords.height() - textBoxSize.height()) / 2);
} else { // AlignTop
// nothing to do
}
if(m_textAlign & Fw::AlignRight) {
glyphScreenCoords.translate(textScreenCoords.width() - textBoxSize.width(), 0);
} else if(m_textAlign & Fw::AlignHorizontalCenter) {
glyphScreenCoords.translate((textScreenCoords.width() - textBoxSize.width()) / 2, 0);
} else { // AlignLeft
// nothing to do
}
// only render glyphs that are after startRenderPosition
if(glyphScreenCoords.bottom() < m_textVirtualOffset.y || glyphScreenCoords.right() < m_textVirtualOffset.x)
continue;
// bound glyph topLeft to startRenderPosition
if(glyphScreenCoords.top() < m_textVirtualOffset.y) {
glyphTextureCoords.setTop(glyphTextureCoords.top() + (m_textVirtualOffset.y - glyphScreenCoords.top()));
glyphScreenCoords.setTop(m_textVirtualOffset.y);
}
if(glyphScreenCoords.left() < m_textVirtualOffset.x) {
glyphTextureCoords.setLeft(glyphTextureCoords.left() + (m_textVirtualOffset.x - glyphScreenCoords.left()));
glyphScreenCoords.setLeft(m_textVirtualOffset.x);
}
// subtract startInternalPos
glyphScreenCoords.translate(-m_textVirtualOffset);
// translate rect to screen coords
glyphScreenCoords.translate(textScreenCoords.topLeft());
// only render if glyph rect is visible on screenCoords
if(!textScreenCoords.intersects(glyphScreenCoords))
continue;
// bound glyph bottomRight to screenCoords bottomRight
if(glyphScreenCoords.bottom() > textScreenCoords.bottom()) {
glyphTextureCoords.setBottom(glyphTextureCoords.bottom() + (textScreenCoords.bottom() - glyphScreenCoords.bottom()));
glyphScreenCoords.setBottom(textScreenCoords.bottom());
}
if(glyphScreenCoords.right() > textScreenCoords.right()) {
glyphTextureCoords.setRight(glyphTextureCoords.right() + (textScreenCoords.right() - glyphScreenCoords.right()));
glyphScreenCoords.setRight(textScreenCoords.right());
}
// render glyph
m_glyphsCoords[i] = glyphScreenCoords;
m_glyphsTexCoords[i] = glyphTextureCoords;
}
if(fireAreaUpdate)
onTextAreaUpdate(m_textVirtualOffset, m_textVirtualSize, m_textTotalSize);
g_app.repaint();
}
bool TextBox::keyEvent(Keyboard::KeyEvent evt, int key)
{
switch (evt)
{
case Keyboard::KEY_PRESS:
{
switch (key)
{
case Keyboard::KEY_SHIFT:
{
_shiftPressed = true;
break;
}
case Keyboard::KEY_CTRL:
{
_ctrlPressed = true;
break;
}
case Keyboard::KEY_HOME:
{
_caretLocation = 0;
break;
}
case Keyboard::KEY_END:
{
_caretLocation = _text.length();
break;
}
case Keyboard::KEY_DELETE:
{
if (_caretLocation < _text.length())
{
int newCaretLocation;
if (_ctrlPressed)
{
newCaretLocation = findNextWord(getDisplayedText(), _caretLocation, false);
}
else
{
newCaretLocation = _caretLocation + 1;
}
_text.erase(_caretLocation, newCaretLocation - _caretLocation);
notifyListeners(Control::Listener::TEXT_CHANGED);
}
break;
}
case Keyboard::KEY_TAB:
{
// Allow tab to move the focus forward.
return false;
}
case Keyboard::KEY_LEFT_ARROW:
{
if (_caretLocation > 0)
{
if (_ctrlPressed)
{
_caretLocation = findNextWord(getDisplayedText(), _caretLocation, true);
}
else
{
--_caretLocation;
}
}
break;
}
case Keyboard::KEY_RIGHT_ARROW:
{
if (_caretLocation < _text.length())
{
if (_ctrlPressed)
{
_caretLocation = findNextWord(getDisplayedText(), _caretLocation, false);
}
else
{
++_caretLocation;
}
}
break;
}
case Keyboard::KEY_UP_ARROW:
{
// TODO: Support multiline
break;
}
case Keyboard::KEY_DOWN_ARROW:
{
// TODO: Support multiline
break;
}
case Keyboard::KEY_BACKSPACE:
{
if (_caretLocation > 0)
{
int newCaretLocation;
if (_ctrlPressed)
{
newCaretLocation = findNextWord(getDisplayedText(), _caretLocation, true);
}
else
{
newCaretLocation = _caretLocation - 1;
}
_text.erase(newCaretLocation, _caretLocation - newCaretLocation);
_caretLocation = newCaretLocation;
notifyListeners(Control::Listener::TEXT_CHANGED);
}
break;
}
}
break;
}
case Keyboard::KEY_CHAR:
{
switch (key)
{
case Keyboard::KEY_RETURN:
// TODO: Support multi-line
break;
case Keyboard::KEY_ESCAPE:
break;
case Keyboard::KEY_BACKSPACE:
break;
case Keyboard::KEY_TAB:
// Allow tab to move the focus forward.
return false;
default:
{
// Insert character into string, only if our font supports this character
if (_shiftPressed && islower(key))
{
key = toupper(key);
}
// Insert character into string, only if our font supports this character
if (_font && _font->isCharacterSupported(key))
{
if (_caretLocation <= _text.length())
{
_text.insert(_caretLocation, 1, (char)key);
++_caretLocation;
}
notifyListeners(Control::Listener::TEXT_CHANGED);
}
break;
}
break;
}
break;
}
case Keyboard::KEY_RELEASE:
switch (key)
{
case Keyboard::KEY_SHIFT:
{
_shiftPressed = false;
break;
}
case Keyboard::KEY_CTRL:
{
_ctrlPressed = false;
break;
}
}
}
_lastKeypress = key;
return Label::keyEvent(evt, key);
}
