vcl/inc/unx/fontmanager.hxx

   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 #pragma once
  21
  22 #include <sal/config.h>
  23
  24 #include <o3tl/sorted_vector.hxx>
  25 #include <tools/fontenum.hxx>
  26 #include <vcl/dllapi.h>
  27 #include <vcl/timer.hxx>
  28 #include <com/sun/star/lang/Locale.hpp>
  29 #include <unx/fc_fontoptions.hxx>
  30
  31 #include <font/PhysicalFontFace.hxx>
  32
  33 #include <set>
  34 #include <memory>
  35 #include <string_view>
  36 #include <vector>
  37 #include <unordered_map>
  38
  39 /*
  40  *  some words on metrics: every length returned by PrintFontManager and
  41  *  friends are PostScript afm style, that is they are 1/1000 font height
  42  */
  43
  44 class FontAttributes;
  45 class FontConfigFontOptions;
  46 namespace vcl::font
  47 {
  48 class FontSelectPattern;
  49 }
  50 namespace vcl { struct NameRecord; }
  51 class GenericUnixSalData;
  52
  53 namespace psp {
  54 class PPDParser;
  55
  56 typedef int fontID;
  57
  58 // a class to manage printable fonts
  59
  60 class VCL_PLUGIN_PUBLIC PrintFontManager
  61 {
  62     struct PrintFont;
  63     friend struct PrintFont;
  64
  65     struct VCL_DLLPRIVATE PrintFont
  66     {
  67         FontAttributes    m_aFontAttributes;
  68
  69         int               m_nDirectory;       // atom containing system dependent path
  70         OString           m_aFontFile;        // relative to directory
  71         int               m_nCollectionEntry; // 0 for regular fonts, 0 to ... for fonts stemming from collections
  72         int               m_nVariationEntry;  // 0 for regular fonts, 0 to ... for fonts stemming from font variations
  73
  74         explicit PrintFont();
  75     };
  76
  77     fontID                                      m_nNextFontID;
  78     std::unordered_map< fontID, PrintFont >     m_aFonts;
  79     // for speeding up findFontFileID
  80     std::unordered_map< OString, o3tl::sorted_vector< fontID > >
  81                                                 m_aFontFileToFontID;
  82
  83     std::unordered_map< OString, int >
  84     m_aDirToAtom;
  85     std::unordered_map< int, OString >          m_aAtomToDir;
  86     int                                         m_nNextDirAtom;
  87
  88     OString getFontFile(const PrintFont& rFont) const;
  89
  90     std::vector<PrintFont> analyzeFontFile(int nDirID, const OString& rFileName, const char *pFormat=nullptr) const;
  91     bool analyzeSfntFile(PrintFont& rFont) const;
  92     // finds the font id for the nFaceIndex face in this font file
  93     // There may be multiple font ids for font collections
  94     fontID findFontFileID(int nDirID, const OString& rFile, int nFaceIndex, int nVariationIndex) const;
  95
  96     // There may be multiple font ids for font collections
  97     std::vector<fontID> findFontFileIDs( int nDirID, const OString& rFile ) const;
  98
  99     static FontFamily matchFamilyName( std::u16string_view rFamily );
 100
 101     OString getDirectory( int nAtom ) const;
 102     int getDirectoryAtom( const OString& rDirectory );
 103
 104     /* try to initialize fonts from libfontconfig
 105
 106     called from <code>initialize()</code>
 107     */
 108     static void initFontconfig();
 109     void countFontconfigFonts();
 110     /* deinitialize fontconfig
 111      */
 112     static void deinitFontconfig();
 113
 114     /* register an application specific font directory for libfontconfig
 115
 116     since fontconfig is asked for font substitutes before OOo will check for font availability
 117     and fontconfig will happily substitute fonts it doesn't know (e.g. "Arial Narrow" -> "DejaVu Sans Book"!)
 118     it becomes necessary to tell the library about all the hidden font treasures
 119     */
 120     static void addFontconfigDir(const OString& rDirectory);
 121
 122     /* register an application specific font file for libfontconfig */
 123     static void addFontconfigFile(const OString& rFile);
 124
 125     std::set<OString> m_aPreviousLangSupportRequests;
 126     std::vector<OUString> m_aCurrentRequests;
 127     Timer m_aFontInstallerTimer;
 128
 129     DECL_DLLPRIVATE_LINK( autoInstallFontLangSupport, Timer*, void );
 130     PrintFontManager();
 131 public:
 132     ~PrintFontManager();
 133     friend class ::GenericUnixSalData;
 134     static PrintFontManager& get(); // one instance only
 135
 136     // There may be multiple font ids for font collections
 137     std::vector<fontID> addFontFile( std::u16string_view rFileUrl );
 138
 139     void initialize();
 140
 141     const PrintFont* getFont( fontID nID ) const
 142     {
 143         auto it = m_aFonts.find( nID );
 144         return it == m_aFonts.end() ? nullptr : &it->second;
 145     }
 146
 147     // returns the ids of all managed fonts.
 148     void getFontList( std::vector< fontID >& rFontIDs );
 149
 150     // routines to get font info in small pieces
 151
 152     // get a specific fonts system dependent filename
 153     OString getFontFileSysPath( fontID nFontID ) const
 154     {
 155         return getFontFile( *getFont( nFontID ) );
 156     }
 157
 158     // get the ttc face number
 159     int getFontFaceNumber( fontID nFontID ) const;
 160
 161     // get the ttc face variation
 162     int getFontFaceVariation( fontID nFontID ) const;
 163
 164     // font administration functions
 165
 166     /*  system dependent font matching
 167
 168     <p>
 169     <code>matchFont</code> matches a pattern of font characteristics
 170     and returns the closest match if possible. If a match was found
 171     it will update rDFA to the found matching font.
 172     </p>
 173     <p>
 174     implementation note: currently the function is only implemented
 175     for fontconfig.
 176     </p>
 177
 178     @param rDFA
 179     out of the FontAttributes structure the following
 180     fields will be used for the match:
 181     <ul>
 182     <li>family name</li>
 183     <li>italic</li>
 184     <li>width</li>
 185     <li>weight</li>
 186     <li>pitch</li>
 187     </ul>
 188
 189     @param rLocale
 190     if <code>rLocal</code> contains non empty strings the corresponding
 191     locale will be used for font matching also; e.g. "Sans" can result
 192     in different fonts in e.g. english and japanese
 193      */
 194     bool matchFont(FontAttributes& rDFA, const css::lang::Locale& rLocale);
 195
 196     static std::unique_ptr<FontConfigFontOptions> getFontOptions(const FontAttributes& rFontAttributes, int nSize);
 197
 198     void Substitute(vcl::font::FontSelectPattern &rPattern, OUString& rMissingCodes);
 199
 200 };
 201
 202 } // namespace
 203
 204 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */