home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / oleaut / lines / enumvar.cpp < prev    next >
C/C++ Source or Header  |  1997-07-31  |  6KB  |  265 lines
  1. /*************************************************************************
  2. **
  3. **  This is a part of the Microsoft Source Code Samples.
  4. **
  5. **  Copyright (C) 1992-1997 Microsoft Corporation. All rights reserved.
  6. **
  7. **  This source code is only intended as a supplement to Microsoft Development
  8. **  Tools and/or WinHelp documentation.  See these sources for detailed
  9. **  information regarding the Microsoft samples programs.
  10. **
  11. **  OLE Automation Lines Object.
  12. **
  13. **  enumvar.cpp
  14. **
  15. **  CEnumVariant implementation
  16. **
  17. **  Written by Microsoft Product Support Services, Windows Developer Support
  18. **
  19. *************************************************************************/
  20.  
  21. #include <windows.h>
  22. #include <windowsx.h>
  23. #ifdef WIN16   
  24.   #include <ole2.h>
  25.   #include <compobj.h>    
  26.   #include <dispatch.h> 
  27.   #include <variant.h>
  28.   #include <olenls.h>  
  29. #endif      
  30. #include "lines.h"  
  31.  
  32. /*
  33.  * CEnumVariant::Create
  34.  *
  35.  * Purpose:
  36.  *  Creates an instance of the IEnumVARIANT enumerator object and initializes it.
  37.  *
  38.  * Parameters:
  39.  *  psa        Safe array containing items to be enumerated.
  40.  *  cElements  Number of items to be enumerated. 
  41.  *  ppenumvariant    Returns enumerator object.
  42.  *
  43.  * Return Value:
  44.  *  HRESULT
  45.  *
  46.  */
  47. HRESULT
  48. CEnumVariant::Create(SAFEARRAY FAR* psa, ULONG cElements, CEnumVariant FAR* FAR* ppenumvariant) 
  49. {   
  50.     HRESULT hr;
  51.     CEnumVariant FAR* penumvariant = NULL;
  52.     long lLBound;
  53.                       
  54.     *ppenumvariant = NULL;
  55.     
  56.     penumvariant = new CEnumVariant();
  57.     if (penumvariant == NULL)
  58.         goto error; 
  59.         
  60.     penumvariant->m_cRef = 0;
  61.     
  62.     // Copy elements into safe array that is used in enumerator implemenatation and 
  63.     // initialize state of enumerator.
  64.     hr = SafeArrayGetLBound(psa, 1, &lLBound);
  65.     if (FAILED(hr))
  66.         goto error;
  67.     penumvariant->m_cElements = cElements;    
  68.     penumvariant->m_lLBound = lLBound;
  69.     penumvariant->m_lCurrent = lLBound;                  
  70.     hr = SafeArrayCopy(psa, &penumvariant->m_psa);
  71.     if (FAILED(hr))
  72.        goto error;
  73.     
  74.     *ppenumvariant = penumvariant;
  75.     return NOERROR;
  76.     
  77. error: 
  78.     if (penumvariant == NULL)
  79.         return E_OUTOFMEMORY;   
  80.                               
  81.     if (penumvariant->m_psa) 
  82.         SafeArrayDestroy(penumvariant->m_psa);   
  83.     penumvariant->m_psa = NULL;     
  84.     delete penumvariant;
  85.     return hr;
  86. }
  87.  
  88. /*
  89.  * CEnumVariant::CEnumVariant
  90.  *
  91.  * Purpose:
  92.  *  Constructor for CEnumVariant object. Initializes members to NULL.
  93.  *
  94.  */
  95. CEnumVariant::CEnumVariant()
  96. {    
  97.     m_psa = NULL;
  98. }
  99.  
  100. /*
  101.  * CEnumVariant::~CEnumVariant
  102.  *
  103.  * Purpose:
  104.  *  Destructor for CEnumVariant object. 
  105.  *
  106.  */
  107. CEnumVariant::~CEnumVariant()
  108. {                   
  109.     if (m_psa) SafeArrayDestroy(m_psa);
  110. }
  111.  
  112. /*
  113.  * CEnumVariant::QueryInterface, AddRef, Release
  114.  *
  115.  * Purpose:
  116.  *  Implements IUnknown::QueryInterface, AddRef, Release
  117.  *
  118.  */
  119. STDMETHODIMP
  120. CEnumVariant::QueryInterface(REFIID iid, void FAR* FAR* ppv) 
  121. {   
  122.     *ppv = NULL;
  123.         
  124.     if (iid == IID_IUnknown || iid == IID_IEnumVARIANT) 
  125.         *ppv = this;     
  126.     else return E_NOINTERFACE; 
  127.  
  128.     AddRef();
  129.     return NOERROR;    
  130. }
  131.  
  132.  
  133. STDMETHODIMP_(ULONG)
  134. CEnumVariant::AddRef(void)
  135. {
  136.  
  137. #ifdef _DEBUG   
  138.     TCHAR ach[50];
  139.     wsprintf(ach, TEXT("Ref = %ld, Enum\r\n"), m_cRef+1); 
  140.     OutputDebugString(ach); 
  141. #endif  
  142.     
  143.     return ++m_cRef;  // AddRef Application Object if enumerator will outlive application object
  144. }
  145.  
  146.  
  147. STDMETHODIMP_(ULONG)
  148. CEnumVariant::Release(void)
  149. {
  150.  
  151. #ifdef _DEBUG   
  152.     TCHAR ach[50];
  153.     wsprintf(ach, TEXT("Ref = %ld, Enum\r\n"), m_cRef-1); 
  154.     OutputDebugString(ach); 
  155. #endif  
  156.     
  157.     if(--m_cRef == 0)
  158.     {
  159.         delete this;
  160.         return 0;
  161.     }
  162.     return m_cRef;
  163. }
  164.  
  165. /*
  166.  * CEnumVariant::Next
  167.  *
  168.  * Purpose:
  169.  *  Retrieves the next cElements elements. Implements IEnumVARIANT::Next. 
  170.  *
  171.  */
  172. STDMETHODIMP
  173. CEnumVariant::Next(ULONG cElements, VARIANT FAR* pvar, ULONG FAR* pcElementFetched)
  174. { 
  175.     HRESULT hr;
  176.     ULONG l;
  177.     long l1;
  178.     ULONG l2;
  179.     
  180.     if (pcElementFetched != NULL)
  181.         *pcElementFetched = 0;
  182.         
  183.     // Retrieve the next cElements elements.
  184.     for (l1=m_lCurrent, l2=0; l1<(long)(m_lLBound+m_cElements) && l2<cElements; l1++, l2++)
  185.     {
  186.        hr = SafeArrayGetElement(m_psa, &l1, &pvar[l2]); 
  187.        if (FAILED(hr))
  188.            goto error; 
  189.     }
  190.     // Set count of elements retrieved
  191.     if (pcElementFetched != NULL)
  192.         *pcElementFetched = l2;
  193.     m_lCurrent = l1;
  194.     
  195.     return  (l2 < cElements) ? S_FALSE : NOERROR;
  196.  
  197. error:
  198.     for (l=0; l<cElements; l++)
  199.         VariantClear(&pvar[l]);
  200.     return hr;    
  201. }
  202.  
  203. /*
  204.  * CEnumVariant::Skip
  205.  *
  206.  * Purpose:
  207.  *  Skips the next cElements elements. Implements IEnumVARIANT::Skip. 
  208.  *
  209.  */
  210. STDMETHODIMP
  211. CEnumVariant::Skip(ULONG cElements)
  212. {   
  213.     m_lCurrent += cElements; 
  214.     if (m_lCurrent > (long)(m_lLBound+m_cElements))
  215.     {
  216.         m_lCurrent =  m_lLBound+m_cElements;
  217.         return S_FALSE;
  218.     } 
  219.     else return NOERROR;
  220. }
  221.  
  222. /*
  223.  * CEnumVariant::Reset
  224.  *
  225.  * Purpose:
  226.  *  Resets the current element in the enumerator to the beginning. Implements IEnumVARIANT::Reset. 
  227.  *
  228.  */
  229. STDMETHODIMP
  230. CEnumVariant::Reset()
  231. { 
  232.     m_lCurrent = m_lLBound;
  233.     return NOERROR;
  234. }
  235.  
  236. /*
  237.  * CEnumVariant::Clone
  238.  *
  239.  * Purpose:
  240.  *  Creates a copy of the current enumeration state. Implements IEnumVARIANT::Clone. 
  241.  *
  242.  */
  243. STDMETHODIMP
  244. CEnumVariant::Clone(IEnumVARIANT FAR* FAR* ppenum)
  245. {
  246.     CEnumVariant FAR* penum = NULL;
  247.     HRESULT hr;
  248.     
  249.     *ppenum = NULL;
  250.     
  251.     hr = CEnumVariant::Create(m_psa, m_cElements, &penum);
  252.     if (FAILED(hr))
  253.         goto error;        
  254.     penum->AddRef();
  255.     penum->m_lCurrent = m_lCurrent; 
  256.     
  257.     *ppenum = penum;        
  258.     return NOERROR;
  259.      
  260. error:
  261.     if (penum)
  262.         penum->Release();
  263.     return hr;        
  264. }
  265.