//----------------------------------------------------------------------------//
void Editbox::onCharacter(KeyEventArgs& e)
{
// NB: We are not calling the base class handler here because it propogates
// inputs back up the window hierarchy, whereas, as a consumer of key
// events, we want such propogation to cease with us regardless of whether
// we actually handle the event.
// fire event.
fireEvent(EventCharacterKey, e, Window::EventNamespace);
// only need to take notice if we have focus
if (e.handled == 0 && hasInputFocus() && !isReadOnly() &&
getFont()->isCodepointAvailable(e.codepoint))
{
// backup current text
String tmp(getText());
tmp.erase(getSelectionStartIndex(), getSelectionLength());
// if there is room
if (tmp.length() < d_maxTextLen)
{
tmp.insert(getSelectionStartIndex(), 1, e.codepoint);
if (handleValidityChangeForString(tmp))
{
// erase selection using mode that does not modify getText()
// (we just want to update state)
eraseSelectedText(false);
// advance caret (done first so we can "do stuff" in event
// handlers!)
d_caretPos++;
// set text to the newly modified string
setText(tmp);
// char was accepted into the Editbox - mark event as handled.
++e.handled;
}
}
else
{
// Trigger text box full event
WindowEventArgs args(this);
onEditboxFullEvent(args);
}
}
// event was (possibly) not handled
}
//----------------------------------------------------------------------------//
void Editbox::handleDelete(void)
{
if (!isReadOnly())
{
String tmp(getText());
if (getSelectionLength() != 0)
{
tmp.erase(getSelectionStartIndex(), getSelectionLength());
if (handleValidityChangeForString(tmp))
{
// erase selection using mode that does not modify getText()
// (we just want to update state)
eraseSelectedText(false);
// set text to the newly modified string
setText(tmp);
}
}
else if (getCaretIndex() < tmp.length())
{
tmp.erase(d_caretPos, 1);
if (handleValidityChangeForString(tmp))
{
// set text to the newly modified string
setText(tmp);
}
}
}
}
//----------------------------------------------------------------------------//
bool Editbox::performCopy(Clipboard& clipboard)
{
if (getSelectionLength() == 0)
return false;
const String selectedText = getText().substr(
getSelectionStartIndex(), getSelectionLength());
clipboard.setText(selectedText);
return true;
}
/*************************************************************************
Erase the currently selected text.
*************************************************************************/
void MultiLineEditbox::eraseSelectedText(bool modify_text)
{
if (getSelectionLength() != 0)
{
// setup new carat position and remove selection highlight.
setCaratIndex(getSelectionStartIndex());
// erase the selected characters (if required)
if (modify_text)
{
d_text.erase(getSelectionStartIndex(), getSelectionLength());
// trigger notification that text has changed.
WindowEventArgs args(this);
onTextChanged(args);
}
clearSelection();
}
}
//----------------------------------------------------------------------------//
bool Editbox::performPaste(Clipboard& clipboard)
{
if (isReadOnly())
return false;
String clipboardText = clipboard.getText();
if (clipboardText.empty())
return false;
// backup current text
String tmp(getText());
tmp.erase(getSelectionStartIndex(), getSelectionLength());
// if there is room
if (tmp.length() < d_maxTextLen)
{
tmp.insert(getSelectionStartIndex(), clipboardText);
if (handleValidityChangeForString(tmp))
{
// erase selection using mode that does not modify getText()
// (we just want to update state)
eraseSelectedText(false);
// advance caret (done first so we can "do stuff" in event
// handlers!)
d_caretPos += clipboardText.length();
// set text to the newly modified string
setText(tmp);
return true;
}
}
return false;
}
void FalagardEditbox::populateRenderCache()
{
const StateImagery* imagery;
// draw container etc
// get WidgetLookFeel for the assigned look.
const WidgetLookFeel& wlf = WidgetLookManager::getSingleton().getWidgetLook(d_lookName);
// try and get imagery for the approprite state.
imagery = &wlf.getStateImagery(isDisabled() ? "Disabled" : (isReadOnly() ? "ReadOnly" : "Enabled"));
// peform the rendering operation for the container.
imagery->render(*this);
// get destination area for text
const Rect textArea(wlf.getNamedArea("TextArea").getArea().getPixelRect(*this));
//
// Required preliminary work for text rendering operations
//
const Font* font = getFont();
// no font == no more rendering
if (!font)
return;
// This will point to the final string to be used for rendering. Useful because it means we
// do not have to have duplicate code or be copying d_text for handling masked/unmasked text.
String* editText;
// Create a 'masked' version of the string if needed.
String maskedText;
if (isTextMasked())
{
maskedText.insert(0, d_text.length(), getMaskCodePoint());
editText = &maskedText;
}
// text not masked to editText will be the windows d_text String.
else
{
editText = &d_text;
}
// calculate best position to render text to ensure carat is always visible
float textOffset;
float extentToCarat = font->getTextExtent(editText->substr(0, getCaratIndex()));
// get carat imagery
const ImagerySection& caratImagery = wlf.getImagerySection("Carat");
// store carat width
float caratWidth = caratImagery.getBoundingRect(*this, textArea).getWidth();
// if box is inactive
if (!hasInputFocus())
{
textOffset = d_lastTextOffset;
}
// if carat is to the left of the box
else if ((d_lastTextOffset + extentToCarat) < 0)
{
textOffset = -extentToCarat;
}
// if carat is off to the right.
else if ((d_lastTextOffset + extentToCarat) >= (textArea.getWidth() - caratWidth))
{
textOffset = textArea.getWidth() - extentToCarat - caratWidth;
}
// else carat is already within the box
else
{
textOffset = d_lastTextOffset;
}
ColourRect colours;
float alpha_comp = getEffectiveAlpha();
//
// Draw label text
//
// setup initial rect for text formatting
Rect text_part_rect(textArea);
// allow for scroll position
text_part_rect.d_left += textOffset;
// centre text vertically within the defined text area
text_part_rect.d_top += (textArea.getHeight() - font->getLineSpacing()) * 0.5f;
// draw pre-highlight text
String sect = editText->substr(0, getSelectionStartIndex());
colours.setColours(d_normalTextColour);
colours.modulateAlpha(alpha_comp);
d_renderCache.cacheText(sect, font, LeftAligned, text_part_rect, 0, colours, &textArea);
// adjust rect for next section
text_part_rect.d_left += font->getTextExtent(sect);
// draw highlight text
sect = editText->substr(getSelectionStartIndex(), getSelectionLength());
colours.setColours(d_selectTextColour);
colours.modulateAlpha(alpha_comp);
d_renderCache.cacheText(sect, font, LeftAligned, text_part_rect, 0, colours, &textArea);
// adjust rect for next section
text_part_rect.d_left += font->getTextExtent(sect);
// draw post-highlight text
sect = editText->substr(getSelectionEndIndex());
colours.setColours(d_normalTextColour);
colours.modulateAlpha(alpha_comp);
d_renderCache.cacheText(sect, font, LeftAligned, text_part_rect, 0, colours, &textArea);
// remember this for next time.
d_lastTextOffset = textOffset;
// see if the editbox is active or inactive.
bool active = (!isReadOnly()) && hasInputFocus();
//
// Render selection imagery.
//
if (getSelectionLength() != 0)
{
// calculate required start and end offsets of selection imagery.
float selStartOffset = font->getTextExtent(editText->substr(0, getSelectionStartIndex()));
float selEndOffset = font->getTextExtent(editText->substr(0, getSelectionEndIndex()));
// calculate area for selection imagery.
Rect hlarea(textArea);
hlarea.d_left += textOffset + selStartOffset;
hlarea.d_right = hlarea.d_left + (selEndOffset - selStartOffset);
// render the selection imagery.
wlf.getStateImagery(active ? "ActiveSelection" : "InactiveSelection").render(*this, hlarea, 0, &textArea);
}
//
// Render carat
//
if (active)
{
Rect caratRect(textArea);
caratRect.d_left += extentToCarat + textOffset;
caratImagery.render(*this, caratRect, 0, 0, &textArea);
}
}
