/**
 * @file llsidepaneltaskinfo.cpp
 * @brief LLSidepanelTaskInfo class implementation
 * This class represents the panel in the build view for
 * viewing/editing object names, owners, permissions, etc.
 *
 * $LicenseInfo:firstyear=2002&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 "llsidepaneltaskinfo.h"

#include "lluuid.h"
#include "llpermissions.h"
#include "llcategory.h"
#include "llclickaction.h"
#include "llfocusmgr.h"
#include "llnotificationsutil.h"
#include "llstring.h"

#include "llviewerwindow.h"
#include "llresmgr.h"
#include "lltextbox.h"
#include "llbutton.h"
#include "llcallbacklist.h"
#include "llcheckboxctrl.h"
#include "llviewerobject.h"
#include "llselectmgr.h"
#include "llagent.h"
#include "llstatusbar.h"        // for getBalance()
#include "lllineeditor.h"
#include "llcombobox.h"
#include "lluiconstants.h"
#include "lldbstrings.h"
#include "llfloatergroups.h"
#include "llfloaterreg.h"
#include "llavataractions.h"
#include "llnamebox.h"
#include "llviewercontrol.h"
#include "llviewermenu.h"
#include "lluictrlfactory.h"
#include "llspinctrl.h"
#include "roles_constants.h"
#include "llgroupactions.h"
#include "lltextbase.h"
#include "llstring.h"
#include "lltrans.h"

///----------------------------------------------------------------------------
/// Class llsidepaneltaskinfo
///----------------------------------------------------------------------------

LLSidepanelTaskInfo* LLSidepanelTaskInfo::sActivePanel = NULL;

static LLPanelInjector<LLSidepanelTaskInfo> t_task_info("sidepanel_task_info");

static std::string click_action_to_string_value(U8 click_action)
{
    switch (click_action)
    {
        case CLICK_ACTION_TOUCH:
            return "Touch";
        case CLICK_ACTION_SIT:
            return "Sit";
        case CLICK_ACTION_BUY:
            return "Buy";
        case CLICK_ACTION_PAY:
            return "Pay";
        case CLICK_ACTION_OPEN:
            return "Open";
        case CLICK_ACTION_ZOOM:
            return "Zoom";
        case CLICK_ACTION_DISABLED:
            return "None";
        case CLICK_ACTION_IGNORE:
            return "Ignore";
        default:
            return "Touch";
    }
    return "Touch";
}

// Default constructor
LLSidepanelTaskInfo::LLSidepanelTaskInfo()
    : mVisibleDebugPermissions(true) // space was allocated by default
{
    setMouseOpaque(false);
    mSelectionUpdateSlot = LLSelectMgr::instance().mUpdateSignal.connect(boost::bind(&LLSidepanelTaskInfo::refreshAll, this));
    gIdleCallbacks.addFunction(&LLSidepanelTaskInfo::onIdle, (void*)this);
}


LLSidepanelTaskInfo::~LLSidepanelTaskInfo()
{
    if (sActivePanel == this)
        sActivePanel = NULL;
    gIdleCallbacks.deleteFunction(&LLSidepanelTaskInfo::onIdle, (void*)this);

    if (mSelectionUpdateSlot.connected())
    {
        mSelectionUpdateSlot.disconnect();
    }
}

// virtual
bool LLSidepanelTaskInfo::postBuild()
{
    mOpenBtn = getChild<LLButton>("open_btn");
    mOpenBtn->setClickedCallback(boost::bind(&LLSidepanelTaskInfo::onOpenButtonClicked, this));
    mPayBtn = getChild<LLButton>("pay_btn");
    mPayBtn->setClickedCallback(boost::bind(&LLSidepanelTaskInfo::onPayButtonClicked, this));
    mBuyBtn = getChild<LLButton>("buy_btn");
    mBuyBtn->setClickedCallback(boost::bind(&handle_buy));
    mDetailsBtn = getChild<LLButton>("details_btn");
    mDetailsBtn->setClickedCallback(boost::bind(&LLSidepanelTaskInfo::onDetailsButtonClicked, this));

    mDeedBtn = getChild<LLButton>("button deed");

    mLabelGroupName = getChild<LLNameBox>("Group Name Proxy");

    childSetCommitCallback("Object Name",                       LLSidepanelTaskInfo::onCommitName,this);
    getChild<LLLineEditor>("Object Name")->setPrevalidate(LLTextValidate::validateASCIIPrintableNoPipe);
    childSetCommitCallback("Object Description",                LLSidepanelTaskInfo::onCommitDesc,this);
    getChild<LLLineEditor>("Object Description")->setPrevalidate(LLTextValidate::validateASCIIPrintableNoPipe);
    getChild<LLUICtrl>("button set group")->setCommitCallback(boost::bind(&LLSidepanelTaskInfo::onClickGroup,this));
    childSetCommitCallback("checkbox share with group",         &LLSidepanelTaskInfo::onCommitGroupShare,this);
    childSetAction("button deed",                               &LLSidepanelTaskInfo::onClickDeedToGroup,this);
    childSetCommitCallback("checkbox allow everyone move",      &LLSidepanelTaskInfo::onCommitEveryoneMove,this);
    childSetCommitCallback("checkbox allow everyone copy",      &LLSidepanelTaskInfo::onCommitEveryoneCopy,this);
    childSetCommitCallback("checkbox for sale",                 &LLSidepanelTaskInfo::onCommitSaleInfo,this);
    childSetCommitCallback("sale type",                         &LLSidepanelTaskInfo::onCommitSaleType,this);
    childSetCommitCallback("Edit Cost",                         &LLSidepanelTaskInfo::onCommitSaleInfo, this);
    childSetCommitCallback("checkbox next owner can modify",    &LLSidepanelTaskInfo::onCommitNextOwnerModify,this);
    childSetCommitCallback("checkbox next owner can copy",      &LLSidepanelTaskInfo::onCommitNextOwnerCopy,this);
    childSetCommitCallback("checkbox next owner can transfer",  &LLSidepanelTaskInfo::onCommitNextOwnerTransfer,this);
    childSetCommitCallback("clickaction",                       &LLSidepanelTaskInfo::onCommitClickAction,this);
    childSetCommitCallback("search_check",                      &LLSidepanelTaskInfo::onCommitIncludeInSearch,this);

    mDAPermModify = getChild<LLUICtrl>("perm_modify");
    mDACreatorName = getChild<LLUICtrl>("Creator Name");
    mDAOwner = getChildView("Owner:");
    mDAOwnerName = getChild<LLUICtrl>("Owner Name");
    mDAButtonSetGroup = getChildView("button set group");
    mDAObjectName = getChild<LLUICtrl>("Object Name");
    mDAName = getChildView("Name:");
    mDADescription = getChildView("Description:");
    mDAObjectDescription = getChild<LLUICtrl>("Object Description");
    mDACheckboxShareWithGroup = getChild<LLUICtrl>("checkbox share with group");
    mDAButtonDeed = getChildView("button deed");
    mDACheckboxAllowEveryoneMove = getChild<LLUICtrl>("checkbox allow everyone move");
    mDACheckboxAllowEveryoneCopy = getChild<LLUICtrl>("checkbox allow everyone copy");
    mDACheckboxNextOwnerCanModify = getChild<LLUICtrl>("checkbox next owner can modify");
    mDACheckboxNextOwnerCanCopy = getChild<LLUICtrl>("checkbox next owner can copy");
    mDACheckboxNextOwnerCanTransfer = getChild<LLUICtrl>("checkbox next owner can transfer");
    mDACheckboxForSale = getChild<LLUICtrl>("checkbox for sale");
    mDASearchCheck = getChild<LLUICtrl>("search_check");
    mDAComboSaleType = getChild<LLComboBox>("sale type");
    mDAEditCost = getChild<LLUICtrl>("Edit Cost");
    mDALabelClickAction = getChildView("label click action");
    mDAComboClickAction = getChild<LLComboBox>("clickaction");
    mDAPathfindingAttributes = getChild<LLTextBase>("pathfinding_attributes_value");
    mDAB = getChild<LLUICtrl>("B:");
    mDAO = getChild<LLUICtrl>("O:");
    mDAG = getChild<LLUICtrl>("G:");
    mDAE = getChild<LLUICtrl>("E:");
    mDAN = getChild<LLUICtrl>("N:");
    mDAF = getChild<LLUICtrl>("F:");

    return true;
}

/*virtual*/ void LLSidepanelTaskInfo::onVisibilityChange(bool visible)
{
    if (visible)
    {
        sActivePanel = this;
        mObject = getFirstSelectedObject();
    }
    else
    {
        sActivePanel = NULL;
        // drop selection reference
        mObjectSelection = NULL;
    }
}


void LLSidepanelTaskInfo::disableAll()
{
    mDACreatorName->setValue(LLStringUtil::null);
    mDACreatorName->setEnabled(false);

    mDAOwner->setEnabled(false);
    mDAOwnerName->setValue(LLStringUtil::null);
    mDAOwnerName->setEnabled(false);

    mDAObjectName->setValue(LLStringUtil::null);
    mDAObjectName->setEnabled(false);
    mDAName->setEnabled(false);
    mDADescription->setEnabled(false);
    mDAObjectDescription->setValue(LLStringUtil::null);
    mDAObjectDescription->setEnabled(false);

    mDAPathfindingAttributes->setEnabled(false);
    mDAPathfindingAttributes->setValue(LLStringUtil::null);

    mDAButtonSetGroup->setEnabled(false);
    mDAButtonDeed->setEnabled(false);

    mDAPermModify->setEnabled(false);
    mDAPermModify->setValue(LLStringUtil::null);
    mDAEditCost->setValue(LLStringUtil::null);
    mDAComboSaleType->setValue(LLSaleInfo::FS_COPY);

    disablePermissions();

    if (mVisibleDebugPermissions)
    {
        mDAB->setVisible(false);
        mDAO->setVisible(false);
        mDAG->setVisible(false);
        mDAE->setVisible(false);
        mDAN->setVisible(false);
        mDAF->setVisible(false);

        LLFloater* parent_floater = gFloaterView->getParentFloater(this);
        LLRect parent_rect = parent_floater->getRect();
        LLRect debug_rect = mDAB->getRect();
        // use double the debug rect for padding (since it isn't trivial to extract top_pad)
        parent_floater->reshape(parent_rect.getWidth(), parent_rect.getHeight() - (debug_rect.getHeight() * 2));
        mVisibleDebugPermissions = false;
    }

    mOpenBtn->setEnabled(false);
    mPayBtn->setEnabled(false);
    mBuyBtn->setEnabled(false);
}

void LLSidepanelTaskInfo::disablePermissions()
{
    mDACheckboxShareWithGroup->setValue(false);
    mDACheckboxShareWithGroup->setEnabled(false);

    mDACheckboxAllowEveryoneMove->setValue(false);
    mDACheckboxAllowEveryoneMove->setEnabled(false);
    mDACheckboxAllowEveryoneCopy->setValue(false);
    mDACheckboxAllowEveryoneCopy->setEnabled(false);

    //Next owner can:
    mDACheckboxNextOwnerCanModify->setValue(false);
    mDACheckboxNextOwnerCanModify->setEnabled(false);
    mDACheckboxNextOwnerCanCopy->setValue(false);
    mDACheckboxNextOwnerCanCopy->setEnabled(false);
    mDACheckboxNextOwnerCanTransfer->setValue(false);
    mDACheckboxNextOwnerCanTransfer->setEnabled(false);

    //checkbox for sale
    mDACheckboxForSale->setValue(false);
    mDACheckboxForSale->setEnabled(false);

    //checkbox include in search
    mDASearchCheck->setValue(false);
    mDASearchCheck->setEnabled(false);

    mDAComboSaleType->setEnabled(false);

    mDAEditCost->setEnabled(false);

    mDALabelClickAction->setEnabled(false);
    if (mDAComboClickAction)
    {
        mDAComboClickAction->setEnabled(false);
        mDAComboClickAction->clear();
    }
}

void LLSidepanelTaskInfo::refresh()
{
    mIsDirty = false;

    LLButton* btn_deed_to_group = mDeedBtn;
    if (btn_deed_to_group)
    {
        std::string deedText;
        if (gWarningSettings.getBOOL("DeedObject"))
        {
            deedText = getString("text deed continued");
        }
        else
        {
            deedText = getString("text deed");
        }
        btn_deed_to_group->setLabelSelected(deedText);
        btn_deed_to_group->setLabelUnselected(deedText);
    }

    bool root_selected = true;
    LLSelectNode* nodep = mObjectSelection->getFirstRootNode();
    S32 object_count = mObjectSelection->getRootObjectCount();
    if (!nodep || (object_count == 0))
    {
        nodep = mObjectSelection->getFirstNode();
        object_count = mObjectSelection->getObjectCount();
        root_selected = false;
    }

    LLViewerObject* objectp = NULL;
    if (nodep)
    {
        objectp = nodep->getObject();
    }

    // ...nothing selected
    if (!nodep || !objectp)
    {
        disableAll();
        return;
    }

    // figure out a few variables
    const bool is_one_object = (object_count == 1);

    // BUG: fails if a root and non-root are both single-selected.
    const bool is_perm_modify = (mObjectSelection->getFirstRootNode() && LLSelectMgr::getInstance()->selectGetRootsModify()) ||
        LLSelectMgr::getInstance()->selectGetModify();
    const bool is_nonpermanent_enforced = (mObjectSelection->getFirstRootNode() && LLSelectMgr::getInstance()->selectGetRootsNonPermanentEnforced()) ||
        LLSelectMgr::getInstance()->selectGetNonPermanentEnforced();

    S32 string_index = 0;
    std::string MODIFY_INFO_STRINGS[] =
        {
            getString("text modify info 1"),
            getString("text modify info 2"),
            getString("text modify info 3"),
            getString("text modify info 4"),
            getString("text modify info 5"),
            getString("text modify info 6")
        };
    if (!is_perm_modify)
    {
        string_index += 2;
    }
    else if (!is_nonpermanent_enforced)
    {
        string_index += 4;
    }
    if (!is_one_object)
    {
        ++string_index;
    }
    getChildView("perm_modify")->setEnabled(true);
    getChild<LLUICtrl>("perm_modify")->setValue(MODIFY_INFO_STRINGS[string_index]);

    std::string pfAttrName;

    if ((mObjectSelection->getFirstRootNode()
        && LLSelectMgr::getInstance()->selectGetRootsNonPathfinding())
        || LLSelectMgr::getInstance()->selectGetNonPathfinding())
    {
        pfAttrName = "Pathfinding_Object_Attr_None";
    }
    else if ((mObjectSelection->getFirstRootNode()
        && LLSelectMgr::getInstance()->selectGetRootsPermanent())
        || LLSelectMgr::getInstance()->selectGetPermanent())
    {
        pfAttrName = "Pathfinding_Object_Attr_Permanent";
    }
    else if ((mObjectSelection->getFirstRootNode()
        && LLSelectMgr::getInstance()->selectGetRootsCharacter())
        || LLSelectMgr::getInstance()->selectGetCharacter())
    {
        pfAttrName = "Pathfinding_Object_Attr_Character";
    }
    else
    {
        pfAttrName = "Pathfinding_Object_Attr_MultiSelect";
    }

    mDAPathfindingAttributes->setEnabled(true);
    mDAPathfindingAttributes->setValue(LLTrans::getString(pfAttrName));

    // Update creator text field
    getChildView("Creator:")->setEnabled(true);

    std::string creator_name;
    LLUUID creator_id;
    LLSelectMgr::getInstance()->selectGetCreator(creator_id, creator_name);

    if(creator_id != mCreatorID )
    {
        mDACreatorName->setValue(creator_name);
        mCreatorID = creator_id;
    }
    if(mDACreatorName->getValue().asString() == LLStringUtil::null)
    {
        mDACreatorName->setValue(creator_name);
    }
    mDACreatorName->setEnabled(true);

    // Update owner text field
    getChildView("Owner:")->setEnabled(true);

    std::string owner_name;
    LLUUID owner_id;
    const bool owners_identical = LLSelectMgr::getInstance()->selectGetOwner(owner_id, owner_name);
    if (owner_id.isNull())
    {
        if (LLSelectMgr::getInstance()->selectIsGroupOwned())
        {
            // Group owned already displayed by selectGetOwner
        }
        else
        {
            // Display last owner if public
            std::string last_owner_name;
            LLSelectMgr::getInstance()->selectGetLastOwner(mLastOwnerID, last_owner_name);

            // It should never happen that the last owner is null and the owner
            // is null, but it seems to be a bug in the simulator right now. JC
            if (!mLastOwnerID.isNull() && !last_owner_name.empty())
            {
                owner_name.append(", last ");
                owner_name.append(last_owner_name);
            }
        }
    }

    if(owner_id.isNull() || (owner_id != mOwnerID))
    {
        mDAOwnerName->setValue(owner_name);
        mOwnerID = owner_id;
    }
    if(mDAOwnerName->getValue().asString() == LLStringUtil::null)
    {
        mDAOwnerName->setValue(owner_name);
    }

    getChildView("Owner Name")->setEnabled(true);

    // update group text field
    getChildView("Group:")->setEnabled(true);
    getChild<LLUICtrl>("Group Name")->setValue(LLStringUtil::null);
    LLUUID group_id;
    bool groups_identical = LLSelectMgr::getInstance()->selectGetGroup(group_id);
    if (groups_identical)
    {
        if (mLabelGroupName)
        {
            mLabelGroupName->setNameID(group_id,true);
            mLabelGroupName->setEnabled(true);
        }
    }
    else
    {
        if (mLabelGroupName)
        {
            mLabelGroupName->setNameID(LLUUID::null, true);
            mLabelGroupName->refresh(LLUUID::null, std::string(), true);
            mLabelGroupName->setEnabled(false);
        }
    }

    getChildView("button set group")->setEnabled(owners_identical && (mOwnerID == gAgent.getID()) && is_nonpermanent_enforced);

    getChildView("Name:")->setEnabled(true);
    LLLineEditor* LineEditorObjectName = getChild<LLLineEditor>("Object Name");
    getChildView("Description:")->setEnabled(true);
    LLLineEditor* LineEditorObjectDesc = getChild<LLLineEditor>("Object Description");

    if (is_one_object)
    {
        if (!LineEditorObjectName->hasFocus())
        {
            getChild<LLUICtrl>("Object Name")->setValue(nodep->mName);
        }

        if (LineEditorObjectDesc)
        {
            if (!LineEditorObjectDesc->hasFocus())
            {
                LineEditorObjectDesc->setText(nodep->mDescription);
            }
        }
    }
    else
    {
        getChild<LLUICtrl>("Object Name")->setValue(LLStringUtil::null);
        LineEditorObjectDesc->setText(LLStringUtil::null);
    }

    // figure out the contents of the name, description, & category
    bool edit_name_desc = false;
    if (is_one_object && objectp->permModify() && !objectp->isPermanentEnforced())
    {
        edit_name_desc = true;
    }
    if (edit_name_desc)
    {
        getChildView("Object Name")->setEnabled(true);
        getChildView("Object Description")->setEnabled(true);
    }
    else
    {
        getChildView("Object Name")->setEnabled(false);
        getChildView("Object Description")->setEnabled(false);
    }

    S32 total_sale_price = 0;
    S32 individual_sale_price = 0;
    bool is_for_sale_mixed = false;
    bool is_sale_price_mixed = false;
    U32 num_for_sale = false;
    LLSelectMgr::getInstance()->selectGetAggregateSaleInfo(num_for_sale,
                                                           is_for_sale_mixed,
                                                           is_sale_price_mixed,
                                                           total_sale_price,
                                                           individual_sale_price);

    const bool self_owned = (gAgent.getID() == mOwnerID);
    const bool group_owned = LLSelectMgr::getInstance()->selectIsGroupOwned() ;
    const bool public_owned = (mOwnerID.isNull() && !LLSelectMgr::getInstance()->selectIsGroupOwned());
    const bool can_transfer = LLSelectMgr::getInstance()->selectGetRootsTransfer();
    const bool can_copy = LLSelectMgr::getInstance()->selectGetRootsCopy();

    if (!owners_identical)
    {
        getChildView("Cost")->setEnabled(false);
        getChild<LLUICtrl>("Edit Cost")->setValue(LLStringUtil::null);
        getChildView("Edit Cost")->setEnabled(false);
    }
    // You own these objects.
    else if (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id,GP_OBJECT_SET_SALE)))
    {
        LLSpinCtrl *edit_price = getChild<LLSpinCtrl>("Edit Cost");

        // If there are multiple items for sale then set text to PRICE PER UNIT.
        if (num_for_sale > 1)
        {
            std::string label_text = is_sale_price_mixed? "Cost Mixed" :"Cost Per Unit";
            edit_price->setLabel(getString(label_text));
        }
        else
        {
            edit_price->setLabel(getString("Cost Default"));
        }

        if (!edit_price->hasFocus())
        {
            // If the sale price is mixed then set the cost to MIXED, otherwise
            // set to the actual cost.
            if ((num_for_sale > 0) && is_for_sale_mixed)
            {
                edit_price->setTentative(true);
            }
            else if ((num_for_sale > 0) && is_sale_price_mixed)
            {
                edit_price->setTentative(true);
            }
            else
            {
                edit_price->setValue(individual_sale_price);
            }
        }
        // The edit fields are only enabled if you can sell this object
        // and the sale price is not mixed.
        bool enable_edit = (num_for_sale && can_transfer) ? !is_for_sale_mixed : false;
        getChildView("Cost")->setEnabled(enable_edit);
        getChildView("Edit Cost")->setEnabled(enable_edit);
    }
    // Someone, not you, owns these objects.
    else if (!public_owned)
    {
        getChildView("Cost")->setEnabled(false);
        getChildView("Edit Cost")->setEnabled(false);

        // Don't show a price if none of the items are for sale.
        if (num_for_sale)
            getChild<LLUICtrl>("Edit Cost")->setValue(llformat("%d",total_sale_price));
        else
            getChild<LLUICtrl>("Edit Cost")->setValue(LLStringUtil::null);

        // If multiple items are for sale, set text to TOTAL PRICE.
        if (num_for_sale > 1)
            getChild<LLSpinCtrl>("Edit Cost")->setLabel(getString("Cost Total"));
        else
            getChild<LLSpinCtrl>("Edit Cost")->setLabel(getString("Cost Default"));
    }
    // This is a public object.
    else
    {
        getChildView("Cost")->setEnabled(false);
        getChild<LLSpinCtrl>("Edit Cost")->setLabel(getString("Cost Default"));
        getChild<LLUICtrl>("Edit Cost")->setValue(LLStringUtil::null);
        getChildView("Edit Cost")->setEnabled(false);
    }

    // Enable and disable the permissions checkboxes
    // based on who owns the object.
    // TODO: Creator permissions

    U32 base_mask_on            = 0;
    U32 base_mask_off           = 0;
    U32 owner_mask_off          = 0;
    U32 owner_mask_on           = 0;
    U32 group_mask_on           = 0;
    U32 group_mask_off          = 0;
    U32 everyone_mask_on        = 0;
    U32 everyone_mask_off       = 0;
    U32 next_owner_mask_on      = 0;
    U32 next_owner_mask_off     = 0;

    bool valid_base_perms       = LLSelectMgr::getInstance()->selectGetPerm(PERM_BASE,
                                                                            &base_mask_on,
                                                                            &base_mask_off);
    //bool valid_owner_perms =//
    LLSelectMgr::getInstance()->selectGetPerm(PERM_OWNER,
                                              &owner_mask_on,
                                              &owner_mask_off);
    bool valid_group_perms      = LLSelectMgr::getInstance()->selectGetPerm(PERM_GROUP,
                                                                            &group_mask_on,
                                                                            &group_mask_off);

    bool valid_everyone_perms   = LLSelectMgr::getInstance()->selectGetPerm(PERM_EVERYONE,
                                                                            &everyone_mask_on,
                                                                            &everyone_mask_off);

    bool valid_next_perms       = LLSelectMgr::getInstance()->selectGetPerm(PERM_NEXT_OWNER,
                                                                            &next_owner_mask_on,
                                                                            &next_owner_mask_off);


    if (gSavedSettings.getBOOL("DebugPermissions") )
    {
        if (valid_base_perms)
        {
            mDAB->setValue("B: " + mask_to_string(base_mask_on));
            mDAB->setVisible(                           true);

            mDAO->setValue("O: " + mask_to_string(owner_mask_on));
            mDAO->setVisible(                           true);

            mDAG->setValue("G: " + mask_to_string(group_mask_on));
            mDAG->setVisible(                           true);

            mDAE->setValue("E: " + mask_to_string(everyone_mask_on));
            mDAE->setVisible(                           true);

            mDAN->setValue("N: " + mask_to_string(next_owner_mask_on));
            mDAN->setVisible(                           true);
        }

        U32 flag_mask = 0x0;
        if (objectp->permMove())        flag_mask |= PERM_MOVE;
        if (objectp->permModify())      flag_mask |= PERM_MODIFY;
        if (objectp->permCopy())        flag_mask |= PERM_COPY;
        if (objectp->permTransfer())    flag_mask |= PERM_TRANSFER;

        mDAF->setValue("F:" + mask_to_string(flag_mask));
        mDAF->setVisible(true);

        if (!mVisibleDebugPermissions)
        {
            LLFloater* parent_floater = gFloaterView->getParentFloater(this);
            LLRect parent_rect = parent_floater->getRect();
            LLRect debug_rect = mDAB->getRect();
            // use double the debug rect for padding (since it isn't trivial to extract top_pad)
            parent_floater->reshape(parent_rect.getWidth(), parent_rect.getHeight() + (debug_rect.getHeight() * 2));
            mVisibleDebugPermissions = true;
        }
    }
    else if (mVisibleDebugPermissions)
    {
        mDAB->setVisible(false);
        mDAO->setVisible(false);
        mDAG->setVisible(false);
        mDAE->setVisible(false);
        mDAN->setVisible(false);
        mDAF->setVisible(false);

        LLFloater* parent_floater = gFloaterView->getParentFloater(this);
        LLRect parent_rect = parent_floater->getRect();
        LLRect debug_rect = mDAB->getRect();
        // use double the debug rect for padding (since it isn't trivial to extract top_pad)
        parent_floater->reshape(parent_rect.getWidth(), parent_rect.getHeight() - (debug_rect.getHeight() * 2));
        mVisibleDebugPermissions = false;
    }

    bool has_change_perm_ability = false;
    bool has_change_sale_ability = false;

    if (valid_base_perms && is_nonpermanent_enforced &&
        (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_MANIPULATE))))
    {
        has_change_perm_ability = true;
    }
    if (valid_base_perms && is_nonpermanent_enforced &&
       (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_SET_SALE))))
    {
        has_change_sale_ability = true;
    }

    if (!has_change_perm_ability && !has_change_sale_ability && !root_selected)
    {
        // ...must select root to choose permissions
        getChild<LLUICtrl>("perm_modify")->setValue(getString("text modify warning"));
    }

    if (has_change_perm_ability)
    {
        getChildView("checkbox share with group")->setEnabled(true);
        getChildView("checkbox allow everyone move")->setEnabled(owner_mask_on & PERM_MOVE);
        getChildView("checkbox allow everyone copy")->setEnabled(owner_mask_on & PERM_COPY && owner_mask_on & PERM_TRANSFER);
    }
    else
    {
        getChildView("checkbox share with group")->setEnabled(false);
        getChildView("checkbox allow everyone move")->setEnabled(false);
        getChildView("checkbox allow everyone copy")->setEnabled(false);
    }

    if (has_change_sale_ability && (owner_mask_on & PERM_TRANSFER))
    {
        getChildView("checkbox for sale")->setEnabled(can_transfer || (!can_transfer && num_for_sale));
        // Set the checkbox to tentative if the prices of each object selected
        // are not the same.
        getChild<LLUICtrl>("checkbox for sale")->setTentative(              is_for_sale_mixed);
        getChildView("sale type")->setEnabled(num_for_sale && can_transfer && !is_sale_price_mixed);

        getChildView("checkbox next owner can modify")->setEnabled(base_mask_on & PERM_MODIFY);
        getChildView("checkbox next owner can copy")->setEnabled(base_mask_on & PERM_COPY);
        getChildView("checkbox next owner can transfer")->setEnabled(next_owner_mask_on & PERM_COPY);
    }
    else
    {
        getChildView("checkbox for sale")->setEnabled(false);
        getChildView("sale type")->setEnabled(false);

        getChildView("checkbox next owner can modify")->setEnabled(false);
        getChildView("checkbox next owner can copy")->setEnabled(false);
        getChildView("checkbox next owner can transfer")->setEnabled(false);
    }

    if (valid_group_perms)
    {
        if ((group_mask_on & PERM_COPY) && (group_mask_on & PERM_MODIFY) && (group_mask_on & PERM_MOVE))
        {
            getChild<LLUICtrl>("checkbox share with group")->setValue(true);
            getChild<LLUICtrl>("checkbox share with group")->setTentative(  false);
            getChildView("button deed")->setEnabled(gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
        }
        else if ((group_mask_off & PERM_COPY) && (group_mask_off & PERM_MODIFY) && (group_mask_off & PERM_MOVE))
        {
            getChild<LLUICtrl>("checkbox share with group")->setValue(false);
            getChild<LLUICtrl>("checkbox share with group")->setTentative(  false);
            getChildView("button deed")->setEnabled(false);
        }
        else
        {
            getChild<LLUICtrl>("checkbox share with group")->setValue(true);
            getChild<LLUICtrl>("checkbox share with group")->setTentative(  true);
            getChildView("button deed")->setEnabled(gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (group_mask_on & PERM_MOVE) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
        }
    }

    if (valid_everyone_perms)
    {
        // Move
        if (everyone_mask_on & PERM_MOVE)
        {
            getChild<LLUICtrl>("checkbox allow everyone move")->setValue(true);
            getChild<LLUICtrl>("checkbox allow everyone move")->setTentative(   false);
        }
        else if (everyone_mask_off & PERM_MOVE)
        {
            getChild<LLUICtrl>("checkbox allow everyone move")->setValue(false);
            getChild<LLUICtrl>("checkbox allow everyone move")->setTentative(   false);
        }
        else
        {
            getChild<LLUICtrl>("checkbox allow everyone move")->setValue(true);
            getChild<LLUICtrl>("checkbox allow everyone move")->setTentative(   true);
        }

        // Copy == everyone can't copy
        if (everyone_mask_on & PERM_COPY)
        {
            getChild<LLUICtrl>("checkbox allow everyone copy")->setValue(true);
            getChild<LLUICtrl>("checkbox allow everyone copy")->setTentative(   !can_copy || !can_transfer);
        }
        else if (everyone_mask_off & PERM_COPY)
        {
            getChild<LLUICtrl>("checkbox allow everyone copy")->setValue(false);
            getChild<LLUICtrl>("checkbox allow everyone copy")->setTentative(   false);
        }
        else
        {
            getChild<LLUICtrl>("checkbox allow everyone copy")->setValue(true);
            getChild<LLUICtrl>("checkbox allow everyone copy")->setTentative(   true);
        }
    }

    if (valid_next_perms)
    {
        // Modify == next owner canot modify
        if (next_owner_mask_on & PERM_MODIFY)
        {
            getChild<LLUICtrl>("checkbox next owner can modify")->setValue(true);
            getChild<LLUICtrl>("checkbox next owner can modify")->setTentative( false);
        }
        else if (next_owner_mask_off & PERM_MODIFY)
        {
            getChild<LLUICtrl>("checkbox next owner can modify")->setValue(false);
            getChild<LLUICtrl>("checkbox next owner can modify")->setTentative( false);
        }
        else
        {
            getChild<LLUICtrl>("checkbox next owner can modify")->setValue(true);
            getChild<LLUICtrl>("checkbox next owner can modify")->setTentative( true);
        }

        // Copy == next owner cannot copy
        if (next_owner_mask_on & PERM_COPY)
        {
            getChild<LLUICtrl>("checkbox next owner can copy")->setValue(true);
            getChild<LLUICtrl>("checkbox next owner can copy")->setTentative(   !can_copy);
        }
        else if (next_owner_mask_off & PERM_COPY)
        {
            getChild<LLUICtrl>("checkbox next owner can copy")->setValue(false);
            getChild<LLUICtrl>("checkbox next owner can copy")->setTentative(   false);
        }
        else
        {
            getChild<LLUICtrl>("checkbox next owner can copy")->setValue(true);
            getChild<LLUICtrl>("checkbox next owner can copy")->setTentative(   true);
        }

        // Transfer == next owner cannot transfer
        if (next_owner_mask_on & PERM_TRANSFER)
        {
            getChild<LLUICtrl>("checkbox next owner can transfer")->setValue(true);
            getChild<LLUICtrl>("checkbox next owner can transfer")->setTentative( !can_transfer);
        }
        else if (next_owner_mask_off & PERM_TRANSFER)
        {
            getChild<LLUICtrl>("checkbox next owner can transfer")->setValue(false);
            getChild<LLUICtrl>("checkbox next owner can transfer")->setTentative( false);
        }
        else
        {
            getChild<LLUICtrl>("checkbox next owner can transfer")->setValue(true);
            getChild<LLUICtrl>("checkbox next owner can transfer")->setTentative( true);
        }
    }

    // reflect sale information
    LLSaleInfo sale_info;
    bool valid_sale_info = LLSelectMgr::getInstance()->selectGetSaleInfo(sale_info);
    LLSaleInfo::EForSale sale_type = sale_info.getSaleType();

    LLComboBox* combo_sale_type = getChild<LLComboBox>("sale type");
    if (valid_sale_info)
    {
        combo_sale_type->setValue(                  sale_type == LLSaleInfo::FS_NOT ? LLSaleInfo::FS_COPY : sale_type);
        combo_sale_type->setTentative(              false); // unfortunately this doesn't do anything at the moment.
    }
    else
    {
        // default option is sell copy, determined to be safest
        combo_sale_type->setValue(                  LLSaleInfo::FS_COPY);
        combo_sale_type->setTentative(              true); // unfortunately this doesn't do anything at the moment.
    }

    getChild<LLUICtrl>("checkbox for sale")->setValue((num_for_sale != 0));

    // HACK: There are some old objects in world that are set for sale,
    // but are no-transfer.  We need to let users turn for-sale off, but only
    // if for-sale is set.
    bool cannot_actually_sell = !can_transfer || (!can_copy && sale_type == LLSaleInfo::FS_COPY);
    if (cannot_actually_sell)
    {
        if (num_for_sale && has_change_sale_ability)
        {
            getChildView("checkbox for sale")->setEnabled(true);
        }
    }

    // Check search status of objects
    const bool all_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME );
    bool include_in_search;
    const bool all_include_in_search = LLSelectMgr::getInstance()->selectionGetIncludeInSearch(&include_in_search);
    getChildView("search_check")->setEnabled(has_change_sale_ability && all_volume);
    getChild<LLUICtrl>("search_check")->setValue(include_in_search);
    getChild<LLUICtrl>("search_check")->setTentative(!all_include_in_search);

    // Click action (touch, sit, buy)
    U8 click_action = 0;
    if (LLSelectMgr::getInstance()->selectionGetClickAction(&click_action))
    {
        getChild<LLComboBox>("clickaction")->setValue(click_action_to_string_value(click_action));
    }
    getChildView("label click action")->setEnabled(is_perm_modify && is_nonpermanent_enforced && all_volume);
    getChildView("clickaction")->setEnabled(is_perm_modify && is_nonpermanent_enforced && all_volume);

    updateVerbs();
}


// static
void LLSidepanelTaskInfo::onClickClaim(void*)
{
    // try to claim ownership
    LLSelectMgr::getInstance()->sendOwner(gAgent.getID(), gAgent.getGroupID());
}

// static
void LLSidepanelTaskInfo::onClickRelease(void*)
{
    // try to release ownership
    LLSelectMgr::getInstance()->sendOwner(LLUUID::null, LLUUID::null);
}

void LLSidepanelTaskInfo::onClickGroup()
{
    LLUUID owner_id;
    std::string name;
    bool owners_identical = LLSelectMgr::getInstance()->selectGetOwner(owner_id, name);
    LLFloater* parent_floater = gFloaterView->getParentFloater(this);

    if (owners_identical && (owner_id == gAgent.getID()))
    {
        LLFloaterGroupPicker* fg = LLFloaterReg::showTypedInstance<LLFloaterGroupPicker>("group_picker", LLSD(gAgent.getID()));
        if (fg)
        {
            fg->setSelectGroupCallback( boost::bind(&LLSidepanelTaskInfo::cbGroupID, this, _1) );
            if (parent_floater)
            {
                LLRect new_rect = gFloaterView->findNeighboringPosition(parent_floater, fg);
                fg->setOrigin(new_rect.mLeft, new_rect.mBottom);
                parent_floater->addDependentFloater(fg);
            }
        }
    }
}

void LLSidepanelTaskInfo::cbGroupID(LLUUID group_id)
{
    if (mLabelGroupName)
    {
        mLabelGroupName->setNameID(group_id, true);
    }
    LLSelectMgr::getInstance()->sendGroup(group_id);
}

static bool callback_deed_to_group(const LLSD& notification, const LLSD& response)
{
    const S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    if (option == 0)
    {
        LLUUID group_id;
        const bool groups_identical = LLSelectMgr::getInstance()->selectGetGroup(group_id);
        if (group_id.notNull() && groups_identical && (gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED)))
        {
            LLSelectMgr::getInstance()->sendOwner(LLUUID::null, group_id, false);
        }
    }
    return false;
}

void LLSidepanelTaskInfo::onClickDeedToGroup(void *data)
{
    LLNotificationsUtil::add("DeedObjectToGroup", LLSD(), LLSD(), callback_deed_to_group);
}

///----------------------------------------------------------------------------
/// Permissions checkboxes
///----------------------------------------------------------------------------

// static
void LLSidepanelTaskInfo::onCommitPerm(LLUICtrl *ctrl, void *data, U8 field, U32 perm)
{
    LLViewerObject* object = LLSelectMgr::getInstance()->getSelection()->getFirstRootObject();
    if(!object) return;

    // Checkbox will have toggled itself
    // LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
    LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
    bool new_state = check->get();

    LLSelectMgr::getInstance()->selectionSetObjectPermissions(field, new_state, perm);

    LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
    if (self)
    {
        self->disablePermissions();
    }
}

// static
void LLSidepanelTaskInfo::onCommitGroupShare(LLUICtrl *ctrl, void *data)
{
    onCommitPerm(ctrl, data, PERM_GROUP, PERM_MODIFY | PERM_MOVE | PERM_COPY);
}

// static
void LLSidepanelTaskInfo::onCommitEveryoneMove(LLUICtrl *ctrl, void *data)
{
    onCommitPerm(ctrl, data, PERM_EVERYONE, PERM_MOVE);
}


// static
void LLSidepanelTaskInfo::onCommitEveryoneCopy(LLUICtrl *ctrl, void *data)
{
    onCommitPerm(ctrl, data, PERM_EVERYONE, PERM_COPY);
}

// static
void LLSidepanelTaskInfo::onCommitNextOwnerModify(LLUICtrl* ctrl, void* data)
{
    //LL_INFOS() << "LLSidepanelTaskInfo::onCommitNextOwnerModify" << LL_ENDL;
    onCommitPerm(ctrl, data, PERM_NEXT_OWNER, PERM_MODIFY);
}

// static
void LLSidepanelTaskInfo::onCommitNextOwnerCopy(LLUICtrl* ctrl, void* data)
{
    //LL_INFOS() << "LLSidepanelTaskInfo::onCommitNextOwnerCopy" << LL_ENDL;
    onCommitPerm(ctrl, data, PERM_NEXT_OWNER, PERM_COPY);
}

// static
void LLSidepanelTaskInfo::onCommitNextOwnerTransfer(LLUICtrl* ctrl, void* data)
{
    //LL_INFOS() << "LLSidepanelTaskInfo::onCommitNextOwnerTransfer" << LL_ENDL;
    onCommitPerm(ctrl, data, PERM_NEXT_OWNER, PERM_TRANSFER);
}

// static
void LLSidepanelTaskInfo::onCommitName(LLUICtrl*, void* data)
{
    //LL_INFOS() << "LLSidepanelTaskInfo::onCommitName()" << LL_ENDL;
    LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
    LLLineEditor*   tb = self->getChild<LLLineEditor>("Object Name");
    if(tb)
    {
        LLSelectMgr::getInstance()->selectionSetObjectName(tb->getText());
//      LLSelectMgr::getInstance()->selectionSetObjectName(self->mLabelObjectName->getText());
    }
}


// static
void LLSidepanelTaskInfo::onCommitDesc(LLUICtrl*, void* data)
{
    //LL_INFOS() << "LLSidepanelTaskInfo::onCommitDesc()" << LL_ENDL;
    LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
    LLLineEditor*   le = self->getChild<LLLineEditor>("Object Description");
    if(le)
    {
        LLSelectMgr::getInstance()->selectionSetObjectDescription(le->getText());
    }
}

// static
void LLSidepanelTaskInfo::onCommitSaleInfo(LLUICtrl*, void* data)
{
    LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
    self->setAllSaleInfo();
}

// static
void LLSidepanelTaskInfo::onCommitSaleType(LLUICtrl*, void* data)
{
    LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
    self->setAllSaleInfo();
}


void LLSidepanelTaskInfo::setAllSaleInfo()
{
    LLSaleInfo::EForSale sale_type = LLSaleInfo::FS_NOT;

    LLCheckBoxCtrl *checkPurchase = getChild<LLCheckBoxCtrl>("checkbox for sale");

    // Set the sale type if the object(s) are for sale.
    if(checkPurchase && checkPurchase->get())
    {
        sale_type = static_cast<LLSaleInfo::EForSale>(getChild<LLComboBox>("sale type")->getValue().asInteger());
    }

    S32 price = -1;

    LLSpinCtrl *edit_price = getChild<LLSpinCtrl>("Edit Cost");
    price = (edit_price->getTentative()) ? DEFAULT_PRICE : edit_price->getValue().asInteger();

    // If somehow an invalid price, turn the sale off.
    if (price < 0)
        sale_type = LLSaleInfo::FS_NOT;

    LLSaleInfo old_sale_info;
    LLSelectMgr::getInstance()->selectGetSaleInfo(old_sale_info);

    LLSaleInfo new_sale_info(sale_type, price);
    LLSelectMgr::getInstance()->selectionSetObjectSaleInfo(new_sale_info);

    U8 old_click_action = 0;
    LLSelectMgr::getInstance()->selectionGetClickAction(&old_click_action);

    if (old_sale_info.isForSale()
        && !new_sale_info.isForSale()
        && old_click_action == CLICK_ACTION_BUY)
    {
        // If turned off for-sale, make sure click-action buy is turned
        // off as well
        LLSelectMgr::getInstance()->
            selectionSetClickAction(CLICK_ACTION_TOUCH);
    }
    else if (new_sale_info.isForSale()
        && !old_sale_info.isForSale()
        && old_click_action == CLICK_ACTION_TOUCH)
    {
        // If just turning on for-sale, preemptively turn on one-click buy
        // unless user have a different click action set
        LLSelectMgr::getInstance()->
            selectionSetClickAction(CLICK_ACTION_BUY);
    }
}

struct LLSelectionPayable : public LLSelectedObjectFunctor
{
    virtual bool apply(LLViewerObject* obj)
    {
        // can pay if you or your parent has money() event in script
        LLViewerObject* parent = (LLViewerObject*)obj->getParent();
        return (obj->flagTakesMoney() ||
                (parent && parent->flagTakesMoney()));
    }
};

static U8 string_value_to_click_action(std::string p_value)
{
    if (p_value == "Touch")
        return CLICK_ACTION_TOUCH;
    if (p_value == "Sit")
        return CLICK_ACTION_SIT;
    if (p_value == "Buy")
        return CLICK_ACTION_BUY;
    if (p_value == "Pay")
        return CLICK_ACTION_PAY;
    if (p_value == "Open")
        return CLICK_ACTION_OPEN;
    if (p_value == "Zoom")
        return CLICK_ACTION_ZOOM;
    if (p_value == "None")
        return CLICK_ACTION_DISABLED;
    if (p_value == "Ignore")
        return CLICK_ACTION_IGNORE;
    return CLICK_ACTION_TOUCH;
}

// static
void LLSidepanelTaskInfo::onCommitClickAction(LLUICtrl* ctrl, void*)
{
    LLComboBox* box = (LLComboBox*)ctrl;
    if (!box)
        return;
    std::string value = box->getValue().asString();
    U8 click_action = string_value_to_click_action(value);
    doClickAction(click_action);
}

// static
void LLSidepanelTaskInfo::doClickAction(U8 click_action)
{
    if (click_action == CLICK_ACTION_BUY)
    {
        LLSaleInfo sale_info;
        LLSelectMgr::getInstance()->selectGetSaleInfo(sale_info);
        if (!sale_info.isForSale())
        {
            LLNotificationsUtil::add("CantSetBuyObject");

            // Set click action back to its old value
            U8 click_action = 0;
            LLSelectMgr::getInstance()->selectionGetClickAction(&click_action);
            return;
        }
    }
    else if (click_action == CLICK_ACTION_PAY)
    {
        // Verify object has script with money() handler
        LLSelectionPayable payable;
        bool can_pay = LLSelectMgr::getInstance()->getSelection()->applyToObjects(&payable);
        if (!can_pay)
        {
            // Warn, but do it anyway.
            LLNotificationsUtil::add("ClickActionNotPayable");
        }
        else
        {
            handle_give_money_dialog();
        }
    }
    LLSelectMgr::getInstance()->selectionSetClickAction(click_action);
}

// static
void LLSidepanelTaskInfo::onCommitIncludeInSearch(LLUICtrl* ctrl, void* data)
{
    LLCheckBoxCtrl* box = (LLCheckBoxCtrl*)ctrl;
    llassert(box);
    LLSelectMgr::getInstance()->selectionSetIncludeInSearch(box->get());
}

// virtual
void LLSidepanelTaskInfo::updateVerbs()
{
    LLSafeHandle<LLObjectSelection> object_selection = LLSelectMgr::getInstance()->getSelection();
    const bool any_selected = (object_selection->getNumNodes() > 0);

    mOpenBtn->setVisible(true);
    mPayBtn->setVisible(true);
    mBuyBtn->setVisible(true);
    mDetailsBtn->setVisible(true);

    mOpenBtn->setEnabled(enable_object_open());
    mPayBtn->setEnabled(enable_pay_object());
    mBuyBtn->setEnabled(enable_buy_object());
    mDetailsBtn->setEnabled(any_selected);
}

void LLSidepanelTaskInfo::onOpenButtonClicked()
{
    if (enable_object_open())
    {
        handle_object_open();
    }
}

void LLSidepanelTaskInfo::onPayButtonClicked()
{
    doClickAction(CLICK_ACTION_PAY);
}

void LLSidepanelTaskInfo::onBuyButtonClicked()
{
    doClickAction(CLICK_ACTION_BUY);
}

void LLSidepanelTaskInfo::onDetailsButtonClicked()
{
    LLFloaterReg::showInstance("inspect", LLSD());
}

// virtual
void LLSidepanelTaskInfo::save()
{
    onCommitGroupShare(getChild<LLCheckBoxCtrl>("checkbox share with group"), this);
    onCommitEveryoneMove(getChild<LLCheckBoxCtrl>("checkbox allow everyone move"), this);
    onCommitEveryoneCopy(getChild<LLCheckBoxCtrl>("checkbox allow everyone copy"), this);
    onCommitNextOwnerModify(getChild<LLCheckBoxCtrl>("checkbox next owner can modify"), this);
    onCommitNextOwnerCopy(getChild<LLCheckBoxCtrl>("checkbox next owner can copy"), this);
    onCommitNextOwnerTransfer(getChild<LLCheckBoxCtrl>("checkbox next owner can transfer"), this);
    onCommitName(getChild<LLLineEditor>("Object Name"), this);
    onCommitDesc(getChild<LLLineEditor>("Object Description"), this);
    onCommitSaleInfo(NULL, this);
    onCommitSaleType(NULL, this);
    onCommitIncludeInSearch(getChild<LLCheckBoxCtrl>("search_check"), this);
}

// removes keyboard focus so that all fields can be updated
// and then restored focus
void LLSidepanelTaskInfo::refreshAll()
{
    // update UI as soon as we have an object
    // but remove keyboard focus first so fields are free to update
    LLFocusableElement* focus = NULL;
    if (hasFocus())
    {
        focus = gFocusMgr.getKeyboardFocus();
        setFocus(false);
    }
    refresh();
    if (focus)
    {
        focus->setFocus(true);
    }
}


void LLSidepanelTaskInfo::setObjectSelection(LLObjectSelectionHandle selection)
{
    mObjectSelection = selection;
    refreshAll();
}

LLSidepanelTaskInfo* LLSidepanelTaskInfo::getActivePanel()
{
    return sActivePanel;
}

void LLSidepanelTaskInfo::dirty()
{
    mIsDirty = true;
}

// static
void LLSidepanelTaskInfo::onIdle( void* user_data )
{
    LLSidepanelTaskInfo* self = reinterpret_cast<LLSidepanelTaskInfo*>(user_data);

    if( self->mIsDirty )
    {
        self->refresh();
        self->mIsDirty = false;
    }
}

LLViewerObject* LLSidepanelTaskInfo::getObject()
{
    if (!mObject->isDead())
        return mObject;
    return NULL;
}

LLViewerObject* LLSidepanelTaskInfo::getFirstSelectedObject()
{
    LLSelectNode *node = mObjectSelection->getFirstRootNode();
    if (node)
    {
        return node->getObject();
    }
    return NULL;
}

const LLUUID& LLSidepanelTaskInfo::getSelectedUUID()
{
    const LLViewerObject* obj = getFirstSelectedObject();
    if (obj)
    {
        return obj->getID();
    }
    return LLUUID::null;
}