sdext/source/pdfimport/wrapper/wrapper.cxx

   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 <config_folders.h>
  21
  22 #include <contentsink.hxx>
  23 #include <pdfparse.hxx>
  24 #include <pdfihelper.hxx>
  25 #include <wrapper.hxx>
  26
  27 #include <osl/file.h>
  28 #include <osl/file.hxx>
  29 #include <osl/thread.h>
  30 #include <osl/process.h>
  31 #include <osl/diagnose.h>
  32 #include <rtl/bootstrap.hxx>
  33 #include <rtl/ustring.hxx>
  34 #include <rtl/ustrbuf.hxx>
  35 #include <rtl/strbuf.hxx>
  36 #include <sal/log.hxx>
  37
  38 #include <comphelper/propertysequence.hxx>
  39 #include <com/sun/star/io/XInputStream.hpp>
  40 #include <com/sun/star/uno/XComponentContext.hpp>
  41 #include <com/sun/star/awt/FontDescriptor.hpp>
  42 #include <com/sun/star/beans/XMaterialHolder.hpp>
  43 #include <com/sun/star/rendering/PathCapType.hpp>
  44 #include <com/sun/star/rendering/PathJoinType.hpp>
  45 #include <com/sun/star/rendering/XPolyPolygon2D.hpp>
  46 #include <com/sun/star/geometry/Matrix2D.hpp>
  47 #include <com/sun/star/geometry/AffineMatrix2D.hpp>
  48 #include <com/sun/star/geometry/RealRectangle2D.hpp>
  49 #include <com/sun/star/geometry/RealSize2D.hpp>
  50 #include <com/sun/star/task/XInteractionHandler.hpp>
  51
  52 #include <basegfx/point/b2dpoint.hxx>
  53 #include <basegfx/polygon/b2dpolypolygon.hxx>
  54 #include <basegfx/polygon/b2dpolygon.hxx>
  55 #include <basegfx/utils/unopolypolygon.hxx>
  56
  57 #include <vcl/metric.hxx>
  58 #include <vcl/font.hxx>
  59 #include <vcl/virdev.hxx>
  60
  61 #include <memory>
  62 #include <unordered_map>
  63 #include <string.h>
  64 #include <stdlib.h>
  65
  66 #include <rtl/character.hxx>
  67
  68 using namespace com::sun::star;
  69
  70 namespace pdfi
  71 {
  72
  73 namespace
  74 {
  75
  76 // identifier of the strings coming from the out-of-process xpdf
  77 // converter
  78 enum parseKey {
  79     CLIPPATH,
  80     DRAWCHAR,
  81     DRAWIMAGE,
  82     DRAWLINK,
  83     DRAWMASK,
  84     DRAWMASKEDIMAGE,
  85     DRAWSOFTMASKEDIMAGE,
  86     ENDPAGE,
  87     ENDTEXTOBJECT,
  88     EOCLIPPATH,
  89     EOFILLPATH,
  90     FILLPATH,
  91     HYPERLINK,
  92     INTERSECTCLIP,
  93     INTERSECTEOCLIP,
  94     POPSTATE,
  95     PUSHSTATE,
  96     RESTORESTATE,
  97     SAVESTATE,
  98     SETBLENDMODE,
  99     SETFILLCOLOR,
 100     SETFONT,
 101     SETLINECAP,
 102     SETLINEDASH,
 103     SETLINEJOIN,
 104     SETLINEWIDTH,
 105     SETMITERLIMIT,
 106     SETPAGENUM,
 107     SETSTROKECOLOR,
 108     SETTEXTRENDERMODE,
 109     SETTRANSFORMATION,
 110     STARTPAGE,
 111     STROKEPATH,
 112     UPDATEBLENDMODE,
 113     UPDATECTM,
 114     UPDATEFILLCOLOR,
 115     UPDATEFILLOPACITY,
 116     UPDATEFLATNESS,
 117     UPDATEFONT,
 118     UPDATELINECAP,
 119     UPDATELINEDASH,
 120     UPDATELINEJOIN,
 121     UPDATELINEWIDTH,
 122     UPDATEMITERLIMIT,
 123     UPDATESTROKECOLOR,
 124     UPDATESTROKEOPACITY,
 125     NONE
 126 };
 127
 128 #if defined _MSC_VER && defined __clang__
 129 #pragma clang diagnostic push
 130 #pragma clang diagnostic ignored "-Wdeprecated-register"
 131 #pragma clang diagnostic ignored "-Wextra-tokens"
 132 #endif
 133 #include <hash.cxx>
 134 #if defined _MSC_VER && defined __clang__
 135 #pragma clang diagnostic pop
 136 #endif
 137
 138 class Parser
 139 {
 140     typedef std::unordered_map< sal_Int64,
 141                            FontAttributes > FontMapType;
 142
 143     ScopedVclPtr<VirtualDevice> m_xDev;
 144     const uno::Reference<uno::XComponentContext> m_xContext;
 145     const ContentSinkSharedPtr                   m_pSink;
 146     const oslFileHandle                          m_pErr;
 147     OString                               m_aLine;
 148     FontMapType                                  m_aFontMap;
 149     sal_Int32                                    m_nNextToken;
 150     sal_Int32                                    m_nCharIndex;
 151
 152
 153     OString readNextToken();
 154     void           readInt32( sal_Int32& o_Value );
 155     sal_Int32      readInt32();
 156     void           readInt64( sal_Int64& o_Value );
 157     void           readDouble( double& o_Value );
 158     double         readDouble();
 159     void           readBinaryData( uno::Sequence<sal_Int8>& rBuf );
 160
 161     uno::Reference<rendering::XPolyPolygon2D> readPath();
 162
 163     void                 readChar();
 164     void                 readLineCap();
 165     void                 readLineDash();
 166     void                 readLineJoin();
 167     void                 readTransformation();
 168     rendering::ARGBColor readColor();
 169     static void          parseFontFamilyName( FontAttributes& aResult );
 170     void                 readFont();
 171     uno::Sequence<beans::PropertyValue> readImageImpl();
 172
 173     void                 readImage();
 174     void                 readMask();
 175     void                 readLink();
 176     void                 readMaskedImage();
 177     void                 readSoftMaskedImage();
 178     static sal_Int32 parseFontCheckForString(const sal_Unicode* pCopy, sal_Int32 nCopyLen,
 179                                       const char* pAttrib, sal_Int32 nAttribLen,
 180                                       FontAttributes& rResult, bool bItalic, bool bBold);
 181     static sal_Int32 parseFontRemoveSuffix(const sal_Unicode* pCopy, sal_Int32 nCopyLen,
 182                               const char* pAttrib, sal_Int32 nAttribLen);
 183
 184 public:
 185     Parser( const ContentSinkSharedPtr&                   rSink,
 186             oslFileHandle                                 pErr,
 187             const uno::Reference<uno::XComponentContext>& xContext ) :
 188         m_xContext(xContext),
 189         m_pSink(rSink),
 190         m_pErr(pErr),
 191         m_aLine(),
 192         m_aFontMap(101),
 193         m_nNextToken(-1),
 194         m_nCharIndex(-1)
 195     {}
 196
 197     void parseLine( const OString& rLine );
 198 };
 199
 200 /** Unescapes line-ending characters in input string. These
 201     characters are encoded as pairs of characters: '\\' 'n', resp.
 202     '\\' 'r'. This function converts them back to '\n', resp. '\r'.
 203   */
 204 OString lcl_unescapeLineFeeds(const OString& i_rStr)
 205 {
 206     const size_t nOrigLen(sal::static_int_cast<size_t>(i_rStr.getLength()));
 207     const sal_Char* const pOrig(i_rStr.getStr());
 208     std::unique_ptr<sal_Char[]> pBuffer(new sal_Char[nOrigLen + 1]);
 209
 210     const sal_Char* pRead(pOrig);
 211     sal_Char* pWrite(pBuffer.get());
 212     const sal_Char* pCur(pOrig);
 213     while ((pCur = strchr(pCur, '\\')) != nullptr)
 214     {
 215         const sal_Char cNext(pCur[1]);
 216         if (cNext == 'n' || cNext == 'r' || cNext == '\\')
 217         {
 218             const size_t nLen(pCur - pRead);
 219             strncpy(pWrite, pRead, nLen);
 220             pWrite += nLen;
 221             *pWrite = cNext == 'n' ? '\n' : (cNext == 'r' ? '\r' : '\\');
 222             ++pWrite;
 223             pCur = pRead = pCur + 2;
 224         }
 225         else
 226         {
 227             // Just continue on the next character. The current
 228             // block will be copied the next time it goes through the
 229             // 'if' branch.
 230             ++pCur;
 231         }
 232     }
 233     // maybe there are some data to copy yet
 234     if (sal::static_int_cast<size_t>(pRead - pOrig) < nOrigLen)
 235     {
 236         const size_t nLen(nOrigLen - (pRead - pOrig));
 237         strncpy(pWrite, pRead, nLen);
 238         pWrite += nLen;
 239     }
 240     *pWrite = '\0';
 241
 242     OString aResult(pBuffer.get());
 243     return aResult;
 244 }
 245
 246 OString Parser::readNextToken()
 247 {
 248     OSL_PRECOND(m_nCharIndex!=-1,"insufficient input");
 249     return m_aLine.getToken(m_nNextToken,' ',m_nCharIndex);
 250 }
 251
 252 void Parser::readInt32( sal_Int32& o_Value )
 253 {
 254     o_Value = readNextToken().toInt32();
 255 }
 256
 257 sal_Int32 Parser::readInt32()
 258 {
 259     return readNextToken().toInt32();
 260 }
 261
 262 void Parser::readInt64( sal_Int64& o_Value )
 263 {
 264     o_Value = readNextToken().toInt64();
 265 }
 266
 267 void Parser::readDouble( double& o_Value )
 268 {
 269     o_Value = readNextToken().toDouble();
 270 }
 271
 272 double Parser::readDouble()
 273 {
 274     return readNextToken().toDouble();
 275 }
 276
 277 void Parser::readBinaryData( uno::Sequence<sal_Int8>& rBuf )
 278 {
 279     sal_Int32 nFileLen( rBuf.getLength() );
 280     sal_Int8*           pBuf( rBuf.getArray() );
 281     sal_uInt64          nBytesRead(0);
 282     oslFileError        nRes=osl_File_E_None;
 283     while( nFileLen &&
 284            osl_File_E_None == (nRes=osl_readFile( m_pErr, pBuf, nFileLen, &nBytesRead )) )
 285     {
 286         pBuf += nBytesRead;
 287         nFileLen -= sal::static_int_cast<sal_Int32>(nBytesRead);
 288     }
 289
 290     OSL_PRECOND(nRes==osl_File_E_None, "inconsistent data");
 291 }
 292
 293 uno::Reference<rendering::XPolyPolygon2D> Parser::readPath()
 294 {
 295     const OString aSubPathMarker( "subpath" );
 296
 297     if( readNextToken() != aSubPathMarker )
 298         OSL_PRECOND(false, "broken path");
 299
 300     basegfx::B2DPolyPolygon aResult;
 301     while( m_nCharIndex != -1 )
 302     {
 303         basegfx::B2DPolygon aSubPath;
 304
 305         sal_Int32 nClosedFlag;
 306         readInt32( nClosedFlag );
 307         aSubPath.setClosed( nClosedFlag != 0 );
 308
 309         sal_Int32 nContiguousControlPoints(0);
 310         sal_Int32 nDummy=m_nCharIndex;
 311         OString aCurrToken( m_aLine.getToken(m_nNextToken,' ',nDummy) );
 312
 313         while( m_nCharIndex != -1 && aCurrToken != aSubPathMarker )
 314         {
 315             sal_Int32 nCurveFlag;
 316             double    nX, nY;
 317             readDouble( nX );
 318             readDouble( nY );
 319             readInt32(  nCurveFlag );
 320
 321             aSubPath.append(basegfx::B2DPoint(nX,nY));
 322             if( nCurveFlag )
 323             {
 324                 ++nContiguousControlPoints;
 325             }
 326             else if( nContiguousControlPoints )
 327             {
 328                 OSL_PRECOND(nContiguousControlPoints==2,"broken bezier path");
 329
 330                 // have two control points before us. the current one
 331                 // is a normal point - thus, convert previous points
 332                 // into bezier segment
 333                 const sal_uInt32 nPoints( aSubPath.count() );
 334                 const basegfx::B2DPoint aCtrlA( aSubPath.getB2DPoint(nPoints-3) );
 335                 const basegfx::B2DPoint aCtrlB( aSubPath.getB2DPoint(nPoints-2) );
 336                 const basegfx::B2DPoint aEnd( aSubPath.getB2DPoint(nPoints-1) );
 337                 aSubPath.remove(nPoints-3, 3);
 338                 aSubPath.appendBezierSegment(aCtrlA, aCtrlB, aEnd);
 339
 340                 nContiguousControlPoints=0;
 341             }
 342
 343             // one token look-ahead (new subpath or more points?
 344             nDummy=m_nCharIndex;
 345             aCurrToken = m_aLine.getToken(m_nNextToken,' ',nDummy);
 346         }
 347
 348         aResult.append( aSubPath );
 349         if( m_nCharIndex != -1 )
 350             readNextToken();
 351     }
 352
 353     return static_cast<rendering::XLinePolyPolygon2D*>(
 354         new basegfx::unotools::UnoPolyPolygon(aResult));
 355 }
 356
 357 void Parser::readChar()
 358 {
 359     double fontSize;
 360     geometry::Matrix2D aUnoMatrix;
 361     geometry::RealRectangle2D aRect;
 362
 363     readDouble(aRect.X1);
 364     readDouble(aRect.Y1);
 365     readDouble(aRect.X2);
 366     readDouble(aRect.Y2);
 367     readDouble(aUnoMatrix.m00);
 368     readDouble(aUnoMatrix.m01);
 369     readDouble(aUnoMatrix.m10);
 370     readDouble(aUnoMatrix.m11);
 371     readDouble(fontSize);
 372
 373     OString aChars;
 374
 375     if (m_nCharIndex != -1)
 376         aChars = lcl_unescapeLineFeeds( m_aLine.copy( m_nCharIndex ) );
 377
 378     // chars gobble up rest of line
 379     m_nCharIndex = -1;
 380
 381     m_pSink->drawGlyphs(OStringToOUString(aChars, RTL_TEXTENCODING_UTF8),
 382         aRect, aUnoMatrix, fontSize);
 383 }
 384
 385 void Parser::readLineCap()
 386 {
 387     sal_Int8 nCap(rendering::PathCapType::BUTT);
 388     switch( readInt32() )
 389     {
 390         default:
 391         case 0: nCap = rendering::PathCapType::BUTT; break;
 392         case 1: nCap = rendering::PathCapType::ROUND; break;
 393         case 2: nCap = rendering::PathCapType::SQUARE; break;
 394     }
 395     m_pSink->setLineCap(nCap);
 396 }
 397
 398 void Parser::readLineDash()
 399 {
 400     if( m_nCharIndex == -1 )
 401     {
 402         m_pSink->setLineDash( uno::Sequence<double>(), 0.0 );
 403         return;
 404     }
 405
 406     const double nOffset(readDouble());
 407     const sal_Int32 nLen(readInt32());
 408
 409     uno::Sequence<double> aDashArray(nLen);
 410     double* pArray=aDashArray.getArray();
 411     for( sal_Int32 i=0; i<nLen; ++i )
 412         *pArray++ = readDouble();
 413
 414     m_pSink->setLineDash( aDashArray, nOffset );
 415 }
 416
 417 void Parser::readLineJoin()
 418 {
 419     sal_Int8 nJoin(rendering::PathJoinType::MITER);
 420     switch( readInt32() )
 421     {
 422         default:
 423         case 0: nJoin = rendering::PathJoinType::MITER; break;
 424         case 1: nJoin = rendering::PathJoinType::ROUND; break;
 425         case 2: nJoin = rendering::PathJoinType::BEVEL; break;
 426     }
 427     m_pSink->setLineJoin(nJoin);
 428 }
 429
 430 void Parser::readTransformation()
 431 {
 432     geometry::AffineMatrix2D aMat;
 433     readDouble(aMat.m00);
 434     readDouble(aMat.m10);
 435     readDouble(aMat.m01);
 436     readDouble(aMat.m11);
 437     readDouble(aMat.m02);
 438     readDouble(aMat.m12);
 439     m_pSink->setTransformation( aMat );
 440 }
 441
 442 rendering::ARGBColor Parser::readColor()
 443 {
 444     rendering::ARGBColor aRes;
 445     readDouble(aRes.Red);
 446     readDouble(aRes.Green);
 447     readDouble(aRes.Blue);
 448     readDouble(aRes.Alpha);
 449     return aRes;
 450 }
 451
 452 sal_Int32 Parser::parseFontCheckForString(
 453     const sal_Unicode* pCopy, sal_Int32 nCopyLen,
 454     const char* pAttrib, sal_Int32 nAttribLen,
 455     FontAttributes& rResult, bool bItalic, bool bBold)
 456 {
 457     if (nCopyLen < nAttribLen)
 458         return 0;
 459     for (sal_Int32 i = 0; i < nAttribLen; ++i)
 460     {
 461         sal_uInt32 nCode = pAttrib[i];
 462         if (rtl::toAsciiLowerCase(pCopy[i]) != nCode
 463             && rtl::toAsciiUpperCase(pCopy[i]) != nCode)
 464             return 0;
 465     }
 466     rResult.isItalic |= bItalic;
 467     rResult.isBold |= bBold;
 468     return nAttribLen;
 469 }
 470
 471 sal_Int32 Parser::parseFontRemoveSuffix(
 472     const sal_Unicode* pCopy, sal_Int32 nCopyLen,
 473     const char* pAttrib, sal_Int32 nAttribLen)
 474 {
 475     if (nCopyLen < nAttribLen)
 476         return 0;
 477     for (sal_Int32 i = 0; i < nAttribLen; ++i)
 478         if ( pCopy[nCopyLen - nAttribLen + i] != pAttrib[i] )
 479             return 0;
 480     return nAttribLen;
 481 }
 482
 483 void Parser::parseFontFamilyName( FontAttributes& rResult )
 484 {
 485     OUStringBuffer aNewFamilyName( rResult.familyName.getLength() );
 486
 487     const sal_Unicode* pCopy = rResult.familyName.getStr();
 488     sal_Int32 nLen = rResult.familyName.getLength();
 489     // parse out truetype subsets (e.g. BAAAAA+Thorndale)
 490     if( nLen > 8 && pCopy[6] == '+' )
 491     {
 492         pCopy += 7;
 493         nLen -= 7;
 494     }
 495
 496     // TODO: Looks like this block needs to be refactored
 497     while( nLen )
 498     {
 499         if (parseFontRemoveSuffix(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("PSMT")))
 500         {
 501             nLen -= RTL_CONSTASCII_LENGTH("PSMT");
 502         }
 503         else if (parseFontRemoveSuffix(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("MT")))
 504         {
 505             nLen -= RTL_CONSTASCII_LENGTH("MT");
 506         }
 507
 508         if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("Italic"), rResult, true, false))
 509         {
 510             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("Italic");
 511             nLen -= nAttribLen;
 512             pCopy += nAttribLen;
 513         }
 514         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("-LightOblique"), rResult, true, false))
 515         {
 516             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("-LightOblique");
 517             nLen -= nAttribLen;
 518             pCopy += nAttribLen;
 519         }
 520         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("-Light"), rResult, false, false))
 521         {
 522             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("-Light");
 523             nLen -= nAttribLen;
 524             pCopy += nAttribLen;
 525         }
 526         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("-BoldOblique"), rResult, true, true))
 527         {
 528             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("-BoldOblique");
 529             nLen -= nAttribLen;
 530             pCopy += nAttribLen;
 531         }
 532         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("-Bold"), rResult, false, true))
 533         {
 534             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("-Bold");
 535             nLen -= nAttribLen;
 536             pCopy += nAttribLen;
 537         }
 538         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("Bold"), rResult, false, true))
 539         {
 540             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("Bold");
 541             nLen -= nAttribLen;
 542             pCopy += nAttribLen;
 543         }
 544         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("-Roman"), rResult, false, false))
 545         {
 546             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("-Roman");
 547             nLen -= nAttribLen;
 548             pCopy += nAttribLen;
 549         }
 550         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("-Oblique"), rResult, true, false))
 551         {
 552             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("-Oblique");
 553             nLen -= nAttribLen;
 554             pCopy += nAttribLen;
 555         }
 556         else if (parseFontCheckForString(pCopy, nLen, RTL_CONSTASCII_STRINGPARAM("-Reg"), rResult, false, false))
 557         {
 558             sal_Int32 nAttribLen = RTL_CONSTASCII_LENGTH("-Reg");
 559             nLen -= nAttribLen;
 560             pCopy += nAttribLen;
 561         }
 562         else if(nLen > 0)
 563         {
 564             if( *pCopy != '-' )
 565                 aNewFamilyName.append( *pCopy );
 566             pCopy++;
 567             nLen--;
 568         }
 569     }
 570     rResult.familyName = aNewFamilyName.makeStringAndClear();
 571 }
 572
 573 void Parser::readFont()
 574 {
 575     OString aFontName;
 576     sal_Int64      nFontID;
 577     sal_Int32      nIsEmbedded, nIsBold, nIsItalic, nIsUnderline, nFileLen;
 578     double         nSize;
 579
 580     readInt64(nFontID);
 581     readInt32(nIsEmbedded);
 582     readInt32(nIsBold);
 583     readInt32(nIsItalic);
 584     readInt32(nIsUnderline);
 585     readDouble(nSize);
 586     readInt32(nFileLen);
 587
 588     nSize = nSize < 0.0 ? -nSize : nSize;
 589     aFontName = lcl_unescapeLineFeeds( m_aLine.copy( m_nCharIndex ) );
 590
 591     // name gobbles up rest of line
 592     m_nCharIndex = -1;
 593
 594     FontMapType::const_iterator pFont( m_aFontMap.find(nFontID) );
 595     if( pFont != m_aFontMap.end() )
 596     {
 597         OSL_PRECOND(nFileLen==0,"font data for known font");
 598         FontAttributes aRes(pFont->second);
 599         aRes.size = nSize;
 600         m_pSink->setFont( aRes );
 601
 602         return;
 603     }
 604
 605     // yet unknown font - get info and add to map
 606     FontAttributes aResult( OStringToOUString( aFontName,
 607                                                     RTL_TEXTENCODING_UTF8 ),
 608                             nIsBold != 0,
 609                             nIsItalic != 0,
 610                             nIsUnderline != 0,
 611                             nSize,
 612                             1.0);
 613
 614     // extract textual attributes (bold, italic in the name, etc.)
 615     parseFontFamilyName(aResult);
 616     // need to read font file?
 617     if( nFileLen )
 618     {
 619         uno::Sequence<sal_Int8> aFontFile(nFileLen);
 620         readBinaryData( aFontFile );
 621
 622         awt::FontDescriptor aFD;
 623         uno::Sequence< uno::Any > aArgs(1);
 624         aArgs[0] <<= aFontFile;
 625
 626         try
 627         {
 628             uno::Reference< beans::XMaterialHolder > xMat(
 629                 m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
 630                     "com.sun.star.awt.FontIdentificator", aArgs, m_xContext ),
 631                 uno::UNO_QUERY );
 632             if( xMat.is() )
 633             {
 634                 uno::Any aRes( xMat->getMaterial() );
 635                 if( aRes >>= aFD )
 636                 {
 637                     if (!aFD.Name.isEmpty())
 638                     {
 639                         aResult.familyName = aFD.Name;
 640                         parseFontFamilyName(aResult);
 641                     }
 642                     aResult.isBold      = (aFD.Weight > 100.0);
 643                     aResult.isItalic    = (aFD.Slant == awt::FontSlant_OBLIQUE ||
 644                                            aFD.Slant == awt::FontSlant_ITALIC );
 645                     aResult.isUnderline = false;
 646                     aResult.size        = 0;
 647                 }
 648             }
 649         }
 650         catch( uno::Exception& )
 651         {
 652         }
 653
 654         if( aResult.familyName.isEmpty() )
 655         {
 656             // last fallback
 657             aResult.familyName  = "Arial";
 658             aResult.isUnderline = false;
 659         }
 660
 661     }
 662
 663     if (!m_xDev)
 664         m_xDev.disposeAndReset(VclPtr<VirtualDevice>::Create());
 665
 666     vcl::Font font(aResult.familyName, Size(0, 1000));
 667     m_xDev->SetFont(font);
 668     FontMetric metric(m_xDev->GetFontMetric());
 669     aResult.ascent = metric.GetAscent() / 1000.0;
 670
 671     m_aFontMap[nFontID] = aResult;
 672
 673     aResult.size = nSize;
 674     m_pSink->setFont(aResult);
 675 }
 676
 677 uno::Sequence<beans::PropertyValue> Parser::readImageImpl()
 678 {
 679     OString aToken = readNextToken();
 680     const sal_Int32 nImageSize( readInt32() );
 681
 682     OUString           aFileName;
 683     if( aToken == "PNG" )
 684         aFileName = "DUMMY.PNG";
 685     else if( aToken == "JPEG" )
 686         aFileName = "DUMMY.JPEG";
 687     else if( aToken == "PBM" )
 688         aFileName = "DUMMY.PBM";
 689     else
 690     {
 691         SAL_WARN_IF(aToken != "PPM","sdext.pdfimport","Invalid bitmap format");
 692         aFileName = "DUMMY.PPM";
 693     }
 694
 695     uno::Sequence<sal_Int8> aDataSequence(nImageSize);
 696     readBinaryData( aDataSequence );
 697
 698     uno::Sequence< uno::Any > aStreamCreationArgs(1);
 699     aStreamCreationArgs[0] <<= aDataSequence;
 700
 701     uno::Reference< uno::XComponentContext > xContext( m_xContext, uno::UNO_SET_THROW );
 702     uno::Reference< lang::XMultiComponentFactory > xFactory( xContext->getServiceManager(), uno::UNO_SET_THROW );
 703     uno::Reference< io::XInputStream > xDataStream(
 704         xFactory->createInstanceWithArgumentsAndContext( "com.sun.star.io.SequenceInputStream", aStreamCreationArgs, m_xContext ),
 705         uno::UNO_QUERY_THROW );
 706
 707     uno::Sequence<beans::PropertyValue> aSequence( comphelper::InitPropertySequence({
 708             { "URL", uno::makeAny(aFileName) },
 709             { "InputStream", uno::makeAny( xDataStream ) },
 710             { "InputSequence", uno::makeAny(aDataSequence) }
 711         }));
 712
 713     return aSequence;
 714 }
 715
 716 void Parser::readImage()
 717 {
 718     sal_Int32 nWidth, nHeight,nMaskColors;
 719     readInt32(nWidth);
 720     readInt32(nHeight);
 721     readInt32(nMaskColors);
 722
 723     uno::Sequence<beans::PropertyValue> aImg( readImageImpl() );
 724
 725     if( nMaskColors )
 726     {
 727         uno::Sequence<sal_Int8> aDataSequence(nMaskColors);
 728         readBinaryData( aDataSequence );
 729
 730         uno::Sequence<uno::Any> aMaskRanges(2);
 731
 732         uno::Sequence<double> aMinRange(nMaskColors/2);
 733         uno::Sequence<double> aMaxRange(nMaskColors/2);
 734         for( sal_Int32 i=0; i<nMaskColors/2; ++i )
 735         {
 736             aMinRange[i] = aDataSequence[i] / 255.0;
 737             aMaxRange[i] = aDataSequence[i+nMaskColors/2] / 255.0;
 738         }
 739
 740         aMaskRanges[0] <<= aMinRange;
 741         aMaskRanges[1] <<= aMaxRange;
 742
 743         m_pSink->drawColorMaskedImage( aImg, aMaskRanges );
 744     }
 745     else
 746         m_pSink->drawImage( aImg );
 747 }
 748
 749 void Parser::readMask()
 750 {
 751     sal_Int32 nWidth, nHeight, nInvert;
 752     readInt32(nWidth);
 753     readInt32(nHeight);
 754     readInt32(nInvert);
 755
 756     m_pSink->drawMask( readImageImpl(), nInvert != 0);
 757 }
 758
 759 void Parser::readLink()
 760 {
 761     geometry::RealRectangle2D aBounds;
 762     readDouble(aBounds.X1);
 763     readDouble(aBounds.Y1);
 764     readDouble(aBounds.X2);
 765     readDouble(aBounds.Y2);
 766
 767     m_pSink->hyperLink( aBounds,
 768                         OStringToOUString( lcl_unescapeLineFeeds(
 769                                 m_aLine.copy(m_nCharIndex) ),
 770                                 RTL_TEXTENCODING_UTF8 ) );
 771     // name gobbles up rest of line
 772     m_nCharIndex = -1;
 773 }
 774
 775 void Parser::readMaskedImage()
 776 {
 777     sal_Int32 nWidth, nHeight, nMaskWidth, nMaskHeight, nMaskInvert;
 778     readInt32(nWidth);
 779     readInt32(nHeight);
 780     readInt32(nMaskWidth);
 781     readInt32(nMaskHeight);
 782     readInt32(nMaskInvert);
 783
 784     const uno::Sequence<beans::PropertyValue> aImage( readImageImpl() );
 785     const uno::Sequence<beans::PropertyValue> aMask ( readImageImpl() );
 786     m_pSink->drawMaskedImage( aImage, aMask, nMaskInvert != 0 );
 787 }
 788
 789 void Parser::readSoftMaskedImage()
 790 {
 791     sal_Int32 nWidth, nHeight, nMaskWidth, nMaskHeight;
 792     readInt32(nWidth);
 793     readInt32(nHeight);
 794     readInt32(nMaskWidth);
 795     readInt32(nMaskHeight);
 796
 797     const uno::Sequence<beans::PropertyValue> aImage( readImageImpl() );
 798     const uno::Sequence<beans::PropertyValue> aMask ( readImageImpl() );
 799     m_pSink->drawAlphaMaskedImage( aImage, aMask );
 800 }
 801
 802 void Parser::parseLine( const OString& rLine )
 803 {
 804     OSL_PRECOND( m_pSink,         "Invalid sink" );
 805     OSL_PRECOND( m_pErr,          "Invalid filehandle" );
 806     OSL_PRECOND( m_xContext.is(), "Invalid service factory" );
 807
 808     m_nNextToken = 0; m_nCharIndex = 0; m_aLine = rLine;
 809     const OString& rCmd = readNextToken();
 810     const hash_entry* pEntry = PdfKeywordHash::in_word_set( rCmd.getStr(),
 811                                                             rCmd.getLength() );
 812     OSL_ASSERT(pEntry);
 813     switch( pEntry->eKey )
 814     {
 815         case CLIPPATH:
 816             m_pSink->intersectClip(readPath()); break;
 817         case DRAWCHAR:
 818             readChar(); break;
 819         case DRAWIMAGE:
 820             readImage(); break;
 821         case DRAWLINK:
 822             readLink(); break;
 823         case DRAWMASK:
 824             readMask(); break;
 825         case DRAWMASKEDIMAGE:
 826             readMaskedImage(); break;
 827         case DRAWSOFTMASKEDIMAGE:
 828             readSoftMaskedImage(); break;
 829         case ENDPAGE:
 830             m_pSink->endPage(); break;
 831         case ENDTEXTOBJECT:
 832             m_pSink->endText(); break;
 833         case EOCLIPPATH:
 834             m_pSink->intersectEoClip(readPath()); break;
 835         case EOFILLPATH:
 836             m_pSink->eoFillPath(readPath()); break;
 837         case FILLPATH:
 838             m_pSink->fillPath(readPath()); break;
 839         case RESTORESTATE:
 840             m_pSink->popState(); break;
 841         case SAVESTATE:
 842             m_pSink->pushState(); break;
 843         case SETPAGENUM:
 844             m_pSink->setPageNum( readInt32() ); break;
 845         case STARTPAGE:
 846         {
 847             const double nWidth ( readDouble() );
 848             const double nHeight( readDouble() );
 849             m_pSink->startPage( geometry::RealSize2D( nWidth, nHeight ) );
 850             break;
 851         }
 852         case STROKEPATH:
 853             m_pSink->strokePath(readPath()); break;
 854         case UPDATECTM:
 855             readTransformation(); break;
 856         case UPDATEFILLCOLOR:
 857             m_pSink->setFillColor( readColor() ); break;
 858         case UPDATEFLATNESS:
 859             m_pSink->setFlatness( readDouble( ) ); break;
 860         case UPDATEFONT:
 861             readFont(); break;
 862         case UPDATELINECAP:
 863             readLineCap(); break;
 864         case UPDATELINEDASH:
 865             readLineDash(); break;
 866         case UPDATELINEJOIN:
 867             readLineJoin(); break;
 868         case UPDATELINEWIDTH:
 869             m_pSink->setLineWidth( readDouble() );break;
 870         case UPDATEMITERLIMIT:
 871             m_pSink->setMiterLimit( readDouble() ); break;
 872         case UPDATESTROKECOLOR:
 873             m_pSink->setStrokeColor( readColor() ); break;
 874         case UPDATESTROKEOPACITY:
 875             break;
 876         case SETTEXTRENDERMODE:
 877             m_pSink->setTextRenderMode( readInt32() ); break;
 878
 879         case NONE:
 880         default:
 881             OSL_PRECOND(false,"Unknown input");
 882             break;
 883     }
 884
 885     // all consumed?
 886     SAL_WARN_IF(m_nCharIndex!=-1, "sdext.pdfimport", "leftover scanner input");
 887 }
 888
 889 } // namespace
 890
 891 static bool checkEncryption( const OUString&                               i_rPath,
 892                              const uno::Reference< task::XInteractionHandler >& i_xIHdl,
 893                              OUString&                                     io_rPwd,
 894                              bool&                                              o_rIsEncrypted,
 895                              const OUString&                               i_rDocName
 896                              )
 897 {
 898     bool bSuccess = false;
 899     OString aPDFFile = OUStringToOString( i_rPath, osl_getThreadTextEncoding() );
 900
 901     std::unique_ptr<pdfparse::PDFEntry> pEntry( pdfparse::PDFReader::read( aPDFFile.getStr() ));
 902     if( pEntry )
 903     {
 904         pdfparse::PDFFile* pPDFFile = dynamic_cast<pdfparse::PDFFile*>(pEntry.get());
 905         if( pPDFFile )
 906         {
 907             o_rIsEncrypted = pPDFFile->isEncrypted();
 908             if( o_rIsEncrypted )
 909             {
 910                 if( pPDFFile->usesSupportedEncryptionFormat() )
 911                 {
 912                     bool bAuthenticated = false;
 913                     if( !io_rPwd.isEmpty() )
 914                     {
 915                         OString aIsoPwd = OUStringToOString( io_rPwd,
 916                                                                        RTL_TEXTENCODING_ISO_8859_1 );
 917                         bAuthenticated = pPDFFile->setupDecryptionData( aIsoPwd.getStr() );
 918                     }
 919                     if( bAuthenticated )
 920                         bSuccess = true;
 921                     else
 922                     {
 923                         if( i_xIHdl.is() )
 924                         {
 925                             bool bEntered = false;
 926                             do
 927                             {
 928                                 bEntered = getPassword( i_xIHdl, io_rPwd, ! bEntered, i_rDocName );
 929                                 OString aIsoPwd = OUStringToOString( io_rPwd,
 930                                                                                RTL_TEXTENCODING_ISO_8859_1 );
 931                                 bAuthenticated = pPDFFile->setupDecryptionData( aIsoPwd.getStr() );
 932                             } while( bEntered && ! bAuthenticated );
 933                         }
 934
 935                         bSuccess = bAuthenticated;
 936                     }
 937                 }
 938                 else if( i_xIHdl.is() )
 939                 {
 940                     reportUnsupportedEncryptionFormat( i_xIHdl );
 941                         //TODO: this should either be handled further down the
 942                         // call stack, or else information that this has already
 943                         // been handled should be passed down the call stack, so
 944                         // that SfxBaseModel::load does not show an additional
 945                         // "General Error" message box
 946                 }
 947             }
 948             else
 949                 bSuccess = true;
 950         }
 951     }
 952     return bSuccess;
 953 }
 954
 955 class Buffering
 956 {
 957     static const int SIZE = 64*1024;
 958     std::unique_ptr<char[]> aBuffer;
 959     oslFileHandle& pOut;
 960     size_t pos;
 961     sal_uInt64 left;
 962
 963 public:
 964     explicit Buffering(oslFileHandle& out) : aBuffer(new char[SIZE]), pOut(out), pos(0), left(0) {}
 965
 966     oslFileError read(char *pChar, short count, sal_uInt64* pBytesRead)
 967     {
 968         oslFileError nRes = osl_File_E_None;
 969         sal_uInt64 nBytesRead = 0;
 970         while (count > 0)
 971         {
 972             if (left == 0)
 973             {
 974                 nRes = osl_readFile(pOut, aBuffer.get(), SIZE, &left);
 975                 if (nRes != osl_File_E_None || left == 0)
 976                 {
 977                     *pBytesRead = nBytesRead;
 978                     return nRes;
 979                 }
 980                 pos = 0;
 981             }
 982             *pChar = aBuffer.get()[pos];
 983             --count;
 984             ++pos;
 985             --left;
 986             ++pChar;
 987             ++nBytesRead;
 988         }
 989         *pBytesRead = nBytesRead;
 990         return osl_File_E_None;
 991     }
 992 };
 993
 994 bool xpdf_ImportFromFile(const OUString& rURL,
 995                          const ContentSinkSharedPtr& rSink,
 996                          const uno::Reference<task::XInteractionHandler>& xIHdl,
 997                          const OUString& rPwd,
 998                          const uno::Reference<uno::XComponentContext>& xContext,
 999                          const OUString& rFilterOptions)
1000 {
1001     OSL_ASSERT(rSink);
1002
1003     OUString aSysUPath;
1004     if( osl_getSystemPathFromFileURL( rURL.pData, &aSysUPath.pData ) != osl_File_E_None )
1005     {
1006         SAL_WARN(
1007             "sdext.pdfimport",
1008             "getSystemPathFromFileURL(" << rURL << ") failed");
1009         return false;
1010     }
1011     OUString aDocName( rURL.copy( rURL.lastIndexOf( '/' )+1 ) );
1012
1013     // check for encryption, if necessary get password
1014     OUString aPwd( rPwd );
1015     bool bIsEncrypted = false;
1016     if( !checkEncryption( aSysUPath, xIHdl, aPwd, bIsEncrypted, aDocName ) )
1017     {
1018         SAL_INFO(
1019             "sdext.pdfimport",
1020             "checkEncryption(" << aSysUPath << ") failed");
1021         return false;
1022     }
1023
1024     // Determine xpdfimport executable URL:
1025     OUString converterURL("$BRAND_BASE_DIR/" LIBO_BIN_FOLDER "/xpdfimport");
1026     rtl::Bootstrap::expandMacros(converterURL); //TODO: detect failure
1027
1028     // Determine pathname of xpdfimport_err.pdf:
1029     OUString errPathname("$BRAND_BASE_DIR/" LIBO_SHARE_FOLDER "/xpdfimport/xpdfimport_err.pdf");
1030     rtl::Bootstrap::expandMacros(errPathname); //TODO: detect failure
1031     if (osl::FileBase::getSystemPathFromFileURL(errPathname, errPathname)
1032         != osl::FileBase::E_None)
1033     {
1034         SAL_WARN(
1035             "sdext.pdfimport",
1036             "getSystemPathFromFileURL(" << errPathname << ") failed");
1037         return false;
1038     }
1039
1040     // spawn separate process to keep LGPL/GPL code apart.
1041
1042     OUString aOptFlag("-o");
1043     rtl_uString*  args[] = { aSysUPath.pData, errPathname.pData,
1044                              aOptFlag.pData, rFilterOptions.pData };
1045     sal_Int32 nArgs = rFilterOptions.isEmpty() ? 2 : 4;
1046
1047     oslProcess    aProcess;
1048     oslFileHandle pIn  = nullptr;
1049     oslFileHandle pOut = nullptr;
1050     oslFileHandle pErr = nullptr;
1051     oslSecurity pSecurity = osl_getCurrentSecurity ();
1052     oslProcessError eErr =
1053         osl_executeProcess_WithRedirectedIO(converterURL.pData,
1054                                             args,
1055                                             nArgs,
1056                                             osl_Process_SEARCHPATH|osl_Process_HIDDEN,
1057                                             pSecurity,
1058                                             nullptr, nullptr, 0,
1059                                             &aProcess, &pIn, &pOut, &pErr);
1060     osl_freeSecurityHandle(pSecurity);
1061
1062     bool bRet=true;
1063     try
1064     {
1065         if( eErr!=osl_Process_E_None )
1066         {
1067             SAL_WARN(
1068                 "sdext.pdfimport",
1069                 "executeProcess of " << converterURL << " failed with "
1070                     << +eErr);
1071             return false;
1072         }
1073
1074         if( pIn )
1075         {
1076             OStringBuffer aBuf(256);
1077             if( bIsEncrypted )
1078                 aBuf.append( OUStringToOString( aPwd, RTL_TEXTENCODING_ISO_8859_1 ) );
1079             aBuf.append( '\n' );
1080
1081             sal_uInt64 nWritten = 0;
1082             osl_writeFile( pIn, aBuf.getStr(), sal_uInt64(aBuf.getLength()), &nWritten );
1083         }
1084
1085         if( pOut && pErr )
1086         {
1087             // read results of PDF parser. One line - one call to
1088             // OutputDev. stderr is used for alternate streams, like
1089             // embedded fonts and bitmaps
1090             Parser aParser(rSink,pErr,xContext);
1091             Buffering aBuffering(pOut);
1092             OStringBuffer line;
1093             for( ;; )
1094             {
1095                 char aChar('\n');
1096                 sal_uInt64 nBytesRead;
1097                 oslFileError nRes;
1098
1099                 // skip garbage \r \n at start of line
1100                 while( osl_File_E_None == (nRes = aBuffering.read(&aChar, 1, &nBytesRead)) &&
1101                        nBytesRead == 1 &&
1102                        (aChar == '\n' || aChar == '\r') ) ;
1103                 if ( osl_File_E_None != nRes )
1104                     break;
1105
1106                 if( aChar != '\n' && aChar != '\r' )
1107                     line.append( aChar );
1108
1109                 while( osl_File_E_None == (nRes = aBuffering.read(&aChar, 1, &nBytesRead)) &&
1110                        nBytesRead == 1 && aChar != '\n' && aChar != '\r' )
1111                 {
1112                     line.append( aChar );
1113                 }
1114                 if ( osl_File_E_None != nRes )
1115                     break;
1116                 if ( line.isEmpty() )
1117                     break;
1118
1119                 aParser.parseLine(line.makeStringAndClear());
1120             }
1121         }
1122     }
1123     catch( uno::Exception& )
1124     {
1125         // crappy C file interface. need manual resource dealloc
1126         bRet = false;
1127     }
1128
1129     if( pIn )
1130         osl_closeFile(pIn);
1131     if( pOut )
1132         osl_closeFile(pOut);
1133     if( pErr )
1134         osl_closeFile(pErr);
1135     eErr = osl_joinProcess(aProcess);
1136     if (eErr == osl_Process_E_None)
1137     {
1138         oslProcessInfo info;
1139         info.Size = sizeof info;
1140         eErr = osl_getProcessInfo(aProcess, osl_Process_EXITCODE, &info);
1141         if (eErr == osl_Process_E_None)
1142         {
1143             if (info.Code != 0)
1144             {
1145                 SAL_WARN(
1146                     "sdext.pdfimport",
1147                     "getProcessInfo of " << converterURL
1148                         << " failed with exit code " << info.Code);
1149                 bRet = false;
1150             }
1151         }
1152         else
1153         {
1154             SAL_WARN(
1155                 "sdext.pdfimport",
1156                 "getProcessInfo of " << converterURL << " failed with "
1157                     << +eErr);
1158             bRet = false;
1159         }
1160     }
1161     else
1162     {
1163         SAL_WARN(
1164             "sdext.pdfimport",
1165             "joinProcess of " << converterURL << " failed with " << +eErr);
1166         bRet = false;
1167     }
1168     osl_freeProcessHandle(aProcess);
1169     return bRet;
1170 }
1171
1172
1173 bool xpdf_ImportFromStream( const uno::Reference< io::XInputStream >&         xInput,
1174                             const ContentSinkSharedPtr&                       rSink,
1175                             const uno::Reference<task::XInteractionHandler >& xIHdl,
1176                             const OUString&                              rPwd,
1177                             const uno::Reference< uno::XComponentContext >&   xContext,
1178                             const OUString&                                   rFilterOptions )
1179 {
1180     OSL_ASSERT(xInput.is());
1181     OSL_ASSERT(rSink);
1182
1183     // convert XInputStream to local temp file
1184     oslFileHandle aFile = nullptr;
1185     OUString aURL;
1186     if( osl_createTempFile( nullptr, &aFile, &aURL.pData ) != osl_File_E_None )
1187         return false;
1188
1189     // copy content, buffered...
1190     const sal_uInt32 nBufSize = 4096;
1191     uno::Sequence<sal_Int8> aBuf( nBufSize );
1192     sal_uInt64 nBytes = 0;
1193     sal_uInt64 nWritten = 0;
1194     bool bSuccess = true;
1195     do
1196     {
1197         try
1198         {
1199             nBytes = xInput->readBytes( aBuf, nBufSize );
1200         }
1201         catch( css::uno::Exception& )
1202         {
1203             osl_closeFile( aFile );
1204             throw;
1205         }
1206         if( nBytes > 0 )
1207         {
1208             osl_writeFile( aFile, aBuf.getConstArray(), nBytes, &nWritten );
1209             if( nWritten != nBytes )
1210             {
1211                 bSuccess = false;
1212                 break;
1213             }
1214         }
1215     }
1216     while( nBytes == nBufSize );
1217
1218     osl_closeFile( aFile );
1219
1220     if ( bSuccess )
1221         bSuccess = xpdf_ImportFromFile( aURL, rSink, xIHdl, rPwd, xContext, rFilterOptions );
1222     osl_removeFile( aURL.pData );
1223
1224     return bSuccess;
1225 }
1226
1227 }
1228
1229 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */