static cairo_test_status_t draw (cairo_t *cr, int width, int height) { size_t i = 0; cairo_operator_t op; cairo_t *bgcr, *fgcr; cairo_surface_t *bg, *fg; bg = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR_ALPHA, SIZE * STEPS, SIZE * STEPS); fg = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR_ALPHA, SIZE * STEPS, SIZE * STEPS); bgcr = cairo_create (bg); fgcr = cairo_create (fg); cairo_scale (bgcr, SIZE, SIZE); cairo_scale (fgcr, SIZE, SIZE); create_patterns (bgcr, fgcr); cairo_destroy (bgcr); cairo_destroy (fgcr); for (op = START_OPERATOR; op <= STOP_OPERATOR; op++, i++) { cairo_save (cr); cairo_translate (cr, SIZE * (STEPS + 1) * (i % COUNT), SIZE * (STEPS + 1) * (i / COUNT)); do_blend (cr, op, bg, fg); cairo_restore (cr); } cairo_surface_destroy (fg); cairo_surface_destroy (bg); return CAIRO_TEST_SUCCESS; }
static void subdraw (cairo_t *cr, int width, int height) { size_t i = 0; cairo_operator_t op; cairo_t *bgcr, *fgcr; cairo_surface_t *bg, *fg; bg = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR_ALPHA, SIZE * STEPS, SIZE * STEPS); fg = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR_ALPHA, SIZE * STEPS, SIZE * STEPS); bgcr = cairo_create (bg); fgcr = cairo_create (fg); cairo_scale (bgcr, SIZE, SIZE); cairo_scale (fgcr, SIZE, SIZE); create_patterns (bgcr, fgcr); cairo_destroy (bgcr); cairo_destroy (fgcr); for (op = START_OPERATOR; op <= STOP_OPERATOR; op++, i++) { cairo_save (cr); cairo_translate (cr, SIZE * (STEPS + 1) * (i % COUNT), SIZE * (STEPS + 1) * (i / COUNT)); cairo_rectangle (cr, 0, 0, SIZE * (STEPS + 1), SIZE * (STEPS+1)); cairo_clip (cr); do_composite (cr, op, bg, fg); cairo_restore (cr); } cairo_surface_destroy (fg); cairo_surface_destroy (bg); }
static void paint_window(GtkWidget* widget, WindowData* windata) { cairo_t* context; cairo_surface_t* surface; cairo_t* cr; if (windata->width == 0 || windata->height == 0) { #if GTK_CHECK_VERSION(3, 0, 0) GtkAllocation allocation; gtk_widget_get_allocation(windata->win, &allocation); windata->width = MAX(allocation.width, 1); windata->height = MAX(allocation.height, 1); #else windata->width = MAX(windata->win->allocation.width, 1); windata->height = MAX(windata->win->allocation.height, 1); #endif } context = gdk_cairo_create(widget->window); cairo_set_operator(context, CAIRO_OPERATOR_SOURCE); #if GTK_CHECK_VERSION(3, 0, 0) GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); surface = cairo_surface_create_similar(cairo_get_target(context), CAIRO_CONTENT_COLOR_ALPHA, allocation.width, allocation.height); #else surface = cairo_surface_create_similar(cairo_get_target(context), CAIRO_CONTENT_COLOR_ALPHA, widget->allocation.width, widget->allocation.height); #endif cr = cairo_create(surface); fill_background(widget, windata, cr); cairo_destroy(cr); cairo_set_source_surface(context, surface, 0, 0); cairo_paint(context); cairo_surface_destroy(surface); cairo_destroy(context); update_shape(windata); }
static cairo_surface_t * _similar_surface_create (void *closure, cairo_content_t content, double width, double height, long uid) { cairo_surface_t *surface; struct scache skey, *s; if (uid == 0 || surface_cache == NULL) return cairo_surface_create_similar (closure, content, width, height); skey.entry.hash = uid; s = _cairo_hash_table_lookup (surface_cache, &skey.entry); if (s != NULL) { if (s->content == content && s->width == width && s->height == height) { return cairo_surface_reference (s->surface); } /* The surface has been resized, allow the original entry to expire * as it becomes inactive. */ } surface = cairo_surface_create_similar (closure, content, width, height); s = malloc (sizeof (struct scache)); if (s == NULL) return surface; s->entry.hash = uid; s->content = content; s->width = width; s->height = height; s->surface = surface; if (_cairo_hash_table_insert (surface_cache, &s->entry)) { free (s); } else if (cairo_surface_set_user_data (surface, (const cairo_user_data_key_t *) &surface_cache, s, scache_remove)) { scache_remove (s); } return surface; }
/* cache buttons as small surfaces */ static cairo_surface_t *cache_button(Gameboard *g, void (*draw)(cairo_t *c, double x, double y), double pR,double pG,double pB,double pA, double fR,double fG,double fB,double fA){ cairo_t *wc = gdk_cairo_create(g->w.window); cairo_surface_t *ret = cairo_surface_create_similar (cairo_get_target (wc), CAIRO_CONTENT_COLOR_ALPHA, BUTTON_RADIUS*2+1, BUTTON_RADIUS*2+1); cairo_t *c = cairo_create(ret); cairo_destroy (wc); cairo_save(c); cairo_set_operator(c,CAIRO_OPERATOR_CLEAR); cairo_set_source_rgba (c, 1,1,1,1); cairo_paint(c); cairo_restore(c); cairo_set_source_rgba(c,fR,fG,fB,fA); cairo_set_line_width(c,BUTTON_LINE_WIDTH); draw(c,BUTTON_RADIUS+.5,BUTTON_RADIUS+.5); cairo_set_source_rgba(c,pR,pG,pB,pA); cairo_stroke(c); cairo_destroy(c); return ret; }
/* Scale the surface with the width and height requested */ cairo_surface_t * scale_surface (cairo_surface_t *surface, gdouble width, gdouble height) { gdouble old_width = cairo_image_surface_get_width (surface); gdouble old_height = cairo_image_surface_get_height (surface); cairo_surface_t *new_surface = cairo_surface_create_similar(surface, CAIRO_CONTENT_COLOR_ALPHA, width, height); cairo_t *cr = cairo_create (new_surface); /* Scale *before* setting the source surface (1) */ cairo_scale (cr, width / old_width, height / old_height); cairo_set_source_surface (cr, surface, 0, 0); /* To avoid getting the edge pixels blended with 0 alpha, which would * occur with the default EXTEND_NONE. Use EXTEND_PAD for 1.2 or newer (2) */ cairo_pattern_set_extend (cairo_get_source(cr), CAIRO_EXTEND_REFLECT); /* Replace the destination with the source instead of overlaying */ cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); /* Do the actual drawing */ cairo_paint (cr); cairo_destroy (cr); return new_surface; }
/** * windows resize funtion */ static gboolean resize_window (GtkWidget *widget, GdkEventMotion *mev) { int w,h; if(isFullSreen) gdk_window_get_size(widget->window,&w,&h); else { w = DEFAULT_WIDTH; h = DEFAULT_HEIGHT; } if(w!=window_w && h!=window_h){ window_w = w; window_h = h; surface = cairo_surface_create_similar ( surface, CAIRO_CONTENT_COLOR_ALPHA, w, h); gtk_widget_set_size_request(widget,w,h); CleanPaint(); } /* tell the canvas widget that it needs to redraw itself */ gtk_widget_queue_draw (widget); return FALSE; }
static gboolean configure_cb (GtkWidget *widget, GdkEventConfigure *evt, gpointer user_data) { canvasbacken_data_t *data = user_data; assert (data); int w = gtk_widget_get_allocated_width (widget); int h = gtk_widget_get_allocated_height (widget); if (data->track) cairo_surface_destroy (data->track); data->track = gdk_window_create_similar_surface ( gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR_ALPHA, w, h); clear_surface (data->track); if (data->surf) cairo_surface_destroy (data->surf); data->surf = cairo_surface_create_similar ( data->track, CAIRO_CONTENT_COLOR_ALPHA, w, h); clear_surface (data->surf); canvas_draw (data); gtk_widget_queue_draw (widget); return TRUE; }
static void draw_mask (cairo_t *cr, int x, int y) { cairo_surface_t *mask_surface; cairo_t *cr2; double width = (int)(0.9 * WIDTH); double height = (int)(0.9 * HEIGHT); x += 0.05 * WIDTH; y += 0.05 * HEIGHT; mask_surface = cairo_surface_create_similar (cairo_get_group_target (cr), CAIRO_CONTENT_ALPHA, width, height); cr2 = cairo_create (mask_surface); cairo_surface_destroy (mask_surface); cairo_save (cr2); cairo_set_source_rgba (cr2, 0, 0, 0, 0); /* transparent */ cairo_set_operator (cr2, CAIRO_OPERATOR_SOURCE); cairo_paint (cr2); cairo_restore (cr2); cairo_set_source_rgb (cr2, 1, 1, 1); /* white */ cairo_arc (cr2, 0.5 * width, 0.5 * height, 0.45 * height, 0, 2 * M_PI); cairo_fill (cr2); cairo_mask_surface (cr, cairo_get_target (cr2), x, y); cairo_destroy (cr2); }
cairo_surface_t * ink_cairo_surface_create_same_size(cairo_surface_t *s, cairo_content_t c) { cairo_surface_t *ns = cairo_surface_create_similar(s, c, ink_cairo_surface_get_width(s), ink_cairo_surface_get_height(s)); return ns; }
static SeedValue seed_cairo_surface_create_similar (SeedContext ctx, SeedObject function, SeedObject this_object, gsize argument_count, const SeedValue arguments[], SeedException *exception) { gint width, height; cairo_surface_t *surface, *ret; cairo_content_t content; CHECK_THIS(); if (argument_count != 3) { EXPECTED_EXCEPTION("create_similar", "3 arguments"); } surface = seed_object_to_cairo_surface (ctx, this_object, exception); if (!surface) return seed_make_undefined (ctx); content = seed_value_to_long (ctx, arguments[0], exception); width = seed_value_to_int (ctx, arguments[1], exception); height = seed_value_to_int (ctx, arguments[2], exception); ret = cairo_surface_create_similar (surface, content, width, height); return seed_object_from_cairo_surface (ctx, ret); }
cairo_surface_t * BitmapSource::GetSurface (cairo_t *cr) { if (image_surface == NULL) return NULL; if (native_surface) return native_surface; if (cr == NULL) return image_surface; native_surface = cairo_surface_create_similar (cairo_get_group_target (cr), cairo_surface_get_content (image_surface), GetPixelWidth (), GetPixelHeight ()); cairo_t *context = cairo_create (native_surface); cairo_set_source_surface (context, image_surface, 0, 0); cairo_pattern_set_filter (cairo_get_source (context), CAIRO_FILTER_FAST); cairo_paint (context); cairo_destroy (context); return native_surface; }
static inline cairo_surface_t * scale_icon (cairo_surface_t *icon, double width, double height) { cairo_surface_t *scaled_icon; cairo_t *cr; scaled_icon = cairo_surface_create_similar (icon, cairo_surface_get_content (icon), THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT); cr = cairo_create (scaled_icon); cairo_scale (cr, THUMBNAIL_WIDTH / width, THUMBNAIL_HEIGHT / height); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_surface (cr, icon, 0.0, 0.0); cairo_paint (cr); cairo_destroy (cr); return scaled_icon; }
mWindow::mWindow() { looping = false; if (!(display = XOpenDisplay(NULL))) exit(1); screenID = DefaultScreen(display); topWin = XCreateSimpleWindow(display, DefaultRootWindow(display), 0, 0, winWidth, winHeight, 0, 100, 0xfffacd); XSelectInput(display, topWin, ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | StructureNotifyMask | ExposureMask); frontSurface = cairo_xlib_surface_create(display, topWin, DefaultVisual(display, screenID), winWidth, winHeight); frontContext = cairo_create(frontSurface); GUI_surface = cairo_surface_create_similar(cairo_get_target(frontContext), CAIRO_CONTENT_COLOR_ALPHA, winWidth, winHeight); // MAP_surface = cairo_surface_create_similar(cairo_get_target(frontContext), // CAIRO_CONTENT_COLOR_ALPHA, winWidth, winHeight); GUI_context = cairo_create(GUI_surface); //MAP_context = cairo_create(MAP_surface); Gmanager = new GUIManager(GUI_context); eventDispatcher = new EventDispatcher(winWidth, winHeight); Gmanager->registerEventDispatcher(eventDispatcher, eventDispatcher->getGUImap()); eventDispatcher->registerGUImanager(Gmanager); animator = new Animator(); Animatable::animator = animator; }
static void set_surface_pattern (cairo_t *cr, int x, int y) { cairo_surface_t *source_surface; cairo_t *cr2; double width = (int)(0.6 * WIDTH); double height = (int)(0.6 * HEIGHT); x += 0.2 * WIDTH; y += 0.2 * HEIGHT; source_surface = cairo_surface_create_similar (cairo_get_group_target (cr), CAIRO_CONTENT_COLOR_ALPHA, width, height); cr2 = cairo_create (source_surface); cairo_surface_destroy (source_surface); cairo_set_source_rgb (cr2, 1, 0, 0); /* red */ cairo_paint (cr2); cairo_set_source_rgb (cr2, 1, 1, 1); /* white */ cairo_arc (cr2, 0.5 * width, 0.5 * height, 0.5 * height, 0, 2 * M_PI); cairo_fill (cr2); cairo_set_source_surface (cr, cairo_get_target (cr2), x, y); cairo_destroy (cr2); }
cairo_surface_t * _gtk_css_image_get_surface (GtkCssImage *image, cairo_surface_t *target, int surface_width, int surface_height) { cairo_surface_t *result; cairo_t *cr; g_return_val_if_fail (GTK_IS_CSS_IMAGE (image), NULL); g_return_val_if_fail (surface_width > 0, NULL); g_return_val_if_fail (surface_height > 0, NULL); if (target) result = cairo_surface_create_similar (target, CAIRO_CONTENT_COLOR_ALPHA, surface_width, surface_height); else result = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, surface_width, surface_height); cr = cairo_create (result); _gtk_css_image_draw (image, cr, surface_width, surface_height); cairo_destroy (cr); return result; }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_surface_t *surface, *target; cairo_t *cr2; /* First draw a shape in blue on the original destination. */ cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ draw_square (cr); /* Then, create an offset surface and repeat the drawing in red. */ target = cairo_get_group_target (cr); surface = cairo_surface_create_similar (target, cairo_surface_get_content (target), SIZE / 2, SIZE / 2); cr2 = cairo_create (surface); cairo_set_source_rgb (cr2, 1, 0, 0); /* red */ draw_square (cr2); cairo_destroy (cr2); cairo_surface_set_device_offset (surface, + SIZE / 2, + SIZE / 2); /* Finally, copy the offset surface to the original destination. * The final result should be a blue square with the upper-left * quarter red. */ cairo_set_source_surface (cr, surface, SIZE / 2, SIZE / 2); cairo_paint (cr); cairo_surface_destroy (surface); return CAIRO_TEST_SUCCESS; }
cairo_surface_t* Win32UIBinding::ScaleCairoSurface( cairo_surface_t* oldSurface, int newWidth, int newHeight) { cairo_matrix_t scaleMatrix; cairo_matrix_init_scale(&scaleMatrix, (double) cairo_image_surface_get_width(oldSurface) / (double) newWidth, (double) cairo_image_surface_get_height(oldSurface) / (double) newHeight); cairo_pattern_t* surfacePattern = cairo_pattern_create_for_surface(oldSurface); cairo_pattern_set_matrix(surfacePattern, &scaleMatrix); cairo_pattern_set_filter(surfacePattern, CAIRO_FILTER_BEST); cairo_surface_t* newSurface = cairo_surface_create_similar( oldSurface, CAIRO_CONTENT_COLOR_ALPHA, newWidth, newHeight); cairo_t* cr = cairo_create(newSurface); cairo_set_source(cr, surfacePattern); /* To avoid getting the edge pixels blended with 0 alpha, which would * occur with the default EXTEND_NONE. Use EXTEND_PAD for 1.2 or newer (2) */ cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REFLECT); /* Replace the destination with the source instead of overlaying */ cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); /* Do the actual drawing */ cairo_paint(cr); cairo_destroy(cr); return newSurface; }
void iupDrawUpdateSize(IdrawCanvas* dc) { int w, h; #if GTK_CHECK_VERSION(2, 24, 0) w = gdk_window_get_width(dc->window); h = gdk_window_get_height(dc->window); #else gdk_drawable_get_size(dc->window, &w, &h); #endif if (w != dc->w || h != dc->h) { cairo_surface_t* surface; dc->w = w; dc->h = h; cairo_destroy(dc->image_cr); surface = cairo_surface_create_similar(cairo_get_target(dc->cr), CAIRO_CONTENT_COLOR_ALPHA, dc->w, dc->h); dc->image_cr = cairo_create(surface); cairo_surface_destroy(surface); } }
static void draw_mask (cairo_t *cr) { cairo_surface_t *surface; cairo_t *cr2; surface = cairo_surface_create_similar (cairo_get_group_target (cr), CAIRO_CONTENT_ALPHA, 50, 50); cr2 = cairo_create (surface); cairo_surface_destroy (surface); cairo_rectangle (cr2, 0, 0, 40, 40); cairo_rectangle (cr2, 10, 10, 40, 40); cairo_clip (cr2); cairo_move_to (cr2, 0, 25); cairo_line_to (cr2, 50, 25); cairo_move_to (cr2, 25, 0); cairo_line_to (cr2, 25, 50); cairo_set_source_rgb (cr2, 1, 1, 1); cairo_stroke (cr2); cairo_set_source_rgb (cr, 1, 0, 0); cairo_mask_surface (cr, cairo_get_target (cr2), 50, 50); cairo_destroy (cr2); }
static void zoom_rect(int x1, int y1, int x2, int y2) { cairo_t *ctx; cairo_surface_t *buf, *t; t = cairo_xlib_surface_create(dpy, wshow, vis, sw, sh); buf = cairo_surface_create_similar(t, CAIRO_CONTENT_COLOR, sw, sh); ctx = cairo_create(buf); cairo_surface_destroy(t); PopplerDocument *pdf; pdf = poppler_document_new_from_file(show->uri, NULL, NULL); PopplerPage *page = poppler_document_get_page(pdf, show->cur); double pdfw, pdfh; poppler_page_get_size(page, &pdfw, &pdfh); cairo_set_source_rgba(ctx, 1, 1, 1, 1); cairo_paint(ctx); double scx = show->w / pdfw, scy = show->h / pdfh; double dx = 0.0, dy = 0.0; if (conf.lock_aspect) { if (scx > scy) dx = (show->w - pdfw * (scx=scy)) / 2.0; else dy = (show->h - pdfh * (scy=scx)) / 2.0; } cairo_scale(ctx, scx * show->w /(double) (x2-x1), scy * show->h /(double) (y2-y1)); cairo_translate(ctx, (dx - x1)/scx, (dy - y1)/scy); poppler_page_render(page, ctx); cairo_set_source_surface(show->target[0].ctx, buf, 0, 0); int i; for (i = conf.fade; i; i--) { cairo_paint_with_alpha(show->target[0].ctx, 1/(float)i); XFlush(dpy); usleep(5000); } cairo_destroy(ctx); cairo_surface_destroy(buf); }
static void draw_mask (cairo_t *cr, int x, int y) { cairo_surface_t *mask_surface; cairo_t *cr2; double width = (int)(0.9 * WIDTH); double height = (int)(0.9 * HEIGHT); x += 0.05 * WIDTH; y += 0.05 * HEIGHT; mask_surface = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_ALPHA, width, height); cr2 = cairo_create (mask_surface); cairo_set_source_rgb (cr2, 1, 1, 1); /* white */ cairo_arc (cr2, 0.5 * width, 0.5 * height, 0.45 * height, 0, 2 * M_PI); cairo_fill (cr2); cairo_destroy (cr2); cairo_mask_surface (cr, mask_surface, x, y); cairo_surface_destroy (mask_surface); }
static gboolean countdown_expose_cb(GtkWidget *pie, GdkEventExpose *event, WindowData *windata) { cairo_t *context; cairo_surface_t *surface; cairo_t *cr; context = gdk_cairo_create(pie->window); cairo_set_operator(context, CAIRO_OPERATOR_SOURCE); surface = cairo_surface_create_similar(cairo_get_target(context), CAIRO_CONTENT_COLOR_ALPHA, pie->allocation.width, pie->allocation.height); cr = cairo_create(surface); cairo_translate (cr, -pie->allocation.x, -pie->allocation.y); fill_background (pie, windata, cr); cairo_translate (cr, pie->allocation.x, pie->allocation.y); draw_pie (pie, windata, cr); cairo_destroy(cr); cairo_set_source_surface(context, surface, 0, 0); cairo_paint(context); cairo_surface_destroy(surface); cairo_destroy(context); return TRUE; }
static cairo_surface_t * fill_image_buffer_from_file (cairo_t *cr, const char *filePath) { GError *error = NULL; RsvgHandle *handle; cairo_surface_t *tmp_surface; cairo_t *tmp_cr; handle = rsvg_handle_new_from_file (filePath, &error); if (handle == NULL) { g_warning("rsvg_handle_new_from_file(\"%s\") failed: %s", filePath, (error ? error->message : "unknown error")); if (error) g_error_free(error); return NULL; } tmp_surface = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR_ALPHA, 32, 32); tmp_cr = cairo_create (tmp_surface); rsvg_handle_render_cairo (handle, tmp_cr); cairo_destroy (tmp_cr); rsvg_handle_free (handle); return tmp_surface; }
static cairo_surface_t * create_surface (cairo_t *target, cairo_content_t content, surface_type_t type) { cairo_surface_t *surface; cairo_t *cr; surface = cairo_surface_create_similar (cairo_get_target (target), content, SIZE, SIZE); if (type == CLEAR) return surface; cr = cairo_create (surface); cairo_surface_destroy (surface); cairo_set_source_rgb (cr, 0.75, 0, 0); cairo_paint (cr); if (type == PAINTED) goto DONE; cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); DONE: surface = cairo_surface_reference (cairo_get_target (cr)); cairo_destroy (cr); return surface; }
cairo_surface_t * ev_document_misc_surface_rotate_and_scale (cairo_surface_t *surface, gint dest_width, gint dest_height, gint dest_rotation) { cairo_surface_t *new_surface; cairo_t *cr; gint width, height; gint new_width = dest_width; gint new_height = dest_height; width = cairo_image_surface_get_width (surface); height = cairo_image_surface_get_height (surface); if (dest_width == width && dest_height == height && dest_rotation == 0) { return cairo_surface_reference (surface); } if (dest_rotation == 90 || dest_rotation == 270) { new_width = dest_height; new_height = dest_width; } new_surface = cairo_surface_create_similar (surface, cairo_surface_get_content (surface), new_width, new_height); cr = cairo_create (new_surface); switch (dest_rotation) { case 90: cairo_translate (cr, new_width, 0); break; case 180: cairo_translate (cr, new_width, new_height); break; case 270: cairo_translate (cr, 0, new_height); break; default: cairo_translate (cr, 0, 0); } cairo_rotate (cr, dest_rotation * G_PI / 180.0); if (dest_width != width || dest_height != height) { cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR); cairo_scale (cr, (gdouble)dest_width / width, (gdouble)dest_height / height); } cairo_set_source_surface (cr, surface, 0, 0); cairo_paint (cr); cairo_destroy (cr); return new_surface; }
cairo_surface_t *compat_gdk_window_create_similar_surface (GdkWindow *window, cairo_content_t content, gint width, gint height) { cairo_t *cr = gdk_cairo_create(window); cairo_surface_t *ws = cairo_get_target(cr); cairo_surface_t *ret = cairo_surface_create_similar(ws, content, width, height); cairo_destroy(cr); return ret; }
static cairo_surface_t * _similar_surface_create (void *closure, cairo_content_t content, double width, double height, long uid) { return cairo_surface_create_similar (closure, content, width, height); }
static cairo_surface_t * get_surface_from_pixbuf (GdkPixbuf *pixbuf, MetaImageFillType fill_type, gdouble width, gdouble height, gboolean vertical_stripes, gboolean horizontal_stripes) { gdouble pixbuf_width; gdouble pixbuf_height; cairo_surface_t *surface; cairo_content_t content; cairo_surface_t *copy; cairo_t *cr; pixbuf_width = gdk_pixbuf_get_width (pixbuf); pixbuf_height = gdk_pixbuf_get_height (pixbuf); surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, 1, NULL); if (pixbuf_width == width && pixbuf_height == height) { return surface; } if (fill_type != META_IMAGE_FILL_TILE) { cairo_surface_t *scaled; scaled = scale_surface (surface, pixbuf_width, pixbuf_height, width, height, vertical_stripes, horizontal_stripes); cairo_surface_destroy (surface); surface = scaled; } content = CAIRO_CONTENT_COLOR_ALPHA; width = ceil (width); height = ceil (height); copy = cairo_surface_create_similar (surface, content, width, height); cr = cairo_create (copy); cairo_set_source_surface (cr, surface, 0, 0); if (fill_type == META_IMAGE_FILL_TILE || vertical_stripes || horizontal_stripes) { cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT); } cairo_paint (cr); cairo_destroy (cr); cairo_surface_destroy (surface); return copy; }
/* This test is designed to test painting a recording surface pattern with * CAIRO_EXTEND_NONE and a non identity pattern matrix. */ static cairo_pattern_t *create_pattern (cairo_t *target) { cairo_surface_t *surface; cairo_pattern_t *pattern; cairo_t *cr; surface = cairo_surface_create_similar (cairo_get_group_target (target), CAIRO_CONTENT_COLOR_ALPHA, PAT_WIDTH, PAT_HEIGHT); cr = cairo_create (surface); cairo_surface_destroy (surface); cairo_set_source_rgba (cr, 1, 0, 1, 0.5); cairo_rectangle (cr, PAT_WIDTH/6.0, PAT_HEIGHT/6.0, PAT_WIDTH/4.0, PAT_HEIGHT/4.0); cairo_fill (cr); cairo_set_source_rgba (cr, 0, 1, 1, 0.5); cairo_rectangle (cr, PAT_WIDTH/2.0, PAT_HEIGHT/2.0, PAT_WIDTH/4.0, PAT_HEIGHT/4.0); cairo_fill (cr); cairo_set_line_width (cr, 1); cairo_move_to (cr, PAT_WIDTH/6.0, 0); cairo_line_to (cr, 0, 0); cairo_line_to (cr, 0, PAT_HEIGHT/6.0); cairo_set_source_rgb (cr, 1, 0, 0); cairo_stroke (cr); cairo_move_to (cr, PAT_WIDTH/6.0, PAT_HEIGHT); cairo_line_to (cr, 0, PAT_HEIGHT); cairo_line_to (cr, 0, 5*PAT_HEIGHT/6.0); cairo_set_source_rgb (cr, 0, 1, 0); cairo_stroke (cr); cairo_move_to (cr, 5*PAT_WIDTH/6.0, 0); cairo_line_to (cr, PAT_WIDTH, 0); cairo_line_to (cr, PAT_WIDTH, PAT_HEIGHT/6.0); cairo_set_source_rgb (cr, 0, 0, 1); cairo_stroke (cr); cairo_move_to (cr, 5*PAT_WIDTH/6.0, PAT_HEIGHT); cairo_line_to (cr, PAT_WIDTH, PAT_HEIGHT); cairo_line_to (cr, PAT_WIDTH, 5*PAT_HEIGHT/6.0); cairo_set_source_rgb (cr, 1, 1, 0); cairo_stroke (cr); cairo_set_source_rgb (cr, 0.5, 0.5, 0.5); cairo_set_line_width (cr, PAT_WIDTH/10.0); cairo_move_to (cr, 0, PAT_HEIGHT/4.0); cairo_line_to (cr, PAT_WIDTH, PAT_HEIGHT/4.0); cairo_stroke (cr); cairo_move_to (cr, PAT_WIDTH/4.0, 0); cairo_line_to (cr, PAT_WIDTH/4.0, PAT_WIDTH); cairo_stroke (cr); pattern = cairo_pattern_create_for_surface (cairo_get_target (cr)); cairo_destroy (cr); return pattern; }