开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
local.cpp
资源名称：COM+编程技术内幕(源码).rar　[点击查看]
上传用户：bjlvip
上传日期：2010-02-08
资源大小：744k
文件大小：17k
源码类别：

Windows编程

开发平台：

Visual C++

local.cpp：源码内容
  1. // local.cpp
  2. #define _WIN32_DCOM
  3. #include <iostream.h>  // For cout
  4. #include <olectl.h>    // For connection point interfaces
  5. #include "Componentcomponent.h" // Generated by MIDL
  6. #include "registry.h"  // For registration functions
  8. long g_cComponents = 0;
  9. long g_cServerLocks = 0;
  10. HANDLE g_hEvent;
  11. IOutGoing* g_pOutGoing;
  12. const NUM_CONNECTION_POINTS = 1;
  13. const CCONNMAX = 2;
  15. class CEnumConnectionPoints : public IEnumConnectionPoints
  16. {
  17. public:
  18. // IUnknown
  19. ULONG __stdcall AddRef();
  20. ULONG __stdcall Release();
  21. HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);
  23. // IEnumConnectionPoints
  24. HRESULT __stdcall Next(ULONG cConnections, IConnectionPoint** rgpcn, ULONG* pcFetched); 
  25. HRESULT __stdcall Skip(ULONG cConnections);
  26. HRESULT __stdcall Reset();
  27. HRESULT __stdcall Clone(IEnumConnectionPoints** ppEnum);
  29. CEnumConnectionPoints(IUnknown* pUnkRef, void** rgpCP);
  30. ~CEnumConnectionPoints();
  32. private:
  33. long m_cRef;
  34.     IUnknown* m_pUnkRef;         // IUnknown for ref counting
  35.     int m_iCur;                  // Current element
  36.     IConnectionPoint* m_rgpCP[NUM_CONNECTION_POINTS];  // Array of connection points
  37. };
  39. // void** rpgCP is used so that this constructor can accept either CConnectionPoint**
  40. // from CInsideCOM::EnumConnectionPoints or IConnectionPoint** from CEnumConnectionPoints::Clone
  41. // This could also be done by overloading the constructor and duplicating some of this code
  42. CEnumConnectionPoints::CEnumConnectionPoints(IUnknown* pUnkRef, void** rgpCP) : m_cRef(0)
  43. {
  44. g_cComponents++;
  45. m_iCur = 0;
  46.     m_pUnkRef = pUnkRef;
  48. // m_rgpCP is a pointer to an array of IConnectionPoints or CConnectionPoints
  49. for(int count = 0; count < NUM_CONNECTION_POINTS; count++)
  50. ((IUnknown*)rgpCP[count])->QueryInterface(IID_IConnectionPoint, (void**)&m_rgpCP[count]);
  51. }
  53. CEnumConnectionPoints::~CEnumConnectionPoints()
  54. {
  55. g_cComponents--;
  56. if(m_rgpCP != NULL)
  57. for(int count = 0; count < NUM_CONNECTION_POINTS; count++)
  58. m_rgpCP[count]->Release();
  59. }
  61. ULONG CEnumConnectionPoints::AddRef()
  62. {
  63. m_pUnkRef->AddRef();
  64. return ++m_cRef;
  65. }
  67. ULONG CEnumConnectionPoints::Release()
  68. {
  69. m_pUnkRef->Release();
  70. if(--m_cRef != 0)
  71.         return m_cRef;
  72.     delete this;
  73.     return 0;
  74. }
  76. HRESULT CEnumConnectionPoints::QueryInterface(REFIID riid, void** ppv)
  77. {
  78. if(riid == IID_IUnknown || riid == IID_IEnumConnectionPoints)
  79. *ppv = (IEnumConnectionPoints*)this;
  80. else 
  81. {
  82. *ppv = NULL;
  83. return E_NOINTERFACE;
  84. }
  85. AddRef();
  86. return S_OK;
  87. }
  89. HRESULT CEnumConnectionPoints::Next(ULONG cConnections, IConnectionPoint** rgpcn, ULONG* pcFetched)
  90. {
  91. if(rgpcn == NULL)
  92. return E_POINTER;
  93. if(pcFetched == NULL && cConnections != 1)
  94. return E_INVALIDARG;
  95. if(pcFetched != NULL)
  96. *pcFetched = 0;
  98. while(m_iCur < NUM_CONNECTION_POINTS && cConnections > 0)
  99. {
  100. *rgpcn = m_rgpCP[m_iCur++];
  101. if(*rgpcn != NULL)
  102. (*rgpcn)->AddRef();
  103. if(pcFetched != NULL)
  104. (*pcFetched)++;
  105. cConnections--;
  106. rgpcn++;
  107. }
  108. return S_OK;
  109. }
  111. HRESULT CEnumConnectionPoints::Skip(ULONG cConnections)
  112. {
  113. if(m_iCur + cConnections >= NUM_CONNECTION_POINTS)
  114. return S_FALSE;
  115.     m_iCur += cConnections;
  116.     return S_OK;
  117. }
  119. HRESULT CEnumConnectionPoints::Reset()
  120. {
  121.     m_iCur = 0;
  122.     return S_OK;
  123. }
  125. HRESULT CEnumConnectionPoints::Clone(IEnumConnectionPoints** ppEnum)
  126. {
  127. if(ppEnum == NULL)
  128. return E_POINTER;
  129. *ppEnum = NULL;
  131.     // Create the clone
  132.     CEnumConnectionPoints* pNew = new CEnumConnectionPoints(m_pUnkRef, (void**)m_rgpCP);
  133.     if(pNew == NULL)
  134.         return E_OUTOFMEMORY;
  136.     pNew->AddRef();
  137.     pNew->m_iCur = m_iCur;
  138.     *ppEnum = pNew;
  139.     return S_OK;
  140. }
  142. class CConnectionPoint;
  143. class CInsideCOM : public ISum, public IConnectionPointContainer, public IProvideClassInfo2
  144. {
  145. public:
  146. // IUnknown
  147. ULONG __stdcall AddRef();
  148. ULONG __stdcall Release();
  149. HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);
  151. // IConnectionPointContainer
  152. HRESULT __stdcall EnumConnectionPoints(IEnumConnectionPoints** ppEnum);
  153. HRESULT __stdcall FindConnectionPoint(REFIID riid, IConnectionPoint** ppCP);
  155. // IProvideClassInfo2
  156. HRESULT __stdcall GetClassInfo(ITypeInfo** pTypeInfo);
  157. HRESULT __stdcall GetGUID(DWORD dwGuidKind, GUID* pGUID);
  159. // ISum
  160. HRESULT __stdcall Sum(int x, int y, int* retval);
  162. CInsideCOM();
  163. ~CInsideCOM();
  165. private:
  166. long m_cRef;
  167. CConnectionPoint* m_rgpConnPt[NUM_CONNECTION_POINTS];
  168. };
  170. class CConnectionPoint : public IConnectionPoint
  171. {
  172. public:
  173. // IUnknown
  174. ULONG __stdcall AddRef();
  175. ULONG __stdcall Release();
  176. HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);
  178. // IConnectionPoint
  179. HRESULT __stdcall GetConnectionInterface(IID *pIID);
  180. HRESULT __stdcall GetConnectionPointContainer(IConnectionPointContainer** ppCPC);
  181. HRESULT __stdcall Advise(IUnknown* pUnknownSink, DWORD* pdwCookie);
  182. HRESULT __stdcall Unadvise(DWORD dwCookie);
  183. HRESULT __stdcall EnumConnections(IEnumConnections** ppEnum);
  185. CConnectionPoint(CInsideCOM* pObj, REFIID refiid);
  186. ~CConnectionPoint();
  188. private:
  189. int m_cRef;
  190. CInsideCOM* m_pObj;
  191. IID m_iid;
  192.     int m_cConn;
  193.     int m_nCookieNext;
  194. unsigned m_rgnCookies[CCONNMAX];
  195. IUnknown* m_rgpUnknown[CCONNMAX];
  196. };
  198. class CEnumConnections : public IEnumConnections
  199. {
  200. public:
  201. // IUnknown
  202. ULONG __stdcall AddRef();
  203. ULONG __stdcall Release();
  204. HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);
  206. // IEnumConnections
  207. HRESULT __stdcall Next(ULONG cConnections, CONNECTDATA* rgpcd, ULONG* pcFetched);
  208. HRESULT __stdcall Skip(ULONG cConnections);
  209. HRESULT __stdcall Reset();
  210. HRESULT __stdcall Clone(IEnumConnections** ppEnum);
  212. CEnumConnections(IUnknown* pUnknown, int cConn, CONNECTDATA* pConnData);
  213. ~CEnumConnections();
  215. private:
  216. int m_cRef;
  217.     IUnknown* m_pUnkRef;       // IUnknown for ref counting
  218.     unsigned m_iCur;           // Current element
  219.     unsigned m_cConn;          // Number of connections
  220.     CONNECTDATA* m_rgConnData; // Source of connections
  221. };
  223. CInsideCOM::CInsideCOM() : m_cRef(0)
  224. {
  225. g_cComponents++;
  226.     m_cRef = 0;
  228.     // Initialize all the connection points to NULL
  229. for(int count = 0; count < NUM_CONNECTION_POINTS; count++)
  230.         m_rgpConnPt[count] = NULL;
  232. // Create our connection point
  233. m_rgpConnPt[0] = new CConnectionPoint(this, IID_IOutGoing);
  234. m_rgpConnPt[0]->AddRef();
  236. // Additional connection points could be instantiated here
  237. }
  239. CInsideCOM::~CInsideCOM()
  240. {
  241. g_cComponents--;
  242.     for(int count = 0; count < NUM_CONNECTION_POINTS; count++)
  243.         if(m_rgpConnPt[count] != NULL)
  244.         delete m_rgpConnPt[count];
  245. }
  247. CEnumConnections::CEnumConnections(IUnknown* pUnknown, int cConn, CONNECTDATA* pConnData) : m_cRef(0)
  248. {
  249. g_cComponents++;
  250. m_pUnkRef = pUnknown;
  251. m_iCur = 0;
  252. m_cConn = 0;
  253. m_rgConnData = new CONNECTDATA[cConn];
  254. if(m_rgConnData != NULL)
  255. for(int count = 0; count < cConn; count++)
  256. {
  257. m_rgConnData[count] = pConnData[count];
  258. m_rgConnData[count].pUnk->AddRef();
  259. }
  260. }
  262. CEnumConnections::~CEnumConnections()
  263. {
  264. g_cComponents--;
  265. if(m_rgConnData != NULL)
  266. {
  267. for(unsigned count = 0; count < m_cConn; count++)
  268. m_rgConnData[count].pUnk->Release();
  269. delete [] m_rgConnData;
  270. }
  271. }
  273. HRESULT CEnumConnections::Next(ULONG cConnections, CONNECTDATA* rgpcd, ULONG* pcFetched)
  274. {
  275. if(pcFetched == NULL && cConnections != 1)
  276. return E_INVALIDARG;
  277. if(pcFetched != NULL)
  278. *pcFetched = 0;
  279.     if(rgpcd == NULL || m_iCur >= m_cConn)
  280.         return S_FALSE;
  281.     unsigned cReturn = 0;
  282.     while(m_iCur < m_cConn && cConnections > 0)
  283.     {
  284.         *rgpcd++ = m_rgConnData[m_iCur];
  285.         m_rgConnData[m_iCur++].pUnk->AddRef();
  286.         cReturn++;
  287.         cConnections--;
  288.     } 
  289.     if(pcFetched != NULL)
  290.         *pcFetched = cReturn;
  291.     return S_OK;
  292. }
  294. HRESULT CEnumConnections::Skip(ULONG cConnections)
  295. {
  296.     if(m_iCur + cConnections >= m_cConn)
  297.         return S_FALSE;
  298.     m_iCur += cConnections;
  299.     return S_OK;
  300. }
  302. HRESULT CEnumConnections::Reset()
  303. {
  304.     m_iCur = 0;
  305.     return S_OK;
  306. }
  308. HRESULT CEnumConnections::Clone(IEnumConnections** ppEnum)
  309. {
  310. if(ppEnum == NULL)
  311. return E_POINTER;
  312. *ppEnum = NULL;
  314.     // Create the clone
  315.     CEnumConnections* pNew = new CEnumConnections(m_pUnkRef, m_cConn, m_rgConnData);
  316.     if(NULL == pNew)
  317.         return E_OUTOFMEMORY;
  319.     pNew->AddRef();
  320.     pNew->m_iCur = m_iCur;
  321.     *ppEnum = pNew;
  322.     return S_OK;
  323. }
  325. HRESULT CEnumConnections::QueryInterface(REFIID riid, void** ppv)
  326. {
  327.     if(IID_IUnknown == riid || IID_IEnumConnections == riid)
  328.         *ppv = (IEnumConnections*)this;
  329.     else
  330. {
  331. *ppv = NULL;
  332. return E_NOINTERFACE;
  333. }
  334. AddRef();
  335. return S_OK;
  336. }
  338. ULONG CEnumConnections::AddRef()
  339.     {
  340.     return ++m_cRef;
  341.     }
  343. ULONG CEnumConnections::Release()
  344.     {
  345.     if(--m_cRef != 0)
  346.         return m_cRef;
  347.     delete this;
  348.     return 0;
  349.     }
  351. CConnectionPoint::CConnectionPoint(CInsideCOM* pObj, REFIID riid) : m_cRef(0)
  352. {
  353. g_cComponents++;
  354.     m_iid = riid;
  356. // Don't need AddRef/Release since we are nested inside CInsideCOM
  357.     m_pObj = pObj;
  358.     for(int count = 0; count < CCONNMAX; count++)
  359.         {
  360.         m_rgpUnknown[count] = NULL;
  361.         m_rgnCookies[count] = 0;
  362.         }
  363.     m_cConn = 0;
  364.     m_nCookieNext = 10; // Arbitrary starting cookie value
  365. }
  367. CConnectionPoint::~CConnectionPoint()
  368. {
  369. g_cComponents--;
  370.     for(int count = 0; count < CCONNMAX; count++)
  371. if(m_rgpUnknown[count] != NULL)
  372. {
  373.         m_rgpUnknown[count]->Release();
  374. m_rgpUnknown[count] = NULL;
  375. }
  376. }
  378. HRESULT CConnectionPoint::QueryInterface(REFIID riid, void** ppv)
  379. {
  380.     if(IID_IUnknown == riid || IID_IConnectionPoint == riid)
  381.         *ppv = (IConnectionPoint*)this;
  382.     else
  383. {
  384. *ppv = NULL;
  385. return E_NOINTERFACE;
  386. }
  387. AddRef();
  388. return S_OK;
  389. }
  391. ULONG CConnectionPoint::AddRef()
  392.     {
  393.     return ++m_cRef;
  394.     }
  396. ULONG CConnectionPoint::Release()
  397.     {
  398.     if(--m_cRef != 0)
  399.         return m_cRef;
  400.     delete this;
  401.     return 0;
  402.     }
  404. HRESULT CConnectionPoint::GetConnectionInterface(IID *pIID)
  405. {
  406. if(pIID == NULL)
  407. return E_POINTER;
  408. *pIID = m_iid;
  409. return S_OK;
  410. }
  412. HRESULT CConnectionPoint::GetConnectionPointContainer(IConnectionPointContainer** ppCPC)
  413. {
  414. return m_pObj->QueryInterface(IID_IConnectionPointContainer, (void**)ppCPC);
  415. }
  417. HRESULT CConnectionPoint::Advise(IUnknown* pUnknownSink, DWORD* pdwCookie)
  418. {
  419. IUnknown* pSink;
  420. *pdwCookie = 0;
  421. if(m_cConn == CCONNMAX)
  422. return CONNECT_E_ADVISELIMIT;
  423. if(FAILED(pUnknownSink->QueryInterface(m_iid, (void**)&pSink)))
  424. return CONNECT_E_CANNOTCONNECT;
  425. for(int count = 0; count < CCONNMAX; count++)
  426. if(m_rgpUnknown[count] == NULL)
  427. {
  428. m_rgpUnknown[count] = pSink;
  429. m_rgnCookies[count] = ++m_nCookieNext;
  430. *pdwCookie = m_nCookieNext;
  431. break;
  432. }
  433. m_cConn++;
  435. // Hack here to copy pointer to a global variable so that we can use it from main()
  436. g_pOutGoing = (IOutGoing*)pSink;
  438. return NOERROR;
  439. }
  441. HRESULT CConnectionPoint::Unadvise(DWORD dwCookie)
  442. {
  443. if(dwCookie == 0)
  444. return E_INVALIDARG;
  445. for(int count = 0; count < CCONNMAX; count++)
  446. if(dwCookie == m_rgnCookies[count])
  447. {
  448. if(m_rgpUnknown[count] != NULL)
  449. {
  450. m_rgpUnknown[count]->Release();
  451. m_rgpUnknown[count] = NULL;
  452. }
  453. m_cConn--;
  454. return NOERROR;
  455. }
  456. return CONNECT_E_NOCONNECTION;
  457. }
  459. HRESULT CConnectionPoint::EnumConnections(IEnumConnections** ppEnum)
  460. {
  461. *ppEnum = NULL;
  462. CONNECTDATA* pCD = new CONNECTDATA[m_cConn];
  463. for(int count1 = 0, count2 = 0; count1 < CCONNMAX; count1++)
  464. if(m_rgpUnknown[count1] != NULL)
  465. {
  466. pCD[count2].pUnk = (IUnknown*)m_rgpUnknown[count1];
  467. pCD[count2].dwCookie = m_rgnCookies[count1];
  468. count2++;
  469. }
  470. CEnumConnections* pEnum = new CEnumConnections(this, m_cConn, pCD);
  471. delete [] pCD;
  472. return pEnum->QueryInterface(IID_IEnumConnections, (void**)ppEnum);
  473. }
  475. HRESULT CInsideCOM::EnumConnectionPoints(IEnumConnectionPoints** ppEnum)
  476. {
  477. cout << "Component: CInsideCOM::EnumConnectionPoints()" << endl;
  478. CEnumConnectionPoints* pEnum = new CEnumConnectionPoints(reinterpret_cast<IUnknown*>(this), (void**)m_rgpConnPt);
  479. return pEnum->QueryInterface(IID_IEnumConnectionPoints, (void**)ppEnum);
  480. }
  482. HRESULT CInsideCOM::FindConnectionPoint(REFIID riid, IConnectionPoint** ppCP)
  483. {
  484. if(riid == IID_IOutGoing)
  485. {
  486. cout << "Component: CInsideCOM::FindConnectionPoint() for IID_IOutGoing" << endl;
  487. return m_rgpConnPt[0]->QueryInterface(IID_IConnectionPoint, (void**)ppCP);
  488. }
  489. return E_NOINTERFACE;
  490. }
  492. HRESULT CInsideCOM::GetClassInfo(ITypeInfo** pTypeInfo)
  493. {
  494. ITypeLib* pTypeLib;
  495. LoadRegTypeLib(LIBID_Component, 1, 0, LANG_NEUTRAL, &pTypeLib);
  496. HRESULT hr = pTypeLib->GetTypeInfoOfGuid(CLSID_InsideCOM, pTypeInfo);
  497. pTypeLib->Release();
  498. return hr;
  499. }
  501. HRESULT CInsideCOM::GetGUID(DWORD dwGuidKind, GUID* pGUID)
  502. {
  503. if(pGUID == NULL)
  504. return E_INVALIDARG;
  505. *pGUID = IID_IOutGoing;
  506. return S_OK;
  507. }
  509. ULONG CInsideCOM::AddRef()
  510. {
  511. return ++m_cRef;
  512. }
  514. ULONG CInsideCOM::Release()
  515. {
  516.     if(--m_cRef != 0)
  517.         return m_cRef;
  518. SetEvent(g_hEvent);
  519.     delete this;
  520.     return 0;
  521. }
  523. HRESULT CInsideCOM::QueryInterface(REFIID riid, void** ppv)
  524. {
  525. if(riid == IID_IUnknown)
  526. *ppv = reinterpret_cast<IUnknown*>(this);
  527. else if(riid == IID_ISum)
  528. {
  529. cout << "Component: CInsideCOM::QueryInterface() for ISum returning " << this << endl;
  530. *ppv = (ISum*)this;
  531. }
  532. else if(riid == IID_IConnectionPointContainer)
  533. {
  534. cout << "Component: CInsideCOM::QueryInterface() for IConnectionPointContainer" << endl;
  535. *ppv = (IConnectionPointContainer*)this;
  536. }
  537. else if(riid == IID_IProvideClassInfo)
  538. {
  539. MessageBox(NULL, "QueryInterface", "IProvideClassInfo", MB_OK);
  540. *ppv = NULL;
  541. return E_NOINTERFACE;
  542. }
  543. else 
  544. {
  545. *ppv = NULL;
  546. return E_NOINTERFACE;
  547. }
  548. AddRef();
  549. return S_OK;
  550. }
  552. HRESULT CInsideCOM::Sum(int x, int y, int* retval)
  553. {
  554. cout << "Component: CInsideCOM::Sum() " << x << " + " << y << " = " << x + y << endl;
  555. *retval = x + y;
  556. return S_OK;
  557. }
  559. class CFactory : public IClassFactory
  560. {
  561. public:
  562. // IUnknown
  563. ULONG __stdcall AddRef();
  564. ULONG __stdcall Release();
  565. HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);
  567. // IClassFactory
  568. HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter, REFIID iid, void** ppv);
  569. HRESULT __stdcall LockServer(BOOL bLock);
  571. CFactory() : m_cRef(0) { g_cComponents++; }
  572. ~CFactory() { g_cComponents--; }
  574. private:
  575. long m_cRef;
  576. };
  578. ULONG CFactory::AddRef()
  579. {
  580. return ++m_cRef;
  581. }
  583. ULONG CFactory::Release()
  584. {
  585.     if(--m_cRef != 0)
  586.         return m_cRef;
  587.     delete this;
  588.     return 0;
  589. }
  591. HRESULT CFactory::QueryInterface(REFIID iid, void** ppv)
  592. {
  593. if((iid == IID_IUnknown) || (iid == IID_IClassFactory))
  594. *ppv = (IClassFactory *)this;
  595. else
  596. {
  597. *ppv = NULL;
  598. return E_NOINTERFACE;
  599. }
  600. AddRef();
  601. return S_OK;
  602. }
  604. HRESULT CFactory::CreateInstance(IUnknown *pUnknownOuter, REFIID iid, void** ppv)
  605. {
  606. if(pUnknownOuter != NULL)
  607. return CLASS_E_NOAGGREGATION;
  609. CInsideCOM *pInsideCOM = new CInsideCOM;
  610. cout << "Component: CFactory::CreateInstance() " << pInsideCOM << endl;
  612. if(pInsideCOM == NULL)
  613. return E_OUTOFMEMORY;
  615. // QueryInterface probably for IID_IUNKNOWN
  616. return pInsideCOM->QueryInterface(iid, ppv);
  617. }
  619. HRESULT CFactory::LockServer(BOOL bLock)
  620. {
  621. if(bLock)
  622. g_cServerLocks++;
  623. else
  624. g_cServerLocks--;
  625. return S_OK;
  626. }
  628. void RegisterComponent()
  629. {
  630. ITypeLib* pTypeLib;
  631. LoadTypeLibEx(L"component.exe", REGKIND_DEFAULT, &pTypeLib);
  632. RegisterServer("component.exe", CLSID_InsideCOM, "Inside COM Sample #1", "Component.InsideCOM", "Component.InsideCOM.1", NULL);
  633. }
  635. void CommandLineParameters(int argc, char** argv)
  636. {
  637. RegisterComponent();
  638. if(argc < 2)
  639. {
  640. cout << "No parameter, but registered anyway..." << endl;
  641. exit(false);
  642. }
  643. char* szToken = strtok(argv[1], "-/"); 
  644. if(_stricmp(szToken, "RegServer") == 0)
  645. {
  646. RegisterComponent();
  647. cout << "RegServer" << endl;
  648. exit(true);
  649. }
  650. if(_stricmp(szToken, "UnregServer") == 0)
  651. {
  652. UnRegisterTypeLib(LIBID_Component, 1, 0, LANG_NEUTRAL, SYS_WIN32);
  653. UnregisterServer(CLSID_InsideCOM, "Component.InsideCOM", "Component.InsideCOM.1");
  654. cout << "UnregServer" << endl;
  655. exit(true);
  656. }
  657. if(_stricmp(szToken, "Embedding") != 0)
  658. {
  659. cout << "Invalid parameter" << endl;
  660. exit(false);
  661. }
  662. }
  664. void main(int argc, char** argv)
  665. {
  666. CommandLineParameters(argc, argv);
  667. g_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  669. CoInitializeEx(NULL, COINIT_MULTITHREADED);
  671. DWORD dwRegister;
  672. IClassFactory *pCFactory = new CFactory();
  673. CoRegisterClassObject(CLSID_InsideCOM, pCFactory, CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
  675. cout << "Press any key to fire an event at the client" << endl;
  676. HANDLE handles[2] = { g_hEvent, GetStdHandle(STD_INPUT_HANDLE) };
  677. while(WaitForMultipleObjects(2, handles, FALSE, INFINITE) - WAIT_OBJECT_0 == 1)
  678. {
  679. INPUT_RECORD ir;
  680. DWORD read;
  681. ReadConsoleInput(handles[1], &ir, 1, &read);
  682. if(ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown == TRUE)
  683. g_pOutGoing->GotMessage(ir.Event.KeyEvent.uChar.AsciiChar);
  684. }
  686. CoRevokeClassObject(dwRegister);
  687. CoUninitialize();
  688. }