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
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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/. */
#ifndef GFX_DWRITECOMMON_H
#define GFX_DWRITECOMMON_H
// Mozilla includes
#include "mozilla/MemoryReporting.h"
#include "mozilla/FontPropertyTypes.h"
#include "nscore.h"
#include "nsCOMPtr.h"
#include "cairo-features.h"
#include "gfxFontConstants.h"
#include "nsTArray.h"
#include "gfxWindowsPlatform.h"
#include <windows.h>
#include <dwrite.h>
static inline DWRITE_FONT_STRETCH DWriteFontStretchFromStretch(
mozilla::FontStretch aStretch) {
if (aStretch == mozilla::FontStretch::UltraCondensed()) {
return DWRITE_FONT_STRETCH_ULTRA_CONDENSED;
}
if (aStretch == mozilla::FontStretch::ExtraCondensed()) {
return DWRITE_FONT_STRETCH_EXTRA_CONDENSED;
}
if (aStretch == mozilla::FontStretch::Condensed()) {
return DWRITE_FONT_STRETCH_CONDENSED;
}
if (aStretch == mozilla::FontStretch::SemiCondensed()) {
return DWRITE_FONT_STRETCH_SEMI_CONDENSED;
}
if (aStretch == mozilla::FontStretch::Normal()) {
return DWRITE_FONT_STRETCH_NORMAL;
}
if (aStretch == mozilla::FontStretch::SemiExpanded()) {
return DWRITE_FONT_STRETCH_SEMI_EXPANDED;
}
if (aStretch == mozilla::FontStretch::Expanded()) {
return DWRITE_FONT_STRETCH_EXPANDED;
}
if (aStretch == mozilla::FontStretch::ExtraExpanded()) {
return DWRITE_FONT_STRETCH_EXTRA_EXPANDED;
}
if (aStretch == mozilla::FontStretch::UltraExpanded()) {
return DWRITE_FONT_STRETCH_ULTRA_EXPANDED;
}
return DWRITE_FONT_STRETCH_UNDEFINED;
}
static inline mozilla::FontStretch FontStretchFromDWriteStretch(
DWRITE_FONT_STRETCH aStretch) {
switch (aStretch) {
case DWRITE_FONT_STRETCH_ULTRA_CONDENSED:
return mozilla::FontStretch::UltraCondensed();
case DWRITE_FONT_STRETCH_EXTRA_CONDENSED:
return mozilla::FontStretch::ExtraCondensed();
case DWRITE_FONT_STRETCH_CONDENSED:
return mozilla::FontStretch::Condensed();
case DWRITE_FONT_STRETCH_SEMI_CONDENSED:
return mozilla::FontStretch::SemiCondensed();
case DWRITE_FONT_STRETCH_NORMAL:
return mozilla::FontStretch::Normal();
case DWRITE_FONT_STRETCH_SEMI_EXPANDED:
return mozilla::FontStretch::SemiExpanded();
case DWRITE_FONT_STRETCH_EXPANDED:
return mozilla::FontStretch::Expanded();
case DWRITE_FONT_STRETCH_EXTRA_EXPANDED:
return mozilla::FontStretch::ExtraExpanded();
case DWRITE_FONT_STRETCH_ULTRA_EXPANDED:
return mozilla::FontStretch::UltraExpanded();
default:
return mozilla::FontStretch::Normal();
}
}
class gfxDWriteFontFileLoader : public IDWriteFontFileLoader {
public:
gfxDWriteFontFileLoader() {}
// IUnknown interface
IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject) {
if (iid == __uuidof(IDWriteFontFileLoader)) {
*ppObject = static_cast<IDWriteFontFileLoader*>(this);
return S_OK;
} else if (iid == __uuidof(IUnknown)) {
*ppObject = static_cast<IUnknown*>(this);
return S_OK;
} else {
return E_NOINTERFACE;
}
}
IFACEMETHOD_(ULONG, AddRef)() { return 1; }
IFACEMETHOD_(ULONG, Release)() { return 1; }
// IDWriteFontFileLoader methods
/**
* Important! Note the key here -has- to be a pointer to a uint64_t.
*/
virtual HRESULT STDMETHODCALLTYPE CreateStreamFromKey(
void const* fontFileReferenceKey, UINT32 fontFileReferenceKeySize,
OUT IDWriteFontFileStream** fontFileStream);
/**
* Gets the singleton loader instance. Note that when using this font
* loader, the key must be a pointer to a unint64_t.
*/
static IDWriteFontFileLoader* Instance() {
if (!mInstance) {
mInstance = new gfxDWriteFontFileLoader();
mozilla::gfx::Factory::GetDWriteFactory()->RegisterFontFileLoader(
mInstance);
}
return mInstance;
}
/**
* Creates a IDWriteFontFile and IDWriteFontFileStream from aFontData.
* The data from aFontData will be copied internally, so the caller
* is free to dispose of it once this method returns.
*
* @param aFontData the font data for the custom font file
* @param aLength length of the font data
* @param aFontFile out param for the created font file
* @param aFontFileStream out param for the corresponding stream
* @return HRESULT of internal calls
*/
static HRESULT CreateCustomFontFile(const uint8_t* aFontData,
uint32_t aLength,
IDWriteFontFile** aFontFile,
IDWriteFontFileStream** aFontFileStream);
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
private:
static IDWriteFontFileLoader* mInstance;
};
#endif /* GFX_DWRITECOMMON_H */
|
