path: root/indra/newview/llfavoritesbar.h

/** 
 * @file llfavoritesbar.h
 * @brief LLFavoritesBarCtrl base class
 *
 * $LicenseInfo:firstyear=2009&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_LLFAVORITESBARCTRL_H
#define LL_LLFAVORITESBARCTRL_H

#include "llbutton.h"
#include "lluictrl.h"
#include "lltextbox.h"

#include "llinventoryobserver.h"
#include "llinventorymodel.h"
#include "llviewerinventory.h"
#include "llinitdestroyclass.h"

class LLMenuItemCallGL;
class LLToggleableMenu;

class LLFavoritesBarCtrl : public LLUICtrl, public LLInventoryObserver
{
public:
	struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
	{
		Optional<LLUIImage*> image_drag_indication;
		Optional<LLTextBox::Params> more_button;
		Optional<LLTextBox::Params> label;
		Params();
	};

protected:
	LLFavoritesBarCtrl(const Params&);
	friend class LLUICtrlFactory;
    friend class LLItemCopiedCallback;
public:
	virtual ~LLFavoritesBarCtrl();

	/*virtual*/ bool postBuild() override;

	/*virtual*/ bool handleDragAndDrop(S32 x, S32 y, MASK mask, bool drop,
		EDragAndDropType cargo_type, void* cargo_data, EAcceptance* accept, std::string& tooltip_msg) override;
	bool handleDragAndDropToMenu(S32 x, S32 y, MASK mask, bool drop,
		EDragAndDropType cargo_type, void* cargo_data, EAcceptance* accept, std::string& tooltip_msg);

	/*virtual*/ bool	handleHover(S32 x, S32 y, MASK mask) override;
	/*virtual*/ bool	handleRightMouseDown(S32 x, S32 y, MASK mask) override;
	// LLInventoryObserver observer trigger
    /*virtual*/ void changed(U32 mask) override;
    /*virtual*/ void reshape(S32 width, S32 height, bool called_from_parent = true) override;
    /*virtual*/ void draw() override;

	void showDragMarker(bool show) { mShowDragMarker = show; }
	void setLandingTab(LLUICtrl* tab) { mLandingTab = tab; }

protected:
    void updateButtons(bool force_update = false);
	LLButton* createButton(const LLPointer<LLViewerInventoryItem> item, const LLButton::Params& button_params, S32 x_offset );
	const LLButton::Params& getButtonParams();
	bool collectFavoriteItems(LLInventoryModel::item_array_t &items);

	void onButtonClick(LLUUID id);
	void onButtonRightClick(LLUUID id,LLView* button,S32 x,S32 y,MASK mask);
	
	void onButtonMouseDown(LLUUID id, LLUICtrl* button, S32 x, S32 y, MASK mask);
	void onButtonMouseUp(LLUUID id, LLUICtrl* button, S32 x, S32 y, MASK mask);

	void onEndDrag();

	bool enableSelected(const LLSD& userdata);
	void doToSelected(const LLSD& userdata);
	static bool onRenameCommit(const LLSD& notification, const LLSD& response);
	bool isClipboardPasteable() const;
	void pasteFromClipboard() const;
	
	void showDropDownMenu();

	void onMoreTextBoxClicked();

	LLHandle<LLView> mOverflowMenuHandle;
	LLHandle<LLView> mContextMenuHandle;

	LLUUID mFavoriteFolderId;
	const LLFontGL *mFont;
	S32 mFirstDropDownItem;
	S32 mDropDownItemsCount;
	bool mUpdateDropDownItems;
	bool mRestoreOverflowMenu;
	bool mDragToOverflowMenu;
	bool mGetPrevItems;

	LLUUID mSelectedItemID;
	LLFrameTimer mItemsChangedTimer;
	LLUIImage* mImageDragIndication;

private:
	/*
	 * Helper function to make code more readable. It handles all drag and drop
	 * operations of the existing favorites items to the favorites bar to on the overflow menu.
	 */
	void handleExistingFavoriteDragAndDrop(S32 x, S32 y);

	/*
	 * Helper function to make code more readable. It handles all drag and drop
	 * operations of the new landmark to the favorites bar or to the overflow menu.
	 */
	void handleNewFavoriteDragAndDrop(LLInventoryItem *item, const LLUUID& favorites_id, S32 x, S32 y);

	// finds a control under the specified LOCAL point
	LLUICtrl* findChildByLocalCoords(S32 x, S32 y);

	bool findDragAndDropTarget(LLUUID &target_id, bool &insert_before, S32 x, S32 y);

	// checks if the current order of the favorites items must be saved
	bool needToSaveItemsOrder(const LLInventoryModel::item_array_t& items);

	/**
	 * inserts an item identified by insertedItemId BEFORE an item identified by beforeItemId.
	 * this function assumes that an item identified by insertedItemId doesn't exist in items array.
	 */
	void insertItem(LLInventoryModel::item_array_t& items, const LLUUID& dest_item_id, LLViewerInventoryItem* insertedItem, bool insert_before);

	// finds an item by it's UUID in the items array
	LLInventoryModel::item_array_t::iterator findItemByUUID(LLInventoryModel::item_array_t& items, const LLUUID& id);

	void createOverflowMenu();

	void updateOverflowMenuItems();

	// Fits menu item label width with favorites menu width
	void fitLabelWidth(LLMenuItemCallGL* menu_item);

	void addOpenLandmarksMenuItem(LLToggleableMenu* menu);

	void positionAndShowOverflowMenu();

	bool mShowDragMarker;
	LLUICtrl* mLandingTab;
	LLUICtrl* mLastTab;
	LLTextBox* mMoreTextBox;
	LLTextBox* mBarLabel;

	LLUUID mDragItemId;
	bool mStartDrag;
	LLInventoryModel::item_array_t mItems;

    static F64 sWaitingForCallabck;
    bool mItemsListDirty;

	S32 mMouseX;
	S32 mMouseY;

	boost::signals2::connection mEndDragConnection;
};

/**
 * Class to store sorting order of favorites landmarks in a local file. EXT-3985.
 * It replaced previously implemented solution to store sort index in landmark's name as a "<N>@" prefix.
 * Data are stored in user home directory.
 */
class LLFavoritesOrderStorage : public LLSingleton<LLFavoritesOrderStorage>
	, public LLDestroyClass<LLFavoritesOrderStorage>
{
	LLSINGLETON(LLFavoritesOrderStorage);
	LOG_CLASS(LLFavoritesOrderStorage);
public:
	/**
	 * Sets sort index for specified with LLUUID favorite landmark
	 */
	void setSortIndex(const LLViewerInventoryItem* inv_item, S32 sort_index);

	/**
	 * Gets sort index for specified with LLUUID favorite landmark
	 */
	S32 getSortIndex(const LLUUID& inv_item_id);
	void removeSortIndex(const LLUUID& inv_item_id);

	void getSLURL(const LLUUID& asset_id);

	// Saves current order of the passed items using inventory item sort field.
	// Resets 'items' sort fields and saves them on server.
	// Is used to save order for Favorites folder.
	void saveItemsOrder(const LLInventoryModel::item_array_t& items);

	void saveOrder();

	void rearrangeFavoriteLandmarks(const LLUUID& source_item_id, const LLUUID& target_item_id);

	/**
	 * Implementation of LLDestroyClass. Calls cleanup() instance method.
	 *
	 * It is important this callback is called before gInventory is cleaned.
	 * For now it is called from LLAppViewer::cleanup() -> LLAppViewer::disconnectViewer(),
	 * Inventory is cleaned later from LLAppViewer::cleanup() after LLAppViewer::disconnectViewer() is called.
	 * @see cleanup()
	 */
	static void destroyClass();
	static std::string getStoredFavoritesFilename(const std::string &grid);
	static std::string getStoredFavoritesFilename();
	static std::string getSavedOrderFileName();

	// Remove record of specified user's favorites from file on disk.
	static void removeFavoritesRecordOfUser(const std::string &user, const std::string &grid);
	// Remove record of current user's favorites from file on disk.
	static void removeFavoritesRecordOfUser();

	bool saveFavoritesRecord(bool pref_changed = false);
	void showFavoritesOnLoginChanged(bool show);

	bool isStorageUpdateNeeded();

	LLInventoryModel::item_array_t mPrevFavorites;
	LLSD mStorageFavorites;
	bool mRecreateFavoriteStorage;

	const static S32 NO_INDEX;
	static bool mSaveOnExit;
	bool mUpdateRequired;
	std::map<LLUUID,std::string> mFavoriteNames;

private:
	/**
	 * Removes sort indexes for items which are not in Favorites bar for now.
	 */
	void cleanup();

	const static std::string SORTING_DATA_FILE_NAME;

	void load();

	void onLandmarkLoaded(const LLUUID& asset_id, class LLLandmark* landmark);
	void storeFavoriteSLURL(const LLUUID& asset_id, std::string& slurl);

	typedef std::map<LLUUID, S32> sort_index_map_t;
	sort_index_map_t mSortIndexes;

	typedef std::map<LLUUID, std::string> slurls_map_t;
	slurls_map_t mSLURLs;
	std::set<LLUUID> mMissingSLURLs;
	bool mIsDirty;

	struct IsNotInFavorites
	{
		IsNotInFavorites(const LLInventoryModel::item_array_t& items)
			: mFavoriteItems(items)
		{

		}

		/**
		 * Returns true if specified item is not found among inventory items
		 */
		bool operator()(const sort_index_map_t::value_type& id_index_pair) const
		{
			LLPointer<LLViewerInventoryItem> item = gInventory.getItem(id_index_pair.first);
			if (item.isNull()) return true;

			LLInventoryModel::item_array_t::const_iterator found_it =
				std::find(mFavoriteItems.begin(), mFavoriteItems.end(), item);

			return found_it == mFavoriteItems.end();
		}
	private:
		LLInventoryModel::item_array_t mFavoriteItems;
	};

};

inline
LLFavoritesOrderStorage::LLFavoritesOrderStorage() :
	mIsDirty(false),
	mUpdateRequired(false),
	mRecreateFavoriteStorage(false)
{ load(); }

#endif // LL_LLFAVORITESBARCTRL_H