void LLCOFWearables::populateClothingList(LLAppearanceMgr::wearables_by_type_t& clothing_by_type)
{
llassert(clothing_by_type.size() == LLWearableType::WT_COUNT);
for (U32 type = LLWearableType::WT_SHIRT; type < LLWearableType::WT_COUNT; ++type)
{
U32 size = clothing_by_type[type].size();
if (!size) continue;
LLAppearanceMgr::sortItemsByActualDescription(clothing_by_type[type]);
//clothing items are displayed in reverse order, from furthest ones to closest ones (relatively to the body)
for (U32 i = size; i != 0; --i)
{
LLViewerInventoryItem* item = clothing_by_type[type][i-1];
LLPanelClothingListItem* item_panel = buildClothingListItem(item, i == size, i == 1);
if (!item_panel) continue;
mClothing->addItem(item_panel, item->getUUID(), ADD_BOTTOM, false);
}
}
addClothingTypesDummies(clothing_by_type);
mClothing->notify(REARRANGE);
}
void LLPanelTopInfoBar::onContextMenuItemClicked(const LLSD::String& item)
{
if (item == "landmark")
{
LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
if(landmark == NULL)
{
LLSideTray::getInstance()->showPanel("panel_places", LLSD().with("type", "create_landmark"));
}
else
{
LLSideTray::getInstance()->showPanel("panel_places",
LLSD().with("type", "landmark").with("id",landmark->getUUID()));
}
}
else if (item == "copy")
{
LLSLURL slurl;
LLAgentUI::buildSLURL(slurl, false);
LLUIString location_str(slurl.getSLURLString());
gClipboard.copyFromString(location_str);
}
}
void LLTracker::setLandmarkVisited()
{
// poke the inventory item
if (!mTrackedLandmarkItemID.isNull())
{
LLInventoryItem* i = gInventory.getItem( mTrackedLandmarkItemID );
LLViewerInventoryItem* item = (LLViewerInventoryItem*)i;
if ( item
&& !(item->getFlags()&LLInventoryItem::II_FLAGS_LANDMARK_VISITED))
{
U32 flags = item->getFlags();
flags |= LLInventoryItem::II_FLAGS_LANDMARK_VISITED;
item->setFlags(flags);
LLMessageSystem* msg = gMessageSystem;
msg->newMessage("ChangeInventoryItemFlags");
msg->nextBlock("AgentData");
msg->addUUID("AgentID", gAgent.getID());
msg->addUUID("SessionID", gAgent.getSessionID());
msg->nextBlock("InventoryData");
msg->addUUID("ItemID", mTrackedLandmarkItemID);
msg->addU32("Flags", flags);
gAgent.sendReliableMessage();
LLInventoryModel::LLCategoryUpdate up(item->getParentUUID(), 0);
gInventory.accountForUpdate(up);
// need to communicate that the icon needs to change...
gInventory.addChangedMask(LLInventoryObserver::INTERNAL, item->getUUID());
gInventory.notifyObservers();
}
}
}
void LLLocationInputCtrl::onAddLandmarkButtonClicked()
{
LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
// Landmark exists, open it for preview and edit
if(landmark && landmark->getUUID().notNull())
{
LLSD key;
key["type"] = "landmark";
key["id"] = landmark->getUUID();
LLSideTray::getInstance()->showPanel("panel_places", key);
}
else
{
LLSideTray::getInstance()->showPanel("panel_places", LLSD().with("type", "create_landmark"));
}
}
void LLLocationInputCtrl::onAddLandmarkButtonClicked()
{
// [RLVa:KB] - Checked: 2010-04-05 (RLVa-1.4.5) | Added: RLVa-1.2.0
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
return;
// [/RLVa:KB]
LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
// Landmark exists, open it for preview and edit
if(landmark && landmark->getUUID().notNull())
{
LLSD key;
key["type"] = "landmark";
key["id"] = landmark->getUUID();
// <FS:Ansariel> FIRE-817: Separate place details floater
//LLFloaterSidePanelContainer::showPanel("places", key);
if (gSavedSettings.getBOOL("FSUseStandalonePlaceDetailsFloater"))
{
LLFloaterReg::showInstance("fs_placedetails", key);
}
else
{
LLFloaterSidePanelContainer::showPanel("places", key);
}
// </FS:Ansariel>
}
else
{
// <FS:Ansariel> FIRE-817: Separate place details floater
//LLFloaterSidePanelContainer::showPanel("places", LLSD().with("type", "create_landmark"));
if (gSavedSettings.getBOOL("FSUseStandalonePlaceDetailsFloater"))
{
LLFloaterReg::showInstance("fs_placedetails", LLSD().with("type", "create_landmark"));
}
else
{
LLFloaterSidePanelContainer::showPanel("places", LLSD().with("type", "create_landmark"));
}
// </FS:Ansariel>
}
}
//
//Bridge initialization
//
void FSLSLBridge :: recreateBridge()
{
if (!gSavedSettings.getBOOL("UseLSLBridge"))
return;
LLUUID catID = findFSCategory();
LLViewerInventoryItem* fsBridge = findInvObject(mCurrentFullName, catID, LLAssetType::AT_OBJECT);
if (fsBridge != NULL)
{
if (get_is_item_worn(fsBridge->getUUID()))
{
LLVOAvatarSelf::detachAttachmentIntoInventory(fsBridge->getUUID());
}
}
if (mpBridge != NULL)
mpBridge = NULL; //the object itself will get cleaned up when new one is created.
initCreationStep();
}
void LLCOFWearables::populateAttachmentsAndBodypartsLists(const LLInventoryModel::item_array_t& cof_items)
{
for (U32 i = 0; i < cof_items.size(); ++i)
{
LLViewerInventoryItem* item = cof_items.get(i);
if (!item) continue;
const LLAssetType::EType item_type = item->getType();
if (item_type == LLAssetType::AT_CLOTHING) continue;
LLPanelInventoryListItemBase* item_panel = NULL;
if (item_type == LLAssetType::AT_OBJECT)
{
item_panel = buildAttachemntListItem(item);
mAttachments->addItem(item_panel, item->getUUID(), ADD_BOTTOM, false);
}
else if (item_type == LLAssetType::AT_BODYPART)
{
item_panel = buildBodypartListItem(item);
if (!item_panel) continue;
mBodyParts->addItem(item_panel, item->getUUID(), ADD_BOTTOM, false);
}
}
if (mAttachments->size())
{
mAttachments->sort();
mAttachments->notify(REARRANGE); //notifying the parent about the list's size change (cause items were added with rearrange=false)
}
else
{
mAttachments->setNoItemsCommentText(LLTrans::getString("no_attachments"));
}
if (mBodyParts->size())
{
mBodyParts->sort();
mBodyParts->notify(REARRANGE);
}
}
bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
{
LLInventoryPanel *panel = mPtr;
LLFolderView* folder = panel->getRootFolder();
if(!folder) return true;
std::set<LLUUID> selected_items;
folder->getSelectionList(selected_items);
LLUUID id = *selected_items.begin();
std::string joint_name = userdata.asString();
LLVOAvatar *avatarp = gAgent.getAvatarObject();
LLViewerJointAttachment* attachmentp = NULL;
for (LLVOAvatar::attachment_map_t::iterator iter = avatarp->mAttachmentPoints.begin();
iter != avatarp->mAttachmentPoints.end(); )
{
LLVOAvatar::attachment_map_t::iterator curiter = iter++;
LLViewerJointAttachment* attachment = curiter->second;
if (attachment->getName() == joint_name)
{
attachmentp = attachment;
break;
}
}
if (attachmentp == NULL)
{
return true;
}
LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(id);
if(item && gInventory.isObjectDescendentOf(id, gAgent.getInventoryRootID()))
{
rez_attachment(item, attachmentp);
}
else if(item && item->isComplete())
{
// must be in library. copy it to our inventory and put it on.
LLPointer<LLInventoryCallback> cb = new RezAttachmentCallback(attachmentp);
copy_inventory_item(
gAgent.getID(),
item->getPermissions().getOwner(),
item->getUUID(),
LLUUID::null,
std::string(),
cb);
}
gFocusMgr.setKeyboardFocus(NULL);
return true;
}
//
//Bridge initialization
//
void FSLSLBridge::recreateBridge()
{
if (!gSavedSettings.getBOOL("UseLSLBridge"))
{
return;
}
if (gSavedSettings.getBOOL("NoInventoryLibrary"))
{
llwarns << "Asked to create bridge, but we don't have a library. Aborting." << llendl;
reportToNearbyChat(LLTrans::getString("fsbridge_no_library"));
mBridgeCreating = false;
return;
}
if (mBridgeCreating)
{
llwarns << "Bridge creation already in progress, aborting new attempt." << llendl;
reportToNearbyChat(LLTrans::getString("fsbridge_already_creating"));
return;
}
LLUUID catID = findFSCategory();
LLViewerInventoryItem* fsBridge = findInvObject(mCurrentFullName, catID, LLAssetType::AT_OBJECT);
if (fsBridge != NULL)
{
if (get_is_item_worn(fsBridge->getUUID()))
{
LLVOAvatarSelf::detachAttachmentIntoInventory(fsBridge->getUUID());
}
}
// clear the stored bridge ID - we are starting over.
mpBridge = 0; //the object itself will get cleaned up when new one is created.
initCreationStep();
}
void LLLocationInputCtrl::onLocationContextMenuItemClicked(const LLSD& userdata)
{
std::string item = userdata.asString();
if (item == "show_coordinates")
{
gSavedSettings.setBOOL("NavBarShowCoordinates",!gSavedSettings.getBOOL("NavBarShowCoordinates"));
}
else if (item == "show_properties")
{
gSavedSettings.setBOOL("NavBarShowParcelProperties",
!gSavedSettings.getBOOL("NavBarShowParcelProperties"));
}
else if (item == "landmark")
{
LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
if(!landmark)
{
LLSideTray::getInstance()->showPanel("panel_places", LLSD().with("type", "create_landmark"));
}
else
{
LLSideTray::getInstance()->showPanel("panel_places",
LLSD().with("type", "landmark").with("id",landmark->getUUID()));
}
}
else if (item == "cut")
{
mTextEntry->cut();
}
else if (item == "copy")
{
mTextEntry->copy();
}
else if (item == "paste")
{
mTextEntry->paste();
}
else if (item == "delete")
{
mTextEntry->deleteSelection();
}
else if (item == "select_all")
{
mTextEntry->selectAll();
}
}
void FSLSLBridge :: createNewBridge()
{
//check if user has a bridge
LLUUID catID = findFSCategory();
//attach the Linden rock from the library (will resize as soon as attached)
LLUUID libID = gInventory.getLibraryRootFolderID();
LLViewerInventoryItem* libRock = findInvObject(LIB_ROCK_NAME, libID, LLAssetType::AT_OBJECT);
//shouldn't happen but just in case
if (libRock != NULL)
{
//copy the library item to inventory and put it on
LLPointer<LLInventoryCallback> cb = new FSLSLBridgeRezCallback();
copy_inventory_item(gAgent.getID(),libRock->getPermissions().getOwner(),libRock->getUUID(),catID,mCurrentFullName,cb);
}
}
void giveInventoryItem_Event(LLUUID &to_agent, LLUUID &item_id, LLUUID &im_session_id)
{
LLViewerInventoryItem *item = gInventory.getItem(item_id);
if(!item)
{
std::string dongs = llformat("Could not find item %s.",item_id.asString());
LuaError(dongs.c_str());
return;
}
std::string name;
gAgent.buildFullname(name);
LLUUID transaction_id;
transaction_id.generate();
const S32 BUCKET_SIZE = sizeof(U8) + UUID_BYTES;
U8 bucket[BUCKET_SIZE];
bucket[0] = (U8)item->getType();
memcpy(&bucket[1], &(item->getUUID().mData), UUID_BYTES); /* Flawfinder: ignore */
pack_instant_message(
gMessageSystem,
gAgent.getID(),
FALSE,
gAgent.getSessionID(),
to_agent,
name,
item->getName(),
IM_ONLINE,
IM_INVENTORY_OFFERED,
transaction_id,
0,
LLUUID::null,
gAgent.getPositionAgent(),
NO_TIMESTAMP,
bucket,
BUCKET_SIZE);
gAgent.sendReliableMessage();
// No VEffects.
gFloaterTools->dirty();
LLMuteList::getInstance()->autoRemove(to_agent, LLMuteList::AR_INVENTORY);
// If this item was given by drag-and-drop into an IM panel, log this action in the IM panel chat.
if (im_session_id != LLUUID::null)
{
LLSD args;
gIMMgr->addSystemMessage(im_session_id, "inventory_item_offered", args);
}
}
void FSLSLBridge :: processAttach(LLViewerObject *object, const LLViewerJointAttachment *attachment)
{
llinfos << "enter process attach, checking the rock" << llendl;
if ((mpBridge == NULL) || (!mBridgeCreating) || (!gAgentAvatarp->isSelf()))
return;
//if (attachment->getName() != "Bridge")
// return;
llinfos << "rock is attached, mpBridge not NULL, BridgeCreating true, avatar self" << llendl;
LLViewerInventoryItem *fsObject = gInventory.getItem(object->getAttachmentItemID());
if (fsObject->getUUID() != mpBridge->getUUID())
return;
llinfos << "rock is the same rock we saved, id matched" << llendl;
setupBridge(object);
}
// static
void LLWLParamManager::loadWindlightNotecard(LLVFS *vfs, const LLUUID& asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status)
{
LLUUID inventory_id(*((LLUUID*)user_data));
std::string name = "WindLight Setting.wl";
LLViewerInventoryItem *item = gInventory.getItem(inventory_id);
if(item)
{
inventory_id = item->getUUID();
name = item->getName();
}
if(LL_ERR_NOERR == status)
{
LLVFile file(vfs, asset_id, asset_type, LLVFile::READ);
S32 file_length = file.getSize();
std::vector<char> buffer(file_length + 1);
file.read((U8*)&buffer[0], file_length);
buffer[file_length] = 0;
LLNotecard notecard(LLNotecard::MAX_SIZE);
LLMemoryStream str((U8*)&buffer[0], file_length + 1);
notecard.importStream(str);
std::string settings = notecard.getText();
LLMemoryStream settings_str((U8*)settings.c_str(), settings.length());
bool is_animator_running = sInstance->mAnimator.mIsRunning;
bool animator_linden_time = sInstance->mAnimator.mUseLindenTime;
sInstance->mAnimator.mIsRunning = false;
sInstance->mAnimator.mUseLindenTime = false;
bool is_real_setting = sInstance->loadPresetXML(name, settings_str, true, true);
if(!is_real_setting)
{
sInstance->mAnimator.mIsRunning = is_animator_running;
sInstance->mAnimator.mUseLindenTime = animator_linden_time;
LLSD subs;
subs["NAME"] = name;
LLNotifications::getInstance()->add("KittyInvalidWindlightNotecard", subs);
}
else
{
// We can do this because we know mCurParams
sInstance->mParamList[name].mInventoryID = inventory_id;
}
}
}
void FSLSLBridge::detachOtherBridges()
{
LLUUID catID = findFSCategory();
LLViewerInventoryCategory::cat_array_t cats;
LLViewerInventoryItem::item_array_t items;
LLViewerInventoryItem* fsBridge = findInvObject(mCurrentFullName, catID, LLAssetType::AT_OBJECT);
//detach everything except current valid bridge - if any
gInventory.collectDescendents(catID,cats,items,FALSE);
for (S32 iIndex = 0; iIndex < items.count(); iIndex++)
{
const LLViewerInventoryItem* itemp = items.get(iIndex);
if (get_is_item_worn(itemp->getUUID()) &&
((fsBridge == NULL) || (itemp->getUUID() != fsBridge->getUUID())))
{
LLVOAvatarSelf::detachAttachmentIntoInventory(itemp->getUUID());
}
}
}
// static
void LLViewerAttachMenu::attachObjects(const uuid_vec_t& items, const std::string& joint_name)
{
LLViewerJointAttachment* attachmentp = NULL;
for (LLVOAvatar::attachment_map_t::iterator iter = gAgentAvatarp->mAttachmentPoints.begin();
iter != gAgentAvatarp->mAttachmentPoints.end(); )
{
LLVOAvatar::attachment_map_t::iterator curiter = iter++;
LLViewerJointAttachment* attachment = curiter->second;
if (attachment->getName() == joint_name)
{
attachmentp = attachment;
break;
}
}
if (attachmentp == NULL)
{
return;
}
for (uuid_vec_t::const_iterator it = items.begin(); it != items.end(); ++it)
{
const LLUUID &id = *it;
LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getLinkedItem(id);
if(item && gInventory.isObjectDescendentOf(id, gInventory.getRootFolderID()))
{
rez_attachment(item, attachmentp); // don't replace if called from an "Attach To..." menu
}
else if(item && item->isFinished())
{
// must be in library. copy it to our inventory and put it on.
LLPointer<LLInventoryCallback> cb = new RezAttachmentCallback(attachmentp);
copy_inventory_item(gAgent.getID(),
item->getPermissions().getOwner(),
item->getUUID(),
LLUUID::null,
std::string(),
cb);
}
}
}
// static
void LLWLParamManager::loadWindlightNotecard(LLVFS *vfs, const LLUUID& asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status)
{
LLUUID inventory_id(*((LLUUID*)user_data));
std::string name = "WindLight Setting.wl";
LLViewerInventoryItem *item = gInventory.getItem(inventory_id);
if(item)
{
inventory_id = item->getUUID();
name = item->getName();
}
if(LL_ERR_NOERR == status)
{
LLVFile file(vfs, asset_id, asset_type, LLVFile::READ);
S32 file_length = file.getSize();
std::vector<char> buffer(file_length + 1);
file.read((U8*)&buffer[0], file_length);
buffer[file_length] = 0;
LLNotecard notecard(LLNotecard::MAX_SIZE);
LLMemoryStream str((U8*)&buffer[0], file_length + 1);
notecard.importStream(str);
std::string settings = notecard.getText();
LLMemoryStream settings_str((U8*)settings.c_str(), settings.length());
LLWLParamKey key((" Notecard: " + name), LLEnvKey::SCOPE_LOCAL);
bool is_real_setting = getInstance()->loadPresetXML(key, settings_str);
if(!is_real_setting)
{
LLSD subs;
subs["NAME"] = name;
LLNotifications::getInstance()->add("KittyInvalidWindlightNotecard", subs);
}
else
{
// We can do this because we know mCurParams
getInstance()->mParamList[key].mInventoryID = inventory_id;
LLEnvManagerNew::instance().setUseSkyPreset(key.name);
}
}
}
void FSLSLBridgeScriptCallback::fire(const LLUUID& inv_item)
{
if (inv_item.isNull() || !FSLSLBridge::instance().getBridgeCreating())
return;
LLViewerInventoryItem* item = gInventory.getItem(inv_item);
if (!item)
{
return;
}
gInventory.updateItem(item);
gInventory.notifyObservers();
LLViewerObject* obj = gAgentAvatarp->getWornAttachment(FSLSLBridge::instance().getBridge()->getUUID());
//caps import
std::string url = gAgent.getRegion()->getCapability("UpdateScriptAgent");
std::string isMono = "lsl2"; //could also be "mono"
if (!url.empty() && obj != NULL)
{
const std::string fName = prepUploadFile();
LLLiveLSLEditor::uploadAssetViaCapsStatic(url, fName,
obj->getID(), inv_item, isMono, true);
llinfos << "updating script ID for bridge" << llendl;
FSLSLBridge::instance().mScriptItemID = inv_item;
}
else
{
//can't complete bridge creation - detach and remove object, remove script
//try to clean up and go away. Fail.
LLVOAvatarSelf::detachAttachmentIntoInventory(FSLSLBridge::instance().getBridge()->getUUID());
FSLSLBridge::instance().cleanUpBridge();
//also clean up script remains
gInventory.purgeObject(item->getUUID());
gInventory.notifyObservers();
return;
}
}
void FSLSLBridge::processDetach(LLViewerObject* object, const LLViewerJointAttachment* attachment)
{
llinfos << "Entering processDetach" << llendl;
if (gAgentAvatarp.isNull() || (!gAgentAvatarp->isSelf()) || (attachment == NULL) || (attachment->getName() != "Bridge"))
{
llwarns << "Couldn't detach bridge, object has wrong name or avatar wasn't self." << llendl;
return;
}
LLViewerInventoryItem* fsObject = gInventory.getItem(object->getAttachmentItemID());
if (fsObject == NULL) //just in case
{
llwarns << "Couldn't detach bridge. inventory object was NULL." << llendl;
return;
}
//is it in the right place?
LLUUID catID = findFSCategory();
if (catID != fsObject->getParentUUID())
{
//that was in the wrong place. It's not ours.
llwarns << "Bridge seems to be the wrong inventory category. Aborting detachment." << llendl;
return;
}
if (mpBridge != NULL && mpBridge->getUUID() == fsObject->getUUID())
{
mpBridge = NULL;
reportToNearbyChat(LLTrans::getString("fsbridge_detached"));
mIsFirstCallDone = false;
if (mBridgeCreating)
{
reportToNearbyChat(LLTrans::getString("fsbridge_warning_not_finished"));
mBridgeCreating = false; //in case we interrupted the creation
}
}
llinfos << "processDetach Finished" << llendl;
}
void FSLSLBridge::createNewBridge()
{
//check if user has a bridge
LLUUID catID = findFSCategory();
//attach the Linden rock from the library (will resize as soon as attached)
LLUUID libID = gInventory.getLibraryRootFolderID();
LLViewerInventoryItem* libRock = findInvObject(LIB_ROCK_NAME, libID, LLAssetType::AT_OBJECT);
//shouldn't happen but just in case
if (libRock != NULL)
{
//copy the library item to inventory and put it on
LLPointer<LLInventoryCallback> cb = new FSLSLBridgeRezCallback();
llinfos << "Cloning a new Bridge container from the Library..." << llendl;
copy_inventory_item(gAgent.getID(), libRock->getPermissions().getOwner(), libRock->getUUID(), catID, mCurrentFullName, cb);
}
else
{
llwarns << "Bridge container not found in the Library!" << llendl;
// AH: Set to false or we won't be able to start another bridge creation
// process in this session!
mBridgeCreating = false;
}
}
// Checked: 2010-03-21 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
void RlvForceWear::forceFolder(const LLViewerInventoryCategory* pFolder, EWearAction eAction, EWearFlags eFlags)
{
// [See LLWearableBridge::wearOnAvatar(): don't wear anything until initial wearables are loaded, can destroy clothing items]
if (!gAgentWearables.areWearablesLoaded())
{
LLNotificationsUtil::add("CanNotChangeAppearanceUntilLoaded");
return;
}
if (!isAgentAvatarValid())
return;
// Grab a list of all the items we'll be wearing/attaching
LLInventoryModel::cat_array_t folders; LLInventoryModel::item_array_t items;
RlvWearableItemCollector f(pFolder, eAction, eFlags);
gInventory.collectDescendentsIf(pFolder->getUUID(), folders, items, FALSE, f, TRUE);
// TRUE if we've already encountered this LLWearableType::EType (used only on wear actions and only for AT_CLOTHING)
bool fSeenWType[LLWearableType::WT_COUNT] = { false };
EWearAction eCurAction = eAction;
for (S32 idxItem = 0, cntItem = items.count(); idxItem < cntItem; idxItem++)
{
LLViewerInventoryItem* pRlvItem = items.get(idxItem);
LLViewerInventoryItem* pItem = (LLAssetType::AT_LINK == pRlvItem->getActualType()) ? pRlvItem->getLinkedItem() : pRlvItem;
// If it's wearable it should be worn on detach
// if ( (ACTION_DETACH == eAction) && (isWearableItem(pItem)) && (!isWearingItem(pItem)) )
// continue;
// Each folder can specify its own EWearAction override
if (isWearAction(eAction))
eCurAction = f.getWearAction(pRlvItem->getParentUUID());
else
eCurAction = eAction;
// NOTES: * if there are composite items then RlvWearableItemCollector made sure they can be worn (or taken off depending)
// * some scripts issue @remattach=force,attach:worn-items=force so we need to attach items even if they're currently worn
switch (pItem->getType())
{
case LLAssetType::AT_BODYPART:
RLV_ASSERT(isWearAction(eAction)); // RlvWearableItemCollector shouldn't be supplying us with body parts on detach
case LLAssetType::AT_CLOTHING:
if (isWearAction(eAction))
{
// The first time we encounter any given clothing type we use 'eCurAction' (replace or add)
// The second time we encounter a given clothing type we'll always add (rather than replace the previous iteration)
eCurAction = (!fSeenWType[pItem->getWearableType()]) ? eCurAction : ACTION_WEAR_ADD;
ERlvWearMask eWearMask = gRlvWearableLocks.canWear(pRlvItem);
if ( ((ACTION_WEAR_REPLACE == eCurAction) && (eWearMask & RLV_WEAR_REPLACE)) ||
((ACTION_WEAR_ADD == eCurAction) && (eWearMask & RLV_WEAR_ADD)) )
{
// The check for whether we're replacing a currently worn composite item happens in onWearableArrived()
if (!isAddWearable(pItem))
addWearable(pRlvItem, eCurAction);
fSeenWType[pItem->getWearableType()] = true;
}
}
else
{
const LLViewerWearable* pWearable = gAgentWearables.getWearableFromItemID(pItem->getUUID());
if ( (pWearable) && (isForceRemovable(pWearable, false)) )
remWearable(pWearable);
}
break;
case LLAssetType::AT_OBJECT:
if (isWearAction(eAction))
{
ERlvWearMask eWearMask = gRlvAttachmentLocks.canAttach(pRlvItem);
if ( ((ACTION_WEAR_REPLACE == eCurAction) && (eWearMask & RLV_WEAR_REPLACE)) ||
((ACTION_WEAR_ADD == eCurAction) && (eWearMask & RLV_WEAR_ADD)) )
{
if (!isAddAttachment(pRlvItem))
{
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
// We still need to check whether we're about to replace a currently worn composite item
// (which we're not if we're just reattaching an attachment we're already wearing)
LLViewerInventoryCategory* pCompositeFolder = NULL;
if ( (pAttachPt->getObject()) && (RlvSettings::getEnableComposites()) &&
(pAttachPt->getItemID() != pItem->getUUID()) &&
(gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pCompositeFolder)) )
{
// If we can't take off the composite folder this item would replace then don't allow it to get attached
if (gRlvHandler.canTakeOffComposite(pCompositeFolder))
{
forceFolder(pCompositeFolder, ACTION_DETACH, FLAG_DEFAULT);
addAttachment(pRlvItem);
}
}
else
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
{
addAttachment(pRlvItem, eCurAction);
}
}
}
}
else
{
const LLViewerObject* pAttachObj = gAgentAvatarp->getWornAttachment(pItem->getUUID());
if ( (pAttachObj) && (isForceDetachable(pAttachObj, false)) )
remAttachment(pAttachObj);
}
break;
#ifdef RLV_EXTENSION_FORCEWEAR_GESTURES
case LLAssetType::AT_GESTURE:
if (isWearAction(eAction))
{
if (std::find_if(m_addGestures.begin(), m_addGestures.end(), RlvPredIsEqualOrLinkedItem(pRlvItem)) == m_addGestures.end())
m_addGestures.push_back(pRlvItem);
}
else
{
if (std::find_if(m_remGestures.begin(), m_remGestures.end(), RlvPredIsEqualOrLinkedItem(pRlvItem)) == m_remGestures.end())
m_remGestures.push_back(pRlvItem);
}
break;
#endif // RLV_EXTENSION_FORCEWEAR_GESTURES
default:
break;
}
}
}
void LLPanelTopInfoBar::onContextMenuItemClicked(const LLSD::String& item)
{
if (item == "landmark")
{
LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
if(landmark == NULL)
{
LLFloaterSidePanelContainer::showPanel("places", LLSD().with("type", "create_landmark"));
}
else
{
LLFloaterSidePanelContainer::showPanel("places", LLSD().with("type", "landmark").with("id",landmark->getUUID()));
}
}
else if (item == "copy")
{
LLSLURL slurl;
LLAgentUI::buildSLURL(slurl, false);
LLUIString location_str(slurl.getSLURLString());
LLClipboard::instance().copyToClipboard(location_str,0,location_str.length());
}
}
bool FSLSLBridge::lslToViewer(std::string message, LLUUID fromID, LLUUID ownerID)
{
if (!gSavedSettings.getBOOL("UseLSLBridge"))
{
return false;
}
lldebugs << message << llendl;
//<FS:TS> FIRE-962: Script controls for built-in AO
if ((message[0]) != '<')
{
return false; // quick exit if no leading <
}
S32 closebracket = message.find('>');
S32 firstblank = message.find(' ');
S32 tagend;
if (closebracket == std::string::npos)
{
tagend = firstblank;
}
else if (firstblank == std::string::npos)
{
tagend = closebracket;
}
else
{
tagend = (closebracket < firstblank) ? closebracket : firstblank;
}
if (tagend == std::string::npos)
{
return false;
}
std::string tag = message.substr(0, tagend + 1);
std::string ourBridge = gSavedPerAccountSettings.getString("FSLSLBridgeUUID");
//</FS:TS> FIRE-962
bool status = false;
if (tag == "<bridgeURL>")
{
// brutish parsing
S32 urlStart = message.find("<bridgeURL>") + 11;
S32 urlEnd = message.find("</bridgeURL>");
S32 authStart = message.find("<bridgeAuth>") + 12;
S32 authEnd = message.find("</bridgeAuth>");
S32 verStart = message.find("<bridgeVer>") + 11;
S32 verEnd = message.find("</bridgeVer>");
std::string bURL = message.substr(urlStart,urlEnd - urlStart);
std::string bAuth = message.substr(authStart,authEnd - authStart);
std::string bVer = message.substr(verStart,verEnd - verStart);
// Verify Version
// todo
// Verify Authorization
if (ourBridge != bAuth)
{
llwarns << "BridgeURL message received from ("<< bAuth <<") , but not from our registered bridge ("<< ourBridge <<"). Ignoring." << llendl;
// Failing bridge authorization automatically kicks off a bridge rebuild. This correctly handles the
// case where a user logs in from multiple computers which cannot have the bridgeAuth ID locally
// synchronized.
// If something that looks like our current bridge is attached but failed auth, detach and recreate.
LLUUID catID = findFSCategory();
LLViewerInventoryItem* fsBridge = findInvObject(mCurrentFullName, catID, LLAssetType::AT_OBJECT);
if (fsBridge != NULL)
{
if (get_is_item_worn(fsBridge->getUUID()))
{
LLVOAvatarSelf::detachAttachmentIntoInventory(fsBridge->getUUID());
//This may have been an unfinished bridge. If so - stop the process before recreating.
if (mBridgeCreating)
mBridgeCreating = false;
recreateBridge();
return true;
}
}
// If something that didn't look like our current bridge failed auth, don't recreate, it might interfere with a bridge creation in progress
// or normal bridge startup. Bridge creation isn't threadsafe yet.
return true;
}
// Save the inworld UUID of this attached bridge for later checking
mBridgeUUID = fromID;
// Get URL
mCurrentURL = bURL;
llinfos << "New Bridge URL is: " << mCurrentURL << llendl;
if (mpBridge == NULL)
{
LLUUID catID = findFSCategory();
LLViewerInventoryItem* fsBridge = findInvObject(mCurrentFullName, catID, LLAssetType::AT_OBJECT);
mpBridge = fsBridge;
}
status = viewerToLSL("URL Confirmed", new FSLSLBridgeRequestResponder());
//updateBoolSettingValue("UseLSLFlightAssist");
if (!mIsFirstCallDone)
{
//on first call from bridge, confirm that we are here
//then check options use
updateBoolSettingValue("UseLSLFlightAssist");
updateBoolSettingValue("FSPublishRadarTag");
mIsFirstCallDone = true;
}
return true;
}
//<FS:TS> FIRE-962: Script controls for built-in AO
if (fromID != mBridgeUUID)
{
return false; // ignore if not from the bridge
}
if (tag == "<clientAO ")
{
status = true;
S32 valuepos = message.find("state=") + 6;
if (valuepos != std::string::npos)
{
if (message.substr(valuepos, 2) == "on")
{
gSavedPerAccountSettings.setBOOL("UseAO", TRUE);
}
else if (message.substr(valuepos, 3) == "off")
{
gSavedPerAccountSettings.setBOOL("UseAO", FALSE);
}
}
}
//</FS:TS> FIRE-962
return status;
}
void LLPanelTopInfoBar::onContextMenuItemClicked(const LLSD::String& item)
{
if (item == "landmark")
{
// [RLVa:KB] - Checked: 2012-02-08 (RLVa-1.4.5) | Added: RLVa-1.4.5
if (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
{
// [/RLVa:KB]
LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
if(landmark == NULL)
{
LLFloaterSidePanelContainer::showPanel("places", LLSD().with("type", "create_landmark"));
}
else
{
LLFloaterSidePanelContainer::showPanel("places", LLSD().with("type", "landmark").with("id",landmark->getUUID()));
}
// [RLVa:KB] - Checked: 2012-02-08 (RLVa-1.4.5) | Added: RLVa-1.4.5
}
// [/RLVa:KB]
}
else if (item == "copy")
{
// [RLVa:KB] - Checked: 2012-02-08 (RLVa-1.4.5) | Added: RLVa-1.4.5
if (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
{
// [/RLVa:KB]
LLSLURL slurl;
LLAgentUI::buildSLURL(slurl, false);
LLUIString location_str(slurl.getSLURLString());
gClipboard.copyFromString(location_str);
// [RLVa:KB] - Checked: 2012-02-08 (RLVa-1.4.5) | Added: RLVa-1.4.5
}
// [/RLVa:KB]
}
}
void FSLSLBridge::processAttach(LLViewerObject* object, const LLViewerJointAttachment* attachment)
{
llinfos << "Entering processAttach, checking the bridge container - gInventory.isInventoryUsable=" << gInventory.isInventoryUsable()<< llendl;
if ((!gAgentAvatarp->isSelf()) || (attachment->getName() != "Bridge"))
{
llwarns << "Bridge not created. Our bridge container attachment isn't named correctly." << llendl;
if (mBridgeCreating)
{
reportToNearbyChat(LLTrans::getString("fsbridge_failure_creation_bad_name"));
mBridgeCreating = false; //in case we interrupted the creation
}
return;
}
LLViewerInventoryItem* fsObject = gInventory.getItem(object->getAttachmentItemID());
if (fsObject == NULL) //just in case
{
llwarns << "Bridge container is still NULL in inventory. Aborting." << llendl;
if (mBridgeCreating)
{
reportToNearbyChat(LLTrans::getString("fsbridge_failure_creation_null"));
mBridgeCreating = false; //in case we interrupted the creation
}
return;
}
if (mpBridge == NULL) //user is attaching an existing bridge?
{
//is it the right version?
if (fsObject->getName() != mCurrentFullName)
{
LLVOAvatarSelf::detachAttachmentIntoInventory(fsObject->getUUID());
llwarns << "Attempt to attach to bridge point an object other than current bridge" << llendl;
reportToNearbyChat(LLTrans::getString("fsbridge_failure_attach_wrong_object"));
if (mBridgeCreating)
{
mBridgeCreating = false; //in case we interrupted the creation
}
return;
}
//is it in the right place?
LLUUID catID = findFSCategory();
if (catID != fsObject->getParentUUID())
{
//the object is not where we think it is. Kick it off.
LLVOAvatarSelf::detachAttachmentIntoInventory(fsObject->getUUID());
llwarns << "Bridge container isn't in the correct inventory location. Detaching it and aborting." << llendl;
if (mBridgeCreating)
{
reportToNearbyChat(LLTrans::getString("fs_bridge_failure_attach_wrong_location"));
mBridgeCreating = false; //in case we interrupted the creation
}
return;
}
mpBridge = fsObject;
}
lldebugs << "Bridge container is attached, mpBridge not NULL, avatar is self, point is bridge, all is good." << llendl;
if (fsObject->getUUID() != mpBridge->getUUID())
{
//something odd just got attached to bridge?
llwarns << "Something unknown just got attached to bridge point, detaching and aborting." << llendl;
if (mBridgeCreating)
{
reportToNearbyChat(LLTrans::getString("fsbridge_failure_attach_point_in_use"));
mBridgeCreating = false; //in case we interrupted the creation
}
LLVOAvatarSelf::detachAttachmentIntoInventory(mpBridge->getUUID());
return;
}
lldebugs << "Bridge container found is the same bridge we saved, id matched." << llendl;
if (!mBridgeCreating) //just an attach. See what it is
{
// AH: We need to request objects inventory first before we can
// do anything with it!
llinfos << "Requesting bridge inventory contents..." << llendl;
object->registerInventoryListener(this, NULL);
object->requestInventory();
}
else
{
configureBridgePrim(object);
}
}
void FSLSLBridgeScriptCallback::fire(const LLUUID& inv_item)
{
if (inv_item.isNull() || !FSLSLBridge::instance().getBridgeCreating())
{
llwarns << "BridgeScriptCallback fired, but target item was null or bridge isn't marked as under creation. Ignoring." << llendl;
return;
}
LLViewerInventoryItem* item = gInventory.getItem(inv_item);
if (!item)
{
llwarns << "BridgeScriptCallback Can't find target item in inventory. Ignoring." << llendl;
return;
}
if (!isAgentAvatarValid())
{
llwarns << "Agent is 0, bailing out" << llendl;
return;
}
gInventory.updateItem(item);
gInventory.notifyObservers();
LLViewerObject* obj(NULL);
if (FSLSLBridge::instance().isBridgeValid())
{
obj = gAgentAvatarp->getWornAttachment(FSLSLBridge::instance().getBridge()->getUUID());
}
else
{
llwarns << "Bridge non valid" << llendl;
}
//caps import
std::string url;
if (gAgent.getRegion())
{
url = gAgent.getRegion()->getCapability("UpdateScriptAgent");
}
std::string isMono = "mono"; //could also be "lsl2"
if (!url.empty() && obj != NULL)
{
const std::string fName = prepUploadFile();
LLLiveLSLEditor::uploadAssetViaCapsStatic(url, fName,
obj->getID(), inv_item, isMono, true);
llinfos << "updating script ID for bridge" << llendl;
FSLSLBridge::instance().mScriptItemID = inv_item;
}
else
{
//can't complete bridge creation - detach and remove object, remove script
//try to clean up and go away. Fail.
if (FSLSLBridge::instance().isBridgeValid())
{
LLVOAvatarSelf::detachAttachmentIntoInventory(FSLSLBridge::instance().getBridge()->getUUID());
}
FSLSLBridge::instance().cleanUpBridge();
//also clean up script remains
gInventory.purgeObject(item->getUUID());
gInventory.notifyObservers();
llwarns << "Can't update bridge script. Purging bridge." << llendl;
return;
}
}
BOOL JCLSLBridge::tick()
{
if(LLStartUp::getStartupState() >= STATE_INVENTORY_SEND)
{
switch(sBridgeStatus)
{
case UNINITIALIZED:
{
/*
We're going to just completely disable this in code, it's shit - CW
if(!gSavedSettings.getBOOL("Meta7BuildBridge"))
{
*/
sBridgeStatus = FAILED;
break;
//}
//cmdline_printchat("initializing");//<< llendl;
LLUUID item_id = findInventoryByName(vBridgeName);
if(gInventory.isEverythingFetched())// || (item_id.notNull() && isworn(item_id)))
{
//cmdline_printchat("inv is fetched");//<< llendl;
if(item_id.notNull())
{
//cmdline_printchat("id="+item_id.asString());
LLViewerInventoryItem* bridge = gInventory.getItem(item_id);
if(bridge)
{
//cmdline_printchat("bridge is ready to attach");//<< llendl;
if(isworn(bridge->getUUID()))
{
//cmdline_printchat("bridge is already worn");//<< llendl;
sBridgeStatus = RECHAN;
}else if(bridge->isComplete())
{
//cmdline_printchat("bridge is complete, attaching");//<< llendl;
LLMessageSystem* msg = gMessageSystem;
msg->newMessageFast(_PREHASH_RezSingleAttachmentFromInv);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addUUIDFast(_PREHASH_ItemID, bridge->getUUID());
msg->addUUIDFast(_PREHASH_OwnerID, bridge->getPermissions().getOwner());
msg->addU8Fast(_PREHASH_AttachmentPt, 128);
pack_permissions_slam(msg, bridge->getFlags(), bridge->getPermissions());
msg->addStringFast(_PREHASH_Name, bridge->getName());
msg->addStringFast(_PREHASH_Description, bridge->getDescription());
msg->sendReliable(gAgent.getRegionHost());
sBridgeStatus = RECHAN;
}
}
}else
{
//cmdline_printchat("no bridge");//<< llendl;
//sBridgeStatus = BUILDING;
std::string directory = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"bridge.xml");
if(!LLFile::isfile(directory.c_str()))
{
//cmdline_printchat("file not there o.o");//<< llendl;
sBridgeStatus = FAILED;
}else
{
//cmdline_printchat("bridge.xml located. importing..");//<< llendl;
gImportTracker.importer(directory,&setBridgeObject);
sBridgeStatus = BUILDING;
}
}
}
}
break;
case RENAMING:
{
////cmdline_printchat("renaming");
LLMessageSystem* msg = gMessageSystem;
msg->newMessageFast(_PREHASH_ObjectAttach);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->addU8Fast(_PREHASH_AttachmentPoint, vCatType);
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, sBridgeObject->getLocalID());
msg->addQuatFast(_PREHASH_Rotation, LLQuaternion(0.0f, 0.0f, 0.0f, 1.0f));
msg->sendReliable(gAgent.getRegion()->getHost());
sBridgeStatus = FOLDERING;
}
break;
case FOLDERING:
{
////cmdline_printchat("foldering");
LLUUID vcatid;
vcatid = gInventory.findCategoryByName(vBridgeOpCat);
if(vcatid.isNull())
{
////cmdline_printchat("creating folder");
vcatid = gInventory.createNewCategory(gAgent.getInventoryRootID(), LLAssetType::AT_NONE, vBridgeOpCat);
}
LLUUID bridge_id = findInventoryByName(vBridgeName);
//cmdline_printchat("id="+bridge_id.asString());
LLViewerInventoryItem* bridge = gInventory.getItem(bridge_id);
if(bridge)
{
move_inventory_item(gAgent.getID(),gAgent.getSessionID(),bridge->getUUID(),vcatid,vBridgeName, NULL);
sBridgeStatus = RECHAN;
////cmdline_printchat("moving to folder");
}
}
break;
case RECHAN:
{
{
//if(l2c == 0) is this really needed ._.
//{
send_chat_from_viewer("-1|l2c", CHAT_TYPE_WHISPER, JCLSLBridge::bridge_channel(gAgent.getID()));
sBridgeStatus = ACTIVE;
//}
}
}
case ACTIVE:
{
LLUUID bridge = findInventoryByName(vBridgeName);
//if(bridge)
//LLVOAvatar* avatar = gAgent.getAvatarObject();
if(bridge.isNull() || !isworn(bridge))
{
l2c = 0;
l2c_inuse = false;
////cmdline_printchat("reattaching");
sBridgeStatus = UNINITIALIZED;
}
}
}
}
return FALSE;
}
// Checked: 2010-03-14 (RLVa-1.1.3a) | Added: RLVa-1.2.0a
void RlvRenameOnWearObserver::doneIdle()
{
const LLViewerInventoryCategory* pRlvRoot = NULL; LLVOAvatar* pAvatar = gAgentAvatarp;
if ( (RlvSettings::getEnableSharedWear()) || (!RlvSettings::getSharedInvAutoRename()) || (LLStartUp::getStartupState() < STATE_STARTED) ||
(!pAvatar) || ((pRlvRoot = RlvInventory::instance().getSharedRoot()) == NULL) )
{
delete this;
return;
}
const LLViewerJointAttachment* pAttachPt = NULL; S32 idxAttachPt = 0;
// RLV_ASSERT(mComplete.size() > 0); // Catch instances where we forgot to call startFetch()
for (uuid_vec_t::const_iterator itItem = mComplete.begin(); itItem != mComplete.end(); ++itItem)
{
const LLUUID& idAttachItem = *itItem;
// If the item resides under #RLV we'll rename it directly; otherwise settle for "renaming" all of its links residing under #RLV
LLInventoryModel::item_array_t items;
if (gInventory.isObjectDescendentOf(idAttachItem, pRlvRoot->getUUID()))
items.push_back(gInventory.getItem(idAttachItem));
else
items = gInventory.collectLinkedItems(idAttachItem, pRlvRoot->getUUID());
if (items.empty())
continue;
if ( ((pAttachPt = pAvatar->getWornAttachmentPoint(idAttachItem)) == NULL) ||
((idxAttachPt = RlvAttachPtLookup::getAttachPointIndex(pAttachPt)) == 0) )
{
// RLV_ASSERT(false);
continue;
}
static const std::string &new_category_name = LLViewerFolderType::lookupNewCategoryName(LLFolderType::FT_NONE);
for (S32 idxItem = 0, cntItem = items.count(); idxItem < cntItem; idxItem++)
{
LLViewerInventoryItem* pItem = items.get(idxItem);
if (!pItem)
continue;
S32 idxAttachPtItem = RlvAttachPtLookup::getAttachPointIndex(pItem);
if ( (idxAttachPt == idxAttachPtItem) || (idxAttachPtItem) )
continue;
std::string strAttachPt = pAttachPt->getName();
LLStringUtil::toLower(strAttachPt);
// If we can modify the item then we rename it directly, otherwise we create a new folder and move it
if (pItem->getPermissions().allowModifyBy(gAgent.getID()))
{
std::string strName = pItem->getName();
LLStringUtil::truncate(strName, DB_INV_ITEM_NAME_STR_LEN - strAttachPt.length() - 3);
strName += " (" + strAttachPt + ")";
pItem->rename(strName);
pItem->updateServer(FALSE);
gInventory.addChangedMask(LLInventoryObserver::LABEL, pItem->getUUID());
}
else
{
// Don't do anything if the item is a direct descendant of the shared root, or a folded folder
LLViewerInventoryCategory* pFolder = gInventory.getCategory(pItem->getParentUUID());
if ( (pFolder) && (pFolder->getUUID() != pRlvRoot->getUUID()) && (!RlvInventory::isFoldedFolder(pFolder, false)) )
{
std::string strFolderName = ".(" + strAttachPt + ")";
// Rename the item's parent folder if it's called "New Folder", isn't directly under #RLV and contains exactly 1 object
if ( (new_category_name == pFolder->getName()) &&
(pFolder->getParentUUID() != pRlvRoot->getUUID()) &&
(1 == RlvInventory::getDirectDescendentsCount(pFolder, LLAssetType::AT_OBJECT)) )
{
pFolder->rename(strFolderName);
pFolder->updateServer(FALSE);
gInventory.addChangedMask(LLInventoryObserver::LABEL, pFolder->getUUID());
}
else
{
// "No modify" item with a non-renameable parent: create a new folder named and move the item into it
LLUUID idAttachFolder = gInventory.createNewCategory(pFolder->getUUID(), LLFolderType::FT_NONE, strFolderName);
move_inventory_item(gAgent.getID(), gAgent.getSessionID(), pItem->getUUID(), idAttachFolder, std::string(), NULL);
}
}
}
}
}
gInventory.notifyObservers();
delete this;
}
void LLGestureMgr::activateGestures(LLViewerInventoryItem::item_array_t& items)
{
// Load up the assets
S32 count = 0;
LLViewerInventoryItem::item_array_t::const_iterator it;
for (it = items.begin(); it != items.end(); ++it)
{
LLViewerInventoryItem* item = *it;
if (isGestureActive(item->getUUID()))
{
continue;
}
else
{ // Make gesture active and persistent through login sessions. -Aura 07-12-06
activateGesture(item->getUUID());
}
count++;
}
mLoadingCount = count;
mDeactivateSimilarNames.clear();
for (it = items.begin(); it != items.end(); ++it)
{
LLViewerInventoryItem* item = *it;
if (isGestureActive(item->getUUID()))
{
continue;
}
// Don't inform server, we'll do that in bulk
const BOOL no_inform_server = FALSE;
const BOOL deactivate_similar = TRUE;
activateGestureWithAsset(item->getUUID(), item->getAssetUUID(),
no_inform_server,
deactivate_similar);
}
// Inform the database of this change
LLMessageSystem* msg = gMessageSystem;
BOOL start_message = TRUE;
for (it = items.begin(); it != items.end(); ++it)
{
LLViewerInventoryItem* item = *it;
if (isGestureActive(item->getUUID()))
{
continue;
}
if (start_message)
{
msg->newMessage("ActivateGestures");
msg->nextBlock("AgentData");
msg->addUUID("AgentID", gAgent.getID());
msg->addUUID("SessionID", gAgent.getSessionID());
msg->addU32("Flags", 0x0);
start_message = FALSE;
}
msg->nextBlock("Data");
msg->addUUID("ItemID", item->getUUID());
msg->addUUID("AssetID", item->getAssetUUID());
msg->addU32("GestureFlags", 0x0);
if (msg->getCurrentSendTotal() > MTUBYTES)
{
gAgent.sendReliableMessage();
start_message = TRUE;
}
}
if (!start_message)
{
gAgent.sendReliableMessage();
}
}
// Checked: 2010-09-18 (RLVa-1.2.1)
void RlvForceWear::done()
{
// Sanity check - don't go through all the motions below only to find out there's nothing to actually do
if ( (m_remWearables.empty()) && (m_remAttachments.empty()) && (m_remGestures.empty()) &&
(m_addWearables.empty()) && (m_addAttachments.empty()) && (m_addGestures.empty()) )
{
return;
}
LLAppearanceMgr* pAppearanceMgr = LLAppearanceMgr::getInstance();
//
// Process removals
//
// Wearables
if (m_remWearables.size())
{
for (std::list<const LLViewerWearable*>::const_iterator itWearable = m_remWearables.begin(); itWearable != m_remWearables.end(); ++itWearable)
pAppearanceMgr->removeItemFromAvatar((*itWearable)->getItemID());
m_remWearables.clear();
}
// Gestures
if (m_remGestures.size())
{
// NOTE: LLGestureMgr::deactivateGesture() will call LLAppearanceMgr::removeCOFItemLinks() for us
for (S32 idxItem = 0, cntItem = m_remGestures.count(); idxItem < cntItem; idxItem++)
LLGestureMgr::instance().deactivateGesture(m_remGestures.get(idxItem)->getUUID());
m_remGestures.clear();
}
// Attachments
if (m_remAttachments.size())
{
// Don't bother with COF if all we're doing is detaching some attachments (keeps people from rebaking on every @remattach=force)
LLAgentWearables::userRemoveMultipleAttachments(m_remAttachments);
for (std::vector<LLViewerObject*>::const_iterator itAttachObj = m_remAttachments.begin();
itAttachObj != m_remAttachments.end(); ++itAttachObj)
{
pAppearanceMgr->removeCOFItemLinks((*itAttachObj)->getAttachmentItemID());
}
m_remAttachments.clear();
}
//
// Process additions
//
// Wearables need to be split into AT_BODYPART and AT_CLOTHING for COF
LLInventoryModel::item_array_t addBodyParts, addClothing;
for (addwearables_map_t::const_iterator itAddWearables = m_addWearables.begin(); itAddWearables != m_addWearables.end(); ++itAddWearables)
{
const LLInventoryModel::item_array_t& wearItems = itAddWearables->second;
for (S32 idxItem = 0, cntItem = wearItems.count(); idxItem < cntItem; idxItem++)
{
LLViewerInventoryItem* pItem = wearItems.get(idxItem);
if (!pAppearanceMgr->isLinkInCOF(pItem->getUUID())) // It's important to examine COF here and *not* gAgentWearables
{
if (LLAssetType::AT_BODYPART == pItem->getType())
addBodyParts.push_back(pItem);
else
addClothing.push_back(pItem);
}
}
}
m_addWearables.clear();
// Until LL provides a way for updateCOF to selectively attach add/replace we have to deal with attachments ourselves
for (addattachments_map_t::const_iterator itAddAttachments = m_addAttachments.begin();
itAddAttachments != m_addAttachments.end(); ++itAddAttachments)
{
const LLInventoryModel::item_array_t& wearItems = itAddAttachments->second;
for (S32 idxItem = 0, cntItem = wearItems.count(); idxItem < cntItem; idxItem++)
{
const LLUUID& idItem = wearItems.get(idxItem)->getLinkedUUID();
if (gAgentAvatarp->attachmentWasRequested(idItem))
continue;
gAgentAvatarp->addAttachmentRequest(idItem);
LLAttachmentsMgr::instance().addAttachment(idItem, itAddAttachments->first & ~ATTACHMENT_ADD, itAddAttachments->first & ATTACHMENT_ADD);
}
}
m_addAttachments.clear();
// If there are additions we need to call LLAppearanceManager::updateCOF(), otherwise LLAppearanceManager::updateAppearanceFromCOF()
if ( (!addBodyParts.empty()) || (!addClothing.empty()) || (!m_addGestures.empty()) )
{
LLInventoryModel::item_array_t addAttachments;
pAppearanceMgr->updateCOF(addBodyParts, addClothing, addAttachments, m_addGestures, true);
m_addGestures.clear();
}
// Since RlvForceWear is a singleton now we want to be sure there aren't any leftovers
RLV_ASSERT( (m_remWearables.empty()) && (m_remAttachments.empty()) && (m_remGestures.empty()) );
RLV_ASSERT( (m_addWearables.empty()) && (m_addAttachments.empty()) && (m_addGestures.empty()) );
}
