Second Life viewer sources 1.18.1.2

1 files changed, 102 insertions, 22 deletions

diff --git a/linden/indra/newview/llmutelist.cpp b/linden/indra/newview/llmutelist.cpp
index bca9080..b5764c5 100644
--- a/linden/indra/newview/llmutelist.cpp
+++ b/linden/indra/newview/llmutelist.cpp
@@ -189,11 +189,11 @@ BOOL LLMuteList::isLinden(const LLString& name) const
 }
 
 
-BOOL LLMuteList::add(const LLMute& mute)
+BOOL LLMuteList::add(const LLMute& mute, U32 flags)
 {
-        // Can't mute Lindens
+        // Can't mute text from Lindens
         if ((mute.mType == LLMute::AGENT || mute.mType == LLMute::BY_NAME)
-                && isLinden(mute.mName))
+                && isLinden(mute.mName) && (flags & LLMute::flagTextChat || flags == 0))
         {
                 gViewerWindow->alertXml("MuteLinden");
                 return FALSE;
@@ -238,25 +238,59 @@ BOOL LLMuteList::add(const LLMute& mute)
         }
         else
         {
-                std::pair<mute_set_t::iterator, bool> result = mMutes.insert(mute);
-                if (result.second)
+                // Need a local (non-const) copy to set up flags properly.
+                LLMute localmute = mute;
+                
+                // If an entry for the same entity is already in the list, remove it, saving flags as necessary.
+                mute_set_t::iterator it = mMutes.find(localmute);
+                if (it != mMutes.end())
                 {
-                        llinfos << "Muting " << mute.mName << " id " << mute.mID << llendl;
-                        updateAdd(mute);
-                        notifyObservers();
-                        //Kill all particle systems owned by muted task
-                        if(mute.mType == LLMute::AGENT || mute.mType == LLMute::OBJECT)
-                        {
-                                gWorldPointer->mPartSim.cleanMutedParticles(mute.mID);
-                        }
+                        // This mute is already in the list.  Save the existing entry's flags if that's warranted.
+                        localmute.mFlags = it->mFlags;
+                        
+                        mMutes.erase(it);
+                        // Don't need to call notifyObservers() here, since it will happen after the entry has been re-added below.
+                }
+                else
+                {
+                        // There was no entry in the list previously.  Fake things up by making it look like the previous entry had all properties unmuted.
+                        localmute.mFlags = LLMute::flagAll;
+                }
 
-                        return TRUE;
+                if(flags)
+                {
+                        // The user passed some combination of flags.  Make sure those flag bits are turned off (i.e. those properties will be muted).
+                        localmute.mFlags &= (~flags);
                 }
                 else
                 {
-                        return FALSE;
+                        // The user passed 0.  Make sure all flag bits are turned off (i.e. all properties will be muted).
+                        localmute.mFlags = 0;
+                }
+                
+                // (re)add the mute entry.
+                {                       
+                        std::pair<mute_set_t::iterator, bool> result = mMutes.insert(localmute);
+                        if (result.second)
+                        {
+                                llinfos << "Muting " << localmute.mName << " id " << localmute.mID << " flags " << localmute.mFlags << llendl;
+                                updateAdd(mute);
+                                notifyObservers();
+                                if(!(localmute.mFlags & LLMute::flagParticles))
+                                {
+                                        //Kill all particle systems owned by muted task
+                                        if(localmute.mType == LLMute::AGENT || localmute.mType == LLMute::OBJECT)
+                                        {
+                                                gWorldPointer->mPartSim.cleanMutedParticles(localmute.mID);
+                                        }
+                                }
+                                return TRUE;
+                        }
                 }
         }
+        
+        // If we were going to return success, we'd have done it by now.
+        return FALSE;
 }
 
 void LLMuteList::updateAdd(const LLMute& mute)
@@ -271,14 +305,14 @@ void LLMuteList::updateAdd(const LLMute& mute)
         msg->addUUIDFast(_PREHASH_MuteID, mute.mID);
         msg->addStringFast(_PREHASH_MuteName, mute.mName);
         msg->addS32("MuteType", mute.mType);
-        msg->addU32("MuteFlags", 0x0);  // future
+        msg->addU32("MuteFlags", mute.mFlags);
         gAgent.sendReliableMessage();
 
         mIsLoaded = TRUE;
 }
 
 
-BOOL LLMuteList::remove(const LLMute& mute)
+BOOL LLMuteList::remove(const LLMute& mute, U32 flags)
 {
         BOOL found = FALSE;
         
@@ -286,8 +320,46 @@ BOOL LLMuteList::remove(const LLMute& mute)
         mute_set_t::iterator it = mMutes.find(mute);
         if (it != mMutes.end())
         {
-                updateRemove(*it);
+                LLMute localmute = *it;
+                bool remove = true;
+                if(flags)
+                {
+                        // If the user passed mute flags, we may only want to turn some flags on.
+                        localmute.mFlags |= flags;
+                        
+                        if(localmute.mFlags == LLMute::flagAll)
+                        {
+                                // Every currently available mute property has been masked out.
+                                // Remove the mute entry entirely.
+                        }
+                        else
+                        {
+                                // Only some of the properties are masked out.  Update the entry.
+                                remove = false;
+                        }
+                }
+                else
+                {
+                        // The caller didn't pass any flags -- just remove the mute entry entirely.
+                }
+                
+                // Always remove the entry from the set -- it will be re-added with new flags if necessary.
                 mMutes.erase(it);
+
+                if(remove)
+                {
+                        // The entry was actually removed.  Notify the server.
+                        updateRemove(localmute);
+                        llinfos << "Unmuting " << localmute.mName << " id " << localmute.mID << " flags " << localmute.mFlags << llendl;
+                }
+                else
+                {
+                        // Flags were updated, the mute entry needs to be retransmitted to the server and re-added to the list.
+                        mMutes.insert(localmute);
+                        updateAdd(localmute);
+                        llinfos << "Updating mute entry " << localmute.mName << " id " << localmute.mID << " flags " << localmute.mFlags << llendl;
+                }
+                
                 // Must be after erase.
                 notifyObservers();
                 found = TRUE;
@@ -381,7 +453,7 @@ BOOL LLMuteList::loadFromFile(const LLString& filename)
                         buffer, " %d %254s %254[^|]| %u\n", &type, id_buffer, name_buffer,
                         &flags);
                 LLUUID id = LLUUID(id_buffer);
-                LLMute mute(id, name_buffer, (LLMute::EType)type);
+                LLMute mute(id, name_buffer, (LLMute::EType)type, flags);
                 if (mute.mID.isNull()
                         || mute.mType == LLMute::BY_NAME)
                 {
@@ -430,19 +502,27 @@ BOOL LLMuteList::saveToFile(const LLString& filename)
         {
                 it->mID.toString(id_string);
                 const LLString& name = it->mName;
-                fprintf(fp, "%d %s %s|\n", (S32)it->mType, id_string, name.c_str());
+                fprintf(fp, "%d %s %s|%u\n", (S32)it->mType, id_string, name.c_str(), it->mFlags);
         }
         fclose(fp);
         return TRUE;
 }
 
 
-BOOL LLMuteList::isMuted(const LLUUID& id, const LLString& name) const
+BOOL LLMuteList::isMuted(const LLUUID& id, const LLString& name, U32 flags) const
 {
         // don't need name or type for lookup
         LLMute mute(id);
         mute_set_t::const_iterator mute_it = mMutes.find(mute);
-        if (mute_it != mMutes.end()) return TRUE;
+        if (mute_it != mMutes.end())
+        {
+                // If any of the flags the caller passed are set, this item isn't considered muted for this caller.
+                if(flags & mute_it->mFlags)
+                {
+                        return FALSE;
+                }
+                return TRUE;
+        }
 
         // empty names can't be legacy-muted
         if (name.empty()) return FALSE;