/* * @doc INTERNAL * * @module - DXFROBJ.C | * * implementation of a generic IDataObject data transfer object. * This object is suitable for use in OLE clipboard and drag drop * operations * * Author: * alexgo (4/25/95) * * Revisions: * murrays (7/13/95) auto-doc'd and added cf_RTF * * Copyright (c) 1995-1998, Microsoft Corporation. All rights reserved. */ #include "_common.h" #include "_edit.h" #include "_dxfrobj.h" #include "_range.h" #include "hash.h" #define NUMOBJCOPIEDFORWAITCURSOR 1 #ifdef PEGASUS #define NUMCHARCOPIEDFORWAITCURSOR 4096 #else #define NUMCHARCOPIEDFORWAITCURSOR 16384 #endif // // Common Data types // // If you change g_rgFETC[], change g_rgDOI[] and enum FETCINDEX and CFETC in // _dxfrobj.h accordingly, and register nonstandard clipboard formats in // RegisterFETCs(). Order entries in order of most desirable to least, e.g., // RTF in front of plain text. //REVIEW (keithcu) All but the first column is const--separate into 2 data structures? FORMATETC g_rgFETC[] = { {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // CF_RTFUTF8 {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // cf_RTF {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // RTF with NCRs for nonASCII {0, NULL, DVASPECT_CONTENT, -1, TYMED_ISTORAGE},// EmbObject {0, NULL, DVASPECT_CONTENT, -1, TYMED_ISTORAGE},// EmbSource {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // ObjDesc {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // LnkSource {CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT}, {CF_DIB, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, {CF_BITMAP, NULL, DVASPECT_CONTENT, -1, TYMED_GDI}, {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // RTF with no objs {CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, {CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // Filename {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}, // CF_RTFASTEXT {0, NULL, DVASPECT_CONTENT, -1, TYMED_ISTORAGE},// Text with objs {0, NULL, DVASPECT_CONTENT, -1, TYMED_ISTORAGE} // Richedit }; // Keep in sync with above and with FETCINDEX and CFETC const DWORD g_rgDOI[] = { DOI_CANPASTERICH, // RTF in UTF8 encoding DOI_CANPASTERICH, // RTF DOI_CANPASTERICH, // RTF with NCRs for nonASCII DOI_CANPASTEOLE, // Embedded Object DOI_CANPASTEOLE, // Embed Source DOI_NONE, // Object Descriptor DOI_CANPASTEOLE, // Link Source DOI_CANPASTEOLE, // Metafile DOI_CANPASTEOLE, // DIB DOI_CANPASTEOLE, // Bitmap DOI_CANPASTERICH, // RTF with no objects DOI_CANPASTEPLAIN, // Unicode plain text DOI_CANPASTEPLAIN, // ANSI plain text DOI_CANPASTEOLE, // Filename DOI_CANPASTEPLAIN, // Pastes RTF as text DOI_CANPASTERICH, // Richedit Text DOI_CANPASTERICH // RichEdit Text w/formatting }; /* * RegisterFETCs() * * @func * Register nonstandard format ETCs. Called when DLL is loaded */ void RegisterFETCs() { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "RegisterFETCs"); #ifdef RTF_HASHCACHE HashKeyword_Init(); // Init rtf control keyword hash table. #endif #ifndef MACPORT g_rgFETC[iRtfFETC].cfFormat // Note: cfFormats are WORDs = (WORD)RegisterClipboardFormatA("Rich Text Format"); g_rgFETC[iRtfUtf8].cfFormat = (WORD)RegisterClipboardFormatA("RTF in UTF8"); g_rgFETC[iRtfNCRforNonASCII].cfFormat = (WORD)RegisterClipboardFormatA("RTF with NCRs for nonASCII"); g_rgFETC[iRtfAsTextFETC].cfFormat = (WORD)RegisterClipboardFormatA("RTF As Text"); g_rgFETC[iRichEdit].cfFormat = (WORD)RegisterClipboardFormatA("RICHEDIT"); g_rgFETC[iObtDesc].cfFormat = (WORD)RegisterClipboardFormatA(CF_OBJECTDESCRIPTOR); g_rgFETC[iEmbObj].cfFormat = (WORD)RegisterClipboardFormatA(CF_EMBEDDEDOBJECT); g_rgFETC[iEmbSrc].cfFormat = (WORD)RegisterClipboardFormatA(CF_EMBEDSOURCE); g_rgFETC[iLnkSrc].cfFormat = (WORD)RegisterClipboardFormatA(CF_LINKSOURCE); g_rgFETC[iRtfNoObjs].cfFormat = (WORD)RegisterClipboardFormatA("Rich Text Format Without Objects"); g_rgFETC[iTxtObj].cfFormat = (WORD)RegisterClipboardFormatA("RichEdit Text and Objects"); g_rgFETC[iFilename].cfFormat = (WORD)RegisterClipboardFormatA(CF_FILENAME); #else // MacPort: Should we even bother to register the clipboard formats if we // are not going to use WLM clipboard??? if(!g_rgFETC[iRtfFETC].cfFormat) { g_rgFETC[iRtfFETC].cfFormat = RegisterClipboardFormatA("RTF "); g_rgFETC[iRtfFETC].cfFormat = 'RTF '; } if(!g_rgFETC[iRtfAsTextFETC].cfFormat) { g_rgFETC[iRtfAsTextFETC].cfFormat = RegisterClipboardFormatA("RTFT"); g_rgFETC[iRtfAsTextFETC].cfFormat = 'RTFT'; } if(!g_rgFETC[iRichEdit].cfFormat) { g_rgFETC[iRichEdit].cfFormat = RegisterClipboardFormatA("RTE "); g_rgFETC[iRichEdit].cfFormat = 'RTE '; } if(!g_rgFETC[iObtDesc].cfFormat) { g_rgFETC[iObtDesc].cfFormat = RegisterClipboardFormatA(CF_OBJECTDESCRIPTOR); g_rgFETC[iObtDesc].cfFormat = cfObjectDescriptor; } if(!g_rgFETC[iEmbObj].cfFormat) { g_rgFETC[iEmbObj].cfFormat = RegisterClipboardFormatA(CF_EMBEDDEDOBJECT); g_rgFETC[iEmbObj].cfFormat = cfEmbeddedObject; } if(!g_rgFETC[iEmbSrc].cfFormat) { g_rgFETC[iEmbSrc].cfFormat = RegisterClipboardFormatA(CF_EMBEDSOURCE); g_rgFETC[iEmbSrc].cfFormat = cfEmbedSource; } if(!g_rgFETC[iLnkSrc].cfFormat) { g_rgFETC[iLnkSrc].cfFormat = RegisterClipboardFormatA(CF_LINKSOURCE); g_rgFETC[iLnkSrc].cfFormat = cfLinkSource; } if(!g_rgFETC[iRtfNoObjs].cfFormat) { g_rgFETC[iRtfNoObjs].cfFormat = RegisterClipboardFormatA("RwoO"); g_rgFETC[iRtfNoObjs].cfFormat = 'RwoO'; } if(!g_rgFETC[iTxtObj].cfFormat) { g_rgFETC[iTxtObj].cfFormat = RegisterClipboardFormatA("RTnO"); g_rgFETC[iTxtObj].cfFormat = 'RTnO'; } if(!g_rgFETC[iFilename].cfFormat) { g_rgFETC[iFilename].cfFormat = RegisterClipboardFormatA(CF_FILENAME); g_rgFETC[iFilename].cfFormat = cfFileName; } if(!g_rgFETC[iRtfUtf8].cfFormat) { g_rgFETC[iRtfUtf8].cfFormat = RegisterClipboardFormatA("UTF8 RTF"); g_rgFETC[iRtfUtf8].cfFormat = 'UTF8 RTF'; } #endif } // // CDataTransferObj PUBLIC methods // /* * CDataTransferObj::QueryInterface (riid, ppv) * * @mfunc * QueryInterface for CDataTransferObj * * @rdesc * HRESULT */ STDMETHODIMP CDataTransferObj::QueryInterface ( REFIID riid, // @parm Reference to requested interface ID void ** ppv) // @parm out parm for interface ptr { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::QueryInterface"); if(!ppv) return E_INVALIDARG; *ppv = NULL; if(IsZombie()) // Check for range zombie return CO_E_RELEASED; HRESULT hresult = E_NOINTERFACE; if( IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IDataObject) || IsEqualIID(riid, IID_IRichEditDO) ) { *ppv = this; AddRef(); hresult = NOERROR; } return hresult; } /* * CDataTransferObj::AddRef() * * @mfunc * IUnknown method * * @rdesc * ULONG - incremented reference count */ STDMETHODIMP_(ULONG) CDataTransferObj::AddRef() { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::AddRef"); return ++_crefs; } /* * CDataTransferObj::Release() * * @mfunc * IUnknown method * * @rdesc * ULONG - decremented reference count */ STDMETHODIMP_(ULONG) CDataTransferObj::Release() { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::Release"); _crefs--; if( _crefs == 0 ) { GlobalFree(_hPlainText); GlobalFree(_hRtfText); GlobalFree(_hRtfUtf8); GlobalFree(_hRtfNCRforNonASCII); delete this; return 0; } return _crefs; } /* * CDataTransferObj::DAdvise (pFormatetc, advf, pAdvSink, pdwConnection) * * @mfunc * establish an advisory connection * * @rdesc * HRESULT = OLE_E_ADVISENOTSUPPORTED * * @devnote * this is a data transfer object, thus the data is a "snapshot" and * cannot change -- no advises are supported. */ STDMETHODIMP CDataTransferObj::DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::DAdvise"); return OLE_E_ADVISENOTSUPPORTED; } /* * CDataTransferObj::DUnadvise (dwConnection) * * @mfunc * destroy an advisory connection * * @rdesc * HRESULT = OLE_E_ADVISENOTSUPPORTED * * @devnote * this is a data transfer object, thus the data is a "snapshot" and * cannot change -- no advises are supported. */ STDMETHODIMP CDataTransferObj::DUnadvise( DWORD dwConnection) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::DUnadvise"); return OLE_E_ADVISENOTSUPPORTED; } /* * CDataTransferObj::EnumDAdvise (ppenumAdvise) * * @mfunc * enumerate advisory connections * * @rdesc * HRESULT = OLE_E_ADVISENOTSUPPORTED * * @devnote * this is a data transfer object, thus the data is a "snapshot" and * cannot change -- no advises are supported. */ STDMETHODIMP CDataTransferObj::EnumDAdvise( IEnumSTATDATA ** ppenumAdvise) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::EnumDAdvise"); return OLE_E_ADVISENOTSUPPORTED; } /* * CDataTransferObj::EnumFormatEtc (dwDirection, ppenumFormatEtc) * * @mfunc * returns an enumerator which lists all of the available formats in * this data transfer object * * @rdesc * HRESULT * * @devnote * we have no 'set' formats for this object */ STDMETHODIMP CDataTransferObj::EnumFormatEtc( DWORD dwDirection, // @parm DATADIR_GET/SET IEnumFORMATETC **ppenumFormatEtc) // @parm out parm for enum FETC interface { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::EnumFormatEtc"); if(!ppenumFormatEtc) return E_INVALIDARG; *ppenumFormatEtc = NULL; if(IsZombie()) // Check for range zombie return CO_E_RELEASED; HRESULT hr = NOERROR; #ifdef DEBUG if (dwDirection == DATADIR_SET && !_ped->Get10Mode()) { Tracef(TRCSEVNONE, "RichEdit 2.0 EnumFormatEtc called with DATADIR_SET"); } #endif //Need riched10 compatibility hack to ignore dwDirection if(dwDirection == DATADIR_GET || _ped->Get10Mode()) hr = CEnumFormatEtc::Create(_prgFormats, _cTotal, ppenumFormatEtc); return hr; } /* * CDataTransferObj::GetCanonicalFormatEtc( pformatetc, pformatetcOut) * * @mfunc * from the given formatetc, return a more standard (or canonical) * format. * * @rdesc * HRESULT = E_NOTIMPL * * @devnote * (alexgo): we may need to write this routine if we ever do anything * snazzy with printers */ STDMETHODIMP CDataTransferObj::GetCanonicalFormatEtc( FORMATETC *pformatetc, FORMATETC *pformatetcOut) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::GetCanonicalFormatEtc"); return E_NOTIMPL; } /* * CDataTransferObj::GetData (pformatetcIn, pmedium) * * @mfunc * retrieves data of the specified format * * @rdesc * HRESULT */ STDMETHODIMP CDataTransferObj::GetData( FORMATETC *pformatetcIn, STGMEDIUM *pmedium ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::GetData"); FillMemory(pmedium, '\0', sizeof(STGMEDIUM)); pmedium->tymed = TYMED_NULL; if(IsZombie()) // Check for range zombie return CO_E_RELEASED; CLIPFORMAT cf = pformatetcIn->cfFormat; HRESULT hr = E_OUTOFMEMORY; // Default not enuf RAM // now handle 'native' richedit formats. if( cf && pformatetcIn->tymed & TYMED_HGLOBAL ) { if( cf == CF_UNICODETEXT ) pmedium->hGlobal = DuplicateHGlobal(TextToHglobal(_hPlainText, tPlain)); else if(cf == CF_TEXT) pmedium->hGlobal = TextHGlobalWtoA(TextToHglobal(_hPlainText, tPlain)); else if(cf == cf_RTF || cf == cf_RTFASTEXT || cf == cf_RTFNOOBJS) pmedium->hGlobal = DuplicateHGlobal(TextToHglobal(_hRtfText, tRtf)); else if(cf == cf_RTFUTF8) pmedium->hGlobal = DuplicateHGlobal(TextToHglobal(_hRtfUtf8, tRtfUtf8)); else if(cf == cf_RTFNCRFORNONASCII) pmedium->hGlobal = DuplicateHGlobal(TextToHglobal(_hRtfNCRforNonASCII, tRtfNCRforNonASCII)); else hr = DV_E_FORMATETC; if (hr == E_OUTOFMEMORY) { if( pmedium->hGlobal ) // Succeeded { pmedium->tymed = TYMED_HGLOBAL; hr = NOERROR; } return hr; } } if ((cf == cf_EMBEDDEDOBJECT || cf == cf_EMBEDSOURCE) && (pformatetcIn->tymed & TYMED_ISTORAGE)) { _pObjStg = GetDataForEmbeddedObject( _pOleObj, pmedium->pstg ); pmedium->tymed = TYMED_ISTORAGE; if (NULL == pmedium->pstg) pmedium->pstg = _pObjStg; hr = _pObjStg != NULL ? NOERROR : hr; return hr; } // Go through richedit's formats and see if there are any matches if( cf == cf_OBJECTDESCRIPTOR && (pformatetcIn->tymed & TYMED_HGLOBAL) && _hObjDesc) { pmedium->hGlobal = DuplicateHGlobal(_hObjDesc); pmedium->tymed = TYMED_HGLOBAL; return NOERROR; } // First propogate the message to the object and see if it handles the format if (_pOleObj) { // Include the formats supported by the object IDataObject * pdataobj = NULL; if (FAILED(_pOleObj->GetClipboardData(0, &pdataobj)) || pdataobj == NULL) _pOleObj->QueryInterface(IID_IDataObject, (void**) &pdataobj); if (pdataobj) { hr = pdataobj->GetData(pformatetcIn, pmedium); pdataobj->Release(); if (SUCCEEDED(hr)) { if ((cf == cf_EMBEDDEDOBJECT || cf == cf_EMBEDSOURCE) && _pOleObj) { OleSaveSiteFlags(pmedium->pstg, _dwFlags, _dwUser, _dvaspect); } return S_OK; } } } if( cf == CF_METAFILEPICT ) { pmedium->hMetaFilePict = OleDuplicateData(_hMFPict, CF_METAFILEPICT, 0); pmedium->tymed = TYMED_MFPICT; return NOERROR; } if( cf == CF_DIB ) { if( _ped->HasObjects() && _cch == 1 ) { COleObject *pobj = _ped->_pobjmgr->GetObjectFromCp(_cpMin); if (pobj) { HGLOBAL hdib = pobj->GetHdata(); if (hdib) { pmedium->hGlobal = DuplicateHGlobal(hdib); pmedium->tymed = TYMED_HGLOBAL; } } } return NOERROR; } return DV_E_FORMATETC; } /* * CDataTransferObj::GetDataForEmbeddedObject (pformatetc, lpstgdest) * * @mfunc * retrieves data for embedded object * * @rdesc * LPSTORAGE * */ LPSTORAGE CDataTransferObj::GetDataForEmbeddedObject( LPOLEOBJECT pOleObj, LPSTORAGE lpstgdest) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::GetDataForEmbeddedObject"); HRESULT hr, hr1; LPPERSISTSTORAGE pperstg; if (_pObjStg != NULL && lpstgdest != NULL) { // We saved the data previously. Copy it to destination. hr = _pObjStg->CopyTo(0, NULL, NULL, lpstgdest); if (hr == NOERROR) { lpstgdest->Commit(STGC_DEFAULT); return _pObjStg; } return NULL; } if (_pObjStg != NULL && lpstgdest == NULL) { // We saved the data previously. Return a reference _pObjStg->AddRef(); return _pObjStg; } // We don't have a saved copy. Create One. hr = pOleObj->QueryInterface( IID_IPersistStorage, (void **) &pperstg ); if (hr != NOERROR) return NULL; if (lpstgdest == NULL) { // It is null. We have to create our own. LPLOCKBYTES lpLockBytes = NULL; hr = CreateILockBytesOnHGlobal(NULL, TRUE, // delete on release (LPLOCKBYTES *)&lpLockBytes); if (hr != NOERROR) { pperstg->Release(); return NULL; } hr = StgCreateDocfileOnILockBytes( lpLockBytes, STGM_READWRITE | STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, // reserved &lpstgdest ); lpLockBytes->Release(); if (hr != NOERROR) { pperstg->Release(); return NULL; } _pObjStg = lpstgdest; } else { // Force the data to be saved _pObjStg = GetDataForEmbeddedObject( _pOleObj, NULL ); pperstg->Release(); return GetDataForEmbeddedObject( _pOleObj, lpstgdest ); } // OLE2NOTE: even if OleSave returns an error you should still call // SaveCompleted. hr = OleSave( pperstg, lpstgdest, FALSE /* fSameAsLoad */ ); hr1 = pperstg->SaveCompleted(NULL); if (hr != NOERROR || hr1 != NOERROR) // Should we use SUCCEED macros ???? lpstgdest = NULL; pperstg->Release(); return _pObjStg; } /* * CDataTransferObj::GetDataorObjectDescriptor (pformatetc, pmedium) * * @mfunc * retrieves data for embedded object descriptor * * @rdesc * HRESULT */ HGLOBAL CDataTransferObj::GetDataForObjectDescriptor( LPOLEOBJECT pOleObj, DWORD dwAspect, SIZEL* psizel) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::GetDataForObjectDescriptor"); POINTL ptl = {0}; SIZEL sizel = {0}; if (psizel) { sizel.cx = psizel->cx; sizel.cy = psizel->cy; } if (_hObjDesc == NULL) { _hObjDesc = OleGetObjectDescriptorDataFromOleObject( pOleObj, dwAspect, ptl, &sizel ); } return _hObjDesc; } /* * CDataTransferObj::GetDataHere (pformatetc, pmedium) * * @mfunc * retrieves data of the specified format into the given medium * * @rdesc * HRESULT = E_NOTIMPL * * @devnote (alexgo): technically, we're supposed to support transfers * into hglobals, but I'd rather not at the moment. */ STDMETHODIMP CDataTransferObj::GetDataHere( FORMATETC *pformatetc, STGMEDIUM *pmedium) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::GetDataHere"); CLIPFORMAT cf = pformatetc->cfFormat; HRESULT hr = DV_E_FORMATETC; if(IsZombie()) // Check for range zombie return CO_E_RELEASED; if( (cf == cf_EMBEDDEDOBJECT || cf == cf_EMBEDSOURCE) && (pformatetc->tymed & TYMED_ISTORAGE)) { // For some reason the NT4.0 and Win95 Shell // ask for the EMBEDSOURCE format. _pObjStg = GetDataForEmbeddedObject( _pOleObj, pmedium->pstg ); pmedium->tymed = TYMED_ISTORAGE; if (NULL == pmedium->pstg) pmedium->pstg = _pObjStg; hr = pmedium->pstg != NULL ? NOERROR : hr; return hr; } if( cf == cf_OBJECTDESCRIPTOR && (pformatetc->tymed & TYMED_HGLOBAL) && _hObjDesc) { pmedium->hGlobal = DuplicateHGlobal(_hObjDesc); pmedium->tymed = TYMED_HGLOBAL; return NOERROR; } // First propogate the message to the object and see if it handles the format if (_pOleObj) { // Include the formats supported by the object IDataObject * pdataobj = NULL; if (FAILED(_pOleObj->GetClipboardData(0, &pdataobj)) || pdataobj == NULL) _pOleObj->QueryInterface(IID_IDataObject, (void**) &pdataobj); if (pdataobj) { hr = pdataobj->GetData(pformatetc, pmedium); pdataobj->Release(); if (hr == S_OK) { if ((cf == cf_EMBEDDEDOBJECT || cf == cf_EMBEDSOURCE) && _pOleObj) { OleSaveSiteFlags(pmedium->pstg, _dwFlags, _dwUser, _dvaspect); } return S_OK; } } } return E_NOTIMPL; } /* * CDataTransferObj::QueryGetData (pformatetc) * * @mfunc * Queries whether the given format is available in this data object * * @rdesc * HRESULT */ STDMETHODIMP CDataTransferObj::QueryGetData( FORMATETC *pformatetc ) // @parm FETC to look for { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::QueryGetData"); if(IsZombie()) // Check for range zombie return CO_E_RELEASED; DWORD cFETC = _cTotal; while (cFETC--) // Maybe faster to search from start { if( pformatetc->cfFormat == _prgFormats[cFETC].cfFormat && (pformatetc->tymed & _prgFormats[cFETC].tymed) ) { return NOERROR; } } return DV_E_FORMATETC; } /* * CDataTransferObj::SetData (pformatetc, pmedium, fRelease) * * @mfunc * allows data to be set into this data object * * @rdesc * HRESULT = E_FAIL * * @devnote * as we are a data transfer object with a "snapshot" of data, * we do not allow it to be replaced */ STDMETHODIMP CDataTransferObj::SetData( FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::SetData"); return E_FAIL; } /* * CDataTransferObj::OnPreReplaceRange (cp, cchDel, cchNew, cpFormatMin, * cpFormatMax) * * @mfunc implementation of ITxNotify::OnPreReplaceRange * called before changes are made to the backing store */ void CDataTransferObj::OnPreReplaceRange( LONG cp, //@parm cp of the changes LONG cchDel, //@parm #of chars deleted LONG cchNew, //@parm # of chars added LONG cpFormatMin, //@parm min cp of formatting changes LONG cpFormatMax) //@parm max cp of formatting changes { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::OnPreReplaceRange"); if(CONVERT_TO_PLAIN != cp && CP_INFINITE != cp) { if(cp > _cpMin + _cch) return; // Change beyond our extent if(cp + cchDel < _cpMin) { _cpMin += (cchNew - cchDel); // Change before our extent return; } } // FUTURE (murrays): save only one master format (UTF8 RTF or better // CTxtStory) and generate individual ones in GetData and GetDataHere. _hPlainText = TextToHglobal(_hPlainText, tPlain); _hRtfText = TextToHglobal(_hRtfText, tRtf); if(_ped->GetCharFlags() & ~(fLATIN1 | fSYMBOL)) _hRtfUtf8 = TextToHglobal(_hRtfUtf8, tRtfUtf8); } /* * CDataTransferObj::OnPostReplaceRange(cp, cchDel, cchNew, cpFormatMin, * cpFormatMax) * @mfunc implementation of ITxNotify::OnPostReplaceRange * called after changes are made to the backing store * * @comm we use this method to keep our cp's up-to-date */ void CDataTransferObj::OnPostReplaceRange( LONG cp, //@parm cp of the changes LONG cchDel, //@parm #of chars deleted LONG cchNew, //@parm # of chars added LONG cpFormatMin, //@parm min cp of formatting changes LONG cpFormatMax) //@parm max cp of formatting changes { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::OnPostReplaceRange"); // Nothing to do return; } /* * CDataTransferObj::Zombie () * * @mfunc * Turn this object into a zombie */ void CDataTransferObj::Zombie () { TRACEBEGIN(TRCSUBSYSOLE, TRCSCOPEEXTERN, "CDataTransferObj::Zombie"); _ped = NULL; } /* * CDataTransferObj::Create(ped, prg, lStreamFormat) * * @mfunc * static function to create CDataTransferObj. Used to force users * not to create this object on the stack, which would break OLE's * liveness rules. * * @rdesc * new CDataTransferObj * */ CDataTransferObj *CDataTransferObj::Create( CTxtEdit *ped, // @parm ped to which this DataObject belongs CTxtRange *prg, // @parm range for the data object LONG lStreamFormat) // @parm stream format to use in Rtf conversion { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::Create"); Assert(CFETC == ARRAY_SIZE(g_rgFETC) && CFETC == ARRAY_SIZE(g_rgDOI)); LONG ch; CNotifyMgr * pnm; CDataTransferObj *pdo = new CDataTransferObj(ped); if( !pdo ) { ped->GetCallMgr()->SetOutOfMemory(); return NULL; } LONG cpMin, cpMost; pdo->_cch = prg->GetRange(cpMin, cpMost); pdo->_cpMin = cpMin; pdo->_lStreamFormat = lStreamFormat; pnm = ped->GetNotifyMgr(); if(pnm) pnm->Add( (ITxNotify *) pdo ); //Set the object count. pdo->_cObjs = 0; if( ped->HasObjects() ) pdo->_cObjs = ped->_pobjmgr->CountObjectsInRange(cpMin, cpMost); int cTotal = !ped->IsRich() ? 2 : (ped->GetCharFlags() & ~(fLATIN1 | fSYMBOL)) ? 7 : 5; int cExtraFmtEtc = 0; COleObject *pobj = NULL; FORMATETC rgfetc[255]; BOOL bValidOleObj = FALSE; // We only support 2 formats in the play text case if ( !ped->IsRich() ) { pdo->_cTotal = cTotal; pdo->_prgFormats = new FORMATETC[cTotal]; if (!pdo->_prgFormats) goto ErrorExit; // Plain-text case pdo->_prgFormats[0] = g_rgFETC[iAnsiFETC]; pdo->_prgFormats[1] = g_rgFETC[iUnicodeFETC]; return pdo; } // We need to count the number of supported formats if (ped->HasObjects() && pdo->_cch == 1 && prg->GetChar(&ch) == NOERROR && ch == WCH_EMBEDDING) { pobj = ped->_pobjmgr->GetObjectFromCp(pdo->_cpMin); pdo->_dwFlags = pobj->GetFlags(); pdo->_dwUser = pobj->GetUser(); pdo->_dvaspect =pobj->GetAspect(); IUnknown * punk = pobj->GetIUnknown(); // We want to query IOleObject on which formats it supports. And add that to the // FORMATETC array. if (punk && punk->QueryInterface(IID_IOleObject,(void **) &pdo->_pOleObj) == NOERROR) { bValidOleObj = TRUE; // Include the formats supported by the object IDataObject * pdataobj = NULL; if (FAILED(pdo->_pOleObj->GetClipboardData(0, &pdataobj)) || pdataobj == NULL) pdo->_pOleObj->QueryInterface(IID_IDataObject, (void**) &pdataobj); if (pdataobj) { IEnumFORMATETC *pifetc = NULL; // 1.0 didn't check the return value of EnumFormatEtc. This is important because ccMail // will return an OLE error although it actually succeeds in setting the formatetc if ((SUCCEEDED(pdataobj->EnumFormatEtc( DATADIR_GET, &pifetc)) || ped->Get10Mode()) && pifetc) { AssertSz(pifetc, "IEnumFormatEtc is NULL"); // Copy the formats which are supported by the object while((pifetc->Next(1, &rgfetc[cExtraFmtEtc], NULL)) == S_OK && cExtraFmtEtc < 255) cExtraFmtEtc++; pifetc->Release(); } pdataobj->Release(); } } } pdo->_cTotal = cTotal + cExtraFmtEtc; pdo->_prgFormats = new FORMATETC[pdo->_cTotal]; if (!pdo->_prgFormats) goto ErrorExit; if (pobj) { // copy over formats supported by the object itself if (cExtraFmtEtc) memcpy(pdo->_prgFormats, rgfetc, cExtraFmtEtc * sizeof(FORMATETC)); // copy formats supported by Richedit as a container // Have an OLE object: offer all OLE formats plus RTF pdo->_prgFormats[cExtraFmtEtc++] = g_rgFETC[iEmbObj]; // EmbeddedObject pdo->_prgFormats[cExtraFmtEtc++] = g_rgFETC[iObtDesc]; // ObjectDescriptor pdo->_prgFormats[cExtraFmtEtc++] = g_rgFETC[iMfPict]; // Metafile pdo->_prgFormats[cExtraFmtEtc++] = g_rgFETC[iRtfFETC]; // RTF pdo->_prgFormats[cExtraFmtEtc++] = g_rgFETC[iRtfNoObjs]; // RTF with no objects } else { // Regular rich-text case pdo->_prgFormats[0] = g_rgFETC[iRtfFETC]; // RTF pdo->_prgFormats[1] = g_rgFETC[iRtfNoObjs]; // RTF with no objects pdo->_prgFormats[2] = g_rgFETC[iRtfAsTextFETC]; // RTF as Text pdo->_prgFormats[3] = g_rgFETC[iAnsiFETC]; // ANSI plain text pdo->_prgFormats[4] = g_rgFETC[iUnicodeFETC]; // Unicode plain text cExtraFmtEtc = 5; } // We only offer up the six formats that we know how to handle in GetData. // The actual values differ somewhat from regular rich text and text // with embedded objects if (cTotal == 7) { pdo->_prgFormats[cExtraFmtEtc++] = g_rgFETC[iRtfUtf8]; // RTF in UTF-8 pdo->_prgFormats[cExtraFmtEtc++] = g_rgFETC[iRtfNCRforNonASCII]; } // Get the embedded object formats now if (bValidOleObj) { SIZEL sizel; pobj->GetSizel(sizel); pdo->_hObjDesc = pdo->GetDataForObjectDescriptor( pdo->_pOleObj, pobj->GetDvaspect(), &sizel); pdo->_pObjStg = pdo->GetDataForEmbeddedObject( pdo->_pOleObj, NULL ); pdo->_hMFPict = (HMETAFILE) OleStdGetMetafilePictFromOleObject( pdo->_pOleObj, pobj->GetDvaspect(), NULL, NULL); } return pdo; ErrorExit: pdo->_cTotal = 0; pdo->Release(); ped->GetCallMgr()->SetOutOfMemory(); return NULL; } /* * CDataTransferObj::TextToHglobal(hText, tKind) * * @mfunc * Instantiates text on demand for the data object. * * @rdesc * HGLOBAL */ HGLOBAL CDataTransferObj::TextToHglobal( HGLOBAL &hText, TEXTKIND tKind) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::PlainTextToHglobal"); if (hText == NULL) { CTxtRange rg(_ped, _cpMin, -_cch); if (tKind == tPlain) { hText = _ped->GetDTE()->UnicodePlainTextFromRange(&rg); } else if(_ped->IsRich()) { LONG lStreamFormat = _lStreamFormat; if(tKind == tRtfUtf8) lStreamFormat = LOWORD(lStreamFormat) | SF_USECODEPAGE | (CP_UTF8 << 16); else if(tKind == tRtfNCRforNonASCII) lStreamFormat |= SF_NCRFORNONASCII; hText = _ped->GetDTE()->RtfFromRange(&rg, lStreamFormat); } } return hText; } // // CDataTransferObj PRIVATE methods // /* * CDataTransferObj::CDataTransferObj() * * @mfunc * Private constructor */ CDataTransferObj::CDataTransferObj( CTxtEdit *ped ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::CDataTransferObj"); _ped = ped; _crefs = 1; _cTotal = CFETC; _prgFormats = g_rgFETC; _cch = 0; _cObjs = 0; } /* * CDataTransferObj::~CDataTransferObj * * @mfunc * Private destructor */ CDataTransferObj::~CDataTransferObj() { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CDataTransferObj::~CDataTransferObj"); // No need to monitor notifications any more CNotifyMgr *pnm; if(_ped) { pnm = _ped->GetNotifyMgr(); if(pnm) pnm->Remove( (ITxNotify *)this ); } if( _prgFormats && _prgFormats != g_rgFETC) delete _prgFormats; if (_pOleObj) _pOleObj->Release(); if (_pObjStg) _pObjStg->Release(); #ifndef NOMETAFILES if (_hMFPict) (void) DeleteMetaFile(_hMFPict); #endif GlobalFree(_hObjDesc); } // // CEnumFormatEtc PUBLIC methods // /* * CEnumFormatEtc::QueryInterface (riid, ppvObj) * * @mfunc * IUnknown method * * @rdesc * HRESULT */ STDMETHODIMP CEnumFormatEtc::QueryInterface( REFIID riid, // @parm Reference to requested interface ID void ** ppv) // @parm out parm for interface ptr { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::QueryInterface"); HRESULT hresult = E_NOINTERFACE; *ppv = NULL; if( IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IEnumFORMATETC) ) { *ppv = this; AddRef(); hresult = NOERROR; } return hresult; } /* * CEnumFormatEtc::AddRef() * * @mfunc * IUnknown method * * @rdesc * ULONG - incremented reference count */ STDMETHODIMP_(ULONG) CEnumFormatEtc::AddRef( ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::AddRef"); return ++_crefs; } /* * CEnumFormatEtc::Release() * * @mfunc * IUnknown method * * @rdesc * ULONG - decremented reference count */ STDMETHODIMP_(ULONG) CEnumFormatEtc::Release( ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::Release"); _crefs--; if( _crefs == 0 ) { delete this; return 0; } return _crefs; } /* * CEnumFormatEtc::Next (celt, rgelt, pceltFetched) * * @mfunc * fetches the next [celt] elements in our formatetc collection * * @rdesc * HRESULT */ STDMETHODIMP CEnumFormatEtc::Next( ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::Next"); HRESULT hresult = NOERROR; ULONG cFetched; if( pceltFetched == NULL && celt != 1 ) { // the spec says that if pceltFetched == NULL, then // the count of elements to fetch must be 1 return E_INVALIDARG; } // we can only grab as many elements as there are left if( celt > _cTotal - _iCurrent ) { cFetched = _cTotal - _iCurrent; hresult = S_FALSE; } else cFetched = celt; // Only copy if we have elements to copy if( cFetched > 0 ) { memcpy( rgelt, _prgFormats + _iCurrent, cFetched * sizeof(FORMATETC) ); } _iCurrent += cFetched; if( pceltFetched ) *pceltFetched = cFetched; return hresult; } /* * CEnumFormatEtc::Skip * * @mfunc * skips the next [celt] formats * * @rdesc * HRESULT */ STDMETHODIMP CEnumFormatEtc::Skip( ULONG celt ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::Skip"); HRESULT hresult = NOERROR; _iCurrent += celt; if( _iCurrent > _cTotal ) { // whoops, skipped too far ahead. Set us to the max limit. _iCurrent = _cTotal; hresult = S_FALSE; } return hresult; } /* * CEnumFormatEtc::Reset * * @mfunc * resets the seek pointer to zero * * @rdesc * HRESULT */ STDMETHODIMP CEnumFormatEtc::Reset( void ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::Reset"); _iCurrent = 0; return NOERROR; } /* * CEnumFormatEtc::Clone * * @mfunc * clones the enumerator * * @rdesc * HRESULT */ STDMETHODIMP CEnumFormatEtc::Clone( IEnumFORMATETC **ppIEnum ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::Clone"); return CEnumFormatEtc::Create(_prgFormats, _cTotal, ppIEnum); } /* * CEnumFormatEtc::Create (prgFormats, cTotal, hr) * * @mfunc * creates a new format enumerator * * @rdesc * HRESULT * * @devnote * *copies* the formats passed in. We do this as it simplifies * memory management under OLE object liveness rules */ HRESULT CEnumFormatEtc::Create( FORMATETC *prgFormats, ULONG cTotal, IEnumFORMATETC **ppenum ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::Create"); CEnumFormatEtc *penum = new CEnumFormatEtc(); if(penum) { // _iCurrent, _crefs are set in the constructor if( cTotal > 0 ) { penum->_prgFormats = new FORMATETC[cTotal]; if( penum->_prgFormats ) { penum->_cTotal = cTotal; memcpy(penum->_prgFormats, prgFormats, cTotal * sizeof(FORMATETC)); *ppenum = penum; return NOERROR; } } delete penum; } return E_OUTOFMEMORY; } // // CEnumFormatEtc PRIVATE methods // /* * CEnumFormatEtc::CEnumFormatEtc() * * @mfunc * Private constructor */ CEnumFormatEtc::CEnumFormatEtc() { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::CEnumFormatEtc"); _cTotal = 0; _crefs = 1; _prgFormats = NULL; _iCurrent = 0; } /* * CEnumFormatEtc::~CEnumFormatEtc() * * @mfunc * Private destructor */ CEnumFormatEtc::~CEnumFormatEtc( void ) { TRACEBEGIN(TRCSUBSYSDTE, TRCSCOPEINTERN, "CEnumFormatEtc::~CEnumFormatEtc"); if( _prgFormats ) delete _prgFormats; }