bool LLFindWearablesEx::operator()(LLInventoryCategory* cat, LLInventoryItem* item)
{
LLViewerInventoryItem *vitem = dynamic_cast<LLViewerInventoryItem*>(item);
if (!vitem) return false;
// Skip non-wearables.
if (!vitem->isWearableType() && vitem->getType() != LLAssetType::AT_OBJECT)
{
return false;
}
// Skip body parts if requested.
if (!mIncludeBodyParts && vitem->getType() == LLAssetType::AT_BODYPART)
{
return false;
}
// Skip broken links.
if (vitem->getIsBrokenLink())
{
return false;
}
return (bool) get_is_item_worn(item->getUUID()) == mIsWorn;
}
void ActivateGestureCallback::fire(const LLUUID& inv_item)
{
if (inv_item.isNull())
return;
LLViewerInventoryItem* item = gInventory.getItem(inv_item);
if (!item)
return;
if (item->getType() != LLAssetType::AT_GESTURE)
return;
gGestureManager.activateGesture(inv_item);
}
// Can we wear another wearable of the given item's wearable type?
// static
bool LLWearableItemsList::ContextMenu::canAddWearable(const LLUUID& item_id)
{
// TODO: investigate wearables may not be loaded at this point EXT-8231
LLViewerInventoryItem* item = gInventory.getItem(item_id);
if (!item || item->getType() != LLAssetType::AT_CLOTHING)
{
return false;
}
U32 wearable_count = gAgentWearables.getWearableCount(item->getWearableType());
return wearable_count < LLAgentWearables::MAX_CLOTHING_PER_TYPE;
}
// Use this version when you have the item_id but not the asset_id,
// and you KNOW the inventory is loaded.
void LLGestureMgr::activateGesture(const LLUUID& item_id)
{
LLViewerInventoryItem* item = gInventory.getItem(item_id);
if (!item) return;
if (item->getType() != LLAssetType::AT_GESTURE)
return;
LLUUID asset_id = item->getAssetUUID();
mLoadingCount = 1;
mDeactivateSimilarNames.clear();
const BOOL inform_server = TRUE;
const BOOL deactivate_similar = FALSE;
activateGestureWithAsset(item_id, asset_id, inform_server, deactivate_similar);
}
void updateMenuItemsVisibility(LLContextMenu* menu)
{
bool bp_selected = false; // true if body parts selected
bool clothes_selected = false;
bool attachments_selected = false;
// See what types of wearables are selected.
for (uuid_vec_t::const_iterator it = mUUIDs.begin(); it != mUUIDs.end(); ++it)
{
LLViewerInventoryItem* item = gInventory.getItem(*it);
if (!item)
{
llwarns << "Invalid item" << llendl;
continue;
}
LLAssetType::EType type = item->getType();
if (type == LLAssetType::AT_CLOTHING)
{
clothes_selected = true;
}
else if (type == LLAssetType::AT_BODYPART)
{
bp_selected = true;
}
else if (type == LLAssetType::AT_OBJECT)
{
attachments_selected = true;
}
}
// Enable/disable some menu items depending on the selection.
bool allow_detach = !bp_selected && !clothes_selected && attachments_selected;
bool allow_take_off = !bp_selected && clothes_selected && !attachments_selected;
// [SL:KB] - Patch: Inventory-AttachmentEdit - Checked: 2010-09-04 (Catznip-2.2.0a) | Added: Catznip-2.1.2a
menu->setItemVisible("edit_item", bp_selected || clothes_selected || attachments_selected);
menu->setItemEnabled("edit_item", 1 == mUUIDs.size());
// [/SL:KB]
menu->setItemVisible("take_off", allow_take_off);
menu->setItemVisible("detach", allow_detach);
// [SL:KB] - Patch: Inventory-AttachmentEdit - Checked: 2010-09-04 (Catznip-2.2.0a) | Added: Catznip-2.1.2a
menu->setItemVisible("take_off_or_detach", (!allow_detach) && (!allow_take_off) && (clothes_selected) && (attachments_selected));
// [/SL:KB]
menu->setItemVisible("edit_outfit_separator", allow_take_off || allow_detach);
}
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 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);
}
}
void updateMenuItemsVisibility(LLContextMenu* menu)
{
bool bp_selected = false; // true if body parts selected
bool clothes_selected = false;
bool attachments_selected = false;
// See what types of wearables are selected.
for (uuid_vec_t::const_iterator it = mUUIDs.begin(); it != mUUIDs.end(); ++it)
{
LLViewerInventoryItem* item = gInventory.getItem(*it);
if (!item)
{
llwarns << "Invalid item" << llendl;
continue;
}
LLAssetType::EType type = item->getType();
if (type == LLAssetType::AT_CLOTHING)
{
clothes_selected = true;
}
else if (type == LLAssetType::AT_BODYPART)
{
bp_selected = true;
}
else if (type == LLAssetType::AT_OBJECT)
{
attachments_selected = true;
}
}
// Enable/disable some menu items depending on the selection.
bool allow_detach = !bp_selected && !clothes_selected && attachments_selected;
bool allow_take_off = !bp_selected && clothes_selected && !attachments_selected;
menu->setItemVisible("take_off", allow_take_off);
menu->setItemVisible("detach", allow_detach);
menu->setItemVisible("edit_outfit_separator", allow_take_off || allow_detach);
}
// 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()) );
}
void ImportTracker::get_update(S32 newid, BOOL justCreated, BOOL createSelected)
{
switch (state)
{
//lgg crap
case WAND:
if(justCreated && createSelected)
{
numberExpected--;
if(numberExpected<=0)
state=IDLE;
LLMessageSystem* msg = gMessageSystem;
msg->newMessageFast(_PREHASH_ObjectImage);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, (U32)newid);
msg->addStringFast(_PREHASH_MediaURL, NULL);
LLPrimitive obj;
obj.setNumTEs(U8(10));
S32 shinnyLevel = 0;
static std::string* shinystr = rebind_llcontrol<std::string>("EmeraldBuildPrefs_Shiny", &gSavedSettings, true);
if(*shinystr == "None") shinnyLevel = 0;
if(*shinystr == "Low") shinnyLevel = 1;
if(*shinystr == "Medium") shinnyLevel = 2;
if(*shinystr == "High") shinnyLevel = 3;
for (int i = 0; i < 10; i++)
{
static std::string* buildpreftex = rebind_llcontrol<std::string>("EmeraldBuildPrefs_Texture", &gSavedSettings, true);
LLTextureEntry tex = LLTextureEntry(LLUUID(*buildpreftex));
tex.setColor(gSavedSettings.getColor4("EmeraldBuildPrefs_Color"));
tex.setAlpha(1.0 - ((gSavedSettings.getF32("EmeraldBuildPrefs_Alpha")) / 100.0));
tex.setGlow(gSavedSettings.getF32("EmeraldBuildPrefs_Glow"));
if(gSavedSettings.getBOOL("EmeraldBuildPrefs_FullBright"))
{
tex.setFullbright(TEM_FULLBRIGHT_MASK);
}
tex.setShiny((U8) shinnyLevel & TEM_SHINY_MASK);
obj.setTE(U8(i), tex);
}
obj.packTEMessage(gMessageSystem);
msg->sendReliable(gAgent.getRegion()->getHost());
msg->newMessage("ObjectFlagUpdate");
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->addU32Fast(_PREHASH_ObjectLocalID, (U32)newid );
msg->addBOOLFast(_PREHASH_UsePhysics, gSavedSettings.getBOOL("EmeraldBuildPrefs_Physical"));
msg->addBOOL("IsTemporary", gSavedSettings.getBOOL("EmeraldBuildPrefs_Temporary"));
msg->addBOOL("IsPhantom", gSavedSettings.getBOOL("EmeraldBuildPrefs_Phantom") );
msg->addBOOL("CastsShadows", true );
msg->sendReliable(gAgent.getRegion()->getHost());
if(gSavedSettings.getBOOL("EmeraldBuildPrefs_EmbedItem"))
{
LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem((LLUUID)gSavedSettings.getString("EmeraldBuildPrefs_Item"));
LLViewerObject* objectp = find((U32)newid);
if(objectp)
if(item)
{
if(item->getType()==LLAssetType::AT_LSL_TEXT)
{
LLToolDragAndDrop::dropScript(objectp,
item,
TRUE,
LLToolDragAndDrop::SOURCE_AGENT,
gAgent.getID());
}else
{
LLToolDragAndDrop::dropInventory(objectp,item,LLToolDragAndDrop::SOURCE_AGENT,gAgent.getID());
}
}
}
//llinfos << "LGG SENDING CUBE TEXTURE.." << llendl;
}
break;
case BUILDING:
if (justCreated && (int)localids.size() < linkset.size())
{
localids.push_back(newid);
localids.sort();
localids.unique();
linkset[localids.size() -1]["LocalID"] = newid;
LLSD prim = linkset[localids.size() -1];
//MAKERIGHT
if (!(prim).has("Updated"))
{
++updated;
send_shape(prim);
send_image(prim);
send_extras(prim);
send_namedesc(prim);
send_vectors(prim,updated);
send_properties(prim, updated);
send_inventory(prim);
(prim)["Updated"] = true;
}
if ((int)localids.size() < linkset.size())
{
plywood_above_head();
return;
}
else
{
if (updated >= linkset.size())
{
updated=0;
llinfos << "FINISHED BUILDING, LINKING.." << llendl;
state = LINKING;
link();
}
}
}
break;
case LINKING:
link();
break;
}
}
void LLWearableItemsList::ContextMenu::updateItemsVisibility(LLContextMenu* menu)
{
if (!menu)
{
llwarns << "Invalid menu" << llendl;
return;
}
const uuid_vec_t& ids = mUUIDs; // selected items IDs
U32 mask = 0; // mask of selected items' types
U32 n_items = ids.size(); // number of selected items
U32 n_worn = 0; // number of worn items among the selected ones
U32 n_already_worn = 0; // number of items worn of same type as selected items
U32 n_links = 0; // number of links among the selected items
U32 n_editable = 0; // number of editable items among the selected ones
for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
{
LLUUID id = *it;
LLViewerInventoryItem* item = gInventory.getItem(id);
if (!item)
{
llwarns << "Invalid item" << llendl;
// *NOTE: the logic below may not work in this case
continue;
}
updateMask(mask, item->getType());
const LLWearableType::EType wearable_type = item->getWearableType();
const bool is_link = item->getIsLinkType();
const bool is_worn = get_is_item_worn(id);
const bool is_editable = gAgentWearables.isWearableModifiable(id);
const bool is_already_worn = gAgentWearables.selfHasWearable(wearable_type);
if (is_worn)
{
++n_worn;
}
if (is_editable)
{
++n_editable;
}
if (is_link)
{
++n_links;
}
if (is_already_worn)
{
++n_already_worn;
}
} // for
bool standalone = mParent ? mParent->isStandalone() : false;
// *TODO: eliminate multiple traversals over the menu items
setMenuItemVisible(menu, "wear_wear", n_already_worn == 0 && n_worn == 0);
setMenuItemEnabled(menu, "wear_wear", n_already_worn == 0 && n_worn == 0);
setMenuItemVisible(menu, "wear_add", mask == MASK_CLOTHING && n_worn == 0 && n_already_worn != 0);
setMenuItemEnabled(menu, "wear_add", n_items == 1 && canAddWearable(ids.front()) && n_already_worn != 0);
setMenuItemVisible(menu, "wear_replace", n_worn == 0 && n_already_worn != 0);
//visible only when one item selected and this item is worn
setMenuItemVisible(menu, "edit", !standalone && mask & (MASK_CLOTHING|MASK_BODYPART) && n_worn == n_items && n_worn == 1);
setMenuItemEnabled(menu, "edit", n_editable == 1 && n_worn == 1 && n_items == 1);
setMenuItemVisible(menu, "create_new", mask & (MASK_CLOTHING|MASK_BODYPART) && n_items == 1);
setMenuItemVisible(menu, "show_original", !standalone);
setMenuItemEnabled(menu, "show_original", n_items == 1 && n_links == n_items);
setMenuItemVisible(menu, "take_off", mask == MASK_CLOTHING && n_worn == n_items);
setMenuItemVisible(menu, "detach", mask == MASK_ATTACHMENT && n_worn == n_items);
setMenuItemVisible(menu, "take_off_or_detach", mask == (MASK_ATTACHMENT|MASK_CLOTHING));
setMenuItemEnabled(menu, "take_off_or_detach", n_worn == n_items);
setMenuItemVisible(menu, "object_profile", !standalone);
setMenuItemEnabled(menu, "object_profile", n_items == 1);
setMenuItemVisible(menu, "--no options--", FALSE);
setMenuItemEnabled(menu, "--no options--", FALSE);
// Populate or hide the "Attach to..." / "Attach to HUD..." submenus.
if (mask == MASK_ATTACHMENT && n_worn == 0)
{
LLViewerAttachMenu::populateMenus("wearable_attach_to", "wearable_attach_to_hud");
}
else
{
setMenuItemVisible(menu, "wearable_attach_to", false);
setMenuItemVisible(menu, "wearable_attach_to_hud", false);
}
if (mask & MASK_UNKNOWN)
{
llwarns << "Non-wearable items passed." << llendl;
}
U32 num_visible_items = 0;
for (U32 menu_item_index = 0; menu_item_index < menu->getItemCount(); ++menu_item_index)
{
const LLMenuItemGL* menu_item = menu->getItem(menu_item_index);
if (menu_item && menu_item->getVisible())
{
num_visible_items++;
}
}
if (num_visible_items == 0)
{
setMenuItemVisible(menu, "--no options--", TRUE);
}
}
void ImportTracker::get_update(S32 newid, BOOL justCreated, BOOL createSelected)
{
switch (state)
{
//lgg crap to change remaining prim parameters from the ascent system build preferences subtab
case WAND:
if(justCreated && createSelected)
{
numberExpected--;
if(numberExpected<=0)
state=IDLE;
LLMessageSystem* msg = gMessageSystem;
msg->newMessageFast(_PREHASH_ObjectImage);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, (U32)newid);
msg->addStringFast(_PREHASH_MediaURL, NULL);
//sets texture stuff
LLPrimitive obj;
obj.setNumTEs(U8(10));
S32 shinnyLevel = 0;
static LLCachedControl<std::string> sshinystr(gSavedSettings, "EmeraldBuildPrefs_Shiny");
std::string shinystr = sshinystr;
//if(shinystr == "None") shinnyLevel = 0; //We're already 0.
if(shinystr == "Low") shinnyLevel = 1;
else if(shinystr == "Medium") shinnyLevel = 2;
else if(shinystr == "High") shinnyLevel = 3;
for (int i = 0; i < 10; i++)
{
LLTextureEntry tex = LLTextureEntry(LLUUID(gSavedSettings.getString("EmeraldBuildPrefs_Texture")));
tex.setColor(gSavedSettings.getColor4("EmeraldBuildPrefs_Color"));
tex.setAlpha(1.0 - ((gSavedSettings.getF32("EmeraldBuildPrefs_Alpha")) / 100.0));
tex.setGlow(gSavedSettings.getF32("EmeraldBuildPrefs_Glow"));
if(gSavedSettings.getBOOL("EmeraldBuildPrefs_FullBright"))
{
tex.setFullbright(TEM_FULLBRIGHT_MASK);
}
tex.setShiny((U8) shinnyLevel & TEM_SHINY_MASK);
obj.setTE(U8(i), tex);
}
obj.packTEMessage(gMessageSystem);
msg->sendReliable(gAgent.getRegion()->getHost());
//sets some object parameters
msg->newMessage("ObjectFlagUpdate");
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->addU32Fast(_PREHASH_ObjectLocalID, (U32)newid );
msg->addBOOLFast(_PREHASH_UsePhysics, gSavedSettings.getBOOL("EmeraldBuildPrefs_Physical"));
msg->addBOOLFast(_PREHASH_IsTemporary, gSavedSettings.getBOOL("EmeraldBuildPrefs_Temporary"));
msg->addBOOLFast(_PREHASH_IsPhantom, gSavedSettings.getBOOL("EmeraldBuildPrefs_Phantom") );
msg->addBOOL("CastsShadows", false );
msg->sendReliable(gAgent.getRegion()->getHost());
if(gSavedSettings.getBOOL("EmeraldBuildPrefs_EmbedItem"))
{
LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem((LLUUID)gSavedPerAccountSettings.getString("EmeraldBuildPrefs_Item"));
LLViewerObject* objectp = find((U32)newid);
if(objectp)
if(item)
{
if(item->getType()==LLAssetType::AT_LSL_TEXT)
{
LLToolDragAndDrop::dropScript(objectp,
item,
TRUE,
LLToolDragAndDrop::SOURCE_AGENT,
gAgent.getID());
}else
{
LLToolDragAndDrop::dropInventory(objectp,item,LLToolDragAndDrop::SOURCE_AGENT,gAgent.getID());
}
}
}
msg->newMessageFast(_PREHASH_ObjectPermissions);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_HeaderData);
msg->addBOOLFast(_PREHASH_Override, FALSE);
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, (U32)newid);
msg->addU8Fast(_PREHASH_Field, PERM_NEXT_OWNER);
msg->addU8Fast(_PREHASH_Set, PERM_SET_TRUE);
U32 flags = 0;
if ( gSavedSettings.getBOOL("NextOwnerCopy") )
{
flags |= PERM_COPY;
}
if ( gSavedSettings.getBOOL("NextOwnerModify") )
{
flags |= PERM_MODIFY;
}
bool next_owner_trans;
if ( next_owner_trans = gSavedSettings.getBOOL("NextOwnerTransfer") )
{
flags |= PERM_TRANSFER;
}
msg->addU32Fast(_PREHASH_Mask, flags);
msg->sendReliable(gAgent.getRegion()->getHost());
if (!next_owner_trans) // Workaround transfer being true by default.
{
msg->newMessageFast(_PREHASH_ObjectPermissions);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgentID);
msg->addUUIDFast(_PREHASH_SessionID, gAgentSessionID);
msg->nextBlockFast(_PREHASH_HeaderData);
msg->addBOOLFast(_PREHASH_Override, false);
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, (U32)newid);
msg->addU8Fast(_PREHASH_Field, PERM_NEXT_OWNER);
msg->addU8Fast(_PREHASH_Set, PERM_SET_FALSE);
msg->addU32Fast(_PREHASH_Mask, PERM_TRANSFER);
msg->sendReliable(gAgent.getRegion()->getHost());
}
//llinfos << "LGG SENDING CUBE TEXTURE.." << llendl;
}
break;
/* case BUILDING:
if (justCreated && (int)localids.size() < linkset.size())
{
localids.push_back(newid);
localids.sort();
localids.unique();
linkset[localids.size() -1]["LocalID"] = newid;
LLSD prim = linkset[localids.size() -1];
//MAKERIGHT
if (!(prim).has("Updated"))
{
++updated;
send_shape(prim);
send_image(prim);
send_extras(prim);
send_namedesc(prim);
send_vectors(prim,updated);
send_properties(prim, updated);
send_inventory(prim);
(prim)["Updated"] = true;
}
if ((int)localids.size() < linkset.size())
{
plywood_above_head();
return;
}
else
{
if (updated >= linkset.size())
{
updated=0;
llinfos << "FINISHED BUILDING, LINKING.." << llendl;
state = LINKING;
link();
}
}
}
break;
case LINKING:
link();
break;*/
}
}
void LLLocalInventory::open(LLUUID item_id)
{
LLViewerInventoryItem* item = gInventory.getItem(item_id);
if(!item)
{
llwarns << "Trying to open non-existent item" << llendl;
return;
}
LLAssetType::EType type = item->getType();
if(type == LLAssetType::AT_SOUND)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewSoundRect");
rect.translate(left - rect.mLeft, top - rect.mTop);
LLPreviewSound* floaterp;
floaterp = new LLPreviewSound("Preview sound",
rect,
"",
item_id);
floaterp->setFocus(TRUE);
gFloaterView->adjustToFitScreen(floaterp, FALSE);
}
else if(type == LLAssetType::AT_ANIMATION)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewAnimRect");
rect.translate(left - rect.mLeft, top - rect.mTop);
LLPreviewAnim* floaterp;
floaterp = new LLPreviewAnim("Preview anim",
rect,
"",
item_id,
LLPreviewAnim::NONE);
floaterp->setFocus(TRUE);
gFloaterView->adjustToFitScreen(floaterp, FALSE);
}
else if(type == LLAssetType::AT_TEXTURE)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewTextureRect");
rect.translate( left - rect.mLeft, top - rect.mTop );
LLPreviewTexture* preview;
preview = new LLPreviewTexture("preview texture",
rect,
"Preview texture",
item_id,
LLUUID::null,
FALSE);
//preview->setSourceID(source_id);
preview->setFocus(TRUE);
gFloaterView->adjustToFitScreen(preview, FALSE);
}
else if(type == LLAssetType::AT_GESTURE)
{
// If only the others were like this
LLPreviewGesture::show("preview gesture", item_id, LLUUID::null, TRUE);
}
else if(type == LLAssetType::AT_LANDMARK)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewLandmarkRect");
rect.translate( left - rect.mLeft, top - rect.mTop );
LLPreviewLandmark* preview;
preview = new LLPreviewLandmark("preview landmark",
rect,
"Preview landmark",
item_id);
preview->setFocus(TRUE);
gFloaterView->adjustToFitScreen(preview, FALSE);
}
else
{
llwarns << "Dunno how to open type " << type << llendl;
}
}
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();
}
}
// static
void LLFloaterProperties::onCommitPermissions()
{
//llinfos << "LLFloaterProperties::onCommitPermissions()" << llendl;
LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem();
if(!item) return;
LLPermissions perm(item->getPermissions());
LLCheckBoxCtrl* CheckShareWithGroup = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
if(CheckShareWithGroup)
{
perm.setGroupBits(gAgent.getID(), gAgent.getGroupID(),
CheckShareWithGroup->get(),
PERM_MODIFY | PERM_MOVE | PERM_COPY);
}
LLCheckBoxCtrl* CheckEveryoneCopy = getChild<LLCheckBoxCtrl>("CheckEveryoneCopy");
if(CheckEveryoneCopy)
{
perm.setEveryoneBits(gAgent.getID(), gAgent.getGroupID(),
CheckEveryoneCopy->get(), PERM_COPY);
}
LLCheckBoxCtrl* CheckNextOwnerModify = getChild<LLCheckBoxCtrl>("CheckNextOwnerModify");
if(CheckNextOwnerModify)
{
perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
CheckNextOwnerModify->get(), PERM_MODIFY);
}
LLCheckBoxCtrl* CheckNextOwnerCopy = getChild<LLCheckBoxCtrl>("CheckNextOwnerCopy");
if(CheckNextOwnerCopy)
{
perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
CheckNextOwnerCopy->get(), PERM_COPY);
}
LLCheckBoxCtrl* CheckNextOwnerTransfer = getChild<LLCheckBoxCtrl>("CheckNextOwnerTransfer");
if(CheckNextOwnerTransfer)
{
perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
CheckNextOwnerTransfer->get(), PERM_TRANSFER);
}
if(perm != item->getPermissions()
&& item->isFinished())
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
new_item->setPermissions(perm);
U32 flags = new_item->getFlags();
// If next owner permissions have changed (and this is an object)
// then set the slam permissions flag so that they are applied on rez.
if((perm.getMaskNextOwner()!=item->getPermissions().getMaskNextOwner())
&& (item->getType() == LLAssetType::AT_OBJECT))
{
flags |= LLInventoryItemFlags::II_FLAGS_OBJECT_SLAM_PERM;
}
// If everyone permissions have changed (and this is an object)
// then set the overwrite everyone permissions flag so they
// are applied on rez.
if ((perm.getMaskEveryone()!=item->getPermissions().getMaskEveryone())
&& (item->getType() == LLAssetType::AT_OBJECT))
{
flags |= LLInventoryItemFlags::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
}
// If group permissions have changed (and this is an object)
// then set the overwrite group permissions flag so they
// are applied on rez.
if ((perm.getMaskGroup()!=item->getPermissions().getMaskGroup())
&& (item->getType() == LLAssetType::AT_OBJECT))
{
flags |= LLInventoryItemFlags::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
}
new_item->setFlags(flags);
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);
}
}
}
else
{
// need to make sure we don't just follow the click
refresh();
}
}
// Checked: 2010-09-18 (RLVa-1.2.1a) | Modified: RLVa-1.2.1a
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;
}
//
// Process removals
//
// Wearables
if (m_remWearables.size())
{
for (std::list<const LLWearable*>::const_iterator itWearable = m_remWearables.begin(); itWearable != m_remWearables.end(); ++itWearable)
gAgent.removeWearable((*itWearable)->getType());
m_remWearables.clear();
}
// Gestures
if (m_remGestures.size())
{
for (S32 idxGesture = 0, cntGesture = m_remGestures.count(); idxGesture < cntGesture; idxGesture++)
{
LLViewerInventoryItem* pItem = m_remGestures.get(idxGesture);
gGestureManager.deactivateGesture(pItem->getUUID());
gInventory.updateItem(pItem);
gInventory.notifyObservers();
}
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)
gMessageSystem->newMessage("ObjectDetach");
gMessageSystem->nextBlockFast(_PREHASH_AgentData);
gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
for (std::list<const LLViewerObject*>::const_iterator itAttachObj = m_remAttachments.begin();
itAttachObj != m_remAttachments.end(); ++itAttachObj)
{
gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, (*itAttachObj)->getLocalID());
}
gMessageSystem->sendReliable(gAgent.getRegionHost());
m_remAttachments.clear();
}
//
// Process additions
//
// Process wearables
if (m_addWearables.size())
{
// [See wear_inventory_category_on_avatar_step2()]
LLWearableHoldingPattern* pWearData = new LLWearableHoldingPattern(TRUE);
// We need to populate 'pWearData->mFoundList' before doing anything else because (some of) the assets might already be available
for (addwearables_map_t::const_iterator itAddWearables = m_addWearables.begin();
itAddWearables != m_addWearables.end(); ++itAddWearables)
{
const LLInventoryModel::item_array_t& wearItems = itAddWearables->second;
RLV_VERIFY(1 == wearItems.count());
if (wearItems.count() > 0)
{
LLViewerInventoryItem* pItem = wearItems.get(0);
if ( (pItem) && ((LLAssetType::AT_BODYPART == pItem->getType()) || (LLAssetType::AT_CLOTHING == pItem->getType())) )
{
LLFoundData* pFound = new LLFoundData(pItem->getUUID(), pItem->getAssetUUID(), pItem->getName(), pItem->getType());
pWearData->mFoundList.push_front(pFound);
}
}
}
if (!pWearData->mFoundList.size())
{
delete pWearData;
return;
}
// If all the assets are available locally then "pWearData" will be freed *before* the last "gWearableList.getAsset()" call returns
bool fContinue = true; LLWearableHoldingPattern::found_list_t::const_iterator itWearable = pWearData->mFoundList.begin();
while ( (fContinue) && (itWearable != pWearData->mFoundList.end()) )
{
const LLFoundData* pFound = *itWearable;
++itWearable;
fContinue = (itWearable != pWearData->mFoundList.end());
gWearableList.getAsset(pFound->mAssetID, pFound->mName, pFound->mAssetType, wear_inventory_category_on_avatar_loop, (void*)pWearData);
}
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();
// Process gestures
if (m_addGestures.size())
{
gGestureManager.activateGestures(m_addGestures);
for (S32 idxGesture = 0, cntGesture = m_addGestures.count(); idxGesture < cntGesture; idxGesture++)
gInventory.updateItem(m_addGestures.get(idxGesture));
gInventory.notifyObservers();
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()) );
}
// 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 FSCommon::applyDefaultBuildPreferences(LLViewerObject* object)
{
if (!object)
{
return;
}
LLTextureEntry texture_entry;
texture_entry.setID(LLUUID(gSavedSettings.getString("FSDefaultObjectTexture")));
texture_entry.setColor(gSavedSettings.getColor4("FSBuildPrefs_Color"));
texture_entry.setAlpha((100.f - gSavedSettings.getF32("FSBuildPrefs_Alpha")) / 100.f);
texture_entry.setGlow(gSavedSettings.getF32("FSBuildPrefs_Glow"));
if(gSavedSettings.getBOOL("FSBuildPrefs_FullBright"))
{
texture_entry.setFullbright(TEM_FULLBRIGHT_MASK);
}
U8 shiny = 0; // Default none
std::string shininess = gSavedSettings.getString("FSBuildPrefs_Shiny");
if(shininess == "Low")
{
shiny = 1;
}
else if(shininess == "Medium")
{
shiny = 2;
}
else if(shininess == "High")
{
shiny = 3;
}
texture_entry.setShiny(shiny);
for(U8 face = 0; face < object->getNumTEs(); face++)
{
object->setTE(face, texture_entry);
}
object->sendTEUpdate();
if(gSavedSettings.getBOOL("FSBuildPrefs_EmbedItem"))
{
LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem((LLUUID)gSavedSettings.getString("FSBuildPrefs_Item"));
if(item)
{
if (item->getType() == LLAssetType::AT_LSL_TEXT)
{
LLToolDragAndDrop::dropScript(object, item, TRUE,
LLToolDragAndDrop::SOURCE_AGENT,
gAgentID);
}
else
{
LLToolDragAndDrop::dropInventory(object, item,
LLToolDragAndDrop::SOURCE_AGENT,
gAgentID);
}
}
}
U32 object_local_id = object->getLocalID();
gMessageSystem->newMessageFast(_PREHASH_ObjectPermissions);
gMessageSystem->nextBlockFast(_PREHASH_AgentData);
gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
gMessageSystem->nextBlockFast(_PREHASH_HeaderData);
gMessageSystem->addBOOLFast(_PREHASH_Override, (BOOL)FALSE);
gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, object_local_id);
gMessageSystem->addU8Fast(_PREHASH_Field, PERM_NEXT_OWNER);
gMessageSystem->addBOOLFast(_PREHASH_Set, gSavedSettings.getBOOL("NextOwnerModify"));
gMessageSystem->addU32Fast(_PREHASH_Mask, PERM_MODIFY);
gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, object_local_id);
gMessageSystem->addU8Fast(_PREHASH_Field, PERM_NEXT_OWNER);
gMessageSystem->addBOOLFast(_PREHASH_Set, gSavedSettings.getBOOL("NextOwnerCopy"));
gMessageSystem->addU32Fast(_PREHASH_Mask, PERM_COPY);
gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, object_local_id);
gMessageSystem->addU8Fast(_PREHASH_Field, PERM_NEXT_OWNER);
gMessageSystem->addBOOLFast(_PREHASH_Set, gSavedSettings.getBOOL("NextOwnerTransfer"));
gMessageSystem->addU32Fast(_PREHASH_Mask, PERM_TRANSFER);
gMessageSystem->sendReliable(object->getRegion()->getHost());
gMessageSystem->newMessage(_PREHASH_ObjectFlagUpdate);
gMessageSystem->nextBlockFast(_PREHASH_AgentData);
gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, object_local_id);
gMessageSystem->addBOOLFast(_PREHASH_UsePhysics, gSavedSettings.getBOOL("FSBuildPrefs_Physical"));
gMessageSystem->addBOOL(_PREHASH_IsTemporary, gSavedSettings.getBOOL("FSBuildPrefs_Temporary"));
gMessageSystem->addBOOL(_PREHASH_IsPhantom, gSavedSettings.getBOOL("FSBuildPrefs_Phantom"));
gMessageSystem->addBOOL("CastsShadows", FALSE );
gMessageSystem->sendReliable(object->getRegion()->getHost());
}
