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; }