static Bool canvas_configure_event(GtkWidget *widget, GdkEventConfigure *event) { GtkAllocation allocation; cairo_text_extents_t te; //printf("canvas_configure_event\n"); gtk_widget_get_allocation(widget,&allocation); vdevice.sizeX = 1; vdevice.sizeY = 1; vdevice.minVx = vdevice.minVy = 0; vdevice.maxVx = vdevice.sizeSx = allocation.width; vdevice.maxVy = vdevice.sizeSy = allocation.height; vdevice.depth = 3; if (VGUI.cr!=NULL) { cairo_destroy (VGUI.cr); cairo_surface_destroy (VGUI.surface); } VGUI.surface= gdk_window_create_similar_surface (gtk_widget_get_window (VGUI.canvas), CAIRO_CONTENT_COLOR, vdevice.sizeSx, vdevice.sizeSy); VGUI.cr = cairo_create(VGUI.surface); cairo_set_antialias(VGUI.cr,VGUI.antialias); my_set_font(VGUI.cr); cairo_text_extents (VGUI.cr, "A", &te); vdevice.hheight = te.height; vdevice.hwidth = te.x_advance; VGUI.line_width=1; //printf("vdevice address=%ld, vdevice.sizeSx=%d, vdevice.sizeSy=%d\n", (long)&vdevice, vdevice.sizeSx, vdevice.sizeSy); Keyboard_Buffer_push(''); // queue a redraw command notify_input(); return TRUE; }
/* Create a new surface of the appropriate size to store our scribbles */ static gboolean scribble_configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer data) { GtkAllocation allocation; cairo_t *cr; if (surface) cairo_surface_destroy (surface); gtk_widget_get_allocation (widget, &allocation); surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, allocation.width, allocation.height); /* Initialize the surface to white */ cr = cairo_create (surface); cairo_set_source_rgb (cr, 1, 1, 1); cairo_paint (cr); cairo_destroy (cr); /* We've handled the configure event, no need for further processing. */ return TRUE; }
static void maybe_update_shape (GtkTooltip *tooltip) { cairo_t *cr; cairo_surface_t *surface; cairo_region_t *region; /* fallback to XShape only for non-composited clients */ if (gtk_widget_is_composited (tooltip->window)) { gtk_widget_shape_combine_region (tooltip->window, NULL); return; } surface = gdk_window_create_similar_surface (gtk_widget_get_window (tooltip->window), CAIRO_CONTENT_COLOR_ALPHA, gtk_widget_get_allocated_width (tooltip->window), gtk_widget_get_allocated_height (tooltip->window)); cr = cairo_create (surface); paint_background_and_frame (tooltip, cr); cairo_destroy (cr); region = gdk_cairo_region_create_from_surface (surface); gtk_widget_shape_combine_region (tooltip->window, region); cairo_surface_destroy (surface); cairo_region_destroy (region); }
static gint load_graph_configure (GtkWidget *widget, GdkEventConfigure *event, gpointer data_ptr) { GtkAllocation allocation; LoadGraph *c = (LoadGraph *) data_ptr; load_graph_unalloc (c); gtk_widget_get_allocation (c->disp, &allocation); c->draw_width = allocation.width; c->draw_height = allocation.height; c->draw_width = MAX (c->draw_width, 1); c->draw_height = MAX (c->draw_height, 1); load_graph_alloc (c); if (!c->surface) c->surface = gdk_window_create_similar_surface (gtk_widget_get_window (c->disp), CAIRO_CONTENT_COLOR, c->draw_width, c->draw_height); gtk_widget_queue_draw (widget); return TRUE; }
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 maybe_update_shape (GtkWidget *widget) { cairo_t *cr; cairo_surface_t *surface; cairo_region_t *region; /* fallback to XShape only for non-composited clients */ if (gtk_widget_is_composited (widget)) { gtk_widget_shape_combine_region (widget, NULL); return; } surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR_ALPHA, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); cr = cairo_create (surface); label_draw_background_and_frame (widget, cr, TRUE); cairo_destroy (cr); region = gdk_cairo_region_create_from_surface (surface); gtk_widget_shape_combine_region (widget, region); cairo_surface_destroy (surface); cairo_region_destroy (region); }
static void gtk_bubble_window_update_shape (GtkBubbleWindow *window) { cairo_surface_t *surface; cairo_region_t *region; GdkWindow *win; cairo_t *cr; win = gtk_widget_get_window (GTK_WIDGET (window)); surface = gdk_window_create_similar_surface (win, CAIRO_CONTENT_COLOR_ALPHA, gdk_window_get_width (win), gdk_window_get_height (win)); cr = cairo_create (surface); gtk_bubble_window_apply_border_path (window, cr); cairo_fill (cr); cairo_destroy (cr); region = gdk_cairo_region_create_from_surface (surface); cairo_surface_destroy (surface); if (!gtk_widget_is_composited (GTK_WIDGET (window))) gtk_widget_shape_combine_region (GTK_WIDGET (window), region); gtk_widget_input_shape_combine_region (GTK_WIDGET (window), region); cairo_region_destroy (region); }
static GdkPixbuf* accessx_status_applet_get_glyph_pixbuf(AccessxStatusApplet* sapplet, GtkWidget* widget, GdkPixbuf* base, GdkColor* fg, GdkColor* bg, gchar* glyphstring) { GdkPixbuf* glyph_pixbuf; cairo_surface_t *surface; PangoLayout* layout; PangoRectangle ink, logic; PangoContext* pango_context; gint w = gdk_pixbuf_get_width(base); gint h = gdk_pixbuf_get_height(base); cairo_t *cr; surface = gdk_window_create_similar_surface (gdk_get_default_root_window (), CAIRO_CONTENT_COLOR_ALPHA, w, h); pango_context = gtk_widget_get_pango_context(widget); layout = pango_layout_new(pango_context); pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); pango_layout_set_text(layout, glyphstring, -1); cr = cairo_create (surface); gdk_cairo_set_source_color (cr, bg); cairo_paint (cr); gdk_cairo_set_source_color (cr, fg); pango_layout_get_pixel_extents(layout, &ink, &logic); cairo_move_to (cr, (w - ink.x - ink.width)/2, (h - ink.y - ink.height)/2); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); g_object_unref(layout); glyph_pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, w, h); cairo_surface_destroy (surface); return glyph_pixbuf; }
static void selection_render_mask (Selection *selection) { GdkWindow *window; cairo_surface_t *surface; cairo_t *cr; window = gtk_widget_get_window (selection->shell->canvas); surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_ALPHA, gdk_window_get_width (window), gdk_window_get_height (window)); cr = cairo_create (surface); cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE); cairo_set_line_width (cr, 1.0); if (selection->shell->rotate_transform) cairo_transform (cr, selection->shell->rotate_transform); gimp_cairo_add_segments (cr, selection->segs_in, selection->n_segs_in); cairo_stroke (cr); selection->segs_in_mask = cairo_pattern_create_for_surface (surface); cairo_destroy (cr); cairo_surface_destroy (surface); }
static gboolean vfo_configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, gpointer data) { fprintf(stderr,"vfo_configure_event_cb: width=%d height=%d\n", gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); if (vfo_surface) cairo_surface_destroy (vfo_surface); vfo_surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); /* Initialize the surface to black */ cairo_t *cr; cr = cairo_create (vfo_surface); cairo_set_source_rgb (cr, 0, 0, 0); cairo_paint (cr); g_idle_add(vfo_update,NULL); /* We've handled the configure event, no need for further processing. */ return TRUE; }
/** * ppg_ruler_size_allocate: * @ruler: (in): A #PpgRuler. * * Handle the "size-allocate" for the #GtkWidget. The pixmap for the * background is created and drawn if necessary. * * Returns: None. * Side effects: None. */ static void ppg_ruler_size_allocate (GtkWidget *widget, GtkAllocation *alloc) { PpgRuler *ruler = (PpgRuler *)widget; PpgRulerPrivate *priv; GdkWindow *window; g_return_if_fail(PPG_IS_RULER(ruler)); priv = ruler->priv; GTK_WIDGET_CLASS(ppg_ruler_parent_class)->size_allocate(widget, alloc); if (priv->ruler) { cairo_surface_destroy(priv->ruler); } if (gtk_widget_is_drawable(widget)) { window = gtk_widget_get_window(widget); priv->ruler = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, alloc->width, alloc->height); ppg_ruler_draw_ruler(ruler); } }
std::unique_ptr<BackingStoreBackendCairo> BackingStore::createBackend() { #if PLATFORM(GTK) && PLATFORM(X11) const auto& sharedDisplay = PlatformDisplay::sharedDisplay(); if (is<PlatformDisplayX11>(sharedDisplay)) { GdkVisual* visual = gtk_widget_get_visual(m_webPageProxy.viewWidget()); GdkScreen* screen = gdk_visual_get_screen(visual); ASSERT(downcast<PlatformDisplayX11>(sharedDisplay).native() == GDK_SCREEN_XDISPLAY(screen)); return std::make_unique<BackingStoreBackendCairoX11>(downcast<PlatformDisplayX11>(sharedDisplay).native(), GDK_WINDOW_XID(gdk_screen_get_root_window(screen)), GDK_VISUAL_XVISUAL(visual), gdk_visual_get_depth(visual), m_size, m_deviceScaleFactor); } #endif IntSize scaledSize = m_size; scaledSize.scale(m_deviceScaleFactor); #if PLATFORM(GTK) RefPtr<cairo_surface_t> surface = adoptRef(gdk_window_create_similar_surface(gtk_widget_get_window(m_webPageProxy.viewWidget()), CAIRO_CONTENT_COLOR_ALPHA, scaledSize.width(), scaledSize.height())); #else RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_ARGB32, scaledSize.width(), scaledSize.height())); #endif cairoSurfaceSetDeviceScale(surface.get(), m_deviceScaleFactor, m_deviceScaleFactor); return std::make_unique<BackingStoreBackendCairoImpl>(surface.get(), m_size); }
void ChunkedUpdateDrawingAreaProxy::ensureBackingStore() { if (m_backingStoreImage) return; m_backingStoreImage = gdk_window_create_similar_surface(gtk_widget_get_window(m_webView->window()), CAIRO_CONTENT_COLOR_ALPHA, size().width(), size().height()); }
static gboolean on_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data) { if (surface != NULL) { cairo_surface_destroy(surface); } surface = gdk_window_create_similar_surface(gtk_widget_get_window(widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget)); clear_surface(); return TRUE; }
static cairo_region_t* curved_rect_mask(GtkWidget *widget) { GdkWindow *window; cairo_region_t *shape; cairo_surface_t *surface; cairo_t *cr; double w, h; int radius; if (!gtk_widget_get_realized(widget)) return NULL; window = gtk_widget_get_window(widget); w = gdk_window_get_width(window); h = gdk_window_get_height(window); if (w <= 50 || h <= 50) return NULL; radius = h / 4; surface = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, w, h); cr = cairo_create (surface); if (radius > w / 2) radius = w / 2; if (radius > h / 2) radius = h / 2; // fill shape with black cairo_save(cr); cairo_rectangle (cr, 0, 0, w, h); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_fill (cr); cairo_restore (cr); cairo_move_to (cr, 0, radius); cairo_curve_to (cr, 0 , 0, 0 , 0, radius, 0); cairo_line_to (cr, w - radius, 0); cairo_curve_to (cr, w, 0, w, 0, w, radius); cairo_line_to (cr, w , h - radius); cairo_curve_to (cr, w, h, w, h, w - radius, h); cairo_line_to (cr, 0 + radius, h); cairo_curve_to (cr, 0, h, 0, h, 0, h - radius); cairo_close_path(cr); cairo_set_source_rgb(cr, 1, 1, 1); cairo_fill(cr); cairo_destroy(cr); shape = gdk_cairo_region_create_from_surface(surface); cairo_surface_destroy(surface); return shape; }
static GdkPixbuf* accessx_status_applet_get_glyph_pixbuf(AccessxStatusApplet* sapplet, GtkWidget* widget, GdkPixbuf* base, GdkColor* fg, GdkColor* bg, gchar* glyphstring) { GdkPixbuf* glyph_pixbuf; #if GTK_CHECK_VERSION (3, 0, 0) cairo_surface_t *surface; #else GdkPixbuf *alpha_pixbuf; GdkPixmap* pixmap; #endif PangoLayout* layout; PangoRectangle ink, logic; PangoContext* pango_context; gint w = gdk_pixbuf_get_width(base); gint h = gdk_pixbuf_get_height(base); cairo_t *cr; #if GTK_CHECK_VERSION (3, 0, 0) surface = gdk_window_create_similar_surface (gdk_get_default_root_window (), CAIRO_CONTENT_COLOR_ALPHA, w, h); #else pixmap = gdk_pixmap_new(gdk_get_default_root_window (),w, h, -1); #endif pango_context = gtk_widget_get_pango_context(widget); layout = pango_layout_new(pango_context); pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); pango_layout_set_text(layout, glyphstring, -1); #if GTK_CHECK_VERSION (3, 0, 0) cr = cairo_create (surface); #else cr = gdk_cairo_create (pixmap); #endif gdk_cairo_set_source_color (cr, bg); cairo_paint (cr); gdk_cairo_set_source_color (cr, fg); pango_layout_get_pixel_extents(layout, &ink, &logic); cairo_move_to (cr, (w - ink.x - ink.width)/2, (h - ink.y - ink.height)/2); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); g_object_unref(layout); #if GTK_CHECK_VERSION (3, 0, 0) glyph_pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, w, h); cairo_surface_destroy (surface); return glyph_pixbuf; #else glyph_pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, NULL, 0, 0, 0, 0, w, h); g_object_unref(pixmap); alpha_pixbuf = gdk_pixbuf_add_alpha(glyph_pixbuf, TRUE, bg->red >> 8, bg->green >> 8, bg->blue >> 8); g_object_unref(G_OBJECT(glyph_pixbuf)); return alpha_pixbuf; #endif }
static cairo_surface_t * tile_surface (cairo_surface_t *surface, int width, int height) { cairo_surface_t *copy; cairo_t *cr; if (surface == NULL) { copy = gdk_window_create_similar_surface (gdk_get_default_root_window (), CAIRO_CONTENT_COLOR, width, height); } else { copy = cairo_surface_create_similar (surface, cairo_surface_get_content (surface), width, height); } cr = cairo_create (copy); if (surface != NULL) { cairo_pattern_t *pattern; cairo_set_source_surface (cr, surface, 0.0, 0.0); pattern = cairo_get_source (cr); cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); } else { GtkStyleContext *context; GdkRGBA bg; context = gtk_style_context_new (); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (gtk_css_provider_get_default ()), GTK_STYLE_PROVIDER_PRIORITY_THEME); gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg); gdk_cairo_set_source_rgba(cr, &bg); g_object_unref (G_OBJECT (context)); } cairo_paint (cr); if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy (copy); copy = NULL; } cairo_destroy(cr); return copy; }
static cairo_surface_t * tile_surface (cairo_surface_t *surface, int width, int height) { cairo_surface_t *copy; cairo_t *cr; #if GTK_CHECK_VERSION (3, 0, 0) if (surface == NULL) { copy = gdk_window_create_similar_surface (gdk_get_default_root_window (), CAIRO_CONTENT_COLOR, width, height); } else { copy = cairo_surface_create_similar (surface, cairo_surface_get_content (surface), width, height); } #else copy = gdk_pixmap_new(surface, width, height, surface == NULL? 24 : -1); #endif cr = cairo_create (copy); if (surface != NULL) { cairo_pattern_t *pattern; cairo_set_source_surface (cr, surface, 0.0, 0.0); pattern = cairo_get_source (cr); cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); } else { GtkStyle *style; style = gtk_widget_get_default_style (); gdk_cairo_set_source_color(cr, &style->bg[GTK_STATE_NORMAL]); } cairo_paint (cr); if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy (copy); copy = NULL; } cairo_destroy(cr); return copy; }
/* Redraws the backing pixmap for the load graph and updates the window */ static void load_graph_draw (LoadGraph *g) { GtkStyle *style; guint i, j; cairo_t *cr; /* we might get called before the configure event so that * g->disp->allocation may not have the correct size * (after the user resized the applet in the prop dialog). */ if (!g->surface) g->surface = gdk_window_create_similar_surface (gtk_widget_get_window (g->disp), CAIRO_CONTENT_COLOR, g->draw_width, g->draw_height); style = gtk_widget_get_style (g->disp); cr = cairo_create (g->surface); cairo_set_line_width (cr, 1.0); cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE); for (i = 0; i < g->draw_width; i++) g->pos [i] = g->draw_height - 1; for (j = 0; j < g->n; j++) { gdk_cairo_set_source_color (cr, &(g->colors [j])); for (i = 0; i < g->draw_width; i++) { if (g->data [i][j] != 0) { cairo_move_to (cr, g->draw_width - i - 0.5, g->pos[i] + 0.5); cairo_line_to (cr, g->draw_width - i - 0.5, g->pos[i] - (g->data [i][j] - 0.5)); g->pos [i] -= g->data [i][j]; } } cairo_stroke (cr); } cairo_destroy (cr); cr = gdk_cairo_create (gtk_widget_get_window (g->disp)); cairo_set_source_surface (cr, g->surface, 0, 0); cairo_paint (cr); cairo_destroy (cr); }
static gboolean gd_stack_draw (GtkWidget *widget, cairo_t *cr) { GdStack *stack = GD_STACK (widget); GdStackPrivate *priv = stack->priv; cairo_t *pattern_cr; if (priv->visible_child) { if (priv->transition_pos < 1.0) { if (priv->last_visible_surface == NULL && priv->last_visible_child != NULL) { gtk_widget_get_allocation (priv->last_visible_child->widget, &priv->last_visible_surface_allocation); priv->last_visible_surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR_ALPHA, priv->last_visible_surface_allocation.width, priv->last_visible_surface_allocation.height); pattern_cr = cairo_create (priv->last_visible_surface); /* We don't use propagate_draw here, because we don't want to apply the bin_window offset */ gtk_widget_draw (priv->last_visible_child->widget, pattern_cr); cairo_destroy (pattern_cr); } switch (priv->transition_type) { case GD_STACK_TRANSITION_TYPE_CROSSFADE: gd_stack_draw_crossfade (widget, cr); break; case GD_STACK_TRANSITION_TYPE_SLIDE_LEFT: case GD_STACK_TRANSITION_TYPE_SLIDE_RIGHT: gd_stack_draw_slide (widget, cr); break; default: g_assert_not_reached (); } } else if (gtk_cairo_should_draw_window (cr, priv->bin_window)) gtk_container_propagate_draw (GTK_CONTAINER (stack), priv->visible_child->widget, cr); } return TRUE; }
/** * ar_card_surface_cache_get_card_surface_by_id: * @cache: * @card_id: * * Returns: a cached #cairo_surface_t for @card_id. */ cairo_surface_t * ar_card_surface_cache_get_card_surface_by_id (ArCardSurfaceCache *cache, guint card_id) { ArCardSurfaceCachePrivate *priv = cache->priv; cairo_surface_t *surface; g_return_val_if_fail (card_id < AR_CARDS_TOTAL , NULL); LOG_CALL (cache); surface = priv->cards[card_id]; if (IS_FAILED_SURFACE (surface)) { LOG_CACHE_HIT (cache); return NULL; } if (surface == NULL) { CardSize card_size; cairo_t *cr; LOG_CACHE_MISS (cache); ar_card_theme_get_size (priv->theme, &card_size); if (priv->drawable != NULL) { surface = gdk_window_create_similar_surface (priv->drawable, CAIRO_CONTENT_COLOR_ALPHA, card_size.width, card_size.height); } else { surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, card_size.width, card_size.height); } cr = cairo_create (surface); ar_card_theme_paint_card (priv->theme, cr, card_id); cairo_destroy (cr); if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy (surface); priv->cards[card_id] = FAILED_SURFACE; return NULL; } priv->cards[card_id] = surface; /* adopts */ } else { LOG_CACHE_HIT (cache); } return surface; }
static gboolean splash_configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, gpointer data) { if (splash_surface) cairo_surface_destroy (splash_surface); splash_surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); return TRUE; }
static gboolean configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, gpointer data) { if (surface) cairo_surface_destroy(surface); surface = gdk_window_create_similar_surface(gtk_widget_get_window(widget), CAIRO_CONTENT_COLOR, CanvasWidth, CanvasWidth); DrawBoard(); gtk_widget_queue_draw_area(widget, 0, 0, CanvasWidth, CanvasWidth); return TRUE; }
static cairo_pattern_t * composite_image_onto_desktop (PanelBackground *background) { int width, height; cairo_t *cr; cairo_surface_t *surface; cairo_pattern_t *pattern; if (!background->desktop) background->desktop = get_desktop_pixbuf (background); if (!background->desktop) return NULL; width = gdk_pixbuf_get_width (background->desktop); height = gdk_pixbuf_get_height (background->desktop); surface = gdk_window_create_similar_surface (background->window, CAIRO_CONTENT_COLOR_ALPHA, width, height); if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy (surface); return NULL; } cr = cairo_create (surface); if(!gdk_window_check_composited_wm(background->window)){ cairo_set_source_rgb (cr, 1, 1, 1); cairo_paint (cr); gdk_cairo_set_source_pixbuf (cr, background->desktop, 0, 0); cairo_rectangle (cr, 0, 0, width, height); cairo_fill (cr); } gdk_cairo_set_source_pixbuf (cr, background->transformed_image, 0, 0); pattern = cairo_get_source (cr); cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); cairo_rectangle (cr, 0, 0, width, height); cairo_fill (cr); cairo_destroy (cr); pattern = cairo_pattern_create_for_surface (surface); cairo_surface_destroy (surface); return pattern; }
cairo_surface_t * create_surface (int w, int h, GtkWidget *parent_style_window) { GdkWindow *window; cairo_surface_t *surface; if (w == 0 || h == 0) abort (); window = gtk_widget_get_window (parent_style_window); surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR_ALPHA, w, h); return surface; }
/** * ppg_visualizer_resize_timeout: * @visualizer: (in): A #PpgVisualizer. * * A GSourceFunc to handle a resize request. The surface of the visualizer * is resized and a draw request is queued. * * Returns: %FALSE always * Side effects: None. */ static gboolean ppg_visualizer_resize_timeout (gpointer data) { PpgVisualizer *visualizer = (PpgVisualizer *)data; PpgVisualizerPrivate *priv; cairo_pattern_t *pattern; GdkWindow *window; GooCanvas *canvas; gdouble width; gdouble height; g_return_val_if_fail(PPG_IS_VISUALIZER(visualizer), FALSE); priv = visualizer->priv; /* * Remove existing surface. */ if (priv->surface) { g_object_set(visualizer, "pattern", NULL, NULL); cairo_surface_destroy(priv->surface); priv->surface = NULL; } /* * Create new surface matching new size allocation. */ g_object_get(visualizer, "height", &height, "width", &width, NULL); canvas = goo_canvas_item_get_canvas(GOO_CANVAS_ITEM(visualizer)); window = gtk_widget_get_window(GTK_WIDGET(canvas)); priv->surface = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, width, height); /* * Create a new pattern for drawing the item. */ pattern = cairo_pattern_create_for_surface(priv->surface); g_object_set(visualizer, "pattern", pattern, NULL); cairo_pattern_destroy(pattern); ppg_visualizer_queue_draw(visualizer); priv->resize_handler = 0; return FALSE; }
/* * Aquí creamos una superficie de dibujo en la cual vamos a almacenar todo. */ gboolean on_drawingareaPrincipal_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data){ /* Verificamos que la superficie no esté en uso */ if(superficie) cairo_surface_destroy(superficie); /* Creamos una nueva instancia de la superficie */ superficie = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); /* Iniciamos con una superficie limpia */ limpia_superficie(); /* En este punto hemos manejado satisfactoriamente el evento. */ return TRUE; }
static void gimp_ruler_make_pixmap (GimpRuler *ruler) { GtkWidget *widget = GTK_WIDGET (ruler); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation allocation; gtk_widget_get_allocation (widget, &allocation); if (priv->backing_store) cairo_surface_destroy (priv->backing_store); priv->backing_store = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, allocation.width, allocation.height); }
static int gtkDialogSetOpacityImageAttrib(Ihandle *ih, const char *value) { GdkPixbuf* pixbuf = iupImageGetImage(value, ih, 0); if (pixbuf) { #if GTK_CHECK_VERSION(3, 0, 0) GdkWindow* window = iupgtkGetWindow(ih->handle); if (window) { cairo_region_t *shape; #if GTK_CHECK_VERSION(3, 10, 0) cairo_surface_t* surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, 0, window); #else int width = gdk_pixbuf_get_width(pixbuf); int height = gdk_pixbuf_get_height(pixbuf); cairo_surface_t* surface = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, width, height); cairo_t* cr = cairo_create(surface); gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0); cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); cairo_paint(cr); cairo_destroy(cr); #endif shape = gdk_cairo_region_create_from_surface(surface); cairo_surface_destroy(surface); gtk_widget_shape_combine_region(ih->handle, shape); cairo_region_destroy(shape); } #else GdkBitmap* mask = NULL; gdk_pixbuf_render_pixmap_and_mask(pixbuf, NULL, &mask, 255); if (mask) { gtk_widget_shape_combine_mask(ih->handle, mask, 0, 0); g_object_unref(mask); } #endif return 1; } return 0; }
/* Create a new surface of the appropriate size to store our scribbles */ static gboolean configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, gpointer data) { if (surface) cairo_surface_destroy (surface); surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); /* Initialize the surface to white */ clear_surface (); /* We've handled the configure event, no need for further processing. */ return TRUE; }