/* Nautilus - Canvas item for floating selection.
*
* Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation
* Copyright (C) 2011 Red Hat Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* Authors: Federico Mena <federico@nuclecu.unam.mx>
* Cosimo Cecchi <cosimoc@redhat.com>
*/
#include <config.h>
#include "nautilus-selection-canvas-item.h"
#include <math.h>
enum
{
PROP_X1 = 1,
PROP_Y1,
PROP_X2,
PROP_Y2,
PROP_FILL_COLOR_RGBA,
PROP_OUTLINE_COLOR_RGBA,
PROP_OUTLINE_STIPPLING,
PROP_WIDTH_PIXELS,
NUM_PROPERTIES
};
static GParamSpec *properties[NUM_PROPERTIES] = { NULL };
typedef struct
{
/*< public >*/
int x0, y0, x1, y1;
} Rect;
struct _NautilusSelectionCanvasItemDetails
{
Rect last_update_rect;
Rect last_outline_update_rect;
int last_outline_update_width;
double x1, y1, x2, y2; /* Corners of item */
double width; /* Outline width */
GdkRGBA fill_color;
GdkRGBA outline_color;
gboolean outline_stippling;
/* Configuration flags */
unsigned int fill_set : 1; /* Is fill color set? */
unsigned int outline_set : 1; /* Is outline color set? */
double fade_out_fill_alpha;
double fade_out_outline_alpha;
gint64 fade_out_start_time;
gint64 fade_out_end_time;
guint fade_out_tick_id;
};
G_DEFINE_TYPE (NautilusSelectionCanvasItem, nautilus_selection_canvas_item, EEL_TYPE_CANVAS_ITEM);
#define DASH_ON 0.8
#define DASH_OFF 1.7
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_tick_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_tick_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 double
nautilus_selection_canvas_item_point (EelCanvasItem *item,
double x,
double y,
int cx,
int cy,
EelCanvasItem **actual_item)
{
NautilusSelectionCanvasItem *self;
double x1, y1, x2, y2;
double hwidth;
double dx, dy;
double tmp;
self = NAUTILUS_SELECTION_CANVAS_ITEM (item);
*actual_item = item;
/* Find the bounds for the rectangle plus its outline width */
x1 = self->priv->x1;
y1 = self->priv->y1;
x2 = self->priv->x2;
y2 = self->priv->y2;
if (self->priv->outline_set)
{
hwidth = (self->priv->width / item->canvas->pixels_per_unit) / 2.0;
x1 -= hwidth;
y1 -= hwidth;
x2 += hwidth;
y2 += hwidth;
}
else
{
hwidth = 0.0;
}
/* Is point inside rectangle (which can be hollow if it has no fill set)? */
if ((x >= x1) && (y >= y1) && (x <= x2) && (y <= y2))
{
if (self->priv->fill_set || !self->priv->outline_set)
{
return 0.0;
}
dx = x - x1;
tmp = x2 - x;
if (tmp < dx)
{
dx = tmp;
}
dy = y - y1;
tmp = y2 - y;
if (tmp < dy)
{
dy = tmp;
}
if (dy < dx)
{
dx = dy;
}
dx -= 2.0 * hwidth;
if (dx < 0.0)
{
return 0.0;
}
else
{
return dx;
}
}
/* Point is outside rectangle */
if (x < x1)
{
dx = x1 - x;
}
else if (x > x2)
{
dx = x - x2;
}
else
{
dx = 0.0;
}
if (y < y1)
{
dy = y1 - y;
}
else if (y > y2)
{
dy = y - y2;
}
else
{
dy = 0.0;
}
return sqrt (dx * dx + dy * dy);
}
static void
request_redraw_borders (EelCanvas *canvas,
Rect *update_rect,
int width)
{
eel_canvas_request_redraw (canvas,
update_rect->x0, update_rect->y0,
update_rect->x1, update_rect->y0 + width);
eel_canvas_request_redraw (canvas,
update_rect->x0, update_rect->y1 - width,
update_rect->x1, update_rect->y1);
eel_canvas_request_redraw (canvas,
update_rect->x0, update_rect->y0,
update_rect->x0 + width, update_rect->y1);
eel_canvas_request_redraw (canvas,
update_rect->x1 - width, update_rect->y0,
update_rect->x1, update_rect->y1);
}
static Rect make_rect (int x0,
int y0,
int x1,
int y1);
static int
rect_empty (const Rect *src)
{
return (src->x1 <= src->x0 || src->y1 <= src->y0);
}
static gboolean
rects_intersect (Rect r1,
Rect r2)
{
if (r1.x0 >= r2.x1)
{
return FALSE;
}
if (r2.x0 >= r1.x1)
{
return FALSE;
}
if (r1.y0 >= r2.y1)
{
return FALSE;
}
if (r2.y0 >= r1.y1)
{
return FALSE;
}
return TRUE;
}
static void
diff_rects_guts (Rect ra,
Rect rb,
int *count,
Rect result[4])
{
if (ra.x0 < rb.x0)
{
result[(*count)++] = make_rect (ra.x0, ra.y0, rb.x0, ra.y1);
}
if (ra.y0 < rb.y0)
{
result[(*count)++] = make_rect (ra.x0, ra.y0, ra.x1, rb.y0);
}
if (ra.x1 < rb.x1)
{
result[(*count)++] = make_rect (ra.x1, rb.y0, rb.x1, rb.y1);
}
if (ra.y1 < rb.y1)
{
result[(*count)++] = make_rect (rb.x0, ra.y1, rb.x1, rb.y1);
}
}
static void
diff_rects (Rect r1,
Rect r2,
int *count,
Rect result[4])
{
g_assert (count != NULL);
g_assert (result != NULL);
*count = 0;
if (rects_intersect (r1, r2))
{
diff_rects_guts (r1, r2, count, result);
diff_rects_guts (r2, r1, count, result);
}
else
{
if (!rect_empty (&r1))
{
result[(*count)++] = r1;
}
if (!rect_empty (&r2))
{
result[(*count)++] = r2;
}
}
}
static Rect
make_rect (int x0,
int y0,
int x1,
int y1)
{
Rect r;
r.x0 = x0;
r.y0 = y0;
r.x1 = x1;
r.y1 = y1;
return r;
}
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;
}
}
static void
nautilus_selection_canvas_item_translate (EelCanvasItem *item,
double dx,
double dy)
{
NautilusSelectionCanvasItem *self;
self = NAUTILUS_SELECTION_CANVAS_ITEM (item);
self->priv->x1 += dx;
self->priv->y1 += dy;
self->priv->x2 += dx;
self->priv->y2 += dy;
}
static void
nautilus_selection_canvas_item_bounds (EelCanvasItem *item,
double *x1,
double *y1,
double *x2,
double *y2)
{
NautilusSelectionCanvasItem *self;
double hwidth;
self = NAUTILUS_SELECTION_CANVAS_ITEM (item);
hwidth = (self->priv->width / item->canvas->pixels_per_unit) / 2.0;
*x1 = self->priv->x1 - hwidth;
*y1 = self->priv->y1 - hwidth;
*x2 = self->priv->x2 + hwidth;
*y2 = self->priv->y2 + hwidth;
}
static gboolean
fade_and_request_redraw (GtkWidget *canvas,
GdkFrameClock *frame_clock,
gpointer user_data)
{
NautilusSelectionCanvasItem *self = user_data;
gint64 frame_time;
gdouble percentage;
frame_time = gdk_frame_clock_get_frame_time (frame_clock);
if (frame_time >= self->priv->fade_out_end_time)
{
self->priv->fade_out_tick_id = 0;
eel_canvas_item_destroy (EEL_CANVAS_ITEM (self));
return G_SOURCE_REMOVE;
}
percentage = 1.0 - (gdouble) (frame_time - self->priv->fade_out_start_time) /
(gdouble) (self->priv->fade_out_end_time - self->priv->fade_out_start_time);
self->priv->fade_out_fill_alpha = self->priv->fill_color.alpha * percentage;
self->priv->fade_out_outline_alpha = self->priv->outline_color.alpha * percentage;
eel_canvas_item_request_redraw (EEL_CANVAS_ITEM (self));
return G_SOURCE_CONTINUE;
}
void
nautilus_selection_canvas_item_fade_out (NautilusSelectionCanvasItem *self,
guint transition_time)
{
EelCanvasItem *item = EEL_CANVAS_ITEM (self);
GtkWidget *widget;
GdkFrameClock *clock;
self->priv->fade_out_fill_alpha = self->priv->fill_color.alpha;
self->priv->fade_out_outline_alpha = self->priv->outline_color.alpha;
widget = GTK_WIDGET (item->canvas);
clock = gtk_widget_get_frame_clock (widget);
self->priv->fade_out_start_time = gdk_frame_clock_get_frame_time (clock);
self->priv->fade_out_end_time = self->priv->fade_out_start_time + 1000 * transition_time;
self->priv->fade_out_tick_id =
gtk_widget_add_tick_callback (GTK_WIDGET (item->canvas), fade_and_request_redraw, self, NULL);
}
static void
nautilus_selection_canvas_item_dispose (GObject *obj)
{
NautilusSelectionCanvasItem *self = NAUTILUS_SELECTION_CANVAS_ITEM (obj);
if (self->priv->fade_out_tick_id != 0)
{
gtk_widget_remove_tick_callback (GTK_WIDGET (EEL_CANVAS_ITEM (self)->canvas), self->priv->fade_out_tick_id);
self->priv->fade_out_tick_id = 0;
}
G_OBJECT_CLASS (nautilus_selection_canvas_item_parent_class)->dispose (obj);
}
static void
do_set_fill (NautilusSelectionCanvasItem *self,
gboolean fill_set)
{
if (self->priv->fill_set != fill_set)
{
self->priv->fill_set = fill_set;
eel_canvas_item_request_update (EEL_CANVAS_ITEM (self));
}
}
static void
do_set_outline (NautilusSelectionCanvasItem *self,
gboolean outline_set)
{
if (self->priv->outline_set != outline_set)
{
self->priv->outline_set = outline_set;
eel_canvas_item_request_update (EEL_CANVAS_ITEM (self));
}
}
static void
nautilus_selection_canvas_item_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
EelCanvasItem *item;
NautilusSelectionCanvasItem *self;
self = NAUTILUS_SELECTION_CANVAS_ITEM (object);
item = EEL_CANVAS_ITEM (object);
switch (param_id)
{
case PROP_X1:
{
self->priv->x1 = g_value_get_double (value);
eel_canvas_item_request_update (item);
}
break;
case PROP_Y1:
{
self->priv->y1 = g_value_get_double (value);
eel_canvas_item_request_update (item);
}
break;
case PROP_X2:
{
self->priv->x2 = g_value_get_double (value);
eel_canvas_item_request_update (item);
}
break;
case PROP_Y2:
{
self->priv->y2 = g_value_get_double (value);
eel_canvas_item_request_update (item);
}
break;
case PROP_FILL_COLOR_RGBA:
{
GdkRGBA *color;
color = g_value_get_boxed (value);
do_set_fill (self, color != NULL);
if (color != NULL)
{
self->priv->fill_color = *color;
}
eel_canvas_item_request_redraw (item);
break;
}
case PROP_OUTLINE_COLOR_RGBA:
{
GdkRGBA *color;
color = g_value_get_boxed (value);
do_set_outline (self, color != NULL);
if (color != NULL)
{
self->priv->outline_color = *color;
}
eel_canvas_item_request_redraw (item);
break;
}
case PROP_OUTLINE_STIPPLING:
{
self->priv->outline_stippling = g_value_get_boolean (value);
eel_canvas_item_request_redraw (item);
}
break;
case PROP_WIDTH_PIXELS:
{
self->priv->width = g_value_get_uint (value);
eel_canvas_item_request_update (item);
}
break;
default:
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
}
break;
}
}
static void
nautilus_selection_canvas_item_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
NautilusSelectionCanvasItem *self;
self = NAUTILUS_SELECTION_CANVAS_ITEM (object);
switch (param_id)
{
case PROP_X1:
{
g_value_set_double (value, self->priv->x1);
}
break;
case PROP_Y1:
{
g_value_set_double (value, self->priv->y1);
}
break;
case PROP_X2:
{
g_value_set_double (value, self->priv->x2);
}
break;
case PROP_Y2:
{
g_value_set_double (value, self->priv->y2);
}
break;
case PROP_FILL_COLOR_RGBA:
{
g_value_set_boxed (value, &self->priv->fill_color);
}
break;
case PROP_OUTLINE_COLOR_RGBA:
{
g_value_set_boxed (value, &self->priv->outline_color);
}
break;
case PROP_OUTLINE_STIPPLING:
{
g_value_set_boolean (value, self->priv->outline_stippling);
}
break;
case PROP_WIDTH_PIXELS:
{
g_value_set_uint (value, self->priv->width);
}
break;
default:
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
}
break;
}
}
static void
nautilus_selection_canvas_item_class_init (NautilusSelectionCanvasItemClass *klass)
{
EelCanvasItemClass *item_class;
GObjectClass *gobject_class;
gobject_class = G_OBJECT_CLASS (klass);
item_class = EEL_CANVAS_ITEM_CLASS (klass);
gobject_class->set_property = nautilus_selection_canvas_item_set_property;
gobject_class->get_property = nautilus_selection_canvas_item_get_property;
gobject_class->dispose = nautilus_selection_canvas_item_dispose;
item_class->draw = nautilus_selection_canvas_item_draw;
item_class->point = nautilus_selection_canvas_item_point;
item_class->update = nautilus_selection_canvas_item_update;
item_class->bounds = nautilus_selection_canvas_item_bounds;
item_class->translate = nautilus_selection_canvas_item_translate;
properties[PROP_X1] =
g_param_spec_double ("x1", NULL, NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
properties[PROP_Y1] =
g_param_spec_double ("y1", NULL, NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
properties[PROP_X2] =
g_param_spec_double ("x2", NULL, NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
properties[PROP_Y2] =
g_param_spec_double ("y2", NULL, NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
properties[PROP_FILL_COLOR_RGBA] =
g_param_spec_boxed ("fill-color-rgba", NULL, NULL,
GDK_TYPE_RGBA,
G_PARAM_READWRITE);
properties[PROP_OUTLINE_COLOR_RGBA] =
g_param_spec_boxed ("outline-color-rgba", NULL, NULL,
GDK_TYPE_RGBA,
G_PARAM_READWRITE);
properties[PROP_OUTLINE_STIPPLING] =
g_param_spec_boolean ("outline-stippling", NULL, NULL,
FALSE, G_PARAM_READWRITE);
properties[PROP_WIDTH_PIXELS] =
g_param_spec_uint ("width-pixels", NULL, NULL,
0, G_MAXUINT, 0,
G_PARAM_READWRITE);
g_object_class_install_properties (gobject_class, NUM_PROPERTIES, properties);
g_type_class_add_private (klass, sizeof (NautilusSelectionCanvasItemDetails));
}
static void
nautilus_selection_canvas_item_init (NautilusSelectionCanvasItem *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, NAUTILUS_TYPE_SELECTION_CANVAS_ITEM,
NautilusSelectionCanvasItemDetails);
}