Applied RLVa-1.0.2c_20091005_Imprudence-1.2.0-diff.patch

8 files changed, 104 insertions, 128 deletions

diff --git a/linden/indra/newview/llinventorybridge.cpp b/linden/indra/newview/llinventorybridge.cpp
index 618c4f9..0d5625c 100644
--- a/linden/indra/newview/llinventorybridge.cpp
+++ b/linden/indra/newview/llinventorybridge.cpp
@@ -3505,7 +3505,7 @@ void LLObjectBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
                                 if ( (rlv_handler_t::isEnabled()) && (!RlvSettings::getEnableWear()) && (gRlvHandler.hasLockedAttachment()) )
                                 {
                                         LLViewerJointAttachment* pAttachPt = gRlvHandler.getAttachPoint(item, true);
-                                        if ( (!pAttachPt) || (!gRlvHandler.isDetachable(pAttachPt->getObject())) )
+                                        if ( (!pAttachPt) || (!gRlvHandler.isDetachable(pAttachPt)) )
                                                 disabled_items.push_back(std::string("Object Wear"));
                                 }
 // [/RLVa:KB]
@@ -4057,7 +4057,7 @@ void wear_inventory_category_on_avatar_step2( BOOL proceed, void* userdata )
                         for (S32 idxObj = obj_item_array.count() - 1; idxObj >= 0; idxObj--)
                         {
                                 LLViewerJointAttachment* pAttachPt = gRlvHandler.getAttachPoint(obj_item_array.get(idxObj).get(), true);
-                                if ( ((!pAttachPt) || (!gRlvHandler.isDetachable(pAttachPt->getObject()))) )
+                                if ( ((!pAttachPt) || (!gRlvHandler.isDetachable(pAttachPt))) )
                                         obj_item_array.remove(idxObj);
                         }
                         obj_count = obj_item_array.count();
@@ -4245,7 +4245,7 @@ void wear_attachments_on_avatar(const std::set<LLUUID>& item_ids, BOOL remove)
 // [RLVa:KB] - Checked: 2009-09-11 (RLVa-1.0.2c) | Modified: RLVa-1.0.2c
                                 LLViewerJointAttachment* pAttachPt = NULL;
                                 if ( (!rlv_handler_t::isEnabled()) || (RlvSettings::getEnableWear()) || (!gRlvHandler.hasLockedAttachment()) || 
-                                         (((pAttachPt = gRlvHandler.getAttachPoint(item, true)) != NULL) && (gRlvHandler.isDetachable(pAttachPt->getObject()))) )
+                                         (((pAttachPt = gRlvHandler.getAttachPoint(item, true)) != NULL) && (gRlvHandler.isDetachable(pAttachPt))) )
                                 {
                                         items.put(item);
                                 }
diff --git a/linden/indra/newview/lltooldraganddrop.cpp b/linden/indra/newview/lltooldraganddrop.cpp
index c99ccbf..178bde6 100644
--- a/linden/indra/newview/lltooldraganddrop.cpp
+++ b/linden/indra/newview/lltooldraganddrop.cpp
@@ -2014,10 +2014,10 @@ EAcceptance LLToolDragAndDrop::dad3dRezAttachmentFromInv(
                 return ACCEPT_NO;
         }
 
-// [RLVa:KB] - Checked: 2009-07-06 (RLVa-1.0.0c) | Modified: RLVa-1.0.0c
+// [RLVa:KB] - Checked: 2009-09-08 (RLVa-1.0.2c) | Modified: RLVa-1.0.2c
         LLViewerJointAttachment* pAttachPt = NULL;
         if ( (rlv_handler_t::isEnabled()) && (gRlvHandler.hasLockedAttachment()) && (!RlvSettings::getEnableWear()) &&
-                 ( ((pAttachPt = gRlvHandler.getAttachPoint(item, true)) == NULL) || (!gRlvHandler.isDetachable(pAttachPt->getObject())) ) )
+                 ( ((pAttachPt = gRlvHandler.getAttachPoint(item, true)) == NULL) || (!gRlvHandler.isDetachable(pAttachPt)) ) )
         {
                 return ACCEPT_NO_LOCKED;
         }
diff --git a/linden/indra/newview/llviewermenu.cpp b/linden/indra/newview/llviewermenu.cpp
index d11bc02..98dd0ea 100644
--- a/linden/indra/newview/llviewermenu.cpp
+++ b/linden/indra/newview/llviewermenu.cpp
@@ -6045,9 +6045,9 @@ private:
 
 // [RLVa:KB] - Checked: 2009-07-06 (RLVa-1.0.0c)
                         if ( (rlv_handler_t::isEnabled()) &&
-                                 ( ((index == 0) && (gRlvHandler.hasLockedAttachment())) ||                                               // Can't wear on default attach point
-                                   ((index > 0) && (!gRlvHandler.isDetachable(attachment_point->getObject()))) || // Can't replace locked attachment
-                                   (gRlvHandler.hasBehaviour(RLV_BHVR_REZ)) ) )                                                                   // Attach on rezzed object == "Take"
+                                 ( ((index == 0) && (gRlvHandler.hasLockedAttachment())) ||                      // Can't wear on default attach point
+                                   ((index > 0) && (!gRlvHandler.isDetachable(attachment_point))) || // Can't replace locked attachment
+                                   (gRlvHandler.hasBehaviour(RLV_BHVR_REZ)) ) )                                          // Attach on rezzed object == "Take"
                         {
                                 setObjectSelection(NULL); // Clear the selection or it'll get stuck
                                 return true;
@@ -6449,9 +6449,9 @@ BOOL object_selected_and_point_valid(void *user_data)
                 //      - enabler set up in LLVOAvatar::buildCharacter() => Rezzed prim / right-click / "Attach >" [user_data == pAttachPt]
                 //      - enabler set up in LLVOAvatar::buildCharacter() => Rezzed prim / Edit menu / "Attach Object" [user_data == pAttachPt]
                 LLViewerJointAttachment* pAttachPt = (LLViewerJointAttachment*)user_data;
-                if  ( ((!pAttachPt) && (gRlvHandler.hasLockedAttachment())) ||                                  // Don't allow attach to default attach point
-                          ((pAttachPt) && (!gRlvHandler.isDetachable(pAttachPt->getObject()))) ||       // Don't allow replacing of locked attachment
-                          (gRlvHandler.hasBehaviour(RLV_BHVR_REZ)) )                                                            // Attaching a rezzed object == "Take"
+                if  ( ((!pAttachPt) && (gRlvHandler.hasLockedAttachment())) ||          // Don't allow attach to default attach point
+                          ((pAttachPt) && (!gRlvHandler.isDetachable(pAttachPt))) ||    // Don't allow replacing of locked attachment
+                          (gRlvHandler.hasBehaviour(RLV_BHVR_REZ)) )                                    // Attaching a rezzed object == "Take"
                 {
                         return FALSE;
                 }
diff --git a/linden/indra/newview/llviewermessage.cpp b/linden/indra/newview/llviewermessage.cpp
index cecef95..33d3d51 100644
--- a/linden/indra/newview/llviewermessage.cpp
+++ b/linden/indra/newview/llviewermessage.cpp
@@ -2579,18 +2579,16 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
                                 verb = " " + LLTrans::getString("whisper") + " ";
                                 break;
                         case CHAT_TYPE_OWNER:
-// [RLVa:KB] - Checked: 2009-08-05 (RLVa-1.0.1e) | Modified: RLVa-1.0.1e
-                                if ( (rlv_handler_t::isEnabled()) && (mesg.length() > 3) && (RLV_CMD_PREFIX == mesg[0]) )
+// [RLVa:KB] - Checked: 2009-08-28 (RLVa-1.0.2a) | Modified: RLVa-1.0.2a
+                                if ( (rlv_handler_t::isEnabled()) && (mesg.length() > 3) && (RLV_CMD_PREFIX == mesg[0]) && (CHAT_TYPE_OWNER == chat.mChatType) )
                                 {
                                         mesg.erase(0, 1);
                                         LLStringUtil::toLower(mesg);
 
                                         std::string strExecuted, strFailed, strRetained, *pstr;
 
-                                        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-                                        boost::char_separator<char> sep(",", "", boost::drop_empty_tokens);
-                                        tokenizer tokens(mesg, sep);
-                                        for (tokenizer::iterator itToken = tokens.begin(); itToken != tokens.end(); ++itToken)
+                                        boost_tokenizer tokens(mesg, boost::char_separator<char>(",", "", boost::drop_empty_tokens));
+                                        for (boost_tokenizer::const_iterator itToken = tokens.begin(); itToken != tokens.end(); ++itToken)
                                         {
                                                 if (LLStartUp::getStartupState() == STATE_STARTED)
                                                 {
diff --git a/linden/indra/newview/rlvhandler.cpp b/linden/indra/newview/rlvhandler.cpp
index 2915002..987c62a 100644
--- a/linden/indra/newview/rlvhandler.cpp
+++ b/linden/indra/newview/rlvhandler.cpp
@@ -93,7 +93,7 @@ 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)) )
@@ -274,7 +274,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 +284,12 @@ 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;
-                }
-
+                // 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 +317,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;
                         }
                 }
@@ -499,7 +491,7 @@ BOOL RlvHandler::processCommand(const LLUUID& uuid, const std::string& strCmd, b
                                                         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)) )
+                                                        if ( (strFilter.empty()) || (std::string::npos != 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";
@@ -780,22 +772,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
                                 {
@@ -946,10 +931,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 +1148,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 +1156,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 +1291,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 +1302,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 +1352,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 +1837,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 +2073,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 +2204,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 +2464,7 @@ BOOL RlvHandler::setEnabled(BOOL fEnable)
 
 BOOL RlvHandler::canDisable()
 {
-        return TRUE;
+        return FALSE;
 }
 
 void RlvHandler::clearState()
diff --git a/linden/indra/newview/rlvhandler.h b/linden/indra/newview/rlvhandler.h
index df3ff9b..505bfd5 100644
--- a/linden/indra/newview/rlvhandler.h
+++ b/linden/indra/newview/rlvhandler.h
@@ -73,6 +73,7 @@ public:
         // Returns TRUE if the specified attachment point is detachable
         bool isDetachable(S32 idxAttachPt) const { return (idxAttachPt) && (m_Attachments.find(idxAttachPt) == m_Attachments.end()); }
         bool isDetachable(const LLInventoryItem* pItem) const;
+        bool isDetachable(LLViewerJointAttachment* pAttachPt) const;
         bool isDetachable(LLViewerObject* pObj) const;
         // Returns TRUE if the specified attachment point is set undetachable by anything other than pObj (or one of its children)
         bool isDetachableExcept(S32 idxAttachPt, LLViewerObject* pObj) const;
@@ -370,6 +371,14 @@ inline bool RlvHandler::hasBehaviourExcept(ERlvBehaviour eBehaviour, const LLUUI
         }
 #endif // RLV_EXPERIMENTAL_COMPOSITES
 
+// Checked: 2009-09-08 (RLVa-1.0.2c) | Added: RLVa-1.0.2c
+inline bool RlvHandler::isDetachable(LLViewerJointAttachment *pAttachPt) const
+{
+        // If there's an attached object it's faster to just use that; otherwise look up the attachment index because it might be locked empty
+        return (pAttachPt == NULL) ||
+                   ( (pAttachPt->getObject() != NULL) && isDetachable(pAttachPt->getObject()) ) || (isDetachable(getAttachPointIndex(pAttachPt)));
+}
+
 // Checked: 2009-05-23 (RLVa-0.2.0d) | Modified: RLVa-0.2.0d
 inline bool RlvHandler::isDetachable(LLViewerObject* pObj) const
 {
diff --git a/linden/indra/newview/rlvhelper.cpp b/linden/indra/newview/rlvhelper.cpp
index 6b2a1a0..429a527 100644
--- a/linden/indra/newview/rlvhelper.cpp
+++ b/linden/indra/newview/rlvhelper.cpp
@@ -409,12 +409,11 @@ bool rlvCanDeleteOrReturn()
         return fIsAllowed;
 }
 
-// Checked: 2009-07-05 (RLVa-1.0.0c)
+// Checked: 2009-09-08 (RLVa-1.0.2c) | Modified: RLVa-1.0.2c
 BOOL rlvAttachToEnabler(void* pParam)
 {
         // Enables/disables an option on the "Attach to (HUD)" submenu depending on whether it is (un)detachable
-        LLViewerJointAttachment* pAttachment = (LLViewerJointAttachment*)pParam;
-        return (!pAttachment) || (gRlvHandler.isDetachable(pAttachment->getObject()));
+        return gRlvHandler.isDetachable((LLViewerJointAttachment*)pParam);
 }
 
 BOOL RlvGCTimer::tick()
@@ -672,3 +671,7 @@ std::string rlvGetLastParenthesisedText(const std::string& strText, std::string:
 }
 
 // =========================================================================
+// Debug helper functions
+//
+
+// =========================================================================
diff --git a/linden/indra/newview/rlvhelper.h b/linden/indra/newview/rlvhelper.h
index a0e040e..9ceb799 100644
--- a/linden/indra/newview/rlvhelper.h
+++ b/linden/indra/newview/rlvhelper.h
@@ -55,8 +55,8 @@ const S32 RLV_VERSION_PATCH = 0;
 // Implementation version
 const S32 RLVa_VERSION_MAJOR = 1;
 const S32 RLVa_VERSION_MINOR = 0;
-const S32 RLVa_VERSION_PATCH = 1;
-const S32 RLVa_VERSION_BUILD = 7;
+const S32 RLVa_VERSION_PATCH = 2;
+const S32 RLVa_VERSION_BUILD = 2;
 
 // The official viewer version we're patching against
 #define RLV_MAKE_TARGET(x, y, z)        ((x << 16) | (y << 8) | z)
@@ -249,7 +249,12 @@ typedef std::list<RlvCommand> rlv_command_list_t;
 class RlvObject
 {
 public:
-        RlvObject(const LLUUID& uuid) : m_UUID(uuid), m_nLookupMisses(0) { m_fLookup = (NULL != gObjectList.findObject(uuid)); }
+        RlvObject(const LLUUID& uuid) : m_UUID(uuid), m_nLookupMisses(0)
+        {
+                LLViewerObject* pObj = gObjectList.findObject(uuid);
+                m_fLookup = (NULL != pObj);
+                m_idxAttachPt = (pObj) ? ATTACHMENT_ID_FROM_STATE(pObj->getState()) : 0;
+        }
 
         BOOL addCommand(const RlvCommand& rlvCmd);
         BOOL removeCommand(const RlvCommand& rlvCmd);
@@ -264,6 +269,7 @@ public:
         const rlv_command_list_t* getCommandList() const { return &m_Commands; }
 protected:
         LLUUID             m_UUID;                              // The object's UUID
+        S32                m_idxAttachPt;               // The object's attachment point (or 0 if it's not an attachment)
         bool               m_fLookup;                   // TRUE if the object existed in gObjectList at one point in time
         S16                m_nLookupMisses;             // Count of unsuccessful lookups in gObjectList by the GC
         rlv_command_list_t m_Commands;                  // List of behaviours held by this object (in the order they were received)
@@ -284,11 +290,16 @@ class RlvCriteriaCategoryCollector : public LLInventoryCollectFunctor
 public:
         RlvCriteriaCategoryCollector(const std::string& strCriteria)
         {
-                typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-                boost::char_separator<char> sep("&&", "", boost::drop_empty_tokens);
-                tokenizer tokens(strCriteria, sep);
-                for (tokenizer::iterator itToken = tokens.begin(); itToken != tokens.end(); ++itToken)
-                        m_Criteria.push_back(*itToken);
+                std::string::size_type idxIt, idxLast = 0;
+                while (idxLast < strCriteria.length())
+                {
+                        idxIt = strCriteria.find("&&", idxLast);
+                        if (std::string::npos == idxIt)
+                                idxIt = strCriteria.length();
+                        if (idxIt != idxLast)
+                                m_Criteria.push_back(strCriteria.substr(idxLast, idxIt - idxLast));
+                        idxLast = idxIt + 2;
+                }
         }
         virtual ~RlvCriteriaCategoryCollector() {}
 
@@ -304,7 +315,7 @@ public:
                         return false;
 
                 for (std::list<std::string>::const_iterator itCrit = m_Criteria.begin(); itCrit != m_Criteria.end(); ++itCrit)
-                        if (-1 == strFolderName.find(*itCrit))  // Return false on the first mismatch
+                        if (std::string::npos == strFolderName.find(*itCrit))   // Return false on the first mismatch
                                 return false;
                 return true;
         }
@@ -317,7 +328,7 @@ protected:
 /*
  * RlvWearableItemCollector
  * ========================
- * Inventory item filter used by attach/detach/attachall/detachall/getinvworn (also used by "Add/Replace Outfit" and "Take Off Items")
+ * Inventory item filter used by attach/detach/attachall/detachall/getinvworn
  *
  */
 
@@ -349,11 +360,8 @@ protected:
 };
 
 // ============================================================================
-/*
- * RlvRetainedCommand
- * ==================
- *
- */
+// RlvRetainedCommand
+//
 
 struct RlvRetainedCommand
 {
@@ -369,11 +377,8 @@ private:
 typedef std::list<RlvRetainedCommand> rlv_retained_list_t;
 
 // ============================================================================
-/*
- * RlvWLSnapshot
- * =============
- *
- */
+// RlvWLSnapshot
+//
 
 struct RlvWLSnapshot
 {
@@ -389,11 +394,8 @@ private:
 };
 
 // ============================================================================
-/*
- * RlvSettings
- * ===========
- *
- */
+// RlvSettings
+//
 
 #define RLV_SETTING_MAIN                                "RestrainedLife"
 #define RLV_SETTING_DEBUG                               "RestrainedLifeDebug"
@@ -437,10 +439,8 @@ public:
 };
 
 // ============================================================================
-/*
- * State keeping classes/structure
- *
- */
+// State keeping classes/structure
+//
 
 struct RlvRedirInfo
 {
@@ -461,10 +461,8 @@ struct RlvReattachInfo
 };
 
 // ============================================================================
-/*
- * Various helper classes/timers/functors
- *
- */
+// Various helper classes/timers/functors
+//
 
 class RlvGCTimer : public LLEventTimer
 {
@@ -504,10 +502,8 @@ struct RlvSelectIsSittingOn : public LLSelectedNodeFunctor
 };
 
 // ============================================================================
-/*
- * Various helper functions
- *
- */
+// Various helper functions
+//
 
 BOOL rlvAttachToEnabler(void* pParam);
 bool rlvCanDeleteOrReturn();
@@ -525,6 +521,10 @@ void rlvStringReplace(std::string& strText, std::string strFrom, const std::stri
 std::string rlvGetFirstParenthesisedText(const std::string& strText, std::string::size_type* pidxMatch = NULL);
 std::string rlvGetLastParenthesisedText(const std::string& strText, std::string::size_type* pidxStart = NULL);
 
+// ============================================================================
+// Debug helper functions
+//
+
 #ifdef RLV_ADVANCED_TOGGLE_RLVA
         // "Advanced / RLVa / Enable RLV" menu option
         void rlvDbgToggleEnabled(void*);
@@ -561,10 +561,10 @@ inline bool rlvIsEmote(const std::string& strUTF8Text)
         return (strUTF8Text.length() > 4) && ( (strUTF8Text.compare(0, 4, "/me ") == 0) || (strUTF8Text.compare(0, 4, "/me'") == 0) );
 }
 
-// Checked: 2009-08-05 (RLVa-1.0.1e) | Added: RLVa-1.0.0e
+// Checked: 2009-09-05 (RLVa-1.0.2a) | Added: RLVa-1.0.2a
 inline bool rlvIsValidChannel(S32 nChannel)
 {
-        return (nChannel >= 0) && (CHAT_CHANNEL_DEBUG != nChannel);
+        return (nChannel > 0) && (CHAT_CHANNEL_DEBUG != nChannel);
 }
 
 // Checked: 2009-08-05 (RLVa-1.0.1e) | Added: RLVa-1.0.0e