void LLPanelLogin::updateGridCombo()
{
const std::string &defaultGrid = gHippoGridManager->getDefaultGridName();
LLComboBox *grids = getChild<LLComboBox>("grids_combo");
std::string top_entry;
grids->removeall();
const HippoGridInfo *curGrid = gHippoGridManager->getCurrentGrid();
const HippoGridInfo *defGrid = gHippoGridManager->getGrid(defaultGrid);
HippoGridManager::GridIterator it, end = gHippoGridManager->endGrid();
for (it = gHippoGridManager->beginGrid(); it != end; ++it)
{
std::string grid = it->second->getGridName();
if(grid.empty() || it->second == defGrid || it->second == curGrid)
continue;
grids->add(grid);
}
if(curGrid || defGrid)
{
if(defGrid)
grids->add(defGrid->getGridName(),ADD_TOP);
if(curGrid && defGrid != curGrid)
grids->add(curGrid->getGridName(),ADD_TOP);
grids->setCurrentByIndex(0);
}
else
{
grids->setLabel(LLStringExplicit("")); // LLComboBox::removeall() does not clear the label
}
}
BOOL LLFloaterMessageBuilder::postBuild()
{
childSetText("message_edit", mInitialText);
childSetAction("send_btn", onClickSend, this);
std::vector<std::string> names;
LLComboBox* combo;
LLMessageSystem::message_template_name_map_t::iterator temp_end = gMessageSystem->mMessageTemplates.end();
LLMessageSystem::message_template_name_map_t::iterator temp_iter;
std::vector<std::string>::iterator names_end;
std::vector<std::string>::iterator names_iter;
for(temp_iter = gMessageSystem->mMessageTemplates.begin(); temp_iter != temp_end; ++temp_iter)
if((*temp_iter).second->getTrust() == MT_NOTRUST)
names.push_back((*temp_iter).second->mName);
std::sort(names.begin(), names.end());
combo = getChild<LLComboBox>("untrusted_message_combo");
names_end = names.end();
for(names_iter = names.begin(); names_iter != names_end; ++names_iter)
combo->add((*names_iter));
names.clear();
for(temp_iter = gMessageSystem->mMessageTemplates.begin(); temp_iter != temp_end; ++temp_iter)
if((*temp_iter).second->getTrust() == MT_TRUST)
names.push_back((*temp_iter).second->mName);
std::sort(names.begin(), names.end());
combo = getChild<LLComboBox>("trusted_message_combo");
names_end = names.end();
for(names_iter = names.begin(); names_iter != names_end; ++names_iter)
combo->add((*names_iter));
childSetCommitCallback("untrusted_message_combo", onCommitPacketCombo, this);
childSetCommitCallback("trusted_message_combo", onCommitPacketCombo, this);
return TRUE;
}
void PanelPreferenceFirestorm::refreshBeamLists()
{
LLComboBox* comboBox = getChild<LLComboBox>("FSBeamShape_combo");
if(comboBox != NULL)
{
comboBox->removeall();
comboBox->add("===OFF===");
std::vector<std::string> names = gLggBeamMaps.getFileNames();
for(int i=0; i<(int)names.size(); i++)
{
comboBox->add(names[i]);
}
comboBox->setSimple(gSavedSettings.getString("FSBeamShape"));
}
comboBox = getChild<LLComboBox>("BeamColor_combo");
if(comboBox != NULL)
{
comboBox->removeall();
comboBox->add("===OFF===");
std::vector<std::string> names = gLggBeamMaps.getColorsFileNames();
for(int i=0; i<(int)names.size(); i++)
{
comboBox->add(names[i]);
}
comboBox->setSimple(gSavedSettings.getString("FSBeamColorFile"));
}
}
void FSPanelPrefs::refreshBeamLists()
{
static const std::string off_label = getString("BeamsOffLabel");
LLComboBox* comboBox = findChild<LLComboBox>("FSBeamShape_combo");
if (comboBox)
{
comboBox->removeall();
comboBox->add(off_label, LLSD(""));
string_vec_t names = gLggBeamMaps.getFileNames();
for (string_vec_t::iterator it = names.begin(); it != names.end(); ++it)
{
comboBox->add(*it, LLSD(*it));
}
comboBox->setSimple(gSavedSettings.getString("FSBeamShape"));
}
comboBox = findChild<LLComboBox>("BeamColor_combo");
if (comboBox)
{
comboBox->removeall();
comboBox->add(off_label, LLSD(""));
string_vec_t names = gLggBeamMaps.getColorsFileNames();
for (string_vec_t::iterator it = names.begin(); it != names.end(); ++it)
{
comboBox->add(*it, LLSD(*it));
}
comboBox->setSimple(gSavedSettings.getString("FSBeamColorFile"));
}
}
void LLPanelLogin::updateGridCombo()
{
const std::string &defaultGrid = gHippoGridManager->getDefaultGridNick();
const std::string ¤tGrid = gHippoGridManager->getCurrentGridNick();
LLComboBox *grids = getChild<LLComboBox>("grids_combo");
S32 selectIndex = -1, i = 0;
grids->removeall();
if (defaultGrid != "") {
grids->add(defaultGrid);
selectIndex = i++;
}
HippoGridManager::GridIterator it, end = gHippoGridManager->endGrid();
for (it = gHippoGridManager->beginGrid(); it != end; ++it) {
const std::string &grid = it->second->getGridName();
if (grid != defaultGrid) {
grids->add(grid);
if (grid == currentGrid) selectIndex = i;
i++;
}
}
if (selectIndex >= 0) {
grids->setCurrentByIndex(selectIndex);
} else {
grids->setLabel(LLStringExplicit("")); // LLComboBox::removeall() does not clear the label
}
}
// static
void LLPanelLogin::addServer(const std::string& server)
{
if (!sInstance)
{
llwarns << "Attempted addServer with no login view shown" << llendl;
return;
}
const std::string &defaultGrid = gHippoGridManager->getDefaultGridNick();
LLComboBox *grids = sInstance->getChild<LLComboBox>("server_combo");
S32 selectIndex = -1, i = 0;
grids->removeall();
if (defaultGrid != "") {
grids->add(defaultGrid);
selectIndex = i++;
}
HippoGridManager::GridIterator it, end = gHippoGridManager->endGrid();
for (it = gHippoGridManager->beginGrid(); it != end; ++it) {
const std::string &grid = it->second->getGridNick();
if (grid != defaultGrid) {
grids->add(grid);
//if (grid == mCurGrid) selectIndex = i;
i++;
}
}
// when you first login select the default, otherwise last connected
if (gDisconnected)
{
grids->setSimple(gHippoGridManager->getCurrentGrid()->getGridNick());
}
else
{
std::string last_grid = gSavedSettings.getString("CmdLineGridChoice");//imprudence TODO:errorcheck
std::string cmd_line_login_uri = gSavedSettings.getLLSD("CmdLineLoginURI").asString();
if (!last_grid.empty()&& cmd_line_login_uri.empty())//don't use --grid if --loginuri is also given
{
//give user chance to change their mind, even with --grid set
gSavedSettings.setString("CmdLineGridChoice","");
}
else if (!cmd_line_login_uri.empty())
{
last_grid = cmd_line_login_uri;
//also clear --grid no matter if it was given
gSavedSettings.setString("CmdLineGridChoice","");
}
else if (last_grid.empty())
{
last_grid = gSavedSettings.getString("LastSelectedGrid");
}
if (last_grid.empty()) last_grid = defaultGrid;
grids->setSimple(last_grid);
}
//LLComboBox* combo = sInstance->getChild<LLComboBox>("server_combo");
//combo->add(server, LLSD(domain_name) );
//combo->setCurrentByIndex(0);
}
bool LLFloaterDayCycle::newPromptCallback(const LLSD& notification, const LLSD& response)
{
std::string text = response["message"].asString();
S32 option = LLNotification::getSelectedOption(notification, response);
if(text == "")
{
return false;
}
if(option == 0) {
LLComboBox* comboBox = sDayCycle->getChild<LLComboBox>("DayCyclePresetsCombo");
LLFloaterDayCycle* sDayCycle = NULL;
LLComboBox* keyCombo = NULL;
if(LLFloaterDayCycle::isOpen())
{
sDayCycle = LLFloaterDayCycle::instance();
keyCombo = sDayCycle->getChild<LLComboBox>("WLKeyPresets");
}
// add the current parameters to the list
// see if it's there first
// if not there, add a new one
if(LLDayCycleManager::getInstance()->findPreset(text).empty())
{
//AscentDayCycleManager::instance()->addParamSet(text,
// AscentDayCycleManager::instance()->mCurParams);
LLDayCycleManager::getInstance()->savePreset(text,
LLWLParamManager::getInstance()->mDay.asLLSD());
comboBox->add(text);
comboBox->sortByName();
// add a blank to the bottom
comboBox->selectFirstItem();
if(comboBox->getSimple() == "")
{
comboBox->remove(0);
}
comboBox->add(LLStringUtil::null);
comboBox->setSelectedByValue(text, true);
if(LLFloaterDayCycle::isOpen())
{
keyCombo->add(text);
keyCombo->sortByName();
}
}
else // otherwise, send a message to the user
{
LLNotificationsUtil::add("ExistsSkyPresetAlert");
}
}
return false;
}
bool LLFloaterWindLight::newPromptCallback(const LLSD& notification, const LLSD& response)
{
std::string text = response["message"].asString();
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
if(text == "")
{
return false;
}
if(option == 0) {
LLComboBox* comboBox = getChild<LLComboBox>("WLPresetsCombo");
LLFloaterDayCycle* day_cycle = LLFloaterReg::findTypedInstance<LLFloaterDayCycle>("env_day_cycle");
LLComboBox* keyCombo = NULL;
if(day_cycle)
{
keyCombo = day_cycle->getChild<LLComboBox>("WLKeyPresets");
}
// add the current parameters to the list
// see if it's there first
std::map<std::string, LLWLParamSet>::iterator mIt =
LLWLParamManager::instance()->mParamList.find(text);
// if not there, add a new one
if(mIt == LLWLParamManager::instance()->mParamList.end())
{
LLWLParamManager::instance()->addParamSet(text,
LLWLParamManager::instance()->mCurParams);
comboBox->add(text);
comboBox->sortByName();
// add a blank to the bottom
comboBox->selectFirstItem();
if(comboBox->getSimple() == "")
{
comboBox->remove(0);
}
comboBox->add(LLStringUtil::null);
comboBox->setSelectedByValue(text, true);
if(keyCombo)
{
keyCombo->add(text);
keyCombo->sortByName();
}
LLWLParamManager::instance()->savePreset(text);
// otherwise, send a message to the user
}
else
{
LLNotificationsUtil::add("ExistsSkyPresetAlert");
}
}
return false;
}
void LLFloaterWindLight::newPromptCallback(S32 option, const std::string& text, void* userData)
{
if(text == "")
{
return;
}
if(option == 0) {
LLComboBox* comboBox = sWindLight->getChild<LLComboBox>(
"WLPresetsCombo");
LLFloaterDayCycle* sDayCycle = NULL;
LLComboBox* keyCombo = NULL;
if(LLFloaterDayCycle::isOpen())
{
sDayCycle = LLFloaterDayCycle::instance();
keyCombo = sDayCycle->getChild<LLComboBox>(
"WLKeyPresets");
}
// add the current parameters to the list
// see if it's there first
std::map<std::string, LLWLParamSet>::iterator mIt =
LLWLParamManager::instance()->mParamList.find(text);
// if not there, add a new one
if(mIt == LLWLParamManager::instance()->mParamList.end())
{
LLWLParamManager::instance()->addParamSet(text,
LLWLParamManager::instance()->mCurParams);
comboBox->add(text);
comboBox->sortByName();
// add a blank to the bottom
comboBox->selectFirstItem();
if(comboBox->getSimple() == "")
{
comboBox->remove(0);
}
comboBox->add(LLStringUtil::null);
comboBox->setSelectedByValue(text, true);
if(LLFloaterDayCycle::isOpen())
{
keyCombo->add(text);
keyCombo->sortByName();
}
LLWLParamManager::instance()->savePreset(text);
// otherwise, send a message to the user
}
else
{
gViewerWindow->alertXml("ExistsSkyPresetAlert");
}
}
}
void LLPreviewGesture::addModifiers()
{
LLComboBox* combo = mModifierCombo;
combo->add( NONE_LABEL, ADD_BOTTOM );
combo->add( SHIFT_LABEL, ADD_BOTTOM );
combo->add( CTRL_LABEL, ADD_BOTTOM );
combo->setCurrentByIndex(0);
}
void LLPreviewGesture::addKeys()
{
LLComboBox* combo = mKeyCombo;
combo->add( NONE_LABEL );
for (KEY key = ' '; key < KEY_NONE; key++)
{
std::string keystr = valid_key_to_string(key);
if(keystr != "")combo->add( keystr, ADD_BOTTOM );
}
combo->setCurrentByIndex(0);
}
// TODO: Sort the legacy and non-legacy together?
void LLPreviewGesture::addAnimations()
{
LLComboBox* combo = mAnimationCombo;
combo->removeall();
std::string none_text = getString("none_text");
combo->add(none_text, LLUUID::null);
// Add all the default (legacy) animations
S32 i;
for (i = 0; i < gUserAnimStatesCount; ++i)
{
// Use the user-readable name
std::string label = LLAnimStateLabels::getStateLabel( gUserAnimStates[i].mName );
const LLUUID& id = gUserAnimStates[i].mID;
combo->add(label, id);
}
// Get all inventory items that are animations
LLViewerInventoryCategory::cat_array_t cats;
LLViewerInventoryItem::item_array_t items;
LLIsTypeWithPermissions is_copyable_animation(LLAssetType::AT_ANIMATION,
PERM_ITEM_UNRESTRICTED,
gAgent.getID(),
gAgent.getGroupID());
gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
cats,
items,
LLInventoryModel::EXCLUDE_TRASH,
is_copyable_animation);
// Copy into something we can sort
std::vector<LLInventoryItem*> animations;
S32 count = items.count();
for(i = 0; i < count; ++i)
{
animations.push_back( items.get(i) );
}
// Do the sort
std::sort(animations.begin(), animations.end(), SortItemPtrsByName());
// And load up the combobox
std::vector<LLInventoryItem*>::iterator it;
for (it = animations.begin(); it != animations.end(); ++it)
{
LLInventoryItem* item = *it;
combo->add(item->getName(), item->getAssetUUID(), ADD_BOTTOM);
}
}
// called from setFocus()
// called internally too
void HippoPanelGridsImpl::refresh()
{
const std::string &defaultGrid = gHippoGridManager->getDefaultGridName();
LLComboBox *grids = getChild<LLComboBox>("grid_selector");
S32 selectIndex = -1, i = 0;
grids->removeall();
if (defaultGrid != "") {
grids->add(defaultGrid);
selectIndex = i++;
}
HippoGridManager::GridIterator it, end = gHippoGridManager->endGrid();
for (it = gHippoGridManager->beginGrid(); it != end; ++it) {
const std::string &grid = it->second->getGridName();
if (grid != defaultGrid) {
grids->add(grid);
if (grid == mCurGrid) selectIndex = i;
i++;
}
}
if ((mState == ADD_NEW) || (mState == ADD_COPY)) {
grids->add("<new>");
selectIndex = i++;
}
if (selectIndex >= 0) {
grids->setCurrentByIndex(selectIndex);
} else {
grids->setLabel(LLStringExplicit("")); // LLComboBox::removeall() does not clear the label
}
childSetTextArg("default_grid", "[DEFAULT]", (defaultGrid != "")? defaultGrid: " ");
childSetEnabled("btn_delete", (selectIndex >= 0));
childSetEnabled("btn_copy", (mState == NORMAL) && (selectIndex >= 0));
childSetEnabled("btn_default", (mState == NORMAL) && (selectIndex > 0));
childSetEnabled("gridname", (mState == ADD_NEW) || (mState == ADD_COPY));
if (childGetValue("platform").asString() == "SecondLife") {
// disable platform selector, if logged into the grid edited and it is SL
// so object export restrictions cannot be circumvented by changing the platform
bool enablePlatform = (LLStartUp::getStartupState() < STATE_LOGIN_CLEANUP) ||
(mCurGrid != gHippoGridManager->getConnectedGrid()->getGridName());
childSetEnabled("platform", enablePlatform);
childSetEnabled("search", false);
childSetText("search", LLStringExplicit(""));
childSetEnabled("render_compat", false);
childSetValue("render_compat", false);
} else {
childSetEnabled("platform", true);
childSetEnabled("search", true);
childSetText("search", gHippoGridManager->getConnectedGrid()->getSearchUrl());
childSetEnabled("render_compat", true);
}
}
void LLPreviewGesture::addKeys()
{
LLComboBox* combo = mKeyCombo;
combo->add( NONE_LABEL );
for (KEY key = KEY_F2; key <= KEY_F12; key++)
{
combo->add( LLKeyboard::stringFromKey(key), ADD_BOTTOM );
}
combo->setCurrentByIndex(0);
}
// Update controls based on current settings
void LLPrefsAscentVan::refresh()
{
//General --------------------------------------------------------------------------------
//Tags\Colors ----------------------------------------------------------------------------
//Colors ---------------------------------------------------------------------------------
LLComboBox* combo = getChild<LLComboBox>("tag_spoofing_combobox");
if(LLVOAvatar::sClientResolutionList.has("isComplete"))
{
//combo->setColor(LLColor4::black);
combo->clear();
for(LLSD::map_iterator itr = LLVOAvatar::sClientResolutionList.beginMap(); itr != LLVOAvatar::sClientResolutionList.endMap(); itr++)
{
LLSD value = (*itr).second;
if(value.has("name"))
{
std::string name = value.get("name");
std::string uuid = (*itr).first;
LLColor4 color = LLColor4(value.get("color"));
if(value["multiple"].asReal() != 0)
{
color *= 1.0/(value["multiple"].asReal()+1.0f);
}
LLScrollListItem* item = combo->add(name,uuid);
//bad practice
item->getColumn(0)->setColor(color);
}
}
//add Viewer 2.0
LLScrollListItem* item = combo->add("Viewer 2.0",IMG_DEFAULT_AVATAR);
//bad practice
item->getColumn(0)->setColor(LLColor4::black);
}
combo->setCurrentByIndex(mSelectedClient);
childSetEnabled("friends_color_textbox", mUseStatusColors);
childSetEnabled("friend_color_swatch", mUseStatusColors);
childSetEnabled("estate_owner_color_swatch", mUseStatusColors);
childSetEnabled("linden_color_swatch", mUseStatusColors);
childSetEnabled("muted_color_swatch", mUseStatusColors);
childSetEnabled("custom_tag_label_text", mCustomTagOn);
childSetEnabled("custom_tag_label_box", mCustomTagOn);
childSetValue("custom_tag_label_box", gSavedSettings.getString("AscentCustomTagLabel"));
childSetEnabled("custom_tag_color_text", mCustomTagOn);
childSetEnabled("custom_tag_color_swatch", mCustomTagOn);
//Body Dynamics --------------------------------------------------------------------------
childSetEnabled("EmeraldBoobMass", mBreastPhysicsToggle);
childSetEnabled("EmeraldBoobHardness", mBreastPhysicsToggle);
childSetEnabled("EmeraldBoobVelMax", mBreastPhysicsToggle);
childSetEnabled("EmeraldBoobFriction", mBreastPhysicsToggle);
childSetEnabled("EmeraldBoobVelMin", mBreastPhysicsToggle);
}
LLFloaterDayCycle::LLFloaterDayCycle() : LLFloater(std::string("Day Cycle Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_day_cycle_options.xml");
// add the combo boxes
LLComboBox* keyCombo = getChild<LLComboBox>("WLKeyPresets");
if(keyCombo != NULL)
{
LLWLParamManager::preset_name_list_t local_presets;
LLWLParamManager::getInstance()->getLocalPresetNames(local_presets);
for (LLWLParamManager::preset_name_list_t::const_iterator it = local_presets.begin(); it != local_presets.end(); ++it)
{
keyCombo->add(*it);
}
// set defaults on combo boxes
keyCombo->selectFirstItem();
}
// add the time slider
LLMultiSliderCtrl* sldr = getChild<LLMultiSliderCtrl>("WLTimeSlider");
sldr->addSlider();
// add the combo boxes
LLComboBox* comboBox = getChild<LLComboBox>("DayCyclePresetsCombo");
if(comboBox != NULL) {
LLDayCycleManager::preset_name_list_t day_presets;
LLDayCycleManager::getInstance()->getPresetNames(day_presets);
LLDayCycleManager::preset_name_list_t::const_iterator it;
for(it = day_presets.begin(); it != day_presets.end(); ++it)
{
comboBox->add(*it);
}
// entry for when we're in estate time
comboBox->add(LLStringUtil::null);
// set defaults on combo boxes
//comboBox->selectByValue(LLSD("Default"));
}
// load it up
initCallbacks();
}
LLFloaterWater::LLFloaterWater() : LLFloater(std::string("water floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_water.xml");
// add the combo boxes
LLComboBox* comboBox = getChild<LLComboBox>("WaterPresetsCombo");
if(comboBox != NULL) {
std::map<std::string, LLWaterParamSet>::iterator mIt =
LLWaterParamManager::instance()->mParamList.begin();
for(; mIt != LLWaterParamManager::instance()->mParamList.end(); mIt++)
{
comboBox->add(mIt->first);
}
// set defaults on combo boxes
comboBox->selectByValue(LLSD("Default"));
}
std::string def_water = getString("WLDefaultWaterNames");
// no editing or deleting of the blank string
sDefaultPresets.insert("");
boost_tokenizer tokens(def_water, boost::char_separator<char>(":"));
for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
std::string tok(*token_iter);
sDefaultPresets.insert(tok);
}
// load it up
initCallbacks();
}
LLFloaterDayCycle::LLFloaterDayCycle() : LLFloater(std::string("Day Cycle Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_day_cycle_options.xml");
// add the combo boxes
LLComboBox* keyCombo = getChild<LLComboBox>("WLKeyPresets");
if(keyCombo != NULL)
{
LLWLParamManager::preset_name_list_t local_presets;
LLWLParamManager::instance()->getLocalPresetNames(local_presets);
for (LLWLParamManager::preset_name_list_t::const_iterator it = local_presets.begin(); it != local_presets.end(); ++it)
{
keyCombo->add(*it);
}
// set defaults on combo boxes
keyCombo->selectFirstItem();
}
// add the time slider
LLMultiSliderCtrl* sldr = getChild<LLMultiSliderCtrl>("WLTimeSlider");
sldr->addSlider();
// load it up
initCallbacks();
}
BOOL LLFloaterNotificationConsole::postBuild()
{
// these are in the order of processing
addChannel("Unexpired");
addChannel("Ignore");
addChannel("VisibilityRules");
addChannel("Visible", true);
// all the ones below attach to the Visible channel
addChannel("Persistent");
addChannel("Alerts");
addChannel("AlertModal");
addChannel("Group Notifications");
addChannel("Notifications");
addChannel("NotificationTips");
// getChild<LLButton>("add_notification")->setClickedCallback(onClickAdd, this);
LLComboBox* notifications = getChild<LLComboBox>("notification_types");
LLNotifications::TemplateNames names = LLNotifications::instance().getTemplateNames();
for (LLNotifications::TemplateNames::iterator template_it = names.begin();
template_it != names.end();
++template_it)
{
notifications->add(*template_it);
}
notifications->sortByName();
return TRUE;
}
BOOL LLFloaterBlacklist::postBuild()
{
childSetAction("add_btn", onClickAdd, this);
childSetAction("clear_btn", onClickClear, this);
childSetAction("copy_uuid_btn", onClickCopyUUID, this);
childSetAction("remove_btn", onClickRemove, this);
childSetAction("save_btn", onClickSave, this);
childSetAction("load_btn", onClickLoad, this);
childSetVisible("copy_uuid_btn",false);
LLComboBox* box = getChild<LLComboBox>("asset_combo");
box->add("Texture",LLSD(0));
box->add("Sound",LLSD(1));
box->add("Animation",LLSD(20));
refresh();
return TRUE;
}
virtual void apply(const std::string& name, LLControlVariable* control)
{
if (!control->isHiddenFromSettingsEditor())
{
combo->add(name, (void*)control);
}
}
// virtual
BOOL LLPreviewTexture::postBuild()
{
if (mCopyToInv)
{
getChild<LLButton>("Keep")->setLabel(getString("Copy"));
childSetAction("Keep",LLPreview::onBtnCopyToInv,this);
getChildView("Discard")->setVisible( false);
}
else if (mShowKeepDiscard)
{
childSetAction("Keep",onKeepBtn,this);
childSetAction("Discard",onDiscardBtn,this);
}
else
{
getChildView("Keep")->setVisible( false);
getChildView("Discard")->setVisible( false);
}
childSetAction("save_tex_btn", LLPreviewTexture::onSaveAsBtn, this);
getChildView("save_tex_btn")->setVisible( true);
getChildView("save_tex_btn")->setEnabled(canSaveAs());
if (!mCopyToInv)
{
const LLInventoryItem* item = getItem();
if (item)
{
childSetCommitCallback("desc", LLPreview::onText, this);
getChild<LLUICtrl>("desc")->setValue(item->getDescription());
getChild<LLLineEditor>("desc")->setPrevalidate(&LLTextValidate::validateASCIIPrintableNoPipe);
}
}
// Fill in ratios list with common aspect ratio values
mRatiosList.clear();
mRatiosList.push_back(LLTrans::getString("Unconstrained"));
mRatiosList.push_back("1:1");
mRatiosList.push_back("4:3");
mRatiosList.push_back("10:7");
mRatiosList.push_back("3:2");
mRatiosList.push_back("16:10");
mRatiosList.push_back("16:9");
mRatiosList.push_back("2:1");
// Now fill combo box with provided list
LLComboBox* combo = getChild<LLComboBox>("combo_aspect_ratio");
combo->removeall();
for (std::vector<std::string>::const_iterator it = mRatiosList.begin(); it != mRatiosList.end(); ++it)
{
combo->add(*it);
}
childSetCommitCallback("combo_aspect_ratio", onAspectRatioCommit, this);
combo->setCurrentByIndex(0);
return LLPreview::postBuild();
}
LLFloaterDayCycle::LLFloaterDayCycle() : LLFloater(std::string("Day Cycle Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_day_cycle_options.xml");
// add the combo boxes
LLComboBox* keyCombo = getChild<LLComboBox>("WLKeyPresets");
if(keyCombo != NULL)
{
std::map<std::string, LLWLParamSet>::iterator mIt =
LLWLParamManager::instance()->mParamList.begin();
for(; mIt != LLWLParamManager::instance()->mParamList.end(); mIt++)
{
if(mIt->second.mInventoryID.isNull())
keyCombo->add(std::string(mIt->first));
}
// set defaults on combo boxes
keyCombo->selectFirstItem();
}
// add the time slider
LLMultiSliderCtrl* sldr = getChild<LLMultiSliderCtrl>("WLTimeSlider");
sldr->addSlider();
// load it up
initCallbacks();
}
void lggDicDownloadFloater::setData(std::vector<std::string> shortNames, std::vector<std::string> longNames, void* data)
{
sNames = shortNames;
lNames = longNames;
empanel = (LLPrefsAscentChat*)data;
LLComboBox* comboBox = getChild<LLComboBox>("Emerald_combo_dics");
if (comboBox != NULL)
{
comboBox->removeall();
for (int i = 0; i < (int)lNames.size(); i++)
{
comboBox->add(lNames[i], ADD_BOTTOM);
}
comboBox->setCurrentByIndex(0);
comboBox->add("", ADD_BOTTOM);
}
}
void LLPreviewGesture::addSounds()
{
LLComboBox* combo = mSoundCombo;
combo->removeall();
std::string none_text = getString("none_text");
combo->add(none_text, LLUUID::null);
// Get all inventory items that are sounds
LLViewerInventoryCategory::cat_array_t cats;
LLViewerInventoryItem::item_array_t items;
LLIsTypeWithPermissions is_copyable_sound(LLAssetType::AT_SOUND,
PERM_ITEM_UNRESTRICTED,
gAgent.getID(),
gAgent.getGroupID());
gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
cats,
items,
LLInventoryModel::EXCLUDE_TRASH,
is_copyable_sound);
// Copy sounds into something we can sort
std::vector<LLInventoryItem*> sounds;
S32 i;
S32 count = items.count();
for(i = 0; i < count; ++i)
{
sounds.push_back( items.get(i) );
}
// Do the sort
std::sort(sounds.begin(), sounds.end(), SortItemPtrsByName());
// And load up the combobox
std::vector<LLInventoryItem*>::iterator it;
for (it = sounds.begin(); it != sounds.end(); ++it)
{
LLInventoryItem* item = *it;
combo->add(item->getName(), item->getAssetUUID(), ADD_BOTTOM);
}
}
BOOL wlfPanel_AdvSettings::postBuild()
{
childSetAction("expand", onClickExpandBtn, this);
LLComboBox* comboBox = getChild<LLComboBox>("WLPresetsCombo");
if(comboBox != NULL) {
std::map<std::string, LLWLParamSet>::iterator mIt =
LLWLParamManager::instance()->mParamList.begin();
for(; mIt != LLWLParamManager::instance()->mParamList.end(); mIt++)
{
comboBox->add(mIt->first);
}
comboBox->add(LLStringUtil::null);
comboBox->selectByValue(LLSD("Default"));
}
comboBox->setCommitCallback(onChangePresetName);
fixPointer = this;
return TRUE;
}
// static
void LLPanelLogin::addServer(const std::string& server)
{
if (!sInstance)
{
llwarns << "Attempted addServer with no login view shown" << llendl;
return;
}
const std::string &defaultGrid = gHippoGridManager->getDefaultGridNick();
LLComboBox *grids = sInstance->getChild<LLComboBox>("server_combo");
S32 selectIndex = -1, i = 0;
grids->removeall();
if (defaultGrid != "") {
grids->add(defaultGrid);
selectIndex = i++;
}
HippoGridManager::GridIterator it, end = gHippoGridManager->endGrid();
for (it = gHippoGridManager->beginGrid(); it != end; ++it) {
const std::string &grid = it->second->getGridNick();
if (grid != defaultGrid) {
grids->add(grid);
//if (grid == mCurGrid) selectIndex = i;
i++;
}
}
// when you first login select the default, otherwise last connected
if (gDisconnected)
{
grids->setSimple(gHippoGridManager->getCurrentGrid()->getGridNick());
}
else
{
std::string last_grid = gSavedSettings.getString("LastSelectedGrid");
if (last_grid.empty()) last_grid = defaultGrid;
grids->setSimple(last_grid);
}
//LLComboBox* combo = sInstance->getChild<LLComboBox>("server_combo");
//combo->add(server, LLSD(domain_name) );
//combo->setCurrentByIndex(0);
}
void add_map_option(LLComboBox& flyout, const std::string& map, const LLUUID& id, U8& did)
{
flyout.remove(map);
if (is_agent_mappable(id) && LLAvatarTracker::instance().isBuddyOnline(id))
{
flyout.add(map, -2);
did |= 0x02; // Added map, needs rebuild.
}
did |= 0x01; // Checked map
}
void LLPanelPlaces::setItem(LLInventoryItem* item)
{
if (!mLandmarkInfo || !item)
return;
mItem = item;
LLAssetType::EType item_type = mItem->getActualType();
if (item_type == LLAssetType::AT_LANDMARK || item_type == LLAssetType::AT_LINK)
{
// If the item is a link get a linked item
if (item_type == LLAssetType::AT_LINK)
{
mItem = gInventory.getItem(mItem->getLinkedUUID());
if (mItem.isNull())
return;
}
}
else
{
return;
}
// Check if item is in agent's inventory and he has the permission to modify it.
BOOL is_landmark_editable = gInventory.isObjectDescendentOf(mItem->getUUID(), gInventory.getRootFolderID()) &&
mItem->getPermissions().allowModifyBy(gAgent.getID());
mEditBtn->setEnabled(is_landmark_editable);
mSaveBtn->setEnabled(is_landmark_editable);
mCloseBtn->setEnabled(TRUE);
mLandmarkInfoBackBtn->setEnabled(TRUE);
if (is_landmark_editable)
{
if(!mLandmarkInfo->setLandmarkFolder(mItem->getParentUUID()) && !mItem->getParentUUID().isNull())
{
const LLViewerInventoryCategory* cat = gInventory.getCategory(mItem->getParentUUID());
if (cat)
{
std::string cat_fullname = LLPanelLandmarkInfo::getFullFolderName(cat);
LLComboBox* folderList = mLandmarkInfo->getChild<LLComboBox>("folder_combo");
folderList->add(cat_fullname, cat->getUUID(), ADD_TOP);
}
}
}
mLandmarkInfo->displayItemInfo(mItem);
LLLandmark* lm = gLandmarkList.getAsset(mItem->getAssetUUID(),
boost::bind(&LLPanelPlaces::onLandmarkLoaded, this, _1));
if (lm)
{
onLandmarkLoaded(lm);
}
}
// static
void LLPanelLogin::addServer(const std::string& server, S32 domain_name)
{
if (!sInstance)
{
llwarns << "Attempted addServer with no login view shown" << llendl;
return;
}
LLComboBox* combo = sInstance->getChild<LLComboBox>("server_combo");
combo->add(server, LLSD(domain_name) );
combo->setCurrentByIndex(0);
}
