summaryrefslogtreecommitdiff
path: root/vcl/inc/outfont.hxx
blob: 348dc51a12b5bf9ba230f2d6801aab17cf6812b1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#ifndef INCLUDED_VCL_INC_OUTFONT_HXX
#define INCLUDED_VCL_INC_OUTFONT_HXX

#include <rtl/ustring.hxx>
#include <sal/types.h>
#include <i18nlangtag/lang.h>
#include <tools/solar.h>
#include <vcl/dllapi.h>
#include <unotools/fontdefs.hxx>
#include <vcl/vclenum.hxx>

#include <boost/unordered_map.hpp>

class ImplDevFontListData;
class ImplGetDevFontList;
class ImplGetDevSizeList;
class ImplFontEntry;
class ImplPreMatchFontSubstitution;
class ImplGlyphFallbackFontSubstitution;
class FontSelectPattern;
class Font;
class ConvertChar;
struct FontMatchStatus;
class OutputDevice;
class Size;

namespace com { namespace sun { namespace star { namespace lang { struct Locale; }}}}

// ----------------------
// - ImplFontAttributes -
// ----------------------
// device independent font properties

class ImplFontAttributes
{
public: // TODO: create matching interface class
    const OUString& GetFamilyName() const   { return maName; }
    const OUString& GetStyleName() const    { return maStyleName; }
    FontWeight      GetWeight() const       { return meWeight; }
    FontItalic      GetSlant() const        { return meItalic; }
    FontFamily      GetFamilyType() const   { return meFamily; }
    FontPitch       GetPitch() const        { return mePitch; }
    FontWidth       GetWidthType() const    { return meWidthType; }
    bool            IsSymbolFont() const    { return mbSymbolFlag; }
    void            SetFamilyName(const OUString sFamilyName)    { maName = sFamilyName; }
    void            SetStyleName( const OUString sStyleName)     { maStyleName = sStyleName; }
    void            SetFamilyType(const FontFamily eFontFamily)  { meFamily = eFontFamily; }
    void            SetPitch(const FontPitch ePitch )          { mePitch = ePitch; }
    void            SetItalic(const FontItalic eItalic )       { meItalic = eItalic; }
    void            SetWeight(const FontWeight eWeight )       { meWeight = eWeight; }
    void            SetWidthType(const FontWidth eWidthType)   { meWidthType = eWidthType; }
    void            SetSymbolFlag(const bool bSymbolFlag )     { mbSymbolFlag = bSymbolFlag; }
    bool operator==(const ImplFontAttributes& rOther) const;
    bool operator!=(const ImplFontAttributes& rOther) const
    {
        return !(*this == rOther);
    }

private:
    OUString        maName;         // Font Family Name
    OUString        maStyleName;    // Font Style Name
    FontWeight      meWeight;       // Weight Type
    FontItalic      meItalic;       // Slant Type
    FontFamily      meFamily;       // Family Type
    FontPitch       mePitch;        // Pitch Type
    FontWidth       meWidthType;    // Width Type
    bool            mbSymbolFlag;
};

// -------------------------
// - ImplDevFontAttributes -
// -------------------------
// device dependent font properties

class ImplDevFontAttributes : public ImplFontAttributes
{
public: // TODO: create matching interface class
    const OUString&    GetAliasNames() const     { return maMapNames; }
    int                GetQuality() const        { return mnQuality; }
    bool               IsRotatable() const       { return mbOrientation; }
    bool               IsDeviceFont() const      { return mbDevice; }
    bool               IsEmbeddable() const      { return mbEmbeddable; }
    bool               IsSubsettable() const     { return mbSubsettable; }

public: // TODO: hide members behind accessor methods
    OUString           maMapNames;       // List of family name aliases separated with ';'
    int                mnQuality;        // Quality (used when similar fonts compete)
    bool               mbOrientation;    // true: physical font can be rotated
    bool               mbDevice;         // true: built in font
    bool               mbSubsettable;    // true: a subset of the font can be created
    bool               mbEmbeddable;     // true: the font can be embedded
};

// ----------------
// - PhysicalFontFace -
// ----------------
// TODO: no more direct access to members
// TODO: add reference counting
// TODO: get rid of height/width for scalable fonts
// TODO: make cloning cheaper

// abstract base class for physical font faces
class VCL_PLUGIN_PUBLIC PhysicalFontFace : public ImplDevFontAttributes
{
public:
    // by using an PhysicalFontFace object as a factory for its corresponding
    // ImplFontEntry an ImplFontEntry can be extended to cache device and
    // font instance specific data
    virtual ImplFontEntry*  CreateFontInstance( FontSelectPattern& ) const = 0;

    virtual int             GetHeight() const           { return mnHeight; }
    virtual int             GetWidth() const            { return mnWidth; }
    virtual sal_IntPtr      GetFontId() const = 0;
    int                     GetFontMagic() const        { return mnMagic; }
    bool                    IsScalable() const          { return (mnHeight == 0); }
    bool                    CheckMagic( int n ) const   { return (n == mnMagic); }
    PhysicalFontFace*       GetNextFace() const         { return mpNext; }
    PhysicalFontFace*       CreateAlias() const         { return Clone(); }

    bool                    IsBetterMatch( const FontSelectPattern&, FontMatchStatus& ) const;
    sal_Int32           CompareWithSize( const PhysicalFontFace& ) const;
    sal_Int32           CompareIgnoreSize( const PhysicalFontFace& ) const;
    virtual                 ~PhysicalFontFace() {}
    virtual PhysicalFontFace* Clone() const = 0;

protected:
    explicit                PhysicalFontFace( const ImplDevFontAttributes&, int nMagic );
    void                    SetBitmapSize( int nW, int nH ) { mnWidth=nW; mnHeight=nH; }

    long                    mnWidth;    // Width (in pixels)
    long                    mnHeight;   // Height (in pixels)

private:
friend class ImplDevFontListData;
    const int               mnMagic;    // poor man's RTTI
    PhysicalFontFace*       mpNext;
};

class FontSelectPatternAttributes : public ImplFontAttributes
{
public:
                        FontSelectPatternAttributes( const Font&, const OUString& rSearchName,
                            const Size&, float fExactHeight );
                        FontSelectPatternAttributes( const PhysicalFontFace&, const Size&,
                            float fExactHeight, int nOrientation, bool bVertical );

    size_t              hashCode() const;
    bool operator==(const FontSelectPatternAttributes& rOther) const;
    bool operator!=(const FontSelectPatternAttributes& rOther) const
    {
        return !(*this == rOther);
    }

public:
    OUString            maTargetName;       // name of the font name token that is chosen
    OUString            maSearchName;       // name of the font that matches best
    int                 mnWidth;            // width of font in pixel units
    int                 mnHeight;           // height of font in pixel units
    float               mfExactHeight;      // requested height (in pixels with subpixel details)
    int                 mnOrientation;      // text orientation in 3600 system
    LanguageType        meLanguage;         // text language
    bool                mbVertical;         // vertical mode of requested font
    bool                mbNonAntialiased;   // true if antialiasing is disabled

    bool                mbEmbolden;         // Force emboldening
    ItalicMatrix        maItalicMatrix;     // Force matrix for slant
};

class FontSelectPattern : public FontSelectPatternAttributes
{
public:
                        FontSelectPattern( const Font&, const OUString& rSearchName,
                            const Size&, float fExactHeight );
#ifdef WNT
// ifdeffed to prevent it going into unusedcode.easy
                        FontSelectPattern( const PhysicalFontFace&, const Size&,
                            float fExactHeight, int nOrientation, bool bVertical );
#endif

public: // TODO: change to private
    const PhysicalFontFace* mpFontData;         // a matching PhysicalFontFace object
    ImplFontEntry*      mpFontEntry;        // pointer to the resulting FontCache entry
    void copyAttributes(const FontSelectPatternAttributes &rAttributes);
};

// -------------------
// - ImplDevFontList -
// -------------------
// TODO: merge with ImplFontCache
// TODO: rename to LogicalFontManager

class VCL_PLUGIN_PUBLIC ImplDevFontList
{
private:
    friend class WinGlyphFallbackSubstititution;
    mutable bool            mbMatchData;    // true if matching attributes are initialized
    bool                    mbMapNames;     // true if MapNames are available

    typedef boost::unordered_map<const OUString, ImplDevFontListData*,FontNameHash> DevFontList;
    DevFontList             maDevFontList;

    ImplPreMatchFontSubstitution* mpPreMatchHook;       // device specific prematch substitution
    ImplGlyphFallbackFontSubstitution* mpFallbackHook;  // device specific glyh fallback substitution

public:
    explicit                ImplDevFontList();
    virtual                 ~ImplDevFontList();

    // fill the list with device fonts
    void                    Add( PhysicalFontFace* );
    void                    Clear();
    int                     Count() const { return maDevFontList.size(); }

    // find the device font
    ImplDevFontListData*    FindFontFamily( const OUString& rFontName ) const;
    ImplDevFontListData*    ImplFindByFont( FontSelectPattern& ) const;
    ImplDevFontListData*    ImplFindBySearchName( const OUString& ) const;

    // suggest fonts for glyph fallback
    ImplDevFontListData*    GetGlyphFallbackFont( FontSelectPattern&,
                        OUString& rMissingCodes, int nFallbackLevel ) const;

    // prepare platform specific font substitutions
    void                    SetPreMatchHook( ImplPreMatchFontSubstitution* );
    void                    SetFallbackHook( ImplGlyphFallbackFontSubstitution* );

    // misc utilities
    ImplDevFontList*        Clone( bool bScalable, bool bEmbeddable ) const;
    ImplGetDevFontList*     GetDevFontList() const;
    ImplGetDevSizeList*     GetDevSizeList( const OUString& rFontName ) const;

    ImplDevFontListData*    ImplFindByTokenNames(const OUString& rTokenStr) const;

protected:
    void                    InitMatchData() const;
    bool                    AreMapNamesAvailable() const { return mbMapNames; }

    ImplDevFontListData*    ImplFindByAliasName(const OUString& rSearchName,
        const OUString& rShortName) const;
    ImplDevFontListData*    ImplFindBySubstFontAttr( const utl::FontNameAttr& ) const;
    ImplDevFontListData*    ImplFindByAttributes(sal_uLong nSearchType, FontWeight, FontWidth,
                                                 FontItalic, const OUString& rSearchFamily) const;
    ImplDevFontListData*    FindDefaultFont() const;

private:
    void                    InitGenericGlyphFallback() const;
    mutable ImplDevFontListData**   mpFallbackList;
    mutable int                     mnFallbackCount;
};

// -----------------------
// - ImplFontMetricData -
// -----------------------

class ImplFontMetricData : public ImplFontAttributes
{
public:
    explicit ImplFontMetricData( const FontSelectPattern& );
    void    ImplInitTextLineSize( const OutputDevice* pDev );
    void    ImplInitAboveTextLineSize();

public: // TODO: hide members behind accessor methods
    // font instance attributes from the font request
    long                mnWidth;                    // Reference Width
    short               mnOrientation;              // Rotation in 1/10 degrees

    // font metrics measured for the font instance
    long                mnAscent;                   // Ascent
    long                mnDescent;                  // Descent
    long                mnIntLeading;               // Internal Leading
    long                mnExtLeading;               // External Leading
    int                 mnSlant;                    // Slant (Italic/Oblique)
    long                mnMinKashida;               // Minimal width of kashida (Arabic)

    // font attributes queried from the font instance
    int                 meFamilyType;               // Font Family Type
    bool                mbDevice;                   // Flag for Device Fonts
    bool                mbScalableFont;
    bool                mbKernableFont;

    // font metrics that are usually derived from the measurements
    long                mnUnderlineSize;            // Lineheight of Underline
    long                mnUnderlineOffset;          // Offset from Underline to Baseline
    long                mnBUnderlineSize;           // Height of bold underline
    long                mnBUnderlineOffset;         // Offset from bold underline to baseline
    long                mnDUnderlineSize;           // Height of double underline
    long                mnDUnderlineOffset1;        // Offset from double underline to baseline
    long                mnDUnderlineOffset2;        // Offset from double underline to baseline
    long                mnWUnderlineSize;           // Height of WaveLine underline
    long                mnWUnderlineOffset;         // Offset from WaveLine underline to baseline, but centrered to WaveLine
    long                mnAboveUnderlineSize;       // Height of single underline (for Vertical Right)
    long                mnAboveUnderlineOffset;     // Offset from single underline to baseline (for Vertical Right)
    long                mnAboveBUnderlineSize;      // Height of bold underline (for Vertical Right)
    long                mnAboveBUnderlineOffset;    // Offset from bold underline to baseline (for Vertical Right)
    long                mnAboveDUnderlineSize;      // Height of double underline (for Vertical Right)
    long                mnAboveDUnderlineOffset1;   // Offset from double underline to baseline (for Vertical Right)
    long                mnAboveDUnderlineOffset2;   // Offset from double underline to baseline (for Vertical Right)
    long                mnAboveWUnderlineSize;      // Height of WaveLine-strike-out (for Vertical Right)
    long                mnAboveWUnderlineOffset;    // Offset from WaveLine-strike-out to baseline, but centrered to to WaveLine (for Vertical Right)
    long                mnStrikeoutSize;            // Height of single strike-out
    long                mnStrikeoutOffset;          // Offset from single strike-out to baseline
    long                mnBStrikeoutSize;           // Height of bold strike-out
    long                mnBStrikeoutOffset;         // Offset of bold strike-out to baseline
    long                mnDStrikeoutSize;           // Height of double strike-out
    long                mnDStrikeoutOffset1;        // Offset of double strike-out to baseline
    long                mnDStrikeoutOffset2;        // Offset of double strike-out to baseline
};

// -----------------
// - ImplFontEntry -
// ------------------
// TODO: rename ImplFontEntry to LogicalFontInstance
// TODO: allow sharing of metrics for related fonts

class VCL_PLUGIN_PUBLIC ImplFontEntry
{
public:
    explicit            ImplFontEntry( const FontSelectPattern& );
    virtual             ~ImplFontEntry();

public: // TODO: make data members private
    FontSelectPattern  maFontSelData;      // FontSelectionData
    ImplFontMetricData  maMetric;           // Font Metric
    const ConvertChar*  mpConversion;       // used e.g. for StarBats->StarSymbol
    long                mnLineHeight;
    sal_uLong               mnRefCount;
    sal_uInt16              mnSetFontFlags;     // Flags returned by SalGraphics::SetFont()
    short               mnOwnOrientation;   // text angle if lower layers don't rotate text themselves
    short               mnOrientation;      // text angle in 3600 system
    bool                mbInit;             // true if maMetric member is valid

    void                AddFallbackForUnicode( sal_UCS4, FontWeight eWeight, const OUString& rFontName );
    bool                GetFallbackForUnicode( sal_UCS4, FontWeight eWeight, OUString* pFontName ) const;
    void                IgnoreFallbackForUnicode( sal_UCS4, FontWeight eWeight, const OUString& rFontName );

private:
    // cache of Unicode characters and replacement font names
    // TODO: a fallback map can be shared with many other ImplFontEntries
    // TODO: at least the ones which just differ in orientation, stretching or height
    typedef ::std::pair<sal_UCS4,FontWeight> GFBCacheKey;
    struct GFBCacheKey_Hash{ size_t operator()( const GFBCacheKey& ) const; };
    typedef ::boost::unordered_map<GFBCacheKey,OUString,GFBCacheKey_Hash> UnicodeFallbackList;
    UnicodeFallbackList* mpUnicodeFallbackList;
};


class ImplTextLineInfo
{
private:
    long        mnWidth;
    sal_Int32   mnIndex;
    sal_Int32   mnLen;

public:
               ImplTextLineInfo( long nWidth, sal_Int32 nIndex, sal_Int32 nLen )
               {
                   if(nIndex == -1 || nIndex == 0x0FFFF || nLen == -1 || nLen == 0x0FFFF)
                   {
                        SAL_INFO("sal.rtl.xub",
                                 "ImplTextLine Info Suspicious arguments nIndex:" << nIndex << " nLen:" << nLen);
                   }
                   mnWidth = nWidth;
                   mnIndex = nIndex;
                   mnLen   = nLen;
               }

    long       GetWidth() const { return mnWidth; }
    sal_Int32  GetIndex() const { return mnIndex; }
    sal_Int32  GetLen() const { return mnLen; }
};

#define MULTITEXTLINEINFO_RESIZE    16
typedef ImplTextLineInfo* PImplTextLineInfo;

class ImplMultiTextLineInfo
{
private:
    PImplTextLineInfo*  mpLines;
    sal_Int32           mnLines;
    sal_Int32           mnSize;

public:
                        ImplMultiTextLineInfo();
                        ~ImplMultiTextLineInfo();

    void                AddLine( ImplTextLineInfo* pLine );
    void                Clear();

    ImplTextLineInfo*   GetLine( sal_uInt16 nLine ) const
                            { return mpLines[nLine]; }
    sal_Int32           Count() const { return mnLines; }

private:
                            ImplMultiTextLineInfo( const ImplMultiTextLineInfo& );
    ImplMultiTextLineInfo&  operator=( const ImplMultiTextLineInfo& );
};

#endif // INCLUDED_VCL_INC_OUTFONT_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */