diff options
Diffstat (limited to 'filter/source/graphicfilter/icgm/cgm.cxx')
-rw-r--r-- | filter/source/graphicfilter/icgm/cgm.cxx | 927 |
1 files changed, 927 insertions, 0 deletions
diff --git a/filter/source/graphicfilter/icgm/cgm.cxx b/filter/source/graphicfilter/icgm/cgm.cxx new file mode 100644 index 000000000000..ea474a160e36 --- /dev/null +++ b/filter/source/graphicfilter/icgm/cgm.cxx @@ -0,0 +1,927 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org 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 version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_filter.hxx" +#include <com/sun/star/task/XStatusIndicator.hpp> +#include <unotools/ucbstreamhelper.hxx> + +#define CGM_BREAK_ACTION 0xffffffff +#include <osl/endian.h> +#include <vcl/virdev.hxx> +#include <vcl/graph.hxx> +#include <tools/stream.hxx> +#include <chart.hxx> +#include <main.hxx> +#include <elements.hxx> +#include <outact.hxx> + +using namespace ::com::sun::star; + +// --------------------------------------------------------------- + +void CGM::ImplCGMInit() +{ + mbIsFinished = mbPicture = mbMetaFile = mbPictureBody = sal_False; + + mnActCount = 0; + mnOutdx = 28000; + mnOutdy = 21000; + + mpBuf = NULL; + mpChart = NULL; + mpBitmapInUse = NULL; + + pCopyOfE = new CGMElements( *this ); + pElement = new CGMElements( *this ); +} + +// --------------------------------------------------------------- + +#ifdef CGM_EXPORT_IMPRESS + +CGM::CGM( sal_uInt32 nMode, uno::Reference< frame::XModel > & rModel ) : + mpGraphic ( NULL ), + mpCommentOut ( NULL ), + mbStatus ( sal_True ), + mpOutAct ( new CGMImpressOutAct( *this, rModel ) ), + mnMode ( nMode ) +{ + mnMode |= CGM_EXPORT_IMPRESS; + ImplCGMInit(); +} +#endif + +// --------------------------------------------------------------- + +void CGM::ImplComment( sal_uInt32 Level, const char* Description ) +{ + if ( mpCommentOut ) + { + if ( Level == CGM_DESCRIPTION ) + { + *mpCommentOut << " " << Description << "\n"; + } + else + { + sal_Int8 nFirst, nSecond, i, nCount = 0; + if ( mnActCount < 10000 ) + nCount++; + if ( mnActCount < 1000 ) + nCount++; + if ( mnActCount < 100 ) + nCount++; + if ( mnActCount < 10 ) + nCount++; + for ( i = 0; i <= nCount; i++ ) + *mpCommentOut << " "; + mpCommentOut->WriteNumber( mnActCount ); + + switch( Level & 0xff ) + { + case CGM_UNKNOWN_LEVEL : + *mpCommentOut << " L?"; + break; + case CGM_UNKNOWN_COMMAND : + *mpCommentOut << " UNKNOWN COMMAND"; + break; + case CGM_GDSF_ONLY : + *mpCommentOut << " LI"; + break; + default: + *mpCommentOut << " L"; + mpCommentOut->WriteNumber( Level & 0xff ); + break; + } + *mpCommentOut << " C"; + mpCommentOut->WriteNumber( mnElementClass ); + *mpCommentOut << " ID-0x"; + nFirst = ( mnElementID > 0x9F ) ? (sal_Int8)( mnElementID >> 4 ) + 'A' - 10: (sal_Int8)( mnElementID >> 4 ) + '0'; + nSecond = ( ( mnElementID & 15 ) > 9 ) ? (sal_Int8)( mnElementID & 15 ) + 'A' - 10 : (sal_Int8)( mnElementID & 15 ) + '0'; + *mpCommentOut << nFirst << nSecond; + *mpCommentOut << " Size"; + nCount = 1; + if ( mnElementSize < 1000000 ) + nCount++; + if ( mnElementSize < 100000 ) + nCount++; + if ( mnElementSize < 10000 ) + nCount++; + if ( mnElementSize < 1000 ) + nCount++; + if ( mnElementSize < 100 ) + nCount++; + if ( mnElementSize < 10 ) + nCount++; + for ( i = 0; i < nCount; i++ ) + *mpCommentOut << " "; + mpCommentOut->WriteNumber( mnElementSize ); + *mpCommentOut << " " << Description << "\n"; + } + } +} + +// --------------------------------------------------------------- + +CGM::~CGM() +{ + +#ifdef CGM_EXPORT_META + if ( mpGraphic ) + { + mpGDIMetaFile->Stop(); + mpGDIMetaFile->SetPrefMapMode( MapMode() ); + mpGDIMetaFile->SetPrefSize( Size( static_cast< long >( mnOutdx ), static_cast< long >( mnOutdy ) ) ); + delete mpVirDev; + *mpGraphic = Graphic( *mpGDIMetaFile ); + } +#endif + sal_Int8* pBuf = (sal_Int8*)maDefRepList.First(); + while( pBuf ) + { + delete pBuf; + pBuf = (sal_Int8*)maDefRepList.Next(); + } + maDefRepList.Clear(); + delete mpBitmapInUse; + delete mpCommentOut; + delete mpChart; + delete mpOutAct; + delete pCopyOfE; + delete pElement; + delete [] mpBuf; +}; + +// --------------------------------------------------------------- + +sal_uInt32 CGM::GetBackGroundColor() +{ + return ( pElement ) ? pElement->aColorTable[ 0 ] : 0; +} + +// --------------------------------------------------------------- + +sal_uInt32 CGM::ImplGetUI16( sal_uInt32 /*nAlign*/ ) +{ + sal_uInt8* pSource = mpSource + mnParaSize; + mnParaSize += 2; + return ( pSource[ 0 ] << 8 ) + pSource[ 1 ]; +}; + +// --------------------------------------------------------------- + +sal_uInt8 CGM::ImplGetByte( sal_uInt32 nSource, sal_uInt32 nPrecision ) +{ + return (sal_uInt8)( nSource >> ( ( nPrecision - 1 ) << 3 ) ); +}; + +// --------------------------------------------------------------- + +long CGM::ImplGetI( sal_uInt32 nPrecision ) +{ + sal_uInt8* pSource = mpSource + mnParaSize; + mnParaSize += nPrecision; + switch( nPrecision ) + { + case 1 : + { + return (char)*pSource; + } + + case 2 : + { + return (sal_Int16)( ( pSource[ 0 ] << 8 ) | pSource[ 1 ] ); + } + + case 3 : + { + return ( ( pSource[ 0 ] << 24 ) | ( pSource[ 1 ] << 16 ) | pSource[ 2 ] << 8 ) >> 8; + } + case 4: + { + return (sal_Int32)( ( pSource[ 0 ] << 24 ) | ( pSource[ 1 ] << 16 ) | ( pSource[ 2 ] << 8 ) | ( pSource[ 3 ] ) ); + } + default: + mbStatus = sal_False; + return 0; + } +} + +// --------------------------------------------------------------- + +sal_uInt32 CGM::ImplGetUI( sal_uInt32 nPrecision ) +{ + sal_uInt8* pSource = mpSource + mnParaSize; + mnParaSize += nPrecision; + switch( nPrecision ) + { + case 1 : + return (sal_Int8)*pSource; + case 2 : + { + return (sal_uInt16)( ( pSource[ 0 ] << 8 ) | pSource[ 1 ] ); + } + case 3 : + { + return ( pSource[ 0 ] << 16 ) | ( pSource[ 1 ] << 8 ) | pSource[ 2 ]; + } + case 4: + { + return (sal_uInt32)( ( pSource[ 0 ] << 24 ) | ( pSource[ 1 ] << 16 ) | ( pSource[ 2 ] << 8 ) | ( pSource[ 3 ] ) ); + } + default: + mbStatus = sal_False; + return 0; + } +} + +// --------------------------------------------------------------- + +void CGM::ImplGetSwitch4( sal_uInt8* pSource, sal_uInt8* pDest ) +{ + for ( int i = 0; i < 4; i++ ) + { + pDest[ i ] = pSource[ i ^ 3 ]; // Little Endian <-> Big Endian switch + } +} + +// --------------------------------------------------------------- + +void CGM::ImplGetSwitch8( sal_uInt8* pSource, sal_uInt8* pDest ) +{ + for ( int i = 0; i < 8; i++ ) + { + pDest[ i ] = pSource[ i ^ 7 ]; // Little Endian <-> Big Endian switch + } +} + +// --------------------------------------------------------------- + +double CGM::ImplGetFloat( RealPrecision eRealPrecision, sal_uInt32 nRealSize ) +{ + void* pPtr; + sal_uInt8 aBuf[8]; + sal_Bool bCompatible; + double nRetValue; + double fDoubleBuf; + float fFloatBuf; + +#ifdef OSL_BIGENDIAN + bCompatible = sal_True; +#else + bCompatible = sal_False; +#endif + if ( bCompatible ) + pPtr = mpSource + mnParaSize; + else + { + if ( nRealSize == 4 ) + ImplGetSwitch4( mpSource + mnParaSize, &aBuf[0] ); + else + ImplGetSwitch8( mpSource + mnParaSize, &aBuf[0] ); + pPtr = &aBuf; + } + if ( eRealPrecision == RP_FLOAT ) + { + if ( nRealSize == 4 ) + { + memcpy( (void*)&fFloatBuf, pPtr, 4 ); + nRetValue = (double)fFloatBuf; + } + else + { + memcpy( (void*)&fDoubleBuf, pPtr, 8 ); + nRetValue = fDoubleBuf; + } + } + else // ->RP_FIXED + { + long nVal; + int nSwitch = ( bCompatible ) ? 0 : 1 ; + if ( nRealSize == 4 ) + { + sal_uInt16* pShort = (sal_uInt16*)pPtr; + nVal = pShort[ nSwitch ]; + nVal <<= 16; + nVal |= pShort[ nSwitch ^ 1 ]; + nRetValue = (double)nVal; + nRetValue /= 65536; + } + else + { + long* pLong = (long*)pPtr; + nRetValue = (double)abs( pLong[ nSwitch ] ); + nRetValue *= 65536; + nVal = (sal_uInt32)( pLong[ nSwitch ^ 1 ] ); + nVal >>= 16; + nRetValue += (double)nVal; + if ( pLong[ nSwitch ] < 0 ) + { + nRetValue -= nRetValue; + } + nRetValue /= 65536; + } + } + mnParaSize += nRealSize; + return nRetValue; +} + +// --------------------------------------------------------------- + +sal_uInt32 CGM::ImplGetPointSize() +{ + if ( pElement->eVDCType == VDC_INTEGER ) + return pElement->nVDCIntegerPrecision << 1; + else + return pElement->nVDCRealSize << 1; +} + +// --------------------------------------------------------------- + +inline double CGM::ImplGetIX() +{ + return ( ( ImplGetI( pElement->nVDCIntegerPrecision ) + mnVDCXadd ) * mnVDCXmul ); +} + +// --------------------------------------------------------------- + +inline double CGM::ImplGetFX() +{ + return ( ( ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize ) + mnVDCXadd ) * mnVDCXmul ); +} + +// --------------------------------------------------------------- + +inline double CGM::ImplGetIY() +{ + return ( ( ImplGetI( pElement->nVDCIntegerPrecision ) + mnVDCYadd ) * mnVDCYmul ); +} + +// --------------------------------------------------------------- + +inline double CGM::ImplGetFY() +{ + return ( ( ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize ) + mnVDCYadd ) * mnVDCYmul ); +} + +// --------------------------------------------------------------- + +void CGM::ImplGetPoint( FloatPoint& rFloatPoint, sal_Bool bMap ) +{ + if ( pElement->eVDCType == VDC_INTEGER ) + { + rFloatPoint.X = ImplGetIX(); + rFloatPoint.Y = ImplGetIY(); + } + else // ->floating points + { + rFloatPoint.X = ImplGetFX(); + rFloatPoint.Y = ImplGetFY(); + } + if ( bMap ) + ImplMapPoint( rFloatPoint ); +} + +// --------------------------------------------------------------- + +void CGM::ImplGetRectangle( FloatRect& rFloatRect, sal_Bool bMap ) +{ + if ( pElement->eVDCType == VDC_INTEGER ) + { + rFloatRect.Left = ImplGetIX(); + rFloatRect.Bottom = ImplGetIY(); + rFloatRect.Right = ImplGetIX(); + rFloatRect.Top = ImplGetIY(); + } + else // ->floating points + { + rFloatRect.Left = ImplGetFX(); + rFloatRect.Bottom = ImplGetFY(); + rFloatRect.Right = ImplGetFX(); + rFloatRect.Top = ImplGetFY(); + } + if ( bMap ) + { + ImplMapX( rFloatRect.Left ); + ImplMapX( rFloatRect.Right ); + ImplMapY( rFloatRect.Top ); + ImplMapY( rFloatRect.Bottom ); + rFloatRect.Justify(); + } +} + +// --------------------------------------------------------------- + +void CGM::ImplGetRectangleNS( FloatRect& rFloatRect ) +{ + if ( pElement->eVDCType == VDC_INTEGER ) + { + rFloatRect.Left = ImplGetI( pElement->nVDCIntegerPrecision ); + rFloatRect.Bottom = ImplGetI( pElement->nVDCIntegerPrecision ); + rFloatRect.Right = ImplGetI( pElement->nVDCIntegerPrecision ); + rFloatRect.Top = ImplGetI( pElement->nVDCIntegerPrecision ); + } + else // ->floating points + { + rFloatRect.Left = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize ); + rFloatRect.Bottom = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize ); + rFloatRect.Right = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize ); + rFloatRect.Top = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize ); + } +} + +// --------------------------------------------------------------- + +sal_uInt32 CGM::ImplGetBitmapColor( sal_Bool bDirect ) +{ + // the background color is always a direct color + + sal_uInt32 nTmp; + if ( ( pElement->eColorSelectionMode == CSM_DIRECT ) || bDirect ) + { + sal_uInt32 nColor = ImplGetByte( ImplGetUI( pElement->nColorPrecision ), 1 ); + sal_uInt32 nDiff = pElement->nColorValueExtent[ 3 ] - pElement->nColorValueExtent[ 0 ] + 1; + + if ( !nDiff ) + nDiff++; + nColor = ( ( nColor - pElement->nColorValueExtent[ 0 ] ) << 8 ) / nDiff; + nTmp = nColor << 16 & 0xff0000; + + nColor = ImplGetByte( ImplGetUI( pElement->nColorPrecision ), 1 ); + nDiff = pElement->nColorValueExtent[ 4 ] - pElement->nColorValueExtent[ 1 ] + 1; + if ( !nDiff ) + nDiff++; + nColor = ( ( nColor - pElement->nColorValueExtent[ 1 ] ) << 8 ) / nDiff; + nTmp |= nColor << 8 & 0xff00; + + nColor = ImplGetByte( ImplGetUI( pElement->nColorPrecision ), 1 ); + nDiff = pElement->nColorValueExtent[ 5 ] - pElement->nColorValueExtent[ 2 ] + 1; + if ( !nDiff ) + nDiff++; + nColor = ( ( nColor - pElement->nColorValueExtent[ 2 ] ) << 8 ) / nDiff; + nTmp |= (sal_uInt8)nColor; + } + else + { + sal_uInt32 nIndex = ImplGetUI( pElement->nColorIndexPrecision ); + nTmp = pElement->aColorTable[ (sal_uInt8)( nIndex ) ] ; + } + return nTmp; +} + +// --------------------------------------------------------------- + +// call this function each time after the mapmode settings has been changed +void CGM::ImplSetMapMode() +{ + int nAngReverse = 1; + mnVDCdx = pElement->aVDCExtent.Right - pElement->aVDCExtent.Left; + + mnVDCXadd = -pElement->aVDCExtent.Left; + mnVDCXmul = 1; + if ( mnVDCdx < 0 ) + { + nAngReverse ^= 1; + mnVDCdx = -mnVDCdx; + mnVDCXmul = -1; + } + + mnVDCdy = pElement->aVDCExtent.Bottom - pElement->aVDCExtent.Top; + mnVDCYadd = -pElement->aVDCExtent.Top; + mnVDCYmul = 1; + if ( mnVDCdy < 0 ) + { + nAngReverse ^= 1; + mnVDCdy = -mnVDCdy; + mnVDCYmul = -1; + } + if ( nAngReverse ) + mbAngReverse = sal_True; + else + mbAngReverse = sal_False; + + double fQuo1 = mnVDCdx / mnVDCdy; + double fQuo2 = mnOutdx / mnOutdy; + if ( fQuo2 < fQuo1 ) + { + mnXFraction = mnOutdx / mnVDCdx; + mnYFraction = mnOutdy * ( fQuo2 / fQuo1 ) / mnVDCdy; + } + else + { + mnXFraction = mnOutdx * ( fQuo1 / fQuo2 ) / mnVDCdx; + mnYFraction = mnOutdy / mnVDCdy; + } +} + +// --------------------------------------------------------------- + +void CGM::ImplMapDouble( double& nNumb ) +{ + if ( pElement->eDeviceViewPortMap == DVPM_FORCED ) + { + // point is 1mm * ScalingFactor + switch ( pElement->eDeviceViewPortMode ) + { + case DVPM_FRACTION : + { + nNumb *= ( mnXFraction + mnYFraction ) / 2; + } + break; + + case DVPM_METRIC : + { +// nNumb *= ( 100 * pElement->nDeviceViewPortScale ); + nNumb *= ( mnXFraction + mnYFraction ) / 2; + if ( pElement->nDeviceViewPortScale < 0 ) + nNumb = -nNumb; + } + break; + + case DVPM_DEVICE : + { + + } + break; + + default: + + break; + } + } + else + { + + + } +} + +// --------------------------------------------------------------- + +void CGM::ImplMapX( double& nNumb ) +{ + if ( pElement->eDeviceViewPortMap == DVPM_FORCED ) + { + // point is 1mm * ScalingFactor + switch ( pElement->eDeviceViewPortMode ) + { + case DVPM_FRACTION : + { + nNumb *= mnXFraction; + } + break; + + case DVPM_METRIC : + { +// nNumb *= ( 100 * pElement->nDeviceViewPortScale ); + nNumb *= mnXFraction; + if ( pElement->nDeviceViewPortScale < 0 ) + nNumb = -nNumb; + } + break; + + case DVPM_DEVICE : + { + + } + break; + + default: + + break; + } + } + else + { + + + } +} + + +// --------------------------------------------------------------- + +void CGM::ImplMapY( double& nNumb ) +{ + if ( pElement->eDeviceViewPortMap == DVPM_FORCED ) + { + // point is 1mm * ScalingFactor + switch ( pElement->eDeviceViewPortMode ) + { + case DVPM_FRACTION : + { + nNumb *= mnYFraction; + } + break; + + case DVPM_METRIC : + { +// nNumb *= ( 100 * pElement->nDeviceViewPortScale ); + nNumb *= mnYFraction; + if ( pElement->nDeviceViewPortScale < 0 ) + nNumb = -nNumb; + } + break; + + case DVPM_DEVICE : + { + + } + break; + + default: + + break; + } + } + else + { + + + } +} + + +// --------------------------------------------------------------- + +// convert a point to the current VC mapmode (1/100TH mm) +void CGM::ImplMapPoint( FloatPoint& rFloatPoint ) +{ + if ( pElement->eDeviceViewPortMap == DVPM_FORCED ) + { + // point is 1mm * ScalingFactor + switch ( pElement->eDeviceViewPortMode ) + { + case DVPM_FRACTION : + { + rFloatPoint.X *= mnXFraction; + rFloatPoint.Y *= mnYFraction; + } + break; + + case DVPM_METRIC : + { + rFloatPoint.X *= mnXFraction; + rFloatPoint.Y *= mnYFraction; + if ( pElement->nDeviceViewPortScale < 0 ) + { + rFloatPoint.X = -rFloatPoint.X; + rFloatPoint.Y = -rFloatPoint.Y; + } + } + break; + + case DVPM_DEVICE : + { + + } + break; + + default: + + break; + } + } + else + { + + + } +} + +// --------------------------------------------------------------- + +void CGM::ImplDoClass() +{ +#ifdef CGM_USER_BREAKPOINT +#ifdef WNT + if ( mnActCount == CGM_BREAK_ACTION ) + _asm int 0x3; +#endif +#endif + switch ( mnElementClass ) + { + case 0 : ImplDoClass0(); break; + case 1 : ImplDoClass1(); break; + case 2 : ImplDoClass2(); break; + case 3 : ImplDoClass3(); break; + case 4 : + { + ImplDoClass4(); + mnAct4PostReset = 0; + } + break; + case 5 : ImplDoClass5(); break; + case 6 : ImplDoClass6(); break; + case 7 : ImplDoClass7(); break; + case 8 : ImplDoClass8(); break; + case 9 : ImplDoClass9(); break; + case 15 :ImplDoClass15(); break; + default : ComOut( CGM_UNKNOWN_COMMAND, "" ); break; + } + mnActCount++; +}; + +// --------------------------------------------------------------- + +void CGM::ImplDefaultReplacement() +{ + sal_uInt8* pBuf = (sal_uInt8*)maDefRepList.First(); + if ( pBuf ) + { + sal_uInt32 nElementSize = (sal_uInt32)(sal_uIntPtr)maDefRepSizeList.First(); + sal_uInt32 nOldEscape = mnEscape; + sal_uInt32 nOldElementClass = mnElementClass; + sal_uInt32 nOldElementID = mnElementID; + sal_uInt32 nOldElementSize = mnElementSize; + sal_uInt8* pOldBuf = mpSource; + while( pBuf ) + { + sal_uInt32 nCount = 0; + while ( mbStatus && ( nCount < nElementSize ) ) + { + mpSource = pBuf + nCount; + mnParaSize = 0; + mnEscape = ImplGetUI16(); + mnElementClass = mnEscape >> 12; + mnElementID = ( mnEscape & 0x0fe0 ) >> 5; + mnElementSize = mnEscape & 0x1f; + if ( mnElementSize == 31 ) + { + mnElementSize = ImplGetUI16(); + } + nCount += mnParaSize; + mnParaSize = 0; + mpSource = pBuf + nCount; + if ( mnElementSize & 1 ) + nCount++; + nCount += mnElementSize; + if ( ( mnElementClass != 1 ) || ( mnElementID != 0xc ) ) // rekursion hier nicht moeglich!! + ImplDoClass(); + } + nElementSize = (sal_uInt32)(sal_uIntPtr)maDefRepSizeList.Next(); + pBuf = (sal_uInt8*)maDefRepList.Next(); + } + mnEscape = nOldEscape; + mnElementClass = nOldElementClass; + mnElementID = nOldElementID; + mnParaSize = mnElementSize = nOldElementSize; + mpSource = pOldBuf; + } +} + +// --------------------------------------------------------------- + +sal_Bool CGM::Write( SvStream& rIStm ) +{ + if ( !mpBuf ) + mpBuf = new sal_uInt8[ 0xffff ]; + + mnParaSize = 0; + mpSource = mpBuf; + rIStm.Read( mpSource, 2 ); + mnEscape = ImplGetUI16(); + mnElementClass = mnEscape >> 12; + mnElementID = ( mnEscape & 0x0fe0 ) >> 5; + mnElementSize = mnEscape & 0x1f; + + if ( mnElementSize == 31 ) + { + rIStm.Read( mpSource + mnParaSize, 2 ); + mnElementSize = ImplGetUI16(); + } + mnParaSize = 0; + if ( mnElementSize ) + rIStm.Read( mpSource + mnParaSize, mnElementSize ); + + if ( mnElementSize & 1 ) + rIStm.SeekRel( 1 ); + ImplDoClass(); + + +#ifdef CGM_USER_BREAKPOINT +#ifdef WNT + if ( !mbStatus || mnParaSize && ( mnElementSize != mnParaSize ) ) + _asm int 0x3; +#endif +#endif + + return mbStatus; +}; + +// --------------------------------------------------------------- + +SvStream& operator>>( SvStream& rOStm, CGM& /*rCGM*/ ) +{ + + return rOStm; +}; + +// --------------------------------------------------------------- + + + +//================== GraphicImport - die exportierte Funktion ================ + +extern "C" sal_uInt32 __LOADONCALLAPI ImportCGM( String& rFileName, uno::Reference< frame::XModel > & rXModel, sal_uInt32 nMode, void* pProgressBar ) +{ + + sal_uInt32 nStatus = 0; // retvalue == 0 -> ERROR + // == 0xffrrggbb -> background color in the lower 24 bits + sal_Bool bProgressBar = sal_False; + + if( rXModel.is() ) + { + CGM* pCGM= NULL; + + try + { + pCGM = new CGM( nMode, rXModel ); + if ( pCGM && pCGM->IsValid() ) + { + if ( nMode & CGM_IMPORT_CGM ) + { + SvStream* pIn = ::utl::UcbStreamHelper::CreateStream( rFileName, STREAM_READ ); + if ( pIn ) + { + pIn->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN ); + pIn->Seek( STREAM_SEEK_TO_END ); + sal_uInt32 nInSize = pIn->Tell(); + pIn->Seek( 0 ); + +#ifdef CGM_EXPORT_IMPRESS + uno::Reference< task::XStatusIndicator > aXStatInd; + sal_uInt32 nNext = 0; + sal_uInt32 nAdd = nInSize / 20; + if ( pProgressBar ) + aXStatInd = *(uno::Reference< task::XStatusIndicator > *)pProgressBar; + bProgressBar = aXStatInd.is(); + if ( bProgressBar ) + aXStatInd->start( rtl::OUString::createFromAscii("CGM Import"), nInSize ); +#endif + + while ( pCGM->IsValid() && ( pIn->Tell() < nInSize ) && !pCGM->IsFinished() ) + { + +#ifdef CGM_EXPORT_IMPRESS + + + if ( bProgressBar ) + { + sal_uInt32 nCurrentPos = pIn->Tell(); + if ( nCurrentPos >= nNext ) + { + aXStatInd->setValue( nCurrentPos ); + nNext = nCurrentPos + nAdd; + } + } +#endif + + if ( pCGM->Write( *pIn ) == sal_False ) + break; + } + if ( pCGM->IsValid() ) + { + nStatus = pCGM->GetBackGroundColor() | 0xff000000; + } +#ifdef CGM_EXPORT_IMPRESS + if ( bProgressBar ) + aXStatInd->end(); +#endif + delete pIn; + } + } + } + } + catch( ::com::sun::star::uno::Exception& ) + { + nStatus = 0; + } + delete pCGM; + } + return nStatus; +} |