//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1992 - 1999
//
//  File:      menubtns.cpp
//
//  Contents:  Menu Buttons implementation
//
//  History:   08-27-99 AnandhaG    Created
//
//--------------------------------------------------------------------------


#include "stdafx.h"
#include "AMC.h"
#include "ChildFrm.h"
#include "menubtns.h"
#include "AMCView.h"
#include "mainfrm.h"
#include "menubar.h"
#include "util.h"         // GetTBBtnTextAndStatus()


CMenuButtonsMgrImpl::CMenuButtonsMgrImpl()
 : m_pChildFrame(NULL), m_pMainFrame(NULL),
   m_pMenuBar(NULL)
{
    m_MenuButtons.clear();
    m_AttachedMenuButtons.clear();
}

CMenuButtonsMgrImpl::~CMenuButtonsMgrImpl()
{
    m_MenuButtons.clear();
    m_AttachedMenuButtons.clear();
}

//+-------------------------------------------------------------------
//
//  Member:      ScInit
//
//  Synopsis:    Init the Menubuttons mgr.
//
//  Arguments:   [pMainFrame]     - Ptr to Main Frame window.
//               [pChildFrameWnd] - Ptr to child frame window.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScInit (CMainFrame* pMainFrame, CChildFrame* pChildFrameWnd)
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScInit"));

    if ( (NULL == pChildFrameWnd) ||
         (NULL == pMainFrame))
        return (sc = E_INVALIDARG);

    m_pChildFrame = pChildFrameWnd;
    m_pMainFrame  = pMainFrame;

    return sc;
}

//+-------------------------------------------------------------------
//
//  Member:     ScAddMenuButton
//
//  Synopsis:   Adds a menu button to the data structure
//              and calls ScAddMenuButtonToMenu.
//
//  Arguments:
//              [pMenuBtnNotifyClbk] - Notify callback for button click.
//              [idCommand]          - Button command id.
//              [lpButtonText]       - Button text.
//              [lpStatusText]       - Button status text.
//
//  Returns:    SC
//
//  Note : The status text is not used.
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScAddMenuButton(
                             CMenuButtonNotify* pMenuBtnNotifyClbk,
                             INT idCommand,
                             LPCOLESTR lpButtonText,
                             LPCOLESTR lpStatusText)
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScAddMenuButton"));

    // Validate the data
    if ( (NULL == pMenuBtnNotifyClbk) ||
         (NULL == lpButtonText) ||
         (NULL == lpStatusText) )
        return (sc = E_INVALIDARG);

    // Add the data to our data structure
    MMC_MenuButtonCollection::iterator it;
    it = GetMMCMenuButton( pMenuBtnNotifyClbk, idCommand);
    if (it != m_MenuButtons.end())
    {
        // Duplicate Menu button found.
        // The pMenuButtonNofifyClbk represents IMenuButton
        // given to the snapin and we found another button
        // with idCommand already added by this snapin.

        // For compatibility reasons (disk mgmt) this is not an error.
        return (sc = S_OK);
    }

    MMC_MENUBUTTON mmb;
    mmb.pMenuButtonNotifyClbk = pMenuBtnNotifyClbk;
    mmb.idCommand = idCommand;

    USES_CONVERSION;
    mmb.lpButtonText = OLE2CT(lpButtonText);
    mmb.lpStatusText = OLE2CT(lpStatusText);

    // Add the MMC_MENUBUTTON to the our array.
    m_MenuButtons.push_back(mmb);

    // Add the menubuttons to main menu
    sc = ScAddMenuButtonsToMainMenu();
    if (sc)
        return sc;

    return (sc);
}


//+-------------------------------------------------------------------
//
//  Member:     ScModifyMenuButton
//
//  Synopsis:   Modify button text or status text for menu button
//
//  Arguments:
//              [pMenuBtnNotifyClbk] - Notify callback for button click.
//              [idCommand]          - Button command id.
//              [lpButtonText]       - Button text.
//              [lpStatusText]       - Button status text.
//
//  Returns:    SC
//
//  Note : The status text is not used.
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScModifyMenuButton(
                             CMenuButtonNotify* pMenuBtnNotifyClbk,
                             INT idCommand,
                             LPCOLESTR lpButtonText,
                             LPCOLESTR lpStatusText)
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScModifyMenuButton"));

    // Validate the data
    if ( (NULL == pMenuBtnNotifyClbk) ||
         (NULL == lpButtonText) ||
         (NULL == lpStatusText) )
        return (sc = E_INVALIDARG);

    if ( (NULL == m_pChildFrame) ||
         (false == m_pChildFrame->IsChildFrameActive()) )
        return (sc = E_UNEXPECTED);

    // Iterate thro the vector and find the MMC_MENUBUTTON for
    // given CMenuButtonNotify* and Command id of button.
    MMC_MenuButtonCollection::iterator it;
    it = GetMMCMenuButton( pMenuBtnNotifyClbk, idCommand);
    if (it == m_MenuButtons.end())
    {
        // Menu button not found.
        // The pMenuButtonNofifyClbk represents IMenuButton
        // given to the snapin and we could not find a menu button
        // with idCommand already added by this snapin.
        return (sc = E_INVALIDARG);
    }

    it->pMenuButtonNotifyClbk = pMenuBtnNotifyClbk;
    it->idCommand = idCommand;

    USES_CONVERSION;
    it->lpButtonText = OLE2CT(lpButtonText);
    it->lpStatusText = OLE2CT(lpStatusText);

    if (NULL == m_pMenuBar)
        return (sc = E_UNEXPECTED);

    // Change the name of the menu item.
    if (-1 != it->nCommandIDFromMenuBar)
    {
        sc = (m_pMenuBar->SetMenuButton(it->nCommandIDFromMenuBar, it->lpButtonText.data()) == -1)
                        ? E_FAIL : S_OK;
        if (sc)
            return sc;
    }

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:     ScModifyMenuButtonState
//
//  Synopsis:   Modify menu button state.
//
//  Arguments:
//              [pMenuBtnNotifyClbk] - Notify callback for button click.
//              [idCommand]          - Button command id.
//              [nState]             - The state to be modified.
//              [bState]             - Set or Reset the state.
//
//  Returns:    SC
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScModifyMenuButtonState(
                             CMenuButtonNotify* pMenuBtnNotifyClbk,
                             INT idCommand,
                             MMC_BUTTON_STATE nState,
                             BOOL bState)
{
    AFX_MANAGE_STATE (AfxGetAppModuleState());
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScModifyMenuButtonState"));

    // Validate the data
    if (NULL == pMenuBtnNotifyClbk)
        return (sc = E_INVALIDARG);

    if (NULL == m_pChildFrame)
        return (sc = E_UNEXPECTED);

    // If childframe is not active, menus for this viewdoes not exist.
    if (false == m_pChildFrame->IsChildFrameActive())
    {
        switch (nState)
        {
        case ENABLED:
            // Enabling is illegal disabling is Ok (do nothing).
            sc = bState ? E_FAIL : S_OK;
            break;

        case HIDDEN:
            // Hiding is Ok(do nothing), Un-hiding is illegal.
            sc = bState ? S_OK : E_FAIL;
            break;

        case BUTTONPRESSED:
            sc = E_FAIL; // Always fail.
            break;

        default:
            ASSERT(FALSE);
            sc = E_FAIL;
            break;
        }

        return sc;
    }

    // Iterate thro the vector and find the MMC_MENUBUTTON for
    // given CMenuButtonNotify* and Command id of button.
    MMC_MenuButtonCollection::iterator it;
    it = GetMMCMenuButton( pMenuBtnNotifyClbk, idCommand);
    if (it == m_MenuButtons.end())
    {
        // Menu button not found.
        // The pMenuButtonNofifyClbk represents IMenuButton
        // given to the snapin and we could not find a menu button
        // with idCommand already added by this snapin.
        return (sc = E_INVALIDARG);
    }


    // Note the hidden state specified by the snapin.
    if (HIDDEN == nState)
    {
        bool bShow = (FALSE == bState);

        it->SetShowMenu(bShow);

        // If a menu button is to be un-hidden make sure that snapin buttons
        // are allowed in this view. Ask view-data for this information.
        if (bShow)
        {
            CAMCView* pAMCView = m_pChildFrame->GetAMCView();
            if (NULL == pAMCView)
                return (sc = E_UNEXPECTED);

            SViewData* pViewData = pAMCView->GetViewData();
            if (NULL == pViewData)
                return (sc = E_UNEXPECTED);

            // We have noted the hidden state of the button.
            // Return S_OK if menubuttons are disabled for this view.
            // Later when the menus are turned on the hidden state will
            // be properly restored.
            if (! pViewData->IsSnapinMenusAllowed())
                return (sc = S_OK);
        }
    }

    if (NULL == m_pMenuBar)
        return (sc = E_UNEXPECTED);

    BOOL bRet = FALSE;

    switch (nState)
    {
    case ENABLED:
        bRet = m_pMenuBar->EnableButton(it->nCommandIDFromMenuBar , bState);
        break;

    case HIDDEN:
        bRet = m_pMenuBar->HideButton(it->nCommandIDFromMenuBar , bState);
        break;

    case BUTTONPRESSED:
        bRet = m_pMenuBar->PressButton(it->nCommandIDFromMenuBar, bState);
        break;

    default:
        ASSERT(FALSE);
        bRet = FALSE;
        break;
    }

    sc = bRet ? S_OK : E_FAIL;
    return sc;
}


//+-------------------------------------------------------------------
//
//  Member:     ScAddMenuButtonsToMainMenu
//
//  Synopsis:   Add the menu buttons that are not yet added to
//              the main menu.
//
//  Arguments:  None
//
//  Returns:    SC
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScAddMenuButtonsToMainMenu ()
{
    AFX_MANAGE_STATE (AfxGetAppModuleState());
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScAddMenuButtonsToMainMenu"));

    // To add a menu button the following conditions must be true.

    // 1. The child frame window must be active.
    if ( (NULL == m_pChildFrame) ||
         (false == m_pChildFrame->IsChildFrameActive()) )
        return (sc = E_UNEXPECTED);

    CAMCView* pAMCView = m_pChildFrame->GetAMCView();
    if (NULL == pAMCView)
        return (sc = E_UNEXPECTED);

    SViewData* pViewData = pAMCView->GetViewData();
    if (NULL == pViewData)
        return (sc = E_UNEXPECTED);

    if (NULL == m_pMainFrame)
        return (sc = E_UNEXPECTED);

    m_pMenuBar = m_pMainFrame->GetMenuBar();
    if (NULL == m_pMenuBar)
        return (sc = E_FAIL);

    MMC_MenuButtonCollection::iterator it;
    for (it = m_MenuButtons.begin(); it != m_MenuButtons.end(); ++it)
    {
        // 2. The menu button is attached (IControlbar::Attach was called).
        if (IsAttached(it->pMenuButtonNotifyClbk) == false)
            continue;

        // 3. The button is not already added.
        if (FALSE == m_pMenuBar->IsButtonHidden(it->nCommandIDFromMenuBar))
            continue;

        BOOL bHidden = FALSE;

        if (false == pViewData->IsSnapinMenusAllowed())
            bHidden = TRUE;

        it->nCommandIDFromMenuBar =
            m_pMenuBar->InsertMenuButton((LPCTSTR)it->lpButtonText.data(),
                                                                                 bHidden || !(it->CanShowMenu()) );

        // In user mode there are no menus so this assert is not valid.
        // ASSERT(-1 != it->nCommandIDFromMenuBar);
    }

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:     ScNotifyMenuClick
//
//  Synopsis:   A menu button is clicked. Notify appropriate owner
//              to display a menu.
//
//  Arguments:
//              [nCommandID] - Command ID
//              [pt]        - display co-ordinates for popup menu.
//
//  Returns:    SC
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScNotifyMenuClick(const INT nCommandID, const POINT& pt)
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScNotifyMenuClick"));
    CAMCView* pAMCView = NULL;

    MMC_MenuButtonCollection::iterator it;

    // Get the MenuButton data.
    it = GetMMCMenuButton( nCommandID );
    if (it == m_MenuButtons.end())
        return (sc = E_FAIL);

    pAMCView = m_pChildFrame->GetAMCView();
    if (NULL == pAMCView)
        return (sc = E_FAIL);

    // This is snapin owned menu, so get the
    // selected HNODE, lParam (if result item)
    // MENUBUTTONDATA.
    HNODE hNode;
    bool  bScope;
    LPARAM lParam;
    MENUBUTTONDATA menuButtonData;

    // Get the details about the selected item.
    sc = pAMCView->ScGetFocusedItem (hNode, lParam, bScope);
    if (sc)
        return sc;

    menuButtonData.idCommand = it->idCommand;
    menuButtonData.x = pt.x;
    menuButtonData.y = pt.y;

    // Notify snapin about the click
    if (NULL == it->pMenuButtonNotifyClbk)
        return (sc = E_UNEXPECTED);

    sc = it->pMenuButtonNotifyClbk->ScNotifyMenuBtnClick(hNode, bScope, lParam, menuButtonData);
    if (sc)
        return sc;

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:     ScAttachMenuButton
//
//  Synopsis:   Attach the menu buttons object (this object corresponds
//                 to the IMenuButton object exposed to the snapin).
//
//  Arguments:
//              [pMenuBtnNotifyClbk] - Notify callback for menu button click.
//
//  Returns:    SC
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScAttachMenuButton (CMenuButtonNotify* pMenuBtnNotifyClbk)
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScAttachMenuButton"));

    MMC_AttachedMenuButtons::iterator it = m_AttachedMenuButtons.find(pMenuBtnNotifyClbk);
    if (m_AttachedMenuButtons.end() != it)
    {
        // Already attached, nothing wrong calling twice, return S_FALSE.
        return (sc = S_FALSE);
    }

    // Add the button to the set.
    std::pair<MMC_AttachedMenuButtons::iterator, bool> rc =
                       m_AttachedMenuButtons.insert(pMenuBtnNotifyClbk);
    if (false == rc.second)
        return (sc = E_FAIL);

    // The menu buttons may already be added  (without calling
    // IControlbar::Attach)
    // So give a chance for those buttons that are already added
    // but just now attached to get themself added to the main menu.
    sc = ScAddMenuButtonsToMainMenu ();
    if (sc)
        return sc;

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:     ScDetachMenuButton
//
//  Synopsis:   Detach the menu buttons object (this object corresponds
//                 to the IMenuButton object exposed to the snapin).
//
//  Arguments:
//              [pMenuBtnNotifyClbk] - Notify callback for menu button click.
//
//  Returns:    SC
//
//  Note : Detach removes the menu buttons and destroys the object.
//         So to re-create the menu button the snapin should again
//         do IMenuButton::AddButton and IControlbar::Attach.
//         This is how it is designed in mmc 1.0
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScDetachMenuButton (CMenuButtonNotify* pMenuBtnNotifyClbk)
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScDetachMenuButton"));

    if ( (NULL == m_pChildFrame) ||
         (false == m_pChildFrame->IsChildFrameActive()))
        return (sc = S_OK); // When child-frame is deactivated the menus are removed.

    // Make sure the menu is currently attached.
    if (m_AttachedMenuButtons.end() ==
        m_AttachedMenuButtons.find(pMenuBtnNotifyClbk))
        // This Menu Button is not attached.
        return (sc = E_UNEXPECTED);

    if ( (NULL == m_pMainFrame) ||
         (NULL == m_pMenuBar) )
        return (sc = E_UNEXPECTED);

    MMC_MenuButtonCollection::iterator it = m_MenuButtons.begin();
    while ( it != m_MenuButtons.end())
    {
        if (it->pMenuButtonNotifyClbk == pMenuBtnNotifyClbk)
        {
            BOOL bRet = FALSE;

            // Remove the menu button from Main Menu.
            if (-1 != it->nCommandIDFromMenuBar)
                bRet = m_pMenuBar->DeleteMenuButton(it->nCommandIDFromMenuBar);

            // The CMenubar removes all the menus when childframe is de-activated.
            // So DeleteMenuButton will fail if the button does not exist.
            // Therefore we do not check below error.
            // if (FALSE == bRet)
            //    return (sc = E_FAIL);

            // Delete the object in our data structure
            it = m_MenuButtons.erase(it);
        }
        else
            ++it;
    }

    // Delete the IMenuButton ref from the set.
    m_AttachedMenuButtons.erase(pMenuBtnNotifyClbk);

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:     ScToggleMenuButton
//
//  Synopsis:   Hide or Show the given menu buttons.
//
//  Arguments:
//              [bShow] - Show or Hide the menu buttons.
//
//  Returns:    SC
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScToggleMenuButton(BOOL bShow)
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScToggleMenuButton"));

    if ( (NULL == m_pChildFrame) ||
         (false == m_pChildFrame->IsChildFrameActive()) ||
         (NULL == m_pMenuBar) )
        return (sc = E_UNEXPECTED);

    // Go thro all the menu buttons added.
    MMC_MenuButtonCollection::iterator it;
    for (it = m_MenuButtons.begin(); it != m_MenuButtons.end(); ++it)
    {
        BOOL bRetVal = TRUE; // Init to true so that failure (false) can be checked below.

        // Toggle the menu hidden status. If the menu is
        // un-hidden then check if it is allowed.
        bRetVal = m_pMenuBar->HideButton(it->nCommandIDFromMenuBar, bShow ? !(it->CanShowMenu()) : TRUE);

        if (FALSE == bRetVal)
            return (sc = E_FAIL);
    }

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:     ScDisableMenuButtons
//
//  Synopsis:   Disable all the menubuttons.
//
//  Arguments:  None.
//
//  Returns:    SC
//
//--------------------------------------------------------------------
SC CMenuButtonsMgrImpl::ScDisableMenuButtons()
{
    DECLARE_SC(sc, _T("CMenuButtonsMgrImpl::ScDisableMenuButtons"));

    if ( (NULL == m_pChildFrame) ||
         (false == m_pChildFrame->IsChildFrameActive()) ||
         (NULL == m_pMenuBar) )
        return (sc = E_UNEXPECTED);

    // Go thro all the menu buttons added.
    MMC_MenuButtonCollection::iterator it;
    for (it = m_MenuButtons.begin(); it != m_MenuButtons.end(); ++it)
    {
        if (m_pMenuBar->IsButtonEnabled(it->nCommandIDFromMenuBar))
        {
            BOOL bRet = m_pMenuBar->EnableButton(it->nCommandIDFromMenuBar, false);

            if (FALSE == bRet)
                return (sc = E_FAIL);
        }
    }


    return (sc);
}


//+-------------------------------------------------------------------
//
//  Member:     GetMMCMenuButton
//
//  Synopsis:   Given the Notify callback and button command id get the button
//
//  Arguments:
//              [pMenuBtnNotifyClbk] - Callback for Menu click.
//              [idCommand]          - Button command id.
//
//  Returns:    iterator to MMC_MenuButtonCollection
//
//--------------------------------------------------------------------
MMC_MenuButtonCollection::iterator
CMenuButtonsMgrImpl::GetMMCMenuButton( CMenuButtonNotify* pMenuBtnNotifyClbk,
                                       INT idCommand)
{
    MMC_MenuButtonCollection::iterator it;
    for (it = m_MenuButtons.begin(); it != m_MenuButtons.end(); ++it)
    {
        if ( (it->pMenuButtonNotifyClbk == pMenuBtnNotifyClbk) &&
             (it->idCommand == idCommand) )
        {
            return it;
        }
    }

    return m_MenuButtons.end();
}

//+-------------------------------------------------------------------
//
//  Member:     GetMMCMenuButton
//
//  Synopsis:   Given the command id get the button
//
//  Arguments:
//              [nCommandID] - Command ID.
//
//  Returns:    iterator to MMC_MenuButtonCollection
//
//--------------------------------------------------------------------
MMC_MenuButtonCollection::iterator
CMenuButtonsMgrImpl::GetMMCMenuButton( INT nCommandID)
{
    MMC_MenuButtonCollection::iterator it;
    for (it = m_MenuButtons.begin(); it != m_MenuButtons.end(); ++it)
    {
        if ( it->nCommandIDFromMenuBar == nCommandID )
        {
            return it;
        }
    }

    return m_MenuButtons.end();
}


//+-------------------------------------------------------------------
//
//  Member:     IsAttached
//
//  Synopsis:   Given the notify callback, check if the MenuButtons
//              object is attached or not.
//
//  Arguments:
//              [pMenuBtnNotifyClbk] - Notify callback.
//
//  Returns:    bool
//
//--------------------------------------------------------------------
bool CMenuButtonsMgrImpl::IsAttached( CMenuButtonNotify* pMenuBtnNotifyClbk)
{
    MMC_AttachedMenuButtons::iterator it = m_AttachedMenuButtons.find(pMenuBtnNotifyClbk);
    if (m_AttachedMenuButtons.end() != it)
        return true;

    return false;
}