git subrepo clone --branch=sono6good https://github.com/essej/JUCE.git deps/juce
subrepo: subdir: "deps/juce" merged: "b13f9084e" upstream: origin: "https://github.com/essej/JUCE.git" branch: "sono6good" commit: "b13f9084e" git-subrepo: version: "0.4.3" origin: "https://github.com/ingydotnet/git-subrepo.git" commit: "2f68596"
This commit is contained in:
essej
822
deps/juce/modules/juce_graphics/fonts/juce_Font.cpp
vendored
Normal file
822
deps/juce/modules/juce_graphics/fonts/juce_Font.cpp
vendored
Normal file
@ -0,0 +1,822 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
|
||||
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
|
||||
|
||||
End User License Agreement: www.juce.com/juce-6-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
namespace FontValues
|
||||
{
|
||||
static float limitFontHeight (const float height) noexcept
|
||||
{
|
||||
return jlimit (0.1f, 10000.0f, height);
|
||||
}
|
||||
|
||||
const float defaultFontHeight = 14.0f;
|
||||
float minimumHorizontalScale = 0.7f;
|
||||
String fallbackFont;
|
||||
String fallbackFontStyle;
|
||||
}
|
||||
|
||||
using GetTypefaceForFont = Typeface::Ptr (*)(const Font&);
|
||||
GetTypefaceForFont juce_getTypefaceForFont = nullptr;
|
||||
|
||||
float Font::getDefaultMinimumHorizontalScaleFactor() noexcept { return FontValues::minimumHorizontalScale; }
|
||||
void Font::setDefaultMinimumHorizontalScaleFactor (float newValue) noexcept { FontValues::minimumHorizontalScale = newValue; }
|
||||
|
||||
//==============================================================================
|
||||
class TypefaceCache : private DeletedAtShutdown
|
||||
{
|
||||
public:
|
||||
TypefaceCache()
|
||||
{
|
||||
setSize (10);
|
||||
}
|
||||
|
||||
~TypefaceCache()
|
||||
{
|
||||
clearSingletonInstance();
|
||||
}
|
||||
|
||||
JUCE_DECLARE_SINGLETON (TypefaceCache, false)
|
||||
|
||||
void setSize (const int numToCache)
|
||||
{
|
||||
const ScopedWriteLock sl (lock);
|
||||
|
||||
faces.clear();
|
||||
faces.insertMultiple (-1, CachedFace(), numToCache);
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
const ScopedWriteLock sl (lock);
|
||||
|
||||
setSize (faces.size());
|
||||
defaultFace = nullptr;
|
||||
}
|
||||
|
||||
Typeface::Ptr findTypefaceFor (const Font& font)
|
||||
{
|
||||
const auto faceName = font.getTypefaceName();
|
||||
const auto faceStyle = font.getTypefaceStyle();
|
||||
|
||||
jassert (faceName.isNotEmpty());
|
||||
|
||||
{
|
||||
const ScopedReadLock slr (lock);
|
||||
|
||||
for (int i = faces.size(); --i >= 0;)
|
||||
{
|
||||
CachedFace& face = faces.getReference(i);
|
||||
|
||||
if (face.typefaceName == faceName
|
||||
&& face.typefaceStyle == faceStyle
|
||||
&& face.typeface != nullptr
|
||||
&& face.typeface->isSuitableForFont (font))
|
||||
{
|
||||
face.lastUsageCount = ++counter;
|
||||
return face.typeface;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const ScopedWriteLock slw (lock);
|
||||
int replaceIndex = 0;
|
||||
auto bestLastUsageCount = std::numeric_limits<size_t>::max();
|
||||
|
||||
for (int i = faces.size(); --i >= 0;)
|
||||
{
|
||||
auto lu = faces.getReference(i).lastUsageCount;
|
||||
|
||||
if (bestLastUsageCount > lu)
|
||||
{
|
||||
bestLastUsageCount = lu;
|
||||
replaceIndex = i;
|
||||
}
|
||||
}
|
||||
|
||||
auto& face = faces.getReference (replaceIndex);
|
||||
face.typefaceName = faceName;
|
||||
face.typefaceStyle = faceStyle;
|
||||
face.lastUsageCount = ++counter;
|
||||
|
||||
if (juce_getTypefaceForFont == nullptr)
|
||||
face.typeface = Font::getDefaultTypefaceForFont (font);
|
||||
else
|
||||
face.typeface = juce_getTypefaceForFont (font);
|
||||
|
||||
jassert (face.typeface != nullptr); // the look and feel must return a typeface!
|
||||
|
||||
if (defaultFace == nullptr && font == Font())
|
||||
defaultFace = face.typeface;
|
||||
|
||||
return face.typeface;
|
||||
}
|
||||
|
||||
Typeface::Ptr getDefaultFace() const noexcept
|
||||
{
|
||||
const ScopedReadLock slr (lock);
|
||||
return defaultFace;
|
||||
}
|
||||
|
||||
private:
|
||||
struct CachedFace
|
||||
{
|
||||
CachedFace() noexcept {}
|
||||
|
||||
// Although it seems a bit wacky to store the name here, it's because it may be a
|
||||
// placeholder rather than a real one, e.g. "<Sans-Serif>" vs the actual typeface name.
|
||||
// Since the typeface itself doesn't know that it may have this alias, the name under
|
||||
// which it was fetched needs to be stored separately.
|
||||
String typefaceName, typefaceStyle;
|
||||
size_t lastUsageCount = 0;
|
||||
Typeface::Ptr typeface;
|
||||
};
|
||||
|
||||
Typeface::Ptr defaultFace;
|
||||
ReadWriteLock lock;
|
||||
Array<CachedFace> faces;
|
||||
size_t counter = 0;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TypefaceCache)
|
||||
};
|
||||
|
||||
JUCE_IMPLEMENT_SINGLETON (TypefaceCache)
|
||||
|
||||
void Typeface::setTypefaceCacheSize (int numFontsToCache)
|
||||
{
|
||||
TypefaceCache::getInstance()->setSize (numFontsToCache);
|
||||
}
|
||||
|
||||
void (*clearOpenGLGlyphCache)() = nullptr;
|
||||
|
||||
void Typeface::clearTypefaceCache()
|
||||
{
|
||||
TypefaceCache::getInstance()->clear();
|
||||
|
||||
RenderingHelpers::SoftwareRendererSavedState::clearGlyphCache();
|
||||
|
||||
if (clearOpenGLGlyphCache != nullptr)
|
||||
clearOpenGLGlyphCache();
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
class Font::SharedFontInternal : public ReferenceCountedObject
|
||||
{
|
||||
public:
|
||||
SharedFontInternal() noexcept
|
||||
: typeface (TypefaceCache::getInstance()->getDefaultFace()),
|
||||
typefaceName (Font::getDefaultSansSerifFontName()),
|
||||
typefaceStyle (Font::getDefaultStyle()),
|
||||
height (FontValues::defaultFontHeight)
|
||||
{
|
||||
}
|
||||
|
||||
SharedFontInternal (int styleFlags, float fontHeight) noexcept
|
||||
: typefaceName (Font::getDefaultSansSerifFontName()),
|
||||
typefaceStyle (FontStyleHelpers::getStyleName (styleFlags)),
|
||||
height (fontHeight),
|
||||
underline ((styleFlags & underlined) != 0)
|
||||
{
|
||||
if (styleFlags == plain)
|
||||
typeface = TypefaceCache::getInstance()->getDefaultFace();
|
||||
}
|
||||
|
||||
SharedFontInternal (const String& name, int styleFlags, float fontHeight) noexcept
|
||||
: typefaceName (name),
|
||||
typefaceStyle (FontStyleHelpers::getStyleName (styleFlags)),
|
||||
height (fontHeight),
|
||||
underline ((styleFlags & underlined) != 0)
|
||||
{
|
||||
if (styleFlags == plain && typefaceName.isEmpty())
|
||||
typeface = TypefaceCache::getInstance()->getDefaultFace();
|
||||
}
|
||||
|
||||
SharedFontInternal (const String& name, const String& style, float fontHeight) noexcept
|
||||
: typefaceName (name), typefaceStyle (style), height (fontHeight)
|
||||
{
|
||||
if (typefaceName.isEmpty())
|
||||
typefaceName = Font::getDefaultSansSerifFontName();
|
||||
}
|
||||
|
||||
explicit SharedFontInternal (const Typeface::Ptr& face) noexcept
|
||||
: typeface (face),
|
||||
typefaceName (face->getName()),
|
||||
typefaceStyle (face->getStyle()),
|
||||
height (FontValues::defaultFontHeight)
|
||||
{
|
||||
jassert (typefaceName.isNotEmpty());
|
||||
}
|
||||
|
||||
SharedFontInternal (const SharedFontInternal& other) noexcept
|
||||
: ReferenceCountedObject(),
|
||||
typeface (other.typeface),
|
||||
typefaceName (other.typefaceName),
|
||||
typefaceStyle (other.typefaceStyle),
|
||||
height (other.height),
|
||||
horizontalScale (other.horizontalScale),
|
||||
kerning (other.kerning),
|
||||
ascent (other.ascent),
|
||||
underline (other.underline)
|
||||
{
|
||||
}
|
||||
|
||||
bool operator== (const SharedFontInternal& other) const noexcept
|
||||
{
|
||||
return height == other.height
|
||||
&& underline == other.underline
|
||||
&& horizontalScale == other.horizontalScale
|
||||
&& kerning == other.kerning
|
||||
&& typefaceName == other.typefaceName
|
||||
&& typefaceStyle == other.typefaceStyle;
|
||||
}
|
||||
|
||||
/* The typeface and ascent data members may be read/set from multiple threads
|
||||
simultaneously, e.g. in the case that two Font instances reference the same
|
||||
SharedFontInternal and call getTypefacePtr() simultaneously.
|
||||
|
||||
We lock in functions that modify the typeface or ascent in order to
|
||||
ensure thread safety.
|
||||
*/
|
||||
|
||||
Typeface::Ptr getTypefacePtr (const Font& f)
|
||||
{
|
||||
const ScopedLock lock (mutex);
|
||||
|
||||
if (typeface == nullptr)
|
||||
{
|
||||
typeface = TypefaceCache::getInstance()->findTypefaceFor (f);
|
||||
jassert (typeface != nullptr);
|
||||
}
|
||||
|
||||
return typeface;
|
||||
}
|
||||
|
||||
void checkTypefaceSuitability (const Font& f)
|
||||
{
|
||||
const ScopedLock lock (mutex);
|
||||
|
||||
if (typeface != nullptr && ! typeface->isSuitableForFont (f))
|
||||
typeface = nullptr;
|
||||
}
|
||||
|
||||
float getAscent (const Font& f)
|
||||
{
|
||||
const ScopedLock lock (mutex);
|
||||
|
||||
if (ascent == 0.0f)
|
||||
ascent = getTypefacePtr (f)->getAscent();
|
||||
|
||||
return height * ascent;
|
||||
}
|
||||
|
||||
/* We do not need to lock in these functions, as it's guaranteed
|
||||
that these data members can only change if there is a single Font
|
||||
instance referencing the shared state.
|
||||
*/
|
||||
|
||||
String getTypefaceName() const { return typefaceName; }
|
||||
String getTypefaceStyle() const { return typefaceStyle; }
|
||||
float getHeight() const { return height; }
|
||||
float getHorizontalScale() const { return horizontalScale; }
|
||||
float getKerning() const { return kerning; }
|
||||
bool getUnderline() const { return underline; }
|
||||
|
||||
/* This shared state may be shared between two or more Font instances that are being
|
||||
read/modified from multiple threads.
|
||||
Before modifying a shared instance you *must* call dupeInternalIfShared to
|
||||
ensure that only one Font instance is pointing to the SharedFontInternal instance
|
||||
during the modification.
|
||||
*/
|
||||
|
||||
void setTypeface (Typeface::Ptr x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
typeface = std::move (x);
|
||||
}
|
||||
|
||||
void setTypefaceName (String x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
typefaceName = std::move (x);
|
||||
}
|
||||
|
||||
void setTypefaceStyle (String x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
typefaceStyle = std::move (x);
|
||||
}
|
||||
|
||||
void setHeight (float x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
height = x;
|
||||
}
|
||||
|
||||
void setHorizontalScale (float x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
horizontalScale = x;
|
||||
}
|
||||
|
||||
void setKerning (float x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
kerning = x;
|
||||
}
|
||||
|
||||
void setAscent (float x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
ascent = x;
|
||||
}
|
||||
|
||||
void setUnderline (bool x)
|
||||
{
|
||||
jassert (getReferenceCount() == 1);
|
||||
underline = x;
|
||||
}
|
||||
|
||||
private:
|
||||
Typeface::Ptr typeface;
|
||||
String typefaceName, typefaceStyle;
|
||||
float height = 0.0f, horizontalScale = 1.0f, kerning = 0.0f, ascent = 0.0f;
|
||||
bool underline = false;
|
||||
|
||||
CriticalSection mutex;
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
Font::Font() : font (new SharedFontInternal()) {}
|
||||
Font::Font (const Typeface::Ptr& typeface) : font (new SharedFontInternal (typeface)) {}
|
||||
Font::Font (const Font& other) noexcept : font (other.font) {}
|
||||
|
||||
Font::Font (float fontHeight, int styleFlags)
|
||||
: font (new SharedFontInternal (styleFlags, FontValues::limitFontHeight (fontHeight)))
|
||||
{
|
||||
}
|
||||
|
||||
Font::Font (const String& typefaceName, float fontHeight, int styleFlags)
|
||||
: font (new SharedFontInternal (typefaceName, styleFlags, FontValues::limitFontHeight (fontHeight)))
|
||||
{
|
||||
}
|
||||
|
||||
Font::Font (const String& typefaceName, const String& typefaceStyle, float fontHeight)
|
||||
: font (new SharedFontInternal (typefaceName, typefaceStyle, FontValues::limitFontHeight (fontHeight)))
|
||||
{
|
||||
}
|
||||
|
||||
Font& Font::operator= (const Font& other) noexcept
|
||||
{
|
||||
font = other.font;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Font::Font (Font&& other) noexcept
|
||||
: font (std::move (other.font))
|
||||
{
|
||||
}
|
||||
|
||||
Font& Font::operator= (Font&& other) noexcept
|
||||
{
|
||||
font = std::move (other.font);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Font::~Font() noexcept = default;
|
||||
|
||||
bool Font::operator== (const Font& other) const noexcept
|
||||
{
|
||||
return font == other.font
|
||||
|| *font == *other.font;
|
||||
}
|
||||
|
||||
bool Font::operator!= (const Font& other) const noexcept
|
||||
{
|
||||
return ! operator== (other);
|
||||
}
|
||||
|
||||
void Font::dupeInternalIfShared()
|
||||
{
|
||||
if (font->getReferenceCount() > 1)
|
||||
font = *new SharedFontInternal (*font);
|
||||
}
|
||||
|
||||
void Font::checkTypefaceSuitability()
|
||||
{
|
||||
font->checkTypefaceSuitability (*this);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
struct FontPlaceholderNames
|
||||
{
|
||||
String sans { "<Sans-Serif>" },
|
||||
serif { "<Serif>" },
|
||||
mono { "<Monospaced>" },
|
||||
regular { "<Regular>" };
|
||||
};
|
||||
|
||||
static const FontPlaceholderNames& getFontPlaceholderNames()
|
||||
{
|
||||
static FontPlaceholderNames names;
|
||||
return names;
|
||||
}
|
||||
|
||||
#if JUCE_MSVC
|
||||
// This is a workaround for the lack of thread-safety in MSVC's handling of function-local
|
||||
// statics - if multiple threads all try to create the first Font object at the same time,
|
||||
// it can cause a race-condition in creating these placeholder strings.
|
||||
struct FontNamePreloader { FontNamePreloader() { getFontPlaceholderNames(); } };
|
||||
static FontNamePreloader fnp;
|
||||
#endif
|
||||
|
||||
const String& Font::getDefaultSansSerifFontName() { return getFontPlaceholderNames().sans; }
|
||||
const String& Font::getDefaultSerifFontName() { return getFontPlaceholderNames().serif; }
|
||||
const String& Font::getDefaultMonospacedFontName() { return getFontPlaceholderNames().mono; }
|
||||
const String& Font::getDefaultStyle() { return getFontPlaceholderNames().regular; }
|
||||
|
||||
String Font::getTypefaceName() const noexcept { return font->getTypefaceName(); }
|
||||
String Font::getTypefaceStyle() const noexcept { return font->getTypefaceStyle(); }
|
||||
|
||||
void Font::setTypefaceName (const String& faceName)
|
||||
{
|
||||
if (faceName != font->getTypefaceName())
|
||||
{
|
||||
jassert (faceName.isNotEmpty());
|
||||
|
||||
dupeInternalIfShared();
|
||||
font->setTypefaceName (faceName);
|
||||
font->setTypeface (nullptr);
|
||||
font->setAscent (0);
|
||||
}
|
||||
}
|
||||
|
||||
void Font::setTypefaceStyle (const String& typefaceStyle)
|
||||
{
|
||||
if (typefaceStyle != font->getTypefaceStyle())
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setTypefaceStyle (typefaceStyle);
|
||||
font->setTypeface (nullptr);
|
||||
font->setAscent (0);
|
||||
}
|
||||
}
|
||||
|
||||
Font Font::withTypefaceStyle (const String& newStyle) const
|
||||
{
|
||||
Font f (*this);
|
||||
f.setTypefaceStyle (newStyle);
|
||||
return f;
|
||||
}
|
||||
|
||||
StringArray Font::getAvailableStyles() const
|
||||
{
|
||||
return findAllTypefaceStyles (getTypefacePtr()->getName());
|
||||
}
|
||||
|
||||
Typeface::Ptr Font::getTypefacePtr() const
|
||||
{
|
||||
return font->getTypefacePtr (*this);
|
||||
}
|
||||
|
||||
Typeface* Font::getTypeface() const
|
||||
{
|
||||
return getTypefacePtr().get();
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
const String& Font::getFallbackFontName()
|
||||
{
|
||||
return FontValues::fallbackFont;
|
||||
}
|
||||
|
||||
void Font::setFallbackFontName (const String& name)
|
||||
{
|
||||
FontValues::fallbackFont = name;
|
||||
|
||||
#if JUCE_MAC || JUCE_IOS
|
||||
jassertfalse; // Note that use of a fallback font isn't currently implemented in OSX..
|
||||
#endif
|
||||
}
|
||||
|
||||
const String& Font::getFallbackFontStyle()
|
||||
{
|
||||
return FontValues::fallbackFontStyle;
|
||||
}
|
||||
|
||||
void Font::setFallbackFontStyle (const String& style)
|
||||
{
|
||||
FontValues::fallbackFontStyle = style;
|
||||
|
||||
#if JUCE_MAC || JUCE_IOS
|
||||
jassertfalse; // Note that use of a fallback font isn't currently implemented in OSX..
|
||||
#endif
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
Font Font::withHeight (const float newHeight) const
|
||||
{
|
||||
Font f (*this);
|
||||
f.setHeight (newHeight);
|
||||
return f;
|
||||
}
|
||||
|
||||
float Font::getHeightToPointsFactor() const
|
||||
{
|
||||
return getTypefacePtr()->getHeightToPointsFactor();
|
||||
}
|
||||
|
||||
Font Font::withPointHeight (float heightInPoints) const
|
||||
{
|
||||
Font f (*this);
|
||||
f.setHeight (heightInPoints / getHeightToPointsFactor());
|
||||
return f;
|
||||
}
|
||||
|
||||
void Font::setHeight (float newHeight)
|
||||
{
|
||||
newHeight = FontValues::limitFontHeight (newHeight);
|
||||
|
||||
if (font->getHeight() != newHeight)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setHeight (newHeight);
|
||||
checkTypefaceSuitability();
|
||||
}
|
||||
}
|
||||
|
||||
void Font::setHeightWithoutChangingWidth (float newHeight)
|
||||
{
|
||||
newHeight = FontValues::limitFontHeight (newHeight);
|
||||
|
||||
if (font->getHeight() != newHeight)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setHorizontalScale (font->getHorizontalScale() * (font->getHeight() / newHeight));
|
||||
font->setHeight (newHeight);
|
||||
checkTypefaceSuitability();
|
||||
}
|
||||
}
|
||||
|
||||
int Font::getStyleFlags() const noexcept
|
||||
{
|
||||
int styleFlags = font->getUnderline() ? underlined : plain;
|
||||
|
||||
if (isBold()) styleFlags |= bold;
|
||||
if (isItalic()) styleFlags |= italic;
|
||||
|
||||
return styleFlags;
|
||||
}
|
||||
|
||||
Font Font::withStyle (const int newFlags) const
|
||||
{
|
||||
Font f (*this);
|
||||
f.setStyleFlags (newFlags);
|
||||
return f;
|
||||
}
|
||||
|
||||
void Font::setStyleFlags (const int newFlags)
|
||||
{
|
||||
if (getStyleFlags() != newFlags)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setTypeface (nullptr);
|
||||
font->setTypefaceStyle (FontStyleHelpers::getStyleName (newFlags));
|
||||
font->setUnderline ((newFlags & underlined) != 0);
|
||||
font->setAscent (0);
|
||||
}
|
||||
}
|
||||
|
||||
void Font::setSizeAndStyle (float newHeight,
|
||||
const int newStyleFlags,
|
||||
const float newHorizontalScale,
|
||||
const float newKerningAmount)
|
||||
{
|
||||
newHeight = FontValues::limitFontHeight (newHeight);
|
||||
|
||||
if (font->getHeight() != newHeight
|
||||
|| font->getHorizontalScale() != newHorizontalScale
|
||||
|| font->getKerning() != newKerningAmount)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setHeight (newHeight);
|
||||
font->setHorizontalScale (newHorizontalScale);
|
||||
font->setKerning (newKerningAmount);
|
||||
checkTypefaceSuitability();
|
||||
}
|
||||
|
||||
setStyleFlags (newStyleFlags);
|
||||
}
|
||||
|
||||
void Font::setSizeAndStyle (float newHeight,
|
||||
const String& newStyle,
|
||||
const float newHorizontalScale,
|
||||
const float newKerningAmount)
|
||||
{
|
||||
newHeight = FontValues::limitFontHeight (newHeight);
|
||||
|
||||
if (font->getHeight() != newHeight
|
||||
|| font->getHorizontalScale() != newHorizontalScale
|
||||
|| font->getKerning() != newKerningAmount)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setHeight (newHeight);
|
||||
font->setHorizontalScale (newHorizontalScale);
|
||||
font->setKerning (newKerningAmount);
|
||||
checkTypefaceSuitability();
|
||||
}
|
||||
|
||||
setTypefaceStyle (newStyle);
|
||||
}
|
||||
|
||||
Font Font::withHorizontalScale (const float newHorizontalScale) const
|
||||
{
|
||||
Font f (*this);
|
||||
f.setHorizontalScale (newHorizontalScale);
|
||||
return f;
|
||||
}
|
||||
|
||||
void Font::setHorizontalScale (const float scaleFactor)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setHorizontalScale (scaleFactor);
|
||||
checkTypefaceSuitability();
|
||||
}
|
||||
|
||||
float Font::getHorizontalScale() const noexcept
|
||||
{
|
||||
return font->getHorizontalScale();
|
||||
}
|
||||
|
||||
float Font::getExtraKerningFactor() const noexcept
|
||||
{
|
||||
return font->getKerning();
|
||||
}
|
||||
|
||||
Font Font::withExtraKerningFactor (const float extraKerning) const
|
||||
{
|
||||
Font f (*this);
|
||||
f.setExtraKerningFactor (extraKerning);
|
||||
return f;
|
||||
}
|
||||
|
||||
void Font::setExtraKerningFactor (const float extraKerning)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setKerning (extraKerning);
|
||||
checkTypefaceSuitability();
|
||||
}
|
||||
|
||||
Font Font::boldened() const { return withStyle (getStyleFlags() | bold); }
|
||||
Font Font::italicised() const { return withStyle (getStyleFlags() | italic); }
|
||||
|
||||
bool Font::isBold() const noexcept { return FontStyleHelpers::isBold (font->getTypefaceStyle()); }
|
||||
bool Font::isItalic() const noexcept { return FontStyleHelpers::isItalic (font->getTypefaceStyle()); }
|
||||
bool Font::isUnderlined() const noexcept { return font->getUnderline(); }
|
||||
|
||||
void Font::setBold (const bool shouldBeBold)
|
||||
{
|
||||
auto flags = getStyleFlags();
|
||||
setStyleFlags (shouldBeBold ? (flags | bold)
|
||||
: (flags & ~bold));
|
||||
}
|
||||
|
||||
void Font::setItalic (const bool shouldBeItalic)
|
||||
{
|
||||
auto flags = getStyleFlags();
|
||||
setStyleFlags (shouldBeItalic ? (flags | italic)
|
||||
: (flags & ~italic));
|
||||
}
|
||||
|
||||
void Font::setUnderline (const bool shouldBeUnderlined)
|
||||
{
|
||||
dupeInternalIfShared();
|
||||
font->setUnderline (shouldBeUnderlined);
|
||||
checkTypefaceSuitability();
|
||||
}
|
||||
|
||||
float Font::getAscent() const
|
||||
{
|
||||
return font->getAscent (*this);
|
||||
}
|
||||
|
||||
float Font::getHeight() const noexcept { return font->getHeight(); }
|
||||
float Font::getDescent() const { return font->getHeight() - getAscent(); }
|
||||
|
||||
float Font::getHeightInPoints() const { return getHeight() * getHeightToPointsFactor(); }
|
||||
float Font::getAscentInPoints() const { return getAscent() * getHeightToPointsFactor(); }
|
||||
float Font::getDescentInPoints() const { return getDescent() * getHeightToPointsFactor(); }
|
||||
|
||||
int Font::getStringWidth (const String& text) const
|
||||
{
|
||||
return (int) std::ceil (getStringWidthFloat (text));
|
||||
}
|
||||
|
||||
float Font::getStringWidthFloat (const String& text) const
|
||||
{
|
||||
auto w = getTypefacePtr()->getStringWidth (text);
|
||||
|
||||
if (font->getKerning() != 0.0f)
|
||||
w += font->getKerning() * (float) text.length();
|
||||
|
||||
return w * font->getHeight() * font->getHorizontalScale();
|
||||
}
|
||||
|
||||
void Font::getGlyphPositions (const String& text, Array<int>& glyphs, Array<float>& xOffsets) const
|
||||
{
|
||||
getTypefacePtr()->getGlyphPositions (text, glyphs, xOffsets);
|
||||
|
||||
if (auto num = xOffsets.size())
|
||||
{
|
||||
auto scale = font->getHeight() * font->getHorizontalScale();
|
||||
auto* x = xOffsets.getRawDataPointer();
|
||||
|
||||
if (font->getKerning() != 0.0f)
|
||||
{
|
||||
for (int i = 0; i < num; ++i)
|
||||
x[i] = (x[i] + (float) i * font->getKerning()) * scale;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = 0; i < num; ++i)
|
||||
x[i] *= scale;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Font::findFonts (Array<Font>& destArray)
|
||||
{
|
||||
for (auto& name : findAllTypefaceNames())
|
||||
{
|
||||
auto styles = findAllTypefaceStyles (name);
|
||||
|
||||
String style ("Regular");
|
||||
|
||||
if (! styles.contains (style, true))
|
||||
style = styles[0];
|
||||
|
||||
destArray.add (Font (name, style, FontValues::defaultFontHeight));
|
||||
}
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
String Font::toString() const
|
||||
{
|
||||
String s;
|
||||
|
||||
if (getTypefaceName() != getDefaultSansSerifFontName())
|
||||
s << getTypefaceName() << "; ";
|
||||
|
||||
s << String (getHeight(), 1);
|
||||
|
||||
if (getTypefaceStyle() != getDefaultStyle())
|
||||
s << ' ' << getTypefaceStyle();
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
Font Font::fromString (const String& fontDescription)
|
||||
{
|
||||
const int separator = fontDescription.indexOfChar (';');
|
||||
String name;
|
||||
|
||||
if (separator > 0)
|
||||
name = fontDescription.substring (0, separator).trim();
|
||||
|
||||
if (name.isEmpty())
|
||||
name = getDefaultSansSerifFontName();
|
||||
|
||||
String sizeAndStyle (fontDescription.substring (separator + 1).trimStart());
|
||||
|
||||
float height = sizeAndStyle.getFloatValue();
|
||||
if (height <= 0)
|
||||
height = 10.0f;
|
||||
|
||||
const String style (sizeAndStyle.fromFirstOccurrenceOf (" ", false, false));
|
||||
|
||||
return Font (name, style, height);
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
Reference in New Issue
Block a user