blob: 85ca1f4b866191c96d15f6312cc7754ec67c3f09 [file] [log] [blame]
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINIKIN_FONT_COLLECTION_H
#define MINIKIN_FONT_COLLECTION_H
#include <map>
#include <memory>
#include <unordered_set>
#include <vector>
#include <minikin/FontFamily.h>
#include <minikin/MinikinFont.h>
namespace minikin {
class FontCollection {
private:
explicit FontCollection();
public:
static std::shared_ptr<minikin::FontCollection> Create(
const std::vector<std::shared_ptr<FontFamily>>& typefaces);
// libtxt extension: an interface for looking up fallback fonts for characters
// that do not match this collection's font families.
class FallbackFontProvider {
public:
virtual ~FallbackFontProvider() = default;
virtual const std::shared_ptr<FontFamily>& matchFallbackFont(
uint32_t ch,
std::string locale) = 0;
};
struct Run {
FakedFont fakedFont;
int start;
int end;
};
void itemize(const uint16_t* string,
size_t string_length,
FontStyle style,
std::vector<Run>* result) const;
// Returns true if there is a glyph for the code point and variation selector
// pair. Returns false if no fonts have a glyph for the code point and
// variation selector pair, or invalid variation selector is passed.
bool hasVariationSelector(uint32_t baseCodepoint,
uint32_t variationSelector) const;
// Get base font with fakery information (fake bold could affect metrics)
FakedFont baseFontFaked(FontStyle style);
// Creates new FontCollection based on this collection while applying font
// variations. Returns nullptr if none of variations apply to this collection.
std::shared_ptr<FontCollection> createCollectionWithVariation(
const std::vector<FontVariation>& variations);
const std::unordered_set<AxisTag>& getSupportedTags() const {
return mSupportedAxes;
}
uint32_t getId() const;
void set_fallback_font_provider(std::unique_ptr<FallbackFontProvider> ffp) {
mFallbackFontProvider = std::move(ffp);
}
private:
static const int kLogCharsPerPage = 8;
static const int kPageMask = (1 << kLogCharsPerPage) - 1;
// mFamilyVec holds the indices of the mFamilies and mRanges holds the range
// of indices of mFamilyVec. The maximum number of pages is 0x10FF (U+10FFFF
// >> 8). The maximum number of the fonts is 0xFF. Thus, technically the
// maximum length of mFamilyVec is 0x10EE01 (0x10FF * 0xFF). However, in
// practice, 16-bit integers are enough since most fonts supports only limited
// range of code points.
struct Range {
uint16_t start;
uint16_t end;
};
// Initialize the FontCollection.
bool init(const std::vector<std::shared_ptr<FontFamily>>& typefaces);
const std::shared_ptr<FontFamily>& getFamilyForChar(uint32_t ch,
uint32_t vs,
uint32_t langListId,
int variant) const;
const std::shared_ptr<FontFamily>&
findFallbackFont(uint32_t ch, uint32_t vs, uint32_t langListId) const;
uint32_t calcFamilyScore(uint32_t ch,
uint32_t vs,
int variant,
uint32_t langListId,
const std::shared_ptr<FontFamily>& fontFamily) const;
uint32_t calcCoverageScore(
uint32_t ch,
uint32_t vs,
const std::shared_ptr<FontFamily>& fontFamily) const;
static uint32_t calcLanguageMatchingScore(uint32_t userLangListId,
const FontFamily& fontFamily);
static uint32_t calcVariantMatchingScore(int variant,
const FontFamily& fontFamily);
// static for allocating unique id's
static uint32_t sNextId;
// unique id for this font collection (suitable for cache key)
uint32_t mId;
// Highest UTF-32 code point that can be mapped
uint32_t mMaxChar;
// This vector has pointers to the all font family instances in this
// collection. This vector can't be empty.
std::vector<std::shared_ptr<FontFamily>> mFamilies;
// Following two vectors are pre-calculated tables for resolving coverage
// faster. For example, to iterate over all fonts which support Unicode code
// point U+XXYYZZ, iterate font families index from
// mFamilyVec[mRanges[0xXXYY].start] to mFamilyVec[mRange[0xXXYY].end] instead
// of whole mFamilies. This vector contains indices into mFamilies. This
// vector can't be empty.
std::vector<Range> mRanges;
std::vector<uint8_t> mFamilyVec;
// This vector has pointers to the font family instances which have cmap 14
// subtables.
std::vector<std::shared_ptr<FontFamily>> mVSFamilyVec;
// Set of supported axes in this collection.
std::unordered_set<AxisTag> mSupportedAxes;
// libtxt extension: Fallback font provider.
std::unique_ptr<FallbackFontProvider> mFallbackFontProvider;
// libtxt extension: Fallback fonts discovered after this font collection
// was constructed.
mutable std::map<std::string, std::vector<std::shared_ptr<FontFamily>>>
mCachedFallbackFamilies;
};
} // namespace minikin
#endif // MINIKIN_FONT_COLLECTION_H