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 / lines.cpp < prev    next >
C/C++ Source or Header  |  1997-07-31  |  12KB  |  514 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. **  lines.cpp
  14. **
  15. **  CLines 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.  * CLines::Create
  34.  *
  35.  * Purpose:
  36.  *  Creates an instance of a Lines 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.  *  ppLines    Returns Lines collection object.
  44.  *
  45.  * Return Value:
  46.  *  HRESULT
  47.  *
  48.  */
  49. HRESULT
  50. CLines::Create(ULONG lMaxSize, long lLBound, CPane FAR* pPane, CLines FAR* FAR* ppLines) 
  51. {   
  52.     HRESULT hr;
  53.     CLines FAR* pLines = NULL;
  54.     SAFEARRAYBOUND sabound[1];
  55.      
  56.     *ppLines = NULL;
  57.     
  58.     // Create new collection
  59.     pLines = new CLines();
  60.     if (pLines == NULL)
  61.         goto error;
  62.  
  63.     pLines->m_cMax = lMaxSize;
  64.     pLines->m_cElements = 0; 
  65.     pLines->m_lLBound = lLBound;
  66.     pLines->m_pPane = pPane;      
  67.     
  68.     // Load type information for the Lines collection from type library. 
  69.     hr = LoadTypeInfo(&pLines->m_ptinfo, IID_ILines);
  70.     if (FAILED(hr))
  71.         goto error;
  72.     
  73.     // Create a safe array of variants which is used to implement the collection.            
  74.     sabound[0].cElements = lMaxSize;
  75.     sabound[0].lLbound = lLBound;        
  76.     pLines->m_psa = SafeArrayCreate(VT_VARIANT, 1, sabound);
  77.     if (pLines->m_psa == NULL)
  78.     {
  79.         hr = E_OUTOFMEMORY;
  80.         goto error;
  81.     }             
  82.  
  83.     *ppLines = pLines;
  84.     return NOERROR;
  85.     
  86. error: 
  87.     if (pLines == NULL)
  88.         return E_OUTOFMEMORY;
  89.     if (pLines->m_ptinfo)
  90.         pLines->m_ptinfo->Release();                            
  91.     if (pLines->m_psa) 
  92.         SafeArrayDestroy(pLines->m_psa); 
  93.   
  94.     pLines->m_psa = NULL;
  95.     pLines->m_ptinfo = NULL; 
  96.     
  97.     delete pLines;
  98.     return hr;
  99. }
  100.  
  101. /*
  102.  * CLines::CLines
  103.  *
  104.  * Purpose:
  105.  *  Constructor for CLines object. Initializes members to NULL.
  106.  *
  107.  */
  108. #pragma warning (disable : 4355)
  109. CLines::CLines() : m_SupportErrorInfo(this, IID_ILines)
  110. #pragma warning (default : 4355)
  111. {    
  112.     m_cRef = 0;
  113.     m_psa = NULL;
  114.     m_ptinfo = NULL; 
  115. }
  116.  
  117. /*
  118.  * CLines::~CLines
  119.  *
  120.  * Purpose:
  121.  *  Destructor for CLines object. 
  122.  *
  123.  */
  124. CLines::~CLines()
  125. {    
  126.      if (m_ptinfo) m_ptinfo->Release();                   
  127.      if (m_psa) SafeArrayDestroy(m_psa);
  128. }
  129.  
  130. /*
  131.  * CLines::QueryInterface, AddRef, Release
  132.  *
  133.  * Purpose:
  134.  *  Implements IUnknown::QueryInterface, AddRef, Release
  135.  *
  136.  */
  137. STDMETHODIMP
  138. CLines::QueryInterface(REFIID iid, void FAR* FAR* ppv) 
  139. {    
  140.     *ppv = NULL;
  141.         
  142.     if (iid == IID_IUnknown || iid == IID_ILines || 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. CLines::AddRef(void)
  155. { 
  156.  
  157. #ifdef _DEBUG  
  158.     TCHAR ach[50];
  159.     wsprintf(ach, TEXT("Ref = %ld, Lines\r\n"), m_cRef+1); 
  160.     OutputDebugString(ach); 
  161. #endif  
  162.     
  163.     return ++m_cRef;
  164. }
  165.  
  166.  
  167. STDMETHODIMP_(ULONG)
  168. CLines::Release(void)
  169. { 
  170.  
  171. #ifdef _DEBUG  
  172.     TCHAR ach[50];
  173.     wsprintf(ach, TEXT("Ref = %ld, Lines\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.  * CLines::GetTypeInfoCount
  187.  *
  188.  * Purpose:
  189.  *  Implements IDispatch::GetTypeInfoCount.
  190.  *
  191.  */
  192. STDMETHODIMP
  193. CLines::GetTypeInfoCount(UINT FAR* pctinfo)
  194. {
  195.     *pctinfo = 1;
  196.     return NOERROR;
  197. }
  198.  
  199. /*
  200.  * CLines::GetTypeInfo
  201.  *
  202.  * Purpose:
  203.  *  Implements IDispatch::GetTypeInfo. 
  204.  *
  205.  */
  206. STDMETHODIMP
  207. CLines::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.  * CLines::GetIDsOfNames
  225.  *
  226.  * Purpose:
  227.  *  Implements IDispatch::GetIDsOfNames.  The standard implementation, DispGetIDsOfNames,
  228.  *  is used.
  229.  *
  230.  */
  231. STDMETHODIMP 
  232. CLines::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.  * CLines::Invoke
  244.  *
  245.  * Purpose:
  246.  *  Implements IDispatch::Invoke.  The standard implementation, DispInvoke,
  247.  *  is used.
  248.  *
  249.  */
  250. STDMETHODIMP
  251. CLines::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.  * 
  269.  * Properties and methods exposed through automation.
  270.  *
  271.  */
  272.  
  273. /*
  274.  * CLines::Add
  275.  *
  276.  * Purpose:
  277.  *  Adds a line to the lines collection. 
  278.  *
  279.  * Parameters:
  280.  *  pLineNew    IDispatch of line to be added to collection.
  281.  *
  282.  */
  283. STDMETHODIMP  
  284. CLines::Add(ILine FAR* pLineNew)
  285. { 
  286.     HRESULT hr;   
  287.     LONG l;
  288.     CLine FAR* pLine = NULL;
  289.     VARIANT v;       
  290.     HDC hdc;
  291.     
  292.     // Is the collection full?
  293.     if (m_cElements == m_cMax) 
  294.         return RaiseException(IDS_CollectionFull, IID_ILines);
  295.  
  296.     hr = pLineNew->QueryInterface(IID_ILine, (void FAR* FAR*)&pLine);
  297.     if (FAILED(hr))
  298.         return RaiseException(IDS_LineFromOtherInstance, IID_ILines);
  299.     
  300.     // Add end points of line to the pane's point collection    
  301.     if (FALSE == pLine->AddEndPointsToPane(m_pPane))     
  302.         {hr = RaiseException(IDS_CantAddEndPoints, IID_ILines); goto error;}  
  303.     
  304.     // Add new line to collection
  305.     l = m_lLBound+m_cElements; 
  306.     VariantInit(&v);
  307.     V_VT(&v) = VT_DISPATCH;
  308.     V_DISPATCH(&v) = pLineNew;    
  309.     hr = SafeArrayPutElement(m_psa, &l, &v);
  310.     if (FAILED(hr))
  311.         {hr = RaiseException(IDS_Unexpected, IID_ILines); goto error;}  
  312.     m_cElements++;   
  313.     
  314.     // Draw the new line
  315.     hdc = m_pPane->GetDC();    
  316.     pLine->Draw(hdc);
  317.     m_pPane->ReleaseDC(hdc);  
  318.     
  319.     pLine->Release();                    
  320.     return NOERROR;    
  321.     
  322. error:  
  323.     if (pLine)
  324.         pLine->Release();      
  325.     return hr;   
  326. }
  327.  
  328. /*
  329.  * CLines::get_Count
  330.  *
  331.  * Purpose:
  332.  *  Returns number of items in collection.
  333.  *
  334.  */
  335. STDMETHODIMP    
  336. CLines::get_Count(long FAR* lCount)  
  337. {
  338.     *lCount = m_cElements;
  339.     return NOERROR;             
  340. }
  341.  
  342. /*
  343.  * CLines::get_Item
  344.  *
  345.  * Purpose:
  346.  *  Retrieves item from collection, given an index. 
  347.  *
  348.  * Parameters:   
  349.  *   lIndex   Index of item to be retrieved. 
  350.  *   ppLine   Returns IDispatch of item retrieved from collection.
  351.  *
  352.  */
  353. STDMETHODIMP
  354. CLines::get_Item(long lIndex, ILine FAR* FAR* ppLine)
  355. { 
  356.     HRESULT hr;                                            
  357.     VARIANT v;
  358.    
  359.     // Check if index is within range         
  360.     if (lIndex < m_lLBound || lIndex >= (long)(m_lLBound+m_cElements)) 
  361.         return RaiseException(IDS_InvalidIndex, IID_ILines); 
  362.     
  363.     // Retrieve and return item. Note that SafeArrayGetElement AddRefs, so an additional AddRef
  364.     // is not required.
  365.     VariantInit(&v);
  366.     hr = SafeArrayGetElement(m_psa, &lIndex, &v);
  367.     if (FAILED(hr))
  368.         return RaiseException(IDS_Unexpected, IID_ILines);
  369.     *ppLine = (ILine FAR*) V_DISPATCH(&v);  
  370.     return NOERROR;
  371. }
  372.  
  373. /*
  374.  * CLines::get_NewEnum
  375.  *
  376.  * Purpose:
  377.  *  Returns an enumerator (IEnumVARIANT) for the items curently in the collection. 
  378.  *  The NewEnum property is restricted and so is invisible to users of an 
  379.  *  automation controller's scripting language. Automation controllers that support
  380.  *  a 'For Each' statement to iterate through the elements of a collection will use
  381.  *  the enumerator returned by NewEnum. The enumerator creates a snapshot of the
  382.  *  the current state of the collection.
  383.  *
  384.  */
  385. STDMETHODIMP
  386. CLines::get__NewEnum(IUnknown FAR* FAR* ppunkEnum)
  387. {
  388.     CEnumVariant FAR* penum = NULL;;
  389.     HRESULT hr;
  390.     
  391.     *ppunkEnum = NULL;
  392.     
  393.     // Create new enumerator for items currently in collection and QI for IUnknown
  394.     hr = CEnumVariant::Create(m_psa, m_cElements, &penum);
  395.     if (FAILED(hr))
  396.         {hr = RaiseException(IDS_OutOfMemory, IID_ILines); goto error;}        
  397.     hr = penum->QueryInterface(IID_IUnknown, (VOID FAR* FAR*)ppunkEnum);    
  398.     if (FAILED(hr)) 
  399.         {hr = RaiseException(IDS_Unexpected, IID_ILines); goto error;}  
  400.     return NOERROR; 
  401.     
  402. error:
  403.     if (penum)
  404.         delete penum;   
  405.     return hr;              
  406. }
  407.  
  408. /*
  409.  * CLines::Remove
  410.  *
  411.  * Purpose:
  412.  *  Removes specified item from collection. 
  413.  *
  414.  * Parameters:   
  415.  *   lIndex   Index of item to be removed. 
  416.  *
  417.  */
  418. STDMETHODIMP
  419. CLines::Remove(long lIndex)
  420. {
  421.     HRESULT hr;
  422.     long l;
  423.     VARIANT HUGEP *pvar;
  424.     CLine FAR* pLine = NULL;  
  425.     RECT rc;
  426.     
  427.     // Check if integer index is within range. 
  428.     if (lIndex < m_lLBound || lIndex >= (long)(m_lLBound+m_cElements))
  429.         return RaiseException(IDS_InvalidIndex, IID_ILines);    
  430.  
  431.     hr = SafeArrayAccessData(m_psa, (void HUGEP* FAR*)&pvar);
  432.     if (FAILED(hr))
  433.         return RaiseException(IDS_Unexpected, IID_ILines); 
  434.     V_DISPATCH(&pvar[lIndex-m_lLBound])->QueryInterface(IID_ILine, (void FAR* FAR*)&pLine);         
  435.      
  436.     // Ask the pane to invalidate the area where the line is drawn.
  437.     pLine->GetInvalidateRect(&rc);
  438.     m_pPane->InvalidateRect(&rc);
  439.     
  440.     // Remove end points of line from the pane's point collection.   
  441.     pLine->RemoveEndPointsFromPane(m_pPane);    
  442.     // Remove Line  
  443.     V_DISPATCH(&pvar[lIndex-m_lLBound])->Release();    
  444.     // Move up the array elements, after the element to be removed.        
  445.     for (l=lIndex-m_lLBound; l<(long)(m_cElements-1); l++)  
  446.         pvar[l] = pvar[l+1];    
  447.     // Remove last element.    
  448.     V_VT(&pvar[l]) = VT_EMPTY;
  449.     
  450.     pLine->Release();        
  451.     hr = SafeArrayUnaccessData(m_psa);
  452.     if (FAILED(hr))
  453.        return RaiseException(IDS_Unexpected, IID_ILines); 
  454.        
  455.     m_cElements--;  
  456.     m_pPane->Update();     // Ask the pane to repaint invalidated areas caused by removal of line.
  457.     return NOERROR;
  458. }
  459.  
  460. /* 
  461.  *
  462.  * The following methods are not exposed through Automation
  463.  *
  464.  */  
  465.  
  466. /*
  467.  * CLines::Draw
  468.  *
  469.  * Purpose:
  470.  *  Draws all lines in collection.
  471.  *
  472.  */
  473. STDMETHODIMP_(void)
  474. CLines::Draw(HDC hdc)
  475. {
  476.     HRESULT hr;
  477.     long l;
  478.     CLine FAR* pLine = NULL;
  479.     VARIANT HUGEP *pvar;
  480.     
  481.     // Draw each line in the Lines collection
  482.     hr = SafeArrayAccessData(m_psa, (void HUGEP* FAR*)&pvar);
  483.     if (FAILED(hr))
  484.        return;           
  485.     for (l=0; l<(long)m_cElements; l++)
  486.     {        
  487.         hr = V_DISPATCH(&pvar[l])->QueryInterface(IID_ILine, (void FAR* FAR*)&pLine);
  488.         if (FAILED(hr))
  489.             continue;          
  490.         pLine->Draw(hdc);
  491.         pLine->Release();        
  492.     }   
  493.     hr = SafeArrayUnaccessData(m_psa);
  494.     if (FAILED(hr))
  495.         return;
  496.     return;
  497. }
  498.  
  499. /*
  500.  * CLines::Clear
  501.  *
  502.  * Purpose:
  503.  *  Removes all items from collection.
  504.  *
  505.  */
  506. STDMETHODIMP_(void)
  507. CLines::Clear(void)
  508. {
  509.     SafeArrayDestroyData(m_psa);   
  510.     SafeArrayAllocData(m_psa);
  511.     m_cElements = 0;
  512. }
  513.  
  514.