static cairo_surface_t *
cairo_surface_create(JoyBubble *self)
{
struct Private *priv = GET_PRIVATE(self);
if (G_LIKELY(priv->surface)) {
return cairo_surface_reference(priv->surface);
}
cairo_rectangle_int_t rect = {
0, 0,
joy_bubble_get_width(self),
joy_bubble_get_height(self)
};
cairo_region_union_rectangle(priv->area, &rect);
// create a GFX3D native surface
JoyScreen *screen = joy_bubble_get_screen(self);
GFX3D_Display display = joy_gfx3d_screen_get_display(screen);
priv->image = GFX3D_Image_Create_Generic(display, rect.width,
rect.height);
if (G_UNLIKELY(!priv->image)) {
goto error;
}
// create a cairo surface
priv->surface = joy_gfx3d_screen_cairo_surface_create(screen,
priv->image);
if (G_UNLIKELY(!priv->surface)) {
goto error;
}
return cairo_surface_reference(priv->surface);
error:
if (priv->image) {
GFX3D_Image_Destroy(display, priv->image);
priv->image = NULL;
}
return NULL;
}
static void
clutter_stage_wayland_add_redraw_clip (ClutterStageWindow *stage_window,
ClutterGeometry *stage_clip)
{
ClutterStageWayland *stage_wayland = CLUTTER_STAGE_WAYLAND (stage_window);
cairo_rectangle_int_t rect;
if (stage_clip == NULL)
{
rect.x = stage_wayland->allocation.x;
rect.y = stage_wayland->allocation.y;
rect.width = stage_wayland->allocation.width;
rect.height = stage_wayland->allocation.height;
}
else
{
rect.x = stage_clip->x;
rect.y = stage_clip->y;
rect.width = stage_clip->width;
rect.height = stage_clip->height;
}
if (stage_wayland->repaint_region == NULL)
stage_wayland->repaint_region = cairo_region_create_rectangle (&rect);
else
cairo_region_union_rectangle (stage_wayland->repaint_region, &rect);
}
void
meta_surface_actor_process_damage (MetaSurfaceActor *self,
int x, int y, int width, int height)
{
MetaSurfaceActorPrivate *priv = self->priv;
if (is_frozen (self))
{
/* The window is frozen due to an effect in progress: we ignore damage
* here on the off chance that this will stop the corresponding
* texture_from_pixmap from being update.
*
* pending_damage tracks any damage that happened while the window was
* frozen so that when can apply it when the window becomes unfrozen.
*
* It should be noted that this is an unreliable mechanism since it's
* quite likely that drivers will aim to provide a zero-copy
* implementation of the texture_from_pixmap extension and in those cases
* any drawing done to the window is always immediately reflected in the
* texture regardless of damage event handling.
*/
cairo_rectangle_int_t rect = { .x = x, .y = y, .width = width, .height = height };
if (!priv->pending_damage)
priv->pending_damage = cairo_region_create_rectangle (&rect);
else
cairo_region_union_rectangle (priv->pending_damage, &rect);
return;
}
META_SURFACE_ACTOR_GET_CLASS (self)->process_damage (self, x, y, width, height);
if (meta_surface_actor_is_visible (self))
meta_surface_actor_update_area (self, x, y, width, height);
}
bool wxRegion::DoUnionWithRect(const wxRect& r)
{
// workaround for a strange GTK/X11 bug: taking union with an empty
// rectangle results in an empty region which is definitely not what we
// want
if ( r.IsEmpty() )
return true;
if ( !m_refData )
{
InitRect(r.x, r.y, r.width, r.height);
}
else
{
AllocExclusive();
GdkRectangle rect;
rect.x = r.x;
rect.y = r.y;
rect.width = r.width;
rect.height = r.height;
#ifdef __WXGTK3__
cairo_region_union_rectangle(M_REGIONDATA->m_region, &rect);
#else
gdk_region_union_with_rect( M_REGIONDATA->m_region, &rect );
#endif
}
return true;
}
void
gimp_tile_handler_projection_invalidate (GimpTileHandlerProjection *projection,
gint x,
gint y,
gint width,
gint height)
{
cairo_rectangle_int_t rect = { x, y, width, height };
gint tile_x1;
gint tile_y1;
gint tile_x2;
gint tile_y2;
gint tile_x;
gint tile_y;
g_return_if_fail (GIMP_IS_TILE_HANDLER_PROJECTION (projection));
cairo_region_union_rectangle (projection->dirty_region, &rect);
tile_x1 = x / projection->tile_width;
tile_y1 = y / projection->tile_height;
tile_x2 = (x + width - 1) / projection->tile_width;
tile_y2 = (y + height - 1) / projection->tile_height;
for (tile_y = tile_y1; tile_y <= tile_y2; tile_y++)
{
for (tile_x = tile_x1; tile_x <= tile_x2; tile_x++)
{
gimp_tile_handler_projection_void_pyramid (GEGL_TILE_SOURCE (projection),
tile_x / 2, tile_y / 2, 1);
}
}
}
// cairo_public cairo_status_t
// cairo_region_union_rectangle (cairo_region_t *dst,
// const cairo_rectangle_int_t *rectangle);
static int l_cairo_region_union_rectangle (lua_State* L)
{
cairo_region_t *dst = get_cairo_region_t (L, 1);
const cairo_rectangle_int_t *rectangle = get_cairo_rectangle_int_t (L, 2);
cairo_status_t v = cairo_region_union_rectangle (dst, rectangle);
lua_pushinteger(L, v);
return 1;
}
/* Get a clip region to draw only part of a layout. index_ranges
* contains alternating range starts/stops. The region is the
* region which contains the given ranges, i.e. if you draw with the
* region as clip, only the given ranges are drawn.
*/
static cairo_region_t*
layout_iter_get_line_clip_region (PangoLayoutIter *iter,
gint x_origin,
gint y_origin,
const gint *index_ranges,
gint n_ranges)
{
PangoLayoutLine *line;
cairo_region_t *clip_region;
PangoRectangle logical_rect;
gint baseline;
gint i;
line = pango_layout_iter_get_line_readonly (iter);
clip_region = cairo_region_create ();
pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
baseline = pango_layout_iter_get_baseline (iter);
i = 0;
while (i < n_ranges)
{
gint *pixel_ranges = NULL;
gint n_pixel_ranges = 0;
gint j;
/* Note that get_x_ranges returns layout coordinates
*/
if (index_ranges[i*2+1] >= line->start_index &&
index_ranges[i*2] < line->start_index + line->length)
pango_layout_line_get_x_ranges (line,
index_ranges[i*2],
index_ranges[i*2+1],
&pixel_ranges, &n_pixel_ranges);
for (j = 0; j < n_pixel_ranges; j++)
{
GdkRectangle rect;
int x_off, y_off;
x_off = PANGO_PIXELS (pixel_ranges[2*j] - logical_rect.x);
y_off = PANGO_PIXELS (baseline - logical_rect.y);
rect.x = x_origin + x_off;
rect.y = y_origin - y_off;
rect.width = PANGO_PIXELS (pixel_ranges[2*j + 1] - logical_rect.x) - x_off;
rect.height = PANGO_PIXELS (baseline - logical_rect.y + logical_rect.height) - y_off;
cairo_region_union_rectangle (clip_region, &rect);
}
g_free (pixel_ranges);
++i;
}
return clip_region;
}
static void
expose(JoyBubble *self, const cairo_rectangle_int_t *rect)
{
struct Private *priv = GET_PRIVATE(self);
if (0 < rect->width && 0 < rect->height) {
cairo_region_union_rectangle(priv->expose, rect);
}
JOY_BUBBLE_CLASS(joy_gfx3d_window_parent_class)->expose(self, rect);
}
/**
* \brief Expose handler for windows on this screen.
*
* The screen aggregates all exposed areas so that they can be cleared prior
* to the next draw.
*
* \param window [in] A window object.
* \param rect [in] The exposed area of \e window.
* \param self [in] The screen \e window is on.
*/
static void
on_expose(JoyBubble *window, const cairo_rectangle_int_t *rect,
JoyScreen *self)
{
cairo_rectangle_int_t expose = {
rect->x + joy_bubble_get_x(window),
rect->y + joy_bubble_get_y(window),
rect->width,
rect->height
};
cairo_region_union_rectangle(GET_PRIVATE(self)->expose, &expose);
}
static void
wl_region_add (struct wl_client *client,
struct wl_resource *resource,
gint32 x,
gint32 y,
gint32 width,
gint32 height)
{
MetaWaylandRegion *region = wl_resource_get_user_data (resource);
cairo_rectangle_int_t rectangle = { x, y, width, height };
cairo_region_union_rectangle (region->region, &rectangle);
}
static void
byzanz_recorder_invalidate_cursor (cairo_region_t *region, XFixesCursorImage *cursor, int x, int y)
{
cairo_rectangle_int_t cursor_rect;
if (cursor == NULL)
return;
cursor_rect.x = x - cursor->xhot;
cursor_rect.y = y - cursor->yhot;
cursor_rect.width = cursor->width;
cursor_rect.height = cursor->height;
cairo_region_union_rectangle (region, &cursor_rect);
}
cairo_region_t* get_window_input_region(Display* dpy, Window w)
{
int count = 0;
int ordering = 0;
XRectangle *rects = XShapeGetRectangles(dpy, w, ShapeInput, &count,
&ordering);
cairo_region_t* reg = cairo_region_create();
for (int i=0; i<count; i++) {
cairo_rectangle_int_t rect = {rects[i].x, rects[i].y,
rects[i].width, rects[i].height};
cairo_region_union_rectangle(reg, &rect);
}
XFree(rects);
return reg;
}
cairo_region_t *make_region(struct Rgn *rgn){
int i;
cairo_region_t *ret = NULL;
if(rgn && rgn->num >= 0){
ret = cairo_region_create();
for(i = 0; i < rgn->num; i++){
rgn->rects[i].width -= rgn->rects[i].x;
rgn->rects[i].height -= rgn->rects[i].y;
cairo_region_union_rectangle(ret, &rgn->rects[i]);
}
}
return ret;
}
static void
constructed(GObject *base)
{
JoyScreen *self = JOY_SCREEN(base);
struct Private *priv = GET_PRIVATE(base);
gint width = joy_screen_get_width(self);
gint height = joy_screen_get_height(self);
// create the display
priv->display = GFX3D_Display_Create(width, height, width, height,
8, joy_screen_get_id(self));
if (G_UNLIKELY(!priv->display)) {
goto exit;
}
// disable automatic cache flushing
GFX3D_Display_Cache_AutoFlush_Set(priv->display, 0);
// update the screen asynchronously
GFX3D_Display_Show_Mode_Set(priv->display,
//GFX3D_DISPLAY_SHOW_MODE_SYNCHRONOUS);
GFX3D_DISPLAY_SHOW_MODE_ASYNCHRONOUS);
//GFX3D_DISPLAY_SHOW_MODE_VSYNC_WAIT_ONLY);
// clear the display
GFX3D_Rect rect = { 0, 0, width, height };
GFX3D_Display_ClearAlpha2D(priv->display, NULL, &rect, 0., 0., 0., 0.);
// show the display
GFX3D_Display_Visibility_Set(priv->display, 1);
// set the display location
GFX3D_Display_Location_Set(priv->display, 0, 0, 0);
// setup the screen area
cairo_region_union_rectangle(priv->area, (gpointer)&rect);
priv->x = (gdouble)width / 2.;
priv->y = (gdouble)height / 2.;
// setup devices
priv->keyboard = joy_gfx3d_keyboard_new(self);
priv->mouse = joy_gfx3d_mouse_new(self);
joy_device_keyboard_set_mouse(priv->keyboard, priv->mouse);
joy_device_mouse_set_keyboard(priv->mouse, priv->keyboard);
// create the cursor
cursor_init(self);
exit:
if (G_OBJECT_CLASS(joy_gfx3d_screen_parent_class)->constructed) {
G_OBJECT_CLASS(joy_gfx3d_screen_parent_class)->
constructed(base);
}
}
void
meta_region_builder_add_rectangle (MetaRegionBuilder *builder,
int x,
int y,
int width,
int height)
{
cairo_rectangle_int_t rect;
int i;
if (builder->levels[0] == NULL)
builder->levels[0] = cairo_region_create ();
rect.x = x;
rect.y = y;
rect.width = width;
rect.height = height;
cairo_region_union_rectangle (builder->levels[0], &rect);
if (cairo_region_num_rectangles (builder->levels[0]) >= MAX_CHUNK_RECTANGLES)
{
for (i = 1; i < builder->n_levels + 1; i++)
{
if (builder->levels[i] == NULL)
{
if (i < META_REGION_BUILDER_MAX_LEVELS)
{
builder->levels[i] = builder->levels[i - 1];
builder->levels[i - 1] = NULL;
if (i == builder->n_levels)
builder->n_levels++;
}
break;
}
else
{
cairo_region_union (builder->levels[i], builder->levels[i - 1]);
cairo_region_destroy (builder->levels[i - 1]);
builder->levels[i - 1] = NULL;
}
}
}
}
static void
clutter_stage_wayland_resize (ClutterStageWindow *stage_window,
gint width,
gint height)
{
ClutterStageWayland *stage_wayland = CLUTTER_STAGE_WAYLAND (stage_window);
cairo_rectangle_int_t rect;
fprintf (stderr, "resize %dx%d\n", width, height);
stage_wayland->pending_allocation.width = width;
stage_wayland->pending_allocation.height = height;
/* FIXME: Shouldn't the stage repaint everything when it gets resized? */
rect.x = stage_wayland->pending_allocation.x;
rect.y = stage_wayland->pending_allocation.y;
rect.width = stage_wayland->pending_allocation.width;
rect.height = stage_wayland->pending_allocation.height;
cairo_region_union_rectangle (stage_wayland->repaint_region, &rect);
}
static cairo_region_t *
make_region_with_monitors (GdkScreen *screen)
{
cairo_region_t *region;
int num_monitors;
int i;
num_monitors = gdk_screen_get_n_monitors (screen);
region = cairo_region_create ();
for (i = 0; i < num_monitors; i++)
{
GdkRectangle rect;
gdk_screen_get_monitor_geometry (screen, i, &rect);
cairo_region_union_rectangle (region, &rect);
}
return region;
}
void
Region::Union (Rect rect)
{
cairo_rectangle_int_t cairo_rect = rect.ToCairoRectangleInt ();
cairo_region_union_rectangle (cairo_region, &cairo_rect);
}
void GraphicsContext::drawFocusRing(const Vector<IntRect>& rects, int width, int /* offset */, const Color& color)
{
if (paintingDisabled())
return;
unsigned rectCount = rects.size();
cairo_t* cr = platformContext()->cr();
cairo_save(cr);
cairo_push_group(cr);
cairo_new_path(cr);
#if PLATFORM(GTK)
#ifdef GTK_API_VERSION_2
GdkRegion* reg = gdk_region_new();
#else
cairo_region_t* reg = cairo_region_create();
#endif
for (unsigned i = 0; i < rectCount; i++) {
#ifdef GTK_API_VERSION_2
GdkRectangle rect = rects[i];
gdk_region_union_with_rect(reg, &rect);
#else
cairo_rectangle_int_t rect = rects[i];
cairo_region_union_rectangle(reg, &rect);
#endif
}
gdk_cairo_region(cr, reg);
#ifdef GTK_API_VERSION_2
gdk_region_destroy(reg);
#else
cairo_region_destroy(reg);
#endif
#else
int radius = (width - 1) / 2;
Path path;
for (unsigned i = 0; i < rectCount; ++i) {
if (i > 0)
path.clear();
path.addRoundedRect(rects[i], FloatSize(radius, radius));
appendWebCorePathToCairoContext(cr, path);
}
#endif
Color ringColor = color;
adjustFocusRingColor(ringColor);
adjustFocusRingLineWidth(width);
setSourceRGBAFromColor(cr, ringColor);
cairo_set_line_width(cr, width);
setPlatformStrokeStyle(focusRingStrokeStyle());
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);
}
/* We double buffer the image. It looks nice and it enables
* grabbing the graph with the pointer and translating it.
* We draw on our own larger surface and then copy part of that
* to the gdk surface.
*
* We assume that this function is drawing to an exposed/showing
* drawing area, so the status update will reflect the current
* exposed/showing drawing area. */
void qp_graph_draw(struct qp_graph *gr, cairo_t *gdk_cr)
{
GtkAllocation allocation;
if(gr->waiting_to_resize_draw && !gr->qp->shape)
{
//WARN("gr=%p gr->name=\"%s\" gr->ref_count=%d\n", gr, gr->name, gr->ref_count);
cairo_set_source_rgba(gdk_cr, gr->background_color.r,
gr->background_color.g, gr->background_color.b,
gr->background_color.a);
cairo_paint(gdk_cr);
g_idle_add_full(G_PRIORITY_LOW, idle_callback, gr, NULL);
/* fight qp_graph_destroy() race condition with flag */
++gr->ref_count;
/* We draw after the other widgets are drawn, in case drawing
* takes a long time. This waiting also gives a chance
* for the watch cursor to show. But that seems to only
* show if the window had focus at the right time. */
return;
}
gtk_widget_get_allocation(gr->drawing_area, &allocation);
if(gr->pixbuf_needs_draw)
{
cairo_t *db_cr; /* double buffer cr */
db_cr = cairo_create(gr->pixbuf_surface);
graph_draw(gr, db_cr, gr->pixbuf_x, gr->pixbuf_y,
gr->pixbuf_width, gr->pixbuf_height);
cairo_destroy(db_cr);
// debuging
//cairo_surface_write_to_png(gr->pixbuf_surface, "x.png");
qp_win_set_status(gr->qp);
}
/* the GTK cairo_t *gdk_cr has no alpha bits so all the
* alpha drawn to it will be smushed. */
//WARN("content=0x%lx\n", (unsigned long)cairo_get_target(gdk_cr));
if(!gr->qp->shape)
{
/* Not using the shape X11 extension */
/* This is where we go from the back buffer to the drawing area */
draw_from_pixbuf(gdk_cr, gr, allocation.width, allocation.height);
if(gr->draw_zoom_box == 1)
draw_zoom_box(gdk_cr, gr);
if(gr->draw_value_pick)
draw_value_pick_line(gdk_cr, gr, allocation.width, allocation.height);
if(gr->pixbuf_needs_draw)
{
gdk_window_set_cursor(gtk_widget_get_window(gr->qp->window), NULL);
gr->pixbuf_needs_draw = 0;
// gr->qp->wait_warning_showing = 0;
}
}
else
{
/* Use the X11 shape extension */
/* TODO: This is a resource pig. Fix it. */
cairo_region_t *reg_draw_area, *window_region;
/* empty flag */
int empty;
cairo_surface_t *mask_surface;
GtkAllocation all;
/* Make sure the surface is up to date */
//cairo_surface_flush(gr->pixbuf_surface);
/* make a sub surface that is the size of the graph drawing area */
mask_surface = cairo_surface_create_for_rectangle(gr->pixbuf_surface,
INT(gr->pixbuf_x+gr->grab_x),
INT(gr->pixbuf_y+gr->grab_y),
allocation.width, allocation.height);
reg_draw_area = get_cairo_region_create_from_surface(gr,
mask_surface, allocation.width, allocation.height);
cairo_surface_destroy(mask_surface);
cairo_region_translate(reg_draw_area, allocation.x, allocation.y);
gtk_widget_get_allocation(gr->qp->window, &all);
all.x = all.y = 0;
window_region = cairo_region_create_rectangle(&all);
cairo_region_subtract_rectangle(window_region, &allocation);
empty = cairo_region_is_empty(reg_draw_area);
if(!empty)
cairo_region_union(window_region, reg_draw_area);
cairo_region_destroy(reg_draw_area);
/* window_region is a region with a hole in it the
* size of the drawing area with the graph and grid added back. */
if(gr->draw_zoom_box && !empty)
{
cairo_rectangle_int_t rec;
rec.x = allocation.x + gr->z_x;
rec.y = allocation.y + gr->z_y;
rec.width = gr->z_w;
rec.height = gr->z_h;
/* regions do not like negitive values or
* maybe shapes do not like negitive values
* in any case we keep width and height
* positive */
if(rec.width < 0)
{
rec.width *= -1;
rec.x -= rec.width;
}
if(rec.height < 0)
{
rec.height *= -1;
rec.y -= rec.height;
}
cairo_region_union_rectangle(window_region, &rec);
/* now we have the zoom box added to window_region */
}
/* This is where we go from the back buffer to the drawing area */
draw_from_pixbuf(gdk_cr, gr, allocation.width, allocation.height);
if(gr->draw_zoom_box)
draw_zoom_box(gdk_cr, gr);
if(gr->draw_value_pick)
draw_value_pick_line(gdk_cr, gr, allocation.width, allocation.height);
if(empty)
{
/* we have nothing to make a shape with */
if(gr->qp->last_shape_region)
{
cairo_region_destroy(gr->qp->last_shape_region);
gr->qp->last_shape_region = NULL;
}
cairo_region_destroy(window_region);
/* remove the old shape region */
gtk_widget_shape_combine_region(gr->qp->window, NULL);
}
else if(!gr->qp->last_shape_region ||
!cairo_region_equal(gr->qp->last_shape_region, window_region))
{
// DEBUG("creating new shape region\n");
/* We need to undo the old shape first */
gtk_widget_shape_combine_region(gr->qp->window, NULL);
gtk_widget_shape_combine_region(gr->qp->window, window_region);
if(gr->qp->last_shape_region)
cairo_region_destroy(gr->qp->last_shape_region);
gr->qp->last_shape_region = window_region;
}
else
cairo_region_destroy(window_region);
gr->pixbuf_needs_draw = 0;
gdk_window_set_cursor(gtk_widget_get_window(gr->qp->window), NULL);
// debuging
//cairo_surface_write_to_png(cairo_get_target(gdk_cr), "y.png");
}
if(gr->qp->update_graph_detail && gr->qp->graph_detail)
{
gr->qp->update_graph_detail = 0;
/* make the graph configure window show stuff about this graph */
qp_win_graph_detail_init(gr->qp);
}
}
static inline
cairo_region_t *
get_cairo_region_create_from_surface(struct qp_graph *gr,
cairo_surface_t *surface, int width, int height)
{
/* TODO: this is a resource pig. Make it better. */
cairo_rectangle_int_t rect;
cairo_surface_t *image;
cairo_region_t *region;
cairo_t *cr;
uint32_t *data, bg;
int x, y, stride;
if(!gr->x11)
/* Creates region that covers the area where the
* given surface is more than 50% opaque.
* The below code copies this method. This GDK
* code is a pig too. */
return gdk_cairo_region_create_from_surface(surface);
if(!gr->x11->background_set)
{
/* We need to see what the background color is when it is
* applied to an image. A small image. */
image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, 1, 1);
cr = cairo_create(image);
cairo_set_source_rgba(cr, gr->background_color.r,
gr->background_color.g, gr->background_color.b,
gr->background_color.a);
cairo_paint (cr);
cairo_destroy (cr);
data = (void *) cairo_image_surface_get_data(image);
gr->x11->background = (data[0] & 0x00FFFFFF);
cairo_surface_destroy(image);
gr->x11->background_set = 1;
}
bg = gr->x11->background;
image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
cr = cairo_create(image);
cairo_set_source_surface(cr, surface, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
data = (void *) cairo_image_surface_get_data(image);
stride = cairo_image_surface_get_stride(image);
region = cairo_region_create();
for(y=0; y < height; y++)
{
for(x=0; x < width; x++)
{
/* Search for a continuous range of "background pixels"*/
gint x0=x;
while(x < width)
{
if((data[x] & 0x00FFFFFF) == bg)
/* This pixel is the background color */
break;
x++;
}
if(x > x0)
{
/* Add the pixels (x0, y) to (x, y+1) as a new rectangle
* in the region
*/
rect.x = x0;
rect.width = x - x0;
rect.y = y;
rect.height = 1;
cairo_region_union_rectangle(region, &rect);
}
}
data += stride/4;
}
cairo_surface_destroy(image);
return region;
}
static void
grab_screenshot (ClutterActor *stage,
_screenshot_data *screenshot_data)
{
MetaScreen *screen = shell_global_get_screen (screenshot_data->screenshot->global);
MetaCursorTracker *tracker;
int width, height;
GSimpleAsyncResult *result;
GSettings *settings;
meta_screen_get_size (screen, &width, &height);
do_grab_screenshot (screenshot_data, 0, 0, width, height);
if (meta_screen_get_n_monitors (screen) > 1)
{
cairo_region_t *screen_region = cairo_region_create ();
cairo_region_t *stage_region;
MetaRectangle monitor_rect;
cairo_rectangle_int_t stage_rect;
int i;
cairo_t *cr;
for (i = meta_screen_get_n_monitors (screen) - 1; i >= 0; i--)
{
meta_screen_get_monitor_geometry (screen, i, &monitor_rect);
cairo_region_union_rectangle (screen_region, (const cairo_rectangle_int_t *) &monitor_rect);
}
stage_rect.x = 0;
stage_rect.y = 0;
stage_rect.width = width;
stage_rect.height = height;
stage_region = cairo_region_create_rectangle ((const cairo_rectangle_int_t *) &stage_rect);
cairo_region_xor (stage_region, screen_region);
cairo_region_destroy (screen_region);
cr = cairo_create (screenshot_data->image);
for (i = 0; i < cairo_region_num_rectangles (stage_region); i++)
{
cairo_rectangle_int_t rect;
cairo_region_get_rectangle (stage_region, i, &rect);
cairo_rectangle (cr, (double) rect.x, (double) rect.y, (double) rect.width, (double) rect.height);
cairo_fill (cr);
}
cairo_destroy (cr);
cairo_region_destroy (stage_region);
}
screenshot_data->screenshot_area.x = 0;
screenshot_data->screenshot_area.y = 0;
screenshot_data->screenshot_area.width = width;
screenshot_data->screenshot_area.height = height;
settings = g_settings_new (A11Y_APPS_SCHEMA);
if (screenshot_data->include_cursor &&
!g_settings_get_boolean (settings, MAGNIFIER_ACTIVE_KEY))
{
tracker = meta_cursor_tracker_get_for_screen (screen);
_draw_cursor_image (tracker, screenshot_data->image, screenshot_data->screenshot_area);
}
g_object_unref (settings);
g_signal_handlers_disconnect_by_func (stage, (void *)grab_screenshot, (gpointer)screenshot_data);
result = g_simple_async_result_new (NULL, on_screenshot_written, (gpointer)screenshot_data, grab_screenshot);
g_simple_async_result_run_in_thread (result, write_screenshot_thread, G_PRIORITY_DEFAULT, NULL);
g_object_unref (result);
}
static cairo_int_status_t
_add_operation (cairo_analysis_surface_t *surface,
cairo_rectangle_int_t *rect,
cairo_int_status_t backend_status)
{
cairo_int_status_t status;
cairo_box_t bbox;
if (rect->width == 0 || rect->height == 0) {
/* Even though the operation is not visible we must be careful
* to not allow unsupported operations to be replayed to the
* backend during CAIRO_PAGINATED_MODE_RENDER */
if (backend_status == CAIRO_INT_STATUS_SUCCESS ||
backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
backend_status == CAIRO_INT_STATUS_NOTHING_TO_DO)
{
return CAIRO_INT_STATUS_SUCCESS;
}
else
{
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
}
}
_cairo_box_from_rectangle (&bbox, rect);
if (surface->has_ctm) {
int tx, ty;
if (_cairo_matrix_is_integer_translation (&surface->ctm, &tx, &ty)) {
rect->x += tx;
rect->y += ty;
tx = _cairo_fixed_from_int (tx);
bbox.p1.x += tx;
bbox.p2.x += tx;
ty = _cairo_fixed_from_int (ty);
bbox.p1.y += ty;
bbox.p2.y += ty;
} else {
_cairo_matrix_transform_bounding_box_fixed (&surface->ctm,
&bbox, NULL);
if (bbox.p1.x == bbox.p2.x || bbox.p1.y == bbox.p2.y) {
/* Even though the operation is not visible we must be
* careful to not allow unsupported operations to be
* replayed to the backend during
* CAIRO_PAGINATED_MODE_RENDER */
if (backend_status == CAIRO_INT_STATUS_SUCCESS ||
backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
backend_status == CAIRO_INT_STATUS_NOTHING_TO_DO)
{
return CAIRO_INT_STATUS_SUCCESS;
}
else
{
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
}
}
_cairo_box_round_to_rectangle (&bbox, rect);
}
}
if (surface->first_op) {
surface->first_op = FALSE;
surface->page_bbox = bbox;
} else
_cairo_box_add_box(&surface->page_bbox, &bbox);
/* If the operation is completely enclosed within the fallback
* region there is no benefit in emitting a native operation as
* the fallback image will be painted on top.
*/
if (cairo_region_contains_rectangle (&surface->fallback_region, rect) == CAIRO_REGION_OVERLAP_IN)
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
if (backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY) {
/* A status of CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY indicates
* that the backend only supports this operation if the
* transparency removed. If the extents of this operation does
* not intersect any other native operation, the operation is
* natively supported and the backend will blend the
* transparency into the white background.
*/
if (cairo_region_contains_rectangle (&surface->supported_region, rect) == CAIRO_REGION_OVERLAP_OUT)
backend_status = CAIRO_INT_STATUS_SUCCESS;
}
if (backend_status == CAIRO_INT_STATUS_SUCCESS) {
/* Add the operation to the supported region. Operations in
* this region will be emitted as native operations.
*/
surface->has_supported = TRUE;
return cairo_region_union_rectangle (&surface->supported_region, rect);
}
/* Add the operation to the unsupported region. This region will
* be painted as an image after all native operations have been
* emitted.
*/
surface->has_unsupported = TRUE;
status = cairo_region_union_rectangle (&surface->fallback_region, rect);
/* The status CAIRO_INT_STATUS_IMAGE_FALLBACK is used to indicate
* unsupported operations to the recording surface as using
* CAIRO_INT_STATUS_UNSUPPORTED would cause cairo-surface to
* invoke the cairo-surface-fallback path then return
* CAIRO_STATUS_SUCCESS.
*/
if (status == CAIRO_INT_STATUS_SUCCESS)
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
else
return status;
}
void
gdk_wayland_window_invalidate_for_new_frame (GdkWindow *window,
cairo_region_t *update_area)
{
cairo_rectangle_int_t window_rect;
GdkDisplay *display = gdk_window_get_display (window);
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
GdkWaylandGLContext *context_wayland;
int buffer_age;
gboolean invalidate_all;
EGLSurface egl_surface;
/* Minimal update is ok if we're not drawing with gl */
if (window->gl_paint_context == NULL)
return;
context_wayland = GDK_WAYLAND_GL_CONTEXT (window->gl_paint_context);
buffer_age = 0;
egl_surface = gdk_wayland_window_get_egl_surface (window->impl_window,
context_wayland->egl_config);
if (display_wayland->have_egl_buffer_age)
{
gdk_gl_context_make_current (window->gl_paint_context);
eglQuerySurface (display_wayland->egl_display, egl_surface,
EGL_BUFFER_AGE_EXT, &buffer_age);
}
invalidate_all = FALSE;
if (buffer_age == 0 || buffer_age >= 4)
invalidate_all = TRUE;
else
{
if (buffer_age >= 2)
{
if (window->old_updated_area[0])
cairo_region_union (update_area, window->old_updated_area[0]);
else
invalidate_all = TRUE;
}
if (buffer_age >= 3)
{
if (window->old_updated_area[1])
cairo_region_union (update_area, window->old_updated_area[1]);
else
invalidate_all = TRUE;
}
}
if (invalidate_all)
{
window_rect.x = 0;
window_rect.y = 0;
window_rect.width = gdk_window_get_width (window);
window_rect.height = gdk_window_get_height (window);
/* If nothing else is known, repaint everything so that the back
* buffer is fully up-to-date for the swapbuffer
*/
cairo_region_union_rectangle (update_area, &window_rect);
}
}
/* This function originally from Jean-Edouard Lachand-Robert, and
* available at www.codeguru.com. Simplified for our needs, not sure
* how much of the original code left any longer. Now handles just
* one-bit deep bitmaps (in Window parlance, ie those that GDK calls
* bitmaps (and not pixmaps), with zero pixels being transparent.
*
* Changed again here from the GDK version to use an 8-bit surface instead
* of a 1-bit bitmap.
*/
static cairo_region_t *
_gdk_cairo_region_create_from_surface (cairo_surface_t *surface)
{
cairo_region_t *region;
GdkRectangle extents, rect;
cairo_surface_t *image;
cairo_t *cr;
gint x, y, stride;
guchar *data;
_gdk_cairo_surface_extents (surface, &extents);
if (cairo_surface_get_content (surface) == CAIRO_CONTENT_COLOR)
return cairo_region_create_rectangle (&extents);
if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_IMAGE ||
cairo_image_surface_get_format (surface) != CAIRO_FORMAT_A8)
{
/* coerce to an A8 image */
image = cairo_image_surface_create (CAIRO_FORMAT_A8,
extents.width, extents.height);
cr = cairo_create (image);
cairo_set_source_surface (cr, surface, -extents.x, -extents.y);
cairo_paint (cr);
cairo_destroy (cr);
}
else
image = cairo_surface_reference (surface);
data = cairo_image_surface_get_data (image);
stride = cairo_image_surface_get_stride (image);
region = cairo_region_create ();
for (y = 0; y < extents.height; y++)
{
for (x = 0; x < extents.width; x++)
{
/* Search for a continuous range of "non transparent pixels"*/
gint x0 = x;
while (x < extents.width)
{
guint8 alpha = data[x];
if (alpha < 24)
/* This pixel is "transparent"*/
break;
x++;
}
if (x > x0)
{
/* Add the pixels (x0, y) to (x, y+1) as a new rectangle
* in the region
*/
rect.x = x0;
rect.width = x - x0;
rect.y = y;
rect.height = 1;
cairo_region_union_rectangle (region, &rect);
}
}
data += stride;
}
cairo_surface_destroy (image);
cairo_region_translate (region, extents.x, extents.y);
return region;
}
/**
* gdk_cairo_draw_from_gl:
* @cr: a cairo context
* @window: The window we're rendering for (not necessarily into)
* @source: The GL ID of the source buffer
* @source_type: The type of the @source
* @buffer_scale: The scale-factor that the @source buffer is allocated for
* @x: The source x position in @source to start copying from in GL coordinates
* @y: The source y position in @source to start copying from in GL coordinates
* @width: The width of the region to draw
* @height: The height of the region to draw
*
* This is the main way to draw GL content in GTK+. It takes a render buffer ID
* (@source_type == #GL_RENDERBUFFER) or a texture id (@source_type == #GL_TEXTURE)
* and draws it onto @cr with an OVER operation, respecting the current clip.
* The top left corner of the rectangle specified by @x, @y, @width and @height
* will be drawn at the current (0,0) position of the cairo_t.
*
* This will work for *all* cairo_t, as long as @window is realized, but the
* fallback implementation that reads back the pixels from the buffer may be
* used in the general case. In the case of direct drawing to a window with
* no special effects applied to @cr it will however use a more efficient
* approach.
*
* For #GL_RENDERBUFFER the code will always fall back to software for buffers
* with alpha components, so make sure you use #GL_TEXTURE if using alpha.
*
* Calling this may change the current GL context.
*
* Since: 3.16
*/
void
gdk_cairo_draw_from_gl (cairo_t *cr,
GdkWindow *window,
int source,
int source_type,
int buffer_scale,
int x,
int y,
int width,
int height)
{
GdkGLContext *paint_context;
cairo_surface_t *image;
cairo_matrix_t matrix;
int dx, dy, window_scale;
gboolean trivial_transform;
cairo_surface_t *group_target;
GdkWindow *direct_window, *impl_window;
guint framebuffer;
int alpha_size = 0;
cairo_region_t *clip_region;
GdkGLContextPaintData *paint_data;
impl_window = window->impl_window;
window_scale = gdk_window_get_scale_factor (impl_window);
paint_context = gdk_window_get_paint_gl_context (window, NULL);
if (paint_context == NULL)
{
g_warning ("gdk_cairo_draw_gl_render_buffer failed - no paint context");
return;
}
clip_region = gdk_cairo_region_from_clip (cr);
gdk_gl_context_make_current (paint_context);
paint_data = gdk_gl_context_get_paint_data (paint_context);
if (paint_data->tmp_framebuffer == 0)
glGenFramebuffersEXT (1, &paint_data->tmp_framebuffer);
if (source_type == GL_RENDERBUFFER)
{
glBindRenderbuffer (GL_RENDERBUFFER, source);
glGetRenderbufferParameteriv (GL_RENDERBUFFER, GL_RENDERBUFFER_ALPHA_SIZE, &alpha_size);
}
else if (source_type == GL_TEXTURE)
{
glBindTexture (GL_TEXTURE_2D, source);
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE, &alpha_size);
}
else
{
g_warning ("Unsupported gl source type %d\n", source_type);
return;
}
group_target = cairo_get_group_target (cr);
direct_window = cairo_surface_get_user_data (group_target, &direct_key);
cairo_get_matrix (cr, &matrix);
dx = matrix.x0;
dy = matrix.y0;
/* Trivial == integer-only translation */
trivial_transform =
(double)dx == matrix.x0 && (double)dy == matrix.y0 &&
matrix.xx == 1.0 && matrix.xy == 0.0 &&
matrix.yx == 0.0 && matrix.yy == 1.0;
/* For direct paint of non-alpha renderbuffer, we can
just do a bitblit */
if ((_gdk_gl_flags & GDK_GL_SOFTWARE_DRAW_GL) == 0 &&
source_type == GL_RENDERBUFFER &&
alpha_size == 0 &&
direct_window != NULL &&
direct_window->current_paint.use_gl &&
trivial_transform &&
clip_region != NULL)
{
int unscaled_window_height;
int i;
/* Create a framebuffer with the source renderbuffer and
make it the current target for reads */
framebuffer = paint_data->tmp_framebuffer;
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, framebuffer);
glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, source);
glBindFramebufferEXT (GL_DRAW_FRAMEBUFFER_EXT, 0);
/* Translate to impl coords */
cairo_region_translate (clip_region, dx, dy);
glEnable (GL_SCISSOR_TEST);
gdk_window_get_unscaled_size (impl_window, NULL, &unscaled_window_height);
glDrawBuffer (GL_BACK);
#define FLIP_Y(_y) (unscaled_window_height - (_y))
for (i = 0; i < cairo_region_num_rectangles (clip_region); i++)
{
cairo_rectangle_int_t clip_rect, dest;
cairo_region_get_rectangle (clip_region, i, &clip_rect);
clip_rect.x *= window_scale;
clip_rect.y *= window_scale;
clip_rect.width *= window_scale;
clip_rect.height *= window_scale;
glScissor (clip_rect.x, FLIP_Y (clip_rect.y + clip_rect.height),
clip_rect.width, clip_rect.height);
dest.x = dx * window_scale;
dest.y = dy * window_scale;
dest.width = width * window_scale / buffer_scale;
dest.height = height * window_scale / buffer_scale;
if (gdk_rectangle_intersect (&clip_rect, &dest, &dest))
{
int clipped_src_x = x + (dest.x - dx * window_scale);
int clipped_src_y = y + (height - dest.height - (dest.y - dy * window_scale));
glBlitFramebufferEXT(clipped_src_x, clipped_src_y,
(clipped_src_x + dest.width), (clipped_src_y + dest.height),
dest.x, FLIP_Y(dest.y + dest.height),
dest.x + dest.width, FLIP_Y(dest.y),
GL_COLOR_BUFFER_BIT, GL_NEAREST);
if (impl_window->current_paint.flushed_region)
{
cairo_rectangle_int_t flushed_rect;
flushed_rect.x = dest.x / window_scale;
flushed_rect.y = dest.y / window_scale;
flushed_rect.width = (dest.x + dest.width + window_scale - 1) / window_scale - flushed_rect.x;
flushed_rect.height = (dest.y + dest.height + window_scale - 1) / window_scale - flushed_rect.y;
cairo_region_union_rectangle (impl_window->current_paint.flushed_region,
&flushed_rect);
cairo_region_subtract_rectangle (impl_window->current_paint.need_blend_region,
&flushed_rect);
}
}
}
glDisable (GL_SCISSOR_TEST);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
#undef FLIP_Y
}
/* For direct paint of alpha or non-alpha textures we can use texturing */
else if ((_gdk_gl_flags & GDK_GL_SOFTWARE_DRAW_GL) == 0 &&
source_type == GL_TEXTURE &&
direct_window != NULL &&
direct_window->current_paint.use_gl &&
trivial_transform &&
clip_region != NULL)
{
int unscaled_window_height;
GLint texture_width;
GLint texture_height;
int i, n_rects, n_quads;
GdkTexturedQuad *quads;
cairo_rectangle_int_t clip_rect;
/* Translate to impl coords */
cairo_region_translate (clip_region, dx, dy);
if (alpha_size != 0)
{
cairo_region_t *opaque_region, *blend_region;
opaque_region = cairo_region_copy (clip_region);
cairo_region_subtract (opaque_region, impl_window->current_paint.flushed_region);
cairo_region_subtract (opaque_region, impl_window->current_paint.need_blend_region);
if (!cairo_region_is_empty (opaque_region))
gdk_gl_texture_from_surface (impl_window->current_paint.surface,
opaque_region);
blend_region = cairo_region_copy (clip_region);
cairo_region_intersect (blend_region, impl_window->current_paint.need_blend_region);
glEnable (GL_BLEND);
if (!cairo_region_is_empty (blend_region))
gdk_gl_texture_from_surface (impl_window->current_paint.surface,
blend_region);
cairo_region_destroy (opaque_region);
cairo_region_destroy (blend_region);
}
glBindTexture (GL_TEXTURE_2D, source);
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &texture_width);
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &texture_height);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEnable (GL_SCISSOR_TEST);
gdk_window_get_unscaled_size (impl_window, NULL, &unscaled_window_height);
#define FLIP_Y(_y) (unscaled_window_height - (_y))
cairo_region_get_extents (clip_region, &clip_rect);
glScissor (clip_rect.x * window_scale, FLIP_Y ((clip_rect.y + clip_rect.height) * window_scale),
clip_rect.width * window_scale, clip_rect.height * window_scale);
n_quads = 0;
n_rects = cairo_region_num_rectangles (clip_region);
quads = g_new (GdkTexturedQuad, n_rects);
for (i = 0; i < n_rects; i++)
{
cairo_rectangle_int_t dest;
cairo_region_get_rectangle (clip_region, i, &clip_rect);
clip_rect.x *= window_scale;
clip_rect.y *= window_scale;
clip_rect.width *= window_scale;
clip_rect.height *= window_scale;
dest.x = dx * window_scale;
dest.y = dy * window_scale;
dest.width = width * window_scale / buffer_scale;
dest.height = height * window_scale / buffer_scale;
if (gdk_rectangle_intersect (&clip_rect, &dest, &dest))
{
int clipped_src_x = x + (dest.x - dx * window_scale);
int clipped_src_y = y + (height - dest.height - (dest.y - dy * window_scale));
GdkTexturedQuad quad = {
dest.x, FLIP_Y(dest.y),
dest.x + dest.width, FLIP_Y(dest.y + dest.height),
clipped_src_x / (float)texture_width, (clipped_src_y + dest.height) / (float)texture_height,
(clipped_src_x + dest.width) / (float)texture_width, clipped_src_y / (float)texture_height,
};
quads[n_quads++] = quad;
if (impl_window->current_paint.flushed_region)
{
cairo_rectangle_int_t flushed_rect;
flushed_rect.x = dest.x / window_scale;
flushed_rect.y = dest.y / window_scale;
flushed_rect.width = (dest.x + dest.width + window_scale - 1) / window_scale - flushed_rect.x;
flushed_rect.height = (dest.y + dest.height + window_scale - 1) / window_scale - flushed_rect.y;
cairo_region_union_rectangle (impl_window->current_paint.flushed_region,
&flushed_rect);
cairo_region_subtract_rectangle (impl_window->current_paint.need_blend_region,
&flushed_rect);
}
}
}
if (n_quads > 0)
gdk_gl_texture_quads (paint_context, GL_TEXTURE_2D, n_quads, quads);
g_free (quads);
if (alpha_size != 0)
glDisable (GL_BLEND);
#undef FLIP_Y
}
else
{
/* Software fallback */
/* TODO: avoid reading back non-required data due to dest clip */
image = cairo_surface_create_similar_image (cairo_get_target (cr),
(alpha_size == 0) ? CAIRO_FORMAT_RGB24 : CAIRO_FORMAT_ARGB32,
width, height);
cairo_surface_set_device_scale (image, buffer_scale, buffer_scale);
framebuffer = paint_data->tmp_framebuffer;
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, framebuffer);
if (source_type == GL_RENDERBUFFER)
{
/* Create a framebuffer with the source renderbuffer and
make it the current target for reads */
glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, source);
}
else
{
glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, source, 0);
}
glPixelStorei (GL_PACK_ALIGNMENT, 4);
glPixelStorei (GL_PACK_ROW_LENGTH, cairo_image_surface_get_stride (image) / 4);
glReadPixels (x, y, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
cairo_image_surface_get_data (image));
glPixelStorei (GL_PACK_ROW_LENGTH, 0);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
cairo_surface_mark_dirty (image);
/* Invert due to opengl having different origin */
cairo_scale (cr, 1, -1);
cairo_translate (cr, 0, -height / buffer_scale);
cairo_set_source_surface (cr, image, 0, 0);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_paint (cr);
cairo_surface_destroy (image);
}
if (clip_region)
cairo_region_destroy (clip_region);
}
gboolean
byzanz_deserialize (GInputStream * stream,
guint64 * msecs_out,
cairo_surface_t ** surface_out,
cairo_region_t ** region_out,
GCancellable * cancellable,
GError ** error)
{
guint i, stride;
cairo_rectangle_int_t extents, *rects;
cairo_region_t *region;
cairo_surface_t *surface;
guchar *data;
guint32 n;
int y;
g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
g_return_val_if_fail (msecs_out != NULL, FALSE);
g_return_val_if_fail (surface_out != NULL, FALSE);
g_return_val_if_fail (region_out != NULL, FALSE);
if (!g_input_stream_read_all (stream, msecs_out, sizeof (guint64), NULL, cancellable, error) ||
!g_input_stream_read_all (stream, &n, sizeof (guint32), NULL, cancellable, error))
return FALSE;
if (n == 0) {
/* end of stream */
*surface_out = NULL;
*region_out = NULL;
return TRUE;
}
region = cairo_region_create ();
rects = g_new (cairo_rectangle_int_t, n);
surface = NULL;
for (i = 0; i < n; i++) {
gint ints[4];
if (!g_input_stream_read_all (stream, ints, sizeof (ints), NULL, cancellable, error))
goto fail;
rects[i].x = ints[0];
rects[i].y = ints[1];
rects[i].width = ints[2];
rects[i].height = ints[3];
cairo_region_union_rectangle (region, &rects[i]);
}
cairo_region_get_extents (region, &extents);
surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, extents.width, extents.height);
cairo_surface_set_device_offset (surface, -extents.x, -extents.y);
stride = cairo_image_surface_get_stride (surface);
for (i = 0; i < n; i++) {
data = cairo_image_surface_get_data (surface)
+ stride * (rects[i].y - extents.y)
+ sizeof (guint32) * (rects[i].x - extents.x);
for (y = 0; y < rects[i].height; y++) {
if (!g_input_stream_read_all (stream, data,
rects[i].width * sizeof (guint32), NULL, cancellable, error))
goto fail;
data += stride;
}
}
g_free (rects);
*region_out = region;
*surface_out = surface;
return TRUE;
fail:
if (surface)
cairo_surface_destroy (surface);
cairo_region_destroy (region);
g_free (rects);
return FALSE;
}
