2524 lines
89 KiB
C++
2524 lines
89 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*************************************************************************
|
|
*
|
|
* 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_vcl.hxx"
|
|
|
|
#define ENABLE_BYTESTRING_STREAM_OPERATORS
|
|
|
|
#include <algorithm>
|
|
#include <string.h>
|
|
#include <tools/stack.hxx>
|
|
#include <tools/debug.hxx>
|
|
#include <tools/stream.hxx>
|
|
#include <vcl/virdev.hxx>
|
|
#include <vcl/graph.hxx>
|
|
#include <vcl/lineinfo.hxx>
|
|
#include <vcl/salbtype.hxx>
|
|
#include <vcl/cvtsvm.hxx>
|
|
#include <rtl/strbuf.hxx>
|
|
|
|
// -----------
|
|
// - Defines -
|
|
// -----------
|
|
|
|
#define CVTSVM_WRITE_SUBACTIONCOUNT 1
|
|
|
|
// -----------
|
|
// - Inlines -
|
|
// -----------
|
|
|
|
void ImplReadRect( SvStream& rIStm, Rectangle& rRect )
|
|
{
|
|
Point aTL;
|
|
Point aBR;
|
|
|
|
rIStm >> aTL;
|
|
rIStm >> aBR;
|
|
|
|
rRect = Rectangle( aTL, aBR );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWriteRect( SvStream& rOStm, const Rectangle& rRect )
|
|
{
|
|
rOStm << rRect.TopLeft();
|
|
rOStm << rRect.BottomRight();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplReadPoly( SvStream& rIStm, Polygon& rPoly )
|
|
{
|
|
sal_Int32 nSize;
|
|
|
|
rIStm >> nSize;
|
|
rPoly = Polygon( (sal_uInt16) nSize );
|
|
|
|
for( sal_uInt16 i = 0; i < (sal_uInt16) nSize; i++ )
|
|
rIStm >> rPoly[ i ];
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplReadPolyPoly( SvStream& rIStm, PolyPolygon& rPolyPoly )
|
|
{
|
|
Polygon aPoly;
|
|
sal_Int32 nPolyCount;
|
|
|
|
rIStm >> nPolyCount;
|
|
|
|
for( sal_uInt16 i = 0; i < (sal_uInt16) nPolyCount; i++ )
|
|
{
|
|
ImplReadPoly( rIStm, aPoly );
|
|
rPolyPoly.Insert( aPoly );
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWritePolyPolyAction( SvStream& rOStm, const PolyPolygon& rPolyPoly )
|
|
{
|
|
const sal_uInt16 nPoly = rPolyPoly.Count();
|
|
sal_uInt16 nPoints = 0;
|
|
sal_uInt16 n;
|
|
|
|
for( n = 0; n < nPoly; n++ )
|
|
nPoints = sal::static_int_cast<sal_uInt16>(nPoints + rPolyPoly[ n ].GetSize());
|
|
|
|
rOStm << (sal_Int16) GDI_POLYPOLYGON_ACTION;
|
|
rOStm << (sal_Int32) ( 8 + ( nPoly << 2 ) + ( nPoints << 3 ) );
|
|
rOStm << (sal_Int32) nPoly;
|
|
|
|
for( n = 0; n < nPoly; n++ )
|
|
{
|
|
// #i102224# Here the evtl. curved nature of Polygon was
|
|
// ignored (for all those Years). Adapted to at least write
|
|
// a polygon representing the curve as good as possible
|
|
Polygon aSimplePoly;
|
|
rPolyPoly[n].AdaptiveSubdivide(aSimplePoly);
|
|
const sal_uInt16 nSize(aSimplePoly.GetSize());
|
|
|
|
rOStm << (sal_Int32) nSize;
|
|
|
|
for( sal_uInt16 j = 0; j < nSize; j++ )
|
|
rOStm << aSimplePoly[ j ];
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplReadColor( SvStream& rIStm, Color& rColor )
|
|
{
|
|
sal_Int16 nVal;
|
|
|
|
rIStm >> nVal; rColor.SetRed( sal::static_int_cast<sal_uInt8>((sal_uInt16)nVal >> 8) );
|
|
rIStm >> nVal; rColor.SetGreen( sal::static_int_cast<sal_uInt8>((sal_uInt16)nVal >> 8) );
|
|
rIStm >> nVal; rColor.SetBlue( sal::static_int_cast<sal_uInt8>((sal_uInt16)nVal >> 8) );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWriteColor( SvStream& rOStm, const Color& rColor )
|
|
{
|
|
sal_Int16 nVal;
|
|
|
|
nVal = ( (sal_Int16) rColor.GetRed() << 8 ) | rColor.GetRed();
|
|
rOStm << nVal;
|
|
|
|
nVal = ( (sal_Int16) rColor.GetGreen() << 8 ) | rColor.GetGreen();
|
|
rOStm << nVal;
|
|
|
|
nVal = ( (sal_Int16) rColor.GetBlue() << 8 ) | rColor.GetBlue();
|
|
rOStm << nVal;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplReadMapMode( SvStream& rIStm, MapMode& rMapMode )
|
|
{
|
|
Point aOrg;
|
|
sal_Int32 nXNum;
|
|
sal_Int32 nXDenom;
|
|
sal_Int32 nYNum;
|
|
sal_Int32 nYDenom;
|
|
sal_Int16 nUnit;
|
|
|
|
rIStm >> nUnit >> aOrg >> nXNum >> nXDenom >> nYNum >> nYDenom;
|
|
rMapMode = MapMode( (MapUnit) nUnit, aOrg, Fraction( nXNum, nXDenom ), Fraction( nYNum, nYDenom ) );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWriteMapMode( SvStream& rOStm, const MapMode& rMapMode )
|
|
{
|
|
rOStm << (sal_Int16) rMapMode.GetMapUnit();
|
|
rOStm << rMapMode.GetOrigin();
|
|
rOStm << (sal_Int32) rMapMode.GetScaleX().GetNumerator();
|
|
rOStm << (sal_Int32) rMapMode.GetScaleX().GetDenominator();
|
|
rOStm << (sal_Int32) rMapMode.GetScaleY().GetNumerator();
|
|
rOStm << (sal_Int32) rMapMode.GetScaleY().GetDenominator();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWritePushAction( SvStream& rOStm )
|
|
{
|
|
rOStm << (sal_Int16) GDI_PUSH_ACTION;
|
|
rOStm << (sal_Int32) 4;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWritePopAction( SvStream& rOStm )
|
|
{
|
|
rOStm << (sal_Int16) GDI_POP_ACTION;
|
|
rOStm << (sal_Int32) 4;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWriteLineColor( SvStream& rOStm, const Color& rColor, sal_Int16 nStyle, sal_Int32 nWidth = 0L )
|
|
{
|
|
if( rColor.GetTransparency() > 127 )
|
|
nStyle = 0;
|
|
|
|
rOStm << (sal_Int16) GDI_PEN_ACTION;
|
|
rOStm << (sal_Int32) 16;
|
|
ImplWriteColor( rOStm, rColor );
|
|
rOStm << nWidth;
|
|
rOStm << nStyle;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWriteFillColor( SvStream& rOStm, const Color& rColor, sal_Int16 nStyle )
|
|
{
|
|
rOStm << (sal_Int16) GDI_FILLBRUSH_ACTION;
|
|
rOStm << (sal_Int32) 20;
|
|
ImplWriteColor( rOStm, rColor );
|
|
|
|
if( rColor.GetTransparency() > 127 )
|
|
nStyle = 0;
|
|
|
|
if( nStyle > 1 )
|
|
{
|
|
ImplWriteColor( rOStm, COL_WHITE );
|
|
rOStm << nStyle;
|
|
rOStm << (sal_Int16) 1;
|
|
}
|
|
else
|
|
{
|
|
ImplWriteColor( rOStm, COL_BLACK );
|
|
rOStm << nStyle;
|
|
rOStm << (sal_Int16) 0;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWriteFont( SvStream& rOStm, const Font& rFont,
|
|
rtl_TextEncoding& rActualCharSet )
|
|
{
|
|
char aName[32];
|
|
short nWeight;
|
|
|
|
ByteString aByteName( rFont.GetName(), rOStm.GetStreamCharSet() );
|
|
strncpy( aName, aByteName.GetBuffer(), 32 );
|
|
|
|
switch ( rFont.GetWeight() )
|
|
{
|
|
case WEIGHT_THIN:
|
|
case WEIGHT_ULTRALIGHT:
|
|
case WEIGHT_LIGHT:
|
|
nWeight = 1;
|
|
break;
|
|
|
|
case WEIGHT_NORMAL:
|
|
case WEIGHT_MEDIUM:
|
|
nWeight = 2;
|
|
break;
|
|
|
|
case WEIGHT_BOLD:
|
|
case WEIGHT_ULTRABOLD:
|
|
case WEIGHT_BLACK:
|
|
nWeight = 3;
|
|
break;
|
|
|
|
default:
|
|
nWeight = 0;
|
|
break;
|
|
}
|
|
|
|
rOStm << (sal_Int16) GDI_FONT_ACTION;
|
|
rOStm << (sal_Int32) 78;
|
|
|
|
rActualCharSet = GetStoreCharSet( rFont.GetCharSet() );
|
|
ImplWriteColor( rOStm, rFont.GetColor() );
|
|
ImplWriteColor( rOStm, rFont.GetFillColor() );
|
|
rOStm.Write( aName, 32 );
|
|
rOStm << rFont.GetSize();
|
|
rOStm << (sal_Int16) 0; // no character orientation anymore
|
|
rOStm << (sal_Int16) rFont.GetOrientation();
|
|
rOStm << (sal_Int16) rActualCharSet;
|
|
rOStm << (sal_Int16) rFont.GetFamily();
|
|
rOStm << (sal_Int16) rFont.GetPitch();
|
|
rOStm << (sal_Int16) rFont.GetAlign();
|
|
rOStm << (sal_Int16) nWeight;
|
|
rOStm << (sal_Int16) rFont.GetUnderline();
|
|
rOStm << (sal_Int16) rFont.GetStrikeout();
|
|
rOStm << (sal_Bool) ( rFont.GetItalic() != ITALIC_NONE );
|
|
rOStm << rFont.IsOutline();
|
|
rOStm << rFont.IsShadow();
|
|
rOStm << rFont.IsTransparent();
|
|
if ( rActualCharSet == RTL_TEXTENCODING_DONTKNOW )
|
|
rActualCharSet = osl_getThreadTextEncoding();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplWriteRasterOpAction( SvStream& rOStm, sal_Int16 nRasterOp )
|
|
{
|
|
rOStm << (sal_Int16) GDI_RASTEROP_ACTION << (sal_Int32) 6 << nRasterOp;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
sal_Bool ImplWriteUnicodeComment( SvStream& rOStm, const String& rString )
|
|
{
|
|
xub_StrLen i, nStringLen = rString.Len();
|
|
if ( nStringLen )
|
|
{
|
|
sal_uInt32 nSize = ( nStringLen << 1 ) + 4;
|
|
sal_uInt16 nType = GDI_UNICODE_COMMENT;
|
|
|
|
rOStm << nType << nSize;
|
|
for ( i = 0; i < nStringLen; i++ )
|
|
{
|
|
sal_Unicode nUni = rString.GetChar( i );
|
|
rOStm << nUni;
|
|
}
|
|
}
|
|
return nStringLen != 0;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplReadUnicodeComment( sal_uInt32 nStrmPos, SvStream& rIStm, String& rString )
|
|
{
|
|
sal_uInt32 nOld = rIStm.Tell();
|
|
if ( nStrmPos )
|
|
{
|
|
sal_uInt16 nType;
|
|
sal_uInt32 nActionSize;
|
|
xub_StrLen nStringLen;
|
|
|
|
rIStm.Seek( nStrmPos );
|
|
rIStm >> nType
|
|
>> nActionSize;
|
|
|
|
nStringLen = sal::static_int_cast<xub_StrLen>(( nActionSize - 4 ) >> 1);
|
|
|
|
if ( nStringLen && ( nType == GDI_UNICODE_COMMENT ) )
|
|
{
|
|
sal_Unicode* pBuffer = rString.AllocBuffer( nStringLen );
|
|
while ( nStringLen-- )
|
|
rIStm >> *pBuffer++;
|
|
}
|
|
}
|
|
rIStm.Seek( nOld );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplSkipActions( SvStream& rIStm, sal_uLong nSkipCount )
|
|
{
|
|
sal_Int32 nActionSize;
|
|
sal_Int16 nType;
|
|
|
|
for( sal_uLong i = 0UL; i < nSkipCount; i++ )
|
|
{
|
|
rIStm >> nType >> nActionSize;
|
|
rIStm.SeekRel( nActionSize - 4L );
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
bool ImplWriteExtendedPolyPolygonAction(SvStream& rOStm, const PolyPolygon& rPolyPolygon, bool bOnlyWhenCurve)
|
|
{
|
|
const sal_uInt16 nPolygonCount(rPolyPolygon.Count());
|
|
|
|
if(nPolygonCount)
|
|
{
|
|
sal_uInt32 nAllPolygonCount(0);
|
|
sal_uInt32 nAllPointCount(0);
|
|
sal_uInt32 nAllFlagCount(0);
|
|
sal_uInt16 a(0);
|
|
|
|
for(a = 0; a < nPolygonCount; a++)
|
|
{
|
|
const Polygon& rCandidate = rPolyPolygon.GetObject(a);
|
|
const sal_uInt16 nPointCount(rCandidate.GetSize());
|
|
|
|
if(nPointCount)
|
|
{
|
|
nAllPolygonCount++;
|
|
nAllPointCount += nPointCount;
|
|
|
|
if(rCandidate.HasFlags())
|
|
{
|
|
nAllFlagCount += nPointCount;
|
|
}
|
|
}
|
|
}
|
|
|
|
if((bOnlyWhenCurve && nAllFlagCount) || (!bOnlyWhenCurve && nAllPointCount))
|
|
{
|
|
rOStm << (sal_Int16) GDI_EXTENDEDPOLYGON_ACTION;
|
|
|
|
const sal_Int32 nActionSize(
|
|
4 + // Action size
|
|
2 + // PolygonCount
|
|
(nAllPolygonCount * 2) + // Points per polygon
|
|
(nAllPointCount << 3) + // Points themselves
|
|
nAllPolygonCount + // Bool if (when poly has points) it has flags, too
|
|
nAllFlagCount); // Flags themselves
|
|
|
|
rOStm << nActionSize;
|
|
rOStm << (sal_uInt16)nAllPolygonCount;
|
|
|
|
for(a = 0; a < nPolygonCount; a++)
|
|
{
|
|
const Polygon& rCandidate = rPolyPolygon.GetObject(a);
|
|
const sal_uInt16 nPointCount(rCandidate.GetSize());
|
|
|
|
if(nPointCount)
|
|
{
|
|
rOStm << nPointCount;
|
|
|
|
for(sal_uInt16 b(0); b < nPointCount; b++)
|
|
{
|
|
rOStm << rCandidate[b];
|
|
}
|
|
|
|
if(rCandidate.HasFlags())
|
|
{
|
|
rOStm << (sal_uInt8)true;
|
|
|
|
for(sal_uInt16 c(0); c < nPointCount; c++)
|
|
{
|
|
rOStm << (sal_uInt8)rCandidate.GetFlags(c);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rOStm << (sal_uInt8)false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ImplReadExtendedPolyPolygonAction(SvStream& rIStm, PolyPolygon& rPolyPoly)
|
|
{
|
|
rPolyPoly.Clear();
|
|
sal_uInt16 nPolygonCount(0);
|
|
rIStm >> nPolygonCount;
|
|
|
|
for(sal_uInt16 a(0); a < nPolygonCount; a++)
|
|
{
|
|
sal_uInt16 nPointCount(0);
|
|
rIStm >> nPointCount;
|
|
Polygon aCandidate(nPointCount);
|
|
|
|
if(nPointCount)
|
|
{
|
|
for(sal_uInt16 b(0); b < nPointCount; b++)
|
|
{
|
|
rIStm >> aCandidate[b];
|
|
}
|
|
|
|
sal_uInt8 bHasFlags(false);
|
|
rIStm >> bHasFlags;
|
|
|
|
if(bHasFlags)
|
|
{
|
|
sal_uInt8 aPolyFlags(0);
|
|
|
|
for(sal_uInt16 c(0); c < nPointCount; c++)
|
|
{
|
|
rIStm >> aPolyFlags;
|
|
aCandidate.SetFlags(c, (PolyFlags)aPolyFlags);
|
|
}
|
|
}
|
|
}
|
|
|
|
rPolyPoly.Insert(aCandidate);
|
|
}
|
|
}
|
|
|
|
// ----------------
|
|
// - SVMConverter -
|
|
// ----------------
|
|
|
|
SVMConverter::SVMConverter( SvStream& rStm, GDIMetaFile& rMtf, sal_uLong nConvertMode )
|
|
{
|
|
if( !rStm.GetError() )
|
|
{
|
|
if( CONVERT_FROM_SVM1 == nConvertMode )
|
|
ImplConvertFromSVM1( rStm, rMtf );
|
|
else if( CONVERT_TO_SVM1 == nConvertMode )
|
|
ImplConvertToSVM1( rStm, rMtf );
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void SVMConverter::ImplConvertFromSVM1( SvStream& rIStm, GDIMetaFile& rMtf )
|
|
{
|
|
const sal_uLong nPos = rIStm.Tell();
|
|
const sal_uInt16 nOldFormat = rIStm.GetNumberFormatInt();
|
|
|
|
rIStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
|
|
|
|
char aCode[ 5 ];
|
|
Size aPrefSz;
|
|
sal_Int16 nSize;
|
|
sal_Int16 nVersion;
|
|
|
|
// read header
|
|
rIStm.Read( (char*) &aCode, sizeof( aCode ) ); // Kennung
|
|
rIStm >> nSize; // Size
|
|
rIStm >> nVersion; // Version
|
|
rIStm >> aPrefSz.Width(); // PrefSize.Width()
|
|
rIStm >> aPrefSz.Height(); // PrefSize.Height()
|
|
|
|
// check header-magic and version
|
|
if( rIStm.GetError()
|
|
|| ( memcmp( aCode, "SVGDI", sizeof( aCode ) ) != 0 )
|
|
|| ( nVersion != 200 ) )
|
|
{
|
|
rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
|
|
rIStm.SetNumberFormatInt( nOldFormat );
|
|
rIStm.Seek( nPos );
|
|
return;
|
|
}
|
|
|
|
LineInfo aLineInfo( LINE_NONE, 0 );
|
|
Stack aLIStack;
|
|
VirtualDevice aFontVDev;
|
|
rtl_TextEncoding eActualCharSet = osl_getThreadTextEncoding();
|
|
sal_Bool bFatLine = sal_False;
|
|
|
|
// TODO: fix reindentation below if you can accept being blamed by the SCM
|
|
MapMode aMapMode;
|
|
Polygon aActionPoly;
|
|
Rectangle aRect;
|
|
Point aPt, aPt1;
|
|
Size aSz;
|
|
Color aActionColor;
|
|
sal_Int32 nTmp, nTmp1, nActionSize;
|
|
sal_Int32 nActions;
|
|
sal_Int16 nType;
|
|
|
|
sal_uInt32 nUnicodeCommentStreamPos = 0;
|
|
sal_Int32 nUnicodeCommentActionNumber = 0;
|
|
|
|
ImplReadMapMode( rIStm, aMapMode ); // MapMode
|
|
rIStm >> nActions; // Action count
|
|
|
|
rMtf.SetPrefSize( aPrefSz );
|
|
rMtf.SetPrefMapMode( aMapMode );
|
|
size_t nLastPolygonAction(0);
|
|
|
|
for( sal_Int32 i = 0L; i < nActions; i++ )
|
|
{
|
|
rIStm >> nType;
|
|
sal_Int32 nActBegin = rIStm.Tell();
|
|
rIStm >> nActionSize;
|
|
|
|
DBG_ASSERT( ( nType <= 33 ) || ( nType >= 1024 ), "Unknown GDIMetaAction while converting!" );
|
|
|
|
switch( nType )
|
|
{
|
|
case( GDI_PIXEL_ACTION ):
|
|
{
|
|
rIStm >> aPt;
|
|
ImplReadColor( rIStm, aActionColor );
|
|
rMtf.AddAction( new MetaPixelAction( aPt, aActionColor ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_POINT_ACTION ):
|
|
{
|
|
rIStm >> aPt;
|
|
rMtf.AddAction( new MetaPointAction( aPt ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_LINE_ACTION ):
|
|
{
|
|
rIStm >> aPt >> aPt1;
|
|
rMtf.AddAction( new MetaLineAction( aPt, aPt1, aLineInfo ) );
|
|
}
|
|
break;
|
|
|
|
case (GDI_LINEJOIN_ACTION) :
|
|
{
|
|
sal_Int16 nLineJoin(0);
|
|
rIStm >> nLineJoin;
|
|
aLineInfo.SetLineJoin((basegfx::B2DLineJoin)nLineJoin);
|
|
}
|
|
break;
|
|
|
|
case (GDI_LINEDASHDOT_ACTION) :
|
|
{
|
|
sal_Int16 a(0);
|
|
sal_Int32 b(0);
|
|
|
|
rIStm >> a; aLineInfo.SetDashCount(a);
|
|
rIStm >> b; aLineInfo.SetDashLen(b);
|
|
rIStm >> a; aLineInfo.SetDotCount(a);
|
|
rIStm >> b; aLineInfo.SetDotLen(b);
|
|
rIStm >> b; aLineInfo.SetDistance(b);
|
|
|
|
if(((aLineInfo.GetDashCount() && aLineInfo.GetDashLen())
|
|
|| (aLineInfo.GetDotCount() && aLineInfo.GetDotLen()))
|
|
&& aLineInfo.GetDistance())
|
|
{
|
|
aLineInfo.SetStyle(LINE_DASH);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case (GDI_EXTENDEDPOLYGON_ACTION) :
|
|
{
|
|
// read the PolyPolygon in every case
|
|
PolyPolygon aInputPolyPolygon;
|
|
ImplReadExtendedPolyPolygonAction(rIStm, aInputPolyPolygon);
|
|
|
|
// now check if it can be set somewhere
|
|
if(nLastPolygonAction < rMtf.GetActionSize())
|
|
{
|
|
MetaPolyLineAction* pPolyLineAction = dynamic_cast< MetaPolyLineAction* >(rMtf.GetAction(nLastPolygonAction));
|
|
|
|
if(pPolyLineAction)
|
|
{
|
|
// replace MetaPolyLineAction when we have a single polygon. Do not rely on the
|
|
// same point count; the originally written GDI_POLYLINE_ACTION may have been
|
|
// Subdivided for better quality for older usages
|
|
if(1 == aInputPolyPolygon.Count())
|
|
{
|
|
rMtf.ReplaceAction(
|
|
new MetaPolyLineAction(
|
|
aInputPolyPolygon.GetObject(0),
|
|
pPolyLineAction->GetLineInfo()),
|
|
nLastPolygonAction);
|
|
pPolyLineAction->Delete();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MetaPolyPolygonAction* pPolyPolygonAction = dynamic_cast< MetaPolyPolygonAction* >(rMtf.GetAction(nLastPolygonAction));
|
|
|
|
if(pPolyPolygonAction)
|
|
{
|
|
// replace MetaPolyPolygonAction when we have a curved polygon. Do rely on the
|
|
// same sub-polygon count
|
|
if(pPolyPolygonAction->GetPolyPolygon().Count() == aInputPolyPolygon.Count())
|
|
{
|
|
rMtf.ReplaceAction(
|
|
new MetaPolyPolygonAction(
|
|
aInputPolyPolygon),
|
|
nLastPolygonAction);
|
|
pPolyPolygonAction->Delete();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MetaPolygonAction* pPolygonAction = dynamic_cast< MetaPolygonAction* >(rMtf.GetAction(nLastPolygonAction));
|
|
|
|
if(pPolygonAction)
|
|
{
|
|
// replace MetaPolygonAction
|
|
if(1 == aInputPolyPolygon.Count())
|
|
{
|
|
rMtf.ReplaceAction(
|
|
new MetaPolygonAction(
|
|
aInputPolyPolygon.GetObject(0)),
|
|
nLastPolygonAction);
|
|
pPolygonAction->Delete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( GDI_RECT_ACTION ):
|
|
{
|
|
ImplReadRect( rIStm, aRect );
|
|
rIStm >> nTmp >> nTmp1;
|
|
|
|
if( nTmp || nTmp1 )
|
|
rMtf.AddAction( new MetaRoundRectAction( aRect, nTmp, nTmp1 ) );
|
|
else
|
|
{
|
|
rMtf.AddAction( new MetaRectAction( aRect ) );
|
|
|
|
if( bFatLine )
|
|
rMtf.AddAction( new MetaPolyLineAction( aRect, aLineInfo ) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( GDI_ELLIPSE_ACTION ):
|
|
{
|
|
ImplReadRect( rIStm, aRect );
|
|
|
|
if( bFatLine )
|
|
{
|
|
const Polygon aPoly( aRect.Center(), aRect.GetWidth() >> 1, aRect.GetHeight() >> 1 );
|
|
|
|
rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
|
|
rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
|
|
rMtf.AddAction( new MetaPolygonAction( aPoly ) );
|
|
rMtf.AddAction( new MetaPopAction() );
|
|
rMtf.AddAction( new MetaPolyLineAction( aPoly, aLineInfo ) );
|
|
}
|
|
else
|
|
rMtf.AddAction( new MetaEllipseAction( aRect ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_ARC_ACTION ):
|
|
{
|
|
ImplReadRect( rIStm, aRect );
|
|
rIStm >> aPt >> aPt1;
|
|
|
|
if( bFatLine )
|
|
{
|
|
const Polygon aPoly( aRect, aPt, aPt1, POLY_ARC );
|
|
|
|
rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
|
|
rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
|
|
rMtf.AddAction( new MetaPolygonAction( aPoly ) );
|
|
rMtf.AddAction( new MetaPopAction() );
|
|
rMtf.AddAction( new MetaPolyLineAction( aPoly, aLineInfo ) );
|
|
}
|
|
else
|
|
rMtf.AddAction( new MetaArcAction( aRect, aPt, aPt1 ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_PIE_ACTION ):
|
|
{
|
|
ImplReadRect( rIStm, aRect );
|
|
rIStm >> aPt >> aPt1;
|
|
|
|
if( bFatLine )
|
|
{
|
|
const Polygon aPoly( aRect, aPt, aPt1, POLY_PIE );
|
|
|
|
rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
|
|
rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
|
|
rMtf.AddAction( new MetaPolygonAction( aPoly ) );
|
|
rMtf.AddAction( new MetaPopAction() );
|
|
rMtf.AddAction( new MetaPolyLineAction( aPoly, aLineInfo ) );
|
|
}
|
|
else
|
|
rMtf.AddAction( new MetaPieAction( aRect, aPt, aPt1 ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_INVERTRECT_ACTION ):
|
|
case( GDI_HIGHLIGHTRECT_ACTION ):
|
|
{
|
|
ImplReadRect( rIStm, aRect );
|
|
rMtf.AddAction( new MetaPushAction( PUSH_RASTEROP ) );
|
|
rMtf.AddAction( new MetaRasterOpAction( ROP_INVERT ) );
|
|
rMtf.AddAction( new MetaRectAction( aRect ) );
|
|
rMtf.AddAction( new MetaPopAction() );
|
|
}
|
|
break;
|
|
|
|
case( GDI_POLYLINE_ACTION ):
|
|
{
|
|
ImplReadPoly( rIStm, aActionPoly );
|
|
nLastPolygonAction = rMtf.GetActionSize();
|
|
|
|
if( bFatLine )
|
|
rMtf.AddAction( new MetaPolyLineAction( aActionPoly, aLineInfo ) );
|
|
else
|
|
rMtf.AddAction( new MetaPolyLineAction( aActionPoly ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_POLYGON_ACTION ):
|
|
{
|
|
ImplReadPoly( rIStm, aActionPoly );
|
|
|
|
if( bFatLine )
|
|
{
|
|
rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
|
|
rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
|
|
rMtf.AddAction( new MetaPolygonAction( aActionPoly ) );
|
|
rMtf.AddAction( new MetaPopAction() );
|
|
rMtf.AddAction( new MetaPolyLineAction( aActionPoly, aLineInfo ) );
|
|
}
|
|
else
|
|
{
|
|
nLastPolygonAction = rMtf.GetActionSize();
|
|
rMtf.AddAction( new MetaPolygonAction( aActionPoly ) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( GDI_POLYPOLYGON_ACTION ):
|
|
{
|
|
PolyPolygon aPolyPoly;
|
|
|
|
ImplReadPolyPoly( rIStm, aPolyPoly );
|
|
|
|
if( bFatLine )
|
|
{
|
|
rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
|
|
rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
|
|
rMtf.AddAction( new MetaPolyPolygonAction( aPolyPoly ) );
|
|
rMtf.AddAction( new MetaPopAction() );
|
|
|
|
for( sal_uInt16 nPoly = 0, nCount = aPolyPoly.Count(); nPoly < nCount; nPoly++ )
|
|
rMtf.AddAction( new MetaPolyLineAction( aPolyPoly[ nPoly ], aLineInfo ) );
|
|
}
|
|
else
|
|
{
|
|
nLastPolygonAction = rMtf.GetActionSize();
|
|
rMtf.AddAction( new MetaPolyPolygonAction( aPolyPoly ) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( GDI_FONT_ACTION ):
|
|
{
|
|
Font aFont;
|
|
char aName[ 32 ];
|
|
sal_Int32 nWidth, nHeight;
|
|
sal_Int16 nCharSet, nFamily, nPitch, nAlign, nWeight, nUnderline, nStrikeout;
|
|
sal_Int16 nCharOrient, nLineOrient;
|
|
sal_Bool bItalic, bOutline, bShadow, bTransparent;
|
|
|
|
ImplReadColor( rIStm, aActionColor ); aFont.SetColor( aActionColor );
|
|
ImplReadColor( rIStm, aActionColor ); aFont.SetFillColor( aActionColor );
|
|
rIStm.Read( aName, 32 );
|
|
aFont.SetName( UniString( aName, rIStm.GetStreamCharSet() ) );
|
|
rIStm >> nWidth >> nHeight;
|
|
rIStm >> nCharOrient >> nLineOrient;
|
|
rIStm >> nCharSet >> nFamily >> nPitch >> nAlign >> nWeight >> nUnderline >> nStrikeout;
|
|
rIStm >> bItalic >> bOutline >> bShadow >> bTransparent;
|
|
|
|
aFont.SetSize( Size( nWidth, nHeight ) );
|
|
aFont.SetCharSet( (CharSet) nCharSet );
|
|
aFont.SetFamily( (FontFamily) nFamily );
|
|
aFont.SetPitch( (FontPitch) nPitch );
|
|
aFont.SetAlign( (FontAlign) nAlign );
|
|
aFont.SetWeight( ( nWeight == 1 ) ? WEIGHT_LIGHT : ( nWeight == 2 ) ? WEIGHT_NORMAL :
|
|
( nWeight == 3 ) ? WEIGHT_BOLD : WEIGHT_DONTKNOW );
|
|
aFont.SetUnderline( (FontUnderline) nUnderline );
|
|
aFont.SetStrikeout( (FontStrikeout) nStrikeout );
|
|
aFont.SetItalic( bItalic ? ITALIC_NORMAL : ITALIC_NONE );
|
|
aFont.SetOutline( bOutline );
|
|
aFont.SetShadow( bShadow );
|
|
aFont.SetOrientation( nLineOrient );
|
|
aFont.SetTransparent( bTransparent );
|
|
|
|
eActualCharSet = aFont.GetCharSet();
|
|
if ( eActualCharSet == RTL_TEXTENCODING_DONTKNOW )
|
|
eActualCharSet = osl_getThreadTextEncoding();
|
|
|
|
rMtf.AddAction( new MetaFontAction( aFont ) );
|
|
rMtf.AddAction( new MetaTextAlignAction( aFont.GetAlign() ) );
|
|
rMtf.AddAction( new MetaTextColorAction( aFont.GetColor() ) );
|
|
rMtf.AddAction( new MetaTextFillColorAction( aFont.GetFillColor(), !aFont.IsTransparent() ) );
|
|
|
|
// #106172# Track font relevant data in shadow VDev
|
|
aFontVDev.SetFont( aFont );
|
|
}
|
|
break;
|
|
|
|
case( GDI_TEXT_ACTION ):
|
|
{
|
|
sal_Int32 nIndex, nLen;
|
|
|
|
rIStm >> aPt >> nIndex >> nLen >> nTmp;
|
|
if ( nTmp && ( static_cast< sal_uInt32 >( nTmp ) < ( SAL_MAX_UINT16 - 1 ) ) )
|
|
{
|
|
rtl::OString aByteStr = read_uInt8s_AsOString(rIStm, nTmp);
|
|
sal_uInt8 nTerminator = 0;
|
|
rIStm >> nTerminator;
|
|
DBG_ASSERT( nTerminator == 0, "expected string to be NULL terminated" );
|
|
|
|
UniString aStr(rtl::OStringToOUString(aByteStr, eActualCharSet));
|
|
if ( nUnicodeCommentActionNumber == i )
|
|
ImplReadUnicodeComment( nUnicodeCommentStreamPos, rIStm, aStr );
|
|
rMtf.AddAction( new MetaTextAction( aPt, aStr, (sal_uInt16) nIndex, (sal_uInt16) nLen ) );
|
|
}
|
|
rIStm.Seek( nActBegin + nActionSize );
|
|
}
|
|
break;
|
|
|
|
case( GDI_TEXTARRAY_ACTION ):
|
|
{
|
|
sal_Int32* pDXAry = NULL;
|
|
sal_Int32 nIndex, nLen, nAryLen;
|
|
|
|
rIStm >> aPt >> nIndex >> nLen >> nTmp >> nAryLen;
|
|
if ( nTmp && ( static_cast< sal_uInt32 >( nTmp ) < ( SAL_MAX_UINT16 - 1 ) ) )
|
|
{
|
|
rtl::OString aByteStr = read_uInt8s_AsOString(rIStm, nTmp);
|
|
sal_uInt8 nTerminator = 0;
|
|
rIStm >> nTerminator;
|
|
DBG_ASSERT( nTerminator == 0, "expected string to be NULL terminated" );
|
|
|
|
UniString aStr(rtl::OStringToOUString(aByteStr, eActualCharSet));
|
|
|
|
if( nAryLen > 0L )
|
|
{
|
|
sal_Int32 nStrLen( aStr.Len() );
|
|
|
|
pDXAry = new sal_Int32[ Max( nAryLen, nStrLen ) ];
|
|
|
|
for( long j = 0L; j < nAryLen; j++ )
|
|
rIStm >> nTmp, pDXAry[ j ] = nTmp;
|
|
|
|
// #106172# Add last DX array elem, if missing
|
|
if( nAryLen != nStrLen )
|
|
{
|
|
if( nAryLen+1 == nStrLen )
|
|
{
|
|
sal_Int32* pTmpAry = new sal_Int32[nStrLen];
|
|
|
|
aFontVDev.GetTextArray( aStr, pTmpAry, (sal_uInt16) nIndex, (sal_uInt16) nLen );
|
|
|
|
// now, the difference between the
|
|
// last and the second last DX array
|
|
// is the advancement for the last
|
|
// glyph. Thus, to complete our meta
|
|
// action's DX array, just add that
|
|
// difference to last elem and store
|
|
// in very last.
|
|
if( nStrLen > 1 )
|
|
pDXAry[ nStrLen-1 ] = pDXAry[ nStrLen-2 ] + pTmpAry[ nStrLen-1 ] - pTmpAry[ nStrLen-2 ];
|
|
else
|
|
pDXAry[ nStrLen-1 ] = pTmpAry[ nStrLen-1 ]; // len=1: 0th position taken to be 0
|
|
|
|
delete[] pTmpAry;
|
|
}
|
|
#ifdef DBG_UTIL
|
|
else
|
|
OSL_FAIL("More than one DX array element missing on SVM import");
|
|
#endif
|
|
}
|
|
}
|
|
if ( nUnicodeCommentActionNumber == i )
|
|
ImplReadUnicodeComment( nUnicodeCommentStreamPos, rIStm, aStr );
|
|
rMtf.AddAction( new MetaTextArrayAction( aPt, aStr, pDXAry, (sal_uInt16) nIndex, (sal_uInt16) nLen ) );
|
|
|
|
if( pDXAry )
|
|
delete[] pDXAry;
|
|
}
|
|
rIStm.Seek( nActBegin + nActionSize );
|
|
}
|
|
break;
|
|
|
|
case( GDI_STRETCHTEXT_ACTION ):
|
|
{
|
|
sal_Int32 nIndex, nLen, nWidth;
|
|
|
|
rIStm >> aPt >> nIndex >> nLen >> nTmp >> nWidth;
|
|
if ( nTmp && ( static_cast< sal_uInt32 >( nTmp ) < ( SAL_MAX_INT16 - 1 ) ) )
|
|
{
|
|
rtl::OString aByteStr = read_uInt8s_AsOString(rIStm, nTmp);
|
|
sal_uInt8 nTerminator = 0;
|
|
rIStm >> nTerminator;
|
|
DBG_ASSERT( nTerminator == 0, "expected string to be NULL terminated" );
|
|
|
|
UniString aStr(rtl::OStringToOUString(aByteStr, eActualCharSet));
|
|
if ( nUnicodeCommentActionNumber == i )
|
|
ImplReadUnicodeComment( nUnicodeCommentStreamPos, rIStm, aStr );
|
|
rMtf.AddAction( new MetaStretchTextAction( aPt, nWidth, aStr, (sal_uInt16) nIndex, (sal_uInt16) nLen ) );
|
|
}
|
|
rIStm.Seek( nActBegin + nActionSize );
|
|
}
|
|
break;
|
|
|
|
case( GDI_BITMAP_ACTION ):
|
|
{
|
|
Bitmap aBmp;
|
|
|
|
rIStm >> aPt >> aBmp;
|
|
rMtf.AddAction( new MetaBmpAction( aPt, aBmp ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_BITMAPSCALE_ACTION ):
|
|
{
|
|
Bitmap aBmp;
|
|
|
|
rIStm >> aPt >> aSz >> aBmp;
|
|
rMtf.AddAction( new MetaBmpScaleAction( aPt, aSz, aBmp ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_BITMAPSCALEPART_ACTION ):
|
|
{
|
|
Bitmap aBmp;
|
|
Size aSz2;
|
|
|
|
rIStm >> aPt >> aSz >> aPt1 >> aSz2 >> aBmp;
|
|
rMtf.AddAction( new MetaBmpScalePartAction( aPt, aSz, aPt1, aSz2, aBmp ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_PEN_ACTION ):
|
|
{
|
|
sal_Int32 nPenWidth;
|
|
sal_Int16 nPenStyle;
|
|
|
|
ImplReadColor( rIStm, aActionColor );
|
|
rIStm >> nPenWidth >> nPenStyle;
|
|
|
|
aLineInfo.SetStyle( nPenStyle ? LINE_SOLID : LINE_NONE );
|
|
aLineInfo.SetWidth( nPenWidth );
|
|
bFatLine = nPenStyle && !aLineInfo.IsDefault();
|
|
|
|
rMtf.AddAction( new MetaLineColorAction( aActionColor, nPenStyle != 0 ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_FILLBRUSH_ACTION ):
|
|
{
|
|
sal_Int16 nBrushStyle;
|
|
|
|
ImplReadColor( rIStm, aActionColor );
|
|
rIStm.SeekRel( 6L );
|
|
rIStm >> nBrushStyle;
|
|
rMtf.AddAction( new MetaFillColorAction( aActionColor, nBrushStyle != 0 ) );
|
|
rIStm.SeekRel( 2L );
|
|
}
|
|
break;
|
|
|
|
case( GDI_MAPMODE_ACTION ):
|
|
{
|
|
ImplReadMapMode( rIStm, aMapMode );
|
|
rMtf.AddAction( new MetaMapModeAction( aMapMode ) );
|
|
|
|
// #106172# Track font relevant data in shadow VDev
|
|
aFontVDev.SetMapMode( aMapMode );
|
|
}
|
|
break;
|
|
|
|
case( GDI_CLIPREGION_ACTION ):
|
|
{
|
|
Region aRegion;
|
|
sal_Int16 nRegType;
|
|
sal_Int16 bIntersect;
|
|
sal_Bool bClip = sal_False;
|
|
|
|
rIStm >> nRegType >> bIntersect;
|
|
ImplReadRect( rIStm, aRect );
|
|
|
|
switch( nRegType )
|
|
{
|
|
case( 0 ):
|
|
break;
|
|
|
|
case( 1 ):
|
|
{
|
|
Rectangle aRegRect;
|
|
|
|
ImplReadRect( rIStm, aRegRect );
|
|
aRegion = Region( aRegRect );
|
|
bClip = sal_True;
|
|
}
|
|
break;
|
|
|
|
case( 2 ):
|
|
{
|
|
ImplReadPoly( rIStm, aActionPoly );
|
|
aRegion = Region( aActionPoly );
|
|
bClip = sal_True;
|
|
}
|
|
break;
|
|
|
|
case( 3 ):
|
|
{
|
|
PolyPolygon aPolyPoly;
|
|
sal_Int32 nPolyCount;
|
|
|
|
rIStm >> nPolyCount;
|
|
|
|
for( sal_uInt16 j = 0; j < (sal_uInt16) nPolyCount; j++ )
|
|
{
|
|
ImplReadPoly( rIStm, aActionPoly );
|
|
aPolyPoly.Insert( aActionPoly );
|
|
}
|
|
|
|
aRegion = Region( aPolyPoly );
|
|
bClip = sal_True;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if( bIntersect )
|
|
aRegion.Intersect( aRect );
|
|
|
|
rMtf.AddAction( new MetaClipRegionAction( aRegion, bClip ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_MOVECLIPREGION_ACTION ):
|
|
{
|
|
rIStm >> nTmp >> nTmp1;
|
|
rMtf.AddAction( new MetaMoveClipRegionAction( nTmp, nTmp1 ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_ISECTCLIPREGION_ACTION ):
|
|
{
|
|
ImplReadRect( rIStm, aRect );
|
|
rMtf.AddAction( new MetaISectRectClipRegionAction( aRect ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_RASTEROP_ACTION ):
|
|
{
|
|
RasterOp eRasterOp;
|
|
sal_Int16 nRasterOp;
|
|
|
|
rIStm >> nRasterOp;
|
|
|
|
switch( nRasterOp )
|
|
{
|
|
case( 1 ):
|
|
eRasterOp = ROP_INVERT;
|
|
break;
|
|
|
|
case( 4 ):
|
|
case( 5 ):
|
|
eRasterOp = ROP_XOR;
|
|
break;
|
|
|
|
default:
|
|
eRasterOp = ROP_OVERPAINT;
|
|
break;
|
|
}
|
|
|
|
rMtf.AddAction( new MetaRasterOpAction( eRasterOp ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_PUSH_ACTION ):
|
|
{
|
|
aLIStack.Push( new LineInfo( aLineInfo ) );
|
|
rMtf.AddAction( new MetaPushAction( PUSH_ALL ) );
|
|
|
|
// #106172# Track font relevant data in shadow VDev
|
|
aFontVDev.Push();
|
|
}
|
|
break;
|
|
|
|
case( GDI_POP_ACTION ):
|
|
{
|
|
|
|
LineInfo* pLineInfo = (LineInfo*) aLIStack.Pop();
|
|
|
|
// restore line info
|
|
if( pLineInfo )
|
|
{
|
|
aLineInfo = *pLineInfo;
|
|
delete pLineInfo;
|
|
bFatLine = ( LINE_NONE != aLineInfo.GetStyle() ) && !aLineInfo.IsDefault();
|
|
}
|
|
|
|
rMtf.AddAction( new MetaPopAction() );
|
|
|
|
// #106172# Track font relevant data in shadow VDev
|
|
aFontVDev.Pop();
|
|
}
|
|
break;
|
|
|
|
case( GDI_GRADIENT_ACTION ):
|
|
{
|
|
Color aStartCol;
|
|
Color aEndCol;
|
|
sal_Int16 nStyle;
|
|
sal_Int16 nAngle;
|
|
sal_Int16 nBorder;
|
|
sal_Int16 nOfsX;
|
|
sal_Int16 nOfsY;
|
|
sal_Int16 nIntensityStart;
|
|
sal_Int16 nIntensityEnd;
|
|
|
|
ImplReadRect( rIStm, aRect );
|
|
rIStm >> nStyle;
|
|
ImplReadColor( rIStm, aStartCol );
|
|
ImplReadColor( rIStm, aEndCol );
|
|
rIStm >> nAngle >> nBorder >> nOfsX >> nOfsY >> nIntensityStart >> nIntensityEnd;
|
|
|
|
Gradient aGrad( (GradientStyle) nStyle, aStartCol, aEndCol );
|
|
|
|
aGrad.SetAngle( nAngle );
|
|
aGrad.SetBorder( nBorder );
|
|
aGrad.SetOfsX( nOfsX );
|
|
aGrad.SetOfsY( nOfsY );
|
|
aGrad.SetStartIntensity( nIntensityStart );
|
|
aGrad.SetEndIntensity( nIntensityEnd );
|
|
rMtf.AddAction( new MetaGradientAction( aRect, aGrad ) );
|
|
}
|
|
break;
|
|
|
|
case( GDI_TRANSPARENT_COMMENT ):
|
|
{
|
|
PolyPolygon aPolyPoly;
|
|
sal_Int32 nFollowingActionCount;
|
|
sal_Int16 nTrans;
|
|
|
|
rIStm >> aPolyPoly >> nTrans >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaTransparentAction( aPolyPoly, nTrans ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case( GDI_FLOATTRANSPARENT_COMMENT ):
|
|
{
|
|
GDIMetaFile aMtf;
|
|
Point aPos;
|
|
Size aSize;
|
|
Gradient aGradient;
|
|
sal_Int32 nFollowingActionCount;
|
|
|
|
rIStm >> aMtf >> aPos >> aSize >> aGradient >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaFloatTransparentAction( aMtf, aPos, aSize, aGradient ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case( GDI_HATCH_COMMENT ):
|
|
{
|
|
PolyPolygon aPolyPoly;
|
|
Hatch aHatch;
|
|
sal_Int32 nFollowingActionCount;
|
|
|
|
rIStm >> aPolyPoly >> aHatch >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaHatchAction( aPolyPoly, aHatch ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case( GDI_REFPOINT_COMMENT ):
|
|
{
|
|
Point aRefPoint;
|
|
sal_Bool bSet;
|
|
sal_Int32 nFollowingActionCount;
|
|
|
|
rIStm >> aRefPoint >> bSet >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaRefPointAction( aRefPoint, bSet ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
|
|
// #106172# Track font relevant data in shadow VDev
|
|
if( bSet )
|
|
aFontVDev.SetRefPoint( aRefPoint );
|
|
else
|
|
aFontVDev.SetRefPoint();
|
|
}
|
|
break;
|
|
|
|
case( GDI_TEXTLINECOLOR_COMMENT ):
|
|
{
|
|
Color aColor;
|
|
sal_Bool bSet;
|
|
sal_Int32 nFollowingActionCount;
|
|
|
|
rIStm >> aColor >> bSet >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaTextLineColorAction( aColor, bSet ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case( GDI_TEXTLINE_COMMENT ):
|
|
{
|
|
Point aStartPt;
|
|
long nWidth;
|
|
sal_uInt32 nStrikeout;
|
|
sal_uInt32 nUnderline;
|
|
sal_Int32 nFollowingActionCount;
|
|
|
|
rIStm >> aStartPt >> nWidth >> nStrikeout >> nUnderline >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaTextLineAction( aStartPt, nWidth,
|
|
(FontStrikeout) nStrikeout,
|
|
(FontUnderline) nUnderline,
|
|
UNDERLINE_NONE ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case( GDI_GRADIENTEX_COMMENT ):
|
|
{
|
|
PolyPolygon aPolyPoly;
|
|
Gradient aGradient;
|
|
sal_Int32 nFollowingActionCount;
|
|
|
|
rIStm >> aPolyPoly >> aGradient >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaGradientExAction( aPolyPoly, aGradient ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case( GDI_COMMENT_COMMENT ):
|
|
{
|
|
ByteString aComment;
|
|
sal_Int32 nValue;
|
|
sal_uInt32 nDataSize;
|
|
sal_uInt8* pData;
|
|
sal_Int32 nFollowingActionCount;
|
|
|
|
rIStm >> aComment >> nValue >> nDataSize;
|
|
|
|
if( nDataSize )
|
|
{
|
|
pData = new sal_uInt8[ nDataSize ];
|
|
rIStm.Read( pData, nDataSize );
|
|
}
|
|
else
|
|
pData = NULL;
|
|
|
|
rIStm >> nFollowingActionCount;
|
|
ImplSkipActions( rIStm, nFollowingActionCount );
|
|
rMtf.AddAction( new MetaCommentAction( aComment, nValue, pData, nDataSize ) );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
i += nFollowingActionCount;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case ( GDI_UNICODE_COMMENT ):
|
|
{
|
|
nUnicodeCommentActionNumber = i + 1;
|
|
nUnicodeCommentStreamPos = rIStm.Tell() - 6;
|
|
rIStm.SeekRel( nActionSize - 4 );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
rIStm.SeekRel( nActionSize - 4L );
|
|
break;
|
|
}
|
|
}
|
|
|
|
// cleanup push-pop stack if neccessary
|
|
for( void* pLineInfo = aLIStack.Pop(); pLineInfo; pLineInfo = aLIStack.Pop() )
|
|
delete (LineInfo*) pLineInfo;
|
|
|
|
rIStm.SetNumberFormatInt( nOldFormat );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void SVMConverter::ImplConvertToSVM1( SvStream& rOStm, GDIMetaFile& rMtf )
|
|
{
|
|
sal_uLong nCountPos;
|
|
Font aSaveFont;
|
|
const sal_uInt16 nOldFormat = rOStm.GetNumberFormatInt();
|
|
rtl_TextEncoding eActualCharSet = osl_getThreadTextEncoding();
|
|
const Size aPrefSize( rMtf.GetPrefSize() );
|
|
sal_Bool bRop_0_1 = sal_False;
|
|
VirtualDevice aSaveVDev;
|
|
Color aLineCol( COL_BLACK );
|
|
Stack aLineColStack;
|
|
|
|
rOStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
|
|
|
|
//MagicCode schreiben
|
|
rOStm << "SVGDI"; // Kennung
|
|
rOStm << (sal_Int16) 42; // HeaderSize
|
|
rOStm << (sal_Int16) 200; // VERSION
|
|
rOStm << (sal_Int32) aPrefSize.Width();
|
|
rOStm << (sal_Int32) aPrefSize.Height();
|
|
ImplWriteMapMode( rOStm, rMtf.GetPrefMapMode() );
|
|
|
|
// ActionCount wird spaeter geschrieben
|
|
nCountPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4L );
|
|
|
|
const sal_Int32 nActCount = ImplWriteActions( rOStm, rMtf, aSaveVDev, bRop_0_1, aLineCol, aLineColStack, eActualCharSet );
|
|
const sal_uLong nActPos = rOStm.Tell();
|
|
|
|
rOStm.Seek( nCountPos );
|
|
rOStm << nActCount;
|
|
rOStm.Seek( nActPos );
|
|
rOStm.SetNumberFormatInt( nOldFormat );
|
|
|
|
// cleanup push-pop stack if neccessary
|
|
for( void* pCol = aLineColStack.Pop(); pCol; pCol = aLineColStack.Pop() )
|
|
delete (Color*) pCol;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
|
|
VirtualDevice& rSaveVDev, sal_Bool& rRop_0_1,
|
|
Color& rLineCol, Stack& rLineColStack,
|
|
rtl_TextEncoding& rActualCharSet )
|
|
{
|
|
sal_uLong nCount = 0;
|
|
for( size_t i = 0, nActionCount = rMtf.GetActionSize(); i < nActionCount; i++ )
|
|
{
|
|
const MetaAction* pAction = rMtf.GetAction( i );
|
|
|
|
switch( pAction->GetType() )
|
|
{
|
|
case( META_PIXEL_ACTION ):
|
|
{
|
|
MetaPixelAction* pAct = (MetaPixelAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_PIXEL_ACTION;
|
|
rOStm << (sal_Int32) 18;
|
|
rOStm << pAct->GetPoint();
|
|
ImplWriteColor( rOStm, pAct->GetColor() );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_POINT_ACTION ):
|
|
{
|
|
MetaPointAction* pAct = (MetaPointAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_POINT_ACTION;
|
|
rOStm << (sal_Int32) 12;
|
|
rOStm << pAct->GetPoint();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_LINE_ACTION ):
|
|
{
|
|
MetaLineAction* pAct = (MetaLineAction*) pAction;
|
|
const LineInfo& rInfo = pAct->GetLineInfo();
|
|
const bool bFatLine(!rInfo.IsDefault() && (LINE_NONE != rInfo.GetStyle()));
|
|
const bool bLineJoin(bFatLine && basegfx::B2DLINEJOIN_ROUND != rInfo.GetLineJoin());
|
|
const bool bLineDashDot(LINE_DASH == rInfo.GetStyle());
|
|
|
|
if( bFatLine )
|
|
{
|
|
ImplWritePushAction( rOStm );
|
|
ImplWriteLineColor( rOStm, rLineCol, 1, rInfo.GetWidth() );
|
|
|
|
if(bLineJoin)
|
|
{
|
|
rOStm << (sal_Int16) GDI_LINEJOIN_ACTION;
|
|
rOStm << (sal_Int32) 6;
|
|
rOStm << (sal_Int16) rInfo.GetLineJoin();
|
|
}
|
|
|
|
if(bLineDashDot)
|
|
{
|
|
rOStm << (sal_Int16) GDI_LINEDASHDOT_ACTION;
|
|
rOStm << (sal_Int32) 4 + 16;
|
|
rOStm << (sal_Int16)rInfo.GetDashCount();
|
|
rOStm << (sal_Int32)rInfo.GetDashLen();
|
|
rOStm << (sal_Int16)rInfo.GetDotCount();
|
|
rOStm << (sal_Int32)rInfo.GetDotLen();
|
|
rOStm << (sal_Int32)rInfo.GetDistance();
|
|
}
|
|
}
|
|
|
|
rOStm << (sal_Int16) GDI_LINE_ACTION;
|
|
rOStm << (sal_Int32) 20;
|
|
rOStm << pAct->GetStartPoint();
|
|
rOStm << pAct->GetEndPoint();
|
|
nCount++;
|
|
|
|
if( bFatLine )
|
|
{
|
|
ImplWritePopAction( rOStm );
|
|
nCount += 3;
|
|
|
|
if(bLineJoin)
|
|
{
|
|
nCount += 1;
|
|
}
|
|
|
|
if(bLineDashDot)
|
|
{
|
|
nCount += 1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( META_RECT_ACTION ):
|
|
{
|
|
MetaRectAction* pAct = (MetaRectAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_RECT_ACTION;
|
|
rOStm << (sal_Int32) 28;
|
|
ImplWriteRect( rOStm, pAct->GetRect() );
|
|
rOStm << (sal_Int32) 0;
|
|
rOStm << (sal_Int32) 0;
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_ROUNDRECT_ACTION ):
|
|
{
|
|
MetaRoundRectAction* pAct = (MetaRoundRectAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_RECT_ACTION;
|
|
rOStm << (sal_Int32) 28;
|
|
ImplWriteRect( rOStm, pAct->GetRect() );
|
|
rOStm << (sal_Int32) pAct->GetHorzRound();
|
|
rOStm << (sal_Int32) pAct->GetVertRound();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_ELLIPSE_ACTION ):
|
|
{
|
|
MetaEllipseAction* pAct = (MetaEllipseAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_ELLIPSE_ACTION;
|
|
rOStm << (sal_Int32) 20;
|
|
ImplWriteRect( rOStm, pAct->GetRect() );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_ARC_ACTION ):
|
|
{
|
|
MetaArcAction* pAct = (MetaArcAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_ARC_ACTION;
|
|
rOStm << (sal_Int32) 36;
|
|
ImplWriteRect( rOStm, pAct->GetRect() );
|
|
rOStm << pAct->GetStartPoint();
|
|
rOStm << pAct->GetEndPoint();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_PIE_ACTION ):
|
|
{
|
|
MetaPieAction* pAct = (MetaPieAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_PIE_ACTION;
|
|
rOStm << (sal_Int32) 36;
|
|
ImplWriteRect( rOStm, pAct->GetRect() );
|
|
rOStm << pAct->GetStartPoint();
|
|
rOStm << pAct->GetEndPoint();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_CHORD_ACTION ):
|
|
{
|
|
MetaChordAction* pAct = (MetaChordAction*) pAction;
|
|
Polygon aChordPoly( pAct->GetRect(), pAct->GetStartPoint(),
|
|
pAct->GetEndPoint(), POLY_CHORD );
|
|
const sal_uInt16 nPoints = aChordPoly.GetSize();
|
|
|
|
rOStm << (sal_Int16) GDI_POLYGON_ACTION;
|
|
rOStm << (sal_Int32) ( 8 + ( nPoints << 3 ) );
|
|
rOStm << (sal_Int32) nPoints;
|
|
|
|
for( sal_uInt16 n = 0; n < nPoints; n++ )
|
|
rOStm << aChordPoly[ n ];
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_POLYLINE_ACTION ):
|
|
{
|
|
// #i102224#
|
|
MetaPolyLineAction* pAct = (MetaPolyLineAction*) pAction;
|
|
// #i102224# Here the evtl. curved nature of Polygon was
|
|
// ignored (for all those Years). Adapted to at least write
|
|
// a polygon representing the curve as good as possible
|
|
Polygon aSimplePoly;
|
|
pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
|
|
const LineInfo& rInfo = pAct->GetLineInfo();
|
|
const sal_uInt16 nPoints(aSimplePoly.GetSize());
|
|
const bool bFatLine(!rInfo.IsDefault() && (LINE_NONE != rInfo.GetStyle()));
|
|
const bool bLineJoin(bFatLine && basegfx::B2DLINEJOIN_ROUND != rInfo.GetLineJoin());
|
|
const bool bLineDashDot(LINE_DASH == rInfo.GetStyle());
|
|
|
|
if( bFatLine )
|
|
{
|
|
ImplWritePushAction( rOStm );
|
|
ImplWriteLineColor( rOStm, rLineCol, 1, rInfo.GetWidth() );
|
|
|
|
if(bLineJoin)
|
|
{
|
|
rOStm << (sal_Int16) GDI_LINEJOIN_ACTION;
|
|
rOStm << (sal_Int32) 6;
|
|
rOStm << (sal_Int16) rInfo.GetLineJoin();
|
|
}
|
|
}
|
|
|
|
if(bLineDashDot)
|
|
{
|
|
rOStm << (sal_Int16) GDI_LINEDASHDOT_ACTION;
|
|
rOStm << (sal_Int32) 4 + 16;
|
|
rOStm << (sal_Int16)rInfo.GetDashCount();
|
|
rOStm << (sal_Int32)rInfo.GetDashLen();
|
|
rOStm << (sal_Int16)rInfo.GetDotCount();
|
|
rOStm << (sal_Int32)rInfo.GetDotLen();
|
|
rOStm << (sal_Int32)rInfo.GetDistance();
|
|
}
|
|
|
|
rOStm << (sal_Int16) GDI_POLYLINE_ACTION;
|
|
rOStm << (sal_Int32) ( 8 + ( nPoints << 3 ) );
|
|
rOStm << (sal_Int32) nPoints;
|
|
|
|
for( sal_uInt16 n = 0; n < nPoints; n++ )
|
|
{
|
|
rOStm << aSimplePoly[ n ];
|
|
}
|
|
|
|
nCount++;
|
|
|
|
const PolyPolygon aPolyPolygon(pAct->GetPolygon());
|
|
if(ImplWriteExtendedPolyPolygonAction(rOStm, aPolyPolygon, true))
|
|
{
|
|
nCount++;
|
|
}
|
|
|
|
if( bFatLine )
|
|
{
|
|
ImplWritePopAction( rOStm );
|
|
nCount += 3;
|
|
|
|
if(bLineJoin)
|
|
{
|
|
nCount += 1;
|
|
}
|
|
}
|
|
|
|
if(bLineDashDot)
|
|
{
|
|
nCount += 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( META_POLYGON_ACTION ):
|
|
{
|
|
MetaPolygonAction* pAct = (MetaPolygonAction*)pAction;
|
|
// #i102224# Here the evtl. curved nature of Polygon was
|
|
// ignored (for all those Years). Adapted to at least write
|
|
// a polygon representing the curve as good as possible
|
|
Polygon aSimplePoly;
|
|
pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
|
|
const sal_uInt16 nPoints(aSimplePoly.GetSize());
|
|
|
|
rOStm << (sal_Int16) GDI_POLYGON_ACTION;
|
|
rOStm << (sal_Int32) ( 8 + ( nPoints << 3 ) );
|
|
rOStm << (sal_Int32) nPoints;
|
|
|
|
for( sal_uInt16 n = 0; n < nPoints; n++ )
|
|
rOStm << aSimplePoly[ n ];
|
|
|
|
nCount++;
|
|
|
|
const PolyPolygon aPolyPolygon(pAct->GetPolygon());
|
|
if(ImplWriteExtendedPolyPolygonAction(rOStm, aPolyPolygon, true))
|
|
{
|
|
nCount++;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( META_POLYPOLYGON_ACTION ):
|
|
{
|
|
MetaPolyPolygonAction* pAct = (MetaPolyPolygonAction*) pAction;
|
|
ImplWritePolyPolyAction( rOStm, pAct->GetPolyPolygon() );
|
|
nCount++;
|
|
|
|
if(ImplWriteExtendedPolyPolygonAction(rOStm, pAct->GetPolyPolygon(), true))
|
|
{
|
|
nCount++;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( META_TEXT_ACTION ):
|
|
{
|
|
MetaTextAction* pAct = (MetaTextAction*) pAction;
|
|
String aUniText( pAct->GetText() );
|
|
ByteString aText( aUniText, rActualCharSet );
|
|
const sal_uLong nStrLen = aText.Len();
|
|
|
|
if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
|
|
nCount++;
|
|
|
|
rOStm << (sal_Int16) GDI_TEXT_ACTION;
|
|
rOStm << (sal_Int32) ( 24 + ( nStrLen + 1 ) );
|
|
rOStm << pAct->GetPoint();
|
|
rOStm << (sal_Int32) pAct->GetIndex();
|
|
rOStm << (sal_Int32) pAct->GetLen();
|
|
rOStm << (sal_Int32) nStrLen;
|
|
rOStm.Write( aText.GetBuffer(), nStrLen + 1 );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_TEXTARRAY_ACTION ):
|
|
{
|
|
MetaTextArrayAction* pAct = (MetaTextArrayAction*)pAction;
|
|
ByteString aText( pAct->GetText(), rActualCharSet );
|
|
String aUniText( pAct->GetText(), pAct->GetIndex(), pAct->GetLen() );
|
|
sal_uLong nAryLen;
|
|
sal_uLong nLen = pAct->GetLen();
|
|
const sal_uLong nTextLen = aText.Len();
|
|
sal_Int32* pDXArray = pAct->GetDXArray();
|
|
|
|
if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
|
|
nCount++;
|
|
|
|
if( ( nLen + pAct->GetIndex() ) > nTextLen )
|
|
{
|
|
if( pAct->GetIndex() <= nTextLen )
|
|
nLen = nTextLen - pAct->GetIndex();
|
|
else
|
|
nLen = 0UL;
|
|
}
|
|
|
|
if( !pDXArray || !nLen )
|
|
nAryLen = 0;
|
|
else
|
|
nAryLen = nLen; // #105987# Write out all of DX array
|
|
|
|
rOStm << (sal_Int16) GDI_TEXTARRAY_ACTION;
|
|
rOStm << (sal_Int32) ( 28 + ( nLen + 1 ) + ( nAryLen * 4 ) );
|
|
rOStm << pAct->GetPoint();
|
|
rOStm << (sal_Int32) 0;
|
|
rOStm << (sal_Int32) nLen;
|
|
rOStm << (sal_Int32) nLen;
|
|
rOStm << (sal_Int32) nAryLen;
|
|
rOStm.Write( aText.GetBuffer()+pAct->GetIndex(), nLen + 1 );
|
|
|
|
for( sal_uLong n = 0UL ; n < nAryLen; n++ )
|
|
rOStm << (sal_Int32) pDXArray[ n ];
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_STRETCHTEXT_ACTION ):
|
|
{
|
|
MetaStretchTextAction* pAct = (MetaStretchTextAction*) pAction;
|
|
String aUniText( pAct->GetText() );
|
|
ByteString aText( aUniText, rActualCharSet );
|
|
const sal_uLong nStrLen = aText.Len();
|
|
|
|
if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
|
|
nCount++;
|
|
|
|
rOStm << (sal_Int16) GDI_STRETCHTEXT_ACTION;
|
|
rOStm << (sal_Int32) ( 28 + ( nStrLen + 1 ) );
|
|
rOStm << pAct->GetPoint();
|
|
rOStm << (sal_Int32) pAct->GetIndex();
|
|
rOStm << (sal_Int32) pAct->GetLen();
|
|
rOStm << (sal_Int32) nStrLen;
|
|
rOStm << (sal_Int32) pAct->GetWidth();
|
|
rOStm.Write( aText.GetBuffer(), nStrLen + 1 );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_BMP_ACTION ):
|
|
{
|
|
MetaBmpAction* pAct = (MetaBmpAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_BITMAP_ACTION;
|
|
rOStm << (sal_Int32) 12;
|
|
rOStm << pAct->GetPoint();
|
|
rOStm << pAct->GetBitmap();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_BMPSCALE_ACTION ):
|
|
{
|
|
MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_BITMAPSCALE_ACTION;
|
|
rOStm << (sal_Int32) 20;
|
|
rOStm << pAct->GetPoint();
|
|
rOStm << pAct->GetSize();
|
|
rOStm << pAct->GetBitmap();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_BMPSCALEPART_ACTION ):
|
|
{
|
|
MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_BITMAPSCALEPART_ACTION;
|
|
rOStm << (sal_Int32) 36;
|
|
rOStm << pAct->GetDestPoint();
|
|
rOStm << pAct->GetDestSize();
|
|
rOStm << pAct->GetSrcPoint();
|
|
rOStm << pAct->GetSrcSize();
|
|
rOStm << pAct->GetBitmap();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_BMPEX_ACTION ):
|
|
{
|
|
MetaBmpExAction* pAct = (MetaBmpExAction*) pAction;
|
|
const Bitmap aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
|
|
|
|
rOStm << (sal_Int16) GDI_BITMAP_ACTION;
|
|
rOStm << (sal_Int32) 12;
|
|
rOStm << pAct->GetPoint();
|
|
rOStm << aBmp;
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_BMPEXSCALE_ACTION ):
|
|
{
|
|
MetaBmpExScaleAction* pAct = (MetaBmpExScaleAction*) pAction;
|
|
const Bitmap aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
|
|
|
|
rOStm << (sal_Int16) GDI_BITMAPSCALE_ACTION;
|
|
rOStm << (sal_Int32) 20;
|
|
rOStm << pAct->GetPoint();
|
|
rOStm << pAct->GetSize();
|
|
rOStm << aBmp;
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_BMPEXSCALEPART_ACTION ):
|
|
{
|
|
MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction;
|
|
const Bitmap aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
|
|
|
|
rOStm << (sal_Int16) GDI_BITMAPSCALEPART_ACTION;
|
|
rOStm << (sal_Int32) 36;
|
|
rOStm << pAct->GetDestPoint();
|
|
rOStm << pAct->GetDestSize();
|
|
rOStm << pAct->GetSrcPoint();
|
|
rOStm << pAct->GetSrcSize();
|
|
rOStm << aBmp;
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_GRADIENT_ACTION ):
|
|
{
|
|
MetaGradientAction* pAct = (MetaGradientAction*) pAction;
|
|
const Gradient& rGrad = pAct->GetGradient();
|
|
|
|
rOStm << (sal_Int16) GDI_GRADIENT_ACTION;
|
|
rOStm << (sal_Int32) 46;
|
|
ImplWriteRect( rOStm, pAct->GetRect() );
|
|
rOStm << (sal_Int16) rGrad.GetStyle();
|
|
ImplWriteColor( rOStm, rGrad.GetStartColor() );
|
|
ImplWriteColor( rOStm, rGrad.GetEndColor() );
|
|
rOStm << (sal_Int16) rGrad.GetAngle();
|
|
rOStm << (sal_Int16) rGrad.GetBorder();
|
|
rOStm << (sal_Int16) rGrad.GetOfsX();
|
|
rOStm << (sal_Int16) rGrad.GetOfsY();
|
|
rOStm << (sal_Int16) rGrad.GetStartIntensity();
|
|
rOStm << (sal_Int16) rGrad.GetEndIntensity();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_GRADIENTEX_ACTION ):
|
|
{
|
|
const MetaGradientExAction* pA = (MetaGradientExAction*) pAction;
|
|
sal_uLong nOldPos, nNewPos;
|
|
|
|
// write RefPoint comment
|
|
rOStm << (sal_Int16) GDI_GRADIENTEX_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write data
|
|
rOStm << pA->GetPolyPolygon() << pA->GetGradient();
|
|
rOStm << (sal_Int32) 0; // number of actions that follow this comment
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos );
|
|
rOStm.Seek( nNewPos );
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_WALLPAPER_ACTION ):
|
|
{
|
|
MetaWallpaperAction* pAct = (MetaWallpaperAction*) pAction;
|
|
const Color& rColor = pAct->GetWallpaper().GetColor();
|
|
|
|
ImplWritePushAction( rOStm );
|
|
ImplWriteLineColor( rOStm, rColor, 1 );
|
|
ImplWriteFillColor( rOStm, rColor, 1 );
|
|
|
|
rOStm << (sal_Int16) GDI_RECT_ACTION;
|
|
rOStm << (sal_Int32) 28;
|
|
ImplWriteRect( rOStm, pAct->GetRect() );
|
|
rOStm << (sal_Int32) 0;
|
|
rOStm << (sal_Int32) 0;
|
|
|
|
ImplWritePopAction( rOStm );
|
|
nCount += 5;
|
|
}
|
|
break;
|
|
|
|
case( META_CLIPREGION_ACTION ):
|
|
{
|
|
MetaClipRegionAction* pAct = (MetaClipRegionAction*) pAction;
|
|
const Region& rRegion = pAct->GetRegion();
|
|
Rectangle aClipRect;
|
|
|
|
rOStm << (sal_Int16) GDI_CLIPREGION_ACTION;
|
|
rOStm << (sal_Int32) 24;
|
|
|
|
if( pAct->IsClipping() )
|
|
{
|
|
aClipRect = rRegion.GetBoundRect();
|
|
rOStm << (sal_Int16) 1;
|
|
}
|
|
else
|
|
rOStm << (sal_Int16) 0;
|
|
|
|
rOStm << (sal_Int16) 0;
|
|
ImplWriteRect( rOStm, aClipRect );
|
|
|
|
if( pAct->IsClipping() )
|
|
ImplWriteRect( rOStm, aClipRect );
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_ISECTRECTCLIPREGION_ACTION ):
|
|
{
|
|
MetaISectRectClipRegionAction* pAct = (MetaISectRectClipRegionAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_ISECTCLIPREGION_ACTION;
|
|
rOStm << (sal_Int32) 20;
|
|
rOStm << pAct->GetRect();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_MOVECLIPREGION_ACTION ):
|
|
{
|
|
MetaMoveClipRegionAction* pAct = (MetaMoveClipRegionAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_MOVECLIPREGION_ACTION;
|
|
rOStm << (sal_Int32) 12;
|
|
rOStm << (sal_Int32) pAct->GetHorzMove();
|
|
rOStm << (sal_Int32) pAct->GetVertMove();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_LINECOLOR_ACTION ):
|
|
{
|
|
MetaLineColorAction* pAct = (MetaLineColorAction*) pAction;
|
|
ImplWriteLineColor( rOStm, rLineCol = pAct->GetColor(), pAct->IsSetting() ? 1 : 0 );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_FILLCOLOR_ACTION ):
|
|
{
|
|
MetaFillColorAction* pAct = (MetaFillColorAction*) pAction;
|
|
ImplWriteFillColor( rOStm, pAct->GetColor(), pAct->IsSetting() ? 1 : 0 );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_FONT_ACTION ):
|
|
{
|
|
rSaveVDev.SetFont( ( (MetaFontAction*) pAction )->GetFont() );
|
|
ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_TEXTCOLOR_ACTION ):
|
|
{
|
|
Font aSaveFont( rSaveVDev.GetFont() );
|
|
|
|
aSaveFont.SetColor( ( (MetaTextColorAction*) pAction )->GetColor() );
|
|
rSaveVDev.SetFont( aSaveFont );
|
|
ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_TEXTFILLCOLOR_ACTION ):
|
|
{
|
|
MetaTextFillColorAction* pAct = (MetaTextFillColorAction*) pAction;
|
|
Font aSaveFont( rSaveVDev.GetFont() );
|
|
|
|
if( pAct->IsSetting() )
|
|
aSaveFont.SetFillColor( pAct->GetColor() );
|
|
else
|
|
aSaveFont.SetFillColor( Color( COL_TRANSPARENT ) );
|
|
|
|
rSaveVDev.SetFont( aSaveFont );
|
|
ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_TEXTALIGN_ACTION ):
|
|
{
|
|
Font aSaveFont( rSaveVDev.GetFont() );
|
|
|
|
aSaveFont.SetAlign( ( (MetaTextAlignAction*) pAction )->GetTextAlign() );
|
|
rSaveVDev.SetFont( aSaveFont );
|
|
ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_MAPMODE_ACTION ):
|
|
{
|
|
MetaMapModeAction* pAct = (MetaMapModeAction*) pAction;
|
|
|
|
rOStm << (sal_Int16) GDI_MAPMODE_ACTION;
|
|
rOStm << (sal_Int32) 30;
|
|
ImplWriteMapMode( rOStm, pAct->GetMapMode() );
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_PUSH_ACTION ):
|
|
{
|
|
ImplWritePushAction( rOStm );
|
|
rLineColStack.Push( new Color( rLineCol ) );
|
|
rSaveVDev.Push();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_POP_ACTION ):
|
|
{
|
|
Color* pCol = (Color*) rLineColStack.Pop();
|
|
|
|
if( pCol )
|
|
{
|
|
rLineCol = *pCol;
|
|
delete pCol;
|
|
}
|
|
|
|
ImplWritePopAction( rOStm );
|
|
rSaveVDev.Pop();
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_RASTEROP_ACTION ):
|
|
{
|
|
MetaRasterOpAction* pAct = (MetaRasterOpAction*) pAction;
|
|
|
|
if( ( pAct->GetRasterOp() != ROP_0 ) && ( pAct->GetRasterOp() != ROP_1 ) )
|
|
{
|
|
sal_Int16 nRasterOp;
|
|
|
|
// Falls vorher ROP_0/1 gesetzt war, alten
|
|
// Zustand durch Pop erst wieder herstellen
|
|
if( rRop_0_1 )
|
|
{
|
|
ImplWritePopAction( rOStm );
|
|
rSaveVDev.Pop();
|
|
rRop_0_1 = sal_False;
|
|
nCount++;
|
|
}
|
|
|
|
switch( pAct->GetRasterOp() )
|
|
{
|
|
case( ROP_OVERPAINT ) : nRasterOp = 0; break;
|
|
case( ROP_XOR ) : nRasterOp = 4; break;
|
|
case( ROP_INVERT ): nRasterOp = 1; break;
|
|
default: nRasterOp = 0; break;
|
|
}
|
|
|
|
ImplWriteRasterOpAction( rOStm, nRasterOp );
|
|
nCount++;
|
|
}
|
|
else
|
|
{
|
|
ImplWritePushAction( rOStm );
|
|
rSaveVDev.Push();
|
|
|
|
if( pAct->GetRasterOp() == ROP_0 )
|
|
{
|
|
ImplWriteLineColor( rOStm, COL_BLACK, 1 );
|
|
ImplWriteFillColor( rOStm, COL_BLACK, 1 );
|
|
}
|
|
else
|
|
{
|
|
ImplWriteLineColor( rOStm, COL_WHITE, 1 );
|
|
ImplWriteFillColor( rOStm, COL_WHITE, 1 );
|
|
}
|
|
|
|
ImplWriteRasterOpAction( rOStm, 0 );
|
|
rRop_0_1 = sal_True;
|
|
nCount += 4;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case( META_TRANSPARENT_ACTION ):
|
|
{
|
|
const PolyPolygon& rPolyPoly = ( (MetaTransparentAction*) pAction )->GetPolyPolygon();
|
|
const sal_Int16 nTrans = ( (MetaTransparentAction*) pAction )->GetTransparence();
|
|
const sal_Int16 nBrushStyle = ( nTrans < 38 ) ? 8 : ( nTrans < 63 ) ? 9 : 10;
|
|
sal_uLong nOldPos, nNewPos;
|
|
|
|
// write transparence comment
|
|
rOStm << (sal_Int16) GDI_TRANSPARENT_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write comment data
|
|
rOStm << rPolyPoly;
|
|
rOStm << nTrans;
|
|
rOStm << (sal_Int32) 15; // number of actions that follow this comment
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos );
|
|
rOStm.Seek( nNewPos );
|
|
|
|
{
|
|
// write actions for transparence
|
|
ImplWritePushAction( rOStm );
|
|
{
|
|
ImplWriteRasterOpAction( rOStm, 4 );
|
|
ImplWritePolyPolyAction( rOStm, rPolyPoly );
|
|
|
|
ImplWritePushAction( rOStm );
|
|
{
|
|
ImplWriteRasterOpAction( rOStm, 2 );
|
|
ImplWriteFillColor( rOStm, COL_BLACK, nBrushStyle );
|
|
ImplWritePolyPolyAction( rOStm, rPolyPoly );
|
|
}
|
|
ImplWritePopAction( rOStm );
|
|
|
|
ImplWriteRasterOpAction( rOStm, 4 );
|
|
ImplWritePolyPolyAction( rOStm, rPolyPoly );
|
|
}
|
|
ImplWritePopAction( rOStm );
|
|
|
|
ImplWritePushAction( rOStm );
|
|
{
|
|
ImplWriteFillColor( rOStm, Color(), 0 );
|
|
ImplWritePolyPolyAction( rOStm, rPolyPoly );
|
|
}
|
|
ImplWritePopAction( rOStm );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
nCount += 15;
|
|
#endif
|
|
}
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_FLOATTRANSPARENT_ACTION ):
|
|
{
|
|
const MetaFloatTransparentAction* pA = (MetaFloatTransparentAction*) pAction;
|
|
const GDIMetaFile& rTransMtf = pA->GetGDIMetaFile();
|
|
const Point& rPos = pA->GetPoint();
|
|
const Size& rSize = pA->GetSize();
|
|
const Gradient& rGradient = pA->GetGradient();
|
|
sal_uLong nOldPos, nNewPos;
|
|
|
|
// write RefPoint comment
|
|
rOStm << (sal_Int16) GDI_FLOATTRANSPARENT_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write comment data
|
|
rOStm << rTransMtf << rPos << rSize << rGradient;
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos + 4 );
|
|
rOStm.Seek( ( nOldPos = nNewPos ) + 4 );
|
|
|
|
{
|
|
// write actions for float transparence
|
|
sal_uLong nAddCount;
|
|
GDIMetaFile aMtf( rTransMtf );
|
|
const Size aSrcSize( rTransMtf.GetPrefSize() );
|
|
Point aSrcPt( rTransMtf.GetPrefMapMode().GetOrigin() );
|
|
const double fScaleX = aSrcSize.Width() ? (double) rSize.Width() / aSrcSize.Width() : 1.0;
|
|
const double fScaleY = aSrcSize.Height() ? (double) rSize.Height() / aSrcSize.Height() : 1.0;
|
|
long nMoveX, nMoveY;
|
|
|
|
if( fScaleX != 1.0 || fScaleY != 1.0 )
|
|
{
|
|
aMtf.Scale( fScaleX, fScaleY );
|
|
aSrcPt.X() = FRound( aSrcPt.X() * fScaleX ), aSrcPt.Y() = FRound( aSrcPt.Y() * fScaleY );
|
|
}
|
|
|
|
nMoveX = rPos.X() - aSrcPt.X(), nMoveY = rPos.Y() - aSrcPt.Y();
|
|
|
|
if( nMoveX || nMoveY )
|
|
aMtf.Move( nMoveX, nMoveY );
|
|
|
|
nAddCount = ImplWriteActions( rOStm, aMtf, rSaveVDev, rRop_0_1, rLineCol, rLineColStack, rActualCharSet );
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) nAddCount;
|
|
rOStm.Seek( nNewPos );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
nCount += nAddCount;
|
|
#endif
|
|
}
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_HATCH_ACTION ):
|
|
{
|
|
const MetaHatchAction* pA = (MetaHatchAction*) pAction;
|
|
const PolyPolygon& rPolyPoly = pA->GetPolyPolygon();
|
|
const Hatch& rHatch = pA->GetHatch();
|
|
sal_uLong nOldPos, nNewPos, nAddCount;
|
|
|
|
// write hatch comment
|
|
rOStm << (sal_Int16) GDI_HATCH_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write comment data
|
|
rOStm << rPolyPoly;
|
|
rOStm << rHatch;
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos + 4 );
|
|
rOStm.Seek( ( nOldPos = nNewPos ) + 4 );
|
|
|
|
{
|
|
// write actions for hatch
|
|
VirtualDevice aVDev;
|
|
GDIMetaFile aTmpMtf;
|
|
|
|
aVDev.AddHatchActions( rPolyPoly, rHatch, aTmpMtf );
|
|
nAddCount = ImplWriteActions( rOStm, aTmpMtf, rSaveVDev, rRop_0_1, rLineCol, rLineColStack, rActualCharSet );
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) nAddCount;
|
|
rOStm.Seek( nNewPos );
|
|
|
|
#ifdef CVTSVM_WRITE_SUBACTIONCOUNT
|
|
nCount += nAddCount;
|
|
#endif
|
|
}
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_REFPOINT_ACTION ):
|
|
{
|
|
const MetaRefPointAction* pA = (MetaRefPointAction*) pAction;
|
|
const Point& rRefPoint = pA->GetRefPoint();
|
|
const sal_Bool bSet = pA->IsSetting();
|
|
sal_uLong nOldPos, nNewPos;
|
|
|
|
// write RefPoint comment
|
|
rOStm << (sal_Int16) GDI_REFPOINT_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write data
|
|
rOStm << rRefPoint << bSet;
|
|
rOStm << (sal_Int32) 0; // number of actions that follow this comment
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos );
|
|
rOStm.Seek( nNewPos );
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_TEXTLINECOLOR_ACTION ):
|
|
{
|
|
const MetaTextLineColorAction* pA = (MetaTextLineColorAction*) pAction;
|
|
const Color& rColor = pA->GetColor();
|
|
const sal_Bool bSet = pA->IsSetting();
|
|
sal_uLong nOldPos, nNewPos;
|
|
|
|
// write RefPoint comment
|
|
rOStm << (sal_Int16) GDI_TEXTLINECOLOR_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write data
|
|
rOStm << rColor << bSet;
|
|
rOStm << (sal_Int32) 0; // number of actions that follow this comment
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos );
|
|
rOStm.Seek( nNewPos );
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_TEXTLINE_ACTION ):
|
|
{
|
|
const MetaTextLineAction* pA = (MetaTextLineAction*) pAction;
|
|
const Point& rStartPt = pA->GetStartPoint();
|
|
const long nWidth = pA->GetWidth();
|
|
const FontStrikeout eStrikeout = pA->GetStrikeout();
|
|
const FontUnderline eUnderline = pA->GetUnderline();
|
|
sal_uLong nOldPos, nNewPos;
|
|
|
|
// write RefPoint comment
|
|
rOStm << (sal_Int16) GDI_TEXTLINE_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write data
|
|
rOStm << rStartPt << nWidth <<
|
|
static_cast<sal_uInt32>(eStrikeout) <<
|
|
static_cast<sal_uInt32>(eUnderline);
|
|
rOStm << (sal_Int32) 0; // number of actions that follow this comment
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos );
|
|
rOStm.Seek( nNewPos );
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
case( META_EPS_ACTION ):
|
|
break;
|
|
|
|
case( META_COMMENT_ACTION ):
|
|
{
|
|
const MetaCommentAction* pA = (MetaCommentAction*) pAction;
|
|
const sal_uInt32 nDataSize = pA->GetDataSize();
|
|
sal_uLong nOldPos, nNewPos;
|
|
|
|
// write RefPoint comment
|
|
rOStm << (sal_Int16) GDI_COMMENT_COMMENT;
|
|
|
|
// we'll write the ActionSize later
|
|
nOldPos = rOStm.Tell();
|
|
rOStm.SeekRel( 4 );
|
|
|
|
// write data
|
|
rOStm << pA->GetComment() << pA->GetValue() << nDataSize;
|
|
|
|
if( nDataSize )
|
|
rOStm.Write( pA->GetData(), nDataSize );
|
|
|
|
rOStm << (sal_Int32) 0; // number of actions that follow this comment
|
|
|
|
// calculate and write ActionSize of comment
|
|
nNewPos = rOStm.Tell();
|
|
rOStm.Seek( nOldPos );
|
|
rOStm << (sal_Int32) ( nNewPos - nOldPos );
|
|
rOStm.Seek( nNewPos );
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
|
|
#ifdef DBG_UTIL
|
|
default:
|
|
{
|
|
rtl::OStringBuffer aStr(RTL_CONSTASCII_STRINGPARAM(
|
|
"Missing implementation for Action#: "));
|
|
aStr.append(static_cast<sal_Int32>(pAction->GetType()));
|
|
aStr.append('!');
|
|
OSL_FAIL(aStr.getStr());
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
/*
|
|
case( META_TEXTRECT_ACTION ):
|
|
{
|
|
MetaTextRectAction* pAct = (MetaTextRectAction*) pAction;
|
|
|
|
rOStm << ;
|
|
rOStm << ;
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
*/
|
|
|
|
/*
|
|
case( META_MASK_ACTION ):
|
|
{
|
|
MetaMaskAction* pAct = (MetaMaskAction*) pAction;
|
|
|
|
rOStm << ;
|
|
rOStm << ;
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
*/
|
|
|
|
/*
|
|
case( META_MASKSCALE_ACTION ):
|
|
{
|
|
MetaMaskScaleAction* pAct = (MetaMaskScaleAction*) pAction;
|
|
|
|
rOStm << ;
|
|
rOStm << ;
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
*/
|
|
|
|
/*
|
|
case( META_MASKSCALEPART_ACTION ):
|
|
{
|
|
MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
|
|
|
|
rOStm << ;
|
|
rOStm << ;
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
*/
|
|
|
|
/*
|
|
case( META_ISECTREGIONCLIPREGION_ACTION ):
|
|
{
|
|
MetaISectRegionClipRegionAction* pAct = (MetaISectRegionClipRegionAction*) pAction;
|
|
|
|
rOStm << ;
|
|
rOStm << ;
|
|
|
|
nCount++;
|
|
}
|
|
break;
|
|
*/
|
|
}
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|