660 lines
19 KiB
C++
660 lines
19 KiB
C++
//____________________________________________________________________________
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
//
|
|
// File: stdbar.cpp
|
|
//
|
|
// Contents: Standard toolbar implementation.
|
|
//
|
|
// History: 10/22/1999 AnandhaG Created
|
|
//____________________________________________________________________________
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "stdbar.h"
|
|
#include "amcview.h"
|
|
#include "toolbar.h"
|
|
#include "util.h" // GetTBBtnTextAndStatus()
|
|
|
|
using namespace std;
|
|
|
|
/*
|
|
* These are used only to give the separators unique IDs, so automatic
|
|
* separator handling will work (see AssertSeparatorsAreValid).
|
|
*/
|
|
enum
|
|
{
|
|
ID_Separator1 = 1,
|
|
ID_Separator2,
|
|
ID_Separator3,
|
|
ID_Separator4,
|
|
ID_Separator5,
|
|
ID_Separator6,
|
|
ID_Separator7,
|
|
ID_Separator8,
|
|
ID_Separator9,
|
|
|
|
// must be last
|
|
ID_SeparatorFirst = ID_Separator1,
|
|
ID_SeparatorLast = ID_Separator9,
|
|
ID_SeparatorMax = ID_SeparatorLast,
|
|
};
|
|
|
|
static MMCBUTTON CommonButtons[] =
|
|
{
|
|
{ 0, IDS_MMC_WEB_BACK , TBSTATE_ENABLED, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 1, IDS_MMC_WEB_FORWARD , TBSTATE_ENABLED, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 0, ID_Separator1 , 0, TBSTYLE_SEP , NULL, NULL },
|
|
{ 9, IDS_MMC_GENL_UPONELEVEL , TBSTATE_ENABLED, TBSTYLE_BUTTON, NULL, NULL },
|
|
{10, IDS_MMC_GENL_SCOPE , TBSTATE_ENABLED, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 0, ID_Separator2 , 0, TBSTYLE_SEP , NULL, NULL },
|
|
{ 5, IDS_MMC_VERB_CUT , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 6, IDS_MMC_VERB_COPY , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 7, IDS_MMC_VERB_PASTE , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 0, ID_Separator3 , 0, TBSTYLE_SEP , NULL, NULL },
|
|
{11, IDS_MMC_VERB_DELETE , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 8, IDS_MMC_VERB_PROPERTIES , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{12, IDS_MMC_VERB_PRINT , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{13, IDS_MMC_VERB_REFRESH , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{16, IDS_SAVE_LIST_BUTTON , 0, TBSTYLE_BUTTON, NULL, NULL },
|
|
{ 0, ID_Separator4 , 0, TBSTYLE_SEP , NULL, NULL },
|
|
{15, IDS_MMC_GENL_CONTEXTHELP , TBSTATE_ENABLED, TBSTYLE_BUTTON, NULL, NULL },
|
|
};
|
|
|
|
|
|
CStandardToolbar::CStandardToolbar()
|
|
:m_pToolbarUI(NULL), m_pAMCView(NULL)
|
|
{
|
|
/*
|
|
* Map helps in determining string id from verb & vice versa.
|
|
*/
|
|
m_MMCVerbCommandIDs[MMC_VERB_CUT] = IDS_MMC_VERB_CUT;
|
|
m_MMCVerbCommandIDs[MMC_VERB_CUT] = IDS_MMC_VERB_CUT;
|
|
m_MMCVerbCommandIDs[MMC_VERB_COPY] = IDS_MMC_VERB_COPY;
|
|
m_MMCVerbCommandIDs[MMC_VERB_PASTE] = IDS_MMC_VERB_PASTE;
|
|
m_MMCVerbCommandIDs[MMC_VERB_DELETE] = IDS_MMC_VERB_DELETE;
|
|
m_MMCVerbCommandIDs[MMC_VERB_PROPERTIES] = IDS_MMC_VERB_PROPERTIES;
|
|
m_MMCVerbCommandIDs[MMC_VERB_PRINT] = IDS_MMC_VERB_PRINT;
|
|
m_MMCVerbCommandIDs[MMC_VERB_REFRESH] = IDS_MMC_VERB_REFRESH;
|
|
}
|
|
|
|
CStandardToolbar::~CStandardToolbar()
|
|
{
|
|
DECLARE_SC(sc, TEXT("CStandardToolbar::~CStandardToolbar"));
|
|
|
|
// Ask the toolbar UI object to delete itself.
|
|
if (m_pToolbarUI)
|
|
{
|
|
sc = m_pToolbarUI->ScDelete(this);
|
|
|
|
if (sc)
|
|
sc.TraceAndClear();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScInitializeStdToolbar
|
|
//
|
|
// Synopsis: Initialize the standard toolbar, add bitmap & buttons.
|
|
//
|
|
// Arguments: [pAMCView] - The CAMCView (owner) of this stdbar.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScInitializeStdToolbar(CAMCView* pAMCView)
|
|
{
|
|
DECLARE_SC (sc, _T("CStandardToolbar::ScInitializeStdToolbar"));
|
|
|
|
if (NULL == pAMCView)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
m_pAMCView = pAMCView;
|
|
|
|
SViewData* pViewData = m_pAMCView->GetViewData();
|
|
if (NULL == pViewData)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
|
|
// Get the toolbars mgr from CAMCView and create the stdandrd toolbar.
|
|
CAMCViewToolbarsMgr* pAMCViewToolbarsMgr = pViewData->GetAMCViewToolbarsMgr();
|
|
if (NULL == pAMCViewToolbarsMgr)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
sc = pAMCViewToolbarsMgr->ScCreateToolBar(&m_pToolbarUI);
|
|
if (sc)
|
|
return sc;
|
|
ASSERT(NULL != m_pToolbarUI);
|
|
|
|
// Add the bitmap
|
|
CBitmap cBmp;
|
|
cBmp.LoadBitmap((pAMCView->GetExStyle() & WS_EX_LAYOUTRTL) ? IDB_COMMON_16_RTL : IDB_COMMON_16);
|
|
|
|
BITMAP bm;
|
|
cBmp.GetBitmap (&bm);
|
|
|
|
int cBitmaps = (bm.bmWidth / BUTTON_BITMAP_SIZE) /*width*/;
|
|
|
|
sc = m_pToolbarUI->ScAddBitmap(this, cBitmaps, cBmp, MMC_TOOLBTN_COLORREF);
|
|
if (sc)
|
|
return sc;
|
|
|
|
// Add the buttons to the toolbar and then display toolbar
|
|
sc = ScAddToolbarButtons(countof(CommonButtons), CommonButtons);
|
|
if (sc)
|
|
return sc;
|
|
|
|
// See if Std bar is allowed or not.
|
|
bool bShowStdbar = (pViewData->m_dwToolbarsDisplayed & STD_BUTTONS);
|
|
|
|
sc = bShowStdbar ? m_pToolbarUI->ScAttach(this) : m_pToolbarUI->ScDetach(this);
|
|
if (sc)
|
|
return sc;
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScAddToolbarButtons
|
|
//
|
|
// Synopsis: Add buttons to standard toolbar.
|
|
//
|
|
// Arguments: [nCnt] - Number of buttons to be added.
|
|
// [pButtons] - Array of nCnt MMCBUTTONS.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScAddToolbarButtons(int nCnt, MMCBUTTON* pButtons)
|
|
{
|
|
DECLARE_SC (sc, _T("CStandardToolbar::ScAddToolbarButtons"));
|
|
|
|
// Array to store button text & tooltip text.
|
|
wstring szButtonText[countof(CommonButtons)];
|
|
wstring szTooltipText[countof(CommonButtons)];
|
|
|
|
USES_CONVERSION;
|
|
|
|
HINSTANCE hInst = GetStringModule();
|
|
|
|
// get resource strings for all buttons
|
|
for (int i = 0; i < nCnt; i++)
|
|
{
|
|
// We dont want to get text for separators.
|
|
if (pButtons[i].idCommand > ID_SeparatorMax)
|
|
{
|
|
bool bSuccess = GetTBBtnTextAndStatus(hInst,
|
|
pButtons[i].idCommand,
|
|
szButtonText[i],
|
|
szTooltipText[i]);
|
|
if (false == bSuccess)
|
|
{
|
|
return (sc = E_FAIL);
|
|
}
|
|
|
|
pButtons[i].lpButtonText = const_cast<LPOLESTR>(szButtonText[i].data());
|
|
pButtons[i].lpTooltipText = const_cast<LPOLESTR>(szTooltipText[i].data());
|
|
}
|
|
}
|
|
|
|
// Got the strings, now add buttons.
|
|
sc = m_pToolbarUI->ScAddButtons(this, nCnt, pButtons);
|
|
if (sc)
|
|
return sc;
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScNotifyToolBarClick
|
|
//
|
|
// Synopsis: Button click handler.
|
|
//
|
|
// Arguments: [hNode] - The HNODE owner of the view.
|
|
// [bScope] - Focus on scope or result.
|
|
// [lParam] - if result the lParam of focused result item.
|
|
// [nID] - Button ID that was clicked.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScNotifyToolBarClick(HNODE hNode, bool bScope, LPARAM lParam, UINT nID)
|
|
{
|
|
DECLARE_SC (sc, _T("CStandardToolbar::ScNotifyToolBarClick"));
|
|
|
|
if (NULL == m_pAMCView)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
switch (nID)
|
|
{
|
|
case IDS_MMC_VERB_CUT:
|
|
sc = m_pAMCView->ScProcessConsoleVerb (hNode, bScope, lParam, evCut);
|
|
break;
|
|
|
|
case IDS_MMC_VERB_COPY:
|
|
sc = m_pAMCView->ScProcessConsoleVerb (hNode, bScope, lParam, evCopy);
|
|
break;
|
|
|
|
case IDS_MMC_VERB_PASTE:
|
|
sc = m_pAMCView->ScProcessConsoleVerb (hNode, bScope, lParam, evPaste);
|
|
break;
|
|
|
|
case IDS_MMC_VERB_DELETE:
|
|
sc = m_pAMCView->ScProcessConsoleVerb (hNode, bScope, lParam, evDelete);
|
|
break;
|
|
|
|
case IDS_MMC_VERB_PROPERTIES:
|
|
sc = m_pAMCView->ScProcessConsoleVerb (hNode, bScope, lParam, evProperties);
|
|
break;
|
|
|
|
case IDS_MMC_VERB_PRINT:
|
|
sc = m_pAMCView->ScProcessConsoleVerb (hNode, bScope, lParam, evPrint);
|
|
break;
|
|
|
|
case IDS_MMC_VERB_REFRESH:
|
|
sc = m_pAMCView->ScProcessConsoleVerb (hNode, bScope, lParam, evRefresh);
|
|
break;
|
|
|
|
case IDS_MMC_GENL_CONTEXTHELP:
|
|
sc = m_pAMCView->ScContextHelp ();
|
|
break;
|
|
|
|
case IDS_MMC_GENL_UPONELEVEL:
|
|
sc = m_pAMCView->ScUpOneLevel ();
|
|
break;
|
|
|
|
case IDS_MMC_GENL_SCOPE:
|
|
sc = m_pAMCView->ScToggleScopePane ();
|
|
break;
|
|
|
|
case IDS_MMC_WEB_BACK:
|
|
sc = m_pAMCView->ScWebCommand (CConsoleView::eWeb_Back);
|
|
break;
|
|
|
|
case IDS_MMC_WEB_FORWARD:
|
|
sc = m_pAMCView->ScWebCommand (CConsoleView::eWeb_Forward);
|
|
break;
|
|
|
|
case IDS_MMC_WEB_STOP:
|
|
sc = m_pAMCView->ScWebCommand (CConsoleView::eWeb_Stop);
|
|
break;
|
|
|
|
case IDS_MMC_WEB_REFRESH:
|
|
sc = m_pAMCView->ScWebCommand (CConsoleView::eWeb_Refresh);
|
|
break;
|
|
|
|
case IDS_MMC_WEB_HOME:
|
|
sc = m_pAMCView->ScWebCommand (CConsoleView::eWeb_Home);
|
|
break;
|
|
|
|
case IDS_SAVE_LIST_BUTTON:
|
|
sc = m_pAMCView->ScSaveList ();
|
|
break;
|
|
|
|
default:
|
|
sc = E_UNEXPECTED;
|
|
TraceError(_T("Unknown Standard bar button ID"), sc);
|
|
break;
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CStandardToolbar::ScAMCViewToolbarsBeingDestroyed
|
|
//
|
|
// Synopsis: The CAMCViewToolbars object is going away, do not
|
|
// reference that object anymore.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScAMCViewToolbarsBeingDestroyed ()
|
|
{
|
|
DECLARE_SC(sc, _T("CStandardToolbar::ScAMCViewToolbarsBeingDestroyed"));
|
|
|
|
m_pToolbarUI = NULL;
|
|
|
|
return (sc);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScEnableButton
|
|
//
|
|
// Synopsis: Enable/Disable given button.
|
|
//
|
|
// Arguments:
|
|
// [nID] - Button ID that should be enabled/disabled.
|
|
// [bool] - Enable or Disable.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScEnableButton(INT nID, bool bState)
|
|
{
|
|
SC sc;
|
|
|
|
if (NULL == m_pToolbarUI)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
sc = m_pToolbarUI->ScSetButtonState(this, nID, TBSTATE_ENABLED, bState);
|
|
if (sc)
|
|
return sc;
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScEnableAndShowButton
|
|
//
|
|
// Synopsis: Enable (and show) or disable (and hide) the given button.
|
|
//
|
|
// Arguments:
|
|
// [nID] - Button ID that should be enabled/disabled.
|
|
// [bool] - If true enable else hide.
|
|
//
|
|
// Note: If the button is being disabled hide it.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScEnableAndShowButton(INT nID, bool bEnableAndShow)
|
|
{
|
|
DECLARE_SC(sc, _T("CStandardToolbar::ScEnableAndShowButton"));
|
|
|
|
sc = ScCheckPointers(m_pToolbarUI, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc;
|
|
|
|
// First hide or show the button.
|
|
sc = m_pToolbarUI->ScSetButtonState(this, nID, TBSTATE_HIDDEN, !bEnableAndShow);
|
|
if (sc)
|
|
return sc;
|
|
|
|
// Now enable or disable the button.
|
|
sc = m_pToolbarUI->ScSetButtonState(this, nID, TBSTATE_ENABLED, bEnableAndShow);
|
|
if (sc)
|
|
return sc;
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScEnableExportList
|
|
//
|
|
// Synopsis: Enable/Disable export-list button.
|
|
//
|
|
// Arguments: [bEnable] - enable/disable.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScEnableExportList(bool bEnable)
|
|
{
|
|
// If there are ANY items on the list, enable the button.
|
|
return ScEnableAndShowButton(IDS_SAVE_LIST_BUTTON, bEnable );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScEnableUpOneLevel
|
|
//
|
|
// Synopsis: Enable/Disable up-one-level button.
|
|
//
|
|
// Arguments: [bEnable] -
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScEnableUpOneLevel(bool bEnable)
|
|
{
|
|
return ScEnableAndShowButton(IDS_MMC_GENL_UPONELEVEL, bEnable);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScEnableContextHelpBtn
|
|
//
|
|
// Synopsis: Enable/Disable help button.
|
|
//
|
|
// Arguments: [bEnable] -
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScEnableContextHelpBtn(bool bEnable)
|
|
{
|
|
return ScEnableAndShowButton(IDS_MMC_GENL_CONTEXTHELP, bEnable);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScEnableScopePaneBtn
|
|
//
|
|
// Synopsis: Enable/Disable scope-pane button.
|
|
//
|
|
// Arguments: [bEnable] -
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScEnableScopePaneBtn(bool bEnable)
|
|
{
|
|
return ScEnableAndShowButton(IDS_MMC_GENL_SCOPE, bEnable);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScCheckScopePaneBtn
|
|
//
|
|
// Synopsis: Set scope button in normal or checked state.
|
|
//
|
|
// Arguments: [bChecked] - BOOL
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScCheckScopePaneBtn(bool bChecked)
|
|
{
|
|
SC sc;
|
|
|
|
if (NULL == m_pToolbarUI)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
sc = m_pToolbarUI->ScSetButtonState(this, IDS_MMC_GENL_SCOPE, TBSTATE_CHECKED, bChecked);
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScShowStdBar
|
|
//
|
|
// Synopsis: Show or Hide std bar.
|
|
//
|
|
// Arguments: [bShow] - BOOL
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScShowStdBar(bool bShow)
|
|
{
|
|
SC sc;
|
|
|
|
if (NULL == m_pToolbarUI)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
sc = bShow ? m_pToolbarUI->ScAttach(this) : m_pToolbarUI->ScDetach(this);
|
|
if (sc)
|
|
return sc;
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScUpdateStdbarVerbs
|
|
//
|
|
// Synopsis: Update the toolbuttons of std-verbs.
|
|
//
|
|
// Arguments: [pCV] - the IConsoleVerb that has state of the verb.
|
|
//
|
|
// Returns: SC.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScUpdateStdbarVerbs(IConsoleVerb* pCV)
|
|
{
|
|
DECLARE_SC (sc, _T("CStandardToolbar::ScUpdateStdbarVerbs"));
|
|
|
|
for (int verb = MMC_VERB_FIRST; verb <= MMC_VERB_LAST; verb++)
|
|
{
|
|
// No toolbar buttons for following verbs.
|
|
if ( (MMC_VERB_OPEN == verb) ||
|
|
(MMC_VERB_RENAME == verb))
|
|
continue;
|
|
|
|
sc = ScUpdateStdbarVerb (static_cast<MMC_CONSOLE_VERB>(verb), pCV);
|
|
if (sc)
|
|
return sc;
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScUpdateStdbarVerb
|
|
//
|
|
// Synopsis: Update the toolbutton of given std-verbs.
|
|
//
|
|
// Arguments: [cVerb] - the verb (ie: toolbutton) to be updated.
|
|
// [pVC] - the IConsoleVerb that has state of the verb.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScUpdateStdbarVerb(MMC_CONSOLE_VERB cVerb, IConsoleVerb* pConsoleVerb /*=NULL*/)
|
|
{
|
|
DECLARE_SC (sc, _T("CStandardToolbar::ScUpdateStdbarVerb"));
|
|
|
|
if (NULL == m_pToolbarUI)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
if (pConsoleVerb == NULL)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
// No toolbuttons for these verbs.
|
|
if ( (MMC_VERB_OPEN == cVerb) ||
|
|
(MMC_VERB_RENAME == cVerb))
|
|
return sc;
|
|
|
|
MMCVerbCommandIDs::iterator it = m_MMCVerbCommandIDs.find(cVerb);
|
|
if (m_MMCVerbCommandIDs.end() == it)
|
|
{
|
|
// Could not find the verb in our map.
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
INT nCommandID = it->second;
|
|
BOOL bFlag = 0;
|
|
pConsoleVerb->GetVerbState(cVerb, HIDDEN, &bFlag);
|
|
sc = m_pToolbarUI->ScSetButtonState(this, nCommandID, TBSTATE_HIDDEN, bFlag);
|
|
if (sc)
|
|
return sc;
|
|
|
|
if (bFlag == FALSE)
|
|
{
|
|
// If verb is not hidden then enable/disable it.
|
|
pConsoleVerb->GetVerbState(cVerb, ENABLED, &bFlag);
|
|
sc = m_pToolbarUI->ScSetButtonState(this, nCommandID, TBSTATE_ENABLED, bFlag);
|
|
|
|
if (sc)
|
|
return sc;
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScUpdateStdbarVerb
|
|
//
|
|
// Synopsis: Update the toolbutton of given std-verb.
|
|
//
|
|
// Arguments: [cVerb] - the verb (ie: toolbutton) to be updated.
|
|
// [nState] - the button state to be updated.
|
|
// [bFlag] - State
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScUpdateStdbarVerb (MMC_CONSOLE_VERB cVerb, BYTE byState, BOOL bFlag)
|
|
{
|
|
DECLARE_SC (sc, _T("CStandardToolbar::ScUpdateStdbarVerb"));
|
|
|
|
if (NULL == m_pToolbarUI)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
MMCVerbCommandIDs::iterator it = m_MMCVerbCommandIDs.find(cVerb);
|
|
if (m_MMCVerbCommandIDs.end() == it)
|
|
{
|
|
// Could not find the verb in our map.
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
INT nCommandID = it->second;
|
|
sc = m_pToolbarUI->ScSetButtonState(this, nCommandID, byState, bFlag);
|
|
if (sc)
|
|
return sc;
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: ScShow
|
|
//
|
|
// Synopsis: Show/Hide the toolbar.
|
|
//
|
|
// Arguments: [bShow] - show/hide.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CStandardToolbar::ScShow (BOOL bShow)
|
|
{
|
|
DECLARE_SC (sc, _T("CStandardToolbar::ScShow"));
|
|
|
|
if (NULL == m_pToolbarUI)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc;
|
|
}
|
|
|
|
sc = m_pToolbarUI->ScShow(this, bShow);
|
|
if (sc)
|
|
return sc;
|
|
|
|
return sc;
|
|
}
|
|
|