static void
region_global_to_output(struct weston_output *output, pixman_region32_t *region)
{
pixman_region32_translate(region, -output->x, -output->y);
weston_transformed_region(output->width, output->height,
output->transform, output->current_scale,
region, region);
}
/**
* cairo_region_translate:
* @region: a #cairo_region_t
* @dx: Amount to translate in the x direction
* @dy: Amount to translate in the y direction
*
* Translates @region by (@dx, @dy).
*
* Since: 1.10
**/
void
cairo_region_translate (cairo_region_t *region,
int dx, int dy)
{
if (region->status)
return;
pixman_region32_translate (®ion->rgn, dx, dy);
}
static inline pixman_bool_t
miClipPictureSrc (pixman_region32_t * pRegion,
pixman_image_t * pPicture,
int dx,
int dy)
{
/* XXX what to do with clipping from transformed pictures? */
if (pPicture->common.transform || pPicture->type != BITS)
return TRUE;
if (pPicture->common.repeat)
{
/* If the clip region was set by a client, then it should be intersected
* with the composite region since it's interpreted as happening
* after the repeat algorithm.
*
* If the clip region was not set by a client, then it was imposed by
* boundaries of the pixmap, or by sibling or child windows, which means
* it should in theory be repeated along. FIXME: we ignore that case.
* It is only relevant for windows that are (a) clipped by siblings/children
* and (b) used as source. However this case is not useful anyway due
* to lack of GraphicsExpose events.
*/
if (pPicture->common.has_client_clip)
{
pixman_region32_translate ( pRegion, dx, dy);
if (!pixman_region32_intersect (pRegion, pRegion,
pPicture->common.src_clip))
return FALSE;
pixman_region32_translate ( pRegion, -dx, -dy);
}
return TRUE;
}
else
{
return miClipPictureReg (pRegion,
pPicture->common.src_clip,
dx,
dy);
}
}
static inline pixman_bool_t
miClipPictureReg (pixman_region32_t * pRegion,
pixman_region32_t * pClip,
int dx,
int dy)
{
if (pixman_region32_n_rects(pRegion) == 1 &&
pixman_region32_n_rects(pClip) == 1)
{
pixman_box32_t * pRbox = pixman_region32_rectangles(pRegion, NULL);
pixman_box32_t * pCbox = pixman_region32_rectangles(pClip, NULL);
int v;
if (pRbox->x1 < (v = pCbox->x1 + dx))
pRbox->x1 = BOUND(v);
if (pRbox->x2 > (v = pCbox->x2 + dx))
pRbox->x2 = BOUND(v);
if (pRbox->y1 < (v = pCbox->y1 + dy))
pRbox->y1 = BOUND(v);
if (pRbox->y2 > (v = pCbox->y2 + dy))
pRbox->y2 = BOUND(v);
if (pRbox->x1 >= pRbox->x2 ||
pRbox->y1 >= pRbox->y2)
{
pixman_region32_init (pRegion);
}
}
else if (!pixman_region32_not_empty (pClip))
return FALSE;
else
{
if (dx || dy)
pixman_region32_translate (pRegion, -dx, -dy);
if (!pixman_region32_intersect (pRegion, pRegion, pClip))
return FALSE;
if (dx || dy)
pixman_region32_translate(pRegion, dx, dy);
}
return pixman_region32_not_empty(pRegion);
}
static void
region_intersect_only_translation(pixman_region32_t *result_global,
pixman_region32_t *global,
pixman_region32_t *surf,
struct weston_view *view)
{
float view_x, view_y;
assert(view_transformation_is_translation(view));
/* Convert from surface to global coordinates */
pixman_region32_copy(result_global, surf);
weston_view_to_global_float(view, 0, 0, &view_x, &view_y);
pixman_region32_translate(result_global, (int)view_x, (int)view_y);
pixman_region32_intersect(result_global, result_global, global);
}
void
_cairo_region_translate (cairo_region_t *region,
int x, int y)
{
pixman_region32_translate (®ion->rgn, x, y);
}
static void
repaint_region(struct weston_view *ev, struct weston_output *output,
pixman_region32_t *region, pixman_region32_t *surf_region,
pixman_op_t pixman_op)
{
struct pixman_renderer *pr =
(struct pixman_renderer *) output->compositor->renderer;
struct pixman_surface_state *ps = get_surface_state(ev->surface);
struct pixman_output_state *po = get_output_state(output);
pixman_region32_t final_region;
float view_x, view_y;
pixman_transform_t transform;
pixman_fixed_t fw, fh;
/* The final region to be painted is the intersection of
* 'region' and 'surf_region'. However, 'region' is in the global
* coordinates, and 'surf_region' is in the surface-local
* coordinates
*/
pixman_region32_init(&final_region);
if (surf_region) {
pixman_region32_copy(&final_region, surf_region);
/* Convert from surface to global coordinates */
if (!ev->transform.enabled) {
pixman_region32_translate(&final_region, ev->geometry.x, ev->geometry.y);
} else {
weston_view_to_global_float(ev, 0, 0, &view_x, &view_y);
pixman_region32_translate(&final_region, (int)view_x, (int)view_y);
}
/* We need to paint the intersection */
pixman_region32_intersect(&final_region, &final_region, region);
} else {
/* If there is no surface region, just use the global region */
pixman_region32_copy(&final_region, region);
}
/* Convert from global to output coord */
region_global_to_output(output, &final_region);
/* And clip to it */
pixman_image_set_clip_region32 (po->shadow_image, &final_region);
/* Set up the source transformation based on the surface
position, the output position/transform/scale and the client
specified buffer transform/scale */
pixman_transform_init_identity(&transform);
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed ((double)1.0/output->current_scale),
pixman_double_to_fixed ((double)1.0/output->current_scale));
fw = pixman_int_to_fixed(output->width);
fh = pixman_int_to_fixed(output->height);
switch (output->transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
case WL_OUTPUT_TRANSFORM_FLIPPED:
break;
case WL_OUTPUT_TRANSFORM_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
pixman_transform_rotate(&transform, NULL, 0, -pixman_fixed_1);
pixman_transform_translate(&transform, NULL, 0, fh);
break;
case WL_OUTPUT_TRANSFORM_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
pixman_transform_rotate(&transform, NULL, -pixman_fixed_1, 0);
pixman_transform_translate(&transform, NULL, fw, fh);
break;
case WL_OUTPUT_TRANSFORM_270:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_rotate(&transform, NULL, 0, pixman_fixed_1);
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
switch (output->transform) {
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_scale(&transform, NULL,
pixman_int_to_fixed (-1),
pixman_int_to_fixed (1));
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
pixman_transform_translate(&transform, NULL,
pixman_double_to_fixed (output->x),
pixman_double_to_fixed (output->y));
if (ev->transform.enabled) {
/* Pixman supports only 2D transform matrix, but Weston uses 3D,
* so we're omitting Z coordinate here
*/
pixman_transform_t surface_transform = {{
{ D2F(ev->transform.matrix.d[0]),
D2F(ev->transform.matrix.d[4]),
D2F(ev->transform.matrix.d[12]),
},
{ D2F(ev->transform.matrix.d[1]),
D2F(ev->transform.matrix.d[5]),
D2F(ev->transform.matrix.d[13]),
},
{ D2F(ev->transform.matrix.d[3]),
D2F(ev->transform.matrix.d[7]),
D2F(ev->transform.matrix.d[15]),
}
}};
pixman_transform_invert(&surface_transform, &surface_transform);
pixman_transform_multiply (&transform, &surface_transform, &transform);
} else {
pixman_transform_translate(&transform, NULL,
pixman_double_to_fixed ((double)-ev->geometry.x),
pixman_double_to_fixed ((double)-ev->geometry.y));
}
if (ev->surface->buffer_viewport.scaler_set) {
double scaler_x, scaler_y, scaler_width, scaler_height;
double ratio_x, ratio_y;
scaler_x = wl_fixed_to_double(ev->surface->buffer_viewport.src_x);
scaler_y = wl_fixed_to_double(ev->surface->buffer_viewport.src_y);
scaler_width = wl_fixed_to_double(ev->surface->buffer_viewport.src_width);
scaler_height = wl_fixed_to_double(ev->surface->buffer_viewport.src_height);
ratio_x = scaler_width / ev->surface->buffer_viewport.dst_width;
ratio_y = scaler_height / ev->surface->buffer_viewport.dst_height;
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed(ratio_x),
pixman_double_to_fixed(ratio_y));
pixman_transform_translate(&transform, NULL, pixman_double_to_fixed(scaler_x),
pixman_double_to_fixed(scaler_y));
}
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed(ev->surface->buffer_viewport.scale),
pixman_double_to_fixed(ev->surface->buffer_viewport.scale));
fw = pixman_int_to_fixed(pixman_image_get_width(ps->image));
fh = pixman_int_to_fixed(pixman_image_get_height(ps->image));
switch (ev->surface->buffer_viewport.transform) {
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_scale(&transform, NULL,
pixman_int_to_fixed (-1),
pixman_int_to_fixed (1));
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
switch (ev->surface->buffer_viewport.transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
case WL_OUTPUT_TRANSFORM_FLIPPED:
break;
case WL_OUTPUT_TRANSFORM_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
pixman_transform_rotate(&transform, NULL, 0, pixman_fixed_1);
pixman_transform_translate(&transform, NULL, fh, 0);
break;
case WL_OUTPUT_TRANSFORM_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
pixman_transform_rotate(&transform, NULL, -pixman_fixed_1, 0);
pixman_transform_translate(&transform, NULL, fw, fh);
break;
case WL_OUTPUT_TRANSFORM_270:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_rotate(&transform, NULL, 0, -pixman_fixed_1);
pixman_transform_translate(&transform, NULL, 0, fw);
break;
}
pixman_image_set_transform(ps->image, &transform);
if (ev->transform.enabled || output->current_scale != ev->surface->buffer_viewport.scale)
pixman_image_set_filter(ps->image, PIXMAN_FILTER_BILINEAR, NULL, 0);
else
pixman_image_set_filter(ps->image, PIXMAN_FILTER_NEAREST, NULL, 0);
if (ps->buffer_ref.buffer)
wl_shm_buffer_begin_access(ps->buffer_ref.buffer->shm_buffer);
pixman_image_composite32(pixman_op,
ps->image, /* src */
NULL /* mask */,
po->shadow_image, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->shadow_image), /* width */
pixman_image_get_height (po->shadow_image) /* height */);
if (ps->buffer_ref.buffer)
wl_shm_buffer_end_access(ps->buffer_ref.buffer->shm_buffer);
if (pr->repaint_debug)
pixman_image_composite32(PIXMAN_OP_OVER,
pr->debug_color, /* src */
NULL /* mask */,
po->shadow_image, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->shadow_image), /* width */
pixman_image_get_height (po->shadow_image) /* height */);
pixman_image_set_clip_region32 (po->shadow_image, NULL);
pixman_region32_fini(&final_region);
}
void Region::offset(const PointT<int>& delta)
{
pixman_region32_translate(&m_region, delta.x, delta.y);
}
void Region::offset(int dx, int dy)
{
pixman_region32_translate(&m_region, dx, dy);
}