WL_EXPORT int wet_shell_init(struct weston_compositor *ec, int *argc, char *argv[]) { struct desktest_shell *dts; dts = zalloc(sizeof *dts); if (!dts) return -1; dts->compositor_destroy_listener.notify = shell_destroy; wl_signal_add(&ec->destroy_signal, &dts->compositor_destroy_listener); weston_layer_init(&dts->layer, ec); weston_layer_init(&dts->background_layer, ec); weston_layer_set_position(&dts->layer, WESTON_LAYER_POSITION_NORMAL); weston_layer_set_position(&dts->background_layer, WESTON_LAYER_POSITION_BACKGROUND); dts->background_surface = weston_surface_create(ec); if (dts->background_surface == NULL) goto out_free; dts->background_view = weston_view_create(dts->background_surface); if (dts->background_view == NULL) goto out_surface; weston_surface_set_color(dts->background_surface, 0.16, 0.32, 0.48, 1.); pixman_region32_fini(&dts->background_surface->opaque); pixman_region32_init_rect(&dts->background_surface->opaque, 0, 0, 2000, 2000); pixman_region32_fini(&dts->background_surface->input); pixman_region32_init_rect(&dts->background_surface->input, 0, 0, 2000, 2000); weston_surface_set_size(dts->background_surface, 2000, 2000); weston_view_set_position(dts->background_view, 0, 0); weston_layer_entry_insert(&dts->background_layer.view_list, &dts->background_view->layer_link); weston_view_update_transform(dts->background_view); dts->desktop = weston_desktop_create(ec, &shell_desktop_api, dts); if (dts->desktop == NULL) goto out_view; return 0; out_view: weston_view_destroy(dts->background_view); out_surface: weston_surface_destroy(dts->background_surface); out_free: free(dts); return -1; }
void DummySurface::setSize(int w, int h) { weston_surface *s = surface(); weston_surface_set_size(s, w, h); pixman_region32_fini(&s->opaque); pixman_region32_init_rect(&s->opaque, 0, 0, w, h); weston_surface_damage(s); if (m_acceptInput) { pixman_region32_fini(&s->input); pixman_region32_init_rect(&s->input, 0, 0, w, h); } }
Region::Region(const Rect& rect) { if (!rect.isEmpty()) pixman_region32_init_rect(&m_region, rect.x, rect.y, rect.w, rect.h); else pixman_region32_init(&m_region); }
static void draw_view_source_clipped(struct weston_view *view, struct weston_output *output, pixman_region32_t *repaint_global) { struct weston_surface *surface = view->surface; pixman_region32_t surf_region; pixman_region32_t buffer_region; pixman_region32_t repaint_output; /* Do not bother separating the opaque region from non-opaque. * Source clipping requires PIXMAN_OP_OVER in all cases, so painting * opaque separately has no benefit. */ pixman_region32_init_rect(&surf_region, 0, 0, surface->width, surface->height); if (view->geometry.scissor_enabled) pixman_region32_intersect(&surf_region, &surf_region, &view->geometry.scissor); pixman_region32_init(&buffer_region); weston_surface_to_buffer_region(surface, &surf_region, &buffer_region); pixman_region32_init(&repaint_output); pixman_region32_copy(&repaint_output, repaint_global); region_global_to_output(output, &repaint_output); repaint_region(view, output, &repaint_output, &buffer_region, PIXMAN_OP_OVER); pixman_region32_fini(&repaint_output); pixman_region32_fini(&buffer_region); pixman_region32_fini(&surf_region); }
/** * cairo_region_xor_rectangle: * @dst: a #cairo_region_t * @rectangle: a #cairo_rectangle_int_t * * Computes the exclusive difference of @dst with @rectangle and places the * result in @dst. That is, @dst will be set to contain all areas that are * either in @dst or in @rectangle, but not in both. * * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY * * Since: 1.10 **/ cairo_status_t cairo_region_xor_rectangle (cairo_region_t *dst, const cairo_rectangle_int_t *rectangle) { cairo_status_t status = CAIRO_STATUS_SUCCESS; pixman_region32_t region, tmp; if (dst->status) return dst->status; pixman_region32_init_rect (®ion, rectangle->x, rectangle->y, rectangle->width, rectangle->height); pixman_region32_init (&tmp); /* XXX: get an xor function into pixman */ if (! pixman_region32_subtract (&tmp, ®ion, &dst->rgn) || ! pixman_region32_subtract (&dst->rgn, &dst->rgn, ®ion) || ! pixman_region32_union (&dst->rgn, &dst->rgn, &tmp)) status = _cairo_region_set_error (dst, CAIRO_STATUS_NO_MEMORY); pixman_region32_fini (&tmp); pixman_region32_fini (®ion); return status; }
void _cairo_region_init_rect (cairo_region_t *region, cairo_rectangle_int_t *rect) { pixman_region32_init_rect (®ion->rgn, rect->x, rect->y, rect->width, rect->height); }
static void subtract(struct wl_client *client, struct wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height) { struct region *region = wl_resource_get_user_data(resource); pixman_region32_t operand; pixman_region32_init_rect(&operand, x, y, width, height); pixman_region32_subtract(®ion->region, ®ion->region, &operand); }
void _cairo_region_init_rectangle (cairo_region_t *region, const cairo_rectangle_int_t *rectangle) { region->status = CAIRO_STATUS_SUCCESS; pixman_region32_init_rect (®ion->rgn, rectangle->x, rectangle->y, rectangle->width, rectangle->height); }
void _cairo_region_init_rectangle (cairo_region_t *region, const cairo_rectangle_int_t *rectangle) { VG (VALGRIND_MAKE_MEM_UNDEFINED (region, sizeof (cairo_region_t))); region->status = CAIRO_STATUS_SUCCESS; CAIRO_REFERENCE_COUNT_INIT (®ion->ref_count, 0); pixman_region32_init_rect (®ion->rgn, rectangle->x, rectangle->y, rectangle->width, rectangle->height); }
void DummySurface::setAcceptInput(bool accept) { if (m_acceptInput == accept) { return; } m_acceptInput = accept; weston_surface *s = surface(); int w = accept ? width() : 0; int h = accept ? height() : 0; pixman_region32_fini(&s->input); pixman_region32_init_rect(&s->input, 0, 0, w, h); }
/** * cairo_region_create_rectangles: * @rects: an array of @count rectangles * @count: number of rectangles * * Allocates a new region object containing the union of all given @rects. * * Return value: A newly allocated #cairo_region_t. Free with * cairo_region_destroy(). This function always returns a * valid pointer; if memory cannot be allocated, then a special * error object is returned where all operations on the object do nothing. * You can check for this with cairo_region_status(). * * Since: 1.10 **/ cairo_region_t * cairo_region_create_rectangles (const cairo_rectangle_int_t *rects, int count) { pixman_box32_t stack_pboxes[CAIRO_STACK_ARRAY_LENGTH (pixman_box32_t)]; pixman_box32_t *pboxes = stack_pboxes; cairo_region_t *region; int i; region = _cairo_malloc (sizeof (cairo_region_t)); if (unlikely (region == NULL)) return _cairo_region_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); CAIRO_REFERENCE_COUNT_INIT (®ion->ref_count, 1); region->status = CAIRO_STATUS_SUCCESS; if (count == 1) { pixman_region32_init_rect (®ion->rgn, rects->x, rects->y, rects->width, rects->height); return region; } if (count > ARRAY_LENGTH (stack_pboxes)) { pboxes = _cairo_malloc_ab (count, sizeof (pixman_box32_t)); if (unlikely (pboxes == NULL)) { free (region); return _cairo_region_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } } for (i = 0; i < count; i++) { pboxes[i].x1 = rects[i].x; pboxes[i].y1 = rects[i].y; pboxes[i].x2 = rects[i].x + rects[i].width; pboxes[i].y2 = rects[i].y + rects[i].height; } i = pixman_region32_init_rects (®ion->rgn, pboxes, count); if (pboxes != stack_pboxes) free (pboxes); if (unlikely (i == 0)) { free (region); return _cairo_region_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } return region; }
static void draw_view(struct weston_view *ev, struct weston_output *output, pixman_region32_t *damage) /* in global coordinates */ { struct pixman_surface_state *ps = get_surface_state(ev->surface); /* repaint bounding region in global coordinates: */ pixman_region32_t repaint; /* non-opaque region in surface coordinates: */ pixman_region32_t surface_blend; /* No buffer attached */ if (!ps->image) return; pixman_region32_init(&repaint); pixman_region32_intersect(&repaint, &ev->transform.boundingbox, damage); pixman_region32_subtract(&repaint, &repaint, &ev->clip); if (!pixman_region32_not_empty(&repaint)) goto out; if (output->zoom.active) { weston_log("pixman renderer does not support zoom\n"); goto out; } /* TODO: Implement repaint_region_complex() using pixman_composite_trapezoids() */ if (ev->transform.enabled && ev->transform.matrix.type != WESTON_MATRIX_TRANSFORM_TRANSLATE) { repaint_region(ev, output, &repaint, NULL, PIXMAN_OP_OVER); } else { /* blended region is whole surface minus opaque region: */ pixman_region32_init_rect(&surface_blend, 0, 0, ev->surface->width, ev->surface->height); pixman_region32_subtract(&surface_blend, &surface_blend, &ev->surface->opaque); if (pixman_region32_not_empty(&ev->surface->opaque)) { repaint_region(ev, output, &repaint, &ev->surface->opaque, PIXMAN_OP_SRC); } if (pixman_region32_not_empty(&surface_blend)) { repaint_region(ev, output, &repaint, &surface_blend, PIXMAN_OP_OVER); } pixman_region32_fini(&surface_blend); } out: pixman_region32_fini(&repaint); }
static void draw_view_translated(struct weston_view *view, struct weston_output *output, pixman_region32_t *repaint_global) { struct weston_surface *surface = view->surface; /* non-opaque region in surface coordinates: */ pixman_region32_t surface_blend; /* region to be painted in output coordinates: */ pixman_region32_t repaint_output; pixman_region32_init(&repaint_output); /* Blended region is whole surface minus opaque region, * unless surface alpha forces us to blend all. */ pixman_region32_init_rect(&surface_blend, 0, 0, surface->width, surface->height); if (!(view->alpha < 1.0)) { pixman_region32_subtract(&surface_blend, &surface_blend, &surface->opaque); if (pixman_region32_not_empty(&surface->opaque)) { region_intersect_only_translation(&repaint_output, repaint_global, &surface->opaque, view); region_global_to_output(output, &repaint_output); repaint_region(view, output, &repaint_output, NULL, PIXMAN_OP_SRC); } } if (pixman_region32_not_empty(&surface_blend)) { region_intersect_only_translation(&repaint_output, repaint_global, &surface_blend, view); region_global_to_output(output, &repaint_output); repaint_region(view, output, &repaint_output, NULL, PIXMAN_OP_OVER); } pixman_region32_fini(&surface_blend); pixman_region32_fini(&repaint_output); }
/** * cairo_region_create_rectangle: * @rectangle: a #cairo_rectangle_int_t * * Allocates a new region object containing @rectangle. * * Return value: A newly allocated #cairo_region_t. Free with * cairo_region_destroy(). This function always returns a * valid pointer; if memory cannot be allocated, then a special * error object is returned where all operations on the object do nothing. * You can check for this with cairo_region_status(). * * Since: 1.10 **/ cairo_region_t * cairo_region_create_rectangle (const cairo_rectangle_int_t *rectangle) { cairo_region_t *region; region = _cairo_malloc (sizeof (cairo_region_t)); if (region == NULL) return (cairo_region_t *) &_cairo_region_nil; region->status = CAIRO_STATUS_SUCCESS; pixman_region32_init_rect (®ion->rgn, rectangle->x, rectangle->y, rectangle->width, rectangle->height); return region; }
/** * cairo_region_create_rectangle: * @rectangle: a #cairo_rectangle_int_t * * Allocates a new region object containing @rectangle. * * Return value: A newly allocated #cairo_region_t. Free with * cairo_region_destroy(). This function always returns a * valid pointer; if memory cannot be allocated, then a special * error object is returned where all operations on the object do nothing. * You can check for this with cairo_region_status(). * * Since: 1.10 **/ cairo_region_t * cairo_region_create_rectangle (const cairo_rectangle_int_t *rectangle) { cairo_region_t *region; region = _cairo_malloc (sizeof (cairo_region_t)); if (unlikely (region == NULL)) return (cairo_region_t *) &_cairo_region_nil; region->status = CAIRO_STATUS_SUCCESS; CAIRO_REFERENCE_COUNT_INIT (®ion->ref_count, 1); pixman_region32_init_rect (®ion->rgn, rectangle->x, rectangle->y, rectangle->width, rectangle->height); return region; }
/** * cairo_region_union_rectangle: * @dst: a #cairo_region_t * @rectangle: a #cairo_rectangle_int_t * * Computes the union of @dst with @rectangle and places the result in @dst. * * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY * * Since: 1.10 **/ cairo_status_t cairo_region_union_rectangle (cairo_region_t *dst, const cairo_rectangle_int_t *rectangle) { cairo_status_t status = CAIRO_STATUS_SUCCESS; pixman_region32_t region; if (dst->status) return dst->status; pixman_region32_init_rect (®ion, rectangle->x, rectangle->y, rectangle->width, rectangle->height); if (! pixman_region32_union (&dst->rgn, &dst->rgn, ®ion)) status = _cairo_region_set_error (dst, CAIRO_STATUS_NO_MEMORY); pixman_region32_fini (®ion); return status; }
int main () { pixman_region32_t r1; pixman_region32_t r2; pixman_region32_t r3; pixman_box32_t boxes[] = { { 10, 10, 20, 20 }, { 30, 30, 30, 40 }, { 50, 45, 60, 44 }, }; pixman_box32_t boxes2[] = { { 2, 6, 7, 6 }, { 4, 1, 6, 7 }, }; pixman_box32_t boxes3[] = { { 2, 6, 7, 6 }, { 4, 1, 6, 1 }, }; int i; pixman_box32_t *b; /* This used to go into an infinite loop before pixman-region.c * was fixed to not use explict "short" variables */ pixman_region32_init_rect (&r1, 0, 0, 20, 64000); pixman_region32_init_rect (&r2, 0, 0, 20, 64000); pixman_region32_init_rect (&r3, 0, 0, 20, 64000); pixman_region32_subtract (&r1, &r2, &r3); /* This would produce a region containing an empty * rectangle in it. Such regions are considered malformed, * but using an empty rectangle for initialization should * work. */ pixman_region32_init_rects (&r1, boxes, 3); b = pixman_region32_rectangles (&r1, &i); assert (i == 1); while (i--) { assert (b[i].x1 < b[i].x2); assert (b[i].y1 < b[i].y2); } /* This would produce a rectangle containing the bounding box * of the two rectangles. The correct result is to eliminate * the broken rectangle. */ pixman_region32_init_rects (&r1, boxes2, 2); b = pixman_region32_rectangles (&r1, &i); assert (i == 1); assert (b[0].x1 == 4); assert (b[0].y1 == 1); assert (b[0].x2 == 6); assert (b[0].y2 == 7); /* This should produce an empty region */ pixman_region32_init_rects (&r1, boxes3, 2); b = pixman_region32_rectangles (&r1, &i); assert (i == 0); return 0; }
int main () { pixman_region32_t r1; pixman_region32_t r2; pixman_region32_t r3; pixman_box32_t boxes[] = { { 10, 10, 20, 20 }, { 30, 30, 30, 40 }, { 50, 45, 60, 44 }, }; pixman_box32_t boxes2[] = { { 2, 6, 7, 6 }, { 4, 1, 6, 7 }, }; pixman_box32_t boxes3[] = { { 2, 6, 7, 6 }, { 4, 1, 6, 1 }, }; int i, j; pixman_box32_t *b; pixman_image_t *image, *fill; pixman_color_t white = { 0xffff, 0xffff, 0xffff, 0xffff }; /* This used to go into an infinite loop before pixman-region.c * was fixed to not use explict "short" variables */ pixman_region32_init_rect (&r1, 0, 0, 20, 64000); pixman_region32_init_rect (&r2, 0, 0, 20, 64000); pixman_region32_init_rect (&r3, 0, 0, 20, 64000); pixman_region32_subtract (&r1, &r2, &r3); /* This would produce a region containing an empty * rectangle in it. Such regions are considered malformed, * but using an empty rectangle for initialization should * work. */ pixman_region32_init_rects (&r1, boxes, 3); b = pixman_region32_rectangles (&r1, &i); assert (i == 1); while (i--) { assert (b[i].x1 < b[i].x2); assert (b[i].y1 < b[i].y2); } /* This would produce a rectangle containing the bounding box * of the two rectangles. The correct result is to eliminate * the broken rectangle. */ pixman_region32_init_rects (&r1, boxes2, 2); b = pixman_region32_rectangles (&r1, &i); assert (i == 1); assert (b[0].x1 == 4); assert (b[0].y1 == 1); assert (b[0].x2 == 6); assert (b[0].y2 == 7); /* This should produce an empty region */ pixman_region32_init_rects (&r1, boxes3, 2); b = pixman_region32_rectangles (&r1, &i); assert (i == 0); fill = pixman_image_create_solid_fill (&white); for (i = 0; i < 100; i++) { int image_size = 128; pixman_region32_init (&r1); /* Add some random rectangles */ for (j = 0; j < 64; j++) pixman_region32_union_rect (&r1, &r1, lcg_rand_n (image_size), lcg_rand_n (image_size), lcg_rand_n (25), lcg_rand_n (25)); /* Clip to image size */ pixman_region32_init_rect (&r2, 0, 0, image_size, image_size); pixman_region32_intersect (&r1, &r1, &r2); pixman_region32_fini (&r2); /* render region to a1 mask */ image = pixman_image_create_bits (PIXMAN_a1, image_size, image_size, NULL, 0); pixman_image_set_clip_region32 (image, &r1); pixman_image_composite32 (PIXMAN_OP_SRC, fill, NULL, image, 0, 0, 0, 0, 0, 0, image_size, image_size); pixman_region32_init_from_image (&r2, image); pixman_image_unref (image); assert (pixman_region32_equal (&r1, &r2)); pixman_region32_fini (&r1); pixman_region32_fini (&r2); } pixman_image_unref (fill); return 0; }
int main (int argc, char **argv) { pixman_image_t *gradient_img; pixman_image_t *src_img, *dst_img; pixman_gradient_stop_t stops[2] = { { pixman_int_to_fixed (0), { 0xffff, 0x0000, 0x0000, 0xffff } }, { pixman_int_to_fixed (1), { 0xffff, 0xffff, 0x0000, 0xffff } } }; pixman_point_fixed_t p1 = { 0, 0 }; pixman_point_fixed_t p2 = { pixman_int_to_fixed (WIDTH), pixman_int_to_fixed (HEIGHT) }; pixman_point_fixed_t c_inner; pixman_point_fixed_t c_outer; pixman_fixed_t r_inner; pixman_fixed_t r_outer; pixman_region32_t clip_region; pixman_transform_t trans = { { { pixman_double_to_fixed (1.3), pixman_double_to_fixed (0), pixman_double_to_fixed (-0.5), }, { pixman_double_to_fixed (0), pixman_double_to_fixed (1), pixman_double_to_fixed (-0.5), }, { pixman_double_to_fixed (0), pixman_double_to_fixed (0), pixman_double_to_fixed (1.0) } } }; src_img = create_solid_bits (0xff0000ff); c_inner.x = pixman_double_to_fixed (100.0); c_inner.y = pixman_double_to_fixed (100.0); c_outer.x = pixman_double_to_fixed (100.0); c_outer.y = pixman_double_to_fixed (100.0); r_inner = 0; r_outer = pixman_double_to_fixed (100.0); gradient_img = pixman_image_create_radial_gradient (&c_inner, &c_outer, r_inner, r_outer, stops, 2); #if 0 gradient_img = pixman_image_create_linear_gradient (&p1, &p2, stops, 2); #endif pixman_image_composite (PIXMAN_OP_OVER, gradient_img, NULL, src_img, 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT); pixman_region32_init_rect (&clip_region, 50, 0, 100, 200); pixman_image_set_clip_region32 (src_img, &clip_region); pixman_image_set_source_clipping (src_img, TRUE); pixman_image_set_has_client_clip (src_img, TRUE); pixman_image_set_transform (src_img, &trans); pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NORMAL); dst_img = create_solid_bits (0xffff0000); pixman_image_composite (PIXMAN_OP_OVER, src_img, NULL, dst_img, 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT); #if 0 printf ("0, 0: %x\n", src[0]); printf ("10, 10: %x\n", src[10 * 10 + 10]); printf ("w, h: %x\n", src[(HEIGHT - 1) * 100 + (WIDTH - 1)]); #endif show_image (dst_img); pixman_image_unref (gradient_img); pixman_image_unref (src_img); return 0; }