![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to olestd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui|
Return to olestd.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Standard Utilities
4: **
5: ** olestd.c
6: **
7: ** This file contains utilities that are useful for most standard
8: ** OLE 2.0 compound document type applications.
9: **
10: ** (c) Copyright Microsoft Corp. 1992 All Rights Reserved
11: **
12: *************************************************************************/
13:
14: #define NONAMELESSUNION // use strict ANSI standard (for DVOBJ.H)
15:
16: #define STRICT 1
17: #include "ole2ui.h"
18: #include <stdlib.h>
19: #include <ctype.h>
20: #include <shellapi.h>
21: #include "regdb.h"
22: #include "geticon.h"
23: #include "common.h"
24:
25: OLEDBGDATA
26:
27: static char szAssertMemAlloc[] = "CoGetMalloc failed";
28:
29:
30: /* OleStdSetupAdvises
31: ** ------------------
32: ** Setup the standard View and Ole advises required by a standard,
33: ** compound document-oriented container. Such a container relies on
34: ** Ole to manage the presentation of the Ole object. The container
35: ** call IViewObject::Draw to render (display) the object.
36: **
37: ** This helper routine performs the following tasks:
38: ** setup View advise
39: ** setup Ole advise
40: ** Call IOleObject::SetHostNames
41: ** Call OleSetContainedObject
42: */
43: STDAPI_(BOOL) OleStdSetupAdvises(LPOLEOBJECT lpOleObject, DWORD dwDrawAspect,
44: LPSTR lpszContainerApp, LPSTR lpszContainerObj,
45: LPADVISESINK lpAdviseSink)
46: {
47: LPVIEWOBJECT lpViewObject;
48: HRESULT hrErr;
49: DWORD dwTemp;
50: BOOL fStatus = TRUE;
51:
52: hrErr = lpOleObject->lpVtbl->QueryInterface(
53: lpOleObject,
54: &IID_IViewObject,
55: (LPVOID FAR*)&lpViewObject
56: );
57:
58: /* Setup View advise */
59: if (hrErr == NOERROR) {
60:
61: OLEDBG_BEGIN2("IViewObject::SetAdvise called\r\n")
62: lpViewObject->lpVtbl->SetAdvise(
63: lpViewObject,
64: dwDrawAspect,
65: 0,
66: lpAdviseSink
67: );
68: OLEDBG_END2
69:
70: OleStdRelease((LPUNKNOWN)lpViewObject);
71: } else {
72: fStatus = FALSE;
73: }
74:
75: /* Setup OLE advise.
76: ** OLE2NOTE: normally containers do NOT need to setup an OLE
77: ** advise. this advise connection is only useful for the OLE's
78: ** DefHandler and the OleLink object implementation. some
79: ** special container's might need to setup this advise for
80: ** programatic reasons.
81: **
82: ** NOTE: this advise will be torn down automatically by the
83: ** server when we release the object, therefore we do not need
84: ** to store the connection id.
85: */
86: OLEDBG_BEGIN2("IOleObject::Advise called\r\n")
87: hrErr = lpOleObject->lpVtbl->Advise(
88: lpOleObject,
89: lpAdviseSink,
90: (DWORD FAR*)&dwTemp
91: );
92: OLEDBG_END2
93: if (hrErr != NOERROR) fStatus = FALSE;
94:
95: /* Setup the host names for the OLE object. */
96: OLEDBG_BEGIN2("IOleObject::SetHostNames called\r\n")
97: hrErr = lpOleObject->lpVtbl->SetHostNames(
98: lpOleObject,
99: lpszContainerApp,
100: lpszContainerObj
101: );
102: OLEDBG_END2
103: if (hrErr != NOERROR) fStatus = FALSE;
104:
105: /* Inform the loadded object's handler/inproc-server that it is in
106: ** its embedding container's process.
107: */
108: OLEDBG_BEGIN2("OleSetContainedObject(TRUE) called\r\n")
109: OleSetContainedObject((LPUNKNOWN)lpOleObject, TRUE);
110: OLEDBG_END2
111:
112: return fStatus;
113: }
114:
115:
116: /* OleStdSwitchDisplayAspect
117: ** -------------------------
118: ** Switch the currently cached display aspect between DVASPECT_ICON
119: ** and DVASPECT_CONTENT.
120: **
121: ** NOTE: when setting up icon aspect, any currently cached content
122: ** cache is discarded and any advise connections for content aspect
123: ** are broken.
124: **
125: ** RETURNS:
126: ** S_OK -- new display aspect setup successfully
127: ** E_INVALIDARG -- IOleCache interface is NOT supported (this is
128: ** required).
129: ** <other SCODE> -- any SCODE that can be returned by
130: ** IOleCache::Cache method.
131: ** NOTE: if an error occurs then the current display aspect and
132: ** cache contents unchanged.
133: */
134: STDAPI OleStdSwitchDisplayAspect(
135: LPOLEOBJECT lpOleObj,
136: LPDWORD lpdwCurAspect,
137: DWORD dwNewAspect,
138: HGLOBAL hMetaPict,
139: BOOL fDeleteOldAspect,
140: BOOL fSetupViewAdvise,
141: LPADVISESINK lpAdviseSink,
142: BOOL FAR* lpfMustUpdate
143: )
144: {
145: LPOLECACHE lpOleCache = NULL;
146: LPVIEWOBJECT lpViewObj = NULL;
147: LPENUMSTATDATA lpEnumStatData = NULL;
148: STATDATA StatData;
149: FORMATETC FmtEtc;
150: STGMEDIUM Medium;
151: DWORD dwAdvf;
152: DWORD dwNewConnection;
153: DWORD dwOldAspect = *lpdwCurAspect;
154: HRESULT hrErr;
155:
156: *lpfMustUpdate = FALSE;
157:
158: lpOleCache = (LPOLECACHE)OleStdQueryInterface(
159: (LPUNKNOWN)lpOleObj,&IID_IOleCache);
160:
161: // if IOleCache* is NOT available, do nothing
162: if (! lpOleCache)
163: return ResultFromScode(E_INVALIDARG);
164:
165: // Setup new cache with the new aspect
166: FmtEtc.cfFormat = CF_METAFILEPICT;
167: FmtEtc.ptd = NULL;
168: FmtEtc.dwAspect = dwNewAspect;
169: FmtEtc.lindex = -1;
170: FmtEtc.tymed = TYMED_MFPICT;
171:
172: /* OLE2NOTE: if we are setting up Icon aspect with a custom icon
173: ** then we do not want DataAdvise notifications to ever change
174: ** the contents of the data cache. thus we set up a NODATA
175: ** advise connection. otherwise we set up a standard DataAdvise
176: ** connection.
177: */
178: if (dwNewAspect == DVASPECT_ICON && hMetaPict)
179: dwAdvf = ADVF_NODATA;
180: else
181: dwAdvf = ADVF_PRIMEFIRST;
182:
183: OLEDBG_BEGIN2("IOleCache::Cache called\r\n")
184: hrErr = lpOleCache->lpVtbl->Cache(
185: lpOleCache,
186: (LPFORMATETC)&FmtEtc,
187: dwAdvf,
188: (LPDWORD)&dwNewConnection
189: );
190: OLEDBG_END2
191:
192: if (! SUCCEEDED(hrErr)) {
193: OleDbgOutHResult("IOleCache::Cache returned", hrErr);
194: OleStdRelease((LPUNKNOWN)lpOleCache);
195: return hrErr;
196: }
197:
198: *lpdwCurAspect = dwNewAspect;
199:
200: /* OLE2NOTE: if we are setting up Icon aspect with a custom icon,
201: ** then stuff the icon into the cache. otherwise force the cache
202: ** to be updated. this will run the object if necessary.
203: */
204: if (dwNewAspect == DVASPECT_ICON && hMetaPict) {
205:
206: Medium.tymed = TYMED_MFPICT;
207: Medium.u.hGlobal = hMetaPict;
208: Medium.pUnkForRelease = NULL;
209:
210: OLEDBG_BEGIN2("IOleCache::SetData called\r\n")
211: hrErr = lpOleCache->lpVtbl->SetData(
212: lpOleCache,
213: (LPFORMATETC)&FmtEtc,
214: (LPSTGMEDIUM)&Medium,
215: FALSE /* fRelease */
216: );
217: OLEDBG_END2
218: } else {
219: *lpfMustUpdate = TRUE;
220: }
221:
222: if (fSetupViewAdvise && lpAdviseSink) {
223: /* OLE2NOTE: re-establish the ViewAdvise connection */
224: lpViewObj = (LPVIEWOBJECT)OleStdQueryInterface(
225: (LPUNKNOWN)lpOleObj,&IID_IViewObject);
226:
227: if (lpViewObj) {
228:
229: OLEDBG_BEGIN2("IViewObject::SetAdvise called\r\n")
230: lpViewObj->lpVtbl->SetAdvise(
231: lpViewObj,
232: dwNewAspect,
233: 0,
234: lpAdviseSink
235: );
236: OLEDBG_END2
237:
238: OleStdRelease((LPUNKNOWN)lpViewObj);
239: }
240: }
241:
242: /* OLE2NOTE: remove any existing caches that are set up for the old
243: ** display aspect. It WOULD be possible to retain the caches set
244: ** up for the old aspect, but this would increase the storage
245: ** space required for the object and possibly require additional
246: ** overhead to maintain the unused cachaes. For these reasons the
247: ** strategy to delete the previous caches is prefered. if it is a
248: ** requirement to quickly switch between Icon and Content
249: ** display, then it would be better to keep both aspect caches.
250: */
251:
252: if (fDeleteOldAspect) {
253: OLEDBG_BEGIN2("IOleCache::EnumCache called\r\n")
254: hrErr = lpOleCache->lpVtbl->EnumCache(
255: lpOleCache,
256: (LPENUMSTATDATA FAR*)&lpEnumStatData
257: );
258: OLEDBG_END2
259:
260: while(hrErr == NOERROR) {
261: hrErr = lpEnumStatData->lpVtbl->Next(
262: lpEnumStatData,
263: 1,
264: (LPSTATDATA)&StatData,
265: NULL
266: );
267: if (hrErr != NOERROR)
268: break; // DONE! no more caches.
269:
270: if (StatData.formatetc.dwAspect == dwOldAspect) {
271:
272: // Remove previous cache with old aspect
273: OLEDBG_BEGIN2("IOleCache::Uncache called\r\n")
274: lpOleCache->lpVtbl->Uncache(lpOleCache,StatData.dwConnection);
275: OLEDBG_END2
276: }
277: }
278:
279: if (lpEnumStatData) {
280: OleStdVerifyRelease(
281: (LPUNKNOWN)lpEnumStatData,
282: "OleStdSwitchDisplayAspect: Cache enumerator NOT released"
283: );
284: }
285: }
286:
287: if (lpOleCache)
288: OleStdRelease((LPUNKNOWN)lpOleCache);
289:
290: return NOERROR;
291: }
292:
293:
294: /* OleStdSetIconInCache
295: ** --------------------
296: ** SetData a new icon into the existing DVASPECT_ICON cache.
297: **
298: ** RETURNS:
299: ** HRESULT returned from IOleCache::SetData
300: */
301: STDAPI OleStdSetIconInCache(LPOLEOBJECT lpOleObj, HGLOBAL hMetaPict)
302: {
303: LPOLECACHE lpOleCache = NULL;
304: FORMATETC FmtEtc;
305: STGMEDIUM Medium;
306: HRESULT hrErr;
307:
308: if (! hMetaPict)
309: return FALSE; // invalid icon
310:
311: lpOleCache = (LPOLECACHE)OleStdQueryInterface(
312: (LPUNKNOWN)lpOleObj,&IID_IOleCache);
313: if (! lpOleCache)
314: return FALSE; // if IOleCache* is NOT available, do nothing
315:
316: FmtEtc.cfFormat = CF_METAFILEPICT;
317: FmtEtc.ptd = NULL;
318: FmtEtc.dwAspect = DVASPECT_ICON;
319: FmtEtc.lindex = -1;
320: FmtEtc.tymed = TYMED_MFPICT;
321:
322: // stuff the icon into the cache.
323: Medium.tymed = TYMED_MFPICT;
324: Medium.u.hGlobal = hMetaPict;
325: Medium.pUnkForRelease = NULL;
326:
327: OLEDBG_BEGIN2("IOleCache::SetData called\r\n")
328: hrErr = lpOleCache->lpVtbl->SetData(
329: lpOleCache,
330: (LPFORMATETC)&FmtEtc,
331: (LPSTGMEDIUM)&Medium,
332: FALSE /* fRelease */
333: );
334: OLEDBG_END2
335:
336: OleStdRelease((LPUNKNOWN)lpOleCache);
337:
338: return hrErr;
339: }
340:
341:
342:
343: /* OleStdDoConvert
344: ** ---------------
345: ** Do the container-side responsibilities for converting an object.
346: ** This function would be used in conjunction with the OleUIConvert
347: ** dialog. If the user selects to convert an object then the
348: ** container must do the following:
349: ** 1. unload the object.
350: ** 2. write the NEW CLSID and NEW user type name
351: ** string into the storage of the object,
352: ** BUT write the OLD format tag.
353: ** 3. force an update of the object to force the actual
354: ** conversion of the data bits.
355: **
356: ** This function takes care of step 2.
357: */
358: STDAPI OleStdDoConvert(LPSTORAGE lpStg, REFCLSID rClsidNew)
359: {
360: HRESULT error;
361: CLSID clsidOld;
362: CLIPFORMAT cfOld;
363: LPSTR lpszOld = NULL;
364: char szNew[OLEUI_CCHKEYMAX];
365:
366: if ((error = ReadClassStg(lpStg, &clsidOld)) != NOERROR) {
367: clsidOld = CLSID_NULL;
368: goto errRtn;
369: }
370:
371: // read old fmt/old user type; sets out params to NULL on error
372: error = ReadFmtUserTypeStg(lpStg, &cfOld, &lpszOld);
373: OleDbgAssert(error == NOERROR || (cfOld == 0 && lpszOld == NULL));
374:
375: // get new user type name; if error, set to NULL string
376: if (OleStdGetUserTypeOfClass(
377: (LPCLSID)rClsidNew, szNew,sizeof(szNew),NULL /* hKey */) == 0)
378: szNew[0] = '\0';
379:
380: // write class stg
381: if ((error = WriteClassStg(lpStg, rClsidNew)) != NOERROR)
382: goto errRtn;
383:
384: // write old fmt/new user type;
385: if ((error = WriteFmtUserTypeStg(lpStg, cfOld, szNew)) != NOERROR)
386: goto errRewriteInfo;
387:
388: // set convert bit
389: if ((error = SetConvertStg(lpStg, TRUE)) != NOERROR)
390: goto errRewriteInfo;
391:
392: // Commit the changes to make them permanent in the storage
393: OleStdCommitStorage(lpStg);
394: goto okRtn;
395:
396: errRewriteInfo:
397: (void)WriteClassStg(lpStg, &clsidOld);
398: (void)WriteFmtUserTypeStg(lpStg, cfOld, lpszOld);
399:
400: errRtn:
401:
402: okRtn:
403: OleStdFreeString(lpszOld, NULL);
404: return error;
405: }
406:
407:
408: /* OleStdGetTreatAsFmtUserType
409: ** ---------------------------
410: ** Determine if the application should perform a TreatAs (ActivateAs
411: ** object or emulation) operation for the object that is stored in
412: ** the storage.
413: **
414: ** if the CLSID written in the storage is not the same as the
415: ** application's own CLSID (clsidApp), then a TreatAs operation
416: ** should take place. if so determine the format the data should be
417: ** written and the user type name of the object the app should
418: ** emulate (ie. pretend to be). if this information is not written
419: ** in the storage then it is looked up in the REGDB. if it can not
420: ** be found in the REGDB, then the TreatAs operation can NOT be
421: ** executed.
422: **
423: ** RETURNS: TRUE -- if TreatAs should be performed.
424: ** valid lpclsid, lplpszType, lpcfFmt to TreatAs are returned
425: ** (NOTE: lplpszType must be freed by caller)
426: ** FALSE -- NO TreatAs. lpszType will be NULL.
427: ** lpclsid = CLSID_NULL; lplpszType = lpcfFmt = NULL;
428: */
429: STDAPI_(BOOL) OleStdGetTreatAsFmtUserType(
430: REFCLSID rclsidApp,
431: LPSTORAGE lpStg,
432: CLSID FAR* lpclsid,
433: CLIPFORMAT FAR* lpcfFmt,
434: LPSTR FAR* lplpszType
435: )
436: {
437: HRESULT hrErr;
438: HKEY hKey;
439: LONG lRet;
440: UINT lSize;
441: char szBuf[OLEUI_CCHKEYMAX];
442:
443: *lpclsid = CLSID_NULL;
444: *lpcfFmt = 0;
445: *lplpszType = NULL;
446:
447: hrErr = ReadClassStg(lpStg, lpclsid);
448: if (hrErr == NOERROR &&
449: ! IsEqualCLSID(lpclsid, &CLSID_NULL) &&
450: ! IsEqualCLSID(lpclsid, rclsidApp)) {
451:
452: hrErr = ReadFmtUserTypeStg(lpStg,(CLIPFORMAT FAR*)lpcfFmt,lplpszType);
453: if (hrErr == NOERROR && lplpszType && *lpcfFmt != 0)
454: return TRUE; // Do TreatAs. info was in lpStg.
455:
456: /* read info from REGDB
457: ** *lpcfFmt = value of field: CLSID\{...}\DataFormats\DefaultFile
458: ** *lplpszType = value of field: CLSID\{...}
459: */
460: //Open up the root key.
461: lRet=RegOpenKey(HKEY_CLASSES_ROOT, NULL, &hKey);
462: if (lRet != (LONG)ERROR_SUCCESS)
463: return FALSE;
464: *lpcfFmt = OleStdGetDefaultFileFormatOfClass(lpclsid, hKey);
465: if (*lpcfFmt == 0)
466: return FALSE;
467: lSize = OleStdGetUserTypeOfClass(lpclsid,szBuf,sizeof(szBuf),hKey);
468: if (lSize == 0)
469: return FALSE;
470: *lplpszType = OleStdCopyString(szBuf, NULL);
471: } else {
472: return FALSE; // NO TreatAs
473: }
474: }
475:
476:
477:
478: /* OleStdDoConvert
479: ** ---------------
480: ** Do the container-side responsibilities for "ActivateAs" (aka.
481: ** TreatAs) for an object.
482: ** This function would be used in conjunction with the OleUIConvert
483: ** dialog. If the user selects to ActivateAs an object then the
484: ** container must do the following:
485: ** 1. unload ALL objects of the OLD class that app knows about
486: ** 2. add the TreatAs tag in the registration database
487: ** by calling CoTreatAsClass().
488: ** 3. lazily it can reload the objects; when the objects
489: ** are reloaded the TreatAs will take effect.
490: **
491: ** This function takes care of step 2.
492: */
493: STDAPI OleStdDoTreatAsClass(LPSTR lpszUserType, REFCLSID rclsid, REFCLSID rclsidNew)
494: {
495: HRESULT hrErr;
496: LPSTR lpszCLSID = NULL;
497: LONG lRet;
498: HKEY hKey;
499:
500: OLEDBG_BEGIN2("CoTreatAsClass called\r\n")
501: hrErr = CoTreatAsClass(rclsid, rclsidNew);
502: OLEDBG_END2
503:
504: if ((hrErr != NOERROR) && lpszUserType) {
505: lRet = RegOpenKey(HKEY_CLASSES_ROOT, (LPCSTR)"CLSID",
506: (HKEY FAR *)&hKey);
507: StringFromCLSID(rclsid, (LPSTR FAR*)&lpszCLSID);
508: RegSetValue(hKey, lpszCLSID, REG_SZ, lpszUserType,
509: lstrlen(lpszUserType));
510:
511: if (lpszCLSID)
512: OleStdFreeString(lpszCLSID, NULL);
513:
514: hrErr = CoTreatAsClass(rclsid, rclsidNew);
515: RegCloseKey(hKey);
516: }
517:
518: return hrErr;
519: }
520:
521:
522:
523: /* OleStdIsOleLink
524: ** ---------------
525: ** Returns TRUE if the OleObject is infact an OLE link object. this
526: ** checks if IOleLink interface is supported. if so, the object is a
527: ** link, otherwise not.
528: */
529: STDAPI_(BOOL) OleStdIsOleLink(LPUNKNOWN lpUnk)
530: {
531: LPOLELINK lpOleLink;
532:
533: lpOleLink = (LPOLELINK)OleStdQueryInterface(lpUnk, &IID_IOleLink);
534:
535: if (lpOleLink) {
536: OleStdRelease((LPUNKNOWN)lpOleLink);
537: return TRUE;
538: } else
539: return FALSE;
540: }
541:
542:
543: /* OleStdQueryInterface
544: ** --------------------
545: ** Returns the desired interface pointer if exposed by the given object.
546: ** Returns NULL if the interface is not available.
547: ** eg.:
548: ** lpDataObj = OleStdQueryInterface(lpOleObj, &IID_DataObject);
549: */
550: STDAPI_(LPUNKNOWN) OleStdQueryInterface(LPUNKNOWN lpUnk, REFIID riid)
551: {
552: LPUNKNOWN lpInterface;
553: HRESULT hrErr;
554:
555: hrErr = lpUnk->lpVtbl->QueryInterface(
556: lpUnk,
557: riid,
558: (LPVOID FAR*)&lpInterface
559: );
560:
561: if (hrErr == NOERROR)
562: return lpInterface;
563: else
564: return NULL;
565: }
566:
567:
568: /* OleStdGetData
569: ** -------------
570: ** Retrieve data from an IDataObject in a specified format on a
571: ** global memory block. This function ALWAYS returns a private copy
572: ** of the data to the caller. if necessary a copy is made of the
573: ** data (ie. if lpMedium->pUnkForRelease != NULL). The caller assumes
574: ** ownership of the data block in all cases and must free the data
575: ** when done with it. The caller may directly free the data handle
576: ** returned (taking care whether it is a simple HGLOBAL or a HANDLE
577: ** to a MetafilePict) or the caller may call
578: ** ReleaseStgMedium(lpMedium). this OLE helper function will do the
579: ** right thing.
580: **
581: ** PARAMETERS:
582: ** LPDATAOBJECT lpDataObj -- object on which GetData should be
583: ** called.
584: ** CLIPFORMAT cfFormat -- desired clipboard format (eg. CF_TEXT)
585: ** DVTARGETDEVICE FAR* lpTargetDevice -- target device for which
586: ** the data should be composed. This may
587: ** be NULL. NULL can be used whenever the
588: ** data format is insensitive to target
589: ** device or when the caller does not care
590: ** what device is used.
591: ** LPSTGMEDIUM lpMedium -- ptr to STGMEDIUM struct. the
592: ** resultant medium from the
593: ** IDataObject::GetData call is
594: ** returned.
595: **
596: ** RETURNS:
597: ** HGLOBAL -- global memory handle of retrieved data block.
598: ** NULL -- if error.
599: */
600: STDAPI_(HGLOBAL) OleStdGetData(
601: LPDATAOBJECT lpDataObj,
602: CLIPFORMAT cfFormat,
603: DVTARGETDEVICE FAR* lpTargetDevice,
604: DWORD dwAspect,
605: LPSTGMEDIUM lpMedium
606: )
607: {
608: HRESULT hrErr;
609: FORMATETC formatetc;
610: HGLOBAL hGlobal = NULL;
611: HGLOBAL hCopy;
612: LPVOID lp;
613:
614: formatetc.cfFormat = cfFormat;
615: formatetc.ptd = lpTargetDevice;
616: formatetc.dwAspect = dwAspect;
617: formatetc.lindex = -1;
618:
619: switch (cfFormat) {
620: case CF_METAFILEPICT:
621: formatetc.tymed = TYMED_MFPICT;
622: break;
623:
624: case CF_BITMAP:
625: formatetc.tymed = TYMED_GDI;
626: break;
627:
628: default:
629: formatetc.tymed = TYMED_HGLOBAL;
630: break;
631: }
632:
633: OLEDBG_BEGIN2("IDataObject::GetData called\r\n")
634: hrErr = lpDataObj->lpVtbl->GetData(
635: lpDataObj,
636: (LPFORMATETC)&formatetc,
637: lpMedium
638: );
639: OLEDBG_END2
640:
641: if (hrErr != NOERROR)
642: return NULL;
643:
644: if ((hGlobal = lpMedium->u.hGlobal) == NULL)
645: return NULL;
646:
647: // Check if hGlobal really points to valid memory
648: if ((lp = GlobalLock(hGlobal)) != NULL) {
649: if (IsBadReadPtr(lp, 1)) {
650: GlobalUnlock(hGlobal);
651: return NULL; // ERROR: memory is NOT valid
652: }
653: GlobalUnlock(hGlobal);
654: }
655:
656: if (hGlobal != NULL && lpMedium->pUnkForRelease != NULL) {
657: /* OLE2NOTE: the callee wants to retain ownership of the data.
658: ** this is indicated by passing a non-NULL pUnkForRelease.
659: ** thus, we will make a copy of the data and release the
660: ** callee's copy.
661: */
662:
663: hCopy = OleDuplicateData(hGlobal, cfFormat, GHND|GMEM_SHARE);
664: ReleaseStgMedium(lpMedium); // release callee's copy of data
665:
666: hGlobal = hCopy;
667: lpMedium->u.hGlobal = hCopy;
668: lpMedium->pUnkForRelease = NULL;
669: }
670: return hGlobal;
671: }
672:
673:
674: /* OleStdMalloc
675: ** ------------
676: ** allocate memory using the currently active IMalloc* allocator
677: */
678: STDAPI_(LPVOID) OleStdMalloc(ULONG ulSize)
679: {
680: LPVOID pout;
681: LPMALLOC pmalloc;
682:
683: if (CoGetMalloc(MEMCTX_TASK, &pmalloc) != S_OK) {
684: OleDbgAssertSz(0, szAssertMemAlloc);
685: return NULL;
686: }
687:
688: pout = (LPVOID)pmalloc->lpVtbl->Alloc(pmalloc, ulSize);
689:
690: if (pmalloc != NULL) {
691: ULONG refs = pmalloc->lpVtbl->Release(pmalloc);
692: }
693:
694: return pout;
695: }
696:
697:
698: /* OleStdRealloc
699: ** -------------
700: ** re-allocate memory using the currently active IMalloc* allocator
701: */
702: STDAPI_(LPVOID) OleStdRealloc(LPVOID pmem, ULONG ulSize)
703: {
704: LPVOID pout;
705: LPMALLOC pmalloc;
706:
707: if (CoGetMalloc(MEMCTX_TASK, &pmalloc) != S_OK) {
708: OleDbgAssertSz(0, szAssertMemAlloc);
709: return NULL;
710: }
711:
712: pout = (LPVOID)pmalloc->lpVtbl->Realloc(pmalloc, pmem, ulSize);
713:
714: if (pmalloc != NULL) {
715: ULONG refs = pmalloc->lpVtbl->Release(pmalloc);
716: }
717:
718: return pout;
719: }
720:
721:
722: /* OleStdFree
723: ** ----------
724: ** free memory using the currently active IMalloc* allocator
725: */
726: STDAPI_(void) OleStdFree(LPVOID pmem)
727: {
728: LPMALLOC pmalloc;
729:
730: if (pmem == NULL)
731: return;
732:
733: if (CoGetMalloc(MEMCTX_TASK, &pmalloc) != S_OK) {
734: OleDbgAssertSz(0, szAssertMemAlloc);
735: return;
736: }
737:
738: pmalloc->lpVtbl->Free(pmalloc, pmem);
739:
740: if (pmalloc != NULL) {
741: ULONG refs = pmalloc->lpVtbl->Release(pmalloc);
742: }
743:
744: }
745:
746:
747: /* OleStdGetSize
748: ** -------------
749: ** Get the size of a memory block that was allocated using the
750: ** currently active IMalloc* allocator.
751: */
752: STDAPI_(ULONG) OleStdGetSize(LPVOID pmem)
753: {
754: ULONG ulSize;
755: LPMALLOC pmalloc;
756:
757: if (CoGetMalloc(MEMCTX_TASK, &pmalloc) != S_OK) {
758: OleDbgAssertSz(0, szAssertMemAlloc);
759: return (ULONG)-1;
760: }
761:
762: ulSize = pmalloc->lpVtbl->GetSize(pmalloc, pmem);
763:
764: if (pmalloc != NULL) {
765: ULONG refs = pmalloc->lpVtbl->Release(pmalloc);
766: }
767:
768: return ulSize;
769: }
770:
771:
772: /* OleStdFreeString
773: ** ----------------
774: ** Free a string that was allocated with the currently active
775: ** IMalloc* allocator.
776: **
777: ** if the caller has the current IMalloc* handy, then it can be
778: ** passed as a argument, otherwise this function will retrieve the
779: ** active allocator and use it.
780: */
781: STDAPI_(void) OleStdFreeString(LPSTR lpsz, LPMALLOC lpMalloc)
782: {
783: BOOL fMustRelease = FALSE;
784:
785: if (! lpMalloc) {
786: if (CoGetMalloc(MEMCTX_TASK, &lpMalloc) != NOERROR)
787: return;
788: fMustRelease = TRUE;
789: }
790:
791: lpMalloc->lpVtbl->Free(lpMalloc, lpsz);
792:
793: if (fMustRelease)
794: OleStdRelease((LPUNKNOWN)lpMalloc);
795: }
796:
797:
798: /* OleStdCopyString
799: ** ----------------
800: ** Copy a string into memory allocated with the currently active
801: ** IMalloc* allocator.
802: **
803: ** if the caller has the current IMalloc* handy, then it can be
804: ** passed as a argument, otherwise this function will retrieve the
805: ** active allocator and use it.
806: */
807: STDAPI_(LPSTR) OleStdCopyString(LPSTR lpszSrc, LPMALLOC lpMalloc)
808: {
809: LPSTR lpszDest = NULL;
810: BOOL fMustRelease = FALSE;
811: UINT lSize = lstrlen(lpszSrc);
812:
813: if (! lpMalloc) {
814: if (CoGetMalloc(MEMCTX_TASK, &lpMalloc) != NOERROR)
815: return NULL;
816: fMustRelease = TRUE;
817: }
818:
819: lpszDest = lpMalloc->lpVtbl->Alloc(lpMalloc, lSize+1);
820:
821: if (lpszDest)
822: lstrcpy(lpszDest, lpszSrc);
823:
824: if (fMustRelease)
825: OleStdRelease((LPUNKNOWN)lpMalloc);
826: return lpszDest;
827: }
828:
829:
830: /*
831: * OleStdCreateStorageOnHGlobal()
832: *
833: * Purpose:
834: * Create a memory based IStorage*.
835: *
836: * OLE2NOTE: if fDeleteOnRelease==TRUE, then the ILockBytes is created
837: * such that it will delete them memory on its last release.
838: * the IStorage on created on top of the ILockBytes in NOT
839: * created with STGM_DELETEONRELEASE. when the IStorage receives
840: * its last release, it will release the ILockBytes which will
841: * in turn free the memory. it is in fact an error to specify
842: * STGM_DELETEONRELEASE in this situation.
843: *
844: * Parameters:
845: * hGlobal -- handle to MEM_SHARE allocated memory. may be NULL and
846: * memory will be automatically allocated.
847: * fDeleteOnRelease -- controls if the memory is freed on the last release.
848: * grfMode -- flags passed to StgCreateDocfileOnILockBytes
849: *
850: * NOTE: if hGlobal is NULL, then a new IStorage is created and
851: * STGM_CREATE flag is passed to StgCreateDocfileOnILockBytes.
852: * if hGlobal is non-NULL, then it is assumed that the hGlobal already
853: * has an IStorage inside it and STGM_CONVERT flag is passed
854: * to StgCreateDocfileOnILockBytes.
855: *
856: * Return Value:
857: * SCODE - S_OK if successful
858: */
859: STDAPI_(LPSTORAGE) OleStdCreateStorageOnHGlobal(
860: HANDLE hGlobal,
861: BOOL fDeleteOnRelease,
862: DWORD grfMode
863: )
864: {
865: DWORD grfCreateMode=grfMode | (hGlobal==NULL ? STGM_CREATE:STGM_CONVERT);
866: HRESULT hrErr;
867: LPLOCKBYTES lpLockBytes = NULL;
868: DWORD reserved = 0;
869: LPSTORAGE lpStg = NULL;
870:
871: hrErr = CreateILockBytesOnHGlobal(
872: hGlobal,
873: fDeleteOnRelease,
874: (LPLOCKBYTES FAR*)&lpLockBytes
875: );
876: if (hrErr != NOERROR)
877: return NULL;
878:
879: hrErr = StgCreateDocfileOnILockBytes(
880: lpLockBytes,
881: grfCreateMode,
882: reserved,
883: (LPSTORAGE FAR*)&lpStg
884: );
885: if (hrErr != NOERROR) {
886: OleStdRelease((LPUNKNOWN)lpLockBytes);
887: return NULL;
888: }
889: return lpStg;
890: }
891:
892:
893:
894: /*
895: * OleStdCreateTempStorage()
896: *
897: * Purpose:
898: * Create a temporay IStorage* that will DeleteOnRelease.
899: * this can be either memory based or file based.
900: *
901: * Parameters:
902: * fUseMemory -- controls if memory-based or file-based stg is created
903: * grfMode -- storage mode flags
904: *
905: * Return Value:
906: * LPSTORAGE - if successful, NULL otherwise
907: */
908: STDAPI_(LPSTORAGE) OleStdCreateTempStorage(BOOL fUseMemory, DWORD grfMode)
909: {
910: LPSTORAGE lpstg;
911: HRESULT hrErr;
912: DWORD reserved = 0;
913:
914: if (fUseMemory) {
915: lpstg = OleStdCreateStorageOnHGlobal(
916: NULL, /* auto allocate */
917: TRUE, /* delete on release */
918: grfMode
919: );
920: } else {
921: /* allocate a temp docfile that will delete on last release */
922: hrErr = StgCreateDocfile(
923: NULL,
924: grfMode | STGM_DELETEONRELEASE | STGM_CREATE,
925: reserved,
926: &lpstg
927: );
928: if (hrErr != NOERROR)
929: return NULL;
930: }
931: return lpstg;
932: }
933:
934:
935: /* OleStdGetOleObjectData
936: ** ----------------------
937: ** Render CF_EMBEDSOURCE/CF_EMBEDDEDOBJECT data on an TYMED_ISTORAGE
938: ** medium by asking the object to save into the storage.
939: ** the object must support IPersistStorage.
940: **
941: ** if lpMedium->tymed == TYMED_NULL, then a delete-on-release
942: ** storage is allocated (either file-based or memory-base depending
943: ** the value of fUseMemory). this is useful to support an
944: ** IDataObject::GetData call where the callee must allocate the
945: ** medium.
946: **
947: ** if lpMedium->tymed == TYMED_ISTORAGE, then the data is writen
948: ** into the passed in IStorage. this is useful to support an
949: ** IDataObject::GetDataHere call where the caller has allocated his
950: ** own IStorage.
951: */
952: STDAPI OleStdGetOleObjectData(
953: LPPERSISTSTORAGE lpPStg,
954: LPFORMATETC lpformatetc,
955: LPSTGMEDIUM lpMedium,
956: BOOL fUseMemory
957: )
958: {
959: LPSTORAGE lpstg = NULL;
960: DWORD reserved = 0;
961: SCODE sc = S_OK;
962: HRESULT hrErr;
963:
964: lpMedium->pUnkForRelease = NULL;
965:
966: if (lpMedium->tymed == TYMED_NULL) {
967:
968: if (lpformatetc->tymed & TYMED_ISTORAGE) {
969:
970: /* allocate a temp docfile that will delete on last release */
971: lpstg = OleStdCreateTempStorage(
972: TRUE /*fUseMemory*/,
973: STGM_READWRITE | STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE
974: );
975: if (!lpstg)
976: return ResultFromScode(E_OUTOFMEMORY);
977:
978: lpMedium->u.pstg = lpstg;
979: lpMedium->tymed = TYMED_ISTORAGE;
980: lpMedium->pUnkForRelease = NULL;
981: } else {
982: return ResultFromScode(DATA_E_FORMATETC);
983: }
984: } else if (lpMedium->tymed == TYMED_ISTORAGE) {
985: lpMedium->tymed = TYMED_ISTORAGE;
986: } else {
987: return ResultFromScode(DATA_E_FORMATETC);
988: }
989:
990: // OLE2NOTE: even if OleSave returns an error you should still call
991: // SaveCompleted.
992:
993: OLEDBG_BEGIN2("OleSave called\r\n")
994: hrErr = OleSave(lpPStg, lpMedium->u.pstg, FALSE /* fSameAsLoad */);
995: OLEDBG_END2
996:
997: if (hrErr != NOERROR) {
998: OleDbgOutHResult("WARNING: OleSave returned", hrErr);
999: sc = GetScode(hrErr);
1000: }
1001: OLEDBG_BEGIN2("IPersistStorage::SaveCompleted called\r\n")
1002: hrErr = lpPStg->lpVtbl->SaveCompleted(lpPStg, NULL);
1003: OLEDBG_END2
1004:
1005: if (hrErr != NOERROR) {
1006: OleDbgOutHResult("WARNING: SaveCompleted returned",hrErr);
1007: if (sc == S_OK)
1008: sc = GetScode(hrErr);
1009: }
1010:
1011: return ResultFromScode(sc);
1012: }
1013:
1014:
1015: STDAPI OleStdGetLinkSourceData(
1016: LPMONIKER lpmk,
1017: LPCLSID lpClsID,
1018: LPFORMATETC lpformatetc,
1019: LPSTGMEDIUM lpMedium
1020: )
1021: {
1022: LPSTREAM lpstm = NULL;
1023: DWORD reserved = 0;
1024: HRESULT hrErr;
1025:
1026: if (lpMedium->tymed == TYMED_NULL) {
1027: if (lpformatetc->tymed & TYMED_ISTREAM) {
1028: hrErr = CreateStreamOnHGlobal(
1029: NULL, /* auto allocate */
1030: TRUE, /* delete on release */
1031: (LPSTREAM FAR*)&lpstm
1032: );
1033: if (hrErr != NOERROR) {
1034: lpMedium->pUnkForRelease = NULL;
1035: return ResultFromScode(E_OUTOFMEMORY);
1036: }
1037: lpMedium->u.pstm = lpstm;
1038: lpMedium->tymed = TYMED_ISTREAM;
1039: lpMedium->pUnkForRelease = NULL;
1040: } else {
1041: lpMedium->pUnkForRelease = NULL;
1042: return ResultFromScode(DATA_E_FORMATETC);
1043: }
1044: } else {
1045: if (lpMedium->tymed == TYMED_ISTREAM) {
1046: lpMedium->tymed = TYMED_ISTREAM;
1047: lpMedium->u.pstm = lpMedium->u.pstm;
1048: lpMedium->pUnkForRelease = NULL;
1049: } else {
1050: lpMedium->pUnkForRelease = NULL;
1051: return ResultFromScode(DATA_E_FORMATETC);
1052: }
1053: }
1054:
1055: hrErr = OleSaveToStream((LPPERSISTSTREAM)lpmk, lpMedium->u.pstm);
1056: if (hrErr != NOERROR) return hrErr;
1057: return WriteClassStm(lpMedium->u.pstm, lpClsID);
1058: }
1059:
1060: /*
1061: * OleStdGetObjectDescriptorData
1062: *
1063: * Purpose:
1064: * Fills and returns a OBJECTDESCRIPTOR structure.
1065: * See OBJECTDESCRIPTOR for more information.
1066: *
1067: * Parameters:
1068: * clsid CLSID CLSID of object being transferred
1069: * dwAspect DWORD Display Aspect of object
1070: * sizel SIZEL Size of object in HIMETRIC
1071: * pointl POINTL Offset from upper-left corner of object where mouse went
1072: * down for drag. Meaningful only when drag-drop is used.
1073: * dwStatus DWORD OLEMISC flags
1074: * lpszFullUserTypeName LPSTR Full User Type Name
1075: * lpszSrcOfCopy LPSTR Source of Copy
1076: *
1077: * Return Value:
1078: * HBGLOBAL Handle to OBJECTDESCRIPTOR structure.
1079: */
1080: STDAPI_(HGLOBAL) OleStdGetObjectDescriptorData(
1081: CLSID clsid,
1082: DWORD dwAspect,
1083: SIZEL sizel,
1084: POINTL pointl,
1085: DWORD dwStatus,
1086: LPSTR lpszFullUserTypeName,
1087: LPSTR lpszSrcOfCopy
1088: )
1089: {
1090: HGLOBAL hMem = NULL;
1091: IBindCtx FAR *pbc = NULL;
1092: LPOBJECTDESCRIPTOR lpOD;
1093: DWORD dwObjectDescSize, dwFullUserTypeNameLen, dwSrcOfCopyLen;
1094:
1095: // Get the length of Full User Type Name; Add 1 for the null terminator
1096: dwFullUserTypeNameLen = lpszFullUserTypeName ? lstrlen(lpszFullUserTypeName)+1 : 0;
1097:
1098: // Get the Source of Copy string and it's length; Add 1 for the null terminator
1099: if (lpszSrcOfCopy)
1100: dwSrcOfCopyLen = lstrlen(lpszSrcOfCopy)+1;
1101: else {
1102: // No src moniker so use user type name as source string.
1103: lpszSrcOfCopy = lpszFullUserTypeName;
1104: dwSrcOfCopyLen = dwFullUserTypeNameLen;
1105: }
1106:
1107: // Allocate space for OBJECTDESCRIPTOR and the additional string data
1108: dwObjectDescSize = sizeof(OBJECTDESCRIPTOR);
1109: hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
1110: dwObjectDescSize + dwFullUserTypeNameLen + dwSrcOfCopyLen);
1111: if (NULL == hMem)
1112: goto error;
1113:
1114: lpOD = (LPOBJECTDESCRIPTOR)GlobalLock(hMem);
1115:
1116: // Set the FullUserTypeName offset and copy the string
1117: if (lpszFullUserTypeName)
1118: {
1119: lpOD->dwFullUserTypeName = dwObjectDescSize;
1120: lstrcpy((LPSTR)lpOD+lpOD->dwFullUserTypeName , lpszFullUserTypeName);
1121: }
1122: else lpOD->dwFullUserTypeName = 0; // zero offset indicates that string is not present
1123:
1124: // Set the SrcOfCopy offset and copy the string
1125: if (lpszSrcOfCopy)
1126: {
1127: lpOD->dwSrcOfCopy = dwObjectDescSize + dwFullUserTypeNameLen;
1128: lstrcpy((LPSTR)lpOD+lpOD->dwSrcOfCopy , lpszSrcOfCopy);
1129: }
1130: else lpOD->dwSrcOfCopy = 0; // zero offset indicates that string is not present
1131:
1132: // Initialize the rest of the OBJECTDESCRIPTOR
1133: lpOD->cbSize = dwObjectDescSize + dwFullUserTypeNameLen + dwSrcOfCopyLen;
1134: lpOD->clsid = clsid;
1135: lpOD->dwDrawAspect = dwAspect;
1136: lpOD->sizel = sizel;
1137: lpOD->pointl = pointl;
1138: lpOD->dwStatus = dwStatus;
1139:
1140: GlobalUnlock(hMem);
1141: return hMem;
1142:
1143: error:
1144: if (hMem)
1145: {
1146: GlobalUnlock(hMem);
1147: GlobalFree(hMem);
1148: }
1149: return NULL;
1150: }
1151:
1152: /*
1153: * OleStdGetObjectDescriptorDataFromOleObject
1154: *
1155: * Purpose:
1156: * Fills and returns a OBJECTDESCRIPTOR structure. Information for the structure is
1157: * obtained from an OLEOBJECT.
1158: * See OBJECTDESCRIPTOR for more information.
1159: *
1160: * Parameters:
1161: * lpOleObj LPOLEOBJECT OleObject from which ONJECTDESCRIPTOR info
1162: * is obtained.
1163: * lpszSrcOfCopy LPSTR string to identify source of copy.
1164: * May be NULL in which case IOleObject::GetMoniker is called
1165: * to get the moniker of the object. if the object is loaded
1166: * as part of a data transfer document, then usually
1167: * lpOleClientSite==NULL is passed to OleLoad when loading
1168: * the object. in this case the IOleObject:GetMoniker call
1169: * will always fail (it tries to call back to the object's
1170: * client site). in this situation a non-NULL lpszSrcOfCopy
1171: * parameter should be passed.
1172: * dwAspect DWORD Display Aspect of object
1173: * pointl POINTL Offset from upper-left corner of object where mouse went
1174: * down for drag. Meaningful only when drag-drop is used.
1175: *
1176: * Return Value:
1177: * HBGLOBAL Handle to OBJECTDESCRIPTOR structure.
1178: */
1179:
1180: STDAPI_(HGLOBAL) OleStdGetObjectDescriptorDataFromOleObject(
1181: LPOLEOBJECT lpOleObj,
1182: LPSTR lpszSrcOfCopy,
1183: DWORD dwAspect,
1184: POINTL pointl
1185: )
1186: {
1187: CLSID clsid;
1188: LPSTR lpszFullUserTypeName = NULL;
1189: LPMONIKER lpSrcMonikerOfCopy = NULL;
1190: HGLOBAL hObjDesc;
1191: IBindCtx FAR *pbc = NULL;
1192: HRESULT hrErr;
1193: SIZEL sizel;
1194: BOOL fFreeSrcOfCopy = FALSE;
1195: LPOLELINK lpOleLink =
1196: (LPOLELINK)OleStdQueryInterface((LPUNKNOWN)lpOleObj,&IID_IOleLink);
1197: BOOL fIsLink = (lpOleLink ? TRUE : FALSE);
1198: char szLinkedTypeFmt[80];
1199: LPSTR lpszBuf = NULL;
1200: DWORD dwStatus = 0;
1201:
1202: // Get CLSID
1203: OLEDBG_BEGIN2("IOleObject::GetUserClassID called\r\n")
1204: hrErr = lpOleObj->lpVtbl->GetUserClassID(lpOleObj, &clsid);
1205: OLEDBG_END2
1206: if (hrErr != NOERROR)
1207: clsid = CLSID_NULL;
1208:
1209: // Get FullUserTypeName
1210: OLEDBG_BEGIN2("IOleObject::GetUserType called\r\n")
1211: hrErr = lpOleObj->lpVtbl->GetUserType(
1212: lpOleObj,
1213: USERCLASSTYPE_FULL,
1214: (LPSTR FAR*)&lpszFullUserTypeName
1215: );
1216: OLEDBG_END2
1217:
1218: // REVIEW: added IDS_OLE2UILINKEDTYPE to strings.rc
1219: /* if object is a link, then expand usertypename to be "Linked %s" */
1220: if (fIsLink && lpszFullUserTypeName) {
1221: lpszBuf = OleStdMalloc(
1222: lstrlen(lpszFullUserTypeName)+lstrlen(szLinkedTypeFmt)+1);
1223: if (lpszBuf) {
1224: #if defined( LATER )
1225: if (0 == LoadString(ghInst, IDS_OLE2UILINKEDTYPE,
1226: (LPSTR)szLinkedTypeFmt, sizeof(szLinkedTypeFmt)))
1227: #endif
1228: lstrcpy(szLinkedTypeFmt, (LPSTR)"Linked %s");
1229:
1230: wsprintf(lpszBuf, szLinkedTypeFmt, lpszFullUserTypeName);
1231: OleStdFreeString(lpszFullUserTypeName, NULL);
1232: lpszFullUserTypeName = lpszBuf;
1233: }
1234: }
1235:
1236: /* Get Source Of Copy
1237: ** if the object is an embedding, then get the object's moniker
1238: ** if the object is a link, then get the link source moniker
1239: */
1240: if (fIsLink) {
1241:
1242: OLEDBG_BEGIN2("IOleLink::GetSourceDisplayName called\r\n")
1243: hrErr = lpOleLink->lpVtbl->GetSourceDisplayName(
1244: lpOleLink, &lpszSrcOfCopy );
1245: OLEDBG_END2
1246: fFreeSrcOfCopy = TRUE;
1247:
1248: } else {
1249:
1250: if (lpszSrcOfCopy == NULL) {
1251: OLEDBG_BEGIN2("IOleObject::GetMoniker called\r\n")
1252: hrErr = lpOleObj->lpVtbl->GetMoniker(
1253: lpOleObj,
1254: OLEGETMONIKER_TEMPFORUSER,
1255: OLEWHICHMK_OBJFULL,
1256: (LPMONIKER FAR*)&lpSrcMonikerOfCopy
1257: );
1258: OLEDBG_END2
1259: if (hrErr == NOERROR)
1260: {
1261: CreateBindCtx(0, (LPBC FAR*)&pbc);
1262: lpSrcMonikerOfCopy->lpVtbl->GetDisplayName(
1263: lpSrcMonikerOfCopy, pbc, NULL, &lpszSrcOfCopy);
1264: pbc->lpVtbl->Release(pbc);
1265: fFreeSrcOfCopy = TRUE;
1266: }
1267: }
1268: }
1269:
1270: // Get SIZEL
1271: OLEDBG_BEGIN2("IOleObject::GetExtent called\r\n")
1272: hrErr = lpOleObj->lpVtbl->GetExtent(
1273: lpOleObj,
1274: dwAspect,
1275: &sizel
1276: );
1277: OLEDBG_END2
1278: if (hrErr != NOERROR)
1279: sizel.cx = sizel.cy = 0;
1280:
1281: // Get DWSTATUS
1282: OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n")
1283: hrErr = lpOleObj->lpVtbl->GetMiscStatus(
1284: lpOleObj,
1285: dwAspect,
1286: &dwStatus
1287: );
1288: OLEDBG_END2
1289: if (hrErr != NOERROR)
1290: dwStatus = 0;
1291:
1292: // Get OBJECTDESCRIPTOR
1293: hObjDesc = OleStdGetObjectDescriptorData(
1294: clsid,
1295: dwAspect,
1296: sizel,
1297: pointl,
1298: dwStatus,
1299: lpszFullUserTypeName,
1300: lpszSrcOfCopy
1301: );
1302: if (! hObjDesc)
1303: goto error;
1304:
1305: // Clean up
1306: if (lpszFullUserTypeName)
1307: OleStdFreeString(lpszFullUserTypeName, NULL);
1308: if (fFreeSrcOfCopy && lpszSrcOfCopy)
1309: OleStdFreeString(lpszSrcOfCopy, NULL);
1310: if (lpSrcMonikerOfCopy)
1311: OleStdRelease((LPUNKNOWN)lpSrcMonikerOfCopy);
1312: if (lpOleLink)
1313: OleStdRelease((LPUNKNOWN)lpOleLink);
1314:
1315: return hObjDesc;
1316:
1317: error:
1318: if (lpszFullUserTypeName)
1319: OleStdFreeString(lpszFullUserTypeName, NULL);
1320: if (fFreeSrcOfCopy && lpszSrcOfCopy)
1321: OleStdFreeString(lpszSrcOfCopy, NULL);
1322: if (lpSrcMonikerOfCopy)
1323: OleStdRelease((LPUNKNOWN)lpSrcMonikerOfCopy);
1324: if (lpOleLink)
1325: OleStdRelease((LPUNKNOWN)lpOleLink);
1326:
1327: return NULL;
1328: }
1329:
1330: /*
1331: * OleStdFillObjectDescriptorFromData
1332: *
1333: * Purpose:
1334: * Fills and returns a OBJECTDESCRIPTOR structure. The source object will offer CF_OBJECTDESCRIPTOR
1335: * if it is an OLE2 object, CF_OWNERLINK if it is an OLE1 object, or CF_FILENAME if it has been
1336: * copied to the clipboard by FileManager.
1337: *
1338: * Parameters:
1339: * lpDataObject LPDATAOBJECT Source object
1340: * lpmedium LPSTGMEDIUM Storage medium
1341: * lpcfFmt CLIPFORMAT FAR * Format offered by lpDataObject (OUT parameter)
1342: *
1343: * Return Value:
1344: * HBGLOBAL Handle to OBJECTDESCRIPTOR structure.
1345: */
1346:
1347: STDAPI_(HGLOBAL) OleStdFillObjectDescriptorFromData(
1348: LPDATAOBJECT lpDataObject,
1349: LPSTGMEDIUM lpmedium,
1350: CLIPFORMAT FAR* lpcfFmt
1351: )
1352: {
1353: CLSID clsid;
1354: SIZEL sizel;
1355: POINTL pointl;
1356: LPSTR lpsz, szFullUserTypeName, szSrcOfCopy, szClassName, szDocName, szItemName;
1357: int nClassName, nDocName, nItemName, nFullUserTypeName;
1358: LPSTR szBuf = NULL;
1359: HGLOBAL hMem = NULL;
1360: HKEY hKey = NULL;
1361: LPMALLOC pIMalloc = NULL;
1362: DWORD dw = OLEUI_CCHKEYMAX;
1363: HGLOBAL hObjDesc;
1364: HRESULT hrErr;
1365:
1366:
1367: // GetData CF_OBJECTDESCRIPTOR format from the object on the clipboard.
1368: // Only OLE 2 objects on the clipboard will offer CF_OBJECTDESCRIPTOR
1369: if (hMem = OleStdGetData(
1370: lpDataObject,
1371: cfObjectDescriptor,
1372: NULL,
1373: DVASPECT_CONTENT,
1374: lpmedium))
1375: {
1376: *lpcfFmt = cfObjectDescriptor;
1377: return hMem; // Don't drop to clean up at the end of this function
1378: }
1379: // If CF_OBJECTDESCRIPTOR is not available, i.e. if this is not an OLE2 object,
1380: // check if this is an OLE 1 object. OLE 1 objects will offer CF_OWNERLINK
1381: else if (hMem = OleStdGetData(
1382: lpDataObject,
1383: cfOwnerLink,
1384: NULL,
1385: DVASPECT_CONTENT,
1386: lpmedium))
1387: {
1388: *lpcfFmt = cfOwnerLink;
1389: // CF_OWNERLINK contains null-terminated strings for class name, document name
1390: // and item name with two null terminating characters at the end
1391: szClassName = (LPSTR)GlobalLock(hMem);
1392: nClassName = lstrlen(szClassName);
1393: szDocName = szClassName + nClassName + 1;
1394: nDocName = lstrlen(szDocName);
1395: szItemName = szDocName + nDocName + 1;
1396: nItemName = lstrlen(szItemName);
1397:
1398: hrErr = CoGetMalloc(MEMCTX_TASK, &pIMalloc);
1399: if (hrErr != NOERROR)
1400: goto error;
1401:
1402: // Find FullUserTypeName from Registration database using class name
1403: if (RegOpenKey(HKEY_CLASSES_ROOT, NULL, &hKey) != ERROR_SUCCESS)
1404: goto error;
1405:
1406: // Allocate space for szFullUserTypeName & szSrcOfCopy. Maximum length of FullUserTypeName
1407: // is OLEUI_CCHKEYMAX. SrcOfCopy is constructed by concatenating FullUserTypeName, Document
1408: // Name and ItemName separated by spaces.
1409: szBuf = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc,
1410: (DWORD)2*OLEUI_CCHKEYMAX+nDocName+nItemName+4);
1411: if (NULL == szBuf)
1412: goto error;
1413: szFullUserTypeName = szBuf;
1414: szSrcOfCopy = szFullUserTypeName+OLEUI_CCHKEYMAX+1;
1415:
1416: // Get FullUserTypeName
1417: if (RegQueryValue(hKey, NULL, szFullUserTypeName, &dw) != ERROR_SUCCESS)
1418: goto error;
1419:
1420: // Build up SrcOfCopy string from FullUserTypeName, DocumentName & ItemName
1421: lpsz = szSrcOfCopy;
1422: lstrcpy(lpsz, szFullUserTypeName);
1423: nFullUserTypeName = lstrlen(szFullUserTypeName);
1424: lpsz[nFullUserTypeName]=' ';
1425: lpsz += nFullUserTypeName+1;
1426: lstrcpy(lpsz, szDocName);
1427: lpsz[nDocName] = ' ';
1428: lpsz += nDocName+1;
1429: lstrcpy(lpsz, szItemName);
1430:
1431: sizel.cx = sizel.cy = 0;
1432: pointl.x = pointl.y = 0;
1433:
1434: CLSIDFromProgID(szClassName, &clsid);
1435:
1436: hObjDesc = OleStdGetObjectDescriptorData(
1437: clsid,
1438: DVASPECT_CONTENT,
1439: sizel,
1440: pointl,
1441: 0,
1442: szFullUserTypeName,
1443: szSrcOfCopy
1444: );
1445: if (!hObjDesc)
1446: goto error;
1447: }
1448: // Check if object is CF_FILENAME
1449: else if (hMem = OleStdGetData(
1450: lpDataObject,
1451: cfFileName,
1452: NULL,
1453: DVASPECT_CONTENT,
1454: lpmedium))
1455: {
1456: *lpcfFmt = cfFileName;
1457: lpsz = (LPSTR)GlobalLock(hMem);
1458: hrErr = GetClassFile(lpsz, &clsid);
1459:
1460: /* OLE2NOTE: if the file does not have an OLE class
1461: ** associated, then use the OLE 1 Packager as the class of
1462: ** the object to be created. this is the behavior of
1463: ** OleCreateFromData API
1464: */
1465: if (hrErr != NOERROR)
1466: CLSIDFromProgID("Package", &clsid);
1467: sizel.cx = sizel.cy = 0;
1468: pointl.x = pointl.y = 0;
1469:
1470: hrErr = CoGetMalloc(MEMCTX_TASK, &pIMalloc);
1471: if (hrErr != NOERROR)
1472: goto error;
1473: szBuf = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, (DWORD)OLEUI_CCHKEYMAX);
1474: if (NULL == szBuf)
1475: goto error;
1476:
1477: OleStdGetUserTypeOfClass(&clsid, szBuf, OLEUI_CCHKEYMAX, NULL);
1478:
1479: hObjDesc = OleStdGetObjectDescriptorData(
1480: clsid,
1481: DVASPECT_CONTENT,
1482: sizel,
1483: pointl,
1484: 0,
1485: szBuf,
1486: lpsz
1487: );
1488: if (!hObjDesc)
1489: goto error;
1490: }
1491: else goto error;
1492:
1493: // Clean up
1494: if (szBuf)
1495: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)szBuf);
1496: if (pIMalloc)
1497: OleStdRelease((LPUNKNOWN)pIMalloc);
1498: if (hMem)
1499: {
1500: GlobalUnlock(hMem);
1501: GlobalFree(hMem);
1502: }
1503: if (hKey)
1504: RegCloseKey(hKey);
1505: return hObjDesc;
1506:
1507: error:
1508: if (szBuf)
1509: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)szBuf);
1510: if (pIMalloc)
1511: OleStdRelease((LPUNKNOWN)pIMalloc);
1512: if (hMem)
1513: {
1514: GlobalUnlock(hMem);
1515: GlobalFree(hMem);
1516: }
1517: if (hKey)
1518: RegCloseKey(hKey);
1519: return NULL;
1520: }
1521:
1522:
1523: STDAPI OleStdQueryOleObjectData(LPFORMATETC lpformatetc)
1524: {
1525: if (lpformatetc->tymed & TYMED_ISTORAGE) {
1526: return NOERROR;
1527: } else {
1528: return ResultFromScode(DATA_E_FORMATETC);
1529: }
1530: }
1531:
1532:
1533: STDAPI OleStdQueryLinkSourceData(LPFORMATETC lpformatetc)
1534: {
1535: if (lpformatetc->tymed & TYMED_ISTREAM)
1536: return NOERROR;
1537: else
1538: return ResultFromScode(DATA_E_FORMATETC);
1539: }
1540:
1541:
1542: STDAPI OleStdQueryObjectDescriptorData(LPFORMATETC lpformatetc)
1543: {
1544: if (lpformatetc->tymed & TYMED_HGLOBAL) {
1545: return NOERROR;
1546: } else {
1547: return ResultFromScode(DATA_E_FORMATETC);
1548: }
1549: }
1550:
1551:
1552: STDAPI OleStdQueryFormatMedium(LPFORMATETC lpformatetc, TYMED tymed)
1553: {
1554: if (lpformatetc->tymed & tymed) {
1555: return NOERROR;
1556: } else {
1557: return ResultFromScode(DATA_E_FORMATETC);
1558: }
1559: }
1560:
1561:
1562:
1563: /*
1564: * OleStdCopyMetafilePict()
1565: *
1566: * Purpose:
1567: * Make an independent copy of a MetafilePict
1568: * Parameters:
1569: *
1570: * Return Value:
1571: * TRUE if successful, else FALSE.
1572: */
1573: STDAPI_(BOOL) OleStdCopyMetafilePict(HANDLE hpictin, HANDLE FAR* phpictout)
1574: {
1575: HANDLE hpictout;
1576: LPMETAFILEPICT ppictin, ppictout;
1577:
1578: if (hpictin == NULL || phpictout == NULL) {
1579: OleDbgAssert(hpictin == NULL || phpictout == NULL);
1580: return FALSE;
1581: }
1582:
1583: *phpictout = NULL;
1584:
1585: if ((ppictin = (LPMETAFILEPICT)GlobalLock(hpictin)) == NULL) {
1586: return FALSE;
1587: }
1588:
1589: hpictout = GlobalAlloc(GHND|GMEM_SHARE, sizeof(METAFILEPICT));
1590:
1591: if (hpictout && (ppictout = (LPMETAFILEPICT)GlobalLock(hpictout))){
1592: ppictout->hMF = CopyMetaFile(ppictin->hMF, NULL);
1593: ppictout->xExt = ppictin->xExt;
1594: ppictout->yExt = ppictin->yExt;
1595: ppictout->mm = ppictin->mm;
1596: GlobalUnlock(hpictout);
1597: }
1598:
1599: *phpictout = hpictout;
1600:
1601: return TRUE;
1602:
1603: }
1604:
1605:
1606: /*
1607: * OleStdGetMetafilePictFromOleObject()
1608: *
1609: * Purpose:
1610: * Generate a MetafilePict by drawing the OLE object.
1611: * Parameters:
1612: *
1613: * Return Value:
1614: * HANDLE -- handle of allocated METAFILEPICT
1615: */
1616: STDAPI_(HANDLE) OleStdGetMetafilePictFromOleObject(
1617: LPOLEOBJECT lpOleObj,
1618: DWORD dwDrawAspect
1619: )
1620: {
1621: LPVIEWOBJECT lpViewObj = NULL;
1622: HDC hDC;
1623: HMETAFILE hmf;
1624: HANDLE hMetaPict;
1625: LPMETAFILEPICT lpPict;
1626: RECT rcHim;
1627: RECTL rclHim;
1628: SIZEL sizelHim;
1629: HRESULT hrErr;
1630: SIZE size;
1631: POINT point;
1632:
1633: lpViewObj = (LPVIEWOBJECT)OleStdQueryInterface(
1634: (LPUNKNOWN)lpOleObj, &IID_IViewObject);
1635: if (! lpViewObj)
1636: return NULL;
1637:
1638: OLEDBG_BEGIN2("IOleObject::GetExtent called\r\n")
1639: lpOleObj->lpVtbl->GetExtent(
1640: lpOleObj,
1641: dwDrawAspect,
1642: (LPSIZEL)&sizelHim
1643: );
1644: OLEDBG_END2
1645:
1646: hDC = CreateMetaFile(NULL);
1647:
1648: rclHim.left = 0;
1649: rclHim.top = 0;
1650: rclHim.right = sizelHim.cx;
1651: rclHim.bottom = sizelHim.cy;
1652:
1653: rcHim.left = (int)rclHim.left;
1654: rcHim.top = (int)rclHim.top;
1655: rcHim.right = (int)rclHim.right;
1656: rcHim.bottom = (int)rclHim.bottom;
1657:
1658: SetWindowOrgEx(hDC, rcHim.left, rcHim.top, &point);
1659: SetWindowExtEx(hDC, rcHim.right-rcHim.left, rcHim.bottom-rcHim.top,&size);
1660:
1661: OLEDBG_BEGIN2("IViewObject::Draw called\r\n")
1662: hrErr = lpViewObj->lpVtbl->Draw(
1663: lpViewObj,
1664: dwDrawAspect,
1665: -1,
1666: NULL,
1667: NULL,
1668: NULL,
1669: hDC,
1670: (LPRECTL)&rclHim,
1671: (LPRECTL)&rclHim,
1672: NULL,
1673: 0
1674: );
1675: OLEDBG_END2
1676:
1677: OleStdRelease((LPUNKNOWN)lpViewObj);
1678: if (hrErr != NOERROR) {
1679: OleDbgOutHResult("IViewObject::Draw returned", hrErr);
1680: }
1681:
1682: hmf = CloseMetaFile(hDC);
1683:
1684: hMetaPict = GlobalAlloc(GHND|GMEM_SHARE, sizeof(METAFILEPICT));
1685:
1686: if (hMetaPict && (lpPict = (LPMETAFILEPICT)GlobalLock(hMetaPict))){
1687: lpPict->hMF = hmf;
1688: lpPict->xExt = (int)sizelHim.cx ;
1689: lpPict->yExt = (int)sizelHim.cy ;
1690: lpPict->mm = MM_ANISOTROPIC;
1691: GlobalUnlock(hMetaPict);
1692: }
1693:
1694: return hMetaPict;
1695: }
1696:
1697:
1698: /* Call Release on the object that is expected to go away.
1699: ** if the refcnt of the object did no go to 0 then give a debug message.
1700: */
1701: STDAPI_(ULONG) OleStdVerifyRelease(LPUNKNOWN lpUnk, LPSTR lpszMsg)
1702: {
1703: ULONG cRef;
1704:
1705: cRef = lpUnk->lpVtbl->Release(lpUnk);
1706:
1707: #if defined( _DEBUG )
1708: if (cRef != 0) {
1709: char szBuf[80];
1710: if (lpszMsg)
1711: MessageBox(NULL, lpszMsg, NULL, MB_ICONEXCLAMATION | MB_OK);
1712: wsprintf(
1713: (LPSTR)szBuf,
1714: "refcnt (%ld) != 0 after object (0x%lx) release\n",
1715: cRef,
1716: lpUnk
1717: );
1718: if (lpszMsg)
1719: OleDbgOut1(lpszMsg);
1720: OleDbgOut1((LPSTR)szBuf);
1721: OleDbgAssertSz(cRef == 0, (LPSTR)szBuf);
1722: } else {
1723: char szBuf[80];
1724: wsprintf(
1725: (LPSTR)szBuf,
1726: "refcnt = 0 after object (0x%lx) release\n", lpUnk
1727: );
1728: OleDbgOut4((LPSTR)szBuf);
1729: }
1730: #endif
1731: return cRef;
1732: }
1733:
1734:
1735: /* Call Release on the object that is NOT necessarily expected to go away.
1736: */
1737: STDAPI_(ULONG) OleStdRelease(LPUNKNOWN lpUnk)
1738: {
1739: ULONG cRef;
1740:
1741: cRef = lpUnk->lpVtbl->Release(lpUnk);
1742:
1743: #if defined( _DEBUG )
1744: {
1745: char szBuf[80];
1746: wsprintf(
1747: (LPSTR)szBuf,
1748: "refcnt = %ld after object (0x%lx) release\n",
1749: cRef,
1750: lpUnk
1751: );
1752: OleDbgOut4((LPSTR)szBuf);
1753: }
1754: #endif
1755: return cRef;
1756: }
1757:
1758:
1759: /* OleStdInitVtbl
1760: ** --------------
1761: **
1762: ** Initialize an interface Vtbl to ensure that there are no NULL
1763: ** function pointers in the Vtbl. All entries in the Vtbl are
1764: ** set to a valid funtion pointer (OleStdNullMethod) that issues
1765: ** debug assert message (message box) and returns E_NOTIMPL if called.
1766: **
1767: ** NOTE: this funtion does not initialize the Vtbl with usefull
1768: ** function pointers, only valid function pointers to avoid the
1769: ** horrible run-time crash when a call is made through the Vtbl with
1770: ** a NULL function pointer. this API is only necessary when
1771: ** initializing the Vtbl's in C. C++ guarantees that all interface
1772: ** functions (in C++ terms -- pure virtual functions) are implemented.
1773: */
1774:
1775: STDAPI_(void) OleStdInitVtbl(LPVOID lpVtbl, UINT nSizeOfVtbl)
1776: {
1777: LPVOID FAR* lpFuncPtrArr = (LPVOID FAR*)lpVtbl;
1778: UINT nMethods = nSizeOfVtbl/sizeof(VOID FAR*);
1779: UINT i;
1780:
1781: for (i = 0; i < nMethods; i++) {
1782: lpFuncPtrArr[i] = OleStdNullMethod;
1783: }
1784: }
1785:
1786:
1787: /* OleStdCheckVtbl
1788: ** ---------------
1789: **
1790: ** Check if all entries in the Vtbl are properly initialized with
1791: ** valid function pointers. If any entries are either NULL or
1792: ** OleStdNullMethod, then this function returns FALSE. If compiled
1793: ** for _DEBUG this function reports which function pointers are
1794: ** invalid.
1795: **
1796: ** RETURNS: TRUE if all entries in Vtbl are valid
1797: ** FALSE otherwise.
1798: */
1799:
1800: STDAPI_(BOOL) OleStdCheckVtbl(LPVOID lpVtbl, UINT nSizeOfVtbl, LPSTR lpszIface)
1801: {
1802: LPVOID FAR* lpFuncPtrArr = (LPVOID FAR*)lpVtbl;
1803: UINT nMethods = nSizeOfVtbl/sizeof(VOID FAR*);
1804: UINT i;
1805: BOOL fStatus = TRUE;
1806: int nChar = 0;
1807:
1808: for (i = 0; i < nMethods; i++) {
1809: if (lpFuncPtrArr[i] == NULL || lpFuncPtrArr[i] == OleStdNullMethod) {
1810: #if defined( _DEBUG )
1811: char szBuf[256];
1812: wsprintf(szBuf, "%s::method# %d NOT valid!", lpszIface, i);
1813: OleDbgOut1((LPSTR)szBuf);
1814: #endif
1815: fStatus = FALSE;
1816: }
1817: }
1818: return fStatus;
1819: }
1820:
1821:
1822: /* OleStdNullMethod
1823: ** ----------------
1824: ** Dummy method used by OleStdInitVtbl to initialize an interface
1825: ** Vtbl to ensure that there are no NULL function pointers in the
1826: ** Vtbl. All entries in the Vtbl are set to this function. this
1827: ** function issues a debug assert message (message box) and returns
1828: ** E_NOTIMPL if called. If all is done properly, this function will
1829: ** NEVER be called!
1830: */
1831: STDMETHODIMP OleStdNullMethod(LPUNKNOWN lpThis)
1832: {
1833: MessageBox(
1834: NULL,
1835: "ERROR: INTERFACE METHOD NOT IMPLEMENTED!\r\n",
1836: NULL,
1837: MB_SYSTEMMODAL | MB_ICONHAND | MB_OK
1838: );
1839:
1840: return ResultFromScode(E_NOTIMPL);
1841: }
1842:
1843:
1844:
1845: static BOOL GetFileTimes(LPSTR lpszFileName, FILETIME FAR* pfiletime)
1846: {
1847: #ifdef WIN32
1848: WIN32_FIND_DATA fd;
1849: HANDLE hFind;
1850: hFind = FindFirstFile(lpszFileName,&fd);
1851: if (hFind == NULL || hFind == INVALID_HANDLE_VALUE) {
1852: return FALSE;
1853: }
1854: FindClose(hFind);
1855: *pfiletime = fd.ftLastWriteTime;
1856: return TRUE;
1857: #else
1858: static char sz[256];
1859: static struct _find_t fileinfo;
1860:
1861: lstrcpyn((LPSTR)sz, lpszFileName, sizeof(sz)-1);
1862: sz[sizeof(sz)-1]= '\0';
1863: AnsiToOem(sz, sz);
1864: return (_dos_findfirst(sz,_A_NORMAL|_A_HIDDEN|_A_SUBDIR|_A_SYSTEM,
1865: (struct _find_t *)&fileinfo) == 0 &&
1866: CoDosDateTimeToFileTime(fileinfo.wr_date,fileinfo.wr_time,pfiletime));
1867: #endif
1868: }
1869:
1870:
1871:
1872: /* OleStdRegisterAsRunning
1873: ** -----------------------
1874: ** Register a moniker in the RunningObjectTable.
1875: ** if there is an existing registration (*lpdwRegister!=NULL), then
1876: ** first revoke that registration.
1877: **
1878: ** new dwRegister key is returned via *lpdwRegister parameter.
1879: */
1880: STDAPI_(void) OleStdRegisterAsRunning(LPUNKNOWN lpUnk, LPMONIKER lpmkFull, DWORD FAR* lpdwRegister)
1881: {
1882: LPRUNNINGOBJECTTABLE lpROT;
1883: HRESULT hrErr;
1884: DWORD dwOldRegister = *lpdwRegister;
1885:
1886: OLEDBG_BEGIN2("OleStdRegisterAsRunning\r\n")
1887:
1888: OLEDBG_BEGIN2("GetRunningObjectTable called\r\n")
1889: hrErr = GetRunningObjectTable(0,(LPRUNNINGOBJECTTABLE FAR*)&lpROT);
1890: OLEDBG_END2
1891:
1892: if (hrErr == NOERROR) {
1893:
1894: /* register as running if a valid moniker is passed
1895: **
1896: ** OLE2NOTE: we deliberately register the new moniker BEFORE
1897: ** revoking the old moniker just in case the object
1898: ** currently has no external locks. if the object has no
1899: ** locks then revoking it from the running object table will
1900: ** cause the object's StubManager to initiate shutdown of
1901: ** the object.
1902: */
1903: if (lpmkFull) {
1904:
1905: OLEDBG_BEGIN2("IRunningObjectTable::Register called\r\n")
1906: lpROT->lpVtbl->Register(lpROT, 0, lpUnk,lpmkFull,lpdwRegister);
1907: OLEDBG_END2
1908:
1909: #if _DEBUG
1910: {
1911: char szBuf[512];
1912: LPSTR lpszDisplay;
1913: LPBC lpbc;
1914:
1915: CreateBindCtx(0, (LPBC FAR*)&lpbc);
1916: lpmkFull->lpVtbl->GetDisplayName(
1917: lpmkFull,
1918: lpbc,
1919: NULL,
1920: (LPSTR FAR*)&lpszDisplay
1921: );
1922: OleStdRelease((LPUNKNOWN)lpbc);
1923: wsprintf(
1924: szBuf,
1925: "Moniker '%s' REGISTERED as [0x%lx] in ROT\r\n",
1926: lpszDisplay,
1927: *lpdwRegister
1928: );
1929: OleDbgOut2(szBuf);
1930: OleStdFreeString(lpszDisplay, NULL);
1931: }
1932: #endif // _DEBUG
1933:
1934: }
1935:
1936: // if already registered, revoke
1937: if (dwOldRegister != 0) {
1938:
1939: #if _DEBUG
1940: {
1941: char szBuf[512];
1942:
1943: wsprintf(
1944: szBuf,
1945: "Moniker [0x%lx] REVOKED from ROT\r\n",
1946: dwOldRegister
1947: );
1948: OleDbgOut2(szBuf);
1949: }
1950: #endif // _DEBUG
1951:
1952: OLEDBG_BEGIN2("IRunningObjectTable::Revoke called\r\n")
1953: lpROT->lpVtbl->Revoke(lpROT, dwOldRegister);
1954: OLEDBG_END2
1955:
1956: *lpdwRegister = 0;
1957: }
1958:
1959: OleStdRelease((LPUNKNOWN)lpROT);
1960: } else {
1961: OleDbgAssertSz(
1962: lpROT != NULL,
1963: "OleStdRegisterAsRunning: GetRunningObjectTable FAILED\r\n"
1964: );
1965: }
1966:
1967: OLEDBG_END2
1968: }
1969:
1970:
1971:
1972: /* OleStdRevokeAsRunning
1973: ** ---------------------
1974: ** Revoke a moniker from the RunningObjectTable if there is an
1975: ** existing registration (*lpdwRegister!=NULL).
1976: **
1977: ** *lpdwRegister parameter will be set to NULL.
1978: */
1979: STDAPI_(void) OleStdRevokeAsRunning(DWORD FAR* lpdwRegister)
1980: {
1981: LPRUNNINGOBJECTTABLE lpROT;
1982: HRESULT hrErr;
1983:
1984: OLEDBG_BEGIN2("OleStdRevokeAsRunning\r\n")
1985:
1986: // if still registered, then revoke
1987: if (*lpdwRegister != 0) {
1988:
1989: OLEDBG_BEGIN2("GetRunningObjectTable called\r\n")
1990: hrErr = GetRunningObjectTable(0,(LPRUNNINGOBJECTTABLE FAR*)&lpROT);
1991: OLEDBG_END2
1992:
1993: if (hrErr == NOERROR) {
1994:
1995: #if _DEBUG
1996: {
1997: char szBuf[512];
1998:
1999: wsprintf(
2000: szBuf,
2001: "Moniker [0x%lx] REVOKED from ROT\r\n",
2002: *lpdwRegister
2003: );
2004: OleDbgOut2(szBuf);
2005: }
2006: #endif // _DEBUG
2007:
2008: OLEDBG_BEGIN2("IRunningObjectTable::Revoke called\r\n")
2009: lpROT->lpVtbl->Revoke(lpROT, *lpdwRegister);
2010: OLEDBG_END2
2011:
2012: *lpdwRegister = 0;
2013:
2014: OleStdRelease((LPUNKNOWN)lpROT);
2015: } else {
2016: OleDbgAssertSz(
2017: lpROT != NULL,
2018: "OleStdRevokeAsRunning: GetRunningObjectTable FAILED\r\n"
2019: );
2020: }
2021: }
2022: OLEDBG_END2
2023: }
2024:
2025:
2026: /* OleStdNoteFileChangeTime
2027: ** ------------------------
2028: ** Note the time a File-Based object has been saved in the
2029: ** RunningObjectTable. These change times are used as the basis for
2030: ** IOleObject::IsUpToDate.
2031: ** It is important to set the time of the file-based object
2032: ** following a save operation to exactly the time of the saved file.
2033: ** this helps IOleObject::IsUpToDate to give the correct answer
2034: ** after a file has been saved.
2035: */
2036: STDAPI_(void) OleStdNoteFileChangeTime(LPSTR lpszFileName, DWORD dwRegister)
2037: {
2038: if (dwRegister != 0) {
2039:
2040: LPRUNNINGOBJECTTABLE lprot;
2041: FILETIME filetime;
2042:
2043: if (GetFileTimes(lpszFileName, &filetime) &&
2044: GetRunningObjectTable(0,&lprot) == NOERROR)
2045: {
2046: lprot->lpVtbl->NoteChangeTime( lprot, dwRegister, &filetime );
2047: lprot->lpVtbl->Release(lprot);
2048:
2049: OleDbgOut2("IRunningObjectTable::NoteChangeTime called\r\n");
2050: }
2051: }
2052: }
2053:
2054:
2055: /* OleStdNoteObjectChangeTime
2056: ** --------------------------
2057: ** Set the last change time of an object that is registered in the
2058: ** RunningObjectTable. These change times are used as the basis for
2059: ** IOleObject::IsUpToDate.
2060: **
2061: ** every time the object sends out a OnDataChange notification, it
2062: ** should update the Time of last change in the ROT.
2063: **
2064: ** NOTE: this function set the change time to the current time.
2065: */
2066: STDAPI_(void) OleStdNoteObjectChangeTime(DWORD dwRegister)
2067: {
2068: if (dwRegister != 0) {
2069:
2070: LPRUNNINGOBJECTTABLE lprot;
2071: FILETIME filetime;
2072:
2073: if (GetRunningObjectTable(0,&lprot) == NOERROR)
2074: {
2075: CoFileTimeNow( &filetime );
2076: lprot->lpVtbl->NoteChangeTime( lprot, dwRegister, &filetime );
2077: lprot->lpVtbl->Release(lprot);
2078:
2079: OleDbgOut2("IRunningObjectTable::NoteChangeTime called\r\n");
2080: }
2081: }
2082: }
2083:
2084:
2085:
2086: STDAPI_(void) OleStdCreateTempFileMoniker(LPSTR lpszPrefixString, UINT FAR* lpuUnique, LPSTR lpszName, LPMONIKER FAR* lplpmk)
2087: {
2088: LPRUNNINGOBJECTTABLE lpROT = NULL;
2089: UINT i = (lpuUnique != NULL ? *lpuUnique : 1);
2090: HRESULT hrErr;
2091:
2092: wsprintf(lpszName, "%s%d", lpszPrefixString, i++);
2093: CreateFileMoniker(lpszName, lplpmk);
2094:
2095: OLEDBG_BEGIN2("GetRunningObjectTable called\r\n")
2096: hrErr = GetRunningObjectTable(0,(LPRUNNINGOBJECTTABLE FAR*)&lpROT);
2097: OLEDBG_END2
2098:
2099: if (hrErr == NOERROR) {
2100:
2101: while (1) {
2102: if (! *lplpmk)
2103: break; // failed to create FileMoniker
2104:
2105: OLEDBG_BEGIN2("IRunningObjectTable::IsRunning called\r\n")
2106: hrErr = lpROT->lpVtbl->IsRunning(lpROT,*lplpmk);
2107: OLEDBG_END2
2108:
2109: if (hrErr != NOERROR)
2110: break; // the Moniker is NOT running; found unused one!
2111:
2112: OleStdVerifyRelease(
2113: (LPUNKNOWN)*lplpmk,
2114: "OleStdCreateTempFileMoniker: Moniker NOT released"
2115: );
2116:
2117: wsprintf(lpszName, "%s%d", lpszPrefixString, i++);
2118: CreateFileMoniker(lpszName, lplpmk);
2119: }
2120:
2121: OleStdRelease((LPUNKNOWN)lpROT);
2122: }
2123:
2124: if (lpuUnique != NULL)
2125: *lpuUnique = i;
2126: }
2127:
2128:
2129: /* OleStdGetFirstMoniker
2130: ** ---------------------
2131: ** return the first piece of a moniker.
2132: **
2133: ** NOTE: if the given moniker is not a generic composite moniker,
2134: ** then an AddRef'ed pointer to the given moniker is returned.
2135: */
2136: STDAPI_(LPMONIKER) OleStdGetFirstMoniker(LPMONIKER lpmk)
2137: {
2138: LPMONIKER lpmkFirst = NULL;
2139: LPENUMMONIKER lpenumMoniker;
2140: DWORD dwMksys;
2141: HRESULT hrErr;
2142:
2143: if (! lpmk)
2144: return NULL;
2145:
2146: if (lpmk->lpVtbl->IsSystemMoniker(lpmk, (LPDWORD)&dwMksys) == NOERROR
2147: && dwMksys == MKSYS_GENERICCOMPOSITE) {
2148:
2149: /* OLE2NOTE: the moniker is a GenericCompositeMoniker.
2150: ** enumerate the moniker to pull off the first piece.
2151: */
2152:
2153: hrErr = lpmk->lpVtbl->Enum(
2154: lpmk,
2155: TRUE /* fForward */,
2156: (LPENUMMONIKER FAR*)&lpenumMoniker
2157: );
2158: if (hrErr != NOERROR)
2159: return NULL; // ERROR: give up!
2160:
2161: hrErr = lpenumMoniker->lpVtbl->Next(
2162: lpenumMoniker,
2163: 1,
2164: (LPMONIKER FAR*)&lpmkFirst,
2165: NULL
2166: );
2167: lpenumMoniker->lpVtbl->Release(lpenumMoniker);
2168: return lpmkFirst;
2169:
2170: } else {
2171: /* OLE2NOTE: the moniker is NOT a GenericCompositeMoniker.
2172: ** return an AddRef'ed pointer to the input moniker.
2173: */
2174: lpmk->lpVtbl->AddRef(lpmk);
2175: return lpmk;
2176: }
2177: }
2178:
2179:
2180: /* OleStdGetLenFilePrefixOfMoniker
2181: ** -------------------------------
2182: ** if the first piece of the Moniker is a FileMoniker, then return
2183: ** the length of the filename string.
2184: **
2185: ** lpmk pointer to moniker
2186: **
2187: ** Returns
2188: ** 0 if moniker does NOT start with a FileMoniker
2189: ** uLen string length of filename prefix of the display name
2190: ** retrieved from the given (lpmk) moniker.
2191: */
2192: STDAPI_(ULONG) OleStdGetLenFilePrefixOfMoniker(LPMONIKER lpmk)
2193: {
2194: LPMONIKER lpmkFirst = NULL;
2195: DWORD dwMksys;
2196: LPSTR lpsz = NULL;
2197: LPBC lpbc = NULL;
2198: ULONG uLen = 0;
2199: HRESULT hrErr;
2200:
2201: if (! lpmk)
2202: return 0;
2203:
2204: lpmkFirst = OleStdGetFirstMoniker(lpmk);
2205: if (lpmkFirst) {
2206: if ( (lpmkFirst->lpVtbl->IsSystemMoniker(
2207: lpmkFirst, (LPDWORD)&dwMksys) == NOERROR)
2208: && dwMksys == MKSYS_FILEMONIKER) {
2209:
2210: hrErr = CreateBindCtx(0, (LPBC FAR*)&lpbc);
2211: if (hrErr == NOERROR) {
2212: hrErr = lpmkFirst->lpVtbl->GetDisplayName(
2213: lpmkFirst,
2214: lpbc,
2215: NULL, /* pmkToLeft */
2216: (LPSTR FAR*)&lpsz
2217: );
2218: if (hrErr == NOERROR && lpsz != NULL) {
2219: uLen = lstrlen(lpsz);
2220: OleStdFreeString(lpsz, NULL);
2221: }
2222: OleStdRelease((LPUNKNOWN)lpbc);
2223: }
2224: }
2225: lpmkFirst->lpVtbl->Release(lpmkFirst);
2226: }
2227: return uLen;
2228: }
2229:
2230:
2231: /*
2232: * OleStdMarkPasteEntryList
2233: *
2234: * Purpose:
2235: * Mark each entry in the PasteEntryList if its format is available from
2236: * the source IDataObject*. the dwScratchSpace field of each PasteEntry
2237: * is set to TRUE if available, else FALSE.
2238: *
2239: * Parameters:
2240: * LPOLEUIPASTEENTRY array of PasteEntry structures
2241: * int count of elements in PasteEntry array
2242: * LPDATAOBJECT source IDataObject* pointer
2243: *
2244: * Return Value:
2245: * none
2246: */
2247: STDAPI_(void) OleStdMarkPasteEntryList(
2248: LPDATAOBJECT lpSrcDataObj,
2249: LPOLEUIPASTEENTRY lpPriorityList,
2250: int cEntries
2251: )
2252: {
2253: LPENUMFORMATETC lpEnumFmtEtc = NULL;
2254: FORMATETC fmtetc;
2255: int i;
2256: HRESULT hrErr;
2257:
2258: // Clear all marks
2259: for (i = 0; i < cEntries; i++) {
2260: lpPriorityList[i].dwScratchSpace = FALSE;
2261:
2262: if (! lpPriorityList[i].fmtetc.cfFormat) {
2263: // caller wants this item always considered available
2264: // (by specifying a NULL format)
2265: lpPriorityList[i].dwScratchSpace = TRUE;
2266: } else if (lpPriorityList[i].fmtetc.cfFormat == cfEmbeddedObject
2267: || lpPriorityList[i].fmtetc.cfFormat == cfEmbedSource
2268: || lpPriorityList[i].fmtetc.cfFormat == cfFileName) {
2269:
2270: // if there is an OLE object format, then handle it
2271: // specially by calling OleQueryCreateFromData. the caller
2272: // need only specify one object type format.
2273: OLEDBG_BEGIN2("OleQueryCreateFromData called\r\n")
2274: hrErr = OleQueryCreateFromData(lpSrcDataObj);
2275: OLEDBG_END2
2276: if(NOERROR == hrErr) {
2277: lpPriorityList[i].dwScratchSpace = TRUE;
2278: }
2279: } else if (lpPriorityList[i].fmtetc.cfFormat == cfLinkSource) {
2280:
2281: // if there is OLE 2.0 LinkSource format, then handle it
2282: // specially by calling OleQueryLinkFromData.
2283: OLEDBG_BEGIN2("OleQueryLinkFromData called\r\n")
2284: hrErr = OleQueryLinkFromData(lpSrcDataObj);
2285: OLEDBG_END2
2286: if(NOERROR == hrErr) {
2287: lpPriorityList[i].dwScratchSpace = TRUE;
2288: }
2289: }
2290: }
2291:
2292: OLEDBG_BEGIN2("IDataObject::EnumFormatEtc called\r\n")
2293: hrErr = lpSrcDataObj->lpVtbl->EnumFormatEtc(
2294: lpSrcDataObj,
2295: DATADIR_GET,
2296: (LPENUMFORMATETC FAR*)&lpEnumFmtEtc
2297: );
2298: OLEDBG_END2
2299:
2300: if (hrErr != NOERROR)
2301: return; // unable to get format enumerator
2302:
2303: // Enumerate the formats offered by the source
2304: // Loop over all formats offered by the source
2305: while (lpEnumFmtEtc->lpVtbl->Next(
2306: lpEnumFmtEtc, 1, (LPFORMATETC)&fmtetc, NULL) == S_OK)
2307: {
2308: for (i = 0; i < cEntries; i++)
2309: {
2310: if (! lpPriorityList[i].dwScratchSpace &&
2311: IsEqualFORMATETC(fmtetc, lpPriorityList[i].fmtetc))
2312: {
2313: lpPriorityList[i].dwScratchSpace = TRUE;
2314: }
2315: }
2316: }
2317:
2318: // Clean up
2319: if (lpEnumFmtEtc)
2320: OleStdRelease((LPUNKNOWN)lpEnumFmtEtc);
2321: }
2322:
2323:
2324: /* OleStdGetPriorityClipboardFormat
2325: ** --------------------------------
2326: **
2327: ** Retrieve the first clipboard format in a list for which data
2328: ** exists in the source IDataObject*.
2329: **
2330: ** Returns -1 if no acceptable match is found.
2331: ** index of first acceptable match in the priority list.
2332: **
2333: */
2334: STDAPI_(int) OleStdGetPriorityClipboardFormat(LPDATAOBJECT lpSrcDataObj, LPOLEUIPASTEENTRY lpPriorityList, int cEntries)
2335: {
2336: int i;
2337: int nFmtEtc = -1;
2338:
2339: // Mark all entries that the Source provides
2340: OleStdMarkPasteEntryList(lpSrcDataObj, lpPriorityList, cEntries);
2341:
2342: // Loop over the target's priority list of formats
2343: for (i = 0; i < cEntries; i++)
2344: {
2345: if (lpPriorityList[i].dwFlags != OLEUIPASTE_PASTEONLY &&
2346: !(lpPriorityList[i].dwFlags & OLEUIPASTE_PASTE))
2347: continue;
2348:
2349: // get first marked entry
2350: if (lpPriorityList[i].dwScratchSpace) {
2351: nFmtEtc = i;
2352: break; // Found priority format; DONE
2353: }
2354: }
2355:
2356: return nFmtEtc;
2357: }
2358:
2359:
2360: /* OleStdIsDuplicateFormat
2361: ** -----------------------
2362: ** Returns TRUE if the lpFmtEtc->cfFormat is found in the array of
2363: ** FormatEtc structures.
2364: */
2365: STDAPI_(BOOL) OleStdIsDuplicateFormat(
2366: LPFORMATETC lpFmtEtc,
2367: LPFORMATETC arrFmtEtc,
2368: int nFmtEtc
2369: )
2370: {
2371: int i;
2372:
2373: for (i = 0; i < nFmtEtc; i++) {
2374: if (lpFmtEtc->cfFormat == arrFmtEtc[i].cfFormat)
2375: return TRUE;
2376: }
2377:
2378: return FALSE;
2379: }
2380:
2381:
2382: /* OleStdGetDropEffect
2383: ** -------------------
2384: **
2385: ** Convert a keyboard state into a DROPEFFECT.
2386: **
2387: ** returns the DROPEFFECT value derived from the key state.
2388: ** the following is the standard interpretation:
2389: ** no modifier -- Default Drop (NULL is returned)
2390: ** CTRL -- DROPEFFECT_COPY
2391: ** SHIFT -- DROPEFFECT_MOVE
2392: ** CTRL-SHIFT -- DROPEFFECT_LINK
2393: **
2394: ** Default Drop: this depends on the type of the target application.
2395: ** this is re-interpretable by each target application. a typical
2396: ** interpretation is if the drag is local to the same document
2397: ** (which is source of the drag) then a MOVE operation is
2398: ** performed. if the drag is not local, then a COPY operation is
2399: ** performed.
2400: */
2401: STDAPI_(DWORD) OleStdGetDropEffect( DWORD grfKeyState )
2402: {
2403:
2404: if (grfKeyState & MK_CONTROL) {
2405:
2406: if (grfKeyState & MK_SHIFT)
2407: return DROPEFFECT_LINK;
2408: else
2409: return DROPEFFECT_COPY;
2410:
2411: } else if (grfKeyState & MK_SHIFT)
2412: return DROPEFFECT_MOVE;
2413:
2414: return 0; // no modifier -- do default operation
2415: }
2416:
2417:
2418: /* OleStdGetItemToken
2419: * ------------------
2420: *
2421: * LPSTR lpszSrc - Pointer to a source string
2422: * LPSTR lpszDst - Pointer to destination buffer
2423: *
2424: * Will copy one token from the lpszSrc buffer to the lpszItem buffer.
2425: * It considers all alpha-numeric and white space characters as valid
2426: * characters for a token. the first non-valid character delimates the
2427: * token.
2428: *
2429: * returns the number of charaters eaten.
2430: */
2431: STDAPI_(ULONG) OleStdGetItemToken(LPSTR lpszSrc, LPSTR lpszDst, int nMaxChars)
2432: {
2433: ULONG chEaten = 0L;
2434:
2435: // skip leading delimeter characters
2436: while (*lpszSrc && --nMaxChars > 0
2437: && ((*lpszSrc=='/') || (*lpszSrc=='\\') ||
2438: (*lpszSrc=='!') || (*lpszSrc==':'))) {
2439: *lpszSrc++;
2440: chEaten++;
2441: }
2442:
2443: // Extract token string (up to first delimeter char or EOS)
2444: while (*lpszSrc && --nMaxChars > 0
2445: && !((*lpszSrc=='/') || (*lpszSrc=='\\') ||
2446: (*lpszSrc=='!') || (*lpszSrc==':'))) {
2447: *lpszDst++ = *lpszSrc++;
2448: chEaten++;
2449: }
2450: *lpszDst = '\0';
2451: return chEaten;
2452: }
2453:
2454:
2455: /*************************************************************************
2456: ** OleStdCreateRootStorage
2457: ** create a root level Storage given a filename that is compatible
2458: ** to be used by a top-level OLE container. if the filename
2459: ** specifies an existing file, then an error is returned.
2460: ** the root storage (Docfile) that is created by this function
2461: ** is suitable to be used to create child storages for embedings.
2462: ** (CreateChildStorage can be used to create child storages.)
2463: ** NOTE: the root-level storage is opened in transacted mode.
2464: *************************************************************************/
2465:
2466: STDAPI_(LPSTORAGE) OleStdCreateRootStorage(LPSTR lpszStgName, DWORD grfMode)
2467: {
2468: HRESULT hr;
2469: DWORD grfCreateMode = STGM_READWRITE | STGM_TRANSACTED;
2470: DWORD reserved = 0;
2471: LPSTORAGE lpRootStg;
2472: char szMsg[64];
2473:
2474: // if temp file is being created, enable delete-on-release
2475: if (! lpszStgName)
2476: grfCreateMode |= STGM_DELETEONRELEASE;
2477:
2478: hr = StgCreateDocfile(
2479: lpszStgName,
2480: grfMode | grfCreateMode,
2481: reserved,
2482: (LPSTORAGE FAR*)&lpRootStg
2483: );
2484:
2485: if (hr == NOERROR)
2486: return lpRootStg; // existing file successfully opened
2487:
2488: OleDbgOutHResult("StgCreateDocfile returned", hr);
2489:
2490: if (0 == LoadString(ghInst, IDS_OLESTDNOCREATEFILE, (LPSTR)szMsg, 64))
2491: return NULL;
2492:
2493: MessageBox(NULL, (LPSTR)szMsg, NULL,MB_ICONEXCLAMATION | MB_OK);
2494: return NULL;
2495: }
2496:
2497:
2498: /*************************************************************************
2499: ** OleStdOpenRootStorage
2500: ** open a root level Storage given a filename that is compatible
2501: ** to be used by a top-level OLE container. if the file does not
2502: ** exist then an error is returned.
2503: ** the root storage (Docfile) that is opened by this function
2504: ** is suitable to be used to create child storages for embedings.
2505: ** (CreateChildStorage can be used to create child storages.)
2506: ** NOTE: the root-level storage is opened in transacted mode.
2507: *************************************************************************/
2508:
2509: STDAPI_(LPSTORAGE) OleStdOpenRootStorage(LPSTR lpszStgName, DWORD grfMode)
2510: {
2511: HRESULT hr;
2512: DWORD reserved = 0;
2513: LPSTORAGE lpRootStg;
2514: char szMsg[64];
2515:
2516: if (lpszStgName) {
2517:
2518: hr = StgOpenStorage(
2519: lpszStgName,
2520: NULL,
2521: grfMode | STGM_TRANSACTED,
2522: NULL,
2523: reserved,
2524: (LPSTORAGE FAR*)&lpRootStg
2525: );
2526:
2527: if (hr == NOERROR)
2528: return lpRootStg; // existing file successfully opened
2529:
2530: OleDbgOutHResult("StgOpenStorage returned", hr);
2531: }
2532:
2533: if (0 == LoadString(ghInst, IDS_OLESTDNOOPENFILE, szMsg, 64))
2534: return NULL;
2535:
2536: MessageBox(NULL, (LPSTR)szMsg, NULL,MB_ICONEXCLAMATION | MB_OK);
2537: return NULL;
2538: }
2539:
2540:
2541: /*************************************************************************
2542: ** OpenOrCreateRootStorage
2543: ** open a root level Storage given a filename that is compatible
2544: ** to be used by a top-level OLE container. if the filename
2545: ** specifies an existing file, then it is open, otherwise a new file
2546: ** with the given name is created.
2547: ** the root storage (Docfile) that is created by this function
2548: ** is suitable to be used to create child storages for embedings.
2549: ** (CreateChildStorage can be used to create child storages.)
2550: ** NOTE: the root-level storage is opened in transacted mode.
2551: *************************************************************************/
2552:
2553: STDAPI_(LPSTORAGE) OleStdOpenOrCreateRootStorage(LPSTR lpszStgName, DWORD grfMode)
2554: {
2555: HRESULT hrErr;
2556: SCODE sc;
2557: DWORD reserved = 0;
2558: LPSTORAGE lpRootStg;
2559: char szMsg[64];
2560:
2561: if (lpszStgName) {
2562:
2563: hrErr = StgOpenStorage(
2564: lpszStgName,
2565: NULL,
2566: grfMode | STGM_READWRITE | STGM_TRANSACTED,
2567: NULL,
2568: reserved,
2569: (LPSTORAGE FAR*)&lpRootStg
2570: );
2571:
2572: if (hrErr == NOERROR)
2573: return lpRootStg; // existing file successfully opened
2574:
2575: OleDbgOutHResult("StgOpenStorage returned", hrErr);
2576: sc = GetScode(hrErr);
2577:
2578: if (sc!=STG_E_FILENOTFOUND && sc!=STG_E_FILEALREADYEXISTS) {
2579: return NULL;
2580: }
2581: }
2582:
2583: /* if file did not already exist, try to create a new one */
2584: hrErr = StgCreateDocfile(
2585: lpszStgName,
2586: grfMode | STGM_READWRITE | STGM_TRANSACTED,
2587: reserved,
2588: (LPSTORAGE FAR*)&lpRootStg
2589: );
2590:
2591: if (hrErr == NOERROR)
2592: return lpRootStg; // existing file successfully opened
2593:
2594: OleDbgOutHResult("StgCreateDocfile returned", hrErr);
2595:
2596: if (0 == LoadString(ghInst, IDS_OLESTDNOCREATEFILE, (LPSTR)szMsg, 64))
2597: return NULL;
2598:
2599: MessageBox(NULL, (LPSTR)szMsg, NULL, MB_ICONEXCLAMATION | MB_OK);
2600: return NULL;
2601: }
2602:
2603:
2604: /*
2605: ** OleStdCreateChildStorage
2606: ** create a child Storage inside the given lpStg that is compatible
2607: ** to be used by an embedded OLE object. the return value from this
2608: ** function can be passed to OleCreateXXX functions.
2609: ** NOTE: the child storage is opened in transacted mode.
2610: */
2611: STDAPI_(LPSTORAGE) OleStdCreateChildStorage(LPSTORAGE lpStg, LPSTR lpszStgName)
2612: {
2613: if (lpStg != NULL) {
2614: LPSTORAGE lpChildStg;
2615: DWORD grfMode = (STGM_READWRITE | STGM_TRANSACTED |
2616: STGM_SHARE_EXCLUSIVE);
2617: DWORD reserved = 0;
2618:
2619: HRESULT hrErr = lpStg->lpVtbl->CreateStorage(
2620: lpStg,
2621: lpszStgName,
2622: grfMode,
2623: reserved,
2624: reserved,
2625: (LPSTORAGE FAR*)&lpChildStg
2626: );
2627:
2628: if (hrErr == NOERROR)
2629: return lpChildStg;
2630:
2631: OleDbgOutHResult("lpStg->lpVtbl->CreateStorage returned", hrErr);
2632: }
2633: return NULL;
2634: }
2635:
2636:
2637: /*
2638: ** OleStdOpenChildStorage
2639: ** open a child Storage inside the given lpStg that is compatible
2640: ** to be used by an embedded OLE object. the return value from this
2641: ** function can be passed to OleLoad function.
2642: ** NOTE: the child storage is opened in transacted mode.
2643: */
2644: STDAPI_(LPSTORAGE) OleStdOpenChildStorage(LPSTORAGE lpStg, LPSTR lpszStgName, DWORD grfMode)
2645: {
2646: LPSTORAGE lpChildStg;
2647: LPSTORAGE lpstgPriority = NULL;
2648: DWORD reserved = 0;
2649: HRESULT hrErr;
2650:
2651: if (lpStg != NULL) {
2652:
2653: hrErr = lpStg->lpVtbl->OpenStorage(
2654: lpStg,
2655: lpszStgName,
2656: lpstgPriority,
2657: grfMode | STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE,
2658: NULL,
2659: reserved,
2660: (LPSTORAGE FAR*)&lpChildStg
2661: );
2662:
2663: if (hrErr == NOERROR)
2664: return lpChildStg;
2665:
2666: OleDbgOutHResult("lpStg->lpVtbl->OpenStorage returned", hrErr);
2667: }
2668: return NULL;
2669: }
2670:
2671: /* OleStdCommitStorage
2672: ** -------------------
2673: ** Commit the changes to the given IStorage*. This routine can be
2674: ** called on either a root-level storage as used by an OLE-Container
2675: ** or by a child storage as used by an embedded object.
2676: **
2677: ** This routine first attempts to perform this commit in a safe
2678: ** manner. if this fails it then attempts to do the commit in a less
2679: ** robust manner (STGC_OVERWRITE).
2680: */
2681: STDAPI_(BOOL) OleStdCommitStorage(LPSTORAGE lpStg)
2682: {
2683: HRESULT hrErr;
2684:
2685: // make the changes permanent
2686: hrErr = lpStg->lpVtbl->Commit(lpStg, 0);
2687:
2688: if (GetScode(hrErr) == STG_E_MEDIUMFULL) {
2689: // try to commit changes in less robust manner.
2690: OleDbgOut("Warning: commiting with STGC_OVERWRITE specified\n");
2691: hrErr = lpStg->lpVtbl->Commit(lpStg, STGC_OVERWRITE);
2692: }
2693:
2694: if (hrErr != NOERROR)
2695: {
2696: char szMsg[64];
2697:
2698: if (0 == LoadString(ghInst, IDS_OLESTDDISKFULL, (LPSTR)szMsg, 64))
2699: return FALSE;
2700:
2701: MessageBox(NULL, (LPSTR)szMsg, NULL, MB_ICONEXCLAMATION | MB_OK);
2702: return FALSE;
2703: }
2704: else {
2705: return TRUE;
2706: }
2707: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.