Windows编程

开发平台：
Visual C++

ABCTBL3.C：源码内容
							/***********************************************************************
 *
 *  ABCTBL3.C
 *
 *  Contents Table - Part 3.
 *
 *
 *  The following routines are implemented in this file.
 *
 *
 *      IVTABC_QueryInterface
 *      IVTABC_Release
 *      IVTABC_SortTable
 *      IVTABC_QuerySortOrder
 *      IVTABC_CreateBookmark
 *      IVTABC_FreeBookmark
 *      IVTABC_ExpandRow
 *      IVTABC_ColapseRow
 *      IVTABC_WaitForCompletion
 *      IVTABC_Abort
 *      IVTABC_Advise
 *      IVTABC_Unadvise
 *      IVTABC_GetStatus
 *      IVTABC_SetColumns
 *      IVTABC_QueryColumns
 *      IVTABC_GetCollapseState,
 *      IVTABC_SetCollapseState,
 *
 *  Copyright 1992-1995 Microsoft Corporation.  All Rights Reserved.
 *
 ***********************************************************************/
#include "abp.h"
#include "abctbl.h"
#include "sampabp.rh"
/*
 *  Default sort order set
 */
static const SizedSSortOrderSet(1, sosIVTABC) =
{
    1,
    0,
    0,
    {
        {
            PR_DISPLAY_NAME_A, TABLE_SORT_ASCEND
        }
    }
};
/*************************************************************************
 *
 *
 -  AVTABC_QueryInterface
 -
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_QueryInterface(LPIVTABC lpIVTAbc,
    REFIID lpiid,
    LPVOID FAR * lppNewObj)
{
    HRESULT hResult = hrSuccess;
    IVTABC_ValidateObject(QueryInterface, lpIVTAbc);
    Validate_IUnknown_QueryInterface(lpIVTAbc, lpiid, lppNewObj);
    
    /*  See if the requested interface is one of ours */
    if (memcmp(lpiid, &IID_IUnknown, sizeof(IID)) &&
        memcmp(lpiid, &IID_IMAPITable, sizeof(IID)))
    {
        *lppNewObj = NULL;      /* OLE requires zeroing the [out] parameter */
        DebugTraceSc(IVTABC_QueryInterface, E_NOINTERFACE);
        return ResultFromScode(E_NOINTERFACE);
    }
    /*  We'll do this one. Bump the usage count and return a new pointer. */
    EnterCriticalSection(&lpIVTAbc->cs);
    ++lpIVTAbc->lcInit;
    LeaveCriticalSection(&lpIVTAbc->cs);
    
    *lppNewObj = lpIVTAbc;
    DebugTraceResult(IVTABC_QueryInterface,hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_Release
 -
 *
 *      Decrement the reference count on this object and free it if
 *      the reference count is zero.
 *      Returns the reference count.
 */
STDMETHODIMP_(ULONG)
IVTABC_Release(LPIVTABC lpIVTAbc)
{
    ULONG ulBK;
    long lcInit;
    
    /*
     *  Check to see if it's big enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, sizeof(IVTABC)))
    {
        /*
         *  Not large enough
         */
        return 1;
    }
    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        return 1;
    }
    Validate_IUnknown_Release(lpIVTAbc);
    EnterCriticalSection(&lpIVTAbc->cs);
    lcInit = --lpIVTAbc->lcInit;
    LeaveCriticalSection(&lpIVTAbc->cs);
    if (lcInit == 0)
    {
        /*
         *  Free up the current column set
         */
        if (lpIVTAbc->lpPTAColSet != ptagaivtabcColSet)
        {
            lpIVTAbc->lpFreeBuff (lpIVTAbc->lpPTAColSet);
        }
        /*
         *  Close up the file
         */
        if (lpIVTAbc->hFile != INVALID_HANDLE_VALUE)
        {
            CloseHandle(lpIVTAbc->hFile);
            lpIVTAbc->hFile = INVALID_HANDLE_VALUE;
        }
        /*
         *  Free up the file name
         */
        lpIVTAbc->lpFreeBuff(lpIVTAbc->lpszFileName);
        /*
         *  Rip through the bookmarks and free up any that are there
         */
        for (ulBK = 0; ulBK < MAX_BOOKMARKS; ulBK++)
            if (lpIVTAbc->rglpABCBK[ulBK])
            {
                (*(lpIVTAbc->lpFreeBuff)) (lpIVTAbc->rglpABCBK[ulBK]);
                lpIVTAbc->rglpABCBK[ulBK] = NULL;
            }
        /*
         *  Free up the ANR stuff, if used
         */
        lpIVTAbc->lpFreeBuff (lpIVTAbc->lpszPartialName);
        FreeANRBitmaps(lpIVTAbc);
        /*
         *  Free up the advise list, if used
         */
        if (lpIVTAbc->parglpAdvise)
            lpIVTAbc->lpMalloc->lpVtbl->Free(lpIVTAbc->lpMalloc, lpIVTAbc->parglpAdvise);
        /*  
         *  Release our reference to the ABLogon object.
         */
        if (lpIVTAbc->lpABLogon)
        {
            lpIVTAbc->lpABLogon->lpVtbl->Release(lpIVTAbc->lpABLogon);
            lpIVTAbc->lpABLogon = NULL;
        }
        /* Delete critical section for this object */
        DeleteCriticalSection(&lpIVTAbc->cs);
        /* Deregister the idle routine */
        DeregisterIdleRoutine(lpIVTAbc->ftg);
        /*
         *  Set the vtbl to NULL.  This way the client will find out
         *  real fast if it's calling a method on a released object.  That is,
         *  the client will crash.  Hopefully, this will happen during the
         *  development stage of the client.
         */
        lpIVTAbc->lpVtbl = NULL;
        /*
         *  Need to free the object
         */
        lpIVTAbc->lpFreeBuff(lpIVTAbc);
        return 0;
    }
    return lcInit;
}
/*
 -  IVTABC_SortTable
 -
 *  The Sample Address Book does not resort it's views.
 *
 */
STDMETHODIMP 
IVTABC_SortTable(LPIVTABC lpIVTAbc,
    LPSSortOrderSet lpSortCriteria,
    ULONG ulFlags)
{
    HRESULT hResult;
    /*
     *  Validate parameters
     */
    IVTABC_ValidateObject(SortTable, lpIVTAbc);
    
    Validate_IMAPITable_SortTable(lpIVTAbc, lpSortCriteria, ulFlags);
    /*
     *  We don't support sorting this table
     */
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
    DebugTraceResult(IVTABC_SortTable, hResult);
    return hResult;
}
/*
 -  IVTABC_QuerySortOrder
 -
 *
 *  For this implementation there is only one sort order
 */
STDMETHODIMP 
IVTABC_QuerySortOrder(LPIVTABC lpIVTAbc,
    LPSSortOrderSet * lppSortCriteria)
{
    SCODE scode;
    HRESULT hResult = hrSuccess;
    int cbSize;
    /*
     *  Validate parameters
     */
    IVTABC_ValidateObject(QuerySortOrder, lpIVTAbc);
    Validate_IMAPITable_QuerySortOrder(lpIVTAbc, lppSortCriteria);
    /*  Calculate size of the structure we're gonna copy */
    cbSize = CbNewSSortOrderSet((int)sosIVTABC.cSorts);
    scode = lpIVTAbc->lpAllocBuff(cbSize, (LPVOID *) lppSortCriteria);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);
        goto out;
    }
    /*
     *  Copy the column set in
     */
    if (cbSize)
        memcpy(*lppSortCriteria, &sosIVTABC, cbSize);
out:
    DebugTraceResult(IVTABC_QuerySortOrder, hResult);
    return hResult;
}
/*
 -  IVTABC_CreateBookmark
 -
 *  Creates a bookmark associated with a row in a table
 *
 */
STDMETHODIMP 
IVTABC_CreateBookmark(LPIVTABC lpIVTAbc,
    BOOKMARK * lpbkPosition)
{
    SCODE scode;
    HRESULT hResult = hrSuccess;
    ULONG ulBK;
    LPABCBK lpABCBK = NULL;
    ULONG cbRead = 0;
    /*
     *  Validate parameters
     */
    IVTABC_ValidateObject(CreateBookmark, lpIVTAbc);
    Validate_IMAPITable_CreateBookmark(lpIVTAbc, lpbkPosition);
    EnterCriticalSection(&lpIVTAbc->cs);
    /*
     *  Open the file
     */
    hResult = HrOpenFile(lpIVTAbc);
    if (HR_FAILED(hResult))
    {
        goto out;
    }
    /*
     *  Shortcuts first
     */
    if (lpIVTAbc->ulPosition == lpIVTAbc->ulMaxPos)
    {
        *lpbkPosition = BOOKMARK_END;
        return hrSuccess;
    }
    /*
     *  search for a blank bookmark
     */
    for (ulBK = 0; lpIVTAbc->rglpABCBK[ulBK] && ulBK < MAX_BOOKMARKS; ulBK++);
    /*  did we find any??  */
    if (ulBK == MAX_BOOKMARKS)
    {
        hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
        goto out;
    }
    scode = lpIVTAbc->lpAllocBuff (sizeof(ABCBK),(LPVOID *) &lpABCBK);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);
        goto out;
    }
    /*
     *  Fill in new bookmark
     */
    lpABCBK->filetime = lpIVTAbc->filetime;
    lpABCBK->ulPosition = lpIVTAbc->ulPosition;
    /*  Seek to position in file  */
    (void) SetFilePointer(lpIVTAbc->hFile, lpABCBK->ulPosition, NULL, FILE_BEGIN);
    /*  Read in the record at that location  */
    if (!ReadFile(lpIVTAbc->hFile,
            (LPVOID) &(lpABCBK->abcrec), sizeof(ABCREC), &cbRead, NULL))
    {
        goto readerror;
    }
    /*  Second check  */
    if (cbRead != sizeof(ABCREC))
    {
        goto readerror;
    }
    /*
     *  Put this in the bookmark structure
     */
    lpIVTAbc->rglpABCBK[ulBK] = lpABCBK;
    /*  Return the bookmark  */
    *lpbkPosition = ulBK + 3;
out:
    LeaveCriticalSection(&lpIVTAbc->cs);
    DebugTraceResult(IVTABC_CreateBookmark, hResult);
    return hResult;
readerror:
    /*
     *  Didn't get the record.
     */
    /*  Restore back to original position  */
    (void) SetFilePointer(lpIVTAbc->hFile, lpIVTAbc->ulPosition, NULL, FILE_BEGIN);
    /*  Free up the new bookmark  */
    lpIVTAbc->lpFreeBuff(lpABCBK);
    hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
    SetErrorIDS(lpIVTAbc, hResult, IDS_SAB_NO_READ);
    goto out;
}
/*************************************************************************
 *
 -  IVTABC_FreeBookmark
 -
 *  Frees up the given bookmark
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_FreeBookmark(LPIVTABC lpIVTAbc,
    BOOKMARK bkPosition)
{
    HRESULT hResult = hrSuccess;
    /*
     *  Validate parameters
     */
    IVTABC_ValidateObject(FreeBookmark, lpIVTAbc);
    Validate_IMAPITable_FreeBookmark(lpIVTAbc, bkPosition);
    EnterCriticalSection(&lpIVTAbc->cs);
    /*
     *  Don't try and free up any of the standard bookmarks
     */
    if ((bkPosition != BOOKMARK_BEGINNING) &&
        (bkPosition != BOOKMARK_CURRENT) &&
        (bkPosition != BOOKMARK_END))
    {
        ULONG ulBK = (ULONG) bkPosition - 3;
        /*
         *  See if it's in range
         */
        if (ulBK >= 0 && ulBK < MAX_BOOKMARKS)
        {
            LPABCBK lpABCBK = NULL;
            /*  If it's valid...  */
            if (lpABCBK = lpIVTAbc->rglpABCBK[ulBK])    /* '=' on purpose */
            {
                /*  ...free it up.  */
                lpIVTAbc->lpFreeBuff(lpABCBK);
                lpIVTAbc->rglpABCBK[ulBK] = NULL;
            }
        }
        else
        {
            /*
             * It's an error
             */
            hResult = ResultFromScode(E_INVALIDARG);
        }
    }
    LeaveCriticalSection(&lpIVTAbc->cs);
    DebugTraceResult(IVTABC_FreeBookmark, hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_ExpandRow
 -
 *  Stubbed out.  This table doesn't implement catagorization.
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_ExpandRow(LPIVTABC lpIVTAbc, ULONG cbIKey, LPBYTE pbIKey,
    ULONG ulRowCount, ULONG ulFlags, LPSRowSet FAR * lppRows,
    ULONG FAR * lpulMoreRows)
{
    HRESULT hResult;
    /*
     *  Validate parameters
     */
    IVTABC_ValidateObject(ExpandRow, lpIVTAbc);
    Validate_IMAPITable_ExpandRow(lpIVTAbc,  cbIKey,  pbIKey,
                            ulRowCount,  ulFlags,  lppRows, lpulMoreRows);
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
    DebugTraceResult(IVTABC_ExpandRow, hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_CollapseRow
 -
 *  Stubbed out.  This table doesn't implement catagorization.
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_CollapseRow(LPIVTABC lpIVTAbc, ULONG cbIKey, LPBYTE pbIKey,
    ULONG ulFlags, ULONG FAR * lpulRowCount)
{
    HRESULT hResult;
    /*
     *  Validate parameters
     */
    IVTABC_ValidateObject(CollapseRow, lpIVTAbc);
    Validate_IMAPITable_CollapseRow(lpIVTAbc, cbIKey, pbIKey, ulFlags, lpulRowCount);
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
    DebugTraceResult(IVTABC_CollapseRow, hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_WaitForCompletion
 -
 *  Stubbed out.
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_WaitForCompletion(LPIVTABC lpIVTAbc, ULONG ulFlags,
    ULONG ulTimeout, ULONG FAR * lpulTableStatus)
{
    HRESULT hResult;
    IVTABC_ValidateObject(WaitForCompletion, lpIVTAbc);
    
    Validate_IMAPITable_WaitForCompletion(lpIVTAbc, ulFlags, ulTimeout, 
                                            lpulTableStatus);
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
    DebugTraceResult(IVTABC_WaitForCompletion, hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_Abort
 -
 *  Nothing ever to abort...
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_Abort(LPIVTABC lpIVTAbc)
{
    /*
     *  Validate parameters
     */
    IVTABC_ValidateObject(Abort, lpIVTAbc);
    Validate_IMAPITable_Abort(lpIVTAbc);
    return hrSuccess;
}
/*************************************************************************
 *
 *
 -  IVTABC_Advise
 -
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_Advise(LPIVTABC lpIVTAbc,
    ULONG ulEventmask,
    LPMAPIADVISESINK lpAdviseSink,
    ULONG FAR * lpulConnection)
{
    HRESULT hResult = hrSuccess;
    UINT iAdvise;
    
    /*
     *  Validate the parameters
     */
    
    IVTABC_ValidateObject(Advise, lpIVTAbc);
    
    Validate_IMAPITable_Advise(lpIVTAbc, ulEventmask, lpAdviseSink,
                                lpulConnection);
    
    /* Get the Critical Section */
    EnterCriticalSection(&lpIVTAbc->cs);
    for (iAdvise = 0;
        lpIVTAbc->parglpAdvise && iAdvise < lpIVTAbc->cAdvise;
        ++iAdvise)
    {
        if (lpIVTAbc->parglpAdvise[iAdvise] == NULL)
            break;
    }
    if (iAdvise >= lpIVTAbc->cAdvise)
    {
        /*
         *   Realloc the array if it exists
         */
        if (lpIVTAbc->parglpAdvise)
        {
            lpIVTAbc->parglpAdvise = lpIVTAbc->lpMalloc->lpVtbl->Realloc(
                lpIVTAbc->lpMalloc,
                lpIVTAbc->parglpAdvise,
                (lpIVTAbc->cAdvise + 1) * sizeof(LPMAPIADVISESINK));
        }
        else
        {
            lpIVTAbc->parglpAdvise = lpIVTAbc->lpMalloc->lpVtbl->Alloc(
                lpIVTAbc->lpMalloc,
                (lpIVTAbc->cAdvise + 1) * sizeof(LPMAPIADVISESINK));
        }
        /*
         *  Could we get the desired memory?
         */
        if (lpIVTAbc->parglpAdvise == NULL)
        {
            hResult = MakeResult(E_OUTOFMEMORY);
            goto ret;
        }
    }
    lpIVTAbc->cAdvise++;
    *lpulConnection = lpIVTAbc->ulConnectMic + iAdvise;
    lpIVTAbc->parglpAdvise[iAdvise] = lpAdviseSink;
    lpAdviseSink->lpVtbl->AddRef(lpAdviseSink);
ret:
    /* leave critical section */
    LeaveCriticalSection(&lpIVTAbc->cs);
    DebugTraceResult(IVTABC_Advise, hResult);
    return hResult;
}
/*************************************************************************
 *
 *
 -  IVTABC_Unadvise
 -
 *
 *
 *
 */
STDMETHODIMP 
IVTABC_Unadvise(LPIVTABC lpIVTAbc, ULONG ulConnection)
{
    LPMAPIADVISESINK padvise;
    UINT iAdvise;
    HRESULT hResult = hrSuccess;
    IVTABC_ValidateObject(Unadvise, lpIVTAbc);
    Validate_IMAPITable_Unadvise(lpIVTAbc, ulConnection);
    if (ulConnection - lpIVTAbc->ulConnectMic > (ULONG) lpIVTAbc->cAdvise)
    {
        DebugTraceSc(IVTABC_Unadvise, E_INVALIDARG);
        return ResultFromScode(E_INVALIDARG);
    }
    /* Get the Critical Section */
    EnterCriticalSection(&lpIVTAbc->cs);
    iAdvise = (UINT) (ulConnection - lpIVTAbc->ulConnectMic);
    padvise = lpIVTAbc->parglpAdvise[iAdvise];
    padvise->lpVtbl->Release(padvise);
    lpIVTAbc->parglpAdvise[iAdvise] = NULL;
    lpIVTAbc->cAdvise--;
    /* leave critical section */
    LeaveCriticalSection(&lpIVTAbc->cs);
    DebugTraceResult(IVTABC_Unadvise, hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_GetStatus
 -
 *  Returns the status of this table.  This table really isn't
 *  dynamic yet, but it could be...
 *
 *
 */
STDMETHODIMP 
IVTABC_GetStatus(LPIVTABC lpIVTAbc,
    ULONG * lpulTableStatus,
    ULONG * lpulTableType)
{
    /*
     *  Parameter checking
     */
    IVTABC_ValidateObject(GetStatus, lpIVTAbc);
    Validate_IMAPITable_GetStatus(lpIVTAbc, lpulTableStatus, lpulTableType);
    *lpulTableStatus = TBLSTAT_COMPLETE;
    *lpulTableType = TBLTYPE_DYNAMIC;
    return hrSuccess;
}
/*************************************************************************
 *
 -  IVTABC_SetColumns
 -
 *
 *  SetColumns for contents table.
 *
 */
STDMETHODIMP 
IVTABC_SetColumns(LPIVTABC lpIVTAbc,
    LPSPropTagArray lpPTAColSet,
    ULONG ulFlags)
{
    SCODE scode;
    HRESULT hResult = hrSuccess;
    int cbSizeOfColSet;
    LPSPropTagArray lpPTAColSetT;
    ULONG uliCol;
    /*
     *  Check parameters
     */
    IVTABC_ValidateObject(SetColumns, lpIVTAbc);
    
    Validate_IMAPITable_SetColumns(lpIVTAbc, lpPTAColSet, ulFlags);
    /*
     *  Verify that there are no PT_ERRORs here...
     */
    for (uliCol = 0; uliCol < lpPTAColSet->cValues; uliCol++)
    {
        if (PROP_TYPE(lpPTAColSet->aulPropTag[uliCol]) == PT_ERROR)
        {
            hResult = ResultFromScode(E_INVALIDARG);
            DebugTraceResult(IVTABC_GetStatus, hResult);
            return hResult;
        }
    }
    /*
     *  Allocate a new column set.
     */
    cbSizeOfColSet = CbNewSPropTagArray(lpPTAColSet->cValues);
    scode = lpIVTAbc->lpAllocBuff(cbSizeOfColSet,(LPVOID *) &lpPTAColSetT);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);
        DebugTraceResult(IVTABC_GetStatus, hResult);
        return hResult;
    }
    /*
     *  Copy the column set in
     */
    if (cbSizeOfColSet)
        memcpy(lpPTAColSetT, lpPTAColSet, cbSizeOfColSet);
    EnterCriticalSection(&lpIVTAbc->cs);
    if (lpIVTAbc->lpPTAColSet != ptagaivtabcColSet)
    {
        /*
         *  Free up the old column set
         */
        lpIVTAbc->lpFreeBuff(lpIVTAbc->lpPTAColSet);
    }
    lpIVTAbc->lpPTAColSet = lpPTAColSetT;
    LeaveCriticalSection(&lpIVTAbc->cs);
    
    return hrSuccess;
}
/*************************************************************************
 *
 -  IVTABC_QueryColumns
 -
 *
 *
 *  I always have all my columns available...  and active.
 */
STDMETHODIMP 
IVTABC_QueryColumns(LPIVTABC lpIVTAbc,
    ULONG ulFlags,
    LPSPropTagArray FAR * lppColumns)
{
    SCODE scode;
    HRESULT hResult = hrSuccess;
    int cbSizeOfColSet;
    /*
     *  Check parameters
     */
    IVTABC_ValidateObject(QueryColumns, lpIVTAbc);
    Validate_IMAPITable_QueryColumns(lpIVTAbc, ulFlags, lppColumns);
    EnterCriticalSection(&lpIVTAbc->cs);
    /*
     *  Allocate enough memory for the column set
     */
    if (ulFlags & TBL_ALL_COLUMNS)
        cbSizeOfColSet = sizeof(ULONG) +
            (int)(ptagaivtabcColSet->cValues) * sizeof(ULONG);
    else
        cbSizeOfColSet = sizeof(ULONG) +
            (int)lpIVTAbc->lpPTAColSet->cValues * sizeof(ULONG);
    scode = lpIVTAbc->lpAllocBuff (cbSizeOfColSet,(LPVOID *) lppColumns);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);
        goto out;
    }
    /*
     *  Copy the column set in
     */
    if (ulFlags & TBL_ALL_COLUMNS)
        memcpy(*lppColumns, ptagaivtabcColSet, cbSizeOfColSet);
    else
        memcpy(*lppColumns, lpIVTAbc->lpPTAColSet, cbSizeOfColSet);
out:
    LeaveCriticalSection(&lpIVTAbc->cs);
    DebugTraceResult(IVTABC_QueryColumns, hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_GetCollapseState
 -
 *  Stubbed out.  Only necessary if this table were to support categorization.
 *
 *
 *
 */
STDMETHODIMP
IVTABC_GetCollapseState(LPIVTABC lpIVTAbc,
                        ULONG ulFlags,
                        ULONG cbInstanceKey,
                        LPBYTE pbInstanceKey,
                        ULONG FAR * lpcbCollapseState,
                        LPBYTE FAR * lppbCollapseState)
{
    HRESULT hResult;
    /*
     *  Check parameters
     */
    IVTABC_ValidateObject(GetCollapseState, lpIVTAbc);
    Validate_IMAPITable_GetCollapseState(lpIVTAbc, ulFlags, cbInstanceKey,
                                        pbInstanceKey, lpcbCollapseState,
                                        lppbCollapseState);
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
    DebugTraceResult(IVTABC_GetCollapseState, hResult);
    return hResult;
}
/*************************************************************************
 *
 -  IVTABC_SetCollapseState
 -
 *  Stubbed out.  Only necessary if this table were to support categorization.
 *
 *
 *
 */
STDMETHODIMP
IVTABC_SetCollapseState(LPIVTABC lpIVTAbc,
                        ULONG ulFlags,
                        ULONG cbCollapseState,
                        LPBYTE pbCollapseState,
                        BOOKMARK FAR * lpbkLocation)
{
    HRESULT hResult;
    /*
     *  Check parameters
     */
    IVTABC_ValidateObject(SetCollapseState, lpIVTAbc);
    Validate_IMAPITable_SetCollapseState(lpIVTAbc, ulFlags, cbCollapseState,
                                        pbCollapseState, lpbkLocation);
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
    DebugTraceResult(IVTABC_SetCollapseState, hResult);
    return hResult;
}

						