Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / filter / source / graphicfilter / eps / eps.cxx
blob: 6a892e4b964c0d846f1827069d287ab2efbd0c58 [file] [log] [blame]
/**************************************************************
*
* 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 <vcl/sv.h>
#include <tools/stream.hxx>
#include <tools/bigint.hxx>
#include <tools/poly.hxx>
#include <vcl/svapp.hxx>
#include <vcl/metaact.hxx>
#include <vcl/graph.hxx>
#include <vcl/bmpacc.hxx>
#include <vcl/region.hxx>
#include <vcl/metric.hxx>
#include <vcl/font.hxx>
#include <vcl/virdev.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/cvtgrf.hxx>
#include <vcl/gradient.hxx>
#include <svl/solar.hrc>
#include <svtools/fltcall.hxx>
#include <svtools/FilterConfigItem.hxx>
#include <vcl/graphictools.hxx>
#include "strings.hrc"
#include <math.h>
#define POSTSCRIPT_BOUNDINGSEARCH 0x1000 // we only try to get the BoundingBox
// in the first 4096 bytes
#define EPS_PREVIEW_TIFF 1
#define EPS_PREVIEW_EPSI 2
#define PS_LINESIZE 70 // maximum number of characters a line in the output
#define PS_NONE 0 // formating mode: action which is inserted behind the output
#define PS_SPACE 1
#define PS_RET 2
#define PS_WRAP 4
// -----------------------------Feld-Typen-------------------------------
struct ChrSet
{
struct ChrSet * pSucc;
sal_uInt8 nSet;
String aName;
FontWeight eWeight;
};
struct StackMember
{
struct StackMember * pSucc;
Color aGlobalCol;
sal_Bool bLineCol;
Color aLineCol;
sal_Bool bFillCol;
Color aFillCol;
Color aTextCol;
sal_Bool bTextFillCol;
Color aTextFillCol;
Color aBackgroundCol;
Font aFont;
TextAlign eTextAlign;
double fLineWidth;
double fMiterLimit;
SvtGraphicStroke::CapType eLineCap;
SvtGraphicStroke::JoinType eJoinType;
SvtGraphicStroke::DashArray aDashArray;
};
struct PSLZWCTreeNode
{
PSLZWCTreeNode* pBrother; // naechster Knoten, der den selben Vater hat
PSLZWCTreeNode* pFirstChild; // erster Sohn
sal_uInt16 nCode; // Der Code fuer den String von Pixelwerten, der sich ergibt, wenn
sal_uInt16 nValue; // Der Pixelwert
};
class PSWriter
{
private:
sal_Bool mbStatus;
sal_uLong mnLevelWarning; // number of embedded eps files which was not exported
sal_uLong mnLastPercent; // Mit welcher Zahl pCallback zuletzt aufgerufen wurde.
sal_uInt32 mnLatestPush; // offset auf streamposition, an der zuletzt gepusht wurde
long mnLevel; // dialog options
sal_Bool mbGrayScale;
sal_Bool mbCompression;
sal_Int32 mnPreview;
sal_Int32 mnTextMode;
SvStream* mpPS;
const GDIMetaFile* pMTF;
GDIMetaFile* pAMTF; // only created if Graphics is not a Metafile
VirtualDevice aVDev;
double nBoundingX1; // this represents the bounding box
double nBoundingY1;
double nBoundingX2;
double nBoundingY2;
//
StackMember* pGDIStack;
sal_uLong mnCursorPos; // aktuelle Cursorposition im Output
Color aColor; // aktuelle Farbe die fuer den Output benutzt wird
sal_Bool bLineColor;
Color aLineColor; // aktuelle GDIMetafile Farbeinstellungen
sal_Bool bFillColor; //
Color aFillColor; //
Color aTextColor; //
sal_Bool bTextFillColor; //
Color aTextFillColor; //
Color aBackgroundColor; //
sal_Bool bRegionChanged;
TextAlign eTextAlign; //
double fLineWidth;
double fMiterLimit;
SvtGraphicStroke::CapType eLineCap;
SvtGraphicStroke::JoinType eJoinType;
SvtGraphicStroke::DashArray aDashArray;
Font maFont;
Font maLastFont;
sal_uInt8 nChrSet;
ChrSet* pChrSetList; // Liste der Character-Sets
sal_uInt8 nNextChrSetId; // die erste unbenutzte ChrSet-Id
PSLZWCTreeNode* pTable; // LZW compression data
PSLZWCTreeNode* pPrefix; // the compression is as same as the TIFF compression
sal_uInt16 nDataSize;
sal_uInt16 nClearCode;
sal_uInt16 nEOICode;
sal_uInt16 nTableSize;
sal_uInt16 nCodeSize;
sal_uLong nOffset;
sal_uLong dwShift;
com::sun::star::uno::Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator;
void ImplWriteProlog( const Graphic* pPreviewEPSI = NULL );
void ImplWriteEpilog();
void ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev );
// this method makes LF's, space inserting and word wrapping as used in all nMode
// parameters
inline void ImplExecMode( sal_uLong nMode );
// writes char[] + LF to stream
inline void ImplWriteLine( const char*, sal_uLong nMode = PS_RET );
// writes ( nNumb / 10^nCount ) in ASCII format to stream
void ImplWriteF( sal_Int32 nNumb, sal_uLong nCount = 3, sal_uLong nMode = PS_SPACE );
// writes a double in ASCII format to stream
void ImplWriteDouble( double, sal_uLong nMode = PS_SPACE );
// writes a long in ASCII format to stream
void ImplWriteLong( sal_Int32 nNumb, sal_uLong nMode = PS_SPACE );
// writes a byte in ASCII format to stream
void ImplWriteByte( sal_uInt8 nNumb, sal_uLong nMode = PS_SPACE );
// writes a byte in ASCII (hex) format to stream
void ImplWriteHexByte( sal_uInt8 nNumb, sal_uLong nMode = PS_WRAP );
// writes nNumb as number from 0.000 till 1.000 in ASCII format to stream
void ImplWriteB1( sal_uInt8 nNumb, sal_uLong nMode = PS_SPACE );
inline void ImplWritePoint( const Point&, sal_uInt32 nMode = PS_SPACE );
void ImplMoveTo( const Point&, sal_uInt32 nMode = PS_SPACE );
void ImplLineTo( const Point&, sal_uInt32 nMode = PS_SPACE );
void ImplCurveTo( const Point& rP1, const Point& rP2, const Point& rP3, sal_uInt32 nMode = PS_SPACE );
void ImplTranslate( const double& fX, const double& fY, sal_uInt32 nMode = PS_RET );
void ImplScale( const double& fX, const double& fY, sal_uInt32 nMode = PS_RET );
void ImplWriteLine( const Polygon & rPolygon );
void ImplAddPath( const Polygon & rPolygon );
void ImplWriteLineInfo( double fLineWidth, double fMiterLimit, SvtGraphicStroke::CapType eLineCap,
SvtGraphicStroke::JoinType eJoinType, SvtGraphicStroke::DashArray& rDashArray );
void ImplWriteLineInfo( const LineInfo& rLineInfo );
void ImplRect( const Rectangle & rRectangle );
void ImplRectFill ( const Rectangle & rRectangle );
void ImplWriteGradient( const PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev );
void ImplIntersect( const PolyPolygon& rPolyPoly );
void ImplPolyPoly( const PolyPolygon & rPolyPolygon, sal_Bool bTextOutline = sal_False );
void ImplPolyLine( const Polygon & rPolygon );
void ImplSetClipRegion( Region& rRegion );
void ImplBmp( Bitmap*, Bitmap*, const Point &, double nWidth, double nHeight );
void ImplText( const String& rUniString, const Point& rPos, const sal_Int32* pDXArry, sal_Int32 nWidth, VirtualDevice& rVDev );
void ImplSetAttrForText( const Point & rPoint );
void ImplWriteCharacter( sal_Char );
void ImplWriteString( const ByteString&, VirtualDevice& rVDev, const sal_Int32* pDXArry = NULL, sal_Bool bStretch = sal_False );
void ImplDefineFont( const char*, const char* );
void ImplClosePathDraw( sal_uLong nMode = PS_RET );
void ImplPathDraw();
inline void ImplWriteLineColor( sal_uLong nMode = PS_RET );
inline void ImplWriteFillColor( sal_uLong nMode = PS_RET );
inline void ImplWriteTextColor( sal_uLong nMode = PS_RET );
inline void ImplWriteTextFillColor( sal_uLong nMode = PS_RET );
void ImplWriteColor( sal_uLong nMode );
double ImplGetScaling( const MapMode& );
void ImplGetMapMode( const MapMode& );
sal_Bool ImplGetBoundingBox( double* nNumb, sal_uInt8* pSource, sal_uLong nSize );
sal_uInt8* ImplSearchEntry( sal_uInt8* pSource, sal_uInt8* pDest, sal_uLong nComp, sal_uLong nSize );
// LZW methods
void StartCompression();
void Compress( sal_uInt8 nSrc );
void EndCompression();
inline void WriteBits( sal_uInt16 nCode, sal_uInt16 nCodeLen );
public:
sal_Bool WritePS( const Graphic& rGraphic, SvStream& rTargetStream, FilterConfigItem* );
PSWriter();
~PSWriter();
};
//========================== Methoden von PSWriter ==========================
//---------------------------------------------------------------------------------
PSWriter::PSWriter()
{
pAMTF = NULL;
}
PSWriter::~PSWriter()
{
delete pAMTF;
}
//---------------------------------------------------------------------------------
sal_Bool PSWriter::WritePS( const Graphic& rGraphic, SvStream& rTargetStream, FilterConfigItem* pFilterConfigItem )
{
sal_uInt32 nStreamPosition = 0, nPSPosition = 0; // -Wall warning, unset, check
mbStatus = sal_True;
mnPreview = 0;
mnLevelWarning = 0;
mnLastPercent = 0;
mnLatestPush = 0xEFFFFFFE;
if ( pFilterConfigItem )
{
xStatusIndicator = pFilterConfigItem->GetStatusIndicator();
if ( xStatusIndicator.is() )
{
rtl::OUString aMsg;
xStatusIndicator->start( aMsg, 100 );
}
}
mpPS = &rTargetStream;
mpPS->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
// default values for the dialog options
mnLevel = 2;
mbGrayScale = sal_False;
mbCompression = sal_True;
mnTextMode = 0; // default0 : export glyph outlines
// try to get the dialog selection
if ( pFilterConfigItem )
{
ByteString aResMgrName( "eps" );
ResMgr* pResMgr;
pResMgr = ResMgr::CreateResMgr( aResMgrName.GetBuffer(), Application::GetSettings().GetUILocale() );
if( pResMgr )
{
String aPreviewStr( RTL_CONSTASCII_USTRINGPARAM( "Preview" ) );
String aVersionStr( RTL_CONSTASCII_USTRINGPARAM( "Version" ) );
String aColorStr( RTL_CONSTASCII_USTRINGPARAM( "ColorFormat" ) );
String aComprStr( RTL_CONSTASCII_USTRINGPARAM( "CompressionMode" ) );
mnPreview = pFilterConfigItem->ReadInt32( aPreviewStr, 1 );
mnLevel = pFilterConfigItem->ReadInt32( aVersionStr, 2 );
if ( mnLevel != 1 )
mnLevel = 2;
mbGrayScale = pFilterConfigItem->ReadInt32( aColorStr, 1 ) == 2;
mbCompression = pFilterConfigItem->ReadInt32( aComprStr, 1 ) == 1;
String sTextMode( RTL_CONSTASCII_USTRINGPARAM( "TextMode" ) );
mnTextMode = pFilterConfigItem->ReadInt32( sTextMode, 0 );
if ( mnTextMode > 2 )
mnTextMode = 0;
delete pResMgr;
}
}
// compression is not available for Level 1
if ( mnLevel == 1 )
{
mbGrayScale = sal_True;
mbCompression = sal_False;
}
if ( mnPreview & EPS_PREVIEW_TIFF )
{
rTargetStream << (sal_uInt32)0xC6D3D0C5;
nStreamPosition = rTargetStream.Tell();
rTargetStream << (sal_uInt32)0 << (sal_uInt32)0 << (sal_uInt32)0 << (sal_uInt32)0
<< nStreamPosition + 26 << (sal_uInt32)0 << (sal_uInt16)0xffff;
sal_uInt32 nErrCode;
if ( mbGrayScale )
{
BitmapEx aTempBitmapEx( rGraphic.GetBitmapEx() );
aTempBitmapEx.Convert( BMP_CONVERSION_8BIT_GREYS );
nErrCode = GraphicConverter::Export( rTargetStream, aTempBitmapEx, CVT_TIF ) ;
}
else
nErrCode = GraphicConverter::Export( rTargetStream, rGraphic, CVT_TIF ) ;
if ( nErrCode == ERRCODE_NONE )
{
rTargetStream.Seek( STREAM_SEEK_TO_END );
nPSPosition = rTargetStream.Tell();
rTargetStream.Seek( nStreamPosition + 20 );
rTargetStream << nPSPosition - 30; // size of tiff gfx
rTargetStream.Seek( nPSPosition );
}
else
{
mnPreview &=~ EPS_PREVIEW_TIFF;
rTargetStream.Seek( nStreamPosition - 4 );
}
}
// global default value setting
ChrSet* pCS;
StackMember* pGS;
if ( rGraphic.GetType() == GRAPHIC_GDIMETAFILE )
pMTF = &rGraphic.GetGDIMetaFile();
else
pMTF = pAMTF = new GDIMetaFile( rGraphic.GetGDIMetaFile() );
aVDev.SetMapMode( pMTF->GetPrefMapMode() );
nBoundingX1 = nBoundingY1 = 0;
nBoundingX2 = pMTF->GetPrefSize().Width();
nBoundingY2 = pMTF->GetPrefSize().Height();
pGDIStack = NULL;
aColor = Color( COL_TRANSPARENT );
bLineColor = sal_True;
aLineColor = Color( COL_BLACK );
bFillColor = sal_True;
aFillColor = Color( COL_WHITE );
bTextFillColor = sal_True;
aTextFillColor = Color( COL_BLACK );
fLineWidth = 1;
fMiterLimit = 15; // use same limit as most graphic systems and basegfx
eLineCap = SvtGraphicStroke::capButt;
eJoinType = SvtGraphicStroke::joinMiter;
aBackgroundColor = Color( COL_WHITE );
eTextAlign = ALIGN_BASELINE;
bRegionChanged = sal_False;
nChrSet = 0x00;
pChrSetList = NULL;
nNextChrSetId = 1;
if( pMTF->GetActionCount() )
{
ImplWriteProlog( ( mnPreview & EPS_PREVIEW_EPSI ) ? &rGraphic : NULL );
mnCursorPos = 0;
ImplWriteActions( *pMTF, aVDev );
ImplWriteEpilog();
if ( mnPreview & EPS_PREVIEW_TIFF )
{
sal_uInt32 nPosition = rTargetStream.Tell();
rTargetStream.Seek( nStreamPosition );
rTargetStream << nPSPosition;
rTargetStream << nPosition - nPSPosition;
rTargetStream.Seek( nPosition );
}
while( pChrSetList )
{
pCS=pChrSetList;
pChrSetList=pCS->pSucc;
delete pCS;
}
while( pGDIStack )
{
pGS=pGDIStack;
pGDIStack=pGS->pSucc;
delete pGS;
}
}
else
mbStatus = sal_False;
if ( mbStatus && mnLevelWarning && pFilterConfigItem )
{
ByteString aResMgrName( "eps" );
ResMgr* pResMgr;
pResMgr = ResMgr::CreateResMgr( aResMgrName.GetBuffer(), Application::GetSettings().GetUILocale() );
if( pResMgr )
{
InfoBox aInfoBox( NULL, String( ResId( KEY_VERSION_CHECK, *pResMgr ) ) );
aInfoBox.Execute();
delete pResMgr;
}
}
if ( xStatusIndicator.is() )
xStatusIndicator->end();
return mbStatus;
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteProlog( const Graphic* pPreview )
{
ImplWriteLine( "%!PS-Adobe-3.0 EPSF-3.0 " );
*mpPS << "%%BoundingBox: "; // BoundingBox
ImplWriteLong( 0 );
ImplWriteLong( 0 );
Size aSizePoint = Application::GetDefaultDevice()->LogicToLogic( pMTF->GetPrefSize(),
pMTF->GetPrefMapMode(), MAP_POINT );
ImplWriteLong( aSizePoint.Width() );
ImplWriteLong( aSizePoint.Height() ,PS_RET );
ImplWriteLine( "%%Pages: 0" );
ImplWriteLine( "%%Creator: Sun Microsystems, Inc." );
ImplWriteLine( "%%Title: none" );
ImplWriteLine( "%%CreationDate: none" );
// defaults
*mpPS << "%%LanguageLevel: "; // Language level
ImplWriteLong( mnLevel, PS_RET );
if ( !mbGrayScale && mnLevel == 1 )
ImplWriteLine( "%%Extensions: CMYK" ); // CMYK extension is to set in color mode in level 1
ImplWriteLine( "%%EndComments" );
if ( pPreview && aSizePoint.Width() && aSizePoint.Height() )
{
Size aSizeBitmap( ( aSizePoint.Width() + 7 ) & ~7, aSizePoint.Height() );
Bitmap aTmpBitmap( pPreview->GetBitmap() );
aTmpBitmap.Scale( aSizeBitmap, BMP_SCALE_INTERPOLATE );
aTmpBitmap.Convert( BMP_CONVERSION_1BIT_THRESHOLD );
BitmapReadAccess* pAcc = aTmpBitmap.AcquireReadAccess();
if ( pAcc )
{
*mpPS << "%%BeginPreview: "; // BoundingBox
ImplWriteLong( aSizeBitmap.Width() );
ImplWriteLong( aSizeBitmap.Height() );
*mpPS << "1 ";
sal_Int32 nLines = aSizeBitmap.Width() / 312;
if ( ( nLines * 312 ) != aSizeBitmap.Width() )
nLines++;
nLines *= aSizeBitmap.Height();
ImplWriteLong( nLines );
char nVal;
sal_Int32 nX, nY, nCount2, nCount = 4;
const BitmapColor aBlack( pAcc->GetBestMatchingColor( Color( COL_BLACK ) ) );
for ( nY = 0; nY < aSizeBitmap.Height(); nY++ )
{
nCount2 = 0;
nVal = 0;
for ( nX = 0; nX < aSizeBitmap.Width(); nX++ )
{
if ( !nCount2 )
{
ImplExecMode( PS_RET );
*mpPS << "%";
nCount2 = 312;
}
nVal <<= 1;
if ( pAcc->GetPixel( nY, nX ) == aBlack )
nVal |= 1;
if ( ! ( --nCount ) )
{
if ( nVal > 9 )
nVal += 'A' - 10;
else
nVal += '0';
*mpPS << nVal;
nVal = 0;
nCount += 4;
}
nCount2--;
}
}
aTmpBitmap.ReleaseAccess( pAcc );
ImplExecMode( PS_RET );
ImplWriteLine( "%%EndPreview" );
}
}
ImplWriteLine( "%%BeginProlog" );
ImplWriteLine( "%%BeginResource: procset SDRes-Prolog 1.0 0" );
// BEGIN EPSF
ImplWriteLine( "/b4_inc_state save def\n/dict_count countdictstack def\n/op_count count 1 sub def\nuserdict begin" );
ImplWriteLine( "0 setgray 0 setlinecap 1 setlinewidth 0 setlinejoin 10 setmiterlimit[] 0 setdash newpath" );
ImplWriteLine( "/languagelevel where {pop languagelevel 1 ne {false setstrokeadjust false setoverprint} if} if" );
ImplWriteLine( "/bdef {bind def} bind def" ); // der neue operator bdef wird erzeugt
if ( mbGrayScale )
ImplWriteLine( "/c {setgray} bdef" );
else
ImplWriteLine( "/c {setrgbcolor} bdef" );
ImplWriteLine( "/l {neg lineto} bdef" );
ImplWriteLine( "/rl {neg rlineto} bdef" );
ImplWriteLine( "/lc {setlinecap} bdef" );
ImplWriteLine( "/lj {setlinejoin} bdef" );
ImplWriteLine( "/lw {setlinewidth} bdef" );
ImplWriteLine( "/ml {setmiterlimit} bdef" );
ImplWriteLine( "/ld {setdash} bdef" );
ImplWriteLine( "/m {neg moveto} bdef" );
ImplWriteLine( "/ct {6 2 roll neg 6 2 roll neg 6 2 roll neg curveto} bdef" );
ImplWriteLine( "/r {rotate} bdef" );
ImplWriteLine( "/t {neg translate} bdef" );
ImplWriteLine( "/s {scale} bdef" );
ImplWriteLine( "/sw {show} bdef" );
ImplWriteLine( "/gs {gsave} bdef" );
ImplWriteLine( "/gr {grestore} bdef" );
ImplWriteLine( "/f {findfont dup length dict begin" ); // Setfont
ImplWriteLine( "{1 index /FID ne {def} {pop pop} ifelse} forall /Encoding ISOLatin1Encoding def" );
ImplWriteLine( "currentdict end /NFont exch definefont pop /NFont findfont} bdef" );
ImplWriteLine( "/p {closepath} bdef" );
ImplWriteLine( "/sf {scalefont setfont} bdef" );
ImplWriteLine( "/ef {eofill}bdef" ); // close path and fill
ImplWriteLine( "/pc {closepath stroke}bdef" ); // close path and draw
ImplWriteLine( "/ps {stroke}bdef" ); // draw current path
ImplWriteLine( "/pum {matrix currentmatrix}bdef" ); // pushes the current matrix
ImplWriteLine( "/pom {setmatrix}bdef" ); // pops the matrix
ImplWriteLine( "/bs {/aString exch def /nXOfs exch def /nWidth exch def currentpoint nXOfs 0 rmoveto pum nWidth aString stringwidth pop div 1 scale aString show pom moveto} bdef" );
ImplWriteLine( "%%EndResource" );
ImplWriteLine( "%%EndProlog" );
ImplWriteLine( "%%BeginSetup" );
ImplWriteLine( "%%EndSetup" );
ImplWriteLine( "%%Page: 1 1" );
ImplWriteLine( "%%BeginPageSetup" );
ImplWriteLine( "%%EndPageSetup" );
ImplWriteLine( "pum" );
ImplScale( (double)aSizePoint.Width() / (double)pMTF->GetPrefSize().Width(), (double)aSizePoint.Height() / (double)pMTF->GetPrefSize().Height() );
ImplWriteDouble( 0 );
ImplWriteDouble( -pMTF->GetPrefSize().Height() );
ImplWriteLine( "t" );
ImplWriteLine( "/tm matrix currentmatrix def" );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteEpilog()
{
ImplTranslate( 0, nBoundingY2 );
ImplWriteLine( "pom" );
ImplWriteLine( "count op_count sub {pop} repeat countdictstack dict_count sub {end} repeat b4_inc_state restore" );
ImplWriteLine( "%%PageTrailer" );
ImplWriteLine( "%%Trailer" );
ImplWriteLine( "%%EOF" );
}
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
{
PolyPolygon aFillPath;
for( sal_uLong nCurAction = 0, nCount = rMtf.GetActionCount(); nCurAction < nCount; nCurAction++ )
{
MetaAction* pMA = rMtf.GetAction( nCurAction );
switch( pMA->GetType() )
{
case META_NULL_ACTION :
break;
case META_PIXEL_ACTION :
{
Color aOldLineColor( aLineColor );
aLineColor = ( (const MetaPixelAction*) pMA )->GetColor();
ImplWriteLineColor( PS_SPACE );
ImplMoveTo( ( (const MetaPixelAction*)pMA )->GetPoint() );
ImplLineTo( ( (const MetaPixelAction*)pMA )->GetPoint() );
ImplPathDraw();
aLineColor = aOldLineColor;
}
break;
case META_POINT_ACTION :
{
ImplWriteLineColor( PS_SPACE );
ImplMoveTo( ( (const MetaPointAction*)pMA )->GetPoint() );
ImplLineTo( ( (const MetaPointAction*)pMA )->GetPoint() );
ImplPathDraw();
}
break;
case META_LINE_ACTION :
{
const LineInfo& rLineInfo = ( ( const MetaLineAction*)pMA )->GetLineInfo();
ImplWriteLineInfo( rLineInfo );
if ( bLineColor )
{
ImplWriteLineColor( PS_SPACE );
ImplMoveTo( ( (const MetaLineAction*) pMA )->GetStartPoint() );
ImplLineTo( ( (const MetaLineAction*) pMA )->GetEndPoint() );
ImplPathDraw();
}
}
break;
case META_RECT_ACTION :
{
ImplRect( ( (const MetaRectAction*) pMA )->GetRect() );
}
break;
case META_ROUNDRECT_ACTION :
ImplRect( ( (const MetaRoundRectAction*) pMA )->GetRect() );
break;
case META_ELLIPSE_ACTION :
{
Rectangle aRect = ( ( (const MetaEllipseAction*) pMA )->GetRect() );
Point aCenter = aRect.Center();
Polygon aPoly( aCenter, aRect.GetWidth() / 2, aRect.GetHeight() / 2 );
PolyPolygon aPolyPoly( aPoly );
ImplPolyPoly( aPolyPoly );
}
break;
case META_ARC_ACTION :
{
Polygon aPoly( ( (const MetaArcAction*)pMA )->GetRect(), ( (const MetaArcAction*)pMA )->GetStartPoint(),
( (const MetaArcAction*)pMA )->GetEndPoint(), POLY_ARC );
PolyPolygon aPolyPoly( aPoly );
ImplPolyPoly( aPolyPoly );
}
break;
case META_PIE_ACTION :
{
Polygon aPoly( ( (const MetaPieAction*)pMA )->GetRect(), ( (const MetaPieAction*)pMA )->GetStartPoint(),
( (const MetaPieAction*)pMA )->GetEndPoint(), POLY_PIE );
PolyPolygon aPolyPoly( aPoly );
ImplPolyPoly( aPolyPoly );
}
break;
case META_CHORD_ACTION :
{
Polygon aPoly( ( (const MetaChordAction*)pMA )->GetRect(), ( (const MetaChordAction*)pMA )->GetStartPoint(),
( (const MetaChordAction*)pMA )->GetEndPoint(), POLY_CHORD );
PolyPolygon aPolyPoly( aPoly );
ImplPolyPoly( aPolyPoly );
}
break;
case META_POLYLINE_ACTION :
{
Polygon aPoly( ( (const MetaPolyLineAction*) pMA )->GetPolygon() );
const LineInfo& rLineInfo = ( ( const MetaPolyLineAction*)pMA )->GetLineInfo();
ImplWriteLineInfo( rLineInfo );
if(basegfx::B2DLINEJOIN_NONE == rLineInfo.GetLineJoin()
&& rLineInfo.GetWidth() > 1)
{
// emulate B2DLINEJOIN_NONE by creating single edges
const sal_uInt16 nPoints(aPoly.GetSize());
const bool bCurve(aPoly.HasFlags());
for(sal_uInt16 a(0); a + 1 < nPoints; a++)
{
if(bCurve
&& POLY_NORMAL != aPoly.GetFlags(a + 1)
&& a + 2 < nPoints
&& POLY_NORMAL != aPoly.GetFlags(a + 2)
&& a + 3 < nPoints)
{
const Polygon aSnippet(4,
aPoly.GetConstPointAry() + a,
aPoly.GetConstFlagAry() + a);
ImplPolyLine(aSnippet);
a += 2;
}
else
{
const Polygon aSnippet(2,
aPoly.GetConstPointAry() + a);
ImplPolyLine(aSnippet);
}
}
}
else
{
ImplPolyLine( aPoly );
}
}
break;
case META_POLYGON_ACTION :
{
PolyPolygon aPolyPoly( ( (const MetaPolygonAction*) pMA )->GetPolygon() );
ImplPolyPoly( aPolyPoly );
}
break;
case META_POLYPOLYGON_ACTION :
{
ImplPolyPoly( ( (const MetaPolyPolygonAction*) pMA )->GetPolyPolygon() );
}
break;
case META_TEXT_ACTION:
{
const MetaTextAction * pA = (const MetaTextAction*) pMA;
String aUniStr( pA->GetText(), pA->GetIndex(), pA->GetLen() );
Point aPoint( pA->GetPoint() );
ImplText( aUniStr, aPoint, NULL, 0, rVDev );
}
break;
case META_TEXTRECT_ACTION:
{
DBG_ERROR( "Unsupported action: TextRect...Action!" );
}
break;
case META_STRETCHTEXT_ACTION :
{
const MetaStretchTextAction* pA = (const MetaStretchTextAction*)pMA;
String aUniStr( pA->GetText(), pA->GetIndex(), pA->GetLen() );
Point aPoint( pA->GetPoint() );
ImplText( aUniStr, aPoint, NULL, pA->GetWidth(), rVDev );
}
break;
case META_TEXTARRAY_ACTION:
{
const MetaTextArrayAction* pA = (const MetaTextArrayAction*)pMA;
String aUniStr( pA->GetText(), pA->GetIndex(), pA->GetLen() );
Point aPoint( pA->GetPoint() );
ImplText( aUniStr, aPoint, pA->GetDXArray(), 0, rVDev );
}
break;
case META_BMP_ACTION :
{
Bitmap aBitmap = ( (const MetaBmpAction*)pMA )->GetBitmap();
if ( mbGrayScale )
aBitmap.Convert( BMP_CONVERSION_8BIT_GREYS );
Point aPoint = ( (const MetaBmpAction*) pMA )->GetPoint();
Size aSize( rVDev.PixelToLogic( aBitmap.GetSizePixel() ) );
ImplBmp( &aBitmap, NULL, aPoint, aSize.Width(), aSize.Height() );
}
break;
case META_BMPSCALE_ACTION :
{
Bitmap aBitmap = ( (const MetaBmpScaleAction*)pMA )->GetBitmap();
if ( mbGrayScale )
aBitmap.Convert( BMP_CONVERSION_8BIT_GREYS );
Point aPoint = ( (const MetaBmpScaleAction*) pMA )->GetPoint();
Size aSize = ( (const MetaBmpScaleAction*)pMA )->GetSize();
ImplBmp( &aBitmap, NULL, aPoint, aSize.Width(), aSize.Height() );
}
break;
case META_BMPSCALEPART_ACTION :
{
Bitmap aBitmap( ( (const MetaBmpScalePartAction*)pMA )->GetBitmap() );
aBitmap.Crop( Rectangle( ( (const MetaBmpScalePartAction*)pMA )->GetSrcPoint(),
( (const MetaBmpScalePartAction*)pMA )->GetSrcSize() ) );
if ( mbGrayScale )
aBitmap.Convert( BMP_CONVERSION_8BIT_GREYS );
Point aPoint = ( (const MetaBmpScalePartAction*) pMA)->GetDestPoint();
Size aSize = ( (const MetaBmpScalePartAction*)pMA )->GetDestSize();
ImplBmp( &aBitmap, NULL, aPoint, aSize.Width(), aSize.Height() );
}
break;
case META_BMPEX_ACTION :
{
BitmapEx aBitmapEx( ( (MetaBmpExAction*)pMA)->GetBitmapEx() );
Bitmap aBitmap( aBitmapEx.GetBitmap() );
if ( mbGrayScale )
aBitmap.Convert( BMP_CONVERSION_8BIT_GREYS );
Bitmap aMask( aBitmapEx.GetMask() );
Point aPoint( ( (const MetaBmpExAction*) pMA )->GetPoint() );
Size aSize( rVDev.PixelToLogic( aBitmap.GetSizePixel() ) );
ImplBmp( &aBitmap, &aMask, aPoint, aSize.Width(), aSize.Height() );
}
break;
case META_BMPEXSCALE_ACTION :
{
BitmapEx aBitmapEx( ( (MetaBmpExScaleAction*)pMA)->GetBitmapEx() );
Bitmap aBitmap( aBitmapEx.GetBitmap() );
if ( mbGrayScale )
aBitmap.Convert( BMP_CONVERSION_8BIT_GREYS );
Bitmap aMask( aBitmapEx.GetMask() );
Point aPoint = ( (const MetaBmpExScaleAction*) pMA)->GetPoint();
Size aSize( ( (const MetaBmpExScaleAction*)pMA )->GetSize() );
ImplBmp( &aBitmap, &aMask, aPoint, aSize.Width(), aSize.Height() );
}
break;
case META_BMPEXSCALEPART_ACTION :
{
BitmapEx aBitmapEx( ( (const MetaBmpExScalePartAction*)pMA )->GetBitmapEx() );
aBitmapEx.Crop( Rectangle( ( (const MetaBmpExScalePartAction*)pMA )->GetSrcPoint(),
( (const MetaBmpExScalePartAction*)pMA )->GetSrcSize() ) );
Bitmap aBitmap( aBitmapEx.GetBitmap() );
if ( mbGrayScale )
aBitmap.Convert( BMP_CONVERSION_8BIT_GREYS );
Bitmap aMask( aBitmapEx.GetMask() );
Point aPoint = ( (const MetaBmpExScalePartAction*) pMA)->GetDestPoint();
Size aSize = ( (const MetaBmpExScalePartAction*)pMA )->GetDestSize();
ImplBmp( &aBitmap, &aMask, aPoint, aSize.Width(), aSize.Height() );
}
break;
// Unsupported Actions
case META_MASK_ACTION:
case META_MASKSCALE_ACTION:
case META_MASKSCALEPART_ACTION:
{
DBG_ERROR( "Unsupported action: MetaMask...Action!" );
}
break;
case META_GRADIENT_ACTION :
{
PolyPolygon aPolyPoly( ( (const MetaGradientAction*)pMA)->GetRect() );
ImplWriteGradient( aPolyPoly, ( (const MetaGradientAction*) pMA )->GetGradient(), rVDev );
}
break;
case META_GRADIENTEX_ACTION :
{
PolyPolygon aPolyPoly( ( (const MetaGradientExAction*)pMA)->GetPolyPolygon() );
ImplWriteGradient( aPolyPoly, ( (const MetaGradientExAction*) pMA )->GetGradient(), rVDev );
}
break;
case META_HATCH_ACTION :
{
VirtualDevice l_aVDev;
GDIMetaFile aTmpMtf;
l_aVDev.SetMapMode( rVDev.GetMapMode() );
l_aVDev.AddHatchActions( ( (const MetaHatchAction*)pMA)->GetPolyPolygon(),
( (const MetaHatchAction*)pMA )->GetHatch(), aTmpMtf );
ImplWriteActions( aTmpMtf, rVDev );
}
break;
case META_WALLPAPER_ACTION :
{
const MetaWallpaperAction* pA = (const MetaWallpaperAction*)pMA;
Rectangle aRect = pA->GetRect();
Wallpaper aWallpaper = pA->GetWallpaper();
if ( aWallpaper.IsBitmap() )
{
BitmapEx aBitmapEx = aWallpaper.GetBitmap();
Bitmap aBitmap( aBitmapEx.GetBitmap() );
if ( aBitmapEx.IsTransparent() )
{
if ( aWallpaper.IsGradient() )
{
// gradient action
}
Bitmap aMask( aBitmapEx.GetMask() );
ImplBmp( &aBitmap, &aMask, Point( aRect.Left(), aRect.Top() ), aRect.GetWidth(), aRect.GetHeight() );
}
else
ImplBmp( &aBitmap, NULL, Point( aRect.Left(), aRect.Top() ), aRect.GetWidth(), aRect.GetHeight() );
// wallpaper Style
}
else if ( aWallpaper.IsGradient() )
{
// gradient action
}
else
{
aColor = aWallpaper.GetColor();
ImplRectFill( aRect );
}
}
break;
case META_ISECTRECTCLIPREGION_ACTION:
{
const MetaISectRectClipRegionAction* pA = (const MetaISectRectClipRegionAction*) pMA;
Region aRegion( pA->GetRect() );
ImplSetClipRegion( aRegion );
}
break;
case META_CLIPREGION_ACTION:
{
const MetaClipRegionAction* pA = (const MetaClipRegionAction*) pMA;
Region aRegion( pA->GetRegion() );
ImplSetClipRegion( aRegion );
}
break;
case META_ISECTREGIONCLIPREGION_ACTION:
{
const MetaISectRegionClipRegionAction* pA = (const MetaISectRegionClipRegionAction*) pMA;
Region aRegion( pA->GetRegion() );
ImplSetClipRegion( aRegion );
}
break;
case META_MOVECLIPREGION_ACTION:
{
/*
if ( !aClipRegion.IsEmpty() )
{
const MetaMoveClipRegionAction* pA = (const MetaMoveClipRegionAction*) pMA;
aClipRegion.Move( pA->GetHorzMove(), pA->GetVertMove() );
ImplSetClipRegion();
}
*/
}
break;
case META_LINECOLOR_ACTION :
{
if ( ( (const MetaLineColorAction*) pMA)->IsSetting() )
{
bLineColor = sal_True;
aLineColor = ( (const MetaLineColorAction*) pMA )->GetColor();
}
else
bLineColor = sal_False;
}
break;
case META_FILLCOLOR_ACTION :
{
if ( ( (const MetaFillColorAction*) pMA )->IsSetting() )
{
bFillColor = sal_True;
aFillColor = ( (const MetaFillColorAction*) pMA )->GetColor();
}
else
bFillColor = sal_False;
}
break;
case META_TEXTCOLOR_ACTION :
{
aTextColor = ( (const MetaTextColorAction*) pMA )->GetColor();
}
break;
case META_TEXTFILLCOLOR_ACTION :
{
if ( ( (const MetaTextFillColorAction*) pMA )->IsSetting() )
{
bTextFillColor = sal_True;
aTextFillColor = ( (const MetaTextFillColorAction*) pMA )->GetColor();
}
else
bTextFillColor = sal_False;
}
break;
case META_TEXTALIGN_ACTION :
{
eTextAlign = ( (const MetaTextAlignAction*) pMA )->GetTextAlign();
}
break;
case META_MAPMODE_ACTION :
{
pMA->Execute( &rVDev );
ImplGetMapMode( rVDev.GetMapMode() );
}
break;
case META_FONT_ACTION :
{
maFont = ((const MetaFontAction*)pMA)->GetFont();
rVDev.SetFont( maFont );
}
break;
case META_PUSH_ACTION :
{
rVDev.Push(((const MetaPushAction*)pMA)->GetFlags() );
StackMember* pGS = new StackMember;
pGS->pSucc = pGDIStack;
pGDIStack = pGS;
pGS->aDashArray = aDashArray;
pGS->eJoinType = eJoinType;
pGS->eLineCap = eLineCap;
pGS->fLineWidth = fLineWidth;
pGS->fMiterLimit = fMiterLimit;
pGS->eTextAlign = eTextAlign;
pGS->aGlobalCol = aColor;
pGS->bLineCol = bLineColor;
pGS->aLineCol = aLineColor;
pGS->bFillCol = bFillColor;
pGS->aFillCol = aFillColor;
pGS->aTextCol = aTextColor;
pGS->bTextFillCol = bTextFillColor;
pGS->aTextFillCol = aTextFillColor;
pGS->aBackgroundCol = aBackgroundColor;
bRegionChanged = sal_False;
pGS->aFont = maFont;
mnLatestPush = mpPS->Tell();
ImplWriteLine( "gs" );
}
break;
case META_POP_ACTION :
{
rVDev.Pop();
StackMember* pGS;
if( pGDIStack )
{
pGS = pGDIStack;
pGDIStack = pGS->pSucc;
aDashArray = pGS->aDashArray;
eJoinType = pGS->eJoinType;
eLineCap = pGS->eLineCap;
fLineWidth = pGS->fLineWidth;
fMiterLimit = pGS->fMiterLimit;
eTextAlign = pGS->eTextAlign;
aColor = pGS->aGlobalCol;
bLineColor = pGS->bLineCol;
aLineColor = pGS->aLineCol;
bFillColor = pGS->bFillCol;
aFillColor = pGS->aFillCol;
aTextColor = pGS->aTextCol;
bTextFillColor = pGS->bTextFillCol;
aTextFillColor = pGS->aTextFillCol;
aBackgroundColor = pGS->aBackgroundCol;
maFont = pGS->aFont;
maLastFont = Font(); // set maLastFont != maFont -> so that
delete pGS;
sal_uInt32 nCurrentPos = mpPS->Tell();
if ( nCurrentPos - 3 == mnLatestPush )
{
mpPS->Seek( mnLatestPush );
ImplWriteLine( " " );
mpPS->Seek( mnLatestPush );
}
else
ImplWriteLine( "gr" );
}
}
break;
case META_EPS_ACTION :
{
GfxLink aGfxLink = ( (const MetaEPSAction*) pMA )->GetLink();
const GDIMetaFile aSubstitute( ( ( const MetaEPSAction*) pMA )->GetSubstitute() );
sal_Bool bLevelConflict = sal_False;
sal_uInt8* pSource = (sal_uInt8*) aGfxLink.GetData();
sal_uLong nSize = aGfxLink.GetDataSize();
sal_uLong nParseThis = POSTSCRIPT_BOUNDINGSEARCH;
if ( nSize < 64 ) // assuming eps is larger than 64 bytes
pSource = NULL;
if ( nParseThis > nSize )
nParseThis = nSize;
if ( pSource && ( mnLevel == 1 ) )
{
sal_uInt8* pFound = ImplSearchEntry( pSource, (sal_uInt8*)"%%LanguageLevel:", nParseThis - 10, 16 );
if ( pFound )
{
sal_uInt8 k, i = 10;
pFound += 16;
while ( --i )
{
k = *pFound++;
if ( ( k > '0' ) && ( k <= '9' ) )
{
if ( k != '1' )
{
bLevelConflict = sal_True;
mnLevelWarning++;
}
break;
}
}
}
}
if ( !bLevelConflict )
{
double nBoundingBox[4];
if ( pSource && ImplGetBoundingBox( nBoundingBox, pSource, nParseThis ) )
{
Point aPoint = ( (const MetaEPSAction*) pMA )->GetPoint();
Size aSize = ( (const MetaEPSAction*) pMA )->GetSize();
MapMode aMapMode( aSubstitute.GetPrefMapMode() );
Size aOutSize( rVDev.LogicToLogic( aSize, rVDev.GetMapMode(), aMapMode ) );
Point aOrigin( rVDev.LogicToLogic( aPoint, rVDev.GetMapMode(), aMapMode ) );
aOrigin.Y() += aOutSize.Height();
aMapMode.SetOrigin( aOrigin );
aMapMode.SetScaleX( aOutSize.Width() / ( nBoundingBox[ 2 ] - nBoundingBox[ 0 ] ) );
aMapMode.SetScaleY( aOutSize.Height() / ( nBoundingBox[ 3 ] - nBoundingBox[ 1 ] ) );
ImplWriteLine( "gs" );
ImplGetMapMode( aMapMode );
ImplWriteLine( "%%BeginDocument:" );
mpPS->Write( pSource, aGfxLink.GetDataSize() );
ImplWriteLine( "%%EndDocument\ngr" );
}
}
}
break;
case META_TRANSPARENT_ACTION:
{
// ImplLine( ( (const MetaTransparentAction*) pMA )->GetPolyPolygon() );
}
break;
case META_RASTEROP_ACTION:
{
pMA->Execute( &rVDev );
}
break;
case META_FLOATTRANSPARENT_ACTION:
{
const MetaFloatTransparentAction* pA = (const MetaFloatTransparentAction*) pMA;
GDIMetaFile aTmpMtf( pA->GetGDIMetaFile() );
Point aSrcPt( aTmpMtf.GetPrefMapMode().GetOrigin() );
const Size aSrcSize( aTmpMtf.GetPrefSize() );
const Point aDestPt( pA->GetPoint() );
const Size aDestSize( pA->GetSize() );
const double fScaleX = aSrcSize.Width() ? (double) aDestSize.Width() / aSrcSize.Width() : 1.0;
const double fScaleY = aSrcSize.Height() ? (double) aDestSize.Height() / aSrcSize.Height() : 1.0;
long nMoveX, nMoveY;
if( fScaleX != 1.0 || fScaleY != 1.0 )
{
aTmpMtf.Scale( fScaleX, fScaleY );
aSrcPt.X() = FRound( aSrcPt.X() * fScaleX ), aSrcPt.Y() = FRound( aSrcPt.Y() * fScaleY );
}
nMoveX = aDestPt.X() - aSrcPt.X(), nMoveY = aDestPt.Y() - aSrcPt.Y();
if( nMoveX || nMoveY )
aTmpMtf.Move( nMoveX, nMoveY );
ImplWriteActions( aTmpMtf, rVDev );
}
break;
case META_COMMENT_ACTION:
{
const MetaCommentAction* pA = (const MetaCommentAction*) pMA;
if ( pA->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_BEGIN" ) == COMPARE_EQUAL )
{
const MetaGradientExAction* pGradAction = NULL;
while( ++nCurAction < nCount )
{
MetaAction* pAction = rMtf.GetAction( nCurAction );
if( pAction->GetType() == META_GRADIENTEX_ACTION )
pGradAction = (const MetaGradientExAction*) pAction;
else if( ( pAction->GetType() == META_COMMENT_ACTION ) &&
( ( (const MetaCommentAction*) pAction )->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_END" ) == COMPARE_EQUAL ) )
{
break;
}
}
if( pGradAction )
ImplWriteGradient( pGradAction->GetPolyPolygon(), pGradAction->GetGradient(), rVDev );
}
else if ( pA->GetComment().Equals( "XPATHFILL_SEQ_END" ) )
{
if ( aFillPath.Count() )
{
aFillPath = PolyPolygon();
ImplWriteLine( "gr" );
}
}
else
{
const sal_uInt8* pData = pA->GetData();
if ( pData )
{
SvMemoryStream aMemStm( (void*)pData, pA->GetDataSize(), STREAM_READ );
sal_Bool bSkipSequence = sal_False;
ByteString sSeqEnd;
if( pA->GetComment().Equals( "XPATHSTROKE_SEQ_BEGIN" ) )
{
sSeqEnd = ByteString( "XPATHSTROKE_SEQ_END" );
SvtGraphicStroke aStroke;
aMemStm >> aStroke;
Polygon aPath;
aStroke.getPath( aPath );
PolyPolygon aStartArrow;
PolyPolygon aEndArrow;
// double fTransparency( aStroke.getTransparency() );
double fStrokeWidth( aStroke.getStrokeWidth() );
SvtGraphicStroke::JoinType eJT( aStroke.getJoinType() );
SvtGraphicStroke::DashArray l_aDashArray;
aStroke.getStartArrow( aStartArrow );
aStroke.getEndArrow( aEndArrow );
aStroke.getDashArray( l_aDashArray );
bSkipSequence = sal_True;
if ( l_aDashArray.size() > 11 ) // ps dasharray limit is 11
bSkipSequence = sal_False;
if ( aStartArrow.Count() || aEndArrow.Count() )
bSkipSequence = sal_False;
if ( (sal_uInt32)eJT > 2 )
bSkipSequence = sal_False;
if ( l_aDashArray.size() && ( fStrokeWidth != 0.0 ) )
bSkipSequence = sal_False;
if ( bSkipSequence )
{
ImplWriteLineInfo( fStrokeWidth, aStroke.getMiterLimit(),
aStroke.getCapType(), eJT, l_aDashArray );
ImplPolyLine( aPath );
}
}
else if( pA->GetComment().Equals( "XPATHFILL_SEQ_BEGIN" ) )
{
sSeqEnd = ByteString( "XPATHFILL_SEQ_END" );
SvtGraphicFill aFill;
aMemStm >> aFill;
switch( aFill.getFillType() )
{
case SvtGraphicFill::fillSolid :
{
bSkipSequence = sal_True;
PolyPolygon aPolyPoly;
aFill.getPath( aPolyPoly );
sal_uInt16 i, nPolyCount = aPolyPoly.Count();
if ( nPolyCount )
{
aFillColor = aFill.getFillColor();
ImplWriteFillColor( PS_SPACE );
for ( i = 0; i < nPolyCount; )
{
ImplAddPath( aPolyPoly.GetObject( i ) );
if ( ++i < nPolyCount )
{
*mpPS << "p";
mnCursorPos += 2;
ImplExecMode( PS_RET );
}
}
*mpPS << "p ef";
mnCursorPos += 4;
ImplExecMode( PS_RET );
}
}
break;
case SvtGraphicFill::fillTexture :
{
aFill.getPath( aFillPath );
/* normally an object filling is consisting of three MetaActions:
MetaBitmapAction using RasterOp xor,
MetaPolyPolygonAction using RasterOp rop_0
MetaBitmapAction using RasterOp xor
Because RasterOps cannot been used in Postscript, we have to
replace these actions. The MetaComment "XPATHFILL_SEQ_BEGIN" is
providing the clippath of the object. The following loop is
trying to find the bitmap that is matching the clippath, so that
only one bitmap is exported, otherwise if the bitmap is not
locatable, all metaactions are played normally.
*/
sal_uInt32 nCommentStartAction = nCurAction;
sal_uInt32 nBitmapCount = 0;
sal_uInt32 nBitmapAction = 0;
sal_Bool bOk = sal_True;
while( bOk && ( ++nCurAction < nCount ) )
{
MetaAction* pAction = rMtf.GetAction( nCurAction );
switch( pAction->GetType() )
{
case META_BMPSCALE_ACTION :
case META_BMPSCALEPART_ACTION :
case META_BMPEXSCALE_ACTION :
case META_BMPEXSCALEPART_ACTION :
{
nBitmapCount++;
nBitmapAction = nCurAction;
}
break;
case META_COMMENT_ACTION :
{
if (((const MetaCommentAction*)pAction)->GetComment().Equals( "XPATHFILL_SEQ_END" ))
bOk = sal_False;
}
break;
}
}
if( nBitmapCount == 2 )
{
ImplWriteLine( "gs" );
ImplIntersect( aFillPath );
GDIMetaFile aTempMtf;
aTempMtf.AddAction( rMtf.GetAction( nBitmapAction )->Clone() );
ImplWriteActions( aTempMtf, rVDev );
ImplWriteLine( "gr" );
aFillPath = PolyPolygon();
}
else
nCurAction = nCommentStartAction + 1;
}
break;
case SvtGraphicFill::fillGradient :
aFill.getPath( aFillPath );
break;
case SvtGraphicFill::fillHatch :
break;
}
if ( aFillPath.Count() )
{
ImplWriteLine( "gs" );
ImplIntersect( aFillPath );
}
}
if ( bSkipSequence )
{
while( ++nCurAction < nCount )
{
pMA = rMtf.GetAction( nCurAction );
if ( pMA->GetType() == META_COMMENT_ACTION )
{
ByteString sComment( ((MetaCommentAction*)pMA)->GetComment() );
if ( sComment.Equals( sSeqEnd ) )
break;
}
}
}
}
}
}
break;
}
}
}
//---------------------------------------------------------------------------------
inline void PSWriter::ImplWritePoint( const Point& rPoint, sal_uInt32 nMode )
{
ImplWriteDouble( rPoint.X() );
ImplWriteDouble( rPoint.Y(), nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplMoveTo( const Point& rPoint, sal_uInt32 nMode )
{
ImplWritePoint( rPoint );
ImplWriteByte( 'm' );
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplLineTo( const Point& rPoint, sal_uInt32 nMode )
{
ImplWritePoint( rPoint );
ImplWriteByte( 'l' );
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplCurveTo( const Point& rP1, const Point& rP2, const Point& rP3, sal_uInt32 nMode )
{
ImplWritePoint( rP1 );
ImplWritePoint( rP2 );
ImplWritePoint( rP3 );
*mpPS << "ct ";
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplTranslate( const double& fX, const double& fY, sal_uInt32 nMode )
{
ImplWriteDouble( fX );
ImplWriteDouble( fY );
ImplWriteByte( 't' );
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplScale( const double& fX, const double& fY, sal_uInt32 nMode )
{
ImplWriteDouble( fX );
ImplWriteDouble( fY );
ImplWriteByte( 's' );
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplRect( const Rectangle & rRect )
{
if ( bFillColor )
ImplRectFill( rRect );
if ( bLineColor )
{
double nWidth = rRect.GetWidth();
double nHeight = rRect.GetHeight();
ImplWriteLineColor( PS_SPACE );
ImplMoveTo( rRect.TopLeft() );
ImplWriteDouble( nWidth );
*mpPS << "0 rl 0 ";
ImplWriteDouble( nHeight );
*mpPS << "rl ";
ImplWriteDouble( nWidth );
*mpPS << "neg 0 rl ";
ImplClosePathDraw();
}
*mpPS << (sal_uInt8)10;
mnCursorPos = 0;
}
//---------------------------------------------------------------------------------
void PSWriter::ImplRectFill( const Rectangle & rRect )
{
double nWidth = rRect.GetWidth();
double nHeight = rRect.GetHeight();
ImplWriteFillColor( PS_SPACE );
ImplMoveTo( rRect.TopLeft() );
ImplWriteDouble( nWidth );
*mpPS << "0 rl 0 ";
ImplWriteDouble( nHeight );
*mpPS << "rl ";
ImplWriteDouble( nWidth );
*mpPS << "neg 0 rl ef ";
*mpPS << "p ef";
mnCursorPos += 2;
ImplExecMode( PS_RET );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplAddPath( const Polygon & rPolygon )
{
sal_uInt16 i = 1;
sal_uInt16 nPointCount = rPolygon.GetSize();
if ( nPointCount > 1 )
{
ImplMoveTo( rPolygon.GetPoint( 0 ) );
while ( i < nPointCount )
{
if ( ( rPolygon.GetFlags( i ) == POLY_CONTROL )
&& ( ( i + 2 ) < nPointCount )
&& ( rPolygon.GetFlags( i + 1 ) == POLY_CONTROL )
&& ( rPolygon.GetFlags( i + 2 ) != POLY_CONTROL ) )
{
ImplCurveTo( rPolygon[ i ], rPolygon[ i + 1 ], rPolygon[ i + 2 ], PS_WRAP );
i += 3;
}
else
ImplLineTo( rPolygon.GetPoint( i++ ), PS_SPACE | PS_WRAP );
}
}
}
//---------------------------------------------------------------------------------
void PSWriter::ImplIntersect( const PolyPolygon& rPolyPoly )
{
sal_uInt16 i, nPolyCount = rPolyPoly.Count();
for ( i = 0; i < nPolyCount; )
{
ImplAddPath( rPolyPoly.GetObject( i ) );
if ( ++i < nPolyCount )
{
*mpPS << "p";
mnCursorPos += 2;
ImplExecMode( PS_RET );
}
}
ImplWriteLine( "eoclip newpath" );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteGradient( const PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev )
{
VirtualDevice l_aVDev;
GDIMetaFile aTmpMtf;
l_aVDev.SetMapMode( rVDev.GetMapMode() );
l_aVDev.AddGradientActions( rPolyPoly.GetBoundRect(), rGradient, aTmpMtf );
ImplWriteActions( aTmpMtf, rVDev );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplPolyPoly( const PolyPolygon & rPolyPoly, sal_Bool bTextOutline )
{
sal_uInt16 i, nPolyCount = rPolyPoly.Count();
if ( nPolyCount )
{
if ( bFillColor || bTextOutline )
{
if ( bTextOutline )
ImplWriteTextColor( PS_SPACE );
else
ImplWriteFillColor( PS_SPACE );
for ( i = 0; i < nPolyCount; )
{
ImplAddPath( rPolyPoly.GetObject( i ) );
if ( ++i < nPolyCount )
{
*mpPS << "p";
mnCursorPos += 2;
ImplExecMode( PS_RET );
}
}
*mpPS << "p ef";
mnCursorPos += 4;
ImplExecMode( PS_RET );
}
if ( bLineColor )
{
ImplWriteLineColor( PS_SPACE );
for ( i = 0; i < nPolyCount; i++ )
ImplAddPath( rPolyPoly.GetObject( i ) );
ImplClosePathDraw( PS_RET );
}
}
}
//---------------------------------------------------------------------------------
void PSWriter::ImplPolyLine( const Polygon & rPoly )
{
if ( bLineColor )
{
ImplWriteLineColor( PS_SPACE );
sal_uInt16 i, nPointCount = rPoly.GetSize();
if ( nPointCount )
{
if ( nPointCount > 1 )
{
ImplMoveTo( rPoly.GetPoint( 0 ) );
i = 1;
while ( i < nPointCount )
{
if ( ( rPoly.GetFlags( i ) == POLY_CONTROL )
&& ( ( i + 2 ) < nPointCount )
&& ( rPoly.GetFlags( i + 1 ) == POLY_CONTROL )
&& ( rPoly.GetFlags( i + 2 ) != POLY_CONTROL ) )
{
ImplCurveTo( rPoly[ i ], rPoly[ i + 1 ], rPoly[ i + 2 ], PS_WRAP );
i += 3;
}
else
ImplLineTo( rPoly.GetPoint( i++ ), PS_SPACE | PS_WRAP );
}
}
// #104645# explicitely close path if polygon is closed
if( rPoly[ 0 ] == rPoly[ nPointCount-1 ] )
ImplClosePathDraw( PS_RET );
else
ImplPathDraw();
}
}
}
//---------------------------------------------------------------------------------
void PSWriter::ImplSetClipRegion( Region& rClipRegion )
{
if ( !rClipRegion.IsEmpty() )
{
RectangleVector aRectangles;
rClipRegion.GetRegionRectangles(aRectangles);
for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++)
{
double nX1(aRectIter->Left());
double nY1(aRectIter->Top());
double nX2(aRectIter->Right());
double nY2(aRectIter->Bottom());
ImplWriteDouble( nX1 );
ImplWriteDouble( nY1 );
ImplWriteByte( 'm' );
ImplWriteDouble( nX2 );
ImplWriteDouble( nY1 );
ImplWriteByte( 'l' );
ImplWriteDouble( nX2 );
ImplWriteDouble( nY2 );
ImplWriteByte( 'l' );
ImplWriteDouble( nX1 );
ImplWriteDouble( nY2 );
ImplWriteByte( 'l' );
ImplWriteDouble( nX1 );
ImplWriteDouble( nY1 );
ImplWriteByte( 'l', PS_SPACE | PS_WRAP );
}
//Rectangle aRect;
//RegionHandle hRegionHandle = rClipRegion.BeginEnumRects();
//
//while ( rClipRegion.GetEnumRects( hRegionHandle, aRect ) )
//{
// double nX1 = aRect.Left();
// double nY1 = aRect.Top();
// double nX2 = aRect.Right();
// double nY2 = aRect.Bottom();
// ImplWriteDouble( nX1 );
// ImplWriteDouble( nY1 );
// ImplWriteByte( 'm' );
// ImplWriteDouble( nX2 );
// ImplWriteDouble( nY1 );
// ImplWriteByte( 'l' );
// ImplWriteDouble( nX2 );
// ImplWriteDouble( nY2 );
// ImplWriteByte( 'l' );
// ImplWriteDouble( nX1 );
// ImplWriteDouble( nY2 );
// ImplWriteByte( 'l' );
// ImplWriteDouble( nX1 );
// ImplWriteDouble( nY1 );
// ImplWriteByte( 'l', PS_SPACE | PS_WRAP );
//};
//rClipRegion.EndEnumRects( hRegionHandle );
ImplWriteLine( "eoclip newpath" );
}
}
//---------------------------------------------------------------------------------
// possible gfx formats:
//
// level 1: grayscale 8 bit
// color 24 bit
//
// level 2: grayscale 8 bit
// color 1(pal), 4(pal), 8(pal), 24 Bit
//
void PSWriter::ImplBmp( Bitmap* pBitmap, Bitmap* pMaskBitmap, const Point & rPoint, double nXWidth, double nYHeightOrg )
{
if ( !pBitmap )
return;
sal_Int32 nHeightOrg = pBitmap->GetSizePixel().Height();
sal_Int32 nHeightLeft = nHeightOrg;
long nWidth = pBitmap->GetSizePixel().Width();
Point aSourcePos( rPoint );
while ( nHeightLeft )
{
Bitmap aTileBitmap( *pBitmap );
long nHeight = nHeightLeft;
double nYHeight = nYHeightOrg;
sal_Bool bDoTrans = sal_False;
Rectangle aRect;
Region aRegion;
if ( pMaskBitmap )
{
bDoTrans = sal_True;
while (sal_True)
{
if ( mnLevel == 1 )
{
if ( nHeight > 10 )
nHeight = 8;
}
aRect = Rectangle( Point( 0, nHeightOrg - nHeightLeft ), Size( (long)nWidth, (long)nHeight ) );
aRegion = Region( pMaskBitmap->CreateRegion( COL_BLACK, aRect ) );
if( mnLevel == 1 )
{
RectangleVector aRectangleVector;
aRegion.GetRegionRectangles(aRectangleVector);
if ( aRectangleVector.size() * 5 > 1000 )
{
nHeight >>= 1;
if ( nHeight < 2 )
return;
continue;
}
}
break;
}
}
if ( nHeight != nHeightOrg )
{
nYHeight = nYHeightOrg * nHeight / nHeightOrg;
aTileBitmap.Crop( Rectangle( Point( 0, nHeightOrg - nHeightLeft ), Size( nWidth, nHeight ) ) );
}
if ( bDoTrans )
{
ImplWriteLine( "gs\npum" );
ImplTranslate( aSourcePos.X(), aSourcePos.Y() );
ImplScale( nXWidth / nWidth, nYHeight / nHeight );
RectangleVector aRectangles;
aRegion.GetRegionRectangles(aRectangles);
const long nMoveVertical(nHeightLeft - nHeightOrg);
for(RectangleVector::iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++)
{
aRectIter->Move(0, nMoveVertical);
ImplWriteLong( aRectIter->Left() );
ImplWriteLong( aRectIter->Top() );
ImplWriteByte( 'm' );
ImplWriteLong( aRectIter->Right() + 1 );
ImplWriteLong( aRectIter->Top() );
ImplWriteByte( 'l' );
ImplWriteLong( aRectIter->Right() + 1 );
ImplWriteLong( aRectIter->Bottom() + 1 );
ImplWriteByte( 'l' );
ImplWriteLong( aRectIter->Left() );
ImplWriteLong( aRectIter->Bottom() + 1 );
ImplWriteByte( 'l' );
ImplWriteByte( 'p', PS_SPACE | PS_WRAP );
}
//RegionHandle hRegionHandle = aRegion.BeginEnumRects();
//
//while ( aRegion.GetEnumRects( hRegionHandle, aRect ) )
//{
// aRect.Move( 0, - ( nHeightOrg - nHeightLeft ) );
// ImplWriteLong( aRect.Left() );
// ImplWriteLong( aRect.Top() );
// ImplWriteByte( 'm' );
// ImplWriteLong( aRect.Right() + 1 );
// ImplWriteLong( aRect.Top() );
// ImplWriteByte( 'l' );
// ImplWriteLong( aRect.Right() + 1 );
// ImplWriteLong( aRect.Bottom() + 1 );
// ImplWriteByte( 'l' );
// ImplWriteLong( aRect.Left() );
// ImplWriteLong( aRect.Bottom() + 1 );
// ImplWriteByte( 'l' );
// ImplWriteByte( 'p', PS_SPACE | PS_WRAP );
//};
//aRegion.EndEnumRects( hRegionHandle );
ImplWriteLine( "eoclip newpath" );
ImplWriteLine( "pom" );
}
BitmapReadAccess* pAcc = aTileBitmap.AcquireReadAccess();
if (!bDoTrans )
ImplWriteLine( "pum" );
ImplTranslate( aSourcePos.X(), aSourcePos.Y() + nYHeight );
ImplScale( nXWidth, nYHeight );
if ( mnLevel == 1 ) // level 1 is always grayscale !!!
{
ImplWriteLong( nWidth );
ImplWriteLong( nHeight );
*mpPS << "8 [";
ImplWriteLong( nWidth );
*mpPS << "0 0 ";
ImplWriteLong( -nHeight );
ImplWriteLong( 0 );
ImplWriteLong( nHeight );
ImplWriteLine( "]" );
*mpPS << "{currentfile ";
ImplWriteLong( nWidth );
ImplWriteLine( "string readhexstring pop}" );
ImplWriteLine( "image" );
for ( long y = 0; y < nHeight; y++ )
{
for ( long x = 0; x < nWidth; x++ )
{
ImplWriteHexByte( pAcc->GetPixelIndex( y, x ) );
}
}
*mpPS << (sal_uInt8)10;
}
else // Level 2
{
if ( mbGrayScale )
{
ImplWriteLine( "/DeviceGray setcolorspace" );
ImplWriteLine( "<<" );
ImplWriteLine( "/ImageType 1" );
*mpPS << "/Width ";
ImplWriteLong( nWidth, PS_RET );
*mpPS << "/Height ";
ImplWriteLong( nHeight, PS_RET );
ImplWriteLine( "/BitsPerComponent 8" );
ImplWriteLine( "/Decode[0 1]" );
*mpPS << "/ImageMatrix[";
ImplWriteLong( nWidth );
*mpPS << "0 0 ";
ImplWriteLong( -nHeight );
ImplWriteLong( 0 );
ImplWriteLong( nHeight, PS_NONE );
ImplWriteByte( ']', PS_RET );
ImplWriteLine( "/DataSource currentfile" );
ImplWriteLine( "/ASCIIHexDecode filter" );
if ( mbCompression )
ImplWriteLine( "/LZWDecode filter" );
ImplWriteLine( ">>" );
ImplWriteLine( "image" );
if ( mbCompression )
{
StartCompression();
for ( long y = 0; y < nHeight; y++ )
{
for ( long x = 0; x < nWidth; x++ )
{
Compress( pAcc->GetPixelIndex( y, x ) );
}
}
EndCompression();
}
else
{
for ( long y = 0; y < nHeight; y++ )
{
for ( long x = 0; x < nWidth; x++ )
{
ImplWriteHexByte( pAcc->GetPixelIndex( y, x ) );
}
}
}
}
else
{
// have we to write a palette ?
if ( pAcc->HasPalette() )
{
ImplWriteLine( "[/Indexed /DeviceRGB " );
ImplWriteLong( pAcc->GetPaletteEntryCount() - 1, PS_RET );
ImplWriteByte( '<', PS_NONE );
for ( sal_uInt16 i = 0; i < pAcc->GetPaletteEntryCount(); i++ )
{
BitmapColor aBitmapColor = pAcc->GetPaletteColor( i );
ImplWriteHexByte( aBitmapColor.GetRed(), PS_NONE );
ImplWriteHexByte( aBitmapColor.GetGreen(), PS_NONE );
ImplWriteHexByte( aBitmapColor.GetBlue(), PS_SPACE | PS_WRAP );
}
ImplWriteByte( '>', PS_RET );
ImplWriteLine( "] setcolorspace" );
ImplWriteLine( "<<" );
ImplWriteLine( "/ImageType 1" );
*mpPS << "/Width ";
ImplWriteLong( nWidth, PS_RET );
*mpPS << "/Height ";
ImplWriteLong( nHeight, PS_RET );
ImplWriteLine( "/BitsPerComponent 8" );
ImplWriteLine( "/Decode[0 255]" );
*mpPS << "/ImageMatrix[";
ImplWriteLong( nWidth );
*mpPS << "0 0 ";
ImplWriteLong( -nHeight );
ImplWriteLong( 0);
ImplWriteLong( nHeight, PS_NONE );
ImplWriteByte( ']', PS_RET );
ImplWriteLine( "/DataSource currentfile" );
ImplWriteLine( "/ASCIIHexDecode filter" );
if ( mbCompression )
ImplWriteLine( "/LZWDecode filter" );
ImplWriteLine( ">>" );
ImplWriteLine( "image" );
if ( mbCompression )
{
StartCompression();
for ( long y = 0; y < nHeight; y++ )
{
for ( long x = 0; x < nWidth; x++ )
{
Compress( pAcc->GetPixelIndex( y, x ) );
}
}
EndCompression();
}
else
{
for ( long y = 0; y < nHeight; y++ )
{
for ( long x = 0; x < nWidth; x++ )
{
ImplWriteHexByte( pAcc->GetPixelIndex( y, x ) );
}
}
}
}
else // 24 bit color
{
ImplWriteLine( "/DeviceRGB setcolorspace" );
ImplWriteLine( "<<" );
ImplWriteLine( "/ImageType 1" );
*mpPS << "/Width ";
ImplWriteLong( nWidth, PS_RET );
*mpPS << "/Height ";
ImplWriteLong( nHeight, PS_RET );
ImplWriteLine( "/BitsPerComponent 8" );
ImplWriteLine( "/Decode[0 1 0 1 0 1]" );
*mpPS << "/ImageMatrix[";
ImplWriteLong( nWidth );
*mpPS << "0 0 ";
ImplWriteLong( -nHeight );
ImplWriteLong( 0 );
ImplWriteLong( nHeight, PS_NONE );
ImplWriteByte( ']', PS_RET );
ImplWriteLine( "/DataSource currentfile" );
ImplWriteLine( "/ASCIIHexDecode filter" );
if ( mbCompression )
ImplWriteLine( "/LZWDecode filter" );
ImplWriteLine( ">>" );
ImplWriteLine( "image" );
if ( mbCompression )
{
StartCompression();
for ( long y = 0; y < nHeight; y++ )
{
for ( long x = 0; x < nWidth; x++ )
{
const BitmapColor aBitmapColor( pAcc->GetPixel( y, x ) );
Compress( aBitmapColor.GetRed() );
Compress( aBitmapColor.GetGreen() );
Compress( aBitmapColor.GetBlue() );
}
}
EndCompression();
}
else
{
for ( long y = 0; y < nHeight; y++ )
{
for ( long x = 0; x < nWidth; x++ )
{
const BitmapColor aBitmapColor( pAcc->GetPixel( y, x ) );
ImplWriteHexByte( aBitmapColor.GetRed() );
ImplWriteHexByte( aBitmapColor.GetGreen() );
ImplWriteHexByte( aBitmapColor.GetBlue() );
}
}
}
}
}
ImplWriteLine( ">" ); // in Level 2 the dictionary needs to be closed (eod)
}
if ( bDoTrans )
ImplWriteLine( "gr" );
else
ImplWriteLine( "pom" );
aTileBitmap.ReleaseAccess( pAcc );
nHeightLeft -= nHeight;
if ( nHeightLeft )
{
nHeightLeft++;
aSourcePos.Y() = (long) ( rPoint.Y() + ( nYHeightOrg * ( nHeightOrg - nHeightLeft ) ) / nHeightOrg );
}
}
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteCharacter( sal_Char nChar )
{
switch( nChar )
{
case '(' :
case ')' :
case '\\' :
ImplWriteByte( (sal_uInt8)'\\', PS_NONE );
}
ImplWriteByte( (sal_uInt8)nChar, PS_NONE );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteString( const ByteString& rString, VirtualDevice& rVDev, const sal_Int32* pDXArry, sal_Bool bStretch )
{
sal_uInt16 nLen = rString.Len();
if ( nLen )
{
sal_uInt16 i;
if ( pDXArry )
{
double nx = 0;
for( i = 0; i < nLen; i++ )
{
if ( i > 0 )
nx = pDXArry[ i - 1 ];
ImplWriteDouble( ( bStretch ) ? nx : rVDev.GetTextWidth( rString.GetChar( i ) ) );
ImplWriteDouble( nx );
ImplWriteLine( "(", PS_NONE );
ImplWriteCharacter( rString.GetChar( i ) );
ImplWriteLine( ") bs" );
}
}
else
{
ImplWriteByte( '(', PS_NONE );
for ( i = 0; i < nLen; i++ )
ImplWriteCharacter( rString.GetChar( i ) );
ImplWriteLine( ") sw" );
}
}
}
// ------------------------------------------------------------------------
void PSWriter::ImplText( const String& rUniString, const Point& rPos, const sal_Int32* pDXArry, sal_Int32 nWidth, VirtualDevice& rVDev )
{
sal_uInt16 nLen = rUniString.Len();
if ( !nLen )
return;
if ( mnTextMode == 0 ) // using glpyh outlines
{
Font aNotRotatedFont( maFont );
aNotRotatedFont.SetOrientation( 0 );
VirtualDevice aVirDev( 1 );
aVirDev.SetMapMode( rVDev.GetMapMode() );
aVirDev.SetFont( aNotRotatedFont );
aVirDev.SetTextAlign( eTextAlign );
sal_Int16 nRotation = maFont.GetOrientation();
Polygon aPolyDummy( 1 );
PolyPolygon aPolyPoly;
Point aPos( rPos );
if ( nRotation )
{
aPolyDummy.SetPoint( aPos, 0 );
aPolyDummy.Rotate( rPos, nRotation );
aPos = aPolyDummy.GetPoint( 0 );
}
sal_Bool bOldLineColor = bLineColor;
bLineColor = sal_False;
std::vector<PolyPolygon> aPolyPolyVec;
if ( aVirDev.GetTextOutlines( aPolyPolyVec, rUniString, 0, 0, STRING_LEN, sal_True, nWidth, pDXArry ) )
{
// always adjust text position to match baseline alignment
ImplWriteLine( "pum" );
ImplWriteDouble( aPos.X() );
ImplWriteDouble( aPos.Y() );
ImplWriteLine( "t" );
if ( nRotation )
{
ImplWriteF( nRotation, 1 );
*mpPS << "r ";
}
std::vector<PolyPolygon>::iterator aIter( aPolyPolyVec.begin() );
while ( aIter != aPolyPolyVec.end() )
ImplPolyPoly( *aIter++, sal_True );
ImplWriteLine( "pom" );
}
bLineColor = bOldLineColor;
}
else if ( ( mnTextMode == 1 ) || ( mnTextMode == 2 ) ) // normal text output
{
if ( mnTextMode == 2 ) // forcing output one complete text packet, by
pDXArry = NULL; // ignoring the kerning array
ImplSetAttrForText( rPos );
ByteString aStr( rUniString, maFont.GetCharSet() );
ImplWriteString( aStr, rVDev, pDXArry, nWidth != 0 );
if ( maFont.GetOrientation() )
ImplWriteLine( "gr" );
}
}
// ------------------------------------------------------------------------
void PSWriter::ImplSetAttrForText( const Point& rPoint )
{
Point aPoint( rPoint );
long nRotation = maFont.GetOrientation();
ImplWriteTextColor();
Size aSize = maFont.GetSize();
if ( maLastFont != maFont )
{
if ( maFont.GetPitch() == PITCH_FIXED ) // a little bit font selection
ImplDefineFont( "Courier", "Oblique" );
else if ( maFont.GetCharSet() == RTL_TEXTENCODING_SYMBOL )
ImplWriteLine( "/Symbol findfont" );
else if ( maFont.GetFamily() == FAMILY_SWISS )
ImplDefineFont( "Helvetica", "Oblique" );
else
ImplDefineFont( "Times", "Italic" );
maLastFont = maFont;
aSize = maFont.GetSize();
ImplWriteDouble( aSize.Height() );
*mpPS << "sf ";
}
if ( eTextAlign != ALIGN_BASELINE )
{ // PostScript kennt kein FontAlignment
if ( eTextAlign == ALIGN_TOP ) // -> ich gehe daher davon aus, dass
aPoint.Y() += ( aSize.Height() * 4 / 5 ); // der Bereich unter der Baseline
else if ( eTextAlign == ALIGN_BOTTOM ) // in etwa 20% der Fontsize ausmacht
aPoint.Y() -= ( aSize.Height() / 5 );
}
ImplMoveTo( aPoint );
if ( nRotation )
{
*mpPS << "gs ";
ImplWriteF( nRotation, 1 );
*mpPS << "r ";
}
}
//---------------------------------------------------------------------------------
void PSWriter::ImplDefineFont( const char* pOriginalName, const char* pItalic )
{
*mpPS << (sal_uInt8)'/'; //convert the font pOriginalName using ISOLatin1Encoding
*mpPS << pOriginalName;
switch ( maFont.GetWeight() )
{
case WEIGHT_SEMIBOLD :
case WEIGHT_BOLD :
case WEIGHT_ULTRABOLD :
case WEIGHT_BLACK :
*mpPS << "-Bold";
if ( maFont.GetItalic() != ITALIC_NONE )
*mpPS << pItalic;
break;
default:
if ( maFont.GetItalic() != ITALIC_NONE )
*mpPS << pItalic;
break;
}
ImplWriteLine( " f" );
}
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
void PSWriter::ImplClosePathDraw( sal_uLong nMode )
{
*mpPS << "pc";
mnCursorPos += 2;
ImplExecMode( nMode );
}
void PSWriter::ImplPathDraw()
{
*mpPS << "ps";
mnCursorPos += 2;
ImplExecMode( PS_RET );
}
//---------------------------------------------------------------------------------
inline void PSWriter::ImplWriteLineColor( sal_uLong nMode )
{
if ( aColor != aLineColor )
{
aColor = aLineColor;
ImplWriteColor( nMode );
}
}
inline void PSWriter::ImplWriteFillColor( sal_uLong nMode )
{
if ( aColor != aFillColor )
{
aColor = aFillColor;
ImplWriteColor( nMode );
}
}
inline void PSWriter::ImplWriteTextColor( sal_uLong nMode )
{
if ( aColor != aTextColor )
{
aColor = aTextColor;
ImplWriteColor( nMode );
}
}
inline void PSWriter::ImplWriteTextFillColor( sal_uLong nMode )
{
if ( aColor != aTextFillColor )
{
aColor = aTextFillColor;
ImplWriteColor( nMode );
}
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteColor( sal_uLong nMode )
{
if ( mbGrayScale )
{
// writes the Color (grayscale) as a Number from 0.000 up to 1.000
ImplWriteF( 1000 * ( (sal_uInt8)aColor.GetRed() * 77 + (sal_uInt8)aColor.GetGreen() * 151 +
(sal_uInt8)aColor.GetBlue() * 28 + 1 ) / 65536, 3, nMode );
}
else
{
ImplWriteB1 ( (sal_uInt8)aColor.GetRed() );
ImplWriteB1 ( (sal_uInt8)aColor.GetGreen() );
ImplWriteB1 ( (sal_uInt8)aColor.GetBlue() );
}
*mpPS << "c"; // ( c is defined as setrgbcolor or setgray )
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
double PSWriter::ImplGetScaling( const MapMode& rMapMode )
{
double nMul;
switch ( rMapMode.GetMapUnit() )
{
case MAP_PIXEL :
case MAP_SYSFONT :
case MAP_APPFONT :
case MAP_100TH_MM :
nMul = 1;
break;
case MAP_10TH_MM :
nMul = 10;
break;
case MAP_MM :
nMul = 100;
break;
case MAP_CM :
nMul = 1000;
break;
case MAP_1000TH_INCH :
nMul = 2.54;
break;
case MAP_100TH_INCH :
nMul = 25.4;
break;
case MAP_10TH_INCH :
nMul = 254;
break;
case MAP_INCH :
nMul = 2540;
break;
case MAP_TWIP :
nMul = 1.76388889;
break;
case MAP_POINT :
nMul = 35.27777778;
break;
default:
nMul = 1.0;
break;
}
return nMul;
}
//---------------------------------------------------------------------------------
void PSWriter::ImplGetMapMode( const MapMode& rMapMode )
{
ImplWriteLine( "tm setmatrix" );
double fMul = ImplGetScaling( rMapMode );
double fScaleX = (double)rMapMode.GetScaleX() * fMul;
double fScaleY = (double)rMapMode.GetScaleY() * fMul;
ImplTranslate( rMapMode.GetOrigin().X() * fScaleX, rMapMode.GetOrigin().Y() * fScaleY );
ImplScale( fScaleX, fScaleY );
}
//---------------------------------------------------------------------------------
inline void PSWriter::ImplExecMode( sal_uLong nMode )
{
if ( nMode & PS_WRAP )
{
if ( mnCursorPos >= PS_LINESIZE )
{
mnCursorPos = 0;
*mpPS << (sal_uInt8)0xa;
return;
}
}
if ( nMode & PS_SPACE )
{
*mpPS << (sal_uInt8)32;
mnCursorPos++;
}
if ( nMode & PS_RET )
{
*mpPS << (sal_uInt8)0xa;
mnCursorPos = 0;
}
}
//---------------------------------------------------------------------------------
inline void PSWriter::ImplWriteLine( const char* pString, sal_uLong nMode )
{
sal_uLong i = 0;
while ( pString[ i ] )
{
*mpPS << (sal_uInt8)pString[ i++ ];
}
mnCursorPos += i;
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteLineInfo( double fLWidth, double fMLimit,
SvtGraphicStroke::CapType eLCap,
SvtGraphicStroke::JoinType eJoin,
SvtGraphicStroke::DashArray& rLDash )
{
if ( fLineWidth != fLWidth )
{
fLineWidth = fLWidth;
ImplWriteDouble( fLineWidth );
ImplWriteLine( "lw", PS_SPACE );
}
if ( eLineCap != eLCap )
{
eLineCap = eLCap;
ImplWriteLong( (sal_Int32)eLineCap, PS_SPACE );
ImplWriteLine( "lc", PS_SPACE );
}
if ( eJoinType != eJoin )
{
eJoinType = eJoin;
ImplWriteLong( (sal_Int32)eJoinType, PS_SPACE );
ImplWriteLine( "lj", PS_SPACE );
}
if ( eJoinType == SvtGraphicStroke::joinMiter )
{
if ( fMiterLimit != fMLimit )
{
fMiterLimit = fMLimit;
ImplWriteDouble( fMiterLimit );
ImplWriteLine( "ml", PS_SPACE );
}
}
if ( aDashArray != rLDash )
{
aDashArray = rLDash;
sal_uInt32 j, i = aDashArray.size();
ImplWriteLine( "[", PS_SPACE );
for ( j = 0; j < i; j++ )
ImplWriteDouble( aDashArray[ j ] );
ImplWriteLine( "] 0 ld" );
}
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteLineInfo( const LineInfo& rLineInfo )
{
SvtGraphicStroke::DashArray l_aDashArray;
if ( rLineInfo.GetStyle() == LINE_DASH )
l_aDashArray.push_back( 2 );
const double fLWidth(( ( rLineInfo.GetWidth() + 1 ) + ( rLineInfo.GetWidth() + 1 ) ) * 0.5);
SvtGraphicStroke::JoinType aJoinType(SvtGraphicStroke::joinMiter);
SvtGraphicStroke::CapType aCapType(SvtGraphicStroke::capButt);
switch(rLineInfo.GetLineJoin())
{
default: // B2DLINEJOIN_NONE, B2DLINEJOIN_MIDDLE
// do NOT use SvtGraphicStroke::joinNone here
// since it will be written as numerical value directly
// and is NOT a valid EPS value
break;
case basegfx::B2DLINEJOIN_MITER:
aJoinType = SvtGraphicStroke::joinMiter;
break;
case basegfx::B2DLINEJOIN_BEVEL:
aJoinType = SvtGraphicStroke::joinBevel;
break;
case basegfx::B2DLINEJOIN_ROUND:
aJoinType = SvtGraphicStroke::joinRound;
break;
}
switch(rLineInfo.GetLineCap())
{
default: /* com::sun::star::drawing::LineCap_BUTT */
{
aCapType = SvtGraphicStroke::capButt;
break;
}
case com::sun::star::drawing::LineCap_ROUND:
{
aCapType = SvtGraphicStroke::capRound;
break;
}
case com::sun::star::drawing::LineCap_SQUARE:
{
aCapType = SvtGraphicStroke::capSquare;
break;
}
}
ImplWriteLineInfo( fLWidth, fMiterLimit, aCapType, aJoinType, l_aDashArray );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteLong( sal_Int32 nNumber, sal_uLong nMode )
{
const ByteString aNumber( ByteString::CreateFromInt32( nNumber ) );
sal_uLong nLen = aNumber.Len();
mnCursorPos += nLen;
for ( sal_uInt16 n = 0; n < nLen; n++ )
*mpPS << aNumber.GetChar( n );
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteDouble( double fNumber, sal_uLong nMode )
{
sal_Int32 nLength;
sal_Int32 nPTemp = (sal_Int32)fNumber;
sal_Int32 nATemp = labs( (sal_Int32)( ( fNumber - nPTemp ) * 100000 ) );
if ( !nPTemp && nATemp && ( fNumber < 0.0 ) )
*mpPS << (sal_Char)'-';
ByteString aNumber1( ByteString::CreateFromInt32( nPTemp ) );
nLength = aNumber1.Len();
mnCursorPos += nLength;
for ( sal_Int32 n = 0; n < nLength; n++ )
*mpPS << aNumber1.GetChar( (sal_uInt16)n );
int zCount = 0;
if ( nATemp )
{
*mpPS << (sal_uInt8)'.';
mnCursorPos++;
const ByteString aNumber2( ByteString::CreateFromInt32( nATemp ) );
sal_Int16 n, nLen = aNumber2.Len();
if ( nLen < 8 )
{
mnCursorPos += 6 - nLen;
for ( n = 0; n < ( 5 - nLen ); n++ )
{
*mpPS << (sal_uInt8)'0';
}
}
mnCursorPos += nLen;
for ( n = 0; n < nLen; n++ )
{
*mpPS << aNumber2.GetChar( n );
zCount--;
if ( aNumber2.GetChar( n ) != '0' )
zCount = 0;
}
if ( zCount )
mpPS->SeekRel( zCount );
}
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
// writes the number to stream: nNumber / ( 10^nCount )
void PSWriter::ImplWriteF( sal_Int32 nNumber, sal_uLong nCount, sal_uLong nMode )
{
if ( nNumber < 0 )
{
*mpPS << (sal_uInt8)'-';
nNumber = -nNumber;
mnCursorPos++;
}
const ByteString aScaleFactor( ByteString::CreateFromInt32( nNumber ) );
sal_uLong nLen = aScaleFactor.Len();
long nStSize = ( nCount + 1 ) - nLen;
if ( nStSize >= 1 )
{
*mpPS << (sal_uInt8)'0';
mnCursorPos++;
}
if ( nStSize >= 2 )
{
*mpPS << (sal_uInt8)'.';
for ( long i = 1; i < nStSize; i++ )
{
*mpPS << (sal_uInt8)'0';
mnCursorPos++;
}
}
mnCursorPos += nLen;
for( sal_uInt16 n = 0UL; n < nLen; n++ )
{
if ( n == nLen - nCount )
{
*mpPS << (sal_uInt8)'.';
mnCursorPos++;
}
*mpPS << aScaleFactor.GetChar( n );
}
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteByte( sal_uInt8 nNumb, sal_uLong nMode )
{
*mpPS << ( nNumb );
mnCursorPos++;
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
void PSWriter::ImplWriteHexByte( sal_uInt8 nNumb, sal_uLong nMode )
{
if ( ( nNumb >> 4 ) > 9 )
*mpPS << (sal_uInt8)( ( nNumb >> 4 ) + 'A' - 10 );
else
*mpPS << (sal_uInt8)( ( nNumb >> 4 ) + '0' );
if ( ( nNumb & 0xf ) > 9 )
*mpPS << (sal_uInt8)( ( nNumb & 0xf ) + 'A' - 10 );
else
*mpPS << (sal_uInt8)( ( nNumb & 0xf ) + '0' );
mnCursorPos += 2;
ImplExecMode( nMode );
}
//---------------------------------------------------------------------------------
// writes the sal_uInt8 nNumb as a Number from 0.000 up to 1.000
void PSWriter::ImplWriteB1( sal_uInt8 nNumb, sal_uLong nMode )
{
ImplWriteF( 1000 * ( nNumb + 1 ) / 256 , 3, nMode );
}
// ------------------------------------------------------------------------
inline void PSWriter::WriteBits( sal_uInt16 nCode, sal_uInt16 nCodeLen )
{
dwShift |= ( nCode << ( nOffset - nCodeLen ) );
nOffset -= nCodeLen;
while ( nOffset < 24 )
{
ImplWriteHexByte( (sal_uInt8)( dwShift >> 24 ) );
dwShift <<= 8;
nOffset += 8;
}
if ( nCode == 257 && nOffset != 32 )
ImplWriteHexByte( (sal_uInt8)( dwShift >> 24 ) );
}
// ------------------------------------------------------------------------
void PSWriter::StartCompression()
{
sal_uInt16 i;
nDataSize = 8;
nClearCode = 1 << nDataSize;
nEOICode = nClearCode + 1;
nTableSize = nEOICode + 1;
nCodeSize = nDataSize + 1;
nOffset = 32; // anzahl freier bits in dwShift
dwShift = 0;
pTable = new PSLZWCTreeNode[ 4096 ];
for ( i = 0; i < 4096; i++ )
{
pTable[ i ].pBrother = pTable[ i ].pFirstChild = NULL;
pTable[ i ].nValue = (sal_uInt8)( pTable[ i ].nCode = i );
}
pPrefix = NULL;
WriteBits( nClearCode, nCodeSize );
}
// ------------------------------------------------------------------------
void PSWriter::Compress( sal_uInt8 nCompThis )
{
PSLZWCTreeNode* p;
sal_uInt16 i;
sal_uInt8 nV;
if( !pPrefix )
{
pPrefix = pTable + nCompThis;
}
else
{
nV = nCompThis;
for( p = pPrefix->pFirstChild; p != NULL; p = p->pBrother )
{
if ( p->nValue == nV )
break;
}
if( p )
pPrefix = p;
else
{
WriteBits( pPrefix->nCode, nCodeSize );
if ( nTableSize == 409 )
{
WriteBits( nClearCode, nCodeSize );
for ( i = 0; i < nClearCode; i++ )
pTable[ i ].pFirstChild = NULL;
nCodeSize = nDataSize + 1;
nTableSize = nEOICode + 1;
}
else
{
if( nTableSize == (sal_uInt16)( ( 1 << nCodeSize ) - 1 ) )
nCodeSize++;
p = pTable + ( nTableSize++ );
p->pBrother = pPrefix->pFirstChild;
pPrefix->pFirstChild = p;
p->nValue = nV;
p->pFirstChild = NULL;
}
pPrefix = pTable + nV;
}
}
}
// ------------------------------------------------------------------------
void PSWriter::EndCompression()
{
if( pPrefix )
WriteBits( pPrefix->nCode, nCodeSize );
WriteBits( nEOICode, nCodeSize );
delete[] pTable;
}
// ------------------------------------------------------------------------
sal_uInt8* PSWriter::ImplSearchEntry( sal_uInt8* pSource, sal_uInt8* pDest, sal_uLong nComp, sal_uLong nSize )
{
while ( nComp-- >= nSize )
{
sal_uLong i;
for ( i = 0; i < nSize; i++ )
{
if ( ( pSource[i]&~0x20 ) != ( pDest[i]&~0x20 ) )
break;
}
if ( i == nSize )
return pSource;
pSource++;
}
return NULL;
}
// ------------------------------------------------------------------------
sal_Bool PSWriter::ImplGetBoundingBox( double* nNumb, sal_uInt8* pSource, sal_uLong nSize )
{
sal_Bool bRetValue = sal_False;
sal_uLong nBytesRead;
if ( nSize < 256 ) // we assume that the file is greater than 256 bytes
return sal_False;
if ( nSize < POSTSCRIPT_BOUNDINGSEARCH )
nBytesRead = nSize;
else
nBytesRead = POSTSCRIPT_BOUNDINGSEARCH;
sal_uInt8* pDest = ImplSearchEntry( pSource, (sal_uInt8*)"%%BoundingBox:", nBytesRead, 14 );
if ( pDest )
{
int nSecurityCount = 100; // only 100 bytes following the bounding box will be checked
nNumb[0] = nNumb[1] = nNumb[2] = nNumb[3] = 0;
pDest += 14;
for ( int i = 0; ( i < 4 ) && nSecurityCount; i++ )
{
int nDivision = 1;
sal_Bool bDivision = sal_False;
sal_Bool bNegative = sal_False;
sal_Bool bValid = sal_True;
while ( ( --nSecurityCount ) && ( ( *pDest == ' ' ) || ( *pDest == 0x9 ) ) )
pDest++;
sal_uInt8 nByte = *pDest;
while ( nSecurityCount && ( nByte != ' ' ) && ( nByte != 0x9 ) && ( nByte != 0xd ) && ( nByte != 0xa ) )
{
switch ( nByte )
{
case '.' :
if ( bDivision )
bValid = sal_False;
else
bDivision = sal_True;
break;
case '-' :
bNegative = sal_True;
break;
default :
if ( ( nByte < '0' ) || ( nByte > '9' ) )
nSecurityCount = 1; // error parsing the bounding box values
else if ( bValid )
{
if ( bDivision )
nDivision*=10;
nNumb[i] *= 10;
nNumb[i] += nByte - '0';
}
break;
}
nSecurityCount--;
nByte = *(++pDest);
}
if ( bNegative )
nNumb[i] = -nNumb[i];
if ( bDivision && ( nDivision != 1 ) )
nNumb[i] /= nDivision;
}
if ( nSecurityCount)
bRetValue = sal_True;
}
return bRetValue;
}
//================== GraphicExport - die exportierte Funktion ================
extern "C" sal_Bool __LOADONCALLAPI GraphicExport( SvStream & rStream, Graphic & rGraphic, FilterConfigItem* pFilterConfigItem, sal_Bool)
{
PSWriter aPSWriter;
return aPSWriter.WritePS( rGraphic, rStream, pFilterConfigItem );
}