?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update git submodules
[LibreOffice.git] / vcl / source / filter / eps / eps.cxx
blobccd62939fd567330e26f494a9ab0eb10ceec5118
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <filter/EpsWriter.hxx>
21 #include <tools/stream.hxx>
22 #include <tools/poly.hxx>
23 #include <tools/fract.hxx>
24 #include <tools/helpers.hxx>
25 #include <tools/UnitConversion.hxx>
26 #include <unotools/resmgr.hxx>
27 #include <vcl/svapp.hxx>
28 #include <vcl/metaact.hxx>
29 #include <vcl/graph.hxx>
30 #include <vcl/BitmapReadAccess.hxx>
31 #include <vcl/region.hxx>
32 #include <vcl/font.hxx>
33 #include <vcl/virdev.hxx>
34 #include <vcl/cvtgrf.hxx>
35 #include <vcl/gradient.hxx>
36 #include <unotools/configmgr.hxx>
37 #include <vcl/FilterConfigItem.hxx>
38 #include <vcl/graphictools.hxx>
39 #include <vcl/weld.hxx>
40 #include <strings.hrc>
41 #include <osl/diagnose.h>
42 #include <com/sun/star/task/XStatusIndicator.hpp>
43 #include <officecfg/Office/Common.hxx>
44
45 #include <cstdlib>
46 #include <memory>
47
48 using namespace ::com::sun::star::uno;
49
50 #define POSTSCRIPT_BOUNDINGSEARCH 0x1000 // we only try to get the BoundingBox
51 // in the first 4096 bytes
52
53 #define EPS_PREVIEW_TIFF 1
54 #define EPS_PREVIEW_EPSI 2
55
56 #define PS_LINESIZE 70 // maximum number of characters a line in the output
57
58 // -----------------------------field-types------------------------------
59
60 namespace {
61
62 struct StackMember
63 {
64 struct StackMember * pSucc;
65 Color aGlobalCol;
66 bool bLineCol;
67 Color aLineCol;
68 bool bFillCol;
69 Color aFillCol;
70 Color aTextCol;
71 bool bTextFillCol;
72 Color aTextFillCol;
73 Color aBackgroundCol;
74 vcl::Font aFont;
75 TextAlign eTextAlign;
76
77 double fLineWidth;
78 double fMiterLimit;
79 SvtGraphicStroke::CapType eLineCap;
80 SvtGraphicStroke::JoinType eJoinType;
81 SvtGraphicStroke::DashArray aDashArray;
82 };
83
84 struct PSLZWCTreeNode
85 {
86
87 PSLZWCTreeNode* pBrother; // next node who has the same father
88 PSLZWCTreeNode* pFirstChild; // first son
89 sal_uInt16 nCode; // The code for the string of pixel values, which arises if... <missing comment>
90 sal_uInt16 nValue; // the pixel value
91 };
92
93 enum NMode {PS_NONE = 0x00, PS_SPACE = 0x01, PS_RET = 0x02, PS_WRAP = 0x04}; // formatting mode: action which is inserted behind the output
94 inline NMode operator|(NMode a, NMode b)
95 {
96 return static_cast<NMode>(static_cast<sal_uInt8>(a) | static_cast<sal_uInt8>(b));
97 }
98
99 class PSWriter
100 {
101 private:
102 bool mbStatus;
103 bool mbLevelWarning; // if there any embedded eps file which was not exported
104 sal_uInt32 mnLatestPush; // offset to streamposition, where last push was done
105
106 tools::Long mnLevel; // dialog options
107 bool mbGrayScale;
108 bool mbCompression;
109 sal_Int32 mnPreview;
110 sal_Int32 mnTextMode;
111
112 SvStream* mpPS;
113 const GDIMetaFile* pMTF;
114 std::unique_ptr<GDIMetaFile>
115 pAMTF; // only created if Graphics is not a Metafile
116 ScopedVclPtrInstance<VirtualDevice>
117 pVDev;
118
119 double nBoundingX2; // this represents the bounding box
120 double nBoundingY2;
121
122 StackMember* pGDIStack;
123 sal_uInt32 mnCursorPos; // current cursor position in output
124 Color aColor; // current color which is used for output
125 bool bLineColor;
126 Color aLineColor; // current GDIMetafile color settings
127 bool bFillColor;
128 Color aFillColor;
129 Color aTextColor;
130 bool bTextFillColor;
131 Color aTextFillColor;
132 Color aBackgroundColor;
133 TextAlign eTextAlign;
134
135 double fLineWidth;
136 double fMiterLimit;
137 SvtGraphicStroke::CapType eLineCap;
138 SvtGraphicStroke::JoinType eJoinType;
139 SvtGraphicStroke::DashArray aDashArray;
140
141 vcl::Font maFont;
142 vcl::Font maLastFont;
143
144 std::unique_ptr<PSLZWCTreeNode[]> pTable; // LZW compression data
145 PSLZWCTreeNode* pPrefix; // the compression is as same as the TIFF compression
146 sal_uInt16 nDataSize;
147 sal_uInt16 nClearCode;
148 sal_uInt16 nEOICode;
149 sal_uInt16 nTableSize;
150 sal_uInt16 nCodeSize;
151 sal_uInt32 nOffset;
152 sal_uInt32 dwShift;
153
154 css::uno::Reference< css::task::XStatusIndicator > xStatusIndicator;
155
156 void ImplWriteProlog( const Graphic* pPreviewEPSI );
157 void ImplWriteEpilog();
158 void ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev );
159
160 // this method makes LF's, space inserting and word wrapping as used in all nMode
161 // parameters
162 inline void ImplExecMode( NMode nMode );
163
164 // writes char[] + LF to stream
165 inline void ImplWriteLine( const char*, NMode nMode = PS_RET );
166
167 // writes ( nNumb / 10^nCount ) in ASCII format to stream
168 void ImplWriteF( sal_Int32 nNumb, sal_uInt8 nCount = 3, NMode nMode = PS_SPACE );
169
170 // writes a double in ASCII format to stream
171 void ImplWriteDouble( double );
172
173 // writes a long in ASCII format to stream
174 void ImplWriteLong( sal_Int32 nNumb, NMode nMode = PS_SPACE );
175
176 // writes a byte in ASCII format to stream
177 void ImplWriteByte( sal_uInt8 nNumb, NMode nMode = PS_SPACE );
178
179 // writes a byte in ASCII (hex) format to stream
180 void ImplWriteHexByte( sal_uInt8 nNumb, NMode nMode = PS_WRAP );
181
182 // writes nNumb as number from 0.000 till 1.000 in ASCII format to stream
183 void ImplWriteB1( sal_uInt8 nNumb );
184
185 inline void ImplWritePoint( const Point& );
186 void ImplMoveTo( const Point& );
187 void ImplLineTo( const Point&, NMode nMode = PS_SPACE );
188 void ImplCurveTo( const Point& rP1, const Point& rP2, const Point& rP3, NMode nMode );
189 void ImplTranslate( const double& fX, const double& fY );
190 void ImplScale( const double& fX, const double& fY );
191
192 void ImplAddPath( const tools::Polygon & rPolygon );
193 void ImplWriteLineInfo( double fLineWidth, double fMiterLimit, SvtGraphicStroke::CapType eLineCap,
194 SvtGraphicStroke::JoinType eJoinType, SvtGraphicStroke::DashArray && rDashArray );
195 void ImplWriteLineInfo( const LineInfo& rLineInfo );
196 void ImplRect( const tools::Rectangle & rRectangle );
197 void ImplRectFill ( const tools::Rectangle & rRectangle );
198 void ImplWriteGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev );
199 void ImplIntersect( const tools::PolyPolygon& rPolyPoly );
200 void ImplPolyPoly( const tools::PolyPolygon & rPolyPolygon, bool bTextOutline = false );
201 void ImplPolyLine( const tools::Polygon & rPolygon );
202
203 void ImplSetClipRegion( vcl::Region const & rRegion );
204 void ImplBmp( Bitmap const *, AlphaMask const *, const Point &, double nWidth, double nHeight );
205 void ImplText( const OUString& rUniString, const Point& rPos, KernArraySpan pDXArry, std::span<const sal_Bool> pKashidaArry, sal_Int32 nWidth, VirtualDevice const & rVDev );
206 void ImplSetAttrForText( const Point & rPoint );
207 void ImplWriteCharacter( char );
208 void ImplWriteString( const OString&, VirtualDevice const & rVDev, KernArraySpan pDXArry, bool bStretch );
209 void ImplDefineFont( const char*, const char* );
210
211 void ImplClosePathDraw();
212 void ImplPathDraw();
213
214 inline void ImplWriteLineColor( NMode nMode );
215 inline void ImplWriteFillColor( NMode nMode );
216 inline void ImplWriteTextColor( NMode nMode );
217 void ImplWriteColor( NMode nMode );
218
219 void ImplGetMapMode( const MapMode& );
220 static bool ImplGetBoundingBox( double* nNumb, sal_uInt8* pSource, sal_uInt32 nSize );
221 static sal_uInt8* ImplSearchEntry( sal_uInt8* pSource, sal_uInt8 const * pDest, sal_uInt32 nComp, sal_uInt32 nSize );
222 // LZW methods
223 void StartCompression();
224 void Compress( sal_uInt8 nSrc );
225 void EndCompression();
226 inline void WriteBits( sal_uInt16 nCode, sal_uInt16 nCodeLen );
227
228 public:
229 bool WritePS( const Graphic& rGraphic, SvStream& rTargetStream, FilterConfigItem* );
230 PSWriter();
231 };
232
233 }
234
235 //========================== methods from PSWriter ==========================
236
237
238 PSWriter::PSWriter()
239 : mbStatus(false)
240 , mbLevelWarning(false)
241 , mnLatestPush(0)
242 , mnLevel(0)
243 , mbGrayScale(false)
244 , mbCompression(false)
245 , mnPreview(0)
246 , mnTextMode(0)
247 , mpPS(nullptr)
248 , pMTF(nullptr)
249 , nBoundingX2(0)
250 , nBoundingY2(0)
251 , pGDIStack(nullptr)
252 , mnCursorPos(0)
253 , bLineColor(false)
254 , bFillColor(false)
255 , bTextFillColor(false)
256 , eTextAlign()
257 , fLineWidth(0)
258 , fMiterLimit(0)
259 , eLineCap()
260 , eJoinType()
261 , pPrefix(nullptr)
262 , nDataSize(0)
263 , nClearCode(0)
264 , nEOICode(0)
265 , nTableSize(0)
266 , nCodeSize(0)
267 , nOffset(0)
268 , dwShift(0)
269 {
270 }
271
272 bool PSWriter::WritePS( const Graphic& rGraphic, SvStream& rTargetStream, FilterConfigItem* pFilterConfigItem )
273 {
274 sal_uInt32 nStreamPosition = 0, nPSPosition = 0; // -Wall warning, unset, check
275
276 mbStatus = true;
277 mnPreview = 0;
278 mbLevelWarning = false;
279 mnLatestPush = 0xEFFFFFFE;
280
281 if ( pFilterConfigItem )
282 {
283 xStatusIndicator = pFilterConfigItem->GetStatusIndicator();
284 if ( xStatusIndicator.is() )
285 {
286 xStatusIndicator->start( OUString(), 100 );
287 }
288 }
289
290 mpPS = &rTargetStream;
291 mpPS->SetEndian( SvStreamEndian::LITTLE );
292
293 // default values for the dialog options
294 mnLevel = 2;
295 mbGrayScale = false;
296 #ifdef UNX // don't compress by default on unix as ghostscript is unable to read LZW compressed eps
297 mbCompression = false;
298 #else
299 mbCompression = true;
300 #endif
301 mnTextMode = 0; // default0 : export glyph outlines
302
303 // try to get the dialog selection
304 if ( pFilterConfigItem )
305 {
306 #ifdef UNX // don't put binary tiff preview ahead of postscript code by default on unix as ghostscript is unable to read it
307 mnPreview = pFilterConfigItem->ReadInt32( u"Preview"_ustr, 0 );
308 #else
309 mnPreview = pFilterConfigItem->ReadInt32( "Preview", 1 );
310 #endif
311 mnLevel = pFilterConfigItem->ReadInt32( u"Version"_ustr, 2 );
312 if ( mnLevel != 1 )
313 mnLevel = 2;
314 mbGrayScale = pFilterConfigItem->ReadInt32( u"ColorFormat"_ustr, 1 ) == 2;
315 #ifdef UNX // don't compress by default on unix as ghostscript is unable to read LZW compressed eps
316 mbCompression = pFilterConfigItem->ReadInt32( u"CompressionMode"_ustr, 0 ) != 0;
317 #else
318 mbCompression = pFilterConfigItem->ReadInt32( "CompressionMode", 1 ) == 1;
319 #endif
320 mnTextMode = pFilterConfigItem->ReadInt32( u"TextMode"_ustr, 0 );
321 if ( mnTextMode > 2 )
322 mnTextMode = 0;
323 }
324
325 // compression is not available for Level 1
326 if ( mnLevel == 1 )
327 {
328 mbGrayScale = true;
329 mbCompression = false;
330 }
331
332 if ( mnPreview & EPS_PREVIEW_TIFF )
333 {
334 rTargetStream.WriteUInt32( 0xC6D3D0C5 );
335 nStreamPosition = rTargetStream.Tell();
336 rTargetStream.WriteUInt32( 0 ).WriteUInt32( 0 ).WriteUInt32( 0 ).WriteUInt32( 0 )
337 .WriteUInt32( nStreamPosition + 26 ).WriteUInt32( 0 ).WriteUInt16( 0xffff );
338
339 ErrCode nErrCode;
340 if ( mbGrayScale )
341 {
342 BitmapEx aTempBitmapEx( rGraphic.GetBitmapEx() );
343 aTempBitmapEx.Convert( BmpConversion::N8BitGreys );
344 nErrCode = GraphicConverter::Export( rTargetStream, aTempBitmapEx, ConvertDataFormat::TIF ) ;
345 }
346 else
347 nErrCode = GraphicConverter::Export( rTargetStream, rGraphic, ConvertDataFormat::TIF ) ;
348
349 if ( nErrCode == ERRCODE_NONE )
350 {
351 nPSPosition = rTargetStream.TellEnd();
352 rTargetStream.Seek( nStreamPosition + 20 );
353 rTargetStream.WriteUInt32( nPSPosition - 30 ); // size of tiff gfx
354 rTargetStream.Seek( nPSPosition );
355 }
356 else
357 {
358 mnPreview &=~ EPS_PREVIEW_TIFF;
359 rTargetStream.Seek( nStreamPosition - 4 );
360 }
361 }
362
363 // global default value setting
364 StackMember* pGS;
365
366 if (rGraphic.GetType() == GraphicType::GdiMetafile)
367 pMTF = &rGraphic.GetGDIMetaFile();
368 else if (rGraphic.GetGDIMetaFile().GetActionSize())
369 {
370 pAMTF.reset( new GDIMetaFile( rGraphic.GetGDIMetaFile() ) );
371 pMTF = pAMTF.get();
372 }
373 else
374 {
375 BitmapEx aBmp( rGraphic.GetBitmapEx() );
376 pAMTF.reset( new GDIMetaFile );
377 ScopedVclPtrInstance< VirtualDevice > pTmpVDev;
378 pAMTF->Record( pTmpVDev );
379 pTmpVDev->DrawBitmapEx( Point(), aBmp );
380 pAMTF->Stop();
381 pAMTF->SetPrefSize( aBmp.GetSizePixel() );
382 pMTF = pAMTF.get();
383 }
384 pVDev->SetMapMode( pMTF->GetPrefMapMode() );
385 nBoundingX2 = pMTF->GetPrefSize().Width();
386 nBoundingY2 = pMTF->GetPrefSize().Height();
387
388 pGDIStack = nullptr;
389 aColor = COL_TRANSPARENT;
390 bLineColor = true;
391 aLineColor = COL_BLACK;
392 bFillColor = true;
393 aFillColor = COL_WHITE;
394 bTextFillColor = true;
395 aTextFillColor = COL_BLACK;
396 fLineWidth = 1;
397 fMiterLimit = 15; // use same limit as most graphic systems and basegfx
398 eLineCap = SvtGraphicStroke::capButt;
399 eJoinType = SvtGraphicStroke::joinMiter;
400 aBackgroundColor = COL_WHITE;
401 eTextAlign = ALIGN_BASELINE;
402
403 if( pMTF->GetActionSize() )
404 {
405 ImplWriteProlog( ( mnPreview & EPS_PREVIEW_EPSI ) ? &rGraphic : nullptr );
406 mnCursorPos = 0;
407 ImplWriteActions( *pMTF, *pVDev );
408 ImplWriteEpilog();
409 if ( mnPreview & EPS_PREVIEW_TIFF )
410 {
411 sal_uInt32 nPosition = rTargetStream.Tell();
412 rTargetStream.Seek( nStreamPosition );
413 rTargetStream.WriteUInt32( nPSPosition );
414 rTargetStream.WriteUInt32( nPosition - nPSPosition );
415 rTargetStream.Seek( nPosition );
416 }
417 while( pGDIStack )
418 {
419 pGS=pGDIStack;
420 pGDIStack=pGS->pSucc;
421 delete pGS;
422 }
423 }
424 else
425 mbStatus = false;
426
427 if ( mbStatus && mbLevelWarning && pFilterConfigItem )
428 {
429 std::locale loc = Translate::Create("flt");
430 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,
431 VclMessageType::Info, VclButtonsType::Ok,
432 Translate::get(KEY_VERSION_CHECK, loc)));
433 xInfoBox->run();
434 }
435
436 if ( xStatusIndicator.is() )
437 xStatusIndicator->end();
438
439 return mbStatus;
440 }
441
442 void PSWriter::ImplWriteProlog( const Graphic* pPreview )
443 {
444 ImplWriteLine( "%!PS-Adobe-3.0 EPSF-3.0 " );
445 mpPS->WriteOString( "%%BoundingBox: " ); // BoundingBox
446 ImplWriteLong( 0 );
447 ImplWriteLong( 0 );
448 Size aSizePoint = OutputDevice::LogicToLogic( pMTF->GetPrefSize(),
449 pMTF->GetPrefMapMode(), MapMode(MapUnit::MapPoint));
450 ImplWriteLong( aSizePoint.Width() );
451 ImplWriteLong( aSizePoint.Height() ,PS_RET );
452 ImplWriteLine( "%%Pages: 0" );
453 OUString aCreator;
454 OUString aCreatorOverride = officecfg::Office::Common::Save::Document::GeneratorOverride::get();
455 if( !aCreatorOverride.isEmpty())
456 aCreator = aCreatorOverride;
457 else
458 aCreator = "%%Creator: " + utl::ConfigManager::getProductName() + " " +
459 utl::ConfigManager::getProductVersion();
460 ImplWriteLine( OUStringToOString( aCreator, RTL_TEXTENCODING_UTF8 ).getStr() );
461 ImplWriteLine( "%%Title: none" );
462 ImplWriteLine( "%%CreationDate: none" );
463
464 // defaults
465
466 mpPS->WriteOString( "%%LanguageLevel: " ); // Language level
467 ImplWriteLong( mnLevel, PS_RET );
468 if ( !mbGrayScale && mnLevel == 1 )
469 ImplWriteLine( "%%Extensions: CMYK" ); // CMYK extension is to set in color mode in level 1
470 ImplWriteLine( "%%EndComments" );
471 if ( pPreview && aSizePoint.Width() && aSizePoint.Height() )
472 {
473 Size aSizeBitmap( ( aSizePoint.Width() + 7 ) & ~7, aSizePoint.Height() );
474 Bitmap aTmpBitmap( pPreview->GetBitmapEx().GetBitmap() );
475 aTmpBitmap.Scale( aSizeBitmap, BmpScaleFlag::BestQuality );
476 aTmpBitmap.Convert( BmpConversion::N1BitThreshold );
477 BitmapScopedReadAccess pAcc(aTmpBitmap);
478 if ( pAcc )
479 {
480 mpPS->WriteOString( "%%BeginPreview: " ); // BoundingBox
481 ImplWriteLong( aSizeBitmap.Width() );
482 ImplWriteLong( aSizeBitmap.Height() );
483 mpPS->WriteOString( "1 " );
484 sal_Int32 nLines = aSizeBitmap.Width() / 312;
485 if ( ( nLines * 312 ) != aSizeBitmap.Width() )
486 nLines++;
487 nLines *= aSizeBitmap.Height();
488 ImplWriteLong( nLines );
489 sal_Int32 nCount2, nCount = 4;
490 const BitmapColor aBlack( pAcc->GetBestMatchingColor( COL_BLACK ) );
491 for ( tools::Long nY = 0; nY < aSizeBitmap.Height(); nY++ )
492 {
493 nCount2 = 0;
494 char nVal = 0;
495 Scanline pScanline = pAcc->GetScanline( nY );
496 for ( tools::Long nX = 0; nX < aSizeBitmap.Width(); nX++ )
497 {
498 if ( !nCount2 )
499 {
500 ImplExecMode( PS_RET );
501 mpPS->WriteOString( "%" );
502 nCount2 = 312;
503 }
504 nVal <<= 1;
505 if ( pAcc->GetPixelFromData( pScanline, nX ) == aBlack )
506 nVal |= 1;
507 if ( ! ( --nCount ) )
508 {
509 if ( nVal > 9 )
510 nVal += 'A' - 10;
511 else
512 nVal += '0';
513 mpPS->WriteChar( nVal );
514 nVal = 0;
515 nCount += 4;
516 }
517 nCount2--;
518 }
519 }
520 pAcc.reset();
521 ImplExecMode( PS_RET );
522 ImplWriteLine( "%%EndPreview" );
523 }
524 }
525 ImplWriteLine( "%%BeginProlog" );
526 ImplWriteLine( "%%BeginResource: procset SDRes-Prolog 1.0 0" );
527
528 // BEGIN EPSF
529 ImplWriteLine( "/b4_inc_state save def\n/dict_count countdictstack def\n/op_count count 1 sub def\nuserdict begin" );
530 ImplWriteLine( "0 setgray 0 setlinecap 1 setlinewidth 0 setlinejoin 10 setmiterlimit[] 0 setdash newpath" );
531 ImplWriteLine( "/languagelevel where {pop languagelevel 1 ne {false setstrokeadjust false setoverprint} if} if" );
532
533 ImplWriteLine( "/bdef {bind def} bind def" ); // the new operator bdef is created
534 if ( mbGrayScale )
535 ImplWriteLine( "/c {setgray} bdef" );
536 else
537 ImplWriteLine( "/c {setrgbcolor} bdef" );
538 ImplWriteLine( "/l {neg lineto} bdef" );
539 ImplWriteLine( "/rl {neg rlineto} bdef" );
540 ImplWriteLine( "/lc {setlinecap} bdef" );
541 ImplWriteLine( "/lj {setlinejoin} bdef" );
542 ImplWriteLine( "/lw {setlinewidth} bdef" );
543 ImplWriteLine( "/ml {setmiterlimit} bdef" );
544 ImplWriteLine( "/ld {setdash} bdef" );
545 ImplWriteLine( "/m {neg moveto} bdef" );
546 ImplWriteLine( "/ct {6 2 roll neg 6 2 roll neg 6 2 roll neg curveto} bdef" );
547 ImplWriteLine( "/r {rotate} bdef" );
548 ImplWriteLine( "/t {neg translate} bdef" );
549 ImplWriteLine( "/s {scale} bdef" );
550 ImplWriteLine( "/sw {show} bdef" );
551 ImplWriteLine( "/gs {gsave} bdef" );
552 ImplWriteLine( "/gr {grestore} bdef" );
553
554 ImplWriteLine( "/f {findfont dup length dict begin" ); // Setfont
555 ImplWriteLine( "{1 index /FID ne {def} {pop pop} ifelse} forall /Encoding ISOLatin1Encoding def" );
556 ImplWriteLine( "currentdict end /NFont exch definefont pop /NFont findfont} bdef" );
557
558 ImplWriteLine( "/p {closepath} bdef" );
559 ImplWriteLine( "/sf {scalefont setfont} bdef" );
560
561 ImplWriteLine( "/ef {eofill}bdef" ); // close path and fill
562 ImplWriteLine( "/pc {closepath stroke}bdef" ); // close path and draw
563 ImplWriteLine( "/ps {stroke}bdef" ); // draw current path
564 ImplWriteLine( "/pum {matrix currentmatrix}bdef" ); // pushes the current matrix
565 ImplWriteLine( "/pom {setmatrix}bdef" ); // pops the matrix
566 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" );
567 ImplWriteLine( "%%EndResource" );
568 ImplWriteLine( "%%EndProlog" );
569 ImplWriteLine( "%%BeginSetup" );
570 ImplWriteLine( "%%EndSetup" );
571 ImplWriteLine( "%%Page: 1 1" );
572 ImplWriteLine( "%%BeginPageSetup" );
573 ImplWriteLine( "%%EndPageSetup" );
574 ImplWriteLine( "pum" );
575 ImplScale( static_cast<double>(aSizePoint.Width()) / static_cast<double>(pMTF->GetPrefSize().Width()), static_cast<double>(aSizePoint.Height()) / static_cast<double>(pMTF->GetPrefSize().Height()) );
576 ImplWriteDouble( 0 );
577 ImplWriteDouble( -pMTF->GetPrefSize().Height() );
578 ImplWriteLine( "t" );
579 ImplWriteLine( "/tm matrix currentmatrix def" );
580 }
581
582 void PSWriter::ImplWriteEpilog()
583 {
584 ImplTranslate( 0, nBoundingY2 );
585 ImplWriteLine( "pom" );
586 ImplWriteLine( "count op_count sub {pop} repeat countdictstack dict_count sub {end} repeat b4_inc_state restore" );
587
588 ImplWriteLine( "%%PageTrailer" );
589 ImplWriteLine( "%%Trailer" );
590
591 ImplWriteLine( "%%EOF" );
592 }
593
594 void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
595 {
596 tools::PolyPolygon aFillPath;
597
598 for( size_t nCurAction = 0, nCount = rMtf.GetActionSize(); nCurAction < nCount; nCurAction++ )
599 {
600 MetaAction* pMA = rMtf.GetAction( nCurAction );
601
602 switch( pMA->GetType() )
603 {
604 case MetaActionType::NONE :
605 break;
606
607 case MetaActionType::PIXEL :
608 {
609 Color aOldLineColor( aLineColor );
610 aLineColor = static_cast<const MetaPixelAction*>(pMA)->GetColor();
611 ImplWriteLineColor( PS_SPACE );
612 ImplMoveTo( static_cast<const MetaPixelAction*>(pMA)->GetPoint() );
613 ImplLineTo( static_cast<const MetaPixelAction*>(pMA)->GetPoint() );
614 ImplPathDraw();
615 aLineColor = aOldLineColor;
616 }
617 break;
618
619 case MetaActionType::POINT :
620 {
621 ImplWriteLineColor( PS_SPACE );
622 ImplMoveTo( static_cast<const MetaPointAction*>(pMA)->GetPoint() );
623 ImplLineTo( static_cast<const MetaPointAction*>(pMA)->GetPoint() );
624 ImplPathDraw();
625 }
626 break;
627
628 case MetaActionType::LINE :
629 {
630 const LineInfo& rLineInfo = static_cast<const MetaLineAction*>(pMA)->GetLineInfo();
631 ImplWriteLineInfo( rLineInfo );
632 if ( bLineColor )
633 {
634 ImplWriteLineColor( PS_SPACE );
635 ImplMoveTo( static_cast<const MetaLineAction*>(pMA)->GetStartPoint() );
636 ImplLineTo( static_cast<const MetaLineAction*>(pMA )->GetEndPoint() );
637 ImplPathDraw();
638 }
639 }
640 break;
641
642 case MetaActionType::RECT :
643 {
644 ImplRect( static_cast<const MetaRectAction*>(pMA)->GetRect() );
645 }
646 break;
647
648 case MetaActionType::ROUNDRECT :
649 ImplRect( static_cast<const MetaRoundRectAction*>(pMA)->GetRect() );
650 break;
651
652 case MetaActionType::ELLIPSE :
653 {
654 tools::Rectangle aRect = static_cast<const MetaEllipseAction*>(pMA)->GetRect();
655 Point aCenter = aRect.Center();
656 tools::Polygon aPoly( aCenter, aRect.GetWidth() / 2, aRect.GetHeight() / 2 );
657 tools::PolyPolygon aPolyPoly( aPoly );
658 ImplPolyPoly( aPolyPoly );
659 }
660 break;
661
662 case MetaActionType::ARC :
663 {
664 tools::Polygon aPoly( static_cast<const MetaArcAction*>(pMA)->GetRect(), static_cast<const MetaArcAction*>(pMA)->GetStartPoint(),
665 static_cast<const MetaArcAction*>(pMA)->GetEndPoint(), PolyStyle::Arc );
666 tools::PolyPolygon aPolyPoly( aPoly );
667 ImplPolyPoly( aPolyPoly );
668 }
669 break;
670
671 case MetaActionType::PIE :
672 {
673 tools::Polygon aPoly( static_cast<const MetaPieAction*>(pMA)->GetRect(), static_cast<const MetaPieAction*>(pMA)->GetStartPoint(),
674 static_cast<const MetaPieAction*>(pMA)->GetEndPoint(), PolyStyle::Pie );
675 tools::PolyPolygon aPolyPoly( aPoly );
676 ImplPolyPoly( aPolyPoly );
677 }
678 break;
679
680 case MetaActionType::CHORD :
681 {
682 tools::Polygon aPoly( static_cast<const MetaChordAction*>(pMA)->GetRect(), static_cast<const MetaChordAction*>(pMA)->GetStartPoint(),
683 static_cast<const MetaChordAction*>(pMA)->GetEndPoint(), PolyStyle::Chord );
684 tools::PolyPolygon aPolyPoly( aPoly );
685 ImplPolyPoly( aPolyPoly );
686 }
687 break;
688
689 case MetaActionType::POLYLINE :
690 {
691 tools::Polygon aPoly( static_cast<const MetaPolyLineAction*>(pMA)->GetPolygon() );
692 const LineInfo& rLineInfo = static_cast<const MetaPolyLineAction*>(pMA)->GetLineInfo();
693 ImplWriteLineInfo( rLineInfo );
694
695 if(basegfx::B2DLineJoin::NONE == rLineInfo.GetLineJoin()
696 && rLineInfo.GetWidth() > 1)
697 {
698 // emulate B2DLineJoin::NONE by creating single edges
699 const sal_uInt16 nPoints(aPoly.GetSize());
700 const bool bCurve(aPoly.HasFlags());
701
702 for(sal_uInt16 a(0); a + 1 < nPoints; a++)
703 {
704 if(bCurve
705 && PolyFlags::Normal != aPoly.GetFlags(a + 1)
706 && a + 2 < nPoints
707 && PolyFlags::Normal != aPoly.GetFlags(a + 2)
708 && a + 3 < nPoints)
709 {
710 const tools::Polygon aSnippet(4,
711 aPoly.GetConstPointAry() + a,
712 aPoly.GetConstFlagAry() + a);
713 ImplPolyLine(aSnippet);
714 a += 2;
715 }
716 else
717 {
718 const tools::Polygon aSnippet(2,
719 aPoly.GetConstPointAry() + a);
720 ImplPolyLine(aSnippet);
721 }
722 }
723 }
724 else
725 {
726 ImplPolyLine( aPoly );
727 }
728 }
729 break;
730
731 case MetaActionType::POLYGON :
732 {
733 tools::PolyPolygon aPolyPoly( static_cast<const MetaPolygonAction*>(pMA)->GetPolygon() );
734 ImplPolyPoly( aPolyPoly );
735 }
736 break;
737
738 case MetaActionType::POLYPOLYGON :
739 {
740 ImplPolyPoly( static_cast<const MetaPolyPolygonAction*>(pMA)->GetPolyPolygon() );
741 }
742 break;
743
744 case MetaActionType::TEXT:
745 {
746 const MetaTextAction * pA = static_cast<const MetaTextAction*>(pMA);
747
748 OUString aUniStr = pA->GetText().copy( pA->GetIndex(), pA->GetLen() );
749 Point aPoint( pA->GetPoint() );
750
751 ImplText( aUniStr, aPoint, {}, {}, 0, rVDev );
752 }
753 break;
754
755 case MetaActionType::TEXTRECT:
756 {
757 OSL_FAIL( "Unsupported action: TextRect...Action!" );
758 }
759 break;
760
761 case MetaActionType::STRETCHTEXT :
762 {
763 const MetaStretchTextAction* pA = static_cast<const MetaStretchTextAction*>(pMA);
764 OUString aUniStr = pA->GetText().copy( pA->GetIndex(), pA->GetLen() );
765 Point aPoint( pA->GetPoint() );
766
767 ImplText( aUniStr, aPoint, {}, {}, pA->GetWidth(), rVDev );
768 }
769 break;
770
771 case MetaActionType::TEXTARRAY:
772 {
773 const MetaTextArrayAction* pA = static_cast<const MetaTextArrayAction*>(pMA);
774 OUString aUniStr = pA->GetText().copy( pA->GetIndex(), pA->GetLen() );
775 Point aPoint( pA->GetPoint() );
776
777 ImplText( aUniStr, aPoint, pA->GetDXArray(), pA->GetKashidaArray(), 0, rVDev );
778 }
779 break;
780
781 case MetaActionType::BMP :
782 {
783 Bitmap aBitmap = static_cast<const MetaBmpAction*>(pMA)->GetBitmap();
784 if ( mbGrayScale )
785 aBitmap.Convert( BmpConversion::N8BitGreys );
786 Point aPoint = static_cast<const MetaBmpAction*>(pMA)->GetPoint();
787 Size aSize( rVDev.PixelToLogic( aBitmap.GetSizePixel() ) );
788 ImplBmp( &aBitmap, nullptr, aPoint, aSize.Width(), aSize.Height() );
789 }
790 break;
791
792 case MetaActionType::BMPSCALE :
793 {
794 Bitmap aBitmap = static_cast<const MetaBmpScaleAction*>(pMA)->GetBitmap();
795 if ( mbGrayScale )
796 aBitmap.Convert( BmpConversion::N8BitGreys );
797 Point aPoint = static_cast<const MetaBmpScaleAction*>(pMA)->GetPoint();
798 Size aSize = static_cast<const MetaBmpScaleAction*>(pMA)->GetSize();
799 ImplBmp( &aBitmap, nullptr, aPoint, aSize.Width(), aSize.Height() );
800 }
801 break;
802
803 case MetaActionType::BMPSCALEPART :
804 {
805 Bitmap aBitmap( static_cast<const MetaBmpScalePartAction*>(pMA)->GetBitmap() );
806 aBitmap.Crop( tools::Rectangle( static_cast<const MetaBmpScalePartAction*>(pMA)->GetSrcPoint(),
807 static_cast<const MetaBmpScalePartAction*>(pMA)->GetSrcSize() ) );
808 if ( mbGrayScale )
809 aBitmap.Convert( BmpConversion::N8BitGreys );
810 Point aPoint = static_cast<const MetaBmpScalePartAction*>(pMA)->GetDestPoint();
811 Size aSize = static_cast<const MetaBmpScalePartAction*>(pMA)->GetDestSize();
812 ImplBmp( &aBitmap, nullptr, aPoint, aSize.Width(), aSize.Height() );
813 }
814 break;
815
816 case MetaActionType::BMPEX :
817 {
818 BitmapEx aBitmapEx( static_cast<MetaBmpExAction*>(pMA)->GetBitmapEx() );
819 Bitmap aBitmap( aBitmapEx.GetBitmap() );
820 if ( mbGrayScale )
821 aBitmap.Convert( BmpConversion::N8BitGreys );
822 const AlphaMask& aMask( aBitmapEx.GetAlphaMask() );
823 Point aPoint( static_cast<const MetaBmpExAction*>(pMA)->GetPoint() );
824 Size aSize( rVDev.PixelToLogic( aBitmap.GetSizePixel() ) );
825 ImplBmp( &aBitmap, &aMask, aPoint, aSize.Width(), aSize.Height() );
826 }
827 break;
828
829 case MetaActionType::BMPEXSCALE :
830 {
831 BitmapEx aBitmapEx( static_cast<MetaBmpExScaleAction*>(pMA)->GetBitmapEx() );
832 Bitmap aBitmap( aBitmapEx.GetBitmap() );
833 if ( mbGrayScale )
834 aBitmap.Convert( BmpConversion::N8BitGreys );
835 const AlphaMask& aMask( aBitmapEx.GetAlphaMask() );
836 Point aPoint = static_cast<const MetaBmpExScaleAction*>(pMA)->GetPoint();
837 Size aSize( static_cast<const MetaBmpExScaleAction*>(pMA)->GetSize() );
838 ImplBmp( &aBitmap, &aMask, aPoint, aSize.Width(), aSize.Height() );
839 }
840 break;
841
842 case MetaActionType::BMPEXSCALEPART :
843 {
844 BitmapEx aBitmapEx( static_cast<const MetaBmpExScalePartAction*>(pMA)->GetBitmapEx() );
845 aBitmapEx.Crop( tools::Rectangle( static_cast<const MetaBmpExScalePartAction*>(pMA)->GetSrcPoint(),
846 static_cast<const MetaBmpExScalePartAction*>(pMA)->GetSrcSize() ) );
847 Bitmap aBitmap( aBitmapEx.GetBitmap() );
848 if ( mbGrayScale )
849 aBitmap.Convert( BmpConversion::N8BitGreys );
850 AlphaMask aMask( aBitmapEx.GetAlphaMask() );
851 Point aPoint = static_cast<const MetaBmpExScalePartAction*>(pMA)->GetDestPoint();
852 Size aSize = static_cast<const MetaBmpExScalePartAction*>(pMA)->GetDestSize();
853 ImplBmp( &aBitmap, &aMask, aPoint, aSize.Width(), aSize.Height() );
854 }
855 break;
856
857 // Unsupported Actions
858 case MetaActionType::MASK:
859 case MetaActionType::MASKSCALE:
860 case MetaActionType::MASKSCALEPART:
861 {
862 OSL_FAIL( "Unsupported action: MetaMask...Action!" );
863 }
864 break;
865
866 case MetaActionType::GRADIENT :
867 {
868 tools::PolyPolygon aPolyPoly( static_cast<const MetaGradientAction*>(pMA)->GetRect() );
869 ImplWriteGradient( aPolyPoly, static_cast<const MetaGradientAction*>(pMA)->GetGradient(), rVDev );
870 }
871 break;
872
873 case MetaActionType::GRADIENTEX :
874 {
875 tools::PolyPolygon aPolyPoly( static_cast<const MetaGradientExAction*>(pMA)->GetPolyPolygon() );
876 ImplWriteGradient( aPolyPoly, static_cast<const MetaGradientExAction*>(pMA)->GetGradient(), rVDev );
877 }
878 break;
879
880 case MetaActionType::HATCH :
881 {
882 ScopedVclPtrInstance< VirtualDevice > l_pVirDev;
883 GDIMetaFile aTmpMtf;
884
885 l_pVirDev->SetMapMode( rVDev.GetMapMode() );
886 l_pVirDev->AddHatchActions( static_cast<const MetaHatchAction*>(pMA)->GetPolyPolygon(),
887 static_cast<const MetaHatchAction*>(pMA)->GetHatch(), aTmpMtf );
888 ImplWriteActions( aTmpMtf, rVDev );
889 }
890 break;
891
892 case MetaActionType::WALLPAPER :
893 {
894 const MetaWallpaperAction* pA = static_cast<const MetaWallpaperAction*>(pMA);
895 tools::Rectangle aRect = pA->GetRect();
896 const Wallpaper& aWallpaper = pA->GetWallpaper();
897
898 if ( aWallpaper.IsBitmap() )
899 {
900 BitmapEx aBitmapEx = aWallpaper.GetBitmap();
901 const Bitmap& aBitmap( aBitmapEx.GetBitmap() );
902 if ( aBitmapEx.IsAlpha() )
903 {
904 if ( aWallpaper.IsGradient() )
905 {
906
907 // gradient action
908
909 }
910 const AlphaMask& aMask( aBitmapEx.GetAlphaMask() );
911 ImplBmp( &aBitmap, &aMask, Point( aRect.Left(), aRect.Top() ), aRect.GetWidth(), aRect.GetHeight() );
912 }
913 else
914 ImplBmp( &aBitmap, nullptr, Point( aRect.Left(), aRect.Top() ), aRect.GetWidth(), aRect.GetHeight() );
915
916 // wallpaper Style
917
918 }
919 else if ( aWallpaper.IsGradient() )
920 {
921
922 // gradient action
923
924 }
925 else
926 {
927 aColor = aWallpaper.GetColor();
928 ImplRectFill( aRect );
929 }
930 }
931 break;
932
933 case MetaActionType::ISECTRECTCLIPREGION:
934 {
935 const MetaISectRectClipRegionAction* pA = static_cast<const MetaISectRectClipRegionAction*>(pMA);
936 vcl::Region aRegion( pA->GetRect() );
937 ImplSetClipRegion( aRegion );
938 }
939 break;
940
941 case MetaActionType::CLIPREGION:
942 {
943 const MetaClipRegionAction* pA = static_cast<const MetaClipRegionAction*>(pMA);
944 const vcl::Region& aRegion( pA->GetRegion() );
945 ImplSetClipRegion( aRegion );
946 }
947 break;
948
949 case MetaActionType::ISECTREGIONCLIPREGION:
950 {
951 const MetaISectRegionClipRegionAction* pA = static_cast<const MetaISectRegionClipRegionAction*>(pMA);
952 const vcl::Region& aRegion( pA->GetRegion() );
953 ImplSetClipRegion( aRegion );
954 }
955 break;
956
957 case MetaActionType::MOVECLIPREGION:
958 {
959 // TODO: Implement!
960 }
961 break;
962
963 case MetaActionType::LINECOLOR :
964 {
965 if ( static_cast<const MetaLineColorAction*>(pMA)->IsSetting() )
966 {
967 bLineColor = true;
968 aLineColor = static_cast<const MetaLineColorAction*>(pMA)->GetColor();
969 }
970 else
971 bLineColor = false;
972 }
973 break;
974
975 case MetaActionType::FILLCOLOR :
976 {
977 if ( static_cast<const MetaFillColorAction*>(pMA)->IsSetting() )
978 {
979 bFillColor = true;
980 aFillColor = static_cast<const MetaFillColorAction*>(pMA)->GetColor();
981 }
982 else
983 bFillColor = false;
984 }
985 break;
986
987 case MetaActionType::TEXTCOLOR :
988 {
989 aTextColor = static_cast<const MetaTextColorAction*>(pMA)->GetColor();
990 }
991 break;
992
993 case MetaActionType::TEXTFILLCOLOR :
994 {
995 if ( static_cast<const MetaTextFillColorAction*>(pMA)->IsSetting() )
996 {
997 bTextFillColor = true;
998 aTextFillColor = static_cast<const MetaTextFillColorAction*>(pMA)->GetColor();
999 }
1000 else
1001 bTextFillColor = false;
1002 }
1003 break;
1004
1005 case MetaActionType::TEXTALIGN :
1006 {
1007 eTextAlign = static_cast<const MetaTextAlignAction*>(pMA)->GetTextAlign();
1008 }
1009 break;
1010
1011 case MetaActionType::MAPMODE :
1012 {
1013 pMA->Execute( &rVDev );
1014 ImplGetMapMode( rVDev.GetMapMode() );
1015 }
1016 break;
1017
1018 case MetaActionType::FONT :
1019 {
1020 maFont = static_cast<const MetaFontAction*>(pMA)->GetFont();
1021 rVDev.SetFont( maFont );
1022 }
1023 break;
1024
1025 case MetaActionType::PUSH :
1026 {
1027 rVDev.Push(static_cast<const MetaPushAction*>(pMA)->GetFlags() );
1028 StackMember* pGS = new StackMember;
1029 pGS->pSucc = pGDIStack;
1030 pGDIStack = pGS;
1031 pGS->aDashArray = aDashArray;
1032 pGS->eJoinType = eJoinType;
1033 pGS->eLineCap = eLineCap;
1034 pGS->fLineWidth = fLineWidth;
1035 pGS->fMiterLimit = fMiterLimit;
1036 pGS->eTextAlign = eTextAlign;
1037 pGS->aGlobalCol = aColor;
1038 pGS->bLineCol = bLineColor;
1039 pGS->aLineCol = aLineColor;
1040 pGS->bFillCol = bFillColor;
1041 pGS->aFillCol = aFillColor;
1042 pGS->aTextCol = aTextColor;
1043 pGS->bTextFillCol = bTextFillColor;
1044 pGS->aTextFillCol = aTextFillColor;
1045 pGS->aBackgroundCol = aBackgroundColor;
1046 pGS->aFont = maFont;
1047 mnLatestPush = mpPS->Tell();
1048 ImplWriteLine( "gs" );
1049 }
1050 break;
1051
1052 case MetaActionType::POP :
1053 {
1054 rVDev.Pop();
1055 if( pGDIStack )
1056 {
1057 StackMember* pGS = pGDIStack;
1058 pGDIStack = pGS->pSucc;
1059 aDashArray = pGS->aDashArray;
1060 eJoinType = pGS->eJoinType;
1061 eLineCap = pGS->eLineCap;
1062 fLineWidth = pGS->fLineWidth;
1063 fMiterLimit = pGS->fMiterLimit;
1064 eTextAlign = pGS->eTextAlign;
1065 aColor = pGS->aGlobalCol;
1066 bLineColor = pGS->bLineCol;
1067 aLineColor = pGS->aLineCol;
1068 bFillColor = pGS->bFillCol;
1069 aFillColor = pGS->aFillCol;
1070 aTextColor = pGS->aTextCol;
1071 bTextFillColor = pGS->bTextFillCol;
1072 aTextFillColor = pGS->aTextFillCol;
1073 aBackgroundColor = pGS->aBackgroundCol;
1074 maFont = pGS->aFont;
1075 maLastFont = vcl::Font(); // set maLastFont != maFont -> so that
1076 delete pGS;
1077 sal_uInt32 nCurrentPos = mpPS->Tell();
1078 if ( nCurrentPos - 3 == mnLatestPush )
1079 {
1080 mpPS->Seek( mnLatestPush );
1081 ImplWriteLine( " " );
1082 mpPS->Seek( mnLatestPush );
1083 }
1084 else
1085 ImplWriteLine( "gr" );
1086 }
1087 }
1088 break;
1089
1090 case MetaActionType::EPS :
1091 {
1092 GfxLink aGfxLink = static_cast<const MetaEPSAction*>(pMA)->GetLink();
1093 const GDIMetaFile aSubstitute( static_cast<const MetaEPSAction*>(pMA)->GetSubstitute() );
1094
1095 bool bLevelConflict = false;
1096 sal_uInt8* pSource = const_cast<sal_uInt8*>(aGfxLink.GetData());
1097 sal_uInt32 nSize = aGfxLink.GetDataSize();
1098 sal_uInt32 nParseThis = POSTSCRIPT_BOUNDINGSEARCH;
1099 if ( nSize < 64 ) // assuming eps is larger than 64 bytes
1100 pSource = nullptr;
1101 if ( nParseThis > nSize )
1102 nParseThis = nSize;
1103
1104 if ( pSource && ( mnLevel == 1 ) )
1105 {
1106 sal_uInt8* pFound = ImplSearchEntry( pSource, reinterpret_cast<sal_uInt8 const *>("%%LanguageLevel:"), nParseThis - 10, 16 );
1107 if ( pFound )
1108 {
1109 sal_uInt8 k, i = 10;
1110 pFound += 16;
1111 while ( --i )
1112 {
1113 k = *pFound++;
1114 if ( ( k > '0' ) && ( k <= '9' ) )
1115 {
1116 if ( k != '1' )
1117 {
1118 bLevelConflict = true;
1119 mbLevelWarning = true;
1120 }
1121 break;
1122 }
1123 }
1124 }
1125 }
1126 if ( !bLevelConflict )
1127 {
1128 double nBoundingBox[4];
1129 if ( pSource && ImplGetBoundingBox( nBoundingBox, pSource, nParseThis ) )
1130 {
1131 Point aPoint = static_cast<const MetaEPSAction*>(pMA)->GetPoint();
1132 Size aSize = static_cast<const MetaEPSAction*>(pMA)->GetSize();
1133
1134 MapMode aMapMode( aSubstitute.GetPrefMapMode() );
1135 Size aOutSize( OutputDevice::LogicToLogic( aSize, rVDev.GetMapMode(), aMapMode ) );
1136 Point aOrigin( OutputDevice::LogicToLogic( aPoint, rVDev.GetMapMode(), aMapMode ) );
1137 aOrigin.AdjustY(aOutSize.Height() );
1138 aMapMode.SetOrigin( aOrigin );
1139 aMapMode.SetScaleX( Fraction(aOutSize.Width() / ( nBoundingBox[ 2 ] - nBoundingBox[ 0 ] )) );
1140 aMapMode.SetScaleY( Fraction(aOutSize.Height() / ( nBoundingBox[ 3 ] - nBoundingBox[ 1 ] )) );
1141 ImplWriteLine( "gs" );
1142 ImplGetMapMode( aMapMode );
1143 ImplWriteLine( "%%BeginDocument:" );
1144 mpPS->WriteBytes(pSource, aGfxLink.GetDataSize());
1145 ImplWriteLine( "%%EndDocument\ngr" );
1146 }
1147 }
1148 }
1149 break;
1150
1151 case MetaActionType::Transparent:
1152 {
1153 // TODO: implement!
1154 }
1155 break;
1156
1157 case MetaActionType::RASTEROP:
1158 {
1159 pMA->Execute( &rVDev );
1160 }
1161 break;
1162
1163 case MetaActionType::FLOATTRANSPARENT:
1164 {
1165 const MetaFloatTransparentAction* pA = static_cast<const MetaFloatTransparentAction*>(pMA);
1166
1167 GDIMetaFile aTmpMtf( pA->GetGDIMetaFile() );
1168 Point aSrcPt( aTmpMtf.GetPrefMapMode().GetOrigin() );
1169 const Size aSrcSize( aTmpMtf.GetPrefSize() );
1170 const Point aDestPt( pA->GetPoint() );
1171 const Size aDestSize( pA->GetSize() );
1172 const double fScaleX = aSrcSize.Width() ? static_cast<double>(aDestSize.Width()) / aSrcSize.Width() : 1.0;
1173 const double fScaleY = aSrcSize.Height() ? static_cast<double>(aDestSize.Height()) / aSrcSize.Height() : 1.0;
1174 tools::Long nMoveX, nMoveY;
1175
1176 if( fScaleX != 1.0 || fScaleY != 1.0 )
1177 {
1178 aTmpMtf.Scale( fScaleX, fScaleY );
1179 aSrcPt.setX(basegfx::fround<tools::Long>(aSrcPt.X() * fScaleX));
1180 aSrcPt.setY(basegfx::fround<tools::Long>(aSrcPt.Y() * fScaleY));
1181 }
1182
1183 nMoveX = aDestPt.X() - aSrcPt.X();
1184 nMoveY = aDestPt.Y() - aSrcPt.Y();
1185
1186 if( nMoveX || nMoveY )
1187 aTmpMtf.Move( nMoveX, nMoveY );
1188
1189 ImplWriteActions( aTmpMtf, rVDev );
1190 }
1191 break;
1192
1193 case MetaActionType::COMMENT:
1194 {
1195 const MetaCommentAction* pA = static_cast<const MetaCommentAction*>(pMA);
1196 if ( pA->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_BEGIN") )
1197 {
1198 const MetaGradientExAction* pGradAction = nullptr;
1199 while( ++nCurAction < nCount )
1200 {
1201 MetaAction* pAction = rMtf.GetAction( nCurAction );
1202 if( pAction->GetType() == MetaActionType::GRADIENTEX )
1203 pGradAction = static_cast<const MetaGradientExAction*>(pAction);
1204 else if( ( pAction->GetType() == MetaActionType::COMMENT ) &&
1205 ( static_cast<const MetaCommentAction*>(pAction)->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END") ) )
1206 {
1207 break;
1208 }
1209 }
1210
1211 if( pGradAction )
1212 ImplWriteGradient( pGradAction->GetPolyPolygon(), pGradAction->GetGradient(), rVDev );
1213 }
1214 else if ( pA->GetComment() == "XPATHFILL_SEQ_END" )
1215 {
1216 if ( aFillPath.Count() )
1217 {
1218 aFillPath = tools::PolyPolygon();
1219 ImplWriteLine( "gr" );
1220 }
1221 }
1222 else
1223 {
1224 const sal_uInt8* pData = pA->GetData();
1225 if ( pData )
1226 {
1227 SvMemoryStream aMemStm( const_cast<sal_uInt8 *>(pData), pA->GetDataSize(), StreamMode::READ );
1228 bool bSkipSequence = false;
1229 OString sSeqEnd;
1230
1231 if( pA->GetComment() == "XPATHSTROKE_SEQ_BEGIN" )
1232 {
1233 sSeqEnd = "XPATHSTROKE_SEQ_END"_ostr;
1234 SvtGraphicStroke aStroke;
1235 ReadSvtGraphicStroke( aMemStm, aStroke );
1236
1237 tools::Polygon aPath;
1238 aStroke.getPath( aPath );
1239
1240 tools::PolyPolygon aStartArrow;
1241 tools::PolyPolygon aEndArrow;
1242 double fStrokeWidth( aStroke.getStrokeWidth() );
1243 SvtGraphicStroke::JoinType eJT( aStroke.getJoinType() );
1244 SvtGraphicStroke::DashArray l_aDashArray;
1245
1246 aStroke.getStartArrow( aStartArrow );
1247 aStroke.getEndArrow( aEndArrow );
1248 aStroke.getDashArray( l_aDashArray );
1249
1250 bSkipSequence = true;
1251 if ( l_aDashArray.size() > 11 ) // ps dasharray limit is 11
1252 bSkipSequence = false;
1253 if ( aStartArrow.Count() || aEndArrow.Count() )
1254 bSkipSequence = false;
1255 if ( static_cast<sal_uInt32>(eJT) > 2 )
1256 bSkipSequence = false;
1257 if ( !l_aDashArray.empty() && ( fStrokeWidth != 0.0 ) )
1258 bSkipSequence = false;
1259 if ( bSkipSequence )
1260 {
1261 ImplWriteLineInfo( fStrokeWidth, aStroke.getMiterLimit(),
1262 aStroke.getCapType(), eJT, std::move(l_aDashArray) );
1263 ImplPolyLine( aPath );
1264 }
1265 }
1266 else if (pA->GetComment() == "XPATHFILL_SEQ_BEGIN")
1267 {
1268 sSeqEnd = "XPATHFILL_SEQ_END"_ostr;
1269 SvtGraphicFill aFill;
1270 ReadSvtGraphicFill( aMemStm, aFill );
1271 switch( aFill.getFillType() )
1272 {
1273 case SvtGraphicFill::fillSolid :
1274 {
1275 bSkipSequence = true;
1276 tools::PolyPolygon aPolyPoly;
1277 aFill.getPath( aPolyPoly );
1278 sal_uInt16 i, nPolyCount = aPolyPoly.Count();
1279 if ( nPolyCount )
1280 {
1281 aFillColor = aFill.getFillColor();
1282 ImplWriteFillColor( PS_SPACE );
1283 for ( i = 0; i < nPolyCount; )
1284 {
1285 ImplAddPath( aPolyPoly.GetObject( i ) );
1286 if ( ++i < nPolyCount )
1287 {
1288 mpPS->WriteOString( "p" );
1289 mnCursorPos += 2;
1290 ImplExecMode( PS_RET );
1291 }
1292 }
1293 mpPS->WriteOString( "p ef" );
1294 mnCursorPos += 4;
1295 ImplExecMode( PS_RET );
1296 }
1297 }
1298 break;
1299
1300 case SvtGraphicFill::fillTexture :
1301 {
1302 aFill.getPath( aFillPath );
1303
1304 /* normally an object filling is consisting of three MetaActions:
1305 MetaBitmapAction using RasterOp xor,
1306 MetaPolyPolygonAction using RasterOp rop_0
1307 MetaBitmapAction using RasterOp xor
1308
1309 Because RasterOps cannot been used in Postscript, we have to
1310 replace these actions. The MetaComment "XPATHFILL_SEQ_BEGIN" is
1311 providing the clippath of the object. The following loop is
1312 trying to find the bitmap that is matching the clippath, so that
1313 only one bitmap is exported, otherwise if the bitmap is not
1314 locatable, all metaactions are played normally.
1315 */
1316 sal_uInt32 nCommentStartAction = nCurAction;
1317 sal_uInt32 nBitmapCount = 0;
1318 sal_uInt32 nBitmapAction = 0;
1319
1320 bool bOk = true;
1321 while( bOk && ( ++nCurAction < nCount ) )
1322 {
1323 MetaAction* pAction = rMtf.GetAction( nCurAction );
1324 switch( pAction->GetType() )
1325 {
1326 case MetaActionType::BMPSCALE :
1327 case MetaActionType::BMPSCALEPART :
1328 case MetaActionType::BMPEXSCALE :
1329 case MetaActionType::BMPEXSCALEPART :
1330 {
1331 nBitmapCount++;
1332 nBitmapAction = nCurAction;
1333 }
1334 break;
1335 case MetaActionType::COMMENT :
1336 {
1337 if (static_cast<const MetaCommentAction*>(pAction)->GetComment() == "XPATHFILL_SEQ_END")
1338 bOk = false;
1339 }
1340 break;
1341 default: break;
1342 }
1343 }
1344 if( nBitmapCount == 2 )
1345 {
1346 ImplWriteLine( "gs" );
1347 ImplIntersect( aFillPath );
1348 GDIMetaFile aTempMtf;
1349 aTempMtf.AddAction( rMtf.GetAction( nBitmapAction )->Clone() );
1350 ImplWriteActions( aTempMtf, rVDev );
1351 ImplWriteLine( "gr" );
1352 aFillPath = tools::PolyPolygon();
1353 }
1354 else
1355 nCurAction = nCommentStartAction + 1;
1356 }
1357 break;
1358
1359 case SvtGraphicFill::fillGradient :
1360 aFill.getPath( aFillPath );
1361 break;
1362
1363 case SvtGraphicFill::fillHatch :
1364 break;
1365 }
1366 if ( aFillPath.Count() )
1367 {
1368 ImplWriteLine( "gs" );
1369 ImplIntersect( aFillPath );
1370 }
1371 }
1372 if ( bSkipSequence )
1373 {
1374 while( ++nCurAction < nCount )
1375 {
1376 pMA = rMtf.GetAction( nCurAction );
1377 if ( pMA->GetType() == MetaActionType::COMMENT )
1378 {
1379 OString sComment( static_cast<MetaCommentAction*>(pMA)->GetComment() );
1380 if ( sComment == sSeqEnd )
1381 break;
1382 }
1383 }
1384 }
1385 }
1386 }
1387 }
1388 break;
1389 default: break;
1390 }
1391 }
1392 }
1393
1394 inline void PSWriter::ImplWritePoint( const Point& rPoint )
1395 {
1396 ImplWriteDouble( rPoint.X() );
1397 ImplWriteDouble( rPoint.Y() );
1398 }
1399
1400 void PSWriter::ImplMoveTo( const Point& rPoint )
1401 {
1402 ImplWritePoint( rPoint );
1403 ImplWriteByte( 'm' );
1404 ImplExecMode( PS_SPACE );
1405 }
1406
1407 void PSWriter::ImplLineTo( const Point& rPoint, NMode nMode )
1408 {
1409 ImplWritePoint( rPoint );
1410 ImplWriteByte( 'l' );
1411 ImplExecMode( nMode );
1412 }
1413
1414 void PSWriter::ImplCurveTo( const Point& rP1, const Point& rP2, const Point& rP3, NMode nMode )
1415 {
1416 ImplWritePoint( rP1 );
1417 ImplWritePoint( rP2 );
1418 ImplWritePoint( rP3 );
1419 mpPS->WriteOString( "ct " );
1420 ImplExecMode( nMode );
1421 }
1422
1423 void PSWriter::ImplTranslate( const double& fX, const double& fY )
1424 {
1425 ImplWriteDouble( fX );
1426 ImplWriteDouble( fY );
1427 ImplWriteByte( 't' );
1428 ImplExecMode( PS_RET );
1429 }
1430
1431 void PSWriter::ImplScale( const double& fX, const double& fY )
1432 {
1433 ImplWriteDouble( fX );
1434 ImplWriteDouble( fY );
1435 ImplWriteByte( 's' );
1436 ImplExecMode( PS_RET );
1437 }
1438
1439 void PSWriter::ImplRect( const tools::Rectangle & rRect )
1440 {
1441 if ( bFillColor )
1442 ImplRectFill( rRect );
1443 if ( bLineColor )
1444 {
1445 double nWidth = rRect.GetWidth();
1446 double nHeight = rRect.GetHeight();
1447
1448 ImplWriteLineColor( PS_SPACE );
1449 ImplMoveTo( rRect.TopLeft() );
1450 ImplWriteDouble( nWidth );
1451 mpPS->WriteOString( "0 rl 0 " );
1452 ImplWriteDouble( nHeight );
1453 mpPS->WriteOString( "rl " );
1454 ImplWriteDouble( nWidth );
1455 mpPS->WriteOString( "neg 0 rl " );
1456 ImplClosePathDraw();
1457 }
1458 mpPS->WriteUChar( 10 );
1459 mnCursorPos = 0;
1460 }
1461
1462 void PSWriter::ImplRectFill( const tools::Rectangle & rRect )
1463 {
1464 double nWidth = rRect.GetWidth();
1465 double nHeight = rRect.GetHeight();
1466
1467 ImplWriteFillColor( PS_SPACE );
1468 ImplMoveTo( rRect.TopLeft() );
1469 ImplWriteDouble( nWidth );
1470 mpPS->WriteOString( "0 rl 0 " );
1471 ImplWriteDouble( nHeight );
1472 mpPS->WriteOString( "rl " );
1473 ImplWriteDouble( nWidth );
1474 mpPS->WriteOString( "neg 0 rl ef " );
1475 mpPS->WriteOString( "p ef" );
1476 mnCursorPos += 2;
1477 ImplExecMode( PS_RET );
1478 }
1479
1480 void PSWriter::ImplAddPath( const tools::Polygon & rPolygon )
1481 {
1482 sal_uInt16 nPointCount = rPolygon.GetSize();
1483 if ( nPointCount <= 1 )
1484 return;
1485
1486 sal_uInt16 i = 1;
1487 ImplMoveTo( rPolygon.GetPoint( 0 ) );
1488 while ( i < nPointCount )
1489 {
1490 if ( ( rPolygon.GetFlags( i ) == PolyFlags::Control )
1491 && ( ( i + 2 ) < nPointCount )
1492 && ( rPolygon.GetFlags( i + 1 ) == PolyFlags::Control )
1493 && ( rPolygon.GetFlags( i + 2 ) != PolyFlags::Control ) )
1494 {
1495 ImplCurveTo( rPolygon[ i ], rPolygon[ i + 1 ], rPolygon[ i + 2 ], PS_WRAP );
1496 i += 3;
1497 }
1498 else
1499 ImplLineTo( rPolygon.GetPoint( i++ ), PS_SPACE | PS_WRAP );
1500 }
1501 }
1502
1503 void PSWriter::ImplIntersect( const tools::PolyPolygon& rPolyPoly )
1504 {
1505 sal_uInt16 i, nPolyCount = rPolyPoly.Count();
1506 for ( i = 0; i < nPolyCount; )
1507 {
1508 ImplAddPath( rPolyPoly.GetObject( i ) );
1509 if ( ++i < nPolyCount )
1510 {
1511 mpPS->WriteOString( "p" );
1512 mnCursorPos += 2;
1513 ImplExecMode( PS_RET );
1514 }
1515 }
1516 ImplWriteLine( "eoclip newpath" );
1517 }
1518
1519 void PSWriter::ImplWriteGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev )
1520 {
1521 ScopedVclPtrInstance< VirtualDevice > l_pVDev;
1522 GDIMetaFile aTmpMtf;
1523 l_pVDev->SetMapMode( rVDev.GetMapMode() );
1524 Gradient aGradient(rGradient);
1525 aGradient.AddGradientActions( rPolyPoly.GetBoundRect(), aTmpMtf );
1526 ImplWriteActions( aTmpMtf, rVDev );
1527 }
1528
1529 void PSWriter::ImplPolyPoly( const tools::PolyPolygon & rPolyPoly, bool bTextOutline )
1530 {
1531 sal_uInt16 i, nPolyCount = rPolyPoly.Count();
1532 if ( !nPolyCount )
1533 return;
1534
1535 if ( bFillColor || bTextOutline )
1536 {
1537 if ( bTextOutline )
1538 ImplWriteTextColor( PS_SPACE );
1539 else
1540 ImplWriteFillColor( PS_SPACE );
1541 for ( i = 0; i < nPolyCount; )
1542 {
1543 ImplAddPath( rPolyPoly.GetObject( i ) );
1544 if ( ++i < nPolyCount )
1545 {
1546 mpPS->WriteOString( "p" );
1547 mnCursorPos += 2;
1548 ImplExecMode( PS_RET );
1549 }
1550 }
1551 mpPS->WriteOString( "p ef" );
1552 mnCursorPos += 4;
1553 ImplExecMode( PS_RET );
1554 }
1555 if ( bLineColor )
1556 {
1557 ImplWriteLineColor( PS_SPACE );
1558 for ( i = 0; i < nPolyCount; i++ )
1559 ImplAddPath( rPolyPoly.GetObject( i ) );
1560 ImplClosePathDraw();
1561 }
1562 }
1563
1564 void PSWriter::ImplPolyLine( const tools::Polygon & rPoly )
1565 {
1566 if ( !bLineColor )
1567 return;
1568
1569 ImplWriteLineColor( PS_SPACE );
1570 sal_uInt16 i, nPointCount = rPoly.GetSize();
1571 if ( !nPointCount )
1572 return;
1573
1574 if ( nPointCount > 1 )
1575 {
1576 ImplMoveTo( rPoly.GetPoint( 0 ) );
1577 i = 1;
1578 while ( i < nPointCount )
1579 {
1580 if ( ( rPoly.GetFlags( i ) == PolyFlags::Control )
1581 && ( ( i + 2 ) < nPointCount )
1582 && ( rPoly.GetFlags( i + 1 ) == PolyFlags::Control )
1583 && ( rPoly.GetFlags( i + 2 ) != PolyFlags::Control ) )
1584 {
1585 ImplCurveTo( rPoly[ i ], rPoly[ i + 1 ], rPoly[ i + 2 ], PS_WRAP );
1586 i += 3;
1587 }
1588 else
1589 ImplLineTo( rPoly.GetPoint( i++ ), PS_SPACE | PS_WRAP );
1590 }
1591 }
1592
1593 // #104645# explicitly close path if polygon is closed
1594 if( rPoly[ 0 ] == rPoly[ nPointCount-1 ] )
1595 ImplClosePathDraw();
1596 else
1597 ImplPathDraw();
1598 }
1599
1600 void PSWriter::ImplSetClipRegion( vcl::Region const & rClipRegion )
1601 {
1602 if ( rClipRegion.IsEmpty() )
1603 return;
1604
1605 RectangleVector aRectangles;
1606 rClipRegion.GetRegionRectangles(aRectangles);
1607
1608 for (auto const& rectangle : aRectangles)
1609 {
1610 double nX1(rectangle.Left());
1611 double nY1(rectangle.Top());
1612 double nX2(rectangle.Right());
1613 double nY2(rectangle.Bottom());
1614
1615 ImplWriteDouble( nX1 );
1616 ImplWriteDouble( nY1 );
1617 ImplWriteByte( 'm' );
1618 ImplWriteDouble( nX2 );
1619 ImplWriteDouble( nY1 );
1620 ImplWriteByte( 'l' );
1621 ImplWriteDouble( nX2 );
1622 ImplWriteDouble( nY2 );
1623 ImplWriteByte( 'l' );
1624 ImplWriteDouble( nX1 );
1625 ImplWriteDouble( nY2 );
1626 ImplWriteByte( 'l' );
1627 ImplWriteDouble( nX1 );
1628 ImplWriteDouble( nY1 );
1629 ImplWriteByte( 'l', PS_SPACE | PS_WRAP );
1630 }
1631
1632 ImplWriteLine( "eoclip newpath" );
1633 }
1634
1635 // possible gfx formats:
1636 //
1637 // level 1: grayscale 8 bit
1638 // color 24 bit
1639 //
1640 // level 2: grayscale 8 bit
1641 // color 1(pal), 4(pal), 8(pal), 24 Bit
1642 //
1643
1644 void PSWriter::ImplBmp( Bitmap const * pBitmap, AlphaMask const * pAlphaMaskBitmap, const Point & rPoint, double nXWidth, double nYHeightOrg )
1645 {
1646 if ( !pBitmap )
1647 return;
1648
1649 sal_Int32 nHeightOrg = pBitmap->GetSizePixel().Height();
1650 sal_Int32 nHeightLeft = nHeightOrg;
1651 tools::Long nWidth = pBitmap->GetSizePixel().Width();
1652 Point aSourcePos( rPoint );
1653
1654 while ( nHeightLeft )
1655 {
1656 Bitmap aTileBitmap( *pBitmap );
1657 tools::Long nHeight = nHeightLeft;
1658 double nYHeight = nYHeightOrg;
1659
1660 bool bDoTrans = false;
1661
1662 tools::Rectangle aRect;
1663 vcl::Region aRegion;
1664
1665 if ( pAlphaMaskBitmap )
1666 {
1667 bDoTrans = true;
1668 while (true)
1669 {
1670 if ( mnLevel == 1 && nHeight > 10 )
1671 nHeight = 8;
1672 aRect = tools::Rectangle( Point( 0, nHeightOrg - nHeightLeft ), Size( nWidth, nHeight ) );
1673 aRegion = pAlphaMaskBitmap->CreateRegion( COL_ALPHA_OPAQUE, aRect );
1674
1675 if( mnLevel == 1 )
1676 {
1677 RectangleVector aRectangleVector;
1678 aRegion.GetRegionRectangles(aRectangleVector);
1679
1680 if ( aRectangleVector.size() * 5 > 1000 )
1681 {
1682 nHeight >>= 1;
1683 if ( nHeight < 2 )
1684 return;
1685 continue;
1686 }
1687 }
1688 break;
1689 }
1690 }
1691 if ( nHeight != nHeightOrg )
1692 {
1693 nYHeight = nYHeightOrg * nHeight / nHeightOrg;
1694 aTileBitmap.Crop( tools::Rectangle( Point( 0, nHeightOrg - nHeightLeft ), Size( nWidth, nHeight ) ) );
1695 }
1696 if ( bDoTrans )
1697 {
1698 ImplWriteLine( "gs\npum" );
1699 ImplTranslate( aSourcePos.X(), aSourcePos.Y() );
1700 ImplScale( nXWidth / nWidth, nYHeight / nHeight );
1701
1702 RectangleVector aRectangles;
1703 aRegion.GetRegionRectangles(aRectangles);
1704 const tools::Long nMoveVertical(nHeightLeft - nHeightOrg);
1705
1706 for (auto & rectangle : aRectangles)
1707 {
1708 rectangle.Move(0, nMoveVertical);
1709
1710 ImplWriteLong( rectangle.Left() );
1711 ImplWriteLong( rectangle.Top() );
1712 ImplWriteByte( 'm' );
1713 ImplWriteLong( rectangle.Right() + 1 );
1714 ImplWriteLong( rectangle.Top() );
1715 ImplWriteByte( 'l' );
1716 ImplWriteLong( rectangle.Right() + 1 );
1717 ImplWriteLong( rectangle.Bottom() + 1 );
1718 ImplWriteByte( 'l' );
1719 ImplWriteLong( rectangle.Left() );
1720 ImplWriteLong( rectangle.Bottom() + 1 );
1721 ImplWriteByte( 'l' );
1722 ImplWriteByte( 'p', PS_SPACE | PS_WRAP );
1723 }
1724
1725 ImplWriteLine( "eoclip newpath" );
1726 ImplWriteLine( "pom" );
1727 }
1728 BitmapScopedReadAccess pAcc(aTileBitmap);
1729
1730 if (!bDoTrans )
1731 ImplWriteLine( "pum" );
1732
1733 ImplTranslate( aSourcePos.X(), aSourcePos.Y() + nYHeight );
1734 ImplScale( nXWidth, nYHeight );
1735 if ( mnLevel == 1 ) // level 1 is always grayscale !!!
1736 {
1737 ImplWriteLong( nWidth );
1738 ImplWriteLong( nHeight );
1739 mpPS->WriteOString( "8 [" );
1740 ImplWriteLong( nWidth );
1741 mpPS->WriteOString( "0 0 " );
1742 ImplWriteLong( -nHeight );
1743 ImplWriteLong( 0 );
1744 ImplWriteLong( nHeight );
1745 ImplWriteLine( "]" );
1746 mpPS->WriteOString( "{currentfile " );
1747 ImplWriteLong( nWidth );
1748 ImplWriteLine( "string readhexstring pop}" );
1749 ImplWriteLine( "image" );
1750 for ( tools::Long y = 0; y < nHeight; y++ )
1751 {
1752 Scanline pScanlineRead = pAcc->GetScanline( y );
1753 for ( tools::Long x = 0; x < nWidth; x++ )
1754 {
1755 ImplWriteHexByte( pAcc->GetIndexFromData( pScanlineRead, x ) );
1756 }
1757 }
1758 mpPS->WriteUChar( 10 );
1759 }
1760 else // Level 2
1761 {
1762 if ( mbGrayScale )
1763 {
1764 ImplWriteLine( "/DeviceGray setcolorspace" );
1765 ImplWriteLine( "<<" );
1766 ImplWriteLine( "/ImageType 1" );
1767 mpPS->WriteOString( "/Width " );
1768 ImplWriteLong( nWidth, PS_RET );
1769 mpPS->WriteOString( "/Height " );
1770 ImplWriteLong( nHeight, PS_RET );
1771 ImplWriteLine( "/BitsPerComponent 8" );
1772 ImplWriteLine( "/Decode[0 1]" );
1773 mpPS->WriteOString( "/ImageMatrix[" );
1774 ImplWriteLong( nWidth );
1775 mpPS->WriteOString( "0 0 " );
1776 ImplWriteLong( -nHeight );
1777 ImplWriteLong( 0 );
1778 ImplWriteLong( nHeight, PS_NONE );
1779 ImplWriteByte( ']', PS_RET );
1780 ImplWriteLine( "/DataSource currentfile" );
1781 ImplWriteLine( "/ASCIIHexDecode filter" );
1782 if ( mbCompression )
1783 ImplWriteLine( "/LZWDecode filter" );
1784 ImplWriteLine( ">>" );
1785 ImplWriteLine( "image" );
1786 if ( mbCompression )
1787 {
1788 StartCompression();
1789 for ( tools::Long y = 0; y < nHeight; y++ )
1790 {
1791 Scanline pScanlineRead = pAcc->GetScanline( y );
1792 for ( tools::Long x = 0; x < nWidth; x++ )
1793 {
1794 Compress( pAcc->GetIndexFromData( pScanlineRead, x ) );
1795 }
1796 }
1797 EndCompression();
1798 }
1799 else
1800 {
1801 for ( tools::Long y = 0; y < nHeight; y++ )
1802 {
1803 Scanline pScanlineRead = pAcc->GetScanline( y );
1804 for ( tools::Long x = 0; x < nWidth; x++ )
1805 {
1806 ImplWriteHexByte( pAcc->GetIndexFromData( pScanlineRead, x ) );
1807 }
1808 }
1809 }
1810 }
1811 else
1812 {
1813 // have we to write a palette ?
1814
1815 if ( pAcc->HasPalette() )
1816 {
1817 ImplWriteLine( "[/Indexed /DeviceRGB " );
1818 ImplWriteLong( pAcc->GetPaletteEntryCount() - 1, PS_RET );
1819 ImplWriteByte( '<', PS_NONE );
1820 for ( sal_uInt16 i = 0; i < pAcc->GetPaletteEntryCount(); i++ )
1821 {
1822 BitmapColor aBitmapColor = pAcc->GetPaletteColor( i );
1823 ImplWriteHexByte( aBitmapColor.GetRed(), PS_NONE );
1824 ImplWriteHexByte( aBitmapColor.GetGreen(), PS_NONE );
1825 ImplWriteHexByte( aBitmapColor.GetBlue(), PS_SPACE | PS_WRAP );
1826 }
1827 ImplWriteByte( '>', PS_RET );
1828
1829 ImplWriteLine( "] setcolorspace" );
1830 ImplWriteLine( "<<" );
1831 ImplWriteLine( "/ImageType 1" );
1832 mpPS->WriteOString( "/Width " );
1833 ImplWriteLong( nWidth, PS_RET );
1834 mpPS->WriteOString( "/Height " );
1835 ImplWriteLong( nHeight, PS_RET );
1836 ImplWriteLine( "/BitsPerComponent 8" );
1837 ImplWriteLine( "/Decode[0 255]" );
1838 mpPS->WriteOString( "/ImageMatrix[" );
1839 ImplWriteLong( nWidth );
1840 mpPS->WriteOString( "0 0 " );
1841 ImplWriteLong( -nHeight );
1842 ImplWriteLong( 0);
1843 ImplWriteLong( nHeight, PS_NONE );
1844 ImplWriteByte( ']', PS_RET );
1845 ImplWriteLine( "/DataSource currentfile" );
1846 ImplWriteLine( "/ASCIIHexDecode filter" );
1847 if ( mbCompression )
1848 ImplWriteLine( "/LZWDecode filter" );
1849 ImplWriteLine( ">>" );
1850 ImplWriteLine( "image" );
1851 if ( mbCompression )
1852 {
1853 StartCompression();
1854 for ( tools::Long y = 0; y < nHeight; y++ )
1855 {
1856 Scanline pScanlineRead = pAcc->GetScanline( y );
1857 for ( tools::Long x = 0; x < nWidth; x++ )
1858 {
1859 Compress( pAcc->GetIndexFromData( pScanlineRead, x ) );
1860 }
1861 }
1862 EndCompression();
1863 }
1864 else
1865 {
1866 for ( tools::Long y = 0; y < nHeight; y++ )
1867 {
1868 Scanline pScanlineRead = pAcc->GetScanline( y );
1869 for ( tools::Long x = 0; x < nWidth; x++ )
1870 {
1871 ImplWriteHexByte( pAcc->GetIndexFromData( pScanlineRead, x ) );
1872 }
1873 }
1874 }
1875 }
1876 else // 24 bit color
1877 {
1878 ImplWriteLine( "/DeviceRGB setcolorspace" );
1879 ImplWriteLine( "<<" );
1880 ImplWriteLine( "/ImageType 1" );
1881 mpPS->WriteOString( "/Width " );
1882 ImplWriteLong( nWidth, PS_RET );
1883 mpPS->WriteOString( "/Height " );
1884 ImplWriteLong( nHeight, PS_RET );
1885 ImplWriteLine( "/BitsPerComponent 8" );
1886 ImplWriteLine( "/Decode[0 1 0 1 0 1]" );
1887 mpPS->WriteOString( "/ImageMatrix[" );
1888 ImplWriteLong( nWidth );
1889 mpPS->WriteOString( "0 0 " );
1890 ImplWriteLong( -nHeight );
1891 ImplWriteLong( 0 );
1892 ImplWriteLong( nHeight, PS_NONE );
1893 ImplWriteByte( ']', PS_RET );
1894 ImplWriteLine( "/DataSource currentfile" );
1895 ImplWriteLine( "/ASCIIHexDecode filter" );
1896 if ( mbCompression )
1897 ImplWriteLine( "/LZWDecode filter" );
1898 ImplWriteLine( ">>" );
1899 ImplWriteLine( "image" );
1900 if ( mbCompression )
1901 {
1902 StartCompression();
1903 for ( tools::Long y = 0; y < nHeight; y++ )
1904 {
1905 Scanline pScanlineRead = pAcc->GetScanline( y );
1906 for ( tools::Long x = 0; x < nWidth; x++ )
1907 {
1908 const BitmapColor aBitmapColor( pAcc->GetPixelFromData( pScanlineRead, x ) );
1909 Compress( aBitmapColor.GetRed() );
1910 Compress( aBitmapColor.GetGreen() );
1911 Compress( aBitmapColor.GetBlue() );
1912 }
1913 }
1914 EndCompression();
1915 }
1916 else
1917 {
1918 for ( tools::Long y = 0; y < nHeight; y++ )
1919 {
1920 Scanline pScanline = pAcc->GetScanline( y );
1921 for ( tools::Long x = 0; x < nWidth; x++ )
1922 {
1923 const BitmapColor aBitmapColor( pAcc->GetPixelFromData( pScanline, x ) );
1924 ImplWriteHexByte( aBitmapColor.GetRed() );
1925 ImplWriteHexByte( aBitmapColor.GetGreen() );
1926 ImplWriteHexByte( aBitmapColor.GetBlue() );
1927 }
1928 }
1929 }
1930 }
1931 }
1932 ImplWriteLine( ">" ); // in Level 2 the dictionary needs to be closed (eod)
1933 }
1934 if ( bDoTrans )
1935 ImplWriteLine( "gr" );
1936 else
1937 ImplWriteLine( "pom" );
1938
1939 pAcc.reset();
1940 nHeightLeft -= nHeight;
1941 if ( nHeightLeft )
1942 {
1943 nHeightLeft++;
1944 aSourcePos.setY( static_cast<tools::Long>( rPoint.Y() + ( nYHeightOrg * ( nHeightOrg - nHeightLeft ) ) / nHeightOrg ) );
1945 }
1946 }
1947 }
1948
1949 void PSWriter::ImplWriteCharacter( char nChar )
1950 {
1951 switch( nChar )
1952 {
1953 case '(' :
1954 case ')' :
1955 case '\\' :
1956 ImplWriteByte( sal_uInt8('\\'), PS_NONE );
1957 }
1958 ImplWriteByte( static_cast<sal_uInt8>(nChar), PS_NONE );
1959 }
1960
1961 void PSWriter::ImplWriteString( const OString& rString, VirtualDevice const & rVDev, KernArraySpan pDXArry, bool bStretch )
1962 {
1963 sal_Int32 nLen = rString.getLength();
1964 if ( !nLen )
1965 return;
1966
1967 if ( !pDXArry.empty() )
1968 {
1969 double nx = 0;
1970
1971 for (sal_Int32 i = 0; i < nLen; ++i)
1972 {
1973 if ( i > 0 )
1974 nx = pDXArry[ i - 1 ];
1975 ImplWriteDouble( bStretch ? nx : rVDev.GetTextWidth( OUString(rString[i]) ) );
1976 ImplWriteDouble( nx );
1977 ImplWriteLine( "(", PS_NONE );
1978 ImplWriteCharacter( rString[i] );
1979 ImplWriteLine( ") bs" );
1980 }
1981 }
1982 else
1983 {
1984 ImplWriteByte( '(', PS_NONE );
1985 for (sal_Int32 i = 0; i < nLen; ++i)
1986 ImplWriteCharacter( rString[i] );
1987 ImplWriteLine( ") sw" );
1988 }
1989 }
1990
1991 void PSWriter::ImplText( const OUString& rUniString, const Point& rPos, KernArraySpan pDXArry, std::span<const sal_Bool> pKashidaArry, sal_Int32 nWidth, VirtualDevice const & rVDev )
1992 {
1993 if ( rUniString.isEmpty() )
1994 return;
1995 if ( mnTextMode == 0 ) // using glyph outlines
1996 {
1997 vcl::Font aNotRotatedFont( maFont );
1998 aNotRotatedFont.SetOrientation( 0_deg10 );
1999
2000 ScopedVclPtrInstance< VirtualDevice > pVirDev(DeviceFormat::WITHOUT_ALPHA);
2001 pVirDev->SetMapMode( rVDev.GetMapMode() );
2002 pVirDev->SetFont( aNotRotatedFont );
2003 pVirDev->SetTextAlign( eTextAlign );
2004
2005 Degree10 nRotation = maFont.GetOrientation();
2006 tools::Polygon aPolyDummy( 1 );
2007
2008 Point aPos( rPos );
2009 if ( nRotation )
2010 {
2011 aPolyDummy.SetPoint( aPos, 0 );
2012 aPolyDummy.Rotate( rPos, nRotation );
2013 aPos = aPolyDummy.GetPoint( 0 );
2014 }
2015 bool bOldLineColor = bLineColor;
2016 bLineColor = false;
2017 std::vector<tools::PolyPolygon> aPolyPolyVec;
2018 if ( pVirDev->GetTextOutlines( aPolyPolyVec, rUniString, 0, 0, -1, nWidth, pDXArry, pKashidaArry ) )
2019 {
2020 // always adjust text position to match baseline alignment
2021 ImplWriteLine( "pum" );
2022 ImplWriteDouble( aPos.X() );
2023 ImplWriteDouble( aPos.Y() );
2024 ImplWriteLine( "t" );
2025 if ( nRotation )
2026 {
2027 ImplWriteF( nRotation.get(), 1 );
2028 mpPS->WriteOString( "r " );
2029 }
2030 for (auto const& elem : aPolyPolyVec)
2031 ImplPolyPoly( elem, true );
2032 ImplWriteLine( "pom" );
2033 }
2034 bLineColor = bOldLineColor;
2035 }
2036 else if ( ( mnTextMode == 1 ) || ( mnTextMode == 2 ) ) // normal text output
2037 {
2038 if ( mnTextMode == 2 ) // forcing output one complete text packet, by
2039 pDXArry = {}; // ignoring the kerning array
2040 ImplSetAttrForText( rPos );
2041 OString aStr(OUStringToOString(rUniString,
2042 maFont.GetCharSet()));
2043 ImplWriteString( aStr, rVDev, pDXArry, nWidth != 0 );
2044 if ( maFont.GetOrientation() )
2045 ImplWriteLine( "gr" );
2046 }
2047 }
2048
2049 void PSWriter::ImplSetAttrForText( const Point& rPoint )
2050 {
2051 Point aPoint( rPoint );
2052
2053 Degree10 nRotation = maFont.GetOrientation();
2054 ImplWriteTextColor(PS_RET);
2055
2056 Size aSize = maFont.GetFontSize();
2057
2058 if ( maLastFont != maFont )
2059 {
2060 if ( maFont.GetPitch() == PITCH_FIXED ) // a little bit font selection
2061 ImplDefineFont( "Courier", "Oblique" );
2062 else if ( maFont.GetCharSet() == RTL_TEXTENCODING_SYMBOL )
2063 ImplWriteLine( "/Symbol findfont" );
2064 else if ( maFont.GetFamilyType() == FAMILY_SWISS )
2065 ImplDefineFont( "Helvetica", "Oblique" );
2066 else
2067 ImplDefineFont( "Times", "Italic" );
2068
2069 maLastFont = maFont;
2070 aSize = maFont.GetFontSize();
2071 ImplWriteDouble( aSize.Height() );
2072 mpPS->WriteOString( "sf " );
2073 }
2074 if ( eTextAlign != ALIGN_BASELINE )
2075 { // PostScript does not know about FontAlignment
2076 if ( eTextAlign == ALIGN_TOP ) // -> so I assume that
2077 aPoint.AdjustY( aSize.Height() * 4 / 5 ); // the area under the baseline
2078 else if ( eTextAlign == ALIGN_BOTTOM ) // is about 20% of the font size
2079 aPoint.AdjustY( -( aSize.Height() / 5 ) );
2080 }
2081 ImplMoveTo( aPoint );
2082 if ( nRotation )
2083 {
2084 mpPS->WriteOString( "gs " );
2085 ImplWriteF( nRotation.get(), 1 );
2086 mpPS->WriteOString( "r " );
2087 }
2088 }
2089
2090 void PSWriter::ImplDefineFont( const char* pOriginalName, const char* pItalic )
2091 {
2092 mpPS->WriteUChar( '/' ); //convert the font pOriginalName using ISOLatin1Encoding
2093 mpPS->WriteOString( pOriginalName );
2094 switch ( maFont.GetWeight() )
2095 {
2096 case WEIGHT_SEMIBOLD :
2097 case WEIGHT_BOLD :
2098 case WEIGHT_ULTRABOLD :
2099 case WEIGHT_BLACK :
2100 mpPS->WriteOString( "-Bold" );
2101 if ( maFont.GetItalic() != ITALIC_NONE )
2102 mpPS->WriteOString( pItalic );
2103 break;
2104 default:
2105 if ( maFont.GetItalic() != ITALIC_NONE )
2106 mpPS->WriteOString( pItalic );
2107 break;
2108 }
2109 ImplWriteLine( " f" );
2110 }
2111
2112 void PSWriter::ImplClosePathDraw()
2113 {
2114 mpPS->WriteOString( "pc" );
2115 mnCursorPos += 2;
2116 ImplExecMode( PS_RET );
2117 }
2118
2119 void PSWriter::ImplPathDraw()
2120 {
2121 mpPS->WriteOString( "ps" );
2122 mnCursorPos += 2;
2123 ImplExecMode( PS_RET );
2124 }
2125
2126
2127 inline void PSWriter::ImplWriteLineColor( NMode nMode )
2128 {
2129 if ( aColor != aLineColor )
2130 {
2131 aColor = aLineColor;
2132 ImplWriteColor( nMode );
2133 }
2134 }
2135
2136 inline void PSWriter::ImplWriteFillColor( NMode nMode )
2137 {
2138 if ( aColor != aFillColor )
2139 {
2140 aColor = aFillColor;
2141 ImplWriteColor( nMode );
2142 }
2143 }
2144
2145 inline void PSWriter::ImplWriteTextColor( NMode nMode )
2146 {
2147 if ( aColor != aTextColor )
2148 {
2149 aColor = aTextColor;
2150 ImplWriteColor( nMode );
2151 }
2152 }
2153
2154 void PSWriter::ImplWriteColor( NMode nMode )
2155 {
2156 if ( mbGrayScale )
2157 {
2158 // writes the Color (grayscale) as a Number from 0.000 up to 1.000
2159
2160 ImplWriteF( 1000 * ( aColor.GetRed() * 77 + aColor.GetGreen() * 151 +
2161 aColor.GetBlue() * 28 + 1 ) / 65536, 3, nMode );
2162 }
2163 else
2164 {
2165 ImplWriteB1 ( aColor.GetRed() );
2166 ImplWriteB1 ( aColor.GetGreen() );
2167 ImplWriteB1 ( aColor.GetBlue() );
2168 }
2169 mpPS->WriteOString( "c" ); // ( c is defined as setrgbcolor or setgray )
2170 ImplExecMode( nMode );
2171 }
2172
2173 void PSWriter::ImplGetMapMode( const MapMode& rMapMode )
2174 {
2175 ImplWriteLine( "tm setmatrix" );
2176 double fScaleX(rMapMode.GetScaleX());
2177 double fScaleY(rMapMode.GetScaleY());
2178 if (o3tl::Length l = MapToO3tlLength(rMapMode.GetMapUnit(), o3tl::Length::invalid);
2179 l != o3tl::Length::invalid)
2180 {
2181 fScaleX = o3tl::convert(fScaleX, l, o3tl::Length::mm100);
2182 fScaleY = o3tl::convert(fScaleY, l, o3tl::Length::mm100);
2183 }
2184 ImplTranslate( rMapMode.GetOrigin().X() * fScaleX, rMapMode.GetOrigin().Y() * fScaleY );
2185 ImplScale( fScaleX, fScaleY );
2186 }
2187
2188 inline void PSWriter::ImplExecMode( NMode nMode )
2189 {
2190 if ( nMode & PS_WRAP )
2191 {
2192 if ( mnCursorPos >= PS_LINESIZE )
2193 {
2194 mnCursorPos = 0;
2195 mpPS->WriteUChar( 0xa );
2196 return;
2197 }
2198 }
2199 if ( nMode & PS_SPACE )
2200 {
2201 mpPS->WriteUChar( 32 );
2202 mnCursorPos++;
2203 }
2204 if ( nMode & PS_RET )
2205 {
2206 mpPS->WriteUChar( 0xa );
2207 mnCursorPos = 0;
2208 }
2209 }
2210
2211 inline void PSWriter::ImplWriteLine( const char* pString, NMode nMode )
2212 {
2213 sal_uInt32 i = 0;
2214 while ( pString[ i ] )
2215 {
2216 mpPS->WriteUChar( pString[ i++ ] );
2217 }
2218 mnCursorPos += i;
2219 ImplExecMode( nMode );
2220 }
2221
2222 void PSWriter::ImplWriteLineInfo( double fLWidth, double fMLimit,
2223 SvtGraphicStroke::CapType eLCap,
2224 SvtGraphicStroke::JoinType eJoin,
2225 SvtGraphicStroke::DashArray && rLDash )
2226 {
2227 if ( fLineWidth != fLWidth )
2228 {
2229 fLineWidth = fLWidth;
2230 ImplWriteDouble( fLineWidth );
2231 ImplWriteLine( "lw", PS_SPACE );
2232 }
2233 if ( eLineCap != eLCap )
2234 {
2235 eLineCap = eLCap;
2236 ImplWriteLong( static_cast<sal_Int32>(eLineCap) );
2237 ImplWriteLine( "lc", PS_SPACE );
2238 }
2239 if ( eJoinType != eJoin )
2240 {
2241 eJoinType = eJoin;
2242 ImplWriteLong( static_cast<sal_Int32>(eJoinType) );
2243 ImplWriteLine( "lj", PS_SPACE );
2244 }
2245 if ( eJoinType == SvtGraphicStroke::joinMiter )
2246 {
2247 if ( fMiterLimit != fMLimit )
2248 {
2249 fMiterLimit = fMLimit;
2250 ImplWriteDouble( fMiterLimit );
2251 ImplWriteLine( "ml", PS_SPACE );
2252 }
2253 }
2254 if ( aDashArray != rLDash )
2255 {
2256 aDashArray = std::move(rLDash);
2257 sal_uInt32 j, i = aDashArray.size();
2258 ImplWriteLine( "[", PS_SPACE );
2259 for ( j = 0; j < i; j++ )
2260 ImplWriteDouble( aDashArray[ j ] );
2261 ImplWriteLine( "] 0 ld" );
2262 }
2263 }
2264
2265 void PSWriter::ImplWriteLineInfo( const LineInfo& rLineInfo )
2266 {
2267 std::vector< double > l_aDashArray;
2268 if ( rLineInfo.GetStyle() == LineStyle::Dash )
2269 l_aDashArray = rLineInfo.GetDotDashArray();
2270 const double fLWidth(( ( rLineInfo.GetWidth() + 1 ) + ( rLineInfo.GetWidth() + 1 ) ) * 0.5);
2271 SvtGraphicStroke::JoinType aJoinType(SvtGraphicStroke::joinMiter);
2272 SvtGraphicStroke::CapType aCapType(SvtGraphicStroke::capButt);
2273
2274 switch(rLineInfo.GetLineJoin())
2275 {
2276 case basegfx::B2DLineJoin::NONE:
2277 // do NOT use SvtGraphicStroke::joinNone here
2278 // since it will be written as numerical value directly
2279 // and is NOT a valid EPS value
2280 break;
2281 case basegfx::B2DLineJoin::Miter:
2282 aJoinType = SvtGraphicStroke::joinMiter;
2283 break;
2284 case basegfx::B2DLineJoin::Bevel:
2285 aJoinType = SvtGraphicStroke::joinBevel;
2286 break;
2287 case basegfx::B2DLineJoin::Round:
2288 aJoinType = SvtGraphicStroke::joinRound;
2289 break;
2290 }
2291 switch(rLineInfo.GetLineCap())
2292 {
2293 default: /* css::drawing::LineCap_BUTT */
2294 {
2295 aCapType = SvtGraphicStroke::capButt;
2296 break;
2297 }
2298 case css::drawing::LineCap_ROUND:
2299 {
2300 aCapType = SvtGraphicStroke::capRound;
2301 break;
2302 }
2303 case css::drawing::LineCap_SQUARE:
2304 {
2305 aCapType = SvtGraphicStroke::capSquare;
2306 break;
2307 }
2308 }
2309
2310 ImplWriteLineInfo( fLWidth, fMiterLimit, aCapType, aJoinType, std::move(l_aDashArray) );
2311 }
2312
2313 void PSWriter::ImplWriteLong(sal_Int32 nNumber, NMode nMode)
2314 {
2315 const OString aNumber(OString::number(nNumber));
2316 mnCursorPos += aNumber.getLength();
2317 mpPS->WriteOString( aNumber );
2318 ImplExecMode(nMode);
2319 }
2320
2321 void PSWriter::ImplWriteDouble( double fNumber )
2322 {
2323 sal_Int32 nPTemp = static_cast<sal_Int32>(fNumber);
2324 sal_Int32 nATemp = std::abs( static_cast<sal_Int32>( ( fNumber - nPTemp ) * 100000 ) );
2325
2326 if ( !nPTemp && nATemp && ( fNumber < 0.0 ) )
2327 mpPS->WriteChar( '-' );
2328
2329 const OString aNumber1(OString::number(nPTemp));
2330 mpPS->WriteOString( aNumber1 );
2331 mnCursorPos += aNumber1.getLength();
2332
2333 if ( nATemp )
2334 {
2335 int zCount = 0;
2336 mpPS->WriteUChar( '.' );
2337 mnCursorPos++;
2338 const OString aNumber2(OString::number(nATemp));
2339
2340 sal_Int16 n, nLen = aNumber2.getLength();
2341 if ( nLen < 8 )
2342 {
2343 mnCursorPos += 6 - nLen;
2344 for ( n = 0; n < ( 5 - nLen ); n++ )
2345 {
2346 mpPS->WriteUChar( '0' );
2347 }
2348 }
2349 mnCursorPos += nLen;
2350 for ( n = 0; n < nLen; n++ )
2351 {
2352 mpPS->WriteChar( aNumber2[n] );
2353 zCount--;
2354 if ( aNumber2[n] != '0' )
2355 zCount = 0;
2356 }
2357 if ( zCount )
2358 mpPS->SeekRel( zCount );
2359 }
2360 ImplExecMode( PS_SPACE );
2361 }
2362
2363 /// Writes the number to stream: nNumber / ( 10^nCount )
2364 void PSWriter::ImplWriteF( sal_Int32 nNumber, sal_uInt8 nCount, NMode nMode )
2365 {
2366 if ( nNumber < 0 )
2367 {
2368 mpPS->WriteUChar( '-' );
2369 nNumber = -nNumber;
2370 mnCursorPos++;
2371 }
2372 const OString aScaleFactor(OString::number(nNumber));
2373 sal_uInt32 nLen = aScaleFactor.getLength();
2374 sal_Int32 const nStSize = (nCount + 1) - nLen;
2375 static_assert(sizeof(nStSize) == sizeof((nCount + 1) - nLen)); // tdf#134667
2376 if ( nStSize >= 1 )
2377 {
2378 mpPS->WriteUChar( '0' );
2379 mnCursorPos++;
2380 }
2381 if ( nStSize >= 2 )
2382 {
2383 mpPS->WriteUChar( '.' );
2384 for (sal_Int32 i = 1; i < nStSize; ++i)
2385 {
2386 mpPS->WriteUChar( '0' );
2387 mnCursorPos++;
2388 }
2389 }
2390 mnCursorPos += nLen;
2391 for( sal_uInt32 n = 0; n < nLen; n++ )
2392 {
2393 if ( n == nLen - nCount )
2394 {
2395 mpPS->WriteUChar( '.' );
2396 mnCursorPos++;
2397 }
2398 mpPS->WriteChar( aScaleFactor[n] );
2399 }
2400 ImplExecMode( nMode );
2401 }
2402
2403 void PSWriter::ImplWriteByte( sal_uInt8 nNumb, NMode nMode )
2404 {
2405 mpPS->WriteUChar( nNumb );
2406 mnCursorPos++;
2407 ImplExecMode( nMode );
2408 }
2409
2410 void PSWriter::ImplWriteHexByte( sal_uInt8 nNumb, NMode nMode )
2411 {
2412 if ( ( nNumb >> 4 ) > 9 )
2413 mpPS->WriteUChar( ( nNumb >> 4 ) + 'A' - 10 );
2414 else
2415 mpPS->WriteUChar( ( nNumb >> 4 ) + '0' );
2416
2417 if ( ( nNumb & 0xf ) > 9 )
2418 mpPS->WriteUChar( ( nNumb & 0xf ) + 'A' - 10 );
2419 else
2420 mpPS->WriteUChar( ( nNumb & 0xf ) + '0' );
2421 mnCursorPos += 2;
2422 ImplExecMode( nMode );
2423 }
2424
2425 // writes the sal_uInt8 nNumb as a Number from 0.000 up to 1.000
2426
2427 void PSWriter::ImplWriteB1( sal_uInt8 nNumb )
2428 {
2429 ImplWriteF( 1000 * ( nNumb + 1 ) / 256 );
2430 }
2431
2432 inline void PSWriter::WriteBits( sal_uInt16 nCode, sal_uInt16 nCodeLen )
2433 {
2434 dwShift |= ( nCode << ( nOffset - nCodeLen ) );
2435 nOffset -= nCodeLen;
2436 while ( nOffset < 24 )
2437 {
2438 ImplWriteHexByte( static_cast<sal_uInt8>( dwShift >> 24 ) );
2439 dwShift <<= 8;
2440 nOffset += 8;
2441 }
2442 if ( nCode == 257 && nOffset != 32 )
2443 ImplWriteHexByte( static_cast<sal_uInt8>( dwShift >> 24 ) );
2444 }
2445
2446 void PSWriter::StartCompression()
2447 {
2448 sal_uInt16 i;
2449 nDataSize = 8;
2450
2451 nClearCode = 1 << nDataSize;
2452 nEOICode = nClearCode + 1;
2453 nTableSize = nEOICode + 1;
2454 nCodeSize = nDataSize + 1;
2455
2456 nOffset = 32; // number of free unused in dwShift
2457 dwShift = 0;
2458
2459 pTable.reset(new PSLZWCTreeNode[ 4096 ]);
2460
2461 for ( i = 0; i < 4096; i++ )
2462 {
2463 pTable[ i ].pBrother = pTable[ i ].pFirstChild = nullptr;
2464 pTable[ i ].nCode = i;
2465 pTable[ i ].nValue = static_cast<sal_uInt8>( i );
2466 }
2467 pPrefix = nullptr;
2468 WriteBits( nClearCode, nCodeSize );
2469 }
2470
2471 void PSWriter::Compress( sal_uInt8 nCompThis )
2472 {
2473 PSLZWCTreeNode* p;
2474 sal_uInt16 i;
2475 sal_uInt8 nV;
2476
2477 if( !pPrefix )
2478 {
2479 pPrefix = pTable.get() + nCompThis;
2480 }
2481 else
2482 {
2483 nV = nCompThis;
2484 for( p = pPrefix->pFirstChild; p != nullptr; p = p->pBrother )
2485 {
2486 if ( p->nValue == nV )
2487 break;
2488 }
2489
2490 if( p )
2491 pPrefix = p;
2492 else
2493 {
2494 WriteBits( pPrefix->nCode, nCodeSize );
2495
2496 if ( nTableSize == 409 )
2497 {
2498 WriteBits( nClearCode, nCodeSize );
2499
2500 for ( i = 0; i < nClearCode; i++ )
2501 pTable[ i ].pFirstChild = nullptr;
2502
2503 nCodeSize = nDataSize + 1;
2504 nTableSize = nEOICode + 1;
2505 }
2506 else
2507 {
2508 if( nTableSize == static_cast<sal_uInt16>( ( 1 << nCodeSize ) - 1 ) )
2509 nCodeSize++;
2510
2511 p = pTable.get() + ( nTableSize++ );
2512 p->pBrother = pPrefix->pFirstChild;
2513 pPrefix->pFirstChild = p;
2514 p->nValue = nV;
2515 p->pFirstChild = nullptr;
2516 }
2517
2518 pPrefix = pTable.get() + nV;
2519 }
2520 }
2521 }
2522
2523 void PSWriter::EndCompression()
2524 {
2525 if( pPrefix )
2526 WriteBits( pPrefix->nCode, nCodeSize );
2527
2528 WriteBits( nEOICode, nCodeSize );
2529 pTable.reset();
2530 }
2531
2532 sal_uInt8* PSWriter::ImplSearchEntry( sal_uInt8* pSource, sal_uInt8 const * pDest, sal_uInt32 nComp, sal_uInt32 nSize )
2533 {
2534 while ( nComp-- >= nSize )
2535 {
2536 sal_uInt64 i;
2537 for ( i = 0; i < nSize; i++ )
2538 {
2539 if ( ( pSource[i]&~0x20 ) != ( pDest[i]&~0x20 ) )
2540 break;
2541 }
2542 if ( i == nSize )
2543 return pSource;
2544 pSource++;
2545 }
2546 return nullptr;
2547 }
2548
2549 bool PSWriter::ImplGetBoundingBox( double* nNumb, sal_uInt8* pSource, sal_uInt32 nSize )
2550 {
2551 bool bRetValue = false;
2552 sal_uInt32 nBytesRead;
2553
2554 if ( nSize < 256 ) // we assume that the file is greater than 256 bytes
2555 return false;
2556
2557 if ( nSize < POSTSCRIPT_BOUNDINGSEARCH )
2558 nBytesRead = nSize;
2559 else
2560 nBytesRead = POSTSCRIPT_BOUNDINGSEARCH;
2561
2562 sal_uInt8* pDest = ImplSearchEntry( pSource, reinterpret_cast<sal_uInt8 const *>("%%BoundingBox:"), nBytesRead, 14 );
2563 if ( pDest )
2564 {
2565 int nSecurityCount = 100; // only 100 bytes following the bounding box will be checked
2566 nNumb[0] = nNumb[1] = nNumb[2] = nNumb[3] = 0;
2567 pDest += 14;
2568 for ( int i = 0; ( i < 4 ) && nSecurityCount; i++ )
2569 {
2570 int nDivision = 1;
2571 bool bDivision = false;
2572 bool bNegative = false;
2573 bool bValid = true;
2574
2575 while ( ( --nSecurityCount ) && ( ( *pDest == ' ' ) || ( *pDest == 0x9 ) ) )
2576 pDest++;
2577 sal_uInt8 nByte = *pDest;
2578 while ( nSecurityCount && ( nByte != ' ' ) && ( nByte != 0x9 ) && ( nByte != 0xd ) && ( nByte != 0xa ) )
2579 {
2580 switch ( nByte )
2581 {
2582 case '.' :
2583 if ( bDivision )
2584 bValid = false;
2585 else
2586 bDivision = true;
2587 break;
2588 case '-' :
2589 bNegative = true;
2590 break;
2591 default :
2592 if ( ( nByte < '0' ) || ( nByte > '9' ) )
2593 nSecurityCount = 1; // error parsing the bounding box values
2594 else if ( bValid )
2595 {
2596 if ( bDivision )
2597 nDivision*=10;
2598 nNumb[i] *= 10;
2599 nNumb[i] += nByte - '0';
2600 }
2601 break;
2602 }
2603 nSecurityCount--;
2604 nByte = *(++pDest);
2605 }
2606 if ( bNegative )
2607 nNumb[i] = -nNumb[i];
2608 if ( bDivision && ( nDivision != 1 ) )
2609 nNumb[i] /= nDivision;
2610 }
2611 if ( nSecurityCount)
2612 bRetValue = true;
2613 }
2614 return bRetValue;
2615 }
2616
2617 //================== GraphicExport - the exported function ===================
2618
2619 bool ExportEpsGraphic(SvStream & rStream, const Graphic & rGraphic, FilterConfigItem* pFilterConfigItem)
2620 {
2621 PSWriter aPSWriter;
2622 return aPSWriter.WritePS(rGraphic, rStream, pFilterConfigItem);
2623 }
2624
2625 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE