Extracted LLInventoryObserver classes from LLInventoryModel.h into their own subclass, LLInventoryObservers.h. This reduces dependencies and compile times, and makes these classes easier to locate.
I have not yet refactored classes to remove #include "llinventorymodel.h" and replace with #include "llinventoryobservers.h". This will happen later.meow-7.2.2
Loren Shih
parent
de6ca4c5ea
commit
6eb5f380e3
|
|
@ -252,6 +252,7 @@ set(viewer_SOURCE_FILES
|
|||
llinventoryfilter.cpp
|
||||
llinventoryfunctions.cpp
|
||||
llinventorymodel.cpp
|
||||
llinventoryobservers.cpp
|
||||
llinventorypanel.cpp
|
||||
llinventorysubtreepanel.cpp
|
||||
lljoystickbutton.cpp
|
||||
|
|
@ -748,6 +749,7 @@ set(viewer_HEADER_FILES
|
|||
llinventoryfilter.h
|
||||
llinventoryfunctions.h
|
||||
llinventorymodel.h
|
||||
llinventoryobservers.h
|
||||
llinventorypanel.h
|
||||
llinventorysubtreepanel.h
|
||||
lljoystickbutton.h
|
||||
|
|
|
|||
|
|
@ -3721,513 +3721,6 @@ bool LLNameCategoryCollector::operator()(
|
|||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
///----------------------------------------------------------------------------
|
||||
/// Observers
|
||||
///----------------------------------------------------------------------------
|
||||
|
||||
void LLInventoryCompletionObserver::changed(U32 mask)
|
||||
{
|
||||
// scan through the incomplete items and move or erase them as
|
||||
// appropriate.
|
||||
if(!mIncomplete.empty())
|
||||
{
|
||||
for(item_ref_t::iterator it = mIncomplete.begin(); it < mIncomplete.end(); )
|
||||
{
|
||||
LLViewerInventoryItem* item = gInventory.getItem(*it);
|
||||
if(!item)
|
||||
{
|
||||
it = mIncomplete.erase(it);
|
||||
continue;
|
||||
}
|
||||
if(item->isComplete())
|
||||
{
|
||||
mComplete.push_back(*it);
|
||||
it = mIncomplete.erase(it);
|
||||
continue;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if(mIncomplete.empty())
|
||||
{
|
||||
done();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LLInventoryCompletionObserver::watchItem(const LLUUID& id)
|
||||
{
|
||||
if(id.notNull())
|
||||
{
|
||||
mIncomplete.push_back(id);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void LLInventoryFetchObserver::changed(U32 mask)
|
||||
{
|
||||
// scan through the incomplete items and move or erase them as
|
||||
// appropriate.
|
||||
if(!mIncomplete.empty())
|
||||
{
|
||||
for(item_ref_t::iterator it = mIncomplete.begin(); it < mIncomplete.end(); )
|
||||
{
|
||||
LLViewerInventoryItem* item = gInventory.getItem(*it);
|
||||
if(!item)
|
||||
{
|
||||
// BUG: This can cause done() to get called prematurely below.
|
||||
// This happens with the LLGestureInventoryFetchObserver that
|
||||
// loads gestures at startup. JC
|
||||
it = mIncomplete.erase(it);
|
||||
continue;
|
||||
}
|
||||
if(item->isComplete())
|
||||
{
|
||||
mComplete.push_back(*it);
|
||||
it = mIncomplete.erase(it);
|
||||
continue;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if(mIncomplete.empty())
|
||||
{
|
||||
done();
|
||||
}
|
||||
}
|
||||
//llinfos << "LLInventoryFetchObserver::changed() mComplete size " << mComplete.size() << llendl;
|
||||
//llinfos << "LLInventoryFetchObserver::changed() mIncomplete size " << mIncomplete.size() << llendl;
|
||||
}
|
||||
|
||||
bool LLInventoryFetchObserver::isEverythingComplete() const
|
||||
{
|
||||
return mIncomplete.empty();
|
||||
}
|
||||
|
||||
void fetch_items_from_llsd(const LLSD& items_llsd)
|
||||
{
|
||||
if (!items_llsd.size()) return;
|
||||
LLSD body;
|
||||
body[0]["cap_name"] = "FetchInventory";
|
||||
body[1]["cap_name"] = "FetchLib";
|
||||
for (S32 i=0; i<items_llsd.size();i++)
|
||||
{
|
||||
if (items_llsd[i]["owner_id"].asString() == gAgent.getID().asString())
|
||||
{
|
||||
body[0]["items"].append(items_llsd[i]);
|
||||
continue;
|
||||
}
|
||||
if (items_llsd[i]["owner_id"].asString() == ALEXANDRIA_LINDEN_ID.asString())
|
||||
{
|
||||
body[1]["items"].append(items_llsd[i]);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
for (S32 i=0; i<body.size(); i++)
|
||||
{
|
||||
if (0 >= body[i].size()) continue;
|
||||
std::string url = gAgent.getRegion()->getCapability(body[i]["cap_name"].asString());
|
||||
|
||||
if (!url.empty())
|
||||
{
|
||||
body[i]["agent_id"] = gAgent.getID();
|
||||
LLHTTPClient::post(url, body[i], new LLInventoryModel::fetchInventoryResponder(body[i]));
|
||||
break;
|
||||
}
|
||||
|
||||
LLMessageSystem* msg = gMessageSystem;
|
||||
BOOL start_new_message = TRUE;
|
||||
for (S32 j=0; j<body[i]["items"].size(); j++)
|
||||
{
|
||||
LLSD item_entry = body[i]["items"][j];
|
||||
if(start_new_message)
|
||||
{
|
||||
start_new_message = FALSE;
|
||||
msg->newMessageFast(_PREHASH_FetchInventory);
|
||||
msg->nextBlockFast(_PREHASH_AgentData);
|
||||
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
|
||||
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
|
||||
}
|
||||
msg->nextBlockFast(_PREHASH_InventoryData);
|
||||
msg->addUUIDFast(_PREHASH_OwnerID, item_entry["owner_id"].asUUID());
|
||||
msg->addUUIDFast(_PREHASH_ItemID, item_entry["item_id"].asUUID());
|
||||
if(msg->isSendFull(NULL))
|
||||
{
|
||||
start_new_message = TRUE;
|
||||
gAgent.sendReliableMessage();
|
||||
}
|
||||
}
|
||||
if(!start_new_message)
|
||||
{
|
||||
gAgent.sendReliableMessage();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LLInventoryFetchObserver::fetchItems(
|
||||
const LLInventoryFetchObserver::item_ref_t& ids)
|
||||
{
|
||||
LLUUID owner_id;
|
||||
LLSD items_llsd;
|
||||
for(item_ref_t::const_iterator it = ids.begin(); it < ids.end(); ++it)
|
||||
{
|
||||
LLViewerInventoryItem* item = gInventory.getItem(*it);
|
||||
if(item)
|
||||
{
|
||||
if(item->isComplete())
|
||||
{
|
||||
// It's complete, so put it on the complete container.
|
||||
mComplete.push_back(*it);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
owner_id = item->getPermissions().getOwner();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// assume it's agent inventory.
|
||||
owner_id = gAgent.getID();
|
||||
}
|
||||
|
||||
// It's incomplete, so put it on the incomplete container, and
|
||||
// pack this on the message.
|
||||
mIncomplete.push_back(*it);
|
||||
|
||||
// Prepare the data to fetch
|
||||
LLSD item_entry;
|
||||
item_entry["owner_id"] = owner_id;
|
||||
item_entry["item_id"] = (*it);
|
||||
items_llsd.append(item_entry);
|
||||
}
|
||||
fetch_items_from_llsd(items_llsd);
|
||||
}
|
||||
|
||||
// virtual
|
||||
void LLInventoryFetchDescendentsObserver::changed(U32 mask)
|
||||
{
|
||||
for(folder_ref_t::iterator it = mIncompleteFolders.begin(); it < mIncompleteFolders.end();)
|
||||
{
|
||||
LLViewerInventoryCategory* cat = gInventory.getCategory(*it);
|
||||
if(!cat)
|
||||
{
|
||||
it = mIncompleteFolders.erase(it);
|
||||
continue;
|
||||
}
|
||||
if(isComplete(cat))
|
||||
{
|
||||
mCompleteFolders.push_back(*it);
|
||||
it = mIncompleteFolders.erase(it);
|
||||
continue;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if(mIncompleteFolders.empty())
|
||||
{
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
void LLInventoryFetchDescendentsObserver::fetchDescendents(
|
||||
const folder_ref_t& ids)
|
||||
{
|
||||
for(folder_ref_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
|
||||
{
|
||||
LLViewerInventoryCategory* cat = gInventory.getCategory(*it);
|
||||
if(!cat) continue;
|
||||
if(!isComplete(cat))
|
||||
{
|
||||
cat->fetchDescendents(); //blindly fetch it without seeing if anything else is fetching it.
|
||||
mIncompleteFolders.push_back(*it); //Add to list of things being downloaded for this observer.
|
||||
}
|
||||
else
|
||||
{
|
||||
mCompleteFolders.push_back(*it);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool LLInventoryFetchDescendentsObserver::isEverythingComplete() const
|
||||
{
|
||||
return mIncompleteFolders.empty();
|
||||
}
|
||||
|
||||
bool LLInventoryFetchDescendentsObserver::isComplete(LLViewerInventoryCategory* cat)
|
||||
{
|
||||
S32 version = cat->getVersion();
|
||||
S32 descendents = cat->getDescendentCount();
|
||||
if((LLViewerInventoryCategory::VERSION_UNKNOWN == version)
|
||||
|| (LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN == descendents))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// it might be complete - check known descendents against
|
||||
// currently available.
|
||||
LLInventoryModel::cat_array_t* cats;
|
||||
LLInventoryModel::item_array_t* items;
|
||||
gInventory.getDirectDescendentsOf(cat->getUUID(), cats, items);
|
||||
if(!cats || !items)
|
||||
{
|
||||
// bit of a hack - pretend we're done if they are gone or
|
||||
// incomplete. should never know, but it would suck if this
|
||||
// kept tight looping because of a corrupt memory state.
|
||||
return true;
|
||||
}
|
||||
S32 known = cats->count() + items->count();
|
||||
if(descendents == known)
|
||||
{
|
||||
// hey - we're done.
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void LLInventoryFetchComboObserver::changed(U32 mask)
|
||||
{
|
||||
if(!mIncompleteItems.empty())
|
||||
{
|
||||
for(item_ref_t::iterator it = mIncompleteItems.begin(); it < mIncompleteItems.end(); )
|
||||
{
|
||||
LLViewerInventoryItem* item = gInventory.getItem(*it);
|
||||
if(!item)
|
||||
{
|
||||
it = mIncompleteItems.erase(it);
|
||||
continue;
|
||||
}
|
||||
if(item->isComplete())
|
||||
{
|
||||
mCompleteItems.push_back(*it);
|
||||
it = mIncompleteItems.erase(it);
|
||||
continue;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
}
|
||||
if(!mIncompleteFolders.empty())
|
||||
{
|
||||
for(folder_ref_t::iterator it = mIncompleteFolders.begin(); it < mIncompleteFolders.end();)
|
||||
{
|
||||
LLViewerInventoryCategory* cat = gInventory.getCategory(*it);
|
||||
if(!cat)
|
||||
{
|
||||
it = mIncompleteFolders.erase(it);
|
||||
continue;
|
||||
}
|
||||
if(gInventory.isCategoryComplete(*it))
|
||||
{
|
||||
mCompleteFolders.push_back(*it);
|
||||
it = mIncompleteFolders.erase(it);
|
||||
continue;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
}
|
||||
if(!mDone && mIncompleteItems.empty() && mIncompleteFolders.empty())
|
||||
{
|
||||
mDone = true;
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
void LLInventoryFetchComboObserver::fetch(
|
||||
const folder_ref_t& folder_ids,
|
||||
const item_ref_t& item_ids)
|
||||
{
|
||||
lldebugs << "LLInventoryFetchComboObserver::fetch()" << llendl;
|
||||
for(folder_ref_t::const_iterator fit = folder_ids.begin(); fit != folder_ids.end(); ++fit)
|
||||
{
|
||||
LLViewerInventoryCategory* cat = gInventory.getCategory(*fit);
|
||||
if(!cat) continue;
|
||||
if(!gInventory.isCategoryComplete(*fit))
|
||||
{
|
||||
cat->fetchDescendents();
|
||||
lldebugs << "fetching folder " << *fit <<llendl;
|
||||
mIncompleteFolders.push_back(*fit);
|
||||
}
|
||||
else
|
||||
{
|
||||
mCompleteFolders.push_back(*fit);
|
||||
lldebugs << "completing folder " << *fit <<llendl;
|
||||
}
|
||||
}
|
||||
|
||||
// Now for the items - we fetch everything which is not a direct
|
||||
// descendent of an incomplete folder because the item will show
|
||||
// up in an inventory descendents message soon enough so we do not
|
||||
// have to fetch it individually.
|
||||
LLSD items_llsd;
|
||||
LLUUID owner_id;
|
||||
for(item_ref_t::const_iterator iit = item_ids.begin(); iit != item_ids.end(); ++iit)
|
||||
{
|
||||
LLViewerInventoryItem* item = gInventory.getItem(*iit);
|
||||
if(!item)
|
||||
{
|
||||
lldebugs << "uanble to find item " << *iit << llendl;
|
||||
continue;
|
||||
}
|
||||
if(item->isComplete())
|
||||
{
|
||||
// It's complete, so put it on the complete container.
|
||||
mCompleteItems.push_back(*iit);
|
||||
lldebugs << "completing item " << *iit << llendl;
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
mIncompleteItems.push_back(*iit);
|
||||
owner_id = item->getPermissions().getOwner();
|
||||
}
|
||||
if(std::find(mIncompleteFolders.begin(), mIncompleteFolders.end(), item->getParentUUID()) == mIncompleteFolders.end())
|
||||
{
|
||||
LLSD item_entry;
|
||||
item_entry["owner_id"] = owner_id;
|
||||
item_entry["item_id"] = (*iit);
|
||||
items_llsd.append(item_entry);
|
||||
}
|
||||
else
|
||||
{
|
||||
lldebugs << "not worrying about " << *iit << llendl;
|
||||
}
|
||||
}
|
||||
fetch_items_from_llsd(items_llsd);
|
||||
}
|
||||
|
||||
void LLInventoryExistenceObserver::watchItem(const LLUUID& id)
|
||||
{
|
||||
if(id.notNull())
|
||||
{
|
||||
mMIA.push_back(id);
|
||||
}
|
||||
}
|
||||
|
||||
void LLInventoryExistenceObserver::changed(U32 mask)
|
||||
{
|
||||
// scan through the incomplete items and move or erase them as
|
||||
// appropriate.
|
||||
if(!mMIA.empty())
|
||||
{
|
||||
for(item_ref_t::iterator it = mMIA.begin(); it < mMIA.end(); )
|
||||
{
|
||||
LLViewerInventoryItem* item = gInventory.getItem(*it);
|
||||
if(!item)
|
||||
{
|
||||
++it;
|
||||
continue;
|
||||
}
|
||||
mExist.push_back(*it);
|
||||
it = mMIA.erase(it);
|
||||
}
|
||||
if(mMIA.empty())
|
||||
{
|
||||
done();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LLInventoryAddedObserver::changed(U32 mask)
|
||||
{
|
||||
if(!(mask & LLInventoryObserver::ADD))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// *HACK: If this was in response to a packet off
|
||||
// the network, figure out which item was updated.
|
||||
LLMessageSystem* msg = gMessageSystem;
|
||||
|
||||
std::string msg_name;
|
||||
if (mMessageName.empty())
|
||||
{
|
||||
msg_name = msg->getMessageName();
|
||||
}
|
||||
else
|
||||
{
|
||||
msg_name = mMessageName;
|
||||
}
|
||||
|
||||
if (msg_name.empty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// We only want newly created inventory items. JC
|
||||
if ( msg_name != "UpdateCreateInventoryItem")
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
|
||||
S32 num_blocks = msg->getNumberOfBlocksFast(_PREHASH_InventoryData);
|
||||
for(S32 i = 0; i < num_blocks; ++i)
|
||||
{
|
||||
titem->unpackMessage(msg, _PREHASH_InventoryData, i);
|
||||
if (!(titem->getUUID().isNull()))
|
||||
{
|
||||
//we don't do anything with null keys
|
||||
mAdded.push_back(titem->getUUID());
|
||||
}
|
||||
}
|
||||
if (!mAdded.empty())
|
||||
{
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
LLInventoryTransactionObserver::LLInventoryTransactionObserver(
|
||||
const LLTransactionID& transaction_id) :
|
||||
mTransactionID(transaction_id)
|
||||
{
|
||||
}
|
||||
|
||||
void LLInventoryTransactionObserver::changed(U32 mask)
|
||||
{
|
||||
if(mask & LLInventoryObserver::ADD)
|
||||
{
|
||||
// This could be it - see if we are processing a bulk update
|
||||
LLMessageSystem* msg = gMessageSystem;
|
||||
if(msg->getMessageName()
|
||||
&& (0 == strcmp(msg->getMessageName(), "BulkUpdateInventory")))
|
||||
{
|
||||
// we have a match for the message - now check the
|
||||
// transaction id.
|
||||
LLUUID id;
|
||||
msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_TransactionID, id);
|
||||
if(id == mTransactionID)
|
||||
{
|
||||
// woo hoo, we found it
|
||||
folder_ref_t folders;
|
||||
item_ref_t items;
|
||||
S32 count;
|
||||
count = msg->getNumberOfBlocksFast(_PREHASH_FolderData);
|
||||
S32 i;
|
||||
for(i = 0; i < count; ++i)
|
||||
{
|
||||
msg->getUUIDFast(_PREHASH_FolderData, _PREHASH_FolderID, id, i);
|
||||
if(id.notNull())
|
||||
{
|
||||
folders.push_back(id);
|
||||
}
|
||||
}
|
||||
count = msg->getNumberOfBlocksFast(_PREHASH_ItemData);
|
||||
for(i = 0; i < count; ++i)
|
||||
{
|
||||
msg->getUUIDFast(_PREHASH_ItemData, _PREHASH_ItemID, id, i);
|
||||
if(id.notNull())
|
||||
{
|
||||
items.push_back(id);
|
||||
}
|
||||
}
|
||||
|
||||
// call the derived class the implements this method.
|
||||
done(folders, items);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
///----------------------------------------------------------------------------
|
||||
/// LLAssetIDMatches
|
||||
///----------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -41,40 +41,27 @@
|
|||
#include "lluuid.h"
|
||||
#include "llpermissionsflags.h"
|
||||
#include "llstring.h"
|
||||
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryObserver
|
||||
//
|
||||
// This class is designed to be a simple abstract base class which can
|
||||
// relay messages when the inventory changes.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// ! REFACTOR ! Remove llinventoryobservers.h and have other files that need it explicitly
|
||||
// include llinventoryobservers.h instead of llinventorymodel.h . This will reduce dependency on
|
||||
// llinventorymodel.h.
|
||||
#include "llinventoryobservers.h"
|
||||
|
||||
class LLInventoryObserver;
|
||||
class LLInventoryObject;
|
||||
class LLInventoryItem;
|
||||
class LLInventoryCategory;
|
||||
class LLViewerInventoryItem;
|
||||
class LLViewerInventoryCategory;
|
||||
class LLViewerInventoryItem;
|
||||
class LLViewerInventoryCategory;
|
||||
class LLMessageSystem;
|
||||
class LLInventoryCollectFunctor;
|
||||
|
||||
class LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
// This enumeration is a way to refer to what changed in a more
|
||||
// human readable format. You can mask the value provided by
|
||||
// chaged() to see if the observer is interested in the change.
|
||||
enum
|
||||
{
|
||||
NONE = 0,
|
||||
LABEL = 1, // name changed
|
||||
INTERNAL = 2, // internal change, eg, asset uuid different
|
||||
ADD = 4, // something added
|
||||
REMOVE = 8, // something deleted
|
||||
STRUCTURE = 16, // structural change, eg, item or folder moved
|
||||
CALLING_CARD = 32, // online, grant status, cancel, etc change
|
||||
ALL = 0xffffffff
|
||||
};
|
||||
virtual ~LLInventoryObserver() {};
|
||||
virtual void changed(U32 mask) = 0;
|
||||
std::string mMessageName; // used by Agent Inventory Service only. [DEV-20328]
|
||||
};
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryModel
|
||||
|
|
@ -87,16 +74,6 @@ public:
|
|||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
|
||||
class LLInventoryObject;
|
||||
class LLInventoryItem;
|
||||
class LLInventoryCategory;
|
||||
class LLViewerInventoryItem;
|
||||
class LLViewerInventoryCategory;
|
||||
class LLViewerInventoryItem;
|
||||
class LLViewerInventoryCategory;
|
||||
class LLMessageSystem;
|
||||
class LLInventoryCollectFunctor;
|
||||
|
||||
class LLInventoryModel
|
||||
{
|
||||
public:
|
||||
|
|
@ -771,183 +748,5 @@ public:
|
|||
LLInventoryItem* item);
|
||||
};
|
||||
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryCompletionObserver
|
||||
//
|
||||
// Class which can be used as a base class for doing something when
|
||||
// when all observed items are locally complete. This class implements
|
||||
// the changed() method of LLInventoryObserver and declares a new
|
||||
// method named done() which is called when all watched items have
|
||||
// complete information in the inventory model.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
class LLInventoryCompletionObserver : public LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
LLInventoryCompletionObserver() {}
|
||||
virtual void changed(U32 mask);
|
||||
|
||||
void watchItem(const LLUUID& id);
|
||||
|
||||
protected:
|
||||
virtual void done() = 0;
|
||||
|
||||
typedef std::vector<LLUUID> item_ref_t;
|
||||
item_ref_t mComplete;
|
||||
item_ref_t mIncomplete;
|
||||
};
|
||||
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryFetchObserver
|
||||
//
|
||||
// This class is much like the LLInventoryCompletionObserver, except
|
||||
// that it handles all the the fetching necessary. Override the done()
|
||||
// method to do the thing you want.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
class LLInventoryFetchObserver : public LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
LLInventoryFetchObserver() {}
|
||||
virtual void changed(U32 mask);
|
||||
|
||||
typedef std::vector<LLUUID> item_ref_t;
|
||||
|
||||
bool isEverythingComplete() const;
|
||||
void fetchItems(const item_ref_t& ids);
|
||||
virtual void done() = 0;
|
||||
|
||||
protected:
|
||||
item_ref_t mComplete;
|
||||
item_ref_t mIncomplete;
|
||||
};
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryFetchDescendentsObserver
|
||||
//
|
||||
// This class is much like the LLInventoryCompletionObserver, except
|
||||
// that it handles fetching based on category. Override the done()
|
||||
// method to do the thing you want.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class LLInventoryFetchDescendentsObserver : public LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
LLInventoryFetchDescendentsObserver() {}
|
||||
virtual void changed(U32 mask);
|
||||
|
||||
typedef std::vector<LLUUID> folder_ref_t;
|
||||
void fetchDescendents(const folder_ref_t& ids);
|
||||
bool isEverythingComplete() const;
|
||||
virtual void done() = 0;
|
||||
|
||||
protected:
|
||||
bool isComplete(LLViewerInventoryCategory* cat);
|
||||
folder_ref_t mIncompleteFolders;
|
||||
folder_ref_t mCompleteFolders;
|
||||
};
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryFetchComboObserver
|
||||
//
|
||||
// This class does an appropriate combination of fetch descendents and
|
||||
// item fetches based on completion of categories and items. Much like
|
||||
// the fetch and fetch descendents, this will call done() when everything
|
||||
// has arrived.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class LLInventoryFetchComboObserver : public LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
LLInventoryFetchComboObserver() : mDone(false) {}
|
||||
virtual void changed(U32 mask);
|
||||
|
||||
typedef std::vector<LLUUID> folder_ref_t;
|
||||
typedef std::vector<LLUUID> item_ref_t;
|
||||
void fetch(const folder_ref_t& folder_ids, const item_ref_t& item_ids);
|
||||
|
||||
virtual void done() = 0;
|
||||
|
||||
protected:
|
||||
bool mDone;
|
||||
folder_ref_t mCompleteFolders;
|
||||
folder_ref_t mIncompleteFolders;
|
||||
item_ref_t mCompleteItems;
|
||||
item_ref_t mIncompleteItems;
|
||||
};
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryExistenceObserver
|
||||
//
|
||||
// This class is used as a base class for doing somethign when all the
|
||||
// observed item ids exist in the inventory somewhere. You can derive
|
||||
// a class from this class and implement the done() method to do
|
||||
// something useful.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
class LLInventoryExistenceObserver : public LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
LLInventoryExistenceObserver() {}
|
||||
virtual void changed(U32 mask);
|
||||
|
||||
void watchItem(const LLUUID& id);
|
||||
|
||||
protected:
|
||||
virtual void done() = 0;
|
||||
|
||||
typedef std::vector<LLUUID> item_ref_t;
|
||||
item_ref_t mExist;
|
||||
item_ref_t mMIA;
|
||||
};
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryAddedObserver
|
||||
//
|
||||
// This class is used as a base class for doing something when
|
||||
// a new item arrives in inventory.
|
||||
// It does not watch for a certain UUID, rather it acts when anything is added
|
||||
// Derive a class from this class and implement the done() method to do
|
||||
// something useful.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
class LLInventoryAddedObserver : public LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
LLInventoryAddedObserver() : mAdded() {}
|
||||
virtual void changed(U32 mask);
|
||||
|
||||
protected:
|
||||
virtual void done() = 0;
|
||||
|
||||
typedef std::vector<LLUUID> item_ref_t;
|
||||
item_ref_t mAdded;
|
||||
};
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Class LLInventoryTransactionObserver
|
||||
//
|
||||
// Class which can be used as a base class for doing something when an
|
||||
// inventory transaction completes.
|
||||
//
|
||||
// *NOTE: This class is not quite complete. Avoid using unless you fix up it's
|
||||
// functionality gaps.
|
||||
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
class LLInventoryTransactionObserver : public LLInventoryObserver
|
||||
{
|
||||
public:
|
||||
LLInventoryTransactionObserver(const LLTransactionID& transaction_id);
|
||||
virtual void changed(U32 mask);
|
||||
|
||||
protected:
|
||||
typedef std::vector<LLUUID> folder_ref_t;
|
||||
typedef std::vector<LLUUID> item_ref_t;
|
||||
virtual void done(const folder_ref_t& folders, const item_ref_t& items) = 0;
|
||||
|
||||
LLTransactionID mTransactionID;
|
||||
};
|
||||
|
||||
|
||||
#endif // LL_LLINVENTORYMODEL_H
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue