This variable was expanding to an empty string, so the next -I flag
was getting completely swallowed. Let's avoid being clever and just
use . which is what we want in the expansion anyway.
Use a utility function to wrap an incoming error status into a new
error stream. As a side-effect, all error streams must be destroyed as
in the general case the caller can not distinguish between a static
error object and one allocated to hold an unusual error status.
Previously the CGFontRef was recreated each time in show_glyphs; this
caused the font to get re-embedded in any PDF files that were being
generated through Quartz.
In ecb895803b Carl made fallback show_glyphs
always use a A8 mask in case of mixed-format glyphs. That's suboptimal if
there are ARGB32 glyphs. Using masks smartly we can implement the desired
behavior. Done now.
Ensure that the ctm remains invertible after multiplying the user
supplied matrices. Although the arguments are checked so that they are
valid per se, we double check that the result after multiplication is
still a valid invertible matrix. This should catch pathological cases
where the user concatenates a long series of matrix operations, which
either exceed our numerical limits or become degenerate through rounding
errors.
Ensure that the error is propagated to the target surface if we fail
whilst performing an operation on its behalf, for example set the size
of the paginated surface.
On the default case for an unknown pattern type, add an assert that the
code is never reached, and just in case upgrade the error to a fatal
PATTERN_TYPE_MISMATCH.
The current NaN check is insufficient as it classifies inf as a valid
determinant. We can improve the test by using isfinite() - but only
when it is available. We use the feature test macros as being the
simplest way of determining the presence of isfinite() as it may be
implemented as a macro, making checking for its usability troublesome
during configure.
Behdad, once again the arbiter of good taste, objected to the use of
the dotfile within the Makefile, and suggested that one calls $MAKE to
pre-process the source file from within the check scripts.
Doing so removes the ugly wart added to Makefile.am...
This fixes the remaining image-backend problems with bug 13479:
Ugly Courier New font with cairo 1.4.12
https://bugs.freedesktop.org/show_bug.cgi?id=13479
although the xlib-backend had been fixed previously.
Specifically, if an A1 glyph is first encountered, then subsequent
glyphs will still be rendered with antialiasing, (previously they
would be rendered very poorly without antialiasing).
Similarly, if the first glyph encountered has component-alpha
sub-pixel antialiasing and then an A1 or A8 glyph is encountered
then all glyphs will rendered in A8 (grayscale antialiasing).
Previously, the non-subpixel-antialiased glyphs would not appear
at all.
Behdad Esfahbod objected to the execution of a compiled program to check
symbol visibility as it makes cross-compilation more difficult.
Instead of executing the program, this method conditionally exports
a variable if cairo uses symbol hiding and scans the executable for
that symbol in a similar manner to check-def.sh. This has the slight
advantage of using the Makefile for performing the compilation, rather
than attempting to invoke $(CPP) from a shell script within the test
environment.
Add a paranoid check that at least one font backend is available - this
should have been already caught by configure, but it should help if a new
font backend is ever added.
Compile a trivial program such that it reports whether cairo is hiding
its internal symbols and skip the tests that depend upon it.
This prevents false errors, such as bug 12726, where the user is
presented with a scary make check failure.
Bug 13342 corresponds with a rebuild of cairo after removing
--enable-glitz from the configure line. Under these circumstances,
the remaining installable headers are not modified and therefore
cairo.def is not rebuilt and still expects to find a reference to
cairo_glitz_surface_create. The solution is to rebuild cairo.def after
any modification to the 'public' headers (installable or otherwise).
For non solid patterns _fill and _show_glyphs sets a clip
path then paints the pattern. Previously if the path is empty
SelectClipPath did not set clip. This was probably the cause
of bug 13657 where the entire page was black.
Fix this by not painting anything if the path is empty.
Non Windows fonts are drawn by getting the outline path, setting
this is the clip path, and painting the source pattern. For
solid colors this can avoid the clip and just do a fill.
==3429== Conditional jump or move depends on uninitialised value(s)
==3429== at 0x4E3FB0F: _cairo_box_round_to_rectangle (cairo-fixed-private.h:196)
==3429== by 0x4E34B29: _cairo_clip_intersect_to_rectangle (cairo-clip.c:162)
==3429== by 0x4E31943: cairo_push_group_with_content (cairo.c:495)
==3429== by 0x403044: draw (clip-zero.c:48)
==3429== by 0x404221: cairo_test_expecting (cairo-test.c:377)
==3429== by 0x64701C3: (below main) (libc-start.c:222)
Caused by setting extents->p2.y to zero twice.
test/pattern-get-type exposes a bug whereby we try to acquire the
_cairo_pattern_solid_pattern_cache_lock before initializing the
mutexes. To fix this move the CAIRO_MUTEX_INITIALIZE() from the
depths of _cairo_pattern_init() and perform it at the public entry
points.
Use the generic surface layer cairo_surface_show_page() instead of
directly calling cairo_paginated_surface_show_page(), as the higher
level performs more error checking.
More the majority of the typedefs from cairoint.h to
cairo-types-private.h and fixup cairo-pdf-operators-private.h to
avoid including cairoint.h.
A better approach would seem to be to rationalise cairoint.h so that it
only provides the symbol aliasing, moving the types and functions to
more appropriate private headers. However, this fixes the immediate
problem of running make check!
A problem with the previous commit for checking the PS level is that
with the default PS level of 3 it prevents PS files from printing on
Level 2 printers even if no Level 3 operators are used.
As the PS header is created after the page content has been generated,
it is easy to check the PS Level actually required and set this in the
header and PS level check code.
http://bugzilla.mozilla.org/show_bug.cgi?id=406376
reported problems with cairo PostScipt output printing black boxes
instead of images. This was found to caused by printing Level 3
PostScript to a Level 2 printer.
Add some PostScript code to to the cairo PS prolog to check the
language level of the printer. If the printer can not print the job, a
message stating the required language level is printed and the job is
aborted.
This should fix the problems reported in
http://lists.cairographics.org/archives/cairo/2007-November/012172.html
The problem is that GetCharacterPlacement() used in
_win32_scaled_font_text_to_glyphs returns utf16 instead of glyph
indices when Type 1 fonts are used.
This has been fixed by using GetGlyphIndices instead of
GetCharacterPlacement if the font is a Type 1.
_win32_scaled_font_map_glyphs_to_unicode has been fixed work with Type 1
glyph indices. It now uses GetFontUnicodeRanges and GetGlyphIndices
to do the reverse lookup.
