| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the 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; |
| } |