diff options
Diffstat (limited to 'indra/newview/llappearancemgr.h')
| -rw-r--r-- | indra/newview/llappearancemgr.h | 291 |
1 files changed, 264 insertions, 27 deletions
diff --git a/indra/newview/llappearancemgr.h b/indra/newview/llappearancemgr.h index 828af32101..28b51ee0f6 100644 --- a/indra/newview/llappearancemgr.h +++ b/indra/newview/llappearancemgr.h @@ -35,54 +35,291 @@ #include "llsingleton.h" #include "llinventorymodel.h" +#include "llinventoryobserver.h" #include "llviewerinventory.h" +#include "llcallbacklist.h" class LLWearable; -struct LLWearableHoldingPattern; +class LLWearableHoldingPattern; +class LLInventoryCallback; class LLAppearanceManager: public LLSingleton<LLAppearanceManager> { + friend class LLSingleton<LLAppearanceManager>; + public: - static void updateAppearanceFromCOF(); - static bool needToSaveCOF(); - static void changeOutfit(bool proceed, const LLUUID& category, bool append); - static void updateCOFFromCategory(const LLUUID& category, bool append); - static void rebuildCOFFromOutfit(const LLUUID& category); - static void wearInventoryCategory(LLInventoryCategory* category, bool copy, bool append); - static void wearInventoryCategoryOnAvatar(LLInventoryCategory* category, bool append); - static void wearOutfitByName(const std::string& name); - static void shallowCopyCategory(const LLUUID& src_id, const LLUUID& dst_id, - LLPointer<LLInventoryCallback> cb); + void updateAppearanceFromCOF(); + bool needToSaveCOF(); + void updateCOF(const LLUUID& category, bool append = false); + void wearInventoryCategory(LLInventoryCategory* category, bool copy, bool append); + void wearInventoryCategoryOnAvatar(LLInventoryCategory* category, bool append); + void wearOutfitByName(const std::string& name); + void changeOutfit(bool proceed, const LLUUID& category, bool append); + + // Copy all items and the src category itself. + void shallowCopyCategory(const LLUUID& src_id, const LLUUID& dst_id, + LLPointer<LLInventoryCallback> cb); + + // Copy all items in a category. + void shallowCopyCategoryContents(const LLUUID& src_id, const LLUUID& dst_id, + LLPointer<LLInventoryCallback> cb); + + // Find the Current Outfit folder. + const LLUUID getCOF() const; + + // Finds the folder link to the currently worn outfit + const LLViewerInventoryItem *getBaseOutfitLink(); + bool getBaseOutfitName(std::string &name); + + // Update the displayed outfit name in UI. + void updatePanelOutfitName(const std::string& name); + + void createBaseOutfitLink(const LLUUID& category, LLPointer<LLInventoryCallback> link_waiter); + + void updateAgentWearables(LLWearableHoldingPattern* holder, bool append); + + // For debugging - could be moved elsewhere. + void dumpCat(const LLUUID& cat_id, const std::string& msg); + void dumpItemArray(const LLInventoryModel::item_array_t& items, const std::string& msg); + + // Attachment link management + void unregisterAttachment(const LLUUID& item_id); + void registerAttachment(const LLUUID& item_id); + void setAttachmentInvLinkEnable(bool val); + void linkRegisteredAttachments(); + + // utility function for bulk linking. + void linkAll(const LLUUID& category, + LLInventoryModel::item_array_t& items, + LLPointer<LLInventoryCallback> cb); // Add COF link to individual item. - static void wearItem(LLInventoryItem* item, bool do_update = true); + void addCOFItemLink(const LLUUID& item_id, bool do_update = true); + void addCOFItemLink(const LLInventoryItem *item, bool do_update = true); + + // Remove COF entries + void removeCOFItemLinks(const LLUUID& item_id, bool do_update = true); // Add COF link to ensemble folder. - static void wearEnsemble(LLInventoryCategory* item, bool do_update = true); - static LLUUID getCOF(); + void addEnsembleLink(LLInventoryCategory* item, bool do_update = true); - // Remove COF entries - static void removeItemLinks(const LLUUID& item_id, bool do_update = true); + //has the current outfit changed since it was loaded? + bool isOutfitDirty() { return mOutfitIsDirty; } - // For debugging - could be moved elsewhere. - static void dumpCat(const LLUUID& cat_id, std::string str); + // set false if you just loaded the outfit, true otherwise + void setOutfitDirty(bool isDirty) { mOutfitIsDirty = isDirty; } + + // manually compare ouftit folder link to COF to see if outfit has changed. + // should only be necessary to do on initial login. + void updateIsDirty(); + + // Called when self avatar is first fully visible. + void onFirstFullyVisible(); + +protected: + LLAppearanceManager(); + ~LLAppearanceManager(); private: - static void getCOFValidDescendents(const LLUUID& category, - LLInventoryModel::item_array_t& items); - - static void getUserDescendents(const LLUUID& category, + + void filterWearableItems(LLInventoryModel::item_array_t& items, S32 max_per_type); + + void getDescendentsOfAssetType(const LLUUID& category, + LLInventoryModel::item_array_t& items, + LLAssetType::EType type, + bool follow_folder_links); + + void getUserDescendents(const LLUUID& category, LLInventoryModel::item_array_t& wear_items, LLInventoryModel::item_array_t& obj_items, LLInventoryModel::item_array_t& gest_items, bool follow_folder_links); - static void onWearableAssetFetch(LLWearable* wearable, void* data); - static void updateAgentWearables(LLWearableHoldingPattern* holder, bool append); - static bool isMandatoryWearableType(EWearableType type); - static void checkMandatoryWearableTypes(const LLUUID& category, std::set<EWearableType>& types_found); - static void purgeCOFBeforeRebuild(const LLUUID& category); + + void purgeCategory(const LLUUID& category, bool keep_outfit_links); + void purgeBaseOutfitLink(const LLUUID& category); + + std::set<LLUUID> mRegisteredAttachments; + bool mAttachmentInvLinkEnabled; + bool mOutfitIsDirty; + + ////////////////////////////////////////////////////////////////////////////////// + // Item-specific convenience functions +public: + // Is this in the COF? + BOOL getIsInCOF(const LLUUID& obj_id) const; + // Is this in the COF and can the user delete it from the COF? + BOOL getIsProtectedCOFItem(const LLUUID& obj_id) const; }; #define SUPPORT_ENSEMBLES 0 +LLUUID findDescendentCategoryIDByName(const LLUUID& parent_id,const std::string& name); + +// Shim class and template function to allow arbitrary boost::bind +// expressions to be run as one-time idle callbacks. +template <typename T> +class OnIdleCallback +{ +public: + OnIdleCallback(T callable): + mCallable(callable) + { + } + static void onIdle(void *data) + { + gIdleCallbacks.deleteFunction(onIdle, data); + OnIdleCallback<T>* self = reinterpret_cast<OnIdleCallback<T>*>(data); + self->call(); + delete self; + } + void call() + { + mCallable(); + } +private: + T mCallable; +}; + +template <typename T> +void doOnIdle(T callable) +{ + OnIdleCallback<T>* cb_functor = new OnIdleCallback<T>(callable); + gIdleCallbacks.addFunction(&OnIdleCallback<T>::onIdle,cb_functor); +} + +// Shim class and template function to allow arbitrary boost::bind +// expressions to be run as recurring idle callbacks. +template <typename T> +class OnIdleCallbackRepeating +{ +public: + OnIdleCallbackRepeating(T callable): + mCallable(callable) + { + } + // Will keep getting called until the callable returns false. + static void onIdle(void *data) + { + OnIdleCallbackRepeating<T>* self = reinterpret_cast<OnIdleCallbackRepeating<T>*>(data); + bool done = self->call(); + if (done) + { + gIdleCallbacks.deleteFunction(onIdle, data); + delete self; + } + } + bool call() + { + return mCallable(); + } +private: + T mCallable; +}; + +template <typename T> +void doOnIdleRepeating(T callable) +{ + OnIdleCallbackRepeating<T>* cb_functor = new OnIdleCallbackRepeating<T>(callable); + gIdleCallbacks.addFunction(&OnIdleCallbackRepeating<T>::onIdle,cb_functor); +} + +template <class T> +class CallAfterCategoryFetchStage2: public LLInventoryFetchObserver +{ +public: + CallAfterCategoryFetchStage2(T callable): + mCallable(callable) + { + } + ~CallAfterCategoryFetchStage2() + { + } + virtual void done() + { + gInventory.removeObserver(this); + doOnIdle(mCallable); + delete this; + } +protected: + T mCallable; +}; + +template <class T> +class CallAfterCategoryFetchStage1: public LLInventoryFetchDescendentsObserver +{ +public: + CallAfterCategoryFetchStage1(T callable): + mCallable(callable) + { + } + ~CallAfterCategoryFetchStage1() + { + } + virtual void done() + { + // What we do here is get the complete information on the items in + // the library, and set up an observer that will wait for that to + // happen. + LLInventoryModel::cat_array_t cat_array; + LLInventoryModel::item_array_t item_array; + gInventory.collectDescendents(mCompleteFolders.front(), + cat_array, + item_array, + LLInventoryModel::EXCLUDE_TRASH); + S32 count = item_array.count(); + if(!count) + { + llwarns << "Nothing fetched in category " << mCompleteFolders.front() + << llendl; + //dec_busy_count(); + gInventory.removeObserver(this); + delete this; + return; + } + + CallAfterCategoryFetchStage2<T> *stage2 = new CallAfterCategoryFetchStage2<T>(mCallable); + LLInventoryFetchObserver::item_ref_t ids; + for(S32 i = 0; i < count; ++i) + { + ids.push_back(item_array.get(i)->getUUID()); + } + + gInventory.removeObserver(this); + + // do the fetch + stage2->fetchItems(ids); + if(stage2->isEverythingComplete()) + { + // everything is already here - call done. + stage2->done(); + } + else + { + // it's all on it's way - add an observer, and the inventory + // will call done for us when everything is here. + gInventory.addObserver(stage2); + } + delete this; + } +protected: + T mCallable; +}; + +template <class T> +void callAfterCategoryFetch(const LLUUID& cat_id, T callable) +{ + CallAfterCategoryFetchStage1<T> *stage1 = new CallAfterCategoryFetchStage1<T>(callable); + LLInventoryFetchDescendentsObserver::folder_ref_t folders; + folders.push_back(cat_id); + stage1->fetchDescendents(folders); + if (stage1->isEverythingComplete()) + { + stage1->done(); + } + else + { + gInventory.addObserver(stage1); + } +} + #endif |