This uses a technique devised by Sean Anderson, July 13, 2001 as found
at http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith32Bits
This technique uses 3 multiplies rather than just shifts and masks, but
performance seems comparable to the old approach, (but more significantly,
the new approach is easier to implement as a macro, and I plan to start
using this bit-swapping elsewhere very soon).
This was a gratuitous thing that was causing excessive fallbacks in
mozilla printing to PDF. The only reason it was ever there was to
get some of the tests that rely on CAIRO_ANTIALIAS_NONE to pass.
Instead we now simply don't run those tests against the PDF backend.
cairo freetype font backend doesn't handle fontconfig configurations
quiet well, it always renders glyphs using configurations in
scaled_font->base.options which usually isn't corresponding to
font pattern used to create the font face and the load flags. As a
result, turning antialias off with fontconfig doesn't work with cairo
HEAD, subpixel order either.
This commit make cairo respect configurations in font pattern and handle
load flags correctly. The ft-text-antialias-none test case passess now.
And should fix bug #6759 and #4792.
Previously, using the ps or pdf backend with a bitmapped font would
result in a coorupt output file, filled with uninitialized values and
missing procedures for drawing the glyphs.
Now, the file should actually be valid, but it's simply drawing black
boxes instead of the correct glyphs.
This allows graceful recovery when first requesting a path from a font
that only supports bitmapped glyph. The changed return type is also
pushed down into the scaled_glyph_init function of the
cairo_scaled_font backend.
The aliases should allow binaries with the old symbols to continue to run.
Meanwhile, the macros in cairo.h prevent any code from being compiled without
using the new, future-proof function names.
This is a temporary, transition strategy and the aliases will be dropped
before the next major release.
Most internal cairo types are transparent within cairo and have init and fini
functions to intialize and finialize them in place. This way they can be
easily be embedded in other structs or derived from. Initially, the
cairo_output_stream_t type was proposed as a publically visible type and
thus kept opaque. However, now it's only used internally and derived from
in a number of places so let's make it an embeddable type for consistency
and ease of use.
The patch keeps _cairo_output_stream_create() and _cairo_output_stream_close()
around for (internal) backwards compatibility by deriving a
cairo_output_stream_with_closure_t stream type.
The patch also moves all cairo_output_stream_t functions out of cairoint.h
and into new file cairo-output-stream-private.h, thus chipping away at the
monolithic cairoint.h.
When the glyph format does not match the font format, the glyph will
be rendered incorrectly. Setting the {x, y}_offset correctly when
converting glyph format fix that.
For doing so, I've changed document owner to be the paginated surface,
instead of the svg surface like previously. That's because fallback
resolution is stored in paginated surface.
With previous commit, freetype font backend is able to transform
both bitmap and outline glyphs, so ignores FC_MATRIX from now,
cairo doesn't need this for artificial oblique. And cairo doesn't
use FC_MATRIX direct anyway, it has its own font matrix that may be not
equal to FC_MATRIX in the font pattern! You should pass the matrix
(usually the matrix is multiplied by font's pixel size) to cairo when
creating scaled font.
This function is used to shape bitmap glyphs(outline glyphs are
transformed by freetype). That means freetype backend is able to
tranform both bitmap & outline glyphs now. This is needed for glyph
rotating, artificial oblique etc.
The old behavior of returning "infinite" extents is inconsistent with
the current usage of meta-surface where it is always created for
replay against a particular (sized) target surface and that size is
passed to _cairo_meta_surface_create.
Also clarify documentation of _cairo_surface_get_extents to eliminate
the possibility of inifinite extents.
