6 files changed, 210 insertions, 32 deletions

diff --git a/linden/indra/newview/llfloateropenobject.cpp b/linden/indra/newview/llfloateropenobject.cpp
index fc483dd..3e672b5 100644
--- a/linden/indra/newview/llfloateropenobject.cpp
+++ b/linden/indra/newview/llfloateropenobject.cpp
@@ -155,29 +155,76 @@ void LLFloaterOpenObject::moveToInventory(bool wear)
         {
                 parent_category_id = gAgent.getInventoryRootID();
         }
+
+        LLCategoryCreate* cat_data = new LLCategoryCreate(object_id, wear);
         LLUUID category_id = gInventory.createNewCategory(parent_category_id, 
-                LLAssetType::AT_NONE, 
-                name);
-
-        LLCatAndWear* data = new LLCatAndWear;
-        data->mCatID = category_id;
-        data->mWear = wear;
-
-        // Copy and/or move the items into the newly created folder.
-        // Ignore any "you're going to break this item" messages.
-        BOOL success = move_inv_category_world_to_agent(object_id, category_id, TRUE,
-                                                                                                        callbackMoveInventory, 
-                                                                                                        (void*)data);
-        if (!success)
-        {
-                delete data;
-                data = NULL;
+                LLAssetType::AT_NONE,
+                                                                                                          name,
+                                                                                                          callbackCreateInventoryCategory,
+                                                                                                          (void*)cat_data);
+
 
-                LLNotifications::instance().add("OpenObjectCannotCopy");
+        // If we get a null category ID, we are using a capability in
+        // createNewCategory and we will handle the following in the
+        // callbackCreateInventoryCategory routine.
+        if (category_id.notNull())
+        {
+                delete cat_data;
+
+                LLCatAndWear* data = new LLCatAndWear;
+                data->mCatID = category_id;
+                data->mWear = wear;
+                data->mFolderResponded = false;
+
+                // Copy and/or move the items into the newly created folder.
+                // Ignore any "you're going to break this item" messages.
+                BOOL success = move_inv_category_world_to_agent(object_id, category_id, TRUE,
+                                                                        callbackMoveInventory,
+                                                                        (void*)data);
+                if (!success)
+                {
+                        delete data;
+                        data = NULL;
+        
+                        LLNotifications::instance().add("OpenObjectCannotCopy");
+                }
         }
 }
 
 // static
+void LLFloaterOpenObject::callbackCreateInventoryCategory(const LLSD& result, void* data)
+{
+        LLCategoryCreate* cat_data = (LLCategoryCreate*)data;
+        if (result.has("failure") and result["failure"])
+        {
+                delete cat_data;
+                return;
+        }
+
+        LLUUID category_id = result["folder_id"].asUUID();
+        LLCatAndWear* wear_data = new LLCatAndWear;
+
+        wear_data->mCatID = category_id;
+        wear_data->mWear = cat_data->mWear;
+        wear_data->mFolderResponded = true;
+
+        // Copy and/or move the items into the newly created folder.
+        // Ignore any "you're going to break this item" messages.
+
+        BOOL success = move_inv_category_world_to_agent(cat_data->mObjectID, category_id, TRUE,
+                                                                                                        callbackMoveInventory, 
+                                                                                                        (void*)wear_data);
+        if (!success)
+        {
+                delete wear_data;
+                wear_data = NULL;
+
+                LLNotifications::instance().add("OpenObjectCannotCopy");
+        }
+        delete cat_data;        
+ }
+
+// static
 void LLFloaterOpenObject::callbackMoveInventory(S32 result, void* data)
 {
         LLCatAndWear* cat = (LLCatAndWear*)data;
diff --git a/linden/indra/newview/llfloateropenobject.h b/linden/indra/newview/llfloateropenobject.h
index 27653a5..4b89158 100644
--- a/linden/indra/newview/llfloateropenobject.h
+++ b/linden/indra/newview/llfloateropenobject.h
@@ -50,10 +50,24 @@ public:
         static void show();
         static void dirty();
         
+        class LLCategoryCreate
+        {
+                public:
+                        LLCategoryCreate(LLUUID object_id, bool wear)
+                        :       mObjectID(object_id),
+                                mWear(wear)
+                        {}
+
+                public:
+                        LLUUID mObjectID;
+                        bool mWear;
+        };
+
         struct LLCatAndWear
         {
                 LLUUID mCatID;
                 bool mWear;
+                bool mFolderResponded;
         };
 
 protected:
@@ -67,6 +81,7 @@ protected:
 
         static void onClickMoveToInventory(void* data);
         static void onClickMoveAndWear(void* data);
+        static void callbackCreateInventoryCategory(const LLSD& result, void* data);
         static void callbackMoveInventory(S32 result, void* data);
         static void* createPanelInventory(void* data);
 
diff --git a/linden/indra/newview/llinventorybridge.cpp b/linden/indra/newview/llinventorybridge.cpp
index f71df2d..eb2170a 100644
--- a/linden/indra/newview/llinventorybridge.cpp
+++ b/linden/indra/newview/llinventorybridge.cpp
@@ -1610,18 +1610,21 @@ void LLRightClickInventoryFetchDescendentsObserver::done()
 class LLInventoryCopyAndWearObserver : public LLInventoryObserver
 {
 public:
-        LLInventoryCopyAndWearObserver(const LLUUID& cat_id, int count) :mCatID(cat_id), mContentsCount(count), mFolderAdded(FALSE) {}
+        LLInventoryCopyAndWearObserver(const LLUUID& cat_id,
+                                                                   int count,
+                                                                   bool folder_added = false)
+        :       mCatID(cat_id),
+                mContentsCount(count),
+                mFolderAdded(folder_added) {}
         virtual ~LLInventoryCopyAndWearObserver() {}
         virtual void changed(U32 mask);
 
 protected:
         LLUUID mCatID;
         int    mContentsCount;
-        BOOL   mFolderAdded;
+        bool   mFolderAdded;
 };
 
-
-
 void LLInventoryCopyAndWearObserver::changed(U32 mask)
 {
         if((mask & (LLInventoryObserver::ADD)) != 0)
@@ -2331,13 +2334,16 @@ bool move_task_inventory_callback(const LLSD& notification, const LLSD& response
 
         if(option == 0 && object)
         {
-                if (cat_and_wear && cat_and_wear->mWear)
+                if (cat_and_wear && cat_and_wear->mWear) // && !cat_and_wear->mFolderResponded)
                 {
                         InventoryObjectList inventory_objects;
                         object->getInventoryContents(inventory_objects);
                         int contents_count = inventory_objects.size()-1; //subtract one for containing folder
 
-                        LLInventoryCopyAndWearObserver* inventoryObserver = new LLInventoryCopyAndWearObserver(cat_and_wear->mCatID, contents_count);
+                        LLInventoryCopyAndWearObserver* inventoryObserver;
+                        inventoryObserver = new LLInventoryCopyAndWearObserver(cat_and_wear->mCatID,
+                                                                                                                                   contents_count,
+                                                                                                                                   cat_and_wear->mFolderResponded);
                         gInventory.addObserver(inventoryObserver);
                 }
 
diff --git a/linden/indra/newview/llinventorymodel.cpp b/linden/indra/newview/llinventorymodel.cpp
index 58a2bdc..dc216e3 100644
--- a/linden/indra/newview/llinventorymodel.cpp
+++ b/linden/indra/newview/llinventorymodel.cpp
@@ -60,6 +60,7 @@
 #include "llvoavatar.h"
 #include "llsdutil.h"
 #include <deque>
+#include "llfloateropenobject.h"
 
 // [RLVa:KB]
 #include "rlvhandler.h"
@@ -396,25 +397,83 @@ LLUUID LLInventoryModel::findCategoryByName(std::string name)
         return LLUUID::null;
 }
 
+class LLCreateInventoryCategoryResponder : public LLHTTPClient::Responder
+{
+public:
+        LLCreateInventoryCategoryResponder(LLInventoryModel* model, 
+                                                                           void (*callback)(const LLSD&, void*),
+                                                                           void* user_data)
+        :       mModel(model),
+                mCallback(callback), 
+                mData(user_data) 
+        {
+        }
+
+        virtual void error(U32 status, const std::string& reason)
+        {
+                llwarns << "CreateInventoryCategory failed. status = " << status
+                                << ", reason = \"" << reason << "\"" << llendl;
+        }
+
+        virtual void result(const LLSD& content)
+        {
+                // Server has created folder.
+
+                LLUUID category_id = content["folder_id"].asUUID();
+
+                // Add the category to the internal representation
+                LLPointer<LLViewerInventoryCategory> cat;
+                cat = new LLViewerInventoryCategory(category_id,
+                                                                                        content["parent_id"].asUUID(),
+                                                                                        (LLAssetType::EType)content["type"].asInteger(),
+                                                                                        content["name"].asString(), 
+                                                                                        gAgent.getID());
+                cat->setVersion(LLViewerInventoryCategory::VERSION_INITIAL);
+                cat->setDescendentCount(0);
+                LLInventoryModel::LLCategoryUpdate update(cat->getParentUUID(), 1);
+                mModel->accountForUpdate(update);
+                mModel->updateCategory(cat);
+
+                if (mCallback && mData)
+                {
+                        mCallback(content, mData);
+                }
+        }
+
+private:
+        void (*mCallback)(const LLSD&, void*);
+        void* mData;
+        LLInventoryModel* mModel;
+};
+
 // Convenience function to create a new category. You could call
 // updateCategory() with a newly generated UUID category, but this
 // version will take care of details like what the name should be
 // based on preferred type. Returns the UUID of the new category.
 LLUUID LLInventoryModel::createNewCategory(const LLUUID& parent_id,
-                                                                                   LLAssetType::EType preferred_type,
-                                                                                   const std::string& pname)
+                                                                                   LLAssetType::EType preferred_type,                                                                              const std::string& pname,
+                                                                                   void (*callback)(const LLSD&, void*),
+                                                                                   void* user_data)
 {
+        llassert_always(NULL != callback);
+
         LLUUID id;
+
         if(!isInventoryUsable())
         {
                 llwarns << "Inventory is broken." << llendl;
-                return id;
-        }
+                LLSD result;
+                result["failure"] = true;
+                callback(result, user_data);
+        }
+
 
         if(preferred_type == LLAssetType::AT_SIMSTATE)
         {
                 LL_DEBUGS("Inventory") << "Attempt to create simstate category." << LL_ENDL;
-                return id;
+                LLSD result;
+                result["failure"] = true;
+                callback(result, user_data);
         }
 
         id.generate();
@@ -433,6 +492,54 @@ LLUUID LLInventoryModel::createNewCategory(const LLUUID& parent_id,
                 name.assign(NEW_CATEGORY_NAME);
         }
 
+        if (user_data)  // callback required for acked message.
+        {
+
+
+                LLViewerRegion* viewer_region = gAgent.getRegion();
+
+                if (!viewer_region->capabilitiesReceived())
+                {
+                        LL_DEBUGS("Inventory") << "We didn't get the region caps yet." << LL_ENDL;
+                }
+
+                std::string url;
+                if (viewer_region)
+                {
+                        url = viewer_region->getCapability("CreateInventoryCategory");
+                }
+
+                if (!url.empty())
+                {
+                        LL_DEBUGS("Inventory") << "Using the CreateInventoryCategory capability."   << LL_ENDL;
+                        // Let's use the new capability.
+                        LLSD request, body;
+                        body["folder_id"] = id;
+                        body["parent_id"] = parent_id;
+                        body["type"] = (LLSD::Integer) preferred_type;
+                        body["name"] = name;
+
+                        request["message"] = "CreateInventoryCategory";
+                        request["payload"] = body;
+
+                        LLHTTPClient::post(url, body,
+                                                           new LLCreateInventoryCategoryResponder(this,
+                                                                                                                                          callback,
+                                                                                                                                          user_data));
+                        return LLUUID::null;
+                }
+                else
+                {
+                        LL_DEBUGS("Inventory") << "Cap url empty"   << LL_ENDL;
+                }
+        }
+        else //NULL == user_data
+        {
+                // user_data is a LLCategoryCreate object instantiated in the calling
+                // function - bug (or low memory - any leaks?).
+                llwarns << "NULL user_data" << llendl;
+        }
+
         // Add the category to the internal representation
         LLPointer<LLViewerInventoryCategory> cat =
                 new LLViewerInventoryCategory(id, parent_id, preferred_type, name, gAgent.getID());
@@ -3173,7 +3280,7 @@ void LLInventoryModel::processBulkUpdateInventory(LLMessageSystem* msg, void**)
                 //              << titem->getParentUUID() << llendl;
                 U32 callback_id;
                 msg->getU32Fast(_PREHASH_ItemData, _PREHASH_CallbackID, callback_id);
-                if(titem->getUUID().notNull())
+                if (titem->getUUID().notNull()) // && callback_id.notNull())
                 {
                         items.push_back(titem);
                         cblist.push_back(InventoryCallbackInfo(callback_id, titem->getUUID()));
diff --git a/linden/indra/newview/llinventorymodel.h b/linden/indra/newview/llinventorymodel.h
index 7222c60..7788c34 100644
--- a/linden/indra/newview/llinventorymodel.h
+++ b/linden/indra/newview/llinventorymodel.h
@@ -308,9 +308,11 @@ public:
         // based on preferred type. Returns the UUID of the new
         // category. If you want to use the default name based on type,
         // pass in a NULL to the 'name parameter.
-        LLUUID createNewCategory(const LLUUID& parent_id,
-                                                         LLAssetType::EType preferred_type,
-                                                         const std::string& name);
+        LLUUID createNewCategory(const LLUUID& parent_id,
+                                                         LLAssetType::EType preferred_type,
+                                                         const std::string& name,
+                                                         void (*callback)(const LLSD&, void*) = NULL,
+                                                         void* user_data = NULL);
 
         LLUUID findCategoryByName(std::string name);
 
diff --git a/linden/indra/newview/llviewerregion.cpp b/linden/indra/newview/llviewerregion.cpp
index a43e0c0..2fafe30 100644
--- a/linden/indra/newview/llviewerregion.cpp
+++ b/linden/indra/newview/llviewerregion.cpp
@@ -1428,6 +1428,7 @@ void LLViewerRegion::setSeedCapability(const std::string& url)
         LLSD capabilityNames = LLSD::emptyArray();
         capabilityNames.append("ChatSessionRequest");
         capabilityNames.append("CopyInventoryFromNotecard");
+        capabilityNames.append("CreateInventoryCategory");
         // Aurora settings -- MC
         capabilityNames.append("DispatchOpenRegionSettings");
         capabilityNames.append("DispatchRegionInfo");