LLCheckBoxCtrl::LLCheckBoxCtrl(const LLCheckBoxCtrl::Params& p)
: LLUICtrl(p),
mTextEnabledColor(p.label_text.text_color()),
mTextDisabledColor(p.label_text.text_readonly_color()),
mFont(p.font())
{
mViewModel->setValue(LLSD(p.initial_value));
mViewModel->resetDirty();
static LLUICachedControl<S32> llcheckboxctrl_spacing ("UICheckboxctrlSpacing", 0);
static LLUICachedControl<S32> llcheckboxctrl_hpad ("UICheckboxctrlHPad", 0);
static LLUICachedControl<S32> llcheckboxctrl_vpad ("UICheckboxctrlVPad", 0);
static LLUICachedControl<S32> llcheckboxctrl_btn_size ("UICheckboxctrlBtnSize", 0);
// must be big enough to hold all children
setUseBoundingRect(TRUE);
// *HACK Get rid of this with SL-55508...
// this allows blank check boxes and radio boxes for now
std::string local_label = p.label;
if(local_label.empty())
{
local_label = " ";
}
LLTextBox::Params tbparams = p.label_text;
tbparams.initial_value(local_label);
if (p.font.isProvided())
{
tbparams.font(p.font);
}
mLabel = LLUICtrlFactory::create<LLTextBox> (tbparams);
mLabel->reshapeToFitText();
addChild(mLabel);
LLRect label_rect = mLabel->getRect();
// Button
// Note: button cover the label by extending all the way to the right.
LLRect btn_rect = p.check_button.rect();
btn_rect.setOriginAndSize(
btn_rect.mLeft,
btn_rect.mBottom,
llmax(btn_rect.mRight, label_rect.mRight - btn_rect.mLeft),
llmax( label_rect.getHeight(), btn_rect.mTop));
std::string active_true_id, active_false_id;
std::string inactive_true_id, inactive_false_id;
LLButton::Params params = p.check_button;
params.rect(btn_rect);
//params.control_name(p.control_name);
params.click_callback.function(boost::bind(&LLCheckBoxCtrl::onCommit, this));
params.commit_on_return(false);
// Checkboxes only allow boolean initial values, but buttons can
// take any LLSD.
params.initial_value(LLSD(p.initial_value));
params.follows.flags(FOLLOWS_LEFT | FOLLOWS_BOTTOM);
mButton = LLUICtrlFactory::create<LLButton>(params);
addChild(mButton);
}
LLAccordionCtrlTab::LLAccordionCtrlTabHeader::LLAccordionCtrlTabHeader(
const LLAccordionCtrlTabHeader::Params& p)
: LLUICtrl(p)
, mHeaderBGColor(p.header_bg_color())
, mNeedsHighlight(false)
, mIsSelected(false),
mImageCollapsed(p.header_collapse_img),
mImageCollapsedPressed(p.header_collapse_img_pressed),
mImageExpanded(p.header_expand_img),
mImageExpandedPressed(p.header_expand_img_pressed),
mImageHeader(p.header_image),
mImageHeaderOver(p.header_image_over),
mImageHeaderPressed(p.header_image_pressed),
mImageHeaderFocused(p.header_image_focused)
{
LLTextBox::Params textboxParams;
textboxParams.name(DD_TEXTBOX_NAME);
textboxParams.initial_value(p.title());
textboxParams.text_color(p.header_text_color());
textboxParams.follows.flags(FOLLOWS_NONE);
textboxParams.font( p.font() );
textboxParams.font_shadow(LLFontGL::NO_SHADOW);
textboxParams.use_ellipses = true;
textboxParams.bg_visible = false;
textboxParams.mouse_opaque = false;
mHeaderTextbox = LLUICtrlFactory::create<LLTextBox>(textboxParams);
addChild(mHeaderTextbox);
}
void LLDragHandleTop::setTitle(const std::string& title)
{
std::string trimmed_title = title;
LLStringUtil::trim(trimmed_title);
if( mTitleBox )
{
mTitleBox->setText(trimmed_title);
}
else
{
const LLFontGL* font = LLFontGL::getFontSansSerif();
LLTextBox::Params params;
params.name("Drag Handle Title");
params.rect(getRect());
params.initial_value(trimmed_title);
params.font(font);
params.follows.flags(FOLLOWS_TOP | FOLLOWS_LEFT | FOLLOWS_RIGHT);
params.font_shadow(LLFontGL::DROP_SHADOW_SOFT);
params.use_ellipses = true;
params.allow_html = false; //cancel URL replacement in floater title
mTitleBox = LLUICtrlFactory::create<LLTextBox> (params);
addChild( mTitleBox );
}
reshapeTitleBox();
}
LLUploadDialog::LLUploadDialog( const std::string& msg)
: LLPanel()
{
setBackgroundVisible( TRUE );
if( LLUploadDialog::sDialog )
{
delete LLUploadDialog::sDialog;
}
LLUploadDialog::sDialog = this;
const LLFontGL* font = LLFontGL::getFontSansSerif();
LLRect msg_rect;
for (int line_num=0; line_num<16; ++line_num)
{
LLTextBox::Params params;
params.name("Filename");
params.rect(msg_rect);
params.initial_value("Filename");
params.font(font);
mLabelBox[line_num] = LLUICtrlFactory::create<LLTextBox> (params);
addChild(mLabelBox[line_num]);
}
setMessage(msg);
// The dialog view is a root view
gViewerWindow->addPopup(this);
}
LLSpinCtrl::LLSpinCtrl(const LLSpinCtrl::Params& p)
: LLF32UICtrl(p),
mLabelBox(NULL),
mbHasBeenSet( FALSE ),
mPrecision(p.decimal_digits),
mTextEnabledColor(p.text_enabled_color()),
mTextDisabledColor(p.text_disabled_color())
{
static LLUICachedControl<S32> spinctrl_spacing ("UISpinctrlSpacing", 0);
static LLUICachedControl<S32> spinctrl_btn_width ("UISpinctrlBtnWidth", 0);
static LLUICachedControl<S32> spinctrl_btn_height ("UISpinctrlBtnHeight", 0);
S32 centered_top = getRect().getHeight();
S32 centered_bottom = getRect().getHeight() - 2 * spinctrl_btn_height;
S32 btn_left = 0;
// reserve space for spinner
S32 label_width = llclamp(p.label_width(), 0, llmax(0, getRect().getWidth() - 40));
// Label
if( !p.label().empty() )
{
LLRect label_rect( 0, centered_top, label_width, centered_bottom );
LLTextBox::Params params;
params.wrap(p.label_wrap);
params.name("SpinCtrl Label");
params.rect(label_rect);
params.initial_value(p.label());
if (p.font.isProvided())
{
params.font(p.font);
}
mLabelBox = LLUICtrlFactory::create<LLTextBox> (params);
addChild(mLabelBox);
btn_left += label_rect.mRight + spinctrl_spacing;
}
S32 btn_right = btn_left + spinctrl_btn_width;
// Spin buttons
LLButton::Params up_button_params(p.up_button);
up_button_params.rect = LLRect(btn_left, getRect().getHeight(), btn_right, getRect().getHeight() - spinctrl_btn_height);
up_button_params.click_callback.function(boost::bind(&LLSpinCtrl::onUpBtn, this, _2));
up_button_params.mouse_held_callback.function(boost::bind(&LLSpinCtrl::onUpBtn, this, _2));
mUpBtn = LLUICtrlFactory::create<LLButton>(up_button_params);
addChild(mUpBtn);
LLButton::Params down_button_params(p.down_button);
down_button_params.rect = LLRect(btn_left, getRect().getHeight() - spinctrl_btn_height, btn_right, getRect().getHeight() - 2 * spinctrl_btn_height);
down_button_params.click_callback.function(boost::bind(&LLSpinCtrl::onDownBtn, this, _2));
down_button_params.mouse_held_callback.function(boost::bind(&LLSpinCtrl::onDownBtn, this, _2));
mDownBtn = LLUICtrlFactory::create<LLButton>(down_button_params);
addChild(mDownBtn);
LLRect editor_rect( btn_right + 1, centered_top, getRect().getWidth(), centered_bottom );
LLLineEditor::Params params;
params.name("SpinCtrl Editor");
params.rect(editor_rect);
if (p.font.isProvided())
{
params.font(p.font);
}
params.max_length.bytes(MAX_STRING_LENGTH);
params.commit_callback.function((boost::bind(&LLSpinCtrl::onEditorCommit, this, _2)));
//*NOTE: allow entering of any chars for LLCalc, proper input will be evaluated on commit
params.follows.flags(FOLLOWS_LEFT | FOLLOWS_BOTTOM);
mEditor = LLUICtrlFactory::create<LLLineEditor> (params);
mEditor->setFocusReceivedCallback( boost::bind(&LLSpinCtrl::onEditorGainFocus, _1, this ));
//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->setSelectAllonCommit(FALSE);
addChild(mEditor);
updateEditor();
setUseBoundingRect( TRUE );
}
LLMultiSliderCtrl::LLMultiSliderCtrl(const LLMultiSliderCtrl::Params& p)
: LLF32UICtrl(p),
mLabelBox( NULL ),
mEditor( NULL ),
mTextBox( NULL ),
mTextEnabledColor(p.text_color()),
mTextDisabledColor(p.text_disabled_color())
{
static LLUICachedControl<S32> multi_sliderctrl_spacing ("UIMultiSliderctrlSpacing", 0);
S32 top = getRect().getHeight();
S32 bottom = 0;
S32 left = 0;
S32 label_width = p.label_width;
S32 text_width = p.text_width;
// Label
if( !p.label().empty() )
{
if (p.label_width == 0)
{
label_width = p.font()->getWidth(p.label);
}
LLRect label_rect( left, top, label_width, bottom );
LLTextBox::Params params;
params.name("MultiSliderCtrl Label");
params.rect(label_rect);
params.initial_value(p.label());
params.font(p.font);
mLabelBox = LLUICtrlFactory::create<LLTextBox> (params);
addChild(mLabelBox);
}
S32 slider_right = getRect().getWidth();
if (p.show_text)
{
if (!p.text_width.isProvided())
{
text_width = 0;
// calculate the size of the text box (log max_value is number of digits - 1 so plus 1)
if ( p.max_value() )
text_width = p.font()->getWidth(std::string("0")) * ( static_cast < S32 > ( log10 ( p.max_value ) ) + p.decimal_digits + 1 );
if ( p.increment < 1.0f )
text_width += p.font()->getWidth(std::string(".")); // (mostly) take account of decimal point in value
if ( p.min_value < 0.0f || p.max_value < 0.0f )
text_width += p.font()->getWidth(std::string("-")); // (mostly) take account of minus sign
// padding to make things look nicer
text_width += 8;
}
S32 text_left = getRect().getWidth() - text_width;
slider_right = text_left - multi_sliderctrl_spacing;
LLRect text_rect( text_left, top, getRect().getWidth(), bottom );
if( p.can_edit_text )
{
LLLineEditor::Params params;
params.name("MultiSliderCtrl Editor");
params.rect(text_rect);
params.font(p.font);
params.max_length_bytes(MAX_STRING_LENGTH);
params.commit_callback.function(LLMultiSliderCtrl::onEditorCommit);
params.prevalidate_callback(&LLTextValidate::validateFloat);
params.follows.flags(FOLLOWS_LEFT | FOLLOWS_BOTTOM);
mEditor = LLUICtrlFactory::create<LLLineEditor> (params);
mEditor->setFocusReceivedCallback( boost::bind(LLMultiSliderCtrl::onEditorGainFocus, _1, this) );
// 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
{
LLTextBox::Params params;
params.name("MultiSliderCtrl Text");
params.rect(text_rect);
params.font(p.font);
params.follows.flags(FOLLOWS_LEFT | FOLLOWS_BOTTOM);
mTextBox = LLUICtrlFactory::create<LLTextBox> (params);
addChild(mTextBox);
}
}
S32 slider_left = label_width ? label_width + multi_sliderctrl_spacing : 0;
LLRect slider_rect( slider_left, top, slider_right, bottom );
LLMultiSlider::Params params;
params.sliders = p.sliders;
params.rect(slider_rect);
params.commit_callback.function( LLMultiSliderCtrl::onSliderCommit );
params.mouse_down_callback( p.mouse_down_callback );
params.mouse_up_callback( p.mouse_up_callback );
params.initial_value(p.initial_value());
params.min_value(p.min_value);
params.max_value(p.max_value);
params.increment(p.increment);
params.max_sliders(p.max_sliders);
params.allow_overlap(p.allow_overlap);
params.draw_track(p.draw_track);
params.use_triangle(p.use_triangle);
params.control_name(p.control_name);
mMultiSlider = LLUICtrlFactory::create<LLMultiSlider> (params);
addChild( mMultiSlider );
mCurValue = mMultiSlider->getCurSliderValue();
updateText();
}
LLToastAlertPanel::LLToastAlertPanel( LLNotificationPtr notification, bool modal)
: LLToastPanel(notification),
mDefaultOption( 0 ),
mCheck(NULL),
mCaution(notification->getPriority() >= NOTIFICATION_PRIORITY_HIGH),
mLabel(notification->getName()),
mLineEditor(NULL)
{
const LLFontGL* font = LLFontGL::getFontSansSerif();
const S32 LINE_HEIGHT = llfloor(font->getLineHeight() + 0.99f);
const S32 EDITOR_HEIGHT = 20;
LLNotificationFormPtr form = mNotification->getForm();
std::string edit_text_name;
std::string edit_text_contents;
S32 edit_text_max_chars = 0;
bool is_password = false;
LLToastPanel::setBackgroundVisible(FALSE);
LLToastPanel::setBackgroundOpaque(TRUE);
typedef std::vector<std::pair<std::string, std::string> > options_t;
options_t supplied_options;
// for now, get LLSD to iterator over form elements
LLSD form_sd = form->asLLSD();
S32 option_index = 0;
for (LLSD::array_const_iterator it = form_sd.beginArray(); it != form_sd.endArray(); ++it)
{
std::string type = (*it)["type"].asString();
if (type == "button")
{
if((*it)["default"])
{
mDefaultOption = option_index;
}
supplied_options.push_back(std::make_pair((*it)["name"].asString(), (*it)["text"].asString()));
ButtonData data;
if (option_index == mNotification->getURLOption())
{
data.mURL = mNotification->getURL();
data.mURLExternal = mNotification->getURLOpenExternally();
}
mButtonData.push_back(data);
option_index++;
}
else if (type == "text")
{
edit_text_contents = (*it)["value"].asString();
edit_text_name = (*it)["name"].asString();
edit_text_max_chars = (*it)["max_length_chars"].asInteger();
}
else if (type == "password")
{
edit_text_contents = (*it)["value"].asString();
edit_text_name = (*it)["name"].asString();
is_password = true;
}
}
// Buttons
options_t options;
if (supplied_options.empty())
{
options.push_back(std::make_pair(std::string("close"), LLNotifications::instance().getGlobalString("implicitclosebutton")));
// add data for ok button.
ButtonData ok_button;
mButtonData.push_back(ok_button);
mDefaultOption = 0;
}
else
{
options = supplied_options;
}
S32 num_options = options.size();
// Calc total width of buttons
S32 button_width = 0;
S32 sp = font->getWidth(std::string("OO"));
for( S32 i = 0; i < num_options; i++ )
{
S32 w = S32(font->getWidth( options[i].second ) + 0.99f) + sp + 2 * LLBUTTON_H_PAD;
button_width = llmax( w, button_width );
}
S32 btn_total_width = button_width;
if( num_options > 1 )
{
btn_total_width = (num_options * button_width) + ((num_options - 1) * BTN_HPAD);
}
// Message: create text box using raw string, as text has been structure deliberately
// Use size of created text box to generate dialog box size
std::string msg = mNotification->getMessage();
llwarns << "Alert: " << msg << llendl;
LLTextBox::Params params;
params.name("Alert message");
params.font(font);
params.tab_stop(false);
params.wrap(true);
params.follows.flags(FOLLOWS_LEFT | FOLLOWS_TOP);
params.allow_scroll(true);
LLTextBox * msg_box = LLUICtrlFactory::create<LLTextBox> (params);
// Compute max allowable height for the dialog text, so we can allocate
// space before wrapping the text to fit.
S32 max_allowed_msg_height =
gFloaterView->getRect().getHeight()
- LINE_HEIGHT // title bar
- 3*VPAD - BTN_HEIGHT;
// reshape to calculate real text width and height
msg_box->reshape( MAX_ALLOWED_MSG_WIDTH, max_allowed_msg_height );
msg_box->setValue(msg);
S32 pixel_width = msg_box->getTextPixelWidth();
S32 pixel_height = msg_box->getTextPixelHeight();
// We should use some space to prevent set textbox's scroller visible when it is unnecessary.
msg_box->reshape( llmin(MAX_ALLOWED_MSG_WIDTH,pixel_width + 2 * msg_box->getHPad() + HPAD),
llmin(max_allowed_msg_height,pixel_height + 2 * msg_box->getVPad()) ) ;
const LLRect& text_rect = msg_box->getRect();
S32 dialog_width = llmax( btn_total_width, text_rect.getWidth() ) + 2 * HPAD;
S32 dialog_height = text_rect.getHeight() + 3 * VPAD + BTN_HEIGHT;
if (hasTitleBar())
{
dialog_height += LINE_HEIGHT; // room for title bar
}
// it's ok for the edit text body to be empty, but we want the name to exist if we're going to draw it
if (!edit_text_name.empty())
{
dialog_height += EDITOR_HEIGHT + VPAD;
dialog_width = llmax(dialog_width, (S32)(font->getWidth( edit_text_contents ) + 0.99f));
}
if (mCaution)
{
// Make room for the caution icon.
dialog_width += 32 + HPAD;
}
LLToastPanel::reshape( dialog_width, dialog_height, FALSE );
S32 msg_y = LLToastPanel::getRect().getHeight() - VPAD;
S32 msg_x = HPAD;
if (hasTitleBar())
{
msg_y -= LINE_HEIGHT; // room for title
}
static LLUIColor alert_caution_text_color = LLUIColorTable::instance().getColor("AlertCautionTextColor");
if (mCaution)
{
LLIconCtrl* icon = LLUICtrlFactory::getInstance()->createFromFile<LLIconCtrl>("alert_icon.xml", this, LLPanel::child_registry_t::instance());
if(icon)
{
icon->setRect(LLRect(msg_x, msg_y, msg_x+32, msg_y-32));
LLToastPanel::addChild(icon);
}
msg_x += 32 + HPAD;
msg_box->setColor( alert_caution_text_color );
}
LLRect rect;
rect.setLeftTopAndSize( msg_x, msg_y, text_rect.getWidth(), text_rect.getHeight() );
msg_box->setRect( rect );
LLToastPanel::addChild(msg_box);
// (Optional) Edit Box
if (!edit_text_name.empty())
{
S32 y = VPAD + BTN_HEIGHT + VPAD/2;
mLineEditor = LLUICtrlFactory::getInstance()->createFromFile<LLLineEditor>("alert_line_editor.xml", this, LLPanel::child_registry_t::instance());
if (mLineEditor)
{
LLRect leditor_rect = LLRect( HPAD, y+EDITOR_HEIGHT, dialog_width-HPAD, y);
mLineEditor->setName(edit_text_name);
mLineEditor->reshape(leditor_rect.getWidth(), leditor_rect.getHeight());
mLineEditor->setRect(leditor_rect);
mLineEditor->setMaxTextChars(edit_text_max_chars);
mLineEditor->setText(edit_text_contents);
// decrease limit of line editor of teleport offer dialog to avoid truncation of
// location URL in invitation message, see EXT-6891
if ("OfferTeleport" == mNotification->getName())
{
mLineEditor->setMaxTextLength(gSavedSettings.getS32(
"teleport_offer_invitation_max_length"));
}
else
{
mLineEditor->setMaxTextLength(STD_STRING_STR_LEN - 1);
}
LLToastPanel::addChild(mLineEditor);
mLineEditor->setDrawAsterixes(is_password);
setEditTextArgs(notification->getSubstitutions());
mLineEditor->setFollowsLeft();
mLineEditor->setFollowsRight();
// find form text input field
LLSD form_text;
for (LLSD::array_const_iterator it = form_sd.beginArray(); it != form_sd.endArray(); ++it)
{
std::string type = (*it)["type"].asString();
if (type == "text")
{
form_text = (*it);
}
}
// if form text input field has width attribute
if (form_text.has("width"))
{
// adjust floater width to fit line editor
S32 editor_width = form_text["width"];
LLRect editor_rect = mLineEditor->getRect();
U32 width_delta = editor_width - editor_rect.getWidth();
LLRect toast_rect = getRect();
reshape(toast_rect.getWidth() + width_delta, toast_rect.getHeight());
}
}
}
// Buttons
S32 button_left = (LLToastPanel::getRect().getWidth() - btn_total_width) / 2;
for( S32 i = 0; i < num_options; i++ )
{
LLRect button_rect;
LLButton* btn = LLUICtrlFactory::getInstance()->createFromFile<LLButton>("alert_button.xml", this, LLPanel::child_registry_t::instance());
if(btn)
{
btn->setName(options[i].first);
btn->setRect(button_rect.setOriginAndSize( button_left, VPAD, button_width, BTN_HEIGHT ));
btn->setLabel(options[i].second);
btn->setFont(font);
btn->setClickedCallback(boost::bind(&LLToastAlertPanel::onButtonPressed, this, _2, i));
mButtonData[i].mButton = btn;
LLToastPanel::addChild(btn);
if( i == mDefaultOption )
{
btn->setFocus(TRUE);
}
}
button_left += button_width + BTN_HPAD;
}
std::string ignore_label;
if (form->getIgnoreType() == LLNotificationForm::IGNORE_WITH_DEFAULT_RESPONSE)
{
setCheckBox(LLNotifications::instance().getGlobalString("skipnexttime"), ignore_label);
}
else if (form->getIgnoreType() == LLNotificationForm::IGNORE_WITH_LAST_RESPONSE)
{
setCheckBox(LLNotifications::instance().getGlobalString("alwayschoose"), ignore_label);
}
// *TODO: check necessity of this code
//gFloaterView->adjustToFitScreen(this, FALSE);
if (mLineEditor)
{
mLineEditor->selectAll();
}
if(mDefaultOption >= 0)
{
// delay before enabling default button
mDefaultBtnTimer.start();
mDefaultBtnTimer.setTimerExpirySec(DEFAULT_BUTTON_DELAY);
}
LLTransientFloaterMgr::instance().addControlView(
LLTransientFloaterMgr::GLOBAL, this);
}
LLCheckBoxCtrl::LLCheckBoxCtrl(const LLCheckBoxCtrl::Params& p)
: LLUICtrl(p),
mTextEnabledColor(p.text_enabled_color()),
mTextDisabledColor(p.text_disabled_color()),
mFont(p.font())
{
mViewModel->setValue(LLSD(p.initial_value));
mViewModel->resetDirty();
static LLUICachedControl<S32> llcheckboxctrl_spacing ("UICheckboxctrlSpacing", 0);
static LLUICachedControl<S32> llcheckboxctrl_hpad ("UICheckboxctrlHPad", 0);
static LLUICachedControl<S32> llcheckboxctrl_vpad ("UICheckboxctrlVPad", 0);
static LLUICachedControl<S32> llcheckboxctrl_btn_size ("UICheckboxctrlBtnSize", 0);
// must be big enough to hold all children
setUseBoundingRect(TRUE);
// Label (add a little space to make sure text actually renders)
const S32 FUDGE = 10;
S32 text_width = mFont->getWidth( p.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 );
// *HACK Get rid of this with SL-55508...
// this allows blank check boxes and radio boxes for now
std::string local_label = p.label;
if(local_label.empty())
{
local_label = " ";
}
LLTextBox::Params tbparams = p.label_text;
tbparams.rect(label_rect);
tbparams.initial_value(local_label);
if (p.font.isProvided())
{
tbparams.font(p.font);
}
tbparams.text_color( p.enabled() ? p.text_enabled_color() : p.text_disabled_color() );
mLabel = LLUICtrlFactory::create<LLTextBox> (tbparams);
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);
std::string active_true_id, active_false_id;
std::string inactive_true_id, inactive_false_id;
LLButton::Params params = p.check_button;
params.rect(btn_rect);
//params.control_name(p.control_name);
params.click_callback.function(boost::bind(&LLCheckBoxCtrl::onButtonPress, this, _2));
params.commit_on_return(false);
// Checkboxes only allow boolean initial values, but buttons can
// take any LLSD.
params.initial_value(LLSD(p.initial_value));
params.follows.flags(FOLLOWS_LEFT | FOLLOWS_BOTTOM);
mButton = LLUICtrlFactory::create<LLButton>(params);
addChild(mButton);
}