struct FooScrollAreaPrivate

{

GdkWindow *input_window;

int width;

int height;

GtkAdjustment *hadj;

GtkAdjustment *vadj;

int x_offset;

int y_offset;

int min_width;

int min_height;

GPtrArray *input_regions;

AutoScrollInfo *auto_scroll_info;

InputRegion *current_input;

gboolean grabbed;

FooScrollAreaEventFunc grab_func;

gpointer grab_data;

foo_scroll_area_map (GtkWidget *widget)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

GTK_WIDGET_CLASS (parent_class)->map (widget);

if (area->priv->input_window)

gdk_window_show (area->priv->input_window);

}

foo_scroll_area_unmap (GtkWidget *widget)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

if (area->priv->input_window)

gdk_window_hide (area->priv->input_window);

GTK_WIDGET_CLASS (parent_class)->unmap (widget);

}

foo_scroll_area_finalize (GObject *object)

{

FooScrollArea *scroll_area = FOO_SCROLL_AREA (object);

g_object_unref (scroll_area->priv->hadj);

g_object_unref (scroll_area->priv->vadj);

g_ptr_array_free (scroll_area->priv->input_regions, TRUE);

g_free (scroll_area->priv);

G_OBJECT_CLASS (foo_scroll_area_parent_class)->finalize (object);

{

GObjectClass *object_class = G_OBJECT_CLASS (class);

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);

object_class->finalize = foo_scroll_area_finalize;

object_class->set_property = foo_scroll_area_set_property;

object_class->get_property = foo_scroll_area_get_property;

G_TYPE_NONE, 2,

GDK_TYPE_RECTANGLE,

GDK_TYPE_RECTANGLE);

signals[PAINT] =

g_signal_new ("paint",

G_OBJECT_CLASS_TYPE (object_class),

gtk_widget_set_has_window (widget, FALSE);

gtk_widget_set_redraw_on_allocate (widget, FALSE);

scroll_area->priv = g_new0 (FooScrollAreaPrivate, 1);

scroll_area->priv->width = 0;

scroll_area->priv->height = 0;

gpointer user_data)

{

int i;

for (i = 0; i < path->num_data; i += path->data[i].header.length)

{

cairo_path_data_t *data = &(path->data[i]);

switch (data->header.type)

{

case CAIRO_PATH_MOVE_TO:

case CAIRO_PATH_LINE_TO:

func (&(data[1].point.x), &(data[1].point.y), user_data);

break;

case CAIRO_PATH_CURVE_TO:

func (&(data[1].point.x), &(data[1].point.y), user_data);

func (&(data[2].point.x), &(data[2].point.y), user_data);

func (&(data[3].point.x), &(data[3].point.y), user_data);

break;

case CAIRO_PATH_CLOSE_PATH:

break;

}

allocation_to_canvas (area, &allocation.x, &allocation.y);

viewport = cairo_region_create_rectangle (&allocation);

cairo_region_subtract (viewport, exposed);

for (i = 0; i < area->priv->input_regions->len; ++i)

{

InputRegion *region = area->priv->input_regions->pdata[i];

GdkRectangle *viewport)

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

if (!viewport)

return;

get_viewport (scroll_area, viewport);

}

GdkDevice *pointer;

int px, py;

new_viewport, old_viewport);

if (scroll_area->priv->input_window == NULL)

&px,

&py,

NULL);

process_event (scroll_area, FOO_MOTION, px, py);

}

GtkAdjustment *hadj = scroll_area->priv->hadj;

GtkAdjustment *vadj = scroll_area->priv->vadj;

/* Horizontal */

gtk_widget_get_allocation (GTK_WIDGET (scroll_area), &allocation);

g_object_freeze_notify (G_OBJECT (hadj));

gtk_adjustment_set_lower (hadj, 0.0);

gtk_adjustment_set_upper (hadj, scroll_area->priv->width);

g_object_thaw_notify (G_OBJECT (hadj));

/* Vertical */

g_object_freeze_notify (G_OBJECT (vadj));

gtk_adjustment_set_page_size (vadj, allocation.height);

clamp_adjustment (hadj);

clamp_adjustment (vadj);

return TRUE;

}

gtk_widget_get_allocation (widget, &widget_allocation);

gtk_widget_set_realized (widget, TRUE);

attributes.window_type = GDK_WINDOW_CHILD;

attributes.x = widget_allocation.x;

attributes.y = widget_allocation.y;

GDK_POINTER_MOTION_MASK |

GDK_ENTER_NOTIFY_MASK |

GDK_LEAVE_NOTIFY_MASK);

attributes_mask = GDK_WA_X | GDK_WA_Y;

window = gtk_widget_get_parent_window (widget);

gtk_widget_set_window (widget, window);

g_object_ref (window);

area->priv->input_window = gdk_window_new (window,

&attributes, attributes_mask);

cr = gdk_cairo_create (gtk_widget_get_window (widget));

cairo_destroy (cr);

gdk_window_set_user_data (area->priv->input_window, area);

gtk_widget_style_attach (widget);

}

foo_scroll_area_unrealize (GtkWidget *widget)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

if (area->priv->input_window)

{

gdk_window_set_user_data (area->priv->input_window, NULL);

gdk_window_destroy (area->priv->input_window);

area->priv->input_window = NULL;

}

GTK_WIDGET_CLASS (parent_class)->unrealize (widget);

}

return new;

}

static void

allocation_to_canvas_region (FooScrollArea *area,

cairo_region_t *region)

cairo_region_destroy (invalid);

gtk_widget_set_allocation (widget, allocation);

if (scroll_area->priv->input_window)

{

cairo_surface_t *new_surface;

cairo_surface_destroy (scroll_area->priv->surface);

scroll_area->priv->surface = new_surface;

}

get_viewport (scroll_area, &new_viewport);

emit_viewport_changed (scroll_area, &new_viewport, &old_viewport);

}

gpointer data)

{

FooScrollAreaEvent event;

if (!func)

return;

if (type != FOO_MOTION)

emit_input (scroll_area, FOO_MOTION, x, y, func, data);

event.type = type;

event.x = x;

event.y = y;

func (scroll_area, &event, data);

}

int i;

allocation_to_canvas (scroll_area, &x, &y);

if (scroll_area->priv->grabbed)

{

emit_input (scroll_area, input_type, x, y,

inside = cairo_in_fill (cr, x, y);

cairo_destroy (cr);

if (inside)

{

emit_input (scroll_area, input_type,

path->data);

return;

}

path = path->next;

}

GdkEvent *event)

{

FooScrollAreaEventType input_type;

if (event->type == GDK_BUTTON_PRESS)

input_type = FOO_BUTTON_PRESS;

else if (event->type == GDK_BUTTON_RELEASE)

input_type = FOO_MOTION;

else

return;

process_event (scroll_area, input_type, x, y);

}

GdkEventButton *event)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

process_gdk_event (area, event->x, event->y, (GdkEvent *)event);

return TRUE;

}

GdkEventButton *event)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

process_gdk_event (area, event->x, event->y, (GdkEvent *)event);

return FALSE;

}

GdkEventMotion *event)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

process_gdk_event (area, event->x, event->y, (GdkEvent *)event);

return TRUE;

}

g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj));

gtk_adjustment_set_value (scroll_area->priv->vadj, new_y);

set_adjustment_values (scroll_area);

g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj));

}

int height)

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

/* FIXME: Default scroll algorithm should probably be to

* keep the same *area* outside the screen as before.

*

* Maybe there should be some generic support for those

* widgets. Can that even be done?

*

* fixed points?

*/

scroll_area->priv->width = width;

scroll_area->priv->height = height;

set_adjustment_values (scroll_area);

}

static void

foo_scroll_area_scroll (FooScrollArea *area,

gint dy)

{

GdkRectangle allocation;

src_area.y -= dy;

invalid_region = cairo_region_create_rectangle (&allocation);

if (gdk_rectangle_intersect (&allocation, &src_area, &move_area))

{

cairo_region_t *move_region;

cairo_destroy (cr);

gtk_widget_queue_draw (GTK_WIDGET (area));

move_region = cairo_region_create_rectangle (&move_area);

cairo_region_translate (move_region, dx, dy);

cairo_region_subtract (invalid_region, move_region);

cairo_region_destroy (move_region);

}

allocation_to_canvas_region (area, invalid_region);

foo_scroll_area_invalidate_region (area, invalid_region);

cairo_region_destroy (invalid_region);

}

gint dx = 0;

gint dy = 0;

GdkRectangle old_viewport, new_viewport;

get_viewport (scroll_area, &old_viewport);

if (adj == scroll_area->priv->hadj)

{

/* FIXME: do we treat the offset as int or double, and,

{

g_assert_not_reached ();

}

if (gtk_widget_get_realized (widget))

{

foo_scroll_area_scroll (scroll_area, -dx, -dy);

}

get_viewport (scroll_area, &new_viewport);

emit_viewport_changed (scroll_area, &new_viewport, &old_viewport);

}

GtkAdjustment **location)

{

g_return_if_fail (location != NULL);

if (adjustment == *location)

return;

if (!adjustment)

adjustment = new_adjustment ();

g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));

if (*location)

{

g_signal_handlers_disconnect_by_func (

*location, foo_scrollbar_adjustment_changed, scroll_area);

g_object_unref (*location);

}

*location = adjustment;

g_object_ref_sink (*location);

g_signal_connect (*location, "value_changed",

G_CALLBACK (foo_scrollbar_adjustment_changed),

scroll_area);

{

scroll_area->priv->min_width = min_width;

scroll_area->priv->min_height = min_height;

/* FIXME: think through invalidation.

*

* Goals: - no repainting everything on size_allocate(),

gpointer data)

{

cairo_t *cr = data;

cairo_user_to_device (cr, x, y);

}

{

GtkAllocation allocation;

GtkWidget *widget = GTK_WIDGET (area);

gtk_widget_get_allocation (widget, &allocation);

cairo_region_translate (region,

-area->priv->x_offset + allocation.x,

if (gtk_widget_get_realized (widget))

{

canvas_to_window (area, region);

gdk_window_invalidate_region (gtk_widget_get_window (widget),

region, TRUE);

window_to_canvas (area, region);

}

}

{

GdkRectangle rect = { x, y, width, height };

cairo_region_t *region;

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

region = cairo_region_create_rectangle (&rect);

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

g_return_if_fail (!scroll_area->priv->grabbed);

scroll_area->priv->grabbed = TRUE;

scroll_area->priv->grab_func = func;

scroll_area->priv->grab_data = input_data;

/* FIXME: we should probably take a server grab */

/* Also, maybe there should be support for setting the grab cursor */

}

foo_scroll_area_end_grab (FooScrollArea *scroll_area)

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

scroll_area->priv->grabbed = FALSE;

scroll_area->priv->grab_func = NULL;

scroll_area->priv->grab_data = NULL;

g_source_remove (area->priv->auto_scroll_info->timeout_id);

g_timer_destroy (area->priv->auto_scroll_info->timer);

g_free (area->priv->auto_scroll_info);

area->priv->auto_scroll_info = NULL;

}

}

AutoScrollInfo *info = area->priv->auto_scroll_info;

int new_x, new_y;

double elapsed;

get_viewport (area, &viewport);

elapsed = g_timer_elapsed (info->timer, NULL);

info->res_x = elapsed * info->dx / 0.2;

info->res_y = elapsed * info->dy / 0.2;

new_x = viewport.x + info->res_x;

new_y = viewport.y + info->res_y;

info->res_y < -1.0))

{

stop_scrolling (area);

/* stop scrolling if it didn't have an effect */

return FALSE;

}

return TRUE;

}

g_idle_add (scroll_idle, area);

area->priv->auto_scroll_info->timer = g_timer_new ();

}

area->priv->auto_scroll_info->dx = dx;

area->priv->auto_scroll_info->dy = dy;

}

FooScrollAreaEvent *event)

{

GdkRectangle viewport;

get_viewport (scroll_area, &viewport);

if (rect_contains (&viewport, event->x, event->y))

{

stop_scrolling (scroll_area);

else

{

int dx, dy;

dx = dy = 0;

if (event->y < viewport.y)

{

dy = event->y - viewport.y;

dy = event->y - (viewport.y + viewport.height - 1);

dy = MAX (dy - 2, 0);

}

if (event->x < viewport.x)

{

dx = event->x - viewport.x;

dx = event->x - (viewport.x + viewport.width - 1);

dx = MAX (dx - 2, 0);

}

ensure_scrolling (scroll_area, dx, dy);

}

}

GtkWidget *panel_checkbox;

GtkWidget *clone_checkbox;

GtkWidget *show_icon_checkbox;

/* We store the event timestamp when the Apply button is clicked */

GtkWidget *apply_button;

* translation could be "Pantallas en Espejo", *not* "Espejar Pantallas".

*/

text = g_strdup_printf (_("Mirror Screens"));

else {

text = g_strdup_printf ("<b>%s</b>\n<small>%s</small>", mate_rr_output_info_get_display_name (output), mate_rr_output_info_get_name (output));

}