![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to classfac.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline|
Return to classfac.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Sample Code
4: **
5: ** classfac.c
6: **
7: ** This file contains the implementation for IClassFactory for both the
8: ** server and the client version of the OUTLINE app.
9: **
10: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
11: **
12: *************************************************************************/
13:
14: #include "outline.h"
15:
16: OLEDBGDATA
17:
18: extern LPOUTLINEAPP g_lpApp;
19:
20:
21: /* OLE2NOTE: this object illustrates the manner in which to statically
22: ** (compile-time) initialize an interface VTBL.
23: */
24: static IClassFactoryVtbl g_AppClassFactoryVtbl = {
25: AppClassFactory_QueryInterface,
26: AppClassFactory_AddRef,
27: AppClassFactory_Release,
28: AppClassFactory_CreateInstance,
29: AppClassFactory_LockServer
30: };
31:
32:
33: /* AppClassFactory_Create
34: ** ----------------------
35: ** create an instance of APPCLASSFACTORY.
36: ** NOTE: type of pointer returned is an IClassFactory* interface ptr.
37: ** the returned pointer can be directly passed to
38: ** CoRegisterClassObject and released later by calling the
39: ** Release method of the interface.
40: */
41: LPCLASSFACTORY WINAPI AppClassFactory_Create(void)
42: {
43: LPAPPCLASSFACTORY lpAppClassFactory;
44: LPMALLOC lpMalloc;
45:
46: if (CoGetMalloc(MEMCTX_TASK, (LPMALLOC FAR*)&lpMalloc) != NOERROR)
47: return NULL;
48:
49: lpAppClassFactory = (LPAPPCLASSFACTORY)lpMalloc->lpVtbl->Alloc(
50: lpMalloc, (sizeof(APPCLASSFACTORY)));
51: lpMalloc->lpVtbl->Release(lpMalloc);
52: if (! lpAppClassFactory) return NULL;
53:
54: lpAppClassFactory->m_lpVtbl = &g_AppClassFactoryVtbl;
55: lpAppClassFactory->m_cRef = 1;
56: lpAppClassFactory->m_cLock = 0;
57:
58: return (LPCLASSFACTORY)lpAppClassFactory;
59: }
60:
61:
62: /*************************************************************************
63: ** OleApp::IClassFactory interface implementation
64: *************************************************************************/
65:
66: STDMETHODIMP AppClassFactory_QueryInterface(
67: LPCLASSFACTORY lpThis, REFIID riid, LPVOID FAR* ppvObj)
68: {
69: LPAPPCLASSFACTORY lpAppClassFactory = (LPAPPCLASSFACTORY)lpThis;
70: SCODE scode;
71:
72: // Two interfaces supported: IUnknown, IClassFactory
73:
74: if (IsEqualIID(riid, &IID_IClassFactory) ||
75: IsEqualIID(riid, &IID_IUnknown)) {
76: lpAppClassFactory->m_cRef++; // A pointer to this object is returned
77: *ppvObj = lpThis;
78: scode = S_OK;
79: }
80: else { // unsupported interface
81: *ppvObj = NULL;
82: scode = E_NOINTERFACE;
83: }
84:
85: return ResultFromScode(scode);
86: }
87:
88:
89: STDMETHODIMP_(ULONG) AppClassFactory_AddRef(LPCLASSFACTORY lpThis)
90: {
91: LPAPPCLASSFACTORY lpAppClassFactory = (LPAPPCLASSFACTORY)lpThis;
92: return ++lpAppClassFactory->m_cRef;
93: }
94:
95: STDMETHODIMP_(ULONG) AppClassFactory_Release(LPCLASSFACTORY lpThis)
96: {
97: LPAPPCLASSFACTORY lpAppClassFactory = (LPAPPCLASSFACTORY)lpThis;
98: LPMALLOC lpMalloc;
99:
100: if (--lpAppClassFactory->m_cRef != 0) // Still used by others
101: return lpAppClassFactory->m_cRef;
102:
103: // Free storage
104: if (CoGetMalloc(MEMCTX_TASK, (LPMALLOC FAR*)&lpMalloc) != NOERROR)
105: return 0;
106:
107: lpMalloc->lpVtbl->Free(lpMalloc, lpAppClassFactory);
108: lpMalloc->lpVtbl->Release(lpMalloc);
109: return 0;
110: }
111:
112:
113: STDMETHODIMP AppClassFactory_CreateInstance (
114: LPCLASSFACTORY lpThis,
115: LPUNKNOWN lpUnkOuter,
116: REFIID riid,
117: LPVOID FAR* lplpvObj
118: )
119: {
120: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
121: LPOLEDOC lpOleDoc;
122: HRESULT hrErr;
123:
124: OLEDBG_BEGIN2("AppClassFactory_CreateInstance\r\n")
125:
126: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
127: *lplpvObj = NULL;
128:
129: /*********************************************************************
130: ** OLE2NOTE: this is an SDI app; it can only create and support one
131: ** instance. After the instance is created, the OLE libraries
132: ** should not call CreateInstance again. it is a good practise
133: ** to specifically guard against this.
134: *********************************************************************/
135:
136: if (lpOutlineApp->m_lpDoc != NULL)
137: return ResultFromScode(E_UNEXPECTED);
138:
139: /* OLE2NOTE: create a new document instance. by the time we return
140: ** from this method the document's refcnt must be 1.
141: */
142: lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE);
143: lpOleDoc = (LPOLEDOC)lpOutlineApp->m_lpDoc;
144: if (! lpOleDoc) {
145: OLEDBG_END2
146: return ResultFromScode(E_OUTOFMEMORY);
147: }
148:
149: /* OLE2NOTE: retrieve pointer to requested interface. the ref cnt
150: ** of the object after OutlineApp_CreateDoc is 0. this call to
151: ** QueryInterface will increment the refcnt to 1. the object
152: ** returned from IClassFactory::CreateInstance should have a
153: ** refcnt of 1 and be controlled by the caller. If the caller
154: ** releases the document, the document should be destroyed.
155: */
156: hrErr = OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj);
157:
158: OLEDBG_END2
159: return hrErr;
160: }
161:
162:
163: STDMETHODIMP AppClassFactory_LockServer (
164: LPCLASSFACTORY lpThis,
165: BOOL fLock
166: )
167: {
168: LPAPPCLASSFACTORY lpAppClassFactory = (LPAPPCLASSFACTORY)lpThis;
169: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
170: HRESULT hrErr;
171:
172: OLEDBG_BEGIN2("AppClassFactory_LockServer\r\n")
173:
174: #if defined( _DEBUG )
175: if (fLock) {
176: ++lpAppClassFactory->m_cLock;
177:
178: OleDbgOutRefCnt3(
179: "AppClassFactory_LockServer: cLock++\r\n",
180: lpAppClassFactory, lpAppClassFactory->m_cLock);
181: } else {
182:
183: /* OLE2NOTE: when there are no open documents and the app is not
184: ** under the control of the user and there are no outstanding
185: ** locks on the app, then revoke our ClassFactory to enable the
186: ** app to shut down.
187: */
188: OleDbgAssertSz (lpAppClassFactory->m_cLock > 0,
189: "AppClassFactory_LockServer(FALSE) called with cLock == 0"
190: );
191:
192: --lpAppClassFactory->m_cLock;
193:
194: if (lpAppClassFactory->m_cLock == 0) {
195: OleDbgOutRefCnt2(
196: "AppClassFactory_LockServer: UNLOCKED\r\n",
197: lpAppClassFactory, lpAppClassFactory->m_cLock);
198: } else {
199: OleDbgOutRefCnt3(
200: "AppClassFactory_LockServer: cLock--\r\n",
201: lpAppClassFactory, lpAppClassFactory->m_cLock);
202: }
203: }
204: #endif // _DEBUG
205:
206: /* OLE2NOTE: in order to hold the application alive we call
207: ** CoLockObjectExternal to add a strong reference to our app
208: ** object. this will keep the app alive when all other external
209: ** references release us. if the user issues File.Exit the
210: ** application will shut down in any case ignoring any
211: ** outstanding LockServer locks because CoDisconnectObject is
212: ** called in OleApp_CloseAllDocsAndExitCommand. this will
213: ** forceably break any existing strong reference counts
214: ** including counts that we add ourselves by calling
215: ** CoLockObjectExternal and guarantee that the App object gets
216: ** its final release (ie. cRefs goes to 0).
217: */
218: hrErr = OleApp_Lock(lpOleApp, fLock, TRUE /* fLastUnlockReleases */);
219:
220: OLEDBG_END2
221: return hrErr;
222: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.