static void pgd_selections_clear_selections (PgdSelectionsDemo *demo) { demo->start.x = -1; if (demo->selection_surface) { cairo_surface_destroy (demo->selection_surface); demo->selection_surface = NULL; } if (demo->selection_region) { cairo_region_destroy (demo->selection_region); demo->selection_region = NULL; } if (demo->selected_text) { g_free (demo->selected_text); demo->selected_text = NULL; } if (demo->selected_region) { cairo_region_destroy (demo->selected_region); demo->selected_region = NULL; } }
static gboolean byzanz_recorder_snapshot (ByzanzRecorder *recorder) { cairo_surface_t *surface; cairo_region_t *invalid; GTimeVal tv; if (!recorder->recording) return FALSE; if (recorder->next_image_source != 0) return FALSE; invalid = byzanz_recorder_get_invalid_region (recorder); if (cairo_region_is_empty (invalid)) { cairo_region_destroy (invalid); return FALSE; } surface = byzanz_recorder_create_snapshot (recorder, invalid); g_get_current_time (&tv); cairo_region_translate (invalid, -recorder->area.x, -recorder->area.y); g_signal_emit (recorder, signals[IMAGE], 0, surface, invalid, &tv); cairo_surface_destroy (surface); cairo_region_destroy (invalid); recorder->next_image_source = gdk_threads_add_timeout_full (G_PRIORITY_HIGH_IDLE, BYZANZ_RECORDER_FRAME_RATE_MS, byzanz_recorder_next_image, recorder, NULL); return TRUE; }
static void finalize(GObject *base) { struct Private *priv = GET_PRIVATE(base); if (priv->area) { cairo_region_destroy(priv->area); } if (priv->expose) { cairo_region_destroy(priv->expose); } if (priv->rects) { g_array_free(priv->rects, TRUE); } JoyScreen *self = (JoyScreen *)base; GFX3D_Rect rect = { 0, 0, joy_screen_get_width(self), joy_screen_get_height(self) }; if (priv->display) { GFX3D_Display_ClearAlpha2D(priv->display, NULL, &rect, 0., 0., 0., 0.); GFX3D_Display_Show_Partial(priv->display, &rect, 1, 1); GFX3D_Display_Destroy(priv->display); } if (priv->cursor) { GFX3D_Display_ClearAlpha2D(priv->cursor, NULL, &rect, 0., 0., 0., 0.); GFX3D_Display_Show_Ch_Reload(priv->cursor); GFX3D_Cursor_Destroy(priv->cursor); } G_OBJECT_CLASS(joy_gfx3d_screen_parent_class)->finalize(base); }
/* When there are multiple monitors with different resolutions, the visible area * within the root window may not be rectangular (it may have an L-shape, for * example). In that case, mask out the areas of the root window which would * not be visible in the monitors, so that screenshot do not end up with content * that the user won't ever see. */ static void mask_monitors (GdkPixbuf *pixbuf, GdkWindow *root_window) { GdkScreen *screen; cairo_region_t *region_with_monitors; cairo_region_t *invisible_region; cairo_rectangle_int_t rect; screen = gdk_window_get_screen (root_window); region_with_monitors = make_region_with_monitors (screen); rect.x = 0; rect.y = 0; rect.width = gdk_screen_get_width (screen); rect.height = gdk_screen_get_height (screen); invisible_region = cairo_region_create_rectangle (&rect); cairo_region_subtract (invisible_region, region_with_monitors); blank_region_in_pixbuf (pixbuf, invisible_region); cairo_region_destroy (region_with_monitors); cairo_region_destroy (invisible_region); }
void on_monitors_changed ( GdkScreen *screen, gpointer user_data) { GromitData *data = (GromitData *) user_data; if(data->debug) g_printerr("DEBUG: screen size changed!\n"); // get new sizes data->width = gdk_screen_get_width (data->screen); data->height = gdk_screen_get_height (data->screen); // change size gtk_widget_set_size_request(GTK_WIDGET(data->win), data->width, data->height); // try to set transparent for input cairo_region_t* r = cairo_region_create(); gtk_widget_input_shape_combine_region(data->win, r); cairo_region_destroy(r); /* recreate the shape surface */ cairo_surface_t *new_shape = cairo_image_surface_create(CAIRO_FORMAT_ARGB32 ,data->width, data->height); cairo_t *cr = cairo_create (new_shape); cairo_set_source_surface (cr, data->backbuffer, 0, 0); cairo_paint (cr); cairo_destroy (cr); cairo_surface_destroy(data->backbuffer); data->backbuffer = new_shape; /* these depend on the shape surface */ GHashTableIter it; gpointer value; g_hash_table_iter_init (&it, data->tool_config); while (g_hash_table_iter_next (&it, NULL, &value)) paint_context_free(value); g_hash_table_remove_all(data->tool_config); parse_config(data); // also calls paint_context_new() :-( data->default_pen = paint_context_new (data, GROMIT_PEN, data->red, 7, 0, 1); data->default_eraser = paint_context_new (data, GROMIT_ERASER, data->red, 75, 0, 1); if(!data->composited) // set shape { cairo_region_t* r = gdk_cairo_region_create_from_surface(data->backbuffer); gtk_widget_shape_combine_region(data->win, r); cairo_region_destroy(r); } setup_input_devices(data); gtk_widget_show_all (data->win); }
/** * gsk_renderer_render: * @renderer: a #GskRenderer * @root: a #GskRenderNode * @region: (nullable): the #cairo_region_t that must be redrawn or %NULL * for the whole window * * Renders the scene graph, described by a tree of #GskRenderNode instances, * ensuring that the given @region gets redrawn. * * Renderers must ensure that changes of the contents given by the @root * node as well as the area given by @region are redrawn. They are however * free to not redraw any pixel outside of @region if they can guarantee that * it didn't change. * * The @renderer will acquire a reference on the #GskRenderNode tree while * the rendering is in progress. */ void gsk_renderer_render (GskRenderer *renderer, GskRenderNode *root, const cairo_region_t *region) { GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer); cairo_region_t *clip; g_return_if_fail (GSK_IS_RENDERER (renderer)); g_return_if_fail (priv->is_realized); g_return_if_fail (GSK_IS_RENDER_NODE (root)); g_return_if_fail (priv->root_node == NULL); if (region == NULL || priv->prev_node == NULL || GSK_RENDERER_DEBUG_CHECK (renderer, FULL_REDRAW)) { clip = cairo_region_create_rectangle (&(GdkRectangle) { 0, 0, gdk_surface_get_width (priv->surface), gdk_surface_get_height (priv->surface) }); } else { clip = cairo_region_copy (region); gsk_render_node_diff (priv->prev_node, root, clip); if (cairo_region_is_empty (clip)) { cairo_region_destroy (clip); return; } } priv->root_node = gsk_render_node_ref (root); GSK_RENDERER_GET_CLASS (renderer)->render (renderer, root, clip); #ifdef G_ENABLE_DEBUG if (GSK_RENDERER_DEBUG_CHECK (renderer, RENDERER)) { GString *buf = g_string_new ("*** Frame stats ***\n\n"); gsk_profiler_append_counters (priv->profiler, buf); g_string_append_c (buf, '\n'); gsk_profiler_append_timers (priv->profiler, buf); g_string_append_c (buf, '\n'); g_print ("%s\n***\n\n", buf->str); g_string_free (buf, TRUE); } #endif g_clear_pointer (&priv->prev_node, gsk_render_node_unref); cairo_region_destroy (clip); priv->prev_node = priv->root_node; priv->root_node = NULL; }
void meta_tile_preview_show (MetaTilePreview *preview, MetaRectangle *tile_rect) { GdkWindow *window; GdkRectangle old_rect; if (gtk_widget_get_visible (preview->preview_window) && preview->tile_rect.x == tile_rect->x && preview->tile_rect.y == tile_rect->y && preview->tile_rect.width == tile_rect->width && preview->tile_rect.height == tile_rect->height) return; /* nothing to do */ gtk_widget_show (preview->preview_window); window = gtk_widget_get_window (preview->preview_window); meta_core_lower_beneath_grab_window (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), GDK_WINDOW_XID (window), gtk_get_current_event_time ()); old_rect.x = old_rect.y = 0; old_rect.width = preview->tile_rect.width; old_rect.height = preview->tile_rect.height; gdk_window_invalidate_rect (window, &old_rect, FALSE); preview->tile_rect = *tile_rect; gdk_window_move_resize (window, preview->tile_rect.x, preview->tile_rect.y, preview->tile_rect.width, preview->tile_rect.height); if (!preview->has_alpha) { cairo_region_t *outer_region, *inner_region; GdkRectangle outer_rect, inner_rect; GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 }; gdk_window_set_background_rgba (window, &black); outer_rect.x = outer_rect.y = 0; outer_rect.width = preview->tile_rect.width; outer_rect.height = preview->tile_rect.height; inner_rect.x = OUTLINE_WIDTH; inner_rect.y = OUTLINE_WIDTH; inner_rect.width = outer_rect.width - 2 * OUTLINE_WIDTH; inner_rect.height = outer_rect.height - 2 * OUTLINE_WIDTH; outer_region = cairo_region_create_rectangle (&outer_rect); inner_region = cairo_region_create_rectangle (&inner_rect); cairo_region_subtract (outer_region, inner_region); cairo_region_destroy (inner_region); gdk_window_shape_combine_region (window, outer_region, 0, 0); cairo_region_destroy (outer_region); } }
static void _draw_cursor_image (MetaCursorTracker *tracker, cairo_surface_t *surface, cairo_rectangle_int_t area) { CoglTexture *texture; int width, height; int stride; guint8 *data; cairo_surface_t *cursor_surface; cairo_region_t *screenshot_region; cairo_t *cr; int x, y; int xhot, yhot; screenshot_region = cairo_region_create_rectangle (&area); get_pointer_coords (&x, &y); if (!cairo_region_contains_point (screenshot_region, x, y)) { cairo_region_destroy (screenshot_region); return; } texture = meta_cursor_tracker_get_sprite (tracker); meta_cursor_tracker_get_hot (tracker, &xhot, &yhot); width = cogl_texture_get_width (texture); height = cogl_texture_get_height (texture); stride = 4 * width; data = g_new (guint8, stride * height); cogl_texture_get_data (texture, CLUTTER_CAIRO_FORMAT_ARGB32, stride, data); /* FIXME: cairo-gl? */ cursor_surface = cairo_image_surface_create_for_data (data, CAIRO_FORMAT_ARGB32, width, height, stride); cr = cairo_create (surface); cairo_set_source_surface (cr, cursor_surface, x - xhot - area.x, y - yhot - area.y); cairo_paint (cr); cairo_destroy (cr); cairo_surface_destroy (cursor_surface); cairo_region_destroy (screenshot_region); g_free (data); }
static void finalize(GObject *base) { struct Private *priv = GET_PRIVATE(base); if (priv->expose) { cairo_region_destroy(priv->expose); } if (priv->area) { cairo_region_destroy(priv->area); } if (priv->surface) { cairo_surface_destroy(priv->surface); } G_OBJECT_CLASS(joy_gfx3d_window_parent_class)->finalize(base); }
static void update_shape_region (cairo_surface_t *surface, WindowData *windata) { if (windata->width == windata->last_width && windata->height == windata->last_height) { return; } if (windata->width == 0 || windata->height == 0) { GtkAllocation allocation; gtk_widget_get_allocation (windata->win, &allocation); windata->width = MAX (allocation.width, 1); windata->height = MAX (allocation.height, 1); } if (!windata->composited) { cairo_region_t *region; region = gdk_cairo_region_create_from_surface (surface); gtk_widget_shape_combine_region (windata->win, region); cairo_region_destroy (region); } else { gtk_widget_shape_combine_region (windata->win, NULL); return; } windata->last_width = windata->width; windata->last_height = windata->height; }
static void cheese_flash_init (CheeseFlash *self) { CheeseFlashPrivate *priv = CHEESE_FLASH_GET_PRIVATE (self); cairo_region_t *input_region; GtkWindow *window; GdkScreen *screen; priv->flash_timeout_tag = 0; priv->fade_timeout_tag = 0; window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP)); /* make it so it doesn't look like a window on the desktop (+fullscreen) */ gtk_window_set_decorated (window, FALSE); gtk_window_set_skip_taskbar_hint (window, TRUE); gtk_window_set_skip_pager_hint (window, TRUE); gtk_window_set_keep_above (window, TRUE); gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_NOTIFICATION); /* Don't take focus */ gtk_window_set_accept_focus (window, FALSE); gtk_window_set_focus_on_map (window, FALSE); /* Don't consume input */ gtk_widget_realize (GTK_WIDGET (window)); input_region = cairo_region_create (); gdk_window_input_shape_combine_region (gtk_widget_get_window (GTK_WIDGET (window)), input_region, 0, 0); cairo_region_destroy (input_region); g_signal_connect (G_OBJECT (window), "draw", G_CALLBACK (cheese_flash_window_draw_event_cb), NULL); priv->window = window; }
static cairo_int_status_t _cairo_gl_composite_setup_clipping (cairo_gl_composite_t *setup, cairo_gl_context_t *ctx, int vertex_size) { if (! _cairo_gl_context_is_flushed (ctx) && (! cairo_region_equal (ctx->clip_region, setup->clip_region) || ! _cairo_clip_equal (ctx->clip, setup->clip))) _cairo_gl_composite_flush (ctx); cairo_region_destroy (ctx->clip_region); ctx->clip_region = cairo_region_reference (setup->clip_region); _cairo_clip_destroy (ctx->clip); ctx->clip = _cairo_clip_copy (setup->clip); assert (!setup->clip_region || !setup->clip); if (ctx->clip_region) { _disable_stencil_buffer (); glEnable (GL_SCISSOR_TEST); return CAIRO_INT_STATUS_SUCCESS; } if (ctx->clip) return _cairo_gl_composite_setup_painted_clipping (setup, ctx, vertex_size); _disable_stencil_buffer (); glDisable (GL_SCISSOR_TEST); return CAIRO_INT_STATUS_SUCCESS; }
static cairo_status_t _gl_flush (void *device) { cairo_gl_context_t *ctx; cairo_status_t status; status = _cairo_gl_context_acquire (device, &ctx); if (unlikely (status)) return status; _cairo_gl_composite_flush (ctx); _cairo_gl_context_destroy_operand (ctx, CAIRO_GL_TEX_SOURCE); _cairo_gl_context_destroy_operand (ctx, CAIRO_GL_TEX_MASK); if (ctx->clip_region) { cairo_region_destroy (ctx->clip_region); ctx->clip_region = NULL; } ctx->current_target = NULL; ctx->current_operator = -1; ctx->vertex_size = 0; ctx->pre_shader = NULL; _cairo_gl_set_shader (ctx, NULL); ctx->dispatch.BindBuffer (GL_ARRAY_BUFFER, 0); glDisable (GL_SCISSOR_TEST); glDisable (GL_BLEND); return _cairo_gl_context_release (ctx, status); }
static gboolean on_draw(GtkWidget *widget, gpointer data) { cairo_t *cr; GtkAllocation alloc; gtk_widget_get_allocation(widget, &alloc); gint width = alloc.width; gint height = alloc.height; gint r = 5; cr = gdk_cairo_create(gtk_widget_get_window(widget)); cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t *cr2 = cairo_create(surface); draw_round_rectangle(cr2, 0, 0, width, height, r); cairo_stroke_preserve(cr2); cairo_fill(cr2) ; cairo_destroy(cr2); cairo_region_t *region = gdk_cairo_region_create_from_surface(surface); gtk_widget_shape_combine_region(widget, region); cairo_set_line_width(cr, 0.3); cairo_set_source_rgb(cr, 0.78, 0.78, 0.78); draw_round_rectangle(cr, 0, 0, width, height, r); cairo_stroke(cr); cairo_region_destroy(region); cairo_surface_destroy(surface); cairo_destroy(cr); }
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 void _gl_destroy (void *device) { cairo_gl_context_t *ctx = device; ctx->acquire (ctx); while (! cairo_list_is_empty (&ctx->fonts)) { cairo_gl_font_t *font; font = cairo_list_first_entry (&ctx->fonts, cairo_gl_font_t, link); cairo_list_del (&font->base.link); cairo_list_del (&font->link); free (font); } _cairo_array_fini (&ctx->tristrip_indices); cairo_region_destroy (ctx->clip_region); _cairo_clip_destroy (ctx->clip); free (ctx->vb); ctx->destroy (ctx); free (ctx); }
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); }
void _gtk_pixel_cache_free (GtkPixelCache *cache) { if (cache == NULL) return; if (cache->timeout_tag || cache->surface || cache->surface_dirty) { g_warning ("pixel cache freed that wasn't unmapped: tag %u surface %p dirty %p", cache->timeout_tag, cache->surface, cache->surface_dirty); } if (cache->timeout_tag) g_source_remove (cache->timeout_tag); if (cache->surface != NULL) cairo_surface_destroy (cache->surface); if (cache->surface_dirty != NULL) cairo_region_destroy (cache->surface_dirty); g_free (cache); }
static void draw_background (MateBGCrossfade *fade) { if (fade->priv->widget != NULL) { gtk_widget_queue_draw (fade->priv->widget); } else if (gdk_window_get_window_type (fade->priv->window) != GDK_WINDOW_ROOT) { cairo_t *cr; cairo_region_t *region; GdkDrawingContext *draw_context; region = gdk_window_get_visible_region (fade->priv->window); draw_context = gdk_window_begin_draw_frame (fade->priv->window, region); cr = gdk_drawing_context_get_cairo_context (draw_context); cairo_set_operator (cr, CAIRO_OPERATOR_OVER); cairo_set_source_surface (cr, fade->priv->fading_surface, 0, 0); cairo_paint (cr); gdk_window_end_draw_frame (fade->priv->window, draw_context); cairo_region_destroy (region); } else { Display *xdisplay = GDK_WINDOW_XDISPLAY (fade->priv->window); GdkDisplay *display; display = gdk_display_get_default (); gdk_x11_display_error_trap_push (display); XGrabServer (xdisplay); XClearWindow (xdisplay, GDK_WINDOW_XID (fade->priv->window)); send_root_property_change_notification (fade); XFlush (xdisplay); XUngrabServer (xdisplay); gdk_x11_display_error_trap_pop_ignored (display); } }
cairo_region_t * meta_region_builder_finish (MetaRegionBuilder *builder) { cairo_region_t *result = NULL; int i; for (i = 0; i < builder->n_levels; i++) { if (builder->levels[i]) { if (result == NULL) result = builder->levels[i]; else { cairo_region_union(result, builder->levels[i]); cairo_region_destroy (builder->levels[i]); } } } if (result == NULL) result = cairo_region_create (); return result; }
/** * meta_background_actor_set_visible_region: * @self: a #MetaBackgroundActor * @visible_region: (allow-none): the area of the actor (in allocate-relative * coordinates) that is visible. * * Sets the area of the background that is unobscured by overlapping windows. * This is used to optimize and only paint the visible portions. */ void meta_background_actor_set_visible_region (MetaBackgroundActor *self, cairo_region_t *visible_region) { MetaBackgroundActorPrivate *priv; g_return_if_fail (META_IS_BACKGROUND_ACTOR (self)); priv = self->priv; if (priv->visible_region) { cairo_region_destroy (priv->visible_region); priv->visible_region = NULL; } if (visible_region) { cairo_rectangle_int_t screen_rect = { 0 }; meta_screen_get_size (priv->background->screen, &screen_rect.width, &screen_rect.height); /* Doing the intersection here is probably unnecessary - MetaWindowGroup * should never compute a visible area that's larger than the root screen! * but it's not that expensive and adds some extra robustness. */ priv->visible_region = cairo_region_create_rectangle (&screen_rect); cairo_region_intersect (priv->visible_region, visible_region); } }
static void pgd_selections_update_selected_text (PgdSelectionsDemo *demo) { GList *region; gchar *text; if (demo->selected_region) cairo_region_destroy (demo->selected_region); demo->selected_region = poppler_page_get_selected_region (demo->page, 1.0, demo->style, &demo->doc_area); if (demo->selected_text) g_free (demo->selected_text); demo->selected_text = NULL; text = poppler_page_get_selected_text (demo->page, demo->style, &demo->doc_area); if (text) { demo->selected_text = g_utf8_normalize (text, -1, G_NORMALIZE_NFKC); g_free (text); gtk_widget_set_sensitive(demo->copy_button, TRUE); } }
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 void dnd_hints_realized_cb(GtkWidget *window, GtkWidget *pix) { GdkPixbuf *pixbuf; cairo_surface_t *surface; cairo_region_t *region; cairo_t *cr; pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(pix)); surface = cairo_image_surface_create(CAIRO_FORMAT_A1, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf)); cr = cairo_create(surface); gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0); cairo_paint(cr); cairo_destroy(cr); region = gdk_cairo_region_create_from_surface(surface); gtk_widget_shape_combine_region(window, region); cairo_region_destroy(region); cairo_surface_destroy(surface); }
static void move_locate_pointer_window (GsdLocatePointerData *data, GdkScreen *screen) { cairo_region_t *region; gint cursor_x, cursor_y; // // gdk_window_get_pointer (gdk_screen_get_root_window (screen), // &cursor_x, &cursor_y, NULL); // use gdk_device_get_position instead of gdk_window_get_device_position // 'coz we use root window here. GdkDisplay *display; GdkDeviceManager * device_manager; GdkDevice* pointer_device; display = gdk_window_get_display (data->window); device_manager = gdk_display_get_device_manager (display); pointer_device = gdk_device_manager_get_client_pointer (device_manager); gdk_device_get_position (pointer_device, NULL, &cursor_x, &cursor_y); // gdk_window_move_resize (data->window, cursor_x - WINDOW_SIZE / 2, cursor_y - WINDOW_SIZE / 2, WINDOW_SIZE, WINDOW_SIZE); /* allow events to happen through the window */ region = cairo_region_create (); gdk_window_input_shape_combine_region (data->window, region, 0, 0); cairo_region_destroy (region); }
static cairo_region_t * byzanz_layer_cursor_snapshot (ByzanzLayer *layer) { ByzanzLayerCursor *clayer = BYZANZ_LAYER_CURSOR (layer); cairo_region_t *region, *area; int x, y; GdkDevice *device; GdkDeviceManager *device_manager; GdkDisplay *display; GdkWindow *window; window = layer->recorder->window; display = gdk_window_get_display (window); device_manager = gdk_display_get_device_manager (display); device = gdk_device_manager_get_client_pointer (device_manager); gdk_window_get_device_position (window, device, &x, &y, NULL); if (x == clayer->cursor_x && y == clayer->cursor_y && clayer->cursor_next == clayer->cursor) return NULL; region = cairo_region_create (); byzanz_recorder_invalidate_cursor (region, clayer->cursor, clayer->cursor_x, clayer->cursor_y); byzanz_recorder_invalidate_cursor (region, clayer->cursor_next, x, y); area = cairo_region_create_rectangle (&layer->recorder->area); cairo_region_intersect (region, area); cairo_region_destroy (area); clayer->cursor = clayer->cursor_next; clayer->cursor_x = x; clayer->cursor_y = y; byzanz_layer_cursor_setup_poll (clayer); return region; }
static void msd_osd_window_real_realize (GtkWidget *widget) { GdkScreen *screen; GdkVisual *visual; cairo_region_t *region; screen = gtk_widget_get_screen (widget); visual = gdk_screen_get_rgba_visual (screen); if (visual == NULL) { visual = gdk_screen_get_system_visual (screen); } gtk_widget_set_visual (widget, visual); if (GTK_WIDGET_CLASS (msd_osd_window_parent_class)->realize) { GTK_WIDGET_CLASS (msd_osd_window_parent_class)->realize (widget); } /* make the whole window ignore events */ region = cairo_region_create (); gtk_widget_input_shape_combine_region (widget, region); cairo_region_destroy (region); }
void _clutter_stage_wayland_redraw (ClutterStageWayland *stage_wayland, ClutterStage *stage) { stage_wayland->allocation = stage_wayland->pending_allocation; if (!stage_wayland->back_buffer) stage_wayland->back_buffer = wayland_create_buffer (&stage_wayland->allocation); cogl_set_framebuffer (stage_wayland->back_buffer->offscreen); _clutter_stage_maybe_setup_viewport (stage_wayland->wrapper); _clutter_stage_wayland_repair_dirty (stage_wayland, stage); _clutter_stage_wayland_repaint_region (stage_wayland, stage); cogl_flush (); glFlush (); wayland_swap_buffers (stage_wayland); if (stage_wayland->back_buffer) stage_wayland->back_buffer->dirty_region = stage_wayland->repaint_region; else cairo_region_destroy (stage_wayland->repaint_region); stage_wayland->repaint_region = NULL; cogl_set_framebuffer (stage_wayland->pick_buffer->offscreen); _clutter_stage_maybe_setup_viewport (stage_wayland->wrapper); }
static void cheese_flash_init (CheeseFlash *self) { CheeseFlashPrivate *priv = self->priv = CHEESE_FLASH_GET_PRIVATE (self); cairo_region_t *input_region; GtkWindow *window = GTK_WINDOW (self); const GdkRGBA white = { 1.0, 1.0, 1.0, 1.0 }; priv->flash_timeout_tag = 0; priv->fade_timeout_tag = 0; /* make it so it doesn't look like a window on the desktop (+fullscreen) */ gtk_window_set_decorated (window, FALSE); gtk_window_set_skip_taskbar_hint (window, TRUE); gtk_window_set_skip_pager_hint (window, TRUE); gtk_window_set_keep_above (window, TRUE); /* Don't take focus */ gtk_window_set_accept_focus (window, FALSE); gtk_window_set_focus_on_map (window, FALSE); /* Make it white */ gtk_widget_override_background_color (GTK_WIDGET (window), GTK_STATE_NORMAL, &white); /* Don't consume input */ gtk_widget_realize (GTK_WIDGET (window)); input_region = cairo_region_create (); gdk_window_input_shape_combine_region (gtk_widget_get_window (GTK_WIDGET (window)), input_region, 0, 0); cairo_region_destroy (input_region); }
void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect) { GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(m_webView)); if (!window) return; m_pendingScrollInvalidations = true; // We cannot use gdk_window_scroll here because it is only able to // scroll the whole window at once, and we often need to scroll // portions of the window only (think frames). GdkRectangle area = clipRect; GdkRectangle moveRect; GdkRectangle sourceRect = area; sourceRect.x -= delta.width(); sourceRect.y -= delta.height(); #ifdef GTK_API_VERSION_2 GdkRegion* invalidRegion = gdk_region_rectangle(&area); if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) { GdkRegion* moveRegion = gdk_region_rectangle(&moveRect); gdk_window_move_region(window, moveRegion, delta.width(), delta.height()); gdk_region_offset(moveRegion, delta.width(), delta.height()); gdk_region_subtract(invalidRegion, moveRegion); gdk_region_destroy(moveRegion); } gdk_window_invalidate_region(window, invalidRegion, FALSE); gdk_region_destroy(invalidRegion); #else cairo_region_t* invalidRegion = cairo_region_create_rectangle(&area); if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) { cairo_region_t* moveRegion = cairo_region_create_rectangle(&moveRect); gdk_window_move_region(window, moveRegion, delta.width(), delta.height()); cairo_region_translate(moveRegion, delta.width(), delta.height()); cairo_region_subtract(invalidRegion, moveRegion); cairo_region_destroy(moveRegion); } gdk_window_invalidate_region(window, invalidRegion, FALSE); cairo_region_destroy(invalidRegion); #endif }