vcl/generic/print/glyphset.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
  21 #include "glyphset.hxx"
  22 #include "psputil.hxx"
  23
  24 #include "sft.hxx"
  25
  26 #include "generic/printergfx.hxx"
  27 #include "fontsubset.hxx"
  28 #include "vcl/fontmanager.hxx"
  29
  30 #include "osl/thread.h"
  31
  32 #include "sal/alloca.h"
  33
  34 #include "rtl/ustring.hxx"
  35 #include "rtl/strbuf.hxx"
  36
  37 #include <set>
  38 #include <map>
  39 #include <algorithm>
  40
  41 using namespace vcl;
  42 using namespace psp;
  43
  44 using ::rtl::OUString;
  45 using ::rtl::OString;
  46 using ::rtl::OStringBuffer;
  47 using ::rtl::OUStringToOString;
  48
  49 GlyphSet::GlyphSet (sal_Int32 nFontID, sal_Bool bVertical)
  50         : mnFontID (nFontID),
  51           mbVertical (bVertical)
  52 {
  53     PrintFontManager &rMgr = PrintFontManager::get();
  54     meBaseType          = rMgr.getFontType (mnFontID);
  55     maBaseName          = OUStringToOString (rMgr.getPSName(mnFontID),
  56                                            RTL_TEXTENCODING_ASCII_US);
  57     mnBaseEncoding      = rMgr.getFontEncoding(mnFontID);
  58     mbUseFontEncoding   = rMgr.getUseOnlyFontEncoding(mnFontID);
  59 }
  60
  61 GlyphSet::~GlyphSet ()
  62 {
  63     /* FIXME delete the glyphlist ??? */
  64 }
  65
  66 sal_Int32
  67 GlyphSet::GetFontID ()
  68 {
  69     return mnFontID;
  70 }
  71
  72 fonttype::type
  73 GlyphSet::GetFontType ()
  74 {
  75     return meBaseType;
  76 }
  77
  78 sal_Bool
  79 GlyphSet::IsVertical ()
  80 {
  81     return mbVertical;
  82 }
  83
  84 sal_Bool
  85 GlyphSet::GetCharID (
  86                      sal_Unicode nChar,
  87                      sal_uChar* nOutGlyphID,
  88                      sal_Int32* nOutGlyphSetID
  89                      )
  90 {
  91     return    LookupCharID (nChar, nOutGlyphID, nOutGlyphSetID)
  92            || AddCharID    (nChar, nOutGlyphID, nOutGlyphSetID);
  93 }
  94
  95 sal_Bool
  96 GlyphSet::GetGlyphID (
  97                       sal_uInt32 nGlyph,
  98                       sal_Unicode nUnicode,
  99                       sal_uChar* nOutGlyphID,
 100                       sal_Int32* nOutGlyphSetID
 101                      )
 102 {
 103     return    LookupGlyphID (nGlyph, nOutGlyphID, nOutGlyphSetID)
 104            || AddGlyphID    (nGlyph, nUnicode, nOutGlyphID, nOutGlyphSetID);
 105 }
 106
 107 sal_Bool
 108 GlyphSet::LookupCharID (
 109                         sal_Unicode nChar,
 110                         sal_uChar* nOutGlyphID,
 111                         sal_Int32* nOutGlyphSetID
 112                         )
 113 {
 114     char_list_t::iterator aGlyphSet;
 115     sal_Int32             nGlyphSetID;
 116
 117     // loop thru all the font subsets
 118     for (aGlyphSet  = maCharList.begin(), nGlyphSetID = 1;
 119          aGlyphSet != maCharList.end();
 120          ++aGlyphSet, nGlyphSetID++)
 121     {
 122         // check every subset if it contains the queried unicode char
 123         char_map_t::const_iterator aGlyph = (*aGlyphSet).find (nChar);
 124         if (aGlyph != (*aGlyphSet).end())
 125         {
 126             // success: found the unicode char, return the glyphid and the glyphsetid
 127             *nOutGlyphSetID = nGlyphSetID;
 128             *nOutGlyphID    = (*aGlyph).second;
 129             return sal_True;
 130         }
 131     }
 132
 133     *nOutGlyphSetID = -1;
 134     *nOutGlyphID    =  0;
 135     return sal_False;
 136 }
 137
 138 sal_Bool
 139 GlyphSet::LookupGlyphID (
 140                         sal_uInt32 nGlyph,
 141                         sal_uChar* nOutGlyphID,
 142                         sal_Int32* nOutGlyphSetID
 143                         )
 144 {
 145     glyph_list_t::iterator aGlyphSet;
 146     sal_Int32             nGlyphSetID;
 147
 148     // loop thru all the font subsets
 149     for (aGlyphSet  = maGlyphList.begin(), nGlyphSetID = 1;
 150          aGlyphSet != maGlyphList.end();
 151          ++aGlyphSet, nGlyphSetID++)
 152     {
 153         // check every subset if it contains the queried unicode char
 154         glyph_map_t::const_iterator aGlyph = (*aGlyphSet).find (nGlyph);
 155         if (aGlyph != (*aGlyphSet).end())
 156         {
 157             // success: found the glyph id, return the mapped glyphid and the glyphsetid
 158             *nOutGlyphSetID = nGlyphSetID;
 159             *nOutGlyphID    = (*aGlyph).second;
 160             return sal_True;
 161         }
 162     }
 163
 164     *nOutGlyphSetID = -1;
 165     *nOutGlyphID    =  0;
 166     return sal_False;
 167 }
 168
 169 sal_uChar
 170 GlyphSet::GetAnsiMapping (sal_Unicode nUnicodeChar)
 171 {
 172     static rtl_UnicodeToTextConverter aConverter =
 173                 rtl_createUnicodeToTextConverter(RTL_TEXTENCODING_MS_1252);
 174     static rtl_UnicodeToTextContext aContext =
 175              rtl_createUnicodeToTextContext( aConverter );
 176
 177     sal_Char            nAnsiChar;
 178     sal_uInt32          nCvtInfo;
 179     sal_Size            nCvtChars;
 180        const sal_uInt32    nCvtFlags =  RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR
 181                                    | RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR;
 182
 183     sal_Size nSize = rtl_convertUnicodeToText( aConverter, aContext,
 184                 &nUnicodeChar, 1, &nAnsiChar, 1,
 185                 nCvtFlags, &nCvtInfo, &nCvtChars );
 186
 187     return nSize == 1 ? (sal_uChar)nAnsiChar : (sal_uChar)0;
 188 }
 189
 190 sal_uChar
 191 GlyphSet::GetSymbolMapping (sal_Unicode nUnicodeChar)
 192 {
 193     if (0x0000 < nUnicodeChar && nUnicodeChar < 0x0100)
 194         return (sal_uChar)nUnicodeChar;
 195     if (0xf000 < nUnicodeChar && nUnicodeChar < 0xf100)
 196         return (sal_uChar)nUnicodeChar;
 197
 198     return 0;
 199 }
 200
 201 void
 202 GlyphSet::AddNotdef (char_map_t &rCharMap)
 203 {
 204     if (rCharMap.empty())
 205         rCharMap[0] = 0;
 206 }
 207
 208 void
 209 GlyphSet::AddNotdef (glyph_map_t &rGlyphMap)
 210 {
 211     if (rGlyphMap.empty())
 212         rGlyphMap[0] = 0;
 213 }
 214 sal_Bool
 215 GlyphSet::AddCharID (
 216                      sal_Unicode nChar,
 217                      sal_uChar* nOutGlyphID,
 218                      sal_Int32* nOutGlyphSetID
 219                      )
 220 {
 221     sal_uChar nMappedChar;
 222
 223     // XXX important: avoid to reencode type1 symbol fonts
 224     if (mnBaseEncoding == RTL_TEXTENCODING_SYMBOL)
 225         nMappedChar = GetSymbolMapping (nChar);
 226     else
 227         nMappedChar = GetAnsiMapping (nChar);
 228
 229     // create an empty glyphmap that is reserved for iso1252 encoded glyphs
 230     // (or -- unencoded -- symbol glyphs) and a second map that takes any other
 231     if (maCharList.empty())
 232     {
 233         char_map_t aMap, aMapp;
 234
 235         maCharList.push_back (aMap);
 236         maCharList.push_back (aMapp);
 237     }
 238     // if the last map is full, create a new one
 239     if ((!nMappedChar) && (maCharList.back().size() == 255))
 240     {
 241         char_map_t aMap;
 242         maCharList.push_back (aMap);
 243     }
 244
 245     // insert a new glyph in the font subset
 246     if (nMappedChar)
 247     {
 248         // always put iso1252 chars into the first map, map them on itself
 249         char_map_t& aGlyphSet = maCharList.front();
 250         AddNotdef (aGlyphSet);
 251
 252         aGlyphSet [nChar] = nMappedChar;
 253         *nOutGlyphSetID   = 1;
 254         *nOutGlyphID      = nMappedChar;
 255     }
 256     else
 257     {
 258         // other chars are just appended to the list
 259         char_map_t& aGlyphSet = maCharList.back();
 260         AddNotdef (aGlyphSet);
 261
 262         int nSize         = aGlyphSet.size();
 263
 264         aGlyphSet [nChar] = nSize;
 265         *nOutGlyphSetID   = maCharList.size();
 266         *nOutGlyphID      = aGlyphSet [nChar];
 267     }
 268
 269     return sal_True;
 270 }
 271
 272 sal_Bool
 273 GlyphSet::AddGlyphID (
 274                      sal_uInt32 nGlyph,
 275                      sal_Unicode nUnicode,
 276                      sal_uChar* nOutGlyphID,
 277                      sal_Int32* nOutGlyphSetID
 278                      )
 279 {
 280     sal_uChar nMappedChar;
 281
 282     // XXX important: avoid to reencode type1 symbol fonts
 283     if (mnBaseEncoding == RTL_TEXTENCODING_SYMBOL)
 284         nMappedChar = GetSymbolMapping (nUnicode);
 285     else
 286         nMappedChar = GetAnsiMapping (nUnicode);
 287
 288     // create an empty glyphmap that is reserved for iso1252 encoded glyphs
 289     // (or -- unencoded -- symbol glyphs) and a second map that takes any other
 290     if (maGlyphList.empty())
 291     {
 292         glyph_map_t aMap, aMapp;
 293
 294         maGlyphList.push_back (aMap);
 295         maGlyphList.push_back (aMapp);
 296     }
 297     // if the last map is full, create a new one
 298     if ((!nMappedChar) && (maGlyphList.back().size() == 255))
 299     {
 300         glyph_map_t aMap;
 301         maGlyphList.push_back (aMap);
 302     }
 303
 304     // insert a new glyph in the font subset
 305     if (nMappedChar)
 306     {
 307         // always put iso1252 chars into the first map, map them on itself
 308         glyph_map_t& aGlyphSet = maGlyphList.front();
 309         AddNotdef (aGlyphSet);
 310
 311         aGlyphSet [nGlyph] = nMappedChar;
 312         *nOutGlyphSetID    = 1;
 313         *nOutGlyphID       = nMappedChar;
 314     }
 315     else
 316     {
 317         // other chars are just appended to the list
 318         glyph_map_t& aGlyphSet = maGlyphList.back();
 319         AddNotdef (aGlyphSet);
 320
 321         int nSize         = aGlyphSet.size();
 322
 323         aGlyphSet [nGlyph] = nSize;
 324         *nOutGlyphSetID   = maGlyphList.size();
 325         *nOutGlyphID      = aGlyphSet [nGlyph];
 326     }
 327
 328     return sal_True;
 329 }
 330
 331 OString
 332 GlyphSet::GetCharSetName (sal_Int32 nGlyphSetID)
 333 {
 334     if (meBaseType == fonttype::TrueType)
 335     {
 336         OStringBuffer aSetName( maBaseName.getLength() + 32 );
 337         aSetName.append( maBaseName );
 338         aSetName.append( "FID" );
 339         aSetName.append( mnFontID );
 340         aSetName.append( mbVertical ? "VCSet" : "HCSet" );
 341         aSetName.append( nGlyphSetID );
 342         return aSetName.makeStringAndClear();
 343     }
 344     else
 345     /* (meBaseType == fonttype::Type1 || meBaseType == fonttype::Builtin) */
 346     {
 347         return maBaseName;
 348     }
 349 }
 350
 351 OString
 352 GlyphSet::GetGlyphSetName (sal_Int32 nGlyphSetID)
 353 {
 354     if (meBaseType == fonttype::TrueType)
 355     {
 356         OStringBuffer aSetName( maBaseName.getLength() + 32 );
 357         aSetName.append( maBaseName );
 358         aSetName.append( "FID" );
 359         aSetName.append( mnFontID );
 360         aSetName.append( mbVertical ? "VGSet" : "HGSet" );
 361         aSetName.append( nGlyphSetID );
 362         return aSetName.makeStringAndClear();
 363     }
 364     else
 365     /* (meBaseType == fonttype::Type1 || meBaseType == fonttype::Builtin) */
 366     {
 367         return maBaseName;
 368     }
 369 }
 370
 371 sal_Int32
 372 GlyphSet::GetGlyphSetEncoding (sal_Int32 nGlyphSetID)
 373 {
 374     if (meBaseType == fonttype::TrueType)
 375         return RTL_TEXTENCODING_DONTKNOW;
 376     else
 377     {
 378     /* (meBaseType == fonttype::Type1 || meBaseType == fonttype::Builtin) */
 379         if (mnBaseEncoding == RTL_TEXTENCODING_SYMBOL)
 380             return RTL_TEXTENCODING_SYMBOL;
 381         else
 382             return nGlyphSetID == 1 ? RTL_TEXTENCODING_MS_1252
 383                                     : RTL_TEXTENCODING_USER_START + nGlyphSetID;
 384     }
 385 }
 386
 387 OString
 388 GlyphSet::GetGlyphSetEncodingName (rtl_TextEncoding nEnc, const OString &rFontName)
 389 {
 390     if (   nEnc == RTL_TEXTENCODING_MS_1252
 391         || nEnc == RTL_TEXTENCODING_ISO_8859_1)
 392     {
 393         return OString("ISO1252Encoding");
 394     }
 395     else
 396     if (nEnc >= RTL_TEXTENCODING_USER_START && nEnc <= RTL_TEXTENCODING_USER_END)
 397     {
 398         return  rFontName
 399                 + OString("Enc")
 400                 + OString::valueOf ((sal_Int32)(nEnc - RTL_TEXTENCODING_USER_START));
 401     }
 402     else
 403     {
 404         return OString();
 405     }
 406 }
 407
 408 OString
 409 GlyphSet::GetGlyphSetEncodingName (sal_Int32 nGlyphSetID)
 410 {
 411     return GetGlyphSetEncodingName (GetGlyphSetEncoding(nGlyphSetID), maBaseName);
 412 }
 413
 414 void
 415 GlyphSet::PSDefineReencodedFont (osl::File* pOutFile, sal_Int32 nGlyphSetID)
 416 {
 417     // only for ps fonts
 418     if ((meBaseType != fonttype::Builtin) && (meBaseType != fonttype::Type1))
 419         return;
 420
 421     sal_Char  pEncodingVector [256];
 422     sal_Int32 nSize = 0;
 423
 424     nSize += psp::appendStr ("(", pEncodingVector + nSize);
 425     nSize += psp::appendStr (GetReencodedFontName(nGlyphSetID).getStr(),
 426                                   pEncodingVector + nSize);
 427     nSize += psp::appendStr (") cvn (", pEncodingVector + nSize);
 428     nSize += psp::appendStr (maBaseName.getStr(),
 429                                   pEncodingVector + nSize);
 430     nSize += psp::appendStr (") cvn ", pEncodingVector + nSize);
 431     nSize += psp::appendStr (GetGlyphSetEncodingName(nGlyphSetID).getStr(),
 432                                   pEncodingVector + nSize);
 433     nSize += psp::appendStr (" psp_definefont\n",
 434                                   pEncodingVector + nSize);
 435
 436     psp::WritePS (pOutFile, pEncodingVector);
 437 }
 438
 439 OString
 440 GlyphSet::GetReencodedFontName (rtl_TextEncoding nEnc, const OString &rFontName)
 441 {
 442     if (   nEnc == RTL_TEXTENCODING_MS_1252
 443         || nEnc == RTL_TEXTENCODING_ISO_8859_1)
 444     {
 445         return rFontName
 446                + OString("-iso1252");
 447     }
 448     else
 449     if (nEnc >= RTL_TEXTENCODING_USER_START && nEnc <= RTL_TEXTENCODING_USER_END)
 450     {
 451         return rFontName
 452                + OString("-enc")
 453                + OString::valueOf ((sal_Int32)(nEnc - RTL_TEXTENCODING_USER_START));
 454     }
 455     else
 456     {
 457         return OString();
 458     }
 459 }
 460
 461 OString
 462 GlyphSet::GetReencodedFontName (sal_Int32 nGlyphSetID)
 463 {
 464     return GetReencodedFontName (GetGlyphSetEncoding(nGlyphSetID), maBaseName);
 465 }
 466
 467 void GlyphSet::DrawGlyphs(
 468                           PrinterGfx& rGfx,
 469                           const Point& rPoint,
 470                           const sal_uInt32* pGlyphIds,
 471                           const sal_Unicode* pUnicodes,
 472                           sal_Int16 nLen,
 473                           const sal_Int32* pDeltaArray,
 474                           const sal_Bool bUseGlyphs)
 475 {
 476     sal_uChar *pGlyphID    = (sal_uChar*)alloca (nLen * sizeof(sal_uChar));
 477     sal_Int32 *pGlyphSetID = (sal_Int32*)alloca (nLen * sizeof(sal_Int32));
 478     std::set< sal_Int32 > aGlyphSet;
 479
 480     // convert unicode to font glyph id and font subset
 481     for (int nChar = 0; nChar < nLen; nChar++)
 482     {
 483         if (bUseGlyphs)
 484             GetGlyphID (pGlyphIds[nChar], pUnicodes[nChar], pGlyphID + nChar, pGlyphSetID + nChar);
 485         else
 486             GetCharID (pUnicodes[nChar], pGlyphID + nChar, pGlyphSetID + nChar);
 487         aGlyphSet.insert (pGlyphSetID[nChar]);
 488     }
 489
 490     // loop over all glyph sets to detect substrings that can be xshown together
 491     // without changing the postscript font
 492     sal_Int32 *pDeltaSubset = (sal_Int32*)alloca (nLen * sizeof(sal_Int32));
 493     sal_uChar *pGlyphSubset = (sal_uChar*)alloca (nLen * sizeof(sal_uChar));
 494
 495     std::set< sal_Int32 >::iterator aSet;
 496     for (aSet = aGlyphSet.begin(); aSet != aGlyphSet.end(); ++aSet)
 497     {
 498         Point     aPoint  = rPoint;
 499         sal_Int32 nOffset = 0;
 500         sal_Int32 nGlyphs = 0;
 501         sal_Int32 nChar;
 502
 503         // get offset to first glyph
 504         for (nChar = 0; (nChar < nLen) && (pGlyphSetID[nChar] != *aSet); nChar++)
 505         {
 506             nOffset = pDeltaArray [nChar];
 507         }
 508
 509         // loop over all chars to extract those that share the current glyph set
 510         for (nChar = 0; nChar < nLen; nChar++)
 511         {
 512             if (pGlyphSetID[nChar] == *aSet)
 513             {
 514                 pGlyphSubset [nGlyphs] = pGlyphID [nChar];
 515                 // the offset to the next glyph is determined by the glyph in
 516                 // front of the next glyph with the same glyphset id
 517                 // most often, this will be the current glyph
 518                 while ((nChar + 1) < nLen)
 519                 {
 520                     if (pGlyphSetID[nChar + 1] == *aSet)
 521                         break;
 522                     else
 523                         nChar += 1;
 524                 }
 525                 pDeltaSubset [nGlyphs] = pDeltaArray[nChar] - nOffset;
 526
 527                 nGlyphs += 1;
 528             }
 529         }
 530
 531         // show the text using the PrinterGfx text api
 532         aPoint.Move (nOffset, 0);
 533
 534         OString aGlyphSetName;
 535         if (bUseGlyphs)
 536             aGlyphSetName = GetGlyphSetName(*aSet);
 537         else
 538             aGlyphSetName = GetCharSetName(*aSet);
 539
 540         rGfx.PSSetFont  (aGlyphSetName, GetGlyphSetEncoding(*aSet));
 541         rGfx.PSMoveTo   (aPoint);
 542         rGfx.PSShowText (pGlyphSubset, nGlyphs, nGlyphs, nGlyphs > 1 ? pDeltaSubset : NULL);
 543     }
 544 }
 545
 546 void
 547 GlyphSet::DrawText (PrinterGfx &rGfx, const Point& rPoint,
 548                     const sal_Unicode* pStr, sal_Int16 nLen, const sal_Int32* pDeltaArray)
 549 {
 550     // dispatch to the impl method
 551     if (pDeltaArray == NULL)
 552         ImplDrawText (rGfx, rPoint, pStr, nLen);
 553     else
 554         ImplDrawText (rGfx, rPoint, pStr, nLen, pDeltaArray);
 555 }
 556
 557 void
 558 GlyphSet::ImplDrawText (PrinterGfx &rGfx, const Point& rPoint,
 559                         const sal_Unicode* pStr, sal_Int16 nLen)
 560 {
 561     rGfx.PSMoveTo (rPoint);
 562
 563     if( mbUseFontEncoding )
 564     {
 565         OString aPSName( OUStringToOString( rGfx.GetFontMgr().getPSName( mnFontID ), RTL_TEXTENCODING_ISO_8859_1 ) );
 566         OString aBytes( OUStringToOString( OUString( pStr, nLen ), mnBaseEncoding ) );
 567         rGfx.PSSetFont( aPSName, mnBaseEncoding );
 568         rGfx.PSShowText( (const unsigned char*)aBytes.getStr(), nLen, aBytes.getLength() );
 569         return;
 570     }
 571
 572     int nChar;
 573     sal_uChar *pGlyphID    = (sal_uChar*)alloca (nLen * sizeof(sal_uChar));
 574     sal_Int32 *pGlyphSetID = (sal_Int32*)alloca (nLen * sizeof(sal_Int32));
 575
 576     // convert unicode to glyph id and char set (font subset)
 577     for (nChar = 0; nChar < nLen; nChar++)
 578         GetCharID (pStr[nChar], pGlyphID + nChar, pGlyphSetID + nChar);
 579
 580     // loop over the string to draw subsequent pieces of chars
 581     // with the same postscript font
 582     for (nChar = 0; nChar < nLen; /* atend */)
 583     {
 584         sal_Int32 nGlyphSetID = pGlyphSetID [nChar];
 585         sal_Int32 nGlyphs     = 1;
 586         for (int nNextChar = nChar + 1; nNextChar < nLen; nNextChar++)
 587         {
 588             if (pGlyphSetID[nNextChar] == nGlyphSetID)
 589                 nGlyphs++;
 590             else
 591                 break;
 592         }
 593
 594         // show the text using the PrinterGfx text api
 595         OString aGlyphSetName(GetCharSetName(nGlyphSetID));
 596         rGfx.PSSetFont (aGlyphSetName, GetGlyphSetEncoding(nGlyphSetID));
 597         rGfx.PSShowText (pGlyphID + nChar, nGlyphs, nGlyphs);
 598
 599         nChar += nGlyphs;
 600     }
 601 }
 602
 603 void
 604 GlyphSet::ImplDrawText (PrinterGfx &rGfx, const Point& rPoint,
 605                         const sal_Unicode* pStr, sal_Int16 nLen, const sal_Int32* pDeltaArray)
 606 {
 607     if( mbUseFontEncoding )
 608     {
 609         OString aPSName( OUStringToOString( rGfx.GetFontMgr().getPSName( mnFontID ), RTL_TEXTENCODING_ISO_8859_1 ) );
 610         OString aBytes( OUStringToOString( OUString( pStr, nLen ), mnBaseEncoding ) );
 611         rGfx.PSMoveTo( rPoint );
 612         rGfx.PSSetFont( aPSName, mnBaseEncoding );
 613         rGfx.PSShowText( (const unsigned char*)aBytes.getStr(), nLen, aBytes.getLength(), pDeltaArray );
 614         return;
 615     }
 616
 617     DrawGlyphs( rGfx, rPoint, NULL, pStr, nLen, pDeltaArray, sal_False);
 618 }
 619
 620 sal_Bool
 621 GlyphSet::PSUploadEncoding(osl::File* pOutFile, PrinterGfx &rGfx)
 622 {
 623     // only for ps fonts
 624     if ((meBaseType != fonttype::Builtin) && (meBaseType != fonttype::Type1))
 625         return sal_False;
 626     if (mnBaseEncoding == RTL_TEXTENCODING_SYMBOL)
 627         return sal_False;
 628
 629     PrintFontManager &rMgr = rGfx.GetFontMgr();
 630
 631     // loop thru all the font subsets
 632     sal_Int32               nGlyphSetID = 0;
 633     char_list_t::iterator   aGlyphSet;
 634     for (aGlyphSet = maCharList.begin(); aGlyphSet != maCharList.end(); ++aGlyphSet)
 635     {
 636         ++nGlyphSetID;
 637
 638         if (nGlyphSetID == 1) // latin1 page uses global reencoding table
 639         {
 640             PSDefineReencodedFont (pOutFile, nGlyphSetID);
 641             continue;
 642         }
 643         if ((*aGlyphSet).empty()) // empty set, doesn't need reencoding
 644         {
 645             continue;
 646         }
 647
 648         // create reencoding table
 649
 650         sal_Char  pEncodingVector [256];
 651         sal_Int32 nSize = 0;
 652
 653         nSize += psp::appendStr ("/",
 654                                  pEncodingVector + nSize);
 655         nSize += psp::appendStr (GetGlyphSetEncodingName(nGlyphSetID).getStr(),
 656                                  pEncodingVector + nSize);
 657         nSize += psp::appendStr (" [ ",
 658                                  pEncodingVector + nSize);
 659
 660         // need a list of glyphs, sorted by glyphid
 661         typedef std::map< sal_uInt8, sal_Unicode > ps_mapping_t;
 662         typedef ps_mapping_t::value_type ps_value_t;
 663         ps_mapping_t aSortedGlyphSet;
 664
 665         char_map_t::const_iterator aUnsortedGlyph;
 666         for (aUnsortedGlyph  = (*aGlyphSet).begin();
 667              aUnsortedGlyph != (*aGlyphSet).end();
 668              ++aUnsortedGlyph)
 669         {
 670             aSortedGlyphSet.insert(ps_value_t((*aUnsortedGlyph).second,
 671                                              (*aUnsortedGlyph).first));
 672         }
 673
 674         ps_mapping_t::const_iterator aSortedGlyph;
 675         // loop thru all the glyphs in the subset
 676         for (aSortedGlyph  = (aSortedGlyphSet).begin();
 677              aSortedGlyph != (aSortedGlyphSet).end();
 678              ++aSortedGlyph)
 679         {
 680             nSize += psp::appendStr ("/",
 681                                      pEncodingVector + nSize);
 682
 683             std::list< OString > aName( rMgr.getAdobeNameFromUnicode((*aSortedGlyph).second) );
 684
 685             if( aName.begin() != aName.end() )
 686                 nSize += psp::appendStr ( aName.front().getStr(), pEncodingVector + nSize);
 687             else
 688                 nSize += psp::appendStr (".notdef", pEncodingVector + nSize );
 689             nSize += psp::appendStr (" ",  pEncodingVector + nSize);
 690             // flush line
 691             if (nSize >= 70)
 692             {
 693                 nSize += psp::appendStr ("\n", pEncodingVector + nSize);
 694                 psp::WritePS (pOutFile, pEncodingVector);
 695                 nSize = 0;
 696             }
 697         }
 698
 699         nSize += psp::appendStr ("] def\n", pEncodingVector + nSize);
 700         psp::WritePS (pOutFile, pEncodingVector);
 701
 702         PSDefineReencodedFont (pOutFile, nGlyphSetID);
 703     }
 704
 705     return sal_True;
 706 }
 707
 708 struct EncEntry
 709 {
 710     sal_uChar  aEnc;
 711     long       aGID;
 712
 713     EncEntry() : aEnc( 0 ), aGID( 0 ) {}
 714
 715     bool operator<( const EncEntry& rRight ) const
 716     { return aEnc < rRight.aEnc; }
 717 };
 718
 719 static void CreatePSUploadableFont( TrueTypeFont* pSrcFont, FILE* pTmpFile,
 720     const char* pGlyphSetName, int nGlyphCount,
 721     /*const*/ sal_uInt16* pRequestedGlyphs, /*const*/ sal_uChar* pEncoding,
 722     bool bAllowType42, bool /*bAllowCID*/ )
 723 {
 724     // match the font-subset to the printer capabilities
 725      // TODO: allow CFF for capable printers
 726     int nTargetMask = FontSubsetInfo::TYPE1_PFA | FontSubsetInfo::TYPE3_FONT;
 727     if( bAllowType42 )
 728         nTargetMask |= FontSubsetInfo::TYPE42_FONT;
 729
 730     std::vector< EncEntry > aSorted( nGlyphCount, EncEntry() );
 731     for( int i = 0; i < nGlyphCount; i++ )
 732     {
 733         aSorted[i].aEnc = pEncoding[i];
 734         aSorted[i].aGID = pRequestedGlyphs[i];
 735     }
 736
 737     std::stable_sort( aSorted.begin(), aSorted.end() );
 738
 739     std::vector< sal_uChar > aEncoding( nGlyphCount );
 740     std::vector< long > aRequestedGlyphs( nGlyphCount );
 741
 742     for( int i = 0; i < nGlyphCount; i++ )
 743     {
 744         aEncoding[i]        = aSorted[i].aEnc;
 745         aRequestedGlyphs[i] = aSorted[i].aGID;
 746     }
 747
 748     FontSubsetInfo aInfo;
 749     aInfo.LoadFont( pSrcFont );
 750
 751     aInfo.CreateFontSubset( nTargetMask, pTmpFile, pGlyphSetName,
 752         &aRequestedGlyphs[0], &aEncoding[0], nGlyphCount, NULL );
 753 }
 754
 755 sal_Bool
 756 GlyphSet::PSUploadFont (osl::File& rOutFile, PrinterGfx &rGfx, bool bAllowType42, std::list< OString >& rSuppliedFonts )
 757 {
 758     // only for truetype fonts
 759     if (meBaseType != fonttype::TrueType)
 760         return sal_False;
 761
 762 #if defined( UNX )
 763     TrueTypeFont *pTTFont;
 764     OString aTTFileName (rGfx.GetFontMgr().getFontFileSysPath(mnFontID));
 765     int nFace = rGfx.GetFontMgr().getFontFaceNumber(mnFontID);
 766     sal_Int32 nSuccess = OpenTTFontFile(aTTFileName.getStr(), nFace, &pTTFont);
 767     if (nSuccess != SF_OK)
 768         return sal_False;
 769     FILE* pTmpFile = tmpfile();
 770     if (pTmpFile == NULL)
 771         return sal_False;
 772
 773     // array of unicode source characters
 774     sal_Unicode pUChars[256];
 775
 776     // encoding vector maps character encoding to the ordinal number
 777     // of the glyph in the output file
 778     sal_uChar  pEncoding[256];
 779     sal_uInt16 pTTGlyphMapping[256];
 780     const bool bAllowCID = false; // TODO: nPSLanguageLevel>=3
 781
 782     // loop thru all the font subsets
 783     sal_Int32 nCharSetID;
 784     char_list_t::iterator aCharSet;
 785     for (aCharSet = maCharList.begin(), nCharSetID = 1;
 786          aCharSet != maCharList.end();
 787          ++aCharSet, nCharSetID++)
 788     {
 789         if ((*aCharSet).empty())
 790             continue;
 791
 792         // loop thru all the chars in the subset
 793         char_map_t::const_iterator aChar;
 794         sal_Int32 n = 0;
 795         for (aChar = (*aCharSet).begin(); aChar != (*aCharSet).end(); ++aChar)
 796         {
 797             pUChars [n]   = (*aChar).first;
 798             pEncoding [n] = (*aChar).second;
 799             n++;
 800         }
 801         // create a mapping from the unicode chars to the char encoding in
 802         // source TrueType font
 803         MapString (pTTFont, pUChars, (*aCharSet).size(), pTTGlyphMapping, mbVertical);
 804
 805         // create the current subset
 806         OString aCharSetName = GetCharSetName(nCharSetID);
 807         fprintf( pTmpFile, "%%%%BeginResource: font %s\n", aCharSetName.getStr() );
 808         CreatePSUploadableFont( pTTFont, pTmpFile, aCharSetName.getStr(), (*aCharSet).size(),
 809                                 pTTGlyphMapping, pEncoding, bAllowType42, bAllowCID );
 810         fprintf( pTmpFile, "%%%%EndResource\n" );
 811         rSuppliedFonts.push_back( aCharSetName );
 812     }
 813
 814     // loop thru all the font glyph subsets
 815     sal_Int32 nGlyphSetID;
 816     glyph_list_t::iterator aGlyphSet;
 817     for (aGlyphSet = maGlyphList.begin(), nGlyphSetID = 1;
 818          aGlyphSet != maGlyphList.end();
 819          ++aGlyphSet, nGlyphSetID++)
 820     {
 821         if ((*aGlyphSet).empty())
 822             continue;
 823
 824         // loop thru all the glyphs in the subset
 825         glyph_map_t::const_iterator aGlyph;
 826         sal_Int32 n = 0;
 827         for (aGlyph = (*aGlyphSet).begin(); aGlyph != (*aGlyphSet).end(); ++aGlyph)
 828         {
 829             pTTGlyphMapping [n] = (*aGlyph).first;
 830             pEncoding       [n] = (*aGlyph).second;
 831             n++;
 832         }
 833
 834         // create the current subset
 835         OString aGlyphSetName = GetGlyphSetName(nGlyphSetID);
 836         fprintf( pTmpFile, "%%%%BeginResource: font %s\n", aGlyphSetName.getStr() );
 837         CreatePSUploadableFont( pTTFont, pTmpFile, aGlyphSetName.getStr(), (*aGlyphSet).size(),
 838                                 pTTGlyphMapping, pEncoding, bAllowType42, bAllowCID );
 839         fprintf( pTmpFile, "%%%%EndResource\n" );
 840         rSuppliedFonts.push_back( aGlyphSetName );
 841     }
 842
 843     // copy the file into the page header
 844     rewind(pTmpFile);
 845     fflush(pTmpFile);
 846
 847     sal_uChar  pBuffer[0x2000];
 848     sal_uInt64 nIn;
 849     sal_uInt64 nOut;
 850     do
 851     {
 852         nIn = fread(pBuffer, 1, sizeof(pBuffer), pTmpFile);
 853         rOutFile.write (pBuffer, nIn, nOut);
 854     }
 855     while ((nIn == nOut) && !feof(pTmpFile));
 856
 857     // cleanup
 858     CloseTTFont (pTTFont);
 859     fclose (pTmpFile);
 860
 861     return sal_True;
 862 #else
 863     (void)rOutFile; (void)rGfx; (void)bAllowType42; (void)rSuppliedFonts;
 864 #  warning FIXME: Missing OpenTTFontFile outside of Unix ...
 865     return sal_False;
 866 #endif
 867 }
 868
 869 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */