![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to olecli.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / mfc / src|
Return to olecli.cpp CVS log | Up to [WindowsNT SDKs] / mstools / mfc / src |
1.1 root 1: // This is a part of the Microsoft Foundation Classes C++ library.
2: // Copyright (C) 1992 Microsoft Corporation
3: // All rights reserved.
4: //
5: // This source code is only intended as a supplement to the
6: // Microsoft Foundation Classes Reference and Microsoft
7: // QuickHelp documentation provided with the library.
8: // See these sources for detailed information regarding the
9: // Microsoft Foundation Classes product.
10:
11:
12: #include "afxole.h"
13: #pragma hdrstop
14:
15: #include "oleptr_.h"
16:
17: #ifdef AFX_OLE_SEG
18: #pragma code_seg(AFX_OLE_SEG)
19: #endif
20:
21: #ifdef _DEBUG
22: #undef THIS_FILE
23: static char BASED_CODE THIS_FILE[] = __FILE__;
24: #endif
25:
26: #define OLEEXPORT FAR PASCAL _export
27:
28: /////////////////////////////////////////////////////////////////////////////
29: #ifdef _DEBUG
30: // character strings to use for debug traces
31:
32: static char BASED_CODE szCHANGED[] = "OLE_CHANGED";
33: static char BASED_CODE szSAVED[] = "OLE_SAVED";
34: static char BASED_CODE szCLOSED[] = "OLE_CLOSED";
35: static char BASED_CODE szRENAMED[] = "OLE_RENAMED";
36: static char BASED_CODE szQUERY_PAINT[] = "OLE_QUERY_PAINT";
37: static char BASED_CODE szRELEASE[] = "OLE_RELEASE";
38: static char BASED_CODE szQUERY_RETRY[] = "OLE_QUERY_RETRY";
39:
40: static char FAR* BASED_CODE notifyStrings[] =
41: {
42: szCHANGED,
43: szSAVED,
44: szCLOSED,
45: szRENAMED,
46: szQUERY_PAINT,
47: szRELEASE,
48: szQUERY_RETRY,
49: };
50: #endif //_DEBUG
51:
52: // Standard protocol strings
53: static char BASED_CODE lpszStaticProtocol[] = "Static";
54: static char BASED_CODE lpszStdProtocol[] = "StdFileEditing";
55:
56: /////////////////////////////////////////////////////////////////////////////
57: // Client view of OLEOBJECT (includes OLECLIENT)
58:
59: IMPLEMENT_DYNAMIC(COleClientItem, CObject)
60:
61: inline COleClientItem *
62: COleClientItem::FromLp(LPOLECLIENT lpClient)
63: {
64: ASSERT(lpClient != NULL);
65: COleClientItem* pOleClient;
66: pOleClient = (COleClientItem*) GetPtrFromFarPtr(lpClient, sizeof(CObject));
67: ASSERT(lpClient == &pOleClient->m_oleClient);
68: return pOleClient;
69: }
70:
71: // friend class to get access to COleClientItem protected implementations
72: struct _afxOleClientItemImplementation
73: {
74: static int OLEEXPORT
75: Client_CallBack(LPOLECLIENT lpClient, OLE_NOTIFICATION wNotification,
76: LPOLEOBJECT lpObject)
77: {
78: COleClientItem* pOleClient = COleClientItem::FromLp(lpClient);
79: ASSERT(pOleClient != NULL);
80:
81: #ifdef _DEBUG
82: if (wNotification != OLE_QUERY_PAINT)
83: {
84: if (afxTraceFlags & 0x10)
85: TRACE("OLE Client_Callback %d [%Fs] for $%lx\n",
86: wNotification, (LPCSTR)notifyStrings[wNotification], lpObject);
87: }
88: #else
89: (void)lpObject; // not used
90: #endif
91: return pOleClient->ClientCallBack(wNotification);
92: }
93: };
94:
95: static struct _OLECLIENTVTBL NEAR clientVtbl =
96: {
97: &_afxOleClientItemImplementation::Client_CallBack
98: };
99:
100: // Many creation variants
101: COleClientItem::COleClientItem(COleClientDoc* pContainerDoc)
102: {
103: ASSERT(pContainerDoc != NULL);
104: ASSERT(pContainerDoc->IsOpen());
105:
106: m_oleClient.lpvtbl = &clientVtbl;
107: m_lpObject = NULL;
108: m_lastStatus = OLE_OK;
109: m_pDocument = pContainerDoc;
110: }
111:
112: COleClientItem::~COleClientItem()
113: {
114: if (m_lpObject != NULL)
115: {
116: // wait for object to be not busy
117: UINT nType = GetType();
118:
119: if (nType != OT_STATIC)
120: WaitForServer();
121: // release linked, delete others
122: CheckAsync((nType == OT_LINK) ?
123: ::OleRelease(m_lpObject) : ::OleDelete(m_lpObject));
124: }
125: }
126:
127: void COleClientItem::Release()
128: {
129: if (m_lpObject == NULL)
130: return;
131:
132: CheckAsync(::OleRelease(m_lpObject));
133:
134: // detach
135: m_lpObject = NULL;
136: }
137:
138: void COleClientItem::Delete()
139: {
140: if (m_lpObject == NULL)
141: return;
142:
143: CheckAsync(::OleDelete(m_lpObject));
144:
145: // detach
146: m_lpObject = NULL;
147: }
148:
149: //////////////////////////////////////////////////////////////////////////////
150: // Create error handling
151:
152: BOOL COleClientItem::CheckCreate(OLESTATUS status)
153: {
154: m_lastStatus = status;
155:
156: switch (status)
157: {
158: case OLE_OK:
159: ASSERT(m_lpObject != NULL);
160: return TRUE; // immediate create success
161:
162: case OLE_WAIT_FOR_RELEASE: // synchronous create
163: ASSERT(m_lpObject != NULL);
164: WaitForServer();
165: return (m_lastStatus == OLE_OK);
166:
167: // cases to treat as exceptions
168: case OLE_ERROR_PROTECT_ONLY:
169: case OLE_ERROR_MEMORY:
170: case OLE_ERROR_OBJECT:
171: case OLE_ERROR_OPTION:
172: TRACE("Warning: COleClientItem::Create?() failed %d\n", status);
173: AfxThrowOleException(status);
174: break;
175: }
176:
177: // the rest are non-exceptional conditions for create
178: TRACE("Warning: COleClientItem::Create?() failed %d, returning FALSE\n", status);
179: m_lpObject = NULL; // just in case
180: return FALSE; // create failed
181: }
182:
183:
184: void COleClientItem::CheckAsync(OLESTATUS status)
185: // special case for possible Async requests
186: {
187: if (status == OLE_WAIT_FOR_RELEASE)
188: {
189: ASSERT(m_lpObject != NULL);
190: WaitForServer();
191: status = m_lastStatus; // set by ASYNC release
192: ASSERT(status != OLE_WAIT_FOR_RELEASE);
193: }
194: CheckGeneral(status); // may throw an exception
195: }
196:
197: void COleClientItem::CheckGeneral(OLESTATUS status)
198: // set 'm_lastStatus'
199: // throw exception if not ok to continue
200: {
201: ASSERT(status != OLE_WAIT_FOR_RELEASE);
202: // Async must be handled as a special case before this
203:
204: m_lastStatus = status;
205: if (status == OLE_OK || status > OLE_WARN_DELETE_DATA)
206: {
207: // ok, or just a warning
208: return;
209: }
210:
211: // otherwise this error wasn't expected, so throw an exception
212: TRACE("Warning: COleClientItem operation failed %d, throwing exception\n", status);
213: AfxThrowOleException(status);
214: }
215:
216:
217: //////////////////////////////////////////////////////////////////////////////
218: // Create variants for real OLEOBJECTs
219:
220: // From clipboard
221: BOOL COleClientItem::CanPaste(OLEOPT_RENDER renderopt,
222: OLECLIPFORMAT cfFormat)
223: {
224: return ::OleQueryCreateFromClip(lpszStdProtocol,
225: renderopt, cfFormat) == OLE_OK ||
226: ::OleQueryCreateFromClip(lpszStaticProtocol,
227: renderopt, cfFormat) == OLE_OK;
228: }
229:
230: BOOL COleClientItem::CanPasteLink(OLEOPT_RENDER renderopt,
231: OLECLIPFORMAT cfFormat)
232: {
233: return ::OleQueryLinkFromClip(lpszStdProtocol,
234: renderopt, cfFormat) == OLE_OK;
235: }
236:
237:
238: BOOL COleClientItem::CreateFromClipboard(LPCSTR lpszObjname,
239: OLEOPT_RENDER renderopt, OLECLIPFORMAT cfFormat)
240: {
241: ASSERT(m_lpObject == NULL); // one time only
242: ASSERT(m_pDocument != NULL);
243: ASSERT(m_pDocument->IsOpen());
244: ASSERT(lpszObjname != NULL);
245:
246: return CheckCreate(::OleCreateFromClip(lpszStdProtocol,
247: &m_oleClient, m_pDocument->m_lhClientDoc, lpszObjname,
248: &m_lpObject, renderopt, cfFormat));
249: }
250:
251: BOOL COleClientItem::CreateStaticFromClipboard(LPCSTR lpszObjname,
252: OLEOPT_RENDER renderopt, OLECLIPFORMAT cfFormat)
253: {
254: ASSERT(m_lpObject == NULL); // one time only
255: ASSERT(m_pDocument != NULL);
256: ASSERT(m_pDocument->IsOpen());
257: ASSERT(lpszObjname != NULL);
258:
259: return CheckCreate(::OleCreateFromClip(lpszStaticProtocol,
260: &m_oleClient, m_pDocument->m_lhClientDoc, lpszObjname,
261: &m_lpObject, renderopt, cfFormat));
262: }
263:
264: BOOL COleClientItem::CreateLinkFromClipboard(LPCSTR lpszObjname,
265: OLEOPT_RENDER renderopt, OLECLIPFORMAT cfFormat)
266: {
267: ASSERT(m_lpObject == NULL); // one time only
268: ASSERT(m_pDocument != NULL);
269: ASSERT(m_pDocument->IsOpen());
270: ASSERT(lpszObjname != NULL);
271:
272: return CheckCreate(::OleCreateLinkFromClip(lpszStdProtocol,
273: &m_oleClient, m_pDocument->m_lhClientDoc, lpszObjname,
274: &m_lpObject, renderopt, cfFormat));
275: }
276:
277:
278: // create from a protocol name or other template
279: BOOL COleClientItem::CreateNewObject(LPCSTR lpszClass, LPCSTR lpszObjname,
280: OLEOPT_RENDER renderopt, OLECLIPFORMAT cfFormat)
281: {
282: ASSERT(m_lpObject == NULL); // one time only
283: ASSERT(m_pDocument != NULL);
284: ASSERT(m_pDocument->IsOpen());
285: ASSERT(lpszClass != NULL);
286: ASSERT(lpszObjname != NULL);
287:
288: return CheckCreate(::OleCreate(lpszStdProtocol,
289: &m_oleClient, lpszClass,
290: m_pDocument->m_lhClientDoc, lpszObjname,
291: &m_lpObject, renderopt, cfFormat));
292: }
293:
294: // create invisible
295: BOOL COleClientItem::CreateInvisibleObject(LPCSTR lpszClass, LPCSTR lpszObjname,
296: OLEOPT_RENDER renderopt, OLECLIPFORMAT cfFormat, BOOL bActivate)
297: {
298: ASSERT(m_lpObject == NULL); // one time only
299: ASSERT(m_pDocument != NULL);
300: ASSERT(m_pDocument->IsOpen());
301: ASSERT(lpszClass != NULL);
302: ASSERT(lpszObjname != NULL);
303:
304: return CheckCreate(::OleCreateInvisible(lpszStdProtocol,
305: &m_oleClient, lpszClass,
306: m_pDocument->m_lhClientDoc, lpszObjname,
307: &m_lpObject, renderopt, cfFormat, bActivate));
308: }
309:
310:
311: /////////////////////////////////////////////////////////////////////////////
312: // More advanced creation
313:
314: BOOL COleClientItem::CreateCloneFrom(COleClientItem* pSrcObject,
315: LPCSTR lpszObjname)
316: {
317: ASSERT(m_lpObject == NULL); // one time only
318: ASSERT(pSrcObject != NULL);
319: ASSERT(m_pDocument != NULL);
320: ASSERT(m_pDocument->IsOpen());
321: ASSERT(lpszObjname != NULL);
322:
323: return CheckCreate(::OleClone(pSrcObject->m_lpObject,
324: &m_oleClient, m_pDocument->m_lhClientDoc, lpszObjname,
325: &m_lpObject));
326: }
327:
328:
329: /////////////////////////////////////////////////////////////////////////////
330: // Default implementations
331:
332: int COleClientItem::ClientCallBack(OLE_NOTIFICATION wNotification)
333: {
334: switch (wNotification)
335: {
336: case OLE_CHANGED: // OLE linked item updated
337: case OLE_SAVED: // OLE server document saved
338: case OLE_CLOSED: // OLE server document closed
339: OnChange(wNotification);
340: break;
341: case OLE_RENAMED:
342: OnRenamed();
343: break;
344: case OLE_RELEASE:
345: OnRelease();
346: break;
347: default:
348: // ignore it (eg: QueryPaint and QueryRetry)
349: break;
350: }
351:
352: return TRUE; // return TRUE in general
353: }
354:
355: void COleClientItem::OnRenamed()
356: {
357: // ignore normally
358: }
359:
360: void COleClientItem::OnRelease()
361: {
362: ASSERT(m_lpObject != NULL);
363: // default will store the release error
364: m_lastStatus = ::OleQueryReleaseError(m_lpObject);
365: ASSERT(m_lastStatus != OLE_WAIT_FOR_RELEASE);
366:
367: if (m_lastStatus != OLE_OK)
368: {
369: // operation failed
370: #ifdef _DEBUG
371: TRACE("Warning: COleClientItem::OnRelease with error %d ($%lx)\n", m_lastStatus,
372: m_lpObject);
373: #endif
374: return;
375: }
376:
377: // Success
378: OLE_RELEASE_METHOD nWhyReleased = ::OleQueryReleaseMethod(m_lpObject);
379:
380: if (nWhyReleased == OLE_DELETE)
381: m_lpObject = NULL; // detach
382: }
383:
384: /////////////////////////////////////////////////////////////////////////////
385: // COleClientItem - attributes
386:
387:
388: UINT COleClientItem::GetType()
389: {
390: ASSERT(m_lpObject != NULL);
391: LONG lType;
392:
393: CheckGeneral(::OleQueryType(m_lpObject, &lType));
394: ASSERT(lType == OT_LINK || lType == OT_EMBEDDED || lType == OT_STATIC);
395: return (UINT)lType;
396: }
397:
398:
399: CString COleClientItem::GetName()
400: {
401: ASSERT(m_lpObject != NULL);
402: char szT[OLE_MAXNAMESIZE];
403:
404: UINT cb = OLE_MAXNAMESIZE;
405: CheckGeneral(::OleQueryName(m_lpObject, szT, &cb));
406:
407: ASSERT(cb == strlen(szT));
408: return CString(szT);
409: }
410:
411:
412: BOOL COleClientItem::GetSize(LPPOINT lpSize)
413: {
414: ASSERT(m_lpObject != NULL);
415:
416: m_lastStatus = ::OleQuerySize(m_lpObject, (DWORD FAR*)lpSize);
417: if (m_lastStatus == OLE_ERROR_BLANK)
418: return FALSE; // no size set yet
419: CheckGeneral(m_lastStatus); // may throw exception
420: return TRUE;
421: }
422:
423: BOOL COleClientItem::GetBounds(LPRECT lpBounds)
424: {
425: ASSERT(m_lpObject != NULL);
426:
427: m_lastStatus = ::OleQueryBounds(m_lpObject, lpBounds);
428: if (m_lastStatus == OLE_ERROR_BLANK)
429: return FALSE; // no size set yet
430: CheckGeneral(m_lastStatus); // may throw exception
431: return TRUE;
432: }
433:
434: BOOL COleClientItem::IsOpen()
435: {
436: ASSERT(m_lpObject != NULL);
437:
438: m_lastStatus = ::OleQueryOpen(m_lpObject);
439: if (m_lastStatus == OLE_ERROR_NOT_OPEN)
440: return FALSE; // not open
441: CheckGeneral(m_lastStatus); // may throw exception
442: return TRUE;
443: }
444:
445: /////////////////////////////////////////////////////////////////////////////
446: // Data exchange plus helpers
447:
448: HANDLE
449: COleClientItem::GetData(OLECLIPFORMAT nFormat, BOOL& bMustDelete)
450: {
451: HANDLE hData = NULL;
452:
453: CheckGeneral(::OleGetData(m_lpObject, nFormat, &hData));
454:
455: ASSERT(hData != NULL);
456: bMustDelete = (m_lastStatus == OLE_WARN_DELETE_DATA);
457: return hData;
458: }
459:
460:
461: void
462: COleClientItem::SetData(OLECLIPFORMAT nFormat, HANDLE hData)
463: {
464: ASSERT(m_lpObject != NULL);
465: CheckAsync(::OleSetData(m_lpObject, nFormat, hData));
466: }
467:
468: void
469: COleClientItem::RequestData(OLECLIPFORMAT nFormat)
470: {
471: ASSERT(m_lpObject != NULL);
472: CheckAsync(::OleRequestData(m_lpObject, nFormat));
473: }
474:
475: /////////////////////////////////////////////////////////////////////////////
476: // Rare or implementation specific attributes
477:
478: BOOL
479: COleClientItem::IsEqual(COleClientItem* pObject)
480: {
481: ASSERT(m_lpObject != NULL);
482: ASSERT(pObject != NULL);
483: ASSERT(pObject->m_lpObject != NULL);
484:
485: m_lastStatus = ::OleEqual(m_lpObject, pObject->m_lpObject);
486: if (m_lastStatus == OLE_ERROR_NOT_EQUAL)
487: return FALSE; // FALSE => not equal
488: CheckGeneral(m_lastStatus); // may throw exception
489: return TRUE; // otherwise equal
490: }
491:
492: HANDLE
493: COleClientItem::GetLinkFormatData()
494: // Return global HANDLE of block containing link information
495: // will return NULL if error or not appropriate type
496: // Both link formats are: "szClass0szDocument0szItem00" */
497: {
498: OLECLIPFORMAT cf = NULL;
499:
500: // first determine the format of the link data
501: switch (GetType())
502: {
503: default:
504: return NULL; // Static or other (i.e. no link format)
505: case OT_EMBEDDED:
506: cf = (OLECLIPFORMAT)::RegisterClipboardFormat("OwnerLink");
507: break;
508: case OT_LINK:
509: cf = (OLECLIPFORMAT)::RegisterClipboardFormat("ObjectLink");
510: break;
511: }
512: ASSERT(cf != NULL);
513:
514: // now get the link data
515: BOOL bMustDelete;
516: HANDLE h;
517: if ((h = GetData(cf, bMustDelete)) == NULL)
518: return NULL;
519: ASSERT(!bMustDelete); // must not have to delete clip format data
520: return h;
521: }
522:
523:
524: /////////////////////////////////////////////////////////////////////////////
525: // Special link attributes
526:
527: OLEOPT_UPDATE COleClientItem::GetLinkUpdateOptions()
528: {
529: ASSERT(m_lpObject != NULL);
530: OLEOPT_UPDATE updateOpt;
531:
532: CheckGeneral(::OleGetLinkUpdateOptions(m_lpObject, &updateOpt));
533: return updateOpt;
534: }
535:
536: void
537: COleClientItem::SetLinkUpdateOptions(OLEOPT_UPDATE updateOpt)
538: {
539: ASSERT(m_lpObject != NULL);
540:
541: CheckAsync(::OleSetLinkUpdateOptions(m_lpObject, updateOpt));
542: }
543:
544: /////////////////////////////////////////////////////////////////////////////
545: // COleClientItem - general operations
546:
547: BOOL
548: COleClientItem::Draw(CDC *pDC, LPRECT lpBounds, LPRECT lpWBounds,
549: CDC* pFormatDC)
550: {
551: ASSERT(m_lpObject != NULL);
552: ASSERT(pDC != NULL);
553: // pFormatDC may be null
554:
555: m_lastStatus = ::OleDraw(m_lpObject, pDC->m_hDC, lpBounds,
556: lpWBounds, pFormatDC->GetSafeHdc());
557:
558: if (m_lastStatus == OLE_ERROR_ABORT || m_lastStatus == OLE_ERROR_DRAW ||
559: m_lastStatus == OLE_ERROR_BLANK)
560: return FALSE; // expected errors
561:
562: CheckGeneral(m_lastStatus); // may throw exception
563: return TRUE; // it worked
564: }
565:
566: void
567: COleClientItem::Activate(UINT nVerb, BOOL bShow, BOOL bTakeFocus,
568: CWnd* pWndContainer, LPRECT lpBounds)
569: {
570: ASSERT(m_lpObject != NULL);
571:
572: CheckAsync(::OleActivate(m_lpObject, nVerb, bShow,
573: bTakeFocus, pWndContainer->GetSafeHwnd(), lpBounds));
574: }
575:
576: /////////////////////////////////////////////////////////////////////////////
577: // more advanced operations
578:
579: void
580: COleClientItem::Rename(LPCSTR lpszNewname)
581: {
582: ASSERT(m_lpObject != NULL);
583: ASSERT(lpszNewname != NULL);
584: CheckGeneral(::OleRename(m_lpObject, lpszNewname));
585: }
586:
587: void
588: COleClientItem::CopyToClipboard()
589: {
590: ASSERT(m_lpObject != NULL);
591:
592: CheckGeneral(::OleCopyToClipboard(m_lpObject));
593: }
594:
595: void
596: COleClientItem::SetTargetDevice(HANDLE hData)
597: {
598: ASSERT(m_lpObject != NULL);
599: ASSERT(hData != NULL);
600: CheckAsync(::OleSetTargetDevice(m_lpObject, hData));
601: }
602:
603: /////////////////////////////////////////////////////////////////////////////
604: // Embedded COleClient operations
605:
606: void
607: COleClientItem::SetHostNames(LPCSTR lpszHost, LPCSTR lpszHostObj)
608: {
609: ASSERT(m_lpObject != NULL);
610: ASSERT(lpszHost != NULL);
611: ASSERT(lpszHostObj != NULL);
612:
613: CheckAsync(::OleSetHostNames(m_lpObject, lpszHost, lpszHostObj));
614: }
615:
616: void
617: COleClientItem::SetBounds(LPRECT lpRect)
618: {
619: ASSERT(m_lpObject != NULL);
620: CheckAsync(::OleSetBounds(m_lpObject, lpRect));
621: }
622:
623: void
624: COleClientItem::SetColorScheme(LPLOGPALETTE lpLogPalette)
625: {
626: ASSERT(m_lpObject != NULL);
627: CheckAsync(::OleSetColorScheme(m_lpObject, lpLogPalette));
628: }
629:
630: /////////////////////////////////////////////////////////////////////////////
631: // Linked COleClient operations
632:
633: void
634: COleClientItem::UpdateLink()
635: {
636: ASSERT(m_lpObject != NULL);
637:
638: CheckAsync(::OleUpdate(m_lpObject));
639: }
640:
641: void COleClientItem::CloseLink()
642: {
643: if (m_lpObject == NULL)
644: return;
645:
646: CheckAsync(::OleClose(m_lpObject));
647: // Does not detach since this can be reactivated later
648: }
649:
650: void
651: COleClientItem::ReconnectLink()
652: {
653: ASSERT(m_lpObject != NULL);
654: CheckAsync(::OleReconnect(m_lpObject));
655: }
656:
657: BOOL COleClientItem::FreezeLink(LPCSTR lpszFrozenName)
658: {
659: ASSERT(m_lpObject != NULL);
660: ASSERT(m_pDocument != NULL);
661: ASSERT(m_pDocument->IsOpen());
662: ASSERT(lpszFrozenName != NULL);
663:
664: ASSERT(GetType() == OT_LINK);
665:
666: LPOLEOBJECT lpOriginalObject = m_lpObject;
667: m_lpObject = NULL;
668: if (!CheckCreate(::OleObjectConvert(lpOriginalObject,
669: lpszStaticProtocol,
670: &m_oleClient, m_pDocument->m_lhClientDoc, lpszFrozenName,
671: &m_lpObject)))
672: {
673: m_lpObject = lpOriginalObject;
674: return FALSE;
675: }
676: ASSERT(GetType() == OT_STATIC);
677:
678: // copy from link worked - now get rid of the original
679: ASSERT(m_lpObject != lpOriginalObject);
680: ASSERT(m_lpObject != NULL);
681:
682: LPOLEOBJECT lpNewObject = m_lpObject;
683: m_lpObject = lpOriginalObject;
684: ASSERT(GetType() == OT_LINK);
685: Delete();
686:
687: ASSERT(m_lpObject == NULL);
688: m_lpObject = lpNewObject;
689: ASSERT(GetType() == OT_STATIC);
690:
691: return TRUE;
692: }
693:
694: /////////////////////////////////////////////////////////////////////////////
695: /////////////////////////////////////////////////////////////////////////////
696: // _COleStream - implementation class connecting OLESTREAM and CArchive
697:
698: struct _COleStream : public _OLESTREAM
699: {
700: CArchive* m_pArchive;
701: _COleStream(CArchive& ar);
702: };
703:
704: static UINT CalcSize(DWORD cbTotal, const void FAR* lpStart)
705: {
706: // return size to read/write (16K max unless limited by segment bounds)
707: DWORD cbThisSeg = 0x10000 - _AFX_FP_OFF(lpStart);
708: DWORD cb = min(cbThisSeg, cbTotal);
709: return (cb > 16384) ? 16384 : (UINT)cb;
710: }
711:
712: // class for static exports
713: struct _afxOleStreamImplementation
714: {
715: static DWORD OLEEXPORT
716: Get(LPOLESTREAM lpStream, void FAR* lpBuffer, DWORD dwCount)
717: {
718: register _COleStream* pStream =
719: (_COleStream*)GetPtrFromFarPtr(lpStream, 0);
720: ASSERT(((LPVOID)pStream) == (LPVOID)lpStream); // no near/far mismatch
721:
722: DWORD dwToRead = dwCount;
723: while (dwToRead > 0)
724: {
725: UINT nRead = CalcSize(dwToRead, lpBuffer);
726: pStream->m_pArchive->Read(lpBuffer, nRead);
727: dwToRead -= nRead;
728: lpBuffer = ((BYTE _huge*)lpBuffer) + nRead;
729: }
730: return dwCount;
731: }
732:
733: static DWORD OLEEXPORT
734: Put(LPOLESTREAM lpStream, OLE_CONST void FAR* lpBuffer, DWORD dwCount)
735: {
736: register _COleStream* pStream =
737: (_COleStream*)GetPtrFromFarPtr(lpStream, 0);
738: ASSERT(((LPVOID)pStream) == (LPVOID)lpStream); // no near/far mismatch
739:
740: DWORD dwToWrite = dwCount;
741: while (dwToWrite > 0)
742: {
743: UINT nWrite = CalcSize(dwToWrite, lpBuffer);
744: pStream->m_pArchive->Write(lpBuffer, nWrite);
745: dwToWrite -= nWrite;
746: lpBuffer = ((OLE_CONST BYTE _huge*)lpBuffer) + nWrite;
747: }
748: return dwCount;
749: }
750: };
751:
752: static struct _OLESTREAMVTBL NEAR streamVtbl =
753: {
754: &_afxOleStreamImplementation::Get,
755: &_afxOleStreamImplementation::Put
756: };
757:
758: _COleStream::_COleStream(CArchive& ar)
759: {
760: m_pArchive = &ar;
761: lpstbl = &streamVtbl; // OLE VTable setup
762: }
763:
764: /////////////////////////////////////////////////////////////////////////////
765: // COleClientItem - serialization
766:
767: void COleClientItem::Serialize(CArchive& ar)
768: {
769: ASSERT(GetDocument() != NULL); // must 'SetDocument' first
770: _COleStream oleStream(ar);
771:
772: if (ar.IsStoring())
773: {
774: ASSERT(m_lpObject != NULL);
775: ar << (WORD) GetType();
776: ar << GetName(); // save our document name
777:
778: // Save object
779: CheckGeneral(::OleSaveToStream(m_lpObject, &oleStream));
780: }
781: else
782: {
783: ASSERT(m_lpObject == NULL);
784:
785: WORD nType;
786: ar >> nType;
787: LPCSTR lpszProtocol;
788:
789: if (nType == OT_LINK || nType == OT_EMBEDDED)
790: {
791: lpszProtocol = lpszStdProtocol;
792: }
793: else if (nType == OT_STATIC)
794: {
795: lpszProtocol = lpszStaticProtocol;
796: }
797: else
798: {
799: // unknown type (i.e. bad file format)
800: AfxThrowOleException(OLE_ERROR_GENERIC);
801: }
802:
803: CString name;
804: ar >> name; // document name
805: if (!CheckCreate(::OleLoadFromStream(&oleStream, lpszProtocol,
806: &m_oleClient, m_pDocument->m_lhClientDoc, name, &m_lpObject)))
807: {
808: // throw an exception regardless
809: AfxThrowOleException(GetLastStatus());
810: }
811: }
812: }
813:
814: /////////////////////////////////////////////////////////////////////////////
815: // COleClientDoc - wrapper for LHCLIENTDOC
816:
817: IMPLEMENT_DYNAMIC(COleClientDoc, CObject)
818:
819: COleClientDoc::COleClientDoc()
820: {
821: m_lhClientDoc = NULL; // not open
822: }
823:
824: void
825: COleClientDoc::Revoke()
826: {
827: if (!IsOpen())
828: return;
829: LHCLIENTDOC lh = m_lhClientDoc;
830: ASSERT(lh != NULL);
831: m_lhClientDoc = NULL;
832: CheckGeneral(::OleRevokeClientDoc(lh));
833: }
834:
835: COleClientDoc::~COleClientDoc()
836: {
837: Revoke();
838: }
839:
840: void COleClientDoc::CheckGeneral(OLESTATUS status) const
841: // throw exception if not ok to continue
842: {
843: ASSERT(status != OLE_WAIT_FOR_RELEASE);
844:
845: if (status == OLE_OK || status > OLE_WARN_DELETE_DATA)
846: {
847: // ok, or just a warning
848: return;
849: }
850:
851: // otherwise this error wasn't expected, so throw an exception
852: TRACE("Warning: COleClientDoc operation failed %d, throwing exception\n", status);
853: AfxThrowOleException(status);
854: }
855:
856: BOOL
857: COleClientDoc::Register(LPCSTR lpszClass, LPCSTR lpszDoc)
858: {
859: ASSERT(m_lhClientDoc == NULL); // one time only
860: return ::OleRegisterClientDoc(lpszClass, lpszDoc,
861: 0L /*reserved*/, &m_lhClientDoc) == OLE_OK;
862: }
863:
864: void
865: COleClientDoc::NotifyRename(LPCSTR lpszNewName)
866: {
867: ASSERT(IsOpen());
868: ASSERT(lpszNewName != NULL);
869:
870: CheckGeneral(::OleRenameClientDoc(m_lhClientDoc, lpszNewName));
871: }
872:
873: void
874: COleClientDoc::NotifyRevert()
875: {
876: ASSERT(IsOpen());
877:
878: CheckGeneral(::OleRevertClientDoc(m_lhClientDoc));
879: }
880:
881: void
882: COleClientDoc::NotifySaved()
883: {
884: ASSERT(IsOpen());
885:
886: CheckGeneral(::OleSavedClientDoc(m_lhClientDoc));
887: }
888:
889: /////////////////////////////////////////////////////////////////////////////
890: // Diagnostics
891:
892: #ifdef _DEBUG
893: void COleClientItem::AssertValid() const
894: {
895: CObject::AssertValid();
896: ASSERT(m_pDocument != NULL);
897: }
898:
899: void COleClientItem::Dump(CDumpContext& dc) const
900: {
901: CObject::Dump(dc);
902:
903: // shallow dump
904: dc << "\n\tm_pDocument = " << (void*) m_pDocument;
905: dc << "\n\tm_lpObject = " << m_lpObject;
906: dc << "\n\tm_lastStatus = " << (int)m_lastStatus;
907: }
908:
909:
910: void COleClientDoc::AssertValid() const
911: {
912: CObject::AssertValid();
913: ASSERT(m_lhClientDoc != NULL);
914: // only valid if truely open
915: }
916:
917: void COleClientDoc::Dump(CDumpContext& dc) const
918: {
919: CObject::Dump(dc);
920: dc << "\n\tm_lhClientDoc = " << m_lhClientDoc;
921: }
922:
923: #endif //_DEBUG
924:
925:
926: /////////////////////////////////////////////////////////////////////////////
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.