path: root/indra/newview/llgrouplist.cpp

/**
 * @file llgrouplist.cpp
 * @brief List of the groups the agent belongs to.
 *
 * $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 "llgrouplist.h"

// libs
#include "llbutton.h"
#include "llgroupiconctrl.h"
#include "llmenugl.h"
#include "lltextbox.h"
#include "lltextutil.h"
#include "lltrans.h"

// newview
#include "llagent.h"
#include "llgroupactions.h"
#include "llfloaterreg.h"
#include "llviewercontrol.h"    // for gSavedSettings
#include "llviewermenu.h"       // for gMenuHolder
#include "llvoiceclient.h"

static LLDefaultChildRegistry::Register<LLGroupList> r("group_list");

class LLGroupComparator : public LLFlatListView::ItemComparator
{
public:
    LLGroupComparator() {};

    /** Returns true if item1 < item2, false otherwise */
    /*virtual*/ bool compare(const LLPanel* item1, const LLPanel* item2) const
    {
        std::string name1 = static_cast<const LLGroupListItem*>(item1)->getGroupName();
        std::string name2 = static_cast<const LLGroupListItem*>(item2)->getGroupName();

        LLStringUtil::toUpper(name1);
        LLStringUtil::toUpper(name2);

        return name1 < name2;
    }
};

class LLSharedGroupComparator : public LLFlatListView::ItemComparator
{
public:
    LLSharedGroupComparator() {};

    /*virtual*/ bool compare(const LLPanel* item1, const LLPanel* item2) const
    {
        const LLGroupListItem* group_item1 = static_cast<const LLGroupListItem*>(item1);
        std::string name1 = group_item1->getGroupName();
        bool item1_shared = gAgent.isInGroup(group_item1->getGroupID(), true);

        const LLGroupListItem* group_item2 = static_cast<const LLGroupListItem*>(item2);
        std::string name2 = group_item2->getGroupName();
        bool item2_shared = gAgent.isInGroup(group_item2->getGroupID(), true);

        if (item2_shared != item1_shared)
        {
            return item1_shared;
        }

        LLStringUtil::toUpper(name1);
        LLStringUtil::toUpper(name2);

        return name1 < name2;
    }
};

static LLGroupComparator GROUP_COMPARATOR;
static LLSharedGroupComparator SHARED_GROUP_COMPARATOR;

LLGroupList::Params::Params()
: for_agent("for_agent", true)
{
}

LLGroupList::LLGroupList(const Params& p)
:   LLFlatListViewEx(p)
    , mForAgent(p.for_agent)
    , mDirty(true) // to force initial update
    , mShowIcons(false)
    , mShowNone(true)
{
    setCommitOnSelectionChange(true);

    // Set default sort order.
    if (mForAgent)
    {
        setComparator(&GROUP_COMPARATOR);
    }
    else
    {
        // shared groups first
        setComparator(&SHARED_GROUP_COMPARATOR);
    }

    if (mForAgent)
    {
        enableForAgent(true);
    }
}

LLGroupList::~LLGroupList()
{
    if (mForAgent) gAgent.removeListener(this);
    if (mContextMenuHandle.get()) mContextMenuHandle.get()->die();
}

void LLGroupList::enableForAgent(bool show_icons)
{
    mForAgent = true;

    mShowIcons = mForAgent && gSavedSettings.getBOOL("GroupListShowIcons") && show_icons;

    // Listen for agent group changes.
    gAgent.addListener(this, "new group");

    // Set up context menu.
    ScopedRegistrarHelper registrar;
    LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;

    registrar.add("People.Groups.Action",           boost::bind(&LLGroupList::onContextMenuItemClick,   this, _2));
    enable_registrar.add("People.Groups.Enable",    boost::bind(&LLGroupList::onContextMenuItemEnable,  this, _2));

    LLToggleableMenu* context_menu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_people_groups.xml",
            gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
    if(context_menu)
        mContextMenuHandle = context_menu->getHandle();
}

// virtual
void LLGroupList::draw()
{
    if (mDirty)
        refresh();

    LLFlatListView::draw();
}

// virtual
BOOL LLGroupList::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
    BOOL handled = LLUICtrl::handleRightMouseDown(x, y, mask);

    if (mForAgent)
    {
        LLToggleableMenu* context_menu = mContextMenuHandle.get();
        if (context_menu && size() > 0)
        {
            context_menu->buildDrawLabels();
            context_menu->updateParent(LLMenuGL::sMenuContainer);
            LLMenuGL::showPopup(this, context_menu, x, y);
        }
    }

    return handled;
}

// virtual
BOOL LLGroupList::handleDoubleClick(S32 x, S32 y, MASK mask)
{
    BOOL handled = LLView::handleDoubleClick(x, y, mask);
    // Handle double click only for the selected item in the list, skip clicks on empty space.
    if (handled)
    {
        if (mDoubleClickSignal && getItemsRect().pointInRect(x, y))
        {
            (*mDoubleClickSignal)(this, x, y, mask);
        }
    }

    return handled;
}

void LLGroupList::setNameFilter(const std::string& filter)
{
    std::string filter_upper = filter;
    LLStringUtil::toUpper(filter_upper);
    if (mNameFilter != filter_upper)
    {
        mNameFilter = filter_upper;

        // set no items message depend on filter state
        updateNoItemsMessage(filter);

        setDirty();
    }
}

static bool findInsensitive(std::string haystack, const std::string& needle_upper)
{
    LLStringUtil::toUpper(haystack);
    return haystack.find(needle_upper) != std::string::npos;
}

void LLGroupList::refresh()
{
    if (mForAgent)
    {
        const LLUUID&       highlight_id    = gAgent.getGroupID();
        S32                 count           = gAgent.mGroups.size();
        LLUUID              id;
        bool                have_filter     = !mNameFilter.empty();

        clear();

        for(S32 i = 0; i < count; ++i)
        {
            id = gAgent.mGroups.at(i).mID;
            const LLGroupData& group_data = gAgent.mGroups.at(i);
            if (have_filter && !findInsensitive(group_data.mName, mNameFilter))
                continue;
            addNewItem(id, group_data.mName, group_data.mInsigniaID, ADD_BOTTOM, group_data.mListInProfile);
        }

        // Sort the list.
        sort();

        // Add "none" to list at top if filter not set (what's the point of filtering "none"?).
        // but only if some real groups exists. EXT-4838
        if (!have_filter && count > 0 && mShowNone)
        {
            std::string loc_none = LLTrans::getString("GroupsNone");
            addNewItem(LLUUID::null, loc_none, LLUUID::null, ADD_TOP);
        }

        selectItemByUUID(highlight_id);
    }
    else
    {
        clear();

        for (group_map_t::iterator it = mGroups.begin(); it != mGroups.end(); ++it)
        {
            addNewItem(it->second, it->first, LLUUID::null, ADD_BOTTOM);
        }

        // Sort the list.
        sort();
    }

    setDirty(false);
    onCommit();
}

void LLGroupList::toggleIcons()
{
    // Save the new value for new items to use.
    mShowIcons = !mShowIcons;
    gSavedSettings.setBOOL("GroupListShowIcons", mShowIcons);

    // Show/hide icons for all existing items.
    std::vector<LLPanel*> items;
    getItems(items);
    for( std::vector<LLPanel*>::const_iterator it = items.begin(); it != items.end(); it++)
    {
        static_cast<LLGroupListItem*>(*it)->setGroupIconVisible(mShowIcons);
    }
}

void LLGroupList::setGroups(const std::map< std::string,LLUUID> group_list)
{
    mGroups = group_list;
    setDirty(true);
}

//////////////////////////////////////////////////////////////////////////
// PRIVATE Section
//////////////////////////////////////////////////////////////////////////

void LLGroupList::addNewItem(const LLUUID& id, const std::string& name, const LLUUID& icon_id, EAddPosition pos, bool visible_in_profile)
{
    LLGroupListItem* item = new LLGroupListItem(mForAgent, mShowIcons);

    item->setGroupID(id);
    item->setName(name, mNameFilter);
    item->setGroupIconID(icon_id);

    item->getChildView("info_btn")->setVisible( false);
    item->getChildView("profile_btn")->setVisible( false);
    item->getChildView("notices_btn")->setVisible(false);
    item->setGroupIconVisible(mShowIcons);
    if (!mShowIcons)
    {
        item->setVisibleInProfile(visible_in_profile);
    }
    addItem(item, id, pos);

//  setCommentVisible(false);
}

// virtual
bool LLGroupList::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
{
    // Why is "new group" sufficient?
    if (event->desc() == "new group")
    {
        setDirty();
        return true;
    }

    if (event->desc() == "value_changed")
    {
        LLSD data = event->getValue();
        if (data.has("group_id") && data.has("visible"))
        {
            LLUUID group_id = data["group_id"].asUUID();
            bool visible = data["visible"].asBoolean();

            std::vector<LLPanel*> items;
            getItems(items);
            for (std::vector<LLPanel*>::iterator it = items.begin(); it != items.end(); ++it)
            {
                LLGroupListItem* item = dynamic_cast<LLGroupListItem*>(*it);
                if (item && item->getGroupID() == group_id)
                {
                    item->setVisibleInProfile(visible);
                    break;
                }
            }
        }
        return true;
    }

    return false;
}

bool LLGroupList::onContextMenuItemClick(const LLSD& userdata)
{
    std::string action = userdata.asString();
    LLUUID selected_group = getSelectedUUID();

    if (action == "view_info")
    {
        LLGroupActions::show(selected_group);
    }
    else if (action == "chat")
    {
        LLGroupActions::startIM(selected_group);
    }
    else if (action == "call")
    {
        LLGroupActions::startCall(selected_group);
    }
    else if (action == "activate")
    {
        LLGroupActions::activate(selected_group);
    }
    else if (action == "leave")
    {
        LLGroupActions::leave(selected_group);
    }

    return true;
}

bool LLGroupList::onContextMenuItemEnable(const LLSD& userdata)
{
    LLUUID selected_group_id = getSelectedUUID();
    bool real_group_selected = selected_group_id.notNull(); // a "real" (not "none") group is selected

    // each group including "none" can be activated
    if (userdata.asString() == "activate")
        return gAgent.getGroupID() != selected_group_id;

    if (userdata.asString() == "call")
      return real_group_selected && LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();

    return real_group_selected;
}

/************************************************************************/
/*          LLGroupListItem implementation                              */
/************************************************************************/

LLGroupListItem::LLGroupListItem(bool for_agent, bool show_icons)
:   LLPanel(),
mGroupIcon(NULL),
mGroupNameBox(NULL),
mInfoBtn(NULL),
mProfileBtn(NULL),
mNoticesBtn(NULL),
mVisibilityHideBtn(NULL),
mVisibilityShowBtn(NULL),
mGroupID(LLUUID::null),
mForAgent(for_agent)
{
    if (show_icons)
    {
        buildFromFile( "panel_group_list_item.xml");
    }
    else
    {
        buildFromFile( "panel_group_list_item_short.xml");
    }
}

LLGroupListItem::~LLGroupListItem()
{
    LLGroupMgr::getInstance()->removeObserver(this);
}

//virtual
BOOL  LLGroupListItem::postBuild()
{
    mGroupIcon = getChild<LLGroupIconCtrl>("group_icon");
    mGroupNameBox = getChild<LLTextBox>("group_name");

    mInfoBtn = getChild<LLButton>("info_btn");
    mInfoBtn->setClickedCallback(boost::bind(&LLGroupListItem::onInfoBtnClick, this));

    mProfileBtn = getChild<LLButton>("profile_btn");
    mProfileBtn->setClickedCallback([this](LLUICtrl *, const LLSD &) { onProfileBtnClick(); });

    mNoticesBtn = getChild<LLButton>("notices_btn");
    mNoticesBtn->setClickedCallback([this](LLUICtrl *, const LLSD &) { onNoticesBtnClick(); });

    mVisibilityHideBtn = findChild<LLButton>("visibility_hide_btn");
    if (mVisibilityHideBtn)
    {
        mVisibilityHideBtn->setClickedCallback([this](LLUICtrl *, const LLSD &) { onVisibilityBtnClick(false); });
    }
    mVisibilityShowBtn = findChild<LLButton>("visibility_show_btn");
    if (mVisibilityShowBtn)
    {
        mVisibilityShowBtn->setClickedCallback([this](LLUICtrl *, const LLSD &) { onVisibilityBtnClick(true); });
    }

    // Remember group icon width including its padding from the name text box,
    // so that we can hide and show the icon again later.
    // Also note that panel_group_list_item and panel_group_list_item_short
    // have icons of different sizes so we need to figure it per file.
    mIconWidth = mGroupNameBox->getRect().mLeft - mGroupIcon->getRect().mLeft;

    return TRUE;
}

//virtual
void LLGroupListItem::setValue( const LLSD& value )
{
    if (!value.isMap()) return;
    if (!value.has("selected")) return;
    getChildView("selected_icon")->setVisible( value["selected"]);
}

void LLGroupListItem::onMouseEnter(S32 x, S32 y, MASK mask)
{
    getChildView("hovered_icon")->setVisible( true);
    if (mGroupID.notNull()) // don't show the info button for the "none" group
    {
        mInfoBtn->setVisible(true);
        mProfileBtn->setVisible(true);
        if (mForAgent)
        {
            LLGroupData agent_gdatap;
            if (gAgent.getGroupData(mGroupID, agent_gdatap))
            {
                if (mVisibilityHideBtn)
                {
                    mVisibilityHideBtn->setVisible(agent_gdatap.mListInProfile);
                    mVisibilityShowBtn->setVisible(!agent_gdatap.mListInProfile);
                }
                mNoticesBtn->setVisible(true);
            }
        }
    }

    LLPanel::onMouseEnter(x, y, mask);
}

void LLGroupListItem::onMouseLeave(S32 x, S32 y, MASK mask)
{
    getChildView("hovered_icon")->setVisible( false);
    mInfoBtn->setVisible(false);
    mProfileBtn->setVisible(false);
    mNoticesBtn->setVisible(false);
    if (mVisibilityHideBtn)
    {
        mVisibilityHideBtn->setVisible(false);
        mVisibilityShowBtn->setVisible(false);
    }

    LLPanel::onMouseLeave(x, y, mask);
}

void LLGroupListItem::setName(const std::string& name, const std::string& highlight)
{
    mGroupName = name;
    LLTextUtil::textboxSetHighlightedVal(mGroupNameBox, mGroupNameStyle, name, highlight);
    mGroupNameBox->setToolTip(name);
}

void LLGroupListItem::setGroupID(const LLUUID& group_id)
{
    LLGroupMgr::getInstance()->removeObserver(this);

    mID = group_id;
    mGroupID = group_id;

    if (mForAgent)
    {
        // Active group should be bold.
        setBold(group_id == gAgent.getGroupID());
    }
    else
    {
        // Groups shared with the agent should be bold
        setBold(gAgent.isInGroup(group_id, true));
    }

    LLGroupMgr::getInstance()->addObserver(this);
}

void LLGroupListItem::setGroupIconID(const LLUUID& group_icon_id)
{
    mGroupIcon->setIconId(group_icon_id);
}

void LLGroupListItem::setGroupIconVisible(bool visible)
{
    // Already done? Then do nothing.
    if (mGroupIcon->getVisible() == (BOOL)visible)
        return;

    // Show/hide the group icon.
    mGroupIcon->setVisible(visible);

    // Move the group name horizontally by icon size + its distance from the group name.
    LLRect name_rect = mGroupNameBox->getRect();
    name_rect.mLeft += visible ? mIconWidth : -mIconWidth;
    mGroupNameBox->setRect(name_rect);
}

void LLGroupListItem::setVisibleInProfile(bool visible)
{
    mGroupNameBox->setColor(LLUIColorTable::instance().getColor((visible ? "GroupVisibleInProfile" : "GroupHiddenInProfile"), LLColor4::red).get());
}

//////////////////////////////////////////////////////////////////////////
// Private Section
//////////////////////////////////////////////////////////////////////////
void LLGroupListItem::setBold(bool bold)
{
    // *BUG: setName() overrides the style params.

    LLFontDescriptor new_desc(mGroupNameBox->getFont()->getFontDesc());

    // *NOTE dzaporozhan
    // On Windows LLFontGL::NORMAL will not remove LLFontGL::BOLD if font
    // is predefined as bold (SansSerifSmallBold, for example)
    new_desc.setStyle(bold ? LLFontGL::BOLD : LLFontGL::NORMAL);
    LLFontGL* new_font = LLFontGL::getFont(new_desc);
    mGroupNameStyle.font = new_font;

    // *NOTE: You cannot set the style on a text box anymore, you must
    // rebuild the text.  This will cause problems if the text contains
    // hyperlinks, as their styles will be wrong.
    mGroupNameBox->setText(mGroupName, mGroupNameStyle);
}

void LLGroupListItem::onInfoBtnClick()
{
    LLFloaterReg::showInstance("inspect_group", LLSD().with("group_id", mGroupID));
}

void LLGroupListItem::onProfileBtnClick()
{
    LLGroupActions::show(mGroupID);
}

void LLGroupListItem::onNoticesBtnClick()
{
    LLGroupActions::show(mGroupID, true);
}

void LLGroupListItem::onVisibilityBtnClick(bool new_visibility)
{
    LLGroupData agent_gdatap;
    if (gAgent.getGroupData(mGroupID, agent_gdatap))
    {
        gAgent.setUserGroupFlags(mGroupID, agent_gdatap.mAcceptNotices, new_visibility);
        setVisibleInProfile(new_visibility);
        mVisibilityHideBtn->setVisible(new_visibility);
        mVisibilityShowBtn->setVisible(!new_visibility);
    }
}

void LLGroupListItem::changed(LLGroupChange gc)
{
    LLGroupMgrGroupData* group_data = LLGroupMgr::getInstance()->getGroupData(mID);
    if ((gc == GC_ALL || gc == GC_PROPERTIES) && group_data)
    {
        setGroupIconID(group_data->mInsigniaID);
    }
}

//EOF