diff options
Diffstat (limited to 'oox/source/ole/olehelper.cxx')
| -rw-r--r-- | oox/source/ole/olehelper.cxx | 572 |
1 files changed, 572 insertions, 0 deletions
diff --git a/oox/source/ole/olehelper.cxx b/oox/source/ole/olehelper.cxx new file mode 100644 index 0000000000..d953cf17f9 --- /dev/null +++ b/oox/source/ole/olehelper.cxx @@ -0,0 +1,572 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <oox/ole/olehelper.hxx> + +#include <rtl/ustrbuf.hxx> +#include <sot/storage.hxx> +#include <osl/diagnose.h> +#include <oox/helper/binaryinputstream.hxx> +#include <oox/helper/binaryoutputstream.hxx> +#include <oox/helper/graphichelper.hxx> +#include <oox/token/properties.hxx> +#include <oox/token/tokens.hxx> +#include <oox/ole/axcontrol.hxx> +#include <oox/helper/propertymap.hxx> +#include <oox/helper/propertyset.hxx> + +#include <com/sun/star/awt/XControlModel.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/form/XFormComponent.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/awt/Size.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> + +#include <tools/globname.hxx> +#include <unotools/streamwrap.hxx> +#include <comphelper/processfactory.hxx> +#include <utility> + +namespace oox::ole { + +using ::com::sun::star::form::XFormComponent; +using ::com::sun::star::awt::XControlModel; +using ::com::sun::star::awt::Size; +using ::com::sun::star::frame::XModel; +using ::com::sun::star::io::XOutputStream; +using ::com::sun::star::io::XInputStream; +using ::com::sun::star::beans::XPropertySet; +using ::com::sun::star::uno::Reference; +using ::com::sun::star::uno::UNO_QUERY; +using ::com::sun::star::uno::XComponentContext; +using ::com::sun::star::lang::XServiceInfo; + +using namespace ::com::sun::star::form; + +namespace { + +const sal_uInt32 OLE_COLORTYPE_MASK = 0xFF000000; +const sal_uInt32 OLE_COLORTYPE_CLIENT = 0x00000000; +const sal_uInt32 OLE_COLORTYPE_PALETTE = 0x01000000; +const sal_uInt32 OLE_COLORTYPE_BGR = 0x02000000; +const sal_uInt32 OLE_COLORTYPE_SYSCOLOR = 0x80000000; + +const sal_uInt32 OLE_PALETTECOLOR_MASK = 0x0000FFFF; +const sal_uInt32 OLE_SYSTEMCOLOR_MASK = 0x0000FFFF; + +/** Swaps the red and blue component of the passed color. */ +sal_uInt32 lclSwapRedBlue( sal_uInt32 nColor ) +{ + return static_cast< sal_uInt32 >( (nColor & 0xFF00FF00) | ((nColor & 0x0000FF) << 16) | ((nColor & 0xFF0000) >> 16) ); +} + +/** Returns the UNO RGB color from the passed encoded OLE BGR color. */ +::Color lclDecodeBgrColor( sal_uInt32 nOleColor ) +{ + return ::Color( ColorTransparency, lclSwapRedBlue( nOleColor ) & 0xFFFFFF ); +} + +const sal_uInt32 OLE_STDPIC_ID = 0x0000746C; + +struct GUIDCNamePair +{ + const char* sGUID; + const char* sName; +}; + +struct IdCntrlData +{ + sal_Int16 nId; + GUIDCNamePair aData; +}; + +const sal_Int16 TOGGLEBUTTON = -1; +const sal_Int16 FORMULAFIELD = -2; + +typedef std::map< sal_Int16, GUIDCNamePair > GUIDCNamePairMap; +class classIdToGUIDCNamePairMap +{ + GUIDCNamePairMap mnIdToGUIDCNamePairMap; + classIdToGUIDCNamePairMap(); +public: + static GUIDCNamePairMap& get(); +}; + +classIdToGUIDCNamePairMap::classIdToGUIDCNamePairMap() +{ + static IdCntrlData const initialCntrlData[] = + { + // Command button MUST be at index 0 + { FormComponentType::COMMANDBUTTON, + { AX_GUID_COMMANDBUTTON, "CommandButton"} , + }, + // Toggle button MUST be at index 1 + { TOGGLEBUTTON, + { AX_GUID_TOGGLEBUTTON, "ToggleButton"}, + }, + { FormComponentType::FIXEDTEXT, + { AX_GUID_LABEL, "Label"}, + }, + { FormComponentType::TEXTFIELD, + { AX_GUID_TEXTBOX, "TextBox"}, + }, + { FormComponentType::LISTBOX, + { AX_GUID_LISTBOX, "ListBox"}, + }, + { FormComponentType::COMBOBOX, + { AX_GUID_COMBOBOX, "ComboBox"}, + }, + { FormComponentType::CHECKBOX, + { AX_GUID_CHECKBOX, "CheckBox"}, + }, + { FormComponentType::RADIOBUTTON, + { AX_GUID_OPTIONBUTTON, "OptionButton"}, + }, + { FormComponentType::IMAGECONTROL, + { AX_GUID_IMAGE, "Image"}, + }, + { FormComponentType::DATEFIELD, + { AX_GUID_TEXTBOX, "TextBox"}, + }, + { FormComponentType::TIMEFIELD, + { AX_GUID_TEXTBOX, "TextBox"}, + }, + { FormComponentType::NUMERICFIELD, + { AX_GUID_TEXTBOX, "TextBox"}, + }, + { FormComponentType::CURRENCYFIELD, + { AX_GUID_TEXTBOX, "TextBox"}, + }, + { FormComponentType::PATTERNFIELD, + { AX_GUID_TEXTBOX, "TextBox"}, + }, + { FORMULAFIELD, + { AX_GUID_TEXTBOX, "TextBox"}, + }, + { FormComponentType::IMAGEBUTTON, + { AX_GUID_COMMANDBUTTON, "CommandButton"}, + }, + { FormComponentType::SPINBUTTON, + { AX_GUID_SPINBUTTON, "SpinButton"}, + }, + { FormComponentType::SCROLLBAR, + { AX_GUID_SCROLLBAR, "ScrollBar"}, + } + }; + int const length = std::size( initialCntrlData ); + IdCntrlData const * pData = initialCntrlData; + for ( int index = 0; index < length; ++index, ++pData ) + mnIdToGUIDCNamePairMap[ pData->nId ] = pData->aData; +}; + +GUIDCNamePairMap& classIdToGUIDCNamePairMap::get() +{ + static classIdToGUIDCNamePairMap theInst; + return theInst.mnIdToGUIDCNamePairMap; +} + +template< typename Type > +void lclAppendHex( OUStringBuffer& orBuffer, Type nValue ) +{ + const sal_Int32 nWidth = 2 * sizeof( Type ); + static const sal_Unicode spcHexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + orBuffer.setLength( orBuffer.getLength() + nWidth ); + for( sal_Int32 nCharIdx = orBuffer.getLength() - 1, nCharEnd = nCharIdx - nWidth; nCharIdx > nCharEnd; --nCharIdx, nValue >>= 4 ) + orBuffer[nCharIdx] = spcHexChars[ nValue & 0xF ]; +} + +} // namespace + +StdFontInfo::StdFontInfo() : + mnHeight( 0 ), + mnWeight( OLE_STDFONT_NORMAL ), + mnCharSet( WINDOWS_CHARSET_ANSI ), + mnFlags( 0 ) +{ +} + +StdFontInfo::StdFontInfo( OUString aName, sal_uInt32 nHeight ) : + maName(std::move( aName )), + mnHeight( nHeight ), + mnWeight( OLE_STDFONT_NORMAL ), + mnCharSet( WINDOWS_CHARSET_ANSI ), + mnFlags( 0 ) +{ +} + +::Color OleHelper::decodeOleColor( + const GraphicHelper& rGraphicHelper, sal_uInt32 nOleColor, bool bDefaultColorBgr ) +{ + static const sal_Int32 spnSystemColors[] = + { + XML_scrollBar, XML_background, XML_activeCaption, XML_inactiveCaption, + XML_menu, XML_window, XML_windowFrame, XML_menuText, + XML_windowText, XML_captionText, XML_activeBorder, XML_inactiveBorder, + XML_appWorkspace, XML_highlight, XML_highlightText, XML_btnFace, + XML_btnShadow, XML_grayText, XML_btnText, XML_inactiveCaptionText, + XML_btnHighlight, XML_3dDkShadow, XML_3dLight, XML_infoText, + XML_infoBk + }; + + switch( nOleColor & OLE_COLORTYPE_MASK ) + { + case OLE_COLORTYPE_CLIENT: + return bDefaultColorBgr ? lclDecodeBgrColor( nOleColor ) : rGraphicHelper.getPaletteColor( nOleColor & OLE_PALETTECOLOR_MASK ); + + case OLE_COLORTYPE_PALETTE: + return rGraphicHelper.getPaletteColor( nOleColor & OLE_PALETTECOLOR_MASK ); + + case OLE_COLORTYPE_BGR: + return lclDecodeBgrColor( nOleColor ); + + case OLE_COLORTYPE_SYSCOLOR: + return rGraphicHelper.getSystemColor( STATIC_ARRAY_SELECT( spnSystemColors, nOleColor & OLE_SYSTEMCOLOR_MASK, XML_TOKEN_INVALID ), API_RGB_WHITE ); + } + OSL_FAIL( "OleHelper::decodeOleColor - unknown color type" ); + return API_RGB_BLACK; +} + +sal_uInt32 OleHelper::encodeOleColor( sal_Int32 nRgbColor ) +{ + return OLE_COLORTYPE_BGR | lclSwapRedBlue( static_cast< sal_uInt32 >( nRgbColor & 0xFFFFFF ) ); +} + +void OleHelper::exportGuid( BinaryOutputStream& rOStr, const SvGlobalName& rId ) +{ + rOStr.WriteUInt32( rId.GetCLSID().Data1 ); + rOStr.WriteUInt16( rId.GetCLSID().Data2 ); + rOStr.WriteUInt16( rId.GetCLSID().Data3 ); + rOStr.writeArray( rId.GetCLSID().Data4, 8 ); +} + +OUString OleHelper::importGuid( BinaryInputStream& rInStrm ) +{ + OUStringBuffer aBuffer(40); + aBuffer.append( '{' ); + lclAppendHex( aBuffer, rInStrm.readuInt32() ); + aBuffer.append( '-' ); + lclAppendHex( aBuffer, rInStrm.readuInt16() ); + aBuffer.append( '-' ); + lclAppendHex( aBuffer, rInStrm.readuInt16() ); + aBuffer.append( '-' ); + lclAppendHex( aBuffer, rInStrm.readuInt8() ); + lclAppendHex( aBuffer, rInStrm.readuInt8() ); + aBuffer.append( '-' ); + for( int nIndex = 0; nIndex < 6; ++nIndex ) + lclAppendHex( aBuffer, rInStrm.readuInt8() ); + aBuffer.append( '}' ); + return aBuffer.makeStringAndClear(); +} + +bool OleHelper::importStdFont( StdFontInfo& orFontInfo, BinaryInputStream& rInStrm, bool bWithGuid ) +{ + if( bWithGuid ) + { + bool bIsStdFont = importGuid( rInStrm ) == OLE_GUID_STDFONT; + OSL_ENSURE( bIsStdFont, "OleHelper::importStdFont - unexpected header GUID, expected StdFont" ); + if( !bIsStdFont ) + return false; + } + + sal_uInt8 nVersion, nNameLen; + nVersion = rInStrm.readuChar(); + orFontInfo.mnCharSet = rInStrm.readuInt16(); + orFontInfo.mnFlags = rInStrm.readuChar(); + orFontInfo.mnWeight = rInStrm.readuInt16(); + orFontInfo.mnHeight = rInStrm.readuInt32(); + nNameLen = rInStrm.readuChar(); + // according to spec the name is ASCII + orFontInfo.maName = rInStrm.readCharArrayUC( nNameLen, RTL_TEXTENCODING_ASCII_US ); + OSL_ENSURE( nVersion <= 1, "OleHelper::importStdFont - wrong version" ); + return !rInStrm.isEof() && (nVersion <= 1); +} + +bool OleHelper::importStdPic( StreamDataSequence& orGraphicData, BinaryInputStream& rInStrm ) +{ + bool bIsStdPic = importGuid( rInStrm ) == OLE_GUID_STDPIC; + OSL_ENSURE( bIsStdPic, "OleHelper::importStdPic - unexpected header GUID, expected StdPic" ); + if( !bIsStdPic ) + return false; + + sal_uInt32 nStdPicId; + sal_Int32 nBytes; + nStdPicId = rInStrm.readuInt32(); + nBytes = rInStrm.readInt32(); + OSL_ENSURE( nStdPicId == OLE_STDPIC_ID, "OleHelper::importStdPic - unexpected header version" ); + return !rInStrm.isEof() && (nStdPicId == OLE_STDPIC_ID) && (nBytes > 0) && (rInStrm.readData( orGraphicData, nBytes ) == nBytes); +} + +static Reference< css::frame::XFrame > lcl_getFrame( const Reference< css::frame::XModel >& rxModel ) +{ + Reference< css::frame::XFrame > xFrame; + if ( rxModel.is() ) + { + Reference< css::frame::XController > xController = rxModel->getCurrentController(); + xFrame = xController.is() ? xController->getFrame() : nullptr; + } + return xFrame; +} + +OleFormCtrlExportHelper::OleFormCtrlExportHelper( const Reference< XComponentContext >& rxCtx, const Reference< XModel >& rxDocModel, const Reference< XControlModel >& xCntrlModel ) : mpModel( nullptr ), maGrfHelper( rxCtx, lcl_getFrame( rxDocModel ), StorageRef() ), mxDocModel( rxDocModel ), mxControlModel( xCntrlModel ) +{ + // try to get the guid + Reference< css::beans::XPropertySet > xProps( xCntrlModel, UNO_QUERY ); + if ( !xProps.is() ) + return; + + sal_Int16 nClassId = 0; + PropertySet aPropSet( mxControlModel ); + if ( !aPropSet.getProperty( nClassId, PROP_ClassId ) ) + return; + + /* pseudo ripped from legacy msocximex: + "There is a truly horrible thing with EditControls and FormattedField + Controls, they both pretend to have an EDITBOX ClassId for compatibility + reasons, at some stage in the future hopefully there will be a proper + FormulaField ClassId rather than this piggybacking two controls onto the + same ClassId, cmc." - when fixed the fake FORMULAFIELD id entry + and definition above can be removed/replaced + */ + if ( nClassId == FormComponentType::TEXTFIELD) + { + Reference< XServiceInfo > xInfo( xCntrlModel, + UNO_QUERY); + if (xInfo-> + supportsService( "com.sun.star.form.component.FormattedField" ) ) + nClassId = FORMULAFIELD; + } + else if ( nClassId == FormComponentType::COMMANDBUTTON ) + { + bool bToggle = false; + if ( aPropSet.getProperty( bToggle, PROP_Toggle ) && bToggle ) + nClassId = TOGGLEBUTTON; + } + else if ( nClassId == FormComponentType::CONTROL ) + { + Reference< XServiceInfo > xInfo( xCntrlModel, + UNO_QUERY); + if (xInfo->supportsService("com.sun.star.form.component.ImageControl" ) ) + nClassId = FormComponentType::IMAGECONTROL; + } + + GUIDCNamePairMap& cntrlMap = classIdToGUIDCNamePairMap::get(); + GUIDCNamePairMap::iterator it = cntrlMap.find( nClassId ); + if ( it != cntrlMap.end() ) + { + aPropSet.getProperty(maName, PROP_Name ); + maTypeName = OUString::createFromAscii( it->second.sName ); + maFullName = "Microsoft Forms 2.0 " + maTypeName; + mpControl.reset(new EmbeddedControl( maName )); + maGUID = OUString::createFromAscii( it->second.sGUID ); + mpModel = mpControl->createModelFromGuid( maGUID ); + } +} + +OleFormCtrlExportHelper::~OleFormCtrlExportHelper() +{ +} + +void OleFormCtrlExportHelper::exportName( const Reference< XOutputStream >& rxOut ) +{ + oox::BinaryXOutputStream aOut( rxOut, false ); + aOut.writeUnicodeArray( maName ); + aOut.WriteInt32(0); +} + +void OleFormCtrlExportHelper::exportCompObj( const Reference< XOutputStream >& rxOut ) +{ + oox::BinaryXOutputStream aOut( rxOut, false ); + if ( mpModel ) + mpModel->exportCompObj( aOut ); +} + +void OleFormCtrlExportHelper::exportControl( const Reference< XOutputStream >& rxOut, const Size& rSize, bool bAutoClose ) +{ + oox::BinaryXOutputStream aOut( rxOut, bAutoClose ); + if ( mpModel ) + { + ::oox::ole::ControlConverter aConv( mxDocModel, maGrfHelper ); + if(mpControl) + mpControl->convertFromProperties( mxControlModel, aConv ); + mpModel->maSize.first = rSize.Width; + mpModel->maSize.second = rSize.Height; + mpModel->exportBinaryModel( aOut ); + } +} + +MSConvertOCXControls::MSConvertOCXControls( const Reference< css::frame::XModel >& rxModel ) : SvxMSConvertOCXControls( rxModel ), mxCtx( comphelper::getProcessComponentContext() ), maGrfHelper( mxCtx, lcl_getFrame( rxModel ), StorageRef() ) +{ +} + +MSConvertOCXControls::~MSConvertOCXControls() +{ +} + +bool +MSConvertOCXControls::importControlFromStream( ::oox::BinaryInputStream& rInStrm, Reference< XFormComponent >& rxFormComp, std::u16string_view rGuidString ) +{ + ::oox::ole::EmbeddedControl aControl( "Unknown" ); + if( ::oox::ole::ControlModelBase* pModel = aControl.createModelFromGuid( rGuidString ) ) + { + pModel->importBinaryModel( rInStrm ); + rxFormComp.set( mxCtx->getServiceManager()->createInstanceWithContext( pModel->getServiceName(), mxCtx ), UNO_QUERY ); + Reference< XControlModel > xCtlModel( rxFormComp, UNO_QUERY ); + ::oox::ole::ControlConverter aConv( mxModel, maGrfHelper ); + aControl.convertProperties( xCtlModel, aConv ); + } + return rxFormComp.is(); +} + +bool +MSConvertOCXControls::ReadOCXCtlsStream( tools::SvRef<SotStorageStream> const & rSrc1, Reference< XFormComponent > & rxFormComp, + sal_Int32 nPos, + sal_Int32 nStreamSize) +{ + if ( rSrc1.is() ) + { + BinaryXInputStream aCtlsStrm( Reference< XInputStream >( new utl::OSeekableInputStreamWrapper( *rSrc1 ) ), true ); + aCtlsStrm.seek( nPos ); + OUString aStrmClassId = ::oox::ole::OleHelper::importGuid( aCtlsStrm ); + return importControlFromStream( aCtlsStrm, rxFormComp, aStrmClassId, nStreamSize ); + } + return false; +} + +bool MSConvertOCXControls::importControlFromStream( ::oox::BinaryInputStream& rInStrm, Reference< XFormComponent >& rxFormComp, const OUString& rStrmClassId, + sal_Int32 nStreamSize) +{ + if ( !rInStrm.isEof() ) + { + // Special processing for those html controls + bool bOneOfHtmlControls = false; + if ( rStrmClassId.toAsciiUpperCase() == HTML_GUID_SELECT + || rStrmClassId.toAsciiUpperCase() == HTML_GUID_TEXTBOX ) + bOneOfHtmlControls = true; + + if ( bOneOfHtmlControls ) + { + // html controls don't seem have a handy record length following the GUID + // in the binary stream. + // Given the control stream length create a stream of nStreamSize bytes starting from + // nPos ( offset by the guid already read in ) + if ( !nStreamSize ) + return false; + const int nGuidSize = 0x10; + StreamDataSequence aDataSeq; + sal_Int32 nBytesToRead = nStreamSize - nGuidSize; + while ( nBytesToRead ) + nBytesToRead -= rInStrm.readData( aDataSeq, nBytesToRead ); + SequenceInputStream aInSeqStream( aDataSeq ); + importControlFromStream( aInSeqStream, rxFormComp, rStrmClassId ); + } + else + { + importControlFromStream( rInStrm, rxFormComp, rStrmClassId ); + } + } + return rxFormComp.is(); +} + +bool MSConvertOCXControls::ReadOCXStorage( tools::SvRef<SotStorage> const & xOleStg, + Reference< XFormComponent > & rxFormComp ) +{ + if ( xOleStg.is() ) + { + tools::SvRef<SotStorageStream> pNameStream = xOleStg->OpenSotStream("\3OCXNAME", StreamMode::READ); + BinaryXInputStream aNameStream( Reference< XInputStream >( new utl::OSeekableInputStreamWrapper( *pNameStream ) ), true ); + + tools::SvRef<SotStorageStream> pContents = xOleStg->OpenSotStream("contents", StreamMode::READ); + BinaryXInputStream aInStrm( Reference< XInputStream >( new utl::OSeekableInputStreamWrapper( *pContents ) ), true ); + + tools::SvRef<SotStorageStream> pClsStrm = xOleStg->OpenSotStream("\1CompObj", StreamMode::READ); + BinaryXInputStream aClsStrm( Reference< XInputStream >( new utl::OSeekableInputStreamWrapper(*pClsStrm ) ), true ); + aClsStrm.skip(12); + + OUString aStrmClassId = ::oox::ole::OleHelper::importGuid( aClsStrm ); + if ( importControlFromStream( aInStrm, rxFormComp, aStrmClassId, aInStrm.size() ) ) + { + OUString aName = aNameStream.readNulUnicodeArray(); + Reference< XControlModel > xCtlModel( rxFormComp, UNO_QUERY ); + if ( !aName.isEmpty() && xCtlModel.is() ) + { + PropertyMap aPropMap; + aPropMap.setProperty( PROP_Name, aName ); + PropertySet aPropSet( xCtlModel ); + aPropSet.setProperties( aPropMap ); + } + return rxFormComp.is(); + } + } + return false; +} + +bool MSConvertOCXControls::WriteOCXExcelKludgeStream( const css::uno::Reference< css::frame::XModel >& rxModel, const css::uno::Reference< css::io::XOutputStream >& xOutStrm, const css::uno::Reference< css::awt::XControlModel > &rxControlModel, const css::awt::Size& rSize,OUString &rName ) +{ + OleFormCtrlExportHelper exportHelper( comphelper::getProcessComponentContext(), rxModel, rxControlModel ); + if ( !exportHelper.isValid() ) + return false; + rName = exportHelper.getTypeName(); + SvGlobalName aName; + aName.MakeId(exportHelper.getGUID()); + BinaryXOutputStream aOut( xOutStrm, false ); + OleHelper::exportGuid( aOut, aName ); + exportHelper.exportControl( xOutStrm, rSize ); + return true; +} + +bool MSConvertOCXControls::WriteOCXStream( const Reference< XModel >& rxModel, tools::SvRef<SotStorage> const &xOleStg, + const Reference< XControlModel > &rxControlModel, + const css::awt::Size& rSize, OUString &rName) +{ + SvGlobalName aName; + + OleFormCtrlExportHelper exportHelper( comphelper::getProcessComponentContext(), rxModel, rxControlModel ); + + if ( !exportHelper.isValid() ) + return false; + + aName.MakeId(exportHelper.getGUID()); + + OUString sFullName = exportHelper.getFullName(); + rName = exportHelper.getTypeName(); + xOleStg->SetClass( aName, SotClipboardFormatId::EMBEDDED_OBJ_OLE, sFullName); + { + tools::SvRef<SotStorageStream> pNameStream = xOleStg->OpenSotStream("\3OCXNAME"); + Reference< XOutputStream > xOut = new utl::OSeekableOutputStreamWrapper( *pNameStream ); + exportHelper.exportName( xOut ); + } + { + tools::SvRef<SotStorageStream> pObjStream = xOleStg->OpenSotStream("\1CompObj"); + Reference< XOutputStream > xOut = new utl::OSeekableOutputStreamWrapper( *pObjStream ); + exportHelper.exportCompObj( xOut ); + } + { + tools::SvRef<SotStorageStream> pContents = xOleStg->OpenSotStream("contents"); + Reference< XOutputStream > xOut = new utl::OSeekableOutputStreamWrapper( *pContents ); + exportHelper.exportControl( xOut, rSize ); + } + return true; +} + +} // namespace oox + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |