windows-server-2003/admin/activec/conui/ftab.cpp

/*--------------------------------------------------------------------------*
 *
 *  Microsoft Windows
 *  Copyright (C) Microsoft Corporation, 1992 - 1999
 *
 *  File:      ftab.h
 *
 *  Contents:  Implementation file for CFolderTab, CFolderTabView
 *
 *  History:   06-May-99 vivekj     Created
 *
 *--------------------------------------------------------------------------*/

#include "stdafx.h"
#include "ftab.h"
#include "amcview.h"
#include <oleacc.h>

/*
 * if we're supporting old platforms, we need to build MSAA stubs
 */
#if (_WINNT_WIN32 < 0x0500)
	#include <winable.h>
	
	#define COMPILE_MSAA_STUBS
	#include "msaastub.h"
	
	#define WM_GETOBJECT	0x003D
#endif


#ifdef DBG
CTraceTag  tagTabAccessibility (_T("Accessibility"), _T("Tab Control"));
#endif


/*+-------------------------------------------------------------------------*
 * ValueOf
 *
 * Returns the value contained in the given variant.  The variant is
 * expected to be of type VT_I4.
 *--------------------------------------------------------------------------*/

inline LONG ValueOf (VARIANT& var)
{
	ASSERT (V_VT (&var) == VT_I4);		// prevalidation is expected
	return (V_I4 (&var));
}


/*+-------------------------------------------------------------------------*
 * CTabAccessible
 *
 * Implements the accessibility interface IAccessible for CFolderTabView.
 *--------------------------------------------------------------------------*/

class CTabAccessible :
	public CMMCIDispatchImpl<IAccessible, &GUID_NULL, &LIBID_Accessibility>,
    public CTiedComObject<CFolderTabView>
{
    typedef CTabAccessible	ThisClass;
    typedef CFolderTabView	CMyTiedObject;

public:
    BEGIN_MMC_COM_MAP(ThisClass)
    END_MMC_COM_MAP()

    DECLARE_NOT_AGGREGATABLE(ThisClass)

public:
    // *** IAccessible methods ***
    MMC_METHOD1 (get_accParent,				IDispatch** /*ppdispParent*/);
    MMC_METHOD1 (get_accChildCount,			long* /*pChildCount*/);
    MMC_METHOD2 (get_accChild,				VARIANT /*varChildID*/, IDispatch ** /*ppdispChild*/);
    MMC_METHOD2 (get_accName,				VARIANT /*varChildID*/, BSTR* /*pszName*/);
    MMC_METHOD2 (get_accValue,				VARIANT /*varChildID*/, BSTR* /*pszValue*/);
    MMC_METHOD2 (get_accDescription,		VARIANT /*varChildID*/, BSTR* /*pszDescription*/);
    MMC_METHOD2 (get_accRole,				VARIANT /*varChildID*/, VARIANT */*pvarRole*/);
    MMC_METHOD2 (get_accState,				VARIANT /*varChildID*/, VARIANT */*pvarState*/);
    MMC_METHOD2 (get_accHelp,				VARIANT /*varChildID*/, BSTR* /*pszHelp*/);
    MMC_METHOD3 (get_accHelpTopic,			BSTR* /*pszHelpFile*/, VARIANT /*varChildID*/, long* /*pidTopic*/);
    MMC_METHOD2 (get_accKeyboardShortcut,	VARIANT /*varChildID*/, BSTR* /*pszKeyboardShortcut*/);
    MMC_METHOD1 (get_accFocus,				VARIANT * /*pvarFocusChild*/);
    MMC_METHOD1 (get_accSelection,			VARIANT * /*pvarSelectedChildren*/);
    MMC_METHOD2 (get_accDefaultAction,		VARIANT /*varChildID*/, BSTR* /*pszDefaultAction*/);
    MMC_METHOD2 (accSelect,					long /*flagsSelect*/, VARIANT /*varChildID*/);
    MMC_METHOD5 (accLocation,				long* /*pxLeft*/, long* /*pyTop*/, long* /*pcxWidth*/, long* /*pcyHeight*/, VARIANT /*varChildID*/);
    MMC_METHOD3 (accNavigate,				long /*navDir*/, VARIANT /*varStart*/, VARIANT * /*pvarEndUpAt*/);
    MMC_METHOD3 (accHitTest,				long /*xLeft*/, long /*yTop*/, VARIANT * /*pvarChildAtPoint*/);
    MMC_METHOD1 (accDoDefaultAction,		VARIANT /*varChildID*/);
    MMC_METHOD2 (put_accName,				VARIANT /*varChildID*/, BSTR /*szName*/);
    MMC_METHOD2 (put_accValue,				VARIANT /*varChildID*/, BSTR /*pszValue*/);
};



//############################################################################
//############################################################################
//
//  Implementation of class CFolderTabMetrics
//
//############################################################################
//############################################################################

CFolderTabMetrics::CFolderTabMetrics()
: m_dwStyle(0), m_textHeight(0)
{
}

int CFolderTabMetrics::GetXOffset()     const {return 8;}
int CFolderTabMetrics::GetXMargin()     const {return 2;}
int CFolderTabMetrics::GetYMargin()     const {return 1;}
int CFolderTabMetrics::GetYBorder()     const {return 1;}
int CFolderTabMetrics::GetExtraYSpace() const {return 0;}
int CFolderTabMetrics::GetTabHeight()   const {return GetTextHeight() + 2 * GetYMargin() + 2 * GetYBorder();}
int CFolderTabMetrics::GetUpDownWidth() const {return 2*GetTabHeight();} //for nice square buttons
int CFolderTabMetrics::GetUpDownHeight()const {return GetTabHeight();} // the up-down control is as tall as the tabs


//############################################################################
//############################################################################
//
//  Implementation of class CFolderTab
//
//############################################################################
//############################################################################

CFolderTab::CFolderTab()
{
}

CFolderTab::CFolderTab(const CFolderTab &other)
{
    *this = other;
}

CFolderTab &
CFolderTab::operator = (const CFolderTab &other)
{
    if((CFolderTab *) this == (CFolderTab *) &other)
       return *this;

    m_sText   = other.m_sText;
    m_rect    = other.m_rect;
    m_clsid   = other.m_clsid;
    m_dwStyle = other.m_dwStyle;
    m_textHeight = other.m_textHeight;

    return *this;
}


/*+-------------------------------------------------------------------------*
 *
 * CFolderTab::GetWidth
 *
 * PURPOSE: Returns the width of the tab.
 *
 * RETURNS:
 *    int
 *
 *+-------------------------------------------------------------------------*/
int
CFolderTab::GetWidth() const
{
    return m_rect.Width() + 1; // rect.Width() returns right-left, need to add 1 for inclusive width.
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTab::SetWidth
 *
 * PURPOSE:  Sets the width of the tab.
 *
 * PARAMETERS:
 *    int  nWidth :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTab::SetWidth(int nWidth)
{
    ASSERT(nWidth > 0);
    ASSERT(GetWidth() >= nWidth);

    int delta = nWidth - (m_rect.Width() + 1);
    m_rect.right = m_rect.left + nWidth -1;

    m_rgPts[2].x+=delta;
    m_rgPts[3].x+=delta;
    SetRgn();
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTab::Offset
 *
 * PURPOSE:     Adds a certain offset to the internal array of points.
 *
 * PARAMETERS:
 *    const  CPoint :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTab::Offset(const CPoint &point)
{
    m_rect.OffsetRect(point);
    m_rgPts[0].Offset(point);
    m_rgPts[1].Offset(point);
    m_rgPts[2].Offset(point);
    m_rgPts[3].Offset(point);
    m_rgn.OffsetRgn(point);
}

void
CFolderTab::SetRgn()
{
    m_rgn.DeleteObject();
    m_rgn.CreatePolygonRgn(m_rgPts, 4, WINDING);
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTab::ComputeRgn
 *
 * PURPOSE: Compute the the points, rect and region for a tab.
 *          Input x is starting x pos.
 *
 * PARAMETERS:
 *    CDC& dc :
 *    int  x :
 *
 * RETURNS:
 *    int: The actual width of the tab
 *
 *+-------------------------------------------------------------------------*/
int
CFolderTab::ComputeRgn(CDC& dc, int x)
{

    CRect& rc = m_rect;
    rc.SetRectEmpty();

    // calculate desired text rectangle
    dc.DrawText(m_sText, &rc, DT_CALCRECT);
    rc.right  += 2*GetXOffset() + 2*GetXMargin();                       // add margins
    rc.bottom = rc.top + GetTabHeight();
    rc += CPoint(x,0);                                                  // shift right

    // create region
    GetTrapezoid(rc, m_rgPts);
    SetRgn();

    return rc.Width();
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTab::GetTrapezoid
 *
 * PURPOSE: Given the bounding rect, compute trapezoid region.
 *          Note that the right and bottom edges not included in rect or
 *          trapezoid; these are normal rules of geometry.
 *
 * PARAMETERS:
 *    const   CRect :
 *    CPoint* pts :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void CFolderTab::GetTrapezoid(const CRect& rc, CPoint* pts) const
{
    pts[0] = CPoint(rc.left,                  rc.top    );
    pts[1] = CPoint(rc.left + GetXOffset(),   rc.bottom );
    pts[2] = CPoint(rc.right- GetXOffset()-1, rc.bottom );
    pts[3] = CPoint(rc.right-1,               rc.top    );
}

//////////////////
// Draw tab in normal or highlighted state
//
int CFolderTab::Draw(CDC& dc, CFont& font, BOOL bSelected, bool bFocused)
{
    return DrawTrapezoidal(dc, font, bSelected, bFocused);
}


/*+-------------------------------------------------------------------------*
 *
 * CFolderTab::DrawTrapezoidal
 *
 * PURPOSE: Draws a trapezoidal tab.
 *
 * PARAMETERS:
 *    CDC&   dc :
 *    CFont& font :
 *    BOOL   bSelected :
 *    bool   bFocused :
 *
 * RETURNS:
 *    int
 *
 *+-------------------------------------------------------------------------*/
int CFolderTab::DrawTrapezoidal(CDC& dc, CFont& font, BOOL bSelected, bool bFocused)
{
    COLORREF bgColor = GetSysColor(bSelected ? COLOR_WINDOW     : COLOR_3DFACE);
    COLORREF fgColor = GetSysColor(bSelected ? COLOR_WINDOWTEXT : COLOR_BTNTEXT);

    CBrush brush(bgColor);                   // background brush
    dc.SetBkColor(bgColor);                  // text background
    dc.SetTextColor(fgColor);                // text color = fg color

    CPen blackPen (PS_SOLID, 1, GetSysColor(COLOR_WINDOWFRAME));
    CPen shadowPen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW));

    // Fill trapezoid
    CPoint pts[4];
    CRect rc = m_rect;
    GetTrapezoid(rc, pts);
    CPen* pOldPen = dc.SelectObject(&blackPen);
    dc.FillRgn(&m_rgn, &brush);

    // Draw edges. This is requires two corrections:
    // 1) Trapezoid dimensions don't include the right and bottom edges,
    // so must use one pixel less on bottom (cybottom)
    // 2) the endpoint of LineTo is not included when drawing the line, so
    // must add one pixel (cytop)
    //
    {
        pts[1].y--;         // correction #1: true bottom edge y-coord
        pts[2].y--;         // ...ditto
        pts[3].y--;         // correction #2:   extend final LineTo
    }
    dc.MoveTo(pts[0]);                      // upper left
    dc.LineTo(pts[1]);                      // bottom left
    dc.SelectObject(&shadowPen);            // bottom line is shadow color
    dc.MoveTo(pts[1]);                      // line is inside trapezoid bottom
    dc.LineTo(pts[2]);                      // ...
    dc.SelectObject(&blackPen);         // upstroke is black
    dc.LineTo(pts[3]);                      // y-1 to include endpoint
    if(!bSelected)
    {
        // if not highlighted, upstroke has a 3D shadow, one pixel inside
        pts[2].x--;     // offset left one pixel
        pts[3].x--;     // ...ditto
        dc.SelectObject(&shadowPen);
        dc.MoveTo(pts[2]);
        dc.LineTo(pts[3]);
    }
    dc.SelectObject(pOldPen);

    // draw text
    rc.DeflateRect(GetXOffset() + GetXMargin(), GetYMargin());
    CFont* pOldFont = dc.SelectObject(&font);
    dc.DrawText(m_sText, &rc, DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);
    dc.SelectObject(pOldFont);

    if(bFocused) // draw the focus rectangle
    {
        // make some more space.
        rc.top--;
        rc.bottom++;
        rc.left--;
        rc.right++;

        dc.DrawFocusRect(&rc);
    }

    return m_rect.right;
}

//############################################################################
//############################################################################
//
//  Implementation of class CFolderTabView
//
//############################################################################
//############################################################################
IMPLEMENT_DYNAMIC(CFolderTabView, CView)
BEGIN_MESSAGE_MAP(CFolderTabView, CView)
	ON_WM_PAINT()
	ON_WM_LBUTTONDOWN()
	ON_WM_SETFOCUS()
	ON_WM_KILLFOCUS()
	ON_WM_MOUSEACTIVATE()
	ON_WM_KEYDOWN()
	ON_WM_SETTINGCHANGE()
	ON_WM_SIZE()
	ON_WM_HSCROLL()
	ON_MESSAGE(WM_GETOBJECT, OnGetObject)
END_MESSAGE_MAP()

CFolderTabView::CFolderTabView(CView *pParentView)
: m_bVisible(false), m_pParentView(pParentView)
{
    m_iCurItem   = -1;		// nothing currently selected
    m_dwStyle    = 0;
    m_textHeight = 0;
    m_sizeX      = 0;
    m_sizeY      = 0;
    m_hWndUpDown = NULL;
    m_nPos       = 0; // the first tab is the one drawn
	m_fHaveFocus = false;
}

CFolderTabView::~CFolderTabView()
{
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScFireAccessibilityEvent
 *
 * Fires accessibility events for the folder tab view
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScFireAccessibilityEvent (
	DWORD	dwEvent,					/* I:event to fire					*/
	LONG	idObject)					/* I:object generating the event	*/
{
	DECLARE_SC (sc, _T("CFolderTabView::ScFireAccessibilityEvent"));

	/*
	 * Accessibility events are fired after the event takes place (e.g.
	 * EVENT_OBJECT_CREATE is sent after the child is created, not before).
	 * Because of this the child ID for EVENT_OBJECT_DESTROY is not
	 * necessarily valid, so we shouldn't validate in that case.
	 */
	if (dwEvent != EVENT_OBJECT_DESTROY)
	{
		sc = ScValidateChildID (idObject);
		if (sc)
			return (sc);
	}

	NotifyWinEvent (dwEvent, m_hWnd, OBJID_CLIENT, idObject);	// returns void
	return (sc);
}


/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::OnHScroll
 *
 * PURPOSE: Called when the position of the scroll bar is changed
 *
 * PARAMETERS:
 *    UINT        nSBCode :
 *    UINT        nPos :
 *    CScrollBar* pScrollBar :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTabView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
{
    // we're only interested in SB_THUMBPOSITION
    if(nSBCode != SB_THUMBPOSITION)
        return;

    // if the position has not changed, do nothing.
    if(nPos == m_nPos)
        return;

    m_nPos = nPos;  // change the position
    RecomputeLayout();
    InvalidateRect(NULL, true); // redraw everything.
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::OnSetFocus
 *
 * WM_SETFOCUS handler for CFolderTabView.
 *--------------------------------------------------------------------------*/

void CFolderTabView::OnSetFocus(CWnd* pOldWnd)
{
	m_fHaveFocus = true;

    InvalidateRect(NULL);
    BC::OnSetFocus(pOldWnd);

	/*
	 * If we have any tabs, one of them will get the focus.  Fire the
	 * focus accessibility event, ignoring errors.  We do this after
	 * calling the base class, so this focus event will override the
	 * "focus to the window" event sent by the system on our behalf.
	 */
	if (GetItemCount() > 0)
		ScFireAccessibilityEvent (EVENT_OBJECT_FOCUS, m_iCurItem+1 /*1-based*/);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::OnKillFocus
 *
 * WM_KILLFOCUS handler for CFolderTabView.
 *--------------------------------------------------------------------------*/

void CFolderTabView::OnKillFocus(CWnd* pNewWnd)
{
	m_fHaveFocus = false;

    InvalidateRect(NULL);
    BC::OnKillFocus(pNewWnd);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::OnMouseActivate
 *
 * WM_MOUSEACTIVATE handler for CFolderTabView.
 *--------------------------------------------------------------------------*/

int CFolderTabView::OnMouseActivate( CWnd* pDesktopWnd, UINT nHitTest, UINT message )
{
    //short-circuit the MFC base class code, which sets the keyboard focus here as well...
    return MA_ACTIVATE;
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::OnCmdMsg
 *
 * WM_COMMAND handler for CFolderTabView.
 *--------------------------------------------------------------------------*/

BOOL CFolderTabView::OnCmdMsg( UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo )
{
    // Do normal command routing
    if (BC::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
        return TRUE;

    // if view didn't handle it, give parent view a chance
    if (m_pParentView != NULL)
        return static_cast<CWnd*>(m_pParentView)->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
    else
        return FALSE;
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::OnKeyDown
 *
 * WM_KEYDOWN handler for CFolderTabView.
 *--------------------------------------------------------------------------*/

void CFolderTabView::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags )
{
    int cSize = m_tabList.size();

    if( (cSize == 0) || ( (nChar != VK_LEFT) && (nChar != VK_RIGHT) ) )
    {
        BC::OnKeyDown(nChar, nRepCnt, nFlags);
        return;
    }

    ASSERT( (nChar == VK_LEFT) || (nChar == VK_RIGHT) );

    int iNew = GetSelectedItem() + (nChar==VK_LEFT ? -1 : 1);
	if(iNew < 0)
		iNew = 0; // does not wrap

	if(iNew >= cSize)
		iNew = cSize -1; // does not wrap

    SelectItem(iNew, true /*bEnsureVisible*/);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::OnSettingChange
 *
 * WM_SETTINGCHANGE handler for CFolderTabView.
 *--------------------------------------------------------------------------*/

void CFolderTabView::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
{
    CView::OnSettingChange(uFlags, lpszSection);

    if (uFlags == SPI_SETNONCLIENTMETRICS)
    {
        DeleteFonts ();
        CreateFonts ();
        InvalidateRect(NULL, true); // redraw everything.
        RecomputeLayout ();
    }
}

//////////////////
// Create folder tab control from static control.
// Destroys the static control. This is convenient for dialogs
//
BOOL CFolderTabView::CreateFromStatic(UINT nID, CWnd* pParent)
{
    CStatic wndStatic;
    if(!wndStatic.SubclassDlgItem(nID, pParent))
        return FALSE;
    CRect rc;
    wndStatic.GetWindowRect(&rc);
    pParent->ScreenToClient(&rc);
    wndStatic.DestroyWindow();
    rc.bottom = rc.top + GetDesiredHeight();
    return Create(WS_CHILD|WS_VISIBLE, rc, pParent, nID);
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::Create
 *
 * PURPOSE: Creates the folder tab control
 *
 * PARAMETERS:
 *    DWORD  dwStyle :
 *    const  RECT :
 *    CWnd*  pParent :
 *    UINT   nID :
 *    DWORD  dwFtabStyle :
 *
 * RETURNS:
 *    BOOL
 *
 *+-------------------------------------------------------------------------*/
BOOL CFolderTabView::Create(DWORD dwStyle, const RECT& rc,
                            CWnd* pParent, UINT nID, DWORD dwFtabStyle)
{
    ASSERT(pParent);
    ASSERT(dwStyle & WS_CHILD);

    m_dwStyle = dwFtabStyle;

    static LPCTSTR lpClassName = _T("AMCCustomTab");
    static BOOL bRegistered = FALSE; // registered?
    if(!bRegistered)
    {
        WNDCLASS wc;
        memset(&wc, 0, sizeof(wc));
        wc.lpfnWndProc = ::DefWindowProc; // will get hooked by MFC
        wc.hInstance = AfxGetInstanceHandle();
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)(COLOR_3DFACE+1);
        wc.lpszMenuName = NULL;
        wc.lpszClassName = lpClassName;
        if(!AfxRegisterClass(&wc))
        {
            TRACE(_T("*** CFolderTabView::AfxRegisterClass failed!\n"));
            return FALSE;
        }
        bRegistered = TRUE;
    }
    if(!BC::CreateEx(0, lpClassName, NULL, dwStyle, rc, pParent, nID))
        return FALSE;

    // initialize fonts
    CreateFonts();

	/*
	 * Bug 141015:  Create a buddy window for the up-down control.  It will
	 * never be visible, but we need it so UDM_GETPOS sent to the up-down
	 * will work.  Narrator will send this message when the up-down becomes
	 * visible, but it will fail if there's no buddy (sad, but true).  It
	 * fails by returning an LRESULT with a non-zero high-order word
	 * (specifically, 0x00010000), so Narrator translates and announces
	 * "65536" instead of the true value.
	 *
	 * This is only required for Narrator support, so if it fails it's
	 * not sufficient reason to fail CFolderTabView creation altogether.
	 */
	HWND hwndBuddy = CreateWindow (_T("edit"), NULL, WS_CHILD, 0, 0, 0, 0,
								   m_hWnd, 0, AfxGetInstanceHandle(), NULL);

    // create the up-down control
    DWORD dwUpDownStyle = WS_CHILD | WS_BORDER |
						  UDS_SETBUDDYINT |		// for Narrator support
						  UDS_HORZ /*to display the arrows left to right*/; // NOTE: the control is created invisible on purpose.
    m_hWndUpDown = CreateUpDownControl(dwUpDownStyle, 0, 0,
                        GetUpDownWidth(),   //width
                        GetUpDownHeight(),  //height
                        m_hWnd,
                        1 /*nID*/,
                        AfxGetInstanceHandle(),
                        hwndBuddy,
                        0 /*nUpper*/,
                        0 /*nLower*/,
                        0 /*nPos*/);

    return TRUE;
}

void CFolderTabView::CreateFonts ()
{
    LOGFONT lf;
    SystemParametersInfo (SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, false);
    m_fontNormal.CreateFontIndirect(&lf);

    // Get the font height (converting from points to pixels)
    CClientDC dc(NULL);
    TEXTMETRIC tm;
	CFont *pFontOld = dc.SelectObject(&m_fontNormal);
    dc.GetTextMetrics(&tm);

    m_textHeight = tm.tmHeight;

	// set the old font back.
	dc.SelectObject(pFontOld);

    lf.lfWeight = FW_BOLD;
    m_fontSelected.CreateFontIndirect(&lf);
}

void CFolderTabView::DeleteFonts ()
{
    m_fontNormal.DeleteObject();
    m_fontSelected.DeleteObject();
}

//////////////////
// copy a font
//
static void CopyFont(CFont& dst, CFont& src)
{
    dst.DeleteObject();
    LOGFONT lf;
    VERIFY(src.GetLogFont(&lf));
    dst.CreateFontIndirect(&lf);
}

//////////////////
// Set normal, selected fonts
//
void CFolderTabView::SetFonts(CFont& fontNormal, CFont& fontSelected)
{
    CopyFont(m_fontNormal, fontNormal);
    CopyFont(m_fontSelected, fontSelected);
}

//////////////////
// Paint function
//

void CFolderTabView::OnDraw(CDC* pDC)
{
}

void CFolderTabView::OnPaint()
{
    Paint (m_fHaveFocus);
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::EnsureVisible
 *
 * PURPOSE: Changes the layout to ensure that the specified tab is visible.
 *
 * NOTE:    Does NOT invalidate the rect, for efficiency.
 *
 * PARAMETERS:
 *    UINT  iTab :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTabView::EnsureVisible(int iTab)
{
    if((iTab < 0) || (iTab > m_tabList.size()))
    {
        ASSERT(0 && "Should not come here.");
        return;
    }

    if(!::IsWindowVisible(m_hWndUpDown))
        return; // the up-down control is hidden, meaning that all tabs are visible

	RecomputeLayout(); // make sure we have the correct dimensions

	if(m_nPos == iTab)
		return; // the tab already shows as much as it can.

    if(m_nPos > iTab) // the first visible tab is to the right of iTab. Make iTab the first visible tab
    {
        m_nPos = iTab;
        RecomputeLayout();
        return;
    }

    iterator iter = m_tabList.begin();
    std::advance(iter, iTab); // get the correct item

    CRect rcCurTab = iter->GetRect();

    // loop: Increase the start tab position until the right edge of iTab fits.
    while((m_nPos < iTab) && (rcCurTab.right > m_sizeX))
    {
        m_nPos++;
        RecomputeLayout();
        rcCurTab = iter->GetRect();
    }
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::Paint
 *
 * PURPOSE: Completely redraws the tab control.
 *
 * PARAMETERS:
 *    bool  bFocused :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTabView::Paint(bool bFocused)
{
    CPaintDC dc(this); // device context for painting

    CRect rc;
    GetClientRect(&rc);

    // draw all the normal (non-selected) tabs
    iterator iterSelected = m_tabList.end();
    int i = 0;
    bool bDraw = true;
    for(iterator iter= m_tabList.begin(); iter!= m_tabList.end(); ++iter, i++)
    {
        if(i!=m_iCurItem)
        {
            if(bDraw && iter->Draw(dc, m_fontNormal, FALSE, false) > rc.right)
                bDraw = false;
        }
        else
        {
            iterSelected = iter;
        }
    }

    ASSERT(iterSelected != m_tabList.end());

    /*
     * Bug 350942: selected tab shouldn't be bold
     */
    // draw selected tab last so it will be "on top" of the others
    iterSelected->Draw(dc, /*m_fontSelected*/ m_fontNormal, TRUE, bFocused);

    // draw border: line along the top edge, excluding seleted tab
    CPoint pts[4];
    CRect rcCurTab = iterSelected->GetRect();
    iterSelected->GetTrapezoid(&rcCurTab, pts);

    CPen blackPen(PS_SOLID, 1, GetSysColor(COLOR_WINDOWFRAME));

    CPen* pOldPen = dc.SelectObject(&blackPen);
    int y = pts[0].y;
    dc.MoveTo(rc.left,      y);
    dc.LineTo(pts[0].x,     y);
    dc.MoveTo(pts[3].x,     y);
    dc.LineTo(rc.right,     y);

    dc.SelectObject(pOldPen);
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::OnLButtonDown
 *
 * PURPOSE: Selects the tab pointed to on a left mouse click
 *
 * PARAMETERS:
 *    UINT    nFlags :
 *    CPoint  pt :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTabView::OnLButtonDown(UINT nFlags, CPoint pt)
{
    int iTab = HitTest(pt);
    if(iTab>=0 && iTab!=m_iCurItem)
    {
        SelectItem(iTab, true /*bEnsureVisible*/);
    }
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::HitTest
 *
 * PURPOSE: Computes which tab is at the specified point.
 *
 * PARAMETERS:
 *    CPoint  pt :
 *
 * RETURNS:
 *    int: The tab index, or -1 if none.
 *
 *+-------------------------------------------------------------------------*/
int
CFolderTabView::HitTest(CPoint pt)
{
    CRect rc;
    GetClientRect(&rc);
    if(rc.PtInRect(pt))
    {
        int i = 0;
        for( iterator iter= m_tabList.begin(); iter!= m_tabList.end(); ++iter, i++)
        {
            if(iter->HitTest(pt))
                return i;
        }
    }
    return -1;
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::SelectItem
 *
 * PURPOSE: Selects the iTab'th tab and returns the index of the tab selected,
 *          or -1 if an error occurred.
 *
 * PARAMETERS:
 *    int   iTab :
 *    bool  bEnsureVisible : If true, repositions the tab to make it visible.
 *
 * RETURNS:
 *    int
 *
 *+-------------------------------------------------------------------------*/
int
CFolderTabView::SelectItem(int iTab, bool bEnsureVisible)
{
    if(iTab<0 || iTab>=GetItemCount())
        return -1;      // bad

    bool bSendTabChanged = (iTab != m_iCurItem); // send a message only if a different item got selected

    // repaint the control
    m_iCurItem = iTab;              // set new selected tab
    if(bEnsureVisible)
        EnsureVisible(iTab);
    else
        RecomputeLayout();

    InvalidateRect(NULL, true);

    if(bSendTabChanged)
    {
		/*
		 * If the selection changed, fire the selection accessibility event.
		 * We do it before sending FTN_TABCHANGED so that if the FTN_TABCHANGED
		 * handler selects another item, observers will get the selection
		 * events in the right order (ignore errors)
		 */
		ScFireAccessibilityEvent (EVENT_OBJECT_SELECTION, m_iCurItem+1 /*1-based*/);

		/*
		 * if our window has the focus, focus changes with selection,
		 * so send focus event, too (ignore errors)
		 */
		if (m_fHaveFocus)
			ScFireAccessibilityEvent (EVENT_OBJECT_FOCUS, m_iCurItem+1 /*1-based*/);

        // send the FTN_TABCHANGED message
        NMFOLDERTAB nm;
        nm.hwndFrom = m_hWnd;
        nm.idFrom = GetDlgCtrlID();
        nm.code = FTN_TABCHANGED;
        nm.iItem = iTab;
        CWnd* pParent = GetParent();
        pParent->SendMessage(WM_NOTIFY, nm.idFrom, (LPARAM)&nm);
    }

    return m_iCurItem;
}


int
CFolderTabView::SelectItemByClsid(const CLSID& clsid)
{
    bool bFound = false;
    int i=0;
    for(iterator iter= m_tabList.begin(); iter!= m_tabList.end(); ++iter, i++)
    {
        if(IsEqualGUID(iter->GetClsid(),clsid))
        {
            bFound = true;
            break;
        }
    }

    if(!bFound)
    {
        ASSERT(0 && "Invalid folder tab.");
        return -1;
    }

    return SelectItem(i);
}


CFolderTab &
CFolderTabView::GetItem(int iPos)
{
    ASSERT(!(iPos<0 || iPos>=GetItemCount()));

    CFolderTabList::iterator iter = m_tabList.begin();
    std::advance(iter, iPos);
    return *iter;
}


int CFolderTabView::AddItem(LPCTSTR lpszText, const CLSID& clsid)
{
    CFolderTab tab;
    tab.SetText(lpszText);
    tab.SetClsid(clsid);
    tab.SetStyle(m_dwStyle);
    tab.SetTextHeight(m_textHeight);

    m_tabList.push_back(tab);

    RecomputeLayout();
    InvalidateRect(NULL, true);

	int nNewItemIndex = m_tabList.size() - 1;	// 0-based

	/*
	 * tell observers we created a new tab, after it's been created (ignore errors)
	 */
	ScFireAccessibilityEvent (EVENT_OBJECT_CREATE, nNewItemIndex+1 /*1-based*/);

    return (nNewItemIndex);
}

BOOL CFolderTabView::RemoveItem(int iPos)
{
    if( (iPos < 0) || (iPos>= m_tabList.size()) )
        return false;

    CFolderTabList::iterator iter = m_tabList.begin();
    std::advance(iter, iPos);
    m_tabList.erase(iter);

	/*
	 * tell observers we destroyed a tab, after it's been destroyed but before
	 * we might send selection/focus notifications in SelectItem (ignore errors)
	 */
	ScFireAccessibilityEvent (EVENT_OBJECT_DESTROY, iPos+1 /*1-based*/);

	/*
	 * If we're deleting the currently selected tab, the selection needs to
	 * move somewhere else.  If there are tabs following the current one,
	 * we'll move the selection to the next tab; otherwise, we'll move to
	 * the previous one.
	 */
	if ((iPos == m_iCurItem) && !m_tabList.empty())
	{
		/*
		 * if there are tabs to the following the one we just deleted,
		 * increment m_iCurItem so the subsequent call to SelectItem
		 * will recognize that the selection change and send the proper
		 * notifications.
		 */
		if (m_iCurItem < m_tabList.size())
			m_iCurItem++;

		SelectItem (m_iCurItem-1, true /*bEnsureVisible*/);
	}
	else
	{
		/*
		 * if we deleted a tab before the selected tab, decrement the
		 * selected tab index to keep things in sync
		 * m_iCurItem will become -1 when the last tab is removed, which is correct
		 */
		if (iPos <= m_iCurItem)
			m_iCurItem--;

		InvalidateRect(NULL, true);
		RecomputeLayout();
	}

    return true;
}

void CFolderTabView::DeleteAllItems()
{
	const int cChildren = m_tabList.size();
    m_tabList.clear();
	m_iCurItem = -1;		// nothing is selected

    InvalidateRect(NULL, true);
    RecomputeLayout();

	/*
	 * Tell accessibility observers that each tab is destroyed.  Notify
	 * in last-to-first order so IDs remain sane during this process.
	 */
	for (int idChild = cChildren /*1-based*/; idChild >= 1; idChild--)
	{
		ScFireAccessibilityEvent (EVENT_OBJECT_DESTROY, idChild);
	}

	/*
	 * If we have the focus, tell accessibility observers that the
	 * control itself has the focus.  We do this to be consistent with
	 * other controls (like the list view)
	 */
	if (m_fHaveFocus)
		ScFireAccessibilityEvent (EVENT_OBJECT_FOCUS, CHILDID_SELF);
}

void CFolderTabView::OnSize(UINT nType, int cx, int cy)
{
    m_sizeX = cx;
    m_sizeY = cy;

    CView::OnSize(nType, cx, cy);

    if (nType != SIZE_MINIMIZED)
	{
        RecomputeLayout();
	}

}


/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::ShowUpDownControl
 *
 * PURPOSE: Shows or hides the up/down control
 *
 * PARAMETERS:
 *    BOOL  bShow : true to show, false to hide.
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTabView::ShowUpDownControl(BOOL bShow)
{
    BOOL bVisible = (m_hWndUpDown != NULL) && ::IsWindowVisible(m_hWndUpDown); // was the up-down control visible previously?
    if(bShow)
    {
        if(!bVisible)
        {
            ::SendMessage(m_hWndUpDown, UDM_SETRANGE32, (WPARAM) 0 /*iLow*/, (LPARAM) m_tabList.size()-1 /*zero-based*/);
            ::SendMessage(m_hWndUpDown, UDM_SETPOS,     (WPARAM) 0,          (LPARAM) m_nPos /*nPos*/);
            ::ShowWindow(m_hWndUpDown, SW_SHOW);

            InvalidateRect(NULL, true);
        }
    }
    else
    {
        // hide the updown control
        if(m_hWndUpDown)
            ::ShowWindow(m_hWndUpDown, SW_HIDE);

        if(bVisible) // invalidate only on a transition from visible to invisible
            InvalidateRect(NULL, true);

		m_nPos = 0;
    }

}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::GetTotalTabWidth
 *
 * PURPOSE: Computes the total width of all the tabs.
 *
 * PARAMETERS:
 *    CClientDC& dc :
 *
 * RETURNS:
 *    int
 *
 *+-------------------------------------------------------------------------*/
int
CFolderTabView::GetTotalTabWidth(CClientDC& dc)
{
    int x = 0;

    // compute the width "as is", ie without taking into account the actual space available.
    for(iterator iter = m_tabList.begin(); iter!= m_tabList.end(); ++iter)
    {
        x += iter->ComputeRgn(dc, x) - GetXOffset();
    }

    return x;
}

/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::ComputeRegion
 *
 * PURPOSE: Computes the location and regions for all the tabs
 *
 * PARAMETERS:
 *    CClientDC& dc :
 *
 * RETURNS:
 *    int
 *
 *+-------------------------------------------------------------------------*/
int
CFolderTabView::ComputeRegion(CClientDC& dc)
{
    int x = GetTotalTabWidth(dc);

    // subtract the top-left x coordinate of the m_nPos'th tab from all x coordinates, thereby creating a shift
    iterator iter = m_tabList.begin();
    std::advance(iter, m_nPos); // advance to the m_nPos'th tab

    int xOffset = iter->GetRect().left;

	x = GetUpDownWidth() - xOffset; // shift everything to the left by xOffset

    for(iterator iterTemp = m_tabList.begin(); iterTemp!= m_tabList.end(); ++iterTemp)
    {
        x += iterTemp->ComputeRgn(dc, x) - GetXOffset();
    }

    return x;
}


/*+-------------------------------------------------------------------------*
 *
 * CFolderTabView::RecomputeLayout
 *
 * PURPOSE: Determines the location of all the tabs, and whether or not the
 *          up/down control should be displayed.
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CFolderTabView::RecomputeLayout()
{
	// set the size of the updown control
    if(m_hWndUpDown)
        ::SetWindowPos(m_hWndUpDown, NULL /*hWndInsertAfter*/, 0 /*left*/, 0 /*top*/,
                     GetUpDownWidth(), GetUpDownHeight(), SWP_NOMOVE| SWP_NOZORDER);

	// set the correct text height for the tabs
    for(iterator iterTemp = m_tabList.begin(); iterTemp!= m_tabList.end(); ++iterTemp)
		iterTemp->SetTextHeight(GetTextHeight());


    CClientDC dc(this);
    CFont* pOldFont = dc.SelectObject(&m_fontSelected); // use the bold font to compute with.

    int totalWidth = GetTotalTabWidth(dc); // the width of ALL tabs

    if(totalWidth <= m_sizeX)
    {
        // there's enough space to show all tabs. Hide the updown control
        ShowUpDownControl(false);
    }
    else
    {
        // not enough width for all tabs.
        BOOL bVisible = ::IsWindowVisible(m_hWndUpDown); // was the up-down control visible previously?

        if(!bVisible) // the up-down control was not visible, so make it visible.
        {
            m_nPos = 0;
            ShowUpDownControl(true);
        }

        ComputeRegion(dc); // make sure we leave space for the tab

    }

    dc.SelectObject(pOldFont);
}


void CFolderTabView::Layout(CRect& rectTotal, CRect& rectFTab)
{
    int cy = GetTabHeight() + GetExtraYSpace();
    rectFTab        = rectTotal;
    if(!IsVisible())
        return;

    rectFTab.top    = rectFTab.bottom - cy;
    rectTotal.bottom= rectFTab.top;
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::OnGetObject
 *
 * WM_GETOBJECT handler for CFolderTabView.
 *--------------------------------------------------------------------------*/

LRESULT CFolderTabView::OnGetObject (WPARAM wParam, LPARAM lParam)
{
	DECLARE_SC (sc, _T("CFolderTabView::OnGetObject"));

	/*
	 * ignore requests for objects other than OBJID_CLIENT
	 */
    if (lParam != OBJID_CLIENT)
	{
		Trace (tagTabAccessibility, _T("WM_GETOBJECT: (lParam != OBJID_CLIENT), returning 0"));
		return (0);
	}

	/*
	 * create our accessibility object
	 */
    if ((sc = CTiedComObjectCreator<CTabAccessible>::ScCreateAndConnect(*this, m_spTabAcc)).IsError() ||
		(sc = ScCheckPointers (m_spTabAcc, E_UNEXPECTED)).IsError())
	{
		sc.TraceAndClear();
		Trace (tagTabAccessibility, _T("WM_GETOBJECT: error creating IAccessible object, returning 0"));
		return (0);
	}

	/*
	 * return a pointer to the IAccessible interface
	 */
	Trace (tagTabAccessibility, _T("WM_GETOBJECT: returning IAccessible*"));
    return (LresultFromObject (IID_IAccessible, wParam, m_spTabAcc));
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accParent
 *
 * Retrieves the IDispatch interface of the object's parent.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accParent(IDispatch ** ppdispParent)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accParent"));
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accParent"));

	sc = ScCheckPointers (ppdispParent);
	if(sc)
		return (sc);

	/*
	 * return the accessibility interface for the OBJID_WINDOW object
	 */
	sc = AccessibleObjectFromWindow (m_hWnd, OBJID_WINDOW, IID_IDispatch,
									 (void **)ppdispParent);
	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accChildCount
 *
 * Retrieves the number of children belonging to this object.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accChildCount(long* pChildCount)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accChildCount"));

	sc = ScCheckPointers (pChildCount);
	if(sc)
		return (sc);

	*pChildCount = GetItemCount();
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accChildCount: returning %d"), GetItemCount());

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accChild
 *
 * Retrieves the address of an IDispatch interface for the specified child.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accChild(VARIANT varChildID, IDispatch ** ppdispChild)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accChild"));
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accChild"));

	sc = ScCheckPointers (ppdispChild);
	if (sc)
		return (sc);

	// init out parameter
	(*ppdispChild) = NULL;

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	/*
	 * all children are simple elements exposed through their parent,
	 * not accessible objects in their own right
	 */
	sc = S_FALSE;

	Trace (tagTabAccessibility, TEXT("returning parent's IDispatch for child %d"), ValueOf(varChildID));
	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accName
 *
 * Retrieves the name of the specified object.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accName(VARIANT varChildID, BSTR* pbstrName)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accName"));

	sc = ScCheckPointers (pbstrName);
	if(sc)
		return (sc);

	// init out parameter
	*pbstrName = NULL;

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	/*
	 * the tab control itself doesn't have a name; otherwise, get the
	 * name of the requested tab
	 */
	LONG idChild = ValueOf (varChildID);
	if (idChild == CHILDID_SELF)
	{
		sc = S_FALSE;
	}
	else
	{
		CFolderTab& tab = GetItem (idChild-1);
		CComBSTR bstrName (tab.GetText());
		*pbstrName = bstrName.Detach();
	}

#ifdef DBG
	USES_CONVERSION;
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accName: child %d, returning \"%s\""),
		   idChild,
		   (*pbstrName) ? W2T(*pbstrName) : _T("<None>"));
#endif

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accValue
 *
 * Retrieves the value of the specified object. Not all objects have a value.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accValue(VARIANT varChildID, BSTR* pbstrValue)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accValue"));
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accValue"));

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	/*
	 * tabs don't have values
	 */
	sc = S_FALSE;

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accDescription
 *
 * Retrieves a string that describes the visual appearance of the specified
 * object. Not all objects have a description.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accDescription(VARIANT varChildID, BSTR* pbstrDescription)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accDescription"));
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accDescription"));

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	/*
	 * tabs don't have descriptions
	 */
	sc = S_FALSE;

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accRole
 *
 * Retrieves information that describes the role of the specified object.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accRole(VARIANT varChildID, VARIANT *pvarRole)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accRole"));
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accRole"));

	sc = ScCheckPointers (pvarRole);
	if(sc)
		return (sc);

	// init out parameter
	VariantInit (pvarRole);

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	/*
	 * the tab control has a "page tab list" role; an individual tab has a
	 * "page tab" role
	 */
	V_VT(pvarRole) = VT_I4;
	V_I4(pvarRole) = (ValueOf (varChildID) == CHILDID_SELF)
						? ROLE_SYSTEM_PAGETABLIST
						: ROLE_SYSTEM_PAGETAB;

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accState
 *
 * Retrieves the current state of the specified object.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accState(VARIANT varChildID, VARIANT *pvarState)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accState"));

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	LONG idChild = ValueOf (varChildID);

	/*
	 * all items are focusable
	 */
	V_VT(pvarState) = VT_I4;
	V_I4(pvarState) = STATE_SYSTEM_FOCUSABLE;

	/*
	 * is this for a tab?
	 */
	if (idChild != CHILDID_SELF)
	{
		/*
		 * all tabs are selectable
		 */
		V_I4(pvarState) |= STATE_SYSTEM_SELECTABLE;

		/*
		 * if this is the selected item, give it the selected state
		 */
		if ((idChild - 1 /*1-based*/) == GetSelectedItem())
		{
			V_I4(pvarState) |= STATE_SYSTEM_SELECTED;

			/*
			 * if the tab control also has the focus, give the selected
			 * item the focused state as well
			 */
			if (m_fHaveFocus)
				V_I4(pvarState) |= STATE_SYSTEM_FOCUSED;
		}
	}
	else
	{
		if (m_fHaveFocus)
			V_I4(pvarState) |= STATE_SYSTEM_FOCUSED;
	}

	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accState: child %d, returning 0x%08x"), idChild, V_I4(pvarState));
	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accHelp
 *
 * Retrieves an object's Help property string. Not all objects need to
 * support this property.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accHelp(VARIANT varChildID, BSTR* pbstrHelp)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accHelp"));

	sc = ScCheckPointers (pbstrHelp);
	if (sc)
		return (sc);

	/*
	 * no help
	 */
	*pbstrHelp = NULL;

	sc = ScValidateChildID (varChildID);
	if (sc)
		return (sc);

	return (sc = S_FALSE);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accHelpTopic
 *
 * Retrieves the full path of the WinHelp file associated with the specified
 * object and the identifier of the appropriate topic within that file. Not
 * all objects need to support this property.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accHelpTopic(BSTR* pbstrHelpFile, VARIANT varChildID, long* pidTopic)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accHelpTopic"));

	sc = ScCheckPointers (pbstrHelpFile, pidTopic);
	if (sc)
		return (sc);

	/*
	 * no help topic
	 */
	*pbstrHelpFile = NULL;
	*pidTopic      = 0;

	sc = ScValidateChildID (varChildID);
	if (sc)
		return (sc);

	return (sc = S_FALSE);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accKeyboardShortcut
 *
 * Retrieves the specified object's shortcut key or access key (also known
 * as the mnemonic). All objects that have a shortcut key or access key
 * should support this property.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accKeyboardShortcut(VARIANT varChildID, BSTR* pbstrKeyboardShortcut)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accKeyboardShortcut"));

	sc = ScCheckPointers (pbstrKeyboardShortcut);
	if (sc)
		return (sc);

	/*
	 * no shortcut keys
	 */
	*pbstrKeyboardShortcut = NULL;

	sc = ScValidateChildID (varChildID);
	if (sc)
		return (sc);

	return (sc = S_FALSE);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accFocus
 *
 * Retrieves the object that has the keyboard focus.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accFocus(VARIANT * pvarFocusChild)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accFocus"));

	sc = ScCheckPointers (pvarFocusChild);
	if (sc)
		return (sc);

	/*
	 * if we have the focus, return the (1-based) ID of the selected tab;
	 * otherwise, return VT_EMPTY
	 */
	if (m_fHaveFocus)
	{
		V_VT(pvarFocusChild) = VT_I4;
		V_I4(pvarFocusChild) = GetSelectedItem() + 1;
		Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accFocus: returning %d"), V_I4(pvarFocusChild));
	}
	else
	{
		V_VT(pvarFocusChild) = VT_EMPTY;
		Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accFocus: returning VT_EMPTY"));
	}

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accSelection
 *
 * Retrieves the selected children of this object.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accSelection(VARIANT * pvarSelectedChildren)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accSelection"));

	sc = ScCheckPointers (pvarSelectedChildren);
	if (sc)
		return (sc);

	/*
	 * return the (1-based) ID of the selected tab, if there is one
	 */
	if (GetSelectedItem() != -1)
	{
		V_VT(pvarSelectedChildren) = VT_I4;
		V_I4(pvarSelectedChildren) = GetSelectedItem() + 1;
		Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accSelection: returning %d"), V_I4(pvarSelectedChildren));
	}
	else
	{
		V_VT(pvarSelectedChildren) = VT_EMPTY;
		Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accSelection: returning VT_EMPTY"));
	}

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scget_accDefaultAction
 *
 * Retrieves a string that describes the object's default action. Not all
 * objects have a default action.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scget_accDefaultAction(VARIANT varChildID, BSTR* pbstrDefaultAction)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scget_accDefaultAction"));

	sc = ScCheckPointers (pbstrDefaultAction);
	if (sc)
		return (sc);

	/*
	 * default to "no default action"
	 */
	*pbstrDefaultAction = NULL;

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	/*
	 * individual tabs have a default action of "Switch", just like WC_TABCONTROL
	 */
	if (ValueOf(varChildID) != CHILDID_SELF)
	{
		CString strDefaultAction (MAKEINTRESOURCE (IDS_TabAccessiblity_DefaultAction));
		CComBSTR bstrDefaultAction (strDefaultAction);

		*pbstrDefaultAction = bstrDefaultAction.Detach();
	}
	else
	{
		sc = S_FALSE;	// no default action
	}

#ifdef DBG
	USES_CONVERSION;
	Trace (tagTabAccessibility, TEXT("CFolderTabView::Scget_accDefaultAction: child %d, returning \"%s\""),
		   ValueOf(varChildID),
		   (*pbstrDefaultAction) ? W2T(*pbstrDefaultAction) : _T("<None>"));
#endif

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScaccSelect
 *
 * Modifies the selection or moves the keyboard focus of the specified
 * object.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScaccSelect(long flagsSelect, VARIANT varChildID)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::ScaccSelect"));
	Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccSelect"));

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	LONG idChild = ValueOf(varChildID);

	/*
	 * can't select the tab control itself, only child elements
	 */
	if (idChild == CHILDID_SELF)
		return (sc = E_INVALIDARG);

	/*
	 * the tab control doesn't support multiple selection, so reject
	 * requests dealing with multiple selection
	 */
	const long lInvalidFlags = SELFLAG_EXTENDSELECTION	|
							   SELFLAG_ADDSELECTION		|
							   SELFLAG_REMOVESELECTION;

	if (flagsSelect & lInvalidFlags)
		return (sc = E_INVALIDARG);

	/*
	 * activate this view, if we're requested to take the focus
	 */
	if (flagsSelect & SELFLAG_TAKEFOCUS)
	{
		CFrameWnd* pFrame = GetParentFrame();
		sc = ScCheckPointers (pFrame, E_FAIL);
		if (sc)
			return (sc);

		pFrame->SetActiveView (this);
	}

	/*
	 * select the given tab, if requested
	 */
	if (flagsSelect & SELFLAG_TAKESELECTION)
	{
		if (SelectItem (idChild - 1 /*0-based*/, true /*bEnsureVisible*/) == -1)
			return (sc = E_FAIL);
	}

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScaccLocation
 *
 * Retrieves the specified object's current screen location.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScaccLocation (
	long*	pxLeft,
	long*	pyTop,
	long*	pcxWidth,
	long*	pcyHeight,
	VARIANT	varChildID)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::ScaccLocation"));
	Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccLocation"));

	sc = ScCheckPointers (pxLeft, pyTop, pcxWidth, pcyHeight);
	if(sc)
		return (sc);

	// init out parameters
	*pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	LONG idChild = ValueOf(varChildID);
	CRect rectLocation;

	/*
	 * for the tab control itself, get the location of the entire window
	 */
	if (idChild == CHILDID_SELF)
		GetWindowRect (rectLocation);

	/*
	 * otherwise, get the rectangle of the tab and convert it to screen coords
	 */
	else
	{
		rectLocation = GetItem(idChild-1).GetRect();
		MapWindowPoints (NULL, rectLocation);
	}

	*pxLeft    = rectLocation.left;
	*pyTop     = rectLocation.top;
	*pcxWidth  = rectLocation.Width();
	*pcyHeight = rectLocation.Height();

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScaccNavigate
 *
 * Traverses to another user interface element within a container and if
 * possible, retrieves the object.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScaccNavigate (long lNavDir, VARIANT varStart, VARIANT * pvarEndUpAt)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::ScaccNavigate"));

	sc = ScCheckPointers (pvarEndUpAt);
	if (sc)
		return (sc);

	// init out parameters
	VariantInit (pvarEndUpAt);

	sc = ScValidateChildID (varStart);
	if (sc)
		return (sc);

	LONG idFrom = ValueOf (varStart);
	LONG idTo   = -1;

	Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccNavigate: start=%d, direction=%d"), idFrom, lNavDir);

	switch (lNavDir)
	{
		case NAVDIR_UP:
		case NAVDIR_DOWN:
			/*
			 * the tab control doesn't have the concept of up and down,
			 * so there's no screen element in that direction; just leave
			 * idTo == -1 and the code below the switch will take care
			 * of the rest
			 */
			break;

		case NAVDIR_FIRSTCHILD:
		case NAVDIR_LASTCHILD:
			/*
			 * NAVDIR_FIRSTCHILD and NAVDIR_LASTCHILD must be relative
			 * to CHILDID_SELF
			 */
			if (idFrom != CHILDID_SELF)
				return (sc = E_INVALIDARG);

			idTo = (lNavDir == NAVDIR_FIRSTCHILD) ? 1 : GetItemCount();
            break;

		case NAVDIR_LEFT:
		case NAVDIR_PREVIOUS:
			/*
			 * if we're moving relative to a child element, bump idTo;
			 * if not, just leave idTo == -1 and the code below the switch
			 * will take of the rest
			 */
			if (idFrom != CHILDID_SELF)
				idTo = idFrom - 1;
            break;

		case NAVDIR_RIGHT:
		case NAVDIR_NEXT:
			/*
			 * if we're moving relative to a child element, bump idTo;
			 * if not, just leave idTo == -1 and the code below the switch
			 * will take of the rest
			 */
			if (idFrom != CHILDID_SELF)
				idTo = idFrom + 1;
            break;

		default:
			return (sc = E_INVALIDARG);
			break;
	}

	/*
	 * if we're trying to navigate to an invalid child ID, return "no element
	 * in that direction"
	 */
	if ((idTo < 1) || (idTo > GetItemCount()))
	{
		V_VT(pvarEndUpAt) = VT_EMPTY;
		sc                = S_FALSE;
		Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccNavigate: VT_EMPTY"));
	}

	/*
	 * otherwise return the new child ID (don't change the selection here;
	 * the client will call IAccessible::accSelect to do that)
	 */
	else
	{
		V_VT(pvarEndUpAt) = VT_I4;
		V_I4(pvarEndUpAt) = idTo;
		Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccNavigate: end=%d"), idTo);
	}

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScaccHitTest
 *
 * Retrieves the child element or child object at a given point on the screen.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScaccHitTest (long x, long y, VARIANT* pvarChildAtPoint)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::ScaccHitTest"));

	sc = ScCheckPointers (pvarChildAtPoint);
	if(sc)
		return (sc);

	// init out parameters
	VariantInit (pvarChildAtPoint);

	/*
	 * hit-test the given point, converted to client coordinates
	 */
	CPoint pt (x, y);
	ScreenToClient (&pt);
	int nHitTest = HitTest (pt);
	Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccHitTest: x=%d y=%d"), x, y);

	/*
	 * not on a tab?  see if it's within the client rect
	 */
	if (nHitTest == -1)
	{
		CRect rectClient;
		GetClientRect (rectClient);

		if (rectClient.PtInRect (pt))
		{
			V_VT(pvarChildAtPoint) = VT_I4;
			V_I4(pvarChildAtPoint) = CHILDID_SELF;
		}
		else
		{
			V_VT(pvarChildAtPoint) = VT_EMPTY;
			sc                     = S_FALSE;		// no element there
		}
	}

	/*
	 * otherwise, it is on a tab; return the 1-based ID
	 */
	else
	{
		V_VT(pvarChildAtPoint) = VT_I4;
		V_I4(pvarChildAtPoint) = nHitTest + 1;
	}

#ifdef DBG
	if (V_VT(pvarChildAtPoint) == VT_I4)
		Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccHitTest: returning %d"), ValueOf (*pvarChildAtPoint));
	else
		Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccHitTest: returning VT_EMPTY"));
#endif

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScaccDoDefaultAction
 *
 * Performs the specified object's default action. Not all objects have a
 * default action.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScaccDoDefaultAction (VARIANT varChildID)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::ScaccDoDefaultAction"));

	sc = ScValidateChildID (varChildID);
	if(sc)
		return (sc);

	/*
	 * the tab control doesn't have a default action
	 */
	LONG idChild = ValueOf (varChildID);
	Trace (tagTabAccessibility, TEXT("CFolderTabView::ScaccDoDefaultAction: child %d"), idChild);
	if (idChild == CHILDID_SELF)
		return (sc = E_INVALIDARG);

	/*
	 * select the given tab item
	 */
	if (SelectItem (idChild - 1 /*0-based*/, true /*bEnsureVisible*/) == -1)
		return (sc = E_FAIL);

	return (sc);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scput_accName
 *
 * This is no longer supported. The SetWindowText or control-specific APIs
 * should be used in place of this method.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scput_accName(VARIANT varChildID, BSTR bstrName)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scput_accName"));

	sc = ScValidateChildID (varChildID);
	if (sc)
		return (sc);

	return (sc = E_NOTIMPL);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::Scput_accValue
 *
 * This is no longer supported. Control-specific APIs should be used in
 * place of this method.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::Scput_accValue(VARIANT varChildID, BSTR bstrValue)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::Scput_accValue"));

	sc = ScValidateChildID (varChildID);
	if (sc)
		return (sc);

	return (sc = E_NOTIMPL);
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScValidateChildID
 *
 * Determines if the supplied variant represents a valid child ID.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScValidateChildID (VARIANT &var)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::ScValidateChildID"));

	/*
	 * child IDs must be VT_I4's
	 */
	if (V_VT(&var) != VT_I4)
		return (sc = E_INVALIDARG);

	return (ScValidateChildID (ValueOf(var)));
}


/*+-------------------------------------------------------------------------*
 * CFolderTabView::ScValidateChildID
 *
 * Determines if the supplied ID is valid child ID.
 *--------------------------------------------------------------------------*/

SC CFolderTabView::ScValidateChildID (LONG idChild)
{
	DECLARE_SC (sc, TEXT("CFolderTabView::ScValidateChildID"));

	/*
	 * child ID must be either CHILDID_SELF or a valid tab index
	 */
	if ((idChild < CHILDID_SELF) || (idChild > GetItemCount()))
		return (sc = E_INVALIDARG);

	return (sc);
}