mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-19 00:05:36 +00:00
e92b9e44cf
This rearranges how synthetic-bold use is determined in the font selection & rendering code. Previously, we would decide during the font-selection algorithm whether we need to apply synthetic-bold to the chosen face, and then pass that decision through the fontgroup (storing it in the FamilyFace entries of the mFonts array there) down to the actual rendering code that instantiates fonts from the faces (font entries) we've selected. That became a problem for variation fonts because in the case of a user font, we may not have downloaded the resource yet, so we just have a "user font container" entry, which carries the descriptors from the @font-face rule and will fetch the actual resource when needed. But in the case of a @font-face rule without a weight descriptor, we don't actually know at font-selection time whether the face will support "true" bold (via a variation axis) or not, so we can't reliably make the right decision about applying synthetic bold. So we now defer that decision until we actually instantiate a platform font object to shape/measure/draw text. At that point, we have the requested style and we also have the real font resource, so we can easily determine whether fake-bold is required. (This patch should not result in any visible behavior change; that will come in a second patch now that the architecture supports it.)
115 lines
4.2 KiB
C++
115 lines
4.2 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* 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_MACFONT_H
|
|
#define GFX_MACFONT_H
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "gfxFont.h"
|
|
#include "cairo.h"
|
|
#include <ApplicationServices/ApplicationServices.h>
|
|
|
|
#include "mozilla/gfx/UnscaledFontMac.h"
|
|
|
|
class MacOSFontEntry;
|
|
|
|
class gfxMacFont : public gfxFont
|
|
{
|
|
public:
|
|
gfxMacFont(const RefPtr<mozilla::gfx::UnscaledFontMac>& aUnscaledFont,
|
|
MacOSFontEntry *aFontEntry, const gfxFontStyle *aFontStyle);
|
|
|
|
virtual ~gfxMacFont();
|
|
|
|
CGFontRef GetCGFontRef() const { return mCGFont; }
|
|
|
|
/* overrides for the pure virtual methods in gfxFont */
|
|
uint32_t GetSpaceGlyph() override {
|
|
return mSpaceGlyph;
|
|
}
|
|
|
|
bool SetupCairoFont(DrawTarget* aDrawTarget) override;
|
|
|
|
/* override Measure to add padding for antialiasing */
|
|
RunMetrics Measure(const gfxTextRun *aTextRun,
|
|
uint32_t aStart, uint32_t aEnd,
|
|
BoundingBoxType aBoundingBoxType,
|
|
DrawTarget *aDrawTargetForTightBoundingBox,
|
|
Spacing *aSpacing,
|
|
mozilla::gfx::ShapedTextFlags aOrientation) override;
|
|
|
|
// We need to provide hinted (non-linear) glyph widths if using a font
|
|
// with embedded color bitmaps (Apple Color Emoji), as Core Text renders
|
|
// the glyphs with non-linear scaling at small pixel sizes.
|
|
bool ProvidesGlyphWidths() const override {
|
|
return mVariationFont ||
|
|
mFontEntry->HasFontTable(TRUETYPE_TAG('s','b','i','x'));
|
|
}
|
|
|
|
int32_t GetGlyphWidth(DrawTarget& aDrawTarget,
|
|
uint16_t aGID) override;
|
|
|
|
already_AddRefed<mozilla::gfx::ScaledFont>
|
|
GetScaledFont(mozilla::gfx::DrawTarget *aTarget) override;
|
|
|
|
void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
|
|
FontCacheSizes* aSizes) const override;
|
|
void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
|
|
FontCacheSizes* aSizes) const override;
|
|
|
|
FontType GetType() const override { return FONT_TYPE_MAC; }
|
|
|
|
// Helper to create a CTFont from a CGFont, with optional font descriptor
|
|
// (for features), and copying any variations that were set on the CGFont.
|
|
// This is public so that gfxCoreTextShaper can also use it.
|
|
static CTFontRef
|
|
CreateCTFontFromCGFontWithVariations(CGFontRef aCGFont,
|
|
CGFloat aSize,
|
|
bool aInstalledFont,
|
|
CTFontDescriptorRef aFontDesc = nullptr);
|
|
|
|
protected:
|
|
const Metrics& GetHorizontalMetrics() override {
|
|
return mMetrics;
|
|
}
|
|
|
|
// override to prefer CoreText shaping with fonts that depend on AAT
|
|
bool ShapeText(DrawTarget *aDrawTarget,
|
|
const char16_t *aText,
|
|
uint32_t aOffset,
|
|
uint32_t aLength,
|
|
Script aScript,
|
|
bool aVertical,
|
|
RoundingFlags aRounding,
|
|
gfxShapedText *aShapedText) override;
|
|
|
|
void InitMetrics();
|
|
void InitMetricsFromPlatform();
|
|
|
|
// Get width and glyph ID for a character; uses aConvFactor
|
|
// to convert font units as returned by CG to actual dimensions
|
|
gfxFloat GetCharWidth(CFDataRef aCmap, char16_t aUniChar,
|
|
uint32_t *aGlyphID, gfxFloat aConvFactor);
|
|
|
|
// a strong reference to the CoreGraphics font
|
|
CGFontRef mCGFont;
|
|
|
|
// a Core Text font reference, created only if we're using CT to measure
|
|
// glyph widths; otherwise null.
|
|
CTFontRef mCTFont;
|
|
|
|
cairo_font_face_t *mFontFace;
|
|
|
|
mozilla::UniquePtr<gfxFontShaper> mCoreTextShaper;
|
|
|
|
Metrics mMetrics;
|
|
uint32_t mSpaceGlyph;
|
|
nscolor mFontSmoothingBackgroundColor;
|
|
|
|
bool mVariationFont; // true if font has OpenType variations
|
|
};
|
|
|
|
#endif /* GFX_MACFONT_H */
|