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 / points.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-01  |  14.3 KB  |  581 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 Points object
  12. **
  13. **  points.cpp
  14. **
  15. **  CPoints collection 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.  * CPoints::Create
  34.  *
  35.  * Purpose:
  36.  *  Creates an instance of a collection object and initializes it.
  37.  *
  38.  * Parameters:
  39.  *  lMaxSize   Maximum number of items that can added to collection.
  40.  *  lLBound    Lower bound of index of collection.  
  41.  *  pPane      Pointer to pane that contains this collection. Required because the pane coordinates 
  42.  *             the lines and points collection.
  43.  *  ppPoints    Returns collection object.
  44.  *
  45.  * Return Value:
  46.  *  HRESULT
  47.  *
  48.  */
  49. HRESULT 
  50. CPoints::Create(ULONG lMaxSize, long lLBound, CPane FAR* pPane, CPoints FAR* FAR* ppPoints) 
  51. {   
  52.     HRESULT hr;
  53.     CPoints FAR* pPoints = NULL;
  54.     SAFEARRAYBOUND sabound[1];
  55.      
  56.     *ppPoints = NULL;
  57.     
  58.     // Create new collection
  59.     pPoints = new CPoints();
  60.     if (pPoints == NULL)
  61.         goto error;
  62.     
  63.     pPoints->m_cMax = lMaxSize;
  64.     pPoints->m_cElements = 0; 
  65.     pPoints->m_lLBound = lLBound;     
  66.     pPoints->m_pPane = pPane;  
  67.     
  68.     // Load type information for the points collection from type library. 
  69.     hr = LoadTypeInfo(&pPoints->m_ptinfo, IID_IPoints);
  70.     if (FAILED(hr))
  71.         goto error;
  72.     
  73.     // Create a safe array which is used to implement the collection.            
  74.     sabound[0].cElements = lMaxSize;
  75.     sabound[0].lLbound = lLBound;        
  76.     pPoints->m_psa = SafeArrayCreate(VT_VARIANT, 1, sabound);
  77.     if (pPoints->m_psa == NULL)
  78.     {
  79.         hr = E_OUTOFMEMORY;
  80.         goto error;
  81.     }             
  82.  
  83.     *ppPoints = pPoints;
  84.     return NOERROR;
  85.     
  86. error: 
  87.     if (pPoints == NULL)
  88.         return E_OUTOFMEMORY;
  89.     if (pPoints->m_ptinfo)
  90.         pPoints->m_ptinfo->Release();                            
  91.     if (pPoints->m_psa) 
  92.         SafeArrayDestroy(pPoints->m_psa); 
  93.   
  94.     pPoints->m_psa = NULL;
  95.     pPoints->m_ptinfo = NULL; 
  96.     
  97.     delete pPoints;
  98.     return hr;
  99. }
  100.  
  101. /*
  102.  * CPoints::CPoints
  103.  *
  104.  * Purpose:
  105.  *  Constructor for CPoints object. Initializes members to NULL.
  106.  *
  107.  */
  108. #pragma warning (disable : 4355)
  109. CPoints::CPoints() : m_SupportErrorInfo(this, IID_IPoints)
  110. #pragma warning (default : 4355)
  111. {    
  112.     m_cRef = 0;
  113.     m_psa = NULL;
  114.     m_ptinfo = NULL; 
  115. }
  116.  
  117. /*
  118.  * CPoints::~CPoints
  119.  *
  120.  * Purpose:
  121.  *  Destructor for CPoints object. 
  122.  *
  123.  */
  124. CPoints::~CPoints()
  125. {    
  126.      if (m_ptinfo) m_ptinfo->Release();                   
  127.      if (m_psa) SafeArrayDestroy(m_psa);
  128. }
  129.  
  130. /*
  131.  * CPoints::QueryInterface, AddRef, Release
  132.  *
  133.  * Purpose:
  134.  *  Implements IUnknown::QueryInterface, AddRef, Release
  135.  *
  136.  */
  137. STDMETHODIMP
  138. CPoints::QueryInterface(REFIID iid, void FAR* FAR* ppv) 
  139. {    
  140.     *ppv = NULL;
  141.         
  142.     if (iid == IID_IUnknown || iid == IID_IPoints || iid == IID_IDispatch)
  143.         *ppv = this;        
  144.     else if (iid == IID_ISupportErrorInfo)
  145.         *ppv = &m_SupportErrorInfo;
  146.     else return E_NOINTERFACE; 
  147.  
  148.     AddRef();
  149.     return NOERROR;    
  150. }
  151.  
  152.  
  153. STDMETHODIMP_(ULONG)
  154. CPoints::AddRef(void)
  155. { 
  156.  
  157. #ifdef _DEBUG  
  158.     TCHAR ach[50];
  159.     wsprintf(ach, TEXT("Ref = %ld, Points\r\n"), m_cRef+1); 
  160.     OutputDebugString(ach); 
  161. #endif  
  162.     
  163.     return ++m_cRef;
  164. }
  165.  
  166.  
  167. STDMETHODIMP_(ULONG)
  168. CPoints::Release(void)
  169. { 
  170.  
  171. #ifdef _DEBUG  
  172.     TCHAR ach[50];
  173.     wsprintf(ach, TEXT("Ref = %ld, Points\r\n"), m_cRef-1); 
  174.     OutputDebugString(ach);   
  175. #endif
  176.     
  177.     if(--m_cRef == 0)
  178.     {
  179.         delete this;
  180.         return 0;
  181.     }
  182.     return m_cRef;
  183. } 
  184.  
  185. /*
  186.  * CPoints::GetTypeInfoCount
  187.  *
  188.  * Purpose:
  189.  *  Implements IDispatch::GetTypeInfoCount.
  190.  *
  191.  */
  192. STDMETHODIMP
  193. CPoints::GetTypeInfoCount(UINT FAR* pctinfo)
  194. {
  195.     *pctinfo = 1;
  196.     return NOERROR;
  197. }
  198.  
  199. /*
  200.  * CPoints::GetTypeInfo
  201.  *
  202.  * Purpose:
  203.  *  Implements IDispatch::GetTypeInfo. 
  204.  *
  205.  */
  206. STDMETHODIMP
  207. CPoints::GetTypeInfo(
  208.       UINT itinfo,
  209.       LCID lcid,
  210.       ITypeInfo FAR* FAR* pptinfo)
  211. {    
  212.     *pptinfo = NULL;
  213.      
  214.     if(itinfo != 0)
  215.         return DISP_E_BADINDEX;
  216.     
  217.     m_ptinfo->AddRef(); 
  218.     *pptinfo = m_ptinfo;
  219.     
  220.     return NOERROR;
  221. }
  222.  
  223. /*
  224.  * CPoints::GetIDsOfNames
  225.  *
  226.  * Purpose:
  227.  *  Implements IDispatch::GetIDsOfNames.  The standard implementation, DispGetIDsOfNames,
  228.  *  is used.
  229.  *
  230.  */
  231. STDMETHODIMP 
  232. CPoints::GetIDsOfNames(
  233.       REFIID riid,
  234.       OLECHAR FAR* FAR* rgszNames,
  235.       UINT cNames,
  236.       LCID lcid,
  237.       DISPID FAR* rgdispid)
  238. {
  239.     return DispGetIDsOfNames(m_ptinfo, rgszNames, cNames, rgdispid);
  240. }
  241.  
  242. /*
  243.  * CPoints::Invoke
  244.  *
  245.  * Purpose:
  246.  *  Implements IDispatch::Invoke.  The standard implementation, DispInvoke,
  247.  *  is used. 
  248.  *
  249.  */
  250. STDMETHODIMP
  251. CPoints::Invoke(
  252.       DISPID dispidMember,
  253.       REFIID riid,
  254.       LCID lcid,
  255.       WORD wFlags,
  256.       DISPPARAMS FAR* pdispparams,
  257.       VARIANT FAR* pvarResult,
  258.       EXCEPINFO FAR* pexcepinfo,
  259.       UINT FAR* puArgErr)
  260. {  
  261.     return DispInvoke(
  262.         this, m_ptinfo,
  263.         dispidMember, wFlags, pdispparams,
  264.         pvarResult, pexcepinfo, puArgErr);   
  265. }
  266.  
  267. /*
  268.  * CPoints::get_Count
  269.  *
  270.  * Purpose:
  271.  *  Returns number of items in collection.
  272.  *
  273.  */
  274. STDMETHODIMP   
  275. CPoints::get_Count(long FAR* plCount)  
  276. {
  277.     *plCount = m_cElements;
  278.     return NOERROR;             
  279. }
  280.  
  281. /*
  282.  * CPoints::get_Item
  283.  *
  284.  * Purpose:
  285.  *  Retrieves item from collection, given an index.
  286.  *
  287.  * Parameters:   
  288.  *   lIndex   Index of item to be retrieved. 
  289.  *
  290.  * Returns
  291.  *  IDispatch of item retrieved from collection.
  292.  *
  293.  */
  294. STDMETHODIMP
  295. CPoints::get_Item(long lIndex, IPoint FAR* FAR* ppPoint)
  296. { 
  297.     HRESULT hr;
  298.     VARIANT v;
  299.     LPDISPATCH pdisp = NULL;
  300.    
  301.     // Check if integer index is within range         
  302.     if (lIndex < m_lLBound || lIndex >= (long)(m_lLBound+m_cElements)) 
  303.         return RaiseException(IDS_InvalidIndex, IID_IPoints); 
  304.     
  305.     // Retrieve and return item. Note that SafeArrayGetElement AddRefs so an additional AddRef
  306.     // is not required.
  307.     VariantInit(&v);
  308.     hr = SafeArrayGetElement(m_psa, &lIndex, &v);
  309.     if (FAILED(hr))
  310.         return RaiseException(IDS_Unexpected, IID_IPoints); 
  311.     *ppPoint = (IPoint FAR*) V_DISPATCH(&v);    
  312.     return NOERROR;
  313. }
  314.  
  315. /*
  316.  * CPoints::get_NewEnum
  317.  *
  318.  * Purpose:
  319.  *  Returns an enumerator (IEnumVARIANT) for the items curently in the collection. 
  320.  *  The NewEnum property is restricted and so is invisible to users of an 
  321.  *  automation controller's scripting language. Automation controllers that support
  322.  *  a 'For Each' statement to iterate through the elements of a collection will use
  323.  *  the enumerator returned by NewEnum. The enumerator creates a snapshot of the
  324.  *  the current state of the collection.
  325.  *
  326.  */
  327. STDMETHODIMP
  328. CPoints::get__NewEnum(IUnknown FAR* FAR* ppunkEnum)
  329. {
  330.     CEnumVariant FAR* penum = NULL;
  331.     HRESULT hr;
  332.     
  333.     // Create new enumerator for items currently in collection and QI for IUnknown
  334.     hr = CEnumVariant::Create(m_psa, m_cElements, &penum);
  335.     if (FAILED(hr))
  336.         {hr = RaiseException(IDS_OutOfMemory, IID_IPoints); goto error;}       
  337.     hr = penum->QueryInterface(IID_IUnknown, (VOID FAR* FAR*)ppunkEnum);    
  338.     if (FAILED(hr)) 
  339.         {hr = RaiseException(IDS_Unexpected, IID_IPoints); goto error;}         
  340.     return NOERROR; 
  341.     
  342. error:
  343.     if (penum)
  344.         delete penum;    
  345.     return hr;              
  346. }
  347.  
  348. /* 
  349.  *
  350.  * The following methods are not exposed through Automation
  351.  *
  352.  */
  353.  
  354. /*
  355.  * CPoints::Add
  356.  *
  357.  * Purpose:
  358.  *  Adds an item to the collection. The points collection does not have duplicates.
  359.  *
  360.  * Parameters:
  361.  *  pPointAdd    Point to be added to collection.
  362.  *
  363.  */
  364. STDMETHODIMP_(BOOL)   
  365. CPoints::Add(CPoint FAR* pPointAdd)
  366. { 
  367.     HRESULT hr;   
  368.     LONG l;
  369.     VARIANT v;  
  370.     VARIANT HUGEP *pvar;
  371.     int nX, nY;
  372.     BOOL bFound = FALSE;     
  373.     LPDISPATCH pdispPointAdd = NULL;
  374.     CPoint FAR *pPoint;
  375.     LPDISPATCH pdispPoint;   
  376.     
  377.     // Is the collection full?
  378.     if (m_cElements == m_cMax) 
  379.         goto error;              
  380.        
  381.     // Get coordinates of point to be added to collection 
  382.     nX = pPointAdd->get_x();
  383.     nY = pPointAdd->get_y();
  384.           
  385.     hr = SafeArrayAccessData(m_psa, (void HUGEP* FAR*)&pvar);
  386.     if (FAILED(hr))
  387.         goto error; 
  388.               
  389.     // Check if point to be added is already in the collection.       
  390.     for (l=0; l<(long)m_cElements; l++)
  391.     {   
  392.         pdispPoint = V_DISPATCH(&pvar[l]);      
  393.         hr = pdispPoint->QueryInterface(IID_IPoint, (void FAR* FAR*)&pPoint);
  394.         if (FAILED(hr))
  395.             continue;                
  396.         if (nX == pPoint->get_x() &&  nY == pPoint->get_y())
  397.         {   
  398.             // Point is already in the collection. AddRef it.   
  399.             // Internal AddRef keeps track of number of times this point was added to this collection. When
  400.             //    this internal ref count drops to 0, this point can be removed from this collection.  
  401.             pPoint->InternalAddRef();        
  402.             pdispPoint->AddRef();  
  403.             
  404.             bFound = TRUE;
  405.             pPoint->Release(); 
  406.             break; 
  407.         }             
  408.         pPoint->Release();        
  409.     }   
  410.     hr = SafeArrayUnaccessData(m_psa);
  411.     if (FAILED(hr))
  412.        goto error;
  413.            
  414.     // Add point if it was not in the collection.
  415.     if (!bFound)
  416.     {
  417.         l = m_lLBound+m_cElements;    
  418.  
  419.         hr = pPointAdd->QueryInterface(IID_IDispatch, (void FAR* FAR*)&pdispPointAdd);
  420.         if (FAILED(hr))
  421.             goto error;              
  422.         VariantInit(&v);
  423.         V_VT(&v) = VT_DISPATCH;
  424.         V_DISPATCH(&v) = pdispPointAdd;    
  425.         hr = SafeArrayPutElement(m_psa, &l, &v);
  426.         if (FAILED(hr))
  427.             goto error;   
  428.             
  429.         // Internal AddRef keeps track of number of times this point was added to this collection. When
  430.         //    this internal ref count drops to 0, this point can be removed from this collection.       
  431.         pPointAdd->InternalAddRef();  
  432.         pdispPointAdd->Release();   
  433.           
  434.         m_cElements++;
  435.     }                    
  436.     return TRUE;    
  437.     
  438. error:
  439.     if (pdispPointAdd)
  440.         pdispPointAdd->Release();     
  441.     return FALSE;   
  442. }
  443.  
  444. /*
  445.  * CPoints::Remove
  446.  *
  447.  * Purpose:
  448.  *  Removes specified item from collection. The points collection does not have duplicates.
  449.  *
  450.  * Parameters:   
  451.  *   pPointRemove    Point to be removed from collection.
  452.  *
  453.  */
  454. STDMETHODIMP_(BOOL)
  455. CPoints::Remove(CPoint FAR* pPointRemove)
  456. {
  457.     HRESULT hr;
  458.     long l, lIndex;
  459.     VARIANT HUGEP *pvar;
  460.     ULONG cRef;
  461.     int nX, nY;
  462.     CPoint FAR* pPoint = NULL;
  463.     BOOL bFound = FALSE;    
  464.     BOOL bRet = FALSE;
  465.     
  466.     // Get coordinates of point to be removed from collection
  467.     nX = pPointRemove->get_x();
  468.     nY = pPointRemove->get_y();
  469.           
  470.     hr = SafeArrayAccessData(m_psa, (void HUGEP* FAR*)&pvar);
  471.     if (FAILED(hr))
  472.        goto error; 
  473.  
  474.               
  475.     // Check if point to be removed is in the collection.       
  476.     for (l=0; l<(long)m_cElements; l++)
  477.     {        
  478.         hr = V_DISPATCH(&pvar[l])->QueryInterface(IID_IPoint, (void FAR* FAR*)&pPoint);
  479.         if (FAILED(hr))
  480.             continue;
  481.                   
  482.         if (nX == pPoint->get_x() &&  nY == pPoint->get_y())
  483.         {
  484.             // Release point. Note that this collection does not have duplicates. Duplicate
  485.             // points are handled by increasing the ref count.
  486.             V_DISPATCH(&pvar[l])->Release();     
  487.             cRef = pPoint->InternalRelease();  
  488.             bFound = TRUE;
  489.             lIndex = l;
  490.             pPoint->Release(); 
  491.             break; 
  492.         }             
  493.         pPoint->Release();        
  494.     }   
  495.     
  496.     // If the internal ref count of point to be removed has dropped to 0, move up the array elements
  497.     // after the element to be removed.     
  498.     if (bFound && cRef == 0)
  499.     {           
  500.         for (l=lIndex; l<(long)(m_cElements-1); l++)  
  501.             pvar[l] = pvar[l+1];
  502.     
  503.         // Remove last element.    
  504.         V_VT(&pvar[l]) = VT_EMPTY;
  505.         m_cElements--; 
  506.         bRet = TRUE;
  507.     }
  508.             
  509.     hr = SafeArrayUnaccessData(m_psa);
  510.     if (FAILED(hr))
  511.        goto error;          
  512.     return bRet; 
  513.        
  514. error: 
  515.     return FALSE;
  516. }
  517.  
  518. /*
  519.  * CPoints::Clear
  520.  *
  521.  * Purpose:
  522.  *  Removes all items from collection.
  523.  *
  524.  */
  525. STDMETHODIMP_(void)
  526. CPoints::Clear(void)
  527. {
  528.     SafeArrayDestroyData(m_psa);     
  529.     SafeArrayAllocData(m_psa);
  530.     m_cElements = 0;
  531. }    
  532.  
  533. /*
  534.  * CPoints::GetMaxXMaxY
  535.  *
  536.  * Purpose:
  537.  *  Get the maximum X and Y coordinates that are in the rectangle, prc.
  538.  *
  539.  */
  540. STDMETHODIMP_(void)
  541. CPoints::GetMaxXMaxY(int FAR *pnX, int FAR *pnY, LPRECT prc)
  542. {   
  543.     HRESULT hr;
  544.     long l;
  545.     VARIANT HUGEP *pvar;
  546.     int nMaxX, nMaxY;       
  547.     CPoint FAR* pPoint;
  548.     POINT pt;
  549.     
  550.     hr = SafeArrayAccessData(m_psa, (void HUGEP* FAR*)&pvar);
  551.     if (FAILED(hr))
  552.        return; 
  553.  
  554.     nMaxX = -1; nMaxY = -1;
  555.     
  556.     // Find the maximume X and Y coordinates that are in the prc rectangle.    
  557.     for (l=0; l<(long)m_cElements; l++)
  558.     {        
  559.         V_DISPATCH(&pvar[l])->QueryInterface(IID_IPoint, (void FAR* FAR*)&pPoint);
  560.         pt.x = pPoint->get_x(); 
  561.         pt.y = pPoint->get_y();
  562.          
  563.         if (PtInRect(prc, pt))
  564.         {   
  565.             if (pt.x > nMaxX)
  566.                 nMaxX = pt.x;
  567.             
  568.             if (pt.y > nMaxY)
  569.                 nMaxY = pt.y;
  570.         }        
  571.         pPoint->Release();
  572.     }
  573.     
  574.     *pnX = nMaxX;
  575.     *pnY = nMaxY;    
  576.     
  577.     SafeArrayUnaccessData(m_psa);  
  578.     return;
  579. }  
  580.  
  581.