static void drawGlyphsShadow(GraphicsContext* graphicsContext, const FloatPoint& point, PangoLayoutLine* layoutLine, PangoRegionType renderRegion) { ShadowBlur& shadow = graphicsContext->platformContext()->shadowBlur(); if (!(graphicsContext->textDrawingMode() & TextModeFill) || shadow.type() == ShadowBlur::NoShadow) return; FloatPoint totalOffset(point + graphicsContext->state().shadowOffset); // Optimize non-blurry shadows, by just drawing text without the ShadowBlur. if (!shadow.mustUseShadowBlur(graphicsContext)) { cairo_t* context = graphicsContext->platformContext()->cr(); cairo_save(context); cairo_translate(context, totalOffset.x(), totalOffset.y()); setSourceRGBAFromColor(context, graphicsContext->state().shadowColor); #if PLATFORM(GTK) gdk_cairo_region(context, renderRegion); #else appendRegionToCairoContext(context, renderRegion); #endif cairo_clip(context); pango_cairo_show_layout_line(context, layoutLine); cairo_restore(context); return; } FloatRect extents(getPangoRegionExtents(renderRegion)); extents.setLocation(FloatPoint(point.x(), point.y() - extents.height())); if (GraphicsContext* shadowContext = shadow.beginShadowLayer(graphicsContext, extents)) { cairo_t* cairoShadowContext = shadowContext->platformContext()->cr(); cairo_translate(cairoShadowContext, point.x(), point.y()); pango_cairo_show_layout_line(cairoShadowContext, layoutLine); // We need the clipping region to be active when we blit the blurred shadow back, // because we don't want any bits and pieces of characters out of range to be // drawn. Since ShadowBlur expects a consistent transform, we have to undo the // translation before calling endShadowLayer as well. cairo_t* context = graphicsContext->platformContext()->cr(); cairo_save(context); cairo_translate(context, totalOffset.x(), totalOffset.y()); #if PLATFORM(GTK) gdk_cairo_region(context, renderRegion); #else appendRegionToCairoContext(context, renderRegion); #endif cairo_clip(context); cairo_translate(context, -totalOffset.x(), -totalOffset.y()); shadow.endShadowLayer(graphicsContext); cairo_restore(context); } }
/* The plug window should completely occupy the area of the child, so we won't * get an expose event. But in case we do (the plug unmaps itself, say), this * expose handler draws with real or fake transparency. */ static gboolean na_tray_child_expose_event (GtkWidget *widget, GdkEventExpose *event) { NaTrayChild *child = NA_TRAY_CHILD (widget); GdkWindow *window = gtk_widget_get_window (widget); if (na_tray_child_has_alpha (child)) { /* Clear to transparent */ cairo_t *cr = gdk_cairo_create (window); cairo_set_source_rgba (cr, 0, 0, 0, 0); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); gdk_cairo_region (cr, event->region); cairo_fill (cr); cairo_destroy (cr); } else if (child->parent_relative_bg) { /* Clear to parent-relative pixmap */ gdk_window_clear_area (window, event->area.x, event->area.y, event->area.width, event->area.height); } return FALSE; }
static gboolean piano_keyboard_expose(GtkWidget *widget, GdkEventExpose *event) { int i; PianoKeyboard *pk = PIANO_KEYBOARD(widget); cairo_t* cr = gdk_cairo_create (GDK_DRAWABLE (GTK_WIDGET(pk)->window)); gdk_cairo_region (cr, event->region); cairo_clip (cr); for (i = 0; i < NNOTES; i++) { GdkRectangle r; r.x = pk->notes[i].x; r.y = 0; r.width = pk->notes[i].w; r.height = pk->notes[i].h; switch (gdk_region_rect_in (event->region, &r)) { case GDK_OVERLAP_RECTANGLE_PART: case GDK_OVERLAP_RECTANGLE_IN: draw_note (pk, cr, i); break; default: break; } } cairo_destroy (cr); return TRUE; }
static gboolean gimp_view_expose_event (GtkWidget *widget, GdkEventExpose *event) { if (gtk_widget_is_drawable (widget)) { GtkAllocation allocation; cairo_t *cr; gtk_widget_get_allocation (widget, &allocation); cr = gdk_cairo_create (event->window); gdk_cairo_region (cr, event->region); cairo_clip (cr); cairo_translate (cr, allocation.x, allocation.y); gimp_view_renderer_draw (GIMP_VIEW (widget)->renderer, widget, cr, allocation.width, allocation.height); cairo_destroy (cr); } return FALSE; }
static gboolean preview_expose(GtkWidget *widget, GdkEventExpose *event) { cairo_t *cr; gint width = preview_get_width (widget); gint height = preview_get_height (widget); cr = gdk_cairo_create (event->window); gdk_cairo_region (cr, event->region); cairo_clip (cr); cairo_set_line_width (cr, 1.); draw_grid (cr, width, height); draw_shapes (cr); if (_tmp_obj) { /* this is a bit of a hack */ gdouble dash = 4.; _tmp_obj->selected |= 4; cairo_set_source_rgb (cr, 1., 0., 1.); cairo_set_dash (cr, &dash, 1, dash); object_draw (_tmp_obj, cr); } cairo_destroy (cr); return FALSE; }
gboolean gimp_display_shell_canvas_expose (GtkWidget *widget, GdkEventExpose *eevent, GimpDisplayShell *shell) { /* are we in destruction? */ if (! shell->display || ! gimp_display_get_shell (shell->display)) return TRUE; /* ignore events on overlays */ if (eevent->window == gtk_widget_get_window (widget)) { cairo_t *cr; cr = gdk_cairo_create (gtk_widget_get_window (shell->canvas)); gdk_cairo_region (cr, eevent->region); cairo_clip (cr); if (gimp_display_get_image (shell->display)) { gimp_display_shell_canvas_draw_image (shell, cr); } else { gimp_display_shell_canvas_draw_drop_zone (shell, cr); } cairo_destroy (cr); } return FALSE; }
static void port_display_expose(GdkEventExpose *ev, GtkWidget *widget, GdkRectangle *rect, gdouble sliderstate, GdkPixbuf *image) { cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget)); GxPortDisplay *port_display = GX_PORT_DISPLAY(widget); GdkRegion *region; region = gdk_region_rectangle (&widget->allocation); gdk_region_intersect (region, ev->region); gdk_cairo_region (cr, region); cairo_clip (cr); gdk_cairo_set_source_pixbuf(cr, image, rect->x - (rect->width-(gint)sliderstate), rect->y); cairo_rectangle(cr, rect->x, rect->y, rect->width, rect->height); cairo_fill(cr); if (port_display->cutoff_low + port_display->cutoff_high) { cairo_set_source_rgba (cr, 0.8, 0.1, 0.1, 0.4); cairo_set_line_width(cr, rect->height); gint low = rect->width * port_display->cutoff_low * 0.01; gint high = (rect->width* port_display->cutoff_high * 0.01)-2; gint lw = rect->height/2; cairo_move_to(cr,rect->x, rect->y+lw); cairo_line_to(cr,rect->x + low, rect->y+lw); cairo_stroke (cr); cairo_move_to(cr,rect->width - high, rect->y+lw); cairo_line_to(cr,rect->width+2, rect->y+lw); cairo_stroke (cr); cairo_set_source_rgba (cr, 0.1, 0.6, 0.1, 0.4); cairo_move_to(cr,rect->x+ low, rect->y+lw); cairo_line_to(cr,rect->width - high, rect->y+lw); cairo_stroke (cr); } cairo_destroy(cr); gdk_region_destroy (region); }
static gboolean hd_incoming_event_window_expose_event (GtkWidget *widget, GdkEventExpose *event) { HDIncomingEventWindowPrivate *priv = HD_INCOMING_EVENT_WINDOW (widget)->priv; cairo_t *cr; cr = gdk_cairo_create (GDK_DRAWABLE (widget->window)); gdk_cairo_region (cr, event->region); cairo_clip (cr); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0); cairo_paint (cr); cairo_set_operator (cr, CAIRO_OPERATOR_OVER); cairo_set_source_surface (cr, priv->bg_image, 0.0, 0.0); cairo_paint (cr); cairo_destroy (cr); return GTK_WIDGET_CLASS (hd_incoming_event_window_parent_class)->expose_event (widget, event); }
static gboolean gimp_ruler_expose (GtkWidget *widget, GdkEventExpose *event) { if (gtk_widget_is_drawable (widget)) { GimpRuler *ruler = GIMP_RULER (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation allocation; cairo_t *cr; gimp_ruler_draw_ticks (ruler); cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_region (cr, event->region); cairo_clip (cr); gtk_widget_get_allocation (widget, &allocation); cairo_translate (cr, allocation.x, allocation.y); cairo_set_source_surface (cr, priv->backing_store, 0, 0); cairo_paint (cr); gimp_ruler_draw_pos (ruler); cairo_destroy (cr); } return FALSE; }
static gboolean canvas_expose_event (GtkWidget *widget, GdkEventExpose *event) { cairo_t *cr; GList *iter; GtkAllocation allocation; cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_region (cr, event->region); cairo_clip (cr); gtk_widget_get_allocation (widget, &allocation); cairo_set_source_rgb (cr, 1, 1, 1); cairo_rectangle (cr, 0, 0, allocation.width, allocation.height); cairo_fill (cr); for (iter = canvas_items; iter; iter = iter->next) canvas_item_draw (iter->data, cr, FALSE); if (drop_item) canvas_item_draw (drop_item, cr, TRUE); cairo_destroy (cr); return TRUE; }
void Font::drawComplexText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const { #if defined(USE_FREETYPE) if (!primaryFont()->platformData().m_pattern) { drawSimpleText(context, run, point, from, to); return; } #endif cairo_t* cr = context->platformContext(); PangoLayout* layout = pango_cairo_create_layout(cr); setPangoAttributes(this, run, layout); gchar* utf8 = convertUniCharToUTF8(run.characters(), run.length(), 0, run.length()); pango_layout_set_text(layout, utf8, -1); // Our layouts are single line PangoLayoutLine* layoutLine = pango_layout_get_line_readonly(layout, 0); // Get the region where this text will be laid out. We will use it to clip // the Cairo context, for when we are only painting part of the text run and // to calculate the size of the shadow buffer. PangoRegionType partialRegion = 0; char* start = g_utf8_offset_to_pointer(utf8, from); char* end = g_utf8_offset_to_pointer(start, to - from); int ranges[] = {start - utf8, end - utf8}; partialRegion = gdk_pango_layout_line_get_clip_region(layoutLine, 0, 0, ranges, 1); drawGlyphsShadow(context, cr, point, layoutLine, partialRegion); cairo_save(cr); cairo_translate(cr, point.x(), point.y()); float red, green, blue, alpha; context->fillColor().getRGBA(red, green, blue, alpha); cairo_set_source_rgba(cr, red, green, blue, alpha); gdk_cairo_region(cr, partialRegion); cairo_clip(cr); pango_cairo_show_layout_line(cr, layoutLine); if (context->textDrawingMode() & TextModeStroke) { Color strokeColor = context->strokeColor(); strokeColor.getRGBA(red, green, blue, alpha); cairo_set_source_rgba(cr, red, green, blue, alpha); pango_cairo_layout_line_path(cr, layoutLine); cairo_set_line_width(cr, context->strokeThickness()); cairo_stroke(cr); } // Pango sometimes leaves behind paths we don't want cairo_new_path(cr); destroyPangoRegion(partialRegion); g_free(utf8); g_object_unref(layout); cairo_restore(cr); }
static gboolean hd_bookmark_shortcut_expose_event (GtkWidget *widget, GdkEventExpose *event) { HDBookmarkShortcutPrivate *priv = HD_BOOKMARK_SHORTCUT (widget)->priv; cairo_t *cr; cairo_surface_t *bg; cairo_surface_t *thumbnail_icon; cr = gdk_cairo_create (GDK_DRAWABLE (widget->window)); gdk_cairo_region (cr, event->region); cairo_clip (cr); if (priv->button_pressed) bg = priv->bg_active; else bg = priv->bg_image; cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0); cairo_paint (cr); if (priv->thumbnail_icon) thumbnail_icon = priv->thumbnail_icon; else { create_default_thumbnail (HD_BOOKMARK_SHORTCUT (widget), bg); thumbnail_icon = priv->default_thumbnail_icon; } if (thumbnail_icon) { cairo_set_source_surface (cr, thumbnail_icon, BORDER_WIDTH_LEFT, BORDER_WIDTH_TOP); if (priv->thumb_mask) cairo_mask_surface (cr, priv->thumb_mask, BORDER_WIDTH_LEFT, BORDER_WIDTH_TOP); } cairo_set_operator (cr, CAIRO_OPERATOR_OVER); if (bg) { cairo_set_source_surface (cr, bg, 0.0, 0.0); cairo_paint (cr); } cairo_destroy (cr); return GTK_WIDGET_CLASS (hd_bookmark_shortcut_parent_class)->expose_event (widget, event); }
static void _gtk_pixel_cache_repaint (GtkPixelCache *cache, GdkWindow *window, GtkPixelCacheDrawFunc draw, cairo_rectangle_int_t *view_rect, cairo_rectangle_int_t *canvas_rect, gpointer user_data) { cairo_t *backing_cr; cairo_region_t *region_dirty = cache->surface_dirty; cache->surface_dirty = NULL; if (cache->surface && region_dirty && !cairo_region_is_empty (region_dirty)) { backing_cr = cairo_create (cache->surface); gdk_cairo_region (backing_cr, region_dirty); cairo_clip (backing_cr); cairo_translate (backing_cr, -cache->surface_x - canvas_rect->x - view_rect->x, -cache->surface_y - canvas_rect->y - view_rect->y); cairo_save (backing_cr); cairo_set_source_rgba (backing_cr, 0.0, 0, 0, 0.0); cairo_set_operator (backing_cr, CAIRO_OPERATOR_SOURCE); cairo_paint (backing_cr); cairo_restore (backing_cr); cairo_save (backing_cr); draw (backing_cr, user_data); cairo_restore (backing_cr); #ifdef G_ENABLE_DEBUG if (GTK_DISPLAY_DEBUG_CHECK (gdk_window_get_display (window), PIXEL_CACHE)) { GdkRGBA colors[] = { { 1, 0, 0, 0.08}, { 0, 1, 0, 0.08}, { 0, 0, 1, 0.08}, { 1, 0, 1, 0.08}, { 1, 1, 0, 0.08}, { 0, 1, 1, 0.08}, }; static int current_color = 0; gdk_cairo_set_source_rgba (backing_cr, &colors[(current_color++) % G_N_ELEMENTS (colors)]); cairo_paint (backing_cr); } #endif cairo_destroy (backing_cr); } if (region_dirty) cairo_region_destroy (region_dirty); }
na_tray_child_expose_event (GtkWidget *widget, GdkEventExpose *event) #endif { NaTrayChild *child = NA_TRAY_CHILD (widget); GdkWindow *window = gtk_widget_get_window (widget); if (na_tray_child_has_alpha (child)) { /* Clear to transparent */ #if !GTK_CHECK_VERSION (3, 0, 0) cairo_t *cr = gdk_cairo_create (window); #endif cairo_set_source_rgba (cr, 0, 0, 0, 0); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); #if GTK_CHECK_VERSION (3, 0, 0) cairo_paint (cr); #else gdk_cairo_region (cr, event->region); cairo_fill (cr); cairo_destroy (cr); #endif } else if (child->parent_relative_bg) { /* Clear to parent-relative pixmap */ #if GTK_CHECK_VERSION (3, 0, 0) GdkWindow *window; cairo_surface_t *target; GdkRectangle clip_rect; window = gtk_widget_get_window (widget); target = cairo_get_group_target (cr); gdk_cairo_get_clip_rectangle (cr, &clip_rect); /* Clear to parent-relative pixmap * We need to use direct X access here because GDK doesn't know about * the parent relative pixmap. */ cairo_surface_flush (target); XClearArea (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window), clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height, False); cairo_surface_mark_dirty_rectangle (target, clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height); #else gdk_window_clear_area (window, event->area.x, event->area.y, event->area.width, event->area.height); #endif } return FALSE; }
static void drawGlyphsShadow(GraphicsContext* graphicsContext, cairo_t* context, const FloatPoint& point, PangoLayoutLine* layoutLine, PangoRegionType renderRegion) { ContextShadow* shadow = graphicsContext->contextShadow(); ASSERT(shadow); if (!(graphicsContext->textDrawingMode() & TextModeFill) || shadow->m_type == ContextShadow::NoShadow) return; FloatPoint totalOffset(point + shadow->m_offset); // Optimize non-blurry shadows, by just drawing text without the ContextShadow. if (!shadow->mustUseContextShadow(context)) { cairo_save(context); cairo_translate(context, totalOffset.x(), totalOffset.y()); setSourceRGBAFromColor(context, shadow->m_color); gdk_cairo_region(context, renderRegion); cairo_clip(context); pango_cairo_show_layout_line(context, layoutLine); cairo_restore(context); return; } FloatRect extents(getPangoRegionExtents(renderRegion)); extents.setLocation(FloatPoint(point.x(), point.y() - extents.height())); cairo_t* shadowContext = shadow->beginShadowLayer(context, extents); if (shadowContext) { cairo_translate(shadowContext, point.x(), point.y()); pango_cairo_show_layout_line(shadowContext, layoutLine); // We need the clipping region to be active when we blit the blurred shadow back, // because we don't want any bits and pieces of characters out of range to be // drawn. Since ContextShadow expects a consistent transform, we have to undo the // translation before calling endShadowLayer as well. cairo_save(context); cairo_translate(context, totalOffset.x(), totalOffset.y()); gdk_cairo_region(context, renderRegion); cairo_clip(context); cairo_translate(context, -totalOffset.x(), -totalOffset.y()); shadow->endShadowLayer(context); cairo_restore(context); } }
static gboolean gimp_color_frame_expose (GtkWidget *widget, GdkEventExpose *eevent) { GimpColorFrame *frame = GIMP_COLOR_FRAME (widget); if (frame->has_number) { GtkStyle *style = gtk_widget_get_style (widget); GtkAllocation allocation; GtkAllocation menu_allocation; GtkAllocation color_area_allocation; cairo_t *cr; gchar buf[8]; gint w, h; gdouble scale; gtk_widget_get_allocation (widget, &allocation); gtk_widget_get_allocation (frame->menu, &menu_allocation); gtk_widget_get_allocation (frame->color_area, &color_area_allocation); cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_region (cr, eevent->region); cairo_clip (cr); cairo_translate (cr, allocation.x, allocation.y); gdk_cairo_set_source_color (cr, &style->light[GTK_STATE_NORMAL]); g_snprintf (buf, sizeof (buf), "%d", frame->number); if (! frame->number_layout) frame->number_layout = gtk_widget_create_pango_layout (widget, NULL); pango_layout_set_text (frame->number_layout, buf, -1); pango_layout_get_pixel_size (frame->number_layout, &w, &h); scale = ((gdouble) (allocation.height - menu_allocation.height - color_area_allocation.height) / (gdouble) h); cairo_scale (cr, scale, scale); cairo_move_to (cr, (allocation.width / 2.0) / scale - w / 2.0, (allocation.height / 2.0 + menu_allocation.height / 2.0 + color_area_allocation.height / 2.0) / scale - h / 2.0); pango_cairo_show_layout (cr, frame->number_layout); cairo_destroy (cr); } return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, eevent); }
bool MyPaintBox::on_expose_event(GdkEventExpose *event) { call_paint_func(event); Cairo::RefPtr<Cairo::Context> cr = Glib::wrap(event->window, true)->create_cairo_context(); gdk_cairo_region(cr->cobj(), event->region); cr->clip(); cr->set_source_rgba(0.0, 0.0, 0.0, 1-background_adj->get_value()); cr->paint(); foreach(sigc::bind(sigc::mem_fun(this, &MyPaintBox::propagate_expose), event)); return true; }
gboolean gimp_overlay_child_expose (GimpOverlayBox *box, GimpOverlayChild *child, GdkEventExpose *event) { GtkWidget *widget; g_return_val_if_fail (GIMP_IS_OVERLAY_BOX (box), FALSE); g_return_val_if_fail (child != NULL, FALSE); g_return_val_if_fail (event != NULL, FALSE); widget = GTK_WIDGET (box); if (event->window == gtk_widget_get_window (widget)) { GtkAllocation child_allocation; GdkRectangle bounds; gtk_widget_get_allocation (child->widget, &child_allocation); gimp_overlay_child_transform_bounds (child, &child_allocation, &bounds); if (gtk_widget_get_visible (child->widget) && gdk_rectangle_intersect (&event->area, &bounds, NULL)) { GdkPixmap *pixmap = gdk_offscreen_window_get_pixmap (child->window); cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_region (cr, event->region); cairo_clip (cr); cairo_transform (cr, &child->matrix); gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0); cairo_paint_with_alpha (cr, child->opacity); cairo_destroy (cr); } } else if (event->window == child->window) { if (! gtk_widget_get_app_paintable (child->widget)) gtk_paint_flat_box (gtk_widget_get_style (child->widget), event->window, GTK_STATE_NORMAL, GTK_SHADOW_NONE, &event->area, widget, NULL, 0, 0, -1, -1); gtk_container_propagate_expose (GTK_CONTAINER (widget), child->widget, event); return TRUE; } return FALSE; }
static gboolean gimp_palette_view_expose (GtkWidget *widget, GdkEventExpose *eevent) { GimpPaletteView *pal_view = GIMP_PALETTE_VIEW (widget); GimpView *view = GIMP_VIEW (widget); if (! gtk_widget_is_drawable (widget)) return FALSE; GTK_WIDGET_CLASS (parent_class)->expose_event (widget, eevent); if (view->renderer->viewable && pal_view->selected) { GimpViewRendererPalette *renderer; GtkStyle *style = gtk_widget_get_style (widget); GtkAllocation allocation; cairo_t *cr; gint row, col; renderer = GIMP_VIEW_RENDERER_PALETTE (view->renderer); gtk_widget_get_allocation (widget, &allocation); row = pal_view->selected->position / renderer->columns; col = pal_view->selected->position % renderer->columns; cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_region (cr, eevent->region); cairo_clip (cr); cairo_translate (cr, allocation.x, allocation.y); cairo_rectangle (cr, col * renderer->cell_width + 0.5, row * renderer->cell_height + 0.5, renderer->cell_width, renderer->cell_height); cairo_set_line_width (cr, 1.0); gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_SELECTED]); cairo_stroke_preserve (cr); if (gimp_cairo_set_focus_line_pattern (cr, widget)) { gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]); cairo_stroke (cr); } cairo_destroy (cr); } return FALSE; }
static gboolean expose_event(GtkWidget *widget, GdkEventExpose *event, GdkPixmap *pixmap) { cairo_t *cr; cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0); gdk_cairo_region (cr, event->region); cairo_fill (cr); cairo_destroy (cr); return FALSE; }
static gboolean avatar_image_expose_event (GtkWidget *widget, GdkEventExpose *event) { GiggleAvatarImagePriv *priv = GET_PRIV (widget); GtkAllocation allocation; GtkRequisition requisition; GtkStyle *style; float xalign, yalign; double x, y; int w, h; cairo_t *cr; gtk_widget_size_request (widget, &requisition); gtk_widget_get_allocation (widget, &allocation); style = gtk_widget_get_style (widget); cr = gdk_cairo_create (event->window); gdk_cairo_region (cr, event->region); cairo_clip (cr); w = requisition.width; h = requisition.height; gtk_misc_get_alignment (GTK_MISC (widget), &xalign, &yalign); cairo_translate (cr, (int) ((allocation.width - w) * xalign), (int) ((allocation.height - h) * yalign)); rounded_rectangle (cr, 0.5, 0.5, w - 1, h - 1, MIN (w, h) * 0.2); gdk_cairo_set_source_color (cr, &style->base[GTK_STATE_NORMAL]); cairo_fill_preserve (cr); if (priv->pixbuf) { x = (w - gdk_pixbuf_get_width (priv->pixbuf)) * 0.5; y = (h - gdk_pixbuf_get_height (priv->pixbuf)) * 0.5; gdk_cairo_set_source_pixbuf (cr, priv->pixbuf, x, y); cairo_fill_preserve (cr); } gdk_cairo_set_source_color (cr, &style->text[GTK_STATE_NORMAL]); cairo_set_line_width (cr, 1); cairo_stroke (cr); cairo_destroy (cr); return TRUE; }
static void _gegueb_window_draw(Gegueb_Window *thiz) { cairo_t *cr; //gdk_window_begin_paint_region(thiz->win, thiz->regions); cr = gdk_cairo_create(thiz->win); gdk_cairo_region(cr, thiz->regions); gegueb_document_draw(thiz->doc, cr, thiz->damages); gdk_region_empty(thiz->regions); //gdk_window_end_paint(thiz->win); //gdk_window_flush(thiz->win); cairo_destroy(cr); thiz->damages = NULL; }
static gboolean mdk_text_scroller_expose(GtkWidget *textScroller, GdkEventExpose *event) { MdkTextScroller *ts = MDK_TEXT_SCROLLER(textScroller); cairo_t *cr; cr = gdk_cairo_create(textScroller->window); gdk_cairo_region(cr, event->region); cairo_clip(cr); cairo_select_font_face(cr, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size(cr, ts->size); cairo_move_to(cr, ts->x+ts->xOffset, ts->y+ts->yOffset); cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); cairo_show_text(cr, ts->text); if (ts->width == 0 || ts->height == 0) { cairo_text_extents_t ext; cairo_text_extents(cr, ts->text, &ext); ts->width = ext.width; ts->height = ext.height; } if (ts->width+ts->xOffset+100 < 0) { cairo_move_to(cr, ts->x+ts->xOffset+ts->width+100, ts->y +ts->yOffset); cairo_show_text(cr, ts->text); } if (ts->x+ts->xOffset+ts->width < 0) { ts->xOffset=ts->xOffset+ts->width+100; } cairo_stroke(cr); cairo_destroy(cr); }
void GraphicsContext::drawFocusRing(const Color& color) { if (paintingDisabled()) return; const Vector<IntRect>& rects = focusRingRects(); unsigned rectCount = rects.size(); cairo_t* cr = m_data->cr; cairo_save(cr); cairo_push_group(cr); cairo_new_path(cr); #if PLATFORM(GTK) GdkRegion* reg = gdk_region_new(); for (unsigned i = 0; i < rectCount; i++) { GdkRectangle rect = rects[i]; gdk_region_union_with_rect(reg, &rect); } gdk_cairo_region(cr, reg); gdk_region_destroy(reg); setColor(cr, color); cairo_set_line_width(cr, 2.0f); setPlatformStrokeStyle(DottedStroke); #else int radius = (focusRingWidth() - 1) / 2; for (unsigned i = 0; i < rectCount; i++) addPath(Path::createRoundedRectangle(rects[i], FloatSize(radius, radius))); // Force the alpha to 50%. This matches what the Mac does with outline rings. Color ringColor(color.red(), color.green(), color.blue(), 127); setColor(cr, ringColor); cairo_set_line_width(cr, focusRingWidth()); setPlatformStrokeStyle(SolidStroke); #endif cairo_set_operator(cr, CAIRO_OPERATOR_OVER); cairo_stroke_preserve(cr); cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); cairo_set_fill_rule(cr, CAIRO_FILL_RULE_WINDING); cairo_fill(cr); cairo_pop_group_to_source(cr); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); cairo_paint(cr); cairo_restore(cr); }
static gboolean polygon_view_expose (GtkWidget *w, GdkEventExpose *ev) { PolygonView *self = (PolygonView *) w; cairo_t *cr; cr = gdk_cairo_create (w->window); gdk_cairo_region (cr, ev->region); cairo_clip (cr); polygon_view_draw (self, cr); cairo_destroy (cr); return FALSE; }
static gboolean expose_event(GtkWidget * widget, GdkEventExpose * event) { printf("%s\n", __func__); cairo_t *cr; cr = gdk_cairo_create(GDK_DRAWABLE(widget->window)); gdk_cairo_region(cr, event->region); cairo_clip(cr); cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_rgba(cr, 0.5, 0.5, 0.5, 1.0); cairo_paint(cr); cairo_destroy(cr); return false; }
static gboolean about_dialog_anim_expose (GtkWidget *widget, GdkEventExpose *event, GimpAboutDialog *dialog) { GtkStyle *style = gtk_widget_get_style (widget); cairo_t *cr; GtkAllocation allocation; gint x, y; gint width, height; if (! dialog->visible) return FALSE; cr = gdk_cairo_create (event->window); gdk_cairo_set_source_color (cr, &style->text[GTK_STATE_NORMAL]); gtk_widget_get_allocation (widget, &allocation); pango_layout_get_pixel_size (dialog->layout, &width, &height); x = (allocation.width - width) / 2; y = (allocation.height - height) / 2; if (dialog->textrange[1] > 0) { GdkRegion *covered_region; covered_region = gdk_pango_layout_get_clip_region (dialog->layout, x, y, dialog->textrange, 1); gdk_region_intersect (covered_region, event->region); gdk_cairo_region (cr, covered_region); cairo_clip (cr); gdk_region_destroy (covered_region); } cairo_move_to (cr, x, y); pango_cairo_show_layout (cr, dialog->layout); cairo_destroy (cr); return FALSE; }
static gboolean window_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data) { cairo_t *cr; cr = gdk_cairo_create (gtk_widget_get_window (widget)); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); gdk_cairo_region (cr, event->region); cairo_set_source_rgba (cr, 1., 1., 1., .5); cairo_fill (cr); cairo_destroy (cr); return FALSE; }
static void on_preview_expose_event (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data) { ScreenshotDialog *dialog = data; GdkPixbuf *pixbuf = NULL; gboolean free_pixbuf = FALSE; cairo_t *cr; /* Stolen from GtkImage. I really should just make the drawing area an * image some day */ if (gtk_widget_get_state (drawing_area) != GTK_STATE_NORMAL) { GtkIconSource *source; source = gtk_icon_source_new (); gtk_icon_source_set_pixbuf (source, dialog->preview_image); gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_icon_source_set_size_wildcarded (source, FALSE); pixbuf = gtk_style_render_icon (drawing_area->style, source, gtk_widget_get_direction (drawing_area), gtk_widget_get_state (drawing_area), (GtkIconSize) -1, drawing_area, "gtk-image"); free_pixbuf = TRUE; gtk_icon_source_free (source); } else { pixbuf = g_object_ref (dialog->preview_image); } cr = gdk_cairo_create (drawing_area->window); gdk_cairo_region (cr, event->region); cairo_clip (cr); gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); cairo_paint (cr); cairo_destroy (cr); g_object_unref (pixbuf); }
/* Handler for expose_event on drawing area. */ static gboolean desk_expose_event(GtkWidget * widget, GdkEventExpose * event, PagerDesk * d) { GtkStyle * style = gtk_widget_get_style(widget); if (d->pixmap != NULL) { cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget)); gdk_cairo_region(cr, event->region); cairo_clip(cr); /* Recompute the pixmap if needed. */ if (d->dirty) { d->dirty = FALSE; PagerPlugin * pg = d->pg; /* Erase the pixmap. */ if (d->pixmap != NULL) { //GtkWidget * widget = GTK_WIDGET(d->da); cairo_t *cr0 = cairo_create(d->pixmap); gdk_cairo_set_source_color(cr0, ((d->desktop_number == d->pg->current_desktop) ? &style->dark[GTK_STATE_SELECTED] : &style->dark[GTK_STATE_NORMAL])); cairo_paint(cr0); check_cairo_status(cr0); cairo_destroy(cr0); } /* Draw tasks onto the pixmap. */ int j; for (j = 0; j < pg->client_count; j++) task_update_pixmap(pg->tasks_in_stacking_order[j], d); } /* Draw the requested part of the pixmap onto the drawing area. */ GtkAllocation allocation; gtk_widget_get_allocation(GTK_WIDGET(widget), &allocation); gdk_cairo_set_source_color(cr, &style->fg[GTK_WIDGET_STATE(widget)]); cairo_set_source_surface(cr, d->pixmap, 0, 0); cairo_paint(cr); check_cairo_status(cr); cairo_destroy(cr); } return FALSE; }