// 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 ImpPrefsFonts::refresh()
{
LLRadioGroup* fonts = getChild<LLRadioGroup>("fonts");
if (fonts)
{
fonts->setValue( gSavedSettings.getString("FontChoice") );
}
}
// static
void LLPanelNetwork::onSocksAuthChanged(LLUICtrl* ctrl, void* data)
{
LLRadioGroup* radio = static_cast<LLRadioGroup*>(ctrl);
LLPanelNetwork* self = static_cast<LLPanelNetwork*>(data);
sSocksSettingsChanged = true;
std::string selection = radio->getValue().asString();
updateProxyEnabled(self, true, selection);
}
void ImpPrefsFonts::apply()
{
LLRadioGroup* fonts = getChild<LLRadioGroup>("fonts");
if (fonts)
{
std::string font_choice = fonts->getValue().asString();
if (font_choice != gSavedSettings.getString("FontChoice") &&
!font_choice.empty())
{
gSavedSettings.setString("FontChoice", font_choice);
LLNotifications::instance().add("ChangeFont");
refresh();
}
}
}
void LLPanelPermissions::setAllSaleInfo()
{
llinfos << "LLPanelPermissions::setAllSaleInfo()" << llendl;
LLSaleInfo::EForSale sale_type = LLSaleInfo::FS_NOT;
LLStringUtil::format_map_t argsCurrency;
argsCurrency["[CURRENCY]"] = gHippoGridManager->getConnectedGrid()->getCurrencySymbol();
LLCheckBoxCtrl *checkPurchase = getChild<LLCheckBoxCtrl>("checkbox for sale");
// Set the sale type if the object(s) are for sale.
if(checkPurchase && checkPurchase->get())
{
LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("sale type");
if(RadioSaleType)
{
switch(RadioSaleType->getSelectedIndex())
{
case 0:
sale_type = LLSaleInfo::FS_ORIGINAL;
break;
case 1:
sale_type = LLSaleInfo::FS_COPY;
break;
case 2:
sale_type = LLSaleInfo::FS_CONTENTS;
break;
default:
sale_type = LLSaleInfo::FS_COPY;
break;
}
}
}
S32 price = -1;
LLLineEditor *editPrice = getChild<LLLineEditor>("Edit Cost");
if (editPrice)
{
// Don't extract the price if it's labeled as MIXED or is empty.
const std::string& editPriceString = editPrice->getText();
if (editPriceString != getString("Cost Mixed", argsCurrency) &&
!editPriceString.empty())
{
price = atoi(editPriceString.c_str());
}
else
{
price = DEFAULT_PRICE;
}
}
// If somehow an invalid price, turn the sale off.
if (price < 0)
sale_type = LLSaleInfo::FS_NOT;
// Force the sale price of not-for-sale items to DEFAULT_PRICE.
if (sale_type == LLSaleInfo::FS_NOT)
{
price = DEFAULT_PRICE;
}
// Pack up the sale info and send the update.
LLSaleInfo sale_info(sale_type, price);
LLSelectMgr::getInstance()->selectionSetObjectSaleInfo(sale_info);
// If turned off for-sale, make sure click-action buy is turned
// off as well
if (sale_type == LLSaleInfo::FS_NOT)
{
U8 click_action = 0;
LLSelectMgr::getInstance()->selectionGetClickAction(&click_action);
if (click_action == CLICK_ACTION_BUY)
{
LLSelectMgr::getInstance()->selectionSetClickAction(CLICK_ACTION_TOUCH);
}
}
}
void LLFloaterProperties::updateSaleInfo()
{
LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem();
if(!item) return;
LLSaleInfo sale_info(item->getSaleInfo());
if(!gAgent.allowOperation(PERM_TRANSFER, item->getPermissions(), GP_OBJECT_SET_SALE))
{
getChild<LLUICtrl>("CheckPurchase")->setValue(LLSD((BOOL)FALSE));
}
if((BOOL)getChild<LLUICtrl>("CheckPurchase")->getValue())
{
// turn on sale info
LLSaleInfo::EForSale sale_type = LLSaleInfo::FS_COPY;
LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("RadioSaleType");
if(RadioSaleType)
{
switch (RadioSaleType->getSelectedIndex())
{
case 0:
sale_type = LLSaleInfo::FS_ORIGINAL;
break;
case 1:
sale_type = LLSaleInfo::FS_COPY;
break;
case 2:
sale_type = LLSaleInfo::FS_CONTENTS;
break;
default:
sale_type = LLSaleInfo::FS_COPY;
break;
}
}
if (sale_type == LLSaleInfo::FS_COPY
&& !gAgent.allowOperation(PERM_COPY, item->getPermissions(),
GP_OBJECT_SET_SALE))
{
sale_type = LLSaleInfo::FS_ORIGINAL;
}
S32 price = -1;
price = getChild<LLUICtrl>("Edit Cost")->getValue().asInteger();;
// Invalid data - turn off the sale
if (price < 0)
{
sale_type = LLSaleInfo::FS_NOT;
price = 0;
}
sale_info.setSaleType(sale_type);
sale_info.setSalePrice(price);
}
else
{
sale_info.setSaleType(LLSaleInfo::FS_NOT);
}
if(sale_info != item->getSaleInfo()
&& item->isFinished())
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
// Force an update on the sale price at rez
if (item->getType() == LLAssetType::AT_OBJECT)
{
U32 flags = new_item->getFlags();
flags |= LLInventoryItemFlags::II_FLAGS_OBJECT_SLAM_SALE;
new_item->setFlags(flags);
}
new_item->setSaleInfo(sale_info);
if(mObjectID.isNull())
{
// This is in the agent's inventory.
new_item->updateServer(FALSE);
gInventory.updateItem(new_item);
gInventory.notifyObservers();
}
else
{
// This is in an object's contents.
LLViewerObject* object = gObjectList.findObject(mObjectID);
if(object)
{
object->updateInventory(
new_item,
TASK_INVENTORY_ITEM_KEY,
false);
}
}
}
else
{
// need to make sure we don't just follow the click
refresh();
}
}
void LLFloaterProperties::refreshFromItem(LLInventoryItem* item)
{
////////////////////////
// PERMISSIONS LOOKUP //
////////////////////////
// do not enable the UI for incomplete items.
LLViewerInventoryItem* i = (LLViewerInventoryItem*)item;
BOOL is_complete = i->isFinished();
const BOOL cannot_restrict_permissions = LLInventoryType::cannotRestrictPermissions(i->getInventoryType());
const BOOL is_calling_card = (i->getInventoryType() == LLInventoryType::IT_CALLINGCARD);
const LLPermissions& perm = item->getPermissions();
const BOOL can_agent_manipulate = gAgent.allowOperation(PERM_OWNER, perm,
GP_OBJECT_MANIPULATE);
const BOOL can_agent_sell = gAgent.allowOperation(PERM_OWNER, perm,
GP_OBJECT_SET_SALE) &&
!cannot_restrict_permissions;
const BOOL is_link = i->getIsLinkType();
// You need permission to modify the object to modify an inventory
// item in it.
LLViewerObject* object = NULL;
if(!mObjectID.isNull()) object = gObjectList.findObject(mObjectID);
BOOL is_obj_modify = TRUE;
if(object)
{
is_obj_modify = object->permOwnerModify();
}
//////////////////////
// ITEM NAME & DESC //
//////////////////////
BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY, perm,
GP_OBJECT_MANIPULATE)
&& is_obj_modify && is_complete;
getChildView("LabelItemNameTitle")->setEnabled(TRUE);
getChildView("LabelItemName")->setEnabled(is_modifiable && !is_calling_card); // for now, don't allow rename of calling cards
getChild<LLUICtrl>("LabelItemName")->setValue(item->getName());
getChildView("LabelItemDescTitle")->setEnabled(TRUE);
getChildView("LabelItemDesc")->setEnabled(is_modifiable);
getChildView("IconLocked")->setVisible(!is_modifiable);
getChild<LLUICtrl>("LabelItemDesc")->setValue(item->getDescription());
//////////////////
// CREATOR NAME //
//////////////////
if(!gCacheName) return;
if(!gAgent.getRegion()) return;
if (item->getCreatorUUID().notNull())
{
std::string name;
gCacheName->getFullName(item->getCreatorUUID(), name);
getChildView("BtnCreator")->setEnabled(TRUE);
getChildView("LabelCreatorTitle")->setEnabled(TRUE);
getChildView("LabelCreatorName")->setEnabled(TRUE);
getChild<LLUICtrl>("LabelCreatorName")->setValue(name);
}
else
{
getChildView("BtnCreator")->setEnabled(FALSE);
getChildView("LabelCreatorTitle")->setEnabled(FALSE);
getChildView("LabelCreatorName")->setEnabled(FALSE);
getChild<LLUICtrl>("LabelCreatorName")->setValue(getString("unknown"));
}
////////////////
// OWNER NAME //
////////////////
if(perm.isOwned())
{
std::string name;
if (perm.isGroupOwned())
{
gCacheName->getGroupName(perm.getGroup(), name);
}
else
{
gCacheName->getFullName(perm.getOwner(), name);
}
getChildView("BtnOwner")->setEnabled(TRUE);
getChildView("LabelOwnerTitle")->setEnabled(TRUE);
getChildView("LabelOwnerName")->setEnabled(TRUE);
getChild<LLUICtrl>("LabelOwnerName")->setValue(name);
}
else
{
getChildView("BtnOwner")->setEnabled(FALSE);
getChildView("LabelOwnerTitle")->setEnabled(FALSE);
getChildView("LabelOwnerName")->setEnabled(FALSE);
getChild<LLUICtrl>("LabelOwnerName")->setValue(getString("public"));
}
//////////////////
// ACQUIRE DATE //
//////////////////
time_t time_utc = item->getCreationDate();
if (0 == time_utc)
{
getChild<LLUICtrl>("LabelAcquiredDate")->setValue(getString("unknown"));
}
else
{
std::string timeStr = getString("acquiredDate");
LLSD substitution;
substitution["datetime"] = (S32) time_utc;
LLStringUtil::format (timeStr, substitution);
getChild<LLUICtrl>("LabelAcquiredDate")->setValue(timeStr);
}
///////////////////////
// OWNER PERMISSIONS //
///////////////////////
if(can_agent_manipulate)
{
getChild<LLUICtrl>("OwnerLabel")->setValue(getString("you_can"));
}
else
{
getChild<LLUICtrl>("OwnerLabel")->setValue(getString("owner_can"));
}
U32 base_mask = perm.getMaskBase();
U32 owner_mask = perm.getMaskOwner();
U32 group_mask = perm.getMaskGroup();
U32 everyone_mask = perm.getMaskEveryone();
U32 next_owner_mask = perm.getMaskNextOwner();
getChildView("OwnerLabel")->setEnabled(TRUE);
getChildView("CheckOwnerModify")->setEnabled(FALSE);
getChild<LLUICtrl>("CheckOwnerModify")->setValue(LLSD((BOOL)(owner_mask & PERM_MODIFY)));
getChildView("CheckOwnerCopy")->setEnabled(FALSE);
getChild<LLUICtrl>("CheckOwnerCopy")->setValue(LLSD((BOOL)(owner_mask & PERM_COPY)));
getChildView("CheckOwnerTransfer")->setEnabled(FALSE);
getChild<LLUICtrl>("CheckOwnerTransfer")->setValue(LLSD((BOOL)(owner_mask & PERM_TRANSFER)));
///////////////////////
// DEBUG PERMISSIONS //
///////////////////////
if( gSavedSettings.getBOOL("DebugPermissions") )
{
BOOL slam_perm = FALSE;
BOOL overwrite_group = FALSE;
BOOL overwrite_everyone = FALSE;
if (item->getType() == LLAssetType::AT_OBJECT)
{
U32 flags = item->getFlags();
slam_perm = flags & LLInventoryItemFlags::II_FLAGS_OBJECT_SLAM_PERM;
overwrite_everyone = flags & LLInventoryItemFlags::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
overwrite_group = flags & LLInventoryItemFlags::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
}
std::string perm_string;
perm_string = "B: ";
perm_string += mask_to_string(base_mask);
getChild<LLUICtrl>("BaseMaskDebug")->setValue(perm_string);
getChildView("BaseMaskDebug")->setVisible(TRUE);
perm_string = "O: ";
perm_string += mask_to_string(owner_mask);
getChild<LLUICtrl>("OwnerMaskDebug")->setValue(perm_string);
getChildView("OwnerMaskDebug")->setVisible(TRUE);
perm_string = "G";
perm_string += overwrite_group ? "*: " : ": ";
perm_string += mask_to_string(group_mask);
getChild<LLUICtrl>("GroupMaskDebug")->setValue(perm_string);
getChildView("GroupMaskDebug")->setVisible(TRUE);
perm_string = "E";
perm_string += overwrite_everyone ? "*: " : ": ";
perm_string += mask_to_string(everyone_mask);
getChild<LLUICtrl>("EveryoneMaskDebug")->setValue(perm_string);
getChildView("EveryoneMaskDebug")->setVisible(TRUE);
perm_string = "N";
perm_string += slam_perm ? "*: " : ": ";
perm_string += mask_to_string(next_owner_mask);
getChild<LLUICtrl>("NextMaskDebug")->setValue(perm_string);
getChildView("NextMaskDebug")->setVisible(TRUE);
}
else
{
getChildView("BaseMaskDebug")->setVisible(FALSE);
getChildView("OwnerMaskDebug")->setVisible(FALSE);
getChildView("GroupMaskDebug")->setVisible(FALSE);
getChildView("EveryoneMaskDebug")->setVisible(FALSE);
getChildView("NextMaskDebug")->setVisible(FALSE);
}
/////////////
// SHARING //
/////////////
// Check for ability to change values.
if (is_link || cannot_restrict_permissions)
{
getChildView("CheckShareWithGroup")->setEnabled(FALSE);
getChildView("CheckEveryoneCopy")->setEnabled(FALSE);
}
else if (is_obj_modify && can_agent_manipulate)
{
getChildView("CheckShareWithGroup")->setEnabled(TRUE);
getChildView("CheckEveryoneCopy")->setEnabled((owner_mask & PERM_COPY) && (owner_mask & PERM_TRANSFER));
}
else
{
getChildView("CheckShareWithGroup")->setEnabled(FALSE);
getChildView("CheckEveryoneCopy")->setEnabled(FALSE);
}
// Set values.
BOOL is_group_copy = (group_mask & PERM_COPY) ? TRUE : FALSE;
BOOL is_group_modify = (group_mask & PERM_MODIFY) ? TRUE : FALSE;
BOOL is_group_move = (group_mask & PERM_MOVE) ? TRUE : FALSE;
if (is_group_copy && is_group_modify && is_group_move)
{
getChild<LLUICtrl>("CheckShareWithGroup")->setValue(LLSD((BOOL)TRUE));
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(FALSE);
}
}
else if (!is_group_copy && !is_group_modify && !is_group_move)
{
getChild<LLUICtrl>("CheckShareWithGroup")->setValue(LLSD((BOOL)FALSE));
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(FALSE);
}
}
else
{
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(TRUE);
ctl->set(TRUE);
}
}
getChild<LLUICtrl>("CheckEveryoneCopy")->setValue(LLSD((BOOL)(everyone_mask & PERM_COPY)));
///////////////
// SALE INFO //
///////////////
const LLSaleInfo& sale_info = item->getSaleInfo();
BOOL is_for_sale = sale_info.isForSale();
// Check for ability to change values.
if (is_obj_modify && can_agent_sell
&& gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE))
{
getChildView("SaleLabel")->setEnabled(is_complete);
getChildView("CheckPurchase")->setEnabled(is_complete);
getChildView("NextOwnerLabel")->setEnabled(TRUE);
getChildView("CheckNextOwnerModify")->setEnabled((base_mask & PERM_MODIFY) && !cannot_restrict_permissions);
getChildView("CheckNextOwnerCopy")->setEnabled((base_mask & PERM_COPY) && !cannot_restrict_permissions);
getChildView("CheckNextOwnerTransfer")->setEnabled((next_owner_mask & PERM_COPY) && !cannot_restrict_permissions);
getChildView("RadioSaleType")->setEnabled(is_complete && is_for_sale);
getChildView("TextPrice")->setEnabled(is_complete && is_for_sale);
getChildView("Edit Cost")->setEnabled(is_complete && is_for_sale);
}
else
{
getChildView("SaleLabel")->setEnabled(FALSE);
getChildView("CheckPurchase")->setEnabled(FALSE);
getChildView("NextOwnerLabel")->setEnabled(FALSE);
getChildView("CheckNextOwnerModify")->setEnabled(FALSE);
getChildView("CheckNextOwnerCopy")->setEnabled(FALSE);
getChildView("CheckNextOwnerTransfer")->setEnabled(FALSE);
getChildView("RadioSaleType")->setEnabled(FALSE);
getChildView("TextPrice")->setEnabled(FALSE);
getChildView("Edit Cost")->setEnabled(FALSE);
}
// Set values.
getChild<LLUICtrl>("CheckPurchase")->setValue(is_for_sale);
getChildView("combobox sale copy")->setEnabled(is_for_sale);
getChildView("Edit Cost")->setEnabled(is_for_sale);
getChild<LLUICtrl>("CheckNextOwnerModify")->setValue(LLSD(BOOL(next_owner_mask & PERM_MODIFY)));
getChild<LLUICtrl>("CheckNextOwnerCopy")->setValue(LLSD(BOOL(next_owner_mask & PERM_COPY)));
getChild<LLUICtrl>("CheckNextOwnerTransfer")->setValue(LLSD(BOOL(next_owner_mask & PERM_TRANSFER)));
LLRadioGroup* radioSaleType = getChild<LLRadioGroup>("RadioSaleType");
if (is_for_sale)
{
radioSaleType->setSelectedIndex((S32)sale_info.getSaleType() - 1);
S32 numerical_price;
numerical_price = sale_info.getSalePrice();
getChild<LLUICtrl>("Edit Cost")->setValue(llformat("%d",numerical_price));
}
else
{
radioSaleType->setSelectedIndex(-1);
getChild<LLUICtrl>("Edit Cost")->setValue(llformat("%d",0));
}
}
void LLPrefsAscentSysImpl::refresh()
{
//General -----------------------------------------------------------------------------
childSetValue("double_click_teleport_check", mDoubleClickTeleport);
childSetValue("center_after_teleport_check", mResetCameraAfterTP);
childSetValue("offset_teleport_check", mOffsetTPByUserHeight);
childSetValue("preview_anim_in_world_check", mPreviewAnimInWorld);
childSetValue("save_scripts_as_mono_check", mSaveScriptsAsMono);
childSetValue("always_rez_in_group_check", mAlwaysRezInGroup);
//Disable Teleport Progress
//Disable Logout progress
//always show Build
childSetValue("always_fly_check", mAlwaysShowFly);
//Disable camera minimum distance
//Chat --------------------------------------------------------------------------------
childSetValue("hide_notifications_in_chat_check", mHideNotificationsInChat);
childSetValue("play_typing_sound_check", mPlayTypingSound);
childSetValue("hide_typing_check", mHideTypingNotification);
childSetValue("seconds_in_chat_and_ims_check", mSecondsInChatAndIMs);
childSetValue("allow_mu_pose_check", mEnableMUPose);
childSetValue("close_ooc_check", mEnableOOCAutoClose);
LLRadioGroup* radioLinkOptions = getChild<LLRadioGroup>("objects_link");
radioLinkOptions->selectNthItem(mLinksForChattingObjects);
//childSetValue("objects_link", mLinksForChattingObjects);
std::string format = gSavedSettings.getString("ShortTimeFormat");
if (format.find("%p") == -1)
{
mTimeFormat = 0;
}
else
{
mTimeFormat = 1;
}
format = gSavedSettings.getString("ShortDateFormat");
if (format.find("%m/%d/%") != -1)
{
mDateFormat = 2;
}
else if (format.find("%d/%m/%") != -1)
{
mDateFormat = 1;
}
else
{
mDateFormat = 0;
}
// time format combobox
LLComboBox* combo = getChild<LLComboBox>("time_format_combobox");
if (combo)
{
combo->setCurrentByIndex(mTimeFormat);
}
// date format combobox
combo = getChild<LLComboBox>("date_format_combobox");
if (combo)
{
combo->setCurrentByIndex(mDateFormat);
}
childSetValue("seconds_in_chat_and_ims_check", mEnableOOCAutoClose);
//Save Performance --------------------------------------------------------------------
childSetValue("fetch_inventory_on_login_check", mFetchInventoryOnLogin);
childSetValue("enable_wind", mEnableLLWind);
childSetValue("enable_clouds", mEnableClouds);
childSetValue("speed_rez_check", mSpeedRez);
if (mSpeedRez)
{
childEnable("speed_rez_interval");
childEnable("speed_rez_seconds");
}
else
{
childDisable("speed_rez_interval");
childDisable("speed_rez_seconds");
}
//Command Line ------------------------------------------------------------------------
//Privacy -----------------------------------------------------------------------------
childSetValue("broadcast_viewer_effects", mBroadcastViewerEffects);
childSetValue("disable_point_at_and_beams_check", mDisablePointAtAndBeam);
childSetValue("private_look_at_check", mPrivateLookAt);
childSetValue("show_look_at_check", mShowLookAt);
childSetValue("revoke_perms_on_stand_up_check", mRevokePermsOnStandUp);
}
void LLSidepanelItemInfo::refreshFromItem(LLViewerInventoryItem* item)
{
////////////////////////
// PERMISSIONS LOOKUP //
////////////////////////
llassert(item);
if (!item) return;
// do not enable the UI for incomplete items.
BOOL is_complete = item->isComplete();
const BOOL cannot_restrict_permissions = LLInventoryType::cannotRestrictPermissions(item->getInventoryType());
const BOOL is_calling_card = (item->getInventoryType() == LLInventoryType::IT_CALLINGCARD);
const LLPermissions& perm = item->getPermissions();
const BOOL can_agent_manipulate = gAgent.allowOperation(PERM_OWNER, perm,
GP_OBJECT_MANIPULATE);
const BOOL can_agent_sell = gAgent.allowOperation(PERM_OWNER, perm,
GP_OBJECT_SET_SALE) &&
!cannot_restrict_permissions;
const BOOL is_link = item->getIsLinkType();
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
bool not_in_trash = (item->getUUID() != trash_id) && !gInventory.isObjectDescendentOf(item->getUUID(), trash_id);
// You need permission to modify the object to modify an inventory
// item in it.
LLViewerObject* object = NULL;
if(!mObjectID.isNull()) object = gObjectList.findObject(mObjectID);
BOOL is_obj_modify = TRUE;
if(object)
{
is_obj_modify = object->permOwnerModify();
}
//////////////////////
// ITEM NAME & DESC //
//////////////////////
BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY, perm,
GP_OBJECT_MANIPULATE)
&& is_obj_modify && is_complete && not_in_trash;
childSetEnabled("LabelItemNameTitle",TRUE);
childSetEnabled("LabelItemName",is_modifiable && !is_calling_card); // for now, don't allow rename of calling cards
childSetText("LabelItemName",item->getName());
childSetEnabled("LabelItemDescTitle",TRUE);
childSetEnabled("LabelItemDesc",is_modifiable);
childSetVisible("IconLocked",!is_modifiable);
childSetText("LabelItemDesc",item->getDescription());
//////////////////
// CREATOR NAME //
//////////////////
if(!gCacheName) return;
if(!gAgent.getRegion()) return;
if (item->getCreatorUUID().notNull())
{
std::string name;
gCacheName->getFullName(item->getCreatorUUID(), name);
childSetEnabled("BtnCreator",TRUE);
childSetEnabled("LabelCreatorTitle",TRUE);
childSetEnabled("LabelCreatorName",TRUE);
childSetText("LabelCreatorName",name);
}
else
{
childSetEnabled("BtnCreator",FALSE);
childSetEnabled("LabelCreatorTitle",FALSE);
childSetEnabled("LabelCreatorName",FALSE);
childSetText("LabelCreatorName",getString("unknown"));
}
////////////////
// OWNER NAME //
////////////////
if(perm.isOwned())
{
std::string name;
if (perm.isGroupOwned())
{
gCacheName->getGroupName(perm.getGroup(), name);
}
else
{
gCacheName->getFullName(perm.getOwner(), name);
}
childSetEnabled("BtnOwner",TRUE);
childSetEnabled("LabelOwnerTitle",TRUE);
childSetEnabled("LabelOwnerName",TRUE);
childSetText("LabelOwnerName",name);
}
else
{
childSetEnabled("BtnOwner",FALSE);
childSetEnabled("LabelOwnerTitle",FALSE);
childSetEnabled("LabelOwnerName",FALSE);
childSetText("LabelOwnerName",getString("public"));
}
//////////////////
// ACQUIRE DATE //
//////////////////
time_t time_utc = item->getCreationDate();
if (0 == time_utc)
{
childSetText("LabelAcquiredDate",getString("unknown"));
}
else
{
std::string timeStr = getString("acquiredDate");
LLSD substitution;
substitution["datetime"] = (S32) time_utc;
LLStringUtil::format (timeStr, substitution);
childSetText ("LabelAcquiredDate", timeStr);
}
/////////////////////////////////////
// PERMISSIONS AND SALE ITEM HIDING
/////////////////////////////////////
const std::string perm_and_sale_items[]={
"perms_inv",
"OwnerLabel",
"perm_modify",
"CheckOwnerModify",
"CheckOwnerCopy",
"CheckOwnerTransfer",
"GroupLabel",
"CheckShareWithGroup",
"AnyoneLabel",
"CheckEveryoneCopy",
"NextOwnerLabel",
"CheckNextOwnerModify",
"CheckNextOwnerCopy",
"CheckNextOwnerTransfer",
"CheckPurchase",
"SaleLabel",
"RadioSaleType",
"combobox sale copy",
"Edit Cost",
"TextPrice"
};
const std::string debug_items[]={
"BaseMaskDebug",
"OwnerMaskDebug",
"GroupMaskDebug",
"EveryoneMaskDebug",
"NextMaskDebug"
};
// Hide permissions checkboxes and labels and for sale info if in the trash
// or ui elements don't apply to these objects and return from function
if (!not_in_trash || cannot_restrict_permissions)
{
for(size_t t=0; t<LL_ARRAY_SIZE(perm_and_sale_items); ++t)
{
childSetVisible(perm_and_sale_items[t],false);
}
for(size_t t=0; t<LL_ARRAY_SIZE(debug_items); ++t)
{
childSetVisible(debug_items[t],false);
}
return;
}
else // Make sure perms and sale ui elements are visible
{
for(size_t t=0; t<LL_ARRAY_SIZE(perm_and_sale_items); ++t)
{
childSetVisible(perm_and_sale_items[t],true);
}
}
///////////////////////
// OWNER PERMISSIONS //
///////////////////////
if(can_agent_manipulate)
{
childSetText("OwnerLabel",getString("you_can"));
}
else
{
childSetText("OwnerLabel",getString("owner_can"));
}
U32 base_mask = perm.getMaskBase();
U32 owner_mask = perm.getMaskOwner();
U32 group_mask = perm.getMaskGroup();
U32 everyone_mask = perm.getMaskEveryone();
U32 next_owner_mask = perm.getMaskNextOwner();
childSetEnabled("OwnerLabel",TRUE);
childSetEnabled("CheckOwnerModify",FALSE);
childSetValue("CheckOwnerModify",LLSD((BOOL)(owner_mask & PERM_MODIFY)));
childSetEnabled("CheckOwnerCopy",FALSE);
childSetValue("CheckOwnerCopy",LLSD((BOOL)(owner_mask & PERM_COPY)));
childSetEnabled("CheckOwnerTransfer",FALSE);
childSetValue("CheckOwnerTransfer",LLSD((BOOL)(owner_mask & PERM_TRANSFER)));
///////////////////////
// DEBUG PERMISSIONS //
///////////////////////
if( gSavedSettings.getBOOL("DebugPermissions") )
{
BOOL slam_perm = FALSE;
BOOL overwrite_group = FALSE;
BOOL overwrite_everyone = FALSE;
if (item->getType() == LLAssetType::AT_OBJECT)
{
U32 flags = item->getFlags();
slam_perm = flags & LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM;
overwrite_everyone = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
overwrite_group = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
}
std::string perm_string;
perm_string = "B: ";
perm_string += mask_to_string(base_mask);
childSetText("BaseMaskDebug",perm_string);
childSetVisible("BaseMaskDebug",TRUE);
perm_string = "O: ";
perm_string += mask_to_string(owner_mask);
childSetText("OwnerMaskDebug",perm_string);
childSetVisible("OwnerMaskDebug",TRUE);
perm_string = "G";
perm_string += overwrite_group ? "*: " : ": ";
perm_string += mask_to_string(group_mask);
childSetText("GroupMaskDebug",perm_string);
childSetVisible("GroupMaskDebug",TRUE);
perm_string = "E";
perm_string += overwrite_everyone ? "*: " : ": ";
perm_string += mask_to_string(everyone_mask);
childSetText("EveryoneMaskDebug",perm_string);
childSetVisible("EveryoneMaskDebug",TRUE);
perm_string = "N";
perm_string += slam_perm ? "*: " : ": ";
perm_string += mask_to_string(next_owner_mask);
childSetText("NextMaskDebug",perm_string);
childSetVisible("NextMaskDebug",TRUE);
}
else
{
childSetVisible("BaseMaskDebug",FALSE);
childSetVisible("OwnerMaskDebug",FALSE);
childSetVisible("GroupMaskDebug",FALSE);
childSetVisible("EveryoneMaskDebug",FALSE);
childSetVisible("NextMaskDebug",FALSE);
}
/////////////
// SHARING //
/////////////
// Check for ability to change values.
if (is_link || cannot_restrict_permissions)
{
childSetEnabled("CheckShareWithGroup",FALSE);
childSetEnabled("CheckEveryoneCopy",FALSE);
}
else if (is_obj_modify && can_agent_manipulate)
{
childSetEnabled("CheckShareWithGroup",TRUE);
childSetEnabled("CheckEveryoneCopy",(owner_mask & PERM_COPY) && (owner_mask & PERM_TRANSFER));
}
else
{
childSetEnabled("CheckShareWithGroup",FALSE);
childSetEnabled("CheckEveryoneCopy",FALSE);
}
// Set values.
BOOL is_group_copy = (group_mask & PERM_COPY) ? TRUE : FALSE;
BOOL is_group_modify = (group_mask & PERM_MODIFY) ? TRUE : FALSE;
BOOL is_group_move = (group_mask & PERM_MOVE) ? TRUE : FALSE;
if (is_group_copy && is_group_modify && is_group_move)
{
childSetValue("CheckShareWithGroup",LLSD((BOOL)TRUE));
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(FALSE);
}
}
else if (!is_group_copy && !is_group_modify && !is_group_move)
{
childSetValue("CheckShareWithGroup",LLSD((BOOL)FALSE));
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(FALSE);
}
}
else
{
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(TRUE);
ctl->set(TRUE);
}
}
childSetValue("CheckEveryoneCopy",LLSD((BOOL)(everyone_mask & PERM_COPY)));
///////////////
// SALE INFO //
///////////////
const LLSaleInfo& sale_info = item->getSaleInfo();
BOOL is_for_sale = sale_info.isForSale();
// Check for ability to change values.
if (is_obj_modify && can_agent_sell
&& gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE))
{
childSetEnabled("SaleLabel",is_complete);
childSetEnabled("CheckPurchase",is_complete);
childSetEnabled("NextOwnerLabel",TRUE);
childSetEnabled("CheckNextOwnerModify",(base_mask & PERM_MODIFY) && !cannot_restrict_permissions);
childSetEnabled("CheckNextOwnerCopy",(base_mask & PERM_COPY) && !cannot_restrict_permissions);
childSetEnabled("CheckNextOwnerTransfer",(next_owner_mask & PERM_COPY) && !cannot_restrict_permissions);
childSetEnabled("RadioSaleType",is_complete && is_for_sale);
childSetEnabled("TextPrice",is_complete && is_for_sale);
childSetEnabled("Edit Cost",is_complete && is_for_sale);
}
else
{
childSetEnabled("SaleLabel",FALSE);
childSetEnabled("CheckPurchase",FALSE);
childSetEnabled("NextOwnerLabel",FALSE);
childSetEnabled("CheckNextOwnerModify",FALSE);
childSetEnabled("CheckNextOwnerCopy",FALSE);
childSetEnabled("CheckNextOwnerTransfer",FALSE);
childSetEnabled("RadioSaleType",FALSE);
childSetEnabled("TextPrice",FALSE);
childSetEnabled("Edit Cost",FALSE);
}
// Set values.
childSetValue("CheckPurchase", is_for_sale);
childSetEnabled("combobox sale copy", is_for_sale);
childSetEnabled("Edit Cost", is_for_sale);
childSetValue("CheckNextOwnerModify",LLSD(BOOL(next_owner_mask & PERM_MODIFY)));
childSetValue("CheckNextOwnerCopy",LLSD(BOOL(next_owner_mask & PERM_COPY)));
childSetValue("CheckNextOwnerTransfer",LLSD(BOOL(next_owner_mask & PERM_TRANSFER)));
LLRadioGroup* radioSaleType = getChild<LLRadioGroup>("RadioSaleType");
if (is_for_sale)
{
radioSaleType->setSelectedIndex((S32)sale_info.getSaleType() - 1);
S32 numerical_price;
numerical_price = sale_info.getSalePrice();
childSetText("Edit Cost",llformat("%d",numerical_price));
}
else
{
radioSaleType->setSelectedIndex(-1);
childSetText("Edit Cost",llformat("%d",0));
}
}
void LLFloaterProperties::refreshFromItem(LLInventoryItem* item)
{
// <edit>
childSetText("EditItemID", item->getUUID().asString());
childSetText("EditFolderID", item->getParentUUID().asString());
childSetText("EditGroup", item->getPermissions().getGroup().asString());
childSetText("EditAssetID", item->getAssetUUID().asString());
std::string type_str = LLAssetType::lookup(item->getType());
if(type_str.c_str() == NULL) type_str = llformat("%d", item->getType());
childSetText("EditType", type_str);
std::string invtype_str = LLInventoryType::lookup(item->getInventoryType());
if(invtype_str.c_str() == NULL) invtype_str = llformat("%d", item->getInventoryType());
childSetText("EditInvType", invtype_str);
childSetText("EditFlags", llformat("%d", item->getFlags()));
std::ostringstream strm;
item->exportLegacyStream(strm, TRUE);
std::string str(strm.str());
LLStringUtil::replaceTabsWithSpaces(str, 4);
childSetText("item_text", str);
// </edit>
////////////////////////
// PERMISSIONS LOOKUP //
////////////////////////
// do not enable the UI for incomplete items.
LLViewerInventoryItem* i = (LLViewerInventoryItem*)item;
BOOL is_complete = i->isComplete();
const LLPermissions& perm = item->getPermissions();
BOOL can_agent_manipulate = gAgent.allowOperation(PERM_OWNER, perm,
GP_OBJECT_MANIPULATE);
BOOL can_agent_sell = gAgent.allowOperation(PERM_OWNER, perm,
GP_OBJECT_SET_SALE);
// You need permission to modify the object to modify an inventory
// item in it.
LLViewerObject* object = NULL;
if(!mObjectID.isNull()) object = gObjectList.findObject(mObjectID);
BOOL is_obj_modify = TRUE;
if(object)
{
is_obj_modify = object->permOwnerModify();
}
//////////////////////
// ITEM NAME & DESC //
//////////////////////
BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY, perm,
GP_OBJECT_MANIPULATE)
&& is_obj_modify && is_complete;
childSetEnabled("LabelItemNameTitle",TRUE);
childSetEnabled("LabelItemName",is_modifiable);
childSetText("LabelItemName",item->getName());
childSetEnabled("LabelItemDescTitle",TRUE);
childSetEnabled("LabelItemDesc",is_modifiable);
childSetVisible("IconLocked",!is_modifiable);
childSetText("LabelItemDesc",item->getDescription());
//////////////////
// CREATOR NAME //
//////////////////
if(!gCacheName) return;
if(!gAgent.getRegion()) return;
if (item->getCreatorUUID().notNull())
{
std::string name;
gCacheName->getFullName(item->getCreatorUUID(), name);
childSetEnabled("BtnCreator",TRUE);
childSetEnabled("LabelCreatorTitle",TRUE);
childSetEnabled("LabelCreatorName",TRUE);
childSetText("LabelCreatorName",name);
}
else
{
childSetEnabled("BtnCreator",FALSE);
childSetEnabled("LabelCreatorTitle",FALSE);
childSetEnabled("LabelCreatorName",FALSE);
childSetText("LabelCreatorName",getString("unknown"));
}
////////////////
// OWNER NAME //
////////////////
if(perm.isOwned())
{
std::string name;
if (perm.isGroupOwned())
{
gCacheName->getGroupName(perm.getGroup(), name);
}
else
{
gCacheName->getFullName(perm.getOwner(), name);
}
childSetEnabled("BtnOwner",TRUE);
childSetEnabled("LabelOwnerTitle",TRUE);
childSetEnabled("LabelOwnerName",TRUE);
childSetText("LabelOwnerName",name);
}
else
{
childSetEnabled("BtnOwner",FALSE);
childSetEnabled("LabelOwnerTitle",FALSE);
childSetEnabled("LabelOwnerName",FALSE);
childSetText("LabelOwnerName",getString("public"));
}
//////////////////
// ACQUIRE DATE //
//////////////////
// *TODO: Localize / translate this
time_t time_utc = item->getCreationDate();
if (0 == time_utc)
{
childSetText("LabelAcquiredDate",getString("unknown"));
}
else
{
std::string timestr;
timeToFormattedString(time_utc, gSavedSettings.getString("TimestampFormat"), timestr);
childSetText("LabelAcquiredDate", timestr);
}
///////////////////////
// OWNER PERMISSIONS //
///////////////////////
if(can_agent_manipulate)
{
childSetText("OwnerLabel",getString("you_can"));
}
else
{
childSetText("OwnerLabel",getString("owner_can"));
}
U32 base_mask = perm.getMaskBase();
U32 owner_mask = perm.getMaskOwner();
U32 group_mask = perm.getMaskGroup();
U32 everyone_mask = perm.getMaskEveryone();
U32 next_owner_mask = perm.getMaskNextOwner();
childSetEnabled("OwnerLabel",TRUE);
childSetEnabled("CheckOwnerModify",FALSE);
childSetValue("CheckOwnerModify",LLSD((BOOL)(owner_mask & PERM_MODIFY)));
childSetEnabled("CheckOwnerCopy",FALSE);
childSetValue("CheckOwnerCopy",LLSD((BOOL)(owner_mask & PERM_COPY)));
childSetEnabled("CheckOwnerTransfer",FALSE);
childSetValue("CheckOwnerTransfer",LLSD((BOOL)(owner_mask & PERM_TRANSFER)));
///////////////////////
// DEBUG PERMISSIONS //
///////////////////////
if( gSavedSettings.getBOOL("DebugPermissions") )
{
BOOL slam_perm = FALSE;
BOOL overwrite_group = FALSE;
BOOL overwrite_everyone = FALSE;
if (item->getType() == LLAssetType::AT_OBJECT)
{
U32 flags = item->getFlags();
slam_perm = flags & LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM;
overwrite_everyone = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
overwrite_group = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
}
std::string perm_string;
perm_string = "B: ";
perm_string += mask_to_string(base_mask);
childSetText("BaseMaskDebug",perm_string);
childSetVisible("BaseMaskDebug",TRUE);
perm_string = "O: ";
perm_string += mask_to_string(owner_mask);
childSetText("OwnerMaskDebug",perm_string);
childSetVisible("OwnerMaskDebug",TRUE);
perm_string = "G";
perm_string += overwrite_group ? "*: " : ": ";
perm_string += mask_to_string(group_mask);
childSetText("GroupMaskDebug",perm_string);
childSetVisible("GroupMaskDebug",TRUE);
perm_string = "E";
perm_string += overwrite_everyone ? "*: " : ": ";
perm_string += mask_to_string(everyone_mask);
childSetText("EveryoneMaskDebug",perm_string);
childSetVisible("EveryoneMaskDebug",TRUE);
perm_string = "N";
perm_string += slam_perm ? "*: " : ": ";
perm_string += mask_to_string(next_owner_mask);
childSetText("NextMaskDebug",perm_string);
childSetVisible("NextMaskDebug",TRUE);
}
else
{
childSetVisible("BaseMaskDebug",FALSE);
childSetVisible("OwnerMaskDebug",FALSE);
childSetVisible("GroupMaskDebug",FALSE);
childSetVisible("EveryoneMaskDebug",FALSE);
childSetVisible("NextMaskDebug",FALSE);
}
/////////////
// SHARING //
/////////////
// Check for ability to change values.
if (is_obj_modify && can_agent_manipulate)
{
childSetEnabled("CheckShareWithGroup",TRUE);
childSetEnabled("CheckEveryoneCopy",(owner_mask & PERM_COPY) && (owner_mask & PERM_TRANSFER));
}
else
{
childSetEnabled("CheckShareWithGroup",FALSE);
childSetEnabled("CheckEveryoneCopy",FALSE);
}
// Set values.
BOOL is_group_copy = (group_mask & PERM_COPY) ? TRUE : FALSE;
BOOL is_group_modify = (group_mask & PERM_MODIFY) ? TRUE : FALSE;
BOOL is_group_move = (group_mask & PERM_MOVE) ? TRUE : FALSE;
if (is_group_copy && is_group_modify && is_group_move)
{
childSetValue("CheckShareWithGroup",LLSD((BOOL)TRUE));
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(FALSE);
}
}
else if (!is_group_copy && !is_group_modify && !is_group_move)
{
childSetValue("CheckShareWithGroup",LLSD((BOOL)FALSE));
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(FALSE);
}
}
else
{
LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(ctl)
{
ctl->setTentative(TRUE);
ctl->set(TRUE);
}
}
childSetValue("CheckEveryoneCopy",LLSD((BOOL)(everyone_mask & PERM_COPY)));
///////////////
// SALE INFO //
///////////////
const LLSaleInfo& sale_info = item->getSaleInfo();
BOOL is_for_sale = sale_info.isForSale();
// Check for ability to change values.
if (is_obj_modify && can_agent_sell
&& gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE))
{
childSetEnabled("SaleLabel",is_complete);
childSetEnabled("CheckPurchase",is_complete);
childSetEnabled("NextOwnerLabel",TRUE);
childSetEnabled("CheckNextOwnerModify",base_mask & PERM_MODIFY);
childSetEnabled("CheckNextOwnerCopy",base_mask & PERM_COPY);
childSetEnabled("CheckNextOwnerTransfer",next_owner_mask & PERM_COPY);
childSetEnabled("RadioSaleType",is_complete && is_for_sale);
childSetEnabled("TextPrice",is_complete && is_for_sale);
childSetEnabled("EditPrice",is_complete && is_for_sale);
}
else
{
childSetEnabled("SaleLabel",FALSE);
childSetEnabled("CheckPurchase",FALSE);
childSetEnabled("NextOwnerLabel",FALSE);
childSetEnabled("CheckNextOwnerModify",FALSE);
childSetEnabled("CheckNextOwnerCopy",FALSE);
childSetEnabled("CheckNextOwnerTransfer",FALSE);
childSetEnabled("RadioSaleType",FALSE);
childSetEnabled("TextPrice",FALSE);
childSetEnabled("EditPrice",FALSE);
}
// Set values.
childSetValue("CheckPurchase", is_for_sale);
childSetValue("CheckNextOwnerModify",LLSD(BOOL(next_owner_mask & PERM_MODIFY)));
childSetValue("CheckNextOwnerCopy",LLSD(BOOL(next_owner_mask & PERM_COPY)));
childSetValue("CheckNextOwnerTransfer",LLSD(BOOL(next_owner_mask & PERM_TRANSFER)));
LLRadioGroup* radioSaleType = getChild<LLRadioGroup>("RadioSaleType");
if (is_for_sale)
{
radioSaleType->setSelectedIndex((S32)sale_info.getSaleType() - 1);
S32 numerical_price;
numerical_price = sale_info.getSalePrice();
childSetText("EditPrice",llformat("%d",numerical_price));
}
else
{
radioSaleType->setSelectedIndex(-1);
childSetText("EditPrice",llformat("%d",0));
}
}
void LLPrefsAscentSysImpl::refresh()
{
//General -----------------------------------------------------------------------------
childSetValue("double_click_teleport_check", mDoubleClickTeleport);
childSetValue("center_after_teleport_check", mResetCameraAfterTP);
childSetEnabled("center_after_teleport_check", mDoubleClickTeleport);
childSetValue("offset_teleport_check", mOffsetTPByUserHeight);
childSetEnabled("offset_teleport_check", mDoubleClickTeleport);
childSetValue("preview_anim_in_world_check", mPreviewAnimInWorld);
childSetValue("save_scripts_as_mono_check", mSaveScriptsAsMono);
childSetValue("always_rez_in_group_check", mAlwaysRezInGroup);
//Disable Teleport Progress
//Disable Logout progress
//always show Build
childSetValue("always_fly_check", mAlwaysShowFly);
//Disable camera minimum distance
childSetValue("power_user_check", mPowerUser);
childSetValue("power_user_confirm_check", mPowerUser);
childSetValue("system_folder_check", mUseSystemFolder);
childSetValue("temp_in_system_check", mUploadToSystem);
childSetEnabled("temp_in_system_check", mUseSystemFolder);
//Chat --------------------------------------------------------------------------------
childSetValue("hide_notifications_in_chat_check", mHideNotificationsInChat);
childSetValue("play_typing_sound_check", mPlayTypingSound);
childSetValue("hide_typing_check", mHideTypingNotification);
childSetValue("seconds_in_chat_and_ims_check", mSecondsInChatAndIMs);
childSetValue("allow_mu_pose_check", mEnableMUPose);
childSetValue("close_ooc_check", mEnableOOCAutoClose);
LLRadioGroup* radioLinkOptions = getChild<LLRadioGroup>("objects_link");
radioLinkOptions->selectNthItem(mLinksForChattingObjects);
//childSetValue("objects_link", mLinksForChattingObjects);
std::string format = gSavedSettings.getString("ShortTimeFormat");
if (format.find("%p") == -1)
{
mTimeFormat = 0;
}
else
{
mTimeFormat = 1;
}
format = gSavedSettings.getString("ShortDateFormat");
if (format.find("%m/%d/%") != -1)
{
mDateFormat = 2;
}
else if (format.find("%d/%m/%") != -1)
{
mDateFormat = 1;
}
else
{
mDateFormat = 0;
}
// time format combobox
LLComboBox* combo = getChild<LLComboBox>("time_format_combobox");
if (combo)
{
combo->setCurrentByIndex(mTimeFormat);
}
// date format combobox
combo = getChild<LLComboBox>("date_format_combobox");
if (combo)
{
combo->setCurrentByIndex(mDateFormat);
}
childSetValue("seconds_in_chat_and_ims_check", mSecondsInChatAndIMs);
LLWString auto_response = utf8str_to_wstring( gSavedPerAccountSettings.getString("AscentInstantMessageResponse") );
LLWStringUtil::replaceChar(auto_response, '^', '\n');
LLWStringUtil::replaceChar(auto_response, '%', ' ');
childSetText("im_response", wstring_to_utf8str(auto_response));
childSetValue("AscentInstantMessageResponseFriends", gSavedPerAccountSettings.getBOOL("AscentInstantMessageResponseFriends"));
childSetValue("AscentInstantMessageResponseMuted", gSavedPerAccountSettings.getBOOL("AscentInstantMessageResponseMuted"));
childSetValue("AscentInstantMessageResponseAnyone", gSavedPerAccountSettings.getBOOL("AscentInstantMessageResponseAnyone"));
childSetValue("AscentInstantMessageShowResponded", gSavedPerAccountSettings.getBOOL("AscentInstantMessageShowResponded"));
childSetValue("AscentInstantMessageShowOnTyping", gSavedPerAccountSettings.getBOOL("AscentInstantMessageAnnounceIncoming"));
childSetValue("AscentInstantMessageResponseRepeat", gSavedPerAccountSettings.getBOOL("AscentInstantMessageResponseRepeat" ));
childSetValue("AscentInstantMessageResponseItem", gSavedPerAccountSettings.getBOOL("AscentInstantMessageResponseItem"));
//Save Performance --------------------------------------------------------------------
childSetValue("fetch_inventory_on_login_check", mFetchInventoryOnLogin);
childSetValue("enable_wind", mEnableLLWind);
childSetValue("enable_clouds", mEnableClouds);
childSetValue("enable_classic_clouds", mEnableClassicClouds);
gLLWindEnabled = mEnableLLWind;
childSetValue("speed_rez_check", mSpeedRez);
childSetEnabled("speed_rez_interval", mSpeedRez);
childSetEnabled("speed_rez_seconds", mSpeedRez);
//Command Line ------------------------------------------------------------------------
//Privacy -----------------------------------------------------------------------------
childSetValue("broadcast_viewer_effects", mBroadcastViewerEffects);
childSetValue("disable_point_at_and_beams_check", mDisablePointAtAndBeam);
childSetValue("private_look_at_check", mPrivateLookAt);
childSetValue("show_look_at_check", mShowLookAt);
childSetValue("revoke_perms_on_stand_up_check", mRevokePermsOnStandUp);
childSetValue("disable_click_sit_check", mDisableClickSit);
}
void LLPanelPermissions::refresh()
{
LLStringUtil::format_map_t argsCurrency;
argsCurrency["[CURRENCY]"] = gHippoGridManager->getConnectedGrid()->getCurrencySymbol();
LLButton* BtnDeedToGroup = getChild<LLButton>("button deed");
if(BtnDeedToGroup)
{
std::string deedText;
if (gSavedSettings.getWarning("DeedObject"))
{
deedText = getString("text deed continued");
}
else
{
deedText = getString("text deed");
}
BtnDeedToGroup->setLabelSelected(deedText);
BtnDeedToGroup->setLabelUnselected(deedText);
}
BOOL root_selected = TRUE;
LLSelectNode* nodep = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode();
S32 object_count = LLSelectMgr::getInstance()->getSelection()->getRootObjectCount();
if(!nodep || 0 == object_count)
{
nodep = LLSelectMgr::getInstance()->getSelection()->getFirstNode();
object_count = LLSelectMgr::getInstance()->getSelection()->getObjectCount();
root_selected = FALSE;
}
//BOOL attachment_selected = LLSelectMgr::getInstance()->getSelection()->isAttachment();
//attachment_selected = false;
LLViewerObject* objectp = NULL;
if(nodep) objectp = nodep->getObject();
if(!nodep || !objectp)// || attachment_selected)
{
// ...nothing selected
disableAll();
return;
}
// figure out a few variables
const BOOL is_one_object = (object_count == 1);
// BUG: fails if a root and non-root are both single-selected.
BOOL is_perm_modify = (LLSelectMgr::getInstance()->getSelection()->getFirstRootNode()
&& LLSelectMgr::getInstance()->selectGetRootsModify())
|| LLSelectMgr::getInstance()->selectGetModify();
BOOL is_nonpermanent_enforced = (LLSelectMgr::getInstance()->getSelection()->getFirstRootNode()
&& LLSelectMgr::getInstance()->selectGetRootsNonPermanentEnforced())
|| LLSelectMgr::getInstance()->selectGetNonPermanentEnforced();
const LLFocusableElement* keyboard_focus_view = gFocusMgr.getKeyboardFocus();
S32 string_index = 0;
std::string MODIFY_INFO_STRINGS[] =
{
getString("text modify info 1"),
getString("text modify info 2"),
getString("text modify info 3"),
getString("text modify info 4"),
getString("text modify info 5"),
getString("text modify info 6")
};
if(!is_perm_modify)
{
string_index += 2;
}
else if (!is_nonpermanent_enforced)
{
string_index += 4;
}
if(!is_one_object)
{
++string_index;
}
getChildView("perm_modify")->setEnabled(TRUE);
getChild<LLUICtrl>("perm_modify")->setValue(MODIFY_INFO_STRINGS[string_index]);
std::string pfAttrName;
if ((LLSelectMgr::getInstance()->getSelection()->getFirstRootNode()
&& LLSelectMgr::getInstance()->selectGetRootsNonPathfinding())
|| LLSelectMgr::getInstance()->selectGetNonPathfinding())
{
pfAttrName = "Pathfinding_Object_Attr_None";
}
else if ((LLSelectMgr::getInstance()->getSelection()->getFirstRootNode()
&& LLSelectMgr::getInstance()->selectGetRootsPermanent())
|| LLSelectMgr::getInstance()->selectGetPermanent())
{
pfAttrName = "Pathfinding_Object_Attr_Permanent";
}
else if ((LLSelectMgr::getInstance()->getSelection()->getFirstRootNode()
&& LLSelectMgr::getInstance()->selectGetRootsCharacter())
|| LLSelectMgr::getInstance()->selectGetCharacter())
{
pfAttrName = "Pathfinding_Object_Attr_Character";
}
else
{
pfAttrName = "Pathfinding_Object_Attr_MultiSelect";
}
getChildView("pathfinding_attributes_value")->setEnabled(TRUE);
getChild<LLUICtrl>("pathfinding_attributes_value")->setValue(LLTrans::getString(pfAttrName));
getChildView("Permissions:")->setEnabled(TRUE);
// Update creator text field
getChildView("Creator:")->setEnabled(TRUE);
// [RLVa:KB] - Checked: 2010-11-02 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
BOOL creators_identical = FALSE;
// [/RLVa:KB]
std::string creator_name;
// [RLVa:KB] - Checked: 2010-11-02 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
creators_identical = LLSelectMgr::getInstance()->selectGetCreator(mCreatorID, creator_name);
// [/RLVa:KB]
// LLSelectMgr::getInstance()->selectGetCreator(mCreatorID, creator_name);
// getChild<LLUICtrl>("Creator Name")->setValue(creator_name);
// getChildView("Creator Name")->setEnabled(TRUE);
// [RLVa:KB] - Moved further down to avoid an annoying flicker when the text is set twice in a row
// Update owner text field
getChildView("Owner:")->setEnabled(TRUE);
// Update last owner text field
getChildView("Last Owner:")->setEnabled(TRUE);
std::string owner_name;
const BOOL owners_identical = LLSelectMgr::getInstance()->selectGetOwner(mOwnerID, owner_name);
// llinfos << "owners_identical " << (owners_identical ? "TRUE": "FALSE") << llendl;
std::string last_owner_name;
LLSelectMgr::getInstance()->selectGetLastOwner(mLastOwnerID, last_owner_name);
if (mOwnerID.isNull())
{
if(LLSelectMgr::getInstance()->selectIsGroupOwned())
{
// Group owned already displayed by selectGetOwner
}
else
{
// Display last owner if public
std::string last_owner_name;
LLSelectMgr::getInstance()->selectGetLastOwner(mLastOwnerID, last_owner_name);
// It should never happen that the last owner is null and the owner
// is null, but it seems to be a bug in the simulator right now. JC
if (!mLastOwnerID.isNull() && !last_owner_name.empty())
{
owner_name.append(", last ");
owner_name.append( last_owner_name );
}
}
}
// getChild<LLUICtrl>("Owner Name")->setValue(owner_name);
// getChildView("Owner Name")->setEnabled(TRUE);
// [RLVa:KB] - Moved further down to avoid an annoying flicker when the text is set twice in a row
// [RLVa:KB] - Checked: 2010-11-02 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
bool fRlvEnableOwner = true;
bool fRlvEnableCreator = true;
bool fRlvEnableLastOwner = true;
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
{
// Only anonymize the creator if all of the selection was created by the same avie who's also the owner or they're a nearby avie
if ( (creators_identical) && (mCreatorID != gAgent.getID()) && ((mCreatorID == mOwnerID) || (RlvUtil::isNearbyAgent(mCreatorID))) )
{
creator_name = RlvStrings::getAnonym(creator_name);
fRlvEnableCreator = false;
}
// Only anonymize the owner name if all of the selection is owned by the same avie and isn't group owned
if ( (owners_identical) && (!LLSelectMgr::getInstance()->selectIsGroupOwned()) && (mOwnerID != gAgent.getID()) )
{
owner_name = RlvStrings::getAnonym(owner_name);
fRlvEnableOwner = false;
}
if (RlvUtil::isNearbyAgent(mLastOwnerID))
{
last_owner_name = RlvStrings::getAnonym(last_owner_name);
fRlvEnableLastOwner = false;
}
}
else if ((objectp->isAttachment() || objectp->isAvatar()) && gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMETAGS) && mOwnerID != gAgentID)
{
owner_name = RlvStrings::getAnonym(owner_name);
fRlvEnableOwner = false;
if (mOwnerID == mCreatorID)
{
creator_name = RlvStrings::getAnonym(creator_name);
fRlvEnableCreator = false;
}
if (mOwnerID == mLastOwnerID)
{
last_owner_name = RlvStrings::getAnonym(last_owner_name);
fRlvEnableLastOwner = false;
}
}
// [/RLVa:KB]
getChild<LLUICtrl>("Creator Name")->setValue(creator_name);
getChildView("Creator Name")->setEnabled(TRUE);
getChild<LLUICtrl>("Owner Name")->setValue(owner_name);
getChildView("Owner Name")->setEnabled(TRUE);
// childSetEnabled("button owner profile",owners_identical && (mOwnerID.notNull() || LLSelectMgr::getInstance()->selectIsGroupOwned()));
// getChildView("button last owner profile")->setEnabled(owners_identical && mLastOwnerID.notNull());
// [RLVa:KB] - Checked: 2009-07-08 (RLVa-1.0.0e)
getChildView("button owner profile")->setEnabled(fRlvEnableOwner && owners_identical && (mOwnerID.notNull() || LLSelectMgr::getInstance()->selectIsGroupOwned()));
getChildView("button creator profile")->setEnabled(fRlvEnableCreator && creators_identical && mCreatorID.notNull());
getChildView("button last owner profile")->setEnabled(fRlvEnableLastOwner && owners_identical && mLastOwnerID.notNull());
// [/RLVa:KB]
getChild<LLUICtrl>("Last Owner Name")->setValue(last_owner_name);
getChildView("Last Owner Name")->setEnabled(TRUE);
// update group text field
getChildView("Group:")->setEnabled(TRUE);
//getChild<LLUICtrl>("Group Name")->setValue(LLStringUtil::null);
LLUUID group_id;
BOOL groups_identical = LLSelectMgr::getInstance()->selectGetGroup(group_id);
if (groups_identical)
{
if(mLabelGroupName)
{
mLabelGroupName->setNameID(group_id, TRUE);
mLabelGroupName->setEnabled(TRUE);
}
}
else
{
if(mLabelGroupName)
{
mLabelGroupName->setNameID(LLUUID::null, TRUE);
mLabelGroupName->refresh(LLUUID::null, std::string(), true);
mLabelGroupName->setEnabled(FALSE);
}
}
getChildView("button set group")->setEnabled(root_selected && owners_identical && (mOwnerID == gAgent.getID()) && is_nonpermanent_enforced);
getChildView("button open group")->setEnabled(group_id.notNull());
getChildView("Name:")->setEnabled(TRUE);
LLLineEditor* LineEditorObjectName = getChild<LLLineEditor>("Object Name");
getChildView("Description:")->setEnabled(TRUE);
LLLineEditor* LineEditorObjectDesc = getChild<LLLineEditor>("Object Description");
if(is_one_object)
{
if(keyboard_focus_view != LineEditorObjectName)
{
LineEditorObjectName->setValue(nodep->mName);
}
if(LineEditorObjectDesc)
{
if(keyboard_focus_view != LineEditorObjectDesc)
{
LineEditorObjectDesc->setText(nodep->mDescription);
}
}
}
else
{
LineEditorObjectName->setText(LLStringUtil::null);
LineEditorObjectDesc->setText(LLStringUtil::null);
}
// figure out the contents of the name, description, & category
// Singu Note: It was requested that the user be able to bulk change description
{
const std::string& str(object_count > 1 ? getString("multiple_objects_selected") : LLStringUtil::null);
LineEditorObjectName->setLabel(str);
LineEditorObjectDesc->setLabel(str);
}
if (/*is_one_object &&*/ objectp->permModify() && !objectp->isPermanentEnforced())
{
LineEditorObjectName->setEnabled(TRUE);
LineEditorObjectDesc->setEnabled(TRUE);
}
else
{
LineEditorObjectName->setEnabled(FALSE);
LineEditorObjectDesc->setEnabled(FALSE);
}
S32 total_sale_price = 0;
S32 individual_sale_price = 0;
BOOL is_for_sale_mixed = FALSE;
BOOL is_sale_price_mixed = FALSE;
U32 num_for_sale = FALSE;
LLSelectMgr::getInstance()->selectGetAggregateSaleInfo(num_for_sale,
is_for_sale_mixed,
is_sale_price_mixed,
total_sale_price,
individual_sale_price);
const BOOL self_owned = (gAgent.getID() == mOwnerID);
const BOOL group_owned = LLSelectMgr::getInstance()->selectIsGroupOwned() ;
const BOOL public_owned = (mOwnerID.isNull() && !LLSelectMgr::getInstance()->selectIsGroupOwned());
const BOOL can_transfer = LLSelectMgr::getInstance()->selectGetRootsTransfer();
const BOOL can_copy = LLSelectMgr::getInstance()->selectGetRootsCopy();
if (!owners_identical)
{
getChildView("Cost")->setEnabled(FALSE);
getChild<LLUICtrl>("Edit Cost")->setValue(LLStringUtil::null);
getChildView("Edit Cost")->setEnabled(FALSE);
}
// You own these objects.
else if(self_owned || (group_owned && gAgent.hasPowerInGroup(group_id,GP_OBJECT_SET_SALE)))
{
// If there are multiple items for sale then set text to PRICE PER UNIT.
if (num_for_sale > 1)
{
getChild<LLUICtrl>("Cost")->setValue(getString("Cost Per Unit"));
}
else
{
getChild<LLUICtrl>("Cost")->setValue(getString("Cost Default"));
}
LLLineEditor *edit_price = getChild<LLLineEditor>("Edit Cost");
if(keyboard_focus_view != edit_price)
{
// If the sale price is mixed then set the cost to MIXED, otherwise
// set to the actual cost.
if (num_for_sale > 0 && is_for_sale_mixed)
{
edit_price->setValue(getString("Sale Mixed"));
}
else if (num_for_sale > 0 && is_sale_price_mixed)
{
edit_price->setValue(getString("Cost Mixed"));
}
else
{
edit_price->setValue(individual_sale_price);
}
}
// The edit fields are only enabled if you can sell this object
// and the sale price is not mixed.
BOOL enable_edit = (num_for_sale && can_transfer) ? !is_for_sale_mixed : FALSE;
getChildView("Cost")->setEnabled(enable_edit);
getChildView("Edit Cost")->setEnabled(enable_edit);
}
// Someone, not you, owns these objects.
else if(!public_owned)
{
getChildView("Cost")->setEnabled(FALSE);
getChildView("Edit Cost")->setEnabled(FALSE);
// Don't show a price if none of the items are for sale.
if (num_for_sale)
getChild<LLUICtrl>("Edit Cost")->setValue(llformat("%d",total_sale_price));
else
getChild<LLUICtrl>("Edit Cost")->setValue(LLStringUtil::null);
// If multiple items are for sale, set text to TOTAL PRICE.
if (num_for_sale > 1)
getChild<LLUICtrl>("Cost")->setValue(getString("Cost Total", argsCurrency));
else
getChild<LLUICtrl>("Cost")->setValue(getString("Cost Default", argsCurrency));
}
// This is a public object.
else
{
getChildView("Cost")->setEnabled(FALSE);
getChild<LLUICtrl>("Cost")->setValue(getString("Cost Default", argsCurrency));
getChild<LLUICtrl>("Edit Cost")->setValue(LLStringUtil::null);
getChildView("Edit Cost")->setEnabled(FALSE);
}
// Enable and disable the permissions checkboxes
// based on who owns the object.
// TODO: Creator permissions
U32 base_mask_on = 0;
U32 base_mask_off = 0;
U32 owner_mask_off = 0;
U32 owner_mask_on = 0;
U32 group_mask_on = 0;
U32 group_mask_off = 0;
U32 everyone_mask_on = 0;
U32 everyone_mask_off = 0;
U32 next_owner_mask_on = 0;
U32 next_owner_mask_off = 0;
BOOL valid_base_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_BASE,
&base_mask_on,
&base_mask_off);
//BOOL valid_owner_perms =//
LLSelectMgr::getInstance()->selectGetPerm(PERM_OWNER,
&owner_mask_on,
&owner_mask_off);
BOOL valid_group_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_GROUP,
&group_mask_on,
&group_mask_off);
BOOL valid_everyone_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_EVERYONE,
&everyone_mask_on,
&everyone_mask_off);
BOOL valid_next_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_NEXT_OWNER,
&next_owner_mask_on,
&next_owner_mask_off);
bool supports_export = LFSimFeatureHandler::instance().simSupportsExport();
if( gSavedSettings.getBOOL("DebugPermissions") )
{
childSetVisible("perm_modify", false);
if (valid_base_perms)
{
std::string perm_string = mask_to_string(base_mask_on);
if (!supports_export && base_mask_on & PERM_EXPORT) // Hide Export when not available
perm_string.erase(perm_string.find_last_of("E"));
if (U32 diff_mask = base_mask_on ^ owner_mask_on) // When different, show the user's potential permissions lowercase.
{
if (diff_mask & PERM_MOVE)
LLStringUtil::replaceChar(perm_string, 'V', 'v');
if (diff_mask & PERM_MODIFY)
LLStringUtil::replaceChar(perm_string, 'M', 'm');
if (diff_mask & PERM_COPY)
LLStringUtil::replaceChar(perm_string, 'C', 'c');
if (diff_mask & PERM_TRANSFER)
LLStringUtil::replaceChar(perm_string, 'T', 't');
if (diff_mask & PERM_EXPORT)
LLStringUtil::replaceChar(perm_string, 'E', 'e');
}
getChild<LLUICtrl>("B:")->setValue("B: " + perm_string);
getChildView("B:")->setVisible( TRUE);
/*
perm_string = mask_to_string(owner_mask_on);
if (!supports_export && owner_mask_on & PERM_EXPORT) // Hide Export when not available
perm_string.erase(perm_string.find_last_of("E"));
getChild<LLUICtrl>("O:")->setValue("O: " + perm_string);
getChildView("O:")->setVisible( TRUE);
*/
getChild<LLUICtrl>("G:")->setValue("G: " + mask_to_string(group_mask_on));
getChildView("G:")->setVisible( TRUE);
perm_string = mask_to_string(everyone_mask_on);
if (!supports_export && everyone_mask_on & PERM_EXPORT) // Hide Export when not available
perm_string.erase(perm_string.find_last_of("E"));
getChild<LLUICtrl>("E:")->setValue("E: " + perm_string);
getChildView("E:")->setVisible( TRUE);
getChild<LLUICtrl>("N:")->setValue("N: " + mask_to_string(next_owner_mask_on));
getChildView("N:")->setVisible( TRUE);
}
U32 flag_mask = 0x0;
if (objectp->permMove()) flag_mask |= PERM_MOVE;
if (objectp->permModify()) flag_mask |= PERM_MODIFY;
if (objectp->permCopy()) flag_mask |= PERM_COPY;
if (objectp->permTransfer()) flag_mask |= PERM_TRANSFER;
getChild<LLUICtrl>("F:")->setValue("F:" + mask_to_string(flag_mask));
getChildView("F:")->setVisible( TRUE);
}
else
{
childSetVisible("perm_modify", true);
getChildView("B:")->setVisible( FALSE);
//getChildView("O:")->setVisible( FALSE);
getChildView("G:")->setVisible( FALSE);
getChildView("E:")->setVisible( FALSE);
getChildView("N:")->setVisible( FALSE);
getChildView("F:")->setVisible( FALSE);
}
BOOL has_change_perm_ability = FALSE;
BOOL has_change_sale_ability = FALSE;
if (valid_base_perms && is_nonpermanent_enforced &&
(self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_MANIPULATE))))
{
has_change_perm_ability = TRUE;
}
if (valid_base_perms && is_nonpermanent_enforced &&
(self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_SET_SALE))))
{
has_change_sale_ability = TRUE;
}
if (!has_change_perm_ability && !has_change_sale_ability && !root_selected)
{
// ...must select root to choose permissions
getChild<LLUICtrl>("perm_modify")->setValue(getString("text modify warning"));
}
if (has_change_perm_ability)
{
getChildView("checkbox share with group")->setEnabled(TRUE);
getChildView("text anyone can")->setEnabled(true);
getChildView("checkbox allow everyone move")->setEnabled(owner_mask_on & PERM_MOVE);
getChildView("checkbox allow everyone copy")->setEnabled(owner_mask_on & PERM_COPY && owner_mask_on & PERM_TRANSFER);
}
else
{
getChildView("checkbox share with group")->setEnabled(FALSE);
getChildView("text anyone can")->setEnabled(false);
getChildView("checkbox allow everyone move")->setEnabled(FALSE);
getChildView("checkbox allow everyone copy")->setEnabled(FALSE);
}
// Is this user allowed to toggle export on this object?
if (supports_export && self_owned && mCreatorID == mOwnerID && can_set_export(base_mask_on, owner_mask_on, next_owner_mask_on))
{
bool can_export = true;
LLInventoryObject::object_list_t objects;
objectp->getInventoryContents(objects);
for (LLInventoryObject::object_list_t::iterator i = objects.begin(); can_export && i != objects.end() ; ++i) //The object's inventory must have EXPORT.
{
LLViewerInventoryItem* item = static_cast<LLViewerInventoryItem*>(i->get()); //getInventoryContents() filters out categories, static_cast.
can_export = perms_allow_export(item->getPermissions());
}
for (U8 i = 0; can_export && i < objectp->getNumTEs(); ++i) // Can the textures be exported?
if (LLTextureEntry* texture = objectp->getTE(i))
can_export = is_asset_exportable(texture->getID());
getChildView("checkbox allow export")->setEnabled(can_export);
}
else
{
getChildView("checkbox allow export")->setEnabled(false);
if (!gHippoGridManager->getCurrentGrid()->isSecondLife())
getChildView("checkbox allow everyone copy")->setVisible(true);
}
if (has_change_sale_ability && (owner_mask_on & PERM_TRANSFER))
{
getChildView("checkbox for sale")->setEnabled(can_transfer || (!can_transfer && num_for_sale));
// Set the checkbox to tentative if the prices of each object selected
// are not the same.
getChild<LLUICtrl>("checkbox for sale")->setTentative( is_for_sale_mixed);
getChildView("sale type")->setEnabled(num_for_sale && can_transfer && !is_sale_price_mixed);
bool no_export = everyone_mask_off & PERM_EXPORT; // Next owner perms can't be changed if set
getChildView("Next owner can:")->setEnabled(no_export);
getChildView("checkbox next owner can modify")->setEnabled(no_export && base_mask_on & PERM_MODIFY);
getChildView("checkbox next owner can copy")->setEnabled(no_export && base_mask_on & PERM_COPY);
getChildView("checkbox next owner can transfer")->setEnabled(no_export && next_owner_mask_on & PERM_COPY);
}
else
{
getChildView("checkbox for sale")->setEnabled(FALSE);
getChildView("sale type")->setEnabled(FALSE);
getChildView("Next owner can:")->setEnabled(FALSE);
getChildView("checkbox next owner can modify")->setEnabled(FALSE);
getChildView("checkbox next owner can copy")->setEnabled(FALSE);
getChildView("checkbox next owner can transfer")->setEnabled(FALSE);
}
if (valid_group_perms)
{
if ((group_mask_on & PERM_COPY) && (group_mask_on & PERM_MODIFY) && (group_mask_on & PERM_MOVE))
{
getChild<LLUICtrl>("checkbox share with group")->setValue(TRUE);
getChild<LLUICtrl>("checkbox share with group")->setTentative( FALSE);
getChildView("button deed")->setEnabled(gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
}
else if ((group_mask_off & PERM_COPY) && (group_mask_off & PERM_MODIFY) && (group_mask_off & PERM_MOVE))
{
getChild<LLUICtrl>("checkbox share with group")->setValue(FALSE);
getChild<LLUICtrl>("checkbox share with group")->setTentative( FALSE);
getChildView("button deed")->setEnabled(FALSE);
}
else
{
getChild<LLUICtrl>("checkbox share with group")->setValue(TRUE);
getChild<LLUICtrl>("checkbox share with group")->setTentative( TRUE);
getChildView("button deed")->setEnabled(gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (group_mask_on & PERM_MOVE) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
}
}
if (valid_everyone_perms)
{
// Move
if (everyone_mask_on & PERM_MOVE)
{
getChild<LLUICtrl>("checkbox allow everyone move")->setValue(TRUE);
getChild<LLUICtrl>("checkbox allow everyone move")->setTentative( FALSE);
}
else if (everyone_mask_off & PERM_MOVE)
{
getChild<LLUICtrl>("checkbox allow everyone move")->setValue(FALSE);
getChild<LLUICtrl>("checkbox allow everyone move")->setTentative( FALSE);
}
else
{
getChild<LLUICtrl>("checkbox allow everyone move")->setValue(TRUE);
getChild<LLUICtrl>("checkbox allow everyone move")->setTentative( TRUE);
}
// Copy == everyone can't copy
if (everyone_mask_on & PERM_COPY)
{
getChild<LLUICtrl>("checkbox allow everyone copy")->setValue(TRUE);
getChild<LLUICtrl>("checkbox allow everyone copy")->setTentative( !can_copy || !can_transfer);
}
else if (everyone_mask_off & PERM_COPY)
{
getChild<LLUICtrl>("checkbox allow everyone copy")->setValue(FALSE);
getChild<LLUICtrl>("checkbox allow everyone copy")->setTentative( FALSE);
}
else
{
getChild<LLUICtrl>("checkbox allow everyone copy")->setValue(TRUE);
getChild<LLUICtrl>("checkbox allow everyone copy")->setTentative( TRUE);
}
// Export
if (supports_export)
{
if(everyone_mask_on & PERM_EXPORT)
{
getChild<LLUICtrl>("checkbox allow export")->setValue(TRUE);
getChild<LLUICtrl>("checkbox allow export")->setTentative( FALSE);
}
else if(everyone_mask_off & PERM_EXPORT)
{
getChild<LLUICtrl>("checkbox allow export")->setValue(FALSE);
getChild<LLUICtrl>("checkbox allow export")->setTentative( FALSE);
}
else
{
getChild<LLUICtrl>("checkbox allow export")->setValue(TRUE);
getChild<LLUICtrl>("checkbox allow export")->setValue( TRUE);
}
}
else
{
childSetValue("checkbox allow export", false);
childSetTentative("checkbox allow export", false);
}
}
if (valid_next_perms)
{
// Modify == next owner canot modify
if (next_owner_mask_on & PERM_MODIFY)
{
getChild<LLUICtrl>("checkbox next owner can modify")->setValue(TRUE);
getChild<LLUICtrl>("checkbox next owner can modify")->setTentative( FALSE);
}
else if (next_owner_mask_off & PERM_MODIFY)
{
getChild<LLUICtrl>("checkbox next owner can modify")->setValue(FALSE);
getChild<LLUICtrl>("checkbox next owner can modify")->setTentative( FALSE);
}
else
{
getChild<LLUICtrl>("checkbox next owner can modify")->setValue(TRUE);
getChild<LLUICtrl>("checkbox next owner can modify")->setTentative( TRUE);
}
// Copy == next owner cannot copy
if (next_owner_mask_on & PERM_COPY)
{
getChild<LLUICtrl>("checkbox next owner can copy")->setValue(TRUE);
getChild<LLUICtrl>("checkbox next owner can copy")->setTentative( !can_copy);
}
else if (next_owner_mask_off & PERM_COPY)
{
getChild<LLUICtrl>("checkbox next owner can copy")->setValue(FALSE);
getChild<LLUICtrl>("checkbox next owner can copy")->setTentative( FALSE);
}
else
{
getChild<LLUICtrl>("checkbox next owner can copy")->setValue(TRUE);
getChild<LLUICtrl>("checkbox next owner can copy")->setTentative( TRUE);
}
// Transfer == next owner cannot transfer
if (next_owner_mask_on & PERM_TRANSFER)
{
getChild<LLUICtrl>("checkbox next owner can transfer")->setValue(TRUE);
getChild<LLUICtrl>("checkbox next owner can transfer")->setTentative( !can_transfer);
}
else if (next_owner_mask_off & PERM_TRANSFER)
{
getChild<LLUICtrl>("checkbox next owner can transfer")->setValue(FALSE);
getChild<LLUICtrl>("checkbox next owner can transfer")->setTentative( FALSE);
}
else
{
getChild<LLUICtrl>("checkbox next owner can transfer")->setValue(TRUE);
getChild<LLUICtrl>("checkbox next owner can transfer")->setTentative( TRUE);
}
}
// reflect sale information
LLSaleInfo sale_info;
BOOL valid_sale_info = LLSelectMgr::getInstance()->selectGetSaleInfo(sale_info);
LLSaleInfo::EForSale sale_type = sale_info.getSaleType();
LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("sale type");
if(RadioSaleType)
{
if (valid_sale_info)
{
RadioSaleType->setSelectedIndex((S32)sale_type - 1);
RadioSaleType->setTentative(FALSE); // unfortunately this doesn't do anything at the moment.
}
else
{
// default option is sell copy, determined to be safest
RadioSaleType->setSelectedIndex((S32)LLSaleInfo::FS_COPY - 1);
RadioSaleType->setTentative(TRUE); // unfortunately this doesn't do anything at the moment.
}
}
getChild<LLUICtrl>("checkbox for sale")->setValue((num_for_sale != 0));
// HACK: There are some old objects in world that are set for sale,
// but are no-transfer. We need to let users turn for-sale off, but only
// if for-sale is set.
bool cannot_actually_sell = !can_transfer || (!can_copy && sale_type == LLSaleInfo::FS_COPY);
if (cannot_actually_sell)
{
if (num_for_sale && has_change_sale_ability)
{
getChildView("checkbox for sale")->setEnabled(true);
}
}
// Check search status of objects
const BOOL all_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME );
bool include_in_search;
const BOOL all_include_in_search = LLSelectMgr::getInstance()->selectionGetIncludeInSearch(&include_in_search);
getChildView("search_check")->setEnabled(has_change_sale_ability && all_volume);
getChild<LLUICtrl>("search_check")->setValue(include_in_search);
getChild<LLUICtrl>("search_check")->setTentative( !all_include_in_search);
// Click action (touch, sit, buy)
U8 click_action = 0;
if (LLSelectMgr::getInstance()->selectionGetClickAction(&click_action))
{
LLComboBox* combo_click_action = getChild<LLComboBox>("clickaction");
if(combo_click_action)
{
combo_click_action->setCurrentByIndex((S32)click_action);
}
}
getChildView("label click action")->setEnabled(is_perm_modify && is_nonpermanent_enforced && all_volume);
getChildView("clickaction")->setEnabled(is_perm_modify && is_nonpermanent_enforced && all_volume);
}
void LLPanelPermissions::disableAll()
{
getChildView("perm_modify")->setEnabled(FALSE);
getChild<LLUICtrl>("perm_modify")->setValue(LLStringUtil::null);
getChildView("pathfinding_attributes_value")->setEnabled(FALSE);
getChild<LLUICtrl>("pathfinding_attributes_value")->setValue(LLStringUtil::null);
getChildView("Creator:")->setEnabled(FALSE);
getChild<LLUICtrl>("Creator Name")->setValue(LLStringUtil::null);
getChildView("Creator Name")->setEnabled(FALSE);
getChildView("button creator profile")->setEnabled(FALSE);
getChildView("Owner:")->setEnabled(FALSE);
getChild<LLUICtrl>("Owner Name")->setValue(LLStringUtil::null);
getChildView("Owner Name")->setEnabled(FALSE);
getChildView("button owner profile")->setEnabled(FALSE);
getChildView("Last Owner:")->setEnabled(FALSE);
getChild<LLUICtrl>("Last Owner Name")->setValue(LLStringUtil::null);
getChildView("Last Owner Name")->setEnabled(FALSE);
getChildView("button last owner profile")->setEnabled(FALSE);
getChildView("Group:")->setEnabled(FALSE);
getChild<LLUICtrl>("Group Name Proxy")->setValue(LLStringUtil::null);
getChildView("Group Name Proxy")->setEnabled(FALSE);
getChildView("button set group")->setEnabled(FALSE);
getChildView("button open group")->setEnabled(FALSE);
LLLineEditor* ed = getChild<LLLineEditor>("Object Name");
ed->setValue(LLStringUtil::null);
ed->setEnabled(FALSE);
ed->setLabel(LLStringUtil::null);
getChildView("Name:")->setEnabled(FALSE);
//getChild<LLUICtrl>("Group Name")->setValue(LLStringUtil::null);
//getChildView("Group Name")->setEnabled(FALSE);
getChildView("Description:")->setEnabled(FALSE);
ed = getChild<LLLineEditor>("Object Description");
ed->setEnabled(FALSE);
ed->setValue(LLStringUtil::null);
ed->setLabel(LLStringUtil::null);
getChildView("Permissions:")->setEnabled(FALSE);
getChild<LLUICtrl>("checkbox share with group")->setValue(FALSE);
getChildView("checkbox share with group")->setEnabled(FALSE);
getChildView("button deed")->setEnabled(FALSE);
getChildView("text anyone can")->setEnabled(FALSE);
getChild<LLUICtrl>("checkbox allow everyone move")->setValue(FALSE);
getChildView("checkbox allow everyone move")->setEnabled(FALSE);
getChild<LLUICtrl>("checkbox allow everyone copy")->setValue(FALSE);
getChildView("checkbox allow everyone copy")->setEnabled(FALSE);
getChild<LLUICtrl>("checkbox allow export")->setValue(FALSE);
getChildView("checkbox allow export")->setEnabled(FALSE);
//Next owner can:
getChildView("Next owner can:")->setEnabled(FALSE);
getChild<LLUICtrl>("checkbox next owner can modify")->setValue(FALSE);
getChildView("checkbox next owner can modify")->setEnabled(FALSE);
getChild<LLUICtrl>("checkbox next owner can copy")->setValue(FALSE);
getChildView("checkbox next owner can copy")->setEnabled(FALSE);
getChild<LLUICtrl>("checkbox next owner can transfer")->setValue(FALSE);
getChildView("checkbox next owner can transfer")->setEnabled(FALSE);
//checkbox for sale
getChild<LLUICtrl>("checkbox for sale")->setValue(FALSE);
getChildView("checkbox for sale")->setEnabled(FALSE);
//checkbox include in search
getChild<LLUICtrl>("search_check")->setValue(FALSE);
getChildView("search_check")->setEnabled(FALSE);
LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("sale type");
if(RadioSaleType)
{
RadioSaleType->setSelectedIndex(-1);
RadioSaleType->setEnabled(FALSE);
}
getChildView("Cost")->setEnabled(FALSE);
getChild<LLUICtrl>("Cost")->setValue(getString("Cost Default"));
getChild<LLUICtrl>("Edit Cost")->setValue(LLStringUtil::null);
getChildView("Edit Cost")->setEnabled(FALSE);
getChildView("label click action")->setEnabled(FALSE);
LLComboBox* combo_click_action = getChild<LLComboBox>("clickaction");
if (combo_click_action)
{
combo_click_action->setEnabled(FALSE);
combo_click_action->clear();
}
getChildView("B:")->setVisible( FALSE);
//getChildView("O:")->setVisible( FALSE);
getChildView("G:")->setVisible( FALSE);
getChildView("E:")->setVisible( FALSE);
getChildView("N:")->setVisible( FALSE);
getChildView("F:")->setVisible( FALSE);
}
void LLPanelPermissions::refresh()
{
LLStringUtil::format_map_t argsCurrency;
argsCurrency["[CURRENCY]"] = gHippoGridManager->getConnectedGrid()->getCurrencySymbol();
LLButton* BtnDeedToGroup = getChild<LLButton>("button deed");
if(BtnDeedToGroup)
{
std::string deedText;
if (gSavedSettings.getWarning("DeedObject"))
{
deedText = getString("text deed continued");
}
else
{
deedText = getString("text deed");
}
BtnDeedToGroup->setLabelSelected(deedText);
BtnDeedToGroup->setLabelUnselected(deedText);
}
BOOL root_selected = TRUE;
LLSelectNode* nodep = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode();
S32 object_count = LLSelectMgr::getInstance()->getSelection()->getRootObjectCount();
if(!nodep || 0 == object_count)
{
nodep = LLSelectMgr::getInstance()->getSelection()->getFirstNode();
object_count = LLSelectMgr::getInstance()->getSelection()->getObjectCount();
root_selected = FALSE;
}
//BOOL attachment_selected = LLSelectMgr::getInstance()->getSelection()->isAttachment();
//attachment_selected = false;
LLViewerObject* objectp = NULL;
if(nodep) objectp = nodep->getObject();
if(!nodep || !objectp)// || attachment_selected)
{
// ...nothing selected
childSetEnabled("perm_modify",false);
childSetText("perm_modify",LLStringUtil::null);
childSetEnabled("Creator:",false);
childSetText("Creator Name",LLStringUtil::null);
childSetEnabled("Creator Name",false);
childSetEnabled("button creator profile",false);
childSetEnabled("Owner:",false);
childSetText("Owner Name",LLStringUtil::null);
childSetEnabled("Owner Name",false);
childSetEnabled("button owner profile",false);
childSetEnabled("Last Owner:",false);
childSetText("Last Owner Name",LLStringUtil::null);
childSetEnabled("Last Owner Name",false);
childSetEnabled("button last owner profile",false);
childSetEnabled("Group:",false);
childSetText("Group Name",LLStringUtil::null);
childSetEnabled("Group Name",false);
childSetEnabled("button set group",false);
childSetText("Object Name",LLStringUtil::null);
childSetEnabled("Object Name",false);
childSetEnabled("Name:",false);
childSetText("Group Name",LLStringUtil::null);
childSetEnabled("Group Name",false);
childSetEnabled("Description:",false);
childSetText("Object Description",LLStringUtil::null);
childSetEnabled("Object Description",false);
childSetEnabled("Permissions:",false);
childSetValue("checkbox share with group",FALSE);
childSetEnabled("checkbox share with group",false);
childSetEnabled("button deed",false);
childSetValue("checkbox allow everyone move",FALSE);
childSetEnabled("checkbox allow everyone move",false);
childSetValue("checkbox allow everyone copy",FALSE);
childSetEnabled("checkbox allow everyone copy",false);
//Next owner can:
childSetEnabled("Next owner can:",false);
childSetValue("checkbox next owner can modify",FALSE);
childSetEnabled("checkbox next owner can modify",false);
childSetValue("checkbox next owner can copy",FALSE);
childSetEnabled("checkbox next owner can copy",false);
childSetValue("checkbox next owner can transfer",FALSE);
childSetEnabled("checkbox next owner can transfer",false);
//checkbox for sale
childSetValue("checkbox for sale",FALSE);
childSetEnabled("checkbox for sale",false);
//checkbox include in search
childSetValue("search_check", FALSE);
childSetEnabled("search_check", false);
LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("sale type");
if(RadioSaleType)
{
RadioSaleType->setSelectedIndex(-1);
RadioSaleType->setEnabled(FALSE);
}
childSetEnabled("Cost",false);
childSetText("Cost", getString("Cost Default", argsCurrency));
childSetText("Edit Cost",LLStringUtil::null);
childSetEnabled("Edit Cost",false);
childSetEnabled("label click action",false);
LLComboBox* ComboClickAction = getChild<LLComboBox>("clickaction");
if(ComboClickAction)
{
ComboClickAction->setEnabled(FALSE);
ComboClickAction->clear();
}
childSetVisible("B:",false);
childSetVisible("O:",false);
childSetVisible("G:",false);
childSetVisible("E:",false);
childSetVisible("N:",false);
childSetVisible("F:",false);
return;
}
// figure out a few variables
BOOL is_one_object = (object_count == 1);
// BUG: fails if a root and non-root are both single-selected.
BOOL is_perm_modify = (LLSelectMgr::getInstance()->getSelection()->getFirstRootNode()
&& LLSelectMgr::getInstance()->selectGetRootsModify())
|| LLSelectMgr::getInstance()->selectGetModify();
const LLView* keyboard_focus_view = gFocusMgr.getKeyboardFocus();
S32 string_index = 0;
std::string MODIFY_INFO_STRINGS[] =
{
getString("text modify info 1"),
getString("text modify info 2"),
getString("text modify info 3"),
getString("text modify info 4")
};
if(!is_perm_modify)
{
string_index += 2;
}
if(!is_one_object)
{
++string_index;
}
childSetEnabled("perm_modify",true);
childSetText("perm_modify",MODIFY_INFO_STRINGS[string_index]);
childSetEnabled("Permissions:",true);
// Update creator text field
childSetEnabled("Creator:",true);
BOOL creators_identical;
std::string creator_name;
creators_identical = LLSelectMgr::getInstance()->selectGetCreator(mCreatorID,
creator_name);
childSetText("Creator Name",creator_name);
childSetEnabled("Creator Name",TRUE);
childSetEnabled("button creator profile", creators_identical && mCreatorID.notNull() );
// Update owner text field
childSetEnabled("Owner:",true);
BOOL owners_identical;
std::string owner_name;
owners_identical = LLSelectMgr::getInstance()->selectGetOwner(mOwnerID, owner_name);
// llinfos << "owners_identical " << (owners_identical ? "TRUE": "FALSE") << llendl;
std::string last_owner_name;
LLSelectMgr::getInstance()->selectGetLastOwner(mLastOwnerID, last_owner_name);
if (mOwnerID.isNull())
{
if(LLSelectMgr::getInstance()->selectIsGroupOwned())
{
// Group owned already displayed by selectGetOwner
}
else
{
// Display last owner if public
//std::string last_owner_name;
//LLSelectMgr::getInstance()->selectGetLastOwner(mLastOwnerID, last_owner_name);
// It should never happen that the last owner is null and the owner
// is null, but it seems to be a bug in the simulator right now. JC
if (!mLastOwnerID.isNull() && !last_owner_name.empty())
{
owner_name.append(", last ");
owner_name.append( last_owner_name );
}
}
}
// [RLVa:KB] - Checked: 2009-07-08 (RLVa-1.0.0e)
bool fRlvEnableOwner = true;
if ( (rlv_handler_t::isEnabled()) && (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) )
{
// Only filter the owner name if: the selection is all owned by the same avie and not group owned
if ( (owners_identical) && (!LLSelectMgr::getInstance()->selectIsGroupOwned()) )
{
owner_name = gRlvHandler.getAnonym(owner_name);
fRlvEnableOwner = false;
}
}
// [/RLVa:KB]
childSetText("Owner Name",owner_name);
childSetEnabled("Owner Name",TRUE);
// childSetEnabled("button owner profile",owners_identical && (mOwnerID.notNull() || LLSelectMgr::getInstance()->selectIsGroupOwned()));
// [RLVa:KB] - Checked: 2009-07-08 (RLVa-1.0.0e)
childSetEnabled("button owner profile",
fRlvEnableOwner && owners_identical && (mOwnerID.notNull() || LLSelectMgr::getInstance()->selectIsGroupOwned()));
// [/RLVa:KB]
//if (owner_name != last_owner_name)
// [RLVa:KB]
if ( (owner_name != last_owner_name) && (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) )
// [/RLVa:KB]
{
childSetEnabled("Last Owner:", TRUE);
childSetText("Last Owner Name", last_owner_name);
childSetEnabled("Last Owner Name", TRUE);
childSetEnabled("button last owner profile", TRUE);
}
else
{
childSetEnabled("Last Owner:", FALSE);
childSetText("Last Owner Name", LLStringUtil::null);
childSetEnabled("Last Owner Name", FALSE);
childSetEnabled("button last owner profile", FALSE);
}
// update group text field
childSetEnabled("Group:",true);
childSetText("Group Name",LLStringUtil::null);
LLUUID group_id;
BOOL groups_identical = LLSelectMgr::getInstance()->selectGetGroup(group_id);
if (groups_identical)
{
if(mLabelGroupName)
{
mLabelGroupName->setNameID(group_id, TRUE);
mLabelGroupName->setEnabled(TRUE);
}
}
else
{
if(mLabelGroupName)
{
mLabelGroupName->setNameID(LLUUID::null, TRUE);
mLabelGroupName->refresh(LLUUID::null, LLStringUtil::null, LLStringUtil::null, TRUE);
mLabelGroupName->setEnabled(FALSE);
}
}
childSetEnabled("button set group",owners_identical && (mOwnerID == gAgent.getID()));
// figure out the contents of the name, description, & category
BOOL edit_name_desc = FALSE;
if(is_one_object && objectp->permModify())
{
edit_name_desc = TRUE;
}
childSetEnabled("Name:",true);
LLLineEditor* LineEditorObjectName = getChild<LLLineEditor>("Object Name");
childSetEnabled("Description:",true);
LLLineEditor* LineEditorObjectDesc = getChild<LLLineEditor>("Object Description");
if(is_one_object)
{
if(keyboard_focus_view != LineEditorObjectName)
{
childSetText("Object Name",nodep->mName);
}
if(LineEditorObjectDesc)
{
if(keyboard_focus_view != LineEditorObjectDesc)
{
LineEditorObjectDesc->setText(nodep->mDescription);
}
}
}
else
{
childSetText("Object Name",LLStringUtil::null);
LineEditorObjectDesc->setText(LLStringUtil::null);
}
if(edit_name_desc)
{
childSetEnabled("Object Name",true);
childSetEnabled("Object Description",true);
}
else
{
childSetEnabled("Object Name",false);
childSetEnabled("Object Description",false);
}
S32 total_sale_price = 0;
S32 individual_sale_price = 0;
BOOL is_for_sale_mixed = FALSE;
BOOL is_sale_price_mixed = FALSE;
U32 num_for_sale = FALSE;
LLSelectMgr::getInstance()->selectGetAggregateSaleInfo(num_for_sale,
is_for_sale_mixed,
is_sale_price_mixed,
total_sale_price,
individual_sale_price);
const BOOL self_owned = (gAgent.getID() == mOwnerID);
const BOOL group_owned = LLSelectMgr::getInstance()->selectIsGroupOwned() ;
const BOOL public_owned = (mOwnerID.isNull() && !LLSelectMgr::getInstance()->selectIsGroupOwned());
const BOOL can_transfer = LLSelectMgr::getInstance()->selectGetRootsTransfer();
const BOOL can_copy = LLSelectMgr::getInstance()->selectGetRootsCopy();
if(!owners_identical)
{
childSetEnabled("Cost",false);
childSetText("Edit Cost",LLStringUtil::null);
childSetEnabled("Edit Cost",false);
}
// You own these objects.
else if(self_owned || (group_owned && gAgent.hasPowerInGroup(group_id,GP_OBJECT_SET_SALE)))
{
// If there are multiple items for sale then set text to PRICE PER UNIT.
if (num_for_sale > 1)
{
childSetText("Cost",getString("Cost Per Unit", argsCurrency));
}
else
{
childSetText("Cost",getString("Cost Default", argsCurrency));
}
LLLineEditor *editPrice = getChild<LLLineEditor>("Edit Cost");
if(keyboard_focus_view != editPrice)
{
// If the sale price is mixed then set the cost to MIXED, otherwise
// set to the actual cost.
if (num_for_sale > 0 && is_for_sale_mixed)
{
childSetText("Edit Cost",getString("Sale Mixed"));
}
else if (num_for_sale > 0 && is_sale_price_mixed)
{
childSetText("Edit Cost",getString("Cost Mixed"));
}
else
{
childSetText("Edit Cost",llformat("%d",individual_sale_price));
}
}
// The edit fields are only enabled if you can sell this object
// and the sale price is not mixed.
bool enable_edit = (num_for_sale && can_transfer) ? !is_for_sale_mixed : false;
childSetEnabled("Cost",enable_edit);
childSetEnabled("Edit Cost",enable_edit);
}
// Someone, not you, owns these objects.
else if(!public_owned)
{
childSetEnabled("Cost",false);
childSetEnabled("Edit Cost",false);
// Don't show a price if none of the items are for sale.
if (num_for_sale)
childSetText("Edit Cost",llformat("%d",total_sale_price));
else
childSetText("Edit Cost",LLStringUtil::null);
// If multiple items are for sale, set text to TOTAL PRICE.
if (num_for_sale > 1)
childSetText("Cost", getString("Cost Total", argsCurrency));
else
childSetText("Cost", getString("Cost Default", argsCurrency));
}
// This is a public object.
else
{
childSetEnabled("Cost",false);
childSetText("Cost", getString("Cost Default", argsCurrency));
childSetText("Edit Cost",LLStringUtil::null);
childSetEnabled("Edit Cost",false);
}
// Enable and disable the permissions checkboxes
// based on who owns the object.
// TODO: Creator permissions
BOOL valid_base_perms = FALSE;
BOOL valid_owner_perms = FALSE;
BOOL valid_group_perms = FALSE;
BOOL valid_everyone_perms = FALSE;
BOOL valid_next_perms = FALSE;
U32 base_mask_on;
U32 base_mask_off;
U32 owner_mask_on;
U32 owner_mask_off;
U32 group_mask_on;
U32 group_mask_off;
U32 everyone_mask_on;
U32 everyone_mask_off;
U32 next_owner_mask_on = 0;
U32 next_owner_mask_off = 0;
valid_base_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_BASE,
&base_mask_on,
&base_mask_off);
valid_owner_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_OWNER,
&owner_mask_on,
&owner_mask_off);
valid_group_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_GROUP,
&group_mask_on,
&group_mask_off);
valid_everyone_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_EVERYONE,
&everyone_mask_on,
&everyone_mask_off);
valid_next_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_NEXT_OWNER,
&next_owner_mask_on,
&next_owner_mask_off);
if( gSavedSettings.getBOOL("DebugPermissions") )
{
std::string perm_string;
if (valid_base_perms)
{
perm_string = "B: ";
perm_string += mask_to_string(base_mask_on);
childSetText("B:",perm_string);
childSetVisible("B:",true);
perm_string = "O: ";
perm_string += mask_to_string(owner_mask_on);
childSetText("O:",perm_string);
childSetVisible("O:",true);
perm_string = "G: ";
perm_string += mask_to_string(group_mask_on);
childSetText("G:",perm_string);
childSetVisible("G:",true);
perm_string = "E: ";
perm_string += mask_to_string(everyone_mask_on);
childSetText("E:",perm_string);
childSetVisible("E:",true);
perm_string = "N: ";
perm_string += mask_to_string(next_owner_mask_on);
childSetText("N:",perm_string);
childSetVisible("N:",true);
}
perm_string = "F: ";
U32 flag_mask = 0x0;
if (objectp->permMove())
flag_mask |= PERM_MOVE;
if (objectp->permModify())
flag_mask |= PERM_MODIFY;
if (objectp->permCopy())
flag_mask |= PERM_COPY;
if (objectp->permTransfer())
flag_mask |= PERM_TRANSFER;
perm_string += mask_to_string(flag_mask);
childSetText("F:",perm_string);
childSetVisible("F:",true);
}
else
{
childSetVisible("B:",false);
childSetVisible("O:",false);
childSetVisible("G:",false);
childSetVisible("E:",false);
childSetVisible("N:",false);
childSetVisible("F:",false);
}
bool has_change_perm_ability = false;
bool has_change_sale_ability = false;
if(valid_base_perms
&& (self_owned
|| (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_MANIPULATE))))
{
has_change_perm_ability = true;
}
if(valid_base_perms
&& (self_owned
|| (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_SET_SALE))))
{
has_change_sale_ability = true;
}
if (!has_change_perm_ability && !has_change_sale_ability && !root_selected)
{
// ...must select root to choose permissions
childSetValue("perm_modify", getString("text modify warning"));
}
if (has_change_perm_ability)
{
childSetEnabled("checkbox share with group",true);
childSetEnabled("checkbox allow everyone move",owner_mask_on & PERM_MOVE);
childSetEnabled("checkbox allow everyone copy",owner_mask_on & PERM_COPY && owner_mask_on & PERM_TRANSFER);
}
else
{
childSetEnabled("checkbox share with group", FALSE);
childSetEnabled("checkbox allow everyone move", FALSE);
childSetEnabled("checkbox allow everyone copy", FALSE);
}
if (has_change_sale_ability && (owner_mask_on & PERM_TRANSFER))
{
childSetEnabled("checkbox for sale", can_transfer || (!can_transfer && num_for_sale));
// Set the checkbox to tentative if the prices of each object selected
// are not the same.
childSetTentative("checkbox for sale", is_for_sale_mixed);
childSetEnabled("sale type",num_for_sale && can_transfer && !is_sale_price_mixed);
childSetEnabled("Next owner can:", TRUE);
childSetEnabled("checkbox next owner can modify",base_mask_on & PERM_MODIFY);
childSetEnabled("checkbox next owner can copy",base_mask_on & PERM_COPY);
childSetEnabled("checkbox next owner can transfer",next_owner_mask_on & PERM_COPY);
}
else
{
childSetEnabled("checkbox for sale",FALSE);
childSetEnabled("sale type",FALSE);
childSetEnabled("Next owner can:",FALSE);
childSetEnabled("checkbox next owner can modify",FALSE);
childSetEnabled("checkbox next owner can copy",FALSE);
childSetEnabled("checkbox next owner can transfer",FALSE);
}
if(valid_group_perms)
{
if((group_mask_on & PERM_COPY) && (group_mask_on & PERM_MODIFY) && (group_mask_on & PERM_MOVE))
{
childSetValue("checkbox share with group",TRUE);
childSetTentative("checkbox share with group",FALSE);
childSetEnabled("button deed",gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
}
else if((group_mask_off & PERM_COPY) && (group_mask_off & PERM_MODIFY) && (group_mask_off & PERM_MOVE))
{
childSetValue("checkbox share with group",FALSE);
childSetTentative("checkbox share with group",false);
childSetEnabled("button deed",false);
}
else
{
childSetValue("checkbox share with group",TRUE);
childSetTentative("checkbox share with group",true);
childSetEnabled("button deed",gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (group_mask_on & PERM_MOVE) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
}
}
if(valid_everyone_perms)
{
// Move
if(everyone_mask_on & PERM_MOVE)
{
childSetValue("checkbox allow everyone move",TRUE);
childSetTentative("checkbox allow everyone move",false);
}
else if(everyone_mask_off & PERM_MOVE)
{
childSetValue("checkbox allow everyone move",FALSE);
childSetTentative("checkbox allow everyone move",false);
}
else
{
childSetValue("checkbox allow everyone move",TRUE);
childSetTentative("checkbox allow everyone move",true);
}
// Copy == everyone can't copy
if(everyone_mask_on & PERM_COPY)
{
childSetValue("checkbox allow everyone copy",TRUE);
childSetTentative("checkbox allow everyone copy",!can_copy || !can_transfer);
}
else if(everyone_mask_off & PERM_COPY)
{
childSetValue("checkbox allow everyone copy",FALSE);
childSetTentative("checkbox allow everyone copy",false);
}
else
{
childSetValue("checkbox allow everyone copy",TRUE);
childSetTentative("checkbox allow everyone copy",true);
}
}
if(valid_next_perms)
{
// Modify == next owner canot modify
if(next_owner_mask_on & PERM_MODIFY)
{
childSetValue("checkbox next owner can modify",TRUE);
childSetTentative("checkbox next owner can modify",false);
}
else if(next_owner_mask_off & PERM_MODIFY)
{
childSetValue("checkbox next owner can modify",FALSE);
childSetTentative("checkbox next owner can modify",false);
}
else
{
childSetValue("checkbox next owner can modify",TRUE);
childSetTentative("checkbox next owner can modify",true);
}
// Copy == next owner cannot copy
if(next_owner_mask_on & PERM_COPY)
{
childSetValue("checkbox next owner can copy",TRUE);
childSetTentative("checkbox next owner can copy",!can_copy);
}
else if(next_owner_mask_off & PERM_COPY)
{
childSetValue("checkbox next owner can copy",FALSE);
childSetTentative("checkbox next owner can copy",FALSE);
}
else
{
childSetValue("checkbox next owner can copy",TRUE);
childSetTentative("checkbox next owner can copy",TRUE);
}
// Transfer == next owner cannot transfer
if(next_owner_mask_on & PERM_TRANSFER)
{
childSetValue("checkbox next owner can transfer",TRUE);
childSetTentative("checkbox next owner can transfer",!can_transfer);
}
else if(next_owner_mask_off & PERM_TRANSFER)
{
childSetValue("checkbox next owner can transfer",FALSE);
childSetTentative("checkbox next owner can transfer",FALSE);
}
else
{
childSetValue("checkbox next owner can transfer",TRUE);
childSetTentative("checkbox next owner can transfer",TRUE);
}
}
// reflect sale information
LLSaleInfo sale_info;
BOOL valid_sale_info = LLSelectMgr::getInstance()->selectGetSaleInfo(sale_info);
LLSaleInfo::EForSale sale_type = sale_info.getSaleType();
LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("sale type");
if(RadioSaleType)
{
if (valid_sale_info)
{
RadioSaleType->setSelectedIndex((S32)sale_type - 1);
RadioSaleType->setTentative(FALSE); // unfortunately this doesn't do anything at the moment.
}
else
{
// default option is sell copy, determined to be safest
RadioSaleType->setSelectedIndex((S32)LLSaleInfo::FS_COPY - 1);
RadioSaleType->setTentative(TRUE); // unfortunately this doesn't do anything at the moment.
}
}
childSetValue("checkbox for sale", num_for_sale != 0);
// HACK: There are some old objects in world that are set for sale,
// but are no-transfer. We need to let users turn for-sale off, but only
// if for-sale is set.
bool cannot_actually_sell = !can_transfer || (!can_copy && sale_type == LLSaleInfo::FS_COPY);
if (num_for_sale && has_change_sale_ability && cannot_actually_sell)
{
childSetEnabled("checkbox for sale", true);
}
// Check search status of objects
BOOL all_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME );
bool include_in_search;
bool all_include_in_search = LLSelectMgr::getInstance()->selectionGetIncludeInSearch(&include_in_search);
childSetEnabled("search_check", has_change_sale_ability && all_volume);
childSetValue("search_check", include_in_search);
childSetTentative("search_check", ! all_include_in_search);
// Click action (touch, sit, buy)
U8 click_action = 0;
if (LLSelectMgr::getInstance()->selectionGetClickAction(&click_action))
{
LLComboBox* ComboClickAction = getChild<LLComboBox>("clickaction");
if(ComboClickAction)
{
ComboClickAction->setCurrentByIndex((S32)click_action);
}
}
childSetEnabled("label click action",is_perm_modify && all_volume);
childSetEnabled("clickaction",is_perm_modify && all_volume);
}
void LLFloaterPreference::refreshEnabledState()
{
LLCheckBoxCtrl* ctrl_reflections = getChild<LLCheckBoxCtrl>("Reflections");
LLRadioGroup* radio_reflection_detail = getChild<LLRadioGroup>("ReflectionDetailRadio");
// Reflections
BOOL reflections = gSavedSettings.getBOOL("VertexShaderEnable")
&& gGLManager.mHasCubeMap
&& LLCubeMap::sUseCubeMaps;
ctrl_reflections->setEnabled(reflections);
// Bump & Shiny
bool bumpshiny = gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps && LLFeatureManager::getInstance()->isFeatureAvailable("RenderObjectBump");
getChild<LLCheckBoxCtrl>("BumpShiny")->setEnabled(bumpshiny ? TRUE : FALSE);
radio_reflection_detail->setEnabled(ctrl_reflections->get() && reflections);
// Avatar Mode
// Enable Avatar Shaders
LLCheckBoxCtrl* ctrl_avatar_vp = getChild<LLCheckBoxCtrl>("AvatarVertexProgram");
// Avatar Render Mode
LLCheckBoxCtrl* ctrl_avatar_cloth = getChild<LLCheckBoxCtrl>("AvatarCloth");
S32 max_avatar_shader = LLViewerShaderMgr::instance()->mMaxAvatarShaderLevel;
ctrl_avatar_vp->setEnabled((max_avatar_shader > 0) ? TRUE : FALSE);
if (gSavedSettings.getBOOL("VertexShaderEnable") == FALSE ||
gSavedSettings.getBOOL("RenderAvatarVP") == FALSE)
{
ctrl_avatar_cloth->setEnabled(false);
}
else
{
ctrl_avatar_cloth->setEnabled(true);
}
// Vertex Shaders
// Global Shader Enable
LLCheckBoxCtrl* ctrl_shader_enable = getChild<LLCheckBoxCtrl>("BasicShaders");
// radio set for terrain detail mode
LLRadioGroup* mRadioTerrainDetail = getChild<LLRadioGroup>("TerrainDetailRadio"); // can be linked with control var
ctrl_shader_enable->setEnabled(LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable"));
BOOL shaders = ctrl_shader_enable->get();
if (shaders)
{
mRadioTerrainDetail->setValue(1);
mRadioTerrainDetail->setEnabled(FALSE);
}
else
{
mRadioTerrainDetail->setEnabled(TRUE);
}
// WindLight
LLCheckBoxCtrl* ctrl_wind_light = getChild<LLCheckBoxCtrl>("WindLightUseAtmosShaders");
// *HACK just checks to see if we can use shaders...
// maybe some cards that use shaders, but don't support windlight
ctrl_wind_light->setEnabled(ctrl_shader_enable->getEnabled() && shaders);
// now turn off any features that are unavailable
disableUnavailableSettings();
}
BOOL LLPreviewGesture::postBuild()
{
LLLineEditor* edit;
LLComboBox* combo;
LLButton* btn;
LLScrollListCtrl* list;
LLTextBox* text;
LLCheckBoxCtrl* check;
edit = LLViewerUICtrlFactory::getLineEditorByName(this, "trigger_editor");
edit->setKeystrokeCallback(onKeystrokeCommit);
edit->setCommitCallback(onCommitSetDirty);
edit->setCommitOnFocusLost(TRUE);
edit->setCallbackUserData(this);
edit->setIgnoreTab(TRUE);
mTriggerEditor = edit;
text = LLViewerUICtrlFactory::getTextBoxByName(this, "replace_text");
text->setEnabled(FALSE);
mReplaceText = text;
edit = LLViewerUICtrlFactory::getLineEditorByName(this, "replace_editor");
edit->setEnabled(FALSE);
edit->setKeystrokeCallback(onKeystrokeCommit);
edit->setCommitCallback(onCommitSetDirty);
edit->setCommitOnFocusLost(TRUE);
edit->setCallbackUserData(this);
edit->setIgnoreTab(TRUE);
mReplaceEditor = edit;
combo = LLViewerUICtrlFactory::getComboBoxByName(this, "modifier_combo");
combo->setCommitCallback(onCommitSetDirty);
combo->setCallbackUserData(this);
mModifierCombo = combo;
combo = LLViewerUICtrlFactory::getComboBoxByName(this, "key_combo");
combo->setCommitCallback(onCommitSetDirty);
combo->setCallbackUserData(this);
mKeyCombo = combo;
list = LLViewerUICtrlFactory::getScrollListByName(this, "library_list");
list->setCommitCallback(onCommitLibrary);
list->setDoubleClickCallback(onClickAdd);
list->setCallbackUserData(this);
mLibraryList = list;
btn = LLViewerUICtrlFactory::getButtonByName(this, "add_btn");
btn->setClickedCallback(onClickAdd);
btn->setCallbackUserData(this);
btn->setEnabled(FALSE);
mAddBtn = btn;
btn = LLViewerUICtrlFactory::getButtonByName(this, "up_btn");
btn->setClickedCallback(onClickUp);
btn->setCallbackUserData(this);
btn->setEnabled(FALSE);
mUpBtn = btn;
btn = LLViewerUICtrlFactory::getButtonByName(this, "down_btn");
btn->setClickedCallback(onClickDown);
btn->setCallbackUserData(this);
btn->setEnabled(FALSE);
mDownBtn = btn;
btn = LLViewerUICtrlFactory::getButtonByName(this, "delete_btn");
btn->setClickedCallback(onClickDelete);
btn->setCallbackUserData(this);
btn->setEnabled(FALSE);
mDeleteBtn = btn;
list = LLViewerUICtrlFactory::getScrollListByName(this, "step_list");
list->setCommitCallback(onCommitStep);
list->setCallbackUserData(this);
mStepList = list;
// Options
text = LLViewerUICtrlFactory::getTextBoxByName(this, "options_text");
text->setBorderVisible(TRUE);
mOptionsText = text;
combo = LLViewerUICtrlFactory::getComboBoxByName(this, "animation_list");
combo->setVisible(FALSE);
combo->setCommitCallback(onCommitAnimation);
combo->setCallbackUserData(this);
mAnimationCombo = combo;
LLRadioGroup* group;
group = LLViewerUICtrlFactory::getRadioGroupByName(this, "animation_trigger_type");
group->setVisible(FALSE);
group->setCommitCallback(onCommitAnimationTrigger);
group->setCallbackUserData(this);
mAnimationRadio = group;
combo = LLViewerUICtrlFactory::getComboBoxByName(this, "sound_list");
combo->setVisible(FALSE);
combo->setCommitCallback(onCommitSound);
combo->setCallbackUserData(this);
mSoundCombo = combo;
edit = LLViewerUICtrlFactory::getLineEditorByName(this, "chat_editor");
edit->setVisible(FALSE);
edit->setCommitCallback(onCommitChat);
//edit->setKeystrokeCallback(onKeystrokeCommit);
edit->setCommitOnFocusLost(TRUE);
edit->setCallbackUserData(this);
edit->setIgnoreTab(TRUE);
mChatEditor = edit;
check = LLViewerUICtrlFactory::getCheckBoxByName(this, "wait_anim_check");
check->setVisible(FALSE);
check->setCommitCallback(onCommitWait);
check->setCallbackUserData(this);
mWaitAnimCheck = check;
check = LLViewerUICtrlFactory::getCheckBoxByName(this, "wait_time_check");
check->setVisible(FALSE);
check->setCommitCallback(onCommitWait);
check->setCallbackUserData(this);
mWaitTimeCheck = check;
edit = LLViewerUICtrlFactory::getLineEditorByName(this, "wait_time_editor");
edit->setEnabled(FALSE);
edit->setVisible(FALSE);
edit->setPrevalidate(LLLineEditor::prevalidateFloat);
// edit->setKeystrokeCallback(onKeystrokeCommit);
edit->setCommitOnFocusLost(TRUE);
edit->setCommitCallback(onCommitWaitTime);
edit->setCallbackUserData(this);
edit->setIgnoreTab(TRUE);
mWaitTimeEditor = edit;
// Buttons at the bottom
check = LLViewerUICtrlFactory::getCheckBoxByName(this, "active_check");
check->setCommitCallback(onCommitActive);
check->setCallbackUserData(this);
mActiveCheck = check;
btn = LLViewerUICtrlFactory::getButtonByName(this, "save_btn");
btn->setClickedCallback(onClickSave);
btn->setCallbackUserData(this);
mSaveBtn = btn;
btn = LLViewerUICtrlFactory::getButtonByName(this, "preview_btn");
btn->setClickedCallback(onClickPreview);
btn->setCallbackUserData(this);
mPreviewBtn = btn;
// Populate the comboboxes
addModifiers();
addKeys();
addAnimations();
addSounds();
const LLInventoryItem* item = getItem();
if (item)
{
childSetCommitCallback("desc", LLPreview::onText, this);
childSetText("desc", item->getDescription());
childSetPrevalidate("desc", &LLLineEditor::prevalidatePrintableNotPipe);
}
return TRUE;
}
LLFloaterTestImpl::LLFloaterTestImpl()
: LLFloater(std::string("test"), LLRect(0, 500, 700, 0), std::string("Test UI"))
{
const S32 HPAD = 5;
const S32 VPAD = 5;
const S32 LEFT = HPAD;
const S32 RIGHT = getRect().getWidth() - HPAD;
const S32 TOP = getRect().getHeight() - LLFLOATER_HEADER_SIZE - VPAD;
const S32 BOTTOM = VPAD;
const S32 LINE = 15;
//S32 x = LEFT;
S32 y = TOP;
LLTextBox* text = NULL;
LLButton* btn = NULL;
LLTabContainer* tab = NULL;
LLPanel* panel = NULL;
LLCheckBoxCtrl* check = NULL;
LLComboBox* combo = NULL;
btn = new LLButton(std::string("can't click"),
LLRect(LEFT+150, y, LEFT+150+100, y-LINE),
LLStringUtil::null,
boost::bind(&LLFloaterTestImpl::onClickButton));
btn->setFollows(FOLLOWS_LEFT|FOLLOWS_TOP);
btn->setFont(LLFontGL::getFontSansSerifSmall());
addChild(btn);
text = new LLTextBox(std::string("simple_text"),
std::string("simple sans-serif text that is mouse opaque opaque opaque"),
50, // max_width
LLFontGL::getFontSansSerifSmall(),
TRUE); // mouse_opaque
text->setClickedCallback(boost::bind(&onClickText));
text->setRect(LLRect(LEFT, y, RIGHT, y-LINE));
addChild(text);
y -= VPAD + LINE;
btn = new LLButton(std::string("can click"),
LLRect(LEFT+150, y, LEFT+150+100, y-LINE),
LLStringUtil::null,
boost::bind(&LLFloaterTestImpl::onClickButton));
btn->setFollows(FOLLOWS_LEFT|FOLLOWS_TOP);
btn->setFont(LLFontGL::getFontSansSerifSmall());
addChild(btn);
text = new LLTextBox(std::string("simple2_text"),
LLRect(LEFT, y, RIGHT, y-LINE),
std::string("monospaced, non-opaque text with tooltip, non-opaque non-opaque"),
LLFontGL::getFontMonospace(),
FALSE); // mouse_opaque
text->setToolTip(std::string("I'm a tooltip"));
addChild(text);
y -= VPAD + LINE;
tab = new LLTabContainer(std::string("test_tab"),
LLRect(LEFT, y, RIGHT, BOTTOM),
LLTabContainer::TOP,
TRUE, // bordered
FALSE); // horizontal
addChild(tab);
mTab = tab;
tab->setCommitCallback(boost::bind(&LLFloaterTestImpl::onClickTab));
//-----------------------------------------------------------------------
// First tab container panel
//-----------------------------------------------------------------------
panel = new LLPanel(std::string("first_tab_panel"),
LLRect(0, 400, 400, 0), // dummy rect
TRUE); // bordered
tab->addTabPanel(panel, std::string("First"),
TRUE); // select
y = panel->getRect().getHeight() - VPAD;
text = new LLTextBox(std::string("unicode_text"),
LLRect(LEFT, y, RIGHT, y-LINE),
std::string("File"),
LLFontGL::getFontSansSerif(),
TRUE); // mouse_opaque
text->setToolTip(std::string("This should be Unicode text"));
panel->addChild(text);
y -= VPAD + LINE;
btn = new LLButton(std::string("unicode_btn"), LLRect(LEFT, y, LEFT+100, y-20));
btn->setLabel(std::string("unicode"));
panel->addChild(btn);
y -= VPAD + 20;
btn = new LLButton(std::string("image_btn"),
LLRect(LEFT, y, LEFT+32, y-32),
std::string("tool_zoom.tga"),
std::string("tool_zoom_active.tga"),
LLStringUtil::null,
boost::bind(&LLFloaterTestImpl::onClickButton),
LLFontGL::getFontSansSerifSmall());
btn->setFollows(FOLLOWS_LEFT | FOLLOWS_TOP);
panel->addChild(btn);
y -= VPAD + 32;
check = new LLCheckBoxCtrl(std::string("simple_check"),
LLRect(LEFT, y, LEFT+150, y-LLCHECKBOXCTRL_HEIGHT),
std::string("Simple Checkbox"),
LLFontGL::getFontSansSerifSmall(),
boost::bind(&LLFloaterTestImpl::onCommitCheck),
TRUE, // initial_value
FALSE, // radio_style
std::string("UIFloaterTestBool")); // control_which
panel->addChild(check);
y -= VPAD + LLCHECKBOXCTRL_HEIGHT;
check = new LLCheckBoxCtrl(std::string("unicode_check"),
LLRect(LEFT, y, LEFT+150, y-LLCHECKBOXCTRL_HEIGHT),
std::string("TODO: Unicode Checkbox"),
LLFontGL::getFontSansSerifSmall(),
boost::bind(&LLFloaterTestImpl::onCommitCheck),
TRUE, // initial_value
FALSE, // radio_style
LLStringUtil::null); // control_which
panel->addChild(check);
mCheckUnicode = check;
y -= VPAD + LLCHECKBOXCTRL_HEIGHT;
combo = new LLComboBox(std::string("combo"),
LLRect(LEFT, y, LEFT+100, y-LLCOMBOBOX_HEIGHT),
std::string("Combobox Label"),
boost::bind(&LLFloaterTestImpl::onCommitCombo, _1,_2) );
combo->add(std::string("first item"));
combo->add(std::string("second item"));
combo->add(std::string("should go to the top"), ADD_TOP);
combo->add(std::string("disabled item"), NULL, ADD_BOTTOM, FALSE);
panel->addChild(combo);
y -= VPAD + LLCOMBOBOX_HEIGHT;
LLIconCtrl* icon = new LLIconCtrl(
std::string("test_icon"),
LLRect(LEFT, y, LEFT+32, y-32),
std::string("object_cone.tga") );
panel->addChild(icon);
mIcon = icon;
y -= VPAD + 32;
LLLineEditor* line = new LLLineEditor(
std::string("test_line"),
LLRect(LEFT, y, LEFT+200, y-20),
std::string("test some unicode text here"),
LLFontGL::getFontSansSerif(),
200, // max_length_bytes
boost::bind(&LLFloaterTestImpl::onCommitLine),
boost::bind(&LLFloaterTestImpl::onKeyLine),
boost::bind(&LLFloaterTestImpl::onFocusLostLine));
line->setHandleEditKeysDirectly(true);
panel->addChild(line);
y -= VPAD + 20;
LLRadioGroup* group = new LLRadioGroup(
std::string("radio_group"),
LLRect(LEFT, y, LEFT+200, y - 50),
0, // initial_index
boost::bind(&LLFloaterTestImpl::onChangeRadioGroup),
TRUE); // border
panel->addChild(group);
S32 yy = 100;
group->addRadioButton(std::string("Radio1"), std::string("Radio 1"), LLRect(0, yy, 200, yy-LINE), LLFontGL::getFontSansSerifSmall());
yy -= LINE;
group->addRadioButton(std::string("Radio2"), std::string("Radio 2"), LLRect(0, yy, 200, yy-LINE), LLFontGL::getFontSansSerifSmall());
yy -= LINE;
group->addRadioButton(std::string("Radio3"), std::string("Radio 3"), LLRect(0, yy, 200, yy-LINE), LLFontGL::getFontSansSerifSmall());
yy -= LINE;
//-----------------------------------------------------------------------
// Second tab container panel
//-----------------------------------------------------------------------
panel = new LLPanel(std::string("second_tab_panel"),
LLRect(0, 400, 400, 0), // dummy rect
TRUE); // bordered
tab->addTabPanel(panel, std::string("Second"),
FALSE); // select
y = panel->getRect().getHeight() - VPAD;
btn = new LLButton(std::string("Simple Button"),
LLRect(LEFT, y, LEFT+100, y - 20),
LLStringUtil::null,
boost::bind(&LLFloaterTestImpl::onClickButton));
btn->setFollows(FOLLOWS_TOP|FOLLOWS_LEFT);
panel->addChild(btn);
mBtnSimple = btn;
//-----------------------------------------------------------------------
// Hook us up with the floater view
//-----------------------------------------------------------------------
open(); /* Flawfinder: ignore */
center();
}
