//----------------------------------------------------------------------------// 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); } }