void LLFloaterRegionDebugConsole::onInput(LLUICtrl* ctrl, void* userdata)
{
LLFloaterRegionDebugConsole* panel = (LLFloaterRegionDebugConsole*)userdata;
if(panel)
{
LLLineEditor* input = static_cast<LLLineEditor*>(ctrl);
std::string text = input->getText() + "\n";
std::string url = gAgent.getRegion()->getCapability("SimConsoleAsync");
if (url.empty())
{
text += CONSOLE_UNAVAILABLE + PROMPT;
}
else
{
// Using SimConsoleAsync
LLHTTPClient::post(
url,
LLSD(input->getText()),
new AsyncConsoleResponder);
}
panel->mOutput->appendText(text, false, false);
input->clear();
}
}
void LLFloaterRegionDebugConsole::onInput(LLUICtrl* ctrl, const LLSD& param)
{
LLLineEditor* input = static_cast<LLLineEditor*>(ctrl);
std::string text = input->getText() + "\n";
std::string url = gAgent.getRegion()->getCapability("SimConsoleAsync");
if (url.empty())
{
// Fall back to the old API
url = gAgent.getRegion()->getCapability("SimConsole");
if (url.empty())
{
text += CONSOLE_UNAVAILABLE + PROMPT;
}
else
{
// Using SimConsole (deprecated)
LLHTTPClient::post(
url,
LLSD(input->getText()),
new ConsoleResponder(mOutput));
}
}
else
{
// Using SimConsoleAsync
LLHTTPClient::post(
url,
LLSD(input->getText()),
new AsyncConsoleResponder);
}
mOutput->appendText(text, false, false);
input->clear();
}
// static
void LLFloaterProperties::onCommitName()
{
//llinfos << "LLFloaterProperties::onCommitName()" << llendl;
LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem();
if(!item)
{
return;
}
LLLineEditor* labelItemName = getChild<LLLineEditor>("LabelItemName");
if(labelItemName&&
(item->getName() != labelItemName->getText()) &&
(gAgent.allowOperation(PERM_MODIFY, item->getPermissions(), GP_OBJECT_MANIPULATE)) )
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
new_item->rename(labelItemName->getText());
if(mObjectID.isNull())
{
new_item->updateServer(FALSE);
gInventory.updateItem(new_item);
gInventory.notifyObservers();
}
else
{
LLViewerObject* object = gObjectList.findObject(mObjectID);
if(object)
{
object->updateInventory(
new_item,
TASK_INVENTORY_ITEM_KEY,
false);
}
}
}
}
void LLFloaterLuaConsole::onClickSend(void *data)
{
LLFloaterLuaConsole *self = (LLFloaterLuaConsole *)data;
LLLineEditor *editor = self->getChild<LLLineEditor>("Lua Editor", TRUE);
if(editor->getLength())
{
LLColor4 text_color = gSavedSettings.getColor4("llOwnerSayChatColor");
LLViewerTextEditor *out = self->getChild<LLViewerTextEditor>("Lua Output Editor");
out->appendColoredText("] "+editor->getText(), false, true, text_color); //echo command, like a proper console.
FLLua::callCommand(editor->getText());
editor->updateHistory();
editor->clear();
}
}
void LLFloaterPathfindingLinksets::onWalkabilityCoefficientEntered(LLUICtrl *pUICtrl, LLSD &pPreviousValue)
{
LLLineEditor *pLineEditor = static_cast<LLLineEditor *>(pUICtrl);
llassert(pLineEditor != NULL);
const std::string &valueString = pLineEditor->getText();
S32 intValue;
LLSD value;
bool doResetValue = false;
if (valueString.empty())
{
value = pPreviousValue;
doResetValue = true;
}
else if (LLStringUtil::convertToS32(valueString, intValue))
{
doResetValue = ((intValue < LLPathfindingLinkset::MIN_WALKABILITY_VALUE) || (intValue > LLPathfindingLinkset::MAX_WALKABILITY_VALUE));
value = LLSD(llclamp(intValue, LLPathfindingLinkset::MIN_WALKABILITY_VALUE, LLPathfindingLinkset::MAX_WALKABILITY_VALUE));
}
else
{
value = LLSD(LLPathfindingLinkset::MAX_WALKABILITY_VALUE);
doResetValue = true;
}
if (doResetValue)
{
pLineEditor->setValue(value);
}
pPreviousValue = value;
}
// static
void LLPanelPermissions::onCommitDesc(LLUICtrl*, void* data)
{
//llinfos << "LLPanelPermissions::onCommitDesc()" << llendl;
LLPanelPermissions* self = (LLPanelPermissions*)data;
LLLineEditor* le = self->getChild<LLLineEditor>("Object Description");
if(le)
{
LLSelectMgr::getInstance()->selectionSetObjectDescription(le->getText());
}
}
// static
void LLPanelPermissions::onCommitName(LLUICtrl*, void* data)
{
//llinfos << "LLPanelPermissions::onCommitName()" << llendl;
LLPanelPermissions* self = (LLPanelPermissions*)data;
LLLineEditor* tb = self->getChild<LLLineEditor>("Object Name");
if(tb)
{
LLSelectMgr::getInstance()->selectionSetObjectName(tb->getText());
// LLSelectMgr::getInstance()->selectionSetObjectName(self->mLabelObjectName->getText());
}
}
////////////////////////////////////////////////////////////////////////////////
// static
void LLFloaterHtml::onCommitUrlEdit(LLUICtrl* ctrl, void* user_data)
{
LLFloaterHtml* self = (LLFloaterHtml*)user_data;
LLLineEditor* editor = (LLLineEditor*)ctrl;
std::string url = editor->getText();
if ( self->mWebBrowser )
{
self->mWebBrowser->navigateTo( url );
};
}
// static
void LLFloaterProperties::onCommitDescription(LLUICtrl* ctrl, void* data)
{
//llinfos << "LLFloaterProperties::onCommitDescription()" << llendl;
LLFloaterProperties* self = (LLFloaterProperties*)data;
if(!self) return;
LLViewerInventoryItem* item = (LLViewerInventoryItem*)self->findItem();
if(!item) return;
LLLineEditor* labelItemDesc = self->getChild<LLLineEditor>("LabelItemDesc");
if(!labelItemDesc)
{
return;
}
if((item->getDescription() != labelItemDesc->getText()) &&
(gAgent.allowOperation(PERM_MODIFY, item->getPermissions(), GP_OBJECT_MANIPULATE)))
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
new_item->setDescription(labelItemDesc->getText());
if(self->mObjectID.isNull())
{
new_item->updateServer(FALSE);
gInventory.updateItem(new_item);
gInventory.notifyObservers();
}
else
{
LLViewerObject* object = gObjectList.findObject(self->mObjectID);
if(object)
{
object->updateInventory(
new_item,
TASK_INVENTORY_ITEM_KEY,
false);
}
}
}
}
// static
void LLFloaterEditUI::onCommitLabel(LLUICtrl* ctrl, void* data)
{
LLView* view = LLView::sEditingUIView;
if (!view) return;
LLLineEditor* line = (LLLineEditor*)ctrl;
const std::string& text = line->getText();
LLButton* btn = dynamic_cast<LLButton*>(view);
if (btn)
{
btn->setLabelUnselected(text);
btn->setLabelSelected(text);
}
}
void LLPanelLogin::mungePassword(LLUICtrl* caller, void* user_data)
{
LLPanelLogin* self = (LLPanelLogin*)user_data;
LLLineEditor* editor = (LLLineEditor*)caller;
std::string password = editor->getText();
// Re-md5 if we've changed at all
if (password != self->mIncomingPassword)
{
LLMD5 pass((unsigned char *)password.c_str());
char munged_password[MD5HEX_STR_SIZE];
pass.hex_digest(munged_password);
self->mMungedPassword = munged_password;
}
}
void LLPanelGroupLandMoney::impl::contributionCommitCallback(LLUICtrl* ctrl,
void* userdata)
{
LLPanelGroupLandMoney* tabp = (LLPanelGroupLandMoney*) userdata;
LLLineEditor* editorp = (LLLineEditor*) ctrl;
if ( tabp && editorp )
{
impl* self = tabp->mImplementationp;
int your_contribution = 0;
int new_contribution = 0;
new_contribution= atoi(editorp->getText().c_str());
your_contribution = self->getStoredContribution();
//reset their junk data to be "good" data to us
self->setYourContributionTextField(new_contribution);
//check to see if they're contribution text has changed
self->mNeedsApply = new_contribution != your_contribution;
tabp->notifyObservers();
}
}
void LLPreviewGesture::saveIfNeeded()
{
if (!gAssetStorage)
{
llwarns << "Can't save gesture, no asset storage system." << llendl;
return;
}
if (!mDirty)
{
return;
}
// Copy the UI into a gesture
LLMultiGesture* gesture = createGesture();
// Serialize the gesture
S32 max_size = gesture->getMaxSerialSize();
char* buffer = new char[max_size];
LLDataPackerAsciiBuffer dp(buffer, max_size);
BOOL ok = gesture->serialize(dp);
if (dp.getCurrentSize() > 1000)
{
gViewerWindow->alertXml("GestureSaveFailedTooManySteps");
delete gesture;
gesture = NULL;
}
else if (!ok)
{
gViewerWindow->alertXml("GestureSaveFailedTryAgain");
delete gesture;
gesture = NULL;
}
else
{
// Every save gets a new UUID. Yup.
LLTransactionID tid;
LLAssetID asset_id;
tid.generate();
asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
LLVFile file(gVFS, asset_id, LLAssetType::AT_GESTURE, LLVFile::APPEND);
S32 size = dp.getCurrentSize();
file.setMaxSize(size);
file.write((U8*)buffer, size);
// Upload that asset to the database
const LLInventoryItem* item = getItem();
if (item)
{
std::string agent_url = gAgent.getRegion()->getCapability("UpdateGestureAgentInventory");
std::string task_url = gAgent.getRegion()->getCapability("UpdateGestureTaskInventory");
if (mObjectUUID.isNull() && !agent_url.empty())
{
// Saving into agent inventory
LLSD body;
body["item_id"] = mItemUUID;
LLHTTPClient::post(agent_url, body,
new LLUpdateAgentInventoryResponder(body, asset_id, LLAssetType::AT_GESTURE));
}
else if (!mObjectUUID.isNull() && !task_url.empty())
{
// Saving into task inventory
LLSD body;
body["task_id"] = mObjectUUID;
body["item_id"] = mItemUUID;
LLHTTPClient::post(task_url, body,
new LLUpdateTaskInventoryResponder(body, asset_id, LLAssetType::AT_GESTURE));
}
else if (gAssetStorage)
{
LLLineEditor* descEditor = LLUICtrlFactory::getLineEditorByName(this, "desc");
LLSaveInfo* info = new LLSaveInfo(mItemUUID, mObjectUUID, descEditor->getText(), tid);
gAssetStorage->storeAssetData(tid, LLAssetType::AT_GESTURE, onSaveComplete, info, FALSE);
}
}
// If this gesture is active, then we need to update the in-memory
// active map with the new pointer.
if (gGestureManager.isGestureActive(mItemUUID))
{
// gesture manager now owns the pointer
gGestureManager.replaceGesture(mItemUUID, gesture, asset_id);
// replaceGesture may deactivate other gestures so let the
// inventory know.
gInventory.notifyObservers();
}
else
{
// we're done with this gesture
delete gesture;
gesture = NULL;
}
mDirty = FALSE;
refresh();
}
delete [] buffer;
buffer = NULL;
}
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 LLPreviewGesture::saveIfNeeded()
{
if (!gAssetStorage)
{
llwarns << "Can't save gesture, no asset storage system." << llendl;
return;
}
if (!mDirty)
{
return;
}
// Copy the UI into a gesture
LLMultiGesture* gesture = createGesture();
// Serialize the gesture
S32 max_size = gesture->getMaxSerialSize();
char* buffer = new char[max_size];
LLDataPackerAsciiBuffer dp(buffer, max_size);
BOOL ok = gesture->serialize(dp);
// <edit>
//if (dp.getCurrentSize() > 1000)
if(0)
// </edit>
{
LLNotificationsUtil::add("GestureSaveFailedTooManySteps");
delete gesture;
gesture = NULL;
}
else if (!ok)
{
LLNotificationsUtil::add("GestureSaveFailedTryAgain");
delete gesture;
gesture = NULL;
}
else
{
// Every save gets a new UUID. Yup.
LLTransactionID tid;
LLAssetID asset_id;
tid.generate();
asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
LLVFile file(gVFS, asset_id, LLAssetType::AT_GESTURE, LLVFile::APPEND);
S32 size = dp.getCurrentSize();
file.setMaxSize(size);
file.write((U8*)buffer, size);
BOOL delayedUpload = FALSE;
// Upload that asset to the database
LLViewerInventoryItem* item = (LLViewerInventoryItem*) getItem();
if (item)
{
std::string agent_url = gAgent.getRegion()->getCapability("UpdateGestureAgentInventory");
std::string task_url = gAgent.getRegion()->getCapability("UpdateGestureTaskInventory");
if (mObjectUUID.isNull() && !agent_url.empty())
{
//need to disable the preview floater so item
//isn't re-saved before new asset arrives
//fake out refresh.
item->setComplete(FALSE);
refresh();
item->setComplete(TRUE);
// Saving into agent inventory
LLSD body;
body["item_id"] = mItemUUID;
LLHTTPClient::post(agent_url, body,
new LLUpdateAgentInventoryResponder(body, asset_id, LLAssetType::AT_GESTURE));
delayedUpload = TRUE;
}
else if (!mObjectUUID.isNull() && !task_url.empty())
{
// Saving into task inventory
LLSD body;
body["task_id"] = mObjectUUID;
body["item_id"] = mItemUUID;
LLHTTPClient::post(task_url, body,
new LLUpdateTaskInventoryResponder(body, asset_id, LLAssetType::AT_GESTURE));
}
else if (gAssetStorage)
{
LLLineEditor* descEditor = getChild<LLLineEditor>("desc");
LLSaveInfo* info = new LLSaveInfo(mItemUUID, mObjectUUID, descEditor->getText(), tid);
gAssetStorage->storeAssetData(tid, LLAssetType::AT_GESTURE, onSaveComplete, info, FALSE);
}
}
// If this gesture is active, then we need to update the in-memory
// active map with the new pointer.
if (!delayedUpload && LLGestureMgr::instance().isGestureActive(mItemUUID))
{
// gesture manager now owns the pointer
LLGestureMgr::instance().replaceGesture(mItemUUID, gesture, asset_id);
// replaceGesture may deactivate other gestures so let the
// inventory know.
gInventory.notifyObservers();
}
else
{
// we're done with this gesture
delete gesture;
gesture = NULL;
}
mDirty = FALSE;
// refresh will be called when callback
// if triggered when delayedUpload
if(!delayedUpload)
{
refresh();
}
}
delete [] buffer;
buffer = NULL;
}
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))
{
childSetValue("CheckPurchase",LLSD((BOOL)FALSE));
}
if((BOOL)childGetValue("CheckPurchase"))
{
// 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;
}
LLLineEditor* EditPrice = getChild<LLLineEditor>("EditPrice");
S32 price = -1;
if(EditPrice)
{
price = atoi(EditPrice->getText().c_str());
}
// 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->isComplete())
{
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 |= LLInventoryItem::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();
}
}
