483 lines
17 KiB
C++
483 lines
17 KiB
C++
/**
|
|
* @file llviewerinventory.h
|
|
* @brief Declaration of the inventory bits that only used on the viewer.
|
|
*
|
|
* $LicenseInfo:firstyear=2002&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#ifndef LL_LLVIEWERINVENTORY_H
|
|
#define LL_LLVIEWERINVENTORY_H
|
|
|
|
#include "llinventory.h"
|
|
#include "llframetimer.h"
|
|
#include "llwearable.h"
|
|
#include "llinitdestroyclass.h" //for LLDestroyClass
|
|
#include "llinventorysettings.h"
|
|
|
|
#include <boost/signals2.hpp> // boost::signals2::trackable
|
|
|
|
class LLInventoryPanel;
|
|
class LLFolderView;
|
|
class LLFolderBridge;
|
|
class LLViewerInventoryCategory;
|
|
class LLInventoryCallback;
|
|
class LLAvatarName;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLViewerInventoryItem
|
|
//
|
|
// An inventory item represents something that the current user has in
|
|
// their inventory.
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
class LLViewerInventoryItem : public LLInventoryItem, public boost::signals2::trackable
|
|
{
|
|
public:
|
|
typedef std::vector<LLPointer<LLViewerInventoryItem> > item_array_t;
|
|
|
|
protected:
|
|
~LLViewerInventoryItem( void ); // ref counted
|
|
bool extractSortFieldAndDisplayName(S32* sortField, std::string* displayName) const { return extractSortFieldAndDisplayName(mName, sortField, displayName); }
|
|
mutable std::string mDisplayName;
|
|
|
|
public:
|
|
virtual LLAssetType::EType getType() const;
|
|
virtual const LLUUID& getAssetUUID() const;
|
|
virtual const LLUUID& getProtectedAssetUUID() const; // returns LLUUID::null if current agent does not have permission to expose this asset's UUID to the user
|
|
virtual const std::string& getName() const;
|
|
virtual S32 getSortField() const;
|
|
//virtual void setSortField(S32 sortField);
|
|
virtual void getSLURL(); //Caches SLURL for landmark. //*TODO: Find a better way to do it and remove this method from here.
|
|
virtual const LLPermissions& getPermissions() const;
|
|
virtual const bool getIsFullPerm() const; // 'fullperm' in the popular sense: modify-ok & copy-ok & transfer-ok, no special god rules applied
|
|
virtual const LLUUID& getCreatorUUID() const;
|
|
virtual const std::string& getDescription() const;
|
|
virtual const LLSaleInfo& getSaleInfo() const;
|
|
virtual const LLUUID& getThumbnailUUID() const;
|
|
virtual LLInventoryType::EType getInventoryType() const;
|
|
virtual bool isWearableType() const;
|
|
virtual LLWearableType::EType getWearableType() const;
|
|
virtual bool isSettingsType() const;
|
|
virtual LLSettingsType::type_e getSettingsType() const;
|
|
|
|
virtual U32 getFlags() const;
|
|
virtual time_t getCreationDate() const;
|
|
virtual U32 getCRC32() const; // really more of a checksum.
|
|
|
|
static bool extractSortFieldAndDisplayName(const std::string& name, S32* sortField, std::string* displayName);
|
|
|
|
// construct a complete viewer inventory item
|
|
LLViewerInventoryItem(const LLUUID& uuid, const LLUUID& parent_uuid,
|
|
const LLPermissions& permissions,
|
|
const LLUUID& asset_uuid,
|
|
LLAssetType::EType type,
|
|
LLInventoryType::EType inv_type,
|
|
const std::string& name,
|
|
const std::string& desc,
|
|
const LLSaleInfo& sale_info,
|
|
U32 flags,
|
|
time_t creation_date_utc);
|
|
|
|
// construct a viewer inventory item which has the minimal amount
|
|
// of information to use in the UI.
|
|
LLViewerInventoryItem(
|
|
const LLUUID& item_id,
|
|
const LLUUID& parent_id,
|
|
const std::string& name,
|
|
LLInventoryType::EType inv_type);
|
|
|
|
// construct an invalid and incomplete viewer inventory item.
|
|
// usually useful for unpacking or importing or what have you.
|
|
// *NOTE: it is important to call setComplete() if you expect the
|
|
// operations to provide all necessary information.
|
|
LLViewerInventoryItem();
|
|
// Create a copy of an inventory item from a pointer to another item
|
|
// Note: Because InventoryItems are ref counted,
|
|
// reference copy (a = b) is prohibited
|
|
LLViewerInventoryItem(const LLViewerInventoryItem* other);
|
|
LLViewerInventoryItem(const LLInventoryItem* other);
|
|
|
|
void copyViewerItem(const LLViewerInventoryItem* other);
|
|
/*virtual*/ void copyItem(const LLInventoryItem* other);
|
|
|
|
// construct a new clone of this item - it creates a new viewer
|
|
// inventory item using the copy constructor, and returns it.
|
|
// It is up to the caller to delete (unref) the item.
|
|
void cloneViewerItem(LLPointer<LLViewerInventoryItem>& newitem) const;
|
|
|
|
// virtual methods
|
|
virtual void updateParentOnServer(bool restamp) const;
|
|
virtual void updateServer(bool is_new) const;
|
|
void fetchFromServer(void) const;
|
|
|
|
virtual void packMessage(LLMessageSystem* msg) const;
|
|
virtual bool unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num = 0);
|
|
virtual bool unpackMessage(const LLSD& item);
|
|
virtual bool importLegacyStream(std::istream& input_stream);
|
|
|
|
// new methods
|
|
bool isFinished() const { return mIsComplete; }
|
|
void setComplete(bool complete) { mIsComplete = complete; }
|
|
//void updateAssetOnServer() const;
|
|
|
|
virtual void setTransactionID(const LLTransactionID& transaction_id);
|
|
struct comparePointers
|
|
{
|
|
bool operator()(const LLPointer<LLViewerInventoryItem>& a, const LLPointer<LLViewerInventoryItem>& b)
|
|
{
|
|
return a->getName().compare(b->getName()) < 0;
|
|
}
|
|
};
|
|
LLTransactionID getTransactionID() const { return mTransactionID; }
|
|
|
|
bool getIsBrokenLink() const; // true if the baseitem this points to doesn't exist in memory.
|
|
LLViewerInventoryItem *getLinkedItem() const;
|
|
LLViewerInventoryCategory *getLinkedCategory() const;
|
|
|
|
// Checks the items permissions (for owner, group, or everyone) and returns true if all mask bits are set.
|
|
bool checkPermissionsSet(PermissionMask mask) const;
|
|
PermissionMask getPermissionMask() const;
|
|
|
|
// callback
|
|
void onCallingCardNameLookup(const LLUUID& id, const LLAvatarName& name);
|
|
|
|
// If this is a broken link, try to fix it and any other identical link.
|
|
bool regenerateLink();
|
|
|
|
public:
|
|
bool mIsComplete;
|
|
LLTransactionID mTransactionID;
|
|
};
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLViewerInventoryCategory
|
|
//
|
|
// An instance of this class represents a category of inventory
|
|
// items. Users come with a set of default categories, and can create
|
|
// new ones as needed.
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
class LLViewerInventoryCategory : public LLInventoryCategory
|
|
{
|
|
public:
|
|
typedef std::vector<LLPointer<LLViewerInventoryCategory> > cat_array_t;
|
|
|
|
protected:
|
|
~LLViewerInventoryCategory();
|
|
|
|
public:
|
|
LLViewerInventoryCategory(const LLUUID& uuid, const LLUUID& parent_uuid,
|
|
LLFolderType::EType preferred_type,
|
|
const std::string& name,
|
|
const LLUUID& owner_id);
|
|
LLViewerInventoryCategory(const LLUUID& owner_id);
|
|
// Create a copy of an inventory category from a pointer to another category
|
|
// Note: Because InventoryCategorys are ref counted, reference copy (a = b)
|
|
// is prohibited
|
|
LLViewerInventoryCategory(const LLViewerInventoryCategory* other);
|
|
void copyViewerCategory(const LLViewerInventoryCategory* other);
|
|
|
|
virtual void updateParentOnServer(bool restamp_children) const;
|
|
virtual void updateServer(bool is_new) const;
|
|
|
|
virtual void packMessage(LLMessageSystem* msg) const;
|
|
|
|
const LLUUID& getOwnerID() const { return mOwnerID; }
|
|
|
|
// Version handling
|
|
enum { VERSION_UNKNOWN = -1, VERSION_INITIAL = 1 };
|
|
S32 getVersion() const;
|
|
void setVersion(S32 version);
|
|
|
|
// Returns true if a fetch was issued (not nessesary in progress).
|
|
// no requests will happen during expiry_seconds even if fetch completed
|
|
bool fetch(S32 expiry_seconds = 10);
|
|
|
|
typedef enum {
|
|
FETCH_NONE = 0,
|
|
FETCH_NORMAL,
|
|
FETCH_RECURSIVE,
|
|
FETCH_FAILED, // back off
|
|
} EFetchType;
|
|
EFetchType getFetching();
|
|
// marks as fetch being in progress or as done
|
|
void setFetching(EFetchType);
|
|
|
|
// used to help make caching more robust - for example, if
|
|
// someone is getting 4 packets but logs out after 3. the viewer
|
|
// may never know the cache is wrong.
|
|
enum { DESCENDENT_COUNT_UNKNOWN = -1 };
|
|
S32 getDescendentCount() const { return mDescendentCount; }
|
|
void setDescendentCount(S32 descendents) { mDescendentCount = descendents; }
|
|
// How many descendents do we currently have information for in the InventoryModel?
|
|
S32 getViewerDescendentCount() const;
|
|
|
|
LLSD exportLLSD() const;
|
|
bool importLLSD(const LLSD& cat_data);
|
|
|
|
void determineFolderType();
|
|
void changeType(LLFolderType::EType new_folder_type);
|
|
virtual void unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num = 0);
|
|
virtual bool unpackMessage(const LLSD& category);
|
|
|
|
// returns true if the category object will accept the incoming item
|
|
bool acceptItem(LLInventoryItem* inv_item);
|
|
|
|
private:
|
|
friend class LLInventoryModel;
|
|
void localizeName(); // intended to be called from the LLInventoryModel
|
|
|
|
protected:
|
|
LLUUID mOwnerID;
|
|
S32 mVersion;
|
|
S32 mDescendentCount;
|
|
EFetchType mFetching;
|
|
LLFrameTimer mDescendentsRequested;
|
|
};
|
|
|
|
class LLInventoryCallback : public LLRefCount
|
|
{
|
|
public:
|
|
virtual ~LLInventoryCallback() {}
|
|
virtual void fire(const LLUUID& inv_item) = 0;
|
|
};
|
|
|
|
class LLViewerJointAttachment;
|
|
|
|
void rez_attachment_cb(const LLUUID& inv_item, LLViewerJointAttachment *attachmentp);
|
|
|
|
void activate_gesture_cb(const LLUUID& inv_item);
|
|
|
|
void create_script_cb(const LLUUID& inv_item);
|
|
void create_gesture_cb(const LLUUID& inv_item);
|
|
void create_notecard_cb(const LLUUID& inv_item);
|
|
|
|
class AddFavoriteLandmarkCallback : public LLInventoryCallback
|
|
{
|
|
public:
|
|
AddFavoriteLandmarkCallback() : mTargetLandmarkId(LLUUID::null) {}
|
|
void setTargetLandmarkId(const LLUUID& target_uuid) { mTargetLandmarkId = target_uuid; }
|
|
|
|
private:
|
|
void fire(const LLUUID& inv_item);
|
|
|
|
LLUUID mTargetLandmarkId;
|
|
};
|
|
|
|
typedef boost::function<void(const LLUUID&)> inventory_func_type;
|
|
typedef boost::function<void(const LLSD&)> llsd_func_type;
|
|
typedef boost::function<void()> nullary_func_type;
|
|
|
|
void no_op_inventory_func(const LLUUID&); // A do-nothing inventory_func
|
|
void no_op_llsd_func(const LLSD&); // likewise for LLSD
|
|
void no_op(); // A do-nothing nullary func.
|
|
|
|
// Shim between inventory callback and boost function/callable
|
|
class LLBoostFuncInventoryCallback: public LLInventoryCallback
|
|
{
|
|
public:
|
|
|
|
LLBoostFuncInventoryCallback(inventory_func_type fire_func,
|
|
nullary_func_type destroy_func = no_op):
|
|
mDestroyFunc(destroy_func)
|
|
{
|
|
mFireFuncs.push_back(fire_func);
|
|
}
|
|
|
|
LLBoostFuncInventoryCallback()
|
|
{
|
|
}
|
|
|
|
void addOnFireFunc(inventory_func_type fire_func)
|
|
{
|
|
mFireFuncs.push_back(fire_func);
|
|
}
|
|
|
|
// virtual
|
|
void fire(const LLUUID& item_id)
|
|
{
|
|
for (inventory_func_type &func: mFireFuncs)
|
|
{
|
|
func(item_id);
|
|
}
|
|
}
|
|
|
|
// virtual
|
|
~LLBoostFuncInventoryCallback()
|
|
{
|
|
mDestroyFunc();
|
|
}
|
|
|
|
|
|
private:
|
|
std::list<inventory_func_type> mFireFuncs;
|
|
nullary_func_type mDestroyFunc;
|
|
};
|
|
|
|
// misc functions
|
|
//void inventory_reliable_callback(void**, S32 status);
|
|
|
|
class LLInventoryCallbackManager : public LLDestroyClass<LLInventoryCallbackManager>
|
|
{
|
|
friend class LLDestroyClass<LLInventoryCallbackManager>;
|
|
public:
|
|
LLInventoryCallbackManager();
|
|
~LLInventoryCallbackManager();
|
|
|
|
void fire(U32 callback_id, const LLUUID& item_id);
|
|
U32 registerCB(LLPointer<LLInventoryCallback> cb);
|
|
private:
|
|
typedef std::map<U32, LLPointer<LLInventoryCallback> > callback_map_t;
|
|
callback_map_t mMap;
|
|
U32 mLastCallback;
|
|
static LLInventoryCallbackManager *sInstance;
|
|
static void destroyClass();
|
|
|
|
public:
|
|
static bool is_instantiated() { return sInstance != NULL; }
|
|
};
|
|
extern LLInventoryCallbackManager gInventoryCallbacks;
|
|
|
|
|
|
const U8 NO_INV_SUBTYPE{ 0 };
|
|
|
|
// *TODO: Find a home for these
|
|
void create_inventory_item(const LLUUID& agent_id, const LLUUID& session_id,
|
|
const LLUUID& parent, const LLTransactionID& transaction_id,
|
|
const std::string& name,
|
|
const std::string& desc, LLAssetType::EType asset_type,
|
|
LLInventoryType::EType inv_type, U8 subtype,
|
|
U32 next_owner_perm,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void create_inventory_wearable(const LLUUID& agent_id, const LLUUID& session_id,
|
|
const LLUUID& parent, const LLTransactionID& transaction_id,
|
|
const std::string& name,
|
|
const std::string& desc, LLAssetType::EType asset_type,
|
|
LLWearableType::EType wtype,
|
|
U32 next_owner_perm,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void create_inventory_settings(const LLUUID& agent_id, const LLUUID& session_id,
|
|
const LLUUID& parent, const LLTransactionID& transaction_id,
|
|
const std::string& name, const std::string& desc,
|
|
LLSettingsType::type_e settype,
|
|
U32 next_owner_perm, LLPointer<LLInventoryCallback> cb);
|
|
|
|
|
|
void create_inventory_callingcard(const LLUUID& avatar_id, const LLUUID& parent = LLUUID::null, LLPointer<LLInventoryCallback> cb=NULL);
|
|
|
|
/**
|
|
* @brief Securely create a new inventory item by copying from another.
|
|
*/
|
|
void copy_inventory_item(
|
|
const LLUUID& agent_id,
|
|
const LLUUID& current_owner,
|
|
const LLUUID& item_id,
|
|
const LLUUID& parent_id,
|
|
const std::string& new_name,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
// utility functions for inventory linking.
|
|
void link_inventory_object(const LLUUID& category,
|
|
LLConstPointer<LLInventoryObject> baseobj,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
void link_inventory_object(const LLUUID& category,
|
|
const LLUUID& id,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
void link_inventory_array(const LLUUID& category,
|
|
LLInventoryObject::const_object_list_t& baseobj_array,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void move_inventory_item(
|
|
const LLUUID& agent_id,
|
|
const LLUUID& session_id,
|
|
const LLUUID& item_id,
|
|
const LLUUID& parent_id,
|
|
const std::string& new_name,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void update_inventory_item(
|
|
LLViewerInventoryItem *update_item,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void update_inventory_item(
|
|
const LLUUID& item_id,
|
|
const LLSD& updates,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void update_inventory_category(
|
|
const LLUUID& cat_id,
|
|
const LLSD& updates,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void remove_inventory_items(
|
|
LLInventoryObject::object_list_t& items,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void remove_inventory_item(
|
|
LLPointer<LLInventoryObject> obj,
|
|
LLPointer<LLInventoryCallback> cb,
|
|
bool immediate_delete = false);
|
|
|
|
void remove_inventory_item(
|
|
const LLUUID& item_id,
|
|
LLPointer<LLInventoryCallback> cb,
|
|
bool immediate_delete = false);
|
|
|
|
void remove_inventory_category(
|
|
const LLUUID& cat_id,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void remove_inventory_object(
|
|
const LLUUID& object_id,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void purge_descendents_of(
|
|
const LLUUID& cat_id,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
const LLUUID get_folder_by_itemtype(const LLInventoryItem *src);
|
|
|
|
void copy_inventory_from_notecard(const LLUUID& destination_id,
|
|
const LLUUID& object_id,
|
|
const LLUUID& notecard_inv_id,
|
|
const LLInventoryItem *src,
|
|
U32 callback_id = 0);
|
|
|
|
void menu_create_inventory_item(LLInventoryPanel* root,
|
|
LLFolderBridge* bridge,
|
|
const LLSD& userdata,
|
|
const LLUUID& default_parent_uuid = LLUUID::null);
|
|
|
|
void menu_create_inventory_item(LLInventoryPanel* panel, LLUUID dest_id, const LLSD& userdata, const LLUUID& default_parent_uuid = LLUUID::null, std::function<void(const LLUUID&)> folder_created_cb = NULL);
|
|
|
|
void slam_inventory_folder(const LLUUID& folder_id,
|
|
const LLSD& contents,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
void remove_folder_contents(const LLUUID& folder_id, bool keep_outfit_links,
|
|
LLPointer<LLInventoryCallback> cb);
|
|
|
|
#endif // LL_LLVIEWERINVENTORY_H
|