static gboolean fish_applet_draw (GtkWidget *widget, cairo_t *cr, FishApplet *fish) { int width, height; int src_x, src_y; g_return_val_if_fail (fish->surface != NULL, FALSE); g_assert (fish->n_frames > 0); width = cairo_xlib_surface_get_width (fish->surface); height = cairo_xlib_surface_get_height (fish->surface); src_x = 0; src_y = 0; if (fish->rotate) { if (fish->orientation == PANEL_APPLET_ORIENT_RIGHT) src_y = ((height * (fish->n_frames - 1 - fish->current_frame)) / fish->n_frames); else if (fish->orientation == PANEL_APPLET_ORIENT_LEFT) src_y = ((height * fish->current_frame) / fish->n_frames); else src_x = ((width * fish->current_frame) / fish->n_frames); } else src_x = ((width * fish->current_frame) / fish->n_frames); cairo_save (cr); cairo_set_source_surface (cr, fish->surface, -src_x, -src_y); cairo_paint (cr); cairo_restore (cr); return FALSE; }
/* deal with the mask surface and make sure it is the correct size */ static void mask_surface_check(cairo_surface_t *cs, unsigned width, unsigned height) { /* deal with the mask surface */ if(!mask_surface) { mask_surface=make_mask_surface(cs, width, height); } else { /* detect if mask should be resized and recreate it */ if((int)height!=cairo_xlib_surface_get_height(mask_surface) || (int)width!=cairo_xlib_surface_get_width(mask_surface)) { destroy_mask_surface(mask_surface); mask_surface=make_mask_surface(cs, width, height); } } }
gfxXlibSurface::gfxXlibSurface(cairo_surface_t *csurf) : mPixmapTaken(PR_FALSE), mSize(cairo_xlib_surface_get_width(csurf), cairo_xlib_surface_get_height(csurf)) { NS_PRECONDITION(cairo_surface_status(csurf) == 0, "Not expecting an error surface"); mDrawable = cairo_xlib_surface_get_drawable(csurf); mDisplay = cairo_xlib_surface_get_display(csurf); Init(csurf, PR_TRUE); }
cairo_surface_t * gitg_platform_support_create_cursor_surface (GdkDisplay *display, GdkCursorType cursor_type, gdouble *hot_x, gdouble *hot_y, gdouble *width, gdouble *height) { GdkCursor *cursor; cairo_surface_t *surface; gdouble w = 0, h = 0; cursor = gdk_cursor_new_for_display (display, cursor_type); surface = gdk_cursor_get_surface (cursor, hot_x, hot_y); if (surface == NULL) { return NULL; } switch (cairo_surface_get_type (surface)) { case CAIRO_SURFACE_TYPE_XLIB: w = cairo_xlib_surface_get_width (surface); h = cairo_xlib_surface_get_height (surface); break; case CAIRO_SURFACE_TYPE_IMAGE: w = cairo_image_surface_get_width (surface); h = cairo_image_surface_get_height (surface); break; } if (width) { *width = w; } if (height) { *height = h; } return surface; }
/** * Try the direct path. * @return True if we took the direct path */ bool gfxXlibNativeRenderer::DrawDirect(gfxContext *ctx, nsIntSize size, PRUint32 flags, Screen *screen, Visual *visual) { cairo_t *cr = ctx->GetCairo(); /* Check that the target surface is an xlib surface. */ cairo_surface_t *target = cairo_get_group_target (cr); if (cairo_surface_get_type (target) != CAIRO_SURFACE_TYPE_XLIB) { NATIVE_DRAWING_NOTE("FALLBACK: non-X surface"); return false; } cairo_matrix_t matrix; cairo_get_matrix (cr, &matrix); double device_offset_x, device_offset_y; cairo_surface_get_device_offset (target, &device_offset_x, &device_offset_y); /* Draw() checked that the matrix contained only a very-close-to-integer translation. Here (and in several other places and thebes) device offsets are assumed to be integer. */ NS_ASSERTION(PRInt32(device_offset_x) == device_offset_x && PRInt32(device_offset_y) == device_offset_y, "Expected integer device offsets"); nsIntPoint offset(NS_lroundf(matrix.x0 + device_offset_x), NS_lroundf(matrix.y0 + device_offset_y)); int max_rectangles = 0; if (flags & DRAW_SUPPORTS_CLIP_RECT) { max_rectangles = 1; } if (flags & DRAW_SUPPORTS_CLIP_LIST) { max_rectangles = MAX_STATIC_CLIP_RECTANGLES; } /* The client won't draw outside the surface so consider this when analysing clip rectangles. */ nsIntRect bounds(offset, size); bounds.IntersectRect(bounds, nsIntRect(0, 0, cairo_xlib_surface_get_width(target), cairo_xlib_surface_get_height(target))); bool needs_clip = true; nsIntRect rectangles[MAX_STATIC_CLIP_RECTANGLES]; int rect_count = 0; /* Check that the clip is rectangular and aligned on unit boundaries. */ /* Temporarily set the matrix for _get_rectangular_clip. It's basically the identity matrix, but we must adjust for the fact that our offset-rect is in device coordinates. */ cairo_identity_matrix (cr); cairo_translate (cr, -device_offset_x, -device_offset_y); bool have_rectangular_clip = _get_rectangular_clip (cr, bounds, &needs_clip, rectangles, max_rectangles, &rect_count); cairo_set_matrix (cr, &matrix); if (!have_rectangular_clip) return false; /* Stop now if everything is clipped out */ if (needs_clip && rect_count == 0) return true; /* Check that the screen is supported. Visuals belong to screens, so, if alternate visuals are not supported, then alternate screens cannot be supported. */ bool supports_alternate_visual = (flags & DRAW_SUPPORTS_ALTERNATE_VISUAL) != 0; bool supports_alternate_screen = supports_alternate_visual && (flags & DRAW_SUPPORTS_ALTERNATE_SCREEN); if (!supports_alternate_screen && cairo_xlib_surface_get_screen (target) != screen) { NATIVE_DRAWING_NOTE("FALLBACK: non-default screen"); return false; } /* Check that there is a visual */ Visual *target_visual = cairo_xlib_surface_get_visual (target); if (!target_visual) { NATIVE_DRAWING_NOTE("FALLBACK: no Visual for surface"); return false; } /* Check that the visual is supported */ if (!supports_alternate_visual && target_visual != visual) { // Only the format of the visual is important (not the GLX properties) // for Xlib or XRender drawing. XRenderPictFormat *target_format = cairo_xlib_surface_get_xrender_format (target); if (!target_format || (target_format != XRenderFindVisualFormat (DisplayOfScreen(screen), visual))) { NATIVE_DRAWING_NOTE("FALLBACK: unsupported Visual"); return false; } } /* we're good to go! */ NATIVE_DRAWING_NOTE("TAKING FAST PATH\n"); cairo_surface_flush (target); nsRefPtr<gfxASurface> surface = gfxASurface::Wrap(target); nsresult rv = DrawWithXlib(static_cast<gfxXlibSurface*>(surface.get()), offset, rectangles, needs_clip ? rect_count : 0); if (NS_SUCCEEDED(rv)) { cairo_surface_mark_dirty (target); return true; } return false; }
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_test_status_t test_cairo_xlib_surface_get_height (cairo_surface_t *surface) { int height = cairo_xlib_surface_get_height (surface); return height == 0 || surface_has_type (surface, CAIRO_SURFACE_TYPE_XLIB) ? CAIRO_TEST_SUCCESS : CAIRO_TEST_ERROR; }
static PyObject * xlib_surface_get_height (PycairoXlibSurface *o) { return PyInt_FromLong (cairo_xlib_surface_get_height (o->surface)); }
static void draw_shadow_background(decor_t * d, cairo_t * cr) { cairo_matrix_t matrix; double w, x2; gint width = 0, height = 0; gint left, right, top, bottom; window_settings *ws = d->fs->ws; if (!ws->large_shadow_surface) { cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0); cairo_paint(cr); return; } if (cairo_surface_get_type(ws->large_shadow_surface) == CAIRO_SURFACE_TYPE_IMAGE) { width = cairo_image_surface_get_width(ws->large_shadow_surface); height = cairo_image_surface_get_height(ws->large_shadow_surface); } else if (cairo_surface_get_type(ws->large_shadow_surface) == CAIRO_SURFACE_TYPE_XLIB) { width = cairo_xlib_surface_get_width(ws->large_shadow_surface); height = cairo_xlib_surface_get_height(ws->large_shadow_surface); } left = ws->left_space + ws->left_corner_space; right = ws->right_space + ws->right_corner_space; top = ws->top_space + ws->top_corner_space; bottom = ws->bottom_space + ws->bottom_corner_space; if (d->width - left - right < 0) { left = d->width / 2; right = d->width - left; } if (d->height - top - bottom < 0) { top = d->height / 2; bottom = d->height - top; } w = d->width - left - right; x2 = d->width - right; /* top left */ cairo_matrix_init_identity(&matrix); cairo_pattern_set_matrix(ws->shadow_pattern, &matrix); cairo_set_source(cr, ws->shadow_pattern); cairo_rectangle(cr, 0.0, 0.0, left, top); cairo_fill(cr); /* top */ if (w > 0) { cairo_matrix_init_translate(&matrix, left, 0.0); cairo_matrix_scale(&matrix, 1.0 / w, 1.0); cairo_matrix_translate(&matrix, -left, 0.0); cairo_pattern_set_matrix(ws->shadow_pattern, &matrix); cairo_set_source(cr, ws->shadow_pattern); cairo_rectangle(cr, left, 0.0, w, top); cairo_fill(cr); } /* top right */ cairo_matrix_init_translate(&matrix, width - right - x2, 0.0); cairo_pattern_set_matrix(ws->shadow_pattern, &matrix); cairo_set_source(cr, ws->shadow_pattern); cairo_rectangle(cr, x2, 0.0, right, top); cairo_clip_preserve(cr); cairo_fill(cr); }