vcl/quartz/salgdi.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 <sal/config.h>
  21 #include <config_folders.h>
  22
  23 #include <basegfx/matrix/b2dhommatrix.hxx>
  24 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  25 #include <basegfx/polygon/b2dpolygon.hxx>
  26 #include <basegfx/polygon/b2dpolygontools.hxx>
  27 #include <basegfx/range/b2drectangle.hxx>
  28 #include <osl/file.hxx>
  29 #include <osl/mutex.hxx>
  30 #include <osl/process.h>
  31 #include <rtl/bootstrap.h>
  32 #include <rtl/strbuf.hxx>
  33
  34 #include <vcl/metric.hxx>
  35 #include <vcl/fontcharmap.hxx>
  36 #include <vcl/svapp.hxx>
  37 #include <vcl/sysdata.hxx>
  38
  39 #include "quartz/ctfonts.hxx"
  40 #include "fontsubset.hxx"
  41 #include "impfont.hxx"
  42 #include "impfontcharmap.hxx"
  43 #include "impfontmetricdata.hxx"
  44 #include "CommonSalLayout.hxx"
  45 #include "outdev.h"
  46 #include "PhysicalFontCollection.hxx"
  47
  48 #ifdef MACOSX
  49 #include "osx/salframe.h"
  50 #endif
  51 #include "quartz/utils.h"
  52 #ifdef IOS
  53 #include "saldatabasic.hxx"
  54 #endif
  55 #include "sallayout.hxx"
  56 #include "sft.hxx"
  57
  58 using namespace vcl;
  59
  60 class CoreTextGlyphFallbackSubstititution
  61 :    public ImplGlyphFallbackFontSubstitution
  62 {
  63 public:
  64     bool FindFontSubstitute(FontSelectPattern&, OUString&) const override;
  65 };
  66
  67 bool CoreTextGlyphFallbackSubstititution::FindFontSubstitute(FontSelectPattern& rPattern,
  68     OUString& rMissingChars) const
  69 {
  70     bool bFound = false;
  71     CoreTextStyle rStyle(rPattern);
  72     CTFontRef pFont = static_cast<CTFontRef>(CFDictionaryGetValue(rStyle.GetStyleDict(), kCTFontAttributeName));
  73     CFStringRef pStr = CreateCFString(rMissingChars);
  74     if (pStr)
  75     {
  76         CTFontRef pFallback = CTFontCreateForString(pFont, pStr, CFRangeMake(0, CFStringGetLength(pStr)));
  77         if (pFallback)
  78         {
  79             bFound = true;
  80
  81             CTFontDescriptorRef pDesc = CTFontCopyFontDescriptor(pFallback);
  82             FontAttributes rAttr = DevFontFromCTFontDescriptor(pDesc, nullptr);
  83
  84             rPattern.maSearchName = rAttr.GetFamilyName();
  85
  86             rPattern.SetWeight(rAttr.GetWeight());
  87             rPattern.SetItalic(rAttr.GetItalic());
  88             rPattern.SetPitch(rAttr.GetPitch());
  89             rPattern.SetWidthType(rAttr.GetWidthType());
  90
  91             SalData* pSalData = GetSalData();
  92             if (pSalData->mpFontList)
  93                 rPattern.mpFontData = pSalData->mpFontList->GetFontDataFromId(reinterpret_cast<sal_IntPtr>(pDesc));
  94
  95             CFRelease(pFallback);
  96             CFRelease(pDesc);
  97         }
  98         CFRelease(pStr);
  99     }
 100
 101     return bFound;
 102 }
 103
 104 CoreTextFontFace::CoreTextFontFace( const CoreTextFontFace& rSrc )
 105   : PhysicalFontFace( rSrc )
 106   , mnFontId( rSrc.mnFontId )
 107 {
 108     if( rSrc.mxCharMap.is() )
 109         mxCharMap = rSrc.mxCharMap;
 110 }
 111
 112 CoreTextFontFace::CoreTextFontFace( const FontAttributes& rDFA, sal_IntPtr nFontId )
 113   : PhysicalFontFace( rDFA )
 114   , mnFontId( nFontId )
 115   , mbFontCapabilitiesRead( false )
 116 {
 117 }
 118
 119 CoreTextFontFace::~CoreTextFontFace()
 120 {
 121 }
 122
 123 sal_IntPtr CoreTextFontFace::GetFontId() const
 124 {
 125     return (sal_IntPtr)mnFontId;
 126 }
 127
 128 const FontCharMapRef CoreTextFontFace::GetFontCharMap() const
 129 {
 130     // return the cached charmap
 131     if( mxCharMap.is() )
 132         return mxCharMap;
 133
 134     // set the default charmap
 135     FontCharMapRef pCharMap( new FontCharMap() );
 136     mxCharMap = pCharMap;
 137
 138     // get the CMAP byte size
 139     // allocate a buffer for the CMAP raw data
 140     const int nBufSize = GetFontTable( "cmap", nullptr );
 141     SAL_WARN_IF( (nBufSize <= 0), "vcl", "CoreTextFontFace::GetFontCharMap : GetFontTable1 failed!");
 142     if( nBufSize <= 0 )
 143         return mxCharMap;
 144
 145     // get the CMAP raw data
 146     std::vector<unsigned char> aBuffer( nBufSize );
 147     const int nRawLength = GetFontTable( "cmap", &aBuffer[0] );
 148     SAL_WARN_IF( (nRawLength <= 0), "vcl", "CoreTextFontFace::GetFontCharMap : GetFontTable2 failed!");
 149     if( nRawLength <= 0 )
 150         return mxCharMap;
 151
 152     SAL_WARN_IF( (nBufSize!=nRawLength), "vcl", "CoreTextFontFace::GetFontCharMap : ByteCount mismatch!");
 153
 154     // parse the CMAP
 155     CmapResult aCmapResult;
 156     if( ParseCMAP( &aBuffer[0], nRawLength, aCmapResult ) )
 157     {
 158         FontCharMapRef xDefFontCharMap( new FontCharMap(aCmapResult) );
 159         // create the matching charmap
 160         mxCharMap = xDefFontCharMap;
 161     }
 162
 163     return mxCharMap;
 164 }
 165
 166 bool CoreTextFontFace::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
 167 {
 168     // read this only once per font
 169     if( mbFontCapabilitiesRead )
 170     {
 171         rFontCapabilities = maFontCapabilities;
 172         return rFontCapabilities.oUnicodeRange || rFontCapabilities.oCodePageRange;
 173     }
 174     mbFontCapabilitiesRead = true;
 175
 176     int nBufSize = GetFontTable( "OS/2", nullptr );
 177     if( nBufSize > 0 )
 178     {
 179         // allocate a buffer for the OS/2 raw data
 180         std::vector<unsigned char> aBuffer( nBufSize );
 181         // get the OS/2 raw data
 182         const int nRawLength = GetFontTable( "OS/2", &aBuffer[0] );
 183         if( nRawLength > 0 )
 184         {
 185             const unsigned char* pOS2Table = &aBuffer[0];
 186             vcl::getTTCoverage( maFontCapabilities.oUnicodeRange,
 187                                 maFontCapabilities.oCodePageRange,
 188                                 pOS2Table, nRawLength);
 189         }
 190     }
 191     rFontCapabilities = maFontCapabilities;
 192     return rFontCapabilities.oUnicodeRange || rFontCapabilities.oCodePageRange;
 193 }
 194
 195 AquaSalGraphics::AquaSalGraphics()
 196     : mxLayer( nullptr )
 197     , mrContext( nullptr )
 198 #ifdef MACOSX
 199     , mpFrame( nullptr )
 200 #endif
 201 #if OSL_DEBUG_LEVEL > 0
 202     , mnContextStackDepth( 0 )
 203 #endif
 204     , mpXorEmulation( nullptr )
 205     , mnXorMode( 0 )
 206     , mnWidth( 0 )
 207     , mnHeight( 0 )
 208     , mnBitmapDepth( 0 )
 209     , mnRealDPIX( 0 )
 210     , mnRealDPIY( 0 )
 211     , mxClipPath( nullptr )
 212     , maLineColor( COL_WHITE )
 213     , maFillColor( COL_BLACK )
 214     , maTextColor( COL_BLACK )
 215     , mbNonAntialiasedText( false )
 216     , mbPrinter( false )
 217     , mbVirDev( false )
 218 #ifdef MACOSX
 219     , mbWindow( false )
 220 #else
 221     , mbForeignContext( false )
 222 #endif
 223 {
 224     SAL_INFO( "vcl.quartz", "AquaSalGraphics::AquaSalGraphics() this=" << this );
 225
 226     for (int i = 0; i < MAX_FALLBACK; ++i)
 227     {
 228         mpTextStyle[i] = nullptr;
 229         mpFontData[i] = nullptr;
 230     }
 231 }
 232
 233 AquaSalGraphics::~AquaSalGraphics()
 234 {
 235     SAL_INFO( "vcl.quartz", "AquaSalGraphics::~AquaSalGraphics() this=" << this );
 236
 237     if( mxClipPath )
 238     {
 239         SAL_INFO("vcl.cg", "CGPathRelease(" << mxClipPath << ")" );
 240         CGPathRelease( mxClipPath );
 241     }
 242
 243     for (int i = 0; i < MAX_FALLBACK; ++i)
 244         delete mpTextStyle[i];
 245
 246     if( mpXorEmulation )
 247         delete mpXorEmulation;
 248
 249 #ifdef IOS
 250     if (mbForeignContext)
 251         return;
 252 #endif
 253     if( mxLayer )
 254     {
 255         SAL_INFO("vcl.cg", "CGLayerRelease(" << mxLayer << ")" );
 256         CGLayerRelease( mxLayer );
 257     }
 258     else if( mrContext
 259 #ifdef MACOSX
 260              && mbWindow
 261 #endif
 262              )
 263     {
 264         // destroy backbuffer bitmap context that we created ourself
 265         SAL_INFO("vcl.cg", "CGContextRelease(" << mrContext << ")" );
 266         CGContextRelease( mrContext );
 267         mrContext = nullptr;
 268     }
 269 }
 270
 271 SalGraphicsImpl* AquaSalGraphics::GetImpl() const
 272 {
 273     return nullptr;
 274 }
 275
 276 void AquaSalGraphics::SetTextColor( SalColor nSalColor )
 277 {
 278     maTextColor = RGBAColor( nSalColor );
 279     // SAL_ DEBUG(std::hex << nSalColor << std::dec << "={" << maTextColor.GetRed() << ", " << maTextColor.GetGreen() << ", " << maTextColor.GetBlue() << ", " << maTextColor.GetAlpha() << "}");
 280 }
 281
 282 void AquaSalGraphics::GetFontMetric(ImplFontMetricDataRef& rxFontMetric, int nFallbackLevel)
 283 {
 284     if (nFallbackLevel < MAX_FALLBACK && mpTextStyle[nFallbackLevel])
 285     {
 286         mpTextStyle[nFallbackLevel]->GetFontMetric(rxFontMetric);
 287     }
 288 }
 289
 290 static bool AddTempDevFont(const OUString& rFontFileURL)
 291 {
 292     OUString aUSytemPath;
 293     OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFontFileURL, aUSytemPath ) );
 294     OString aCFileName = OUStringToOString( aUSytemPath, RTL_TEXTENCODING_UTF8 );
 295
 296     CFStringRef rFontPath = CFStringCreateWithCString(nullptr, aCFileName.getStr(), kCFStringEncodingUTF8);
 297     CFURLRef rFontURL = CFURLCreateWithFileSystemPath(nullptr, rFontPath, kCFURLPOSIXPathStyle, true);
 298
 299     CFErrorRef error;
 300     bool success = CTFontManagerRegisterFontsForURL(rFontURL, kCTFontManagerScopeProcess, &error);
 301     if (!success)
 302     {
 303         CFRelease(error);
 304     }
 305     CFRelease(rFontPath);
 306     CFRelease(rFontURL);
 307
 308     return success;
 309 }
 310
 311 static void AddTempFontDir( const OUString &rFontDirUrl )
 312 {
 313     osl::Directory aFontDir( rFontDirUrl );
 314     osl::FileBase::RC rcOSL = aFontDir.open();
 315     if( rcOSL == osl::FileBase::E_None )
 316     {
 317         osl::DirectoryItem aDirItem;
 318
 319         while( aFontDir.getNextItem( aDirItem, 10 ) == osl::FileBase::E_None )
 320         {
 321             osl::FileStatus aFileStatus( osl_FileStatus_Mask_FileURL );
 322             rcOSL = aDirItem.getFileStatus( aFileStatus );
 323             if ( rcOSL == osl::FileBase::E_None )
 324             {
 325                 AddTempDevFont(aFileStatus.getFileURL());
 326             }
 327         }
 328     }
 329 }
 330
 331 static void AddLocalTempFontDirs()
 332 {
 333     static bool bFirst = true;
 334     if( !bFirst )
 335         return;
 336
 337     bFirst = false;
 338
 339     // add private font files
 340
 341     OUString aBrandStr( "$BRAND_BASE_DIR" );
 342     rtl_bootstrap_expandMacros( &aBrandStr.pData );
 343     AddTempFontDir( aBrandStr + "/" LIBO_SHARE_FOLDER "/fonts/truetype/" );
 344 }
 345
 346 void AquaSalGraphics::GetDevFontList( PhysicalFontCollection* pFontCollection )
 347 {
 348     SAL_WARN_IF( !pFontCollection, "vcl", "AquaSalGraphics::GetDevFontList(NULL) !");
 349
 350     AddLocalTempFontDirs();
 351
 352     // The idea is to cache the list of system fonts once it has been generated.
 353     // SalData seems to be a good place for this caching. However we have to
 354     // carefully make the access to the font list thread-safe. If we register
 355     // a font-change event handler to update the font list in case fonts have
 356     // changed on the system we have to lock access to the list. The right
 357     // way to do that is the solar mutex since GetDevFontList is protected
 358     // through it as should be all event handlers
 359
 360     SalData* pSalData = GetSalData();
 361     if( !pSalData->mpFontList )
 362         pSalData->mpFontList = GetCoretextFontList();
 363
 364     // Copy all PhysicalFontFace objects contained in the SystemFontList
 365     pSalData->mpFontList->AnnounceFonts( *pFontCollection );
 366
 367     static CoreTextGlyphFallbackSubstititution aSubstFallback;
 368     pFontCollection->SetFallbackHook(&aSubstFallback);
 369 }
 370
 371 void AquaSalGraphics::ClearDevFontCache()
 372 {
 373     SalData* pSalData = GetSalData();
 374     delete pSalData->mpFontList;
 375     pSalData->mpFontList = nullptr;
 376 }
 377
 378 bool AquaSalGraphics::AddTempDevFont( PhysicalFontCollection*,
 379     const OUString& rFontFileURL, const OUString& /*rFontName*/ )
 380 {
 381     return ::AddTempDevFont(rFontFileURL);
 382 }
 383
 384 bool AquaSalGraphics::GetGlyphOutline(const GlyphItem& rGlyph, basegfx::B2DPolyPolygon& rPolyPoly)
 385 {
 386     const int nFallbackLevel = rGlyph.mnFallbackLevel;
 387     if (nFallbackLevel < MAX_FALLBACK && mpTextStyle[nFallbackLevel])
 388     {
 389         const bool bRC = mpTextStyle[nFallbackLevel]->GetGlyphOutline(rGlyph, rPolyPoly);
 390         return bRC;
 391     }
 392     return false;
 393 }
 394
 395 bool AquaSalGraphics::GetGlyphBoundRect(const GlyphItem& rGlyph, tools::Rectangle& rRect )
 396 {
 397     const int nFallbackLevel = rGlyph.mnFallbackLevel;
 398     if (nFallbackLevel < MAX_FALLBACK && mpTextStyle[nFallbackLevel])
 399     {
 400         const bool bRC = mpTextStyle[nFallbackLevel]->GetGlyphBoundRect(rGlyph, rRect);
 401         return bRC;
 402     }
 403     return false;
 404 }
 405
 406 void AquaSalGraphics::DrawTextLayout(const CommonSalLayout& rLayout)
 407 {
 408     const CoreTextStyle& rStyle = rLayout.getFontData();
 409     const FontSelectPattern& rFontSelect = rStyle.maFontSelData;
 410     if (rFontSelect.mnHeight == 0)
 411         return;
 412
 413     CTFontRef pFont = static_cast<CTFontRef>(CFDictionaryGetValue(rStyle.GetStyleDict(), kCTFontAttributeName));
 414     CGAffineTransform aRotMatrix = CGAffineTransformMakeRotation(-rStyle.mfFontRotation);
 415
 416     Point aPos;
 417     const GlyphItem* pGlyph;
 418     std::vector<CGGlyph> aGlyphIds;
 419     std::vector<CGPoint> aGlyphPos;
 420     std::vector<bool> aGlyphOrientation;
 421     int nStart = 0;
 422     while (rLayout.GetNextGlyphs(1, &pGlyph, aPos, nStart))
 423     {
 424         CGPoint aGCPos = CGPointMake(aPos.X(), -aPos.Y());
 425
 426         // Whether the glyph should be upright in vertical mode or not
 427         bool bUprightGlyph = false;
 428
 429         if (rStyle.mfFontRotation)
 430         {
 431             if (pGlyph->IsVertical())
 432             {
 433                 bUprightGlyph = true;
 434                 // Adjust the position of upright (vertical) glyphs.
 435                 aGCPos.y -= CTFontGetAscent(pFont) - CTFontGetDescent(pFont);
 436             }
 437             else
 438             {
 439                 // Transform the position of rotated glyphs.
 440                 aGCPos = CGPointApplyAffineTransform(aGCPos, aRotMatrix);
 441             }
 442         }
 443
 444         aGlyphIds.push_back(pGlyph->maGlyphId);
 445         aGlyphPos.push_back(aGCPos);
 446         aGlyphOrientation.push_back(bUprightGlyph);
 447     }
 448
 449     if (aGlyphIds.empty())
 450         return;
 451
 452     CGContextSaveGState(mrContext);
 453
 454     // The view is vertically flipped (no idea why), flip it back.
 455     CGContextScaleCTM(mrContext, 1.0, -1.0);
 456     CGContextSetShouldAntialias(mrContext, !mbNonAntialiasedText);
 457     CGContextSetFillColor(mrContext, maTextColor.AsArray());
 458
 459     auto aIt = aGlyphOrientation.cbegin();
 460     while (aIt != aGlyphOrientation.cend())
 461     {
 462         bool bUprightGlyph = *aIt;
 463         // Find the boundary of the run of glyphs with the same rotation, to be
 464         // drawn together.
 465         auto aNext = std::find(aIt, aGlyphOrientation.cend(), !bUprightGlyph);
 466         size_t nStartIndex = std::distance(aGlyphOrientation.cbegin(), aIt);
 467         size_t nLen = std::distance(aIt, aNext);
 468
 469         CGContextSaveGState(mrContext);
 470         if (rStyle.mfFontRotation && !bUprightGlyph)
 471             CGContextRotateCTM(mrContext, rStyle.mfFontRotation);
 472         CTFontDrawGlyphs(pFont, &aGlyphIds[nStartIndex], &aGlyphPos[nStartIndex], nLen, mrContext);
 473         CGContextRestoreGState(mrContext);
 474
 475         aIt = aNext;
 476     }
 477
 478     CGContextRestoreGState(mrContext);
 479 }
 480
 481 void AquaSalGraphics::SetFont(FontSelectPattern* pReqFont, int nFallbackLevel)
 482 {
 483     // release the text style
 484     for (int i = nFallbackLevel; i < MAX_FALLBACK; ++i)
 485     {
 486         delete mpTextStyle[i];
 487         mpTextStyle[i] = nullptr;
 488     }
 489
 490     // handle NULL request meaning: release-font-resources request
 491     if( !pReqFont )
 492     {
 493         mpFontData[nFallbackLevel] = nullptr;
 494         return;
 495     }
 496
 497     // update the text style
 498     mpFontData[nFallbackLevel] = static_cast<const CoreTextFontFace*>(pReqFont->mpFontData);
 499     mpTextStyle[nFallbackLevel] = new CoreTextStyle(*pReqFont);
 500
 501     SAL_INFO("vcl.ct",
 502             "SetFont"
 503                " to "     << mpFontData[nFallbackLevel]->GetFamilyName()
 504             << ", "       << mpFontData[nFallbackLevel]->GetStyleName()
 505             << " fontid=" << mpFontData[nFallbackLevel]->GetFontId()
 506             << " for "    << pReqFont->GetFamilyName()
 507             << ", "       << pReqFont->GetStyleName()
 508             << " weight=" << pReqFont->GetWeight()
 509             << " slant="  << pReqFont->GetItalic()
 510             << " size="   << pReqFont->mnHeight << "x" << pReqFont->mnWidth
 511             << " orientation=" << pReqFont->mnOrientation
 512             << " fallback level " << nFallbackLevel
 513             );
 514 }
 515
 516 SalLayout* AquaSalGraphics::GetTextLayout(ImplLayoutArgs& /*rArgs*/, int nFallbackLevel)
 517 {
 518     if (mpTextStyle[nFallbackLevel])
 519         return new CommonSalLayout(*mpTextStyle[nFallbackLevel]);
 520
 521     return nullptr;
 522 }
 523
 524 const FontCharMapRef AquaSalGraphics::GetFontCharMap() const
 525 {
 526     if (!mpFontData[0])
 527     {
 528         FontCharMapRef xFontCharMap( new FontCharMap() );
 529         return xFontCharMap;
 530     }
 531
 532     return mpFontData[0]->GetFontCharMap();
 533 }
 534
 535 bool AquaSalGraphics::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
 536 {
 537     if (!mpFontData[0])
 538         return false;
 539
 540     return mpFontData[0]->GetFontCapabilities(rFontCapabilities);
 541 }
 542
 543 // fake a SFNT font directory entry for a font table
 544 // see http://developer.apple.com/fonts/TTRefMan/RM06/Chap6.html#Directory
 545 static void FakeDirEntry( const char aTag[5], ByteCount nOfs, ByteCount nLen,
 546                           const unsigned char* /*pData*/, unsigned char*& rpDest )
 547 {
 548     // write entry tag
 549     rpDest[ 0] = aTag[0];
 550     rpDest[ 1] = aTag[1];
 551     rpDest[ 2] = aTag[2];
 552     rpDest[ 3] = aTag[3];
 553     // TODO: get entry checksum and write it
 554     //      not too important since the subsetter doesn't care currently
 555     //      for( pData+nOfs ... pData+nOfs+nLen )
 556     // write entry offset
 557     rpDest[ 8] = (char)(nOfs >> 24);
 558     rpDest[ 9] = (char)(nOfs >> 16);
 559     rpDest[10] = (char)(nOfs >>  8);
 560     rpDest[11] = (char)(nOfs >>  0);
 561     // write entry length
 562     rpDest[12] = (char)(nLen >> 24);
 563     rpDest[13] = (char)(nLen >> 16);
 564     rpDest[14] = (char)(nLen >>  8);
 565     rpDest[15] = (char)(nLen >>  0);
 566     // advance to next entry
 567     rpDest += 16;
 568 }
 569
 570 // fake a TTF or CFF font as directly accessing font file is not possible
 571 // when only the fontid is known. This approach also handles *.font fonts.
 572 bool AquaSalGraphics::GetRawFontData( const PhysicalFontFace* pFontData,
 573                                       std::vector<unsigned char>& rBuffer, bool* pJustCFF )
 574 {
 575     const CoreTextFontFace* pMacFont = static_cast<const CoreTextFontFace*>(pFontData);
 576
 577     // short circuit for CFF-only fonts
 578     const int nCffSize = pMacFont->GetFontTable( "CFF ", nullptr);
 579     if( pJustCFF != nullptr )
 580     {
 581         *pJustCFF = (nCffSize > 0);
 582         if( *pJustCFF)
 583         {
 584             rBuffer.resize( nCffSize);
 585             const int nCffRead = pMacFont->GetFontTable( "CFF ", &rBuffer[0]);
 586             if( nCffRead != nCffSize)
 587             {
 588                 return false;
 589             }
 590             return true;
 591         }
 592     }
 593
 594     // get font table availability and size in bytes
 595     const int nHeadSize = pMacFont->GetFontTable( "head", nullptr);
 596     if( nHeadSize <= 0)
 597         return false;
 598
 599     const int nMaxpSize = pMacFont->GetFontTable( "maxp", nullptr);
 600     if( nMaxpSize <= 0)
 601         return false;
 602
 603     const int nCmapSize = pMacFont->GetFontTable( "cmap", nullptr);
 604     if( nCmapSize <= 0)
 605         return false;
 606
 607     const int nNameSize = pMacFont->GetFontTable( "name", nullptr);
 608     if( nNameSize <= 0)
 609         return false;
 610
 611     const int nHheaSize = pMacFont->GetFontTable( "hhea", nullptr);
 612     if( nHheaSize <= 0)
 613         return false;
 614
 615     const int nHmtxSize = pMacFont->GetFontTable( "hmtx", nullptr);
 616     if( nHmtxSize <= 0)
 617         return false;
 618
 619     // get the ttf-glyf outline tables
 620     int nLocaSize = 0;
 621     int nGlyfSize = 0;
 622     if( nCffSize <= 0)
 623     {
 624         nLocaSize = pMacFont->GetFontTable( "loca", nullptr);
 625         if( nLocaSize <= 0)
 626             return false;
 627
 628         nGlyfSize = pMacFont->GetFontTable( "glyf", nullptr);
 629         if( nGlyfSize <= 0)
 630             return false;
 631     }
 632
 633     int nPrepSize = 0, nCvtSize = 0, nFpgmSize = 0;
 634     if( nGlyfSize) // TODO: reduce PDF size by making hint subsetting optional
 635     {
 636         nPrepSize = pMacFont->GetFontTable( "prep", nullptr);
 637         nCvtSize  = pMacFont->GetFontTable( "cvt ", nullptr);
 638         nFpgmSize = pMacFont->GetFontTable( "fpgm", nullptr);
 639     }
 640
 641     // prepare a byte buffer for a fake font
 642     int nTableCount = 7;
 643     nTableCount += (nPrepSize>0?1:0) + (nCvtSize>0?1:0) + (nFpgmSize>0?1:0) + (nGlyfSize>0?1:0);
 644     const ByteCount nFdirSize = 12 + 16*nTableCount;
 645     ByteCount nTotalSize = nFdirSize;
 646     nTotalSize += nHeadSize + nMaxpSize + nNameSize + nCmapSize;
 647
 648     if( nGlyfSize )
 649     {
 650         nTotalSize += nLocaSize + nGlyfSize;
 651     }
 652     else
 653     {
 654         nTotalSize += nCffSize;
 655     }
 656     nTotalSize += nHheaSize + nHmtxSize;
 657     nTotalSize += nPrepSize + nCvtSize + nFpgmSize;
 658     rBuffer.resize( nTotalSize );
 659
 660     // fake a SFNT font directory header
 661     if( nTableCount < 16 )
 662     {
 663         int nLog2 = 0;
 664         while( (nTableCount >> nLog2) > 1 ) ++nLog2;
 665         rBuffer[ 1] = 1;                        // Win-TTF style scaler
 666         rBuffer[ 5] = nTableCount;              // table count
 667         rBuffer[ 7] = nLog2*16;                 // searchRange
 668         rBuffer[ 9] = nLog2;                    // entrySelector
 669         rBuffer[11] = (nTableCount-nLog2)*16;   // rangeShift
 670     }
 671
 672     // get font table raw data and update the fake directory entries
 673     ByteCount nOfs = nFdirSize;
 674     unsigned char* pFakeEntry = &rBuffer[12];
 675     if( nCmapSize != pMacFont->GetFontTable( "cmap", &rBuffer[nOfs]))
 676         return false;
 677
 678     FakeDirEntry( "cmap", nOfs, nCmapSize, &rBuffer[0], pFakeEntry );
 679     nOfs += nCmapSize;
 680     if( nCvtSize )
 681     {
 682         if( nCvtSize != pMacFont->GetFontTable( "cvt ", &rBuffer[nOfs]))
 683             return false;
 684
 685         FakeDirEntry( "cvt ", nOfs, nCvtSize, &rBuffer[0], pFakeEntry );
 686         nOfs += nCvtSize;
 687     }
 688     if( nFpgmSize )
 689     {
 690         if( nFpgmSize != pMacFont->GetFontTable( "fpgm", &rBuffer[nOfs]))
 691             return false;
 692
 693         FakeDirEntry( "fpgm", nOfs, nFpgmSize, &rBuffer[0], pFakeEntry );
 694         nOfs += nFpgmSize;
 695     }
 696     if( nCffSize )
 697     {
 698         if( nCffSize != pMacFont->GetFontTable( "CFF ", &rBuffer[nOfs]))
 699             return false;
 700
 701         FakeDirEntry( "CFF ", nOfs, nCffSize, &rBuffer[0], pFakeEntry );
 702         nOfs += nGlyfSize;
 703     }
 704     else
 705     {
 706         if( nGlyfSize != pMacFont->GetFontTable( "glyf", &rBuffer[nOfs]))
 707             return false;
 708
 709         FakeDirEntry( "glyf", nOfs, nGlyfSize, &rBuffer[0], pFakeEntry );
 710         nOfs += nGlyfSize;
 711
 712         if( nLocaSize != pMacFont->GetFontTable( "loca", &rBuffer[nOfs]))
 713             return false;
 714
 715         FakeDirEntry( "loca", nOfs, nLocaSize, &rBuffer[0], pFakeEntry );
 716         nOfs += nLocaSize;
 717     }
 718     if( nHeadSize != pMacFont->GetFontTable( "head", &rBuffer[nOfs]))
 719         return false;
 720
 721     FakeDirEntry( "head", nOfs, nHeadSize, &rBuffer[0], pFakeEntry );
 722     nOfs += nHeadSize;
 723
 724     if( nHheaSize != pMacFont->GetFontTable( "hhea", &rBuffer[nOfs]))
 725         return false;
 726
 727     FakeDirEntry( "hhea", nOfs, nHheaSize, &rBuffer[0], pFakeEntry );
 728     nOfs += nHheaSize;
 729     if( nHmtxSize != pMacFont->GetFontTable( "hmtx", &rBuffer[nOfs]))
 730         return false;
 731
 732     FakeDirEntry( "hmtx", nOfs, nHmtxSize, &rBuffer[0], pFakeEntry );
 733     nOfs += nHmtxSize;
 734     if( nMaxpSize != pMacFont->GetFontTable( "maxp", &rBuffer[nOfs]))
 735         return false;
 736
 737     FakeDirEntry( "maxp", nOfs, nMaxpSize, &rBuffer[0], pFakeEntry );
 738     nOfs += nMaxpSize;
 739     if( nNameSize != pMacFont->GetFontTable( "name", &rBuffer[nOfs]))
 740         return false;
 741
 742     FakeDirEntry( "name", nOfs, nNameSize, &rBuffer[0], pFakeEntry );
 743     nOfs += nNameSize;
 744     if( nPrepSize )
 745     {
 746         if( nPrepSize != pMacFont->GetFontTable( "prep", &rBuffer[nOfs]))
 747             return false;
 748
 749         FakeDirEntry( "prep", nOfs, nPrepSize, &rBuffer[0], pFakeEntry );
 750         nOfs += nPrepSize;
 751     }
 752
 753     SAL_WARN_IF( (nOfs!=nTotalSize), "vcl", "AquaSalGraphics::CreateFontSubset (nOfs!=nTotalSize)");
 754
 755     return true;
 756 }
 757
 758 void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bVertical,
 759     std::vector< sal_Int32 >& rGlyphWidths, Ucs2UIntMap& rUnicodeEnc )
 760 {
 761     rGlyphWidths.clear();
 762     rUnicodeEnc.clear();
 763
 764     std::vector<unsigned char> aBuffer;
 765     if( !GetRawFontData( pFontData, aBuffer, nullptr ) )
 766         return;
 767
 768     // TODO: modernize psprint's horrible fontsubset C-API
 769     // this probably only makes sense after the switch to another SCM
 770     // that can preserve change history after file renames
 771
 772     // use the font subsetter to get the widths
 773     TrueTypeFont* pSftFont = nullptr;
 774     int nRC = ::OpenTTFontBuffer( static_cast<void*>(&aBuffer[0]), aBuffer.size(), 0, &pSftFont);
 775     if( nRC != SF_OK )
 776         return;
 777
 778     const int nGlyphCount = ::GetTTGlyphCount( pSftFont );
 779     if( nGlyphCount > 0 )
 780     {
 781         // get glyph metrics
 782         rGlyphWidths.resize(nGlyphCount);
 783         std::vector<sal_uInt16> aGlyphIds(nGlyphCount);
 784         for( int i = 0; i < nGlyphCount; i++ )
 785         {
 786             aGlyphIds[i] = static_cast<sal_uInt16>(i);
 787         }
 788
 789         const TTSimpleGlyphMetrics* pGlyphMetrics = ::GetTTSimpleGlyphMetrics( pSftFont, &aGlyphIds[0],
 790                                                                                nGlyphCount, bVertical );
 791         if( pGlyphMetrics )
 792         {
 793             for( int i = 0; i < nGlyphCount; ++i )
 794             {
 795                 rGlyphWidths[i] = pGlyphMetrics[i].adv;
 796             }
 797             free( const_cast<TTSimpleGlyphMetrics *>(pGlyphMetrics) );
 798         }
 799
 800         CoreTextFontFace rCTFontData(*pFontData, pFontData->GetFontId());
 801         FontCharMapRef xFCMap = rCTFontData.GetFontCharMap();
 802         SAL_WARN_IF( !xFCMap.is() || !xFCMap->GetCharCount(), "vcl", "no charmap" );
 803
 804         // get unicode<->glyph encoding
 805         // TODO? avoid sft mapping by using the xFCMap itself
 806         int nCharCount = xFCMap->GetCharCount();
 807         sal_uInt32 nChar = xFCMap->GetFirstChar();
 808         for( ; --nCharCount >= 0; nChar = xFCMap->GetNextChar( nChar ) )
 809         {
 810             if( nChar > 0xFFFF ) // TODO: allow UTF-32 chars
 811                 break;
 812
 813             sal_Ucs nUcsChar = static_cast<sal_Ucs>(nChar);
 814             sal_uInt32 nGlyph = ::MapChar( pSftFont, nUcsChar );
 815             if( nGlyph > 0 )
 816             {
 817                 rUnicodeEnc[ nUcsChar ] = nGlyph;
 818             }
 819         }
 820
 821         xFCMap = nullptr;
 822     }
 823
 824     ::CloseTTFont( pSftFont );
 825 }
 826
 827 const void* AquaSalGraphics::GetEmbedFontData(const PhysicalFontFace*, long* /*pDataLen*/)
 828 {
 829     return nullptr;
 830 }
 831
 832 void AquaSalGraphics::FreeEmbedFontData( const void* pData, long /*nDataLen*/ )
 833 {
 834     // TODO: implementing this only makes sense when the implementation of
 835     //      AquaSalGraphics::GetEmbedFontData() returns non-NULL
 836     (void)pData;
 837     SAL_WARN_IF( (pData==nullptr), "vcl", "AquaSalGraphics::FreeEmbedFontData() is not implemented");
 838 }
 839
 840 bool AquaSalGraphics::IsFlipped() const
 841 {
 842 #ifdef MACOSX
 843     return mbWindow;
 844 #else
 845     return false;
 846 #endif
 847 }
 848
 849 void AquaSalGraphics::RefreshRect(float lX, float lY, float lWidth, float lHeight)
 850 {
 851 #ifdef MACOSX
 852     if( ! mbWindow ) // view only on Window graphics
 853         return;
 854
 855     if( mpFrame )
 856     {
 857         // update a little more around the designated rectangle
 858         // this helps with antialiased rendering
 859         // Rounding down x and width can accumulate a rounding error of up to 2
 860         // The decrementing of x, the rounding error and the antialiasing border
 861         // require that the width and the height need to be increased by four
 862         const tools::Rectangle aVclRect(Point(static_cast<long int>(lX-1),
 863                                        static_cast<long int>(lY-1) ),
 864                                  Size(  static_cast<long int>(lWidth+4),
 865                                         static_cast<long int>(lHeight+4) ) );
 866         mpFrame->maInvalidRect.Union( aVclRect );
 867     }
 868 #else
 869     (void) lX;
 870     (void) lY;
 871     (void) lWidth;
 872     (void) lHeight;
 873     return;
 874 #endif
 875 }
 876
 877 #ifdef IOS
 878
 879 bool AquaSalGraphics::CheckContext()
 880 {
 881     if (mbForeignContext)
 882     {
 883         SAL_INFO("vcl.ios", "CheckContext() this=" << this << ", mbForeignContext, return true");
 884         return true;
 885     }
 886
 887     SAL_INFO( "vcl.ios", "CheckContext() this=" << this << ",  not foreign, return false");
 888     return false;
 889 }
 890
 891 CGContextRef AquaSalGraphics::GetContext()
 892 {
 893     if ( !mrContext )
 894         CheckContext();
 895
 896     return mrContext;
 897 }
 898
 899 #endif
 900
 901 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */