/* * Copyright © 2005 Red Hat, Inc. * * Permission to use, copy, modify, distribute, and sell this software * and its documentation for any purpose is hereby granted without * fee, provided that the above copyright notice appear in all copies * and that both that copyright notice and this permission notice * appear in supporting documentation, and that the name of * Red Hat, Inc. not be used in advertising or publicity pertaining to * distribution of the software without specific, written prior * permission. Red Hat, Inc. makes no representations about the * suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * RED HAT, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS, IN NO EVENT SHALL RED HAT, INC. BE LIABLE FOR ANY SPECIAL, * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Carl D. Worth */ #include #include #include "cairo.h" #include "cairo-xlib.h" #include "cairo-test.h" #include "cairo-boilerplate-xlib.h" #include "buffer-diff.h" #define SIZE 100 #define OFFSCREEN_OFFSET 50 cairo_bool_t result = 0; #if CAIRO_HAS_XLIB_XRENDER_SURFACE #include "cairo-xlib-xrender.h" /* Vladimir Vukicevic reported that surfaces were being created with * mismatching Visuals and XRenderPictFormats. */ static cairo_bool_t surface_compare_visual_and_format (cairo_surface_t *surface) { Display *dpy; Visual *visual; XRenderPictFormat *format; dpy = cairo_xlib_surface_get_display (surface); visual = cairo_xlib_surface_get_visual (surface); if (visual == NULL) return TRUE; format = cairo_xlib_surface_get_xrender_format (surface); if (format == NULL) return TRUE; return format == XRenderFindVisualFormat (dpy, visual); } #else static cairo_bool_t surface_compare_visual_and_format (cairo_surface_t *surface) { return TRUE; } #endif static cairo_bool_t check_similar_visual_and_format (cairo_surface_t *surface) { cairo_surface_t *similar; cairo_bool_t ret; similar = cairo_surface_create_similar (surface, CAIRO_CONTENT_COLOR_ALPHA, 1, 1); if (cairo_surface_status (similar)) return FALSE; ret = surface_compare_visual_and_format (similar); cairo_surface_destroy (similar); return ret; } static void draw_pattern (cairo_surface_t *surface) { cairo_t *cr = cairo_create (surface); int i; cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */ cairo_paint (cr); cairo_set_source_rgba (cr, 0, 0.0, 0.0, 0.50); /* half-alpha-black */ for (i = 1; i <= 3; i++) { int inset = SIZE / 8 * i; cairo_rectangle (cr, inset, inset, SIZE - 2 * inset, SIZE - 2 * inset); cairo_fill (cr); } cairo_destroy (cr); } static void erase_pattern (cairo_surface_t *surface) { cairo_t *cr = cairo_create (surface); cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */ cairo_paint (cr); cairo_destroy (cr); } static cairo_test_status_t do_test (const cairo_test_context_t *ctx, Display *dpy, unsigned char *reference_data, unsigned char *test_data, unsigned char *diff_data, cairo_bool_t use_render, cairo_bool_t use_pixmap, cairo_bool_t set_size, cairo_bool_t offscreen) { cairo_surface_t *surface; cairo_surface_t *test_surface; cairo_t *test_cr; buffer_diff_result_t result; Drawable drawable; int screen = DefaultScreen (dpy); if (use_pixmap && offscreen) return CAIRO_TEST_SUCCESS; if (use_pixmap) { drawable = XCreatePixmap (dpy, DefaultRootWindow (dpy), SIZE, SIZE, DefaultDepth (dpy, screen)); } else { XSetWindowAttributes xwa; int x, y; xwa.override_redirect = True; if (offscreen) { x = - OFFSCREEN_OFFSET; y = - OFFSCREEN_OFFSET; } else { x = 0; y = 0; } drawable = XCreateWindow (dpy, DefaultRootWindow (dpy), x, y, SIZE, SIZE, 0, DefaultDepth (dpy, screen), InputOutput, DefaultVisual (dpy, screen), CWOverrideRedirect, &xwa); XMapWindow (dpy, drawable); } surface = cairo_xlib_surface_create (dpy, drawable, DefaultVisual (dpy, screen), SIZE, SIZE); if (! surface_compare_visual_and_format (surface)) return CAIRO_TEST_FAILURE; if (!use_render) cairo_boilerplate_xlib_surface_disable_render (surface); if (set_size) { cairo_xlib_surface_set_size (surface, SIZE, SIZE); if (cairo_xlib_surface_get_width (surface) != SIZE || cairo_xlib_surface_get_height (surface) != SIZE) return CAIRO_TEST_FAILURE; } if (! check_similar_visual_and_format (surface)) return CAIRO_TEST_FAILURE; draw_pattern (surface); test_surface = cairo_image_surface_create_for_data (test_data, CAIRO_FORMAT_RGB24, SIZE, SIZE, SIZE * 4); test_cr = cairo_create (test_surface); cairo_set_source_surface (test_cr, surface, 0, 0); cairo_paint (test_cr); cairo_destroy (test_cr); cairo_surface_destroy (test_surface); /* We erase the surface to black in case we get the same * memory back again for the pixmap case. */ erase_pattern (surface); cairo_surface_destroy (surface); if (use_pixmap) XFreePixmap (dpy, drawable); else XDestroyWindow (dpy, drawable); if (offscreen) { size_t offset = 4 * (SIZE * OFFSCREEN_OFFSET + OFFSCREEN_OFFSET); buffer_diff_noalpha (reference_data + offset, test_data + offset, diff_data + offset, SIZE - OFFSCREEN_OFFSET, SIZE - OFFSCREEN_OFFSET, 4 * SIZE, &result); } else { buffer_diff_noalpha (reference_data, test_data, diff_data, SIZE, SIZE, 4 * SIZE, &result); } cairo_test_log (ctx, "xlib-surface: %s, %s, %s%s: %s\n", use_render ? " render" : "no-render", set_size ? " size" : "no-size", use_pixmap ? "pixmap" : "window", use_pixmap ? " " : (offscreen ? ", offscreen" : ", onscreen"), image_diff_is_failure (&result, 0) ? "FAIL" : "PASS"); if (image_diff_is_failure (&result, 0)) return CAIRO_TEST_FAILURE; else return CAIRO_TEST_SUCCESS; } static cairo_bool_t check_visual (Display *dpy) { Visual *visual = DefaultVisual (dpy, DefaultScreen (dpy)); if ((visual->red_mask == 0xff0000 && visual->green_mask == 0x00ff00 && visual->blue_mask == 0x0000ff) || (visual->red_mask == 0x0000ff && visual->green_mask == 0x00ff00 && visual->blue_mask == 0xff0000)) return 1; else return 0; } #undef xcalloc static void * xcalloc (const cairo_test_context_t *ctx, size_t a, size_t b) { void *ptr = calloc (a, b); if (ptr == NULL) { cairo_test_log (ctx, "xlib-surface: unable to allocate memory, skipping\n"); abort (); } return ptr; } static cairo_test_status_t preamble (cairo_test_context_t *ctx) { Display *dpy; unsigned char *reference_data; unsigned char *test_data; unsigned char *diff_data; cairo_surface_t *reference_surface; cairo_bool_t use_pixmap; cairo_bool_t set_size; cairo_bool_t offscreen; cairo_test_status_t status, result = CAIRO_TEST_UNTESTED; int stride; if (! cairo_test_is_target_enabled (ctx, "xlib")) goto CLEANUP_TEST; dpy = XOpenDisplay (NULL); if (!dpy) { cairo_test_log (ctx, "xlib-surface: Cannot open display, skipping\n"); goto CLEANUP_TEST; } if (!check_visual (dpy)) { cairo_test_log (ctx, "xlib-surface: default visual is not RGB24 or BGR24, skipping\n"); goto CLEANUP_DISPLAY; } stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, SIZE); reference_data = xcalloc (ctx, SIZE, stride); test_data = xcalloc (ctx, SIZE, stride); diff_data = xcalloc (ctx, SIZE, stride); reference_surface = cairo_image_surface_create_for_data (reference_data, CAIRO_FORMAT_RGB24, SIZE, SIZE, stride); draw_pattern (reference_surface); cairo_surface_destroy (reference_surface); result = CAIRO_TEST_SUCCESS; for (set_size = 0; set_size <= 1; set_size++) for (use_pixmap = 0; use_pixmap <= 1; use_pixmap++) for (offscreen = 0; offscreen <= 1; offscreen++) { status = do_test (ctx, dpy, reference_data, test_data, diff_data, 1, use_pixmap, set_size, offscreen); if (status) result = status; } for (set_size = 0; set_size <= 1; set_size++) for (use_pixmap = 0; use_pixmap <= 1; use_pixmap++) for (offscreen = 0; offscreen <= 1; offscreen++) { status = do_test (ctx, dpy, reference_data, test_data, diff_data, 0, use_pixmap, set_size, offscreen); if (status) result = status; } free (reference_data); free (test_data); free (diff_data); CLEANUP_DISPLAY: XCloseDisplay (dpy); CLEANUP_TEST: return result; } CAIRO_TEST (xlib_surface, "Check creating surfaces for various XWindows", "xlib", /* keywords */ NULL, /* requirements */ 0, 0, preamble, NULL)