1 files changed, 134 insertions, 354 deletions

diff --git a/linden/indra/newview/llfloaterbulkpermission.cpp b/linden/indra/newview/llfloaterbulkpermission.cpp
index e66d1af..d4e1e98 100644
--- a/linden/indra/newview/llfloaterbulkpermission.cpp
+++ b/linden/indra/newview/llfloaterbulkpermission.cpp
@@ -1,10 +1,11 @@
 /** 
  * @file llfloaterbulkpermissions.cpp
+ * @author Michelle2 Zenovka
  * @brief A floater which allows task inventory item's properties to be changed on mass.
  *
  * $LicenseInfo:firstyear=2008&license=viewergpl$
  * 
- * Copyright (c) 2008, Linden Research, Inc.
+ * Copyright (c) 2008-2009, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -17,7 +18,8 @@
  * There are special exceptions to the terms and conditions of the GPL as
  * it is applied to this Source Code. View the full text of the exception
  * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -29,20 +31,10 @@
  * $/LicenseInfo$
  */
 
-/* Allow multiple task inventory properties to be set in one go, by Michelle2 Zenovka */
-
-/* TODO
-        
-        * Add in the option to select objects or task inventory
-s
-
-It would be nice to set the permissions on groups of prims as well as task inventory
-
-*/
-
 
 #include "llviewerprecompiledheaders.h"
 #include "llfloaterbulkpermission.h"
+#include "llfloaterperms.h" // for utilities
 #include "llagent.h"
 #include "llchat.h"
 #include "llviewerwindow.h"
@@ -60,192 +52,59 @@ It would be nice to set the permissions on groups of prims as well as task inven
 #include "llviewerstats.h"
 #include "lluictrlfactory.h"
 #include "llselectmgr.h"
-#include "llinventory.h"
-
-
-#include <algorithm>
-#include <functional>
-#include "llcachename.h"
-#include "lldbstrings.h"
-#include "llinventory.h"
-
-#include "llagent.h"
-#include "llbutton.h"
-#include "llcheckboxctrl.h"
-#include "llfloateravatarinfo.h"
-#include "llfloatergroupinfo.h"
-#include "llinventorymodel.h"
-#include "lllineeditor.h"
-#include "llradiogroup.h"
-#include "llresmgr.h"
-#include "roles_constants.h"
-#include "llselectmgr.h"
-#include "lltextbox.h"
-#include "lluiconstants.h"
-#include "llviewerinventory.h"
-#include "llviewerobjectlist.h"
-#include "llviewerregion.h"
-#include "llviewercontrol.h"
-
-#include "lluictrlfactory.h"
-
-
-const char* BULKPERM_QUEUE_TITLE = "Update Progress";
-const char* BULKPERM_START_STRING = "update";
-
-namespace
-{
-        struct BulkQueueObjects : public LLSelectedObjectFunctor
-        {
-                BOOL scripted;
-                BOOL modifiable;
-                LLFloaterBulkPermission* mQueue;
-                BulkQueueObjects(LLFloaterBulkPermission* q) : mQueue(q), scripted(FALSE), modifiable(FALSE) {}
-                virtual bool apply(LLViewerObject* obj)
-                {
-                        scripted = obj->flagScripted();
-                        modifiable = obj->permModify();
-
-                        mQueue->addObject(obj->getID());
-                        return false;
-                        
-                }
-        };
-}
-
-///----------------------------------------------------------------------------
-/// Class LLFloaterBulkPermission
-///----------------------------------------------------------------------------
 
-// static
-LLMap<LLUUID, LLFloaterBulkPermission*> LLFloaterBulkPermission::sInstances;
+#include "roles_constants.h" // for GP_OBJECT_MANIPULATE
 
 
-// Default constructor
-LLFloaterBulkPermission::LLFloaterBulkPermission(const std::string& name,
-                                                                                         const LLRect& rect,
-                                                                                         const char* title,
-                                                                                         const char* start_string) :
-        LLFloater(name, rect, title,
-                          RESIZE_YES, DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT,
-                          DRAG_ON_TOP, MINIMIZE_YES, CLOSE_YES)
+LLFloaterBulkPermission::LLFloaterBulkPermission(const LLSD& seed) : mDone(FALSE)
 {
-
-        req_perm_mask=0; // This should match the default state the checkboxes are set to
-        recurse=false;
-
+        mID.generate();
         LLUICtrlFactory::getInstance()->buildFloater(this,"floater_bulk_perms.xml");
-
-        childSetAction("Apply...",onApplyBtn,this);
-        childSetEnabled("Apply...",TRUE);
-
-        childSetCommitCallback("Modify",&onCommitPermissions, this);
-        childSetCommitCallback("Trans",&onCommitPermissions, this);
-        childSetCommitCallback("Copy",&onCommitPermissions, this);
-
-        //childSetCommitCallback("Recurse",&onRecurse, this);
-
-        childSetCommitCallback("Parent",&onParent, this);
-
-        childSetCommitCallback("objects",&InvSelection, this);
-        childSetCommitCallback("scripts",&InvSelection, this);
-        childSetCommitCallback("textures",&InvSelection, this);
-        childSetCommitCallback("sounds",&InvSelection, this);
-        childSetCommitCallback("animations",&InvSelection, this);
-        childSetCommitCallback("notecards",&InvSelection, this);
-        childSetCommitCallback("landmarks",&InvSelection, this);
-        childSetCommitCallback("bodyparts",&InvSelection, this);
-        childSetCommitCallback("clothing",&InvSelection, this);
-        childSetCommitCallback("gestures",&InvSelection, this);
-
-        //Set variable state to XUI default state consistancy
-        processObject=getChild<LLCheckBoxCtrl>("objects")->get();
-        processScript=getChild<LLCheckBoxCtrl>("scripts")->get();
-        processTexture=getChild<LLCheckBoxCtrl>("textures")->get();
-        processSound=getChild<LLCheckBoxCtrl>("sounds")->get();
-        processAnimation=getChild<LLCheckBoxCtrl>("animations")->get();
-        processNotecard=getChild<LLCheckBoxCtrl>("notecards")->get();
-        processGesture=getChild<LLCheckBoxCtrl>("gestures")->get();
-        processClothing=getChild<LLCheckBoxCtrl>("clothing")->get();
-        processBodypart=getChild<LLCheckBoxCtrl>("bodyparts")->get();
-        processLandmark=getChild<LLCheckBoxCtrl>("landmarks")->get();
-        parent=getChild<LLCheckBoxCtrl>("Parent")->get();
-
-
-        setTitle(title);
-        
-        if (!getHost())
-        {
-                LLRect curRect = getRect();
-                translate(rect.mLeft - curRect.mLeft, rect.mTop - curRect.mTop);
-        }
-        
-        mStartString = start_string;
-        mDone = FALSE;
-        sInstances.addData(mID, this);
-
+        childSetEnabled("next_owner_transfer", gSavedSettings.getBOOL("BulkChangeNextOwnerCopy"));
+        childSetAction("help", onHelpBtn, this);
+        childSetAction("apply", onApplyBtn, this);
+        childSetAction("close", onCloseBtn, this);
+        childSetAction("check_all", onCheckAll, this);
+        childSetAction("check_none", onUncheckAll, this);
+        childSetCommitCallback("next_owner_copy", &onCommitCopy, this);
 }
 
 void LLFloaterBulkPermission::doApply()
 {
-        // Its alive now do the nasty work that the ScriptQueue and friends try to do in the menu code
-        // but first grab the user options
-
-        LLScrollListCtrl* list = getChild<LLScrollListCtrl>("queue output");
-        list->deleteAllItems();
-
-        //Apply to selected objects if requested first
-
-        if(parent)
-        {
-                llinfos<< "Setting permission on parent items" << llendl;
-                LLSelectMgr::getInstance()->selectionSetObjectPermissions(PERM_NEXT_OWNER,true, req_perm_mask);
-                LLSelectMgr::getInstance()->selectionSetObjectPermissions(PERM_NEXT_OWNER,false, ~req_perm_mask); //How annoying need to set and unset
-        }
-
-
-        LLFloaterBulkPermission* q;
-        q=(LLFloaterBulkPermission*)this;
-
-        BulkQueueObjects func(q);
-        bool fail = LLSelectMgr::getInstance()->getSelection()->applyToObjects(&func);
-        if(fail)
+        // Inspects a stream of selected object contents and adds modifiable ones to the given array.
+        class ModifiableGatherer : public LLSelectedNodeFunctor
         {
-                if ( !func.modifiable )
-                {
-                        gViewerWindow->alertXml("NO MODIFY");
-                }
-                else
+        public:
+                ModifiableGatherer(LLDynamicArray<LLUUID>& q) : mQueue(q) {}
+                virtual bool apply(LLSelectNode* node)
                 {
-                        llwarns << "Bad logic. Are there actualy any items in that prim?" << llendl;
+                        if( node->allowOperationOnNode(PERM_MODIFY, GP_OBJECT_MANIPULATE) )
+                        {
+                                mQueue.put(node->getObject()->getID());
+                        }
+                        return true;
                 }
+        private:
+                LLDynamicArray<LLUUID>& mQueue;
+        };
+        LLScrollListCtrl* list = getChild<LLScrollListCtrl>("queue output");
+        list->deleteAllItems();
+        ModifiableGatherer gatherer(mObjectIDs);
+        LLSelectMgr::getInstance()->getSelection()->applyToNodes(&gatherer);
+        if(mObjectIDs.empty())
+        {
+                list->addCommentText(getString("nothing_to_modify_text"));
         }
         else
         {
-                if (!q->start())
+                mDone = FALSE;
+                if (!start())
                 {
-                        llwarns << "Unexpected failure attepmting to set permissions." << llendl;
+                        llwarns << "Unexpected bulk permission change failure." << llendl;
                 }
         }
 }
 
-// Destroys the object
-LLFloaterBulkPermission::~LLFloaterBulkPermission()
-{
-        sInstances.removeData(mID);
-}
-
-// find an instance by ID. Return NULL if it does not exist.
-// static
-LLFloaterBulkPermission* LLFloaterBulkPermission::findInstance(const LLUUID& id)
-{
-        if(sInstances.checkData(id))
-        {
-                return sInstances.getData(id);
-        }
-        return NULL;
-}
-
 
 // This is the callback method for the viewer object currently being
 // worked on.
@@ -255,8 +114,7 @@ void LLFloaterBulkPermission::inventoryChanged(LLViewerObject* viewer_object,
                                                                                          S32,
                                                                                          void* q_id)
 {
-        llinfos << "LLFloaterBulkPermission::inventoryChanged() for  object "
-                        << viewer_object->getID() << llendl;
+        //llinfos << "changed object: " << viewer_object->getID() << llendl;
 
         //Remove this listener from the object since its
         //listener callback is now being executed.
@@ -281,116 +139,50 @@ void LLFloaterBulkPermission::inventoryChanged(LLViewerObject* viewer_object,
                 // something went wrong...
                 // note that we're not working on this one, and move onto the
                 // next object in the list.
-                llwarns << "No inventory for " << mCurrentObjectID
-                                << llendl;
+                llwarns << "No inventory for " << mCurrentObjectID << llendl;
                 nextObject();
         }
 }
 
 void LLFloaterBulkPermission::onApplyBtn(void* user_data)
 {
-        LLFloaterBulkPermission* self = (LLFloaterBulkPermission*)user_data;
+        LLFloaterBulkPermission* self = static_cast<LLFloaterBulkPermission*>(user_data);
         self->doApply();
 }
 
-
-// static
-void LLFloaterBulkPermission::InvSelection(LLUICtrl* ctrl, void* data)
-{
-        LLFloaterBulkPermission* self = (LLFloaterBulkPermission*)data;
-
-        self->processObject=self->getChild<LLCheckBoxCtrl>("objects")->get();
-        self->processScript=self->getChild<LLCheckBoxCtrl>("scripts")->get();
-        self->processTexture=self->getChild<LLCheckBoxCtrl>("textures")->get();
-        self->processSound=self->getChild<LLCheckBoxCtrl>("sounds")->get();
-        self->processAnimation=self->getChild<LLCheckBoxCtrl>("animations")->get();
-        self->processNotecard=self->getChild<LLCheckBoxCtrl>("notecards")->get();
-        self->processGesture=self->getChild<LLCheckBoxCtrl>("gestures")->get();
-        self->processClothing=self->getChild<LLCheckBoxCtrl>("clothing")->get();
-        self->processBodypart=self->getChild<LLCheckBoxCtrl>("bodyparts")->get();
-        self->processLandmark=self->getChild<LLCheckBoxCtrl>("landmarks")->get();
-
-
-}
-
-// static
-void LLFloaterBulkPermission::onParent(LLUICtrl* ctrl, void* data)
+void LLFloaterBulkPermission::onHelpBtn(void* user_data)
 {
-        LLFloaterBulkPermission* self = (LLFloaterBulkPermission*)data;
-        self->parent=self->getChild<LLCheckBoxCtrl>("Parent")->get();
+        LLNotifications::instance().add("HelpBulkPermission");
 }
 
-// static
-void LLFloaterBulkPermission::onRecurse(LLUICtrl* ctrl, void* data)
+void LLFloaterBulkPermission::onCloseBtn(void* user_data)
 {
-        LLFloaterBulkPermission* self = (LLFloaterBulkPermission*)data;
-        self->recurse=self->getChild<LLCheckBoxCtrl>("Recurse")->get();
+        LLFloaterBulkPermission* self = static_cast<LLFloaterBulkPermission*>(user_data);
+        self->onClose(false);
 }
 
-// static
-void LLFloaterBulkPermission::onCommitPermissions(LLUICtrl* ctrl, void* data)
+//static 
+void LLFloaterBulkPermission::onCommitCopy(LLUICtrl* ctrl, void* data)
 {
-        LLFloaterBulkPermission* self = (LLFloaterBulkPermission*)data;
-        LLCheckBoxCtrl* CheckModify = self->getChild<LLCheckBoxCtrl>("Modify");
-        LLCheckBoxCtrl* CheckCopy = self->getChild<LLCheckBoxCtrl>("Copy");
-        LLCheckBoxCtrl* CheckTrans = self->getChild<LLCheckBoxCtrl>("Trans");
-
-        self->req_perm_mask=0;
-
-        if(CheckModify->get())
-        {
-                self->req_perm_mask|=PERM_MODIFY;
-        }
-        else
-        {
-                self->req_perm_mask&=~PERM_MODIFY;
-        }
-
-        if(CheckCopy->get())
-        {
-                self->req_perm_mask|=PERM_COPY;
-        }
-        else
-        {
-                self->req_perm_mask&=~PERM_COPY;
-        }
-
-        if(CheckTrans->get())
+        LLFloaterBulkPermission* self = static_cast<LLFloaterBulkPermission*>(data);
+        // Implements fair use
+        BOOL copyable = gSavedSettings.getBOOL("BulkChangeNextOwnerCopy");
+        if(!copyable)
         {
-                self->req_perm_mask|=PERM_TRANSFER;
+                gSavedSettings.setBOOL("BulkChangeNextOwnerTransfer", TRUE);
         }
-        else
-        {
-                self->req_perm_mask&=~PERM_TRANSFER;
-        }
-
-
-}
-
-void LLFloaterBulkPermission::addObject(const LLUUID& id)
-{
-        mObjectIDs.put(id);
+        LLCheckBoxCtrl* xfer = self->getChild<LLCheckBoxCtrl>("next_owner_transfer");
+        xfer->setEnabled(copyable);
 }
 
 BOOL LLFloaterBulkPermission::start()
 {
-        llinfos << "LLFloaterBulkPermission::start()" << llendl;
-        char buffer[MAX_STRING];                                /*Flawfinder: ignore*/
-        snprintf(buffer, sizeof(buffer), "Starting %s of %d items.", mStartString, mObjectIDs.count());                 /* Flawfinder: ignore */
-
-        LLScrollListCtrl* list = getChild<LLScrollListCtrl>("queue output");
-        list->addCommentText(buffer);
-
+        // note: number of top-level objects to modify is mObjectIDs.count().
+        getChild<LLScrollListCtrl>("queue output")->addCommentText(getString("start_text"));
         return nextObject();
 }
 
-BOOL LLFloaterBulkPermission::isDone() const
-{
-        return (mCurrentObjectID.isNull() || (mObjectIDs.count() == 0));
-}
-
-// go to the next object. If no objects left, it falls out silently
-// and waits to be killed by the window being closed.
+// Go to the next object and start if found. Returns false if no objects left, true otherwise.
 BOOL LLFloaterBulkPermission::nextObject()
 {
         S32 count;
@@ -398,60 +190,47 @@ BOOL LLFloaterBulkPermission::nextObject()
         do
         {
                 count = mObjectIDs.count();
-                llinfos << "LLFloaterBulkPermission::nextObject() - " << count
-                                << " objects left to process." << llendl;
+                //llinfos << "Objects left to process = " << count << llendl;
                 mCurrentObjectID.setNull();
                 if(count > 0)
                 {
                         successful_start = popNext();
+                        //llinfos << (successful_start ? "successful" : "unsuccessful") << llendl; 
                 }
-                llinfos << "LLFloaterBulkPermission::nextObject() "
-                                << (successful_start ? "successful" : "unsuccessful")
-                                << llendl; 
         } while((mObjectIDs.count() > 0) && !successful_start);
 
         if(isDone() && !mDone)
         {
-                
-                LLScrollListCtrl* list = getChild<LLScrollListCtrl>("queue output");
+                getChild<LLScrollListCtrl>("queue output")->addCommentText(getString("done_text"));
                 mDone = TRUE;
-                char buffer[MAX_STRING];                /*Flawfinder: ignore*/
-                snprintf(buffer, sizeof(buffer), "Done.");                              /* Flawfinder: ignore */
-                list->addCommentText(buffer);
-
         }
         return successful_start;
 }
 
-// returns true if the queue has started, otherwise false.  This
-// method pops the top object off of the queue.
+// Pop the top object off of the queue.
+// Return TRUE if the queue has started, otherwise FALSE.
 BOOL LLFloaterBulkPermission::popNext()
 {
-        // get the first element off of the container, and attempt to get
-        // the inventory.
+        // get the head element from the container, and attempt to get its inventory.
         BOOL rv = FALSE;
         S32 count = mObjectIDs.count();
         if(mCurrentObjectID.isNull() && (count > 0))
         {
                 mCurrentObjectID = mObjectIDs.get(0);
-                llinfos << "LLFloaterBulkPermission::popNext() - mCurrentID: "
-                                << mCurrentObjectID << llendl;
+                //llinfos << "mCurrentID: " << mCurrentObjectID << llendl;
                 mObjectIDs.remove(0);
                 LLViewerObject* obj = gObjectList.findObject(mCurrentObjectID);
                 if(obj)
                 {
-                        llinfos << "LLFloaterBulkPermission::popNext() requesting inv for "
-                                        << mCurrentObjectID << llendl;
+                        //llinfos << "requesting inv for " << mCurrentObjectID << llendl;
                         LLUUID* id = new LLUUID(mID);
-
                         registerVOInventoryListener(obj,id);
                         requestVOInventory();
                         rv = TRUE;
                 }
                 else
                 {
-                        llinfos<<"LLFloaterBulkPermission::popNext() returned a NULL LLViewerObject" <<llendl;
-                        //Arrrg what do we do here?
+                        llinfos<<"NULL LLViewerObject" <<llendl;
                 }
         }
 
@@ -459,47 +238,42 @@ BOOL LLFloaterBulkPermission::popNext()
 }
 
 
-// static
-LLFloaterBulkPermission* LLFloaterBulkPermission::create()
+void LLFloaterBulkPermission::doCheckUncheckAll(BOOL check)
 {
-        S32 left, top;
-        gFloaterView->getNewFloaterPosition(&left, &top);
-        LLRect rect = gSavedSettings.getRect("CompileOutputRect");
-        rect.translate(left - rect.mLeft, top - rect.mTop);
-        LLFloaterBulkPermission* new_queue = new LLFloaterBulkPermission("queue",rect,"Setting Bulk permissions","Results");
-        new_queue->open();       /*Flawfinder: ignore*/
-        return new_queue;
+        gSavedSettings.setBOOL("BulkChangeIncludeAnimations", check);
+        gSavedSettings.setBOOL("BulkChangeIncludeBodyParts" , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeClothing"  , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeGestures"  , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeLandmarks" , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeNotecards" , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeObjects"   , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeScripts"   , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeSounds"    , check);
+        gSavedSettings.setBOOL("BulkChangeIncludeTextures"  , check);
 }
 
 
 void LLFloaterBulkPermission::handleInventory(LLViewerObject* viewer_obj, InventoryObjectList* inv)
 {
-        // find all of the lsl, leaving off duplicates. We'll remove
-        // all matching asset uuids on compilation success.
-
-        llinfos<<"handleInventory"<<llendl;
-
-        char buffer[MAX_STRING];                 /*Flawfinder: ignore*/
         LLScrollListCtrl* list = getChild<LLScrollListCtrl>("queue output");
 
         InventoryObjectList::const_iterator it = inv->begin();
         InventoryObjectList::const_iterator end = inv->end();
         for ( ; it != end; ++it)
         {
-                llinfos<<"Doing iterator of inventory"<<llendl;
-
-                if(  ( (*it)->getType() == LLAssetType::AT_LSL_TEXT && processScript) ||
-                     ( (*it)->getType() == LLAssetType::AT_TEXTURE && processTexture) ||
-                     ( (*it)->getType() == LLAssetType::AT_SOUND && processSound) ||
-                     ( (*it)->getType() == LLAssetType::AT_LANDMARK && processLandmark) ||
-                     ( (*it)->getType() == LLAssetType::AT_CLOTHING && processClothing) ||
-                     ( (*it)->getType() == LLAssetType::AT_OBJECT && processObject) ||
-                     ( (*it)->getType() == LLAssetType::AT_NOTECARD && processNotecard) ||
-                     ( (*it)->getType() == LLAssetType::AT_BODYPART && processBodypart) ||
-                     ( (*it)->getType() == LLAssetType::AT_ANIMATION && processAnimation) ||
-                     ( (*it)->getType() == LLAssetType::AT_GESTURE && processGesture))
+                LLAssetType::EType asstype = (*it)->getType();
+                if(
+                        ( asstype == LLAssetType::AT_ANIMATION && gSavedSettings.getBOOL("BulkChangeIncludeAnimations")) ||
+                        ( asstype == LLAssetType::AT_BODYPART  && gSavedSettings.getBOOL("BulkChangeIncludeBodyParts" )) ||
+                        ( asstype == LLAssetType::AT_CLOTHING  && gSavedSettings.getBOOL("BulkChangeIncludeClothing"  )) ||
+                        ( asstype == LLAssetType::AT_GESTURE   && gSavedSettings.getBOOL("BulkChangeIncludeGestures"  )) ||
+                        ( asstype == LLAssetType::AT_LANDMARK  && gSavedSettings.getBOOL("BulkChangeIncludeLandmarks" )) ||
+                        ( asstype == LLAssetType::AT_NOTECARD  && gSavedSettings.getBOOL("BulkChangeIncludeNotecards" )) ||
+                        ( asstype == LLAssetType::AT_OBJECT    && gSavedSettings.getBOOL("BulkChangeIncludeObjects"   )) ||
+                        ( asstype == LLAssetType::AT_LSL_TEXT  && gSavedSettings.getBOOL("BulkChangeIncludeScripts"   )) ||
+                        ( asstype == LLAssetType::AT_SOUND     && gSavedSettings.getBOOL("BulkChangeIncludeSounds"    )) ||
+                        ( asstype == LLAssetType::AT_TEXTURE   && gSavedSettings.getBOOL("BulkChangeIncludeTextures"  )))
                 {
-
                         LLViewerObject* object = gObjectList.findObject(viewer_obj->getID());
 
                         if (object)
@@ -513,43 +287,56 @@ void LLFloaterBulkPermission::handleInventory(LLViewerObject* viewer_obj, Invent
                                 std::string invname;
                                 invname=item->getName().substr(0,item->getName().size() < 30 ? item->getName().size() : 30 );
                                 
-                                // My attempt at checking valid permissions, CHECK ME
-                                // note its not actually bad to try to set permissions that are not allowed as the
-                                // server will protect against this, but it will piss the user off if its wrong
-                                if(
-                                (perm.getCreator()==gAgentID) ||
-                                (perm.getMaskOwner() & PERM_TRANSFER) && (perm.getMaskOwner() & PERM_MODIFY) || 
-                                (gAgent.getGroupID()==perm.getGroup() && (perm.getMaskGroup() & PERM_TRANSFER) && (perm.getMaskGroup() & PERM_MODIFY))
-                                ){      
-                                        llinfos<<"Setting perms"<<llendl;
-                                        perm.setMaskNext(req_perm_mask);
-                                        new_item->setPermissions(perm);
-                                        updateInventory(object,new_item,TASK_INVENTORY_ITEM_KEY,FALSE);                         
-                                        snprintf(buffer, sizeof(buffer), "Setting perms on '%s' [OK]", invname.c_str());                        /* Flawfinder: ignore */
+                                LLUIString status_text = getString("status_text");
+                                status_text.setArg("[NAME]", invname.c_str());
+                                // Check whether we appear to have the appropriate permissions to change permission on this item.
+                                // Although the server will disallow any forbidden changes, it is a good idea to guess correctly
+                                // so that we can warn the user. The risk of getting this check wrong is therefore the possibility
+                                // of incorrectly choosing to not attempt to make a valid change.
+                                //
+                                // Trouble is this is extremely difficult to do and even when we know the results
+                                // it is difficult to design the best messaging. Therefore in this initial implementation
+                                // we'll always try to set the requested permissions and consider all cases successful
+                                // and perhaps later try to implement a smarter, friendlier solution. -MG
+                                if(true
+                                        //gAgent.allowOperation(PERM_MODIFY, perm, GP_OBJECT_MANIPULATE) // for group and everyone masks
+                                        //|| something else // for next owner perms
+                                        )
+                                {
+                                        perm.setMaskNext(LLFloaterPerms::getNextOwnerPerms("BulkChange"));
+                                        perm.setMaskEveryone(LLFloaterPerms::getEveryonePerms("BulkChange"));
+                                        perm.setMaskGroup(LLFloaterPerms::getGroupPerms("BulkChange"));
+                                        new_item->setPermissions(perm); // here's the beef
+                                        updateInventory(object,new_item,TASK_INVENTORY_ITEM_KEY,FALSE);
+                                        //status_text.setArg("[STATUS]", getString("status_ok_text"));
+                                        status_text.setArg("[STATUS]", "");
                                 }
                                 else
                                 {
-                                        llinfos<<"NOT setting perms"<<llendl;
-                                        snprintf(buffer, sizeof(buffer), "Setting perms on '%s' [FAILED]", invname.c_str());                    /* Flawfinder: ignore */
-
+                                        //status_text.setArg("[STATUS]", getString("status_bad_text"));
+                                        status_text.setArg("[STATUS]", "");
                                 }
                                 
-                                list->addCommentText(buffer);
-
-                                if(recurse &&  ( (*it)->getType() == LLAssetType::AT_OBJECT && processObject))
-                                {
-                                        //Add this object back to the queue to be processed as it has inventory
-                                        snprintf(buffer, sizeof(buffer), "Queueing object '%s' for open", invname.c_str());
-                                        llwarns << "Queueing object "<< invname.c_str() << " ID "<< (*it)->getUUID()<<llendl;
-                                        mObjectIDs.put((*it)->getUUID());
-                                        // This will not YET work. as this is not a viewer object the unpack will fail                  
-                                }
-
+                                list->addCommentText(status_text.getString());
+
+                                //TODO if we are an object inside an object we should check a recuse flag and if set
+                                //open the inventory of the object and recurse - Michelle2 Zenovka
+
+                                //      if(recurse &&  ( (*it)->getType() == LLAssetType::AT_OBJECT && processObject))
+                                //      {
+                                //              I think we need to get the UUID of the object inside the inventory
+                                //              call item->fetchFromServer();
+                                //              we need a call back to say item has arrived *sigh*
+                                //              we then need to do something like
+                                //              LLUUID* id = new LLUUID(mID);
+                                //              registerVOInventoryListener(obj,id);
+                                //              requestVOInventory();
+                                //      }
                         }
                 }
         }
 
-        nextObject();   
+        nextObject();
 }
 
 
@@ -557,18 +344,12 @@ void LLFloaterBulkPermission::handleInventory(LLViewerObject* viewer_obj, Invent
 // we could do this via LLViewerObject::updateInventory but that uses inventory call backs and buggers
 // us up and we would have a dodgy item iterator
 
-void LLFloaterBulkPermission::updateInventory(
-        LLViewerObject* object,
-        LLViewerInventoryItem* item,
-        U8 key,
-        bool is_new)
+void LLFloaterBulkPermission::updateInventory(LLViewerObject* object, LLViewerInventoryItem* item, U8 key, bool is_new)
 {
         LLMemType mt(LLMemType::MTYPE_OBJECT);
         
-
-        // This slices the object into what we're concerned about on the
-        // viewer. The simulator will take the permissions and transfer
-        // ownership.
+        // This slices the object into what we're concerned about on the viewer. 
+        // The simulator will take the permissions and transfer ownership.
         LLPointer<LLViewerInventoryItem> task_item =
                 new LLViewerInventoryItem(item->getUUID(), mID, item->getPermissions(),
                                                                   item->getAssetUUID(), item->getType(),
@@ -589,6 +370,5 @@ void LLFloaterBulkPermission::updateInventory(
         msg->nextBlockFast(_PREHASH_InventoryData);
         task_item->packMessage(msg);
         msg->sendReliable(object->getRegion()->getHost());
-
 }