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