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 / app.cpp next >
C/C++ Source or Header  |  1997-07-31  |  15KB  |  583 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. **  app.cpp
  14. **
  15. **  CApplication 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.  * CApplication::Create
  34.  *
  35.  * Purpose:
  36.  *  Creates an instance of the Application automation object and initializes it.
  37.  *
  38.  * Parameters:       
  39.  *  hinst            HINSTANCE of application.
  40.  *  ppApplication    Returns Application automation object.
  41.  *
  42.  * Return Value:
  43.  *  HRESULT
  44.  *
  45.  */
  46. HRESULT
  47. CApplication::Create(HINSTANCE hinst, CApplication FAR* FAR* ppApplication ) 
  48. {   
  49.     TCHAR ach[STR_LEN];   
  50.     TCHAR achFullName[260];
  51.     HRESULT hr;
  52.     CApplication FAR* pApplication = NULL;  
  53.     HWND hwnd;
  54.      
  55.     *ppApplication = NULL;
  56.     
  57.     // Create application object.
  58.     pApplication = new CApplication();
  59.     if (pApplication == NULL)
  60.     {
  61.         hr = E_OUTOFMEMORY; 
  62.         goto error;
  63.     }
  64.     
  65.     LoadString(hinst, IDS_Name, ach, sizeof(ach));
  66.     hwnd = CreateWindow(TEXT("MainWndClass"), ach,
  67.                        WS_OVERLAPPEDWINDOW,
  68.                        CW_USEDEFAULT, CW_USEDEFAULT,
  69.                        650, 650,
  70.                        NULL, NULL, hinst, NULL);
  71.     if (!hwnd)
  72.     {
  73.        hr = E_OUTOFMEMORY;  
  74.        goto error;
  75.     }  
  76.     pApplication->m_hwnd = hwnd;
  77.     pApplication->m_hinst = hinst;
  78.     
  79.     // Set name and fullname of application.  
  80.     pApplication->m_bstrName = SysAllocString(TO_OLE_STRING(ach));
  81.     if (NULL == pApplication->m_bstrName)
  82.     {
  83.         hr = E_OUTOFMEMORY;    
  84.         goto error;
  85.     } 
  86.     GetModuleFileName(hinst, achFullName, sizeof(achFullName));
  87.     pApplication->m_bstrFullName = SysAllocString(TO_OLE_STRING(achFullName));
  88.     if (NULL == pApplication->m_bstrFullName)
  89.     {
  90.         hr = E_OUTOFMEMORY;    
  91.         goto error;
  92.     }
  93.     // ProgID 
  94.     LoadString(hinst, IDS_ProgID, ach, sizeof(ach));  
  95.     pApplication->m_bstrProgID = SysAllocString(TO_OLE_STRING(ach));
  96.     if (NULL == pApplication->m_bstrProgID)
  97.     {
  98.         hr = E_OUTOFMEMORY;    
  99.         goto error;
  100.     }      
  101.     
  102.     // Load type information for the application object from type library.
  103.     // If required, notify user on failure. 
  104.     hr = LoadTypeInfo(&pApplication->m_ptinfo, IID_IApplication);
  105.     if (FAILED(hr)) 
  106.     {       
  107.         LoadString(hinst, IDS_ErrorLoadingTypeLib, ach, sizeof(ach));
  108.         MessageBox(NULL, ach, FROM_OLE_STRING(pApplication->m_bstrName), MB_OK);
  109.         goto error;
  110.     }
  111.         
  112.     // Create Pane    
  113.     hr = CPane::Create(hwnd, &pApplication->m_pPane);
  114.     if (FAILED(hr))
  115.        goto error;    
  116.     pApplication->m_pPane->AddRef();    
  117.  
  118.     *ppApplication = pApplication;
  119.     return NOERROR;
  120.     
  121. error:                        
  122.     if (pApplication == NULL)
  123.         return E_OUTOFMEMORY; 
  124.     
  125.     if (pApplication->m_bstrFullName)
  126.         SysFreeString(pApplication->m_bstrFullName);  
  127.     if (pApplication->m_bstrName)
  128.         SysFreeString(pApplication->m_bstrName);
  129.     if (pApplication->m_bstrProgID) 
  130.         SysFreeString(pApplication->m_bstrProgID);                       
  131.     if (pApplication->m_ptinfo)
  132.         pApplication->m_ptinfo->Release();        
  133.     if (pApplication->m_pPane)
  134.         pApplication->m_pPane->Release();
  135.     
  136.     // Set to NULL to prevent destructor from attempting to free again
  137.     pApplication->m_bstrFullName = NULL;
  138.     pApplication->m_bstrName = NULL;
  139.         pApplication->m_bstrProgID = NULL;
  140.     pApplication->m_ptinfo = NULL;
  141.     pApplication->m_pPane = NULL;
  142.     
  143.     delete pApplication;
  144.     return hr;
  145. }
  146.  
  147. /*
  148.  * CApplication::CApplication
  149.  *
  150.  * Purpose:
  151.  *  Constructor for CApplication object. Initializes members to NULL.
  152.  *
  153.  */
  154. #pragma warning (disable : 4355)
  155. CApplication::CApplication() : m_SupportErrorInfo(this, IID_IApplication)
  156. #pragma warning (default : 4355)
  157. {   
  158.     extern ULONG g_cObj;
  159.      
  160.     m_hwnd = NULL;
  161.     m_bstrFullName = NULL;
  162.     m_bstrName = NULL;
  163.     m_bstrProgID = NULL;
  164.     m_ptinfo = NULL;
  165.     m_pPane = NULL;
  166.     m_cRef = 0;   
  167.     m_bVisible = 0;
  168.     m_bUserClosing = FALSE;
  169. }
  170.  
  171. /*
  172.  * CApplication::~CApplication
  173.  *
  174.  * Purpose:
  175.  *  Destructor for CApplication object. Frees Application message BSTR and default
  176.  *  IDispatch implementation. Closes the aplication.
  177.  *
  178.  */
  179. CApplication::~CApplication()
  180. { 
  181.      extern ULONG g_cObj;
  182.      
  183.      if (m_bstrFullName) SysFreeString(m_bstrFullName);
  184.      if (m_bstrName) SysFreeString(m_bstrName);
  185.      if (m_bstrProgID) SysFreeString(m_bstrProgID);          
  186.      if (m_ptinfo) m_ptinfo->Release();  
  187.      if (m_pPane) m_pPane->Release();
  188.      if (!m_bUserClosing && IsWindow(m_hwnd)) DestroyWindow(m_hwnd);     
  189. }
  190.  
  191. /*
  192.  * CApplication::QueryInterface, AddRef, Release
  193.  *
  194.  * Purpose:
  195.  *  Implements IUnknown::QueryInterface, AddRef, Release
  196.  *
  197.  */
  198. STDMETHODIMP
  199. CApplication::QueryInterface(REFIID iid, void FAR* FAR* ppv) 
  200. {   
  201.     *ppv = NULL;
  202.     
  203.     if (iid == IID_IUnknown || iid == IID_IDispatch || iid == IID_IApplication)
  204.         *ppv = this; 
  205.     else if (iid == IID_ISupportErrorInfo)
  206.         *ppv = &m_SupportErrorInfo;
  207.     else return E_NOINTERFACE; 
  208.  
  209.     AddRef();
  210.     return NOERROR;    
  211. }
  212.  
  213.  
  214. STDMETHODIMP_(ULONG)
  215. CApplication::AddRef(void)
  216. {    
  217. #ifdef _DEBUG  
  218.     TCHAR ach[50];
  219.     wsprintf(ach, TEXT("Ref = %ld, App\r\n"), m_cRef+1); 
  220.     OutputDebugString(ach); 
  221. #endif  
  222.  
  223.     return ++m_cRef;
  224. }
  225.  
  226. STDMETHODIMP_(ULONG)
  227. CApplication::Release(void)
  228. {
  229. #ifdef _DEBUG  
  230.     TCHAR ach[50];
  231.     wsprintf(ach, TEXT("Ref = %ld, App\r\n"), m_cRef-1); 
  232.     OutputDebugString(ach);   
  233. #endif
  234.     
  235.     if(--m_cRef == 0)
  236.     {
  237.         delete this;
  238.         return 0;
  239.     }
  240.     return m_cRef;
  241. }
  242.  
  243. /*
  244.  * CApplication::GetTypeInfoCount
  245.  *
  246.  * Purpose:
  247.  *  Implements IDispatch::GetTypeInfoCount.
  248.  *
  249.  */
  250. STDMETHODIMP
  251. CApplication::GetTypeInfoCount(UINT FAR* pctinfo)
  252. {
  253.     *pctinfo = 1;
  254.     return NOERROR;
  255. }
  256.  
  257. /*
  258.  * CApplication::GetTypeInfo
  259.  *
  260.  * Purpose:
  261.  *  Implements IDispatch::GetTypeInfo. 
  262.  *
  263.  */
  264. STDMETHODIMP
  265. CApplication::GetTypeInfo(
  266.       UINT itinfo,
  267.       LCID lcid,
  268.       ITypeInfo FAR* FAR* pptinfo)
  269. {    
  270.     *pptinfo = NULL;
  271.      
  272.     if(itinfo != 0)
  273.         return DISP_E_BADINDEX;
  274.     
  275.     m_ptinfo->AddRef(); 
  276.     *pptinfo = m_ptinfo;
  277.     
  278.     return NOERROR;
  279. }
  280.  
  281. /*
  282.  * CApplication::GetIDsOfNames
  283.  *
  284.  * Purpose:
  285.  *  Implements IDispatch::GetIDsOfNames.  The standard implementation, DispGetIDsOfNames,
  286.  *  is used.
  287.  *
  288.  */
  289. STDMETHODIMP 
  290. CApplication::GetIDsOfNames(
  291.       REFIID riid,
  292.       OLECHAR FAR* FAR* rgszNames,
  293.       UINT cNames,
  294.       LCID lcid,
  295.       DISPID FAR* rgdispid)
  296. {
  297.     return DispGetIDsOfNames(m_ptinfo, rgszNames, cNames, rgdispid);
  298. }
  299.  
  300. /*
  301.  * CApplication::Invoke
  302.  *
  303.  * Purpose:
  304.  *  Implements IDispatch::Invoke.  The standard implementation, DispInvoke,
  305.  *  is used.
  306.  *
  307.  */
  308. STDMETHODIMP
  309. CApplication::Invoke(
  310.       DISPID dispidMember,
  311.       REFIID riid,
  312.       LCID lcid,
  313.       WORD wFlags,
  314.       DISPPARAMS FAR* pdispparams,
  315.       VARIANT FAR* pvarResult,
  316.       EXCEPINFO FAR* pexcepinfo,
  317.       UINT FAR* puArgErr)
  318. {  
  319.    return DispInvoke(
  320.         this, m_ptinfo,
  321.         dispidMember, wFlags, pdispparams,
  322.         pvarResult, pexcepinfo, puArgErr);   
  323. }
  324.  
  325. /*
  326.  * CApplication::get_Application, get_FullName, get_Name, get_Parent, get_Visible, put_Visible, Quit 
  327.  *
  328.  * Purpose:
  329.  *  Implements the standard Application, FullName, Name, Parent & Visible properties
  330.  *  and the Quit method. 
  331.  *
  332.  */
  333. STDMETHODIMP
  334. CApplication::get_Application(IApplication FAR* FAR* ppApplication)
  335. {
  336.     HRESULT hr;
  337.     
  338.     hr = QueryInterface(IID_IDispatch, (void FAR* FAR*)ppApplication); 
  339.     if (FAILED(hr))
  340.         return RaiseException(IDS_Unexpected, IID_IApplication); 
  341.     return NOERROR;
  342. }
  343.  
  344. STDMETHODIMP
  345. CApplication::get_FullName(BSTR FAR* pbstr)
  346. {
  347.     *pbstr = SysAllocString(m_bstrFullName);   
  348.     return NOERROR;
  349. }
  350.  
  351. STDMETHODIMP
  352. CApplication::get_Name(BSTR FAR* pbstr)
  353. {
  354.     *pbstr = SysAllocString(m_bstrName); 
  355.     return NOERROR; 
  356. }
  357.  
  358. STDMETHODIMP
  359. CApplication::get_Parent(IApplication FAR* FAR* ppApplication)      
  360. {
  361.     HRESULT hr;
  362.     
  363.     hr = QueryInterface(IID_IDispatch, (void FAR* FAR*)ppApplication); 
  364.     if (FAILED(hr))
  365.         return RaiseException(IDS_Unexpected, IID_IApplication); 
  366.     return NOERROR;
  367. }
  368.  
  369. STDMETHODIMP
  370. CApplication::put_Visible(VARIANT_BOOL bVisible)
  371. {
  372.     ShowWindow(bVisible ? SW_SHOW : SW_HIDE);  
  373.     return NOERROR;
  374. } 
  375.  
  376. STDMETHODIMP
  377. CApplication::get_Visible(VARIANT_BOOL FAR* pbVisible)
  378. {
  379.     *pbVisible = m_bVisible;     
  380.     return NOERROR;
  381. }
  382.  
  383. STDMETHODIMP
  384. CApplication::Quit()
  385. {
  386.     // CoDisconnectObject has no effect for an inproc server.  So the controller
  387.     // will GP fault if it attempts to access the object (including calling IUnknown::Release())
  388.     // after Quit has been called. For a local server, CoDisconnectObject will disconnect
  389.     // the object from external connections. So the controller will get an RPC error if
  390.     // it access the object after calling Quit. The controller will not GP fault in this case. 
  391.     CoDisconnectObject((LPUNKNOWN)this, 0);  
  392.     PostMessage(m_hwnd, WM_CLOSE, 0, 0L);
  393.     return NOERROR;                                     
  394. } 
  395.  
  396. /*
  397.  * CApplication::get_Pane
  398.  *
  399.  * Purpose:
  400.  *  Returns pane object.
  401.  *
  402.  */      
  403. STDMETHODIMP
  404. CApplication::get_Pane(IPane FAR* FAR* ppPane)
  405. {
  406.     HRESULT hr;
  407.     
  408.     hr = m_pPane->QueryInterface(IID_IDispatch, (void FAR* FAR*)ppPane); 
  409.     if (FAILED(hr))
  410.         return RaiseException(IDS_Unexpected, IID_IApplication); 
  411.     return NOERROR;
  412. }
  413.  
  414. /*
  415.  * CApplication::CreateLine
  416.  *
  417.  * Purpose:
  418.  *  Returns a newly created line object with no start or end point.
  419.  *
  420.  */  
  421. STDMETHODIMP
  422. CApplication::CreateLine(ILine FAR* FAR* ppLine)
  423. {
  424.     CLine FAR* pline = NULL;
  425.     HRESULT hr;
  426.     
  427.     // Create new item and QI for IDispatch   
  428.     hr = CLine::Create(&pline);
  429.     if (FAILED(hr)) 
  430.         {hr = RaiseException(IDS_OutOfMemory, IID_IApplication); goto error;} 
  431.               
  432.     hr = pline->QueryInterface(IID_IDispatch, (void FAR* FAR*)ppLine); 
  433.     if (FAILED(hr)) 
  434.         {hr = RaiseException(IDS_Unexpected, IID_IApplication); goto error;}
  435.     return NOERROR;
  436.     
  437. error: 
  438.     if (pline)
  439.         delete pline;       
  440.     return hr;     
  441. }
  442.  
  443. /*
  444.  * CApplication::CreateLine
  445.  *
  446.  * Purpose:
  447.  *  Returns a newly created point object intialized to (0,0).
  448.  *
  449.  */ 
  450. STDMETHODIMP
  451. CApplication::CreatePoint(IPoint FAR* FAR* ppPoint)
  452. {
  453.     CPoint FAR* ppoint = NULL;
  454.     HRESULT hr;
  455.     
  456.     // Create new item and QI for IDispatch   
  457.     hr = CPoint::Create(&ppoint);
  458.     if (FAILED(hr))
  459.         {hr = RaiseException(IDS_OutOfMemory, IID_IApplication); goto error;}          
  460.         
  461.     hr = ppoint->QueryInterface(IID_IDispatch, (void FAR* FAR*)ppPoint); 
  462.     if (FAILED(hr))
  463.         {hr = RaiseException(IDS_Unexpected, IID_IApplication); goto error;}
  464.     return NOERROR;
  465.     
  466. error: 
  467.     if (ppoint)
  468.         delete ppoint;        
  469.     return hr;     
  470. }   
  471.  
  472. /* 
  473.  *
  474.  * The following methods are not exposed through Automation
  475.  *
  476.  */
  477.  
  478. STDMETHODIMP_(void)
  479. CApplication::Draw()
  480. {
  481.    m_pPane->Draw();
  482. }
  483.  
  484. /*
  485.  * CApplication::OnSize
  486.  *
  487.  * Purpose:
  488.  *  Called when application window receives WM_SIZE.
  489.  *
  490.  */ 
  491. STDMETHODIMP_(void)
  492. CApplication::OnSize(unsigned int nWidth, unsigned int nHeight) 
  493. {
  494.    m_pPane->OnSize(nWidth, nHeight);
  495. } 
  496.  
  497. STDMETHODIMP_(void)
  498. CApplication::ShowWindow(int nCmdShow)
  499. {   
  500.     // Return if curently hidden and asked to hide or currently visible
  501.     // and asked to show.
  502.     if ((!m_bVisible && nCmdShow == SW_HIDE) || (m_bVisible && nCmdShow != SW_HIDE))
  503.         return; 
  504.     
  505.     m_bVisible = (nCmdShow == SW_HIDE) ? FALSE : TRUE;
  506.     
  507.     // The Automation object shutdown behavior is as follows:
  508.     // 1. If the object application is visible, it shuts down only in response to an
  509.     // explicit user command (File/Exit) or it's programmatic equivalent (for example
  510.     // the Quit method of the Application object).
  511.     // 2. If the object application is not visible, it goes away when it's last
  512.     // object is released.   
  513.     //   
  514.     // CoLockObjectExternal can be used to increment the ref count of the application object
  515.     // when it is visible. This will implement shutdown behavior 1. When the application
  516.     // goes invisible, CoLockObjectExternal is used to decrement the ref count. This will
  517.     // implement shutdown behavior 2.
  518.     
  519.     if (m_bVisible)
  520.         CoLockObjectExternal(this, TRUE /*fLock*/, TRUE/*ignored when fLock==TRUE*/);
  521.     else CoLockObjectExternal(this, FALSE/*fLock*/, TRUE/*fLastLockReleases*/);  
  522.     ::ShowWindow (m_hwnd, nCmdShow);
  523. }
  524.  
  525. STDMETHODIMP_(void)
  526. CApplication::CreateAndDrawLine()
  527. {   
  528.     LINEINFO lineinfo;
  529.     CLine FAR* pLine = NULL;
  530.     CPoint FAR* pPointStart = NULL;
  531.     CPoint FAR* pPointEnd = NULL; 
  532.     ILines FAR* pLines = NULL; 
  533.     int nRet;     
  534.     HRESULT hr;
  535.                   
  536.     nRet = DialogBoxParam(m_hinst, MAKEINTRESOURCE(IDD_DRAWLINE), m_hwnd, 
  537.                       (DLGPROC)DrawLineDialogFunc, (LPARAM)(LPLINEINFO)&lineinfo);    
  538.     if (nRet != IDOK) 
  539.         return;
  540.     hr = CLine::Create(&pLine);
  541.     if (FAILED(hr))  
  542.         goto error;
  543.     hr = CPoint::Create(&pPointStart);
  544.     if (FAILED(hr)) 
  545.         goto error; 
  546.     hr = CPoint::Create(&pPointEnd);
  547.     if (FAILED(hr))
  548.         goto error;
  549.  
  550.     pPointStart->put_x(lineinfo.ptStart.x);
  551.     pPointStart->put_y(lineinfo.ptStart.y); 
  552.     pPointEnd->put_x(lineinfo.ptEnd.x);
  553.     pPointEnd->put_y(lineinfo.ptEnd.y);   
  554.  
  555.     pLine->putref_StartPoint(pPointStart);  
  556.     pLine->putref_EndPoint(pPointEnd);  
  557.     pLine->put_Thickness(lineinfo.nThickness);
  558.     pLine->put_Color(lineinfo.colorref);
  559.     
  560.     hr = m_pPane->get_Lines(&pLines); 
  561.     if (FAILED(hr)) 
  562.         goto error; 
  563.     hr = pLines->Add(pLine); 
  564.     if (FAILED(hr)) 
  565.         goto error;  
  566.     pLines->Release();
  567.     return;
  568.  
  569. error:
  570.     if (pLine) delete pLine;
  571.     if (pPointStart) delete pPointStart;
  572.     if (pPointEnd) delete pPointEnd; 
  573.     if (pLines) pLines->Release();   
  574.     MessageBox(m_hwnd, TEXT("Cannot create Line"), FROM_OLE_STRING(m_bstrName), MB_OK);
  575. }
  576.  
  577. STDMETHODIMP_(void)
  578. CApplication::ClearPane()  
  579. {
  580.     m_pPane->Clear();
  581. }  
  582.  
  583.