path: root/indra/llui/lltextbase.cpp

/**
 * @file lltextbase.cpp
 * @author Martin Reddy
 * @brief The base class of text box/editor, providing Url handling support
 *
 * $LicenseInfo:firstyear=2009&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2009-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 "linden_common.h"

#include "lltextbase.h"

#include "llemojidictionary.h"
#include "llemojihelper.h"
#include "lllocalcliprect.h"
#include "llmenugl.h"
#include "llscrollcontainer.h"
#include "llspellcheck.h"
#include "llstl.h"
#include "lltextparser.h"
#include "lltextutil.h"
#include "lltooltip.h"
#include "lltrans.h"
#include "lluictrl.h"
#include "llurlaction.h"
#include "llurlregistry.h"
#include "llview.h"
#include "llwindow.h"
#include <boost/bind.hpp>

const F32   CURSOR_FLASH_DELAY = 1.0f;  // in seconds
const S32   CURSOR_THICKNESS = 2;
const F32   TRIPLE_CLICK_INTERVAL = 0.3f;   // delay between double and triple click.

LLTextBase::line_info::line_info(S32 index_start, S32 index_end, LLRect rect, S32 line_num)
:   mDocIndexStart(index_start),
    mDocIndexEnd(index_end),
    mRect(rect),
    mLineNum(line_num)
{}

bool LLTextBase::compare_segment_end::operator()(const LLTextSegmentPtr& a, const LLTextSegmentPtr& b) const
{
    // sort empty spans (e.g. 11-11) after previous non-empty spans (e.g. 5-11)
    if (a->getEnd() == b->getEnd())
    {
        return a->getStart() < b->getStart();
    }
    else
    {
        return a->getEnd() < b->getEnd();
    }
}


// helper functors
bool LLTextBase::compare_bottom::operator()(const S32& a, const LLTextBase::line_info& b) const
{
    return a > b.mRect.mBottom; // bottom of a is higher than bottom of b
}

bool LLTextBase::compare_bottom::operator()(const LLTextBase::line_info& a, const S32& b) const
{
    return a.mRect.mBottom > b; // bottom of a is higher than bottom of b
}

bool LLTextBase::compare_bottom::operator()(const LLTextBase::line_info& a, const LLTextBase::line_info& b) const
{
    return a.mRect.mBottom > b.mRect.mBottom; // bottom of a is higher than bottom of b
}

// helper functors
bool LLTextBase::compare_top::operator()(const S32& a, const LLTextBase::line_info& b) const
{
    return a > b.mRect.mTop; // top of a is higher than top of b
}

bool LLTextBase::compare_top::operator()(const LLTextBase::line_info& a, const S32& b) const
{
    return a.mRect.mTop > b; // top of a is higher than top of b
}

bool LLTextBase::compare_top::operator()(const LLTextBase::line_info& a, const LLTextBase::line_info& b) const
{
    return a.mRect.mTop > b.mRect.mTop; // top of a is higher than top of b
}

struct LLTextBase::line_end_compare
{
    bool operator()(const S32& pos, const LLTextBase::line_info& info) const
    {
        return (pos < info.mDocIndexEnd);
    }

    bool operator()(const LLTextBase::line_info& info, const S32& pos) const
    {
        return (info.mDocIndexEnd < pos);
    }

    bool operator()(const LLTextBase::line_info& a, const LLTextBase::line_info& b) const
    {
        return (a.mDocIndexEnd < b.mDocIndexEnd);
    }

};

//////////////////////////////////////////////////////////////////////////
//
// LLTextBase
//

// register LLTextBase::Params under name "textbase"
static LLWidgetNameRegistry::StaticRegistrar sRegisterTextBaseParams(&typeid(LLTextBase::Params), "textbase");

LLTextBase::LineSpacingParams::LineSpacingParams()
:   multiple("multiple", 1.f),
    pixels("pixels", 0)
{
}


LLTextBase::Params::Params()
:   cursor_color("cursor_color"),
    text_color("text_color"),
    text_readonly_color("text_readonly_color"),
    text_tentative_color("text_tentative_color"),
    bg_visible("bg_visible", false),
    border_visible("border_visible", false),
    bg_readonly_color("bg_readonly_color"),
    bg_writeable_color("bg_writeable_color"),
    bg_focus_color("bg_focus_color"),
    text_selected_color("text_selected_color"),
    bg_selected_color("bg_selected_color"),
    allow_scroll("allow_scroll", true),
    plain_text("plain_text",false),
    track_end("track_end", false),
    read_only("read_only", false),
    skip_link_underline("skip_link_underline", false),
    spellcheck("spellcheck", false),
    v_pad("v_pad", 0),
    h_pad("h_pad", 0),
    clip("clip", true),
    clip_partial("clip_partial", true),
    line_spacing("line_spacing"),
    max_text_length("max_length", 255),
    font_shadow("font_shadow"),
    text_valign("text_valign"),
    wrap("wrap"),
    trusted_content("trusted_content", true),
    always_show_icons("always_show_icons", false),
    use_ellipses("use_ellipses", false),
    use_emoji("use_emoji", true),
    use_color("use_color", true),
    parse_urls("parse_urls", false),
    force_urls_external("force_urls_external", false),
    parse_highlights("parse_highlights", false)
{
    addSynonym(track_end, "track_bottom");
    addSynonym(wrap, "word_wrap");
    addSynonym(parse_urls, "allow_html");
}


LLTextBase::LLTextBase(const LLTextBase::Params &p)
:   LLUICtrl(p, LLTextViewModelPtr(new LLTextViewModel)),
    mURLClickSignal(NULL),
    mIsFriendSignal(NULL),
    mIsObjectBlockedSignal(NULL),
    mMaxTextByteLength( p.max_text_length ),
    mFont(p.font),
    mFontShadow(p.font_shadow),
    mPopupMenuHandle(),
    mReadOnly(p.read_only),
    mSkipTripleClick(false),
    mSkipLinkUnderline(p.skip_link_underline),
    mSpellCheck(p.spellcheck),
    mSpellCheckStart(-1),
    mSpellCheckEnd(-1),
    mCursorColor(p.cursor_color),
    mFgColor(p.text_color),
    mBorderVisible( p.border_visible ),
    mReadOnlyFgColor(p.text_readonly_color),
    mTentativeFgColor(p.text_tentative_color()),
    mWriteableBgColor(p.bg_writeable_color),
    mReadOnlyBgColor(p.bg_readonly_color),
    mFocusBgColor(p.bg_focus_color),
    mTextSelectedColor(p.text_selected_color),
    mSelectedBGColor(p.bg_selected_color),
    mReflowIndex(S32_MAX),
    mCursorPos( 0 ),
    mScrollNeeded(false),
    mDesiredXPixel(-1),
    mHPad(p.h_pad),
    mVPad(p.v_pad),
    mHAlign(p.font_halign),
    mVAlign(p.font_valign),
    mTextVAlign(p.text_valign.isProvided() ? p.text_valign.getValue() : p.font_valign.getValue()),
    mLineSpacingMult(p.line_spacing.multiple),
    mLineSpacingPixels(p.line_spacing.pixels),
    mClip(p.clip),
    mClipPartial(p.clip_partial && !p.allow_scroll),
    mTrustedContent(p.trusted_content),
    mAlwaysShowIcons(p.always_show_icons),
    mTrackEnd( p.track_end ),
    mScrollIndex(-1),
    mSelectionStart( 0 ),
    mSelectionEnd( 0 ),
    mIsSelecting( false ),
    mPlainText ( p.plain_text ),
    mWordWrap(p.wrap),
    mUseEllipses( p.use_ellipses ),
    mUseEmoji(p.use_emoji),
    mUseColor(p.use_color),
    mParseHTML(p.parse_urls),
    mForceUrlsExternal(p.force_urls_external),
    mParseHighlights(p.parse_highlights),
    mBGVisible(p.bg_visible),
    mScroller(NULL),
    mStyleDirty(true)
{
    if(p.allow_scroll)
    {
        LLScrollContainer::Params scroll_params;
        scroll_params.name = "text scroller";
        scroll_params.rect = getLocalRect();
        scroll_params.follows.flags = FOLLOWS_ALL;
        scroll_params.is_opaque = false;
        scroll_params.mouse_opaque = false;
        scroll_params.min_auto_scroll_rate = 200;
        scroll_params.max_auto_scroll_rate = 800;
        scroll_params.border_visible = p.border_visible;
        mScroller = LLUICtrlFactory::create<LLScrollContainer>(scroll_params);
        addChild(mScroller);
    }

    LLView::Params view_params;
    view_params.name = "text_contents";
    view_params.rect =  LLRect(0, 500, 500, 0);
    view_params.mouse_opaque = false;

    mDocumentView = LLUICtrlFactory::create<LLView>(view_params);
    if (mScroller)
    {
        mScroller->addChild(mDocumentView);
    }
    else
    {
        addChild(mDocumentView);
    }

    if (mSpellCheck)
    {
        LLSpellChecker::setSettingsChangeCallback(boost::bind(&LLTextBase::onSpellCheckSettingsChange, this));
    }
    mSpellCheckTimer.reset();

    createDefaultSegment();

    updateRects();
}

LLTextBase::~LLTextBase()
{
    mSegments.clear();
    LLContextMenu* menu = static_cast<LLContextMenu*>(mPopupMenuHandle.get());
    if (menu)
    {
        menu->die();
        mPopupMenuHandle.markDead();
    }
    delete mURLClickSignal;
    delete mIsFriendSignal;
    delete mIsObjectBlockedSignal;
}

void LLTextBase::initFromParams(const LLTextBase::Params& p)
{
    LLUICtrl::initFromParams(p);
    resetDirty();       // Update saved text state
    updateSegments();

    // HACK: work around enabled == readonly design bug -- RN
    // setEnabled will modify our read only status, so do this after
    // LLTextBase::initFromParams
    if (p.read_only.isProvided())
    {
        mReadOnly = p.read_only;
    }
}

bool LLTextBase::truncate()
{
    bool did_truncate = false;

    // First rough check - if we're less than 1/4th the size, we're OK
    if (getLength() >= S32(mMaxTextByteLength / 4))
    {
        // Have to check actual byte size
        S32 utf8_byte_size = 0;
        LLSD value = getViewModel()->getValue();
        if (value.type() == LLSD::TypeString)
        {
            // save a copy for strings.
            utf8_byte_size = static_cast<S32>(value.size());
        }
        else
        {
            // non string LLSDs need explicit conversion to string
            utf8_byte_size = static_cast<S32>(value.asString().size());
        }

        if ( utf8_byte_size > mMaxTextByteLength )
        {
            // Truncate safely in UTF-8
            std::string temp_utf8_text = value.asString();
            temp_utf8_text = utf8str_truncate( temp_utf8_text, mMaxTextByteLength );
            LLWString text = utf8str_to_wstring( temp_utf8_text );
            // remove extra bit of current string, to preserve formatting, etc.
            removeStringNoUndo(static_cast<S32>(text.size()), static_cast<S32>(getWText().size() - text.size()));
            did_truncate = true;
        }
    }

    return did_truncate;
}

const LLStyle::Params& LLTextBase::getStyleParams()
{
    //FIXME: convert mDefaultStyle to a flyweight http://www.boost.org/doc/libs/1_40_0/libs/flyweight/doc/index.html
    //and eliminate color member values
    if (mStyleDirty)
    {
          mStyle
                  .color(LLUIColor(&mFgColor))                      // pass linked color instead of copy of mFGColor
                  .readonly_color(LLUIColor(&mReadOnlyFgColor))
                  .selected_color(LLUIColor(&mTextSelectedColor))
                  .font(mFont)
                  .drop_shadow(mFontShadow);
          mStyleDirty = false;
    }
    return mStyle;
}

void LLTextBase::beforeValueChange()
{

}

void LLTextBase::onValueChange(S32 start, S32 end)
{
}

std::vector<LLRect> LLTextBase::getSelectionRects()
{
    // Nor supposed to be called without selection
    llassert(hasSelection());
    llassert(!mLineInfoList.empty());

    std::vector<LLRect> selection_rects;

    S32 selection_left = llmin(mSelectionStart, mSelectionEnd);
    S32 selection_right = llmax(mSelectionStart, mSelectionEnd);

    // Skip through the lines we aren't drawing.
    LLRect content_display_rect = getVisibleDocumentRect();

    // binary search for line that starts before top of visible buffer
    line_list_t::const_iterator line_iter = std::lower_bound(mLineInfoList.begin(), mLineInfoList.end(), content_display_rect.mTop, compare_bottom());
    line_list_t::const_iterator end_iter = std::upper_bound(mLineInfoList.begin(), mLineInfoList.end(), content_display_rect.mBottom, compare_top());

    bool done = false;

    // Find the coordinates of the selected area
    for (; line_iter != end_iter && !done; ++line_iter)
    {
        // is selection visible on this line?
        if (line_iter->mDocIndexEnd > selection_left && line_iter->mDocIndexStart < selection_right)
        {
            segment_set_t::iterator segment_iter;
            S32 segment_offset;
            getSegmentAndOffset(line_iter->mDocIndexStart, &segment_iter, &segment_offset);

            // Use F32 otherwise a string of multiple segments
            // will accumulate a large error
            F32 left_precise = line_iter->mRect.mLeft;
            F32 right_precise = line_iter->mRect.mLeft;

            for (; segment_iter != mSegments.end(); ++segment_iter, segment_offset = 0)
            {
                LLTextSegmentPtr segmentp = *segment_iter;

                S32 segment_line_start = segmentp->getStart() + segment_offset;
                S32 segment_line_end = llmin(segmentp->getEnd(), line_iter->mDocIndexEnd);

                if (segment_line_start > segment_line_end) break;

                F32 segment_width = 0;
                S32 segment_height = 0;

                // if selection after beginning of segment
                if (selection_left >= segment_line_start)
                {
                    S32 num_chars = llmin(selection_left, segment_line_end) - segment_line_start;
                    segmentp->getDimensionsF32(segment_offset, num_chars, segment_width, segment_height);
                    left_precise += segment_width;
                }

                // if selection_right == segment_line_end then that means we are the first character of the next segment
                // or first character of the next line, in either case we want to add the length of the current segment
                // to the selection rectangle and continue.
                // if selection right > segment_line_end then selection spans end of current segment...
                if (selection_right >= segment_line_end)
                {
                    // extend selection slightly beyond end of line
                    // to indicate selection of newline character (use "n" character to determine width)
                    S32 num_chars = segment_line_end - segment_line_start;
                    segmentp->getDimensionsF32(segment_offset, num_chars, segment_width, segment_height);
                    right_precise += segment_width;
                }
                // else if selection ends on current segment...
                else
                {
                    S32 num_chars = selection_right - segment_line_start;
                    segmentp->getDimensionsF32(segment_offset, num_chars, segment_width, segment_height);
                    right_precise += segment_width;

                    break;
                }
            }

            LLRect selection_rect;
            selection_rect.mLeft = left_precise;
            selection_rect.mRight = right_precise;
            selection_rect.mBottom = line_iter->mRect.mBottom;
            selection_rect.mTop = line_iter->mRect.mTop;

            selection_rects.push_back(selection_rect);
        }
    }

    return selection_rects;
}

// Draws the black box behind the selected text
void LLTextBase::drawSelectionBackground()
{
    // Draw selection even if we don't have keyboard focus for search/replace
    if (hasSelection() && !mLineInfoList.empty())
    {
        std::vector<LLRect> selection_rects = getSelectionRects();

        // Draw the selection box (we're using a box instead of reversing the colors on the selected text).
        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
        const LLColor4& color = mSelectedBGColor;
        F32 alpha = hasFocus() ? 0.7f : 0.3f;
        alpha *= getDrawContext().mAlpha;

        LLColor4 selection_color(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], alpha);
        LLRect content_display_rect = getVisibleDocumentRect();

        for (std::vector<LLRect>::iterator rect_it = selection_rects.begin();
            rect_it != selection_rects.end();
            ++rect_it)
        {
            LLRect selection_rect = *rect_it;
            if (mScroller)
            {
                // If scroller is On content_display_rect has correct rect and safe to use as is
                // Note: we might need to account for border
                selection_rect.translate(mVisibleTextRect.mLeft - content_display_rect.mLeft, mVisibleTextRect.mBottom - content_display_rect.mBottom);
            }
            else
            {
                // If scroller is Off content_display_rect will have rect from document, adjusted to text width, heigh and position
                // and we have to acount for offset depending on position
                S32 v_delta = 0;
                S32 h_delta = 0;
                switch (mVAlign)
                {
                case LLFontGL::TOP:
                    v_delta = mVisibleTextRect.mTop - content_display_rect.mTop - mVPad;
                    break;
                case LLFontGL::VCENTER:
                    v_delta = (llmax(mVisibleTextRect.getHeight() - content_display_rect.mTop, -content_display_rect.mBottom) + (mVisibleTextRect.mBottom - content_display_rect.mBottom)) / 2;
                    break;
                case LLFontGL::BOTTOM:
                    v_delta = mVisibleTextRect.mBottom - content_display_rect.mBottom;
                    break;
                default:
                    break;
                }
                switch (mHAlign)
                {
                case LLFontGL::LEFT:
                    h_delta = mVisibleTextRect.mLeft - content_display_rect.mLeft + mHPad;
                    break;
                case LLFontGL::HCENTER:
                    h_delta = (llmax(mVisibleTextRect.getWidth() - content_display_rect.mLeft, -content_display_rect.mRight) + (mVisibleTextRect.mRight - content_display_rect.mRight)) / 2;
                    break;
                case LLFontGL::RIGHT:
                    h_delta = mVisibleTextRect.mRight - content_display_rect.mRight;
                    break;
                default:
                    break;
                }
                selection_rect.translate(h_delta, v_delta);
            }
            gl_rect_2d(selection_rect, selection_color);
        }
    }
}

void LLTextBase::drawCursor()
{
    F32 alpha = getDrawContext().mAlpha;

    if( hasFocus()
        && gFocusMgr.getAppHasFocus()
        && !mReadOnly)
    {
        const LLWString &wtext = getWText();
        const llwchar* text = wtext.c_str();

        LLRect cursor_rect = getLocalRectFromDocIndex(mCursorPos);
        cursor_rect.translate(-1, 0);
        segment_set_t::iterator seg_it = getSegIterContaining(mCursorPos);

        // take style from last segment
        LLTextSegmentPtr segmentp;

        if (seg_it != mSegments.end())
        {
            segmentp = *seg_it;
        }
        else
        {
            return;
        }

        // Draw the cursor
        // (Flash the cursor every half second starting a fixed time after the last keystroke)
        F32 elapsed = mCursorBlinkTimer.getElapsedTimeF32();
        if( (elapsed < CURSOR_FLASH_DELAY ) || (S32(elapsed * 2) & 1) )
        {

            if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection())
            {
                S32 segment_width = 0;
                S32 segment_height = 0;
                segmentp->getDimensions(mCursorPos - segmentp->getStart(), 1, segment_width, segment_height);
                S32 width = llmax(CURSOR_THICKNESS, segment_width);
                cursor_rect.mRight = cursor_rect.mLeft + width;
            }
            else
            {
                cursor_rect.mRight = cursor_rect.mLeft + CURSOR_THICKNESS;
            }

            gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

            LLColor4 cursor_color = mCursorColor.get() % alpha;
            gGL.color4fv( cursor_color.mV );

            gl_rect_2d(cursor_rect);

            if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection() && text[mCursorPos] != '\n')
            {
                LLColor4 text_color;
                const LLFontGL* fontp;
                text_color = segmentp->getColor();
                fontp = segmentp->getStyle()->getFont();
                fontp->render(text, mCursorPos, cursor_rect,
                    LLColor4(1.f - text_color.mV[VRED], 1.f - text_color.mV[VGREEN], 1.f - text_color.mV[VBLUE], alpha),
                    LLFontGL::LEFT, mTextVAlign,
                    LLFontGL::NORMAL,
                    LLFontGL::NO_SHADOW,
                    1);
            }

            // Make sure the IME is in the right place
            LLRect screen_pos = calcScreenRect();
            LLCoordGL ime_pos( screen_pos.mLeft + llfloor(cursor_rect.mLeft), screen_pos.mBottom + llfloor(cursor_rect.mTop) );

            ime_pos.mX = (S32) (ime_pos.mX * LLUI::getScaleFactor().mV[VX]);
            ime_pos.mY = (S32) (ime_pos.mY * LLUI::getScaleFactor().mV[VY]);
            getWindow()->setLanguageTextInput( ime_pos );
        }
    }
}

void LLTextBase::drawText()
{
    S32 text_len = getLength();

    if (text_len <= 0 && mLabel.empty())
    {
        return;
    }
    else if (useLabel())
    {
        text_len = static_cast<S32>(mLabel.getWString().length());
    }

    S32 selection_left = -1;
    S32 selection_right = -1;
    // Draw selection even if we don't have keyboard focus for search/replace
    if( hasSelection())
    {
        selection_left = llmin( mSelectionStart, mSelectionEnd );
        selection_right = llmax( mSelectionStart, mSelectionEnd );
    }

    std::pair<S32, S32> line_range = getVisibleLines(mClipPartial);
    S32 first_line = line_range.first;
    S32 last_line = line_range.second;
    if (first_line >= last_line)
    {
        return;
    }

    S32 line_start = getLineStart(first_line);
    // find first text segment that spans top of visible portion of text buffer
    segment_set_t::iterator seg_iter = getSegIterContaining(line_start);
    if (seg_iter == mSegments.end())
    {
        return;
    }

    // Perform spell check if needed
    if ( (getSpellCheck()) && (getWText().length() > 2) )
    {
        // Calculate start and end indices for the spell checking range
        S32 start = line_start;
        S32 end   = getLineEnd(last_line);

        if ( (mSpellCheckStart != start) || (mSpellCheckEnd != end) )
        {
            const LLWString& wstrText = getWText();
            mMisspellRanges.clear();

            segment_set_t::const_iterator seg_it = getSegIterContaining(start);
            while (mSegments.end() != seg_it)
            {
                LLTextSegmentPtr text_segment = *seg_it;
                if ( (text_segment.isNull()) || (text_segment->getStart() >= end) )
                {
                    break;
                }

                if (!text_segment->canEdit())
                {
                    ++seg_it;
                    continue;
                }

                // Combine adjoining text segments into one
                U32 seg_start = text_segment->getStart(), seg_end = llmin(text_segment->getEnd(), end);
                while (mSegments.end() != ++seg_it)
                {
                    text_segment = *seg_it;
                    if ( (text_segment.isNull()) || (!text_segment->canEdit()) || (text_segment->getStart() >= end) )
                    {
                        break;
                    }
                    seg_end = llmin(text_segment->getEnd(), end);
                }

                // Find the start of the first word
                U32 word_start = seg_start, word_end = -1;
                U32 text_length = static_cast<U32>(wstrText.length());
                while ( (word_start < text_length) && (!LLStringOps::isAlpha(wstrText[word_start])) )
                {
                    word_start++;
                }

                // Iterate over all words in the text block and check them one by one
                while (word_start < seg_end)
                {
                    // Find the end of the current word (special case handling for "'" when it's used as a contraction)
                    word_end = word_start + 1;
                    while ( (word_end < seg_end) &&
                            ((LLWStringUtil::isPartOfWord(wstrText[word_end])) ||
                                ((L'\'' == wstrText[word_end]) &&
                                (LLStringOps::isAlnum(wstrText[word_end - 1])) && (LLStringOps::isAlnum(wstrText[word_end + 1])))) )
                    {
                        word_end++;
                    }
                    if (word_end > seg_end)
                    {
                        break;
                    }

                    if (word_start < text_length && word_end <= text_length && word_end > word_start)
                    {
                        std::string word = wstring_to_utf8str(wstrText.substr(word_start, word_end - word_start));

                        // Don't process words shorter than 3 characters
                        if ( (word.length() >= 3) && (!LLSpellChecker::instance().checkSpelling(word)) )
                        {
                            mMisspellRanges.push_back(std::pair<U32, U32>(word_start, word_end));
                        }
                    }

                    // Find the start of the next word
                    word_start = word_end + 1;
                    while ( (word_start < seg_end) && (!LLWStringUtil::isPartOfWord(wstrText[word_start])) )
                    {
                        word_start++;
                    }
                }
            }

            mSpellCheckStart = start;
            mSpellCheckEnd = end;
        }
    }
    else
    {
        mMisspellRanges.clear();
    }

    LLTextSegmentPtr cur_segment = *seg_iter;

    std::list<std::pair<U32, U32> >::const_iterator misspell_it = std::lower_bound(mMisspellRanges.begin(), mMisspellRanges.end(), std::pair<U32, U32>(line_start, 0));
    for (S32 cur_line = first_line; cur_line < last_line; cur_line++)
    {
        S32 next_line = cur_line + 1;
        line_info& line = mLineInfoList[cur_line];

        S32 next_start = -1;
        S32 line_end = text_len;

        if (next_line < getLineCount())
        {
            next_start = getLineStart(next_line);
            line_end = next_start;
        }

        LLRectf text_rect(line.mRect.mLeft, line.mRect.mTop, line.mRect.mRight, line.mRect.mBottom);
        text_rect.mRight = mDocumentView->getRect().getWidth(); // clamp right edge to document extents
        text_rect.translate(mDocumentView->getRect().mLeft, mDocumentView->getRect().mBottom); // adjust by scroll position

        // draw a single line of text
        S32 seg_start = line_start;
        while( seg_start < line_end )
        {
            while( cur_segment->getEnd() <= seg_start )
            {
                seg_iter++;
                if (seg_iter == mSegments.end())
                {
                    LL_WARNS() << "Ran off the segmentation end!" << LL_ENDL;

                    return;
                }
                cur_segment = *seg_iter;
            }

            S32 seg_end = llmin(line_end, cur_segment->getEnd());
            S32 clipped_end = seg_end - cur_segment->getStart();

            if (mUseEllipses                                // using ellipses
                && clipped_end == line_end                  // last segment on line
                && next_line == last_line                   // this is the last visible line
                && last_line < (S32)mLineInfoList.size())   // and there is more text to display
            {
                // more lines of text to go, but we can't fit them
                // so shrink text rect to force ellipses
                text_rect.mRight -= 2;
            }

            // Draw squiggly lines under any visible misspelled words
            while ( (mMisspellRanges.end() != misspell_it) && (misspell_it->first < (U32)seg_end) && (misspell_it->second > (U32)seg_start) )
            {
                // Skip the current word if the user is still busy editing it
                if ( (!mSpellCheckTimer.hasExpired()) && (misspell_it->first <= (U32)mCursorPos) && (misspell_it->second >= (U32)mCursorPos) )
                {
                    ++misspell_it;
                    continue;
                }

                U32 misspell_start = llmax<U32>(misspell_it->first, (U32)seg_start), misspell_end = llmin<U32>(misspell_it->second, (U32)seg_end);
                S32 squiggle_start = 0, squiggle_end = 0, pony = 0;
                cur_segment->getDimensions(seg_start - cur_segment->getStart(), misspell_start - seg_start, squiggle_start, pony);
                cur_segment->getDimensions(misspell_start - cur_segment->getStart(), misspell_end - misspell_start, squiggle_end, pony);
                squiggle_start += text_rect.mLeft;

                pony = (squiggle_end + 3) / 6;
                squiggle_start += squiggle_end / 2 - pony * 3;
                squiggle_end = squiggle_start + pony * 6;

                S32 squiggle_bottom = text_rect.mBottom + (S32)cur_segment->getStyle()->getFont()->getDescenderHeight();

                gGL.color4ub(255, 0, 0, 200);
                while (squiggle_start + 1 < squiggle_end)
                {
                    gl_line_2d(squiggle_start, squiggle_bottom, squiggle_start + 2, squiggle_bottom - 2);
                    if (squiggle_start + 3 < squiggle_end)
                    {
                        gl_line_2d(squiggle_start + 2, squiggle_bottom - 3, squiggle_start + 4, squiggle_bottom - 1);
                    }
                    squiggle_start += 4;
                }

                if (misspell_it->second > (U32)seg_end)
                {
                    break;
                }
                ++misspell_it;
            }

            text_rect.mLeft = cur_segment->draw(seg_start - cur_segment->getStart(), clipped_end, selection_left, selection_right, text_rect);

            seg_start = clipped_end + cur_segment->getStart();
        }

        line_start = next_start;
    }
}

///////////////////////////////////////////////////////////////////
// Returns change in number of characters in mWText

S32 LLTextBase::insertStringNoUndo(S32 pos, const LLWString &wstr, LLTextBase::segment_vec_t* segments )
{
    beforeValueChange();

    S32 old_len = getLength();      // length() returns character length
    S32 insert_len = static_cast<S32>(wstr.length());

    pos = getEditableIndex(pos, true);
    if (pos > old_len)
    {
        pos = old_len;
        // Should not happen,
        // if you encounter this, check where wrong position comes from
        llassert(false);
    }

    segment_set_t::iterator seg_iter = getEditableSegIterContaining(pos);

    LLTextSegmentPtr default_segment;

    LLTextSegmentPtr segmentp;
    if (seg_iter != mSegments.end())
    {
        segmentp = *seg_iter;
    }
    else
    {
        //segmentp = mSegments.back();
        return pos;
    }

    if (segmentp->canEdit())
    {
        segmentp->setEnd(segmentp->getEnd() + insert_len);
        if (seg_iter != mSegments.end())
        {
            ++seg_iter;
        }
    }
    else
    {
        // create default editable segment to hold new text
        LLStyleConstSP sp(new LLStyle(getStyleParams()));
        default_segment = new LLNormalTextSegment( sp, pos, pos + insert_len, *this);
    }

    // shift remaining segments to right
    for(;seg_iter != mSegments.end(); ++seg_iter)
    {
        LLTextSegmentPtr segmentp = *seg_iter;
        segmentp->setStart(segmentp->getStart() + insert_len);
        segmentp->setEnd(segmentp->getEnd() + insert_len);
    }

    // insert new segments
    if (segments)
    {
        if (default_segment.notNull())
        {
            // potentially overwritten by segments passed in
            insertSegment(default_segment);
        }
        for (segment_vec_t::iterator seg_iter = segments->begin();
            seg_iter != segments->end();
            ++seg_iter)
        {
            LLTextSegment* segmentp = *seg_iter;
            insertSegment(segmentp);
        }
    }

    // Insert special segments where necessary (insertSegment takes care of splitting normal text segments around them for us)
    if (mUseEmoji)
    {
        LLStyleSP emoji_style;
        LLEmojiDictionary* ed = LLEmojiDictionary::instanceExists() ? LLEmojiDictionary::getInstance() : NULL;
        for (S32 text_kitty = 0, text_len = static_cast<S32>(wstr.size()); text_kitty < text_len; text_kitty++)
        {
            llwchar code = wstr[text_kitty];
            bool isEmoji = ed ? ed->isEmoji(code) : LLStringOps::isEmoji(code);
            if (isEmoji)
            {
                if (!emoji_style)
                {
                    emoji_style = new LLStyle(getStyleParams());
                    emoji_style->setFont(LLFontGL::getFontEmojiLarge());
                }

                S32 new_seg_start = pos + text_kitty;
                insertSegment(new LLEmojiTextSegment(emoji_style, new_seg_start, new_seg_start + 1, *this));
            }
        }
    }

    getViewModel()->getEditableDisplay().insert(pos, wstr);

    if ( truncate() )
    {
        insert_len = getLength() - old_len;
    }

    onValueChange(pos, pos + insert_len);
    needsReflow(pos);

    return insert_len;
}

S32 LLTextBase::removeStringNoUndo(S32 pos, S32 length)
{

    beforeValueChange();
    segment_set_t::iterator seg_iter = getSegIterContaining(pos);
    while(seg_iter != mSegments.end())
    {
        LLTextSegmentPtr segmentp = *seg_iter;
        S32 end = pos + length;
        if (segmentp->getStart() < pos)
        {
            // deleting from middle of segment
            if (segmentp->getEnd() > end)
            {
                segmentp->setEnd(segmentp->getEnd() - length);
            }
            // truncating segment
            else
            {
                segmentp->setEnd(pos);
            }
        }
        else if (segmentp->getStart() < end)
        {
            // deleting entire segment
            if (segmentp->getEnd() <= end)
            {
                // remove segment
                segmentp->unlinkFromDocument(this);
                segment_set_t::iterator seg_to_erase(seg_iter++);
                mSegments.erase(seg_to_erase);
                continue;
            }
            // deleting head of segment
            else
            {
                segmentp->setStart(pos);
                segmentp->setEnd(segmentp->getEnd() - length);
            }
        }
        else
        {
            // shifting segments backward to fill deleted portion
            segmentp->setStart(segmentp->getStart() - length);
            segmentp->setEnd(segmentp->getEnd() - length);
        }
        ++seg_iter;
    }

    getViewModel()->getEditableDisplay().erase(pos, length);

    // recreate default segment in case we erased everything
    createDefaultSegment();

    onValueChange(pos, pos);
    needsReflow(pos);

    return -length; // This will be wrong if someone calls removeStringNoUndo with an excessive length
}

S32 LLTextBase::overwriteCharNoUndo(S32 pos, llwchar wc)
{
    beforeValueChange();

    if (pos > (S32)getLength())
    {
        return 0;
    }
    getViewModel()->getEditableDisplay()[pos] = wc;

    onValueChange(pos, pos + 1);
    needsReflow(pos);

    return 1;
}


void LLTextBase::createDefaultSegment()
{
    // ensures that there is always at least one segment
    if (mSegments.empty())
    {
        LLStyleConstSP sp(new LLStyle(getStyleParams()));
        LLTextSegmentPtr default_segment = new LLNormalTextSegment( sp, 0, getLength() + 1, *this);
        mSegments.insert(default_segment);
        default_segment->linkToDocument(this);
    }
}

void LLTextBase::insertSegment(LLTextSegmentPtr segment_to_insert)
{
    if (segment_to_insert.isNull())
    {
        return;
    }

    segment_set_t::iterator cur_seg_iter = getSegIterContaining(segment_to_insert->getStart());
    S32 reflow_start_index = 0;

    if (cur_seg_iter == mSegments.end())
    {
        mSegments.insert(segment_to_insert);
        segment_to_insert->linkToDocument(this);
        reflow_start_index = segment_to_insert->getStart();
    }
    else
    {
        LLTextSegmentPtr cur_segmentp = *cur_seg_iter;
        reflow_start_index = cur_segmentp->getStart();
        if (cur_segmentp->getStart() < segment_to_insert->getStart())
        {
            S32 old_segment_end = cur_segmentp->getEnd();
            // split old at start point for new segment
            cur_segmentp->setEnd(segment_to_insert->getStart());
            // advance to next segment
            // insert remainder of old segment
            LLStyleConstSP sp = cur_segmentp->getStyle();
            LLTextSegmentPtr remainder_segment = new LLNormalTextSegment( sp, segment_to_insert->getStart(), old_segment_end, *this);
            mSegments.insert(cur_seg_iter, remainder_segment);
            remainder_segment->linkToDocument(this);
            // insert new segment before remainder of old segment
            mSegments.insert(cur_seg_iter, segment_to_insert);

            segment_to_insert->linkToDocument(this);
            // at this point, there will be two overlapping segments owning the text
            // associated with the incoming segment
        }
        else
        {
            mSegments.insert(cur_seg_iter, segment_to_insert);
            segment_to_insert->linkToDocument(this);
        }

        // now delete/truncate remaining segments as necessary
        // cur_seg_iter points to segment before incoming segment
        while(cur_seg_iter != mSegments.end())
        {
            cur_segmentp = *cur_seg_iter;
            if (cur_segmentp == segment_to_insert)
            {
                ++cur_seg_iter;
                continue;
            }

            if (cur_segmentp->getStart() >= segment_to_insert->getStart())
            {
                if(cur_segmentp->getEnd() <= segment_to_insert->getEnd())
                {
                    cur_segmentp->unlinkFromDocument(this);
                    // grab copy of iterator to erase, and bump it
                    segment_set_t::iterator seg_to_erase(cur_seg_iter++);
                    mSegments.erase(seg_to_erase);
                    continue;
                }
                else
                {
                    // last overlapping segment, clip to end of incoming segment
                    // and stop traversal
                    cur_segmentp->setStart(segment_to_insert->getEnd());
                    break;
                }
            }
            ++cur_seg_iter;
        }
    }

    // layout potentially changed
    needsReflow(reflow_start_index);
}

//virtual
bool LLTextBase::handleMouseDown(S32 x, S32 y, MASK mask)
{
    // handle triple click
    if (!mTripleClickTimer.hasExpired())
    {
        if (mSkipTripleClick)
        {
            return true;
        }

        S32 real_line = getLineNumFromDocIndex(mCursorPos, false);
        S32 line_start = -1;
        S32 line_end = -1;
        for (line_list_t::const_iterator it = mLineInfoList.begin(), end_it = mLineInfoList.end();
                it != end_it;
                ++it)
        {
            if (it->mLineNum < real_line)
            {
                continue;
            }
            if (it->mLineNum > real_line)
            {
                break;
            }
            if (line_start == -1)
            {
                line_start = it->mDocIndexStart;
            }
            line_end = it->mDocIndexEnd;
            line_end = llclamp(line_end, 0, getLength());
        }

        if (line_start == -1)
        {
            return true;
        }

        mSelectionEnd = line_start;
        mSelectionStart = line_end;
        setCursorPos(line_start);

        return true;
    }

    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleMouseDown(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleMouseDown(x, y, mask);
}

//virtual
bool LLTextBase::handleMouseUp(S32 x, S32 y, MASK mask)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (hasMouseCapture() && cur_segment && cur_segment->handleMouseUp(x, y, mask))
    {
        // Did we just click on a link?
        if (mURLClickSignal
            && cur_segment->getStyle()
            && cur_segment->getStyle()->isLink())
        {
            // *TODO: send URL here?
            (*mURLClickSignal)(this, LLSD() );
        }
        return true;
    }

    return LLUICtrl::handleMouseUp(x, y, mask);
}

//virtual
bool LLTextBase::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleMiddleMouseDown(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleMiddleMouseDown(x, y, mask);
}

//virtual
bool LLTextBase::handleMiddleMouseUp(S32 x, S32 y, MASK mask)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleMiddleMouseUp(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleMiddleMouseUp(x, y, mask);
}

//virtual
bool LLTextBase::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleRightMouseDown(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleRightMouseDown(x, y, mask);
}

//virtual
bool LLTextBase::handleRightMouseUp(S32 x, S32 y, MASK mask)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleRightMouseUp(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleRightMouseUp(x, y, mask);
}

//virtual
bool LLTextBase::handleDoubleClick(S32 x, S32 y, MASK mask)
{
    //Don't start triple click timer if user have clicked on scrollbar
    mVisibleTextRect = mScroller ? mScroller->getContentWindowRect() : getLocalRect();
    if (x >= mVisibleTextRect.mLeft && x <= mVisibleTextRect.mRight
        && y >= mVisibleTextRect.mBottom && y <= mVisibleTextRect.mTop)
    {
        mTripleClickTimer.setTimerExpirySec(TRIPLE_CLICK_INTERVAL);
    }

    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleDoubleClick(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleDoubleClick(x, y, mask);
}

//virtual
bool LLTextBase::handleHover(S32 x, S32 y, MASK mask)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleHover(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleHover(x, y, mask);
}

//virtual
bool LLTextBase::handleScrollWheel(S32 x, S32 y, S32 clicks)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleScrollWheel(x, y, clicks))
    {
        return true;
    }

    return LLUICtrl::handleScrollWheel(x, y, clicks);
}

//virtual
bool LLTextBase::handleToolTip(S32 x, S32 y, MASK mask)
{
    LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
    if (cur_segment && cur_segment->handleToolTip(x, y, mask))
    {
        return true;
    }

    return LLUICtrl::handleToolTip(x, y, mask);
}

//virtual
void LLTextBase::reshape(S32 width, S32 height, bool called_from_parent)
{
    if (width != getRect().getWidth() || height != getRect().getHeight() || LLView::sForceReshape)
    {
        bool scrolled_to_bottom = mScroller ? mScroller->isAtBottom() : false;

        LLUICtrl::reshape( width, height, called_from_parent );

        if (mScroller && scrolled_to_bottom && mTrackEnd)
        {
            // keep bottom of text buffer visible
            // do this here as well as in reflow to handle case
            // where shrinking from top, which causes buffer to temporarily
            // not be scrolled to the bottom, since the scroll index
            // specified the _top_ of the visible document region
            mScroller->goToBottom();
        }

        // do this first after reshape, because other things depend on
        // up-to-date mVisibleTextRect
        updateRects();

        needsReflow();
    }
}

//virtual
void LLTextBase::draw()
{
    // reflow if needed, on demand
    reflow();

    // then update scroll position, as cursor may have moved
    if (!mReadOnly)
    {
        updateScrollFromCursor();
    }

    LLRect text_rect;
    if (mScroller)
    {
        mScroller->localRectToOtherView(mScroller->getContentWindowRect(), &text_rect, this);
    }
    else
    {
        LLRect visible_lines_rect;
        std::pair<S32, S32> line_range = getVisibleLines(mClipPartial);
        for (S32 i = line_range.first; i < line_range.second; i++)
        {
            if (visible_lines_rect.isEmpty())
            {
                visible_lines_rect = mLineInfoList[i].mRect;
            }
            else
            {
                visible_lines_rect.unionWith(mLineInfoList[i].mRect);
            }
        }
        text_rect = visible_lines_rect;
        text_rect.translate(mDocumentView->getRect().mLeft, mDocumentView->getRect().mBottom);
    }

    if (mBGVisible)
    {
        F32 alpha = getCurrentTransparency();
        // clip background rect against extents, if we support scrolling
        LLRect bg_rect = mVisibleTextRect;
        if (mScroller)
        {
            bg_rect.intersectWith(text_rect);
        }
        LLColor4 bg_color = mReadOnly
                            ? mReadOnlyBgColor.get()
                            : hasFocus()
                                ? mFocusBgColor.get()
                                : mWriteableBgColor.get();
        gl_rect_2d(text_rect, bg_color % alpha, true);
    }

    // Draw highlighted if needed
    if( ll::ui::SearchableControl::getHighlighted() )
    {
        LLColor4 bg_color = ll::ui::SearchableControl::getHighlightColor();
        LLRect bg_rect = mVisibleTextRect;
        if( mScroller )
            bg_rect.intersectWith( text_rect );

        gl_rect_2d( text_rect, bg_color, true );
    }

    bool should_clip = mClip || mScroller != NULL;
    { LLLocalClipRect clip(text_rect, should_clip);

        // draw document view
        if (mScroller)
        {
            drawChild(mScroller);
        }
        else
        {
            drawChild(mDocumentView);
        }

        drawSelectionBackground();
        drawText();
        drawCursor();
    }

    mDocumentView->setVisibleDirect(false);
    LLUICtrl::draw();
    mDocumentView->setVisibleDirect(true);
}


//virtual
void LLTextBase::setColor( const LLColor4& c )
{
    mFgColor = c;
    mStyleDirty = true;
}

//virtual
void LLTextBase::setReadOnlyColor(const LLColor4 &c)
{
    mReadOnlyFgColor = c;
    mStyleDirty = true;
}

//virtual
void LLTextBase::onVisibilityChange( bool new_visibility )
{
    LLContextMenu* menu = static_cast<LLContextMenu*>(mPopupMenuHandle.get());
    if(!new_visibility && menu)
    {
        menu->hide();
    }
    LLUICtrl::onVisibilityChange(new_visibility);
}

//virtual
void LLTextBase::setValue(const LLSD& value )
{
    setText(value.asString());
}

//virtual
bool LLTextBase::canDeselect() const
{
    return hasSelection();
}


//virtual
void LLTextBase::deselect()
{
    mSelectionStart = 0;
    mSelectionEnd = 0;
    mIsSelecting = false;
}

bool LLTextBase::getSpellCheck() const
{
    return (LLSpellChecker::getUseSpellCheck()) && (!mReadOnly) && (mSpellCheck);
}

const std::string& LLTextBase::getSuggestion(U32 index) const
{
    return (index < mSuggestionList.size()) ? mSuggestionList[index] : LLStringUtil::null;
}

U32 LLTextBase::getSuggestionCount() const
{
    return static_cast<U32>(mSuggestionList.size());
}

void LLTextBase::replaceWithSuggestion(U32 index)
{
    for (std::list<std::pair<U32, U32> >::const_iterator it = mMisspellRanges.begin(); it != mMisspellRanges.end(); ++it)
    {
        if ( (it->first <= (U32)mCursorPos) && (it->second >= (U32)mCursorPos) )
        {
            deselect();
            // Insert the suggestion in its place
            LLWString suggestion = utf8str_to_wstring(mSuggestionList[index]);
            insertStringNoUndo(it->first, utf8str_to_wstring(mSuggestionList[index]));

            // Delete the misspelled word
            removeStringNoUndo(it->first + (S32)suggestion.length(), it->second - it->first);


            setCursorPos(it->first + (S32)suggestion.length());
            onSpellCheckPerformed();

            break;
        }
    }
    mSpellCheckStart = mSpellCheckEnd = -1;
}

void LLTextBase::addToDictionary()
{
    if (canAddToDictionary())
    {
        LLSpellChecker::instance().addToCustomDictionary(getMisspelledWord(mCursorPos));
    }
}

bool LLTextBase::canAddToDictionary() const
{
    return (getSpellCheck()) && (isMisspelledWord(mCursorPos));
}

void LLTextBase::addToIgnore()
{
    if (canAddToIgnore())
    {
        LLSpellChecker::instance().addToIgnoreList(getMisspelledWord(mCursorPos));
    }
}

bool LLTextBase::canAddToIgnore() const
{
    return (getSpellCheck()) && (isMisspelledWord(mCursorPos));
}

std::string LLTextBase::getMisspelledWord(U32 pos) const
{
    for (std::list<std::pair<U32, U32> >::const_iterator it = mMisspellRanges.begin(); it != mMisspellRanges.end(); ++it)
    {
        if ( (it->first <= pos) && (it->second >= pos) )
        {
            return wstring_to_utf8str(getWText().substr(it->first, it->second - it->first));
        }
    }
    return LLStringUtil::null;
}

bool LLTextBase::isMisspelledWord(U32 pos) const
{
    for (std::list<std::pair<U32, U32> >::const_iterator it = mMisspellRanges.begin(); it != mMisspellRanges.end(); ++it)
    {
        if ( (it->first <= pos) && (it->second >= pos) )
        {
            return true;
        }
    }
    return false;
}

void LLTextBase::onSpellCheckSettingsChange()
{
    // Recheck the spelling on every change
    mMisspellRanges.clear();
    mSpellCheckStart = mSpellCheckEnd = -1;
}

void LLTextBase::onFocusReceived()
{
    LLUICtrl::onFocusReceived();
    if (!getLength() && !mLabel.empty())
    {
        // delete label which is LLLabelTextSegment
        clearSegments();
    }
}

void LLTextBase::onFocusLost()
{
    LLUICtrl::onFocusLost();
    if (!getLength() && !mLabel.empty())
    {
        resetLabel();
    }
}

// Sets the scrollbar from the cursor position
void LLTextBase::updateScrollFromCursor()
{
    // Update scroll position even in read-only mode (when there's no cursor displayed)
    // because startOfDoc()/endOfDoc() modify cursor position. See EXT-736.

    if (!mScrollNeeded || !mScroller)
    {
        return;
    }
    mScrollNeeded = false;

    // scroll so that the cursor is at the top of the page
    LLRect scroller_doc_window = getVisibleDocumentRect();
    LLRect cursor_rect_doc = getDocRectFromDocIndex(mCursorPos);
    mScroller->scrollToShowRect(cursor_rect_doc, LLRect(0, scroller_doc_window.getHeight() - 5, scroller_doc_window.getWidth(), 5));
}

S32 LLTextBase::getLeftOffset(S32 width)
{
    switch (mHAlign)
    {
    case LLFontGL::LEFT:
        return mHPad;
    case LLFontGL::HCENTER:
        return mHPad + llmax(0, (mVisibleTextRect.getWidth() - width - mHPad) / 2);
    case LLFontGL::RIGHT:
        {
            // Font's rendering rounds string size, if value gets rounded
            // down last symbol might not have enough space to render,
            // compensate by adding an extra pixel as padding
            const S32 right_padding = 1;
            return llmax(mHPad, mVisibleTextRect.getWidth() - width - right_padding);
        }
    default:
        return mHPad;
    }
}

void LLTextBase::reflow()
{
    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;

    updateSegments();

    if (mReflowIndex == S32_MAX)
    {
        return;
    }

    bool scrolled_to_bottom = mScroller ? mScroller->isAtBottom() : false;

    LLRect cursor_rect = getLocalRectFromDocIndex(mCursorPos);
    bool follow_selection = getLocalRect().overlaps(cursor_rect); // cursor is (potentially) visible

    // store in top-left relative coordinates to avoid issues with horizontal scrollbar appearing and disappearing
    cursor_rect.mTop = mVisibleTextRect.mTop - cursor_rect.mTop;
    cursor_rect.mBottom = mVisibleTextRect.mTop - cursor_rect.mBottom;

    S32 first_line = getFirstVisibleLine();

    // if scroll anchor not on first line, update it to first character of first line
    if ((first_line < mLineInfoList.size())
        &&  (mScrollIndex <  mLineInfoList[first_line].mDocIndexStart
            ||  mScrollIndex >= mLineInfoList[first_line].mDocIndexEnd))
    {
        mScrollIndex = mLineInfoList[first_line].mDocIndexStart;
    }
    LLRect first_char_rect = getLocalRectFromDocIndex(mScrollIndex);
    // store in top-left relative coordinates to avoid issues with horizontal scrollbar appearing and disappearing
    first_char_rect.mTop = mVisibleTextRect.mTop - first_char_rect.mTop;
    first_char_rect.mBottom = mVisibleTextRect.mTop - first_char_rect.mBottom;

    S32 reflow_count = 0;
    while(mReflowIndex < S32_MAX)
    {
        // we can get into an infinite loop if the document height does not monotonically increase
        // with decreasing width (embedded ui elements with alternate layouts).  In that case,
        // we want to stop reflowing after 2 iterations.  We use 2, since we need to handle the case
        // of introducing a vertical scrollbar causing a reflow with less width.  We should also always
        // use an even number of iterations to avoid user visible oscillation of the layout
        if(++reflow_count > 2)
        {
            LL_DEBUGS() << "Breaking out of reflow due to possible infinite loop in " << getName() << LL_ENDL;
            break;
        }

        S32 start_index = mReflowIndex;
        mReflowIndex = S32_MAX;

        // shrink document to minimum size (visible portion of text widget)
        // to force inlined widgets with follows set to shrink
        if (mWordWrap)
        {
            mDocumentView->reshape(mVisibleTextRect.getWidth(), mDocumentView->getRect().getHeight());
        }

        S32 cur_top = 0;

        segment_set_t::iterator seg_iter = mSegments.begin();
        S32 seg_offset = 0;
        S32 line_start_index = 0;
        const F32 text_available_width = mVisibleTextRect.getWidth() - mHPad;  // reserve room for margin
        F32 remaining_pixels = text_available_width;
        S32 line_count = 0;

        // find and erase line info structs starting at start_index and going to end of document
        if (!mLineInfoList.empty())
        {
            // find first element whose end comes after start_index
            line_list_t::iterator iter = std::upper_bound(mLineInfoList.begin(), mLineInfoList.end(), start_index, line_end_compare());
            if (iter != mLineInfoList.end())
            {
                line_start_index = iter->mDocIndexStart;
                line_count = iter->mLineNum;
                cur_top = iter->mRect.mTop;
                getSegmentAndOffset(iter->mDocIndexStart, &seg_iter, &seg_offset);
                mLineInfoList.erase(iter, mLineInfoList.end());
            }
        }

        S32 line_height = 0;
        S32 seg_line_offset = line_count + 1;

        while(seg_iter != mSegments.end())
        {
            LLTextSegmentPtr segment = *seg_iter;

            // track maximum height of any segment on this line
            S32 cur_index = segment->getStart() + seg_offset;

            // ask segment how many character fit in remaining space
            S32 character_count = segment->getNumChars(getWordWrap() ? llmax(0, ll_round(remaining_pixels)) : S32_MAX,
                                                        seg_offset,
                                                        cur_index - line_start_index,
                                                        S32_MAX,
                                                        line_count - seg_line_offset);

            F32 segment_width;
            S32 segment_height;
            bool force_newline = segment->getDimensionsF32(seg_offset, character_count, segment_width, segment_height);
            // grow line height as necessary based on reported height of this segment
            line_height = llmax(line_height, segment_height);
            remaining_pixels -= segment_width;

            seg_offset += character_count;

            S32 last_segment_char_on_line = segment->getStart() + seg_offset;

            // Note: make sure text will fit in width - use ceil, but also make sure
            // ceil is used only once per line
            S32 text_actual_width = llceil(text_available_width - remaining_pixels);
            S32 text_left = getLeftOffset(text_actual_width);
            LLRect line_rect(text_left,
                            cur_top,
                            text_left + text_actual_width,
                            cur_top - line_height);

            // if we didn't finish the current segment...
            if (last_segment_char_on_line < segment->getEnd())
            {
                // add line info and keep going
                mLineInfoList.push_back(line_info(
                                            line_start_index,
                                            last_segment_char_on_line,
                                            line_rect,
                                            line_count));

                line_start_index = segment->getStart() + seg_offset;
                cur_top -= ll_round((F32)line_height * mLineSpacingMult) + mLineSpacingPixels;
                remaining_pixels = text_available_width;
                line_height = 0;
            }
            // ...just consumed last segment..
            else if (++segment_set_t::iterator(seg_iter) == mSegments.end())
            {
                mLineInfoList.push_back(line_info(
                                            line_start_index,
                                            last_segment_char_on_line,
                                            line_rect,
                                            line_count));
                cur_top -= ll_round((F32)line_height * mLineSpacingMult) + mLineSpacingPixels;
                break;
            }
            // ...or finished a segment and there are segments remaining on this line
            else
            {
                // subtract pixels used and increment segment
                if (force_newline)
                {
                    mLineInfoList.push_back(line_info(
                                                line_start_index,
                                                last_segment_char_on_line,
                                                line_rect,
                                                line_count));
                    line_start_index = segment->getStart() + seg_offset;
                    cur_top -= ll_round((F32)line_height * mLineSpacingMult) + mLineSpacingPixels;
                    line_height = 0;
                    remaining_pixels = text_available_width;
                }
                ++seg_iter;
                seg_offset = 0;
                seg_line_offset = force_newline ? line_count + 1 : line_count;
            }
            if (force_newline)
            {
                line_count++;
            }
        }

        // calculate visible region for diplaying text
        updateRects();

        for (segment_set_t::iterator segment_it = mSegments.begin();
            segment_it != mSegments.end();
            ++segment_it)
        {
            LLTextSegmentPtr segmentp = *segment_it;
            segmentp->updateLayout(*this);

        }
    }

    // apply scroll constraints after reflowing text
    if (!hasMouseCapture() && mScroller)
    {
        if (scrolled_to_bottom && mTrackEnd)
        {
            // keep bottom of text buffer visible
            endOfDoc();
        }
        else if (hasSelection() && follow_selection)
        {
            // keep cursor in same vertical position on screen when selecting text
            LLRect new_cursor_rect_doc = getDocRectFromDocIndex(mCursorPos);
            LLRect old_cursor_rect = cursor_rect;
            old_cursor_rect.mTop = mVisibleTextRect.mTop - cursor_rect.mTop;
            old_cursor_rect.mBottom = mVisibleTextRect.mTop - cursor_rect.mBottom;

            mScroller->scrollToShowRect(new_cursor_rect_doc, old_cursor_rect);
        }
        else
        {
            // keep first line of text visible
            LLRect new_first_char_rect = getDocRectFromDocIndex(mScrollIndex);

            // pass in desired rect in the coordinate frame of the document viewport
            LLRect old_first_char_rect = first_char_rect;
            old_first_char_rect.mTop = mVisibleTextRect.mTop - first_char_rect.mTop;
            old_first_char_rect.mBottom = mVisibleTextRect.mTop - first_char_rect.mBottom;

            mScroller->scrollToShowRect(new_first_char_rect, old_first_char_rect);
        }
    }

    // reset desired x cursor position
    updateCursorXPos();
}

LLRect LLTextBase::getTextBoundingRect()
{
    reflow();
    return mTextBoundingRect;
}


void LLTextBase::clearSegments()
{
    mSegments.clear();
    createDefaultSegment();
}

S32 LLTextBase::getLineStart( S32 line ) const
{
    S32 num_lines = getLineCount();
    if (num_lines == 0)
    {
        return 0;
    }

    line = llclamp(line, 0, num_lines-1);
    return mLineInfoList[line].mDocIndexStart;
}

S32 LLTextBase::getLineEnd( S32 line ) const
{
    S32 num_lines = getLineCount();
    if (num_lines == 0)
    {
        return 0;
    }

    line = llclamp(line, 0, num_lines-1);
    return mLineInfoList[line].mDocIndexEnd;
}



S32 LLTextBase::getLineNumFromDocIndex( S32 doc_index, bool include_wordwrap) const
{
    if (mLineInfoList.empty())
    {
        return 0;
    }
    else
    {
        line_list_t::const_iterator iter = std::upper_bound(mLineInfoList.begin(), mLineInfoList.end(), doc_index, line_end_compare());
        if (include_wordwrap)
        {
            return iter - mLineInfoList.begin();
        }
        else
        {
            if (iter == mLineInfoList.end())
            {
                return mLineInfoList.back().mLineNum;
            }
            else
            {
                return iter->mLineNum;
            }
        }
    }
}

// Given an offset into text (pos), find the corresponding line (from the start of the doc) and an offset into the line.
S32 LLTextBase::getLineOffsetFromDocIndex( S32 startpos, bool include_wordwrap) const
{
    if (mLineInfoList.empty())
    {
        return startpos;
    }
    else
    {
        line_list_t::const_iterator iter = std::upper_bound(mLineInfoList.begin(), mLineInfoList.end(), startpos, line_end_compare());
        return startpos - iter->mDocIndexStart;
    }
}

S32 LLTextBase::getFirstVisibleLine() const
{
    LLRect visible_region = getVisibleDocumentRect();

    // binary search for line that starts before top of visible buffer
    line_list_t::const_iterator iter = std::lower_bound(mLineInfoList.begin(), mLineInfoList.end(), visible_region.mTop, compare_bottom());

    return iter - mLineInfoList.begin();
}

std::pair<S32, S32> LLTextBase::getVisibleLines(bool require_fully_visible)
{
    LLRect visible_region = getVisibleDocumentRect();
    line_list_t::const_iterator first_iter;
    line_list_t::const_iterator last_iter;

    // make sure we have an up-to-date mLineInfoList
    reflow();

    if (require_fully_visible)
    {
        first_iter = std::lower_bound(mLineInfoList.begin(), mLineInfoList.end(), visible_region.mTop, compare_top());
        last_iter = std::upper_bound(mLineInfoList.begin(), mLineInfoList.end(), visible_region.mBottom, compare_bottom());
    }
    else
    {
        first_iter = std::upper_bound(mLineInfoList.begin(), mLineInfoList.end(), visible_region.mTop, compare_bottom());
        last_iter = std::lower_bound(mLineInfoList.begin(), mLineInfoList.end(), visible_region.mBottom, compare_top());
    }
    return std::pair<S32, S32>(first_iter - mLineInfoList.begin(), last_iter - mLineInfoList.begin());
}



LLTextViewModel* LLTextBase::getViewModel() const
{
    return (LLTextViewModel*)mViewModel.get();
}

void LLTextBase::addDocumentChild(LLView* view)
{
    mDocumentView->addChild(view);
}

void LLTextBase::removeDocumentChild(LLView* view)
{
    mDocumentView->removeChild(view);
}


void LLTextBase::updateSegments()
{
    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
    createDefaultSegment();
}

void LLTextBase::getSegmentAndOffset( S32 startpos, segment_set_t::const_iterator* seg_iter, S32* offsetp ) const
{
    *seg_iter = getSegIterContaining(startpos);
    if (*seg_iter == mSegments.end())
    {
        *offsetp = 0;
    }
    else
    {
        *offsetp = startpos - (**seg_iter)->getStart();
    }
}

void LLTextBase::getSegmentAndOffset( S32 startpos, segment_set_t::iterator* seg_iter, S32* offsetp )
{
    *seg_iter = getSegIterContaining(startpos);
    if (*seg_iter == mSegments.end())
    {
        *offsetp = 0;
    }
    else
    {
        *offsetp = startpos - (**seg_iter)->getStart();
    }
}

LLTextBase::segment_set_t::iterator LLTextBase::getEditableSegIterContaining(S32 index)
{
    segment_set_t::iterator it = getSegIterContaining(index);
    segment_set_t::iterator orig_it = it;

    if (it == mSegments.end()) return it;

    if (!(*it)->canEdit()
        && index == (*it)->getStart()
        && it != mSegments.begin())
    {
        it--;
        if ((*it)->canEdit())
        {
            return it;
        }
    }
    return orig_it;
}

LLTextBase::segment_set_t::const_iterator LLTextBase::getEditableSegIterContaining(S32 index) const
{
    segment_set_t::const_iterator it = getSegIterContaining(index);
    segment_set_t::const_iterator orig_it = it;
    if (it == mSegments.end()) return it;

    if (!(*it)->canEdit()
        && index == (*it)->getStart()
        && it != mSegments.begin())
    {
        it--;
        if ((*it)->canEdit())
        {
            return it;
        }
    }
    return orig_it;
}

LLTextBase::segment_set_t::iterator LLTextBase::getSegIterContaining(S32 index)
{
    static LLPointer<LLIndexSegment> index_segment = new LLIndexSegment();

    // when there are no segments, we return the end iterator, which must be checked by caller
    if (mSegments.size() <= 1) { return mSegments.begin(); }

    index_segment->setStart(index);
    index_segment->setEnd(index);
    segment_set_t::iterator it = mSegments.upper_bound(index_segment);
    return it;
}

LLTextBase::segment_set_t::const_iterator LLTextBase::getSegIterContaining(S32 index) const
{
    static LLPointer<LLIndexSegment> index_segment = new LLIndexSegment();

    // when there are no segments, we return the end iterator, which must be checked by caller
    if (mSegments.size() <= 1) { return mSegments.begin(); }

    index_segment->setStart(index);
    index_segment->setEnd(index);
    LLTextBase::segment_set_t::const_iterator it =  mSegments.upper_bound(index_segment);
    return it;
}

// Finds the text segment (if any) at the give local screen position
LLTextSegmentPtr LLTextBase::getSegmentAtLocalPos( S32 x, S32 y, bool hit_past_end_of_line)
{
    // Find the cursor position at the requested local screen position
    S32 offset = getDocIndexFromLocalCoord( x, y, false, hit_past_end_of_line);
    segment_set_t::iterator seg_iter = getSegIterContaining(offset);
    if (seg_iter != mSegments.end())
    {
        return *seg_iter;
    }
    else
    {
        return LLTextSegmentPtr();
    }
}

void LLTextBase::createUrlContextMenu(S32 x, S32 y, const std::string &in_url)
{
    // work out the XUI menu file to use for this url
    LLUrlMatch match;
    std::string url = in_url;
    if (! LLUrlRegistry::instance().findUrl(url, match))
    {
        return;
    }

    std::string xui_file = match.getMenuName();
    if (xui_file.empty())
    {
        return;
    }

    // set up the callbacks for all of the potential menu items, N.B. we
    // don't use const ref strings in callbacks in case url goes out of scope
    LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
    registrar.add("Url.Open", boost::bind(&LLUrlAction::openURL, url));
    registrar.add("Url.OpenInternal", boost::bind(&LLUrlAction::openURLInternal, url));
    registrar.add("Url.OpenExternal", boost::bind(&LLUrlAction::openURLExternal, url));
    registrar.add("Url.Execute", boost::bind(&LLUrlAction::executeSLURL, url, true));
    registrar.add("Url.Block", boost::bind(&LLUrlAction::blockObject, url));
    registrar.add("Url.Unblock", boost::bind(&LLUrlAction::unblockObject, url));
    registrar.add("Url.Teleport", boost::bind(&LLUrlAction::teleportToLocation, url));
    registrar.add("Url.ShowProfile", boost::bind(&LLUrlAction::showProfile, url));
    registrar.add("Url.AddFriend", boost::bind(&LLUrlAction::addFriend, url));
    registrar.add("Url.RemoveFriend", boost::bind(&LLUrlAction::removeFriend, url));
    registrar.add("Url.ReportAbuse", boost::bind(&LLUrlAction::reportAbuse, url));
    registrar.add("Url.SendIM", boost::bind(&LLUrlAction::sendIM, url));
    registrar.add("Url.ShowOnMap", boost::bind(&LLUrlAction::showLocationOnMap, url));
    registrar.add("Url.CopyLabel", boost::bind(&LLUrlAction::copyLabelToClipboard, url));
    registrar.add("Url.CopyUrl", boost::bind(&LLUrlAction::copyURLToClipboard, url));

    // create and return the context menu from the XUI file

    LLContextMenu* menu = static_cast<LLContextMenu*>(mPopupMenuHandle.get());
    if (menu)
    {
        menu->die();
        mPopupMenuHandle.markDead();
    }
    llassert(LLMenuGL::sMenuContainer != NULL);
    menu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>(xui_file, LLMenuGL::sMenuContainer,
                                                                         LLMenuHolderGL::child_registry_t::instance());
    if (menu)
    {
        mPopupMenuHandle = menu->getHandle();

        if (mIsFriendSignal)
        {
            bool isFriend = *(*mIsFriendSignal)(LLUUID(LLUrlAction::getUserID(url)));
            LLView* addFriendButton = menu->getChild<LLView>("add_friend");
            LLView* removeFriendButton = menu->getChild<LLView>("remove_friend");

            if (addFriendButton && removeFriendButton)
            {
                addFriendButton->setEnabled(!isFriend);
                removeFriendButton->setEnabled(isFriend);
            }
        }

        if (mIsObjectBlockedSignal)
        {
            bool is_blocked = *(*mIsObjectBlockedSignal)(LLUUID(LLUrlAction::getObjectId(url)), LLUrlAction::getObjectName(url));
            LLView* blockButton = menu->getChild<LLView>("block_object");
            LLView* unblockButton = menu->getChild<LLView>("unblock_object");

            if (blockButton && unblockButton)
            {
                blockButton->setVisible(!is_blocked);
                unblockButton->setVisible(is_blocked);
            }
        }
        menu->show(x, y);
        LLMenuGL::showPopup(this, menu, x, y);
    }
}

void LLTextBase::setText(const LLStringExplicit &utf8str, const LLStyle::Params& input_params)
{
    // clear out the existing text and segments
    getViewModel()->setDisplay(LLWStringUtil::null);

    clearSegments();
//  createDefaultSegment();

    deselect();

    // append the new text (supports Url linking)
    std::string text(utf8str);
    LLStringUtil::removeCRLF(text);

    // appendText modifies mCursorPos...
    appendText(text, false, input_params);
    // ...so move cursor to top after appending text
    if (!mTrackEnd)
    {
        startOfDoc();
    }

    onValueChange(0, getLength());
}

// virtual
const std::string& LLTextBase::getText() const
{
    return getViewModel()->getStringValue();
}

// IDEVO - icons can be UI image names or UUID sent from
// server with avatar display name
static LLUIImagePtr image_from_icon_name(const std::string& icon_name)
{
    if (LLUUID::validate(icon_name))
    {
        return LLUI::getUIImageByID( LLUUID(icon_name) );
    }
    else
    {
        return LLUI::getUIImage(icon_name);
    }
}


void LLTextBase::appendTextImpl(const std::string &new_text, const LLStyle::Params& input_params)
{
    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
    LLStyle::Params style_params(input_params);
    style_params.fillFrom(getStyleParams());

    S32 part = (S32)LLTextParser::WHOLE;
    if (mParseHTML && !style_params.is_link) // Don't search for URLs inside a link segment (STORM-358).
    {
        S32 start=0,end=0;
        LLUrlMatch match;
        std::string text = new_text;
        while (LLUrlRegistry::instance().findUrl(text, match,
                boost::bind(&LLTextBase::replaceUrl, this, _1, _2, _3), isContentTrusted() || mAlwaysShowIcons))
        {
            start = match.getStart();
            end = match.getEnd()+1;

            LLStyle::Params link_params(style_params);
            link_params.overwriteFrom(match.getStyle());

            // output the text before the Url
            if (start > 0)
            {
                if (part == (S32)LLTextParser::WHOLE ||
                    part == (S32)LLTextParser::START)
                {
                    part = (S32)LLTextParser::START;
                }
                else
                {
                    part = (S32)LLTextParser::MIDDLE;
                }
                std::string subtext=text.substr(0,start);
                appendAndHighlightText(subtext, part, style_params);
            }

            // add icon before url if need
            LLTextUtil::processUrlMatch(&match, this, isContentTrusted() || match.isTrusted() || mAlwaysShowIcons);
            if ((isContentTrusted() || match.isTrusted()) && !match.getIcon().empty() )
            {
                setLastSegmentToolTip(LLTrans::getString("TooltipSLIcon"));
            }

            // output the styled Url
            appendAndHighlightTextImpl(match.getLabel(), part, link_params, match.underlineOnHoverOnly());
            bool tooltip_required =  !match.getTooltip().empty();

            // set the tooltip for the Url label
            if (tooltip_required)
            {
                setLastSegmentToolTip(match.getTooltip());
            }

            // show query part of url with gray color only for LLUrlEntryHTTP url entries
            std::string label = match.getQuery();
            if (label.size())
            {
                link_params.color = LLColor4::grey;
                link_params.readonly_color = LLColor4::grey;
                appendAndHighlightTextImpl(label, part, link_params, match.underlineOnHoverOnly());

                // set the tooltip for the query part of url
                if (tooltip_required)
                {
                    setLastSegmentToolTip(match.getTooltip());
                }
            }

            // move on to the rest of the text after the Url
            if (end < (S32)text.length())
            {
                text = text.substr(end,text.length() - end);
                end=0;
                part=(S32)LLTextParser::END;
            }
            else
            {
                break;
            }
        }
        if (part != (S32)LLTextParser::WHOLE)
            part=(S32)LLTextParser::END;
        if (end < (S32)text.length())
            appendAndHighlightText(text, part, style_params);
    }
    else
    {
        appendAndHighlightText(new_text, part, style_params);
    }
}

void LLTextBase::setLastSegmentToolTip(const std::string &tooltip)
{
    segment_set_t::iterator it = getSegIterContaining(getLength()-1);
    if (it != mSegments.end())
    {
        LLTextSegmentPtr segment = *it;
        segment->setToolTip(tooltip);
    }
}

void LLTextBase::appendText(const std::string &new_text, bool prepend_newline, const LLStyle::Params& input_params)
{
    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
    if (new_text.empty())
        return;

    if(prepend_newline)
        appendLineBreakSegment(input_params);
    appendTextImpl(new_text,input_params);
}

void LLTextBase::setLabel(const LLStringExplicit& label)
{
    mLabel = label;
    resetLabel();
}

bool LLTextBase::setLabelArg(const std::string& key, const LLStringExplicit& text )
{
    mLabel.setArg(key, text);
    return true;
}

void LLTextBase::resetLabel()
{
    if (useLabel())
    {
        clearSegments();

        LLStyle* style = new LLStyle(getStyleParams());
        style->setColor(mTentativeFgColor);
        LLStyleConstSP sp(style);

        LLTextSegmentPtr label = new LLLabelTextSegment(sp, 0, static_cast<S32>(mLabel.getWString().length()) + 1, *this);
        insertSegment(label);
    }
}

bool LLTextBase::useLabel() const
{
    return !getLength() && !mLabel.empty() && !hasFocus();
}

void LLTextBase::setFont(const LLFontGL* font)
{
    mFont = font;
    mStyleDirty = true;
}

void LLTextBase::needsReflow(S32 index)
{
    LL_DEBUGS() << "reflow on object " << (void*)this << " index = " << mReflowIndex << ", new index = " << index << LL_ENDL;
    mReflowIndex = llmin(mReflowIndex, index);
}

S32 LLTextBase::removeFirstLine()
{
    if (!mLineInfoList.empty())
    {
        S32 length = getLineEnd(0);
        deselect();
        removeStringNoUndo(0, length);
        return length;
    }
    return 0;
}

void LLTextBase::appendLineBreakSegment(const LLStyle::Params& style_params)
{
    segment_vec_t segments;
    LLStyleConstSP sp(new LLStyle(style_params));
    segments.push_back(new LLLineBreakTextSegment(sp, getLength()));

    insertStringNoUndo(getLength(), utf8str_to_wstring("\n"), &segments);
}

void LLTextBase::appendImageSegment(const LLStyle::Params& style_params)
{
    if(getPlainText())
    {
        return;
    }
    segment_vec_t segments;
    LLStyleConstSP sp(new LLStyle(style_params));
    segments.push_back(new LLImageTextSegment(sp, getLength(),*this));

    insertStringNoUndo(getLength(), utf8str_to_wstring(" "), &segments);
}

void LLTextBase::appendWidget(const LLInlineViewSegment::Params& params, const std::string& text, bool allow_undo)
{
    segment_vec_t segments;
    LLWString widget_wide_text = utf8str_to_wstring(text);
    segments.push_back(new LLInlineViewSegment(params, getLength(), getLength() + static_cast<S32>(widget_wide_text.size())));

    insertStringNoUndo(getLength(), widget_wide_text, &segments);
}

void LLTextBase::appendAndHighlightTextImpl(const std::string &new_text, S32 highlight_part, const LLStyle::Params& style_params, bool underline_on_hover_only)
{
    // Save old state
    S32 selection_start = mSelectionStart;
    S32 selection_end = mSelectionEnd;
    bool was_selecting = mIsSelecting;
    S32 cursor_pos = mCursorPos;
    S32 old_length = getLength();
    bool cursor_was_at_end = (mCursorPos == old_length);

    deselect();

    setCursorPos(old_length);

    if (mParseHighlights)
    {
        LLStyle::Params highlight_params(style_params);

        LLSD pieces = LLTextParser::instance().parsePartialLineHighlights(new_text, highlight_params.color(), (LLTextParser::EHighlightPosition)highlight_part);
        for (S32 i = 0; i < pieces.size(); i++)
        {
            LLSD color_llsd = pieces[i]["color"];
            LLColor4 lcolor;
            lcolor.setValue(color_llsd);
            highlight_params.color = lcolor;

            LLWString wide_text;
            wide_text = utf8str_to_wstring(pieces[i]["text"].asString());

            S32 cur_length = getLength();
            LLStyleConstSP sp(new LLStyle(highlight_params));
            LLTextSegmentPtr segmentp;
            if (underline_on_hover_only || mSkipLinkUnderline)
            {
                highlight_params.font.style("NORMAL");
                LLStyleConstSP normal_sp(new LLStyle(highlight_params));
                segmentp = new LLOnHoverChangeableTextSegment(sp, normal_sp, cur_length, cur_length + static_cast<S32>(wide_text.size()), *this);
            }
            else
            {
                segmentp = new LLNormalTextSegment(sp, cur_length, cur_length + static_cast<S32>(wide_text.size()), *this);
            }
            segment_vec_t segments;
            segments.push_back(segmentp);
            insertStringNoUndo(cur_length, wide_text, &segments);
        }
    }
    else
    {
        LLWString wide_text;
        wide_text = utf8str_to_wstring(new_text);

        segment_vec_t segments;
        S32 segment_start = old_length;
        S32 segment_end = old_length + static_cast<S32>(wide_text.size());
        LLStyleConstSP sp(new LLStyle(style_params));
        if (underline_on_hover_only || mSkipLinkUnderline)
        {
            LLStyle::Params normal_style_params(style_params);
            normal_style_params.font.style("NORMAL");
            LLStyleConstSP normal_sp(new LLStyle(normal_style_params));
            segments.push_back(new LLOnHoverChangeableTextSegment(sp, normal_sp, segment_start, segment_end, *this));
        }
        else
        {
            segments.push_back(new LLNormalTextSegment(sp, segment_start, segment_end, *this));
        }

        insertStringNoUndo(getLength(), wide_text, &segments);
    }

    // Set the cursor and scroll position
    if (selection_start != selection_end)
    {
        mSelectionStart = selection_start;
        mSelectionEnd = selection_end;

        mIsSelecting = was_selecting;
        setCursorPos(cursor_pos);
    }
    else if (cursor_was_at_end)
    {
        setCursorPos(getLength());
    }
    else
    {
        setCursorPos(cursor_pos);
    }
}

void LLTextBase::appendAndHighlightText(const std::string &new_text, S32 highlight_part, const LLStyle::Params& style_params, bool underline_on_hover_only)
{
    if (new_text.empty())
    {
        return;
    }

    std::string::size_type start = 0;
    std::string::size_type pos = new_text.find("\n", start);

    while (pos != std::string::npos)
    {
        if (pos != start)
        {
            std::string str = std::string(new_text,start,pos-start);
            appendAndHighlightTextImpl(str, highlight_part, style_params, underline_on_hover_only);
        }
        appendLineBreakSegment(style_params);
        start = pos+1;
        pos = new_text.find("\n", start);
    }

    std::string str = std::string(new_text, start, new_text.length() - start);
    appendAndHighlightTextImpl(str, highlight_part, style_params, underline_on_hover_only);
}


void LLTextBase::replaceUrl(const std::string &url,
                            const std::string &label,
                            const std::string &icon)
{
    // get the full (wide) text for the editor so we can change it
    LLWString text = getWText();
    LLWString wlabel = utf8str_to_wstring(label);
    bool modified = false;
    S32 seg_start = 0;

    // iterate through each segment looking for ones styled as links
    segment_set_t::iterator it;
    for (it = mSegments.begin(); it != mSegments.end(); ++it)
    {
        LLTextSegment *seg = *it;
        LLStyleConstSP style = seg->getStyle();

        // update segment start/end length in case we replaced text earlier
        S32 seg_length = seg->getEnd() - seg->getStart();
        seg->setStart(seg_start);
        seg->setEnd(seg_start + seg_length);

        // if we find a link with our Url, then replace the label
        if (style->getLinkHREF() == url)
        {
            S32 start = seg->getStart();
            S32 end = seg->getEnd();
            text = text.substr(0, start) + wlabel + text.substr(end, text.size() - end + 1);
            seg->setEnd(start + static_cast<S32>(wlabel.size()));
            modified = true;
        }

        // Icon might be updated when more avatar or group info
        // becomes available
        if (style->isImage() && style->getLinkHREF() == url)
        {
            LLUIImagePtr image = image_from_icon_name( icon );
            if (image)
            {
                LLStyle::Params icon_params;
                icon_params.image = image;
                LLStyleConstSP new_style(new LLStyle(icon_params));
                seg->setStyle(new_style);
                modified = true;
            }
        }

        // work out the character offset for the next segment
        seg_start = seg->getEnd();
    }

    // update the editor with the new (wide) text string
    if (modified)
    {
        getViewModel()->setDisplay(text);
        deselect();
        setCursorPos(mCursorPos);
        needsReflow();
    }
}


void LLTextBase::setWText(const LLWString& text)
{
    setText(wstring_to_utf8str(text));
}

const LLWString& LLTextBase::getWText() const
{
    return getViewModel()->getDisplay();
}

// If round is true, if the position is on the right half of a character, the cursor
// will be put to its right.  If round is false, the cursor will always be put to the
// character's left.

S32 LLTextBase::getDocIndexFromLocalCoord( S32 local_x, S32 local_y, bool round, bool hit_past_end_of_line) const
{
    // Figure out which line we're nearest to.
    LLRect doc_rect = mDocumentView->getRect();
    S32 doc_y = local_y - doc_rect.mBottom;

    // binary search for line that starts before local_y
    line_list_t::const_iterator line_iter = std::lower_bound(mLineInfoList.begin(), mLineInfoList.end(), doc_y, compare_bottom());

    if (!mLineInfoList.size() || line_iter == mLineInfoList.end())
    {
        return getLength(); // past the end
    }

    S32 pos = getLength();
    F32 start_x = line_iter->mRect.mLeft + doc_rect.mLeft;

    segment_set_t::iterator line_seg_iter;
    S32 line_seg_offset;
    for(getSegmentAndOffset(line_iter->mDocIndexStart, &line_seg_iter, &line_seg_offset);
        line_seg_iter != mSegments.end();
        ++line_seg_iter, line_seg_offset = 0)
    {
        const LLTextSegmentPtr segmentp = *line_seg_iter;

        S32 segment_line_start = segmentp->getStart() + line_seg_offset;
        S32 segment_line_length = llmin(segmentp->getEnd(), line_iter->mDocIndexEnd) - segment_line_start;
        F32 text_width;
        S32 text_height;
        bool newline = segmentp->getDimensionsF32(line_seg_offset, segment_line_length, text_width, text_height);

        if(newline)
        {
            pos = segment_line_start + segmentp->getOffset(local_x - start_x, line_seg_offset, segment_line_length, round);
            break;
        }

        // if we've reached a line of text *below* the mouse cursor, doc index is first character on that line
        if (hit_past_end_of_line && doc_y > line_iter->mRect.mTop)
        {
            pos = segment_line_start;
            break;
        }
        if (local_x < start_x + text_width)         // cursor to left of right edge of text
        {
            // Figure out which character we're nearest to.
            S32 offset;
            if (!segmentp->canEdit())
            {
                F32 segment_width;
                S32 segment_height;
                segmentp->getDimensionsF32(0, segmentp->getEnd() - segmentp->getStart(), segment_width, segment_height);
                if (round && local_x - start_x > segment_width / 2)
                {
                    offset = segment_line_length;
                }
                else
                {
                    offset = 0;
                }
            }
            else
            {
                offset = segmentp->getOffset(local_x - start_x, line_seg_offset, segment_line_length, round);
            }
            pos = segment_line_start + offset;
            break;
        }
        else if (hit_past_end_of_line && segmentp->getEnd() >= line_iter->mDocIndexEnd)
        {
            if (getLineNumFromDocIndex(line_iter->mDocIndexEnd - 1) == line_iter->mLineNum)
            {
                // if segment wraps to the next line we should step one char back
                // to compensate for the space char between words
                // which is removed due to wrapping
                pos = llclamp(line_iter->mDocIndexEnd - 1, 0, getLength());
            }
            else
            {
                pos = llclamp(line_iter->mDocIndexEnd, 0, getLength());
            }
            break;
        }
        start_x += text_width;
    }

    return pos;
}

// returns rectangle of insertion caret
// in document coordinate frame from given index into text
LLRect LLTextBase::getDocRectFromDocIndex(S32 pos) const
{
    if (mLineInfoList.empty())
    {
        return LLRect();
    }

    // clamp pos to valid values
    pos = llclamp(pos, 0, mLineInfoList.back().mDocIndexEnd - 1);

    line_list_t::const_iterator line_iter = std::upper_bound(mLineInfoList.begin(), mLineInfoList.end(), pos, line_end_compare());

    segment_set_t::iterator line_seg_iter;
    S32 line_seg_offset;
    segment_set_t::iterator cursor_seg_iter;
    S32 cursor_seg_offset;
    getSegmentAndOffset(line_iter->mDocIndexStart, &line_seg_iter, &line_seg_offset);
    getSegmentAndOffset(pos, &cursor_seg_iter, &cursor_seg_offset);

    F32 doc_left_precise = line_iter->mRect.mLeft;

    while(line_seg_iter != mSegments.end())
    {
        const LLTextSegmentPtr segmentp = *line_seg_iter;

        if (line_seg_iter == cursor_seg_iter)
        {
            // cursor advanced to right based on difference in offset of cursor to start of line
            F32 segment_width;
            S32 segment_height;
            segmentp->getDimensionsF32(line_seg_offset, cursor_seg_offset - line_seg_offset, segment_width, segment_height);
            doc_left_precise += segment_width;

            break;
        }
        else
        {
            // add remainder of current text segment to cursor position
            F32 segment_width;
            S32 segment_height;
            segmentp->getDimensionsF32(line_seg_offset, (segmentp->getEnd() - segmentp->getStart()) - line_seg_offset, segment_width, segment_height);
            doc_left_precise += segment_width;
            // offset will be 0 for all segments after the first
            line_seg_offset = 0;
            // go to next text segment on this line
            ++line_seg_iter;
        }
    }

    LLRect doc_rect;
    doc_rect.mLeft = doc_left_precise;
    doc_rect.mBottom = line_iter->mRect.mBottom;
    doc_rect.mTop = line_iter->mRect.mTop;

    // set rect to 0 width
    doc_rect.mRight = doc_rect.mLeft;

    return doc_rect;
}

LLRect LLTextBase::getLocalRectFromDocIndex(S32 pos) const
{
    LLRect content_window_rect = mScroller ? mScroller->getContentWindowRect() : getLocalRect();
    if (mBorderVisible)
    {
        content_window_rect.stretch(-1);
    }

    LLRect local_rect;

    if (mLineInfoList.empty())
    {
        // return default height rect in upper left
        local_rect = content_window_rect;
        local_rect.mBottom = local_rect.mTop - mFont->getLineHeight();
        return local_rect;
    }

    // get the rect in document coordinates
    LLRect doc_rect = getDocRectFromDocIndex(pos);

    // compensate for scrolled, inset view of doc
    LLRect scrolled_view_rect = getVisibleDocumentRect();
    local_rect = doc_rect;
    local_rect.translate(content_window_rect.mLeft - scrolled_view_rect.mLeft,
                        content_window_rect.mBottom - scrolled_view_rect.mBottom);

    return local_rect;
}

void LLTextBase::updateCursorXPos()
{
    // reset desired x cursor position
    mDesiredXPixel = getLocalRectFromDocIndex(mCursorPos).mLeft;
}


void LLTextBase::startOfLine()
{
    S32 offset = getLineOffsetFromDocIndex(mCursorPos);
    setCursorPos(mCursorPos - offset);
}

void LLTextBase::endOfLine()
{
    S32 line = getLineNumFromDocIndex(mCursorPos);
    S32 num_lines = getLineCount();
    if (line + 1 >= num_lines)
    {
        setCursorPos(getLength());
    }
    else
    {
        setCursorPos( getLineStart(line + 1) - 1 );
    }
}

void LLTextBase::startOfDoc()
{
    setCursorPos(0);
    if (mScroller)
    {
        mScroller->goToTop();
    }
}

void LLTextBase::endOfDoc()
{
    setCursorPos(getLength());
    if (mScroller)
    {
        mScroller->goToBottom();
    }
}

void LLTextBase::changePage( S32 delta )
{
    const S32 PIXEL_OVERLAP_ON_PAGE_CHANGE = 10;
    if (delta == 0 || !mScroller) return;

    LLRect cursor_rect = getLocalRectFromDocIndex(mCursorPos);

    if( delta == -1 )
    {
        mScroller->pageUp(PIXEL_OVERLAP_ON_PAGE_CHANGE);
    }
    else
    if( delta == 1 )
    {
        mScroller->pageDown(PIXEL_OVERLAP_ON_PAGE_CHANGE);
    }

    if (getLocalRectFromDocIndex(mCursorPos) == cursor_rect)
    {
        // cursor didn't change apparent position, so move to top or bottom of document, respectively
        if (delta < 0)
        {
            startOfDoc();
        }
        else
        {
            endOfDoc();
        }
    }
    else
    {
        setCursorAtLocalPos(cursor_rect.getCenterX(), cursor_rect.getCenterY(), true, false);
    }
}

// Picks a new cursor position based on the screen size of text being drawn.
void LLTextBase::setCursorAtLocalPos( S32 local_x, S32 local_y, bool round, bool keep_cursor_offset )
{
    setCursorPos(getDocIndexFromLocalCoord(local_x, local_y, round), keep_cursor_offset);
}


void LLTextBase::changeLine( S32 delta )
{
    S32 line = getLineNumFromDocIndex(mCursorPos);
    S32 max_line_nb = getLineCount() - 1;
    max_line_nb = (max_line_nb < 0 ? 0 : max_line_nb);

    S32 new_line = llclamp(line + delta, 0, max_line_nb);

    if (new_line != line)
    {
        LLRect visible_region = getVisibleDocumentRect();
        S32 new_cursor_pos = getDocIndexFromLocalCoord(mDesiredXPixel,
                                                       mLineInfoList[new_line].mRect.mBottom + mVisibleTextRect.mBottom - visible_region.mBottom, true);
        S32 actual_line = getLineNumFromDocIndex(new_cursor_pos);
        if (actual_line != new_line)
        {
            // line edge, correcting position by 1 to move onto proper line
            new_cursor_pos += new_line - actual_line;
        }
        setCursorPos(new_cursor_pos, true);
    }
}

bool LLTextBase::scrolledToStart()
{
    return mScroller->isAtTop();
}

bool LLTextBase::scrolledToEnd()
{
    return mScroller->isAtBottom();
}

bool LLTextBase::setCursor(S32 row, S32 column)
{
    if (row < 0 || column < 0) return false;

    S32 n_lines = static_cast<S32>(mLineInfoList.size());
    for (S32 line = row; line < n_lines; ++line)
    {
        const line_info& li = mLineInfoList[line];

        if (li.mLineNum < row)
        {
            continue;
        }
        else if (li.mLineNum > row)
        {
            break; // invalid column specified
        }

        // Found the given row.
        S32 line_length = li.mDocIndexEnd - li.mDocIndexStart;;
        if (column >= line_length)
        {
            column -= line_length;
            continue;
        }

        // Found the given column.
        updateCursorXPos();
        S32 doc_pos = li.mDocIndexStart + column;
        return setCursorPos(doc_pos);
    }

    return false; // invalid row or column specified
}


bool LLTextBase::setCursorPos(S32 cursor_pos, bool keep_cursor_offset)
{
    S32 new_cursor_pos = cursor_pos;
    if (new_cursor_pos != mCursorPos)
    {
        new_cursor_pos = getEditableIndex(new_cursor_pos, new_cursor_pos >= mCursorPos);
    }

    mCursorPos = llclamp(new_cursor_pos, 0, (S32)getLength());
    needsScroll();
    if (!keep_cursor_offset)
        updateCursorXPos();
    // did we get requested position?
    return new_cursor_pos == cursor_pos;
}

// constraint cursor to editable segments of document
S32 LLTextBase::getEditableIndex(S32 index, bool increasing_direction)
{
    segment_set_t::iterator segment_iter;
    S32 offset;
    getSegmentAndOffset(index, &segment_iter, &offset);
    if (segment_iter == mSegments.end())
    {
        return 0;
    }

    LLTextSegmentPtr segmentp = *segment_iter;

    if (segmentp->canEdit())
    {
        return segmentp->getStart() + offset;
    }
    else if (segmentp->getStart() < index && index < segmentp->getEnd())
    {
        // bias towards document end
        if (increasing_direction)
        {
            return segmentp->getEnd();
        }
        // bias towards document start
        else
        {
            return segmentp->getStart();
        }
    }
    else
    {
        return index;
    }
}

void LLTextBase::updateRects()
{
    LLRect old_text_rect = mVisibleTextRect;
    mVisibleTextRect = mScroller ? mScroller->getContentWindowRect() : getLocalRect();

    if (mLineInfoList.empty())
    {
        mTextBoundingRect = LLRect(0, mVPad, mHPad, 0);
    }
    else
    {
        mTextBoundingRect = mLineInfoList.begin()->mRect;
        for (line_list_t::const_iterator line_iter = ++mLineInfoList.begin();
            line_iter != mLineInfoList.end();
            ++line_iter)
        {
            mTextBoundingRect.unionWith(line_iter->mRect);
        }

        mTextBoundingRect.mTop += mVPad;

        S32 delta_pos = 0;

        switch(mVAlign)
        {
        case LLFontGL::TOP:
            delta_pos = llmax(mVisibleTextRect.getHeight() - mTextBoundingRect.mTop, -mTextBoundingRect.mBottom);
            break;
        case LLFontGL::VCENTER:
            delta_pos = (llmax(mVisibleTextRect.getHeight() - mTextBoundingRect.mTop, -mTextBoundingRect.mBottom) + (mVisibleTextRect.mBottom - mTextBoundingRect.mBottom)) / 2;
            break;
        case LLFontGL::BOTTOM:
            delta_pos = mVisibleTextRect.mBottom - mTextBoundingRect.mBottom;
            break;
        case LLFontGL::BASELINE:
            // do nothing
            break;
        }
        // move line segments to fit new document rect
        for (line_list_t::iterator it = mLineInfoList.begin(); it != mLineInfoList.end(); ++it)
        {
            it->mRect.translate(0, delta_pos);
        }
        mTextBoundingRect.translate(0, delta_pos);
    }

    // update document container dimensions according to text contents
    LLRect doc_rect;
    // use old mVisibleTextRect constraint document to width of viewable region
    doc_rect.mBottom = llmin(mVisibleTextRect.mBottom,  mTextBoundingRect.mBottom);
    doc_rect.mLeft = 0;

    // allow horizontal scrolling?
    // if so, use entire width of text contents
    // otherwise, stop at width of mVisibleTextRect
    //FIXME: consider use of getWordWrap() instead
    doc_rect.mRight = mScroller
        ? llmax(mVisibleTextRect.getWidth(), mTextBoundingRect.mRight)
        : mVisibleTextRect.getWidth();
    doc_rect.mTop = llmax(mVisibleTextRect.mTop, mTextBoundingRect.mTop);

    if (!mScroller)
    {
        // push doc rect to top of text widget
        switch(mVAlign)
        {
        case LLFontGL::TOP:
            doc_rect.translate(0, mVisibleTextRect.getHeight() - doc_rect.mTop);
            break;
        case LLFontGL::VCENTER:
            doc_rect.translate(0, (mVisibleTextRect.getHeight() - doc_rect.mTop) / 2);
        case LLFontGL::BOTTOM:
        default:
            break;
        }
    }

    mDocumentView->setShape(doc_rect);

    //update mVisibleTextRect *after* mDocumentView has been resized
    // so that scrollbars are added if document needs to scroll
    // since mVisibleTextRect does not include scrollbars
    mVisibleTextRect = mScroller ? mScroller->getContentWindowRect() : getLocalRect();
    //FIXME: replace border with image?
    if (mBorderVisible)
    {
        mVisibleTextRect.stretch(-1);
    }
    if (mVisibleTextRect != old_text_rect)
    {
        needsReflow();
    }

    // update mTextBoundingRect after mVisibleTextRect took scrolls into account
    if (!mLineInfoList.empty() && mScroller)
    {
        S32 delta_pos = 0;

        switch(mVAlign)
        {
        case LLFontGL::TOP:
            delta_pos = llmax(mVisibleTextRect.getHeight() - mTextBoundingRect.mTop, -mTextBoundingRect.mBottom);
            break;
        case LLFontGL::VCENTER:
            delta_pos = (llmax(mVisibleTextRect.getHeight() - mTextBoundingRect.mTop, -mTextBoundingRect.mBottom) + (mVisibleTextRect.mBottom - mTextBoundingRect.mBottom)) / 2;
            break;
        case LLFontGL::BOTTOM:
            delta_pos = mVisibleTextRect.mBottom - mTextBoundingRect.mBottom;
            break;
        case LLFontGL::BASELINE:
            // do nothing
            break;
        }
        // move line segments to fit new visible rect
        if (delta_pos != 0)
        {
            for (line_list_t::iterator it = mLineInfoList.begin(); it != mLineInfoList.end(); ++it)
            {
                it->mRect.translate(0, delta_pos);
            }
            mTextBoundingRect.translate(0, delta_pos);
        }
    }

    // update document container again, using new mVisibleTextRect (that has scrollbars enabled as needed)
    doc_rect.mBottom = llmin(mVisibleTextRect.mBottom,  mTextBoundingRect.mBottom);
    doc_rect.mLeft = 0;
    doc_rect.mRight = mScroller
        ? llmax(mVisibleTextRect.getWidth(), mTextBoundingRect.mRight)
        : mVisibleTextRect.getWidth();
    doc_rect.mTop = llmax(mVisibleTextRect.getHeight(), mTextBoundingRect.getHeight()) + doc_rect.mBottom;
    if (!mScroller)
    {
        // push doc rect to top of text widget
        switch(mVAlign)
        {
        case LLFontGL::TOP:
            doc_rect.translate(0, mVisibleTextRect.getHeight() - doc_rect.mTop);
            break;
        case LLFontGL::VCENTER:
            doc_rect.translate(0, (mVisibleTextRect.getHeight() - doc_rect.mTop) / 2);
        case LLFontGL::BOTTOM:
        default:
            break;
        }
    }
    mDocumentView->setShape(doc_rect);
}


void LLTextBase::startSelection()
{
    if( !mIsSelecting )
    {
        mIsSelecting = true;
        mSelectionStart = mCursorPos;
        mSelectionEnd = mCursorPos;
    }
}

void LLTextBase::endSelection()
{
    if( mIsSelecting )
    {
        mIsSelecting = false;
        mSelectionEnd = mCursorPos;
    }
}

// get portion of document that is visible in text editor
LLRect LLTextBase::getVisibleDocumentRect() const
{
    if (mScroller)
    {
        return mScroller->getVisibleContentRect();
    }
    else if (mClip)
    {
        LLRect visible_text_rect = getVisibleTextRect();
        LLRect doc_rect = mDocumentView->getRect();
        visible_text_rect.translate(-doc_rect.mLeft, -doc_rect.mBottom);

        // reject partially visible lines
        LLRect visible_lines_rect;
        for (line_list_t::const_iterator it = mLineInfoList.begin(), end_it = mLineInfoList.end();
            it != end_it;
            ++it)
        {
            bool line_visible = mClipPartial ? visible_text_rect.contains(it->mRect) : visible_text_rect.overlaps(it->mRect);
            if (line_visible)
            {
                if (visible_lines_rect.isEmpty())
                {
                    visible_lines_rect = it->mRect;
                }
                else
                {
                    visible_lines_rect.unionWith(it->mRect);
                }
            }
        }
        return visible_lines_rect;
    }
    else
    {   // entire document rect is visible
        // but offset according to height of widget

        LLRect doc_rect = mDocumentView->getLocalRect();
        doc_rect.mLeft -= mDocumentView->getRect().mLeft;
        // adjust for height of text above widget baseline
        doc_rect.mBottom = doc_rect.getHeight() - mVisibleTextRect.getHeight();
        return doc_rect;
    }
}

boost::signals2::connection LLTextBase::setURLClickedCallback(const commit_signal_t::slot_type& cb)
{
    if (!mURLClickSignal)
    {
        mURLClickSignal = new commit_signal_t();
    }
    return mURLClickSignal->connect(cb);
}

boost::signals2::connection LLTextBase::setIsFriendCallback(const is_friend_signal_t::slot_type& cb)
{
    if (!mIsFriendSignal)
    {
        mIsFriendSignal = new is_friend_signal_t();
    }
    return mIsFriendSignal->connect(cb);
}

boost::signals2::connection LLTextBase::setIsObjectBlockedCallback(const is_blocked_signal_t::slot_type& cb)
{
    if (!mIsObjectBlockedSignal)
    {
        mIsObjectBlockedSignal = new is_blocked_signal_t();
    }
    return mIsObjectBlockedSignal->connect(cb);
}

//
// LLTextSegment
//

LLTextSegment::~LLTextSegment()
{}

bool LLTextSegment::getDimensionsF32(S32 first_char, S32 num_chars, F32& width, S32& height) const { width = 0; height = 0; return false; }
bool LLTextSegment::getDimensions(S32 first_char, S32 num_chars, S32& width, S32& height) const
{
    F32 fwidth = 0;
    bool result = getDimensionsF32(first_char, num_chars, fwidth, height);
    width = ll_round(fwidth);
    return result;
}

S32 LLTextSegment::getOffset(S32 segment_local_x_coord, S32 start_offset, S32 num_chars, bool round) const { return 0; }
S32 LLTextSegment::getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars, S32 line_ind) const { return 0; }
void LLTextSegment::updateLayout(const LLTextBase& editor) {}
F32 LLTextSegment::draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect) { return draw_rect.mLeft; }
bool LLTextSegment::canEdit() const { return false; }
void LLTextSegment::unlinkFromDocument(LLTextBase*) {}
void LLTextSegment::linkToDocument(LLTextBase*) {}
const LLColor4& LLTextSegment::getColor() const { return LLColor4::white; }
//void LLTextSegment::setColor(const LLColor4 &color) {}
LLStyleConstSP LLTextSegment::getStyle() const {static LLStyleConstSP sp(new LLStyle()); return sp; }
void LLTextSegment::setStyle(LLStyleConstSP style) {}
void LLTextSegment::setToken( LLKeywordToken* token ) {}
LLKeywordToken* LLTextSegment::getToken() const { return NULL; }
void LLTextSegment::setToolTip( const std::string &msg ) {}
void LLTextSegment::dump() const {}
bool LLTextSegment::handleMouseDown(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleMouseUp(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleMiddleMouseDown(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleMiddleMouseUp(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleRightMouseDown(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleRightMouseUp(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleDoubleClick(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleHover(S32 x, S32 y, MASK mask) { return false; }
bool LLTextSegment::handleScrollWheel(S32 x, S32 y, S32 clicks) { return false; }
bool LLTextSegment::handleScrollHWheel(S32 x, S32 y, S32 clicks) { return false; }
bool LLTextSegment::handleToolTip(S32 x, S32 y, MASK mask) { return false; }
const std::string&  LLTextSegment::getName() const
{
    return LLStringUtil::null;
}
void LLTextSegment::onMouseCaptureLost() {}
void LLTextSegment::screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const {}
void LLTextSegment::localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const {}
bool LLTextSegment::hasMouseCapture() { return false; }

//
// LLNormalTextSegment
//

LLNormalTextSegment::LLNormalTextSegment( LLStyleConstSP style, S32 start, S32 end, LLTextBase& editor )
:   LLTextSegment(start, end),
    mStyle( style ),
    mToken(NULL),
    mEditor(editor)
{
    mFontHeight = mStyle->getFont()->getLineHeight();

    LLUIImagePtr image = mStyle->getImage();
    if (image.notNull())
    {
        mImageLoadedConnection = image->addLoadedCallback(boost::bind(&LLTextBase::needsReflow, &mEditor, start));
    }
}

LLNormalTextSegment::LLNormalTextSegment( const LLColor4& color, S32 start, S32 end, LLTextBase& editor, bool is_visible)
:   LLTextSegment(start, end),
    mToken(NULL),
    mEditor(editor)
{
    mStyle = new LLStyle(LLStyle::Params().visible(is_visible).color(color));

    mFontHeight = mStyle->getFont()->getLineHeight();
}

LLNormalTextSegment::~LLNormalTextSegment()
{
    mImageLoadedConnection.disconnect();
}


F32 LLNormalTextSegment::draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect)
{
    if( end - start > 0 )
    {
        return drawClippedSegment( getStart() + start, getStart() + end, selection_start, selection_end, draw_rect);
    }
    return draw_rect.mLeft;
}

// Draws a single text segment, reversing the color for selection if needed.
F32 LLNormalTextSegment::drawClippedSegment(S32 seg_start, S32 seg_end, S32 selection_start, S32 selection_end, LLRectf rect)
{
    F32 alpha = LLViewDrawContext::getCurrentContext().mAlpha;

    const LLWString &text = getWText();

    F32 right_x = rect.mLeft;
    if (!mStyle->isVisible())
    {
        return right_x;
    }

    const LLFontGL* font = mStyle->getFont();

    LLColor4 color = (mEditor.getReadOnly() ? mStyle->getReadOnlyColor() : mStyle->getColor())  % alpha;

    if( selection_start > seg_start )
    {
        // Draw normally
        S32 start = seg_start;
        S32 end = llmin( selection_start, seg_end );
        S32 length =  end - start;
        font->render(text, start,
                 rect,
                 color,
                 LLFontGL::LEFT, mEditor.mTextVAlign,
                 LLFontGL::NORMAL,
                 mStyle->getShadowType(),
                 length,
                 &right_x,
                 mEditor.getUseEllipses(),
                 mEditor.getUseColor());
    }
    rect.mLeft = right_x;

    if( (selection_start < seg_end) && (selection_end > seg_start) )
    {
        // Draw reversed
        S32 start = llmax( selection_start, seg_start );
        S32 end = llmin( selection_end, seg_end );
        S32 length = end - start;

        font->render(text, start,
                 rect,
                 mStyle->getSelectedColor().get(),
                 LLFontGL::LEFT, mEditor.mTextVAlign,
                 LLFontGL::NORMAL,
                 LLFontGL::NO_SHADOW,
                 length,
                 &right_x,
                 mEditor.getUseEllipses(),
                 mEditor.getUseColor());
    }
    rect.mLeft = right_x;
    if( selection_end < seg_end )
    {
        // Draw normally
        S32 start = llmax( selection_end, seg_start );
        S32 end = seg_end;
        S32 length = end - start;
        font->render(text, start,
                 rect,
                 color,
                 LLFontGL::LEFT, mEditor.mTextVAlign,
                 LLFontGL::NORMAL,
                 mStyle->getShadowType(),
                 length,
                 &right_x,
                 mEditor.getUseEllipses(),
                 mEditor.getUseColor());
    }
    return right_x;
}

bool LLNormalTextSegment::handleHover(S32 x, S32 y, MASK mask)
{
    if (getStyle() && getStyle()->isLink())
    {
        // Only process the click if it's actually in this segment, not to the right of the end-of-line.
        if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
        {
            LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND);
            return true;
        }
    }
    return false;
}

bool LLNormalTextSegment::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
    if (getStyle() && getStyle()->isLink())
    {
        // Only process the click if it's actually in this segment, not to the right of the end-of-line.
        if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
        {
            mEditor.createUrlContextMenu(x, y, getStyle()->getLinkHREF());
            return true;
        }
    }
    return false;
}

bool LLNormalTextSegment::handleMouseDown(S32 x, S32 y, MASK mask)
{
    if (getStyle() && getStyle()->isLink())
    {
        // Only process the click if it's actually in this segment, not to the right of the end-of-line.
        if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
        {
            // eat mouse down event on hyperlinks, so we get the mouse up
            return true;
        }
    }

    return false;
}

bool LLNormalTextSegment::handleMouseUp(S32 x, S32 y, MASK mask)
{
    if (getStyle() && getStyle()->isLink())
    {
        // Only process the click if it's actually in this segment, not to the right of the end-of-line.
        if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
        {
            std::string url = getStyle()->getLinkHREF();
            if (!mEditor.mForceUrlsExternal)
            {
                LLUrlAction::clickAction(url, mEditor.isContentTrusted());
            }
            else if (!LLUrlAction::executeSLURL(url, mEditor.isContentTrusted()))
            {
                LLUrlAction::openURLExternal(url);
            }
            return true;
        }
    }

    return false;
}

bool LLNormalTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
{
    std::string msg;
    // do we have a tooltip for a loaded keyword (for script editor)?
    if (mToken && !mToken->getToolTip().empty())
    {
        const LLWString& wmsg = mToken->getToolTip();
        LLToolTipMgr::instance().show(wstring_to_utf8str(wmsg), (mToken->getType() == LLKeywordToken::TT_FUNCTION));
        return true;
    }
    // or do we have an explicitly set tooltip (e.g., for Urls)
    if (!mTooltip.empty())
    {
        LLToolTipMgr::instance().show(mTooltip);
        return true;
    }

    return false;
}

void LLNormalTextSegment::setToolTip(const std::string& tooltip)
{
    // we cannot replace a keyword tooltip that's loaded from a file
    if (mToken)
    {
        LL_WARNS() << "LLTextSegment::setToolTip: cannot replace keyword tooltip." << LL_ENDL;
        return;
    }
    mTooltip = tooltip;
}

bool LLNormalTextSegment::getDimensionsF32(S32 first_char, S32 num_chars, F32& width, S32& height) const
{
    height = 0;
    width = 0;
    if (num_chars > 0)
    {
        height = mFontHeight;
        const LLWString &text = getWText();
        // if last character is a newline, then return true, forcing line break
        width = mStyle->getFont()->getWidthF32(text.c_str(), mStart + first_char, num_chars, true);
    }
    return false;
}

S32 LLNormalTextSegment::getOffset(S32 segment_local_x_coord, S32 start_offset, S32 num_chars, bool round) const
{
    const LLWString &text = getWText();
    return mStyle->getFont()->charFromPixelOffset(text.c_str(), mStart + start_offset,
                                               (F32)segment_local_x_coord,
                                               F32_MAX,
                                               num_chars,
                                               round);
}

S32 LLNormalTextSegment::getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars, S32 line_ind) const
{
    const LLWString &text = getWText();

    LLUIImagePtr image = mStyle->getImage();
    if( image.notNull())
    {
        num_pixels = llmax(0, num_pixels - image->getWidth());
    }

    S32 last_char = mEnd;

    // set max characters to length of segment, or to first newline
    max_chars = llmin(max_chars, last_char - (mStart + segment_offset));

    // if no character yet displayed on this line, don't require word wrapping since
    // we can just move to the next line, otherwise insist on it so we make forward progress
    LLFontGL::EWordWrapStyle word_wrap_style = (line_offset == 0)
        ? LLFontGL::WORD_BOUNDARY_IF_POSSIBLE
        : LLFontGL::ONLY_WORD_BOUNDARIES;


    S32 offsetLength = static_cast<S32>(text.length()) - (segment_offset + mStart);

    if(getLength() < segment_offset + mStart)
    {
        LL_INFOS() << "getLength() < segment_offset + mStart\t getLength()\t" << getLength() << "\tsegment_offset:\t"
                        << segment_offset << "\tmStart:\t" << mStart << "\tsegments\t" << mEditor.mSegments.size() << "\tmax_chars\t" << max_chars << LL_ENDL;
    }

    if( (offsetLength + 1) < max_chars)
    {
        LL_INFOS() << "offsetString.length() + 1 < max_chars\t max_chars:\t" << max_chars << "\toffsetString.length():\t" << offsetLength << " getLength() : "
            << getLength() << "\tsegment_offset:\t" << segment_offset << "\tmStart:\t" << mStart << "\tsegments\t" << mEditor.mSegments.size() << LL_ENDL;
    }

    S32 num_chars = mStyle->getFont()->maxDrawableChars( text.c_str() + (segment_offset + mStart),
                                                (F32)num_pixels,
                                                max_chars,
                                                word_wrap_style);

    if (num_chars == 0
        && line_offset == 0
        && max_chars > 0)
    {
        // If at the beginning of a line, and a single character won't fit, draw it anyway
        num_chars = 1;
    }

    // include *either* the EOF or newline character in this run of text
    // but not both
    S32 last_char_in_run = mStart + segment_offset + num_chars;
    // check length first to avoid indexing off end of string
    if (last_char_in_run < mEnd
        && (last_char_in_run >= getLength()))
    {
        num_chars++;
    }
    return num_chars;
}

void LLNormalTextSegment::dump() const
{
    LL_INFOS() << "Segment [" <<
//          mColor.mV[VRED] << ", " <<
//          mColor.mV[VGREEN] << ", " <<
//          mColor.mV[VBLUE] << "]\t[" <<
        mStart << ", " <<
        getEnd() << "]" <<
        LL_ENDL;
}

/*virtual*/
const LLWString& LLNormalTextSegment::getWText()    const
{
    return mEditor.getWText();
}

/*virtual*/
const S32 LLNormalTextSegment::getLength() const
{
    return mEditor.getLength();
}

LLLabelTextSegment::LLLabelTextSegment( LLStyleConstSP style, S32 start, S32 end, LLTextBase& editor )
:   LLNormalTextSegment(style, start, end, editor)
{
}

LLLabelTextSegment::LLLabelTextSegment( const LLColor4& color, S32 start, S32 end, LLTextBase& editor, bool is_visible)
:   LLNormalTextSegment(color, start, end, editor, is_visible)
{
}

/*virtual*/
const LLWString& LLLabelTextSegment::getWText() const
{
    return mEditor.getWlabel();
}
/*virtual*/
const S32 LLLabelTextSegment::getLength() const
{
    return static_cast<S32>(mEditor.getWlabel().length());
}

//
// LLEmojiTextSegment
//
LLEmojiTextSegment::LLEmojiTextSegment(LLStyleConstSP style, S32 start, S32 end, LLTextBase& editor)
    : LLNormalTextSegment(style, start, end, editor)
{
}

LLEmojiTextSegment::LLEmojiTextSegment(const LLColor4& color, S32 start, S32 end, LLTextBase& editor, bool is_visible)
    : LLNormalTextSegment(color, start, end, editor, is_visible)
{
}

bool LLEmojiTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
{
    if (mTooltip.empty())
    {
        LLWString emoji = getWText().substr(getStart(), getEnd() - getStart());
        if (!emoji.empty())
        {
            mTooltip = LLEmojiHelper::instance().getToolTip(emoji[0]);
        }
    }

    return LLNormalTextSegment::handleToolTip(x, y, mask);
}

//
// LLOnHoverChangeableTextSegment
//

LLOnHoverChangeableTextSegment::LLOnHoverChangeableTextSegment( LLStyleConstSP style, LLStyleConstSP normal_style, S32 start, S32 end, LLTextBase& editor ):
      LLNormalTextSegment(normal_style, start, end, editor),
      mHoveredStyle(style),
      mNormalStyle(normal_style){}

/*virtual*/
F32 LLOnHoverChangeableTextSegment::draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect)
{
    F32 result = LLNormalTextSegment::draw(start, end, selection_start, selection_end, draw_rect);
    if (end == mEnd - mStart)
    {
        mStyle = mNormalStyle;
    }
    return result;
}

/*virtual*/
bool LLOnHoverChangeableTextSegment::handleHover(S32 x, S32 y, MASK mask)
{
    mStyle = mEditor.getSkipLinkUnderline() ? mNormalStyle : mHoveredStyle;
    return LLNormalTextSegment::handleHover(x, y, mask);
}


//
// LLInlineViewSegment
//

LLInlineViewSegment::LLInlineViewSegment(const Params& p, S32 start, S32 end)
:   LLTextSegment(start, end),
    mView(p.view),
    mForceNewLine(p.force_newline),
    mLeftPad(p.left_pad),
    mRightPad(p.right_pad),
    mTopPad(p.top_pad),
    mBottomPad(p.bottom_pad)
{
}

LLInlineViewSegment::~LLInlineViewSegment()
{
    mView->die();
}

bool LLInlineViewSegment::getDimensionsF32(S32 first_char, S32 num_chars, F32& width, S32& height) const
{
    if (first_char == 0 && num_chars == 0)
    {
        // We didn't fit on a line or were forced to new string
        // the widget will fall on the next line, so width here is 0
        width = 0;

        if (mForceNewLine)
        {
            // Chat, string can't be smaller then font height even if it is empty
            LLStyleSP s(new LLStyle(LLStyle::Params().visible(true)));
            height = s->getFont()->getLineHeight();

            return true; // new line
        }
        else
        {
            // height from previous segment in same string will be used, word-wrap
            height = 0;
        }

    }
    else
    {
        width = mLeftPad + mRightPad + mView->getRect().getWidth();
        height = mBottomPad + mTopPad + mView->getRect().getHeight();
    }

    return false;
}

S32 LLInlineViewSegment::getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars, S32 line_ind) const
{
    // if putting a widget anywhere but at the beginning of a line
    // and the widget doesn't fit or mForceNewLine is true
    // then return 0 chars for that line, and all characters for the next
    if (mForceNewLine && line_ind == 0)
    {
        return 0;
    }
    else if (line_offset != 0 && num_pixels < mView->getRect().getWidth())
    {
        return 0;
    }
    else
    {
        return mEnd - mStart;
    }
}

void LLInlineViewSegment::updateLayout(const LLTextBase& editor)
{
    LLRect start_rect = editor.getDocRectFromDocIndex(mStart);
    mView->setOrigin(start_rect.mLeft + mLeftPad, start_rect.mBottom + mBottomPad);
}

F32 LLInlineViewSegment::draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect)
{
    // return padded width of widget
    // widget is actually drawn during mDocumentView's draw()
    return (F32)(draw_rect.mLeft + mView->getRect().getWidth() + mLeftPad + mRightPad);
}

void LLInlineViewSegment::unlinkFromDocument(LLTextBase* editor)
{
    editor->removeDocumentChild(mView);
}

void LLInlineViewSegment::linkToDocument(LLTextBase* editor)
{
    editor->addDocumentChild(mView);
}

LLLineBreakTextSegment::LLLineBreakTextSegment(S32 pos):LLTextSegment(pos,pos+1)
{
    LLStyleSP s( new LLStyle(LLStyle::Params().visible(true)));

    mFontHeight = s->getFont()->getLineHeight();
}
LLLineBreakTextSegment::LLLineBreakTextSegment(LLStyleConstSP style,S32 pos):LLTextSegment(pos,pos+1)
{
    mFontHeight = style->getFont()->getLineHeight();
}
LLLineBreakTextSegment::~LLLineBreakTextSegment()
{
}
bool LLLineBreakTextSegment::getDimensionsF32(S32 first_char, S32 num_chars, F32& width, S32& height) const
{
    width = 0;
    height = mFontHeight;

    return true;
}
S32 LLLineBreakTextSegment::getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars, S32 line_ind) const
{
    return 1;
}
F32 LLLineBreakTextSegment::draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect)
{
    return  draw_rect.mLeft;
}

LLImageTextSegment::LLImageTextSegment(LLStyleConstSP style,S32 pos,class LLTextBase& editor)
:   LLTextSegment(pos,pos+1),
    mStyle( style ),
    mEditor(editor)
{
}

LLImageTextSegment::~LLImageTextSegment()
{
}

static const S32 IMAGE_HPAD = 3;

bool LLImageTextSegment::getDimensionsF32(S32 first_char, S32 num_chars, F32& width, S32& height) const
{
    width = 0;
    height = mStyle->getFont()->getLineHeight();

    LLUIImagePtr image = mStyle->getImage();
    if( num_chars>0 && image.notNull())
    {
        width += image->getWidth() + IMAGE_HPAD;
        height = llmax(height, image->getHeight() + IMAGE_HPAD );
    }
    return false;
}

S32  LLImageTextSegment::getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars, S32 line_ind) const
{
    LLUIImagePtr image = mStyle->getImage();

    if (image.isNull())
    {
        return 1;
    }

    S32 image_width = image->getWidth();
    if(line_offset == 0 || num_pixels>image_width + IMAGE_HPAD)
    {
        return 1;
    }

    return 0;
}

bool LLImageTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
{
    if (!mTooltip.empty())
    {
        LLToolTipMgr::instance().show(mTooltip);
        return true;
    }

    return false;
}

void LLImageTextSegment::setToolTip(const std::string& tooltip)
{
    mTooltip = tooltip;
}

F32 LLImageTextSegment::draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect)
{
    if ( (start >= 0) && (end <= mEnd - mStart))
    {
        LLColor4 color = LLColor4::white % mEditor.getDrawContext().mAlpha;
        LLUIImagePtr image = mStyle->getImage();
        if (image.notNull())
        {
            S32 style_image_height = image->getHeight();
            S32 style_image_width = image->getWidth();
            // Text is drawn from the top of the draw_rect downward

            S32 text_center = draw_rect.mTop - (draw_rect.getHeight() / 2);
            // Align image to center of draw rect
            S32 image_bottom = text_center - (style_image_height / 2);
            image->draw(draw_rect.mLeft, image_bottom,
                style_image_width, style_image_height, color);

            const S32 IMAGE_HPAD = 3;
            return draw_rect.mLeft + style_image_width + IMAGE_HPAD;
        }
    }
    return 0.0;
}

void LLTextBase::setWordWrap(bool wrap)
{
    mWordWrap = wrap;
}