/** * @file llexpandabletextbox.cpp * @brief LLExpandableTextBox and related class implementations * * $LicenseInfo:firstyear=2004&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "llexpandabletextbox.h" #include "llscrollcontainer.h" #include "lltrans.h" #include "llwindow.h" #include "llviewerwindow.h" static LLDefaultChildRegistry::Register<LLExpandableTextBox> t1("expandable_text"); class LLExpanderSegment : public LLTextSegment { public: LLExpanderSegment(const LLStyleSP& style, S32 start, S32 end, const std::string& more_text, LLTextBase& editor ) : LLTextSegment(start, end), mEditor(editor), mStyle(style), mExpanderLabel(utf8str_to_wstring(more_text)) { } /*virtual*/ LLTextSegmentPtr clone(LLTextBase& target) const { LLStyleSP sp((&target == &mEditor) ? mStyle : mStyle->clone()); LLExpanderSegment* copy = new LLExpanderSegment(sp, mStart, mEnd, LLStringUtil::null, target); copy->mExpanderLabel = mExpanderLabel; return copy; } /*virtual*/ bool getDimensionsF32(S32 first_char, S32 num_chars, F32& width, S32& height) const { // more label always spans width of text box if (num_chars == 0) { width = 0; height = 0; } else { width = (F32)(mEditor.getDocumentView()->getRect().getWidth() - mEditor.getHPad()); height = mStyle->getFont()->getLineHeight(); } return true; } /*virtual*/ S32 getOffset(S32 segment_local_x_coord, S32 start_offset, S32 num_chars, bool round) const { return start_offset; } /*virtual*/ S32 getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars, S32 line_ind) const { // require full line to ourselves if (line_offset == 0) { // print all our text return getEnd() - getStart(); } else { // wait for next line return 0; } } /*virtual*/ F32 draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect) { F32 right_x; mStyle->getFont()->render(mExpanderLabel, start, draw_rect.mRight, draw_rect.mTop, mStyle->getColor(), LLFontGL::RIGHT, LLFontGL::TOP, 0, mStyle->getShadowType(), end - start, (S32)draw_rect.getWidth(), &right_x, mEditor.getUseEllipses(), mEditor.getUseColor()); return right_x; } /*virtual*/ bool canEdit() const { return false; } // eat handleMouseDown event so we get the mouseup event /*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask) { return true; } /*virtual*/ bool handleMouseUp(S32 x, S32 y, MASK mask) { mEditor.onCommit(); return true; } /*virtual*/ bool handleHover(S32 x, S32 y, MASK mask) { LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND); return true; } private: LLTextBase& mEditor; LLStyleSP mStyle; LLWString mExpanderLabel; }; LLExpandableTextBox::LLTextBoxEx::Params::Params() { } LLExpandableTextBox::LLTextBoxEx::LLTextBoxEx(const Params& p) : LLTextEditor(p), mExpanderLabel(p.label.isProvided() ? p.label : LLTrans::getString("More")), mExpanderVisible(false) { setIsChrome(true); setMaxTextLength(p.max_text_length); } void LLExpandableTextBox::LLTextBoxEx::reshape(S32 width, S32 height, bool called_from_parent) { LLTextEditor::reshape(width, height, called_from_parent); } void LLExpandableTextBox::LLTextBoxEx::setText(const LLStringExplicit& text,const LLStyle::Params& input_params) { // LLTextBox::setText will obliterate the expander segment, so make sure // we generate it again by clearing mExpanderVisible mExpanderVisible = false; LLTextEditor::setText(text, input_params); hideOrShowExpandTextAsNeeded(); } void LLExpandableTextBox::LLTextBoxEx::showExpandText() { if (!mExpanderVisible) { // make sure we're scrolled to top when collapsing if (mScroller) { mScroller->goToTop(); } // get fully visible lines std::pair<S32, S32> visible_lines = getVisibleLines(true); S32 last_line = visible_lines.second - 1; LLStyle::Params expander_style(getStyleParams()); expander_style.font.style = "UNDERLINE"; expander_style.color = LLUIColorTable::instance().getColor("HTMLLinkColor"); LLExpanderSegment* expanderp = new LLExpanderSegment(new LLStyle(expander_style), getLineStart(last_line), getLength() + 1, mExpanderLabel, *this); insertSegment(expanderp); mExpanderVisible = true; } } //NOTE: obliterates existing styles (including hyperlinks) void LLExpandableTextBox::LLTextBoxEx::hideExpandText() { if (mExpanderVisible) { // this will overwrite the expander segment and all text styling with a single style LLStyleConstSP sp(new LLStyle(getStyleParams())); LLNormalTextSegment* segmentp = new LLNormalTextSegment(sp, 0, getLength() + 1, *this); insertSegment(segmentp); mExpanderVisible = false; } } S32 LLExpandableTextBox::LLTextBoxEx::getVerticalTextDelta() { S32 text_height = getTextPixelHeight(); S32 textbox_height = getRect().getHeight(); return text_height - textbox_height; } S32 LLExpandableTextBox::LLTextBoxEx::getTextPixelHeight() { return getTextBoundingRect().getHeight(); } void LLExpandableTextBox::LLTextBoxEx::hideOrShowExpandTextAsNeeded() { // Restore the text box contents to calculate the text height properly, // otherwise if a part of the text is hidden under "More" link // getTextPixelHeight() returns only the height of currently visible text // including the "More" link. See STORM-250. hideExpandText(); // Show the expander a.k.a. "More" link if we need it, depending on text // contents height. If not, keep it hidden. if (getTextPixelHeight() > getRect().getHeight()) { showExpandText(); } } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// LLExpandableTextBox::Params::Params() : textbox("textbox"), scroll("scroll"), max_height("max_height", 0), bg_visible("bg_visible", false), expanded_bg_visible("expanded_bg_visible", true), bg_color("bg_color", LLColor4::black), expanded_bg_color("expanded_bg_color", LLColor4::black) { } LLExpandableTextBox::LLExpandableTextBox(const Params& p) : LLUICtrl(p), mMaxHeight(p.max_height), mBGVisible(p.bg_visible), mExpandedBGVisible(p.expanded_bg_visible), mBGColor(p.bg_color), mExpandedBGColor(p.expanded_bg_color), mExpanded(false) { LLRect rc = getLocalRect(); LLScrollContainer::Params scroll_params = p.scroll; scroll_params.rect(rc); mScroll = LLUICtrlFactory::create<LLScrollContainer>(scroll_params); addChild(mScroll); LLTextBoxEx::Params textbox_params = p.textbox; textbox_params.rect(rc); mTextBox = LLUICtrlFactory::create<LLTextBoxEx>(textbox_params); mTextBox->setContentTrusted(false); mScroll->addChild(mTextBox); updateTextBoxRect(); mTextBox->setCommitCallback(boost::bind(&LLExpandableTextBox::onExpandClicked, this)); } LLExpandableTextBox::~LLExpandableTextBox() { gViewerWindow->removePopup(this); } void LLExpandableTextBox::draw() { if(mBGVisible && !mExpanded) { gl_rect_2d(getLocalRect(), mBGColor.get(), true); } if(mExpandedBGVisible && mExpanded) { gl_rect_2d(getLocalRect(), mExpandedBGColor.get(), true); } collapseIfPosChanged(); LLUICtrl::draw(); } void LLExpandableTextBox::setContentTrusted(bool trusted_content) { mTextBox->setContentTrusted(trusted_content); } void LLExpandableTextBox::collapseIfPosChanged() { if(mExpanded) { LLView* parentp = getParent(); LLRect parent_rect = parentp->getRect(); parentp->localRectToOtherView(parent_rect, &parent_rect, getRootView()); if(parent_rect.mLeft != mParentRect.mLeft || parent_rect.mTop != mParentRect.mTop) { collapseTextBox(); } } } void LLExpandableTextBox::onExpandClicked() { expandTextBox(); } void LLExpandableTextBox::updateTextBoxRect() { LLRect rc = getLocalRect(); rc.mLeft += mScroll->getBorderWidth(); rc.mRight -= mScroll->getBorderWidth(); rc.mTop -= mScroll->getBorderWidth(); rc.mBottom += mScroll->getBorderWidth(); mTextBox->reshape(rc.getWidth(), rc.getHeight()); mTextBox->setRect(rc); // *HACK // hideExpandText brakes text styles (replaces hyper-links with plain text), see ticket EXT-3290 // Also text segments are not removed properly. Same issue at expandTextBox(). // So set text again to make text box re-apply styles and clear segments. // *TODO Find a solution that does not involve text segment. mTextBox->setText(mText); } S32 LLExpandableTextBox::recalculateTextDelta(S32 text_delta) { LLRect expanded_rect = getLocalRect(); LLView* root_view = getRootView(); LLRect window_rect = root_view->getRect(); LLRect expanded_screen_rect; localRectToOtherView(expanded_rect, &expanded_screen_rect, root_view); // don't allow expanded text box bottom go off screen if(expanded_screen_rect.mBottom - text_delta < window_rect.mBottom) { text_delta = expanded_screen_rect.mBottom - window_rect.mBottom; } // show scroll bar if max_height is valid // and expanded size is greater that max_height else if(mMaxHeight > 0 && expanded_rect.getHeight() + text_delta > mMaxHeight) { text_delta = mMaxHeight - expanded_rect.getHeight(); } return text_delta; } void LLExpandableTextBox::expandTextBox() { // hide "more" link, and show full text contents mTextBox->hideExpandText(); // *HACK dz // hideExpandText brakes text styles (replaces hyper-links with plain text), see ticket EXT-3290 // Set text again to make text box re-apply styles. // *TODO Find proper solution to fix this issue. // Maybe add removeSegment to LLTextBase mTextBox->setTextBase(mText); S32 text_delta = mTextBox->getVerticalTextDelta(); text_delta += mTextBox->getVPad() * 2; text_delta += mScroll->getBorderWidth() * 2; // no need to expand if(text_delta <= 0) { return; } saveCollapsedState(); LLRect expanded_rect = getLocalRect(); LLRect expanded_screen_rect; S32 updated_text_delta = recalculateTextDelta(text_delta); // actual expand expanded_rect.mBottom -= updated_text_delta; LLRect text_box_rect = mTextBox->getRect(); // check if we need to show scrollbar if(text_delta != updated_text_delta) { static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0); // disable horizontal scrollbar text_box_rect.mRight -= scrollbar_size; // text box size has changed - redo text wrap // Should be handled automatically in reshape() below. JC //mTextBox->setWrappedText(mText, text_box_rect.getWidth()); // recalculate text delta since text wrap changed text height text_delta = mTextBox->getVerticalTextDelta() + mTextBox->getVPad() * 2; } // expand text text_box_rect.mBottom -= text_delta; mTextBox->reshape(text_box_rect.getWidth(), text_box_rect.getHeight()); mTextBox->setRect(text_box_rect); // expand text box localRectToOtherView(expanded_rect, &expanded_screen_rect, getParent()); reshape(expanded_screen_rect.getWidth(), expanded_screen_rect.getHeight(), false); setRect(expanded_screen_rect); setFocus(true); // this lets us receive top_lost event(needed to collapse text box) // it also draws text box above all other ui elements gViewerWindow->addPopup(this); mExpanded = true; } void LLExpandableTextBox::collapseTextBox() { if(!mExpanded) { return; } mExpanded = false; reshape(mCollapsedRect.getWidth(), mCollapsedRect.getHeight(), false); setRect(mCollapsedRect); updateTextBoxRect(); gViewerWindow->removePopup(this); } void LLExpandableTextBox::onFocusLost() { collapseTextBox(); LLUICtrl::onFocusLost(); } void LLExpandableTextBox::onTopLost() { collapseTextBox(); LLUICtrl::onTopLost(); } void LLExpandableTextBox::updateTextShape() { llassert(!mExpanded); updateTextBoxRect(); } void LLExpandableTextBox::reshape(S32 width, S32 height, bool called_from_parent) { mExpanded = false; LLUICtrl::reshape(width, height, called_from_parent); updateTextBoxRect(); } void LLExpandableTextBox::setValue(const LLSD& value) { collapseTextBox(); mText = value.asString(); mTextBox->setValue(value); } void LLExpandableTextBox::setText(const std::string& str) { collapseTextBox(); mText = str; mTextBox->setText(str); } void LLExpandableTextBox::saveCollapsedState() { mCollapsedRect = getRect(); mParentRect = getParent()->getRect(); // convert parent rect to screen coordinates, // this will allow to track parent's position change getParent()->localRectToOtherView(mParentRect, &mParentRect, getRootView()); }