289 lines
10 KiB
C++
289 lines
10 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/. */
|
|
|
|
#include "gfxFontMissingGlyphs.h"
|
|
|
|
#include "gfxUtils.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/gfx/Helpers.h"
|
|
#include "mozilla/gfx/PathHelpers.h"
|
|
#include "mozilla/RefPtr.h"
|
|
#include "nsDeviceContext.h"
|
|
#include "nsLayoutUtils.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::gfx;
|
|
|
|
#define CHAR_BITS(b00, b01, b02, b10, b11, b12, b20, b21, b22, b30, b31, b32, b40, b41, b42) \
|
|
((b00 << 0) | (b01 << 1) | (b02 << 2) | (b10 << 3) | (b11 << 4) | (b12 << 5) | \
|
|
(b20 << 6) | (b21 << 7) | (b22 << 8) | (b30 << 9) | (b31 << 10) | (b32 << 11) | \
|
|
(b40 << 12) | (b41 << 13) | (b42 << 14))
|
|
|
|
static const uint16_t glyphMicroFont[16] = {
|
|
CHAR_BITS(0, 1, 0,
|
|
1, 0, 1,
|
|
1, 0, 1,
|
|
1, 0, 1,
|
|
0, 1, 0),
|
|
CHAR_BITS(0, 1, 0,
|
|
0, 1, 0,
|
|
0, 1, 0,
|
|
0, 1, 0,
|
|
0, 1, 0),
|
|
CHAR_BITS(1, 1, 1,
|
|
0, 0, 1,
|
|
1, 1, 1,
|
|
1, 0, 0,
|
|
1, 1, 1),
|
|
CHAR_BITS(1, 1, 1,
|
|
0, 0, 1,
|
|
1, 1, 1,
|
|
0, 0, 1,
|
|
1, 1, 1),
|
|
CHAR_BITS(1, 0, 1,
|
|
1, 0, 1,
|
|
1, 1, 1,
|
|
0, 0, 1,
|
|
0, 0, 1),
|
|
CHAR_BITS(1, 1, 1,
|
|
1, 0, 0,
|
|
1, 1, 1,
|
|
0, 0, 1,
|
|
1, 1, 1),
|
|
CHAR_BITS(1, 1, 1,
|
|
1, 0, 0,
|
|
1, 1, 1,
|
|
1, 0, 1,
|
|
1, 1, 1),
|
|
CHAR_BITS(1, 1, 1,
|
|
0, 0, 1,
|
|
0, 0, 1,
|
|
0, 0, 1,
|
|
0, 0, 1),
|
|
CHAR_BITS(0, 1, 0,
|
|
1, 0, 1,
|
|
0, 1, 0,
|
|
1, 0, 1,
|
|
0, 1, 0),
|
|
CHAR_BITS(1, 1, 1,
|
|
1, 0, 1,
|
|
1, 1, 1,
|
|
0, 0, 1,
|
|
0, 0, 1),
|
|
CHAR_BITS(1, 1, 1,
|
|
1, 0, 1,
|
|
1, 1, 1,
|
|
1, 0, 1,
|
|
1, 0, 1),
|
|
CHAR_BITS(1, 1, 0,
|
|
1, 0, 1,
|
|
1, 1, 0,
|
|
1, 0, 1,
|
|
1, 1, 0),
|
|
CHAR_BITS(0, 1, 1,
|
|
1, 0, 0,
|
|
1, 0, 0,
|
|
1, 0, 0,
|
|
0, 1, 1),
|
|
CHAR_BITS(1, 1, 0,
|
|
1, 0, 1,
|
|
1, 0, 1,
|
|
1, 0, 1,
|
|
1, 1, 0),
|
|
CHAR_BITS(1, 1, 1,
|
|
1, 0, 0,
|
|
1, 1, 1,
|
|
1, 0, 0,
|
|
1, 1, 1),
|
|
CHAR_BITS(1, 1, 1,
|
|
1, 0, 0,
|
|
1, 1, 1,
|
|
1, 0, 0,
|
|
1, 0, 0)
|
|
};
|
|
|
|
/* Parameters that control the rendering of hexboxes. They look like this:
|
|
|
|
BMP codepoints non-BMP codepoints
|
|
(U+0000 - U+FFFF) (U+10000 - U+10FFFF)
|
|
|
|
+---------+ +-------------+
|
|
| | | |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| | | |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| HHH HHH | | HHH HHH HHH |
|
|
| | | |
|
|
+---------+ +-------------+
|
|
*/
|
|
|
|
/** Width of a minifont glyph (see above) */
|
|
static const int MINIFONT_WIDTH = 3;
|
|
/** Height of a minifont glyph (see above) */
|
|
static const int MINIFONT_HEIGHT = 5;
|
|
/**
|
|
* Gap between minifont glyphs (both horizontal and vertical) and also
|
|
* the minimum desired gap between the box border and the glyphs
|
|
*/
|
|
static const int HEX_CHAR_GAP = 1;
|
|
/**
|
|
* The amount of space between the vertical edge of the glyphbox and the
|
|
* box border. We make this nonzero so that when multiple missing glyphs
|
|
* occur consecutively there's a gap between their rendered boxes.
|
|
*/
|
|
static const int BOX_HORIZONTAL_INSET = 1;
|
|
/** The width of the border */
|
|
static const int BOX_BORDER_WIDTH = 1;
|
|
/**
|
|
* The scaling factor for the border opacity; this is multiplied by the current
|
|
* opacity being used to draw the text.
|
|
*/
|
|
static const Float BOX_BORDER_OPACITY = 0.5;
|
|
/**
|
|
* Draw a single hex character using the current color. A nice way to do this
|
|
* would be to fill in an A8 image surface and then use it as a mask
|
|
* to paint the current color. Tragically this doesn't currently work with the
|
|
* Quartz cairo backend which doesn't generally support masking with surfaces.
|
|
* So for now we just paint a bunch of rectangles...
|
|
*/
|
|
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
|
|
static void
|
|
DrawHexChar(uint32_t aDigit, const Point& aPt, DrawTarget& aDrawTarget,
|
|
const Pattern &aPattern)
|
|
{
|
|
// To avoid the potential for seams showing between rects when we're under
|
|
// a transform we concat all the rects into a PathBuilder and fill the
|
|
// resulting Path (rather than using DrawTarget::FillRect).
|
|
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
|
|
uint32_t glyphBits = glyphMicroFont[aDigit];
|
|
for (int y = 0; y < MINIFONT_HEIGHT; ++y) {
|
|
for (int x = 0; x < MINIFONT_WIDTH; ++x) {
|
|
if (glyphBits & 1) {
|
|
Rect r(aPt.x + x, aPt.y + y, 1, 1);
|
|
MaybeSnapToDevicePixels(r, aDrawTarget, true);
|
|
builder->MoveTo(r.TopLeft());
|
|
builder->LineTo(r.TopRight());
|
|
builder->LineTo(r.BottomRight());
|
|
builder->LineTo(r.BottomLeft());
|
|
builder->Close();
|
|
}
|
|
glyphBits >>= 1;
|
|
}
|
|
}
|
|
RefPtr<Path> path = builder->Finish();
|
|
aDrawTarget.Fill(path, aPattern);
|
|
}
|
|
#endif // MOZ_GFX_OPTIMIZE_MOBILE
|
|
|
|
void
|
|
gfxFontMissingGlyphs::DrawMissingGlyph(uint32_t aChar,
|
|
const Rect& aRect,
|
|
DrawTarget& aDrawTarget,
|
|
const Pattern& aPattern,
|
|
uint32_t aAppUnitsPerDevPixel)
|
|
{
|
|
// If we're currently drawing with some kind of pattern, we just draw the
|
|
// missing-glyph data in black.
|
|
ColorPattern color = aPattern.GetType() == PatternType::COLOR ?
|
|
static_cast<const ColorPattern&>(aPattern) :
|
|
ColorPattern(ToDeviceColor(Color(0.f, 0.f, 0.f, 1.f)));
|
|
|
|
// Stroke a rectangle so that the stroke's left edge is inset one pixel
|
|
// from the left edge of the glyph box and the stroke's right edge
|
|
// is inset one pixel from the right edge of the glyph box.
|
|
Float halfBorderWidth = BOX_BORDER_WIDTH / 2.0;
|
|
Float borderLeft = aRect.X() + BOX_HORIZONTAL_INSET + halfBorderWidth;
|
|
Float borderRight = aRect.XMost() - BOX_HORIZONTAL_INSET - halfBorderWidth;
|
|
Rect borderStrokeRect(borderLeft, aRect.Y() + halfBorderWidth,
|
|
borderRight - borderLeft,
|
|
aRect.Height() - 2.0 * halfBorderWidth);
|
|
if (!borderStrokeRect.IsEmpty()) {
|
|
ColorPattern adjustedColor = color;
|
|
color.mColor.a *= BOX_BORDER_OPACITY;
|
|
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
|
|
aDrawTarget.FillRect(borderStrokeRect, adjustedColor);
|
|
#else
|
|
StrokeOptions strokeOptions(BOX_BORDER_WIDTH);
|
|
aDrawTarget.StrokeRect(borderStrokeRect, adjustedColor, strokeOptions);
|
|
#endif
|
|
}
|
|
|
|
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
|
|
Point center = aRect.Center();
|
|
Float halfGap = HEX_CHAR_GAP / 2.f;
|
|
Float top = -(MINIFONT_HEIGHT + halfGap);
|
|
// We always want integer scaling, otherwise the "bitmap" glyphs will look
|
|
// even uglier than usual when zoomed
|
|
int32_t devPixelsPerCSSPx =
|
|
std::max<int32_t>(1, nsDeviceContext::AppUnitsPerCSSPixel() /
|
|
aAppUnitsPerDevPixel);
|
|
AutoRestoreTransform autoRestoreTransform(&aDrawTarget);
|
|
aDrawTarget.SetTransform(
|
|
aDrawTarget.GetTransform().PreTranslate(center).
|
|
PreScale(devPixelsPerCSSPx,
|
|
devPixelsPerCSSPx));
|
|
if (aChar < 0x10000) {
|
|
if (aRect.Width() >= 2 * (MINIFONT_WIDTH + HEX_CHAR_GAP) &&
|
|
aRect.Height() >= 2 * MINIFONT_HEIGHT + HEX_CHAR_GAP) {
|
|
// Draw 4 digits for BMP
|
|
Float left = -(MINIFONT_WIDTH + halfGap);
|
|
DrawHexChar((aChar >> 12) & 0xF,
|
|
Point(left, top), aDrawTarget, color);
|
|
DrawHexChar((aChar >> 8) & 0xF,
|
|
Point(halfGap, top), aDrawTarget, color);
|
|
DrawHexChar((aChar >> 4) & 0xF,
|
|
Point(left, halfGap), aDrawTarget, color);
|
|
DrawHexChar(aChar & 0xF,
|
|
Point(halfGap, halfGap), aDrawTarget, color);
|
|
}
|
|
} else {
|
|
if (aRect.Width() >= 3 * (MINIFONT_WIDTH + HEX_CHAR_GAP) &&
|
|
aRect.Height() >= 2 * MINIFONT_HEIGHT + HEX_CHAR_GAP) {
|
|
// Draw 6 digits for non-BMP
|
|
Float first = -(MINIFONT_WIDTH * 1.5 + HEX_CHAR_GAP);
|
|
Float second = -(MINIFONT_WIDTH / 2.0);
|
|
Float third = (MINIFONT_WIDTH / 2.0 + HEX_CHAR_GAP);
|
|
DrawHexChar((aChar >> 20) & 0xF,
|
|
Point(first, top), aDrawTarget, color);
|
|
DrawHexChar((aChar >> 16) & 0xF,
|
|
Point(second, top), aDrawTarget, color);
|
|
DrawHexChar((aChar >> 12) & 0xF,
|
|
Point(third, top), aDrawTarget, color);
|
|
DrawHexChar((aChar >> 8) & 0xF,
|
|
Point(first, halfGap), aDrawTarget, color);
|
|
DrawHexChar((aChar >> 4) & 0xF,
|
|
Point(second, halfGap), aDrawTarget, color);
|
|
DrawHexChar(aChar & 0xF,
|
|
Point(third, halfGap), aDrawTarget, color);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
Float
|
|
gfxFontMissingGlyphs::GetDesiredMinWidth(uint32_t aChar,
|
|
uint32_t aAppUnitsPerDevPixel)
|
|
{
|
|
/**
|
|
* The minimum desired width for a missing-glyph glyph box. I've laid it out
|
|
* like this so you can see what goes where.
|
|
*/
|
|
Float width = BOX_HORIZONTAL_INSET + BOX_BORDER_WIDTH + HEX_CHAR_GAP +
|
|
MINIFONT_WIDTH + HEX_CHAR_GAP + MINIFONT_WIDTH +
|
|
((aChar < 0x10000) ? 0 : HEX_CHAR_GAP + MINIFONT_WIDTH) +
|
|
HEX_CHAR_GAP + BOX_BORDER_WIDTH + BOX_HORIZONTAL_INSET;
|
|
// Note that this will give us floating-point division, so the width will
|
|
// -not- be snapped to integer multiples of its basic pixel value
|
|
width *= Float(nsDeviceContext::AppUnitsPerCSSPixel()) / aAppUnitsPerDevPixel;
|
|
return width;
|
|
}
|