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