Print done when done.

78 files changed, 41343 insertions, 0 deletions

diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
new file mode 100644
index 0000000000..c02be6bb8d
--- /dev/null
+++ b/indra/llui/llbutton.cpp
@@ -0,0 +1,1012 @@
+/** 
+ * @file llbutton.cpp
+ * @brief LLButton base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llbutton.h"
+
+// Linden library includes
+#include "v4color.h"
+#include "llstring.h"
+
+// Project includes
+#include "llkeyboard.h"
+#include "llgl.h"
+#include "llui.h"
+#include "lluiconstants.h"
+//#include "llcallbacklist.h"
+#include "llresmgr.h"
+#include "llcriticaldamp.h"
+#include "llglheaders.h"
+#include "llfocusmgr.h"
+#include "llwindow.h"
+
+// globals loaded from settings.xml
+S32	LLBUTTON_ORIG_H_PAD	= 6; // Pre-zoomable UI
+S32	LLBUTTON_H_PAD	= 0;
+S32	LLBUTTON_V_PAD	= 0;
+S32 BTN_HEIGHT_SMALL= 0;
+S32 BTN_HEIGHT		= 0;
+
+S32 BTN_GRID		= 12;
+S32 BORDER_SIZE = 1;
+
+// static
+LLFrameTimer	LLButton::sFlashingTimer;
+
+LLButton::LLButton(	const LLString& name, const LLRect& rect, const LLString& control_name, void (*click_callback)(void*), void *callback_data)
+:	LLUICtrl(name, rect, TRUE, NULL, NULL),
+	mClickedCallback( click_callback ),
+	mMouseDownCallback( NULL ),
+	mMouseUpCallback( NULL ),
+	mHeldDownCallback( NULL ),
+	mGLFont( NULL ),
+	mHeldDownDelay( 0.5f ),			// seconds until held-down callback is called
+	mImageUnselected( NULL ),
+	mImageSelected( NULL ),
+	mImageHoverSelected( NULL ),
+	mImageHoverUnselected( NULL ),
+	mImageDisabled( NULL ),
+	mImageDisabledSelected( NULL ),
+	mToggleState( FALSE ),
+	mScaleImage( TRUE ),
+	mDropShadowedText( TRUE ),
+	mBorderEnabled( FALSE ),
+	mFlashing( FALSE ),
+	mHAlign( LLFontGL::HCENTER ),
+	mLeftHPad( LLBUTTON_H_PAD ),
+	mRightHPad( LLBUTTON_H_PAD ),
+	mFixedWidth( 16 ),
+	mFixedHeight( 16 ),
+	mHoverGlowStrength(0.15f),
+	mCurGlowStrength(0.f),
+	mNeedsHighlight(FALSE),
+	mCommitOnReturn(TRUE),
+	mImagep( NULL )
+{
+	mUnselectedLabel = name;
+	mSelectedLabel = name;
+
+	setImageUnselected("button_enabled_32x128.tga");
+	setImageSelected("button_enabled_selected_32x128.tga");
+	setImageDisabled("button_disabled_32x128.tga");
+	setImageDisabledSelected("button_disabled_32x128.tga");
+
+	mImageColor = LLUI::sColorsGroup->getColor( "ButtonImageColor" );
+	mDisabledImageColor = LLUI::sColorsGroup->getColor( "ButtonImageColor" );
+
+	init(click_callback, callback_data, NULL, control_name);
+}
+
+
+LLButton::LLButton(const LLString& name, const LLRect& rect, 
+				   const LLString &unselected_image_name, 
+				   const LLString &selected_image_name, 
+				   const LLString& control_name,
+				   void (*click_callback)(void*),
+				   void *callback_data,
+				   const LLFontGL *font,
+				   const LLString& unselected_label, 
+				   const LLString& selected_label )
+:	LLUICtrl(name, rect, TRUE, NULL, NULL),
+	mClickedCallback( click_callback ),
+	mMouseDownCallback( NULL ),
+	mMouseUpCallback( NULL ),
+	mHeldDownCallback( NULL ),
+	mGLFont( NULL ),
+	mHeldDownDelay( 0.5f ),			// seconds until held-down callback is called
+	mImageUnselected( NULL ),
+	mImageSelected( NULL ),
+	mImageHoverSelected( NULL ),
+	mImageHoverUnselected( NULL ),
+	mImageDisabled( NULL ),
+	mImageDisabledSelected( NULL ),
+	mToggleState( FALSE ),
+	mScaleImage( TRUE ),
+	mDropShadowedText( TRUE ),
+	mBorderEnabled( FALSE ),
+	mFlashing( FALSE ),
+	mHAlign( LLFontGL::HCENTER ),
+	mLeftHPad( LLBUTTON_H_PAD ), 
+	mRightHPad( LLBUTTON_H_PAD ),
+	mFixedWidth( 16 ),
+	mFixedHeight( 16 ),
+	mHoverGlowStrength(0.25f),
+	mCurGlowStrength(0.f),
+	mNeedsHighlight(FALSE),
+	mCommitOnReturn(TRUE),
+	mImagep( NULL )
+{
+	mUnselectedLabel = unselected_label;
+	mSelectedLabel = selected_label;
+
+	// by default, disabled color is same as enabled
+	mImageColor = LLUI::sColorsGroup->getColor( "ButtonImageColor" );
+	mDisabledImageColor = LLUI::sColorsGroup->getColor( "ButtonImageColor" );
+
+	if( unselected_image_name != "" )
+	{
+		setImageUnselected(unselected_image_name);
+		setImageDisabled(unselected_image_name);
+		
+		mDisabledImageColor.mV[VALPHA] = 0.5f;
+		mImageDisabled = mImageUnselected;
+		mDisabledImageColor.mV[VALPHA] = 0.5f;
+		// user-specified image - don't use fixed borders unless requested
+		mFixedWidth = 0;
+		mFixedHeight = 0;
+		mScaleImage = FALSE;
+	}
+	else
+	{
+		setImageUnselected("button_enabled_32x128.tga");
+		setImageDisabled("button_disabled_32x128.tga");
+	}
+
+	if( selected_image_name != "" )
+	{
+		setImageSelected(selected_image_name);
+		setImageDisabledSelected(selected_image_name);
+
+		mDisabledImageColor.mV[VALPHA] = 0.5f;
+		// user-specified image - don't use fixed borders unless requested
+		mFixedWidth = 0;
+		mFixedHeight = 0;
+		mScaleImage = FALSE;
+	}
+	else
+	{
+		setImageSelected("button_enabled_selected_32x128.tga");
+		setImageDisabledSelected("button_disabled_32x128.tga");
+	}
+
+	init(click_callback, callback_data, font, control_name);
+}
+
+void LLButton::init(void (*click_callback)(void*), void *callback_data, const LLFontGL* font, const LLString& control_name)
+{
+	mGLFont = ( font ? font : LLFontGL::sSansSerif);
+
+	// Hack to make sure there is space for at least one character
+	if (mRect.getWidth() - (mRightHPad + mLeftHPad) < mGLFont->getWidth(" "))
+	{
+		// Use old defaults
+		mLeftHPad = LLBUTTON_ORIG_H_PAD;
+		mRightHPad = LLBUTTON_ORIG_H_PAD;
+	}
+	
+	mCallbackUserData = callback_data;
+	mMouseDownTimer.stop();
+
+	setControlName(control_name, NULL);
+
+	mUnselectedLabelColor = (			LLUI::sColorsGroup->getColor( "ButtonLabelColor" ) );
+	mSelectedLabelColor = (			LLUI::sColorsGroup->getColor( "ButtonLabelSelectedColor" ) );
+	mDisabledLabelColor = (			LLUI::sColorsGroup->getColor( "ButtonLabelDisabledColor" ) );
+	mDisabledSelectedLabelColor = (	LLUI::sColorsGroup->getColor( "ButtonLabelSelectedDisabledColor" ) );
+	mHighlightColor = (				LLUI::sColorsGroup->getColor( "ButtonUnselectedFgColor" ) );
+	mUnselectedBgColor = (				LLUI::sColorsGroup->getColor( "ButtonUnselectedBgColor" ) );
+	mSelectedBgColor = (				LLUI::sColorsGroup->getColor( "ButtonSelectedBgColor" ) );
+}
+
+LLButton::~LLButton()
+{
+ 	if( this == gFocusMgr.getMouseCapture() )
+	{
+		gFocusMgr.setMouseCapture( NULL, NULL );
+	}
+}
+
+// virtual
+EWidgetType LLButton::getWidgetType() const
+{
+	return WIDGET_TYPE_BUTTON;
+}
+
+// virtual
+LLString LLButton::getWidgetTag() const
+{
+	return LL_BUTTON_TAG;
+}
+
+// HACK: Committing a button is the same as instantly clicking it.
+// virtual
+void LLButton::onCommit()
+{
+	// WARNING: Sometimes clicking a button destroys the floater or
+	// panel containing it.  Therefore we need to call mClickedCallback
+	// LAST, otherwise this becomes deleted memory.
+	LLUICtrl::onCommit();
+
+	if (mMouseDownCallback)
+	{
+		(*mMouseDownCallback)(mCallbackUserData);
+	}
+	
+	if (mMouseUpCallback)
+	{
+		(*mMouseUpCallback)(mCallbackUserData);
+	}
+
+	if (mSoundFlags & MOUSE_DOWN)
+	{
+		make_ui_sound("UISndClick");
+	}
+
+	if (mSoundFlags & MOUSE_UP)
+	{
+		make_ui_sound("UISndClickRelease");
+	}
+
+	if (mClickedCallback)
+	{
+		(*mClickedCallback)( mCallbackUserData );
+	}
+}
+
+BOOL LLButton::handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+	if( getVisible() && mEnabled && !called_from_parent && ' ' == uni_char && !gKeyboard->getKeyRepeated(' '))
+	{
+		if (mClickedCallback)
+		{
+			(*mClickedCallback)( mCallbackUserData );
+		}
+		handled = TRUE;
+	}
+	return handled;	
+}
+
+BOOL LLButton::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent )
+{
+	BOOL handled = FALSE;
+	if( getVisible() && mEnabled && !called_from_parent )
+	{
+		if( mCommitOnReturn && KEY_RETURN == key && mask == MASK_NONE && !gKeyboard->getKeyRepeated(key))
+		{
+			if (mClickedCallback)
+			{
+				(*mClickedCallback)( mCallbackUserData );
+			}
+			handled = TRUE;
+		}
+	}
+	return handled;
+}
+
+
+BOOL LLButton::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	// Route future Mouse messages here preemptively.  (Release on mouse up.)
+	gFocusMgr.setMouseCapture( this, &LLButton::onMouseCaptureLost );
+
+	if (hasTabStop() && !getIsChrome())
+	{
+		setFocus(TRUE);
+	}
+
+	if (mMouseDownCallback)
+	{
+		(*mMouseDownCallback)(mCallbackUserData);
+	}
+
+	mMouseDownTimer.start();
+	
+	if (mSoundFlags & MOUSE_DOWN)
+	{
+		make_ui_sound("UISndClick");
+	}
+
+	return TRUE;
+}
+
+
+BOOL LLButton::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	// We only handle the click if the click both started and ended within us
+	if( this == gFocusMgr.getMouseCapture() )
+	{
+		// Regardless of where mouseup occurs, handle callback
+		if (mMouseUpCallback)
+		{
+			(*mMouseUpCallback)(mCallbackUserData);
+		}
+
+		mMouseDownTimer.stop();
+
+		// Always release the mouse
+		gFocusMgr.setMouseCapture( NULL, NULL );
+
+		// DO THIS AT THE VERY END to allow the button to be destroyed as a result of being clicked.
+		// If mouseup in the widget, it's been clicked
+		if (pointInView(x, y))
+		{
+			if (mSoundFlags & MOUSE_UP)
+			{
+				make_ui_sound("UISndClickRelease");
+			}
+
+			if (mClickedCallback)
+			{
+				(*mClickedCallback)( mCallbackUserData );
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+
+BOOL LLButton::handleHover(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	LLMouseHandler* other_captor = gFocusMgr.getMouseCapture();
+	mNeedsHighlight = other_captor == NULL || 
+				other_captor == this ||
+				// this following bit is to support modal dialogs
+				(other_captor->isView() && hasAncestor((LLView*)other_captor));
+
+	if (mMouseDownTimer.getStarted() && NULL != mHeldDownCallback)
+	{
+		F32 elapsed = mMouseDownTimer.getElapsedTimeF32();
+ 		if( mHeldDownDelay < elapsed )
+		{
+			mHeldDownCallback( mCallbackUserData );		
+		}
+	}
+
+	// We only handle the click if the click both started and ended within us
+	if( this == gFocusMgr.getMouseCapture() )
+	{
+		handled = TRUE;
+	}
+	else if( getVisible() )
+	{
+		// Opaque
+		handled = TRUE;
+	}
+
+	if( handled )
+	{
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;		
+	}
+
+	return handled;
+}
+
+
+// virtual
+void LLButton::draw()
+{
+	if( getVisible() ) 
+	{
+		BOOL flash = FALSE;
+		if( mFlashing )
+		{
+			F32 elapsed = LLButton::sFlashingTimer.getElapsedTimeF32();
+			flash = S32(elapsed * 2) & 1;
+		}
+
+		BOOL pressed_by_keyboard = FALSE;
+		if (hasFocus())
+		{
+			pressed_by_keyboard = gKeyboard->getKeyDown(' ') || (mCommitOnReturn && gKeyboard->getKeyDown(KEY_RETURN));
+		}
+
+		// Unselected image assignments
+		S32 local_mouse_x;
+		S32 local_mouse_y;
+		LLCoordWindow cursor_pos_window;
+		getWindow()->getCursorPosition(&cursor_pos_window);
+		LLCoordGL cursor_pos_gl;
+		getWindow()->convertCoords(cursor_pos_window, &cursor_pos_gl);
+		cursor_pos_gl.mX = llround((F32)cursor_pos_gl.mX / LLUI::sGLScaleFactor.mV[VX]);
+		cursor_pos_gl.mY = llround((F32)cursor_pos_gl.mY / LLUI::sGLScaleFactor.mV[VY]);
+		screenPointToLocal(cursor_pos_gl.mX, cursor_pos_gl.mY, &local_mouse_x, &local_mouse_y);
+
+		BOOL pressed = pressed_by_keyboard || (this == gFocusMgr.getMouseCapture() && pointInView(local_mouse_x, local_mouse_y));
+
+		BOOL display_state = FALSE;
+		if( pressed )
+		{
+			mImagep = mImageSelected;
+			// show the resulting state after releasing the mouse button while it is down
+			display_state = mToggleState ? FALSE : TRUE;
+		}
+		else
+		{
+			display_state = mToggleState || flash;
+		}
+		
+		BOOL use_glow_effect = FALSE;
+		if ( mNeedsHighlight )
+		{
+			if (display_state)
+			{
+				if (mImageHoverSelected)
+				{
+					mImagep = mImageHoverSelected;
+				}
+				else
+				{
+					mImagep = mImageSelected;
+					use_glow_effect = TRUE;
+				}
+			}
+			else
+			{
+				if (mImageHoverUnselected)
+				{
+					mImagep = mImageHoverUnselected;
+				}
+				else
+				{
+					mImagep = mImageUnselected;
+					use_glow_effect = TRUE;
+				}
+			}
+		}
+		else if ( display_state )
+		{
+			mImagep = mImageSelected;
+		}
+		else
+		{
+			mImagep = mImageUnselected;
+		}
+
+		// Override if more data is available
+		// HACK: Use gray checked state to mean either:
+		//   enabled and tentative
+		// or
+		//   disabled but checked
+		if (!mImageDisabledSelected.isNull() && ( (mEnabled && mTentative) || (!mEnabled && display_state ) ) )
+		{
+			mImagep = mImageDisabledSelected;
+		}
+		else if (!mImageDisabled.isNull() && !mEnabled && !display_state)
+		{
+			mImagep = mImageDisabled;
+		}
+
+		if (mNeedsHighlight && !mImagep)
+		{
+			use_glow_effect = TRUE;
+		}
+
+		// Figure out appropriate color for the text
+		LLColor4 label_color;
+
+		if ( mEnabled )
+		{
+			if ( !display_state )
+			{
+				label_color = mUnselectedLabelColor;
+			}
+			else
+			{
+				label_color = mSelectedLabelColor;
+			}
+		}
+		else
+		{
+			if ( !display_state )
+			{
+				label_color = mDisabledLabelColor;
+			}
+			else
+			{
+				label_color = mDisabledSelectedLabelColor;
+			}
+		}
+
+		// Unselected label assignments
+		LLWString label;
+
+		if( display_state )
+		{
+			if( mEnabled || mDisabledSelectedLabel.empty() )
+			{
+				label = mSelectedLabel;
+			}
+			else
+			{
+				label = mDisabledSelectedLabel;
+			}
+		}
+		else
+		{
+			if( mEnabled || mDisabledLabel.empty() )
+			{
+				label = mUnselectedLabel;
+			}
+			else
+			{
+				label = mDisabledLabel;
+			}
+		}
+		
+		// draw default button border
+		if (mEnabled && mBorderEnabled && gFocusMgr.getAppHasFocus()) // because we're the default button in a panel
+		{
+			drawBorder(LLUI::sColorsGroup->getColor( "ButtonBorderColor" ), BORDER_SIZE);
+		}
+
+		// overlay with keyboard focus border
+		if (hasFocus())
+		{
+			F32 lerp_amt = gFocusMgr.getFocusFlashAmt();
+			drawBorder(gFocusMgr.getFocusColor(), llround(lerp(1.f, 3.f, lerp_amt)));
+		}
+		
+		if (use_glow_effect)
+		{
+			mCurGlowStrength = lerp(mCurGlowStrength, mHoverGlowStrength, LLCriticalDamp::getInterpolant(0.05f));
+		}
+		else
+		{
+			mCurGlowStrength = lerp(mCurGlowStrength, 0.f, LLCriticalDamp::getInterpolant(0.05f));
+		}
+
+		// Draw button image, if available.
+		// Otherwise draw basic rectangular button.
+		if( mImagep.notNull() && !mScaleImage)
+		{
+			gl_draw_image( 0, 0, mImagep, mEnabled ? mImageColor : mDisabledImageColor );
+			if (mCurGlowStrength > 0.01f)
+			{
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+				gl_draw_scaled_image_with_border(0, 0, 0, 0, mImagep->getWidth(), mImagep->getHeight(), mImagep, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength), TRUE);
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			}
+		}
+		else
+		if ( mImagep.notNull() && mScaleImage)
+		{
+			gl_draw_scaled_image_with_border(0, 0, mFixedWidth, mFixedHeight, mRect.getWidth(), mRect.getHeight(), 
+											mImagep, mEnabled ? mImageColor : mDisabledImageColor  );
+			if (mCurGlowStrength > 0.01f)
+			{
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+				gl_draw_scaled_image_with_border(0, 0, mFixedWidth, mFixedHeight, mRect.getWidth(), mRect.getHeight(), 
+											mImagep, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength), TRUE);
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			}
+		}
+		else
+		{
+			// no image
+			llalerts << "No image for button " << mName << llendl;
+			// draw it in pink so we can find it
+			gl_rect_2d(0, mRect.getHeight(), mRect.getWidth(), 0, LLColor4::pink1, FALSE);
+		}
+
+		// Draw label
+		if( !label.empty() )
+		{
+			S32 drawable_width = mRect.getWidth() - mLeftHPad - mRightHPad;
+
+			LLWString::trim(label);
+
+			S32 x;
+			switch( mHAlign )
+			{
+			case LLFontGL::RIGHT:
+				x = mRect.getWidth() - mRightHPad;
+				break;
+			case LLFontGL::HCENTER:
+				x = mRect.getWidth() / 2;
+				break;
+			case LLFontGL::LEFT:
+			default:
+				x = mLeftHPad;
+				break;
+			}
+
+			S32 y_offset = 2 + (mRect.getHeight() - 20)/2;
+		
+			if (pressed || display_state)
+			{
+				y_offset--;
+				x++;
+			}
+
+			mGLFont->render(label, 0, (F32)x, (F32)(LLBUTTON_V_PAD + y_offset), 
+				label_color,
+				mHAlign, LLFontGL::BOTTOM,
+				mDropShadowedText ? LLFontGL::DROP_SHADOW : LLFontGL::NORMAL,
+				U32_MAX, drawable_width,
+				NULL, FALSE, FALSE);
+		}
+
+		if (sDebugRects	
+			|| (LLView::sEditingUI && this == LLView::sEditingUIView))
+		{
+			drawDebugRect();
+		}
+	}
+	// reset hover status for next frame
+	mNeedsHighlight = FALSE;
+}
+
+void LLButton::drawBorder(const LLColor4& color, S32 size)
+{
+	S32 left = -size;
+	S32 top = mRect.getHeight() + size;
+	S32 right = mRect.getWidth() + size;
+	S32 bottom = -size;
+
+	if (mImagep.isNull())
+	{
+		gl_rect_2d(left, top, right, bottom, color, FALSE);
+		return;
+	}
+
+	if (mScaleImage)
+	{
+		gl_draw_scaled_image_with_border(left, bottom, mFixedWidth, mFixedHeight, right-left, top-bottom, 
+								mImagep, color, TRUE );
+	}
+	else
+	{
+		gl_draw_scaled_image_with_border(left, bottom, 0, 0, mImagep->getWidth() + size * 2, 
+								mImagep->getHeight() + size * 2, mImagep, color, TRUE );
+	}
+}
+
+void LLButton::setClickedCallback(void (*cb)(void*), void* userdata)
+{
+	mClickedCallback = cb;
+	if (userdata)
+	{
+		mCallbackUserData = userdata;
+	}
+}
+
+
+void LLButton::setToggleState(BOOL b)
+{
+	if( b != mToggleState )
+	{
+		mToggleState = b;
+		LLValueChangedEvent *evt = new LLValueChangedEvent(this, mToggleState);
+		fireEvent(evt, "");
+	}
+}
+
+void LLButton::setValue(const LLSD& value )
+{
+	mToggleState = value.asBoolean();
+}
+
+LLSD LLButton::getValue() const
+{
+	return mToggleState;
+}
+
+void LLButton::setLabel( const LLString& label )
+{
+	setLabelUnselected(label);
+	setLabelSelected(label);
+}
+
+//virtual
+BOOL LLButton::setLabelArg( const LLString& key, const LLString& text )
+{
+	mUnselectedLabel.setArg(key, text);
+	mSelectedLabel.setArg(key, text);
+	return TRUE;
+}
+
+void LLButton::setLabelUnselected( const LLString& label )
+{
+	mUnselectedLabel = label;
+}
+
+void LLButton::setLabelSelected( const LLString& label )
+{
+	mSelectedLabel = label;
+}
+
+void LLButton::setDisabledLabel( const LLString& label )
+{
+	mDisabledLabel = label;
+}
+
+void LLButton::setDisabledSelectedLabel( const LLString& label )
+{
+	mDisabledSelectedLabel = label;
+}
+
+void LLButton::setImageUnselectedID( const LLUUID &image_id )
+{	
+	mImageUnselectedName = "";
+	mImageUnselected = LLUI::sImageProvider->getUIImageByID(image_id);
+}
+
+void LLButton::setImages( const LLString &image_name, const LLString &selected_name )
+{
+	setImageUnselected(image_name);
+	setImageSelected(selected_name);
+
+}
+
+void LLButton::setImageSelectedID( const LLUUID &image_id )
+{
+	mImageSelectedName = "";
+	mImageSelected = LLUI::sImageProvider->getUIImageByID(image_id);
+}
+
+void LLButton::setImageColor(const LLColor4& c)		
+{ 
+	mImageColor = c; 
+}
+
+
+void LLButton::setImageDisabledID( const LLUUID &image_id )
+{
+	mImageDisabledName = "";
+	mImageDisabled = LLUI::sImageProvider->getUIImageByID(image_id);
+	mDisabledImageColor = mImageColor;
+	mDisabledImageColor.mV[VALPHA] *= 0.5f;
+}
+
+void LLButton::setImageDisabledSelectedID( const LLUUID &image_id )
+{	
+	mImageDisabledSelectedName = "";
+	mImageDisabledSelected = LLUI::sImageProvider->getUIImageByID(image_id);
+	mDisabledImageColor = mImageColor;
+	mDisabledImageColor.mV[VALPHA] *= 0.5f;
+}
+
+void LLButton::setDisabledImages( const LLString &image_name, const LLString &selected_name, const LLColor4& c )
+{
+	setImageDisabled(image_name);
+	setImageDisabledSelected(selected_name);
+	mDisabledImageColor = c;
+}
+
+
+void LLButton::setImageHoverSelectedID( const LLUUID& image_id )
+{
+	mImageHoverSelectedName = "";
+	mImageHoverSelected = LLUI::sImageProvider->getUIImageByID(image_id);
+}
+
+void LLButton::setDisabledImages( const LLString &image_name, const LLString &selected_name)
+{
+	LLColor4 clr = mImageColor;
+	clr.mV[VALPHA] *= .5f;
+	setDisabledImages( image_name, selected_name, clr );
+}
+
+void LLButton::setImageHoverUnselectedID( const LLUUID& image_id )
+{
+	mImageHoverUnselectedName = "";
+	mImageHoverUnselected = LLUI::sImageProvider->getUIImageByID(image_id);
+}
+
+void LLButton::setHoverImages( const LLString& image_name, const LLString& selected_name )
+{
+	setImageHoverUnselected(image_name);
+	setImageHoverSelected(selected_name);
+}
+
+// static
+void LLButton::onMouseCaptureLost( LLMouseHandler* old_captor )
+{
+	LLButton* self = (LLButton*) old_captor;
+	self->mMouseDownTimer.stop();
+}
+
+//-------------------------------------------------------------------------
+// LLSquareButton
+//-------------------------------------------------------------------------
+LLSquareButton::LLSquareButton(const LLString& name, const LLRect& rect, 
+		const LLString& label,
+		const LLFontGL *font,
+		const LLString& control_name,	
+		void (*click_callback)(void*),
+		void *callback_data,
+		const LLString& selected_label )
+:	LLButton(name, rect, "","", 
+			control_name, 
+			click_callback, callback_data,
+			font,
+			label, 
+			(selected_label.empty() ? label : selected_label) )
+{ 
+	setImageUnselected("square_btn_32x128.tga");
+	//	mImageUnselected = LLUI::sImageProvider->getUIImageByID(LLUUID(LLUI::sAssetsGroup->getString("square_btn_32x128.tga")));
+	setImageSelected("square_btn_selected_32x128.tga");
+	//	mImageSelectedImage = LLUI::sImageProvider->getUIImageByID(LLUUID(LLUI::sAssetsGroup->getString("square_btn_selected_32x128.tga")));
+	setImageDisabled("square_btn_32x128.tga");
+	//mDisabledImage = LLUI::sImageProvider->getUIImageByID(LLUUID(LLUI::sAssetsGroup->getString("square_btn_32x128.tga")));
+	setImageDisabledSelected("square_btn_selected_32x128.tga");
+	//mDisabledSelectedImage = LLUI::sImageProvider->getUIImageByID(LLUUID(LLUI::sAssetsGroup->getString("square_btn_selected_32x128.tga")));
+	mImageColor = LLUI::sColorsGroup->getColor("ButtonColor");
+}
+
+//-------------------------------------------------------------------------
+// Utilities
+//-------------------------------------------------------------------------
+S32 round_up(S32 grid, S32 value)
+{
+	S32 mod = value % grid;
+
+	if (mod > 0)
+	{
+		// not even multiple
+		return value + (grid - mod);
+	}
+	else
+	{
+		return value;
+	}
+}
+
+void			LLButton::setImageUnselected(const LLString &image_name)
+{	
+	setImageUnselectedID(LLUI::findAssetUUIDByName(image_name));
+	mImageUnselectedName = image_name;
+}
+
+void			LLButton::setImageSelected(const LLString &image_name)
+{	
+	setImageSelectedID(LLUI::findAssetUUIDByName(image_name));
+	mImageSelectedName = image_name;
+}
+
+void			LLButton::setImageHoverSelected(const LLString &image_name)
+{
+	setImageHoverSelectedID(LLUI::findAssetUUIDByName(image_name));
+	mImageHoverSelectedName = image_name;
+}
+
+void			LLButton::setImageHoverUnselected(const LLString &image_name)
+{
+	setImageHoverUnselectedID(LLUI::findAssetUUIDByName(image_name));
+	mImageHoverUnselectedName = image_name;
+}
+
+void			LLButton::setImageDisabled(const LLString &image_name)
+{
+	setImageDisabledID(LLUI::findAssetUUIDByName(image_name));
+	mImageDisabledName = image_name;
+}
+
+void			LLButton::setImageDisabledSelected(const LLString &image_name)
+{
+	setImageDisabledSelectedID(LLUI::findAssetUUIDByName(image_name));
+	mImageDisabledSelectedName = image_name;
+}
+
+void LLButton::addImageAttributeToXML(LLXMLNodePtr node, 
+									  const LLString& image_name,
+									  const LLUUID&	image_id,
+									  const LLString& xml_tag_name) const
+{
+	if( !image_name.empty() )
+	{
+		node->createChild(xml_tag_name, TRUE)->setStringValue(image_name);
+	}
+	else if( image_id != LLUUID::null )
+	{
+		node->createChild(xml_tag_name + "_id", TRUE)->setUUIDValue(image_id);
+	}
+}
+
+// virtual
+LLXMLNodePtr LLButton::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	node->createChild("label", TRUE)->setStringValue(getLabelUnselected());
+	node->createChild("label_selected", TRUE)->setStringValue(getLabelSelected());
+	node->createChild("font", TRUE)->setStringValue(LLFontGL::nameFromFont(mGLFont));
+	node->createChild("halign", TRUE)->setStringValue(LLFontGL::nameFromHAlign(mHAlign));
+	node->createChild("border_width", TRUE)->setIntValue(mFixedWidth);
+	node->createChild("border_height", TRUE)->setIntValue(mFixedHeight);
+
+	addImageAttributeToXML(node,mImageUnselectedName,mImageUnselectedID,"image_unselected");
+	addImageAttributeToXML(node,mImageSelectedName,mImageSelectedID,"image_selected");
+	addImageAttributeToXML(node,mImageHoverSelectedName,mImageHoverSelectedID,"image_hover_selected");
+	addImageAttributeToXML(node,mImageHoverUnselectedName,mImageHoverUnselectedID,"image_hover_unselected");
+	addImageAttributeToXML(node,mImageDisabledName,mImageDisabledID,"image_disabled");
+	addImageAttributeToXML(node,mImageDisabledSelectedName,mImageDisabledSelectedID,"image_disabled_selected");
+
+	node->createChild("scale_image", TRUE)->setBoolValue(mScaleImage);
+
+	return node;
+}
+
+// static
+LLView* LLButton::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("button");
+	node->getAttributeString("name", name);
+
+	LLString label = name;
+	node->getAttributeString("label", label);
+
+	LLString label_selected = label;
+	node->getAttributeString("label_selected", label_selected);
+
+	LLFontGL* font = selectFont(node);
+
+	LLString	image_unselected;
+	if (node->hasAttribute("image_unselected")) node->getAttributeString("image_unselected",image_unselected);
+	
+	LLString	image_selected;
+	if (node->hasAttribute("image_selected")) node->getAttributeString("image_selected",image_selected);
+	
+	LLString	image_hover_selected;
+	if (node->hasAttribute("image_hover_selected")) node->getAttributeString("image_hover_selected",image_hover_selected);
+	
+	LLString	image_hover_unselected;
+	if (node->hasAttribute("image_hover_unselected")) node->getAttributeString("image_hover_unselected",image_hover_unselected);
+	
+	LLString	image_disabled_selected;
+	if (node->hasAttribute("image_disabled_selected")) node->getAttributeString("image_disabled_selected",image_disabled_selected);
+	
+	LLString	image_disabled;
+	if (node->hasAttribute("image_disabled")) node->getAttributeString("image_disabled",image_disabled);
+
+	LLButton *button = new LLButton(name, 
+			LLRect(),
+			image_unselected,
+			image_selected,
+			"", 
+			NULL, 
+			parent,
+			font,
+			label,
+			label_selected);
+
+	node->getAttributeS32("border_width", button->mFixedWidth);
+	node->getAttributeS32("border_height", button->mFixedHeight);
+
+	if(image_hover_selected != LLString::null) button->setImageHoverSelected(image_hover_selected);
+	
+	if(image_hover_unselected != LLString::null) button->setImageHoverUnselected(image_hover_unselected);
+	
+	if(image_disabled_selected != LLString::null) button->setImageDisabledSelected(image_disabled_selected );
+	
+	if(image_disabled != LLString::null) button->setImageDisabled(image_disabled);
+	
+
+	if (node->hasAttribute("halign"))
+	{
+		LLFontGL::HAlign halign = selectFontHAlign(node);
+		button->setHAlign(halign);
+	}
+
+	if (node->hasAttribute("scale_image"))
+	{
+		BOOL	needsScale = FALSE;
+		node->getAttributeBOOL("scale_image",needsScale);
+		button->setScaleImage( needsScale );
+	}
+
+	if(label.empty())
+	{
+		button->setLabelUnselected(node->getTextContents());
+	}
+	if (label_selected.empty())
+	{
+		button->setLabelSelected(node->getTextContents());
+	}
+
+	button->initFromXML(node, parent);
+	
+	return button;
+}
+
diff --git a/indra/llui/llbutton.h b/indra/llui/llbutton.h
new file mode 100644
index 0000000000..0a4e41b017
--- /dev/null
+++ b/indra/llui/llbutton.h
@@ -0,0 +1,261 @@
+/** 
+ * @file llbutton.h
+ * @brief Header for buttons
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLBUTTON_H
+#define LL_LLBUTTON_H
+
+#include "lluuid.h"
+#include "llcontrol.h"
+#include "lluictrl.h"
+#include "v4color.h"
+#include "llframetimer.h"
+#include "llfontgl.h"
+#include "llimage.h"
+#include "lluistring.h"
+
+//
+// Constants
+//
+
+// PLEASE please use these "constants" when building your own buttons.
+// They are loaded from settings.xml at run time.
+extern S32	LLBUTTON_H_PAD;
+extern S32	LLBUTTON_V_PAD;
+extern S32	BTN_HEIGHT_SMALL;
+extern S32	BTN_HEIGHT;
+
+
+// All button widths should be rounded up to this size
+extern S32	BTN_GRID;
+
+//
+// Classes
+//
+
+class LLButton
+: public LLUICtrl
+{
+public:
+	// simple button with text label
+	LLButton(const LLString& name, const LLRect &rect, const LLString& control_name = "", 
+			 void (*on_click)(void*) = NULL, void *data = NULL);
+
+	LLButton(const LLString& name, const LLRect& rect, 
+			 const LLString &unselected_image,
+			 const LLString &selected_image,
+			 const LLString& control_name,	
+			 void (*click_callback)(void*),
+			 void *callback_data = NULL,
+			 const LLFontGL* mGLFont = NULL,
+			 const LLString& unselected_label = LLString::null,
+			 const LLString& selected_label = LLString::null );
+
+	virtual ~LLButton();
+	void init(void (*click_callback)(void*), void *callback_data, const LLFontGL* font, const LLString& control_name);
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+	
+	void			addImageAttributeToXML(LLXMLNodePtr node, const LLString& imageName,
+										const LLUUID&	imageID,const LLString&	xmlTagName) const;
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual BOOL	handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent);
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual void	draw();
+
+	// HACK: "committing" a button is the same as clicking on it.
+	virtual void	onCommit();
+
+	void			setUnselectedLabelColor( const LLColor4& c )		{ mUnselectedLabelColor = c; }
+	void			setSelectedLabelColor( const LLColor4& c )			{ mSelectedLabelColor = c; }
+
+	void			setClickedCallback( void (*cb)(void *data), void* data = NULL ); // mouse down and up within button
+	void			setMouseDownCallback( void (*cb)(void *data) )		{ mMouseDownCallback = cb; }	// mouse down within button
+	void			setMouseUpCallback( void (*cb)(void *data) )		{ mMouseUpCallback = cb; }		// mouse up, EVEN IF NOT IN BUTTON
+	void			setHeldDownCallback( void (*cb)(void *data) )		{ mHeldDownCallback = cb; }		// Mouse button held down and in button
+	void			setHeldDownDelay( F32 seconds)						{ mHeldDownDelay = seconds; }
+
+	F32				getHeldDownTime() const								{ return mMouseDownTimer.getElapsedTimeF32(); }
+
+	BOOL			toggleState()			{ setToggleState( !mToggleState ); return mToggleState; }
+	BOOL			getToggleState() const	{ return mToggleState; }
+	void			setToggleState(BOOL b);
+
+	void			setFlashing( BOOL b )	{ mFlashing = b; }
+	BOOL			getFlashing() const		{ return mFlashing; }
+
+	void			setHAlign( LLFontGL::HAlign align )		{ mHAlign = align; }
+	void			setLeftHPad( S32 pad )					{ mLeftHPad = pad; }
+	void			setRightHPad( S32 pad )					{ mRightHPad = pad; }
+
+	const LLString	getLabelUnselected() const { return wstring_to_utf8str(mUnselectedLabel); }
+	const LLString	getLabelSelected() const { return wstring_to_utf8str(mSelectedLabel); }
+
+
+	// HACK to allow images to be freed when the caller knows he's done with it.
+	LLImageGL*		getImageUnselected() const							{ return mImageUnselected; }
+
+	void			setImageColor(const LLString& color_control);
+	void			setImages(const LLString &image_name, const LLString &selected_name);
+	void			setImageColor(const LLColor4& c);
+	
+	void			setDisabledImages(const LLString &image_name, const LLString &selected_name);
+	void			setDisabledImages(const LLString &image_name, const LLString &selected_name, const LLColor4& c);
+	
+	void			setHoverImages(const LLString &image_name, const LLString &selected_name);
+
+	void			setDisabledImageColor(const LLColor4& c)		{ mDisabledImageColor = c; }
+
+	void			setDisabledSelectedLabelColor( const LLColor4& c )	{ mDisabledSelectedLabelColor = c; }
+
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+
+	void			setLabel( const LLString& label);
+	virtual BOOL	setLabelArg( const LLString& key, const LLString& text );
+	void			setLabelUnselected(const LLString& label);
+	void			setLabelSelected(const LLString& label);
+	void			setDisabledLabel(const LLString& disabled_label);
+	void			setDisabledSelectedLabel(const LLString& disabled_label);
+	void			setDisabledLabelColor( const LLColor4& c )		{ mDisabledLabelColor = c; }
+	
+	void			setFont(const LLFontGL *font)		
+		{ mGLFont = ( font ? font : LLFontGL::sSansSerif); }
+	void			setScaleImage(BOOL scale)			{ mScaleImage = scale; }
+
+	void			setDropShadowedText(BOOL b)			{ mDropShadowedText = b; }
+
+	void			setBorderEnabled(BOOL b)					{ mBorderEnabled = b; }
+
+	static void		onHeldDown(void *userdata);  // to be called by gIdleCallbacks
+	static void		onMouseCaptureLost(LLMouseHandler* old_captor);
+
+	void			setFixedBorder(S32 width, S32 height) { mFixedWidth = width; mFixedHeight = height; }
+	void			setHoverGlowStrength(F32 strength) { mHoverGlowStrength = strength; }
+
+private:
+	void			setImageUnselectedID(const LLUUID &image_id);
+	void			setImageSelectedID(const LLUUID &image_id);
+	void			setImageHoverSelectedID(const LLUUID &image_id);
+	void			setImageHoverUnselectedID(const LLUUID &image_id);
+	void			setImageDisabledID(const LLUUID &image_id);
+	void			setImageDisabledSelectedID(const LLUUID &image_id);
+public:
+	void			setImageUnselected(const LLString &image_name);
+	void			setImageSelected(const LLString &image_name);
+	void			setImageHoverSelected(const LLString &image_name);
+	void			setImageHoverUnselected(const LLString &image_name);
+	void			setImageDisabled(const LLString &image_name);
+	void			setImageDisabledSelected(const LLString &image_name);
+	void			setCommitOnReturn(BOOL commit) { mCommitOnReturn = commit; }
+	BOOL			getCommitOnReturn() { return mCommitOnReturn; }
+
+protected:
+	virtual void	drawBorder(const LLColor4& color, S32 size);
+
+protected:
+
+	void			(*mClickedCallback)(void* data );
+	void			(*mMouseDownCallback)(void *data);
+	void			(*mMouseUpCallback)(void *data);
+	void			(*mHeldDownCallback)(void *data);
+
+	const LLFontGL	*mGLFont;
+	
+	LLFrameTimer	mMouseDownTimer;
+	F32				mHeldDownDelay;		// seconds, after which held-down callbacks get called
+
+	LLPointer<LLImageGL>	mImageUnselected;
+	LLUIString				mUnselectedLabel;
+	LLColor4				mUnselectedLabelColor;
+
+	LLPointer<LLImageGL>	mImageSelected;
+	LLUIString				mSelectedLabel;
+	LLColor4				mSelectedLabelColor;
+
+	LLPointer<LLImageGL>	mImageHoverSelected;
+
+	LLPointer<LLImageGL>	mImageHoverUnselected;
+
+	LLPointer<LLImageGL>	mImageDisabled;
+	LLUIString				mDisabledLabel;
+	LLColor4				mDisabledLabelColor;
+
+	LLPointer<LLImageGL>	mImageDisabledSelected;
+	LLUIString				mDisabledSelectedLabel;
+	LLColor4				mDisabledSelectedLabelColor;
+
+
+	LLUUID			mImageUnselectedID;
+	LLUUID			mImageSelectedID;
+	LLUUID			mImageHoverSelectedID;
+	LLUUID			mImageHoverUnselectedID;
+	LLUUID			mImageDisabledID;
+	LLUUID			mImageDisabledSelectedID;
+	LLString		mImageUnselectedName;
+	LLString		mImageSelectedName;
+	LLString		mImageHoverSelectedName;
+	LLString		mImageHoverUnselectedName;
+	LLString		mImageDisabledName;
+	LLString		mImageDisabledSelectedName;
+
+	LLColor4		mHighlightColor;
+	LLColor4		mUnselectedBgColor;
+	LLColor4		mSelectedBgColor;
+
+	LLColor4		mImageColor;
+	LLColor4		mDisabledImageColor;
+
+	BOOL			mToggleState;
+	BOOL			mScaleImage;
+
+	BOOL			mDropShadowedText;
+
+	BOOL			mBorderEnabled;
+
+	BOOL			mFlashing;
+
+	LLFontGL::HAlign mHAlign;
+	S32				mLeftHPad;
+	S32				mRightHPad;
+
+	S32				mFixedWidth;
+	S32				mFixedHeight;
+
+	F32				mHoverGlowStrength;
+	F32				mCurGlowStrength;
+
+	BOOL			mNeedsHighlight;
+	BOOL			mCommitOnReturn;
+
+	LLPointer<LLImageGL> mImagep;
+
+	static LLFrameTimer	sFlashingTimer;
+};
+
+class LLSquareButton
+:	public LLButton
+{
+public:
+	LLSquareButton(const LLString& name, const LLRect& rect, 
+		const LLString& label,
+		const LLFontGL *font = NULL,
+		const LLString& control_name = "",	
+		void (*click_callback)(void*) = NULL,
+		void *callback_data = NULL,
+		const LLString& selected_label = LLString::null );
+};
+
+// Helpful functions
+S32 round_up(S32 grid, S32 value);
+
+#endif  // LL_LLBUTTON_H
diff --git a/indra/llui/llcallbackmap.h b/indra/llui/llcallbackmap.h
new file mode 100644
index 0000000000..dfc965aa08
--- /dev/null
+++ b/indra/llui/llcallbackmap.h
@@ -0,0 +1,36 @@
+/** 
+ * @file llcallbackmap.h
+ * @brief LLCallbackMap base class
+ *
+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// llcallbackmap.h
+//
+// Copyright 2006, Linden Research, Inc.
+
+#ifndef LL_CALLBACK_MAP_H
+#define LL_CALLBACK_MAP_H
+
+#include <map>
+#include "llstring.h"
+
+class LLCallbackMap
+{
+public:
+	// callback definition.
+	typedef void* (*callback_t)(void* data);
+	
+	typedef std::map<LLString, LLCallbackMap> map_t;
+	typedef map_t::iterator map_iter_t;
+	typedef map_t::const_iterator map_const_iter_t;
+
+	LLCallbackMap() : mCallback(NULL), mData(NULL) { }
+	LLCallbackMap(callback_t callback, void* data) : mCallback(callback), mData(data) { }
+
+	callback_t	mCallback;
+	void*		mData;
+};
+
+#endif // LL_CALLBACK_MAP_H
diff --git a/indra/llui/llcheckboxctrl.cpp b/indra/llui/llcheckboxctrl.cpp
new file mode 100644
index 0000000000..3b054d2fec
--- /dev/null
+++ b/indra/llui/llcheckboxctrl.cpp
@@ -0,0 +1,315 @@
+/** 
+ * @file llcheckboxctrl.cpp
+ * @brief LLCheckBoxCtrl base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// The mutants are coming!
+
+#include "linden_common.h"
+
+#include "llcheckboxctrl.h"
+
+#include "llgl.h"
+#include "llui.h"
+#include "lluiconstants.h"
+#include "lluictrlfactory.h"
+#include "llcontrol.h"
+
+#include "llstring.h"
+#include "llfontgl.h"
+#include "lltextbox.h"
+#include "llkeyboard.h"
+#include "llviewborder.h"
+
+const U32 MAX_STRING_LENGTH = 10;
+
+ 
+LLCheckBoxCtrl::LLCheckBoxCtrl(const LLString& name, const LLRect& rect, 
+							    const LLString& label, 
+								const LLFontGL* font,
+								void (*commit_callback)(LLUICtrl* ctrl, void* userdata),
+								void* callback_user_data,
+								BOOL initial_value,
+								BOOL use_radio_style,
+								const LLString& control_which)
+:	LLUICtrl(name, rect, TRUE, commit_callback, callback_user_data, FOLLOWS_LEFT | FOLLOWS_TOP),
+	mTextEnabledColor( LLUI::sColorsGroup->getColor( "LabelTextColor" ) ),
+	mTextDisabledColor( LLUI::sColorsGroup->getColor( "LabelDisabledColor" ) ),
+	mRadioStyle( use_radio_style ),
+	mInitialValue( initial_value )
+{
+	if (font)
+	{
+		mFont = font;
+	}
+	else
+	{
+		mFont = LLFontGL::sSansSerifSmall;
+	}
+
+	// must be big enough to hold all children
+	setSpanChildren(TRUE);
+
+	mKeyboardFocusOnClick = TRUE;
+
+	// Label (add a little space to make sure text actually renders)
+	const S32 FUDGE = 10;
+	S32 text_width = mFont->getWidth( label ) + FUDGE;
+	S32 text_height = llround(mFont->getLineHeight());
+	LLRect label_rect;
+	label_rect.setOriginAndSize(
+		LLCHECKBOXCTRL_HPAD + LLCHECKBOXCTRL_BTN_SIZE + LLCHECKBOXCTRL_SPACING,
+		LLCHECKBOXCTRL_VPAD + 1, // padding to get better alignment
+		text_width + LLCHECKBOXCTRL_HPAD,
+		text_height );
+	mLabel = new LLTextBox( "CheckboxCtrl Label", label_rect, label.c_str(), mFont );
+	mLabel->setFollowsLeft();
+	mLabel->setFollowsBottom();
+	addChild(mLabel);
+
+	// Button
+	// Note: button cover the label by extending all the way to the right.
+	LLRect btn_rect;
+	btn_rect.setOriginAndSize(
+		LLCHECKBOXCTRL_HPAD,
+		LLCHECKBOXCTRL_VPAD,
+		LLCHECKBOXCTRL_BTN_SIZE + LLCHECKBOXCTRL_SPACING + text_width + LLCHECKBOXCTRL_HPAD,
+		llmax( text_height, LLCHECKBOXCTRL_BTN_SIZE ) + LLCHECKBOXCTRL_VPAD);
+	LLString active_true_id, active_false_id;
+	LLString inactive_true_id, inactive_false_id;
+	if (mRadioStyle)
+	{
+		active_true_id = "UIImgRadioActiveSelectedUUID";
+		active_false_id = "UIImgRadioActiveUUID";
+		inactive_true_id = "UIImgRadioInactiveSelectedUUID";
+		inactive_false_id = "UIImgRadioInactiveUUID";
+		mButton = new LLButton(
+			"Radio control button", btn_rect,
+			active_false_id, active_true_id, control_which,
+			&LLCheckBoxCtrl::onButtonPress, this, LLFontGL::sSansSerif ); 
+		mButton->setDisabledImages( inactive_false_id, inactive_true_id );
+		mButton->setHoverGlowStrength(0.35f);
+	}
+	else
+	{
+		active_false_id = "UIImgCheckboxActiveUUID";
+		active_true_id = "UIImgCheckboxActiveSelectedUUID";
+		inactive_true_id = "UIImgCheckboxInactiveSelectedUUID";
+		inactive_false_id = "UIImgCheckboxInactiveUUID";
+		mButton = new LLButton(
+			"Checkbox control button", btn_rect,
+			active_false_id, active_true_id, control_which,
+			&LLCheckBoxCtrl::onButtonPress, this, LLFontGL::sSansSerif ); 
+		mButton->setDisabledImages( inactive_false_id, inactive_true_id );
+		mButton->setHoverGlowStrength(0.35f);
+	}
+	mButton->setToggleState( initial_value );
+	mButton->setFollowsLeft();
+	mButton->setFollowsBottom();
+	mButton->setCommitOnReturn(FALSE);
+	addChild(mButton);
+}
+
+LLCheckBoxCtrl::~LLCheckBoxCtrl()
+{
+	// Children all cleaned up by default view destructor.
+}
+
+
+// static
+void LLCheckBoxCtrl::onButtonPress( void *userdata )
+{
+	LLCheckBoxCtrl* self = (LLCheckBoxCtrl*) userdata;
+
+	if (self->mRadioStyle)
+	{
+		if (!self->getValue())
+		{
+			self->setValue(TRUE);
+		}
+	}
+	else
+	{
+		self->toggle();
+	}
+	self->setControlValue(self->getValue());
+	self->onCommit();
+
+	if (self->mKeyboardFocusOnClick)
+	{
+		self->setFocus( TRUE );
+		self->onFocusReceived();
+	}
+}
+
+void LLCheckBoxCtrl::onCommit()
+{
+	if( getEnabled() )
+	{
+		setTentative(FALSE);
+		LLUICtrl::onCommit();
+	}
+}
+
+void LLCheckBoxCtrl::setEnabled(BOOL b)
+{
+	LLUICtrl::setEnabled(b);
+	mButton->setEnabled(b);
+}
+
+void LLCheckBoxCtrl::clear()
+{
+	setValue( FALSE );
+}
+
+void LLCheckBoxCtrl::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	//stretch or shrink bounding rectangle of label when rebuilding UI at new scale
+	const S32 FUDGE = 10;
+	S32 text_width = mFont->getWidth( mLabel->getText() ) + FUDGE;
+	S32 text_height = llround(mFont->getLineHeight());
+	LLRect label_rect;
+	label_rect.setOriginAndSize(
+		LLCHECKBOXCTRL_HPAD + LLCHECKBOXCTRL_BTN_SIZE + LLCHECKBOXCTRL_SPACING,
+		LLCHECKBOXCTRL_VPAD,
+		text_width,
+		text_height );
+	mLabel->setRect(label_rect);
+
+	LLRect btn_rect;
+	btn_rect.setOriginAndSize(
+		LLCHECKBOXCTRL_HPAD,
+		LLCHECKBOXCTRL_VPAD,
+		LLCHECKBOXCTRL_BTN_SIZE + LLCHECKBOXCTRL_SPACING + text_width,
+		llmax( text_height, LLCHECKBOXCTRL_BTN_SIZE ) );
+	mButton->setRect( btn_rect );
+	
+	LLUICtrl::reshape(width, height, called_from_parent);
+}
+
+void LLCheckBoxCtrl::draw()
+{
+	if (mEnabled)
+	{
+		mLabel->setColor( mTextEnabledColor );
+	}
+	else
+	{
+		mLabel->setColor( mTextDisabledColor );
+	}
+
+	// Draw children
+	LLUICtrl::draw();
+}
+
+//virtual
+void LLCheckBoxCtrl::setValue(const LLSD& value )
+{
+	mButton->setToggleState( value.asBoolean() );
+}
+
+//virtual
+LLSD LLCheckBoxCtrl::getValue() const
+{
+	return mButton->getToggleState();
+}
+
+void LLCheckBoxCtrl::setLabel( const LLString& label )
+{
+	mLabel->setText( label );
+	reshape(getRect().getWidth(), getRect().getHeight(), FALSE);
+}
+
+LLString LLCheckBoxCtrl::getLabel() const
+{
+	return mLabel->getText();
+}
+
+BOOL LLCheckBoxCtrl::setLabelArg( const LLString& key, const LLString& text )
+{
+	BOOL res = mLabel->setTextArg(key, text);
+	reshape(getRect().getWidth(), getRect().getHeight(), FALSE);
+	return res;
+}
+
+//virtual
+LLString LLCheckBoxCtrl::getControlName() const
+{
+	return mButton->getControlName();
+}
+
+// virtual
+void LLCheckBoxCtrl::setControlName(const LLString& control_name, LLView* context)
+{
+	mButton->setControlName(control_name, context);
+}
+
+// virtual
+LLXMLNodePtr LLCheckBoxCtrl::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	node->createChild("label", TRUE)->setStringValue(mLabel->getText());
+
+	LLString control_name = mButton->getControlName();
+	
+	node->createChild("initial_value", TRUE)->setBoolValue(mInitialValue);
+
+	node->createChild("font", TRUE)->setStringValue(LLFontGL::nameFromFont(mFont));
+
+	node->createChild("radio_style", TRUE)->setBoolValue(mRadioStyle);
+
+	return node;
+}
+
+// static
+LLView* LLCheckBoxCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("checkbox");
+	node->getAttributeString("name", name);
+
+	LLString label("");
+	node->getAttributeString("label", label);
+
+	BOOL initial_value = FALSE;
+	
+	LLFontGL* font = LLView::selectFont(node);
+
+	BOOL radio_style = FALSE;
+	node->getAttributeBOOL("radio_style", radio_style);
+
+	LLUICtrlCallback callback = NULL;
+
+	if (label.empty())
+	{
+		label.assign(node->getTextContents());
+	}
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	LLCheckBoxCtrl* checkbox = new LLCheckboxCtrl(name, 
+		rect, 
+		label,
+		font,
+		callback,
+		NULL,
+		initial_value,
+		radio_style); // if true, draw radio button style icons
+
+	LLColor4 color;
+	color = LLUI::sColorsGroup->getColor( "LabelTextColor" );
+	LLUICtrlFactory::getAttributeColor(node,"text_enabled_color", color);
+	checkbox->setEnabledColor(color);
+
+	color = LLUI::sColorsGroup->getColor( "LabelDisabledColor" );
+	LLUICtrlFactory::getAttributeColor(node,"text_disabled_color", color);
+	checkbox->setDisabledColor(color);
+
+	checkbox->initFromXML(node, parent);
+
+	return checkbox;
+}
diff --git a/indra/llui/llcheckboxctrl.h b/indra/llui/llcheckboxctrl.h
new file mode 100644
index 0000000000..b2f9c95974
--- /dev/null
+++ b/indra/llui/llcheckboxctrl.h
@@ -0,0 +1,112 @@
+/** 
+ * @file llcheckboxctrl.h
+ * @brief LLCheckBoxCtrl base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLCHECKBOXCTRL_H
+#define LL_LLCHECKBOXCTRL_H
+
+
+#include "stdtypes.h"
+#include "lluictrl.h"
+#include "llbutton.h"
+#include "v4color.h"
+#include "llrect.h"
+
+//
+// Constants
+//
+const S32 LLCHECKBOXCTRL_BTN_SIZE = 13;
+const S32 LLCHECKBOXCTRL_VPAD = 2;
+const S32 LLCHECKBOXCTRL_HPAD = 2;
+const S32 LLCHECKBOXCTRL_SPACING = 5;
+const S32 LLCHECKBOXCTRL_HEIGHT = 16;
+
+// Deprecated, don't use.
+#define CHECKBOXCTRL_HEIGHT LLCHECKBOXCTRL_HEIGHT
+
+const BOOL	RADIO_STYLE = TRUE;
+const BOOL	CHECK_STYLE = FALSE;
+
+//
+// Classes
+//
+class LLFontGL;
+class LLTextBox;
+class LLViewBorder;
+
+class LLCheckBoxCtrl
+: public LLUICtrl
+{
+public:
+	LLCheckBoxCtrl(const LLString& name, const LLRect& rect, const LLString& label,	
+		const LLFontGL* font = NULL,
+		void (*commit_callback)(LLUICtrl*, void*) = NULL,
+		void* callback_userdata = NULL,
+		BOOL initial_value = FALSE,
+		BOOL use_radio_style = FALSE, // if true, draw radio button style icons
+		const LLString& control_which = LLString::null);
+	virtual ~LLCheckBoxCtrl();
+
+	// LLView interface
+	virtual EWidgetType getWidgetType() const	{ return WIDGET_TYPE_CHECKBOX; }
+	virtual LLString getWidgetTag() const { return LL_CHECK_BOX_CTRL_TAG; }
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual void		setEnabled( BOOL b );
+
+	virtual void		draw();
+	virtual void		reshape(S32 width, S32 height, BOOL called_from_parent);
+
+	// LLUICtrl interface
+	virtual void		setValue(const LLSD& value );
+	virtual LLSD		getValue() const;
+			BOOL		get() { return (BOOL)getValue().asBoolean(); }
+			void		set(BOOL value) { setValue(value); }
+
+	virtual void		setTentative(BOOL b)	{ mButton->setTentative(b); }
+	virtual BOOL		getTentative() const	{ return mButton->getTentative(); }
+
+	virtual BOOL		setLabelArg( const LLString& key, const LLString& text );
+
+	virtual void		clear();
+	virtual void		onCommit();
+
+	// LLCheckBoxCtrl interface
+	virtual BOOL		toggle()				{ return mButton->toggleState(); }		// returns new state
+
+	void				setEnabledColor( const LLColor4 &color ) { mTextEnabledColor = color; }
+	void				setDisabledColor( const LLColor4 &color ) { mTextDisabledColor = color; }
+
+	void				setLabel( const LLString& label );
+	LLString			getLabel() const;
+
+	virtual void		setControlName(const LLString& control_name, LLView* context);
+	virtual LLString 	getControlName() const;
+
+	static void			onButtonPress(void *userdata);
+
+protected:
+	// note: value is stored in toggle state of button
+	LLButton*		mButton;
+	LLTextBox*		mLabel;
+	const LLFontGL* mFont;
+	LLColor4		mTextEnabledColor;
+	LLColor4		mTextDisabledColor;
+	BOOL			mRadioStyle;
+	BOOL			mInitialValue;
+	BOOL			mKeyboardFocusOnClick;
+	LLViewBorder*	mBorder;
+};
+
+
+// HACK: fix old capitalization problem
+//typedef LLCheckBoxCtrl LLCheckboxCtrl;
+#define LLCheckboxCtrl LLCheckBoxCtrl
+
+
+#endif  // LL_LLCHECKBOXCTRL_H
diff --git a/indra/llui/llclipboard.cpp b/indra/llui/llclipboard.cpp
new file mode 100644
index 0000000000..f2b546ec28
--- /dev/null
+++ b/indra/llui/llclipboard.cpp
@@ -0,0 +1,71 @@
+/** 
+ * @file llclipboard.cpp
+ * @brief LLClipboard base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llclipboard.h"
+
+#include "llerror.h"
+#include "llmath.h"
+#include "llstring.h"
+#include "llview.h"
+#include "llwindow.h"
+
+// Global singleton
+LLClipboard gClipboard;
+
+
+LLClipboard::LLClipboard()
+{
+}
+
+
+LLClipboard::~LLClipboard()
+{
+}
+
+
+void LLClipboard::copyFromSubstring(const LLWString &src, S32 pos, S32 len, const LLUUID& source_id )
+{
+	mSourceID = source_id;
+	mString = src.substr(pos, len);
+	LLView::getWindow()->copyTextToClipboard( mString );
+}
+
+
+LLWString LLClipboard::getPasteWString( LLUUID* source_id )
+{
+	if( mSourceID.notNull() )
+	{
+		LLWString temp_string;
+		LLView::getWindow()->pasteTextFromClipboard(temp_string);
+
+		if( temp_string != mString )
+		{
+			mSourceID.setNull();
+			mString = temp_string;
+		}
+	}
+	else
+	{
+		LLView::getWindow()->pasteTextFromClipboard(mString);
+	}
+
+	if( source_id )
+	{
+		*source_id = mSourceID;
+	}
+
+	return mString;
+}
+
+
+BOOL LLClipboard::canPasteString()
+{
+	return LLView::getWindow()->isClipboardTextAvailable();
+}
diff --git a/indra/llui/llclipboard.h b/indra/llui/llclipboard.h
new file mode 100644
index 0000000000..a5bb4fc790
--- /dev/null
+++ b/indra/llui/llclipboard.h
@@ -0,0 +1,41 @@
+/** 
+ * @file llclipboard.h
+ * @brief LLClipboard base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLCLIPBOARD_H
+#define LL_LLCLIPBOARD_H
+
+
+#include "llstring.h"
+#include "lluuid.h"
+
+//
+// Classes
+//
+class LLClipboard
+{
+protected:
+	LLUUID		mSourceID;
+	LLWString mString;
+	
+public:
+	LLClipboard();
+	~LLClipboard();
+
+	void		copyFromSubstring(const LLWString &copy_from, S32 pos, S32 len, const LLUUID& source_id = LLUUID::null );
+
+
+	BOOL		canPasteString();
+	LLWString 	getPasteWString(LLUUID* source_id = NULL);
+};
+
+
+// Global singleton
+extern LLClipboard gClipboard;
+
+
+#endif  // LL_LLCLIPBOARD_H
diff --git a/indra/llui/llcombobox.cpp b/indra/llui/llcombobox.cpp
new file mode 100644
index 0000000000..84c5d354be
--- /dev/null
+++ b/indra/llui/llcombobox.cpp
@@ -0,0 +1,1133 @@
+/** 
+ * @file llcombobox.cpp
+ * @brief LLComboBox base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// A control that displays the name of the chosen item, which when
+// clicked shows a scrolling box of options.
+
+#include "linden_common.h"
+
+// file includes
+#include "llcombobox.h"
+
+// common includes
+#include "llstring.h"
+
+// newview includes
+#include "llbutton.h"
+#include "llkeyboard.h"
+#include "llscrolllistctrl.h"
+#include "llwindow.h"
+#include "llfloater.h"
+#include "llscrollbar.h"
+#include "llcontrol.h"
+#include "llfocusmgr.h"
+#include "lllineeditor.h"
+#include "v2math.h"
+
+// Globals
+S32 LLCOMBOBOX_HEIGHT = 0;
+S32 LLCOMBOBOX_WIDTH = 0;
+ 
+LLComboBox::LLComboBox(	const LLString& name, const LLRect &rect, const LLString& label,
+	void (*commit_callback)(LLUICtrl*,void*),
+	void *callback_userdata,
+	S32 list_width
+	)
+:	LLUICtrl(name, rect, TRUE, commit_callback, callback_userdata, 
+			 FOLLOWS_LEFT | FOLLOWS_TOP),
+	mDrawButton(TRUE),
+	mTextEntry(NULL),
+	mArrowImage(NULL),
+	mAllowTextEntry(FALSE),
+	mMaxChars(20),
+	mTextEntryTentative(TRUE),
+	mPrearrangeCallback( NULL ),
+	mTextEntryCallback( NULL ),
+	mListWidth(list_width)
+{
+	// For now, all comboboxes don't take keyboard focus when clicked.
+	// This might change if it is part of a modal dialog.
+	// mKeyboardFocusOnClick = FALSE;
+
+	// Revert to standard behavior.  When this control's parent is hidden, it needs to
+	// hide this ctrl--which won't just happen automatically since when LLComboBox is 
+	// showing its list, it's also set to TopView.  When keyboard focus is cleared all
+	// controls (including this one) know that they are no longer editing.
+	mKeyboardFocusOnClick = TRUE;
+
+	LLRect r;
+	r.setOriginAndSize(0, 0, rect.getWidth(), rect.getHeight());
+
+	// Always use text box 
+	// Text label button
+	mButton = new LLSquareButton("comboxbox button",
+								 r, label, NULL, LLString::null,
+								 &LLComboBox::onButtonClick, this);
+	mButton->setFont(LLFontGL::sSansSerifSmall);
+	mButton->setFollows(FOLLOWS_LEFT | FOLLOWS_BOTTOM | FOLLOWS_RIGHT);
+	mButton->setHAlign( LLFontGL::LEFT );
+
+	const S32 ARROW_WIDTH = 16;
+	mButton->setRightHPad( ARROW_WIDTH );
+	addChild(mButton);
+
+	// Default size, will be set by arrange() call in button callback. 
+	if (list_width == 0)
+	{
+		list_width = mRect.getWidth() + SCROLLBAR_SIZE;
+	}
+	r.setOriginAndSize(0, 16, list_width, 220);
+
+	// disallow multiple selection
+	mList = new LLScrollListCtrl(
+		"ComboBox", r, 
+		&LLComboBox::onItemSelected, this, FALSE);
+	mList->setVisible(FALSE);
+	mList->setBgWriteableColor( LLColor4(1,1,1,1) );
+	mList->setCommitOnKeyboardMovement(FALSE);
+	addChild(mList);
+
+	LLRect border_rect(0, mRect.getHeight(), mRect.getWidth(), 0);
+	mBorder = new LLViewBorder( "combo border", border_rect );
+	addChild( mBorder );
+	mBorder->setFollows(FOLLOWS_LEFT|FOLLOWS_RIGHT|FOLLOWS_TOP|FOLLOWS_BOTTOM);
+
+	LLUUID arrow_image_id( LLUI::sAssetsGroup->getString("combobox_arrow.tga") );
+	mArrowImage = LLUI::sImageProvider->getUIImageByID(arrow_image_id);
+}
+
+
+LLComboBox::~LLComboBox()
+{
+	// children automatically deleted, including mMenu, mButton
+}
+
+// virtual
+LLXMLNodePtr LLComboBox::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	// Attributes
+
+	node->createChild("allow_text_entry", TRUE)->setBoolValue(mAllowTextEntry);
+
+	node->createChild("max_chars", TRUE)->setIntValue(mMaxChars);
+
+	// Contents
+
+	std::vector<LLScrollListItem*> data_list = mList->getAllData();
+	std::vector<LLScrollListItem*>::iterator data_itor;
+	for (data_itor = data_list.begin(); data_itor != data_list.end(); ++data_itor)
+	{
+		LLScrollListItem* item = *data_itor;
+		LLScrollListCell* cell = item->getColumn(0);
+		if (cell)
+		{
+			LLXMLNodePtr item_node = node->createChild("combo_item", FALSE);
+			LLSD value = item->getValue();
+			item_node->createChild("value", TRUE)->setStringValue(value.asString());
+			item_node->createChild("enabled", TRUE)->setBoolValue(item->getEnabled());
+			item_node->setStringValue(cell->getText());
+		}
+	}
+
+	return node;
+}
+
+// static
+LLView* LLComboBox::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("combo_box");
+	node->getAttributeString("name", name);
+
+	LLString label("");
+	node->getAttributeString("label", label);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	BOOL allow_text_entry = FALSE;
+	node->getAttributeBOOL("allow_text_entry", allow_text_entry);
+
+	S32 max_chars = 20;
+	node->getAttributeS32("max_chars", max_chars);
+
+	LLUICtrlCallback callback = NULL;
+
+	LLComboBox* combo_box = new LLComboBox(name,
+							rect, 
+							label,
+							callback,
+							NULL);
+	combo_box->setAllowTextEntry(allow_text_entry, max_chars);
+
+	combo_box->initFromXML(node, parent);
+
+	const LLString& contents = node->getValue();
+
+	if (contents.find_first_not_of(" \n\t") != contents.npos)
+	{
+		llerrs << "Legacy combo box item format used! Please convert to <combo_item> tags!" << llendl;
+	}
+	else
+	{
+		LLXMLNodePtr child;
+		for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+		{
+			if (child->hasName("combo_item"))
+			{
+				LLString label = child->getTextContents();
+
+				LLString value = label;
+				child->getAttributeString("value", value);
+
+				combo_box->add(label, LLSD(value) );
+			}
+		}
+	}
+
+	combo_box->selectFirstItem();
+
+	return combo_box;
+}
+
+void LLComboBox::setEnabled(BOOL enabled)
+{
+	LLUICtrl::setEnabled(enabled);
+	mButton->setEnabled(enabled);
+}
+
+//FIXME: these are all hacks to support the fact that the combobox has mouse capture
+// so we can hide the list when we don't handle the mouse up event
+BOOL LLComboBox::handleHover(S32 x, S32 y, MASK mask)
+{
+	if (mList->getVisible())
+	{
+		S32 local_x, local_y;
+		LLView::localPointToOtherView(x, y, &local_x, &local_y, mList);
+		if (mList->pointInView(local_x, local_y))
+		{
+			return mList->handleHover(local_x, local_y, mask);
+		}
+	}
+	return LLUICtrl::handleHover(x, y, mask);
+}
+
+BOOL LLComboBox::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	if (mList->getVisible())
+	{
+		S32 local_x, local_y;
+		LLView::localPointToOtherView(x, y, &local_x, &local_y, mList);
+		if (mList->pointInView(local_x, local_y))
+		{
+			return mList->handleMouseDown(local_x, local_y, mask);
+		}
+	}
+	BOOL has_focus_now = hasFocus();
+	BOOL handled = LLUICtrl::handleMouseDown(x, y, mask);
+	if (handled && !has_focus_now)
+	{
+		onFocusReceived();
+	}
+
+	return handled;
+}	
+
+BOOL LLComboBox::handleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	if (mList->getVisible())
+	{
+		S32 local_x, local_y;
+		LLView::localPointToOtherView(x, y, &local_x, &local_y, mList);
+		if (mList->pointInView(local_x, local_y))
+		{
+			return mList->handleRightMouseDown(local_x, local_y, mask);
+		}
+	}
+	return LLUICtrl::handleRightMouseDown(x, y, mask);
+}
+
+BOOL LLComboBox::handleRightMouseUp(S32 x, S32 y, MASK mask)
+{
+	if (mList->getVisible())
+	{
+		S32 local_x, local_y;
+		LLView::localPointToOtherView(x, y, &local_x, &local_y, mList);
+		if (mList->pointInView(local_x, local_y))
+		{
+			return mList->handleRightMouseUp(local_x, local_y, mask);
+		}
+	}
+	return LLUICtrl::handleRightMouseUp(x, y, mask);
+}
+
+BOOL LLComboBox::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	if (mList->getVisible())
+	{
+		S32 local_x, local_y;
+		LLView::localPointToOtherView(x, y, &local_x, &local_y, mList);
+		if (mList->pointInView(local_x, local_y))
+		{
+			return mList->handleDoubleClick(local_x, local_y, mask);
+		}
+	}
+	return LLUICtrl::handleDoubleClick(x, y, mask);
+}
+
+BOOL LLComboBox::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = childrenHandleMouseUp(x, y, mask) != NULL;
+
+	if (!handled && mList->getVisible())
+	{
+		S32 local_x, local_y;
+		LLView::localPointToOtherView(x, y, &local_x, &local_y, mList);
+		if (mList->pointInView(local_x, local_y))
+		{
+			handled = mList->handleMouseUp(local_x, local_y, mask);
+		}
+	}
+
+	if( !handled && gFocusMgr.getMouseCapture() == this )
+	{
+		// Mouse events that we didn't handle cause the list to be hidden.
+		// Eat mouse event, regardless of where on the screen it happens.
+		hideList();
+		handled = TRUE;
+	}
+
+	return handled;
+}
+
+void LLComboBox::clear()
+{ 
+	if (mTextEntry)
+	{
+		mTextEntry->setText("");
+	}
+	mButton->setLabelSelected("");
+	mButton->setLabelUnselected("");
+	mButton->setDisabledLabel("");
+	mButton->setDisabledSelectedLabel("");
+	mList->deselectAllItems();
+}
+
+void LLComboBox::onCommit()
+{
+	if (mAllowTextEntry && getCurrentIndex() != -1)
+	{
+		// we have selected an existing item, blitz the manual text entry with
+		// the properly capitalized item
+		mTextEntry->setValue(getSimple());
+		mTextEntry->setTentative(FALSE);
+	}
+	LLUICtrl::onCommit();
+}
+
+// add item "name" to menu
+void LLComboBox::add(const LLString& name, EAddPosition pos, BOOL enabled)
+{
+	mList->addSimpleItem(name, pos, enabled);
+	mList->selectFirstItem();
+}
+
+// add item "name" with a unique id to menu
+void LLComboBox::add(const LLString& name, const LLUUID& id, EAddPosition pos, BOOL enabled )
+{
+	mList->addSimpleItem(name, LLSD(id), pos, enabled);
+	mList->selectFirstItem();
+}
+
+// add item "name" with attached userdata
+void LLComboBox::add(const LLString& name, void* userdata, EAddPosition pos, BOOL enabled )
+{
+	LLScrollListItem* item = mList->addSimpleItem(name, pos, enabled);
+	item->setUserdata( userdata );
+	mList->selectFirstItem();
+}
+
+// add item "name" with attached generic data
+void LLComboBox::add(const LLString& name, LLSD value, EAddPosition pos, BOOL enabled )
+{
+	mList->addSimpleItem(name, value, pos, enabled);
+	mList->selectFirstItem();
+}
+
+
+void LLComboBox::sortByName()
+{
+	mList->sortByColumn(0, TRUE);
+}
+
+
+// Choose an item with a given name in the menu.
+// Returns TRUE if the item was found.
+BOOL LLComboBox::setSimple(const LLString& name)
+{
+	BOOL found = mList->selectSimpleItem(name, FALSE);
+
+	if (found)
+	{
+		setLabel(name);
+	}
+
+	return found;
+}
+
+// virtual
+void LLComboBox::setValue(const LLSD& value)
+{
+	BOOL found = mList->selectByValue(value);
+	if (found)
+	{
+		LLScrollListItem* item = mList->getFirstSelected();
+		if (item)
+		{
+			setLabel( mList->getSimpleSelectedItem() );
+		}
+	}
+}
+
+const LLString& LLComboBox::getSimple() const
+{
+	const LLString& res = mList->getSimpleSelectedItem();
+	if (res.empty() && mAllowTextEntry)
+	{
+		return mTextEntry->getText();
+	}
+	else
+	{
+		return res;
+	}
+}
+
+const LLString& LLComboBox::getSimpleSelectedItem(S32 column) const
+{
+	return mList->getSimpleSelectedItem(column);
+}
+
+// virtual
+LLSD LLComboBox::getValue() const
+{
+	LLScrollListItem* item = mList->getFirstSelected();
+	if( item )
+	{
+		return item->getValue();
+	}
+	else if (mAllowTextEntry)
+	{
+		return mTextEntry->getValue();
+	}
+	else
+	{
+		return LLSD();
+	}
+}
+
+void LLComboBox::setLabel(const LLString& name)
+{
+	if ( mAllowTextEntry )
+	{
+		mTextEntry->setText(name);
+		if (mList->selectSimpleItem(name, FALSE))
+		{
+			mTextEntry->setTentative(FALSE);
+		}
+		else
+		{
+			mTextEntry->setTentative(mTextEntryTentative);
+		}
+	}
+	else
+	{
+		mButton->setLabelUnselected(name);
+		mButton->setLabelSelected(name);
+		mButton->setDisabledLabel(name);
+		mButton->setDisabledSelectedLabel(name);
+	}
+}
+
+
+BOOL LLComboBox::remove(const LLString& name)
+{
+	BOOL found = mList->selectSimpleItem(name);
+
+	if (found)
+	{
+		LLScrollListItem* item = mList->getFirstSelected();
+		if (item)
+		{
+			mList->deleteSingleItem(mList->getItemIndex(item));
+		}
+	}
+
+	return found;
+}
+
+BOOL LLComboBox::remove(S32 index)
+{
+	if (index < mList->getItemCount())
+	{
+		mList->deleteSingleItem(index);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+// Keyboard focus lost.
+void LLComboBox::onFocusLost()
+{
+	hideList();
+	// if valid selection
+	if (mAllowTextEntry && getCurrentIndex() != -1)
+	{
+		mTextEntry->selectAll();
+	}
+}
+
+void LLComboBox::setButtonVisible(BOOL visible)
+{
+	mButton->setVisible(visible);
+	mDrawButton = visible;
+	if (mTextEntry)
+	{
+		LLRect text_entry_rect(0, mRect.getHeight(), mRect.getWidth(), 0);
+		if (visible)
+		{
+			text_entry_rect.mRight -= mArrowImage->getWidth() + 2 * LLUI::sConfigGroup->getS32("DropShadowButton");
+		}
+		//mTextEntry->setRect(text_entry_rect);
+		mTextEntry->reshape(text_entry_rect.getWidth(), text_entry_rect.getHeight(), TRUE);
+	}
+}
+
+void LLComboBox::draw()
+{
+	if( getVisible() )
+	{
+		mBorder->setKeyboardFocusHighlight(hasFocus());
+
+		mButton->setEnabled(mEnabled /*&& !mList->isEmpty()*/);
+
+		// Draw children
+		LLUICtrl::draw();
+
+		if (mDrawButton)
+		{
+			// Paste the graphic on the right edge
+			if (!mArrowImage.isNull())
+			{
+				S32 left = mRect.getWidth() - mArrowImage->getWidth() - LLUI::sConfigGroup->getS32("DropShadowButton");
+
+				gl_draw_image( left, 0, mArrowImage,
+					LLColor4::white);
+			}
+		}
+	}
+}
+
+BOOL LLComboBox::setCurrentByIndex( S32 index )
+{
+	BOOL found = mList->selectNthItem( index );
+	if (found)
+	{
+		setLabel(mList->getSimpleSelectedItem());
+	}
+	return found;
+}
+
+S32 LLComboBox::getCurrentIndex() const
+{
+	LLScrollListItem* item = mList->getFirstSelected();
+	if( item )
+	{
+		return mList->getItemIndex( item );
+	}
+	return -1;
+}
+
+
+void* LLComboBox::getCurrentUserdata()
+{
+	LLScrollListItem* item = mList->getFirstSelected();
+	if( item )
+	{
+		return item->getUserdata();
+	}
+	return NULL;
+}
+
+
+void LLComboBox::showList()
+{
+	// Make sure we don't go off top of screen.
+	LLCoordWindow window_size;
+	getWindow()->getSize(&window_size);
+	//HACK: shouldn't have to know about scale here
+	mList->arrange( 192, llfloor((F32)window_size.mY / LLUI::sGLScaleFactor.mV[VY]) - 50 );
+
+	// Move rect so it hangs off the bottom of this view
+	LLRect rect = mList->getRect();
+
+	rect.setLeftTopAndSize(0, 0, rect.getWidth(), rect.getHeight() );
+	mList->setRect(rect);
+
+	// Make sure that we can see the whole list
+	LLRect floater_area_screen;
+	LLRect floater_area_local;
+	gFloaterView->getParent()->localRectToScreen( gFloaterView->getRect(), &floater_area_screen );
+	screenRectToLocal( floater_area_screen, &floater_area_local );
+	mList->translateIntoRect( floater_area_local, FALSE );
+
+	// Make sure we didn't go off bottom of screen
+	S32 x, y;
+	mList->localPointToScreen(0, 0, &x, &y);
+
+	if (y < 0)
+	{
+		mList->translate(0, -y);
+	}
+
+	gFocusMgr.setMouseCapture( this, LLComboBox::onMouseCaptureLost );
+	// NB: this call will trigger the focuslost callback which will hide the list, so do it first
+	// before finally showing the list
+
+	if (!mList->getFirstSelected())
+	{
+		// if nothing is selected, select the first item
+		// so that the callback is not immediately triggered on setFocus()
+		mList->selectFirstItem();
+	}
+	gFocusMgr.setKeyboardFocus(mList, onListFocusLost);
+
+	// Show the list and push the button down
+	mButton->setToggleState(TRUE);
+	mList->setVisible(TRUE);
+	
+	gFocusMgr.setTopView(mList, LLComboBox::onTopViewLost );
+
+}
+
+void LLComboBox::hideList()
+{
+	mButton->setToggleState(FALSE);
+	mList->setVisible(FALSE);
+	mList->highlightNthItem(-1);
+
+	if( gFocusMgr.getTopView() == mList )
+	{
+		gFocusMgr.setTopView(NULL, NULL);
+	}
+
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		gFocusMgr.setMouseCapture( NULL, NULL );
+	}
+
+	if( gFocusMgr.getKeyboardFocus() == mList )
+	{
+		if (mAllowTextEntry)
+		{
+			mTextEntry->setFocus(TRUE);
+		}
+		else
+		{
+			setFocus(TRUE);
+		}
+	}
+}
+
+
+
+//------------------------------------------------------------------
+// static functions
+//------------------------------------------------------------------
+
+// static
+void LLComboBox::onButtonClick(void *userdata)
+{
+	LLComboBox *self = (LLComboBox *)userdata;
+
+	if (!self->mList->getVisible())
+	{
+		LLScrollListItem* last_selected_item = self->mList->getLastSelectedItem();
+		if (last_selected_item)
+		{
+			// highlight the original selection before potentially selecting a new item
+			self->mList->highlightNthItem(self->mList->getItemIndex(last_selected_item));
+		}
+
+		if( self->mPrearrangeCallback )
+		{
+			self->mPrearrangeCallback( self, self->mCallbackUserData );
+		}
+
+		if (self->mList->getItemCount() != 0)
+		{
+			self->showList();
+		}
+
+		if (self->mKeyboardFocusOnClick && !self->hasFocus())
+		{
+			self->setFocus( TRUE );
+		}
+	}
+	else
+	{
+		// hide and release keyboard focus
+		self->hideList();
+
+		self->onCommit();
+	}
+}
+
+
+
+// static
+void LLComboBox::onItemSelected(LLUICtrl* item, void *userdata)
+{
+	// Note: item is the LLScrollListCtrl
+	LLComboBox *self = (LLComboBox *) userdata;
+
+	const LLString& name = self->mList->getSimpleSelectedItem();
+
+	self->hideList();
+
+	S32 cur_id = self->getCurrentIndex();
+	if (cur_id != -1)
+	{
+		self->setLabel(self->mList->getSimpleSelectedItem());
+
+		if (self->mAllowTextEntry)
+		{
+			self->mTextEntry->setText(name);
+			self->mTextEntry->setTentative(FALSE);
+			gFocusMgr.setKeyboardFocus(self->mTextEntry, NULL);
+			self->mTextEntry->selectAll();
+		}
+		else
+		{
+			self->mButton->setLabelUnselected( name );
+			self->mButton->setLabelSelected( name );
+			self->mButton->setDisabledLabel( name );
+			self->mButton->setDisabledSelectedLabel( name );
+		}
+	}
+	self->onCommit();
+}
+
+// static
+void LLComboBox::onTopViewLost(LLView* old_focus)
+{
+	LLComboBox *self = (LLComboBox *) old_focus->getParent();
+	self->hideList();
+}
+
+
+// static
+void LLComboBox::onMouseCaptureLost(LLMouseHandler*)
+{
+	// Can't hide the list here.  If the list scrolls off the screen,
+	// and you click in the arrow buttons of the scroll bar, they must capture
+	// the mouse to handle scrolling-while-mouse-down.
+}
+
+BOOL LLComboBox::handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect_screen)
+{
+	
+    LLString tool_tip;
+
+	if (LLUI::sShowXUINames)
+	{
+		tool_tip = mName;
+	}
+	else
+	{
+		tool_tip = mToolTipMsg;
+	}
+
+	if( getVisible() && pointInView( x, y ) ) 
+	{
+		if( !tool_tip.empty() )
+		{
+			msg = tool_tip;
+
+			// Convert rect local to screen coordinates
+			localPointToScreen( 
+				0, 0, 
+				&(sticky_rect_screen->mLeft), &(sticky_rect_screen->mBottom) );
+			localPointToScreen(
+				mRect.getWidth(), mRect.getHeight(),
+				&(sticky_rect_screen->mRight), &(sticky_rect_screen->mTop) );
+		}
+		return TRUE;
+	}
+	return FALSE;
+}
+
+BOOL LLComboBox::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	BOOL result = FALSE;
+	if (gFocusMgr.childHasKeyboardFocus(this))
+	{
+		//give list a chance to pop up and handle key
+		LLScrollListItem* last_selected_item = mList->getLastSelectedItem();
+		if (last_selected_item)
+		{
+			// highlight the original selection before potentially selecting a new item
+			mList->highlightNthItem(mList->getItemIndex(last_selected_item));
+		}
+		result = mList->handleKeyHere(key, mask, FALSE);
+		// if selection has changed, pop open list
+		if (mList->getLastSelectedItem() != last_selected_item)
+		{
+			showList();
+		}
+	}
+	return result;
+}
+
+BOOL LLComboBox::handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent)
+{
+	BOOL result = FALSE;
+	if (gFocusMgr.childHasKeyboardFocus(this))
+	{
+		// space bar just shows the list
+		if (' ' != uni_char )
+		{
+			LLScrollListItem* last_selected_item = mList->getLastSelectedItem();
+			if (last_selected_item)
+			{
+				// highlight the original selection before potentially selecting a new item
+				mList->highlightNthItem(mList->getItemIndex(last_selected_item));
+			}
+			result = mList->handleUnicodeCharHere(uni_char, called_from_parent);
+			if (mList->getLastSelectedItem() != last_selected_item)
+			{
+				showList();
+			}
+		}
+	}
+	return result;
+}
+
+void LLComboBox::setAllowTextEntry(BOOL allow, S32 max_chars, BOOL set_tentative)
+{
+	LLRect rect( 0, mRect.getHeight(), mRect.getWidth(), 0);
+	if (allow && !mAllowTextEntry)
+	{
+		S32 shadow_size = LLUI::sConfigGroup->getS32("DropShadowButton");
+		mButton->setRect(LLRect( mRect.getWidth() - mArrowImage->getWidth() - 2 * shadow_size,
+								rect.mTop, rect.mRight, rect.mBottom));
+		mButton->setTabStop(FALSE);
+
+		// clear label on button
+		LLString cur_label = mButton->getLabelSelected();
+		setLabel("");
+		if (!mTextEntry)
+		{
+			LLRect text_entry_rect(0, mRect.getHeight(), mRect.getWidth(), 0);
+			text_entry_rect.mRight -= mArrowImage->getWidth() + 2 * LLUI::sConfigGroup->getS32("DropShadowButton");
+			mTextEntry = new LLLineEditor("combo_text_entry",
+										text_entry_rect,
+										"",
+										LLFontGL::sSansSerifSmall,
+										max_chars,
+										onTextCommit,
+										onTextEntry,
+										NULL,
+										this,
+										NULL,		// prevalidate func
+										LLViewBorder::BEVEL_NONE,
+										LLViewBorder::STYLE_LINE,
+										0);	// no border
+			mTextEntry->setSelectAllonFocusReceived(TRUE);
+			mTextEntry->setHandleEditKeysDirectly(TRUE);
+			mTextEntry->setCommitOnFocusLost(FALSE);
+			mTextEntry->setText(cur_label);
+			mTextEntry->setIgnoreTab(TRUE);
+			addChild(mTextEntry);
+			mMaxChars = max_chars;
+		}
+		else
+		{
+			mTextEntry->setVisible(TRUE);
+		}
+	}
+	else if (!allow && mAllowTextEntry)
+	{
+		mButton->setRect(rect);
+		mButton->setTabStop(TRUE);
+
+		if (mTextEntry)
+		{
+			mTextEntry->setVisible(FALSE);
+		}
+	}
+	mAllowTextEntry = allow;
+	mTextEntryTentative = set_tentative;	
+}
+
+void LLComboBox::setTextEntry(const LLString& text)
+{
+	if (mTextEntry)
+	{
+		mTextEntry->setText(text);
+		updateSelection();
+	}
+}
+
+//static 
+void LLComboBox::onTextEntry(LLLineEditor* line_editor, void* user_data)
+{
+	LLComboBox* self = (LLComboBox*)user_data;
+
+	if (self->mTextEntryCallback)
+	{
+		(*self->mTextEntryCallback)(line_editor, self->mCallbackUserData);
+	}
+
+	KEY key = gKeyboard->currentKey();
+	if (key == KEY_BACKSPACE || 
+		key == KEY_DELETE)
+	{
+		if (self->mList->selectSimpleItem(line_editor->getText(), FALSE))
+		{
+			line_editor->setTentative(FALSE);
+		}
+		else
+		{
+			line_editor->setTentative(self->mTextEntryTentative);
+		}
+		return;
+	}
+
+	if (key == KEY_LEFT || 
+		key == KEY_RIGHT)
+	{
+		return;
+	}
+
+	if (key == KEY_DOWN)
+	{
+		self->setCurrentByIndex(llmin(self->getItemCount() - 1, self->getCurrentIndex() + 1));
+		if (!self->mList->getVisible())
+		{
+			if( self->mPrearrangeCallback )
+			{
+				self->mPrearrangeCallback( self, self->mCallbackUserData );
+			}
+
+			if (self->mList->getItemCount() != 0)
+			{
+				self->showList();
+			}
+		}
+		line_editor->selectAll();
+		line_editor->setTentative(FALSE);
+	}
+	else if (key == KEY_UP)
+	{
+		self->setCurrentByIndex(llmax(0, self->getCurrentIndex() - 1));
+		if (!self->mList->getVisible())
+		{
+			if( self->mPrearrangeCallback )
+			{
+				self->mPrearrangeCallback( self, self->mCallbackUserData );
+			}
+
+			if (self->mList->getItemCount() != 0)
+			{
+				self->showList();
+			}
+		}
+		line_editor->selectAll();
+		line_editor->setTentative(FALSE);
+	}
+	else
+	{
+		// RN: presumably text entry
+		self->updateSelection();
+	}
+}
+
+void LLComboBox::updateSelection()
+{
+	LLWString left_wstring = mTextEntry->getWText().substr(0, mTextEntry->getCursor());
+	// user-entered portion of string, based on assumption that any selected
+    // text was a result of auto-completion
+	LLWString user_wstring = mTextEntry->hasSelection() ? left_wstring : mTextEntry->getWText();
+	LLString full_string = mTextEntry->getText();
+
+	// go ahead and arrange drop down list on first typed character, even
+	// though we aren't showing it... some code relies on prearrange
+	// callback to populate content
+	if( mTextEntry->getWText().size() == 1 )
+	{
+		if (mPrearrangeCallback)
+		{
+			mPrearrangeCallback( this, mCallbackUserData );
+		}
+	}
+
+	if (mList->selectSimpleItem(full_string, FALSE))
+	{
+		mTextEntry->setTentative(FALSE);
+	}
+	else if (!mList->selectSimpleItemByPrefix(left_wstring, FALSE))
+	{
+		mList->deselectAllItems();
+		mTextEntry->setText(wstring_to_utf8str(user_wstring));
+		mTextEntry->setTentative(mTextEntryTentative);
+	}
+	else
+	{
+		LLWString selected_item = utf8str_to_wstring(mList->getSimpleSelectedItem());
+		LLWString wtext = left_wstring + selected_item.substr(left_wstring.size(), selected_item.size());
+		mTextEntry->setText(wstring_to_utf8str(wtext));
+		mTextEntry->setSelection(left_wstring.size(), mTextEntry->getWText().size());
+		mTextEntry->endSelection();
+		mTextEntry->setTentative(FALSE);
+	}
+}
+
+//static 
+void LLComboBox::onTextCommit(LLUICtrl* caller, void* user_data)
+{
+	LLComboBox* self = (LLComboBox*)user_data;
+	LLString text = self->mTextEntry->getText();
+	self->setSimple(text);
+	self->onCommit();
+	self->mTextEntry->selectAll();
+}
+
+void LLComboBox::setFocus(BOOL b)
+{
+	LLUICtrl::setFocus(b);
+
+	if (b)
+	{
+		mList->clearSearchString();
+	}
+}
+
+//============================================================================
+// LLCtrlListInterface functions
+
+S32 LLComboBox::getItemCount() const
+{
+	return mList->getItemCount();
+}
+
+void LLComboBox::addColumn(const LLSD& column, EAddPosition pos)
+{
+	mList->clearColumns();
+	mList->addColumn(column, pos);
+}
+
+void LLComboBox::clearColumns()
+{
+	mList->clearColumns();
+}
+
+void LLComboBox::setColumnLabel(const LLString& column, const LLString& label)
+{
+	mList->setColumnLabel(column, label);
+}
+
+LLScrollListItem* LLComboBox::addElement(const LLSD& value, EAddPosition pos, void* userdata)
+{
+	return mList->addElement(value, pos, userdata);
+}
+
+LLScrollListItem* LLComboBox::addSimpleElement(const LLString& value, EAddPosition pos, const LLSD& id)
+{
+	return mList->addSimpleElement(value, pos, id);
+}
+
+void LLComboBox::clearRows()
+{
+	mList->clearRows();
+}
+
+void LLComboBox::sortByColumn(LLString name, BOOL ascending)
+{
+}
+
+//============================================================================
+//LLCtrlSelectionInterface functions
+
+BOOL LLComboBox::setCurrentByID(const LLUUID& id)
+{
+	BOOL found = mList->selectByID( id );
+
+	if (found)
+	{
+		setLabel(mList->getSimpleSelectedItem());
+	}
+
+	return found;
+}
+
+LLUUID LLComboBox::getCurrentID()
+{
+	return mList->getStringUUIDSelectedItem();
+}
+BOOL LLComboBox::setSelectedByValue(LLSD value, BOOL selected)
+{
+	BOOL found = mList->setSelectedByValue(value, selected);
+	if (found)
+	{
+		setLabel(mList->getSimpleSelectedItem());
+	}
+	return found;
+}
+
+LLSD LLComboBox::getSimpleSelectedValue()
+{
+	return mList->getSimpleSelectedValue();
+}
+
+BOOL LLComboBox::isSelected(LLSD value)
+{
+	return mList->isSelected(value);
+}
+
+BOOL LLComboBox::operateOnSelection(EOperation op)
+{
+	if (op == OP_DELETE)
+	{
+		mList->deleteSelectedItems();
+		return TRUE;
+	}
+	return FALSE;
+}
+
+BOOL LLComboBox::operateOnAll(EOperation op)
+{
+	if (op == OP_DELETE)
+	{
+		clearRows();
+		return TRUE;
+	}
+	return FALSE;
+}
+
+//static 
+void LLComboBox::onListFocusLost(LLUICtrl* old_focus)
+{
+	// if focus is going to nothing (user hit ESC), take it back
+	LLComboBox* combo = (LLComboBox*)old_focus->getParent();
+	combo->hideList();
+	if (gFocusMgr.getKeyboardFocus() == NULL)
+	{
+		combo->focusFirstItem();
+	}
+}
diff --git a/indra/llui/llcombobox.h b/indra/llui/llcombobox.h
new file mode 100644
index 0000000000..1ec31ec1c0
--- /dev/null
+++ b/indra/llui/llcombobox.h
@@ -0,0 +1,178 @@
+/** 
+ * @file llcombobox.h
+ * @brief LLComboBox base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// A control that displays the name of the chosen item, which when clicked
+// shows a scrolling box of choices.
+
+#ifndef LL_LLCOMBOBOX_H
+#define LL_LLCOMBOBOX_H
+
+#include "llbutton.h"
+#include "lluictrl.h"
+#include "llctrlselectioninterface.h"
+#include "llimagegl.h"
+#include "llrect.h"
+
+// Classes
+
+class LLFontGL;
+class LLButton;
+class LLSquareButton;
+class LLScrollListCtrl;
+class LLLineEditor;
+class LLViewBorder;
+
+extern S32 LLCOMBOBOX_HEIGHT;
+extern S32 LLCOMBOBOX_WIDTH;
+
+class LLComboBox
+:	public LLUICtrl, public LLCtrlListInterface
+{
+public:
+	LLComboBox(
+		const LLString& name, 
+		const LLRect &rect,
+		const LLString& label,
+		void (*commit_callback)(LLUICtrl*, void*) = NULL,
+		void *callback_userdata = NULL,
+		S32 list_width = 0
+		);
+	virtual ~LLComboBox(); 
+
+	// LLView interface
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_COMBO_BOX; }
+	virtual LLString getWidgetTag() const { return LL_COMBO_BOX_TAG; }
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual void	draw();
+	virtual void	onFocusLost();
+
+	virtual void	setEnabled(BOOL enabled);
+
+	virtual BOOL	handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect);
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL	handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent);
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleRightMouseUp(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+
+	// LLUICtrl interface
+	virtual void	clear();					// select nothing
+	virtual void	onCommit();
+	virtual BOOL	acceptsTextInput() const		{ return mAllowTextEntry; }
+
+	virtual void	setFocus(BOOL b);
+
+	// Selects item by underlying LLSD value, using LLSD::asString() matching.  
+	// For simple items, this is just the name of the label.
+	virtual void	setValue(const LLSD& value );
+
+	// Gets underlying LLSD value for currently selected items.  For simple
+	// items, this is just the label.
+	virtual LLSD	getValue() const;
+
+	void			setAllowTextEntry(BOOL allow, S32 max_chars = 50, BOOL make_tentative = TRUE);
+	void			setTextEntry(const LLString& text);
+
+	void			add(const LLString& name, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE);	// add item "name" to menu
+	void			add(const LLString& name, const LLUUID& id, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE);
+	void			add(const LLString& name, void* userdata, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE);
+	void			add(const LLString& name, LLSD value, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE);
+	BOOL			remove( S32 index );	// remove item by index, return TRUE if found and removed
+	void			removeall() { clearRows(); }
+
+	void			sortByName(); // Sort the entries in the combobox by name
+
+	// Select current item by name using selectSimpleItem.  Returns FALSE if not found.
+	BOOL			setSimple(const LLString& name);
+	// Get name of current item. Returns an empty string if not found.
+	const LLString&	getSimple() const;
+	// Get contents of column x of selected row
+	const LLString& getSimpleSelectedItem(S32 column = 0) const;
+
+	// Sets the label, which doesn't have to exist in the label.
+	// This is probably a UI abuse.
+	void			setLabel(const LLString& name);
+
+	BOOL			remove(const LLString& name);	// remove item "name", return TRUE if found and removed
+	
+	BOOL			setCurrentByIndex( S32 index );
+	S32				getCurrentIndex() const;
+
+	//========================================================================
+	LLCtrlSelectionInterface* getSelectionInterface()	{ return (LLCtrlSelectionInterface*)this; };
+	LLCtrlListInterface* getListInterface()				{ return (LLCtrlListInterface*)this; };
+
+	// LLCtrlListInterface functions
+	// See llscrolllistctrl.h
+	virtual S32		getItemCount() const;
+	// Overwrites the default column (See LLScrollListCtrl for format)
+	virtual void 	addColumn(const LLSD& column, EAddPosition pos = ADD_BOTTOM);
+	virtual void 	clearColumns();
+	virtual void	setColumnLabel(const LLString& column, const LLString& label);
+	virtual LLScrollListItem* addElement(const LLSD& value, EAddPosition pos = ADD_BOTTOM, void* userdata = NULL);
+	virtual LLScrollListItem* addSimpleElement(const LLString& value, EAddPosition pos = ADD_BOTTOM, const LLSD& id = LLSD());
+	virtual void 	clearRows();
+	virtual void 	sortByColumn(LLString name, BOOL ascending);
+
+	// LLCtrlSelectionInterface functions
+	virtual BOOL	getCanSelect() const				{ return TRUE; }
+	virtual BOOL	selectFirstItem()					{ return setCurrentByIndex(0); }
+	virtual BOOL	selectNthItem( S32 index )			{ return setCurrentByIndex(index); }
+	virtual S32		getFirstSelectedIndex()				{ return getCurrentIndex(); }
+	virtual BOOL	setCurrentByID( const LLUUID& id );
+	virtual LLUUID	getCurrentID();				// LLUUID::null if no items in menu
+	virtual BOOL	setSelectedByValue(LLSD value, BOOL selected);
+	virtual LLSD	getSimpleSelectedValue();
+	virtual BOOL	isSelected(LLSD value);
+	virtual BOOL	operateOnSelection(EOperation op);
+	virtual BOOL	operateOnAll(EOperation op);
+
+	//========================================================================
+	
+	void*			getCurrentUserdata();
+
+	void			setPrearrangeCallback( void (*cb)(LLUICtrl*,void*) ) { mPrearrangeCallback = cb; }
+	void			setTextEntryCallback( void (*cb)(LLLineEditor*, void*) ) { mTextEntryCallback = cb; }
+
+	void			setButtonVisible(BOOL visible);
+
+	static void		onButtonClick(void *userdata);
+	static void		onItemSelected(LLUICtrl* item, void *userdata);
+	static void		onTopViewLost(LLView* old_focus);
+	static void		onMouseCaptureLost(LLMouseHandler* old_captor);
+	static void		onTextEntry(LLLineEditor* line_editor, void* user_data);
+	static void		onTextCommit(LLUICtrl* caller, void* user_data);
+
+	void			updateSelection();
+	void			showList();
+	void			hideList();
+
+	static void		onListFocusLost(LLUICtrl* old_focus);
+
+protected:
+	LLButton*			mButton;
+	LLScrollListCtrl*	mList;
+	LLViewBorder*		mBorder;
+	BOOL				mKeyboardFocusOnClick;
+	BOOL				mDrawButton;
+	LLLineEditor*		mTextEntry;
+	LLPointer<LLImageGL>	mArrowImage;
+	BOOL				mAllowTextEntry;
+	S32				mMaxChars;
+	BOOL				mTextEntryTentative;
+	void				(*mPrearrangeCallback)(LLUICtrl*,void*);
+	void				(*mTextEntryCallback)(LLLineEditor*, void*);
+	S32 mListWidth;	// width of pop-up list, 0 = use combobox width
+};
+
+#endif
diff --git a/indra/llui/llctrlselectioninterface.cpp b/indra/llui/llctrlselectioninterface.cpp
new file mode 100644
index 0000000000..a58fb88e75
--- /dev/null
+++ b/indra/llui/llctrlselectioninterface.cpp
@@ -0,0 +1,44 @@
+/** 

+ * @file llctrlselectioninterface.cpp

+ * @brief Programmatic selection of items in a list.

+ *

+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.

+ * $License$

+ */

+

+#include "llctrlselectioninterface.h"

+

+#include "llsd.h"

+

+// virtual

+LLCtrlSelectionInterface::~LLCtrlSelectionInterface()

+{ }

+

+BOOL LLCtrlSelectionInterface::selectByValue(LLSD value)

+{

+	return setSelectedByValue(value, TRUE);

+}

+

+BOOL LLCtrlSelectionInterface::deselectByValue(LLSD value)

+{ 

+	return setSelectedByValue(value, FALSE); 

+}

+

+

+// virtual

+LLCtrlListInterface::~LLCtrlListInterface()

+{ }

+

+LLScrollListItem* LLCtrlListInterface::addSimpleElement(const LLString& value)

+{

+	return addSimpleElement(value, ADD_BOTTOM, LLSD());

+}

+

+LLScrollListItem* LLCtrlListInterface::addSimpleElement(const LLString& value, EAddPosition pos)

+{

+	return addSimpleElement(value, pos, LLSD());

+}

+

+// virtual

+LLCtrlScrollInterface::~LLCtrlScrollInterface()

+{ }

diff --git a/indra/llui/llctrlselectioninterface.h b/indra/llui/llctrlselectioninterface.h
new file mode 100644
index 0000000000..4e2807e9a1
--- /dev/null
+++ b/indra/llui/llctrlselectioninterface.h
@@ -0,0 +1,84 @@
+/** 

+ * @file llctrlselectioninterface.h

+ * @brief Programmatic selection of items in a list.

+ *

+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.

+ * $License$

+ */

+

+#ifndef LLCTRLSELECTIONINTERFACE_H

+#define LLCTRLSELECTIONINTERFACE_H

+

+#include "stdtypes.h"

+#include "stdenums.h"

+#include "llstring.h"

+

+class LLSD;

+class LLUUID;

+class LLScrollListItem;

+

+class LLCtrlSelectionInterface

+{

+public:

+	virtual ~LLCtrlSelectionInterface();

+	

+	enum EOperation

+	{

+		OP_DELETE = 1,

+		OP_SELECT,

+		OP_DESELECT,

+	};

+

+	virtual BOOL	getCanSelect() const = 0;

+

+	virtual BOOL	selectFirstItem() = 0;

+	virtual BOOL	selectNthItem( S32 index ) = 0;

+

+	virtual S32		getFirstSelectedIndex() = 0;

+

+	// TomY TODO: Simply cast the UUIDs to LLSDs, using the selectByValue function

+	virtual BOOL	setCurrentByID( const LLUUID& id ) = 0;

+	virtual LLUUID	getCurrentID() = 0;

+

+			BOOL	selectByValue(LLSD value);

+			BOOL	deselectByValue(LLSD value);

+	virtual BOOL	setSelectedByValue(LLSD value, BOOL selected) = 0;

+	virtual LLSD	getSimpleSelectedValue() = 0;

+

+	virtual BOOL	isSelected(LLSD value) = 0;

+

+	virtual BOOL	operateOnSelection(EOperation op) = 0;

+	virtual BOOL	operateOnAll(EOperation op) = 0;

+};

+

+class LLCtrlListInterface : public LLCtrlSelectionInterface

+{

+public:

+	virtual ~LLCtrlListInterface();

+	

+	virtual S32 getItemCount() const = 0;

+	virtual void addColumn(const LLSD& column, EAddPosition pos = ADD_BOTTOM) = 0;

+	virtual void clearColumns() = 0;

+	virtual void setColumnLabel(const LLString& column, const LLString& label) = 0;

+	// TomY TODO: Document this

+	virtual LLScrollListItem* addElement(const LLSD& value, EAddPosition pos = ADD_BOTTOM, void* userdata = NULL) = 0;

+

+	LLScrollListItem* addSimpleElement(const LLString& value); // defaults to bottom

+	LLScrollListItem* addSimpleElement(const LLString& value, EAddPosition pos); // defaults to no LLSD() id

+	virtual LLScrollListItem* addSimpleElement(const LLString& value, EAddPosition pos, const LLSD& id) = 0;

+

+	virtual void clearRows() = 0;

+	virtual void sortByColumn(LLString name, BOOL ascending) = 0;

+};

+

+class LLCtrlScrollInterface

+{

+public:

+	virtual ~LLCtrlScrollInterface();

+	

+	virtual S32 getScrollPos() = 0;

+	virtual void setScrollPos( S32 pos ) = 0;

+	virtual void scrollToShowSelected() = 0;

+};

+

+#endif

diff --git a/indra/llui/lldraghandle.cpp b/indra/llui/lldraghandle.cpp
new file mode 100644
index 0000000000..a88fbb7744
--- /dev/null
+++ b/indra/llui/lldraghandle.cpp
@@ -0,0 +1,353 @@
+/** 
+ * @file lldraghandle.cpp
+ * @brief LLDragHandle base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// A widget for dragging a view around the screen using the mouse.
+
+#include "linden_common.h"
+
+#include "lldraghandle.h"
+
+#include "llmath.h"
+
+//#include "llviewerwindow.h"
+#include "llui.h"
+#include "llmenugl.h"
+#include "lltextbox.h"
+#include "llcontrol.h"
+#include "llresmgr.h"
+#include "llfontgl.h"
+#include "llwindow.h"
+#include "llfocusmgr.h"
+
+const S32 LEADING_PAD = 5;
+const S32 TITLE_PAD = 8;
+const S32 BORDER_PAD = 1;
+const S32 LEFT_PAD = BORDER_PAD + TITLE_PAD + LEADING_PAD;
+const S32 RIGHT_PAD = BORDER_PAD + 32; // HACK: space for close btn and minimize btn
+
+S32 LLDragHandle::sSnapMargin = 5;
+
+LLDragHandle::LLDragHandle( const LLString& name, const LLRect& rect, const LLString& title )
+:	LLView( name, rect, TRUE ),
+	mDragLastScreenX( 0 ),
+	mDragLastScreenY( 0 ),
+	mLastMouseScreenX( 0 ),
+	mLastMouseScreenY( 0 ),
+	mDragHighlightColor(	LLUI::sColorsGroup->getColor( "DefaultHighlightLight" ) ),
+	mDragShadowColor(		LLUI::sColorsGroup->getColor( "DefaultShadowDark" ) ),
+	mTitleBox( NULL ),
+	mMaxTitleWidth( 0 ),
+	mForeground( TRUE )
+{
+	sSnapMargin = LLUI::sConfigGroup->getS32("SnapMargin");
+
+	setSaveToXML(false);
+}
+
+void LLDragHandle::setTitleVisible(BOOL visible) 
+{ 
+	mTitleBox->setVisible(visible); 
+}
+
+LLDragHandleTop::LLDragHandleTop(const LLString& name, const LLRect &rect, const LLString& title)
+:	LLDragHandle(name, rect, title)
+{
+	setFollowsAll();
+	setTitle( title );
+}
+
+EWidgetType LLDragHandleTop::getWidgetType() const
+{
+	return WIDGET_TYPE_DRAG_HANDLE_TOP;
+}
+
+LLString LLDragHandleTop::getWidgetTag() const
+{
+	return LL_DRAG_HANDLE_TOP_TAG;
+}
+
+LLDragHandleLeft::LLDragHandleLeft(const LLString& name, const LLRect &rect, const LLString& title)
+:	LLDragHandle(name, rect, title)
+{
+	setFollowsAll();
+	setTitle( title );
+}
+
+EWidgetType LLDragHandleLeft::getWidgetType() const
+{
+	return WIDGET_TYPE_DRAG_HANDLE_LEFT;
+}
+
+LLString LLDragHandleLeft::getWidgetTag() const
+{
+	return LL_DRAG_HANDLE_LEFT_TAG;
+}
+
+void LLDragHandleTop::setTitle(const LLString& title)
+{
+	if( mTitleBox )
+	{
+		removeChild(mTitleBox);
+		delete mTitleBox;
+	}
+
+	LLString trimmed_title = title;
+	LLString::trim(trimmed_title);
+
+	const LLFontGL* font = gResMgr->getRes( LLFONT_SANSSERIF );
+	mTitleBox = new LLTextBox( "Drag Handle Title", mRect, trimmed_title, font );
+	mTitleBox->setFollows(FOLLOWS_TOP | FOLLOWS_LEFT | FOLLOWS_RIGHT);
+	reshapeTitleBox();
+	
+	// allow empty titles, as default behavior replaces them with title box name
+	if (trimmed_title.empty())
+	{
+		mTitleBox->setText(LLString::null);
+	}
+	addChild( mTitleBox );
+}
+
+
+const LLString& LLDragHandleTop::getTitle() const
+{
+	return mTitleBox->getText();
+}
+
+
+void LLDragHandleLeft::setTitle(const LLString& )
+{
+	if( mTitleBox )
+	{
+		removeChild(mTitleBox);
+		delete mTitleBox;
+	}
+
+	mTitleBox = NULL;
+
+	/* no title on left edge */
+}
+
+
+const LLString& LLDragHandleLeft::getTitle() const
+{
+	return LLString::null;
+}
+
+
+void LLDragHandleTop::draw()
+{
+	/* Disable lines.  Can drag anywhere in most windows.  JC
+	if( getVisible() && mEnabled && mForeground) 
+	{
+		const S32 BORDER_PAD = 2;
+		const S32 HPAD = 2;
+		const S32 VPAD = 2;
+		S32 left = BORDER_PAD + HPAD;
+		S32 top = mRect.getHeight() - 2 * VPAD;
+		S32 right = mRect.getWidth() - HPAD;
+//		S32 bottom = VPAD;
+
+		// draw lines for drag areas
+
+		const S32 LINE_SPACING = (DRAG_HANDLE_HEIGHT - 2 * VPAD) / 4;
+		S32 line = top - LINE_SPACING;
+
+		LLRect title_rect = mTitleBox->getRect();
+		S32 title_right = title_rect.mLeft + mTitleWidth;
+		BOOL show_right_side = title_right < mRect.getWidth();
+
+		for( S32 i=0; i<4; i++ )
+		{
+			gl_line_2d(left, line+1, title_rect.mLeft - LEADING_PAD, line+1, mDragHighlightColor);
+			if( show_right_side )
+			{
+				gl_line_2d(title_right, line+1, right, line+1, mDragHighlightColor);
+			}
+
+			gl_line_2d(left, line, title_rect.mLeft - LEADING_PAD, line, mDragShadowColor);
+			if( show_right_side )
+			{
+				gl_line_2d(title_right, line, right, line, mDragShadowColor);
+			}
+			line -= LINE_SPACING;
+		}
+	}
+	*/
+
+	// Colorize the text to match the frontmost state
+	if (mTitleBox)
+	{
+		mTitleBox->setEnabled(mForeground);
+	}
+
+	LLView::draw();
+}
+
+
+// assumes GL state is set for 2D
+void LLDragHandleLeft::draw()
+{
+	/* Disable lines.  Can drag anywhere in most windows. JC
+	if( getVisible() && mEnabled && mForeground ) 
+	{
+		const S32 BORDER_PAD = 2;
+//		const S32 HPAD = 2;
+		const S32 VPAD = 2;
+		const S32 LINE_SPACING = 3;
+
+		S32 left = BORDER_PAD + LINE_SPACING;
+		S32 top = mRect.getHeight() - 2 * VPAD;
+//		S32 right = mRect.getWidth() - HPAD;
+		S32 bottom = VPAD;
+ 
+		// draw lines for drag areas
+
+		// no titles yet
+		//LLRect title_rect = mTitleBox->getRect();
+		//S32 title_right = title_rect.mLeft + mTitleWidth;
+		//BOOL show_right_side = title_right < mRect.getWidth();
+
+		S32 line = left;
+		for( S32 i=0; i<4; i++ )
+		{
+			gl_line_2d(line, top, line, bottom, mDragHighlightColor);
+
+			gl_line_2d(line+1, top, line+1, bottom, mDragShadowColor);
+
+			line += LINE_SPACING;
+		}
+	}
+	*/
+
+	// Colorize the text to match the frontmost state
+	if (mTitleBox)
+	{
+		mTitleBox->setEnabled(mForeground);
+	}
+
+	LLView::draw();
+}
+
+void LLDragHandleTop::reshapeTitleBox()
+{
+	const LLFontGL* font = gResMgr->getRes( LLFONT_SANSSERIF );
+	S32 title_width = font->getWidth( mTitleBox->getText() ) + TITLE_PAD;
+	if (mMaxTitleWidth > 0)
+		title_width = llmin(title_width, mMaxTitleWidth);
+	S32 title_height = llround(font->getLineHeight());
+	LLRect title_rect;
+	title_rect.setLeftTopAndSize( 
+		LEFT_PAD, 
+		mRect.getHeight() - BORDER_PAD,
+		mRect.getWidth() - LEFT_PAD - RIGHT_PAD,
+		title_height);
+
+	mTitleBox->setRect( title_rect );
+}
+
+void LLDragHandleTop::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	LLView::reshape(width, height, called_from_parent);
+	reshapeTitleBox();
+}
+
+void LLDragHandleLeft::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	LLView::reshape(width, height, called_from_parent);
+}
+
+//-------------------------------------------------------------
+// UI event handling
+//-------------------------------------------------------------
+
+BOOL LLDragHandle::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	// Route future Mouse messages here preemptively.  (Release on mouse up.)
+	// No handler needed for focus lost since this clas has no state that depends on it.
+	gFocusMgr.setMouseCapture(this, NULL );
+
+	localPointToScreen(x, y, &mDragLastScreenX, &mDragLastScreenY);
+	mLastMouseScreenX = mDragLastScreenX;
+	mLastMouseScreenY = mDragLastScreenY;
+
+	// Note: don't pass on to children
+	return TRUE;
+}
+
+
+BOOL LLDragHandle::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		// Release the mouse
+		gFocusMgr.setMouseCapture( NULL, NULL );
+	}
+
+	// Note: don't pass on to children
+	return TRUE;
+}
+
+
+BOOL LLDragHandle::handleHover(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// We only handle the click if the click both started and ended within us
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		S32 screen_x;
+		S32 screen_y;
+		localPointToScreen(x, y, &screen_x, &screen_y);
+
+		// Resize the parent
+		S32 delta_x = screen_x - mDragLastScreenX;
+		S32 delta_y = screen_y - mDragLastScreenY;
+		getParent()->translate(delta_x, delta_y);
+		S32 pre_snap_x = getParent()->getRect().mLeft;
+		S32 pre_snap_y = getParent()->getRect().mBottom;
+		mDragLastScreenX = screen_x;
+		mDragLastScreenY = screen_y;
+
+		LLRect new_rect;
+		LLCoordGL mouse_dir;
+		// use hysteresis on mouse motion to preserve user intent when mouse stops moving
+		mouse_dir.mX = (screen_x == mLastMouseScreenX) ? mLastMouseDir.mX : screen_x - mLastMouseScreenX;
+		mouse_dir.mY = (screen_y == mLastMouseScreenY) ? mLastMouseDir.mY : screen_y - mLastMouseScreenY;
+		mLastMouseDir = mouse_dir;
+		mLastMouseScreenX = screen_x;
+		mLastMouseScreenY = screen_y;
+
+		LLView* snap_view = getParent()->findSnapRect(new_rect, mouse_dir, SNAP_PARENT_AND_SIBLINGS, sSnapMargin);
+
+		getParent()->snappedTo(snap_view);
+		delta_x = new_rect.mLeft - pre_snap_x;
+		delta_y = new_rect.mBottom - pre_snap_y;
+		getParent()->translate(delta_x, delta_y);
+		mDragLastScreenX += delta_x;
+		mDragLastScreenY += delta_y;
+
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" <<llendl;		
+		handled = TRUE;
+	}
+	else if( getVisible() )
+	{
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)" << llendl;		
+		handled = TRUE;
+	}
+
+	// Note: don't pass on to children
+
+	return handled;
+}
+
+void LLDragHandle::setValue(const LLSD& value)
+{
+	setTitle(value.asString());
+}
diff --git a/indra/llui/lldraghandle.h b/indra/llui/lldraghandle.h
new file mode 100644
index 0000000000..557c01cec6
--- /dev/null
+++ b/indra/llui/lldraghandle.h
@@ -0,0 +1,98 @@
+/** 
+ * @file lldraghandle.h
+ * @brief LLDragHandle base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// A widget for dragging a view around the screen using the mouse.
+
+#ifndef LL_DRAGHANDLE_H
+#define LL_DRAGHANDLE_H
+
+#include "llview.h"
+#include "v4color.h"
+#include "llrect.h"
+#include "llcoord.h"
+
+class LLTextBox;
+
+class LLDragHandle : public LLView
+{
+public:
+	LLDragHandle(const LLString& name, const LLRect& rect, const LLString& title );
+
+	virtual void setValue(const LLSD& value);
+
+	void			setForeground(BOOL b)		{ mForeground = b; }
+	void			setMaxTitleWidth(S32 max_width) {mMaxTitleWidth = llmin(max_width, mMaxTitleWidth); }
+	void			setTitleVisible(BOOL visible);
+
+	virtual void	setTitle( const LLString& title ) = 0;
+	virtual const LLString&	getTitle() const = 0;
+	virtual void	draw() = 0;
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE) = 0;
+
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+
+protected:
+	S32				mDragLastScreenX;
+	S32				mDragLastScreenY;
+	S32				mLastMouseScreenX;
+	S32				mLastMouseScreenY;
+	LLCoordGL		mLastMouseDir;
+	LLColor4		mDragHighlightColor;
+	LLColor4		mDragShadowColor;
+	LLTextBox*		mTitleBox;
+	S32				mMaxTitleWidth;
+	BOOL			mForeground;
+
+	// Pixels near the edge to snap floaters.
+	static S32		sSnapMargin;
+};
+
+
+// Use this one for traditional top-of-window draggers
+class LLDragHandleTop
+: public LLDragHandle
+{
+public:
+	LLDragHandleTop(const LLString& name, const LLRect& rect, const LLString& title );
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual void	setTitle( const LLString& title );
+	virtual const LLString& getTitle() const;
+	virtual void	draw();
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+private:
+	void	reshapeTitleBox();
+};
+
+
+// Use this for left-side, vertical text draggers
+class LLDragHandleLeft
+: public LLDragHandle
+{
+public:
+	LLDragHandleLeft(const LLString& name, const LLRect& rect, const LLString& title );
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual void	setTitle( const LLString& title );
+	virtual const LLString& getTitle() const;
+	virtual void	draw();
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+};
+
+const S32 DRAG_HANDLE_HEIGHT = 16;
+const S32 DRAG_HANDLE_WIDTH = 16;
+
+#endif  // LL_DRAGHANDLE_H
diff --git a/indra/llui/lleditmenuhandler.cpp b/indra/llui/lleditmenuhandler.cpp
new file mode 100644
index 0000000000..656eaff563
--- /dev/null
+++ b/indra/llui/lleditmenuhandler.cpp
@@ -0,0 +1,107 @@
+/** 
+* @file lleditmenuhandler.cpp
+* @authors Aaron Yonas, James Cook
+*
+* Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+* $License$
+*/
+
+#include "stdtypes.h"
+
+#include "lleditmenuhandler.h"
+
+LLEditMenuHandler* gEditMenuHandler = NULL;
+
+// virtual
+LLEditMenuHandler::~LLEditMenuHandler()
+{ }
+
+// virtual
+void LLEditMenuHandler::undo()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canUndo()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::redo()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canRedo()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::cut()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canCut()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::copy()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canCopy()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::paste()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canPaste()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::doDelete()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canDoDelete()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::selectAll()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canSelectAll()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::deselect()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canDeselect()
+{
+	return FALSE;
+}
+
+// virtual
+void LLEditMenuHandler::duplicate()
+{ }
+
+// virtual
+BOOL LLEditMenuHandler::canDuplicate()
+{
+	return FALSE;
+}
diff --git a/indra/llui/lleditmenuhandler.h b/indra/llui/lleditmenuhandler.h
new file mode 100644
index 0000000000..3f49f2c6e8
--- /dev/null
+++ b/indra/llui/lleditmenuhandler.h
@@ -0,0 +1,50 @@
+/** 
+* @file lleditmenuhandler.h
+* @authors Aaron Yonas, James Cook
+*
+* Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+* $License$
+*/
+
+#ifndef LLEDITMENUHANDLER_H
+#define LLEDITMENUHANDLER_H
+
+// Interface used by menu system for plug-in hotkey/menu handling
+class LLEditMenuHandler
+{
+public:
+	// this is needed even though this is just an interface class.
+	virtual ~LLEditMenuHandler();
+	
+	virtual void	undo();
+	virtual BOOL	canUndo();
+	
+	virtual void	redo();
+	virtual BOOL	canRedo();
+	
+	virtual void	cut();
+	virtual BOOL	canCut();
+	
+	virtual void	copy();
+	virtual BOOL	canCopy();
+	
+	virtual void	paste();
+	virtual BOOL	canPaste();
+	
+	// "delete" is a keyword
+	virtual void	doDelete();
+	virtual BOOL	canDoDelete();
+	
+	virtual void	selectAll();
+	virtual BOOL	canSelectAll();
+	
+	virtual void	deselect();
+	virtual BOOL	canDeselect();
+	
+	virtual void	duplicate();
+	virtual BOOL	canDuplicate();
+};
+
+extern LLEditMenuHandler* gEditMenuHandler;
+
+#endif
diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
new file mode 100644
index 0000000000..3f9139fe86
--- /dev/null
+++ b/indra/llui/llfloater.cpp
@@ -0,0 +1,2933 @@
+/** 
+ * @file llfloater.cpp
+ * @brief LLFloater base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Floating "windows" within the GL display, like the inventory floater,
+// mini-map floater, etc.
+
+#include "linden_common.h"
+
+#include "llfloater.h"
+
+#include "llfocusmgr.h"
+
+#include "lluictrlfactory.h"
+#include "llbutton.h"
+#include "llcheckboxctrl.h"
+#include "lldraghandle.h"
+#include "llfocusmgr.h"
+#include "llresizebar.h"
+#include "llresizehandle.h"
+#include "llkeyboard.h"
+#include "llmenugl.h"	// MENU_BAR_HEIGHT
+#include "lltextbox.h"
+#include "llresmgr.h"
+#include "llui.h"
+#include "llviewborder.h"
+#include "llwindow.h"
+#include "llstl.h"
+#include "llcontrol.h"
+#include "lltabcontainer.h"
+#include "v2math.h"
+
+extern BOOL gNoRender;
+
+const S32 MINIMIZED_WIDTH = 160;
+const S32 CLOSE_BOX_FROM_TOP = 1;
+
+LLString	LLFloater::sButtonActiveImageNames[BUTTON_COUNT] = 
+{
+	"UIImgBtnCloseActiveUUID",		//BUTTON_CLOSE
+	"UIImgBtnRestoreActiveUUID",	//BUTTON_RESTORE
+	"UIImgBtnMinimizeActiveUUID",	//BUTTON_MINIMIZE
+	"UIImgBtnTearOffActiveUUID",	//BUTTON_TEAR_OFF
+	"UIImgBtnCloseActiveUUID",		//BUTTON_EDIT
+};
+
+LLString	LLFloater::sButtonInactiveImageNames[BUTTON_COUNT] = 
+{
+	"UIImgBtnCloseInactiveUUID",	//BUTTON_CLOSE
+	"UIImgBtnRestoreInactiveUUID",	//BUTTON_RESTORE
+	"UIImgBtnMinimizeInactiveUUID",	//BUTTON_MINIMIZE
+	"UIImgBtnTearOffInactiveUUID",	//BUTTON_TEAR_OFF
+	"UIImgBtnCloseInactiveUUID",	//BUTTON_EDIT
+};
+
+LLString	LLFloater::sButtonPressedImageNames[BUTTON_COUNT] = 
+{
+	"UIImgBtnClosePressedUUID",		//BUTTON_CLOSE
+	"UIImgBtnRestorePressedUUID",	//BUTTON_RESTORE
+	"UIImgBtnMinimizePressedUUID",	//BUTTON_MINIMIZE
+	"UIImgBtnTearOffPressedUUID",	//BUTTON_TEAR_OFF
+	"UIImgBtnClosePressedUUID",		//BUTTON_EDIT
+};
+
+LLString	LLFloater::sButtonNames[BUTTON_COUNT] = 
+{
+	"llfloater_close_btn",	//BUTTON_CLOSE
+	"llfloater_restore_btn",	//BUTTON_RESTORE
+	"llfloater_minimize_btn",	//BUTTON_MINIMIZE
+	"llfloater_tear_off_btn",	//BUTTON_TEAR_OFF
+	"llfloater_edit_btn",		//BUTTON_EDIT
+};
+
+LLString	LLFloater::sButtonToolTips[BUTTON_COUNT] = 
+{
+#ifdef LL_DARWIN
+	"Close (Cmd-W)",	//BUTTON_CLOSE
+#else
+	"Close (Ctrl-W)",	//BUTTON_CLOSE
+#endif
+	"Restore",	//BUTTON_RESTORE
+	"Minimize",	//BUTTON_MINIMIZE
+	"Tear Off",	//BUTTON_TEAR_OFF
+	"Edit",		//BUTTON_EDIT
+};
+
+LLFloater::click_callback LLFloater::sButtonCallbacks[BUTTON_COUNT] =
+{
+	LLFloater::onClickClose,	//BUTTON_CLOSE
+	LLFloater::onClickMinimize, //BUTTON_RESTORE
+	LLFloater::onClickMinimize, //BUTTON_MINIMIZE
+	LLFloater::onClickTearOff,	//BUTTON_TEAR_OFF
+	LLFloater::onClickEdit,	//BUTTON_EDIT
+};
+
+LLMultiFloater* LLFloater::sHostp = NULL;
+BOOL			LLFloater::sEditModeEnabled;
+LLFloater::handle_map_t	LLFloater::sFloaterMap;
+
+LLFloaterView* gFloaterView = NULL;
+
+LLFloater::LLFloater() 
+{
+	// automatically take focus when opened
+	mAutoFocus = TRUE;
+	for (S32 i = 0; i < BUTTON_COUNT; i++)
+	{
+		mButtonsEnabled[i] = FALSE;
+		mButtons[i] = NULL;
+	}
+	mDragHandle = NULL;
+}
+
+LLFloater::LLFloater(const LLString& name)
+:	LLPanel(name)
+{
+	for (S32 i = 0; i < BUTTON_COUNT; i++)
+	{
+		mButtonsEnabled[i] = FALSE;
+		mButtons[i] = NULL;
+	}
+
+	LLString title; // null string
+	// automatically take focus when opened
+	mAutoFocus = TRUE;
+	init(title, FALSE, DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT, FALSE, TRUE, TRUE); // defaults
+}
+
+
+LLFloater::LLFloater(const LLString& name, const LLRect& rect, const LLString& title, 
+	BOOL resizable, 
+	S32 min_width, 
+	S32 min_height,
+	BOOL drag_on_left,
+	BOOL minimizable,
+	BOOL close_btn,
+	BOOL bordered)
+:	LLPanel(name, rect, bordered)
+{
+	for (S32 i = 0; i < BUTTON_COUNT; i++)
+	{
+		mButtonsEnabled[i] = FALSE;
+		mButtons[i] = NULL;
+	}
+	// automatically take focus when opened
+	mAutoFocus = TRUE;
+	init( title, resizable, min_width, min_height, drag_on_left, minimizable, close_btn);
+}
+
+LLFloater::LLFloater(const LLString& name, const LLString& rect_control, const LLString& title, 
+	BOOL resizable, 
+	S32 min_width, 
+	S32 min_height,
+	BOOL drag_on_left,
+	BOOL minimizable,
+	BOOL close_btn,
+	BOOL bordered)
+:	LLPanel(name, rect_control, bordered)
+{
+	for (S32 i = 0; i < BUTTON_COUNT; i++)
+	{
+		mButtonsEnabled[i] = FALSE;
+		mButtons[i] = NULL;
+	}
+	// automatically take focus when opened
+	mAutoFocus = TRUE;
+	init( title, resizable, min_width, min_height, drag_on_left, minimizable, close_btn);
+}
+
+
+// Note: Floaters constructed from XML call init() twice!
+void LLFloater::init(const LLString& title,
+					 BOOL resizable, S32 min_width, S32 min_height,
+					 BOOL drag_on_left, BOOL minimizable, BOOL close_btn)
+{
+	// Init function can be called more than once, so clear out old data.
+	for (S32 i = 0; i < BUTTON_COUNT; i++)
+	{
+		mButtonsEnabled[i] = FALSE;
+		if (mButtons[i] != NULL)
+		{
+			removeChild(mButtons[i]);
+			delete mButtons[i];
+			mButtons[i] = NULL;
+		}
+	}
+	mButtonScale = 1.f;
+
+	LLPanel::deleteAllChildren();
+	//sjb: HACK! we had a border which was just deleted, so re-create it
+	if (mBorder != NULL)
+	{
+		addBorder();
+	}
+
+	// chrome floaters don't take focus at all
+	mIsFocusRoot = !getIsChrome();
+
+	// Reset cached pointers
+	mDragHandle = NULL;
+	for (S32 i = 0; i < 4; i++) 
+	{
+		mResizeBar[i] = NULL;
+		mResizeHandle[i] = NULL;
+	}
+	mCanTearOff = TRUE;
+	mEditing = FALSE;
+
+	// Clicks stop here.
+	setMouseOpaque(TRUE);
+
+	mFirstLook = TRUE;
+	mForeground = FALSE;
+	mDragOnLeft = drag_on_left == TRUE;
+
+	// Floaters always draw their background, unlike every other panel.
+	setBackgroundVisible(TRUE);
+
+	// Floaters start not minimized.  When minimized, they save their
+	// prior rectangle to be used on restore.
+	mMinimized = FALSE;
+	mPreviousRect.set(0,0,0,0);
+	
+	S32 close_pad;			// space to the right of close box
+	S32 close_box_size;		// For layout purposes, how big is the close box?
+	if (close_btn)
+	{
+		close_box_size = LLFLOATER_CLOSE_BOX_SIZE;
+		close_pad = 0;
+	}
+	else
+	{
+		close_box_size = 0;
+		close_pad = 0;
+	}
+
+	S32 minimize_box_size;
+	S32 minimize_pad;
+	if (minimizable && !drag_on_left)
+	{
+		minimize_box_size = LLFLOATER_CLOSE_BOX_SIZE;
+		minimize_pad = 0;
+	}
+	else
+	{
+		minimize_box_size = 0;
+		minimize_pad = 0;
+	}
+
+	// Drag Handle
+	// Add first so it's in the background.
+//	const S32 drag_pad = 2;
+	LLRect drag_handle_rect;
+	if (!drag_on_left)
+	{
+		drag_handle_rect.set( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+
+		/*
+		drag_handle_rect.setLeftTopAndSize(
+			0, mRect.getHeight(),
+			mRect.getWidth() 
+				- LLPANEL_BORDER_WIDTH 
+				- drag_pad
+				- minimize_box_size - minimize_pad 
+				- close_box_size - close_pad,
+			DRAG_HANDLE_HEIGHT);
+			*/
+		mDragHandle = new LLDragHandleTop( "Drag Handle", drag_handle_rect, title );
+	}
+	else
+	{
+		drag_handle_rect.setOriginAndSize(
+			0, 0,
+			DRAG_HANDLE_WIDTH,
+			mRect.getHeight() - LLPANEL_BORDER_WIDTH - close_box_size);
+		mDragHandle = new LLDragHandleLeft("drag", drag_handle_rect, title );
+	}
+	mDragHandle->setSaveToXML(false);
+	addChild(mDragHandle);
+
+	// Resize Handle
+	mResizable = resizable;
+	mMinWidth = min_width;
+	mMinHeight = min_height;
+
+	if( mResizable )
+	{
+		// Resize bars (sides)
+		const S32 RESIZE_BAR_THICKNESS = 3;
+		mResizeBar[0] = new LLResizeBar( 
+			"resizebar_left",
+			LLRect( 0, mRect.getHeight(), RESIZE_BAR_THICKNESS, 0), 
+			min_width, min_height, LLResizeBar::LEFT );
+		mResizeBar[0]->setSaveToXML(false);
+		addChild( mResizeBar[0] );
+
+		mResizeBar[1] = new LLResizeBar( 
+			"resizebar_top",
+			LLRect( 0, mRect.getHeight(), mRect.getWidth(), mRect.getHeight() - RESIZE_BAR_THICKNESS), 
+			min_width, min_height, LLResizeBar::TOP );
+		mResizeBar[1]->setSaveToXML(false);
+		addChild( mResizeBar[1] );
+
+		mResizeBar[2] = new LLResizeBar( 
+			"resizebar_right",
+			LLRect( mRect.getWidth() - RESIZE_BAR_THICKNESS, mRect.getHeight(), mRect.getWidth(), 0), 
+			min_width, min_height, LLResizeBar::RIGHT );
+		mResizeBar[2]->setSaveToXML(false);
+		addChild( mResizeBar[2] );
+
+		mResizeBar[3] = new LLResizeBar( 
+			"resizebar_bottom",
+			LLRect( 0, RESIZE_BAR_THICKNESS, mRect.getWidth(), 0), 
+			min_width, min_height, LLResizeBar::BOTTOM );
+		mResizeBar[3]->setSaveToXML(false);
+		addChild( mResizeBar[3] );
+
+
+		// Resize handles (corners)
+		mResizeHandle[0] = new LLResizeHandle( 
+			"Resize Handle",
+			LLRect( mRect.getWidth() - RESIZE_HANDLE_WIDTH, RESIZE_HANDLE_HEIGHT, mRect.getWidth(), 0),
+			min_width,
+			min_height,
+			LLResizeHandle::RIGHT_BOTTOM);
+		mResizeHandle[0]->setSaveToXML(false);
+		addChild(mResizeHandle[0]);
+
+		mResizeHandle[1] = new LLResizeHandle( "resize", 
+			LLRect( mRect.getWidth() - RESIZE_HANDLE_WIDTH, mRect.getHeight(), mRect.getWidth(), mRect.getHeight() - RESIZE_HANDLE_HEIGHT),
+			min_width,
+			min_height,
+			LLResizeHandle::RIGHT_TOP );
+		mResizeHandle[1]->setSaveToXML(false);
+		addChild(mResizeHandle[1]);
+		
+		mResizeHandle[2] = new LLResizeHandle( "resize", 
+			LLRect( 0, RESIZE_HANDLE_HEIGHT, RESIZE_HANDLE_WIDTH, 0 ),
+			min_width,
+			min_height,
+			LLResizeHandle::LEFT_BOTTOM );
+		mResizeHandle[2]->setSaveToXML(false);
+		addChild(mResizeHandle[2]);
+
+		mResizeHandle[3] = new LLResizeHandle( "resize", 
+			LLRect( 0, mRect.getHeight(), RESIZE_HANDLE_WIDTH, mRect.getHeight() - RESIZE_HANDLE_HEIGHT ),
+			min_width,
+			min_height,
+			LLResizeHandle::LEFT_TOP );
+		mResizeHandle[3]->setSaveToXML(false);
+		addChild(mResizeHandle[3]);
+	}
+	else
+	{
+		mResizeBar[0]	= NULL;
+		mResizeBar[1]	= NULL;
+		mResizeBar[2]	= NULL;
+		mResizeBar[3]	= NULL;
+
+		mResizeHandle[0] = NULL;
+		mResizeHandle[1] = NULL;
+		mResizeHandle[2] = NULL;
+		mResizeHandle[3] = NULL;
+	}
+
+	// Close button.
+	if (close_btn)
+	{
+		mButtonsEnabled[BUTTON_CLOSE] = TRUE;
+	}
+
+	// Minimize button only for top draggers
+	if ( !drag_on_left && minimizable )
+	{
+		mButtonsEnabled[BUTTON_MINIMIZE] = TRUE;
+	}
+
+	buildButtons();
+
+	// JC - Don't do this here, because many floaters first construct themselves,
+	// then show themselves.  Put it in setVisibleAndFrontmost.
+	// make_ui_sound("UISndWindowOpen");
+
+	// RN: floaters are created in the invisible state	
+	setVisible(FALSE);
+
+	// add self to handle->floater map
+	sFloaterMap[mViewHandle] = this;
+
+	if (!getParent())
+	{
+		gFloaterView->addChild(this);
+	}
+}
+
+// virtual
+LLFloater::~LLFloater()
+{
+	control_map_t::iterator itor;
+	for (itor = mFloaterControls.begin(); itor != mFloaterControls.end(); ++itor)
+	{
+		delete itor->second;
+	}
+	mFloaterControls.clear();
+
+	//// am I not hosted by another floater?
+	//if (mHostHandle.isDead())
+	//{
+	//	LLFloaterView* parent = (LLFloaterView*) getParent();
+
+	//	if( parent )
+	//	{
+	//		parent->removeChild( this );
+	//	}
+	//}
+
+	// Just in case we might still have focus here, release it.
+	releaseFocus();
+
+	// This is important so that floaters with persistent rects (i.e., those
+	// created with rect control rather than an LLRect) are restored in their
+	// correct, non-minimized positions.
+	setMinimized( FALSE );
+
+	sFloaterMap.erase(mViewHandle);
+
+	delete mDragHandle;
+	for (S32 i = 0; i < 4; i++) 
+	{
+		delete mResizeBar[i];
+		delete mResizeHandle[i];
+	}
+}
+
+// virtual
+EWidgetType LLFloater::getWidgetType() const
+{
+	return WIDGET_TYPE_FLOATER;
+}
+
+// virtual
+LLString LLFloater::getWidgetTag() const
+{
+	return LL_FLOATER_TAG;
+}
+
+void LLFloater::destroy()
+{
+	die();	
+}
+
+void LLFloater::setVisible( BOOL visible )
+{
+	LLPanel::setVisible(visible);
+	if( visible && mFirstLook )
+	{
+		mFirstLook = FALSE;
+	}
+
+	if( !visible )
+	{
+		if( gFocusMgr.childIsTopView( this ) )
+		{
+			gFocusMgr.setTopView(NULL, NULL);
+		}
+
+		if( gFocusMgr.childHasMouseCapture( this ) )
+		{
+			gFocusMgr.setMouseCapture(NULL, NULL);
+		}
+	}
+
+	for(handle_set_iter_t dependent_it = mDependents.begin();
+		dependent_it != mDependents.end(); )
+	{
+		LLFloater* floaterp = LLFloater::getFloaterByHandle(*dependent_it);
+
+		if (floaterp)
+		{
+			floaterp->setVisible(visible);
+		}
+		++dependent_it;
+	}
+}
+
+LLView*	LLFloater::getRootMostFastFrameView()
+{
+	// trying to render a background floater in a fast frame, abort!!!
+	//if (!isFrontmost())
+	//{
+	//	gViewerWindow->finishFastFrame();
+	//}
+
+	return LLView::getRootMostFastFrameView();
+}
+
+void LLFloater::open()
+{
+	//RN: for now, we don't allow rehosting from one multifloater to another
+	// just need to fix the bugs
+	LLMultiFloater* hostp = getHost();
+	if (sHostp != NULL && hostp == NULL)
+	{
+		// needs a host
+		sHostp->addFloater(this, TRUE);
+	}
+	else if (hostp != NULL)
+	{
+		// already hosted
+		hostp->showFloater(this);
+	}
+	else
+	{
+		setMinimized(FALSE);
+		setVisibleAndFrontmost(mAutoFocus);
+	}
+
+	if (mSoundFlags != SILENT)
+	{
+		if (!getVisible() || isMinimized())
+		{
+			make_ui_sound("UISndWindowOpen");
+		}
+	}
+}
+
+void LLFloater::close(bool app_quitting)
+{
+	// Always unminimize before trying to close.
+	// Most of the time the user will never see this state.
+	setMinimized(FALSE);
+
+	if (canClose())
+	{
+		if (getHost())
+		{
+			((LLMultiFloater*)getHost())->removeFloater(this);
+		}
+
+		if (mSoundFlags != SILENT
+			&& getVisible()
+			&& !app_quitting)
+		{
+			make_ui_sound("UISndWindowClose");
+		}
+
+		// now close dependent floater
+		for(handle_set_iter_t dependent_it = mDependents.begin();
+			dependent_it != mDependents.end(); )
+		{
+			
+			LLFloater* floaterp = LLFloater::getFloaterByHandle(*dependent_it);
+			if (floaterp)
+			{
+				++dependent_it;
+				floaterp->close();
+			}
+			else
+			{
+				mDependents.erase(dependent_it++);
+			}
+		}
+		
+		cleanupHandles();
+		gFocusMgr.clearLastFocusForGroup(this);
+
+		// Do this early, so UI controls will commit before the
+		// window is taken down.
+		releaseFocus();
+
+		// give focus to dependee floater if it exists, and we had focus first
+		if (isDependent())
+		{
+			LLFloater* dependee = LLFloater::getFloaterByHandle(mDependeeHandle);
+			if (dependee && !dependee->isDead())
+			{
+				dependee->setFocus(TRUE);
+			}
+		}
+
+		// Let floater do cleanup.
+		onClose(app_quitting);
+	}
+}
+
+
+void LLFloater::releaseFocus()
+{
+	if( gFocusMgr.childIsTopView( this ) )
+	{
+		gFocusMgr.setTopView(NULL, NULL);
+	}
+
+	if( gFocusMgr.childHasKeyboardFocus( this ) )
+	{
+		gFocusMgr.setKeyboardFocus(NULL, NULL);
+	}
+
+	if( gFocusMgr.childHasMouseCapture( this ) )
+	{
+		gFocusMgr.setMouseCapture(NULL, NULL);
+	}
+}
+
+
+void LLFloater::setResizeLimits( S32 min_width, S32 min_height )
+{
+	mMinWidth = min_width;
+	mMinHeight = min_height;
+
+	for( S32 i = 0; i < 4; i++ )
+	{
+		if( mResizeBar[i] )
+		{
+			mResizeBar[i]->setResizeLimits( min_width, min_height );
+		}
+		if( mResizeHandle[i] )
+		{
+			mResizeHandle[i]->setResizeLimits( min_width, min_height );
+		}
+	}
+}
+
+
+void LLFloater::center()
+{
+	if(getHost())
+	{
+		// hosted floaters can't move
+		return;
+	}
+	const LLRect &window = gFloaterView->getRect();
+
+	S32 left   = window.mLeft + (window.getWidth() - mRect.getWidth()) / 2;
+	S32 bottom = window.mBottom + (window.getHeight() - mRect.getHeight()) / 2;
+
+	translate( left - mRect.mLeft, bottom - mRect.mBottom );
+}
+
+void LLFloater::applyRectControl()
+{
+	if (!mRectControl.empty())
+	{
+		const LLRect& rect = LLUI::sConfigGroup->getRect(mRectControl);
+		translate( rect.mLeft - mRect.mLeft, rect.mBottom - mRect.mBottom);
+		if (mResizable)
+		{
+			reshape(llmax(mMinWidth, rect.getWidth()), llmax(mMinHeight, rect.getHeight()));
+		}
+	}
+}
+
+void LLFloater::setTitle( const LLString& title )
+{
+	if (gNoRender)
+	{
+		return;
+	}
+	mDragHandle->setTitle( title );
+}
+
+const LLString& LLFloater::getTitle() const
+{
+	return mDragHandle ? mDragHandle->getTitle() : LLString::null;
+}
+
+void LLFloater::translate(S32 x, S32 y)
+{
+	LLView::translate(x, y);
+
+	if (x != 0 || y != 0)
+	{
+		for(handle_set_iter_t dependent_it = mDependents.begin();
+			dependent_it != mDependents.end(); ++dependent_it)
+		{
+			LLFloater* floaterp = LLFloater::getFloaterByHandle(*dependent_it);
+			// is a dependent snapped to us?
+			if (floaterp && floaterp->getSnapTarget() == mViewHandle)
+			{
+				floaterp->translate(x, y);
+			}
+		}
+	}
+}
+
+BOOL LLFloater::canSnapTo(LLView* other_view)
+{
+	if (other_view && other_view != getParent())
+	{
+		LLFloater* other_floaterp = (LLFloater*)other_view;
+		
+		if (other_floaterp->getSnapTarget() == mViewHandle && mDependents.find(other_floaterp->getHandle()) != mDependents.end())
+		{
+			// this is a dependent that is already snapped to us, so don't snap back to it
+			return FALSE;
+		}
+	}
+
+	return LLView::canSnapTo(other_view);
+}
+
+void LLFloater::snappedTo(LLView* snap_view)
+{
+	if (!snap_view || snap_view == getParent())
+	{
+		clearSnapTarget();
+	}
+	else
+	{
+		//RN: assume it's a floater as it must be a sibling to our parent floater
+		LLFloater* floaterp = (LLFloater*)snap_view;
+		
+		setSnapTarget(floaterp->getHandle());
+	}
+}
+
+void LLFloater::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	S32 old_width = mRect.getWidth();
+	S32 old_height = mRect.getHeight();
+
+	LLView::reshape(width, height, called_from_parent);
+
+	if (width != old_width || height != old_height)
+	{
+		// gather all snapped dependents
+		for(handle_set_iter_t dependent_it = mDependents.begin();
+			dependent_it != mDependents.end(); ++dependent_it)
+		{
+			LLFloater* floaterp = LLFloater::getFloaterByHandle(*dependent_it);
+			// is a dependent snapped to us?
+			if (floaterp && floaterp->getSnapTarget() == mViewHandle)
+			{
+				S32 delta_x = 0;
+				S32 delta_y = 0;
+				// check to see if it snapped to right or top
+				LLRect floater_rect = floaterp->getRect();
+				if (floater_rect.mLeft - mRect.mLeft >= old_width ||
+					floater_rect.mRight == mRect.mLeft + old_width)
+				{
+					// was snapped directly onto right side or aligned with it
+					delta_x += width - old_width;
+				}
+				if (floater_rect.mBottom - mRect.mBottom >= old_height ||
+					floater_rect.mTop == mRect.mBottom + old_height)
+				{
+					// was snapped directly onto top side or aligned with it
+					delta_y += height - old_height;
+				}
+
+				floaterp->translate(delta_x, delta_y);
+			}
+		}
+	}
+}
+
+void LLFloater::setMinimized(BOOL minimize)
+{
+	if (minimize == mMinimized) return;
+
+	if (minimize)
+	{
+		mMinimized = TRUE;
+
+		mPreviousRect = mRect;
+
+		reshape( MINIMIZED_WIDTH, LLFLOATER_HEADER_SIZE, TRUE);
+
+		S32 left, bottom;
+		gFloaterView->getMinimizePosition(&left, &bottom);
+		setOrigin( left, bottom );
+
+		if (mButtonsEnabled[BUTTON_MINIMIZE])
+		{
+			mButtonsEnabled[BUTTON_MINIMIZE] = FALSE;
+			mButtonsEnabled[BUTTON_RESTORE] = TRUE;
+		}
+
+		mMinimizedHiddenChildren.clear();
+		// hide all children
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			if (!viewp->getVisible())
+			{
+				mMinimizedHiddenChildren.push_back(viewp);
+			}
+			viewp->setVisible(FALSE);
+		}
+
+		// except the special controls
+		if (mDragHandle)
+		{
+			mDragHandle->setVisible(TRUE);
+		}
+
+		setBorderVisible(TRUE);
+
+		for(handle_set_iter_t dependent_it = mDependents.begin();
+			dependent_it != mDependents.end(); )
+		{
+			LLFloater* floaterp = LLFloater::getFloaterByHandle(*dependent_it);
+			if (floaterp)
+			{
+				floaterp->setVisible(FALSE);
+			}
+			++dependent_it;
+		}
+
+		// Lose keyboard focus when minimized
+		releaseFocus();
+	}
+	else
+	{
+		reshape( mPreviousRect.getWidth(), mPreviousRect.getHeight(), TRUE );
+		setOrigin( mPreviousRect.mLeft, mPreviousRect.mBottom );
+
+		mMinimized = FALSE;
+
+		if (mButtonsEnabled[BUTTON_RESTORE])
+		{
+			mButtonsEnabled[BUTTON_MINIMIZE] = TRUE;
+			mButtonsEnabled[BUTTON_RESTORE] = FALSE;
+		}
+
+		// show all children
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			viewp->setVisible(TRUE);
+		}
+
+		std::vector<LLView*>::iterator itor = mMinimizedHiddenChildren.begin();
+		while (itor != mMinimizedHiddenChildren.end())
+		{
+			(*itor)->setVisible(FALSE);
+			++itor;
+		}
+		mMinimizedHiddenChildren.clear();
+
+		// show dependent floater
+		for(handle_set_iter_t dependent_it = mDependents.begin();
+			dependent_it != mDependents.end(); )
+		{
+			LLFloater* floaterp = LLFloater::getFloaterByHandle(*dependent_it);
+			if (floaterp)
+			{
+				floaterp->setVisible(TRUE);
+			}
+			++dependent_it;
+		}
+	}
+	make_ui_sound("UISndWindowClose");
+	updateButtons();
+}
+
+void LLFloater::setFocus( BOOL b )
+{
+	if (b && getIsChrome())
+	{
+		return;
+	}
+	LLUICtrl* last_focus = gFocusMgr.getLastFocusForGroup(this);
+	// a descendent already has focus
+	BOOL child_had_focus = gFocusMgr.childHasKeyboardFocus(this);
+
+	// give focus to first valid descendent
+	LLPanel::setFocus(b);
+
+	if (b)
+	{
+		// only push focused floaters to front of stack if not in midst of ctrl-tab cycle
+		if (!getHost() && !((LLFloaterView*)getParent())->getCycleMode())
+		{
+			if (!isFrontmost())
+			{
+				setFrontmost();
+			}
+		}
+
+		// when getting focus, delegate to last descendent which had focus
+		if (last_focus && !child_had_focus && 
+			last_focus->isInEnabledChain() &&
+			last_focus->isInVisibleChain())
+		{
+			// FIXME: should handle case where focus doesn't stick
+			last_focus->setFocus(TRUE);
+		}
+	}
+}
+
+void LLFloater::setIsChrome(BOOL is_chrome)
+{
+	// chrome floaters don't take focus at all
+	if (is_chrome)
+	{
+		// remove focus if we're changing to chrome
+		setFocus(FALSE);
+		// can't Ctrl-Tab to "chrome" floaters
+		mIsFocusRoot = FALSE;
+	}
+	
+	// no titles displayed on "chrome" floaters
+	mDragHandle->setTitleVisible(!is_chrome);
+	
+	LLPanel::setIsChrome(is_chrome);
+}
+
+// Change the draw style to account for the foreground state.
+void LLFloater::setForeground(BOOL front)
+{
+	if (front != mForeground)
+	{
+		mForeground = front;
+		mDragHandle->setForeground( front );
+
+		if (!front)
+		{
+			releaseFocus();
+		}
+
+		setBackgroundOpaque( front ); 
+	}
+}
+
+void LLFloater::cleanupHandles()
+{
+	// remove handles to non-existent dependents
+	for(handle_set_iter_t dependent_it = mDependents.begin();
+		dependent_it != mDependents.end(); )
+	{
+		LLFloater* floaterp = LLFloater::getFloaterByHandle(*dependent_it);
+		if (!floaterp)
+		{
+			mDependents.erase(dependent_it++);
+		}
+		else
+		{
+			++dependent_it;
+		}
+	}
+}
+
+void LLFloater::setHost(LLMultiFloater* host)
+{
+	if (mHostHandle.isDead() && host)
+	{
+		// make buttons smaller for hosted windows to differentiate from parent
+		mButtonScale = 0.9f;
+
+		// add tear off button
+		if (mCanTearOff)
+		{
+			mButtonsEnabled[BUTTON_TEAR_OFF] = TRUE;
+		}
+
+		mIsFocusRoot = FALSE;
+	}
+	else if (!mHostHandle.isDead() && !host)
+	{
+		mButtonScale = 1.f;
+		mIsFocusRoot = TRUE;
+		//mButtonsEnabled[BUTTON_TEAR_OFF] = FALSE;
+	}
+	updateButtons();
+	if (host)
+	{
+		mHostHandle = host->getHandle();
+		mLastHostHandle = host->getHandle();
+	}
+	else
+	{
+		mHostHandle.markDead();
+	}
+}
+
+void LLFloater::moveResizeHandleToFront()
+{
+	// 0 is the bottom  right
+	if( mResizeHandle[0] )
+	{
+		sendChildToFront(mResizeHandle[0]);
+	}
+}
+
+BOOL LLFloater::isFrontmost()
+{
+	return gFloaterView && gFloaterView->getFrontmost() == this && getVisible();
+}
+
+void LLFloater::addDependentFloater(LLFloater* floaterp, BOOL reposition)
+{
+	mDependents.insert(floaterp->getHandle());
+	floaterp->mDependeeHandle = getHandle();
+
+	if (reposition)
+	{
+		floaterp->setRect(gFloaterView->findNeighboringPosition(this, floaterp));
+		floaterp->setSnapTarget(mViewHandle);
+	}
+	gFloaterView->adjustToFitScreen(floaterp, FALSE);
+	if (floaterp->isFrontmost())
+	{
+		// make sure to bring self and sibling floaters to front
+		gFloaterView->bringToFront(floaterp);
+	}
+}
+
+void LLFloater::addDependentFloater(LLViewHandle dependent, BOOL reposition)
+{
+	LLFloater* dependent_floaterp = LLFloater::getFloaterByHandle(dependent);
+	if(dependent_floaterp)
+	{
+		addDependentFloater(dependent_floaterp, reposition);
+	}
+}
+
+void LLFloater::removeDependentFloater(LLFloater* floaterp)
+{
+	mDependents.erase(floaterp->getHandle());
+	floaterp->mDependeeHandle = LLViewHandle::sDeadHandle;
+}
+
+// virtual
+BOOL LLFloater::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	if( mMinimized )
+	{
+		// Offer the click to the close button.
+		// Any other click = restore
+		if( mButtonsEnabled[BUTTON_CLOSE] )
+		{
+			S32 local_x = x - mButtons[BUTTON_CLOSE]->getRect().mLeft;
+			S32 local_y = y - mButtons[BUTTON_CLOSE]->getRect().mBottom;
+
+			if (mButtons[BUTTON_CLOSE]->pointInView(local_x, local_y)
+				&& mButtons[BUTTON_CLOSE]->handleMouseDown(local_x, local_y, mask))
+			{
+				// close button handled it, return
+				return TRUE;
+			}
+		}
+
+		// restore
+		bringToFront( x, y );
+		return TRUE;
+	}
+	else
+	{
+		bringToFront( x, y );
+		return LLPanel::handleMouseDown( x, y, mask );
+	}
+}
+
+// virtual
+BOOL LLFloater::handleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL was_minimized = mMinimized;
+	bringToFront( x, y );
+	return was_minimized || LLPanel::handleRightMouseDown( x, y, mask );
+}
+
+
+// virtual
+BOOL LLFloater::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	BOOL was_minimized = mMinimized;
+	setMinimized(FALSE);
+	return was_minimized || LLPanel::handleDoubleClick(x, y, mask);
+}
+
+void LLFloater::bringToFront( S32 x, S32 y )
+{
+	if (getVisible() && pointInView(x, y))
+	{
+		LLMultiFloater* hostp = getHost();
+		if (hostp)
+		{
+			hostp->showFloater(this);
+		}
+		else
+		{
+			LLFloaterView* parent = (LLFloaterView*) getParent();
+			if (parent)
+			{
+				parent->bringToFront( this );
+			}
+		}
+	}
+}
+
+
+// virtual
+void LLFloater::setVisibleAndFrontmost(BOOL take_focus)
+{
+	setVisible(TRUE);
+	setFrontmost(take_focus);
+}
+
+void LLFloater::setFrontmost(BOOL take_focus)
+{
+	LLMultiFloater* hostp = getHost();
+	if (hostp)
+	{
+		// this will bring the host floater to the front and select
+		// the appropriate panel
+		hostp->showFloater(this);
+	}
+	else
+	{
+		// there are more than one floater view
+		// so we need to query our parent directly
+		((LLFloaterView*)getParent())->bringToFront(this, take_focus);
+	}
+}
+
+// static
+LLFloater*	LLFloater::getFloaterByHandle(LLViewHandle handle)
+{
+	LLFloater* floater = NULL;
+	if (sFloaterMap.count(handle))
+	{
+		floater = sFloaterMap[handle];
+	}
+	if (floater && !floater->isDead())
+	{
+		return floater;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+//static
+void LLFloater::setEditModeEnabled(BOOL enable)
+{
+	if (enable != sEditModeEnabled)
+	{
+		S32 count = 0;
+		std::map<LLViewHandle, LLFloater*>::iterator iter;
+		for(iter = sFloaterMap.begin(); iter != sFloaterMap.end(); ++iter)
+		{
+			LLFloater* floater = iter->second;
+			if (!floater->isDead())
+			{
+				iter->second->mButtonsEnabled[BUTTON_EDIT] = enable;
+				iter->second->updateButtons();
+			}
+			count++;
+		}
+	}
+
+	sEditModeEnabled = enable;
+}
+
+//static
+BOOL LLFloater::getEditModeEnabled()
+{
+	return sEditModeEnabled;
+}
+
+// static
+void LLFloater::onClickMinimize(void *userdata)
+{
+	LLFloater* self = (LLFloater*) userdata;
+	if (!self) return;
+
+	self->setMinimized( !self->isMinimized() );
+}
+
+void LLFloater::onClickTearOff(void *userdata)
+{
+	LLFloater* self = (LLFloater*) userdata;
+	if (!self) return;
+
+	LLMultiFloater* host_floater = self->getHost();
+	if (host_floater) //Tear off
+	{
+		LLRect new_rect;
+		host_floater->removeFloater(self);
+		// reparent to floater view
+		gFloaterView->addChild(self);
+
+		new_rect.setLeftTopAndSize(host_floater->getRect().mLeft + 5, host_floater->getRect().mTop - LLFLOATER_HEADER_SIZE - 5, self->mRect.getWidth(), self->mRect.getHeight());
+
+		self->open();
+		self->setRect(new_rect);
+		gFloaterView->adjustToFitScreen(self, FALSE);
+		self->setCanDrag(TRUE);		
+		self->setCanResize(TRUE);		
+		self->setCanMinimize(TRUE);
+	}
+	else  //Attach to parent.
+	{
+		LLMultiFloater* new_host = (LLMultiFloater*)LLFloater::getFloaterByHandle(self->mLastHostHandle);
+		if (new_host)
+		{
+			new_host->showFloater(self);
+		}
+	}
+}
+
+// static
+void LLFloater::onClickEdit(void *userdata)
+{
+	LLFloater* self = (LLFloater*) userdata;
+	if (!self) return;
+
+	self->mEditing = self->mEditing ? FALSE : TRUE;
+}
+
+// static
+void LLFloater::closeByMenu( void* userdata )
+{
+	LLFloater* self = (LLFloater*) userdata;
+	if (!self || self->getHost()) return;
+
+	LLFloaterView* parent = (LLFloaterView*) self->getParent();
+
+	// grab focus status before close just in case floater is deleted
+	BOOL has_focus = gFocusMgr.childHasKeyboardFocus(self);
+	self->close();
+
+	// if this floater used to have focus and now nothing took focus
+	// give it to next floater (to allow closing multiple windows via keyboard in rapid succession)
+	if (has_focus && gFocusMgr.getKeyboardFocus() == NULL)
+	{
+		parent->focusFrontFloater();
+	}
+
+}
+
+
+// static
+void LLFloater::onClickClose( void* userdata )
+{
+	LLFloater* self = (LLFloater*) userdata;
+	if (!self) return;
+
+	self->close();
+}
+
+
+// virtual
+void LLFloater::draw()
+{
+	if( getVisible() )
+	{
+		// draw background
+		if( mBgVisible )
+		{
+			S32 left = LLPANEL_BORDER_WIDTH;
+			S32 top = mRect.getHeight() - LLPANEL_BORDER_WIDTH;
+			S32 right = mRect.getWidth() - LLPANEL_BORDER_WIDTH;
+			S32 bottom = LLPANEL_BORDER_WIDTH;
+
+			LLColor4 shadow_color = LLUI::sColorsGroup->getColor("ColorDropShadow");
+			F32 shadow_offset = (F32)LLUI::sConfigGroup->getS32("DropShadowFloater");
+			if (!mBgOpaque)
+			{
+				shadow_offset *= 0.2f;
+				shadow_color.mV[VALPHA] *= 0.5f;
+			}
+			gl_drop_shadow(left, top, right, bottom, 
+				shadow_color, 
+				llround(shadow_offset));
+
+			// No transparent windows in simple UI
+			if (mBgOpaque)
+			{
+				gl_rect_2d( left, top, right, bottom, mBgColorOpaque );
+			}
+			else
+			{
+				gl_rect_2d( left, top, right, bottom, mBgColorAlpha );
+			}
+
+			if(gFocusMgr.childHasKeyboardFocus(this) && !getIsChrome() && !getTitle().empty())
+			{
+				// draw highlight on title bar to indicate focus.  RDW
+				const LLFontGL* font = gResMgr->getRes( LLFONT_SANSSERIF );
+				LLRect r = getRect();
+				gl_rect_2d_offset_local(0, r.getHeight(), r.getWidth(), r.getHeight() - (S32)font->getLineHeight() - 1, 
+					LLUI::sColorsGroup->getColor("TitleBarFocusColor"), 0, TRUE);
+			}
+		}
+
+		if( mDefaultBtn)
+		{
+			if (gFocusMgr.childHasKeyboardFocus( this ) && mDefaultBtn->getEnabled())
+			{
+				LLUICtrl* focus_ctrl = gFocusMgr.getKeyboardFocus();
+				// is this button a direct descendent and not a nested widget (e.g. checkbox)?
+				BOOL focus_is_child_button = focus_ctrl->getWidgetType() == WIDGET_TYPE_BUTTON && focus_ctrl->getParent() == this;
+				// only enable default button when current focus is not a button
+				mDefaultBtn->setBorderEnabled(!focus_is_child_button);
+			}
+			else
+			{
+				mDefaultBtn->setBorderEnabled(FALSE);
+			}
+		}
+
+		// draw children
+		LLView* focused_child = gFocusMgr.getKeyboardFocus();
+		BOOL focused_child_visible = FALSE;
+		if (focused_child && focused_child->getParent() == this)
+		{
+			focused_child_visible = focused_child->getVisible();
+			focused_child->setVisible(FALSE);
+		}
+
+		LLView::draw();
+
+		if( mBgVisible )
+		{
+			// add in a border to improve spacialized visual aclarity ;)
+			// use lines instead of gl_rect_2d so we can round the edges as per james' recommendation
+			LLUI::setLineWidth(1.5f);
+			LLColor4 outlineColor = gFocusMgr.childHasKeyboardFocus(this) ? LLUI::sColorsGroup->getColor("FloaterFocusBorderColor") : LLUI::sColorsGroup->getColor("FloaterUnfocusBorderColor");
+			gl_rect_2d_offset_local(0, mRect.getHeight() + 1, mRect.getWidth() + 1, 0, outlineColor, -LLPANEL_BORDER_WIDTH, FALSE);
+			LLUI::setLineWidth(1.f);
+		}
+	
+		if (focused_child_visible)
+		{
+			focused_child->setVisible(TRUE);
+		}
+		drawChild(focused_child);
+	}
+}
+
+// virtual
+void LLFloater::onClose(bool app_quitting)
+{
+	destroy();
+}
+
+// virtual
+BOOL LLFloater::canClose()
+{
+	return TRUE;
+}
+
+// virtual
+BOOL LLFloater::canSaveAs()
+{
+	return FALSE;
+}
+
+// virtual
+void LLFloater::saveAs()
+{
+}
+
+void	LLFloater::setCanMinimize(BOOL can_minimize)
+{
+	// removing minimize/restore button programmatically,
+	// go ahead and uniminimize floater
+	if (!can_minimize)
+	{
+		setMinimized(FALSE);
+	}
+
+	if (can_minimize)
+	{
+		if (isMinimized())
+		{
+			mButtonsEnabled[BUTTON_MINIMIZE] = FALSE;
+			mButtonsEnabled[BUTTON_RESTORE] = TRUE;
+		}
+		else
+		{
+			mButtonsEnabled[BUTTON_MINIMIZE] = TRUE;
+			mButtonsEnabled[BUTTON_RESTORE] = FALSE;
+		}
+	}
+	else
+	{
+		mButtonsEnabled[BUTTON_MINIMIZE] = FALSE;
+		mButtonsEnabled[BUTTON_RESTORE] = FALSE;
+	}
+
+	updateButtons();
+}
+
+void	LLFloater::setCanClose(BOOL can_close)
+{
+	mButtonsEnabled[BUTTON_CLOSE] = can_close;
+
+	updateButtons();
+}
+
+void	LLFloater::setCanTearOff(BOOL can_tear_off)
+{
+	mCanTearOff = can_tear_off;
+	mButtonsEnabled[BUTTON_TEAR_OFF] = mCanTearOff && !mHostHandle.isDead();
+
+	updateButtons();
+}
+
+
+void	LLFloater::setCanResize(BOOL can_resize)
+{
+	if (mResizable && !can_resize)
+	{
+		removeChild(mResizeBar[0]);
+		removeChild(mResizeBar[1]);
+		removeChild(mResizeBar[2]);
+		removeChild(mResizeBar[3]);
+		removeChild(mResizeHandle[0]);
+		removeChild(mResizeHandle[1]);
+		removeChild(mResizeHandle[2]);
+		removeChild(mResizeHandle[3]);
+		delete mResizeBar[0];
+		delete mResizeBar[1];
+		delete mResizeBar[2];
+		delete mResizeBar[3];
+		delete mResizeHandle[0];
+		delete mResizeHandle[1];
+		delete mResizeHandle[2];
+		mResizeHandle[3] = NULL;
+		mResizeBar[0] = NULL;
+		mResizeBar[1] = NULL;
+		mResizeBar[2] = NULL;
+		mResizeBar[3] = NULL;
+		mResizeHandle[0] = NULL;
+		mResizeHandle[1] = NULL;
+		mResizeHandle[2] = NULL;
+		mResizeHandle[3] = NULL;
+	}
+	else if (!mResizable && can_resize)
+	{
+		// Resize bars (sides)
+		const S32 RESIZE_BAR_THICKNESS = 3;
+		mResizeBar[0] = new LLResizeBar( 
+			"resizebar_left",
+			LLRect( 0, mRect.getHeight(), RESIZE_BAR_THICKNESS, 0), 
+			mMinWidth, mMinHeight, LLResizeBar::LEFT );
+		mResizeBar[0]->setSaveToXML(false);
+		addChild( mResizeBar[0] );
+
+		mResizeBar[1] = new LLResizeBar( 
+			"resizebar_top",
+			LLRect( 0, mRect.getHeight(), mRect.getWidth(), mRect.getHeight() - RESIZE_BAR_THICKNESS), 
+			mMinWidth, mMinHeight, LLResizeBar::TOP );
+		mResizeBar[1]->setSaveToXML(false);
+		addChild( mResizeBar[1] );
+
+		mResizeBar[2] = new LLResizeBar( 
+			"resizebar_right",
+			LLRect( mRect.getWidth() - RESIZE_BAR_THICKNESS, mRect.getHeight(), mRect.getWidth(), 0), 
+			mMinWidth, mMinHeight, LLResizeBar::RIGHT );
+		mResizeBar[2]->setSaveToXML(false);
+		addChild( mResizeBar[2] );
+
+		mResizeBar[3] = new LLResizeBar( 
+			"resizebar_bottom",
+			LLRect( 0, RESIZE_BAR_THICKNESS, mRect.getWidth(), 0), 
+			mMinWidth, mMinHeight, LLResizeBar::BOTTOM );
+		mResizeBar[3]->setSaveToXML(false);
+		addChild( mResizeBar[3] );
+
+
+		// Resize handles (corners)
+		mResizeHandle[0] = new LLResizeHandle( 
+			"Resize Handle",
+			LLRect( mRect.getWidth() - RESIZE_HANDLE_WIDTH, RESIZE_HANDLE_HEIGHT, mRect.getWidth(), 0),
+			mMinWidth,
+			mMinHeight,
+			LLResizeHandle::RIGHT_BOTTOM);
+		mResizeHandle[0]->setSaveToXML(false);
+		addChild(mResizeHandle[0]);
+
+		mResizeHandle[1] = new LLResizeHandle( "resize", 
+			LLRect( mRect.getWidth() - RESIZE_HANDLE_WIDTH, mRect.getHeight(), mRect.getWidth(), mRect.getHeight() - RESIZE_HANDLE_HEIGHT),
+			mMinWidth,
+			mMinHeight,
+			LLResizeHandle::RIGHT_TOP );
+		mResizeHandle[1]->setSaveToXML(false);
+		addChild(mResizeHandle[1]);
+		
+		mResizeHandle[2] = new LLResizeHandle( "resize", 
+			LLRect( 0, RESIZE_HANDLE_HEIGHT, RESIZE_HANDLE_WIDTH, 0 ),
+			mMinWidth,
+			mMinHeight,
+			LLResizeHandle::LEFT_BOTTOM );
+		mResizeHandle[2]->setSaveToXML(false);
+		addChild(mResizeHandle[2]);
+
+		mResizeHandle[3] = new LLResizeHandle( "resize", 
+			LLRect( 0, mRect.getHeight(), RESIZE_HANDLE_WIDTH, mRect.getHeight() - RESIZE_HANDLE_HEIGHT ),
+			mMinWidth,
+			mMinHeight,
+			LLResizeHandle::LEFT_TOP );
+		mResizeHandle[3]->setSaveToXML(false);
+		addChild(mResizeHandle[3]);
+	}
+	mResizable = can_resize;
+}
+
+void LLFloater::setCanDrag(BOOL can_drag)
+{
+	// if we delete drag handle, we no longer have access to the floater's title
+	// so just enable/disable it
+	if (!can_drag && mDragHandle->getEnabled())
+	{
+		mDragHandle->setEnabled(FALSE);
+	}
+	else if (can_drag && !mDragHandle->getEnabled())
+	{
+		mDragHandle->setEnabled(TRUE);
+	}
+}
+
+void LLFloater::updateButtons()
+{
+	S32 button_count = 0;
+	for (S32 i = 0; i < BUTTON_COUNT; i++)
+	{
+		if (mButtonsEnabled[i])
+		{
+			button_count++;
+
+			LLRect btn_rect;
+			if (mDragOnLeft)
+			{
+				btn_rect.setLeftTopAndSize(
+					LLPANEL_BORDER_WIDTH,
+					mRect.getHeight() - CLOSE_BOX_FROM_TOP - (LLFLOATER_CLOSE_BOX_SIZE + 1) * button_count,
+					llround((F32)LLFLOATER_CLOSE_BOX_SIZE * mButtonScale),
+					llround((F32)LLFLOATER_CLOSE_BOX_SIZE * mButtonScale));
+			}
+			else
+			{
+				btn_rect.setLeftTopAndSize(
+					mRect.getWidth() - LLPANEL_BORDER_WIDTH - (LLFLOATER_CLOSE_BOX_SIZE + 1) * button_count,
+					mRect.getHeight() - CLOSE_BOX_FROM_TOP,
+					llround((F32)LLFLOATER_CLOSE_BOX_SIZE * mButtonScale),
+					llround((F32)LLFLOATER_CLOSE_BOX_SIZE * mButtonScale));
+			}
+
+			mButtons[i]->setRect(btn_rect);
+			mButtons[i]->setVisible(TRUE);
+			mButtons[i]->setEnabled(TRUE);
+			// the restore button should have a tab stop so that it takes action when you Ctrl-Tab to a minimized floater
+			mButtons[i]->setTabStop(i == BUTTON_RESTORE);
+		}
+		else if (mButtons[i])
+		{
+			mButtons[i]->setVisible(FALSE);
+			mButtons[i]->setEnabled(FALSE);
+		}
+	}
+
+	mDragHandle->setMaxTitleWidth(mRect.getWidth() - (button_count * (LLFLOATER_CLOSE_BOX_SIZE + 1)));
+}
+
+void LLFloater::buildButtons()
+{
+	for (S32 i = 0; i < BUTTON_COUNT; i++)
+	{
+		LLRect btn_rect;
+		if (mDragOnLeft)
+		{
+			btn_rect.setLeftTopAndSize(
+				LLPANEL_BORDER_WIDTH,
+				mRect.getHeight() - CLOSE_BOX_FROM_TOP - (LLFLOATER_CLOSE_BOX_SIZE + 1) * (i + 1),
+				llround(LLFLOATER_CLOSE_BOX_SIZE * mButtonScale),
+				llround(LLFLOATER_CLOSE_BOX_SIZE * mButtonScale));
+		}
+		else
+		{
+			btn_rect.setLeftTopAndSize(
+				mRect.getWidth() - LLPANEL_BORDER_WIDTH - (LLFLOATER_CLOSE_BOX_SIZE + 1) * (i + 1),
+				mRect.getHeight() - CLOSE_BOX_FROM_TOP,
+				llround(LLFLOATER_CLOSE_BOX_SIZE * mButtonScale),
+				llround(LLFLOATER_CLOSE_BOX_SIZE * mButtonScale));
+		}
+
+		LLButton* buttonp = new LLButton(
+			sButtonNames[i],
+			btn_rect,
+			sButtonActiveImageNames[i],
+			sButtonPressedImageNames[i],
+			"",
+			sButtonCallbacks[i],
+			this,
+			LLFontGL::sSansSerif);
+
+		buttonp->setTabStop(FALSE);
+		buttonp->setFollowsTop();
+		buttonp->setFollowsRight();
+		buttonp->setToolTip( sButtonToolTips[i] );
+		buttonp->setImageColor(LLUI::sColorsGroup->getColor("FloaterButtonImageColor"));
+		buttonp->setHoverImages(sButtonPressedImageNames[i],
+								sButtonPressedImageNames[i]);
+		buttonp->setScaleImage(TRUE);
+		buttonp->setSaveToXML(false);
+		addChild(buttonp);
+		mButtons[i] = buttonp;
+	}
+
+	updateButtons();
+}
+
+/////////////////////////////////////////////////////
+// LLFloaterView
+
+LLFloaterView::LLFloaterView( const LLString& name, const LLRect& rect )
+:	LLUICtrl( name, rect, FALSE, NULL, NULL, FOLLOWS_ALL ),
+	mFocusCycleMode(FALSE),
+	mSnapOffsetBottom(0)
+{
+	setTabStop(FALSE);
+	resetStartingFloaterPosition();
+}
+
+EWidgetType LLFloaterView::getWidgetType() const
+{
+	return WIDGET_TYPE_FLOATER_VIEW;
+}
+
+LLString LLFloaterView::getWidgetTag() const
+{
+	return LL_FLOATER_VIEW_TAG;
+}
+
+// By default, adjust vertical.
+void LLFloaterView::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	reshape(width, height, called_from_parent, ADJUST_VERTICAL_YES);
+}
+
+// When reshaping this view, make the floaters follow their closest edge.
+void LLFloaterView::reshape(S32 width, S32 height, BOOL called_from_parent, BOOL adjust_vertical)
+{
+	S32 old_width = mRect.getWidth();
+	S32 old_height = mRect.getHeight();
+
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		LLFloater* floaterp = (LLFloater*)viewp;
+		if (floaterp->isDependent())
+		{
+			// dependents use same follow flags as their "dependee"
+			continue;
+		}
+		LLRect r = floaterp->getRect();
+
+		// Compute absolute distance from each edge of screen
+		S32 left_offset = llabs(r.mLeft - 0);
+		S32 right_offset = llabs(old_width - r.mRight);
+
+		S32 top_offset = llabs(old_height - r.mTop);
+		S32 bottom_offset = llabs(r.mBottom - 0);
+
+		// Make if follow the edge it is closest to
+		U32 follow_flags = 0x0;
+
+		if (left_offset < right_offset)
+		{
+			follow_flags |= FOLLOWS_LEFT;
+		}
+		else
+		{
+			follow_flags |= FOLLOWS_RIGHT;
+		}
+
+		// "No vertical adjustment" usually means that the bottom of the view
+		// has been pushed up or down.  Hence we want the floaters to follow
+		// the top.
+		if (!adjust_vertical)
+		{
+			follow_flags |= FOLLOWS_TOP;
+		}
+		else if (top_offset < bottom_offset)
+		{
+			follow_flags |= FOLLOWS_TOP;
+		}
+		else
+		{
+			follow_flags |= FOLLOWS_BOTTOM;
+		}
+
+		floaterp->setFollows(follow_flags);
+
+		//RN: all dependent floaters copy follow behavior of "parent"
+		for(LLFloater::handle_set_iter_t dependent_it = floaterp->mDependents.begin();
+			dependent_it != floaterp->mDependents.end(); ++dependent_it)
+		{
+			LLFloater* dependent_floaterp = getFloaterByHandle(*dependent_it);
+			if (dependent_floaterp)
+			{
+				dependent_floaterp->setFollows(follow_flags);
+			}
+		}
+	}
+
+	LLView::reshape(width, height, called_from_parent);
+}
+
+
+void LLFloaterView::restoreAll()
+{
+	// make sure all subwindows aren't minimized
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLFloater* floaterp = (LLFloater*)*child_it;
+		floaterp->setMinimized(FALSE);
+	}
+
+	//FIXME: make sure dependents are restored
+
+	// children then deleted by default view constructor
+}
+
+
+void LLFloaterView::getNewFloaterPosition(S32* left,S32* top)
+{
+	// Workaround: mRect may change between when this object is created and the first time it is used.
+	static BOOL first = TRUE;
+	if( first )
+	{
+		resetStartingFloaterPosition();
+		first = FALSE;
+	}
+	
+	const S32 FLOATER_PAD = 16;
+	LLCoordWindow window_size;
+	getWindow()->getSize(&window_size);
+	LLRect full_window(0, window_size.mY, window_size.mX, 0);
+	LLRect floater_creation_rect(
+		160,
+		full_window.getHeight() - 2 * MENU_BAR_HEIGHT,
+		full_window.getWidth() * 2 / 3,
+		130 );
+	floater_creation_rect.stretch( -FLOATER_PAD );
+
+	*left = mNextLeft;
+	*top = mNextTop;
+
+	const S32 STEP = 25;
+	S32 bottom = floater_creation_rect.mBottom + 2 * STEP;
+	S32 right = floater_creation_rect.mRight - 4 * STEP;
+
+	mNextTop -= STEP;
+	mNextLeft += STEP;
+
+	if( (mNextTop < bottom ) || (mNextLeft > right) )
+	{
+		mColumn++;
+		mNextTop = floater_creation_rect.mTop;
+		mNextLeft = STEP * mColumn;
+
+		if( (mNextTop < bottom) || (mNextLeft > right) )
+		{
+			// Advancing the column didn't work, so start back at the beginning
+			resetStartingFloaterPosition();
+		}
+	}
+}
+
+void LLFloaterView::resetStartingFloaterPosition()
+{
+	const S32 FLOATER_PAD = 16;
+	LLCoordWindow window_size;
+	getWindow()->getSize(&window_size);
+	LLRect full_window(0, window_size.mY, window_size.mX, 0);
+	LLRect floater_creation_rect(
+		160,
+		full_window.getHeight() - 2 * MENU_BAR_HEIGHT,
+		full_window.getWidth() * 2 / 3,
+		130 );
+	floater_creation_rect.stretch( -FLOATER_PAD );
+
+	mNextLeft = floater_creation_rect.mLeft;
+	mNextTop = floater_creation_rect.mTop;
+	mColumn = 0;
+}
+
+LLRect LLFloaterView::findNeighboringPosition( LLFloater* reference_floater, LLFloater* neighbor )
+{
+	LLRect base_rect = reference_floater->getRect();
+	S32 width = neighbor->getRect().getWidth();
+	S32 height = neighbor->getRect().getHeight();
+	LLRect new_rect = neighbor->getRect();
+
+	LLRect expanded_base_rect = base_rect;
+	expanded_base_rect.stretch(10);
+	for(LLFloater::handle_set_iter_t dependent_it = reference_floater->mDependents.begin();
+		dependent_it != reference_floater->mDependents.end(); ++dependent_it)
+	{
+		LLFloater* sibling = LLFloater::getFloaterByHandle(*dependent_it);
+		// check for dependents within 10 pixels of base floater
+		if (sibling && 
+			sibling != neighbor && 
+			sibling->getVisible() && 
+			expanded_base_rect.rectInRect(&sibling->getRect()))
+		{
+			base_rect |= sibling->getRect();
+		}
+	}
+
+	S32 left_margin = llmax(0, base_rect.mLeft);
+	S32 right_margin = llmax(0, mRect.getWidth() - base_rect.mRight);
+	S32 top_margin = llmax(0, mRect.getHeight() - base_rect.mTop);
+	S32 bottom_margin = llmax(0, base_rect.mBottom);
+
+	// find position for floater in following order
+	// right->left->bottom->top
+	for (S32 i = 0; i < 5; i++)
+	{
+		if (right_margin > width)
+		{
+			new_rect.translate(base_rect.mRight - neighbor->mRect.mLeft, base_rect.mTop - neighbor->mRect.mTop);
+			return new_rect;
+		}
+		else if (left_margin > width)
+		{
+			new_rect.translate(base_rect.mLeft - neighbor->mRect.mRight, base_rect.mTop - neighbor->mRect.mTop);
+			return new_rect;
+		}
+		else if (bottom_margin > height)
+		{
+			new_rect.translate(base_rect.mLeft - neighbor->mRect.mLeft, base_rect.mBottom - neighbor->mRect.mTop);
+			return new_rect;
+		}
+		else if (top_margin > height)
+		{
+			new_rect.translate(base_rect.mLeft - neighbor->mRect.mLeft, base_rect.mTop - neighbor->mRect.mBottom);
+			return new_rect;
+		}
+
+		// keep growing margins to find "best" fit
+		left_margin += 20;
+		right_margin += 20;
+		top_margin += 20;
+		bottom_margin += 20;
+	}
+
+	// didn't find anything, return initial rect
+	return new_rect;
+}
+
+void LLFloaterView::setCycleMode(BOOL mode)
+{
+	mFocusCycleMode = mode;
+}
+
+BOOL LLFloaterView::getCycleMode()
+{
+	return mFocusCycleMode;
+}
+
+void LLFloaterView::bringToFront(LLFloater* child, BOOL give_focus)
+{
+	//FIXME: make this respect floater's mAutoFocus value, instead of using parameter
+	if (child->getHost())
+ 	{
+		// this floater is hosted elsewhere and hence not one of our children, abort
+		return;
+	}
+	std::vector<LLView*> floaters_to_move;
+	// Look at all floaters...tab
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		LLFloater *floater = (LLFloater *)viewp;
+
+		// ...but if I'm a dependent floater...
+		if (child->isDependent())
+		{
+			// ...look for floaters that have me as a dependent...
+			LLFloater::handle_set_iter_t found_dependent = floater->mDependents.find(child->getHandle());
+
+			if (found_dependent != floater->mDependents.end())
+			{
+				// ...and make sure all children of that floater (including me) are brought to front...
+				for(LLFloater::handle_set_iter_t dependent_it = floater->mDependents.begin();
+					dependent_it != floater->mDependents.end(); )
+				{
+					LLFloater* sibling = LLFloater::getFloaterByHandle(*dependent_it);
+					if (sibling)
+					{
+						floaters_to_move.push_back(sibling);
+					}
+					++dependent_it;
+				}
+				//...before bringing my parent to the front...
+				floaters_to_move.push_back(floater);
+			}
+		}
+	}
+
+	std::vector<LLView*>::iterator view_it;
+	for(view_it = floaters_to_move.begin(); view_it != floaters_to_move.end(); ++view_it)
+	{
+		LLFloater* floaterp = (LLFloater*)(*view_it);
+		sendChildToFront(floaterp);
+
+		floaterp->setMinimized(FALSE);
+	}
+	floaters_to_move.clear();
+
+	// ...then bringing my own dependents to the front...
+	for(LLFloater::handle_set_iter_t dependent_it = child->mDependents.begin();
+		dependent_it != child->mDependents.end(); )
+	{
+		LLFloater* dependent = getFloaterByHandle(*dependent_it);
+		if (dependent)
+		{
+			sendChildToFront(dependent);
+			dependent->setMinimized(FALSE);
+		}
+		++dependent_it;
+	}
+
+	// ...and finally bringing myself to front 
+	// (do this last, so that I'm left in front at end of this call)
+	if( *getChildList()->begin() != child ) 
+	{
+		sendChildToFront(child);
+	}
+	child->setMinimized(FALSE);
+	if (give_focus && !gFocusMgr.childHasKeyboardFocus(child))
+	{
+		child->setFocus(TRUE);
+	}
+}
+
+void LLFloaterView::highlightFocusedFloater()
+{
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLFloater *floater = (LLFloater *)(*child_it);
+
+		// skip dependent floaters, as we'll handle them in a batch along with their dependee(?)
+		if (floater->isDependent())
+		{
+			continue;
+		}
+
+		BOOL floater_or_dependent_has_focus = gFocusMgr.childHasKeyboardFocus(floater);
+		for(LLFloater::handle_set_iter_t dependent_it = floater->mDependents.begin();
+			dependent_it != floater->mDependents.end(); 
+			++dependent_it)
+		{
+			LLFloater* dependent_floaterp = getFloaterByHandle(*dependent_it);
+			if (dependent_floaterp && gFocusMgr.childHasKeyboardFocus(dependent_floaterp))
+			{
+				floater_or_dependent_has_focus = TRUE;
+			}
+		}
+
+		// now set this floater and all its dependents
+		floater->setForeground(floater_or_dependent_has_focus);
+
+		for(LLFloater::handle_set_iter_t dependent_it = floater->mDependents.begin();
+			dependent_it != floater->mDependents.end(); )
+		{
+			LLFloater* dependent_floaterp = getFloaterByHandle(*dependent_it);
+			if (dependent_floaterp)
+			{
+				dependent_floaterp->setForeground(floater_or_dependent_has_focus);
+			}
+			++dependent_it;
+		}
+			
+		floater->cleanupHandles();
+	}
+}
+
+void LLFloaterView::unhighlightFocusedFloater()
+{
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLFloater *floater = (LLFloater *)(*child_it);
+
+		floater->setForeground(FALSE);
+	}
+}
+
+void LLFloaterView::focusFrontFloater()
+{
+	LLFloater* floaterp = getFrontmost();
+	if (floaterp)
+	{
+		floaterp->setFocus(TRUE);
+	}
+}
+
+void LLFloaterView::getMinimizePosition(S32 *left, S32 *bottom)
+{
+	// count the number of minimized children
+	S32 count = 0;
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		LLFloater *floater = (LLFloater *)viewp;
+		if (floater->isMinimized())
+		{
+			count++;
+		}
+	}
+
+	// space over for that many and up if necessary
+	S32 tiles_per_row = mRect.getWidth() / MINIMIZED_WIDTH;
+
+	*left = (count % tiles_per_row) * MINIMIZED_WIDTH;
+	*bottom = (count / tiles_per_row) * LLFLOATER_HEADER_SIZE;
+}
+
+
+void LLFloaterView::destroyAllChildren()
+{
+	LLView::deleteAllChildren();
+}
+
+void LLFloaterView::closeAllChildren(bool app_quitting)
+{
+	// iterate over a copy of the list, because closing windows will destroy
+	// some windows on the list.
+	child_list_t child_list = *(getChildList());
+
+	for (child_list_const_iter_t it = child_list.begin(); it != child_list.end(); ++it)
+	{
+		LLView* viewp = *it;
+		child_list_const_iter_t exists = std::find(getChildList()->begin(), getChildList()->end(), viewp);
+		if (exists == getChildList()->end())
+		{
+			// this floater has already been removed
+			continue;
+		}
+
+		LLFloater* floaterp = (LLFloater*)viewp;
+
+		// Attempt to close floater.  This will cause the "do you want to save"
+		// dialogs to appear.
+		if (floaterp->canClose())
+		{
+			floaterp->close(app_quitting);
+		}
+	}
+}
+
+
+BOOL LLFloaterView::allChildrenClosed()
+{
+	// see if there are any visible floaters (some floaters "close"
+	// by setting themselves invisible)
+	S32 visible_count = 0;
+	for (child_list_const_iter_t it = getChildList()->begin(); it != getChildList()->end(); ++it)
+	{
+		LLView* viewp = *it;
+		LLFloater* floaterp = (LLFloater*)viewp;
+
+		if (floaterp->getVisible() && floaterp->canClose())
+		{
+			visible_count++;
+		}
+	}
+
+	return (visible_count == 0);
+}
+
+
+void LLFloaterView::refresh()
+{
+	// Constrain children to be entirely on the screen
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLFloater* floaterp = (LLFloater*)*child_it;
+		if( floaterp->getVisible() )
+		{
+			adjustToFitScreen(floaterp, TRUE);
+		}
+	}
+}
+
+void LLFloaterView::adjustToFitScreen(LLFloater* floater, BOOL allow_partial_outside)
+{
+	if (floater->getParent() != this)
+	{
+		// floater is hosted elsewhere, so ignore
+		return;
+	}
+	S32 screen_width = getSnapRect().getWidth();
+	S32 screen_height = getSnapRect().getHeight();
+	// convert to local coordinate frame
+	LLRect snap_rect_local = getSnapRect();
+	snap_rect_local.translate(-mRect.mLeft, -mRect.mBottom);
+
+	if( floater->isResizable() )
+	{
+		LLRect view_rect = floater->getRect();
+		S32 view_width = view_rect.getWidth();
+		S32 view_height = view_rect.getHeight();
+		S32 min_width;
+		S32 min_height;
+		floater->getResizeLimits( &min_width, &min_height );
+
+		S32 new_width = llmax( min_width, view_width );
+		S32 new_height = llmax( min_height, view_height );
+
+		if( (new_width > screen_width) || (new_height > screen_height) )
+		{
+			new_width = llmin(new_width, screen_width);
+			new_height = llmin(new_height, screen_height);
+
+			floater->reshape( new_width, new_height, TRUE );
+
+			// Make sure the damn thing is actually onscreen.
+			if (floater->translateIntoRect(snap_rect_local, FALSE))
+			{
+				floater->clearSnapTarget();
+			}
+		}
+		else if (!floater->isMinimized())
+		{
+			floater->reshape(new_width, new_height, TRUE);
+		}
+	}
+
+	if (floater->translateIntoRect( snap_rect_local, allow_partial_outside ))
+	{
+		floater->clearSnapTarget();
+	}
+}
+
+void LLFloaterView::draw()
+{
+	if( getVisible() )
+	{
+		refresh();
+
+		// hide focused floater if in cycle mode, so that it can be drawn on top
+		LLFloater* focused_floater = getFocusedFloater();
+		BOOL floater_visible = FALSE;
+		if (mFocusCycleMode && focused_floater)
+		{
+			floater_visible = focused_floater->getVisible();
+			focused_floater->setVisible(FALSE);
+		}
+
+		// And actually do the draw
+		LLView::draw();
+
+		// manually draw focused floater on top when in cycle mode
+		if (mFocusCycleMode && focused_floater)
+		{
+			// draw focused item on top for better feedback
+			focused_floater->setVisible(floater_visible);
+			if (floater_visible)
+			{
+				drawChild(focused_floater);
+			}
+		}
+	}
+}
+
+const LLRect LLFloaterView::getSnapRect() const
+{
+	LLRect snap_rect = mRect;
+	snap_rect.mBottom += mSnapOffsetBottom;
+
+	return snap_rect;
+}
+
+LLFloater *LLFloaterView::getFocusedFloater()
+{
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLUICtrl* ctrlp = (*child_it)->isCtrl() ? static_cast<LLUICtrl*>(*child_it) : NULL;
+		if ( ctrlp && ctrlp->hasFocus() )
+		{
+			return static_cast<LLFloater *>(ctrlp);
+		}
+	}
+	return NULL;
+}
+
+LLFloater *LLFloaterView::getFrontmost()
+{
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		if ( viewp->getVisible() )
+		{
+			return (LLFloater *)viewp;
+		}
+	}
+	return NULL;
+}
+
+LLFloater *LLFloaterView::getBackmost()
+{
+	LLFloater* back_most = NULL;
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		if ( viewp->getVisible() )
+		{
+			back_most = (LLFloater *)viewp;
+		}
+	}
+	return back_most;
+}
+
+void LLFloaterView::syncFloaterTabOrder()
+{
+	// bring focused floater to front
+	for ( child_list_const_reverse_iter_t child_it = getChildList()->rbegin(); child_it != getChildList()->rend(); ++child_it)
+	{
+		LLFloater* floaterp = (LLFloater*)*child_it;
+		if (gFocusMgr.childHasKeyboardFocus(floaterp))
+		{
+			bringToFront(floaterp, FALSE);
+			break;
+		}
+	}
+
+	// then sync draw order to tab order
+	for ( child_list_const_reverse_iter_t child_it = getChildList()->rbegin(); child_it != getChildList()->rend(); ++child_it)
+	{
+		LLFloater* floaterp = (LLFloater*)*child_it;
+		moveChildToFrontOfTabGroup(floaterp);
+	}
+}
+
+LLFloater* LLFloaterView::getFloaterByHandle(LLViewHandle handle)
+{
+	if (handle == LLViewHandle::sDeadHandle)
+	{
+		return NULL;
+	}
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		if (((LLFloater*)viewp)->getHandle() == handle)
+		{
+			return (LLFloater*)viewp;
+		}
+	}
+	return NULL;
+}
+
+LLFloater*	LLFloaterView::getParentFloater(LLView* viewp)
+{
+	LLView* parentp = viewp->getParent();
+
+	while(parentp && parentp != this)
+	{
+		viewp = parentp;
+		parentp = parentp->getParent();
+	}
+
+	if (parentp == this)
+	{
+		return (LLFloater*)viewp;
+	}
+
+	return NULL;
+}
+
+S32 LLFloaterView::getZOrder(LLFloater* child)
+{
+	S32 rv = 0;
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		if(viewp == child)
+		{
+			break;
+		}
+		++rv;
+	}
+	return rv;
+}
+
+void LLFloaterView::pushVisibleAll(BOOL visible, const skip_list_t& skip_list)
+{
+	for (child_list_const_iter_t child_iter = getChildList()->begin();
+		 child_iter != getChildList()->end(); ++child_iter)
+	{
+		LLView *view = *child_iter;
+		if (skip_list.find(view) == skip_list.end())
+		{
+			view->pushVisible(visible);
+		}
+	}
+}
+
+void LLFloaterView::popVisibleAll(const skip_list_t& skip_list)
+{
+	for (child_list_const_iter_t child_iter = getChildList()->begin();
+		 child_iter != getChildList()->end(); ++child_iter)
+	{
+		LLView *view = *child_iter;
+		if (skip_list.find(view) == skip_list.end())
+		{
+			view->popVisible();
+		}
+	}
+}
+
+//
+// LLMultiFloater
+//
+
+LLMultiFloater::LLMultiFloater() :
+	mTabContainer(NULL),
+	mTabPos(LLTabContainerCommon::TOP),
+	mAutoResize(FALSE)
+{
+
+}
+
+LLMultiFloater::LLMultiFloater(LLTabContainerCommon::TabPosition tab_pos) :
+	mTabContainer(NULL),
+	mTabPos(tab_pos),
+	mAutoResize(FALSE)
+{
+
+}
+
+LLMultiFloater::LLMultiFloater(const LLString &name) :
+	LLFloater(name),
+	mTabContainer(NULL),
+	mTabPos(LLTabContainerCommon::TOP),
+	mAutoResize(FALSE)
+{
+}
+
+LLMultiFloater::LLMultiFloater(
+	const LLString& name,
+	const LLRect& rect,
+	LLTabContainer::TabPosition tab_pos,
+	BOOL auto_resize) : 
+	LLFloater(name, rect, name),
+	mTabContainer(NULL),
+	mTabPos(LLTabContainerCommon::TOP),
+	mAutoResize(auto_resize)
+{
+	mTabContainer = new LLTabContainer("Preview Tabs", 
+		LLRect(LLPANEL_BORDER_WIDTH, mRect.getHeight() - LLFLOATER_HEADER_SIZE, mRect.getWidth() - LLPANEL_BORDER_WIDTH, 0), 
+		mTabPos, 
+		NULL, 
+		NULL);
+	mTabContainer->setFollowsAll();
+	if (mResizable)
+	{
+		mTabContainer->setRightTabBtnOffset(RESIZE_HANDLE_WIDTH);
+	}
+
+	addChild(mTabContainer);
+}
+
+LLMultiFloater::LLMultiFloater(
+	const LLString& name,
+	const LLString& rect_control,
+	LLTabContainer::TabPosition tab_pos,
+	BOOL auto_resize) : 
+	LLFloater(name, rect_control, name),
+	mTabContainer(NULL),
+	mTabPos(tab_pos),
+	mAutoResize(auto_resize)
+{
+	mTabContainer = new LLTabContainer("Preview Tabs", 
+	LLRect(LLPANEL_BORDER_WIDTH, mRect.getHeight() - LLFLOATER_HEADER_SIZE, mRect.getWidth() - LLPANEL_BORDER_WIDTH, 0), 
+	mTabPos, 
+	NULL, 
+	NULL);
+	mTabContainer->setFollowsAll();
+	if (mResizable && mTabPos == LLTabContainerCommon::BOTTOM)
+	{
+		mTabContainer->setRightTabBtnOffset(RESIZE_HANDLE_WIDTH);
+	}
+
+	addChild(mTabContainer);
+	
+}
+
+LLMultiFloater::~LLMultiFloater()
+{
+}
+
+// virtual
+EWidgetType LLMultiFloater::getWidgetType() const
+{
+	return WIDGET_TYPE_MULTI_FLOATER;
+}
+
+// virtual
+LLString LLMultiFloater::getWidgetTag() const
+{
+	return LL_MULTI_FLOATER_TAG;
+}
+
+void LLMultiFloater::init(const LLString& title, BOOL resizable, 
+						S32 min_width, S32 min_height, BOOL drag_on_left,
+						BOOL minimizable, BOOL close_btn)
+{
+	LLFloater::init(title, resizable, min_width, min_height, drag_on_left, minimizable, close_btn);
+
+	/*mTabContainer = new LLTabContainer("Preview Tabs", 
+		LLRect(LLPANEL_BORDER_WIDTH, mRect.getHeight() - LLFLOATER_HEADER_SIZE, mRect.getWidth() - LLPANEL_BORDER_WIDTH, 0), 
+		mTabPos, 
+		NULL, 
+		NULL);
+	mTabContainer->setFollowsAll();
+	if (mResizable && mTabPos == LLTabContainerCommon::BOTTOM)
+	{
+		mTabContainer->setRightTabBtnOffset(RESIZE_HANDLE_WIDTH);
+	}
+
+	addChild(mTabContainer);*/
+}
+
+void LLMultiFloater::open()
+{
+	if (mTabContainer->getTabCount() > 0)
+	{
+		LLFloater::open();
+	}
+	else
+	{
+		// for now, don't allow multifloaters
+		// without any child floaters
+		close();
+	}
+}
+
+void LLMultiFloater::onClose(bool app_quitting)
+{
+	if(closeAllFloaters() == TRUE)
+	{
+		LLFloater::onClose(app_quitting ? true : false);
+	}//else not all tabs could be closed...
+}
+
+void LLMultiFloater::draw()
+{
+	if (mTabContainer->getTabCount() == 0)
+	{
+		//RN: could this potentially crash in draw hierarchy?
+		close();
+	}
+	else
+	{
+		for (S32 i = 0; i < mTabContainer->getTabCount(); i++)
+		{
+			LLFloater* floaterp = (LLFloater*)mTabContainer->getPanelByIndex(i);
+			if (floaterp->getTitle() != mTabContainer->getPanelTitle(i))
+			{
+				mTabContainer->setPanelTitle(i, floaterp->getTitle());
+			}
+		}
+		LLFloater::draw();
+	}
+}
+
+BOOL LLMultiFloater::closeAllFloaters()
+{
+	S32	tabToClose = 0;
+	S32	lastTabCount = mTabContainer->getTabCount();
+	while (tabToClose < mTabContainer->getTabCount())
+	{
+		LLFloater* first_floater = (LLFloater*)mTabContainer->getPanelByIndex(tabToClose);
+		first_floater->close();
+		if(lastTabCount == mTabContainer->getTabCount())
+		{
+			//Tab did not actually close, possibly due to a pending Save Confirmation dialog..
+			//so try and close the next one in the list...
+			tabToClose++;
+		}else
+		{
+			//Tab closed ok.
+			lastTabCount = mTabContainer->getTabCount();
+		}
+	}
+	if( mTabContainer->getTabCount() != 0 )
+		return FALSE; // Couldn't close all the tabs (pending save dialog?) so return FALSE.
+	return TRUE; //else all tabs were successfully closed...
+}
+
+void LLMultiFloater::growToFit(LLFloater* floaterp, S32 width, S32 height)
+{
+	floater_data_map_t::iterator found_data_it;
+	found_data_it = mFloaterDataMap.find(floaterp->getHandle());
+	if (found_data_it != mFloaterDataMap.end())
+	{
+		// store new width and height with this floater so that it will keep its size when detached
+		found_data_it->second.mWidth = width;
+		found_data_it->second.mHeight = height;
+
+		S32 cur_height = mRect.getHeight();
+		reshape(llmax(mRect.getWidth(), width + LLPANEL_BORDER_WIDTH * 2), llmax(mRect.getHeight(), height + LLFLOATER_HEADER_SIZE + TABCNTR_HEADER_HEIGHT + (LLPANEL_BORDER_WIDTH * 2)));
+		
+		// make sure upper left corner doesn't move
+		translate(0, mRect.getHeight() - cur_height);
+
+		// Try to keep whole view onscreen, don't allow partial offscreen.
+		gFloaterView->adjustToFitScreen(this, FALSE);
+	}
+}
+
+/**
+  void addFloater(LLFloater* floaterp, BOOL select_added_floater)
+
+  Adds the LLFloater pointed to by floaterp to this.
+  If floaterp is already hosted by this, then it is re-added to get
+  new titles, etc.
+  If select_added_floater is true, the LLFloater pointed to by floaterp will
+  become the selected tab in this
+
+  Affects: mTabContainer, floaterp
+**/
+void LLMultiFloater::addFloater(LLFloater* floaterp, BOOL select_added_floater, LLTabContainer::eInsertionPoint insertion_point)
+{
+	if (!floaterp)
+	{
+		return;
+	}
+
+	if (!mTabContainer)
+	{
+		llerrs << "Tab Container used without having been initialized." << llendl;
+	}
+
+	if (floaterp->getHost() == this)
+	{
+		// already hosted by me, remove
+		// do this so we get updated title, etc.
+		mFloaterDataMap.erase(floaterp->getHandle());
+		mTabContainer->removeTabPanel(floaterp);
+	}
+	else if (floaterp->getHost())
+	{
+		// floaterp is hosted by somebody else and
+		// this is adding it, so remove it from it's old host
+		floaterp->getHost()->removeFloater(floaterp);
+	}
+	else if (floaterp->getParent() == gFloaterView)
+	{
+		// rehost preview floater as child panel
+		gFloaterView->removeChild(floaterp);
+	}
+
+	// store original configuration
+	LLFloaterData floater_data;
+	floater_data.mWidth = floaterp->getRect().getWidth();
+	floater_data.mHeight = floaterp->getRect().getHeight();
+	floater_data.mCanMinimize = floaterp->isMinimizeable();
+	floater_data.mCanResize = floaterp->isResizable();
+
+	// remove minimize and close buttons
+	floaterp->setCanMinimize(FALSE);
+	floaterp->setCanResize(FALSE);
+	floaterp->setCanDrag(FALSE);
+
+	S32 new_width = llmax(mRect.getWidth(), floaterp->getRect().getWidth()); 
+	S32 new_height = llmax(mRect.getHeight(), floaterp->getRect().getHeight() + LLFLOATER_HEADER_SIZE + TABCNTR_HEADER_HEIGHT); 
+
+	reshape(new_width, new_height);
+
+	//add the panel, add it to proper maps
+	mTabContainer->addTabPanel(floaterp, floaterp->getTitle(), FALSE, onTabSelected, this, 0, FALSE, insertion_point);
+	mFloaterDataMap[floaterp->getHandle()] = floater_data;
+
+	if ( select_added_floater )
+	{
+		mTabContainer->selectLastTab();
+		// explicitly call tabopen to load preview assets, etc.
+		tabOpen((LLFloater*)mTabContainer->getCurrentPanel(), true);
+	}
+
+	floaterp->setHost(this);
+	if (mMinimized)
+	{
+		floaterp->setVisible(FALSE);
+	}
+}
+
+/**
+	BOOL selectFloater(LLFloater* floaterp)
+
+	If the LLFloater pointed to by floaterp is hosted by this,
+	then its tab is selected and returns true.  Otherwise returns false.
+
+	Affects: mTabContainer
+**/
+BOOL LLMultiFloater::selectFloater(LLFloater* floaterp)
+{
+	return mTabContainer->selectTabPanel(floaterp);
+}
+
+// virtual
+void LLMultiFloater::selectNextFloater()
+{
+	mTabContainer->selectNextTab();
+}
+
+// virtual
+void LLMultiFloater::selectPrevFloater()
+{
+	mTabContainer->selectPrevTab();
+}
+
+void LLMultiFloater::showFloater(LLFloater* floaterp)
+{
+	// we won't select a panel that already is selected
+	// it is hard to do this internally to tab container
+	// as tab selection is handled via index and the tab at a given
+	// index might have changed
+	if (floaterp != mTabContainer->getCurrentPanel() &&
+		!mTabContainer->selectTabPanel(floaterp))
+	{
+		addFloater(floaterp, TRUE);
+	}
+	setVisibleAndFrontmost();
+}
+
+void LLMultiFloater::removeFloater(LLFloater* floaterp)
+{
+	if ( floaterp->getHost() != this )
+		return;
+
+	floater_data_map_t::iterator found_data_it = mFloaterDataMap.find(floaterp->getHandle());
+	if (found_data_it != mFloaterDataMap.end())
+	{
+		LLFloaterData& floater_data = found_data_it->second;
+		floaterp->setCanMinimize(floater_data.mCanMinimize);
+		if (!floater_data.mCanResize)
+		{
+			// restore original size
+			floaterp->reshape(floater_data.mWidth, floater_data.mHeight);
+		}
+		floaterp->setCanResize(floater_data.mCanResize);
+		mFloaterDataMap.erase(found_data_it);
+	}
+	mTabContainer->removeTabPanel(floaterp);
+	floaterp->setBackgroundVisible(TRUE);
+	floaterp->setHost(NULL);
+
+	if (mAutoResize)
+	{
+		floater_data_map_t::iterator floater_it;
+		S32 new_width = 0;
+		S32 new_height = 0;
+		for (floater_it = mFloaterDataMap.begin(); floater_it != mFloaterDataMap.end(); ++floater_it)
+		{
+			new_width = llmax(new_width, floater_it->second.mWidth + LLPANEL_BORDER_WIDTH * 2);
+			new_height = llmax(new_height, floater_it->second.mHeight + LLFLOATER_HEADER_SIZE + TABCNTR_HEADER_HEIGHT);
+		}	
+
+		S32 cur_height = mRect.getHeight();
+
+		reshape(new_width, new_height);
+
+		// make sure upper left corner doesn't move
+		translate(0, cur_height - new_height);
+
+		// Try to keep whole view onscreen, don't allow partial offscreen.
+		gFloaterView->adjustToFitScreen(this, FALSE);
+	}
+
+	tabOpen((LLFloater*)mTabContainer->getCurrentPanel(), false);
+}
+
+void LLMultiFloater::tabOpen(LLFloater* opened_floater, bool from_click)
+{
+	// default implementation does nothing
+}
+
+void LLMultiFloater::tabClose()
+{
+	if (mTabContainer->getTabCount() == 0)
+	{
+		// no more children, close myself
+		close();
+	}
+}
+
+void LLMultiFloater::setVisible(BOOL visible)
+{
+	//FIXME: shouldn't have to do this, fix adding to minimized multifloater
+	LLFloater::setVisible(visible);
+	
+	if (mTabContainer)
+	{
+		LLPanel* cur_floaterp = mTabContainer->getCurrentPanel();
+
+		if (cur_floaterp)
+		{
+			cur_floaterp->setVisible(visible);
+		}
+	}
+}
+
+BOOL LLMultiFloater::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	if (getEnabled()
+		&& mask == (MASK_CONTROL|MASK_SHIFT))
+	{
+		if (key == 'W')
+		{
+			LLFloater* floater = getActiveFloater();
+			if (floater && floater->canClose())
+			{
+				floater->close();
+			}
+			return TRUE;
+		}
+	}
+
+	return LLFloater::handleKeyHere(key, mask, called_from_parent);
+}
+
+LLFloater* LLMultiFloater::getActiveFloater()
+{
+	return (LLFloater*)mTabContainer->getCurrentPanel();
+}
+
+S32	LLMultiFloater::getFloaterCount()
+{
+	return mTabContainer->getTabCount();
+}
+
+/**
+	BOOL isFloaterFlashing(LLFloater* floaterp)
+
+	Returns true if the LLFloater pointed to by floaterp
+	is currently in a flashing state and is hosted by this.
+	False otherwise.
+
+	Requires: floaterp != NULL
+**/
+BOOL LLMultiFloater::isFloaterFlashing(LLFloater* floaterp)
+{
+	if ( floaterp && floaterp->getHost() == this )
+		return mTabContainer->getTabPanelFlashing(floaterp);
+
+	return FALSE;
+}
+
+/**
+	BOOL setFloaterFlashing(LLFloater* floaterp, BOOL flashing)
+
+	Sets the current flashing state of the LLFloater pointed
+	to by floaterp to be the BOOL flashing if the LLFloater pointed
+	to by floaterp is hosted by this.
+
+	Requires: floaterp != NULL
+**/
+void LLMultiFloater::setFloaterFlashing(LLFloater* floaterp, BOOL flashing)
+{
+	if ( floaterp && floaterp->getHost() == this )
+		mTabContainer->setTabPanelFlashing(floaterp, flashing);
+}
+
+//static
+void LLMultiFloater::onTabSelected(void* userdata, bool from_click)
+{
+	LLMultiFloater* floaterp = (LLMultiFloater*)userdata;
+
+	floaterp->tabOpen((LLFloater*)floaterp->mTabContainer->getCurrentPanel(), from_click);
+}
+
+void LLMultiFloater::setCanResize(BOOL can_resize)
+{
+	LLFloater::setCanResize(can_resize);
+	if (mResizable && mTabContainer->getTabPosition() == LLTabContainer::BOTTOM)
+	{
+		mTabContainer->setRightTabBtnOffset(RESIZE_HANDLE_WIDTH);
+	}
+	else
+	{
+		mTabContainer->setRightTabBtnOffset(0);
+	}
+}
+
+BOOL LLMultiFloater::postBuild()
+{
+	if (mTabContainer)
+	{
+		return TRUE;
+	}
+
+	requires("Preview Tabs", WIDGET_TYPE_TAB_CONTAINER);
+	if (checkRequirements())
+	{
+		mTabContainer = LLUICtrlFactory::getTabContainerByName(this, "Preview Tabs");
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+// virtual
+LLXMLNodePtr LLFloater::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLPanel::getXML();
+
+	node->createChild("title", TRUE)->setStringValue(getTitle());
+
+	node->createChild("can_resize", TRUE)->setBoolValue(isResizable());
+
+	node->createChild("can_minimize", TRUE)->setBoolValue(isMinimizeable());
+
+	node->createChild("can_close", TRUE)->setBoolValue(isCloseable());
+
+	node->createChild("can_drag_on_left", TRUE)->setBoolValue(isDragOnLeft());
+
+	node->createChild("min_width", TRUE)->setIntValue(getMinWidth());
+
+	node->createChild("min_height", TRUE)->setIntValue(getMinHeight());
+
+	node->createChild("can_tear_off", TRUE)->setBoolValue(mCanTearOff);
+	
+	return node;
+}
+
+// static
+LLView* LLFloater::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("floater");
+	node->getAttributeString("name", name);
+
+	LLFloater *floaterp = new LLFloater(name);
+
+	LLString filename;
+	node->getAttributeString("filename", filename);
+
+	if (filename.empty())
+	{
+		// Load from node
+		floaterp->initFloaterXML(node, parent, factory);
+	}
+	else
+	{
+		// Load from file
+		factory->buildFloater(floaterp, filename);
+	}
+
+	return floaterp;
+}
+
+void LLFloater::initFloaterXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory, BOOL open)
+{
+	LLString name(getName());
+	LLString title(getTitle());
+	LLString rect_control("");
+	BOOL resizable = isResizable();
+	S32 min_width = getMinWidth();
+	S32 min_height = getMinHeight();
+	BOOL drag_on_left = isDragOnLeft();
+	BOOL minimizable = isMinimizeable();
+	BOOL close_btn = isCloseable();
+	LLRect rect;
+
+	node->getAttributeString("name", name);
+	node->getAttributeString("title", title);
+	node->getAttributeString("rect_control", rect_control);
+	node->getAttributeBOOL("can_resize", resizable);
+	node->getAttributeBOOL("can_minimize", minimizable);
+	node->getAttributeBOOL("can_close", close_btn);
+	node->getAttributeBOOL("can_drag_on_left", drag_on_left);
+	node->getAttributeS32("min_width", min_width);
+	node->getAttributeS32("min_height", min_height);
+
+	if (! rect_control.empty())
+	{
+		setRectControl(rect_control);
+	}
+
+	createRect(node, rect, parent, LLRect());
+	
+	setRect(rect);
+	setName(name);
+	
+	init(title,
+			resizable,
+			min_width,
+			min_height,
+			drag_on_left,
+			minimizable,
+			close_btn);
+
+	BOOL can_tear_off;
+	if (node->getAttributeBOOL("can_tear_off", can_tear_off))
+	{
+		setCanTearOff(can_tear_off);
+	}
+	
+	initFromXML(node, parent);
+
+	LLMultiFloater* last_host = LLFloater::getFloaterHost();
+	if (node->hasName("multi_floater"))
+	{
+		LLFloater::setFloaterHost((LLMultiFloater*) this);
+	}
+
+	LLXMLNodePtr child;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		factory->createWidget(this, child);
+	}
+	if (node->hasName("multi_floater"))
+	{
+		LLFloater::setFloaterHost(last_host);
+	}
+
+
+	BOOL result = postBuild();
+
+	if (!result)
+	{
+		llerrs << "Failed to construct floater " << name << llendl;
+	}
+
+	applyRectControl();
+	if (open)
+	{
+		this->open();
+	}
+}
diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h
new file mode 100644
index 0000000000..d682c7a36a
--- /dev/null
+++ b/indra/llui/llfloater.h
@@ -0,0 +1,399 @@
+/** 
+ * @file llfloater.h
+ * @brief LLFloater base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Floating "windows" within the GL display, like the inventory floater,
+// mini-map floater, etc.
+
+
+#ifndef LL_FLOATER_H
+#define LL_FLOATER_H
+
+#include "llpanel.h"
+#include "lluuid.h"
+#include "lltabcontainer.h"
+#include <set>
+
+class LLDragHandle;
+class LLResizeHandle;
+class LLResizeBar;
+class LLButton;
+class LLMultiFloater;
+
+const S32 LLFLOATER_VPAD = 6;
+const S32 LLFLOATER_HPAD = 6;
+const S32 LLFLOATER_CLOSE_BOX_SIZE = 16;
+const S32 LLFLOATER_HEADER_SIZE = 16;
+
+const BOOL RESIZE_YES = TRUE;
+const BOOL RESIZE_NO = FALSE;
+
+const S32 DEFAULT_MIN_WIDTH = 100;
+const S32 DEFAULT_MIN_HEIGHT = 100;
+
+const BOOL DRAG_ON_TOP = FALSE;
+const BOOL DRAG_ON_LEFT = TRUE;
+
+const BOOL MINIMIZE_YES = TRUE;
+const BOOL MINIMIZE_NO = FALSE;
+
+const BOOL CLOSE_YES = TRUE;
+const BOOL CLOSE_NO = FALSE;
+
+const BOOL ADJUST_VERTICAL_YES = TRUE;
+const BOOL ADJUST_VERTICAL_NO = FALSE;
+
+
+class LLFloater : public LLPanel
+{
+friend class LLFloaterView;
+public:
+	enum EFloaterButtons
+	{
+		BUTTON_CLOSE,
+		BUTTON_RESTORE,
+		BUTTON_MINIMIZE,
+		BUTTON_TEAR_OFF,
+		BUTTON_EDIT,
+		BUTTON_COUNT
+	};
+	
+	LLFloater();
+ 	LLFloater(const LLString& name); //simple constructor for data-driven initialization
+	LLFloater(	const LLString& name, const LLRect& rect, const LLString& title,
+		BOOL resizable = FALSE,
+		S32 min_width = DEFAULT_MIN_WIDTH,
+		S32 min_height = DEFAULT_MIN_HEIGHT,
+		BOOL drag_on_left = FALSE,
+		BOOL minimizable = TRUE,
+		BOOL close_btn = TRUE,
+		BOOL bordered = BORDER_NO);
+
+	LLFloater(	const LLString& name, const LLString& rect_control, const LLString& title,
+		BOOL resizable = FALSE,
+		S32 min_width = DEFAULT_MIN_WIDTH, 
+		S32 min_height = DEFAULT_MIN_HEIGHT,
+		BOOL drag_on_left = FALSE,
+		BOOL minimizable = TRUE,
+		BOOL close_btn = TRUE,
+		BOOL bordered = BORDER_NO);
+
+	virtual ~LLFloater();
+
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	void initFloaterXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory, BOOL open = TRUE);
+
+	/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = 1);
+	/*virtual*/ void translate(S32 x, S32 y);
+	/*virtual*/ BOOL canSnapTo(LLView* other_view);
+	/*virtual*/ void snappedTo(LLView* snap_view);
+	/*virtual*/ void setFocus( BOOL b );
+	/*virtual*/ void setIsChrome(BOOL is_chrome);
+
+	// Can be called multiple times to reset floater parameters.
+	// Deletes all children of the floater.
+	virtual void		init(const LLString& title, BOOL resizable, 
+						S32 min_width, S32 min_height, BOOL drag_on_left,
+						BOOL minimizable, BOOL close_btn);
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual void	open();
+
+	// If allowed, close the floater cleanly, releasing focus.
+	// app_quitting is passed to onClose() below.
+	virtual void	close(bool app_quitting = false);
+
+	void			setAutoFocus(BOOL focus) { mAutoFocus = focus; setFocus(focus); }
+	
+	// Release keyboard and mouse focus
+	void			releaseFocus();
+
+	// moves to center of gFloaterView
+	void			center();
+	// applies rectangle stored in mRectControl, if any
+	void			applyRectControl();
+
+
+	LLMultiFloater* getHost() { return (LLMultiFloater*)LLFloater::getFloaterByHandle(mHostHandle); }
+
+	void			setTitle( const LLString& title );
+	const LLString&		getTitle() const;
+	virtual void	setMinimized(BOOL b);
+	void			moveResizeHandleToFront();
+	void			addDependentFloater(LLFloater* dependent, BOOL reposition = TRUE);
+	void			addDependentFloater(LLViewHandle dependent_handle, BOOL reposition = TRUE);
+	LLFloater*              getDependee() { return (LLFloater*)LLFloater::getFloaterByHandle(mDependeeHandle); }
+	void                    removeDependentFloater(LLFloater* dependent);
+	BOOL			isMinimized()					{ return mMinimized; }
+	BOOL			isFrontmost();
+	BOOL			isDependent()					{ return !mDependeeHandle.isDead(); }
+	void			setCanMinimize(BOOL can_minimize);
+	void			setCanClose(BOOL can_close);
+	void			setCanTearOff(BOOL can_tear_off);
+	virtual void	setCanResize(BOOL can_resize);
+	void			setCanDrag(BOOL can_drag);
+	void			setHost(LLMultiFloater* host);
+	BOOL			isResizable() const				{ return mResizable; }
+	void			setResizeLimits( S32 min_width, S32 min_height );
+	void			getResizeLimits( S32* min_width, S32* min_height ) { *min_width = mMinWidth; *min_height = mMinHeight; }
+
+
+	bool			isMinimizeable() const{ return mButtonsEnabled[BUTTON_MINIMIZE]; }
+	// Does this window have a close button, NOT can we close it right now.
+	bool			isCloseable() const{ return (mButtonsEnabled[BUTTON_CLOSE] ? true : false); }
+	bool			isDragOnLeft() const{ return mDragOnLeft; }
+	S32				getMinWidth() const{ return mMinWidth; }
+	S32				getMinHeight() const{ return mMinHeight; }
+
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
+
+	virtual void	draw();
+
+	// Call destroy() to free memory, or setVisible(FALSE) to keep it
+	// If app_quitting, you might not want to save your visibility.
+	// Defaults to destroy().
+	virtual void	onClose(bool app_quitting);
+
+	// Defaults to true.
+	virtual BOOL	canClose();
+
+	virtual void	setVisible(BOOL visible);
+	void			setFrontmost(BOOL take_focus = TRUE);
+
+	// Defaults to false.
+	virtual BOOL	canSaveAs();
+
+	// Defaults to no-op.
+	virtual void	saveAs();
+
+	void			setSnapTarget(LLViewHandle handle) { mSnappedTo = handle; }
+	void			clearSnapTarget() { mSnappedTo.markDead(); }
+	LLViewHandle	getSnapTarget() { return mSnappedTo; }
+
+	/*virtual*/ LLView*	getRootMostFastFrameView();
+
+	static void		closeByMenu(void *userdata);
+	static void		onClickClose(void *userdata);
+	static void		onClickMinimize(void *userdata);
+	static void		onClickTearOff(void *userdata);
+	static void		onClickEdit(void *userdata);
+
+	static void		setFloaterHost(LLMultiFloater* hostp) {sHostp = hostp; }
+	static void		setEditModeEnabled(BOOL enable);
+	static BOOL		getEditModeEnabled();
+	static LLMultiFloater*		getFloaterHost() {return sHostp; }
+
+	static LLFloater* getFloaterByHandle(LLViewHandle handle);
+
+protected:
+	// Don't call this directly.  You probably want to call close(). JC
+	void			destroy();
+	virtual void	bringToFront(S32 x, S32 y);
+	virtual void	setVisibleAndFrontmost(BOOL take_focus=TRUE);
+	void			setForeground(BOOL b);	// called only by floaterview
+	void			cleanupHandles(); // remove handles to dead floaters
+	void			createMinimizeButton();
+	void			updateButtons();
+	void			buildButtons();
+
+protected:
+//	static LLViewerImage*		sBackgroundImage;
+//	static LLViewerImage*		sShadowImage;
+
+	LLDragHandle*	mDragHandle;
+	LLResizeBar*	mResizeBar[4];
+	LLResizeHandle* mResizeHandle[4];
+	LLButton		*mMinimizeButton;
+	BOOL			mCanTearOff;
+	BOOL			mMinimized;
+	LLRect			mPreviousRect;
+	BOOL			mForeground;
+	LLViewHandle	mDependeeHandle;
+
+	BOOL			mFirstLook;			// TRUE if the _next_ time this floater is visible will be the first time in the session that it is visible.
+
+	BOOL			mResizable;
+	S32				mMinWidth;
+	S32				mMinHeight;
+
+	BOOL			mAutoFocus;
+	BOOL			mEditing;
+	
+	typedef std::set<LLViewHandle> handle_set_t;
+	typedef std::set<LLViewHandle>::iterator handle_set_iter_t;
+	handle_set_t	mDependents;
+	bool            mDragOnLeft;
+
+	BOOL			mButtonsEnabled[BUTTON_COUNT];
+	LLButton*		mButtons[BUTTON_COUNT];
+	F32				mButtonScale;
+
+	LLViewHandle	mSnappedTo;
+	
+	LLViewHandle mHostHandle;
+	LLViewHandle mLastHostHandle;
+
+	static BOOL		sEditModeEnabled;
+	static LLMultiFloater* sHostp;
+	static LLString	sButtonActiveImageNames[BUTTON_COUNT];
+	static LLString	sButtonInactiveImageNames[BUTTON_COUNT];
+	static LLString	sButtonPressedImageNames[BUTTON_COUNT];
+	static LLString	sButtonNames[BUTTON_COUNT];
+	static LLString	sButtonToolTips[BUTTON_COUNT];
+	typedef void (*click_callback)(void *);
+	static click_callback sButtonCallbacks[BUTTON_COUNT];
+
+	typedef std::map<LLViewHandle, LLFloater*> handle_map_t;
+	typedef std::map<LLViewHandle, LLFloater*>::iterator handle_map_iter_t;
+	static handle_map_t	sFloaterMap;
+
+	std::vector<LLView*> mMinimizedHiddenChildren;
+};
+
+
+/////////////////////////////////////////////////////////////
+// LLFloaterView
+// Parent of all floating panels
+
+class LLFloaterView : public LLUICtrl
+{
+public:
+	LLFloaterView( const LLString& name, const LLRect& rect );
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent);
+	void reshape(S32 width, S32 height, BOOL called_from_parent, BOOL adjust_vertical);
+
+	/*virtual*/ void draw();
+	/*virtual*/ const LLRect getSnapRect() const;
+	void refresh();
+
+	void			getNewFloaterPosition( S32* left, S32* top );
+	void			resetStartingFloaterPosition();
+	LLRect			findNeighboringPosition( LLFloater* reference_floater, LLFloater* neighbor );
+
+	// Given a child of gFloaterView, make sure this view can fit entirely onscreen.
+	void			adjustToFitScreen(LLFloater* floater, BOOL allow_partial_outside);
+
+	void			getMinimizePosition( S32 *left, S32 *bottom);
+	void			restoreAll();		// un-minimize all floaters
+	typedef std::set<LLView*> skip_list_t;
+	void LLFloaterView::pushVisibleAll(BOOL visible, const skip_list_t& skip_list = skip_list_t());
+	void LLFloaterView::popVisibleAll(const skip_list_t& skip_list = skip_list_t());
+
+	void			setCycleMode(BOOL mode);
+	BOOL			getCycleMode();
+	void			bringToFront( LLFloater* child, BOOL give_focus = TRUE );
+	void			highlightFocusedFloater();
+	void			unhighlightFocusedFloater();
+	void			focusFrontFloater();
+	void			destroyAllChildren();
+	// attempt to close all floaters
+	void			closeAllChildren(bool app_quitting);
+	BOOL			allChildrenClosed();
+
+	LLFloater* getFrontmost();
+	LLFloater* getBackmost();
+	LLFloater* getParentFloater(LLView* viewp);
+	LLFloater* getFocusedFloater();
+	void		syncFloaterTabOrder();
+
+	// Get a floater based the handle. If this returns NULL, it is up
+	// to the caller to discard the handle.
+	LLFloater* getFloaterByHandle(LLViewHandle handle);
+
+	// Returns z order of child provided. 0 is closest, larger numbers
+	// are deeper in the screen. If there is no such child, the return
+	// value is not defined.
+	S32 getZOrder(LLFloater* child);
+
+	void setSnapOffsetBottom(S32 offset) { mSnapOffsetBottom = offset; }
+
+private:
+	S32				mColumn;
+	S32				mNextLeft;
+	S32				mNextTop;
+	BOOL			mFocusCycleMode;
+	S32				mSnapOffsetBottom;
+};
+
+class LLMultiFloater : public LLFloater
+{
+public:
+	LLMultiFloater();
+	LLMultiFloater(LLTabContainerCommon::TabPosition tab_pos);
+	LLMultiFloater(const LLString& name);
+	LLMultiFloater(const LLString& name, const LLRect& rect, LLTabContainer::TabPosition tab_pos = LLTabContainer::TOP, BOOL auto_resize = FALSE);
+	LLMultiFloater(const LLString& name, const LLString& rect_control, LLTabContainer::TabPosition tab_pos = LLTabContainer::TOP, BOOL auto_resize = FALSE);
+	virtual ~LLMultiFloater();
+
+	virtual void init(const LLString& title, BOOL resizable, 
+						S32 min_width, S32 min_height, BOOL drag_on_left,
+						BOOL minimizable, BOOL close_btn);
+
+	virtual BOOL postBuild();
+	/*virtual*/ void open();
+	/*virtual*/ void onClose(bool app_quitting);
+	/*virtual*/ void draw();
+	/*virtual*/ void setVisible(BOOL visible);
+	/*virtual*/ BOOL handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+
+	/*virtual*/ EWidgetType getWidgetType() const;
+	/*virtual*/ LLString getWidgetTag() const;
+
+	virtual void setCanResize(BOOL can_resize);
+	virtual void growToFit(LLFloater* floaterp, S32 width, S32 height);
+	virtual void addFloater(LLFloater* floaterp, BOOL select_added_floater, LLTabContainerCommon::eInsertionPoint insertion_point = LLTabContainerCommon::END);
+
+	virtual void showFloater(LLFloater* floaterp);
+	virtual void removeFloater(LLFloater* floaterp);
+
+	virtual void tabOpen(LLFloater* opened_floater, bool from_click);
+	virtual void tabClose();
+
+	virtual BOOL selectFloater(LLFloater* floaterp);
+	virtual void selectNextFloater();
+	virtual void selectPrevFloater();
+
+	virtual LLFloater* getActiveFloater();
+	virtual BOOL       isFloaterFlashing(LLFloater* floaterp);
+	virtual S32			getFloaterCount();
+
+	virtual void setFloaterFlashing(LLFloater* floaterp, BOOL flashing);
+	virtual BOOL closeAllFloaters();	//Returns FALSE if the floater could not be closed due to pending confirmation dialogs
+	void setTabContainer(LLTabContainerCommon* tab_container) { if (!mTabContainer) mTabContainer = tab_container; }
+	static void onTabSelected(void* userdata, bool);
+
+protected:
+	struct LLFloaterData
+	{
+		S32		mWidth;
+		S32		mHeight;
+		BOOL	mCanMinimize;
+		BOOL	mCanResize;
+	};
+
+	LLTabContainerCommon*		mTabContainer;
+	
+	typedef std::map<LLViewHandle, LLFloaterData> floater_data_map_t;
+	floater_data_map_t	mFloaterDataMap;
+	
+	LLTabContainerCommon::TabPosition mTabPos;
+	BOOL				mAutoResize;
+};
+
+
+extern LLFloaterView* gFloaterView;
+
+#endif  // LL_FLOATER_H
+
diff --git a/indra/llui/llfocusmgr.cpp b/indra/llui/llfocusmgr.cpp
new file mode 100644
index 0000000000..030fbf0653
--- /dev/null
+++ b/indra/llui/llfocusmgr.cpp
@@ -0,0 +1,369 @@
+/** 
+ * @file llfocusmgr.cpp
+ * @brief LLFocusMgr base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llfocusmgr.h"
+#include "lluictrl.h"
+#include "v4color.h"
+
+const F32 FOCUS_FADE_TIME = 0.3f;
+
+LLFocusMgr gFocusMgr;
+
+LLFocusMgr::LLFocusMgr()
+	:
+	mLockedView( NULL ),
+	mKeyboardLockedFocusLostCallback( NULL ),
+	mMouseCaptor( NULL ),
+	mMouseCaptureLostCallback( NULL ),
+	mKeyboardFocus( NULL ),
+	mDefaultKeyboardFocus( NULL ),
+	mKeyboardFocusLostCallback( NULL ),
+	mTopView( NULL ),
+	mTopViewLostCallback( NULL ),
+	mFocusWeight(0.f),
+	mAppHasFocus(TRUE)   // Macs don't seem to notify us that we've gotten focus, so default to true
+	#ifdef _DEBUG
+		, mMouseCaptorName("none")
+		, mKeyboardFocusName("none")
+		, mTopViewName("none")
+	#endif
+{
+}
+
+LLFocusMgr::~LLFocusMgr()
+{
+	mFocusHistory.clear();
+}
+
+void LLFocusMgr::releaseFocusIfNeeded( LLView* view )
+{
+	if( childHasMouseCapture( view ) )
+	{
+		setMouseCapture( NULL, NULL );
+	}
+
+	if( childHasKeyboardFocus( view ))
+	{
+		if (view == mLockedView)
+		{
+			mLockedView = NULL;
+			mKeyboardLockedFocusLostCallback = NULL;
+			setKeyboardFocus( NULL, NULL );
+		}
+		else
+		{
+			setKeyboardFocus( mLockedView, mKeyboardLockedFocusLostCallback );
+		}
+	}
+
+	if( childIsTopView( view ) )
+	{
+		setTopView( NULL, NULL );
+	}
+}
+
+
+void LLFocusMgr::setKeyboardFocus(LLUICtrl* new_focus, FocusLostCallback on_focus_lost, BOOL lock)
+{
+	if (mLockedView && 
+		(new_focus == NULL || 
+			(new_focus != mLockedView && !new_focus->hasAncestor(mLockedView))))
+	{
+		// don't allow focus to go to anything that is not the locked focus
+		// or one of its descendants
+		return;
+	}
+	FocusLostCallback old_callback = mKeyboardFocusLostCallback;
+	mKeyboardFocusLostCallback = on_focus_lost;
+
+	//llinfos << "Keyboard focus handled by " << (new_focus ? new_focus->getName() : "nothing") << llendl;
+
+	if( new_focus != mKeyboardFocus )
+	{
+		LLUICtrl* old_focus = mKeyboardFocus;
+		mKeyboardFocus = new_focus;
+
+		// clear out any existing flash
+		if (new_focus)
+		{
+			mFocusWeight = 0.f;
+		}
+		mFocusTimer.reset();
+
+		if( old_callback )
+		{
+			old_callback( old_focus );
+		}
+
+		#ifdef _DEBUG
+			mKeyboardFocusName = new_focus ? new_focus->getName() : "none";
+		#endif
+
+		// If we've got a default keyboard focus, and the caller is
+		// releasing keyboard focus, move to the default.
+		if (mDefaultKeyboardFocus != NULL && new_focus == NULL)
+		{
+			mDefaultKeyboardFocus->setFocus(TRUE);
+		}
+
+		LLView* focus_subtree = new_focus;
+		LLView* viewp = new_focus;
+		// find root-most focus root
+		while(viewp)
+		{
+			if (viewp->isFocusRoot())
+			{
+				focus_subtree = viewp;
+			}
+			viewp = viewp->getParent();
+		}
+
+		
+		if (focus_subtree)
+		{
+			mFocusHistory[focus_subtree->mViewHandle] = new_focus ? new_focus->mViewHandle : LLViewHandle::sDeadHandle; 
+		}
+	}
+	
+	if (lock)
+	{
+		mLockedView = new_focus; 
+		mKeyboardLockedFocusLostCallback = on_focus_lost; 
+	}
+}
+
+void LLFocusMgr::setDefaultKeyboardFocus(LLUICtrl* default_focus)
+{
+	mDefaultKeyboardFocus = default_focus;
+}
+
+// Returns TRUE is parent or any descedent of parent has keyboard focus.
+BOOL LLFocusMgr::childHasKeyboardFocus(const LLView* parent ) const
+{
+	LLView* focus_view = mKeyboardFocus;
+	while( focus_view )
+	{
+		if( focus_view == parent )
+		{
+			return TRUE;
+		}
+		focus_view = focus_view->getParent();
+	}
+	return FALSE;
+}
+
+// Returns TRUE is parent or any descedent of parent is the mouse captor.
+BOOL LLFocusMgr::childHasMouseCapture( LLView* parent )
+{
+	if( mMouseCaptor && mMouseCaptor->isView() )
+	{
+		LLView* captor_view = (LLView*)mMouseCaptor;
+		while( captor_view )
+		{
+			if( captor_view == parent )
+			{
+				return TRUE;
+			}
+			captor_view = captor_view->getParent();
+		}
+	}
+	return FALSE;
+}
+
+void LLFocusMgr::removeKeyboardFocusWithoutCallback( LLView* focus )
+{
+	// should be ok to unlock here, as you have to know the locked view
+	// in order to unlock it
+	if (focus == mLockedView)
+	{
+		mLockedView = NULL;
+		mKeyboardLockedFocusLostCallback = NULL;
+	}
+
+	if( mKeyboardFocus == focus )
+	{
+		mKeyboardFocus = NULL;
+		mKeyboardFocusLostCallback = NULL;
+		#ifdef _DEBUG
+			mKeyboardFocusName = "none";
+		#endif
+	}
+}
+
+
+void LLFocusMgr::setMouseCapture( LLMouseHandler* new_captor, void (*on_capture_lost)(LLMouseHandler* old_captor) )
+{
+	//if (mFocusLocked)
+	//{
+	//	return;
+	//}
+
+	void (*old_callback)(LLMouseHandler*) = mMouseCaptureLostCallback;
+	mMouseCaptureLostCallback = on_capture_lost;
+
+	if( new_captor != mMouseCaptor )
+	{
+		LLMouseHandler* old_captor = mMouseCaptor;
+		mMouseCaptor = new_captor;
+		/*
+		if (new_captor)
+		{
+			if ( new_captor->getName() == "Stickto")
+			{
+				llinfos << "New mouse captor: " << new_captor->getName() << llendl;
+			}
+			else
+			{
+				llinfos << "New mouse captor: " << new_captor->getName() << llendl;
+			}
+		}
+		else
+		{
+			llinfos << "New mouse captor: NULL" << llendl;
+		}
+		*/
+
+		if( old_callback )
+		{
+			old_callback( old_captor );
+		}
+
+		#ifdef _DEBUG
+			mMouseCaptorName = new_captor ? new_captor->getName() : "none";
+		#endif
+	}
+}
+
+void LLFocusMgr::removeMouseCaptureWithoutCallback( LLMouseHandler* captor )
+{
+	//if (mFocusLocked)
+	//{
+	//	return;
+	//}
+	if( mMouseCaptor == captor )
+	{
+		mMouseCaptor = NULL;
+		mMouseCaptureLostCallback = NULL;
+		#ifdef _DEBUG
+			mMouseCaptorName = "none";
+		#endif
+	}
+}
+
+
+BOOL LLFocusMgr::childIsTopView( LLView* parent )
+{
+	LLView* top_view = mTopView;
+	while( top_view )
+	{
+		if( top_view == parent )
+		{
+			return TRUE;
+		}
+		top_view = top_view->getParent();
+	}
+	return FALSE;
+}
+
+
+
+// set new_top = NULL to release top_view.
+void LLFocusMgr::setTopView( LLView* new_top, void (*on_top_lost)(LLView* old_top)  )
+{
+	void (*old_callback)(LLView*) = mTopViewLostCallback;
+	mTopViewLostCallback = on_top_lost;
+
+	if( new_top != mTopView )
+	{
+		LLView* old_top = mTopView;
+		mTopView = new_top;
+		if( old_callback )
+		{
+			old_callback( old_top );
+		}
+
+		mTopView = new_top;
+
+		#ifdef _DEBUG
+			mTopViewName = new_top ? new_top->getName() : "none";
+		#endif
+	}
+}
+
+void LLFocusMgr::removeTopViewWithoutCallback( LLView* top_view )
+{
+	if( mTopView == top_view )
+	{
+		mTopView = NULL;
+		mTopViewLostCallback = NULL;
+		#ifdef _DEBUG
+			mTopViewName = "none";
+		#endif
+	}
+}
+
+void LLFocusMgr::unlockFocus()
+{
+	mLockedView = NULL; 
+	mKeyboardLockedFocusLostCallback = NULL;
+}
+
+F32 LLFocusMgr::getFocusFlashAmt()
+{
+	return clamp_rescale(getFocusTime(), 0.f, FOCUS_FADE_TIME, mFocusWeight, 0.f);
+}
+
+LLColor4 LLFocusMgr::getFocusColor()
+{
+	LLColor4 focus_color = lerp(LLUI::sColorsGroup->getColor( "FocusColor" ), LLColor4::white, getFocusFlashAmt());
+	// de-emphasize keyboard focus when app has lost focus (to avoid typing into wrong window problem)
+	if (!mAppHasFocus)
+	{
+		focus_color.mV[VALPHA] *= 0.4f;
+	}
+	return focus_color;
+}
+
+void LLFocusMgr::triggerFocusFlash()
+{
+	mFocusTimer.reset();
+	mFocusWeight = 1.f;
+}
+
+void LLFocusMgr::setAppHasFocus(BOOL focus) 
+{ 
+	if (!mAppHasFocus && focus)
+	{
+		triggerFocusFlash();
+	}
+	mAppHasFocus = focus; 
+}
+
+LLUICtrl* LLFocusMgr::getLastFocusForGroup(LLView* subtree_root)
+{
+	if (subtree_root)
+	{
+		focus_history_map_t::iterator found_it = mFocusHistory.find(subtree_root->mViewHandle);
+		if (found_it != mFocusHistory.end())
+		{
+			// found last focus for this subtree
+			return static_cast<LLUICtrl*>(LLView::getViewByHandle(found_it->second));
+		}
+	}
+	return NULL;
+}
+
+void LLFocusMgr::clearLastFocusForGroup(LLView* subtree_root)
+{
+	if (subtree_root)
+	{
+		mFocusHistory.erase(subtree_root->mViewHandle);
+	}
+}
diff --git a/indra/llui/llfocusmgr.h b/indra/llui/llfocusmgr.h
new file mode 100644
index 0000000000..cb555fca91
--- /dev/null
+++ b/indra/llui/llfocusmgr.h
@@ -0,0 +1,102 @@
+/** 
+ * @file llfocusmgr.h
+ * @brief LLFocusMgr base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Singleton that manages keyboard and mouse focus
+
+#ifndef LL_LLFOCUSMGR_H
+#define LL_LLFOCUSMGR_H
+
+#include "llstring.h"
+#include "llframetimer.h"
+#include "llview.h"
+
+class LLUICtrl;
+class LLMouseHandler;
+
+class LLFocusMgr
+{
+public:
+	typedef void (*FocusLostCallback)(LLUICtrl*);
+
+	LLFocusMgr();
+	~LLFocusMgr();
+
+	// Mouse Captor
+	void			setMouseCapture(LLMouseHandler* new_captor,void (*on_capture_lost)(LLMouseHandler* old_captor));	// new_captor = NULL to release the mouse.
+	LLMouseHandler* getMouseCapture() { return mMouseCaptor; } 
+	void			removeMouseCaptureWithoutCallback( LLMouseHandler* captor );
+	BOOL			childHasMouseCapture( LLView* parent );
+
+	// Keyboard Focus
+	void			setKeyboardFocus(LLUICtrl* new_focus, FocusLostCallback on_focus_lost, BOOL lock = FALSE);		// new_focus = NULL to release the focus.
+	LLUICtrl*		getKeyboardFocus() const { return mKeyboardFocus; }  
+	BOOL			childHasKeyboardFocus( const LLView* parent ) const;
+	void			removeKeyboardFocusWithoutCallback( LLView* focus );
+	FocusLostCallback getFocusCallback() { return mKeyboardFocusLostCallback; }
+	F32				getFocusTime() const { return mFocusTimer.getElapsedTimeF32(); }
+	F32				getFocusFlashAmt();
+	LLColor4		getFocusColor();
+	void			triggerFocusFlash();
+	BOOL			getAppHasFocus() { return mAppHasFocus; }
+	void			setAppHasFocus(BOOL focus);
+	LLUICtrl*		getLastFocusForGroup(LLView* subtree_root);
+	void			clearLastFocusForGroup(LLView* subtree_root);
+
+	// If setKeyboardFocus(NULL) is called, and there is a non-NULL default
+	// keyboard focus view, focus goes there. JC
+	void			setDefaultKeyboardFocus(LLUICtrl* default_focus);
+	LLUICtrl*		getDefaultKeyboardFocus() const { return mDefaultKeyboardFocus; }
+
+	
+	// Top View
+	void			setTopView(LLView* new_top, void (*on_top_lost)(LLView* old_top));
+	LLView*			getTopView() const					{ return mTopView; }
+	void			removeTopViewWithoutCallback( LLView* top_view );
+	BOOL			childIsTopView( LLView* parent );
+
+	// All Three
+	void			releaseFocusIfNeeded( LLView* top_view );
+	void			unlockFocus();
+	BOOL			focusLocked() { return mLockedView != NULL; }
+
+protected:
+	LLUICtrl*			mLockedView;
+	FocusLostCallback mKeyboardLockedFocusLostCallback;
+
+	// Mouse Captor
+	LLMouseHandler*		mMouseCaptor;				// Mouse events are premptively routed to this object
+	void				(*mMouseCaptureLostCallback)(LLMouseHandler*);	// The object to which mouse events are routed is called before another object takes its place
+
+	// Keyboard Focus
+	LLUICtrl*			mKeyboardFocus;				// Keyboard events are preemptively routed to this object
+	LLUICtrl*			mDefaultKeyboardFocus;
+	FocusLostCallback	mKeyboardFocusLostCallback;	// The object to which keyboard events are routed is called before another object takes its place
+
+	// Top View
+	LLView*				mTopView;
+	void				(*mTopViewLostCallback)(LLView*);
+
+	LLFrameTimer		mFocusTimer;
+	F32					mFocusWeight;
+
+	BOOL				mAppHasFocus;
+
+	typedef std::map<LLViewHandle, LLViewHandle> focus_history_map_t;
+	focus_history_map_t mFocusHistory;
+
+	#ifdef _DEBUG
+		LLString		mMouseCaptorName;
+		LLString		mKeyboardFocusName;
+		LLString		mTopViewName;
+	#endif
+};
+
+extern LLFocusMgr gFocusMgr;
+
+#endif  // LL_LLFOCUSMGR_H
+
diff --git a/indra/llui/lliconctrl.cpp b/indra/llui/lliconctrl.cpp
new file mode 100644
index 0000000000..006334fa4e
--- /dev/null
+++ b/indra/llui/lliconctrl.cpp
@@ -0,0 +1,139 @@
+/** 
+ * @file lliconctrl.cpp
+ * @brief LLIconCtrl base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "lliconctrl.h"
+
+// Linden library includes 
+
+// Project includes
+#include "llcontrol.h"
+#include "llui.h"
+#include "lluictrlfactory.h"
+
+const F32 RESOLUTION_BUMP = 1.f;
+
+LLIconCtrl::LLIconCtrl(const LLString& name, const LLRect &rect, const LLUUID &image_id)
+:	LLUICtrl(name, 
+			 rect, 
+			 FALSE, // mouse opaque
+			 NULL, NULL, 
+			 FOLLOWS_LEFT | FOLLOWS_TOP),
+	mColor( LLColor4::white ),
+	mImageName("")
+{
+	setImage( image_id );
+	setTabStop(FALSE);
+}
+
+LLIconCtrl::LLIconCtrl(const LLString& name, const LLRect &rect, const LLString &image_name)
+:	LLUICtrl(name, 
+			 rect, 
+			 FALSE, // mouse opaque
+			 NULL, NULL, 
+			 FOLLOWS_LEFT | FOLLOWS_TOP),
+	mColor( LLColor4::white ),
+	mImageName(image_name)
+{
+	LLUUID image_id;
+	image_id.set(LLUI::sAssetsGroup->getString( image_name ));
+	setImage( image_id );
+	setTabStop(FALSE);
+}
+
+
+LLIconCtrl::~LLIconCtrl()
+{
+	mImagep = NULL;
+}
+
+
+void LLIconCtrl::setImage(const LLUUID &image_id)
+{
+	mImageID = image_id;
+	mImagep = LLUI::sImageProvider->getUIImageByID(image_id);
+}
+
+
+void LLIconCtrl::draw()
+{
+	if( getVisible() ) 
+	{
+		// Border
+		BOOL has_image = !mImageID.isNull();
+
+		if( has_image )
+		{
+			if( mImagep.notNull() )
+			{
+				gl_draw_scaled_image(0, 0, 
+									 mRect.getWidth(), mRect.getHeight(), 
+									 mImagep,
+									 mColor );
+			}
+		}
+
+		LLUICtrl::draw();
+	}
+}
+
+// virtual
+void LLIconCtrl::setValue(const LLSD& value )
+{
+	setImage(value.asUUID());
+}
+
+// virtual
+LLSD LLIconCtrl::getValue() const
+{
+	LLSD ret = getImage();
+	return ret;
+}
+
+// virtual
+LLXMLNodePtr LLIconCtrl::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	if (mImageName != "")
+	{
+		node->createChild("image_name", TRUE)->setStringValue(mImageName);
+	}
+
+	node->createChild("color", TRUE)->setFloatValue(4, mColor.mV);
+
+	return node;
+}
+
+LLView* LLIconCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("icon");
+	node->getAttributeString("name", name);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	LLUUID image_id;
+	if (node->hasAttribute("image_name"))
+	{
+		LLString image_name;
+		node->getAttributeString("image_name", image_name);
+		image_id.set(LLUI::sAssetsGroup->getString( image_name ));
+	}
+
+	LLColor4 color(LLColor4::white);
+	LLUICtrlFactory::getAttributeColor(node,"color", color);
+
+	LLIconCtrl* icon = new LLIconCtrl(name, rect, image_id);
+	icon->setColor(color);
+
+	icon->initFromXML(node, parent);
+
+	return icon;
+}
diff --git a/indra/llui/lliconctrl.h b/indra/llui/lliconctrl.h
new file mode 100644
index 0000000000..ea762982a2
--- /dev/null
+++ b/indra/llui/lliconctrl.h
@@ -0,0 +1,55 @@
+/** 
+ * @file lliconctrl.h
+ * @brief LLIconCtrl base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLICONCTRL_H
+#define LL_LLICONCTRL_H
+
+#include "lluuid.h"
+#include "v4color.h"
+#include "lluictrl.h"
+#include "stdenums.h"
+#include "llimagegl.h"
+
+class LLTextBox;
+
+//
+// Classes
+//
+class LLIconCtrl
+: public LLUICtrl
+{
+public:
+	LLIconCtrl(const LLString& name, const LLRect &rect, const LLUUID &image_id);
+	LLIconCtrl(const LLString& name, const LLRect &rect, const LLString &image_name);
+	virtual ~LLIconCtrl();
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_ICON; }
+	virtual LLString getWidgetTag() const { return LL_ICON_CTRL_TAG; }
+
+	// llview overrides
+	virtual void	draw();
+
+	void			setImage(const LLUUID &image_id);
+	const LLUUID	&getImage() const						{ return mImageID; }
+
+	// Takes a UUID, wraps get/setImage
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+
+	void			setColor(const LLColor4& color) { mColor = color; }
+
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+protected:
+	LLColor4		mColor;
+	LLString		mImageName;
+	LLUUID			mImageID;
+	LLPointer<LLImageGL>	mImagep;
+};
+
+#endif
diff --git a/indra/llui/llkeywords.cpp b/indra/llui/llkeywords.cpp
new file mode 100644
index 0000000000..e8628c9374
--- /dev/null
+++ b/indra/llui/llkeywords.cpp
@@ -0,0 +1,502 @@
+/** 
+ * @file llkeywords.cpp
+ * @brief Keyword list for LSL
+ *
+ * Copyright (c) 2000-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include <iostream>
+#include <fstream>
+
+#include "llkeywords.h"
+#include "lltexteditor.h"
+#include "llstl.h"
+#include <boost/tokenizer.hpp>
+
+const U32 KEYWORD_FILE_CURRENT_VERSION = 2;
+
+inline BOOL LLKeywordToken::isHead(const llwchar* s)
+{
+	// strncmp is much faster than string compare
+	BOOL res = TRUE;
+	const llwchar* t = mToken.c_str();
+	S32 len = mToken.size();
+	for (S32 i=0; i<len; i++)
+	{
+		if (s[i] != t[i])
+		{
+			res = FALSE;
+			break;
+		}
+	}
+	return res;
+}
+
+LLKeywords::LLKeywords() : mLoaded(FALSE)
+{
+}
+
+LLKeywords::~LLKeywords()
+{
+	std::for_each(mWordTokenMap.begin(), mWordTokenMap.end(), DeletePairedPointer());
+	std::for_each(mLineTokenList.begin(), mLineTokenList.end(), DeletePointer());
+	std::for_each(mDelimiterTokenList.begin(), mDelimiterTokenList.end(), DeletePointer());
+}
+
+BOOL LLKeywords::loadFromFile( const LLString& filename )
+{
+	mLoaded = FALSE;
+
+	////////////////////////////////////////////////////////////
+	// File header
+
+	const S32 BUFFER_SIZE = 1024;
+	char	buffer[BUFFER_SIZE];
+
+	llifstream file;
+	file.open(filename.c_str());
+	if( file.fail() )
+	{
+		llinfos << "LLKeywords::loadFromFile()  Unable to open file: " << filename << llendl;
+		return mLoaded;
+	}
+
+	// Identifying string
+	file >> buffer;
+	if( strcmp( buffer, "llkeywords" ) )
+	{
+		llinfos << filename << " does not appear to be a keyword file" << llendl;
+		return mLoaded;
+	}
+
+	// Check file version
+	file >> buffer;
+	U32	version_num;
+	file >> version_num;
+	if( strcmp(buffer, "version") || version_num != (U32)KEYWORD_FILE_CURRENT_VERSION )
+	{
+		llinfos << filename << " does not appear to be a version " << KEYWORD_FILE_CURRENT_VERSION << " keyword file" << llendl;
+		return mLoaded;
+	}
+
+	// start of line (SOL)
+	const char SOL_COMMENT[] = "#";
+	const char SOL_WORD[] = "[word ";
+	const char SOL_LINE[] = "[line ";
+	const char SOL_ONE_SIDED_DELIMITER[] = "[one_sided_delimiter ";
+	const char SOL_TWO_SIDED_DELIMITER[] = "[two_sided_delimiter ";
+
+	LLColor3 cur_color( 1, 0, 0 );
+	LLKeywordToken::TOKEN_TYPE cur_type = LLKeywordToken::WORD;
+
+	while (!file.eof())
+	{
+		file.getline( buffer, BUFFER_SIZE );
+		if( !strncmp( buffer, SOL_COMMENT, strlen(SOL_COMMENT) ) )
+		{
+			continue;
+		}
+		else
+		if( !strncmp( buffer, SOL_WORD, strlen(SOL_WORD) ) )
+		{
+			cur_color = readColor( buffer + strlen(SOL_WORD) );
+			cur_type = LLKeywordToken::WORD;
+			continue;
+		}
+		else
+		if( !strncmp( buffer, SOL_LINE, strlen(SOL_LINE) ) )
+		{
+			cur_color = readColor( buffer + strlen(SOL_LINE) );
+			cur_type = LLKeywordToken::LINE;
+			continue;
+		}
+		else
+		if( !strncmp( buffer, SOL_TWO_SIDED_DELIMITER, strlen(SOL_TWO_SIDED_DELIMITER) ) )
+		{
+			cur_color = readColor( buffer + strlen(SOL_TWO_SIDED_DELIMITER) );
+			cur_type = LLKeywordToken::TWO_SIDED_DELIMITER;
+			continue;
+		}
+		if( !strncmp( buffer, SOL_ONE_SIDED_DELIMITER, strlen(SOL_ONE_SIDED_DELIMITER) ) )
+		{
+			cur_color = readColor( buffer + strlen(SOL_ONE_SIDED_DELIMITER) );
+			cur_type = LLKeywordToken::ONE_SIDED_DELIMITER;
+			continue;
+		}
+
+		LLString token_buffer( buffer );
+		LLString::trim(token_buffer);
+		
+		typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+		boost::char_separator<char> sep_word("", " \t");
+		tokenizer word_tokens(token_buffer, sep_word);
+		tokenizer::iterator token_word_iter = word_tokens.begin();
+
+		if( !token_buffer.empty() && token_word_iter != word_tokens.end() )
+		{
+			// first word is keyword
+			LLString keyword = (*token_word_iter);
+			LLString::trim(keyword);
+
+			// following words are tooltip
+			LLString tool_tip;
+			while (++token_word_iter != word_tokens.end())
+			{
+				tool_tip += (*token_word_iter);
+			}
+			LLString::trim(tool_tip);
+			
+			if( !tool_tip.empty() )
+			{
+				// Replace : with \n for multi-line tool tips.
+				LLString::replaceChar( tool_tip, ':', '\n' );
+				addToken(cur_type, keyword, cur_color, tool_tip );
+			}
+			else
+			{
+				addToken(cur_type, keyword, cur_color, NULL );
+			}
+		}
+	}
+
+	file.close();
+
+	mLoaded = TRUE;
+	return mLoaded;
+}
+
+// Add the token as described
+void LLKeywords::addToken(LLKeywordToken::TOKEN_TYPE type,
+						  const LLString& key_in,
+						  const LLColor3& color,
+						  const LLString& tool_tip_in )
+{
+	LLWString key = utf8str_to_wstring(key_in);
+	LLWString tool_tip = utf8str_to_wstring(tool_tip_in);
+	switch(type)
+	{
+	case LLKeywordToken::WORD:
+		mWordTokenMap[key] = new LLKeywordToken(type, color, key, tool_tip);
+		break;
+
+	case LLKeywordToken::LINE:
+		mLineTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip));
+		break;
+
+	case LLKeywordToken::TWO_SIDED_DELIMITER:
+	case LLKeywordToken::ONE_SIDED_DELIMITER:
+		mDelimiterTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip));
+		break;
+
+	default:
+		llassert(0);
+	}
+}
+
+LLColor3 LLKeywords::readColor( const LLString& s )
+{
+	F32 r, g, b;
+	r = g = b = 0.0f;
+	S32 read = sscanf(s.c_str(), "%f, %f, %f]", &r, &g, &b );
+	if( read != 3 )
+	{
+		llinfos << " poorly formed color in keyword file" << llendl;
+	}
+	return LLColor3( r, g, b );
+}
+
+// Walk through a string, applying the rules specified by the keyword token list and
+// create a list of color segments.
+void LLKeywords::findSegments(std::vector<LLTextSegment *>* seg_list, const LLWString& wtext)
+{
+	std::for_each(seg_list->begin(), seg_list->end(), DeletePointer());
+	seg_list->clear();
+
+	if( wtext.empty() )
+	{
+		return;
+	}
+	
+	S32 text_len = wtext.size();
+
+	seg_list->push_back( new LLTextSegment( LLColor3(0,0,0), 0, text_len ) );
+
+	const llwchar* base = wtext.c_str();
+	const llwchar* cur = base;
+	const llwchar* line = NULL;
+
+	while( *cur )
+	{
+		if( *cur == '\n' || cur == base )
+		{
+			if( *cur == '\n' )
+			{
+				cur++;
+				if( !*cur || *cur == '\n' )
+				{
+					continue;
+				}
+			}
+
+			// Start of a new line
+			line = cur;
+
+			// Skip white space
+			while( *cur && isspace(*cur) && (*cur != '\n')  )
+			{
+				cur++;
+			}
+			if( !*cur || *cur == '\n' )
+			{
+				continue;
+			}
+
+			// cur is now at the first non-whitespace character of a new line	
+		
+			// Line start tokens
+			{
+				BOOL line_done = FALSE;
+				for (token_list_t::iterator iter = mLineTokenList.begin();
+					 iter != mLineTokenList.end(); ++iter)
+				{
+					LLKeywordToken* cur_token = *iter;
+					if( cur_token->isHead( cur ) )
+					{
+						S32 seg_start = cur - base;
+						while( *cur && *cur != '\n' )
+						{
+							// skip the rest of the line
+							cur++;
+						}
+						S32 seg_end = cur - base;
+						
+						//llinfos << "Seg: [" << (char*)LLString( base, seg_start, seg_end-seg_start) << "]" << llendl;
+						LLTextSegment* text_segment = new LLTextSegment( cur_token->getColor(), seg_start, seg_end );
+						text_segment->setToken( cur_token );
+						insertSegment( seg_list, text_segment, text_len);
+						line_done = TRUE; // to break out of second loop.
+						break;
+					}
+				}
+
+				if( line_done )
+				{
+					continue;
+				}
+			}
+		}
+
+		// Skip white space
+		while( *cur && isspace(*cur) && (*cur != '\n')  )
+		{
+			cur++;
+		}
+
+		while( *cur && *cur != '\n' )
+		{
+			// Check against delimiters
+			{
+				S32 seg_start = 0;
+				LLKeywordToken* cur_delimiter = NULL;
+				for (token_list_t::iterator iter = mDelimiterTokenList.begin();
+					 iter != mDelimiterTokenList.end(); ++iter)
+				{
+					LLKeywordToken* delimiter = *iter;
+					if( delimiter->isHead( cur ) )
+					{
+						cur_delimiter = delimiter;
+						break;
+					}
+				}
+
+				if( cur_delimiter )
+				{
+					S32 between_delimiters = 0;
+					S32 seg_end = 0;
+
+					seg_start = cur - base;
+					cur += cur_delimiter->getLength();
+					
+					if( cur_delimiter->getType() == LLKeywordToken::TWO_SIDED_DELIMITER )
+					{
+						while( *cur && !cur_delimiter->isHead(cur))
+						{
+							// Check for an escape sequence.
+							if (*cur == '\\')
+							{
+								// Count the number of backslashes.
+								S32 num_backslashes = 0;
+								while (*cur == '\\')
+								{
+									num_backslashes++;
+									between_delimiters++;
+									cur++;
+								}
+								// Is the next character the end delimiter?
+								if (cur_delimiter->isHead(cur))
+								{
+									// Is there was an odd number of backslashes, then this delimiter
+									// does not end the sequence.
+									if (num_backslashes % 2 == 1)
+									{
+										between_delimiters++;
+										cur++;
+									}
+									else
+									{
+										// This is an end delimiter.
+										break;
+									}
+								}
+							}
+							else
+							{
+								between_delimiters++;
+								cur++;
+							}
+						}
+
+						if( *cur )
+						{
+							cur += cur_delimiter->getLength();
+							seg_end = seg_start + between_delimiters + 2 * cur_delimiter->getLength();
+						}
+						else
+						{
+							// eof
+							seg_end = seg_start + between_delimiters + cur_delimiter->getLength();
+						}
+					}
+					else
+					{
+						llassert( cur_delimiter->getType() == LLKeywordToken::ONE_SIDED_DELIMITER );
+						// Left side is the delimiter.  Right side is eol or eof.
+						while( *cur && ('\n' != *cur) )
+						{
+							between_delimiters++;
+							cur++;
+						}
+						seg_end = seg_start + between_delimiters + cur_delimiter->getLength();
+					}
+
+
+					//llinfos << "Seg: [" << (char*)LLString( base, seg_start, seg_end-seg_start ) << "]" << llendl;
+					LLTextSegment* text_segment = new LLTextSegment( cur_delimiter->getColor(), seg_start, seg_end );
+					text_segment->setToken( cur_delimiter );
+					insertSegment( seg_list, text_segment, text_len);
+
+					// Note: we don't increment cur, since the end of one delimited seg may be immediately
+					// followed by the start of another one.
+					continue;
+				}
+			}
+
+			// check against words
+			llwchar prev = cur > base ? *(cur-1) : 0;
+			if( !isalnum( prev ) && (prev != '_') )
+			{
+				const llwchar* p = cur;
+				while( isalnum( *p ) || (*p == '_') )
+				{
+					p++;
+				}
+				S32 seg_len = p - cur;
+				if( seg_len > 0 )
+				{
+					LLWString word( cur, 0, seg_len );
+					word_token_map_t::iterator map_iter = mWordTokenMap.find(word);
+					if( map_iter != mWordTokenMap.end() )
+					{
+						LLKeywordToken* cur_token = map_iter->second;
+						S32 seg_start = cur - base;
+						S32 seg_end = seg_start + seg_len;
+
+						// llinfos << "Seg: [" << word.c_str() << "]" << llendl;
+
+
+						LLTextSegment* text_segment = new LLTextSegment( cur_token->getColor(), seg_start, seg_end );
+						text_segment->setToken( cur_token );
+						insertSegment( seg_list, text_segment, text_len);
+					}
+					cur += seg_len; 
+					continue;
+				}
+			}
+
+			if( *cur && *cur != '\n' )
+			{
+				cur++;
+			}
+		}
+	}
+}
+
+void LLKeywords::insertSegment(std::vector<LLTextSegment*>* seg_list, LLTextSegment* new_segment, S32 text_len )
+{
+	LLTextSegment* last = seg_list->back();
+	S32 new_seg_end = new_segment->getEnd();
+
+	if( new_segment->getStart() == last->getStart() )
+	{
+		*last = *new_segment;
+		delete new_segment;
+	}
+	else
+	{
+		last->setEnd( new_segment->getStart() );
+		seg_list->push_back( new_segment );
+	}
+
+	if( new_seg_end < text_len )
+	{
+		seg_list->push_back( new LLTextSegment( LLColor3(0,0,0), new_seg_end, text_len ) );
+	}
+}
+
+#ifdef _DEBUG
+void LLKeywords::dump()
+{
+	llinfos << "LLKeywords" << llendl;
+
+
+	llinfos << "LLKeywords::sWordTokenMap" << llendl;
+	word_token_map_t::iterator word_token_iter = mWordTokenMap.begin();
+	while( word_token_iter != mWordTokenMap.end() )
+	{
+		LLKeywordToken* word_token = word_token_iter->second;
+		word_token->dump();
+		++word_token_iter;
+	}
+
+	llinfos << "LLKeywords::sLineTokenList" << llendl;
+	for (token_list_t::iterator iter = mLineTokenList.begin();
+		 iter != mLineTokenList.end(); ++iter)
+	{
+		LLKeywordToken* line_token = *iter;
+		line_token->dump();
+	}
+
+
+	llinfos << "LLKeywords::sDelimiterTokenList" << llendl;
+	for (token_list_t::iterator iter = mDelimiterTokenList.begin();
+		 iter != mDelimiterTokenList.end(); ++iter)
+	{
+		LLKeywordToken* delimiter_token = *iter;
+		delimiter_token->dump();
+	}
+}
+
+void LLKeywordToken::dump()
+{
+	llinfos << "[" << 
+		mColor.mV[VX] << ", " <<
+		mColor.mV[VY] << ", " <<
+		mColor.mV[VZ] << "] [" <<
+		mToken.c_str() << "]" <<
+		llendl;
+}
+
+#endif  // DEBUG
diff --git a/indra/llui/llkeywords.h b/indra/llui/llkeywords.h
new file mode 100644
index 0000000000..fcf70b77b1
--- /dev/null
+++ b/indra/llui/llkeywords.h
@@ -0,0 +1,91 @@
+/** 
+ * @file llkeywords.h
+ * @brief Keyword list for LSL
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLKEYWORDS_H
+#define LL_LLKEYWORDS_H
+
+
+#include "llstring.h"
+#include "v3color.h"
+#include <map>
+#include <list>
+#include <deque>
+
+class LLTextSegment;
+
+
+class LLKeywordToken
+{
+public:
+	enum TOKEN_TYPE { WORD, LINE, TWO_SIDED_DELIMITER, ONE_SIDED_DELIMITER };
+
+	LLKeywordToken( TOKEN_TYPE type, const LLColor3& color, const LLWString& token, const LLWString& tool_tip ) 
+		:
+		mType( type ),
+		mToken( token ),
+		mColor( color ),
+		mToolTip( tool_tip )
+	{
+	}
+
+	S32					getLength()				{ return mToken.size(); }
+	BOOL				isHead(const llwchar* s);
+	const LLColor3&		getColor()				{ return mColor; }
+	TOKEN_TYPE			getType()				{ return mType; }
+	const LLWString&	getToolTip()			{ return mToolTip; }
+
+#ifdef _DEBUG
+	void		dump();
+#endif
+
+private:
+	TOKEN_TYPE	mType;
+public:
+	LLWString	mToken;
+	LLColor3	mColor;
+private:
+	LLWString	mToolTip;
+};
+
+class LLKeywords
+{
+public:
+	LLKeywords();
+	~LLKeywords();
+
+	BOOL		loadFromFile(const LLString& filename);
+	BOOL		isLoaded()	{ return mLoaded; }
+
+	void		findSegments(std::vector<LLTextSegment *> *seg_list, const LLWString& text );
+
+#ifdef _DEBUG
+	void		dump();
+#endif
+
+	// Add the token as described
+	void addToken(LLKeywordToken::TOKEN_TYPE type,
+					const LLString& key,
+					const LLColor3& color,
+					const LLString& tool_tip = LLString::null);
+
+private:
+	LLColor3	readColor(const LLString& s);
+	void		insertSegment(std::vector<LLTextSegment *> *seg_list, LLTextSegment* new_segment, S32 text_len);
+
+private:
+	BOOL						 mLoaded;
+public:
+	typedef std::map<LLWString, LLKeywordToken*> word_token_map_t;
+	word_token_map_t mWordTokenMap;
+private:
+	typedef std::deque<LLKeywordToken*> token_list_t;
+	token_list_t mLineTokenList;
+	token_list_t mDelimiterTokenList;
+};
+
+#endif  // LL_LLKEYWORDS_H
diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp
new file mode 100644
index 0000000000..41049fdf1f
--- /dev/null
+++ b/indra/llui/lllineeditor.cpp
@@ -0,0 +1,2301 @@
+/** 
+ * @file lllineeditor.cpp
+ * @brief LLLineEditor base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Text editor widget to let users enter a single line.
+
+#include "linden_common.h"
+ 
+#include "lllineeditor.h"
+
+#include "audioengine.h"
+#include "llmath.h"
+#include "llfontgl.h"
+#include "llgl.h"
+#include "sound_ids.h"
+#include "lltimer.h"
+
+//#include "llclipboard.h"
+#include "llcontrol.h"
+#include "llbutton.h"
+#include "llfocusmgr.h"
+#include "llkeyboard.h"
+#include "llrect.h"
+#include "llresmgr.h"
+#include "llstring.h"
+#include "llwindow.h"
+#include "llui.h"
+#include "lluictrlfactory.h"
+#include "llclipboard.h"
+
+//
+// Imported globals
+//
+
+//
+// Constants
+//
+
+const S32	UI_LINEEDITOR_CURSOR_THICKNESS = 2;
+const S32	UI_LINEEDITOR_H_PAD = 2;
+const S32	UI_LINEEDITOR_V_PAD = 1;
+const F32	CURSOR_FLASH_DELAY = 1.0f;  // in seconds
+const S32	SCROLL_INCREMENT_ADD = 0;	// make space for typing
+const S32   SCROLL_INCREMENT_DEL = 4;	// make space for baskspacing
+const F32   AUTO_SCROLL_TIME = 0.05f;
+const F32	LABEL_HPAD = 5.f;
+
+// This is a friend class of and is only used by LLLineEditor
+class LLLineEditorRollback
+{
+public:
+	LLLineEditorRollback( LLLineEditor* ed )
+		:
+		mCursorPos( ed->mCursorPos ),
+		mScrollHPos( ed->mScrollHPos ),
+		mIsSelecting( ed->mIsSelecting ),
+		mSelectionStart( ed->mSelectionStart ),
+		mSelectionEnd( ed->mSelectionEnd )
+	{
+		mText = ed->getText();
+	}
+
+	void doRollback( LLLineEditor* ed )
+	{
+		ed->mCursorPos = mCursorPos;
+		ed->mScrollHPos = mScrollHPos;
+		ed->mIsSelecting = mIsSelecting;
+		ed->mSelectionStart = mSelectionStart;
+		ed->mSelectionEnd = mSelectionEnd;
+		ed->mText = mText;
+	}
+
+	LLString getText()   { return mText; }
+
+private:
+	LLString mText;
+	S32		mCursorPos;
+	S32		mScrollHPos;
+	BOOL	mIsSelecting;
+	S32		mSelectionStart;
+	S32		mSelectionEnd;
+};
+
+
+//
+// Member functions
+//
+ 
+LLLineEditor::LLLineEditor(const LLString& name, const LLRect& rect,
+						   const LLString& default_text, const LLFontGL* font,
+						   S32 max_length_bytes,
+						   void (*commit_callback)(LLUICtrl* caller, void* user_data ),
+						   void (*keystroke_callback)(LLLineEditor* caller, void* user_data ),
+						   void (*focus_lost_callback)(LLLineEditor* caller, void* user_data ),
+						   void* userdata,
+						   LLLinePrevalidateFunc prevalidate_func,
+						   LLViewBorder::EBevel border_bevel,
+						   LLViewBorder::EStyle border_style,
+						   S32 border_thickness)
+	:
+		LLUICtrl( name, rect, TRUE, commit_callback, userdata, FOLLOWS_TOP | FOLLOWS_LEFT ),
+		mMaxLengthChars(max_length_bytes),
+		mMaxLengthBytes(max_length_bytes),
+		mCursorPos( 0 ),
+		mScrollHPos( 0 ),
+		mBorderLeft(0),
+		mBorderRight(0),
+		mCommitOnFocusLost( TRUE ),
+		mKeystrokeCallback( keystroke_callback ),
+		mFocusLostCallback( focus_lost_callback ),
+		mIsSelecting( FALSE ),
+		mSelectionStart( 0 ),
+		mSelectionEnd( 0 ),
+		mLastSelectionX(-1),
+		mLastSelectionY(-1),
+		mPrevalidateFunc( prevalidate_func ),
+		mCursorColor(		LLUI::sColorsGroup->getColor( "TextCursorColor" ) ),
+		mFgColor(			LLUI::sColorsGroup->getColor( "TextFgColor" ) ),
+		mReadOnlyFgColor(	LLUI::sColorsGroup->getColor( "TextFgReadOnlyColor" ) ),
+		mTentativeFgColor(	LLUI::sColorsGroup->getColor( "TextFgTentativeColor" ) ),
+		mWriteableBgColor(	LLUI::sColorsGroup->getColor( "TextBgWriteableColor" ) ),
+		mReadOnlyBgColor(	LLUI::sColorsGroup->getColor( "TextBgReadOnlyColor" ) ),
+		mFocusBgColor(		LLUI::sColorsGroup->getColor( "TextBgFocusColor" ) ),
+		mBorderThickness( border_thickness ),
+		mIgnoreArrowKeys( FALSE ),
+		mIgnoreTab( TRUE ),
+		mDrawAsterixes( FALSE ),
+		mHandleEditKeysDirectly( FALSE ),
+		mSelectAllonFocusReceived( FALSE ),
+		mPassDelete(FALSE),
+		mReadOnly(FALSE)
+{
+	llassert( max_length_bytes > 0 );
+
+	if (font)
+	{
+		mGLFont = font;
+	}
+	else
+	{
+		mGLFont = LLFontGL::sSansSerifSmall;
+	}
+
+	mMinHPixels = mBorderThickness + UI_LINEEDITOR_H_PAD + mBorderLeft;
+	mMaxHPixels = mRect.getWidth() - mMinHPixels - mBorderThickness - mBorderRight;
+
+	mScrollTimer.reset();
+
+	setText(default_text);
+
+	setCursor(mText.length());
+
+	// Scalable UI somehow made these rectangles off-by-one.
+	// I don't know why. JC
+	LLRect border_rect(0, mRect.getHeight()-1, mRect.getWidth()-1, 0);
+	mBorder = new LLViewBorder( "line ed border", border_rect, border_bevel, border_style, mBorderThickness );
+	addChild( mBorder );
+	mBorder->setFollows(FOLLOWS_LEFT|FOLLOWS_RIGHT|FOLLOWS_TOP|FOLLOWS_BOTTOM);
+}
+
+
+LLLineEditor::~LLLineEditor()
+{
+	mFocusLostCallback = NULL;
+	mCommitOnFocusLost = FALSE;
+
+	gFocusMgr.releaseFocusIfNeeded( this );
+
+	if( gEditMenuHandler == this )
+	{
+		gEditMenuHandler = NULL;
+	}
+}
+
+//virtual
+EWidgetType LLLineEditor::getWidgetType() const
+{
+	return WIDGET_TYPE_LINE_EDITOR;
+}
+
+//virtual
+LLString LLLineEditor::getWidgetTag() const
+{
+	return LL_LINE_EDITOR_TAG;
+}
+
+void LLLineEditor::onFocusLost()
+{
+	if( mFocusLostCallback )
+	{
+		mFocusLostCallback( this, mCallbackUserData );
+	}
+	
+	if( mCommitOnFocusLost ) 
+	{
+		onCommit();
+	}
+
+	if( gEditMenuHandler == this )
+	{
+		gEditMenuHandler = NULL;
+	}
+
+	getWindow()->showCursorFromMouseMove();
+}
+
+void LLLineEditor::onCommit()
+{
+	LLUICtrl::onCommit();
+	selectAll();
+}
+
+void LLLineEditor::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	LLUICtrl::reshape(width, height, called_from_parent );
+
+	mMaxHPixels = mRect.getWidth() - 2 * (mBorderThickness + UI_LINEEDITOR_H_PAD) + 1 - mBorderRight;
+}
+
+
+void LLLineEditor::setEnabled(BOOL enabled)
+{
+	mReadOnly = !enabled;
+	setTabStop(!mReadOnly);
+}
+
+
+void LLLineEditor::setMaxTextLength(S32 max_text_length)
+{
+	S32 max_len = llmax(0, max_text_length);
+	mMaxLengthBytes = max_len;
+	mMaxLengthChars = max_len;
+} 
+
+void LLLineEditor::setBorderWidth(S32 left, S32 right)
+{
+	mBorderLeft = llclamp(left, 0, mRect.getWidth());
+	mBorderRight = llclamp(right, 0, mRect.getWidth());
+	mMinHPixels = mBorderThickness + UI_LINEEDITOR_H_PAD + mBorderLeft;
+	mMaxHPixels = mRect.getWidth() - mMinHPixels - mBorderThickness - mBorderRight;
+}
+
+void LLLineEditor::setLabel(const LLString &new_label)
+{
+	mLabel = new_label;
+}
+
+void LLLineEditor::setText(const LLString &new_text)
+{
+	// If new text is identical, don't copy and don't move insertion point
+	if (mText.getString() == new_text)
+	{
+		return;
+	}
+
+	// Check to see if entire field is selected.
+	S32 len = mText.length();
+	BOOL allSelected = (len > 0) && (( mSelectionStart == 0 && mSelectionEnd == len ) 
+		|| ( mSelectionStart == len && mSelectionEnd == 0 ));
+
+	LLString truncated_utf8 = new_text;
+	if (truncated_utf8.size() > (U32)mMaxLengthBytes)
+	{
+		utf8str_truncate(truncated_utf8, mMaxLengthBytes);
+	}
+	mText.assign(truncated_utf8);
+	mText.truncate(mMaxLengthChars);
+
+	if (allSelected)
+	{
+		// ...keep whole thing selected
+		selectAll();
+	}
+	else
+	{
+		// try to preserve insertion point, but deselect text
+		deselect();
+	}
+	setCursor(llmin((S32)mText.length(), getCursor()));
+}
+
+
+// Picks a new cursor position based on the actual screen size of text being drawn.
+void LLLineEditor::setCursorAtLocalPos( S32 local_mouse_x )
+{
+	const llwchar* wtext = mText.getWString().c_str();
+	LLWString asterix_text;
+	if (mDrawAsterixes)
+	{
+		for (S32 i = 0; i < mText.length(); i++)
+		{
+			asterix_text += '*';
+		}
+		wtext = asterix_text.c_str();
+	}
+
+	S32 cursor_pos =
+		mScrollHPos + 
+		mGLFont->charFromPixelOffset(
+			wtext, mScrollHPos,
+			(F32)(local_mouse_x - mMinHPixels),
+			(F32)(mMaxHPixels - mMinHPixels + 1)); // min-max range is inclusive
+	setCursor(cursor_pos);
+}
+
+void LLLineEditor::setCursor( S32 pos )
+{
+	S32 old_cursor_pos = getCursor();
+	mCursorPos = llclamp( pos, 0, mText.length());
+
+	S32 pixels_after_scroll = findPixelNearestPos();
+	if( pixels_after_scroll > mMaxHPixels )
+	{
+		S32 width_chars_to_left = mGLFont->getWidth(mText.getWString().c_str(), 0, mScrollHPos);
+		S32 last_visible_char = mGLFont->maxDrawableChars(mText.getWString().c_str(), llmax(0.f, (F32)(mMaxHPixels - mMinHPixels + width_chars_to_left))); 
+		S32 min_scroll = mGLFont->firstDrawableChar(mText.getWString().c_str(), (F32)(mMaxHPixels - mMinHPixels), mText.length(), getCursor());
+		if (old_cursor_pos == last_visible_char)
+		{
+			mScrollHPos = llmin(mText.length(), llmax(min_scroll, mScrollHPos + SCROLL_INCREMENT_ADD));
+		}
+		else
+		{
+			mScrollHPos = min_scroll;
+		}
+	}
+	else if (getCursor() < mScrollHPos)
+	{
+		if (old_cursor_pos == mScrollHPos)
+		{
+			mScrollHPos = llmax(0, llmin(getCursor(), mScrollHPos - SCROLL_INCREMENT_DEL));
+		}
+		else
+		{
+			mScrollHPos = getCursor();
+		}
+	}
+}
+
+
+void LLLineEditor::setCursorToEnd()
+{
+	setCursor(mText.length());
+	deselect();
+}
+
+BOOL LLLineEditor::canDeselect()
+{
+	return hasSelection();
+}
+
+
+void LLLineEditor::deselect()
+{
+	mSelectionStart = 0;
+	mSelectionEnd = 0;
+	mIsSelecting = FALSE;
+}
+
+
+void LLLineEditor::startSelection()
+{
+	mIsSelecting = TRUE;
+	mSelectionStart = getCursor();
+	mSelectionEnd = getCursor();
+}
+
+void LLLineEditor::endSelection()
+{
+	if( mIsSelecting )
+	{
+		mIsSelecting = FALSE;
+		mSelectionEnd = getCursor();
+	}
+}
+
+BOOL LLLineEditor::canSelectAll()
+{
+	return TRUE;
+}
+
+void LLLineEditor::selectAll()
+{
+	mSelectionStart = mText.length();
+	mSelectionEnd = 0;
+	setCursor(mSelectionEnd);
+	//mScrollHPos = 0;
+	mIsSelecting = TRUE;
+}
+
+
+BOOL LLLineEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	setFocus( TRUE );
+
+	if (mSelectionEnd == 0 && mSelectionStart == mText.length())
+	{
+		// if everything is selected, handle this as a normal click to change insertion point
+		handleMouseDown(x, y, mask);
+	}
+	else
+	{
+		// otherwise select everything
+		selectAll();
+	}
+
+	// We don't want handleMouseUp() to "finish" the selection (and thereby
+	// set mSelectionEnd to where the mouse is), so we finish the selection 
+	// here.
+	mIsSelecting = FALSE;  
+
+	// delay cursor flashing
+	mKeystrokeTimer.reset();
+
+	return TRUE;
+}
+
+BOOL LLLineEditor::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	if (x < mBorderLeft || x > (mRect.getWidth() - mBorderRight))
+	{
+		return LLUICtrl::handleMouseDown(x, y, mask);
+	}
+	if (mSelectAllonFocusReceived
+		&& gFocusMgr.getKeyboardFocus() != this)
+	{
+		setFocus( TRUE );
+	}
+	else
+	{
+		setFocus( TRUE );
+
+		if (mask & MASK_SHIFT)
+		{
+			// Handle selection extension
+			S32 old_cursor_pos = getCursor();
+			setCursorAtLocalPos(x);
+
+			if (hasSelection())
+			{
+				/* Mac-like behavior - extend selection towards the cursor
+				if (getCursor() < mSelectionStart
+					&& getCursor() < mSelectionEnd)
+				{
+					// ...left of selection
+					mSelectionStart = llmax(mSelectionStart, mSelectionEnd);
+					mSelectionEnd = getCursor();
+				}
+				else if (getCursor() > mSelectionStart
+					&& getCursor() > mSelectionEnd)
+				{
+					// ...right of selection
+					mSelectionStart = llmin(mSelectionStart, mSelectionEnd);
+					mSelectionEnd = getCursor();
+				}
+				else
+				{
+					mSelectionEnd = getCursor();
+				}
+				*/
+				// Windows behavior
+				mSelectionEnd = getCursor();
+			}
+			else
+			{
+				mSelectionStart = old_cursor_pos;
+				mSelectionEnd = getCursor();
+			}
+			// assume we're starting a drag select
+			mIsSelecting = TRUE;
+		}
+		else
+		{
+			// Move cursor and deselect for regular click
+			setCursorAtLocalPos( x );
+			deselect();
+			startSelection();
+		}
+
+		gFocusMgr.setMouseCapture( this, &LLLineEditor::onMouseCaptureLost );
+	}
+
+	// delay cursor flashing
+	mKeystrokeTimer.reset();
+
+	return TRUE;
+}
+
+
+BOOL LLLineEditor::handleHover(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = FALSE;
+	if (gFocusMgr.getMouseCapture() != this && (x < mBorderLeft || x > (mRect.getWidth() - mBorderRight)))
+	{
+		return LLUICtrl::handleHover(x, y, mask);
+	}
+
+	if( getVisible() )
+	{
+		if( (gFocusMgr.getMouseCapture() == this) && mIsSelecting )
+		{
+			if (x != mLastSelectionX || y != mLastSelectionY)
+			{
+				mLastSelectionX = x;
+				mLastSelectionY = y;
+			}
+			// Scroll if mouse cursor outside of bounds
+			if (mScrollTimer.hasExpired())
+			{
+				S32 increment = llround(mScrollTimer.getElapsedTimeF32() / AUTO_SCROLL_TIME);
+				mScrollTimer.reset();
+				mScrollTimer.setTimerExpirySec(AUTO_SCROLL_TIME);
+				if( (x < mMinHPixels) && (mScrollHPos > 0 ) )
+				{
+					// Scroll to the left
+					mScrollHPos = llclamp(mScrollHPos - increment, 0, mText.length());
+				}
+				else
+				if( (x > mMaxHPixels) && (mCursorPos < (S32)mText.length()) )
+				{
+					// If scrolling one pixel would make a difference...
+					S32 pixels_after_scrolling_one_char = findPixelNearestPos(1);
+					if( pixels_after_scrolling_one_char >= mMaxHPixels )
+					{
+						// ...scroll to the right
+						mScrollHPos = llclamp(mScrollHPos + increment, 0, mText.length());
+					}
+				}
+			}
+
+			setCursorAtLocalPos( x );
+			mSelectionEnd = getCursor();
+
+			// delay cursor flashing
+			mKeystrokeTimer.reset();
+
+			getWindow()->setCursor(UI_CURSOR_IBEAM);
+			lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;		
+			handled = TRUE;
+		}
+
+		if( !handled  )
+		{
+			getWindow()->setCursor(UI_CURSOR_IBEAM);
+			lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)" << llendl;		
+			handled = TRUE;
+		}
+	}
+
+	return handled;
+}
+
+
+BOOL LLLineEditor::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		gFocusMgr.setMouseCapture( NULL, NULL );
+		handled = TRUE;
+	}
+
+	if (!handled && (x < mBorderLeft || x > (mRect.getWidth() - mBorderRight)))
+	{
+		return LLUICtrl::handleMouseUp(x, y, mask);
+	}
+
+	if( mIsSelecting )
+	{
+		setCursorAtLocalPos( x );
+		mSelectionEnd = getCursor();
+
+		handled = TRUE;
+	}
+
+	if( handled )
+	{
+		// delay cursor flashing
+		mKeystrokeTimer.reset();
+	}
+
+	return handled;
+}
+
+
+// Remove a single character from the text
+void LLLineEditor::removeChar()
+{
+	if( getCursor() > 0 )
+	{
+		mText.erase(getCursor() - 1, 1);
+
+		setCursor(getCursor() - 1);
+	}
+	else
+	{
+		reportBadKeystroke();
+	}
+}
+
+
+void LLLineEditor::addChar(const llwchar uni_char)
+{
+	llwchar new_c = uni_char;
+	if (hasSelection())
+	{
+		deleteSelection();
+	}
+	else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
+	{
+		mText.erase(getCursor(), 1);
+	}
+
+	S32 length_chars = mText.length();
+	S32 cur_bytes = mText.getString().size();;
+	S32 new_bytes = wchar_utf8_length(new_c);
+
+	BOOL allow_char = TRUE;
+
+	// Inserting character
+	if (length_chars == mMaxLengthChars)
+	{
+		allow_char = FALSE;
+	}
+	if ((new_bytes + cur_bytes) > mMaxLengthBytes)
+	{
+		allow_char = FALSE;
+	}
+
+	if (allow_char)
+	{
+		// Will we need to scroll?
+		LLWString w_buf;
+		w_buf.assign(1, new_c);
+
+		mText.insert(getCursor(), w_buf);
+		setCursor(getCursor() + 1);
+	}
+	else
+	{
+		reportBadKeystroke();
+	}
+
+	getWindow()->hideCursorUntilMouseMove();
+}
+
+// Extends the selection box to the new cursor position
+void LLLineEditor::extendSelection( S32 new_cursor_pos )
+{
+	if( !mIsSelecting )
+	{
+		startSelection();
+	}
+	
+	setCursor(new_cursor_pos);
+	mSelectionEnd = getCursor();
+}
+
+
+void LLLineEditor::setSelection(S32 start, S32 end)
+{
+	S32 len = mText.length();
+
+	mIsSelecting = TRUE;
+
+	// JC, yes, this seems odd, but I think you have to presume a 
+	// selection dragged from the end towards the start.
+	mSelectionStart = llclamp(end, 0, len);
+	mSelectionEnd = llclamp(start, 0, len);
+	setCursor(start);
+}
+
+S32 LLLineEditor::prevWordPos(S32 cursorPos) const
+{
+	const LLWString& wtext = mText.getWString();
+	while( (cursorPos > 0) && (wtext[cursorPos-1] == ' ') )
+	{
+		cursorPos--;
+	}
+	while( (cursorPos > 0) && isPartOfWord( wtext[cursorPos-1] ) )
+	{
+		cursorPos--;
+	}
+	return cursorPos;
+}
+
+S32 LLLineEditor::nextWordPos(S32 cursorPos) const
+{
+	const LLWString& wtext = mText.getWString();
+	while( (cursorPos < getLength()) && isPartOfWord( wtext[cursorPos+1] ) )
+	{
+		cursorPos++;
+	} 
+	while( (cursorPos < getLength()) && (wtext[cursorPos+1] == ' ') )
+	{
+		cursorPos++;
+	}
+	return cursorPos;
+}
+
+
+BOOL LLLineEditor::handleSelectionKey(KEY key, MASK mask)
+{
+	BOOL handled = FALSE;
+
+	if( mask & MASK_SHIFT )
+	{
+		handled = TRUE;
+
+		switch( key )
+		{
+		case KEY_LEFT:
+			if (mIgnoreArrowKeys) 
+			{
+				handled = FALSE;
+				break;
+			}
+			if( 0 < getCursor() )
+			{
+				S32 cursorPos = getCursor() - 1;
+				if( mask & MASK_CONTROL )
+				{
+					cursorPos = prevWordPos(cursorPos);
+				}
+				extendSelection( cursorPos );
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			break;
+
+		case KEY_RIGHT:
+			if (mIgnoreArrowKeys) 
+			{
+				handled = FALSE;
+				break;
+			}
+			if( getCursor() < mText.length())
+			{
+				S32 cursorPos = getCursor() + 1;
+				if( mask & MASK_CONTROL )
+				{
+					cursorPos = nextWordPos(cursorPos);
+				}
+				extendSelection( cursorPos );
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			break;
+
+		case KEY_PAGE_UP:
+		case KEY_HOME:
+			if (mIgnoreArrowKeys) 
+			{
+				handled = FALSE;
+				break;
+			}
+			extendSelection( 0 );
+			break;
+		
+		case KEY_PAGE_DOWN:
+		case KEY_END:
+			{
+				if (mIgnoreArrowKeys) 
+				{
+					handled = FALSE;
+					break;
+				}
+				S32 len = mText.length();
+				if( len )
+				{
+					extendSelection( len );
+				}
+				break;
+			}
+
+		default:
+			handled = FALSE;
+			break;
+		}
+	}
+
+	if (!handled && mHandleEditKeysDirectly)
+	{
+		if( (MASK_CONTROL & mask) && ('A' == key) )
+		{
+			if( canSelectAll() )
+			{
+				selectAll();
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+	}
+
+
+	return handled;
+}
+
+void LLLineEditor::deleteSelection()
+{
+	if( !mReadOnly && hasSelection() )
+	{
+		S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+		S32 selection_length = abs( mSelectionStart - mSelectionEnd );
+
+		mText.erase(left_pos, selection_length);
+		deselect();
+		setCursor(left_pos);
+	}
+}
+
+BOOL LLLineEditor::canCut()
+{
+	return !mReadOnly && !mDrawAsterixes && hasSelection();
+}
+
+// cut selection to clipboard
+void LLLineEditor::cut()
+{
+	if( canCut() )
+	{
+		// Prepare for possible rollback
+		LLLineEditorRollback rollback( this );
+
+
+		S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+		S32 length = abs( mSelectionStart - mSelectionEnd );
+		gClipboard.copyFromSubstring( mText.getWString(), left_pos, length );
+		deleteSelection();
+
+		// Validate new string and rollback the if needed.
+		BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
+		if( need_to_rollback )
+		{
+			rollback.doRollback( this );
+			reportBadKeystroke();
+		}
+		else
+		if( mKeystrokeCallback )
+		{
+			mKeystrokeCallback( this, mCallbackUserData );
+		}
+	}
+}
+
+BOOL LLLineEditor::canCopy()
+{
+	return !mDrawAsterixes && hasSelection();
+}
+
+
+// copy selection to clipboard
+void LLLineEditor::copy()
+{
+	if( canCopy() )
+	{
+		S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+		S32 length = abs( mSelectionStart - mSelectionEnd );
+		gClipboard.copyFromSubstring( mText.getWString(), left_pos, length );
+	}
+}
+
+BOOL LLLineEditor::canPaste()
+{
+	return !mReadOnly && gClipboard.canPasteString(); 
+}
+
+
+// paste from clipboard
+void LLLineEditor::paste()
+{
+	if (canPaste())
+	{
+		LLWString paste = gClipboard.getPasteWString();
+		if (!paste.empty())
+		{
+			// Prepare for possible rollback
+			LLLineEditorRollback rollback(this);
+			
+			// Delete any selected characters
+			if (hasSelection())
+			{
+				deleteSelection();
+			}
+
+			// Clean up string (replace tabs and returns and remove characters that our fonts don't support.)
+			LLWString clean_string(paste);
+			LLWString::replaceTabsWithSpaces(clean_string, 1);
+			//clean_string = wstring_detabify(paste, 1);
+			LLWString::replaceChar(clean_string, '\n', ' ');
+
+			// Insert the string
+
+			//check to see that the size isn't going to be larger than the
+			//max number of characters or bytes
+			U32 available_bytes = mMaxLengthBytes - wstring_utf8_length(mText);
+			size_t available_chars = mMaxLengthChars - mText.length();
+
+			if ( available_bytes < (U32) wstring_utf8_length(clean_string) )
+			{
+				llwchar current_symbol = clean_string[0];
+				U32 wchars_that_fit = 0;
+				U32 total_bytes = wchar_utf8_length(current_symbol);
+
+				//loop over the "wide" characters (symbols)
+				//and check to see how large (in bytes) each symbol is.
+				while ( total_bytes <= available_bytes )
+				{
+					//while we still have available bytes
+					//"accept" the current symbol and check the size
+					//of the next one
+					current_symbol = clean_string[++wchars_that_fit];
+					total_bytes += wchar_utf8_length(current_symbol);
+				}
+
+				clean_string = clean_string.substr(0, wchars_that_fit);
+				reportBadKeystroke();
+			}
+			else if (available_chars < clean_string.length())
+			{
+				// We can't insert all the characters.  Insert as many as possible
+				// but make a noise to alert the user. JC
+				clean_string = clean_string.substr(0, available_chars);
+				reportBadKeystroke();
+			}
+
+			mText.insert(getCursor(), clean_string);
+			setCursor(llmin(mMaxLengthChars, getCursor() + (S32)clean_string.length()));
+			deselect();
+
+			// Validate new string and rollback the if needed.
+			BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
+			if( need_to_rollback )
+			{
+				rollback.doRollback( this );
+				reportBadKeystroke();
+			}
+			else
+			if( mKeystrokeCallback )
+			{
+				mKeystrokeCallback( this, mCallbackUserData );
+			}
+		}
+	}
+}
+
+	
+BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)	
+{
+	BOOL handled = FALSE;
+
+	switch( key )
+	{
+	case KEY_INSERT:
+		if (mask == MASK_NONE)
+		{
+			gKeyboard->toggleInsertMode();
+		}
+
+		handled = TRUE;
+		break;
+
+	case KEY_BACKSPACE:
+		if (!mReadOnly)
+		{
+			//llinfos << "Handling backspace" << llendl;
+			if( hasSelection() )
+			{
+				deleteSelection();
+			}
+			else
+			if( 0 < getCursor() )
+			{
+				removeChar();
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+		}
+		handled = TRUE;
+		break;
+
+	case KEY_PAGE_UP:
+	case KEY_HOME:
+		if (!mIgnoreArrowKeys)
+		{
+			setCursor(0);
+			handled = TRUE;
+		}
+		break;
+
+	case KEY_PAGE_DOWN:
+	case KEY_END:
+		if (!mIgnoreArrowKeys)
+		{
+			S32 len = mText.length();
+			if( len )
+			{
+				setCursor(len);
+			}
+			handled = TRUE;
+		}
+		break;
+
+	case KEY_LEFT:
+		if (!mIgnoreArrowKeys)
+		{
+			if( hasSelection() )
+			{
+				setCursor(llmin( getCursor() - 1, mSelectionStart, mSelectionEnd ));
+			}
+			else
+			if( 0 < getCursor() )
+			{
+				S32 cursorPos = getCursor() - 1;
+				if( mask & MASK_CONTROL )
+				{
+					cursorPos = prevWordPos(cursorPos);
+				}
+				setCursor(cursorPos);
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+		break;
+
+	case KEY_RIGHT:
+		if (!mIgnoreArrowKeys)
+		{
+			if (hasSelection())
+			{
+				setCursor(llmax(getCursor() + 1, mSelectionStart, mSelectionEnd));
+			}
+			else
+			if (getCursor() < mText.length())
+			{
+				S32 cursorPos = getCursor() + 1;
+				if( mask & MASK_CONTROL )
+				{
+					cursorPos = nextWordPos(cursorPos);
+				}
+				setCursor(cursorPos);
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	if( !handled && mHandleEditKeysDirectly )
+	{
+		// Standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system.
+		if( KEY_DELETE == key )
+		{
+			if( canDoDelete() )
+			{
+				doDelete();
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+		else
+		if( MASK_CONTROL & mask )
+		{
+			if( 'C' == key )
+			{
+				if( canCopy() )
+				{
+					copy();
+				}
+				else
+				{
+					reportBadKeystroke();
+				}
+				handled = TRUE;
+			}
+			else
+			if( 'V' == key )
+			{
+				if( canPaste() )
+				{
+					paste();
+				}
+				else
+				{
+					reportBadKeystroke();
+				}
+				handled = TRUE;
+			}
+			else
+			if( 'X' == key )
+			{
+				if( canCut() )
+				{
+					cut();
+				}
+				else
+				{
+					reportBadKeystroke();
+				}
+				handled = TRUE;
+			}
+		}
+	}
+	return handled;
+}
+
+
+BOOL LLLineEditor::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent )
+{
+	BOOL	handled = FALSE;
+	BOOL	selection_modified = FALSE;
+
+	if ( (gFocusMgr.getKeyboardFocus() == this) && getVisible())
+	{
+		LLLineEditorRollback rollback( this );
+
+		if( !handled )
+		{
+			handled = handleSelectionKey( key, mask );
+			selection_modified = handled;
+		}
+		
+		// Handle most keys only if the text editor is writeable.
+		if ( !mReadOnly )
+		{
+			if( !handled )
+			{
+				handled = handleSpecialKey( key, mask );
+			}
+		}
+
+		if( handled )
+		{
+			mKeystrokeTimer.reset();
+
+			// Most keystrokes will make the selection box go away, but not all will.
+			if( !selection_modified &&
+				KEY_SHIFT != key &&
+				KEY_CONTROL != key &&
+				KEY_ALT != key &&
+				KEY_CAPSLOCK )
+			{
+				deselect();
+			}
+
+			BOOL need_to_rollback = FALSE;
+
+			// If read-only, don't allow changes
+			need_to_rollback |= (mReadOnly && (mText.getString() == rollback.getText()));
+
+			// Validate new string and rollback the keystroke if needed.
+			need_to_rollback |= (mPrevalidateFunc && !mPrevalidateFunc(mText.getWString()));
+
+			if (need_to_rollback)
+			{
+				rollback.doRollback(this);
+
+				reportBadKeystroke();
+			}
+
+			// Notify owner if requested
+			if (!need_to_rollback && handled)
+			{
+				if (mKeystrokeCallback)
+				{
+					mKeystrokeCallback(this, mCallbackUserData);
+				}
+			}
+		}
+	}
+
+	return handled;
+}
+
+
+BOOL LLLineEditor::handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent)
+{
+	if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
+	{
+		return FALSE;
+	}
+
+	BOOL	handled = FALSE;
+
+	if ( (gFocusMgr.getKeyboardFocus() == this) && getVisible() && !mReadOnly)
+	{
+		handled = TRUE;
+
+		LLLineEditorRollback rollback( this );
+
+		addChar(uni_char);
+
+		mKeystrokeTimer.reset();
+
+		deselect();
+
+		BOOL need_to_rollback = FALSE;
+
+		// Validate new string and rollback the keystroke if needed.
+		need_to_rollback |= ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
+
+		if( need_to_rollback )
+		{
+			rollback.doRollback( this );
+
+			reportBadKeystroke();
+		}
+
+		// Notify owner if requested
+		if( !need_to_rollback && handled )
+		{
+			if( mKeystrokeCallback )
+			{
+				// HACK! The only usage of this callback doesn't do anything with the character.
+				// We'll have to do something about this if something ever changes! - Doug
+				mKeystrokeCallback( this, mCallbackUserData );
+			}
+		}
+	}
+	return handled;
+}
+
+
+BOOL LLLineEditor::canDoDelete()
+{
+	return ( !mReadOnly && (!mPassDelete || (hasSelection() || (getCursor() < mText.length()))) );
+}
+
+void LLLineEditor::doDelete()
+{
+	if (canDoDelete())
+	{
+		// Prepare for possible rollback
+		LLLineEditorRollback rollback( this );
+
+		if (hasSelection())
+		{
+			deleteSelection();
+		}
+		else if ( getCursor() < mText.length())
+		{	
+			setCursor(getCursor() + 1);
+			removeChar();
+		}
+
+		// Validate new string and rollback the if needed.
+		BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
+		if( need_to_rollback )
+		{
+			rollback.doRollback( this );
+			reportBadKeystroke();
+		}
+		else
+		{
+			if( mKeystrokeCallback )
+			{
+				mKeystrokeCallback( this, mCallbackUserData );
+			}
+		}
+	}
+}
+
+
+void LLLineEditor::draw()
+{
+	if( !getVisible() )
+	{
+		return;
+	}
+
+	S32 text_len = mText.length();
+
+	LLString saved_text;
+	if (mDrawAsterixes)
+	{
+		saved_text = mText.getString();
+		LLString text;
+		for (S32 i = 0; i < mText.length(); i++)
+		{
+			text += '*';
+		}
+		mText = text;
+	}
+
+	// draw rectangle for the background
+	LLRect background( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+	background.stretch( -mBorderThickness );
+
+	LLColor4 bg_color = mReadOnlyBgColor;
+
+	// drawing solids requires texturing be disabled
+	{
+		LLGLSNoTexture no_texture;
+		// draw background for text
+		if( !mReadOnly )
+		{
+			if( gFocusMgr.getKeyboardFocus() == this )
+			{
+				bg_color = mFocusBgColor;
+			}
+			else
+			{
+				bg_color = mWriteableBgColor;
+			}
+		}
+		gl_rect_2d(background, bg_color);
+	}
+
+	// draw text
+
+	S32 cursor_bottom = background.mBottom + 1;
+	S32 cursor_top = background.mTop - 1;
+
+	LLColor4 text_color;
+	if (!mReadOnly)
+	{
+		if (!mTentative)
+		{
+			text_color = mFgColor;
+		}
+		else
+		{
+			text_color = mTentativeFgColor;
+		}
+	}
+	else
+	{
+		text_color = mReadOnlyFgColor;
+	}
+	LLColor4 label_color = mTentativeFgColor;
+
+	S32 rendered_text = 0;
+	F32 rendered_pixels_right = (F32)mMinHPixels;
+	F32 text_bottom = (F32)background.mBottom + (F32)UI_LINEEDITOR_V_PAD;
+
+	if( (gFocusMgr.getKeyboardFocus() == this) && hasSelection() )
+	{
+		S32 select_left;
+		S32 select_right;
+		if( mSelectionStart < getCursor() )
+		{
+			select_left = mSelectionStart;
+			select_right = getCursor();
+		}
+		else
+		{
+			select_left = getCursor();
+			select_right = mSelectionStart;
+		}
+		
+		if( select_left > mScrollHPos )
+		{
+			// unselected, left side
+			rendered_text = mGLFont->render( 
+				mText, mScrollHPos,
+				rendered_pixels_right, text_bottom,
+				text_color,
+				LLFontGL::LEFT, LLFontGL::BOTTOM,
+				LLFontGL::NORMAL,
+				select_left - mScrollHPos,
+				mMaxHPixels - llround(rendered_pixels_right),
+				&rendered_pixels_right);
+		}
+		
+		if( (rendered_pixels_right < (F32)mMaxHPixels) && (rendered_text < text_len) )
+		{
+			LLColor4 color(1.f - bg_color.mV[0], 1.f - bg_color.mV[1], 1.f - bg_color.mV[2], 1.f);
+			// selected middle
+			S32 width = mGLFont->getWidth(mText.getWString().c_str(), mScrollHPos + rendered_text, select_right - mScrollHPos - rendered_text);
+			width = llmin(width, mMaxHPixels - llround(rendered_pixels_right));
+			gl_rect_2d(llround(rendered_pixels_right), cursor_top, llround(rendered_pixels_right)+width, cursor_bottom, color);
+
+			rendered_text += mGLFont->render( 
+				mText, mScrollHPos + rendered_text,
+				rendered_pixels_right, text_bottom,
+				LLColor4( 1.f - text_color.mV[0], 1.f - text_color.mV[1], 1.f - text_color.mV[2], 1 ),
+				LLFontGL::LEFT, LLFontGL::BOTTOM,
+				LLFontGL::NORMAL,
+				select_right - mScrollHPos - rendered_text,
+				mMaxHPixels - llround(rendered_pixels_right),
+				&rendered_pixels_right);
+		}
+
+		if( (rendered_pixels_right < (F32)mMaxHPixels) && (rendered_text < text_len) )
+		{
+			// unselected, right side
+			mGLFont->render( 
+				mText, mScrollHPos + rendered_text,
+				rendered_pixels_right, text_bottom,
+				text_color,
+				LLFontGL::LEFT, LLFontGL::BOTTOM,
+				LLFontGL::NORMAL,
+				S32_MAX,
+				mMaxHPixels - llround(rendered_pixels_right),
+				&rendered_pixels_right);
+		}
+	}
+	else
+	{
+		mGLFont->render( 
+			mText, mScrollHPos, 
+			rendered_pixels_right, text_bottom,
+			text_color,
+			LLFontGL::LEFT, LLFontGL::BOTTOM,
+			LLFontGL::NORMAL,
+			S32_MAX,
+			mMaxHPixels - llround(rendered_pixels_right),
+			&rendered_pixels_right);
+	}
+
+	// If we're editing...
+	if( gFocusMgr.getKeyboardFocus() == this)
+	{
+		// (Flash the cursor every half second)
+		if (gShowTextEditCursor && !mReadOnly)
+		{
+			F32 elapsed = mKeystrokeTimer.getElapsedTimeF32();
+			if( (elapsed < CURSOR_FLASH_DELAY ) || (S32(elapsed * 2) & 1) )
+			{
+				S32 cursor_left = findPixelNearestPos();
+				cursor_left -= UI_LINEEDITOR_CURSOR_THICKNESS / 2;
+				S32 cursor_right = cursor_left + UI_LINEEDITOR_CURSOR_THICKNESS;
+				if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection())
+				{
+					const LLWString space(utf8str_to_wstring(LLString(" ")));
+					S32 wswidth = mGLFont->getWidth(space.c_str());
+					S32 width = mGLFont->getWidth(mText.getWString().c_str(), getCursor(), 1) + 1;
+					cursor_right = cursor_left + llmax(wswidth, width);
+				}
+				// Use same color as text for the Cursor
+				gl_rect_2d(cursor_left, cursor_top,
+					cursor_right, cursor_bottom, text_color);
+				if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection())
+				{
+					mGLFont->render(mText, getCursor(), (F32)(cursor_left + UI_LINEEDITOR_CURSOR_THICKNESS / 2), text_bottom, 
+						LLColor4( 1.f - text_color.mV[0], 1.f - text_color.mV[1], 1.f - text_color.mV[2], 1 ),
+						LLFontGL::LEFT, LLFontGL::BOTTOM,
+						LLFontGL::NORMAL,
+						1);
+				}
+			}
+		}
+
+		// Draw children (border)
+		//mBorder->setVisible(TRUE);
+		mBorder->setKeyboardFocusHighlight( TRUE );
+		LLView::draw();
+		mBorder->setKeyboardFocusHighlight( FALSE );
+		//mBorder->setVisible(FALSE);
+	}
+	else // does not have keyboard input
+	{
+		// draw label if no text provided
+		if (0 == mText.length())
+		{
+			mGLFont->render(mLabel.getWString(), 0, 
+							LABEL_HPAD, (F32)text_bottom,
+							label_color,
+							LLFontGL::LEFT, LLFontGL::BOTTOM,
+							LLFontGL::NORMAL,
+							S32_MAX,
+							mMaxHPixels - llround(rendered_pixels_right),
+							&rendered_pixels_right, FALSE);
+		}
+		// Draw children (border)
+		LLView::draw();
+	}
+
+	if (mDrawAsterixes)
+	{
+		mText = saved_text;
+	}
+}
+
+
+// Returns the local screen space X coordinate associated with the text cursor position.
+S32 LLLineEditor::findPixelNearestPos(const S32 cursor_offset)
+{
+	S32 dpos = getCursor() - mScrollHPos + cursor_offset;
+	S32 result = mGLFont->getWidth(mText.getWString().c_str(), mScrollHPos, dpos) + mMinHPixels;
+	return result;
+}
+
+void LLLineEditor::reportBadKeystroke()
+{
+	make_ui_sound("UISndBadKeystroke");
+}
+
+//virtual
+void LLLineEditor::clear()
+{
+	mText.clear();
+	setCursor(0);
+}
+
+//virtual
+void LLLineEditor::onTabInto()
+{
+	selectAll();
+}
+
+//virtual
+BOOL LLLineEditor::acceptsTextInput() const
+{
+	return TRUE;
+}
+
+// Start or stop the editor from accepting text-editing keystrokes
+void LLLineEditor::setFocus( BOOL new_state )
+{
+	BOOL old_state = hasFocus();
+
+	// getting focus when we didn't have it before, and we want to select all
+	if (!old_state && new_state && mSelectAllonFocusReceived)
+	{
+		selectAll();
+		// We don't want handleMouseUp() to "finish" the selection (and thereby
+		// set mSelectionEnd to where the mouse is), so we finish the selection 
+		// here.
+		mIsSelecting = FALSE;
+	}
+
+	if( new_state )
+	{
+		gEditMenuHandler = this;
+
+		// Don't start the cursor flashing right away
+		mKeystrokeTimer.reset();
+	}
+	else
+	{
+		// Not really needed, since loss of keyboard focus should take care of this,
+		// but limited paranoia is ok.
+		if( gEditMenuHandler == this )
+		{
+			gEditMenuHandler = NULL;
+		}
+
+		endSelection();
+	}
+
+	LLUICtrl::setFocus( new_state );
+}
+
+//virtual 
+void LLLineEditor::setRect(const LLRect& rect)
+{
+	LLUICtrl::setRect(rect);
+	if (mBorder)
+	{
+		LLRect border_rect = mBorder->getRect();
+		// Scalable UI somehow made these rectangles off-by-one.
+		// I don't know why. JC
+		border_rect.setOriginAndSize(border_rect.mLeft, border_rect.mBottom, 
+				rect.getWidth()-1, rect.getHeight()-1);
+		mBorder->setRect(border_rect);
+	}
+}
+
+// Limits what characters can be used to [1234567890.-] with [-] only valid in the first position.
+// Does NOT ensure that the string is a well-formed number--that's the job of post-validation--for
+// the simple reasons that intermediate states may be invalid even if the final result is valid.
+// 
+// static
+BOOL LLLineEditor::prevalidateFloat(const LLWString &str)
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	BOOL success = TRUE;
+	LLWString trimmed = str;
+	LLWString::trim(trimmed);
+	S32 len = trimmed.length();
+	if( 0 < len )
+	{
+		// May be a comma or period, depending on the locale
+		char decimal_point = gResMgr->getDecimalPoint();
+
+		S32 i = 0;
+
+		// First character can be a negative sign
+		if( '-' == trimmed[0] )
+		{
+			i++;
+		}
+
+		for( ; i < len; i++ )
+		{
+			if( (decimal_point != trimmed[i] ) && !isdigit( trimmed[i] ) )
+			{
+				success = FALSE;
+				break;
+			}
+		}
+	}		
+
+	return success;
+}
+
+//static
+BOOL LLLineEditor::isPartOfWord(llwchar c) { return (c == '_') || isalnum(c); }
+
+// static
+BOOL LLLineEditor::postvalidateFloat(const LLString &str)
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	BOOL success = TRUE;
+	BOOL has_decimal = FALSE;
+	BOOL has_digit = FALSE;
+
+	LLWString trimmed = utf8str_to_wstring(str);
+	LLWString::trim(trimmed);
+	S32 len = trimmed.length();
+	if( 0 < len )
+	{
+		S32 i = 0;
+
+		// First character can be a negative sign
+		if( '-' == trimmed[0] )
+		{
+			i++;
+		}
+
+		// May be a comma or period, depending on the locale
+		char decimal_point = gResMgr->getDecimalPoint();
+
+		for( ; i < len; i++ )
+		{
+			if( decimal_point == trimmed[i] )
+			{
+				if( has_decimal )
+				{
+					// can't have two
+					success = FALSE;
+					break;
+				}
+				else
+				{
+					has_decimal = TRUE;
+				}
+			}
+			else
+			if( isdigit( trimmed[i] ) )
+			{
+				has_digit = TRUE;
+			}
+			else
+			{
+				success = FALSE;
+				break;
+			}
+		}
+	}		
+
+	// Gotta have at least one
+	success = has_digit;
+
+	return success;
+}
+
+// Limits what characters can be used to [1234567890-] with [-] only valid in the first position.
+// Does NOT ensure that the string is a well-formed number--that's the job of post-validation--for
+// the simple reasons that intermediate states may be invalid even if the final result is valid.
+//
+// static
+BOOL LLLineEditor::prevalidateInt(const LLWString &str)
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	BOOL success = TRUE;
+	LLWString trimmed = str;
+	LLWString::trim(trimmed);
+	S32 len = trimmed.length();
+	if( 0 < len )
+	{
+		S32 i = 0;
+
+		// First character can be a negative sign
+		if( '-' == trimmed[0] )
+		{
+			i++;
+		}
+
+		for( ; i < len; i++ )
+		{
+			if( !isdigit( trimmed[i] ) )
+			{
+				success = FALSE;
+				break;
+			}
+		}
+	}		
+
+	return success;
+}
+
+// static
+BOOL LLLineEditor::prevalidatePositiveS32(const LLWString &str)
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	LLWString trimmed = str;
+	LLWString::trim(trimmed);
+	S32 len = trimmed.length();
+	BOOL success = TRUE;
+	if(0 < len)
+	{
+		if(('-' == trimmed[0]) || ('0' == trimmed[0]))
+		{
+			success = FALSE;
+		}
+		S32 i = 0;
+		while(success && (i < len))
+		{
+			if(!isdigit(trimmed[i++]))
+			{
+				success = FALSE;
+			}
+		}
+	}
+	if (success)
+	{
+		S32 val = strtol(wstring_to_utf8str(trimmed).c_str(), NULL, 10);
+		if (val <= 0)
+		{
+			success = FALSE;
+		}
+	}
+	return success;
+}
+
+BOOL LLLineEditor::prevalidateNonNegativeS32(const LLWString &str)
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	LLWString trimmed = str;
+	LLWString::trim(trimmed);
+	S32 len = trimmed.length();
+	BOOL success = TRUE;
+	if(0 < len)
+	{
+		if('-' == trimmed[0])
+		{
+			success = FALSE;
+		}
+		S32 i = 0;
+		while(success && (i < len))
+		{
+			if(!isdigit(trimmed[i++]))
+			{
+				success = FALSE;
+			}
+		}
+	}
+	if (success)
+	{
+		S32 val = strtol(wstring_to_utf8str(trimmed).c_str(), NULL, 10);
+		if (val < 0)
+		{
+			success = FALSE;
+		}
+	}
+	return success;
+}
+
+BOOL LLLineEditor::prevalidateAlphaNum(const LLWString &str)
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	BOOL rv = TRUE;
+	S32 len = str.length();
+	if(len == 0) return rv;
+	while(len--)
+	{
+		if( !isalnum(str[len]) )
+		{
+			rv = FALSE;
+			break;
+		}
+	}
+	return rv;
+}
+
+// static
+BOOL LLLineEditor::prevalidateAlphaNumSpace(const LLWString &str)
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	BOOL rv = TRUE;
+	S32 len = str.length();
+	if(len == 0) return rv;
+	while(len--)
+	{
+		if(!(isalnum(str[len]) || (' ' == str[len])))
+		{
+			rv = FALSE;
+			break;
+		}
+	}
+	return rv;
+}
+
+// static
+BOOL LLLineEditor::prevalidatePrintableNotPipe(const LLWString &str)
+{
+	BOOL rv = TRUE;
+	S32 len = str.length();
+	if(len == 0) return rv;
+	while(len--)
+	{
+		if('|' == str[len])
+		{
+			rv = FALSE;
+			break;
+		}
+		if(!((' ' == str[len]) || isalnum(str[len]) || ispunct(str[len])))
+		{
+			rv = FALSE;
+			break;
+		}
+	}
+	return rv;
+}
+
+
+// static
+BOOL LLLineEditor::prevalidatePrintableNoSpace(const LLWString &str)
+{
+	BOOL rv = TRUE;
+	S32 len = str.length();
+	if(len == 0) return rv;
+	while(len--)
+	{
+		if(iswspace(str[len]))
+		{
+			rv = FALSE;
+			break;
+		}
+		if( !(isalnum(str[len]) || ispunct(str[len]) ) )
+		{
+			rv = FALSE;
+			break;
+		}
+	}
+	return rv;
+}
+
+// static
+BOOL LLLineEditor::prevalidateASCII(const LLWString &str)
+{
+	BOOL rv = TRUE;
+	S32 len = str.length();
+	while(len--)
+	{
+		if (str[len] < 0x20 || str[len] > 0x7f)
+		{
+			rv = FALSE;
+			break;
+		}
+	}
+	return rv;
+}
+
+//static
+void LLLineEditor::onMouseCaptureLost( LLMouseHandler* old_captor )
+{
+	LLLineEditor* self = (LLLineEditor*) old_captor;
+	self->endSelection();
+}
+
+
+void LLLineEditor::setSelectAllonFocusReceived(BOOL b)
+{
+	mSelectAllonFocusReceived = b;
+}
+
+
+void LLLineEditor::setKeystrokeCallback(void (*keystroke_callback)(LLLineEditor* caller, void* user_data))
+{
+	mKeystrokeCallback = keystroke_callback;
+}
+
+void LLLineEditor::setFocusLostCallback(void (*keystroke_callback)(LLLineEditor* caller, void* user_data))
+{
+	mFocusLostCallback = keystroke_callback;
+}
+
+// virtual
+LLXMLNodePtr LLLineEditor::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	node->createChild("max_length", TRUE)->setIntValue(mMaxLengthBytes);
+
+	node->createChild("font", TRUE)->setStringValue(LLFontGL::nameFromFont(mGLFont));
+
+	if (mBorder)
+	{
+		LLString bevel;
+		switch(mBorder->getBevel())
+		{
+		default:
+		case LLViewBorder::BEVEL_NONE:	bevel = "none"; break;
+		case LLViewBorder::BEVEL_IN:	bevel = "in"; break;
+		case LLViewBorder::BEVEL_OUT:	bevel = "out"; break;
+		case LLViewBorder::BEVEL_BRIGHT:bevel = "bright"; break;
+		}
+		node->createChild("bevel_style", TRUE)->setStringValue(bevel);
+
+		LLString style;
+		switch(mBorder->getStyle())
+		{
+		default:
+		case LLViewBorder::STYLE_LINE:		style = "line"; break;
+		case LLViewBorder::STYLE_TEXTURE:	style = "texture"; break;
+		}
+		node->createChild("border_style", TRUE)->setStringValue(style);
+
+		node->createChild("border_thickness", TRUE)->setIntValue(mBorder->getBorderWidth());
+	}
+
+	if (!mLabel.empty())
+	{
+		node->createChild("label", TRUE)->setStringValue(mLabel.getString());
+	}
+
+	node->createChild("select_all_on_focus_received", TRUE)->setBoolValue(mSelectAllonFocusReceived);
+
+	node->createChild("handle_edit_keys_directly", TRUE)->setBoolValue(mHandleEditKeysDirectly );
+
+	addColorXML(node, mCursorColor, "cursor_color", "TextCursorColor");
+	addColorXML(node, mFgColor, "text_color", "TextFgColor");
+	addColorXML(node, mReadOnlyFgColor, "text_readonly_color", "TextFgReadOnlyColor");
+	addColorXML(node, mTentativeFgColor, "text_tentative_color", "TextFgTentativeColor");
+	addColorXML(node, mReadOnlyBgColor, "bg_readonly_color", "TextBgReadOnlyColor");
+	addColorXML(node, mWriteableBgColor, "bg_writeable_color", "TextBgWriteableColor");
+	addColorXML(node, mFocusBgColor, "bg_focus_color", "TextBgFocusColor");
+
+	node->createChild("select_on_focus", TRUE)->setBoolValue(mSelectAllonFocusReceived );
+
+	return node;
+}
+
+// static
+LLView* LLLineEditor::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("line_editor");
+	node->getAttributeString("name", name);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	S32 max_text_length = 128;
+	node->getAttributeS32("max_length", max_text_length);
+
+	LLFontGL* font = LLView::selectFont(node);
+
+	LLString text = node->getTextContents().substr(0, max_text_length - 1);
+
+	LLViewBorder::EBevel bevel_style = LLViewBorder::BEVEL_IN;
+	LLViewBorder::getBevelFromAttribute(node, bevel_style);
+	
+	LLViewBorder::EStyle border_style = LLViewBorder::STYLE_LINE;
+	LLString border_string;
+	node->getAttributeString("border_style", border_string);
+	LLString::toLower(border_string);
+
+	if (border_string == "texture")
+	{
+		border_style = LLViewBorder::STYLE_TEXTURE;
+	}
+
+	S32 border_thickness = 1;
+	node->getAttributeS32("border_thickness", border_thickness);
+
+	LLUICtrlCallback commit_callback = NULL;
+
+	LLLineEditor* line_editor = new LLLineEditor(name,
+								rect, 
+								text, 
+								font,
+								max_text_length,
+								commit_callback,
+								NULL,
+								NULL,
+								NULL,
+								NULL,
+								bevel_style,
+								border_style,
+								border_thickness);
+
+	LLString label;
+	if(node->getAttributeString("label", label))
+	{
+		line_editor->setLabel(label);
+	}
+	BOOL select_all_on_focus_received = FALSE;
+	if (node->getAttributeBOOL("select_all_on_focus_received", select_all_on_focus_received))
+	{
+		line_editor->setSelectAllonFocusReceived(select_all_on_focus_received);
+	}
+	BOOL handle_edit_keys_directly = FALSE;
+	if (node->getAttributeBOOL("handle_edit_keys_directly", handle_edit_keys_directly))
+	{
+		line_editor->setHandleEditKeysDirectly(handle_edit_keys_directly);
+	}
+	
+	line_editor->setColorParameters(node);
+	
+	if(node->hasAttribute("select_on_focus"))
+	{
+		BOOL selectall = FALSE;
+		node->getAttributeBOOL("select_on_focus", selectall);
+		line_editor->setSelectAllonFocusReceived(selectall);
+	}
+
+	LLString prevalidate;
+	if(node->getAttributeString("prevalidate", prevalidate))
+	{
+		LLString::toLower(prevalidate);
+
+		if ("ascii" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidateASCII );
+		}
+		else if ("float" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidateFloat );
+		}
+		else if ("int" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidateInt );
+		}
+		else if ("positive_s32" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidatePositiveS32 );
+		}
+		else if ("non_negative_s32" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidateNonNegativeS32 );
+		}
+		else if ("alpha_num" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidateAlphaNum );
+		}
+		else if ("alpha_num_space" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidateAlphaNumSpace );
+		}
+		else if ("printable_not_pipe" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidatePrintableNotPipe );
+		}
+		else if ("printable_no_space" == prevalidate)
+		{
+			line_editor->setPrevalidate( LLLineEditor::prevalidatePrintableNoSpace );
+		}
+	}
+	
+	line_editor->initFromXML(node, parent);
+	
+	return line_editor;
+}
+
+void LLLineEditor::setColorParameters(LLXMLNodePtr node)
+{
+	LLColor4 color;
+	if (LLUICtrlFactory::getAttributeColor(node,"cursor_color", color)) 
+	{
+		setCursorColor(color);
+	}
+	if(node->hasAttribute("text_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"text_color", color);
+		setFgColor(color);
+	}
+	if(node->hasAttribute("text_readonly_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"text_readonly_color", color);
+		setReadOnlyFgColor(color);
+	}
+	if (LLUICtrlFactory::getAttributeColor(node,"text_tentative_color", color))
+	{
+		setTentativeFgColor(color);
+	}
+	if(node->hasAttribute("bg_readonly_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"bg_readonly_color", color);
+		setReadOnlyBgColor(color);
+	}
+	if(node->hasAttribute("bg_writeable_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"bg_writeable_color", color);
+		setWriteableBgColor(color);
+	}
+}
+
+void LLLineEditor::setValue(const LLSD& value )
+{
+	setText(value.asString());
+}
+
+LLSD LLLineEditor::getValue() const
+{
+	LLString str = getText();
+	LLSD ret(str);
+	return ret;
+}
+
+BOOL LLLineEditor::setTextArg( const LLString& key, const LLString& text )
+{
+	mText.setArg(key, text);
+	return TRUE;
+}
+
+BOOL LLLineEditor::setLabelArg( const LLString& key, const LLString& text )
+{
+	mLabel.setArg(key, text);
+	return TRUE;
+}
+
+LLSearchEditor::LLSearchEditor(const LLString& name, 
+		const LLRect& rect,
+		S32 max_length_bytes,
+		void (*search_callback)(const LLString& search_string, void* user_data),
+		void* userdata)
+	: 
+		LLUICtrl(name, rect, TRUE, NULL, userdata),
+		mSearchCallback(search_callback)
+{
+	LLRect search_edit_rect(0, mRect.getHeight(), mRect.getWidth(), 0);
+	mSearchEdit = new LLLineEditor("search edit",
+			search_edit_rect,
+			LLString::null,
+			NULL,
+			max_length_bytes,
+			NULL,
+			onSearchEdit,
+			NULL,
+			this);
+	// TODO: this should be translatable
+	mSearchEdit->setLabel("Type here to search");
+	mSearchEdit->setFollowsAll();
+	mSearchEdit->setSelectAllonFocusReceived(TRUE);
+
+	addChild(mSearchEdit);
+
+	S32 btn_width = rect.getHeight(); // button is square, and as tall as search editor
+	LLRect clear_btn_rect(rect.getWidth() - btn_width, rect.getHeight(), rect.getWidth(), 0);
+	mClearSearchButton = new LLButton("clear search", 
+								clear_btn_rect, 
+								"closebox.tga",
+								"UIImgBtnCloseInactiveUUID",
+								LLString::null,
+								onClearSearch,
+								this,
+								NULL,
+								LLString::null);
+	mClearSearchButton->setFollowsRight();
+	mClearSearchButton->setFollowsTop();
+	mClearSearchButton->setImageColor(LLUI::sColorsGroup->getColor("TextFgTentativeColor"));
+	mClearSearchButton->setTabStop(FALSE);
+	mSearchEdit->addChild(mClearSearchButton);
+
+	mSearchEdit->setBorderWidth(0, btn_width);
+}
+
+LLSearchEditor::~LLSearchEditor() 
+{
+}
+
+//virtual
+EWidgetType LLSearchEditor::getWidgetType() const
+{
+	return WIDGET_TYPE_SEARCH_EDITOR;
+}
+
+//virtual
+LLString LLSearchEditor::getWidgetTag() const
+{
+	return LL_SEARCH_EDITOR_TAG;
+}
+
+//virtual
+void LLSearchEditor::setValue(const LLSD& value )
+{
+	mSearchEdit->setValue(value);
+}
+
+//virtual
+LLSD LLSearchEditor::getValue() const
+{
+	return mSearchEdit->getValue();
+}
+
+//virtual
+BOOL LLSearchEditor::setTextArg( const LLString& key, const LLString& text )
+{
+	return mSearchEdit->setTextArg(key, text);
+}
+
+//virtual
+BOOL LLSearchEditor::setLabelArg( const LLString& key, const LLString& text )
+{
+	return mSearchEdit->setLabelArg(key, text);
+}
+
+//virtual
+void LLSearchEditor::clear()
+{
+	if (mSearchEdit)
+	{
+		mSearchEdit->clear();
+	}
+}
+
+
+void LLSearchEditor::draw()
+{
+	mClearSearchButton->setVisible(!mSearchEdit->getWText().empty());
+
+	LLUICtrl::draw();
+}
+
+void LLSearchEditor::setText(const LLString &new_text)
+{
+	mSearchEdit->setText(new_text);
+}
+
+//static
+void LLSearchEditor::onSearchEdit(LLLineEditor* caller, void* user_data )
+{
+	LLSearchEditor* search_editor = (LLSearchEditor*)user_data;
+	if (search_editor->mSearchCallback)
+	{
+		search_editor->mSearchCallback(caller->getText(), search_editor->mCallbackUserData);
+	}
+}
+
+//static
+void LLSearchEditor::onClearSearch(void* user_data)
+{
+	LLSearchEditor* search_editor = (LLSearchEditor*)user_data;
+
+	search_editor->setText(LLString::null);
+	if (search_editor->mSearchCallback)
+	{
+		search_editor->mSearchCallback(LLString::null, search_editor->mCallbackUserData);
+	}
+}
+
+// static
+LLView* LLSearchEditor::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("search_editor");
+	node->getAttributeString("name", name);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	S32 max_text_length = 128;
+	node->getAttributeS32("max_length", max_text_length);
+
+	LLString text = node->getValue().substr(0, max_text_length - 1);
+
+	LLSearchEditor* search_editor = new LLSearchEditor(name,
+								rect, 
+								max_text_length,
+								NULL, NULL);
+
+	search_editor->setText(text);
+
+	search_editor->initFromXML(node, parent);
+	
+	return search_editor;
+}
diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h
new file mode 100644
index 0000000000..1df5dd88f7
--- /dev/null
+++ b/indra/llui/lllineeditor.h
@@ -0,0 +1,298 @@
+/** 
+ * @file lllineeditor.h
+ * @brief LLLineEditor base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Text editor widget to let users enter/edit a single line.
+//
+//
+// Features: 
+//		Text entry of a single line (text, delete, left and right arrow, insert, return).
+//		Callbacks either on every keystroke or just on the return key.
+//		Focus (allow multiple text entry widgets)
+//		Clipboard (cut, copy, and paste)
+//		Horizontal scrolling to allow strings longer than widget size allows 
+//		Pre-validation (limit which keys can be used)
+
+
+#ifndef LL_LLLINEEDITOR_H
+#define LL_LLLINEEDITOR_H
+
+#include "v4color.h"
+#include "llframetimer.h"
+
+#include "lleditmenuhandler.h"
+#include "lluictrl.h"
+#include "lluistring.h"
+#include "llviewborder.h"
+
+class LLFontGL;
+class LLLineEditorRollback;
+class LLButton;
+
+typedef BOOL (*LLLinePrevalidateFunc)(const LLWString &wstr);
+
+// 
+// Classes
+//
+class LLLineEditor
+: public LLUICtrl, public LLEditMenuHandler
+{
+	friend class LLLineEditorRollback;
+
+public:
+	LLLineEditor(const LLString& name, 
+				 const LLRect& rect,
+				 const LLString& default_text = LLString::null,
+				 const LLFontGL* glfont = NULL,
+				 S32 max_length_bytes = 254,
+				 void (*commit_callback)(LLUICtrl* caller, void* user_data) = NULL,
+				 void (*keystroke_callback)(LLLineEditor* caller, void* user_data) = NULL,
+				 void (*focus_lost_callback)(LLLineEditor* caller, void* user_data) = NULL,
+				 void* userdata = NULL,
+				 LLLinePrevalidateFunc prevalidate_func = NULL,
+				 LLViewBorder::EBevel border_bevel = LLViewBorder::BEVEL_IN,
+				 LLViewBorder::EStyle border_style = LLViewBorder::STYLE_LINE,
+				 S32 border_thickness = 1);
+
+	virtual ~LLLineEditor();
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	void setColorParameters(LLXMLNodePtr node);
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	// mousehandler overrides
+	/*virtual*/ BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleDoubleClick(S32 x,S32 y,MASK mask);
+	/*virtual*/ BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent );
+	/*virtual*/ BOOL	handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent);
+
+	// LLEditMenuHandler overrides
+	virtual void	cut();
+	virtual BOOL	canCut();
+
+	virtual void	copy();
+	virtual BOOL	canCopy();
+
+	virtual void	paste();
+	virtual BOOL	canPaste();
+	
+	virtual void	doDelete();
+	virtual BOOL	canDoDelete();
+
+	virtual void	selectAll();
+	virtual BOOL	canSelectAll();
+
+	virtual void	deselect();
+	virtual BOOL	canDeselect();
+
+	// view overrides
+	virtual void	draw();
+	virtual void	reshape(S32 width,S32 height,BOOL called_from_parent=TRUE);
+	virtual void	onFocusLost();
+	virtual void	setEnabled(BOOL enabled);
+
+	// UI control overrides
+	virtual void	clear();
+	virtual void	onTabInto();
+	virtual void	setFocus( BOOL b );
+	virtual void 	setRect(const LLRect& rect);
+	virtual BOOL	acceptsTextInput() const;
+	virtual void	onCommit();
+
+	// assumes UTF8 text
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+	virtual BOOL	setTextArg( const LLString& key, const LLString& text );
+	virtual BOOL	setLabelArg( const LLString& key, const LLString& text );
+
+	void			setLabel(const LLString &new_label);
+	void			setText(const LLString &new_text);
+
+	const LLString& getText() const		{ return mText.getString(); }
+	const LLWString& getWText() const	{ return mText.getWString(); }
+	S32				getLength() const	{ return mText.length(); }
+
+	S32				getCursor()		{ return mCursorPos; }
+	void			setCursor( S32 pos );
+	void			setCursorToEnd();
+
+	// Selects characters 'start' to 'end'.
+	void			setSelection(S32 start, S32 end);
+	
+	void			setCommitOnFocusLost( BOOL b )	{ mCommitOnFocusLost = b; }
+
+	void setCursorColor(const LLColor4& c)			{ mCursorColor = c; }
+	const LLColor4& getCursorColor() const		{ return mCursorColor; }
+
+	void setFgColor( const LLColor4& c )			{ mFgColor = c; }
+	void setReadOnlyFgColor( const LLColor4& c )	{ mReadOnlyFgColor = c; }
+	void setTentativeFgColor(const LLColor4& c)		{ mTentativeFgColor = c; }
+	void setWriteableBgColor( const LLColor4& c )	{ mWriteableBgColor = c; }
+	void setReadOnlyBgColor( const LLColor4& c )	{ mReadOnlyBgColor = c; }
+	void setFocusBgColor(const LLColor4& c)			{ mFocusBgColor = c; }
+
+	const LLColor4& getFgColor() const			{ return mFgColor; }
+	const LLColor4& getReadOnlyFgColor() const	{ return mReadOnlyFgColor; }
+	const LLColor4& getTentativeFgColor() const { return mTentativeFgColor; }
+	const LLColor4& getWriteableBgColor() const	{ return mWriteableBgColor; }
+	const LLColor4& getReadOnlyBgColor() const	{ return mReadOnlyBgColor; }
+	const LLColor4& getFocusBgColor() const		{ return mFocusBgColor; }
+
+	void			setIgnoreArrowKeys(BOOL b)		{ mIgnoreArrowKeys = b; }
+	void			setIgnoreTab(BOOL b)			{ mIgnoreTab = b; }
+	void			setPassDelete(BOOL b)			{ mPassDelete = b; }
+
+	void			setDrawAsterixes(BOOL b)		{ mDrawAsterixes = b; }
+
+	// get the cursor position of the beginning/end of the prev/next word in the text
+	S32				prevWordPos(S32 cursorPos) const;
+	S32				nextWordPos(S32 cursorPos) const;
+
+	BOOL			hasSelection() { return (mSelectionStart != mSelectionEnd); }
+	void			startSelection();
+	void			endSelection();
+	void			extendSelection(S32 new_cursor_pos);
+	void			deleteSelection();
+
+	void			setHandleEditKeysDirectly( BOOL b ) { mHandleEditKeysDirectly = b; }
+	void			setSelectAllonFocusReceived(BOOL b);
+
+	void			setKeystrokeCallback(void (*keystroke_callback)(LLLineEditor* caller, void* user_data));
+	void			setFocusLostCallback(void (*keystroke_callback)(LLLineEditor* caller, void* user_data));
+
+	void			setMaxTextLength(S32 max_text_length); 
+	void			setBorderWidth(S32 left, S32 right);
+
+	static BOOL		isPartOfWord(llwchar c);
+	// Prevalidation controls which keystrokes can affect the editor
+	void			setPrevalidate( BOOL (*func)(const LLWString &) ) { mPrevalidateFunc = func; }
+	static BOOL		prevalidateFloat(const LLWString &str );
+	static BOOL		prevalidateInt(const LLWString &str );
+	static BOOL		prevalidatePositiveS32(const LLWString &str);
+	static BOOL		prevalidateNonNegativeS32(const LLWString &str);
+	static BOOL		prevalidateAlphaNum(const LLWString &str );
+	static BOOL		prevalidateAlphaNumSpace(const LLWString &str );
+	static BOOL		prevalidatePrintableNotPipe(const LLWString &str); 
+	static BOOL		prevalidatePrintableNoSpace(const LLWString &str);
+	static BOOL		prevalidateASCII(const LLWString &str);
+
+	static BOOL		postvalidateFloat(const LLString &str);
+
+	static void		onMouseCaptureLost( LLMouseHandler* old_captor );
+
+protected:
+	void			removeChar();
+	void			addChar(const llwchar c);
+	void			setCursorAtLocalPos(S32 local_mouse_x);
+
+	S32				findPixelNearestPos(S32 cursor_offset = 0);
+	void			reportBadKeystroke();
+
+	BOOL			handleSpecialKey(KEY key, MASK mask);
+	BOOL			handleSelectionKey(KEY key, MASK mask);
+	BOOL			handleControlKey(KEY key, MASK mask);
+	S32				handleCommitKey(KEY key, MASK mask);
+
+protected:
+	LLUIString		mText;					// The string being edited.
+	LLUIString		mLabel;					// text label that is visible when no user text provided
+
+	LLViewBorder* mBorder;
+	const LLFontGL*	mGLFont;
+	S32			mMaxLengthChars;			// Max number of characters
+	S32			mMaxLengthBytes;			// Max length of the UTF8 string.
+	S32			mCursorPos;					// I-beam is just after the mCursorPos-th character.
+	S32			mScrollHPos;				// Horizontal offset from the start of mText.  Used for scrolling.
+	LLFrameTimer mScrollTimer;
+	S32			mMinHPixels;
+	S32			mMaxHPixels;
+	S32			mBorderLeft;
+	S32			mBorderRight;
+
+	BOOL		mCommitOnFocusLost;
+
+	void		(*mKeystrokeCallback)( LLLineEditor* caller, void* userdata );
+	void		(*mFocusLostCallback)( LLLineEditor* caller, void* userdata );
+
+	BOOL		mIsSelecting;				// Selection for clipboard operations
+	S32			mSelectionStart;
+	S32			mSelectionEnd;
+	S32			mLastSelectionX;
+	S32			mLastSelectionY;
+
+	S32			(*mPrevalidateFunc)(const LLWString &str);
+
+	LLFrameTimer mKeystrokeTimer;
+
+	LLColor4	mCursorColor;
+
+	LLColor4	mFgColor;
+	LLColor4	mReadOnlyFgColor;
+	LLColor4	mTentativeFgColor;
+	LLColor4	mWriteableBgColor;
+	LLColor4	mReadOnlyBgColor;
+	LLColor4	mFocusBgColor;
+
+	S32			mBorderThickness;
+
+	BOOL		mIgnoreArrowKeys;
+	BOOL		mIgnoreTab;
+	BOOL		mDrawAsterixes;
+
+	BOOL		mHandleEditKeysDirectly;  // If true, the standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system
+	BOOL		mSelectAllonFocusReceived;
+	BOOL		mPassDelete;
+
+	BOOL		mReadOnly;
+};
+
+
+class LLSearchEditor : public LLUICtrl
+{
+friend class LLLineEditorRollback;
+
+public:
+	LLSearchEditor(const LLString& name, 
+		const LLRect& rect,
+		S32 max_length_bytes,
+		void (*search_callback)(const LLString& search_string, void* user_data),
+		void* userdata);
+
+	virtual ~LLSearchEditor();
+
+	/*virtual*/ void	draw();
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	void setText(const LLString &new_text);
+
+	void setSearchCallback(void (*search_callback)(const LLString& search_string, void* user_data), void* data) { mSearchCallback = search_callback; mCallbackUserData = data; }
+
+	// LLUICtrl interface
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+	virtual BOOL	setTextArg( const LLString& key, const LLString& text );
+	virtual BOOL	setLabelArg( const LLString& key, const LLString& text );
+	virtual void	clear();
+
+
+protected:
+	LLLineEditor* mSearchEdit;
+	LLButton* mClearSearchButton;
+
+	void (*mSearchCallback)(const LLString& search_string, void* user_data);
+
+	static void onSearchEdit(LLLineEditor* caller, void* user_data );
+	static void onClearSearch(void* user_data);
+};
+
+#endif  // LL_LINEEDITOR_
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
new file mode 100644
index 0000000000..de06c34c44
--- /dev/null
+++ b/indra/llui/llmenugl.cpp
@@ -0,0 +1,4341 @@
+/** 
+ * @file llmenugl.cpp
+ * @brief LLMenuItemGL base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+//*****************************************************************************
+//
+// This file contains the opengl based menu implementation.
+//
+// NOTES: A menu label is split into 4 columns. The left column, the
+// label colum, the accelerator column, and the right column. The left
+// column is used for displaying boolean values for toggle and check
+// controls. The right column is used for submenus.
+//
+//*****************************************************************************
+
+//#include "llviewerprecompiledheaders.h"
+#include "linden_common.h"
+
+#include "llmenugl.h"
+
+#include "llmath.h"
+#include "llgl.h"
+#include "llfocusmgr.h"
+#include "llfont.h"
+#include "llcoord.h"
+#include "llwindow.h"
+#include "llcriticaldamp.h"
+#include "lluictrlfactory.h"
+
+#include "llfontgl.h"
+#include "llresmgr.h"
+#include "llui.h"
+
+#include "llglheaders.h"
+#include "llstl.h"
+
+#include "v2math.h"
+#include <set>
+#include <boost/tokenizer.hpp>
+
+// static
+LLView *LLMenuGL::sDefaultMenuContainer = NULL;
+
+S32 MENU_BAR_HEIGHT = 0;
+S32 MENU_BAR_WIDTH = 0;
+
+///============================================================================
+/// Local function declarations, constants, enums, and typedefs
+///============================================================================
+
+const LLString SEPARATOR_NAME("separator");
+const LLString TEAROFF_SEPARATOR_LABEL( "~~~~~~~~~~~" );
+const LLString SEPARATOR_LABEL( "-----------" );
+const LLString VERTICAL_SEPARATOR_LABEL( "|" );
+
+const S32 LABEL_BOTTOM_PAD_PIXELS = 2;
+
+const U32 LEFT_PAD_PIXELS = 3;
+const U32 LEFT_WIDTH_PIXELS = 15;
+const U32 LEFT_PLAIN_PIXELS = LEFT_PAD_PIXELS + LEFT_WIDTH_PIXELS;
+
+const U32 RIGHT_PAD_PIXELS = 2;
+const U32 RIGHT_WIDTH_PIXELS = 15;
+const U32 RIGHT_PLAIN_PIXELS = RIGHT_PAD_PIXELS + RIGHT_WIDTH_PIXELS;
+
+const U32 ACCEL_PAD_PIXELS = 10;
+const U32 PLAIN_PAD_PIXELS = LEFT_PAD_PIXELS + LEFT_WIDTH_PIXELS + RIGHT_PAD_PIXELS + RIGHT_WIDTH_PIXELS;
+
+const U32 BRIEF_PAD_PIXELS = 2;
+
+const U32 SEPARATOR_HEIGHT_PIXELS = 8;
+const S32 TEAROFF_SEPARATOR_HEIGHT_PIXELS = 10;
+const S32 MENU_ITEM_PADDING = 4;
+
+const LLString BOOLEAN_TRUE_PREFIX( "X" );
+const LLString BRANCH_SUFFIX( ">" );
+const LLString ARROW_UP  ("^^^^^^^");
+const LLString ARROW_DOWN("vvvvvvv");
+
+const F32 MAX_MOUSE_SLOPE_SUB_MENU = 0.9f;
+
+const S32 PIE_GESTURE_ACTIVATE_DISTANCE = 10;
+
+LLColor4 LLMenuItemGL::sEnabledColor( 0.0f, 0.0f, 0.0f, 1.0f );
+LLColor4 LLMenuItemGL::sDisabledColor( 0.5f, 0.5f, 0.5f, 1.0f );
+LLColor4 LLMenuItemGL::sHighlightBackground( 0.0f, 0.0f, 0.7f, 1.0f );
+LLColor4 LLMenuItemGL::sHighlightForeground( 1.0f, 1.0f, 1.0f, 1.0f );
+BOOL LLMenuItemGL::sDropShadowText = TRUE;
+LLColor4 LLMenuGL::sDefaultBackgroundColor( 0.25f, 0.25f, 0.25f, 0.75f );
+
+LLViewHandle LLMenuHolderGL::sItemLastSelectedHandle;
+LLFrameTimer LLMenuHolderGL::sItemActivationTimer;
+//LLColor4 LLMenuGL::sBackgroundColor( 0.8f, 0.8f, 0.0f, 1.0f );
+
+const S32 PIE_CENTER_SIZE = 20;		// pixels, radius of center hole
+const F32 PIE_SCALE_FACTOR = 1.7f; // scale factor for pie menu when mouse is initially down
+const F32 PIE_SHRINK_TIME = 0.2f; // time of transition between unbounded and bounded display of pie menu
+
+const F32 ACTIVATE_HIGHLIGHT_TIME = 0.3f;
+
+///============================================================================
+/// Class LLMenuItemGL
+///============================================================================
+
+// Default constructor
+LLMenuItemGL::LLMenuItemGL( const LLString& name, const LLString& label, KEY key, MASK mask ) :
+	LLView( name, TRUE ),
+	mJumpKey(KEY_NONE),
+	mAcceleratorKey( key ),
+	mAcceleratorMask( mask ),
+	mAllowKeyRepeat(FALSE),
+	mHighlight( FALSE ),
+	mGotHover( FALSE ),
+	mBriefItem( FALSE ),
+	mFont( LLFontGL::sSansSerif ),
+	mStyle(LLFontGL::NORMAL),
+	mDrawTextDisabled( FALSE )
+{
+	setLabel( label );
+}
+
+// virtual
+LLXMLNodePtr LLMenuItemGL::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLView::getXML();
+
+	node->createChild("type", TRUE)->setStringValue(getType());
+
+	node->createChild("label", TRUE)->setStringValue(mLabel);
+
+	if (mAcceleratorKey != KEY_NONE)
+	{
+		std::stringstream out;
+		if (mAcceleratorMask & MASK_CONTROL)
+		{
+			out << "control|";
+		}
+		if (mAcceleratorMask & MASK_ALT)
+		{
+			out << "alt|";
+		}
+		if (mAcceleratorMask & MASK_SHIFT)
+		{
+			out << "shift|";
+		}
+		out << LLKeyboard::stringFromKey(mAcceleratorKey);
+
+		node->createChild("shortcut", TRUE)->setStringValue(out.str());
+	}
+
+	return node;
+}
+
+BOOL LLMenuItemGL::handleKey(KEY key, MASK mask, BOOL called_from_parent)
+{
+	// modified from LLView::handleKey
+	// ignore visibility, as keyboard accelerators should still trigger menu items
+	// even when they are not visible
+	// also, ignore enabled flag for self, as that can change based on menu callbacks
+	BOOL handled = FALSE;
+
+	if( called_from_parent )  
+	{
+		// Downward traversal
+		if (mEnabled)
+		{
+			handled = childrenHandleKey( key, mask ) != NULL;
+		}
+	}
+	
+	if( !handled )
+	{
+		handled = handleKeyHere( key, mask, called_from_parent );
+	}
+
+	return handled;
+}
+
+BOOL LLMenuItemGL::handleAcceleratorKey(KEY key, MASK mask)
+{
+	if( mEnabled && (!gKeyboard->getKeyRepeated(key) || mAllowKeyRepeat) && (key == mAcceleratorKey) && (mask == mAcceleratorMask) )
+	{
+		doIt();
+		return TRUE;
+	}
+	return FALSE;
+}
+
+BOOL LLMenuItemGL::handleHover(S32 x, S32 y, MASK mask)
+{
+	mGotHover = TRUE;
+	getWindow()->setCursor(UI_CURSOR_ARROW);
+	return TRUE;
+}
+	
+void LLMenuItemGL::setBriefItem(BOOL b)
+{
+	mBriefItem = b;
+}
+
+// This function checks to see if the accelerator key is already in use;
+// if not, it will be added to the list
+BOOL LLMenuItemGL::addToAcceleratorList(std::list <LLKeyBinding*> *listp)
+{
+	LLKeyBinding *accelerator = NULL;
+
+	if (mAcceleratorKey != KEY_NONE)
+	{
+		std::list<LLKeyBinding*>::iterator list_it;
+		for (list_it = listp->begin(); list_it != listp->end(); ++list_it)
+		{
+			accelerator = *list_it;
+			if ((accelerator->mKey == mAcceleratorKey) && (accelerator->mMask == mAcceleratorMask))
+			{
+			//FIXME: get calling code to throw up warning or route warning messages back to app-provided output
+			//	LLString warning;
+			//	warning.append("Duplicate key binding <");
+			//	appendAcceleratorString( warning );
+			//	warning.append("> for menu items:\n    ");
+			//	warning.append(accelerator->mName);
+			//	warning.append("\n    ");
+			//	warning.append(mLabel);
+
+			//	llwarns << warning << llendl;
+			//	LLAlertDialog::modalAlert(warning);
+				return FALSE;
+			}
+		}
+		if (!accelerator)
+		{				
+			accelerator = new LLKeyBinding;
+			if (accelerator)
+			{
+				accelerator->mKey = mAcceleratorKey;
+				accelerator->mMask = mAcceleratorMask;
+// 				accelerator->mName = mLabel;
+			}
+			listp->push_back(accelerator);//addData(accelerator);
+		}
+	}
+	return TRUE;
+}
+
+// This function appends the character string representation of
+// the current accelerator key and mask to the provided string.
+void LLMenuItemGL::appendAcceleratorString( LLString& st )
+{
+	// break early if this is a silly thing to do.
+	if( KEY_NONE == mAcceleratorKey )
+	{
+		return;
+	}
+
+	// Append any masks
+#ifdef LL_DARWIN
+	// Standard Mac names for modifier keys in menu equivalents
+	// We could use the symbol characters, but they only exist in certain fonts.
+	if( mAcceleratorMask & MASK_CONTROL )
+		st.append( "Cmd-" );		// Symbol would be "\xE2\x8C\x98"
+	if( mAcceleratorMask & MASK_ALT )
+		st.append( "Opt-" );		// Symbol would be "\xE2\x8C\xA5"
+	if( mAcceleratorMask & MASK_SHIFT )
+		st.append( "Shift-" );		// Symbol would be "\xE2\x8C\xA7"
+#else
+	if( mAcceleratorMask & MASK_CONTROL )
+		st.append( "Ctrl-" );
+	if( mAcceleratorMask & MASK_ALT )
+		st.append( "Alt-" );
+	if( mAcceleratorMask & MASK_SHIFT )
+		st.append( "Shift-" );
+#endif
+
+	LLString keystr = LLKeyboard::stringFromKey( mAcceleratorKey );
+	if ((mAcceleratorMask & (MASK_CONTROL|MASK_ALT|MASK_SHIFT)) &&
+		(keystr[0] == '-' || keystr[0] == '='))
+	{
+		st.append( " " );
+	}
+	st.append( keystr );
+}
+
+void LLMenuItemGL::setJumpKey(KEY key)
+{
+	mJumpKey = LLStringOps::toUpper((char)key);
+}
+
+KEY LLMenuItemGL::getJumpKey()
+{
+	return mJumpKey;
+}
+
+
+// set the font used by all of the menu objects
+void LLMenuItemGL::setFont(LLFontGL* font)
+{
+	mFont = font;
+}
+
+// returns the height in pixels for the current font.
+U32 LLMenuItemGL::getNominalHeight( void )
+{
+	return llround(mFont->getLineHeight()) + MENU_ITEM_PADDING;
+}
+
+// functions to control the color scheme
+void LLMenuItemGL::setEnabledColor( const LLColor4& color )
+{
+	sEnabledColor = color;
+}
+
+void LLMenuItemGL::setDisabledColor( const LLColor4& color )
+{
+	sDisabledColor = color;
+}
+
+void LLMenuItemGL::setHighlightBGColor( const LLColor4& color )
+{
+	sHighlightBackground = color;
+}
+
+void LLMenuItemGL::setHighlightFGColor( const LLColor4& color )
+{
+	sHighlightForeground = color;
+}
+
+
+// change the label
+void LLMenuItemGL::setLabel( const LLString& label )
+{
+	mLabel = label;
+}
+
+// Get the parent menu for this item
+LLMenuGL* LLMenuItemGL::getMenu()
+{
+	return (LLMenuGL*) getParent();
+}
+
+
+// getNominalWidth() - returns the normal width of this control in
+// pixels - this is used for calculating the widest item, as well as
+// for horizontal arrangement.
+U32 LLMenuItemGL::getNominalWidth( void )
+{
+	U32 width;
+	
+	if (mBriefItem)
+	{
+		width = BRIEF_PAD_PIXELS;
+	}
+	else
+	{
+		width = PLAIN_PAD_PIXELS;
+	}
+
+	if( KEY_NONE != mAcceleratorKey )
+	{
+		width += ACCEL_PAD_PIXELS;
+		LLString temp;
+		appendAcceleratorString( temp );
+		width += mFont->getWidth( temp );
+	}
+	width += mFont->getWidth( mLabel.getWString().c_str() );
+	return width;
+}
+
+// called to rebuild the draw label
+void LLMenuItemGL::buildDrawLabel( void )
+{
+	mDrawAccelLabel.clear();
+	LLString st = mDrawAccelLabel.getString();
+	appendAcceleratorString( st );
+	mDrawAccelLabel = st;
+}
+
+// set the hover status (called by it's menu)
+ void LLMenuItemGL::setHighlight( BOOL highlight )
+{
+	mHighlight = highlight;
+}
+
+// determine if this object is active
+BOOL LLMenuItemGL::isActive( void ) const
+{
+	return FALSE;
+}
+
+BOOL LLMenuItemGL::handleKeyHere( KEY key, MASK mask, BOOL called_from_parent )
+{
+	if (mHighlight && 
+		getMenu()->getVisible() &&
+		(!getMenu()->getTornOff() || ((LLFloater*)getMenu()->getParent())->hasFocus()))
+	{
+		if (key == KEY_UP)
+		{
+			getMenu()->highlightPrevItem(this);
+			return TRUE;
+		}
+		else if (key == KEY_DOWN)
+		{
+			getMenu()->highlightNextItem(this);
+			return TRUE;
+		}
+		else if (key == KEY_RETURN && mask == MASK_NONE)
+		{
+			doIt();
+			if (!getMenu()->getTornOff())
+			{
+				((LLMenuHolderGL*)getMenu()->getParent())->hideMenus();
+			}
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL LLMenuItemGL::handleMouseUp( S32 x, S32 y, MASK )
+{
+	//llinfos << mLabel.c_str() << " handleMouseUp " << x << "," << y
+	//	<< llendl;
+	if (mEnabled)
+	{
+		doIt();
+		mHighlight = FALSE;
+		make_ui_sound("UISndClickRelease");
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+void LLMenuItemGL::draw( void )
+{
+	// *FIX: This can be optimized by using switches. Want to avoid
+	// that until the functionality is finalized.
+
+	// HACK: Brief items don't highlight.  Pie menu takes care of it.  JC
+	if( mHighlight && !mBriefItem)
+	{
+		glColor4fv( sHighlightBackground.mV );
+		gl_rect_2d( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+	}
+
+	LLColor4 color;
+
+	U8 font_style = mStyle;
+	if (LLMenuItemGL::sDropShadowText && getEnabled() && !mDrawTextDisabled )
+	{
+		font_style |= LLFontGL::DROP_SHADOW;
+	}
+
+	if ( mHighlight )
+	{
+		color = sHighlightForeground;
+	}
+	else if( getEnabled() && !mDrawTextDisabled )
+	{
+		color = sEnabledColor;
+	}
+	else
+	{
+		color = sDisabledColor;
+	}
+
+	// Draw the text on top.
+	if (mBriefItem)
+	{
+		mFont->render( mLabel, 0, BRIEF_PAD_PIXELS / 2, 0, color,
+					   LLFontGL::LEFT, LLFontGL::BOTTOM, font_style );
+	}
+	else
+	{
+		if( !mDrawBoolLabel.empty() )
+		{
+			mFont->render( mDrawBoolLabel.getWString(), 0, (F32)LEFT_PAD_PIXELS, ((F32)MENU_ITEM_PADDING / 2.f) + 1.f, color,
+						   LLFontGL::LEFT, LLFontGL::BOTTOM, font_style, S32_MAX, S32_MAX, NULL, FALSE );
+		}
+		mFont->render( mLabel.getWString(), 0, (F32)LEFT_PLAIN_PIXELS, ((F32)MENU_ITEM_PADDING / 2.f) + 1.f, color,
+					   LLFontGL::LEFT, LLFontGL::BOTTOM, font_style, S32_MAX, S32_MAX, NULL, FALSE );
+		if( !mDrawAccelLabel.empty() )
+		{
+			mFont->render( mDrawAccelLabel.getWString(), 0, (F32)mRect.mRight - (F32)RIGHT_PLAIN_PIXELS, ((F32)MENU_ITEM_PADDING / 2.f) + 1.f, color,
+						   LLFontGL::RIGHT, LLFontGL::BOTTOM, font_style, S32_MAX, S32_MAX, NULL, FALSE );
+		}
+		if( !mDrawBranchLabel.empty() )
+		{
+			mFont->render( mDrawBranchLabel.getWString(), 0, (F32)mRect.mRight - (F32)RIGHT_PAD_PIXELS, ((F32)MENU_ITEM_PADDING / 2.f) + 1.f, color,
+						   LLFontGL::RIGHT, LLFontGL::BOTTOM, font_style, S32_MAX, S32_MAX, NULL, FALSE );
+		}
+	}
+
+	// underline navigation key
+	BOOL draw_jump_key = gKeyboard->currentMask(FALSE) == MASK_ALT && 
+								(!getMenu()->getHighlightedItem() || !getMenu()->getHighlightedItem()->isActive()) &&
+								(!getMenu()->getTornOff());
+	if (draw_jump_key)
+	{
+		LLString upper_case_label = mLabel.getString();
+		LLString::toUpper(upper_case_label);
+		std::string::size_type offset = upper_case_label.find(mJumpKey);
+		if (offset != std::string::npos)
+		{
+			S32 x_begin = LEFT_PLAIN_PIXELS + mFont->getWidth(mLabel, 0, offset);
+			S32 x_end = LEFT_PLAIN_PIXELS + mFont->getWidth(mLabel, 0, offset + 1);
+			gl_line_2d(x_begin, (MENU_ITEM_PADDING / 2) + 1, x_end, (MENU_ITEM_PADDING / 2) + 1);
+		}
+	}
+
+	// clear got hover every frame
+	mGotHover = FALSE;
+}
+
+BOOL LLMenuItemGL::setLabelArg( const LLString& key, const LLString& text )
+{
+	mLabel.setArg(key, text);
+	return TRUE;
+}
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemSeparatorGL
+//
+// This class represents a separator.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemSeparatorGL : public LLMenuItemGL
+{
+public:
+	LLMenuItemSeparatorGL( const LLString &name = SEPARATOR_NAME );
+
+	virtual LLString getType() const	{ return "separator"; }
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_MENU_ITEM_SEPARATOR; }
+	virtual LLString getWidgetTag() const { return LL_MENU_ITEM_SEPARATOR_GL_TAG; }
+
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void ) {}
+
+	virtual void draw( void );
+	virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual BOOL handleHover(S32 x, S32 y, MASK mask);
+
+	virtual U32 getNominalHeight( void ) { return SEPARATOR_HEIGHT_PIXELS; }
+};
+
+LLMenuItemSeparatorGL::LLMenuItemSeparatorGL( const LLString &name ) :
+	LLMenuItemGL( SEPARATOR_NAME, SEPARATOR_LABEL )
+{
+}
+
+void LLMenuItemSeparatorGL::draw( void )
+{
+	glColor4fv( sDisabledColor.mV );
+	const S32 y = mRect.getHeight() / 2;
+	const S32 PAD = 6;
+	gl_line_2d( PAD, y, mRect.getWidth() - PAD, y );
+}
+
+BOOL LLMenuItemSeparatorGL::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	LLMenuGL* parent_menu = getMenu();
+	if (y > mRect.getHeight() / 2)
+	{
+		return parent_menu->handleMouseDown(x + mRect.mLeft, mRect.mTop + 1, mask);
+	}
+	else
+	{
+		return parent_menu->handleMouseDown(x + mRect.mLeft, mRect.mBottom - 1, mask);
+	}
+}
+
+BOOL LLMenuItemSeparatorGL::handleMouseUp(S32 x, S32 y, MASK mask) 
+{
+	LLMenuGL* parent_menu = getMenu();
+	if (y > mRect.getHeight() / 2)
+	{
+		return parent_menu->handleMouseUp(x + mRect.mLeft, mRect.mTop + 1, mask);
+	}
+	else
+	{
+		return parent_menu->handleMouseUp(x + mRect.mLeft, mRect.mBottom - 1, mask);
+	}
+}
+
+BOOL LLMenuItemSeparatorGL::handleHover(S32 x, S32 y, MASK mask) 
+{
+	LLMenuGL* parent_menu = getMenu();
+	if (y > mRect.getHeight() / 2)
+	{
+		parent_menu->highlightPrevItem(this, FALSE);
+		return FALSE;
+	}
+	else
+	{
+		parent_menu->highlightNextItem(this, FALSE);
+		return FALSE;
+	}
+}
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemVerticalSeparatorGL
+//
+// This class represents a vertical separator.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemVerticalSeparatorGL
+:	public LLMenuItemSeparatorGL
+{
+public:
+	LLMenuItemVerticalSeparatorGL( void );
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_MENU_SEPARATOR_VERTICAL; }
+	virtual LLString getWidgetTag() const { return LL_MENU_ITEM_VERTICAL_SEPARATOR_GL_TAG; }
+
+	virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask) { return FALSE; }
+};
+
+LLMenuItemVerticalSeparatorGL::LLMenuItemVerticalSeparatorGL( void )
+{
+	setLabel( VERTICAL_SEPARATOR_LABEL );
+}
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemTearOffGL
+//
+// This class represents a separator.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+LLMenuItemTearOffGL::LLMenuItemTearOffGL(LLViewHandle parent_floater_handle) : 
+	LLMenuItemGL("tear off", TEAROFF_SEPARATOR_LABEL), 
+	mParentHandle(parent_floater_handle)
+{
+}
+
+EWidgetType LLMenuItemTearOffGL::getWidgetType() const
+{
+	return WIDGET_TYPE_TEAROFF_MENU;
+}
+
+LLString LLMenuItemTearOffGL::getWidgetTag() const
+{
+	return LL_MENU_ITEM_TEAR_OFF_GL_TAG;
+}
+
+void LLMenuItemTearOffGL::doIt()
+{
+	if (getMenu()->getTornOff())
+	{
+		LLTearOffMenu* torn_off_menu = (LLTearOffMenu*)(getMenu()->getParent());
+		torn_off_menu->close();
+	}
+	else
+	{
+		// transfer keyboard focus and highlight to first real item in list
+		if (getHighlight())
+		{
+			getMenu()->highlightNextItem(this);
+		}
+
+		// grab menu holder before this menu is parented to a floater
+		LLMenuHolderGL* menu_holder = ((LLMenuHolderGL*)getMenu()->getParent());
+		getMenu()->arrange();
+
+		LLFloater* parent_floater = LLFloater::getFloaterByHandle(mParentHandle);
+		LLFloater* tear_off_menu = LLTearOffMenu::create(getMenu());
+		if (parent_floater && tear_off_menu)
+		{
+			parent_floater->addDependentFloater(tear_off_menu, FALSE);
+		}
+
+		// hide menus
+		// only do it if the menu is open, not being triggered via accelerator
+		if (getMenu()->getVisible())
+		{
+			menu_holder->hideMenus();
+		}
+
+		// give focus to torn off menu because it will have been taken away
+		// when parent menu closes
+		tear_off_menu->setFocus(TRUE);
+	}
+}
+
+void LLMenuItemTearOffGL::draw()
+{
+	if( mHighlight && !mBriefItem)
+	{
+		glColor4fv( sHighlightBackground.mV );
+		gl_rect_2d( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+	}
+
+	if (mEnabled)
+	{
+		glColor4fv( sEnabledColor.mV );
+	}
+	else
+	{
+		glColor4fv( sDisabledColor.mV );
+	}
+	const S32 y = mRect.getHeight() / 3;
+	const S32 PAD = 6;
+	gl_line_2d( PAD, y, mRect.getWidth() - PAD, y );
+	gl_line_2d( PAD, y * 2, mRect.getWidth() - PAD, y * 2 );
+}
+
+U32 LLMenuItemTearOffGL::getNominalHeight( void ) { return TEAROFF_SEPARATOR_HEIGHT_PIXELS; }
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemBlankGL
+//
+// This class represents a blank, non-functioning item.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemBlankGL : public LLMenuItemGL
+{
+public:
+	LLMenuItemBlankGL( void );
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_MENU_ITEM_BLANK; }
+	virtual LLString getWidgetTag() const { return LL_MENU_ITEM_BLANK_GL_TAG; }
+
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void ) {}
+
+	virtual void draw( void ) {}
+};
+
+LLMenuItemBlankGL::LLMenuItemBlankGL( void )
+:	LLMenuItemGL( "", "" )
+{
+	mEnabled = FALSE;
+}
+
+///============================================================================
+/// Class LLMenuItemCallGL
+///============================================================================
+
+LLMenuItemCallGL::LLMenuItemCallGL( const LLString& name, 
+									const LLString& label, 
+									menu_callback clicked_cb, 
+								    enabled_callback enabled_cb,
+									void* user_data,
+									KEY key, MASK mask,
+									BOOL enabled,
+									on_disabled_callback on_disabled_cb) :
+	LLMenuItemGL( name, label, key, mask ),
+	mCallback( clicked_cb ),
+	mEnabledCallback( enabled_cb ),
+	mLabelCallback(NULL),
+	mUserData( user_data ),
+	mOnDisabledCallback(on_disabled_cb)
+{
+	if(!enabled) setEnabled(FALSE);
+}
+
+LLMenuItemCallGL::LLMenuItemCallGL( const LLString& name, 
+									menu_callback clicked_cb, 
+								    enabled_callback enabled_cb,
+									void* user_data,
+									KEY key, MASK mask,
+									BOOL enabled,
+									on_disabled_callback on_disabled_cb) :
+	LLMenuItemGL( name, name, key, mask ),
+	mCallback( clicked_cb ),
+	mEnabledCallback( enabled_cb ),
+	mLabelCallback(NULL),
+	mUserData( user_data ),
+	mOnDisabledCallback(on_disabled_cb)
+{
+	if(!enabled) setEnabled(FALSE);
+}
+
+LLMenuItemCallGL::LLMenuItemCallGL(const LLString& name,
+								   const LLString& label,
+								   menu_callback clicked_cb,
+								   enabled_callback enabled_cb,
+								   label_callback label_cb,
+								   void* user_data,
+								   KEY key, MASK mask,
+								   BOOL enabled,
+								   on_disabled_callback on_disabled_cb) :
+	LLMenuItemGL(name, label, key, mask),
+	mCallback(clicked_cb),
+	mEnabledCallback(enabled_cb),
+	mLabelCallback(label_cb),
+	mUserData(user_data),
+	mOnDisabledCallback(on_disabled_cb)
+{
+	if(!enabled) setEnabled(FALSE);
+}
+
+LLMenuItemCallGL::LLMenuItemCallGL(const LLString& name,
+								   menu_callback clicked_cb,
+								   enabled_callback enabled_cb,
+								   label_callback label_cb,
+								   void* user_data,
+								   KEY key, MASK mask,
+								   BOOL enabled,
+								   on_disabled_callback on_disabled_cb) :
+	LLMenuItemGL(name, name, key, mask),
+	mCallback(clicked_cb),
+	mEnabledCallback(enabled_cb),
+	mLabelCallback(label_cb),
+	mUserData(user_data),
+	mOnDisabledCallback(on_disabled_cb)
+{
+	if(!enabled) setEnabled(FALSE);
+}
+
+void LLMenuItemCallGL::setEnabledControl(LLString enabled_control, LLView *context)
+{
+	// Register new listener
+	if (!enabled_control.empty())
+	{
+		LLControlBase *control = context->findControl(enabled_control);
+		if (control)
+		{
+			LLSD state = control->registerListener(this, "ENABLED");
+			setEnabled(state);
+		}
+		else
+		{
+			context->addBoolControl(enabled_control, mEnabled);
+			control = context->findControl(enabled_control);
+			control->registerListener(this, "ENABLED");
+		}
+	}
+}
+
+void LLMenuItemCallGL::setVisibleControl(LLString enabled_control, LLView *context)
+{
+	// Register new listener
+	if (!enabled_control.empty())
+	{
+		LLControlBase *control = context->findControl(enabled_control);
+		if (control)
+		{
+			LLSD state = control->registerListener(this, "VISIBLE");
+			setVisible(state);
+		}
+		else
+		{
+			context->addBoolControl(enabled_control, mEnabled);
+			control = context->findControl(enabled_control);
+			control->registerListener(this, "VISIBLE");
+		}
+	}
+}
+
+// virtual
+bool LLMenuItemCallGL::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+	if (userdata.asString() == "ENABLED" && event->desc() == "value_changed")
+	{
+		LLSD state = event->getValue();
+		setEnabled(state);
+		return TRUE;
+	}
+	if (userdata.asString() == "VISIBLE" && event->desc() == "value_changed")
+	{
+		LLSD state = event->getValue();
+		setVisible(state);
+		return TRUE;
+	}
+	return LLMenuItemGL::handleEvent(event, userdata);
+}
+
+// virtual
+LLXMLNodePtr LLMenuItemCallGL::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLMenuItemGL::getXML();
+
+	// Contents
+
+	std::vector<LLListenerEntry> listeners = mDispatcher->getListeners();
+	std::vector<LLListenerEntry>::iterator itor;
+	for (itor = listeners.begin(); itor != listeners.end(); ++itor)
+	{
+		LLString listener_name = findEventListener((LLSimpleListener*)itor->listener);
+		if (!listener_name.empty())
+		{
+			LLXMLNodePtr child_node = node->createChild("on_click", FALSE);
+			child_node->createChild("function", TRUE)->setStringValue(listener_name);
+			child_node->createChild("filter", TRUE)->setStringValue(itor->filter.asString());
+			child_node->createChild("userdata", TRUE)->setStringValue(itor->userdata.asString());
+		}
+	}
+
+	return node;
+}
+
+// doIt() - Call the callback provided
+void LLMenuItemCallGL::doIt( void )
+{
+	// RN: menu item can be deleted in callback, so beware
+	getMenu()->setItemLastSelected( this );
+
+	if( mCallback )
+	{
+		mCallback( mUserData );
+	}
+	LLPointer<LLEvent> fired_event = new LLEvent(this);
+	fireEvent(fired_event, "on_click");
+}
+
+EWidgetType LLMenuItemCallGL::getWidgetType() const 
+{
+	return WIDGET_TYPE_MENU_ITEM_CALL;
+}
+
+LLString LLMenuItemCallGL::getWidgetTag() const
+{
+	return LL_MENU_ITEM_CALL_GL_TAG;
+}
+
+void LLMenuItemCallGL::buildDrawLabel( void )
+{
+	LLPointer<LLEvent> fired_event = new LLEvent(this);
+	fireEvent(fired_event, "on_build");
+	if( mEnabledCallback )
+	{
+		setEnabled( mEnabledCallback( mUserData ) );
+	}
+	if(mLabelCallback)
+	{
+		LLString label;
+		mLabelCallback(label, mUserData);
+		mLabel = label;
+	}
+	LLMenuItemGL::buildDrawLabel();
+}
+
+BOOL LLMenuItemCallGL::handleAcceleratorKey( KEY key, MASK mask )
+{
+ 	if( (!gKeyboard->getKeyRepeated(key) || mAllowKeyRepeat) && (key == mAcceleratorKey) && (mask == mAcceleratorMask) )
+	{
+		LLPointer<LLEvent> fired_event = new LLEvent(this);
+		fireEvent(fired_event, "on_build");
+		if( mEnabledCallback )
+		{
+			setEnabled( mEnabledCallback( mUserData ) );
+		}
+		if( !mEnabled )
+		{
+			if( mOnDisabledCallback )
+			{
+				mOnDisabledCallback( mUserData );
+			}
+		}
+	}
+	return LLMenuItemGL::handleAcceleratorKey(key, mask);
+}
+
+///============================================================================
+/// Class LLMenuItemCheckGL
+///============================================================================
+
+LLMenuItemCheckGL::LLMenuItemCheckGL ( const LLString& name, 
+									   const LLString& label,
+									   menu_callback clicked_cb,
+									   enabled_callback enabled_cb,
+									   check_callback check_cb,
+									   void* user_data,
+									   KEY key, MASK mask ) :
+	LLMenuItemCallGL( name, label, clicked_cb, enabled_cb, user_data, key, mask ),
+	mCheckCallback( check_cb ), 
+	mChecked(FALSE)
+{
+}
+
+LLMenuItemCheckGL::LLMenuItemCheckGL ( const LLString& name, 
+									   menu_callback clicked_cb,
+									   enabled_callback enabled_cb,
+									   check_callback check_cb,
+									   void* user_data,
+									   KEY key, MASK mask ) :
+	LLMenuItemCallGL( name, name, clicked_cb, enabled_cb, user_data, key, mask ),
+	mCheckCallback( check_cb ), 
+	mChecked(FALSE)
+{
+}
+
+LLMenuItemCheckGL::LLMenuItemCheckGL ( const LLString& name, 
+									   const LLString& label,
+									   menu_callback clicked_cb,
+									   enabled_callback enabled_cb,
+									   LLString control_name,
+									   LLView *context,
+									   void* user_data,
+									   KEY key, MASK mask ) :
+	LLMenuItemCallGL( name, label, clicked_cb, enabled_cb, user_data, key, mask ),
+	mCheckCallback( NULL )
+{
+	setControlName(control_name, context);
+}
+
+void LLMenuItemCheckGL::setCheckedControl(LLString checked_control, LLView *context)
+{
+	// Register new listener
+	if (!checked_control.empty())
+	{
+		LLControlBase *control = context->findControl(checked_control);
+		if (control)
+		{
+			LLSD state = control->registerListener(this, "CHECKED");
+			mChecked = state;
+		}
+		else
+		{
+			context->addBoolControl(checked_control, mChecked);
+			control = context->findControl(checked_control);
+			control->registerListener(this, "CHECKED");
+		}
+	}
+}
+
+// virtual
+bool LLMenuItemCheckGL::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+	if (userdata.asString() == "CHECKED" && event->desc() == "value_changed")
+	{
+		LLSD state = event->getValue();
+		mChecked = state;
+		if(mChecked)
+		{
+			mDrawBoolLabel = BOOLEAN_TRUE_PREFIX;
+		}
+		else
+		{
+			mDrawBoolLabel.clear();
+		}
+		return TRUE;
+	}
+	return LLMenuItemCallGL::handleEvent(event, userdata);
+}
+
+// virtual
+LLXMLNodePtr LLMenuItemCheckGL::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLMenuItemCallGL::getXML();
+	return node;
+}
+
+EWidgetType LLMenuItemCheckGL::getWidgetType() const 
+{ 
+	return WIDGET_TYPE_MENU_ITEM_CHECK;
+}
+
+LLString LLMenuItemCheckGL::getWidgetTag() const
+{
+	return LL_MENU_ITEM_CHECK_GL_TAG;
+}
+
+// called to rebuild the draw label
+void LLMenuItemCheckGL::buildDrawLabel( void )
+{
+	if(mChecked || (mCheckCallback && mCheckCallback( mUserData ) ) )
+	{
+		mDrawBoolLabel = BOOLEAN_TRUE_PREFIX;
+	}
+	else
+	{
+		mDrawBoolLabel.clear();
+	}
+	LLMenuItemCallGL::buildDrawLabel();
+}
+
+
+///============================================================================
+/// Class LLMenuItemToggleGL
+///============================================================================
+
+LLMenuItemToggleGL::LLMenuItemToggleGL( const LLString& name, const LLString& label, BOOL* toggle,
+										KEY key, MASK mask ) :
+	LLMenuItemGL( name, label, key, mask ),
+	mToggle( toggle )
+{
+}
+
+LLMenuItemToggleGL::LLMenuItemToggleGL( const LLString& name, BOOL* toggle,
+										KEY key, MASK mask ) :
+	LLMenuItemGL( name, name, key, mask ),
+	mToggle( toggle )
+{
+}
+
+
+// called to rebuild the draw label
+void LLMenuItemToggleGL::buildDrawLabel( void )
+{
+	if( *mToggle )
+	{
+		mDrawBoolLabel = BOOLEAN_TRUE_PREFIX;
+	}
+	else
+	{
+		mDrawBoolLabel.clear();
+	}
+	mDrawAccelLabel.clear();
+	LLString st = mDrawAccelLabel;
+	appendAcceleratorString( st );
+	mDrawAccelLabel = st;
+}
+
+// doIt() - do the primary funcationality of the menu item.
+void LLMenuItemToggleGL::doIt( void )
+{
+	getMenu()->setItemLastSelected( this );
+	//llinfos << "LLMenuItemToggleGL::doIt " << mLabel.c_str() << llendl;
+	*mToggle = !(*mToggle);
+	buildDrawLabel();
+}
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemBranchGL
+//
+// The LLMenuItemBranchGL represents a menu item that has a
+// sub-menu. This is used to make cascading menus.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemBranchGL : public LLMenuItemGL
+{
+protected:
+	LLMenuGL* mBranch;
+
+public:
+	LLMenuItemBranchGL( const LLString& name, const LLString& label, LLMenuGL* branch,
+						KEY key = KEY_NONE, MASK mask = MASK_NONE );
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+
+	virtual LLView* getChildByName(const LLString& name, BOOL recurse) const;
+
+	virtual LLString getType() const	{ return "menu"; }
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+
+	virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+
+	// check if we've used these accelerators already
+	virtual BOOL addToAcceleratorList(std::list <LLKeyBinding*> *listp);
+
+	// called to rebuild the draw label
+	virtual void buildDrawLabel( void );
+
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void );
+
+	virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
+
+	// set the hover status (called by it's menu) and if the object is
+	// active. This is used for behavior transfer.
+	virtual void setHighlight( BOOL highlight );
+
+	virtual BOOL handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+
+	virtual BOOL isActive() const	{ return !mBranch->getTornOff() && mBranch->getVisible(); }
+
+	LLMenuGL *getBranch() const { return mBranch; }
+
+	virtual void updateBranchParent( LLView* parentp );
+
+	// LLView Functionality
+	virtual void onVisibilityChange( BOOL curVisibilityIn );
+
+	virtual void draw();
+
+	virtual void setEnabledSubMenus(BOOL enabled);
+};
+
+LLMenuItemBranchGL::LLMenuItemBranchGL( const LLString& name, const LLString& label, LLMenuGL* branch,
+										KEY key, MASK mask ) :
+	LLMenuItemGL( name, label, key, mask ),
+	mBranch( branch )
+{
+	mBranch->setVisible( FALSE );
+	mBranch->setParentMenuItem(this);
+}
+
+// virtual
+LLView* LLMenuItemBranchGL::getChildByName(const LLString& name, BOOL recurse) const
+{
+	if (mBranch->getName() == name)
+	{
+		return mBranch;
+	}
+	// Always recurse on branches
+	return mBranch->getChildByName(name, recurse);
+}
+
+EWidgetType LLMenuItemBranchGL::getWidgetType() const
+{
+	return WIDGET_TYPE_MENU_ITEM_BRANCH;
+}
+
+LLString LLMenuItemBranchGL::getWidgetTag() const
+{
+	return LL_MENU_ITEM_BRANCH_GL_TAG;
+}
+
+// virtual
+BOOL LLMenuItemBranchGL::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	if (mEnabled)
+	{
+		doIt();
+		make_ui_sound("UISndClickRelease");
+	}
+	return FALSE;
+}
+
+BOOL LLMenuItemBranchGL::handleAcceleratorKey(KEY key, MASK mask)
+{
+	return mBranch->handleAcceleratorKey(key, mask);
+}
+
+// virtual
+LLXMLNodePtr LLMenuItemBranchGL::getXML(bool save_children) const
+{
+	if (mBranch)
+	{
+		return mBranch->getXML();
+	}
+
+	return LLMenuItemGL::getXML();
+}
+
+
+// This function checks to see if the accelerator key is already in use;
+// if not, it will be added to the list
+BOOL LLMenuItemBranchGL::addToAcceleratorList(std::list<LLKeyBinding*> *listp)
+{
+	U32 item_count = mBranch->getItemCount();
+	LLMenuItemGL *item;
+
+	while (item_count--)
+	{
+		if ((item = mBranch->getItem(item_count)))
+		{
+			return item->addToAcceleratorList(listp);
+		}
+	}
+	return FALSE;
+}
+
+
+// called to rebuild the draw label
+void LLMenuItemBranchGL::buildDrawLabel( void )
+{
+	mDrawAccelLabel.clear();
+	LLString st = mDrawAccelLabel;
+	appendAcceleratorString( st );
+	mDrawAccelLabel = st;
+	mDrawBranchLabel = BRANCH_SUFFIX;
+}
+
+// doIt() - do the primary functionality of the menu item.
+void LLMenuItemBranchGL::doIt( void )
+{
+	if (mBranch->getTornOff())
+	{
+		gFloaterView->bringToFront((LLFloater*)mBranch->getParent());
+		// this might not be necessary, as torn off branches don't get focus and hence no highligth
+		mBranch->highlightNextItem(NULL);
+	}
+	else if( !mBranch->getVisible() )
+	{
+		mBranch->arrange();
+
+		LLRect rect = mBranch->getRect();
+		// calculate root-view relative position for branch menu
+		S32 left = mRect.mRight;
+		S32 top = mRect.mTop - mRect.mBottom;
+
+		localPointToOtherView(left, top, &left, &top, mBranch->getParent());
+
+		rect.setLeftTopAndSize( left, top,
+								rect.getWidth(), rect.getHeight() );
+
+		if (mBranch->getCanTearOff())
+		{
+			rect.translate(0, TEAROFF_SEPARATOR_HEIGHT_PIXELS);
+		}
+		mBranch->setRect( rect );
+		S32 x = 0;
+		S32 y = 0;
+		mBranch->localPointToOtherView( 0, 0, &x, &y, mBranch->getParent() ); 
+		S32 delta_x = 0;
+		S32 delta_y = 0;
+		if( y < 0 )
+		{
+			delta_y = -y;
+		}
+
+		S32 window_width = mBranch->getParent()->getRect().getWidth();
+		if( x > window_width - rect.getWidth() )
+		{
+			// move sub-menu over to left side
+			delta_x = llmax(-x, (-1 * (rect.getWidth() + mRect.getWidth())));
+		}
+		mBranch->translate( delta_x, delta_y );
+		mBranch->setVisible( TRUE );
+	}
+}
+
+BOOL LLMenuItemBranchGL::handleKey(KEY key, MASK mask, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+	if (called_from_parent)
+	{
+		handled = mBranch->handleKey(key, mask, called_from_parent);
+	}
+
+	if (!handled)
+	{
+		handled = LLMenuItemGL::handleKey(key, mask, called_from_parent);
+	}
+
+	return handled;
+}
+
+// set the hover status (called by it's menu)
+void LLMenuItemBranchGL::setHighlight( BOOL highlight )
+{
+	BOOL auto_open = mEnabled && (!mBranch->getVisible() || mBranch->getTornOff());
+	// torn off menus don't open sub menus on hover unless they have focus
+	if (getMenu()->getTornOff() && !((LLFloater*)getMenu()->getParent())->hasFocus())
+	{
+		auto_open = FALSE;
+	}
+	// don't auto open torn off sub-menus (need to explicitly active menu item to give them focus)
+	if (mBranch->getTornOff())
+	{
+		auto_open = FALSE;
+	}
+
+	mHighlight = highlight;
+	if( highlight )
+	{
+		if(auto_open)
+		{
+			doIt();
+		}
+	}
+	else
+	{
+		if (mBranch->getTornOff())
+		{
+			((LLFloater*)mBranch->getParent())->setFocus(FALSE);
+			mBranch->clearHoverItem();
+		}
+		else
+		{
+			mBranch->setVisible( FALSE );
+		}
+	}
+}
+
+void LLMenuItemBranchGL::setEnabledSubMenus(BOOL enabled)
+{
+	mBranch->setEnabledSubMenus(enabled);
+}
+
+void LLMenuItemBranchGL::draw()
+{
+	LLMenuItemGL::draw();
+	if (mBranch->getVisible() && !mBranch->getTornOff())
+	{
+		mHighlight = TRUE;
+	}
+}
+
+void LLMenuItemBranchGL::updateBranchParent(LLView* parentp)
+{
+	if (mBranch->getParent() == NULL)
+	{
+		// make the branch menu a sibling of my parent menu
+		mBranch->updateParent(parentp);
+	}
+}
+
+void LLMenuItemBranchGL::onVisibilityChange( BOOL curVisibilityIn )
+{
+	if (curVisibilityIn == FALSE && mBranch->getVisible() && !mBranch->getTornOff())
+	{
+		mBranch->setVisible(FALSE);
+	}
+}
+
+BOOL LLMenuItemBranchGL::handleKeyHere( KEY key, MASK mask, BOOL called_from_parent )
+{
+	if (getMenu()->getVisible() && mBranch->getVisible() && key == KEY_LEFT)
+	{
+		BOOL handled = mBranch->clearHoverItem();
+		if (handled && getMenu()->getTornOff())
+		{
+			((LLFloater*)getMenu()->getParent())->setFocus(TRUE);
+		}
+		return handled;
+	}
+
+	if (mHighlight && 
+		getMenu()->getVisible() &&
+		// ignore keystrokes on background torn-off menus
+		(!getMenu()->getTornOff() || ((LLFloater*)getMenu()->getParent())->hasFocus()) &&
+		key == KEY_RIGHT && !mBranch->getHighlightedItem())
+	{
+		LLMenuItemGL* itemp = mBranch->highlightNextItem(NULL);
+		if (itemp)
+		{
+			return TRUE;
+		}
+	}
+
+	return LLMenuItemGL::handleKeyHere(key, mask, called_from_parent);
+}
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemBranchDownGL
+//
+// The LLMenuItemBranchDownGL represents a menu item that has a
+// sub-menu. This is used to make menu bar menus.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemBranchDownGL : public LLMenuItemBranchGL
+{
+protected:
+
+public:
+	LLMenuItemBranchDownGL( const LLString& name, const LLString& label, LLMenuGL* branch,
+							KEY key = KEY_NONE, MASK mask = MASK_NONE );
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_MENU_ITEM_BRANCH_DOWN; }
+	virtual LLString getWidgetTag() const { return LL_MENU_ITEM_BRANCH_DOWN_GL_TAG; }
+
+	virtual LLString getType() const	{ return "menu"; }
+
+	// returns the normal width of this control in pixels - this is
+	// used for calculating the widest item, as well as for horizontal
+	// arrangement.
+	virtual U32 getNominalWidth( void );
+
+	// called to rebuild the draw label
+	virtual void buildDrawLabel( void );
+
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void );
+
+	// set the hover status (called by it's menu) and if the object is
+	// active. This is used for behavior transfer.
+	virtual void setHighlight( BOOL highlight );
+
+	// determine if this object is active
+	virtual BOOL isActive( void ) const;
+
+	// LLView functionality
+	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
+	virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask ) {return FALSE; }
+	virtual void draw( void );
+	virtual BOOL handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	
+	virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+};
+
+LLMenuItemBranchDownGL::LLMenuItemBranchDownGL( const LLString& name,
+												const LLString& label,
+												LLMenuGL* branch, 
+												KEY key, MASK mask ) :
+	LLMenuItemBranchGL( name, label, branch, key, mask )
+{
+}
+
+// returns the normal width of this control in pixels - this is used
+// for calculating the widest item, as well as for horizontal
+// arrangement.
+U32 LLMenuItemBranchDownGL::getNominalWidth( void )
+{
+	U32 width = LEFT_PAD_PIXELS + LEFT_WIDTH_PIXELS + RIGHT_PAD_PIXELS;
+	width += mFont->getWidth( mLabel.getWString().c_str() ); 
+	return width;
+}
+
+// called to rebuild the draw label
+void LLMenuItemBranchDownGL::buildDrawLabel( void )
+{
+	mDrawAccelLabel.clear();
+	LLString st = mDrawAccelLabel;
+	appendAcceleratorString( st );
+	mDrawAccelLabel = st;
+}
+
+// doIt() - do the primary funcationality of the menu item.
+void LLMenuItemBranchDownGL::doIt( void )
+{
+	if( mBranch->getVisible() && !mBranch->getTornOff() )
+	{
+		mBranch->setVisible( FALSE );
+	}
+	else
+	{
+		if (mBranch->getTornOff())
+		{
+			gFloaterView->bringToFront((LLFloater*)mBranch->getParent());
+		}
+		else
+		{
+			// We're showing the drop-down menu, so patch up its labels/rects
+			mBranch->arrange();
+
+			LLRect rect = mBranch->getRect();
+			S32 left = 0;
+			S32 top = mRect.mBottom;
+			localPointToOtherView(left, top, &left, &top, mBranch->getParent());
+
+			rect.setLeftTopAndSize( left, top,
+									rect.getWidth(), rect.getHeight() );
+			mBranch->setRect( rect );
+			S32 x = 0;
+			S32 y = 0;
+			mBranch->localPointToScreen( 0, 0, &x, &y ); 
+			S32 delta_x = 0;
+
+			LLCoordScreen window_size;
+			LLWindow* windowp = getWindow();
+			windowp->getSize(&window_size);
+
+			S32 window_width = window_size.mX;
+			if( x > window_width - rect.getWidth() )
+			{
+				delta_x = (window_width - rect.getWidth()) - x;
+			}
+			mBranch->translate( delta_x, 0 );
+
+			//FIXME: get menuholder lookup working more generically
+			// hide existing menus
+			if (!mBranch->getTornOff())
+			{
+				((LLMenuHolderGL*)mBranch->getParent())->hideMenus();
+			}
+
+			mBranch->setVisible( TRUE );
+		}
+	}
+}
+
+// set the hover status (called by it's menu)
+void LLMenuItemBranchDownGL::setHighlight( BOOL highlight )
+{
+	mHighlight = highlight;
+	if( !highlight)
+	{
+		if (mBranch->getTornOff())
+		{
+			((LLFloater*)mBranch->getParent())->setFocus(FALSE);
+			mBranch->clearHoverItem();
+		}
+		else
+		{
+			mBranch->setVisible( FALSE );
+		}
+	}
+}
+
+// determine if this object is active
+// which, for branching menus, means the branch is open and has "focus"
+BOOL LLMenuItemBranchDownGL::isActive( void ) const
+{
+	if (mBranch->getTornOff())
+	{
+		return ((LLFloater*)mBranch->getParent())->hasFocus();
+	}
+	else
+	{
+		return mBranch->getVisible();
+	}
+}
+
+BOOL LLMenuItemBranchDownGL::handleMouseDown( S32 x, S32 y, MASK mask )
+{
+	doIt();
+	make_ui_sound("UISndClick");
+	return TRUE;
+}
+
+
+BOOL LLMenuItemBranchDownGL::handleAcceleratorKey(KEY key, MASK mask)
+{
+	BOOL branch_visible = mBranch->getVisible();
+	BOOL handled = mBranch->handleAcceleratorKey(key, mask);
+	if (handled && !branch_visible)
+	{
+		// flash this menu entry because we triggered an invisible menu item
+		LLMenuHolderGL::setActivatedItem(this);
+	}
+
+	return handled;
+}
+
+BOOL LLMenuItemBranchDownGL::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	if (mHighlight && getMenu()->getVisible() && mBranch->getVisible())
+	{
+		if (key == KEY_LEFT)
+		{
+			LLMenuItemGL* itemp = getMenu()->highlightPrevItem(this);
+			if (itemp)
+			{
+				itemp->doIt();
+			}
+
+			return TRUE;
+		}
+		else if (key == KEY_RIGHT)
+		{
+			LLMenuItemGL* itemp = getMenu()->highlightNextItem(this);
+			if (itemp)
+			{
+				itemp->doIt();
+			}
+
+			return TRUE;
+		}
+		else if (key == KEY_DOWN)
+		{
+			if (!mBranch->getTornOff())
+			{
+				mBranch->setVisible(TRUE);
+			}
+			mBranch->highlightNextItem(NULL);
+			return TRUE;
+		}
+		else if (key == KEY_UP)
+		{
+			if (!mBranch->getTornOff())
+			{
+				mBranch->setVisible(TRUE);
+			}
+			mBranch->highlightPrevItem(NULL);
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+void LLMenuItemBranchDownGL::draw( void )
+{
+	if( mHighlight )
+	{
+		glColor4fv( sHighlightBackground.mV );
+		gl_rect_2d( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+	}
+
+	U8 font_style = mStyle;
+	if (LLMenuItemGL::sDropShadowText && getEnabled() && !mDrawTextDisabled )
+	{
+		font_style |= LLFontGL::DROP_SHADOW;
+	}
+
+	LLColor4 color;
+	if (mHighlight)
+	{
+		color = sHighlightForeground;
+	}
+	else if( mEnabled )
+	{
+		color = sEnabledColor;
+	}
+	else
+	{
+		color = sDisabledColor;
+	}
+	mFont->render( mLabel.getWString(), 0, (F32)mRect.getWidth() / 2.f, (F32)LABEL_BOTTOM_PAD_PIXELS, color,
+				   LLFontGL::HCENTER, LLFontGL::BOTTOM, font_style );
+	// if branching menu is closed clear out highlight
+	if (mHighlight && ((!mBranch->getVisible() /*|| mBranch->getTornOff()*/) && !mGotHover))
+	{
+		setHighlight(FALSE);
+	}
+
+	// underline navigation key
+	BOOL draw_jump_key = gKeyboard->currentMask(FALSE) == MASK_ALT && 
+								(!getMenu()->getHighlightedItem() || !getMenu()->getHighlightedItem()->isActive()) &&
+								(!getMenu()->getTornOff()); // torn off menus don't use jump keys, too complicated
+
+	if (draw_jump_key)
+	{
+		LLString upper_case_label = mLabel.getString();
+		LLString::toUpper(upper_case_label);
+		std::string::size_type offset = upper_case_label.find(mJumpKey);
+		if (offset != std::string::npos)
+		{
+			S32 x_offset = llround((F32)mRect.getWidth() / 2.f - mFont->getWidthF32(mLabel.getString(), 0, S32_MAX) / 2.f);
+			S32 x_begin = x_offset + mFont->getWidth(mLabel, 0, offset);
+			S32 x_end = x_offset + mFont->getWidth(mLabel, 0, offset + 1);
+			gl_line_2d(x_begin, LABEL_BOTTOM_PAD_PIXELS, x_end, LABEL_BOTTOM_PAD_PIXELS);
+		}
+	}
+
+	// reset every frame so that we only show highlight 
+	// when we get hover events on that frame
+	mGotHover = FALSE;
+}
+
+///============================================================================
+/// Class LLMenuGL
+///============================================================================
+
+// Default constructor
+LLMenuGL::LLMenuGL( const LLString& name, const LLString& label, LLViewHandle parent_floater_handle )
+:	LLUICtrl( name, LLRect(), FALSE, NULL, NULL ),
+	mBackgroundColor( sDefaultBackgroundColor ),
+	mBgVisible( TRUE ),
+	mParentMenuItem( NULL ),
+	mLabel( label ),
+	mDropShadowed( TRUE ),
+	mHorizontalLayout( FALSE ),
+	mKeepFixedSize( FALSE ),
+	mLastMouseX(0),
+	mLastMouseY(0),
+	mMouseVelX(0),
+	mMouseVelY(0),
+	mTornOff(FALSE),
+	mTearOffItem(NULL),
+	mSpilloverBranch(NULL),
+	mSpilloverMenu(NULL),
+	mParentFloaterHandle(parent_floater_handle),
+	mJumpKey(KEY_NONE)
+{
+	mFadeTimer.stop();
+	setCanTearOff(TRUE, parent_floater_handle);
+	setTabStop(FALSE);
+}
+
+LLMenuGL::LLMenuGL( const LLString& label, LLViewHandle parent_floater_handle )
+:	LLUICtrl( label, LLRect(), FALSE, NULL, NULL ),
+	mBackgroundColor( sDefaultBackgroundColor ),
+	mBgVisible( TRUE ),
+	mParentMenuItem( NULL ),
+	mLabel( label ),
+	mDropShadowed( TRUE ),
+	mHorizontalLayout( FALSE ),
+	mKeepFixedSize( FALSE ),
+	mLastMouseX(0),
+	mLastMouseY(0),
+	mMouseVelX(0),
+	mMouseVelY(0),
+	mTornOff(FALSE),
+	mTearOffItem(NULL),
+	mSpilloverBranch(NULL),
+	mSpilloverMenu(NULL),
+	mParentFloaterHandle(parent_floater_handle),
+	mJumpKey(KEY_NONE)
+{
+	mFadeTimer.stop();
+	setCanTearOff(TRUE, parent_floater_handle);
+	setTabStop(FALSE);
+}
+
+// Destroys the object
+LLMenuGL::~LLMenuGL( void )
+{
+	// delete the branch, as it might not be in view hierarchy
+	// leave the menu, because it is always in view hierarchy
+	delete mSpilloverBranch;
+	mJumpKeys.clear();
+}
+
+void LLMenuGL::setCanTearOff(BOOL tear_off, LLViewHandle parent_floater_handle )
+{
+	if (tear_off && mTearOffItem == NULL)
+	{
+		mTearOffItem = new LLMenuItemTearOffGL(parent_floater_handle);
+		mItems.insert(mItems.begin(), mTearOffItem);
+		addChildAtEnd(mTearOffItem);
+		arrange();
+	}
+	else if (!tear_off && mTearOffItem != NULL)
+	{
+		mItems.remove(mTearOffItem);
+		removeChild(mTearOffItem);
+		delete mTearOffItem;
+		mTearOffItem = NULL;
+		arrange();
+	}
+}
+
+// virtual
+LLXMLNodePtr LLMenuGL::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLView::getXML();
+
+	// Attributes
+
+	node->createChild("opaque", TRUE)->setBoolValue(mBgVisible);
+
+	node->createChild("drop_shadow", TRUE)->setBoolValue(mDropShadowed);
+
+	node->createChild("tear_off", TRUE)->setBoolValue((mTearOffItem != NULL));
+
+	if (mBgVisible)
+	{
+		// TomY TODO: this should save out the color control name
+		node->createChild("color", TRUE)->setFloatValue(4, mBackgroundColor.mV);
+	}
+
+	// Contents
+	item_list_t::const_iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		LLView* child = (*item_iter);
+		LLMenuItemGL* item = (LLMenuItemGL*)child;
+
+		LLXMLNodePtr child_node = item->getXML();
+
+		node->addChild(child_node);
+	}
+
+	return node;
+}
+
+void LLMenuGL::parseChildXML(LLXMLNodePtr child, LLView *parent, LLUICtrlFactory *factory)
+{
+	if (child->hasName(LL_MENU_GL_TAG))
+	{
+		// SUBMENU
+		LLMenuGL *submenu = (LLMenuGL*)LLMenuGL::fromXML(child, parent, factory);
+		appendMenu(submenu);
+		if (LLMenuGL::sDefaultMenuContainer != NULL)
+		{
+			submenu->updateParent(LLMenuGL::sDefaultMenuContainer);
+		}
+		else
+		{
+			submenu->updateParent(parent);
+		}
+	}
+	else if (child->hasName(LL_MENU_ITEM_CALL_GL_TAG) || 
+			child->hasName(LL_MENU_ITEM_CHECK_GL_TAG) || 
+			child->hasName(LL_MENU_ITEM_SEPARATOR_GL_TAG))
+	{
+		LLMenuItemGL *item = NULL;
+
+		LLString type;
+		LLString item_name;
+		LLString source_label;
+		LLString item_label;
+		KEY		 jump_key = KEY_NONE;
+
+		child->getAttributeString("type", type);
+		child->getAttributeString("name", item_name);
+		child->getAttributeString("label", source_label);
+
+		// parse jump key out of label
+		typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+		boost::char_separator<char> sep("_");
+		tokenizer tokens(source_label, sep);
+		tokenizer::iterator token_iter;
+		S32 token_count = 0;
+		for( token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
+		{
+			item_label += (*token_iter);
+			if (token_count > 0)
+			{
+				jump_key = (*token_iter).c_str()[0];
+			}
+			++token_count;
+		}
+
+
+		if (child->hasName(LL_MENU_ITEM_SEPARATOR_GL_TAG))
+		{
+			appendSeparator(item_name);
+		}
+		else
+		{
+			// ITEM
+			if (child->hasName(LL_MENU_ITEM_CALL_GL_TAG) || 
+				child->hasName(LL_MENU_ITEM_CHECK_GL_TAG))
+			{
+				MASK mask = 0;
+				LLString shortcut;
+				child->getAttributeString("shortcut", shortcut);
+				if (shortcut.find("control") != shortcut.npos)
+				{
+					mask |= MASK_CONTROL;
+				}
+				if (shortcut.find("alt") != shortcut.npos)
+				{
+					mask |= MASK_ALT;
+				}
+				if (shortcut.find("shift") != shortcut.npos)
+				{
+					mask |= MASK_SHIFT;
+				}
+				S32 pipe_pos = shortcut.rfind("|");
+				LLString key_str = shortcut.substr(pipe_pos+1);
+
+				KEY key = KEY_NONE;
+				LLKeyboard::keyFromString(key_str, &key);
+
+				LLMenuItemCallGL *new_item;
+				LLXMLNodePtr call_child;
+
+				if (child->hasName(LL_MENU_ITEM_CHECK_GL_TAG))
+				{
+					LLString control_name;
+					child->getAttributeString("control_name", control_name);
+
+					new_item = new LLMenuItemCheckGL(item_name, item_label, 0, 0, control_name, parent, 0, key, mask);
+
+					for (call_child = child->getFirstChild(); call_child.notNull(); call_child = call_child->getNextSibling())
+					{
+						if (call_child->hasName("on_check"))
+						{
+							LLString callback_name;
+							LLString control_name = "";
+							if (call_child->hasAttribute("function"))
+							{
+								call_child->getAttributeString("function", callback_name);
+
+								control_name = callback_name;
+
+								LLString callback_data = item_name;
+								if (call_child->hasAttribute("userdata"))
+								{
+									call_child->getAttributeString("userdata", callback_data);
+									if (!callback_data.empty())
+									{
+										control_name = llformat("%s(%s)", callback_name.c_str(), callback_data.c_str());
+									}
+								}
+
+								LLSD userdata;
+								userdata["control"] = control_name;
+								userdata["data"] = callback_data;
+
+								LLSimpleListener* callback = parent->getListenerByName(callback_name);
+
+								if (!callback) continue;
+
+								new_item->addListener(callback, "on_build", userdata);
+							}
+							else if (call_child->hasAttribute("control"))
+							{
+								call_child->getAttributeString("control", control_name);
+							}
+							else
+							{
+								continue;
+							}
+							LLControlBase *control = parent->findControl(control_name);
+							if (!control)
+							{
+								parent->addBoolControl(control_name, FALSE);
+							}
+							((LLMenuItemCheckGL*)new_item)->setCheckedControl(control_name, parent);
+						}
+					}
+				}
+				else
+				{
+					new_item = new LLMenuItemCallGL(item_name, item_label, 0, 0, 0, 0, key, mask);
+				}
+
+				for (call_child = child->getFirstChild(); call_child.notNull(); call_child = call_child->getNextSibling())
+				{
+					if (call_child->hasName("on_click"))
+					{
+						LLString callback_name;
+						call_child->getAttributeString("function", callback_name);
+
+						LLString callback_data = item_name;
+						if (call_child->hasAttribute("userdata"))
+						{
+							call_child->getAttributeString("userdata", callback_data);
+						}
+
+						LLSimpleListener* callback = parent->getListenerByName(callback_name);
+
+						if (!callback) continue;
+
+						new_item->addListener(callback, "on_click", callback_data);
+					}
+					if (call_child->hasName("on_enable"))
+					{
+						LLString callback_name;
+						LLString control_name = "";
+						if (call_child->hasAttribute("function"))
+						{
+							call_child->getAttributeString("function", callback_name);
+
+							control_name = callback_name;
+
+							LLString callback_data = "";
+							if (call_child->hasAttribute("userdata"))
+							{
+								call_child->getAttributeString("userdata", callback_data);
+								if (!callback_data.empty())
+								{
+									control_name = llformat("%s(%s)", callback_name.c_str(), callback_data.c_str());
+								}
+							}
+
+							LLSD userdata;
+							userdata["control"] = control_name;
+							userdata["data"] = callback_data;
+
+							LLSimpleListener* callback = parent->getListenerByName(callback_name);
+
+							if (!callback) continue;
+
+							new_item->addListener(callback, "on_build", userdata);
+						}
+						else if (call_child->hasAttribute("control"))
+						{
+							call_child->getAttributeString("control", control_name);
+						}
+						else
+						{
+							continue;
+						}
+						new_item->setEnabledControl(control_name, parent);
+					}
+					if (call_child->hasName("on_visible"))
+					{
+						LLString callback_name;
+						LLString control_name = "";
+						if (call_child->hasAttribute("function"))
+						{
+							call_child->getAttributeString("function", callback_name);
+
+							control_name = callback_name;
+
+							LLString callback_data = "";
+							if (call_child->hasAttribute("userdata"))
+							{
+								call_child->getAttributeString("userdata", callback_data);
+								if (!callback_data.empty())
+								{
+									control_name = llformat("%s(%s)", callback_name.c_str(), callback_data.c_str());
+								}
+							}
+
+							LLSD userdata;
+							userdata["control"] = control_name;
+							userdata["data"] = callback_data;
+
+							LLSimpleListener* callback = parent->getListenerByName(callback_name);
+
+							if (!callback) continue;
+
+							new_item->addListener(callback, "on_build", userdata);
+						}
+						else if (call_child->hasAttribute("control"))
+						{
+							call_child->getAttributeString("control", control_name);
+						}
+						else
+						{
+							continue;
+						}
+						new_item->setVisibleControl(control_name, parent);
+					}
+				}
+				item = new_item;
+				item->setLabel(item_label);
+				item->setJumpKey(jump_key);
+			}
+
+			if (item != NULL)
+			{
+				append(item);
+			}
+		}
+	}
+}
+
+// static
+LLView* LLMenuGL::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("menu");
+	node->getAttributeString("name", name);
+
+	LLString label = name;
+	node->getAttributeString("label", label);
+
+	// parse jump key out of label
+	LLString new_menu_label;
+
+	typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+	boost::char_separator<char> sep("_");
+	tokenizer tokens(label, sep);
+	tokenizer::iterator token_iter;
+
+	KEY jump_key = KEY_NONE;
+	S32 token_count = 0;
+	for( token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
+	{
+		new_menu_label += (*token_iter);
+		if (token_count > 0)
+		{
+			jump_key = (*token_iter).c_str()[0];
+		}
+		++token_count;
+	}
+
+	BOOL opaque = FALSE;
+	node->getAttributeBOOL("opaque", opaque);
+
+	LLMenuGL *menu = new LLMenuGL(name, new_menu_label);
+
+	menu->setJumpKey(jump_key);
+
+	BOOL tear_off = FALSE;
+	node->getAttributeBOOL("tear_off", tear_off);
+	menu->setCanTearOff(tear_off);
+
+	if (node->hasAttribute("drop_shadow"))
+	{
+		BOOL drop_shadow = FALSE;
+		node->getAttributeBOOL("drop_shadow", drop_shadow);
+		menu->setDropShadowed(drop_shadow);
+	}
+
+	menu->setBackgroundVisible(opaque);
+	LLColor4 color(0,0,0,1);
+	if (opaque && LLUICtrlFactory::getAttributeColor(node,"color", color))
+	{
+		menu->setBackgroundColor(color);
+	}
+
+	BOOL create_jump_keys = FALSE;
+	node->getAttributeBOOL("create_jump_keys", create_jump_keys);
+
+	LLXMLNodePtr child;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		menu->parseChildXML(child, parent, factory);
+	}
+
+	if (create_jump_keys)
+	{
+		menu->createJumpKeys();
+	}
+	return menu;
+}
+
+// control the color scheme
+void LLMenuGL::setDefaultBackgroundColor( const LLColor4& color )
+{
+	sDefaultBackgroundColor = color;
+}
+
+void LLMenuGL::setBackgroundColor( const LLColor4& color )
+{
+	mBackgroundColor = color;
+}
+
+// rearrange the child rects so they fit the shape of the menu.
+void LLMenuGL::arrange( void )
+{
+	// calculate the height & width, and set our rect based on that
+	// information.
+	LLRect initial_rect = mRect;
+
+	U32 width = 0, height = MENU_ITEM_PADDING;
+
+	cleanupSpilloverBranch();
+
+	if( mItems.size() ) 
+	{
+		U32 max_width = (getParent() != NULL) ? getParent()->getRect().getWidth() : U32_MAX;
+		U32 max_height = (getParent() != NULL) ? getParent()->getRect().getHeight() : U32_MAX;
+		//FIXME: create the item first and then ask for its dimensions?
+		S32 spillover_item_width = PLAIN_PAD_PIXELS + LLFontGL::sSansSerif->getWidth( "More" );
+		S32 spillover_item_height = llround(LLFontGL::sSansSerif->getLineHeight()) + MENU_ITEM_PADDING;
+
+		if (mHorizontalLayout)
+		{
+			item_list_t::iterator item_iter;
+			for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+			{
+				if ((*item_iter)->getVisible())
+				{
+					if (!getTornOff() && width + (*item_iter)->getNominalWidth() > max_width - spillover_item_width)
+					{
+						// no room for any more items
+						createSpilloverBranch();
+
+						item_list_t::iterator spillover_iter;
+						for (spillover_iter = item_iter; spillover_iter != mItems.end(); ++spillover_iter)
+						{
+							LLMenuItemGL* itemp = (*spillover_iter);
+							removeChild(itemp);
+							mSpilloverMenu->append(itemp);
+						}
+						mItems.erase(item_iter, mItems.end());
+						
+						mItems.push_back(mSpilloverBranch);
+						addChild(mSpilloverBranch);
+						height = llmax(height, mSpilloverBranch->getNominalHeight());
+						width += mSpilloverBranch->getNominalWidth();
+
+						break;
+					}
+					else
+					{
+						// track our rect
+						height = llmax(height, (*item_iter)->getNominalHeight());
+						width += (*item_iter)->getNominalWidth();
+					}
+				}
+			}
+		}
+		else
+		{
+			item_list_t::iterator item_iter;
+			for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+			{
+				if ((*item_iter)->getVisible())
+				{
+					if (!getTornOff() && height + (*item_iter)->getNominalHeight() > max_height - spillover_item_height)
+					{
+						// no room for any more items
+						createSpilloverBranch();
+
+						item_list_t::iterator spillover_iter;
+						for (spillover_iter= item_iter; spillover_iter != mItems.end(); ++spillover_iter)
+						{
+							LLMenuItemGL* itemp = (*spillover_iter);
+							removeChild(itemp);
+							mSpilloverMenu->append(itemp);
+						}
+						mItems.erase(item_iter, mItems.end());
+						mItems.push_back(mSpilloverBranch);
+						addChild(mSpilloverBranch);
+						height += mSpilloverBranch->getNominalHeight();
+						width = llmax( width, mSpilloverBranch->getNominalWidth() );
+
+						break;
+					}
+					else
+					{
+						// track our rect
+						height += (*item_iter)->getNominalHeight();
+						width = llmax( width, (*item_iter)->getNominalWidth() );
+					}
+				}
+			}
+		}
+
+		mRect.mRight = mRect.mLeft + width;
+		mRect.mTop = mRect.mBottom + height;
+
+		S32 cur_height = (S32)llmin(max_height, height);
+		S32 cur_width = 0;
+		item_list_t::iterator item_iter;
+		for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+		{
+			if ((*item_iter)->getVisible())
+			{
+				// setup item rect to hold label
+				LLRect rect;
+				if (mHorizontalLayout)
+				{
+					rect.setLeftTopAndSize( cur_width, height, (*item_iter)->getNominalWidth(), height);
+					cur_width += (*item_iter)->getNominalWidth();
+				}
+				else
+				{
+					rect.setLeftTopAndSize( 0, cur_height, width, (*item_iter)->getNominalHeight());
+					cur_height -= (*item_iter)->getNominalHeight();
+				}
+				(*item_iter)->setRect( rect );
+				(*item_iter)->buildDrawLabel();
+			}
+		}
+	}
+	if (mKeepFixedSize)
+	{
+		reshape(initial_rect.getWidth(), initial_rect.getHeight());
+	}
+}
+
+void LLMenuGL::createSpilloverBranch()
+{
+	if (!mSpilloverBranch)
+	{
+		// should be NULL but delete anyway
+		delete mSpilloverMenu;
+		// technically, you can't tear off spillover menus, but we're passing the handle
+		// along just to be safe
+		mSpilloverMenu = new LLMenuGL("More", "More", mParentFloaterHandle);
+		mSpilloverMenu->updateParent(getParent());
+		// Inherit colors
+		mSpilloverMenu->setBackgroundColor( mBackgroundColor );
+		mSpilloverMenu->setCanTearOff(FALSE);
+
+		mSpilloverBranch = new LLMenuItemBranchGL("More", "More", mSpilloverMenu);
+		mSpilloverBranch->setFontStyle(LLFontGL::ITALIC);
+	}
+}
+
+void LLMenuGL::cleanupSpilloverBranch()
+{
+	if (mSpilloverBranch && mSpilloverBranch->getParent() == this)
+	{
+		// head-recursion to propagate items back up to root menu
+		mSpilloverMenu->cleanupSpilloverBranch();
+
+		removeChild(mSpilloverBranch);
+
+		item_list_t::iterator found_iter = std::find(mItems.begin(), mItems.end(), mSpilloverBranch);
+		if (found_iter != mItems.end())
+		{
+			mItems.erase(found_iter);
+		}
+
+		// pop off spillover items
+		while (mSpilloverMenu->getItemCount())
+		{
+			LLMenuItemGL* itemp = mSpilloverMenu->getItem(0);
+			mSpilloverMenu->removeChild(itemp);
+			mSpilloverMenu->mItems.erase(mSpilloverMenu->mItems.begin());
+			// put them at the end of our own list
+			mItems.push_back(itemp);
+			addChild(itemp);
+		}
+	}
+}
+
+void LLMenuGL::createJumpKeys()
+{
+	mJumpKeys.clear();
+
+	std::set<LLString> unique_words;
+	std::set<LLString> shared_words;
+
+	item_list_t::iterator item_it;
+	typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+	boost::char_separator<char> sep(" ");
+
+	for(item_it = mItems.begin(); item_it != mItems.end(); ++item_it)
+	{
+		LLString uppercase_label = (*item_it)->getLabel();
+		LLString::toUpper(uppercase_label);
+
+		tokenizer tokens(uppercase_label, sep);
+		tokenizer::iterator token_iter;
+		for( token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
+		{
+			if (unique_words.find(*token_iter) != unique_words.end())
+			{
+				// this word exists in more than one menu instance
+				shared_words.insert(*token_iter);
+			}
+			else
+			{
+				// we have a new word, keep track of it
+				unique_words.insert(*token_iter);
+			}
+		}
+	}
+
+	// pre-assign specified jump keys
+	for(item_it = mItems.begin(); item_it != mItems.end(); ++item_it)
+	{
+		KEY jump_key = (*item_it)->getJumpKey();
+		if(jump_key != KEY_NONE)
+		{
+			if (mJumpKeys.find(jump_key) == mJumpKeys.end())
+			{
+				mJumpKeys.insert(std::pair<KEY, LLMenuItemGL*>(jump_key, (*item_it)));
+			}
+			else
+			{
+				// this key is already spoken for, 
+				// so we need to reassign it below
+				(*item_it)->setJumpKey(KEY_NONE);
+			}
+		}
+	}
+
+	for(item_it = mItems.begin(); item_it != mItems.end(); ++item_it)
+	{
+		// skip over items that already have assigned jump keys
+		if ((*item_it)->getJumpKey() != KEY_NONE)
+		{
+			continue;
+		}
+		LLString uppercase_label = (*item_it)->getLabel();
+		LLString::toUpper(uppercase_label);
+
+		tokenizer tokens(uppercase_label, sep);
+		tokenizer::iterator token_iter;
+
+		BOOL found_key = FALSE;
+		for( token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
+		{
+			LLString uppercase_word = *token_iter;
+
+			// this word is not shared with other menu entries...
+			if (shared_words.find(*token_iter) == shared_words.end())
+			{
+				S32 i;
+				for(i = 0; i < (S32)uppercase_word.size(); i++)
+				{
+					char jump_key = uppercase_word[i];
+					
+					if (LLStringOps::isDigit(jump_key) || LLStringOps::isUpper(jump_key) &&
+						mJumpKeys.find(jump_key) == mJumpKeys.end())
+					{
+						mJumpKeys.insert(std::pair<KEY, LLMenuItemGL*>(jump_key, (*item_it)));
+						(*item_it)->setJumpKey(jump_key);
+						found_key = TRUE;
+						break;
+					}
+				}
+			}
+			if (found_key)
+			{
+				break;
+			}
+		}
+	}
+}
+
+// remove all items on the menu
+void LLMenuGL::empty( void )
+{
+	mItems.clear();
+
+	deleteAllChildren();
+	
+}
+
+// Adjust rectangle of the menu
+void LLMenuGL::setLeftAndBottom(S32 left, S32 bottom)
+{
+	mRect.mLeft = left;
+	mRect.mBottom = bottom;
+	arrange();
+}
+
+void LLMenuGL::handleJumpKey(KEY key)
+{
+	navigation_key_map_t::iterator found_it = mJumpKeys.find(key);
+	if(found_it != mJumpKeys.end() && found_it->second->getEnabled())
+	{
+		clearHoverItem();
+		// force highlight to close old menus and open and sub-menus
+		found_it->second->setHighlight(TRUE);
+		found_it->second->doIt();
+		if (!found_it->second->isActive() && !getTornOff())
+		{
+			// parent is a menu holder, because this is not a menu bar
+			((LLMenuHolderGL*)getParent())->hideMenus();
+		}
+	}
+}
+
+
+// Add the menu item to this menu.
+BOOL LLMenuGL::append( LLMenuItemGL* item )
+{
+	mItems.push_back( item );
+	addChild( item );
+	arrange();
+	return TRUE;
+}
+
+// add a separator to this menu
+BOOL LLMenuGL::appendSeparator( const LLString &separator_name )
+{
+	LLMenuItemGL* separator = new LLMenuItemSeparatorGL(separator_name);
+	return append( separator );
+}
+
+// add a menu - this will create a cascading menu
+BOOL LLMenuGL::appendMenu( LLMenuGL* menu )
+{
+	if( menu == this )
+	{
+		llerrs << "** Attempt to attach menu to itself. This is certainly "
+			   << "a logic error." << llendl;
+	}
+	BOOL success = TRUE;
+
+	LLMenuItemBranchGL* branch = NULL;
+	branch = new LLMenuItemBranchGL( menu->getName(), menu->getLabel(), menu );
+	branch->setJumpKey(menu->getJumpKey());
+	success &= append( branch );
+
+	// Inherit colors
+	menu->setBackgroundColor( mBackgroundColor );
+
+	return success;
+}
+
+void LLMenuGL::setEnabledSubMenus(BOOL enable)
+{
+	setEnabled(enable);
+	item_list_t::iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		(*item_iter)->setEnabledSubMenus( enable );
+	}
+}
+
+// setItemEnabled() - pass the label and the enable flag for a menu
+// item. TRUE will make sure it's enabled, FALSE will disable it.
+void LLMenuGL::setItemEnabled( const LLString& name, BOOL enable )
+{
+	item_list_t::iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		if( (*item_iter)->getName() == name )
+		{
+			(*item_iter)->setEnabled( enable );
+			(*item_iter)->setEnabledSubMenus( enable );
+			break;
+		}
+	}
+}
+
+void LLMenuGL::setItemVisible( const LLString& name, BOOL visible )
+{
+	item_list_t::iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		if( (*item_iter)->getName() == name )
+		{
+			(*item_iter)->setVisible( visible );
+			break;
+		}
+	}
+}
+
+void LLMenuGL::setItemLastSelected(LLMenuItemGL* item)
+{
+	if (getVisible())
+	{
+		LLMenuHolderGL::setActivatedItem(item);
+	}
+
+	// fix the checkmarks
+	item->buildDrawLabel();
+}
+
+//  Set whether drop shadowed 
+void LLMenuGL::setDropShadowed( const BOOL shadowed )
+{
+	mDropShadowed = shadowed;
+}
+
+void LLMenuGL::setTornOff(BOOL torn_off)
+{ 
+	mTornOff = torn_off;
+}
+
+U32 LLMenuGL::getItemCount()
+{
+	return mItems.size();
+}
+
+LLMenuItemGL* LLMenuGL::getItem(S32 number)
+{
+	if (number >= 0 && number < (S32)mItems.size())
+	{
+		item_list_t::iterator item_iter;
+		for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+		{
+			if (number == 0)
+			{
+				return (*item_iter);
+			}
+			number--;
+		}
+	}
+	return NULL;
+}
+
+LLMenuItemGL* LLMenuGL::getHighlightedItem()
+{
+	item_list_t::iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		if ((*item_iter)->getHighlight())
+		{
+			return (*item_iter);
+		}
+	}
+	return NULL;
+}
+
+LLMenuItemGL* LLMenuGL::highlightNextItem(LLMenuItemGL* cur_item, BOOL skip_disabled)
+{
+	// highlighting first item on a torn off menu is the
+	// same as giving focus to it
+	if (!cur_item && getTornOff())
+	{
+		((LLFloater*)getParent())->setFocus(TRUE);
+	}
+
+	item_list_t::iterator cur_item_iter;
+	for (cur_item_iter = mItems.begin(); cur_item_iter != mItems.end(); ++cur_item_iter)
+	{
+		if( (*cur_item_iter) == cur_item)
+		{
+			break;
+		}
+	}
+
+	item_list_t::iterator next_item_iter;
+	if (cur_item_iter == mItems.end())
+	{
+		next_item_iter = mItems.begin();
+	}
+	else
+	{
+		next_item_iter = cur_item_iter;
+		next_item_iter++;
+		if (next_item_iter == mItems.end())
+		{
+			next_item_iter = mItems.begin();
+		}
+	}
+
+	// when first highlighting a menu, skip over tear off menu item
+	if (mTearOffItem && !cur_item)
+	{
+		// we know the first item is the tear off menu item
+		cur_item_iter = mItems.begin();
+		next_item_iter++;
+		if (next_item_iter == mItems.end())
+		{
+			next_item_iter = mItems.begin();
+		}
+	}
+
+	while(1)
+	{
+		// skip separators and disabled items
+		if ((*next_item_iter)->getEnabled() && (*next_item_iter)->getName() != SEPARATOR_NAME)
+		{
+			if (cur_item)
+			{
+				cur_item->setHighlight(FALSE);
+			}
+			(*next_item_iter)->setHighlight(TRUE);
+			return (*next_item_iter);
+		}
+
+
+		if (!skip_disabled || next_item_iter == cur_item_iter)
+		{
+			break;
+		}
+
+		next_item_iter++;
+		if (next_item_iter == mItems.end())
+		{
+			if (cur_item_iter == mItems.end())
+			{
+				break;
+			}
+			next_item_iter = mItems.begin();
+		}
+	}
+
+	return NULL;
+}
+
+LLMenuItemGL* LLMenuGL::highlightPrevItem(LLMenuItemGL* cur_item, BOOL skip_disabled)
+{
+	// highlighting first item on a torn off menu is the
+	// same as giving focus to it
+	if (!cur_item && getTornOff())
+	{
+		((LLFloater*)getParent())->setFocus(TRUE);
+	}
+
+	item_list_t::reverse_iterator cur_item_iter;
+	for (cur_item_iter = mItems.rbegin(); cur_item_iter != mItems.rend(); ++cur_item_iter)
+	{
+		if( (*cur_item_iter) == cur_item)
+		{
+			break;
+		}
+	}
+
+	item_list_t::reverse_iterator prev_item_iter;
+	if (cur_item_iter == mItems.rend())
+	{
+		prev_item_iter = mItems.rbegin();
+	}
+	else
+	{
+		prev_item_iter = cur_item_iter;
+		prev_item_iter++;
+		if (prev_item_iter == mItems.rend())
+		{
+			prev_item_iter = mItems.rbegin();
+		}
+	}
+
+	while(1)
+	{
+		// skip separators and disabled items
+		if ((*prev_item_iter)->getEnabled() && (*prev_item_iter)->getName() != SEPARATOR_NAME)
+		{
+			if (cur_item)
+			{
+				cur_item->setHighlight(FALSE);
+			}
+			(*prev_item_iter)->setHighlight(TRUE);
+			return (*prev_item_iter);
+		}
+
+		if (!skip_disabled || prev_item_iter == cur_item_iter)
+		{
+			break;
+		}
+
+		prev_item_iter++;
+		if (prev_item_iter == mItems.rend())
+		{
+			if (cur_item_iter == mItems.rend())
+			{
+				break;
+			}
+
+			prev_item_iter = mItems.rbegin();
+		}
+	}
+
+	return NULL;
+}
+
+void LLMenuGL::buildDrawLabels()
+{
+	item_list_t::iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		(*item_iter)->buildDrawLabel();
+	}
+}
+
+void LLMenuGL::updateParent(LLView* parentp)
+{
+	if (getParent())
+	{
+		getParent()->removeChild(this);
+	}
+	parentp->addChild(this);
+	item_list_t::iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		(*item_iter)->updateBranchParent(parentp);
+	}
+}
+
+// LLView functionality
+BOOL LLMenuGL::handleKey( KEY key, MASK mask, BOOL called_from_parent )
+{
+	BOOL handled = FALSE;
+
+	// Pass down even if not visible
+	if( mEnabled && called_from_parent )
+	{
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			if (viewp->handleKey(key, mask, TRUE))
+			{
+				handled = TRUE;
+				break;
+			}
+		}
+	}
+
+	if( !handled )
+	{
+		handled = handleKeyHere( key, mask, called_from_parent );
+		if (handled && LLView::sDebugKeys)
+		{
+			llinfos << "Key handled by " << getName() << llendl;
+		}
+	}
+
+	return handled;
+}
+
+BOOL LLMenuGL::handleAcceleratorKey(KEY key, MASK mask)
+{
+	// Pass down even if not visible
+	item_list_t::iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		LLMenuItemGL* itemp = *item_iter;
+		if (itemp->handleAcceleratorKey(key, mask))
+		{
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL LLMenuGL::handleKeyHere( KEY key, MASK mask, BOOL called_from_parent )
+{
+	if (key < KEY_SPECIAL && getVisible() && getEnabled() && mask == MASK_ALT)
+	{
+		if (getTornOff())
+		{
+			// torn off menus do not handle jump keys (for now, the interaction is complex)
+			return FALSE;
+		}
+		handleJumpKey(key);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+BOOL LLMenuGL::handleHover( S32 x, S32 y, MASK mask )
+{
+	// leave submenu in place if slope of mouse < MAX_MOUSE_SLOPE_SUB_MENU
+	S32 mouse_delta_x = x - mLastMouseX;
+	S32 mouse_delta_y = y - mLastMouseY;
+	LLVector2 mouse_dir((F32)mouse_delta_x, (F32)mouse_delta_y);
+	mouse_dir.normVec();
+	LLVector2 mouse_avg_dir((F32)mMouseVelX, (F32)mMouseVelY);
+	mouse_avg_dir.normVec();
+	F32 interp = 0.5f * (llclamp(mouse_dir * mouse_avg_dir, 0.f, 1.f));
+	mMouseVelX = llround(lerp((F32)mouse_delta_x, (F32)mMouseVelX, interp));
+	mMouseVelY = llround(lerp((F32)mouse_delta_y, (F32)mMouseVelY, interp));
+	mLastMouseX = x;
+	mLastMouseY = y;
+
+	// don't change menu focus unless mouse is moving or alt key is not held down
+	if ((gKeyboard->currentMask(FALSE) != MASK_ALT || 
+			llabs(mMouseVelX) > 0 || 
+			llabs(mMouseVelY) > 0) &&
+		(!mHasSelection ||
+		//(mouse_delta_x == 0 && mouse_delta_y == 0) ||
+		(mMouseVelX < 0) ||
+		llabs((F32)mMouseVelY) / llabs((F32)mMouseVelX) > MAX_MOUSE_SLOPE_SUB_MENU))
+	{
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->getRect().mLeft;
+			S32 local_y = y - viewp->getRect().mBottom;
+			if (!viewp->pointInView(local_x, local_y) && ((LLMenuItemGL*)viewp)->getHighlight())
+			{
+				// moving mouse always highlights new item
+				if (mouse_delta_x != 0 || mouse_delta_y != 0)
+				{
+					((LLMenuItemGL*)viewp)->setHighlight(FALSE);
+				}
+			}
+		}
+
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->getRect().mLeft;
+			S32 local_y = y - viewp->getRect().mBottom;
+			//RN: always call handleHover to track mGotHover status
+			// but only set highlight when mouse is moving
+			if( viewp->getVisible() && 
+				viewp->getEnabled() &&
+				viewp->pointInView(local_x, local_y) && 
+				viewp->handleHover(local_x, local_y, mask))
+			{
+				// moving mouse always highlights new item
+				if (mouse_delta_x != 0 || mouse_delta_y != 0)
+				{
+					((LLMenuItemGL*)viewp)->setHighlight(TRUE);
+				}
+				mHasSelection = TRUE;
+			}
+		}
+	}
+	getWindow()->setCursor(UI_CURSOR_ARROW);
+	return TRUE;
+}
+
+BOOL LLMenuGL::handleMouseUp( S32 x, S32 y, MASK mask )
+{
+	if( LLView::childrenHandleMouseUp( x, y, mask ) )
+	{
+		if (!getTornOff())
+		{
+			((LLMenuHolderGL*)getParent())->hideMenus();
+		}
+	}
+
+	return TRUE;
+}
+
+void LLMenuGL::draw( void )
+{
+	if (mDropShadowed && !mTornOff)
+	{
+		gl_drop_shadow(0, mRect.getHeight(), mRect.getWidth(), 0, 
+			LLUI::sColorsGroup->getColor("ColorDropShadow"), 
+			LLUI::sConfigGroup->getS32("DropShadowFloater") );
+	}
+
+	LLColor4 bg_color = mBackgroundColor;
+
+	if( mBgVisible )
+	{
+		gl_rect_2d( 0, mRect.getHeight(), mRect.getWidth(), 0, mBackgroundColor );
+	}
+	LLView::draw();
+}
+
+void LLMenuGL::drawBackground(LLMenuItemGL* itemp, LLColor4& color)
+{
+	glColor4fv( color.mV );
+	LLRect item_rect = itemp->getRect();
+	gl_rect_2d( 0, item_rect.getHeight(), item_rect.getWidth(), 0);
+}
+
+void LLMenuGL::setVisible(BOOL visible)
+{
+	if (visible != getVisible())
+	{
+		if (!visible)
+		{
+			mFadeTimer.start();
+			clearHoverItem();
+		}
+		else
+		{
+			mHasSelection = FALSE;
+			mFadeTimer.stop();
+		}
+
+		//gViewerWindow->finishFastFrame();
+		LLView::setVisible(visible);
+	}
+}
+
+LLMenuGL* LLMenuGL::getChildMenuByName(const LLString& name, BOOL recurse) const
+{
+	LLView* view = getChildByName(name, recurse);
+	if (view)
+	{
+		if (view->getWidgetType() == WIDGET_TYPE_MENU_ITEM_BRANCH)
+		{
+			LLMenuItemBranchGL *branch = (LLMenuItemBranchGL *)view;
+			return branch->getBranch();
+		}
+		if (view->getWidgetType() == WIDGET_TYPE_MENU || view->getWidgetType() == WIDGET_TYPE_PIE_MENU)
+		{
+			return (LLMenuGL*)view;
+		}
+	}
+	llwarns << "Child Menu " << name << " not found in menu " << mName << llendl;
+	return NULL;
+}
+
+BOOL LLMenuGL::clearHoverItem(BOOL include_active)
+{
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLMenuItemGL* itemp = (LLMenuItemGL*)*child_it;
+		if (itemp->getHighlight() && (include_active || !itemp->isActive()))
+		{
+			itemp->setHighlight(FALSE);
+			return TRUE;
+		}
+	}		
+	return FALSE;
+}
+
+void hide_top_view( LLView* view )
+{
+	if( view ) view->setVisible( FALSE );
+}
+
+
+// static
+void LLMenuGL::showPopup(LLView* spawning_view, LLMenuGL* menu, S32 x, S32 y)
+{
+	const S32 HPAD = 2;
+	LLRect rect = menu->getRect();
+	//LLView* cur_view = spawning_view;
+	S32 left = x + HPAD;
+	S32 top = y;
+	spawning_view->localPointToOtherView(left, top, &left, &top, menu->getParent());
+	rect.setLeftTopAndSize( left, top,
+							rect.getWidth(), rect.getHeight() );
+
+
+	//rect.setLeftTopAndSize(x + HPAD, y, rect.getWidth(), rect.getHeight());
+	menu->setRect( rect );
+
+	S32 bottom;
+	left = rect.mLeft;
+	bottom = rect.mBottom;
+	//menu->getParent()->localPointToScreen( rect.mLeft, rect.mBottom, 
+	//									&left, &bottom ); 
+	S32 delta_x = 0;
+	S32 delta_y = 0;
+	if( bottom < 0 )
+	{
+		delta_y = -bottom;
+	}
+
+	S32 parent_width = menu->getParent()->getRect().getWidth();
+	if( left > parent_width - rect.getWidth() )
+	{
+		// At this point, we need to move the context menu to the
+		// other side of the mouse.
+		//delta_x = (window_width - rect.getWidth()) - x;
+		delta_x = -(rect.getWidth() + 2 * HPAD);
+	}
+	menu->translate( delta_x, delta_y );
+	menu->setVisible( TRUE );
+}
+
+//-----------------------------------------------------------------------------
+// class LLPieMenuBranch
+// A branch to another pie menu
+//-----------------------------------------------------------------------------
+class LLPieMenuBranch : public LLMenuItemGL
+{
+public:
+	LLPieMenuBranch(const LLString& name, const LLString& label, LLPieMenu* branch,
+					enabled_callback ecb, void* user_data);
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_PIE_MENU_BRANCH; }
+	virtual LLString getWidgetTag() const { return LL_PIE_MENU_BRANCH_TAG; }
+
+	// called to rebuild the draw label
+	virtual void buildDrawLabel( void );
+
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void );
+
+	LLPieMenu* getBranch() { return mBranch; }
+
+protected:
+	LLPieMenu* mBranch;
+	enabled_callback mEnabledCallback;
+	void* mUserData;
+};
+
+LLPieMenuBranch::LLPieMenuBranch(const LLString& name,
+								 const LLString& label,
+								 LLPieMenu* branch,
+								 enabled_callback ecb,
+								 void* user_data) 
+:	LLMenuItemGL( name, label, KEY_NONE, MASK_NONE ),
+	mBranch( branch ),
+	mEnabledCallback( ecb ),
+	mUserData(user_data)
+{
+	mBranch->hide(FALSE);
+	mBranch->setParentMenuItem(this);
+}
+
+// called to rebuild the draw label
+void LLPieMenuBranch::buildDrawLabel( void )
+{
+	if(mEnabledCallback)
+	{
+		setEnabled(mEnabledCallback(mUserData));
+		mDrawTextDisabled = FALSE;
+	}
+	else
+	{
+		// default enablement is this -- if any of the subitems are
+		// enabled, this item is enabled. JC
+		U32 sub_count = mBranch->getItemCount();
+		U32 i;
+		BOOL any_enabled = FALSE;
+		for (i = 0; i < sub_count; i++)
+		{
+			LLMenuItemGL* item = mBranch->getItem(i);
+			item->buildDrawLabel();
+			if (item->getEnabled() && !item->getDrawTextDisabled() )
+			{
+				any_enabled = TRUE;
+				break;
+			}
+		}
+		mDrawTextDisabled = !any_enabled;
+		setEnabled(TRUE);
+	}
+
+	mDrawAccelLabel.clear();
+	LLString st = mDrawAccelLabel;
+	appendAcceleratorString( st );
+	mDrawAccelLabel = st;
+	
+	// No special branch suffix
+	mDrawBranchLabel.clear();
+}
+
+// doIt() - do the primary funcationality of the menu item.
+void LLPieMenuBranch::doIt( void )
+{
+	LLPieMenu *parent = (LLPieMenu *)getParent();
+
+	LLRect rect = parent->getRect();
+	S32 center_x;
+	S32 center_y;
+	parent->localPointToScreen(rect.getWidth() / 2, rect.getHeight() / 2, &center_x, &center_y);
+
+	parent->hide(TRUE);
+	mBranch->show(	center_x, center_y, FALSE );
+}
+
+//-----------------------------------------------------------------------------
+// class LLPieMenu
+// A circular menu of items, icons, etc.
+//-----------------------------------------------------------------------------
+LLPieMenu::LLPieMenu(const LLString& name, const LLString& label)
+:	LLMenuGL(name, label),
+	mFirstMouseDown(FALSE),
+	mUseInfiniteRadius(FALSE),
+	mHoverItem(NULL),
+	mHoverThisFrame(FALSE),
+	mOuterRingAlpha(1.f),
+	mCurRadius(0.f),
+	mRightMouseDown(FALSE)
+{ 
+	LLMenuGL::setVisible(FALSE);
+	setCanTearOff(FALSE);
+}
+
+LLPieMenu::LLPieMenu(const LLString& name)
+:	LLMenuGL(name, name),
+	mFirstMouseDown(FALSE),
+	mUseInfiniteRadius(FALSE),
+	mHoverItem(NULL),
+	mHoverThisFrame(FALSE),
+	mOuterRingAlpha(1.f),
+	mCurRadius(0.f),
+	mRightMouseDown(FALSE)
+{ 
+	LLMenuGL::setVisible(FALSE);
+	setCanTearOff(FALSE);
+}
+
+// virtual
+LLPieMenu::~LLPieMenu()
+{ }
+
+
+EWidgetType LLPieMenu::getWidgetType() const
+{
+	return WIDGET_TYPE_PIE_MENU;
+}
+
+LLString LLPieMenu::getWidgetTag() const
+{
+	return LL_PIE_MENU_TAG;
+}
+
+void LLPieMenu::initXML(LLXMLNodePtr node, LLView *context, LLUICtrlFactory *factory)
+{
+	LLXMLNodePtr child;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		if (child->hasName(LL_PIE_MENU_TAG))
+		{
+			// SUBMENU
+			LLString name("menu");
+			child->getAttributeString("name", name);
+			LLString label(name);
+			child->getAttributeString("label", label);
+
+			LLPieMenu *submenu = new LLPieMenu(name, label);
+			appendMenu(submenu);
+			submenu->initXML(child, context, factory);
+		}
+		else
+		{
+			parseChildXML(child, context, factory);
+		}
+	}
+}
+
+// virtual
+void LLPieMenu::setVisible(BOOL visible)
+{
+	if (!visible)
+	{
+		hide(FALSE);
+	}
+}
+
+BOOL LLPieMenu::handleHover( S32 x, S32 y, MASK mask )
+{
+	// This is mostly copied from the llview class, but it continues
+	// the hover handle code after a hover handler has been found.
+	BOOL handled = FALSE;
+
+	// If we got a hover event, we've already moved the cursor
+	// for any menu shifts, so subsequent mouseup messages will be in the
+	// correct position.  No need to correct them.
+	//mShiftHoriz = 0;
+	//mShiftVert = 0;
+
+	// release mouse capture after short period of visibility if we're using a finite boundary
+	// so that right click outside of boundary will trigger new pie menu
+	if (gFocusMgr.getMouseCapture() == this && 
+		!mRightMouseDown && 
+		mShrinkBorderTimer.getStarted() && 
+		mShrinkBorderTimer.getElapsedTimeF32() >= PIE_SHRINK_TIME)
+	{
+		gFocusMgr.setMouseCapture(NULL, NULL);
+		mUseInfiniteRadius = FALSE;
+	}
+
+	LLMenuItemGL *item = pieItemFromXY( x, y );
+
+	if (item && item->getEnabled())
+	{
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;		
+		handled = TRUE;
+
+		if (item != mHoverItem)
+		{
+			BOOL active = FALSE;
+			if (mHoverItem)
+			{
+				active = mHoverItem->isActive();
+				mHoverItem->setHighlight( FALSE );
+			}
+			mHoverItem = item;
+			mHoverItem->setHighlight( TRUE );
+
+			switch(pieItemIndexFromXY(x, y))
+			{
+			case 0:
+				make_ui_sound("UISndPieMenuSliceHighlight0");
+				break;
+			case 1:
+				make_ui_sound("UISndPieMenuSliceHighlight1");
+				break;
+			case 2:
+				make_ui_sound("UISndPieMenuSliceHighlight2");
+				break;
+			case 3:
+				make_ui_sound("UISndPieMenuSliceHighlight3");
+				break;
+			case 4:
+				make_ui_sound("UISndPieMenuSliceHighlight4");
+				break;
+			case 5:
+				make_ui_sound("UISndPieMenuSliceHighlight5");
+				break;
+			case 6:
+				make_ui_sound("UISndPieMenuSliceHighlight6");
+				break;
+			case 7:
+				make_ui_sound("UISndPieMenuSliceHighlight7");
+				break;
+			default:
+				make_ui_sound("UISndPieMenuSliceHighlight0");
+				break;
+			}
+		}
+	}
+	else
+	{
+		// clear out our selection
+		if (mHoverItem)
+		{
+			mHoverItem->setHighlight(FALSE);
+			mHoverItem = NULL;
+		}
+	}
+
+	if( !handled && pointInView( x, y ) )
+	{
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;		
+		handled = TRUE;
+	}
+
+	mHoverThisFrame = TRUE;
+
+	return handled;
+}
+
+BOOL LLPieMenu::handleMouseDown( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = FALSE;
+	// The click was somewhere within our rectangle
+	LLMenuItemGL *item = pieItemFromXY( x, y );
+
+	if (item)
+	{
+		// lie to the item about where the click happened
+		// to make sure it's within the item's rectangle
+		handled = item->handleMouseDown( 0, 0, mask );
+	}
+
+	// always handle mouse down as mouse up will close open menus
+	return handled;
+}
+
+BOOL LLPieMenu::handleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = FALSE;
+
+	mRightMouseDown = TRUE;
+
+	// The click was somewhere within our rectangle
+	LLMenuItemGL *item = pieItemFromXY( x, y );
+	S32 delta_x = x /*+ mShiftHoriz*/ - getLocalRect().getCenterX();
+	S32 delta_y = y /*+ mShiftVert*/ - getLocalRect().getCenterY();
+	BOOL clicked_in_pie = ((delta_x * delta_x) + (delta_y * delta_y) < mCurRadius*mCurRadius) || mUseInfiniteRadius;
+
+	// grab mouse if right clicking anywhere within pie (even deadzone in middle), to detect drag outside of pie
+	if (clicked_in_pie)
+	{
+		// capture mouse cursor as if on initial menu show
+		gFocusMgr.setMouseCapture(this, NULL);
+		mShrinkBorderTimer.stop();
+		mUseInfiniteRadius = TRUE;
+		handled = TRUE;
+	}
+	
+	if (item)
+	{
+		// lie to the item about where the click happened
+		// to make sure it's within the item's rectangle
+		if (item->handleMouseDown( 0, 0, mask ))
+		{
+			handled = TRUE;
+		}
+	}
+
+	return handled;
+}
+
+BOOL LLPieMenu::handleRightMouseUp( S32 x, S32 y, MASK mask )
+{
+	// release mouse capture when right mouse button released, and we're past the shrink time
+	if (mShrinkBorderTimer.getStarted() && 
+		mShrinkBorderTimer.getElapsedTimeF32() > PIE_SHRINK_TIME)
+	{
+		mUseInfiniteRadius = FALSE;
+		gFocusMgr.setMouseCapture(NULL, NULL);
+	}
+
+	BOOL result = handleMouseUp( x, y, mask );
+	mRightMouseDown = FALSE;
+
+	return result;
+}
+
+BOOL LLPieMenu::handleMouseUp( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = FALSE;
+
+	// The click was somewhere within our rectangle
+	LLMenuItemGL *item = pieItemFromXY( x, y );
+
+	if (item)
+	{
+		// lie to the item about where the click happened
+		// to make sure it's within the item's rectangle
+		if (item->getEnabled())
+		{
+			handled = item->handleMouseUp( 0, 0, mask );
+			hide(TRUE);
+		}
+	}
+
+	if (handled)
+	{
+		make_ui_sound("UISndClickRelease");
+	}
+
+	if (!handled && !mUseInfiniteRadius)
+	{
+		// call hidemenus to make sure transient selections get cleared
+		((LLMenuHolderGL*)getParent())->hideMenus();
+	}
+
+	if (mFirstMouseDown)
+	{
+		make_ui_sound("UISndPieMenuAppear");
+		mFirstMouseDown = FALSE;
+	}
+	
+	//FIXME: is this necessary?
+	if (!mShrinkBorderTimer.getStarted())
+	{
+		mShrinkBorderTimer.start();
+	}
+
+	return handled;
+}
+
+
+// virtual
+void LLPieMenu::draw()
+{
+	// clear hover if mouse moved away
+	if (!mHoverThisFrame && mHoverItem)
+	{
+		mHoverItem->setHighlight(FALSE);
+		mHoverItem = NULL;
+	}
+
+	F32 width = (F32) mRect.getWidth();
+	F32 height = (F32) mRect.getHeight();
+	mCurRadius = PIE_SCALE_FACTOR * llmax( width/2, height/2 );
+
+	mOuterRingAlpha = mUseInfiniteRadius ? 0.f : 1.f;
+	if (mShrinkBorderTimer.getStarted())
+	{
+		mOuterRingAlpha = clamp_rescale(mShrinkBorderTimer.getElapsedTimeF32(), 0.f, PIE_SHRINK_TIME, 0.f, 1.f);
+		mCurRadius *= clamp_rescale(mShrinkBorderTimer.getElapsedTimeF32(), 0.f, PIE_SHRINK_TIME, 1.f, 1.f / PIE_SCALE_FACTOR);
+	}
+
+	// correct for non-square pixels
+	F32 center_x = width/2;
+	F32 center_y = height/2;
+	S32 steps = 100;
+
+	glPushMatrix();
+	{
+		glTranslatef(center_x, center_y, 0.f);
+
+		F32 line_width = LLUI::sConfigGroup->getF32("PieMenuLineWidth");
+		LLColor4 line_color = LLUI::sColorsGroup->getColor("PieMenuLineColor");
+		LLColor4 bg_color = LLUI::sColorsGroup->getColor("PieMenuBgColor");
+		LLColor4 selected_color = LLUI::sColorsGroup->getColor("PieMenuSelectedColor");
+
+		// main body
+		LLColor4 outer_color = bg_color;
+		outer_color.mV[VALPHA] *= mOuterRingAlpha;
+		gl_washer_2d( mCurRadius, (F32) PIE_CENTER_SIZE, steps, bg_color, outer_color );
+
+		// selected wedge
+		item_list_t::iterator item_iter;
+		S32 i = 0;
+		for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+		{
+			if ((*item_iter)->getHighlight())
+			{
+				F32 arc_size = F_PI * 0.25f;
+
+				F32 start_radians = (i * arc_size) - (arc_size * 0.5f);
+				F32 end_radians = start_radians + arc_size;
+
+				LLColor4 outer_color = selected_color;
+				outer_color.mV[VALPHA] *= mOuterRingAlpha;
+				gl_washer_segment_2d( mCurRadius, (F32)PIE_CENTER_SIZE, start_radians, end_radians, steps / 8, selected_color, outer_color );
+			}
+			i++;
+		}
+
+		LLUI::setLineWidth( line_width );
+
+		// inner lines
+		outer_color = line_color;
+		outer_color.mV[VALPHA] *= mOuterRingAlpha;
+		gl_washer_spokes_2d( mCurRadius, (F32)PIE_CENTER_SIZE, 8, line_color, outer_color );
+
+		// inner circle
+		glColor4fv( line_color.mV );
+		gl_circle_2d( 0, 0, (F32)PIE_CENTER_SIZE, steps, FALSE );
+
+		// outer circle
+		glColor4fv( outer_color.mV );
+		gl_circle_2d( 0, 0, mCurRadius, steps, FALSE );
+
+		LLUI::setLineWidth(1.0f);
+	}
+	glPopMatrix();
+
+	mHoverThisFrame = FALSE;
+
+	LLView::draw();
+}
+
+void LLPieMenu::drawBackground(LLMenuItemGL* itemp, LLColor4& color)
+{
+	F32 width = (F32) mRect.getWidth();
+	F32 height = (F32) mRect.getHeight();
+	F32 center_x = width/2;
+	F32 center_y = height/2;
+	S32 steps = 100;
+
+	glColor4fv( color.mV );
+	glPushMatrix();
+	{
+		glTranslatef(center_x - itemp->getRect().mLeft, center_y - itemp->getRect().mBottom, 0.f);
+
+		item_list_t::iterator item_iter;
+		S32 i = 0;
+		for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+		{
+			if ((*item_iter) == itemp)
+			{
+				F32 arc_size = F_PI * 0.25f;
+
+				F32 start_radians = (i * arc_size) - (arc_size * 0.5f);
+				F32 end_radians = start_radians + arc_size;
+
+				LLColor4 outer_color = color;
+				outer_color.mV[VALPHA] *= mOuterRingAlpha;
+				gl_washer_segment_2d( mCurRadius, (F32)PIE_CENTER_SIZE, start_radians, end_radians, steps / 8, color, outer_color );
+			}
+			i++;
+		}
+	}
+	glPopMatrix();
+}
+
+// virtual
+BOOL LLPieMenu::append(LLMenuItemGL *item)
+{
+	item->setBriefItem(TRUE);
+	item->setFont( LLFontGL::sSansSerifSmall );
+	return LLMenuGL::append(item);
+}
+
+// virtual
+BOOL LLPieMenu::appendSeparator(const LLString &separator_name)
+{
+	LLMenuItemGL* separator = new LLMenuItemBlankGL();
+	separator->setFont( LLFontGL::sSansSerifSmall );
+	return append( separator );
+}
+
+
+// virtual
+BOOL LLPieMenu::appendMenu(LLPieMenu *menu,
+						   enabled_callback enabled_cb,
+						   void* user_data)
+{
+	if (menu == this)
+	{
+		llerrs << "Can't attach a pie menu to itself" << llendl;
+	}
+	LLPieMenuBranch *item;
+	item = new LLPieMenuBranch(menu->getName(), menu->getLabel(), menu, enabled_cb, user_data);
+	getParent()->addChild(item->getBranch());
+	item->setFont( LLFontGL::sSansSerifSmall );
+	return append( item );
+}
+
+// virtual
+void LLPieMenu::arrange()
+{
+	const S32 rect_height = 180;
+	const S32 rect_width = 180;
+
+	// all divide by 6
+	const S32 CARD_X = 60;
+	const S32 DIAG_X = 48;
+	const S32 CARD_Y = 76;
+	const S32 DIAG_Y = 42;
+
+	const S32 ITEM_CENTER_X[] = { CARD_X, DIAG_X,      0, -DIAG_X, -CARD_X, -DIAG_X,       0,  DIAG_X };
+	const S32 ITEM_CENTER_Y[] = {      0, DIAG_Y, CARD_Y,  DIAG_Y,       0, -DIAG_Y, -CARD_Y, -DIAG_Y };
+
+	LLRect rect;
+	
+	S32 font_height = 0;
+	if( mItems.size() )
+	{
+		font_height = (*mItems.begin())->getNominalHeight();
+	}
+	S32 item_width = 0;
+
+//	F32 sin_delta = OO_SQRT2;	// sin(45 deg)
+//	F32 cos_delta = OO_SQRT2;	// cos(45 deg)
+
+	// TODO: Compute actual bounding rect for menu
+
+	mRect.setOriginAndSize(mRect.mLeft, mRect.mBottom, rect_width, rect_height );
+
+	// place items around a circle, with item 0 at positive X,
+	// rotating counter-clockwise
+	item_list_t::iterator item_iter;
+	S32 i = 0;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		LLMenuItemGL *item = *item_iter;
+
+		item_width = item->getNominalWidth();
+
+		// Put in the right place around a circle centered at 0,0
+		rect.setCenterAndSize(ITEM_CENTER_X[i],
+							  ITEM_CENTER_Y[i], 
+							  item_width, font_height );
+
+		// Correct for the actual rectangle size
+		rect.translate( rect_width/2, rect_height/2 );
+
+		item->setRect( rect );
+
+		// Make sure enablement is correct
+		item->buildDrawLabel();
+		i++;
+	}
+}
+
+LLMenuItemGL *LLPieMenu::pieItemFromXY(S32 x, S32 y)
+{
+	// We might have shifted this menu on draw.  If so, we need
+	// to shift over mouseup events until we get a hover event.
+	//x += mShiftHoriz;
+	//y += mShiftVert; 
+
+	// An arc of the pie menu is 45 degrees
+	const F32 ARC_DEG = 45.f;
+	S32 delta_x = x - mRect.getWidth() / 2;
+	S32 delta_y = y - mRect.getHeight() / 2;
+
+	// circle safe zone in the center
+	S32 dist_squared = delta_x*delta_x + delta_y*delta_y;
+	if (dist_squared < PIE_CENTER_SIZE*PIE_CENTER_SIZE)
+	{
+		return NULL;
+	}
+
+	// infinite radius is only used with right clicks
+	S32 radius = llmax( mRect.getWidth()/2, mRect.getHeight()/2 );
+	if (!(mUseInfiniteRadius && mRightMouseDown) && dist_squared > radius * radius)
+	{
+		return NULL;
+	}
+
+	F32 angle = RAD_TO_DEG * (F32) atan2((F32)delta_y, (F32)delta_x);
+	
+	// rotate marks CCW so that east = [0, ARC_DEG) instead of
+	// [-ARC_DEG/2, ARC_DEG/2)
+	angle += ARC_DEG / 2.f;
+
+	// make sure we're only using positive angles
+	if (angle < 0.f) angle += 360.f;
+
+	S32 which = S32( angle / ARC_DEG );
+
+	if (0 <= which && which < (S32)mItems.size() )
+	{
+		item_list_t::iterator item_iter;
+		for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+		{
+			if (which == 0)
+			{
+				return (*item_iter);
+			}
+			which--;
+		}
+	}
+
+	return NULL;
+}
+
+S32 LLPieMenu::pieItemIndexFromXY(S32 x, S32 y)
+{
+	// An arc of the pie menu is 45 degrees
+	const F32 ARC_DEG = 45.f;
+	// correct for non-square pixels
+	S32 delta_x = x - mRect.getWidth() / 2;
+	S32 delta_y = y - mRect.getHeight() / 2;
+
+	// circle safe zone in the center
+	if (delta_x*delta_x + delta_y*delta_y < PIE_CENTER_SIZE*PIE_CENTER_SIZE)
+	{
+		return -1;
+	}
+
+	F32 angle = RAD_TO_DEG * (F32) atan2((F32)delta_y, (F32)delta_x);
+	
+	// rotate marks CCW so that east = [0, ARC_DEG) instead of
+	// [-ARC_DEG/2, ARC_DEG/2)
+	angle += ARC_DEG / 2.f;
+
+	// make sure we're only using positive angles
+	if (angle < 0.f) angle += 360.f;
+
+	S32 which = S32( angle / ARC_DEG );
+	return which;
+}
+
+void LLPieMenu::show(S32 x, S32 y, BOOL mouse_down)
+{
+	S32 width = mRect.getWidth();
+	S32 height = mRect.getHeight();
+
+	LLView* parent_view = getParent();
+	S32 menu_region_width = parent_view->getRect().getWidth();
+	S32 menu_region_height = parent_view->getRect().getHeight();
+
+	BOOL moved = FALSE;
+
+	S32 local_x, local_y;
+	parent_view->screenPointToLocal(x, y, &local_x, &local_y);
+
+	mRect.setCenterAndSize(local_x, local_y, width, height);
+	arrange();
+
+	// Adjust the pie rectangle to keep it on screen
+	if (mRect.mLeft < 0) 
+	{
+		//mShiftHoriz = 0 - mRect.mLeft;
+		//mRect.translate( mShiftHoriz, 0 );
+		mRect.translate( 0 - mRect.mLeft, 0 );
+		moved = TRUE;
+	}
+
+	if (mRect.mRight > menu_region_width) 
+	{
+		//mShiftHoriz = menu_region_width - mRect.mRight;
+		//mRect.translate( mShiftHoriz, 0);
+		mRect.translate( menu_region_width - mRect.mRight, 0 );
+		moved = TRUE;
+	}
+
+	if (mRect.mBottom < 0)
+	{
+		//mShiftVert = -mRect.mBottom;
+		//mRect.translate( 0, mShiftVert );
+		mRect.translate( 0, 0 - mRect.mBottom );
+		moved = TRUE;
+	}
+
+
+	if (mRect.mTop > menu_region_height)
+	{
+		//mShiftVert = menu_region_height - mRect.mTop;
+		//mRect.translate( 0, mShiftVert );
+		mRect.translate( 0, menu_region_height - mRect.mTop );
+		moved = TRUE;
+	}
+
+	// If we had to relocate the pie menu, put the cursor in the
+	// center of its rectangle
+	if (moved)
+	{
+		LLCoordGL center;
+		center.mX = (mRect.mLeft + mRect.mRight) / 2;
+		center.mY = (mRect.mTop + mRect.mBottom) / 2;
+
+		LLUI::setCursorPositionLocal(getParent(), center.mX, center.mY);
+	}
+
+	// FIXME: what happens when mouse buttons reversed?
+	mRightMouseDown = mouse_down;
+	mFirstMouseDown = mouse_down;
+	mUseInfiniteRadius = TRUE;
+	if (!mFirstMouseDown)
+	{
+		make_ui_sound("UISndPieMenuAppear");
+	}
+
+	LLView::setVisible(TRUE);
+
+	// we want all mouse events in case user does quick right click again off of pie menu
+	// rectangle, to support gestural menu traversal
+	gFocusMgr.setMouseCapture(this, NULL);
+
+	if (mouse_down)
+	{
+		mShrinkBorderTimer.stop();
+	}
+	else 
+	{
+		mShrinkBorderTimer.start();
+	}
+}
+
+void LLPieMenu::hide(BOOL item_selected)
+{
+	if (!getVisible()) return;
+
+	if (mHoverItem)
+	{
+		mHoverItem->setHighlight( FALSE );
+		mHoverItem = NULL;
+	}
+
+	make_ui_sound("UISndPieMenuHide");
+
+	mFirstMouseDown = FALSE;
+	mRightMouseDown = FALSE;
+	mUseInfiniteRadius = FALSE;
+
+	LLView::setVisible(FALSE);
+
+	gFocusMgr.setMouseCapture(NULL, NULL);
+}
+
+///============================================================================
+/// Class LLMenuBarGL
+///============================================================================
+
+// Default constructor
+LLMenuBarGL::LLMenuBarGL( const LLString& name ) : LLMenuGL ( name, name )
+{
+	mHorizontalLayout = TRUE;
+	setCanTearOff(FALSE);
+	mKeepFixedSize = TRUE;
+}
+
+// Default destructor
+LLMenuBarGL::~LLMenuBarGL()
+{
+	std::for_each(mAccelerators.begin(), mAccelerators.end(), DeletePointer());
+	mAccelerators.clear();
+}
+
+// virtual
+LLXMLNodePtr LLMenuBarGL::getXML(bool save_children) const
+{
+	// Sorty of hacky: reparent items to this and then back at the end of the export
+	LLView *orig_parent = NULL;
+	item_list_t::const_iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		LLMenuItemGL* child = *item_iter;
+		LLMenuItemBranchGL* branch = (LLMenuItemBranchGL*)child;
+		LLMenuGL *menu = branch->getBranch();
+		orig_parent = menu->getParent();
+		menu->updateParent((LLView *)this);
+	}
+
+	LLXMLNodePtr node = LLMenuGL::getXML();
+
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		LLMenuItemGL* child = *item_iter;
+		LLMenuItemBranchGL* branch = (LLMenuItemBranchGL*)child;
+		LLMenuGL *menu = branch->getBranch();
+		menu->updateParent(orig_parent);
+	}
+
+	return node;
+}
+
+LLView* LLMenuBarGL::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("menu");
+	node->getAttributeString("name", name);
+
+	BOOL opaque = FALSE;
+	node->getAttributeBOOL("opaque", opaque);
+
+	LLMenuBarGL *menubar = new LLMenuBarGL(name);
+
+	LLViewHandle parent_handle = LLViewHandle::sDeadHandle;
+	if (parent->getWidgetType() == WIDGET_TYPE_FLOATER)
+	{
+		parent_handle = ((LLFloater*)parent)->getHandle();
+	}
+
+	// We need to have the rect early so that it's around when building
+	// the menu items
+	LLRect view_rect;
+	createRect(node, view_rect, parent, menubar->getRequiredRect());
+	menubar->setRect(view_rect);
+
+	if (node->hasAttribute("drop_shadow"))
+	{
+		BOOL drop_shadow = FALSE;
+		node->getAttributeBOOL("drop_shadow", drop_shadow);
+		menubar->setDropShadowed(drop_shadow);
+	}
+
+	menubar->setBackgroundVisible(opaque);
+	LLColor4 color(0,0,0,0);
+	if (opaque && LLUICtrlFactory::getAttributeColor(node,"color", color))
+	{
+		menubar->setBackgroundColor(color);
+	}
+
+	LLXMLNodePtr child;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		if (child->hasName("menu"))
+		{
+			LLMenuGL *menu = (LLMenuGL*)LLMenuGL::fromXML(child, parent, factory);
+			// because of lazy initialization, have to disable tear off functionality
+			// and then re-enable with proper parent handle
+			if (menu->getCanTearOff())
+			{
+				menu->setCanTearOff(FALSE);
+				menu->setCanTearOff(TRUE, parent_handle);
+			}
+			menubar->appendMenu(menu);
+			if (LLMenuGL::sDefaultMenuContainer != NULL)
+			{
+				menu->updateParent(LLMenuGL::sDefaultMenuContainer);
+			}
+			else
+			{
+				menu->updateParent(parent);
+			}
+		}
+	}
+
+	menubar->initFromXML(node, parent);
+
+	BOOL create_jump_keys = FALSE;
+	node->getAttributeBOOL("create_jump_keys", create_jump_keys);
+	if (create_jump_keys)
+	{
+		menubar->createJumpKeys();
+	}
+
+	return menubar;
+}
+
+void LLMenuBarGL::handleJumpKey(KEY key)
+{
+	navigation_key_map_t::iterator found_it = mJumpKeys.find(key);
+	if(found_it != mJumpKeys.end() && found_it->second->getEnabled())
+	{
+		clearHoverItem();
+		found_it->second->setHighlight(TRUE);
+		found_it->second->doIt();
+	}
+}
+
+// rearrange the child rects so they fit the shape of the menu bar.
+void LLMenuBarGL::arrange( void )
+{
+	U32 pos = 0;
+	LLRect rect( 0, mRect.getHeight(), 0, 0 );
+	item_list_t::const_iterator item_iter;
+	for (item_iter = mItems.begin(); item_iter != mItems.end(); ++item_iter)
+	{
+		LLMenuItemGL* item = *item_iter;
+		rect.mLeft = pos;
+		pos += item->getNominalWidth();
+		rect.mRight = pos;
+		item->setRect( rect );
+		item->buildDrawLabel();
+	}
+}
+
+
+S32 LLMenuBarGL::getRightmostMenuEdge()
+{
+	// Find the last visible menu
+	item_list_t::reverse_iterator item_iter;
+	for (item_iter = mItems.rbegin(); item_iter != mItems.rend(); ++item_iter)
+	{
+		if ((*item_iter)->getVisible())
+		{
+			break;
+		}
+	}
+
+	if (item_iter == mItems.rend())
+	{
+		return 0;
+	}
+	return (*item_iter)->getRect().mRight;
+}
+
+// add a vertical separator to this menu
+BOOL LLMenuBarGL::appendSeparator( const LLString &separator_name )
+{
+	LLMenuItemGL* separator = new LLMenuItemVerticalSeparatorGL();
+	return append( separator );
+}
+
+// add a menu - this will create a drop down menu.
+BOOL LLMenuBarGL::appendMenu( LLMenuGL* menu )
+{
+	if( menu == this )
+	{
+		llerrs << "** Attempt to attach menu to itself. This is certainly "
+			   << "a logic error." << llendl;
+	}
+
+	BOOL success = TRUE;
+
+	LLMenuItemBranchGL* branch = NULL;
+	branch = new LLMenuItemBranchDownGL( menu->getName(), menu->getLabel(), menu );
+	success &= branch->addToAcceleratorList(&mAccelerators);
+	success &= append( branch );
+	branch->setJumpKey(branch->getJumpKey());
+	return success;
+}
+
+BOOL LLMenuBarGL::handleHover( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = FALSE;
+	LLView* active_menu = NULL;
+
+	S32 mouse_delta_x = x - mLastMouseX;
+	S32 mouse_delta_y = y - mLastMouseY;
+	mMouseVelX = (mMouseVelX / 2) + (mouse_delta_x / 2);
+	mMouseVelY = (mMouseVelY / 2) + (mouse_delta_y / 2);
+	mLastMouseX = x;
+	mLastMouseY = y;
+
+	// if nothing currently selected or mouse has moved since last call, pick menu item via mouse
+	// otherwise let keyboard control it
+	if (!getHighlightedItem() || llabs(mMouseVelX) > 0 || llabs(mMouseVelY) > 0)
+	{
+		// find current active menu
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			if (((LLMenuItemGL*)viewp)->isActive())
+			{
+				active_menu = viewp;
+			}
+		}
+
+		// check for new active menu
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->getRect().mLeft;
+			S32 local_y = y - viewp->getRect().mBottom;
+			if( viewp->getVisible() && 
+				viewp->getEnabled() &&
+				viewp->pointInView(local_x, local_y) && 
+				viewp->handleHover(local_x, local_y, mask))
+			{
+				((LLMenuItemGL*)viewp)->setHighlight(TRUE);
+				handled = TRUE;
+				if (active_menu && active_menu != viewp)
+				{
+					((LLMenuItemGL*)viewp)->doIt();
+				}
+			}
+		}
+
+		if (handled)
+		{
+			// set hover false on inactive menus
+			for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+			{
+				LLView* viewp = *child_it;
+				S32 local_x = x - viewp->getRect().mLeft;
+				S32 local_y = y - viewp->getRect().mBottom;
+				if (!viewp->pointInView(local_x, local_y) && ((LLMenuItemGL*)viewp)->getHighlight())
+				{
+					((LLMenuItemGL*)viewp)->setHighlight(FALSE);
+				}
+			}
+		}
+	}
+
+	getWindow()->setCursor(UI_CURSOR_ARROW);
+	
+	return TRUE;
+}
+
+///============================================================================
+/// Class LLMenuHolderGL
+///============================================================================
+LLMenuHolderGL::LLMenuHolderGL()
+:	LLPanel("Menu Holder")
+{
+	setMouseOpaque(FALSE);
+	sItemActivationTimer.stop();
+	mCanHide = TRUE;
+}
+
+LLMenuHolderGL::LLMenuHolderGL(const LLString& name, const LLRect& rect, BOOL mouse_opaque, U32 follows) 
+:	LLPanel(name, rect, FALSE)
+{
+	setMouseOpaque(mouse_opaque);
+	sItemActivationTimer.stop();
+	mCanHide = TRUE;
+}
+
+LLMenuHolderGL::~LLMenuHolderGL()
+{
+}
+
+EWidgetType LLMenuHolderGL::getWidgetType() const
+{
+	return WIDGET_TYPE_MENU_HOLDER;
+}
+
+LLString LLMenuHolderGL::getWidgetTag() const
+{
+	return LL_MENU_HOLDER_GL_TAG;
+}
+
+void LLMenuHolderGL::draw()
+{
+	LLView::draw();
+	// now draw last selected item as overlay
+	LLMenuItemGL* selecteditem = (LLMenuItemGL*)LLView::getViewByHandle(sItemLastSelectedHandle);
+	if (selecteditem && sItemActivationTimer.getStarted() && sItemActivationTimer.getElapsedTimeF32() < ACTIVATE_HIGHLIGHT_TIME)
+	{
+		// make sure toggle items, for example, show the proper state when fading out
+		selecteditem->buildDrawLabel();
+
+		LLRect item_rect;
+		selecteditem->localRectToOtherView(selecteditem->getLocalRect(), &item_rect, this);
+
+		F32 interpolant = sItemActivationTimer.getElapsedTimeF32() / ACTIVATE_HIGHLIGHT_TIME;
+		F32 alpha = lerp(LLMenuItemGL::sHighlightBackground.mV[VALPHA], 0.f, interpolant);
+		LLColor4 bg_color(LLMenuItemGL::sHighlightBackground.mV[VRED], 
+			LLMenuItemGL::sHighlightBackground.mV[VGREEN], 
+			LLMenuItemGL::sHighlightBackground.mV[VBLUE], 
+			alpha);
+		
+		LLUI::pushMatrix();
+		{
+			LLUI::translate((F32)item_rect.mLeft, (F32)item_rect.mBottom, 0.f);
+			selecteditem->getMenu()->drawBackground(selecteditem, bg_color);
+			selecteditem->draw();
+		}
+		LLUI::popMatrix();
+	}
+}
+
+BOOL LLMenuHolderGL::handleMouseDown( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
+	if (!handled)
+	{
+		// clicked off of menu, hide them all
+		hideMenus();
+	}
+	return handled;
+}
+
+BOOL LLMenuHolderGL::handleRightMouseDown( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = LLView::childrenHandleRightMouseDown(x, y, mask) != NULL;
+	if (!handled)
+	{
+		// clicked off of menu, hide them all
+		hideMenus();
+	}
+	return handled;
+}
+
+void LLMenuHolderGL::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	if (width != mRect.getWidth() || height != mRect.getHeight())
+	{
+		hideMenus();
+	}
+	LLView::reshape(width, height, called_from_parent);
+}
+
+BOOL LLMenuHolderGL::hasVisibleMenu()
+{
+	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		if (viewp->getVisible())
+		{
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+BOOL LLMenuHolderGL::hideMenus()
+{
+	if (!mCanHide)
+	{
+		return FALSE;
+	}
+	BOOL menu_visible = hasVisibleMenu();
+	if (menu_visible)
+	{
+		// clicked off of menu, hide them all
+		for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			if (viewp->getVisible())
+			{
+				viewp->setVisible(FALSE);
+			}
+		}
+	}
+	//if (gFocusMgr.childHasKeyboardFocus(this))
+	//{
+	//	gFocusMgr.setKeyboardFocus(NULL, NULL);
+	//}
+
+	return menu_visible;
+}
+
+void LLMenuHolderGL::setActivatedItem(LLMenuItemGL* item)
+{
+	sItemLastSelectedHandle = item->mViewHandle;
+	sItemActivationTimer.start();
+}
+
+///============================================================================
+/// Class LLTearOffMenu
+///============================================================================
+LLTearOffMenu::LLTearOffMenu(LLMenuGL* menup) : 
+	LLFloater(menup->getName(), LLRect(0, 100, 100, 0), menup->getLabel(), FALSE, DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT, FALSE, FALSE)
+{
+	LLRect rect;
+	menup->localRectToOtherView(LLRect(-1, menup->getRect().getHeight(), menup->getRect().getWidth() + 3, 0), &rect, gFloaterView);
+	mTargetHeight = (F32)(rect.getHeight() + LLFLOATER_HEADER_SIZE + 5);
+	reshape(rect.getWidth(), rect.getHeight());
+	setRect(rect);
+	mOldParent = menup->getParent();
+	mOldParent->removeChild(menup);
+
+	menup->setFollowsAll();
+	addChild(menup);
+	menup->setVisible(TRUE);
+	menup->translate(-menup->getRect().mLeft + 1, -menup->getRect().mBottom + 1);
+
+	menup->setTornOff(TRUE);
+	menup->setDropShadowed(FALSE);
+
+	mMenu = menup;
+
+	// highlight first item (tear off item will be disabled)
+	mMenu->highlightNextItem(NULL);
+}
+
+LLTearOffMenu::~LLTearOffMenu()
+{
+}
+
+void LLTearOffMenu::draw()
+{
+	if (hasFocus())
+	{
+		LLMenuItemGL* parent_menu_item = mMenu->getParentMenuItem();
+		while(parent_menu_item)
+		{
+			if (parent_menu_item->getMenu()->getVisible())
+			{
+				parent_menu_item->setHighlight(TRUE);
+				parent_menu_item = parent_menu_item->getMenu()->getParentMenuItem();
+			}
+			else
+			{
+				break;
+			}
+		}
+	}
+
+	mMenu->setBackgroundVisible(mBgOpaque);
+	mMenu->arrange();
+
+	if (mRect.getHeight() != mTargetHeight)
+	{
+		// animate towards target height
+		reshape(mRect.getWidth(), llceil(lerp((F32)mRect.getHeight(), mTargetHeight, LLCriticalDamp::getInterpolant(0.05f))));
+	}
+	else
+	{
+		// when in stasis, remain big enough to hold menu contents
+		mTargetHeight = (F32)(mMenu->getRect().getHeight() + LLFLOATER_HEADER_SIZE + 4);
+		reshape(mMenu->getRect().getWidth() + 3, mMenu->getRect().getHeight() + LLFLOATER_HEADER_SIZE + 5);
+	}
+	LLFloater::draw();
+}
+
+void LLTearOffMenu::onFocusReceived()
+{
+	// if nothing is highlighted, just highlight first item
+	if (!mMenu->getHighlightedItem())
+	{
+		mMenu->highlightNextItem(NULL);
+	}
+}
+
+void LLTearOffMenu::onFocusLost()
+{
+	// remove highlight from parent item and our own menu
+	mMenu->clearHoverItem();
+}
+
+//static
+LLTearOffMenu* LLTearOffMenu::create(LLMenuGL* menup)
+{
+	LLTearOffMenu* tearoffp = new LLTearOffMenu(menup);
+	// keep onscreen
+	gFloaterView->adjustToFitScreen(tearoffp, FALSE);
+	tearoffp->open();
+	return tearoffp;
+}
+
+void LLTearOffMenu::onClose(bool app_quitting)
+{
+	removeChild(mMenu);
+	mOldParent->addChild(mMenu);
+	mMenu->clearHoverItem();
+	mMenu->setFollowsNone();
+	mMenu->setBackgroundVisible(TRUE);
+	mMenu->setVisible(FALSE);
+	mMenu->setTornOff(FALSE);
+	mMenu->setDropShadowed(TRUE);
+	destroy();
+}
+
+///============================================================================
+/// Class LLEditMenuHandlerMgr
+///============================================================================
+LLEditMenuHandlerMgr& LLEditMenuHandlerMgr::getInstance()
+{
+	static LLEditMenuHandlerMgr instance;
+	return instance;
+}
+
+LLEditMenuHandlerMgr::LLEditMenuHandlerMgr()
+{
+}
+
+LLEditMenuHandlerMgr::~LLEditMenuHandlerMgr()
+{
+}
+
+///============================================================================
+/// Local function definitions
+///============================================================================
diff --git a/indra/llui/llmenugl.h b/indra/llui/llmenugl.h
new file mode 100644
index 0000000000..84cbf13b69
--- /dev/null
+++ b/indra/llui/llmenugl.h
@@ -0,0 +1,728 @@
+/** 
+ * @file llmenugl.h
+ * @brief Declaration of the opengl based menu system.
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLMENUGL_H
+#define LL_LLMENUGL_H
+
+#include <list>
+
+#include "llstring.h"
+#include "v4color.h"
+#include "llframetimer.h"
+#include "llevent.h"
+
+#include "llkeyboard.h"
+#include "llfloater.h"
+#include "lluistring.h"
+#include "llview.h"
+
+class LLMenuItemGL;
+
+extern S32 MENU_BAR_HEIGHT;
+extern S32 MENU_BAR_WIDTH;
+
+// These callbacks are used by the LLMenuItemCallGL and LLMenuItemCheckGL
+// classes during their work.
+typedef void (*menu_callback)(void*);
+
+// These callbacks are used by the LLMenuItemCallGL 
+// classes during their work.
+typedef void (*on_disabled_callback)(void*);
+
+// This callback is used by the LLMenuItemCallGL and LLMenuItemCheckGL
+// to determine if the current menu is enabled.
+typedef BOOL (*enabled_callback)(void*);
+
+// This callback is used by LLMenuItemCheckGL to determine it's
+// 'checked' state.
+typedef BOOL (*check_callback)(void*);
+
+// This callback is potentially used by LLMenuItemCallGL. If provided,
+// this function is called whenever it's time to determine the label's
+// contents. Put the contents of the label in the provided parameter.
+typedef void (*label_callback)(LLString&,void*);
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemGL
+//
+// The LLMenuItemGL represents a single menu item in a menu. 
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLFontGL;
+class LLMenuGL;
+
+
+class LLMenuItemGL : public LLView
+{
+public:
+	LLMenuItemGL( const LLString& name, const LLString& label, KEY key = KEY_NONE, MASK = MASK_NONE );
+
+	virtual void setValue(const LLSD& value) { setLabel(value.asString()); }
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_MENU_ITEM; }
+	virtual LLString getWidgetTag() const { return LL_MENU_ITEM_TAG; }
+
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+
+	virtual LLString getType() const	{ return "item"; }
+
+	virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL handleHover(S32 x, S32 y, MASK mask);
+
+	virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+
+	BOOL getHighlight() const			{ return mHighlight; }
+
+	void setJumpKey(KEY key);
+	KEY getJumpKey();
+	
+	// set the font used by this item.
+	void setFont(LLFontGL* font);
+	void setFontStyle(U8 style) { mStyle = style; }
+
+	// returns the height in pixels for the current font.
+	virtual U32 getNominalHeight( void );
+
+	// functions to control the color scheme
+	static void setEnabledColor( const LLColor4& color );
+	static void setDisabledColor( const LLColor4& color );
+	static void setHighlightBGColor( const LLColor4& color );
+	static void setHighlightFGColor( const LLColor4& color );
+	
+	// Marks item as not needing space for check marks or accelerator keys
+	virtual void setBriefItem(BOOL brief);
+
+	virtual BOOL addToAcceleratorList(std::list<LLKeyBinding*> *listp);
+	void setAllowKeyRepeat(BOOL allow) { mAllowKeyRepeat = allow; }
+
+	// return the name label
+	LLString getLabel( void ) const { return mLabel.getString(); }
+
+	// change the label
+	void setLabel( const LLString& label );
+	virtual BOOL setLabelArg( const LLString& key, const LLString& text );
+
+	// Get the parent menu for this item
+	virtual LLMenuGL*	getMenu();
+
+	// returns the normal width of this control in pixels - this is
+	// used for calculating the widest item, as well as for horizontal
+	// arrangement.
+	virtual U32 getNominalWidth( void );
+
+	// buildDrawLabel() - constructs the string used during the draw()
+	// function. This reduces the overall string manipulation, but can
+	// lead to visual errors if the state of the object changes
+	// without the knowledge of the menu item. For example, if a
+	// boolean being watched is changed outside of the menu item's
+	// doIt() function, the draw buffer will not be updated and will
+	// reflect the wrong value. If this ever becomes an issue, there
+	// are ways to fix this.
+	// Returns the enabled state of the item.
+	virtual void buildDrawLabel( void );
+
+	// for branching menu items, bring sub menus up to root level of menu hierarchy
+	virtual void updateBranchParent( LLView* parentp ){};
+	
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void ) = 0;
+
+	// set the hover status (called by it's menu)
+	virtual void setHighlight( BOOL highlight );
+
+	// determine if this object is active
+	virtual BOOL isActive( void ) const;
+
+	virtual void setEnabledSubMenus(BOOL enable){};
+
+	// LLView Functionality
+	virtual BOOL handleKeyHere( KEY key, MASK mask, BOOL called_from_parent );
+	virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
+	virtual void draw( void );
+
+	BOOL getDrawTextDisabled() const { return mDrawTextDisabled; }
+
+protected:
+	// This function appends the character string representation of
+	// the current accelerator key and mask to the provided string.
+	void appendAcceleratorString( LLString& st );
+
+public:
+	static LLColor4 sEnabledColor;
+	static LLColor4 sDisabledColor;
+	static LLColor4 sHighlightBackground;
+	static LLColor4 sHighlightForeground;
+
+protected:
+	static BOOL sDropShadowText;
+
+	// mLabel contains the actual label specified by the user.
+	LLUIString mLabel;
+
+	// The draw labels contain some of the labels that we draw during
+	// the draw() routine. This optimizes away some of the string
+	// manipulation.
+	LLUIString mDrawBoolLabel;
+	LLUIString mDrawAccelLabel;
+	LLUIString mDrawBranchLabel;
+
+	// Keyboard and mouse variables
+	KEY mJumpKey;
+	KEY mAcceleratorKey;
+	MASK mAcceleratorMask;
+	BOOL mAllowKeyRepeat;
+	BOOL mHighlight;
+	BOOL mGotHover;
+
+	// If true, suppress normal space for check marks on the left and accelerator
+	// keys on the right.
+	BOOL mBriefItem;
+
+	// Font for this item
+	LLFontGL* mFont;
+
+	U8	mStyle;
+	BOOL mDrawTextDisabled;
+};
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemCallGL
+//
+// The LLMenuItemCallerGL represents a single menu item in a menu that
+// calls a user defined callback.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemCallGL : public LLMenuItemGL
+{
+protected:
+	menu_callback			mCallback;
+	// mEnabledCallback should return TRUE if the item should be enabled
+	enabled_callback		mEnabledCallback;	
+	label_callback			mLabelCallback;
+	void*					mUserData;
+	on_disabled_callback	mOnDisabledCallback;
+
+public:
+
+
+	void setMenuCallback(menu_callback callback, void* data) { mCallback = callback;  mUserData = data; };
+	void setEnabledCallback(enabled_callback callback) { mEnabledCallback = callback; };
+
+	// normal constructor
+	LLMenuItemCallGL( const LLString& name,
+ 					  menu_callback clicked_cb, 
+					  enabled_callback enabled_cb = NULL,
+					  void* user_data = NULL, 
+					  KEY key = KEY_NONE, MASK mask = MASK_NONE,
+					  BOOL enabled = TRUE,
+					  on_disabled_callback on_disabled_cb = NULL);
+	LLMenuItemCallGL( const LLString& name,
+					  const LLString& label,
+ 					  menu_callback clicked_cb, 
+					  enabled_callback enabled_cb = NULL,
+					  void* user_data = NULL, 
+					  KEY key = KEY_NONE, MASK mask = MASK_NONE,
+					  BOOL enabled = TRUE,
+					  on_disabled_callback on_disabled_cb = NULL);
+
+	// constructor for when you want to trap the arrange method.
+	LLMenuItemCallGL( const LLString& name,
+					  const LLString& label,
+					  menu_callback clicked_cb,
+					  enabled_callback enabled_cb,
+					  label_callback label_cb,
+					  void* user_data,
+					  KEY key = KEY_NONE, MASK mask = MASK_NONE,
+					  BOOL enabled = TRUE,
+					  on_disabled_callback on_disabled_c = NULL);
+	LLMenuItemCallGL( const LLString& name,
+					  menu_callback clicked_cb,
+					  enabled_callback enabled_cb,
+					  label_callback label_cb,
+					  void* user_data,
+					  KEY key = KEY_NONE, MASK mask = MASK_NONE,
+					  BOOL enabled = TRUE,
+					  on_disabled_callback on_disabled_c = NULL);
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+
+	virtual LLString getType() const	{ return "call"; }
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	void setEnabledControl(LLString enabled_control, LLView *context);
+	void setVisibleControl(LLString enabled_control, LLView *context);
+
+	virtual void setUserData(void *userdata)	{ mUserData = userdata; }
+
+	// called to rebuild the draw label
+	virtual void buildDrawLabel( void );
+
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void );
+
+	virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+
+	//virtual void draw();
+
+	virtual bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata);
+};
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemCheckGL
+//
+// The LLMenuItemCheckGL is an extension of the LLMenuItemCallGL
+// class, by allowing another method to be specified which determines
+// if the menu item should consider itself checked as true or not.  Be
+// careful that the check callback provided - it needs to be VERY
+// FUCKING EFFICIENT, because it may need to be checked a lot.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemCheckGL 
+:	public LLMenuItemCallGL
+{
+protected:
+	check_callback mCheckCallback;
+	BOOL mChecked;
+
+public:
+	LLMenuItemCheckGL( const LLString& name, 
+					   const LLString& label,
+					   menu_callback callback,
+					   enabled_callback enabled_cb,
+					   check_callback check,
+					   void* user_data,
+					   KEY key = KEY_NONE, MASK mask = MASK_NONE );
+	LLMenuItemCheckGL( const LLString& name, 
+					   menu_callback callback,
+					   enabled_callback enabled_cb,
+					   check_callback check,
+					   void* user_data,
+					   KEY key = KEY_NONE, MASK mask = MASK_NONE );
+	LLMenuItemCheckGL( const LLString& name, 
+					   const LLString& label,
+					   menu_callback callback,
+					   enabled_callback enabled_cb,
+					   LLString control_name,
+					   LLView *context,
+					   void* user_data,
+					   KEY key = KEY_NONE, MASK mask = MASK_NONE );
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+
+	void setCheckedControl(LLString checked_control, LLView *context);
+
+	virtual void setValue(const LLSD& value) { mChecked = value.asBoolean(); }
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual LLString getType() const	{ return "check"; }
+
+	// called to rebuild the draw label
+	virtual void buildDrawLabel( void );
+
+	virtual bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata);
+
+	// LLView Functionality
+	//virtual void draw( void );
+};
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemToggleGL
+//
+// The LLMenuItemToggleGL is a menu item that wraps around a user
+// specified and controlled boolean.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemToggleGL : public LLMenuItemGL
+{
+protected:
+	BOOL* mToggle;
+
+public:
+	LLMenuItemToggleGL( const LLString& name, const LLString& label,
+						BOOL* toggle, 
+						KEY key = KEY_NONE, MASK mask = MASK_NONE );
+
+	LLMenuItemToggleGL( const LLString& name,
+						BOOL* toggle, 
+						KEY key = KEY_NONE, MASK mask = MASK_NONE );
+
+	virtual LLString getType() const	{ return "toggle"; }
+
+	// called to rebuild the draw label
+	virtual void buildDrawLabel( void );
+
+	// doIt() - do the primary funcationality of the menu item.
+	virtual void doIt( void );
+
+	// LLView Functionality
+	//virtual void draw( void );
+};
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuGL
+//
+// The Menu class represents a normal rectangular menu somewhere on
+// screen. A Menu can have menu items (described above) or sub-menus
+// attached to it. Sub-menus are implemented via a specialized
+// menu-item type known as a branch. Since it's easy to do wrong, I've
+// taken the branch functionality out of public view, and encapsulate
+// it in the appendMenu() method.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuArrowGL;
+class LLMenuItemBranchGL;
+class LLMenuItemTearOffGL;
+
+class LLMenuGL 
+:	public LLUICtrl
+{
+public:
+	LLMenuGL( const LLString& name, const LLString& label, LLViewHandle parent_floater = LLViewHandle::sDeadHandle );
+	LLMenuGL( const LLString& label, LLViewHandle parent_floater = LLViewHandle::sDeadHandle );
+	virtual ~LLMenuGL( void );
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	void parseChildXML(LLXMLNodePtr child, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_MENU; }
+	virtual LLString getWidgetTag() const { return LL_MENU_GL_TAG; }
+
+	// LLView Functionality
+	virtual BOOL handleKey( KEY key, MASK mask, BOOL called_from_parent );
+	virtual BOOL handleKeyHere( KEY key, MASK mask, BOOL called_from_parent );
+	virtual BOOL handleHover( S32 x, S32 y, MASK mask );
+	virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
+	virtual void draw( void );
+	virtual void drawBackground(LLMenuItemGL* itemp, LLColor4& color);
+	virtual void setVisible(BOOL visible);
+
+	virtual BOOL LLMenuGL::handleAcceleratorKey(KEY key, MASK mask);
+
+	LLMenuGL* getChildMenuByName(const LLString& name, BOOL recurse) const;
+	
+	BOOL clearHoverItem(BOOL include_active = TRUE);
+
+	// return the name label
+	const LLString& getLabel( void ) const { return mLabel.getString(); }
+	void setLabel(const LLString& label) { mLabel = label; }
+
+	static void setDefaultBackgroundColor( const LLColor4& color );
+	void setBackgroundColor( const LLColor4& color );
+	void setBackgroundVisible( BOOL b )	{ mBgVisible = b; }
+	void setCanTearOff(BOOL tear_off, LLViewHandle parent_floater_handle = LLViewHandle::sDeadHandle);
+
+	// Add the menu item to this menu.
+	virtual BOOL append( LLMenuItemGL* item );
+
+	// add a separator to this menu
+	virtual BOOL appendSeparator( const LLString &separator_name = "separator" );
+
+	// add a menu - this will create a cascading menu
+	virtual BOOL appendMenu( LLMenuGL* menu );
+
+	// for branching menu items, bring sub menus up to root level of menu hierarchy
+	virtual void updateParent( LLView* parentp );
+
+	// setItemEnabled() - pass the name and the enable flag for a
+	// menu item. TRUE will make sure it's enabled, FALSE will disable
+	// it.
+	void setItemEnabled( const LLString& name, BOOL enable ); 
+	
+	// propagate message to submenus
+	void setEnabledSubMenus(BOOL enable);
+
+	void setItemVisible( const LLString& name, BOOL visible);
+	
+	// sets the left,bottom corner of menu, useful for popups
+	void setLeftAndBottom(S32 left, S32 bottom);
+
+	virtual void handleJumpKey(KEY key);
+
+	// Shape this menu to fit the current state of the children, and
+	// adjust the child rects to fit. This is called automatically
+	// when you add items. *FIX: We may need to deal with visibility
+	// arrangement.
+	virtual void arrange( void );
+
+	// remove all items on the menu
+	void empty( void );
+
+	// Rearrange the components, and do the right thing if the menu doesn't
+	// fit in the bounds.
+	// virtual void arrangeWithBounds(LLRect bounds);
+
+	void			setItemLastSelected(LLMenuItemGL* item);	// must be in menu
+	U32				getItemCount();				// number of menu items
+	LLMenuItemGL*	getItem(S32 number);		// 0 = first item
+	LLMenuItemGL*	getHighlightedItem();				
+
+	LLMenuItemGL*	highlightNextItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);
+	LLMenuItemGL*	highlightPrevItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);
+
+	void buildDrawLabels();
+	void createJumpKeys();
+
+	// Show popup in global screen space based on last mouse location.
+	static void showPopup(LLMenuGL* menu);
+
+	// Show popup at a specific location.
+	static void showPopup(LLView* spawning_view, LLMenuGL* menu, S32 x, S32 y);
+
+	// Whether to drop shadow menu bar 
+	void setDropShadowed( const BOOL shadowed );
+
+	void setParentMenuItem( LLMenuItemGL* parent_menu_item ) { mParentMenuItem = parent_menu_item; }
+	LLMenuItemGL* getParentMenuItem() { return mParentMenuItem; }
+
+	void setTornOff(BOOL torn_off);
+	BOOL getTornOff() { return mTornOff; }
+
+	BOOL getCanTearOff() { return mTearOffItem != NULL; }
+
+	KEY getJumpKey() { return mJumpKey; }
+	void setJumpKey(KEY key) { mJumpKey = key; }
+
+	static void onFocusLost(LLView* old_focus);
+
+	static LLView *sDefaultMenuContainer;
+	
+protected:
+	void createSpilloverBranch();
+	void cleanupSpilloverBranch();
+
+protected:
+	static LLColor4 sDefaultBackgroundColor;
+
+	LLColor4		mBackgroundColor;
+	BOOL			mBgVisible;
+	typedef std::list< LLMenuItemGL* > item_list_t;
+	item_list_t mItems;
+	typedef std::map<KEY, LLMenuItemGL*> navigation_key_map_t;
+	navigation_key_map_t mJumpKeys;
+	LLMenuItemGL*	mParentMenuItem;
+	LLUIString		mLabel;
+	BOOL mDropShadowed; 	//  Whether to drop shadow 
+	BOOL			mHorizontalLayout;
+	BOOL			mKeepFixedSize;
+	BOOL			mHasSelection;
+	LLFrameTimer	mFadeTimer;
+	S32				mLastMouseX;
+	S32				mLastMouseY;
+	S32				mMouseVelX;
+	S32				mMouseVelY;
+	BOOL			mTornOff;
+	LLMenuItemTearOffGL* mTearOffItem;
+	LLMenuItemBranchGL* mSpilloverBranch;
+	LLMenuGL*		mSpilloverMenu;
+	LLViewHandle	mParentFloaterHandle;
+	KEY				mJumpKey;
+};
+
+//-----------------------------------------------------------------------------
+// class LLPieMenu
+// A circular menu of items, icons, etc.
+//-----------------------------------------------------------------------------
+
+class LLPieMenu
+: public LLMenuGL
+{
+public:
+	LLPieMenu(const LLString& name, const LLString& label);
+	LLPieMenu(const LLString& name);
+	virtual ~LLPieMenu();
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	void initXML(LLXMLNodePtr node, LLView *context, LLUICtrlFactory *factory);
+
+	// LLView Functionality
+	// can't set visibility directly, must call show or hide
+	virtual void setVisible(BOOL visible);
+	
+	//virtual BOOL handleKey( KEY key, MASK mask, BOOL called_from_parent );
+	virtual BOOL handleHover( S32 x, S32 y, MASK mask );
+	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
+	virtual BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL handleRightMouseUp( S32 x, S32 y, MASK mask );
+	virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
+	virtual void draw();
+	virtual void drawBackground(LLMenuItemGL* itemp, LLColor4& color);
+
+	virtual BOOL append(LLMenuItemGL* item);
+	virtual BOOL appendSeparator( const LLString &separator_name = "separator" );
+
+	// the enabled callback is meant for the submenu. The api works
+	// this way because the menu branch item responsible for the pie
+	// submenu is constructed here.
+	virtual BOOL appendMenu(LLPieMenu *menu,
+							enabled_callback enabled_cb = NULL,
+							void* user_data = NULL );
+	virtual void arrange( void );
+
+	// Display the menu centered on this point on the screen.
+	void show(S32 x, S32 y, BOOL mouse_down);
+	void hide(BOOL item_selected);
+
+protected:
+	LLMenuItemGL *pieItemFromXY(S32 x, S32 y);
+	S32			  pieItemIndexFromXY(S32 x, S32 y);
+
+private:
+	// These cause menu items to be spuriously selected by right-clicks
+	// near the window edge at low frame rates.  I don't think they are
+	// needed unless you shift the menu position in the draw() function. JC
+	//S32				mShiftHoriz;	// non-zero if menu had to shift this frame
+	//S32				mShiftVert;		// non-zero if menu had to shift this frame
+	BOOL			mFirstMouseDown;	// true from show until mouse up
+	BOOL			mUseInfiniteRadius;	// allow picking pie menu items anywhere outside of center circle
+	LLMenuItemGL*	mHoverItem;
+	BOOL			mHoverThisFrame;
+	LLFrameTimer	mShrinkBorderTimer;
+	F32				mOuterRingAlpha; // for rendering pie menus as both bounded and unbounded
+	F32				mCurRadius;
+	BOOL			mRightMouseDown;
+};
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuBarGL
+//
+// A menu bar displays menus horizontally.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuBarGL : public LLMenuGL
+{
+protected:
+	std::list <LLKeyBinding*> mAccelerators;
+
+public:
+	LLMenuBarGL( const LLString& name );
+	virtual ~LLMenuBarGL();
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_MENU_BAR; }
+	virtual LLString getWidgetTag() const { return LL_MENU_BAR_GL_TAG; }
+
+	// rearrange the child rects so they fit the shape of the menu
+	// bar.
+	virtual void handleJumpKey(KEY key);
+	virtual void arrange( void );
+
+	// add a vertical separator to this menu
+	virtual BOOL appendSeparator( const LLString &separator_name = "separator" );
+
+	// add a menu - this will create a drop down menu.
+	virtual BOOL appendMenu( LLMenuGL* menu );
+
+	// LLView Functionality
+	virtual BOOL handleHover( S32 x, S32 y, MASK mask );
+
+	// Returns x position of rightmost child, usually Help menu
+	S32 getRightmostMenuEdge();
+};
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuHolderGL
+//
+// High level view that serves as parent for all menus
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class LLMenuHolderGL : public LLPanel
+{
+public:
+	LLMenuHolderGL();
+	LLMenuHolderGL(const LLString& name, const LLRect& rect, BOOL mouse_opaque, U32 follows = FOLLOWS_NONE);
+	virtual ~LLMenuHolderGL();
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual BOOL hideMenus();
+	void reshape(S32 width, S32 height, BOOL called_from_parent);
+	void setCanHide(BOOL can_hide) { mCanHide = can_hide; }
+
+	// LLView functionality
+	virtual void draw();
+	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
+	virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
+
+	static void setActivatedItem(LLMenuItemGL* item);
+protected:
+	BOOL hasVisibleMenu();
+
+	static LLViewHandle sItemLastSelectedHandle;
+	static LLFrameTimer sItemActivationTimer;
+
+	BOOL mCanHide;
+};
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLTearOffMenu
+//
+// Floater that hosts a menu
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class LLTearOffMenu : public LLFloater
+{
+public:
+	static LLTearOffMenu* create(LLMenuGL* menup);
+	virtual ~LLTearOffMenu();
+	virtual void onClose(bool app_quitting);
+	virtual void draw(void);
+	virtual void onFocusReceived();
+	virtual void onFocusLost();
+
+protected:
+	LLTearOffMenu(LLMenuGL* menup);
+
+protected:
+	LLView*		mOldParent;
+	LLMenuGL*	mMenu;
+	F32			mTargetHeight;
+};
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLMenuItemTearOffGL
+//
+// This class represents a separator.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLMenuItemTearOffGL : public LLMenuItemGL
+{
+public:
+	LLMenuItemTearOffGL( LLViewHandle parent_floater_handle = (LLViewHandle)LLViewHandle::sDeadHandle );
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual LLString getType() const	{ return "tearoff_menu"; }
+
+	virtual void doIt(void);
+	virtual void draw(void);
+	virtual U32 getNominalHeight();
+
+protected:
+	LLViewHandle mParentHandle;
+};
+
+
+//FIXME: this is currently working, so finish implementation
+class LLEditMenuHandlerMgr
+{
+public:
+	LLEditMenuHandlerMgr& getInstance();
+	virtual ~LLEditMenuHandlerMgr();
+protected:
+	LLEditMenuHandlerMgr();
+
+};
+
+#endif // LL_LLMENUGL_H
diff --git a/indra/llui/llmodaldialog.cpp b/indra/llui/llmodaldialog.cpp
new file mode 100644
index 0000000000..4eaf6b7559
--- /dev/null
+++ b/indra/llui/llmodaldialog.cpp
@@ -0,0 +1,288 @@
+/** 
+ * @file llmodaldialog.cpp
+ * @brief LLModalDialog base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llmodaldialog.h"
+
+#include "llfocusmgr.h"
+#include "v4color.h"
+#include "v2math.h"
+#include "llui.h"
+#include "llwindow.h"
+#include "llkeyboard.h"
+
+// static
+std::list<LLModalDialog*> LLModalDialog::sModalStack;
+
+LLModalDialog::LLModalDialog( const LLString& title, S32 width, S32 height, BOOL modal )
+	: LLFloater( "modal container",
+				 LLRect( 0, height, width, 0 ),
+				 title,
+				 FALSE, // resizable
+				 DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT,
+				 FALSE, // drag_on_left
+				 modal ? FALSE : TRUE, // minimizable
+				 modal ? FALSE : TRUE, // close button
+				 TRUE), // bordered
+	  mModal( modal )
+{
+	setVisible( FALSE );
+	setBackgroundVisible(TRUE);
+	setBackgroundOpaque(TRUE);
+	centerOnScreen(); // default position
+}
+
+LLModalDialog::~LLModalDialog()
+{
+	// don't unlock focus unless we have it
+	if (gFocusMgr.childHasKeyboardFocus(this))
+	{
+		gFocusMgr.unlockFocus();
+	}
+}
+
+void LLModalDialog::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	LLFloater::reshape(width, height, called_from_parent);
+	centerOnScreen();
+}
+
+void LLModalDialog::startModal()
+{
+	if (mModal)
+	{
+		// If Modal, Hide the active modal dialog
+		if (!sModalStack.empty())
+		{
+			LLModalDialog* front = sModalStack.front();
+			front->setVisible(FALSE);
+		}
+	
+		// This is a modal dialog.  It sucks up all mouse and keyboard operations.
+		gFocusMgr.setMouseCapture( this, NULL );
+		gFocusMgr.setTopView( this, NULL );
+		setFocus(TRUE);
+
+		sModalStack.push_front( this );
+	}
+
+	setVisible( TRUE );
+}
+
+void LLModalDialog::stopModal()
+{
+	gFocusMgr.unlockFocus();
+	gFocusMgr.releaseFocusIfNeeded( this );
+
+	if (mModal)
+	{
+		std::list<LLModalDialog*>::iterator iter = std::find(sModalStack.begin(), sModalStack.end(), this);
+		if (iter != sModalStack.end())
+		{
+			sModalStack.erase(iter);
+		}
+		else
+		{
+			llwarns << "LLModalDialog::stopModal not in list!" << llendl;
+		}
+	}
+	if (!sModalStack.empty())
+	{
+		LLModalDialog* front = sModalStack.front();
+		front->setVisible(TRUE);
+	}
+}
+
+
+void LLModalDialog::setVisible( BOOL visible )
+{
+	if (mModal)
+	{
+		if( visible )
+		{
+			// This is a modal dialog.  It sucks up all mouse and keyboard operations.
+			gFocusMgr.setMouseCapture( this, NULL );
+
+			// The dialog view is a root view
+			gFocusMgr.setTopView( this, NULL );
+			setFocus( TRUE );
+		}
+		else
+		{
+			gFocusMgr.releaseFocusIfNeeded( this );
+		}
+	}
+	
+	LLFloater::setVisible( visible );
+}
+
+BOOL LLModalDialog::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	if (!LLFloater::handleMouseDown(x, y, mask))
+	{
+		if (mModal)
+		{
+			// Click was outside the panel
+			make_ui_sound("UISndInvalidOp");
+		}
+	}
+	return TRUE;
+}
+
+BOOL LLModalDialog::handleHover(S32 x, S32 y, MASK mask)		
+{ 
+	if( childrenHandleHover(x, y, mask) == NULL )
+	{
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;		
+	}
+	return TRUE;
+}
+
+BOOL LLModalDialog::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	childrenHandleMouseUp(x, y, mask);
+	return TRUE;
+}
+
+BOOL LLModalDialog::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	childrenHandleScrollWheel(x, y, clicks);
+	return TRUE;
+}
+
+BOOL LLModalDialog::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	if (!LLFloater::handleDoubleClick(x, y, mask))
+	{
+		// Click outside the panel
+		make_ui_sound("UISndInvalidOp");
+	}
+	return TRUE;
+}
+
+BOOL LLModalDialog::handleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	childrenHandleRightMouseDown(x, y, mask);
+	return TRUE;
+}
+
+
+BOOL LLModalDialog::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent )
+{
+	childrenHandleKey(key, mask);
+
+	LLFloater::handleKeyHere(key, mask, called_from_parent );
+
+	if (mModal)
+	{
+		// Suck up all keystokes except CTRL-Q.
+		BOOL is_quit = ('Q' == key) && (MASK_CONTROL == mask);
+		return !is_quit;
+	}
+	else
+	{
+		// don't process escape key until message box has been on screen a minimal amount of time
+		// to avoid accidentally destroying the message box when user is hitting escape at the time it appears
+		BOOL enough_time_elapsed = mVisibleTime.getElapsedTimeF32() > 1.0f;
+		if (enough_time_elapsed && key == KEY_ESCAPE)
+		{
+			close();
+			return TRUE;
+		}
+		return FALSE;
+	}	
+}
+
+void LLModalDialog::onClose(bool app_quitting)
+{
+	stopModal();
+	LLFloater::onClose(app_quitting);
+}
+
+// virtual
+void LLModalDialog::draw()
+{
+	if (getVisible())
+	{
+		LLColor4 shadow_color = LLUI::sColorsGroup->getColor("ColorDropShadow");
+		S32 shadow_lines = LLUI::sConfigGroup->getS32("DropShadowFloater");
+
+		gl_drop_shadow( 0, mRect.getHeight(), mRect.getWidth(), 0,
+			shadow_color, shadow_lines);
+
+		LLFloater::draw();
+
+		if (mModal)
+		{
+			// If we've lost focus to a non-child, get it back ASAP.
+			if( gFocusMgr.getTopView() != this )
+			{
+				gFocusMgr.setTopView( this, NULL);
+			}
+
+			if( !gFocusMgr.childHasKeyboardFocus( this ) )
+			{
+				setFocus(TRUE);
+			}
+
+			if( !gFocusMgr.childHasMouseCapture( this ) )
+			{
+				gFocusMgr.setMouseCapture( this, NULL );
+			}
+		}
+	}
+}
+
+void LLModalDialog::centerOnScreen()
+{
+	LLVector2 window_size = LLUI::getWindowSize();
+
+	S32 dialog_left = (llround(window_size.mV[VX]) - mRect.getWidth()) / 2;
+	S32 dialog_bottom = (llround(window_size.mV[VY]) - mRect.getHeight()) / 2;
+
+	translate( dialog_left - mRect.mLeft, dialog_bottom - mRect.mBottom );
+}
+
+
+// static 
+void LLModalDialog::onAppFocusLost()
+{
+	if( !sModalStack.empty() )
+	{
+		LLModalDialog* instance = LLModalDialog::sModalStack.front();
+		if( gFocusMgr.childHasMouseCapture( instance ) )
+		{
+			gFocusMgr.setMouseCapture( NULL, NULL );
+		}
+
+		if( gFocusMgr.childHasKeyboardFocus( instance ) )
+		{
+			gFocusMgr.setKeyboardFocus( NULL, NULL );
+		}
+	}
+}
+
+// static 
+void LLModalDialog::onAppFocusGained()
+{
+	if( !sModalStack.empty() )
+	{
+		LLModalDialog* instance = LLModalDialog::sModalStack.front();
+
+		// This is a modal dialog.  It sucks up all mouse and keyboard operations.
+		gFocusMgr.setMouseCapture( instance, NULL );
+		instance->setFocus(TRUE);
+		gFocusMgr.setTopView( instance, NULL );
+
+		instance->centerOnScreen();
+	}
+}
+
+
diff --git a/indra/llui/llmodaldialog.h b/indra/llui/llmodaldialog.h
new file mode 100644
index 0000000000..b97e95d12c
--- /dev/null
+++ b/indra/llui/llmodaldialog.h
@@ -0,0 +1,60 @@
+/** 
+ * @file llmodaldialog.h
+ * @brief LLModalDialog base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLMODALDIALOG_H
+#define LL_LLMODALDIALOG_H
+
+#include "llfloater.h"
+#include "llframetimer.h"
+
+class LLModalDialog;
+
+// By default, a ModalDialog is modal, i.e. no other window can have focus
+// However, for the sake of code reuse and simplicity, if mModal == false,
+// the dialog behaves like a normal floater
+
+class LLModalDialog : public LLFloater
+{
+public:
+	LLModalDialog( const LLString& title, S32 width, S32 height, BOOL modal = true );
+	/*virtual*/ ~LLModalDialog();
+
+	/*virtual*/ void 	reshape(S32 width, S32 height, BOOL called_from_parent = 1);
+	
+	/*virtual*/ void	startModal();
+	/*virtual*/ void	stopModal();
+
+	/*virtual*/ BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent );
+
+	/*virtual*/ void	onClose(bool app_quitting);
+
+	/*virtual*/ void	setVisible(BOOL visible);
+	/*virtual*/ void	draw();
+
+	static void		onAppFocusLost();
+	static void		onAppFocusGained();
+
+	static S32		activeCount() { return sModalStack.size(); }
+	
+protected:
+	void			centerOnScreen();
+
+protected:
+	LLFrameTimer 	mVisibleTime;
+	BOOL			mModal; // do not change this after creation!
+
+	static std::list<LLModalDialog*> sModalStack;  // Top of stack is currently being displayed
+};
+
+#endif  // LL_LLMODALDIALOG_H
diff --git a/indra/llui/llpanel.cpp b/indra/llui/llpanel.cpp
new file mode 100644
index 0000000000..91bf6befe7
--- /dev/null
+++ b/indra/llui/llpanel.cpp
@@ -0,0 +1,1030 @@
+/** 
+ * @file llpanel.cpp
+ * @brief LLPanel base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Opaque view with a background and a border.  Can contain LLUICtrls.
+
+#include "linden_common.h"
+
+#include "llpanel.h"
+
+#include "llalertdialog.h"
+#include "llfocusmgr.h"
+#include "llfontgl.h"
+#include "llrect.h"
+#include "llerror.h"
+#include "lltimer.h"
+
+#include "llmenugl.h"
+//#include "llstatusbar.h"
+#include "llui.h"
+#include "llkeyboard.h"
+#include "lllineeditor.h"
+#include "llcontrol.h"
+#include "lltextbox.h"
+#include "lluictrl.h"
+#include "lluictrlfactory.h"
+#include "llviewborder.h"
+#include "llbutton.h"
+
+LLPanel::panel_map_t LLPanel::sPanelMap;
+LLPanel::alert_queue_t LLPanel::sAlertQueue;
+
+void LLPanel::init()
+{
+	// mRectControl
+	mBgColorAlpha        = LLUI::sColorsGroup->getColor( "DefaultBackgroundColor" );
+	mBgColorOpaque       = LLUI::sColorsGroup->getColor( "FocusBackgroundColor" );
+	mDefaultBtnHighlight = LLUI::sColorsGroup->getColor( "DefaultHighlightLight" );
+	mBgVisible = FALSE;
+	mBgOpaque = FALSE;
+	mBorder = NULL;
+	mDefaultBtn = NULL;
+	setIsChrome(FALSE); //is this a decorator to a live window or a form?
+	mLastTabGroup = 0;
+
+	// add self to handle->panel map
+	sPanelMap[mViewHandle] = this;
+	setTabStop(FALSE);
+}
+
+LLPanel::LLPanel()
+: mRectControl()
+{
+	init();
+}
+
+LLPanel::LLPanel(const LLString& name)
+:	LLUICtrl(name, LLRect(0, 0, 0, 0), TRUE, NULL, NULL),
+	mRectControl()
+{
+	init();
+}
+
+
+LLPanel::LLPanel(const LLString& name, const LLRect& rect, BOOL bordered)
+:	LLUICtrl(name, rect, TRUE, NULL, NULL),
+	mRectControl()
+{
+	init();
+	if (bordered)
+	{
+		addBorder();
+	}
+}
+
+
+LLPanel::LLPanel(const LLString& name, const LLString& rect_control, BOOL bordered)
+:	LLUICtrl(name, LLUI::sConfigGroup->getRect(rect_control), TRUE, NULL, NULL),
+	mRectControl( rect_control )
+{
+	init();
+	if (bordered)
+	{
+		addBorder();
+	}
+}
+
+void LLPanel::addBorder(LLViewBorder::EBevel border_bevel,
+						LLViewBorder::EStyle border_style, S32 border_thickness)
+{
+	mBorder = new LLViewBorder( "panel border", 
+								LLRect(0, mRect.getHeight(), mRect.getWidth(), 0), 
+								border_bevel, border_style, border_thickness );
+	mBorder->setSaveToXML(false);
+	addChild( mBorder );
+}
+
+
+LLPanel::~LLPanel()
+{
+	if( !mRectControl.empty() )
+	{
+		LLUI::sConfigGroup->setRect( mRectControl, mRect );
+	}
+	sPanelMap.erase(mViewHandle);
+}
+
+
+// virtual
+EWidgetType LLPanel::getWidgetType() const
+{
+	return WIDGET_TYPE_PANEL;
+}
+
+// virtual
+LLString LLPanel::getWidgetTag() const
+{
+	return LL_PANEL_TAG;
+}
+
+// virtual
+BOOL LLPanel::isPanel()
+{
+	return TRUE;
+}
+
+// virtual
+BOOL LLPanel::postBuild()
+{
+	return TRUE;
+}
+
+// virtual
+void LLPanel::clearCtrls()
+{
+	LLView::ctrl_list_t ctrls = getCtrlList();
+	for (LLView::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
+	{
+		LLUICtrl* ctrl = *ctrl_it;
+		ctrl->setFocus( FALSE );
+		ctrl->setEnabled( FALSE );
+		ctrl->clear();
+	}
+}
+
+void LLPanel::setCtrlsEnabled( BOOL b )
+{
+	LLView::ctrl_list_t ctrls = getCtrlList();
+	for (LLView::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
+	{
+		LLUICtrl* ctrl = *ctrl_it;
+		ctrl->setEnabled( b );
+	}
+}
+
+void LLPanel::draw()
+{
+	if( getVisible() )
+	{
+		// draw background
+		if( mBgVisible )
+		{
+			S32 left = LLPANEL_BORDER_WIDTH;
+			S32 top = mRect.getHeight() - LLPANEL_BORDER_WIDTH;
+			S32 right = mRect.getWidth() - LLPANEL_BORDER_WIDTH;
+			S32 bottom = LLPANEL_BORDER_WIDTH;
+
+			if (mBgOpaque )
+			{
+				gl_rect_2d( left, top, right, bottom, mBgColorOpaque );
+			}
+			else
+			{
+				gl_rect_2d( left, top, right, bottom, mBgColorAlpha );
+			}
+		}
+
+		if( mDefaultBtn)
+		{
+			if (gFocusMgr.childHasKeyboardFocus( this ) && mDefaultBtn->getEnabled())
+			{
+				LLUICtrl* focus_ctrl = gFocusMgr.getKeyboardFocus();
+				BOOL focus_is_child_button = focus_ctrl->getWidgetType() == WIDGET_TYPE_BUTTON && static_cast<LLButton *>(focus_ctrl)->getCommitOnReturn();
+				// only enable default button when current focus is not a return-capturing button
+				mDefaultBtn->setBorderEnabled(!focus_is_child_button);
+			}
+			else
+			{
+				mDefaultBtn->setBorderEnabled(FALSE);
+			}
+		}
+
+		LLView::draw();
+	}
+}
+
+void LLPanel::refresh()
+{
+	// do nothing by default
+	// but is automatically called in setFocus(TRUE)
+}
+
+void LLPanel::setDefaultBtn(LLButton* btn)
+{
+	if (mDefaultBtn && mDefaultBtn->getEnabled())
+	{
+		mDefaultBtn->setBorderEnabled(FALSE);
+	}
+	mDefaultBtn = btn; 
+	if (mDefaultBtn)
+	{
+		mDefaultBtn->setBorderEnabled(TRUE);
+	}
+}
+
+void LLPanel::setDefaultBtn(const LLString& id)
+{
+	LLButton *button = LLUICtrlFactory::getButtonByName(this, id);
+	if (button)
+	{
+		setDefaultBtn(button);
+	}
+	else
+	{
+		setDefaultBtn(NULL);
+	}
+}
+
+BOOL LLPanel::handleKey(KEY key, MASK mask, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+	if (getVisible() && getEnabled())
+	{
+		if( (mask == MASK_SHIFT) && (KEY_TAB == key))	
+		{
+			//SHIFT-TAB
+			LLView* cur_focus = gFocusMgr.getKeyboardFocus();
+			if (cur_focus && gFocusMgr.childHasKeyboardFocus(this))
+			{
+				LLView* focus_root = cur_focus;
+				while(cur_focus->getParent())
+				{
+					cur_focus = cur_focus->getParent();
+					if (cur_focus->isFocusRoot())
+					{
+						// this is the root-most focus root found so far
+						focus_root = cur_focus;
+					}
+				}
+				handled = focus_root->focusPrevItem(FALSE);
+			}
+			else if (!cur_focus && mIsFocusRoot)
+			{
+				handled = focusLastItem();
+				if (!handled)
+				{
+					setFocus(TRUE);
+					handled = TRUE;
+				}
+			}
+		}
+		else
+		if( (mask == MASK_NONE ) && (KEY_TAB == key))	
+		{
+			//TAB
+			LLView* cur_focus = gFocusMgr.getKeyboardFocus();
+			if (cur_focus && gFocusMgr.childHasKeyboardFocus(this))
+			{
+				LLView* focus_root = cur_focus;
+				while(cur_focus->getParent())
+				{
+					cur_focus = cur_focus->getParent();
+					if (cur_focus->isFocusRoot())
+					{
+						focus_root = cur_focus;
+					}
+				}
+				handled = focus_root->focusNextItem(FALSE);
+			}
+			else if (!cur_focus && mIsFocusRoot)
+			{
+				handled = focusFirstItem();
+				if (!handled)
+				{
+					setFocus(TRUE);
+					handled = TRUE;
+				}
+			}
+		}
+	}
+
+	if (!handled)
+	{
+		handled = LLView::handleKey(key, mask, called_from_parent);
+	}
+
+	return handled;
+}
+
+void LLPanel::addCtrl( LLUICtrl* ctrl, S32 tab_group)
+{
+	mLastTabGroup = tab_group;
+
+	LLView::addCtrl(ctrl, tab_group);
+	// propagate chrome to children only if they have not been flagged as chrome
+	if (!ctrl->getIsChrome())
+	{
+		ctrl->setIsChrome(getIsChrome());
+	}
+}
+
+void LLPanel::addCtrlAtEnd( LLUICtrl* ctrl, S32 tab_group)
+{
+	mLastTabGroup = tab_group;
+
+	LLView::addCtrlAtEnd(ctrl, tab_group);
+	if (!ctrl->getIsChrome())
+	{
+		ctrl->setIsChrome(getIsChrome());
+	}
+}
+
+BOOL LLPanel::handleKeyHere( KEY key, MASK mask, BOOL called_from_parent )
+{
+	BOOL handled = FALSE;
+
+	if( getVisible() && getEnabled() && gFocusMgr.childHasKeyboardFocus(this) && KEY_ESCAPE == key )
+	{
+		gFocusMgr.setKeyboardFocus(NULL, NULL);
+		return TRUE;
+	}
+
+	if( getVisible() && getEnabled() && 
+		gFocusMgr.childHasKeyboardFocus(this) && !called_from_parent )
+	{
+		LLUICtrl* cur_focus = gFocusMgr.getKeyboardFocus();
+		if (key == KEY_RETURN && mask == MASK_NONE)
+		{
+			// set keyboard focus to self to trigger commitOnFocusLost behavior on current ctrl
+			if (cur_focus && cur_focus->acceptsTextInput())
+			{
+				cur_focus->onCommit();
+				handled = TRUE;
+			}
+		}
+
+		// If we have a default button, click it when
+		// return is pressed, unless current focus is a return-capturing button
+		// in which case *that* button will handle the return key
+		if (!(cur_focus->getWidgetType() == WIDGET_TYPE_BUTTON && static_cast<LLButton *>(cur_focus)->getCommitOnReturn()))
+		{
+			// RETURN key means hit default button in this case
+			if (key == KEY_RETURN && mask == MASK_NONE 
+				&& mDefaultBtn != NULL 
+				&& mDefaultBtn->getVisible()
+				&& mDefaultBtn->getEnabled())
+			{
+				mDefaultBtn->onCommit();
+				handled = TRUE;
+			}
+		}
+	}
+
+	return handled;
+}
+
+void LLPanel::requires(LLString name, EWidgetType type)
+{
+	mRequirements[name] = type;
+}
+
+BOOL LLPanel::checkRequirements()
+{
+	BOOL retval = TRUE;
+	LLString message;
+
+	for (requirements_map_t::iterator i = mRequirements.begin(); i != mRequirements.end(); ++i)
+	{
+		if (!this->getCtrlByNameAndType(i->first, i->second))
+		{
+			retval = FALSE;
+			message += i->first + " " + LLUICtrlFactory::getWidgetType(i->second) + "\n";
+		}
+	}
+
+	if (!retval)
+	{
+		LLString::format_map_t args;
+		args["[COMPONENTS]"] = message;
+		args["[FLOATER]"] = getName();
+
+		llwarns << getName() << " failed requirements check on: \n"  
+				<< message << llendl;
+			
+		alertXml("FailedRequirementsCheck", args);
+	}
+
+	return retval;
+}
+
+//static
+void LLPanel::alertXml(LLString label, LLString::format_map_t args)
+{
+	sAlertQueue.push(LLAlertInfo(label,args));
+}
+
+//static
+BOOL LLPanel::nextAlert(LLAlertInfo &alert)
+{
+	if (!sAlertQueue.empty())
+	{
+		alert = sAlertQueue.front();
+		sAlertQueue.pop();
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+void LLPanel::setFocus(BOOL b)
+{
+	if( b )
+	{
+		if (!gFocusMgr.childHasKeyboardFocus(this))
+		{
+			//refresh();
+			if (!focusFirstItem())
+			{
+				LLUICtrl::setFocus(TRUE);
+			}
+			onFocusReceived();
+		}
+	}
+	else
+	{
+		if( this == gFocusMgr.getKeyboardFocus() )
+		{
+			gFocusMgr.setKeyboardFocus( NULL, NULL );
+		}
+		else
+		{
+			//RN: why is this here?
+			LLView::ctrl_list_t ctrls = getCtrlList();
+			for (LLView::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
+			{
+				LLUICtrl* ctrl = *ctrl_it;
+				ctrl->setFocus( FALSE );
+			}
+		}
+	}
+}
+
+void LLPanel::setBackgroundColor(const LLColor4& color)
+{
+	mBgColorOpaque = color;
+}
+
+void LLPanel::setTransparentColor(const LLColor4& color)
+{
+	mBgColorAlpha = color;
+}
+
+void LLPanel::setBorderVisible(BOOL b)
+{
+	if (mBorder)
+	{
+		mBorder->setVisible( b );
+	}
+}
+
+LLView* LLPanel::getCtrlByNameAndType(const LLString& name, EWidgetType type)
+{
+	LLView* view = getChildByName(name, TRUE);
+	if (view)
+	{
+		if (type ==	WIDGET_TYPE_DONTCARE || view->getWidgetType() == type)
+		{
+			return view;
+		}
+		else
+		{
+			llwarns << "Widget " << name << " has improper type in panel " << mName << "\n"
+					<< "Is: \t\t" << view->getWidgetType() << "\n" 
+					<< "Should be: \t" << type 
+					<< llendl;
+		}
+	}
+	else
+	{
+		childNotFound(name);
+	}
+	return NULL;
+}
+
+// static 
+LLPanel* LLPanel::getPanelByHandle(LLViewHandle handle)
+{
+	if (!sPanelMap.count(handle))
+	{
+		return NULL;
+	}
+ 
+	return sPanelMap[handle];
+}
+
+// virtual
+LLXMLNodePtr LLPanel::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLView::getXML();
+
+	if (mBorder && mBorder->getVisible())
+	{
+		node->createChild("border", TRUE)->setBoolValue(TRUE);
+	}
+
+	if (!mRectControl.empty())
+	{
+		node->createChild("rect_control", TRUE)->setStringValue(mRectControl);
+	}
+
+	if (!mLabel.empty())
+	{
+		node->createChild("label", TRUE)->setStringValue(mLabel);
+	}
+
+	if (save_children)
+	{
+		LLView::child_list_const_reverse_iter_t rit;
+		for (rit = getChildList()->rbegin(); rit != getChildList()->rend(); ++rit)
+		{
+			LLView* childp = *rit;
+
+			if (childp->getSaveToXML())
+			{
+				LLXMLNodePtr xml_node = childp->getXML();
+
+				node->addChild(xml_node);
+			}
+		}
+	}
+
+	return node;
+}
+
+LLView* LLPanel::fromXML(LLXMLNodePtr node, LLView* parentp, LLUICtrlFactory *factory)
+{
+	LLString name("panel");
+	node->getAttributeString("name", name);
+
+	LLPanel* panelp = factory->createFactoryPanel(name);
+	// Fall back on a default panel, if there was no special factory.
+	if (!panelp)
+	{
+		panelp = new LLPanel("tab panel");
+	}
+
+	panelp->initPanelXML(node, parentp, factory);
+
+	return panelp;
+}
+
+void LLPanel::initPanelXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("panel");
+	node->getAttributeString("name", name);
+	setName(name);
+
+	setPanelParameters(node, parent);
+
+	LLXMLNodePtr child;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		factory->createWidget(this, child);
+	}
+
+	LLString xml_filename;
+	node->getAttributeString("filename", xml_filename);
+	if (!xml_filename.empty())
+	{
+		factory->buildPanel(this, xml_filename, NULL);
+	}
+	
+	postBuild();
+}
+
+void LLPanel::setPanelParameters(LLXMLNodePtr node, LLView* parentp)
+{
+	/////// Rect, follows, tool_tip, enabled, visible attributes ///////
+	initFromXML(node, parentp);
+
+	/////// Border attributes ///////
+	BOOL border = FALSE;
+	node->getAttributeBOOL("border", border);
+	if (border)
+	{
+		LLViewBorder::EBevel bevel_style = LLViewBorder::BEVEL_OUT;
+		LLViewBorder::getBevelFromAttribute(node, bevel_style);
+
+		LLViewBorder::EStyle border_style = LLViewBorder::STYLE_LINE;
+		LLString border_string;
+		node->getAttributeString("border_style", border_string);
+		LLString::toLower(border_string);
+
+		if (border_string == "texture")
+		{
+			border_style = LLViewBorder::STYLE_TEXTURE;
+		}
+
+		S32 border_thickness = LLPANEL_BORDER_WIDTH;
+		node->getAttributeS32("border_thickness", border_thickness);
+
+		addBorder(bevel_style, border_style, border_thickness);
+	}
+
+	/////// Background attributes ///////
+	BOOL background_visible = FALSE;
+	node->getAttributeBOOL("background_visible", background_visible);
+	setBackgroundVisible(background_visible);
+	
+	BOOL background_opaque = FALSE;
+	node->getAttributeBOOL("background_opaque", background_opaque);
+	setBackgroundOpaque(background_opaque);
+
+	LLColor4 color;
+	color = LLUI::sColorsGroup->getColor( "FocusBackgroundColor" );
+	LLUICtrlFactory::getAttributeColor(node,"bg_opaque_color", color);
+	setBackgroundColor(color);
+
+	color = LLUI::sColorsGroup->getColor( "DefaultBackgroundColor" );
+	LLUICtrlFactory::getAttributeColor(node,"bg_alpha_color", color);
+	setTransparentColor(color);
+
+	LLString label;
+	node->getAttributeString("label", label);
+	setLabel(label);
+}
+
+void LLPanel::childSetVisible(const LLString& id, bool visible)
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		child->setVisible(visible);
+	}
+}
+
+bool LLPanel::childIsVisible(const LLString& id) const
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		return (bool)child->getVisible();
+	}
+	return false;
+}
+
+void LLPanel::childSetEnabled(const LLString& id, bool enabled)
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		child->setEnabled(enabled);
+	}
+}
+
+void LLPanel::childSetTentative(const LLString& id, bool tentative)
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		child->setTentative(tentative);
+	}
+}
+
+bool LLPanel::childIsEnabled(const LLString& id) const
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		return (bool)child->getEnabled();
+	}
+	return false;
+}
+
+
+void LLPanel::childSetToolTip(const LLString& id, const LLString& msg)
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		child->setToolTip(msg);
+	}
+}
+
+void LLPanel::childSetRect(const LLString& id, const LLRect& rect)
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		child->setRect(rect);
+	}
+}
+
+bool LLPanel::childGetRect(const LLString& id, LLRect& rect) const
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		rect = child->getRect();
+		return true;
+	}
+	return false;
+}
+
+void LLPanel::childSetFocus(const LLString& id, BOOL focus)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setFocus(focus);
+	}
+}
+
+BOOL LLPanel::childHasFocus(const LLString& id)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		return child->hasFocus();
+	}
+	else
+	{
+		childNotFound(id);
+		return FALSE;
+	}
+}
+
+
+void LLPanel::childSetFocusChangedCallback(const LLString& id, void (*cb)(LLUICtrl*, void*))
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setFocusChangedCallback(cb);
+	}
+}
+
+void LLPanel::childSetCommitCallback(const LLString& id, void (*cb)(LLUICtrl*, void*), void *userdata )
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setCommitCallback(cb);
+		child->setCallbackUserData(userdata);
+	}
+}
+
+void LLPanel::childSetDoubleClickCallback(const LLString& id, void (*cb)(void*), void *userdata )
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setDoubleClickCallback(cb);
+		if (userdata)
+		{
+			child->setCallbackUserData(userdata);
+		}
+	}
+}
+
+void LLPanel::childSetValidate(const LLString& id, BOOL (*cb)(LLUICtrl*, void*))
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setValidateBeforeCommit(cb);
+	}
+}
+
+void LLPanel::childSetUserData(const LLString& id, void* userdata)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setCallbackUserData(userdata);
+	}
+}
+
+void LLPanel::childSetColor(const LLString& id, const LLColor4& color)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setColor(color);
+	}
+}
+
+LLCtrlSelectionInterface* LLPanel::childGetSelectionInterface(const LLString& id)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		return child->getSelectionInterface();
+	}
+	return NULL;
+}
+
+LLCtrlListInterface* LLPanel::childGetListInterface(const LLString& id)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		return child->getListInterface();
+	}
+	return NULL;
+}
+
+LLCtrlScrollInterface* LLPanel::childGetScrollInterface(const LLString& id)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		return child->getScrollInterface();
+	}
+	return NULL;
+}
+
+void LLPanel::childSetValue(const LLString& id, LLSD value)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setValue(value);
+	}
+}
+
+LLSD LLPanel::childGetValue(const LLString& id) const
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		return child->getValue();
+	}
+	// Not found => return undefined
+	return LLSD();
+}
+
+BOOL LLPanel::childSetTextArg(const LLString& id, const LLString& key, const LLString& text)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		return child->setTextArg(key, text);
+	}
+	return FALSE;
+}
+
+BOOL LLPanel::childSetLabelArg(const LLString& id, const LLString& key, const LLString& text)
+{
+	LLView* child = getChildByName(id, true);
+	if (child)
+	{
+		return child->setLabelArg(key, text);
+	}
+	return FALSE;
+}
+
+void LLPanel::childSetMinValue(const LLString& id, LLSD min_value)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setMinValue(min_value);
+	}
+}
+
+void LLPanel::childSetMaxValue(const LLString& id, LLSD max_value)
+{
+	LLUICtrl* child = (LLUICtrl*)getChildByName(id, true);
+	if (child)
+	{
+		child->setMaxValue(max_value);
+	}
+}
+
+void LLPanel::childShowTab(const LLString& id, const LLString& tabname, bool visible)
+{
+	LLTabContainerCommon* child = LLUICtrlFactory::getTabContainerByName(this, id);
+	if (child)
+	{
+		child->selectTabByName(tabname);
+	}
+}
+
+LLPanel *LLPanel::childGetVisibleTab(const LLString& id)
+{
+	LLTabContainerCommon* child = LLUICtrlFactory::getTabContainerByName(this, id);
+	if (child)
+	{
+		return child->getCurrentPanel();
+	}
+	return NULL;
+}
+
+void LLPanel::childSetTabChangeCallback(const LLString& id, const LLString& tabname, void (*on_tab_clicked)(void*, bool), void *userdata)
+{
+	LLTabContainerCommon* child = LLUICtrlFactory::getTabContainerByName(this, id);
+	if (child)
+	{
+		LLPanel *panel = child->getPanelByName(tabname);
+		if (panel)
+		{
+			child->setTabChangeCallback(panel, on_tab_clicked);
+			child->setTabUserData(panel, userdata);
+		}
+	}
+}
+
+void LLPanel::childSetText(const LLString& id, const LLString& text)
+{
+	childSetValue(id, LLSD(text));
+}
+
+void LLPanel::childSetKeystrokeCallback(const LLString& id, void (*keystroke_callback)(LLLineEditor* caller, void* user_data), void *user_data)
+{
+	LLLineEditor* child = LLUICtrlFactory::getLineEditorByName(this, id);
+	if (child)
+	{
+		child->setKeystrokeCallback(keystroke_callback);
+		if (user_data)
+		{
+			child->setCallbackUserData(user_data);
+		}
+	}
+}
+
+void LLPanel::childSetPrevalidate(const LLString& id, BOOL (*func)(const LLWString &) )
+{
+	LLLineEditor* child = LLUICtrlFactory::getLineEditorByName(this, id);
+	if (child)
+	{
+		child->setPrevalidate(func);
+	}
+}
+
+LLString LLPanel::childGetText(const LLString& id)
+{
+	return childGetValue(id).asString();
+}
+
+void LLPanel::childSetWrappedText(const LLString& id, const LLString& text, bool visible)
+{
+	LLTextBox* child = (LLTextBox*)getCtrlByNameAndType(id, WIDGET_TYPE_TEXT_BOX);
+	if (child)
+	{
+		child->setVisible(visible);
+		child->setWrappedText(text);
+	}
+}
+
+void LLPanel::childSetAction(const LLString& id, void(*function)(void*), void* value)
+{
+	LLButton* button = (LLButton*)getCtrlByNameAndType(id, WIDGET_TYPE_BUTTON);
+	if (button)
+	{
+		button->setClickedCallback(function, value);
+	}
+}
+
+void LLPanel::childSetActionTextbox(const LLString& id, void(*function)(void*))
+{
+	LLTextBox* textbox = (LLTextBox*)getCtrlByNameAndType(id, WIDGET_TYPE_TEXT_BOX);
+	if (textbox)
+	{
+		textbox->setClickedCallback(function);
+	}
+}
+
+void LLPanel::childSetControlName(const LLString& id, const LLString& control_name)
+{
+	LLView* view = getChildByName(id, TRUE);
+	if (view)
+	{
+		view->setControlName(control_name, NULL);
+	}
+}
+
+//virtual
+LLView* LLPanel::getChildByName(const LLString& name, BOOL recurse) const
+{
+	LLView* view = LLUICtrl::getChildByName(name, recurse);
+	if (!view)
+	{
+		childNotFound(name);
+	}
+	return view;
+}
+
+void LLPanel::childNotFound(const LLString& id) const
+{
+	if (mExpectedMembers.find(id) == mExpectedMembers.end())
+	{
+		mNewExpectedMembers.insert(id);
+	}
+}
+
+void LLPanel::childDisplayNotFound()
+{
+	if (mNewExpectedMembers.empty())
+	{
+		return;
+	}
+	LLString msg;
+	expected_members_list_t::iterator itor;
+	for (itor=mNewExpectedMembers.begin(); itor!=mNewExpectedMembers.end(); ++itor)
+	{
+		msg.append(*itor);
+		msg.append("\n");
+		mExpectedMembers.insert(*itor);
+	}
+	mNewExpectedMembers.clear();
+	LLString::format_map_t args;
+	args["[CONTROLS]"] = msg;
+	LLAlertDialog::showXml("FloaterNotFound", args);
+}
+
diff --git a/indra/llui/llpanel.h b/indra/llui/llpanel.h
new file mode 100644
index 0000000000..9da27b6f38
--- /dev/null
+++ b/indra/llui/llpanel.h
@@ -0,0 +1,229 @@
+/** 
+ * @file llpanel.h
+ * @author James Cook, Tom Yedwab
+ * @brief LLPanel base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLPANEL_H
+#define LL_LLPANEL_H
+
+// Opaque view with a background and a border.  Can contain LLUICtrls.
+
+#include "llcallbackmap.h"
+#include "lluictrl.h"
+#include "llviewborder.h"
+#include "v4color.h"
+#include <list>
+
+const S32 LLPANEL_BORDER_WIDTH = 1;
+const BOOL BORDER_YES = TRUE;
+const BOOL BORDER_NO = FALSE;
+
+class LLViewerImage;
+class LLUUID;
+class LLCheckBoxCtrl;
+class LLComboBox;
+class LLIconCtrl;
+class LLLineEditor;
+class LLRadioGroup;
+class LLScrollListCtrl;
+class LLSliderCtrl;
+class LLSpinCtrl;
+class LLTextBox;
+class LLTextEditor;
+
+class LLAlertInfo
+{
+public:
+	LLString mLabel;
+	LLString::format_map_t mArgs;
+
+	LLAlertInfo(LLString label, LLString::format_map_t args)
+		: mLabel(label), mArgs(args) { }
+
+		LLAlertInfo() { }
+};
+
+class LLPanel : public LLUICtrl
+{
+public:
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	// defaults to TRUE
+	virtual BOOL isPanel();
+
+	// minimal constructor for data-driven initialization
+	LLPanel();
+	LLPanel(const LLString& name);
+
+	// Position and size not saved
+	LLPanel(const LLString& name, const LLRect& rect, BOOL bordered = TRUE);
+
+	// Position and size are saved to rect_control
+	LLPanel(const LLString& name, const LLString& rect_control, BOOL bordered = TRUE);
+
+	void addBorder( LLViewBorder::EBevel border_bevel = LLViewBorder::BEVEL_OUT,
+					LLViewBorder::EStyle border_style = LLViewBorder::STYLE_LINE,
+					S32 border_thickness = LLPANEL_BORDER_WIDTH );
+
+	virtual ~LLPanel();
+	virtual void	draw();	
+	virtual void 	refresh();	// called in setFocus()
+	virtual void	setFocus( BOOL b );
+	void			setFocusRoot(BOOL b) { mIsFocusRoot = b; }
+	virtual BOOL	handleKeyHere( KEY key, MASK mask, BOOL called_from_parent );
+	virtual BOOL	handleKey( KEY key, MASK mask, BOOL called_from_parent );
+	virtual BOOL	postBuild();
+
+	void			requires(LLString name, EWidgetType type = WIDGET_TYPE_DONTCARE);
+	BOOL			checkRequirements();
+
+	static void		alertXml(LLString label, LLString::format_map_t args = LLString::format_map_t());
+	static BOOL		nextAlert(LLAlertInfo &alert);
+
+	void			setBackgroundColor( const LLColor4& color );
+	void			setTransparentColor(const LLColor4& color);
+	void			setBackgroundVisible( BOOL b )	{ mBgVisible = b; }
+	void			setBackgroundOpaque(BOOL b)		{ mBgOpaque = b; }
+	void			setDefaultBtn(LLButton* btn = NULL);
+	void			setDefaultBtn(const LLString& id);
+	void			setLabel(LLString label) { mLabel = label; }
+	LLString		getLabel() const { return mLabel; }
+	
+	void            setRectControl(const LLString& rect_control) { mRectControl.assign(rect_control); }
+	
+	void			setBorderVisible( BOOL b );
+
+	void			setCtrlsEnabled(BOOL b);
+	virtual void	clearCtrls();
+
+	LLViewHandle	getHandle() { return mViewHandle; }
+
+	S32				getLastTabGroup() { return mLastTabGroup; }
+
+	LLView*			getCtrlByNameAndType(const LLString& name, EWidgetType type);
+
+	static LLPanel*	getPanelByHandle(LLViewHandle handle);
+
+	virtual const LLCallbackMap::map_t& getFactoryMap() const { return mFactoryMap; }
+
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	void initPanelXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	void setPanelParameters(LLXMLNodePtr node, LLView *parentp);
+
+	// ** Wrappers for setting child properties by name ** -TomY
+
+	// Override to set not found list
+	virtual LLView* getChildByName(const LLString& name, BOOL recurse = FALSE) const;
+	
+	// LLView
+	void childSetVisible(const LLString& name, bool visible);
+	void childShow(const LLString& name) { childSetVisible(name, true); }
+	void childHide(const LLString& name) { childSetVisible(name, false); }
+	bool childIsVisible(const LLString& id) const;
+	void childSetTentative(const LLString& name, bool tentative);
+
+	void childSetEnabled(const LLString& name, bool enabled);
+	void childEnable(const LLString& name)	{ childSetEnabled(name, true); }
+	void childDisable(const LLString& name) { childSetEnabled(name, false); };
+	bool childIsEnabled(const LLString& id) const;
+
+	void childSetToolTip(const LLString& id, const LLString& msg);
+	void childSetRect(const LLString& id, const LLRect &rect);
+	bool childGetRect(const LLString& id, LLRect& rect) const;
+
+	// LLUICtrl
+	void childSetFocus(const LLString& id, BOOL focus = TRUE);
+	BOOL childHasFocus(const LLString& id);
+	void childSetFocusChangedCallback(const LLString& id, void (*cb)(LLUICtrl*, void*));
+	
+	void childSetCommitCallback(const LLString& id, void (*cb)(LLUICtrl*, void*), void* userdata = NULL );
+	void childSetDoubleClickCallback(const LLString& id, void (*cb)(void*), void* userdata = NULL );
+	void childSetValidate(const LLString& id, BOOL (*cb)(LLUICtrl*, void*) );
+	void childSetUserData(const LLString& id, void* userdata);
+
+	void childSetColor(const LLString& id, const LLColor4& color);
+
+	LLCtrlSelectionInterface* childGetSelectionInterface(const LLString& id);
+	LLCtrlListInterface* childGetListInterface(const LLString& id);
+	LLCtrlScrollInterface* childGetScrollInterface(const LLString& id);
+
+	// This is the magic bullet for data-driven UI
+	void childSetValue(const LLString& id, LLSD value);
+	LLSD childGetValue(const LLString& id) const;
+
+	// For setting text / label replacement params, e.g. "Hello [NAME]"
+	// Not implemented for all types, defaults to noop, returns FALSE if not applicaple
+	BOOL childSetTextArg(const LLString& id, const LLString& key, const LLString& text);
+	BOOL childSetLabelArg(const LLString& id, const LLString& key, const LLString& text);
+	
+	// LLSlider / LLSpinCtrl
+	void childSetMinValue(const LLString& id, LLSD min_value);
+	void childSetMaxValue(const LLString& id, LLSD max_value);
+
+	// LLTabContainer
+	void childShowTab(const LLString& id, const LLString& tabname, bool visible = true);
+	LLPanel *childGetVisibleTab(const LLString& id);
+	void childSetTabChangeCallback(const LLString& id, const LLString& tabname, void (*on_tab_clicked)(void*, bool), void *userdata);
+
+	// LLTextBox
+	void childSetWrappedText(const LLString& id, const LLString& text, bool visible = true);
+
+	// LLTextBox/LLTextEditor/LLLineEditor
+	void childSetText(const LLString& id, const LLString& text);
+	LLString childGetText(const LLString& id);
+
+	// LLLineEditor
+	void childSetKeystrokeCallback(const LLString& id, void (*keystroke_callback)(LLLineEditor* caller, void* user_data), void *user_data);
+	void childSetPrevalidate(const LLString& id, BOOL (*func)(const LLWString &) );
+
+	// LLButton
+	void childSetAction(const LLString& id, void(*function)(void*), void* value);
+	void childSetActionTextbox(const LLString& id, void(*function)(void*));
+	void childSetControlName(const LLString& id, const LLString& control_name);
+
+	// Error reporting
+	void childNotFound(const LLString& id) const;
+	void childDisplayNotFound();
+
+	typedef std::queue<LLAlertInfo> alert_queue_t;
+	static alert_queue_t sAlertQueue;
+
+private:
+	// common constructor
+	void init();
+	
+protected:
+	virtual void	addCtrl( LLUICtrl* ctrl, S32 tab_group );
+	virtual void	addCtrlAtEnd( LLUICtrl* ctrl, S32 tab_group);
+
+	// Unified error reporting for the child* functions
+	typedef std::set<LLString> expected_members_list_t;
+	mutable expected_members_list_t mExpectedMembers;
+	mutable expected_members_list_t mNewExpectedMembers;
+
+	LLString		mRectControl;
+	LLColor4		mBgColorAlpha;
+	LLColor4		mBgColorOpaque;
+	LLColor4		mDefaultBtnHighlight;
+	BOOL			mBgVisible;
+	BOOL			mBgOpaque;
+	LLViewBorder*	mBorder;
+	LLButton*		mDefaultBtn;
+	LLCallbackMap::map_t mFactoryMap;
+	LLString		mLabel;
+	S32				mLastTabGroup;
+
+	typedef std::map<LLString, EWidgetType> requirements_map_t;
+	requirements_map_t mRequirements;
+
+	typedef std::map<LLViewHandle, LLPanel*> panel_map_t;
+	static panel_map_t sPanelMap;
+};
+
+#endif
diff --git a/indra/llui/llradiogroup.cpp b/indra/llui/llradiogroup.cpp
new file mode 100644
index 0000000000..69c0da6933
--- /dev/null
+++ b/indra/llui/llradiogroup.cpp
@@ -0,0 +1,440 @@
+/** 
+ * @file llradiogroup.cpp
+ * @brief LLRadioGroup base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// An invisible view containing multiple mutually exclusive toggling 
+// buttons (usually radio buttons).  Automatically handles the mutex
+// condition by highlighting only one button at a time.
+
+#include "linden_common.h"
+
+#include "llboost.h"
+
+#include "llradiogroup.h"
+#include "indra_constants.h"
+
+#include "llviewborder.h"
+#include "llcontrol.h"
+#include "llui.h"
+#include "llfocusmgr.h"
+
+LLRadioGroup::LLRadioGroup(const LLString& name, const LLRect& rect,
+						   const LLString& control_name,
+						   LLUICtrlCallback callback,
+						   void* userdata,
+						   BOOL border)
+:	LLUICtrl(name, rect, TRUE, callback, userdata, FOLLOWS_LEFT | FOLLOWS_TOP),
+	mSelectedIndex(0)
+{
+	setControlName(control_name, NULL);
+	init(border);
+}
+
+LLRadioGroup::LLRadioGroup(const LLString& name, const LLRect& rect,
+						   S32 initial_index,
+						   LLUICtrlCallback callback,
+						   void* userdata,
+						   BOOL border) :
+	LLUICtrl(name, rect, TRUE, callback, userdata, FOLLOWS_LEFT | FOLLOWS_TOP),
+	mSelectedIndex(initial_index)
+{
+	init(border);
+}
+
+void LLRadioGroup::init(BOOL border)
+{
+	if (border)
+	{
+		addChild( new LLViewBorder( "radio group border", 
+									LLRect(0, mRect.getHeight(), mRect.getWidth(), 0), 
+									LLViewBorder::BEVEL_NONE, 
+									LLViewBorder::STYLE_LINE, 
+									1 ) );
+	}
+	mHasBorder = border;
+}
+
+
+
+
+LLRadioGroup::~LLRadioGroup()
+{
+}
+
+
+// virtual
+void LLRadioGroup::setEnabled(BOOL enabled)
+{
+	for (child_list_const_iter_t child_iter = getChildList()->begin();
+		 child_iter != getChildList()->end(); ++child_iter)
+	{
+		LLView *child = *child_iter;
+		child->setEnabled(enabled);
+	}
+	LLView::setEnabled(enabled);
+}
+
+void LLRadioGroup::setIndexEnabled(S32 index, BOOL enabled)
+{
+	S32 count = 0;
+	for (button_list_t::iterator iter = mRadioButtons.begin();
+		 iter != mRadioButtons.end(); ++iter)
+	{
+		LLRadioCtrl* child = *iter;
+		if (count == index)
+		{
+			child->setEnabled(enabled);
+			if (index == mSelectedIndex && enabled == FALSE)
+			{
+				setSelectedIndex(-1);
+			}
+			break;
+		}
+		count++;
+	}
+	count = 0;
+	if (mSelectedIndex < 0)
+	{
+		// Set to highest enabled value < index,
+		// or lowest value above index if none lower are enabled
+		// or 0 if none are enabled
+		for (button_list_t::iterator iter = mRadioButtons.begin();
+			 iter != mRadioButtons.end(); ++iter)
+		{
+			LLRadioCtrl* child = *iter;
+			if (count >= index && mSelectedIndex >= 0)
+			{
+				break;
+			}
+			if (child->getEnabled())
+			{
+				setSelectedIndex(count);
+			}
+			count++;
+		}
+		if (mSelectedIndex < 0)
+		{
+			setSelectedIndex(0);
+		}
+	}
+}
+
+S32 LLRadioGroup::getSelectedIndex() const
+{
+	return mSelectedIndex;
+}
+
+BOOL LLRadioGroup::setSelectedIndex(S32 index, BOOL from_event)
+{
+	if (index < 0 || index >= (S32)mRadioButtons.size())
+	{
+		return FALSE;
+	}
+
+	mSelectedIndex = index;
+
+	if (!from_event)
+	{
+		setControlValue(getSelectedIndex());
+	}
+
+	return TRUE;
+}
+
+BOOL LLRadioGroup::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+	// do any of the tab buttons have keyboard focus?
+	if (getEnabled() && !called_from_parent)
+	{
+		switch(key)
+		{
+		case KEY_DOWN:
+			if (!setSelectedIndex((getSelectedIndex() + 1)))
+			{
+				make_ui_sound("UISndInvalidOp");
+			}
+			else
+			{
+				onCommit();
+			}
+			handled = TRUE;
+			break;
+		case KEY_UP:
+			if (!setSelectedIndex((getSelectedIndex() - 1)))
+			{
+				make_ui_sound("UISndInvalidOp");
+			}
+			else
+			{
+				onCommit();
+			}
+			handled = TRUE;
+			break;
+		case KEY_LEFT:
+			if (!setSelectedIndex((getSelectedIndex() - 1)))
+			{
+				make_ui_sound("UISndInvalidOp");
+			}
+			else
+			{
+				onCommit();
+			}
+			handled = TRUE;
+			break;
+		case KEY_RIGHT:
+			if (!setSelectedIndex((getSelectedIndex() + 1)))
+			{
+				make_ui_sound("UISndInvalidOp");
+			}
+			else
+			{
+				onCommit();
+			}
+			handled = TRUE;
+			break;
+		default:
+			break;
+		}
+	}
+	return handled;
+}
+
+void LLRadioGroup::draw()
+{
+	S32 current_button = 0;
+
+	BOOL take_focus = FALSE;
+	if (gFocusMgr.childHasKeyboardFocus(this))
+	{
+		take_focus = TRUE;
+	}
+
+	for (button_list_t::iterator iter = mRadioButtons.begin();
+		 iter != mRadioButtons.end(); ++iter)
+	{
+		LLRadioCtrl* radio = *iter;
+		BOOL selected = (current_button == mSelectedIndex);
+		radio->setValue( selected );
+		if (take_focus && selected && !gFocusMgr.childHasKeyboardFocus(radio))
+		{
+			radio->focusFirstItem();
+		}
+		current_button++;
+	}
+
+	LLView::draw();
+}
+
+
+// When adding a button, we need to ensure that the radio
+// group gets a message when the button is clicked.
+LLRadioCtrl* LLRadioGroup::addRadioButton(const LLString& name, const LLString& label, const LLRect& rect, const LLFontGL* font )
+{
+	// Highlight will get fixed in draw method above
+	LLRadioCtrl* radio = new LLRadioCtrl(name, rect, label, font,
+		onClickButton, this);
+	addChild(radio);
+	mRadioButtons.push_back(radio);
+	return radio;
+}
+
+// Handle one button being clicked.  All child buttons must have this
+// function as their callback function.
+
+// static
+void LLRadioGroup::onClickButton(LLUICtrl* ui_ctrl, void* userdata)
+{
+	// llinfos << "LLRadioGroup::onClickButton" << llendl;
+
+	LLRadioCtrl* clickedRadio = (LLRadioCtrl*) ui_ctrl;
+	LLRadioGroup* self = (LLRadioGroup*) userdata;
+
+	S32 counter = 0;
+	for (button_list_t::iterator iter = self->mRadioButtons.begin();
+		 iter != self->mRadioButtons.end(); ++iter)
+	{
+		LLRadioCtrl* radio = *iter;
+		if (radio == clickedRadio)
+		{
+			// llinfos << "clicked button " << counter << llendl;
+			self->setSelectedIndex(counter);
+			self->setControlValue(counter);
+			
+			// BUG: Calls click callback even if button didn't actually change
+			self->onCommit();
+
+			return;
+		}
+
+		counter++;
+	}
+
+	llwarns << "LLRadioGroup::onClickButton - clicked button that isn't a child" << llendl;
+}
+
+void LLRadioGroup::setValue( const LLSD& value )
+{
+	LLString value_name = value.asString();
+	int idx = 0;
+	for (button_list_t::const_iterator iter = mRadioButtons.begin();
+		 iter != mRadioButtons.end(); ++iter)
+	{
+		LLRadioCtrl* radio = *iter;
+		if (radio->getName() == value_name)
+		{
+			setSelectedIndex(idx);
+			idx = -1;
+			break;
+		}
+		++idx;
+	}
+	if (idx != -1)
+	{
+		// string not found, try integer
+		if (value.isInteger())
+		{
+			setSelectedIndex((S32) value.asInteger(), TRUE);
+		}
+		else
+		{
+			llwarns << "LLRadioGroup::setValue: value not found: " << value_name << llendl;
+		}
+	}
+}
+
+LLSD LLRadioGroup::getValue() const
+{
+	int index = getSelectedIndex();
+	int idx = 0;
+	for (button_list_t::const_iterator iter = mRadioButtons.begin();
+		 iter != mRadioButtons.end(); ++iter)
+	{
+		if (idx == index) return LLSD((*iter)->getName());
+		++idx;
+	}
+	return LLSD();
+}
+
+// virtual
+LLXMLNodePtr LLRadioGroup::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	// Attributes
+
+	node->createChild("draw_border", TRUE)->setBoolValue(mHasBorder);
+
+	// Contents
+
+	for (button_list_t::const_iterator iter = mRadioButtons.begin();
+		 iter != mRadioButtons.end(); ++iter)
+	{
+		LLRadioCtrl* radio = *iter;
+
+		LLXMLNodePtr child_node = radio->LLView::getXML();
+		child_node->setStringValue(radio->getLabel());
+		child_node->setName("radio_item");
+
+		node->addChild(child_node);
+	}
+
+	return node;
+}
+
+// static
+LLView* LLRadioGroup::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("radio_group");
+	node->getAttributeString("name", name);
+
+	U32 initial_value = 0;
+	node->getAttributeU32("initial_value", initial_value);
+
+	BOOL draw_border = TRUE;
+	node->getAttributeBOOL("draw_border", draw_border);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	LLRadioGroup* radio_group = new LLRadioGroup(name, 
+		rect,
+		initial_value,
+		NULL,
+		NULL,
+		draw_border);
+
+	const LLString& contents = node->getValue();
+
+	LLRect group_rect = radio_group->getRect();
+
+	LLFontGL *font = LLView::selectFont(node);
+
+	if (contents.find_first_not_of(" \n\t") != contents.npos)
+	{
+		// ...old school default vertical layout
+		typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+		boost::char_separator<char> sep("\t\n");
+		tokenizer tokens(contents, sep);
+		tokenizer::iterator token_iter = tokens.begin();
+	
+		const S32 HPAD = 4, VPAD = 4;
+		S32 cur_y = group_rect.getHeight() - VPAD;
+	
+		while(token_iter != tokens.end())
+		{
+			const char* line = token_iter->c_str();
+			LLRect rect(HPAD, cur_y, group_rect.getWidth() - (2 * HPAD), cur_y - 15);
+			cur_y -= VPAD + 15;
+			radio_group->addRadioButton("radio", line, rect, font);
+			++token_iter;
+		}
+		llwarns << "Legacy radio group format used! Please convert to use <radio_item> tags!" << llendl;
+	}
+	else
+	{
+		// ...per pixel layout
+		LLXMLNodePtr child;
+		for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+		{
+			if (child->hasName("radio_item"))
+			{
+				LLRect item_rect;
+				createRect(child, item_rect, radio_group, rect);
+
+				LLString radioname("radio");
+				child->getAttributeString("name", radioname);
+				LLString item_label = child->getTextContents();
+				LLRadioCtrl* radio = radio_group->addRadioButton(radioname, item_label.c_str(), item_rect, font);
+
+				radio->initFromXML(child, radio_group);
+			}
+		}
+	}
+
+	radio_group->initFromXML(node, parent);
+
+	return radio_group;
+}
+
+
+LLRadioCtrl::LLRadioCtrl(const LLString& name, const LLRect& rect, const LLString& label,	
+						 const LLFontGL* font, void (*commit_callback)(LLUICtrl*, void*), void* callback_userdata) :
+				LLCheckBoxCtrl(name, rect, label, font, commit_callback, callback_userdata, FALSE, RADIO_STYLE)
+{
+	setTabStop(FALSE);
+}
+
+LLRadioCtrl::~LLRadioCtrl()
+{
+}
+
+void LLRadioCtrl::setValue(const LLSD& value)
+{
+	LLCheckBoxCtrl::setValue(value);
+	mButton->setTabStop(value.asBoolean());
+}
diff --git a/indra/llui/llradiogroup.h b/indra/llui/llradiogroup.h
new file mode 100644
index 0000000000..01b4a61b82
--- /dev/null
+++ b/indra/llui/llradiogroup.h
@@ -0,0 +1,102 @@
+/** 
+ * @file llradiogroup.h
+ * @brief LLRadioGroup base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// An invisible view containing multiple mutually exclusive toggling 
+// buttons (usually radio buttons).  Automatically handles the mutex
+// condition by highlighting only one button at a time.
+
+#ifndef LL_LLRADIOGROUP_H
+#define LL_LLRADIOGROUP_H
+
+#include "lluictrl.h"
+#include "llcheckboxctrl.h"
+
+class LLFontGL;
+
+// Radio controls are checkbox controls with use_radio_style true
+class LLRadioCtrl : public LLCheckBoxCtrl 
+{
+public:
+	LLRadioCtrl(const LLString& name, const LLRect& rect, const LLString& label,	
+		const LLFontGL* font = NULL,
+		void (*commit_callback)(LLUICtrl*, void*) = NULL,
+		void* callback_userdata = NULL);
+	/*virtual*/ ~LLRadioCtrl();
+
+	/*virtual*/ void setValue(const LLSD& value);
+};
+
+class LLRadioGroup
+:	public LLUICtrl
+{
+public:
+	// Build a radio group.  The number (0...n-1) of the currently selected
+	// element will be stored in the named control.  After the control is
+	// changed the callback will be called.
+	LLRadioGroup(const LLString& name, const LLRect& rect, 
+		const LLString& control_name, 
+		LLUICtrlCallback callback = NULL,
+		void* userdata = NULL,
+		BOOL border = TRUE);
+
+	// Another radio group constructor, but this one doesn't rely on
+	// needing a control
+	LLRadioGroup(const LLString& name, const LLRect& rect,
+				 S32 initial_index,
+				 LLUICtrlCallback callback = NULL,
+				 void* userdata = NULL,
+				 BOOL border = TRUE);
+
+	virtual ~LLRadioGroup();
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_RADIO_GROUP; }
+	virtual LLString getWidgetTag() const { return LL_RADIO_GROUP_TAG; }
+
+	virtual BOOL handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+
+	virtual void setEnabled(BOOL enabled);
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	void setIndexEnabled(S32 index, BOOL enabled);
+	
+	S32 getItemCount() { return mRadioButtons.size(); }
+	// return the index value of the selected item
+	S32 getSelectedIndex() const;
+	
+	// set the index value programatically
+	BOOL setSelectedIndex(S32 index, BOOL from_event = FALSE);
+
+	// Accept and retrieve strings of the radio group control names
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+
+	// Draw the group, but also fix the highlighting based on the
+	// control.
+	void draw();
+
+	// You must use this method to add buttons to a radio group.
+	// Don't use addChild -- it won't set the callback function
+	// correctly.
+	LLRadioCtrl* addRadioButton(const LLString& name, const LLString& label, const LLRect& rect, const LLFontGL* font);
+	LLRadioCtrl* getRadioButton(const S32& index) { return mRadioButtons[index]; }
+	// Update the control as needed.  Userdata must be a pointer to the
+	// button.
+	static void onClickButton(LLUICtrl* radio, void* userdata);
+	
+protected:
+	// protected function shared by the two constructors.
+	void init(BOOL border);
+
+	S32 mSelectedIndex;
+	typedef std::vector<LLRadioCtrl*> button_list_t;
+	button_list_t mRadioButtons;
+
+	BOOL mHasBorder;
+};
+
+
+#endif
diff --git a/indra/llui/llresizebar.cpp b/indra/llui/llresizebar.cpp
new file mode 100644
index 0000000000..0183c58c93
--- /dev/null
+++ b/indra/llui/llresizebar.cpp
@@ -0,0 +1,257 @@
+/** 
+ * @file llresizebar.cpp
+ * @brief LLResizeBar base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llresizebar.h"
+
+//#include "llviewermenu.h"
+//#include "llviewerimagelist.h"
+#include "llmath.h"
+#include "llui.h"
+#include "llmenugl.h"
+#include "llfocusmgr.h"
+#include "llwindow.h"
+
+LLResizeBar::LLResizeBar( const LLString& name, const LLRect& rect, S32 min_width, S32 min_height, Side side )
+	:
+	LLView( name, rect, TRUE ),
+	mDragStartScreenX( 0 ),
+	mDragStartScreenY( 0 ),
+	mLastMouseScreenX( 0 ),
+	mLastMouseScreenY( 0 ),
+	mMinWidth( min_width ),
+	mMinHeight( min_height ),
+	mSide( side )
+{
+	// set up some generically good follow code.
+	switch( side )
+	{
+	case LEFT:
+		setFollowsLeft();
+		setFollowsTop();
+		setFollowsBottom();
+		break;
+	case TOP:
+		setFollowsTop();
+		setFollowsLeft();
+		setFollowsRight();
+		break;
+	case RIGHT:
+		setFollowsRight();
+		setFollowsTop();
+		setFollowsBottom();
+		break;
+	case BOTTOM:
+		setFollowsBottom();
+		setFollowsLeft();
+		setFollowsRight();
+		break;
+	default:
+		break;
+	}
+}
+
+
+BOOL LLResizeBar::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	if( mEnabled )
+	{
+		// Route future Mouse messages here preemptively.  (Release on mouse up.)
+		// No handler needed for focus lost since this clas has no state that depends on it.
+		gFocusMgr.setMouseCapture( this, NULL );
+
+		//localPointToScreen(x, y, &mDragStartScreenX, &mDragStartScreenX);
+		localPointToOtherView(x, y, &mDragStartScreenX, &mDragStartScreenY, getParent()->getParent());
+		mLastMouseScreenX = mDragStartScreenX;
+		mLastMouseScreenY = mDragStartScreenY;
+	}
+
+	return TRUE;
+}
+
+
+BOOL LLResizeBar::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		// Release the mouse
+		gFocusMgr.setMouseCapture( NULL, NULL );
+		handled = TRUE;
+	}
+	else
+	{
+		handled = TRUE;
+	}
+	return handled;
+}
+
+EWidgetType LLResizeBar::getWidgetType() const
+{
+	return WIDGET_TYPE_RESIZE_BAR;
+}
+
+LLString LLResizeBar::getWidgetTag() const
+{
+	return LL_RESIZE_BAR_TAG;
+}
+
+BOOL LLResizeBar::handleHover(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// We only handle the click if the click both started and ended within us
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		//FIXME: this, of course, is fragile
+		LLView* floater_view = getParent()->getParent();
+		S32 floater_view_x;
+		S32 floater_view_y;
+		localPointToOtherView(x, y, &floater_view_x, &floater_view_y, floater_view);
+		
+		S32 delta_x = floater_view_x - mDragStartScreenX;
+		S32 delta_y = floater_view_y - mDragStartScreenY;
+				
+		LLCoordGL mouse_dir;
+		// use hysteresis on mouse motion to preserve user intent when mouse stops moving
+		mouse_dir.mX = (floater_view_x == mLastMouseScreenX) ? mLastMouseDir.mX : floater_view_x - mLastMouseScreenX;
+		mouse_dir.mY = (floater_view_y == mLastMouseScreenY) ? mLastMouseDir.mY : floater_view_y - mLastMouseScreenY;
+		mLastMouseDir = mouse_dir;
+		mLastMouseScreenX = floater_view_x;
+		mLastMouseScreenY = floater_view_y;
+
+		// Make sure the mouse in still over the application.  We don't want to make the parent
+		// so big that we can't see the resize handle any more.
+		LLRect valid_rect = floater_view->getRect();
+		LLView* parentView = getParent();
+		if( valid_rect.localPointInRect( floater_view_x, floater_view_y ) && parentView )
+		{
+			// Resize the parent
+			LLRect parent_rect = parentView->getRect();
+			LLRect scaled_rect = parent_rect;
+				
+			S32 new_width = parent_rect.getWidth();
+			S32 new_height = parent_rect.getHeight();
+
+			switch( mSide )
+			{
+			case LEFT:
+				new_width = parent_rect.getWidth() - delta_x;
+				if( new_width < mMinWidth )
+				{
+					new_width = mMinWidth;
+					delta_x = parent_rect.getWidth() - mMinWidth;
+				}
+				scaled_rect.translate(delta_x, 0);
+				break;
+
+			case TOP:
+				new_height = parent_rect.getHeight() + delta_y;
+				if( new_height < mMinHeight )
+				{
+					new_height = mMinHeight;
+					delta_y = mMinHeight - parent_rect.getHeight();
+				}
+				break;
+			
+			case RIGHT:
+				new_width = parent_rect.getWidth() + delta_x;
+				if( new_width < mMinWidth )
+				{
+					new_width = mMinWidth;
+					delta_x = mMinWidth - parent_rect.getWidth();
+				}
+				break;
+		
+			case BOTTOM:
+				new_height = parent_rect.getHeight() - delta_y;
+				if( new_height < mMinHeight )
+				{
+					new_height = mMinHeight;
+					delta_y = parent_rect.getHeight() - mMinHeight;
+				}
+				scaled_rect.translate(0, delta_y);
+				break;
+			}
+
+			scaled_rect.mTop = scaled_rect.mBottom + new_height;
+			scaled_rect.mRight = scaled_rect.mLeft + new_width;
+			parentView->setRect(scaled_rect);
+
+			S32 snap_delta_x = 0;
+			S32 snap_delta_y = 0;
+
+			LLView* snap_view = NULL;
+
+			switch( mSide )
+			{
+			case LEFT:
+				snap_view = parentView->findSnapEdge(snap_delta_x, mouse_dir, SNAP_LEFT, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_x -= scaled_rect.mLeft;
+				scaled_rect.mLeft += snap_delta_x;
+				break;
+			case TOP:
+				snap_view = parentView->findSnapEdge(snap_delta_y, mouse_dir, SNAP_TOP, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_y -= scaled_rect.mTop;
+				scaled_rect.mTop += snap_delta_y;
+				break;
+			case RIGHT:
+				snap_view = parentView->findSnapEdge(snap_delta_x, mouse_dir, SNAP_RIGHT, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_x -= scaled_rect.mRight;
+				scaled_rect.mRight += snap_delta_x;
+				break;
+			case BOTTOM:
+				snap_view = parentView->findSnapEdge(snap_delta_y, mouse_dir, SNAP_BOTTOM, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_y -= scaled_rect.mBottom;
+				scaled_rect.mBottom += snap_delta_y;
+				break;
+			}
+
+			parentView->snappedTo(snap_view);
+
+			parentView->setRect(parent_rect);
+
+			parentView->reshape(scaled_rect.getWidth(), scaled_rect.getHeight(), FALSE);
+			parentView->translate(scaled_rect.mLeft - parentView->getRect().mLeft, scaled_rect.mBottom - parentView->getRect().mBottom);
+
+			floater_view_x = mDragStartScreenX + delta_x;
+			floater_view_y = mDragStartScreenY + delta_y;
+			mDragStartScreenX = floater_view_x + snap_delta_x;
+			mDragStartScreenY = floater_view_y + snap_delta_y;
+		}
+
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;		
+		handled = TRUE;
+	}
+	else
+	{
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)" << llendl;		
+		handled = TRUE;
+	}
+
+	if( handled )
+	{
+		switch( mSide )
+		{
+		case LEFT:
+		case RIGHT:
+			getWindow()->setCursor(UI_CURSOR_SIZEWE);
+			break;
+
+		case TOP:
+		case BOTTOM:
+			getWindow()->setCursor(UI_CURSOR_SIZENS);
+			break;
+		}
+	}
+
+	return handled;
+}
+
diff --git a/indra/llui/llresizebar.h b/indra/llui/llresizebar.h
new file mode 100644
index 0000000000..c2a07fd3e3
--- /dev/null
+++ b/indra/llui/llresizebar.h
@@ -0,0 +1,47 @@
+/** 
+ * @file llresizebar.h
+ * @brief LLResizeBar base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_RESIZEBAR_H
+#define LL_RESIZEBAR_H
+
+#include "llview.h"
+#include "llcoord.h"
+
+class LLResizeBar : public LLView
+{
+public:
+	enum Side { LEFT, TOP, RIGHT, BOTTOM };
+
+	LLResizeBar(const LLString& name, const LLRect& rect, S32 min_width, S32 min_height, Side side );
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+//	virtual void	draw();  No appearance
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+
+	void			setResizeLimits( S32 min_width, S32 min_height ) { mMinWidth = min_width; mMinHeight = min_height; }
+
+protected:
+	S32				mDragStartScreenX;
+	S32				mDragStartScreenY;
+	S32				mLastMouseScreenX;
+	S32				mLastMouseScreenY;
+	LLCoordGL		mLastMouseDir;
+	S32				mMinWidth;
+	S32				mMinHeight;
+	Side			mSide;
+};
+
+const S32 RESIZE_BAR_HEIGHT = 3;
+
+#endif  // LL_RESIZEBAR_H
+
+
diff --git a/indra/llui/llresizehandle.cpp b/indra/llui/llresizehandle.cpp
new file mode 100644
index 0000000000..77101fa296
--- /dev/null
+++ b/indra/llui/llresizehandle.cpp
@@ -0,0 +1,321 @@
+/** 
+ * @file llresizehandle.cpp
+ * @brief LLResizeHandle base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llresizehandle.h"
+
+#include "llfocusmgr.h"
+#include "llmath.h"
+#include "llui.h"
+#include "llmenugl.h"
+#include "llcontrol.h"
+#include "llfloater.h"
+#include "llwindow.h"
+
+const S32 RESIZE_BORDER_WIDTH = 3;
+
+LLResizeHandle::LLResizeHandle( const LLString& name, const LLRect& rect, S32 min_width, S32 min_height, ECorner corner )
+	:
+	LLView( name, rect, TRUE ),
+	mDragStartScreenX( 0 ),
+	mDragStartScreenY( 0 ),
+	mLastMouseScreenX( 0 ),
+	mLastMouseScreenY( 0 ),
+	mImage( NULL ),
+	mMinWidth( min_width ),
+	mMinHeight( min_height ),
+	mCorner( corner )
+{
+	setSaveToXML(false);
+
+	if( RIGHT_BOTTOM == mCorner)
+	{
+		LLUUID image_id(LLUI::sConfigGroup->getString("UIImgResizeBottomRightUUID"));
+		mImage = LLUI::sImageProvider->getUIImageByID(image_id);
+	}
+
+	switch( mCorner )
+	{
+	case LEFT_TOP:		setFollows( FOLLOWS_LEFT | FOLLOWS_TOP );		break;
+	case LEFT_BOTTOM:	setFollows( FOLLOWS_LEFT | FOLLOWS_BOTTOM );	break;
+	case RIGHT_TOP:		setFollows( FOLLOWS_RIGHT | FOLLOWS_TOP );		break;
+	case RIGHT_BOTTOM:	setFollows( FOLLOWS_RIGHT | FOLLOWS_BOTTOM );	break;
+	}
+}
+
+EWidgetType LLResizeHandle::getWidgetType() const
+{
+	return WIDGET_TYPE_RESIZE_HANDLE;
+}
+
+LLString LLResizeHandle::getWidgetTag() const
+{
+	return LL_RESIZE_HANDLE_TAG;
+}
+
+BOOL LLResizeHandle::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = FALSE;
+	if( getVisible() && pointInHandle(x, y) )
+	{
+		handled = TRUE;
+		if( mEnabled )
+		{
+			// Route future Mouse messages here preemptively.  (Release on mouse up.)
+			// No handler needed for focus lost since this clas has no state that depends on it.
+			gFocusMgr.setMouseCapture( this, NULL );
+
+			localPointToScreen(x, y, &mDragStartScreenX, &mDragStartScreenY);
+			mLastMouseScreenX = mDragStartScreenX;
+			mLastMouseScreenY = mDragStartScreenY;
+		}
+	}
+
+	return handled;
+}
+
+
+BOOL LLResizeHandle::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		// Release the mouse
+		gFocusMgr.setMouseCapture( NULL, NULL );
+		handled = TRUE;
+	}
+	else
+	if( getVisible() && pointInHandle(x, y) )
+	{
+		handled = TRUE;
+	}
+
+	return handled;
+}
+
+
+BOOL LLResizeHandle::handleHover(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// We only handle the click if the click both started and ended within us
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		// Make sure the mouse in still over the application.  We don't want to make the parent
+		// so big that we can't see the resize handle any more.
+	
+		S32 screen_x;
+		S32 screen_y;
+		localPointToScreen(x, y, &screen_x, &screen_y);
+		const LLRect& valid_rect = gFloaterView->getRect(); // Assumes that the parent is a floater.
+		screen_x = llclamp( screen_x, valid_rect.mLeft, valid_rect.mRight );
+		screen_y = llclamp( screen_y, valid_rect.mBottom, valid_rect.mTop );
+
+		LLView* parentView = getParent();
+		if( parentView )
+		{
+			// Resize the parent
+			LLRect parent_rect = parentView->getRect();
+			LLRect scaled_rect = parent_rect;
+			S32 delta_x = screen_x - mDragStartScreenX;
+			S32 delta_y = screen_y - mDragStartScreenY;
+			LLCoordGL mouse_dir;
+			// use hysteresis on mouse motion to preserve user intent when mouse stops moving
+			mouse_dir.mX = (screen_x == mLastMouseScreenX) ? mLastMouseDir.mX : screen_x - mLastMouseScreenX;
+			mouse_dir.mY = (screen_y == mLastMouseScreenY) ? mLastMouseDir.mY : screen_y - mLastMouseScreenY;
+			mLastMouseScreenX = screen_x;
+			mLastMouseScreenY = screen_y;
+			mLastMouseDir = mouse_dir;
+
+			S32 x_multiple = 1;
+			S32 y_multiple = 1;
+			switch( mCorner )
+			{
+			case LEFT_TOP:
+				x_multiple = -1; 
+				y_multiple =  1;	
+				break;
+			case LEFT_BOTTOM:	
+				x_multiple = -1; 
+				y_multiple = -1;	
+				break;
+			case RIGHT_TOP:		
+				x_multiple =  1; 
+				y_multiple =  1;	
+				break;
+			case RIGHT_BOTTOM:	
+				x_multiple =  1; 
+				y_multiple = -1;	
+				break;
+			}
+
+			S32 new_width = parent_rect.getWidth() + x_multiple * delta_x;
+			if( new_width < mMinWidth )
+			{
+				new_width = mMinWidth;
+				delta_x = x_multiple * (mMinWidth - parent_rect.getWidth());
+			}
+
+			S32 new_height = parent_rect.getHeight() + y_multiple * delta_y;
+			if( new_height < mMinHeight )
+			{
+				new_height = mMinHeight;
+				delta_y = y_multiple * (mMinHeight - parent_rect.getHeight());
+			}
+
+			switch( mCorner )
+			{
+			case LEFT_TOP:		
+				scaled_rect.translate(delta_x, 0);			
+				break;
+			case LEFT_BOTTOM:	
+				scaled_rect.translate(delta_x, delta_y);	
+				break;
+			case RIGHT_TOP:		
+				break;
+			case RIGHT_BOTTOM:	
+				scaled_rect.translate(0, delta_y);			
+				break;
+			}
+
+			// temporarily set new parent rect
+			scaled_rect.mRight = scaled_rect.mLeft + new_width;
+			scaled_rect.mTop = scaled_rect.mBottom + new_height;
+			parentView->setRect(scaled_rect);
+
+			S32 snap_delta_x = 0;
+			S32 snap_delta_y = 0;
+
+			LLView* snap_view = NULL;
+			LLView* test_view = NULL;
+
+			// now do snapping
+			switch(mCorner)
+			{
+			case LEFT_TOP:		
+				snap_view = parentView->findSnapEdge(snap_delta_x, mouse_dir, SNAP_LEFT, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_x -= scaled_rect.mLeft;
+				test_view = parentView->findSnapEdge(snap_delta_y, mouse_dir, SNAP_TOP, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_y -= scaled_rect.mTop;
+				if (!snap_view)
+				{
+					snap_view = test_view;
+				}
+				scaled_rect.mLeft += snap_delta_x;
+				scaled_rect.mTop += snap_delta_y;
+				break;
+			case LEFT_BOTTOM:	
+				snap_view = parentView->findSnapEdge(snap_delta_x, mouse_dir, SNAP_LEFT, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_x -= scaled_rect.mLeft;
+				test_view = parentView->findSnapEdge(snap_delta_y, mouse_dir, SNAP_BOTTOM, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_y -= scaled_rect.mBottom;
+				if (!snap_view)
+				{
+					snap_view = test_view;
+				}
+				scaled_rect.mLeft += snap_delta_x;
+				scaled_rect.mBottom += snap_delta_y;
+				break;
+			case RIGHT_TOP:		
+				snap_view = parentView->findSnapEdge(snap_delta_x, mouse_dir, SNAP_RIGHT, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_x -= scaled_rect.mRight;
+				test_view = parentView->findSnapEdge(snap_delta_y, mouse_dir, SNAP_TOP, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_y -= scaled_rect.mTop;
+				if (!snap_view)
+				{
+					snap_view = test_view;
+				}
+				scaled_rect.mRight += snap_delta_x;
+				scaled_rect.mTop += snap_delta_y;
+				break;
+			case RIGHT_BOTTOM:	
+				snap_view = parentView->findSnapEdge(snap_delta_x, mouse_dir, SNAP_RIGHT, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_x -= scaled_rect.mRight;
+				test_view = parentView->findSnapEdge(snap_delta_y, mouse_dir, SNAP_BOTTOM, SNAP_PARENT_AND_SIBLINGS, LLUI::sConfigGroup->getS32("SnapMargin"));
+				snap_delta_y -= scaled_rect.mBottom;
+				if (!snap_view)
+				{
+					snap_view = test_view;
+				}
+				scaled_rect.mRight += snap_delta_x;
+				scaled_rect.mBottom += snap_delta_y;
+				break;
+			}
+
+			parentView->snappedTo(snap_view);
+
+			// reset parent rect
+			parentView->setRect(parent_rect);
+
+			// translate and scale to new shape
+			parentView->reshape(scaled_rect.getWidth(), scaled_rect.getHeight(), FALSE);
+			parentView->translate(scaled_rect.mLeft - parentView->getRect().mLeft, scaled_rect.mBottom - parentView->getRect().mBottom);
+			
+			screen_x = mDragStartScreenX + delta_x + snap_delta_x;
+			screen_y = mDragStartScreenY + delta_y + snap_delta_y;
+			mDragStartScreenX = screen_x;
+			mDragStartScreenY = screen_y;
+		}
+
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active) " << llendl;		
+		handled = TRUE;
+	}
+	else
+	if( getVisible() && pointInHandle( x, y ) )
+	{
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive) " << llendl;		
+		handled = TRUE;
+	}
+
+	if( handled )
+	{
+		switch( mCorner )
+		{
+		case RIGHT_BOTTOM:
+		case LEFT_TOP:	
+			getWindow()->setCursor(UI_CURSOR_SIZENWSE); 
+			break;
+		case LEFT_BOTTOM:
+		case RIGHT_TOP:	
+			getWindow()->setCursor(UI_CURSOR_SIZENESW); 
+			break;
+		}
+	}
+
+	return handled;
+}
+
+// assumes GL state is set for 2D
+void LLResizeHandle::draw()
+{
+	if( mImage.notNull() && getVisible() && (RIGHT_BOTTOM == mCorner) ) 
+	{
+		gl_draw_image( 0, 0, mImage );
+	}
+}
+
+
+BOOL LLResizeHandle::pointInHandle( S32 x, S32 y )
+{
+	if( pointInView(x, y) )
+	{
+		const S32 TOP_BORDER = (mRect.getHeight() - RESIZE_BORDER_WIDTH);
+		const S32 RIGHT_BORDER = (mRect.getWidth() - RESIZE_BORDER_WIDTH);
+
+		switch( mCorner )
+		{
+		case LEFT_TOP:		return (x <= RESIZE_BORDER_WIDTH) || (y >= TOP_BORDER);
+		case LEFT_BOTTOM:	return (x <= RESIZE_BORDER_WIDTH) || (y <= RESIZE_BORDER_WIDTH);
+		case RIGHT_TOP:		return (x >= RIGHT_BORDER) || (y >= TOP_BORDER);
+		case RIGHT_BOTTOM:	return TRUE;
+		}
+	}
+	return FALSE;
+}
diff --git a/indra/llui/llresizehandle.h b/indra/llui/llresizehandle.h
new file mode 100644
index 0000000000..1350d1af20
--- /dev/null
+++ b/indra/llui/llresizehandle.h
@@ -0,0 +1,56 @@
+/** 
+ * @file llresizehandle.h
+ * @brief LLResizeHandle base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_RESIZEHANDLE_H
+#define LL_RESIZEHANDLE_H
+
+#include "stdtypes.h"
+#include "llview.h"
+#include "llimagegl.h"
+#include "llcoord.h"
+
+
+class LLResizeHandle : public LLView
+{
+public:
+	enum ECorner { LEFT_TOP, LEFT_BOTTOM, RIGHT_TOP, RIGHT_BOTTOM };
+
+	
+	LLResizeHandle(const LLString& name, const LLRect& rect, S32 min_width, S32 min_height, ECorner corner = RIGHT_BOTTOM );
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual void	draw();
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+
+	void			setResizeLimits( S32 min_width, S32 min_height ) { mMinWidth = min_width; mMinHeight = min_height; }
+
+protected:
+	BOOL			pointInHandle( S32 x, S32 y );
+
+protected:
+	S32				mDragStartScreenX;
+	S32				mDragStartScreenY;
+	S32				mLastMouseScreenX;
+	S32				mLastMouseScreenY;
+	LLCoordGL		mLastMouseDir;
+	LLPointer<LLImageGL>	mImage;
+	S32				mMinWidth;
+	S32				mMinHeight;
+	ECorner			mCorner;
+};
+
+const S32 RESIZE_HANDLE_HEIGHT = 16;
+const S32 RESIZE_HANDLE_WIDTH = 16;
+
+#endif  // LL_RESIZEHANDLE_H
+
+
diff --git a/indra/llui/llresmgr.cpp b/indra/llui/llresmgr.cpp
new file mode 100644
index 0000000000..67137d8bbb
--- /dev/null
+++ b/indra/llui/llresmgr.cpp
@@ -0,0 +1,447 @@
+/** 
+ * @file llresmgr.cpp
+ * @brief Localized resource manager
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// NOTE: this is a MINIMAL implementation.  The interface will remain, but the implementation will
+// (when the time is right) become dynamic and probably use external files.
+
+#include "linden_common.h"
+
+#include "llresmgr.h"
+#include "llfontgl.h"
+#include "llerror.h"
+#include "llstring.h"
+
+// Global singleton
+LLResMgr* gResMgr = NULL;
+
+LLResMgr::LLResMgr()
+{
+	U32 i;
+
+	// Init values for each locale.
+	// Note: This is only the most bare-bones version.  In the future, load these dynamically, on demand.
+
+	//////////////////////////////////////////////////////////////////////////////
+	// USA
+	// USA Fonts
+	for( i=0; i<LLFONT_COUNT; i++ )
+	{
+		mUSAFonts[i] = NULL;
+	}
+	mUSAFonts[ LLFONT_OCRA ]			= LLFontGL::sMonospace;
+	mUSAFonts[ LLFONT_SANSSERIF ]		= LLFontGL::sSansSerif;
+	mUSAFonts[ LLFONT_SANSSERIF_SMALL ]	= LLFontGL::sSansSerifSmall;
+	mUSAFonts[ LLFONT_SANSSERIF_BIG ]	= LLFontGL::sSansSerifBig;
+	mUSAFonts[ LLFONT_SMALL ]			= LLFontGL::sMonospace;
+/*
+	// USA Strings
+	for( i=0; i<LLSTR_COUNT; i++ )
+	{
+		mUSAStrings[i] = "";
+	}
+	mUSAStrings[ LLSTR_HELLO ]			= "hello";
+	mUSAStrings[ LLSTR_GOODBYE ]		= "goodbye";
+	mUSAStrings[ LLSTR_CHAT_LABEL ]		= "Chat";
+	mUSAStrings[ LLSTR_STATUS_LABEL ]	= "Properties";
+	mUSAStrings[ LLSTR_X ]				= "X";
+	mUSAStrings[ LLSTR_Y ]				= "Y";
+	mUSAStrings[ LLSTR_Z ]				= "Z";
+	mUSAStrings[ LLSTR_POSITION ]		= "Position (meters)";
+	mUSAStrings[ LLSTR_SCALE ]			= "Size (meters)";
+	mUSAStrings[ LLSTR_ROTATION ]		= "Rotation (degrees)";
+	mUSAStrings[ LLSTR_HAS_PHYSICS ]	= "Has Physics";
+	mUSAStrings[ LLSTR_SCRIPT ]			= "Script";
+	mUSAStrings[ LLSTR_HELP ]			= "Help";
+	mUSAStrings[ LLSTR_REMOVE ]			= "Remove";
+	mUSAStrings[ LLSTR_CLEAR ]			= "Clear";
+	mUSAStrings[ LLSTR_APPLY ]			= "Apply";
+	mUSAStrings[ LLSTR_CANCEL ]			= "Cancel";
+	mUSAStrings[ LLSTR_MATERIAL ]		= "Material";
+	mUSAStrings[ LLSTR_FACE ]			= "Face";
+	mUSAStrings[ LLSTR_TEXTURE ]		= "Texture";
+	mUSAStrings[ LLSTR_TEXTURE_SIZE ]	= "Repeats per Face";
+	mUSAStrings[ LLSTR_TEXTURE_OFFSET ]	= "Offset";
+	mUSAStrings[ LLSTR_TEXTURE_ROTATION ]	= "Rotation (degrees)";
+	mUSAStrings[ LLSTR_U ]				= "U";
+	mUSAStrings[ LLSTR_V ]				= "V";
+	mUSAStrings[ LLSTR_OWNERSHIP ]		= "Ownership";
+	mUSAStrings[ LLSTR_PUBLIC ]			= "Public";
+	mUSAStrings[ LLSTR_PRIVATE ]		= "Private";
+	mUSAStrings[ LLSTR_REVERT ]			= "Revert";
+	mUSAStrings[ LLSTR_INSERT_SAMPLE ]	= "Insert Sample";
+	mUSAStrings[ LLSTR_SET_TEXTURE ]	= "Set Texture";
+	mUSAStrings[ LLSTR_EDIT_SCRIPT ]	= "Edit Script...";
+	mUSAStrings[ LLSTR_MOUSELOOK_INSTRUCTIONS ] = "Press ESC to leave Mouselook.";
+	mUSAStrings[ LLSTR_EDIT_FACE_INSTRUCTIONS ] = "Click on face to select part.  Click and hold on a picture to look more like that.  Press ESC to leave Face Edit Mode.";
+	mUSAStrings[ LLSTR_CLOSE ]			= "Close";
+	mUSAStrings[ LLSTR_MOVE ]			= "Move";
+	mUSAStrings[ LLSTR_ROTATE ]			= "Rotate";
+	mUSAStrings[ LLSTR_RESIZE ]			= "Resize";
+	mUSAStrings[ LLSTR_PLACE_BOX ]		= "Place Box";
+	mUSAStrings[ LLSTR_PLACE_PRISM ]	= "Place Prism";
+	mUSAStrings[ LLSTR_PLACE_PYRAMID ]	= "Place Pyramid";
+	mUSAStrings[ LLSTR_PLACE_TETRAHEDRON ]	= "Place Tetrahedron";
+	mUSAStrings[ LLSTR_PLACE_CYLINDER ]	= "Place Cylinder";
+	mUSAStrings[ LLSTR_PLACE_HALF_CYLINDER ] = "Place Half-Cylinder";
+	mUSAStrings[ LLSTR_PLACE_CONE ]		= "Place Cone";
+	mUSAStrings[ LLSTR_PLACE_HALF_CONE ] = "Place Half-Cone";
+	mUSAStrings[ LLSTR_PLACE_SPHERE ]	= "Place Sphere";
+	mUSAStrings[ LLSTR_PLACE_HALF_SPHERE ] = "Place Half-Sphere";
+	mUSAStrings[ LLSTR_PLACE_BIRD ]		= "Place Bird";
+	mUSAStrings[ LLSTR_PLACE_SNAKE ]	= "Place Silly Snake";
+	mUSAStrings[ LLSTR_PLACE_ROCK ]		= "Place Rock";
+	mUSAStrings[ LLSTR_PLACE_TREE ]		= "Place Tree";
+	mUSAStrings[ LLSTR_PLACE_GRASS ]	= "Place Grass";
+	mUSAStrings[ LLSTR_MODIFY_LAND ]	= "Modify Land";
+*/
+	//////////////////////////////////////////////////////////////////////////////
+	// UK
+	// The Brits are a lot like us Americans, so initially assume we're the same and only code the exceptions.
+
+	// UK Fonts
+	for( i=0; i<LLFONT_COUNT; i++ )
+	{
+		mUKFonts[i] = mUSAFonts[i];
+	}
+/*
+	// UK Strings
+	for( i=0; i<LLSTR_COUNT; i++ )
+	{
+		mUKStrings[i] = mUSAStrings[i];
+	}
+	mUKStrings[ LLSTR_HELLO ]			= "hullo";
+	mUKStrings[ LLSTR_GOODBYE ]			= "cheerio";
+*/
+	//////////////////////////////////////////////////////////////////////////////
+	// Set default
+	setLocale( LLLOCALE_USA );
+
+}
+
+
+void LLResMgr::setLocale( LLLOCALE_ID locale_id )
+{
+	mLocale = locale_id;
+
+	//RN: for now, use normal 'C' locale for everything but specific UI input/output routines
+	switch( locale_id )
+	{
+	case LLLOCALE_USA: 
+//#if LL_WINDOWS
+//		// Windows doesn't use ISO country codes.
+//		llinfos << "Setting locale to " << setlocale( LC_ALL, "english-usa" ) << llendl;
+//#else	
+//		// posix version should work everywhere else.
+//		llinfos << "Setting locale to " << setlocale( LC_ALL, "en_US" ) << llendl;
+//#endif
+
+//		mStrings	= mUSAStrings;
+		mFonts		= mUSAFonts;
+		break;
+	case LLLOCALE_UK:
+//#if LL_WINDOWS
+//		// Windows doesn't use ISO country codes.
+//		llinfos << "Setting locale to " << setlocale( LC_ALL, "english-uk" ) << llendl;
+//#else
+//		// posix version should work everywhere else.
+//		llinfos << "Setting locale to " << setlocale( LC_ALL, "en_GB" ) << llendl;
+//#endif
+
+//		mStrings	= mUKStrings;
+		mFonts		= mUKFonts;
+		break;
+	default:
+		llassert(0);
+		setLocale(LLLOCALE_USA);
+		break;
+	}
+}
+
+char LLResMgr::getDecimalPoint() const					
+{ 
+	char decimal = localeconv()->decimal_point[0]; 
+
+#if LL_DARWIN
+	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
+	if(decimal == 0)
+	{
+		decimal = '.';
+	}
+#endif
+
+	return decimal;
+}
+
+char LLResMgr::getThousandsSeparator() const			
+{
+	char separator = localeconv()->thousands_sep[0]; 
+
+#if LL_DARWIN
+	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
+	if(separator == 0)
+	{
+		separator = ',';
+	}
+#endif
+
+	return separator;
+}
+
+char LLResMgr::getMonetaryDecimalPoint() const
+{
+	char decimal = localeconv()->mon_decimal_point[0]; 
+
+#if LL_DARWIN
+	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
+	if(decimal == 0)
+	{
+		decimal = '.';
+	}
+#endif
+
+	return decimal;
+}
+
+char LLResMgr::getMonetaryThousandsSeparator() const	
+{
+	char separator = localeconv()->mon_thousands_sep[0]; 
+
+#if LL_DARWIN
+	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
+	if(separator == 0)
+	{
+		separator = ',';
+	}
+#endif
+
+	return separator;
+}
+
+
+// Sets output to a string of integers with monetary separators inserted according to the locale.
+void LLResMgr::getMonetaryString( LLString& output, S32 input ) const
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+	struct lconv *conv = localeconv();
+	
+#if LL_DARWIN
+	// On the Mac, locale support is broken before 10.4, which causes things to go all pear-shaped.
+	// Fake up a conv structure with some reasonable values for the fields this function uses.
+	struct lconv fakeconv;
+	if(conv->negative_sign[0] == 0)	// Real locales all seem to have something here...
+	{
+		fakeconv = *conv;	// start with what's there.
+		switch(mLocale)
+		{
+			default:  			// Unknown -- use the US defaults.
+			case LLLOCALE_USA: 
+			case LLLOCALE_UK:	// UK ends up being the same as US for the items used here.
+				fakeconv.negative_sign = "-";
+				fakeconv.mon_grouping = "\x03\x03\x00";	// commas every 3 digits
+				fakeconv.n_sign_posn = 1; // negative sign before the string
+			break;
+		}
+		conv = &fakeconv;
+	}
+#endif
+
+	char* negative_sign = conv->negative_sign;
+	char separator = getMonetaryThousandsSeparator();
+	char* grouping = conv->mon_grouping;
+	
+	// Note on mon_grouping:
+	// Specifies a string that defines the size of each group of digits in formatted monetary quantities.
+	// The operand for the mon_grouping keyword consists of a sequence of semicolon-separated integers. 
+	// Each integer specifies the number of digits in a group. The initial integer defines the size of
+	// the group immediately to the left of the decimal delimiter. The following integers define succeeding
+	// groups to the left of the previous group. If the last integer is not -1, the size of the previous
+	// group (if any) is repeatedly used for the remainder of the digits. If the last integer is -1, no
+	// further grouping is performed. 
+
+
+	// Note: we assume here that the currency symbol goes on the left. (Hey, it's Lindens! We can just decide.)
+	BOOL negative = (input < 0 );
+	BOOL negative_before = negative && (conv->n_sign_posn != 2);
+	BOOL negative_after = negative && (conv->n_sign_posn == 2);
+
+	LLString digits = llformat("%u", abs(input));
+	if( !grouping || !grouping[0] )
+	{
+		output.assign("L$");
+		if( negative_before )
+		{
+			output.append( negative_sign );
+		}
+		output.append( digits );
+		if( negative_after )
+		{
+			output.append( negative_sign );
+		}
+		return;
+	}
+
+	S32 groupings[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+	S32 cur_group;
+	for( cur_group = 0; grouping[ cur_group ]; cur_group++ )
+	{
+		if( grouping[ cur_group ] != ';' )
+		{
+			groupings[cur_group] = grouping[ cur_group ];
+		}
+		cur_group++;
+
+		if( groupings[cur_group] < 0 )
+		{
+			break;
+		}
+	}
+	S32 group_count = cur_group;
+
+	char reversed_output[20] = "";
+	char forward_output[20] = "";
+	S32 output_pos = 0;
+	
+	cur_group = 0;
+	S32 pos = digits.size()-1;
+	S32 count_within_group = 0;
+	while( (pos >= 0) && (groupings[cur_group] >= 0) )
+	{
+		count_within_group++;
+		if( count_within_group > groupings[cur_group] )
+		{
+			count_within_group = 1;
+			reversed_output[ output_pos++ ] = separator;
+
+			if( (cur_group + 1) >= group_count )
+			{
+				break;
+			}
+			else
+			if( groupings[cur_group + 1] > 0 )
+			{
+				cur_group++;
+			}
+		}
+		reversed_output[ output_pos++ ] = digits[pos--];
+	}
+
+	while( pos >= 0 )
+	{
+		reversed_output[ output_pos++ ] = digits[pos--];
+	}
+
+
+	reversed_output[ output_pos ] = '\0';
+	forward_output[ output_pos ] = '\0';
+
+	for( S32 i = 0; i < output_pos; i++ )
+	{
+		forward_output[ output_pos - 1 - i ] = reversed_output[ i ];
+	}
+
+	output.assign("L$");
+	if( negative_before )
+	{
+		output.append( negative_sign );
+	}
+	output.append( forward_output );
+	if( negative_after )
+	{
+		output.append( negative_sign );
+	}
+}
+
+void LLResMgr::getIntegerString( LLString& output, S32 input ) const
+{
+	S32 fraction = 0;
+	LLString fraction_string;
+	S32 remaining_count = input;
+	while(remaining_count > 0)
+	{
+		fraction = (remaining_count) % 1000;
+		
+		if (!output.empty())
+		{
+			if (fraction == remaining_count)
+			{
+				fraction_string = llformat("%d%c", fraction, getThousandsSeparator());
+			}
+			else
+			{
+				fraction_string = llformat("%3.3d%c", fraction, getThousandsSeparator());
+			}
+			output = fraction_string + output;
+		}
+		else
+		{
+			if (fraction == remaining_count)
+			{
+				fraction_string = llformat("%d", fraction);
+			}
+			else
+			{
+				fraction_string = llformat("%3.3d", fraction);
+			}
+			output = fraction_string;
+		}
+		remaining_count /= 1000;
+	}
+}
+
+const LLString LLFONT_ID_NAMES[] =
+{
+	LLString("OCRA"),
+	LLString("SANSSERIF"),
+	LLString("SANSSERIF_SMALL"),
+	LLString("SANSSERIF_BIG"),
+	LLString("SMALL"),
+};
+
+const LLFontGL* LLResMgr::getRes( LLString font_id ) const
+{
+	for (S32 i=0; i<LLFONT_COUNT; ++i)
+	{
+		if (LLFONT_ID_NAMES[i] == font_id)
+		{
+			return getRes((LLFONT_ID)i);
+		}
+	}
+	return NULL;
+}
+
+#if LL_WINDOWS
+const LLString LLLocale::USER_LOCALE("English_United States.1252");// = LLString::null;
+const LLString LLLocale::SYSTEM_LOCALE("English_United States.1252");
+#elif LL_DARWIN
+const LLString LLLocale::USER_LOCALE("en_US.iso8859-1");// = LLString::null;
+const LLString LLLocale::SYSTEM_LOCALE("en_US.iso8859-1");
+#else // LL_LINUX likes this
+const LLString LLLocale::USER_LOCALE("en_US.utf8");// = LLString::null;
+const LLString LLLocale::SYSTEM_LOCALE("en_US.utf8");
+#endif
+
+
+LLLocale::LLLocale(const LLString& locale_string)
+{
+	mPrevLocaleString = setlocale( LC_ALL, NULL );
+	char* new_locale_string = setlocale( LC_ALL, locale_string.c_str());
+	if ( new_locale_string == NULL)
+	{
+		llwarns << "Failed to set locale " << locale_string << llendl;
+		setlocale(LC_ALL, SYSTEM_LOCALE.c_str());
+	}
+	//else
+	//{
+	//	llinfos << "Set locale to " << new_locale_string << llendl;
+	//}
+}
+
+LLLocale::~LLLocale() 
+{
+	setlocale( LC_ALL, mPrevLocaleString.c_str() );
+}
diff --git a/indra/llui/llresmgr.h b/indra/llui/llresmgr.h
new file mode 100644
index 0000000000..b79fa2021f
--- /dev/null
+++ b/indra/llui/llresmgr.h
@@ -0,0 +1,147 @@
+/** 
+ * @file llresmgr.h
+ * @brief Localized resource manager
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// NOTE: this is a MINIMAL implementation.  The interface will remain, but the implementation will
+// (when the time is right) become dynamic and probably use external files.
+
+#ifndef LL_LLRESMGR_H
+#define LL_LLRESMGR_H
+
+#include "locale.h"
+#include "stdtypes.h"
+#include "llstring.h"
+
+enum LLLOCALE_ID
+{
+	LLLOCALE_USA,
+	LLLOCALE_UK,
+	LLLOCALE_COUNT	// Number of values in this enum.  Keep at end.
+};
+
+/*
+enum LLSTR_ID 
+{
+	LLSTR_HELLO,
+	LLSTR_GOODBYE,
+	LLSTR_CHAT_LABEL,
+	LLSTR_STATUS_LABEL,
+	LLSTR_X,
+	LLSTR_Y,
+	LLSTR_Z,
+	LLSTR_POSITION,
+	LLSTR_SCALE,
+	LLSTR_ROTATION,
+	LLSTR_HAS_PHYSICS,
+	LLSTR_SCRIPT,
+	LLSTR_HELP,
+	LLSTR_REMOVE,
+	LLSTR_CLEAR,
+	LLSTR_APPLY,
+	LLSTR_CANCEL,
+	LLSTR_MATERIAL,
+	LLSTR_FACE,
+	LLSTR_TEXTURE,
+	LLSTR_TEXTURE_SIZE,
+	LLSTR_TEXTURE_OFFSET,
+	LLSTR_TEXTURE_ROTATION,
+	LLSTR_U,
+	LLSTR_V,
+	LLSTR_OWNERSHIP,
+	LLSTR_PUBLIC,
+	LLSTR_PRIVATE,
+	LLSTR_REVERT,
+	LLSTR_INSERT_SAMPLE,
+	LLSTR_SET_TEXTURE,
+	LLSTR_EDIT_SCRIPT,
+	LLSTR_MOUSELOOK_INSTRUCTIONS,
+	LLSTR_EDIT_FACE_INSTRUCTIONS,
+	LLSTR_CLOSE,
+	LLSTR_MOVE,
+	LLSTR_ROTATE,
+	LLSTR_RESIZE,
+	LLSTR_PLACE_BOX,
+	LLSTR_PLACE_PRISM,
+	LLSTR_PLACE_PYRAMID,
+	LLSTR_PLACE_TETRAHEDRON,
+	LLSTR_PLACE_CYLINDER,
+	LLSTR_PLACE_HALF_CYLINDER,
+	LLSTR_PLACE_CONE,
+	LLSTR_PLACE_HALF_CONE,
+	LLSTR_PLACE_SPHERE,
+	LLSTR_PLACE_HALF_SPHERE,
+	LLSTR_PLACE_BIRD,
+	LLSTR_PLACE_SNAKE,
+	LLSTR_PLACE_ROCK,
+	LLSTR_PLACE_TREE,
+	LLSTR_PLACE_GRASS,
+	LLSTR_MODIFY_LAND,
+	LLSTR_COUNT		// Number of values in this enum.  Keep at end.
+};
+*/
+
+enum LLFONT_ID
+{
+	LLFONT_OCRA,
+	LLFONT_SANSSERIF,
+	LLFONT_SANSSERIF_SMALL,
+	LLFONT_SANSSERIF_BIG,
+	LLFONT_SMALL,
+	LLFONT_COUNT	// Number of values in this enum.  Keep at end.
+};
+
+class LLFontGL;
+
+class LLResMgr
+{
+public:
+	LLResMgr();
+
+	void				setLocale( LLLOCALE_ID locale_id );
+	LLLOCALE_ID			getLocale() const						{ return mLocale; }
+
+	char				getDecimalPoint() const;
+	char				getThousandsSeparator() const;
+
+	char				getMonetaryDecimalPoint() const;	
+	char				getMonetaryThousandsSeparator() const;
+	void				getMonetaryString( LLString& output, S32 input ) const;
+	void				getIntegerString( LLString& output, S32 input ) const;
+
+//	const char*			getRes( LLSTR_ID string_id ) const		{ return mStrings[ string_id ]; }
+	const LLFontGL*		getRes( LLFONT_ID font_id ) const		{ return mFonts[ font_id ]; }
+	const LLFontGL*		getRes( LLString font_id ) const;
+
+private:
+	LLLOCALE_ID			mLocale;
+//	const char**		mStrings;
+	const LLFontGL**	mFonts;
+
+//	const char*			mUSAStrings[LLSTR_COUNT];
+	const LLFontGL*		mUSAFonts[LLFONT_COUNT];
+
+//	const char*			mUKStrings[LLSTR_COUNT];
+	const LLFontGL*		mUKFonts[LLFONT_COUNT];
+};
+
+class LLLocale
+{
+public:
+	LLLocale(const LLString& locale_string);
+	virtual ~LLLocale();
+
+public:
+	static const LLString USER_LOCALE;
+	static const LLString SYSTEM_LOCALE;
+
+protected:
+	LLString	mPrevLocaleString;
+};
+
+extern LLResMgr* gResMgr;
+
+#endif  // LL_RESMGR_
diff --git a/indra/llui/llscrollbar.cpp b/indra/llui/llscrollbar.cpp
new file mode 100644
index 0000000000..4a5ae1dadf
--- /dev/null
+++ b/indra/llui/llscrollbar.cpp
@@ -0,0 +1,618 @@
+/** 
+ * @file llscrollbar.cpp
+ * @brief Scrollbar UI widget
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llscrollbar.h"
+
+#include "llmath.h"
+#include "lltimer.h"
+#include "v3color.h"
+
+#include "llbutton.h"
+#include "llcriticaldamp.h"
+#include "llkeyboard.h"
+#include "llui.h"
+//#include "llviewerimagelist.h"
+#include "llfocusmgr.h"
+#include "llwindow.h"
+#include "llglheaders.h"
+#include "llcontrol.h"
+
+LLScrollbar::LLScrollbar(
+		const LLString& name, LLRect rect,
+		LLScrollbar::ORIENTATION orientation,
+		S32 doc_size, S32 doc_pos, S32 page_size,
+		void (*change_callback)( S32 new_pos, LLScrollbar* self, void* userdata ),
+		void* callback_user_data,
+		S32 step_size)
+:		LLUICtrl( name, rect, TRUE, NULL, NULL ),
+
+		mChangeCallback( change_callback ),
+		mCallbackUserData( callback_user_data ),
+		mOrientation( orientation ),
+		mDocSize( doc_size ),
+		mDocPos( doc_pos ),
+		mPageSize( page_size ),
+		mStepSize( step_size ),
+		mDocChanged(FALSE),
+		mDragStartX( 0 ),
+		mDragStartY( 0 ),
+		mHoverGlowStrength(0.15f),
+		mCurGlowStrength(0.f),
+		mTrackColor( LLUI::sColorsGroup->getColor("ScrollbarTrackColor") ),
+		mThumbColor ( LLUI::sColorsGroup->getColor("ScrollbarThumbColor") ),
+		mHighlightColor ( LLUI::sColorsGroup->getColor("DefaultHighlightLight") ),
+		mShadowColor ( LLUI::sColorsGroup->getColor("DefaultShadowLight") ),
+		mOnScrollEndCallback( NULL ),
+		mOnScrollEndData( NULL )
+{
+	//llassert( 0 <= mDocSize );
+	//llassert( 0 <= mDocPos && mDocPos <= mDocSize );
+	
+	setTabStop(FALSE);
+	updateThumbRect();
+	
+	// Page up and page down buttons
+	LLRect line_up_rect;
+	LLString line_up_img;
+	LLString line_up_selected_img;
+	LLString line_down_img;
+	LLString line_down_selected_img;
+
+	LLRect line_down_rect;
+
+	if( LLScrollbar::VERTICAL == mOrientation )
+	{
+		line_up_rect.setLeftTopAndSize( 0, mRect.getHeight(), SCROLLBAR_SIZE, SCROLLBAR_SIZE );
+		line_up_img="UIImgBtnScrollUpOutUUID";
+		line_up_selected_img="UIImgBtnScrollUpInUUID";
+
+		line_down_rect.setOriginAndSize( 0, 0, SCROLLBAR_SIZE, SCROLLBAR_SIZE );
+		line_down_img="UIImgBtnScrollDownOutUUID";
+		line_down_selected_img="UIImgBtnScrollDownInUUID";
+	}
+	else
+	{
+		// Horizontal
+		line_up_rect.setOriginAndSize( 0, 0, SCROLLBAR_SIZE, SCROLLBAR_SIZE );
+		line_up_img="UIImgBtnScrollLeftOutUUID";
+		line_up_selected_img="UIImgBtnScrollLeftInUUID";
+
+		line_down_rect.setOriginAndSize( mRect.getWidth() - SCROLLBAR_SIZE, 0, SCROLLBAR_SIZE, SCROLLBAR_SIZE );
+		line_down_img="UIImgBtnScrollRightOutUUID";
+		line_down_selected_img="UIImgBtnScrollRightInUUID";
+	}
+
+	LLButton* line_up_btn = new LLButton(
+		"Line Up", line_up_rect,
+		line_up_img, line_up_selected_img, "",
+		&LLScrollbar::onLineUpBtnPressed, this, LLFontGL::sSansSerif );
+	if( LLScrollbar::VERTICAL == mOrientation )
+	{
+		line_up_btn->setFollowsRight();
+		line_up_btn->setFollowsTop();
+	}
+	else
+	{
+		// horizontal
+		line_up_btn->setFollowsLeft();
+		line_up_btn->setFollowsBottom();
+	}
+	line_up_btn->setHeldDownCallback( &LLScrollbar::onLineUpBtnPressed );
+	line_up_btn->setTabStop(FALSE);
+	addChild(line_up_btn);
+
+	LLButton* line_down_btn = new LLButton(
+		"Line Down", line_down_rect,
+		line_down_img, line_down_selected_img, "",
+		&LLScrollbar::onLineDownBtnPressed, this, LLFontGL::sSansSerif );
+	line_down_btn->setFollowsRight();
+	line_down_btn->setFollowsBottom();
+	line_down_btn->setHeldDownCallback( &LLScrollbar::onLineDownBtnPressed );
+	line_down_btn->setTabStop(FALSE);
+	addChild(line_down_btn);
+}
+
+
+LLScrollbar::~LLScrollbar()
+{
+	// Children buttons killed by parent class
+}
+
+void LLScrollbar::setDocParams( S32 size, S32 pos )
+{
+	mDocSize = size;
+	mDocPos = llclamp( pos, 0, getDocPosMax() );
+	mDocChanged = TRUE;
+
+	updateThumbRect();
+}
+
+void LLScrollbar::setDocPos(S32 pos)
+{
+	mDocPos = llclamp( pos, 0, getDocPosMax() );
+	mDocChanged = TRUE;
+
+	updateThumbRect();
+}
+
+void LLScrollbar::setDocSize(S32 size)
+{
+	mDocSize = size;
+	mDocPos = llclamp( mDocPos, 0, getDocPosMax() );
+	mDocChanged = TRUE;
+
+	updateThumbRect();
+}
+
+void LLScrollbar::setPageSize( S32 page_size )
+{
+	mPageSize = page_size;
+	mDocPos = llclamp( mDocPos, 0, getDocPosMax() );
+	mDocChanged = TRUE;
+
+	updateThumbRect();
+}
+
+void LLScrollbar::updateThumbRect()
+{
+//	llassert( 0 <= mDocSize );
+//	llassert( 0 <= mDocPos && mDocPos <= getDocPosMax() );
+	
+	const S32 THUMB_MIN_LENGTH = 16;
+
+	S32 window_length = (mOrientation == LLScrollbar::HORIZONTAL) ? mRect.getWidth() : mRect.getHeight();
+	S32 thumb_bg_length = window_length - 2 * SCROLLBAR_SIZE;
+	S32 visible_lines = llmin( mDocSize, mPageSize );
+	S32 thumb_length = mDocSize ? llmax( visible_lines * thumb_bg_length / mDocSize, THUMB_MIN_LENGTH ) : thumb_bg_length;
+
+	S32 variable_lines = mDocSize - visible_lines;
+
+	if( mOrientation == LLScrollbar::VERTICAL )
+	{ 
+		S32 thumb_start_max = thumb_bg_length + SCROLLBAR_SIZE;
+		S32 thumb_start_min = SCROLLBAR_SIZE + THUMB_MIN_LENGTH;
+		S32 thumb_start = variable_lines ? llclamp( thumb_start_max - (mDocPos * (thumb_bg_length - thumb_length)) / variable_lines, thumb_start_min, thumb_start_max ) : thumb_start_max;
+
+		mThumbRect.mLeft =  0;
+		mThumbRect.mTop = thumb_start;
+		mThumbRect.mRight = SCROLLBAR_SIZE;
+		mThumbRect.mBottom = thumb_start - thumb_length;
+	}
+	else
+	{
+		// Horizontal
+		S32 thumb_start_max = thumb_bg_length + SCROLLBAR_SIZE - thumb_length;
+		S32 thumb_start_min = SCROLLBAR_SIZE;
+		S32 thumb_start = variable_lines ? llclamp( thumb_start_min + (mDocPos * (thumb_bg_length - thumb_length)) / variable_lines, thumb_start_min, thumb_start_max ) : thumb_start_min;
+	
+		mThumbRect.mLeft = thumb_start;
+		mThumbRect.mTop = SCROLLBAR_SIZE;
+		mThumbRect.mRight = thumb_start + thumb_length;
+		mThumbRect.mBottom = 0;
+	}
+	
+	if (mOnScrollEndCallback && mOnScrollEndData && (mDocPos == getDocPosMax()))
+	{
+		mOnScrollEndCallback(mOnScrollEndData);
+	}
+}
+
+BOOL LLScrollbar::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	// Check children first
+	BOOL handled_by_child = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
+	if( !handled_by_child )
+	{
+		if( mThumbRect.pointInRect(x,y) )
+		{
+			// Start dragging the thumb
+			// No handler needed for focus lost since this clas has no state that depends on it.
+			gFocusMgr.setMouseCapture( this, NULL );  
+			mDragStartX = x;
+			mDragStartY = y;
+			mOrigRect.mTop = mThumbRect.mTop;
+			mOrigRect.mBottom = mThumbRect.mBottom;
+			mOrigRect.mLeft = mThumbRect.mLeft;
+			mOrigRect.mRight = mThumbRect.mRight;
+			mLastDelta = 0;
+		}
+		else
+		{
+			if( 
+				( (LLScrollbar::VERTICAL == mOrientation) && (mThumbRect.mTop < y) ) ||
+				( (LLScrollbar::HORIZONTAL == mOrientation) && (x < mThumbRect.mLeft) )
+			)
+			{
+				// Page up
+				pageUp(0);
+			}
+			else
+			if(
+				( (LLScrollbar::VERTICAL == mOrientation) && (y < mThumbRect.mBottom) ) ||
+				( (LLScrollbar::HORIZONTAL == mOrientation) && (mThumbRect.mRight < x) )
+			)
+			{
+				// Page down
+				pageDown(0);
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+
+BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
+{
+	// Note: we don't bother sending the event to the children (the arrow buttons)
+	// because they'll capture the mouse whenever they need hover events.
+	
+	BOOL handled = FALSE;
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		S32 height = mRect.getHeight();
+		S32 width = mRect.getWidth();
+
+		if( VERTICAL == mOrientation )
+		{
+//			S32 old_pos = mThumbRect.mTop;
+
+			S32 delta_pixels = y - mDragStartY;
+			if( mOrigRect.mBottom + delta_pixels < SCROLLBAR_SIZE )
+			{
+				delta_pixels = SCROLLBAR_SIZE - mOrigRect.mBottom - 1;
+			}
+			else
+			if( mOrigRect.mTop + delta_pixels > height - SCROLLBAR_SIZE )
+			{
+				delta_pixels = height - SCROLLBAR_SIZE - mOrigRect.mTop + 1;
+			}
+
+			mThumbRect.mTop = mOrigRect.mTop + delta_pixels;
+			mThumbRect.mBottom = mOrigRect.mBottom + delta_pixels;
+
+			S32 thumb_length = mThumbRect.getHeight();
+			S32 thumb_track_length = height - 2 * SCROLLBAR_SIZE;
+
+
+			if( delta_pixels != mLastDelta || mDocChanged)
+			{	
+				// Note: delta_pixels increases as you go up.  mDocPos increases down (line 0 is at the top of the page).
+				S32 usable_track_length = thumb_track_length - thumb_length;
+				if( 0 < usable_track_length )
+				{
+					S32 variable_lines = getDocPosMax();
+					S32 pos = mThumbRect.mTop;
+					F32 ratio = F32(pos - SCROLLBAR_SIZE - thumb_length) / usable_track_length;	
+	
+					S32 new_pos = llclamp( S32(variable_lines - ratio * variable_lines + 0.5f), 0, variable_lines );
+					// Note: we do not call updateThumbRect() here.  Instead we let the thumb and the document go slightly
+					// out of sync (less than a line's worth) to make the thumb feel responsive.
+					changeLine( new_pos - mDocPos, FALSE );
+				}
+			}
+
+			mLastDelta = delta_pixels;
+		
+		}
+		else
+		{
+			// Horizontal
+//			S32 old_pos = mThumbRect.mLeft;
+
+			S32 delta_pixels = x - mDragStartX;
+
+			if( mOrigRect.mLeft + delta_pixels < SCROLLBAR_SIZE )
+			{
+				delta_pixels = SCROLLBAR_SIZE - mOrigRect.mLeft - 1;
+			}
+			else
+			if( mOrigRect.mRight + delta_pixels > width - SCROLLBAR_SIZE )
+			{
+				delta_pixels = width - SCROLLBAR_SIZE - mOrigRect.mRight + 1;
+			}
+
+			mThumbRect.mLeft = mOrigRect.mLeft + delta_pixels;
+			mThumbRect.mRight = mOrigRect.mRight + delta_pixels;
+			
+			S32 thumb_length = mThumbRect.getWidth();
+			S32 thumb_track_length = width - 2 * SCROLLBAR_SIZE;
+
+			if( delta_pixels != mLastDelta || mDocChanged)
+			{	
+				// Note: delta_pixels increases as you go up.  mDocPos increases down (line 0 is at the top of the page).
+				S32 usable_track_length = thumb_track_length - thumb_length;
+				if( 0 < usable_track_length )
+				{
+					S32 variable_lines = getDocPosMax();
+					S32 pos = mThumbRect.mLeft;
+					F32 ratio = F32(pos - SCROLLBAR_SIZE) / usable_track_length;	
+	
+					S32 new_pos = llclamp( S32(ratio * variable_lines + 0.5f), 0, variable_lines);
+	
+					// Note: we do not call updateThumbRect() here.  Instead we let the thumb and the document go slightly
+					// out of sync (less than a line's worth) to make the thumb feel responsive.
+					changeLine( new_pos - mDocPos, FALSE );
+				}
+			}
+
+			mLastDelta = delta_pixels;
+		}
+
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;		
+		handled = TRUE;
+	}
+	else
+	{
+		handled = childrenHandleMouseUp( x, y, mask ) != NULL;
+	}
+
+	// Opaque
+	if( !handled )
+	{
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)"  << llendl;		
+		handled = TRUE;
+	}
+
+	mDocChanged = FALSE;
+	return handled;
+}
+
+
+BOOL LLScrollbar::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	BOOL handled = FALSE;
+	if( getVisible() && mRect.localPointInRect( x, y ) )
+	{
+		if( getEnabled() )
+		{
+			changeLine( clicks * mStepSize, TRUE );
+		}
+		handled = TRUE;
+	}
+
+	return handled;
+}
+
+BOOL LLScrollbar::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
+									EDragAndDropType cargo_type, void *carge_data, EAcceptance *accept, LLString &tooltip_msg)
+{
+	if (!drop)
+	{
+		//TODO: refactor this
+		S32 variable_lines = getDocPosMax();
+		S32 pos = (VERTICAL == mOrientation) ? y : x;
+		S32 thumb_length = (VERTICAL == mOrientation) ? mThumbRect.getHeight() : mThumbRect.getWidth();
+		S32 thumb_track_length = (VERTICAL == mOrientation) ? (mRect.getHeight() - 2 * SCROLLBAR_SIZE) : (mRect.getWidth() - 2 * SCROLLBAR_SIZE);
+		S32 usable_track_length = thumb_track_length - thumb_length;
+		F32 ratio = (VERTICAL == mOrientation) ? F32(pos - SCROLLBAR_SIZE - thumb_length) / usable_track_length
+			: F32(pos - SCROLLBAR_SIZE) / usable_track_length;	
+		S32 new_pos = (VERTICAL == mOrientation) ? llclamp( S32(variable_lines - ratio * variable_lines + 0.5f), 0, variable_lines )
+			: llclamp( S32(ratio * variable_lines + 0.5f), 0, variable_lines );
+		changeLine( new_pos - mDocPos, TRUE );
+	}
+	return TRUE;
+}
+
+BOOL LLScrollbar::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = FALSE;
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		gFocusMgr.setMouseCapture( NULL, NULL );
+		handled = TRUE;
+	}
+	else
+	{
+		// Opaque, so don't just check children
+		handled = LLView::handleMouseUp( x, y, mask );
+	}
+
+	return handled;
+}
+
+void LLScrollbar::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	LLView::reshape( width, height, called_from_parent );
+	updateThumbRect();
+}
+
+
+void LLScrollbar::draw()
+{
+	if( getVisible() )
+	{
+		S32 local_mouse_x;
+		S32 local_mouse_y;
+		LLCoordWindow cursor_pos_window;
+		getWindow()->getCursorPosition(&cursor_pos_window);
+		LLCoordGL cursor_pos_gl;
+		getWindow()->convertCoords(cursor_pos_window, &cursor_pos_gl);
+
+		screenPointToLocal(cursor_pos_gl.mX, cursor_pos_gl.mY, &local_mouse_x, &local_mouse_y);
+		BOOL other_captor = gFocusMgr.getMouseCapture() && gFocusMgr.getMouseCapture() != this;
+		BOOL hovered = mEnabled && !other_captor && (gFocusMgr.getMouseCapture() == this || mThumbRect.pointInRect(local_mouse_x, local_mouse_y));
+		if (hovered)
+		{
+			mCurGlowStrength = lerp(mCurGlowStrength, mHoverGlowStrength, LLCriticalDamp::getInterpolant(0.05f));
+		}
+		else
+		{
+			mCurGlowStrength = lerp(mCurGlowStrength, 0.f, LLCriticalDamp::getInterpolant(0.05f));
+		}
+
+
+		// Draw background and thumb.
+		LLUUID rounded_rect_image_id;
+		rounded_rect_image_id.set(LLUI::sAssetsGroup->getString("rounded_square.tga"));
+		LLImageGL* rounded_rect_imagep = LLUI::sImageProvider->getUIImageByID(rounded_rect_image_id);
+
+		if (!rounded_rect_imagep)
+		{
+			gl_rect_2d(mOrientation == HORIZONTAL ? SCROLLBAR_SIZE : 0, 
+			mOrientation == VERTICAL ? mRect.getHeight() - 2 * SCROLLBAR_SIZE : mRect.getHeight(),
+			mOrientation == HORIZONTAL ? mRect.getWidth() - 2 * SCROLLBAR_SIZE : mRect.getWidth(), 
+			mOrientation == VERTICAL ? SCROLLBAR_SIZE : 0, mTrackColor, TRUE);
+
+			gl_rect_2d(mThumbRect, mThumbColor, TRUE);
+
+		}
+		else
+		{
+			// Background
+			gl_draw_scaled_image_with_border(mOrientation == HORIZONTAL ? SCROLLBAR_SIZE : 0, 
+				mOrientation == VERTICAL ? SCROLLBAR_SIZE : 0,
+				16,
+				16,
+				mOrientation == HORIZONTAL ? mRect.getWidth() - 2 * SCROLLBAR_SIZE : mRect.getWidth(), 
+				mOrientation == VERTICAL ? mRect.getHeight() - 2 * SCROLLBAR_SIZE : mRect.getHeight(),
+				rounded_rect_imagep, 
+				mTrackColor,
+				TRUE);
+
+			// Thumb
+			LLRect outline_rect = mThumbRect;
+			outline_rect.stretch(2);
+
+			if (gFocusMgr.getKeyboardFocus() == this)
+			{
+				gl_draw_scaled_image_with_border(outline_rect.mLeft, outline_rect.mBottom, 16, 16, outline_rect.getWidth(), outline_rect.getHeight(), 
+							rounded_rect_imagep, gFocusMgr.getFocusColor() );
+			}
+
+			gl_draw_scaled_image_with_border(mThumbRect.mLeft, mThumbRect.mBottom, 16, 16, mThumbRect.getWidth(), mThumbRect.getHeight(), 
+							rounded_rect_imagep, mThumbColor );
+			if (mCurGlowStrength > 0.01f)
+			{
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+				gl_draw_scaled_image_with_border(mThumbRect.mLeft, mThumbRect.mBottom, 16, 16, mThumbRect.getWidth(), mThumbRect.getHeight(), 
+							rounded_rect_imagep, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength), TRUE);
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			}
+		}
+
+		BOOL was_scrolled_to_bottom = (getDocPos() == getDocPosMax());
+		if (mOnScrollEndCallback && was_scrolled_to_bottom)
+		{
+			mOnScrollEndCallback(mOnScrollEndData);
+		}
+		// Draw children
+		LLView::draw();
+	}
+}
+
+void LLScrollbar::changeLine( S32 delta, BOOL update_thumb )
+{
+	S32 new_pos = llclamp( mDocPos + delta, 0, getDocPosMax() );
+	if( new_pos != mDocPos )
+	{
+		mDocPos = new_pos;
+	}
+
+	if( mChangeCallback )
+	{
+		mChangeCallback( mDocPos, this, mCallbackUserData );
+	}
+
+	if( update_thumb )
+	{
+		updateThumbRect();
+	}
+}
+
+void LLScrollbar::setValue(const LLSD& value) 
+{ 
+	setDocPos((S32) value.asInteger());
+}
+
+EWidgetType LLScrollbar::getWidgetType() const
+{
+	return WIDGET_TYPE_SCROLLBAR;
+}
+
+LLString LLScrollbar::getWidgetTag() const
+{
+	return LL_SCROLLBAR_TAG;
+}
+
+BOOL LLScrollbar::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+
+	if( getVisible() && mEnabled && !called_from_parent )
+	{
+		switch( key )
+		{
+		case KEY_HOME:
+			changeLine( -mDocPos, TRUE );
+			handled = TRUE;
+			break;
+		
+		case KEY_END:
+			changeLine( getDocPosMax() - mDocPos, TRUE );
+			handled = TRUE;
+			break;
+		
+		case KEY_DOWN:
+			changeLine( mStepSize, TRUE );
+			handled = TRUE;
+			break;
+		
+		case KEY_UP:
+			changeLine( - mStepSize, TRUE );
+			handled = TRUE;
+			break;
+
+		case KEY_PAGE_DOWN:
+			pageDown(1);
+			break;
+
+		case KEY_PAGE_UP:
+			pageUp(1);
+			break;
+		}
+	}
+
+	return handled;
+}
+
+void LLScrollbar::pageUp(S32 overlap)
+{
+	if (mDocSize > mPageSize)
+	{
+		changeLine( -(mPageSize - overlap), TRUE );
+	}
+}
+
+void LLScrollbar::pageDown(S32 overlap)
+{
+	if (mDocSize > mPageSize)
+	{
+		changeLine( mPageSize - overlap, TRUE );
+	}
+}
+
+// static
+void LLScrollbar::onLineUpBtnPressed( void* userdata )
+{
+	LLScrollbar* self = (LLScrollbar*) userdata;
+
+	self->changeLine( - self->mStepSize, TRUE );
+}
+
+// static
+void LLScrollbar::onLineDownBtnPressed( void* userdata )
+{
+	LLScrollbar* self = (LLScrollbar*) userdata;
+	self->changeLine( self->mStepSize, TRUE );
+}
+
diff --git a/indra/llui/llscrollbar.h b/indra/llui/llscrollbar.h
new file mode 100644
index 0000000000..f479707499
--- /dev/null
+++ b/indra/llui/llscrollbar.h
@@ -0,0 +1,123 @@
+/** 
+ * @file llscrollbar.h
+ * @brief Scrollbar UI widget
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_SCROLLBAR_H
+#define LL_SCROLLBAR_H
+
+#include "stdtypes.h"
+#include "lluictrl.h"
+#include "v4color.h"
+
+//
+// Constants
+//
+const S32 SCROLLBAR_SIZE = 16;
+
+
+//
+// Classes
+//
+class LLScrollbar
+: public LLUICtrl
+{
+public:
+	enum ORIENTATION { HORIZONTAL, VERTICAL };
+
+	LLScrollbar(const LLString& name, LLRect rect,
+		ORIENTATION orientation,
+		S32 doc_size, S32 doc_pos, S32 page_size,
+		void(*change_callback)( S32 new_pos, LLScrollbar* self, void* userdata ),
+		void* callback_user_data = NULL,
+		S32 step_size = 1);
+
+	virtual ~LLScrollbar();
+
+	virtual void setValue(const LLSD& value);
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	// Overrides from LLView
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	virtual BOOL	handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, 
+		EDragAndDropType cargo_type, void *carge_data, EAcceptance *accept, LLString &tooltip_msg);
+
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+	virtual void	draw();
+
+	void				setDocParams( S32 size, S32 pos );
+
+	// How long the "document" is.
+	void				setDocSize( S32 size );
+	S32					getDocSize()			{ return mDocSize; }
+
+	// How many "lines" the "document" has scrolled.
+	// 0 <= DocPos <= DocSize - DocVisibile
+	void				setDocPos( S32 pos );
+	S32					getDocPos()				{ return mDocPos; }
+
+	// How many "lines" of the "document" is can appear on a page.
+	void				setPageSize( S32 page_size );
+	S32					getPageSize()			{ return mPageSize; }
+	
+	// The farthest the document can be scrolled (top of the last page).
+	S32					getDocPosMax()			{ return llmax( 0, mDocSize - mPageSize); }
+
+	void				pageUp(S32 overlap);
+	void				pageDown(S32 overlap);
+
+	static void			onLineUpBtnPressed(void* userdata);
+	static void			onLineDownBtnPressed(void* userdata);
+
+	void setTrackColor( const LLColor4& color ) { mTrackColor = color; }
+	void setThumbColor( const LLColor4& color ) { mThumbColor = color; }
+	void setHighlightColor( const LLColor4& color ) { mHighlightColor = color; }
+	void setShadowColor( const LLColor4& color ) { mShadowColor = color; }
+
+	void setOnScrollEndCallback(void (*callback)(void*), void* userdata) { mOnScrollEndCallback = callback; mOnScrollEndData = userdata;}
+protected:
+	void				updateThumbRect();
+	void				changeLine(S32 delta, BOOL update_thumb );
+
+protected:
+	void				(*mChangeCallback)( S32 new_pos, LLScrollbar* self, void* userdata );
+	void*				mCallbackUserData;
+
+	ORIENTATION			mOrientation;	
+	S32					mDocSize;		// Size of the document that the scrollbar is modeling.  Units depend on the user.  0 <= mDocSize.
+	S32					mDocPos;		// Position within the doc that the scrollbar is modeling, in "lines" (user size)
+	S32					mPageSize;		// Maximum number of lines that can be seen at one time.
+	S32					mStepSize;
+	BOOL				mDocChanged;
+
+	LLRect				mThumbRect;
+	S32					mDragStartX;
+	S32					mDragStartY;
+	F32					mHoverGlowStrength;
+	F32					mCurGlowStrength;
+
+	LLRect				mOrigRect;
+	S32					mLastDelta;
+
+	LLColor4			mTrackColor;
+	LLColor4			mThumbColor;
+	LLColor4			mFocusColor;
+	LLColor4			mHighlightColor;
+	LLColor4			mShadowColor;
+
+	void			(*mOnScrollEndCallback)(void*);
+	void			*mOnScrollEndData;
+};
+
+
+
+#endif  // LL_SCROLLBAR_H
diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp
new file mode 100644
index 0000000000..15bb8e3f24
--- /dev/null
+++ b/indra/llui/llscrollcontainer.cpp
@@ -0,0 +1,772 @@
+/** 
+ * @file llscrollcontainer.cpp
+ * @brief LLScrollableContainerView base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+//*****************************************************************************
+//
+// A view meant to encapsulate a clipped region which is
+// scrollable. It automatically takes care of pixel perfect scrolling
+// and cliipping, as well as turning the scrollbars on or off based on
+// the width and height of the view you're scrolling.
+//
+//*****************************************************************************
+
+#include "linden_common.h"
+
+#include "llgl.h"
+
+#include "llscrollcontainer.h"
+#include "llscrollbar.h"
+#include "llui.h"
+#include "llkeyboard.h"
+#include "llviewborder.h"
+#include "llfocusmgr.h"
+#include "llframetimer.h"
+#include "lluictrlfactory.h"
+#include "llfontgl.h"
+
+#include "llglheaders.h"
+
+///----------------------------------------------------------------------------
+/// Local function declarations, constants, enums, and typedefs
+///----------------------------------------------------------------------------
+
+static const S32 HORIZONTAL_MULTIPLE = 8;
+static const S32 VERTICAL_MULTIPLE = 16;
+static const F32 MIN_AUTO_SCROLL_RATE = 120.f;
+static const F32 MAX_AUTO_SCROLL_RATE = 500.f;
+static const F32 AUTO_SCROLL_RATE_ACCEL = 120.f;
+
+///----------------------------------------------------------------------------
+/// Class LLScrollableContainerView
+///----------------------------------------------------------------------------
+
+// Default constructor
+LLScrollableContainerView::LLScrollableContainerView( const LLString& name,
+													  const LLRect& rect,
+													  LLView* scrolled_view,
+													  BOOL is_opaque,
+													  const LLColor4& bg_color ) :
+	LLUICtrl( name, rect, FALSE, NULL, NULL ),
+	mScrolledView( scrolled_view ),
+	mIsOpaque( is_opaque ),
+	mBackgroundColor( bg_color ),
+	mReserveScrollCorner( FALSE ),
+	mAutoScrolling( FALSE ),
+	mAutoScrollRate( 0.f )
+{
+	if( mScrolledView )
+	{
+		addChild( mScrolledView );
+	}
+
+	init();
+}
+
+// LLUICtrl constructor
+LLScrollableContainerView::LLScrollableContainerView( const LLString& name, const LLRect& rect,
+							   LLUICtrl* scrolled_ctrl, BOOL is_opaque,
+							   const LLColor4& bg_color) :
+	LLUICtrl( name, rect, FALSE, NULL, NULL ),
+	mScrolledView( scrolled_ctrl ),
+	mIsOpaque( is_opaque ),
+	mBackgroundColor( bg_color ),
+	mReserveScrollCorner( FALSE ),
+	mAutoScrolling( FALSE ),
+	mAutoScrollRate( 0.f )
+{
+	if( scrolled_ctrl )
+	{
+		addChild( scrolled_ctrl );
+	}
+
+	init();
+}
+
+void LLScrollableContainerView::init()
+{
+	LLRect border_rect( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+	mBorder = new LLViewBorder( "scroll border", border_rect, LLViewBorder::BEVEL_IN );
+	addChild( mBorder );
+
+	mInnerRect.set( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+	mInnerRect.stretch( -mBorder->getBorderWidth()  );
+
+	LLRect vertical_scroll_rect = mInnerRect;
+	vertical_scroll_rect.mLeft = vertical_scroll_rect.mRight - SCROLLBAR_SIZE;
+	mScrollbar[VERTICAL] = new LLScrollbar( "scrollable vertical",
+											vertical_scroll_rect,
+											LLScrollbar::VERTICAL,
+											mInnerRect.getHeight(), 
+											0,
+											mInnerRect.getHeight(),
+											NULL, this,
+											VERTICAL_MULTIPLE);
+	addChild( mScrollbar[VERTICAL] );
+	mScrollbar[VERTICAL]->setVisible( FALSE );
+	mScrollbar[VERTICAL]->setFollowsRight();
+	mScrollbar[VERTICAL]->setFollowsTop();
+	mScrollbar[VERTICAL]->setFollowsBottom();
+	
+	LLRect horizontal_scroll_rect = mInnerRect;
+	horizontal_scroll_rect.mTop = horizontal_scroll_rect.mBottom + SCROLLBAR_SIZE;
+	mScrollbar[HORIZONTAL] = new LLScrollbar( "scrollable horizontal",
+											  horizontal_scroll_rect,
+											  LLScrollbar::HORIZONTAL,
+											  mInnerRect.getWidth(),
+											  0,
+											  mInnerRect.getWidth(),
+											  NULL, this,
+											  HORIZONTAL_MULTIPLE);
+	addChild( mScrollbar[HORIZONTAL] );
+	mScrollbar[HORIZONTAL]->setVisible( FALSE );
+	mScrollbar[HORIZONTAL]->setFollowsLeft();
+	mScrollbar[HORIZONTAL]->setFollowsRight();
+
+	setTabStop(FALSE);
+}
+
+// Destroys the object
+LLScrollableContainerView::~LLScrollableContainerView( void )
+{
+	// mScrolledView and mScrollbar are child views, so the LLView
+	// destructor takes care of memory deallocation.
+	for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
+	{
+		mScrollbar[i] = NULL;
+	}
+	mScrolledView = NULL;
+}
+
+/*
+// scrollbar handlers
+void LLScrollableContainerView::horizontalChange( S32 new_pos,
+												  LLScrollbar* sb,
+												  void* user_data )
+{
+	LLScrollableContainerView* cont = reinterpret_cast<LLScrollableContainerView*>(user_data);
+//	cont->scrollHorizontal( new_pos );
+}
+
+
+void LLScrollableContainerView::verticalChange( S32 new_pos, LLScrollbar* sb,
+												void* user_data )
+{
+	LLScrollableContainerView* cont = reinterpret_cast<LLScrollableContainerView*>(user_data);
+//	cont->scrollVertical( new_pos );
+}
+*/
+
+// internal scrollbar handlers
+// virtual
+void LLScrollableContainerView::scrollHorizontal( S32 new_pos )
+{
+	//llinfos << "LLScrollableContainerView::scrollHorizontal()" << llendl;
+	if( mScrolledView )
+	{
+		LLRect doc_rect = mScrolledView->getRect();
+		S32 old_pos = -(doc_rect.mLeft - mInnerRect.mLeft);
+		mScrolledView->translate( -(new_pos - old_pos), 0 );
+	}
+}
+
+// virtual
+void LLScrollableContainerView::scrollVertical( S32 new_pos )
+{
+	// llinfos << "LLScrollableContainerView::scrollVertical() " << new_pos << llendl;
+	if( mScrolledView )
+	{
+		LLRect doc_rect = mScrolledView->getRect();
+		S32 old_pos = doc_rect.mTop - mInnerRect.mTop;
+		mScrolledView->translate( 0, new_pos - old_pos );
+	}
+}
+
+// LLView functionality
+void LLScrollableContainerView::reshape(S32 width, S32 height,
+										BOOL called_from_parent)
+{
+	LLUICtrl::reshape( width, height, called_from_parent );
+
+	mInnerRect.set( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+	mInnerRect.stretch( -mBorder->getBorderWidth() );
+
+	if (mScrolledView)
+	{
+		const LLRect& scrolled_rect = mScrolledView->getRect();
+
+		S32 visible_width = 0;
+		S32 visible_height = 0;
+		BOOL show_v_scrollbar = FALSE;
+		BOOL show_h_scrollbar = FALSE;
+		calcVisibleSize( scrolled_rect, &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+
+		mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
+		mScrollbar[VERTICAL]->setPageSize( visible_height );
+
+		mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
+		mScrollbar[HORIZONTAL]->setPageSize( visible_width );
+	}
+}
+
+BOOL LLScrollableContainerView::handleKey( KEY key, MASK mask, BOOL called_from_parent )
+{
+	if( getVisible() && mEnabled )
+	{
+		if( called_from_parent )
+		{
+			// Downward traversal
+
+			// Don't pass keys to scrollbars on downward.
+
+			// Handle 'child' view.
+			if( mScrolledView && mScrolledView->handleKey(key, mask, TRUE) )
+			{
+				return TRUE;
+			}
+		}
+		else
+		{
+			// Upward traversal
+			
+			for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
+			{
+				// Note: the scrollbar _is_ actually being called from it's parent.  Here
+				// we're delgating LLScrollableContainerView's upward traversal to the scrollbars
+				if( mScrollbar[i]->handleKey(key, mask, TRUE) )
+				{
+					return TRUE;
+				}
+			}
+
+			if (getParent()) 
+			{
+				return getParent()->handleKey( key, mask, FALSE );
+			}
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL LLScrollableContainerView::handleScrollWheel( S32 x, S32 y, S32 clicks )
+{
+	if( mEnabled )
+	{
+		for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
+		{
+			// Note: tries vertical and then horizontal
+
+			// Pretend the mouse is over the scrollbar
+			if( mScrollbar[i]->handleScrollWheel( 0, 0, clicks ) )
+			{
+				return TRUE;
+			}
+		}
+	}
+
+	// Opaque
+	return TRUE;
+}
+
+BOOL LLScrollableContainerView::handleDragAndDrop(S32 x, S32 y, MASK mask,
+												  BOOL drop,
+												  EDragAndDropType cargo_type,
+												  void* cargo_data,
+												  EAcceptance* accept,
+												  LLString& tooltip_msg)
+{
+	// Scroll folder view if needed.  Never accepts a drag or drop.
+	*accept = ACCEPT_NO;
+	BOOL handled = FALSE;
+	if( mScrollbar[HORIZONTAL]->getVisible() || mScrollbar[VERTICAL]->getVisible() )
+	{
+		const S32 AUTOSCROLL_SIZE = 10;
+		S32 auto_scroll_speed = llround(mAutoScrollRate * LLFrameTimer::getFrameDeltaTimeF32());
+		
+		LLRect inner_rect_local( 0, mInnerRect.getHeight(), mInnerRect.getWidth(), 0 );
+		if(	mScrollbar[HORIZONTAL]->getVisible() )
+		{
+			inner_rect_local.mBottom += SCROLLBAR_SIZE;
+		}
+		if(	mScrollbar[VERTICAL]->getVisible() )
+		{
+			inner_rect_local.mRight -= SCROLLBAR_SIZE;
+		}
+
+		if(	mScrollbar[HORIZONTAL]->getVisible() )
+		{
+			LLRect left_scroll_rect = inner_rect_local;
+			left_scroll_rect.mRight = AUTOSCROLL_SIZE;
+			if( left_scroll_rect.pointInRect( x, y ) && (mScrollbar[HORIZONTAL]->getDocPos() > 0) )
+			{
+				mScrollbar[HORIZONTAL]->setDocPos( mScrollbar[HORIZONTAL]->getDocPos() - auto_scroll_speed );
+				mAutoScrolling = TRUE;
+				handled = TRUE;
+			}
+
+			LLRect right_scroll_rect = inner_rect_local;
+			right_scroll_rect.mLeft = inner_rect_local.mRight - AUTOSCROLL_SIZE;
+			if( right_scroll_rect.pointInRect( x, y ) && (mScrollbar[HORIZONTAL]->getDocPos() < mScrollbar[HORIZONTAL]->getDocPosMax()) )
+			{
+				mScrollbar[HORIZONTAL]->setDocPos( mScrollbar[HORIZONTAL]->getDocPos() + auto_scroll_speed );
+				mAutoScrolling = TRUE;
+				handled = TRUE;
+			}
+		}
+		if(	mScrollbar[VERTICAL]->getVisible() )
+		{
+			LLRect bottom_scroll_rect = inner_rect_local;
+			bottom_scroll_rect.mTop = AUTOSCROLL_SIZE + bottom_scroll_rect.mBottom;
+			if( bottom_scroll_rect.pointInRect( x, y ) && (mScrollbar[VERTICAL]->getDocPos() < mScrollbar[VERTICAL]->getDocPosMax()) )
+			{
+				mScrollbar[VERTICAL]->setDocPos( mScrollbar[VERTICAL]->getDocPos() + auto_scroll_speed );
+				mAutoScrolling = TRUE;
+				handled = TRUE;
+			}
+
+			LLRect top_scroll_rect = inner_rect_local;
+			top_scroll_rect.mBottom = inner_rect_local.mTop - AUTOSCROLL_SIZE;
+			if( top_scroll_rect.pointInRect( x, y ) && (mScrollbar[VERTICAL]->getDocPos() > 0) )
+			{
+				mScrollbar[VERTICAL]->setDocPos( mScrollbar[VERTICAL]->getDocPos() - auto_scroll_speed );
+				mAutoScrolling = TRUE;
+				handled = TRUE;
+			}
+		}
+	}
+
+	if( !handled )
+	{
+		handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
+											cargo_data, accept, tooltip_msg) != NULL;
+	}
+
+	return TRUE;
+}
+
+
+BOOL LLScrollableContainerView::handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect)
+{
+	if( getVisible() && pointInView(x,y) )
+	{
+		S32 local_x, local_y;
+		for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
+		{
+			local_x = x - mScrollbar[i]->getRect().mLeft;
+			local_y = y - mScrollbar[i]->getRect().mBottom;
+			if( mScrollbar[i]->handleToolTip(local_x, local_y, msg, sticky_rect) )
+			{
+				return TRUE;
+			}
+		}
+		// Handle 'child' view.
+		if( mScrolledView )
+		{
+			local_x = x - mScrolledView->getRect().mLeft;
+			local_y = y - mScrolledView->getRect().mBottom;
+			if( mScrolledView->handleToolTip(local_x, local_y, msg, sticky_rect) )
+			{
+				return TRUE;
+			}
+		}
+
+		// Opaque
+		return TRUE;
+	}
+	return FALSE;
+}
+
+void LLScrollableContainerView::calcVisibleSize( S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar )
+{
+	const LLRect& rect = mScrolledView->getRect();
+	calcVisibleSize(rect, visible_width, visible_height, show_h_scrollbar, show_v_scrollbar);
+}
+
+void LLScrollableContainerView::calcVisibleSize( const LLRect& doc_rect, S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar )
+{
+	S32 doc_width = doc_rect.getWidth();
+	S32 doc_height = doc_rect.getHeight();
+
+	*visible_width = mRect.getWidth() - 2 * mBorder->getBorderWidth();
+	*visible_height = mRect.getHeight() - 2 * mBorder->getBorderWidth();
+	
+	*show_v_scrollbar = FALSE;
+	if( *visible_height < doc_height )
+	{
+		*show_v_scrollbar = TRUE;
+		*visible_width -= SCROLLBAR_SIZE;
+	}
+
+	*show_h_scrollbar = FALSE;
+	if( *visible_width < doc_width )
+	{
+		*show_h_scrollbar = TRUE;
+		*visible_height -= SCROLLBAR_SIZE;
+
+		// Must retest now that visible_height has changed
+		if( !*show_v_scrollbar && (*visible_height < doc_height) )
+		{
+			*show_v_scrollbar = TRUE;
+			*visible_width -= SCROLLBAR_SIZE;
+		}
+	}
+}
+
+void LLScrollableContainerView::draw()
+{
+	if (mAutoScrolling)
+	{
+		// add acceleration to autoscroll
+		mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), MAX_AUTO_SCROLL_RATE);
+	}
+	else
+	{
+		// reset to minimum
+		mAutoScrollRate = MIN_AUTO_SCROLL_RATE;
+	}
+	// clear this flag to be set on next call to handleDragAndDrop
+	mAutoScrolling = FALSE;
+
+	if( getVisible() )
+	{
+		// auto-focus when scrollbar active
+		// this allows us to capture user intent (i.e. stop automatically scrolling the view/etc)
+		if (!gFocusMgr.childHasKeyboardFocus(this) && 
+			(gFocusMgr.getMouseCapture() == mScrollbar[VERTICAL] || gFocusMgr.getMouseCapture() == mScrollbar[HORIZONTAL]))
+		{
+			focusFirstItem();
+		}
+
+		// Draw background
+		if( mIsOpaque )
+		{
+			LLGLSNoTexture no_texture;
+			glColor4fv( mBackgroundColor.mV );
+			gl_rect_2d( mInnerRect );
+		}
+		
+		// Draw mScrolledViews and update scroll bars.
+		// get a scissor region ready, and draw the scrolling view. The
+		// scissor region ensures that we don't draw outside of the bounds
+		// of the rectangle.
+		if( mScrolledView )
+		{
+			updateScroll();
+
+			// Draw the scrolled area.
+			{
+				S32 visible_width = 0;
+				S32 visible_height = 0;
+				BOOL show_v_scrollbar = FALSE;
+				BOOL show_h_scrollbar = FALSE;
+				calcVisibleSize( mScrolledView->getRect(), &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+
+				LLGLEnable scissor_test(GL_SCISSOR_TEST);
+				LLUI::setScissorRegionLocal(LLRect(mInnerRect.mLeft, 
+						mInnerRect.mBottom + (show_h_scrollbar ? SCROLLBAR_SIZE : 0) + visible_height,
+						visible_width,
+						mInnerRect.mBottom + (show_h_scrollbar ? SCROLLBAR_SIZE : 0)
+						));
+				drawChild(mScrolledView);
+			}
+		}
+
+		// Highlight border if a child of this container has keyboard focus
+		if( mBorder->getVisible() )
+		{
+			mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus(this) );
+		}
+
+		// Draw all children except mScrolledView
+		// Note: scrollbars have been adjusted by above drawing code
+		for (child_list_const_reverse_iter_t child_iter = getChildList()->rbegin();
+			 child_iter != getChildList()->rend(); ++child_iter)
+		{
+			LLView *viewp = *child_iter;
+			if( sDebugRects )
+			{
+				sDepth++;
+			}
+			if( (viewp != mScrolledView) && viewp->getVisible() )
+			{
+				drawChild(viewp);
+			}
+			if( sDebugRects )
+			{
+				sDepth--;
+			}
+		}
+
+		if (sDebugRects)
+		{
+			drawDebugRect();
+		}
+	}
+}
+
+void LLScrollableContainerView::updateScroll()
+{
+	LLRect doc_rect = mScrolledView->getRect();
+	S32 doc_width = doc_rect.getWidth();
+	S32 doc_height = doc_rect.getHeight();
+	S32 visible_width = 0;
+	S32 visible_height = 0;
+	BOOL show_v_scrollbar = FALSE;
+	BOOL show_h_scrollbar = FALSE;
+	calcVisibleSize( doc_rect, &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+
+	S32 border_width = mBorder->getBorderWidth();
+	if( show_v_scrollbar )
+	{
+		if( doc_rect.mTop < mRect.getHeight() - border_width )
+		{
+			mScrolledView->translate( 0, mRect.getHeight() - border_width - doc_rect.mTop );
+		}
+
+		scrollVertical(	mScrollbar[VERTICAL]->getDocPos() );
+		mScrollbar[VERTICAL]->setVisible( TRUE );
+
+		S32 v_scrollbar_height = visible_height;
+		if( !show_h_scrollbar && mReserveScrollCorner )
+		{
+			v_scrollbar_height -= SCROLLBAR_SIZE;
+		}
+		mScrollbar[VERTICAL]->reshape( SCROLLBAR_SIZE, v_scrollbar_height, TRUE );
+
+		// Make room for the horizontal scrollbar (or not)
+		S32 v_scrollbar_offset = 0;
+		if( show_h_scrollbar || mReserveScrollCorner )
+		{
+			v_scrollbar_offset = SCROLLBAR_SIZE;
+		}
+		LLRect r = mScrollbar[VERTICAL]->getRect();
+		r.translate( 0, mInnerRect.mBottom - r.mBottom + v_scrollbar_offset );
+		mScrollbar[VERTICAL]->setRect( r );
+	}
+	else
+	{
+		mScrolledView->translate( 0, mRect.getHeight() - border_width - doc_rect.mTop );
+
+		mScrollbar[VERTICAL]->setVisible( FALSE );
+		mScrollbar[VERTICAL]->setDocPos( 0 );
+	}
+		
+	if( show_h_scrollbar )
+	{
+		if( doc_rect.mLeft > border_width )
+		{
+			mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
+			mScrollbar[HORIZONTAL]->setDocPos( 0 );
+		}
+		else
+		{
+			scrollHorizontal( mScrollbar[HORIZONTAL]->getDocPos() );
+		}
+	
+		mScrollbar[HORIZONTAL]->setVisible( TRUE );
+		S32 h_scrollbar_width = visible_width;
+		if( !show_v_scrollbar && mReserveScrollCorner )
+		{
+			h_scrollbar_width -= SCROLLBAR_SIZE;
+		}
+		mScrollbar[HORIZONTAL]->reshape( h_scrollbar_width, SCROLLBAR_SIZE, TRUE );
+	}
+	else
+	{
+		mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
+		
+		mScrollbar[HORIZONTAL]->setVisible( FALSE );
+		mScrollbar[HORIZONTAL]->setDocPos( 0 );
+	}
+
+	mScrollbar[HORIZONTAL]->setDocSize( doc_width );
+	mScrollbar[HORIZONTAL]->setPageSize( visible_width );
+
+	mScrollbar[VERTICAL]->setDocSize( doc_height );
+	mScrollbar[VERTICAL]->setPageSize( visible_height );
+}
+
+void LLScrollableContainerView::setBorderVisible(BOOL b)
+{
+	mBorder->setVisible( b );
+}
+
+// Scroll so that as much of rect as possible is showing (where rect is defined in the space of scroller view, not scrolled)
+void LLScrollableContainerView::scrollToShowRect(const LLRect& rect, const LLCoordGL& desired_offset)
+{
+	if (!mScrolledView)
+	{
+		llwarns << "LLScrollableContainerView::scrollToShowRect with no view!" << llendl;
+		return;
+	}
+
+	S32 visible_width = 0;
+	S32 visible_height = 0;
+	BOOL show_v_scrollbar = FALSE;
+	BOOL show_h_scrollbar = FALSE;
+	const LLRect& scrolled_rect = mScrolledView->getRect();
+	calcVisibleSize( scrolled_rect, &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+
+	// can't be so far left that right side of rect goes off screen, or so far right that left side does
+	S32 horiz_offset = llclamp(desired_offset.mX, llmin(0, -visible_width + rect.getWidth()), 0);
+	// can't be so high that bottom of rect goes off screen, or so low that top does
+	S32 vert_offset = llclamp(desired_offset.mY, 0, llmax(0, visible_height - rect.getHeight()));
+
+	// Vertical
+	// 1. First make sure the top is visible
+	// 2. Then, if possible without hiding the top, make the bottom visible.
+	S32 vert_pos = mScrollbar[VERTICAL]->getDocPos();
+
+	// find scrollbar position to get top of rect on screen (scrolling up)
+	S32 top_offset = scrolled_rect.mTop - rect.mTop - vert_offset;
+	// find scrollbar position to get bottom of rect on screen (scrolling down)
+	S32 bottom_offset = vert_offset == 0 ? scrolled_rect.mTop - rect.mBottom - visible_height : top_offset;
+	// scroll up far enough to see top or scroll down just enough if item is bigger than visual area
+	if( vert_pos >= top_offset || visible_height < rect.getHeight())
+	{
+		vert_pos = top_offset;
+	}
+	// else scroll down far enough to see bottom
+	else
+	if( vert_pos <= bottom_offset )
+	{
+		vert_pos = bottom_offset;
+	}
+
+	mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
+	mScrollbar[VERTICAL]->setPageSize( visible_height );
+	mScrollbar[VERTICAL]->setDocPos( vert_pos );
+
+	// Horizontal
+	// 1. First make sure left side is visible
+	// 2. Then, if possible without hiding the left side, make the right side visible.
+	S32 horiz_pos = mScrollbar[HORIZONTAL]->getDocPos();
+	S32 left_offset = rect.mLeft - scrolled_rect.mLeft + horiz_offset;
+	S32 right_offset = horiz_offset == 0 ? rect.mRight - scrolled_rect.mLeft - visible_width : left_offset;
+
+	if( horiz_pos >= left_offset || visible_width < rect.getWidth() )
+	{
+		horiz_pos = left_offset;
+	}
+	else if( horiz_pos <= right_offset )
+	{
+		horiz_pos = right_offset;
+	}
+	
+	mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
+	mScrollbar[HORIZONTAL]->setPageSize( visible_width );
+	mScrollbar[HORIZONTAL]->setDocPos( horiz_pos );
+
+	// propagate scroll to document
+	updateScroll();
+}
+
+void LLScrollableContainerView::pageUp(S32 overlap)
+{
+	mScrollbar[VERTICAL]->pageUp(overlap);
+}
+
+void LLScrollableContainerView::pageDown(S32 overlap)
+{
+	mScrollbar[VERTICAL]->pageDown(overlap);
+}
+
+void LLScrollableContainerView::goToTop()
+{
+	mScrollbar[VERTICAL]->setDocPos(0);
+}
+
+void LLScrollableContainerView::goToBottom()
+{
+	mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocSize());
+}
+
+S32 LLScrollableContainerView::getBorderWidth()
+{
+	if (mBorder)
+	{
+		return mBorder->getBorderWidth();
+	}
+
+	return 0;
+}
+
+// virtual
+LLXMLNodePtr LLScrollableContainerView::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLView::getXML();
+
+	// Attributes
+
+	node->createChild("opaque", TRUE)->setBoolValue(mIsOpaque);
+
+	if (mIsOpaque)
+	{
+		node->createChild("color", TRUE)->setFloatValue(4, mBackgroundColor.mV);
+	}
+
+	// Contents
+
+	LLXMLNodePtr child_node = mScrolledView->getXML();
+
+	node->addChild(child_node);
+
+	return node;
+}
+
+LLView* LLScrollableContainerView::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("scroll_container");
+	node->getAttributeString("name", name);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+	
+	BOOL opaque = FALSE;
+	node->getAttributeBOOL("opaque", opaque);
+
+	LLColor4 color(0,0,0,0);
+	LLUICtrlFactory::getAttributeColor(node,"color", color);
+
+	// Create the scroll view
+	LLScrollableContainerView *ret = new LLScrollableContainerView(name, rect, (LLPanel*)NULL, opaque, color);
+
+	LLPanel* panelp = NULL;
+
+	// Find a child panel to add
+	LLXMLNodePtr child;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		LLView *control = factory->createCtrlWidget(panelp, child);
+		if (control && control->isPanel())
+		{
+			if (panelp)
+			{
+				llinfos << "Warning! Attempting to put multiple panels into a scrollable container view!" << llendl;
+				delete control;
+			}
+			else
+			{
+				panelp = (LLPanel*)control;
+			}
+		}
+	}
+
+	if (panelp == NULL)
+	{
+		panelp = new LLPanel("dummy", LLRect::null, FALSE);
+	}
+
+	ret->mScrolledView = panelp;
+
+	return ret;
+}
+
+///----------------------------------------------------------------------------
+/// Local function definitions
+///----------------------------------------------------------------------------
diff --git a/indra/llui/llscrollcontainer.h b/indra/llui/llscrollcontainer.h
new file mode 100644
index 0000000000..5f23be4628
--- /dev/null
+++ b/indra/llui/llscrollcontainer.h
@@ -0,0 +1,109 @@
+/** 
+ * @file llscrollcontainer.h
+ * @brief LLScrollableContainerView class header file.
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLSCROLLCONTAINER_H
+#define LL_LLSCROLLCONTAINER_H
+
+#include "lluictrl.h"
+#ifndef LL_V4COLOR_H
+#include "v4color.h"
+#endif
+#include "stdenums.h"
+#include "llcoord.h"
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLScrollableContainerView
+//
+// A view meant to encapsulate a clipped region which is
+// scrollable. It automatically takes care of pixel perfect scrolling
+// and cliipping, as well as turning the scrollbars on or off based on
+// the width and height of the view you're scrolling.
+//
+// This class is a decorator class.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLScrollbar;
+class LLViewBorder;
+
+
+class LLScrollableContainerView : public LLUICtrl
+{
+public:
+	LLScrollableContainerView( const LLString& name, const LLRect& rect,
+							   LLView* scrolled_view, BOOL is_opaque = FALSE,
+							   const LLColor4& bg_color = LLColor4(0,0,0,0) );
+	LLScrollableContainerView( const LLString& name, const LLRect& rect,
+							   LLUICtrl* scrolled_ctrl, BOOL is_opaque = FALSE,
+							   const LLColor4& bg_color = LLColor4(0,0,0,0) );
+	virtual ~LLScrollableContainerView( void );
+
+	void init();
+
+	void setScrolledView(LLView* view) { mScrolledView = view; }
+
+	virtual void setValue(const LLSD& value) { mInnerRect.setValue(value); }
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_SCROLL_CONTAINER; }
+	virtual LLString getWidgetTag() const { return LL_SCROLLABLE_CONTAINER_VIEW_TAG; }
+
+	// scrollbar handlers
+	static void		horizontalChange( S32 new_pos, LLScrollbar* sb, void* user_data );
+	static void		verticalChange( S32 new_pos, LLScrollbar* sb, void* user_data );
+
+	void			calcVisibleSize( S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar );
+	void			calcVisibleSize( const LLRect& doc_rect, S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar );
+	void			setBorderVisible( BOOL b );
+
+	void			scrollToShowRect( const LLRect& rect, const LLCoordGL& desired_offset );
+	void			setReserveScrollCorner( BOOL b ) { mReserveScrollCorner = b; }
+	const LLRect&	getScrolledViewRect() { return mScrolledView->getRect(); }
+	void			pageUp(S32 overlap = 0);
+	void			pageDown(S32 overlap = 0);
+	void			goToTop();
+	void			goToBottom();
+	S32				getBorderWidth();
+
+	// LLView functionality
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent);
+	virtual BOOL	handleKey(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL	handleScrollWheel( S32 x, S32 y, S32 clicks );
+	virtual BOOL	handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
+								   EDragAndDropType cargo_type,
+								   void* cargo_data,
+								   EAcceptance* accept,
+								   LLString& tooltip_msg);
+
+	virtual BOOL	handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect);
+	virtual void	draw();
+
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+protected:
+	// internal scrollbar handlers
+	virtual void scrollHorizontal( S32 new_pos );
+	virtual void scrollVertical( S32 new_pos );
+	void updateScroll();
+
+	// Note: vertical comes before horizontal because vertical
+	// scrollbars have priority for mouse and keyboard events.
+	enum { VERTICAL, HORIZONTAL, SCROLLBAR_COUNT };
+
+	LLScrollbar* mScrollbar[SCROLLBAR_COUNT];
+	LLView*		mScrolledView;
+	S32			mSize;
+	BOOL		mIsOpaque;
+	LLColor4	mBackgroundColor;
+	LLRect		mInnerRect;
+	LLViewBorder* mBorder;
+	BOOL		mReserveScrollCorner;
+	BOOL		mAutoScrolling;
+	F32			mAutoScrollRate;
+};
+
+
+#endif // LL_LLSCROLLCONTAINER_H
diff --git a/indra/llui/llscrollingpanellist.cpp b/indra/llui/llscrollingpanellist.cpp
new file mode 100644
index 0000000000..a4d20edfe9
--- /dev/null
+++ b/indra/llui/llscrollingpanellist.cpp
@@ -0,0 +1,150 @@
+/** 
+ * @file llscrollingpanellist.cpp
+ * @brief 
+ *
+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+#include "llstl.h"
+
+#include "llscrollingpanellist.h"
+
+/////////////////////////////////////////////////////////////////////
+// LLScrollingPanelList
+
+// This could probably be integrated with LLScrollContainer -SJB
+
+void LLScrollingPanelList::clearPanels()
+{
+	deleteAllChildren();
+	mPanelList.clear();
+	reshape( 1, 1, FALSE );
+}
+
+void LLScrollingPanelList::addPanel( LLScrollingPanel* panel )
+{
+	addChildAtEnd( panel );
+	mPanelList.push_front( panel );
+	
+	const S32 GAP_BETWEEN_PANELS = 6;
+
+	// Resize this view
+	S32 total_height = 0;
+	S32 max_width = 0;
+	S32 cur_gap = 0;
+	for (std::deque<LLScrollingPanel*>::iterator iter = mPanelList.begin();
+		 iter != mPanelList.end(); ++iter)
+	{
+		LLScrollingPanel *childp = *iter;
+		total_height += childp->getRect().getHeight() + cur_gap;
+		max_width = llmax( max_width, childp->getRect().getWidth() );
+		cur_gap = GAP_BETWEEN_PANELS;
+	}
+	reshape( max_width, total_height, FALSE );
+
+	// Reposition each of the child views
+	S32 cur_y = total_height;
+	for (std::deque<LLScrollingPanel*>::iterator iter = mPanelList.begin();
+		 iter != mPanelList.end(); ++iter)
+	{
+		LLScrollingPanel *childp = *iter;
+		cur_y -= childp->getRect().getHeight();
+		childp->translate( -childp->getRect().mLeft, cur_y - childp->getRect().mBottom);
+		cur_y -= GAP_BETWEEN_PANELS;
+	}
+}
+	
+void LLScrollingPanelList::updatePanels(BOOL allow_modify)
+{
+    for (std::deque<LLScrollingPanel*>::iterator iter = mPanelList.begin();
+		 iter != mPanelList.end(); ++iter)
+    {
+		LLScrollingPanel *childp = *iter;
+		childp->updatePanel(allow_modify);
+    }
+}
+
+void LLScrollingPanelList::updatePanelVisiblilty()
+{
+	// Determine visibility of children.
+	S32 BORDER_WIDTH = 2;  // HACK
+
+	LLRect parent_local_rect = getParent()->getRect();
+	parent_local_rect.stretch( -BORDER_WIDTH );
+	
+	LLRect parent_screen_rect;
+	getParent()->localPointToScreen( 
+		BORDER_WIDTH, 0, 
+		&parent_screen_rect.mLeft, &parent_screen_rect.mBottom );
+	getParent()->localPointToScreen( 
+		parent_local_rect.getWidth() - BORDER_WIDTH, parent_local_rect.getHeight() - BORDER_WIDTH,
+		&parent_screen_rect.mRight, &parent_screen_rect.mTop );
+
+	for (std::deque<LLScrollingPanel*>::iterator iter = mPanelList.begin();
+		 iter != mPanelList.end(); ++iter)
+	{
+		LLScrollingPanel *childp = *iter;
+		const LLRect& local_rect = childp->getRect();
+		LLRect screen_rect;
+		childp->localPointToScreen( 
+			0, 0, 
+			&screen_rect.mLeft, &screen_rect.mBottom );
+		childp->localPointToScreen(
+			local_rect.getWidth(), local_rect.getHeight(),
+			&screen_rect.mRight, &screen_rect.mTop );
+
+		BOOL intersects = 
+			( (screen_rect.mRight > parent_screen_rect.mLeft) && (screen_rect.mLeft < parent_screen_rect.mRight) ) && 
+			( (screen_rect.mTop > parent_screen_rect.mBottom) && (screen_rect.mBottom < parent_screen_rect.mTop) );
+
+		childp->setVisible( intersects );
+	}
+}
+
+void LLScrollingPanelList::setValue(const LLSD& value)
+{
+
+}
+
+EWidgetType LLScrollingPanelList::getWidgetType() const
+{
+	return WIDGET_TYPE_SCROLLING_PANEL_LIST;
+}
+
+LLString LLScrollingPanelList::getWidgetTag() const
+{
+	return LL_SCROLLING_PANEL_LIST_TAG;
+}
+
+void LLScrollingPanelList::draw()
+{
+	if( getVisible() )
+	{
+		updatePanelVisiblilty();
+	}
+	LLUICtrl::draw();
+}
+
+
+// static
+LLView* LLScrollingPanelList::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+    LLString name("scrolling_panel_list");
+    node->getAttributeString("name", name);
+
+    LLRect rect;
+    createRect(node, rect, parent, LLRect());
+
+    LLScrollingPanelList* scrolling_panel_list = new LLScrollingPanelList(name, rect);
+    scrolling_panel_list->initFromXML(node, parent);
+    return scrolling_panel_list;
+}
+
+// virtual
+LLXMLNodePtr LLScrollingPanelList::getXML(bool save_children) const
+{
+    LLXMLNodePtr node = LLUICtrl::getXML();
+    return node;
+}
diff --git a/indra/llui/llscrollingpanellist.h b/indra/llui/llscrollingpanellist.h
new file mode 100644
index 0000000000..b5f20ce172
--- /dev/null
+++ b/indra/llui/llscrollingpanellist.h
@@ -0,0 +1,53 @@
+/** 
+ * @file llscrollingpanellist.h
+ *
+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <vector>
+
+#include "llui.h"
+#include "lluictrlfactory.h"
+#include "llview.h"
+#include "llpanel.h"
+
+// virtual class for scrolling panels
+class LLScrollingPanel : public LLPanel
+{
+public:
+	LLScrollingPanel(const LLString& name, const LLRect& rect)
+		: LLPanel(name, rect)
+	{
+	}
+	virtual void updatePanel(BOOL allow_modify) = 0;
+	
+};
+	
+// A set of panels that are displayed in a vertical sequence inside a scroll container.
+class LLScrollingPanelList : public LLUICtrl
+{
+public:
+	LLScrollingPanelList(const LLString& name, const LLRect& rect)
+		:	LLUICtrl(name, rect, TRUE, NULL, NULL, FOLLOWS_LEFT | FOLLOWS_BOTTOM ) {}
+
+	virtual void setValue(const LLSD& value);
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual LLXMLNodePtr getXML(bool save_children) const;
+	
+	virtual void		draw();
+
+	void				clearPanels();
+	void				addPanel( LLScrollingPanel* panel );
+	void				updatePanels(BOOL allow_modify);
+
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	
+protected:
+	void				updatePanelVisiblilty();
+
+protected:
+	std::deque<LLScrollingPanel*> mPanelList;
+};
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
new file mode 100644
index 0000000000..5d11973b88
--- /dev/null
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -0,0 +1,2673 @@
+/** 
+ * @file llscrolllistctrl.cpp
+ * @brief LLScrollListCtrl base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include <algorithm>
+
+#include "linden_common.h"
+#include "llstl.h"
+#include "llboost.h"
+
+#include "llscrolllistctrl.h"
+
+#include "indra_constants.h"
+
+#include "llcheckboxctrl.h"
+#include "llclipboard.h"
+#include "llfocusmgr.h"
+#include "llgl.h"
+#include "llglheaders.h"
+#include "llresmgr.h"
+#include "llscrollbar.h"
+#include "llstring.h"
+#include "llui.h"
+#include "lluictrlfactory.h"
+#include "llwindow.h"
+#include "llcontrol.h"
+#include "llkeyboard.h"
+
+const S32 LIST_BORDER_PAD = 2;		// white space inside the border and to the left of the scrollbar
+
+U32 LLScrollListCtrl::sSortColumn = 1;
+BOOL LLScrollListCtrl::sSortAscending = TRUE; 
+
+// local structures & classes.
+struct SortScrollListItem
+{
+	SortScrollListItem(const S32 sort_col, BOOL sort_ascending)
+	{
+		mSortCol = sort_col;
+		sSortAscending = sort_ascending;
+	}
+
+	bool operator()(const LLScrollListItem* i1, const LLScrollListItem* i2)
+	{
+		const LLScrollListCell *cell1;
+		const LLScrollListCell *cell2;
+		
+		cell1 = i1->getColumn(mSortCol);
+		cell2 = i2->getColumn(mSortCol);
+		
+		S32 order = 1;
+		if (!sSortAscending)
+		{
+			order = -1;
+		}
+
+		BOOL retval = FALSE;
+
+		if (cell1 && cell2)
+		{
+			retval = ((order * LLString::compareDict(cell1->getText(),	cell2->getText())) < 0);
+		}
+
+		return (retval ? TRUE : FALSE);
+	}
+
+protected:
+	S32 mSortCol;
+	S32 sSortAscending;
+};
+
+
+
+//
+// LLScrollListIcon
+//
+LLScrollListIcon::LLScrollListIcon(LLImageGL* icon, S32 width, LLUUID image_id) :
+mIcon(icon), mImageUUID(image_id.getString())
+{
+	if (width)
+	{
+		mWidth = width;
+	}
+	else
+	{
+		mWidth = icon->getWidth();
+	}
+}
+
+LLScrollListIcon::~LLScrollListIcon()
+{
+}
+
+//
+// LLScrollListCheck
+//
+LLScrollListCheck::LLScrollListCheck(LLCheckBoxCtrl* check_box, S32 width)
+{
+	mCheckBox = check_box;
+	LLRect rect(mCheckBox->getRect());
+	if (width)
+	{
+		
+		rect.mRight = rect.mLeft + width;
+		mCheckBox->setRect(rect);
+		mWidth = width;
+	}
+	else
+	{
+		mWidth = rect.getWidth(); //check_box->getWidth();
+	}
+}
+
+LLScrollListCheck::~LLScrollListCheck()
+{
+	delete mCheckBox;
+}
+
+void LLScrollListCheck::drawToWidth(S32 width, const LLColor4& color, const LLColor4& highlight_color) const
+{
+	mCheckBox->draw();
+
+}
+
+BOOL LLScrollListCheck::handleClick()
+{ 
+	if ( mCheckBox->getEnabled() )
+	{
+		LLCheckBoxCtrl::onButtonPress(mCheckBox); 
+	}
+	return TRUE; 
+}
+
+//
+// LLScrollListText
+//
+U32 LLScrollListText::sCount = 0;
+
+LLScrollListText::LLScrollListText( const LLString& text, const LLFontGL* font, S32 width, U8 font_style, LLColor4& color, BOOL use_color, BOOL visible)
+:	mText( text ),
+	mFont( font ),
+	mFontStyle( font_style ),
+	mWidth( width ),
+	mVisible( visible ),
+	mHighlightChars( 0 )
+{
+	if (use_color)
+	{
+		mColor = new LLColor4();
+		mColor->setVec(color);
+	}
+	else
+	{
+		mColor = NULL;
+	}
+
+	sCount++;
+
+	// initialize rounded rect image
+	if (!mRoundedRectImage)
+	{
+		mRoundedRectImage = LLUI::sImageProvider->getUIImageByID(LLUUID(LLUI::sAssetsGroup->getString("rounded_square.tga")));
+	}
+
+	// Yes, that's four dots, because we want it to have a little
+	// padding, in proportion to the font size.
+	mEllipsisWidth = (S32)mFont->getWidth("....");
+}
+
+LLScrollListText::~LLScrollListText()
+{
+	sCount--;
+	delete mColor;
+}
+
+void LLScrollListText::setText(const LLString& text)
+{
+	mText = text;
+}
+
+void LLScrollListText::drawToWidth(S32 width, const LLColor4& color, const LLColor4& highlight_color) const
+{
+	// If the user has specified a small minimum width, use that.
+	if (mWidth > 0 && mWidth < width)
+	{
+		width = mWidth;
+	}
+
+	const LLColor4* display_color;
+	if (mColor)
+	{
+		display_color = mColor;
+	}
+	else
+	{
+		display_color = &color;
+	}
+
+	if (mHighlightChars > 0)
+	{
+		mRoundedRectImage->bind();
+		glColor4fv(highlight_color.mV);
+		gl_segmented_rect_2d_tex(-2, 
+				llround(mFont->getLineHeight()) + 1, 
+				mFont->getWidth(mText.getString(), 0, mHighlightChars) + 1, 
+				1, 
+				mRoundedRectImage->getWidth(), 
+				mRoundedRectImage->getHeight(), 
+				16);
+	}
+
+	// Try to draw the entire string
+	F32 right_x;
+	U32 string_chars = mText.length();
+	U32 drawn_chars = mFont->render(mText.getWString(), 0, 0, 2,
+									*display_color,
+									LLFontGL::LEFT,
+									LLFontGL::BOTTOM, 
+									mFontStyle,
+									string_chars, 
+									width - mEllipsisWidth,
+									&right_x, FALSE);
+
+	// If we didn't get the whole string, abbreviate
+	if (drawn_chars < string_chars && drawn_chars)
+	{
+		mFont->renderUTF8("...", 0, right_x, 0.f, color, LLFontGL::LEFT, LLFontGL::BOTTOM, mFontStyle,
+						  S32_MAX, S32_MAX, NULL, FALSE);
+	}
+}
+
+
+LLScrollListItem::~LLScrollListItem()
+{
+	std::for_each(mColumns.begin(), mColumns.end(), DeletePointer());
+}
+
+BOOL LLScrollListItem::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = FALSE;
+
+	S32 left = 0;
+	S32 right = 0;
+	S32 width = 0;
+
+	std::vector<LLScrollListCell *>::iterator iter = mColumns.begin();
+	std::vector<LLScrollListCell *>::iterator end = mColumns.end();
+	for ( ; iter != end; ++iter)
+	{
+		width = (*iter)->getWidth();
+		right += width;
+		if (left <= x && x < right )
+		{
+			handled = (*iter)->handleClick();
+			break;
+		}
+		
+		left += width;
+	}
+	return handled;
+}
+
+void LLScrollListItem::setNumColumns(S32 columns)
+{
+	S32 prev_columns = mColumns.size();
+	if (columns < prev_columns)
+	{
+		std::for_each(mColumns.begin()+columns, mColumns.end(), DeletePointer());
+	}
+	
+	mColumns.resize(columns);
+
+	for (S32 col = prev_columns; col < columns; ++col)
+	{
+		mColumns[col] = NULL;
+	}
+}
+
+void LLScrollListItem::setColumn( S32 column, LLScrollListCell *cell )
+{
+	if (column < (S32)mColumns.size())
+	{
+		delete mColumns[column];
+		mColumns[column] = cell;
+	}
+	else
+	{
+		llerrs << "LLScrollListItem::setColumn: bad column: " << column << llendl;
+	}
+}
+
+LLString LLScrollListItem::getContentsCSV()
+{
+	LLString ret;
+
+	S32 count = getNumColumns();
+	for (S32 i=0; i<count; ++i)
+	{
+		ret += getColumn(i)->getText();
+		if (i < count-1)
+		{
+			ret += ", ";
+		}
+	}
+
+	return ret;
+}
+
+void LLScrollListItem::setEnabled(BOOL b)
+{
+	if (b != mEnabled)
+	{
+		std::vector<LLScrollListCell *>::iterator iter = mColumns.begin();
+		std::vector<LLScrollListCell *>::iterator end = mColumns.end();
+		for ( ; iter != end; ++iter)
+		{
+			(*iter)->setEnabled(b);
+		}
+		mEnabled = b;
+	}
+}
+
+//---------------------------------------------------------------------------
+// LLScrollListCtrl
+//---------------------------------------------------------------------------
+
+LLScrollListCtrl::LLScrollListCtrl(const LLString& name, const LLRect& rect,
+	void (*commit_callback)(LLUICtrl* ctrl, void* userdata),
+	void* callback_user_data,
+	BOOL allow_multiple_selection,
+	BOOL show_border
+	)
+ :	LLUICtrl(name, rect, TRUE, commit_callback, callback_user_data),
+	mLineHeight(0),
+	mScrollLines(0),
+	mPageLines(0),
+	mHeadingHeight(20),
+	mMaxSelectable(0),
+	mHeadingFont(NULL),
+	mAllowMultipleSelection( allow_multiple_selection ),
+	mAllowKeyboardMovement(TRUE),
+	mCommitOnKeyboardMovement(TRUE),
+	mCommitOnSelectionChange(FALSE),
+	mSelectionChanged(FALSE),
+	mCanSelect(TRUE),
+	mDisplayColumnButtons(FALSE),
+	mCollapseEmptyColumns(FALSE),
+	mIsPopup(FALSE),
+	mMaxItemCount(INT_MAX), 
+	//mItemCount(0),
+	mBackgroundVisible( TRUE ),
+	mDrawStripes(TRUE),
+	mBgWriteableColor(	LLUI::sColorsGroup->getColor( "ScrollBgWriteableColor" ) ),
+	mBgReadOnlyColor(	LLUI::sColorsGroup->getColor( "ScrollBgReadOnlyColor" ) ),
+	mBgSelectedColor( LLUI::sColorsGroup->getColor("ScrollSelectedBGColor") ),
+	mBgStripeColor( LLUI::sColorsGroup->getColor("ScrollBGStripeColor") ),
+	mFgSelectedColor( LLUI::sColorsGroup->getColor("ScrollSelectedFGColor") ),
+	mFgUnselectedColor( LLUI::sColorsGroup->getColor("ScrollUnselectedColor") ),
+	mFgDisabledColor( LLUI::sColorsGroup->getColor("ScrollDisabledColor") ),
+	mHighlightedColor( LLUI::sColorsGroup->getColor("ScrollHighlightedColor") ),
+	mBorderThickness( 2 ),
+	mOnDoubleClickCallback( NULL ),
+	mOnMaximumSelectCallback( NULL ),
+	mHighlightedItem(-1),
+	mBorder(NULL),
+	mDefaultColumn("SIMPLE"),
+	mSearchColumn(0),
+	mNumDynamicWidthColumns(0),
+	mTotalStaticColumnWidth(0),
+	mDrewSelected(FALSE)
+{
+	mItemListRect.setOriginAndSize(
+		mBorderThickness + LIST_BORDER_PAD,
+		mBorderThickness + LIST_BORDER_PAD,
+		mRect.getWidth() - 2*( mBorderThickness + LIST_BORDER_PAD ) - SCROLLBAR_SIZE,
+		mRect.getHeight() - 2*( mBorderThickness + LIST_BORDER_PAD ) );
+
+	updateLineHeight();
+
+	mPageLines = mLineHeight? (mItemListRect.getHeight()) / mLineHeight : 0;
+
+	// Init the scrollbar
+	LLRect scroll_rect;
+	scroll_rect.setOriginAndSize( 
+		mRect.getWidth() - mBorderThickness - SCROLLBAR_SIZE,
+		mItemListRect.mBottom,
+		SCROLLBAR_SIZE,
+		mItemListRect.getHeight());
+	mScrollbar = new LLScrollbar( "Scrollbar", scroll_rect,
+		LLScrollbar::VERTICAL,
+		getItemCount(),
+		mScrollLines,
+		mPageLines,
+		&LLScrollListCtrl::onScrollChange, this );
+	mScrollbar->setFollowsRight();
+	mScrollbar->setFollowsTop();
+	mScrollbar->setFollowsBottom();
+	mScrollbar->setEnabled( TRUE );
+	mScrollbar->setVisible( TRUE );
+	addChild(mScrollbar);
+
+	// Border
+	if (show_border)
+	{
+		LLRect border_rect( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+		mBorder = new LLViewBorder( "dlg border", border_rect, LLViewBorder::BEVEL_IN, LLViewBorder::STYLE_LINE, 1 );
+		addChild(mBorder);
+	}
+
+	mColumnPadding = 5;
+
+	mLastSelected = NULL;
+}
+
+LLScrollListCtrl::~LLScrollListCtrl()
+{
+	std::for_each(mItemList.begin(), mItemList.end(), DeletePointer());
+
+	if( gEditMenuHandler == this )
+	{
+		gEditMenuHandler = NULL;
+	}
+}
+
+
+BOOL LLScrollListCtrl::setMaxItemCount(S32 max_count)
+{
+	if (max_count >= getItemCount())
+	{
+		mMaxItemCount = max_count;
+	}
+	return (max_count == mMaxItemCount);
+}
+
+S32 LLScrollListCtrl::isEmpty() const
+{
+	return mItemList.empty();
+}
+
+S32 LLScrollListCtrl::getItemCount() const
+{
+	return mItemList.size();
+}
+
+// virtual LLScrolListInterface function (was deleteAllItems)
+void LLScrollListCtrl::clearRows()
+{
+	std::for_each(mItemList.begin(), mItemList.end(), DeletePointer());
+	mItemList.clear();
+	//mItemCount = 0;
+
+	// Scroll the bar back up to the top.
+	mScrollbar->setDocParams(0, 0);
+
+	mScrollLines = 0;
+	mLastSelected = NULL;
+}
+
+
+LLScrollListItem* LLScrollListCtrl::getFirstSelected() const
+{
+	item_list::const_iterator iter;
+	for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item  = *iter;
+		if (item->getSelected())
+		{
+			return item;
+		}
+	}
+	return NULL;
+}
+
+std::vector<LLScrollListItem*> LLScrollListCtrl::getAllSelected() const
+{
+	std::vector<LLScrollListItem*> ret;
+	item_list::const_iterator iter;
+	for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item  = *iter;
+		if (item->getSelected())
+		{
+			ret.push_back(item);
+		}
+	}
+	return ret;
+}
+
+S32 LLScrollListCtrl::getFirstSelectedIndex()
+{
+	S32 CurSelectedIndex = 0;
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item  = *iter;
+		if (item->getSelected())
+		{
+			return CurSelectedIndex;
+		}
+		CurSelectedIndex++;
+	}
+
+	return -1;
+}
+
+
+LLScrollListItem* LLScrollListCtrl::getFirstData() const
+{
+	if (mItemList.size() == 0)
+	{
+		return NULL;
+	}
+	return mItemList[0];
+}
+
+std::vector<LLScrollListItem*> LLScrollListCtrl::getAllData() const
+{
+	std::vector<LLScrollListItem*> ret;
+	item_list::const_iterator iter;
+	for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item  = *iter;
+		ret.push_back(item);
+	}
+	return ret;
+}
+
+
+void LLScrollListCtrl::reshape( S32 width, S32 height, BOOL called_from_parent )
+{
+	LLUICtrl::reshape( width, height, called_from_parent );
+
+	S32 heading_size = (mDisplayColumnButtons ? mHeadingHeight : 0);
+
+	mItemListRect.setOriginAndSize(
+		mBorderThickness + LIST_BORDER_PAD,
+		mBorderThickness + LIST_BORDER_PAD,
+		mRect.getWidth() - 2*( mBorderThickness + LIST_BORDER_PAD ) - SCROLLBAR_SIZE,
+		mRect.getHeight() - 2*( mBorderThickness + LIST_BORDER_PAD ) - heading_size );
+
+	mPageLines = mLineHeight? mItemListRect.getHeight() / mLineHeight : 0;
+	mScrollbar->setVisible(mPageLines < getItemCount());
+	mScrollbar->setPageSize( mPageLines );
+
+	updateColumns();
+	updateColumnButtons();
+}
+
+
+// Attempt to size the control to show all items.
+// Do not make larger than width or height.
+void LLScrollListCtrl::arrange(S32 max_width, S32 max_height)
+{
+	S32 height = mLineHeight * (getItemCount() + 1);
+	height = llmin( height, max_height );
+
+	S32 width = mRect.getWidth();
+
+	reshape( width, height );
+}
+
+
+LLRect LLScrollListCtrl::getRequiredRect()
+{
+	S32 height = mLineHeight * (getItemCount() + 1);
+	S32 width = mRect.getWidth();
+
+	return LLRect(0, height, width, 0);
+}
+
+
+BOOL LLScrollListCtrl::addItem( LLScrollListItem* item, EAddPosition pos )
+{
+	BOOL not_too_big = getItemCount() < mMaxItemCount;
+	if (not_too_big)
+	{
+		switch( pos )
+		{
+		case ADD_TOP:
+			mItemList.push_front(item);
+			break;
+	
+		case ADD_SORTED:
+			LLScrollListCtrl::sSortColumn = 0;
+			LLScrollListCtrl::sSortAscending = TRUE;
+			mItemList.push_back(item);
+			std::sort(mItemList.begin(), mItemList.end(), SortScrollListItem(sSortColumn, sSortAscending));
+			break;
+	
+		case ADD_BOTTOM:
+			mItemList.push_back(item);
+			break;
+	
+		default:
+			llassert(0);
+			mItemList.push_back(item);
+			break;
+		}
+	
+		updateLineHeight();
+		mPageLines = mLineHeight ? mItemListRect.getHeight() / mLineHeight : 0;
+		mScrollbar->setVisible(mPageLines < getItemCount());
+		mScrollbar->setPageSize( mPageLines );
+	
+		mScrollbar->setDocSize( getItemCount() );
+	}
+	return not_too_big;
+}
+
+
+// Line height is the max height of all the cells in all the items.
+void LLScrollListCtrl::updateLineHeight()
+{
+	const S32 ROW_PAD = 2;
+
+	mLineHeight = 0;
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem *itemp = *iter;
+		S32 num_cols = itemp->getNumColumns();
+		S32 i = 0;
+		for (const LLScrollListCell* cell = itemp->getColumn(i); i < num_cols; cell = itemp->getColumn(++i))
+		{
+			mLineHeight = llmax( mLineHeight, cell->getHeight() + ROW_PAD );
+		}
+	}
+}
+
+void LLScrollListCtrl::updateColumns()
+{
+	mColumnsIndexed.resize(mColumns.size());
+
+	std::map<LLString, LLScrollListColumn>::iterator column_itor;
+	for (column_itor = mColumns.begin(); column_itor != mColumns.end(); ++column_itor)
+	{
+		LLScrollListColumn *column = &column_itor->second;
+		if (column->mRelWidth >= 0)
+		{
+			column->mWidth = (S32)llround(column->mRelWidth*mItemListRect.getWidth());
+		}
+		else if (column->mDynamicWidth)
+		{
+			column->mWidth = (mItemListRect.getWidth() - mTotalStaticColumnWidth) / mNumDynamicWidthColumns;
+ 
+		}
+		mColumnsIndexed[column_itor->second.mIndex] = column;
+	}
+}
+
+void LLScrollListCtrl::updateColumnButtons()
+{
+	std::map<LLString, LLScrollListColumn>::iterator column_itor;
+	for (column_itor = mColumns.begin(); column_itor != mColumns.end(); ++column_itor)
+	{
+		LLScrollListColumn* column = &column_itor->second;
+		LLButton *button = column->mButton;
+
+		if (button)
+		{
+			mColumnsIndexed[column->mIndex] = column;
+
+			S32 top = mItemListRect.mTop;
+			S32 left = mItemListRect.mLeft;
+			{
+				std::map<LLString, LLScrollListColumn>::iterator itor;
+				for (itor = mColumns.begin(); itor != mColumns.end(); ++itor)
+				{
+					if (itor->second.mIndex < column->mIndex &&
+						itor->second.mWidth > 0)
+					{
+						left += itor->second.mWidth + mColumnPadding;
+					}
+				}
+			}
+			S32 right = left+column->mWidth;
+			if (column->mIndex != (S32)mColumns.size()-1)
+			{
+				right += mColumnPadding;
+			}
+			LLRect temp_rect = LLRect(left,top+mHeadingHeight,right,top);
+			button->setRect(temp_rect);
+			button->setFont(mHeadingFont);
+			button->setVisible(mDisplayColumnButtons);
+		}
+	}
+}
+
+void LLScrollListCtrl::setDisplayHeading(BOOL display)
+{
+	mDisplayColumnButtons = display;
+
+	updateColumns();
+
+	setHeadingHeight(mHeadingHeight);
+}
+
+void LLScrollListCtrl::setHeadingHeight(S32 heading_height)
+{
+	mHeadingHeight = heading_height;
+
+	reshape(mRect.getWidth(), mRect.getHeight());
+
+	// Resize
+	mScrollbar->reshape(SCROLLBAR_SIZE, mItemListRect.getHeight());
+
+	updateColumnButtons();
+}
+
+void LLScrollListCtrl::setHeadingFont(const LLFontGL* heading_font)
+{
+	mHeadingFont = heading_font;
+	updateColumnButtons();
+}
+
+void LLScrollListCtrl::setCollapseEmptyColumns(BOOL collapse)
+{
+	mCollapseEmptyColumns = collapse;
+}
+
+BOOL LLScrollListCtrl::selectFirstItem()
+{
+	BOOL success = FALSE;
+
+	// our $%&@#$()^%#$()*^ iterators don't let us check against the first item inside out iteration
+	BOOL first_item = TRUE;
+
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem *itemp = *iter;
+		if( first_item && itemp->getEnabled() )
+		{
+			if (!itemp->getSelected())
+			{
+				selectItem(itemp);
+			}
+			success = TRUE;
+		}
+		else
+		{
+			deselectItem(itemp);
+		}
+		first_item = FALSE;
+	}
+	if (mCommitOnSelectionChange)
+	{
+		commitIfChanged();
+	}
+	return success;
+}
+
+
+BOOL LLScrollListCtrl::selectNthItem( S32 target_index )
+{
+	// Deselects all other items
+	BOOL success = FALSE;
+	S32 index = 0;
+
+	target_index = llclamp(target_index, 0, (S32)mItemList.size() - 1);
+
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem *itemp = *iter;
+		if( target_index == index )
+		{
+			if( itemp->getEnabled() )
+			{
+				selectItem(itemp);
+				success = TRUE;
+			}
+		}
+		else
+		{
+			deselectItem(itemp);
+		}
+		index++;
+	}
+
+	if (mCommitOnSelectionChange)
+	{
+		commitIfChanged();
+	}
+
+	mSearchString.clear();
+
+	return success;
+}
+
+
+void LLScrollListCtrl::swapWithNext(S32 index)
+{
+	if (index >= ((S32)mItemList.size() - 1))
+	{
+		// At end of list, doesn't do anything
+		return;
+	}
+	LLScrollListItem *cur_itemp = mItemList[index];
+	mItemList[index] = mItemList[index + 1];
+	mItemList[index + 1] = cur_itemp;
+}
+
+
+void LLScrollListCtrl::swapWithPrevious(S32 index)
+{
+	if (index <= 0)
+	{
+		// At beginning of list, don't do anything
+	}
+
+	LLScrollListItem *cur_itemp = mItemList[index];
+	mItemList[index] = mItemList[index - 1];
+	mItemList[index - 1] = cur_itemp;
+}
+
+
+void LLScrollListCtrl::deleteSingleItem(S32 target_index)
+{
+	if (target_index >= (S32)mItemList.size())
+	{
+		return;
+	}
+
+	LLScrollListItem *itemp;
+	itemp = mItemList[target_index];
+	if (itemp == mLastSelected)
+	{
+		mLastSelected = NULL;
+	}
+	delete itemp;
+	mItemList.erase(mItemList.begin() + target_index);
+}
+
+void LLScrollListCtrl::deleteSelectedItems()
+{
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter < mItemList.end(); )
+	{
+		LLScrollListItem* itemp = *iter;
+		if (itemp->getSelected())
+		{
+			delete itemp;
+			iter = mItemList.erase(iter);
+		}
+		else
+		{
+			iter++;
+		}
+	}
+	mLastSelected = NULL;
+}
+
+void LLScrollListCtrl::highlightNthItem(S32 target_index)
+{
+	if (mHighlightedItem != target_index)
+	{
+		mHighlightedItem = target_index;
+	}
+}
+
+S32 LLScrollListCtrl::getItemIndex( LLScrollListItem* target_item )
+{
+	S32 index = 0;
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem *itemp = *iter;
+		if (target_item == itemp)
+		{
+			return index;
+		}
+		index++;
+	}
+	return -1;
+}
+
+S32 LLScrollListCtrl::getItemIndex( LLUUID& target_id )
+{
+	S32 index = 0;
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem *itemp = *iter;
+		if (target_id == itemp->getUUID())
+		{
+			return index;
+		}
+		index++;
+	}
+	return -1;
+}
+
+void LLScrollListCtrl::selectPrevItem( BOOL extend_selection)
+{
+	LLScrollListItem* prev_item = NULL;
+
+	if (!getFirstSelected())
+	{
+		selectFirstItem();
+	}
+	else
+	{
+		item_list::iterator iter;
+		for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+		{
+			LLScrollListItem* cur_item = *iter;
+
+			if (cur_item->getSelected())
+			{
+				if (prev_item)
+				{
+					selectItem(prev_item, !extend_selection);
+				}
+				else
+				{
+					reportInvalidInput();
+				}
+				break;
+			}
+
+			prev_item = cur_item;
+		}
+	}
+
+	if ((mCommitOnSelectionChange || mCommitOnKeyboardMovement))
+	{
+		commitIfChanged();
+	}
+
+	mSearchString.clear();
+}
+
+
+void LLScrollListCtrl::selectNextItem( BOOL extend_selection)
+{
+	if (!getFirstSelected())
+	{
+		selectFirstItem();
+	}
+	else
+	{
+		item_list::iterator iter;
+		for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+		{
+			LLScrollListItem* item = *iter;
+			if (item->getSelected())
+			{
+				if (++iter != mItemList.end())
+				{
+					LLScrollListItem *next_item = *iter;
+					if (next_item)
+					{
+						selectItem(next_item, !extend_selection);
+					}
+					else
+					{
+						reportInvalidInput();
+					}
+				}
+				break;
+			}
+		}
+	}
+
+	if ((mCommitOnSelectionChange || mCommitOnKeyboardMovement))
+	{
+		onCommit();
+	}
+
+	mSearchString.clear();
+}
+
+
+
+void LLScrollListCtrl::deselectAllItems(BOOL no_commit_on_change)
+{
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item = *iter;
+		deselectItem(item);
+	}
+
+	if (mCommitOnSelectionChange && !no_commit_on_change)
+	{
+		commitIfChanged();
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// "Simple" interface: use this when you're creating a list that contains only unique strings, only
+// one of which can be selected at a time.
+
+LLScrollListItem* LLScrollListCtrl::addSimpleItem(const LLString& item_text, EAddPosition pos, BOOL enabled)
+{
+	LLScrollListItem* item = NULL;
+	if (getItemCount() < mMaxItemCount)
+	{
+		// simple items have their LLSD data set to their label
+		item = new LLScrollListItem( LLSD(item_text) );
+		item->setEnabled(enabled);
+		item->addColumn( item_text, gResMgr->getRes( LLFONT_SANSSERIF_SMALL ) );
+		addItem( item, pos );
+	}
+	return item;
+}
+
+
+// Selects first enabled item of the given name.
+// Returns false if item not found.
+BOOL LLScrollListCtrl::selectSimpleItem(const LLString& label, BOOL case_sensitive)
+{
+	//RN: assume no empty items
+	if (label.empty())
+	{
+		return FALSE;
+	}
+
+	LLString target_text = label;
+	if (!case_sensitive)
+	{
+		LLString::toLower(target_text);
+	}
+
+	BOOL found = FALSE;
+
+	item_list::iterator iter;
+	S32 index = 0;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item = *iter;
+		// Only select enabled items with matching names
+		LLString item_text = item->getColumn(0)->getText();
+		if (!case_sensitive)
+		{
+			LLString::toLower(item_text);
+		}
+		BOOL select = !found && item->getEnabled() && item_text == target_text;
+		if (select)
+		{
+			selectItem(item);
+		}
+		found = found || select;
+		index++;
+	}
+
+	if (mCommitOnSelectionChange)
+	{
+		commitIfChanged();
+	}
+
+	return found;
+}
+
+
+BOOL LLScrollListCtrl::selectSimpleItemByPrefix(const LLString& target, BOOL case_sensitive)
+{
+	return selectSimpleItemByPrefix(utf8str_to_wstring(target), case_sensitive);
+}
+
+// Selects first enabled item that has a name where the name's first part matched the target string.
+// Returns false if item not found.
+BOOL LLScrollListCtrl::selectSimpleItemByPrefix(const LLWString& target, BOOL case_sensitive)
+{
+	BOOL found = FALSE;
+
+	LLWString target_trimmed( target );
+	S32 target_len = target_trimmed.size();
+	
+	if( 0 == target_len )
+	{
+		// Is "" a valid choice?
+		item_list::iterator iter;
+		for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+		{
+			LLScrollListItem* item = *iter;
+			// Only select enabled items with matching names
+			LLScrollListCell* cellp = item->getColumn(mSearchColumn);
+			BOOL select = cellp ? item->getEnabled() && ('\0' == cellp->getText()[0]) : FALSE;
+			if (select)
+			{
+				selectItem(item);
+				found = TRUE;
+				break;
+			}
+		}
+	}
+	else
+	{
+		if (!case_sensitive)
+		{
+			// do comparisons in lower case
+			LLWString::toLower(target_trimmed);
+		}
+
+		for (item_list::iterator iter = mItemList.begin(); iter != mItemList.end(); iter++)
+		{
+			LLScrollListItem* item = *iter;
+
+			// Only select enabled items with matching names
+			LLScrollListCell* cellp = item->getColumn(mSearchColumn);
+			if (!cellp)
+			{
+				continue;
+			}
+			LLWString item_label = utf8str_to_wstring(cellp->getText());
+			if (!case_sensitive)
+			{
+				LLWString::toLower(item_label);
+			}
+			
+			BOOL select = item->getEnabled() && !item_label.compare(0, target_len, target_trimmed);
+
+			if (select)
+			{
+				selectItem(item);
+				found = TRUE;
+				break;
+			}
+		}
+	}
+
+	if (mCommitOnSelectionChange)
+	{
+		commitIfChanged();
+	}
+
+	return found;
+}
+
+const LLString& LLScrollListCtrl::getSimpleSelectedItem(S32 column) const
+{
+	LLScrollListItem* item;
+
+	item = getFirstSelected();
+	if (item)
+	{
+		return item->getColumn(column)->getText();
+	}
+
+	return LLString::null;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// "StringUUID" interface: use this when you're creating a list that contains non-unique strings each of which
+// has an associated, unique UUID, and only one of which can be selected at a time.
+
+LLScrollListItem* LLScrollListCtrl::addStringUUIDItem(const LLString& item_text, const LLUUID& id, EAddPosition pos, BOOL enabled, S32 column_width)
+{
+	LLScrollListItem* item = NULL;
+	if (getItemCount() < mMaxItemCount)
+	{
+		item = new LLScrollListItem( enabled, NULL, id );
+		item->addColumn(item_text, gResMgr->getRes(LLFONT_SANSSERIF_SMALL), column_width);
+		addItem( item, pos );
+	}
+	return item;
+}
+
+LLScrollListItem* LLScrollListCtrl::addSimpleItem(const LLString& item_text, LLSD sd, EAddPosition pos, BOOL enabled, S32 column_width)
+{
+	LLScrollListItem* item = NULL;
+	if (getItemCount() < mMaxItemCount)
+	{
+		item = new LLScrollListItem( sd );
+		item->setEnabled(enabled);
+		item->addColumn(item_text, gResMgr->getRes(LLFONT_SANSSERIF_SMALL), column_width);
+		addItem( item, pos );
+	}
+	return item;
+}
+
+
+// Select the line or lines that match this UUID
+BOOL LLScrollListCtrl::selectByID( const LLUUID& id )
+{
+	return selectByValue( LLSD(id) );
+}
+
+BOOL LLScrollListCtrl::setSelectedByValue(LLSD value, BOOL selected)
+{
+	BOOL found = FALSE;
+
+	if (selected && !mAllowMultipleSelection) deselectAllItems(TRUE);
+
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item = *iter;
+		if (item->getEnabled() && (item->getValue().asString() == value.asString()))
+		{
+			if (selected)
+			{
+				selectItem(item);
+			}
+			else
+			{
+				deselectItem(item);
+			}
+			found = TRUE;
+			break;
+		}
+	}
+
+	if (mCommitOnSelectionChange)
+	{
+		commitIfChanged();
+	}
+
+	return found;
+}
+
+BOOL LLScrollListCtrl::isSelected(LLSD value)
+{
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item = *iter;
+		if (item->getValue().asString() == value.asString())
+		{
+			return item->getSelected();
+		}
+	}
+	return FALSE;
+}
+
+LLUUID LLScrollListCtrl::getStringUUIDSelectedItem()
+{
+	LLScrollListItem* item = getFirstSelected();
+
+	if (item)
+	{
+		return item->getUUID();
+	}
+
+	return LLUUID::null;
+}
+
+LLSD LLScrollListCtrl::getSimpleSelectedValue()
+{
+	LLScrollListItem* item = getFirstSelected();
+
+	if (item)
+	{
+		return item->getValue();
+	}
+	else
+	{
+		return LLSD();
+	}
+}
+
+void LLScrollListCtrl::drawItems()
+{
+	S32 x = mItemListRect.mLeft;
+	S32 y = mItemListRect.mTop - mLineHeight;
+
+	S32 num_page_lines = mPageLines;
+
+	LLRect item_rect;
+
+	LLGLSUIDefault gls_ui;
+	
+	{
+	
+		S32 cur_x = x;
+		S32 cur_y = y;
+		
+		mDrewSelected = FALSE;
+
+		S32 line = 0;
+		LLColor4 color;
+		S32 max_columns = 0;
+
+		item_list::iterator iter;
+		for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+		{
+			LLScrollListItem* item = *iter;
+			
+			item_rect.setOriginAndSize( 
+				cur_x, 
+				cur_y, 
+				mScrollbar->getVisible() ? mItemListRect.getWidth() : mItemListRect.getWidth() + mScrollbar->getRect().getWidth(),
+				mLineHeight );
+
+			lldebugs << mItemListRect.getWidth() << llendl;
+
+			if (item->getSelected())
+			{
+				mDrewSelected = TRUE;
+			}
+
+			max_columns = llmax(max_columns, item->getNumColumns());
+
+			LLRect bg_rect = item_rect;
+			// pad background rectangle to separate it from contents
+			bg_rect.stretch(LIST_BORDER_PAD, 0);
+
+			if( mScrollLines <= line && line < mScrollLines + num_page_lines )
+			{
+				if( item->getSelected() && mCanSelect)
+				{
+					// Draw background of selected item
+					LLGLSNoTexture no_texture;
+					glColor4fv(mBgSelectedColor.mV);
+					gl_rect_2d( bg_rect );
+                    
+					color = mFgSelectedColor;
+				}
+				else if (mHighlightedItem == line && mCanSelect)
+				{
+					LLGLSNoTexture no_texture;
+					glColor4fv(mHighlightedColor.mV);
+					gl_rect_2d( bg_rect );
+					color = (item->getEnabled() ? mFgUnselectedColor : mFgDisabledColor);
+				}
+				else 
+				{
+					color = (item->getEnabled() ? mFgUnselectedColor : mFgDisabledColor);
+					if (mDrawStripes && (line%2 == 0) && (max_columns > 1))
+					{
+						LLGLSNoTexture no_texture;
+						glColor4fv(mBgStripeColor.mV);
+						gl_rect_2d( bg_rect );
+					}
+				}
+
+				S32 line_x = cur_x;
+				{
+					S32 num_cols = item->getNumColumns();
+					S32 cur_col = 0;
+					S32 dynamic_width = 0;
+					S32 dynamic_remainder = 0;
+					if(mNumDynamicWidthColumns > 0)
+					{
+						dynamic_width = (mItemListRect.getWidth() - mTotalStaticColumnWidth) / mNumDynamicWidthColumns;
+						dynamic_remainder = (mItemListRect.getWidth() - mTotalStaticColumnWidth) % mNumDynamicWidthColumns;
+					}
+					for (LLScrollListCell* cell = item->getColumn(0); cur_col < num_cols; cell = item->getColumn(++cur_col))
+					{
+						S32 cell_width = cell->getWidth();
+						if(mColumnsIndexed.size() > (U32)cur_col && mColumnsIndexed[cur_col] && mColumnsIndexed[cur_col]->mDynamicWidth)
+						{							
+							cell_width = dynamic_width + (--dynamic_remainder ? 1 : 0);
+							cell->setWidth(cell_width);
+						}
+						// Two ways a cell could be hidden
+						if (cell_width < 0
+							|| !cell->getVisible()) continue;
+						LLUI::pushMatrix();
+						LLUI::translate((F32) cur_x, (F32) cur_y, 0.0f);
+						S32 space_left = mItemListRect.mRight - cur_x;
+						LLColor4 highlight_color = LLColor4::white;
+						F32 type_ahead_timeout = LLUI::sConfigGroup->getF32("TypeAheadTimeout");
+
+						highlight_color.mV[VALPHA] = clamp_rescale(mSearchTimer.getElapsedTimeF32(), type_ahead_timeout * 0.7f, type_ahead_timeout, 0.4f, 0.f);
+						cell->drawToWidth( space_left, color, highlight_color );
+						LLUI::popMatrix();
+						
+						cur_x += cell_width + mColumnPadding;
+
+					}
+				} 
+				cur_x = line_x;			
+				cur_y -= mLineHeight;
+			}
+			line++;
+		}
+	}
+}
+
+
+void LLScrollListCtrl::draw()
+{
+	if( getVisible() )
+	{
+		LLRect background(0, mRect.getHeight(), mRect.getWidth(), 0);
+		// Draw background
+		if (mBackgroundVisible)
+		{
+			LLGLSNoTexture no_texture;
+			glColor4fv( getEnabled() ? mBgWriteableColor.mV : mBgReadOnlyColor.mV );
+			gl_rect_2d(background);
+		}
+
+		drawItems();
+
+		if (mBorder)
+		{
+			mBorder->setKeyboardFocusHighlight(gFocusMgr.getKeyboardFocus() == this);
+		}
+
+		LLUICtrl::draw();
+	}
+}
+
+void LLScrollListCtrl::setEnabled(BOOL enabled)
+{
+	mCanSelect = enabled;
+	setTabStop(enabled);
+	mScrollbar->setTabStop(!enabled && mScrollbar->getPageSize() < mScrollbar->getDocSize());
+}
+
+BOOL LLScrollListCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	BOOL handled = FALSE;
+	// Pretend the mouse is over the scrollbar
+	handled = mScrollbar->handleScrollWheel( 0, 0, clicks );
+	return handled;
+}
+
+
+BOOL LLScrollListCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
+
+	if( !handled && mCanSelect)
+	{
+		LLScrollListItem* hit_item = hitItem(x, y);
+		if( hit_item )
+		{
+			if( mAllowMultipleSelection )
+			{
+				if (mask & MASK_SHIFT)
+				{
+					if (mLastSelected == NULL)
+					{
+						selectItem(hit_item);
+					}
+					else
+					{
+						// Select everthing between mLastSelected and hit_item
+						bool selecting = false;
+						item_list::iterator itor;
+						// If we multiselect backwards, we'll stomp on mLastSelected,
+						// meaning that we never stop selecting until hitting max or
+						// the end of the list.
+						LLScrollListItem* lastSelected = mLastSelected;
+						for (itor = mItemList.begin(); itor != mItemList.end(); ++itor)
+						{
+							if(mMaxSelectable > 0 && getAllSelected().size() >= mMaxSelectable)
+							{
+								if(mOnMaximumSelectCallback)
+								{
+									mOnMaximumSelectCallback(mCallbackUserData);
+								}
+								break;
+							}
+							LLScrollListItem *item = *itor;
+                            if (item == hit_item || item == lastSelected)
+							{
+								selectItem(item, FALSE);
+								selecting = !selecting;
+							}
+							if (selecting)
+							{
+								selectItem(item, FALSE);
+							}
+						}
+					}
+				}
+				else if (mask & MASK_CONTROL)
+				{
+					if (hit_item->getSelected())
+					{
+						deselectItem(hit_item);
+					}
+					else
+					{
+						if(!(mMaxSelectable > 0 && getAllSelected().size() >= mMaxSelectable))
+						{
+							selectItem(hit_item, FALSE);
+						}
+						else
+						{
+							if(mOnMaximumSelectCallback)
+							{
+								mOnMaximumSelectCallback(mCallbackUserData);
+							}
+						}
+					}
+				}
+				else
+				{
+					deselectAllItems(TRUE);
+					selectItem(hit_item);
+				}
+			}
+			else
+			{
+				selectItem(hit_item);
+			}
+
+			hit_item->handleMouseDown(x - mBorderThickness - LIST_BORDER_PAD, 
+									  1, mask);
+			// always commit on mousedown
+			onCommit();
+			mSelectionChanged = FALSE;
+
+			// clear search string on mouse operations
+			mSearchString.clear();
+		}
+		else
+		{
+			mLastSelected = NULL;
+		}
+	}
+
+	gFocusMgr.setKeyboardFocus(this, NULL);
+
+	return TRUE;
+}
+
+BOOL LLScrollListCtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	//BOOL handled = FALSE;
+	if(getVisible())
+	{
+		// Offer the click to the children, even if we aren't enabled
+		// so the scroll bars will work.
+		if (NULL == LLView::childrenHandleDoubleClick(x, y, mask))
+		{
+			if( mCanSelect && mOnDoubleClickCallback )
+			{
+				mOnDoubleClickCallback( mCallbackUserData );
+			}
+		}
+	}
+	return TRUE;
+}
+
+LLScrollListItem* LLScrollListCtrl::hitItem( S32 x, S32 y )
+{
+	// Excludes disabled items.
+	LLScrollListItem* hit_item = NULL;
+
+	LLRect item_rect;
+	item_rect.setLeftTopAndSize( 
+		mItemListRect.mLeft,
+		mItemListRect.mTop,
+		mItemListRect.getWidth(),
+		mLineHeight );
+
+	int num_page_lines = mPageLines;
+
+	S32 line = 0;
+	item_list::iterator iter;
+	for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem* item  = *iter;
+		if( mScrollLines <= line && line < mScrollLines + num_page_lines )
+		{
+			if( item->getEnabled() && item_rect.pointInRect( x, y ) )
+			{
+				hit_item = item;
+				break;
+			}
+
+			item_rect.translate(0, -mLineHeight);
+		}
+		line++;
+	}
+
+	return hit_item;
+}
+
+
+BOOL LLScrollListCtrl::handleHover(S32 x,S32 y,MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	if(getVisible())
+	{
+		if (mCanSelect)
+		{
+			LLScrollListItem* item = hitItem(x, y);
+			if (item)
+			{
+				highlightNthItem(getItemIndex(item));
+			}
+			else
+			{
+				highlightNthItem(-1);
+			}
+		}
+
+		handled = LLView::handleHover( x, y, mask );
+
+		if( !handled )
+		{
+			// Opaque
+			getWindow()->setCursor(UI_CURSOR_ARROW);
+			lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;		
+			handled = TRUE;
+		}
+	}
+	return handled;
+}
+
+
+BOOL LLScrollListCtrl::handleKeyHere(KEY key,MASK mask, BOOL called_from_parent )
+{
+	BOOL handled = FALSE;
+
+	// not called from parent means we have keyboard focus or a child does
+	if (mCanSelect && !called_from_parent) 
+	{
+		// Ignore capslock
+		mask = mask;
+
+		if (mask == MASK_NONE)
+		{
+			switch(key)
+			{
+			case KEY_UP:
+				if (mAllowKeyboardMovement || hasFocus())
+				{
+					// commit implicit in call
+					selectPrevItem(FALSE);
+					scrollToShowSelected();
+					handled = TRUE;
+				}
+				break;
+			case KEY_DOWN:
+				if (mAllowKeyboardMovement || hasFocus())
+				{
+					// commit implicit in call
+					selectNextItem(FALSE);
+					scrollToShowSelected();
+					handled = TRUE;
+				}
+				break;
+			case KEY_PAGE_UP:
+				if (mAllowKeyboardMovement || hasFocus())
+				{
+					selectNthItem(getFirstSelectedIndex() - (mScrollbar->getPageSize() - 1));
+					scrollToShowSelected();
+					if (mCommitOnKeyboardMovement
+						&& !mCommitOnSelectionChange) 
+					{
+						onCommit();
+					}
+					handled = TRUE;
+				}
+				break;
+			case KEY_PAGE_DOWN:
+				if (mAllowKeyboardMovement || hasFocus())
+				{
+					selectNthItem(getFirstSelectedIndex() + (mScrollbar->getPageSize() - 1));
+					scrollToShowSelected();
+					if (mCommitOnKeyboardMovement
+						&& !mCommitOnSelectionChange) 
+					{
+						onCommit();
+					}
+					handled = TRUE;
+				}
+				break;
+			case KEY_HOME:
+				if (mAllowKeyboardMovement || hasFocus())
+				{
+					selectFirstItem();
+					scrollToShowSelected();
+					if (mCommitOnKeyboardMovement
+						&& !mCommitOnSelectionChange) 
+					{
+						onCommit();
+					}
+					handled = TRUE;
+				}
+				break;
+			case KEY_END:
+				if (mAllowKeyboardMovement || hasFocus())
+				{
+					selectNthItem(getItemCount() - 1);
+					scrollToShowSelected();
+					if (mCommitOnKeyboardMovement
+						&& !mCommitOnSelectionChange) 
+					{
+						onCommit();
+					}
+					handled = TRUE;
+				}
+				break;
+			case KEY_RETURN:
+				// JC - Special case: Only claim to have handled it
+				// if we're the special non-commit-on-move
+				// type. AND we are visible
+			  	if (!mCommitOnKeyboardMovement && mask == MASK_NONE && getVisible())
+				{
+					onCommit();
+					mSearchString.clear();
+					handled = TRUE;
+				}
+				break;
+			case KEY_BACKSPACE:
+				mSearchTimer.reset();
+				if (mSearchString.size())
+				{
+					mSearchString.erase(mSearchString.size() - 1, 1);
+				}
+				if (mSearchString.empty())
+				{
+					if (getFirstSelected())
+					{
+						LLScrollListCell* cellp = getFirstSelected()->getColumn(mSearchColumn);
+						if (cellp)
+						{
+							cellp->highlightText(0);
+						}
+					}
+				}
+				else if (selectSimpleItemByPrefix(wstring_to_utf8str(mSearchString), FALSE))
+				{
+					// update search string only on successful match
+					mSearchTimer.reset();
+
+					// highlight current search on matching item
+					LLScrollListCell* cellp = getFirstSelected()->getColumn(mSearchColumn);
+					if (cellp)
+					{
+						cellp->highlightText(mSearchString.size());
+					}
+
+					if (mCommitOnKeyboardMovement
+						&& !mCommitOnSelectionChange) 
+					{
+						onCommit();
+					}
+				}
+				break;
+			default:
+				break;
+			}
+		}
+		// TODO: multiple: shift-up, shift-down, shift-home, shift-end, select all
+	}
+
+	return handled;
+}
+
+BOOL LLScrollListCtrl::handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent)
+{
+	if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
+	{
+		return FALSE;
+	}
+
+	// perform incremental search based on keyboard input
+	if (mSearchTimer.getElapsedTimeF32() > LLUI::sConfigGroup->getF32("TypeAheadTimeout"))
+	{
+		mSearchString.clear();
+	}
+
+	// type ahead search is case insensitive
+	uni_char = LLStringOps::toLower((llwchar)uni_char);
+
+	if (selectSimpleItemByPrefix(wstring_to_utf8str(mSearchString + (llwchar)uni_char), FALSE))
+	{
+		// update search string only on successful match
+		mSearchString += uni_char;
+		mSearchTimer.reset();
+
+		// highlight current search on matching item
+		LLScrollListCell* cellp = getFirstSelected()->getColumn(mSearchColumn);
+		if (cellp)
+		{
+			cellp->highlightText(mSearchString.size());
+		}
+
+		if (mCommitOnKeyboardMovement
+			&& !mCommitOnSelectionChange) 
+		{
+			onCommit();
+		}
+	}
+	// handle iterating over same starting character
+	else if (isRepeatedChars(mSearchString + (llwchar)uni_char) && !mItemList.empty())
+	{
+		// start from last selected item, in case we previously had a successful match against
+		// duplicated characters ('AA' matches 'Aaron')
+		item_list::iterator start_iter = mItemList.begin();
+		S32 first_selected = getFirstSelectedIndex();
+
+		// if we have a selection (> -1) then point iterator at the selected item
+		if (first_selected > 0)
+		{
+			// point iterator to first selected item
+			start_iter += first_selected;
+		}
+
+		// start search at first item after current selection
+		item_list::iterator iter = start_iter;
+		++iter;
+		if (iter == mItemList.end())
+		{
+			iter = mItemList.begin();
+		}
+
+		// loop around once, back to previous selection
+		while(iter != start_iter)
+		{
+			LLScrollListItem* item = *iter;
+
+			LLScrollListCell* cellp = item->getColumn(mSearchColumn);
+			if (cellp)
+			{
+				// Only select enabled items with matching first characters
+				LLWString item_label = utf8str_to_wstring(cellp->getText());
+				if (item->getEnabled() && LLStringOps::toLower(item_label[0]) == uni_char)
+				{
+					selectItem(item);
+					cellp->highlightText(1);
+					mSearchTimer.reset();
+
+					if (mCommitOnKeyboardMovement
+						&& !mCommitOnSelectionChange) 
+					{
+						onCommit();
+					}
+
+					break;
+				}
+			}
+
+			++iter;
+			if (iter == mItemList.end())
+			{
+				iter = mItemList.begin();
+			}
+		}
+	}
+
+	// make sure selected item is on screen
+	scrollToShowSelected();
+	return TRUE;
+}
+
+
+void LLScrollListCtrl::reportInvalidInput()
+{
+	make_ui_sound("UISndBadKeystroke");
+}
+
+BOOL LLScrollListCtrl::isRepeatedChars(const LLWString& string) const
+{
+	if (string.empty())
+	{
+		return FALSE;
+	}
+
+	llwchar first_char = string[0];
+
+	for (U32 i = 0; i < string.size(); i++)
+	{
+		if (string[i] != first_char)
+		{
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+void LLScrollListCtrl::selectItem(LLScrollListItem* itemp, BOOL select_single_item)
+{
+	if (!itemp) return;
+
+	if (!itemp->getSelected())
+	{
+		if (mLastSelected)
+		{
+			LLScrollListCell* cellp = mLastSelected->getColumn(mSearchColumn);
+			if (cellp)
+			{
+				cellp->highlightText(0);
+			}
+		}
+		if (select_single_item)
+		{
+			deselectAllItems(TRUE);
+		}
+		itemp->setSelected(TRUE);
+		mLastSelected = itemp;
+		mSelectionChanged = TRUE;
+	}
+}
+
+void LLScrollListCtrl::deselectItem(LLScrollListItem* itemp)
+{
+	if (!itemp) return;
+
+	if (itemp->getSelected())
+	{
+		if (mLastSelected == itemp)
+		{
+			mLastSelected = NULL;
+		}
+
+		itemp->setSelected(FALSE);
+		LLScrollListCell* cellp = itemp->getColumn(mSearchColumn);
+		if (cellp)
+		{
+			cellp->highlightText(0);
+		}
+		mSelectionChanged = TRUE;
+	}
+}
+
+void LLScrollListCtrl::commitIfChanged()
+{
+	if (mSelectionChanged)
+	{
+		mSelectionChanged = FALSE;
+		onCommit();
+	}
+}
+
+// Called by scrollbar
+//static
+void LLScrollListCtrl::onScrollChange( S32 new_pos, LLScrollbar* scrollbar, void* userdata )
+{
+	LLScrollListCtrl* self = (LLScrollListCtrl*) userdata;
+	self->mScrollLines = new_pos;
+}
+
+
+// First column is column 0
+void  LLScrollListCtrl::sortByColumn(U32 column, BOOL ascending)
+{
+	LLScrollListCtrl::sSortColumn = column;
+	LLScrollListCtrl::sSortAscending = ascending;
+	std::sort(mItemList.begin(), mItemList.end(), SortScrollListItem(sSortColumn, sSortAscending));
+}
+
+void LLScrollListCtrl::sortByColumn(LLString name, BOOL ascending)
+{
+	std::map<LLString, LLScrollListColumn>::iterator itor = mColumns.find(name);
+	if (itor != mColumns.end())
+	{
+		sortByColumn((*itor).second.mIndex, ascending);
+	}
+}
+
+S32 LLScrollListCtrl::getScrollPos()
+{
+	return mScrollbar->getDocPos();
+}
+
+
+void LLScrollListCtrl::setScrollPos( S32 pos )
+{
+	mScrollbar->setDocPos( pos );
+
+	onScrollChange(mScrollbar->getDocPos(), mScrollbar, this);
+}
+
+
+void LLScrollListCtrl::scrollToShowSelected()
+{
+	S32 index = getFirstSelectedIndex();
+	if (index < 0)
+	{
+		return;
+	}
+
+	LLScrollListItem* item = mItemList[index];
+	if (!item)
+	{
+		// I don't THINK this should ever happen.
+		return;
+	}
+
+	S32 lowest = mScrollLines;
+	S32 highest = mScrollLines + mPageLines;
+
+	if (index < lowest)
+	{
+		// need to scroll to show item
+		setScrollPos(index);
+	}
+	else if (highest <= index)
+	{
+		setScrollPos(index - mPageLines + 1);
+	}
+}
+
+// virtual
+LLXMLNodePtr LLScrollListCtrl::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	// Attributes
+
+	node->createChild("multi_select", TRUE)->setBoolValue(mAllowMultipleSelection);
+
+	node->createChild("draw_border", TRUE)->setBoolValue((mBorder != NULL));
+
+	node->createChild("draw_heading", TRUE)->setBoolValue(mDisplayColumnButtons);
+
+	node->createChild("background_visible", TRUE)->setBoolValue(mBackgroundVisible);
+
+	node->createChild("draw_stripes", TRUE)->setBoolValue(mDrawStripes);
+
+	node->createChild("column_padding", TRUE)->setIntValue(mColumnPadding);
+
+	addColorXML(node, mBgWriteableColor, "bg_writeable_color", "ScrollBgWriteableColor");
+	addColorXML(node, mBgReadOnlyColor, "bg_read_only_color", "ScrollBgReadOnlyColor");
+	addColorXML(node, mBgSelectedColor, "bg_selected_color", "ScrollSelectedBGColor");
+	addColorXML(node, mBgStripeColor, "bg_stripe_color", "ScrollBGStripeColor");
+	addColorXML(node, mFgSelectedColor, "fg_selected_color", "ScrollSelectedFGColor");
+	addColorXML(node, mFgUnselectedColor, "fg_unselected_color", "ScrollUnselectedColor");
+	addColorXML(node, mFgDisabledColor, "fg_disable_color", "ScrollDisabledColor");
+	addColorXML(node, mHighlightedColor, "highlighted_color", "ScrollHighlightedColor");
+
+	// Contents
+
+	std::map<LLString, LLScrollListColumn>::const_iterator itor;
+	std::vector<const LLScrollListColumn*> sorted_list;
+	sorted_list.resize(mColumns.size());
+	for (itor = mColumns.begin(); itor != mColumns.end(); ++itor)
+	{
+		sorted_list[itor->second.mIndex] = &itor->second;
+	}
+
+	std::vector<const LLScrollListColumn*>::iterator itor2;
+	for (itor2 = sorted_list.begin(); itor2 != sorted_list.end(); ++itor2)
+	{
+		LLXMLNodePtr child_node = node->createChild("column", FALSE);
+		const LLScrollListColumn *column = *itor2;
+
+		child_node->createChild("name", TRUE)->setStringValue(column->mName);
+		child_node->createChild("label", TRUE)->setStringValue(column->mLabel);
+		child_node->createChild("width", TRUE)->setIntValue(column->mWidth);
+	}
+
+	return node;
+}
+
+void LLScrollListCtrl::setScrollListParameters(LLXMLNodePtr node)
+{
+	// James: This is not a good way to do colors. We need a central "UI style"
+	// manager that sets the colors for ALL scroll lists, buttons, etc.
+
+	LLColor4 color;
+	if(node->hasAttribute("fg_unselected_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"fg_unselected_color", color);
+		setFgUnselectedColor(color);
+	}
+	if(node->hasAttribute("fg_selected_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"fg_selected_color", color);
+		setFgSelectedColor(color);
+	}
+	if(node->hasAttribute("bg_selected_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"bg_selected_color", color);
+		setBgSelectedColor(color);
+	}
+	if(node->hasAttribute("fg_disable_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"fg_disable_color", color);
+		setFgDisableColor(color);
+	}
+	if(node->hasAttribute("bg_writeable_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"bg_writeable_color", color);
+		setBgWriteableColor(color);
+	}
+	if(node->hasAttribute("bg_read_only_color"))
+	{
+		LLUICtrlFactory::getAttributeColor(node,"bg_read_only_color", color);
+		setReadOnlyBgColor(color);
+	}
+	if (LLUICtrlFactory::getAttributeColor(node,"bg_stripe_color", color))
+	{
+		setBgStripeColor(color);
+	}
+	if (LLUICtrlFactory::getAttributeColor(node,"highlighted_color", color))
+	{
+		setHighlightedColor(color);
+	}
+
+	if(node->hasAttribute("background_visible"))
+	{
+		BOOL background_visible;
+		node->getAttributeBOOL("background_visible", background_visible);
+		setBackgroundVisible(background_visible);
+	}
+
+	if(node->hasAttribute("draw_stripes"))
+	{
+		BOOL draw_stripes;
+		node->getAttributeBOOL("draw_stripes", draw_stripes);
+		setDrawStripes(draw_stripes);
+	}
+	
+	if(node->hasAttribute("column_padding"))
+	{
+		S32 column_padding;
+		node->getAttributeS32("column_padding", column_padding);
+		setColumnPadding(column_padding);
+	}
+}
+
+// static
+LLView* LLScrollListCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("scroll_list");
+	node->getAttributeString("name", name);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	BOOL multi_select = FALSE;
+	node->getAttributeBOOL("multi_select", multi_select);
+
+	BOOL draw_border = TRUE;
+	node->getAttributeBOOL("draw_border", draw_border);
+
+	BOOL draw_heading = FALSE;
+	node->getAttributeBOOL("draw_heading", draw_heading);
+
+	BOOL collapse_empty_columns = FALSE;
+	node->getAttributeBOOL("collapse_empty_columns", collapse_empty_columns);
+
+	S32 search_column = 0;
+	node->getAttributeS32("search_column", search_column);
+
+	LLUICtrlCallback callback = NULL;
+
+	LLScrollListCtrl* scroll_list = new LLScrollListCtrl(
+		name,
+		rect,
+		callback,
+		NULL,
+		multi_select,
+		draw_border);
+	
+	scroll_list->setDisplayHeading(draw_heading);
+	if (node->hasAttribute("heading_height"))
+	{
+		S32 heading_height;
+		node->getAttributeS32("heading_height", heading_height);
+		scroll_list->setHeadingHeight(heading_height);
+	}
+	if (node->hasAttribute("heading_font"))
+	{
+		LLString heading_font("");
+		node->getAttributeString("heading_font", heading_font);
+		LLFontGL* gl_font = LLFontGL::fontFromName(heading_font.c_str());
+		scroll_list->setHeadingFont(gl_font);
+	}
+	scroll_list->setCollapseEmptyColumns(collapse_empty_columns);
+
+	scroll_list->setScrollListParameters(node);
+
+	scroll_list->initFromXML(node, parent);
+
+	scroll_list->setSearchColumn(search_column);
+
+	LLSD columns;
+	S32 index = 0;
+	LLXMLNodePtr child;
+	S32 total_static = 0, num_dynamic = 0;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		if (child->hasName("column"))
+		{
+			LLString labelname("");
+			child->getAttributeString("label", labelname);
+
+			LLString columnname(labelname);
+			child->getAttributeString("name", columnname);
+
+			LLString sortname(columnname);
+			child->getAttributeString("sort", sortname);
+
+			LLString imagename;
+			child->getAttributeString("image", imagename);
+
+			BOOL columndynamicwidth = FALSE;
+			child->getAttributeBOOL("dynamicwidth", columndynamicwidth);
+
+			S32 columnwidth = -1;
+			child->getAttributeS32("width", columnwidth);	
+
+			if(!columndynamicwidth) total_static += columnwidth;
+			else ++num_dynamic;
+
+			F32 columnrelwidth = 0.f;
+			child->getAttributeF32("relwidth", columnrelwidth);
+
+
+			columns[index]["name"] = columnname;
+			columns[index]["sort"] = sortname;
+			columns[index]["image"] = imagename;
+			columns[index]["label"] = labelname;
+			columns[index]["width"] = columnwidth;
+			columns[index]["relwidth"] = columnrelwidth;
+			columns[index]["dynamicwidth"] = columndynamicwidth;
+			index++;
+		}
+	}
+	scroll_list->setNumDynamicColumns(num_dynamic);
+	scroll_list->setTotalStaticColumnWidth(total_static);
+	scroll_list->setColumnHeadings(columns);
+
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		if (child->hasName("row"))
+		{
+			LLUUID id;
+			child->getAttributeUUID("id", id);
+
+			LLSD row;
+
+			row["id"] = id;
+
+			S32 column_idx = 0;
+			LLXMLNodePtr row_child;
+			for (row_child = child->getFirstChild(); row_child.notNull(); row_child = row_child->getNextSibling())
+			{
+				if (row_child->hasName("column"))
+				{
+					LLString value = row_child->getTextContents();
+
+					LLString columnname("");
+					row_child->getAttributeString("name", columnname);
+
+					LLString font("");
+					row_child->getAttributeString("font", font);
+
+					LLString font_style("");
+					row_child->getAttributeString("font-style", font_style);
+
+					row["columns"][column_idx]["column"] = columnname;
+					row["columns"][column_idx]["value"] = value;
+					row["columns"][column_idx]["font"] = font;
+					row["columns"][column_idx]["font-style"] = font_style;
+					column_idx++;
+				}
+			}
+			scroll_list->addElement(row);
+		}
+	}
+
+	LLString contents = node->getTextContents();
+	if (!contents.empty())
+	{
+		typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+		boost::char_separator<char> sep("\t\n");
+		tokenizer tokens(contents, sep);
+		tokenizer::iterator token_iter = tokens.begin();
+
+		while(token_iter != tokens.end())
+		{
+			const char* line = token_iter->c_str();
+			scroll_list->addSimpleItem(line);
+			++token_iter;
+		}
+	}
+	
+	return scroll_list;
+}
+
+// LLEditMenuHandler functions
+
+// virtual
+void	LLScrollListCtrl::copy()
+{
+	LLString buffer;
+
+	std::vector<LLScrollListItem*> items = getAllSelected();
+	std::vector<LLScrollListItem*>::iterator itor;
+	for (itor = items.begin(); itor != items.end(); ++itor)
+	{
+		buffer += (*itor)->getContentsCSV() + "\n";
+	}
+	gClipboard.copyFromSubstring(utf8str_to_wstring(buffer), 0, buffer.length());
+}
+
+// virtual
+BOOL	LLScrollListCtrl::canCopy()
+{
+	return (getFirstSelected() != NULL);
+}
+
+// virtual
+void	LLScrollListCtrl::cut()
+{
+	copy();
+	doDelete();
+}
+
+// virtual
+BOOL	LLScrollListCtrl::canCut()
+{
+	return canCopy() && canDoDelete();
+}
+
+// virtual
+void	LLScrollListCtrl::doDelete()
+{
+	// Not yet implemented
+}
+
+// virtual
+BOOL	LLScrollListCtrl::canDoDelete()
+{
+	// Not yet implemented
+	return FALSE;
+}
+
+// virtual
+void	LLScrollListCtrl::selectAll()
+{
+	// Deselects all other items
+	item_list::iterator iter;
+	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
+	{
+		LLScrollListItem *itemp = *iter;
+		if( itemp->getEnabled() )
+		{
+			selectItem(itemp, FALSE);
+		}
+	}
+
+	if (mCommitOnSelectionChange)
+	{
+		commitIfChanged();
+	}
+}
+
+// virtual
+BOOL	LLScrollListCtrl::canSelectAll()
+{
+	return getCanSelect() && mAllowMultipleSelection && !(mMaxSelectable > 0 && mItemList.size() > mMaxSelectable);
+}
+
+// virtual
+void	LLScrollListCtrl::deselect()
+{
+	deselectAllItems();
+}
+
+// virtual
+BOOL	LLScrollListCtrl::canDeselect()
+{
+	return getCanSelect();
+}
+
+void LLScrollListCtrl::addColumn(const LLSD& column, EAddPosition pos)
+{
+	LLString name = column["name"].asString();
+	if (mColumns.size() == 0)
+	{
+		mDefaultColumn = 0;
+	}
+	if (mColumns.find(name) == mColumns.end())
+	{
+		// Add column
+		mColumns[name] = LLScrollListColumn(column);
+		LLScrollListColumn* new_column = &mColumns[name];
+		new_column->mParentCtrl = this;
+		new_column->mIndex = mColumns.size()-1;
+
+		// Add button
+		if (new_column->mWidth > 0 || new_column->mRelWidth > 0 || new_column->mDynamicWidth)
+		{
+			if (new_column->mRelWidth >= 0)
+			{
+				new_column->mWidth = (S32)llround(new_column->mRelWidth*mItemListRect.getWidth());
+			}
+			else if(new_column->mDynamicWidth)
+			{
+				new_column->mWidth = (mItemListRect.getWidth() - mTotalStaticColumnWidth) / mNumDynamicWidthColumns;
+			}
+			S32 top = mItemListRect.mTop;
+			S32 left = mItemListRect.mLeft;
+			{
+				std::map<LLString, LLScrollListColumn>::iterator itor;
+				for (itor = mColumns.begin(); itor != mColumns.end(); ++itor)
+				{
+					if (itor->second.mIndex < new_column->mIndex &&
+						itor->second.mWidth > 0)
+					{
+						left += itor->second.mWidth + mColumnPadding;
+					}
+				}
+			}
+			LLString button_name = "btn_" + name;
+			S32 right = left+new_column->mWidth;
+			if (new_column->mIndex != (S32)mColumns.size()-1)
+			{
+				right += mColumnPadding;
+			}
+			LLRect temp_rect = LLRect(left,top+mHeadingHeight,right,top);
+			new_column->mButton = new LLSquareButton(button_name, temp_rect, "", mHeadingFont, "", onClickColumn, NULL); 
+			if(column["image"].asString() != "")
+			{
+				//new_column->mButton->setScaleImage(false);
+				new_column->mButton->setImageSelected(column["image"].asString());				
+				new_column->mButton->setImageUnselected(column["image"].asString());
+			}
+			else
+			{
+				new_column->mButton->setLabelSelected(new_column->mLabel);
+				new_column->mButton->setLabelUnselected(new_column->mLabel);
+			}
+			//RN: although it might be useful to change sort order with the keyboard,
+			// mixing tab stops on child items along with the parent item is not supported yet
+			new_column->mButton->setTabStop(FALSE);
+			addChild(new_column->mButton);
+			new_column->mButton->setVisible(mDisplayColumnButtons);
+
+
+			// Move scroll to front
+			removeChild(mScrollbar);
+			addChild(mScrollbar);
+			
+			new_column->mButton->setCallbackUserData(new_column);
+		}
+	}
+	updateColumns();
+}
+
+// static
+void LLScrollListCtrl::onClickColumn(void *userdata)
+{
+	LLScrollListColumn *info = (LLScrollListColumn*)userdata;
+	if (!info) return;
+
+	U32 column_index = info->mIndex;
+
+	LLScrollListColumn* column = info->mParentCtrl->mColumnsIndexed[info->mIndex];
+	if (column->mSortingColumn != column->mName)
+	{
+		if (info->mParentCtrl->mColumns.find(column->mSortingColumn) != info->mParentCtrl->mColumns.end())
+		{
+			LLScrollListColumn& info_redir = info->mParentCtrl->mColumns[column->mSortingColumn];
+			column_index = info_redir.mIndex;
+		}
+	}
+
+	// TomY TODO: shouldn't these be non-static members?
+	bool ascending = true;
+	if (column_index == LLScrollListCtrl::sSortColumn)
+	{
+		ascending = !LLScrollListCtrl::sSortAscending;
+	}
+
+	info->mParentCtrl->sortByColumn(column_index, ascending);
+}
+
+void LLScrollListCtrl::clearColumns()
+{
+	std::map<LLString, LLScrollListColumn>::iterator itor;
+	for (itor = mColumns.begin(); itor != mColumns.end(); ++itor)
+	{
+		LLButton *button = itor->second.mButton;
+		if (button)
+		{
+			removeChild(button);
+			delete button;
+		}
+	}
+	mColumns.clear();
+}
+
+void LLScrollListCtrl::setColumnLabel(const LLString& column, const LLString& label)
+{
+	std::map<LLString, LLScrollListColumn>::iterator itor = mColumns.find(column);
+	if (itor != mColumns.end())
+	{
+		itor->second.mLabel = label;
+		if (itor->second.mButton)
+		{
+			itor->second.mButton->setLabelSelected(label);
+			itor->second.mButton->setLabelUnselected(label);
+		}
+	}
+}
+
+void LLScrollListCtrl::setColumnHeadings(LLSD headings)
+{
+	mColumns.clear();
+	LLSD::array_const_iterator itor;
+	for (itor = headings.beginArray(); itor != headings.endArray(); ++itor)
+	{
+		addColumn(*itor);
+	}
+}
+
+LLScrollListItem* LLScrollListCtrl::addElement(const LLSD& value, EAddPosition pos, void* userdata)
+{
+	// ID
+	LLSD id = value["id"];
+
+	LLScrollListItem *new_item = new LLScrollListItem(id, userdata);
+	if (value.has("enabled"))
+	{
+		new_item->setEnabled( value["enabled"].asBoolean() );
+	}
+
+	new_item->setNumColumns(mColumns.size());
+
+	// Add any columns we don't already have
+	LLSD columns = value["columns"];
+	LLSD::array_const_iterator itor;
+	for (itor = columns.beginArray(); itor != columns.endArray(); ++itor)
+	{
+		LLString column = (*itor)["column"].asString();
+
+		if (mColumns.size() == 0)
+		{
+			mDefaultColumn = 0;
+		}
+		std::map<LLString, LLScrollListColumn>::iterator column_itor = mColumns.find(column);
+		if (column_itor == mColumns.end())
+		{
+			LLSD new_column;
+			new_column["name"] = column;
+			new_column["label"] = column;
+			new_column["width"] = 0;
+			addColumn(new_column);
+			column_itor = mColumns.find(column);
+			new_item->setNumColumns(mColumns.size());
+		}
+
+		S32 index = column_itor->second.mIndex;
+		S32 width = column_itor->second.mWidth;
+
+		LLSD value = (*itor)["value"];
+		LLString fontname = (*itor)["font"].asString();
+		LLString fontstyle = (*itor)["font-style"].asString();
+		LLString type = (*itor)["type"].asString();
+
+		const LLFontGL *font = gResMgr->getRes(fontname);
+		if (!font)
+		{
+			font = gResMgr->getRes( LLFONT_SANSSERIF_SMALL );
+		}
+		U8 font_style = LLFontGL::getStyleFromString(fontstyle);
+
+		if (type == "icon")
+		{
+			LLUUID image_id = value.asUUID();
+			LLImageGL* icon = LLUI::sImageProvider->getUIImageByID(image_id);
+			new_item->setColumn(index, new LLScrollListIcon(icon, width, image_id));
+		}
+		else if (type == "checkbox")
+		{
+			LLCheckBoxCtrl* ctrl = new LLCheckBoxCtrl(value.asString(),
+														LLRect(0, 0, width, width), "label");
+			new_item->setColumn(index, new LLScrollListCheck(ctrl,width));
+		}
+		else
+		{
+			new_item->setColumn(index, new LLScrollListText(value.asString(), font, width, font_style));
+		}
+	}
+
+	S32 num_columns = mColumns.size();
+	for (S32 column = 0; column < num_columns; ++column)
+	{
+		if (new_item->getColumn(column) == NULL)
+		{
+			LLScrollListColumn* column_ptr = mColumnsIndexed[column];
+			new_item->setColumn(column, new LLScrollListText("", gResMgr->getRes( LLFONT_SANSSERIF_SMALL ), column_ptr->mWidth, LLFontGL::NORMAL));
+		}
+	}
+
+	addItem(new_item, pos);
+
+	return new_item;
+}
+
+LLScrollListItem* LLScrollListCtrl::addSimpleElement(const LLString& value, EAddPosition pos, const LLSD& id)
+{
+	LLSD entry_id = id;
+
+	if (id.isUndefined())
+	{
+		entry_id = value;
+	}
+
+	LLScrollListItem *new_item = new LLScrollListItem(entry_id);
+
+	const LLFontGL *font = gResMgr->getRes( LLFONT_SANSSERIF_SMALL );
+
+	new_item->addColumn(value, font, getRect().getWidth());
+
+	addItem(new_item, pos);
+	return new_item;
+}
+
+void LLScrollListCtrl::setValue(const LLSD& value )
+{
+	LLSD::array_const_iterator itor;
+	for (itor = value.beginArray(); itor != value.endArray(); ++itor)
+	{
+		addElement(*itor);
+	}
+}
+
+LLSD LLScrollListCtrl::getValue() const
+{
+	LLScrollListItem *item = getFirstSelected();
+	if (!item) return LLSD();
+	return item->getValue();
+}
+
+BOOL LLScrollListCtrl::operateOnSelection(EOperation op)
+{
+	if (op == OP_DELETE)
+	{
+		deleteSelectedItems();
+		return TRUE;
+	}
+	else if (op == OP_DESELECT)
+	{
+		deselectAllItems();
+	}
+	return FALSE;
+}
+
+BOOL LLScrollListCtrl::operateOnAll(EOperation op)
+{
+	if (op == OP_DELETE)
+	{
+		clearRows();
+		return TRUE;
+	}
+	else if (op == OP_DESELECT)
+	{
+		deselectAllItems();
+	}
+	else if (op == OP_SELECT)
+	{
+		selectAll();
+	}
+	return FALSE;
+}
+//virtual 
+void LLScrollListCtrl::setFocus(BOOL b)
+{
+	mSearchString.clear();
+	// for tabbing into pristine scroll lists (Finder)
+	if (!getFirstSelected())
+	{
+		selectFirstItem();
+		onCommit();
+	}
+	LLUICtrl::setFocus(b);
+}
+//virtual 
+void LLScrollListCtrl::onFocusLost()
+{
+	if (mIsPopup)
+	{
+		if (getParent())
+		{
+			getParent()->onFocusLost();
+		}
+	}
+}
diff --git a/indra/llui/llscrolllistctrl.h b/indra/llui/llscrolllistctrl.h
new file mode 100644
index 0000000000..426e817215
--- /dev/null
+++ b/indra/llui/llscrolllistctrl.h
@@ -0,0 +1,527 @@
+/** 
+ * @file llscrolllistctrl.h
+ * @brief LLScrollListCtrl base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_SCROLLLISTCTRL_H
+#define LL_SCROLLLISTCTRL_H
+
+#include <vector>
+#include <deque>
+
+#include "lluictrl.h"
+#include "llctrlselectioninterface.h"
+#include "llfontgl.h"
+#include "llui.h"
+#include "llstring.h"
+#include "llimagegl.h"
+#include "lleditmenuhandler.h"
+#include "llviewborder.h"
+#include "llframetimer.h"
+#include "llcheckboxctrl.h"
+
+class LLScrollbar;
+class LLScrollListCtrl;
+
+class LLScrollListCell
+{
+public:
+	virtual ~LLScrollListCell() {};
+	virtual void			drawToWidth(S32 width, const LLColor4& color, const LLColor4& highlight_color) const = 0;		// truncate to given width, if possible
+	virtual S32				getWidth() const = 0;
+	virtual S32				getHeight() const = 0;
+	virtual const LLString&	getText() const { return LLString::null; }
+	virtual const LLString&	getTextLower() const { return LLString::null; }
+	virtual const BOOL		getVisible() const { return TRUE; }
+	virtual void			setWidth(S32 width) = 0;
+	virtual void			highlightText(S32 num_chars) {}
+
+	virtual BOOL	handleClick() { return FALSE; }
+	virtual	void	setEnabled(BOOL enable) { }
+};
+
+class LLScrollListText : public LLScrollListCell
+{
+	static U32 sCount;
+public:
+	LLScrollListText( const LLString& text, const LLFontGL* font, S32 width = 0, U8 font_style = LLFontGL::NORMAL, LLColor4& color = LLColor4::black, BOOL use_color = FALSE, BOOL visible = TRUE);
+	/*virtual*/ ~LLScrollListText();
+
+	virtual void    drawToWidth(S32 width, const LLColor4& color, const LLColor4& highlight_color) const;
+	virtual S32		getWidth() const			{ return mWidth; }
+	virtual void	setWidth(S32 width)			{ mWidth = width; }
+	virtual S32		getHeight() const			{ return llround(mFont->getLineHeight()); }
+	virtual const LLString&		getText() const		{ return mText.getString(); }
+	virtual const BOOL			getVisible() const  { return mVisible; }
+	virtual void	highlightText(S32 num_chars) {mHighlightChars = num_chars;}
+	void			setText(const LLString& text);
+
+private:
+	LLUIString		mText;
+	const LLFontGL*	mFont;
+	LLColor4*		mColor;
+	const U8		mFontStyle;
+	S32				mWidth;
+	S32				mEllipsisWidth;	// in pixels, of "..."
+	BOOL			mVisible;
+	S32				mHighlightChars;
+
+	LLPointer<LLImageGL> mRoundedRectImage;
+};
+
+class LLScrollListIcon : public LLScrollListCell
+{
+public:
+	LLScrollListIcon( LLImageGL* icon, S32 width = 0, LLUUID image_id = LLUUID::null);
+	/*virtual*/ ~LLScrollListIcon();
+	virtual void	drawToWidth(S32 width, const LLColor4& color, const LLColor4& highlight_color) const	{ gl_draw_image(0, 0, mIcon); }
+	virtual S32		getWidth() const			{ return mWidth; }
+	virtual S32		getHeight() const			{ return mIcon->getHeight(); }
+	virtual const LLString& getText() const { return mImageUUID; }
+	virtual const LLString& getTextLower() const { return mImageUUID; }
+	virtual void	setWidth(S32 width)			{ mWidth = width; }
+
+private:
+	LLPointer<LLImageGL> mIcon;
+	LLString mImageUUID;
+	S32 mWidth;
+};
+
+class LLScrollListCheck : public LLScrollListCell
+{
+public:
+	LLScrollListCheck( LLCheckBoxCtrl* check_box, S32 width = 0);
+	/*virtual*/ ~LLScrollListCheck();
+	virtual void	drawToWidth(S32 width, const LLColor4& color, const LLColor4& highlight_color) const;
+	virtual S32		getWidth() const			{ return mWidth; }
+	virtual S32		getHeight() const			{ return 0; } 
+	virtual void	setWidth(S32 width)			{ mWidth = width; }
+
+	virtual BOOL	handleClick();
+	virtual void	setEnabled(BOOL enable)		{ if (mCheckBox) mCheckBox->setEnabled(enable); }
+
+	LLCheckBoxCtrl*	getCheckBox()				{ return mCheckBox; }
+
+private:
+	LLCheckBoxCtrl* mCheckBox;
+	S32 mWidth;
+};
+
+class LLScrollListColumn
+{
+public:
+	// Default constructor
+	LLScrollListColumn() : mName(""), mSortingColumn(""), mLabel(""), mWidth(-1), mRelWidth(-1.0), mDynamicWidth(FALSE), mIndex(-1), mParentCtrl(NULL), mButton(NULL) { }
+
+	LLScrollListColumn(LLString name, LLString label, S32 width, F32 relwidth)
+		: mName(name), mSortingColumn(name), mLabel(label), mWidth(width), mRelWidth(relwidth), mDynamicWidth(FALSE), mIndex(-1), mParentCtrl(NULL), mButton(NULL) { }
+
+	LLScrollListColumn(const LLSD &sd)
+	{
+		mName = sd.get("name").asString();
+		mSortingColumn = mName;
+		if (sd.has("sort"))
+		{
+			mSortingColumn = sd.get("sort").asString();
+		}
+		mLabel = sd.get("label").asString();
+		if (sd.has("relwidth") && (F32)sd.get("relwidth").asReal() > 0)
+		{
+			mRelWidth = (F32)sd.get("relwidth").asReal();
+			if (mRelWidth < 0) mRelWidth = 0;
+			if (mRelWidth > 1) mRelWidth = 1;
+			mDynamicWidth = FALSE;
+			mWidth = 0;
+		}
+		else if(sd.has("dynamicwidth") && (BOOL)sd.get("dynamicwidth").asBoolean() == TRUE)
+		{
+			mDynamicWidth = TRUE;
+			mRelWidth = -1;
+			mWidth = 0;
+		}
+		else
+		{
+			mWidth = sd.get("width").asInteger();
+			mDynamicWidth = FALSE;
+			mRelWidth = -1;
+		}
+		mIndex = -1;
+		mParentCtrl = NULL;
+		mButton = NULL;
+	}
+
+	LLString mName;
+	LLString mSortingColumn;
+	LLString mLabel;
+	S32 mWidth;
+	F32 mRelWidth;
+	BOOL mDynamicWidth;
+	S32 mIndex;
+	LLScrollListCtrl *mParentCtrl;
+	LLButton *mButton;
+};
+
+class LLScrollListItem
+{
+public:
+	LLScrollListItem( BOOL enabled = TRUE, void* userdata = NULL, const LLUUID& uuid = LLUUID::null )
+		: mSelected(FALSE), mEnabled( enabled ), mUserdata( userdata ), mItemValue( uuid ), mColumns() {}
+	LLScrollListItem( LLSD item_value, void* userdata = NULL )
+		: mSelected(FALSE), mEnabled( TRUE ), mUserdata( userdata ), mItemValue( item_value ), mColumns() {}
+
+	virtual ~LLScrollListItem();
+
+	void	setSelected( BOOL b )			{ mSelected = b; }
+	BOOL	getSelected() const				{ return mSelected; }
+
+	void	setEnabled( BOOL b );
+	BOOL	getEnabled() const 				{ return mEnabled; }
+
+	void	setUserdata( void* userdata )	{ mUserdata = userdata; }
+	void*	getUserdata() const 			{ return mUserdata; }
+
+	LLUUID	getUUID() const					{ return mItemValue.asUUID(); }
+	LLSD	getValue() const				{ return mItemValue; }
+
+	// If width = 0, just use the width of the text.  Otherwise override with
+	// specified width in pixels.
+	void	addColumn( const LLString& text, const LLFontGL* font, S32 width = 0 , U8 font_style = LLFontGL::NORMAL, BOOL visible = TRUE)
+				{ mColumns.push_back( new LLScrollListText(text, font, width, font_style, LLColor4::black, FALSE, visible) ); }
+
+	void	addColumn( LLImageGL* icon, S32 width = 0 )
+				{ mColumns.push_back( new LLScrollListIcon(icon, width) ); }
+
+	void	addColumn( LLCheckBoxCtrl* check, S32 width = 0 )
+				{ mColumns.push_back( new LLScrollListCheck(check,width) ); }
+
+	void	setNumColumns(S32 columns);
+
+	void	setColumn( S32 column, LLScrollListCell *cell );
+	
+	S32		getNumColumns() const				{ return mColumns.size(); }
+
+	LLScrollListCell *getColumn(const S32 i) const	{ if (i < (S32)mColumns.size()) { return mColumns[i]; } return NULL; }
+
+	virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+
+	LLString getContentsCSV();
+
+private:
+	BOOL	mSelected;
+	BOOL	mEnabled;
+	void*	mUserdata;
+	LLSD	mItemValue;
+	std::vector<LLScrollListCell *> mColumns;
+};
+
+
+class LLScrollListCtrl : public LLUICtrl, public LLEditMenuHandler, 
+	public LLCtrlListInterface, public LLCtrlScrollInterface
+{
+public:
+	LLScrollListCtrl(
+		const LLString& name,
+		const LLRect& rect,
+		void (*commit_callback)(LLUICtrl*, void*),
+		void* callback_userdata,
+		BOOL allow_multiple_selection,
+		BOOL draw_border = TRUE);
+
+	virtual ~LLScrollListCtrl();
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_SCROLL_LIST; }
+	virtual LLString getWidgetTag() const { return LL_SCROLL_LIST_CTRL_TAG; }
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	void setScrollListParameters(LLXMLNodePtr node);
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	S32				isEmpty() const;
+
+	void			deleteAllItems() { clearRows(); }
+	
+	// Sets an array of column descriptors
+	void 	   		 setColumnHeadings(LLSD headings);
+	// Numerical based sort by column function (used by LLComboBox)
+	void   			 sortByColumn(U32 column, BOOL ascending);
+	
+	// LLCtrlListInterface functions
+	virtual S32  getItemCount() const;
+	// Adds a single column descriptor: ["name" : string, "label" : string, "width" : integer, "relwidth" : integer ]
+	virtual void addColumn(const LLSD& column, EAddPosition pos = ADD_BOTTOM);
+	virtual void clearColumns();
+	virtual void setColumnLabel(const LLString& column, const LLString& label);
+	// Adds a single element, from an array of:
+	// "columns" => [ "column" => column name, "value" => value, "type" => type, "font" => font, "font-style" => style ], "id" => uuid
+	// Creates missing columns automatically.
+	virtual LLScrollListItem* addElement(const LLSD& value, EAddPosition pos = ADD_BOTTOM, void* userdata = NULL);
+	// Simple add element. Takes a single array of:
+	// [ "value" => value, "font" => font, "font-style" => style ]
+	virtual LLScrollListItem* addSimpleElement(const LLString& value, EAddPosition pos = ADD_BOTTOM, const LLSD& id = LLSD());
+	virtual void clearRows(); // clears all elements
+	virtual void sortByColumn(LLString name, BOOL ascending);
+
+	// These functions take and return an array of arrays of elements, as above
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+
+	LLCtrlSelectionInterface*	getSelectionInterface()	{ return (LLCtrlSelectionInterface*)this; }
+	LLCtrlListInterface*		getListInterface()		{ return (LLCtrlListInterface*)this; }
+	LLCtrlScrollInterface*		getScrollInterface()	{ return (LLCtrlScrollInterface*)this; }
+
+	// DEPRECATED: Use setSelectedByValue() below.
+	BOOL			setCurrentByID( const LLUUID& id )	{ return selectByID(id); }
+	virtual LLUUID	getCurrentID()						{ return getStringUUIDSelectedItem(); }
+
+	BOOL			operateOnSelection(EOperation op);
+	BOOL			operateOnAll(EOperation op);
+
+	// returns FALSE if unable to set the max count so low
+	BOOL 			setMaxItemCount(S32 max_count);
+
+	BOOL			selectByID( const LLUUID& id );		// FALSE if item not found
+
+	// Match item by value.asString(), which should work for string, integer, uuid.
+	// Returns FALSE if not found.
+	BOOL			setSelectedByValue(LLSD value, BOOL selected);
+
+	virtual BOOL	isSelected(LLSD value);
+
+	BOOL			selectFirstItem();
+	BOOL			selectNthItem( S32 index );
+
+	void			deleteSingleItem( S32 index ) ;
+	void 			deleteSelectedItems();
+	void			deselectAllItems(BOOL no_commit_on_change = FALSE);	// by default, go ahead and commit on selection change
+
+	void			highlightNthItem( S32 index );
+	void			setDoubleClickCallback( void (*cb)(void*) ) { mOnDoubleClickCallback = cb; }
+	void			setMaxiumumSelectCallback( void (*cb)(void*) ) { mOnMaximumSelectCallback = cb; }
+
+	void			swapWithNext(S32 index);
+	void			swapWithPrevious(S32 index);
+
+	void			setCanSelect(BOOL can_select)		{ mCanSelect = can_select; }
+	virtual BOOL	getCanSelect() const				{ return mCanSelect; }
+
+	S32				getItemIndex( LLScrollListItem* item );
+	S32				getItemIndex( LLUUID& item_id );
+
+	// "Simple" interface: use this when you're creating a list that contains only unique strings, only
+	// one of which can be selected at a time.
+	LLScrollListItem* addSimpleItem( const LLString& item_text, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE );
+	// Add an item with an associated LLSD
+	LLScrollListItem* addSimpleItem(const LLString& item_text, LLSD sd, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE, S32 column_width = 0 );
+
+	BOOL			selectSimpleItem( const LLString& item, BOOL case_sensitive = TRUE );		// FALSE if item not found
+	BOOL			selectSimpleItemByPrefix(const LLString& target, BOOL case_sensitive);
+	BOOL			selectSimpleItemByPrefix(const LLWString& target, BOOL case_sensitive);
+	const LLString&	getSimpleSelectedItem(S32 column = 0) const;
+	LLSD			getSimpleSelectedValue();
+
+	// DEPRECATED: Use LLSD versions of addSimpleItem() and getSimpleSelectedValue().
+	// "StringUUID" interface: use this when you're creating a list that contains non-unique strings each of which
+	// has an associated, unique UUID, and only one of which can be selected at a time.
+	LLScrollListItem*	addStringUUIDItem(const LLString& item_text, const LLUUID& id, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE, S32 column_width = 0);
+	LLUUID				getStringUUIDSelectedItem();
+
+	// "Full" interface: use this when you're creating a list that has one or more of the following:
+	// * contains icons
+	// * contains multiple columns
+	// * allows multiple selection
+	// * has items that are not guarenteed to have unique names
+	// * has additional per-item data (e.g. a UUID or void* userdata)
+	//
+	// To add items using this approach, create new LLScrollListItems and LLScrollListCells.  Add the
+	// cells (column entries) to each item, and add the item to the LLScrollListCtrl.
+	//
+	// The LLScrollListCtrl owns its items and is responsible for deleting them
+	// (except in the case that the addItem() call fails, in which case it is up
+	// to the caller to delete the item)
+
+	// returns FALSE if item faile to be added to list, does NOT delete 'item'
+	// TomY TODO - Deprecate this API and remove it
+	BOOL				addItem( LLScrollListItem* item, EAddPosition pos = ADD_BOTTOM );
+	LLScrollListItem*	getFirstSelected() const;
+	virtual S32			getFirstSelectedIndex();
+	std::vector<LLScrollListItem*> getAllSelected() const;
+
+	LLScrollListItem*	getLastSelectedItem() const { return mLastSelected; }
+
+	// iterate over all items
+	LLScrollListItem*	getFirstData() const;
+	std::vector<LLScrollListItem*>	getAllData() const;
+	
+	void setAllowMultipleSelection(BOOL mult )	{ mAllowMultipleSelection = mult; }
+
+	void setBgWriteableColor(const LLColor4 &c)	{ mBgWriteableColor = c; }
+	void setReadOnlyBgColor(const LLColor4 &c)	{ mBgReadOnlyColor = c; }
+	void setBgSelectedColor(const LLColor4 &c)	{ mBgSelectedColor = c; }
+	void setBgStripeColor(const LLColor4& c)	{ mBgStripeColor = c; }
+	void setFgSelectedColor(const LLColor4 &c)	{ mFgSelectedColor = c; }
+	void setFgUnselectedColor(const LLColor4 &c){ mFgUnselectedColor = c; }
+	void setHighlightedColor(const LLColor4 &c)	{ mHighlightedColor = c; }
+	void setFgDisableColor(const LLColor4 &c)	{ mFgDisabledColor = c; }
+
+	void setBackgroundVisible(BOOL b)			{ mBackgroundVisible = b; }
+	void setDrawStripes(BOOL b)					{ mDrawStripes = b; }
+	void setColumnPadding(const S32 c)          { mColumnPadding = c; }
+	void setCommitOnKeyboardMovement(BOOL b)	{ mCommitOnKeyboardMovement = b; }
+	void setCommitOnSelectionChange(BOOL b)		{ mCommitOnSelectionChange = b; }
+	void setAllowKeyboardMovement(BOOL b)		{ mAllowKeyboardMovement = b; }
+
+	void			setMaxSelectable(U32 max_selected) { mMaxSelectable = max_selected; }
+	S32				getMaxSelectable() { return mMaxSelectable; }
+
+
+	virtual S32		getScrollPos();
+	virtual void	setScrollPos( S32 pos );
+
+	S32				getSearchColumn() { return mSearchColumn; }
+	void			setSearchColumn(S32 column) { mSearchColumn = column; }
+
+	void			clearSearchString() { mSearchString.clear(); }
+
+	// Overridden from LLView
+	virtual void    draw();
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL	handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent);
+	virtual BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	virtual void	setEnabled(BOOL enabled);
+	virtual void	setFocus( BOOL b );
+	virtual void	onFocusLost();
+
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+	virtual void	arrange(S32 max_width, S32 max_height);
+	virtual LLRect	getRequiredRect();
+	static  BOOL    rowPreceeds(LLScrollListItem *new_row, LLScrollListItem *test_row);
+
+	// Used "internally" by the scroll bar.
+	static void		onScrollChange( S32 new_pos, LLScrollbar* src, void* userdata );
+
+	static void onClickColumn(void *userdata);
+
+	void updateColumns();
+	void updateColumnButtons();
+
+	void setDisplayHeading(BOOL display);
+	void setHeadingHeight(S32 heading_height);
+	void setHeadingFont(const LLFontGL* heading_font);
+	void setCollapseEmptyColumns(BOOL collapse);
+	void setIsPopup(BOOL is_popup) { mIsPopup = is_popup; }
+
+	LLScrollListItem*	hitItem(S32 x,S32 y);
+	virtual void		scrollToShowSelected();
+
+	// LLEditMenuHandler functions
+	virtual void	copy();
+	virtual BOOL	canCopy();
+
+	virtual void	cut();
+	virtual BOOL	canCut();
+
+	virtual void	doDelete();
+	virtual BOOL	canDoDelete();
+
+	virtual void	selectAll();
+	virtual BOOL	canSelectAll();
+
+	virtual void	deselect();
+	virtual BOOL	canDeselect();
+
+	void setNumDynamicColumns(int num) { mNumDynamicWidthColumns = num; }
+	void setTotalStaticColumnWidth(int width) { mTotalStaticColumnWidth = width; }
+
+protected:
+	void			selectPrevItem(BOOL extend_selection);
+	void			selectNextItem(BOOL extend_selection);
+	void			drawItems();
+	void			updateLineHeight();
+	void			reportInvalidInput();
+	BOOL			isRepeatedChars(const LLWString& string) const;
+	void			selectItem(LLScrollListItem* itemp, BOOL single_select = TRUE);
+	void			deselectItem(LLScrollListItem* itemp);
+	void			commitIfChanged();
+
+protected:
+	S32				mCurIndex;			// For get[First/Next]Data
+	S32				mCurSelectedIndex;  // For get[First/Next]Selected
+
+	S32				mLineHeight;	// the max height of a single line
+	S32				mScrollLines;	// how many lines we've scrolled down
+	S32				mPageLines;		// max number of lines is it possible to see on the screen given mRect and mLineHeight
+	S32				mHeadingHeight;	// the height of the column header buttons, if visible
+	U32				mMaxSelectable; 
+	const LLFontGL*	mHeadingFont;	// the font to use for column head buttons, if visible
+	LLScrollbar*	mScrollbar;
+	BOOL 			mAllowMultipleSelection;
+	BOOL			mAllowKeyboardMovement;
+	BOOL			mCommitOnKeyboardMovement;
+	BOOL			mCommitOnSelectionChange;
+	BOOL			mSelectionChanged;
+	BOOL			mCanSelect;
+	BOOL			mDisplayColumnButtons;
+	BOOL			mCollapseEmptyColumns;
+	BOOL			mIsPopup;
+
+	typedef std::deque<LLScrollListItem *> item_list;
+	item_list		mItemList;
+
+	LLScrollListItem *mLastSelected;
+
+	S32				mMaxItemCount; 
+
+	LLRect			mItemListRect;
+
+	S32             mColumnPadding;
+
+	BOOL			mBackgroundVisible;
+	BOOL			mDrawStripes;
+
+	LLColor4		mBgWriteableColor;
+	LLColor4		mBgReadOnlyColor;
+	LLColor4		mBgSelectedColor;
+	LLColor4		mBgStripeColor;
+	LLColor4		mFgSelectedColor;
+	LLColor4		mFgUnselectedColor;
+	LLColor4		mFgDisabledColor;
+	LLColor4		mHighlightedColor;
+
+	S32				mBorderThickness;
+	void			(*mOnDoubleClickCallback)(void* userdata);
+	void			(*mOnMaximumSelectCallback)(void* userdata );
+
+	S32				mHighlightedItem;
+	LLViewBorder*	mBorder;
+
+	LLWString		mSearchString;
+	LLFrameTimer	mSearchTimer;
+	
+	LLString		mDefaultColumn;
+
+	S32				mSearchColumn;
+	S32				mNumDynamicWidthColumns;
+	S32				mTotalStaticColumnWidth;
+
+	static U32      sSortColumn;
+	static BOOL     sSortAscending;
+
+	std::map<LLString, LLScrollListColumn> mColumns;
+	std::vector<LLScrollListColumn*> mColumnsIndexed;
+
+public:
+	// HACK:  Did we draw one selected item this frame?
+	BOOL mDrewSelected;
+};
+
+const BOOL MULTIPLE_SELECT_YES = TRUE;
+const BOOL MULTIPLE_SELECT_NO = FALSE;
+
+const BOOL SHOW_BORDER_YES = TRUE;
+const BOOL SHOW_BORDER_NO = FALSE;
+
+#endif  // LL_SCROLLLISTCTRL_H
diff --git a/indra/llui/llslider.cpp b/indra/llui/llslider.cpp
new file mode 100644
index 0000000000..2a1c2f7845
--- /dev/null
+++ b/indra/llui/llslider.cpp
@@ -0,0 +1,352 @@
+/** 
+ * @file llslider.cpp
+ * @brief LLSlider base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llslider.h"
+#include "llui.h"
+
+#include "llgl.h"
+#include "llwindow.h"
+#include "llfocusmgr.h"
+#include "llkeyboard.h"			// for the MASK constants
+#include "llcontrol.h"
+#include "llimagegl.h"
+
+const S32 THUMB_WIDTH = 8;
+const S32 TRACK_HEIGHT = 6;
+
+LLSlider::LLSlider( 
+	const LLString& name,
+	const LLRect& rect,
+	void (*on_commit_callback)(LLUICtrl* ctrl, void* userdata),
+	void* callback_userdata,
+	F32 initial_value,
+	F32 min_value,
+	F32 max_value,
+	F32 increment,
+	const LLString& control_name)
+	:
+	LLUICtrl( name, rect, TRUE,	on_commit_callback, callback_userdata, 
+		FOLLOWS_LEFT | FOLLOWS_TOP),
+	mValue( initial_value ),
+	mInitialValue( initial_value ),
+	mMinValue( min_value ),
+	mMaxValue( max_value ),
+	mIncrement( increment ),
+	mMouseOffset( 0 ),
+	mDragStartThumbRect( 0, mRect.getHeight(), THUMB_WIDTH, 0 ),
+	mThumbRect( 0, mRect.getHeight(), THUMB_WIDTH, 0 ),
+	mTrackColor(		LLUI::sColorsGroup->getColor( "SliderTrackColor" ) ),
+	mThumbOutlineColor(	LLUI::sColorsGroup->getColor( "SliderThumbOutlineColor" ) ),
+	mThumbCenterColor(	LLUI::sColorsGroup->getColor( "SliderThumbCenterColor" ) ),
+	mDisabledThumbColor(LLUI::sColorsGroup->getColor( "SliderDisabledThumbColor" ) ),
+	mMouseDownCallback( NULL ),
+	mMouseUpCallback( NULL )
+{
+	// prperly handle setting the starting thumb rect
+	// do it this way to handle both the operating-on-settings
+	// and standalone ways of using this
+	setControlName(control_name, NULL);
+	setValue(getValueF32());
+}
+
+EWidgetType LLSlider::getWidgetType() const
+{
+	return WIDGET_TYPE_SLIDER_BAR;
+}
+
+LLString LLSlider::getWidgetTag() const
+{
+	return LL_SLIDER_TAG;
+}
+
+void LLSlider::setValue(F32 value, BOOL from_event)
+{
+	value = llclamp( value, mMinValue, mMaxValue );
+
+	// Round to nearest increment (bias towards rounding down)
+	value -= mMinValue;
+	value += mIncrement/2.0001f;
+	value -= fmod(value, mIncrement);
+	mValue = mMinValue + value;
+
+	if (!from_event)
+	{
+		setControlValue(mValue);
+	}
+	
+	F32 t = (mValue - mMinValue) / (mMaxValue - mMinValue);
+
+	S32 left_edge = THUMB_WIDTH/2;
+	S32 right_edge = mRect.getWidth() - (THUMB_WIDTH/2);
+
+	S32 x = left_edge + S32( t * (right_edge - left_edge) );
+	mThumbRect.mLeft = x - (THUMB_WIDTH/2);
+	mThumbRect.mRight = x + (THUMB_WIDTH/2);
+}
+
+F32 LLSlider::getValueF32() const
+{
+	return mValue;
+}
+
+BOOL LLSlider::handleHover(S32 x, S32 y, MASK mask)
+{
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		S32 left_edge = THUMB_WIDTH/2;
+		S32 right_edge = mRect.getWidth() - (THUMB_WIDTH/2);
+
+		x += mMouseOffset;
+		x = llclamp( x, left_edge, right_edge );
+
+		F32 t = F32(x - left_edge) / (right_edge - left_edge);
+		setValue(t * (mMaxValue - mMinValue) + mMinValue );
+		onCommit();
+
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;		
+	}
+	else
+	{
+		getWindow()->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)" << llendl;		
+	}
+	return TRUE;
+}
+
+BOOL LLSlider::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = FALSE;
+
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		gFocusMgr.setMouseCapture( NULL, NULL );
+
+		if( mMouseUpCallback )
+		{
+			mMouseUpCallback( this, mCallbackUserData );
+		}
+		handled = TRUE;
+		make_ui_sound("UISndClickRelease");
+	}
+	else
+	{
+		handled = TRUE;
+	}
+
+	return handled;
+}
+
+BOOL LLSlider::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	// only do sticky-focus on non-chrome widgets
+	if (!getIsChrome())
+	{
+		setFocus(TRUE);
+	}
+	if( mMouseDownCallback )
+	{
+		mMouseDownCallback( this, mCallbackUserData );
+	}
+
+	if (MASK_CONTROL & mask) // if CTRL is modifying
+	{
+		setValue(mInitialValue);
+		onCommit();
+	}
+	else
+	{
+		// Find the offset of the actual mouse location from the center of the thumb.
+		if (mThumbRect.pointInRect(x,y))
+		{
+			mMouseOffset = (mThumbRect.mLeft + THUMB_WIDTH/2) - x;
+		}
+		else
+		{
+			mMouseOffset = 0;
+		}
+
+		// Start dragging the thumb
+		// No handler needed for focus lost since this class has no state that depends on it.
+		gFocusMgr.setMouseCapture( this, NULL );  
+		mDragStartThumbRect = mThumbRect;				
+	}
+	make_ui_sound("UISndClick");
+
+	return TRUE;
+}
+
+BOOL	LLSlider::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+	if( getVisible() && mEnabled && !called_from_parent )
+	{
+		switch(key)
+		{
+		case KEY_UP:
+		case KEY_DOWN:
+			// eat up and down keys to be consistent
+			handled = TRUE;
+			break;
+		case KEY_LEFT:
+			setValue(getValueF32() - getIncrement());
+			onCommit();
+			handled = TRUE;
+			break;
+		case KEY_RIGHT:
+			setValue(getValueF32() + getIncrement());
+			onCommit();
+			handled = TRUE;
+			break;
+		default:
+			break;
+		}
+	}
+	return handled;
+}
+
+void LLSlider::draw()
+{
+	if( getVisible() )
+	{
+		// Draw background and thumb.
+
+		// drawing solids requires texturing be disabled
+		LLGLSNoTexture no_texture;
+
+		LLRect rect(mDragStartThumbRect);
+
+		F32 opacity = mEnabled ? 1.f : 0.3f;
+
+		// Track
+
+		LLUUID thumb_image_id;
+		thumb_image_id.set(LLUI::sAssetsGroup->getString("rounded_square.tga"));
+		LLImageGL* thumb_imagep = LLUI::sImageProvider->getUIImageByID(thumb_image_id);
+
+		S32 height_offset = (mRect.getHeight() - TRACK_HEIGHT) / 2;
+		LLRect track_rect(0, mRect.getHeight() - height_offset, mRect.getWidth(), height_offset );
+
+		track_rect.stretch(-1);
+		gl_draw_scaled_image_with_border(track_rect.mLeft, track_rect.mBottom, 16, 16, track_rect.getWidth(), track_rect.getHeight(),
+			thumb_imagep, mTrackColor % opacity);
+		//gl_rect_2d( track_rect, mThumbOutlineColor % opacity );
+
+		if (!thumb_imagep)
+		{
+			gl_rect_2d(mThumbRect, mThumbCenterColor, TRUE);
+			if (gFocusMgr.getMouseCapture() == this)
+			{
+				gl_rect_2d(mDragStartThumbRect, mThumbCenterColor % opacity, FALSE);
+			}
+		}
+		else if( gFocusMgr.getMouseCapture() == this )
+		{
+			gl_draw_scaled_image_with_border(mDragStartThumbRect.mLeft, mDragStartThumbRect.mBottom, 16, 16, mDragStartThumbRect.getWidth(), mDragStartThumbRect.getHeight(), 
+				thumb_imagep, mThumbCenterColor % 0.3f, TRUE);
+
+			if (hasFocus())
+			{
+				F32 lerp_amt = gFocusMgr.getFocusFlashAmt();
+				LLRect highlight_rect = mThumbRect;
+				highlight_rect.stretch(llround(lerp(1.f, 3.f, lerp_amt)));
+				gl_draw_scaled_image_with_border(highlight_rect.mLeft, highlight_rect.mBottom, 16, 16, highlight_rect.getWidth(), highlight_rect.getHeight(),
+					thumb_imagep, gFocusMgr.getFocusColor());
+			}
+
+
+			gl_draw_scaled_image_with_border(mThumbRect.mLeft, mThumbRect.mBottom, 16, 16, mThumbRect.getWidth(), mThumbRect.getHeight(), 
+				thumb_imagep, mThumbOutlineColor, TRUE);
+
+			//// Start Thumb
+			//gl_rect_2d( mDragStartThumbRect, mThumbOutlineColor % 0.3f );
+			//rect.stretch(-1);
+			//gl_rect_2d( rect, mThumbCenterColor % 0.3f );
+
+			//// Thumb
+			//gl_rect_2d( mThumbRect, mThumbOutlineColor );
+		}
+		else
+		{ 
+			if (hasFocus())
+			{
+				F32 lerp_amt = gFocusMgr.getFocusFlashAmt();
+				LLRect highlight_rect = mThumbRect;
+				highlight_rect.stretch(llround(lerp(1.f, 3.f, lerp_amt)));
+				gl_draw_scaled_image_with_border(highlight_rect.mLeft, highlight_rect.mBottom, 16, 16, highlight_rect.getWidth(), highlight_rect.getHeight(),
+					thumb_imagep, gFocusMgr.getFocusColor());
+			}
+
+			gl_draw_scaled_image_with_border(mThumbRect.mLeft, mThumbRect.mBottom, 16, 16, mThumbRect.getWidth(), mThumbRect.getHeight(), 
+				thumb_imagep, mThumbCenterColor % opacity, TRUE);
+			//rect = mThumbRect;
+
+			//gl_rect_2d( mThumbRect, mThumbOutlineColor % opacity );
+			//  
+			//rect.stretch(-1);
+
+			//// Thumb
+			//gl_rect_2d( rect, mThumbCenterColor % opacity );
+
+		}
+
+		LLUICtrl::draw();
+	}
+}
+
+// virtual
+LLXMLNodePtr LLSlider::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	node->createChild("initial_val", TRUE)->setFloatValue(getInitialValue());
+	node->createChild("min_val", TRUE)->setFloatValue(getMinValue());
+	node->createChild("max_val", TRUE)->setFloatValue(getMaxValue());
+	node->createChild("increment", TRUE)->setFloatValue(getIncrement());
+
+	return node;
+}
+
+
+//static
+LLView* LLSlider::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("slider_bar");
+	node->getAttributeString("name", name);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	F32 initial_value = 0.f;
+	node->getAttributeF32("initial_val", initial_value);
+
+	F32 min_value = 0.f;
+	node->getAttributeF32("min_val", min_value);
+
+	F32 max_value = 1.f; 
+	node->getAttributeF32("max_val", max_value);
+
+	F32 increment = 0.1f;
+	node->getAttributeF32("increment", increment);
+
+
+	LLSlider* slider = new LLSlider(name,
+							rect,
+							NULL,
+							NULL,
+							initial_value,
+							min_value,
+							max_value,
+							increment);
+
+	slider->initFromXML(node, parent);
+
+	return slider;
+}
diff --git a/indra/llui/llslider.h b/indra/llui/llslider.h
new file mode 100644
index 0000000000..a437cf2886
--- /dev/null
+++ b/indra/llui/llslider.h
@@ -0,0 +1,79 @@
+/** 
+ * @file llslider.h
+ * @brief A simple slider with no label.
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLSLIDER_H
+#define LL_LLSLIDER_H
+
+#include "lluictrl.h"
+#include "v4color.h"
+
+class LLSlider : public LLUICtrl
+{
+public:
+	LLSlider( 
+		const LLString& name,
+		const LLRect& rect,
+		void (*on_commit_callback)(LLUICtrl* ctrl, void* userdata),
+		void* callback_userdata,
+		F32 initial_value,
+		F32 min_value,
+		F32 max_value,
+		F32 increment,
+		const LLString& control_name = LLString::null );
+
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static  LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	void			setValue( F32 value, BOOL from_event = FALSE );
+	F32				getValueF32() const;
+
+	virtual void	setValue(const LLSD& value )	{ setValue((F32)value.asReal(), TRUE); }
+	virtual LLSD	getValue() const		{ return LLSD(getValueF32()); }
+
+	virtual void	setMinValue(LLSD min_value)	{ setMinValue((F32)min_value.asReal()); }
+	virtual void	setMaxValue(LLSD max_value)	{ setMaxValue((F32)max_value.asReal());  }
+
+	F32				getInitialValue() const { return mInitialValue; }
+	F32				getMinValue() const		{ return mMinValue; }
+	F32				getMaxValue() const		{ return mMaxValue; }
+	F32				getIncrement() const	{ return mIncrement; }
+	void			setMinValue(F32 min_value) {mMinValue = min_value;}
+	void			setMaxValue(F32 max_value) {mMaxValue = max_value;}
+	void			setIncrement(F32 increment) {mIncrement = increment;}
+	void			setMouseDownCallback( void (*cb)(LLUICtrl* ctrl, void* userdata) ) { mMouseDownCallback = cb; }
+	void			setMouseUpCallback(	void (*cb)(LLUICtrl* ctrl, void* userdata) ) { mMouseUpCallback = cb; }
+
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	virtual void	draw();
+
+protected:
+	F32				mValue;
+	F32				mInitialValue;
+	F32				mMinValue;
+	F32				mMaxValue;
+	F32				mIncrement;
+
+	S32				mMouseOffset;
+	LLRect			mDragStartThumbRect;
+
+	LLRect			mThumbRect;
+	LLColor4		mTrackColor;
+	LLColor4		mThumbOutlineColor;
+	LLColor4		mThumbCenterColor;
+	LLColor4		mDisabledThumbColor;
+	
+	void			(*mMouseDownCallback)(LLUICtrl* ctrl, void* userdata);
+	void			(*mMouseUpCallback)(LLUICtrl* ctrl, void* userdata);
+};
+
+#endif  // LL_LLSLIDER_H
diff --git a/indra/llui/llsliderctrl.cpp b/indra/llui/llsliderctrl.cpp
new file mode 100644
index 0000000000..6c740aa39e
--- /dev/null
+++ b/indra/llui/llsliderctrl.cpp
@@ -0,0 +1,538 @@
+/** 
+ * @file llsliderctrl.cpp
+ * @brief LLSliderCtrl base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llsliderctrl.h"
+
+#include "audioengine.h"
+#include "sound_ids.h"
+
+#include "llmath.h"
+#include "llfontgl.h"
+#include "llgl.h"
+#include "llkeyboard.h"
+#include "lllineeditor.h"
+#include "llslider.h"
+#include "llstring.h"
+#include "lltextbox.h"
+#include "llui.h"
+#include "lluiconstants.h"
+#include "llcontrol.h"
+#include "llfocusmgr.h"
+#include "llresmgr.h"
+
+const U32 MAX_STRING_LENGTH = 10;
+
+ 
+LLSliderCtrl::LLSliderCtrl(const LLString& name, const LLRect& rect, 
+						   const LLString& label,
+						   const LLFontGL* font,
+						   S32 label_width,
+						   S32 text_left,
+						   BOOL show_text,
+						   BOOL can_edit_text,
+						   void (*commit_callback)(LLUICtrl*, void*),
+						   void* callback_user_data,
+						   F32 initial_value, F32 min_value, F32 max_value, F32 increment,
+						   const LLString& control_which)
+	: LLUICtrl(name, rect, TRUE, commit_callback, callback_user_data ),
+	  mFont(font),
+	  mShowText( show_text ),
+	  mCanEditText( can_edit_text ),
+	  mPrecision( 3 ),
+	  mLabelBox( NULL ),
+	  mLabelWidth( label_width ),
+	  mValue( initial_value ),
+	  mEditor( NULL ),
+	  mTextBox( NULL ),
+	  mTextEnabledColor( LLUI::sColorsGroup->getColor( "LabelTextColor" ) ),
+	  mTextDisabledColor( LLUI::sColorsGroup->getColor( "LabelDisabledColor" ) ),
+	  mSliderMouseUpCallback( NULL ),
+	  mSliderMouseDownCallback( NULL )
+{
+	S32 top = mRect.getHeight();
+	S32 bottom = 0;
+	S32 left = 0;
+
+	// Label
+	if( !label.empty() )
+	{
+		if (label_width == 0)
+		{
+			label_width = font->getWidth(label);
+		}
+		LLRect label_rect( left, top, label_width, bottom );
+		mLabelBox = new LLTextBox( "SliderCtrl Label", label_rect, label.c_str(), font );
+		addChild(mLabelBox);
+	}
+
+	S32 slider_right = mRect.getWidth();
+	if( show_text )
+	{
+		slider_right = text_left - SLIDERCTRL_SPACING;
+	}
+
+	S32 slider_left = label_width ? label_width + SLIDERCTRL_SPACING : 0;
+	LLRect slider_rect( slider_left, top, slider_right, bottom );
+	mSlider = new LLSlider( 
+		"slider",
+		slider_rect, 
+		LLSliderCtrl::onSliderCommit, this, 
+		initial_value, min_value, max_value, increment,
+		control_which );
+	addChild( mSlider );
+	
+	if( show_text )
+	{
+		LLRect text_rect( text_left, top, mRect.getWidth(), bottom );
+		if( can_edit_text )
+		{
+			mEditor = new LLLineEditor( "SliderCtrl Editor", text_rect,
+				"", font,
+				MAX_STRING_LENGTH,
+				&LLSliderCtrl::onEditorCommit, NULL, NULL, this,
+				&LLLineEditor::prevalidateFloat );
+			mEditor->setFollowsLeft();
+			mEditor->setFollowsBottom();
+			mEditor->setFocusReceivedCallback( &LLSliderCtrl::onEditorGainFocus );
+			mEditor->setIgnoreTab(TRUE);
+			// don't do this, as selecting the entire text is single clicking in some cases
+			// and double clicking in others
+			//mEditor->setSelectAllonFocusReceived(TRUE);
+			addChild(mEditor);
+		}
+		else
+		{
+			mTextBox = new LLTextBox( "SliderCtrl Text", text_rect,	"",	font);
+			mTextBox->setFollowsLeft();
+			mTextBox->setFollowsBottom();
+			addChild(mTextBox);
+		}
+	}
+
+	updateText();
+}
+
+LLSliderCtrl::~LLSliderCtrl()
+{
+	// Children all cleaned up by default view destructor.
+}
+
+// static
+void LLSliderCtrl::onEditorGainFocus( LLUICtrl* caller, void *userdata )
+{
+	LLSliderCtrl* self = (LLSliderCtrl*) userdata;
+	llassert( caller == self->mEditor );
+
+	self->onFocusReceived();
+}
+
+F32 LLSliderCtrl::getValueF32() const
+{
+	return mSlider->getValueF32();
+}
+
+void LLSliderCtrl::setValue(F32 v, BOOL from_event)
+{
+	mSlider->setValue( v, from_event );
+	mValue = mSlider->getValueF32();
+	updateText();
+}
+
+BOOL LLSliderCtrl::setLabelArg( const LLString& key, const LLString& text )
+{
+	BOOL res = FALSE;
+	if (mLabelBox)
+	{
+		res = mLabelBox->setTextArg(key, text);
+		if (res && mLabelWidth == 0)
+		{
+			S32 label_width = mFont->getWidth(mLabelBox->getText());
+			LLRect rect = mLabelBox->getRect();
+			S32 prev_right = rect.mRight;
+			rect.mRight = rect.mLeft + label_width;
+			mLabelBox->setRect(rect);
+				
+			S32 delta = rect.mRight - prev_right;
+			rect = mSlider->getRect();
+			S32 left = rect.mLeft + delta;
+			left = llclamp(left, 0, rect.mRight-SLIDERCTRL_SPACING);
+			rect.mLeft = left;
+			mSlider->setRect(rect);
+		}
+	}
+	return res;
+}
+
+void LLSliderCtrl::clear()
+{
+	setValue(0.0f);
+	if( mEditor )
+	{
+		mEditor->setText( "" );
+	}
+	if( mTextBox )
+	{
+		mTextBox->setText( "" );
+	}
+
+}
+
+BOOL LLSliderCtrl::isMouseHeldDown()
+{
+	return gFocusMgr.getMouseCapture() == mSlider;
+}
+
+void LLSliderCtrl::updateText()
+{
+	if( mEditor || mTextBox )
+	{
+		LLLocale locale(LLLocale::USER_LOCALE);
+
+		// Don't display very small negative values as -0.000
+		F32 displayed_value = (F32)(floor(getValueF32() * pow(10, mPrecision) + 0.5) / pow(10, mPrecision));
+
+		LLString format = llformat("%%.%df", mPrecision);
+		LLString text = llformat(format.c_str(), displayed_value);
+		if( mEditor )
+		{
+			mEditor->setText( text );
+		}
+		else
+		{
+			mTextBox->setText( text );
+		}
+	}
+}
+
+// static
+void LLSliderCtrl::onEditorCommit( LLUICtrl* caller, void *userdata )
+{
+	LLSliderCtrl* self = (LLSliderCtrl*) userdata;
+	llassert( caller == self->mEditor );
+
+	BOOL success = FALSE;
+	F32 val = self->mValue;
+	F32 saved_val = self->mValue;
+
+	LLString text = self->mEditor->getText();
+	if( LLLineEditor::postvalidateFloat( text ) )
+	{
+		LLLocale locale(LLLocale::USER_LOCALE);
+		val = (F32) atof( text.c_str() );
+		if( self->mSlider->getMinValue() <= val && val <= self->mSlider->getMaxValue() )
+		{
+			if( self->mValidateCallback )
+			{
+				self->setValue( val );  // set the value temporarily so that the callback can retrieve it.
+				if( self->mValidateCallback( self, self->mCallbackUserData ) )
+				{
+					success = TRUE;
+				}
+			}
+			else
+			{
+				self->setValue( val );
+				success = TRUE;
+			}
+		}
+	}
+
+	if( success )
+	{
+		self->onCommit();
+	}
+	else
+	{
+		if( self->getValueF32() != saved_val )
+		{
+			self->setValue( saved_val );
+		}
+		self->reportInvalidData();		
+	}
+	self->updateText();
+}
+
+// static
+void LLSliderCtrl::onSliderCommit( LLUICtrl* caller, void *userdata )
+{
+	LLSliderCtrl* self = (LLSliderCtrl*) userdata;
+	llassert( caller == self->mSlider );
+
+	BOOL success = FALSE;
+	F32 saved_val = self->mValue;
+	F32 new_val = self->mSlider->getValueF32();
+
+	if( self->mValidateCallback )
+	{
+		self->mValue = new_val;  // set the value temporarily so that the callback can retrieve it.
+		if( self->mValidateCallback( self, self->mCallbackUserData ) )
+		{
+			success = TRUE;
+		}
+	}
+	else
+	{
+		self->mValue = new_val;
+		success = TRUE;
+	}
+
+	if( success )
+	{
+		self->onCommit();
+	}
+	else
+	{
+		if( self->mValue != saved_val )
+		{
+			self->setValue( saved_val );
+		}
+		self->reportInvalidData();		
+	}
+	self->updateText();
+}
+
+void LLSliderCtrl::setEnabled(BOOL b)
+{
+	LLUICtrl::setEnabled( b );
+
+	if( mLabelBox )
+	{
+		mLabelBox->setColor( b ? mTextEnabledColor : mTextDisabledColor );
+	}
+
+	mSlider->setEnabled( b );
+
+	if( mEditor )
+	{
+		mEditor->setEnabled( b );
+	}
+
+	if( mTextBox )
+	{
+		mTextBox->setColor( b ? mTextEnabledColor : mTextDisabledColor );
+	}
+}
+
+
+void LLSliderCtrl::setTentative(BOOL b)
+{
+	if( mEditor )
+	{
+		mEditor->setTentative(b);
+	}
+	LLUICtrl::setTentative(b);
+}
+
+
+void LLSliderCtrl::onCommit()
+{
+	setTentative(FALSE);
+
+	if( mEditor )
+	{
+		mEditor->setTentative(FALSE);
+	}
+
+	LLUICtrl::onCommit();
+}
+
+
+void LLSliderCtrl::setPrecision(S32 precision)
+{
+	if (precision < 0 || precision > 10)
+	{
+		llerrs << "LLSliderCtrl::setPrecision - precision out of range" << llendl;
+		return;
+	}
+
+	mPrecision = precision;
+	updateText();
+}
+
+void LLSliderCtrl::setSliderMouseDownCallback( void (*slider_mousedown_callback)(LLUICtrl* caller, void* userdata) )
+{
+	mSliderMouseDownCallback = slider_mousedown_callback;
+	mSlider->setMouseDownCallback( LLSliderCtrl::onSliderMouseDown );
+}
+
+// static
+void LLSliderCtrl::onSliderMouseDown(LLUICtrl* caller, void* userdata)
+{
+	LLSliderCtrl* self = (LLSliderCtrl*) userdata;
+	if( self->mSliderMouseDownCallback )
+	{
+		self->mSliderMouseDownCallback( self, self->mCallbackUserData );
+	}
+}
+
+
+void LLSliderCtrl::setSliderMouseUpCallback( void (*slider_mouseup_callback)(LLUICtrl* caller, void* userdata) )
+{
+	mSliderMouseUpCallback = slider_mouseup_callback;
+	mSlider->setMouseUpCallback( LLSliderCtrl::onSliderMouseUp );
+}
+
+// static
+void LLSliderCtrl::onSliderMouseUp(LLUICtrl* caller, void* userdata)
+{
+	LLSliderCtrl* self = (LLSliderCtrl*) userdata;
+	if( self->mSliderMouseUpCallback )
+	{
+		self->mSliderMouseUpCallback( self, self->mCallbackUserData );
+	}
+}
+
+void LLSliderCtrl::onTabInto()
+{
+	if( mEditor )
+	{
+		mEditor->onTabInto(); 
+	}
+}
+
+void LLSliderCtrl::reportInvalidData()
+{
+	make_ui_sound("UISndBadKeystroke");
+}
+
+//virtual
+LLString LLSliderCtrl::getControlName() const
+{
+	return mSlider->getControlName();
+}
+
+// virtual
+void LLSliderCtrl::setControlName(const LLString& control_name, LLView* context)
+{
+	mSlider->setControlName(control_name, context);
+}
+
+// virtual
+LLXMLNodePtr LLSliderCtrl::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	node->createChild("show_text", TRUE)->setBoolValue(mShowText);
+
+	node->createChild("can_edit_text", TRUE)->setBoolValue(mCanEditText);
+
+	node->createChild("decimal_digits", TRUE)->setIntValue(mPrecision);
+
+	if (mLabelBox)
+	{
+		node->createChild("label", TRUE)->setStringValue(mLabelBox->getText());
+	}
+
+	// TomY TODO: Do we really want to export the transient state of the slider?
+	node->createChild("value", TRUE)->setFloatValue(mValue);
+
+	if (mSlider)
+	{
+		node->createChild("initial_val", TRUE)->setFloatValue(mSlider->getInitialValue());
+		node->createChild("min_val", TRUE)->setFloatValue(mSlider->getMinValue());
+		node->createChild("max_val", TRUE)->setFloatValue(mSlider->getMaxValue());
+		node->createChild("increment", TRUE)->setFloatValue(mSlider->getIncrement());
+	}
+	addColorXML(node, mTextEnabledColor, "text_enabled_color", "LabelTextColor");
+	addColorXML(node, mTextDisabledColor, "text_disabled_color", "LabelDisabledColor");
+
+	return node;
+}
+
+LLView* LLSliderCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("slider");
+	node->getAttributeString("name", name);
+
+	LLString label;
+	node->getAttributeString("label", label);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	LLFontGL* font = LLView::selectFont(node);
+
+	// HACK: Font might not be specified.
+	if (!font)
+	{
+		font = LLFontGL::sSansSerifSmall;
+	}
+
+	S32 label_width = 0;
+	node->getAttributeS32("label_width", label_width);
+
+	BOOL show_text = TRUE;
+	node->getAttributeBOOL("show_text", show_text);
+
+	BOOL can_edit_text = FALSE;
+	node->getAttributeBOOL("can_edit_text", can_edit_text);
+
+	F32 initial_value = 0.f;
+	node->getAttributeF32("initial_val", initial_value);
+
+	F32 min_value = 0.f;
+	node->getAttributeF32("min_val", min_value);
+
+	F32 max_value = 1.f; 
+	node->getAttributeF32("max_val", max_value);
+
+	F32 increment = 0.1f;
+	node->getAttributeF32("increment", increment);
+
+	U32 precision = 3;
+	node->getAttributeU32("decimal_digits", precision);
+
+	S32 text_left = 0;
+	if (show_text)
+	{
+		// calculate the size of the text box (log max_value is number of digits - 1 so plus 1)
+		if ( max_value )
+			text_left = font->getWidth("0") * ( static_cast < S32 > ( log10  ( max_value ) ) + precision + 1 );
+
+		if ( increment < 1.0f )
+			text_left += font->getWidth(".");	// (mostly) take account of decimal point in value
+
+		if ( min_value < 0.0f || max_value < 0.0f )
+			text_left += font->getWidth("-");	// (mostly) take account of minus sign 
+
+		// padding to make things look nicer
+		text_left += 8;
+	}
+
+	LLUICtrlCallback callback = NULL;
+
+	if (label.empty())
+	{
+		label.assign(node->getTextContents());
+	}
+
+	LLSliderCtrl* slider = new LLSliderCtrl(name,
+							rect,
+							label,
+							font,
+							label_width,
+							rect.getWidth() - text_left,
+							show_text,
+							can_edit_text,
+							callback,
+							NULL,
+							initial_value, 
+							min_value, 
+							max_value, 
+							increment);
+
+	slider->setPrecision(precision);
+
+	slider->initFromXML(node, parent);
+
+	slider->updateText();
+	
+	return slider;
+}
diff --git a/indra/llui/llsliderctrl.h b/indra/llui/llsliderctrl.h
new file mode 100644
index 0000000000..2185e42eb1
--- /dev/null
+++ b/indra/llui/llsliderctrl.h
@@ -0,0 +1,124 @@
+/** 
+ * @file llsliderctrl.h
+ * @brief LLSliderCtrl base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLSLIDERCTRL_H
+#define LL_LLSLIDERCTRL_H
+
+#include "lluictrl.h"
+#include "v4color.h"
+#include "llslider.h"
+#include "lltextbox.h"
+#include "llrect.h"
+
+//
+// Constants
+//
+const S32	SLIDERCTRL_SPACING		=  4;				// space between label, slider, and text
+const S32	SLIDERCTRL_HEIGHT		=  16;
+
+//
+// Classes
+//
+class LLFontGL;
+class LLLineEditor;
+class LLSlider;
+
+
+class LLSliderCtrl : public LLUICtrl
+{
+public:
+	LLSliderCtrl(const LLString& name, 
+		const LLRect& rect, 
+		const LLString& label, 
+		const LLFontGL* font,
+		S32 slider_left,
+		S32 text_left,
+		BOOL show_text,
+		BOOL can_edit_text,
+		void (*commit_callback)(LLUICtrl*, void*),
+		void* callback_userdata,
+		F32 initial_value, F32 min_value, F32 max_value, F32 increment,
+		const LLString& control_which = LLString::null );
+
+	virtual ~LLSliderCtrl();
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_SLIDER; }
+	virtual LLString getWidgetTag() const { return LL_SLIDER_CTRL_TAG; }
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	F32				getValueF32() const;
+	void			setValue(F32 v, BOOL from_event = FALSE);
+
+	virtual void	setValue(const LLSD& value )	{ setValue((F32)value.asReal(), TRUE); }
+	virtual LLSD	getValue() const		{ return LLSD(getValueF32()); }
+	virtual BOOL	setLabelArg( const LLString& key, const LLString& text );
+
+	virtual void	setMinValue(LLSD min_value)	{ setMinValue((F32)min_value.asReal()); }
+	virtual void	setMaxValue(LLSD max_value)	{ setMaxValue((F32)max_value.asReal());  }
+
+	BOOL			isMouseHeldDown();
+
+	virtual void    setEnabled( BOOL b );
+	virtual void	clear();
+	virtual void	setPrecision(S32 precision);
+	void			setMinValue(F32 min_value) {mSlider->setMinValue(min_value);}
+	void			setMaxValue(F32 max_value) {mSlider->setMaxValue(max_value);}
+	void			setIncrement(F32 increment) {mSlider->setIncrement(increment);}
+
+	F32				getMinValue() { return mSlider->getMinValue(); }
+	F32				getMaxValue() { return mSlider->getMaxValue(); }
+
+	void			setLabel(const LLString& label)				{ if (mLabelBox) mLabelBox->setText(label); }
+	void			setLabelColor(const LLColor4& c)			{ mTextEnabledColor = c; }
+	void			setDisabledLabelColor(const LLColor4& c)	{ mTextDisabledColor = c; }
+
+	void			setSliderMouseDownCallback(	void (*slider_mousedown_callback)(LLUICtrl* caller, void* userdata) );
+	void			setSliderMouseUpCallback(	void (*slider_mouseup_callback)(LLUICtrl* caller, void* userdata) );
+
+	virtual void	onTabInto();
+
+	virtual void	setTentative(BOOL b);			// marks value as tentative
+	virtual void	onCommit();						// mark not tentative, then commit
+
+	virtual void		setControlName(const LLString& control_name, LLView* context);
+	virtual LLString 	getControlName() const;
+	
+	static void		onSliderCommit(LLUICtrl* caller, void* userdata);
+	static void		onSliderMouseDown(LLUICtrl* caller,void* userdata);
+	static void		onSliderMouseUp(LLUICtrl* caller,void* userdata);
+
+	static void		onEditorCommit(LLUICtrl* caller, void* userdata);
+	static void		onEditorGainFocus(LLUICtrl* caller, void *userdata);
+	static void		onEditorChangeFocus(LLUICtrl* caller, S32 direction, void *userdata);
+
+private:
+	void			updateText();
+	void			reportInvalidData();
+
+private:
+	const LLFontGL*	mFont;
+	BOOL			mShowText;
+	BOOL			mCanEditText;
+
+	S32				mPrecision;
+	LLTextBox*		mLabelBox;
+	S32				mLabelWidth;
+	
+	F32				mValue;
+	LLSlider*		mSlider;
+	LLLineEditor*	mEditor;
+	LLTextBox*		mTextBox;
+
+	LLColor4		mTextEnabledColor;
+	LLColor4		mTextDisabledColor;
+
+	void			(*mSliderMouseUpCallback)( LLUICtrl* ctrl, void* userdata );
+	void			(*mSliderMouseDownCallback)( LLUICtrl* ctrl, void* userdata );
+};
+
+#endif  // LL_LLSLIDERCTRL_H
diff --git a/indra/llui/llspinctrl.cpp b/indra/llui/llspinctrl.cpp
new file mode 100644
index 0000000000..332372011e
--- /dev/null
+++ b/indra/llui/llspinctrl.cpp
@@ -0,0 +1,509 @@
+/** 
+ * @file llspinctrl.cpp
+ * @brief LLSpinCtrl base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+ 
+#include "llspinctrl.h"
+
+#include "llgl.h"
+#include "llui.h"
+#include "lluiconstants.h"
+
+#include "llstring.h"
+#include "llfontgl.h"
+#include "lllineeditor.h"
+#include "llbutton.h"
+#include "lltextbox.h"
+#include "llkeyboard.h"
+#include "llmath.h"
+#include "sound_ids.h"
+#include "audioengine.h"
+#include "llcontrol.h"
+#include "llfocusmgr.h"
+#include "llresmgr.h"
+
+const U32 MAX_STRING_LENGTH = 32;
+
+ 
+LLSpinCtrl::LLSpinCtrl(	const LLString& name, const LLRect& rect, const LLString& label, const LLFontGL* font,
+	void (*commit_callback)(LLUICtrl*, void*),
+	void* callback_user_data,
+	F32 initial_value, F32 min_value, F32 max_value, F32 increment,
+	const LLString& control_name,
+	S32 label_width)
+	:
+	LLUICtrl(name, rect, TRUE, commit_callback, callback_user_data, FOLLOWS_LEFT | FOLLOWS_TOP ),
+	mValue( initial_value ),
+	mInitialValue( initial_value ),
+	mMaxValue( max_value ),
+	mMinValue( min_value ),
+	mIncrement( increment ),
+	mPrecision( 3 ),
+	mLabelBox( NULL ),
+	mTextEnabledColor( LLUI::sColorsGroup->getColor( "LabelTextColor" ) ),
+	mTextDisabledColor( LLUI::sColorsGroup->getColor( "LabelDisabledColor" ) ),
+	mbHasBeenSet( FALSE )
+{
+	S32 top = mRect.getHeight();
+	S32 bottom = top - 2 * SPINCTRL_BTN_HEIGHT;
+	S32 centered_top = top;
+	S32 centered_bottom = bottom;
+	S32 btn_left = 0;
+
+	// Label
+	if( !label.empty() )
+	{
+		LLRect label_rect( 0, centered_top, label_width, centered_bottom );
+		mLabelBox = new LLTextBox( "SpinCtrl Label", label_rect, label.c_str(), font );
+		addChild(mLabelBox);
+
+		btn_left += label_rect.mRight + SPINCTRL_SPACING;
+	}
+
+	S32 btn_right = btn_left + SPINCTRL_BTN_WIDTH;
+	
+	// Spin buttons
+	LLRect up_rect( btn_left, top, btn_right, top - SPINCTRL_BTN_HEIGHT );
+	LLString out_id = "UIImgBtnSpinUpOutUUID";
+	LLString in_id = "UIImgBtnSpinUpInUUID";
+	mUpBtn = new LLButton(
+		"SpinCtrl Up", up_rect,
+		out_id,
+		in_id,
+		"",
+		&LLSpinCtrl::onUpBtn, this, LLFontGL::sSansSerif );
+	mUpBtn->setFollowsLeft();
+	mUpBtn->setFollowsBottom();
+	mUpBtn->setHeldDownCallback( &LLSpinCtrl::onUpBtn );
+	mUpBtn->setTabStop(FALSE);
+	addChild(mUpBtn);
+
+	LLRect down_rect( btn_left, top - SPINCTRL_BTN_HEIGHT, btn_right, bottom );
+	out_id = "UIImgBtnSpinDownOutUUID";
+	in_id = "UIImgBtnSpinDownInUUID";
+	mDownBtn = new LLButton(
+		"SpinCtrl Down", down_rect,
+		out_id,
+		in_id,
+		"",
+		&LLSpinCtrl::onDownBtn, this, LLFontGL::sSansSerif );
+	mDownBtn->setFollowsLeft();
+	mDownBtn->setFollowsBottom();
+	mDownBtn->setHeldDownCallback( &LLSpinCtrl::onDownBtn );
+	mDownBtn->setTabStop(FALSE);
+	addChild(mDownBtn);
+
+	LLRect editor_rect( btn_right + 1, centered_top, mRect.getWidth(), centered_bottom );
+	mEditor = new LLLineEditor( "SpinCtrl Editor", editor_rect, "",	font,
+		MAX_STRING_LENGTH,
+		&LLSpinCtrl::onEditorCommit, NULL, NULL, this,
+		&LLLineEditor::prevalidateFloat );
+	mEditor->setFollowsLeft();
+	mEditor->setFollowsBottom();
+	mEditor->setFocusReceivedCallback( &LLSpinCtrl::onEditorGainFocus );
+	//RN: this seems to be a BAD IDEA, as it makes the editor behavior different when it has focus
+	// than when it doesn't.  Instead, if you always have to double click to select all the text, 
+	// it's easier to understand
+	//mEditor->setSelectAllonFocusReceived(TRUE);
+	mEditor->setIgnoreTab(TRUE);
+	addChild(mEditor);
+
+	updateEditor();
+	setSpanChildren( TRUE );
+}
+
+LLSpinCtrl::~LLSpinCtrl()
+{
+	// Children all cleaned up by default view destructor.
+}
+
+
+// static
+void LLSpinCtrl::onUpBtn( void *userdata )
+{
+	LLSpinCtrl* self = (LLSpinCtrl*) userdata;
+	if( self->getEnabled() )
+	{
+		// use getValue()/setValue() to force reload from/to control
+		F32 val = (F32)self->getValue().asReal() + self->mIncrement;
+		val = llmin( val, self->mMaxValue );
+		
+		if( self->mValidateCallback )
+		{
+			F32 saved_val = (F32)self->getValue().asReal();
+			self->setValue(val);
+			if( !self->mValidateCallback( self, self->mCallbackUserData ) )
+			{
+				self->setValue( saved_val );
+				self->reportInvalidData();
+				self->updateEditor();
+				return;
+			}
+		}
+		else
+		{
+			self->setValue(val);
+		}
+
+		self->updateEditor();
+		self->onCommit();
+	}
+}
+
+// static
+void LLSpinCtrl::onDownBtn( void *userdata )
+{
+	LLSpinCtrl* self = (LLSpinCtrl*) userdata;
+
+	if( self->getEnabled() )
+	{
+		F32 val = (F32)self->getValue().asReal() - self->mIncrement;
+		val = llmax( val, self->mMinValue );
+
+		if( self->mValidateCallback )
+		{
+			F32 saved_val = (F32)self->getValue().asReal();
+			self->setValue(val);
+			if( !self->mValidateCallback( self, self->mCallbackUserData ) )
+			{
+				self->setValue( saved_val );
+				self->reportInvalidData();
+				self->updateEditor();
+				return;
+			}
+		}
+		else
+		{
+			self->setValue(val);
+		}
+		
+		self->updateEditor();
+		self->onCommit();
+	}
+}
+
+// static
+void LLSpinCtrl::onEditorGainFocus( LLUICtrl* caller, void *userdata )
+{
+	LLSpinCtrl* self = (LLSpinCtrl*) userdata;
+	llassert( caller == self->mEditor );
+
+	self->onFocusReceived();
+}
+
+void LLSpinCtrl::setValue(const LLSD& value )
+{
+	F32 v = (F32)value.asReal();
+	if (mValue != v || !mbHasBeenSet)
+	{
+		mbHasBeenSet = TRUE;
+		mValue = v;
+		
+		if (!mEditor->hasFocus())
+		{
+			updateEditor();
+		}
+	}
+}
+
+LLSD LLSpinCtrl::getValue() const
+{
+	return mValue;
+}
+
+void LLSpinCtrl::clear()
+{
+	setValue(mMinValue);
+	mEditor->clear();
+	mbHasBeenSet = FALSE;
+}
+
+
+void LLSpinCtrl::updateEditor()
+{
+	LLLocale locale(LLLocale::USER_LOCALE);
+
+	// Don't display very small negative values as -0.000
+	F32 displayed_value = (F32)floor(getValue().asReal() * pow(10, mPrecision) + 0.5) / (F32)pow(10, mPrecision);
+
+//	if( S32( displayed_value * pow( 10, mPrecision ) ) == 0 )
+//	{
+//		displayed_value = 0.f;
+//	}
+
+	LLString format = llformat("%%.%df", mPrecision);
+	LLString text = llformat(format.c_str(), displayed_value);
+	mEditor->setText( text );
+}
+
+void LLSpinCtrl::onEditorCommit( LLUICtrl* caller, void *userdata )
+{
+	BOOL success = FALSE;
+	
+	LLSpinCtrl* self = (LLSpinCtrl*) userdata;
+	llassert( caller == self->mEditor );
+
+	LLString text = self->mEditor->getText();
+	if( LLLineEditor::postvalidateFloat( text ) )
+	{
+		LLLocale locale(LLLocale::USER_LOCALE);
+		F32 val = (F32) atof(text.c_str());
+
+		if (val < self->mMinValue) val = self->mMinValue;
+		if (val > self->mMaxValue) val = self->mMaxValue;
+
+		if( self->mValidateCallback )
+		{
+			F32 saved_val = self->mValue;
+			self->mValue = val;
+			if( self->mValidateCallback( self, self->mCallbackUserData ) )
+			{
+				success = TRUE;
+				self->onCommit();
+			}
+			else
+			{
+				self->mValue = saved_val;
+			}
+		}
+		else
+		{
+			self->mValue = val;
+			self->onCommit();
+			success = TRUE;
+		}
+	}
+	self->updateEditor();
+
+	if( !success )
+	{
+		self->reportInvalidData();		
+	}
+}
+
+
+void LLSpinCtrl::forceEditorCommit()
+{
+	onEditorCommit(mEditor, this);
+}
+
+
+void LLSpinCtrl::setFocus(BOOL b)
+{
+	LLUICtrl::setFocus( b );
+	mEditor->setFocus( b );
+}
+
+void LLSpinCtrl::setEnabled(BOOL b)
+{
+	LLUICtrl::setEnabled( b );
+	mEditor->setEnabled( b );
+}
+
+
+void LLSpinCtrl::setTentative(BOOL b)
+{
+	mEditor->setTentative(b);
+	LLUICtrl::setTentative(b);
+}
+
+
+BOOL LLSpinCtrl::isMouseHeldDown()
+{
+	return 
+		gFocusMgr.getMouseCapture() == mDownBtn ||
+		gFocusMgr.getMouseCapture() == mUpBtn;
+}
+
+void LLSpinCtrl::onCommit()
+{
+	setTentative(FALSE);
+
+	setControlValue(mValue);
+
+	LLUICtrl::onCommit();
+}
+
+
+void LLSpinCtrl::setPrecision(S32 precision)
+{
+	if (precision < 0 || precision > 10)
+	{
+		llerrs << "LLSpinCtrl::setPrecision - precision out of range" << llendl;
+		return;
+	}
+
+	mPrecision = precision;
+	updateEditor();
+}
+
+void LLSpinCtrl::setLabel(const LLString& label)
+{
+	if (mLabelBox)
+	{
+		mLabelBox->setText(label);
+	}
+	else
+	{
+		llwarns << "Attempting to set label on LLSpinCtrl constructed without one " << getName() << llendl;
+	}
+}
+
+void LLSpinCtrl::onTabInto()
+{
+	mEditor->onTabInto(); 
+}
+
+
+void LLSpinCtrl::reportInvalidData()
+{
+	make_ui_sound("UISndBadKeystroke");
+}
+
+void LLSpinCtrl::draw()
+{
+	if( mLabelBox )
+	{
+		mLabelBox->setColor( mEnabled ? mTextEnabledColor : mTextDisabledColor );
+	}
+	LLUICtrl::draw();
+}
+
+
+BOOL LLSpinCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	if( mEnabled )
+	{
+		if( clicks > 0 )
+		{
+			while( clicks-- )
+			{
+				LLSpinCtrl::onDownBtn(this);
+			}
+		}
+		else
+		while( clicks++ )
+		{
+			LLSpinCtrl::onUpBtn(this);
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL LLSpinCtrl::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	if (mEditor->hasFocus())
+	{
+		if(key == KEY_ESCAPE)
+		{
+			// text editors don't support revert normally (due to user confusion)
+			// but not allowing revert on a spinner seems dangerous
+			updateEditor();
+			mEditor->setFocus(FALSE);
+			return TRUE;
+		}
+		if(key == KEY_UP)
+		{
+			LLSpinCtrl::onUpBtn(this);
+			return TRUE;
+		}
+		if(key == KEY_DOWN)
+		{
+			LLSpinCtrl::onDownBtn(this);
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+// virtual
+LLXMLNodePtr LLSpinCtrl::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	node->createChild("decimal_digits", TRUE)->setIntValue(mPrecision);
+
+	if (mLabelBox)
+	{
+		node->createChild("label", TRUE)->setStringValue(mLabelBox->getText());
+
+		node->createChild("label_width", TRUE)->setIntValue(mLabelBox->getRect().getWidth());
+	}
+
+	node->createChild("initial_val", TRUE)->setFloatValue(mInitialValue);
+
+	node->createChild("min_val", TRUE)->setFloatValue(mMinValue);
+
+	node->createChild("max_val", TRUE)->setFloatValue(mMaxValue);
+
+	node->createChild("increment", TRUE)->setFloatValue(mIncrement);
+	
+	addColorXML(node, mTextEnabledColor, "text_enabled_color", "LabelTextColor");
+	addColorXML(node, mTextDisabledColor, "text_disabled_color", "LabelDisabledColor");
+
+	return node;
+}
+
+LLView* LLSpinCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("spinner");
+	node->getAttributeString("name", name);
+
+	LLString label;
+	node->getAttributeString("label", label);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	LLFontGL* font = LLView::selectFont(node);
+
+	F32 initial_value = 0.f;
+	node->getAttributeF32("initial_val", initial_value);
+
+	F32 min_value = 0.f;
+	node->getAttributeF32("min_val", min_value);
+
+	F32 max_value = 1.f; 
+	node->getAttributeF32("max_val", max_value);
+
+	F32 increment = 0.1f;
+	node->getAttributeF32("increment", increment);
+
+	U32 precision = 3;
+	node->getAttributeU32("decimal_digits", precision);
+	
+	S32 label_width = llmin(40, rect.getWidth() - 40);
+	node->getAttributeS32("label_width", label_width);
+
+	LLUICtrlCallback callback = NULL;
+
+	if(label.empty())
+	{
+		label.assign( node->getValue() );
+	}
+
+	LLSpinCtrl* spinner = new LLSpinCtrl(name,
+							rect,
+							label,
+							font,
+							callback,
+							NULL,
+							initial_value, 
+							min_value, 
+							max_value, 
+							increment,
+							"",
+							label_width);
+
+	spinner->setPrecision(precision);
+
+	spinner->initFromXML(node, parent);
+
+	return spinner;
+}
diff --git a/indra/llui/llspinctrl.h b/indra/llui/llspinctrl.h
new file mode 100644
index 0000000000..d6ccd4d6bf
--- /dev/null
+++ b/indra/llui/llspinctrl.h
@@ -0,0 +1,121 @@
+/** 
+ * @file llspinctrl.h
+ * @brief LLSpinCtrl base class
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLSPINCTRL_H
+#define LL_LLSPINCTRL_H
+
+
+#include "stdtypes.h"
+#include "lluictrl.h"
+#include "v4color.h"
+#include "llrect.h"
+
+//
+// Constants
+//
+const S32	SPINCTRL_BTN_HEIGHT		=  8;
+const S32	SPINCTRL_BTN_WIDTH		= 16;
+const S32	SPINCTRL_SPACING		=  2;							// space between label right and button left
+const S32	SPINCTRL_HEIGHT			=  2 * SPINCTRL_BTN_HEIGHT;
+const S32	SPINCTRL_DEFAULT_LABEL_WIDTH = 10;
+
+//
+// Classes
+//
+class LLFontGL;
+class LLButton;
+class LLTextBox;
+class LLLineEditor;
+
+
+class LLSpinCtrl
+: public LLUICtrl
+{
+public:
+	LLSpinCtrl(const LLString& name, const LLRect& rect,
+		const LLString& label,
+		const LLFontGL* font,
+		void (*commit_callback)(LLUICtrl*, void*),
+		void* callback_userdata,
+		F32 initial_value, F32 min_value, F32 max_value, F32 increment,
+		const LLString& control_name = LLString(),
+		S32 label_width = SPINCTRL_DEFAULT_LABEL_WIDTH );
+
+	virtual ~LLSpinCtrl();
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_SPINNER; }
+	virtual LLString getWidgetTag() const { return LL_SPIN_CTRL_TAG; }
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+			F32		get() { return (F32)getValue().asReal(); }
+			void	set(F32 value) { setValue(value); }
+
+	virtual void	setMinValue(LLSD min_value)	{ setMinValue((F32)min_value.asReal()); }
+	virtual void	setMaxValue(LLSD max_value)	{ setMaxValue((F32)max_value.asReal());  }
+
+	BOOL			isMouseHeldDown();
+
+	virtual void    setEnabled( BOOL b );
+	virtual void	setFocus( BOOL b );
+	virtual void	clear();
+	virtual void	setPrecision(S32 precision);
+	virtual void	setMinValue(F32 min)			{ mMinValue = min; }
+	virtual void	setMaxValue(F32 max)			{ mMaxValue = max; }
+	virtual void	setIncrement(F32 inc)			{ mIncrement = inc; }
+
+	void			setLabel(const LLString& label);
+	void			setLabelColor(const LLColor4& c)			{ mTextEnabledColor = c; }
+	void			setDisabledLabelColor(const LLColor4& c)	{ mTextDisabledColor = c; }
+
+	virtual void	onTabInto();
+
+	virtual void	setTentative(BOOL b);			// marks value as tentative
+	virtual void	onCommit();						// mark not tentative, then commit
+
+	void 			forceEditorCommit();			// for commit on external button
+
+	virtual BOOL	handleScrollWheel(S32 x,S32 y,S32 clicks);
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+
+	virtual void	draw();
+
+	static void		onEditorCommit(LLUICtrl* caller, void* userdata);
+	static void		onEditorGainFocus(LLUICtrl* caller, void *userdata);
+	static void		onEditorChangeFocus(LLUICtrl* caller, S32 direction, void *userdata);
+
+	static void		onUpBtn(void *userdata);
+	static void		onDownBtn(void *userdata);
+
+protected:
+	void			updateEditor();
+	void			reportInvalidData();
+
+protected:
+
+	F32				mValue;
+	F32				mInitialValue;
+	F32				mMaxValue;
+	F32				mMinValue;
+	F32				mIncrement;
+
+	S32				mPrecision;
+	LLTextBox*		mLabelBox;
+
+	LLLineEditor*	mEditor;
+	LLColor4		mTextEnabledColor;
+	LLColor4		mTextDisabledColor;
+
+	LLButton*		mUpBtn;
+	LLButton*		mDownBtn;
+
+	BOOL			mbHasBeenSet;
+};
+
+#endif  // LL_LLSPINCTRL_H
diff --git a/indra/llui/llstyle.cpp b/indra/llui/llstyle.cpp
new file mode 100644
index 0000000000..e03dd987d7
--- /dev/null
+++ b/indra/llui/llstyle.cpp
@@ -0,0 +1,223 @@
+/** 
+ * @file llstyle.cpp
+ * @brief Text style class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llstyle.h"
+#include "llstring.h"
+#include "llui.h"
+
+//#include "llviewerimagelist.h"
+
+LLStyle::LLStyle()
+{
+	init(TRUE, LLColor4(0,0,0,1),"");
+}
+
+LLStyle::LLStyle(const LLStyle &style)
+{
+	if (this != &style)
+	{
+		init(style.isVisible(),style.getColor(),style.getFontString());
+		if (style.isLink())
+		{
+			setLinkHREF(style.getLinkHREF());
+		}
+		mItalic = style.mItalic;
+		mBold = style.mBold;
+		mUnderline = style.mUnderline;
+		mDropShadow = style.mDropShadow;
+		mImageHeight = style.mImageHeight;
+		mImageWidth = style.mImageWidth;
+		mImagep = style.mImagep;
+		mIsEmbeddedItem = style.mIsEmbeddedItem;
+	}
+	else
+	{
+		init(TRUE, LLColor4(0,0,0,1),"");
+	}
+}
+
+LLStyle::LLStyle(BOOL is_visible, const LLColor4 &color, const LLString& font_name)
+{
+	init(is_visible, color, font_name);
+}
+
+LLStyle::~LLStyle()
+{
+	free();
+}
+
+void LLStyle::init(BOOL is_visible, const LLColor4 &color, const LLString& font_name)
+{
+	mVisible = is_visible;
+	mColor = color;
+	setFontName(font_name);
+	setLinkHREF("");
+	mItalic = FALSE;
+	mBold = FALSE;
+	mUnderline = FALSE;
+	mDropShadow = FALSE;
+	mImageHeight = 0;
+	mImageWidth = 0;
+	mIsEmbeddedItem = FALSE;
+}
+
+void LLStyle::free()
+{
+}
+
+LLFONT_ID LLStyle::getFontID() const
+{
+	return mFontID;	
+}
+
+// Copy assignment
+LLStyle &LLStyle::operator=(const LLStyle &rhs)
+{
+	if (this != &rhs)
+	{
+		setVisible(rhs.isVisible());
+		setColor(rhs.getColor());
+		this->mFontName = rhs.getFontString();
+		this->mLink = rhs.getLinkHREF();
+		mImagep = rhs.mImagep;
+		mImageHeight = rhs.mImageHeight;
+		mImageWidth = rhs.mImageWidth;
+		mItalic = rhs.mItalic;
+		mBold = rhs.mBold;
+		mUnderline = rhs.mUnderline;
+		mDropShadow = rhs.mUnderline;
+		mIsEmbeddedItem = rhs.mIsEmbeddedItem;
+	}
+	
+	return *this;
+}
+
+// Compare
+bool LLStyle::operator==(const LLStyle &rhs) const
+{
+	if ((mVisible != rhs.isVisible()) 
+		|| (mColor != rhs.getColor()) 
+		|| (mFontName != rhs.getFontString())
+		|| (mLink != rhs.getLinkHREF())
+		|| (mImagep != rhs.mImagep)
+		|| (mImageHeight != rhs.mImageHeight)
+		|| (mImageWidth != rhs.mImageWidth)
+		|| (mItalic != rhs.mItalic)
+		|| (mBold != rhs.mBold)
+		|| (mUnderline != rhs.mUnderline)
+		|| (mDropShadow != rhs.mDropShadow)
+		|| (mIsEmbeddedItem != rhs.mIsEmbeddedItem)
+		)
+	{
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool LLStyle::operator!=(const LLStyle& rhs) const
+{
+	return !(*this == rhs);
+}
+
+
+const LLColor4& LLStyle::getColor() const
+{
+	return(mColor);
+}
+
+void LLStyle::setColor(const LLColor4 &color)
+{
+	mColor = color;
+}
+
+const LLString& LLStyle::getFontString() const
+{
+	return mFontName;
+}
+
+void LLStyle::setFontName(const LLString& fontname)
+{
+	mFontName = fontname;
+
+	LLString fontname_lc = fontname;
+	LLString::toLower(fontname_lc);
+	
+	mFontID = LLFONT_OCRA; // default
+	
+	if ((fontname_lc == "sansserif") || (fontname_lc == "sans-serif"))
+	{
+		mFontID = LLFONT_SANSSERIF;
+	}
+	else if ((fontname_lc == "serif"))
+	{
+		mFontID = LLFONT_SMALL;
+	}
+	else if ((fontname_lc == "sansserifbig"))
+	{
+		mFontID = LLFONT_SANSSERIF_BIG;
+	}
+	else if (fontname_lc ==  "small")
+	{
+		mFontID = LLFONT_SANSSERIF_SMALL;
+	}
+}
+
+const LLString& LLStyle::getLinkHREF() const
+{
+	return mLink;
+}
+
+void LLStyle::setLinkHREF(const LLString& href)
+{
+	mLink = href;
+}
+
+BOOL LLStyle::isLink() const
+{
+	return mLink.size();
+}
+
+BOOL LLStyle::isVisible() const
+{
+	return mVisible;
+}
+
+void LLStyle::setVisible(BOOL is_visible)
+{
+	mVisible = is_visible;
+}
+
+LLImageGL *LLStyle::getImage() const
+{
+	return mImagep;
+}
+
+void LLStyle::setImage(const LLString& src)
+{
+	if (src.size() < UUID_STR_LENGTH - 1)
+	{
+		return;
+	}
+	else
+	{
+		mImagep = LLUI::sImageProvider->getUIImageByID(LLUUID(src));
+	}
+}
+
+BOOL LLStyle::isImage() const
+{
+	return ((mImageWidth != 0) && (mImageHeight != 0));
+}
+
+void LLStyle::setImageSize(S32 width, S32 height)
+{
+    mImageWidth = width;
+    mImageHeight = height;
+}
diff --git a/indra/llui/llstyle.h b/indra/llui/llstyle.h
new file mode 100644
index 0000000000..6a689dab98
--- /dev/null
+++ b/indra/llui/llstyle.h
@@ -0,0 +1,75 @@
+/** 
+ * @file llstyle.h
+ * @brief Text style class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLSTYLE_H
+#define LL_LLSTYLE_H
+
+#include "v4color.h"
+#include "llresmgr.h"
+#include "llfont.h"
+#include "llimagegl.h"
+
+class LLStyle
+{
+public:
+	LLStyle();
+	LLStyle(const LLStyle &style);
+	LLStyle(BOOL is_visible, const LLColor4 &color, const LLString& font_name);
+
+	LLStyle &operator=(const LLStyle &rhs);
+
+	virtual ~LLStyle();
+
+	virtual void init (BOOL is_visible, const LLColor4 &color, const LLString& font_name);
+	virtual void free ();
+
+	bool operator==(const LLStyle &rhs) const;
+	bool operator!=(const LLStyle &rhs) const;
+
+	virtual const LLColor4& getColor() const;
+	virtual void setColor(const LLColor4 &color);
+
+	virtual BOOL isVisible() const;
+	virtual void setVisible(BOOL is_visible);
+
+	virtual const LLString& getFontString() const;
+	virtual void setFontName(const LLString& fontname);
+	virtual LLFONT_ID getFontID() const;
+
+	virtual const LLString& getLinkHREF() const;
+	virtual void setLinkHREF(const LLString& fontname);
+	virtual BOOL isLink() const;
+
+	virtual LLImageGL *getImage() const;
+	virtual void setImage(const LLString& src);
+	virtual BOOL isImage() const;
+	virtual void setImageSize(S32 width, S32 height);
+
+	BOOL	getIsEmbeddedItem() const	{ return mIsEmbeddedItem; }
+	void	setIsEmbeddedItem( BOOL b ) { mIsEmbeddedItem = b; }
+
+public:	
+	BOOL        mItalic;
+	BOOL        mBold;
+	BOOL        mUnderline;
+	BOOL		mDropShadow;
+	S32         mImageWidth;
+	S32         mImageHeight;
+
+protected:
+	BOOL		mVisible;
+	LLColor4	mColor;
+	LLString	mFontName;
+	LLFONT_ID   mFontID;
+	LLString	mLink;
+	LLPointer<LLImageGL> mImagep;
+
+	BOOL		mIsEmbeddedItem;
+};
+
+#endif  // LL_LLSTYLE_H
diff --git a/indra/llui/lltabcontainer.cpp b/indra/llui/lltabcontainer.cpp
new file mode 100644
index 0000000000..fd85dbb2f4
--- /dev/null
+++ b/indra/llui/lltabcontainer.cpp
@@ -0,0 +1,1469 @@
+/** 
+ * @file lltabcontainer.cpp
+ * @brief LLTabContainerCommon base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "lltabcontainer.h"
+
+#include "llfocusmgr.h"
+#include "llfontgl.h"
+#include "llgl.h"
+
+#include "llbutton.h"
+#include "llrect.h"
+#include "llpanel.h"
+#include "llresmgr.h"
+#include "llkeyboard.h"
+#include "llresizehandle.h"
+#include "llui.h"
+#include "lltextbox.h"
+#include "llcontrol.h"
+#include "llcriticaldamp.h"
+#include "lluictrlfactory.h"
+
+#include "lltabcontainervertical.h"
+
+#include "llglheaders.h"
+
+const F32 SCROLL_STEP_TIME = 0.4f;
+const S32 TAB_PADDING = 15;
+const S32 TABCNTR_TAB_MIN_WIDTH = 60;
+const S32 TABCNTR_TAB_MAX_WIDTH = 150;
+const S32 TABCNTR_TAB_PARTIAL_WIDTH = 12;	// When tabs are parially obscured, how much can you still see.
+const S32 TABCNTR_TAB_HEIGHT = 16;
+const S32 TABCNTR_ARROW_BTN_SIZE = 16;
+const S32 TABCNTR_BUTTON_PANEL_OVERLAP = 1;  // how many pixels the tab buttons and tab panels overlap.
+const S32 TABCNTR_TAB_H_PAD = 4;
+
+
+LLTabContainerCommon::LLTabContainerCommon( 
+	const LLString& name, const LLRect& rect, 
+	TabPosition pos, 
+	void(*close_callback)(void*), void* callback_userdata,
+	BOOL bordered )
+	: 
+	LLPanel(name, rect, bordered),
+	mCurrentTabIdx(-1),
+	mScrolled(FALSE),
+	mScrollPos(0),
+	mScrollPosPixels(0),
+	mMaxScrollPos(0),
+	mCloseCallback( close_callback ),
+	mCallbackUserdata( callback_userdata ),
+	mTitleBox(NULL),
+	mTopBorderHeight(LLPANEL_BORDER_WIDTH),
+	mTabPosition(pos)
+{ 
+	setMouseOpaque(FALSE);
+}
+
+
+LLTabContainerCommon::LLTabContainerCommon( 
+	const LLString& name,
+	const LLString& rect_control,
+	TabPosition pos,
+	void(*close_callback)(void*), void* callback_userdata,
+	BOOL bordered )
+	: 
+	LLPanel(name, rect_control, bordered),
+	mCurrentTabIdx(-1),
+	mScrolled(FALSE),
+	mScrollPos(0),
+	mScrollPosPixels(0),
+	mMaxScrollPos(0),
+	mCloseCallback( close_callback ),
+	mCallbackUserdata( callback_userdata ),
+	mTitleBox(NULL),
+	mTopBorderHeight(LLPANEL_BORDER_WIDTH),
+	mTabPosition(pos)
+{
+	setMouseOpaque(FALSE);
+}
+
+
+LLTabContainerCommon::~LLTabContainerCommon()
+{
+	std::for_each(mTabList.begin(), mTabList.end(), DeletePointer());
+}
+
+LLView* LLTabContainerCommon::getChildByName(const LLString& name, BOOL recurse) const
+{
+	tuple_list_t::const_iterator itor;
+	for (itor = mTabList.begin(); itor != mTabList.end(); ++itor)
+	{
+		LLPanel *panel = (*itor)->mTabPanel;
+		if (panel->getName() == name)
+		{
+			return panel;
+		}
+	}
+	if (recurse)
+	{
+		for (itor = mTabList.begin(); itor != mTabList.end(); ++itor)
+		{
+			LLPanel *panel = (*itor)->mTabPanel;
+			LLView *child = panel->getChildByName(name, recurse);
+			if (child)
+			{
+				return child;
+			}
+		}
+	}
+	return LLView::getChildByName(name, recurse);
+}
+
+void LLTabContainerCommon::addPlaceholder(LLPanel* child, const LLString& label)
+{
+	addTabPanel(child, label, FALSE, NULL, NULL, 0, TRUE);
+}
+
+void LLTabContainerCommon::removeTabPanel(LLPanel* child)
+{
+	BOOL has_focus = gFocusMgr.childHasKeyboardFocus(this);
+
+	// If the tab being deleted is the selected one, select a different tab.
+	for(std::vector<LLTabTuple*>::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+	{
+		LLTabTuple* tuple = *iter;
+		if( tuple->mTabPanel == child )
+		{
+ 			removeChild( tuple->mButton );
+ 			delete tuple->mButton;
+
+ 			removeChild( tuple->mTabPanel );
+// 			delete tuple->mTabPanel;
+			
+			mTabList.erase( iter );
+			delete tuple;
+
+			break;
+		}
+	}
+	if (mCurrentTabIdx >= (S32)mTabList.size())
+	{
+		mCurrentTabIdx = mTabList.size()-1;
+	}
+	selectTab(mCurrentTabIdx);
+	if (has_focus)
+	{
+		LLPanel* panelp = getPanelByIndex(mCurrentTabIdx);
+		if (panelp)
+		{
+			panelp->setFocus(TRUE);
+		}
+	}
+
+	updateMaxScrollPos();
+}
+
+void LLTabContainerCommon::deleteAllTabs()
+{
+	// Remove all the tab buttons and delete them.  Also, unlink all the child panels.
+	for(std::vector<LLTabTuple*>::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+	{
+		LLTabTuple* tuple = *iter;
+
+		removeChild( tuple->mButton );
+		delete tuple->mButton;
+
+ 		removeChild( tuple->mTabPanel );
+// 		delete tuple->mTabPanel;
+	}
+
+	// Actually delete the tuples themselves
+	std::for_each(mTabList.begin(), mTabList.end(), DeletePointer());
+	mTabList.clear();
+	
+	// And there isn't a current tab any more
+	mCurrentTabIdx = -1;
+}
+
+
+LLPanel* LLTabContainerCommon::getCurrentPanel()
+{
+	if (mCurrentTabIdx < 0 || mCurrentTabIdx >= (S32) mTabList.size()) return NULL;
+		
+	return mTabList[mCurrentTabIdx]->mTabPanel;
+}
+
+LLTabContainerCommon::LLTabTuple* LLTabContainerCommon::getTabByPanel(LLPanel* child)
+{
+	for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+	{
+		LLTabTuple* tuple = *iter;
+		if( tuple->mTabPanel == child )
+		{
+			return tuple;
+		}
+	}
+	return NULL;
+}
+
+void LLTabContainerCommon::setTabChangeCallback(LLPanel* tab, void (*on_tab_clicked)(void*, bool))
+{
+	LLTabTuple* tuplep = getTabByPanel(tab);
+	if (tuplep)
+	{
+		tuplep->mOnChangeCallback = on_tab_clicked;
+	}
+}
+
+void LLTabContainerCommon::setTabUserData(LLPanel* tab, void* userdata)
+{
+	LLTabTuple* tuplep = getTabByPanel(tab);
+	if (tuplep)
+	{
+		tuplep->mUserData = userdata;
+	}
+}
+
+S32 LLTabContainerCommon::getCurrentPanelIndex()
+{
+	return mCurrentTabIdx;
+}
+
+S32 LLTabContainerCommon::getTabCount()
+{
+	return mTabList.size();
+}
+
+LLPanel* LLTabContainerCommon::getPanelByIndex(S32 index)
+{
+	if (index >= 0 && index < (S32)mTabList.size())
+	{
+		return mTabList[index]->mTabPanel;
+	}
+	return NULL;
+}
+
+S32 LLTabContainerCommon::getIndexForPanel(LLPanel* panel)
+{
+	for (S32 index = 0; index < (S32)mTabList.size(); index++)
+	{
+		if (mTabList[index]->mTabPanel == panel)
+		{
+			return index;
+		}
+	}
+	return -1;
+}
+
+S32 LLTabContainerCommon::getPanelIndexByTitle(const LLString& title)
+{
+	for (S32 index = 0 ; index < (S32)mTabList.size(); index++)
+	{
+		if (title == mTabList[index]->mButton->getLabelSelected())
+		{
+			return index;
+		}
+	}
+	return -1;
+}
+
+LLPanel *LLTabContainerCommon::getPanelByName(const LLString& name)
+{
+	for (S32 index = 0 ; index < (S32)mTabList.size(); index++)
+	{
+		LLPanel *panel = mTabList[index]->mTabPanel;
+		if (name == panel->getName())
+		{
+			return panel;
+		}
+	}
+	return NULL;
+}
+
+
+void LLTabContainerCommon::scrollNext()
+{
+	// No wrap
+	if( mScrollPos < mMaxScrollPos )
+	{
+		mScrollPos++;
+	}
+}
+
+void LLTabContainerCommon::scrollPrev()
+{
+	// No wrap
+	if( mScrollPos > 0 )
+	{
+		mScrollPos--;
+	}
+}
+
+void LLTabContainerCommon::enableTabButton(S32 which, BOOL enable)
+{
+	if (which >= 0 && which < (S32)mTabList.size())
+	{
+		mTabList[which]->mButton->setEnabled(enable);
+	}
+}
+
+BOOL LLTabContainerCommon::selectTabPanel(LLPanel* child)
+{
+	S32 idx = 0;
+	for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+	{
+		LLTabTuple* tuple = *iter;
+		if( tuple->mTabPanel == child )
+		{
+			return selectTab( idx );
+		}
+		idx++;
+	}
+	return FALSE;
+}
+
+BOOL LLTabContainerCommon::selectTabByName(const LLString& name)
+{
+	LLPanel* panel = getPanelByName(name);
+	if (!panel)
+	{
+		llwarns << "LLTabContainerCommon::selectTabByName("
+			<< name << ") failed" << llendl;
+		return FALSE;
+	}
+
+	BOOL result = selectTabPanel(panel);
+	return result;
+}
+
+
+void LLTabContainerCommon::selectFirstTab()
+{
+	selectTab( 0 );
+}
+
+
+void LLTabContainerCommon::selectLastTab()
+{
+	selectTab( mTabList.size()-1 );
+}
+
+
+void LLTabContainerCommon::selectNextTab()
+{
+	BOOL tab_has_focus = FALSE;
+	if (mCurrentTabIdx >= 0 && mTabList[mCurrentTabIdx]->mButton->hasFocus())
+	{
+		tab_has_focus = TRUE;
+	}
+	S32 idx = mCurrentTabIdx+1;
+	if (idx >= (S32)mTabList.size())
+		idx = 0;
+	while (!selectTab(idx) && idx != mCurrentTabIdx)
+	{
+		idx = (idx + 1 ) % (S32)mTabList.size();
+	}
+
+	if (tab_has_focus)
+	{
+		mTabList[idx]->mButton->setFocus(TRUE);
+	}
+}
+
+void LLTabContainerCommon::selectPrevTab()
+{
+	BOOL tab_has_focus = FALSE;
+	if (mCurrentTabIdx >= 0 && mTabList[mCurrentTabIdx]->mButton->hasFocus())
+	{
+		tab_has_focus = TRUE;
+	}
+	S32 idx = mCurrentTabIdx-1;
+	if (idx < 0)
+		idx = mTabList.size()-1;
+	while (!selectTab(idx) && idx != mCurrentTabIdx)
+	{
+		idx = idx - 1;
+		if (idx < 0)
+			idx = mTabList.size()-1;
+	}
+	if (tab_has_focus)
+	{
+		mTabList[idx]->mButton->setFocus(TRUE);
+	}
+}	
+
+
+void LLTabContainerCommon::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	LLPanel::reshape( width, height, called_from_parent );
+	updateMaxScrollPos();
+}
+
+// static 
+void LLTabContainerCommon::onTabBtn( void* userdata )
+{
+	LLTabTuple* tuple = (LLTabTuple*) userdata;
+	LLTabContainerCommon* self = tuple->mTabContainer;
+	self->selectTabPanel( tuple->mTabPanel );
+	
+	if( tuple->mOnChangeCallback )
+	{
+		tuple->mOnChangeCallback( tuple->mUserData, true );
+	}
+
+	tuple->mTabPanel->setFocus(TRUE);
+}
+
+// static 
+void LLTabContainerCommon::onCloseBtn( void* userdata )
+{
+	LLTabContainer* self = (LLTabContainer*) userdata;
+	if( self->mCloseCallback )
+	{
+		self->mCloseCallback( self->mCallbackUserdata );
+	}
+}
+
+// static 
+void LLTabContainerCommon::onNextBtn( void* userdata )
+{
+	// Scroll tabs to the left
+	LLTabContainer* self = (LLTabContainer*) userdata;
+	if (!self->mScrolled)
+	{
+		self->scrollNext();
+	}
+	self->mScrolled = FALSE;
+}
+
+// static 
+void LLTabContainerCommon::onNextBtnHeld( void* userdata )
+{
+	LLTabContainer* self = (LLTabContainer*) userdata;
+	if (self->mScrollTimer.getElapsedTimeF32() > SCROLL_STEP_TIME)
+	{
+		self->mScrollTimer.reset();
+		self->scrollNext();
+		self->mScrolled = TRUE;
+	}
+}
+
+// static 
+void LLTabContainerCommon::onPrevBtn( void* userdata )
+{
+	LLTabContainer* self = (LLTabContainer*) userdata;
+	if (!self->mScrolled)
+	{
+		self->scrollPrev();
+	}
+	self->mScrolled = FALSE;
+}
+
+// static 
+void LLTabContainerCommon::onPrevBtnHeld( void* userdata )
+{
+	LLTabContainer* self = (LLTabContainer*) userdata;
+	if (self->mScrollTimer.getElapsedTimeF32() > SCROLL_STEP_TIME)
+	{
+		self->mScrollTimer.reset();
+		self->scrollPrev();
+		self->mScrolled = TRUE;
+	}
+}
+
+BOOL LLTabContainerCommon::getTabPanelFlashing(LLPanel *child)
+{
+	LLTabTuple* tuple = getTabByPanel(child);
+	if( tuple )
+	{
+		return tuple->mButton->getFlashing();
+	}
+	return FALSE;
+}
+
+void LLTabContainerCommon::setTabPanelFlashing(LLPanel* child, BOOL state )
+{
+	LLTabTuple* tuple = getTabByPanel(child);
+	if( tuple )
+	{
+		tuple->mButton->setFlashing( state );
+	}
+}
+
+void LLTabContainerCommon::setTitle(const LLString& title)
+{
+	if (mTitleBox)
+	{
+		mTitleBox->setText( title );
+	}
+}
+
+const LLString LLTabContainerCommon::getPanelTitle(S32 index)
+{
+	if (index >= 0 && index < (S32)mTabList.size())
+	{
+		LLButton* tab_button = mTabList[index]->mButton;
+		return tab_button->getLabelSelected();
+	}
+	return LLString::null;
+}
+
+void LLTabContainerCommon::setTopBorderHeight(S32 height)
+{
+	mTopBorderHeight = height;
+}
+
+// Change the name of the button for the current tab.
+void LLTabContainerCommon::setCurrentTabName(const LLString& name)
+{
+	// Might not have a tab selected
+	if (mCurrentTabIdx < 0) return;
+
+	mTabList[mCurrentTabIdx]->mButton->setLabelSelected(name);
+	mTabList[mCurrentTabIdx]->mButton->setLabelUnselected(name);
+}
+
+LLView* LLTabContainerCommon::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("tab_container");
+	node->getAttributeString("name", name);
+
+	// Figure out if we are creating a vertical or horizontal tab container.
+	bool is_vertical = false;
+	LLTabContainer::TabPosition tab_position = LLTabContainer::TOP;
+	if (node->hasAttribute("tab_position"))
+	{
+		LLString tab_position_string;
+		node->getAttributeString("tab_position", tab_position_string);
+		LLString::toLower(tab_position_string);
+
+		if ("top" == tab_position_string)
+		{
+			tab_position = LLTabContainer::TOP;
+			is_vertical = false;
+		}
+		else if ("bottom" == tab_position_string)
+		{
+			tab_position = LLTabContainer::BOTTOM;
+			is_vertical = false;
+		}
+		else if ("left" == tab_position_string)
+		{
+			is_vertical = true;
+		}
+	}
+	BOOL border = FALSE;
+	node->getAttributeBOOL("border", border);
+
+	// Create the correct container type.
+	LLTabContainerCommon* 	tab_container = NULL;
+
+	if (is_vertical)
+	{
+		// Vertical tabs can specify tab width
+		U32 tab_width = TABCNTRV_TAB_WIDTH;
+		if (node->hasAttribute("tab_width"))
+		{
+			node->getAttributeU32("tab_width", tab_width);
+		}
+
+		tab_container = new LLTabContainerVertical(name,
+				LLRect::null,
+				NULL,
+				NULL,
+				tab_width,
+				border);
+
+	}
+	else // horizontal tab container
+	{
+		// Horizontal tabs can have a title (?)
+		LLString title(LLString::null);
+		if (node->hasAttribute("title"))
+		{
+			node->getAttributeString("title", title);
+		}
+
+		tab_container = new LLTabContainer(name,
+				LLRect::null,
+				tab_position,
+				NULL,
+				NULL,
+				title,
+				border);
+		
+		if(node->hasAttribute("tab_min_width"))
+		{
+			S32	minTabWidth=0;
+			node->getAttributeS32("tab_min_width",minTabWidth);
+			((LLTabContainer*)tab_container)->setMinTabWidth(minTabWidth); 
+		}
+		if(node->hasAttribute("tab_max_width"))
+		{
+			S32	maxTabWidth=0;
+			node->getAttributeS32("tab_max_width",maxTabWidth);
+			((LLTabContainer*)tab_container)->setMaxTabWidth(maxTabWidth); 
+		}
+	}
+	
+	tab_container->setPanelParameters(node, parent);
+
+	if (LLFloater::getFloaterHost())
+	{
+		LLFloater::getFloaterHost()->setTabContainer(tab_container);
+	}
+
+	//parent->addChild(tab_container);
+
+	// Add all tab panels.
+	LLXMLNodePtr child;
+	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+	{
+		LLView *control = factory->createCtrlWidget(tab_container, child);
+		if (control && control->isPanel())
+		{
+			LLPanel* panelp = (LLPanel*)control;
+			LLString label;
+			child->getAttributeString("label", label);
+			if (label.empty())
+			{
+				label = panelp->getLabel();
+			}
+			BOOL placeholder = FALSE;
+			child->getAttributeBOOL("placeholder", placeholder);
+			tab_container->addTabPanel(panelp, label.c_str(), false,
+									   NULL, NULL, 0, placeholder);
+		}
+	}
+
+	tab_container->selectFirstTab();
+
+	tab_container->postBuild();
+
+	tab_container->initButtons(); // now that we have the correct rect
+	
+	return tab_container;
+}
+
+void LLTabContainerCommon::insertTuple(LLTabTuple * tuple, eInsertionPoint insertion_point)
+{
+	switch(insertion_point)
+	{
+	case START:
+		// insert the new tab in the front of the list
+		mTabList.insert(mTabList.begin(), tuple);
+		break;
+	case RIGHT_OF_CURRENT:
+		// insert the new tab after the current tab
+		{
+		tuple_list_t::iterator current_iter = mTabList.begin() + mCurrentTabIdx + 1;
+		mTabList.insert(current_iter, tuple);
+		}
+		break;
+	case END:
+	default:
+		mTabList.push_back( tuple );
+	}
+}
+
+
+LLTabContainer::LLTabContainer( 
+	const LLString& name, const LLRect& rect, TabPosition pos,
+	void(*close_callback)(void*), void* callback_userdata,
+	const LLString& title, BOOL bordered )
+	: 
+	LLTabContainerCommon(name, rect, pos, close_callback, callback_userdata, bordered),
+	mLeftArrowBtn(NULL),
+	mRightArrowBtn(NULL),
+	mRightTabBtnOffset(0),
+	mMinTabWidth(TABCNTR_TAB_MIN_WIDTH),
+	mMaxTabWidth(TABCNTR_TAB_MAX_WIDTH),
+	mTotalTabWidth(0)
+{
+	initButtons( );
+}
+
+LLTabContainer::LLTabContainer( 
+	const LLString& name, const LLString& rect_control, TabPosition pos,
+	void(*close_callback)(void*), void* callback_userdata,
+	const LLString& title, BOOL bordered )
+	: 
+	LLTabContainerCommon(name, rect_control, pos, close_callback, callback_userdata, bordered),
+	mLeftArrowBtn(NULL),
+	mRightArrowBtn(NULL),
+	mRightTabBtnOffset(0),
+	mMinTabWidth(TABCNTR_TAB_MIN_WIDTH),
+	mMaxTabWidth(TABCNTR_TAB_MAX_WIDTH),
+	mTotalTabWidth(0)
+{
+	initButtons( );
+}
+
+void LLTabContainer::initButtons()
+{
+	// Hack:
+	if (mRect.getHeight() == 0 || mLeftArrowBtn)
+	{
+		return; // Don't have a rect yet or already got called
+	}
+	
+	LLString out_id;
+	LLString in_id;
+
+	S32 arrow_fudge = 1;		//  match new art better 
+
+	// tabs on bottom reserve room for resize handle (just in case)
+	if (mTabPosition == BOTTOM)
+	{
+		mRightTabBtnOffset = RESIZE_HANDLE_WIDTH;
+	}
+
+	// Left and right scroll arrows (for when there are too many tabs to show all at once).
+	S32 btn_top = (mTabPosition == TOP ) ? mRect.getHeight() - mTopBorderHeight : TABCNTR_ARROW_BTN_SIZE + 1;
+
+	LLRect left_arrow_btn_rect;
+	left_arrow_btn_rect.setLeftTopAndSize( LLPANEL_BORDER_WIDTH+1, btn_top + arrow_fudge, TABCNTR_ARROW_BTN_SIZE, TABCNTR_ARROW_BTN_SIZE );
+
+	S32 right_pad = TABCNTR_ARROW_BTN_SIZE + LLPANEL_BORDER_WIDTH + 1;
+	LLRect right_arrow_btn_rect;
+	right_arrow_btn_rect.setLeftTopAndSize( mRect.getWidth() - mRightTabBtnOffset - right_pad,
+											btn_top + arrow_fudge,
+											TABCNTR_ARROW_BTN_SIZE, TABCNTR_ARROW_BTN_SIZE );
+
+	out_id = "UIImgBtnScrollLeftOutUUID";
+	in_id = "UIImgBtnScrollLeftInUUID";
+	mLeftArrowBtn = new LLButton(
+		"Left Arrow", left_arrow_btn_rect,
+		out_id, in_id, "",
+		&LLTabContainer::onPrevBtn, this, LLFontGL::sSansSerif );
+	mLeftArrowBtn->setHeldDownCallback(onPrevBtnHeld);
+	mLeftArrowBtn->setFollowsLeft();
+	mLeftArrowBtn->setSaveToXML(false);
+	mLeftArrowBtn->setTabStop(FALSE);
+	addChild(mLeftArrowBtn);
+
+	out_id = "UIImgBtnScrollRightOutUUID";
+	in_id = "UIImgBtnScrollRightInUUID";
+	mRightArrowBtn = new LLButton(
+		"Right Arrow", right_arrow_btn_rect,
+		out_id, in_id, "",
+		&LLTabContainer::onNextBtn, this,
+		LLFontGL::sSansSerif);
+	mRightArrowBtn->setFollowsRight();
+	mRightArrowBtn->setHeldDownCallback(onNextBtnHeld);
+	mRightArrowBtn->setSaveToXML(false);
+	mRightArrowBtn->setTabStop(FALSE);
+	addChild(mRightArrowBtn);
+
+	if( mTabPosition == TOP )
+	{
+		mRightArrowBtn->setFollowsTop();
+		mLeftArrowBtn->setFollowsTop();
+	}
+	else
+	{
+		mRightArrowBtn->setFollowsBottom();
+		mLeftArrowBtn->setFollowsBottom();
+	}
+
+	// set default tab group to be panel contents
+	mDefaultTabGroup = 1;
+}
+
+LLTabContainer::~LLTabContainer()
+{
+}
+
+void LLTabContainer::addTabPanel(LLPanel* child, 
+								 const LLString& label, 
+								 BOOL select, 
+								 void (*on_tab_clicked)(void*, bool), 
+								 void* userdata,
+								 S32 indent,
+								 BOOL placeholder,
+								 eInsertionPoint insertion_point)
+{
+	if (child->getParent() == this)
+	{
+		// already a child of mine
+		return;
+	}
+	const LLFontGL* font = gResMgr->getRes( LLFONT_SANSSERIF_SMALL );
+
+	// Store the original label for possible xml export.
+	child->setLabel(label);
+	LLString trimmed_label = label;
+	LLString::trim(trimmed_label);
+
+	S32 button_width = llclamp(font->getWidth(trimmed_label) + TAB_PADDING, mMinTabWidth, mMaxTabWidth);
+
+	// Tab panel
+	S32 tab_panel_top;
+	S32 tab_panel_bottom;
+	if( LLTabContainer::TOP == mTabPosition )
+	{
+		tab_panel_top = mRect.getHeight() - mTopBorderHeight - (TABCNTR_TAB_HEIGHT - TABCNTR_BUTTON_PANEL_OVERLAP);	
+		tab_panel_bottom = LLPANEL_BORDER_WIDTH;
+	}
+	else
+	{
+		tab_panel_top = mRect.getHeight() - mTopBorderHeight;
+		tab_panel_bottom = (TABCNTR_TAB_HEIGHT - TABCNTR_BUTTON_PANEL_OVERLAP);  // Run to the edge, covering up the border
+	}
+	
+	LLRect tab_panel_rect(
+		LLPANEL_BORDER_WIDTH, 
+		tab_panel_top,
+		mRect.getWidth()-LLPANEL_BORDER_WIDTH,
+		tab_panel_bottom );
+
+	child->setFollowsAll();
+	child->translate( tab_panel_rect.mLeft - child->getRect().mLeft, tab_panel_rect.mBottom - child->getRect().mBottom);
+	child->reshape( tab_panel_rect.getWidth(), tab_panel_rect.getHeight(), TRUE );
+	child->setBackgroundVisible( FALSE );  // No need to overdraw
+	// add this child later
+
+	child->setVisible( FALSE );  // Will be made visible when selected
+
+	mTotalTabWidth += button_width;
+
+	// Tab button
+	LLRect btn_rect;  // Note: btn_rect.mLeft is just a dummy.  Will be updated in draw().
+	LLString tab_img;
+	LLString tab_selected_img;
+	S32 tab_fudge = 1;		//  To make new tab art look better, nudge buttons up 1 pel
+
+	if( LLTabContainer::TOP == mTabPosition )
+	{
+		btn_rect.setLeftTopAndSize( 0, mRect.getHeight() - mTopBorderHeight + tab_fudge, button_width, TABCNTR_TAB_HEIGHT );
+		tab_img = "UIImgBtnTabTopOutUUID";
+		tab_selected_img = "UIImgBtnTabTopInUUID";
+	}
+	else
+	{
+		btn_rect.setOriginAndSize( 0, 0 + tab_fudge, button_width, TABCNTR_TAB_HEIGHT );
+		tab_img = "UIImgBtnTabBottomOutUUID";
+		tab_selected_img = "UIImgBtnTabBottomInUUID";
+	}
+
+	if (placeholder)
+	{
+		//FIXME: wont work for horizontal tabs
+		btn_rect.translate(0, -LLBUTTON_V_PAD-2);
+		LLString box_label = trimmed_label;
+		LLTextBox* text = new LLTextBox(box_label, btn_rect, box_label, font);
+		addChild( text, 0 );
+
+		LLButton* btn = new LLButton("", LLRect(0,0,0,0));
+		LLTabTuple* tuple = new LLTabTuple( this, child, btn, on_tab_clicked, userdata, text );
+		addChild( btn, 0 );
+		addChild( child, 1 );
+		insertTuple(tuple, insertion_point);
+	}
+	else
+	{
+		LLString tooltip = trimmed_label;
+		tooltip += "\nCtrl-[ for previous tab";
+		tooltip += "\nCtrl-] for next tab";
+
+		LLButton* btn = new LLButton(
+			LLString(child->getName()) + " tab",
+			btn_rect, 
+			tab_img, tab_selected_img, "",
+			&LLTabContainer::onTabBtn, NULL, // set userdata below
+			font,
+			trimmed_label, trimmed_label );
+		btn->setSaveToXML(false);
+		btn->setVisible( FALSE );
+		btn->setToolTip( tooltip );
+		btn->setScaleImage(TRUE);
+		btn->setFixedBorder(14, 14);
+
+		// Try to squeeze in a bit more text
+		btn->setLeftHPad( 4 );
+		btn->setRightHPad( 2 );
+		btn->setHAlign(LLFontGL::LEFT);
+		btn->setTabStop(FALSE);
+		if (indent)
+		{
+			btn->setLeftHPad(indent);
+		}
+
+		if( mTabPosition == TOP )
+		{
+			btn->setFollowsTop();
+		}
+		else
+		{
+			btn->setFollowsBottom();
+		}
+
+		LLTabTuple* tuple = new LLTabTuple( this, child, btn, on_tab_clicked, userdata );
+		btn->setCallbackUserData( tuple );
+		addChild( btn, 0 );
+		addChild( child, 1 );
+		insertTuple(tuple, insertion_point);
+	}
+
+	updateMaxScrollPos();
+
+	if( select )
+	{
+		selectLastTab();
+	}
+}
+
+void LLTabContainer::removeTabPanel(LLPanel* child)
+{
+	// Adjust the total tab width.
+	for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+	{
+		LLTabTuple* tuple = *iter;
+		if( tuple->mTabPanel == child )
+		{
+			mTotalTabWidth -= tuple->mButton->getRect().getWidth();
+			break;
+		}
+	}
+
+	LLTabContainerCommon::removeTabPanel(child);
+}
+
+void LLTabContainer::setPanelTitle(S32 index, const LLString& title)
+{
+	if (index >= 0 && index < (S32)mTabList.size())
+	{
+		LLButton* tab_button = mTabList[index]->mButton;
+		const LLFontGL* fontp = gResMgr->getRes( LLFONT_SANSSERIF_SMALL );
+		mTotalTabWidth -= tab_button->getRect().getWidth();
+		tab_button->reshape(llclamp(fontp->getWidth(title) + TAB_PADDING, mMinTabWidth, mMaxTabWidth), tab_button->getRect().getHeight());
+		mTotalTabWidth += tab_button->getRect().getWidth();
+		tab_button->setLabelSelected(title);
+		tab_button->setLabelUnselected(title);
+	}
+	updateMaxScrollPos();
+}
+
+
+void LLTabContainer::updateMaxScrollPos()
+{
+	S32 tab_space = 0;
+	S32 available_space = 0;
+	tab_space = mTotalTabWidth;
+	available_space = mRect.getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + TABCNTR_TAB_H_PAD);
+
+	if( tab_space > available_space )
+	{
+		S32 available_width_with_arrows = mRect.getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + TABCNTR_ARROW_BTN_SIZE + 1);
+		// subtract off reserved portion on left
+		available_width_with_arrows -= TABCNTR_TAB_PARTIAL_WIDTH;
+
+		S32 running_tab_width = 0;
+		mMaxScrollPos = mTabList.size();
+		for(tuple_list_t::reverse_iterator tab_it = mTabList.rbegin(); tab_it != mTabList.rend(); ++tab_it)
+		{
+			running_tab_width += (*tab_it)->mButton->getRect().getWidth();
+			if (running_tab_width > available_width_with_arrows)
+			{
+				break;
+			}
+			mMaxScrollPos--;
+		}
+		// in case last tab doesn't actually fit on screen, make it the last scrolling position
+		mMaxScrollPos = llmin(mMaxScrollPos, (S32)mTabList.size() - 1);
+	}
+	else
+	{
+		mMaxScrollPos = 0;
+		mScrollPos = 0;
+	}
+	if (mScrollPos > mMaxScrollPos)
+	{
+		mScrollPos = mMaxScrollPos;
+	}
+}
+
+void LLTabContainer::commitHoveredButton(S32 x, S32 y)
+{
+	if (gFocusMgr.getMouseCapture() == this)
+	{
+		for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+		{
+			LLTabTuple* tuple = *iter;
+			tuple->mButton->setVisible( TRUE );
+			S32 local_x = x - tuple->mButton->getRect().mLeft;
+			S32 local_y = y - tuple->mButton->getRect().mBottom;
+			if (tuple->mButton->pointInView(local_x, local_y) && tuple->mButton->getEnabled() && !tuple->mTabPanel->getVisible())
+			{
+				tuple->mButton->onCommit();
+			}
+		}
+	}
+}
+
+void LLTabContainer::setMinTabWidth(S32 width)
+{
+	mMinTabWidth = width;
+}
+
+void LLTabContainer::setMaxTabWidth(S32 width)
+{
+	mMaxTabWidth = width;
+}
+
+S32 LLTabContainer::getMinTabWidth() const
+{
+	return mMinTabWidth;
+}
+
+S32 LLTabContainer::getMaxTabWidth() const
+{
+	return mMaxTabWidth;
+}
+
+BOOL LLTabContainer::selectTab(S32 which)
+{
+	if (which >= (S32)mTabList.size()) return FALSE;
+	if (which < 0) return FALSE;
+
+	//if( gFocusMgr.childHasKeyboardFocus( this ) )
+	//{
+	//	gFocusMgr.setKeyboardFocus( NULL, NULL );
+	//}
+
+	LLTabTuple* selected_tuple = mTabList[which];
+	if (!selected_tuple)
+	{
+		return FALSE;
+	}
+	
+	if (mTabList[which]->mButton->getEnabled())
+	{
+		mCurrentTabIdx = which;
+
+		S32 i = 0;
+		for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+		{
+			LLTabTuple* tuple = *iter;
+			BOOL is_selected = ( tuple == selected_tuple );
+			tuple->mTabPanel->setVisible( is_selected );
+// 			tuple->mTabPanel->setFocus(is_selected); // not clear that we want to do this here.
+			tuple->mButton->setToggleState( is_selected );
+			// RN: this limits tab-stops to active button only, which would require arrow keys to switch tabs
+			tuple->mButton->setTabStop( is_selected && mTabList.size() > 1 );
+			
+			if( is_selected && mMaxScrollPos > 0)
+			{
+				// Make sure selected tab is within scroll region
+				if( i < mScrollPos )
+				{
+					mScrollPos = i;
+				}
+				else
+				{
+					S32 available_width_with_arrows = mRect.getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + TABCNTR_ARROW_BTN_SIZE + 1);
+					S32 running_tab_width = tuple->mButton->getRect().getWidth();
+					S32 j = i - 1;
+					S32 min_scroll_pos = i;
+					if (running_tab_width < available_width_with_arrows)
+					{
+						while (j >= 0)
+						{
+							LLTabTuple* other_tuple = mTabList[j];
+							running_tab_width += other_tuple->mButton->getRect().getWidth();
+							if (running_tab_width > available_width_with_arrows)
+							{
+								break;
+							}
+							j--;
+						}
+						min_scroll_pos = j + 1;
+					}
+					mScrollPos = llclamp(mScrollPos, min_scroll_pos, i);
+					mScrollPos = llmin(mScrollPos, mMaxScrollPos);
+				}
+			}
+			i++;
+		}
+		if( selected_tuple->mOnChangeCallback )
+		{
+			selected_tuple->mOnChangeCallback( selected_tuple->mUserData, false );
+		}
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+void LLTabContainer::draw()
+{
+	S32 target_pixel_scroll = 0;
+	S32 cur_scroll_pos = mScrollPos;
+	if (cur_scroll_pos > 0)
+	{
+		S32 available_width_with_arrows = mRect.getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + TABCNTR_ARROW_BTN_SIZE + 1);
+		for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+		{
+			if (cur_scroll_pos == 0)
+			{
+				break;
+			}
+			target_pixel_scroll += (*iter)->mButton->getRect().getWidth();
+			cur_scroll_pos--;
+		}
+
+		// Show part of the tab to the left of what is fully visible
+		target_pixel_scroll -= TABCNTR_TAB_PARTIAL_WIDTH;
+		// clamp so that rightmost tab never leaves right side of screen
+		target_pixel_scroll = llmin(mTotalTabWidth - available_width_with_arrows, target_pixel_scroll);
+	}
+
+	mScrollPosPixels = (S32)lerp((F32)mScrollPosPixels, (F32)target_pixel_scroll, LLCriticalDamp::getInterpolant(0.08f));
+	if( getVisible() )
+	{
+		BOOL has_scroll_arrows = (mMaxScrollPos > 0) || (mScrollPosPixels > 0);
+		mLeftArrowBtn->setVisible( has_scroll_arrows );
+		mRightArrowBtn->setVisible( has_scroll_arrows );
+
+		// Set the leftmost position of the tab buttons.
+		S32 left = LLPANEL_BORDER_WIDTH + (has_scroll_arrows ? TABCNTR_ARROW_BTN_SIZE : TABCNTR_TAB_H_PAD);
+		left -= mScrollPosPixels;
+
+		// Hide all the buttons
+		for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+		{
+			LLTabTuple* tuple = *iter;
+			tuple->mButton->setVisible( FALSE );
+		}
+
+		LLPanel::draw();
+
+		// Show all the buttons
+		for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+		{
+			LLTabTuple* tuple = *iter;
+			tuple->mButton->setVisible( TRUE );
+		}
+
+		// Draw some of the buttons...
+
+		LLGLEnable scissor_test(has_scroll_arrows ? GL_SCISSOR_TEST : GL_FALSE);
+		if( has_scroll_arrows )
+		{
+			// ...but clip them.
+			S32 x1 = mLeftArrowBtn->getRect().mRight;
+			S32 y1 = 0;
+			S32 x2 = mRightArrowBtn->getRect().mLeft;
+			S32 y2 = 1;
+			if (mTabList.size() > 0)
+			{
+				y2 = mTabList[0]->mButton->getRect().mTop;
+			}
+			LLUI::setScissorRegionLocal(LLRect(x1, y2, x2, y1));
+		}
+
+		S32 max_scroll_visible = mTabList.size() - mMaxScrollPos + mScrollPos;
+		S32 idx = 0;
+		for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+		{
+			LLTabTuple* tuple = *iter;
+			tuple->mButton->translate( left - tuple->mButton->getRect().mLeft, 0 );
+			left += tuple->mButton->getRect().getWidth();
+
+			if( idx < mScrollPos )
+			{
+				if( tuple->mButton->getFlashing() )
+				{
+					mLeftArrowBtn->setFlashing( TRUE );
+				}
+			}
+			else
+			if( max_scroll_visible < idx )
+			{
+				if( tuple->mButton->getFlashing() )
+				{
+					mRightArrowBtn->setFlashing( TRUE );
+				}
+			}
+
+			LLUI::pushMatrix();
+			{
+				LLUI::translate((F32)tuple->mButton->getRect().mLeft, (F32)tuple->mButton->getRect().mBottom, 0.f);
+				tuple->mButton->draw();
+			}
+			LLUI::popMatrix();
+		
+			idx++;
+		}
+
+		mLeftArrowBtn->setFlashing(FALSE);
+		mRightArrowBtn->setFlashing(FALSE);
+	}
+}
+
+
+void LLTabContainer::setRightTabBtnOffset(S32 offset)
+{
+	mRightArrowBtn->translate( -offset - mRightTabBtnOffset, 0 );
+	mRightTabBtnOffset = offset;
+	updateMaxScrollPos();
+}
+
+BOOL LLTabContainer::handleMouseDown( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = FALSE;
+	BOOL has_scroll_arrows = (mMaxScrollPos > 0);
+
+	if (has_scroll_arrows)
+	{
+		if (mLeftArrowBtn->getRect().pointInRect(x, y))
+		{
+			S32 local_x = x - mLeftArrowBtn->getRect().mLeft;
+			S32 local_y = y - mLeftArrowBtn->getRect().mBottom;
+			handled = mLeftArrowBtn->handleMouseDown(local_x, local_y, mask);
+		}
+		else if (mRightArrowBtn->getRect().pointInRect(x, y))
+		{
+			S32 local_x = x - mRightArrowBtn->getRect().mLeft;
+			S32 local_y = y - mRightArrowBtn->getRect().mBottom;
+			handled = mRightArrowBtn->handleMouseDown(local_x, local_y, mask);
+		}
+	}
+	if (!handled)
+	{
+		handled = LLPanel::handleMouseDown( x, y, mask );
+	}
+
+	if (mTabList.size() > 0)
+	{
+		LLTabTuple* firsttuple = mTabList[0];
+		LLRect tab_rect(has_scroll_arrows ? mLeftArrowBtn->getRect().mRight : mLeftArrowBtn->getRect().mLeft,
+						firsttuple->mButton->getRect().mTop,
+						has_scroll_arrows ? mRightArrowBtn->getRect().mLeft : mRightArrowBtn->getRect().mRight,
+						firsttuple->mButton->getRect().mBottom );
+		if( tab_rect.pointInRect( x, y ) )
+		{
+			LLButton* tab_button = mTabList[getCurrentPanelIndex()]->mButton;
+			gFocusMgr.setMouseCapture(this, NULL);
+			gFocusMgr.setKeyboardFocus(tab_button, NULL);
+		}
+	}
+	return handled;
+}
+
+BOOL LLTabContainer::handleHover( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = FALSE;
+	BOOL has_scroll_arrows = (mMaxScrollPos > 0);
+
+	if (has_scroll_arrows)
+	{
+		if (mLeftArrowBtn->getRect().pointInRect(x, y))
+		{
+			S32 local_x = x - mLeftArrowBtn->getRect().mLeft;
+			S32 local_y = y - mLeftArrowBtn->getRect().mBottom;
+			handled = mLeftArrowBtn->handleHover(local_x, local_y, mask);
+		}
+		else if (mRightArrowBtn->getRect().pointInRect(x, y))
+		{
+			S32 local_x = x - mRightArrowBtn->getRect().mLeft;
+			S32 local_y = y - mRightArrowBtn->getRect().mBottom;
+			handled = mRightArrowBtn->handleHover(local_x, local_y, mask);
+		}
+	}
+	if (!handled)
+	{
+		handled = LLPanel::handleHover(x, y, mask);
+	}
+
+	commitHoveredButton(x, y);
+	return handled;
+}
+
+BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
+{
+	BOOL handled = FALSE;
+	BOOL has_scroll_arrows = (mMaxScrollPos > 0);
+
+	if (has_scroll_arrows)
+	{
+		if (mLeftArrowBtn->getRect().pointInRect(x, y))
+		{
+			S32 local_x = x - mLeftArrowBtn->getRect().mLeft;
+			S32 local_y = y - mLeftArrowBtn->getRect().mBottom;
+			handled = mLeftArrowBtn->handleMouseUp(local_x, local_y, mask);
+		}
+		else if (mRightArrowBtn->getRect().pointInRect(x, y))
+		{
+			S32 local_x = x - mRightArrowBtn->getRect().mLeft;
+			S32 local_y = y - mRightArrowBtn->getRect().mBottom;
+			handled = mRightArrowBtn->handleMouseUp(local_x, local_y, mask);
+		}
+	}
+	if (!handled)
+	{
+		handled = LLPanel::handleMouseUp( x, y, mask );
+	}
+
+	commitHoveredButton(x, y);
+	LLPanel* cur_panel = getCurrentPanel();
+	if (gFocusMgr.getMouseCapture() == this)
+	{
+		if (cur_panel)
+		{
+			if (!cur_panel->focusFirstItem(FALSE))
+			{
+				// if nothing in the panel gets focus, make sure the new tab does
+				// otherwise the last tab might keep focus
+				mTabList[getCurrentPanelIndex()]->mButton->setFocus(TRUE);
+			}
+		}
+		gFocusMgr.setMouseCapture(NULL, NULL);
+	}
+	return handled;
+}
+
+BOOL LLTabContainer::handleToolTip( S32 x, S32 y, LLString& msg, LLRect* sticky_rect )
+{
+	BOOL handled = LLPanel::handleToolTip( x, y, msg, sticky_rect );
+	if (!handled && mTabList.size() > 0 && getVisible() && pointInView( x, y ) ) 
+	{
+		LLTabTuple* firsttuple = mTabList[0];
+
+		BOOL has_scroll_arrows = (mMaxScrollPos > 0);
+		LLRect clip(
+			has_scroll_arrows ? mLeftArrowBtn->getRect().mRight : mLeftArrowBtn->getRect().mLeft,
+			firsttuple->mButton->getRect().mTop,
+			has_scroll_arrows ? mRightArrowBtn->getRect().mLeft : mRightArrowBtn->getRect().mRight,
+			0 );
+		if( clip.pointInRect( x, y ) )
+		{
+			for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+			{
+				LLTabTuple* tuple = *iter;
+				tuple->mButton->setVisible( TRUE );
+				S32 local_x = x - tuple->mButton->getRect().mLeft;
+				S32 local_y = y - tuple->mButton->getRect().mBottom;
+				handled = tuple->mButton->handleToolTip( local_x, local_y, msg, sticky_rect );
+				if( handled )
+				{
+					break;
+				}
+			}
+		}
+
+		for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
+		{
+			LLTabTuple* tuple = *iter;
+			tuple->mButton->setVisible( FALSE );
+		}
+	}
+	return handled;
+}
+
+BOOL LLTabContainer::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	if (!getEnabled()) return FALSE;
+
+	if (!gFocusMgr.childHasKeyboardFocus(this)) return FALSE;
+
+	BOOL handled = FALSE;
+	if (key == '[' && mask == MASK_CONTROL)
+	{
+		selectPrevTab();
+		handled = TRUE;
+	}
+	else if (key == ']' && mask == MASK_CONTROL)
+	{
+		selectNextTab();
+		handled = TRUE;
+	}
+
+	if (handled)
+	{
+		if (getCurrentPanel())
+		{
+			getCurrentPanel()->setFocus(TRUE);
+		}
+	}
+
+	if (!gFocusMgr.childHasKeyboardFocus(getCurrentPanel()))
+	{
+		// if child has focus, but not the current panel, focus
+		// is on a button
+		switch(key)
+		{
+		case KEY_UP:
+			if (getTabPosition() == BOTTOM && getCurrentPanel())
+			{
+				getCurrentPanel()->setFocus(TRUE);
+			}
+			handled = TRUE;
+			break;
+		case KEY_DOWN:
+			if (getTabPosition() == TOP && getCurrentPanel())
+			{
+				getCurrentPanel()->setFocus(TRUE);
+			}
+			handled = TRUE;
+			break;
+		case KEY_LEFT:
+		  	selectPrevTab();
+			handled = TRUE;
+			break;
+		case KEY_RIGHT:
+		  	selectNextTab();
+			handled = TRUE;
+			break;
+		default:
+			break;
+		}
+	}
+	return handled;
+}
+
+// virtual
+LLXMLNodePtr LLTabContainer::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLTabContainerCommon::getXML();
+
+	node->createChild("tab_position", TRUE)->setStringValue((mTabPosition == TOP ? "top" : "bottom"));
+
+	return node;
+}
+
+BOOL LLTabContainer::handleDragAndDrop(S32 x, S32 y, MASK mask,	BOOL drop,	EDragAndDropType type, void* cargo_data, EAcceptance *accept, LLString	&tooltip)
+{
+	BOOL has_scroll_arrows = (mMaxScrollPos	> 0);
+
+	if (has_scroll_arrows)
+	{
+		if (mLeftArrowBtn->getRect().pointInRect(x,	y))
+		{
+			S32	local_x	= x	- mLeftArrowBtn->getRect().mLeft;
+			S32	local_y	= y	- mLeftArrowBtn->getRect().mBottom;
+			mLeftArrowBtn->handleHover(local_x,	local_y, mask);
+		}
+		else if	(mRightArrowBtn->getRect().pointInRect(x, y))
+		{
+			S32	local_x	= x	- mRightArrowBtn->getRect().mLeft;
+			S32	local_y	= y	- mRightArrowBtn->getRect().mBottom;
+			mRightArrowBtn->handleHover(local_x, local_y, mask);
+		}
+	}
+
+	for(tuple_list_t::iterator iter	= mTabList.begin();	iter !=	 mTabList.end(); ++iter)
+	{
+		LLTabTuple*	tuple =	*iter;
+		tuple->mButton->setVisible(	TRUE );
+		S32	local_x	= x	- tuple->mButton->getRect().mLeft;
+		S32	local_y	= y	- tuple->mButton->getRect().mBottom;
+		if (tuple->mButton->pointInView(local_x, local_y) &&  tuple->mButton->getEnabled() && !tuple->mTabPanel->getVisible())
+		{
+			tuple->mButton->onCommit();
+		}
+	}
+
+	return LLView::handleDragAndDrop(x,	y, mask, drop, type, cargo_data,  accept, tooltip);
+}
+
diff --git a/indra/llui/lltabcontainer.h b/indra/llui/lltabcontainer.h
new file mode 100644
index 0000000000..41e602eaea
--- /dev/null
+++ b/indra/llui/lltabcontainer.h
@@ -0,0 +1,242 @@
+/** 
+ * @file lltabcontainer.h
+ * @brief LLTabContainerCommon base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Fear my script-fu!
+
+#ifndef LL_TABCONTAINER_H
+#define LL_TABCONTAINER_H
+
+#include "llpanel.h"
+#include "llframetimer.h"
+
+class LLButton;
+class LLTextBox;
+
+
+class LLTabContainerCommon : public LLPanel
+{
+public:
+	enum TabPosition
+	{
+		TOP,
+		BOTTOM,
+		LEFT
+	};
+	typedef enum e_insertion_point
+	{
+		START,
+		END,
+		RIGHT_OF_CURRENT
+	} eInsertionPoint;
+
+	LLTabContainerCommon( const LLString& name, 
+		const LLRect& rect,
+		TabPosition pos,
+		void(*close_callback)(void*), void* callback_userdata, 
+		BOOL bordered = TRUE);
+
+	LLTabContainerCommon( const LLString& name, 		
+		const LLString& rect_control,
+		TabPosition pos,
+		void(*close_callback)(void*), void* callback_userdata, 
+		BOOL bordered = TRUE);
+
+	virtual ~LLTabContainerCommon();
+
+	virtual void initButtons() = 0;
+	
+	virtual void setValue(const LLSD& value) { selectTab((S32) value.asInteger()); }
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_TAB_CONTAINER; }
+	virtual LLString getWidgetTag() const { return LL_TAB_CONTAINER_COMMON_TAG; }
+	
+	virtual LLView* getChildByName(const LLString& name, BOOL recurse = FALSE) const;
+
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual void addTabPanel(LLPanel* child, 
+							 const LLString& label, 
+							 BOOL select = FALSE,  
+							 void (*on_tab_clicked)(void*, bool) = NULL, 
+							 void* userdata = NULL,
+							 S32 indent = 0,
+							 BOOL placeholder = FALSE,
+							 eInsertionPoint insertion_point = END) = 0;
+	virtual void		addPlaceholder(LLPanel* child, const LLString& label);
+	
+	virtual void		enableTabButton(S32 which, BOOL enable);
+
+	virtual void removeTabPanel( LLPanel* child );
+	virtual void		deleteAllTabs();
+	virtual LLPanel*	getCurrentPanel();
+	virtual S32			getCurrentPanelIndex();
+	virtual S32			getTabCount();
+	virtual S32			getPanelIndexByTitle(const LLString& title);
+	virtual LLPanel*	getPanelByIndex(S32 index);
+	virtual LLPanel*	getPanelByName(const LLString& name);
+	virtual S32			getIndexForPanel(LLPanel* panel);
+
+	virtual void		setCurrentTabName(const LLString& name);
+
+
+	virtual void		selectFirstTab();
+	virtual void		selectLastTab();
+	virtual BOOL selectTabPanel( LLPanel* child );
+	virtual BOOL selectTab(S32 which) = 0;
+	virtual BOOL 		selectTabByName(const LLString& title);
+	virtual void		selectNextTab();
+	virtual void		selectPrevTab();
+
+	BOOL        getTabPanelFlashing(LLPanel* child);
+	void		setTabPanelFlashing(LLPanel* child, BOOL state);
+	void		setTitle( const LLString& title );
+	const LLString getPanelTitle(S32 index);
+	
+	virtual void		setTopBorderHeight(S32 height);
+	
+	virtual void 		setTabChangeCallback(LLPanel* tab, void (*on_tab_clicked)(void*,bool));
+	virtual void 		setTabUserData(LLPanel* tab, void* userdata);
+
+	virtual void reshape(S32 width, S32 height, BOOL called_from_parent);
+
+	static void	onCloseBtn(void* userdata);
+	static void	onTabBtn(void* userdata);
+	static void	onNextBtn(void* userdata);
+	static void	onNextBtnHeld(void* userdata);
+	static void	onPrevBtn(void* userdata);
+	static void	onPrevBtnHeld(void* userdata);
+
+	virtual void		setRightTabBtnOffset( S32 offset ) { }
+	virtual void		setPanelTitle(S32 index, const LLString& title) { }
+
+	virtual TabPosition getTabPosition() { return mTabPosition; }
+
+
+protected:
+	// Structure used to map tab buttons to and from tab panels
+	struct LLTabTuple
+	{
+		LLTabTuple( LLTabContainerCommon* c, LLPanel* p, LLButton* b,
+					void (*cb)(void*,bool), void* userdata, LLTextBox* placeholder = NULL )
+			:
+			mTabContainer(c),
+			mTabPanel(p),
+			mButton(b),
+			mOnChangeCallback( cb ),
+			mUserData( userdata ),
+			mOldState(FALSE),
+			mPlaceholderText(placeholder)
+			{}
+
+		LLTabContainerCommon*  mTabContainer;
+		LLPanel*		 mTabPanel;
+		LLButton*		 mButton;
+		void			 (*mOnChangeCallback)(void*, bool);
+		void*			 mUserData;
+		BOOL			 mOldState;
+		LLTextBox*		 mPlaceholderText;
+	};
+
+	typedef std::vector<LLTabTuple*> tuple_list_t;
+	tuple_list_t					mTabList;
+	S32								mCurrentTabIdx;
+
+	BOOL							mScrolled;
+	LLFrameTimer					mScrollTimer;
+	S32								mScrollPos;
+	S32								mScrollPosPixels;
+	S32								mMaxScrollPos;
+
+	void							(*mCloseCallback)(void*);
+	void*							mCallbackUserdata;
+
+	LLTextBox*						mTitleBox;
+
+	S32								mTopBorderHeight;
+	TabPosition 					mTabPosition;
+
+protected:
+	void		scrollPrev();
+	void		scrollNext();
+
+	virtual void		updateMaxScrollPos() = 0;
+	virtual void		commitHoveredButton(S32 x, S32 y) = 0;
+	LLTabTuple* getTabByPanel(LLPanel* child);
+	void insertTuple(LLTabTuple * tuple, eInsertionPoint insertion_point);
+};
+
+class LLTabContainer : public LLTabContainerCommon
+{
+public:
+	LLTabContainer( const LLString& name, const LLRect& rect, TabPosition pos, 
+		void(*close_callback)(void*), void* callback_userdata, 
+					const LLString& title=LLString::null, BOOL bordered = TRUE );
+
+	LLTabContainer( const LLString& name, const LLString& rect_control, TabPosition pos, 
+		void(*close_callback)(void*), void* callback_userdata, 
+					const LLString& title=LLString::null, BOOL bordered = TRUE );
+	
+	~LLTabContainer();
+
+	/*virtual*/ void initButtons();
+
+	/*virtual*/ void draw();
+
+	/*virtual*/ void addTabPanel(LLPanel* child, 
+							 const LLString& label, 
+							 BOOL select = FALSE,  
+							 void (*on_tab_clicked)(void*, bool) = NULL, 
+							 void* userdata = NULL,
+							 S32 indent = 0,
+							 BOOL placeholder = FALSE,
+							 eInsertionPoint insertion_point = END);
+
+	/*virtual*/ BOOL selectTab(S32 which);
+	/*virtual*/ void removeTabPanel( LLPanel* child );
+
+	/*virtual*/ void		setPanelTitle(S32 index, const LLString& title);
+
+	/*virtual*/ void		setRightTabBtnOffset( S32 offset );
+	 
+	/*virtual*/ void		setMinTabWidth(S32 width);
+	/*virtual*/ void		setMaxTabWidth(S32 width);
+
+	/*virtual*/ S32			getMinTabWidth() const;
+	/*virtual*/ S32			getMaxTabWidth() const;
+
+	/*virtual*/ BOOL handleMouseDown( S32 x, S32 y, MASK mask );
+	/*virtual*/ BOOL handleHover( S32 x, S32 y, MASK mask );
+	/*virtual*/ BOOL handleMouseUp( S32 x, S32 y, MASK mask );
+	/*virtual*/ BOOL handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect );
+	/*virtual*/ BOOL handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	/*virtual*/ BOOL handleDragAndDrop(S32 x, S32 y, MASK mask,	BOOL drop,
+									   EDragAndDropType type, void* cargo_data,
+									   EAcceptance* accept, LLString& tooltip);
+
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+
+
+protected:
+
+	LLButton*						mLeftArrowBtn;
+	LLButton*						mRightArrowBtn;
+
+	S32								mRightTabBtnOffset; // Extra room to the right of the tab buttons.
+
+protected:
+	virtual void	updateMaxScrollPos();
+	virtual void	commitHoveredButton(S32 x, S32 y);
+
+	S32								mMinTabWidth;
+	S32								mMaxTabWidth;
+	S32								mTotalTabWidth;
+};
+
+const S32 TABCNTR_CLOSE_BTN_SIZE = 16;
+const S32 TABCNTR_HEADER_HEIGHT = LLPANEL_BORDER_WIDTH + TABCNTR_CLOSE_BTN_SIZE;
+
+#endif  // LL_TABCONTAINER_H
diff --git a/indra/llui/lltextbox.cpp b/indra/llui/lltextbox.cpp
new file mode 100644
index 0000000000..0cd2e98514
--- /dev/null
+++ b/indra/llui/lltextbox.cpp
@@ -0,0 +1,438 @@
+/** 
+ * @file lltextbox.cpp
+ * @brief A text display widget
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "lltextbox.h"
+
+#include "llerror.h"
+#include "llgl.h"
+#include "llui.h"
+#include "lluictrlfactory.h"
+#include "llcontrol.h"
+#include "llfocusmgr.h"
+#include "llstl.h"
+#include <boost/tokenizer.hpp>
+
+LLTextBox::LLTextBox(const LLString& name, const LLRect& rect, const LLString& text,
+					 const LLFontGL* font, BOOL mouse_opaque)
+:	LLUICtrl(name, rect, mouse_opaque, NULL, NULL, FOLLOWS_LEFT | FOLLOWS_TOP ),
+	mTextColor(			LLUI::sColorsGroup->getColor( "LabelTextColor" ) ),
+	mDisabledColor(		LLUI::sColorsGroup->getColor( "LabelDisabledColor" ) ),
+	mBackgroundColor(	LLUI::sColorsGroup->getColor( "DefaultBackgroundColor" ) ),
+	mBorderColor(		LLUI::sColorsGroup->getColor( "DefaultHighlightLight" ) ),
+	mBackgroundVisible( FALSE ),
+	mBorderVisible( FALSE ),
+	mDropshadowVisible( TRUE ),
+	mBorderDropShadowVisible( FALSE ),
+	mHPad(0),
+	mVPad(0),
+	mHAlign( LLFontGL::LEFT ),
+	mVAlign( LLFontGL::TOP ),
+	mClickedCallback(NULL),
+	mCallbackUserData(NULL)
+{
+	// TomY TODO Nuke this eventually
+	setText( !text.empty() ? text : name );
+	mFontGL = font ? font : LLFontGL::sSansSerifSmall;
+	setTabStop(FALSE);
+}
+
+LLTextBox::LLTextBox(const LLString& name, const LLString& text, F32 max_width,
+					 const LLFontGL* font, BOOL mouse_opaque) :
+	LLUICtrl(name, LLRect(0, 0, 1, 1), mouse_opaque, NULL, NULL, FOLLOWS_LEFT | FOLLOWS_TOP),	
+	mFontGL(font ? font : LLFontGL::sSansSerifSmall),
+	mTextColor(LLUI::sColorsGroup->getColor("LabelTextColor")),
+	mDisabledColor(LLUI::sColorsGroup->getColor("LabelDisabledColor")),
+	mBackgroundColor(LLUI::sColorsGroup->getColor("DefaultBackgroundColor")),
+	mBorderColor(LLUI::sColorsGroup->getColor("DefaultHighlightLight")),
+	mBackgroundVisible(FALSE),
+	mBorderVisible(FALSE),
+	mDropshadowVisible(TRUE),
+	mBorderDropShadowVisible(FALSE),
+	mHPad(0),
+	mVPad(0),
+	mHAlign(LLFontGL::LEFT),
+	mVAlign( LLFontGL::TOP ),
+	mClickedCallback(NULL),
+	mCallbackUserData(NULL)
+{
+	setWrappedText(!text.empty() ? text : name, max_width);
+	reshapeToFitText();
+	setTabStop(FALSE);
+}
+
+LLTextBox::~LLTextBox()
+{
+}
+
+// virtual
+EWidgetType LLTextBox::getWidgetType() const
+{
+	return WIDGET_TYPE_TEXT_BOX;
+}
+
+// virtual
+LLString LLTextBox::getWidgetTag() const
+{
+	return LL_TEXT_BOX_TAG;
+}
+
+BOOL LLTextBox::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// HACK: Only do this if there actually is a click callback, so that
+	// overly large text boxes in the older UI won't start eating clicks.
+	if (mClickedCallback)
+	{
+		handled = TRUE;
+
+		// Route future Mouse messages here preemptively.  (Release on mouse up.)
+		gFocusMgr.setMouseCapture( this, NULL );
+		
+		if (mSoundFlags & MOUSE_DOWN)
+		{
+			make_ui_sound("UISndClick");
+		}
+	}
+
+	return handled;
+}
+
+
+BOOL LLTextBox::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// We only handle the click if the click both started and ended within us
+
+	// HACK: Only do this if there actually is a click callback, so that
+	// overly large text boxes in the older UI won't start eating clicks.
+	if (mClickedCallback
+		&& this == gFocusMgr.getMouseCapture())
+	{
+		handled = TRUE;
+
+		// Release the mouse
+		gFocusMgr.setMouseCapture( NULL, NULL );
+
+		if (mSoundFlags & MOUSE_UP)
+		{
+			make_ui_sound("UISndClickRelease");
+		}
+
+		// DO THIS AT THE VERY END to allow the button to be destroyed as a result of being clicked.
+		// If mouseup in the widget, it's been clicked
+		if (mClickedCallback)
+		{
+			(*mClickedCallback)( mCallbackUserData );
+		}
+	}
+
+	return handled;
+}
+
+void LLTextBox::setText(const LLString& text)
+{
+	mText.assign(text);
+	setLineLengths();
+}
+
+void LLTextBox::setLineLengths()
+{
+	mLineLengthList.clear();
+	
+	LLString::size_type  cur = 0;
+	LLString::size_type  len = mText.getWString().size();
+
+	while (cur < len)
+	{
+		LLString::size_type end = mText.getWString().find('\n', cur);
+		LLString::size_type runLen;
+		
+		if (end == LLString::npos)
+		{
+			runLen = len - cur;
+			cur = len;
+		}
+		else
+		{
+			runLen = end - cur;
+			cur = end + 1; // skip the new line character
+		}
+
+		mLineLengthList.push_back( (S32)runLen );
+	}
+}
+
+void LLTextBox::setWrappedText(const LLString& in_text, F32 max_width)
+{
+	if (max_width < 0.0)
+	{
+		max_width = (F32)getRect().getWidth();
+	}
+
+	LLWString wtext = utf8str_to_wstring(in_text);
+	LLWString final_wtext;
+
+	LLWString::size_type  cur = 0;;
+	LLWString::size_type  len = wtext.size();
+
+	while (cur < len)
+	{
+		LLWString::size_type end = wtext.find('\n', cur);
+		if (end == LLWString::npos)
+		{
+			end = len;
+		}
+		
+		LLWString::size_type runLen = end - cur;
+		if (runLen > 0)
+		{
+			LLWString run(wtext, cur, runLen);
+			LLWString::size_type useLen =
+				mFontGL->maxDrawableChars(run.c_str(), max_width, runLen, TRUE);
+
+			final_wtext.append(wtext, cur, useLen);
+			cur += useLen;
+		}
+
+		if (cur < len)
+		{
+			if (wtext[cur] == '\n')
+			{
+				cur += 1;
+			}
+			final_wtext += '\n';
+		}
+	}
+
+	LLString final_text = wstring_to_utf8str(final_wtext);
+	setText(final_text);
+}
+
+S32 LLTextBox::getTextPixelWidth()
+{
+	S32 max_line_width = 0;
+	if( mLineLengthList.size() > 0 )
+	{
+		S32 cur_pos = 0;
+		for (std::vector<S32>::iterator iter = mLineLengthList.begin();
+			iter != mLineLengthList.end(); ++iter)
+		{
+			S32 line_length = *iter;
+			S32 line_width = mFontGL->getWidth( mText.getWString().c_str(), cur_pos, line_length );
+			if( line_width > max_line_width )
+			{
+				max_line_width = line_width;
+			}
+			cur_pos += line_length+1;
+		}
+	}
+	else
+	{
+		max_line_width = mFontGL->getWidth(mText.getWString().c_str());
+	}
+	return max_line_width;
+}
+
+S32 LLTextBox::getTextPixelHeight()
+{
+	S32 num_lines = mLineLengthList.size();
+	if( num_lines < 1 )
+	{
+		num_lines = 1;
+	}
+	return (S32)(num_lines * mFontGL->getLineHeight());
+}
+
+
+void LLTextBox::setValue(const LLSD& value )
+{
+	setText(value.asString());
+}
+
+LLSD LLTextBox::getValue() const
+{
+	return LLSD(getText());
+}
+
+BOOL LLTextBox::setTextArg( const LLString& key, const LLString& text )
+{
+	mText.setArg(key, text);
+	setLineLengths();
+	return TRUE;
+}
+
+void LLTextBox::draw()
+{
+	if( getVisible() )
+	{
+		if (mBorderVisible)
+		{
+			gl_rect_2d_offset_local(getLocalRect(), 2, FALSE);
+		}
+
+		if( mBorderDropShadowVisible )
+		{
+			static LLColor4 color_drop_shadow = LLUI::sColorsGroup->getColor("ColorDropShadow");
+			static S32 drop_shadow_tooltip = LLUI::sConfigGroup->getS32("DropShadowTooltip");
+			gl_drop_shadow(0, mRect.getHeight(), mRect.getWidth(), 0,
+				color_drop_shadow, drop_shadow_tooltip);
+		}
+	
+		if (mBackgroundVisible)
+		{
+			LLRect r( 0, mRect.getHeight(), mRect.getWidth(), 0 );
+			gl_rect_2d( r, mBackgroundColor );
+		}
+
+		S32 text_x = 0;
+		switch( mHAlign )
+		{
+		case LLFontGL::LEFT:	
+			text_x = mHPad;						
+			break;
+		case LLFontGL::HCENTER:
+			text_x = mRect.getWidth() / 2;
+			break;
+		case LLFontGL::RIGHT:
+			text_x = mRect.getWidth() - mHPad;
+			break;
+		}
+
+		S32 text_y = mRect.getHeight() - mVPad;
+
+		if ( getEnabled() )
+		{
+			drawText( text_x, text_y, mTextColor );
+		}
+		else
+		{
+			drawText( text_x, text_y, mDisabledColor );
+		}
+
+		if (sDebugRects)
+		{
+			drawDebugRect();
+		}
+	}
+}
+
+void LLTextBox::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	// reparse line lengths
+	setText(mText);
+	LLView::reshape(width, height, called_from_parent);
+}
+
+void LLTextBox::drawText( S32 x, S32 y, const LLColor4& color )
+{
+	if( !mLineLengthList.empty() )
+	{
+		S32 cur_pos = 0;
+		for (std::vector<S32>::iterator iter = mLineLengthList.begin();
+			iter != mLineLengthList.end(); ++iter)
+		{
+			S32 line_length = *iter;
+			mFontGL->render(mText.getWString(), cur_pos, (F32)x, (F32)y, color,
+							mHAlign, mVAlign,
+							mDropshadowVisible ? LLFontGL::DROP_SHADOW : LLFontGL::NORMAL,
+							line_length, mRect.getWidth(), NULL, TRUE );
+			cur_pos += line_length + 1;
+			y -= llfloor(mFontGL->getLineHeight());
+		}
+	}
+	else
+	{
+		mFontGL->render(mText.getWString(), 0, (F32)x, (F32)y, color,
+						mHAlign, mVAlign, 
+						mDropshadowVisible ? LLFontGL::DROP_SHADOW : LLFontGL::NORMAL,
+						S32_MAX, mRect.getWidth(), NULL, TRUE);
+	}
+}
+
+
+void LLTextBox::reshapeToFitText()
+{
+	S32 width = getTextPixelWidth();
+	S32 height = getTextPixelHeight();
+	reshape( width + 2 * mHPad, height + 2 * mVPad );
+}
+
+// virtual
+LLXMLNodePtr LLTextBox::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	// Attributes
+
+	node->createChild("font", TRUE)->setStringValue(LLFontGL::nameFromFont(mFontGL));
+
+	node->createChild("halign", TRUE)->setStringValue(LLFontGL::nameFromHAlign(mHAlign));
+
+	addColorXML(node, mTextColor, "text_color", "LabelTextColor");
+	addColorXML(node, mDisabledColor, "disabled_color", "LabelDisabledColor");
+	addColorXML(node, mBackgroundColor, "bg_color", "DefaultBackgroundColor");
+	addColorXML(node, mBorderColor, "border_color", "DefaultHighlightLight");
+
+	node->createChild("bg_visible", TRUE)->setBoolValue(mBackgroundVisible);
+
+	node->createChild("border_visible", TRUE)->setBoolValue(mBorderVisible);
+
+	node->createChild("drop_shadow_visible", TRUE)->setBoolValue(mDropshadowVisible);
+
+	node->createChild("border_drop_shadow_visible", TRUE)->setBoolValue(mBorderDropShadowVisible);
+
+	node->createChild("h_pad", TRUE)->setIntValue(mHPad);
+
+	node->createChild("v_pad", TRUE)->setIntValue(mVPad);
+
+	// Contents
+
+	node->setStringValue(mText);
+
+	return node;
+}
+
+// static
+LLView* LLTextBox::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("text_box");
+	node->getAttributeString("name", name);
+	LLFontGL* font = LLView::selectFont(node);
+
+	LLString text = node->getTextContents();
+
+	// TomY Yes I know this is a hack, but insert a space to make a blank text field
+	if (text == "")
+	{
+		text = " ";
+	}
+
+	LLTextBox* text_box = new LLTextBox(name,
+		LLRect(),
+		text,
+		font,
+		FALSE);
+
+	LLFontGL::HAlign halign = LLView::selectFontHAlign(node);
+	text_box->setHAlign(halign);
+
+	text_box->initFromXML(node, parent);
+
+	if(node->hasAttribute("text_color"))
+	{
+		LLColor4 color;
+		LLUICtrlFactory::getAttributeColor(node, "text_color", color);
+		text_box->setColor(color);
+	}
+
+	return text_box;
+}
diff --git a/indra/llui/lltextbox.h b/indra/llui/lltextbox.h
new file mode 100644
index 0000000000..0c09ae26b4
--- /dev/null
+++ b/indra/llui/lltextbox.h
@@ -0,0 +1,106 @@
+/** 
+ * @file lltextbox.h
+ * @brief A single text item display
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLTEXTBOX_H
+#define LL_LLTEXTBOX_H
+
+#include "lluictrl.h"
+#include "v4color.h"
+#include "llstring.h"
+#include "llfontgl.h"
+#include "lluistring.h"
+
+
+class LLTextBox
+:	public LLUICtrl
+{
+public:
+	// By default, follows top and left and is mouse-opaque.
+	// If no text, text = name.
+	// If no font, uses default system font.
+	LLTextBox(const LLString& name, const LLRect& rect, const LLString& text = LLString::null,
+			  const LLFontGL* font = NULL, BOOL mouse_opaque = TRUE );
+
+	// Construct a textbox which handles word wrapping for us.
+	LLTextBox(const LLString& name, const LLString& text, F32 max_width = 200,
+			  const LLFontGL* font = NULL, BOOL mouse_opaque = TRUE );
+
+	virtual ~LLTextBox();
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+
+	virtual void	draw();
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+
+	void			setColor( const LLColor4& c )			{ mTextColor = c; }
+	void			setDisabledColor( const LLColor4& c)	{ mDisabledColor = c; }
+	void			setBackgroundColor( const LLColor4& c)	{ mBackgroundColor = c; }	
+	void			setBorderColor( const LLColor4& c)		{ mBorderColor = c; }	
+	void			setText( const LLString& text );
+	void			setWrappedText(const LLString& text, F32 max_width = -1.0);
+						// default width means use existing control width
+	
+	void			setBackgroundVisible(BOOL visible)		{ mBackgroundVisible = visible; }
+	void			setBorderVisible(BOOL visible)			{ mBorderVisible = visible; }
+	void			setDropshadowVisible(BOOL visible)		{ mDropshadowVisible = visible; }
+	void			setBorderDropshadowVisible(BOOL visible){ mBorderDropShadowVisible = visible; }
+	void			setHPad(S32 pixels)						{ mHPad = pixels; }
+	void			setVPad(S32 pixels)						{ mVPad = pixels; }
+	void			setRightAlign()							{ mHAlign = LLFontGL::RIGHT; }
+	void			setHAlign( LLFontGL::HAlign align )		{ mHAlign = align; }
+	void			setClickedCallback( void (*cb)(void *data) ){ mClickedCallback = cb; }		// mouse down and up within button
+	void			setCallbackUserData( void* data )			{ mCallbackUserData = data; }
+
+	const LLFontGL* getFont() const							{ return mFontGL; }
+
+	void			reshapeToFitText();
+
+	const LLString&	getText() const							{ return mText.getString(); }
+	S32				getTextPixelWidth();
+	S32				getTextPixelHeight();
+
+
+	virtual void	setValue(const LLSD& value );
+	virtual LLSD	getValue() const;
+	virtual BOOL	setTextArg( const LLString& key, const LLString& text );
+
+protected:
+	void			setLineLengths();
+	void			drawText(S32 x, S32 y, const LLColor4& color );
+
+protected:
+	LLUIString		mText;
+	const LLFontGL*	mFontGL;
+	LLColor4		mTextColor;
+	LLColor4		mDisabledColor;
+
+	LLColor4		mBackgroundColor;
+	LLColor4		mBorderColor;
+	
+	BOOL			mBackgroundVisible;
+	BOOL			mBorderVisible;
+	
+	BOOL			mDropshadowVisible;	// Draws black dropshadow below and to the right of the text.
+	BOOL			mBorderDropShadowVisible;
+
+	S32				mHPad;
+	S32				mVPad;
+	LLFontGL::HAlign mHAlign;
+	LLFontGL::VAlign mVAlign;
+
+	std::vector<S32> mLineLengthList;
+	void			(*mClickedCallback)(void* data );
+	void*			mCallbackUserData;
+};
+
+#endif
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
new file mode 100644
index 0000000000..a4747aef67
--- /dev/null
+++ b/indra/llui/lltexteditor.cpp
@@ -0,0 +1,4144 @@
+/** 
+ * @file lltexteditor.cpp
+ * @brief LLTextEditor base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Text editor widget to let users enter a a multi-line ASCII document.
+
+#include "linden_common.h"
+
+#include "lltexteditor.h"
+
+#include "llfontgl.h"
+#include "llgl.h"
+#include "llui.h"
+#include "lluictrlfactory.h"
+#include "llrect.h"
+#include "llfocusmgr.h"
+#include "sound_ids.h"
+#include "lltimer.h"
+#include "llmath.h"
+
+#include "audioengine.h"
+#include "llclipboard.h"
+#include "llscrollbar.h"
+#include "llstl.h"
+#include "llkeyboard.h"
+#include "llkeywords.h"
+#include "llundo.h"
+#include "llviewborder.h"
+#include "llcontrol.h"
+#include "llimagegl.h"
+#include "llwindow.h"
+#include "llglheaders.h"
+#include <queue>
+
+// 
+// Globals
+//
+
+BOOL gDebugTextEditorTips = FALSE;
+
+//
+// Constants
+//
+
+const S32	UI_TEXTEDITOR_BUFFER_BLOCK_SIZE = 512;
+
+const S32	UI_TEXTEDITOR_BORDER = 1;
+const S32	UI_TEXTEDITOR_H_PAD = 4;
+const S32	UI_TEXTEDITOR_V_PAD_TOP = 4;
+const F32	CURSOR_FLASH_DELAY = 1.0f;  // in seconds
+const S32	CURSOR_THICKNESS = 2;
+const S32	SPACES_PER_TAB = 4;
+
+LLColor4 LLTextEditor::mLinkColor = LLColor4::blue;
+void (* LLTextEditor::mURLcallback)(const char*)              = NULL;
+BOOL (* LLTextEditor::mSecondlifeURLcallback)(LLString)   = NULL;
+
+///////////////////////////////////////////////////////////////////
+//virtuals
+BOOL LLTextCmd::canExtend(S32 pos)
+{
+	return FALSE;
+}
+
+void LLTextCmd::blockExtensions()
+{
+}
+
+BOOL LLTextCmd::extendAndExecute( LLTextEditor* editor, S32 pos, llwchar c, S32* delta )
+{
+	llassert(0);
+	return 0;
+}
+
+BOOL LLTextCmd::hasExtCharValue( llwchar value )
+{
+	return FALSE;
+}
+
+// Utility funcs
+S32 LLTextCmd::insert(LLTextEditor* editor, S32 pos, const LLWString &utf8str)
+{
+	return editor->insertStringNoUndo( pos, utf8str );
+}
+S32 LLTextCmd::remove(LLTextEditor* editor, S32 pos, S32 length)
+{
+	return editor->removeStringNoUndo( pos, length );
+}
+S32 LLTextCmd::overwrite(LLTextEditor* editor, S32 pos, llwchar wc)
+{
+	return editor->overwriteCharNoUndo(pos, wc);
+}
+
+///////////////////////////////////////////////////////////////////
+
+class LLTextCmdInsert : public LLTextCmd 
+{
+public:
+	LLTextCmdInsert(S32 pos, BOOL group_with_next, const LLWString &ws)
+		: LLTextCmd(pos, group_with_next), mString(ws)
+	{
+	}
+	virtual BOOL execute( LLTextEditor* editor, S32* delta )
+	{
+		*delta = insert(editor, mPos, mString );
+		LLWString::truncate(mString, *delta);
+		//mString = wstring_truncate(mString, *delta);
+		return (*delta != 0);
+	}	
+	virtual S32 undo( LLTextEditor* editor )
+	{
+		remove(editor, mPos, mString.length() );
+		return mPos;
+	}
+	virtual S32 redo( LLTextEditor* editor )
+	{
+		insert(editor, mPos, mString );
+		return mPos + mString.length();
+	}
+
+private:
+	LLWString mString;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class LLTextCmdAddChar : public LLTextCmd
+{
+public:
+	LLTextCmdAddChar( S32 pos, BOOL group_with_next, llwchar wc)
+		: LLTextCmd(pos, group_with_next), mString(1, wc), mBlockExtensions(FALSE)
+	{
+	}
+	virtual void blockExtensions()
+	{
+		mBlockExtensions = TRUE;
+	}
+	virtual BOOL canExtend(S32 pos)
+	{
+		return !mBlockExtensions && (pos == mPos + (S32)mString.length());
+	}
+	virtual BOOL execute( LLTextEditor* editor, S32* delta )
+	{
+		*delta = insert(editor, mPos, mString);
+		LLWString::truncate(mString, *delta);
+		//mString = wstring_truncate(mString, *delta);
+		return (*delta != 0);
+	}
+	virtual BOOL extendAndExecute( LLTextEditor* editor, S32 pos, llwchar wc, S32* delta )	
+	{ 
+		LLWString ws;
+		ws += wc;
+		
+		*delta = insert(editor, pos, ws);
+		if( *delta > 0 )
+		{
+			mString += wc;
+		}
+		return (*delta != 0);
+	}
+	virtual S32 undo( LLTextEditor* editor )
+	{
+		remove(editor, mPos, mString.length() );
+		return mPos;
+	}
+	virtual S32 redo( LLTextEditor* editor )
+	{
+		insert(editor, mPos, mString );
+		return mPos + mString.length();
+	}
+
+private:
+	LLWString	mString;
+	BOOL		mBlockExtensions;
+
+};
+
+///////////////////////////////////////////////////////////////////
+
+class LLTextCmdOverwriteChar : public LLTextCmd
+{
+public:
+	LLTextCmdOverwriteChar( S32 pos, BOOL group_with_next, llwchar wc)
+		: LLTextCmd(pos, group_with_next), mChar(wc), mOldChar(0) {}
+
+	virtual BOOL execute( LLTextEditor* editor, S32* delta )
+	{ 
+		mOldChar = editor->getWChar(mPos);
+		overwrite(editor, mPos, mChar);
+		*delta = 0;
+		return TRUE;
+	}	
+	virtual S32 undo( LLTextEditor* editor )
+	{
+		overwrite(editor, mPos, mOldChar);
+		return mPos;
+	}
+	virtual S32 redo( LLTextEditor* editor )
+	{
+		overwrite(editor, mPos, mChar);
+		return mPos+1;
+	}
+
+private:
+	llwchar		mChar;
+	llwchar		mOldChar;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class LLTextCmdRemove : public LLTextCmd
+{
+public:
+	LLTextCmdRemove( S32 pos, BOOL group_with_next, S32 len ) :
+		LLTextCmd(pos, group_with_next), mLen(len)
+	{
+	}
+	virtual BOOL execute( LLTextEditor* editor, S32* delta )
+	{ 
+		mString = editor->getWSubString(mPos, mLen);
+		*delta = remove(editor, mPos, mLen );
+		return (*delta != 0);
+	}
+	virtual S32 undo( LLTextEditor* editor )
+	{
+		insert(editor, mPos, mString );
+		return mPos + mString.length();
+	}
+	virtual S32 redo( LLTextEditor* editor )
+	{
+		remove(editor, mPos, mLen );
+		return mPos;
+	}
+private:
+	LLWString	mString;
+	S32				mLen;
+};
+
+///////////////////////////////////////////////////////////////////
+
+//
+// Member functions
+//
+
+LLTextEditor::LLTextEditor(	
+	const LLString& name, 
+	const LLRect& rect, 
+	S32 max_length, 
+	const LLString &default_text, 
+	const LLFontGL* font,
+	BOOL allow_embedded_items)
+	:	
+	LLUICtrl( name, rect, TRUE, NULL, NULL, FOLLOWS_TOP | FOLLOWS_LEFT ),
+	mTextIsUpToDate(TRUE),
+	mMaxTextLength( max_length ),
+	mBaseDocIsPristine(TRUE),
+	mPristineCmd( NULL ),
+	mLastCmd( NULL ),
+	mCursorPos( 0 ),
+	mIsSelecting( FALSE ),
+	mSelectionStart( 0 ),
+	mSelectionEnd( 0 ),
+	mOnScrollEndCallback( NULL ),
+	mOnScrollEndData( NULL ),
+	mCursorColor(		LLUI::sColorsGroup->getColor( "TextCursorColor" ) ),
+	mFgColor(			LLUI::sColorsGroup->getColor( "TextFgColor" ) ),
+	mReadOnlyFgColor(	LLUI::sColorsGroup->getColor( "TextFgReadOnlyColor" ) ),
+	mWriteableBgColor(	LLUI::sColorsGroup->getColor( "TextBgWriteableColor" ) ),
+	mReadOnlyBgColor(	LLUI::sColorsGroup->getColor( "TextBgReadOnlyColor" ) ),
+	mFocusBgColor(		LLUI::sColorsGroup->getColor( "TextBgFocusColor" ) ),
+	mReadOnly(FALSE),
+	mWordWrap( FALSE ),
+	mTabToNextField( TRUE ),
+	mCommitOnFocusLost( FALSE ),
+	mTakesFocus( TRUE ),
+	mHideScrollbarForShortDocs( FALSE ),
+	mTakesNonScrollClicks( TRUE ),
+	mAllowEmbeddedItems( allow_embedded_items ),
+	mAcceptCallingCardNames(FALSE),
+	mHandleEditKeysDirectly( FALSE ),
+	mMouseDownX(0),
+	mMouseDownY(0),
+	mLastSelectionX(-1),
+	mLastSelectionY(-1)
+{
+	mSourceID.generate();
+
+	if (font)
+	{
+		mGLFont = font;
+	}
+	else
+	{
+		mGLFont = LLFontGL::sSansSerif;
+	}
+
+	updateTextRect();
+
+	S32 line_height = llround( mGLFont->getLineHeight() );
+	S32 page_size = mTextRect.getHeight() / line_height;
+
+	// Init the scrollbar
+	LLRect scroll_rect;
+	scroll_rect.setOriginAndSize( 
+		mRect.getWidth() - UI_TEXTEDITOR_BORDER - SCROLLBAR_SIZE,
+		UI_TEXTEDITOR_BORDER,
+		SCROLLBAR_SIZE,
+		mRect.getHeight() - 2 * UI_TEXTEDITOR_BORDER );
+	S32 lines_in_doc = getLineCount();
+	mScrollbar = new LLScrollbar( "Scrollbar", scroll_rect,
+		LLScrollbar::VERTICAL,
+		lines_in_doc,						
+		0,						
+		page_size,
+		NULL, this );
+	mScrollbar->setFollowsRight();
+	mScrollbar->setFollowsTop();
+	mScrollbar->setFollowsBottom();
+	mScrollbar->setEnabled( TRUE );
+	mScrollbar->setVisible( TRUE );
+	mScrollbar->setOnScrollEndCallback(mOnScrollEndCallback, mOnScrollEndData);
+	addChild(mScrollbar);
+
+	mBorder = new LLViewBorder( "text ed border", LLRect(0, mRect.getHeight(), mRect.getWidth(), 0), LLViewBorder::BEVEL_IN, LLViewBorder::STYLE_LINE, UI_TEXTEDITOR_BORDER );
+	addChild( mBorder );
+
+	setText(default_text);
+	
+	mParseHTML=FALSE;
+	mHTML="";
+}
+
+
+LLTextEditor::~LLTextEditor()
+{
+	gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit()
+
+	// Route menu back to the default
+	if( gEditMenuHandler == this )
+	{
+		gEditMenuHandler = NULL;
+	}
+
+	// Scrollbar is deleted by LLView
+	mHoverSegment = NULL;
+	std::for_each(mSegments.begin(), mSegments.end(), DeletePointer());
+
+	std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
+}
+
+//virtual
+LLString LLTextEditor::getWidgetTag() const
+{
+	return LL_TEXT_EDITOR_TAG;
+}
+
+void LLTextEditor::setTrackColor( const LLColor4& color )
+{ 
+	mScrollbar->setTrackColor(color); 
+}
+
+void LLTextEditor::setThumbColor( const LLColor4& color ) 
+{ 
+	mScrollbar->setThumbColor(color); 
+}
+
+void LLTextEditor::setHighlightColor( const LLColor4& color ) 
+{ 
+	mScrollbar->setHighlightColor(color); 
+}
+
+void LLTextEditor::setShadowColor( const LLColor4& color ) 
+{ 
+	mScrollbar->setShadowColor(color); 
+}
+
+void LLTextEditor::updateLineStartList(S32 startpos)
+{
+	updateSegments();
+	
+	bindEmbeddedChars( mGLFont );
+
+	S32 seg_num = mSegments.size();
+	S32 seg_idx = 0;
+	S32 seg_offset = 0;
+
+	if (!mLineStartList.empty())
+	{
+		getSegmentAndOffset(startpos, &seg_idx, &seg_offset);
+		line_info t(seg_idx, seg_offset);
+		line_list_t::iterator iter = std::upper_bound(mLineStartList.begin(), mLineStartList.end(), t, line_info_compare());
+		if (iter != mLineStartList.begin()) --iter;
+		seg_idx = iter->mSegment;
+		seg_offset = iter->mOffset;
+		mLineStartList.erase(iter, mLineStartList.end());
+	}
+	
+	while( seg_idx < seg_num )
+	{
+		mLineStartList.push_back(line_info(seg_idx,seg_offset));
+		BOOL line_ended = FALSE;
+		S32 line_width = 0;
+		while(!line_ended && seg_idx < seg_num)
+		{
+			LLTextSegment* segment = mSegments[seg_idx];
+			S32 start_idx = segment->getStart() + seg_offset;
+			S32 end_idx = start_idx;
+			while (end_idx < segment->getEnd() && mWText[end_idx] != '\n')
+			{
+				end_idx++;
+			}
+			if (start_idx == end_idx)
+			{
+				if (end_idx >= segment->getEnd())
+				{
+					// empty segment
+					seg_idx++;
+					seg_offset = 0;
+				}
+				else
+				{
+					// empty line
+					line_ended = TRUE;
+					seg_offset++;
+				}
+			}
+			else
+			{ 
+				const llwchar* str = mWText.c_str() + start_idx;
+				S32 drawn = mGLFont->maxDrawableChars(str, (F32)mTextRect.getWidth() - line_width,
+													  end_idx - start_idx, mWordWrap, mAllowEmbeddedItems );
+				if( 0 == drawn && line_width == 0)
+				{
+					// If at the beginning of a line, draw at least one character, even if it doesn't all fit.
+					drawn = 1;
+				}
+				seg_offset += drawn;
+				line_width += mGLFont->getWidth(str, 0, drawn, mAllowEmbeddedItems);
+				end_idx = segment->getStart() + seg_offset;
+				if (end_idx < segment->getEnd())
+				{
+					line_ended = TRUE;
+					if (mWText[end_idx] == '\n')
+					{
+						seg_offset++; // skip newline
+					}
+				}
+				else
+				{
+					// finished with segment
+					seg_idx++;
+					seg_offset = 0;
+				}
+			}
+		}
+	}
+	
+	unbindEmbeddedChars(mGLFont);
+
+	mScrollbar->setDocSize( getLineCount() );
+
+	if (mHideScrollbarForShortDocs)
+	{
+		BOOL short_doc = (mScrollbar->getDocSize() <= mScrollbar->getPageSize());
+		mScrollbar->setVisible(!short_doc);
+	}
+
+}
+
+////////////////////////////////////////////////////////////
+// LLTextEditor
+// Public methods
+
+//static
+BOOL LLTextEditor::isPartOfWord(llwchar c) { return (c == '_') || isalnum(c); }
+
+
+
+void LLTextEditor::truncate()
+{
+	if (mWText.size() > (size_t)mMaxTextLength)
+	{
+		LLWString::truncate(mWText, mMaxTextLength);
+		mTextIsUpToDate = FALSE;
+	}
+}
+
+void LLTextEditor::setText(const LLString &utf8str)
+{
+	mUTF8Text = utf8str;
+	mWText = utf8str_to_wstring(utf8str);
+	mTextIsUpToDate = TRUE;
+
+	truncate();
+	blockUndo();
+
+	setCursorPos(0);
+	deselect();
+
+	updateLineStartList();
+	updateScrollFromCursor();
+}
+
+void LLTextEditor::setWText(const LLWString &wtext)
+{
+	mWText = wtext;
+	mUTF8Text.clear();
+	mTextIsUpToDate = FALSE;
+
+	truncate();
+	blockUndo();
+
+	setCursorPos(0);
+	deselect();
+
+	updateLineStartList();
+	updateScrollFromCursor();
+}
+
+void LLTextEditor::setValue(const LLSD& value)
+{
+	setText(value.asString());
+}
+
+const LLString& LLTextEditor::getText() const
+{
+	if (!mTextIsUpToDate)
+	{
+		if (mAllowEmbeddedItems)
+		{
+			llwarns << "getText() called on text with embedded items (not supported)" << llendl;
+		}
+		mUTF8Text = wstring_to_utf8str(mWText);
+		mTextIsUpToDate = TRUE;
+	}
+	return mUTF8Text;
+}
+
+LLSD LLTextEditor::getValue() const
+{
+	return LLSD(getText());
+}
+
+void LLTextEditor::setWordWrap(BOOL b)
+{
+	mWordWrap = b; 
+
+	setCursorPos(0);
+	deselect();
+	
+	updateLineStartList();
+	updateScrollFromCursor();
+}
+
+
+void LLTextEditor::setBorderVisible(BOOL b)
+{
+	mBorder->setVisible(b);
+}
+
+
+
+void LLTextEditor::setHideScrollbarForShortDocs(BOOL b)
+{
+	mHideScrollbarForShortDocs = b;
+
+	if (mHideScrollbarForShortDocs)
+	{
+		BOOL short_doc = (mScrollbar->getDocSize() <= mScrollbar->getPageSize());
+		mScrollbar->setVisible(!short_doc);
+	}
+}
+
+void LLTextEditor::selectNext(const LLString& search_text_in, BOOL case_insensitive, BOOL wrap)
+{
+	if (search_text_in.empty())
+	{
+		return;
+	}
+
+	LLWString text = getWText();
+	LLWString search_text = utf8str_to_wstring(search_text_in);
+	if (case_insensitive)
+	{
+		LLWString::toLower(text);
+		LLWString::toLower(search_text);
+	}
+	
+	if (mIsSelecting)
+	{
+		LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
+		
+		if (selected_text == search_text)
+		{
+			// We already have this word selected, we are searching for the next.
+			mCursorPos += search_text.size();
+		}
+	}
+	
+	S32 loc = text.find(search_text,mCursorPos);
+	
+	// If Maybe we wrapped, search again
+	if (wrap && (-1 == loc))
+	{	
+		loc = text.find(search_text);
+	}
+	
+	// If still -1, then search_text just isn't found.
+    if (-1 == loc)
+	{
+		mIsSelecting = FALSE;
+		mSelectionEnd = 0;
+		mSelectionStart = 0;
+		return;
+	}
+
+	setCursorPos(loc);
+	
+	mIsSelecting = TRUE;
+	mSelectionEnd = mCursorPos;
+	mSelectionStart = llmin((S32)getLength(), (S32)(mCursorPos + search_text.size()));
+}
+
+BOOL LLTextEditor::replaceText(const LLString& search_text_in, const LLString& replace_text,
+							   BOOL case_insensitive, BOOL wrap)
+{
+	BOOL replaced = FALSE;
+
+	if (search_text_in.empty())
+	{
+		return replaced;
+	}
+
+	LLWString search_text = utf8str_to_wstring(search_text_in);
+	if (mIsSelecting)
+	{
+		LLWString text = getWText();
+		LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
+
+		if (case_insensitive)
+		{
+			LLWString::toLower(selected_text);
+			LLWString::toLower(search_text);
+		}
+
+		if (selected_text == search_text)
+		{
+			insertText(replace_text);
+			replaced = TRUE;
+		}
+	}
+
+	selectNext(search_text_in, case_insensitive, wrap);
+	return replaced;
+}
+
+void LLTextEditor::replaceTextAll(const LLString& search_text, const LLString& replace_text, BOOL case_insensitive)
+{
+	S32 cur_pos = mScrollbar->getDocPos();
+
+	setCursorPos(0);
+	selectNext(search_text, case_insensitive, FALSE);
+
+	BOOL replaced = TRUE;
+	while ( replaced )
+	{
+		replaced = replaceText(search_text,replace_text, case_insensitive, FALSE);
+	}
+
+	mScrollbar->setDocPos(cur_pos);
+}
+
+void LLTextEditor::setTakesNonScrollClicks(BOOL b)
+{
+	mTakesNonScrollClicks = b;
+}
+
+
+// Picks a new cursor position based on the screen size of text being drawn.
+void LLTextEditor::setCursorAtLocalPos( S32 local_x, S32 local_y, BOOL round )
+{
+	setCursorPos(getCursorPosFromLocalCoord(local_x, local_y, round));
+}
+
+S32 LLTextEditor::prevWordPos(S32 cursorPos) const
+{
+	const LLWString& wtext = mWText;
+	while( (cursorPos > 0) && (wtext[cursorPos-1] == ' ') )
+	{
+		cursorPos--;
+	}
+	while( (cursorPos > 0) && isPartOfWord( wtext[cursorPos-1] ) )
+	{
+		cursorPos--;
+	}
+	return cursorPos;
+}
+
+S32 LLTextEditor::nextWordPos(S32 cursorPos) const
+{
+	const LLWString& wtext = mWText;
+	while( (cursorPos < getLength()) && isPartOfWord( wtext[cursorPos+1] ) )
+	{
+		cursorPos++;
+	} 
+	while( (cursorPos < getLength()) && (wtext[cursorPos+1] == ' ') )
+	{
+		cursorPos++;
+	}
+	return cursorPos;
+}
+
+S32 LLTextEditor::getLineCount()
+{
+	return mLineStartList.size();
+}
+
+S32 LLTextEditor::getLineStart( S32 line )
+{
+	S32 num_lines = getLineCount();
+	if (num_lines == 0)
+    {
+		return 0;
+    }
+	line = llclamp(line, 0, num_lines-1);
+	S32 segidx = mLineStartList[line].mSegment;
+	S32 segoffset = mLineStartList[line].mOffset;
+	LLTextSegment* seg = mSegments[segidx];
+	S32 res = seg->getStart() + segoffset;
+	if (res > seg->getEnd()) llerrs << "wtf" << llendl;
+	return res;
+}
+
+// Given an offset into text (pos), find the corresponding line (from the start of the doc) and an offset into the line.
+void LLTextEditor::getLineAndOffset( S32 startpos, S32* linep, S32* offsetp )
+{
+	if (mLineStartList.empty())
+	{
+		*linep = 0;
+		*offsetp = startpos;
+	}
+	else
+	{
+		S32 seg_idx, seg_offset;
+		getSegmentAndOffset( startpos, &seg_idx, &seg_offset );
+
+		line_info tline(seg_idx, seg_offset);
+		line_list_t::iterator iter = std::upper_bound(mLineStartList.begin(), mLineStartList.end(), tline, line_info_compare());
+		if (iter != mLineStartList.begin()) --iter;
+		*linep = iter - mLineStartList.begin();
+		S32 line_start = mSegments[iter->mSegment]->getStart() + iter->mOffset;
+		*offsetp = startpos - line_start;
+	}
+}
+
+void LLTextEditor::getSegmentAndOffset( S32 startpos, S32* segidxp, S32* offsetp )
+{
+	if (mSegments.empty())
+	{
+		*segidxp = -1;
+		*offsetp = startpos;
+	}
+	
+	LLTextSegment tseg(startpos);
+	segment_list_t::iterator seg_iter;
+	seg_iter = std::upper_bound(mSegments.begin(), mSegments.end(), &tseg, LLTextSegment::compare());
+	if (seg_iter != mSegments.begin()) --seg_iter;
+	*segidxp = seg_iter - mSegments.begin();
+	*offsetp = startpos - (*seg_iter)->getStart();
+}
+
+const LLWString& LLTextEditor::getWText() const
+{
+	return mWText;
+}
+
+S32 LLTextEditor::getLength() const
+{
+	return mWText.length();
+}
+
+llwchar	LLTextEditor::getWChar(S32 pos)
+{
+	return mWText[pos];
+}
+
+LLWString LLTextEditor::getWSubString(S32 pos, S32 len)
+{
+	return mWText.substr(pos, len);
+}
+
+S32 LLTextEditor::getCursorPosFromLocalCoord( S32 local_x, S32 local_y, BOOL round )
+{
+		// 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.
+
+	// Figure out which line we're nearest to.
+	S32 total_lines = getLineCount();
+	S32 line_height = llround( mGLFont->getLineHeight() );
+	S32 max_visible_lines = mTextRect.getHeight() / line_height;
+	S32 scroll_lines = mScrollbar->getDocPos();
+	S32 visible_lines = llmin( total_lines - scroll_lines, max_visible_lines );			// Lines currently visible 
+
+	//S32 line = S32( 0.5f + ((mTextRect.mTop - local_y) / mGLFont->getLineHeight()) );
+	S32 line = (mTextRect.mTop - 1 - local_y) / line_height;
+	if (line >= total_lines)
+	{
+		return getLength(); // past the end
+	}
+	
+	line = llclamp( line, 0, visible_lines ) + scroll_lines;
+
+	S32 line_start = getLineStart(line);
+	S32 next_start = getLineStart(line+1);
+	S32	line_end = (next_start != line_start) ? next_start - 1 : getLength();
+
+	if(line_start == -1)
+	{
+		return 0;
+	}
+	else
+	{
+		S32 line_len = line_end - line_start;
+		S32 pos;
+
+		if (mAllowEmbeddedItems)
+		{
+			// Figure out which character we're nearest to.
+			bindEmbeddedChars(mGLFont);
+			pos = mGLFont->charFromPixelOffset(mWText.c_str(), line_start,
+											   (F32)(local_x - mTextRect.mLeft),
+											   (F32)(mTextRect.getWidth()),
+											   line_len,
+											   round, TRUE);
+			unbindEmbeddedChars(mGLFont);
+		}
+		else
+		{
+			pos = mGLFont->charFromPixelOffset(mWText.c_str(), line_start,
+											   (F32)(local_x - mTextRect.mLeft),
+											   (F32)mTextRect.getWidth(),
+											   line_len,
+											   round);
+		}
+
+		return line_start + pos;
+	}
+}
+
+void LLTextEditor::setCursor(S32 row, S32 column)
+{
+	const llwchar* doc = mWText.c_str();
+	const char CR = 10;
+	while(row--)
+	{
+		while (CR != *doc++);
+	}
+	doc += column;
+	setCursorPos(doc - mWText.c_str());
+	updateScrollFromCursor();
+}
+
+void LLTextEditor::setCursorPos(S32 offset)
+{
+	mCursorPos = llclamp(offset, 0, (S32)getLength());
+	updateScrollFromCursor();
+}
+
+
+BOOL LLTextEditor::canDeselect()
+{
+	return hasSelection(); 
+}
+
+
+void LLTextEditor::deselect()
+{
+	mSelectionStart = 0;
+	mSelectionEnd = 0;
+	mIsSelecting = FALSE;
+}
+
+
+void LLTextEditor::startSelection()
+{
+	if( !mIsSelecting )
+	{
+		mIsSelecting = TRUE;
+		mSelectionStart = mCursorPos;
+		mSelectionEnd = mCursorPos;
+	}
+}
+
+void LLTextEditor::endSelection()
+{
+	if( mIsSelecting )
+	{
+		mIsSelecting = FALSE;
+		mSelectionEnd = mCursorPos;
+	}
+	if (mParseHTML && mHTML.length() > 0)
+	{
+			//Special handling for slurls
+		if ( (mSecondlifeURLcallback!=NULL) && !(*mSecondlifeURLcallback)(mHTML) )
+		{
+			if (mURLcallback!=NULL) (*mURLcallback)(mHTML.c_str());
+
+			//load_url(url.c_str());
+		}
+		mHTML="";
+	}
+}
+
+BOOL LLTextEditor::selectionContainsLineBreaks()
+{
+	if (hasSelection())
+	{
+		S32 left = llmin(mSelectionStart, mSelectionEnd);
+		S32 right = left + abs(mSelectionStart - mSelectionEnd);
+
+		const LLWString &wtext = mWText;
+		for( S32 i = left; i < right; i++ )
+		{
+			if (wtext[i] == '\n')
+			{
+				return TRUE;
+			}
+		}
+	}
+	return FALSE;
+}
+
+
+S32 LLTextEditor::indentLine( S32 pos, S32 spaces )
+{
+	// Assumes that pos is at the start of the line
+	// spaces may be positive (indent) or negative (unindent).
+	// Returns the actual number of characters added or removed.
+
+	llassert(pos >= 0);
+	llassert(pos <= getLength() );
+
+	S32 delta_spaces = 0;
+
+	if (spaces >= 0)
+	{
+		// Indent
+		for(S32 i=0; i < spaces; i++)
+		{
+			delta_spaces += addChar(pos, ' ');
+		}
+	}
+	else
+	{
+		// Unindent
+		for(S32 i=0; i < -spaces; i++)
+		{
+			const LLWString &wtext = mWText;
+			if (wtext[pos] == ' ')
+			{
+				delta_spaces += remove( pos, 1, FALSE );
+			}
+ 		}
+	}
+
+	return delta_spaces;
+}
+
+void LLTextEditor::indentSelectedLines( S32 spaces )
+{
+	if( hasSelection() )
+	{
+		const LLWString &text = mWText;
+		S32 left = llmin( mSelectionStart, mSelectionEnd );
+		S32 right = left + abs( mSelectionStart - mSelectionEnd );
+		BOOL cursor_on_right = (mSelectionEnd > mSelectionStart);
+		S32 cur = left;
+
+		// Expand left to start of line
+		while( (cur > 0) && (text[cur] != '\n') )
+		{
+			cur--;
+		}
+		left = cur;
+		if( cur > 0 )
+		{
+			left++;
+		}
+
+		// Expand right to end of line
+		if( text[right - 1] == '\n' )
+		{
+			right--;
+		}
+		else
+		{
+			while( (text[right] != '\n') && (right <= getLength() ) )
+			{
+				right++;
+			}
+		}
+
+		// Find each start-of-line and indent it
+		do
+		{
+			if( text[cur] == '\n' )
+			{
+				cur++;
+			}
+
+			S32 delta_spaces = indentLine( cur, spaces );
+			if( delta_spaces > 0 )
+			{
+				cur += delta_spaces;
+			}
+			right += delta_spaces;
+
+			//text = mWText;
+
+			// Find the next new line
+			while( (cur < right) && (text[cur] != '\n') )
+			{
+				cur++;
+			}
+		}
+		while( cur < right );
+
+		if( (right < getLength()) && (text[right] == '\n') )
+		{
+			right++;
+		}
+
+		// Set the selection and cursor
+		if( cursor_on_right )
+		{
+			mSelectionStart = left;
+			mSelectionEnd = right;
+		}
+		else
+		{
+			mSelectionStart = right;
+			mSelectionEnd = left;
+		}
+		mCursorPos = mSelectionEnd;
+	}
+}
+
+
+BOOL LLTextEditor::canSelectAll()
+{
+	return TRUE;
+}
+
+void LLTextEditor::selectAll()
+{
+	mSelectionStart = getLength();
+	mSelectionEnd = 0;
+	mCursorPos = mSelectionEnd;
+}
+
+
+BOOL LLTextEditor::handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect_screen)
+{
+	if (pointInView(x, y) && getVisible())
+	{
+		for ( child_list_const_iter_t child_it = getChildList()->begin();
+			  child_it != getChildList()->end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->getRect().mLeft;
+			S32 local_y = y - viewp->getRect().mBottom;
+			if( viewp->handleToolTip(local_x, local_y, msg, sticky_rect_screen ) )
+			{
+				return TRUE;
+			}
+		}
+
+		if( mSegments.empty() )
+		{
+			return TRUE;
+		}
+
+		LLTextSegment* cur_segment = getSegmentAtLocalPos( x, y );
+		if( cur_segment )
+		{
+			BOOL has_tool_tip = FALSE;
+			has_tool_tip = cur_segment->getToolTip( msg );
+
+			if( has_tool_tip )
+			{
+				// Just use a slop area around the cursor
+				// Convert rect local to screen coordinates
+				S32 SLOP = 8;
+				localPointToScreen( 
+					x - SLOP, y - SLOP, 
+					&(sticky_rect_screen->mLeft), &(sticky_rect_screen->mBottom) );
+				sticky_rect_screen->mRight = sticky_rect_screen->mLeft + 2 * SLOP;
+				sticky_rect_screen->mTop = sticky_rect_screen->mBottom + 2 * SLOP;
+			}
+		}
+		return TRUE;
+	}
+	return FALSE;
+}
+
+BOOL LLTextEditor::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	// Pretend the mouse is over the scrollbar
+	if (getVisible())
+	{
+		return mScrollbar->handleScrollWheel( 0, 0, clicks );
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// Let scrollbar have first dibs
+	handled = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
+
+	if( !handled && mTakesNonScrollClicks)
+	{
+		if (!(mask & MASK_SHIFT))
+		{
+			deselect();
+		}
+
+		BOOL start_select = TRUE;
+		if( start_select )
+		{
+			// If we're not scrolling (handled by child), then we're selecting
+			if (mask & MASK_SHIFT)
+			{
+				S32 old_cursor_pos = mCursorPos;
+				setCursorAtLocalPos( x, y, TRUE );
+
+				if (hasSelection())
+				{
+					/* Mac-like behavior - extend selection towards the cursor
+					if (mCursorPos < mSelectionStart
+						&& mCursorPos < mSelectionEnd)
+					{
+						// ...left of selection
+						mSelectionStart = llmax(mSelectionStart, mSelectionEnd);
+						mSelectionEnd = mCursorPos;
+					}
+					else if (mCursorPos > mSelectionStart
+						&& mCursorPos > mSelectionEnd)
+					{
+						// ...right of selection
+						mSelectionStart = llmin(mSelectionStart, mSelectionEnd);
+						mSelectionEnd = mCursorPos;
+					}
+					else
+					{
+						mSelectionEnd = mCursorPos;
+					}
+					*/
+					// Windows behavior
+					mSelectionEnd = mCursorPos;
+				}
+				else
+				{
+					mSelectionStart = old_cursor_pos;
+					mSelectionEnd = mCursorPos;
+				}
+				// assume we're starting a drag select
+				mIsSelecting = TRUE;
+			}
+			else
+			{
+				setCursorAtLocalPos( x, y, TRUE );
+				startSelection();
+			}
+			gFocusMgr.setMouseCapture( this, &LLTextEditor::onMouseCaptureLost );
+		}
+
+		handled = TRUE;
+	}
+
+	if (mTakesFocus)
+	{
+		setFocus( TRUE );
+		handled = TRUE;
+	}
+
+	// Delay cursor flashing
+	mKeystrokeTimer.reset();
+
+	return handled;
+}
+
+
+BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = FALSE;
+
+	mHoverSegment = NULL;
+	if( getVisible() )
+	{
+		if(gFocusMgr.getMouseCapture() == this )
+		{
+			if( mIsSelecting ) 
+			{
+				if (x != mLastSelectionX || y != mLastSelectionY)
+				{
+					mLastSelectionX = x;
+					mLastSelectionY = y;
+				}
+
+				if( y > mTextRect.mTop )
+				{
+					mScrollbar->setDocPos( mScrollbar->getDocPos() - 1 );
+				}
+				else
+				if( y < mTextRect.mBottom )
+				{
+					mScrollbar->setDocPos( mScrollbar->getDocPos() + 1 );
+				}
+
+				setCursorAtLocalPos( x, y, TRUE );
+				mSelectionEnd = mCursorPos;
+				
+				updateScrollFromCursor();
+			}
+
+			lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;		
+			getWindow()->setCursor(UI_CURSOR_IBEAM);
+			handled = TRUE;
+		}
+
+		if( !handled )
+		{
+			// Pass to children
+			handled = LLView::childrenHandleHover(x, y, mask) != NULL;
+		}
+
+		if( handled )
+		{
+			// Delay cursor flashing
+			mKeystrokeTimer.reset();
+		}
+	
+		// Opaque
+		if( !handled && mTakesNonScrollClicks)
+		{
+			// Check to see if we're over an HTML-style link
+			if( !mSegments.empty() )
+			{
+				LLTextSegment* cur_segment = getSegmentAtLocalPos( x, y );
+				if( cur_segment )
+				{
+					if(cur_segment->getStyle().isLink())
+					{
+						lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (over link, inactive)" << llendl;		
+						getWindow()->setCursor(UI_CURSOR_HAND);
+						handled = TRUE;
+					}
+					else
+					if(cur_segment->getStyle().getIsEmbeddedItem())
+					{
+						lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (over embedded item, inactive)" << llendl;		
+						getWindow()->setCursor(UI_CURSOR_HAND);
+						//getWindow()->setCursor(UI_CURSOR_ARROW);
+						handled = TRUE;
+					}
+					mHoverSegment = cur_segment;
+				}
+			}
+
+			if( !handled )
+			{
+				lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)" << llendl;		
+				if (!mScrollbar->getVisible() || x < mRect.getWidth() - SCROLLBAR_SIZE)
+				{
+					getWindow()->setCursor(UI_CURSOR_IBEAM);
+				}
+				else
+				{
+					getWindow()->setCursor(UI_CURSOR_ARROW);
+				}
+				handled = TRUE;
+			}
+		}
+	}
+
+	if (mOnScrollEndCallback && mOnScrollEndData && (mScrollbar->getDocPos() == mScrollbar->getDocPosMax()))
+	{
+		mOnScrollEndCallback(mOnScrollEndData);
+	}
+	return handled;
+}
+
+
+BOOL LLTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// let scrollbar have first dibs
+	handled = LLView::childrenHandleMouseUp(x, y, mask) != NULL;
+
+	if( !handled && mTakesNonScrollClicks)
+	{
+		if( mIsSelecting )
+		{
+			// Finish selection
+			if( y > mTextRect.mTop )
+			{
+				mScrollbar->setDocPos( mScrollbar->getDocPos() - 1 );
+			}
+			else
+			if( y < mTextRect.mBottom )
+			{
+				mScrollbar->setDocPos( mScrollbar->getDocPos() + 1 );
+			}
+			
+			setCursorAtLocalPos( x, y, TRUE );
+			endSelection();
+
+			updateScrollFromCursor();
+		}
+		
+		if( !hasSelection() )
+		{
+			handleMouseUpOverSegment( x, y, mask );
+		}
+
+		handled = TRUE;
+	}
+
+	// Delay cursor flashing
+	mKeystrokeTimer.reset();
+
+	if( gFocusMgr.getMouseCapture() == this  )
+	{
+		gFocusMgr.setMouseCapture( NULL, NULL );
+		handled = TRUE;
+	}
+
+	return handled;
+}
+
+
+BOOL LLTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	BOOL	handled = FALSE;
+
+	// let scrollbar have first dibs
+	handled = LLView::childrenHandleDoubleClick(x, y, mask) != NULL;
+
+	if( !handled && mTakesNonScrollClicks)
+	{
+		if (mTakesFocus)
+		{
+			setFocus( TRUE );
+		}
+		
+		setCursorAtLocalPos( x, y, FALSE );
+		deselect();
+
+		const LLWString &text = mWText;
+		
+		if( isPartOfWord( text[mCursorPos] ) )
+		{
+			// Select word the cursor is over
+			while ((mCursorPos > 0) && isPartOfWord(text[mCursorPos-1]))
+			{
+				mCursorPos--;
+			}
+			startSelection();
+
+			while ((mCursorPos < (S32)text.length()) && isPartOfWord( text[mCursorPos] ) )
+			{
+				mCursorPos++;
+			}
+		
+			mSelectionEnd = mCursorPos;
+		}
+		else if ((mCursorPos < (S32)text.length()) && !iswspace( text[mCursorPos]) )
+		{
+			// Select the character the cursor is over
+			startSelection();
+			mCursorPos++;
+			mSelectionEnd = mCursorPos;
+		}
+
+		// We don't want handleMouseUp() to "finish" the selection (and thereby
+		// set mSelectionEnd to where the mouse is), so we finish the selection here.
+		mIsSelecting = FALSE;  
+
+		// delay cursor flashing
+		mKeystrokeTimer.reset();
+
+		handled = TRUE;
+	}
+	return handled;
+}
+
+
+// Allow calling cards to be dropped onto text fields.  Append the name and
+// a carriage return.
+// virtual
+BOOL LLTextEditor::handleDragAndDrop(S32 x, S32 y, MASK mask,
+					  BOOL drop, EDragAndDropType cargo_type, void *cargo_data,
+					  EAcceptance *accept,
+					  LLString& tooltip_msg)
+{
+	*accept = ACCEPT_NO;
+
+	return TRUE;
+}
+
+//----------------------------------------------------------------------------
+// Returns change in number of characters in mText
+
+S32 LLTextEditor::execute( LLTextCmd* cmd )
+{
+	S32 delta = 0;
+	if( cmd->execute(this, &delta) )
+	{
+		// Delete top of undo stack
+		undo_stack_t::iterator enditer = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
+		if (enditer != mUndoStack.begin())
+		{
+			--enditer;
+			std::for_each(mUndoStack.begin(), enditer, DeletePointer());
+			mUndoStack.erase(mUndoStack.begin(), enditer);
+		}
+		// Push the new command is now on the top (front) of the undo stack.
+		mUndoStack.push_front(cmd);
+		mLastCmd = cmd;
+	}
+	else
+	{
+		// Operation failed, so don't put it on the undo stack.
+		delete cmd;
+	}
+
+	return delta;
+}
+
+S32 LLTextEditor::insert(const S32 pos, const LLWString &wstr, const BOOL group_with_next_op)
+{
+	return execute( new LLTextCmdInsert( pos, group_with_next_op, wstr ) );
+}
+
+S32 LLTextEditor::remove(const S32 pos, const S32 length, const BOOL group_with_next_op)
+{
+	return execute( new LLTextCmdRemove( pos, group_with_next_op, length ) );
+}
+
+S32 LLTextEditor::append(const LLWString &wstr, const BOOL group_with_next_op)
+{
+	return insert(mWText.length(), wstr, group_with_next_op);
+}
+
+S32 LLTextEditor::overwriteChar(S32 pos, llwchar wc)
+{
+	if ((S32)mWText.length() == pos)
+	{
+		return addChar(pos, wc);
+	}
+	else
+	{
+		return execute(new LLTextCmdOverwriteChar(pos, FALSE, wc));
+	}
+}
+
+// Remove a single character from the text.  Tries to remove
+// a pseudo-tab (up to for spaces in a row)
+void LLTextEditor::removeCharOrTab()
+{
+	if( getEnabled() )
+	{
+		if( mCursorPos > 0 )
+		{
+			S32 chars_to_remove = 1;
+
+			const LLWString &text = mWText;
+			if (text[mCursorPos - 1] == ' ')
+			{
+				// Try to remove a "tab"
+				S32 line, offset;
+				getLineAndOffset(mCursorPos, &line, &offset);
+				if (offset > 0)
+				{
+					chars_to_remove = offset % SPACES_PER_TAB;
+					if( chars_to_remove == 0 )
+					{
+						chars_to_remove = SPACES_PER_TAB;
+					}
+
+					for( S32 i = 0; i < chars_to_remove; i++ )
+					{
+						if (text[ mCursorPos - i - 1] != ' ')
+						{
+							// Fewer than a full tab's worth of spaces, so
+							// just delete a single character.
+							chars_to_remove = 1;
+							break;
+						}
+					}
+				}
+			}
+		
+			for (S32 i = 0; i < chars_to_remove; i++)
+			{
+				setCursorPos(mCursorPos - 1);
+				remove( mCursorPos, 1, FALSE );
+			}
+		}
+		else
+		{
+			reportBadKeystroke();
+		}
+	}
+}
+
+// Remove a single character from the text
+S32 LLTextEditor::removeChar(S32 pos)
+{
+	return remove( pos, 1, FALSE );
+}
+
+void LLTextEditor::removeChar()
+{
+	if (getEnabled())
+	{
+		if (mCursorPos > 0)
+		{
+			setCursorPos(mCursorPos - 1);
+			removeChar(mCursorPos);
+		}
+		else
+		{
+			reportBadKeystroke();
+		}
+	}
+}
+
+// Add a single character to the text
+S32 LLTextEditor::addChar(S32 pos, llwchar wc)
+{
+	if ((S32)mWText.length() == mMaxTextLength)
+	{
+		make_ui_sound("UISndBadKeystroke");
+		return 0;
+	}
+
+	if (mLastCmd && mLastCmd->canExtend(pos))
+	{
+		S32 delta = 0;
+		mLastCmd->extendAndExecute(this, pos, wc, &delta);
+		return delta;
+	}
+	else
+	{
+		return execute(new LLTextCmdAddChar(pos, FALSE, wc));
+	}
+}
+
+void LLTextEditor::addChar(llwchar wc)
+{
+	if( getEnabled() )
+	{
+		if( hasSelection() )
+		{
+			deleteSelection(TRUE);
+		}
+		else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
+		{
+			removeChar(mCursorPos);
+		}
+
+		setCursorPos(mCursorPos + addChar( mCursorPos, wc ));
+	}
+}
+
+
+BOOL LLTextEditor::handleSelectionKey(const KEY key, const MASK mask)
+{
+	BOOL handled = FALSE;
+
+	if( mask & MASK_SHIFT )
+	{
+		handled = TRUE;
+		
+		switch( key )
+		{
+		case KEY_LEFT:
+			if( 0 < mCursorPos )
+			{
+				startSelection();
+				mCursorPos--;
+				if( mask & MASK_CONTROL )
+				{
+					mCursorPos = prevWordPos(mCursorPos);
+				}
+				mSelectionEnd = mCursorPos;
+			}
+			break;
+
+		case KEY_RIGHT:
+			if( mCursorPos < getLength() )
+			{
+				startSelection();
+				mCursorPos++;
+				if( mask & MASK_CONTROL )
+				{
+					mCursorPos = nextWordPos(mCursorPos);
+				}
+				mSelectionEnd = mCursorPos;
+			}
+			break;
+
+		case KEY_UP:
+			startSelection();
+			changeLine( -1 );
+			mSelectionEnd = mCursorPos;
+			break;
+
+		case KEY_PAGE_UP:
+			startSelection();
+			changePage( -1 );
+			mSelectionEnd = mCursorPos;
+			break;
+
+		case KEY_HOME:
+			startSelection();
+			if( mask & MASK_CONTROL )
+			{
+				mCursorPos = 0;
+			}
+			else
+			{
+				startOfLine();
+			}
+			mSelectionEnd = mCursorPos;
+			break;
+
+		case KEY_DOWN:
+			startSelection();
+			changeLine( 1 );
+			mSelectionEnd = mCursorPos;
+			break;
+
+		case KEY_PAGE_DOWN:
+			startSelection();
+			changePage( 1 );
+			mSelectionEnd = mCursorPos;
+			break;
+
+		case KEY_END:
+			startSelection();
+			if( mask & MASK_CONTROL )
+			{
+				mCursorPos = getLength();
+			}
+			else
+			{
+				endOfLine();
+			}
+			mSelectionEnd = mCursorPos;
+			break;
+
+		default:
+			handled = FALSE;
+			break;
+		}
+	}
+
+
+	if( !handled && mHandleEditKeysDirectly )
+	{
+		if( (MASK_CONTROL & mask) && ('A' == key) )
+		{
+			if( canSelectAll() )
+			{
+				selectAll();
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+	}
+
+	return handled;
+}
+
+BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
+{
+	BOOL handled = FALSE;
+
+	// Ignore capslock key
+	if( MASK_NONE == mask )
+	{
+		handled = TRUE;
+		switch( key )
+		{
+		case KEY_UP:
+			if (mReadOnly)
+			{
+				mScrollbar->setDocPos(mScrollbar->getDocPos() - 1);
+			}
+			else
+			{
+				changeLine( -1 );
+			}
+			break;
+
+		case KEY_PAGE_UP:
+			changePage( -1 );
+			break;
+
+		case KEY_HOME:
+			if (mReadOnly)
+			{
+				mScrollbar->setDocPos(0);
+			}
+			else
+			{
+				startOfLine();
+			}
+			break;
+
+		case KEY_DOWN:
+			if (mReadOnly)
+			{
+				mScrollbar->setDocPos(mScrollbar->getDocPos() + 1);
+			}
+			else
+			{
+				changeLine( 1 );
+			}
+			break;
+
+		case KEY_PAGE_DOWN:
+			changePage( 1 );
+			break;
+ 
+		case KEY_END:
+			if (mReadOnly)
+			{
+				mScrollbar->setDocPos(mScrollbar->getDocPosMax());
+			}
+			else
+			{
+				endOfLine();
+			}
+			break;
+
+		case KEY_LEFT:
+			if (mReadOnly)
+			{
+				break;
+			}
+			if( hasSelection() )
+			{
+				setCursorPos(llmin( mCursorPos - 1, mSelectionStart, mSelectionEnd ));
+			}
+			else
+			{
+				if( 0 < mCursorPos )
+				{
+					setCursorPos(mCursorPos - 1);
+				}
+				else
+				{
+					reportBadKeystroke();
+				}
+			}
+			break;
+
+		case KEY_RIGHT:
+			if (mReadOnly)
+			{
+				break;
+			}
+			if( hasSelection() )
+			{
+				setCursorPos(llmax( mCursorPos + 1, mSelectionStart, mSelectionEnd ));
+			}
+			else
+			{
+				if( mCursorPos < getLength() )
+				{
+					setCursorPos(mCursorPos + 1);
+				}
+				else
+				{
+					reportBadKeystroke();
+				}
+			}	
+			break;
+			
+		default:
+			handled = FALSE;
+			break;
+		}
+	}
+	
+	if (mOnScrollEndCallback && mOnScrollEndData && (mScrollbar->getDocPos() == mScrollbar->getDocPosMax()))
+	{
+		mOnScrollEndCallback(mOnScrollEndData);
+	}
+	return handled;
+}
+
+void LLTextEditor::deleteSelection(BOOL group_with_next_op )
+{
+	if( getEnabled() && hasSelection() )
+	{
+		S32 pos = llmin( mSelectionStart, mSelectionEnd );
+		S32 length = abs( mSelectionStart - mSelectionEnd );
+	
+		remove( pos, length, group_with_next_op );
+
+		deselect();
+		setCursorPos(pos);
+	}
+}
+
+BOOL LLTextEditor::canCut()
+{
+	return !mReadOnly && hasSelection();
+}
+
+// cut selection to clipboard
+void LLTextEditor::cut()
+{
+	if( canCut() )
+	{
+		S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+		S32 length = abs( mSelectionStart - mSelectionEnd );
+		gClipboard.copyFromSubstring( mWText, left_pos, length, mSourceID );
+		deleteSelection( FALSE );
+
+		updateLineStartList();
+		updateScrollFromCursor();
+	}
+}
+
+BOOL LLTextEditor::canCopy()
+{
+	return hasSelection();
+}
+
+
+// copy selection to clipboard
+void LLTextEditor::copy()
+{
+	if( canCopy() )
+	{
+		S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+		S32 length = abs( mSelectionStart - mSelectionEnd );
+		gClipboard.copyFromSubstring(mWText, left_pos, length, mSourceID);
+	}
+}
+
+BOOL LLTextEditor::canPaste()
+{
+	return !mReadOnly && gClipboard.canPasteString();
+}
+
+
+// paste from clipboard
+void LLTextEditor::paste()
+{
+	if (canPaste())
+	{
+		LLUUID source_id;
+		LLWString paste = gClipboard.getPasteWString(&source_id);
+		if (!paste.empty())
+		{
+			// Delete any selected characters (the paste replaces them)
+			if( hasSelection() )
+			{
+				deleteSelection(TRUE);
+			}
+
+			// Clean up string (replace tabs and remove characters that our fonts don't support).
+			LLWString clean_string(paste);
+			LLWString::replaceTabsWithSpaces(clean_string, SPACES_PER_TAB);
+			if( mAllowEmbeddedItems )
+			{
+				const llwchar LF = 10;
+				S32 len = clean_string.length();
+				for( S32 i = 0; i < len; i++ )
+				{
+					llwchar wc = clean_string[i];
+					if( (wc < LLFont::FIRST_CHAR) && (wc != LF) )
+					{
+						clean_string[i] = LL_UNKNOWN_CHAR;
+					}
+					else if (wc >= FIRST_EMBEDDED_CHAR && wc <= LAST_EMBEDDED_CHAR)
+					{
+						clean_string[i] = pasteEmbeddedItem(wc);
+					}
+				}
+			}
+	
+			// Insert the new text into the existing text.
+			setCursorPos(mCursorPos + insert(mCursorPos, clean_string, FALSE));
+			deselect();
+
+			updateLineStartList();
+			updateScrollFromCursor();
+		}
+	}
+}
+
+
+BOOL LLTextEditor::handleControlKey(const KEY key, const MASK mask)	
+{
+	BOOL handled = FALSE;
+
+	if( mask & MASK_CONTROL )
+	{
+		handled = TRUE;
+
+		switch( key )
+		{
+		case KEY_HOME:
+			if( mask & MASK_SHIFT )
+			{
+				startSelection();
+				mCursorPos = 0;
+				mSelectionEnd = mCursorPos;
+			}
+			else
+			{
+				// Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+				// all move the cursor as if clicking, so should deselect.
+				deselect();
+				setCursorPos(0);
+			}
+			break;
+
+		case KEY_END:
+			{
+				if( mask & MASK_SHIFT )
+				{
+					startSelection();
+				}
+				else
+				{
+					// Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+					// all move the cursor as if clicking, so should deselect.
+					deselect();
+				}
+				endOfDoc();
+				if( mask & MASK_SHIFT )
+				{
+					mSelectionEnd = mCursorPos;
+				}
+				break;
+			}
+
+		case KEY_RIGHT:
+			if( mCursorPos < getLength() )
+			{
+				// Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+				// all move the cursor as if clicking, so should deselect.
+				deselect();
+
+				setCursorPos(nextWordPos(mCursorPos + 1));
+			}
+			break;
+
+
+		case KEY_LEFT:
+			if( mCursorPos > 0 )
+			{
+				// Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+				// all move the cursor as if clicking, so should deselect.
+				deselect();
+
+				setCursorPos(prevWordPos(mCursorPos - 1));
+			}
+			break;
+
+		default:
+			handled = FALSE;
+			break;
+		}
+	}
+
+	return handled;
+}
+
+BOOL LLTextEditor::handleEditKey(const KEY key, const MASK mask)
+{
+	BOOL handled = FALSE;
+
+	// Standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system.
+	if( KEY_DELETE == key )
+	{
+		if( canDoDelete() )
+		{
+			doDelete();
+		}
+		else
+		{
+			reportBadKeystroke();
+		}
+		handled = TRUE;
+	}
+	else
+	if( MASK_CONTROL & mask )
+	{
+		if( 'C' == key )
+		{
+			if( canCopy() )
+			{
+				copy();
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+		else
+		if( 'V' == key )
+		{
+			if( canPaste() )
+			{
+				paste();
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+		else
+		if( 'X' == key )
+		{
+			if( canCut() )
+			{
+				cut();
+			}
+			else
+			{
+				reportBadKeystroke();
+			}
+			handled = TRUE;
+		}
+	}
+
+	return handled;
+}
+
+	
+BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask, BOOL* return_key_hit)	
+{
+	*return_key_hit = FALSE;
+	BOOL handled = TRUE;
+
+	switch( key )
+	{
+	case KEY_INSERT:
+		if (mask == MASK_NONE)
+		{
+			gKeyboard->toggleInsertMode();
+		}
+		break;
+
+	case KEY_BACKSPACE:
+		if( hasSelection() )
+		{
+			deleteSelection(FALSE);
+		}
+		else
+		if( 0 < mCursorPos )
+		{
+			removeCharOrTab();
+		}
+		else
+		{
+			reportBadKeystroke();
+		}
+		break;
+
+
+	case KEY_RETURN:
+		if (mask == MASK_NONE)
+		{
+			if( hasSelection() )
+			{
+				deleteSelection(FALSE);
+			}
+			autoIndent(); // TODO: make this optional
+		}
+		else
+		{
+			handled = FALSE;
+			break;
+		}
+		break;
+
+	case KEY_TAB:
+		if (mask & MASK_CONTROL)
+		{
+			handled = FALSE;
+			break;
+		}
+		if( hasSelection() && selectionContainsLineBreaks() )
+		{
+			indentSelectedLines( (mask & MASK_SHIFT) ? -SPACES_PER_TAB : SPACES_PER_TAB );
+		}
+		else
+		{
+			if( hasSelection() )
+			{
+				deleteSelection(FALSE);
+			}
+			
+			S32 line, offset;
+			getLineAndOffset( mCursorPos, &line, &offset );
+
+			S32 spaces_needed = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
+			for( S32 i=0; i < spaces_needed; i++ )
+			{
+				addChar( ' ' );
+			}
+		}
+		break;
+		
+	default:
+		handled = FALSE;
+		break;
+	}
+
+	return handled;
+}
+
+
+void LLTextEditor::unindentLineBeforeCloseBrace()
+{
+	if( mCursorPos >= 1 )
+	{
+		const LLWString &text = mWText;
+		if( ' ' == text[ mCursorPos - 1 ] )
+		{
+			removeCharOrTab();
+		}
+	}
+}
+
+
+BOOL LLTextEditor::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent )
+{
+	BOOL	handled = FALSE;
+	BOOL	selection_modified = FALSE;
+	BOOL	return_key_hit = FALSE;
+	BOOL	text_may_have_changed = TRUE;
+
+	if ( (gFocusMgr.getKeyboardFocus() == this) && getVisible())
+	{
+		// Special case for TAB.  If want to move to next field, report
+		// not handled and let the parent take care of field movement.
+		if (KEY_TAB == key && mTabToNextField)
+		{
+			return FALSE;
+		}
+
+		handled = handleNavigationKey( key, mask );
+		if( handled )
+		{
+			text_may_have_changed = FALSE;
+		}
+			
+		if( !handled )
+		{
+			handled = handleSelectionKey( key, mask );
+			if( handled )
+			{
+				selection_modified = TRUE;
+			}
+		}
+	
+		if( !handled )
+		{
+			handled = handleControlKey( key, mask );
+			if( handled )
+			{
+				selection_modified = TRUE;
+			}
+		}
+
+		if( !handled && mHandleEditKeysDirectly )
+		{
+			handled = handleEditKey( key, mask );
+			if( handled )
+			{
+				selection_modified = TRUE;
+				text_may_have_changed = TRUE;
+			}
+		}
+
+		// Handle most keys only if the text editor is writeable.
+		if( !mReadOnly )
+		{
+			if( !handled )
+			{
+				handled = handleSpecialKey( key, mask, &return_key_hit );
+				if( handled )
+				{
+					selection_modified = TRUE;
+					text_may_have_changed = TRUE;
+				}
+			}
+
+		}
+
+		if( handled )
+		{
+			mKeystrokeTimer.reset();
+
+			// Most keystrokes will make the selection box go away, but not all will.
+			if( !selection_modified &&
+				KEY_SHIFT != key &&
+				KEY_CONTROL != key &&
+				KEY_ALT != key &&
+				KEY_CAPSLOCK )
+			{
+				deselect();
+			}
+
+			if(text_may_have_changed)
+			{
+				updateLineStartList();
+			}
+			updateScrollFromCursor();
+		}
+	}
+
+	return handled;
+}
+
+
+BOOL LLTextEditor::handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent)
+{
+	if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
+	{
+		return FALSE;
+	}
+
+	BOOL	handled = FALSE;
+
+	if ( (gFocusMgr.getKeyboardFocus() == this) && getVisible())
+	{
+		// Handle most keys only if the text editor is writeable.
+		if( !mReadOnly )
+		{
+			if( '}' == uni_char )
+			{
+				unindentLineBeforeCloseBrace();
+			}
+
+			// TODO: KLW Add auto show of tool tip on (
+			addChar( uni_char );
+
+			// Keys that add characters temporarily hide the cursor
+			getWindow()->hideCursorUntilMouseMove();
+
+			handled = TRUE;
+		}
+
+		if( handled )
+		{
+			mKeystrokeTimer.reset();
+
+			// Most keystrokes will make the selection box go away, but not all will.
+			deselect();
+
+			updateLineStartList();
+			updateScrollFromCursor();
+		}
+	}
+
+	return handled;
+}
+
+
+
+BOOL LLTextEditor::canDoDelete()
+{
+	return !mReadOnly && ( hasSelection() || (mCursorPos < getLength()) );
+}
+
+void LLTextEditor::doDelete()
+{
+	if( canDoDelete() )
+	{
+		if( hasSelection() )
+		{
+			deleteSelection(FALSE);
+		}
+		else
+		if( mCursorPos < getLength() )
+		{	
+			S32 i;
+			S32 chars_to_remove = 1;
+			const LLWString &text = mWText;
+			if( (text[ mCursorPos ] == ' ') && (mCursorPos + SPACES_PER_TAB < getLength()) )
+			{
+				// Try to remove a full tab's worth of spaces
+				S32 line, offset;
+				getLineAndOffset( mCursorPos, &line, &offset );
+				chars_to_remove = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
+				if( chars_to_remove == 0 )
+				{
+					chars_to_remove = SPACES_PER_TAB;
+				}
+
+				for( i = 0; i < chars_to_remove; i++ )
+				{
+					if( text[mCursorPos + i] != ' ' )
+					{
+						chars_to_remove = 1;
+						break;
+					}
+				}
+			}
+
+
+			for( i = 0; i < chars_to_remove; i++ )
+			{
+				setCursorPos(mCursorPos + 1);
+				removeChar();
+			}
+		}
+
+		updateLineStartList();
+		updateScrollFromCursor();		
+	}
+}
+
+//----------------------------------------------------------------------------
+
+
+void LLTextEditor::blockUndo()
+{
+	mBaseDocIsPristine = FALSE;
+	mLastCmd = NULL;
+	std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
+	mUndoStack.clear();
+}
+
+
+BOOL LLTextEditor::canUndo()
+{
+	return !mReadOnly && mLastCmd != NULL;
+}
+
+void LLTextEditor::undo()
+{
+	if( canUndo() )
+	{
+		deselect();
+
+		S32 pos = 0;
+		do
+		{
+			pos = mLastCmd->undo(this);
+			undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
+			if (iter != mUndoStack.end())
+				++iter;
+			if (iter != mUndoStack.end())
+				mLastCmd = *iter;
+			else
+				mLastCmd = NULL;
+
+		} while( mLastCmd && mLastCmd->groupWithNext() );
+
+		setCursorPos(pos);
+
+		updateLineStartList();
+		updateScrollFromCursor();
+	}
+}
+
+BOOL LLTextEditor::canRedo()
+{
+	return !mReadOnly && (mUndoStack.size() > 0) && (mLastCmd != mUndoStack.front());
+}
+
+void LLTextEditor::redo()
+{
+	if( canRedo() )
+	{
+		deselect();
+
+		S32 pos = 0;
+		do
+		{
+			if( !mLastCmd )
+			{
+				mLastCmd = mUndoStack.back();
+			}
+			else
+			{
+				undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
+				if (iter != mUndoStack.begin())
+					mLastCmd = *(--iter);
+				else
+					mLastCmd = NULL;
+			}
+
+			if( mLastCmd )
+			{
+				pos = mLastCmd->redo(this);
+			}
+		} while( 
+			mLastCmd &&
+			mLastCmd->groupWithNext() &&
+			(mLastCmd != mUndoStack.front()) );
+		
+		setCursorPos(pos);
+
+		updateLineStartList();
+		updateScrollFromCursor();
+	}
+}
+
+
+// virtual, from LLView
+void LLTextEditor::onFocusLost()
+{
+	// Route menu back to the default
+ 	if( gEditMenuHandler == this )
+	{
+		gEditMenuHandler = NULL;
+	}
+
+	if (mCommitOnFocusLost)
+	{
+		onCommit();
+	}
+
+	// Make sure cursor is shown again
+	getWindow()->showCursorFromMouseMove();
+}
+
+void LLTextEditor::setEnabled(BOOL enabled)
+{
+	// just treat enabled as read-only flag
+	BOOL read_only = !enabled;
+	if (read_only != mReadOnly)
+	{
+		mReadOnly = read_only;
+		updateSegments();
+	}
+}
+
+void LLTextEditor::drawBackground()
+{
+	S32 left = 0;
+	S32 top = mRect.getHeight();
+	S32 right = mRect.getWidth();
+	S32 bottom = 0;
+
+	LLColor4 bg_color = mReadOnlyBgColor;
+
+	if( !mReadOnly )
+	{
+		if (gFocusMgr.getKeyboardFocus() == this)
+		{
+			bg_color = mFocusBgColor;
+		}
+		else
+		{
+			bg_color = mWriteableBgColor;
+		}
+	}
+	gl_rect_2d(left, top, right, bottom, bg_color);
+
+	LLView::draw();
+}
+
+// Draws the black box behind the selected text
+void LLTextEditor::drawSelectionBackground()
+{
+	// Draw selection even if we don't have keyboard focus for search/replace
+	if( hasSelection() )
+	{
+		const LLWString &text = mWText;
+		const S32 text_len = getLength();
+		std::queue<S32> line_endings;
+
+		S32 line_height = llround( mGLFont->getLineHeight() );
+
+		S32 selection_left		= llmin( mSelectionStart, mSelectionEnd );
+		S32 selection_right		= llmax( mSelectionStart, mSelectionEnd );
+		S32 selection_left_x	= mTextRect.mLeft;
+		S32 selection_left_y	= mTextRect.mTop - line_height;
+		S32 selection_right_x	= mTextRect.mRight;
+		S32 selection_right_y	= mTextRect.mBottom;
+
+		BOOL selection_left_visible = FALSE;
+		BOOL selection_right_visible = FALSE;
+
+		// Skip through the lines we aren't drawing.
+		S32 cur_line = mScrollbar->getDocPos();
+
+		S32 left_line_num = cur_line;
+		S32 num_lines = getLineCount();
+		S32 right_line_num = num_lines - 1;
+
+		S32 line_start = -1;
+		if (cur_line >= num_lines)
+		{
+			return;
+		}
+
+		line_start = getLineStart(cur_line);
+
+		S32 left_visible_pos	= line_start;
+		S32 right_visible_pos	= line_start;
+
+		S32 text_y = mTextRect.mTop - line_height;
+
+		// Find the coordinates of the selected area
+		while((cur_line < num_lines))
+		{
+			S32 next_line = -1;
+			S32 line_end = text_len;
+			
+			if ((cur_line + 1) < num_lines)
+			{
+				next_line = getLineStart(cur_line + 1);
+				line_end = next_line;
+
+				line_end = ( (line_end - line_start)==0 || text[next_line-1] == '\n' || text[next_line-1] == '\0' || text[next_line-1] == ' ' || text[next_line-1] == '\t'  ) ? next_line-1 : next_line;
+			}
+
+			const llwchar* line = text.c_str() + line_start;
+
+			if( line_start <= selection_left && selection_left <= line_end )
+			{
+				left_line_num = cur_line;
+				selection_left_visible = TRUE;
+				selection_left_x = mTextRect.mLeft + mGLFont->getWidth(line, 0, selection_left - line_start, mAllowEmbeddedItems);
+				selection_left_y = text_y;
+			}
+			if( line_start <= selection_right && selection_right <= line_end )
+			{
+				right_line_num = cur_line;
+				selection_right_visible = TRUE;
+				selection_right_x = mTextRect.mLeft + mGLFont->getWidth(line, 0, selection_right - line_start, mAllowEmbeddedItems);
+				if (selection_right == line_end)
+				{
+					// add empty space for "newline"
+					//selection_right_x += mGLFont->getWidth("n");
+				}
+				selection_right_y = text_y;
+			}
+			
+			// if selection spans end of current line...
+			if (selection_left <= line_end && line_end < selection_right && selection_left != selection_right)
+			{
+				// extend selection slightly beyond end of line
+				// to indicate selection of newline character (use "n" character to determine width)
+				const LLWString nstr(utf8str_to_wstring(LLString("n")));
+				line_endings.push(mTextRect.mLeft + mGLFont->getWidth(line, 0, line_end - line_start, mAllowEmbeddedItems) + mGLFont->getWidth(nstr.c_str()));
+			}
+			
+			// move down one line
+			text_y -= line_height;
+
+			right_visible_pos = line_end;
+			line_start = next_line;
+			cur_line++;
+
+			if (selection_right_visible)
+			{
+				break;
+			}
+		}
+		
+		// Draw the selection box (we're using a box instead of reversing the colors on the selected text).
+		BOOL selection_visible = (left_visible_pos <= selection_right) && (selection_left <= right_visible_pos);
+		if( selection_visible )
+		{
+			LLGLSNoTexture no_texture;
+			const LLColor4& color = mReadOnly ? mReadOnlyBgColor : mWriteableBgColor;
+			glColor3f( 1.f - color.mV[0], 1.f - color.mV[1], 1.f - color.mV[2] );
+
+			if( selection_left_y == selection_right_y )
+			{
+				// Draw from selection start to selection end
+				gl_rect_2d( selection_left_x, selection_left_y + line_height + 1,
+					selection_right_x, selection_right_y);
+			}
+			else
+			{
+				// Draw from selection start to the end of the first line
+				if( mTextRect.mRight == selection_left_x )
+				{
+					selection_left_x -= CURSOR_THICKNESS;
+				}
+				
+				S32 line_end = line_endings.front();
+				line_endings.pop();
+				gl_rect_2d( selection_left_x, selection_left_y + line_height + 1,
+					line_end, selection_left_y );
+
+				S32 line_num = left_line_num + 1;
+				while(line_endings.size())
+				{
+					S32 vert_offset = -(line_num - left_line_num) * line_height;
+					// Draw the block between the two lines
+					gl_rect_2d( mTextRect.mLeft, selection_left_y + vert_offset + line_height + 1,
+						line_endings.front(), selection_left_y + vert_offset);
+					line_endings.pop();
+					line_num++;
+				}
+
+				// Draw from the start of the last line to selection end
+				if( mTextRect.mLeft == selection_right_x )
+				{
+					selection_right_x += CURSOR_THICKNESS;
+				}
+				gl_rect_2d( mTextRect.mLeft, selection_right_y + line_height + 1,
+					selection_right_x, selection_right_y );
+			}
+		}
+	}
+}
+
+void LLTextEditor::drawCursor()
+{
+	if( gFocusMgr.getKeyboardFocus() == this
+		&& gShowTextEditCursor && !mReadOnly)
+	{
+		const LLWString &text = mWText;
+		const S32 text_len = getLength();
+
+		// Skip through the lines we aren't drawing.
+		S32 cur_pos = mScrollbar->getDocPos();
+
+		S32 num_lines = getLineCount();
+		if (cur_pos >= num_lines)
+		{
+			return;
+		}
+		S32 line_start = getLineStart(cur_pos);
+
+		F32 line_height = mGLFont->getLineHeight();
+		F32 text_y = (F32)(mTextRect.mTop) - line_height;
+
+		F32 cursor_left = 0.f; 
+		F32 next_char_left = 0.f;
+		F32 cursor_bottom = 0.f;
+		BOOL cursor_visible = FALSE;
+
+		S32 line_end = 0;
+		// Determine if the cursor is visible and if so what its coordinates are.
+		while( (mTextRect.mBottom <= llround(text_y)) && (cur_pos < num_lines))
+		{
+			line_end = text_len + 1;
+			S32 next_line = -1;
+
+			if ((cur_pos + 1) < num_lines)
+			{
+				next_line = getLineStart(cur_pos + 1);
+				line_end = next_line - 1;
+			}
+
+			const llwchar* line = text.c_str() + line_start;
+
+			// Find the cursor and selection bounds
+			if( line_start <= mCursorPos && mCursorPos <= line_end )
+			{
+				cursor_visible = TRUE;
+				next_char_left = (F32)mTextRect.mLeft + mGLFont->getWidthF32(line, 0, mCursorPos - line_start, mAllowEmbeddedItems );
+				cursor_left = next_char_left - 1.f;
+				cursor_bottom = text_y;
+				break;
+			}
+
+			// move down one line
+			text_y -= line_height;
+			line_start = next_line;
+			cur_pos++;
+		}
+
+		// Draw the cursor
+		if( cursor_visible )
+		{
+			// (Flash the cursor every half second starting a fixed time after the last keystroke)
+			F32 elapsed = mKeystrokeTimer.getElapsedTimeF32();
+			if( (elapsed < CURSOR_FLASH_DELAY ) || (S32(elapsed * 2) & 1) )
+			{
+				F32 cursor_top = cursor_bottom + line_height + 1.f;
+				F32 cursor_right = cursor_left + (F32)CURSOR_THICKNESS;
+				if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection())
+				{
+					cursor_left += CURSOR_THICKNESS;
+					const LLWString space(utf8str_to_wstring(LLString(" ")));
+					F32 spacew = mGLFont->getWidthF32(space.c_str());
+					if (mCursorPos == line_end)
+					{
+						cursor_right = cursor_left + spacew;
+					}
+					else
+					{
+						F32 width = mGLFont->getWidthF32(text.c_str(), mCursorPos, 1, mAllowEmbeddedItems);
+						cursor_right = cursor_left + llmax(spacew, width);
+					}
+				}
+				
+				LLGLSNoTexture no_texture;
+
+				glColor4fv( mCursorColor.mV );
+				
+				gl_rect_2d(llfloor(cursor_left), llfloor(cursor_top),
+					llfloor(cursor_right), llfloor(cursor_bottom));
+
+				if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection() && text[mCursorPos] != '\n')
+				{
+					LLTextSegment* segmentp = getSegmentAtOffset(mCursorPos);
+					LLColor4 text_color;
+					if (segmentp)
+					{
+						text_color = segmentp->getColor();
+					}
+					else if (mReadOnly)
+					{
+						text_color = mReadOnlyFgColor;
+					}
+					else
+					{
+						text_color = mFgColor;
+					}
+					LLGLSTexture texture;
+					mGLFont->render(text, mCursorPos, next_char_left, cursor_bottom + line_height, 
+						LLColor4(1.f - text_color.mV[VRED], 1.f - text_color.mV[VGREEN], 1.f - text_color.mV[VBLUE], 1.f),
+						LLFontGL::LEFT, LLFontGL::TOP,
+						LLFontGL::NORMAL,
+						1);
+				}
+
+
+			}
+		}
+	}
+}
+
+
+void LLTextEditor::drawText()
+{
+	const LLWString &text = mWText;
+	const S32 text_len = getLength();
+
+	if( text_len > 0 )
+	{
+		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 );
+		}
+
+		LLGLSUIDefault gls_ui;
+
+		S32 cur_line = mScrollbar->getDocPos();
+		S32 num_lines = getLineCount();
+		if (cur_line >= num_lines)
+		{
+			return;
+		}
+		
+		S32 line_start = getLineStart(cur_line);
+		LLTextSegment t(line_start);
+		segment_list_t::iterator seg_iter;
+		seg_iter = std::upper_bound(mSegments.begin(), mSegments.end(), &t, LLTextSegment::compare());
+		if (seg_iter == mSegments.end() || (*seg_iter)->getStart() > line_start) --seg_iter;
+		LLTextSegment* cur_segment = *seg_iter;
+		
+		S32 line_height = llround( mGLFont->getLineHeight() );
+		F32 text_y = (F32)(mTextRect.mTop - line_height);
+		while((mTextRect.mBottom <= text_y) && (cur_line < num_lines))
+		{
+			S32 next_start = -1;
+			S32 line_end = text_len;
+
+			if ((cur_line + 1) < num_lines)
+			{
+				next_start = getLineStart(cur_line + 1);
+				line_end = next_start;
+			}
+			if ( text[line_end-1] == '\n' )
+			{
+				--line_end;
+			}
+			
+			F32 text_x = (F32)mTextRect.mLeft;
+
+			S32 seg_start = line_start;
+			while( seg_start < line_end )
+			{
+				while( cur_segment->getEnd() <= seg_start )
+				{
+					seg_iter++;
+					if (seg_iter == mSegments.end())
+					{
+						llwarns << "Ran off the segmentation end!" << llendl;
+						return;
+					}
+					cur_segment = *seg_iter;
+				}
+				
+				// Draw a segment within the line
+				S32 clipped_end	=	llmin( line_end, cur_segment->getEnd() );
+				S32 clipped_len =	clipped_end - seg_start;
+				if( clipped_len > 0 )
+				{
+					LLStyle style = cur_segment->getStyle();
+					if ( style.isImage() && (cur_segment->getStart() >= seg_start) && (cur_segment->getStart() <= clipped_end))
+					{
+						LLImageGL *image = style.getImage();
+
+						gl_draw_scaled_image( llround(text_x), llround(text_y)+line_height-style.mImageHeight, style.mImageWidth, style.mImageHeight, image, LLColor4::white );
+						
+					}
+
+					if (cur_segment == mHoverSegment && style.getIsEmbeddedItem())
+					{
+						style.mUnderline = TRUE;
+					}
+
+					S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+					
+					if ( (mParseHTML) && (left_pos > seg_start) && (left_pos < clipped_end) &&  mIsSelecting && (mSelectionStart == mSelectionEnd) )
+					{
+						mHTML = style.getLinkHREF();
+					}
+
+					drawClippedSegment( text, seg_start, clipped_end, text_x, text_y, selection_left, selection_right, style, &text_x );
+
+					// Note: text_x is incremented by drawClippedSegment()
+					seg_start += clipped_len;
+				}
+			}
+
+			// move down one line
+			text_y -= (F32)line_height;
+
+			line_start = next_start;
+			cur_line++;
+		}
+	}
+}
+
+// Draws a single text segment, reversing the color for selection if needed.
+void LLTextEditor::drawClippedSegment(const LLWString &text, S32 seg_start, S32 seg_end, F32 x, F32 y, S32 selection_left, S32 selection_right, const LLStyle& style, F32* right_x )
+{
+	const LLFontGL* font = mGLFont;
+
+	LLColor4 color;
+
+	if (!style.isVisible())
+	{
+		return;
+	}
+
+	color = style.getColor();
+
+	if ( style.getFontString()[0] )
+	{
+		font = gResMgr->getRes(style.getFontID());
+	}
+
+	U8 font_flags = LLFontGL::NORMAL;
+	
+	if (style.mBold)
+	{
+		font_flags |= LLFontGL::BOLD;
+	}
+	if (style.mItalic)
+	{
+		font_flags |= LLFontGL::ITALIC;
+	}
+	if (style.mUnderline)
+	{
+		font_flags |= LLFontGL::UNDERLINE;
+	}
+
+	if (style.getIsEmbeddedItem())
+	{
+		if (mReadOnly)
+		{
+			color = LLUI::sColorsGroup->getColor("TextEmbeddedItemReadOnlyColor");
+		}
+		else
+		{
+			color = LLUI::sColorsGroup->getColor("TextEmbeddedItemColor");
+		}
+	}
+
+	F32 y_top = y + (F32)llround(font->getLineHeight());
+
+  	if( selection_left > seg_start )
+	{
+		// Draw normally
+		S32 start = seg_start;
+		S32 end = llmin( selection_left, seg_end );
+		S32 length =  end - start;
+		font->render(text, start, x, y_top, color, LLFontGL::LEFT, LLFontGL::TOP, font_flags, length, S32_MAX, right_x, mAllowEmbeddedItems);
+	}
+	x = *right_x;
+	
+	if( (selection_left < seg_end) && (selection_right > seg_start) )
+	{
+		// Draw reversed
+		S32 start = llmax( selection_left, seg_start );
+		S32 end = llmin( selection_right, seg_end );
+		S32 length = end - start;
+
+		font->render(text, start, x, y_top,
+					 LLColor4( 1.f - color.mV[0], 1.f - color.mV[1], 1.f - color.mV[2], 1.f ),
+					 LLFontGL::LEFT, LLFontGL::TOP, font_flags, length, S32_MAX, right_x, mAllowEmbeddedItems);
+	}
+	x = *right_x;
+	if( selection_right < seg_end )
+	{
+		// Draw normally
+		S32 start = llmax( selection_right, seg_start );
+		S32 end = seg_end;
+		S32 length = end - start;
+		font->render(text, start, x, y_top, color, LLFontGL::LEFT, LLFontGL::TOP, font_flags, length, S32_MAX, right_x, mAllowEmbeddedItems);
+	}
+ }
+
+
+void LLTextEditor::draw()
+{
+	if( getVisible() )
+	{
+		{
+			LLGLEnable scissor_test(GL_SCISSOR_TEST);
+			LLUI::setScissorRegionLocal(LLRect(0, mRect.getHeight(), mRect.getWidth() - (mScrollbar->getVisible() ? SCROLLBAR_SIZE : 0), 0));
+
+			bindEmbeddedChars( mGLFont );
+
+			drawBackground();
+			drawSelectionBackground();
+			drawText();
+			drawCursor();
+
+			unbindEmbeddedChars( mGLFont );
+
+			//RN: the decision was made to always show the orange border for keyboard focus but do not put an insertion caret
+			// when in readonly mode
+			mBorder->setKeyboardFocusHighlight( gFocusMgr.getKeyboardFocus() == this);// && !mReadOnly);
+		}
+		LLView::draw();  // Draw children (scrollbar and border)
+	}
+}
+
+void LLTextEditor::reportBadKeystroke()
+{
+	make_ui_sound("UISndBadKeystroke");
+}
+
+
+void LLTextEditor::onTabInto()
+{
+	// selecting all on tabInto causes users to hit tab twice and replace their text with a tab character
+	// theoretically, one could selectAll if mTabToNextField is true, but we couldn't think of a use case
+	// where you'd want to select all anyway
+	// preserve insertion point when returning to the editor
+	//selectAll();
+}
+
+void LLTextEditor::clear()
+{
+	setText("");
+}
+
+// Start or stop the editor from accepting text-editing keystrokes
+// see also LLLineEditor
+void LLTextEditor::setFocus( BOOL new_state )
+{
+	BOOL old_state = hasFocus();
+
+	// Don't change anything if the focus state didn't change
+	if (new_state == old_state) return;
+
+	LLUICtrl::setFocus( new_state );
+
+	if( new_state )
+	{
+		// Route menu to this class
+		gEditMenuHandler = this;
+
+		// Don't start the cursor flashing right away
+		mKeystrokeTimer.reset();
+	}
+	else
+	{
+		// Route menu back to the default
+		if( gEditMenuHandler == this )
+		{
+			gEditMenuHandler = NULL;
+		}
+
+		endSelection();
+	}
+}
+
+BOOL LLTextEditor::acceptsTextInput() const
+{
+	return !mReadOnly;
+}
+
+// Given a line (from the start of the doc) and an offset into the line, find the offset (pos) into text.
+S32 LLTextEditor::getPos( S32 line, S32 offset )
+{
+	S32 line_start = getLineStart(line);
+	S32 next_start = getLineStart(line+1);
+	if (next_start == line_start)
+	{
+		next_start = getLength() + 1;
+	}
+	S32 line_length = next_start - line_start - 1;
+	line_length = llmax(line_length, 0);
+	return line_start + llmin( offset, line_length );
+}
+
+
+void LLTextEditor::changePage( S32 delta )
+{
+	S32 line, offset;
+	getLineAndOffset( mCursorPos, &line, &offset );
+
+	// allow one line overlap
+	S32 page_size = mScrollbar->getPageSize() - 1;
+	if( delta == -1 )
+	{
+		line = llmax( line - page_size, 0);
+		setCursorPos(getPos( line, offset ));
+		mScrollbar->setDocPos( mScrollbar->getDocPos() - page_size );
+	}
+	else
+	if( delta == 1 )
+	{
+		setCursorPos(getPos( line + page_size, offset ));
+		mScrollbar->setDocPos( mScrollbar->getDocPos() + page_size );
+	}
+	if (mOnScrollEndCallback && mOnScrollEndData && (mScrollbar->getDocPos() == mScrollbar->getDocPosMax()))
+	{
+		mOnScrollEndCallback(mOnScrollEndData);
+	}
+}
+
+void LLTextEditor::changeLine( S32 delta )
+{
+	bindEmbeddedChars( mGLFont );
+
+	S32 line, offset;
+	getLineAndOffset( mCursorPos, &line, &offset );
+
+	S32  line_start = getLineStart(line);
+
+	S32 desired_x_pixel;
+	
+	desired_x_pixel = mGLFont->getWidth(mWText.c_str(), line_start, offset, mAllowEmbeddedItems );
+
+	S32 new_line = 0;
+	if( (delta < 0) && (line > 0 ) )
+	{
+		new_line = line - 1;
+	}
+	else
+	if( (delta > 0) && (line < (getLineCount() - 1)) )
+	{
+		new_line = line + 1;
+	}
+	else
+	{
+		unbindEmbeddedChars( mGLFont );
+		return;
+	}
+
+	S32 num_lines = getLineCount();
+	S32 new_line_start = getLineStart(new_line);
+	S32 new_line_end = getLength();
+	if (new_line + 1 < num_lines)
+	{
+		new_line_end = getLineStart(new_line + 1) - 1;
+	}
+
+	S32 new_line_len = new_line_end - new_line_start;
+
+	S32 new_offset;
+	new_offset = mGLFont->charFromPixelOffset(mWText.c_str(), new_line_start,
+											  (F32)desired_x_pixel,
+											  (F32)mTextRect.getWidth(),
+											  new_line_len,
+											  mAllowEmbeddedItems);
+
+	setCursorPos (getPos( new_line, new_offset ));
+	unbindEmbeddedChars( mGLFont );
+}
+
+void LLTextEditor::startOfLine()
+{
+	S32 line, offset;
+	getLineAndOffset( mCursorPos, &line, &offset );
+	setCursorPos(mCursorPos - offset);
+}
+
+
+// public
+void LLTextEditor::setCursorAndScrollToEnd()
+{
+	deselect();
+	endOfDoc();
+	updateScrollFromCursor();
+}
+
+
+void LLTextEditor::getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wordwrap )
+{
+	if( include_wordwrap )
+	{
+		getLineAndOffset( mCursorPos, line, col );
+	}
+	else
+	{
+		const LLWString &text = mWText;
+		S32 line_count = 0;
+		S32 line_start = 0;
+		S32 i;
+		for( i = 0; text[i] && (i < mCursorPos); i++ )
+		{
+			if( '\n' == text[i] )
+			{
+				line_start = i + 1;
+				line_count++;
+			}
+		}
+		*line = line_count;
+		*col = i - line_start;
+	}
+}
+
+
+void LLTextEditor::endOfLine()
+{
+	S32 line, offset;
+	getLineAndOffset( mCursorPos, &line, &offset );
+	S32 num_lines = getLineCount();
+	if (line + 1 >= num_lines)
+	{
+		setCursorPos(getLength());
+	}
+	else
+	{
+		setCursorPos( getLineStart(line + 1) - 1 );
+	}
+}
+
+void LLTextEditor::endOfDoc()
+{
+	mScrollbar->setDocPos( mScrollbar->getDocPosMax() );
+	S32 len = getLength();
+	if( len )
+	{
+		setCursorPos(len);
+	}
+	if (mOnScrollEndCallback && mOnScrollEndData && (mScrollbar->getDocPos() == mScrollbar->getDocPosMax()))
+	{
+		mOnScrollEndCallback(mOnScrollEndData);
+	}
+}
+
+// Sets the scrollbar from the cursor position
+void LLTextEditor::updateScrollFromCursor()
+{
+	mScrollbar->setDocSize( getLineCount() );
+
+	if (mReadOnly)
+	{
+		// no cursor in read only mode
+		return;
+	}
+
+	S32 line, offset;
+	getLineAndOffset( mCursorPos, &line, &offset ); 
+
+	S32 page_size = mScrollbar->getPageSize();
+
+	if( line < mScrollbar->getDocPos() )
+	{
+		// scroll so that the cursor is at the top of the page
+		mScrollbar->setDocPos( line );
+	}
+	else if( line >= mScrollbar->getDocPos() + page_size - 1 )
+	{
+		S32 new_pos = 0;
+		if( line < mScrollbar->getDocSize() - 1 )
+		{
+			// scroll so that the cursor is one line above the bottom of the page,
+			new_pos = line - page_size + 1;
+		}
+		else
+		{
+			// if there is less than a page of text remaining, scroll so that the cursor is at the bottom
+			new_pos = mScrollbar->getDocPosMax();
+		}
+		mScrollbar->setDocPos( new_pos );
+	}
+
+	// Check if we've scrolled to bottom for callback if asked for callback
+	if (mOnScrollEndCallback && mOnScrollEndData && (mScrollbar->getDocPos() == mScrollbar->getDocPosMax()))
+	{
+		mOnScrollEndCallback(mOnScrollEndData);
+	}
+}
+
+void LLTextEditor::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	LLView::reshape( width, height, called_from_parent );
+
+	updateTextRect();
+
+	S32 line_height = llround( mGLFont->getLineHeight() );
+	S32 page_lines = mTextRect.getHeight() / line_height;
+	mScrollbar->setPageSize( page_lines );
+
+	updateLineStartList();
+}
+
+void LLTextEditor::autoIndent()
+{
+	// Count the number of spaces in the current line
+	S32 line, offset;
+	getLineAndOffset( mCursorPos, &line, &offset );
+	S32 line_start = getLineStart(line);
+	S32 space_count = 0;
+	S32 i;
+
+	const LLWString &text = mWText;
+	while( ' ' == text[line_start] )
+	{
+		space_count++;
+		line_start++;
+	}
+
+	// If we're starting a braced section, indent one level.
+	if( (mCursorPos > 0) && (text[mCursorPos -1] == '{') )
+	{
+		space_count += SPACES_PER_TAB;
+	}
+
+	// Insert that number of spaces on the new line
+	addChar( '\n' );
+	for( i = 0; i < space_count; i++ )
+	{
+		addChar( ' ' );
+	}
+}
+
+// Inserts new text at the cursor position
+void LLTextEditor::insertText(const LLString &new_text)
+{
+	BOOL enabled = getEnabled();
+	setEnabled( TRUE );
+
+	// Delete any selected characters (the insertion replaces them)
+	if( hasSelection() )
+	{
+		deleteSelection(TRUE);
+	}
+
+	setCursorPos(mCursorPos + insert( mCursorPos, utf8str_to_wstring(new_text), FALSE ));
+	
+	updateLineStartList();
+	updateScrollFromCursor();
+
+	setEnabled( enabled );
+}
+
+
+void LLTextEditor::appendColoredText(const LLString &new_text, 
+									 bool allow_undo, 
+									 bool prepend_newline,
+									 const LLColor4 &color,
+									 const LLString& font_name)
+{
+	LLStyle style;
+	style.setVisible(true);
+	style.setColor(color);
+	style.setFontName(font_name);
+	if(mParseHTML)
+	{
+
+		S32 start=0,end=0;
+		LLString text = new_text;
+		while ( findHTML(text, &start, &end) )
+		{
+			LLStyle html;
+			html.setVisible(true);
+			html.setColor(mLinkColor);
+			html.setFontName(font_name);
+			html.mUnderline = TRUE;
+
+			if (start > 0) appendText(text.substr(0,start),allow_undo, prepend_newline, &style);
+			html.setLinkHREF(text.substr(start,end-start));
+			appendText(text.substr(start, end-start),allow_undo, prepend_newline, &html);
+			if (end < (S32)text.length()) 
+			{
+				text = text.substr(end,text.length() - end);
+				end=0;
+			}
+			else
+			{
+				break;
+			}
+		}
+		if (end < (S32)text.length()) appendText(text,allow_undo, prepend_newline, &style);		
+	}
+	else
+	{
+		appendText(new_text, allow_undo, prepend_newline, &style);
+	}
+}
+
+void LLTextEditor::appendStyledText(const LLString &new_text, 
+									 bool allow_undo, 
+									 bool prepend_newline,
+									 const LLStyle &style)
+{
+	appendText(new_text, allow_undo, prepend_newline, &style);
+}
+
+// Appends new text to end of document
+void LLTextEditor::appendText(const LLString &new_text, bool allow_undo, bool prepend_newline,
+							  const LLStyle* segment_style)
+{
+	// Save old state
+	BOOL was_scrolled_to_bottom = (mScrollbar->getDocPos() == mScrollbar->getDocPosMax());
+	S32 selection_start = mSelectionStart;
+	S32 selection_end = mSelectionEnd;
+	S32 cursor_pos = mCursorPos;
+	S32 old_length = getLength();
+	BOOL cursor_was_at_end = (mCursorPos == old_length);
+
+	deselect();
+
+	setCursorPos(old_length);
+
+	// Add carriage return if not first line
+	if (getLength() != 0
+		&& prepend_newline)
+	{
+		LLString final_text = "\n";
+		final_text += new_text;
+		append(utf8str_to_wstring(final_text), TRUE);
+	}
+	else
+	{
+		append(utf8str_to_wstring(new_text), TRUE );
+	}
+
+	if (segment_style)
+	{
+		S32 segment_start = old_length;
+		S32 segment_end = getLength();
+		LLTextSegment* segment = new LLTextSegment(*segment_style, segment_start, segment_end );
+		mSegments.push_back(segment);
+	}
+	
+	updateLineStartList(old_length);
+	
+	// Set the cursor and scroll position
+	// Maintain the scroll position unless the scroll was at the end of the doc 
+	//	  (in which case, move it to the new end of the doc)
+	if( was_scrolled_to_bottom )
+	{
+		endOfDoc();
+	}
+	else if( selection_start != selection_end )
+	{
+		mSelectionStart = selection_start;
+
+		mSelectionEnd = selection_end;
+		setCursorPos(cursor_pos);
+	}
+	else if( cursor_was_at_end )
+	{
+		setCursorPos(getLength());
+	}
+	else
+	{
+		setCursorPos(cursor_pos);
+	}
+
+	if( !allow_undo )
+	{
+		blockUndo();
+	}
+}
+
+void LLTextEditor::removeTextFromEnd(S32 num_chars)
+{
+	if (num_chars <= 0) return;
+
+	remove(getLength() - num_chars, num_chars, FALSE);
+
+	S32 len = getLength();
+	mCursorPos = llclamp(mCursorPos, 0, len);
+	mSelectionStart = llclamp(mSelectionStart, 0, len);
+	mSelectionEnd = llclamp(mSelectionEnd, 0, len);
+
+	pruneSegments();
+	updateLineStartList();
+}
+
+///////////////////////////////////////////////////////////////////
+// Returns change in number of characters in mWText
+
+S32 LLTextEditor::insertStringNoUndo(const S32 pos, const LLWString &wstr)
+{
+	S32 len = mWText.length();
+	S32 s_len = wstr.length();
+	S32 new_len = len + s_len;
+	if( new_len > mMaxTextLength )
+	{
+		new_len = mMaxTextLength;
+
+		// The user's not getting everything he's hoping for
+		make_ui_sound("UISndBadKeystroke");
+	}
+
+	mWText.insert(pos, wstr);
+	mTextIsUpToDate = FALSE;
+	truncate();
+
+	return new_len - len;
+}
+
+S32 LLTextEditor::removeStringNoUndo(S32 pos, S32 length)
+{
+	mWText.erase(pos, length);
+	mTextIsUpToDate = FALSE;
+	return -length;	// This will be wrong if someone calls removeStringNoUndo with an excessive length
+}
+
+S32 LLTextEditor::overwriteCharNoUndo(S32 pos, llwchar wc)
+{
+	if (pos > (S32)mWText.length())
+	{
+		return 0;
+	}
+	mWText[pos] = wc;
+	mTextIsUpToDate = FALSE;
+	return 1;
+}
+
+//----------------------------------------------------------------------------
+
+void LLTextEditor::makePristine()
+{
+	mPristineCmd = mLastCmd;
+	mBaseDocIsPristine = !mLastCmd;
+
+	// Create a clean partition in the undo stack.  We don't want a single command to extend from
+	// the "pre-pristine" state to the "post-pristine" state.
+	if( mLastCmd )
+	{
+		mLastCmd->blockExtensions();
+	}
+}
+
+BOOL LLTextEditor::isPristine() const
+{
+	if( mPristineCmd )
+	{
+		return (mPristineCmd == mLastCmd);
+	}
+	else
+	{
+		// No undo stack, so check if the version before and commands were done was the original version
+		return !mLastCmd && mBaseDocIsPristine;
+	}
+}
+
+BOOL LLTextEditor::tryToRevertToPristineState()
+{
+	if( !isPristine() )
+	{
+		deselect();
+		S32 i = 0;
+		while( !isPristine() && canUndo() )
+		{
+			undo();
+			i--;
+		}
+
+		while( !isPristine() && canRedo() )
+		{
+			redo();
+			i++;
+		}
+
+		if( !isPristine() )
+		{
+			// failed, so go back to where we started
+			while( i > 0 )
+			{
+				undo();
+				i--;
+			}
+		}
+
+		updateLineStartList();
+		updateScrollFromCursor();
+	}
+
+	return isPristine(); // TRUE => success
+}
+
+
+
+void LLTextEditor::updateTextRect()
+{
+	mTextRect.setOriginAndSize( 
+		UI_TEXTEDITOR_BORDER + UI_TEXTEDITOR_H_PAD,
+		UI_TEXTEDITOR_BORDER, 
+		mRect.getWidth() - SCROLLBAR_SIZE - 2 * (UI_TEXTEDITOR_BORDER + UI_TEXTEDITOR_H_PAD),
+		mRect.getHeight() - 2 * UI_TEXTEDITOR_BORDER - UI_TEXTEDITOR_V_PAD_TOP );
+}
+
+void LLTextEditor::loadKeywords(const LLString& filename,
+								const LLDynamicArray<const char*>& funcs,
+								const LLDynamicArray<const char*>& tooltips,
+								const LLColor3& color)
+{
+	if(mKeywords.loadFromFile(filename))
+	{
+		S32 count = funcs.count();
+		LLString name;
+		for(S32 i = 0; i < count; i++)
+		{
+			name = funcs.get(i);
+			name = utf8str_trim(name);
+			mKeywords.addToken(LLKeywordToken::WORD, name.c_str(), color, tooltips.get(i) );
+		}
+
+		mKeywords.findSegments( &mSegments, mWText );
+
+		llassert( mSegments.front()->getStart() == 0 );
+		llassert( mSegments.back()->getEnd() == getLength() );
+	}
+}
+
+void LLTextEditor::updateSegments()
+{
+	if (mKeywords.isLoaded())
+	{
+		// HACK:  No non-ascii keywords for now
+		mKeywords.findSegments(&mSegments, mWText);
+	}
+	else if (mAllowEmbeddedItems)
+	{
+		findEmbeddedItemSegments();
+	}
+	// Make sure we have at least one segment
+	if (mSegments.size() == 1 && mSegments[0]->getIsDefault())
+	{
+		delete mSegments[0];
+		mSegments.clear(); // create default segment
+	}
+	if (mSegments.empty())
+	{
+		LLColor4& text_color = ( mReadOnly ? mReadOnlyFgColor : mFgColor );
+		LLTextSegment* default_segment = new LLTextSegment( text_color, 0, mWText.length() );
+		default_segment->setIsDefault(TRUE);
+		mSegments.push_back(default_segment);
+	}
+}
+
+// Only effective if text was removed from the end of the editor
+void LLTextEditor::pruneSegments()
+{
+	S32 len = mWText.length();
+	// Find and update the first valid segment
+	segment_list_t::iterator iter = mSegments.end();
+	while(iter != mSegments.begin())
+	{
+		--iter;
+		LLTextSegment* seg = *iter;
+		if (seg->getStart() < len)
+		{
+			// valid segment
+			if (seg->getEnd() > len)
+			{
+				seg->setEnd(len);
+			}
+			break; // done
+		}			
+	}
+	// erase invalid segments
+	++iter;
+	std::for_each(iter, mSegments.end(), DeletePointer());
+	mSegments.erase(iter, mSegments.end());
+}
+
+void LLTextEditor::findEmbeddedItemSegments()
+{
+	mHoverSegment = NULL;
+	std::for_each(mSegments.begin(), mSegments.end(), DeletePointer());
+	mSegments.clear();
+
+	BOOL found_embedded_items = FALSE;
+	const LLWString &text = mWText;
+	S32 idx = 0;
+	while( text[idx] )
+	{
+		if( text[idx] >= FIRST_EMBEDDED_CHAR && text[idx] <= LAST_EMBEDDED_CHAR )
+ 		{
+			found_embedded_items = TRUE;
+			break;
+		}
+		++idx;
+	}
+
+	if( !found_embedded_items )
+	{
+		return;
+	}
+
+	S32 text_len = text.length();
+
+	BOOL in_text = FALSE;
+
+	LLColor4& text_color = ( mReadOnly ? mReadOnlyFgColor : mFgColor  );
+
+	if( idx > 0 )
+	{
+		mSegments.push_back( new LLTextSegment( text_color, 0, text_len ) ); // text
+		in_text = TRUE;
+	}
+
+	LLStyle embedded_style;
+	embedded_style.setIsEmbeddedItem( TRUE );
+
+	// Start with i just after the first embedded item
+	while ( text[idx] )
+	{
+		if( text[idx] >= FIRST_EMBEDDED_CHAR && text[idx] <= LAST_EMBEDDED_CHAR )
+		{
+			if( in_text )
+			{
+				mSegments.back()->setEnd( idx );
+			}
+			mSegments.push_back( new LLTextSegment( embedded_style, idx, idx + 1 ) );  // item
+			in_text = FALSE;
+		}
+		else
+		if( !in_text )
+		{
+			mSegments.push_back( new LLTextSegment( text_color, idx, text_len ) );  // text
+			in_text = TRUE;
+		}
+		++idx;
+	}
+}
+
+BOOL LLTextEditor::handleMouseUpOverSegment(S32 x, S32 y, MASK mask)
+{
+	return FALSE;
+}
+
+llwchar LLTextEditor::pasteEmbeddedItem(llwchar ext_char)
+{
+	return ext_char;
+}
+
+void LLTextEditor::bindEmbeddedChars(const LLFontGL* font)
+{
+}
+
+void LLTextEditor::unbindEmbeddedChars(const LLFontGL* font)
+{
+}
+
+// Finds the text segment (if any) at the give local screen position
+LLTextSegment* LLTextEditor::getSegmentAtLocalPos( S32 x, S32 y )
+{
+	// Find the cursor position at the requested local screen position
+	S32 offset = getCursorPosFromLocalCoord( x, y, FALSE );
+	S32 idx = getSegmentIdxAtOffset(offset);
+	return idx >= 0 ? mSegments[idx] : NULL;
+}
+
+LLTextSegment* LLTextEditor::getSegmentAtOffset(S32 offset)
+{
+	S32 idx = getSegmentIdxAtOffset(offset);
+	return idx >= 0 ? mSegments[idx] : NULL;
+}
+
+S32 LLTextEditor::getSegmentIdxAtOffset(S32 offset)
+{
+	if (mSegments.empty() || offset < 0 || offset >= getLength())
+	{
+		return -1;
+	}
+	else
+	{
+		S32 segidx, segoff;
+		getSegmentAndOffset(offset, &segidx, &segoff);
+		return segidx;
+	}
+}
+
+//static
+void LLTextEditor::onMouseCaptureLost( LLMouseHandler* old_captor )
+{
+	LLTextEditor* self = (LLTextEditor*) old_captor;
+	self->endSelection();
+}
+
+void LLTextEditor::setOnScrollEndCallback(void (*callback)(void*), void* userdata)
+{
+	mOnScrollEndCallback = callback;
+	mOnScrollEndData = userdata;
+	mScrollbar->setOnScrollEndCallback(callback, userdata);
+}
+
+///////////////////////////////////////////////////////////////////
+// Hack for Notecards
+
+BOOL LLTextEditor::importBuffer(const LLString& buffer )
+{
+	std::istringstream instream(buffer);
+	
+	// Version 1 format:
+	//		Linden text version 1\n
+	//		{\n
+	//			<EmbeddedItemList chunk>
+	//			Text length <bytes without \0>\n
+	//			<text without \0> (text may contain ext_char_values)
+	//		}\n
+
+	char tbuf[MAX_STRING];
+	
+	S32 version = 0;
+	instream.getline(tbuf, MAX_STRING);
+	if( 1 != sscanf(tbuf, "Linden text version %d", &version) )
+	{
+		llwarns << "Invalid Linden text file header " << llendl;
+		return FALSE;
+	}
+
+	if( 1 != version )
+	{
+		llwarns << "Invalid Linden text file version: " << version << llendl;
+		return FALSE;
+	}
+
+	instream.getline(tbuf, MAX_STRING);
+	if( 0 != sscanf(tbuf, "{") )
+	{
+		llwarns << "Invalid Linden text file format" << llendl;
+		return FALSE;
+	}
+
+	S32 text_len = 0;
+	instream.getline(tbuf, MAX_STRING);
+	if( 1 != sscanf(tbuf, "Text length %d", &text_len) )
+	{
+		llwarns << "Invalid Linden text length field" << llendl;
+		return FALSE;
+	}
+
+	if( text_len > mMaxTextLength )
+	{
+		llwarns << "Invalid Linden text length: " << text_len << llendl;
+		return FALSE;
+	}
+
+	BOOL success = TRUE;
+
+	char* text = new char[ text_len + 1];
+	instream.get(text, text_len + 1, '\0');
+	text[text_len] = '\0';
+	if( text_len != (S32)strlen(text) )
+	{
+		llwarns << llformat("Invalid text length: %d != %d ",strlen(text),text_len) << llendl;
+		success = FALSE;
+	}
+
+	instream.getline(tbuf, MAX_STRING);
+	if( success && (0 != sscanf(tbuf, "}")) )
+	{
+		llwarns << "Invalid Linden text file format: missing terminal }" << llendl;
+		success = FALSE;
+	}
+
+	if( success )
+	{
+		// Actually set the text
+		setText( text );
+	}
+
+	delete[] text;
+
+	setCursorPos(0);
+	deselect();
+
+	updateLineStartList();
+	updateScrollFromCursor();
+
+	return success;
+}
+
+BOOL LLTextEditor::exportBuffer(LLString &buffer )
+{
+	std::ostringstream outstream(buffer);
+	
+	outstream << "Linden text version 1\n";
+	outstream << "{\n";
+
+	outstream << llformat("Text length %d\n", mWText.length() );
+	outstream << getText();
+	outstream << "}\n";
+
+	return TRUE;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// LLTextSegment
+
+LLTextSegment::LLTextSegment(S32 start) : mStart(start)
+{
+} 
+LLTextSegment::LLTextSegment( const LLStyle& style, S32 start, S32 end ) :
+	mStyle( style ),
+	mStart( start),
+	mEnd( end ),
+	mToken(NULL),
+	mIsDefault(FALSE)
+{
+}
+LLTextSegment::LLTextSegment(
+	const LLColor4& color, S32 start, S32 end, BOOL is_visible) :
+	mStyle( is_visible, color,"" ),
+	mStart( start),
+	mEnd( end ),
+	mToken(NULL),
+	mIsDefault(FALSE)
+{
+}
+LLTextSegment::LLTextSegment( const LLColor4& color, S32 start, S32 end ) :
+	mStyle( TRUE, color,"" ),
+	mStart( start),
+	mEnd( end ),
+	mToken(NULL),
+	mIsDefault(FALSE)
+{
+}
+LLTextSegment::LLTextSegment( const LLColor3& color, S32 start, S32 end ) :
+	mStyle( TRUE, color,"" ),
+	mStart( start),
+	mEnd( end ),
+	mToken(NULL),
+	mIsDefault(FALSE)
+{
+}
+
+BOOL LLTextSegment::getToolTip(LLString& msg)
+{
+	if (mToken && !mToken->getToolTip().empty())
+	{
+		const LLWString& wmsg = mToken->getToolTip();
+		msg = wstring_to_utf8str(wmsg);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+
+
+void LLTextSegment::dump()
+{
+	llinfos << "Segment [" << 
+//			mColor.mV[VX] << ", " <<
+//			mColor.mV[VY] << ", " <<
+//			mColor.mV[VZ] << "]\t[" <<
+		mStart << ", " <<
+		getEnd() << "]" <<
+		llendl;
+
+}
+
+// virtual
+LLXMLNodePtr LLTextEditor::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLUICtrl::getXML();
+
+	// Attributes
+
+	node->createChild("max_length", TRUE)->setIntValue(getMaxLength());
+
+	node->createChild("embedded_items", TRUE)->setBoolValue(mAllowEmbeddedItems);
+
+	node->createChild("font", TRUE)->setStringValue(LLFontGL::nameFromFont(mGLFont));
+
+	node->createChild("word_wrap", TRUE)->setBoolValue(mWordWrap);
+
+	addColorXML(node, mCursorColor, "cursor_color", "TextCursorColor");
+	addColorXML(node, mFgColor, "text_color", "TextFgColor");
+	addColorXML(node, mReadOnlyFgColor, "text_readonly_color", "TextFgReadOnlyColor");
+	addColorXML(node, mReadOnlyBgColor, "bg_readonly_color", "TextBgReadOnlyColor");
+	addColorXML(node, mWriteableBgColor, "bg_writeable_color", "TextBgWriteableColor");
+	addColorXML(node, mFocusBgColor, "bg_focus_color", "TextBgFocusColor");
+
+	// Contents
+ 	node->setStringValue(getText());
+
+	return node;
+}
+
+// static
+LLView* LLTextEditor::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("text_editor");
+	node->getAttributeString("name", name);
+
+	LLRect rect;
+	createRect(node, rect, parent, LLRect());
+
+	U32 max_text_length = 255;
+	node->getAttributeU32("max_length", max_text_length);
+
+	BOOL allow_embedded_items;
+	node->getAttributeBOOL("embedded_items", allow_embedded_items);
+
+	LLFontGL* font = LLView::selectFont(node);
+
+	LLString text = node->getTextContents().substr(0, max_text_length - 1);
+
+	LLTextEditor* text_editor = new LLTextEditor(name, 
+								rect,
+								max_text_length,
+								text,
+								font,
+								allow_embedded_items);
+
+	text_editor->setTextEditorParameters(node);
+
+	BOOL hide_scrollbar = FALSE;
+	node->getAttributeBOOL("hide_scrollbar",hide_scrollbar);
+	text_editor->setHideScrollbarForShortDocs(hide_scrollbar);
+
+	text_editor->initFromXML(node, parent);
+
+	return text_editor;
+}
+
+void LLTextEditor::setTextEditorParameters(LLXMLNodePtr node)
+{
+	BOOL word_wrap = FALSE;
+	node->getAttributeBOOL("word_wrap", word_wrap);
+	setWordWrap(word_wrap);
+
+	LLColor4 color;
+	if (LLUICtrlFactory::getAttributeColor(node,"cursor_color", color)) 
+	{
+		setCursorColor(color);
+	}
+	if(LLUICtrlFactory::getAttributeColor(node,"text_color", color))
+	{
+		setFgColor(color);
+	}
+	if(LLUICtrlFactory::getAttributeColor(node,"text_readonly_color", color))
+	{
+		setReadOnlyFgColor(color);
+	}
+	if(LLUICtrlFactory::getAttributeColor(node,"bg_readonly_color", color))
+	{
+		setReadOnlyBgColor(color);
+	}
+	if(LLUICtrlFactory::getAttributeColor(node,"bg_writeable_color", color))
+	{
+		setWriteableBgColor(color);
+	}
+}
+
+///////////////////////////////////////////////////////////////////
+S32 LLTextEditor::findHTMLToken(const LLString &line, S32 pos, BOOL reverse)
+{
+	LLString openers=" \t('\"[{<>";
+	LLString closers=" \t)'\"]}><;";
+
+	S32 m2;
+	S32 retval;
+	
+	if (reverse)
+	{
+		
+		for (retval=pos; retval>0; retval--)
+		{
+			m2 = openers.find(line.substr(retval,1));
+			if (m2 >= 0)
+			{
+				retval++;
+				break;
+			}
+		}
+	} 
+	else
+	{
+		
+		for (retval=pos; retval<(S32)line.length(); retval++)
+		{
+			m2 = closers.find(line.substr(retval,1));
+			if (m2 >= 0)
+			{
+				break;
+			}
+		} 
+	}		
+	
+	return retval;
+}
+
+BOOL LLTextEditor::findHTML(const LLString &line, S32 *begin, S32 *end)
+{
+	  
+	S32 m1,m2,m3;
+	BOOL matched = FALSE;
+	
+	m1=line.find("://",*end);
+	
+	if (m1 >= 0) //Easy match.
+	{
+		*begin = findHTMLToken(line, m1, TRUE);
+		*end   = findHTMLToken(line, m1, FALSE);
+		
+		//Load_url only handles http and https so don't hilite ftp, smb, etc.
+		m2 = line.substr(*begin,(m1 - *begin)).find("http");
+		m3 = line.substr(*begin,(m1 - *begin)).find("secondlife");
+	
+		LLString badneighbors=".,<>/?';\"][}{=-+_)(*&^%$#@!~`\t\r\n\\";
+	
+		if (m2 >= 0 || m3>=0)
+		{
+			S32 bn = badneighbors.find(line.substr(m1+3,1));
+			
+			if (bn < 0)
+			{
+				matched = TRUE;
+			}
+		}
+	}
+/*	matches things like secondlife.com (no http://) needs a whitelist to really be effective.
+	else	//Harder match.
+	{
+		m1 = line.find(".",*end);
+		
+		if (m1 >= 0)
+		{
+			*end   = findHTMLToken(line, m1, FALSE);
+			*begin = findHTMLToken(line, m1, TRUE);
+			
+			m1 = line.rfind(".",*end);
+
+			if ( ( *end - m1 ) > 2 && m1 > *begin)
+			{
+				LLString badneighbors=".,<>/?';\"][}{=-+_)(*&^%$#@!~`";
+				m2 = badneighbors.find(line.substr(m1+1,1));
+				m3 = badneighbors.find(line.substr(m1-1,1));
+				if (m3<0 && m2<0)
+				{
+					matched = TRUE;
+				}
+			}
+		}
+	}
+	*/
+	
+	if (matched)
+	{
+		S32 strpos, strpos2;
+
+		LLString url     = line.substr(*begin,*end - *begin);
+		LLString slurlID = "slurl.com/secondlife/";
+		strpos = url.find(slurlID);
+		
+		if (strpos < 0)
+		{
+			slurlID="secondlife://";
+			strpos = url.find(slurlID);
+		}
+	
+		if (strpos >= 0) 
+		{
+			strpos+=slurlID.length();
+			
+			while ( ( strpos2=url.find("/",strpos) ) == -1 ) 
+			{
+				if ((*end+2) >= (S32)line.length() || line.substr(*end,1) != " " )
+				{
+					matched=FALSE;
+					break;
+				}
+				
+				strpos = (*end + 1) - *begin;
+								
+				*end = findHTMLToken(line,(*begin + strpos),FALSE);
+				url = line.substr(*begin,*end - *begin);
+			}
+		}
+
+	}
+	
+	if (!matched)
+	{
+		*begin=*end=0;
+	}
+	return matched;
+}
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
new file mode 100644
index 0000000000..bebf2b31f2
--- /dev/null
+++ b/indra/llui/lltexteditor.h
@@ -0,0 +1,483 @@
+/** 
+ * @file lltexteditor.h
+ * @brief LLTextEditor base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Text editor widget to let users enter a a multi-line ASCII document//
+
+#ifndef LL_LLTEXTEDITOR_H
+#define LL_LLTEXTEDITOR_H
+
+#include "llrect.h"
+#include "llkeywords.h"
+#include "lluictrl.h"
+#include "llframetimer.h"
+#include "lldarray.h"
+#include "llstyle.h"
+#include "lleditmenuhandler.h"
+#include "lldarray.h"
+
+class LLFontGL;
+class LLScrollbar;
+class LLViewBorder;
+class LLKeywordToken;
+class LLTextCmd;
+
+//
+// Constants
+//
+
+const llwchar FIRST_EMBEDDED_CHAR = 0x100000;
+const llwchar LAST_EMBEDDED_CHAR =  0x10ffff;
+const S32 MAX_EMBEDDED_ITEMS = LAST_EMBEDDED_CHAR - FIRST_EMBEDDED_CHAR + 1;
+
+//
+// Classes
+//
+class LLTextSegment;
+class LLTextCmd;
+
+class LLTextEditor : public LLUICtrl, LLEditMenuHandler
+{
+	friend class LLTextCmd;
+public:
+	LLTextEditor(const LLString& name,
+				 const LLRect& rect,
+				 S32 max_length,
+				 const LLString &default_text, 
+				 const LLFontGL* glfont = NULL,
+				 BOOL allow_embedded_items = FALSE);
+
+	virtual ~LLTextEditor();
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_TEXT_EDITOR; }
+	virtual LLString getWidgetTag() const;
+
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	void    setTextEditorParameters(LLXMLNodePtr node);
+	void	setParseHTML(BOOL parsing) {mParseHTML=parsing;}
+
+	// mousehandler overrides
+	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
+	virtual BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	virtual BOOL	handleDoubleClick(S32 x, S32 y, MASK mask );
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent );
+	virtual BOOL	handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent);
+
+	virtual BOOL	handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect);
+	virtual BOOL	handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
+									  EDragAndDropType cargo_type, void *cargo_data,
+									  EAcceptance *accept, LLString& tooltip_msg);
+
+	// view overrides
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent);
+	virtual void	draw();
+	virtual void	onFocusLost();
+	virtual void	setEnabled(BOOL enabled);
+
+	// uictrl overrides
+	virtual void	onTabInto();
+	virtual void	clear();
+	virtual void	setFocus( BOOL b );
+	virtual BOOL	acceptsTextInput() const;
+
+	// LLEditMenuHandler interface
+	virtual void	undo();
+	virtual BOOL	canUndo();
+
+	virtual void	redo();
+	virtual BOOL	canRedo();
+
+	virtual void	cut();
+	virtual BOOL	canCut();
+
+	virtual void	copy();
+	virtual BOOL	canCopy();
+
+	virtual void	paste();
+	virtual BOOL	canPaste();
+	
+	virtual void	doDelete();
+	virtual BOOL	canDoDelete();
+
+	virtual void	selectAll();
+	virtual BOOL	canSelectAll();
+
+	virtual void	deselect();
+	virtual BOOL	canDeselect();
+
+	void			selectNext(const LLString& search_text_in, BOOL case_insensitive, BOOL wrap = TRUE);
+	BOOL			replaceText(const LLString& search_text, const LLString& replace_text, BOOL case_insensitive, BOOL wrap = TRUE);
+	void			replaceTextAll(const LLString& search_text, const LLString& replace_text, BOOL case_insensitive);
+	
+	// Undo/redo stack
+	void			blockUndo();
+
+	// Text editing
+	virtual void	makePristine();
+	BOOL			isPristine() const;
+
+	// inserts text at cursor
+	void			insertText(const LLString &text);
+	// appends text at end
+	void 			appendText(const LLString &wtext, bool allow_undo, bool prepend_newline,
+							   const LLStyle* segment_style = NULL);
+
+	void 			appendColoredText(const LLString &wtext, bool allow_undo, 
+									  bool prepend_newline,
+									  const LLColor4 &color,
+									  const LLString& font_name = LLString::null);
+	// if styled text starts a line, you need to prepend a newline.
+	void 			appendStyledText(const LLString &new_text, bool allow_undo, 
+									 bool prepend_newline,
+									 const LLStyle &style);
+
+	// Removes text from the end of document
+	// Does not change highlight or cursor position.
+	void 			removeTextFromEnd(S32 num_chars);
+
+	BOOL			tryToRevertToPristineState();
+
+	void			setCursor(S32 row, S32 column);
+	void			setCursorPos(S32 offset);
+	void			setCursorAndScrollToEnd();
+
+	void			getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wordwrap );
+
+	void			loadKeywords(const LLString& filename,
+								 const LLDynamicArray<const char*>& funcs,
+								 const LLDynamicArray<const char*>& tooltips,
+								 const LLColor3& func_color);
+
+	void 			setCursorColor(const LLColor4& c)			{ mCursorColor = c; }
+	void 			setFgColor( const LLColor4& c )				{ mFgColor = c; }
+	void 			setReadOnlyFgColor( const LLColor4& c )		{ mReadOnlyFgColor = c; }
+	void 			setWriteableBgColor( const LLColor4& c )	{ mWriteableBgColor = c; }
+	void 			setReadOnlyBgColor( const LLColor4& c )		{ mReadOnlyBgColor = c; }
+
+	void			setTrackColor( const LLColor4& color );
+	void			setThumbColor( const LLColor4& color );
+	void			setHighlightColor( const LLColor4& color );
+	void			setShadowColor( const LLColor4& color );
+
+	// Hacky methods to make it into a word-wrapping, potentially scrolling,
+	// read-only text box.
+	void			setBorderVisible(BOOL b);
+	void			setTakesNonScrollClicks(BOOL b);
+	void			setHideScrollbarForShortDocs(BOOL b);
+
+	void			setWordWrap( BOOL b );
+	void			setTabToNextField(BOOL b)				{ mTabToNextField = b; }
+	void			setCommitOnFocusLost(BOOL b)			{ mCommitOnFocusLost = b; }
+
+	// If takes focus, will take keyboard focus on click.
+	void			setTakesFocus(BOOL b)					{ mTakesFocus = b; }
+
+	// Hack to handle Notecards
+	virtual BOOL	importBuffer(const LLString& buffer );
+	virtual BOOL	exportBuffer(LLString& buffer );
+
+	void			setSourceID(const LLUUID& id) 			{ mSourceID = id; }
+	void 			setAcceptCallingCardNames(BOOL enable)	{ mAcceptCallingCardNames = enable; }
+
+	void			setHandleEditKeysDirectly( BOOL b ) 	{ mHandleEditKeysDirectly = b; }
+
+	// Callbacks
+	static void		onMouseCaptureLost( LLMouseHandler* old_captor );
+	static void		setLinkColor(LLColor4 color) { mLinkColor = color; }
+	static void		setURLCallbacks(	void (*callback1) (const char* url), 
+										BOOL (*callback2) (LLString url)      ) 
+										{ mURLcallback = callback1; mSecondlifeURLcallback = callback2;}
+
+	void			setOnScrollEndCallback(void (*callback)(void*), void* userdata);
+
+	// new methods
+	void 			setValue(const LLSD& value);
+	LLSD 			getValue() const;
+
+ 	const LLString&	getText() const;
+	
+	// Non-undoable
+	void			setText(const LLString &utf8str);
+	void			setWText(const LLWString &wtext);
+	
+	S32				getMaxLength() const 			{ return mMaxTextLength; }
+
+	// Change cursor
+	void			startOfLine();
+	void			endOfLine();
+	void			endOfDoc();
+	
+	// Getters
+	const LLWString& getWText() const;
+	llwchar			getWChar(S32 pos);
+	LLWString		getWSubString(S32 pos, S32 len);
+	
+protected:
+ 	S32				getLength() const;
+	void			getSegmentAndOffset( S32 startpos, S32* segidxp, S32* offsetp );
+
+	void			drawBackground();
+	void			drawSelectionBackground();
+	void			drawCursor();
+	void			drawText();
+	void			drawClippedSegment(const LLWString &wtext, S32 seg_start, S32 seg_end, F32 x, F32 y, S32 selection_left, S32 selection_right, const LLStyle& color, F32* right_x);
+
+	void			updateLineStartList(S32 startpos = 0);
+	void			updateScrollFromCursor();
+	void			updateTextRect();
+	void			updateSegments();
+	void			pruneSegments();
+
+	void 			assignEmbedded(const LLString &s);
+	void 			truncate();
+	
+	static BOOL		isPartOfWord(llwchar c);
+
+	void			removeCharOrTab();
+	void			setCursorAtLocalPos(S32 x, S32 y, BOOL round);
+	S32				getCursorPosFromLocalCoord( S32 local_x, S32 local_y, BOOL round );
+
+	void			indentSelectedLines( S32 spaces );
+	S32				indentLine( S32 pos, S32 spaces );
+	void			unindentLineBeforeCloseBrace();
+
+	S32				getSegmentIdxAtOffset(S32 offset);
+	LLTextSegment*	getSegmentAtLocalPos(S32 x, S32 y);
+	LLTextSegment*	getSegmentAtOffset(S32 offset);
+
+	void			reportBadKeystroke();
+
+	BOOL			handleNavigationKey(const KEY key, const MASK mask);
+	BOOL			handleSpecialKey(const KEY key, const MASK mask, BOOL* return_key_hit);
+	BOOL			handleSelectionKey(const KEY key, const MASK mask);
+	BOOL			handleControlKey(const KEY key, const MASK mask);
+	BOOL			handleEditKey(const KEY key, const MASK mask);
+
+	BOOL			hasSelection() { return (mSelectionStart !=mSelectionEnd); }
+	BOOL			selectionContainsLineBreaks();
+	void			startSelection();
+	void			endSelection();
+	void			deleteSelection(BOOL transient_operation);
+
+	S32				prevWordPos(S32 cursorPos) const;
+	S32				nextWordPos(S32 cursorPos) const;
+
+	S32 			getLineCount();
+	S32 			getLineStart( S32 line );
+	void			getLineAndOffset(S32 pos, S32* linep, S32* offsetp);
+	S32				getPos(S32 line, S32 offset);
+
+	void			changePage(S32 delta);
+	void			changeLine(S32 delta);
+
+	void			autoIndent();
+
+	S32 			execute(LLTextCmd* cmd);
+	
+	void			findEmbeddedItemSegments();
+	
+	virtual BOOL	handleMouseUpOverSegment(S32 x, S32 y, MASK mask);
+	virtual llwchar	pasteEmbeddedItem(llwchar ext_char);
+	virtual void	bindEmbeddedChars(const LLFontGL* font);
+	virtual void	unbindEmbeddedChars(const LLFontGL* font);
+	
+	S32				findHTMLToken(const LLString &line, S32 pos, BOOL reverse);
+	BOOL			findHTML(const LLString &line, S32 *begin, S32 *end);
+
+protected:
+	// Undoable operations
+	void			addChar(llwchar c); // at mCursorPos
+	S32				addChar(S32 pos, llwchar wc);
+	S32				overwriteChar(S32 pos, llwchar wc);
+	void			removeChar();
+	S32 			removeChar(S32 pos);
+	S32				insert(const S32 pos, const LLWString &wstr, const BOOL group_with_next_op);
+	S32				remove(const S32 pos, const S32 length, const BOOL group_with_next_op);
+	S32				append(const LLWString &wstr, const BOOL group_with_next_op);
+	
+	// direct operations
+	S32				insertStringNoUndo(S32 pos, const LLWString &utf8str); // returns num of chars actually inserted
+	S32 			removeStringNoUndo(S32 pos, S32 length);
+	S32				overwriteCharNoUndo(S32 pos, llwchar wc);
+	
+public:
+	LLKeywords		mKeywords;
+	static LLColor4 mLinkColor;
+	static void			(*mURLcallback) (const char* url);
+	static BOOL			(*mSecondlifeURLcallback) (LLString url);
+protected:
+	LLWString		mWText;
+	mutable LLString mUTF8Text;
+	mutable BOOL	mTextIsUpToDate;
+	
+	S32				mMaxTextLength;		// Maximum length mText is allowed to be
+
+	const LLFontGL*	mGLFont;
+
+	LLScrollbar*	mScrollbar;
+	LLViewBorder*	mBorder;
+
+	BOOL			mBaseDocIsPristine;
+	LLTextCmd*		mPristineCmd;
+
+	LLTextCmd*		mLastCmd;
+
+	typedef std::deque<LLTextCmd*> undo_stack_t;
+	undo_stack_t	mUndoStack;
+
+	S32				mCursorPos;				// I-beam is just after the mCursorPos-th character.
+	LLRect			mTextRect;				// The rect in which text is drawn.  Excludes borders.
+	// List of offsets and segment index of the start of each line.  Always has at least one node (0).
+	struct line_info
+	{
+		line_info(S32 segment, S32 offset) : mSegment(segment), mOffset(offset) {}
+		S32 mSegment;
+		S32 mOffset;
+	};
+	struct line_info_compare
+	{
+		bool operator()(const line_info& a, const line_info& b) const
+		{
+			if (a.mSegment < b.mSegment)
+				return true;
+			else if (a.mSegment > b.mSegment)
+				return false;
+			else
+				return a.mOffset < b.mOffset;
+		}
+	};
+	typedef std::vector<line_info> line_list_t;
+	line_list_t mLineStartList;
+	
+	// Are we in the middle of a drag-select?  To figure out if there is a current
+	// selection, call hasSelection().
+	BOOL			mIsSelecting;
+
+	S32				mSelectionStart;
+	S32				mSelectionEnd;
+
+	void			(*mOnScrollEndCallback)(void*);
+	void			*mOnScrollEndData;
+
+	typedef std::vector<LLTextSegment *> segment_list_t;
+	segment_list_t mSegments;
+	LLTextSegment*	mHoverSegment;
+	LLFrameTimer	mKeystrokeTimer;
+
+	LLColor4		mCursorColor;
+
+	LLColor4		mFgColor;
+	LLColor4		mReadOnlyFgColor;
+	LLColor4		mWriteableBgColor;
+	LLColor4		mReadOnlyBgColor;
+	LLColor4		mFocusBgColor;
+
+	BOOL			mReadOnly;
+	BOOL			mWordWrap;
+
+	BOOL			mTabToNextField;		// if true, tab moves focus to next field, else inserts spaces
+	BOOL			mCommitOnFocusLost;
+	BOOL			mTakesFocus;
+	BOOL			mHideScrollbarForShortDocs;
+	BOOL			mTakesNonScrollClicks;
+
+	BOOL			mAllowEmbeddedItems;
+
+	BOOL 			mAcceptCallingCardNames;
+
+	LLUUID			mSourceID;
+
+	BOOL			mHandleEditKeysDirectly;  // If true, the standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system
+
+	// Use these to determine if a click on an embedded item is a drag 
+	// or not.
+	S32				mMouseDownX;
+	S32				mMouseDownY;
+
+	S32				mLastSelectionX;
+	S32				mLastSelectionY;
+
+	BOOL			mParseHTML;
+	LLString		mHTML;
+};
+
+class LLTextSegment
+{
+public:
+	// for creating a compare value
+	LLTextSegment(S32 start);
+	LLTextSegment( const LLStyle& style, S32 start, S32 end );
+	LLTextSegment( const LLColor4& color, S32 start, S32 end, BOOL is_visible);
+	LLTextSegment( const LLColor4& color, S32 start, S32 end );
+	LLTextSegment( const LLColor3& color, S32 start, S32 end );
+
+	S32					getStart()							{ return mStart; }
+	S32					getEnd()							{ return mEnd; }
+	void				setEnd( S32 end )					{ mEnd = end; }
+	const LLColor4&		getColor()							{ return mStyle.getColor(); }
+	void 				setColor(const LLColor4 &color)		{ mStyle.setColor(color); }
+	const LLStyle&		getStyle()							{ return mStyle; }
+	void 				setStyle(const LLStyle &style)		{ mStyle = style; }
+	void 				setIsDefault(BOOL b)   				{ mIsDefault = b; }
+	BOOL 				getIsDefault()		   				{ return mIsDefault; }
+
+	void				setToken( LLKeywordToken* token )	{ mToken = token; }
+	LLKeywordToken*		getToken()							{ return mToken; }
+	BOOL				getToolTip( LLString& msg );
+
+	void				dump();
+
+	struct compare
+	{
+		bool operator()(const LLTextSegment* a, const LLTextSegment* b) const
+		{
+			return a->mStart < b->mStart;
+		}
+	};
+	
+private:
+	LLStyle     mStyle;
+	S32			mStart;
+	S32			mEnd;
+	LLKeywordToken* mToken;
+	BOOL		mIsDefault;
+};
+
+class LLTextCmd
+{
+public:
+	LLTextCmd( S32 pos, BOOL group_with_next )
+		: mPos(pos),
+		  mGroupWithNext(group_with_next)
+	{
+	}
+	virtual			~LLTextCmd() {}
+	virtual BOOL	execute(LLTextEditor* editor, S32* delta) = 0;
+	virtual S32		undo(LLTextEditor* editor) = 0;
+	virtual S32		redo(LLTextEditor* editor) = 0;
+	virtual BOOL	canExtend(S32 pos);
+	virtual void	blockExtensions();
+	virtual BOOL	extendAndExecute( LLTextEditor* editor, S32 pos, llwchar c, S32* delta );
+	virtual BOOL	hasExtCharValue( llwchar value );
+
+	// Define these here so they can access LLTextEditor through the friend relationship
+	S32				insert(LLTextEditor* editor, S32 pos, const LLWString &utf8str);
+	S32 			remove(LLTextEditor* editor, S32 pos, S32 length);
+	S32				overwrite(LLTextEditor* editor, S32 pos, llwchar wc);
+	
+	BOOL			groupWithNext() { return mGroupWithNext; }
+	
+protected:
+	S32			mPos;
+	BOOL		mGroupWithNext;
+};
+
+
+#endif  // LL_TEXTEDITOR_
diff --git a/indra/llui/llui.cpp b/indra/llui/llui.cpp
new file mode 100644
index 0000000000..d951cb70f6
--- /dev/null
+++ b/indra/llui/llui.cpp
@@ -0,0 +1,1764 @@
+/** 
+ * @file llui.cpp
+ * @brief UI implementation
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Utilities functions the user interface needs
+
+//#include "llviewerprecompiledheaders.h"
+#include "linden_common.h"
+
+#include <string>
+#include <map>
+
+// Linden library includes
+#include "audioengine.h"
+#include "v2math.h"
+#include "v4color.h"
+#include "llgl.h"
+#include "llrect.h"
+#include "llimagegl.h"
+//#include "llviewerimage.h"
+#include "lldir.h"
+#include "llfontgl.h"
+
+// Project includes
+//#include "audioengine.h"
+#include "llcontrol.h"
+//#include "llstartup.h"
+#include "llui.h"
+#include "llview.h"
+#include "llwindow.h"
+
+#include "llglheaders.h"
+
+//
+// Globals
+//
+const LLColor4 UI_VERTEX_COLOR(1.f, 1.f, 1.f, 1.f);
+
+// Used to hide the flashing text cursor when window doesn't have focus.
+BOOL gShowTextEditCursor = TRUE;
+
+// Language for UI construction
+LLString gLanguage = "english-usa";
+std::map<LLString, LLString> gTranslation;
+std::list<LLString> gUntranslated;
+
+LLControlGroup* LLUI::sConfigGroup = NULL;
+LLControlGroup* LLUI::sColorsGroup = NULL;
+LLControlGroup* LLUI::sAssetsGroup = NULL;
+LLImageProviderInterface* LLUI::sImageProvider = NULL;
+LLUIAudioCallback LLUI::sAudioCallback = NULL;
+LLVector2		LLUI::sGLScaleFactor(1.f, 1.f);
+LLWindow*		LLUI::sWindow = NULL;
+BOOL            LLUI::sShowXUINames = FALSE;
+//
+// Functions
+//
+void make_ui_sound(const LLString& name)
+{
+	if (!LLUI::sConfigGroup->controlExists(name))
+	{
+		llwarns << "tried to make ui sound for unknown sound name: " << name << llendl;	
+	}
+	else
+	{
+		LLUUID uuid(LLUI::sConfigGroup->getString(name));		
+		if (uuid.isNull())
+		{
+			if ("00000000-0000-0000-0000-000000000000" == LLUI::sConfigGroup->getString(name))
+			{
+				if (LLUI::sConfigGroup->getBOOL("UISndDebugSpamToggle"))
+				{
+					llinfos << "ui sound name: " << name << " triggered but silent (null uuid)" << llendl;	
+				}				
+			}
+			else
+			{
+				llwarns << "ui sound named: " << name << " does not translate to a valid uuid" << llendl;	
+			}
+
+		}
+		else if (LLUI::sAudioCallback != NULL)
+		{
+			if (LLUI::sConfigGroup->getBOOL("UISndDebugSpamToggle"))
+			{
+				llinfos << "ui sound name: " << name << llendl;	
+			}
+			LLUI::sAudioCallback(uuid, LLUI::sConfigGroup->getF32("AudioLevelUI"));
+		}
+	}
+}
+
+BOOL ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom)
+{
+	if (x < left || right < x) return FALSE;
+	if (y < bottom || top < y) return FALSE;
+	return TRUE;
+}
+
+
+// Puts GL into 2D drawing mode by turning off lighting, setting to an
+// orthographic projection, etc.
+void gl_state_for_2d(S32 width, S32 height)
+{
+	stop_glerror();
+	F32 window_width = (F32) width;//gViewerWindow->getWindowWidth();
+	F32 window_height = (F32) height;//gViewerWindow->getWindowHeight();
+
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	glOrtho(0.0f, window_width, 0.0f, window_height, -1.0f, 1.0f);
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+	stop_glerror();
+}
+
+
+void gl_draw_x(const LLRect& rect, const LLColor4& color)
+{
+	LLGLSNoTexture no_texture;
+
+	glColor4fv( color.mV );
+
+	glBegin( GL_LINES );
+		glVertex2i( rect.mLeft,		rect.mTop );
+		glVertex2i( rect.mRight,	rect.mBottom );
+		glVertex2i( rect.mLeft,		rect.mBottom );
+		glVertex2i( rect.mRight,	rect.mTop );
+	glEnd();
+}
+
+
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset, BOOL filled)
+{
+	glColor4fv(color.mV);
+	gl_rect_2d_offset_local(left, top, right, bottom, pixel_offset, filled);
+}
+
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset, BOOL filled)
+{
+	glPushMatrix();
+	left += LLFontGL::sCurOrigin.mX;
+	right += LLFontGL::sCurOrigin.mX;
+	bottom += LLFontGL::sCurOrigin.mY;
+	top += LLFontGL::sCurOrigin.mY;
+
+	glLoadIdentity();
+	gl_rect_2d(llfloor((F32)left * LLUI::sGLScaleFactor.mV[VX]) - pixel_offset,
+				llfloor((F32)top * LLUI::sGLScaleFactor.mV[VY]) + pixel_offset,
+				llfloor((F32)right * LLUI::sGLScaleFactor.mV[VX]) + pixel_offset,
+				llfloor((F32)bottom * LLUI::sGLScaleFactor.mV[VY]) - pixel_offset,
+				filled);
+	glPopMatrix();
+}
+
+
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled )
+{
+	stop_glerror();
+	LLGLSNoTexture no_texture;
+
+	// Counterclockwise quad will face the viewer
+	if( filled )
+	{
+		glBegin( GL_QUADS );
+			glVertex2i(left, top);
+			glVertex2i(left, bottom);
+			glVertex2i(right, bottom);
+			glVertex2i(right, top);
+		glEnd();
+	}
+	else
+	{
+		if( gGLManager.mATIOffsetVerticalLines )
+		{
+			// Work around bug in ATI driver: vertical lines are offset by (-1,-1)
+			glBegin( GL_LINES );
+
+				// Verticals 
+				glVertex2i(left + 1, top);
+				glVertex2i(left + 1, bottom);
+
+				glVertex2i(right, bottom);
+				glVertex2i(right, top);
+
+				// Horizontals
+				top--;
+				right--;
+				glVertex2i(left, bottom);
+				glVertex2i(right, bottom);
+
+				glVertex2i(left, top);
+				glVertex2i(right, top);
+			glEnd();
+		}
+		else
+		{
+			top--;
+			right--;
+			glBegin( GL_LINE_STRIP );
+				glVertex2i(left, top);
+				glVertex2i(left, bottom);
+				glVertex2i(right, bottom);
+				glVertex2i(right, top);
+				glVertex2i(left, top);
+			glEnd();
+		}
+	}
+	stop_glerror();
+}
+
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, BOOL filled )
+{
+	glColor4fv( color.mV );
+	gl_rect_2d( left, top, right, bottom, filled );
+}
+
+
+void gl_rect_2d( const LLRect& rect, const LLColor4& color, BOOL filled )
+{
+	glColor4fv( color.mV );
+	gl_rect_2d( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, filled );
+}
+
+// Given a rectangle on the screen, draws a drop shadow _outside_
+// the right and bottom edges of it.  Along the right it has width "lines"
+// and along the bottom it has height "lines".
+void gl_drop_shadow(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &start_color, S32 lines)
+{
+	stop_glerror();
+	LLGLSNoTexture no_texture;
+	
+	// HACK: Overlap with the rectangle by a single pixel.
+	right--;
+	bottom++;
+	lines++;
+
+	LLColor4 end_color = start_color;
+	end_color.mV[VALPHA] = 0.f;
+
+	glBegin(GL_QUADS);
+
+	// Right edge, CCW faces screen
+	glColor4fv(start_color.mV);
+	glVertex2i(right,		top-lines);
+	glVertex2i(right,		bottom);
+	glColor4fv(end_color.mV);
+	glVertex2i(right+lines, bottom);
+	glVertex2i(right+lines, top-lines);
+
+	// Bottom edge, CCW faces screen
+	glColor4fv(start_color.mV);
+	glVertex2i(right,		bottom);
+	glVertex2i(left+lines,	bottom);
+	glColor4fv(end_color.mV);
+	glVertex2i(left+lines,	bottom-lines);
+	glVertex2i(right,		bottom-lines);
+
+	// bottom left Corner
+	glColor4fv(start_color.mV);
+	glVertex2i(left+lines,	bottom);
+	glColor4fv(end_color.mV);
+	glVertex2i(left,		bottom);
+	// make the bottom left corner not sharp
+	glVertex2i(left+1,		bottom-lines+1);
+	glVertex2i(left+lines,	bottom-lines);
+
+	// bottom right corner
+	glColor4fv(start_color.mV);
+	glVertex2i(right,		bottom);
+	glColor4fv(end_color.mV);
+	glVertex2i(right,		bottom-lines);
+	// make the rightmost corner not sharp
+	glVertex2i(right+lines-1,	bottom-lines+1);
+	glVertex2i(right+lines,	bottom);
+
+	// top right corner
+	glColor4fv(start_color.mV);
+	glVertex2i( right,			top-lines );
+	glColor4fv(end_color.mV);
+	glVertex2i( right+lines,	top-lines );
+	// make the corner not sharp
+	glVertex2i( right+lines-1,	top-1 );
+	glVertex2i( right,			top );
+
+	glEnd();
+	stop_glerror();
+}
+
+void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2 )
+{
+	// Work around bug in ATI driver: vertical lines are offset by (-1,-1)
+	if( gGLManager.mATIOffsetVerticalLines && (x1 == x2) )
+	{
+		x1++;
+		x2++;
+		y1++;
+		y2++;
+	}
+
+	LLGLSNoTexture no_texture;
+	
+	glBegin(GL_LINES);
+		glVertex2i(x1, y1);
+		glVertex2i(x2, y2);
+	glEnd();
+}
+
+void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2, const LLColor4 &color )
+{
+	// Work around bug in ATI driver: vertical lines are offset by (-1,-1)
+	if( gGLManager.mATIOffsetVerticalLines && (x1 == x2) )
+	{
+		x1++;
+		x2++;
+		y1++;
+		y2++;
+	}
+
+	LLGLSNoTexture no_texture;
+
+	glColor4fv( color.mV );
+
+	glBegin(GL_LINES);
+		glVertex2i(x1, y1);
+		glVertex2i(x2, y2);
+	glEnd();
+}
+
+void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, BOOL filled)
+{
+	LLGLSNoTexture no_texture;
+
+	glColor4fv(color.mV);
+
+	if (filled)
+	{
+		glBegin(GL_TRIANGLES);
+	}
+	else
+	{
+		glBegin(GL_LINE_LOOP);
+	}
+	glVertex2i(x1, y1);
+	glVertex2i(x2, y2);
+	glVertex2i(x3, y3);
+	glEnd();
+}
+
+void gl_corners_2d(S32 left, S32 top, S32 right, S32 bottom, S32 length, F32 max_frac)
+{
+	LLGLSNoTexture no_texture;
+
+	length = llmin((S32)(max_frac*(right - left)), length);
+	length = llmin((S32)(max_frac*(top - bottom)), length);
+	glBegin(GL_LINES);
+	glVertex2i(left, top);
+	glVertex2i(left + length, top);
+	
+	glVertex2i(left, top);
+	glVertex2i(left, top - length);
+
+	glVertex2i(left, bottom);
+	glVertex2i(left + length, bottom);
+	
+	glVertex2i(left, bottom);
+	glVertex2i(left, bottom + length);
+
+	glVertex2i(right, top);
+	glVertex2i(right - length, top);
+
+	glVertex2i(right, top);
+	glVertex2i(right, top - length);
+
+	glVertex2i(right, bottom);
+	glVertex2i(right - length, bottom);
+
+	glVertex2i(right, bottom);
+	glVertex2i(right, bottom + length);
+	glEnd();
+}
+
+
+void gl_draw_image( S32 x, S32 y, LLImageGL* image, const LLColor4& color )
+{
+	gl_draw_scaled_rotated_image( x, y, image->getWidth(), image->getHeight(), 0.f, image, color );
+}
+
+void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLImageGL* image, const LLColor4& color)
+{
+	gl_draw_scaled_rotated_image( x, y, width, height, 0.f, image, color );
+}
+
+void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLImageGL* image, const LLColor4& color, BOOL solid_color)
+{
+	stop_glerror();
+	F32 border_scale = 1.f;
+
+	if (border_height * 2 > height)
+	{
+		border_scale = (F32)height / ((F32)border_height * 2.f);
+	}
+	if (border_width * 2 > width)
+	{
+		border_scale = llmin(border_scale, (F32)width / ((F32)border_width * 2.f));
+	}
+
+	// scale screen size of borders down
+	S32 scaled_border_width = llfloor(border_scale * (F32)border_width);
+	S32 scaled_border_height = llfloor(border_scale * (F32)border_height);
+
+	LLGLSUIDefault gls_ui;
+	
+	if (solid_color)
+	{
+		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,		GL_COMBINE_ARB);
+		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB,		GL_REPLACE);
+		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB,		GL_MODULATE);
+
+		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB,		GL_PREVIOUS);
+		glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB,		GL_SRC_COLOR);
+
+		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB,		GL_TEXTURE);
+		glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB,	GL_SRC_ALPHA);
+
+		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB,		GL_PRIMARY_COLOR_ARB);
+		glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB,	GL_SRC_ALPHA);
+	}
+
+	glPushMatrix();
+	{
+		glTranslatef((F32)x, (F32)y, 0.f);
+
+		image->bind();
+
+		glColor4fv(color.mV);
+		
+		F32 border_width_fraction = (F32)border_width / (F32)image->getWidth();
+		F32 border_height_fraction = (F32)border_height / (F32)image->getHeight();
+
+		glBegin(GL_QUADS);
+		{
+			// draw bottom left
+			glTexCoord2f(0.f, 0.f);
+			glVertex2i(0, 0);
+
+			glTexCoord2f(border_width_fraction, 0.f);
+			glVertex2i(scaled_border_width, 0);
+
+			glTexCoord2f(border_width_fraction, border_height_fraction);
+			glVertex2i(scaled_border_width, scaled_border_height);
+
+			glTexCoord2f(0.f, border_height_fraction);
+			glVertex2i(0, scaled_border_height);
+
+			// draw bottom middle
+			glTexCoord2f(border_width_fraction, 0.f);
+			glVertex2i(scaled_border_width, 0);
+
+			glTexCoord2f(1.f - border_width_fraction, 0.f);
+			glVertex2i(width - scaled_border_width, 0);
+
+			glTexCoord2f(1.f - border_width_fraction, border_height_fraction);
+			glVertex2i(width - scaled_border_width, scaled_border_height);
+
+			glTexCoord2f(border_width_fraction, border_height_fraction);
+			glVertex2i(scaled_border_width, scaled_border_height);
+
+			// draw bottom right
+			glTexCoord2f(1.f - border_width_fraction, 0.f);
+			glVertex2i(width - scaled_border_width, 0);
+
+			glTexCoord2f(1.f, 0.f);
+			glVertex2i(width, 0);
+
+			glTexCoord2f(1.f, border_height_fraction);
+			glVertex2i(width, scaled_border_height);
+
+			glTexCoord2f(1.f - border_width_fraction, border_height_fraction);
+			glVertex2i(width - scaled_border_width, scaled_border_height);
+
+			// draw left 
+			glTexCoord2f(0.f, border_height_fraction);
+			glVertex2i(0, scaled_border_height);
+
+			glTexCoord2f(border_width_fraction, border_height_fraction);
+			glVertex2i(scaled_border_width, scaled_border_height);
+
+			glTexCoord2f(border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(scaled_border_width, height - scaled_border_height);
+
+			glTexCoord2f(0.f, 1.f - border_height_fraction);
+			glVertex2i(0, height - scaled_border_height);
+
+			// draw middle
+			glTexCoord2f(border_width_fraction, border_height_fraction);
+			glVertex2i(scaled_border_width, scaled_border_height);
+
+			glTexCoord2f(1.f - border_width_fraction, border_height_fraction);
+			glVertex2i(width - scaled_border_width, scaled_border_height);
+
+			glTexCoord2f(1.f - border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(width - scaled_border_width, height - scaled_border_height);
+
+			glTexCoord2f(border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(scaled_border_width, height - scaled_border_height);
+
+			// draw right 
+			glTexCoord2f(1.f - border_width_fraction, border_height_fraction);
+			glVertex2i(width - scaled_border_width, scaled_border_height);
+
+			glTexCoord2f(1.f, border_height_fraction);
+			glVertex2i(width, scaled_border_height);
+
+			glTexCoord2f(1.f, 1.f - border_height_fraction);
+			glVertex2i(width, height - scaled_border_height);
+
+			glTexCoord2f(1.f - border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(width - scaled_border_width, height - scaled_border_height);
+
+			// draw top left
+			glTexCoord2f(0.f, 1.f - border_height_fraction);
+			glVertex2i(0, height - scaled_border_height);
+
+			glTexCoord2f(border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(scaled_border_width, height - scaled_border_height);
+
+			glTexCoord2f(border_width_fraction, 1.f);
+			glVertex2i(scaled_border_width, height);
+
+			glTexCoord2f(0.f, 1.f);
+			glVertex2i(0, height);
+
+			// draw top middle
+			glTexCoord2f(border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(scaled_border_width, height - scaled_border_height);
+
+			glTexCoord2f(1.f - border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(width - scaled_border_width, height - scaled_border_height);
+
+			glTexCoord2f(1.f - border_width_fraction, 1.f);
+			glVertex2i(width - scaled_border_width, height);
+
+			glTexCoord2f(border_width_fraction, 1.f);
+			glVertex2i(scaled_border_width, height);
+
+			// draw top right
+			glTexCoord2f(1.f - border_width_fraction, 1.f - border_height_fraction);
+			glVertex2i(width - scaled_border_width, height - scaled_border_height);
+
+			glTexCoord2f(1.f, 1.f - border_height_fraction);
+			glVertex2i(width, height - scaled_border_height);
+
+			glTexCoord2f(1.f, 1.f);
+			glVertex2i(width, height);
+
+			glTexCoord2f(1.f - border_width_fraction, 1.f);
+			glVertex2i(width - scaled_border_width, height);
+		}
+		glEnd();
+	}
+	glPopMatrix();
+
+	if (solid_color)
+	{
+		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+	}
+}
+
+void gl_draw_rotated_image(S32 x, S32 y, F32 degrees, LLImageGL* image, const LLColor4& color)
+{
+	gl_draw_scaled_rotated_image( x, y, image->getWidth(), image->getHeight(), degrees, image, color );
+}
+
+void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degrees, LLImageGL* image, const LLColor4& color)
+{
+	LLGLSUIDefault gls_ui;
+
+	glPushMatrix();
+	{
+		glTranslatef((F32)x, (F32)y, 0.f);
+		if( degrees )
+		{
+			F32 offset_x = F32(width/2);
+			F32 offset_y = F32(height/2);
+			glTranslatef( offset_x, offset_y, 0.f);
+			glRotatef( degrees, 0.f, 0.f, 1.f );
+			glTranslatef( -offset_x, -offset_y, 0.f );
+		}
+
+		image->bind();
+
+		glColor4fv(color.mV);
+		
+		glBegin(GL_QUADS);
+		{
+			glTexCoord2f(1.f, 1.f);
+			glVertex2i(width, height );
+
+			glTexCoord2f(0.f, 1.f);
+			glVertex2i(0, height );
+
+			glTexCoord2f(0.f, 0.f);
+			glVertex2i(0, 0);
+
+			glTexCoord2f(1.f, 0.f);
+			glVertex2i(width, 0);
+		}
+		glEnd();
+	}
+	glPopMatrix();
+}
+
+
+void gl_draw_scaled_image_inverted(S32 x, S32 y, S32 width, S32 height, LLImageGL* image, const LLColor4& color)
+{
+	LLGLSUIDefault gls_ui;
+
+	glPushMatrix();
+	{
+		glTranslatef((F32)x, (F32)y, 0.f);
+
+		image->bind();
+
+		glColor4fv(color.mV);
+		
+		glBegin(GL_QUADS);
+		{
+			glTexCoord2f(1.f, 0.f);
+			glVertex2i(width, height );
+
+			glTexCoord2f(0.f, 0.f);
+			glVertex2i(0, height );
+
+			glTexCoord2f(0.f, 1.f);
+			glVertex2i(0, 0);
+
+			glTexCoord2f(1.f, 1.f);
+			glVertex2i(width, 0);
+		}
+		glEnd();
+	}
+	glPopMatrix();
+}
+
+
+void gl_stippled_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& color, F32 phase )
+{
+	phase = fmod(phase, 1.f);
+
+	S32 shift = S32(phase * 4.f) % 4;
+
+	// Stippled line
+	LLGLEnable stipple(GL_LINE_STIPPLE);
+	
+	glColor4f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], color.mV[VALPHA]);
+	glLineWidth(2.5f);
+	glLineStipple(2, 0x3333 << shift);
+
+	glBegin(GL_LINES);
+	{
+		glVertex3fv( start.mV );
+		glVertex3fv( end.mV );
+	}
+	glEnd();
+
+	LLUI::setLineWidth(1.f);
+}
+
+
+void gl_rect_2d_xor(S32 left, S32 top, S32 right, S32 bottom)
+{
+	glColor4fv( LLColor4::white.mV );
+	glLogicOp( GL_XOR );
+	stop_glerror();
+
+	glBegin(GL_QUADS);
+		glVertex2i(left, top);
+		glVertex2i(left, bottom);
+		glVertex2i(right, bottom);
+		glVertex2i(right, top);
+	glEnd();
+
+	glLogicOp( GL_COPY );
+	stop_glerror();
+}
+
+
+void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle)
+{
+	if (end_angle < start_angle)
+	{
+		end_angle += F_TWO_PI;
+	}
+
+	glPushMatrix();
+	{
+		glTranslatef(center_x, center_y, 0.f);
+
+		// Inexact, but reasonably fast.
+		F32 delta = (end_angle - start_angle) / steps;
+		F32 sin_delta = sin( delta );
+		F32 cos_delta = cos( delta );
+		F32 x = cosf(start_angle) * radius;
+		F32 y = sinf(start_angle) * radius;
+
+		if (filled)
+		{
+			glBegin(GL_TRIANGLE_FAN);
+			glVertex2f(0.f, 0.f);
+			// make sure circle is complete
+			steps += 1;
+		}
+		else
+		{
+			glBegin(GL_LINE_STRIP);
+		}
+
+		while( steps-- )
+		{
+			// Successive rotations
+			glVertex2f( x, y );
+			F32 x_new = x * cos_delta - y * sin_delta;
+			y = x * sin_delta +  y * cos_delta;
+			x = x_new;
+		}
+		glEnd();
+	}
+	glPopMatrix();
+}
+
+void gl_circle_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled)
+{
+	glPushMatrix();
+	{
+		LLGLSNoTexture gls_no_texture;
+		glTranslatef(center_x, center_y, 0.f);
+
+		// Inexact, but reasonably fast.
+		F32 delta = F_TWO_PI / steps;
+		F32 sin_delta = sin( delta );
+		F32 cos_delta = cos( delta );
+		F32 x = radius;
+		F32 y = 0.f;
+
+		if (filled)
+		{
+			glBegin(GL_TRIANGLE_FAN);
+			glVertex2f(0.f, 0.f);
+			// make sure circle is complete
+			steps += 1;
+		}
+		else
+		{
+			glBegin(GL_LINE_LOOP);
+		}
+
+		while( steps-- )
+		{
+			// Successive rotations
+			glVertex2f( x, y );
+			F32 x_new = x * cos_delta - y * sin_delta;
+			y = x * sin_delta +  y * cos_delta;
+			x = x_new;
+		}
+		glEnd();
+	}
+	glPopMatrix();
+}
+
+// Renders a ring with sides (tube shape)
+void gl_deep_circle( F32 radius, F32 depth, S32 steps )
+{
+	F32 x = radius;
+	F32 y = 0.f;
+	F32 angle_delta = F_TWO_PI / (F32)steps;
+	glBegin( GL_TRIANGLE_STRIP  );
+	{
+		S32 step = steps + 1; // An extra step to close the circle.
+		while( step-- )
+		{
+			glVertex3f( x, y, depth );
+			glVertex3f( x, y, 0.f );
+
+			F32 x_new = x * cosf(angle_delta) - y * sinf(angle_delta);
+			y = x * sinf(angle_delta) +  y * cosf(angle_delta);
+			x = x_new;
+		}
+	}
+	glEnd();
+}
+
+void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, BOOL render_center )
+{
+	glPushMatrix();
+	{
+		glTranslatef(0.f, 0.f, -width / 2);
+		if( render_center )
+		{
+			glColor4fv(center_color.mV);
+			gl_deep_circle( radius, width, steps );
+		}
+		else
+		{
+			gl_washer_2d(radius, radius - width, steps, side_color, side_color);
+			glTranslatef(0.f, 0.f, width);
+			gl_washer_2d(radius - width, radius, steps, side_color, side_color);
+		}
+	}
+	glPopMatrix();
+}
+
+// Draw gray and white checkerboard with black border
+void gl_rect_2d_checkerboard(const LLRect& rect)
+{
+	// Initialize the first time this is called.
+	const S32 PIXELS = 32;
+	static GLubyte checkerboard[PIXELS * PIXELS];
+	static BOOL first = TRUE;
+	if( first )
+	{
+		for( S32 i = 0; i < PIXELS; i++ )
+		{
+			for( S32 j = 0; j < PIXELS; j++ )
+			{
+				checkerboard[i * PIXELS + j] = ((i & 1) ^ (j & 1)) * 0xFF;
+			}
+		}
+		first = FALSE;
+	}
+	
+	LLGLSNoTexture gls_no_texture;
+
+	// ...white squares
+	glColor3f( 1.f, 1.f, 1.f );
+	gl_rect_2d(rect);
+
+	// ...gray squares
+	glColor3f( .7f, .7f, .7f );
+	glPolygonStipple( checkerboard );
+
+	LLGLEnable polygon_stipple(GL_POLYGON_STIPPLE);
+	gl_rect_2d(rect);
+}
+
+
+// Draws the area between two concentric circles, like
+// a doughnut or washer.
+void gl_washer_2d(F32 outer_radius, F32 inner_radius, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color)
+{
+	const F32 DELTA = F_TWO_PI / steps;
+	const F32 SIN_DELTA = sin( DELTA );
+	const F32 COS_DELTA = cos( DELTA );
+
+	F32 x1 = outer_radius;
+	F32 y1 = 0.f;
+	F32 x2 = inner_radius;
+	F32 y2 = 0.f;
+
+	LLGLSNoTexture gls_no_texture;
+
+	glBegin( GL_TRIANGLE_STRIP  );
+	{
+		steps += 1; // An extra step to close the circle.
+		while( steps-- )
+		{
+			glColor4fv(outer_color.mV);
+			glVertex2f( x1, y1 );
+			glColor4fv(inner_color.mV);
+			glVertex2f( x2, y2 );
+
+			F32 x1_new = x1 * COS_DELTA - y1 * SIN_DELTA;
+			y1 = x1 * SIN_DELTA +  y1 * COS_DELTA;
+			x1 = x1_new;
+
+			F32 x2_new = x2 * COS_DELTA - y2 * SIN_DELTA;
+			y2 = x2 * SIN_DELTA +  y2 * COS_DELTA;
+			x2 = x2_new;
+		}
+	}
+	glEnd();
+}
+
+// Draws the area between two concentric circles, like
+// a doughnut or washer.
+void gl_washer_segment_2d(F32 outer_radius, F32 inner_radius, F32 start_radians, F32 end_radians, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color)
+{
+	const F32 DELTA = (end_radians - start_radians) / steps;
+	const F32 SIN_DELTA = sin( DELTA );
+	const F32 COS_DELTA = cos( DELTA );
+
+	F32 x1 = outer_radius * cos( start_radians );
+	F32 y1 = outer_radius * sin( start_radians );
+	F32 x2 = inner_radius * cos( start_radians );
+	F32 y2 = inner_radius * sin( start_radians );
+
+	LLGLSNoTexture gls_no_texture;
+	glBegin( GL_TRIANGLE_STRIP  );
+	{
+		steps += 1; // An extra step to close the circle.
+		while( steps-- )
+		{
+			glColor4fv(outer_color.mV);
+			glVertex2f( x1, y1 );
+			glColor4fv(inner_color.mV);
+			glVertex2f( x2, y2 );
+
+			F32 x1_new = x1 * COS_DELTA - y1 * SIN_DELTA;
+			y1 = x1 * SIN_DELTA +  y1 * COS_DELTA;
+			x1 = x1_new;
+
+			F32 x2_new = x2 * COS_DELTA - y2 * SIN_DELTA;
+			y2 = x2 * SIN_DELTA +  y2 * COS_DELTA;
+			x2 = x2_new;
+		}
+	}
+	glEnd();
+}
+
+// Draws spokes around a circle.
+void gl_washer_spokes_2d(F32 outer_radius, F32 inner_radius, S32 count, const LLColor4& inner_color, const LLColor4& outer_color)
+{
+	const F32 DELTA = F_TWO_PI / count;
+	const F32 HALF_DELTA = DELTA * 0.5f;
+	const F32 SIN_DELTA = sin( DELTA );
+	const F32 COS_DELTA = cos( DELTA );
+
+	F32 x1 = outer_radius * cos( HALF_DELTA );
+	F32 y1 = outer_radius * sin( HALF_DELTA );
+	F32 x2 = inner_radius * cos( HALF_DELTA );
+	F32 y2 = inner_radius * sin( HALF_DELTA );
+
+	LLGLSNoTexture gls_no_texture;
+
+	glBegin( GL_LINES  );
+	{
+		while( count-- )
+		{
+			glColor4fv(outer_color.mV);
+			glVertex2f( x1, y1 );
+			glColor4fv(inner_color.mV);
+			glVertex2f( x2, y2 );
+
+			F32 x1_new = x1 * COS_DELTA - y1 * SIN_DELTA;
+			y1 = x1 * SIN_DELTA +  y1 * COS_DELTA;
+			x1 = x1_new;
+
+			F32 x2_new = x2 * COS_DELTA - y2 * SIN_DELTA;
+			y2 = x2 * SIN_DELTA +  y2 * COS_DELTA;
+			x2 = x2_new;
+		}
+	}
+	glEnd();
+}
+
+void gl_rect_2d_simple_tex( S32 width, S32 height )
+{
+	glBegin( GL_QUADS );
+
+		glTexCoord2f(1.f, 1.f);
+		glVertex2i(width, height);
+
+		glTexCoord2f(0.f, 1.f);
+		glVertex2i(0, height);
+
+		glTexCoord2f(0.f, 0.f);
+		glVertex2i(0, 0);
+
+		glTexCoord2f(1.f, 0.f);
+		glVertex2i(width, 0);
+	
+	glEnd();
+}
+
+void gl_rect_2d_simple( S32 width, S32 height )
+{
+	glBegin( GL_QUADS );
+		glVertex2i(width, height);
+		glVertex2i(0, height);
+		glVertex2i(0, 0);
+		glVertex2i(width, 0);
+	glEnd();
+}
+
+void gl_segmented_rect_2d_tex(const S32 left, 
+							  const S32 top, 
+							  const S32 right, 
+							  const S32 bottom, 
+							  const S32 texture_width, 
+							  const S32 texture_height, 
+							  const S32 border_size, 
+							  const U32 edges)
+{
+	S32 width = llabs(right - left);
+	S32 height = llabs(top - bottom);
+
+	glPushMatrix();
+
+	glTranslatef((F32)left, (F32)bottom, 0.f);
+	LLVector2 border_uv_scale((F32)border_size / (F32)texture_width, (F32)border_size / (F32)texture_height);
+
+	if (border_uv_scale.mV[VX] > 0.5f)
+	{
+		border_uv_scale *= 0.5f / border_uv_scale.mV[VX];
+	}
+	if (border_uv_scale.mV[VY] > 0.5f)
+	{
+		border_uv_scale *= 0.5f / border_uv_scale.mV[VY];
+	}
+
+	F32 border_scale = llmin((F32)border_size, (F32)width * 0.5f, (F32)height * 0.5f);
+	LLVector2 border_width_left = ((edges & (~(U32)ROUNDED_RECT_RIGHT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
+	LLVector2 border_width_right = ((edges & (~(U32)ROUNDED_RECT_LEFT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
+	LLVector2 border_height_bottom = ((edges & (~(U32)ROUNDED_RECT_TOP)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
+	LLVector2 border_height_top = ((edges & (~(U32)ROUNDED_RECT_BOTTOM)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
+	LLVector2 width_vec((F32)width, 0.f);
+	LLVector2 height_vec(0.f, (F32)height);
+
+	glBegin(GL_QUADS);
+	{
+		// draw bottom left
+		glTexCoord2f(0.f, 0.f);
+		glVertex2f(0.f, 0.f);
+
+		glTexCoord2f(border_uv_scale.mV[VX], 0.f);
+		glVertex2fv(border_width_left.mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + border_height_bottom).mV);
+
+		glTexCoord2f(0.f, border_uv_scale.mV[VY]);
+		glVertex2fv(border_height_bottom.mV);
+
+		// draw bottom middle
+		glTexCoord2f(border_uv_scale.mV[VX], 0.f);
+		glVertex2fv(border_width_left.mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 0.f);
+		glVertex2fv((width_vec - border_width_right).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + border_height_bottom).mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + border_height_bottom).mV);
+
+		// draw bottom right
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 0.f);
+		glVertex2fv((width_vec - border_width_right).mV);
+
+		glTexCoord2f(1.f, 0.f);
+		glVertex2fv(width_vec.mV);
+
+		glTexCoord2f(1.f, border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec + border_height_bottom).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + border_height_bottom).mV);
+
+		// draw left 
+		glTexCoord2f(0.f, border_uv_scale.mV[VY]);
+		glVertex2fv(border_height_bottom.mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + border_height_bottom).mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + height_vec - border_height_top).mV);
+
+		glTexCoord2f(0.f, 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((height_vec - border_height_top).mV);
+
+		// draw middle
+		glTexCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + border_height_bottom).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + border_height_bottom).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + height_vec - border_height_top).mV);
+
+		// draw right 
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + border_height_bottom).mV);
+
+		glTexCoord2f(1.f, border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec + border_height_bottom).mV);
+
+		glTexCoord2f(1.f, 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec + height_vec - border_height_top).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
+
+		// draw top left
+		glTexCoord2f(0.f, 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((height_vec - border_height_top).mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + height_vec - border_height_top).mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], 1.f);
+		glVertex2fv((border_width_left + height_vec).mV);
+
+		glTexCoord2f(0.f, 1.f);
+		glVertex2fv((height_vec).mV);
+
+		// draw top middle
+		glTexCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((border_width_left + height_vec - border_height_top).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
+		glVertex2fv((width_vec - border_width_right + height_vec).mV);
+
+		glTexCoord2f(border_uv_scale.mV[VX], 1.f);
+		glVertex2fv((border_width_left + height_vec).mV);
+
+		// draw top right
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
+
+		glTexCoord2f(1.f, 1.f - border_uv_scale.mV[VY]);
+		glVertex2fv((width_vec + height_vec - border_height_top).mV);
+
+		glTexCoord2f(1.f, 1.f);
+		glVertex2fv((width_vec + height_vec).mV);
+
+		glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
+		glVertex2fv((width_vec - border_width_right + height_vec).mV);
+	}
+	glEnd();
+
+	glPopMatrix();
+}
+
+void gl_segmented_rect_2d_fragment_tex(const S32 left, 
+									   const S32 top, 
+									   const S32 right, 
+									   const S32 bottom, 
+									   const S32 texture_width, 
+									   const S32 texture_height, 
+									   const S32 border_size, 
+									   const F32 start_fragment, 
+									   const F32 end_fragment, 
+									   const U32 edges)
+{
+	S32 width = llabs(right - left);
+	S32 height = llabs(top - bottom);
+
+	glPushMatrix();
+
+	glTranslatef((F32)left, (F32)bottom, 0.f);
+	LLVector2 border_uv_scale((F32)border_size / (F32)texture_width, (F32)border_size / (F32)texture_height);
+
+	if (border_uv_scale.mV[VX] > 0.5f)
+	{
+		border_uv_scale *= 0.5f / border_uv_scale.mV[VX];
+	}
+	if (border_uv_scale.mV[VY] > 0.5f)
+	{
+		border_uv_scale *= 0.5f / border_uv_scale.mV[VY];
+	}
+
+	F32 border_scale = llmin((F32)border_size, (F32)width * 0.5f, (F32)height * 0.5f);
+	LLVector2 border_width_left = ((edges & (~(U32)ROUNDED_RECT_RIGHT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
+	LLVector2 border_width_right = ((edges & (~(U32)ROUNDED_RECT_LEFT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
+	LLVector2 border_height_bottom = ((edges & (~(U32)ROUNDED_RECT_TOP)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
+	LLVector2 border_height_top = ((edges & (~(U32)ROUNDED_RECT_BOTTOM)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
+	LLVector2 width_vec((F32)width, 0.f);
+	LLVector2 height_vec(0.f, (F32)height);
+
+	F32 middle_start = border_scale / (F32)width;
+	F32 middle_end = 1.f - middle_start;
+
+	F32 u_min;
+	F32 u_max;
+	LLVector2 x_min;
+	LLVector2 x_max;
+
+	glBegin(GL_QUADS);
+	{
+		if (start_fragment < middle_start)
+		{
+			u_min = (start_fragment / middle_start) * border_uv_scale.mV[VX];
+			u_max = llmin(end_fragment / middle_start, 1.f) * border_uv_scale.mV[VX];
+			x_min = (start_fragment / middle_start) * border_width_left;
+			x_max = llmin(end_fragment / middle_start, 1.f) * border_width_left;
+
+			// draw bottom left
+			glTexCoord2f(u_min, 0.f);
+			glVertex2fv(x_min.mV);
+
+			glTexCoord2f(border_uv_scale.mV[VX], 0.f);
+			glVertex2fv(x_max.mV);
+
+			glTexCoord2f(u_max, border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + border_height_bottom).mV);
+
+			glTexCoord2f(u_min, border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + border_height_bottom).mV);
+
+			// draw left 
+			glTexCoord2f(u_min, border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + border_height_bottom).mV);
+
+			glTexCoord2f(u_max, border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + border_height_bottom).mV);
+
+			glTexCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + height_vec - border_height_top).mV);
+
+			glTexCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + height_vec - border_height_top).mV);
+			
+			// draw top left
+			glTexCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + height_vec - border_height_top).mV);
+
+			glTexCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + height_vec - border_height_top).mV);
+
+			glTexCoord2f(u_max, 1.f);
+			glVertex2fv((x_max + height_vec).mV);
+
+			glTexCoord2f(u_min, 1.f);
+			glVertex2fv((x_min + height_vec).mV);
+		}
+
+		if (end_fragment > middle_start || start_fragment < middle_end)
+		{
+			x_min = border_width_left + ((llclamp(start_fragment, middle_start, middle_end) - middle_start)) * width_vec;
+			x_max = border_width_left + ((llclamp(end_fragment, middle_start, middle_end) - middle_start)) * width_vec;
+
+			// draw bottom middle
+			glTexCoord2f(border_uv_scale.mV[VX], 0.f);
+			glVertex2fv(x_min.mV);
+
+			glTexCoord2f(1.f - border_uv_scale.mV[VX], 0.f);
+			glVertex2fv((x_max).mV);
+
+			glTexCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + border_height_bottom).mV);
+
+			glTexCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + border_height_bottom).mV);
+
+			// draw middle
+			glTexCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + border_height_bottom).mV);
+
+			glTexCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + border_height_bottom).mV);
+
+			glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + height_vec - border_height_top).mV);
+
+			glTexCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + height_vec - border_height_top).mV);
+
+			// draw top middle
+			glTexCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + height_vec - border_height_top).mV);
+
+			glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + height_vec - border_height_top).mV);
+
+			glTexCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
+			glVertex2fv((x_max + height_vec).mV);
+
+			glTexCoord2f(border_uv_scale.mV[VX], 1.f);
+			glVertex2fv((x_min + height_vec).mV);
+		}
+
+		if (end_fragment > middle_end)
+		{
+			u_min = (1.f - llmax(0.f, ((start_fragment - middle_end) / middle_start))) * border_uv_scale.mV[VX];
+			u_max = (1.f - ((end_fragment - middle_end) / middle_start)) * border_uv_scale.mV[VX];
+			x_min = width_vec - ((1.f - llmax(0.f, ((start_fragment - middle_end) / middle_start))) * border_width_right);
+			x_max = width_vec - ((1.f - ((end_fragment - middle_end) / middle_start)) * border_width_right);
+
+			// draw bottom right
+			glTexCoord2f(u_min, 0.f);
+			glVertex2fv((x_min).mV);
+
+			glTexCoord2f(u_max, 0.f);
+			glVertex2fv(x_max.mV);
+
+			glTexCoord2f(u_max, border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + border_height_bottom).mV);
+
+			glTexCoord2f(u_min, border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + border_height_bottom).mV);
+
+			// draw right 
+			glTexCoord2f(u_min, border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + border_height_bottom).mV);
+
+			glTexCoord2f(u_max, border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + border_height_bottom).mV);
+
+			glTexCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + height_vec - border_height_top).mV);
+
+			glTexCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + height_vec - border_height_top).mV);
+
+			// draw top right
+			glTexCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_min + height_vec - border_height_top).mV);
+
+			glTexCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
+			glVertex2fv((x_max + height_vec - border_height_top).mV);
+
+			glTexCoord2f(u_max, 1.f);
+			glVertex2fv((x_max + height_vec).mV);
+
+			glTexCoord2f(u_min, 1.f);
+			glVertex2fv((x_min + height_vec).mV);
+		}
+	}
+	glEnd();
+
+	glPopMatrix();
+}
+
+void gl_segmented_rect_3d_tex(const LLVector2& border_scale, const LLVector3& border_width, 
+							  const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec,
+							  const U32 edges)
+{
+	LLVector3 left_border_width = ((edges & (~(U32)ROUNDED_RECT_RIGHT)) != 0) ? border_width : LLVector3::zero;
+	LLVector3 right_border_width = ((edges & (~(U32)ROUNDED_RECT_LEFT)) != 0) ? border_width : LLVector3::zero;
+
+	LLVector3 top_border_height = ((edges & (~(U32)ROUNDED_RECT_BOTTOM)) != 0) ? border_height : LLVector3::zero;
+	LLVector3 bottom_border_height = ((edges & (~(U32)ROUNDED_RECT_TOP)) != 0) ? border_height : LLVector3::zero;
+
+	glBegin(GL_QUADS);
+	{
+		// draw bottom left
+		glTexCoord2f(0.f, 0.f);
+		glVertex3f(0.f, 0.f, 0.f);
+
+		glTexCoord2f(border_scale.mV[VX], 0.f);
+		glVertex3fv(left_border_width.mV);
+
+		glTexCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((left_border_width + bottom_border_height).mV);
+
+		glTexCoord2f(0.f, border_scale.mV[VY]);
+		glVertex3fv(bottom_border_height.mV);
+
+		// draw bottom middle
+		glTexCoord2f(border_scale.mV[VX], 0.f);
+		glVertex3fv(left_border_width.mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], 0.f);
+		glVertex3fv((width_vec - right_border_width).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + bottom_border_height).mV);
+
+		glTexCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((left_border_width + bottom_border_height).mV);
+
+		// draw bottom right
+		glTexCoord2f(1.f - border_scale.mV[VX], 0.f);
+		glVertex3fv((width_vec - right_border_width).mV);
+
+		glTexCoord2f(1.f, 0.f);
+		glVertex3fv(width_vec.mV);
+
+		glTexCoord2f(1.f, border_scale.mV[VY]);
+		glVertex3fv((width_vec + bottom_border_height).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + bottom_border_height).mV);
+
+		// draw left 
+		glTexCoord2f(0.f, border_scale.mV[VY]);
+		glVertex3fv(bottom_border_height.mV);
+
+		glTexCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((left_border_width + bottom_border_height).mV);
+
+		glTexCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((left_border_width + height_vec - top_border_height).mV);
+
+		glTexCoord2f(0.f, 1.f - border_scale.mV[VY]);
+		glVertex3fv((height_vec - top_border_height).mV);
+
+		// draw middle
+		glTexCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((left_border_width + bottom_border_height).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + bottom_border_height).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
+
+		glTexCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((left_border_width + height_vec - top_border_height).mV);
+
+		// draw right 
+		glTexCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + bottom_border_height).mV);
+
+		glTexCoord2f(1.f, border_scale.mV[VY]);
+		glVertex3fv((width_vec + bottom_border_height).mV);
+
+		glTexCoord2f(1.f, 1.f - border_scale.mV[VY]);
+		glVertex3fv((width_vec + height_vec - top_border_height).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
+
+		// draw top left
+		glTexCoord2f(0.f, 1.f - border_scale.mV[VY]);
+		glVertex3fv((height_vec - top_border_height).mV);
+
+		glTexCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((left_border_width + height_vec - top_border_height).mV);
+
+		glTexCoord2f(border_scale.mV[VX], 1.f);
+		glVertex3fv((left_border_width + height_vec).mV);
+
+		glTexCoord2f(0.f, 1.f);
+		glVertex3fv((height_vec).mV);
+
+		// draw top middle
+		glTexCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((left_border_width + height_vec - top_border_height).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], 1.f);
+		glVertex3fv((width_vec - right_border_width + height_vec).mV);
+
+		glTexCoord2f(border_scale.mV[VX], 1.f);
+		glVertex3fv((left_border_width + height_vec).mV);
+
+		// draw top right
+		glTexCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
+		glVertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
+
+		glTexCoord2f(1.f, 1.f - border_scale.mV[VY]);
+		glVertex3fv((width_vec + height_vec - top_border_height).mV);
+
+		glTexCoord2f(1.f, 1.f);
+		glVertex3fv((width_vec + height_vec).mV);
+
+		glTexCoord2f(1.f - border_scale.mV[VX], 1.f);
+		glVertex3fv((width_vec - right_border_width + height_vec).mV);
+	}
+	glEnd();
+}
+
+void gl_segmented_rect_3d_tex_top(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec)
+{
+	gl_segmented_rect_3d_tex(border_scale, border_width, border_height, width_vec, height_vec, ROUNDED_RECT_TOP);
+}
+
+#if 0 // No longer used
+void load_tr(const LLString& lang)
+{
+	LLString inname = "words." + lang + ".txt";
+	LLString filename = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, inname.c_str());
+
+	llifstream file;
+	file.open(filename.c_str(), std::ios_base::binary);
+	if (!file)
+	{
+		llinfos << "No translation dictionary for: " << filename << llendl;
+		return;
+	}
+
+	llinfos << "Reading language translation dictionary: " << filename << llendl;
+
+	gTranslation.clear();
+	gUntranslated.clear();
+
+	const S32 MAX_LINE_LEN = 1024;
+	char buffer[MAX_LINE_LEN];
+	while (!file.eof())
+	{
+		file.getline(buffer, MAX_LINE_LEN);
+		LLString line(buffer);
+		S32 commentpos = line.find("//");
+		if (commentpos != LLString::npos)
+		{
+			line = line.substr(0, commentpos);
+		}
+		S32 offset = line.find('\t');
+		if (offset != LLString::npos)
+		{
+			LLString english = line.substr(0,offset);
+			LLString translation = line.substr(offset+1);
+			//llinfos << "TR: " << english << " = " << translation << llendl;
+			gTranslation[english] = translation;
+		}
+	}
+
+	file.close();
+}
+
+void init_tr(const LLString& language)
+{
+	if (!language.empty())
+	{
+		gLanguage = language;
+	}
+	load_tr(gLanguage);
+}
+
+void cleanup_tr()
+{
+	// Dump untranslated phrases to help with translation
+	if (gUntranslated.size() > 0)
+	{
+		LLString outname = "untranslated_" + gLanguage + ".txt";
+		LLString outfilename = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, outname.c_str());
+		llofstream outfile;
+		outfile.open(outfilename.c_str());
+		if (!outfile)
+		{
+			return;
+		}
+		llinfos << "Writing untranslated words to: " << outfilename << llendl;
+		LLString outtext;
+		for (std::list<LLString>::iterator iter = gUntranslated.begin();
+			 iter != gUntranslated.end(); ++iter)
+		{
+			// output: english_phrase	english_phrase
+			outtext += *iter;
+			outtext += "\t";
+			outtext += *iter;
+			outtext += "\n";
+		}
+		outfile << outtext.c_str();
+		outfile.close();
+	}
+}
+
+LLString tr(const LLString& english_string)
+{
+	std::map<LLString, LLString>::iterator it = gTranslation.find(english_string);
+	if (it != gTranslation.end())
+	{
+		return it->second;
+	}
+	else
+	{
+		gUntranslated.push_back(english_string);
+		return english_string;
+	}
+}
+
+#endif
+
+
+class LLShowXUINamesListener: public LLSimpleListener
+{
+	bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+	{
+		LLUI::sShowXUINames = (BOOL) event->getValue().asBoolean();
+		return true;
+	}
+};
+static LLShowXUINamesListener show_xui_names_listener;
+
+
+void LLUI::initClass(LLControlGroup* config, 
+					 LLControlGroup* colors, 
+					 LLControlGroup* assets, 
+					 LLImageProviderInterface* image_provider,
+					 LLUIAudioCallback audio_callback,
+					 const LLVector2* scale_factor,
+					 const LLString& language)
+{
+	sConfigGroup = config;
+	sColorsGroup = colors;
+	sAssetsGroup = assets;
+	sImageProvider = image_provider;
+	sAudioCallback = audio_callback;
+	sGLScaleFactor = (scale_factor == NULL) ? LLVector2(1.f, 1.f) : *scale_factor;
+	sWindow = NULL; // set later in startup
+	LLFontGL::sShadowColor = colors->getColor("ColorDropShadow");
+
+	LLUI::sShowXUINames = LLUI::sConfigGroup->getBOOL("ShowXUINames");
+	LLUI::sConfigGroup->getControl("ShowXUINames")->addListener(&show_xui_names_listener);
+// 	init_tr(language);
+}
+
+void LLUI::cleanupClass()
+{
+// 	cleanup_tr();
+}
+
+
+//static
+void LLUI::translate(F32 x, F32 y, F32 z)
+{
+	glTranslatef(x,y,z);
+	LLFontGL::sCurOrigin.mX += (S32) x;
+	LLFontGL::sCurOrigin.mY += (S32) y;
+	LLFontGL::sCurOrigin.mZ += z;
+}
+
+//static
+void LLUI::pushMatrix()
+{
+	glPushMatrix();
+	LLFontGL::sOriginStack.push_back(LLFontGL::sCurOrigin);
+}
+
+//static
+void LLUI::popMatrix()
+{
+	glPopMatrix();
+	LLFontGL::sCurOrigin = *LLFontGL::sOriginStack.rbegin();
+	LLFontGL::sOriginStack.pop_back();
+}
+
+//static 
+void LLUI::loadIdentity()
+{
+	glLoadIdentity();
+	LLFontGL::sCurOrigin.mX = 0;
+	LLFontGL::sCurOrigin.mY = 0;
+	LLFontGL::sCurOrigin.mZ = 0;
+}
+
+//static 
+void LLUI::setScissorRegionScreen(const LLRect& rect)
+{
+	stop_glerror();
+	S32 x,y,w,h;
+	x = llround(rect.mLeft * LLUI::sGLScaleFactor.mV[VX]);
+	y = llround(rect.mBottom * LLUI::sGLScaleFactor.mV[VY]);
+	w = llround(rect.getWidth() * LLUI::sGLScaleFactor.mV[VX]);
+	h = llround(rect.getHeight() * LLUI::sGLScaleFactor.mV[VY]);
+	glScissor( x,y,w,h );
+	stop_glerror();
+}
+
+//static
+void LLUI::setScissorRegionLocal(const LLRect& rect)
+{
+	stop_glerror();
+	S32 screen_left = LLFontGL::sCurOrigin.mX + rect.mLeft;
+	S32 screen_bottom = LLFontGL::sCurOrigin.mY + rect.mBottom;
+	
+	S32 x,y,w,h;
+	
+	x = llround((F32)screen_left * LLUI::sGLScaleFactor.mV[VX]);
+	y = llround((F32)screen_bottom * LLUI::sGLScaleFactor.mV[VY]);
+	w = llround((F32)rect.getWidth() * LLUI::sGLScaleFactor.mV[VX]);
+	h = llround((F32)rect.getHeight() * LLUI::sGLScaleFactor.mV[VY]);
+	
+	w = llmax(0,w);
+	h = llmax(0,h);
+	
+	glScissor(x,y,w,h);
+	stop_glerror();
+}
+
+//static
+void LLUI::setScaleFactor(const LLVector2 &scale_factor)
+{
+	sGLScaleFactor = scale_factor;
+}
+
+//static
+void LLUI::setLineWidth(F32 width)
+{
+	glLineWidth(width * lerp(sGLScaleFactor.mV[VX], sGLScaleFactor.mV[VY], 0.5f));
+}
+
+//static 
+void LLUI::setCursorPositionScreen(S32 x, S32 y)
+{
+	S32 screen_x, screen_y;
+	screen_x = llround((F32)x * sGLScaleFactor.mV[VX]);
+	screen_y = llround((F32)y * sGLScaleFactor.mV[VY]);
+	
+	LLCoordWindow window_point;
+	LLView::getWindow()->convertCoords(LLCoordGL(screen_x, screen_y), &window_point);
+
+	LLView::getWindow()->setCursorPosition(window_point);
+}
+
+//static 
+void LLUI::setCursorPositionLocal(LLView* viewp, S32 x, S32 y)
+{
+	S32 screen_x, screen_y;
+	viewp->localPointToScreen(x, y, &screen_x, &screen_y);
+
+	setCursorPositionScreen(screen_x, screen_y);
+}
+
+//static
+LLString LLUI::locateSkin(const LLString& filename)
+{
+	LLString slash = gDirUtilp->getDirDelimiter();
+	LLString found_file = filename;
+	if (!gDirUtilp->fileExists(found_file))
+	{
+		found_file = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, filename); // Should be CUSTOM_SKINS?
+	}
+	if (sConfigGroup && sConfigGroup->controlExists("Language"))
+	{
+		if (!gDirUtilp->fileExists(found_file))
+		{
+			LLString localization(sConfigGroup->getString("Language"));		
+			LLString local_skin = "xui" + slash + localization + slash + filename;
+			found_file = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, local_skin);
+		}
+	}
+	if (!gDirUtilp->fileExists(found_file))
+	{
+		LLString local_skin = "xui" + slash + "en-us" + slash + filename;
+		found_file = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, local_skin);
+	}
+	if (!gDirUtilp->fileExists(found_file))
+	{
+		found_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, filename);
+	}
+	return found_file;
+}	
+
+//static
+LLVector2 LLUI::getWindowSize()
+{
+	LLCoordWindow window_rect;
+	sWindow->getSize(&window_rect);
+
+	return LLVector2(window_rect.mX / sGLScaleFactor.mV[VX], window_rect.mY / sGLScaleFactor.mV[VY]);
+}
+
+//static
+LLUUID			LLUI::findAssetUUIDByName(const LLString	&asset_name)
+{
+	if(asset_name == LLString::null) return LLUUID::null;
+	LLString	foundValue = LLUI::sConfigGroup->findString(asset_name);
+	if(foundValue==LLString::null)
+	{
+		foundValue = LLUI::sAssetsGroup->findString(asset_name);
+	}
+	if(foundValue == LLString::null){
+		return LLUUID::null;
+	}
+	return LLUUID( foundValue );
+}
diff --git a/indra/llui/llui.h b/indra/llui/llui.h
new file mode 100644
index 0000000000..282e41a113
--- /dev/null
+++ b/indra/llui/llui.h
@@ -0,0 +1,255 @@
+/** 
+ * @file llui.h
+ * @brief UI implementation
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// All immediate-mode gl drawing should happen here.
+
+#ifndef LL_LLUI_H
+#define LL_LLUI_H
+
+#include "llrect.h"
+#include "llcontrol.h"
+#include "llrect.h"
+#include "llcoord.h"
+
+class LLColor4;
+class LLVector3;
+class LLVector2;
+class LLImageGL;
+class LLUUID;
+class LLWindow;
+class LLView;
+
+// UI colors
+extern const LLColor4 UI_VERTEX_COLOR;
+void make_ui_sound(const LLString& name);
+
+BOOL ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom);
+void gl_state_for_2d(S32 width, S32 height);
+
+void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2);
+void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2, const LLColor4 &color );
+void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, BOOL filled);
+void gl_rect_2d_simple( S32 width, S32 height );
+
+void gl_draw_x(const LLRect& rect, const LLColor4& color);
+
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled = TRUE );
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, BOOL filled = TRUE );
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset = 0, BOOL filled = TRUE );
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset = 0, BOOL filled = TRUE );
+void gl_rect_2d(const LLRect& rect, BOOL filled = TRUE );
+void gl_rect_2d(const LLRect& rect, const LLColor4& color, BOOL filled = TRUE );
+void gl_rect_2d_checkerboard(const LLRect& rect);
+
+void gl_drop_shadow(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &start_color, S32 lines);
+
+void gl_circle_2d(F32 x, F32 y, F32 radius, S32 steps, BOOL filled);
+void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle);
+void gl_deep_circle( F32 radius, F32 depth );
+void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, BOOL render_center );
+void gl_corners_2d(S32 left, S32 top, S32 right, S32 bottom, S32 length, F32 max_frac);
+void gl_washer_2d(F32 outer_radius, F32 inner_radius, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
+void gl_washer_segment_2d(F32 outer_radius, F32 inner_radius, F32 start_radians, F32 end_radians, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
+void gl_washer_spokes_2d(F32 outer_radius, F32 inner_radius, S32 count, const LLColor4& inner_color, const LLColor4& outer_color);
+
+void gl_draw_image(S32 x, S32 y, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR);
+void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR);
+void gl_draw_rotated_image(S32 x, S32 y, F32 degrees, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR);
+void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degrees,LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR);
+void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLImageGL* image, const LLColor4 &color, BOOL solid_color = FALSE);
+// Flip vertical, used for LLFloaterHTML
+void gl_draw_scaled_image_inverted(S32 x, S32 y, S32 width, S32 height, LLImageGL* image, const LLColor4& color = UI_VERTEX_COLOR);
+
+void gl_rect_2d_xor(S32 left, S32 top, S32 right, S32 bottom);
+void gl_stippled_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& color, F32 phase = 0.f ); 
+
+void gl_rect_2d_simple_tex( S32 width, S32 height );
+
+// segmented rectangles
+
+/*
+   TL |______TOP_________| TR 
+     /|                  |\  
+   _/_|__________________|_\_
+   L| |    MIDDLE        | |R
+   _|_|__________________|_|_
+    \ |    BOTTOM        | /  
+   BL\|__________________|/ BR
+      |                  |    
+*/
+
+typedef enum e_rounded_edge
+{
+	ROUNDED_RECT_LEFT	= 0x1, 
+	ROUNDED_RECT_TOP	= 0x2, 
+	ROUNDED_RECT_RIGHT	= 0x4, 
+	ROUNDED_RECT_BOTTOM	= 0x8,
+	ROUNDED_RECT_ALL	= 0xf
+}ERoundedEdge;
+
+
+void gl_segmented_rect_2d_tex(const S32 left, const S32 top, const S32 right, const S32 bottom, const S32 texture_width, const S32 texture_height, const S32 border_size, const U32 edges = ROUNDED_RECT_ALL);
+void gl_segmented_rect_2d_fragment_tex(const S32 left, const S32 top, const S32 right, const S32 bottom, const S32 texture_width, const S32 texture_height, const S32 border_size, const F32 start_fragment, const F32 end_fragment, const U32 edges = ROUNDED_RECT_ALL);
+void gl_segmented_rect_3d_tex(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec, U32 edges = ROUNDED_RECT_ALL);
+void gl_segmented_rect_3d_tex_top(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec);
+
+inline void gl_rect_2d( const LLRect& rect, BOOL filled )
+{
+	gl_rect_2d( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, filled );
+}
+
+inline void gl_rect_2d_offset_local( const LLRect& rect, S32 pixel_offset, BOOL filled)
+{
+	gl_rect_2d_offset_local( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, pixel_offset, filled );
+}
+
+// No longer used
+// Initializes translation table
+// void init_tr();
+
+// Returns a string from the string table in the correct language
+// LLString tr(const LLString& english_chars);
+
+// Used to hide the flashing text cursor when window doesn't have focus.
+extern BOOL gShowTextEditCursor;
+
+// Language
+extern LLString gLanguage;
+
+class LLImageProviderInterface;
+typedef	void (*LLUIAudioCallback)(const LLUUID& uuid, F32 volume);
+
+class LLUI
+{
+public:
+	static void initClass(LLControlGroup* config, 
+						  LLControlGroup* colors, 
+						  LLControlGroup* assets, 
+						  LLImageProviderInterface* image_provider,
+						  LLUIAudioCallback audio_callback = NULL,
+						  const LLVector2 *scale_factor = NULL,
+						  const LLString& language = LLString::null);
+	static void cleanupClass();
+
+	static void pushMatrix();
+	static void popMatrix();
+	static void loadIdentity();
+	static void translate(F32 x, F32 y, F32 z = 0.0f);
+
+	//helper functions (should probably move free standing rendering helper functions here)
+	static LLString locateSkin(const LLString& filename);
+	static void setScissorRegionScreen(const LLRect& rect);
+	static void setScissorRegionLocal(const LLRect& rect); // works assuming LLUI::translate has been called
+	static void setCursorPositionScreen(S32 x, S32 y);
+	static void setCursorPositionLocal(LLView* viewp, S32 x, S32 y);
+	static void setScaleFactor(const LLVector2& scale_factor);
+	static void setLineWidth(F32 width);
+	static LLUUID findAssetUUIDByName(const LLString&	name);
+	static LLVector2 getWindowSize();
+public:
+	static LLControlGroup* sConfigGroup;
+	static LLControlGroup* sColorsGroup;
+	static LLControlGroup* sAssetsGroup;
+	static LLImageProviderInterface* sImageProvider;
+	static LLUIAudioCallback sAudioCallback;
+	static LLVector2		sGLScaleFactor;
+	static LLWindow*		sWindow;
+	static BOOL             sShowXUINames;
+};
+
+// UI widgets
+// This MUST match UICtrlNames in lluictrlfactory.cpp
+typedef enum e_widget_type
+{
+	WIDGET_TYPE_VIEW = 0,
+	WIDGET_TYPE_ROOT_VIEW,
+	WIDGET_TYPE_FLOATER_VIEW,
+	WIDGET_TYPE_BUTTON,
+	WIDGET_TYPE_JOYSTICK_TURN,
+	WIDGET_TYPE_JOYSTICK_SLIDE,
+	WIDGET_TYPE_CHECKBOX,
+	WIDGET_TYPE_COLOR_SWATCH,
+	WIDGET_TYPE_COMBO_BOX,
+	WIDGET_TYPE_LINE_EDITOR,
+	WIDGET_TYPE_SEARCH_EDITOR,
+	WIDGET_TYPE_SCROLL_LIST,
+	WIDGET_TYPE_NAME_LIST,
+	WIDGET_TYPE_WEBBROWSER,
+	WIDGET_TYPE_SLIDER,	// actually LLSliderCtrl
+	WIDGET_TYPE_SLIDER_BAR, // actually LLSlider
+	WIDGET_TYPE_VOLUME_SLIDER,//actually LLVolumeSliderCtrl
+	WIDGET_TYPE_SPINNER,
+	WIDGET_TYPE_TEXT_EDITOR,
+	WIDGET_TYPE_TEXTURE_PICKER,
+	WIDGET_TYPE_TEXT_BOX,
+	WIDGET_TYPE_PAD,	// used in XML for positioning, not a real widget
+	WIDGET_TYPE_RADIO_GROUP,
+	WIDGET_TYPE_ICON,
+	WIDGET_TYPE_LOCATE,	// used in XML for positioning, not a real widget
+	WIDGET_TYPE_VIEW_BORDER,	// decorative border
+	WIDGET_TYPE_PANEL,
+	WIDGET_TYPE_MENU,
+	WIDGET_TYPE_PIE_MENU,
+	WIDGET_TYPE_PIE_MENU_BRANCH,
+	WIDGET_TYPE_MENU_ITEM,
+	WIDGET_TYPE_MENU_ITEM_SEPARATOR,
+	WIDGET_TYPE_MENU_SEPARATOR_VERTICAL,
+	WIDGET_TYPE_MENU_ITEM_CALL,
+	WIDGET_TYPE_MENU_ITEM_CHECK,
+	WIDGET_TYPE_MENU_ITEM_BRANCH,
+	WIDGET_TYPE_MENU_ITEM_BRANCH_DOWN,
+	WIDGET_TYPE_MENU_ITEM_BLANK,
+	WIDGET_TYPE_TEAROFF_MENU,
+	WIDGET_TYPE_MENU_BAR,
+	WIDGET_TYPE_TAB_CONTAINER,
+	WIDGET_TYPE_SCROLL_CONTAINER, // LLScrollableContainerView
+	WIDGET_TYPE_SCROLLBAR,
+	WIDGET_TYPE_INVENTORY_PANEL, // LLInventoryPanel
+	WIDGET_TYPE_FLOATER,
+	WIDGET_TYPE_DRAG_HANDLE_TOP,
+	WIDGET_TYPE_DRAG_HANDLE_LEFT,
+	WIDGET_TYPE_RESIZE_HANDLE,
+	WIDGET_TYPE_RESIZE_BAR,
+	WIDGET_TYPE_NAME_EDITOR,
+	WIDGET_TYPE_MULTI_FLOATER,
+	WIDGET_TYPE_MEDIA_REMOTE,
+	WIDGET_TYPE_FOLDER_VIEW,
+	WIDGET_TYPE_FOLDER_ITEM,
+	WIDGET_TYPE_FOLDER,
+	WIDGET_TYPE_STAT_GRAPH,
+	WIDGET_TYPE_STAT_VIEW,
+	WIDGET_TYPE_STAT_BAR,
+	WIDGET_TYPE_DROP_TARGET,
+	WIDGET_TYPE_TEXTURE_BAR,
+	WIDGET_TYPE_TEX_MEM_BAR,
+	WIDGET_TYPE_SNAPSHOT_LIVE_PREVIEW,
+	WIDGET_TYPE_STATUS_BAR,
+	WIDGET_TYPE_PROGRESS_VIEW,
+	WIDGET_TYPE_TALK_VIEW,
+	WIDGET_TYPE_OVERLAY_BAR,
+	WIDGET_TYPE_HUD_VIEW,
+	WIDGET_TYPE_HOVER_VIEW,
+	WIDGET_TYPE_MORPH_VIEW,
+	WIDGET_TYPE_NET_MAP,
+	WIDGET_TYPE_PERMISSIONS_VIEW,
+	WIDGET_TYPE_MENU_HOLDER,
+	WIDGET_TYPE_DEBUG_VIEW,
+	WIDGET_TYPE_SCROLLING_PANEL_LIST,
+	WIDGET_TYPE_AUDIO_STATUS,
+	WIDGET_TYPE_CONTAINER_VIEW,
+	WIDGET_TYPE_CONSOLE,
+	WIDGET_TYPE_FAST_TIMER_VIEW,
+	WIDGET_TYPE_VELOCITY_BAR,
+	WIDGET_TYPE_TEXTURE_VIEW,
+	WIDGET_TYPE_MEMORY_VIEW,
+	WIDGET_TYPE_FRAME_STAT_VIEW,
+	WIDGET_TYPE_DONTCARE,
+	WIDGET_TYPE_COUNT
+} EWidgetType;
+
+#endif
diff --git a/indra/llui/lluiconstants.h b/indra/llui/lluiconstants.h
new file mode 100644
index 0000000000..01663ed233
--- /dev/null
+++ b/indra/llui/lluiconstants.h
@@ -0,0 +1,32 @@
+/** 
+ * @file lluiconstants.h
+ * @brief Compile-time configuration for UI
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLUICONSTANTS_H
+#define LL_LLUICONSTANTS_H
+
+// spacing for small font lines of text, like LLTextBoxes
+const S32 LINE = 16;
+
+// spacing for larger lines of text
+const S32 LINE_BIG = 24;
+
+// default vertical padding
+const S32 VPAD = 4;
+
+// default horizontal padding
+const S32 HPAD = 4;
+
+// Account History, how far to look into past
+const S32 SUMMARY_INTERVAL = 7;		// one week
+const S32 SUMMARY_MAX = 8;			// 
+const S32 DETAILS_INTERVAL = 1;		// one day
+const S32 DETAILS_MAX = 30;			// one month
+const S32 TRANSACTIONS_INTERVAL = 1;// one day
+const S32 TRANSACTIONS_MAX = 30;	// one month
+
+#endif
diff --git a/indra/llui/lluictrl.cpp b/indra/llui/lluictrl.cpp
new file mode 100644
index 0000000000..0d9791c660
--- /dev/null
+++ b/indra/llui/lluictrl.cpp
@@ -0,0 +1,341 @@
+/** 
+ * @file lluictrl.cpp
+ * @author James Cook, Richard Nelson, Tom Yedwab
+ * @brief Abstract base class for UI controls
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+//#include "llviewerprecompiledheaders.h"
+#include "linden_common.h"
+
+#include "lluictrl.h"
+
+#include "llgl.h"
+#include "llui.h"
+#include "lluiconstants.h"
+#include "llfocusmgr.h"
+#include "v3color.h"
+
+#include "llstring.h"
+#include "llfontgl.h"
+#include "llkeyboard.h"
+
+const U32 MAX_STRING_LENGTH = 10;
+
+LLUICtrl::LLUICtrl() :
+	mCommitCallback(NULL),
+	mFocusReceivedCallback(NULL),
+	mFocusChangedCallback(NULL),
+	mValidateCallback(NULL),
+	mCallbackUserData(NULL),
+	mTentative(FALSE),
+	mTabStop(TRUE),
+	mIsChrome(FALSE)
+{
+}
+
+LLUICtrl::LLUICtrl(const LLString& name, const LLRect& rect, BOOL mouse_opaque,
+	void (*on_commit_callback)(LLUICtrl*, void*),
+	void* callback_userdata,
+	U32 reshape)
+:	// can't make this automatically follow top and left, breaks lots
+	// of buttons in the UI. JC 7/20/2002
+	LLView( name, rect, mouse_opaque, reshape ),
+	mCommitCallback( on_commit_callback) ,
+	mFocusReceivedCallback( NULL ),
+	mFocusChangedCallback( NULL ),
+	mValidateCallback( NULL ),
+	mCallbackUserData( callback_userdata ),
+	mTentative( FALSE ),
+	mTabStop( TRUE ),
+	mIsChrome(FALSE)
+{
+}
+
+LLUICtrl::~LLUICtrl()
+{
+	gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit()
+}
+
+void LLUICtrl::onCommit()
+{
+	if( mCommitCallback )
+	{
+		mCommitCallback( this, mCallbackUserData );
+	}
+}
+
+// virtual
+BOOL LLUICtrl::setTextArg( const LLString& key, const LLString& text ) 
+{ 
+	return FALSE; 
+}
+
+// virtual
+BOOL LLUICtrl::setLabelArg( const LLString& key, const LLString& text ) 
+{ 
+	return FALSE; 
+}
+
+// virtual
+LLCtrlSelectionInterface* LLUICtrl::getSelectionInterface()	
+{ 
+	return NULL; 
+}
+
+// virtual
+LLCtrlListInterface* LLUICtrl::getListInterface()				
+{ 
+	return NULL; 
+}
+
+// virtual
+LLCtrlScrollInterface* LLUICtrl::getScrollInterface()			
+{ 
+	return NULL; 
+}
+
+// virtual
+void LLUICtrl::setTabStop( BOOL b )	
+{ 
+	mTabStop = b;
+}
+
+// virtual
+BOOL LLUICtrl::hasTabStop() const		
+{ 
+	return mTabStop;
+}
+
+// virtual
+BOOL LLUICtrl::acceptsTextInput() const
+{ 
+	return FALSE; 
+}
+
+// virtual
+void LLUICtrl::onTabInto()				
+{
+}
+
+// virtual
+void LLUICtrl::clear()					
+{
+}
+
+// virtual
+void LLUICtrl::setIsChrome(BOOL is_chrome)
+{
+	mIsChrome = is_chrome; 
+}
+
+// virtual
+BOOL LLUICtrl::getIsChrome() const
+{ 
+	return mIsChrome; 
+}
+
+void LLUICtrl::onFocusReceived()
+{
+	if( mFocusReceivedCallback )
+	{
+		mFocusReceivedCallback( this, mCallbackUserData );
+	}
+	if( mFocusChangedCallback )
+	{
+		mFocusChangedCallback( this, mCallbackUserData );
+	}
+}
+
+void LLUICtrl::onFocusLost()
+{
+	if( mFocusChangedCallback )
+	{
+		mFocusChangedCallback( this, mCallbackUserData );
+	}
+}
+
+BOOL LLUICtrl::hasFocus() const
+{
+	return (gFocusMgr.childHasKeyboardFocus(this));
+}
+
+void LLUICtrl::setFocus(BOOL b)
+{
+	// focus NEVER goes to ui ctrls that are disabled!
+	if (!mEnabled)
+	{
+		return;
+	}
+	if( b )
+	{
+		if (!hasFocus())
+		{
+			gFocusMgr.setKeyboardFocus( this, &LLUICtrl::onFocusLostCallback );
+			onFocusReceived();
+		}
+	}
+	else
+	{
+		if( gFocusMgr.childHasKeyboardFocus(this))
+		{
+			gFocusMgr.setKeyboardFocus( NULL, NULL );
+			onFocusLost();
+		}
+	}
+}
+
+// static
+void LLUICtrl::onFocusLostCallback( LLUICtrl* old_focus )
+{
+	old_focus->onFocusLost();
+}
+
+// this comparator uses the crazy disambiguating logic of LLCompareByTabOrder,
+// but to switch up the order so that children that have the default tab group come first
+// and those that are prior to the default tab group come last
+class CompareByDefaultTabGroup: public LLCompareByTabOrder
+{
+public:
+	CompareByDefaultTabGroup(LLView::child_tab_order_t order, S32 default_tab_group):
+			LLCompareByTabOrder(order),
+			mDefaultTabGroup(default_tab_group) {}
+protected:
+	/*virtual*/ bool compareTabOrders(const LLView::tab_order_t & a, const LLView::tab_order_t & b) const
+	{
+		S32 ag = a.first; // tab group for a
+		S32 bg = b.first; // tab group for b
+		// these two ifs have the effect of moving elements prior to the default tab group to the end of the list 
+		// (still sorted relative to each other, though)
+		if(ag < mDefaultTabGroup && bg >= mDefaultTabGroup) return false;
+		if(bg < mDefaultTabGroup && ag >= mDefaultTabGroup) return true;
+		return a < b;  // sort correctly if they're both on the same side of the default tab group
+	}
+	S32 mDefaultTabGroup;
+};
+
+// sorter for plugging into the query
+class DefaultTabGroupFirstSorter : public LLQuerySorter, public LLSingleton<DefaultTabGroupFirstSorter>
+{
+public:
+	/*virtual*/ void operator() (LLView * parent, viewList_t &children) const
+	{
+		children.sort(CompareByDefaultTabGroup(parent->getCtrlOrder(), parent->getDefaultTabGroup()));
+	}		
+};
+
+BOOL LLUICtrl::focusFirstItem(BOOL prefer_text_fields)
+{
+	// try to select default tab group child
+	LLCtrlQuery query = LLView::getTabOrderQuery();
+	// sort things such that the default tab group is at the front
+	query.setSorter(DefaultTabGroupFirstSorter::getInstance());
+	LLView::child_list_t result = query(this);
+	if(result.size() > 0)
+	{
+		LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front());
+		if(!ctrl->hasFocus())
+		{
+			ctrl->setFocus(TRUE);
+			ctrl->onTabInto();  
+			gFocusMgr.triggerFocusFlash();
+		}
+		return TRUE;
+	}	
+	// fall back on default behavior if we didn't find anything
+	return LLView::focusFirstItem(prefer_text_fields);
+}
+
+/*
+// Don't let the children handle the tool tip.  Handle it here instead.
+BOOL LLUICtrl::handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect_screen)
+{
+	BOOL handled = FALSE;
+	if (getVisible() && pointInView( x, y ) ) 
+	{
+		if( !mToolTipMsg.empty() )
+		{
+			msg = mToolTipMsg;
+
+			// Convert rect local to screen coordinates
+			localPointToScreen( 
+				0, 0, 
+				&(sticky_rect_screen->mLeft), &(sticky_rect_screen->mBottom) );
+			localPointToScreen(
+				mRect.getWidth(), mRect.getHeight(),
+				&(sticky_rect_screen->mRight), &(sticky_rect_screen->mTop) );
+
+			handled = TRUE;
+		}
+	}
+
+	if (!handled)
+	{
+		return LLView::handleToolTip(x, y, msg, sticky_rect_screen);
+	}
+
+	return handled;
+}*/
+
+void LLUICtrl::initFromXML(LLXMLNodePtr node, LLView* parent)
+{
+	BOOL has_tab_stop = hasTabStop();
+	node->getAttributeBOOL("tab_stop", has_tab_stop);
+
+	setTabStop(has_tab_stop);
+
+	LLView::initFromXML(node, parent);
+}
+
+LLXMLNodePtr LLUICtrl::getXML(bool save_children) const
+{
+	LLXMLNodePtr node = LLView::getXML(save_children);
+	node->createChild("tab_stop", TRUE)->setBoolValue(hasTabStop());
+
+	return node;
+}
+
+// *NOTE: If other classes derive from LLPanel, they will need to be
+// added to this function.
+LLPanel* LLUICtrl::getParentPanel() const
+{
+	LLView* parent = getParent();
+	while (parent 
+		   && parent->getWidgetType() != WIDGET_TYPE_PANEL
+		   && parent->getWidgetType() != WIDGET_TYPE_FLOATER)
+	{
+		parent = parent->getParent();
+	}
+	return reinterpret_cast<LLPanel*>(parent);
+}
+
+// virtual
+void LLUICtrl::setTentative(BOOL b)									
+{ 
+	mTentative = b; 
+}
+
+// virtual
+BOOL LLUICtrl::getTentative() const									
+{ 
+	return mTentative; 
+}
+
+// virtual
+void LLUICtrl::setDoubleClickCallback( void (*cb)(void*) )				
+{ 
+}
+
+// virtual
+void LLUICtrl::setColor(const LLColor4& color)							
+{ }
+
+// virtual
+void LLUICtrl::setMinValue(LLSD min_value)								
+{ }
+
+// virtual
+void LLUICtrl::setMaxValue(LLSD max_value)								
+{ }
diff --git a/indra/llui/lluictrl.h b/indra/llui/lluictrl.h
new file mode 100644
index 0000000000..f58b7d6e16
--- /dev/null
+++ b/indra/llui/lluictrl.h
@@ -0,0 +1,153 @@
+/** 
+ * @file lluictrl.h
+ * @author James Cook, Richard Nelson, Tom Yedwab
+ * @brief Abstract base class for UI controls
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLUICTRL_H
+#define LL_LLUICTRL_H
+
+#include "llview.h"
+#include "llrect.h"
+#include "llsd.h"
+
+//
+// Classes
+//
+class LLViewerImage;
+class LLFontGL;
+class LLButton;
+class LLTextBox;
+class LLLineEditor;
+class LLUICtrl;
+class LLPanel;
+class LLCtrlSelectionInterface;
+class LLCtrlListInterface;
+class LLCtrlScrollInterface;
+
+typedef void (*LLUICtrlCallback)(LLUICtrl* ctrl, void* userdata);
+typedef BOOL (*LLUICtrlValidate)(LLUICtrl* ctrl, void* userdata);
+
+class LLUICtrl
+: public LLView
+{
+public:
+	LLUICtrl();
+	LLUICtrl( const LLString& name, const LLRect& rect, BOOL mouse_opaque,
+		LLUICtrlCallback callback,
+		void* callback_userdata,
+		U32 reshape=FOLLOWS_NONE);
+	virtual ~LLUICtrl();
+
+	// LLView interface
+	//virtual BOOL	handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect);
+	virtual void	initFromXML(LLXMLNodePtr node, LLView* parent);
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+
+	virtual LLSD	getValue() const { return LLSD(); }
+
+	// Defaults to no-op
+	virtual BOOL	setTextArg( const LLString& key, const LLString& text );
+
+	// Defaults to no-op
+	virtual BOOL	setLabelArg( const LLString& key, const LLString& text );
+
+	// Defaults to return NULL
+	virtual LLCtrlSelectionInterface* getSelectionInterface();
+	virtual LLCtrlListInterface* getListInterface();
+	virtual LLCtrlScrollInterface* getScrollInterface();
+
+	virtual void	setFocus( BOOL b );
+	virtual BOOL	hasFocus() const;
+
+	virtual void	setTabStop( BOOL b );
+	virtual BOOL	hasTabStop() const;
+
+	// Defaults to false
+	virtual BOOL	acceptsTextInput() const;
+
+	// Default to no-op
+	virtual void	onTabInto();
+	virtual void	clear();
+
+	virtual void	setIsChrome(BOOL is_chrome);
+	virtual BOOL	getIsChrome() const;
+
+	virtual void	onCommit();
+
+	virtual BOOL	isCtrl() const	{ return TRUE; }
+	// "Tentative" controls have a proposed value, but haven't committed
+	// it yet.  This is used when multiple objects are selected and we
+	// want to display a parameter that differs between the objects.
+	virtual void	setTentative(BOOL b);
+	virtual BOOL	getTentative() const;
+
+	// Returns containing panel/floater or NULL if none found.
+	LLPanel*		getParentPanel() const;
+
+	void*			getCallbackUserData() const								{ return mCallbackUserData; }
+	void			setCallbackUserData( void* data )						{ mCallbackUserData = data; }
+	
+	void			setCommitCallback( void (*cb)(LLUICtrl*, void*) )		{ mCommitCallback = cb; }
+	void			setValidateBeforeCommit( BOOL(*cb)(LLUICtrl*, void*) )	{ mValidateCallback = cb; }
+
+	// Defaults to no-op!
+	virtual	void	setDoubleClickCallback( void (*cb)(void*) );
+
+	// Defaults to no-op
+	virtual void	setColor(const LLColor4& color);
+
+	// Defaults to no-op
+	virtual void	setMinValue(LLSD min_value);
+	virtual void	setMaxValue(LLSD max_value);
+
+	// In general, only LLPanel uses these.
+	void			setFocusReceivedCallback( void (*cb)(LLUICtrl*, void*) )	{ mFocusReceivedCallback = cb; }
+	void			setFocusChangedCallback( void (*cb)(LLUICtrl*, void*) )		{ mFocusChangedCallback = cb; }
+
+	static void		onFocusLostCallback(LLUICtrl* old_focus);
+
+	/*virtual*/ BOOL focusFirstItem(BOOL prefer_text_fields = FALSE );
+
+	class LLTabStopPostFilter : public LLQueryFilter, public LLSingleton<LLTabStopPostFilter>
+	{
+		/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const 
+		{
+			return filterResult_t(view->isCtrl() && static_cast<const LLUICtrl * const>(view)->hasTabStop() && children.size() == 0, TRUE);
+		}
+	};
+
+	class LLTextInputFilter : public LLQueryFilter, public LLSingleton<LLTextInputFilter>
+	{
+		/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const 
+		{
+			return filterResult_t(view->isCtrl() && static_cast<const LLUICtrl * const>(view)->acceptsTextInput(), TRUE);
+		}
+	};
+
+protected:
+	virtual void	onFocusReceived();
+	virtual void	onFocusLost();
+	void			onChangeFocus( S32 direction );
+
+protected:
+
+	void			(*mCommitCallback)( LLUICtrl* ctrl, void* userdata );
+	void			(*mFocusReceivedCallback)( LLUICtrl* ctrl, void* userdata );
+	void			(*mFocusChangedCallback)( LLUICtrl* ctrl, void* userdata );
+	BOOL			(*mValidateCallback)( LLUICtrl* ctrl, void* userdata );
+
+	void*			mCallbackUserData;
+	BOOL			mTentative;
+	BOOL			mTabStop;
+
+private:
+	BOOL			mIsChrome;
+
+
+};
+
+#endif  // LL_LLUICTRL_H
diff --git a/indra/llui/lluictrlfactory.cpp b/indra/llui/lluictrlfactory.cpp
new file mode 100644
index 0000000000..7e286f0bee
--- /dev/null
+++ b/indra/llui/lluictrlfactory.cpp
@@ -0,0 +1,722 @@
+/** 
+ * @file lluictrlfactory.cpp
+ * @brief Factory class for creating UI controls
+ *
+ * Copyright (c) 2003-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "lluictrlfactory.h"
+
+#include <fstream>
+#include <boost/tokenizer.hpp>
+
+// other library includes
+#include "llcontrol.h"
+#include "lldir.h"
+#include "v4color.h"
+
+// this library includes
+#include "llbutton.h"
+#include "llcheckboxctrl.h"
+//#include "llcolorswatch.h"
+#include "llcombobox.h"
+#include "llcontrol.h"
+#include "lldir.h"
+#include "llevent.h"
+#include "llfloater.h"
+#include "lliconctrl.h"
+#include "lllineeditor.h"
+#include "llmenugl.h"
+#include "llradiogroup.h"
+#include "llscrollcontainer.h"
+#include "llscrollingpanellist.h"
+#include "llscrolllistctrl.h"
+#include "llslider.h"
+#include "llsliderctrl.h"
+#include "llspinctrl.h"
+#include "lltabcontainer.h"
+#include "lltabcontainervertical.h"
+#include "lltextbox.h"
+#include "lltexteditor.h"
+#include "llui.h"
+#include "llviewborder.h"
+
+
+const char XML_HEADER[] = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\" ?>\n";
+
+// *NOTE: If you add a new class derived from LLPanel, add a check for its
+// widget type to LLUICtrl::getParentPanel().
+// *NOTE: This MUST match EWidgetType in llui.h
+//static
+const LLString LLUICtrlFactory::sUICtrlNames[WIDGET_TYPE_COUNT] = 
+{
+	LLString("view"),			//WIDGET_TYPE_VIEW
+	LLString("root_view"),		//WIDGET_TYPE_ROOT_VIEW
+	LLString("floater_view"),	//WIDGET_TYPE_FLOATER_VIEW
+	LLString("button"),		//WIDGET_TYPE_BUTTON
+	LLString("joystick_turn"),	//WIDGET_TYPE_JOYSTICK_TURN
+	LLString("joystick_slide"),	//WIDGET_TYPE_JOYSTICK_SLIDE
+	LLString("check_box"),	//WIDGET_TYPE_CHECKBOX
+	LLString("color_swatch"),	//WIDGET_TYPE_COLOR_SWATCH
+	LLString("combo_box"),	//WIDGET_TYPE_COMBO_BOX
+	LLString("line_editor"),	//WIDGET_TYPE_LINE_EDITOR
+	LLString("search_editor"),	//WIDGET_TYPE_SEARCH_EDITOR
+	LLString("scroll_list"),	//WIDGET_TYPE_SCROLL_LIST
+	LLString("name_list"),	//WIDGET_TYPE_NAME_LIST
+	LLString("web_browser"),	//WIDGET_TYPE_WEBBROWSER
+	LLString("slider"),		//WIDGET_TYPE_SLIDER, actually LLSliderCtrl
+	LLString("slider_bar"), //WIDGET_TYPE_SLIDER_BAR, actually LLSlider
+	LLString("volume_slider"),	//WIDGET_TYPE_VOLUME_SLIDER, actually LLVolumeSliderCtrl
+	LLString("spinner"),		//WIDGET_TYPE_SPINNER, actually LLSpinCtrl
+	LLString("text_editor"),	//WIDGET_TYPE_TEXT_EDITOR
+	LLString("texture_picker"),//WIDGET_TYPE_TEXTURE_PICKER
+	LLString("text"),			//WIDGET_TYPE_TEXT_BOX
+	LLString("pad"),			//WIDGET_TYPE_PAD
+	LLString("radio_group"),	//WIDGET_TYPE_RADIO_GROUP
+	LLString("icon"),			//WIDGET_TYPE_ICON
+	LLString("locate"),		//WIDGET_TYPE_LOCATE
+	LLString("view_border"),	//WIDGET_TYPE_VIEW_BORDER
+	LLString("panel"),		//WIDGET_TYPE_PANEL
+	LLString("menu"),		//WIDGET_TYPE_MENU
+	LLString("pie_menu"),	//WIDGET_TYPE_PIE_MENU
+	LLString("pie_menu_branch"), //WIDGET_TYPE_PIE_MENU_BRANCH
+	LLString("menu_item"), //WIDGET_TYPE_MENU_ITEM
+	LLString("menu_item_separator"), //WIDGET_TYPE_MENU_ITEM_SEPARATOR
+	LLString("menu_separator_vertical"), //	WIDGET_TYPE_MENU_SEPARATOR_VERTICAL
+	LLString("menu_item_call"), // WIDGET_TYPE_MENU_ITEM_CALL
+	LLString("menu_item_check"),// WIDGET_TYPE_MENU_ITEM_CHECK
+	LLString("menu_item_branch"), // WIDGET_TYPE_MENU_ITEM_BRANCH
+	LLString("menu_item_branch_down"), //WIDGET_TYPE_MENU_ITEM_BRANCH_DOWN,
+	LLString("menu_item_blank"), //WIDGET_TYPE_MENU_ITEM_BLANK,
+	LLString("tearoff_menu"), //WIDGET_TYPE_TEAROFF_MENU
+	LLString("menu_bar"),	//WIDGET_TYPE_MENU_BAR
+	LLString("tab_container"),//WIDGET_TYPE_TAB_CONTAINER
+	LLString("scroll_container"),//WIDGET_TYPE_SCROLL_CONTAINER
+	LLString("scrollbar"),	//WIDGET_TYPE_SCROLLBAR
+	LLString("inventory_panel"), //WIDGET_TYPE_INVENTORY_PANEL
+	LLString("floater"),		//WIDGET_TYPE_FLOATER
+	LLString("drag_handle_top"), //WIDGET_TYPE_DRAG_HANDLE_TOP
+	LLString("drag_handle_left"), //WIDGET_TYPE_DRAG_HANDLE_LEFT
+	LLString("resize_handle"), //WIDGET_TYPE_RESIZE_HANDLE
+	LLString("resize_bar"), //WIDGET_TYPE_RESIZE_BAR
+	LLString("name_editor"),	//WIDGET_TYPE_NAME_EDITOR
+	LLString("multi_floater"),	//WIDGET_TYPE_MULTI_FLOATER
+	LLString("media_remote"), //WIDGET_TYPE_MEDIA_REMOTE
+	LLString("folder_view"), //WIDGET_TYPE_FOLDER_VIEW
+	LLString("folder_item"), //WIDGET_TYPE_FOLDER_ITEM
+	LLString("folder"), //WIDGET_TYPE_FOLDER
+	LLString("stat_graph"), //WIDGET_TYPE_STAT_GRAPH
+	LLString("stat_view"), //WIDGET_TYPE_STAT_VIEW
+	LLString("stat_bar"), //WIDGET_TYPE_STAT_BAR
+	LLString("drop_target"), //WIDGET_TYPE_DROP_TARGET
+	LLString("texture_bar"), //WIDGET_TYPE_TEXTURE_BAR
+	LLString("tex_mem_bar"), //WIDGET_TYPE_TEX_MEM_BAR
+	LLString("snapshot_live_preview"), //WIDGET_TYPE_SNAPSHOT_LIVE_PREVIEW
+	LLString("status_bar"), //WIDGET_TYPE_STATUS_BAR
+	LLString("progress_view"), //WIDGET_TYPE_PROGRESS_VIEW
+	LLString("talk_view"), //WIDGET_TYPE_TALK_VIEW
+	LLString("overlay_bar"), //WIDGET_TYPE_OVERLAY_BAR
+	LLString("hud_view"), //WIDGET_TYPE_HUD_VIEW
+	LLString("hover_view"), //WIDGET_TYPE_HOVER_VIEW
+	LLString("morph_view"), //WIDGET_TYPE_MORPH_VIEW
+	LLString("net_map"), //WIDGET_TYPE_NET_MAP
+	LLString("permissions_view"), //WIDGET_TYPE_PERMISSIONS_VIEW
+	LLString("menu_holder"), //WIDGET_TYPE_MENU_HOLDER
+	LLString("debug_view"), //WIDGET_TYPE_DEBUG_VIEW
+	LLString("scrolling_panel_list"), //WIDGET_TYPE_SCROLLING_PANEL_LIST
+	LLString("audio_status"), //WIDGET_TYPE_AUDIO_STATUS
+	LLString("container_view"), //WIDGET_TYPE_CONTAINER_VIEW
+	LLString("console"), //WIDGET_TYPE_CONSOLE
+	LLString("fast_timer_view"), //WIDGET_TYPE_FAST_TIMER_VIEW
+	LLString("velocity_bar"), //WIDGET_TYPE_VELOCITY_BAR
+	LLString("texture_view"), //WIDGET_TYPE_TEXTURE_VIEW
+	LLString("memory_view"), //WIDGET_TYPE_MEMORY_VIEW
+	LLString("frame_stat_view"), //WIDGET_TYPE_FRAME_STAT_VIEW
+	LLString("DONT_CARE"),	//WIDGET_TYPE_DONTCARE
+};
+
+const S32 HPAD = 4;
+const S32 VPAD = 4;
+const S32 FLOATER_H_MARGIN = 15;
+const S32 MIN_WIDGET_HEIGHT = 10;
+
+std::vector<LLString> LLUICtrlFactory::mXUIPaths;
+
+// UI Ctrl class for padding
+class LLUICtrlLocate : public LLUICtrl
+{
+public:
+	LLUICtrlLocate() : LLUICtrl("locate", LLRect(0,0,0,0), FALSE, NULL, NULL) {}
+	virtual void draw() { }
+
+	virtual EWidgetType getWidgetType() const { return WIDGET_TYPE_LOCATE; }
+	virtual LLString getWidgetTag() const { return LL_UI_CTRL_LOCATE_TAG; }
+
+	static LLView *fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+	{
+		LLUICtrlLocate *new_ctrl = new LLUICtrlLocate();
+		new_ctrl->initFromXML(node, parent);
+		return new_ctrl;
+	}
+};
+
+//-----------------------------------------------------------------------------
+// LLUICtrlFactory()
+//-----------------------------------------------------------------------------
+LLUICtrlFactory::LLUICtrlFactory()
+{
+	// Register controls
+	LLUICtrlCreator<LLButton>::registerCreator(LL_BUTTON_TAG, this);
+	LLUICtrlCreator<LLCheckBoxCtrl>::registerCreator(LL_CHECK_BOX_CTRL_TAG, this);
+	LLUICtrlCreator<LLComboBox>::registerCreator(LL_COMBO_BOX_TAG, this);
+	LLUICtrlCreator<LLLineEditor>::registerCreator(LL_LINE_EDITOR_TAG, this);
+	LLUICtrlCreator<LLSearchEditor>::registerCreator(LL_SEARCH_EDITOR_TAG, this);
+	LLUICtrlCreator<LLScrollListCtrl>::registerCreator(LL_SCROLL_LIST_CTRL_TAG, this);
+	LLUICtrlCreator<LLSliderCtrl>::registerCreator(LL_SLIDER_CTRL_TAG, this);
+	LLUICtrlCreator<LLSlider>::registerCreator(LL_SLIDER_TAG, this);
+	LLUICtrlCreator<LLSpinCtrl>::registerCreator(LL_SPIN_CTRL_TAG, this);
+	LLUICtrlCreator<LLTextBox>::registerCreator(LL_TEXT_BOX_TAG, this);
+	LLUICtrlCreator<LLRadioGroup>::registerCreator(LL_RADIO_GROUP_TAG, this);
+	LLUICtrlCreator<LLIconCtrl>::registerCreator(LL_ICON_CTRL_TAG, this);
+	LLUICtrlCreator<LLUICtrlLocate>::registerCreator(LL_UI_CTRL_LOCATE_TAG, this);
+	LLUICtrlCreator<LLUICtrlLocate>::registerCreator(LL_PAD_TAG, this);
+	LLUICtrlCreator<LLViewBorder>::registerCreator(LL_VIEW_BORDER_TAG, this);
+	LLUICtrlCreator<LLTabContainerCommon>::registerCreator(LL_TAB_CONTAINER_COMMON_TAG, this);
+	LLUICtrlCreator<LLScrollableContainerView>::registerCreator(LL_SCROLLABLE_CONTAINER_VIEW_TAG, this);
+	LLUICtrlCreator<LLPanel>::registerCreator(LL_PANEL_TAG, this);
+	LLUICtrlCreator<LLMenuGL>::registerCreator(LL_MENU_GL_TAG, this);
+	LLUICtrlCreator<LLMenuBarGL>::registerCreator(LL_MENU_BAR_GL_TAG, this);
+	LLUICtrlCreator<LLScrollingPanelList>::registerCreator(LL_SCROLLING_PANEL_LIST_TAG, this);
+
+
+	LLString filename = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, "paths.xml");
+
+	LLXMLNodePtr root;
+	BOOL success  = LLXMLNode::parseFile(filename, root, NULL);
+
+	if (!success)
+	{
+		LLString slash = gDirUtilp->getDirDelimiter();
+		LLString dir = gDirUtilp->getAppRODataDir() + slash + "skins" + slash + "xui" + slash + "en-us" + slash;
+		llwarns << "XUI::config file unable to open." << llendl;
+		mXUIPaths.push_back(dir);
+	}
+	else
+	{
+		LLXMLNodePtr path;
+		LLString app_dir = gDirUtilp->getAppRODataDir();
+	
+		for (path = root->getFirstChild(); path.notNull(); path = path->getNextSibling())
+		{
+			LLUIString path_val_ui(path->getValue());
+			LLString language = "en-us";
+			if (LLUI::sConfigGroup)
+			{
+				language = LLUI::sConfigGroup->getString("Language");
+			}
+			path_val_ui.setArg("[Language]", language);
+			LLString fullpath = app_dir + path_val_ui.getString();
+
+			if (mXUIPaths.empty() || (find(mXUIPaths.begin(), mXUIPaths.end(), fullpath) == mXUIPaths.end()) )
+			{
+				mXUIPaths.push_back(app_dir + path_val_ui.getString());
+			}
+		}
+	}
+
+
+}
+
+//-----------------------------------------------------------------------------
+// ~LLUICtrlFactory()
+//-----------------------------------------------------------------------------
+LLUICtrlFactory::~LLUICtrlFactory()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// getLayeredXMLNode()
+//-----------------------------------------------------------------------------
+bool LLUICtrlFactory::getLayeredXMLNode(const LLString &filename, LLXMLNodePtr& root)
+{
+	
+	if (!LLXMLNode::parseFile(mXUIPaths.front() + filename, root, NULL))
+	{	
+		llwarns << "Problem reading UI description file: " << mXUIPaths.front() + filename << llendl;
+		return FALSE;
+	}
+
+	LLXMLNodePtr updateRoot;
+
+	std::vector<LLString>::const_iterator itor;
+
+	for (itor = mXUIPaths.begin(), ++itor; itor != mXUIPaths.end(); ++itor)
+	{
+		LLString nodeName;
+		LLString updateName;
+
+		LLXMLNode::parseFile((*itor) + filename, updateRoot, NULL);
+	
+		updateRoot->getAttributeString("name", updateName);
+		root->getAttributeString("name", nodeName);
+
+		if (updateName == nodeName)
+		{
+			LLXMLNode::updateNode(root, updateRoot);
+		}
+	}
+
+	return TRUE;
+}
+
+
+//-----------------------------------------------------------------------------
+// buildFloater()
+//-----------------------------------------------------------------------------
+void LLUICtrlFactory::buildFloater(LLFloater* floaterp, const LLString &filename, 
+									const LLCallbackMap::map_t* factory_map, BOOL open)
+{
+	LLXMLNodePtr root;
+
+	if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
+	{
+		return;
+	}
+	
+	// root must be called floater
+	if( !(root->hasName("floater") || root->hasName("multi_floater") ) )
+	{
+		llwarns << "Root node should be named floater in: " << filename << llendl;
+		return;
+	}
+
+	if (factory_map)
+	{
+		mFactoryStack.push_front(factory_map);
+	}
+
+	floaterp->initFloaterXML(root, NULL, this, open);
+
+	if (LLUI::sShowXUINames)
+	{
+		floaterp->mToolTipMsg = filename;
+	}
+
+	if (factory_map)
+	{
+		mFactoryStack.pop_front();
+	}
+
+	LLViewHandle handle = floaterp->getHandle();
+	mBuiltFloaters[handle] = filename;
+}
+
+//-----------------------------------------------------------------------------
+// saveToXML()
+//-----------------------------------------------------------------------------
+S32 LLUICtrlFactory::saveToXML(LLView* viewp, const LLString& filename)
+{
+	llofstream out(filename.c_str());
+	if (!out.good())
+	{
+		llwarns << "Unable to open " << filename << " for output." << llendl;
+		return 1;
+	}
+
+	out << XML_HEADER;
+
+	LLXMLNodePtr xml_node = viewp->getXML();
+
+	xml_node->writeToOstream(out);
+
+	out.close();
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// buildPanel()
+//-----------------------------------------------------------------------------
+void LLUICtrlFactory::buildPanel(LLPanel* panelp, const LLString &filename,
+									const LLCallbackMap::map_t* factory_map)
+{
+	LLXMLNodePtr root;
+
+	if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
+	{
+		return;
+	}
+
+	// root must be called panel
+	if( !root->hasName("panel" ) )
+	{
+		llwarns << "Root node should be named panel in : " << filename << llendl;
+		return;
+	}
+
+	if (factory_map)
+	{
+		mFactoryStack.push_front(factory_map);
+	}
+
+	panelp->initPanelXML(root, NULL, this);
+	
+	if (LLUI::sShowXUINames)
+	{
+		panelp->mToolTipMsg = filename;
+	}
+
+	LLViewHandle handle = panelp->getHandle();
+	mBuiltPanels[handle] = filename;
+
+	if (factory_map)
+	{
+		mFactoryStack.pop_front();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// buildMenu()
+//-----------------------------------------------------------------------------
+LLMenuGL *LLUICtrlFactory::buildMenu(const LLString &filename, LLView* parentp)
+{
+	// TomY TODO: Break this function into buildMenu and buildMenuBar
+	LLXMLNodePtr root;
+
+	if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
+	{
+		return NULL;
+	}
+
+	// root must be called panel
+	if( !root->hasName( "menu_bar" ) && !root->hasName( "menu" ))
+	{
+		llwarns << "Root node should be named menu bar or menu in : " << filename << llendl;
+		return NULL;
+	}
+
+	if (root->hasName("menu"))
+	{
+		return (LLMenuGL*)LLMenuGL::fromXML(root, parentp, this);
+	}
+
+	return (LLMenuGL*)LLMenuBarGL::fromXML(root, parentp, this);
+}
+
+//-----------------------------------------------------------------------------
+// buildMenu()
+//-----------------------------------------------------------------------------
+LLPieMenu *LLUICtrlFactory::buildPieMenu(const LLString &filename, LLView* parentp)
+{
+
+	LLXMLNodePtr root;
+
+	if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
+	{
+		return NULL;
+	}
+
+	// root must be called panel
+	if( !root->hasName( LL_PIE_MENU_TAG ))
+	{
+		llwarns << "Root node should be named " LL_PIE_MENU_TAG " in : " << filename << llendl;
+		return NULL;
+	}
+
+	LLString name("menu");
+	root->getAttributeString("name", name);
+
+	LLPieMenu *menu = new LLPieMenu(name);
+	parentp->addChild(menu);
+	menu->initXML(root, parentp, this);
+	return menu;
+}
+
+//-----------------------------------------------------------------------------
+// removePanel()
+//-----------------------------------------------------------------------------
+void LLUICtrlFactory::removePanel(LLPanel* panelp)
+{
+	mBuiltPanels.erase(panelp->getHandle());
+}
+
+//-----------------------------------------------------------------------------
+// removeFloater()
+//-----------------------------------------------------------------------------
+void LLUICtrlFactory::removeFloater(LLFloater* floaterp)
+{
+	mBuiltFloaters.erase(floaterp->getHandle());
+}
+
+//-----------------------------------------------------------------------------
+// rebuild()
+//-----------------------------------------------------------------------------
+void LLUICtrlFactory::rebuild()
+{
+	built_panel_t::iterator built_panel_it;
+	for (built_panel_it = mBuiltPanels.begin();
+		built_panel_it != mBuiltPanels.end();
+		++built_panel_it)
+		{
+			LLString filename = built_panel_it->second;
+			LLPanel* panelp = LLPanel::getPanelByHandle(built_panel_it->first);
+			if (!panelp)
+			{
+				continue;
+			}
+			llinfos << "Rebuilding UI panel " << panelp->getName() 
+				<< " from " << filename
+				<< llendl;
+			BOOL visible = panelp->getVisible();
+			panelp->setVisible(FALSE);
+			panelp->setFocus(FALSE);
+			panelp->deleteAllChildren();
+
+			buildPanel(panelp, filename.c_str(), &panelp->getFactoryMap());
+			panelp->setVisible(visible);
+		}
+
+	built_floater_t::iterator built_floater_it;
+	for (built_floater_it = mBuiltFloaters.begin();
+		built_floater_it != mBuiltFloaters.end();
+		++built_floater_it)
+		{
+			LLFloater* floaterp = LLFloater::getFloaterByHandle(built_floater_it->first);
+			if (!floaterp)
+			{
+				continue;
+			}
+			LLString filename = built_floater_it->second;
+			llinfos << "Rebuilding UI floater " << floaterp->getName()
+				<< " from " << filename
+				<< llendl;
+			BOOL visible = floaterp->getVisible();
+			floaterp->setVisible(FALSE);
+			floaterp->setFocus(FALSE);
+			floaterp->deleteAllChildren();
+
+			gFloaterView->removeChild(floaterp);
+			buildFloater(floaterp, filename, &floaterp->getFactoryMap());
+			floaterp->setVisible(visible);
+		}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+// static
+EWidgetType LLUICtrlFactory::getWidgetType(const LLString& ctrl_type)
+{
+	U32 ctrl_id;
+	for (ctrl_id = 0; ctrl_id < WIDGET_TYPE_COUNT; ctrl_id++)
+	{
+		if (sUICtrlNames[ctrl_id] == ctrl_type)
+		{
+			break;
+		}
+	}
+	return (EWidgetType) ctrl_id;
+}
+
+LLString LLUICtrlFactory::getWidgetType(EWidgetType ctrl_type)
+{
+	return sUICtrlNames[ctrl_type];
+}
+
+LLView *LLUICtrlFactory::createCtrlWidget(LLPanel *parent, LLXMLNodePtr node)
+{
+	LLString ctrl_type = node->getName()->mString;
+	LLString::toLower(ctrl_type);
+	
+	creator_list_t::const_iterator it = mCreatorFunctions.find(ctrl_type);
+	if (it == mCreatorFunctions.end())
+	{
+		llwarns << "Unknown control type " << ctrl_type << llendl;
+		return NULL;
+	}
+
+	LLView *ctrl = (*it->second)(node, parent, this);
+
+	return ctrl;
+}
+
+void LLUICtrlFactory::createWidget(LLPanel *parent, LLXMLNodePtr node)
+{
+	LLView* view = createCtrlWidget(parent, node);
+
+	S32 tab_group = parent->getLastTabGroup();
+	node->getAttributeS32("tab_group", tab_group);
+
+	if (view)
+	{
+		parent->addChild(view, tab_group);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// createFactoryPanel()
+//-----------------------------------------------------------------------------
+LLPanel* LLUICtrlFactory::createFactoryPanel(LLString name)
+{
+	std::deque<const LLCallbackMap::map_t*>::iterator itor;
+	for (itor = mFactoryStack.begin(); itor != mFactoryStack.end(); ++itor)
+	{
+		const LLCallbackMap::map_t* factory_map = *itor;
+
+		// Look up this panel's name in the map.
+		LLCallbackMap::map_const_iter_t iter = factory_map->find( name );
+		if (iter != factory_map->end())
+		{
+			// Use the factory to create the panel, instead of using a default LLPanel.
+			LLPanel *ret = (LLPanel*) iter->second.mCallback( iter->second.mData );
+			return ret;
+		}
+	}
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+
+//static
+BOOL LLUICtrlFactory::getAttributeColor(LLXMLNodePtr node, const LLString& name, LLColor4& color)
+{
+	LLString colorstring;
+	BOOL res = node->getAttributeString(name, colorstring);
+	if (res && LLUI::sColorsGroup)
+	{
+		if (LLUI::sColorsGroup->controlExists(colorstring))
+		{
+			color.setVec(LLUI::sColorsGroup->getColor(colorstring));
+		}
+		else
+		{
+			res = FALSE;
+		}
+	}
+	if (!res)
+	{
+		res = LLColor4::parseColor(colorstring.c_str(), &color);
+	}	
+	if (!res)
+	{
+		res = node->getAttributeColor(name, color);
+	}
+	return res;
+}
+
+//============================================================================
+
+LLButton*	LLUICtrlFactory::getButtonByName(LLPanel* panelp, const LLString& name)
+{ 
+	return (LLButton*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_BUTTON); 
+}
+
+LLCheckBoxCtrl*		LLUICtrlFactory::getCheckBoxByName(LLPanel* panelp, const LLString& name)		
+{ 
+	return (LLCheckBoxCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_CHECKBOX); 
+}
+
+LLComboBox*			LLUICtrlFactory::getComboBoxByName(LLPanel* panelp, const LLString& name)		
+{ 
+	return (LLComboBox*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_COMBO_BOX); 
+}
+
+LLIconCtrl*			LLUICtrlFactory::getIconByName(LLPanel* panelp, const LLString& name)			
+{ 
+	return (LLIconCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_ICON); 
+}
+
+LLLineEditor*		LLUICtrlFactory::getLineEditorByName(LLPanel* panelp, const LLString& name)	
+{ 
+	return (LLLineEditor*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_LINE_EDITOR); 
+}
+
+LLNameListCtrl*	LLUICtrlFactory::getNameListByName(LLPanel* panelp, const LLString& name)	
+{ 
+	return (LLNameListCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_NAME_LIST); 
+}
+
+LLRadioGroup*		LLUICtrlFactory::getRadioGroupByName(LLPanel* panelp, const LLString& name)	
+{ 
+	return (LLRadioGroup*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_RADIO_GROUP); 
+}
+
+LLScrollListCtrl*	LLUICtrlFactory::getScrollListByName(LLPanel* panelp, const LLString& name)	
+{ 
+	return (LLScrollListCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_SCROLL_LIST); 
+}
+
+LLSliderCtrl*		LLUICtrlFactory::getSliderByName(LLPanel* panelp, const LLString& name)		
+{ 
+	return (LLSliderCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_SLIDER); 
+}
+
+LLSlider*			LLUICtrlFactory::getSliderBarByName(LLPanel* panelp, const LLString& name)		
+{ 
+	return (LLSlider*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_SLIDER_BAR); 
+}
+
+LLSpinCtrl*			LLUICtrlFactory::getSpinnerByName(LLPanel* panelp, const LLString& name)		
+{ 
+	return (LLSpinCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_SPINNER); 
+}
+
+LLTextBox*			LLUICtrlFactory::getTextBoxByName(LLPanel* panelp, const LLString& name)		
+{ 
+	return (LLTextBox*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_TEXT_BOX);
+}
+
+LLTextEditor*		LLUICtrlFactory::getTextEditorByName(LLPanel* panelp, const LLString& name)	
+{ 
+	return (LLTextEditor*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_TEXT_EDITOR); 
+}
+
+LLTabContainerCommon* LLUICtrlFactory::getTabContainerByName(LLPanel* panelp, const LLString& name)	
+{ 
+	return (LLTabContainerCommon*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_TAB_CONTAINER); 
+}
+
+LLScrollableContainerView* LLUICtrlFactory::getScrollableContainerByName(LLPanel* panelp, const LLString& name)
+{
+	return (LLScrollableContainerView*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_SCROLL_CONTAINER); 
+}
+
+LLTextureCtrl* LLUICtrlFactory::getTexturePickerByName(LLPanel* panelp, const LLString& name)
+{
+	return (LLTextureCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_TEXTURE_PICKER);
+}
+
+LLPanel* LLUICtrlFactory::getPanelByName(LLPanel* panelp, const LLString& name)	
+{ 
+	return (LLPanel*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_PANEL); 
+}
+
+LLColorSwatchCtrl* LLUICtrlFactory::getColorSwatchByName(LLPanel* panelp, const LLString& name)
+{ 
+	return (LLColorSwatchCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_COLOR_SWATCH); 
+}
+
+LLWebBrowserCtrl* LLUICtrlFactory::getWebBrowserCtrlByName(LLPanel* panelp, const LLString& name)
+{ 
+	return (LLWebBrowserCtrl*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_WEBBROWSER); 
+}
+
+LLMenuItemCallGL* LLUICtrlFactory::getMenuItemCallByName(LLPanel* panelp, const LLString& name)
+{ 
+	return (LLMenuItemCallGL*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_MENU_ITEM_CALL); 
+}
+
+LLScrollingPanelList* LLUICtrlFactory::getScrollingPanelList(LLPanel* panelp, const LLString& name)
+{ 
+	return (LLScrollingPanelList*)panelp->getCtrlByNameAndType(name, WIDGET_TYPE_SCROLLING_PANEL_LIST); 
+}
+
+void LLUICtrlFactory::registerCreator(LLString ctrlname, creator_function_t function)
+{
+	LLString::toLower(ctrlname);
+	mCreatorFunctions[ctrlname] = function;
+}
+
diff --git a/indra/llui/lluictrlfactory.h b/indra/llui/lluictrlfactory.h
new file mode 100644
index 0000000000..b3bd5c9020
--- /dev/null
+++ b/indra/llui/lluictrlfactory.h
@@ -0,0 +1,142 @@
+/** 
+ * @file lluictrlfactory.h
+ * @brief Factory class for creating UI controls
+ *
+ * Copyright (c) 2003-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LLUICTRLFACTORY_H
+#define LLUICTRLFACTORY_H
+
+#include <iosfwd>
+#include <stack>
+
+#include "llcallbackmap.h"
+#include "llfloater.h"
+
+class LLControlGroup;
+class LLView;
+class LLFontGL;
+
+class LLFloater;
+class LLPanel;
+class LLButton;
+class LLCheckBoxCtrl;
+class LLComboBox;
+class LLIconCtrl;
+class LLLineEditor;
+class LLMenuGL;
+class LLMenuBarGL;
+class LLMenuItemCallGL;
+class LLNameListCtrl;
+class LLPieMenu;
+class LLRadioGroup;
+class LLSearchEditor;
+class LLScrollableContainerView;
+class LLScrollListCtrl;
+class LLSlider;
+class LLSliderCtrl;
+class LLSpinCtrl;
+class LLTextBox;
+class LLTextEditor;
+class LLTextureCtrl;
+class LLWebBrowserCtrl;
+class LLViewBorder;
+class LLColorSwatchCtrl;
+class LLScrollingPanelList;
+
+// Widget 
+
+class LLUICtrlFactory
+{
+public:
+	LLUICtrlFactory();
+	// do not call!  needs to be public so run-time can clean up the singleton
+	virtual ~LLUICtrlFactory();
+
+	void buildFloater(LLFloater* floaterp, const LLString &filename, 
+						const LLCallbackMap::map_t* factory_map = NULL, BOOL open = TRUE);
+
+	void buildPanel(LLPanel* panelp, const LLString &filename,
+						const LLCallbackMap::map_t* factory_map = NULL);
+
+	LLMenuGL *buildMenu(const LLString &filename, LLView* parentp);
+
+	LLPieMenu *buildPieMenu(const LLString &filename, LLView* parentp);
+
+	// Does what you want for LLFloaters and LLPanels
+	// Returns 0 on success
+	S32 saveToXML(LLView* viewp, const LLString& filename);
+
+	void removePanel(LLPanel* panelp);
+	void removeFloater(LLFloater* floaterp);
+
+	void rebuild();
+
+	static EWidgetType getWidgetType(const LLString& ctrl_type);
+	static LLString	getWidgetType(EWidgetType ctrl_type);
+	static BOOL getAttributeColor(LLXMLNodePtr node, const LLString& name, LLColor4& color);
+
+	// specific typed getters
+	static LLButton*			getButtonByName(		LLPanel* panelp, const LLString& name);
+	static LLCheckBoxCtrl*		getCheckBoxByName(		LLPanel* panelp, const LLString& name);
+	static LLComboBox*			getComboBoxByName(		LLPanel* panelp, const LLString& name);
+	static LLIconCtrl*			getIconByName(			LLPanel* panelp, const LLString& name);
+	static LLLineEditor*		getLineEditorByName(	LLPanel* panelp, const LLString& name);
+	static LLNameListCtrl*		getNameListByName(		LLPanel* panelp, const LLString& name);
+	static LLRadioGroup*		getRadioGroupByName(	LLPanel* panelp, const LLString& name);
+	static LLScrollListCtrl*	getScrollListByName(	LLPanel* panelp, const LLString& name);
+	static LLSliderCtrl*		getSliderByName(		LLPanel* panelp, const LLString& name);
+	static LLSlider*			getSliderBarByName(		LLPanel* panelp, const LLString& name);
+	static LLSpinCtrl*			getSpinnerByName(		LLPanel* panelp, const LLString& name);
+	static LLTextBox*			getTextBoxByName(		LLPanel* panelp, const LLString& name);
+	static LLTextEditor*		getTextEditorByName(	LLPanel* panelp, const LLString& name);
+	static LLTabContainerCommon* getTabContainerByName(	LLPanel* panelp, const LLString& name);
+	static LLScrollableContainerView*	getScrollableContainerByName(LLPanel* panelp, const LLString& name);
+	static LLTextureCtrl*		getTexturePickerByName(	LLPanel* panelp, const LLString& name);
+	static LLPanel* 			getPanelByName(LLPanel* panelp, const LLString& name);
+	static LLColorSwatchCtrl*	getColorSwatchByName(LLPanel* panelp, const LLString& name);
+	static LLWebBrowserCtrl*	getWebBrowserCtrlByName(LLPanel* panelp, const LLString& name);
+	static LLMenuItemCallGL*	getMenuItemCallByName(LLPanel* panelp, const LLString& name);
+	static LLScrollingPanelList* getScrollingPanelList(LLPanel* panelp, const LLString& name);
+
+	LLPanel* createFactoryPanel(LLString name);
+
+	virtual LLView* createCtrlWidget(LLPanel *parent, LLXMLNodePtr node);
+	virtual void createWidget(LLPanel *parent, LLXMLNodePtr node);
+
+	// Creator library
+	typedef LLView* (*creator_function_t)(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	void registerCreator(LLString ctrlname, creator_function_t function);
+
+	static bool getLayeredXMLNode(const LLString &filename, LLXMLNodePtr& root);
+
+protected:
+
+
+	typedef std::map<LLViewHandle, LLString> built_panel_t;
+	built_panel_t mBuiltPanels;
+	typedef std::map<LLViewHandle, LLString> built_floater_t;
+	built_floater_t mBuiltFloaters;
+
+	std::deque<const LLCallbackMap::map_t*> mFactoryStack;
+
+	static const LLString sUICtrlNames[];
+
+	typedef std::map<LLString, creator_function_t> creator_list_t;
+	creator_list_t mCreatorFunctions;
+	static std::vector<LLString> mXUIPaths;
+};
+
+template<class T>
+class LLUICtrlCreator
+{
+public:
+	static void registerCreator(LLString name, LLUICtrlFactory *factory)
+	{
+		factory->registerCreator(name, T::fromXML);
+	}
+};
+
+#endif //LL_LLWIDGETFACTORY_H
diff --git a/indra/llui/lluistring.cpp b/indra/llui/lluistring.cpp
new file mode 100755
index 0000000000..8c5b587158
--- /dev/null
+++ b/indra/llui/lluistring.cpp
@@ -0,0 +1,87 @@
+/** 
+ * @file lluistring.cpp
+ * @brief LLUIString base class
+ *
+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "lluistring.h"
+
+// public
+
+LLUIString::LLUIString(const LLString& instring, const LLString::format_map_t& args)
+	: mOrig(instring),
+	  mArgs(args)
+{
+	format();
+}
+
+void LLUIString::assign(const LLString& s)
+{
+	mOrig = s;
+	format();
+}
+
+void LLUIString::setArgList(const LLString::format_map_t& args)
+{
+	mArgs = args;
+	format();
+}
+
+void LLUIString::setArg(const LLString& key, const LLString& replacement)
+{
+	mArgs[key] = replacement;
+	format();
+}
+
+void LLUIString::truncate(S32 maxchars)
+{
+	if (mWResult.size() > (size_t)maxchars)
+	{
+		LLWString::truncate(mWResult, maxchars);
+		mResult = wstring_to_utf8str(mWResult);
+	}
+}
+
+void LLUIString::erase(S32 charidx, S32 len)
+{
+	mWResult.erase(charidx, len);
+	mResult = wstring_to_utf8str(mWResult);
+}
+
+void LLUIString::insert(S32 charidx, const LLWString& wchars)
+{
+	mWResult.insert(charidx, wchars);
+	mResult = wstring_to_utf8str(mWResult);
+}
+
+void LLUIString::replace(S32 charidx, llwchar wc)
+{
+	mWResult[charidx] = wc;
+	mResult = wstring_to_utf8str(mWResult);
+}
+
+void LLUIString::clear()
+{
+	// Keep Args
+	mOrig.clear();
+	mResult.clear();
+	mWResult.clear();
+}
+
+void LLUIString::clearArgs()
+{
+	mArgs.clear();
+}
+
+// private
+
+void LLUIString::format()
+{
+	mResult = mOrig;
+	LLString::format(mResult, mArgs);
+	mWResult = utf8str_to_wstring(mResult);
+}
diff --git a/indra/llui/lluistring.h b/indra/llui/lluistring.h
new file mode 100755
index 0000000000..8c2e3c481c
--- /dev/null
+++ b/indra/llui/lluistring.h
@@ -0,0 +1,87 @@
+/** 
+ * @file lluistring.h
+ * @author: Steve Bennetts
+ * @brief LLUIString base class
+ *
+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLUISTRING_H
+#define LL_LLUISTRING_H
+
+// lluistring.h
+//
+// Copyright 2006, Linden Research, Inc.
+// Original aurthor: Steve
+
+#include "stdtypes.h"
+#include "llstring.h"
+#include <string>
+
+// Use this class to store translated text that may have arguments
+// e.g. "Welcome [USERNAME] to [SECONDLIFE]!"
+
+// Adding or changing an argument will update the result string, preserving the origianl
+// Thus, subsequent changes to arguments or even the original string will produce
+//  the correct result
+
+// Example Usage:
+// LLUIString mMessage("Welcome [USERNAME] to [SECONDLIFE]!");
+// mMessage.setArg("[USERNAME]", "Steve");
+// mMessage.setArg("[SECONDLIFE]", "Second Life");
+// llinfos << mMessage.getString().c_str() << llendl; // outputs "Welcome Steve to Second Life"
+// mMessage.setArg("[USERNAME]", "Joe");
+// llinfos << mMessage.getString().c_str() << llendl; // outputs "Welcome Joe to Second Life"
+// mMessage = "Recepción a la [SECONDLIFE] [USERNAME]"
+// mMessage.setArg("[SECONDLIFE]", "Segunda Vida");
+// llinfos << mMessage.getString().c_str() << llendl; // outputs "Recepción a la Segunda Vida Joe"
+
+// Implementation Notes:
+// Attempting to have operator[](const LLString& s) return mArgs[s] fails because we have
+// to call format() after the assignment happens.
+
+class LLUIString
+{
+public:
+	// These methods all perform appropriate argument substitution
+	// and modify mOrig where appropriate
+	LLUIString() {}
+	LLUIString(const LLString& instring, const LLString::format_map_t& args);
+	LLUIString(const LLString& instring) { assign(instring); }
+
+	void assign(const LLString& instring);
+	LLUIString& operator=(const LLString& s) { assign(s); return *this; }
+
+	void setArgList(const LLString::format_map_t& args);
+	void setArg(const LLString& key, const LLString& replacement);
+
+	const LLString& getString() const { return mResult; }
+	operator LLString() const { return mResult; }
+
+	const LLWString& getWString() const { return mWResult; }
+	operator LLWString() const { return mWResult; }
+
+	bool empty() const { return mWResult.empty(); }
+	S32 length() const { return mWResult.size(); }
+
+	void clear();
+	void clearArgs();
+	
+	// These utuilty functions are included for text editing.
+	// They do not affect mOrig and do not perform argument substitution
+	void truncate(S32 maxchars);
+	void erase(S32 charidx, S32 len);
+	void insert(S32 charidx, const LLWString& wchars);
+	void replace(S32 charidx, llwchar wc);
+	
+private:
+	void format();	
+	
+	LLString mOrig;
+	LLString mResult;
+	LLWString mWResult; // for displaying
+	LLString::format_map_t mArgs;
+};
+
+#endif // LL_LLUISTRING_H
diff --git a/indra/llui/llundo.cpp b/indra/llui/llundo.cpp
new file mode 100644
index 0000000000..61e17c1879
--- /dev/null
+++ b/indra/llui/llundo.cpp
@@ -0,0 +1,161 @@
+/** 
+ * @file llundo.cpp
+ * @brief LLUndo class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// Generic interface for undo/redo circular buffer
+
+#include "linden_common.h"
+
+#include "llundo.h"
+#include "llerror.h"
+
+
+// TODO:
+// implement doubly linked circular list for ring buffer
+// this will allow us to easily change the size of an undo buffer on the fly
+
+//-----------------------------------------------------------------------------
+// LLUndoBuffer()
+//-----------------------------------------------------------------------------
+LLUndoBuffer::LLUndoBuffer( LLUndoAction (*create_func()), S32 initial_count )
+{
+	mNextAction = 0;
+	mLastAction = 0;
+	mFirstAction = 0;
+	mOperationID = 0;
+
+	mNumActions = initial_count;	
+
+	mActions = new LLUndoAction *[initial_count];
+
+	//initialize buffer with actions
+	for (S32 i = 0; i < initial_count; i++)
+	{
+		mActions[i] = create_func();
+		if (!mActions[i])
+		{
+			llerrs << "Unable to create action for undo buffer" << llendl;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// ~LLUndoBuffer()
+//-----------------------------------------------------------------------------
+LLUndoBuffer::~LLUndoBuffer()
+{
+	for (S32 i = 0; i < mNumActions; i++)
+	{
+		delete mActions[i];
+	}
+
+	delete [] mActions;
+}
+
+//-----------------------------------------------------------------------------
+// getNextAction()
+//-----------------------------------------------------------------------------
+LLUndoAction *LLUndoBuffer::getNextAction(BOOL setClusterBegin)
+{
+	LLUndoAction *nextAction = mActions[mNextAction];
+
+	if (setClusterBegin)
+	{
+		mOperationID++;
+	}
+	mActions[mNextAction]->mClusterID = mOperationID;
+
+	mNextAction = (mNextAction + 1) % mNumActions;
+	mLastAction = mNextAction;
+
+	if (mNextAction == mFirstAction)
+	{
+		mActions[mFirstAction]->cleanup();
+		mFirstAction = (mFirstAction + 1) % mNumActions;
+	}
+
+	return nextAction;
+}
+
+//-----------------------------------------------------------------------------
+// undoAction()
+//-----------------------------------------------------------------------------
+BOOL LLUndoBuffer::undoAction()
+{
+	if (!canUndo())
+	{
+		return FALSE;
+	}
+
+	S32 prevAction = (mNextAction + mNumActions - 1) % mNumActions;
+
+	while(mActions[prevAction]->mClusterID == mOperationID)
+	{
+		// go ahead and decrement action index
+		mNextAction = prevAction;
+
+		// undo this action
+		mActions[mNextAction]->undo();
+
+		// we're at the first action, so we don't know if we've actually undid everything
+		if (mNextAction == mFirstAction)
+		{
+			mOperationID--;
+			return FALSE;
+		}
+
+		// do wrap-around of index, but avoid negative numbers for modulo operator
+		prevAction = (mNextAction + mNumActions - 1) % mNumActions;
+	}
+
+	mOperationID--;
+
+	return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// redoAction()
+//-----------------------------------------------------------------------------
+BOOL LLUndoBuffer::redoAction()
+{
+	if (!canRedo())
+	{
+		return FALSE;
+	}
+
+	mOperationID++;
+
+	while(mActions[mNextAction]->mClusterID == mOperationID)
+	{
+		if (mNextAction == mLastAction)
+		{
+			return FALSE;
+		}
+
+		mActions[mNextAction]->redo();
+
+		// do wrap-around of index
+		mNextAction = (mNextAction + 1) % mNumActions;
+	}
+
+	return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// flushActions()
+//-----------------------------------------------------------------------------
+void LLUndoBuffer::flushActions()
+{
+	for (S32 i = 0; i < mNumActions; i++)
+	{
+		mActions[i]->cleanup();
+	}
+	mNextAction = 0;
+	mLastAction = 0;
+	mFirstAction = 0;
+	mOperationID = 0;
+}
diff --git a/indra/llui/llundo.h b/indra/llui/llundo.h
new file mode 100644
index 0000000000..8d0428ad3e
--- /dev/null
+++ b/indra/llui/llundo.h
@@ -0,0 +1,52 @@
+/** 
+ * @file llundo.h
+ * @brief LLUndo class header file
+ *
+ * Copyright (c) 2000-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLUNDO_H
+#define LL_LLUNDO_H
+
+class LLUndoAction
+{
+	friend class LLUndoBuffer;
+protected:
+	S32		mClusterID;
+protected:
+	LLUndoAction(): mClusterID(0) {};
+	virtual ~LLUndoAction(){};
+
+public:
+	static LLUndoAction *create() { return NULL; }
+
+	virtual void undo() = 0;
+	virtual void redo() = 0;
+	virtual void cleanup() {};
+};
+
+class LLUndoBuffer
+{
+protected:
+	LLUndoAction **mActions;	// array of pointers to undoactions
+	S32			mNumActions;	// total number of actions in ring buffer
+	S32			mNextAction;	// next action to perform undo/redo on
+	S32			mLastAction;	// last action actually added to undo buffer
+	S32			mFirstAction;	// beginning of ring buffer (don't undo any further)
+	S32			mOperationID;	// current operation id, for undoing and redoing in clusters
+
+public:
+	LLUndoBuffer( LLUndoAction (*create_func()), S32 initial_count );
+	virtual ~LLUndoBuffer();
+
+	LLUndoAction *getNextAction(BOOL setClusterBegin = TRUE);
+	BOOL undoAction();
+	BOOL redoAction();
+	BOOL canUndo() { return (mNextAction != mFirstAction); }
+	BOOL canRedo() { return (mNextAction != mLastAction); }
+
+	void flushActions();
+};
+
+#endif //LL_LLUNDO_H
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
new file mode 100644
index 0000000000..f8d1504f3c
--- /dev/null
+++ b/indra/llui/llview.cpp
@@ -0,0 +1,2924 @@
+/** 
+ * @file llview.cpp
+ * @author James Cook
+ * @brief Container for other views, anything that draws.
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llview.h"
+
+#include "llstring.h"
+#include "llrect.h"
+#include "llgl.h"
+#include "llevent.h"
+#include "llfontgl.h"
+#include "llfocusmgr.h"
+#include "llglheaders.h"
+#include "llwindow.h"
+#include "llstl.h"
+#include "lluictrl.h"
+#include "llui.h"	// colors saved settings
+#include "v3color.h"
+#include "llstl.h"
+
+#include <boost/tokenizer.hpp>
+
+#include <assert.h>
+
+BOOL	LLView::sDebugRects = FALSE;
+BOOL	LLView::sDebugKeys = FALSE;
+S32		LLView::sDepth = 0;
+LLView* LLView::sFastFrameView = NULL;
+BOOL	LLView::sDebugMouseHandling = FALSE;
+LLString LLView::sMouseHandlerMessage;
+S32	LLView::sSelectID = GL_NAME_UI_RESERVED;
+BOOL	LLView::sEditingUI = FALSE;
+BOOL	LLView::sForceReshape = FALSE;
+LLView*	LLView::sEditingUIView = NULL;
+S32		LLView::sLastLeftXML = S32_MIN;
+S32		LLView::sLastBottomXML = S32_MIN;
+std::map<LLViewHandle,LLView*> LLView::sViewHandleMap;
+
+S32		LLViewHandle::sNextID = 0;
+LLViewHandle LLViewHandle::sDeadHandle;
+
+#if LL_DEBUG
+BOOL LLView::sIsDrawing = FALSE;
+#endif
+
+//static
+LLView* LLView::getViewByHandle(LLViewHandle handle)
+{
+	if (handle == LLViewHandle::sDeadHandle)
+	{
+		return NULL;
+	}
+	std::map<LLViewHandle,LLView*>::iterator iter = sViewHandleMap.find(handle);
+	if (iter != sViewHandleMap.end())
+	{
+		return iter->second;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+//static
+BOOL LLView::deleteViewByHandle(LLViewHandle handle)
+{
+	std::map<LLViewHandle,LLView*>::iterator iter = sViewHandleMap.find(handle);
+	if (iter != sViewHandleMap.end())
+	{
+		delete iter->second; // will remove from map
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+LLView::LLView() :
+	mParentView(NULL),
+	mReshapeFlags(FOLLOWS_NONE),
+	mDefaultTabGroup(0),
+	mEnabled(TRUE),
+	mMouseOpaque(TRUE),
+	mSoundFlags(MOUSE_UP), // default to only make sound on mouse up
+	mSaveToXML(TRUE),
+	mIsFocusRoot(FALSE),
+	mLastVisible(TRUE),
+	mRenderInFastFrame(TRUE),
+	mSpanChildren(FALSE),
+	mVisible(TRUE),
+	mHidden(FALSE),
+	mNextInsertionOrdinal(0)
+{
+	mViewHandle.init();
+	sViewHandleMap[mViewHandle] = this;
+}
+
+LLView::LLView(const LLString& name, BOOL mouse_opaque) :
+	mParentView(NULL),
+	mName(name),
+	mReshapeFlags(FOLLOWS_NONE),
+	mDefaultTabGroup(0),
+	mEnabled(TRUE),
+	mMouseOpaque(mouse_opaque),
+	mSoundFlags(MOUSE_UP), // default to only make sound on mouse up
+	mSaveToXML(TRUE),
+	mIsFocusRoot(FALSE),
+	mLastVisible(TRUE),
+	mRenderInFastFrame(TRUE),
+	mSpanChildren(FALSE),
+	mVisible(TRUE),
+	mHidden(FALSE),
+	mNextInsertionOrdinal(0)
+{
+	mViewHandle.init();
+	sViewHandleMap[mViewHandle] = this;
+}
+
+
+LLView::LLView(
+	const LLString& name, const LLRect& rect, BOOL mouse_opaque, U32 reshape) :
+	mParentView(NULL),
+	mName(name),
+	mRect(rect),
+	mReshapeFlags(reshape),
+	mDefaultTabGroup(0),
+	mEnabled(TRUE),
+	mMouseOpaque(mouse_opaque),
+	mSoundFlags(MOUSE_UP), // default to only make sound on mouse up
+	mSaveToXML(TRUE),
+	mIsFocusRoot(FALSE),
+	mLastVisible(TRUE),
+	mRenderInFastFrame(TRUE),
+	mSpanChildren(FALSE),
+	mVisible(TRUE),
+	mHidden(FALSE),
+	mNextInsertionOrdinal(0)
+{
+	mViewHandle.init();
+	sViewHandleMap[mViewHandle] = this;
+}
+
+
+LLView::~LLView()
+{
+	//llinfos << "Deleting view " << mName << ":" << (void*) this << llendl;
+// 	llassert(LLView::sIsDrawing == FALSE);
+	if( gFocusMgr.getKeyboardFocus() == this )
+	{
+		llwarns << "View holding keyboard focus deleted: " << getName() << ".  Keyboard focus removed." << llendl;
+		gFocusMgr.removeKeyboardFocusWithoutCallback( this );
+	}
+
+	if( gFocusMgr.getMouseCapture() == this )
+	{
+		llwarns << "View holding mouse capture deleted: " << getName() << ".  Mouse capture removed." << llendl;
+		gFocusMgr.removeMouseCaptureWithoutCallback( this );
+	}
+
+	if( gFocusMgr.getTopView() == this )
+	{
+		llwarns << "View holding top view deleted: " << getName() << ".  Top view removed." << llendl;
+		gFocusMgr.removeTopViewWithoutCallback( this );
+	}
+
+	sViewHandleMap.erase(mViewHandle);
+
+	deleteAllChildren();
+
+	if (mParentView != NULL)
+	{
+		mParentView->removeChild(this);
+	}
+
+	if(LLView::sFastFrameView == this)
+	{
+		LLView::sFastFrameView = NULL;
+	}
+
+	dispatch_list_t::iterator itor;
+	for (itor = mDispatchList.begin(); itor != mDispatchList.end(); ++itor)
+	{
+		(*itor).second->clearDispatchers();
+		delete (*itor).second;
+	}
+}
+
+// virtual
+BOOL LLView::isView()
+{
+	return TRUE;
+}
+
+// virtual
+BOOL LLView::isCtrl() const
+{
+	return FALSE;
+}
+
+// virtual
+BOOL LLView::isPanel()
+{
+	return FALSE;
+}
+
+void LLView::setMouseOpaque(BOOL b)
+{
+	mMouseOpaque = b;
+}
+
+void LLView::setToolTip(const LLString& msg)
+{
+	mToolTipMsg = msg;
+}
+
+// virtual
+void LLView::setRect(const LLRect& rect)
+{
+	mRect = rect;
+}
+
+
+void LLView::setFollows(U32 flags)			
+{
+	mReshapeFlags = flags;
+}
+
+void LLView::setFollowsNone() 				
+{
+	mReshapeFlags = FOLLOWS_NONE; 
+}
+
+void LLView::setFollowsLeft()				
+{
+	mReshapeFlags |= FOLLOWS_LEFT; 
+}
+
+void LLView::setFollowsTop()					
+{
+	mReshapeFlags |= FOLLOWS_TOP; 
+}
+
+void LLView::setFollowsRight()				
+{
+	mReshapeFlags |= FOLLOWS_RIGHT;
+}
+
+void LLView::setFollowsBottom()				
+{
+	mReshapeFlags |= FOLLOWS_BOTTOM;
+}
+
+void LLView::setFollowsAll()					
+{
+	mReshapeFlags |= FOLLOWS_ALL;
+}
+
+void LLView::setSoundFlags(U8 flags)         
+{
+	mSoundFlags = flags;
+}
+
+void LLView::setName(LLString name)			
+{
+	mName = name;
+}
+
+void LLView::setSpanChildren( BOOL span_children ) 
+{
+	mSpanChildren = span_children; updateRect();
+}
+
+const LLString& LLView::getToolTip()
+{
+	return mToolTipMsg;
+}
+
+// virtual
+const LLString& LLView::getName() const
+{
+	static const LLString unnamed("(no name)");
+	return mName.empty() ? unnamed : mName;
+}
+
+void LLView::sendChildToFront(LLView* child)
+{
+	if (child->mParentView == this) 
+	{
+		mChildList.remove( child );
+		mChildList.push_front(child);
+	}
+}
+
+void LLView::sendChildToBack(LLView* child)
+{
+	if (child->mParentView == this) 
+	{
+		mChildList.remove( child );
+		mChildList.push_back(child);
+	}
+}
+
+void LLView::moveChildToFrontOfTabGroup(LLUICtrl* child)
+{
+	if(mCtrlOrder.find(child) != mCtrlOrder.end())
+	{
+		mCtrlOrder[child].second = -1 * mNextInsertionOrdinal++;
+	}
+}
+
+void LLView::addChild(LLView* child, S32 tab_group)
+{
+	// remove from current parent
+	if (child->mParentView) 
+	{
+		child->mParentView->removeChild(child);
+	}
+
+	// add to front of child list, as normal
+	mChildList.push_front(child);
+
+	// add to ctrl list if is LLUICtrl
+	if (child->isCtrl())
+	{
+		// controls are stored in reverse order from render order
+		addCtrlAtEnd((LLUICtrl*) child, tab_group);
+	}
+
+	child->mParentView = this;
+	updateRect();
+}
+
+
+void LLView::addChildAtEnd(LLView* child, S32 tab_group)
+{
+	// remove from current parent
+	if (child->mParentView) 
+	{
+		child->mParentView->removeChild(child);
+	}
+
+	// add to back of child list
+	mChildList.push_back(child);
+
+	// add to ctrl list if is LLUICtrl
+	if (child->isCtrl())
+	{
+		// controls are stored in reverse order from render order
+		addCtrl((LLUICtrl*) child, tab_group);
+	}
+	
+	child->mParentView = this;
+	updateRect();
+}
+
+// remove the specified child from the view, and set it's parent to NULL.
+void LLView::removeChild( LLView* child )
+{
+	if (child->mParentView == this) 
+	{
+		mChildList.remove( child );
+		child->mParentView = NULL;
+	}
+	else
+	{
+		llerrs << "LLView::removeChild called with non-child" << llendl;
+	}
+
+	if (child->isCtrl())
+	{
+		removeCtrl((LLUICtrl*)child);
+	}
+}
+
+void LLView::addCtrlAtEnd(LLUICtrl* ctrl, S32 tab_group)
+{
+	mCtrlOrder.insert(tab_order_pair_t(ctrl,
+								tab_order_t(tab_group, mNextInsertionOrdinal++)));
+}
+
+void LLView::addCtrl( LLUICtrl* ctrl, S32 tab_group)
+{
+	// add to front of list by using negative ordinal, which monotonically increases
+	mCtrlOrder.insert(tab_order_pair_t(ctrl,
+								tab_order_t(tab_group, -1 * mNextInsertionOrdinal++)));
+}
+
+void LLView::removeCtrl(LLUICtrl* ctrl)
+{
+	child_tab_order_t::iterator found = mCtrlOrder.find(ctrl);
+	if(found != mCtrlOrder.end())
+	{
+		mCtrlOrder.erase(found);
+	}
+}
+
+S32 LLView::getDefaultTabGroup() const { return mDefaultTabGroup; }
+
+LLView::ctrl_list_t LLView::getCtrlList() const
+{
+	ctrl_list_t controls;
+	for(child_list_const_iter_t iter = mChildList.begin();
+		iter != mChildList.end();
+		iter++)
+	{
+		if((*iter)->isCtrl())
+		{
+			controls.push_back(static_cast<LLUICtrl*>(*iter));
+		}
+	}
+	return controls;
+}
+
+LLView::ctrl_list_t LLView::getCtrlListSorted() const
+{
+	ctrl_list_t controls = getCtrlList();
+	std::sort(controls.begin(), controls.end(), LLCompareByTabOrder(mCtrlOrder));
+	return controls;
+}
+
+LLCompareByTabOrder::LLCompareByTabOrder(LLView::child_tab_order_t order): mTabOrder(order) {}
+
+bool LLCompareByTabOrder::compareTabOrders(const LLView::tab_order_t & a, const LLView::tab_order_t & b) const
+{
+	return a < b;
+}
+
+// This method compares two LLViews by the tab order specified in the comparator object.  The
+// code for this is a little convoluted because each argument can have four states:
+// 1) not a control, 2) a control but not in the tab order, 3) a control in the tab order, 4) null
+bool LLCompareByTabOrder::operator() (const LLView* const a, const LLView* const b) const
+{
+	S32 a_score = 0, b_score = 0;
+	if(a) a_score--;
+	if(b) b_score--;
+	if(a && a->isCtrl()) a_score--;
+	if(b && b->isCtrl()) b_score--;
+	if(a_score == -2 && b_score == -2)
+	{
+		const LLUICtrl * const a_ctrl = static_cast<const LLUICtrl* const>(a);
+		const LLUICtrl * const b_ctrl = static_cast<const LLUICtrl* const>(b);
+		LLView::child_tab_order_const_iter_t a_found = mTabOrder.find(a_ctrl), b_found = mTabOrder.find(b_ctrl);
+		if(a_found != mTabOrder.end()) a_score--;
+		if(b_found != mTabOrder.end()) b_score--;
+		if(a_score == -3 && b_score == -3)
+		{
+			// whew!  Once we're in here, they're both in the tab order, and we can compare based on that
+			return compareTabOrders(a_found->second, b_found->second);
+		}
+	}
+	return (a_score == b_score) ? a < b : a_score < b_score;
+}
+
+BOOL LLView::isInVisibleChain() const
+{
+	const LLView* cur_view = this;
+	while(cur_view)
+	{
+		if (!cur_view->getVisible())
+		{
+			return FALSE;
+		}
+		cur_view = cur_view->getParent();
+	}
+	return TRUE;
+}
+
+BOOL LLView::isInEnabledChain() const
+{
+	const LLView* cur_view = this;
+	while(cur_view)
+	{
+		if (!cur_view->getEnabled())
+		{
+			return FALSE;
+		}
+		cur_view = cur_view->getParent();
+	}
+	return TRUE;
+}
+
+BOOL LLView::isFocusRoot() const
+{
+	return mIsFocusRoot;
+}
+
+LLView* LLView::findRootMostFocusRoot() 
+{
+	LLView* focus_root = NULL;
+	LLView* next_view = this;
+	while(next_view)
+	{
+		if (next_view->isFocusRoot())
+		{
+			focus_root = next_view;
+		}
+		next_view = next_view->getParent();
+	}
+	return focus_root;
+}
+
+BOOL LLView::canFocusChildren() const
+{
+	return TRUE;
+}
+
+BOOL LLView::focusNextRoot()
+{
+	LLView::child_list_t result = LLView::getFocusRootsQuery().run(this);
+	return LLView::focusNext(result);
+}
+
+BOOL LLView::focusPrevRoot()
+{
+	LLView::child_list_t result = LLView::getFocusRootsQuery().run(this);
+	return LLView::focusPrev(result);
+}
+
+BOOL LLView::focusNextItem(BOOL text_fields_only)
+{
+	// this assumes that this method is called on the focus root.
+	LLCtrlQuery query = LLView::getTabOrderQuery();
+	if(text_fields_only || LLUI::sConfigGroup->getBOOL("TabToTextFieldsOnly"))
+	{
+		query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance());
+	}
+	LLView::child_list_t result = query(this);
+	return LLView::focusNext(result);
+}
+
+BOOL LLView::focusPrevItem(BOOL text_fields_only)
+{
+	// this assumes that this method is called on the focus root.
+	LLCtrlQuery query = LLView::getTabOrderQuery();
+	if(text_fields_only || LLUI::sConfigGroup->getBOOL("TabToTextFieldsOnly"))
+	{
+		query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance());
+	}
+	LLView::child_list_t result = query(this);
+	return LLView::focusPrev(result);
+}
+
+
+// static
+BOOL LLView::focusNext(LLView::child_list_t & result)
+{
+	LLView::child_list_iter_t focused = result.end();
+	for(LLView::child_list_iter_t iter = result.begin();
+		iter != result.end();
+		++iter)
+	{
+		if(gFocusMgr.childHasKeyboardFocus(*iter))
+		{
+			focused = iter;
+			break;
+		}
+	}
+	LLView::child_list_iter_t next = focused;
+	next = (next == result.end()) ? result.begin() : ++next;
+	while(next != focused)
+	{
+		// wrap around to beginning if necessary
+		if(next == result.end())
+		{
+			next = result.begin();
+		}
+		if((*next)->isCtrl())
+		{
+			LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
+			ctrl->setFocus(TRUE);
+			ctrl->onTabInto();  
+			gFocusMgr.triggerFocusFlash();
+			return TRUE;
+		}
+		++next;
+	}
+	return FALSE;
+}
+
+// static
+BOOL LLView::focusPrev(LLView::child_list_t & result)
+{
+	LLView::child_list_reverse_iter_t focused = result.rend();
+	for(LLView::child_list_reverse_iter_t iter = result.rbegin();
+		iter != result.rend();
+		++iter)
+	{
+		if(gFocusMgr.childHasKeyboardFocus(*iter))
+		{
+			focused = iter;
+			break;
+		}
+	}
+	LLView::child_list_reverse_iter_t next = focused;
+	next = (next == result.rend()) ? result.rbegin() : ++next;
+	while(next != focused)
+	{
+		// wrap around to beginning if necessary
+		if(next == result.rend())
+		{
+			next = result.rbegin();
+		}
+		if((*next)->isCtrl())
+		{
+			LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
+			if (!ctrl->hasFocus())
+			{
+				ctrl->setFocus(TRUE);
+				ctrl->onTabInto();  
+				gFocusMgr.triggerFocusFlash();
+			}
+			return TRUE;
+		}
+		++next;
+	}
+	return FALSE;
+}
+
+BOOL LLView::focusFirstItem(BOOL prefer_text_fields)
+{
+	// search for text field first
+	if(prefer_text_fields)
+	{
+		LLCtrlQuery query = LLView::getTabOrderQuery();
+		query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance());
+		LLView::child_list_t result = query(this);
+		if(result.size() > 0)
+		{
+			LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front());
+			if(!ctrl->hasFocus())
+			{
+				ctrl->setFocus(TRUE);
+				ctrl->onTabInto();  
+				gFocusMgr.triggerFocusFlash();
+			}
+			return TRUE;
+		}
+	}
+	// no text field found, or we don't care about text fields
+	LLView::child_list_t result = LLView::getTabOrderQuery().run(this);
+	if(result.size() > 0)
+	{
+		LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front());
+		if(!ctrl->hasFocus())
+		{
+			ctrl->setFocus(TRUE);
+			ctrl->onTabInto();  
+			gFocusMgr.triggerFocusFlash();
+		}
+		return TRUE;
+	}	
+	return FALSE;
+}
+
+BOOL LLView::focusLastItem(BOOL prefer_text_fields)
+{
+	// search for text field first
+	if(prefer_text_fields)
+	{
+		LLCtrlQuery query = LLView::getTabOrderQuery();
+		query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance());
+		LLView::child_list_t result = query(this);
+		if(result.size() > 0)
+		{
+			LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.back());
+			if(!ctrl->hasFocus())
+			{
+				ctrl->setFocus(TRUE);
+				ctrl->onTabInto();  
+				gFocusMgr.triggerFocusFlash();
+			}
+			return TRUE;
+		}
+	}
+	// no text field found, or we don't care about text fields
+	LLView::child_list_t result = LLView::getTabOrderQuery().run(this);
+	if(result.size() > 0)
+	{
+		LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.back());
+		if(!ctrl->hasFocus())
+		{
+			ctrl->setFocus(TRUE);
+			ctrl->onTabInto();  
+			gFocusMgr.triggerFocusFlash();
+		}
+		return TRUE;
+	}	
+	return FALSE;
+}
+
+
+
+// delete all children. Override this function if you need to
+// perform any extra clean up such as cached pointers to selected
+// children, etc.
+void LLView::deleteAllChildren()
+{
+	// clear out the control ordering
+	mCtrlOrder.clear();
+
+	while (!mChildList.empty())
+	{
+		LLView* viewp = mChildList.front();
+		delete viewp; // will remove the child from mChildList
+	}
+}
+
+void LLView::setAllChildrenEnabled(BOOL b)
+{
+	for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		viewp->setEnabled(b);
+	}
+}
+
+// virtual
+void LLView::setTentative(BOOL b)
+{
+}
+
+// virtual
+BOOL LLView::getTentative() const
+{
+	return FALSE;
+}
+
+// virtual
+void LLView::setEnabled(BOOL enabled)
+{
+	mEnabled = enabled;
+}
+
+// virtual
+void LLView::setVisible(BOOL visible)
+{
+	if( !visible && (gFocusMgr.getTopView() == this) )
+	{
+		gFocusMgr.setTopView( NULL, NULL );
+	}
+
+	if ( mVisible != visible )
+	{
+		// tell all children of this view that the visibility may have changed
+		onVisibilityChange ( visible );
+	}
+
+	mVisible = visible;
+}
+
+// virtual
+void LLView::setHidden(BOOL hidden)
+{
+	mHidden = hidden;
+}
+
+// virtual
+BOOL LLView::setLabelArg(const LLString& key, const LLString& text)
+{
+	return FALSE;
+}
+
+void LLView::onVisibilityChange ( BOOL curVisibilityIn )
+{
+	for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		// only views that are themselves visible will have their overall visibility affected by their ancestors
+		if (viewp->getVisible())
+		{
+			viewp->onVisibilityChange ( curVisibilityIn );
+		}
+	}
+}
+
+// virtual
+void LLView::translate(S32 x, S32 y)
+{
+	mRect.translate(x, y);
+}
+
+// virtual
+BOOL LLView::canSnapTo(LLView* other_view)
+{
+	return other_view->getVisible();
+}
+
+// virtual
+void LLView::snappedTo(LLView* snap_view)
+{
+}
+
+BOOL LLView::handleHover(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = childrenHandleHover( x, y, mask ) != NULL;
+	if( !handled && mMouseOpaque && pointInView( x, y ) )
+	{
+		LLUI::sWindow->setCursor(UI_CURSOR_ARROW);
+		lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << llendl;
+		handled = TRUE;
+	}
+
+	return handled;
+}
+
+BOOL LLView::handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect_screen)
+{
+	BOOL handled = FALSE;
+
+    LLString tool_tip;
+
+	if ( getVisible() && getEnabled())
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if( viewp->handleToolTip(local_x, local_y, msg, sticky_rect_screen ) )
+			{
+				handled = TRUE;
+				break;
+			}
+		}
+
+		if (LLUI::sShowXUINames && (mToolTipMsg.find(".xml", 0) == LLString::npos) && 
+			(mName.find("Drag", 0) == LLString::npos))
+		{
+			tool_tip = mName;
+		}
+		else
+		{
+			tool_tip = mToolTipMsg;
+		}
+		
+
+
+		BOOL showNamesTextBox = LLUI::sShowXUINames && (getWidgetType() == WIDGET_TYPE_TEXT_BOX);
+
+		if( !handled && (mMouseOpaque || showNamesTextBox) && pointInView( x, y ) && !tool_tip.empty())
+		{
+
+			msg = tool_tip;
+
+			// Convert rect local to screen coordinates
+			localPointToScreen(
+				0, 0,
+				&(sticky_rect_screen->mLeft), &(sticky_rect_screen->mBottom) );
+			localPointToScreen(
+				mRect.getWidth(), mRect.getHeight(),
+				&(sticky_rect_screen->mRight), &(sticky_rect_screen->mTop) );
+			
+			handled = TRUE;
+		}
+	}
+
+	return handled;
+}
+
+
+BOOL LLView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+
+	if( called_from_parent )
+	{
+		// Downward traversal
+		if (getVisible() && mEnabled)
+		{
+			handled = childrenHandleKey( key, mask ) != NULL;
+		}
+	}
+
+	if( !handled )
+	{
+		// JC: Must pass to disabled views, since they could have
+		// keyboard focus, which requires the escape key to exit.
+		if (getVisible())
+		{
+			handled = handleKeyHere( key, mask, called_from_parent );
+			if (handled && LLView::sDebugKeys)
+			{
+				llinfos << "Key handled by " << getName() << llendl;
+			}
+		}
+	}
+
+	if( !handled && !called_from_parent)
+	{
+		if (mIsFocusRoot)
+		{
+			// stop processing at focus root
+			handled = FALSE;
+		}
+		else if (mParentView)
+		{
+			// Upward traversal
+			handled = mParentView->handleKey( key, mask, FALSE );
+		}
+	}
+	return handled;
+}
+
+// Called from handleKey()
+// Handles key in this object.  Checking parents and children happens in handleKey()
+BOOL LLView::handleKeyHere(KEY key, MASK mask, BOOL called_from_parent)
+{
+	return FALSE;
+}
+
+
+BOOL LLView::handleUnicodeChar(llwchar uni_char, BOOL called_from_parent)
+{
+	BOOL handled = FALSE;
+
+	/*
+	if( called_from_parent )
+	{
+		// Downward traversal
+		if (getVisible() && mEnabled)
+		{
+			handled = childrenHandleKey( key, mask ) != NULL;
+		}
+	}
+	*/
+
+	// JC: Must pass to disabled views, since they could have
+	// keyboard focus, which requires the escape key to exit.
+	if (getVisible())
+	{
+		handled = handleUnicodeCharHere(uni_char, called_from_parent);
+		if (handled && LLView::sDebugKeys)
+		{
+			llinfos << "Unicode key handled by " << getName() << llendl;
+		}
+	}
+
+
+	if (!handled && !called_from_parent)
+	{
+		if (mIsFocusRoot)
+		{
+			// stop processing at focus root
+			handled = FALSE;
+		}
+		else if(mParentView)
+		{
+			// Upward traversal
+			handled = mParentView->handleUnicodeChar(uni_char, FALSE);
+		}
+	}
+
+	return handled;
+}
+
+
+BOOL LLView::handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent )
+{
+	return FALSE;
+}
+
+
+BOOL LLView::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
+							   EDragAndDropType cargo_type, void* cargo_data,
+							   EAcceptance* accept,
+							   LLString& tooltip_msg)
+{
+	// CRO this is an experiment to allow drag and drop into object inventory based on the DragAndDrop tool's permissions rather than the parent
+	BOOL handled = childrenHandleDragAndDrop( x, y, mask, drop,
+											cargo_type,
+											cargo_data,
+											accept,
+											tooltip_msg) != NULL;
+	if( !handled && mMouseOpaque )
+	{
+		*accept = ACCEPT_NO;
+		handled = TRUE;
+		lldebugst(LLERR_USER_INPUT) << "dragAndDrop handled by LLView " << getName() << llendl;
+	}
+
+	return handled;
+}
+
+LLView* LLView::childrenHandleDragAndDrop(S32 x, S32 y, MASK mask,
+									   BOOL drop,
+									   EDragAndDropType cargo_type,
+									   void* cargo_data,
+									   EAcceptance* accept,
+									   LLString& tooltip_msg)
+{
+	LLView* handled_view = FALSE;
+	// CRO this is an experiment to allow drag and drop into object inventory based on the DragAndDrop tool's permissions rather than the parent
+	if( getVisible() )
+//	if( getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if( viewp->pointInView(local_x, local_y) && 
+				viewp->getVisible() &&
+				viewp->mEnabled &&
+				viewp->handleDragAndDrop(local_x, local_y, mask, drop,
+										 cargo_type,
+										 cargo_data,
+										 accept,
+										 tooltip_msg))
+			{
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+	return handled_view;
+}
+
+
+
+BOOL LLView::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = childrenHandleMouseUp( x, y, mask ) != NULL;
+	if( !handled && mMouseOpaque )
+	{
+		handled = TRUE;
+	}
+	return handled;
+}
+
+BOOL LLView::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	LLView* handled_view = childrenHandleMouseDown( x, y, mask );
+	BOOL handled = (handled_view != NULL);
+	if( !handled && mMouseOpaque )
+	{
+		handled = TRUE;
+		handled_view = this;
+	}
+
+	// HACK If we're editing UI, select the leaf view that ate the click.
+	if (sEditingUI && handled_view)
+	{
+		// need to find leaf views, big hack
+		EWidgetType type = handled_view->getWidgetType();
+		if (type == WIDGET_TYPE_BUTTON
+			|| type == WIDGET_TYPE_LINE_EDITOR
+			|| type == WIDGET_TYPE_TEXT_EDITOR
+			|| type == WIDGET_TYPE_TEXT_BOX)
+		{
+			sEditingUIView = handled_view;
+		}
+	}
+
+	return handled;
+}
+
+BOOL LLView::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = childrenHandleDoubleClick( x, y, mask ) != NULL;
+	if( !handled && mMouseOpaque )
+	{
+		handleMouseDown(x, y, mask);
+		handled = TRUE;
+	}
+	return handled;
+}
+
+BOOL LLView::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	BOOL handled = FALSE;
+	if( getVisible() && mEnabled )
+	{
+		handled = childrenHandleScrollWheel( x, y, clicks ) != NULL;
+		if( !handled && mMouseOpaque )
+		{
+			handled = TRUE;
+		}
+	}
+	return handled;
+}
+
+BOOL LLView::handleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = childrenHandleRightMouseDown( x, y, mask ) != NULL;
+	if( !handled && mMouseOpaque )
+	{
+		handled = TRUE;
+	}
+	return handled;
+}
+
+BOOL LLView::handleRightMouseUp(S32 x, S32 y, MASK mask)
+{
+	BOOL handled = childrenHandleRightMouseUp( x, y, mask ) != NULL;
+	if( !handled && mMouseOpaque )
+	{
+		handled = TRUE;
+	}
+	return handled;
+}
+
+LLView* LLView::childrenHandleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	LLView* handled_view = NULL;
+	if (getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if (viewp->pointInView(local_x, local_y) && 
+				viewp->handleScrollWheel( local_x, local_y, clicks ))
+			{
+				if (sDebugMouseHandling)
+				{
+					sMouseHandlerMessage = LLString("->") + viewp->mName.c_str() + sMouseHandlerMessage;
+				}
+
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+	return handled_view;
+}
+
+LLView* LLView::childrenHandleHover(S32 x, S32 y, MASK mask)
+{
+	LLView* handled_view = NULL;
+	if (getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if(viewp->pointInView(local_x, local_y) &&
+				viewp->getVisible() &&
+				viewp->getEnabled() &&
+				viewp->handleHover(local_x, local_y, mask) )
+			{
+				if (sDebugMouseHandling)
+				{
+					sMouseHandlerMessage = LLString("->") + viewp->mName.c_str() + sMouseHandlerMessage;
+				}
+
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+	return handled_view;
+}
+
+// Called during downward traversal
+LLView* LLView::childrenHandleKey(KEY key, MASK mask)
+{
+	LLView* handled_view = NULL;
+
+	if ( getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			if (viewp->handleKey(key, mask, TRUE))
+			{
+				if (LLView::sDebugKeys)
+				{
+					llinfos << "Key handled by " << viewp->getName() << llendl;
+				}
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+
+	return handled_view;
+}
+
+
+LLView* LLView::childrenHandleMouseDown(S32 x, S32 y, MASK mask)
+{
+	LLView* handled_view = NULL;
+
+	for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+	{
+		LLView* viewp = *child_it;
+		S32 local_x = x - viewp->mRect.mLeft;
+		S32 local_y = y - viewp->mRect.mBottom;
+
+		if (viewp->pointInView(local_x, local_y) && 
+			viewp->getVisible() && 
+			viewp->mEnabled && 
+			viewp->handleMouseDown( local_x, local_y, mask ))
+		{
+			if (sDebugMouseHandling)
+			{
+				sMouseHandlerMessage = LLString("->") + viewp->mName.c_str() + sMouseHandlerMessage;
+			}
+			handled_view = viewp;
+			break;
+		}
+	}
+	return handled_view;
+}
+
+LLView* LLView::childrenHandleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	LLView* handled_view = NULL;
+
+	if (getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if (viewp->pointInView(local_x, local_y) &&
+				viewp->getVisible() &&
+				viewp->mEnabled &&
+				viewp->handleRightMouseDown( local_x, local_y, mask ))
+			{
+				if (sDebugMouseHandling)
+				{
+					sMouseHandlerMessage = LLString("->") + viewp->mName.c_str() + sMouseHandlerMessage;
+				}
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+	return handled_view;
+}
+
+LLView* LLView::childrenHandleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	LLView* handled_view = NULL;
+
+	if (getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if (viewp->pointInView(local_x, local_y) &&
+				viewp->getVisible() &&
+				viewp->mEnabled &&
+				viewp->handleDoubleClick( local_x, local_y, mask ))
+			{
+				if (sDebugMouseHandling)
+				{
+					sMouseHandlerMessage = LLString("->") + viewp->mName.c_str() + sMouseHandlerMessage;
+				}
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+	return handled_view;
+}
+
+LLView* LLView::childrenHandleMouseUp(S32 x, S32 y, MASK mask)
+{
+	LLView* handled_view = NULL;
+	if( getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if (!viewp->pointInView(local_x, local_y))
+				continue;
+			if (!viewp->getVisible())
+				continue;
+			if (!viewp->mEnabled)
+				continue;
+			if (viewp->handleMouseUp( local_x, local_y, mask ))
+			{
+				if (sDebugMouseHandling)
+				{
+					sMouseHandlerMessage = LLString("->") + viewp->mName.c_str() + sMouseHandlerMessage;
+				}
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+	return handled_view;
+}
+
+LLView* LLView::childrenHandleRightMouseUp(S32 x, S32 y, MASK mask)
+{
+	LLView* handled_view = NULL;
+	if( getVisible() && mEnabled )
+	{
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			S32 local_x = x - viewp->mRect.mLeft;
+			S32 local_y = y - viewp->mRect.mBottom;
+			if (viewp->pointInView(local_x, local_y) &&
+				viewp->getVisible() &&
+				viewp->mEnabled &&
+				viewp->handleRightMouseUp( local_x, local_y, mask ))
+			{
+				if (sDebugMouseHandling)
+				{
+					sMouseHandlerMessage = LLString("->") + viewp->mName.c_str() + sMouseHandlerMessage;
+				}
+				handled_view = viewp;
+				break;
+			}
+		}
+	}
+	return handled_view;
+}
+
+
+void LLView::draw()
+{
+	if (getVisible())
+	{
+		if (sDebugRects)
+		{
+			drawDebugRect();
+
+			// Check for bogus rectangle
+			if (mRect.mRight <= mRect.mLeft
+				|| mRect.mTop <= mRect.mBottom)
+			{
+				llwarns << "Bogus rectangle for " << getName() << " with " << mRect << llendl;
+			}
+		}
+
+		LLRect rootRect = getRootView()->getRect();
+		LLRect screenRect;
+
+		// draw focused control on top of everything else
+		LLView* focus_view = gFocusMgr.getKeyboardFocus();
+		if (focus_view && focus_view->getParent() != this)
+		{
+			focus_view = NULL;
+		}
+
+		for (child_list_reverse_iter_t child_iter = mChildList.rbegin(); child_iter != mChildList.rend(); ++child_iter)
+		{
+			LLView *viewp = *child_iter;
+			++sDepth;
+
+			if (viewp->getVisible() && viewp != focus_view)
+			{
+				// Only draw views that are within the root view
+				localRectToScreen(viewp->getRect(),&screenRect);
+				if ( rootRect.rectInRect(&screenRect) )
+				{
+					glMatrixMode(GL_MODELVIEW);
+					LLUI::pushMatrix();
+					{
+						LLUI::translate((F32)viewp->getRect().mLeft, (F32)viewp->getRect().mBottom, 0.f);
+						viewp->draw();
+					}
+					LLUI::popMatrix();
+				}
+			}
+
+			--sDepth;
+		}
+
+		if (focus_view && focus_view->getVisible())
+		{
+			drawChild(focus_view);
+		}
+
+		// HACK
+		if (sEditingUI && this == sEditingUIView)
+		{
+			drawDebugRect();
+		}
+	}
+}
+
+//Draw a box for debugging.
+void LLView::drawDebugRect()
+{
+	// drawing solids requires texturing be disabled
+	LLGLSNoTexture no_texture;
+
+	// draw red rectangle for the border
+	LLColor4 border_color(0.f, 0.f, 0.f, 1.f);
+	if (sEditingUI)
+	{
+		border_color.mV[0] = 1.f;
+	}
+	else
+	{
+		border_color.mV[sDepth%3] = 1.f;
+	}
+
+	glColor4fv( border_color.mV );
+
+	glBegin(GL_LINES);
+		glVertex2i(0, mRect.getHeight() - 1);
+		glVertex2i(0, 0);
+
+		glVertex2i(0, 0);
+		glVertex2i(mRect.getWidth() - 1, 0);
+
+		glVertex2i(mRect.getWidth() - 1, 0);
+		glVertex2i(mRect.getWidth() - 1, mRect.getHeight() - 1);
+
+		glVertex2i(mRect.getWidth() - 1, mRect.getHeight() - 1);
+		glVertex2i(0, mRect.getHeight() - 1);
+	glEnd();
+
+	// Draw the name if it's not a leaf node
+	if (mChildList.size() && !sEditingUI)
+	{
+		//char temp[256];
+		S32 x, y;
+		glColor4fv( border_color.mV );
+		x = mRect.getWidth()/2;
+		y = mRect.getHeight()/2;
+		LLString debug_text = llformat("%s (%d x %d)", getName().c_str(),
+									   mRect.getWidth(), mRect.getHeight());
+		LLFontGL::sSansSerifSmall->renderUTF8(debug_text, 0, (F32)x, (F32)y, border_color,
+											  LLFontGL::HCENTER, LLFontGL::BASELINE, LLFontGL::NORMAL,
+											  S32_MAX, S32_MAX, NULL, FALSE);
+	}
+}
+
+void LLView::drawChild(LLView* childp, S32 x_offset, S32 y_offset)
+{
+	if (childp && childp->getParent() == this)
+	{
+		++sDepth;
+
+		if (childp->getVisible())
+		{
+			glMatrixMode(GL_MODELVIEW);
+			LLUI::pushMatrix();
+			{
+				LLUI::translate((F32)childp->getRect().mLeft + x_offset, (F32)childp->getRect().mBottom + y_offset, 0.f);
+				childp->draw();
+			}
+			LLUI::popMatrix();
+		}
+
+		--sDepth;
+	}
+}
+
+
+void LLView::reshape(S32 width, S32 height, BOOL called_from_parent)
+{
+	// make sure this view contains all its children
+	updateRect();
+
+	// compute how much things changed and apply reshape logic to children
+	S32 delta_width = width - mRect.getWidth();
+	S32 delta_height = height - mRect.getHeight();
+
+	if (delta_width || delta_height || sForceReshape)
+	{
+		// adjust our rectangle
+		mRect.mRight = mRect.mLeft + width;
+		mRect.mTop = mRect.mBottom + height;
+
+		// move child views according to reshape flags
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			LLRect child_rect( viewp->mRect );
+
+			if (viewp->followsRight() && viewp->followsLeft())
+			{
+				child_rect.mRight += delta_width;
+			}
+			else if (viewp->followsRight())
+			{
+				child_rect.mLeft += delta_width;
+				child_rect.mRight += delta_width;
+			}
+			else if (viewp->followsLeft())
+			{
+				// left is 0, don't need to adjust coords
+			}
+			else
+			{
+				// BUG what to do when we don't follow anyone?
+				// for now, same as followsLeft
+			}
+
+			if (viewp->followsTop() && viewp->followsBottom())
+			{
+				child_rect.mTop += delta_height;
+			}
+			else if (viewp->followsTop())
+			{
+				child_rect.mTop += delta_height;
+				child_rect.mBottom += delta_height;
+			}
+			else if (viewp->followsBottom())
+			{
+				// bottom is 0, so don't need to adjust coords
+			}
+			else
+			{
+				// BUG what to do when we don't follow?
+				// for now, same as bottom
+			}
+
+			S32 delta_x = child_rect.mLeft - viewp->mRect.mLeft;
+			S32 delta_y = child_rect.mBottom - viewp->mRect.mBottom;
+			viewp->translate( delta_x, delta_y );
+			viewp->reshape(child_rect.getWidth(), child_rect.getHeight());
+		}
+	}
+
+	if (!called_from_parent)
+	{
+		if (mParentView)
+		{
+			mParentView->reshape(mParentView->getRect().getWidth(), mParentView->getRect().getHeight(), FALSE);
+		}
+	}
+}
+
+LLRect LLView::getRequiredRect()
+{
+	return mRect;
+}
+
+const LLRect LLView::getScreenRect() const
+{
+	//FIXME: check for one-off error
+	LLRect screen_rect;
+	localPointToScreen(0, 0, &screen_rect.mLeft, &screen_rect.mBottom);
+	localPointToScreen(mRect.getWidth(), mRect.getHeight(), &screen_rect.mRight, &screen_rect.mTop);
+	return screen_rect;
+}
+
+const LLRect LLView::getLocalRect() const
+{
+	LLRect local_rect(0, mRect.getHeight(), mRect.getWidth(), 0);
+	return local_rect;
+}
+
+void LLView::updateRect()
+{
+	if (mSpanChildren && mChildList.size())
+	{
+		LLView* first_child = (*mChildList.begin());
+		LLRect child_spanning_rect = first_child->mRect;
+
+		for ( child_list_iter_t child_it = ++mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			if (viewp->getVisible())
+			{
+				child_spanning_rect |=  viewp->mRect;
+			}
+		}
+
+		S32 translate_x = llmin(0, child_spanning_rect.mLeft);
+		S32 translate_y = llmin(0, child_spanning_rect.mBottom);
+		S32 new_width	= llmax(mRect.getWidth() + translate_x, child_spanning_rect.getWidth());
+		S32 new_height	= llmax(mRect.getHeight() + translate_y, child_spanning_rect.getHeight());
+
+		mRect.setOriginAndSize(mRect.mLeft + translate_x, mRect.mBottom + translate_y, new_width, new_height);
+
+		for ( child_list_iter_t child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* viewp = *child_it;
+			viewp->mRect.translate(-translate_x, -translate_y);
+		}
+	}
+}
+
+BOOL LLView::hasAncestor(LLView* parentp)
+{
+	if (!parentp)
+	{
+		return FALSE;
+	}
+
+	LLView* viewp = getParent();
+	while(viewp)
+	{
+		if (viewp == parentp)
+		{
+			return TRUE;
+		}
+		viewp = viewp->getParent();
+	}
+
+	return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+
+BOOL LLView::childHasKeyboardFocus( const LLString& childname ) const
+{
+	LLView *child = getChildByName(childname);
+	if (child)
+	{
+		return gFocusMgr.childHasKeyboardFocus(child);
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+//-----------------------------------------------------------------------------
+
+BOOL LLView::hasChild(const LLString& childname, BOOL recurse) const
+{
+	return getChildByName(childname, recurse) ? TRUE : FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// getChildByName()
+//-----------------------------------------------------------------------------
+LLView* LLView::getChildByName(const LLString& name, BOOL recurse) const
+{
+	if(name.empty()) return NULL;
+	child_list_const_iter_t child_it;
+	// Look for direct children *first*
+	for ( child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+	{
+		LLView* childp = *child_it;
+		if (childp->getName() == name)
+		{
+			return childp;
+		}
+	}
+	if (recurse)
+	{
+		// Look inside the child as well.
+		for ( child_it = mChildList.begin(); child_it != mChildList.end(); ++child_it)
+		{
+			LLView* childp = *child_it;
+			LLView* viewp = childp->getChildByName(name, recurse);
+			if ( viewp )
+			{
+				return viewp;
+			}
+		}
+	}
+	return NULL;
+}
+
+// virtual
+void LLView::onFocusLost()
+{
+}
+
+// virtual
+void LLView::onFocusReceived()
+{
+}
+
+// virtual
+void LLView::screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const
+{
+	*local_x = screen_x - mRect.mLeft;
+	*local_y = screen_y - mRect.mBottom;
+
+	const LLView* cur = this;
+	while( cur->mParentView )
+	{
+		cur = cur->mParentView;
+		*local_x -= cur->mRect.mLeft;
+		*local_y -= cur->mRect.mBottom;
+	}
+}
+
+void LLView::localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const
+{
+	*screen_x = local_x + mRect.mLeft;
+	*screen_y = local_y + mRect.mBottom;
+
+	const LLView* cur = this;
+	while( cur->mParentView )
+	{
+		cur = cur->mParentView;
+		*screen_x += cur->mRect.mLeft;
+		*screen_y += cur->mRect.mBottom;
+	}
+}
+
+void LLView::screenRectToLocal(const LLRect& screen, LLRect* local) const
+{
+	*local = screen;
+	local->translate( -mRect.mLeft, -mRect.mBottom );
+
+	const LLView* cur = this;
+	while( cur->mParentView )
+	{
+		cur = cur->mParentView;
+		local->translate( -cur->mRect.mLeft, -cur->mRect.mBottom );
+	}
+}
+
+void LLView::localRectToScreen(const LLRect& local, LLRect* screen) const
+{
+	*screen = local;
+	screen->translate( mRect.mLeft, mRect.mBottom );
+
+	const LLView* cur = this;
+	while( cur->mParentView )
+	{
+		cur = cur->mParentView;
+		screen->translate( cur->mRect.mLeft, cur->mRect.mBottom );
+	}
+}
+
+LLView* LLView::getRootMostFastFrameView()
+{
+	if (gFocusMgr.getTopView() == this)
+	{
+		return this;
+	}
+
+	if (getParent())
+	{
+		LLView* rootmost_view = getParent()->getRootMostFastFrameView();
+		if (rootmost_view)
+		{
+			return rootmost_view;
+		}
+	}
+
+	return mRenderInFastFrame ? this : NULL;
+}
+
+
+LLView* LLView::getRootView()
+{
+	LLView* view = this;
+	while( view->mParentView )
+	{
+		view = view->mParentView;
+	}
+	return view;
+}
+
+//static 
+LLWindow* LLView::getWindow(void)
+{
+	return LLUI::sWindow;
+}
+
+// Moves the view so that it is entirely inside of constraint.
+// If the view will not fit because it's too big, aligns with the top and left.
+// (Why top and left?  That's where the drag bars are for floaters.)
+BOOL LLView::translateIntoRect(const LLRect& constraint, BOOL allow_partial_outside )
+{
+	S32 delta_x = 0;
+	S32 delta_y = 0;
+
+	if (allow_partial_outside)
+	{
+		const S32 KEEP_ONSCREEN_PIXELS = 16;
+
+		if( mRect.mRight - KEEP_ONSCREEN_PIXELS < constraint.mLeft )
+		{
+			delta_x = constraint.mLeft - (mRect.mRight - KEEP_ONSCREEN_PIXELS);
+		}
+		else
+		if( mRect.mLeft + KEEP_ONSCREEN_PIXELS > constraint.mRight )
+		{
+			delta_x = constraint.mRight - (mRect.mLeft + KEEP_ONSCREEN_PIXELS);
+			delta_x += llmax( 0, mRect.getWidth() - constraint.getWidth() );
+		}
+
+		if( mRect.mTop > constraint.mTop )
+		{
+			delta_y = constraint.mTop - mRect.mTop;
+		}
+		else
+		if( mRect.mTop - KEEP_ONSCREEN_PIXELS < constraint.mBottom )
+		{
+			delta_y = constraint.mBottom - (mRect.mTop - KEEP_ONSCREEN_PIXELS);
+			delta_y -= llmax( 0, mRect.getHeight() - constraint.getHeight() );
+		}
+	}
+	else
+	{
+		if( mRect.mLeft < constraint.mLeft )
+		{
+			delta_x = constraint.mLeft - mRect.mLeft;
+		}
+		else
+		if( mRect.mRight > constraint.mRight )
+		{
+			delta_x = constraint.mRight - mRect.mRight;
+			delta_x += llmax( 0, mRect.getWidth() - constraint.getWidth() );
+		}
+
+		if( mRect.mTop > constraint.mTop )
+		{
+			delta_y = constraint.mTop - mRect.mTop;
+		}
+		else
+		if( mRect.mBottom < constraint.mBottom )
+		{
+			delta_y = constraint.mBottom - mRect.mBottom;
+			delta_y -= llmax( 0, mRect.getHeight() - constraint.getHeight() );
+		}
+	}
+
+	if (delta_x != 0 || delta_y != 0)
+	{
+		translate(delta_x, delta_y);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+BOOL LLView::localPointToOtherView( S32 x, S32 y, S32 *other_x, S32 *other_y, LLView* other_view)
+{
+	LLView* cur_view = this;
+	LLView* root_view = NULL;
+
+	while (cur_view)
+	{
+		if (cur_view == other_view)
+		{
+			*other_x = x;
+			*other_y = y;
+			return TRUE;
+		}
+
+		x += cur_view->getRect().mLeft;
+		y += cur_view->getRect().mBottom;
+
+		cur_view = cur_view->getParent();
+		root_view = cur_view;
+	}
+
+	// assuming common root between two views, chase other_view's parents up to root
+	cur_view = other_view;
+	while (cur_view)
+	{
+		x -= cur_view->getRect().mLeft;
+		y -= cur_view->getRect().mBottom;
+
+		cur_view = cur_view->getParent();
+
+		if (cur_view == root_view)
+		{
+			*other_x = x;
+			*other_y = y;
+			return TRUE;
+		}
+	}
+
+	*other_x = x;
+	*other_y = y;
+	return FALSE;
+}
+
+BOOL LLView::localRectToOtherView( const LLRect& local, LLRect* other, LLView* other_view ) const
+{
+	LLRect cur_rect = local;
+	const LLView* cur_view = this;
+	const LLView* root_view = NULL;
+
+	while (cur_view)
+	{
+		if (cur_view == other_view)
+		{
+			*other = cur_rect;
+			return TRUE;
+		}
+
+		cur_rect.translate(cur_view->getRect().mLeft, cur_view->getRect().mBottom);
+
+		cur_view = cur_view->getParent();
+		root_view = cur_view;
+	}
+
+	// assuming common root between two views, chase other_view's parents up to root
+	cur_view = other_view;
+	while (cur_view)
+	{
+		cur_rect.translate(-cur_view->getRect().mLeft, -cur_view->getRect().mBottom);
+
+		cur_view = cur_view->getParent();
+
+		if (cur_view == root_view)
+		{
+			*other = cur_rect;
+			return TRUE;
+		}
+	}
+
+	*other = cur_rect;
+	return FALSE;
+}
+
+// virtual
+LLXMLNodePtr LLView::getXML(bool save_children) const
+{
+	const LLString& type_name = getWidgetTag();
+
+	LLXMLNodePtr node = new LLXMLNode(type_name, FALSE);
+
+	node->createChild("name", TRUE)->setStringValue(getName());
+	node->createChild("width", TRUE)->setIntValue(getRect().getWidth());
+	node->createChild("height", TRUE)->setIntValue(getRect().getHeight());
+
+	LLView* parent = getParent();
+	S32 left = mRect.mLeft;
+	S32 bottom = mRect.mBottom;
+	if (parent) bottom -= parent->getRect().getHeight();
+
+	node->createChild("left", TRUE)->setIntValue(left);
+	node->createChild("bottom", TRUE)->setIntValue(bottom);
+
+	U32 follows_flags = getFollows();
+	if (follows_flags)
+	{
+		std::stringstream buffer;
+		bool pipe = false;
+		if (followsLeft())
+		{
+			buffer << "left";
+			pipe = true;
+		}
+		if (followsTop())
+		{
+			if (pipe) buffer << "|";
+			buffer << "top";
+			pipe = true;
+		}
+		if (followsRight())
+		{
+			if (pipe) buffer << "|";
+			buffer << "right";
+			pipe = true;
+		}
+		if (followsBottom())
+		{
+			if (pipe) buffer << "|";
+			buffer << "bottom";
+		}
+		node->createChild("follows", TRUE)->setStringValue(buffer.str());
+	}
+	// Export all widgets as enabled and visible - code must disable.
+	node->createChild("hidden", TRUE)->setBoolValue(mHidden);
+	node->createChild("mouse_opaque", TRUE)->setBoolValue(mMouseOpaque );
+	if (!mToolTipMsg.empty())
+	{
+		node->createChild("tool_tip", TRUE)->setStringValue(mToolTipMsg);
+	}
+	if (mSoundFlags != MOUSE_UP)
+	{
+		node->createChild("sound_flags", TRUE)->setIntValue((S32)mSoundFlags);
+	}
+
+	node->createChild("enabled", TRUE)->setBoolValue(mEnabled);
+
+	if (!mControlName.empty())
+	{
+		node->createChild("control_name", TRUE)->setStringValue(mControlName);
+	}
+	return node;
+}
+
+// static
+void LLView::addColorXML(LLXMLNodePtr node, const LLColor4& color,
+							const LLString& xml_name, const LLString& control_name)
+{
+	if (color != LLUI::sColorsGroup->getColor(control_name))
+	{
+		node->createChild(xml_name, TRUE)->setFloatValue(4, color.mV);
+	}
+}
+
+// static
+void LLView::saveColorToXML(std::ostream& out, const LLColor4& color,
+							const LLString& xml_name, const LLString& control_name,
+							const LLString& indent)
+{
+	if (color != LLUI::sColorsGroup->getColor(control_name))
+	{
+		out << indent << xml_name << "=\"" 
+			<< color.mV[VRED] << ", " 
+			<< color.mV[VGREEN] << ", " 
+			<< color.mV[VBLUE] << ", " 
+			<< color.mV[VALPHA] << "\"\n";
+	}
+}
+
+//static 
+LLString LLView::escapeXML(const LLString& xml, LLString& indent)
+{
+	LLString ret = indent + "\"" + LLXMLNode::escapeXML(xml);
+
+	//replace every newline with a close quote, new line, indent, open quote
+	size_t index = ret.size()-1;
+	size_t fnd;
+	
+	while ((fnd = ret.rfind("\n", index)) != std::string::npos)
+	{
+		ret.replace(fnd, 1, "\"\n" + indent + "\"");
+		index = fnd-1;
+	}
+
+	//append close quote
+	ret.append("\"");
+	
+	return ret;	
+}
+
+// static
+LLWString LLView::escapeXML(const LLWString& xml)
+{
+	LLWString out;
+	for (LLWString::size_type i = 0; i < xml.size(); ++i)
+	{
+		llwchar c = xml[i];
+		switch(c)
+		{
+		case '"':	out.append(utf8string_to_wstring("&quot;"));	break;
+		case '\'':	out.append(utf8string_to_wstring("&apos;"));	break;
+		case '&':	out.append(utf8string_to_wstring("&amp;"));		break;
+		case '<':	out.append(utf8string_to_wstring("&lt;"));		break;
+		case '>':	out.append(utf8string_to_wstring("&gt;"));		break;
+		default:	out.push_back(c); break;
+		}
+	}
+	return out;
+}
+
+// static
+const LLCtrlQuery & LLView::getTabOrderQuery()
+{
+	static LLCtrlQuery query;
+	if(query.getPreFilters().size() == 0) {
+		query.addPreFilter(LLVisibleFilter::getInstance());
+		query.addPreFilter(LLEnabledFilter::getInstance());
+		query.addPreFilter(LLTabStopFilter::getInstance());
+		query.addPostFilter(LLUICtrl::LLTabStopPostFilter::getInstance());
+	}
+	return query;
+}
+
+// static
+const LLCtrlQuery & LLView::getFocusRootsQuery()
+{
+	static LLCtrlQuery query;
+	if(query.getPreFilters().size() == 0) {
+		query.addPreFilter(LLVisibleFilter::getInstance());
+		query.addPreFilter(LLEnabledFilter::getInstance());
+		query.addPreFilter(LLView::LLFocusRootsFilter::getInstance());
+	}
+	return query;
+}
+
+
+LLView* LLView::findSnapRect(LLRect& new_rect, const LLCoordGL& mouse_dir,
+							 LLView::ESnapType snap_type, S32 threshold, S32 padding)
+{
+	LLView* snap_view = NULL;
+
+	if (!mParentView)
+	{
+		new_rect = mRect;
+		return snap_view;
+	}
+
+	// If the view is near the edge of its parent, snap it to
+	// the edge.
+	LLRect test_rect = getSnapRect();
+	LLRect view_rect = getSnapRect();
+	test_rect.stretch(padding);
+	view_rect.stretch(padding);
+
+	BOOL snapped_x = FALSE;
+	BOOL snapped_y = FALSE;
+
+	LLRect parent_local_snap_rect = mParentView->getSnapRect();
+	parent_local_snap_rect.translate(-mParentView->getRect().mLeft, -mParentView->getRect().mBottom);
+
+	if (snap_type == SNAP_PARENT || snap_type == SNAP_PARENT_AND_SIBLINGS)
+	{
+		if (llabs(parent_local_snap_rect.mRight - test_rect.mRight) <= threshold && (parent_local_snap_rect.mRight - test_rect.mRight) * mouse_dir.mX >= 0)
+		{
+			view_rect.translate(parent_local_snap_rect.mRight - view_rect.mRight, 0);
+			snap_view = mParentView;
+			snapped_x = TRUE;
+		}
+
+		if (llabs(test_rect.mLeft - parent_local_snap_rect.mLeft) <= threshold && test_rect.mLeft * mouse_dir.mX <= 0)
+		{
+			view_rect.translate(parent_local_snap_rect.mLeft - view_rect.mLeft, 0);
+			snap_view = mParentView;
+			snapped_x = TRUE;
+		}
+
+		if (llabs(test_rect.mBottom - parent_local_snap_rect.mBottom) <= threshold && test_rect.mBottom * mouse_dir.mY <= 0)
+		{
+			view_rect.translate(0, parent_local_snap_rect.mBottom - view_rect.mBottom);
+			snap_view = mParentView;
+			snapped_y = TRUE;
+		}
+
+		if (llabs(parent_local_snap_rect.mTop - test_rect.mTop) <= threshold && (parent_local_snap_rect.mTop - test_rect.mTop) * mouse_dir.mY >= 0)
+		{
+			view_rect.translate(0, parent_local_snap_rect.mTop - view_rect.mTop);
+			snap_view = mParentView;
+			snapped_y = TRUE;
+		}
+	}
+	if (snap_type == SNAP_SIBLINGS || snap_type == SNAP_PARENT_AND_SIBLINGS)
+	{
+		for ( child_list_const_iter_t child_it = mParentView->getChildList()->begin();
+			  child_it != mParentView->getChildList()->end(); ++child_it)
+		{
+			LLView* siblingp = *child_it;
+			// skip self
+			if (siblingp == this || !siblingp->getVisible() || !canSnapTo(siblingp))
+			{
+				continue;
+			}
+
+			LLRect sibling_rect = siblingp->getSnapRect();
+
+			if (!snapped_x && llabs(test_rect.mRight - sibling_rect.mLeft) <= threshold && (test_rect.mRight - sibling_rect.mLeft) * mouse_dir.mX <= 0)
+			{
+				view_rect.translate(sibling_rect.mLeft - view_rect.mRight, 0);
+				if (!snapped_y)
+				{
+					if (llabs(test_rect.mTop - sibling_rect.mTop) <= threshold && (test_rect.mTop - sibling_rect.mTop) * mouse_dir.mY <= 0)
+					{
+						view_rect.translate(0, sibling_rect.mTop - test_rect.mTop);
+						snapped_y = TRUE;
+					}
+					else if (llabs(test_rect.mBottom - sibling_rect.mBottom) <= threshold && (test_rect.mBottom - sibling_rect.mBottom) * mouse_dir.mY <= 0)
+					{
+						view_rect.translate(0, sibling_rect.mBottom - test_rect.mBottom);
+						snapped_y = TRUE;
+					}
+				}
+				snap_view = siblingp;
+				snapped_x = TRUE;
+			}
+
+			if (!snapped_x && llabs(test_rect.mLeft - sibling_rect.mRight) <= threshold && (test_rect.mLeft - sibling_rect.mRight) * mouse_dir.mX <= 0)
+			{
+				view_rect.translate(sibling_rect.mRight - view_rect.mLeft, 0);
+				if (!snapped_y)
+				{
+					if (llabs(test_rect.mTop - sibling_rect.mTop) <= threshold && (test_rect.mTop - sibling_rect.mTop) * mouse_dir.mY <= 0)
+					{
+						view_rect.translate(0, sibling_rect.mTop - test_rect.mTop);
+						snapped_y = TRUE;
+					}
+					else if (llabs(test_rect.mBottom - sibling_rect.mBottom) <= threshold && (test_rect.mBottom - sibling_rect.mBottom) * mouse_dir.mY <= 0)
+					{
+						view_rect.translate(0, sibling_rect.mBottom - test_rect.mBottom);
+						snapped_y = TRUE;
+					}
+				}
+				snap_view = siblingp;
+				snapped_x = TRUE;
+			}
+
+			if (!snapped_y && llabs(test_rect.mBottom - sibling_rect.mTop) <= threshold && (test_rect.mBottom - sibling_rect.mTop) * mouse_dir.mY <= 0)
+			{
+				view_rect.translate(0, sibling_rect.mTop - view_rect.mBottom);
+				if (!snapped_x)
+				{
+					if (llabs(test_rect.mLeft - sibling_rect.mLeft) <= threshold && (test_rect.mLeft - sibling_rect.mLeft) * mouse_dir.mX <= 0)
+					{
+						view_rect.translate(sibling_rect.mLeft - test_rect.mLeft, 0);
+						snapped_x = TRUE;
+					}
+					else if (llabs(test_rect.mRight - sibling_rect.mRight) <= threshold && (test_rect.mRight - sibling_rect.mRight) * mouse_dir.mX <= 0)
+					{
+						view_rect.translate(sibling_rect.mRight - test_rect.mRight, 0);
+						snapped_x = TRUE;
+					}
+				}
+				snap_view = siblingp;
+				snapped_y = TRUE;
+			}
+
+			if (!snapped_y && llabs(test_rect.mTop - sibling_rect.mBottom) <= threshold && (test_rect.mTop - sibling_rect.mBottom) * mouse_dir.mY <= 0)
+			{
+				view_rect.translate(0, sibling_rect.mBottom - view_rect.mTop);
+				if (!snapped_x)
+				{
+					if (llabs(test_rect.mLeft - sibling_rect.mLeft) <= threshold && (test_rect.mLeft - sibling_rect.mLeft) * mouse_dir.mX <= 0)
+					{
+						view_rect.translate(sibling_rect.mLeft - test_rect.mLeft, 0);
+						snapped_x = TRUE;
+					}
+					else if (llabs(test_rect.mRight - sibling_rect.mRight) <= threshold && (test_rect.mRight - sibling_rect.mRight) * mouse_dir.mX <= 0)
+					{
+						view_rect.translate(sibling_rect.mRight - test_rect.mRight, 0);
+						snapped_x = TRUE;
+					}
+				}
+				snap_view = siblingp;
+				snapped_y = TRUE;
+			}
+			
+			if (snapped_x && snapped_y)
+			{
+				break;
+			}
+		}
+	}
+
+	// shrink actual view rect back down
+	view_rect.stretch(-padding);
+	new_rect = view_rect;
+	return snap_view;
+}
+
+LLView*	LLView::findSnapEdge(S32& new_edge_val, const LLCoordGL& mouse_dir, ESnapEdge snap_edge, ESnapType snap_type, S32 threshold, S32 padding)
+{
+	LLRect snap_rect = getSnapRect();
+	S32 snap_pos = 0;
+	switch(snap_edge)
+	{
+	case SNAP_LEFT:
+		snap_pos = snap_rect.mLeft;
+		break;
+	case SNAP_RIGHT:
+		snap_pos = snap_rect.mRight;
+		break;
+	case SNAP_TOP:
+		snap_pos = snap_rect.mTop;
+		break;
+	case SNAP_BOTTOM:
+		snap_pos = snap_rect.mBottom;
+		break;
+	}
+
+	if (!mParentView)
+	{
+		new_edge_val = snap_pos;
+		return NULL;
+	}
+
+	LLView* snap_view = NULL;
+
+	// If the view is near the edge of its parent, snap it to
+	// the edge.
+	LLRect test_rect = snap_rect;
+	test_rect.stretch(padding);
+
+	BOOL snapped_x = FALSE;
+	BOOL snapped_y = FALSE;
+
+	LLRect parent_local_snap_rect = mParentView->getSnapRect();
+	parent_local_snap_rect.translate(-mParentView->getRect().mLeft, -mParentView->getRect().mBottom);
+
+	if (snap_type == SNAP_PARENT || snap_type == SNAP_PARENT_AND_SIBLINGS)
+	{
+		switch(snap_edge)
+		{
+		case SNAP_RIGHT:
+			if (llabs(parent_local_snap_rect.mRight - test_rect.mRight) <= threshold && (parent_local_snap_rect.mRight - test_rect.mRight) * mouse_dir.mX >= 0)
+			{
+				snap_pos = parent_local_snap_rect.mRight - padding;
+				snap_view = mParentView;
+				snapped_x = TRUE;
+			}
+			break;
+		case SNAP_LEFT:
+			if (llabs(test_rect.mLeft - parent_local_snap_rect.mLeft) <= threshold && test_rect.mLeft * mouse_dir.mX <= 0)
+			{
+				snap_pos = parent_local_snap_rect.mLeft + padding;
+				snap_view = mParentView;
+				snapped_x = TRUE;
+			}
+			break;
+		case SNAP_BOTTOM:
+			if (llabs(test_rect.mBottom - parent_local_snap_rect.mBottom) <= threshold && test_rect.mBottom * mouse_dir.mY <= 0)
+			{
+				snap_pos = parent_local_snap_rect.mBottom + padding;
+				snap_view = mParentView;
+				snapped_y = TRUE;
+			}
+			break;
+		case SNAP_TOP:
+			if (llabs(parent_local_snap_rect.mTop - test_rect.mTop) <= threshold && (parent_local_snap_rect.mTop - test_rect.mTop) * mouse_dir.mY >= 0)
+			{
+				snap_pos = parent_local_snap_rect.mTop - padding;
+				snap_view = mParentView;
+				snapped_y = TRUE;
+			}
+			break;
+		default:
+			llerrs << "Invalid snap edge" << llendl;
+		}
+	}
+
+	if (snap_type == SNAP_SIBLINGS || snap_type == SNAP_PARENT_AND_SIBLINGS)
+	{
+		for ( child_list_const_iter_t child_it = mParentView->getChildList()->begin();
+			  child_it != mParentView->getChildList()->end(); ++child_it)
+		{
+			LLView* siblingp = *child_it;
+			// skip self
+			if (siblingp == this || !siblingp->getVisible() || !canSnapTo(siblingp))
+			{
+				continue;
+			}
+
+			LLRect sibling_rect = siblingp->getSnapRect();
+
+			switch(snap_edge)
+			{
+			case SNAP_RIGHT:
+				if (!snapped_x)
+				{
+					if (llabs(test_rect.mRight - sibling_rect.mLeft) <= threshold && (test_rect.mRight - sibling_rect.mLeft) * mouse_dir.mX <= 0)
+					{
+						snap_pos = sibling_rect.mLeft - padding;
+						snap_view = siblingp;
+						snapped_x = TRUE;
+					}
+					// if snapped with sibling along other axis, check for shared edge
+					else if (llabs(sibling_rect.mTop - (test_rect.mBottom - padding)) <= threshold ||
+						llabs(sibling_rect.mBottom - (test_rect.mTop + padding)) <= threshold)
+					{
+						if (llabs(test_rect.mRight - sibling_rect.mRight) <= threshold && (test_rect.mRight - sibling_rect.mRight) * mouse_dir.mX <= 0)
+						{
+							snap_pos = sibling_rect.mRight;
+							snap_view = siblingp;
+							snapped_x = TRUE;
+						}
+					}
+				}
+				break;
+			case SNAP_LEFT:
+				if (!snapped_x)
+				{
+					if (llabs(test_rect.mLeft - sibling_rect.mRight) <= threshold && (test_rect.mLeft - sibling_rect.mRight) * mouse_dir.mX <= 0)
+					{
+						snap_pos = sibling_rect.mRight + padding;
+						snap_view = siblingp;
+						snapped_x = TRUE;
+					}
+					// if snapped with sibling along other axis, check for shared edge
+					else if (llabs(sibling_rect.mTop - (test_rect.mBottom - padding)) <= threshold ||
+						llabs(sibling_rect.mBottom - (test_rect.mTop + padding)) <= threshold)
+					{
+						if (llabs(test_rect.mLeft - sibling_rect.mLeft) <= threshold && (test_rect.mLeft - sibling_rect.mLeft) * mouse_dir.mX <= 0)
+						{
+							snap_pos = sibling_rect.mLeft;
+							snap_view = siblingp;
+							snapped_x = TRUE;
+						}
+					}
+				}
+				break;
+			case SNAP_BOTTOM:
+				if (!snapped_y)
+				{
+					if (llabs(test_rect.mBottom - sibling_rect.mTop) <= threshold && (test_rect.mBottom - sibling_rect.mTop) * mouse_dir.mY <= 0)
+					{
+						snap_pos = sibling_rect.mTop + padding;
+						snap_view = siblingp;
+						snapped_y = TRUE;
+					}
+					// if snapped with sibling along other axis, check for shared edge
+					else if (llabs(sibling_rect.mRight - (test_rect.mLeft - padding)) <= threshold ||
+						llabs(sibling_rect.mLeft - (test_rect.mRight + padding)) <= threshold)
+					{
+						if (llabs(test_rect.mBottom - sibling_rect.mBottom) <= threshold && (test_rect.mBottom - sibling_rect.mBottom) * mouse_dir.mY <= 0)
+						{
+							snap_pos = sibling_rect.mBottom;
+							snap_view = siblingp;
+							snapped_y = TRUE;
+						}
+					}
+				}
+				break;
+			case SNAP_TOP:
+				if (!snapped_y)
+				{
+					if (llabs(test_rect.mTop - sibling_rect.mBottom) <= threshold && (test_rect.mTop - sibling_rect.mBottom) * mouse_dir.mY <= 0)
+					{
+						snap_pos = sibling_rect.mBottom - padding;
+						snap_view = siblingp;
+						snapped_y = TRUE;
+					}
+					// if snapped with sibling along other axis, check for shared edge
+					else if (llabs(sibling_rect.mRight - (test_rect.mLeft - padding)) <= threshold ||
+						llabs(sibling_rect.mLeft - (test_rect.mRight + padding)) <= threshold)
+					{
+						if (llabs(test_rect.mTop - sibling_rect.mTop) <= threshold && (test_rect.mTop - sibling_rect.mTop) * mouse_dir.mY <= 0)
+						{
+							snap_pos = sibling_rect.mTop;
+							snap_view = siblingp;
+							snapped_y = TRUE;
+						}
+					}
+				}
+				break;
+			default:
+				llerrs << "Invalid snap edge" << llendl;
+			}
+			if (snapped_x && snapped_y)
+			{
+				break;
+			}
+		}
+	}
+
+	new_edge_val = snap_pos;
+	return snap_view;
+}
+
+bool operator==(const LLViewHandle& lhs, const LLViewHandle& rhs)
+{
+	return lhs.mID == rhs.mID;
+}
+
+bool operator!=(const LLViewHandle& lhs, const LLViewHandle& rhs)
+{
+	return lhs.mID != rhs.mID;
+}
+
+bool operator<(const LLViewHandle &lhs, const LLViewHandle &rhs)
+{
+	return lhs.mID < rhs.mID;
+}
+
+//-----------------------------------------------------------------------------
+// Listener dispatch functions
+//-----------------------------------------------------------------------------
+
+void LLView::registerEventListener(LLString name, LLSimpleListener* function)
+{
+	mDispatchList.insert(std::pair<LLString, LLSimpleListener*>(name, function));
+}
+
+void LLView::deregisterEventListener(LLString name)
+{
+	dispatch_list_t::iterator itor = mDispatchList.find(name);
+	if (itor != mDispatchList.end())
+	{
+		delete itor->second;
+		mDispatchList.erase(itor);
+	}
+}
+
+LLString LLView::findEventListener(LLSimpleListener *listener) const
+{
+	dispatch_list_t::const_iterator itor;
+	for (itor = mDispatchList.begin(); itor != mDispatchList.end(); ++itor)
+	{
+		if (itor->second == listener)
+		{
+			return itor->first;
+		}
+	}
+	if (mParentView)
+	{
+		return mParentView->findEventListener(listener);
+	}
+	return LLString::null;
+}
+
+LLSimpleListener* LLView::getListenerByName(const LLString& callback_name)
+{
+	LLSimpleListener* callback = NULL;
+	dispatch_list_t::iterator itor = mDispatchList.find(callback_name);
+	if (itor != mDispatchList.end())
+	{
+		callback = itor->second;
+	}
+	else if (mParentView)
+	{
+		callback = mParentView->getListenerByName(callback_name);
+	}
+	return callback;
+}
+
+void LLView::addListenerToControl(LLEventDispatcher *dispatcher, const LLString& name, LLSD filter, LLSD userdata)
+{
+	LLSimpleListener* listener = getListenerByName(name);
+	if (listener)
+	{
+		dispatcher->addListener(listener, filter, userdata);
+	}
+}
+
+LLControlBase *LLView::findControl(LLString name)
+{
+	control_map_t::iterator itor = mFloaterControls.find(name);
+	if (itor != mFloaterControls.end())
+	{
+		return itor->second;
+	}
+	if (mParentView)
+	{
+		return mParentView->findControl(name);
+	}
+	return LLUI::sConfigGroup->getControl(name);
+}
+
+const S32 FLOATER_H_MARGIN = 15;
+const S32 MIN_WIDGET_HEIGHT = 10;
+const S32 VPAD = 4;
+
+// static
+U32 LLView::createRect(LLXMLNodePtr node, LLRect &rect, LLView* parent_view, const LLRect &required_rect)
+{
+	U32 follows = 0;
+	S32 x = FLOATER_H_MARGIN;
+	S32 y = 0;
+	S32 w = 0;
+	S32 h = 0;
+
+	U32 last_x = 0;
+	U32 last_y = 0;
+	if (parent_view)
+	{
+		last_y = parent_view->getRect().getHeight();
+		child_list_t::const_iterator itor = parent_view->getChildList()->begin();
+		if (itor != parent_view->getChildList()->end())
+		{
+			LLView *last_view = (*itor);
+			if (last_view->getSaveToXML())
+			{
+				last_x = last_view->getRect().mLeft;
+				last_y = last_view->getRect().mBottom;
+			}
+		}
+	}
+
+	LLString rect_control;
+	node->getAttributeString("rect_control", rect_control);
+	if (! rect_control.empty())
+	{
+		LLRect rect = LLUI::sConfigGroup->getRect(rect_control);
+		x = rect.mLeft;
+		y = rect.mBottom;
+		w = rect.getWidth();
+		h = rect.getHeight();
+	}
+	
+	if (node->hasAttribute("left"))
+	{
+		node->getAttributeS32("left", x);
+	}
+	if (node->hasAttribute("bottom"))
+	{
+		node->getAttributeS32("bottom", y);
+	}
+
+	// Make your width the width of the containing
+	// view if you don't specify a width.
+	if (parent_view)
+	{
+		w = llmax(required_rect.getWidth(), parent_view->getRect().getWidth() - (FLOATER_H_MARGIN) - x);
+		h = llmax(MIN_WIDGET_HEIGHT, required_rect.getHeight());
+	}
+
+	if (node->hasAttribute("width"))
+	{
+		node->getAttributeS32("width", w);
+	}
+	if (node->hasAttribute("height"))
+	{
+		node->getAttributeS32("height", h);
+	}
+
+	if (parent_view)
+	{
+		if (node->hasAttribute("left_delta"))
+		{
+			S32 left_delta = 0;
+			node->getAttributeS32("left_delta", left_delta);
+			x = last_x + left_delta;
+		}
+		else if (node->hasAttribute("left") && node->hasAttribute("right"))
+		{
+			// compute width based on left and right
+			S32 right = 0;
+			node->getAttributeS32("right", right);
+			if (right < 0)
+			{
+				right = parent_view->getRect().getWidth() + right;
+			}
+			w = right - x;
+		}
+		else if (node->hasAttribute("left"))
+		{
+			if (x < 0)
+			{
+				x = parent_view->getRect().getWidth() + x;
+				follows |= FOLLOWS_RIGHT;
+			}
+			else
+			{
+				follows |= FOLLOWS_LEFT;
+			}
+		}
+		else if (node->hasAttribute("width") && node->hasAttribute("right"))
+		{
+			S32 right = 0;
+			node->getAttributeS32("right", right);
+			if (right < 0)
+			{
+				right = parent_view->getRect().getWidth() + right;
+			}
+			x = right - w;
+		}
+		else
+		{
+			// left not specified, same as last
+			x = last_x;
+		}
+
+		if (node->hasAttribute("bottom_delta"))
+		{
+			S32 bottom_delta = 0;
+			node->getAttributeS32("bottom_delta", bottom_delta);
+			y = last_y + bottom_delta;
+		}
+		else if (node->hasAttribute("top"))
+		{
+			// compute height based on top
+			S32 top = 0;
+			node->getAttributeS32("top", top);
+			if (top < 0)
+			{
+				top = parent_view->getRect().getHeight() + top;
+			}
+			h = top - y;
+		}
+		else if (node->hasAttribute("bottom"))
+		{
+			if (y < 0)
+			{
+				y = parent_view->getRect().getHeight() + y;
+				follows |= FOLLOWS_TOP;
+			}
+			else
+			{
+				follows |= FOLLOWS_BOTTOM;
+			}
+		}
+		else
+		{
+			// if bottom not specified, generate automatically
+			if (last_y == 0)
+			{
+				// treat first child as "bottom"
+				y = parent_view->getRect().getHeight() - (h + VPAD);
+				follows |= FOLLOWS_TOP;
+			}
+			else
+			{
+				// treat subsequent children as "bottom_delta"
+				y = last_y - (h + VPAD);
+			}
+		}
+	}
+	else
+	{
+		x = llmax(x, 0);
+		y = llmax(y, 0);
+		follows = FOLLOWS_LEFT | FOLLOWS_TOP;
+	}
+	rect.setOriginAndSize(x, y, w, h);
+
+	return follows;
+}
+
+void LLView::initFromXML(LLXMLNodePtr node, LLView* parent)
+{
+	// create rect first, as this will supply initial follows flags
+	LLRect view_rect;
+	U32 follows_flags = createRect(node, view_rect, parent, getRequiredRect());
+	// call reshape in case there are any child elements that need to be layed out
+	reshape(view_rect.getWidth(), view_rect.getHeight());
+	setRect(view_rect);
+	setFollows(follows_flags);
+
+	if (node->hasAttribute("follows"))
+	{
+		setFollowsNone();
+
+		LLString follows;
+		node->getAttributeString("follows", follows);
+
+		typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+		boost::char_separator<char> sep("|");
+		tokenizer tokens(follows, sep);
+		tokenizer::iterator token_iter = tokens.begin();
+
+		while(token_iter != tokens.end())
+		{
+			const std::string& token_str = *token_iter;
+			if (token_str == "left")
+			{
+				setFollowsLeft();
+			}
+			else if (token_str == "right")
+			{
+				setFollowsRight();
+			}
+			else if (token_str == "top")
+			{
+				setFollowsTop();
+			}
+			else if (token_str == "bottom")
+			{
+				setFollowsBottom();
+			}
+			else if (token_str == "all")
+			{
+				setFollowsAll();
+			}
+			++token_iter;
+		}
+	}
+
+	if (node->hasAttribute("control_name"))
+	{
+		LLString control_name;
+		node->getAttributeString("control_name", control_name);
+		setControlName(control_name, NULL);
+	}
+
+	if (node->hasAttribute("tool_tip"))
+	{
+		LLString tool_tip_msg("");
+		node->getAttributeString("tool_tip", tool_tip_msg);
+		setToolTip(tool_tip_msg);
+	}
+
+	if (node->hasAttribute("enabled"))
+	{
+		BOOL enabled;
+		node->getAttributeBOOL("enabled", enabled);
+		setEnabled(enabled);
+	}
+	
+	if (node->hasAttribute("visible"))
+	{
+		BOOL visible;
+		node->getAttributeBOOL("visible", visible);
+		setVisible(visible);
+	}
+	
+	if (node->hasAttribute("hidden"))
+	{
+		BOOL hidden;
+		node->getAttributeBOOL("hidden", hidden);
+		setHidden(hidden);
+	}
+
+	node->getAttributeS32("default_tab_group", mDefaultTabGroup);
+	
+	reshape(view_rect.getWidth(), view_rect.getHeight());
+}
+
+// static
+LLFontGL* LLView::selectFont(LLXMLNodePtr node)
+{
+	LLFontGL* gl_font = NULL;
+
+	if (node->hasAttribute("font"))
+	{
+		LLString font_name;
+		node->getAttributeString("font", font_name);
+
+		gl_font = LLFontGL::fontFromName(font_name.c_str());
+	}
+	return gl_font;
+}
+
+// static
+LLFontGL::HAlign LLView::selectFontHAlign(LLXMLNodePtr node)
+{
+	LLFontGL::HAlign gl_hfont_align = LLFontGL::LEFT;
+
+	if (node->hasAttribute("halign"))
+	{
+		LLString horizontal_align_name;
+		node->getAttributeString("halign", horizontal_align_name);
+		gl_hfont_align = LLFontGL::hAlignFromName(horizontal_align_name);
+	}
+	return gl_hfont_align;
+}
+
+// static
+LLFontGL::VAlign LLView::selectFontVAlign(LLXMLNodePtr node)
+{
+	LLFontGL::VAlign gl_vfont_align = LLFontGL::BASELINE;
+
+	if (node->hasAttribute("valign"))
+	{
+		LLString vert_align_name;
+		node->getAttributeString("valign", vert_align_name);
+		gl_vfont_align = LLFontGL::vAlignFromName(vert_align_name);
+	}
+	return gl_vfont_align;
+}
+
+// static
+LLFontGL::StyleFlags LLView::selectFontStyle(LLXMLNodePtr node)
+{
+	LLFontGL::StyleFlags gl_font_style = LLFontGL::NORMAL;
+
+	if (node->hasAttribute("style"))
+	{
+		LLString style_flags_name;
+		node->getAttributeString("style", style_flags_name);
+
+		if (style_flags_name == "normal")
+		{
+			gl_font_style = LLFontGL::NORMAL;
+		}
+		else if (style_flags_name == "bold")
+		{
+			gl_font_style = LLFontGL::BOLD;
+		}
+		else if (style_flags_name == "italic")
+		{
+			gl_font_style = LLFontGL::ITALIC;
+		}
+		else if (style_flags_name == "underline")
+		{
+			gl_font_style = LLFontGL::UNDERLINE;
+		}
+		//else leave left
+	}
+	return gl_font_style;
+}
+
+void LLView::setControlValue(const LLSD& value)
+{
+	LLUI::sConfigGroup->setValue(getControlName(), value);
+}
+
+//virtual
+LLString LLView::getControlName() const
+{
+	return mControlName;
+}
+
+//virtual
+void LLView::setControlName(const LLString& control_name, LLView *context)
+{
+	if (context == NULL)
+	{
+		context = this;
+	}
+
+	// Unregister from existing listeners
+	if (!mControlName.empty())
+	{
+		clearDispatchers();
+	}
+
+	// Register new listener
+	if (!control_name.empty())
+	{
+		LLControlBase *control = context->findControl(control_name);
+		if (control)
+		{
+			mControlName = control_name;
+			LLSD state = control->registerListener(this, "DEFAULT");
+			setValue(state);
+		}
+	}
+}
+
+// virtual
+bool LLView::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+	if (userdata.asString() == "DEFAULT" && event->desc() == "value_changed")
+	{
+		LLSD state = event->getValue();
+		setValue(state);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+void LLView::setValue(const LLSD& value)
+{
+}
+
+
+void LLView::addBoolControl(LLString name, bool initial_value)
+{
+	mFloaterControls[name] = new LLControl(name, TYPE_BOOLEAN, initial_value, "Internal floater control");
+}
+
+LLControlBase *LLView::getControl(LLString name)
+{
+	control_map_t::iterator itor = mFloaterControls.find(name);
+	if (itor != mFloaterControls.end())
+	{
+		return itor->second;
+	}
+	return NULL;
+}
diff --git a/indra/llui/llview.h b/indra/llui/llview.h
new file mode 100644
index 0000000000..63d85fbcdc
--- /dev/null
+++ b/indra/llui/llview.h
@@ -0,0 +1,489 @@
+/** 
+ * @file llview.h
+ * @brief Container for other views, anything that draws.
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLVIEW_H
+#define LL_LLVIEW_H
+
+// A view is an area in a window that can draw.  It might represent
+// the HUD or a dialog box or a button.  It can also contain sub-views
+// and child widgets
+
+#include <iosfwd>
+#include <list>
+
+#include "lluixmltags.h"
+#include "llrect.h"
+#include "llmousehandler.h"
+#include "stdenums.h"
+#include "llsd.h"
+#include "llstring.h"
+#include "llnametable.h"
+#include "llcoord.h"
+#include "llmortician.h"
+#include "llxmlnode.h"
+#include "llfontgl.h"
+#include "llviewquery.h"
+
+#include "llui.h"
+
+class LLColor4;
+class LLWindow;
+class LLUICtrl;
+class LLScrollListItem;
+
+const U32	FOLLOWS_NONE	= 0x00;
+const U32	FOLLOWS_LEFT	= 0x01;
+const U32	FOLLOWS_RIGHT	= 0x02;
+const U32	FOLLOWS_TOP		= 0x10;
+const U32	FOLLOWS_BOTTOM	= 0x20;
+const U32	FOLLOWS_ALL		= 0x33;
+
+const BOOL	MOUSE_OPAQUE = TRUE;
+const BOOL	NOT_MOUSE_OPAQUE = FALSE;
+
+const U32 GL_NAME_UI_RESERVED = 2;
+
+class LLSimpleListener;
+class LLEventDispatcher;
+
+class LLViewHandle
+{
+public:
+	LLViewHandle() { mID = 0; } 
+
+	void init() { mID = ++sNextID; }
+	void markDead() { mID = 0; }
+	BOOL isDead() { return (mID == 0); }
+	friend bool operator==(const LLViewHandle& lhs, const LLViewHandle& rhs);
+	friend bool operator!=(const LLViewHandle& lhs, const LLViewHandle& rhs);
+	friend bool	operator<(const LLViewHandle &a, const LLViewHandle &b);
+
+public:
+	static LLViewHandle sDeadHandle;
+
+protected:
+	S32		mID;
+
+	static S32 sNextID;
+};
+
+class LLView : public LLMouseHandler, public LLMortician, public LLSimpleListenerObservable
+{
+
+public:
+#if LL_DEBUG
+	static BOOL sIsDrawing;
+#endif
+	enum ESoundFlags
+	{
+		SILENT = 0,
+		MOUSE_DOWN = 1,
+		MOUSE_UP = 2
+	};
+
+	enum ESnapType
+	{
+		SNAP_PARENT,
+		SNAP_SIBLINGS,
+		SNAP_PARENT_AND_SIBLINGS
+	};
+
+	enum ESnapEdge
+	{
+		SNAP_LEFT, 
+		SNAP_TOP, 
+		SNAP_RIGHT, 
+		SNAP_BOTTOM
+	};
+
+	typedef std::list<LLView*> child_list_t;
+	typedef child_list_t::iterator					child_list_iter_t;
+	typedef child_list_t::const_iterator  			child_list_const_iter_t;
+	typedef child_list_t::reverse_iterator 			child_list_reverse_iter_t;
+	typedef child_list_t::const_reverse_iterator 	child_list_const_reverse_iter_t;
+
+	typedef std::vector<LLUICtrl *>					ctrl_list_t;
+
+	typedef std::pair<S32, S32>							tab_order_t;
+	typedef std::pair<LLUICtrl *, tab_order_t>			tab_order_pair_t;
+	// this structure primarily sorts by the tab group, secondarily by the insertion ordinal (lastly by the value of the pointer)
+	typedef std::map<const LLUICtrl*, tab_order_t>		child_tab_order_t;
+	typedef child_tab_order_t::iterator					child_tab_order_iter_t;
+	typedef child_tab_order_t::const_iterator			child_tab_order_const_iter_t;
+	typedef child_tab_order_t::reverse_iterator			child_tab_order_reverse_iter_t;
+	typedef child_tab_order_t::const_reverse_iterator	child_tab_order_const_reverse_iter_t;
+
+private:
+	LLView*		mParentView;
+	child_list_t mChildList;
+
+protected:
+	LLString	mName;
+	// location in pixels, relative to surrounding structure, bottom,left=0,0
+	LLRect		mRect;
+	
+	U32			mReshapeFlags;
+
+	child_tab_order_t mCtrlOrder;
+	S32			mDefaultTabGroup;
+
+	BOOL		mEnabled;		// Enabled means "accepts input that has an effect on the state of the application."
+								// A disabled view, for example, may still have a scrollbar that responds to mouse events.
+	BOOL		mMouseOpaque;	// Opaque views handle all mouse events that are over their rect.
+	LLString	mToolTipMsg;	// isNull() is true if none.
+
+	U8          mSoundFlags;
+	BOOL		mSaveToXML;
+
+	BOOL		mIsFocusRoot;
+
+public:
+	LLViewHandle mViewHandle;
+	BOOL		mLastVisible;
+	BOOL		mRenderInFastFrame;
+	BOOL		mSpanChildren;
+
+private:
+	BOOL		mVisible;
+	BOOL		mHidden;		// Never show (generally for replacement text only)
+
+	S32			mNextInsertionOrdinal;
+
+protected:
+	static LLWindow* sWindow;	// All root views must know about their window.
+
+public:
+	static BOOL	sDebugRects;	// Draw debug rects behind everything.
+	static BOOL sDebugKeys;
+	static S32	sDepth;
+	static LLView* sFastFrameView;
+	static BOOL sDebugMouseHandling;
+	static LLString sMouseHandlerMessage;
+	static S32	sSelectID;
+	static BOOL sEditingUI;
+	static LLView* sEditingUIView;
+	static S32 sLastLeftXML;
+	static S32 sLastBottomXML;
+	static std::map<LLViewHandle,LLView*> sViewHandleMap;
+	static BOOL sForceReshape;
+
+public:
+	static LLView* getViewByHandle(LLViewHandle handle);
+	static BOOL deleteViewByHandle(LLViewHandle handle);
+	
+public:
+	LLView();
+	LLView(const LLString& name, BOOL mouse_opaque);
+	LLView(const LLString& name, const LLRect& rect, BOOL mouse_opaque, U32 follows=FOLLOWS_NONE);
+
+	virtual ~LLView();
+
+	// Hack to support LLFocusMgr
+	virtual BOOL isView();
+
+	// Some UI widgets need to be added as controls.  Others need to
+	// be added as regular view children.  isCtrl should return TRUE
+	// if a widget needs to be added as a ctrl
+	virtual BOOL isCtrl() const;
+
+	virtual BOOL isPanel();
+	
+	//
+	// MANIPULATORS
+	//
+	void		setMouseOpaque( BOOL b );
+	void		setToolTip( const LLString& msg );
+
+	virtual void setRect(const LLRect &rect);
+	void		setFollows(U32 flags);
+
+	// deprecated, use setFollows() with FOLLOWS_LEFT | FOLLOWS_TOP, etc.
+	void		setFollowsNone();
+	void		setFollowsLeft();
+	void		setFollowsTop();
+	void		setFollowsRight();
+	void		setFollowsBottom();
+	void		setFollowsAll();
+
+	void        setSoundFlags(U8 flags);
+	void		setName(LLString name);
+	void		setSpanChildren( BOOL span_children );
+
+	const LLString& getToolTip();
+
+	void		sendChildToFront(LLView* child);
+	void		sendChildToBack(LLView* child);
+	void		moveChildToFrontOfTabGroup(LLUICtrl* child);
+
+	void		addChild(LLView* view, S32 tab_group = 0);
+	void		addChildAtEnd(LLView* view,  S32 tab_group = 0);
+	// remove the specified child from the view, and set it's parent to NULL.
+	void		removeChild( LLView* view );
+
+	virtual void	addCtrl( LLUICtrl* ctrl, S32 tab_group);
+	virtual void	addCtrlAtEnd( LLUICtrl* ctrl, S32 tab_group);
+	virtual void	removeCtrl( LLUICtrl* ctrl);
+
+	child_tab_order_t getCtrlOrder() const { return mCtrlOrder; }
+	ctrl_list_t getCtrlList() const;
+	ctrl_list_t getCtrlListSorted() const;
+	S32 getDefaultTabGroup() const;
+
+	BOOL		isInVisibleChain() const;
+	BOOL		isInEnabledChain() const;
+
+	BOOL		isFocusRoot() const;
+	LLView*		findRootMostFocusRoot();
+	virtual BOOL canFocusChildren() const;
+
+	class LLFocusRootsFilter : public LLQueryFilter, public LLSingleton<LLFocusRootsFilter>
+	{
+		/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const 
+		{
+			return filterResult_t(view->isCtrl() && view->isFocusRoot(), !view->isFocusRoot());
+		}
+	};
+
+	virtual  BOOL focusNextRoot();
+	virtual  BOOL focusPrevRoot();
+
+	virtual BOOL focusNextItem(BOOL text_entry_only);
+	virtual BOOL focusPrevItem(BOOL text_entry_only);
+	virtual BOOL focusFirstItem(BOOL prefer_text_fields = FALSE );
+	virtual BOOL focusLastItem(BOOL prefer_text_fields = FALSE);
+
+	// delete all children. Override this function if you need to
+	// perform any extra clean up such as cached pointers to selected
+	// children, etc.
+	virtual void deleteAllChildren();
+
+	// by default, does nothing
+	virtual void	setTentative(BOOL b);
+	// by default, returns false
+	virtual BOOL	getTentative() const;
+	virtual void 	setAllChildrenEnabled(BOOL b);
+
+	virtual void	setEnabled(BOOL enabled);
+	virtual void	setVisible(BOOL visible);
+	virtual void	setHidden(BOOL hidden);		// Never show (replacement text)
+
+	// by default, does nothing and returns false
+	virtual BOOL	setLabelArg( const LLString& key, const LLString& text );
+
+	virtual void	onVisibilityChange ( BOOL curVisibilityIn );
+
+	void			pushVisible(BOOL visible)	{ mLastVisible = mVisible; setVisible(visible); }
+	void			popVisible()				{ setVisible(mLastVisible); mLastVisible = TRUE; }
+
+	//
+	// ACCESSORS
+	//
+	BOOL		getMouseOpaque() const			{ return mMouseOpaque; }
+
+	U32			getFollows() const				{ return mReshapeFlags; }
+	BOOL		followsLeft() const				{ return mReshapeFlags & FOLLOWS_LEFT; }
+	BOOL		followsRight() const			{ return mReshapeFlags & FOLLOWS_RIGHT; }
+	BOOL		followsTop() const				{ return mReshapeFlags & FOLLOWS_TOP; }
+	BOOL		followsBottom() const			{ return mReshapeFlags & FOLLOWS_BOTTOM; }
+	BOOL		followsAll() const				{ return mReshapeFlags & FOLLOWS_ALL; }
+
+	const LLRect&	getRect() const				{ return mRect; }
+	const LLRect	getScreenRect() const;
+	const LLRect	getLocalRect() const;
+	virtual const LLRect getSnapRect() const	{ return mRect; }
+
+	virtual LLRect getRequiredRect();		// Get required size for this object. 0 for width/height means don't care.
+	virtual void updateRect();				// apply procedural updates to own rectangle
+
+	LLView*		getRootView();
+	LLView*		getParent() const				{ return mParentView; }
+	LLView*		getFirstChild() 				{ return (mChildList.empty()) ? NULL : *(mChildList.begin()); }
+	S32			getChildCount()	const			{ return (S32)mChildList.size(); }
+	template<class _Pr3> void sortChildren(_Pr3 _Pred) { mChildList.sort(_Pred); }
+	BOOL		hasAncestor(LLView* parentp);
+
+	BOOL		hasChild(const LLString& childname, BOOL recurse = FALSE) const;
+
+	BOOL 		childHasKeyboardFocus( const LLString& childname ) const;
+
+	//
+	// UTILITIES
+	//
+
+	// Default behavior is to use reshape flags to resize child views
+	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
+	virtual void	translate( S32 x, S32 y );
+	BOOL			translateIntoRect( const LLRect& constraint, BOOL allow_partial_outside );
+	void			setOrigin( S32 x, S32 y )	{ mRect.translate( x - mRect.mLeft, y - mRect.mBottom ); }
+	LLView*			findSnapRect(LLRect& new_rect, const LLCoordGL& mouse_dir, LLView::ESnapType snap_type, S32 threshold, S32 padding = 0);
+	LLView*			findSnapEdge(S32& new_edge_val, const LLCoordGL& mouse_dir, ESnapEdge snap_edge, ESnapType snap_type, S32 threshold, S32 padding = 0);
+
+	// Defaults to other_view->getVisible()
+	virtual BOOL	canSnapTo(LLView* other_view);
+
+	virtual void	snappedTo(LLView* snap_view);
+
+	virtual BOOL	handleKey(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL	handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
+	virtual BOOL	handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
+									  EDragAndDropType cargo_type,
+									  void* cargo_data,
+									  EAcceptance* accept,
+									  LLString& tooltip_msg);
+
+	// LLMouseHandler functions
+	// Default behavior is to pass events to children
+
+	/*virtual*/ BOOL	handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ BOOL	handleRightMouseUp(S32 x, S32 y, MASK mask);
+
+	// Default behavior is to pass the tooltip event to children,
+	// then display mToolTipMsg if no child handled it.
+	/*virtual*/ BOOL	handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect);
+
+	virtual void	draw();
+
+	void			drawDebugRect();
+	void			drawChild(LLView* childp, S32 x_offset = 0, S32 y_offset = 0);
+
+	virtual const LLString&	getName() const;
+
+	virtual EWidgetType getWidgetType() const = 0;
+	virtual LLString getWidgetTag() const = 0;
+	virtual LLXMLNodePtr getXML(bool save_children = true) const;
+
+	static U32 createRect(LLXMLNodePtr node, LLRect &rect, LLView* parent_view, const LLRect &required_rect = LLRect());
+	virtual void initFromXML(LLXMLNodePtr node, LLView* parent);
+
+	static LLFontGL* selectFont(LLXMLNodePtr node);
+	static LLFontGL::HAlign selectFontHAlign(LLXMLNodePtr node);
+	static LLFontGL::VAlign selectFontVAlign(LLXMLNodePtr node);
+	static LLFontGL::StyleFlags selectFontStyle(LLXMLNodePtr node);
+
+	// Some widgets, like close box buttons, don't need to be saved
+	BOOL getSaveToXML() const { return mSaveToXML; }
+	void setSaveToXML(BOOL b) { mSaveToXML = b; }
+
+	// Only saves color if different from default setting.
+	static void addColorXML(LLXMLNodePtr node, const LLColor4& color,
+							const LLString& xml_name, const LLString& control_name);
+	static void saveColorToXML(std::ostream& out, const LLColor4& color,
+							   const LLString& xml_name, const LLString& control_name,
+							   const LLString& indent); // DEPRECATED
+	// Escapes " (quot) ' (apos) & (amp) < (lt) > (gt)
+	//static LLString escapeXML(const LLString& xml);
+	static LLWString escapeXML(const LLWString& xml);
+	
+	//same as above, but wraps multiple lines in quotes and prepends
+	//indent as leading white space on each line
+	static LLString escapeXML(const LLString& xml, LLString& indent);
+
+	// focuses the item in the list after the currently-focused item, wrapping if necessary
+	static	BOOL focusNext(LLView::child_list_t & result);
+	// focuses the item in the list before the currently-focused item, wrapping if necessary
+	static	BOOL focusPrev(LLView::child_list_t & result);
+
+	// returns query for iterating over controls in tab order	
+	static const LLCtrlQuery & getTabOrderQuery();
+	// return query for iterating over focus roots in tab order
+	static const LLCtrlQuery & getFocusRootsQuery();
+
+	BOOL			getEnabled() const			{ return mEnabled; }
+	BOOL			getVisible() const			{ return mVisible && !mHidden; }
+	U8              getSoundFlags() const       { return mSoundFlags; }
+
+	// Default to no action
+	virtual void	onFocusLost();
+	virtual void	onFocusReceived();
+
+	BOOL			parentPointInView(S32 x, S32 y) const { return mRect.pointInRect( x, y ); }
+	BOOL			pointInView(S32 x, S32 y) const { return mRect.localPointInRect( x, y ); }
+	virtual void	screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const;
+	virtual void	localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const;
+	virtual BOOL	localPointToOtherView( S32 x, S32 y, S32 *other_x, S32 *other_y, LLView* other_view);
+	virtual void	screenRectToLocal( const LLRect& screen, LLRect* local ) const;
+	virtual void	localRectToScreen( const LLRect& local, LLRect* screen ) const;
+	virtual BOOL	localRectToOtherView( const LLRect& local, LLRect* other, LLView* other_view ) const;
+
+	void			setRenderInFastFrame(BOOL render) { mRenderInFastFrame = render; }
+	virtual LLView*	getRootMostFastFrameView();
+
+	static LLWindow*	getWindow(void);
+
+	// Listener dispatching functions (Dispatcher deletes pointers to listeners on deregistration or destruction)
+	LLSimpleListener* getListenerByName(const LLString &callback_name);
+	void registerEventListener(LLString name, LLSimpleListener* function);
+	void deregisterEventListener(LLString name);
+	LLString findEventListener(LLSimpleListener *listener) const;
+	void addListenerToControl(LLEventDispatcher *observer, const LLString& name, LLSD filter, LLSD userdata);
+
+	virtual LLView* getChildByName(const LLString& name, BOOL recurse = FALSE) const;
+
+	void addBoolControl(LLString name, bool initial_value);
+	LLControlBase *getControl(LLString name);
+	virtual LLControlBase *findControl(LLString name);
+
+	void			setControlValue(const LLSD& value);
+	virtual void	setControlName(const LLString& control, LLView *context);
+	virtual LLString getControlName() const;
+	virtual bool	handleEvent(LLPointer<LLEvent> event, const LLSD& userdata);
+	virtual void	setValue(const LLSD& value);
+	const child_list_t*	getChildList() const { return &mChildList; }
+
+protected:
+	virtual BOOL	handleKeyHere(KEY key, MASK mask, BOOL called_from_parent);
+	virtual BOOL	handleUnicodeCharHere(llwchar uni_char, BOOL called_from_parent);
+
+	LLView*	childrenHandleKey(KEY key, MASK mask);
+	LLView*	childrenHandleDragAndDrop(S32 x, S32 y, MASK mask,
+											  BOOL drop,
+											  EDragAndDropType type,
+											  void* data,
+											  EAcceptance* accept,
+											  LLString& tooltip_msg);
+
+	LLView*	childrenHandleHover(S32 x, S32 y, MASK mask);
+	LLView* childrenHandleMouseUp(S32 x, S32 y, MASK mask);
+	LLView* childrenHandleMouseDown(S32 x, S32 y, MASK mask);
+	LLView* childrenHandleDoubleClick(S32 x, S32 y, MASK mask);
+	LLView*	childrenHandleScrollWheel(S32 x, S32 y, S32 clicks);
+	LLView* childrenHandleRightMouseDown(S32 x, S32 y, MASK mask);
+	LLView* childrenHandleRightMouseUp(S32 x, S32 y, MASK mask);
+
+	typedef std::map<LLString, LLSimpleListener*> dispatch_list_t;
+	dispatch_list_t mDispatchList;
+
+protected:
+	typedef std::map<LLString, LLControlBase*> control_map_t;
+	control_map_t mFloaterControls;
+
+	LLString		mControlName;
+	friend class LLUICtrlFactory;
+};
+
+
+
+
+class LLCompareByTabOrder
+{
+public:
+	LLCompareByTabOrder(LLView::child_tab_order_t order);
+	virtual ~LLCompareByTabOrder() {}
+	bool operator() (const LLView* const a, const LLView* const b) const;
+protected:
+	virtual bool compareTabOrders(const LLView::tab_order_t & a, const LLView::tab_order_t & b) const;
+	LLView::child_tab_order_t mTabOrder;
+};
+
+#endif
diff --git a/indra/llui/llviewborder.cpp b/indra/llui/llviewborder.cpp
new file mode 100644
index 0000000000..24cc57e709
--- /dev/null
+++ b/indra/llui/llviewborder.cpp
@@ -0,0 +1,337 @@
+/** 
+ * @file llviewborder.cpp
+ * @brief LLViewBorder base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// A customizable decorative border.  Does not interact with mouse events.              
+
+#include "linden_common.h"
+
+#include "llviewborder.h"
+
+#include "llgl.h"
+#include "llui.h"
+#include "llimagegl.h"
+//#include "llviewerimagelist.h"
+#include "llcontrol.h"
+#include "llglheaders.h"
+#include "v2math.h"
+#include "llfocusmgr.h"
+
+LLViewBorder::LLViewBorder( const LLString& name, const LLRect& rect, EBevel bevel, EStyle style, S32 width )
+	:
+	LLView( name, rect, FALSE ),
+	mBevel( bevel ),
+	mStyle( style ),
+	mHighlightLight( LLUI::sColorsGroup->getColor( "DefaultHighlightLight" ) ),
+	mHighlightDark(	LLUI::sColorsGroup->getColor( "DefaultHighlightDark" ) ),
+	mShadowLight( LLUI::sColorsGroup->getColor( "DefaultShadowLight" ) ),
+	mShadowDark( LLUI::sColorsGroup->getColor( "DefaultShadowDark" ) ),
+//	mKeyboardFocusColor(LLUI::sColorsGroup->getColor( "FocusColor" ) ),
+	mBorderWidth( width ),
+	mTexture( NULL ),
+	mHasKeyboardFocus( FALSE )
+{
+	setFollowsAll();
+}
+
+// virtual
+BOOL LLViewBorder::isCtrl()
+{
+	return FALSE;
+}
+
+void LLViewBorder::setColors( const LLColor4& shadow_dark, const LLColor4& highlight_light )
+{
+	mShadowDark = shadow_dark;
+	mHighlightLight = highlight_light;
+}
+
+void LLViewBorder::setColorsExtended( const LLColor4& shadow_light, const LLColor4& shadow_dark,
+				  			   const LLColor4& highlight_light, const LLColor4& highlight_dark )
+{
+	mShadowDark = shadow_dark;
+	mShadowLight = shadow_light;
+	mHighlightLight = highlight_light;
+	mHighlightDark = highlight_dark;
+}
+
+void LLViewBorder::setTexture( const LLUUID &image_id )
+{
+	mTexture = LLUI::sImageProvider->getUIImageByID(image_id);
+}
+
+
+void LLViewBorder::draw()
+{
+	if( getVisible() )
+	{
+		if( STYLE_LINE == mStyle )
+		{
+			if( 0 == mBorderWidth )
+			{
+				// no visible border
+			}
+			else
+			if( 1 == mBorderWidth )
+			{
+				drawOnePixelLines();
+			}
+			else
+			if( 2 == mBorderWidth )
+			{
+				drawTwoPixelLines();
+			}
+			else
+			{
+				llassert( FALSE );  // not implemented
+			}
+		}
+		else
+		if( STYLE_TEXTURE == mStyle )
+		{
+			if( mTexture )
+			{
+				drawTextures();
+			}
+		}
+
+		// draw the children
+		LLView::draw();
+	}	
+}
+
+void LLViewBorder::drawOnePixelLines()
+{
+	LLGLSNoTexture uiNoTexture;
+
+	LLColor4 top_color = mHighlightLight;
+	LLColor4 bottom_color = mHighlightLight;
+	switch( mBevel )
+	{
+	case BEVEL_OUT:
+		top_color		= mHighlightLight;
+		bottom_color	= mShadowDark;
+		break;
+	case BEVEL_IN:
+		top_color		= mShadowDark;
+		bottom_color	= mHighlightLight;
+		break;
+	case BEVEL_NONE:
+		// use defaults
+		break;
+	default:
+		llassert(0);
+	}
+
+	if( mHasKeyboardFocus )
+	{
+		F32 lerp_amt = gFocusMgr.getFocusFlashAmt();
+		top_color = gFocusMgr.getFocusColor();
+		bottom_color = top_color;
+
+		LLUI::setLineWidth(lerp(1.f, 3.f, lerp_amt));
+	}
+
+	S32 left	= 0;
+	S32 top		= mRect.getHeight();
+	S32 right	= mRect.getWidth();
+	S32 bottom	= 0;
+
+	glColor4fv( top_color.mV );
+	gl_line_2d(left, bottom, left, top);
+	gl_line_2d(left, top, right, top);
+
+	glColor4fv( bottom_color.mV );
+	gl_line_2d(right, top, right, bottom);
+	gl_line_2d(left, bottom, right, bottom);
+
+	LLUI::setLineWidth(1.f);
+}
+
+void LLViewBorder::drawTwoPixelLines()
+{
+	LLGLSNoTexture no_texture;
+	
+	LLColor4 focus_color = gFocusMgr.getFocusColor();
+
+	F32* top_in_color		= mShadowDark.mV;
+	F32* top_out_color		= mShadowDark.mV;
+	F32* bottom_in_color	= mShadowDark.mV;
+	F32* bottom_out_color	= mShadowDark.mV;
+	switch( mBevel )
+	{
+	case BEVEL_OUT:
+		top_in_color		= mHighlightLight.mV;
+		top_out_color		= mHighlightDark.mV;
+		bottom_in_color		= mShadowLight.mV;
+		bottom_out_color	= mShadowDark.mV;
+		break;
+	case BEVEL_IN:
+		top_in_color		= mShadowDark.mV;
+		top_out_color		= mShadowLight.mV;
+		bottom_in_color		= mHighlightDark.mV;
+		bottom_out_color	= mHighlightLight.mV;
+		break;
+	case BEVEL_BRIGHT:
+		top_in_color		= mHighlightLight.mV;
+		top_out_color		= mHighlightLight.mV;
+		bottom_in_color		= mHighlightLight.mV;
+		bottom_out_color	= mHighlightLight.mV;
+		break;
+	case BEVEL_NONE:
+		// use defaults
+		break;
+	default:
+		llassert(0);
+	}
+
+	if( mHasKeyboardFocus )
+	{
+		top_out_color = focus_color.mV;
+		bottom_out_color = focus_color.mV;
+	}
+
+	S32 left	= 0;
+	S32 top		= mRect.getHeight();
+	S32 right	= mRect.getWidth();
+	S32 bottom	= 0;
+
+	// draw borders
+	glColor3fv( top_out_color );
+	gl_line_2d(left, bottom, left, top-1);
+	gl_line_2d(left, top-1, right, top-1);
+
+	glColor3fv( top_in_color );
+	gl_line_2d(left+1, bottom+1, left+1, top-2);
+	gl_line_2d(left+1, top-2, right-1, top-2);
+
+	glColor3fv( bottom_out_color );
+	gl_line_2d(right-1, top-1, right-1, bottom);
+	gl_line_2d(left, bottom, right, bottom);
+
+	glColor3fv( bottom_in_color );
+	gl_line_2d(right-2, top-2, right-2, bottom+1);
+	gl_line_2d(left+1, bottom+1, right-1, bottom+1);
+}
+
+void LLViewBorder::drawTextures()
+{
+	LLGLSUIDefault gls_ui;
+
+	llassert( FALSE );  // TODO: finish implementing
+
+	glColor4fv(UI_VERTEX_COLOR.mV);
+
+	mTexture->bind();
+	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
+	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+
+	drawTextureTrapezoid(   0.f, mBorderWidth, mRect.getWidth(),  0,					0 );
+	drawTextureTrapezoid(  90.f, mBorderWidth, mRect.getHeight(), (F32)mRect.getWidth(),0 );
+	drawTextureTrapezoid( 180.f, mBorderWidth, mRect.getWidth(),  (F32)mRect.getWidth(),(F32)mRect.getHeight() );
+	drawTextureTrapezoid( 270.f, mBorderWidth, mRect.getHeight(), 0,					(F32)mRect.getHeight() );
+}
+
+
+void LLViewBorder::drawTextureTrapezoid( F32 degrees, S32 width, S32 length, F32 start_x, F32 start_y )
+{
+	glPushMatrix();
+	{
+		glTranslatef(start_x, start_y, 0.f);
+		glRotatef( degrees, 0, 0, 1 );
+
+		glBegin(GL_QUADS);
+		{
+			//      width, width   /---------\ length-width, width		//
+			//	   			      /           \							//
+			//				     /			   \						//
+			//				    /---------------\						//
+			//    			0,0					  length, 0				//
+
+			glTexCoord2f( 0, 0 );
+			glVertex2i( 0, 0 );
+
+			glTexCoord2f( (GLfloat)length, 0 );
+			glVertex2i( length, 0 );
+
+			glTexCoord2f( (GLfloat)(length - width), (GLfloat)width );
+			glVertex2i( length - width, width );
+
+			glTexCoord2f( (GLfloat)width, (GLfloat)width );
+			glVertex2i( width, width );
+		}
+		glEnd();
+	}
+	glPopMatrix();
+}
+
+bool LLViewBorder::getBevelFromAttribute(LLXMLNodePtr node, LLViewBorder::EBevel& bevel_style)
+{
+	if (node->hasAttribute("bevel_style"))
+	{
+		LLString bevel_string;
+		node->getAttributeString("bevel_style", bevel_string);
+		LLString::toLower(bevel_string);
+
+		if (bevel_string == "none")
+		{
+			bevel_style = LLViewBorder::BEVEL_NONE;
+		}
+		else if (bevel_string == "in")
+		{
+			bevel_style = LLViewBorder::BEVEL_IN;
+		}
+		else if (bevel_string == "out")
+		{
+			bevel_style = LLViewBorder::BEVEL_OUT;
+		}
+		else if (bevel_string == "bright")
+		{
+			bevel_style = LLViewBorder::BEVEL_BRIGHT;
+		}
+		return true;
+	}
+	return false;
+}
+
+void LLViewBorder::setValue(const LLSD& val)
+{
+	setRect(LLRect(val));
+}
+
+EWidgetType LLViewBorder::getWidgetType() const
+{
+	return WIDGET_TYPE_VIEW_BORDER;
+}
+
+LLString LLViewBorder::getWidgetTag() const
+{
+	return LL_VIEW_BORDER_TAG;
+}
+
+// static
+LLView* LLViewBorder::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
+{
+	LLString name("view_border");
+	node->getAttributeString("name", name);
+
+	LLViewBorder::EBevel bevel_style = LLViewBorder::BEVEL_IN;
+	getBevelFromAttribute(node, bevel_style);
+
+	S32 border_thickness = 1;
+	node->getAttributeS32("border_thickness", border_thickness);
+
+	LLViewBorder* border = new LLViewBorder(name, 
+									LLRect(), 
+									bevel_style,
+									LLViewBorder::STYLE_LINE,
+									border_thickness);
+
+	border->initFromXML(node, parent);
+	
+	return border;
+}
diff --git a/indra/llui/llviewborder.h b/indra/llui/llviewborder.h
new file mode 100644
index 0000000000..984eee6e60
--- /dev/null
+++ b/indra/llui/llviewborder.h
@@ -0,0 +1,77 @@
+/** 
+ * @file llviewborder.h
+ * @brief LLViewBorder base class
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+// A customizable decorative border.  Does not interact with mouse events.              
+
+#ifndef LL_LLVIEWBORDER_H
+#define LL_LLVIEWBORDER_H
+
+#include "llview.h"
+#include "v4color.h"
+#include "lluuid.h"
+#include "llimagegl.h"
+#include "llxmlnode.h"
+
+class LLUUID;
+
+
+class LLViewBorder : public LLView
+{
+public:
+	enum EBevel { BEVEL_IN, BEVEL_OUT, BEVEL_BRIGHT, BEVEL_NONE };
+		
+	enum EStyle { STYLE_LINE, STYLE_TEXTURE };
+
+	LLViewBorder( const LLString& name, const LLRect& rect, EBevel bevel = BEVEL_OUT, EStyle style = STYLE_LINE, S32 width = 1 );
+
+	virtual void setValue(const LLSD& val);
+	virtual EWidgetType getWidgetType() const;
+	virtual LLString getWidgetTag() const;
+
+	virtual BOOL	isCtrl();
+
+	// llview functionality
+	virtual void draw();
+	
+	static  LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
+	static bool getBevelFromAttribute(LLXMLNodePtr node, LLViewBorder::EBevel& bevel_style);
+
+	void		setBorderWidth(S32 width)			{ mBorderWidth = width; }
+	void		setBevel(EBevel bevel)				{ mBevel = bevel; }
+	void		setColors( const LLColor4& shadow_dark, const LLColor4& highlight_light );
+	void		setColorsExtended( const LLColor4& shadow_light, const LLColor4& shadow_dark,
+				  				   const LLColor4& highlight_light, const LLColor4& highlight_dark );
+	void		setTexture( const LLUUID &image_id );
+
+	EBevel		getBevel() const { return mBevel; }
+	EStyle		getStyle() const { return mStyle; }
+	S32			getBorderWidth() const				{ return mBorderWidth; }
+
+	void		setKeyboardFocusHighlight( BOOL b )	{ mHasKeyboardFocus = b; }
+
+protected:
+	void		drawOnePixelLines();
+	void		drawTwoPixelLines();
+	void		drawTextures();
+	void		drawTextureTrapezoid( F32 degrees, S32 width, S32 length, F32 start_x, F32 start_y );
+
+protected:
+	EBevel		mBevel;
+	EStyle		mStyle;
+	LLColor4	mHighlightLight;
+	LLColor4	mHighlightDark;
+	LLColor4	mShadowLight;
+	LLColor4	mShadowDark;
+	LLColor4	mBackgroundColor;
+	S32			mBorderWidth;
+	LLPointer<LLImageGL>	mTexture;
+	BOOL		mHasKeyboardFocus;
+};
+
+#endif // LL_LLVIEWBORDER_H
+
diff --git a/indra/llui/llviewquery.cpp b/indra/llui/llviewquery.cpp
new file mode 100644
index 0000000000..416ca623bc
--- /dev/null
+++ b/indra/llui/llviewquery.cpp
@@ -0,0 +1,126 @@
+/** 

+ * @file llviewquery.cpp

+ * @brief Implementation of view query class.

+ *

+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.

+ * $License$

+ */

+

+#include "llview.h"

+#include "lluictrl.h"

+#include "llviewquery.h"

+

+void LLQuerySorter::operator() (LLView * parent, viewList_t &children) const {}

+

+filterResult_t LLNoLeavesFilter::operator() (const LLView* const view, const viewList_t & children) const 

+{

+	return filterResult_t(!(view->getChildList()->size() == 0), TRUE);

+}

+

+filterResult_t LLVisibleFilter::operator() (const LLView* const view, const viewList_t & children) const 

+{

+	return filterResult_t(view->getVisible(), view->getVisible());

+}

+filterResult_t LLEnabledFilter::operator() (const LLView* const view, const viewList_t & children) const 

+{

+	return filterResult_t(view->getEnabled(), view->getEnabled());

+}

+filterResult_t LLTabStopFilter::operator() (const LLView* const view, const viewList_t & children) const 

+{

+	return filterResult_t(view->isCtrl() && static_cast<const LLUICtrl* const>(view)->hasTabStop(),

+						view->canFocusChildren());

+}

+

+// LLViewQuery

+

+LLViewQuery::LLViewQuery(): mPreFilters(), mPostFilters(), mSorterp() 

+{

+}

+

+void LLViewQuery::addPreFilter(const LLQueryFilter* prefilter) { mPreFilters.push_back(prefilter); }

+

+void LLViewQuery::addPostFilter(const LLQueryFilter* postfilter) {	mPostFilters.push_back(postfilter); }

+

+const LLViewQuery::filterList_t & LLViewQuery::getPreFilters() const { return mPreFilters; }

+

+const LLViewQuery::filterList_t & LLViewQuery::getPostFilters() const { return mPostFilters; }

+

+void LLViewQuery::setSorter(const LLQuerySorter* sorterp) { mSorterp = sorterp; }

+const LLQuerySorter* LLViewQuery::getSorter() const { return mSorterp; }

+

+viewList_t LLViewQuery::run(LLView * view) const

+{

+	viewList_t result;

+

+	filterResult_t pre = runFilters(view, viewList_t(), mPreFilters);

+	if(!pre.first && !pre.second)

+	{

+		// skip post filters completely if we're not including ourselves or the children

+		return result;

+	}

+	if(pre.second)

+	{

+		// run filters on children

+		viewList_t filtered_children;

+		filterChildren(view, filtered_children);

+		filterResult_t post = runFilters(view, filtered_children, mPostFilters);

+		if(pre.first && post.first)

+		{

+			result.push_back(view);

+		}

+		if(post.second)

+		{

+			result.insert(result.end(), filtered_children.begin(), filtered_children.end());

+		}

+	}

+	else 

+	{

+		if(pre.first) 

+		{

+			result.push_back(view);

+		}

+	}

+	return result;

+}

+

+void LLViewQuery::filterChildren(LLView * view, viewList_t & filtered_children) const

+{

+	LLView::child_list_t views(*(view->getChildList()));

+	(*mSorterp)(view, views); // sort the children per the sorter

+	for(LLView::child_list_iter_t iter = views.begin();

+			iter != views.end();

+			iter++)

+		{

+			viewList_t indiv_children = this->run(*iter);

+			filtered_children.insert(filtered_children.end(), indiv_children.begin(), indiv_children.end());

+		}

+}

+

+filterResult_t LLViewQuery::runFilters(LLView * view, const viewList_t children, const filterList_t filters) const

+{

+	filterResult_t result = filterResult_t(TRUE, TRUE);

+	for(filterList_const_iter_t iter = filters.begin();

+		iter != filters.end();

+		iter++)

+	{

+		filterResult_t filtered = (**iter)(view, children);

+		result.first = result.first && filtered.first;

+		result.second = result.second && filtered.second;

+	}

+	return result;

+}

+

+class SortByTabOrder : public LLQuerySorter, public LLSingleton<SortByTabOrder>

+{

+	/*virtual*/ void operator() (LLView * parent, LLView::child_list_t &children) const 

+	{

+		children.sort(LLCompareByTabOrder(parent->getCtrlOrder()));

+	}

+};

+

+LLCtrlQuery::LLCtrlQuery() : 

+	LLViewQuery()

+{

+	setSorter(SortByTabOrder::getInstance());

+}

+

diff --git a/indra/llui/llviewquery.h b/indra/llui/llviewquery.h
new file mode 100644
index 0000000000..ba59965c59
--- /dev/null
+++ b/indra/llui/llviewquery.h
@@ -0,0 +1,89 @@
+/** 

+ * @file llviewquery.h

+ * @brief Query algorithm for flattening and filtering the view hierarchy.

+ *

+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.

+ * $License$

+ */

+

+#ifndef LL_LLVIEWQUERY_H

+#define LL_LLVIEWQUERY_H

+

+#include <list>	

+

+#include "llmemory.h"

+

+class LLView;

+

+typedef std::list<LLView *>			viewList_t;

+typedef std::pair<BOOL, BOOL>		filterResult_t;

+

+// Abstract base class for all filters.

+class LLQueryFilter : public LLRefCount

+{

+public:

+	virtual filterResult_t operator() (const LLView* const view, const viewList_t & children) const =0;

+};

+

+class LLQuerySorter : public LLRefCount

+{

+public:

+	virtual void operator() (LLView * parent, viewList_t &children) const;

+};

+

+class LLNoLeavesFilter : public LLQueryFilter, public LLSingleton<LLNoLeavesFilter>

+{

+	/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const;

+};

+class LLVisibleFilter : public LLQueryFilter, public LLSingleton<LLVisibleFilter>

+{

+	/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const;

+};

+class LLEnabledFilter : public LLQueryFilter, public LLSingleton<LLEnabledFilter>

+{

+	/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const;

+};

+class LLTabStopFilter : public LLQueryFilter, public LLSingleton<LLTabStopFilter>

+{

+	/*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const;

+};

+

+// Algorithm for flattening

+class LLViewQuery

+{

+public:

+	typedef std::list<const LLQueryFilter*>		filterList_t;

+	typedef filterList_t::iterator				filterList_iter_t;

+	typedef filterList_t::const_iterator		filterList_const_iter_t;

+

+	LLViewQuery();

+	virtual ~LLViewQuery() {}

+

+	void addPreFilter(const LLQueryFilter* prefilter);

+	void addPostFilter(const LLQueryFilter* postfilter);

+	const filterList_t & getPreFilters() const;

+	const filterList_t & getPostFilters() const;

+

+	void setSorter(const LLQuerySorter* sorter);

+	const LLQuerySorter* getSorter() const;

+

+	viewList_t run(LLView * view) const;

+	// syntactic sugar

+	viewList_t operator () (LLView * view) const { return run(view); }

+protected:

+	// override this method to provide iteration over other types of children

+	virtual void filterChildren(LLView * view, viewList_t & filtered_children) const;

+	filterResult_t runFilters(LLView * view, const viewList_t children, const filterList_t filters) const;

+protected:

+	filterList_t mPreFilters;

+	filterList_t mPostFilters;

+	const LLQuerySorter* mSorterp;

+};

+

+class LLCtrlQuery : public LLViewQuery

+{

+public:

+	LLCtrlQuery();

+};

+

+#endif