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
}
