phoenix-firestorm/indra/newview/llinventoryitemslist.cpp

/**
 * @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"

bool LLInventoryItemsList::sListIdleRegistered = false;
LLInventoryItemsList::all_list_t LLInventoryItemsList::sAllLists;
LLInventoryItemsList::all_list_t::iterator LLInventoryItemsList::sAllListIter;

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"));

    sAllLists.push_back(this);
    sAllListIter = sAllLists.begin();

    if (!sListIdleRegistered)
    {
        sAllListIter = sAllLists.begin();
        gIdleCallbacks.addFunction(idle, nullptr);

        LLEventPumps::instance().obtain("LLApp").listen(
            "LLInventoryItemsList",
            [](const LLSD& stat)
        {
            std::string status(stat["status"]);
            if (status != "running")
            {
                // viewer is starting shutdown
                gIdleCallbacks.deleteFunction(idle, nullptr);
            }
            return false;
        });
        sListIdleRegistered = true;
    }
}

// virtual
LLInventoryItemsList::~LLInventoryItemsList()
{
    auto it = std::find(sAllLists.begin(), sAllLists.end(), this);
    if (it != sAllLists.end())
    {
        sAllLists.erase(it);
        sAllListIter = sAllLists.begin();
    }
}

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->asUUID());
        if(select_ids_it != mSelectTheseIDs.end())
        {
            selectItemByUUID(*select_ids_it);
            mSelectTheseIDs.erase(select_ids_it);
        }
    }

    scrollToShowFirstSelectedItem();
    mSelectTheseIDs.clear();
}

bool LLInventoryItemsList::doIdle()
{
    if (mRefreshState == REFRESH_COMPLETE) return true; // done

    if (isInVisibleChain() || mForceRefresh || !getFilterSubString().empty())
    {
        refresh();

        mRefreshCompleteSignal(this, LLSD());
        return false; // keep going
    }
    return true; // done
}

//static
void LLInventoryItemsList::idle(void* user_data)
{
    if (sAllLists.empty())
        return;

    LL_PROFILE_ZONE_SCOPED;

    using namespace std::chrono;
    auto start = steady_clock::now();
    const milliseconds time_limit = milliseconds(3);
    const auto end_time = start + time_limit;
    S32 max_update_count = 50;

    if (sAllListIter == sAllLists.end())
    {
        sAllListIter = sAllLists.begin();
    }

    S32 updated = 0;
    while (steady_clock::now() < end_time
           && updated < max_update_count
           && sAllListIter != sAllLists.end())
    {
        LLInventoryItemsList* list = *sAllListIter;
        // Refresh is split into multiple separate parts,
        // so keep repeating it while there is time, until done.
        // Todo: refresh() split is pointless now?
        // Or still useful for large folders?
        if (list->doIdle())
        {
            // Item is done
            ++sAllListIter;
            updated++;
        }
    }
}

void LLInventoryItemsList::refresh()
{
    LL_PROFILE_ZONE_SCOPED;

    switch (mRefreshState)
    {
    case REFRESH_ALL:
        {
            LL_PROFILE_ZONE_NAMED("items_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:
        {
            LL_PROFILE_ZONE_NAMED("items_refresh_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:
        {
            LL_PROFILE_ZONE_NAMED("items_refresh_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:
        {
            LL_PROFILE_ZONE_NAMED("items_refresh_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:
        {
            mRefreshState = REFRESH_COMPLETE;
            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