mirror of
https://gitlab.freedesktop.org/cairo/cairo.git
synced 2025-12-20 18:40:08 +01:00
352 lines
8.7 KiB
C
352 lines
8.7 KiB
C
/*
|
|
* 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 <cworth@cworth.org>
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#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_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 (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\n",
|
|
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,
|
|
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)
|