static gfxFloat ComputeMaxDescent(const gfxFont::Metrics& aMetrics,
gfxFontGroup* aFontGroup)
{
gfxFloat offset = NS_floor(-aFontGroup->GetUnderlineOffset() + 0.5);
gfxFloat size = NS_round(aMetrics.underlineSize);
gfxFloat minDescent = NS_floor(offset + size + 0.5);
return PR_MAX(minDescent, aMetrics.maxDescent);
}
// Snap a line to pixels while keeping the center and size of the
// line as close to the original position as possible.
static void SnapLineToPixels(gfxFloat& aOffset, gfxFloat& aSize)
{
gfxFloat snappedSize = PR_MAX(NS_floor(aSize + 0.5), 1.0);
// Correct offset for change in size
gfxFloat offset = aOffset - 0.5 * (aSize - snappedSize);
// Snap offset
aOffset = NS_floor(offset + 0.5);
aSize = snappedSize;
}
void
gfxRect::RoundOut()
{
gfxFloat x0 = NS_floor(X());
gfxFloat y0 = NS_floor(Y());
gfxFloat x1 = NS_ceil(XMost());
gfxFloat y1 = NS_ceil(YMost());
pos.x = x0;
pos.y = y0;
size.width = x1 - x0;
size.height = y1 - y0;
}
void
gfxRect::Round()
{
// Note that don't use NS_round here. See the comment for this method in gfxRect.h
gfxFloat x0 = NS_floor(X() + 0.5);
gfxFloat y0 = NS_floor(Y() + 0.5);
gfxFloat x1 = NS_floor(XMost() + 0.5);
gfxFloat y1 = NS_floor(YMost() + 0.5);
pos.x = x0;
pos.y = y0;
size.width = x1 - x0;
size.height = y1 - y0;
}
// gfxOS2Font::GetMetrics()
// return the metrics of the current font using the gfxFont metrics structure.
// If the metrics are not available yet, compute them using the FreeType
// function on the font. (This is partly based on the respective function from
// gfxPangoFonts)
const gfxFont::Metrics& gfxOS2Font::GetMetrics()
{
#ifdef DEBUG_thebes_1
printf("gfxOS2Font[%#x]::GetMetrics()\n", (unsigned)this);
#endif
if (mMetrics) {
return *mMetrics;
}
// whatever happens below, we can always create the metrics
mMetrics = new gfxFont::Metrics;
mSpaceGlyph = 0;
// round size to integer pixels, this is to get full pixels for layout
// together with internal/external leading (see below)
mMetrics->emHeight = NS_floor(GetStyle()->size + 0.5);
FT_Face face = cairo_ft_scaled_font_lock_face(CairoScaledFont());
if (!face) {
// Abort here already, otherwise we crash in the following
// this can happen if the font-size requested is zero.
FillMetricsDefaults(mMetrics);
return *mMetrics;
}
if (!face->charmap) {
// Also abort, if the charmap isn't loaded; then the char
// lookups won't work. This happens for fonts without Unicode
// charmap.
cairo_ft_scaled_font_unlock_face(CairoScaledFont());
FillMetricsDefaults(mMetrics);
return *mMetrics;
}
// compute font scaling factors
gfxFloat emUnit = 1.0 * face->units_per_EM;
gfxFloat xScale = face->size->metrics.x_ppem / emUnit;
gfxFloat yScale = face->size->metrics.y_ppem / emUnit;
FT_UInt gid; // glyph ID
// properties of space
gid = FT_Get_Char_Index(face, ' ');
if (gid) {
// Load glyph into glyph slot. Use load_default here to get results in
// 26.6 fractional pixel format which is what is used for all other
// characters in gfxOS2FontGroup::CreateGlyphRunsFT.
FT_Load_Glyph(face, gid, FT_LOAD_DEFAULT);
// glyph width doesn't work for spaces, use advance instead
mMetrics->spaceWidth = face->glyph->advance.x >> 6;
// save the space glyph
mSpaceGlyph = gid;
} else {
PRBool
nsNativeTheme::QueueAnimatedContentForRefresh(nsIContent* aContent,
PRUint32 aMinimumFrameRate)
{
NS_ASSERTION(aContent, "Null pointer!");
NS_ASSERTION(aMinimumFrameRate, "aMinimumFrameRate must be non-zero!");
NS_ASSERTION(aMinimumFrameRate <= 1000,
"aMinimumFrameRate must be less than 1000!");
PRUint32 timeout = PRUint32(NS_floor(1000 / aMinimumFrameRate));
timeout = PR_MIN(mAnimatedContentTimeout, timeout);
if (!mAnimatedContentTimer) {
mAnimatedContentTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
NS_ENSURE_TRUE(mAnimatedContentTimer, PR_FALSE);
}
if (mAnimatedContentList.IsEmpty() || timeout != mAnimatedContentTimeout) {
nsresult rv;
if (!mAnimatedContentList.IsEmpty()) {
rv = mAnimatedContentTimer->Cancel();
NS_ENSURE_SUCCESS(rv, PR_FALSE);
}
rv = mAnimatedContentTimer->InitWithCallback(this, timeout,
nsITimer::TYPE_ONE_SHOT);
NS_ENSURE_SUCCESS(rv, PR_FALSE);
mAnimatedContentTimeout = timeout;
}
if (!mAnimatedContentList.AppendElement(aContent)) {
NS_WARNING("Out of memory!");
return PR_FALSE;
}
return PR_TRUE;
}
static gfxFloat ComputeMaxAscent(const gfxFont::Metrics& aMetrics)
{
return NS_floor(aMetrics.maxAscent + 0.5);
}
void
gfxFT2LockedFace::GetMetrics(gfxFont::Metrics* aMetrics,
PRUint32* aSpaceGlyph)
{
NS_PRECONDITION(aMetrics != NULL, "aMetrics must not be NULL");
NS_PRECONDITION(aSpaceGlyph != NULL, "aSpaceGlyph must not be NULL");
if (NS_UNLIKELY(!mFace)) {
// No face. This unfortunate situation might happen if the font
// file is (re)moved at the wrong time.
aMetrics->emHeight = mGfxFont->GetStyle()->size;
aMetrics->emAscent = 0.8 * aMetrics->emHeight;
aMetrics->emDescent = 0.2 * aMetrics->emHeight;
aMetrics->maxAscent = aMetrics->emAscent;
aMetrics->maxDescent = aMetrics->maxDescent;
aMetrics->maxHeight = aMetrics->emHeight;
aMetrics->internalLeading = 0.0;
aMetrics->externalLeading = 0.2 * aMetrics->emHeight;
aSpaceGlyph = 0;
aMetrics->spaceWidth = 0.5 * aMetrics->emHeight;
aMetrics->maxAdvance = aMetrics->spaceWidth;
aMetrics->aveCharWidth = aMetrics->spaceWidth;
aMetrics->zeroOrAveCharWidth = aMetrics->spaceWidth;
aMetrics->xHeight = 0.5 * aMetrics->emHeight;
aMetrics->underlineSize = aMetrics->emHeight / 14.0;
aMetrics->underlineOffset = -aMetrics->underlineSize;
aMetrics->strikeoutOffset = 0.25 * aMetrics->emHeight;
aMetrics->strikeoutSize = aMetrics->underlineSize;
aMetrics->superscriptOffset = aMetrics->xHeight;
aMetrics->subscriptOffset = aMetrics->xHeight;
return;
}
const FT_Size_Metrics& ftMetrics = mFace->size->metrics;
gfxFloat emHeight;
// Scale for vertical design metric conversion: pixels per design unit.
gfxFloat yScale;
if (FT_IS_SCALABLE(mFace)) {
// Prefer FT_Size_Metrics::x_scale to x_ppem as x_ppem does not
// have subpixel accuracy.
//
// FT_Size_Metrics::y_scale is in 16.16 fixed point format. Its
// (fractional) value is a factor that converts vertical metrics from
// design units to units of 1/64 pixels, so that the result may be
// interpreted as pixels in 26.6 fixed point format.
yScale = FLOAT_FROM_26_6(FLOAT_FROM_16_16(ftMetrics.y_scale));
emHeight = mFace->units_per_EM * yScale;
} else { // Not scalable.
// FT_Size_Metrics doc says x_scale is "only relevant for scalable
// font formats".
gfxFloat emUnit = mFace->units_per_EM;
emHeight = ftMetrics.y_ppem;
yScale = emHeight / emUnit;
}
TT_OS2 *os2 =
static_cast<TT_OS2*>(FT_Get_Sfnt_Table(mFace, ft_sfnt_os2));
aMetrics->maxAscent = FLOAT_FROM_26_6(ftMetrics.ascender);
aMetrics->maxDescent = -FLOAT_FROM_26_6(ftMetrics.descender);
aMetrics->maxAdvance = FLOAT_FROM_26_6(ftMetrics.max_advance);
gfxFloat lineHeight;
if (os2 && os2->sTypoAscender) {
aMetrics->emAscent = os2->sTypoAscender * yScale;
aMetrics->emDescent = -os2->sTypoDescender * yScale;
FT_Short typoHeight =
os2->sTypoAscender - os2->sTypoDescender + os2->sTypoLineGap;
lineHeight = typoHeight * yScale;
// maxAscent/maxDescent get used for frame heights, and some fonts
// don't have the HHEA table ascent/descent set (bug 279032).
if (aMetrics->emAscent > aMetrics->maxAscent)
aMetrics->maxAscent = aMetrics->emAscent;
if (aMetrics->emDescent > aMetrics->maxDescent)
aMetrics->maxDescent = aMetrics->emDescent;
} else {
aMetrics->emAscent = aMetrics->maxAscent;
aMetrics->emDescent = aMetrics->maxDescent;
lineHeight = FLOAT_FROM_26_6(ftMetrics.height);
}
cairo_text_extents_t extents;
*aSpaceGlyph = GetCharExtents(' ', &extents);
if (*aSpaceGlyph) {
aMetrics->spaceWidth = extents.x_advance;
} else {
aMetrics->spaceWidth = aMetrics->maxAdvance; // guess
}
aMetrics->zeroOrAveCharWidth = 0.0;
if (GetCharExtents('0', &extents)) {
aMetrics->zeroOrAveCharWidth = extents.x_advance;
}
// Prefering a measured x over sxHeight because sxHeight doesn't consider
// hinting, but maybe the x extents are not quite right in some fancy
// script fonts. CSS 2.1 suggests possibly using the height of an "o",
// which would have a more consistent glyph across fonts.
if (GetCharExtents('x', &extents) && extents.y_bearing < 0.0) {
aMetrics->xHeight = -extents.y_bearing;
aMetrics->aveCharWidth = extents.x_advance;
} else {
if (os2 && os2->sxHeight) {
aMetrics->xHeight = os2->sxHeight * yScale;
} else {
// CSS 2.1, section 4.3.2 Lengths: "In the cases where it is
// impossible or impractical to determine the x-height, a value of
// 0.5em should be used."
aMetrics->xHeight = 0.5 * emHeight;
}
aMetrics->aveCharWidth = 0.0; // updated below
}
// aveCharWidth is used for the width of text input elements so be
// liberal rather than conservative in the estimate.
if (os2 && os2->xAvgCharWidth) {
// Round to pixels as this is compared with maxAdvance to guess
// whether this is a fixed width font.
gfxFloat avgCharWidth =
ScaleRoundDesignUnits(os2->xAvgCharWidth, ftMetrics.x_scale);
aMetrics->aveCharWidth =
NS_MAX(aMetrics->aveCharWidth, avgCharWidth);
}
aMetrics->aveCharWidth =
NS_MAX(aMetrics->aveCharWidth, aMetrics->zeroOrAveCharWidth);
if (aMetrics->aveCharWidth == 0.0) {
aMetrics->aveCharWidth = aMetrics->spaceWidth;
}
if (aMetrics->zeroOrAveCharWidth == 0.0) {
aMetrics->zeroOrAveCharWidth = aMetrics->aveCharWidth;
}
// Apparently hinting can mean that max_advance is not always accurate.
aMetrics->maxAdvance =
NS_MAX(aMetrics->maxAdvance, aMetrics->aveCharWidth);
// gfxFont::Metrics::underlineOffset is the position of the top of the
// underline.
//
// FT_FaceRec documentation describes underline_position as "the
// center of the underlining stem". This was the original definition
// of the PostScript metric, but in the PostScript table of OpenType
// fonts the metric is "the top of the underline"
// (http://www.microsoft.com/typography/otspec/post.htm), and FreeType
// (up to version 2.3.7) doesn't make any adjustment.
//
// Therefore get the underline position directly from the table
// ourselves when this table exists. Use FreeType's metrics for
// other (including older PostScript) fonts.
if (mFace->underline_position && mFace->underline_thickness) {
aMetrics->underlineSize = mFace->underline_thickness * yScale;
TT_Postscript *post = static_cast<TT_Postscript*>
(FT_Get_Sfnt_Table(mFace, ft_sfnt_post));
if (post && post->underlinePosition) {
aMetrics->underlineOffset = post->underlinePosition * yScale;
} else {
aMetrics->underlineOffset = mFace->underline_position * yScale
+ 0.5 * aMetrics->underlineSize;
}
} else { // No underline info.
// Imitate Pango.
aMetrics->underlineSize = emHeight / 14.0;
aMetrics->underlineOffset = -aMetrics->underlineSize;
}
if (os2 && os2->yStrikeoutSize && os2->yStrikeoutPosition) {
aMetrics->strikeoutSize = os2->yStrikeoutSize * yScale;
aMetrics->strikeoutOffset = os2->yStrikeoutPosition * yScale;
} else { // No strikeout info.
aMetrics->strikeoutSize = aMetrics->underlineSize;
// Use OpenType spec's suggested position for Roman font.
aMetrics->strikeoutOffset = emHeight * 409.0 / 2048.0
+ 0.5 * aMetrics->strikeoutSize;
}
SnapLineToPixels(aMetrics->strikeoutOffset, aMetrics->strikeoutSize);
if (os2 && os2->ySuperscriptYOffset) {
gfxFloat val = ScaleRoundDesignUnits(os2->ySuperscriptYOffset,
ftMetrics.y_scale);
aMetrics->superscriptOffset = NS_MAX(1.0, val);
} else {
aMetrics->superscriptOffset = aMetrics->xHeight;
}
if (os2 && os2->ySubscriptYOffset) {
gfxFloat val = ScaleRoundDesignUnits(os2->ySubscriptYOffset,
ftMetrics.y_scale);
// some fonts have the incorrect sign.
val = fabs(val);
aMetrics->subscriptOffset = NS_MAX(1.0, val);
} else {
aMetrics->subscriptOffset = aMetrics->xHeight;
}
aMetrics->maxHeight = aMetrics->maxAscent + aMetrics->maxDescent;
// Make the line height an integer number of pixels so that lines will be
// equally spaced (rather than just being snapped to pixels, some up and
// some down). Layout calculates line height from the emHeight +
// internalLeading + externalLeading, but first each of these is rounded
// to layout units. To ensure that the result is an integer number of
// pixels, round each of the components to pixels.
aMetrics->emHeight = NS_floor(emHeight + 0.5);
// maxHeight will normally be an integer, but round anyway in case
// FreeType is configured differently.
aMetrics->internalLeading =
NS_floor(aMetrics->maxHeight - aMetrics->emHeight + 0.5);
// Text input boxes currently don't work well with lineHeight
// significantly less than maxHeight (with Verdana, for example).
lineHeight = NS_floor(NS_MAX(lineHeight, aMetrics->maxHeight) + 0.5);
aMetrics->externalLeading =
lineHeight - aMetrics->internalLeading - aMetrics->emHeight;
// Ensure emAscent + emDescent == emHeight
gfxFloat sum = aMetrics->emAscent + aMetrics->emDescent;
aMetrics->emAscent = sum > 0.0 ?
aMetrics->emAscent * aMetrics->emHeight / sum : 0.0;
aMetrics->emDescent = aMetrics->emHeight - aMetrics->emAscent;
}
