home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / BOCOLE.PAK / BOLEFACT.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  10.5 KB  |  426 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectComponents
  3. // Copyright (c) 1994, 1996 by Borland International, All Rights Reserved
  4. //
  5. // $Revision:   2.3  $
  6. //
  7. //  Implements the server-side helper for allowing OLE2 to create objects 
  8. //  made available by Bolero server apps.
  9. //----------------------------------------------------------------------------
  10. #include "BOleFact.h"
  11. #include "BOleSvc.h"
  12. #include "BOleIPS.h"
  13. #include "BOleCMan.h"
  14.  
  15.  
  16. //
  17. //  DllGetClassObject
  18. //
  19.  
  20. STDAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void FAR* FAR* ppv)
  21. {
  22.   HRESULT hRes =  ResultFromScode(E_OUTOFMEMORY);
  23.   return hRes;
  24. }
  25.  
  26.  
  27. STDAPI  DllCanUnloadNow()
  28. {
  29.   return ResultFromScode( S_OK );
  30. }
  31.  
  32.  
  33. BOleFact::BOleFact(BOleClassManager * pFact, IBUnknownMain *pOuter):
  34.     RefCnt (1), 
  35.     pObjCM(NULL), 
  36.     hReg (0L), 
  37.     regId (0),
  38.     dwRegisterActiveObject (0),
  39.     id (CLSID_NULL), 
  40.     BOleComponent(pFact, (IBUnknownMain *) this),
  41.     pIPEFact (NULL)
  42. {
  43. }
  44.  
  45. BOleFact::~BOleFact()
  46. {
  47.   if (pIPEFact) {
  48.     pIPEFact->Release();
  49.     pIPEFact = NULL;
  50.   }
  51. }
  52.  
  53. HRESULT _IFUNC BOleFact::QueryInterfaceMain(REFIID iid, LPVOID FAR* ppv)
  54. {
  55.   HRESULT hr = ResultFromScode(E_NOINTERFACE);
  56.   *ppv = NULL;
  57.  
  58.   // interfaces
  59.   
  60.   SUCCEEDED(hr = IBClass_QueryInterface(this, iid, ppv))
  61.  
  62.   // base classes
  63.   
  64.   || SUCCEEDED(hr = BOleComponent::QueryInterfaceMain(iid, ppv))
  65.     
  66.   // helpers
  67.   ;
  68.  
  69.   return hr;
  70. }
  71.  
  72. HRESULT _IFUNC BOleFact::Init (BOOL fInProc, LPCOLESTR szProgId, 
  73.                                             IBClassMgr *pCM, BCID rid)
  74. {
  75.   pObjCM = pCM;
  76.   regId = rid;
  77.  
  78.   // If the user's object is capable of being instantiated in its own
  79.   // container, create a special BOleInProcFactory
  80.   //
  81.   if (fInProc) {
  82.     pIPEFact = new BOleInProcFactory (pFactory, this, id);
  83.     if (!pIPEFact)
  84.       return ResultFromScode(E_OUTOFMEMORY);
  85.   }
  86.  
  87.   return CLSIDFromProgID(szProgId, &id);
  88. }
  89.  
  90. HRESULT _IFUNC BOleFact::Register (BOOL fSingleUse)
  91. {
  92.   HRESULT hErr;
  93.  
  94.   // register the class factory for this id
  95.   //
  96.   if (!SUCCEEDED(hErr = CoRegisterClassObject(
  97.       id,
  98.       (IClassFactory *)this,
  99.       CLSCTX_LOCAL_SERVER,
  100.       fSingleUse ? REGCLS_SINGLEUSE : REGCLS_MULTI_SEPARATE,
  101.       &hReg))) 
  102.   {
  103.     OLEHRES("Failed Registering", hErr);
  104.   }
  105.  
  106.   // Register the embedding helper factory if we embed in ourselves
  107.   if (pIPEFact) {
  108.     if (!SUCCEEDED(hErr = pIPEFact->Register (fSingleUse)))
  109.       return hErr;
  110.   }
  111.  
  112.   // The online dox for CoLockObjectExternal say we should do this here
  113.   //
  114.   if (SUCCEEDED(hErr)) {
  115.     LPCLASSFACTORY pWorkAround = this;
  116.     CoLockObjectExternal (pWorkAround, TRUE, TRUE);
  117.   }
  118.   
  119.   // if the class manager supports automation let's register it as "Active"
  120.   //
  121.   IDispatch *pDispatch;
  122.   if (SUCCEEDED(pObjCM->QueryInterface(IID_IDispatch, &(LPVOID)pDispatch))) {
  123.     RegisterActiveObject (pDispatch, id, NULL, &dwRegisterActiveObject);
  124.     pDispatch->Release();
  125.   }
  126.   return hErr;
  127. }
  128.  
  129. HRESULT _IFUNC BOleFact::Revoke ()
  130. {
  131.   if (hReg) {
  132.     LPCLASSFACTORY pWorkAround = this;
  133.     CoLockObjectExternal (pWorkAround, FALSE, TRUE);
  134.     CoRevokeClassObject( hReg);
  135.     hReg = 0;
  136.   }
  137.  
  138.   if (dwRegisterActiveObject) {
  139.     RevokeActiveObject (dwRegisterActiveObject, NULL);
  140.     dwRegisterActiveObject = 0;
  141.   }
  142.  
  143.   if (pIPEFact) {
  144.     pIPEFact->Revoke ();
  145.     pIPEFact->Release ();
  146.     pIPEFact = NULL;
  147.   }
  148.   return NOERROR;
  149. }
  150.  
  151. HRESULT _IFUNC BOleFact::GetClassID (LPCLSID pClass)
  152. {
  153.   *pClass = id;
  154.   return NOERROR;
  155. }
  156.  
  157. BOOL _IFUNC BOleFact::IsA (REFCLSID cid)
  158. {
  159.   return IsEqualCLSID(cid, id);
  160. }
  161.  
  162. HRESULT _IFUNC BOleFact::CreateInstance(IUnknown FAR* pUnk, REFIID iid, 
  163.                                               LPVOID  FAR* ppv)
  164. {
  165.   HRESULT hr = ResultFromScode(E_FAIL);
  166.   *ppv = 0L;
  167.  
  168.   PIUnknown pObj;
  169.   IBClassMgr * pICM;
  170.     
  171.   if (SUCCEEDED(pObjCM->QueryInterface(IID_IBClassMgr, &(LPVOID)pICM))) {
  172.     if (SUCCEEDED(pICM->ComponentCreate(&pObj, pUnk, regId))) {
  173.       if (pUnk && iid == IID_IUnknown) {
  174.         hr = NOERROR;      
  175.         *ppv = pObj;  // always give out main IUnknown
  176.       }
  177.       else {
  178.         hr = pObj->QueryInterface(iid, ppv);
  179.         pObj->Release();  // QI bumps
  180.       }
  181.     }
  182.     pICM->Release();
  183.   }
  184.  
  185.   return hr;
  186. }
  187.  
  188.  
  189. HRESULT _IFUNC BOleFact::LockServer( BOOL fLock )
  190. {
  191.   LPCLASSFACTORY pICF = this;
  192.   CoLockObjectExternal(pICF, fLock, TRUE);
  193.   pFactory->ServerCount( fLock ? 1L : -1L);
  194.   
  195.   return NOERROR;
  196. }
  197.  
  198. // Used by DllGetClassObject to return the interface to the factory which
  199. // creates the default handler which will create the in-proc server object.
  200. //
  201. HRESULT _IFUNC BOleFact::GetEmbeddingHelperFactory (LPUNKNOWN *ppF)
  202. {
  203.   if (pIPEFact) {
  204.     *ppF = pIPEFact;
  205.     (*ppF)->AddRef();
  206.     return NOERROR;
  207.   }
  208.   else {
  209.     *ppF = NULL;
  210.     return ResultFromScode(E_FAIL);
  211.   }
  212. }
  213.  
  214. // When Bolero container-side dialog boxes need to know whether to put the
  215. // CLSID for our own factories in the dialog box, this is how they find out
  216. //
  217. BOOL _IFUNC BOleFact::AllowEmbedFromSelf ()
  218. {
  219.   return pIPEFact ? TRUE : FALSE;
  220. }
  221.  
  222. //**************************************************************************
  223. //
  224. // BOleInProcFactory -- The role of this factory is to load the default
  225. //                      handler on the server side when the container 
  226. //                      side of an app needs to instantiate an object it 
  227. //                      serves. 
  228. //
  229. //                      If we don't do this, the RPC/handler system 
  230. //                      creates the server object as if it were an inproc 
  231. //                      server with no handler, but our EXE-based objects 
  232. //                      must use the default handler.
  233. //
  234. //**************************************************************************
  235.  
  236. //***********************************
  237. //
  238. // Implementation methods
  239. //
  240. //***********************************
  241.  
  242. BOleInProcFactory::BOleInProcFactory (BOleClassManager *pCM, 
  243.                                       BOleFact FAR *pF, REFIID iid) :  
  244.   BOleComponent(pCM, NULL),
  245.   iidServer (iid),
  246.   nRef (1),
  247.   pRealFactory (pF),
  248.   regCookie (0)
  249. {
  250.   pF->AddRef();
  251. }
  252.  
  253. BOleInProcFactory::~BOleInProcFactory ()
  254. {
  255.   if (pRealFactory) {
  256.     pRealFactory->Release();
  257.     pRealFactory = NULL;
  258.   }
  259. }
  260.  
  261. HRESULT _IFUNC BOleInProcFactory::Register (BOOL fSingleUse)
  262. {
  263.   HRESULT hr =  ::CoRegisterClassObject (
  264.     iidServer, this, CLSCTX_INPROC_SERVER, 
  265.     fSingleUse ? REGCLS_SINGLEUSE : REGCLS_MULTI_SEPARATE, ®Cookie);
  266.  
  267.   if (SUCCEEDED(hr)) {
  268.     LPCLASSFACTORY pWorkAround = this;
  269.     CoLockObjectExternal (pWorkAround, TRUE, TRUE);
  270.   }
  271.  
  272.   return hr;
  273. }
  274.  
  275. HRESULT _IFUNC BOleInProcFactory::Revoke ()
  276. {
  277.   if (regCookie) {
  278.     LPCLASSFACTORY pWorkAround = this;
  279.     CoLockObjectExternal (pWorkAround, FALSE, TRUE);
  280.     return ::CoRevokeClassObject (regCookie);
  281.   }
  282.  
  283.   if (pRealFactory) {               // this breaks a cycle when we're 
  284.     pRealFactory->Release();  // in the embed from file "registered case"
  285.     pRealFactory = NULL;
  286.   }
  287.   // if we don't register we expect releasing BOleInProcFactory
  288.   // to release BOleFact (since BOleInProcFactory is returned
  289.   // from DllGetClassObject)
  290.   //  
  291.   
  292.   return ResultFromScode (E_FAIL);
  293. }
  294.  
  295. //***********************************
  296. //
  297. // IUnknown methods
  298. //
  299. //***********************************
  300.  
  301. HRESULT _IFUNC BOleInProcFactory::QueryInterfaceMain(REFIID riid, 
  302.                                             LPVOID FAR *ppObj)
  303. {
  304.   HRESULT hr;
  305.   *ppObj = NULL;
  306.   if (SUCCEEDED(hr = IClassFactory_QueryInterface (this, riid, ppObj))) {
  307.   }
  308.   else if (SUCCEEDED(hr = BOleComponent::QueryInterfaceMain(riid, ppObj))) {
  309.   }
  310.   return hr;
  311. }
  312.  
  313. //***********************************
  314. // 
  315. // IClassFactory methods
  316. //
  317. //***********************************
  318.  
  319. HRESULT _IFUNC BOleInProcFactory::CreateInstance (LPUNKNOWN pUnkOuter, 
  320.                                   REFIID iidContainer, LPVOID FAR* ppv)
  321. {
  322.   // We ask OLE2 to create an instance
  323.   // of the default handler. The default handler uses pRealFactory to
  324.   // call back to us when it's time to create the real server object.
  325.   //
  326.   return ::OleCreateEmbeddingHelper (iidServer, pUnkOuter, 
  327.     EMBDHLP_INPROC_SERVER | EMBDHLP_DELAYCREATE, pRealFactory, 
  328.     iidContainer, ppv);
  329. }
  330.  
  331. HRESULT _IFUNC BOleInProcFactory::LockServer (BOOL fLock)
  332. {
  333.   ::CoLockObjectExternal (this, fLock, TRUE);
  334.   pFactory->ServerCount (fLock ? 1L : -1L);
  335.   return NOERROR;
  336. }
  337.  
  338.  
  339.  
  340. //***********************************
  341. // 
  342. // BOleControlFactory methods
  343. //
  344. //***********************************
  345.  
  346.   // rayk - this is a place holder for the real control class factory
  347.   //        this will properly handle the licensing information for 
  348.   //        controls that we create
  349.  
  350. BOleControlFact::BOleControlFact(BOleClassManager * pFact, 
  351.                                         IBUnknownMain *pOuter):
  352.   BOleFact (pFact, pOuter)
  353. {
  354. }
  355.  
  356. BOleControlFact::~BOleControlFact()
  357. {
  358. }
  359.  
  360. HRESULT _IFUNC BOleControlFact::QueryInterfaceMain(REFIID iid, LPVOID FAR* ppv)
  361. {
  362.   HRESULT hr = ResultFromScode(E_NOINTERFACE);
  363.   *ppv = NULL;
  364.  
  365.   // interfaces
  366.   
  367.   SUCCEEDED(hr = IClassFactory2_QueryInterface(this, iid, ppv))
  368.  
  369.   // base classes
  370.   
  371.   || SUCCEEDED(hr = BOleFact::QueryInterfaceMain(iid, ppv))
  372.     
  373.   // helpers
  374.   ;
  375.  
  376.   return hr;
  377. }
  378.  
  379.  
  380. HRESULT _IFUNC BOleControlFact::CreateInstanceLic (LPUNKNOWN pUnkOuter,
  381.                  LPUNKNOWN pUnkReserved, REFIID riid, BSTR bstrKey,
  382.                   LPVOID FAR* ppvObject)
  383. {
  384.   return ResultFromScode(E_FAIL);
  385. }
  386.  
  387.  
  388. HRESULT _IFUNC BOleControlFact::CreateInstance(IUnknown FAR* pUnk, 
  389.                  REFIID iid, LPVOID FAR* ppv)
  390. {
  391.   HRESULT hr = ResultFromScode(E_FAIL);
  392.   *ppv = 0L;
  393.  
  394.   PIUnknown pObj;
  395.   IBClassMgr * pICM;
  396.  
  397.   // rayk - need a check here to see if we think the license is valid  
  398.   if (SUCCEEDED(pObjCM->QueryInterface(IID_IBClassMgr, &(LPVOID)pICM))) {
  399.     if (SUCCEEDED(pICM->ComponentCreate(&pObj, pUnk, regId))) {
  400.       if (pUnk && iid == IID_IUnknown) {
  401.         hr = NOERROR;      
  402.         *ppv = pObj;  // always give out main IUnknown
  403.       }
  404.       else {
  405.         hr = pObj->QueryInterface(iid, ppv);
  406.         pObj->Release();  // QI bumps
  407.       }
  408.     }
  409.     pICM->Release();
  410.   }
  411.  
  412.   return hr;
  413. }
  414.  
  415.  
  416.  
  417. HRESULT _IFUNC BOleControlFact::GetLicInfo (LPLICINFO pLicInfo)
  418. {
  419.   return ResultFromScode(E_FAIL);
  420. }
  421.  
  422. HRESULT _IFUNC BOleControlFact::RequestLicKey (DWORD dwResrved, BSTR FAR* pbstrKey)
  423. {
  424.   return ResultFromScode(E_FAIL);
  425. }
  426.