Line data Source code
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 "pdfwriter_impl.hxx"
21 :
22 : #include "vcl/pdfextoutdevdata.hxx"
23 : #include "vcl/virdev.hxx"
24 : #include "vcl/gdimtf.hxx"
25 : #include "vcl/metaact.hxx"
26 : #include "vcl/bmpacc.hxx"
27 : #include "vcl/graph.hxx"
28 :
29 : #include "svdata.hxx"
30 :
31 : #include "unotools/streamwrap.hxx"
32 :
33 : #include <tools/fract.hxx>
34 :
35 : #include "comphelper/processfactory.hxx"
36 :
37 : #include "com/sun/star/beans/PropertyValue.hpp"
38 : #include "com/sun/star/io/XSeekable.hpp"
39 : #include "com/sun/star/graphic/GraphicProvider.hpp"
40 : #include "com/sun/star/graphic/XGraphicProvider.hpp"
41 :
42 : #include "cppuhelper/implbase1.hxx"
43 :
44 : #include <rtl/digest.h>
45 : #include <memory>
46 :
47 : using namespace vcl;
48 : using namespace com::sun::star;
49 : using namespace com::sun::star::uno;
50 : using namespace com::sun::star::beans;
51 :
52 : static bool lcl_canUsePDFAxialShading(const Gradient& rGradient);
53 :
54 0 : void PDFWriterImpl::implWriteGradient( const tools::PolyPolygon& i_rPolyPoly, const Gradient& i_rGradient,
55 : VirtualDevice* i_pDummyVDev, const vcl::PDFWriter::PlayMetafileContext& i_rContext )
56 : {
57 0 : GDIMetaFile aTmpMtf;
58 :
59 0 : i_pDummyVDev->AddGradientActions( i_rPolyPoly.GetBoundRect(), i_rGradient, aTmpMtf );
60 :
61 0 : m_rOuterFace.Push();
62 0 : m_rOuterFace.IntersectClipRegion( i_rPolyPoly.getB2DPolyPolygon() );
63 0 : playMetafile( aTmpMtf, NULL, i_rContext, i_pDummyVDev );
64 0 : m_rOuterFace.Pop();
65 0 : }
66 :
67 0 : void PDFWriterImpl::implWriteBitmapEx( const Point& i_rPoint, const Size& i_rSize, const BitmapEx& i_rBitmapEx,
68 : VirtualDevice* i_pDummyVDev, const vcl::PDFWriter::PlayMetafileContext& i_rContext )
69 : {
70 0 : if ( !i_rBitmapEx.IsEmpty() && i_rSize.Width() && i_rSize.Height() )
71 : {
72 0 : BitmapEx aBitmapEx( i_rBitmapEx );
73 0 : Point aPoint( i_rPoint );
74 0 : Size aSize( i_rSize );
75 :
76 : // #i19065# Negative sizes have mirror semantics on
77 : // OutputDevice. BitmapEx and co. have no idea about that, so
78 : // perform that _before_ doing anything with aBitmapEx.
79 0 : BmpMirrorFlags nMirrorFlags(BmpMirrorFlags::NONE);
80 0 : if( aSize.Width() < 0 )
81 : {
82 0 : aSize.Width() *= -1;
83 0 : aPoint.X() -= aSize.Width();
84 0 : nMirrorFlags |= BmpMirrorFlags::Horizontal;
85 : }
86 0 : if( aSize.Height() < 0 )
87 : {
88 0 : aSize.Height() *= -1;
89 0 : aPoint.Y() -= aSize.Height();
90 0 : nMirrorFlags |= BmpMirrorFlags::Vertical;
91 : }
92 :
93 0 : if( nMirrorFlags != BmpMirrorFlags::NONE )
94 : {
95 0 : aBitmapEx.Mirror( nMirrorFlags );
96 : }
97 0 : if( i_rContext.m_nMaxImageResolution > 50 )
98 : {
99 : // do downsampling if necessary
100 0 : const Size aDstSizeTwip( i_pDummyVDev->PixelToLogic( i_pDummyVDev->LogicToPixel( aSize ), MAP_TWIP ) );
101 0 : const Size aBmpSize( aBitmapEx.GetSizePixel() );
102 0 : const double fBmpPixelX = aBmpSize.Width();
103 0 : const double fBmpPixelY = aBmpSize.Height();
104 0 : const double fMaxPixelX = aDstSizeTwip.Width() * i_rContext.m_nMaxImageResolution / 1440.0;
105 0 : const double fMaxPixelY = aDstSizeTwip.Height() * i_rContext.m_nMaxImageResolution / 1440.0;
106 :
107 : // check, if the bitmap DPI exceeds the maximum DPI (allow 4 pixel rounding tolerance)
108 0 : if( ( ( fBmpPixelX > ( fMaxPixelX + 4 ) ) ||
109 0 : ( fBmpPixelY > ( fMaxPixelY + 4 ) ) ) &&
110 0 : ( fBmpPixelY > 0.0 ) && ( fMaxPixelY > 0.0 ) )
111 : {
112 : // do scaling
113 0 : Size aNewBmpSize;
114 0 : const double fBmpWH = fBmpPixelX / fBmpPixelY;
115 0 : const double fMaxWH = fMaxPixelX / fMaxPixelY;
116 :
117 0 : if( fBmpWH < fMaxWH )
118 : {
119 0 : aNewBmpSize.Width() = FRound( fMaxPixelY * fBmpWH );
120 0 : aNewBmpSize.Height() = FRound( fMaxPixelY );
121 : }
122 0 : else if( fBmpWH > 0.0 )
123 : {
124 0 : aNewBmpSize.Width() = FRound( fMaxPixelX );
125 0 : aNewBmpSize.Height() = FRound( fMaxPixelX / fBmpWH);
126 : }
127 :
128 0 : if( aNewBmpSize.Width() && aNewBmpSize.Height() )
129 : {
130 : // #i121233# Use best quality for PDF exports
131 0 : aBitmapEx.Scale( aNewBmpSize, BmpScaleFlag::BestQuality );
132 : }
133 : else
134 : {
135 0 : aBitmapEx.SetEmpty();
136 : }
137 : }
138 : }
139 :
140 0 : const Size aSizePixel( aBitmapEx.GetSizePixel() );
141 0 : if ( aSizePixel.Width() && aSizePixel.Height() )
142 : {
143 0 : if( m_aContext.ColorMode == PDFWriter::DrawGreyscale )
144 : {
145 0 : BmpConversion eConv = BMP_CONVERSION_8BIT_GREYS;
146 0 : int nDepth = aBitmapEx.GetBitmap().GetBitCount();
147 0 : if( nDepth <= 4 )
148 0 : eConv = BMP_CONVERSION_4BIT_GREYS;
149 0 : if( nDepth > 1 )
150 0 : aBitmapEx.Convert( eConv );
151 : }
152 0 : bool bUseJPGCompression = !i_rContext.m_bOnlyLosslessCompression;
153 0 : if ( ( aSizePixel.Width() < 32 ) || ( aSizePixel.Height() < 32 ) )
154 0 : bUseJPGCompression = false;
155 :
156 0 : SvMemoryStream aStrm;
157 0 : Bitmap aMask;
158 :
159 0 : bool bTrueColorJPG = true;
160 0 : if ( bUseJPGCompression )
161 : {
162 : sal_uInt32 nZippedFileSize; // sj: we will calculate the filesize of a zipped bitmap
163 : { // to determine if jpeg compression is useful
164 0 : SvMemoryStream aTemp;
165 0 : aTemp.SetCompressMode( aTemp.GetCompressMode() | SvStreamCompressFlags::ZBITMAP );
166 0 : aTemp.SetVersion( SOFFICE_FILEFORMAT_40 ); // sj: up from version 40 our bitmap stream operator
167 0 : WriteDIBBitmapEx(aBitmapEx, aTemp); // is capable of zlib stream compression
168 0 : aTemp.Seek( STREAM_SEEK_TO_END );
169 0 : nZippedFileSize = aTemp.Tell();
170 : }
171 0 : if ( aBitmapEx.IsTransparent() )
172 : {
173 0 : if ( aBitmapEx.IsAlpha() )
174 0 : aMask = aBitmapEx.GetAlpha().GetBitmap();
175 : else
176 0 : aMask = aBitmapEx.GetMask();
177 : }
178 0 : Graphic aGraphic( aBitmapEx.GetBitmap() );
179 0 : sal_Int32 nColorMode = 0;
180 :
181 0 : Sequence< PropertyValue > aFilterData( 2 );
182 0 : aFilterData[ 0 ].Name = "Quality";
183 0 : aFilterData[ 0 ].Value <<= sal_Int32(i_rContext.m_nJPEGQuality);
184 0 : aFilterData[ 1 ].Name = "ColorMode";
185 0 : aFilterData[ 1 ].Value <<= nColorMode;
186 :
187 : try
188 : {
189 0 : uno::Reference < io::XStream > xStream = new utl::OStreamWrapper( aStrm );
190 0 : uno::Reference< io::XSeekable > xSeekable( xStream, UNO_QUERY_THROW );
191 0 : uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );
192 0 : uno::Reference< graphic::XGraphicProvider > xGraphicProvider( graphic::GraphicProvider::create(xContext) );
193 0 : uno::Reference< graphic::XGraphic > xGraphic( aGraphic.GetXGraphic() );
194 0 : uno::Reference < io::XOutputStream > xOut( xStream->getOutputStream() );
195 0 : OUString aMimeType("image/jpeg");
196 0 : uno::Sequence< beans::PropertyValue > aOutMediaProperties( 3 );
197 0 : aOutMediaProperties[0].Name = "OutputStream";
198 0 : aOutMediaProperties[0].Value <<= xOut;
199 0 : aOutMediaProperties[1].Name = "MimeType";
200 0 : aOutMediaProperties[1].Value <<= aMimeType;
201 0 : aOutMediaProperties[2].Name = "FilterData";
202 0 : aOutMediaProperties[2].Value <<= aFilterData;
203 0 : xGraphicProvider->storeGraphic( xGraphic, aOutMediaProperties );
204 0 : xOut->flush();
205 0 : if ( xSeekable->getLength() > nZippedFileSize )
206 : {
207 0 : bUseJPGCompression = false;
208 : }
209 : else
210 : {
211 0 : aStrm.Seek( STREAM_SEEK_TO_END );
212 :
213 0 : xSeekable->seek( 0 );
214 0 : Sequence< PropertyValue > aArgs( 1 );
215 0 : aArgs[ 0 ].Name = "InputStream";
216 0 : aArgs[ 0 ].Value <<= xStream;
217 0 : uno::Reference< XPropertySet > xPropSet( xGraphicProvider->queryGraphicDescriptor( aArgs ) );
218 0 : if ( xPropSet.is() )
219 : {
220 0 : sal_Int16 nBitsPerPixel = 24;
221 0 : if ( xPropSet->getPropertyValue("BitsPerPixel") >>= nBitsPerPixel )
222 : {
223 0 : bTrueColorJPG = nBitsPerPixel != 8;
224 : }
225 0 : }
226 0 : }
227 : }
228 0 : catch( uno::Exception& )
229 : {
230 0 : bUseJPGCompression = false;
231 0 : }
232 : }
233 0 : if ( bUseJPGCompression )
234 0 : m_rOuterFace.DrawJPGBitmap( aStrm, bTrueColorJPG, aSizePixel, Rectangle( aPoint, aSize ), aMask );
235 0 : else if ( aBitmapEx.IsTransparent() )
236 0 : m_rOuterFace.DrawBitmapEx( aPoint, aSize, aBitmapEx );
237 : else
238 0 : m_rOuterFace.DrawBitmap( aPoint, aSize, aBitmapEx.GetBitmap() );
239 0 : }
240 : }
241 0 : }
242 :
243 0 : void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevData* i_pOutDevData, const vcl::PDFWriter::PlayMetafileContext& i_rContext, VirtualDevice* pDummyVDev )
244 : {
245 0 : bool bAssertionFired( false );
246 :
247 0 : ScopedVclPtr<VirtualDevice> xPrivateDevice;
248 0 : if( ! pDummyVDev )
249 : {
250 0 : xPrivateDevice.reset(VclPtr<VirtualDevice>::Create());
251 0 : pDummyVDev = xPrivateDevice.get();
252 0 : pDummyVDev->EnableOutput( false );
253 0 : pDummyVDev->SetMapMode( i_rMtf.GetPrefMapMode() );
254 : }
255 0 : GDIMetaFile aMtf( i_rMtf );
256 :
257 0 : for( sal_uInt32 i = 0, nCount = aMtf.GetActionSize(); i < (sal_uInt32)nCount; )
258 : {
259 0 : if ( !i_pOutDevData || !i_pOutDevData->PlaySyncPageAct( m_rOuterFace, i ) )
260 : {
261 0 : const MetaAction* pAction = aMtf.GetAction( i );
262 0 : const MetaActionType nType = pAction->GetType();
263 :
264 0 : switch( nType )
265 : {
266 : case( MetaActionType::PIXEL ):
267 : {
268 0 : const MetaPixelAction* pA = static_cast<const MetaPixelAction*>(pAction);
269 0 : m_rOuterFace.DrawPixel( pA->GetPoint(), pA->GetColor() );
270 : }
271 0 : break;
272 :
273 : case( MetaActionType::POINT ):
274 : {
275 0 : const MetaPointAction* pA = static_cast<const MetaPointAction*>(pAction);
276 0 : m_rOuterFace.DrawPixel( pA->GetPoint() );
277 : }
278 0 : break;
279 :
280 : case( MetaActionType::LINE ):
281 : {
282 0 : const MetaLineAction* pA = static_cast<const MetaLineAction*>(pAction);
283 0 : if ( pA->GetLineInfo().IsDefault() )
284 0 : m_rOuterFace.DrawLine( pA->GetStartPoint(), pA->GetEndPoint() );
285 : else
286 0 : m_rOuterFace.DrawLine( pA->GetStartPoint(), pA->GetEndPoint(), pA->GetLineInfo() );
287 : }
288 0 : break;
289 :
290 : case( MetaActionType::RECT ):
291 : {
292 0 : const MetaRectAction* pA = static_cast<const MetaRectAction*>(pAction);
293 0 : m_rOuterFace.DrawRect( pA->GetRect() );
294 : }
295 0 : break;
296 :
297 : case( MetaActionType::ROUNDRECT ):
298 : {
299 0 : const MetaRoundRectAction* pA = static_cast<const MetaRoundRectAction*>(pAction);
300 0 : m_rOuterFace.DrawRect( pA->GetRect(), pA->GetHorzRound(), pA->GetVertRound() );
301 : }
302 0 : break;
303 :
304 : case( MetaActionType::ELLIPSE ):
305 : {
306 0 : const MetaEllipseAction* pA = static_cast<const MetaEllipseAction*>(pAction);
307 0 : m_rOuterFace.DrawEllipse( pA->GetRect() );
308 : }
309 0 : break;
310 :
311 : case( MetaActionType::ARC ):
312 : {
313 0 : const MetaArcAction* pA = static_cast<const MetaArcAction*>(pAction);
314 0 : m_rOuterFace.DrawArc( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint() );
315 : }
316 0 : break;
317 :
318 : case( MetaActionType::PIE ):
319 : {
320 0 : const MetaArcAction* pA = static_cast<const MetaArcAction*>(pAction);
321 0 : m_rOuterFace.DrawPie( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint() );
322 : }
323 0 : break;
324 :
325 : case( MetaActionType::CHORD ):
326 : {
327 0 : const MetaChordAction* pA = static_cast<const MetaChordAction*>(pAction);
328 0 : m_rOuterFace.DrawChord( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint() );
329 : }
330 0 : break;
331 :
332 : case( MetaActionType::POLYGON ):
333 : {
334 0 : const MetaPolygonAction* pA = static_cast<const MetaPolygonAction*>(pAction);
335 0 : m_rOuterFace.DrawPolygon( pA->GetPolygon() );
336 : }
337 0 : break;
338 :
339 : case( MetaActionType::POLYLINE ):
340 : {
341 0 : const MetaPolyLineAction* pA = static_cast<const MetaPolyLineAction*>(pAction);
342 0 : if ( pA->GetLineInfo().IsDefault() )
343 0 : m_rOuterFace.DrawPolyLine( pA->GetPolygon() );
344 : else
345 0 : m_rOuterFace.DrawPolyLine( pA->GetPolygon(), pA->GetLineInfo() );
346 : }
347 0 : break;
348 :
349 : case( MetaActionType::POLYPOLYGON ):
350 : {
351 0 : const MetaPolyPolygonAction* pA = static_cast<const MetaPolyPolygonAction*>(pAction);
352 0 : m_rOuterFace.DrawPolyPolygon( pA->GetPolyPolygon() );
353 : }
354 0 : break;
355 :
356 : case( MetaActionType::GRADIENT ):
357 : {
358 0 : const MetaGradientAction* pA = static_cast<const MetaGradientAction*>(pAction);
359 0 : const Gradient& rGradient = pA->GetGradient();
360 0 : if (lcl_canUsePDFAxialShading(rGradient))
361 : {
362 0 : m_rOuterFace.DrawGradient( pA->GetRect(), rGradient );
363 : }
364 : else
365 : {
366 0 : const tools::PolyPolygon aPolyPoly( pA->GetRect() );
367 0 : implWriteGradient( aPolyPoly, rGradient, pDummyVDev, i_rContext );
368 : }
369 : }
370 0 : break;
371 :
372 : case( MetaActionType::GRADIENTEX ):
373 : {
374 0 : const MetaGradientExAction* pA = static_cast<const MetaGradientExAction*>(pAction);
375 0 : const Gradient& rGradient = pA->GetGradient();
376 :
377 0 : if (lcl_canUsePDFAxialShading(rGradient))
378 0 : m_rOuterFace.DrawGradient( pA->GetPolyPolygon(), rGradient );
379 : else
380 0 : implWriteGradient( pA->GetPolyPolygon(), rGradient, pDummyVDev, i_rContext );
381 : }
382 0 : break;
383 :
384 : case MetaActionType::HATCH:
385 : {
386 0 : const MetaHatchAction* pA = static_cast<const MetaHatchAction*>(pAction);
387 0 : m_rOuterFace.DrawHatch( pA->GetPolyPolygon(), pA->GetHatch() );
388 : }
389 0 : break;
390 :
391 : case( MetaActionType::Transparent ):
392 : {
393 0 : const MetaTransparentAction* pA = static_cast<const MetaTransparentAction*>(pAction);
394 0 : m_rOuterFace.DrawTransparent( pA->GetPolyPolygon(), pA->GetTransparence() );
395 : }
396 0 : break;
397 :
398 : case( MetaActionType::FLOATTRANSPARENT ):
399 : {
400 0 : const MetaFloatTransparentAction* pA = static_cast<const MetaFloatTransparentAction*>(pAction);
401 :
402 0 : GDIMetaFile aTmpMtf( pA->GetGDIMetaFile() );
403 0 : const Point& rPos = pA->GetPoint();
404 0 : const Size& rSize= pA->GetSize();
405 0 : const Gradient& rTransparenceGradient = pA->GetGradient();
406 :
407 : // special case constant alpha value
408 0 : if( rTransparenceGradient.GetStartColor() == rTransparenceGradient.GetEndColor() )
409 : {
410 0 : const Color aTransCol( rTransparenceGradient.GetStartColor() );
411 0 : const sal_uInt16 nTransPercent = aTransCol.GetLuminance() * 100 / 255;
412 0 : m_rOuterFace.BeginTransparencyGroup();
413 0 : playMetafile( aTmpMtf, NULL, i_rContext, pDummyVDev );
414 0 : m_rOuterFace.EndTransparencyGroup( Rectangle( rPos, rSize ), nTransPercent );
415 : }
416 : else
417 : {
418 0 : const Size aDstSizeTwip( pDummyVDev->PixelToLogic( pDummyVDev->LogicToPixel( rSize ), MAP_TWIP ) );
419 :
420 : // i#115962# Always use at least 300 DPI for bitmap conversion of transparence gradients,
421 : // else the quality is not acceptable (see bugdoc as example)
422 0 : sal_Int32 nMaxBmpDPI(300);
423 :
424 0 : if( i_rContext.m_nMaxImageResolution > 50 )
425 : {
426 0 : if ( nMaxBmpDPI > i_rContext.m_nMaxImageResolution )
427 0 : nMaxBmpDPI = i_rContext.m_nMaxImageResolution;
428 : }
429 0 : const sal_Int32 nPixelX = (sal_Int32)((double)aDstSizeTwip.Width() * (double)nMaxBmpDPI / 1440.0);
430 0 : const sal_Int32 nPixelY = (sal_Int32)((double)aDstSizeTwip.Height() * (double)nMaxBmpDPI / 1440.0);
431 0 : if ( nPixelX && nPixelY )
432 : {
433 0 : Size aDstSizePixel( nPixelX, nPixelY );
434 0 : ScopedVclPtrInstance<VirtualDevice> xVDev;
435 0 : if( xVDev->SetOutputSizePixel( aDstSizePixel ) )
436 : {
437 0 : Bitmap aPaint, aMask;
438 0 : AlphaMask aAlpha;
439 0 : Point aPoint;
440 :
441 0 : MapMode aMapMode( pDummyVDev->GetMapMode() );
442 0 : aMapMode.SetOrigin( aPoint );
443 0 : xVDev->SetMapMode( aMapMode );
444 0 : Size aDstSize( xVDev->PixelToLogic( aDstSizePixel ) );
445 :
446 0 : Point aMtfOrigin( aTmpMtf.GetPrefMapMode().GetOrigin() );
447 0 : if ( aMtfOrigin.X() || aMtfOrigin.Y() )
448 0 : aTmpMtf.Move( -aMtfOrigin.X(), -aMtfOrigin.Y() );
449 0 : double fScaleX = (double)aDstSize.Width() / (double)aTmpMtf.GetPrefSize().Width();
450 0 : double fScaleY = (double)aDstSize.Height() / (double)aTmpMtf.GetPrefSize().Height();
451 0 : if( fScaleX != 1.0 || fScaleY != 1.0 )
452 0 : aTmpMtf.Scale( fScaleX, fScaleY );
453 0 : aTmpMtf.SetPrefMapMode( aMapMode );
454 :
455 : // create paint bitmap
456 0 : aTmpMtf.WindStart();
457 0 : aTmpMtf.Play( xVDev.get(), aPoint, aDstSize );
458 0 : aTmpMtf.WindStart();
459 :
460 0 : xVDev->EnableMapMode( false );
461 0 : aPaint = xVDev->GetBitmap( aPoint, aDstSizePixel );
462 0 : xVDev->EnableMapMode( true );
463 :
464 : // create mask bitmap
465 0 : xVDev->SetLineColor( COL_BLACK );
466 0 : xVDev->SetFillColor( COL_BLACK );
467 0 : xVDev->DrawRect( Rectangle( aPoint, aDstSize ) );
468 0 : xVDev->SetDrawMode( DrawModeFlags::WhiteLine | DrawModeFlags::WhiteFill | DrawModeFlags::WhiteText |
469 0 : DrawModeFlags::WhiteBitmap | DrawModeFlags::WhiteGradient );
470 0 : aTmpMtf.WindStart();
471 0 : aTmpMtf.Play( xVDev.get(), aPoint, aDstSize );
472 0 : aTmpMtf.WindStart();
473 0 : xVDev->EnableMapMode( false );
474 0 : aMask = xVDev->GetBitmap( aPoint, aDstSizePixel );
475 0 : xVDev->EnableMapMode( true );
476 :
477 : // create alpha mask from gradient
478 0 : xVDev->SetDrawMode( DrawModeFlags::GrayGradient );
479 0 : xVDev->DrawGradient( Rectangle( aPoint, aDstSize ), rTransparenceGradient );
480 0 : xVDev->SetDrawMode( DrawModeFlags::Default );
481 0 : xVDev->EnableMapMode( false );
482 0 : xVDev->DrawMask( aPoint, aDstSizePixel, aMask, Color( COL_WHITE ) );
483 0 : aAlpha = xVDev->GetBitmap( aPoint, aDstSizePixel );
484 0 : implWriteBitmapEx( rPos, rSize, BitmapEx( aPaint, aAlpha ), pDummyVDev, i_rContext );
485 0 : }
486 : }
487 0 : }
488 : }
489 0 : break;
490 :
491 : case( MetaActionType::EPS ):
492 : {
493 0 : const MetaEPSAction* pA = static_cast<const MetaEPSAction*>(pAction);
494 0 : const GDIMetaFile aSubstitute( pA->GetSubstitute() );
495 :
496 0 : m_rOuterFace.Push();
497 0 : pDummyVDev->Push();
498 :
499 0 : MapMode aMapMode( aSubstitute.GetPrefMapMode() );
500 0 : Size aOutSize( OutputDevice::LogicToLogic( pA->GetSize(), pDummyVDev->GetMapMode(), aMapMode ) );
501 0 : aMapMode.SetScaleX( Fraction( aOutSize.Width(), aSubstitute.GetPrefSize().Width() ) );
502 0 : aMapMode.SetScaleY( Fraction( aOutSize.Height(), aSubstitute.GetPrefSize().Height() ) );
503 0 : aMapMode.SetOrigin( OutputDevice::LogicToLogic( pA->GetPoint(), pDummyVDev->GetMapMode(), aMapMode ) );
504 :
505 0 : m_rOuterFace.SetMapMode( aMapMode );
506 0 : pDummyVDev->SetMapMode( aMapMode );
507 0 : playMetafile( aSubstitute, NULL, i_rContext, pDummyVDev );
508 0 : pDummyVDev->Pop();
509 0 : m_rOuterFace.Pop();
510 : }
511 0 : break;
512 :
513 : case( MetaActionType::COMMENT ):
514 0 : if( ! i_rContext.m_bTransparenciesWereRemoved )
515 : {
516 0 : const MetaCommentAction* pA = static_cast<const MetaCommentAction*>(pAction);
517 :
518 0 : if( pA->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_BEGIN"))
519 : {
520 0 : const MetaGradientExAction* pGradAction = NULL;
521 0 : bool bDone = false;
522 :
523 0 : while( !bDone && ( ++i < nCount ) )
524 : {
525 0 : pAction = aMtf.GetAction( i );
526 :
527 0 : if( pAction->GetType() == MetaActionType::GRADIENTEX )
528 0 : pGradAction = static_cast<const MetaGradientExAction*>(pAction);
529 0 : else if( ( pAction->GetType() == MetaActionType::COMMENT ) &&
530 0 : ( static_cast<const MetaCommentAction*>(pAction)->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END")) )
531 : {
532 0 : bDone = true;
533 : }
534 : }
535 :
536 0 : if( pGradAction )
537 : {
538 0 : if (lcl_canUsePDFAxialShading(pGradAction->GetGradient()))
539 : {
540 0 : m_rOuterFace.DrawGradient( pGradAction->GetPolyPolygon(), pGradAction->GetGradient() );
541 : }
542 : else
543 : {
544 0 : implWriteGradient( pGradAction->GetPolyPolygon(), pGradAction->GetGradient(), pDummyVDev, i_rContext );
545 : }
546 : }
547 : }
548 : else
549 : {
550 0 : const sal_uInt8* pData = pA->GetData();
551 0 : if ( pData )
552 : {
553 0 : SvMemoryStream aMemStm( const_cast<sal_uInt8 *>(pData), pA->GetDataSize(), StreamMode::READ );
554 0 : bool bSkipSequence = false;
555 0 : OString sSeqEnd;
556 :
557 0 : if( pA->GetComment() == "XPATHSTROKE_SEQ_BEGIN" )
558 : {
559 0 : sSeqEnd = OString("XPATHSTROKE_SEQ_END");
560 0 : SvtGraphicStroke aStroke;
561 0 : ReadSvtGraphicStroke( aMemStm, aStroke );
562 :
563 0 : Polygon aPath;
564 0 : aStroke.getPath( aPath );
565 :
566 0 : tools::PolyPolygon aStartArrow;
567 0 : tools::PolyPolygon aEndArrow;
568 0 : double fTransparency( aStroke.getTransparency() );
569 0 : double fStrokeWidth( aStroke.getStrokeWidth() );
570 0 : SvtGraphicStroke::DashArray aDashArray;
571 :
572 0 : aStroke.getStartArrow( aStartArrow );
573 0 : aStroke.getEndArrow( aEndArrow );
574 0 : aStroke.getDashArray( aDashArray );
575 :
576 0 : bSkipSequence = true;
577 0 : if ( aStartArrow.Count() || aEndArrow.Count() )
578 0 : bSkipSequence = false;
579 0 : if ( aDashArray.size() && ( fStrokeWidth != 0.0 ) && ( fTransparency == 0.0 ) )
580 0 : bSkipSequence = false;
581 0 : if ( bSkipSequence )
582 : {
583 0 : PDFWriter::ExtLineInfo aInfo;
584 0 : aInfo.m_fLineWidth = fStrokeWidth;
585 0 : aInfo.m_fTransparency = fTransparency;
586 0 : aInfo.m_fMiterLimit = aStroke.getMiterLimit();
587 0 : switch( aStroke.getCapType() )
588 : {
589 : default:
590 0 : case SvtGraphicStroke::capButt: aInfo.m_eCap = PDFWriter::capButt;break;
591 0 : case SvtGraphicStroke::capRound: aInfo.m_eCap = PDFWriter::capRound;break;
592 0 : case SvtGraphicStroke::capSquare: aInfo.m_eCap = PDFWriter::capSquare;break;
593 : }
594 0 : switch( aStroke.getJoinType() )
595 : {
596 : default:
597 0 : case SvtGraphicStroke::joinMiter: aInfo.m_eJoin = PDFWriter::joinMiter;break;
598 0 : case SvtGraphicStroke::joinRound: aInfo.m_eJoin = PDFWriter::joinRound;break;
599 0 : case SvtGraphicStroke::joinBevel: aInfo.m_eJoin = PDFWriter::joinBevel;break;
600 : case SvtGraphicStroke::joinNone:
601 0 : aInfo.m_eJoin = PDFWriter::joinMiter;
602 0 : aInfo.m_fMiterLimit = 0.0;
603 0 : break;
604 : }
605 0 : aInfo.m_aDashArray = aDashArray;
606 :
607 0 : if(SvtGraphicStroke::joinNone == aStroke.getJoinType()
608 0 : && fStrokeWidth > 0.0)
609 : {
610 : // emulate no edge rounding by handling single edges
611 0 : const sal_uInt16 nPoints(aPath.GetSize());
612 0 : const bool bCurve(aPath.HasFlags());
613 :
614 0 : for(sal_uInt16 a(0); a + 1 < nPoints; a++)
615 : {
616 0 : if(bCurve
617 0 : && POLY_NORMAL != aPath.GetFlags(a + 1)
618 0 : && a + 2 < nPoints
619 0 : && POLY_NORMAL != aPath.GetFlags(a + 2)
620 0 : && a + 3 < nPoints)
621 : {
622 : const Polygon aSnippet(4,
623 0 : aPath.GetConstPointAry() + a,
624 0 : aPath.GetConstFlagAry() + a);
625 0 : m_rOuterFace.DrawPolyLine( aSnippet, aInfo );
626 0 : a += 2;
627 : }
628 : else
629 : {
630 : const Polygon aSnippet(2,
631 0 : aPath.GetConstPointAry() + a);
632 0 : m_rOuterFace.DrawPolyLine( aSnippet, aInfo );
633 : }
634 : }
635 : }
636 : else
637 : {
638 0 : m_rOuterFace.DrawPolyLine( aPath, aInfo );
639 0 : }
640 0 : }
641 : }
642 0 : else if ( pA->GetComment() == "XPATHFILL_SEQ_BEGIN" )
643 : {
644 0 : sSeqEnd = OString("XPATHFILL_SEQ_END");
645 0 : SvtGraphicFill aFill;
646 0 : ReadSvtGraphicFill( aMemStm, aFill );
647 :
648 0 : if ( ( aFill.getFillType() == SvtGraphicFill::fillSolid ) && ( aFill.getFillRule() == SvtGraphicFill::fillEvenOdd ) )
649 : {
650 0 : double fTransparency = aFill.getTransparency();
651 0 : if ( fTransparency == 0.0 )
652 : {
653 0 : tools::PolyPolygon aPath;
654 0 : aFill.getPath( aPath );
655 :
656 0 : bSkipSequence = true;
657 0 : m_rOuterFace.DrawPolyPolygon( aPath );
658 : }
659 0 : else if ( fTransparency == 1.0 )
660 0 : bSkipSequence = true;
661 0 : }
662 : /* #i81548# removing optimization for fill textures, because most of the texture settings are not
663 : exported properly. In OpenOffice 3.1 the drawing layer will support graphic primitives, then it
664 : will not be a problem to optimize the filltexture export. But for wysiwyg is more important than
665 : filesize.
666 : else if( aFill.getFillType() == SvtGraphicFill::fillTexture && aFill.isTiling() )
667 : {
668 : sal_Int32 nPattern = mnCachePatternId;
669 : Graphic aPatternGraphic;
670 : aFill.getGraphic( aPatternGraphic );
671 : bool bUseCache = false;
672 : SvtGraphicFill::Transform aPatTransform;
673 : aFill.getTransform( aPatTransform );
674 :
675 : if( mnCachePatternId >= 0 )
676 : {
677 : SvtGraphicFill::Transform aCacheTransform;
678 : maCacheFill.getTransform( aCacheTransform );
679 : if( aCacheTransform.matrix[0] == aPatTransform.matrix[0] &&
680 : aCacheTransform.matrix[1] == aPatTransform.matrix[1] &&
681 : aCacheTransform.matrix[2] == aPatTransform.matrix[2] &&
682 : aCacheTransform.matrix[3] == aPatTransform.matrix[3] &&
683 : aCacheTransform.matrix[4] == aPatTransform.matrix[4] &&
684 : aCacheTransform.matrix[5] == aPatTransform.matrix[5]
685 : )
686 : {
687 : Graphic aCacheGraphic;
688 : maCacheFill.getGraphic( aCacheGraphic );
689 : if( aCacheGraphic == aPatternGraphic )
690 : bUseCache = true;
691 : }
692 : }
693 :
694 : if( ! bUseCache )
695 : {
696 :
697 : // paint graphic to metafile
698 : GDIMetaFile aPattern;
699 : pDummyVDev->SetConnectMetaFile( &aPattern );
700 : pDummyVDev->Push();
701 : pDummyVDev->SetMapMode( aPatternGraphic.GetPrefMapMode() );
702 :
703 : aPatternGraphic.Draw( &rDummyVDev, Point( 0, 0 ) );
704 : pDummyVDev->Pop();
705 : pDummyVDev->SetConnectMetaFile( NULL );
706 : aPattern.WindStart();
707 :
708 : MapMode aPatternMapMode( aPatternGraphic.GetPrefMapMode() );
709 : // prepare pattern from metafile
710 : Size aPrefSize( aPatternGraphic.GetPrefSize() );
711 : // FIXME: this magic -1 shouldn't be necessary
712 : aPrefSize.Width() -= 1;
713 : aPrefSize.Height() -= 1;
714 : aPrefSize = m_rOuterFace.GetReferenceDevice()->
715 : LogicToLogic( aPrefSize,
716 : &aPatternMapMode,
717 : &m_rOuterFace.GetReferenceDevice()->GetMapMode() );
718 : // build bounding rectangle of pattern
719 : Rectangle aBound( Point( 0, 0 ), aPrefSize );
720 : m_rOuterFace.BeginPattern( aBound );
721 : m_rOuterFace.Push();
722 : pDummyVDev->Push();
723 : m_rOuterFace.SetMapMode( aPatternMapMode );
724 : pDummyVDev->SetMapMode( aPatternMapMode );
725 : ImplWriteActions( m_rOuterFace, NULL, aPattern, rDummyVDev );
726 : pDummyVDev->Pop();
727 : m_rOuterFace.Pop();
728 :
729 : nPattern = m_rOuterFace.EndPattern( aPatTransform );
730 :
731 : // try some caching and reuse pattern
732 : mnCachePatternId = nPattern;
733 : maCacheFill = aFill;
734 : }
735 :
736 : // draw polypolygon with pattern fill
737 : tools::PolyPolygon aPath;
738 : aFill.getPath( aPath );
739 : m_rOuterFace.DrawPolyPolygon( aPath, nPattern, aFill.getFillRule() == SvtGraphicFill::fillEvenOdd );
740 :
741 : bSkipSequence = true;
742 : }
743 : */
744 : }
745 0 : if ( bSkipSequence )
746 : {
747 0 : while( ++i < nCount )
748 : {
749 0 : pAction = aMtf.GetAction( i );
750 0 : if ( pAction->GetType() == MetaActionType::COMMENT )
751 : {
752 0 : OString sComment( static_cast<const MetaCommentAction*>(pAction)->GetComment() );
753 0 : if (sComment == sSeqEnd)
754 0 : break;
755 : }
756 : // #i44496#
757 : // the replacement action for stroke is a filled rectangle
758 : // the set fillcolor of the replacement is part of the graphics
759 : // state and must not be skipped
760 0 : else if( pAction->GetType() == MetaActionType::FILLCOLOR )
761 : {
762 0 : const MetaFillColorAction* pMA = static_cast<const MetaFillColorAction*>(pAction);
763 0 : if( pMA->IsSetting() )
764 0 : m_rOuterFace.SetFillColor( pMA->GetColor() );
765 : else
766 0 : m_rOuterFace.SetFillColor();
767 : }
768 : }
769 0 : }
770 : }
771 : }
772 : }
773 0 : break;
774 :
775 : case( MetaActionType::BMP ):
776 : {
777 0 : const MetaBmpAction* pA = static_cast<const MetaBmpAction*>(pAction);
778 0 : BitmapEx aBitmapEx( pA->GetBitmap() );
779 0 : Size aSize( OutputDevice::LogicToLogic( aBitmapEx.GetPrefSize(),
780 0 : aBitmapEx.GetPrefMapMode(), pDummyVDev->GetMapMode() ) );
781 0 : if( ! ( aSize.Width() && aSize.Height() ) )
782 0 : aSize = pDummyVDev->PixelToLogic( aBitmapEx.GetSizePixel() );
783 0 : implWriteBitmapEx( pA->GetPoint(), aSize, aBitmapEx, pDummyVDev, i_rContext );
784 : }
785 0 : break;
786 :
787 : case( MetaActionType::BMPSCALE ):
788 : {
789 0 : const MetaBmpScaleAction* pA = static_cast<const MetaBmpScaleAction*>(pAction);
790 0 : implWriteBitmapEx( pA->GetPoint(), pA->GetSize(), BitmapEx( pA->GetBitmap() ), pDummyVDev, i_rContext );
791 : }
792 0 : break;
793 :
794 : case( MetaActionType::BMPSCALEPART ):
795 : {
796 0 : const MetaBmpScalePartAction* pA = static_cast<const MetaBmpScalePartAction*>(pAction);
797 0 : BitmapEx aBitmapEx( pA->GetBitmap() );
798 0 : aBitmapEx.Crop( Rectangle( pA->GetSrcPoint(), pA->GetSrcSize() ) );
799 0 : implWriteBitmapEx( pA->GetDestPoint(), pA->GetDestSize(), aBitmapEx, pDummyVDev, i_rContext );
800 : }
801 0 : break;
802 :
803 : case( MetaActionType::BMPEX ):
804 : {
805 0 : const MetaBmpExAction* pA = static_cast<const MetaBmpExAction*>(pAction);
806 0 : BitmapEx aBitmapEx( pA->GetBitmapEx() );
807 0 : Size aSize( OutputDevice::LogicToLogic( aBitmapEx.GetPrefSize(),
808 0 : aBitmapEx.GetPrefMapMode(), pDummyVDev->GetMapMode() ) );
809 0 : implWriteBitmapEx( pA->GetPoint(), aSize, aBitmapEx, pDummyVDev, i_rContext );
810 : }
811 0 : break;
812 :
813 : case( MetaActionType::BMPEXSCALE ):
814 : {
815 0 : const MetaBmpExScaleAction* pA = static_cast<const MetaBmpExScaleAction*>(pAction);
816 0 : implWriteBitmapEx( pA->GetPoint(), pA->GetSize(), pA->GetBitmapEx(), pDummyVDev, i_rContext );
817 : }
818 0 : break;
819 :
820 : case( MetaActionType::BMPEXSCALEPART ):
821 : {
822 0 : const MetaBmpExScalePartAction* pA = static_cast<const MetaBmpExScalePartAction*>(pAction);
823 0 : BitmapEx aBitmapEx( pA->GetBitmapEx() );
824 0 : aBitmapEx.Crop( Rectangle( pA->GetSrcPoint(), pA->GetSrcSize() ) );
825 0 : implWriteBitmapEx( pA->GetDestPoint(), pA->GetDestSize(), aBitmapEx, pDummyVDev, i_rContext );
826 : }
827 0 : break;
828 :
829 : case( MetaActionType::MASK ):
830 : case( MetaActionType::MASKSCALE ):
831 : case( MetaActionType::MASKSCALEPART ):
832 : {
833 : OSL_TRACE( "MetaMask...Action not supported yet" );
834 : }
835 0 : break;
836 :
837 : case( MetaActionType::TEXT ):
838 : {
839 0 : const MetaTextAction* pA = static_cast<const MetaTextAction*>(pAction);
840 0 : m_rOuterFace.DrawText( pA->GetPoint(), pA->GetText().copy( pA->GetIndex(), std::min<sal_Int32>(pA->GetText().getLength() - pA->GetIndex(), pA->GetLen()) ) );
841 : }
842 0 : break;
843 :
844 : case( MetaActionType::TEXTRECT ):
845 : {
846 0 : const MetaTextRectAction* pA = static_cast<const MetaTextRectAction*>(pAction);
847 0 : m_rOuterFace.DrawText( pA->GetRect(), pA->GetText(), pA->GetStyle() );
848 : }
849 0 : break;
850 :
851 : case( MetaActionType::TEXTARRAY ):
852 : {
853 0 : const MetaTextArrayAction* pA = static_cast<const MetaTextArrayAction*>(pAction);
854 0 : m_rOuterFace.DrawTextArray( pA->GetPoint(), pA->GetText(), pA->GetDXArray(), pA->GetIndex(), pA->GetLen() );
855 : }
856 0 : break;
857 :
858 : case( MetaActionType::STRETCHTEXT ):
859 : {
860 0 : const MetaStretchTextAction* pA = static_cast<const MetaStretchTextAction*>(pAction);
861 0 : m_rOuterFace.DrawStretchText( pA->GetPoint(), pA->GetWidth(), pA->GetText(), pA->GetIndex(), pA->GetLen() );
862 : }
863 0 : break;
864 :
865 : case( MetaActionType::TEXTLINE ):
866 : {
867 0 : const MetaTextLineAction* pA = static_cast<const MetaTextLineAction*>(pAction);
868 0 : m_rOuterFace.DrawTextLine( pA->GetStartPoint(), pA->GetWidth(), pA->GetStrikeout(), pA->GetUnderline(), pA->GetOverline() );
869 :
870 : }
871 0 : break;
872 :
873 : case( MetaActionType::CLIPREGION ):
874 : {
875 0 : const MetaClipRegionAction* pA = static_cast<const MetaClipRegionAction*>(pAction);
876 :
877 0 : if( pA->IsClipping() )
878 : {
879 0 : if( pA->GetRegion().IsEmpty() )
880 0 : m_rOuterFace.SetClipRegion( basegfx::B2DPolyPolygon() );
881 : else
882 : {
883 0 : vcl::Region aReg( pA->GetRegion() );
884 0 : m_rOuterFace.SetClipRegion( aReg.GetAsB2DPolyPolygon() );
885 : }
886 : }
887 : else
888 0 : m_rOuterFace.SetClipRegion();
889 : }
890 0 : break;
891 :
892 : case( MetaActionType::ISECTRECTCLIPREGION ):
893 : {
894 0 : const MetaISectRectClipRegionAction* pA = static_cast<const MetaISectRectClipRegionAction*>(pAction);
895 0 : m_rOuterFace.IntersectClipRegion( pA->GetRect() );
896 : }
897 0 : break;
898 :
899 : case( MetaActionType::ISECTREGIONCLIPREGION ):
900 : {
901 0 : const MetaISectRegionClipRegionAction* pA = static_cast<const MetaISectRegionClipRegionAction*>(pAction);
902 0 : vcl::Region aReg( pA->GetRegion() );
903 0 : m_rOuterFace.IntersectClipRegion( aReg.GetAsB2DPolyPolygon() );
904 : }
905 0 : break;
906 :
907 : case( MetaActionType::MOVECLIPREGION ):
908 : {
909 0 : const MetaMoveClipRegionAction* pA = static_cast<const MetaMoveClipRegionAction*>(pAction);
910 0 : m_rOuterFace.MoveClipRegion( pA->GetHorzMove(), pA->GetVertMove() );
911 : }
912 0 : break;
913 :
914 : case( MetaActionType::MAPMODE ):
915 : {
916 0 : const_cast< MetaAction* >( pAction )->Execute( pDummyVDev );
917 0 : m_rOuterFace.SetMapMode( pDummyVDev->GetMapMode() );
918 : }
919 0 : break;
920 :
921 : case( MetaActionType::LINECOLOR ):
922 : {
923 0 : const MetaLineColorAction* pA = static_cast<const MetaLineColorAction*>(pAction);
924 :
925 0 : if( pA->IsSetting() )
926 0 : m_rOuterFace.SetLineColor( pA->GetColor() );
927 : else
928 0 : m_rOuterFace.SetLineColor();
929 : }
930 0 : break;
931 :
932 : case( MetaActionType::FILLCOLOR ):
933 : {
934 0 : const MetaFillColorAction* pA = static_cast<const MetaFillColorAction*>(pAction);
935 :
936 0 : if( pA->IsSetting() )
937 0 : m_rOuterFace.SetFillColor( pA->GetColor() );
938 : else
939 0 : m_rOuterFace.SetFillColor();
940 : }
941 0 : break;
942 :
943 : case( MetaActionType::TEXTLINECOLOR ):
944 : {
945 0 : const MetaTextLineColorAction* pA = static_cast<const MetaTextLineColorAction*>(pAction);
946 :
947 0 : if( pA->IsSetting() )
948 0 : m_rOuterFace.SetTextLineColor( pA->GetColor() );
949 : else
950 0 : m_rOuterFace.SetTextLineColor();
951 : }
952 0 : break;
953 :
954 : case( MetaActionType::OVERLINECOLOR ):
955 : {
956 0 : const MetaOverlineColorAction* pA = static_cast<const MetaOverlineColorAction*>(pAction);
957 :
958 0 : if( pA->IsSetting() )
959 0 : m_rOuterFace.SetOverlineColor( pA->GetColor() );
960 : else
961 0 : m_rOuterFace.SetOverlineColor();
962 : }
963 0 : break;
964 :
965 : case( MetaActionType::TEXTFILLCOLOR ):
966 : {
967 0 : const MetaTextFillColorAction* pA = static_cast<const MetaTextFillColorAction*>(pAction);
968 :
969 0 : if( pA->IsSetting() )
970 0 : m_rOuterFace.SetTextFillColor( pA->GetColor() );
971 : else
972 0 : m_rOuterFace.SetTextFillColor();
973 : }
974 0 : break;
975 :
976 : case( MetaActionType::TEXTCOLOR ):
977 : {
978 0 : const MetaTextColorAction* pA = static_cast<const MetaTextColorAction*>(pAction);
979 0 : m_rOuterFace.SetTextColor( pA->GetColor() );
980 : }
981 0 : break;
982 :
983 : case( MetaActionType::TEXTALIGN ):
984 : {
985 0 : const MetaTextAlignAction* pA = static_cast<const MetaTextAlignAction*>(pAction);
986 0 : m_rOuterFace.SetTextAlign( pA->GetTextAlign() );
987 : }
988 0 : break;
989 :
990 : case( MetaActionType::FONT ):
991 : {
992 0 : const MetaFontAction* pA = static_cast<const MetaFontAction*>(pAction);
993 0 : m_rOuterFace.SetFont( pA->GetFont() );
994 : }
995 0 : break;
996 :
997 : case( MetaActionType::PUSH ):
998 : {
999 0 : const MetaPushAction* pA = static_cast<const MetaPushAction*>(pAction);
1000 :
1001 0 : pDummyVDev->Push( pA->GetFlags() );
1002 0 : m_rOuterFace.Push( pA->GetFlags() );
1003 : }
1004 0 : break;
1005 :
1006 : case( MetaActionType::POP ):
1007 : {
1008 0 : pDummyVDev->Pop();
1009 0 : m_rOuterFace.Pop();
1010 : }
1011 0 : break;
1012 :
1013 : case( MetaActionType::LAYOUTMODE ):
1014 : {
1015 0 : const MetaLayoutModeAction* pA = static_cast<const MetaLayoutModeAction*>(pAction);
1016 0 : m_rOuterFace.SetLayoutMode( pA->GetLayoutMode() );
1017 : }
1018 0 : break;
1019 :
1020 : case MetaActionType::TEXTLANGUAGE:
1021 : {
1022 0 : const MetaTextLanguageAction* pA = static_cast<const MetaTextLanguageAction*>(pAction);
1023 0 : m_rOuterFace.SetDigitLanguage( pA->GetTextLanguage() );
1024 : }
1025 0 : break;
1026 :
1027 : case( MetaActionType::WALLPAPER ):
1028 : {
1029 0 : const MetaWallpaperAction* pA = static_cast<const MetaWallpaperAction*>(pAction);
1030 0 : m_rOuterFace.DrawWallpaper( pA->GetRect(), pA->GetWallpaper() );
1031 : }
1032 0 : break;
1033 :
1034 : case( MetaActionType::RASTEROP ):
1035 : {
1036 : // !!! >>> we don't want to support this actions
1037 : }
1038 0 : break;
1039 :
1040 : case( MetaActionType::REFPOINT ):
1041 : {
1042 : // !!! >>> we don't want to support this actions
1043 : }
1044 0 : break;
1045 :
1046 : default:
1047 : // #i24604# Made assertion fire only once per
1048 : // metafile. The asserted actions here are all
1049 : // deprecated
1050 0 : if( !bAssertionFired )
1051 : {
1052 0 : bAssertionFired = true;
1053 : OSL_TRACE( "PDFExport::ImplWriteActions: deprecated and unsupported MetaAction encountered" );
1054 : }
1055 0 : break;
1056 : }
1057 0 : i++;
1058 : }
1059 0 : }
1060 0 : }
1061 :
1062 : // Encryption methods
1063 :
1064 : /* a crutch to transport an rtlDigest safely though UNO API
1065 : this is needed for the PDF export dialog, which otherwise would have to pass
1066 : clear text passwords down till they can be used in PDFWriter. Unfortunately
1067 : the MD5 sum of the password (which is needed to create the PDF encryption key)
1068 : is not sufficient, since an rtl MD5 digest cannot be created in an arbitrary state
1069 : which would be needed in PDFWriterImpl::computeEncryptionKey.
1070 : */
1071 : class EncHashTransporter : public cppu::WeakImplHelper1 < com::sun::star::beans::XMaterialHolder >
1072 : {
1073 : rtlDigest maUDigest;
1074 : sal_IntPtr maID;
1075 : std::vector< sal_uInt8 > maOValue;
1076 :
1077 : static std::map< sal_IntPtr, EncHashTransporter* > sTransporters;
1078 : public:
1079 0 : EncHashTransporter()
1080 0 : : maUDigest( rtl_digest_createMD5() )
1081 : {
1082 0 : maID = reinterpret_cast< sal_IntPtr >(this);
1083 0 : while( sTransporters.find( maID ) != sTransporters.end() ) // paranoia mode
1084 0 : maID++;
1085 0 : sTransporters[ maID ] = this;
1086 0 : }
1087 :
1088 0 : virtual ~EncHashTransporter()
1089 0 : {
1090 0 : sTransporters.erase( maID );
1091 0 : if( maUDigest )
1092 0 : rtl_digest_destroyMD5( maUDigest );
1093 : OSL_TRACE( "EncHashTransporter freed" );
1094 0 : }
1095 :
1096 0 : rtlDigest getUDigest() const { return maUDigest; };
1097 0 : std::vector< sal_uInt8 >& getOValue() { return maOValue; }
1098 0 : void invalidate()
1099 : {
1100 0 : if( maUDigest )
1101 : {
1102 0 : rtl_digest_destroyMD5( maUDigest );
1103 0 : maUDigest = NULL;
1104 : }
1105 0 : }
1106 :
1107 : // XMaterialHolder
1108 0 : virtual uno::Any SAL_CALL getMaterial() throw(std::exception) SAL_OVERRIDE
1109 : {
1110 0 : return uno::makeAny( sal_Int64(maID) );
1111 : }
1112 :
1113 : static EncHashTransporter* getEncHashTransporter( const uno::Reference< beans::XMaterialHolder >& );
1114 :
1115 : };
1116 :
1117 267 : std::map< sal_IntPtr, EncHashTransporter* > EncHashTransporter::sTransporters;
1118 :
1119 0 : EncHashTransporter* EncHashTransporter::getEncHashTransporter( const uno::Reference< beans::XMaterialHolder >& xRef )
1120 : {
1121 0 : EncHashTransporter* pResult = NULL;
1122 0 : if( xRef.is() )
1123 : {
1124 0 : uno::Any aMat( xRef->getMaterial() );
1125 0 : sal_Int64 nMat = 0;
1126 0 : if( aMat >>= nMat )
1127 : {
1128 0 : std::map< sal_IntPtr, EncHashTransporter* >::iterator it = sTransporters.find( static_cast<sal_IntPtr>(nMat) );
1129 0 : if( it != sTransporters.end() )
1130 0 : pResult = it->second;
1131 0 : }
1132 : }
1133 0 : return pResult;
1134 : }
1135 :
1136 0 : bool PDFWriterImpl::checkEncryptionBufferSize( register sal_Int32 newSize )
1137 : {
1138 0 : if( m_nEncryptionBufferSize < newSize )
1139 : {
1140 : /* reallocate the buffer, the used function allocate as rtl_allocateMemory
1141 : if the pointer parameter is NULL */
1142 0 : m_pEncryptionBuffer = static_cast<sal_uInt8*>(rtl_reallocateMemory( m_pEncryptionBuffer, newSize ));
1143 0 : if( m_pEncryptionBuffer )
1144 0 : m_nEncryptionBufferSize = newSize;
1145 : else
1146 0 : m_nEncryptionBufferSize = 0;
1147 : }
1148 0 : return ( m_nEncryptionBufferSize != 0 );
1149 : }
1150 :
1151 0 : void PDFWriterImpl::checkAndEnableStreamEncryption( register sal_Int32 nObject )
1152 : {
1153 0 : if( m_aContext.Encryption.Encrypt() )
1154 : {
1155 0 : m_bEncryptThisStream = true;
1156 0 : sal_Int32 i = m_nKeyLength;
1157 0 : m_aContext.Encryption.EncryptionKey[i++] = (sal_uInt8)nObject;
1158 0 : m_aContext.Encryption.EncryptionKey[i++] = (sal_uInt8)( nObject >> 8 );
1159 0 : m_aContext.Encryption.EncryptionKey[i++] = (sal_uInt8)( nObject >> 16 );
1160 : // the other location of m_nEncryptionKey is already set to 0, our fixed generation number
1161 : // do the MD5 hash
1162 : sal_uInt8 nMD5Sum[ RTL_DIGEST_LENGTH_MD5 ];
1163 : // the i+2 to take into account the generation number, always zero
1164 0 : rtl_digest_MD5( &m_aContext.Encryption.EncryptionKey[0], i+2, nMD5Sum, sizeof(nMD5Sum) );
1165 : // initialize the RC4 with the key
1166 : // key length: see algorithm 3.1, step 4: (N+5) max 16
1167 0 : rtl_cipher_initARCFOUR( m_aCipher, rtl_Cipher_DirectionEncode, nMD5Sum, m_nRC4KeyLength, NULL, 0 );
1168 : }
1169 0 : }
1170 :
1171 0 : void PDFWriterImpl::enableStringEncryption( register sal_Int32 nObject )
1172 : {
1173 0 : if( m_aContext.Encryption.Encrypt() )
1174 : {
1175 0 : sal_Int32 i = m_nKeyLength;
1176 0 : m_aContext.Encryption.EncryptionKey[i++] = (sal_uInt8)nObject;
1177 0 : m_aContext.Encryption.EncryptionKey[i++] = (sal_uInt8)( nObject >> 8 );
1178 0 : m_aContext.Encryption.EncryptionKey[i++] = (sal_uInt8)( nObject >> 16 );
1179 : // the other location of m_nEncryptionKey is already set to 0, our fixed generation number
1180 : // do the MD5 hash
1181 : sal_uInt8 nMD5Sum[ RTL_DIGEST_LENGTH_MD5 ];
1182 : // the i+2 to take into account the generation number, always zero
1183 0 : rtl_digest_MD5( &m_aContext.Encryption.EncryptionKey[0], i+2, nMD5Sum, sizeof(nMD5Sum) );
1184 : // initialize the RC4 with the key
1185 : // key length: see algorithm 3.1, step 4: (N+5) max 16
1186 0 : rtl_cipher_initARCFOUR( m_aCipher, rtl_Cipher_DirectionEncode, nMD5Sum, m_nRC4KeyLength, NULL, 0 );
1187 : }
1188 0 : }
1189 :
1190 : /* init the encryption engine
1191 : 1. init the document id, used both for building the document id and for building the encryption key(s)
1192 : 2. build the encryption key following algorithms described in the PDF specification
1193 : */
1194 0 : uno::Reference< beans::XMaterialHolder > PDFWriterImpl::initEncryption( const OUString& i_rOwnerPassword,
1195 : const OUString& i_rUserPassword,
1196 : bool b128Bit
1197 : )
1198 : {
1199 0 : uno::Reference< beans::XMaterialHolder > xResult;
1200 0 : if( !i_rOwnerPassword.isEmpty() || !i_rUserPassword.isEmpty() )
1201 : {
1202 0 : EncHashTransporter* pTransporter = new EncHashTransporter;
1203 0 : xResult = pTransporter;
1204 :
1205 : // get padded passwords
1206 : sal_uInt8 aPadUPW[ENCRYPTED_PWD_SIZE], aPadOPW[ENCRYPTED_PWD_SIZE];
1207 0 : padPassword( i_rOwnerPassword.isEmpty() ? i_rUserPassword : i_rOwnerPassword, aPadOPW );
1208 0 : padPassword( i_rUserPassword, aPadUPW );
1209 0 : sal_Int32 nKeyLength = SECUR_40BIT_KEY;
1210 0 : if( b128Bit )
1211 0 : nKeyLength = SECUR_128BIT_KEY;
1212 :
1213 0 : if( computeODictionaryValue( aPadOPW, aPadUPW, pTransporter->getOValue(), nKeyLength ) )
1214 : {
1215 0 : rtlDigest aDig = pTransporter->getUDigest();
1216 0 : if( rtl_digest_updateMD5( aDig, aPadUPW, ENCRYPTED_PWD_SIZE ) != rtl_Digest_E_None )
1217 0 : xResult.clear();
1218 : }
1219 : else
1220 0 : xResult.clear();
1221 :
1222 : // trash temporary padded cleartext PWDs
1223 0 : rtl_secureZeroMemory (aPadOPW, sizeof(aPadOPW));
1224 0 : rtl_secureZeroMemory (aPadUPW, sizeof(aPadUPW));
1225 : }
1226 0 : return xResult;
1227 : }
1228 :
1229 0 : bool PDFWriterImpl::prepareEncryption( const uno::Reference< beans::XMaterialHolder >& xEnc )
1230 : {
1231 0 : bool bSuccess = false;
1232 0 : EncHashTransporter* pTransporter = EncHashTransporter::getEncHashTransporter( xEnc );
1233 0 : if( pTransporter )
1234 : {
1235 0 : sal_Int32 nKeyLength = 0, nRC4KeyLength = 0;
1236 0 : sal_Int32 nAccessPermissions = computeAccessPermissions( m_aContext.Encryption, nKeyLength, nRC4KeyLength );
1237 0 : m_aContext.Encryption.OValue = pTransporter->getOValue();
1238 0 : bSuccess = computeUDictionaryValue( pTransporter, m_aContext.Encryption, nKeyLength, nAccessPermissions );
1239 : }
1240 0 : if( ! bSuccess )
1241 : {
1242 0 : m_aContext.Encryption.OValue.clear();
1243 0 : m_aContext.Encryption.UValue.clear();
1244 0 : m_aContext.Encryption.EncryptionKey.clear();
1245 : }
1246 0 : return bSuccess;
1247 : }
1248 :
1249 0 : sal_Int32 PDFWriterImpl::computeAccessPermissions( const vcl::PDFWriter::PDFEncryptionProperties& i_rProperties,
1250 : sal_Int32& o_rKeyLength, sal_Int32& o_rRC4KeyLength )
1251 : {
1252 : /*
1253 : 2) compute the access permissions, in numerical form
1254 :
1255 : the default value depends on the revision 2 (40 bit) or 3 (128 bit security):
1256 : - for 40 bit security the unused bit must be set to 1, since they are not used
1257 : - for 128 bit security the same bit must be preset to 0 and set later if needed
1258 : according to the table 3.15, pdf v 1.4 */
1259 0 : sal_Int32 nAccessPermissions = ( i_rProperties.Security128bit ) ? 0xfffff0c0 : 0xffffffc0 ;
1260 :
1261 : /* check permissions for 40 bit security case */
1262 0 : nAccessPermissions |= ( i_rProperties.CanPrintTheDocument ) ? 1 << 2 : 0;
1263 0 : nAccessPermissions |= ( i_rProperties.CanModifyTheContent ) ? 1 << 3 : 0;
1264 0 : nAccessPermissions |= ( i_rProperties.CanCopyOrExtract ) ? 1 << 4 : 0;
1265 0 : nAccessPermissions |= ( i_rProperties.CanAddOrModify ) ? 1 << 5 : 0;
1266 0 : o_rKeyLength = SECUR_40BIT_KEY;
1267 0 : o_rRC4KeyLength = SECUR_40BIT_KEY+5; // for this value see PDF spec v 1.4, algorithm 3.1 step 4, where n is 5
1268 :
1269 0 : if( i_rProperties.Security128bit )
1270 : {
1271 0 : o_rKeyLength = SECUR_128BIT_KEY;
1272 0 : o_rRC4KeyLength = 16; // for this value see PDF spec v 1.4, algorithm 3.1 step 4, where n is 16, thus maximum
1273 : // permitted value is 16
1274 0 : nAccessPermissions |= ( i_rProperties.CanFillInteractive ) ? 1 << 8 : 0;
1275 0 : nAccessPermissions |= ( i_rProperties.CanExtractForAccessibility ) ? 1 << 9 : 0;
1276 0 : nAccessPermissions |= ( i_rProperties.CanAssemble ) ? 1 << 10 : 0;
1277 0 : nAccessPermissions |= ( i_rProperties.CanPrintFull ) ? 1 << 11 : 0;
1278 : }
1279 0 : return nAccessPermissions;
1280 : }
1281 :
1282 : /*************************************************************
1283 : begin i12626 methods
1284 :
1285 : Implements Algorithm 3.2, step 1 only
1286 : */
1287 0 : void PDFWriterImpl::padPassword( const OUString& i_rPassword, sal_uInt8* o_pPaddedPW )
1288 : {
1289 : // get ansi-1252 version of the password string CHECKIT ! i12626
1290 0 : OString aString( OUStringToOString( i_rPassword, RTL_TEXTENCODING_MS_1252 ) );
1291 :
1292 : //copy the string to the target
1293 0 : sal_Int32 nToCopy = ( aString.getLength() < ENCRYPTED_PWD_SIZE ) ? aString.getLength() : ENCRYPTED_PWD_SIZE;
1294 : sal_Int32 nCurrentChar;
1295 :
1296 0 : for( nCurrentChar = 0; nCurrentChar < nToCopy; nCurrentChar++ )
1297 0 : o_pPaddedPW[nCurrentChar] = (sal_uInt8)( aString[nCurrentChar] );
1298 :
1299 : //pad it with standard byte string
1300 : sal_Int32 i,y;
1301 0 : for( i = nCurrentChar, y = 0 ; i < ENCRYPTED_PWD_SIZE; i++, y++ )
1302 0 : o_pPaddedPW[i] = s_nPadString[y];
1303 0 : }
1304 :
1305 : /**********************************
1306 : Algorithm 3.2 Compute the encryption key used
1307 :
1308 : step 1 should already be done before calling, the paThePaddedPassword parameter should contain
1309 : the padded password and must be 32 byte long, the encryption key is returned into the paEncryptionKey parameter,
1310 : it will be 16 byte long for 128 bit security; for 40 bit security only the first 5 bytes are used
1311 :
1312 : TODO: in pdf ver 1.5 and 1.6 the step 6 is different, should be implemented. See spec.
1313 :
1314 : */
1315 0 : bool PDFWriterImpl::computeEncryptionKey( EncHashTransporter* i_pTransporter, vcl::PDFWriter::PDFEncryptionProperties& io_rProperties, sal_Int32 i_nAccessPermissions )
1316 : {
1317 0 : bool bSuccess = true;
1318 : sal_uInt8 nMD5Sum[ RTL_DIGEST_LENGTH_MD5 ];
1319 :
1320 : // transporter contains an MD5 digest with the padded user password already
1321 0 : rtlDigest aDigest = i_pTransporter->getUDigest();
1322 0 : rtlDigestError nError = rtl_Digest_E_None;
1323 0 : if( aDigest )
1324 : {
1325 : //step 3
1326 0 : if( ! io_rProperties.OValue.empty() )
1327 0 : nError = rtl_digest_updateMD5( aDigest, &io_rProperties.OValue[0] , sal_Int32(io_rProperties.OValue.size()) );
1328 : else
1329 0 : bSuccess = false;
1330 : //Step 4
1331 : sal_uInt8 nPerm[4];
1332 :
1333 0 : nPerm[0] = (sal_uInt8)i_nAccessPermissions;
1334 0 : nPerm[1] = (sal_uInt8)( i_nAccessPermissions >> 8 );
1335 0 : nPerm[2] = (sal_uInt8)( i_nAccessPermissions >> 16 );
1336 0 : nPerm[3] = (sal_uInt8)( i_nAccessPermissions >> 24 );
1337 :
1338 0 : if( nError == rtl_Digest_E_None )
1339 0 : nError = rtl_digest_updateMD5( aDigest, nPerm , sizeof( nPerm ) );
1340 :
1341 : //step 5, get the document ID, binary form
1342 0 : if( nError == rtl_Digest_E_None )
1343 0 : nError = rtl_digest_updateMD5( aDigest, &io_rProperties.DocumentIdentifier[0], sal_Int32(io_rProperties.DocumentIdentifier.size()) );
1344 : //get the digest
1345 0 : if( nError == rtl_Digest_E_None )
1346 : {
1347 0 : rtl_digest_getMD5( aDigest, nMD5Sum, sizeof( nMD5Sum ) );
1348 :
1349 : //step 6, only if 128 bit
1350 0 : if( io_rProperties.Security128bit )
1351 : {
1352 0 : for( sal_Int32 i = 0; i < 50; i++ )
1353 : {
1354 0 : nError = rtl_digest_updateMD5( aDigest, &nMD5Sum, sizeof( nMD5Sum ) );
1355 0 : if( nError != rtl_Digest_E_None )
1356 : {
1357 0 : bSuccess = false;
1358 0 : break;
1359 : }
1360 0 : rtl_digest_getMD5( aDigest, nMD5Sum, sizeof( nMD5Sum ) );
1361 : }
1362 : }
1363 : }
1364 : else
1365 : {
1366 0 : bSuccess = false;
1367 : }
1368 : }
1369 : else
1370 0 : bSuccess = false;
1371 :
1372 0 : i_pTransporter->invalidate();
1373 :
1374 : //Step 7
1375 0 : if( bSuccess )
1376 : {
1377 0 : io_rProperties.EncryptionKey.resize( MAXIMUM_RC4_KEY_LENGTH );
1378 0 : for( sal_Int32 i = 0; i < MD5_DIGEST_SIZE; i++ )
1379 0 : io_rProperties.EncryptionKey[i] = nMD5Sum[i];
1380 : }
1381 : else
1382 0 : io_rProperties.EncryptionKey.clear();
1383 :
1384 0 : return bSuccess;
1385 : }
1386 :
1387 : /**********************************
1388 : Algorithm 3.3 Compute the encryption dictionary /O value, save into the class data member
1389 : the step numbers down here correspond to the ones in PDF v.1.4 specfication
1390 : */
1391 0 : bool PDFWriterImpl::computeODictionaryValue( const sal_uInt8* i_pPaddedOwnerPassword,
1392 : const sal_uInt8* i_pPaddedUserPassword,
1393 : std::vector< sal_uInt8 >& io_rOValue,
1394 : sal_Int32 i_nKeyLength
1395 : )
1396 : {
1397 0 : bool bSuccess = true;
1398 :
1399 0 : io_rOValue.resize( ENCRYPTED_PWD_SIZE );
1400 :
1401 0 : rtlDigest aDigest = rtl_digest_createMD5();
1402 0 : rtlCipher aCipher = rtl_cipher_createARCFOUR( rtl_Cipher_ModeStream );
1403 0 : if( aDigest && aCipher)
1404 : {
1405 : //step 1 already done, data is in i_pPaddedOwnerPassword
1406 : //step 2
1407 :
1408 0 : rtlDigestError nError = rtl_digest_updateMD5( aDigest, i_pPaddedOwnerPassword, ENCRYPTED_PWD_SIZE );
1409 0 : if( nError == rtl_Digest_E_None )
1410 : {
1411 : sal_uInt8 nMD5Sum[ RTL_DIGEST_LENGTH_MD5 ];
1412 :
1413 0 : rtl_digest_getMD5( aDigest, nMD5Sum, sizeof(nMD5Sum) );
1414 : //step 3, only if 128 bit
1415 0 : if( i_nKeyLength == SECUR_128BIT_KEY )
1416 : {
1417 : sal_Int32 i;
1418 0 : for( i = 0; i < 50; i++ )
1419 : {
1420 0 : nError = rtl_digest_updateMD5( aDigest, nMD5Sum, sizeof( nMD5Sum ) );
1421 0 : if( nError != rtl_Digest_E_None )
1422 : {
1423 0 : bSuccess = false;
1424 0 : break;
1425 : }
1426 0 : rtl_digest_getMD5( aDigest, nMD5Sum, sizeof( nMD5Sum ) );
1427 : }
1428 : }
1429 : //Step 4, the key is in nMD5Sum
1430 : //step 5 already done, data is in i_pPaddedUserPassword
1431 : //step 6
1432 : rtl_cipher_initARCFOUR( aCipher, rtl_Cipher_DirectionEncode,
1433 0 : nMD5Sum, i_nKeyLength , NULL, 0 );
1434 : // encrypt the user password using the key set above
1435 : rtl_cipher_encodeARCFOUR( aCipher, i_pPaddedUserPassword, ENCRYPTED_PWD_SIZE, // the data to be encrypted
1436 0 : &io_rOValue[0], sal_Int32(io_rOValue.size()) ); //encrypted data
1437 : //Step 7, only if 128 bit
1438 0 : if( i_nKeyLength == SECUR_128BIT_KEY )
1439 : {
1440 : sal_uInt32 i, y;
1441 : sal_uInt8 nLocalKey[ SECUR_128BIT_KEY ]; // 16 = 128 bit key
1442 :
1443 0 : for( i = 1; i <= 19; i++ ) // do it 19 times, start with 1
1444 : {
1445 0 : for( y = 0; y < sizeof( nLocalKey ); y++ )
1446 0 : nLocalKey[y] = (sal_uInt8)( nMD5Sum[y] ^ i );
1447 :
1448 : rtl_cipher_initARCFOUR( aCipher, rtl_Cipher_DirectionEncode,
1449 0 : nLocalKey, SECUR_128BIT_KEY, NULL, 0 ); //destination data area, on init can be NULL
1450 0 : rtl_cipher_encodeARCFOUR( aCipher, &io_rOValue[0], sal_Int32(io_rOValue.size()), // the data to be encrypted
1451 0 : &io_rOValue[0], sal_Int32(io_rOValue.size()) ); // encrypted data, can be the same as the input, encrypt "in place"
1452 : //step 8, store in class data member
1453 : }
1454 : }
1455 : }
1456 : else
1457 0 : bSuccess = false;
1458 : }
1459 : else
1460 0 : bSuccess = false;
1461 :
1462 0 : if( aDigest )
1463 0 : rtl_digest_destroyMD5( aDigest );
1464 0 : if( aCipher )
1465 0 : rtl_cipher_destroyARCFOUR( aCipher );
1466 :
1467 0 : if( ! bSuccess )
1468 0 : io_rOValue.clear();
1469 0 : return bSuccess;
1470 : }
1471 :
1472 : /**********************************
1473 : Algorithms 3.4 and 3.5 Compute the encryption dictionary /U value, save into the class data member, revision 2 (40 bit) or 3 (128 bit)
1474 : */
1475 0 : bool PDFWriterImpl::computeUDictionaryValue( EncHashTransporter* i_pTransporter,
1476 : vcl::PDFWriter::PDFEncryptionProperties& io_rProperties,
1477 : sal_Int32 i_nKeyLength,
1478 : sal_Int32 i_nAccessPermissions
1479 : )
1480 : {
1481 0 : bool bSuccess = true;
1482 :
1483 0 : io_rProperties.UValue.resize( ENCRYPTED_PWD_SIZE );
1484 :
1485 0 : rtlDigest aDigest = rtl_digest_createMD5();
1486 0 : rtlCipher aCipher = rtl_cipher_createARCFOUR( rtl_Cipher_ModeStream );
1487 0 : if( aDigest && aCipher )
1488 : {
1489 : //step 1, common to both 3.4 and 3.5
1490 0 : if( computeEncryptionKey( i_pTransporter, io_rProperties, i_nAccessPermissions ) )
1491 : {
1492 : // prepare encryption key for object
1493 0 : for( sal_Int32 i = i_nKeyLength, y = 0; y < 5 ; y++ )
1494 0 : io_rProperties.EncryptionKey[i++] = 0;
1495 :
1496 0 : if( !io_rProperties.Security128bit )
1497 : {
1498 : //3.4
1499 : //step 2 and 3
1500 : rtl_cipher_initARCFOUR( aCipher, rtl_Cipher_DirectionEncode,
1501 0 : &io_rProperties.EncryptionKey[0], 5 , // key and key length
1502 0 : NULL, 0 ); //destination data area
1503 : // encrypt the user password using the key set above, save for later use
1504 : rtl_cipher_encodeARCFOUR( aCipher, s_nPadString, sizeof( s_nPadString ), // the data to be encrypted
1505 0 : &io_rProperties.UValue[0], sal_Int32(io_rProperties.UValue.size()) ); //encrypted data, stored in class data member
1506 : }
1507 : else
1508 : {
1509 : //or 3.5, for 128 bit security
1510 : //step6, initialize the last 16 bytes of the encrypted user password to 0
1511 0 : for(sal_uInt32 i = MD5_DIGEST_SIZE; i < sal_uInt32(io_rProperties.UValue.size()); i++)
1512 0 : io_rProperties.UValue[i] = 0;
1513 : //step 2
1514 0 : rtlDigestError nError = rtl_digest_updateMD5( aDigest, s_nPadString, sizeof( s_nPadString ) );
1515 : //step 3
1516 0 : if( nError == rtl_Digest_E_None )
1517 0 : nError = rtl_digest_updateMD5( aDigest, &io_rProperties.DocumentIdentifier[0], sal_Int32(io_rProperties.DocumentIdentifier.size()) );
1518 : else
1519 0 : bSuccess = false;
1520 :
1521 : sal_uInt8 nMD5Sum[ RTL_DIGEST_LENGTH_MD5 ];
1522 0 : rtl_digest_getMD5( aDigest, nMD5Sum, sizeof(nMD5Sum) );
1523 : //Step 4
1524 : rtl_cipher_initARCFOUR( aCipher, rtl_Cipher_DirectionEncode,
1525 0 : &io_rProperties.EncryptionKey[0], SECUR_128BIT_KEY, NULL, 0 ); //destination data area
1526 : rtl_cipher_encodeARCFOUR( aCipher, nMD5Sum, sizeof( nMD5Sum ), // the data to be encrypted
1527 0 : &io_rProperties.UValue[0], sizeof( nMD5Sum ) ); //encrypted data, stored in class data member
1528 : //step 5
1529 : sal_uInt32 i, y;
1530 : sal_uInt8 nLocalKey[SECUR_128BIT_KEY];
1531 :
1532 0 : for( i = 1; i <= 19; i++ ) // do it 19 times, start with 1
1533 : {
1534 0 : for( y = 0; y < sizeof( nLocalKey ) ; y++ )
1535 0 : nLocalKey[y] = (sal_uInt8)( io_rProperties.EncryptionKey[y] ^ i );
1536 :
1537 : rtl_cipher_initARCFOUR( aCipher, rtl_Cipher_DirectionEncode,
1538 : nLocalKey, SECUR_128BIT_KEY, // key and key length
1539 0 : NULL, 0 ); //destination data area, on init can be NULL
1540 0 : rtl_cipher_encodeARCFOUR( aCipher, &io_rProperties.UValue[0], SECUR_128BIT_KEY, // the data to be encrypted
1541 0 : &io_rProperties.UValue[0], SECUR_128BIT_KEY ); // encrypted data, can be the same as the input, encrypt "in place"
1542 : }
1543 : }
1544 : }
1545 : else
1546 0 : bSuccess = false;
1547 : }
1548 : else
1549 0 : bSuccess = false;
1550 :
1551 0 : if( aDigest )
1552 0 : rtl_digest_destroyMD5( aDigest );
1553 0 : if( aCipher )
1554 0 : rtl_cipher_destroyARCFOUR( aCipher );
1555 :
1556 0 : if( ! bSuccess )
1557 0 : io_rProperties.UValue.clear();
1558 0 : return bSuccess;
1559 : }
1560 :
1561 : /* end i12626 methods */
1562 :
1563 : static const long unsetRun[256] =
1564 : {
1565 : 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, /* 0x00 - 0x0f */
1566 : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x10 - 0x1f */
1567 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x20 - 0x2f */
1568 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x30 - 0x3f */
1569 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */
1570 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x50 - 0x5f */
1571 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */
1572 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x70 - 0x7f */
1573 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 - 0x8f */
1574 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 - 0x9f */
1575 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 - 0xaf */
1576 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb0 - 0xbf */
1577 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 - 0xcf */
1578 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 - 0xdf */
1579 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 - 0xef */
1580 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf0 - 0xff */
1581 : };
1582 :
1583 : static const long setRun[256] =
1584 : {
1585 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x0f */
1586 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */
1587 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x2f */
1588 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 - 0x3f */
1589 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x4f */
1590 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */
1591 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x6f */
1592 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 - 0x7f */
1593 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x80 - 0x8f */
1594 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x90 - 0x9f */
1595 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xa0 - 0xaf */
1596 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xb0 - 0xbf */
1597 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xc0 - 0xcf */
1598 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xd0 - 0xdf */
1599 : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xe0 - 0xef */
1600 : 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8, /* 0xf0 - 0xff */
1601 : };
1602 :
1603 0 : inline bool isSet( const Scanline i_pLine, long i_nIndex )
1604 : {
1605 0 : return (i_pLine[ i_nIndex/8 ] & (0x80 >> (i_nIndex&7))) != 0;
1606 : }
1607 :
1608 0 : long findBitRun( const Scanline i_pLine, long i_nStartIndex, long i_nW, bool i_bSet )
1609 : {
1610 0 : if( i_nStartIndex < 0 )
1611 0 : return i_nW;
1612 :
1613 0 : long nIndex = i_nStartIndex;
1614 0 : if( nIndex < i_nW )
1615 : {
1616 0 : const sal_uInt8 * pByte = static_cast<sal_uInt8*>(i_pLine) + (nIndex/8);
1617 0 : sal_uInt8 nByte = *pByte;
1618 :
1619 : // run up to byte boundary
1620 0 : long nBitInByte = (nIndex & 7);
1621 0 : if( nBitInByte )
1622 : {
1623 0 : sal_uInt8 nMask = 0x80 >> nBitInByte;
1624 0 : while( nBitInByte != 8 )
1625 : {
1626 0 : if( (nByte & nMask) != (i_bSet ? nMask : 0) )
1627 0 : return nIndex < i_nW ? nIndex : i_nW;
1628 0 : nMask = nMask >> 1;
1629 0 : nBitInByte++;
1630 0 : nIndex++;
1631 : }
1632 0 : if( nIndex < i_nW )
1633 : {
1634 0 : pByte++;
1635 0 : nByte = *pByte;
1636 : }
1637 : }
1638 :
1639 : sal_uInt8 nRunByte;
1640 : const long* pRunTable;
1641 0 : if( i_bSet )
1642 : {
1643 0 : nRunByte = 0xff;
1644 0 : pRunTable = setRun;
1645 : }
1646 : else
1647 : {
1648 0 : nRunByte = 0;
1649 0 : pRunTable = unsetRun;
1650 : }
1651 :
1652 0 : if( nIndex < i_nW )
1653 : {
1654 0 : while( nByte == nRunByte )
1655 : {
1656 0 : nIndex += 8;
1657 :
1658 0 : if (nIndex >= i_nW)
1659 0 : break;
1660 :
1661 0 : pByte++;
1662 0 : nByte = *pByte;
1663 : }
1664 : }
1665 :
1666 0 : if( nIndex < i_nW )
1667 : {
1668 0 : nIndex += pRunTable[nByte];
1669 : }
1670 : }
1671 0 : return nIndex < i_nW ? nIndex : i_nW;
1672 : }
1673 :
1674 : struct BitStreamState
1675 : {
1676 : sal_uInt8 mnBuffer;
1677 : sal_uInt32 mnNextBitPos;
1678 :
1679 0 : BitStreamState()
1680 : : mnBuffer( 0 )
1681 0 : , mnNextBitPos( 8 )
1682 : {
1683 0 : }
1684 :
1685 0 : const sal_uInt8& getByte() const { return mnBuffer; }
1686 0 : void flush() { mnNextBitPos = 8; mnBuffer = 0; }
1687 : };
1688 :
1689 0 : void PDFWriterImpl::putG4Bits( sal_uInt32 i_nLength, sal_uInt32 i_nCode, BitStreamState& io_rState )
1690 : {
1691 0 : while( i_nLength > io_rState.mnNextBitPos )
1692 : {
1693 0 : io_rState.mnBuffer |= static_cast<sal_uInt8>( i_nCode >> (i_nLength - io_rState.mnNextBitPos) );
1694 0 : i_nLength -= io_rState.mnNextBitPos;
1695 0 : writeBuffer( &io_rState.getByte(), 1 );
1696 0 : io_rState.flush();
1697 : }
1698 : OSL_ASSERT( i_nLength < 9 );
1699 : static const unsigned int msbmask[9] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
1700 0 : io_rState.mnBuffer |= static_cast<sal_uInt8>( (i_nCode & msbmask[i_nLength]) << (io_rState.mnNextBitPos - i_nLength) );
1701 0 : io_rState.mnNextBitPos -= i_nLength;
1702 0 : if( io_rState.mnNextBitPos == 0 )
1703 : {
1704 0 : writeBuffer( &io_rState.getByte(), 1 );
1705 0 : io_rState.flush();
1706 : }
1707 0 : }
1708 :
1709 : struct PixelCode
1710 : {
1711 : sal_uInt32 mnEncodedPixels;
1712 : sal_uInt32 mnCodeBits;
1713 : sal_uInt32 mnCode;
1714 : };
1715 :
1716 : static const PixelCode WhitePixelCodes[] =
1717 : {
1718 : { 0, 8, 0x35 }, // 0011 0101
1719 : { 1, 6, 0x7 }, // 0001 11
1720 : { 2, 4, 0x7 }, // 0111
1721 : { 3, 4, 0x8 }, // 1000
1722 : { 4, 4, 0xB }, // 1011
1723 : { 5, 4, 0xC }, // 1100
1724 : { 6, 4, 0xE }, // 1110
1725 : { 7, 4, 0xF }, // 1111
1726 : { 8, 5, 0x13 }, // 1001 1
1727 : { 9, 5, 0x14 }, // 1010 0
1728 : { 10, 5, 0x7 }, // 0011 1
1729 : { 11, 5, 0x8 }, // 0100 0
1730 : { 12, 6, 0x8 }, // 0010 00
1731 : { 13, 6, 0x3 }, // 0000 11
1732 : { 14, 6, 0x34 }, // 1101 00
1733 : { 15, 6, 0x35 }, // 1101 01
1734 : { 16, 6, 0x2A }, // 1010 10
1735 : { 17, 6, 0x2B }, // 1010 11
1736 : { 18, 7, 0x27 }, // 0100 111
1737 : { 19, 7, 0xC }, // 0001 100
1738 : { 20, 7, 0x8 }, // 0001 000
1739 : { 21, 7, 0x17 }, // 0010 111
1740 : { 22, 7, 0x3 }, // 0000 011
1741 : { 23, 7, 0x4 }, // 0000 100
1742 : { 24, 7, 0x28 }, // 0101 000
1743 : { 25, 7, 0x2B }, // 0101 011
1744 : { 26, 7, 0x13 }, // 0010 011
1745 : { 27, 7, 0x24 }, // 0100 100
1746 : { 28, 7, 0x18 }, // 0011 000
1747 : { 29, 8, 0x2 }, // 0000 0010
1748 : { 30, 8, 0x3 }, // 0000 0011
1749 : { 31, 8, 0x1A }, // 0001 1010
1750 : { 32, 8, 0x1B }, // 0001 1011
1751 : { 33, 8, 0x12 }, // 0001 0010
1752 : { 34, 8, 0x13 }, // 0001 0011
1753 : { 35, 8, 0x14 }, // 0001 0100
1754 : { 36, 8, 0x15 }, // 0001 0101
1755 : { 37, 8, 0x16 }, // 0001 0110
1756 : { 38, 8, 0x17 }, // 0001 0111
1757 : { 39, 8, 0x28 }, // 0010 1000
1758 : { 40, 8, 0x29 }, // 0010 1001
1759 : { 41, 8, 0x2A }, // 0010 1010
1760 : { 42, 8, 0x2B }, // 0010 1011
1761 : { 43, 8, 0x2C }, // 0010 1100
1762 : { 44, 8, 0x2D }, // 0010 1101
1763 : { 45, 8, 0x4 }, // 0000 0100
1764 : { 46, 8, 0x5 }, // 0000 0101
1765 : { 47, 8, 0xA }, // 0000 1010
1766 : { 48, 8, 0xB }, // 0000 1011
1767 : { 49, 8, 0x52 }, // 0101 0010
1768 : { 50, 8, 0x53 }, // 0101 0011
1769 : { 51, 8, 0x54 }, // 0101 0100
1770 : { 52, 8, 0x55 }, // 0101 0101
1771 : { 53, 8, 0x24 }, // 0010 0100
1772 : { 54, 8, 0x25 }, // 0010 0101
1773 : { 55, 8, 0x58 }, // 0101 1000
1774 : { 56, 8, 0x59 }, // 0101 1001
1775 : { 57, 8, 0x5A }, // 0101 1010
1776 : { 58, 8, 0x5B }, // 0101 1011
1777 : { 59, 8, 0x4A }, // 0100 1010
1778 : { 60, 8, 0x4B }, // 0100 1011
1779 : { 61, 8, 0x32 }, // 0011 0010
1780 : { 62, 8, 0x33 }, // 0011 0011
1781 : { 63, 8, 0x34 }, // 0011 0100
1782 : { 64, 5, 0x1B }, // 1101 1
1783 : { 128, 5, 0x12 }, // 1001 0
1784 : { 192, 6, 0x17 }, // 0101 11
1785 : { 256, 7, 0x37 }, // 0110 111
1786 : { 320, 8, 0x36 }, // 0011 0110
1787 : { 384, 8, 0x37 }, // 0011 0111
1788 : { 448, 8, 0x64 }, // 0110 0100
1789 : { 512, 8, 0x65 }, // 0110 0101
1790 : { 576, 8, 0x68 }, // 0110 1000
1791 : { 640, 8, 0x67 }, // 0110 0111
1792 : { 704, 9, 0xCC }, // 0110 0110 0
1793 : { 768, 9, 0xCD }, // 0110 0110 1
1794 : { 832, 9, 0xD2 }, // 0110 1001 0
1795 : { 896, 9, 0xD3 }, // 0110 1001 1
1796 : { 960, 9, 0xD4 }, // 0110 1010 0
1797 : { 1024, 9, 0xD5 }, // 0110 1010 1
1798 : { 1088, 9, 0xD6 }, // 0110 1011 0
1799 : { 1152, 9, 0xD7 }, // 0110 1011 1
1800 : { 1216, 9, 0xD8 }, // 0110 1100 0
1801 : { 1280, 9, 0xD9 }, // 0110 1100 1
1802 : { 1344, 9, 0xDA }, // 0110 1101 0
1803 : { 1408, 9, 0xDB }, // 0110 1101 1
1804 : { 1472, 9, 0x98 }, // 0100 1100 0
1805 : { 1536, 9, 0x99 }, // 0100 1100 1
1806 : { 1600, 9, 0x9A }, // 0100 1101 0
1807 : { 1664, 6, 0x18 }, // 0110 00
1808 : { 1728, 9, 0x9B }, // 0100 1101 1
1809 : { 1792, 11, 0x8 }, // 0000 0001 000
1810 : { 1856, 11, 0xC }, // 0000 0001 100
1811 : { 1920, 11, 0xD }, // 0000 0001 101
1812 : { 1984, 12, 0x12 }, // 0000 0001 0010
1813 : { 2048, 12, 0x13 }, // 0000 0001 0011
1814 : { 2112, 12, 0x14 }, // 0000 0001 0100
1815 : { 2176, 12, 0x15 }, // 0000 0001 0101
1816 : { 2240, 12, 0x16 }, // 0000 0001 0110
1817 : { 2304, 12, 0x17 }, // 0000 0001 0111
1818 : { 2368, 12, 0x1C }, // 0000 0001 1100
1819 : { 2432, 12, 0x1D }, // 0000 0001 1101
1820 : { 2496, 12, 0x1E }, // 0000 0001 1110
1821 : { 2560, 12, 0x1F } // 0000 0001 1111
1822 : };
1823 :
1824 : static const PixelCode BlackPixelCodes[] =
1825 : {
1826 : { 0, 10, 0x37 }, // 0000 1101 11
1827 : { 1, 3, 0x2 }, // 010
1828 : { 2, 2, 0x3 }, // 11
1829 : { 3, 2, 0x2 }, // 10
1830 : { 4, 3, 0x3 }, // 011
1831 : { 5, 4, 0x3 }, // 0011
1832 : { 6, 4, 0x2 }, // 0010
1833 : { 7, 5, 0x3 }, // 0001 1
1834 : { 8, 6, 0x5 }, // 0001 01
1835 : { 9, 6, 0x4 }, // 0001 00
1836 : { 10, 7, 0x4 }, // 0000 100
1837 : { 11, 7, 0x5 }, // 0000 101
1838 : { 12, 7, 0x7 }, // 0000 111
1839 : { 13, 8, 0x4 }, // 0000 0100
1840 : { 14, 8, 0x7 }, // 0000 0111
1841 : { 15, 9, 0x18 }, // 0000 1100 0
1842 : { 16, 10, 0x17 }, // 0000 0101 11
1843 : { 17, 10, 0x18 }, // 0000 0110 00
1844 : { 18, 10, 0x8 }, // 0000 0010 00
1845 : { 19, 11, 0x67 }, // 0000 1100 111
1846 : { 20, 11, 0x68 }, // 0000 1101 000
1847 : { 21, 11, 0x6C }, // 0000 1101 100
1848 : { 22, 11, 0x37 }, // 0000 0110 111
1849 : { 23, 11, 0x28 }, // 0000 0101 000
1850 : { 24, 11, 0x17 }, // 0000 0010 111
1851 : { 25, 11, 0x18 }, // 0000 0011 000
1852 : { 26, 12, 0xCA }, // 0000 1100 1010
1853 : { 27, 12, 0xCB }, // 0000 1100 1011
1854 : { 28, 12, 0xCC }, // 0000 1100 1100
1855 : { 29, 12, 0xCD }, // 0000 1100 1101
1856 : { 30, 12, 0x68 }, // 0000 0110 1000
1857 : { 31, 12, 0x69 }, // 0000 0110 1001
1858 : { 32, 12, 0x6A }, // 0000 0110 1010
1859 : { 33, 12, 0x6B }, // 0000 0110 1011
1860 : { 34, 12, 0xD2 }, // 0000 1101 0010
1861 : { 35, 12, 0xD3 }, // 0000 1101 0011
1862 : { 36, 12, 0xD4 }, // 0000 1101 0100
1863 : { 37, 12, 0xD5 }, // 0000 1101 0101
1864 : { 38, 12, 0xD6 }, // 0000 1101 0110
1865 : { 39, 12, 0xD7 }, // 0000 1101 0111
1866 : { 40, 12, 0x6C }, // 0000 0110 1100
1867 : { 41, 12, 0x6D }, // 0000 0110 1101
1868 : { 42, 12, 0xDA }, // 0000 1101 1010
1869 : { 43, 12, 0xDB }, // 0000 1101 1011
1870 : { 44, 12, 0x54 }, // 0000 0101 0100
1871 : { 45, 12, 0x55 }, // 0000 0101 0101
1872 : { 46, 12, 0x56 }, // 0000 0101 0110
1873 : { 47, 12, 0x57 }, // 0000 0101 0111
1874 : { 48, 12, 0x64 }, // 0000 0110 0100
1875 : { 49, 12, 0x65 }, // 0000 0110 0101
1876 : { 50, 12, 0x52 }, // 0000 0101 0010
1877 : { 51, 12, 0x53 }, // 0000 0101 0011
1878 : { 52, 12, 0x24 }, // 0000 0010 0100
1879 : { 53, 12, 0x37 }, // 0000 0011 0111
1880 : { 54, 12, 0x38 }, // 0000 0011 1000
1881 : { 55, 12, 0x27 }, // 0000 0010 0111
1882 : { 56, 12, 0x28 }, // 0000 0010 1000
1883 : { 57, 12, 0x58 }, // 0000 0101 1000
1884 : { 58, 12, 0x59 }, // 0000 0101 1001
1885 : { 59, 12, 0x2B }, // 0000 0010 1011
1886 : { 60, 12, 0x2C }, // 0000 0010 1100
1887 : { 61, 12, 0x5A }, // 0000 0101 1010
1888 : { 62, 12, 0x66 }, // 0000 0110 0110
1889 : { 63, 12, 0x67 }, // 0000 0110 0111
1890 : { 64, 10, 0xF }, // 0000 0011 11
1891 : { 128, 12, 0xC8 }, // 0000 1100 1000
1892 : { 192, 12, 0xC9 }, // 0000 1100 1001
1893 : { 256, 12, 0x5B }, // 0000 0101 1011
1894 : { 320, 12, 0x33 }, // 0000 0011 0011
1895 : { 384, 12, 0x34 }, // 0000 0011 0100
1896 : { 448, 12, 0x35 }, // 0000 0011 0101
1897 : { 512, 13, 0x6C }, // 0000 0011 0110 0
1898 : { 576, 13, 0x6D }, // 0000 0011 0110 1
1899 : { 640, 13, 0x4A }, // 0000 0010 0101 0
1900 : { 704, 13, 0x4B }, // 0000 0010 0101 1
1901 : { 768, 13, 0x4C }, // 0000 0010 0110 0
1902 : { 832, 13, 0x4D }, // 0000 0010 0110 1
1903 : { 896, 13, 0x72 }, // 0000 0011 1001 0
1904 : { 960, 13, 0x73 }, // 0000 0011 1001 1
1905 : { 1024, 13, 0x74 }, // 0000 0011 1010 0
1906 : { 1088, 13, 0x75 }, // 0000 0011 1010 1
1907 : { 1152, 13, 0x76 }, // 0000 0011 1011 0
1908 : { 1216, 13, 0x77 }, // 0000 0011 1011 1
1909 : { 1280, 13, 0x52 }, // 0000 0010 1001 0
1910 : { 1344, 13, 0x53 }, // 0000 0010 1001 1
1911 : { 1408, 13, 0x54 }, // 0000 0010 1010 0
1912 : { 1472, 13, 0x55 }, // 0000 0010 1010 1
1913 : { 1536, 13, 0x5A }, // 0000 0010 1101 0
1914 : { 1600, 13, 0x5B }, // 0000 0010 1101 1
1915 : { 1664, 13, 0x64 }, // 0000 0011 0010 0
1916 : { 1728, 13, 0x65 }, // 0000 0011 0010 1
1917 : { 1792, 11, 0x8 }, // 0000 0001 000
1918 : { 1856, 11, 0xC }, // 0000 0001 100
1919 : { 1920, 11, 0xD }, // 0000 0001 101
1920 : { 1984, 12, 0x12 }, // 0000 0001 0010
1921 : { 2048, 12, 0x13 }, // 0000 0001 0011
1922 : { 2112, 12, 0x14 }, // 0000 0001 0100
1923 : { 2176, 12, 0x15 }, // 0000 0001 0101
1924 : { 2240, 12, 0x16 }, // 0000 0001 0110
1925 : { 2304, 12, 0x17 }, // 0000 0001 0111
1926 : { 2368, 12, 0x1C }, // 0000 0001 1100
1927 : { 2432, 12, 0x1D }, // 0000 0001 1101
1928 : { 2496, 12, 0x1E }, // 0000 0001 1110
1929 : { 2560, 12, 0x1F } // 0000 0001 1111
1930 : };
1931 :
1932 0 : void PDFWriterImpl::putG4Span( long i_nSpan, bool i_bWhitePixel, BitStreamState& io_rState )
1933 : {
1934 0 : const PixelCode* pTable = i_bWhitePixel ? WhitePixelCodes : BlackPixelCodes;
1935 : // maximum encoded span is 2560 consecutive pixels
1936 0 : while( i_nSpan > 2623 )
1937 : {
1938 : // write 2560 bits, that is entry (63 + (2560 >> 6)) == 103 in the appropriate table
1939 0 : putG4Bits( pTable[103].mnCodeBits, pTable[103].mnCode, io_rState );
1940 0 : i_nSpan -= pTable[103].mnEncodedPixels;
1941 : }
1942 : // write multiples of 64 pixels up to 2560
1943 0 : if( i_nSpan > 63 )
1944 : {
1945 0 : sal_uInt32 nTabIndex = 63 + (i_nSpan >> 6);
1946 : OSL_ASSERT( pTable[nTabIndex].mnEncodedPixels == static_cast<sal_uInt32>(64*(i_nSpan >> 6)) );
1947 0 : putG4Bits( pTable[nTabIndex].mnCodeBits, pTable[nTabIndex].mnCode, io_rState );
1948 0 : i_nSpan -= pTable[nTabIndex].mnEncodedPixels;
1949 : }
1950 0 : putG4Bits( pTable[i_nSpan].mnCodeBits, pTable[i_nSpan].mnCode, io_rState );
1951 0 : }
1952 :
1953 0 : void PDFWriterImpl::writeG4Stream( BitmapReadAccess* i_pBitmap )
1954 : {
1955 0 : long nW = i_pBitmap->Width();
1956 0 : long nH = i_pBitmap->Height();
1957 0 : if( nW <= 0 || nH <= 0 )
1958 0 : return;
1959 0 : if( i_pBitmap->GetBitCount() != 1 )
1960 0 : return;
1961 :
1962 0 : BitStreamState aBitState;
1963 :
1964 : // the first reference line is virtual and completely empty
1965 0 : const Scanline pFirstRefLine = static_cast<Scanline>(rtl_allocateZeroMemory( nW/8 + 1 ));
1966 0 : Scanline pRefLine = pFirstRefLine;
1967 0 : for( long nY = 0; nY < nH; nY++ )
1968 : {
1969 0 : const Scanline pCurLine = i_pBitmap->GetScanline( nY );
1970 0 : long nLineIndex = 0;
1971 0 : bool bRunSet = (*pCurLine & 0x80) != 0;
1972 0 : bool bRefSet = (*pRefLine & 0x80) != 0;
1973 0 : long nRunIndex1 = bRunSet ? 0 : findBitRun( pCurLine, 0, nW, bRunSet );
1974 0 : long nRefIndex1 = bRefSet ? 0 : findBitRun( pRefLine, 0, nW, bRefSet );
1975 0 : for( ; nLineIndex < nW; )
1976 : {
1977 0 : long nRefIndex2 = findBitRun( pRefLine, nRefIndex1, nW, isSet( pRefLine, nRefIndex1 ) );
1978 0 : if( nRefIndex2 >= nRunIndex1 )
1979 : {
1980 0 : long nDiff = nRefIndex1 - nRunIndex1;
1981 0 : if( -3 <= nDiff && nDiff <= 3 )
1982 : { // vertical coding
1983 : static const struct
1984 : {
1985 : sal_uInt32 mnCodeBits;
1986 : sal_uInt32 mnCode;
1987 : } VerticalCodes[7] = {
1988 : { 7, 0x03 }, // 0000 011
1989 : { 6, 0x03 }, // 0000 11
1990 : { 3, 0x03 }, // 011
1991 : { 1, 0x1 }, // 1
1992 : { 3, 0x2 }, // 010
1993 : { 6, 0x02 }, // 0000 10
1994 : { 7, 0x02 } // 0000 010
1995 : };
1996 : // convert to index
1997 0 : nDiff += 3;
1998 :
1999 : // emit diff code
2000 0 : putG4Bits( VerticalCodes[nDiff].mnCodeBits, VerticalCodes[nDiff].mnCode, aBitState );
2001 0 : nLineIndex = nRunIndex1;
2002 : }
2003 : else
2004 : { // difference too large, horizontal coding
2005 : // emit horz code 001
2006 0 : putG4Bits( 3, 0x1, aBitState );
2007 0 : long nRunIndex2 = findBitRun( pCurLine, nRunIndex1, nW, isSet( pCurLine, nRunIndex1 ) );
2008 0 : bool bWhiteFirst = ( nLineIndex + nRunIndex1 == 0 || ! isSet( pCurLine, nLineIndex ) );
2009 0 : putG4Span( nRunIndex1 - nLineIndex, bWhiteFirst, aBitState );
2010 0 : putG4Span( nRunIndex2 - nRunIndex1, ! bWhiteFirst, aBitState );
2011 0 : nLineIndex = nRunIndex2;
2012 : }
2013 : }
2014 : else
2015 : { // emit pass code 0001
2016 0 : putG4Bits( 4, 0x1, aBitState );
2017 0 : nLineIndex = nRefIndex2;
2018 : }
2019 0 : if( nLineIndex < nW )
2020 : {
2021 0 : bool bSet = isSet( pCurLine, nLineIndex );
2022 0 : nRunIndex1 = findBitRun( pCurLine, nLineIndex, nW, bSet );
2023 0 : nRefIndex1 = findBitRun( pRefLine, nLineIndex, nW, ! bSet );
2024 0 : nRefIndex1 = findBitRun( pRefLine, nRefIndex1, nW, bSet );
2025 : }
2026 : }
2027 :
2028 : // the current line is the reference for the next line
2029 0 : pRefLine = pCurLine;
2030 : }
2031 : // terminate strip with EOFB
2032 0 : putG4Bits( 12, 1, aBitState );
2033 0 : putG4Bits( 12, 1, aBitState );
2034 0 : if( aBitState.mnNextBitPos != 8 )
2035 : {
2036 0 : writeBuffer( &aBitState.getByte(), 1 );
2037 0 : aBitState.flush();
2038 : }
2039 :
2040 0 : rtl_freeMemory( pFirstRefLine );
2041 : }
2042 :
2043 0 : static bool lcl_canUsePDFAxialShading(const Gradient& rGradient) {
2044 0 : switch (rGradient.GetStyle())
2045 : {
2046 : case GradientStyle_LINEAR:
2047 : case GradientStyle_AXIAL:
2048 0 : break;
2049 : default:
2050 0 : return false;
2051 : }
2052 :
2053 : // TODO: handle step count
2054 0 : if (rGradient.GetSteps() > 0)
2055 0 : return false;
2056 :
2057 0 : return true;
2058 801 : }
2059 :
2060 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
