示例#1
0
static NemoIcon *
nemo_icon_container_item_at (NemoIconContainer *container,
				 int x, int y)
{
	GList *p;
	int size;
	EelDRect point;
	EelIRect canvas_point;

	/* build the hit-test rectangle. Base the size on the scale factor to ensure that it is
	 * non-empty even at the smallest scale factor
	 */
	
	size = MAX (1, 1 + (1 / EEL_CANVAS (container)->pixels_per_unit));
	point.x0 = x;
	point.y0 = y;
	point.x1 = x + size;
	point.y1 = y + size;

	for (p = container->details->icons; p != NULL; p = p->next) {
		NemoIcon *icon;
		icon = p->data;
		
		eel_canvas_w2c (EEL_CANVAS (container),
				point.x0,
				point.y0,
				&canvas_point.x0,
				&canvas_point.y0);
		eel_canvas_w2c (EEL_CANVAS (container),
				point.x1,
				point.y1,
				&canvas_point.x1,
				&canvas_point.y1);
		if (nemo_icon_canvas_item_hit_test_rectangle (icon->item, canvas_point)) {
			return icon;
		}
	}
	
	return NULL;
}
static void
nautilus_selection_canvas_item_draw (EelCanvasItem *item,
				     cairo_t *cr,
				     cairo_region_t *region)
{
	NautilusSelectionCanvasItem *self;
	double x1, y1, x2, y2;
	int cx1, cy1, cx2, cy2;
	double i2w_dx, i2w_dy;

	self = NAUTILUS_SELECTION_CANVAS_ITEM (item);

	/* Get canvas pixel coordinates */
	i2w_dx = 0.0;
	i2w_dy = 0.0;
	eel_canvas_item_i2w (item, &i2w_dx, &i2w_dy);
	
	x1 = self->priv->x1 + i2w_dx;
	y1 = self->priv->y1 + i2w_dy;
	x2 = self->priv->x2 + i2w_dx;
	y2 = self->priv->y2 + i2w_dy;

	eel_canvas_w2c (item->canvas, x1, y1, &cx1, &cy1);
	eel_canvas_w2c (item->canvas, x2, y2, &cx2, &cy2);
	
	if (cx2 <= cx1 || cy2 <= cy1 ) {
		return;
	}

	cairo_save (cr);

	if (self->priv->fill_set) {
		GdkRGBA actual_fill;

		actual_fill = self->priv->fill_color;

		if (self->priv->fade_out_handler_id != 0) {
			actual_fill.alpha = self->priv->fade_out_fill_alpha;
		}

		gdk_cairo_set_source_rgba (cr, &actual_fill);
		cairo_rectangle (cr,
				 cx1, cy1,
				 cx2 - cx1 + 1,
				 cy2 - cy1 + 1);
		cairo_fill (cr);
	}

	if (self->priv->outline_set) {
		GdkRGBA actual_outline;

		actual_outline = self->priv->outline_color;

		if (self->priv->fade_out_handler_id != 0) {
			actual_outline.alpha = self->priv->fade_out_outline_alpha;
		}

		gdk_cairo_set_source_rgba (cr, &actual_outline);
		cairo_set_line_width (cr, (int) self->priv->width);

		if (self->priv->outline_stippling) {
			double dash[2] = { DASH_ON, DASH_OFF };

			cairo_set_dash (cr, dash, G_N_ELEMENTS (dash), 0);
		}

		cairo_rectangle (cr,
				 cx1 + 0.5, cy1 + 0.5,
				 cx2 - cx1,
				 cy2 - cy1);
		cairo_stroke (cr);
	}

	cairo_restore (cr);
}
static void
nautilus_selection_canvas_item_update (EelCanvasItem *item,
				       double i2w_dx,
				       double i2w_dy,
				       gint flags)
{
	NautilusSelectionCanvasItem *self;
	NautilusSelectionCanvasItemDetails *priv;
	double x1, y1, x2, y2;
	int cx1, cy1, cx2, cy2;
	int repaint_rects_count, i;
	int width_pixels;
	int width_lt, width_rb;
	Rect update_rect, repaint_rects[4];

	if (EEL_CANVAS_ITEM_CLASS (nautilus_selection_canvas_item_parent_class)->update)
		(* EEL_CANVAS_ITEM_CLASS (nautilus_selection_canvas_item_parent_class)->update) (item, i2w_dx, i2w_dy, flags);

	self = NAUTILUS_SELECTION_CANVAS_ITEM (item);
	priv = self->priv;

	x1 = priv->x1 + i2w_dx;
	y1 = priv->y1 + i2w_dy;
	x2 = priv->x2 + i2w_dx;
	y2 = priv->y2 + i2w_dy;

	eel_canvas_w2c (item->canvas, x1, y1, &cx1, &cy1);
	eel_canvas_w2c (item->canvas, x2, y2, &cx2, &cy2);

	update_rect = make_rect (cx1, cy1, cx2+1, cy2+1);
	diff_rects (update_rect, priv->last_update_rect,
		    &repaint_rects_count, repaint_rects);
	for (i = 0; i < repaint_rects_count; i++) {
		eel_canvas_request_redraw (item->canvas,
					   repaint_rects[i].x0, repaint_rects[i].y0,
					   repaint_rects[i].x1, repaint_rects[i].y1);
	}

	priv->last_update_rect = update_rect;

	if (priv->outline_set) {
		/* Outline and bounding box */
		width_pixels = (int) priv->width;
		width_lt = width_pixels / 2;
		width_rb = (width_pixels + 1) / 2;
		
		cx1 -= width_lt;
		cy1 -= width_lt;
		cx2 += width_rb;
		cy2 += width_rb;

		update_rect = make_rect (cx1, cy1, cx2, cy2);
		request_redraw_borders (item->canvas, &update_rect,
					(width_lt + width_rb));
		request_redraw_borders (item->canvas, &priv->last_outline_update_rect,
					priv->last_outline_update_width);
		priv->last_outline_update_rect = update_rect;
		priv->last_outline_update_width = width_lt + width_rb;
		
		item->x1 = cx1;
		item->y1 = cy1;
		item->x2 = cx2+1;
		item->y2 = cy2+1;
	} else {
		item->x1 = cx1;
		item->y1 = cy1;
		item->x2 = cx2+1;
		item->y2 = cy2+1;
	}
}