static gboolean
meta_surface_actor_x11_is_opaque (MetaSurfaceActor *actor)
{
MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
/* If we're not ARGB32, then we're opaque. */
if (!meta_surface_actor_is_argb32 (actor))
return TRUE;
cairo_region_t *opaque_region = meta_surface_actor_get_opaque_region (actor);
/* If we have no opaque region, then no pixels are opaque. */
if (!opaque_region)
return FALSE;
MetaWindow *window = priv->window;
cairo_rectangle_int_t client_area;
meta_window_get_client_area_rect (window, &client_area);
/* Otherwise, check if our opaque region covers our entire surface. */
if (cairo_region_contains_rectangle (opaque_region, &client_area) == CAIRO_REGION_OVERLAP_IN)
return TRUE;
return FALSE;
}
wxRegionContain wxRegion::DoContainsRect(const wxRect& r) const
{
if (!m_refData)
return wxOutRegion;
GdkRectangle rect;
rect.x = r.x;
rect.y = r.y;
rect.width = r.width;
rect.height = r.height;
#ifdef __WXGTK3__
switch (cairo_region_contains_rectangle(M_REGIONDATA->m_region, &rect))
{
case CAIRO_REGION_OVERLAP_IN: return wxInRegion;
case CAIRO_REGION_OVERLAP_PART: return wxPartRegion;
default: break;
}
#else
GdkOverlapType res = gdk_region_rect_in( M_REGIONDATA->m_region, &rect );
switch (res)
{
case GDK_OVERLAP_RECTANGLE_IN: return wxInRegion;
case GDK_OVERLAP_RECTANGLE_OUT: return wxOutRegion;
case GDK_OVERLAP_RECTANGLE_PART: return wxPartRegion;
}
#endif
return wxOutRegion;
}
// cairo_public cairo_region_overlap_t
// cairo_region_contains_rectangle (const cairo_region_t *region,
// const cairo_rectangle_int_t *rectangle);
static int l_cairo_region_contains_rectangle (lua_State* L)
{
const cairo_region_t *region = get_cairo_region_t (L, 1);
const cairo_rectangle_int_t *rectangle = get_cairo_rectangle_int_t (L, 2);
cairo_region_overlap_t v = cairo_region_contains_rectangle (region, rectangle);
lua_pushinteger(L, v);
return 1;
}
/**
* gtk_snapshot_clips_rect:
* @snapshot: a #GtkSnapshot
* @bounds: a rectangle
*
* Tests whether the rectangle is entirely outside the clip region of @snapshot.
*
* Returns: %TRUE is @bounds is entirely outside the clip region
*
* Since: 3.90
*/
gboolean
gtk_snapshot_clips_rect (GtkSnapshot *snapshot,
const graphene_rect_t *bounds)
{
graphene_rect_t offset_bounds;
cairo_rectangle_int_t rect;
if (snapshot->state->clip_region == NULL)
return FALSE;
graphene_rect_offset_r (bounds, snapshot->state->translate_x, snapshot->state->translate_y, &offset_bounds);
rectangle_init_from_graphene (&rect, &offset_bounds);
return cairo_region_contains_rectangle (snapshot->state->clip_region, &rect) == CAIRO_REGION_OVERLAP_OUT;
}
static gboolean
viewport_coordinates_get_visible(cairo_rectangle_int_t *r, document_data_t *d)
{
/* calculate visible region */
GtkWidget *w = d->widget;
gdouble width = w->allocation.width;
gdouble height = w->allocation.height;
cairo_rectangle_int_t rect = {
d->hadjust->value * d->zoom,
d->vadjust->value * d->zoom,
width,
height,
};
cairo_region_t *visible_r = cairo_region_create_rectangle(&rect);
gboolean visible = (cairo_region_contains_rectangle(visible_r, r) != CAIRO_REGION_OVERLAP_OUT);
cairo_region_destroy(visible_r);
return visible;
}
static gboolean
can_draw_in_region (cairo_region_t *draw_region,
gint x,
gint y,
gint width,
gint height)
{
GdkRectangle rect;
g_return_val_if_fail (draw_region != NULL, FALSE);
rect.x = x;
rect.y = y;
rect.width = width;
rect.height = height;
return cairo_region_contains_rectangle (draw_region, &rect) !=
CAIRO_REGION_OVERLAP_OUT;
}
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;
}
/**
* meta_shadow_paint:
* @window_x: x position of the region to paint a shadow for
* @window_y: y position of the region to paint a shadow for
* @window_width: actual width of the region to paint a shadow for
* @window_height: actual height of the region to paint a shadow for
* @clip: (allow-none): if non-%NULL specifies the visible portion
* of the shadow.
* @clip_strictly: if %TRUE, drawing will be clipped strictly
* to @clip, otherwise, it will be only used to optimize
* drawing.
*
* Paints the shadow at the given position, for the specified actual
* size of the region. (Since a #MetaShadow can be shared between
* different sizes with the same extracted #MetaWindowShape the
* size needs to be passed in here.)
*/
void
meta_shadow_paint (MetaShadow *shadow,
int window_x,
int window_y,
int window_width,
int window_height,
guint8 opacity,
cairo_region_t *clip,
gboolean clip_strictly)
{
float texture_width = cogl_texture_get_width (shadow->texture);
float texture_height = cogl_texture_get_height (shadow->texture);
int i, j;
float src_x[4];
float src_y[4];
int dest_x[4];
int dest_y[4];
int n_x, n_y;
cogl_material_set_color4ub (shadow->material,
opacity, opacity, opacity, opacity);
cogl_set_source (shadow->material);
if (shadow->scale_width)
{
n_x = 3;
src_x[0] = 0.0;
src_x[1] = (shadow->inner_border_left + shadow->outer_border_left) / texture_width;
src_x[2] = (texture_width - (shadow->inner_border_right + shadow->outer_border_right)) / texture_width;
src_x[3] = 1.0;
dest_x[0] = window_x - shadow->outer_border_left;
dest_x[1] = window_x + shadow->inner_border_left;
dest_x[2] = window_x + window_width - shadow->inner_border_right;
dest_x[3] = window_x + window_width + shadow->outer_border_right;
}
else
{
n_x = 1;
src_x[0] = 0.0;
src_x[1] = 1.0;
dest_x[0] = window_x - shadow->outer_border_left;
dest_x[1] = window_x + window_width + shadow->outer_border_right;
}
if (shadow->scale_height)
{
n_y = 3;
src_y[0] = 0.0;
src_y[1] = (shadow->inner_border_top + shadow->outer_border_top) / texture_height;
src_y[2] = (texture_height - (shadow->inner_border_bottom + shadow->outer_border_bottom)) / texture_height;
src_y[3] = 1.0;
dest_y[0] = window_y - shadow->outer_border_top;
dest_y[1] = window_y + shadow->inner_border_top;
dest_y[2] = window_y + window_height - shadow->inner_border_bottom;
dest_y[3] = window_y + window_height + shadow->outer_border_bottom;
}
else
{
n_y = 1;
src_y[0] = 0.0;
src_y[1] = 1.0;
dest_y[0] = window_y - shadow->outer_border_top;
dest_y[1] = window_y + window_height + shadow->outer_border_bottom;
}
for (j = 0; j < n_y; j++)
{
cairo_rectangle_int_t dest_rect;
dest_rect.y = dest_y[j];
dest_rect.height = dest_y[j + 1] - dest_y[j];
if (dest_rect.height == 0)
continue;
for (i = 0; i < n_x; i++)
{
cairo_region_overlap_t overlap;
dest_rect.x = dest_x[i];
dest_rect.width = dest_x[i + 1] - dest_x[i];
if (dest_rect.width == 0)
continue;
if (clip)
overlap = cairo_region_contains_rectangle (clip, &dest_rect);
else
overlap = CAIRO_REGION_OVERLAP_IN;
/* There's quite a bit of overhead from allocating a new
* region in order to find an exact intersection and
* generating more geometry - we make the assumption that
* unless we have to clip strictly it will be cheaper to
* just draw the entire rectangle.
*/
if (overlap == CAIRO_REGION_OVERLAP_IN ||
(overlap == CAIRO_REGION_OVERLAP_PART && !clip_strictly))
{
cogl_rectangle_with_texture_coords (dest_x[i], dest_y[j],
dest_x[i + 1], dest_y[j + 1],
src_x[i], src_y[j],
src_x[i + 1], src_y[j + 1]);
}
else if (overlap == CAIRO_REGION_OVERLAP_PART)
{
cairo_region_t *intersection;
int n_rectangles, k;
intersection = cairo_region_create_rectangle (&dest_rect);
cairo_region_intersect (intersection, clip);
n_rectangles = cairo_region_num_rectangles (intersection);
for (k = 0; k < n_rectangles; k++)
{
cairo_rectangle_int_t rect;
float src_x1, src_x2, src_y1, src_y2;
cairo_region_get_rectangle (intersection, k, &rect);
/* Separately linear interpolate X and Y coordinates in the source
* based on the destination X and Y coordinates */
src_x1 = (src_x[i] * (dest_rect.x + dest_rect.width - rect.x) +
src_x[i + 1] * (rect.x - dest_rect.x)) / dest_rect.width;
src_x2 = (src_x[i] * (dest_rect.x + dest_rect.width - (rect.x + rect.width)) +
src_x[i + 1] * (rect.x + rect.width - dest_rect.x)) / dest_rect.width;
src_y1 = (src_y[j] * (dest_rect.y + dest_rect.height - rect.y) +
src_y[j + 1] * (rect.y - dest_rect.y)) / dest_rect.height;
src_y2 = (src_y[j] * (dest_rect.y + dest_rect.height - (rect.y + rect.height)) +
src_y[j + 1] * (rect.y + rect.height - dest_rect.y)) / dest_rect.height;
cogl_rectangle_with_texture_coords (rect.x, rect.y,
rect.x + rect.width, rect.y + rect.height,
src_x1, src_y1, src_x2, src_y2);
}
cairo_region_destroy (intersection);
}
}
}
}
cairo_region_overlap_t
Region::RectIn (Rect rect)
{
cairo_rectangle_int_t cairo_rect = rect.ToCairoRectangleInt ();
return cairo_region_contains_rectangle (cairo_region, &cairo_rect);
}
inf_text_gtk_viewport_scrollbar_expose_event_cb(GtkWidget* scrollbar,
GdkEventExpose* event,
gpointer user_data)
#endif
{
InfTextGtkViewport* viewport;
InfTextGtkViewportPrivate* priv;
InfTextGtkViewportUser* viewport_user;
GdkRectangle* rectangle;
GdkColor* color;
double h,s,v;
double r,g,b;
GSList* item;
double line_width;
#if GTK_CHECK_VERSION(2, 91, 0)
GdkRectangle clip_area;
#else
cairo_t* cr;
#endif
viewport = INF_TEXT_GTK_VIEWPORT(user_data);
priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(viewport);
/* Can this happen? */
#if GTK_CHECK_VERSION(2, 91, 0)
if(!gtk_cairo_should_draw_window(cr, gtk_widget_get_window(scrollbar)))
#elif GTK_CHECK_VERSION(2,14,0)
if(event->window != gtk_widget_get_window(scrollbar))
#else
if(event->window != GTK_WIDGET(scrollbar)->window)
#endif
return FALSE;
if(priv->show_user_markers)
{
color = >k_widget_get_style(scrollbar)->bg[GTK_STATE_NORMAL];
h = color->red / 65535.0;
s = color->green / 65535.0;
v = color->blue / 65535.0;
rgb_to_hsv(&h, &s, &v);
s = MIN(MAX(s, 0.5), 0.8);
v = MAX(v, 0.5);
#if GTK_CHECK_VERSION(2, 91, 0)
gtk_cairo_transform_to_window(
cr,
GTK_WIDGET(scrollbar),
gtk_widget_get_window(scrollbar)
);
gdk_cairo_get_clip_rectangle(cr, &clip_area);
#else
cr = gdk_cairo_create(event->window);
#endif
line_width = cairo_get_line_width(cr);
for(item = priv->users; item != NULL; item = item->next)
{
viewport_user = (InfTextGtkViewportUser*)item->data;
rectangle = &viewport_user->rectangle;
#if GTK_CHECK_VERSION(2, 91, 0)
if(gdk_rectangle_intersect(&clip_area, rectangle, NULL))
#elif GTK_CHECK_VERSION(2,90,5)
if(cairo_region_contains_rectangle(event->region, rectangle) !=
CAIRO_REGION_OVERLAP_OUT)
#else
if(gdk_region_rect_in(event->region, rectangle) !=
GDK_OVERLAP_RECTANGLE_OUT)
#endif
{
h = inf_text_user_get_hue(viewport_user->user);
cairo_rectangle(
cr,
rectangle->x + line_width/2,
rectangle->y + line_width/2,
rectangle->width - line_width,
rectangle->height - line_width
);
r = h; g = s; b = v/2.0;
hsv_to_rgb(&r, &g, &b);
cairo_set_source_rgba(cr, r, g, b, 0.6);
cairo_stroke_preserve(cr);
r = h; g = s; b = v;
hsv_to_rgb(&r, &g, &b);
cairo_set_source_rgba(cr, r, g, b, 0.6);
cairo_fill(cr);
}
}
#if ! GTK_CHECK_VERSION(2, 91, 0)
cairo_destroy(cr);
#endif
}
return FALSE;
}