094587aefd
This involves making libllcommon shared, a change that was not finished for windows/Mac. More changes are needed to indra/newview/viewer_manifest.py for those two operating systems, as well as to indra/copy_win_scripts. I did not test this on linux 32bit, nor non-standalone on that OS, either. I did not check voice (which will very likely not work anyway on 64bit). And currently the webkit plugin doesn't work for me, but I'll fix that in a different commit.
964 lines
33 KiB
C++
964 lines
33 KiB
C++
/**
|
|
* @file llfolderview.h
|
|
* @brief Definition of the folder view collection of classes.
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2001-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
/**
|
|
*
|
|
* The folder view collection of classes provides an interface for
|
|
* making a 'folder view' similar to the way the a single pane file
|
|
* folder interface works.
|
|
*
|
|
*/
|
|
|
|
#ifndef LL_LLFOLDERVIEW_H
|
|
#define LL_LLFOLDERVIEW_H
|
|
|
|
#include <vector>
|
|
#include <map>
|
|
#include <deque>
|
|
|
|
#include "lluictrl.h"
|
|
#include "v4color.h"
|
|
#include "lldarray.h"
|
|
//#include "llviewermenu.h"
|
|
#include "stdenums.h"
|
|
#include "llfontgl.h"
|
|
#include "lleditmenuhandler.h"
|
|
#include "llviewertexture.h"
|
|
#include "lldepthstack.h"
|
|
#include "lltooldraganddrop.h"
|
|
|
|
class LLMenuGL;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLFolderViewEventListener
|
|
//
|
|
// This is an abstract base class that users of the folderview classes
|
|
// would use to catch the useful events emitted from the folder
|
|
// views.
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
class LLFolderViewItem;
|
|
class LLFolderView;
|
|
class LLInventoryModel;
|
|
class LLScrollableContainerView;
|
|
|
|
class LLFolderViewEventListener
|
|
{
|
|
public:
|
|
virtual ~LLFolderViewEventListener( void ) {}
|
|
virtual const std::string& getName() const = 0;
|
|
virtual const std::string& getDisplayName() const = 0;
|
|
virtual const LLUUID& getUUID() const = 0;
|
|
virtual time_t getCreationDate() const = 0; // UTC seconds
|
|
virtual PermissionMask getPermissionMask() const = 0;
|
|
virtual LLUIImagePtr getIcon() const = 0;
|
|
virtual LLFontGL::StyleFlags getLabelStyle() const = 0;
|
|
virtual std::string getLabelSuffix() const = 0;
|
|
virtual void openItem( void ) = 0;
|
|
virtual void previewItem( void ) = 0;
|
|
virtual void selectItem(void) = 0;
|
|
virtual void showProperties(void) = 0;
|
|
virtual BOOL isItemRenameable() const = 0;
|
|
virtual BOOL renameItem(const std::string& new_name) = 0;
|
|
virtual BOOL isItemMovable( void ) = 0; // Can be moved to another folder
|
|
virtual BOOL isItemRemovable( void ) = 0; // Can be destroyed
|
|
virtual BOOL removeItem() = 0;
|
|
virtual void removeBatch(LLDynamicArray<LLFolderViewEventListener*>& batch) = 0;
|
|
virtual void move( LLFolderViewEventListener* parent_listener ) = 0;
|
|
virtual BOOL isItemCopyable() const = 0;
|
|
virtual BOOL copyToClipboard() const = 0;
|
|
virtual BOOL cutToClipboard() const = 0;
|
|
virtual BOOL isClipboardPasteable() const = 0;
|
|
virtual void pasteFromClipboard() = 0;
|
|
virtual void pasteLinkFromClipboard() = 0;
|
|
virtual void buildContextMenu(LLMenuGL& menu, U32 flags) = 0;
|
|
virtual BOOL isUpToDate() const = 0;
|
|
virtual BOOL hasChildren() const = 0;
|
|
virtual LLInventoryType::EType getInventoryType() const = 0;
|
|
virtual void performAction(LLFolderView* folder, LLInventoryModel* model, std::string action) {}
|
|
|
|
// This method should be called when a drag begins. returns TRUE
|
|
// if the drag can begin, otherwise FALSE.
|
|
virtual BOOL startDrag(EDragAndDropType* type, LLUUID* id) const = 0;
|
|
|
|
// This method will be called to determine if a drop can be
|
|
// performed, and will set drop to TRUE if a drop is
|
|
// requested. Returns TRUE if a drop is possible/happened,
|
|
// otherwise FALSE.
|
|
virtual BOOL dragOrDrop(MASK mask, BOOL drop,
|
|
EDragAndDropType cargo_type,
|
|
void* cargo_data) = 0;
|
|
|
|
// This method is called when the object being referenced by the
|
|
// bridge is actually dropped. This allows for cleanup of the old
|
|
// view, reference counting, etc.
|
|
// virtual void dropped() = 0;
|
|
|
|
// this method accesses the parent and arranges and sets it as
|
|
// specified.
|
|
void arrangeAndSet(LLFolderViewItem* focus, BOOL set_selection,
|
|
BOOL take_keyboard_focus = TRUE);
|
|
};
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLFolderViewListenerFunctor
|
|
//
|
|
// This simple abstract base class can be used to applied to all
|
|
// listeners in a hierarchy.
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
class LLFolderViewListenerFunctor
|
|
{
|
|
public:
|
|
virtual ~LLFolderViewListenerFunctor() {}
|
|
virtual void operator()(LLFolderViewEventListener* listener) = 0;
|
|
};
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLFolderViewFunctor
|
|
//
|
|
// Simple abstract base class for applying a functor to folders and
|
|
// items in a folder view hierarchy. This is suboptimal for algorithms
|
|
// that only work folders or only work on items, but I'll worry about
|
|
// that later when it's determined to be too slow.
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
class LLFolderViewItem;
|
|
class LLFolderViewFolder;
|
|
|
|
class LLFolderViewFunctor
|
|
{
|
|
public:
|
|
virtual ~LLFolderViewFunctor() {}
|
|
virtual void doFolder(LLFolderViewFolder* folder) = 0;
|
|
virtual void doItem(LLFolderViewItem* item) = 0;
|
|
};
|
|
|
|
class LLInventoryFilter
|
|
{
|
|
public:
|
|
typedef enum e_folder_show
|
|
{
|
|
SHOW_ALL_FOLDERS,
|
|
SHOW_NON_EMPTY_FOLDERS,
|
|
SHOW_NO_FOLDERS
|
|
} EFolderShow;
|
|
|
|
typedef enum e_filter_behavior
|
|
{
|
|
FILTER_NONE, // nothing to do, already filtered
|
|
FILTER_RESTART, // restart filtering from scratch
|
|
FILTER_LESS_RESTRICTIVE, // existing filtered items will certainly pass this filter
|
|
FILTER_MORE_RESTRICTIVE // if you didn't pass the previous filter, you definitely won't pass this one
|
|
} EFilterBehavior;
|
|
|
|
static const U32 SO_DATE = 1;
|
|
static const U32 SO_FOLDERS_BY_NAME = 2;
|
|
static const U32 SO_SYSTEM_FOLDERS_TO_TOP = 4;
|
|
|
|
LLInventoryFilter(const std::string& name);
|
|
virtual ~LLInventoryFilter();
|
|
|
|
void setFilterTypes(U32 types);
|
|
U32 getFilterTypes() const { return mFilterOps.mFilterTypes; }
|
|
|
|
void setFilterSubString(const std::string& string);
|
|
const std::string getFilterSubString(BOOL trim = FALSE);
|
|
|
|
void setFilterWorn(bool worn) { mFilterWorn = worn; }
|
|
bool getFilterWorn() const { return mFilterWorn; }
|
|
|
|
void setFilterPermissions(PermissionMask perms);
|
|
PermissionMask getFilterPermissions() const { return mFilterOps.mPermissions; }
|
|
|
|
void setDateRange(time_t min_date, time_t max_date);
|
|
void setDateRangeLastLogoff(BOOL sl);
|
|
time_t getMinDate() const { return mFilterOps.mMinDate; }
|
|
time_t getMaxDate() const { return mFilterOps.mMaxDate; }
|
|
|
|
void setHoursAgo(U32 hours);
|
|
U32 getHoursAgo() const { return mFilterOps.mHoursAgo; }
|
|
|
|
void setShowFolderState( EFolderShow state);
|
|
EFolderShow getShowFolderState() { return mFilterOps.mShowFolderState; }
|
|
|
|
void setSortOrder(U32 order);
|
|
U32 getSortOrder() { return mOrder; }
|
|
|
|
BOOL check(LLFolderViewItem* item);
|
|
std::string::size_type getStringMatchOffset() const;
|
|
BOOL isActive();
|
|
BOOL isNotDefault();
|
|
BOOL isModified();
|
|
BOOL isModifiedAndClear();
|
|
BOOL isSinceLogoff();
|
|
void clearModified() { mModified = FALSE; mFilterBehavior = FILTER_NONE; }
|
|
const std::string getName() const { return mName; }
|
|
std::string getFilterText();
|
|
|
|
void setFilterCount(S32 count) { mFilterCount = count; }
|
|
S32 getFilterCount() { return mFilterCount; }
|
|
void decrementFilterCount() { mFilterCount--; }
|
|
|
|
void markDefault();
|
|
void resetDefault();
|
|
|
|
BOOL isFilterWith(LLInventoryType::EType t);
|
|
|
|
S32 getCurrentGeneration() const { return mFilterGeneration; }
|
|
S32 getMinRequiredGeneration() const { return mMinRequiredGeneration; }
|
|
S32 getMustPassGeneration() const { return mMustPassGeneration; }
|
|
|
|
//RN: this is public to allow system to externally force a global refilter
|
|
void setModified(EFilterBehavior behavior = FILTER_RESTART);
|
|
|
|
void toLLSD(LLSD& data);
|
|
void fromLLSD(LLSD& data);
|
|
|
|
protected:
|
|
struct filter_ops
|
|
{
|
|
U32 mFilterTypes;
|
|
time_t mMinDate;
|
|
time_t mMaxDate;
|
|
U32 mHoursAgo;
|
|
EFolderShow mShowFolderState;
|
|
PermissionMask mPermissions;
|
|
};
|
|
filter_ops mFilterOps;
|
|
filter_ops mDefaultFilterOps;
|
|
std::string::size_type mSubStringMatchOffset;
|
|
std::string mFilterSubString;
|
|
bool mFilterWorn;
|
|
U32 mOrder;
|
|
const std::string mName;
|
|
S32 mFilterGeneration;
|
|
S32 mMustPassGeneration;
|
|
S32 mMinRequiredGeneration;
|
|
S32 mFilterCount;
|
|
S32 mNextFilterGeneration;
|
|
EFilterBehavior mFilterBehavior;
|
|
|
|
private:
|
|
U32 mLastLogoff;
|
|
BOOL mModified;
|
|
BOOL mNeedTextRebuild;
|
|
std::string mFilterText;
|
|
};
|
|
|
|
// These are grouping of inventory types.
|
|
// Order matters when sorting system folders to the top.
|
|
enum EInventorySortGroup
|
|
{
|
|
SG_SYSTEM_FOLDER,
|
|
SG_TRASH_FOLDER,
|
|
SG_NORMAL_FOLDER,
|
|
SG_ITEM
|
|
};
|
|
|
|
class LLInventorySort
|
|
{
|
|
public:
|
|
LLInventorySort()
|
|
: mSortOrder(0),
|
|
mByDate(false),
|
|
mSystemToTop(false),
|
|
mFoldersByName(false) { }
|
|
|
|
// Returns true if order has changed
|
|
bool updateSort(U32 order);
|
|
U32 getSort() { return mSortOrder; }
|
|
|
|
bool operator()(const LLFolderViewItem* const& a, const LLFolderViewItem* const& b);
|
|
private:
|
|
U32 mSortOrder;
|
|
bool mByDate;
|
|
bool mSystemToTop;
|
|
bool mFoldersByName;
|
|
};
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLFolderViewItem
|
|
//
|
|
// An instance of this class represents a single item in a folder view
|
|
// such as an inventory item or a file.
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
class LLFontGL;
|
|
class LLFolderViewFolder;
|
|
class LLFolderView;
|
|
|
|
class LLFolderViewItem : public LLUICtrl
|
|
{
|
|
friend class LLFolderViewEventListener;
|
|
|
|
private:
|
|
BOOL mIsSelected;
|
|
|
|
protected:
|
|
static const LLFontGL* sFont;
|
|
static const LLFontGL* sSmallFont;
|
|
static LLColor4 sFgColor;
|
|
static LLColor4 sHighlightBgColor;
|
|
static LLColor4 sHighlightFgColor;
|
|
static LLColor4 sFilterBGColor;
|
|
static LLColor4 sFilterTextColor;
|
|
static LLColor4 sSuffixColor;
|
|
static LLColor4 sSearchStatusColor;
|
|
static LLUIImagePtr sArrowImage;
|
|
static LLUIImagePtr sBoxImage;
|
|
|
|
std::string mLabel;
|
|
std::string mSearchableLabel;
|
|
std::string mSearchableLabelDesc;
|
|
std::string mSearchableLabelCreator;
|
|
std::string mSearchable;
|
|
std::string mType;
|
|
S32 mLabelWidth;
|
|
U32 mCreationDate;
|
|
LLFolderViewFolder* mParentFolder;
|
|
LLFolderViewEventListener* mListener;
|
|
BOOL mIsCurSelection;
|
|
BOOL mSelectPending;
|
|
LLFontGL::StyleFlags mLabelStyle;
|
|
std::string mLabelSuffix;
|
|
LLUIImagePtr mIcon;
|
|
std::string mStatusText;
|
|
BOOL mHasVisibleChildren;
|
|
S32 mIndentation;
|
|
BOOL mFiltered;
|
|
S32 mLastFilterGeneration;
|
|
std::string::size_type mStringMatchOffset;
|
|
F32 mControlLabelRotation;
|
|
LLFolderView* mRoot;
|
|
BOOL mDragAndDropTarget;
|
|
BOOL mIsLoading;
|
|
LLTimer mTimeSinceRequestStart;
|
|
|
|
// helper function to change the selection from the root.
|
|
void changeSelectionFromRoot(LLFolderViewItem* selection, BOOL selected);
|
|
|
|
// helper function to change the selection from the root.
|
|
void extendSelectionFromRoot(LLFolderViewItem* selection);
|
|
|
|
// this is an internal method used for adding items to folders. A
|
|
// no-op at this leve, but reimplemented in derived classes.
|
|
virtual BOOL addItem(LLFolderViewItem*) { return FALSE; }
|
|
virtual BOOL addFolder(LLFolderViewFolder*) { return FALSE; }
|
|
|
|
public:
|
|
// This function clears the currently selected item, and records
|
|
// the specified selected item appropriately for display and use
|
|
// in the UI. If open is TRUE, then folders are opened up along
|
|
// the way to the selection.
|
|
void setSelectionFromRoot(LLFolderViewItem* selection, BOOL openitem,
|
|
BOOL take_keyboard_focus = TRUE);
|
|
|
|
static void initClass();
|
|
static void cleanupClass();
|
|
|
|
// This function is called when the folder view is dirty. It's
|
|
// implemented here but called by derived classes when folding the
|
|
// views.
|
|
void arrangeFromRoot();
|
|
void filterFromRoot( void );
|
|
|
|
// creation_date is in UTC seconds
|
|
LLFolderViewItem( const std::string& name, LLUIImagePtr icon, S32 creation_date, LLFolderView* root, LLFolderViewEventListener* listener );
|
|
virtual ~LLFolderViewItem( void );
|
|
|
|
// addToFolder() returns TRUE if it succeeds. FALSE otherwise
|
|
enum { ARRANGE = TRUE, DO_NOT_ARRANGE = FALSE };
|
|
virtual BOOL addToFolder(LLFolderViewFolder* folder, LLFolderView* root);
|
|
|
|
virtual EInventorySortGroup getSortGroup() const;
|
|
|
|
// Finds width and height of this object and it's children. Also
|
|
// makes sure that this view and it's children are the right size.
|
|
virtual S32 arrange( S32* width, S32* height, S32 filter_generation );
|
|
virtual S32 getItemHeight();
|
|
|
|
// applies filters to control visibility of inventory items
|
|
virtual void filter( LLInventoryFilter& filter);
|
|
|
|
// updates filter serial number and optionally propagated value up to root
|
|
S32 getLastFilterGeneration() { return mLastFilterGeneration; }
|
|
|
|
virtual void dirtyFilter();
|
|
|
|
// If 'selection' is 'this' then note that otherwise ignore.
|
|
// Returns TRUE if this item ends up being selected.
|
|
virtual BOOL setSelection(LLFolderViewItem* selection, BOOL openitem, BOOL take_keyboard_focus);
|
|
|
|
// This method is used to set the selection state of an item.
|
|
// If 'selection' is 'this' then note selection.
|
|
// Returns TRUE if the selection state of this item was changed.
|
|
virtual BOOL changeSelection(LLFolderViewItem* selection, BOOL selected);
|
|
|
|
// this method is used to group select items
|
|
virtual void extendSelection(LLFolderViewItem* selection, LLFolderViewItem* last_selected, LLDynamicArray<LLFolderViewItem*>& items) { }
|
|
|
|
// this method is used to deselect this element
|
|
void deselectItem();
|
|
|
|
// this method is used to select this element
|
|
void selectItem();
|
|
|
|
// gets multiple-element selection
|
|
virtual BOOL getSelectionList(std::set<LLUUID> &selection){return TRUE;}
|
|
|
|
// Returns true is this object and all of its children can be removed (deleted by user)
|
|
virtual BOOL isRemovable();
|
|
|
|
// Returns true is this object and all of its children can be moved
|
|
virtual BOOL isMovable();
|
|
|
|
// destroys this item recursively
|
|
virtual void destroyView();
|
|
|
|
BOOL isSelected() const { return mIsSelected; }
|
|
|
|
void setIsCurSelection(BOOL select) { mIsCurSelection = select; }
|
|
|
|
BOOL getIsCurSelection() { return mIsCurSelection; }
|
|
|
|
BOOL hasVisibleChildren() { return mHasVisibleChildren; }
|
|
|
|
// Call through to the viewed object and return true if it can be
|
|
// removed. Returns true if it's removed.
|
|
//virtual BOOL removeRecursively(BOOL single_item);
|
|
BOOL remove();
|
|
|
|
// Build an appropriate context menu for the item. Flags unused.
|
|
void buildContextMenu(LLMenuGL& menu, U32 flags);
|
|
|
|
// This method returns the actual name of the thing being
|
|
// viewed. This method will ask the viewed object itself.
|
|
const std::string& getName( void ) const;
|
|
|
|
std::string& getSearchableLabel( void );
|
|
|
|
// This method returns the label displayed on the view. This
|
|
// method was primarily added to allow sorting on the folder
|
|
// contents possible before the entire view has been constructed.
|
|
const std::string& getLabel() const { return mLabel; }
|
|
|
|
// Used for sorting, like getLabel() above.
|
|
virtual time_t getCreationDate() const { return mCreationDate; }
|
|
|
|
LLFolderViewFolder* getParentFolder( void ) { return mParentFolder; }
|
|
const LLFolderViewFolder* getParentFolder( void ) const { return mParentFolder; }
|
|
|
|
LLFolderViewItem* getNextOpenNode( BOOL include_children = TRUE );
|
|
LLFolderViewItem* getPreviousOpenNode( BOOL include_children = TRUE );
|
|
|
|
const LLFolderViewEventListener* getListener( void ) const { return mListener; }
|
|
LLFolderViewEventListener* getListener( void ) { return mListener; }
|
|
|
|
// just rename the object.
|
|
void rename(const std::string& new_name);
|
|
|
|
// open
|
|
virtual void openItem( void );
|
|
virtual void preview(void);
|
|
|
|
// Show children (unfortunate that this is called "open")
|
|
virtual void setOpen(BOOL open = TRUE) {};
|
|
|
|
virtual BOOL isOpen() { return FALSE; }
|
|
|
|
LLFolderView* getRoot();
|
|
BOOL isDescendantOf( const LLFolderViewFolder* potential_ancestor );
|
|
S32 getIndentation() { return mIndentation; }
|
|
|
|
virtual BOOL potentiallyVisible(); // do we know for a fact that this item has been filtered out?
|
|
|
|
virtual BOOL getFiltered();
|
|
virtual BOOL getFiltered(S32 filter_generation);
|
|
virtual void setFiltered(BOOL filtered, S32 filter_generation);
|
|
|
|
// change the icon
|
|
void setIcon(LLUIImagePtr icon);
|
|
|
|
// refresh information from the object being viewed.
|
|
void refreshFromListener();
|
|
virtual void refresh();
|
|
|
|
virtual void applyListenerFunctorRecursively(LLFolderViewListenerFunctor& functor);
|
|
|
|
// LLView functionality
|
|
virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleHover( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleDoubleClick( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
|
|
|
|
// virtual void handleDropped();
|
|
virtual void draw();
|
|
virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
|
|
EDragAndDropType cargo_type,
|
|
void* cargo_data,
|
|
EAcceptance* accept,
|
|
std::string& tooltip_msg);
|
|
};
|
|
|
|
|
|
// function used for sorting.
|
|
typedef bool (*sort_order_f)(LLFolderViewItem* a, LLFolderViewItem* b);
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLFolderViewFolder
|
|
//
|
|
// An instance of an LLFolderViewFolder represents a collection of
|
|
// more folders and items. This is used to build the hierarchy of
|
|
// items found in the folder view. :)
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
class LLFolderViewFolder : public LLFolderViewItem
|
|
{
|
|
public:
|
|
typedef enum e_trash
|
|
{
|
|
UNKNOWN, TRASH, NOT_TRASH
|
|
} ETrash;
|
|
|
|
private:
|
|
S32 mNumDescendantsSelected;
|
|
|
|
public: // Accessed needed by LLFolderViewItem
|
|
void recursiveIncrementNumDescendantsSelected(S32 increment);
|
|
S32 numSelected(void) const { return mNumDescendantsSelected + (isSelected() ? 1 : 0); }
|
|
|
|
protected:
|
|
typedef std::list<LLFolderViewItem*> items_t;
|
|
typedef std::list<LLFolderViewFolder*> folders_t;
|
|
items_t mItems;
|
|
folders_t mFolders;
|
|
LLInventorySort mSortFunction;
|
|
|
|
BOOL mIsOpen;
|
|
BOOL mExpanderHighlighted;
|
|
F32 mCurHeight;
|
|
F32 mTargetHeight;
|
|
F32 mAutoOpenCountdown;
|
|
time_t mSubtreeCreationDate;
|
|
mutable ETrash mAmTrash;
|
|
S32 mLastArrangeGeneration;
|
|
S32 mLastCalculatedWidth;
|
|
S32 mCompletedFilterGeneration;
|
|
S32 mMostFilteredDescendantGeneration;
|
|
public:
|
|
typedef enum e_recurse_type
|
|
{
|
|
RECURSE_NO,
|
|
RECURSE_UP,
|
|
RECURSE_DOWN,
|
|
RECURSE_UP_DOWN
|
|
} ERecurseType;
|
|
|
|
LLFolderViewFolder( const std::string& name, LLUIImagePtr icon,
|
|
LLFolderView* root,
|
|
LLFolderViewEventListener* listener );
|
|
virtual ~LLFolderViewFolder( void );
|
|
|
|
virtual BOOL potentiallyVisible();
|
|
|
|
LLFolderViewItem* getNextFromChild( LLFolderViewItem*, BOOL include_children = TRUE );
|
|
LLFolderViewItem* getPreviousFromChild( LLFolderViewItem*, BOOL include_children = TRUE );
|
|
|
|
// addToFolder() returns TRUE if it succeeds. FALSE otherwise
|
|
virtual BOOL addToFolder(LLFolderViewFolder* folder, LLFolderView* root);
|
|
|
|
// Finds width and height of this object and it's children. Also
|
|
// makes sure that this view and it's children are the right size.
|
|
virtual S32 arrange( S32* width, S32* height, S32 filter_generation );
|
|
|
|
BOOL needsArrange();
|
|
|
|
// Returns the sort group (system, trash, folder) for this folder.
|
|
virtual EInventorySortGroup getSortGroup() const;
|
|
|
|
virtual void setCompletedFilterGeneration(S32 generation, BOOL recurse_up);
|
|
virtual S32 getCompletedFilterGeneration() { return mCompletedFilterGeneration; }
|
|
|
|
BOOL hasFilteredDescendants(S32 filter_generation) { return mMostFilteredDescendantGeneration >= filter_generation; }
|
|
BOOL hasFilteredDescendants();
|
|
|
|
// applies filters to control visibility of inventory items
|
|
virtual void filter( LLInventoryFilter& filter);
|
|
virtual void setFiltered(BOOL filtered, S32 filter_generation);
|
|
virtual void dirtyFilter();
|
|
|
|
// Passes selection information on to children and record
|
|
// selection information if necessary.
|
|
// Returns TRUE if this object (or a child) ends up being selected.
|
|
// If 'openitem' is TRUE then folders are opened up along the way to the selection.
|
|
virtual BOOL setSelection(LLFolderViewItem* selection, BOOL openitem, BOOL take_keyboard_focus);
|
|
|
|
// This method is used to change the selection of an item.
|
|
// Recursively traverse all children; if 'selection' is 'this' then change
|
|
// the select status if necessary.
|
|
// Returns TRUE if the selection state of this folder, or of a child, was changed.
|
|
virtual BOOL changeSelection(LLFolderViewItem* selection, BOOL selected);
|
|
|
|
// this method is used to group select items
|
|
virtual void extendSelection(LLFolderViewItem* selection, LLFolderViewItem* last_selected, LLDynamicArray<LLFolderViewItem*>& items);
|
|
|
|
// Deselect this folder and all folder/items it contains recursively.
|
|
void recursiveDeselect(BOOL deselect_self);
|
|
|
|
// Returns true is this object and all of its children can be removed.
|
|
virtual BOOL isRemovable();
|
|
|
|
// Returns true is this object and all of its children can be moved
|
|
virtual BOOL isMovable();
|
|
|
|
// destroys this folder, and all children
|
|
virtual void destroyView();
|
|
|
|
// If this folder can be removed, remove all children that can be
|
|
// removed, return TRUE if this is empty after the operation and
|
|
// it's viewed folder object can be removed.
|
|
//virtual BOOL removeRecursively(BOOL single_item);
|
|
//virtual BOOL remove();
|
|
|
|
// remove the specified item (and any children) if
|
|
// possible. Return TRUE if the item was deleted.
|
|
BOOL removeItem(LLFolderViewItem* item);
|
|
|
|
// simply remove the view (and any children) Don't bother telling
|
|
// the listeners.
|
|
void removeView(LLFolderViewItem* item);
|
|
|
|
// extractItem() removes the specified item from the folder, but
|
|
// doesn't delete it.
|
|
void extractItem( LLFolderViewItem* item );
|
|
|
|
// This function is called by a child that needs to be resorted.
|
|
void resort(LLFolderViewItem* item);
|
|
|
|
void setItemSortOrder(U32 ordering);
|
|
void sortBy(U32);
|
|
//BOOL (*func)(LLFolderViewItem* a, LLFolderViewItem* b));
|
|
|
|
void setAutoOpenCountdown(F32 countdown) { mAutoOpenCountdown = countdown; }
|
|
|
|
// folders can be opened. This will usually be called by internal
|
|
// methods.
|
|
virtual void toggleOpen();
|
|
|
|
// Force a folder open or closed
|
|
virtual void setOpen(BOOL openitem = TRUE);
|
|
|
|
// Called when a child is refreshed.
|
|
// don't rearrange child folder contents unless explicitly requested
|
|
virtual void requestArrange(BOOL include_descendants = FALSE);
|
|
|
|
// internal method which doesn't update the entire view. This
|
|
// method was written because the list iterators destroy the state
|
|
// of other iterations, thus, we can't arrange while iterating
|
|
// through the children (such as when setting which is selected.
|
|
virtual void setOpenArrangeRecursively(BOOL openitem, ERecurseType recurse = RECURSE_NO);
|
|
|
|
// Get the current state of the folder.
|
|
virtual BOOL isOpen() { return mIsOpen; }
|
|
|
|
// special case if an object is dropped on the child.
|
|
BOOL handleDragAndDropFromChild(MASK mask,
|
|
BOOL drop,
|
|
EDragAndDropType cargo_type,
|
|
void* cargo_data,
|
|
EAcceptance* accept,
|
|
std::string& tooltip_msg);
|
|
|
|
void applyFunctorRecursively(LLFolderViewFunctor& functor);
|
|
virtual void applyListenerFunctorRecursively(LLFolderViewListenerFunctor& functor);
|
|
|
|
virtual void openItem( void );
|
|
virtual BOOL addItem(LLFolderViewItem* item);
|
|
virtual BOOL addFolder( LLFolderViewFolder* folder);
|
|
|
|
// LLView functionality
|
|
virtual BOOL handleHover(S32 x, S32 y, MASK mask);
|
|
virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleDoubleClick( S32 x, S32 y, MASK mask );
|
|
virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
|
|
EDragAndDropType cargo_type,
|
|
void* cargo_data,
|
|
EAcceptance* accept,
|
|
std::string& tooltip_msg);
|
|
virtual void draw();
|
|
|
|
time_t getCreationDate() const;
|
|
bool isTrash() const;
|
|
S32 getNumSelectedDescendants(void) const { return mNumDescendantsSelected; }
|
|
};
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Class LLFolderView
|
|
//
|
|
// Th LLFolderView represents the root level folder view object. It
|
|
// manages the screen region of the folder view.
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
class LLUICtrl;
|
|
class LLLineEditor;
|
|
|
|
class LLFolderView : public LLFolderViewFolder, LLEditMenuHandler
|
|
{
|
|
public:
|
|
typedef void (*SelectCallback)(const std::deque<LLFolderViewItem*> &items, BOOL user_action, void* data);
|
|
|
|
static F32 sAutoOpenTime;
|
|
|
|
LLFolderView( const std::string& name, LLUIImagePtr root_folder_icon, const LLRect& rect,
|
|
const LLUUID& source_id, LLView *parent_view );
|
|
virtual ~LLFolderView( void );
|
|
|
|
virtual BOOL canFocusChildren() const;
|
|
|
|
// FolderViews default to sort by name. This will change that,
|
|
// and resort the items if necessary.
|
|
void setSortOrder(U32 order);
|
|
void checkTreeResortForModelChanged();
|
|
void setFilterPermMask(PermissionMask filter_perm_mask) { mFilter.setFilterPermissions(filter_perm_mask); }
|
|
void setSelectCallback(SelectCallback callback, void* user_data) { mSelectCallback = callback, mUserData = user_data; }
|
|
void setAllowMultiSelect(BOOL allow) { mAllowMultiSelect = allow; }
|
|
|
|
LLInventoryFilter* getFilter() { return &mFilter; }
|
|
const std::string getFilterSubString(BOOL trim = FALSE);
|
|
bool getFilterWorn() const { return mFilter.getFilterWorn(); }
|
|
U32 getFilterTypes() const { return mFilter.getFilterTypes(); }
|
|
PermissionMask getFilterPermissions() const { return mFilter.getFilterPermissions(); }
|
|
LLInventoryFilter::EFolderShow getShowFolderState() { return mFilter.getShowFolderState(); }
|
|
U32 getSortOrder() const;
|
|
BOOL isFilterModified() { return mFilter.isNotDefault(); }
|
|
BOOL getAllowMultiSelect() { return mAllowMultiSelect; }
|
|
|
|
U32 toggleSearchType(std::string toggle);
|
|
U32 getSearchType() const;
|
|
|
|
// Close all folders in the view
|
|
void closeAllFolders();
|
|
void openFolder(const std::string& foldername);
|
|
|
|
virtual void toggleOpen() {};
|
|
virtual void setOpenArrangeRecursively(BOOL openitem, ERecurseType recurse);
|
|
virtual BOOL addFolder( LLFolderViewFolder* folder);
|
|
|
|
// Finds width and height of this object and it's children. Also
|
|
// makes sure that this view and it's children are the right size.
|
|
virtual S32 arrange( S32* width, S32* height, S32 filter_generation );
|
|
|
|
void arrangeAll() { mArrangeGeneration++; }
|
|
S32 getArrangeGeneration() { return mArrangeGeneration; }
|
|
|
|
// applies filters to control visibility of inventory items
|
|
virtual void filter( LLInventoryFilter& filter);
|
|
|
|
// get the last selected item
|
|
virtual LLFolderViewItem* getCurSelectedItem( void );
|
|
|
|
// Record the selected item and pass it down the hierachy.
|
|
virtual BOOL setSelection(LLFolderViewItem* selection, BOOL openitem,
|
|
BOOL take_keyboard_focus);
|
|
|
|
// This method is used to toggle the selection of an item. Walks
|
|
// children, and keeps track of selected objects.
|
|
virtual BOOL changeSelection(LLFolderViewItem* selection, BOOL selected);
|
|
|
|
virtual void extendSelection(LLFolderViewItem* selection, LLFolderViewItem* last_selected, LLDynamicArray<LLFolderViewItem*>& items);
|
|
|
|
virtual BOOL getSelectionList(std::set<LLUUID> &selection);
|
|
|
|
// make sure if ancestor is selected, descendents are not
|
|
void sanitizeSelection();
|
|
void clearSelection();
|
|
void addToSelectionList(LLFolderViewItem* item);
|
|
void removeFromSelectionList(LLFolderViewItem* item);
|
|
|
|
BOOL startDrag(LLToolDragAndDrop::ESource source);
|
|
void setDragAndDropThisFrame() { mDragAndDropThisFrame = TRUE; }
|
|
|
|
// deletion functionality
|
|
void removeSelectedItems();
|
|
|
|
// open the selected item.
|
|
void openSelectedItems( void );
|
|
void propertiesSelectedItems( void );
|
|
|
|
void autoOpenItem(LLFolderViewFolder* item);
|
|
void closeAutoOpenedFolders();
|
|
BOOL autoOpenTest(LLFolderViewFolder* item);
|
|
|
|
// copy & paste
|
|
virtual void copy();
|
|
virtual BOOL canCopy() const;
|
|
|
|
virtual void cut();
|
|
virtual BOOL canCut() const;
|
|
|
|
virtual void paste();
|
|
virtual BOOL canPaste() const;
|
|
|
|
virtual void doDelete();
|
|
virtual BOOL canDoDelete() const;
|
|
|
|
// public rename functionality - can only start the process
|
|
void startRenamingSelectedItem( void );
|
|
|
|
// These functions were used when there was only one folderview,
|
|
// and relied on that concept. This functionality is now handled
|
|
// by the listeners and the lldraganddroptool.
|
|
//LLFolderViewItem* getMovingItem() { return mMovingItem; }
|
|
//void setMovingItem( LLFolderViewItem* item ) { mMovingItem = item; }
|
|
//void dragItemIntoFolder( LLFolderViewItem* moving_item, LLFolderViewFolder* dst_folder, BOOL drop, BOOL* accept );
|
|
//void dragFolderIntoFolder( LLFolderViewFolder* moving_folder, LLFolderViewFolder* dst_folder, BOOL drop, BOOL* accept );
|
|
|
|
// LLUICtrl Functionality
|
|
/*virtual*/ void setFocus(BOOL focus);
|
|
|
|
// LLView functionality
|
|
///*virtual*/ BOOL handleKey( KEY key, MASK mask, BOOL called_from_parent );
|
|
/*virtual*/ BOOL handleKeyHere( KEY key, MASK mask );
|
|
/*virtual*/ BOOL handleUnicodeCharHere(llwchar uni_char);
|
|
/*virtual*/ BOOL handleMouseDown( S32 x, S32 y, MASK mask );
|
|
/*virtual*/ BOOL handleDoubleClick( S32 x, S32 y, MASK mask );
|
|
/*virtual*/ BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
|
|
/*virtual*/ BOOL handleHover( S32 x, S32 y, MASK mask );
|
|
/*virtual*/ BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
|
|
EDragAndDropType cargo_type,
|
|
void* cargo_data,
|
|
EAcceptance* accept,
|
|
std::string& tooltip_msg);
|
|
/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
|
|
/*virtual*/ void onFocusLost();
|
|
virtual BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
|
|
virtual void draw();
|
|
virtual void deleteAllChildren();
|
|
|
|
void scrollToShowSelection();
|
|
void scrollToShowItem(LLFolderViewItem* item);
|
|
void setScrollContainer( LLScrollableContainerView* parent ) { mScrollContainer = parent; }
|
|
LLRect getVisibleRect();
|
|
|
|
BOOL search(LLFolderViewItem* first_item, const std::string &search_string, BOOL backward);
|
|
void setShowSelectionContext(BOOL show) { mShowSelectionContext = show; }
|
|
BOOL getShowSelectionContext();
|
|
void setShowSingleSelection(BOOL show);
|
|
BOOL getShowSingleSelection() { return mShowSingleSelection; }
|
|
F32 getSelectionFadeElapsedTime() { return mMultiSelectionFadeTimer.getElapsedTimeF32(); }
|
|
|
|
void addItemID(const LLUUID& id, LLFolderViewItem* itemp);
|
|
void removeItemID(const LLUUID& id);
|
|
LLFolderViewItem* getItemByID(const LLUUID& id);
|
|
|
|
void doIdle(); // Real idle routine
|
|
static void idle(void* user_data); // static glue to doIdle()
|
|
|
|
BOOL needsAutoSelect() { return mNeedsAutoSelect && !mAutoSelectOverride; }
|
|
BOOL needsAutoRename() { return mNeedsAutoRename; }
|
|
void setNeedsAutoRename(BOOL val) { mNeedsAutoRename = val; }
|
|
|
|
BOOL getDebugFilters() { return mDebugFilters; }
|
|
|
|
// DEBUG only
|
|
void dumpSelectionInformation();
|
|
|
|
protected:
|
|
LLScrollableContainerView* mScrollContainer; // NULL if this is not a child of a scroll container.
|
|
|
|
static void commitRename( LLUICtrl* renamer, void* user_data );
|
|
static void onRenamerLost( LLUICtrl* renamer, void* user_data);
|
|
|
|
void finishRenamingItem( void );
|
|
void closeRenamer( void );
|
|
|
|
protected:
|
|
LLHandle<LLView> mPopupMenuHandle;
|
|
|
|
typedef std::deque<LLFolderViewItem*> selected_items_t;
|
|
selected_items_t mSelectedItems;
|
|
BOOL mKeyboardSelection;
|
|
BOOL mAllowMultiSelect;
|
|
BOOL mShowFolderHierarchy;
|
|
LLUUID mSourceID;
|
|
|
|
// Renaming variables and methods
|
|
LLFolderViewItem* mRenameItem; // The item currently being renamed
|
|
LLLineEditor* mRenamer;
|
|
|
|
BOOL mNeedsScroll;
|
|
LLFolderViewItem* mLastScrollItem;
|
|
LLCoordGL mLastScrollOffset;
|
|
BOOL mNeedsAutoSelect;
|
|
BOOL mAutoSelectOverride;
|
|
BOOL mNeedsAutoRename;
|
|
|
|
BOOL mDebugFilters;
|
|
U32 mSortOrder;
|
|
U32 mSearchType;
|
|
LLDepthStack<LLFolderViewFolder> mAutoOpenItems;
|
|
LLFolderViewFolder* mAutoOpenCandidate;
|
|
LLFrameTimer mAutoOpenTimer;
|
|
LLFrameTimer mSearchTimer;
|
|
std::string mSearchString;
|
|
LLInventoryFilter mFilter;
|
|
BOOL mShowSelectionContext;
|
|
BOOL mShowSingleSelection;
|
|
LLFrameTimer mMultiSelectionFadeTimer;
|
|
S32 mArrangeGeneration;
|
|
|
|
void* mUserData;
|
|
SelectCallback mSelectCallback;
|
|
S32 mSignalSelectCallback;
|
|
S32 mMinWidth;
|
|
std::map<LLUUID, LLFolderViewItem*> mItemMap;
|
|
BOOL mDragAndDropThisFrame;
|
|
|
|
};
|
|
|
|
bool sort_item_name(LLFolderViewItem* a, LLFolderViewItem* b);
|
|
bool sort_item_date(LLFolderViewItem* a, LLFolderViewItem* b);
|
|
|
|
// Flags for buildContextMenu()
|
|
const U32 SUPPRESS_OPEN_ITEM = 0x1;
|
|
const U32 FIRST_SELECTED_ITEM = 0x2;
|
|
|
|
#endif // LL_LLFOLDERVIEW_H
|