293 lines
8.6 KiB
C++
293 lines
8.6 KiB
C++
/**
|
|
* @file llinventoryitemslist.cpp
|
|
* @brief A list of inventory items represented by LLFlatListView.
|
|
*
|
|
* Class LLInventoryItemsList implements a flat list of inventory items.
|
|
*
|
|
* $LicenseInfo:firstyear=2010&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$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "llinventoryitemslist.h"
|
|
|
|
// llcommon
|
|
#include "llcommonutils.h"
|
|
|
|
#include "lltrans.h"
|
|
|
|
#include "llcallbacklist.h"
|
|
#include "llinventorylistitem.h"
|
|
#include "llinventorymodel.h"
|
|
#include "llviewerinventory.h"
|
|
|
|
LLInventoryItemsList::Params::Params()
|
|
{}
|
|
|
|
LLInventoryItemsList::LLInventoryItemsList(const LLInventoryItemsList::Params& p)
|
|
: LLFlatListViewEx(p)
|
|
, mRefreshState(REFRESH_COMPLETE)
|
|
, mForceRefresh(false)
|
|
{
|
|
// TODO: mCommitOnSelectionChange is set to "false" in LLFlatListView
|
|
// but reset to true in all derived classes. This settings might need to
|
|
// be added to LLFlatListView::Params() and/or set to "true" by default.
|
|
setCommitOnSelectionChange(true);
|
|
|
|
setNoFilteredItemsMsg(LLTrans::getString("InventoryNoMatchingItems"));
|
|
|
|
gIdleCallbacks.addFunction(idle, this);
|
|
}
|
|
|
|
// virtual
|
|
LLInventoryItemsList::~LLInventoryItemsList()
|
|
{
|
|
gIdleCallbacks.deleteFunction(idle, this);
|
|
}
|
|
|
|
void LLInventoryItemsList::refreshList(const LLInventoryModel::item_array_t item_array)
|
|
{
|
|
getIDs().clear();
|
|
LLInventoryModel::item_array_t::const_iterator it = item_array.begin();
|
|
for( ; item_array.end() != it; ++it)
|
|
{
|
|
getIDs().push_back((*it)->getUUID());
|
|
}
|
|
mRefreshState = REFRESH_ALL;
|
|
}
|
|
|
|
boost::signals2::connection LLInventoryItemsList::setRefreshCompleteCallback(const commit_signal_t::slot_type& cb)
|
|
{
|
|
return mRefreshCompleteSignal.connect(cb);
|
|
}
|
|
|
|
bool LLInventoryItemsList::selectItemByValue(const LLSD& value, bool select)
|
|
{
|
|
if (!LLFlatListView::selectItemByValue(value, select) && !value.isUndefined())
|
|
{
|
|
mSelectTheseIDs.push_back(value);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void LLInventoryItemsList::updateSelection()
|
|
{
|
|
if(mSelectTheseIDs.empty()) return;
|
|
|
|
std::vector<LLSD> cur;
|
|
getValues(cur);
|
|
|
|
for(std::vector<LLSD>::const_iterator cur_id_it = cur.begin(); cur_id_it != cur.end() && !mSelectTheseIDs.empty(); ++cur_id_it)
|
|
{
|
|
uuid_vec_t::iterator select_ids_it = std::find(mSelectTheseIDs.begin(), mSelectTheseIDs.end(), *cur_id_it);
|
|
if(select_ids_it != mSelectTheseIDs.end())
|
|
{
|
|
selectItemByUUID(*select_ids_it);
|
|
mSelectTheseIDs.erase(select_ids_it);
|
|
}
|
|
}
|
|
|
|
scrollToShowFirstSelectedItem();
|
|
mSelectTheseIDs.clear();
|
|
}
|
|
|
|
void LLInventoryItemsList::doIdle()
|
|
{
|
|
if (mRefreshState == REFRESH_COMPLETE) return;
|
|
|
|
if (isInVisibleChain() || mForceRefresh )
|
|
{
|
|
refresh();
|
|
|
|
mRefreshCompleteSignal(this, LLSD());
|
|
}
|
|
}
|
|
|
|
//static
|
|
void LLInventoryItemsList::idle(void* user_data)
|
|
{
|
|
LLInventoryItemsList* self = static_cast<LLInventoryItemsList*>(user_data);
|
|
if ( self )
|
|
{ // Do the real idle
|
|
self->doIdle();
|
|
}
|
|
}
|
|
|
|
void LLInventoryItemsList::refresh()
|
|
{
|
|
LL_PROFILE_ZONE_SCOPED;
|
|
|
|
switch (mRefreshState)
|
|
{
|
|
case REFRESH_ALL:
|
|
{
|
|
mAddedItems.clear();
|
|
mRemovedItems.clear();
|
|
computeDifference(getIDs(), mAddedItems, mRemovedItems);
|
|
if (mRemovedItems.size() > 0)
|
|
{
|
|
mRefreshState = REFRESH_LIST_ERASE;
|
|
}
|
|
else if (mAddedItems.size() > 0)
|
|
{
|
|
mRefreshState = REFRESH_LIST_APPEND;
|
|
}
|
|
else
|
|
{
|
|
mRefreshState = REFRESH_LIST_SORT;
|
|
}
|
|
|
|
rearrangeItems();
|
|
notifyParentItemsRectChanged();
|
|
break;
|
|
}
|
|
case REFRESH_LIST_ERASE:
|
|
{
|
|
uuid_vec_t::const_iterator it = mRemovedItems.begin();
|
|
for (; mRemovedItems.end() != it; ++it)
|
|
{
|
|
// don't filter items right away
|
|
removeItemByUUID(*it, false);
|
|
}
|
|
mRemovedItems.clear();
|
|
mRefreshState = REFRESH_LIST_SORT; // fix visibility and arrange
|
|
break;
|
|
}
|
|
case REFRESH_LIST_APPEND:
|
|
{
|
|
static const unsigned ADD_LIMIT = 25; // Note: affects perfomance
|
|
|
|
unsigned int nadded = 0;
|
|
|
|
// form a list to add
|
|
uuid_vec_t::iterator it = mAddedItems.begin();
|
|
pairs_list_t panel_list;
|
|
while(mAddedItems.size() > 0 && nadded < ADD_LIMIT)
|
|
{
|
|
LLViewerInventoryItem* item = gInventory.getItem(*it);
|
|
llassert(item);
|
|
if (item)
|
|
{
|
|
LLPanel *list_item = createNewItem(item);
|
|
if (list_item)
|
|
{
|
|
item_pair_t* new_pair = new item_pair_t(list_item, item->getUUID());
|
|
panel_list.push_back(new_pair);
|
|
++nadded;
|
|
}
|
|
}
|
|
|
|
it = mAddedItems.erase(it);
|
|
}
|
|
|
|
// add the list
|
|
// Note: usually item pairs are sorted with std::sort, but we are calling
|
|
// this function on idle and pairs' list can take a lot of time to sort
|
|
// through, so we are sorting items into list while adding them
|
|
addItemPairs(panel_list, false);
|
|
|
|
// update visibility of items in the list
|
|
std::string cur_filter = getFilterSubString();
|
|
LLStringUtil::toUpper(cur_filter);
|
|
LLSD action;
|
|
action.with("match_filter", cur_filter);
|
|
|
|
pairs_const_iterator_t pair_it = panel_list.begin();
|
|
for (; pair_it != panel_list.end(); ++pair_it)
|
|
{
|
|
item_pair_t* item_pair = *pair_it;
|
|
if (item_pair->first->getParent() != NULL)
|
|
{
|
|
updateItemVisibility(item_pair->first, action);
|
|
}
|
|
}
|
|
|
|
rearrangeItems();
|
|
notifyParentItemsRectChanged();
|
|
|
|
if (mAddedItems.size() > 0)
|
|
{
|
|
mRefreshState = REFRESH_LIST_APPEND;
|
|
}
|
|
else
|
|
{
|
|
// Note: while we do sort and check visibility at REFRESH_LIST_APPEND, update
|
|
// could have changed something about existing items so redo checks for all items.
|
|
mRefreshState = REFRESH_LIST_SORT;
|
|
}
|
|
break;
|
|
}
|
|
case REFRESH_LIST_SORT:
|
|
{
|
|
// Filter, sort, rearrange and notify parent about shape changes
|
|
filterItems(true, true);
|
|
|
|
if (mAddedItems.size() == 0)
|
|
{
|
|
// After list building completed, select items that had been requested to select before list was build
|
|
updateSelection();
|
|
mRefreshState = REFRESH_COMPLETE;
|
|
}
|
|
else
|
|
{
|
|
mRefreshState = REFRESH_LIST_APPEND;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
setForceRefresh(mRefreshState != REFRESH_COMPLETE);
|
|
}
|
|
|
|
void LLInventoryItemsList::computeDifference(
|
|
const uuid_vec_t& vnew,
|
|
uuid_vec_t& vadded,
|
|
uuid_vec_t& vremoved)
|
|
{
|
|
uuid_vec_t vcur;
|
|
{
|
|
std::vector<LLSD> vcur_values;
|
|
getValues(vcur_values);
|
|
|
|
for (size_t i=0; i<vcur_values.size(); i++)
|
|
vcur.push_back(vcur_values[i].asUUID());
|
|
}
|
|
|
|
LLCommonUtils::computeDifference(vnew, vcur, vadded, vremoved);
|
|
}
|
|
|
|
LLPanel* LLInventoryItemsList::createNewItem(LLViewerInventoryItem* item)
|
|
{
|
|
if (!item)
|
|
{
|
|
LL_WARNS() << "No inventory item. Couldn't create flat list item." << LL_ENDL;
|
|
llassert(item != NULL);
|
|
return NULL;
|
|
}
|
|
return LLPanelInventoryListItemBase::create(item);
|
|
}
|
|
|
|
// EOF
|