ENUMCPP.CPP

/* 
 * ENUMCPP.CPP 
 * Enumerator in C++ Chapter 2 
 * 
 * Implements the CEnumRECT class 
 * 
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved 
 * 
 * Kraig Brockschmidt, Microsoft 
 * Internet  :  kraigb@microsoft.com 
 * Compuserve:  >INTERNET:kraigb@microsoft.com 
 */ 
 
 
#include "enumrect.h" 
 
 
/* 
 * CreateRECTEnumeratorCPP 
 * 
 * Purpose: 
 *  Creates an enumerator object returning an IEnumRECT interface. 
 * 
 * Parameters: 
 *  ppEnum          PENUMRECT * in which to return the 
 *                  interface pointer on the created object. 
 * 
 * Return Value: 
 *  BOOL            TRUE if the function is successful, 
 *                  FALSE otherwise. 
 */ 
 
BOOL CreateRECTEnumeratorCPP(PENUMRECT *ppEnum) 
    { 
    PCEnumRect  pER; 
    HRESULT     hr; 
 
    if (NULL==ppEnum) 
        return FALSE; 
 
    //Create the object 
    pER=new CEnumRect(); 
 
    if (NULL==pER) 
        return FALSE; 
 
    //Get the interface, which calls AddRef 
    hr=pER->QueryInterface(IID_IEnumRECT, (void **)ppEnum); 
    return SUCCEEDED(hr); 
    } 
 
 
 
 
 
/* 
 * CEnumRect::CEnumRect 
 * CEnumRect::~CEnumRect 
 * 
 * Constructor Parameters: 
 *  None 
 */ 
 
CEnumRect::CEnumRect(void) 
    { 
    UINT        i; 
 
    //Initialize the array of rectangles 
    for (i=0; i < CRECTS; i++) 
        SetRect(&m_rgrc[i], i, i*2, i*3, i*4); 
 
    //Ref counts always start at zero 
    m_cRef=0; 
 
    //Current pointer is the first element. 
    m_iCur=0; 
 
    return; 
    } 
 
 
CEnumRect::~CEnumRect(void) 
    { 
    return; 
    } 
 
 
 
 
/* 
 * CEnumRect::QueryInterface 
 * 
 * Purpose: 
 *  Manages interfaces for the CEnumRect object. 
 * 
 * Parameters: 
 *  riid            REFIID of the interface to return. 
 *  ppv             PPVOID in which to return the pointer. 
 * 
 * Return Value: 
 *  HRESULT         NOERROR if successful, E_NOINTERFACE if the 
 *                  interface is not supported. 
 */ 
 
STDMETHODIMP CEnumRect::QueryInterface(REFIID riid, PPVOID ppv) 
    { 
    //Always NULL the out-parameters 
    *ppv=NULL; 
 
    /* 
     * No explicit typecast necessary since we singly derive 
     * from IEnumRECT. 
     */ 
    if (IID_IUnknown==riid || IID_IEnumRECT==riid) 
        *ppv=this; 
 
    if (NULL==*ppv) 
        return ResultFromScode(E_NOINTERFACE); 
 
    //AddRef any interface we'll return. 
    ((LPUNKNOWN)*ppv)->AddRef(); 
    return NOERROR; 
    } 
 
 
 
 
/* 
 * CEnumRect::AddRef 
 * 
 * Purpose: 
 *  Increments the reference count on the object. 
 * 
 * Parameters: 
 *  None 
 * 
 * Return Value: 
 *  ULONG           New reference count. 
 */ 
 
STDMETHODIMP_(ULONG) CEnumRect::AddRef(void) 
    { 
    return ++m_cRef; 
    } 
 
 
 
 
 
 
/* 
 * CEnumRect::Release 
 * 
 * Purpose: 
 *  Indicates that someone on whose behalf we once AddRef'd has 
 *  finished with the object.  We decrement our reference count 
 *  and if zero, we delete the object. 
 * 
 * Parameters: 
 *  None 
 * 
 * Return Value: 
 *  ULONG           Current reference count after decrement.  If 
 *                  this returns zero then the interface is no 
 *                  longer valid. 
 */ 
 
STDMETHODIMP_(ULONG) CEnumRect::Release(void) 
    { 
    if (0!=--m_cRef) 
        return m_cRef; 
 
    delete this; 
    return 0; 
    } 
 
 
 
 
 
 
 
/* 
 * CEnumRect::Next 
 * 
 * Purpose: 
 *  Returns the next rectangle in the enumerator. 
 * 
 * Parameters: 
 *  cRect           DWORD number of RECTs to return 
 *  prc             LPRECT in which to store the returned RECT. 
 *  pdwRects        LPDWORD in which to store the number of 
 *                  structs returned. 
 * 
 * Return Value: 
 *  HRESULT         NOERROR if successful, S_FALSE otherwise, 
 */ 
 
STDMETHODIMP CEnumRect::Next(DWORD cRect, LPRECT prc, LPDWORD pdwRects) 
    { 
    DWORD           cRectReturn=0L; 
 
    if (NULL==pdwRects) 
        { 
        if (1L!=cRect) 
            return ResultFromScode(S_FALSE); 
        } 
    else 
        *pdwRects=0L; 
 
    if (NULL==prc || (m_iCur >= CRECTS)) 
        return ResultFromScode(S_FALSE); 
 
    while (m_iCur < CRECTS && cRect > 0) 
        { 
        *prc++=m_rgrc[m_iCur++]; 
        cRectReturn++; 
        cRect--; 
        } 
 
    if (NULL!=pdwRects) 
        *pdwRects=cRectReturn; 
 
    return NOERROR; 
    } 
 
 
 
 
 
/* 
 * CEnumRect::Skip 
 * 
 * Purpose: 
 *  Skips the next n elements in the enumerator. 
 * 
 * Parameters: 
 *  cSkip           DWORD number of elements to skip. 
 * 
 * Return Value: 
 *  HRESULT         NOERROR if successful, S_FALSE if we could not 
 *                  skip the requested number. 
 */ 
 
STDMETHODIMP CEnumRect::Skip(DWORD cSkip) 
    { 
    if ((m_iCur+cSkip) >= CRECTS) 
        return ResultFromScode(S_FALSE); 
 
    m_iCur+=cSkip; 
    return NOERROR; 
    } 
 
 
 
 
/* 
 * CEnumRect::Reset 
 * 
 * Purpose: 
 *  Resets the current element in the enumerator to zero. 
 * 
 * Parameters: 
 *  None 
 * 
 * Return Value: 
 *  HRESULT         NOERROR 
 */ 
 
STDMETHODIMP CEnumRect::Reset(void) 
    { 
    m_iCur=0; 
    return NOERROR; 
    } 
 
 
 
 
/* 
 * CImpEnumRECT::Clone 
 * 
 * Purpose: 
 *  Creates a copy enumerator. 
 * 
 * Parameters: 
 *  ppEnum          PENUMRECT * in which to store the clone. 
 * 
 * Return Value: 
 *  HRESULT         NOERROR if successful, error code otherwise. 
 */ 
 
STDMETHODIMP CEnumRect::Clone(PENUMRECT *ppEnum) 
    { 
    if (CreateRECTEnumeratorCPP(ppEnum)) 
        { 
        /* 
         * Copy the current index.  The typecast is safe because 
         * we know that the IEnumRECT from the creation function 
         * is really a CEnumRect pointer. 
         */ 
        ((PCEnumRect)(*ppEnum))->m_iCur=m_iCur; 
        return NOERROR; 
        } 
 
    return ResultFromScode(E_OUTOFMEMORY); 
    }