vcl/headless/svptextrender.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/types.h>
  21
  22 #include <cassert>
  23
  24 #include <basebmp/scanlineformats.hxx>
  25 #include <basegfx/polygon/b2dpolypolygon.hxx>
  26 #include <basegfx/range/b2drange.hxx>
  27 #include <basegfx/range/b2ibox.hxx>
  28 #include <rtl/instance.hxx>
  29 #include <tools/debug.hxx>
  30 #include <vcl/sysdata.hxx>
  31
  32 #include "generic/geninst.h"
  33 #include "generic/genpspgraphics.h"
  34 #include "generic/glyphcache.hxx"
  35 #include "headless/svpbmp.hxx"
  36 #include "headless/svpgdi.hxx"
  37 #include "headless/svptextrender.hxx"
  38 #include "impfont.hxx"
  39 #include "outfont.hxx"
  40 #include "PhysicalFontFace.hxx"
  41
  42 class PhysicalFontCollection;
  43
  44 using namespace basegfx;
  45 using namespace basebmp;
  46
  47 class SvpGlyphPeer : public GlyphCachePeer
  48 {
  49 public:
  50     SvpGlyphPeer() {}
  51
  52     BitmapDeviceSharedPtr GetGlyphBmp( ServerFont&, sal_GlyphId,
  53                                        basebmp::Format nBmpFormat, B2IPoint& rTargetPos );
  54
  55 protected:
  56     virtual void    RemovingFont( ServerFont& ) SAL_OVERRIDE;
  57     virtual void    RemovingGlyph( GlyphData& ) SAL_OVERRIDE;
  58
  59     class SvpGcpHelper
  60     {
  61     public:
  62         RawBitmap               maRawBitmap;
  63         BitmapDeviceSharedPtr   maBitmapDev;
  64     };
  65 };
  66
  67 class SvpGlyphCache : public GlyphCache
  68 {
  69 public:
  70     SvpGlyphCache( SvpGlyphPeer& rPeer ) : GlyphCache( rPeer) {}
  71     SvpGlyphPeer& GetPeer() { return reinterpret_cast<SvpGlyphPeer&>( mrPeer ); }
  72     static SvpGlyphCache& GetInstance();
  73 };
  74
  75 namespace
  76 {
  77     struct GlyphCacheHolder
  78     {
  79     private:
  80         SvpGlyphPeer* m_pSvpGlyphPeer;
  81         SvpGlyphCache* m_pSvpGlyphCache;
  82     public:
  83         GlyphCacheHolder()
  84         {
  85             m_pSvpGlyphPeer = new SvpGlyphPeer();
  86             m_pSvpGlyphCache = new SvpGlyphCache( *m_pSvpGlyphPeer );
  87         }
  88         SvpGlyphCache& getGlyphCache()
  89         {
  90             return *m_pSvpGlyphCache;
  91         }
  92         ~GlyphCacheHolder()
  93         {
  94             delete m_pSvpGlyphCache;
  95             delete m_pSvpGlyphPeer;
  96         }
  97     };
  98
  99     struct theGlyphCacheHolder :
 100         public rtl::Static<GlyphCacheHolder, theGlyphCacheHolder>
 101     {};
 102 }
 103
 104 SvpGlyphCache& SvpGlyphCache::GetInstance()
 105 {
 106     return theGlyphCacheHolder::get().getGlyphCache();
 107 }
 108
 109 BitmapDeviceSharedPtr SvpGlyphPeer::GetGlyphBmp( ServerFont& rServerFont,
 110     sal_GlyphId aGlyphId, basebmp::Format nBmpFormat, B2IPoint& rTargetPos )
 111 {
 112     GlyphData& rGlyphData = rServerFont.GetGlyphData( aGlyphId );
 113
 114     if( rGlyphData.ExtDataRef().meInfo != nBmpFormat )
 115     {
 116         SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
 117             rGlyphData.ExtDataRef().mpData);
 118         bool bNew = pGcpHelper == 0;
 119         if( bNew )
 120             pGcpHelper = new SvpGcpHelper;
 121
 122         // get glyph bitmap in matching format
 123         bool bFound = false;
 124         switch( nBmpFormat )
 125         {
 126             case FORMAT_ONE_BIT_LSB_GREY:
 127                 bFound = rServerFont.GetGlyphBitmap1( aGlyphId, pGcpHelper->maRawBitmap );
 128                 break;
 129             case FORMAT_EIGHT_BIT_GREY:
 130                 bFound = rServerFont.GetGlyphBitmap8( aGlyphId, pGcpHelper->maRawBitmap );
 131                 break;
 132             default:
 133                 OSL_FAIL( "SVP GCP::GetGlyphBmp(): illegal scanline format");
 134                 // fall back to black&white mask
 135                 nBmpFormat = FORMAT_ONE_BIT_LSB_GREY;
 136                 bFound = false;
 137                 break;
 138         }
 139
 140         // return .notdef glyph if needed
 141         if( !bFound && (aGlyphId != 0) )
 142         {
 143             if( bNew )
 144                 delete pGcpHelper;
 145             return GetGlyphBmp( rServerFont, 0, nBmpFormat, rTargetPos );
 146         }
 147
 148         // construct alpha mask from raw bitmap
 149         if (pGcpHelper->maRawBitmap.mnScanlineSize && pGcpHelper->maRawBitmap.mnHeight)
 150         {
 151             const B2IVector aSize(
 152                 pGcpHelper->maRawBitmap.mnScanlineSize,
 153                 pGcpHelper->maRawBitmap.mnHeight );
 154             static PaletteMemorySharedVector aDummyPAL;
 155             pGcpHelper->maBitmapDev = createBitmapDevice( aSize, true, nBmpFormat, aSize.getX(), pGcpHelper->maRawBitmap.mpBits, aDummyPAL );
 156         }
 157
 158         rGlyphData.ExtDataRef().meInfo = nBmpFormat;
 159         rGlyphData.ExtDataRef().mpData = pGcpHelper;
 160     }
 161
 162     SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
 163         rGlyphData.ExtDataRef().mpData);
 164     assert(pGcpHelper != 0);
 165     rTargetPos += B2IPoint( pGcpHelper->maRawBitmap.mnXOffset, pGcpHelper->maRawBitmap.mnYOffset );
 166     return pGcpHelper->maBitmapDev;
 167 }
 168
 169 void SvpGlyphPeer::RemovingFont( ServerFont& )
 170 {
 171     // nothing to do: no font resources held in SvpGlyphPeer
 172 }
 173
 174 void SvpGlyphPeer::RemovingGlyph( GlyphData& rGlyphData )
 175 {
 176     SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
 177         rGlyphData.ExtDataRef().mpData);
 178     rGlyphData.ExtDataRef().meInfo = basebmp::FORMAT_NONE;
 179     rGlyphData.ExtDataRef().mpData = 0;
 180     delete pGcpHelper;
 181 }
 182
 183 SvpTextRender::SvpTextRender(SvpSalGraphics& rParent)
 184     : m_rParent(rParent)
 185     , m_aTextColor(COL_BLACK)
 186     , m_eTextFmt(basebmp::FORMAT_EIGHT_BIT_GREY)
 187 {
 188     for( int i = 0; i < MAX_FALLBACK; ++i )
 189         m_pServerFont[i] = NULL;
 190 }
 191
 192 sal_uInt16 SvpTextRender::SetFont( FontSelectPattern* pIFSD, int nFallbackLevel )
 193 {
 194     // release all no longer needed font resources
 195     for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
 196     {
 197         if( m_pServerFont[i] != NULL )
 198         {
 199             // old server side font is no longer referenced
 200             SvpGlyphCache::GetInstance().UncacheFont( *m_pServerFont[i] );
 201             m_pServerFont[i] = NULL;
 202         }
 203     }
 204
 205     // return early if there is no new font
 206     if( !pIFSD )
 207         return 0;
 208
 209     // handle the request for a non-native X11-font => use the GlyphCache
 210     ServerFont* pServerFont = SvpGlyphCache::GetInstance().CacheFont( *pIFSD );
 211     if( !pServerFont )
 212         return SAL_SETFONT_BADFONT;
 213
 214     // check selected font
 215     if( !pServerFont->TestFont() )
 216     {
 217         SvpGlyphCache::GetInstance().UncacheFont( *pServerFont );
 218         return SAL_SETFONT_BADFONT;
 219     }
 220
 221     // update SalGraphics font settings
 222     m_pServerFont[ nFallbackLevel ] = pServerFont;
 223     return SAL_SETFONT_USEDRAWTEXTARRAY;
 224 }
 225
 226 void SvpTextRender::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel )
 227 {
 228     if( nFallbackLevel >= MAX_FALLBACK )
 229         return;
 230
 231     if( m_pServerFont[nFallbackLevel] != NULL )
 232     {
 233         long rDummyFactor;
 234         m_pServerFont[nFallbackLevel]->FetchFontMetric( *pMetric, rDummyFactor );
 235     }
 236 }
 237
 238 const FontCharMapPtr SvpTextRender::GetFontCharMap() const
 239 {
 240     if( !m_pServerFont[0] )
 241         return NULL;
 242
 243     const FontCharMapPtr pFCMap = m_pServerFont[0]->GetFontCharMap();
 244     return pFCMap;
 245 }
 246
 247 bool SvpTextRender::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
 248 {
 249     if (!m_pServerFont[0])
 250         return false;
 251
 252     return m_pServerFont[0]->GetFontCapabilities(rFontCapabilities);
 253 }
 254
 255 void SvpTextRender::GetDevFontList( PhysicalFontCollection* pFontCollection )
 256 {
 257     GlyphCache& rGC = SvpGlyphCache::GetInstance();
 258
 259     psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
 260     psp::FastPrintFontInfo aInfo;
 261     ::std::list< psp::fontID > aList;
 262     rMgr.getFontList( aList );
 263     ::std::list< psp::fontID >::iterator it;
 264     for( it = aList.begin(); it != aList.end(); ++it )
 265     {
 266         if( !rMgr.getFontFastInfo( *it, aInfo ) )
 267             continue;
 268
 269         // normalize face number to the GlyphCache
 270         int nFaceNum = rMgr.getFontFaceNumber( aInfo.m_nID );
 271
 272         // inform GlyphCache about this font provided by the PsPrint subsystem
 273         ImplDevFontAttributes aDFA = GenPspGraphics::Info2DevFontAttributes( aInfo );
 274         aDFA.mnQuality += 4096;
 275         const OString& rFileName = rMgr.getFontFileSysPath( aInfo.m_nID );
 276         rGC.AddFontFile( rFileName, nFaceNum, aInfo.m_nID, aDFA );
 277    }
 278
 279     // announce glyphcache fonts
 280     rGC.AnnounceFonts( pFontCollection );
 281
 282     // register platform specific font substitutions if available
 283     SalGenericInstance::RegisterFontSubstitutors( pFontCollection );
 284
 285     ImplGetSVData()->maGDIData.mbNativeFontConfig = true;
 286 }
 287
 288 void SvpTextRender::ClearDevFontCache()
 289 {
 290     GlyphCache& rGC = SvpGlyphCache::GetInstance();
 291     rGC.ClearFontCache();
 292 }
 293
 294 bool SvpTextRender::AddTempDevFont( PhysicalFontCollection*,
 295     const OUString&, const OUString& )
 296 {
 297     return false;
 298 }
 299
 300 bool SvpTextRender::CreateFontSubset(
 301     const OUString& rToFile,
 302     const PhysicalFontFace* pFont,
 303     const sal_GlyphId* pGlyphIds,
 304     const sal_uInt8* pEncoding,
 305     sal_Int32* pWidths,
 306     int nGlyphCount,
 307     FontSubsetInfo& rInfo
 308     )
 309 {
 310     // in this context the pFont->GetFontId() is a valid PSP
 311     // font since they are the only ones left after the PDF
 312     // export has filtered its list of subsettable fonts (for
 313     // which this method was created). The correct way would
 314     // be to have the GlyphCache search for the PhysicalFontFace pFont
 315     psp::fontID aFont = pFont->GetFontId();
 316
 317     psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
 318     bool bSuccess = rMgr.createFontSubset( rInfo,
 319                                  aFont,
 320                                  rToFile,
 321                                  pGlyphIds,
 322                                  pEncoding,
 323                                  pWidths,
 324                                  nGlyphCount );
 325     return bSuccess;
 326 }
 327
 328 const Ucs2SIntMap* SvpTextRender::GetFontEncodingVector( const PhysicalFontFace* pFont, const Ucs2OStrMap** pNonEncoded, std::set<sal_Unicode> const** ppPriority)
 329 {
 330     // in this context the pFont->GetFontId() is a valid PSP
 331     // font since they are the only ones left after the PDF
 332     // export has filtered its list of subsettable fonts (for
 333     // which this method was created). The correct way would
 334     // be to have the GlyphCache search for the PhysicalFontFace pFont
 335     psp::fontID aFont = pFont->GetFontId();
 336     return GenPspGraphics::DoGetFontEncodingVector(aFont, pNonEncoded, ppPriority);
 337 }
 338
 339 const void* SvpTextRender::GetEmbedFontData(
 340     const PhysicalFontFace* pFont,
 341     const sal_Ucs* pUnicodes,
 342     sal_Int32* pWidths,
 343     size_t nLen,
 344     FontSubsetInfo& rInfo,
 345     long* pDataLen
 346     )
 347 {
 348     // in this context the pFont->GetFontId() is a valid PSP
 349     // font since they are the only ones left after the PDF
 350     // export has filtered its list of subsettable fonts (for
 351     // which this method was created). The correct way would
 352     // be to have the GlyphCache search for the PhysicalFontFace pFont
 353     psp::fontID aFont = pFont->GetFontId();
 354     return GenPspGraphics::DoGetEmbedFontData( aFont, pUnicodes, pWidths, nLen, rInfo, pDataLen );
 355 }
 356
 357 void SvpTextRender::FreeEmbedFontData( const void* pData, long nLen )
 358 {
 359     GenPspGraphics::DoFreeEmbedFontData( pData, nLen );
 360 }
 361
 362 void SvpTextRender::GetGlyphWidths( const PhysicalFontFace* pFont,
 363                                    bool bVertical,
 364                                    Int32Vector& rWidths,
 365                                    Ucs2UIntMap& rUnicodeEnc )
 366 {
 367     // in this context the pFont->GetFontId() is a valid PSP
 368     // font since they are the only ones left after the PDF
 369     // export has filtered its list of subsettable fonts (for
 370     // which this method was created). The correct way would
 371     // be to have the GlyphCache search for the PhysicalFontFace pFont
 372     psp::fontID aFont = pFont->GetFontId();
 373     GenPspGraphics::DoGetGlyphWidths( aFont, bVertical, rWidths, rUnicodeEnc );
 374 }
 375
 376 bool SvpTextRender::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
 377 {
 378     const int nLevel = aGlyphId >> GF_FONTSHIFT;
 379     if( nLevel >= MAX_FALLBACK )
 380         return false;
 381
 382     ServerFont* pSF = m_pServerFont[ nLevel ];
 383     if( !pSF )
 384         return false;
 385
 386     aGlyphId &= GF_IDXMASK;
 387     const GlyphMetric& rGM = pSF->GetGlyphMetric( aGlyphId );
 388     rRect = Rectangle( rGM.GetOffset(), rGM.GetSize() );
 389     return true;
 390 }
 391
 392 bool SvpTextRender::GetGlyphOutline( sal_GlyphId aGlyphId, B2DPolyPolygon& rPolyPoly )
 393 {
 394     const int nLevel = aGlyphId >> GF_FONTSHIFT;
 395     if( nLevel >= MAX_FALLBACK )
 396         return false;
 397
 398     const ServerFont* pSF = m_pServerFont[ nLevel ];
 399     if( !pSF )
 400         return false;
 401
 402     aGlyphId &= GF_IDXMASK;
 403     if( pSF->GetGlyphOutline( aGlyphId, rPolyPoly ) )
 404         return true;
 405
 406     return false;
 407 }
 408
 409 SalLayout* SvpTextRender::GetTextLayout( ImplLayoutArgs&, int nFallbackLevel )
 410 {
 411     GenericSalLayout* pLayout = NULL;
 412
 413     if( m_pServerFont[ nFallbackLevel ] )
 414         pLayout = new ServerFontLayout( *m_pServerFont[ nFallbackLevel ] );
 415
 416     return pLayout;
 417 }
 418
 419 void SvpTextRender::DrawServerFontLayout( const ServerFontLayout& rSalLayout )
 420 {
 421     // iterate over all glyphs in the layout
 422     Point aPos;
 423     sal_GlyphId aGlyphId;
 424     SvpGlyphPeer& rGlyphPeer = SvpGlyphCache::GetInstance().GetPeer();
 425     for( int nStart = 0; rSalLayout.GetNextGlyphs( 1, &aGlyphId, aPos, nStart ); )
 426     {
 427         ServerFont& rFont = rSalLayout.GetServerFont();
 428         // get the glyph's alpha mask and adjust the drawing position
 429         aGlyphId &= GF_IDXMASK;
 430         B2IPoint aDstPoint( aPos.X(), aPos.Y() );
 431         BitmapDeviceSharedPtr aAlphaMask
 432             = rGlyphPeer.GetGlyphBmp(rFont, aGlyphId, m_eTextFmt, aDstPoint);
 433         if( !aAlphaMask )   // ignore empty glyphs
 434             continue;
 435
 436         // blend text color into target using the glyph's mask
 437         m_rParent.BlendTextColor(m_aTextColor, aAlphaMask, aDstPoint);
 438     }
 439 }
 440
 441 void SvpTextRender::SetTextColor( SalColor nSalColor )
 442 {
 443     m_aTextColor = basebmp::Color( nSalColor );
 444 }
 445
 446 SystemFontData SvpTextRender::GetSysFontData( int nFallbackLevel ) const
 447 {
 448     SystemFontData aSysFontData;
 449
 450     if (nFallbackLevel >= MAX_FALLBACK) nFallbackLevel = MAX_FALLBACK - 1;
 451     if (nFallbackLevel < 0 ) nFallbackLevel = 0;
 452
 453     if (m_pServerFont[nFallbackLevel] != NULL)
 454     {
 455         ServerFont* rFont = m_pServerFont[nFallbackLevel];
 456         aSysFontData.nFontId = rFont->GetFtFace();
 457         aSysFontData.nFontFlags = rFont->GetLoadFlags();
 458         aSysFontData.bFakeBold = rFont->NeedsArtificialBold();
 459         aSysFontData.bFakeItalic = rFont->NeedsArtificialItalic();
 460         aSysFontData.bAntialias = rFont->GetAntialiasAdvice();
 461         aSysFontData.bVerticalCharacterType = rFont->GetFontSelData().mbVertical;
 462     }
 463
 464     return aSysFontData;
 465 }
 466
 467 void SvpTextRender::setDevice( basebmp::BitmapDeviceSharedPtr& rDevice )
 468 {
 469     // determine matching bitmap format for masks
 470     basebmp::Format nDeviceFmt = rDevice ? rDevice->getScanlineFormat() : basebmp::FORMAT_EIGHT_BIT_GREY;
 471     switch( nDeviceFmt )
 472     {
 473         case basebmp::FORMAT_EIGHT_BIT_GREY:
 474         case basebmp::FORMAT_SIXTEEN_BIT_LSB_TC_MASK:
 475         case basebmp::FORMAT_SIXTEEN_BIT_MSB_TC_MASK:
 476         case basebmp::FORMAT_TWENTYFOUR_BIT_TC_MASK:
 477         case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_BGRX:
 478         case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_BGRA:
 479         case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_ARGB:
 480         case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_ABGR:
 481         case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_RGBA:
 482             m_eTextFmt = basebmp::FORMAT_EIGHT_BIT_GREY;
 483             break;
 484         default:
 485             m_eTextFmt = basebmp::FORMAT_ONE_BIT_LSB_GREY;
 486             break;
 487     }
 488 }
 489
 490 GlyphCache& SvpSalGraphics::getPlatformGlyphCache()
 491 {
 492     return SvpGlyphCache::GetInstance();
 493 }
 494
 495 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */