/**
 * @file llpanellandmarks.cpp
 * @brief Landmarks tab for Side Bar "Places" panel
 *
 * $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$
 */

#include "llviewerprecompiledheaders.h"

#include "llpanellandmarks.h"

#include "llbutton.h"
#include "llfloaterprofile.h"
#include "llfloaterreg.h"
#include "llnotificationsutil.h"
#include "llsdutil.h"
#include "llsdutil_math.h"
#include "llregionhandle.h"

#include "llaccordionctrl.h"
#include "llagent.h"
#include "llagentpicksinfo.h"
#include "llagentui.h"
#include "llavataractions.h"
#include "llcallbacklist.h"
#include "llfloatersidepanelcontainer.h"
#include "llfloaterworldmap.h"
#include "llfolderviewitem.h"
#include "llinventorymodelbackgroundfetch.h"
#include "llinventorypanel.h"
#include "llinventoryfunctions.h"
#include "lllandmarkactions.h"
#include "llmenubutton.h"
#include "llplacesinventorybridge.h"
#include "llplacesinventorypanel.h"
#include "llplacesfolderview.h"
#include "lltoggleablemenu.h"
#include "llviewermenu.h"
#include "llviewerregion.h"

// Not yet implemented; need to remove buildPanel() from constructor when we switch
//static LLRegisterPanelClassWrapper<LLLandmarksPanel> t_landmarks("panel_landmarks");

// helper functions
static void filter_list(LLPlacesInventoryPanel* inventory_list, const std::string& string);
static void collapse_all_folders(LLFolderView* root_folder);
static void expand_all_folders(LLFolderView* root_folder);
static bool has_expanded_folders(LLFolderView* root_folder);
static bool has_collapsed_folders(LLFolderView* root_folder);
static void toggle_restore_menu(LLMenuGL* menu, bool visible, bool enabled);

/**
 * Functor counting expanded and collapsed folders in folder view tree to know
 * when to enable or disable "Expand all folders" and "Collapse all folders" commands.
 */
class LLCheckFolderState : public LLFolderViewFunctor
{
public:
    LLCheckFolderState()
    :   mCollapsedFolders(0),
        mExpandedFolders(0)
    {}
    virtual ~LLCheckFolderState() {}
    virtual void doFolder(LLFolderViewFolder* folder);
    virtual void doItem(LLFolderViewItem* item) {}
    S32 getCollapsedFolders() { return mCollapsedFolders; }
    S32 getExpandedFolders() { return mExpandedFolders; }

private:
    S32 mCollapsedFolders;
    S32 mExpandedFolders;
};

// virtual
void LLCheckFolderState::doFolder(LLFolderViewFolder* folder)
{
    // Counting only folders that pass the filter.
    // The listener check allow us to avoid counting the folder view
    // object itself because it has no listener assigned.
    if (folder->getViewModelItem()->descendantsPassedFilter())
    {
        if (folder->isOpen())
        {
            ++mExpandedFolders;
        }
        else
        {
            ++mCollapsedFolders;
        }
    }
}

// Functor searching and opening a folder specified by UUID
// in a folder view tree.
class LLOpenFolderByID : public LLFolderViewFunctor
{
public:
    LLOpenFolderByID(const LLUUID& folder_id)
    :   mFolderID(folder_id)
    ,   mIsFolderOpen(false)
    {}
    virtual ~LLOpenFolderByID() {}
    /*virtual*/ void doFolder(LLFolderViewFolder* folder);
    /*virtual*/ void doItem(LLFolderViewItem* item) {}

    bool isFolderOpen() { return mIsFolderOpen; }

private:
    bool    mIsFolderOpen;
    LLUUID  mFolderID;
};

// virtual
void LLOpenFolderByID::doFolder(LLFolderViewFolder* folder)
{
    if (folder->getViewModelItem() && static_cast<LLFolderViewModelItemInventory*>(folder->getViewModelItem())->getUUID() == mFolderID)
    {
        if (!folder->isOpen())
        {
            folder->setOpen(true);
            mIsFolderOpen = true;
        }
    }
}

LLLandmarksPanel::LLLandmarksPanel()
    :   LLPanelPlacesTab()
    ,   mLandmarksInventoryPanel(NULL)
    ,   mCurrentSelectedList(NULL)
    ,   mGearFolderMenu(NULL)
    ,   mGearLandmarkMenu(NULL)
    ,   mSortingMenu(NULL)
    ,   mAddMenu(NULL)
    ,   isLandmarksPanel(true)
{
    buildFromFile("panel_landmarks.xml");
}

LLLandmarksPanel::LLLandmarksPanel(bool is_landmark_panel)
    :   LLPanelPlacesTab()
    ,   mLandmarksInventoryPanel(NULL)
    ,   mCurrentSelectedList(NULL)
    ,   mGearFolderMenu(NULL)
    ,   mGearLandmarkMenu(NULL)
    ,   mSortingMenu(NULL)
    ,   mAddMenu(NULL)
    ,   isLandmarksPanel(is_landmark_panel)
{
    if (is_landmark_panel)
    {
        buildFromFile("panel_landmarks.xml");
    }
}

LLLandmarksPanel::~LLLandmarksPanel()
{
}

bool LLLandmarksPanel::postBuild()
{
    if (!gInventory.isInventoryUsable())
        return false;

    // mast be called before any other initXXX methods to init Gear menu
    initListCommandsHandlers();
    initLandmarksInventoryPanel();

    return true;
}

// virtual
void LLLandmarksPanel::onSearchEdit(const std::string& string)
{
    filter_list(mCurrentSelectedList, string);

    if (sFilterSubString != string)
        sFilterSubString = string;
}

// virtual
void LLLandmarksPanel::onShowOnMap()
{
    if (NULL == mCurrentSelectedList)
    {
        LL_WARNS() << "There are no selected list. No actions are performed." << LL_ENDL;
        return;
    }

    doActionOnCurSelectedLandmark(boost::bind(&LLLandmarksPanel::doShowOnMap, this, _1));
}

//virtual
void LLLandmarksPanel::onShowProfile()
{
    LLFolderViewModelItemInventory* cur_item = getCurSelectedViewModelItem();

    if(!cur_item)
        return;

    cur_item->performAction(mCurrentSelectedList->getModel(),"about");
}

// virtual
void LLLandmarksPanel::onTeleport()
{
    LLFolderViewModelItemInventory* view_model_item = getCurSelectedViewModelItem();
    if (view_model_item && view_model_item->getInventoryType() == LLInventoryType::IT_LANDMARK)
    {
        view_model_item->openItem();
    }
}

/*virtual*/
void LLLandmarksPanel::onRemoveSelected()
{
    onClipboardAction("delete");
}

// virtual
bool LLLandmarksPanel::isSingleItemSelected()
{
    bool result = false;

    if (mCurrentSelectedList != NULL)
    {
        LLFolderView* root_view = mCurrentSelectedList->getRootFolder();

        if (root_view->getSelectedCount() == 1)
        {
            result = isLandmarkSelected();
        }
    }

    return result;
}

// virtual
LLToggleableMenu* LLLandmarksPanel::getSelectionMenu()
{
    LLToggleableMenu* menu = mGearFolderMenu;

    if (mCurrentSelectedList)
    {
        LLFolderViewModelItemInventory* listenerp = getCurSelectedViewModelItem();
        if (!listenerp)
            return menu;

        if (listenerp->getInventoryType() == LLInventoryType::IT_LANDMARK)
        {
            menu = mGearLandmarkMenu;
        }
    }
    return menu;
}

// virtual
LLToggleableMenu* LLLandmarksPanel::getSortingMenu()
{
    return mSortingMenu;
}

// virtual
LLToggleableMenu* LLLandmarksPanel::getCreateMenu()
{
    return mAddMenu;
}

void LLLandmarksPanel::updateVerbs()
{
    if (sRemoveBtn)
    {
        sRemoveBtn->setEnabled(isActionEnabled("delete") && (isFolderSelected() || isLandmarkSelected()));
    }
}

void LLLandmarksPanel::setItemSelected(const LLUUID& obj_id, bool take_keyboard_focus)
{
    if (!mCurrentSelectedList)
        return;

    LLFolderView* root = mCurrentSelectedList->getRootFolder();
    LLFolderViewItem* item = mCurrentSelectedList->getItemByID(obj_id);
    if (!item)
        return;
    root->setSelection(item, false, take_keyboard_focus);
    root->scrollToShowSelection();
}

//////////////////////////////////////////////////////////////////////////
// PROTECTED METHODS
//////////////////////////////////////////////////////////////////////////

bool LLLandmarksPanel::isLandmarkSelected() const
{
    LLFolderViewModelItemInventory* current_item = getCurSelectedViewModelItem();
    return current_item && (current_item->getInventoryType() == LLInventoryType::IT_LANDMARK);
}

bool LLLandmarksPanel::isFolderSelected() const
{
    LLFolderViewModelItemInventory* current_item = getCurSelectedViewModelItem();
    return current_item && (current_item->getInventoryType() == LLInventoryType::IT_CATEGORY);
}

void LLLandmarksPanel::doActionOnCurSelectedLandmark(LLLandmarkList::loaded_callback_t cb)
{
    LLFolderViewModelItemInventory* cur_item = getCurSelectedViewModelItem();
    if(cur_item && cur_item->getInventoryType() == LLInventoryType::IT_LANDMARK)
    {
        LLLandmark* landmark = LLLandmarkActions::getLandmark(cur_item->getUUID(), cb);
        if (landmark)
        {
            cb(landmark);
        }
    }
}

LLFolderViewItem* LLLandmarksPanel::getCurSelectedItem() const
{
    return mCurrentSelectedList ?  mCurrentSelectedList->getRootFolder()->getCurSelectedItem() : NULL;
}

LLFolderViewModelItemInventory* LLLandmarksPanel::getCurSelectedViewModelItem() const
{
    LLFolderViewItem* cur_item = getCurSelectedItem();
    if (cur_item)
    {
        return  static_cast<LLFolderViewModelItemInventory*>(cur_item->getViewModelItem());
    }
    return NULL;
}


void LLLandmarksPanel::updateSortOrder(LLInventoryPanel* panel, bool byDate)
{
    if(!panel) return;

    U32 order = panel->getSortOrder();
    if (byDate)
    {
        panel->setSortOrder( order | LLInventoryFilter::SO_DATE );
    }
    else
    {
        panel->setSortOrder( order & ~LLInventoryFilter::SO_DATE );
    }
}

void LLLandmarksPanel::resetSelection()
{
}

// virtual
void LLLandmarksPanel::processParcelInfo(const LLParcelData& parcel_data)
{
    //this function will be called after user will try to create a pick for selected landmark.
    // We have to make request to sever to get parcel_id and snaption_id.
    if(mCreatePickItemId.notNull())
    {
        LLInventoryItem* inv_item = gInventory.getItem(mCreatePickItemId);

        if (inv_item && inv_item->getInventoryType() == LLInventoryType::IT_LANDMARK)
        {
            // we are processing response for doCreatePick, landmark should be already loaded
            LLLandmark* landmark = LLLandmarkActions::getLandmark(inv_item->getUUID());
            if (landmark)
            {
                doProcessParcelInfo(landmark, inv_item, parcel_data);
            }
        }
        mCreatePickItemId.setNull();
    }
}

// virtual
void LLLandmarksPanel::setParcelID(const LLUUID& parcel_id)
{
    if (!parcel_id.isNull())
    {
        LLRemoteParcelInfoProcessor::getInstance()->addObserver(parcel_id, this);
        LLRemoteParcelInfoProcessor::getInstance()->sendParcelInfoRequest(parcel_id);
    }
}

// virtual
void LLLandmarksPanel::setErrorStatus(S32 status, const std::string& reason)
{
    LL_WARNS() << "Can't handle remote parcel request."<< " Http Status: "<< status << ". Reason : "<< reason<<LL_ENDL;
}


//////////////////////////////////////////////////////////////////////////
// PRIVATE METHODS
//////////////////////////////////////////////////////////////////////////

void LLLandmarksPanel::initLandmarksInventoryPanel()
{
    mLandmarksInventoryPanel = getChild<LLPlacesInventoryPanel>("landmarks_list");

    initLandmarksPanel(mLandmarksInventoryPanel);

    mLandmarksInventoryPanel->setShowFolderState(LLInventoryFilter::SHOW_ALL_FOLDERS);

    // subscribe to have auto-rename functionality while creating New Folder
    mLandmarksInventoryPanel->setSelectCallback(boost::bind(&LLInventoryPanel::onSelectionChange, mLandmarksInventoryPanel, _1, _2));

    mCurrentSelectedList = mLandmarksInventoryPanel;
}

void LLLandmarksPanel::initLandmarksPanel(LLPlacesInventoryPanel* inventory_list)
{
    inventory_list->getFilter().setEmptyLookupMessage("PlacesNoMatchingItems");
    inventory_list->setFilterTypes(0x1 << LLInventoryType::IT_LANDMARK);
    inventory_list->setSelectCallback(boost::bind(&LLLandmarksPanel::updateVerbs, this));

    inventory_list->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
    bool sorting_order = gSavedSettings.getBOOL("LandmarksSortedByDate");
    updateSortOrder(inventory_list, sorting_order);

    LLPlacesFolderView* root_folder = dynamic_cast<LLPlacesFolderView*>(inventory_list->getRootFolder());
    if (root_folder)
    {
        if (mGearFolderMenu)
        {
            root_folder->setupMenuHandle(LLInventoryType::IT_CATEGORY, mGearFolderMenu->getHandle());
        }
        if (mGearLandmarkMenu)
        {
            root_folder->setupMenuHandle(LLInventoryType::IT_LANDMARK, mGearLandmarkMenu->getHandle());
        }

        root_folder->setParentLandmarksPanel(this);
    }

    inventory_list->saveFolderState();
}


// List Commands Handlers
void LLLandmarksPanel::initListCommandsHandlers()
{
    mCommitCallbackRegistrar.add("Places.LandmarksGear.Add.Action", boost::bind(&LLLandmarksPanel::onAddAction, this, _2));
    mCommitCallbackRegistrar.add("Places.LandmarksGear.CopyPaste.Action", boost::bind(&LLLandmarksPanel::onClipboardAction, this, _2));
    mCommitCallbackRegistrar.add("Places.LandmarksGear.Custom.Action", boost::bind(&LLLandmarksPanel::onCustomAction, this, _2));
    mCommitCallbackRegistrar.add("Places.LandmarksGear.Folding.Action", boost::bind(&LLLandmarksPanel::onFoldingAction, this, _2));
    mEnableCallbackRegistrar.add("Places.LandmarksGear.Check", boost::bind(&LLLandmarksPanel::isActionChecked, this, _2));
    mEnableCallbackRegistrar.add("Places.LandmarksGear.Enable", boost::bind(&LLLandmarksPanel::isActionEnabled, this, _2));
    mGearLandmarkMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_places_gear_landmark.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
    mGearFolderMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_places_gear_folder.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
    mSortingMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_places_gear_sorting.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
    mAddMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_place_add_button.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());

    if (mGearLandmarkMenu)
    {
        mGearLandmarkMenu->setVisibilityChangeCallback(boost::bind(&LLLandmarksPanel::onMenuVisibilityChange, this, _1, _2));
        // show menus even if all items are disabled
        mGearLandmarkMenu->setAlwaysShowMenu(true);
    } // Else corrupted files?

    if (mGearFolderMenu)
    {
        mGearFolderMenu->setVisibilityChangeCallback(boost::bind(&LLLandmarksPanel::onMenuVisibilityChange, this, _1, _2));
        mGearFolderMenu->setAlwaysShowMenu(true);
    }

    if (mAddMenu)
    {
        mAddMenu->setAlwaysShowMenu(true);
    }
}

void LLLandmarksPanel::updateMenuVisibility(LLUICtrl* menu)
{
    onMenuVisibilityChange(menu, LLSD().with("visibility", true));
}

void LLLandmarksPanel::onTrashButtonClick() const
{
    onClipboardAction("delete");
}

void LLLandmarksPanel::onAddAction(const LLSD& userdata) const
{
    LLFolderViewModelItemInventory* view_model = getCurSelectedViewModelItem();
    LLFolderViewItem* item = getCurSelectedItem();

    std::string command_name = userdata.asString();
    if("add_landmark" == command_name
        || "add_landmark_root" == command_name)
    {
        LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
        if(landmark)
        {
            LLNotificationsUtil::add("LandmarkAlreadyExists");
        }
        else
        {
            LLSD args;
            args["type"] = "create_landmark";
            if ("add_landmark" == command_name
                && view_model->getInventoryType() == LLInventoryType::IT_CATEGORY)
            {
                args["dest_folder"] = view_model->getUUID();
            }
            if ("add_landmark_root" == command_name
                && mCurrentSelectedList == mLandmarksInventoryPanel)
            {
                args["dest_folder"] = mLandmarksInventoryPanel->getRootFolderID();
            }
            // else will end up in favorites
            LLFloaterReg::showInstance("add_landmark", args);
        }
    }
    else if ("category" == command_name)
    {
        if (item && mCurrentSelectedList == mLandmarksInventoryPanel)
        {
            LLFolderViewModelItem* folder_bridge = NULL;

            if (view_model->getInventoryType()
                    == LLInventoryType::IT_LANDMARK)
            {
                // for a landmark get parent folder bridge
                folder_bridge = item->getParentFolder()->getViewModelItem();
            }
            else if (view_model->getInventoryType()
                    == LLInventoryType::IT_CATEGORY)
            {
                // for a folder get its own bridge
                folder_bridge = view_model;
            }

            menu_create_inventory_item(mCurrentSelectedList,
                    dynamic_cast<LLFolderBridge*> (folder_bridge), LLSD(
                            "category"), gInventory.findCategoryUUIDForType(
                            LLFolderType::FT_LANDMARK));
        }
        else
        {
            //in case My Landmarks tab is completely empty (thus cannot be determined as being selected)
            menu_create_inventory_item(mLandmarksInventoryPanel, NULL,  LLSD("category"),
                gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK));
        }
    }
    else if ("category_root" == command_name)
    {
        //in case My Landmarks tab is completely empty (thus cannot be determined as being selected)
        menu_create_inventory_item(mLandmarksInventoryPanel, NULL, LLSD("category"),
            gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK));
    }
}

void LLLandmarksPanel::onClipboardAction(const LLSD& userdata) const
{
    if(!mCurrentSelectedList)
        return;
    std::string command_name = userdata.asString();
    if("copy_slurl" == command_name)
    {
        LLFolderViewModelItemInventory* cur_item = getCurSelectedViewModelItem();
        if(cur_item)
            LLLandmarkActions::copySLURLtoClipboard(cur_item->getUUID());
    }
    else if ( "paste" == command_name)
    {
        mCurrentSelectedList->getRootFolder()->paste();
    }
    else if ( "cut" == command_name)
    {
        mCurrentSelectedList->getRootFolder()->cut();
    }
    else
    {
        mCurrentSelectedList->doToSelected(command_name);
    }
}

void LLLandmarksPanel::onFoldingAction(const LLSD& userdata)
{
    std::string command_name = userdata.asString();

    if ("expand_all" == command_name)
    {
        expand_all_folders(mCurrentSelectedList->getRootFolder());
    }
    else if ("collapse_all" == command_name)
    {
        collapse_all_folders(mCurrentSelectedList->getRootFolder());
    }
    else if ("sort_by_date" == command_name)
    {
        bool sorting_order = gSavedSettings.getBOOL("LandmarksSortedByDate");
        sorting_order=!sorting_order;
        gSavedSettings.setBOOL("LandmarksSortedByDate",sorting_order);
        updateSortOrder(mLandmarksInventoryPanel, sorting_order);
    }
    else
    {
        if(mCurrentSelectedList)
        {
            mCurrentSelectedList->doToSelected(userdata);
        }
    }
}

bool LLLandmarksPanel::isActionChecked(const LLSD& userdata) const
{
    const std::string command_name = userdata.asString();

    if ( "sort_by_date" == command_name)
    {
        bool sorting_order = gSavedSettings.getBOOL("LandmarksSortedByDate");
        return  sorting_order;
    }

    return false;
}

bool LLLandmarksPanel::isActionEnabled(const LLSD& userdata) const
{
    std::string command_name = userdata.asString();

    LLFolderView* root_folder_view = mCurrentSelectedList
        ? mCurrentSelectedList->getRootFolder()
        : NULL;

    bool is_single_selection = root_folder_view && root_folder_view->getSelectedCount() == 1;

    if ("collapse_all" == command_name)
    {
        if (!mCurrentSelectedList)
        {
            return false;
        }
        return has_expanded_folders(mCurrentSelectedList->getRootFolder());
    }
    else if ("expand_all" == command_name)
    {
        if (!mCurrentSelectedList)
        {
            return false;
        }
        return has_collapsed_folders(mCurrentSelectedList->getRootFolder());
    }
    else if ("sort_by_date" == command_name)
    {
        // disable "sort_by_date" for Favorites tab because
        // it has its own items order. EXT-1758
        if (!isLandmarksPanel)
        {
            return false;
        }
    }
    else if (  "paste"      == command_name
            || "cut"        == command_name
            || "copy"       == command_name
            || "delete"     == command_name
            || "collapse"   == command_name
            || "expand"     == command_name
            )
    {
        if (!root_folder_view) return false;

        std::set<LLFolderViewItem*> selected_uuids =    root_folder_view->getSelectionList();

        if (selected_uuids.empty())
        {
            return false;
        }

        // Allow to execute the command only if it can be applied to all selected items.
        for (std::set<LLFolderViewItem*>::const_iterator iter =    selected_uuids.begin(); iter != selected_uuids.end(); ++iter)
        {
            LLFolderViewItem* item = *iter;

            if (!item) return false;

            if (!canItemBeModified(command_name, item)) return false;
        }

        return true;
    }
    else if (  "teleport"       == command_name
            || "more_info"      == command_name
            || "show_on_map"    == command_name
            || "copy_slurl"     == command_name
            || "rename"         == command_name
            )
    {
        // disable some commands for multi-selection. EXT-1757
        if (!is_single_selection)
        {
            return false;
        }

        if ("show_on_map" == command_name)
        {
            LLFolderViewModelItemInventory* cur_item = getCurSelectedViewModelItem();
            if (!cur_item) return false;

            LLViewerInventoryItem* inv_item = dynamic_cast<LLViewerInventoryItem*>(cur_item->getInventoryObject());
            if (!inv_item) return false;

            LLUUID asset_uuid = inv_item->getAssetUUID();
            if (asset_uuid.isNull()) return false;

            // Disable "Show on Map" if landmark loading is in progress.
            return !gLandmarkList.isAssetInLoadedCallbackMap(asset_uuid);
        }
        else if ("rename" == command_name)
        {
            LLFolderViewItem* selected_item = getCurSelectedItem();
            if (!selected_item) return false;

            return canItemBeModified(command_name, selected_item);
        }

        return true;
    }
    if ("category_root" == command_name || "category" == command_name)
    {
        // we can add folder only in Landmarks tab
        return isLandmarksPanel;
    }
    else if("create_pick" == command_name)
    {
        if (mCurrentSelectedList)
        {
            std::set<LLFolderViewItem*> selection =    mCurrentSelectedList->getRootFolder()->getSelectionList();
            if (!selection.empty())
            {
                return ( 1 == selection.size() && !LLAgentPicksInfo::getInstance()->isPickLimitReached() );
            }
        }
        return false;
    }
    else if ("add_landmark" == command_name)
    {
        if (!is_single_selection)
        {
            return false;
        }

        LLFolderViewModelItemInventory* view_model = getCurSelectedViewModelItem();
        if (!view_model || view_model->getInventoryType() != LLInventoryType::IT_CATEGORY)
        {
            return false;
        }
        LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
        if (landmark)
        {
            //already exists
            return false;
        }
        return true;
    }
    else if ("add_landmark_root" == command_name)
    {
        LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
        if (landmark)
        {
            //already exists
            return false;
        }
        return true;
    }
    else if ("share" == command_name)
    {
        if (!mCurrentSelectedList)
        {
            return false;
        }
        if (!LLAvatarActions::canShareSelectedItems(mCurrentSelectedList))
        {
            return false;
        }
        return true;
    }
    else if (command_name == "move_to_landmarks" || command_name == "move_to_favorites")
    {
        LLFolderViewModelItemInventory* cur_item_model = getCurSelectedViewModelItem();
        if (cur_item_model)
        {
            LLFolderType::EType folder_type = command_name == "move_to_landmarks" ? LLFolderType::FT_FAVORITE : LLFolderType::FT_LANDMARK;
            if (!gInventory.isObjectDescendentOf(cur_item_model->getUUID(), gInventory.findCategoryUUIDForType(folder_type)))
            {
                return false;
            }

            if (root_folder_view)
            {
                std::set<LLFolderViewItem*> selected_uuids = root_folder_view->getSelectionList();
                for (std::set<LLFolderViewItem*>::const_iterator iter = selected_uuids.begin(); iter != selected_uuids.end(); ++iter)
                {
                    LLFolderViewItem* item = *iter;
                    if (!item) return false;

                    cur_item_model = static_cast<LLFolderViewModelItemInventory*>(item->getViewModelItem());
                    if (!cur_item_model || cur_item_model->getInventoryType() != LLInventoryType::IT_LANDMARK)
                    {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }
    else
    {
        LL_WARNS() << "Unprocessed command has come: " << command_name << LL_ENDL;
    }

    return true;
}

void LLLandmarksPanel::onCustomAction(const LLSD& userdata)
{
    std::string command_name = userdata.asString();
    if("more_info" == command_name)
    {
        onShowProfile();
    }
    else if ("teleport" == command_name)
    {
        onTeleport();
    }
    else if ("show_on_map" == command_name)
    {
        onShowOnMap();
    }
    else if ("create_pick" == command_name)
    {
        LLFolderViewModelItemInventory* cur_item = getCurSelectedViewModelItem();
        if (cur_item)
        {
            doActionOnCurSelectedLandmark(boost::bind(&LLLandmarksPanel::doCreatePick, this, _1, cur_item->getUUID()));
        }
    }
    else if ("share" == command_name && mCurrentSelectedList)
    {
        LLAvatarActions::shareWithAvatars(mCurrentSelectedList);
    }
    else if ("restore" == command_name && mCurrentSelectedList)
    {
        mCurrentSelectedList->doToSelected(userdata);
    }
    else if (command_name == "move_to_landmarks" || command_name == "move_to_favorites")
    {
        LLFolderView* root_folder_view = mCurrentSelectedList ? mCurrentSelectedList->getRootFolder() : NULL;
        if (root_folder_view)
        {
            LLFolderType::EType folder_type = command_name == "move_to_landmarks" ? LLFolderType::FT_LANDMARK : LLFolderType::FT_FAVORITE;
            std::set<LLFolderViewItem*> selected_uuids = root_folder_view->getSelectionList();
            for (std::set<LLFolderViewItem*>::const_iterator iter = selected_uuids.begin(); iter != selected_uuids.end(); ++iter)
            {
                LLFolderViewItem* item = *iter;
                if (item)
                {
                    LLFolderViewModelItemInventory* item_model = static_cast<LLFolderViewModelItemInventory*>(item->getViewModelItem());
                    if (item_model)
                    {
                        change_item_parent(item_model->getUUID(), gInventory.findCategoryUUIDForType(folder_type));
                    }
                }
            }
        }

    }
}

void LLLandmarksPanel::onMenuVisibilityChange(LLUICtrl* ctrl, const LLSD& param)
{
    bool new_visibility = param["visibility"].asBoolean();

    // We don't have to update items visibility if the menu is hiding.
    if (!new_visibility) return;

    bool are_any_items_in_trash = false;
    bool are_all_items_in_trash = true;

    LLFolderView* root_folder_view = mCurrentSelectedList ? mCurrentSelectedList->getRootFolder() : NULL;
    if(root_folder_view)
    {
        const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);

        std::set<LLFolderViewItem*> selected_items =    root_folder_view->getSelectionList();

        // Iterate through selected items to find out if any of these items are in Trash
        // or all the items are in Trash category.
        for (std::set<LLFolderViewItem*>::const_iterator iter =    selected_items.begin(); iter != selected_items.end(); ++iter)
        {
            LLFolderViewItem* item = *iter;

            // If no item is found it might be a folder id.
            if (!item) continue;

            LLFolderViewModelItemInventory* listenerp = static_cast<LLFolderViewModelItemInventory*>(item->getViewModelItem());
            if(!listenerp) continue;

            // Trash category itself should not be included because it can't be
            // actually restored from trash.
            are_all_items_in_trash &= listenerp->isItemInTrash() &&    listenerp->getUUID() != trash_id;

            // If there are any selected items in Trash including the Trash category itself
            // we show "Restore Item" in context menu and hide other irrelevant items.
            are_any_items_in_trash |= listenerp->isItemInTrash();
        }
    }

    // Display "Restore Item" menu entry if at least one of the selected items
    // is in Trash or the Trash category itself is among selected items.
    // Hide other menu entries in this case.
    // Enable this menu entry only if all selected items are in the Trash category.
    toggle_restore_menu((LLMenuGL*)ctrl, are_any_items_in_trash, are_all_items_in_trash);
}

/*
Processes such actions: cut/rename/delete/paste actions

Rules:
 1. We can't perform any action in Library
 2. For Landmarks we can:
    - cut/rename/delete in any other accordions
    - paste - only in Favorites, Landmarks accordions
 3. For Folders we can: perform any action in Landmarks accordion, except Received folder
 4. We can paste folders from Clipboard (processed by LLFolderView::canPaste())
 5. Check LLFolderView/Inventory Bridges rules
 */
bool LLLandmarksPanel::canItemBeModified(const std::string& command_name, LLFolderViewItem* item) const
{
    // validate own rules first

    if (!item) return false;

    bool can_be_modified = false;

    // landmarks can be modified in any other accordion...
    if (static_cast<LLFolderViewModelItemInventory*>(item->getViewModelItem())->getInventoryType() == LLInventoryType::IT_LANDMARK)
    {
        can_be_modified = true;
    }
    else
    {
        // ...folders only in the Landmarks accordion...
        can_be_modified = isLandmarksPanel;
    }

    // then ask LLFolderView permissions

    LLFolderView* root_folder = mCurrentSelectedList ? mCurrentSelectedList->getRootFolder() : nullptr;

    if ("copy" == command_name)
    {
        // we shouldn't be able to copy folders from My Inventory Panel
        return can_be_modified && root_folder && root_folder->canCopy();
    }
    else if ("collapse" == command_name)
    {
        return item->isOpen();
    }
    else if ("expand" == command_name)
    {
        return !item->isOpen();
    }

    if (can_be_modified)
    {
        LLFolderViewModelItemInventory* listenerp = static_cast<LLFolderViewModelItemInventory*>(item->getViewModelItem());

        if ("cut" == command_name)
        {
            can_be_modified = root_folder && root_folder->canCut();
        }
        else if ("rename" == command_name)
        {
            can_be_modified = listenerp ? listenerp->isItemRenameable() : false;
        }
        else if ("delete" == command_name)
        {
            can_be_modified = listenerp ? listenerp->isItemRemovable() && !listenerp->isItemInTrash() : false;
        }
        else if("paste" == command_name)
        {
            can_be_modified = root_folder && root_folder->canPaste();
        }
        else
        {
            LL_WARNS() << "Unprocessed command has come: " << command_name << LL_ENDL;
        }
    }

    return can_be_modified;
}

bool LLLandmarksPanel::handleDragAndDropToTrash(bool drop, EDragAndDropType cargo_type, void* cargo_data , EAcceptance* accept)
{
    *accept = ACCEPT_NO;

    switch (cargo_type)
    {

    case DAD_LANDMARK:
    case DAD_CATEGORY:
        {
            bool is_enabled = isActionEnabled("delete");

            if (is_enabled) *accept = ACCEPT_YES_MULTI;

            if (is_enabled && drop)
            {
                // don't call onClipboardAction("delete")
                // this lead to removing (N * 2 - 1) items if drag N>1 items into trash. EXT-6757
                // So, let remove items one by one.
                LLInventoryItem* item = static_cast<LLInventoryItem*>(cargo_data);
                if (item)
                {
                    LLFolderViewItem* fv_item = mCurrentSelectedList
                        ? mCurrentSelectedList->getItemByID(item->getUUID())
                        : NULL;

                    if (fv_item)
                    {
                        // is Item Removable checked inside of remove()
                        fv_item->remove();
                    }
                }
            }
        }
        break;
    default:
        break;
    }

    updateVerbs();
    return true;
}

void LLLandmarksPanel::doShowOnMap(LLLandmark* landmark)
{
    LLVector3d landmark_global_pos;
    if (!landmark->getGlobalPos(landmark_global_pos))
        return;

    LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
    if (!landmark_global_pos.isExactlyZero() && worldmap_instance)
    {
        worldmap_instance->trackLocation(landmark_global_pos);
        LLFloaterReg::showInstance("world_map", "center");
    }

    if (mGearLandmarkMenu)
    {
        mGearLandmarkMenu->setItemEnabled("show_on_map", true);
    }
}

void LLLandmarksPanel::doProcessParcelInfo(LLLandmark* landmark,
                                           LLInventoryItem* inv_item,
                                           const LLParcelData& parcel_data)
{
    LLVector3d landmark_global_pos;
    landmark->getGlobalPos(landmark_global_pos);

    LLPickData data;
    data.pos_global = landmark_global_pos;
    data.name = inv_item->getName();
    data.desc = inv_item->getDescription();
    data.snapshot_id = parcel_data.snapshot_id;
    data.parcel_id = parcel_data.parcel_id;

    LLFloaterProfile* profile_floater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", gAgentID)));
    if (profile_floater)
    {
        profile_floater->createPick(data);
    }
}

void LLLandmarksPanel::doCreatePick(LLLandmark* landmark, const LLUUID &item_id)
{
    LLViewerRegion* region = gAgent.getRegion();
    if (!region) return;

    mCreatePickItemId = item_id;

    LLGlobalVec pos_global;
    LLUUID region_id;
    landmark->getGlobalPos(pos_global);
    landmark->getRegionID(region_id);
    LLVector3 region_pos((F32)fmod(pos_global.mdV[VX], (F64)REGION_WIDTH_METERS),
                      (F32)fmod(pos_global.mdV[VY], (F64)REGION_WIDTH_METERS),
                      (F32)pos_global.mdV[VZ]);

    LLSD body;
    std::string url = region->getCapability("RemoteParcelRequest");
    if (!url.empty())
    {
        LLRemoteParcelInfoProcessor::getInstance()->requestRegionParcelInfo(url,
            region_id, region_pos, pos_global, getObserverHandle());
    }
    else
    {
        LL_WARNS() << "Can't create pick for landmark for region" << region_id
                << ". Region: " << region->getName()
                << " does not support RemoteParcelRequest" << LL_ENDL;
    }
}

//////////////////////////////////////////////////////////////////////////
// HELPER FUNCTIONS
//////////////////////////////////////////////////////////////////////////
static void filter_list(LLPlacesInventoryPanel* inventory_list, const std::string& string)
{
    // When search is cleared, restore the old folder state.
    if (!inventory_list->getFilterSubString().empty() && string == "")
    {
        inventory_list->setFilterSubString(LLStringUtil::null);
        // Re-open folders that were open before
        inventory_list->restoreFolderState();
    }

    if (inventory_list->getFilterSubString().empty() && string.empty())
    {
        // current filter and new filter empty, do nothing
        return;
    }

    // save current folder open state if no filter currently applied
    if (inventory_list->getFilterSubString().empty())
    {
        inventory_list->saveFolderState();
    }

    // Set new filter string
    inventory_list->setFilterSubString(string);
}

static void collapse_all_folders(LLFolderView* root_folder)
{
    if (!root_folder)
        return;

    root_folder->setOpenArrangeRecursively(false, LLFolderViewFolder::RECURSE_DOWN);
    root_folder->arrangeAll();
}

static void expand_all_folders(LLFolderView* root_folder)
{
    if (!root_folder)
        return;

    root_folder->setOpenArrangeRecursively(true, LLFolderViewFolder::RECURSE_DOWN);
    root_folder->arrangeAll();
}

static bool has_expanded_folders(LLFolderView* root_folder)
{
    LLCheckFolderState checker;
    root_folder->applyFunctorRecursively(checker);

    // We assume that the root folder is always expanded so we enable "collapse_all"
    // command when we have at least one more expanded folder.
    if (checker.getExpandedFolders() < 2)
    {
        return false;
    }

    return true;
}

static bool has_collapsed_folders(LLFolderView* root_folder)
{
    LLCheckFolderState checker;
    root_folder->applyFunctorRecursively(checker);

    if (checker.getCollapsedFolders() < 1)
    {
        return false;
    }

    return true;
}

// Displays "Restore Item" context menu entry while hiding
// all other entries or vice versa.
// Sets "Restore Item" enabled state.
void toggle_restore_menu(LLMenuGL *menu, bool visible, bool enabled)
{
    if (!menu) return;

    const LLView::child_list_t *list = menu->getChildList();
    for (LLView::child_list_t::const_iterator itor = list->begin();
         itor != list->end();
         ++itor)
    {
        LLView *menu_item = (*itor);
        std::string name = menu_item->getName();

        if ("restore_item" == name)
        {
            menu_item->setVisible(visible);
            menu_item->setEnabled(enabled);
        }
        else
        {
            menu_item->setVisible(!visible);
        }
    }
}

LLFavoritesPanel::LLFavoritesPanel()
    :   LLLandmarksPanel(false)
{
    buildFromFile("panel_favorites.xml");
}

bool LLFavoritesPanel::postBuild()
{
    if (!gInventory.isInventoryUsable())
        return false;

    // mast be called before any other initXXX methods to init Gear menu
    LLLandmarksPanel::initListCommandsHandlers();

    initFavoritesInventoryPanel();

    return true;
}

void LLFavoritesPanel::initFavoritesInventoryPanel()
{
    mCurrentSelectedList = getChild<LLPlacesInventoryPanel>("favorites_list");

    LLLandmarksPanel::initLandmarksPanel(mCurrentSelectedList);
    mCurrentSelectedList->getFilter().setEmptyLookupMessage("FavoritesNoMatchingItems");
}
// EOF