diff options
Diffstat (limited to 'lotuswordpro/source/filter/lwpoleobject.cxx')
| -rw-r--r-- | lotuswordpro/source/filter/lwpoleobject.cxx | 752 |
1 files changed, 752 insertions, 0 deletions
diff --git a/lotuswordpro/source/filter/lwpoleobject.cxx b/lotuswordpro/source/filter/lwpoleobject.cxx new file mode 100644 index 000000000000..30e9c3fa978d --- /dev/null +++ b/lotuswordpro/source/filter/lwpoleobject.cxx @@ -0,0 +1,752 @@ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (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.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: IBM Corporation + * + * Copyright: 2008 by IBM Corporation + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ +/** + * @file + * For LWP filter architecture prototype - OLE object + */ +/************************************************************************* + * Change History + Feb 2005 Created + ************************************************************************/ +#include <stdio.h> +#include <tools/stream.hxx> +#include "lwpglobalmgr.hxx" +#include "lwpoleobject.hxx" +#include "lwpobjfactory.hxx" +#include "lwpidxmgr.hxx" +#include "lwp9reader.hxx" +#include "xfilter/xfoleobj.hxx" +#include "xfilter/xfparagraph.hxx" +#include "lwpframelayout.hxx" +#include "xfilter/xfstylemanager.hxx" +#include "bento.hxx" + +/** + * @descr: construction function + * @param: objHdr - object header, read before entering this function + * @param: pStrm - file stream + * @return: None + * @date: 2/22/2005 + */ +LwpGraphicOleObject::LwpGraphicOleObject(LwpObjectHeader &objHdr, LwpSvStream* pStrm) + : LwpContent(objHdr, pStrm) +{} +/** + * @descr: Read GraphicOleObject part + * @param: None + * @return: None + * @date: 2/22/2005 + */ +void LwpGraphicOleObject::Read() +{ + LwpContent::Read(); + + if (LwpFileHeader::m_nFileRevision >= 0x000b) + { + // I'm not sure about the read method + m_pNextObj.ReadIndexed(m_pObjStrm); + m_pPrevObj.ReadIndexed(m_pObjStrm); + } + m_pObjStrm->SkipExtra(); + +} + +void LwpGraphicOleObject::GetGrafOrgSize(double & rWidth, double & rHeight) +{ + rWidth = 0; + rHeight = 0; +} + +void LwpGraphicOleObject::GetGrafScaledSize(double & fWidth, double & fHeight) +{ + GetGrafOrgSize(fWidth, fHeight); + // scaled image size + double fSclGrafWidth = fWidth;//LwpTools::ConvertFromUnitsToMetric(pMyScale->GetScaleWidth()); + double fSclGrafHeight = fHeight;//LwpTools::ConvertFromUnitsToMetric(pMyScale->GetScaleHeight()); + + + LwpVirtualLayout* pLayout = GetLayout(NULL); + if (pLayout && pLayout->IsFrame()) + { + LwpFrameLayout* pMyFrameLayout = static_cast<LwpFrameLayout*>(pLayout); + LwpLayoutScale* pMyScale = pMyFrameLayout->GetLayoutScale(); + LwpLayoutGeometry* pFrameGeo = pMyFrameLayout->GetGeometry(); + + // original image size + //double fOrgGrafWidth = (double)m_Cache.Width/TWIPS_PER_CM; + //double fOrgGrafHeight = (double)m_Cache.Height/TWIPS_PER_CM; + + // get margin values + double fLeftMargin = pMyFrameLayout->GetMarginsValue(MARGIN_LEFT); + double fRightMargin = pMyFrameLayout->GetMarginsValue(MARGIN_RIGHT); + double fTopMargin = pMyFrameLayout->GetMarginsValue(MARGIN_TOP); + double fBottomMargin = pMyFrameLayout->GetMarginsValue(MARGIN_BOTTOM); + + if (pMyScale && pFrameGeo) + { + // frame size + double fFrameWidth = LwpTools::ConvertFromUnitsToMetric(pFrameGeo->GetWidth()); + double fFrameHeight = LwpTools::ConvertFromUnitsToMetric(pFrameGeo->GetHeight()); + + // calculate the displayed size of the frame + double fDisFrameWidth = fFrameWidth - (fLeftMargin+fRightMargin); + double fDisFrameHeight = fFrameHeight - (fTopMargin+fBottomMargin); + + // get scale mode + sal_uInt16 nScalemode = pMyScale->GetScaleMode(); + if (nScalemode & LwpLayoutScale::CUSTOM) + { + fSclGrafWidth = LwpTools::ConvertFromUnitsToMetric(pMyScale->GetScaleWidth()); + fSclGrafHeight = LwpTools::ConvertFromUnitsToMetric(pMyScale->GetScaleHeight()); + } + else if (nScalemode & LwpLayoutScale::PERCENTAGE) + { + double fScalePercentage = (double)pMyScale->GetScalePercentage() / 1000; + fSclGrafWidth = fScalePercentage * fWidth; + fSclGrafHeight = fScalePercentage * fHeight; + } + else if (nScalemode & LwpLayoutScale::FIT_IN_FRAME) + { + if (pMyFrameLayout->IsFitGraphic()) + { + fSclGrafWidth = fWidth; + fSclGrafHeight = fHeight; + } + else if (nScalemode & LwpLayoutScale::MAINTAIN_ASPECT_RATIO) + { + if (fWidth/fHeight >= fDisFrameWidth/fDisFrameHeight) + { + fSclGrafWidth = fDisFrameWidth; + fSclGrafHeight = (fDisFrameWidth/fWidth) * fHeight; + } + else + { + fSclGrafHeight = fDisFrameHeight; + fSclGrafWidth = (fDisFrameHeight/fHeight) * fWidth; + } + } + else + { + fSclGrafWidth = fDisFrameWidth; + fSclGrafHeight = fDisFrameHeight; + } + } + } + } + fWidth = fSclGrafWidth ; + fHeight = fSclGrafHeight ; + +} + +/** + * @descr: construction function + * @param: objHdr - object header, read before entering this function + * @param: pStrm - file stream + * @return: None + * @date: 2/22/2005 + */ +LwpOleObject::LwpOleObject(LwpObjectHeader &objHdr, LwpSvStream* pStrm) + : LwpGraphicOleObject(objHdr, pStrm),m_SizeRect(0,0,5,5) +{ +} +/** + * @descr: Read VO_OLEOBJECT record + * @param: None + * @return: None + * @date: 2/22/2005 + */ +void LwpOleObject::Read() +{ + LwpGraphicOleObject::Read(); + + cPersistentFlags = m_pObjStrm->QuickReaduInt16(); + + sal_uInt16 nNonVersionedPersistentFlags = 0; + sal_uInt32 nFormat = 0; + sal_uInt16 nNumberOfPages = 0; + // qCMarker read + LwpObjectID ID; + + if (LwpFileHeader::m_nFileRevision >= 0x0004) + { + nNonVersionedPersistentFlags = m_pObjStrm->QuickReaduInt16(); + + OUString sFormat = m_pObjStrm->QuickReadStringPtr(); + + if (LwpFileHeader::m_nFileRevision < 0x000B) + { + // null pointers have a VO_INVALID type + //if (VO_INVALID == m_pObjStrm->QuickReaduInt16()) + // return; + + ID.Read(m_pObjStrm); + //return m_pObjStrm->Locate(ID); + } + else + { + ID.ReadIndexed(m_pObjStrm); + //if (ID.IsNull()) + // return; + + //return m_pObjStrm->Locate(ID); + } + } + + if (m_pObjStrm->CheckExtra()) + { + nNumberOfPages = m_pObjStrm->QuickReaduInt16(); + m_pObjStrm->SkipExtra(); + } + +} +/** + * @descr: Construct ole-storage name by ObjectID + * @param: pObjName - input&output string of object name, spaces allocated outside and at least length should be MAX_STREAMORSTORAGENAME + * @return: None + * @date: 2/22/2005 + */ +void LwpOleObject::GetChildStorageName(char *pObjName) +{ + /*LwpObjectFactory * pObjMgr = LwpObjectFactory::Instance(); + LwpIndexManager * pIdxMgr = pObjMgr->GetIndexManager(); + sal_uInt32 nLowID = pIdxMgr->GetObjTime(static_cast<sal_uInt16>(GetObjectID()->GetLow()));*/ + + char sName[MAX_STREAMORSTORAGENAME]; + //LwpObjectID ID(nLowID, GetObjectID()->GetHigh()); + sprintf( sName, "%s%lX,%lX", "Ole", + GetObjectID()->GetHigh(), GetObjectID()->GetLow()); + + strcpy( pObjName, sName); + return; +} +/** + * @descr: Parse VO_OLEOBJECT and dump to XML stream only on WIN32 platform + * @param: pOutputStream - stream to dump OLE object + * @param: pFrameLayout - framlayout object used to dump OLE object + * @return: None + * @date: 2/22/2005 + */ +void LwpOleObject::Parse(IXFStream* pOutputStream) +{ +#if 0 +#ifdef WIN32 + + // + // Construct OLE object storage name + // + char sObjectName[MAX_STREAMORSTORAGENAME]; + GetChildStorageName(sObjectName); + String aObjName= String::CreateFromAscii(sObjectName); + + // + // Get OLE objects information + // + LwpGlobalMgr* pGlobal = LwpGlobalMgr::GetInstance(); + LwpObjectFactory* pObjMgr = pGlobal->GetLwpObjFactory(); + SvStorageRef objStor; + SvStorageInfoList * pInfoList; + pObjMgr->GetOleObjInfo(objStor, &pInfoList); + + if(pInfoList == NULL) + { + assert(sal_False); + return; + } + + // + // Get ole object buffer + // + BYTE * pBuf = NULL; + sal_uInt32 nSize = 0; + for (sal_uInt32 j=0; j<pInfoList->Count(); j++) + { + + SvStorageInfo& rInfo = pInfoList->GetObject(j); + String aName = rInfo.GetName(); + + if(aName == aObjName) + { + SvStorageRef childStor; + childStor = objStor->OpenStorage(rInfo.GetName()); + SvStorage * aEleStor; + aEleStor = objStor->OpenOLEStorage( rInfo.GetName() ); + SvInPlaceObjectRef xInplaceObj( ((SvFactory*)SvInPlaceObject::ClassFactory())->CreateAndLoad( childStor ) ); + SvOutPlaceObjectRef xOutplaceObj(xInplaceObj); + aEleStor->SetVersion( SOFFICE_FILEFORMAT_60 ); + SvStream *pStream=xOutplaceObj->GetOLEObjectStream(aEleStor); + + //Get Ole original size + m_SizeRect = xOutplaceObj->GetVisSize(xOutplaceObj->GetViewAspect()); + + nSize = pStream->Seek( STREAM_SEEK_TO_END ); + pBuf = new BYTE[nSize]; + if (pBuf == NULL) + { + assert(sal_False); + return; + } + pStream->Seek(0); + pStream->Read(pBuf, nSize); + + delete pStream; + break; + } + } + + // + // dump the buffer by XFilter + // + if(pBuf != NULL) + { + // set ole buffer + XFOleObject *pOleObj = new XFOleObject(); + pOleObj->SetOleData(pBuf, nSize); + + // set frame attributes + pOleObj->SetAnchorType(enumXFAnchorPara); + double fWidth = 0; + double fHeight = 0; + GetGrafScaledSize( fWidth, fHeight); + if(fWidth < 0.001 || fHeight < 0.001) + { + fWidth = 5.0; + fHeight = 5.0; + } + pOleObj->SetWidth(fWidth); + pOleObj->SetHeight(fHeight); + /* + pOleObj->SetName(A2OUSTR("TestOle")); + pOleObj->SetX(5); + pOleObj->SetY(5); + pOleObj->SetWidth(5); + pOleObj->SetHeight(5); + */ + + // To XML + XFParagraph *pPara = new XFParagraph(); + pPara->Add(pOleObj); + pPara->ToXml(pOutputStream); + + delete pPara; // pOleObj will be deleted inside + +#if 0 + // dump to file + String aTempDir( SvtPathOptions().GetTempPath() ); + sal_Int32 nLength = aTempDir.Len(); + if ( aTempDir.GetChar(nLength-1 ) !=UChar32( '/' ) ) + aTempDir += String::CreateFromAscii("/"); + + aTempDir += aObjName; + SvFileStream aStream(aTempDir, STREAM_WRITE); + aStream.Write(pBuf, nSize); + aStream.Close(); +#endif + delete []pBuf; + + // dump attributes to + } + + return; +#endif +#endif +} + +void LwpOleObject::XFConvert(XFContentContainer * pCont) +{ +#if 0 + //Add by 10/24/2005 + //Get ole object stream with the object name; + + // modified by + // if small file, use the compressed stream for BENTO + LwpSvStream* pStream = m_pStrm->GetCompressedStream() ? m_pStrm->GetCompressedStream(): m_pStrm; + // end modified by + + OpenStormBento::LtcBenContainer* pBentoContainer; + ULONG ulRet = OpenStormBento::BenOpenContainer(pStream, &pBentoContainer); + + char sObjectName[MAX_STREAMORSTORAGENAME]; + GetChildStorageName(sObjectName); + std::string aObjName(sObjectName); + SotStorageStreamRef xOleObjStm = pBentoContainer->ConvertAswStorageToOLE2Stream(aObjName.c_str()); + + //Get stream size and data + if(!xOleObjStm.Is() || xOleObjStm->GetError()) + return; + + + BYTE * pBuf = NULL; + sal_uInt32 nSize = 0; + + SvStorageRef xOleObjStor = new SvStorage( *xOleObjStm ); + //SvStorageRef xOleObjStor = pBentoContainer->CreateOLEStorageWithObjectName(aObjName.c_str()); + if( !xOleObjStor.Is()) + return ; + + SvInPlaceObjectRef xInplaceObj( ((SvFactory*)SvInPlaceObject::ClassFactory())->CreateAndLoad( xOleObjStor ) ); + + + //when the OLE object is converted into native object. +// SvOutPlaceObjectRef xOutplaceObj(xInplaceObj); +// xOutplaceObj->SetVersion( SOFFICE_FILEFORMAT_60 ); +// SvStream *pOleStream=xOutplaceObj->GetOLEObjectStream(xOleObjStor); + //Get Ole original size + m_SizeRect = GetOLEObjectSize(xOleObjStor); + //End by + + nSize = xOleObjStm->Seek( STREAM_SEEK_TO_END ); + pBuf = new BYTE[nSize]; + if (pBuf == NULL) + { + assert(sal_False); + return; + } + xOleObjStm->Seek(0); + xOleObjStm->Read(pBuf, nSize); + + //delete pOleStream; + + + //End by + + // + // dump the buffer by XFilter + // + if(pBuf != NULL) + { + // set ole buffer + XFOleObject *pOleObj = new XFOleObject(); + pOleObj->SetOleData(pBuf, nSize); + + // set frame attributes + pOleObj->SetAnchorType(enumXFAnchorFrame); + pOleObj->SetStyleName( m_strStyleName); + LwpFrameLayout* pMyFrameLayout = static_cast<LwpFrameLayout*>(GetLayout(NULL)); + if(pMyFrameLayout) + { + pOleObj->SetX(pMyFrameLayout->GetMarginsValue(MARGIN_LEFT)); + pOleObj->SetY(pMyFrameLayout->GetMarginsValue(MARGIN_TOP)); + } + + double fWidth = 0; + double fHeight = 0; + GetGrafScaledSize( fWidth, fHeight); + if(fWidth < 0.001 || fHeight < 0.001) + { + fWidth = 5.0; + fHeight = 5.0; + } + + + pOleObj->SetWidth(fWidth); + pOleObj->SetHeight(fHeight); + + + //delete pPara; // pOleObj will be deleted inside + pCont->Add(pOleObj); + +#if 0 + // dump to file + String aTempDir( SvtPathOptions().GetTempPath() ); + sal_Int32 nLength = aTempDir.Len(); + if ( aTempDir.GetChar(nLength-1 ) !=UChar32( '/' ) ) + aTempDir += String::CreateFromAscii("/"); + + aTempDir += aObjName; + SvFileStream aStream(aTempDir, STREAM_WRITE); + aStream.Write(pBuf, nSize); + aStream.Close(); +#endif + delete []pBuf; + + // dump attributes to + } +#endif + return; +} + +void LwpOleObject::GetGrafOrgSize(double & rWidth, double & rHeight) +{ + rWidth = (double)m_SizeRect.GetWidth()/1000;//cm unit + rHeight = (double)m_SizeRect.GetHeight()/1000;//cm unit +} + +void LwpOleObject::RegisterStyle() +{ +#if 0 +#ifdef WIN32 + LwpVirtualLayout* pMyLayout = GetLayout(NULL); + if(pMyLayout->IsFrame()) + { + XFFrameStyle* pXFFrameStyle = new XFFrameStyle(); + pXFFrameStyle->SetXPosType(enumXFFrameXPosFromLeft, enumXFFrameXRelFrame); + pXFFrameStyle->SetYPosType(enumXFFrameYPosFromTop, enumXFFrameYRelPara); + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + m_strStyleName = pXFStyleManager->AddStyle(pXFFrameStyle)->GetStyleName(); + } +#endif +#endif +} + + +#include <sot/exchange.hxx> +#include <sot/storinfo.hxx> +#include <svtools/wmf.hxx> +/** +* @descr: For SODC_2667, To get the OLE object size by reading OLE object picture information. +*/ +Rectangle LwpOleObject::GetOLEObjectSize( SotStorage * pStor ) const +{ + Rectangle aSize(0,0,0,0); + String aStreamName; + if( pStor->IsContained( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\002OlePres000" ) ) ) ) + aStreamName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\002OlePres000" ) ); + else if( pStor->IsContained( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\1Ole10Native" ) ) ) ) + aStreamName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\1Ole10Native" ) ); + + if( aStreamName.Len() == 0 ) + return aSize; + + + for( USHORT i = 1; i < 10; i++ ) + { + SotStorageStreamRef xStm = pStor->OpenSotStream( aStreamName, + STREAM_READ | STREAM_NOCREATE ); + if( xStm->GetError() ) + break; + + xStm->SetBufferSize( 8192 ); + LwpOlePres * pEle = new LwpOlePres( 0 ); + if( pEle->Read( *xStm ) && !xStm->GetError() ) + { + if( pEle->GetFormat() == FORMAT_GDIMETAFILE || pEle->GetFormat() == FORMAT_BITMAP ) + { + aSize = Rectangle( Point(), pEle->GetSize()); + delete pEle; + break; + } + } + delete pEle; + pEle = NULL; + aStreamName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\002OlePres00" ) ); + aStreamName += String( i ); + }; + + return aSize; +} +/** +* @descr: Read OLE object picture information +*/ +BOOL LwpOlePres::Read( SvStream & rStm ) +{ +#if 0 + ULONG nBeginPos = rStm.Tell(); + INT32 n; + rStm >> n; + if( n != -1 ) + { + pBmp = new Bitmap; + rStm >> *pBmp; + if( rStm.GetError() == SVSTREAM_OK ) + { + nFormat = FORMAT_BITMAP; + aSize = pBmp->GetPrefSize(); + MapMode aMMSrc; + if( !aSize.Width() || !aSize.Height() ) + { + // letzte Chance + aSize = pBmp->GetSizePixel(); + aMMSrc = MAP_PIXEL; + } + else + aMMSrc = pBmp->GetPrefMapMode(); + MapMode aMMDst( MAP_100TH_MM ); + aSize = OutputDevice::LogicToLogic( aSize, aMMSrc, aMMDst ); + return TRUE; + } + else + { + delete pBmp; + pBmp = NULL; + + pMtf = new GDIMetaFile(); + rStm.ResetError(); + rStm >> *pMtf; + if( rStm.GetError() == SVSTREAM_OK ) + { + nFormat = FORMAT_GDIMETAFILE; + aSize = pMtf->GetPrefSize(); + MapMode aMMSrc = pMtf->GetPrefMapMode(); + MapMode aMMDst( MAP_100TH_MM ); + aSize = OutputDevice::LogicToLogic( aSize, aMMSrc, aMMDst ); + return TRUE; + } + else + { + delete pMtf; + pMtf = NULL; + } + } + + } + + rStm.ResetError(); + rStm.Seek( nBeginPos ); + nFormat = ReadClipboardFormat( rStm ); + // JobSetup, bzw. TargetDevice ueberlesen + // Information aufnehmen, um sie beim Schreiben nicht zu verlieren + nJobLen = 0; + rStm >> nJobLen; + if( nJobLen >= 4 ) + { + nJobLen -= 4; + if( nJobLen ) + { + pJob = new BYTE[ nJobLen ]; + rStm.Read( pJob, nJobLen ); + } + } + else + { + rStm.SetError( SVSTREAM_GENERALERROR ); + return FALSE; + } + UINT32 nAsp; + rStm >> nAsp; + USHORT nSvAsp = USHORT( nAsp ); + SetAspect( nSvAsp ); + rStm.SeekRel( 4 ); //L-Index ueberlesen + rStm >> nAdvFlags; + rStm.SeekRel( 4 ); //Compression + UINT32 nWidth = 0; + UINT32 nHeight = 0; + UINT32 nSize = 0; + rStm >> nWidth >> nHeight >> nSize; + aSize.Width() = nWidth; + aSize.Height() = nHeight; + + if( nFormat == FORMAT_GDIMETAFILE ) + { + pMtf = new GDIMetaFile(); + ReadWindowMetafile( rStm, *pMtf ); + } + else if( nFormat == FORMAT_BITMAP ) + { + pBmp = new Bitmap(); + rStm >> *pBmp; + } + else + { + void * p = new BYTE[ nSize ]; + rStm.Read( p, nSize ); + delete p; + return FALSE; + } +#endif + return TRUE; +} + +/** +* @descr: Write OLE object picture information. +*/ +void LwpOlePres::Write( SvStream & rStm ) +{ + WriteClipboardFormat( rStm, FORMAT_GDIMETAFILE ); + rStm << (INT32)(nJobLen +4); // immer leeres TargetDevice + if( nJobLen ) + rStm.Write( pJob, nJobLen ); + rStm << (UINT32)nAspect; + rStm << (INT32)-1; //L-Index immer -1 + rStm << (INT32)nAdvFlags; + rStm << (INT32)0; //Compression + rStm << (INT32)aSize.Width(); + rStm << (INT32)aSize.Height(); + ULONG nPos = rStm.Tell(); + rStm << (INT32)0; + + if( GetFormat() == FORMAT_GDIMETAFILE && pMtf ) + { + // Immer auf 1/100 mm, bis Mtf-Loesung gefunden + // Annahme (keine Skalierung, keine Org-Verschiebung) + DBG_ASSERT( pMtf->GetPrefMapMode().GetScaleX() == Fraction( 1, 1 ), + "X-Skalierung im Mtf" ); + DBG_ASSERT( pMtf->GetPrefMapMode().GetScaleY() == Fraction( 1, 1 ), + "Y-Skalierung im Mtf" ); + DBG_ASSERT( pMtf->GetPrefMapMode().GetOrigin() == Point(), + "Origin-Verschiebung im Mtf" ); + MapUnit nMU = pMtf->GetPrefMapMode().GetMapUnit(); + if( MAP_100TH_MM != nMU ) + { + Size aPrefS( pMtf->GetPrefSize() ); + Size aS( aPrefS ); + aS = OutputDevice::LogicToLogic( aS, nMU, MAP_100TH_MM ); + + pMtf->Scale( Fraction( aS.Width(), aPrefS.Width() ), + Fraction( aS.Height(), aPrefS.Height() ) ); + pMtf->SetPrefMapMode( MAP_100TH_MM ); + pMtf->SetPrefSize( aS ); + } + WriteWindowMetafileBits( rStm, *pMtf ); + } + else + { + DBG_ERROR( "unknown format" ); + } + ULONG nEndPos = rStm.Tell(); + rStm.Seek( nPos ); + rStm << (UINT32)(nEndPos - nPos - 4); + rStm.Seek( nEndPos ); +} +//End by |