1 files changed, 79 insertions, 94 deletions

diff --git a/linden/indra/newview/rlvhandler.cpp b/linden/indra/newview/rlvhandler.cpp
index 2915002..6044aa9 100644
--- a/linden/indra/newview/rlvhandler.cpp
+++ b/linden/indra/newview/rlvhandler.cpp
@@ -1,6 +1,7 @@
 #include "llviewerprecompiledheaders.h"
 #include "llagent.h"
 #include "lldrawpoolalpha.h"
+#include "llfirstuse.h"
 #include "llfloaterbeacons.h"
 #include "llfloaterchat.h"
 #include "llfloaterdaycycle.h"
@@ -93,10 +94,10 @@ inline bool rlvIsWearingItem(const LLInventoryItem* pItem)
 static bool rlvParseNotifyOption(const std::string& strOption, S32& nChannel, std::string& strFilter)
 {
         boost_tokenizer tokens(strOption, boost::char_separator<char>(";", "", boost::keep_empty_tokens));
-        boost_tokenizer::iterator itTok = tokens.begin();
+        boost_tokenizer::const_iterator itTok = tokens.begin();
 
         // Extract and sanity check the first token (required) which is the channel
-        if ( (itTok == tokens.end()) || (!LLStringUtil::convertToS32(*itTok, nChannel)) || (!rlvIsValidChannel(nChannel)) )
+        if ( (itTok == tokens.end()) || (!LLStringUtil::convertToS32(*itTok, nChannel)) || (!rlvIsValidReplyChannel(nChannel)) )
                 return false;
 
         // Second token (optional) is the filter
@@ -274,7 +275,7 @@ bool RlvHandler::isDetachableExcept(S32 idxAttachPt, LLViewerObject *pObj) const
         return true;
 }
 
-// Checked: 2009-05-31 (RLVa-0.2.0e) | Modified: RLVa-0.2.0e
+// Checked: 2009-09-06 (RLVa-1.0.2b) | Modified: RLVa-1.0.2b
 bool RlvHandler::setDetachable(S32 idxAttachPt, const LLUUID& idRlvObj, bool fDetachable)
 {
         // Sanity check - make sure it's an object we know about
@@ -284,20 +285,16 @@ bool RlvHandler::setDetachable(S32 idxAttachPt, const LLUUID& idRlvObj, bool fDe
 
         if (!fDetachable)
         {
-                // Sanity check - make sure it's not already marked undetachable by this object (NOTE: m_Attachments is a *multimap*, not a map)
-                for (rlv_detach_map_t::const_iterator itAttach = m_Attachments.lower_bound(idxAttachPt), 
-                                endAttach = m_Attachments.upper_bound(idxAttachPt); itAttach != endAttach; ++itAttach)
-                {
-                        if (itObj->second.m_UUID == itAttach->second)
-                                return false;
-                }
+                #ifdef RLV_EXPERIMENTAL_FIRSTUSE
+                        LLFirstUse::useRlvDetach();
+                #endif // RLV_EXPERIMENTAL_FIRSTUSE
 
+                // NOTE: m_Attachments can contain duplicate <idxAttachPt, idRlvObj> pairs (ie @detach:spine=n,detach=n from an attachment on spine)
                 m_Attachments.insert(std::pair<S32, LLUUID>(idxAttachPt, itObj->second.m_UUID));
                 return true;
         }
         else
         {
-                // NOTE: m_Attachments is a *multimap*, not a map
                 for (rlv_detach_map_t::iterator itAttach = m_Attachments.lower_bound(idxAttachPt), 
                                 endAttach = m_Attachments.upper_bound(idxAttachPt); itAttach != endAttach; ++itAttach)
                 {
@@ -325,11 +322,11 @@ bool RlvHandler::setDetachable(S32 idxAttachPt, const LLUUID& idRlvObj, bool fDe
                         LLViewerInventoryItem* pItem = gInventory.getItem(idItem);
                         if (pItem)
                         {
-                                if (-1 != pItem->getName().find(RLV_FOLDER_FLAG_NOSTRIP))
+                                if (std::string::npos != pItem->getName().find(RLV_FOLDER_FLAG_NOSTRIP))
                                         return false;
 
                                 LLViewerInventoryCategory* pFolder = gInventory.getCategory(pItem->getParentUUID());
-                                if ( (pFolder) && (-1 != pFolder->getName().find(RLV_FOLDER_FLAG_NOSTRIP)) )
+                                if ( (pFolder) && (std::string::npos != pFolder->getName().find(RLV_FOLDER_FLAG_NOSTRIP)) )
                                         return false;
                         }
                 }
@@ -477,6 +474,10 @@ BOOL RlvHandler::processCommand(const LLUUID& uuid, const std::string& strCmd, b
                                 }
                         }
                         break;
+                case RLV_TYPE_CLEAR:
+                        fRet = processClearCommand(uuid, rlvCmd);
+                        notifyBehaviourObservers(rlvCmd, !fFromObj);
+                        break;
                 case RLV_TYPE_FORCE:            // Checked:
                         fRet = processForceCommand(uuid, rlvCmd);
                         break;
@@ -484,32 +485,6 @@ BOOL RlvHandler::processCommand(const LLUUID& uuid, const std::string& strCmd, b
                         fRet = processReplyCommand(uuid, rlvCmd);
                         break;
                 case RLV_TYPE_UNKNOWN:          // Checked:
-                        {
-                                if ("clear" == rlvCmd.getBehaviour())
-                                {
-                                        const std::string& strFilter = rlvCmd.getParam(); std::string strCmdRem;
-
-                                        rlv_object_map_t::const_iterator itObj = m_Objects.find(uuid);
-                                        if (itObj != m_Objects.end())   // No sense in @clear'ing if we don't have any commands for this object
-                                        {
-                                                const RlvObject& rlvObj = itObj->second; bool fContinue = true;
-                                                for (rlv_command_list_t::const_iterator itCmd = rlvObj.m_Commands.begin(), itCurCmd; 
-                                                                ((fContinue) && (itCmd != rlvObj.m_Commands.end())); )
-                                                {
-                                                        itCurCmd = itCmd++;             // Point itCmd ahead so it won't get invalidated if/when we erase a command
-
-                                                        const RlvCommand& rlvCmdRem = *itCurCmd;
-                                                        if ( (strFilter.empty()) || (-1 != rlvCmdRem.asString().find(strFilter)) )
-                                                        {
-                                                                fContinue = (rlvObj.m_Commands.size() > 1); // rlvObj will become invalid once we remove the last command
-                                                                strCmdRem = rlvCmdRem.getBehaviour() + ":" + rlvCmdRem.getOption() + "=y";
-                                                                processCommand(uuid, strCmdRem, false);
-                                                        }
-                                                }
-                                                fRet = TRUE;
-                                        }
-                                }
-                        }
                         break;
                 #ifdef LL_GNUC
                 default:
@@ -671,6 +646,13 @@ BOOL RlvHandler::processAddCommand(const LLUUID& uuid, const RlvCommand& rlvCmd)
                                 LLFloaterChat::getInstance()->childSetVisible("active_speakers_panel", false);
                         }
                         break;
+                case RLV_BHVR_FARTOUCH:
+                        {
+                                #ifdef RLV_EXPERIMENTAL_FIRSTUSE
+                                        LLFirstUse::useRlvFartouch();
+                                #endif // RLV_EXPERIMENTAL_FIRSTUSE
+                        }
+                        break;
                 case RLV_BHVR_FLY:                                      // @fly=n                                       - Checked: 2009-07-05 (RLVa-1.0.0c)
                         {
                                 // If currently flying, simulate clicking the Fly button [see LLToolBar::onClickFly()]
@@ -780,22 +762,15 @@ BOOL RlvHandler::processRemoveCommand(const LLUUID& uuid, const RlvCommand& rlvC
         {
                 case RLV_BHVR_DETACH:                           // @detach[:<option>]=y         - Checked: 2009-08-04 (RLVa-1.0.1d) | Modified: RLVa-1.0.1d
                         {
-                                S32 idxAttachPt;
+                                S32 idxAttachPt = 0;
                                 if (strOption.empty())                                                                                          // @detach=y
                                 {
-                                        // The object may or may not (if it got detached) still exist so clean up the hard way
-                                        if (m_Objects.find(uuid) != m_Objects.end())
-                                        {
-                                                for (rlv_detach_map_t::const_iterator itAttach = m_Attachments.begin(), endAttach = m_Attachments.end();
-                                                        itAttach != endAttach; ++itAttach)
-                                                {
-                                                        if (itAttach->second == uuid)
-                                                        {
-                                                                setDetachable(itAttach->first, uuid, true); // <- invalidates our iterators on return
-                                                                break;
-                                                        }
-                                                }
-                                        }
+                                        // The object may or may not (if it got detached) still exist
+                                        rlv_object_map_t::const_iterator itObj = m_Objects.find(uuid);
+                                        if (itObj != m_Objects.end())
+                                                idxAttachPt = itObj->second.m_idxAttachPt;
+                                        if (idxAttachPt)
+                                                setDetachable(idxAttachPt, uuid, true);
                                 }
                                 else if ((idxAttachPt = getAttachPointIndex(strOption, true)))          // @detach:<attachpt>=y
                                 {
@@ -915,6 +890,35 @@ BOOL RlvHandler::processRemoveCommand(const LLUUID& uuid, const RlvCommand& rlvC
         return TRUE; // Remove commands don't fail, doesn't matter what we return here
 }
 
+BOOL RlvHandler::processClearCommand(const LLUUID& idObj, const RlvCommand& rlvCmd)
+{
+        const std::string& strFilter = rlvCmd.getParam(); std::string strCmdRem;
+
+        rlv_object_map_t::const_iterator itObj = m_Objects.find(idObj);
+        if (itObj != m_Objects.end())   // No sense in clearing if we don't have any commands for this object
+        {
+                const RlvObject& rlvObj = itObj->second; bool fContinue = true;
+                for (rlv_command_list_t::const_iterator itCmd = rlvObj.m_Commands.begin(), itCurCmd;
+                                ((fContinue) && (itCmd != rlvObj.m_Commands.end())); )
+                {
+                        itCurCmd = itCmd++;             // Point itCmd ahead so it won't get invalidated if/when we erase a command
+
+                        const RlvCommand& rlvCmdRem = *itCurCmd; strCmdRem = rlvCmdRem.asString();
+                        if ( (strFilter.empty()) || (std::string::npos != strCmdRem.find(strFilter)) )
+                        {
+                                fContinue = (rlvObj.m_Commands.size() > 1); // rlvObj will become invalid once we remove the last command
+                                processCommand(idObj, strCmdRem.append("=y"), false);
+                        }
+                }
+        }
+
+        // Let our observers know about clear commands
+        RlvEvent rlvEvent(idObj, rlvCmd);
+        m_Emitter.update(&RlvObserver::onClearCommand, rlvEvent);
+
+        return TRUE; // Don't fail clear commands even if the object didn't exist since it confuses people
+}
+
 BOOL RlvHandler::processForceCommand(const LLUUID& idObj, const RlvCommand& rlvCmd) const
 {
         const std::string& strOption = rlvCmd.getOption();
@@ -946,10 +950,8 @@ BOOL RlvHandler::processForceCommand(const LLUUID& idObj, const RlvCommand& rlvC
                                 {
                                         LLVector3d posGlobal;
 
-                                        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-                                        boost::char_separator<char> sep("/", "", boost::keep_empty_tokens);
-                                        tokenizer tokens(strOption, sep); int idx = 0;
-                                        for (tokenizer::iterator itToken = tokens.begin(); itToken != tokens.end(); ++itToken)
+                                        boost_tokenizer tokens(strOption, boost::char_separator<char>("/", "", boost::keep_empty_tokens)); int idx = 0;
+                                        for (boost_tokenizer::const_iterator itToken = tokens.begin(); itToken != tokens.end(); ++itToken)
                                         {
                                                 if (idx < 3)
                                                         LLStringUtil::convertToF64(*itToken, posGlobal[idx++]);
@@ -1165,7 +1167,7 @@ BOOL RlvHandler::processReplyCommand(const LLUUID& uuid, const RlvCommand& rlvCm
                 case RLV_BHVR_GETINVWORN:               // @getinvworn[:path]=<channel>           - Checked:
                         onGetInvWorn(rlvCmd.getOption(), strReply);
                         break;
-                case RLV_BHVR_FINDFOLDER:               // @findfolder:<criteria>=<channel>   - Checked: 2009-07-12 (RLVa-1.0.0h)
+                case RLV_BHVR_FINDFOLDER:               // @findfolder:<criteria>=<channel>   - Checked: 2009-08-26 (RLVa-1.0.2a) | Modified: RLVa-1.0.2a
                         {
                                 // COMPAT-RLV: RLV 1.16.1 returns the first random folder it finds (probably tries to match "" to a folder name?)
                                 //             (just going to stick with what's there for now... no option => no folder)
@@ -1173,7 +1175,8 @@ BOOL RlvHandler::processReplyCommand(const LLUUID& uuid, const RlvCommand& rlvCm
                                 if ( (!strOption.empty()) && (findSharedFolders(strOption, folders)) )
                                 {
                                         // We need to return an "in depth" result so whoever has the most '/' is our lucky winner
-                                        int maxSlashes = 0, curSlashes; std::string strFolderName;
+                                        // (maxSlashes needs to be initialized to -1 since children of the #RLV folder won't have '/' in their shared path)
+                                        int maxSlashes = -1, curSlashes; std::string strFolderName;
                                         for (S32 idxFolder = 0, cntFolder = folders.count(); idxFolder < cntFolder; idxFolder++)
                                         {
                                                 strFolderName = getSharedPath(folders.get(idxFolder));
@@ -1307,6 +1310,9 @@ void RlvHandler::onAttach(LLViewerJointAttachment* pAttachPt, bool fFullyLoaded)
         rlv_object_map_t::iterator itObj = m_Objects.find(pObj->getID());
         if (itObj != m_Objects.end())
         {
+                // Save the attachment point index
+                itObj->second.m_idxAttachPt = idxAttachPt;
+
                 // If it's an attachment we processed commands for but that only just rezzed in we need to mark it as existing in gObjectList
                 if (!itObj->second.m_fLookup)
                         itObj->second.m_fLookup = true;
@@ -1315,7 +1321,7 @@ void RlvHandler::onAttach(LLViewerJointAttachment* pAttachPt, bool fFullyLoaded)
                 if (itObj->second.hasBehaviour(RLV_BHVR_DETACH))
                 {
                         // (Copy/paste from processAddCommand)
-                        setDetachable(pObj, pObj->getID(), false);
+                        setDetachable(idxAttachPt, pObj->getID(), false);
 
                         if (pObj->isHUDAttachment())
                                 LLPipeline::sShowHUDAttachments = TRUE; // Prevents hiding of locked HUD attachments
@@ -1365,29 +1371,15 @@ void RlvHandler::onAttach(LLViewerJointAttachment* pAttachPt, bool fFullyLoaded)
                                  (!getAttachPoint(pFolder, true)) )
                         {
                                 // It's no mod and its parent folder doesn't contain an attach point
-                                LLInventoryModel::cat_array_t*  pFolders;
-                                LLInventoryModel::item_array_t* pItems;
-                                gInventory.getDirectDescendentsOf(pFolder->getUUID(), pFolders, pItems);
-
-                                if (pItems)
+                                if ( (1 == rlvGetDirectDescendentsCount(pFolder, LLAssetType::AT_OBJECT)) && (NEW_CATEGORY_NAME == pFolder->getName()) )
                                 {
-                                        int cntObjects = 0;
-                                        for (S32 idxItem = 0, cntItem = pItems->size(); idxItem < cntItem; idxItem++)
-                                        {
-                                                if (LLAssetType::AT_OBJECT == pItems->get(idxItem)->getType())
-                                                        cntObjects++;
-                                        }
-
                                         // Only rename if there's exactly 1 object/attachment inside of it [see LLFolderBridge::renameItem()]
-                                        if ( (1 == cntObjects) && (NEW_CATEGORY_NAME == pFolder->getName()) )
-                                        {
-                                                std::string strName = ".(" + strAttachPt + ")";
+                                        std::string strName = ".(" + strAttachPt + ")";
 
-                                                pFolder->rename(strName);
-                                                pFolder->updateServer(FALSE);
-                                                gInventory.updateCategory(pFolder);
-                                                //gInventory.notifyObservers(); <- done further down in LLVOAvatar::attachObject()
-                                        }
+                                        pFolder->rename(strName);
+                                        pFolder->updateServer(FALSE);
+                                        gInventory.updateCategory(pFolder);
+                                        //gInventory.notifyObservers(); <- done further down in LLVOAvatar::attachObject()
                                 }
                         }
                 }
@@ -1864,10 +1856,8 @@ LLViewerInventoryCategory* RlvHandler::getSharedFolder(const std::string& strPat
                 return NULL;
 
         // Walk the path (starting at the root)
-        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-        boost::char_separator<char> sep("/", "", boost::drop_empty_tokens);
-        tokenizer tokens(strPath, sep);
-        for (tokenizer::iterator itToken = tokens.begin(); itToken != tokens.end(); ++itToken)
+        boost_tokenizer tokens(strPath, boost::char_separator<char>("/", "", boost::drop_empty_tokens));
+        for (boost_tokenizer::const_iterator itToken = tokens.begin(); itToken != tokens.end(); ++itToken)
         {
                 pFolder = getSharedFolder(pFolder->getUUID(), *itToken);
                 if (!pFolder)
@@ -2102,15 +2092,10 @@ void RlvHandler::onForceRemOutfit(const LLUUID& idObj, const std::string& strOpt
         for (int idxType = 0; idxType < WT_COUNT; idxType++)
         {
                 type = (EWearableType)idxType;
+                if (LLAssetType::AT_CLOTHING != LLWearable::typeToAssetType(type))
+                        continue; // Only strip clothing, not bodyparts
 
-                // Only strip clothing (that's currently worn and not marked "nostrip")
-                if ( (LLAssetType::AT_CLOTHING != LLWearable::typeToAssetType(type)) || 
-                         (!gAgent.getWearable(type)) || (!isStrippable(gAgent.getWearableItem(type))) )
-                {
-                        continue;
-                }
-
-                if ( (typeOption == type) || (strOption.empty()) )
+                if ( ((typeOption == type) || (strOption.empty())) && (gAgent.getWearable(type)) && (isStrippable(gAgent.getWearableItem(type))) )
                 {
                         #ifdef RLV_EXPERIMENTAL_COMPOSITES
                                 // If we're stripping something that's part of a composite folder then we should @detachthis instead
@@ -2238,7 +2223,7 @@ void RlvHandler::onForceWear(const std::string& strPath, bool fAttach, bool fMat
                                                                 // Simulate wearing an object to a specific attachment point (copy/paste to suppress replacement dialog)
                                                                 // LLAttachObject::handleEvent() => rez_attachment()
                                                                 LLViewerJointAttachment* pAttachPt = getAttachPoint(pItem, true);
-                                                                if ( (pAttachPt) && (isDetachable(pAttachPt->getObject())) )
+                                                                if ( (pAttachPt) && (isDetachable(pAttachPt)) )
                                                                 {
                                                                         #if RLV_TARGET < RLV_MAKE_TARGET(1, 23, 0)                      // Version: 1.22.11
                                                                                 LLAttachmentRezAction* rez_action = new LLAttachmentRezAction;
@@ -2498,7 +2483,7 @@ BOOL RlvHandler::setEnabled(BOOL fEnable)
 
 BOOL RlvHandler::canDisable()
 {
-        return TRUE;
+        return FALSE;
 }
 
 void RlvHandler::clearState()