// =========================================================================== // File: M F C U I . C P P // // Copyright 1995 Microsoft Corporation. All Rights Reserved. // Microsoft Confidential // =========================================================================== #ifndef UNICODE // %%Includes: --------------------------------------------------------------- #include #include #include // %%Prototypes: ------------------------------------------------------------- STDAPI Ole2AnsiWFromA(REFIID riid, LPUNKNOWN punkWrappeeA, LPUNKNOWN *ppunkWrapperW); STDAPI Ole2AnsiAFromW(REFIID riid, LPUNKNOWN punkWrappeeW, LPUNKNOWN *ppunkWrapperA); // --------------------------------------------------------------------------- // %%Function: OleUIAddVerbMenu %%Reviewed: 00/00/95 // // Description: // Wraps OleUIAddVerbMenu to OLEDLG.DLL for MFC clients, which expect to be // able to pass Ansi IOleObject's. // --------------------------------------------------------------------------- #undef OleUIAddVerbMenu // overrides the Ansi/Unicode macros in OLEDLG.H STDAPI_(BOOL) OleUIAddVerbMenu(LPOLEOBJECT lpOleObjA, LPCSTR lpszShortType, HMENU hMenu, UINT uPos, UINT uIDVerbMin, UINT uIDVerbMax, BOOL bAddConvert, UINT idConvert, HMENU FAR *lphMenu) { LPOLEOBJECT lpOleObjW = NULL; BOOL fResult = FALSE; // allow NULL IOleObject (OleUIAddVerbMenuA handles this by making an empty menu), but // otherwise wrap the Ansi IOleObject to Unicode. if (lpOleObjA == NULL || SUCCEEDED(Ole2AnsiWFromA(IID_IOleObject, (LPUNKNOWN)lpOleObjA, (LPUNKNOWN *)&lpOleObjW))) { fResult = OleUIAddVerbMenuA(lpOleObjW, lpszShortType, hMenu, uPos, uIDVerbMin, uIDVerbMax, bAddConvert, idConvert, lphMenu); // release the Unicode IOleObject if it was created if (lpOleObjW != NULL) lpOleObjW->Release(); } return fResult; } // OleUIAddVerbMenu // --------------------------------------------------------------------------- // %%Function: OleUIInsertObject %%Reviewed: 00/00/95 // // Description: // Wraps OleUIInsertObject to OLEDLG.DLL for MFC clients, which expect to be // able to pass Ansi IOleClientSite and IStorage in and receive Ansi interfaces // out in ppvObj. // --------------------------------------------------------------------------- #undef OleUIInsertObject // overrides the Ansi/Unicode macros in OLEDLG.H STDAPI_(UINT) OleUIInsertObject(LPOLEUIINSERTOBJECTA lpio) { LPOLECLIENTSITE lpIOleClientSiteA = NULL; LPSTORAGE lpIStorageA = NULL; LPVOID FAR *ppvObjA; LPUNKNOWN punkObjW = NULL; BOOL fCreatingObject; UINT wResult; HRESULT hr = S_OK; // validate the structure superficially: let the actual function do most of the validation if (!lpio) return OLEUI_ERR_STRUCTURENULL; if (IsBadReadPtr(lpio, sizeof(LPOLEUIINSERTOBJECTA)) || IsBadWritePtr(lpio, sizeof(LPOLEUIINSERTOBJECTA))) return OLEUI_ERR_STRUCTUREINVALID; if (lpio->cbStruct < sizeof(LPOLEUIINSERTOBJECTA)) return OLEUI_ERR_CBSTRUCTINCORRECT; if (fCreatingObject = (lpio->dwFlags & (IOF_CREATENEWOBJECT | IOF_CREATEFILEOBJECT | IOF_CREATELINKOBJECT))) { // verify these parameters, otherwise cleanup becomes complicated if (IsBadWritePtr(lpio->ppvObj, sizeof(LPUNKNOWN))) return OLEUI_IOERR_PPVOBJINVALID; if (lpio->lpIOleClientSite != NULL && IsBadReadPtr(lpio->lpIOleClientSite, sizeof(IOleClientSite))) return OLEUI_IOERR_LPIOLECLIENTSITEINVALID; if (lpio->lpIStorage != NULL && IsBadReadPtr(lpio->lpIStorage, sizeof(IStorage))) return OLEUI_IOERR_LPISTORAGEINVALID; // save away the Ansi IOleClientSite, stuff in our Unicode one. // if it's NULL, OleUIInsertObjectA() will handle the error appropriately and we'll clean up correctly, below. if (lpIOleClientSiteA = lpio->lpIOleClientSite) { hr = Ole2AnsiWFromA(IID_IOleClientSite, (LPUNKNOWN)lpIOleClientSiteA, (LPUNKNOWN *)&lpio->lpIOleClientSite); if (FAILED(hr)) { lpio->lpIOleClientSite = lpIOleClientSiteA; lpio->sc = hr; return OLEUI_IOERR_SCODEHASERROR; } } // save away the Ansi IStorage, stuff in our Unicode one. // if it's NULL, OleUIInsertObjectA() will handle the error appropriately and we'll clean up correctly, below. if (lpIStorageA = lpio->lpIStorage) { hr = Ole2AnsiWFromA(IID_IStorage, (LPUNKNOWN)lpIStorageA, (LPUNKNOWN *)&lpio->lpIStorage); if (FAILED(hr)) { // make sure to free the Unicode IOleClientSite which we converted above. if (lpio->lpIOleClientSite) { lpio->lpIOleClientSite->Release(); lpio->lpIOleClientSite = lpIOleClientSiteA; } lpio->lpIStorage = lpIStorageA; lpio->sc = hr; return OLEUI_IOERR_SCODEHASERROR; } } // save the current Ansi ppvObj, stuff in our Unicode one ppvObjA = lpio->ppvObj; lpio->ppvObj = (LPVOID FAR *)&punkObjW; } wResult = OleUIInsertObjectA(lpio); // regardless of success or failure of the above call, we have to clean up the wrapping we did if (fCreatingObject) { // return the Ansi versions of the IOleClientSite and IStorage to // the structure, and release the Unicode ones if (lpio->lpIOleClientSite) { lpio->lpIOleClientSite->Release(); lpio->lpIOleClientSite = lpIOleClientSiteA; } if (lpio->lpIStorage) { lpio->lpIStorage->Release(); lpio->lpIStorage = lpIStorageA; } // return the Ansi object pointer to the structure lpio->ppvObj = ppvObjA; // convert if (punkObjW != NULL) { HRESULT hr; // if we were creating an object and we succeeded, punkObjW must be valid and contain an interface // of type iid. if not, there is a problem in OleUIInsertObjectA(), not in this code. we could assert // here if this code wanted to, but wouldn't be able to properly circumvent the error anyway. if (FAILED(hr = Ole2AnsiAFromW(lpio->iid, (LPUNKNOWN)punkObjW, (LPUNKNOWN *)ppvObjA))) { lpio->sc = hr; } punkObjW->Release(); if (lpio->sc != S_OK) return OLEUI_IOERR_SCODEHASERROR; } } return wResult; } // OleUIInsertObject // --------------------------------------------------------------------------- // %%Function: OleUIPasteSpecial %%Reviewed: 00/00/95 // // Description: // Wraps OleUIPasteSpecial to OLEDLG.DLL for MFC clients, which expect to be // able to pass in and get back Ansi IDataObject's. // --------------------------------------------------------------------------- #undef OleUIPasteSpecial // overrides the Ansi/Unicode macros in OLEDLG.H STDAPI_(UINT) OleUIPasteSpecial(LPOLEUIPASTESPECIALA lpps) { LPDATAOBJECT lpSrcDataObjA; UINT wResult; // validate the structure superficially: let the actual function do most of the validation if (!lpps) return OLEUI_ERR_STRUCTURENULL; if (IsBadReadPtr(lpps, sizeof(LPOLEUIPASTESPECIALA)) || IsBadWritePtr(lpps, sizeof(LPOLEUIPASTESPECIALA))) return OLEUI_ERR_STRUCTUREINVALID; if (lpps->cbStruct < sizeof(LPOLEUIPASTESPECIALA)) return OLEUI_ERR_CBSTRUCTINCORRECT; if (NULL != lpps->lpSrcDataObj && IsBadReadPtr(lpps->lpSrcDataObj, sizeof(IDataObject))) return OLEUI_IOERR_SRCDATAOBJECTINVALID; if (!(lpSrcDataObjA = lpps->lpSrcDataObj) || SUCCEEDED(Ole2AnsiWFromA(IID_IDataObject, (LPUNKNOWN)lpSrcDataObjA, (LPUNKNOWN *)&lpps->lpSrcDataObj))) { wResult = OleUIPasteSpecialA(lpps); // if we had an Ansi IDataObject on entry, put it back and release the Unicode wrapper. if (lpSrcDataObjA != NULL) { lpps->lpSrcDataObj->Release(); lpps->lpSrcDataObj = lpSrcDataObjA; } // otherwise check to see if OleUIPasteSpecialA() placed a Unicode IDataObject into our structure. // if it did, wrap it to make sure an Ansi one gets sent back out. else if (lpps->lpSrcDataObj != NULL) { if (FAILED(Ole2AnsiAFromW(IID_IDataObject, (LPUNKNOWN)lpps->lpSrcDataObj, (LPUNKNOWN *)&lpSrcDataObjA))) { lpps->lpSrcDataObj->Release(); lpps->lpSrcDataObj = NULL; return OLEUI_PSERR_GETCLIPBOARDFAILED; // well, that's pretty much what happened, after all } lpps->lpSrcDataObj->Release(); lpps->lpSrcDataObj = lpSrcDataObjA; } } return wResult; } // OleUIPasteSpecial #endif // !UNICODE // EOF =======================================================================