From 88df7df3a93920e62b6a2441e92513f0bc9004b0 Mon Sep 17 00:00:00 2001 From: William Jon McCann Date: Sat, 20 Nov 2010 18:30:40 -0500 Subject: [PATCH] display: use consistent indentation and spacing --- panels/display/scrollarea.c | 1386 ++++++++-------- panels/display/scrollarea.h | 42 +- panels/display/xrandr-capplet.c | 2626 +++++++++++++++---------------- 3 files changed, 2027 insertions(+), 2027 deletions(-) diff --git a/panels/display/scrollarea.c b/panels/display/scrollarea.c index 4e785bbe6..3262e516d 100644 --- a/panels/display/scrollarea.c +++ b/panels/display/scrollarea.c @@ -35,84 +35,84 @@ typedef struct AutoScrollInfo AutoScrollInfo; struct InputPath { - gboolean is_stroke; - cairo_fill_rule_t fill_rule; - double line_width; - cairo_path_t *path; /* In canvas coordinates */ + gboolean is_stroke; + cairo_fill_rule_t fill_rule; + double line_width; + cairo_path_t *path; /* In canvas coordinates */ - FooScrollAreaEventFunc func; - gpointer data; + FooScrollAreaEventFunc func; + gpointer data; - InputPath *next; + InputPath *next; }; /* InputRegions are mutually disjoint */ struct InputRegion { - /* the boundary of this area in canvas coordinates */ - cairo_region_t *region; + /* the boundary of this area in canvas coordinates */ + cairo_region_t *region; - InputPath *paths; + InputPath *paths; }; struct AutoScrollInfo { - int dx; - int dy; - int timeout_id; - int begin_x; - int begin_y; - double res_x; - double res_y; - GTimer *timer; + int dx; + int dy; + int timeout_id; + int begin_x; + int begin_y; + double res_x; + double res_y; + GTimer *timer; }; struct FooScrollAreaPrivate { - GdkWindow *input_window; + GdkWindow *input_window; - int width; - int height; + int width; + int height; - GtkAdjustment *hadj; - GtkAdjustment *vadj; - int x_offset; - int y_offset; + GtkAdjustment *hadj; + GtkAdjustment *vadj; + int x_offset; + int y_offset; - int min_width; - int min_height; + int min_width; + int min_height; - GPtrArray *input_regions; + GPtrArray *input_regions; - AutoScrollInfo *auto_scroll_info; + AutoScrollInfo *auto_scroll_info; - /* During expose, this region is set to the region - * being exposed. At other times, it is NULL - * - * It is used for clipping of input areas - */ - InputRegion *current_input; + /* During expose, this region is set to the region + * being exposed. At other times, it is NULL + * + * It is used for clipping of input areas + */ + InputRegion *current_input; - gboolean grabbed; - FooScrollAreaEventFunc grab_func; - gpointer grab_data; + gboolean grabbed; + FooScrollAreaEventFunc grab_func; + gpointer grab_data; - cairo_surface_t *surface; - cairo_region_t *update_region; /* In canvas coordinates */ + cairo_surface_t *surface; + cairo_region_t *update_region; /* In canvas coordinates */ }; enum -{ + { VIEWPORT_CHANGED, PAINT, INPUT, LAST_SIGNAL, -}; + }; enum { - PROP_0, - PROP_VADJUSTMENT, - PROP_HADJUSTMENT + PROP_0, + PROP_VADJUSTMENT, + PROP_HADJUSTMENT }; static guint signals [LAST_SIGNAL] = { 0 }; @@ -145,38 +145,38 @@ static gboolean foo_scroll_area_motion (GtkWidget *widget, static void foo_scroll_area_map (GtkWidget *widget) { - FooScrollArea *area = FOO_SCROLL_AREA (widget); + FooScrollArea *area = FOO_SCROLL_AREA (widget); - GTK_WIDGET_CLASS (parent_class)->map (widget); + GTK_WIDGET_CLASS (parent_class)->map (widget); - if (area->priv->input_window) - gdk_window_show (area->priv->input_window); + if (area->priv->input_window) + gdk_window_show (area->priv->input_window); } static void foo_scroll_area_unmap (GtkWidget *widget) { - FooScrollArea *area = FOO_SCROLL_AREA (widget); + FooScrollArea *area = FOO_SCROLL_AREA (widget); - if (area->priv->input_window) - gdk_window_hide (area->priv->input_window); + if (area->priv->input_window) + gdk_window_hide (area->priv->input_window); - GTK_WIDGET_CLASS (parent_class)->unmap (widget); + GTK_WIDGET_CLASS (parent_class)->unmap (widget); } static void foo_scroll_area_finalize (GObject *object) { - FooScrollArea *scroll_area = FOO_SCROLL_AREA (object); + FooScrollArea *scroll_area = FOO_SCROLL_AREA (object); - g_object_unref (scroll_area->priv->hadj); - g_object_unref (scroll_area->priv->vadj); + 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_ptr_array_free (scroll_area->priv->input_regions, TRUE); - g_free (scroll_area->priv); + g_free (scroll_area->priv); - G_OBJECT_CLASS (foo_scroll_area_parent_class)->finalize (object); + G_OBJECT_CLASS (foo_scroll_area_parent_class)->finalize (object); } static void @@ -206,99 +206,99 @@ foo_scroll_area_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - switch (property_id) { - case PROP_VADJUSTMENT: - foo_scroll_area_set_vadjustment (FOO_SCROLL_AREA (object), g_value_get_object (value)); - break; - case PROP_HADJUSTMENT: - foo_scroll_area_set_hadjustment (FOO_SCROLL_AREA (object), g_value_get_object (value)); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); - } + switch (property_id) { + case PROP_VADJUSTMENT: + foo_scroll_area_set_vadjustment (FOO_SCROLL_AREA (object), g_value_get_object (value)); + break; + case PROP_HADJUSTMENT: + foo_scroll_area_set_hadjustment (FOO_SCROLL_AREA (object), g_value_get_object (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } } static void foo_scroll_area_class_init (FooScrollAreaClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (class); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); + 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; + 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; - widget_class->get_preferred_width = foo_scroll_area_get_preferred_width; - widget_class->get_preferred_height = foo_scroll_area_get_preferred_height; - widget_class->draw = foo_scroll_area_draw; - widget_class->size_allocate = foo_scroll_area_size_allocate; - widget_class->realize = foo_scroll_area_realize; - widget_class->unrealize = foo_scroll_area_unrealize; - widget_class->button_press_event = foo_scroll_area_button_press; - widget_class->button_release_event = foo_scroll_area_button_release; - widget_class->motion_notify_event = foo_scroll_area_motion; - widget_class->map = foo_scroll_area_map; - widget_class->unmap = foo_scroll_area_unmap; + widget_class->get_preferred_width = foo_scroll_area_get_preferred_width; + widget_class->get_preferred_height = foo_scroll_area_get_preferred_height; + widget_class->draw = foo_scroll_area_draw; + widget_class->size_allocate = foo_scroll_area_size_allocate; + widget_class->realize = foo_scroll_area_realize; + widget_class->unrealize = foo_scroll_area_unrealize; + widget_class->button_press_event = foo_scroll_area_button_press; + widget_class->button_release_event = foo_scroll_area_button_release; + widget_class->motion_notify_event = foo_scroll_area_motion; + widget_class->map = foo_scroll_area_map; + widget_class->unmap = foo_scroll_area_unmap; - parent_class = g_type_class_peek_parent (class); + parent_class = g_type_class_peek_parent (class); - /* Scrollable interface properties */ - g_object_class_override_property (object_class, PROP_HADJUSTMENT, "hadjustment"); - g_object_class_override_property (object_class, PROP_VADJUSTMENT, "vadjustment"); + /* Scrollable interface properties */ + g_object_class_override_property (object_class, PROP_HADJUSTMENT, "hadjustment"); + g_object_class_override_property (object_class, PROP_VADJUSTMENT, "vadjustment"); - signals[VIEWPORT_CHANGED] = - g_signal_new ("viewport_changed", - G_OBJECT_CLASS_TYPE (object_class), - G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, - G_STRUCT_OFFSET (FooScrollAreaClass, - viewport_changed), - NULL, NULL, - foo_marshal_VOID__BOXED_BOXED, - G_TYPE_NONE, 2, - GDK_TYPE_RECTANGLE, - GDK_TYPE_RECTANGLE); + signals[VIEWPORT_CHANGED] = + g_signal_new ("viewport_changed", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (FooScrollAreaClass, + viewport_changed), + NULL, NULL, + foo_marshal_VOID__BOXED_BOXED, + G_TYPE_NONE, 2, + GDK_TYPE_RECTANGLE, + GDK_TYPE_RECTANGLE); - signals[PAINT] = - g_signal_new ("paint", - G_OBJECT_CLASS_TYPE (object_class), - G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, - G_STRUCT_OFFSET (FooScrollAreaClass, - paint), - NULL, NULL, - g_cclosure_marshal_VOID__POINTER, - G_TYPE_NONE, 1, - G_TYPE_POINTER); + signals[PAINT] = + g_signal_new ("paint", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (FooScrollAreaClass, + paint), + NULL, NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, 1, + G_TYPE_POINTER); } static GtkAdjustment * new_adjustment (void) { - return GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)); + return GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)); } static void foo_scroll_area_init (FooScrollArea *scroll_area) { - GtkWidget *widget; + GtkWidget *widget; - widget = GTK_WIDGET (scroll_area); + widget = GTK_WIDGET (scroll_area); - gtk_widget_set_has_window (widget, FALSE); - gtk_widget_set_redraw_on_allocate (widget, FALSE); + 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; - scroll_area->priv->hadj = g_object_ref_sink (new_adjustment()); - scroll_area->priv->vadj = g_object_ref_sink (new_adjustment()); - scroll_area->priv->x_offset = 0.0; - scroll_area->priv->y_offset = 0.0; - scroll_area->priv->min_width = -1; - scroll_area->priv->min_height = -1; - scroll_area->priv->auto_scroll_info = NULL; - scroll_area->priv->input_regions = g_ptr_array_new (); - scroll_area->priv->surface = NULL; - scroll_area->priv->update_region = cairo_region_create (); + scroll_area->priv = g_new0 (FooScrollAreaPrivate, 1); + scroll_area->priv->width = 0; + scroll_area->priv->height = 0; + scroll_area->priv->hadj = g_object_ref_sink (new_adjustment()); + scroll_area->priv->vadj = g_object_ref_sink (new_adjustment()); + scroll_area->priv->x_offset = 0.0; + scroll_area->priv->y_offset = 0.0; + scroll_area->priv->min_width = -1; + scroll_area->priv->min_height = -1; + scroll_area->priv->auto_scroll_info = NULL; + scroll_area->priv->input_regions = g_ptr_array_new (); + scroll_area->priv->surface = NULL; + scroll_area->priv->update_region = cairo_region_create (); } typedef void (* PathForeachFunc) (double *x, @@ -310,69 +310,69 @@ path_foreach_point (cairo_path_t *path, PathForeachFunc func, gpointer user_data) { - int i; + int i; - for (i = 0; i < path->num_data; i += path->data[i].header.length) + for (i = 0; i < path->num_data; i += path->data[i].header.length) { - cairo_path_data_t *data = &(path->data[i]); + cairo_path_data_t *data = &(path->data[i]); - switch (data->header.type) + 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; + 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; + 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; + break; } } } typedef struct { - double x1, y1, x2, y2; + double x1, y1, x2, y2; } Box; static void input_path_free_list (InputPath *paths) { - if (!paths) - return; + if (!paths) + return; - input_path_free_list (paths->next); - cairo_path_destroy (paths->path); - g_free (paths); + input_path_free_list (paths->next); + cairo_path_destroy (paths->path); + g_free (paths); } static void input_region_free (InputRegion *region) { - input_path_free_list (region->paths); - cairo_region_destroy (region->region); + input_path_free_list (region->paths); + cairo_region_destroy (region->region); - g_free (region); + g_free (region); } static void get_viewport (FooScrollArea *scroll_area, GdkRectangle *viewport) { - GtkAllocation allocation; - GtkWidget *widget = GTK_WIDGET (scroll_area); + GtkAllocation allocation; + GtkWidget *widget = GTK_WIDGET (scroll_area); - gtk_widget_get_allocation (widget, &allocation); + gtk_widget_get_allocation (widget, &allocation); - viewport->x = scroll_area->priv->x_offset; - viewport->y = scroll_area->priv->y_offset; - viewport->width = allocation.width; - viewport->height = allocation.height; + viewport->x = scroll_area->priv->x_offset; + viewport->y = scroll_area->priv->y_offset; + viewport->width = allocation.width; + viewport->height = allocation.height; } static void @@ -380,40 +380,40 @@ allocation_to_canvas (FooScrollArea *area, int *x, int *y) { - *x += area->priv->x_offset; - *y += area->priv->y_offset; + *x += area->priv->x_offset; + *y += area->priv->y_offset; } static void clear_exposed_input_region (FooScrollArea *area, cairo_region_t *exposed) /* in canvas coordinates */ { - int i; - cairo_region_t *viewport; - GdkRectangle allocation; + int i; + cairo_region_t *viewport; + GdkRectangle allocation; - gtk_widget_get_allocation (GTK_WIDGET (area), &allocation); - allocation.x = 0; - allocation.y = 0; - allocation_to_canvas (area, &allocation.x, &allocation.y); + gtk_widget_get_allocation (GTK_WIDGET (area), &allocation); + allocation.x = 0; + allocation.y = 0; + allocation_to_canvas (area, &allocation.x, &allocation.y); - viewport = cairo_region_create_rectangle (&allocation); - cairo_region_subtract (viewport, exposed); + viewport = cairo_region_create_rectangle (&allocation); + cairo_region_subtract (viewport, exposed); - for (i = 0; i < area->priv->input_regions->len; ++i) + for (i = 0; i < area->priv->input_regions->len; ++i) { - InputRegion *region = area->priv->input_regions->pdata[i]; + InputRegion *region = area->priv->input_regions->pdata[i]; - cairo_region_intersect (region->region, viewport); + cairo_region_intersect (region->region, viewport); - if (cairo_region_is_empty (region->region)) + if (cairo_region_is_empty (region->region)) { - input_region_free (region); - g_ptr_array_remove_index_fast (area->priv->input_regions, i--); + input_region_free (region); + g_ptr_array_remove_index_fast (area->priv->input_regions, i--); } } - cairo_region_destroy (viewport); + cairo_region_destroy (viewport); } /* taken from mutter */ @@ -443,72 +443,72 @@ static void initialize_background (GtkWidget *widget, cairo_t *cr) { - setup_background_cr (gtk_widget_get_window (widget), cr, 0, 0); + setup_background_cr (gtk_widget_get_window (widget), cr, 0, 0); - cairo_paint (cr); + cairo_paint (cr); } static gboolean foo_scroll_area_draw (GtkWidget *widget, cairo_t *cr) { - FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); - cairo_region_t *region; - int x_offset, y_offset; - GtkAllocation widget_allocation; + FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); + cairo_region_t *region; + int x_offset, y_offset; + GtkAllocation widget_allocation; - /* Note that this function can be called at a time - * where the adj->value is different from x_offset. - * Ie., the GtkScrolledWindow changed the adj->value - * without emitting the value_changed signal. - * - * Hence we must always use the value we got - * the last time the signal was emitted, ie., - * priv->{x,y}_offset. - */ - x_offset = scroll_area->priv->x_offset; - y_offset = scroll_area->priv->y_offset; + /* Note that this function can be called at a time + * where the adj->value is different from x_offset. + * Ie., the GtkScrolledWindow changed the adj->value + * without emitting the value_changed signal. + * + * Hence we must always use the value we got + * the last time the signal was emitted, ie., + * priv->{x,y}_offset. + */ + x_offset = scroll_area->priv->x_offset; + y_offset = scroll_area->priv->y_offset; - /* Setup input areas */ - clear_exposed_input_region (scroll_area, scroll_area->priv->update_region); + /* Setup input areas */ + clear_exposed_input_region (scroll_area, scroll_area->priv->update_region); - scroll_area->priv->current_input = g_new0 (InputRegion, 1); - scroll_area->priv->current_input->region = cairo_region_copy (scroll_area->priv->update_region); - scroll_area->priv->current_input->paths = NULL; - g_ptr_array_add (scroll_area->priv->input_regions, - scroll_area->priv->current_input); + scroll_area->priv->current_input = g_new0 (InputRegion, 1); + scroll_area->priv->current_input->region = cairo_region_copy (scroll_area->priv->update_region); + scroll_area->priv->current_input->paths = NULL; + g_ptr_array_add (scroll_area->priv->input_regions, + scroll_area->priv->current_input); - region = scroll_area->priv->update_region; - scroll_area->priv->update_region = cairo_region_create (); + region = scroll_area->priv->update_region; + scroll_area->priv->update_region = cairo_region_create (); - initialize_background (widget, cr); + initialize_background (widget, cr); - g_signal_emit (widget, signals[PAINT], 0, cr); + g_signal_emit (widget, signals[PAINT], 0, cr); - scroll_area->priv->current_input = NULL; + scroll_area->priv->current_input = NULL; - gtk_widget_get_allocation (widget, &widget_allocation); + gtk_widget_get_allocation (widget, &widget_allocation); - /* Finally draw the backing surface */ - cairo_set_source_surface (cr, scroll_area->priv->surface, - widget_allocation.x, widget_allocation.y); - cairo_fill (cr); + /* Finally draw the backing surface */ + cairo_set_source_surface (cr, scroll_area->priv->surface, + widget_allocation.x, widget_allocation.y); + cairo_fill (cr); - cairo_region_destroy (region); + cairo_region_destroy (region); - return TRUE; + return TRUE; } void foo_scroll_area_get_viewport (FooScrollArea *scroll_area, GdkRectangle *viewport) { - g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); + g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); - if (!viewport) - return; + if (!viewport) + return; - get_viewport (scroll_area, viewport); + get_viewport (scroll_area, viewport); } static void @@ -522,167 +522,167 @@ emit_viewport_changed (FooScrollArea *scroll_area, GdkRectangle *new_viewport, GdkRectangle *old_viewport) { - int px, py; - g_signal_emit (scroll_area, signals[VIEWPORT_CHANGED], 0, - new_viewport, old_viewport); + int px, py; + g_signal_emit (scroll_area, signals[VIEWPORT_CHANGED], 0, + new_viewport, old_viewport); - gdk_window_get_pointer (scroll_area->priv->input_window, &px, &py, NULL); + gdk_window_get_pointer (scroll_area->priv->input_window, &px, &py, NULL); #if 0 - g_print ("procc\n"); + g_print ("procc\n"); #endif - process_event (scroll_area, FOO_MOTION, px, py); + process_event (scroll_area, FOO_MOTION, px, py); } static void clamp_adjustment (GtkAdjustment *adj) { - if (gtk_adjustment_get_upper (adj) >= gtk_adjustment_get_page_size (adj)) - gtk_adjustment_set_value (adj, CLAMP (gtk_adjustment_get_value (adj), 0.0, - gtk_adjustment_get_upper (adj) - - gtk_adjustment_get_page_size (adj))); - else - gtk_adjustment_set_value (adj, 0.0); + if (gtk_adjustment_get_upper (adj) >= gtk_adjustment_get_page_size (adj)) + gtk_adjustment_set_value (adj, CLAMP (gtk_adjustment_get_value (adj), 0.0, + gtk_adjustment_get_upper (adj) + - gtk_adjustment_get_page_size (adj))); + else + gtk_adjustment_set_value (adj, 0.0); - gtk_adjustment_changed (adj); + gtk_adjustment_changed (adj); } static gboolean set_adjustment_values (FooScrollArea *scroll_area) { - GtkAllocation allocation; + GtkAllocation allocation; - GtkAdjustment *hadj = scroll_area->priv->hadj; - GtkAdjustment *vadj = scroll_area->priv->vadj; + 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_page_size (hadj, allocation.width); - gtk_adjustment_set_step_increment (hadj, 0.1 * allocation.width); - gtk_adjustment_set_page_increment (hadj, 0.9 * allocation.width); - gtk_adjustment_set_lower (hadj, 0.0); - gtk_adjustment_set_upper (hadj, scroll_area->priv->width); - g_object_thaw_notify (G_OBJECT (hadj)); + /* Horizontal */ + gtk_widget_get_allocation (GTK_WIDGET (scroll_area), &allocation); + g_object_freeze_notify (G_OBJECT (hadj)); + gtk_adjustment_set_page_size (hadj, allocation.width); + gtk_adjustment_set_step_increment (hadj, 0.1 * allocation.width); + gtk_adjustment_set_page_increment (hadj, 0.9 * allocation.width); + 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); - gtk_adjustment_set_step_increment (vadj, 0.1 * allocation.height); - gtk_adjustment_set_page_increment (vadj, 0.9 * allocation.height); - gtk_adjustment_set_lower (vadj, 0.0); - gtk_adjustment_set_upper (vadj, scroll_area->priv->height); - g_object_thaw_notify (G_OBJECT (vadj)); + /* Vertical */ + g_object_freeze_notify (G_OBJECT (vadj)); + gtk_adjustment_set_page_size (vadj, allocation.height); + gtk_adjustment_set_step_increment (vadj, 0.1 * allocation.height); + gtk_adjustment_set_page_increment (vadj, 0.9 * allocation.height); + gtk_adjustment_set_lower (vadj, 0.0); + gtk_adjustment_set_upper (vadj, scroll_area->priv->height); + g_object_thaw_notify (G_OBJECT (vadj)); - clamp_adjustment (hadj); - clamp_adjustment (vadj); + clamp_adjustment (hadj); + clamp_adjustment (vadj); - return TRUE; + return TRUE; } static void foo_scroll_area_realize (GtkWidget *widget) { - FooScrollArea *area = FOO_SCROLL_AREA (widget); - GdkWindowAttr attributes; - GtkAllocation widget_allocation; - GdkWindow *window; - gint attributes_mask; - cairo_t *cr; + FooScrollArea *area = FOO_SCROLL_AREA (widget); + GdkWindowAttr attributes; + GtkAllocation widget_allocation; + GdkWindow *window; + gint attributes_mask; + cairo_t *cr; - gtk_widget_get_allocation (widget, &widget_allocation); - gtk_widget_set_realized (widget, 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; - attributes.width = widget_allocation.width; - attributes.height = widget_allocation.height; - attributes.wclass = GDK_INPUT_ONLY; - attributes.event_mask = gtk_widget_get_events (widget); - attributes.event_mask |= (GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_BUTTON1_MOTION_MASK | - GDK_BUTTON2_MOTION_MASK | - GDK_BUTTON3_MOTION_MASK | - GDK_POINTER_MOTION_MASK | - GDK_ENTER_NOTIFY_MASK | - GDK_LEAVE_NOTIFY_MASK); + attributes.window_type = GDK_WINDOW_CHILD; + attributes.x = widget_allocation.x; + attributes.y = widget_allocation.y; + attributes.width = widget_allocation.width; + attributes.height = widget_allocation.height; + attributes.wclass = GDK_INPUT_ONLY; + attributes.event_mask = gtk_widget_get_events (widget); + attributes.event_mask |= (GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_BUTTON1_MOTION_MASK | + GDK_BUTTON2_MOTION_MASK | + GDK_BUTTON3_MOTION_MASK | + GDK_POINTER_MOTION_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK); - attributes_mask = GDK_WA_X | GDK_WA_Y; + 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); + 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); + area->priv->input_window = gdk_window_new (window, + &attributes, attributes_mask); - cr = gdk_cairo_create (gtk_widget_get_window (widget)); - area->priv->surface = cairo_surface_create_similar (cairo_get_target (cr), - CAIRO_CONTENT_COLOR, - widget_allocation.width, - widget_allocation.height); - cairo_destroy (cr); + cr = gdk_cairo_create (gtk_widget_get_window (widget)); + area->priv->surface = cairo_surface_create_similar (cairo_get_target (cr), + CAIRO_CONTENT_COLOR, + widget_allocation.width, + widget_allocation.height); + cairo_destroy (cr); - gdk_window_set_user_data (area->priv->input_window, area); + gdk_window_set_user_data (area->priv->input_window, area); - gtk_widget_style_attach (widget); + gtk_widget_style_attach (widget); } static void foo_scroll_area_unrealize (GtkWidget *widget) { - FooScrollArea *area = FOO_SCROLL_AREA (widget); + FooScrollArea *area = FOO_SCROLL_AREA (widget); - if (area->priv->input_window) + 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; + 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); + GTK_WIDGET_CLASS (parent_class)->unrealize (widget); } static cairo_surface_t * create_new_surface (GtkWidget *widget, cairo_surface_t *old) { - GtkAllocation widget_allocation; - cairo_surface_t *new; - cairo_t *cr; + GtkAllocation widget_allocation; + cairo_surface_t *new; + cairo_t *cr; - gtk_widget_get_allocation (widget, &widget_allocation); - cr = gdk_cairo_create (gtk_widget_get_window (widget)); - new = cairo_surface_create_similar (cairo_get_target (cr), - CAIRO_CONTENT_COLOR, - widget_allocation.width, - widget_allocation.height); - cairo_destroy (cr); + gtk_widget_get_allocation (widget, &widget_allocation); + cr = gdk_cairo_create (gtk_widget_get_window (widget)); + new = cairo_surface_create_similar (cairo_get_target (cr), + CAIRO_CONTENT_COLOR, + widget_allocation.width, + widget_allocation.height); + cairo_destroy (cr); - /* Unfortunately we don't know in which direction we were resized, - * so we just assume we were dragged from the south-east corner. - * - * Although, maybe we could get the root coordinates of the input-window? - * That might just work, actually. We need to make sure metacity uses - * static gravity for the window before this will be useful. - */ - cr = cairo_create (new); - cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); - cairo_set_source_surface (cr, old, 0, 0); - cairo_paint (cr); - cairo_destroy (cr); + /* Unfortunately we don't know in which direction we were resized, + * so we just assume we were dragged from the south-east corner. + * + * Although, maybe we could get the root coordinates of the input-window? + * That might just work, actually. We need to make sure metacity uses + * static gravity for the window before this will be useful. + */ + cr = cairo_create (new); + cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); + cairo_set_source_surface (cr, old, 0, 0); + cairo_paint (cr); + cairo_destroy (cr); - return new; + return new; } static void allocation_to_canvas_region (FooScrollArea *area, cairo_region_t *region) { - cairo_region_translate (region, area->priv->x_offset, area->priv->y_offset); + cairo_region_translate (region, area->priv->x_offset, area->priv->y_offset); } static void @@ -705,49 +705,49 @@ static void foo_scroll_area_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { - FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); - GdkRectangle new_viewport; - GdkRectangle old_viewport; - cairo_region_t *old_allocation; - cairo_region_t *invalid; - GtkAllocation widget_allocation; + FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); + GdkRectangle new_viewport; + GdkRectangle old_viewport; + cairo_region_t *old_allocation; + cairo_region_t *invalid; + GtkAllocation widget_allocation; - get_viewport (scroll_area, &old_viewport); + get_viewport (scroll_area, &old_viewport); - gtk_widget_get_allocation (widget, &widget_allocation); + gtk_widget_get_allocation (widget, &widget_allocation); - old_allocation = cairo_region_create_rectangle (&widget_allocation); - cairo_region_translate (old_allocation, - -widget_allocation.x, -widget_allocation.y); + old_allocation = cairo_region_create_rectangle (&widget_allocation); + cairo_region_translate (old_allocation, + -widget_allocation.x, -widget_allocation.y); - invalid = cairo_region_create_rectangle (allocation); - cairo_region_translate (invalid, -allocation->x, -allocation->y); - _cairo_region_xor (invalid, old_allocation); - allocation_to_canvas_region (scroll_area, invalid); - foo_scroll_area_invalidate_region (scroll_area, invalid); + invalid = cairo_region_create_rectangle (allocation); + cairo_region_translate (invalid, -allocation->x, -allocation->y); + _cairo_region_xor (invalid, old_allocation); + allocation_to_canvas_region (scroll_area, invalid); + foo_scroll_area_invalidate_region (scroll_area, invalid); - cairo_region_destroy (old_allocation); - cairo_region_destroy (invalid); + cairo_region_destroy (old_allocation); + cairo_region_destroy (invalid); - gtk_widget_set_allocation (widget, allocation); + gtk_widget_set_allocation (widget, allocation); - if (scroll_area->priv->input_window) + if (scroll_area->priv->input_window) { - cairo_surface_t *new_surface; + cairo_surface_t *new_surface; - gdk_window_move_resize (scroll_area->priv->input_window, - allocation->x, allocation->y, - allocation->width, allocation->height); + gdk_window_move_resize (scroll_area->priv->input_window, + allocation->x, allocation->y, + allocation->width, allocation->height); - new_surface = create_new_surface (widget, scroll_area->priv->surface); - cairo_surface_destroy (scroll_area->priv->surface); + new_surface = create_new_surface (widget, scroll_area->priv->surface); + cairo_surface_destroy (scroll_area->priv->surface); - scroll_area->priv->surface = new_surface; + scroll_area->priv->surface = new_surface; } - get_viewport (scroll_area, &new_viewport); + get_viewport (scroll_area, &new_viewport); - emit_viewport_changed (scroll_area, &new_viewport, &old_viewport); + emit_viewport_changed (scroll_area, &new_viewport, &old_viewport); } static void @@ -758,19 +758,19 @@ emit_input (FooScrollArea *scroll_area, FooScrollAreaEventFunc func, gpointer data) { - FooScrollAreaEvent event; + FooScrollAreaEvent event; - if (!func) - return; + if (!func) + return; - if (type != FOO_MOTION) - emit_input (scroll_area, FOO_MOTION, x, y, func, data); + if (type != FOO_MOTION) + emit_input (scroll_area, FOO_MOTION, x, y, func, data); - event.type = type; - event.x = x; - event.y = y; + event.type = type; + event.x = x; + event.y = y; - func (scroll_area, &event, data); + func (scroll_area, &event, data); } static void @@ -779,71 +779,71 @@ process_event (FooScrollArea *scroll_area, int x, int y) { - GtkWidget *widget = GTK_WIDGET (scroll_area); - int i; + GtkWidget *widget = GTK_WIDGET (scroll_area); + int i; - allocation_to_canvas (scroll_area, &x, &y); + allocation_to_canvas (scroll_area, &x, &y); - if (scroll_area->priv->grabbed) + if (scroll_area->priv->grabbed) { - emit_input (scroll_area, input_type, x, y, - scroll_area->priv->grab_func, - scroll_area->priv->grab_data); - return; + emit_input (scroll_area, input_type, x, y, + scroll_area->priv->grab_func, + scroll_area->priv->grab_data); + return; } #if 0 - g_print ("number of input regions: %d\n", scroll_area->priv->input_regions->len); + g_print ("number of input regions: %d\n", scroll_area->priv->input_regions->len); #endif - for (i = 0; i < scroll_area->priv->input_regions->len; ++i) + for (i = 0; i < scroll_area->priv->input_regions->len; ++i) { - InputRegion *region = scroll_area->priv->input_regions->pdata[i]; + InputRegion *region = scroll_area->priv->input_regions->pdata[i]; #if 0 - g_print ("region %d (looking for %d,%d) ", i, x, y); + g_print ("region %d (looking for %d,%d) ", i, x, y); #endif - if (cairo_region_contains_point (region->region, x, y)) + if (cairo_region_contains_point (region->region, x, y)) { - InputPath *path; + InputPath *path; - path = region->paths; - while (path) + path = region->paths; + while (path) { - cairo_t *cr; - gboolean inside; + cairo_t *cr; + gboolean inside; - cr = gdk_cairo_create (gtk_widget_get_window (widget)); - cairo_set_fill_rule (cr, path->fill_rule); - cairo_set_line_width (cr, path->line_width); - cairo_append_path (cr, path->path); + cr = gdk_cairo_create (gtk_widget_get_window (widget)); + cairo_set_fill_rule (cr, path->fill_rule); + cairo_set_line_width (cr, path->line_width); + cairo_append_path (cr, path->path); - if (path->is_stroke) - inside = cairo_in_stroke (cr, x, y); - else - inside = cairo_in_fill (cr, x, y); + if (path->is_stroke) + inside = cairo_in_stroke (cr, x, y); + else + inside = cairo_in_fill (cr, x, y); - cairo_destroy (cr); + cairo_destroy (cr); - if (inside) + if (inside) { - emit_input (scroll_area, input_type, - x, y, - path->func, - path->data); - return; + emit_input (scroll_area, input_type, + x, y, + path->func, + path->data); + return; } - path = path->next; + path = path->next; } - /* Since the regions are all disjoint, no other region - * can match. Of course we could be clever and try and - * sort the regions, but so far I have been unable to - * make this loop show up on a profile. - */ - return; + /* Since the regions are all disjoint, no other region + * can match. Of course we could be clever and try and + * sort the regions, but so far I have been unable to + * make this loop show up on a profile. + */ + return; } } } @@ -854,50 +854,50 @@ process_gdk_event (FooScrollArea *scroll_area, int y, GdkEvent *event) { - FooScrollAreaEventType input_type; + FooScrollAreaEventType input_type; - if (event->type == GDK_BUTTON_PRESS) - input_type = FOO_BUTTON_PRESS; - else if (event->type == GDK_BUTTON_RELEASE) - input_type = FOO_BUTTON_RELEASE; - else if (event->type == GDK_MOTION_NOTIFY) - input_type = FOO_MOTION; - else - return; + if (event->type == GDK_BUTTON_PRESS) + input_type = FOO_BUTTON_PRESS; + else if (event->type == GDK_BUTTON_RELEASE) + input_type = FOO_BUTTON_RELEASE; + else if (event->type == GDK_MOTION_NOTIFY) + input_type = FOO_MOTION; + else + return; - process_event (scroll_area, input_type, x, y); + process_event (scroll_area, input_type, x, y); } static gboolean foo_scroll_area_button_press (GtkWidget *widget, GdkEventButton *event) { - FooScrollArea *area = FOO_SCROLL_AREA (widget); + FooScrollArea *area = FOO_SCROLL_AREA (widget); - process_gdk_event (area, event->x, event->y, (GdkEvent *)event); + process_gdk_event (area, event->x, event->y, (GdkEvent *)event); - return TRUE; + return TRUE; } static gboolean foo_scroll_area_button_release (GtkWidget *widget, GdkEventButton *event) { - FooScrollArea *area = FOO_SCROLL_AREA (widget); + FooScrollArea *area = FOO_SCROLL_AREA (widget); - process_gdk_event (area, event->x, event->y, (GdkEvent *)event); + process_gdk_event (area, event->x, event->y, (GdkEvent *)event); - return FALSE; + return FALSE; } static gboolean foo_scroll_area_motion (GtkWidget *widget, GdkEventMotion *event) { - FooScrollArea *area = FOO_SCROLL_AREA (widget); + FooScrollArea *area = FOO_SCROLL_AREA (widget); - process_gdk_event (area, event->x, event->y, (GdkEvent *)event); - return TRUE; + process_gdk_event (area, event->x, event->y, (GdkEvent *)event); + return TRUE; } void @@ -907,17 +907,17 @@ foo_scroll_area_set_size_fixed_y (FooScrollArea *scroll_area, int old_y, int new_y) { - scroll_area->priv->width = width; - scroll_area->priv->height = height; + scroll_area->priv->width = width; + scroll_area->priv->height = height; #if 0 - g_print ("diff: %d\n", new_y - old_y); + g_print ("diff: %d\n", new_y - old_y); #endif - g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj)); - gtk_adjustment_set_value (scroll_area->priv->vadj, new_y); + 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)); + set_adjustment_values (scroll_area); + g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj)); } void @@ -925,27 +925,27 @@ foo_scroll_area_set_size (FooScrollArea *scroll_area, int width, int height) { - g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); + 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. - * - * For wrapper widgets that will do something roughly - * right. For widgets that don't change size, it - * will do the right thing. Except for idle-layouting - * widgets. - * - * Maybe there should be some generic support for those - * widgets. Can that even be done? - * - * Should we have a version of this function using - * fixed points? - */ + /* FIXME: Default scroll algorithm should probably be to + * keep the same *area* outside the screen as before. + * + * For wrapper widgets that will do something roughly + * right. For widgets that don't change size, it + * will do the right thing. Except for idle-layouting + * widgets. + * + * Maybe there should be some generic support for those + * widgets. Can that even be done? + * + * Should we have a version of this function using + * fixed points? + */ - scroll_area->priv->width = width; - scroll_area->priv->height = height; + scroll_area->priv->width = width; + scroll_area->priv->height = height; - set_adjustment_values (scroll_area); + set_adjustment_values (scroll_area); } static void @@ -953,14 +953,14 @@ foo_scroll_area_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural) { - FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); + FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); - if (minimum != NULL) { - *minimum = scroll_area->priv->min_width; - } - if (natural != NULL) { - *natural = scroll_area->priv->min_width; - } + if (minimum != NULL) { + *minimum = scroll_area->priv->min_width; + } + if (natural != NULL) { + *natural = scroll_area->priv->min_width; + } } static void @@ -968,14 +968,14 @@ foo_scroll_area_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) { - FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); + FooScrollArea *scroll_area = FOO_SCROLL_AREA (widget); - if (minimum != NULL) { - *minimum = scroll_area->priv->min_height; - } - if (natural != NULL) { - *natural = scroll_area->priv->min_height; - } + if (minimum != NULL) { + *minimum = scroll_area->priv->min_height; + } + if (natural != NULL) { + *natural = scroll_area->priv->min_height; + } } static void @@ -983,106 +983,106 @@ foo_scroll_area_scroll (FooScrollArea *area, gint dx, gint dy) { - GdkRectangle allocation; - GdkRectangle src_area; - GdkRectangle move_area; - cairo_region_t *invalid_region; + GdkRectangle allocation; + GdkRectangle src_area; + GdkRectangle move_area; + cairo_region_t *invalid_region; - gtk_widget_get_allocation (GTK_WIDGET (area), &allocation); - allocation.x = 0; - allocation.y = 0; + gtk_widget_get_allocation (GTK_WIDGET (area), &allocation); + allocation.x = 0; + allocation.y = 0; - src_area = allocation; - src_area.x -= dx; - src_area.y -= dy; + src_area = allocation; + src_area.x -= dx; + src_area.y -= dy; - invalid_region = cairo_region_create_rectangle (&allocation); + invalid_region = cairo_region_create_rectangle (&allocation); - if (gdk_rectangle_intersect (&allocation, &src_area, &move_area)) + if (gdk_rectangle_intersect (&allocation, &src_area, &move_area)) { - cairo_region_t *move_region; - cairo_t *cr; + cairo_region_t *move_region; + cairo_t *cr; #if 0 - g_print ("scrolling %d %d %d %d (%d %d)\n", - move_area.x, move_area.y, - move_area.width, move_area.height, - dx, dy); + g_print ("scrolling %d %d %d %d (%d %d)\n", + move_area.x, move_area.y, + move_area.width, move_area.height, + dx, dy); #endif - cr = cairo_create (area->priv->surface); + cr = cairo_create (area->priv->surface); - /* Cairo doesn't allow self-copies, so we do this little trick instead: - * 1) Clip so the group size is small. - * 2) Call push_group() which creates a temporary pixmap as a workaround - */ - gdk_cairo_rectangle (cr, &move_area); - cairo_clip (cr); - cairo_push_group (cr); + /* Cairo doesn't allow self-copies, so we do this little trick instead: + * 1) Clip so the group size is small. + * 2) Call push_group() which creates a temporary pixmap as a workaround + */ + gdk_cairo_rectangle (cr, &move_area); + cairo_clip (cr); + cairo_push_group (cr); - cairo_set_source_surface (cr, area->priv->surface, dx, dy); - gdk_cairo_rectangle (cr, &move_area); - cairo_fill (cr); + cairo_set_source_surface (cr, area->priv->surface, dx, dy); + gdk_cairo_rectangle (cr, &move_area); + cairo_fill (cr); - cairo_pop_group_to_source (cr); - cairo_paint (cr); + cairo_pop_group_to_source (cr); + cairo_paint (cr); - cairo_destroy (cr); + cairo_destroy (cr); - gtk_widget_queue_draw (GTK_WIDGET (area)); + 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); + 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); + allocation_to_canvas_region (area, invalid_region); - foo_scroll_area_invalidate_region (area, invalid_region); + foo_scroll_area_invalidate_region (area, invalid_region); - cairo_region_destroy (invalid_region); + cairo_region_destroy (invalid_region); } static void foo_scrollbar_adjustment_changed (GtkAdjustment *adj, FooScrollArea *scroll_area) { - GtkWidget *widget = GTK_WIDGET (scroll_area); - gint dx = 0; - gint dy = 0; - GdkRectangle old_viewport, new_viewport; + GtkWidget *widget = GTK_WIDGET (scroll_area); + gint dx = 0; + gint dy = 0; + GdkRectangle old_viewport, new_viewport; - get_viewport (scroll_area, &old_viewport); + get_viewport (scroll_area, &old_viewport); - if (adj == scroll_area->priv->hadj) + if (adj == scroll_area->priv->hadj) { - /* FIXME: do we treat the offset as int or double, and, - * if int, how do we round? - */ - dx = (int)gtk_adjustment_get_value (adj) - scroll_area->priv->x_offset; - scroll_area->priv->x_offset = gtk_adjustment_get_value (adj); + /* FIXME: do we treat the offset as int or double, and, + * if int, how do we round? + */ + dx = (int)gtk_adjustment_get_value (adj) - scroll_area->priv->x_offset; + scroll_area->priv->x_offset = gtk_adjustment_get_value (adj); } - else if (adj == scroll_area->priv->vadj) + else if (adj == scroll_area->priv->vadj) { - dy = (int)gtk_adjustment_get_value (adj) - scroll_area->priv->y_offset; - scroll_area->priv->y_offset = gtk_adjustment_get_value (adj); + dy = (int)gtk_adjustment_get_value (adj) - scroll_area->priv->y_offset; + scroll_area->priv->y_offset = gtk_adjustment_get_value (adj); } - else + else { - g_assert_not_reached (); + g_assert_not_reached (); } - if (gtk_widget_get_realized (widget)) + if (gtk_widget_get_realized (widget)) { - foo_scroll_area_scroll (scroll_area, -dx, -dy); + foo_scroll_area_scroll (scroll_area, -dx, -dy); - //translate_input_regions (scroll_area, -dx, -dy); + //translate_input_regions (scroll_area, -dx, -dy); } - get_viewport (scroll_area, &new_viewport); + get_viewport (scroll_area, &new_viewport); - emit_viewport_changed (scroll_area, &new_viewport, &old_viewport); + emit_viewport_changed (scroll_area, &new_viewport, &old_viewport); } static void @@ -1090,55 +1090,55 @@ set_one_adjustment (FooScrollArea *scroll_area, GtkAdjustment *adjustment, GtkAdjustment **location) { - g_return_if_fail (location != NULL); + g_return_if_fail (location != NULL); - if (adjustment == *location) - return; + if (adjustment == *location) + return; - if (!adjustment) - adjustment = new_adjustment (); + if (!adjustment) + adjustment = new_adjustment (); - g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment)); + g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment)); - if (*location) + if (*location) { - g_signal_handlers_disconnect_by_func ( - *location, foo_scrollbar_adjustment_changed, scroll_area); + g_signal_handlers_disconnect_by_func ( + *location, foo_scrollbar_adjustment_changed, scroll_area); - g_object_unref (*location); + g_object_unref (*location); } - *location = adjustment; + *location = adjustment; - g_object_ref_sink (*location); + g_object_ref_sink (*location); - g_signal_connect (*location, "value_changed", - G_CALLBACK (foo_scrollbar_adjustment_changed), - scroll_area); + g_signal_connect (*location, "value_changed", + G_CALLBACK (foo_scrollbar_adjustment_changed), + scroll_area); } static void foo_scroll_area_set_hadjustment (FooScrollArea *scroll_area, GtkAdjustment *hadjustment) { - set_one_adjustment (scroll_area, hadjustment, &scroll_area->priv->hadj); + set_one_adjustment (scroll_area, hadjustment, &scroll_area->priv->hadj); - set_adjustment_values (scroll_area); + set_adjustment_values (scroll_area); } static void foo_scroll_area_set_vadjustment (FooScrollArea *scroll_area, GtkAdjustment *vadjustment) { - set_one_adjustment (scroll_area, vadjustment, &scroll_area->priv->vadj); + set_one_adjustment (scroll_area, vadjustment, &scroll_area->priv->vadj); - set_adjustment_values (scroll_area); + set_adjustment_values (scroll_area); } FooScrollArea * foo_scroll_area_new (void) { - return g_object_new (FOO_TYPE_SCROLL_AREA, NULL); + return g_object_new (FOO_TYPE_SCROLL_AREA, NULL); } void @@ -1146,16 +1146,16 @@ foo_scroll_area_set_min_size (FooScrollArea *scroll_area, int min_width, int min_height) { - scroll_area->priv->min_width = min_width; - scroll_area->priv->min_height = min_height; + 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(), - * - make sure input boxes are invalidated when - * needed - */ - gtk_widget_queue_resize (GTK_WIDGET (scroll_area)); + /* FIXME: think through invalidation. + * + * Goals: - no repainting everything on size_allocate(), + * - make sure input boxes are invalidated when + * needed + */ + gtk_widget_queue_resize (GTK_WIDGET (scroll_area)); } static void @@ -1163,10 +1163,10 @@ user_to_device (double *x, double *y, gpointer data) { #if 0 - cairo_t *cr = data; + cairo_t *cr = data; - /* FIXME: not set transform in first place? */ - cairo_user_to_device (cr, x, y); + /* FIXME: not set transform in first place? */ + cairo_user_to_device (cr, x, y); #endif } @@ -1177,18 +1177,18 @@ make_path (FooScrollArea *area, FooScrollAreaEventFunc func, gpointer data) { - InputPath *path = g_new0 (InputPath, 1); + InputPath *path = g_new0 (InputPath, 1); - path->is_stroke = is_stroke; - path->fill_rule = cairo_get_fill_rule (cr); - path->line_width = cairo_get_line_width (cr); - path->path = cairo_copy_path (cr); - path_foreach_point (path->path, user_to_device, cr); - path->func = func; - path->data = data; - path->next = area->priv->current_input->paths; - area->priv->current_input->paths = path; - return path; + path->is_stroke = is_stroke; + path->fill_rule = cairo_get_fill_rule (cr); + path->line_width = cairo_get_line_width (cr); + path->path = cairo_copy_path (cr); + path_foreach_point (path->path, user_to_device, cr); + path->func = func; + path->data = data; + path->next = area->priv->current_input->paths; + area->priv->current_input->paths = path; + return path; } /* FIXME: we probably really want a @@ -1204,11 +1204,11 @@ foo_scroll_area_add_input_from_fill (FooScrollArea *scroll_area, FooScrollAreaEventFunc func, gpointer data) { - g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); - g_return_if_fail (cr != NULL); - g_return_if_fail (scroll_area->priv->current_input); + g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); + g_return_if_fail (cr != NULL); + g_return_if_fail (scroll_area->priv->current_input); - make_path (scroll_area, cr, FALSE, func, data); + make_path (scroll_area, cr, FALSE, func, data); } void @@ -1217,72 +1217,72 @@ foo_scroll_area_add_input_from_stroke (FooScrollArea *scroll_area, FooScrollAreaEventFunc func, gpointer data) { - g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); - g_return_if_fail (cr != NULL); - g_return_if_fail (scroll_area->priv->current_input); + g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); + g_return_if_fail (cr != NULL); + g_return_if_fail (scroll_area->priv->current_input); - make_path (scroll_area, cr, TRUE, func, data); + make_path (scroll_area, cr, TRUE, func, data); } void foo_scroll_area_invalidate (FooScrollArea *scroll_area) { - GtkAllocation allocation; - GtkWidget *widget = GTK_WIDGET (scroll_area); + GtkAllocation allocation; + GtkWidget *widget = GTK_WIDGET (scroll_area); - gtk_widget_get_allocation (widget, &allocation); - foo_scroll_area_invalidate_rect (scroll_area, - scroll_area->priv->x_offset, scroll_area->priv->y_offset, - allocation.width, - allocation.height); + gtk_widget_get_allocation (widget, &allocation); + foo_scroll_area_invalidate_rect (scroll_area, + scroll_area->priv->x_offset, scroll_area->priv->y_offset, + allocation.width, + allocation.height); } static void canvas_to_window (FooScrollArea *area, cairo_region_t *region) { - GtkAllocation allocation; - GtkWidget *widget = GTK_WIDGET (area); + GtkAllocation allocation; + GtkWidget *widget = GTK_WIDGET (area); - gtk_widget_get_allocation (widget, &allocation); - cairo_region_translate (region, - -area->priv->x_offset + allocation.x, - -area->priv->y_offset + allocation.y); + gtk_widget_get_allocation (widget, &allocation); + cairo_region_translate (region, + -area->priv->x_offset + allocation.x, + -area->priv->y_offset + allocation.y); } static void window_to_canvas (FooScrollArea *area, cairo_region_t *region) { - GtkAllocation allocation; - GtkWidget *widget = GTK_WIDGET (area); + GtkAllocation allocation; + GtkWidget *widget = GTK_WIDGET (area); - gtk_widget_get_allocation (widget, &allocation); - cairo_region_translate (region, - area->priv->x_offset - allocation.x, - area->priv->y_offset - allocation.y); + gtk_widget_get_allocation (widget, &allocation); + cairo_region_translate (region, + area->priv->x_offset - allocation.x, + area->priv->y_offset - allocation.y); } void foo_scroll_area_invalidate_region (FooScrollArea *area, cairo_region_t *region) { - GtkWidget *widget; + GtkWidget *widget; - g_return_if_fail (FOO_IS_SCROLL_AREA (area)); + g_return_if_fail (FOO_IS_SCROLL_AREA (area)); - widget = GTK_WIDGET (area); + widget = GTK_WIDGET (area); - cairo_region_union (area->priv->update_region, region); + cairo_region_union (area->priv->update_region, region); - if (gtk_widget_get_realized (widget)) + if (gtk_widget_get_realized (widget)) { - canvas_to_window (area, region); + canvas_to_window (area, region); - gdk_window_invalidate_region (gtk_widget_get_window (widget), - region, TRUE); + gdk_window_invalidate_region (gtk_widget_get_window (widget), + region, TRUE); - window_to_canvas (area, region); + window_to_canvas (area, region); } } @@ -1293,16 +1293,16 @@ foo_scroll_area_invalidate_rect (FooScrollArea *scroll_area, int width, int height) { - cairo_rectangle_int_t rect = { x, y, width, height }; - cairo_region_t *region; + cairo_rectangle_int_t rect = { x, y, width, height }; + cairo_region_t *region; - g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); + g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); - region = cairo_region_create_rectangle (&rect); + region = cairo_region_create_rectangle (&rect); - foo_scroll_area_invalidate_region (scroll_area, region); + foo_scroll_area_invalidate_region (scroll_area, region); - cairo_region_destroy (region); + cairo_region_destroy (region); } void @@ -1310,31 +1310,31 @@ foo_scroll_area_begin_grab (FooScrollArea *scroll_area, FooScrollAreaEventFunc func, gpointer input_data) { - g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area)); - g_return_if_fail (!scroll_area->priv->grabbed); + 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; + 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 */ + /* FIXME: we should probably take a server grab */ + /* Also, maybe there should be support for setting the grab cursor */ } void foo_scroll_area_end_grab (FooScrollArea *scroll_area) { - g_return_if_fail (FOO_IS_SCROLL_AREA (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; + scroll_area->priv->grabbed = FALSE; + scroll_area->priv->grab_func = NULL; + scroll_area->priv->grab_data = NULL; } gboolean foo_scroll_area_is_grabbed (FooScrollArea *scroll_area) { - return scroll_area->priv->grabbed; + return scroll_area->priv->grabbed; } void @@ -1342,104 +1342,104 @@ foo_scroll_area_set_viewport_pos (FooScrollArea *scroll_area, int x, int y) { - g_object_freeze_notify (G_OBJECT (scroll_area->priv->hadj)); - g_object_freeze_notify (G_OBJECT (scroll_area->priv->vadj)); - gtk_adjustment_set_value (scroll_area->priv->hadj, x); - gtk_adjustment_set_value (scroll_area->priv->vadj, y); + g_object_freeze_notify (G_OBJECT (scroll_area->priv->hadj)); + g_object_freeze_notify (G_OBJECT (scroll_area->priv->vadj)); + gtk_adjustment_set_value (scroll_area->priv->hadj, x); + gtk_adjustment_set_value (scroll_area->priv->vadj, y); - set_adjustment_values (scroll_area); - g_object_thaw_notify (G_OBJECT (scroll_area->priv->hadj)); - g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj)); + set_adjustment_values (scroll_area); + g_object_thaw_notify (G_OBJECT (scroll_area->priv->hadj)); + g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj)); } static gboolean rect_contains (const GdkRectangle *rect, int x, int y) { - return (x >= rect->x && - y >= rect->y && - x < rect->x + rect->width && - y < rect->y + rect->height); + return (x >= rect->x && + y >= rect->y && + x < rect->x + rect->width && + y < rect->y + rect->height); } static void stop_scrolling (FooScrollArea *area) { #if 0 - g_print ("stop scrolling\n"); + g_print ("stop scrolling\n"); #endif - if (area->priv->auto_scroll_info) + if (area->priv->auto_scroll_info) { - 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); + 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; + area->priv->auto_scroll_info = NULL; } } static gboolean scroll_idle (gpointer data) { - GdkRectangle viewport, new_viewport; - FooScrollArea *area = data; - AutoScrollInfo *info = area->priv->auto_scroll_info; - int new_x, new_y; - double elapsed; + GdkRectangle viewport, new_viewport; + FooScrollArea *area = data; + AutoScrollInfo *info = area->priv->auto_scroll_info; + int new_x, new_y; + double elapsed; - get_viewport (area, &viewport); + get_viewport (area, &viewport); #if 0 - g_print ("old info: %d %d\n", info->dx, info->dy); + g_print ("old info: %d %d\n", info->dx, info->dy); - g_print ("timeout (%d %d)\n", dx, dy); + g_print ("timeout (%d %d)\n", dx, dy); #endif #if 0 - g_print ("new info %d %d\n", info->dx, info->dy); + g_print ("new info %d %d\n", info->dx, info->dy); #endif - elapsed = g_timer_elapsed (info->timer, NULL); + elapsed = g_timer_elapsed (info->timer, NULL); - info->res_x = elapsed * info->dx / 0.2; - info->res_y = elapsed * info->dy / 0.2; + info->res_x = elapsed * info->dx / 0.2; + info->res_y = elapsed * info->dy / 0.2; #if 0 - g_print ("%f %f\n", info->res_x, info->res_y); + g_print ("%f %f\n", info->res_x, info->res_y); #endif - new_x = viewport.x + info->res_x; - new_y = viewport.y + info->res_y; + new_x = viewport.x + info->res_x; + new_y = viewport.y + info->res_y; #if 0 - g_print ("%f\n", elapsed * (info->dx / 0.2)); + g_print ("%f\n", elapsed * (info->dx / 0.2)); #endif #if 0 - g_print ("new_x, new_y\n: %d %d\n", new_x, new_y); + g_print ("new_x, new_y\n: %d %d\n", new_x, new_y); #endif - foo_scroll_area_set_viewport_pos (area, new_x, new_y); + foo_scroll_area_set_viewport_pos (area, new_x, new_y); #if 0 - viewport.x + info->dx, - viewport.y + info->dy); + viewport.x + info->dx, + viewport.y + info->dy); #endif - get_viewport (area, &new_viewport); +get_viewport (area, &new_viewport); - if (viewport.x == new_viewport.x && - viewport.y == new_viewport.y && - (info->res_x > 1.0 || - info->res_y > 1.0 || - info->res_x < -1.0 || - info->res_y < -1.0)) - { - stop_scrolling (area); +if (viewport.x == new_viewport.x && + viewport.y == new_viewport.y && + (info->res_x > 1.0 || + info->res_y > 1.0 || + info->res_x < -1.0 || + info->res_y < -1.0)) + { + stop_scrolling (area); - /* stop scrolling if it didn't have an effect */ - return FALSE; - } + /* stop scrolling if it didn't have an effect */ + return FALSE; + } - return TRUE; +return TRUE; } static void @@ -1447,86 +1447,86 @@ ensure_scrolling (FooScrollArea *area, int dx, int dy) { - if (!area->priv->auto_scroll_info) + if (!area->priv->auto_scroll_info) { #if 0 - g_print ("start scrolling\n"); + g_print ("start scrolling\n"); #endif - area->priv->auto_scroll_info = g_new0 (AutoScrollInfo, 1); - area->priv->auto_scroll_info->timeout_id = - g_idle_add (scroll_idle, area); - area->priv->auto_scroll_info->timer = g_timer_new (); + area->priv->auto_scroll_info = g_new0 (AutoScrollInfo, 1); + area->priv->auto_scroll_info->timeout_id = + g_idle_add (scroll_idle, area); + area->priv->auto_scroll_info->timer = g_timer_new (); } #if 0 - g_print ("setting scrolling to %d %d\n", dx, dy); + g_print ("setting scrolling to %d %d\n", dx, dy); #endif #if 0 - g_print ("dx, dy: %d %d\n", dx, dy); + g_print ("dx, dy: %d %d\n", dx, dy); #endif - area->priv->auto_scroll_info->dx = dx; - area->priv->auto_scroll_info->dy = dy; + area->priv->auto_scroll_info->dx = dx; + area->priv->auto_scroll_info->dy = dy; } void foo_scroll_area_auto_scroll (FooScrollArea *scroll_area, FooScrollAreaEvent *event) { - GdkRectangle viewport; + GdkRectangle viewport; - get_viewport (scroll_area, &viewport); + get_viewport (scroll_area, &viewport); - if (rect_contains (&viewport, event->x, event->y)) + if (rect_contains (&viewport, event->x, event->y)) { - stop_scrolling (scroll_area); + stop_scrolling (scroll_area); } - else + else { - int dx, dy; + int dx, dy; - dx = dy = 0; + dx = dy = 0; - if (event->y < viewport.y) + if (event->y < viewport.y) { - dy = event->y - viewport.y; - dy = MIN (dy + 2, 0); + dy = event->y - viewport.y; + dy = MIN (dy + 2, 0); } - else if (event->y >= viewport.y + viewport.height) + else if (event->y >= viewport.y + viewport.height) { - dy = event->y - (viewport.y + viewport.height - 1); - dy = MAX (dy - 2, 0); + dy = event->y - (viewport.y + viewport.height - 1); + dy = MAX (dy - 2, 0); } - if (event->x < viewport.x) + if (event->x < viewport.x) { - dx = event->x - viewport.x; - dx = MIN (dx + 2, 0); + dx = event->x - viewport.x; + dx = MIN (dx + 2, 0); } - else if (event->x >= viewport.x + viewport.width) + else if (event->x >= viewport.x + viewport.width) { - dx = event->x - (viewport.x + viewport.width - 1); - dx = MAX (dx - 2, 0); + dx = event->x - (viewport.x + viewport.width - 1); + dx = MAX (dx - 2, 0); } #if 0 - g_print ("dx, dy: %d %d\n", dx, dy); + g_print ("dx, dy: %d %d\n", dx, dy); #endif - ensure_scrolling (scroll_area, dx, dy); + ensure_scrolling (scroll_area, dx, dy); } } void foo_scroll_area_begin_auto_scroll (FooScrollArea *scroll_area) { - /* noop for now */ + /* noop for now */ } void foo_scroll_area_end_auto_scroll (FooScrollArea *scroll_area) { - stop_scrolling (scroll_area); + stop_scrolling (scroll_area); } diff --git a/panels/display/scrollarea.h b/panels/display/scrollarea.h index fba99ef95..b394c17bc 100644 --- a/panels/display/scrollarea.h +++ b/panels/display/scrollarea.h @@ -31,17 +31,17 @@ typedef struct FooScrollAreaPrivate FooScrollAreaPrivate; typedef struct FooScrollAreaEvent FooScrollAreaEvent; typedef enum -{ + { FOO_BUTTON_PRESS, FOO_BUTTON_RELEASE, FOO_MOTION -} FooScrollAreaEventType; + } FooScrollAreaEventType; struct FooScrollAreaEvent { - FooScrollAreaEventType type; - int x; - int y; + FooScrollAreaEventType type; + int x; + int y; }; typedef void (* FooScrollAreaEventFunc) (FooScrollArea *area, @@ -50,27 +50,27 @@ typedef void (* FooScrollAreaEventFunc) (FooScrollArea *area, struct FooScrollArea { - GtkContainer parent_instance; + GtkContainer parent_instance; - FooScrollAreaPrivate *priv; + FooScrollAreaPrivate *priv; }; struct FooScrollAreaClass { - GtkContainerClass parent_class; + GtkContainerClass parent_class; - void (*set_scroll_adjustments) (FooScrollArea *scroll_area, - GtkAdjustment *hadjustment, - GtkAdjustment *vadjustment); + void (*set_scroll_adjustments) (FooScrollArea *scroll_area, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); - void (*viewport_changed) (FooScrollArea *scroll_area, - GdkRectangle *old_viewport, - GdkRectangle *new_viewport); + void (*viewport_changed) (FooScrollArea *scroll_area, + GdkRectangle *old_viewport, + GdkRectangle *new_viewport); - void (*paint) (FooScrollArea *scroll_area, - cairo_t *cr, - GdkRectangle *extents, - cairo_region_t *region); + void (*paint) (FooScrollArea *scroll_area, + cairo_t *cr, + GdkRectangle *extents, + cairo_region_t *region); }; GType foo_scroll_area_get_type (void); @@ -101,9 +101,9 @@ void foo_scroll_area_add_input_from_stroke (FooScrollArea *sc FooScrollAreaEventFunc func, gpointer data); void foo_scroll_area_add_input_from_fill (FooScrollArea *scroll_area, - cairo_t *cr, - FooScrollAreaEventFunc func, - gpointer data); + cairo_t *cr, + FooScrollAreaEventFunc func, + gpointer data); void foo_scroll_area_invalidate_region (FooScrollArea *area, cairo_region_t *region); void foo_scroll_area_invalidate (FooScrollArea *scroll_area); diff --git a/panels/display/xrandr-capplet.c b/panels/display/xrandr-capplet.c index 80746469b..e9c7b0455 100644 --- a/panels/display/xrandr-capplet.c +++ b/panels/display/xrandr-capplet.c @@ -43,41 +43,41 @@ typedef struct GrabInfo GrabInfo; struct App { - GnomeRRScreen *screen; - GnomeRRConfig *current_configuration; - GnomeRRLabeler *labeler; - GnomeOutputInfo *current_output; + GnomeRRScreen *screen; + GnomeRRConfig *current_configuration; + GnomeRRLabeler *labeler; + GnomeOutputInfo *current_output; - GtkBuilder *builder; + GtkBuilder *builder; - GtkWidget *panel; - GtkWidget *current_monitor_event_box; - GtkWidget *current_monitor_label; - GtkWidget *monitor_on_radio; - GtkWidget *monitor_off_radio; - GtkListStore *resolution_store; - GtkWidget *resolution_combo; - GtkWidget *rotation_combo; - GtkWidget *clone_checkbox; - GtkWidget *clone_label; - GtkWidget *show_icon_checkbox; + GtkWidget *panel; + GtkWidget *current_monitor_event_box; + GtkWidget *current_monitor_label; + GtkWidget *monitor_on_radio; + GtkWidget *monitor_off_radio; + GtkListStore *resolution_store; + GtkWidget *resolution_combo; + GtkWidget *rotation_combo; + GtkWidget *clone_checkbox; + GtkWidget *clone_label; + GtkWidget *show_icon_checkbox; - /* We store the event timestamp when the Apply button is clicked */ - GtkWidget *apply_button; - guint32 apply_button_clicked_timestamp; + /* We store the event timestamp when the Apply button is clicked */ + GtkWidget *apply_button; + guint32 apply_button_clicked_timestamp; - GtkWidget *area; - gboolean ignore_gui_changes; + GtkWidget *area; + gboolean ignore_gui_changes; - /* These are used while we are waiting for the ApplyConfiguration method to be executed over D-bus */ - DBusGConnection *connection; - DBusGProxy *proxy; - DBusGProxyCall *proxy_call; + /* These are used while we are waiting for the ApplyConfiguration method to be executed over D-bus */ + DBusGConnection *connection; + DBusGProxy *proxy; + DBusGProxyCall *proxy_call; - enum { - APPLYING_VERSION_1, - APPLYING_VERSION_2 - } apply_configuration_state; + enum { + APPLYING_VERSION_1, + APPLYING_VERSION_2 + } apply_configuration_state; }; static void rebuild_gui (App *app); @@ -93,65 +93,65 @@ static gboolean output_info_supports_mode (App *app, GnomeOutputInfo *info, int static void error_message (App *app, const char *primary_text, const char *secondary_text) { - GtkWidget *toplevel; - GtkWidget *dialog; + GtkWidget *toplevel; + GtkWidget *dialog; - if (app && app->panel) - toplevel = gtk_widget_get_toplevel (app->panel); - else - toplevel = NULL; + if (app && app->panel) + toplevel = gtk_widget_get_toplevel (app->panel); + else + toplevel = NULL; - dialog = gtk_message_dialog_new (GTK_WINDOW (toplevel), - GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, - GTK_MESSAGE_ERROR, - GTK_BUTTONS_CLOSE, - "%s", primary_text); + dialog = gtk_message_dialog_new (GTK_WINDOW (toplevel), + GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + "%s", primary_text); - if (secondary_text) - gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", secondary_text); + if (secondary_text) + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", secondary_text); - gtk_dialog_run (GTK_DIALOG (dialog)); - gtk_widget_destroy (dialog); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); } static gboolean do_free (gpointer data) { - g_free (data); - return FALSE; + g_free (data); + return FALSE; } static gchar * idle_free (gchar *s) { - g_idle_add (do_free, s); + g_idle_add (do_free, s); - return s; + return s; } static void on_screen_changed (GnomeRRScreen *scr, gpointer data) { - GnomeRRConfig *current; - App *app = data; + GnomeRRConfig *current; + App *app = data; - current = gnome_rr_config_new_current (app->screen); + current = gnome_rr_config_new_current (app->screen); - if (app->current_configuration) - gnome_rr_config_free (app->current_configuration); + if (app->current_configuration) + gnome_rr_config_free (app->current_configuration); - app->current_configuration = current; - app->current_output = NULL; + app->current_configuration = current; + app->current_output = NULL; - if (app->labeler) { - gnome_rr_labeler_hide (app->labeler); - g_object_unref (app->labeler); - } + if (app->labeler) { + gnome_rr_labeler_hide (app->labeler); + g_object_unref (app->labeler); + } - app->labeler = gnome_rr_labeler_new (app->current_configuration); + app->labeler = gnome_rr_labeler_new (app->current_configuration); - select_current_output_from_dialog_position (app); + select_current_output_from_dialog_position (app); } static void @@ -159,42 +159,42 @@ on_viewport_changed (FooScrollArea *scroll_area, GdkRectangle *old_viewport, GdkRectangle *new_viewport) { - foo_scroll_area_set_size (scroll_area, - new_viewport->width, - new_viewport->height); + foo_scroll_area_set_size (scroll_area, + new_viewport->width, + new_viewport->height); - foo_scroll_area_invalidate (scroll_area); + foo_scroll_area_invalidate (scroll_area); } static void layout_set_font (PangoLayout *layout, const char *font) { - PangoFontDescription *desc = - pango_font_description_from_string (font); + PangoFontDescription *desc = + pango_font_description_from_string (font); - if (desc) + if (desc) { - pango_layout_set_font_description (layout, desc); + pango_layout_set_font_description (layout, desc); - pango_font_description_free (desc); + pango_font_description_free (desc); } } static void clear_combo (GtkWidget *widget) { - GtkComboBox *box = GTK_COMBO_BOX (widget); - GtkTreeModel *model = gtk_combo_box_get_model (box); - GtkListStore *store = GTK_LIST_STORE (model); + GtkComboBox *box = GTK_COMBO_BOX (widget); + GtkTreeModel *model = gtk_combo_box_get_model (box); + GtkListStore *store = GTK_LIST_STORE (model); - gtk_list_store_clear (store); + gtk_list_store_clear (store); } typedef struct { - const char *text; - gboolean found; - GtkTreeIter iter; + const char *text; + gboolean found; + GtkTreeIter iter; } ForeachInfo; static gboolean @@ -203,21 +203,21 @@ foreach (GtkTreeModel *model, GtkTreeIter *iter, gpointer data) { - ForeachInfo *info = data; - char *text = NULL; + ForeachInfo *info = data; + char *text = NULL; - gtk_tree_model_get (model, iter, 0, &text, -1); + gtk_tree_model_get (model, iter, 0, &text, -1); - g_assert (text != NULL); + g_assert (text != NULL); - if (strcmp (info->text, text) == 0) + if (strcmp (info->text, text) == 0) { - info->found = TRUE; - info->iter = *iter; - return TRUE; + info->found = TRUE; + info->iter = *iter; + return TRUE; } - return FALSE; + return FALSE; } static void @@ -226,156 +226,156 @@ add_key (GtkWidget *widget, int width, int height, int rate, GnomeRRRotation rotation) { - ForeachInfo info; - GtkComboBox *box = GTK_COMBO_BOX (widget); - GtkTreeModel *model = gtk_combo_box_get_model (box); - GtkListStore *store = GTK_LIST_STORE (model); - gboolean retval; + ForeachInfo info; + GtkComboBox *box = GTK_COMBO_BOX (widget); + GtkTreeModel *model = gtk_combo_box_get_model (box); + GtkListStore *store = GTK_LIST_STORE (model); + gboolean retval; - info.text = text; - info.found = FALSE; + info.text = text; + info.found = FALSE; - gtk_tree_model_foreach (model, foreach, &info); + gtk_tree_model_foreach (model, foreach, &info); - if (!info.found) + if (!info.found) { - GtkTreeIter iter; - gtk_list_store_insert_with_values (store, &iter, -1, - 0, text, - 1, width, - 2, height, - 3, rate, - 4, width * height, - 5, rotation, - -1); + GtkTreeIter iter; + gtk_list_store_insert_with_values (store, &iter, -1, + 0, text, + 1, width, + 2, height, + 3, rate, + 4, width * height, + 5, rotation, + -1); - retval = TRUE; + retval = TRUE; } - else + else { - retval = FALSE; + retval = FALSE; } } static gboolean combo_select (GtkWidget *widget, const char *text) { - GtkComboBox *box = GTK_COMBO_BOX (widget); - GtkTreeModel *model = gtk_combo_box_get_model (box); - ForeachInfo info; + GtkComboBox *box = GTK_COMBO_BOX (widget); + GtkTreeModel *model = gtk_combo_box_get_model (box); + ForeachInfo info; - info.text = text; - info.found = FALSE; + info.text = text; + info.found = FALSE; - gtk_tree_model_foreach (model, foreach, &info); + gtk_tree_model_foreach (model, foreach, &info); - if (!info.found) - return FALSE; + if (!info.found) + return FALSE; - gtk_combo_box_set_active_iter (box, &info.iter); - return TRUE; + gtk_combo_box_set_active_iter (box, &info.iter); + return TRUE; } static GnomeRRMode ** get_current_modes (App *app) { - GnomeRROutput *output; + GnomeRROutput *output; - if (app->current_configuration->clone) + if (app->current_configuration->clone) { - return gnome_rr_screen_list_clone_modes (app->screen); + return gnome_rr_screen_list_clone_modes (app->screen); } - else + else { - if (!app->current_output) - return NULL; + if (!app->current_output) + return NULL; - output = gnome_rr_screen_get_output_by_name ( - app->screen, app->current_output->name); + output = gnome_rr_screen_get_output_by_name ( + app->screen, app->current_output->name); - if (!output) - return NULL; + if (!output) + return NULL; - return gnome_rr_output_list_modes (output); + return gnome_rr_output_list_modes (output); } } static void rebuild_rotation_combo (App *app) { - typedef struct + typedef struct + { + GnomeRRRotation rotation; + const char * name; + } RotationInfo; + static const RotationInfo rotations[] = { + { GNOME_RR_ROTATION_0, N_("Normal") }, + { GNOME_RR_ROTATION_90, N_("Left") }, + { GNOME_RR_ROTATION_270, N_("Right") }, + { GNOME_RR_ROTATION_180, N_("Upside Down") }, + }; + const char *selection; + GnomeRRRotation current; + int i; + + clear_combo (app->rotation_combo); + + gtk_widget_set_sensitive ( + app->rotation_combo, app->current_output && app->current_output->on); + + if (!app->current_output) + return; + + current = app->current_output->rotation; + + selection = NULL; + for (i = 0; i < G_N_ELEMENTS (rotations); ++i) { - GnomeRRRotation rotation; - const char * name; - } RotationInfo; - static const RotationInfo rotations[] = { - { GNOME_RR_ROTATION_0, N_("Normal") }, - { GNOME_RR_ROTATION_90, N_("Left") }, - { GNOME_RR_ROTATION_270, N_("Right") }, - { GNOME_RR_ROTATION_180, N_("Upside Down") }, - }; - const char *selection; - GnomeRRRotation current; - int i; + const RotationInfo *info = &(rotations[i]); - clear_combo (app->rotation_combo); + app->current_output->rotation = info->rotation; - gtk_widget_set_sensitive ( - app->rotation_combo, app->current_output && app->current_output->on); - - if (!app->current_output) - return; - - current = app->current_output->rotation; - - selection = NULL; - for (i = 0; i < G_N_ELEMENTS (rotations); ++i) - { - const RotationInfo *info = &(rotations[i]); - - app->current_output->rotation = info->rotation; - - /* NULL-GError --- FIXME: we should say why this rotation is not available! */ - if (gnome_rr_config_applicable (app->current_configuration, app->screen, NULL)) + /* NULL-GError --- FIXME: we should say why this rotation is not available! */ + if (gnome_rr_config_applicable (app->current_configuration, app->screen, NULL)) { - add_key (app->rotation_combo, _(info->name), 0, 0, 0, info->rotation); + add_key (app->rotation_combo, _(info->name), 0, 0, 0, info->rotation); - if (info->rotation == current) - selection = _(info->name); + if (info->rotation == current) + selection = _(info->name); } } - app->current_output->rotation = current; + app->current_output->rotation = current; - if (!(selection && combo_select (app->rotation_combo, selection))) - combo_select (app->rotation_combo, _("Normal")); + if (!(selection && combo_select (app->rotation_combo, selection))) + combo_select (app->rotation_combo, _("Normal")); } static int count_active_outputs (App *app) { - int i, count = 0; + int i, count = 0; - for (i = 0; app->current_configuration->outputs[i] != NULL; ++i) + for (i = 0; app->current_configuration->outputs[i] != NULL; ++i) { - GnomeOutputInfo *output = app->current_configuration->outputs[i]; - if (output->on) - count++; + GnomeOutputInfo *output = app->current_configuration->outputs[i]; + if (output->on) + count++; } - return count; + return count; } #if 0 static int count_all_outputs (GnomeRRConfig *config) { - int i; + int i; - for (i = 0; config->outputs[i] != NULL; i++) - ; + for (i = 0; config->outputs[i] != NULL; i++) + ; - return i; + return i; } #endif @@ -388,209 +388,209 @@ count_all_outputs (GnomeRRConfig *config) static gboolean mirror_screens_is_supported (App *app) { - int clone_width, clone_height; - gboolean have_clone_size; - gboolean mirror_is_supported; + int clone_width, clone_height; + gboolean have_clone_size; + gboolean mirror_is_supported; - mirror_is_supported = FALSE; + mirror_is_supported = FALSE; - have_clone_size = get_clone_size (app->screen, &clone_width, &clone_height); + have_clone_size = get_clone_size (app->screen, &clone_width, &clone_height); - if (have_clone_size) { - int i; - int num_outputs_with_clone_size; + if (have_clone_size) { + int i; + int num_outputs_with_clone_size; - num_outputs_with_clone_size = 0; + num_outputs_with_clone_size = 0; - for (i = 0; app->current_configuration->outputs[i] != NULL; i++) - { - GnomeOutputInfo *output = app->current_configuration->outputs[i]; + for (i = 0; app->current_configuration->outputs[i] != NULL; i++) + { + GnomeOutputInfo *output = app->current_configuration->outputs[i]; - /* We count the connected outputs that support the clone size. It - * doesn't matter if those outputs aren't actually On currently; we - * will turn them on in on_clone_changed(). - */ - if (output->connected && output_info_supports_mode (app, output, clone_width, clone_height)) - num_outputs_with_clone_size++; - } + /* We count the connected outputs that support the clone size. It + * doesn't matter if those outputs aren't actually On currently; we + * will turn them on in on_clone_changed(). + */ + if (output->connected && output_info_supports_mode (app, output, clone_width, clone_height)) + num_outputs_with_clone_size++; + } - if (num_outputs_with_clone_size >= 2) - mirror_is_supported = TRUE; - } + if (num_outputs_with_clone_size >= 2) + mirror_is_supported = TRUE; + } - return mirror_is_supported; + return mirror_is_supported; } static void rebuild_mirror_screens (App *app) { - gboolean mirror_is_active; - gboolean mirror_is_supported; + gboolean mirror_is_active; + gboolean mirror_is_supported; - g_signal_handlers_block_by_func (app->clone_checkbox, G_CALLBACK (on_clone_changed), app); + g_signal_handlers_block_by_func (app->clone_checkbox, G_CALLBACK (on_clone_changed), app); - mirror_is_active = app->current_configuration && app->current_configuration->clone; + mirror_is_active = app->current_configuration && app->current_configuration->clone; - /* If mirror_is_active, then it *must* be possible to turn mirroring off */ - mirror_is_supported = mirror_is_active || mirror_screens_is_supported (app); - - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (app->clone_checkbox), mirror_is_active); - gtk_widget_set_sensitive (app->clone_checkbox, mirror_is_supported); - gtk_widget_set_sensitive (app->clone_label, mirror_is_supported); + /* If mirror_is_active, then it *must* be possible to turn mirroring off */ + mirror_is_supported = mirror_is_active || mirror_screens_is_supported (app); - g_signal_handlers_unblock_by_func (app->clone_checkbox, G_CALLBACK (on_clone_changed), app); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (app->clone_checkbox), mirror_is_active); + gtk_widget_set_sensitive (app->clone_checkbox, mirror_is_supported); + gtk_widget_set_sensitive (app->clone_label, mirror_is_supported); + + g_signal_handlers_unblock_by_func (app->clone_checkbox, G_CALLBACK (on_clone_changed), app); } static void rebuild_current_monitor_label (App *app) { - char *str, *tmp; - GdkColor color; - gboolean use_color; + char *str, *tmp; + GdkColor color; + gboolean use_color; - if (app->current_output) - { - if (app->current_configuration->clone) - tmp = g_strdup (_("Mirror Screens")); - else - tmp = g_strdup (app->current_output->display_name); + if (app->current_output) + { + if (app->current_configuration->clone) + tmp = g_strdup (_("Mirror Screens")); + else + tmp = g_strdup (app->current_output->display_name); - str = g_strdup_printf ("%s", tmp); - gnome_rr_labeler_get_color_for_output (app->labeler, app->current_output, &color); - use_color = TRUE; - g_free (tmp); - } - else - { - str = g_strdup_printf ("%s", _("Monitor")); - use_color = FALSE; - } + str = g_strdup_printf ("%s", tmp); + gnome_rr_labeler_get_color_for_output (app->labeler, app->current_output, &color); + use_color = TRUE; + g_free (tmp); + } + else + { + str = g_strdup_printf ("%s", _("Monitor")); + use_color = FALSE; + } - gtk_label_set_markup (GTK_LABEL (app->current_monitor_label), str); - g_free (str); + gtk_label_set_markup (GTK_LABEL (app->current_monitor_label), str); + g_free (str); - if (use_color) - { - GdkColor black = { 0, 0, 0, 0 }; + if (use_color) + { + GdkColor black = { 0, 0, 0, 0 }; - gtk_widget_modify_bg (app->current_monitor_event_box, gtk_widget_get_state (app->current_monitor_event_box), &color); + gtk_widget_modify_bg (app->current_monitor_event_box, gtk_widget_get_state (app->current_monitor_event_box), &color); - /* Make the label explicitly black. We don't want it to follow the - * theme's colors, since the label is always shown against a light - * pastel background. See bgo#556050 - */ - gtk_widget_modify_fg (app->current_monitor_label, gtk_widget_get_state (app->current_monitor_label), &black); - } - else - { - /* Remove any modifications we did on the label's color */ - GtkRcStyle *reset_rc_style; + /* Make the label explicitly black. We don't want it to follow the + * theme's colors, since the label is always shown against a light + * pastel background. See bgo#556050 + */ + gtk_widget_modify_fg (app->current_monitor_label, gtk_widget_get_state (app->current_monitor_label), &black); + } + else + { + /* Remove any modifications we did on the label's color */ + GtkRcStyle *reset_rc_style; - reset_rc_style = gtk_rc_style_new (); - gtk_widget_modify_style (app->current_monitor_label, reset_rc_style); /* takes ownership of, and destroys, the rc style */ - } + reset_rc_style = gtk_rc_style_new (); + gtk_widget_modify_style (app->current_monitor_label, reset_rc_style); /* takes ownership of, and destroys, the rc style */ + } - gtk_event_box_set_visible_window (GTK_EVENT_BOX (app->current_monitor_event_box), use_color); + gtk_event_box_set_visible_window (GTK_EVENT_BOX (app->current_monitor_event_box), use_color); } static void rebuild_on_off_radios (App *app) { - gboolean sensitive; - gboolean on_active; - gboolean off_active; + gboolean sensitive; + gboolean on_active; + gboolean off_active; - g_signal_handlers_block_by_func (app->monitor_on_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); - g_signal_handlers_block_by_func (app->monitor_off_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); + g_signal_handlers_block_by_func (app->monitor_on_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); + g_signal_handlers_block_by_func (app->monitor_off_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); - sensitive = FALSE; - on_active = FALSE; - off_active = FALSE; + sensitive = FALSE; + on_active = FALSE; + off_active = FALSE; - if (!app->current_configuration->clone && app->current_output) + if (!app->current_configuration->clone && app->current_output) { - if (count_active_outputs (app) > 1 || !app->current_output->on) - sensitive = TRUE; - else - sensitive = FALSE; + if (count_active_outputs (app) > 1 || !app->current_output->on) + sensitive = TRUE; + else + sensitive = FALSE; - on_active = app->current_output->on; - off_active = !on_active; + on_active = app->current_output->on; + off_active = !on_active; } - gtk_widget_set_sensitive (app->monitor_on_radio, sensitive); - gtk_widget_set_sensitive (app->monitor_off_radio, sensitive); + gtk_widget_set_sensitive (app->monitor_on_radio, sensitive); + gtk_widget_set_sensitive (app->monitor_off_radio, sensitive); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (app->monitor_on_radio), on_active); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (app->monitor_off_radio), off_active); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (app->monitor_on_radio), on_active); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (app->monitor_off_radio), off_active); - g_signal_handlers_unblock_by_func (app->monitor_on_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); - g_signal_handlers_unblock_by_func (app->monitor_off_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); + g_signal_handlers_unblock_by_func (app->monitor_on_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); + g_signal_handlers_unblock_by_func (app->monitor_off_radio, G_CALLBACK (monitor_on_off_toggled_cb), app); } static char * make_resolution_string (int width, int height) { - int ratio; - const char *aspect = NULL; + int ratio; + const char *aspect = NULL; - if (width && height) { - if (width > height) - ratio = width * 10 / height; - else - ratio = height * 10 / width; - - switch (ratio) { - case 13: - aspect = "4:3"; - break; - case 16: - aspect = "16:10"; - break; - case 17: - aspect = "16:9"; - break; - case 12: - aspect = "5:4"; - break; - /* This catches 1.5625 as well (1600x1024) when maybe it shouldn't. */ - case 15: - aspect = "3:2"; - break; - case 18: - aspect = "9:5"; - break; - case 10: - aspect = "1:1"; - break; - } - } - - if (aspect != NULL) - return g_strdup_printf (_("%d x %d (%s)"), width, height, aspect); + if (width && height) { + if (width > height) + ratio = width * 10 / height; else - return g_strdup_printf (_("%d x %d"), width, height); + ratio = height * 10 / width; + + switch (ratio) { + case 13: + aspect = "4:3"; + break; + case 16: + aspect = "16:10"; + break; + case 17: + aspect = "16:9"; + break; + case 12: + aspect = "5:4"; + break; + /* This catches 1.5625 as well (1600x1024) when maybe it shouldn't. */ + case 15: + aspect = "3:2"; + break; + case 18: + aspect = "9:5"; + break; + case 10: + aspect = "1:1"; + break; + } + } + + if (aspect != NULL) + return g_strdup_printf (_("%d x %d (%s)"), width, height, aspect); + else + return g_strdup_printf (_("%d x %d"), width, height); } static void find_best_mode (GnomeRRMode **modes, int *out_width, int *out_height) { - int i; + int i; - *out_width = 0; - *out_height = 0; + *out_width = 0; + *out_height = 0; - for (i = 0; modes[i] != NULL; i++) + for (i = 0; modes[i] != NULL; i++) { - int w, h; + int w, h; - w = gnome_rr_mode_get_width (modes[i]); - h = gnome_rr_mode_get_height (modes[i]); + w = gnome_rr_mode_get_width (modes[i]); + h = gnome_rr_mode_get_height (modes[i]); - if (w * h > *out_width * *out_height) + if (w * h > *out_width * *out_height) { - *out_width = w; - *out_height = h; + *out_width = w; + *out_height = h; } } } @@ -598,301 +598,301 @@ find_best_mode (GnomeRRMode **modes, int *out_width, int *out_height) static void rebuild_resolution_combo (App *app) { - int i; - GnomeRRMode **modes; - const char *current; + int i; + GnomeRRMode **modes; + const char *current; - clear_combo (app->resolution_combo); + clear_combo (app->resolution_combo); - if (!(modes = get_current_modes (app)) - || !app->current_output - || !app->current_output->on) + if (!(modes = get_current_modes (app)) + || !app->current_output + || !app->current_output->on) { - gtk_widget_set_sensitive (app->resolution_combo, FALSE); - return; + gtk_widget_set_sensitive (app->resolution_combo, FALSE); + return; } - g_assert (app->current_output != NULL); - g_assert (app->current_output->width != 0 && app->current_output->height != 0); + g_assert (app->current_output != NULL); + g_assert (app->current_output->width != 0 && app->current_output->height != 0); - gtk_widget_set_sensitive (app->resolution_combo, TRUE); + gtk_widget_set_sensitive (app->resolution_combo, TRUE); - for (i = 0; modes[i] != NULL; ++i) + for (i = 0; modes[i] != NULL; ++i) { - int width, height; + int width, height; - width = gnome_rr_mode_get_width (modes[i]); - height = gnome_rr_mode_get_height (modes[i]); + width = gnome_rr_mode_get_width (modes[i]); + height = gnome_rr_mode_get_height (modes[i]); - add_key (app->resolution_combo, - idle_free (make_resolution_string (width, height)), - width, height, 0, -1); + add_key (app->resolution_combo, + idle_free (make_resolution_string (width, height)), + width, height, 0, -1); } - current = idle_free (make_resolution_string (app->current_output->width, app->current_output->height)); + current = idle_free (make_resolution_string (app->current_output->width, app->current_output->height)); - if (!combo_select (app->resolution_combo, current)) + if (!combo_select (app->resolution_combo, current)) { - int best_w, best_h; + int best_w, best_h; - find_best_mode (modes, &best_w, &best_h); - combo_select (app->resolution_combo, idle_free (make_resolution_string (best_w, best_h))); + find_best_mode (modes, &best_w, &best_h); + combo_select (app->resolution_combo, idle_free (make_resolution_string (best_w, best_h))); } } static void rebuild_gui (App *app) { - gboolean sensitive; + gboolean sensitive; - /* We would break spectacularly if we recursed, so - * just assert if that happens - */ - g_assert (app->ignore_gui_changes == FALSE); + /* We would break spectacularly if we recursed, so + * just assert if that happens + */ + g_assert (app->ignore_gui_changes == FALSE); - app->ignore_gui_changes = TRUE; + app->ignore_gui_changes = TRUE; - sensitive = app->current_output ? TRUE : FALSE; + sensitive = app->current_output ? TRUE : FALSE; #if 0 - g_debug ("rebuild gui, is on: %d", app->current_output->on); + g_debug ("rebuild gui, is on: %d", app->current_output->on); #endif - rebuild_mirror_screens (app); - rebuild_current_monitor_label (app); - rebuild_on_off_radios (app); - rebuild_resolution_combo (app); - rebuild_rotation_combo (app); + rebuild_mirror_screens (app); + rebuild_current_monitor_label (app); + rebuild_on_off_radios (app); + rebuild_resolution_combo (app); + rebuild_rotation_combo (app); #if 0 - g_debug ("sensitive: %d, on: %d", sensitive, app->current_output->on); + g_debug ("sensitive: %d, on: %d", sensitive, app->current_output->on); #endif - app->ignore_gui_changes = FALSE; + app->ignore_gui_changes = FALSE; } static gboolean get_mode (GtkWidget *widget, int *width, int *height, int *freq, GnomeRRRotation *rot) { - GtkTreeIter iter; - GtkTreeModel *model; - GtkComboBox *box = GTK_COMBO_BOX (widget); - int dummy; + GtkTreeIter iter; + GtkTreeModel *model; + GtkComboBox *box = GTK_COMBO_BOX (widget); + int dummy; - if (!gtk_combo_box_get_active_iter (box, &iter)) - return FALSE; + if (!gtk_combo_box_get_active_iter (box, &iter)) + return FALSE; - if (!width) - width = &dummy; + if (!width) + width = &dummy; - if (!height) - height = &dummy; + if (!height) + height = &dummy; - if (!freq) - freq = &dummy; + if (!freq) + freq = &dummy; - if (!rot) - rot = (GnomeRRRotation *)&dummy; + if (!rot) + rot = (GnomeRRRotation *)&dummy; - model = gtk_combo_box_get_model (box); - gtk_tree_model_get (model, &iter, - 1, width, - 2, height, - 3, freq, - 5, rot, - -1); + model = gtk_combo_box_get_model (box); + gtk_tree_model_get (model, &iter, + 1, width, + 2, height, + 3, freq, + 5, rot, + -1); - return TRUE; + return TRUE; } static void on_rotation_changed (GtkComboBox *box, gpointer data) { - App *app = data; - GnomeRRRotation rotation; + App *app = data; + GnomeRRRotation rotation; - if (!app->current_output) - return; + if (!app->current_output) + return; - if (get_mode (app->rotation_combo, NULL, NULL, NULL, &rotation)) - app->current_output->rotation = rotation; + if (get_mode (app->rotation_combo, NULL, NULL, NULL, &rotation)) + app->current_output->rotation = rotation; - foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); + foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); } static void select_resolution_for_current_output (App *app) { - GnomeRRMode **modes; - int width, height; + GnomeRRMode **modes; + int width, height; - if (app->current_output->pref_width != 0 && app->current_output->pref_height != 0) + if (app->current_output->pref_width != 0 && app->current_output->pref_height != 0) { - app->current_output->width = app->current_output->pref_width; - app->current_output->height = app->current_output->pref_height; - return; + app->current_output->width = app->current_output->pref_width; + app->current_output->height = app->current_output->pref_height; + return; } - modes = get_current_modes (app); - if (!modes) - return; + modes = get_current_modes (app); + if (!modes) + return; - find_best_mode (modes, &width, &height); + find_best_mode (modes, &width, &height); - app->current_output->width = width; - app->current_output->height = height; + app->current_output->width = width; + app->current_output->height = height; } static void monitor_on_off_toggled_cb (GtkToggleButton *toggle, gpointer data) { - App *app = data; - gboolean is_on; + App *app = data; + gboolean is_on; - if (!app->current_output) - return; + if (!app->current_output) + return; - if (!gtk_toggle_button_get_active (toggle)) - return; + if (!gtk_toggle_button_get_active (toggle)) + return; - if (GTK_WIDGET (toggle) == app->monitor_on_radio) - is_on = TRUE; - else if (GTK_WIDGET (toggle) == app->monitor_off_radio) - is_on = FALSE; - else + if (GTK_WIDGET (toggle) == app->monitor_on_radio) + is_on = TRUE; + else if (GTK_WIDGET (toggle) == app->monitor_off_radio) + is_on = FALSE; + else { - g_assert_not_reached (); - return; + g_assert_not_reached (); + return; } - app->current_output->on = is_on; + app->current_output->on = is_on; - if (is_on) - select_resolution_for_current_output (app); + if (is_on) + select_resolution_for_current_output (app); - rebuild_gui (app); - foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); + rebuild_gui (app); + foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); } static void realign_outputs_after_resolution_change (App *app, GnomeOutputInfo *output_that_changed, int old_width, int old_height) { - /* We find the outputs that were below or to the right of the output that - * changed, and realign them; we also do that for outputs that shared the - * right/bottom edges with the output that changed. The outputs that are - * above or to the left of that output don't need to change. - */ + /* We find the outputs that were below or to the right of the output that + * changed, and realign them; we also do that for outputs that shared the + * right/bottom edges with the output that changed. The outputs that are + * above or to the left of that output don't need to change. + */ - int i; - int old_right_edge, old_bottom_edge; - int dx, dy; + int i; + int old_right_edge, old_bottom_edge; + int dx, dy; - g_assert (app->current_configuration != NULL); + g_assert (app->current_configuration != NULL); - if (output_that_changed->width == old_width && output_that_changed->height == old_height) - return; + if (output_that_changed->width == old_width && output_that_changed->height == old_height) + return; - old_right_edge = output_that_changed->x + old_width; - old_bottom_edge = output_that_changed->y + old_height; + old_right_edge = output_that_changed->x + old_width; + old_bottom_edge = output_that_changed->y + old_height; - dx = output_that_changed->width - old_width; - dy = output_that_changed->height - old_height; + dx = output_that_changed->width - old_width; + dy = output_that_changed->height - old_height; - for (i = 0; app->current_configuration->outputs[i] != NULL; i++) { - GnomeOutputInfo *output; - int output_width, output_height; + for (i = 0; app->current_configuration->outputs[i] != NULL; i++) { + GnomeOutputInfo *output; + int output_width, output_height; - output = app->current_configuration->outputs[i]; + output = app->current_configuration->outputs[i]; - if (output == output_that_changed || !output->connected) - continue; + if (output == output_that_changed || !output->connected) + continue; - get_geometry (output, &output_width, &output_height); + get_geometry (output, &output_width, &output_height); - if (output->x >= old_right_edge) - output->x += dx; - else if (output->x + output_width == old_right_edge) - output->x = output_that_changed->x + output_that_changed->width - output_width; + if (output->x >= old_right_edge) + output->x += dx; + else if (output->x + output_width == old_right_edge) + output->x = output_that_changed->x + output_that_changed->width - output_width; - if (output->y >= old_bottom_edge) - output->y += dy; - else if (output->y + output_height == old_bottom_edge) - output->y = output_that_changed->y + output_that_changed->height - output_height; - } + if (output->y >= old_bottom_edge) + output->y += dy; + else if (output->y + output_height == old_bottom_edge) + output->y = output_that_changed->y + output_that_changed->height - output_height; + } } static void on_resolution_changed (GtkComboBox *box, gpointer data) { - App *app = data; - int old_width, old_height; - int width; - int height; + App *app = data; + int old_width, old_height; + int width; + int height; - if (!app->current_output) - return; + if (!app->current_output) + return; - old_width = app->current_output->width; - old_height = app->current_output->height; + old_width = app->current_output->width; + old_height = app->current_output->height; - if (get_mode (app->resolution_combo, &width, &height, NULL, NULL)) + if (get_mode (app->resolution_combo, &width, &height, NULL, NULL)) { - app->current_output->width = width; - app->current_output->height = height; + app->current_output->width = width; + app->current_output->height = height; - if (width == 0 || height == 0) - app->current_output->on = FALSE; - else - app->current_output->on = TRUE; + if (width == 0 || height == 0) + app->current_output->on = FALSE; + else + app->current_output->on = TRUE; } - realign_outputs_after_resolution_change (app, app->current_output, old_width, old_height); + realign_outputs_after_resolution_change (app, app->current_output, old_width, old_height); - rebuild_rotation_combo (app); + rebuild_rotation_combo (app); - foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); + foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); } static void lay_out_outputs_horizontally (App *app) { - int i; - int x; + int i; + int x; - /* Lay out all the monitors horizontally when "mirror screens" is turned - * off, to avoid having all of them overlapped initially. We put the - * outputs turned off on the right-hand side. - */ + /* Lay out all the monitors horizontally when "mirror screens" is turned + * off, to avoid having all of them overlapped initially. We put the + * outputs turned off on the right-hand side. + */ - x = 0; + x = 0; - /* First pass, all "on" outputs */ + /* First pass, all "on" outputs */ - for (i = 0; app->current_configuration->outputs[i]; ++i) + for (i = 0; app->current_configuration->outputs[i]; ++i) { - GnomeOutputInfo *output; + GnomeOutputInfo *output; - output = app->current_configuration->outputs[i]; - if (output->connected && output->on) { - output->x = x; - output->y = 0; - x += output->width; - } + output = app->current_configuration->outputs[i]; + if (output->connected && output->on) { + output->x = x; + output->y = 0; + x += output->width; + } } - /* Second pass, all the black screens */ + /* Second pass, all the black screens */ - for (i = 0; app->current_configuration->outputs[i]; ++i) + for (i = 0; app->current_configuration->outputs[i]; ++i) { - GnomeOutputInfo *output; + GnomeOutputInfo *output; - output = app->current_configuration->outputs[i]; - if (!(output->connected && output->on)) { - output->x = x; - output->y = 0; - x += output->width; - } + output = app->current_configuration->outputs[i]; + if (!(output->connected && output->on)) { + output->x = x; + output->y = 0; + x += output->width; + } } } @@ -903,129 +903,129 @@ lay_out_outputs_horizontally (App *app) static gboolean get_clone_size (GnomeRRScreen *screen, int *width, int *height) { - GnomeRRMode **modes = gnome_rr_screen_list_clone_modes (screen); - int best_w, best_h; - int i; + GnomeRRMode **modes = gnome_rr_screen_list_clone_modes (screen); + int best_w, best_h; + int i; - best_w = 0; - best_h = 0; + best_w = 0; + best_h = 0; - for (i = 0; modes[i] != NULL; ++i) { - GnomeRRMode *mode = modes[i]; - int w, h; + for (i = 0; modes[i] != NULL; ++i) { + GnomeRRMode *mode = modes[i]; + int w, h; - w = gnome_rr_mode_get_width (mode); - h = gnome_rr_mode_get_height (mode); + w = gnome_rr_mode_get_width (mode); + h = gnome_rr_mode_get_height (mode); - if (w * h > best_w * best_h) { - best_w = w; - best_h = h; - } - } + if (w * h > best_w * best_h) { + best_w = w; + best_h = h; + } + } - if (best_w > 0 && best_h > 0) { - if (width) - *width = best_w; - if (height) - *height = best_h; + if (best_w > 0 && best_h > 0) { + if (width) + *width = best_w; + if (height) + *height = best_h; - return TRUE; - } + return TRUE; + } - return FALSE; + return FALSE; } static gboolean output_info_supports_mode (App *app, GnomeOutputInfo *info, int width, int height) { - GnomeRROutput *output; - GnomeRRMode **modes; - int i; - - if (!info->connected) - return FALSE; - - output = gnome_rr_screen_get_output_by_name (app->screen, info->name); - if (!output) - return FALSE; - - modes = gnome_rr_output_list_modes (output); - - for (i = 0; modes[i]; i++) { - if (gnome_rr_mode_get_width (modes[i]) == width - && gnome_rr_mode_get_height (modes[i]) == height) - return TRUE; - } + GnomeRROutput *output; + GnomeRRMode **modes; + int i; + if (!info->connected) return FALSE; + + output = gnome_rr_screen_get_output_by_name (app->screen, info->name); + if (!output) + return FALSE; + + modes = gnome_rr_output_list_modes (output); + + for (i = 0; modes[i]; i++) { + if (gnome_rr_mode_get_width (modes[i]) == width + && gnome_rr_mode_get_height (modes[i]) == height) + return TRUE; + } + + return FALSE; } static void on_clone_changed (GtkWidget *box, gpointer data) { - App *app = data; + App *app = data; - app->current_configuration->clone = - gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (app->clone_checkbox)); + app->current_configuration->clone = + gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (app->clone_checkbox)); - if (app->current_configuration->clone) + if (app->current_configuration->clone) { - int i; - int width, height; + int i; + int width, height; - for (i = 0; app->current_configuration->outputs[i]; ++i) + for (i = 0; app->current_configuration->outputs[i]; ++i) { - if (app->current_configuration->outputs[i]->connected) + if (app->current_configuration->outputs[i]->connected) { - app->current_output = app->current_configuration->outputs[i]; - break; + app->current_output = app->current_configuration->outputs[i]; + break; } } - /* Turn on all the connected screens that support the best clone mode. - * The user may hit "Mirror Screens", but he shouldn't have to turn on - * all the required outputs as well. - */ + /* Turn on all the connected screens that support the best clone mode. + * The user may hit "Mirror Screens", but he shouldn't have to turn on + * all the required outputs as well. + */ - get_clone_size (app->screen, &width, &height); + get_clone_size (app->screen, &width, &height); - for (i = 0; app->current_configuration->outputs[i]; i++) { - if (output_info_supports_mode (app, app->current_configuration->outputs[i], width, height)) { - app->current_configuration->outputs[i]->on = TRUE; - app->current_configuration->outputs[i]->width = width; - app->current_configuration->outputs[i]->height = height; - } + for (i = 0; app->current_configuration->outputs[i]; i++) { + if (output_info_supports_mode (app, app->current_configuration->outputs[i], width, height)) { + app->current_configuration->outputs[i]->on = TRUE; + app->current_configuration->outputs[i]->width = width; + app->current_configuration->outputs[i]->height = height; } + } } - else + else { - if (output_overlaps (app->current_output, app->current_configuration)) - lay_out_outputs_horizontally (app); + if (output_overlaps (app->current_output, app->current_configuration)) + lay_out_outputs_horizontally (app); } - rebuild_gui (app); + rebuild_gui (app); } static void get_geometry (GnomeOutputInfo *output, int *w, int *h) { - if (output->on) + if (output->on) { - *h = output->height; - *w = output->width; + *h = output->height; + *w = output->width; } - else + else { - *h = output->pref_height; - *w = output->pref_width; + *h = output->pref_height; + *w = output->pref_width; + } + if ((output->rotation & GNOME_RR_ROTATION_90) || (output->rotation & GNOME_RR_ROTATION_270)) + { + int tmp; + tmp = *h; + *h = *w; + *w = tmp; } - if ((output->rotation & GNOME_RR_ROTATION_90) || (output->rotation & GNOME_RR_ROTATION_270)) - { - int tmp; - tmp = *h; - *h = *w; - *w = tmp; - } } #define SPACE 15 @@ -1034,227 +1034,227 @@ get_geometry (GnomeOutputInfo *output, int *w, int *h) static GList * list_connected_outputs (App *app, int *total_w, int *total_h) { - int i, dummy; - GList *result = NULL; + int i, dummy; + GList *result = NULL; - if (!total_w) - total_w = &dummy; - if (!total_h) - total_h = &dummy; + if (!total_w) + total_w = &dummy; + if (!total_h) + total_h = &dummy; - *total_w = 0; - *total_h = 0; - for (i = 0; app->current_configuration->outputs[i] != NULL; ++i) + *total_w = 0; + *total_h = 0; + for (i = 0; app->current_configuration->outputs[i] != NULL; ++i) { - GnomeOutputInfo *output = app->current_configuration->outputs[i]; + GnomeOutputInfo *output = app->current_configuration->outputs[i]; - if (output->connected) + if (output->connected) { - int w, h; + int w, h; - result = g_list_prepend (result, output); + result = g_list_prepend (result, output); - get_geometry (output, &w, &h); + get_geometry (output, &w, &h); - *total_w += w; - *total_h += h; + *total_w += w; + *total_h += h; } } - return g_list_reverse (result); + return g_list_reverse (result); } static int get_n_connected (App *app) { - GList *connected_outputs = list_connected_outputs (app, NULL, NULL); - int n = g_list_length (connected_outputs); + GList *connected_outputs = list_connected_outputs (app, NULL, NULL); + int n = g_list_length (connected_outputs); - g_list_free (connected_outputs); + g_list_free (connected_outputs); - return n; + return n; } static double compute_scale (App *app) { - int available_w, available_h; - int total_w, total_h; - int n_monitors; - GdkRectangle viewport; - GList *connected_outputs; + int available_w, available_h; + int total_w, total_h; + int n_monitors; + GdkRectangle viewport; + GList *connected_outputs; - foo_scroll_area_get_viewport (FOO_SCROLL_AREA (app->area), &viewport); + foo_scroll_area_get_viewport (FOO_SCROLL_AREA (app->area), &viewport); - connected_outputs = list_connected_outputs (app, &total_w, &total_h); + connected_outputs = list_connected_outputs (app, &total_w, &total_h); - n_monitors = g_list_length (connected_outputs); + n_monitors = g_list_length (connected_outputs); - g_list_free (connected_outputs); + g_list_free (connected_outputs); - available_w = viewport.width - 2 * MARGIN - (n_monitors - 1) * SPACE; - available_h = viewport.height - 2 * MARGIN - (n_monitors - 1) * SPACE; + available_w = viewport.width - 2 * MARGIN - (n_monitors - 1) * SPACE; + available_h = viewport.height - 2 * MARGIN - (n_monitors - 1) * SPACE; - return MIN ((double)available_w / total_w, (double)available_h / total_h); + return MIN ((double)available_w / total_w, (double)available_h / total_h); } typedef struct Edge { - GnomeOutputInfo *output; - int x1, y1; - int x2, y2; + GnomeOutputInfo *output; + int x1, y1; + int x2, y2; } Edge; typedef struct Snap { - Edge *snapper; /* Edge that should be snapped */ - Edge *snappee; - int dy, dx; + Edge *snapper; /* Edge that should be snapped */ + Edge *snappee; + int dy, dx; } Snap; static void add_edge (GnomeOutputInfo *output, int x1, int y1, int x2, int y2, GArray *edges) { - Edge e; + Edge e; - e.x1 = x1; - e.x2 = x2; - e.y1 = y1; - e.y2 = y2; - e.output = output; + e.x1 = x1; + e.x2 = x2; + e.y1 = y1; + e.y2 = y2; + e.output = output; - g_array_append_val (edges, e); + g_array_append_val (edges, e); } static void list_edges_for_output (GnomeOutputInfo *output, GArray *edges) { - int x, y, w, h; + int x, y, w, h; - x = output->x; - y = output->y; - get_geometry (output, &w, &h); + x = output->x; + y = output->y; + get_geometry (output, &w, &h); - /* Top, Bottom, Left, Right */ - add_edge (output, x, y, x + w, y, edges); - add_edge (output, x, y + h, x + w, y + h, edges); - add_edge (output, x, y, x, y + h, edges); - add_edge (output, x + w, y, x + w, y + h, edges); + /* Top, Bottom, Left, Right */ + add_edge (output, x, y, x + w, y, edges); + add_edge (output, x, y + h, x + w, y + h, edges); + add_edge (output, x, y, x, y + h, edges); + add_edge (output, x + w, y, x + w, y + h, edges); } static void list_edges (GnomeRRConfig *config, GArray *edges) { - int i; + int i; - for (i = 0; config->outputs[i]; ++i) + for (i = 0; config->outputs[i]; ++i) { - GnomeOutputInfo *output = config->outputs[i]; + GnomeOutputInfo *output = config->outputs[i]; - if (output->connected) - list_edges_for_output (output, edges); + if (output->connected) + list_edges_for_output (output, edges); } } static gboolean overlap (int s1, int e1, int s2, int e2) { - return (!(e1 < s2 || s1 >= e2)); + return (!(e1 < s2 || s1 >= e2)); } static gboolean horizontal_overlap (Edge *snapper, Edge *snappee) { - if (snapper->y1 != snapper->y2 || snappee->y1 != snappee->y2) - return FALSE; + if (snapper->y1 != snapper->y2 || snappee->y1 != snappee->y2) + return FALSE; - return overlap (snapper->x1, snapper->x2, snappee->x1, snappee->x2); + return overlap (snapper->x1, snapper->x2, snappee->x1, snappee->x2); } static gboolean vertical_overlap (Edge *snapper, Edge *snappee) { - if (snapper->x1 != snapper->x2 || snappee->x1 != snappee->x2) - return FALSE; + if (snapper->x1 != snapper->x2 || snappee->x1 != snappee->x2) + return FALSE; - return overlap (snapper->y1, snapper->y2, snappee->y1, snappee->y2); + return overlap (snapper->y1, snapper->y2, snappee->y1, snappee->y2); } static void add_snap (GArray *snaps, Snap snap) { - if (ABS (snap.dx) <= 200 || ABS (snap.dy) <= 200) - g_array_append_val (snaps, snap); + if (ABS (snap.dx) <= 200 || ABS (snap.dy) <= 200) + g_array_append_val (snaps, snap); } static void add_edge_snaps (Edge *snapper, Edge *snappee, GArray *snaps) { - Snap snap; + Snap snap; - snap.snapper = snapper; - snap.snappee = snappee; + snap.snapper = snapper; + snap.snappee = snappee; - if (horizontal_overlap (snapper, snappee)) + if (horizontal_overlap (snapper, snappee)) { - snap.dx = 0; - snap.dy = snappee->y1 - snapper->y1; + snap.dx = 0; + snap.dy = snappee->y1 - snapper->y1; - add_snap (snaps, snap); + add_snap (snaps, snap); } - else if (vertical_overlap (snapper, snappee)) + else if (vertical_overlap (snapper, snappee)) { - snap.dy = 0; - snap.dx = snappee->x1 - snapper->x1; + snap.dy = 0; + snap.dx = snappee->x1 - snapper->x1; - add_snap (snaps, snap); + add_snap (snaps, snap); } - /* Corner snaps */ - /* 1->1 */ - snap.dx = snappee->x1 - snapper->x1; - snap.dy = snappee->y1 - snapper->y1; + /* Corner snaps */ + /* 1->1 */ + snap.dx = snappee->x1 - snapper->x1; + snap.dy = snappee->y1 - snapper->y1; - add_snap (snaps, snap); + add_snap (snaps, snap); - /* 1->2 */ - snap.dx = snappee->x2 - snapper->x1; - snap.dy = snappee->y2 - snapper->y1; + /* 1->2 */ + snap.dx = snappee->x2 - snapper->x1; + snap.dy = snappee->y2 - snapper->y1; - add_snap (snaps, snap); + add_snap (snaps, snap); - /* 2->2 */ - snap.dx = snappee->x2 - snapper->x2; - snap.dy = snappee->y2 - snapper->y2; + /* 2->2 */ + snap.dx = snappee->x2 - snapper->x2; + snap.dy = snappee->y2 - snapper->y2; - add_snap (snaps, snap); + add_snap (snaps, snap); - /* 2->1 */ - snap.dx = snappee->x1 - snapper->x2; - snap.dy = snappee->y1 - snapper->y2; + /* 2->1 */ + snap.dx = snappee->x1 - snapper->x2; + snap.dy = snappee->y1 - snapper->y2; - add_snap (snaps, snap); + add_snap (snaps, snap); } static void list_snaps (GnomeOutputInfo *output, GArray *edges, GArray *snaps) { - int i; + int i; - for (i = 0; i < edges->len; ++i) + for (i = 0; i < edges->len; ++i) { - Edge *output_edge = &(g_array_index (edges, Edge, i)); + Edge *output_edge = &(g_array_index (edges, Edge, i)); - if (output_edge->output == output) + if (output_edge->output == output) { - int j; + int j; - for (j = 0; j < edges->len; ++j) + for (j = 0; j < edges->len; ++j) { - Edge *edge = &(g_array_index (edges, Edge, j)); + Edge *edge = &(g_array_index (edges, Edge, j)); - if (edge->output != output) - add_edge_snaps (output_edge, edge, snaps); + if (edge->output != output) + add_edge_snaps (output_edge, edge, snaps); } } } @@ -1264,182 +1264,182 @@ list_snaps (GnomeOutputInfo *output, GArray *edges, GArray *snaps) static void print_edge (Edge *edge) { - g_debug ("(%d %d %d %d)", edge->x1, edge->y1, edge->x2, edge->y2); + g_debug ("(%d %d %d %d)", edge->x1, edge->y1, edge->x2, edge->y2); } #endif static gboolean corner_on_edge (int x, int y, Edge *e) { - if (x == e->x1 && x == e->x2 && y >= e->y1 && y <= e->y2) - return TRUE; + if (x == e->x1 && x == e->x2 && y >= e->y1 && y <= e->y2) + return TRUE; - if (y == e->y1 && y == e->y2 && x >= e->x1 && x <= e->x2) - return TRUE; + if (y == e->y1 && y == e->y2 && x >= e->x1 && x <= e->x2) + return TRUE; - return FALSE; + return FALSE; } static gboolean edges_align (Edge *e1, Edge *e2) { - if (corner_on_edge (e1->x1, e1->y1, e2)) - return TRUE; + if (corner_on_edge (e1->x1, e1->y1, e2)) + return TRUE; - if (corner_on_edge (e2->x1, e2->y1, e1)) - return TRUE; + if (corner_on_edge (e2->x1, e2->y1, e1)) + return TRUE; - return FALSE; + return FALSE; } static gboolean output_is_aligned (GnomeOutputInfo *output, GArray *edges) { - gboolean result = FALSE; - int i; + gboolean result = FALSE; + int i; - for (i = 0; i < edges->len; ++i) + for (i = 0; i < edges->len; ++i) { - Edge *output_edge = &(g_array_index (edges, Edge, i)); + Edge *output_edge = &(g_array_index (edges, Edge, i)); - if (output_edge->output == output) + if (output_edge->output == output) { - int j; + int j; - for (j = 0; j < edges->len; ++j) + for (j = 0; j < edges->len; ++j) { - Edge *edge = &(g_array_index (edges, Edge, j)); + Edge *edge = &(g_array_index (edges, Edge, j)); - /* We are aligned if an output edge matches - * an edge of another output - */ - if (edge->output != output_edge->output) + /* We are aligned if an output edge matches + * an edge of another output + */ + if (edge->output != output_edge->output) { - if (edges_align (output_edge, edge)) + if (edges_align (output_edge, edge)) { - result = TRUE; - goto done; + result = TRUE; + goto done; } } } } } -done: + done: - return result; + return result; } static void get_output_rect (GnomeOutputInfo *output, GdkRectangle *rect) { - int w, h; + int w, h; - get_geometry (output, &w, &h); + get_geometry (output, &w, &h); - rect->width = w; - rect->height = h; - rect->x = output->x; - rect->y = output->y; + rect->width = w; + rect->height = h; + rect->x = output->x; + rect->y = output->y; } static gboolean output_overlaps (GnomeOutputInfo *output, GnomeRRConfig *config) { - int i; - GdkRectangle output_rect; + int i; + GdkRectangle output_rect; - g_assert (output != NULL); + g_assert (output != NULL); - get_output_rect (output, &output_rect); + get_output_rect (output, &output_rect); - for (i = 0; config->outputs[i]; ++i) + for (i = 0; config->outputs[i]; ++i) { - GnomeOutputInfo *other = config->outputs[i]; + GnomeOutputInfo *other = config->outputs[i]; - if (other != output && other->connected) + if (other != output && other->connected) { - GdkRectangle other_rect; + GdkRectangle other_rect; - get_output_rect (other, &other_rect); - if (gdk_rectangle_intersect (&output_rect, &other_rect, NULL)) - return TRUE; + get_output_rect (other, &other_rect); + if (gdk_rectangle_intersect (&output_rect, &other_rect, NULL)) + return TRUE; } } - return FALSE; + return FALSE; } static gboolean gnome_rr_config_is_aligned (GnomeRRConfig *config, GArray *edges) { - int i; - gboolean result = TRUE; + int i; + gboolean result = TRUE; - for (i = 0; config->outputs[i]; ++i) + for (i = 0; config->outputs[i]; ++i) { - GnomeOutputInfo *output = config->outputs[i]; + GnomeOutputInfo *output = config->outputs[i]; - if (output->connected) + if (output->connected) { - if (!output_is_aligned (output, edges)) - return FALSE; + if (!output_is_aligned (output, edges)) + return FALSE; - if (output_overlaps (output, config)) - return FALSE; + if (output_overlaps (output, config)) + return FALSE; } } - return result; + return result; } struct GrabInfo { - int grab_x; - int grab_y; - int output_x; - int output_y; + int grab_x; + int grab_y; + int output_x; + int output_y; }; static gboolean is_corner_snap (const Snap *s) { - return s->dx != 0 && s->dy != 0; + return s->dx != 0 && s->dy != 0; } static int compare_snaps (gconstpointer v1, gconstpointer v2) { - const Snap *s1 = v1; - const Snap *s2 = v2; - int sv1 = MAX (ABS (s1->dx), ABS (s1->dy)); - int sv2 = MAX (ABS (s2->dx), ABS (s2->dy)); - int d; + const Snap *s1 = v1; + const Snap *s2 = v2; + int sv1 = MAX (ABS (s1->dx), ABS (s1->dy)); + int sv2 = MAX (ABS (s2->dx), ABS (s2->dy)); + int d; - d = sv1 - sv2; + d = sv1 - sv2; - /* This snapping algorithm is good enough for rock'n'roll, but - * this is probably a better: - * - * First do a horizontal/vertical snap, then - * with the new coordinates from that snap, - * do a corner snap. - * - * Right now, it's confusing that corner snapping - * depends on the distance in an axis that you can't actually see. - * - */ - if (d == 0) + /* This snapping algorithm is good enough for rock'n'roll, but + * this is probably a better: + * + * First do a horizontal/vertical snap, then + * with the new coordinates from that snap, + * do a corner snap. + * + * Right now, it's confusing that corner snapping + * depends on the distance in an axis that you can't actually see. + * + */ + if (d == 0) { - if (is_corner_snap (s1) && !is_corner_snap (s2)) - return -1; - else if (is_corner_snap (s2) && !is_corner_snap (s1)) - return 1; - else - return 0; + if (is_corner_snap (s1) && !is_corner_snap (s2)) + return -1; + else if (is_corner_snap (s2) && !is_corner_snap (s1)) + return 1; + else + return 0; } - else + else { - return d; + return d; } } @@ -1450,34 +1450,34 @@ compare_snaps (gconstpointer v1, gconstpointer v2) static void set_cursor (GtkWidget *widget, GdkCursorType type) { - GdkCursor *cursor; - GdkWindow *window; + GdkCursor *cursor; + GdkWindow *window; - if (type == GDK_BLANK_CURSOR) - cursor = NULL; - else - cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), type); + if (type == GDK_BLANK_CURSOR) + cursor = NULL; + else + cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), type); - window = gtk_widget_get_window (widget); + window = gtk_widget_get_window (widget); - if (window) - gdk_window_set_cursor (window, cursor); + if (window) + gdk_window_set_cursor (window, cursor); - if (cursor) - gdk_cursor_unref (cursor); + if (cursor) + gdk_cursor_unref (cursor); } static void set_monitors_tooltip (App *app, gboolean is_dragging) { - const char *text; + const char *text; - if (is_dragging) - text = NULL; - else - text = _("Select a monitor to change its properties; drag it to rearrange its placement."); + if (is_dragging) + text = NULL; + else + text = _("Select a monitor to change its properties; drag it to rearrange its placement."); - gtk_widget_set_tooltip_text (app->area, text); + gtk_widget_set_tooltip_text (app->area, text); } static void @@ -1485,112 +1485,112 @@ on_output_event (FooScrollArea *area, FooScrollAreaEvent *event, gpointer data) { - GnomeOutputInfo *output = data; - App *app = g_object_get_data (G_OBJECT (area), "app"); + GnomeOutputInfo *output = data; + App *app = g_object_get_data (G_OBJECT (area), "app"); - /* If the mouse is inside the outputs, set the cursor to "you can move me". See - * on_canvas_event() for where we reset the cursor to the default if it - * exits the outputs' area. - */ - if (!app->current_configuration->clone && get_n_connected (app) > 1) - set_cursor (GTK_WIDGET (area), GDK_FLEUR); + /* If the mouse is inside the outputs, set the cursor to "you can move me". See + * on_canvas_event() for where we reset the cursor to the default if it + * exits the outputs' area. + */ + if (!app->current_configuration->clone && get_n_connected (app) > 1) + set_cursor (GTK_WIDGET (area), GDK_FLEUR); - if (event->type == FOO_BUTTON_PRESS) + if (event->type == FOO_BUTTON_PRESS) { - GrabInfo *info; + GrabInfo *info; - app->current_output = output; + app->current_output = output; - rebuild_gui (app); - set_monitors_tooltip (app, TRUE); + rebuild_gui (app); + set_monitors_tooltip (app, TRUE); - if (!app->current_configuration->clone && get_n_connected (app) > 1) + if (!app->current_configuration->clone && get_n_connected (app) > 1) { - foo_scroll_area_begin_grab (area, on_output_event, data); + foo_scroll_area_begin_grab (area, on_output_event, data); - info = g_new0 (GrabInfo, 1); - info->grab_x = event->x; - info->grab_y = event->y; - info->output_x = output->x; - info->output_y = output->y; + info = g_new0 (GrabInfo, 1); + info->grab_x = event->x; + info->grab_y = event->y; + info->output_x = output->x; + info->output_y = output->y; - output->user_data = info; + output->user_data = info; } - foo_scroll_area_invalidate (area); + foo_scroll_area_invalidate (area); } - else + else { - if (foo_scroll_area_is_grabbed (area)) + if (foo_scroll_area_is_grabbed (area)) { - GrabInfo *info = output->user_data; - double scale = compute_scale (app); - int old_x, old_y; - int new_x, new_y; - int i; - GArray *edges, *snaps, *new_edges; + GrabInfo *info = output->user_data; + double scale = compute_scale (app); + int old_x, old_y; + int new_x, new_y; + int i; + GArray *edges, *snaps, *new_edges; - old_x = output->x; - old_y = output->y; - new_x = info->output_x + (event->x - info->grab_x) / scale; - new_y = info->output_y + (event->y - info->grab_y) / scale; + old_x = output->x; + old_y = output->y; + new_x = info->output_x + (event->x - info->grab_x) / scale; + new_y = info->output_y + (event->y - info->grab_y) / scale; - output->x = new_x; - output->y = new_y; + output->x = new_x; + output->y = new_y; - edges = g_array_new (TRUE, TRUE, sizeof (Edge)); - snaps = g_array_new (TRUE, TRUE, sizeof (Snap)); - new_edges = g_array_new (TRUE, TRUE, sizeof (Edge)); + edges = g_array_new (TRUE, TRUE, sizeof (Edge)); + snaps = g_array_new (TRUE, TRUE, sizeof (Snap)); + new_edges = g_array_new (TRUE, TRUE, sizeof (Edge)); - list_edges (app->current_configuration, edges); - list_snaps (output, edges, snaps); + list_edges (app->current_configuration, edges); + list_snaps (output, edges, snaps); - g_array_sort (snaps, compare_snaps); + g_array_sort (snaps, compare_snaps); - output->x = info->output_x; - output->y = info->output_y; + output->x = info->output_x; + output->y = info->output_y; - for (i = 0; i < snaps->len; ++i) + for (i = 0; i < snaps->len; ++i) { - Snap *snap = &(g_array_index (snaps, Snap, i)); - GArray *new_edges = g_array_new (TRUE, TRUE, sizeof (Edge)); + Snap *snap = &(g_array_index (snaps, Snap, i)); + GArray *new_edges = g_array_new (TRUE, TRUE, sizeof (Edge)); - output->x = new_x + snap->dx; - output->y = new_y + snap->dy; + output->x = new_x + snap->dx; + output->y = new_y + snap->dy; - g_array_set_size (new_edges, 0); - list_edges (app->current_configuration, new_edges); + g_array_set_size (new_edges, 0); + list_edges (app->current_configuration, new_edges); - if (gnome_rr_config_is_aligned (app->current_configuration, new_edges)) + if (gnome_rr_config_is_aligned (app->current_configuration, new_edges)) { - g_array_free (new_edges, TRUE); - break; + g_array_free (new_edges, TRUE); + break; } - else + else { - output->x = info->output_x; - output->y = info->output_y; + output->x = info->output_x; + output->y = info->output_y; } } - g_array_free (new_edges, TRUE); - g_array_free (snaps, TRUE); - g_array_free (edges, TRUE); + g_array_free (new_edges, TRUE); + g_array_free (snaps, TRUE); + g_array_free (edges, TRUE); - if (event->type == FOO_BUTTON_RELEASE) + if (event->type == FOO_BUTTON_RELEASE) { - foo_scroll_area_end_grab (area); - set_monitors_tooltip (app, FALSE); + foo_scroll_area_end_grab (area); + set_monitors_tooltip (app, FALSE); - g_free (output->user_data); - output->user_data = NULL; + g_free (output->user_data); + output->user_data = NULL; #if 0 - g_debug ("new position: %d %d %d %d", output->x, output->y, output->width, output->height); + g_debug ("new position: %d %d %d %d", output->x, output->y, output->width, output->height); #endif } - foo_scroll_area_invalidate (area); + foo_scroll_area_invalidate (area); } } } @@ -1600,204 +1600,204 @@ on_canvas_event (FooScrollArea *area, FooScrollAreaEvent *event, gpointer data) { - /* If the mouse exits the outputs, reset the cursor to the default. See - * on_output_event() for where we set the cursor to the movement cursor if - * it is over one of the outputs. - */ - set_cursor (GTK_WIDGET (area), GDK_BLANK_CURSOR); + /* If the mouse exits the outputs, reset the cursor to the default. See + * on_output_event() for where we set the cursor to the movement cursor if + * it is over one of the outputs. + */ + set_cursor (GTK_WIDGET (area), GDK_BLANK_CURSOR); } static PangoLayout * get_display_name (App *app, GnomeOutputInfo *output) { - PangoLayout *layout; - char *text; + PangoLayout *layout; + char *text; - if (app->current_configuration->clone) { - /* Translators: this is the feature where what you see on your laptop's - * screen is the same as your external monitor. Here, "Mirror" is being - * used as an adjective, not as a verb. For example, the Spanish - * translation could be "Pantallas en Espejo", *not* "Espejar Pantallas". - */ - text = g_strdup(_("Mirror Screens")); - } else { - text = g_strdup (output->display_name); - } + if (app->current_configuration->clone) { + /* Translators: this is the feature where what you see on your laptop's + * screen is the same as your external monitor. Here, "Mirror" is being + * used as an adjective, not as a verb. For example, the Spanish + * translation could be "Pantallas en Espejo", *not* "Espejar Pantallas". + */ + text = g_strdup(_("Mirror Screens")); + } else { + text = g_strdup (output->display_name); + } - layout = gtk_widget_create_pango_layout (GTK_WIDGET (app->area), text); - g_free (text); - pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER); + layout = gtk_widget_create_pango_layout (GTK_WIDGET (app->area), text); + g_free (text); + pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER); - return layout; + return layout; } static void paint_background (FooScrollArea *area, cairo_t *cr) { - GdkRectangle viewport; - GtkWidget *widget; - GtkStyle *widget_style; + GdkRectangle viewport; + GtkWidget *widget; + GtkStyle *widget_style; - widget = GTK_WIDGET (area); + widget = GTK_WIDGET (area); - foo_scroll_area_get_viewport (area, &viewport); - widget_style = gtk_widget_get_style (widget); + foo_scroll_area_get_viewport (area, &viewport); + widget_style = gtk_widget_get_style (widget); - cairo_set_source_rgb (cr, - widget_style->mid[GTK_STATE_NORMAL].red / 65535.0, - widget_style->mid[GTK_STATE_NORMAL].green / 65535.0, - widget_style->mid[GTK_STATE_NORMAL].blue / 65535.0); + cairo_set_source_rgb (cr, + widget_style->mid[GTK_STATE_NORMAL].red / 65535.0, + widget_style->mid[GTK_STATE_NORMAL].green / 65535.0, + widget_style->mid[GTK_STATE_NORMAL].blue / 65535.0); - cairo_rectangle (cr, - viewport.x, viewport.y, - viewport.width, viewport.height); + cairo_rectangle (cr, + viewport.x, viewport.y, + viewport.width, viewport.height); - cairo_fill_preserve (cr); + cairo_fill_preserve (cr); - foo_scroll_area_add_input_from_fill (area, cr, on_canvas_event, NULL); + foo_scroll_area_add_input_from_fill (area, cr, on_canvas_event, NULL); - cairo_set_source_rgb (cr, - widget_style->dark[GTK_STATE_NORMAL].red / 65535.0, - widget_style->dark[GTK_STATE_NORMAL].green / 65535.0, - widget_style->dark[GTK_STATE_NORMAL].blue / 65535.0); + cairo_set_source_rgb (cr, + widget_style->dark[GTK_STATE_NORMAL].red / 65535.0, + widget_style->dark[GTK_STATE_NORMAL].green / 65535.0, + widget_style->dark[GTK_STATE_NORMAL].blue / 65535.0); - cairo_stroke (cr); + cairo_stroke (cr); } static void paint_output (App *app, cairo_t *cr, int i) { - int w, h; - double scale = compute_scale (app); - double x, y; - int total_w, total_h; - GList *connected_outputs = list_connected_outputs (app, &total_w, &total_h); - GnomeOutputInfo *output = g_list_nth (connected_outputs, i)->data; - PangoLayout *layout = get_display_name (app, output); - PangoRectangle ink_extent, log_extent; - GdkRectangle viewport; - GdkColor output_color; - double r, g, b; - double available_w; - double factor; + int w, h; + double scale = compute_scale (app); + double x, y; + int total_w, total_h; + GList *connected_outputs = list_connected_outputs (app, &total_w, &total_h); + GnomeOutputInfo *output = g_list_nth (connected_outputs, i)->data; + PangoLayout *layout = get_display_name (app, output); + PangoRectangle ink_extent, log_extent; + GdkRectangle viewport; + GdkColor output_color; + double r, g, b; + double available_w; + double factor; - cairo_save (cr); + cairo_save (cr); - foo_scroll_area_get_viewport (FOO_SCROLL_AREA (app->area), &viewport); - get_geometry (output, &w, &h); + foo_scroll_area_get_viewport (FOO_SCROLL_AREA (app->area), &viewport); + get_geometry (output, &w, &h); #if 0 - g_debug ("%s (%p) geometry %d %d %d", output->name, output, - w, h, output->rate); + g_debug ("%s (%p) geometry %d %d %d", output->name, output, + w, h, output->rate); #endif - viewport.height -= 2 * MARGIN; - viewport.width -= 2 * MARGIN; + viewport.height -= 2 * MARGIN; + viewport.width -= 2 * MARGIN; - x = output->x * scale + MARGIN + (viewport.width - total_w * scale) / 2.0; - y = output->y * scale + MARGIN + (viewport.height - total_h * scale) / 2.0; + x = output->x * scale + MARGIN + (viewport.width - total_w * scale) / 2.0; + y = output->y * scale + MARGIN + (viewport.height - total_h * scale) / 2.0; #if 0 - g_debug ("scaled: %f %f", x, y); + g_debug ("scaled: %f %f", x, y); - g_debug ("scale: %f", scale); + g_debug ("scale: %f", scale); - g_debug ("%f %f %f %f", x, y, w * scale + 0.5, h * scale + 0.5); + g_debug ("%f %f %f %f", x, y, w * scale + 0.5, h * scale + 0.5); #endif - cairo_translate (cr, - x + (w * scale + 0.5) / 2, - y + (h * scale + 0.5) / 2); + cairo_translate (cr, + x + (w * scale + 0.5) / 2, + y + (h * scale + 0.5) / 2); - /* rotation is already applied in get_geometry */ + /* rotation is already applied in get_geometry */ - if (output->rotation & GNOME_RR_REFLECT_X) - cairo_scale (cr, -1, 1); + if (output->rotation & GNOME_RR_REFLECT_X) + cairo_scale (cr, -1, 1); - if (output->rotation & GNOME_RR_REFLECT_Y) - cairo_scale (cr, 1, -1); + if (output->rotation & GNOME_RR_REFLECT_Y) + cairo_scale (cr, 1, -1); - cairo_translate (cr, - - x - (w * scale + 0.5) / 2, - - y - (h * scale + 0.5) / 2); + cairo_translate (cr, + - x - (w * scale + 0.5) / 2, + - y - (h * scale + 0.5) / 2); - if (output == app->current_output) + if (output == app->current_output) { - GtkStyle *style; - GdkColor color; - double r, g, b; + GtkStyle *style; + GdkColor color; + double r, g, b; - style = gtk_widget_get_style (app->area); - color = style->bg[GTK_STATE_SELECTED]; - r = (float)color.red / 65535.0; - g = (float)color.green / 65535.0; - b = (float)color.blue / 65535.0; + style = gtk_widget_get_style (app->area); + color = style->bg[GTK_STATE_SELECTED]; + r = (float)color.red / 65535.0; + g = (float)color.green / 65535.0; + b = (float)color.blue / 65535.0; - cairo_rectangle (cr, x - 2, y - 2, w * scale + 0.5 + 4, h * scale + 0.5 + 4); + cairo_rectangle (cr, x - 2, y - 2, w * scale + 0.5 + 4, h * scale + 0.5 + 4); - cairo_set_line_width (cr, 4); - cairo_set_source_rgba (cr, r, g, b, 0.5); - cairo_stroke (cr); + cairo_set_line_width (cr, 4); + cairo_set_source_rgba (cr, r, g, b, 0.5); + cairo_stroke (cr); } - cairo_rectangle (cr, x, y, w * scale + 0.5, h * scale + 0.5); - cairo_clip_preserve (cr); + cairo_rectangle (cr, x, y, w * scale + 0.5, h * scale + 0.5); + cairo_clip_preserve (cr); - gnome_rr_labeler_get_color_for_output (app->labeler, output, &output_color); - r = output_color.red / 65535.0; - g = output_color.green / 65535.0; - b = output_color.blue / 65535.0; + gnome_rr_labeler_get_color_for_output (app->labeler, output, &output_color); + r = output_color.red / 65535.0; + g = output_color.green / 65535.0; + b = output_color.blue / 65535.0; - if (!output->on) + if (!output->on) { - /* If the output is turned off, just darken the selected color */ - r *= 0.2; - g *= 0.2; - b *= 0.2; + /* If the output is turned off, just darken the selected color */ + r *= 0.2; + g *= 0.2; + b *= 0.2; } - cairo_set_source_rgba (cr, r, g, b, 1.0); + cairo_set_source_rgba (cr, r, g, b, 1.0); - foo_scroll_area_add_input_from_fill (FOO_SCROLL_AREA (app->area), - cr, on_output_event, output); - cairo_fill (cr); + foo_scroll_area_add_input_from_fill (FOO_SCROLL_AREA (app->area), + cr, on_output_event, output); + cairo_fill (cr); - cairo_rectangle (cr, x + 0.5, y + 0.5, w * scale + 0.5 - 1, h * scale + 0.5 - 1); + cairo_rectangle (cr, x + 0.5, y + 0.5, w * scale + 0.5 - 1, h * scale + 0.5 - 1); - cairo_set_line_width (cr, 1); - cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0); + cairo_set_line_width (cr, 1); + cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0); - cairo_stroke (cr); - cairo_set_line_width (cr, 2); + cairo_stroke (cr); + cairo_set_line_width (cr, 2); - layout_set_font (layout, "Sans 10"); - pango_layout_get_pixel_extents (layout, &ink_extent, &log_extent); + layout_set_font (layout, "Sans 10"); + pango_layout_get_pixel_extents (layout, &ink_extent, &log_extent); - available_w = w * scale + 0.5 - 6; /* Same as the inner rectangle's width, minus 1 pixel of padding on each side */ - if (available_w < ink_extent.width) - factor = available_w / ink_extent.width; - else - factor = 1.0; + available_w = w * scale + 0.5 - 6; /* Same as the inner rectangle's width, minus 1 pixel of padding on each side */ + if (available_w < ink_extent.width) + factor = available_w / ink_extent.width; + else + factor = 1.0; - cairo_move_to (cr, - x + ((w * scale + 0.5) - factor * log_extent.width) / 2, - y + ((h * scale + 0.5) - factor * log_extent.height) / 2); + cairo_move_to (cr, + x + ((w * scale + 0.5) - factor * log_extent.width) / 2, + y + ((h * scale + 0.5) - factor * log_extent.height) / 2); - cairo_scale (cr, factor, factor); + cairo_scale (cr, factor, factor); - if (output->on) - cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); - else - cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); + if (output->on) + cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); + else + cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); - pango_cairo_show_layout (cr, layout); + pango_cairo_show_layout (cr, layout); - cairo_restore (cr); + cairo_restore (cr); - g_object_unref (layout); + g_object_unref (layout); } static void @@ -1805,115 +1805,115 @@ on_area_paint (FooScrollArea *area, cairo_t *cr, gpointer data) { - App *app = data; - double scale; - GList *connected_outputs = NULL; - GList *list; + App *app = data; + double scale; + GList *connected_outputs = NULL; + GList *list; - paint_background (area, cr); + paint_background (area, cr); - if (!app->current_configuration) - return; + if (!app->current_configuration) + return; - scale = compute_scale (app); - connected_outputs = list_connected_outputs (app, NULL, NULL); + scale = compute_scale (app); + connected_outputs = list_connected_outputs (app, NULL, NULL); #if 0 - g_debug ("scale: %f", scale); + g_debug ("scale: %f", scale); #endif - for (list = connected_outputs; list != NULL; list = list->next) + for (list = connected_outputs; list != NULL; list = list->next) { - paint_output (app, cr, g_list_position (connected_outputs, list)); + paint_output (app, cr, g_list_position (connected_outputs, list)); - if (app->current_configuration->clone) - break; + if (app->current_configuration->clone) + break; } } static void make_text_combo (GtkWidget *widget, int sort_column) { - GtkComboBox *box = GTK_COMBO_BOX (widget); - GtkListStore *store = gtk_list_store_new ( - 6, - G_TYPE_STRING, /* Text */ - G_TYPE_INT, /* Width */ - G_TYPE_INT, /* Height */ - G_TYPE_INT, /* Frequency */ - G_TYPE_INT, /* Width * Height */ - G_TYPE_INT); /* Rotation */ + GtkComboBox *box = GTK_COMBO_BOX (widget); + GtkListStore *store = gtk_list_store_new ( + 6, + G_TYPE_STRING, /* Text */ + G_TYPE_INT, /* Width */ + G_TYPE_INT, /* Height */ + G_TYPE_INT, /* Frequency */ + G_TYPE_INT, /* Width * Height */ + G_TYPE_INT); /* Rotation */ - GtkCellRenderer *cell; + GtkCellRenderer *cell; - gtk_cell_layout_clear (GTK_CELL_LAYOUT (widget)); + gtk_cell_layout_clear (GTK_CELL_LAYOUT (widget)); - gtk_combo_box_set_model (box, GTK_TREE_MODEL (store)); + gtk_combo_box_set_model (box, GTK_TREE_MODEL (store)); - cell = gtk_cell_renderer_text_new (); - gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (box), cell, TRUE); - gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (box), cell, - "text", 0, - NULL); + cell = gtk_cell_renderer_text_new (); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (box), cell, TRUE); + gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (box), cell, + "text", 0, + NULL); - if (sort_column != -1) + if (sort_column != -1) { - gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), - sort_column, - GTK_SORT_DESCENDING); + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), + sort_column, + GTK_SORT_DESCENDING); } } static void compute_virtual_size_for_configuration (GnomeRRConfig *config, int *ret_width, int *ret_height) { - int i; - int width, height; + int i; + int width, height; - width = height = 0; + width = height = 0; - for (i = 0; config->outputs[i] != NULL; i++) + for (i = 0; config->outputs[i] != NULL; i++) { - GnomeOutputInfo *output; + GnomeOutputInfo *output; - output = config->outputs[i]; + output = config->outputs[i]; - if (output->on) + if (output->on) { - width = MAX (width, output->x + output->width); - height = MAX (height, output->y + output->height); + width = MAX (width, output->x + output->width); + height = MAX (height, output->y + output->height); } } - *ret_width = width; - *ret_height = height; + *ret_width = width; + *ret_height = height; } static void check_required_virtual_size (App *app) { - int req_width, req_height; - int min_width, max_width; - int min_height, max_height; + int req_width, req_height; + int min_width, max_width; + int min_height, max_height; - compute_virtual_size_for_configuration (app->current_configuration, &req_width, &req_height); + compute_virtual_size_for_configuration (app->current_configuration, &req_width, &req_height); - gnome_rr_screen_get_ranges (app->screen, &min_width, &max_width, &min_height, &max_height); + gnome_rr_screen_get_ranges (app->screen, &min_width, &max_width, &min_height, &max_height); #if 0 - g_debug ("X Server supports:"); - g_debug ("min_width = %d, max_width = %d", min_width, max_width); - g_debug ("min_height = %d, max_height = %d", min_height, max_height); + g_debug ("X Server supports:"); + g_debug ("min_width = %d, max_width = %d", min_width, max_width); + g_debug ("min_height = %d, max_height = %d", min_height, max_height); - g_debug ("Requesting size of %dx%d", req_width, req_height); + g_debug ("Requesting size of %dx%d", req_width, req_height); #endif - if (!(min_width <= req_width && req_width <= max_width - && min_height <= req_height && req_height <= max_height)) + if (!(min_width <= req_width && req_width <= max_width + && min_height <= req_height && req_height <= max_height)) { - /* FIXME: present a useful dialog, maybe even before the user tries to Apply */ + /* FIXME: present a useful dialog, maybe even before the user tries to Apply */ #if 0 - g_debug ("Your X server needs a larger Virtual size!"); + g_debug ("Your X server needs a larger Virtual size!"); #endif } } @@ -1921,74 +1921,74 @@ check_required_virtual_size (App *app) static void begin_version2_apply_configuration (App *app, GdkWindow *parent_window, guint32 timestamp) { - XID parent_window_xid; + XID parent_window_xid; - parent_window_xid = GDK_WINDOW_XID (parent_window); + parent_window_xid = GDK_WINDOW_XID (parent_window); - app->proxy = dbus_g_proxy_new_for_name (app->connection, - "org.gnome.SettingsDaemon", - "/org/gnome/SettingsDaemon/XRANDR", - "org.gnome.SettingsDaemon.XRANDR_2"); - g_assert (app->proxy != NULL); /* that call does not fail unless we pass bogus names */ + app->proxy = dbus_g_proxy_new_for_name (app->connection, + "org.gnome.SettingsDaemon", + "/org/gnome/SettingsDaemon/XRANDR", + "org.gnome.SettingsDaemon.XRANDR_2"); + g_assert (app->proxy != NULL); /* that call does not fail unless we pass bogus names */ - app->apply_configuration_state = APPLYING_VERSION_2; - app->proxy_call = dbus_g_proxy_begin_call (app->proxy, "ApplyConfiguration", - apply_configuration_returned_cb, app, - NULL, - G_TYPE_INT64, (gint64) parent_window_xid, - G_TYPE_INT64, (gint64) timestamp, - G_TYPE_INVALID, - G_TYPE_INVALID); - /* FIXME: we don't check for app->proxy_call == NULL, which could happen if - * the connection was disconnected. This is left as an exercise for the - * reader. - */ + app->apply_configuration_state = APPLYING_VERSION_2; + app->proxy_call = dbus_g_proxy_begin_call (app->proxy, "ApplyConfiguration", + apply_configuration_returned_cb, app, + NULL, + G_TYPE_INT64, (gint64) parent_window_xid, + G_TYPE_INT64, (gint64) timestamp, + G_TYPE_INVALID, + G_TYPE_INVALID); + /* FIXME: we don't check for app->proxy_call == NULL, which could happen if + * the connection was disconnected. This is left as an exercise for the + * reader. + */ } static void begin_version1_apply_configuration (App *app) { - app->proxy = dbus_g_proxy_new_for_name (app->connection, - "org.gnome.SettingsDaemon", - "/org/gnome/SettingsDaemon/XRANDR", - "org.gnome.SettingsDaemon.XRANDR"); - g_assert (app->proxy != NULL); /* that call does not fail unless we pass bogus names */ + app->proxy = dbus_g_proxy_new_for_name (app->connection, + "org.gnome.SettingsDaemon", + "/org/gnome/SettingsDaemon/XRANDR", + "org.gnome.SettingsDaemon.XRANDR"); + g_assert (app->proxy != NULL); /* that call does not fail unless we pass bogus names */ - app->apply_configuration_state = APPLYING_VERSION_1; - app->proxy_call = dbus_g_proxy_begin_call (app->proxy, "ApplyConfiguration", - apply_configuration_returned_cb, app, - NULL, - G_TYPE_INVALID, - G_TYPE_INVALID); - /* FIXME: we don't check for app->proxy_call == NULL, which could happen if - * the connection was disconnected. This is left as an exercise for the - * reader. - */ + app->apply_configuration_state = APPLYING_VERSION_1; + app->proxy_call = dbus_g_proxy_begin_call (app->proxy, "ApplyConfiguration", + apply_configuration_returned_cb, app, + NULL, + G_TYPE_INVALID, + G_TYPE_INVALID); + /* FIXME: we don't check for app->proxy_call == NULL, which could happen if + * the connection was disconnected. This is left as an exercise for the + * reader. + */ } static void ensure_current_configuration_is_saved (void) { - GnomeRRScreen *rr_screen; - GnomeRRConfig *rr_config; + GnomeRRScreen *rr_screen; + GnomeRRConfig *rr_config; - /* Normally, gnome_rr_config_save() creates a backup file based on the - * old monitors.xml. However, if *that* file didn't exist, there is - * nothing from which to create a backup. So, here we'll save the - * current/unchanged configuration and then let our caller call - * gnome_rr_config_save() again with the new/changed configuration, so - * that there *will* be a backup file in the end. - */ + /* Normally, gnome_rr_config_save() creates a backup file based on the + * old monitors.xml. However, if *that* file didn't exist, there is + * nothing from which to create a backup. So, here we'll save the + * current/unchanged configuration and then let our caller call + * gnome_rr_config_save() again with the new/changed configuration, so + * that there *will* be a backup file in the end. + */ - rr_screen = gnome_rr_screen_new (gdk_screen_get_default (), NULL, NULL, NULL); /* NULL-GError */ - if (!rr_screen) - return; + rr_screen = gnome_rr_screen_new (gdk_screen_get_default (), NULL, NULL, NULL); /* NULL-GError */ + if (!rr_screen) + return; - rr_config = gnome_rr_config_new_current (rr_screen); - gnome_rr_config_save (rr_config, NULL); /* NULL-GError */ + rr_config = gnome_rr_config_new_current (rr_screen); + gnome_rr_config_save (rr_config, NULL); /* NULL-GError */ - gnome_rr_config_free (rr_config); - gnome_rr_screen_destroy (rr_screen); + gnome_rr_config_free (rr_config); + gnome_rr_screen_destroy (rr_screen); } /* Callback for dbus_g_proxy_begin_call() */ @@ -1997,93 +1997,93 @@ apply_configuration_returned_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, void *data) { - App *app = data; - gboolean success; - GError *error; + App *app = data; + gboolean success; + GError *error; - g_assert (call_id == app->proxy_call); + g_assert (call_id == app->proxy_call); - error = NULL; - success = dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID); + error = NULL; + success = dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID); - if (!success) { - if (app->apply_configuration_state == APPLYING_VERSION_2 - && g_error_matches (error, DBUS_GERROR, DBUS_GERROR_UNKNOWN_METHOD)) { - g_error_free (error); + if (!success) { + if (app->apply_configuration_state == APPLYING_VERSION_2 + && g_error_matches (error, DBUS_GERROR, DBUS_GERROR_UNKNOWN_METHOD)) { + g_error_free (error); - g_object_unref (app->proxy); - app->proxy = NULL; + g_object_unref (app->proxy); + app->proxy = NULL; - begin_version1_apply_configuration (app); - return; - } else { - /* We don't pop up an error message; gnome-settings-daemon already does that - * in case the selected RANDR configuration could not be applied. - */ - g_error_free (error); - } + begin_version1_apply_configuration (app); + return; + } else { + /* We don't pop up an error message; gnome-settings-daemon already does that + * in case the selected RANDR configuration could not be applied. + */ + g_error_free (error); } + } - g_object_unref (app->proxy); - app->proxy = NULL; + g_object_unref (app->proxy); + app->proxy = NULL; - dbus_g_connection_unref (app->connection); - app->connection = NULL; - app->proxy_call = NULL; + dbus_g_connection_unref (app->connection); + app->connection = NULL; + app->proxy_call = NULL; - gtk_widget_set_sensitive (app->panel, TRUE); + gtk_widget_set_sensitive (app->panel, TRUE); } static gboolean sanitize_and_save_configuration (App *app) { - GError *error; + GError *error; - gnome_rr_config_sanitize (app->current_configuration); + gnome_rr_config_sanitize (app->current_configuration); - check_required_virtual_size (app); + check_required_virtual_size (app); - foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); + foo_scroll_area_invalidate (FOO_SCROLL_AREA (app->area)); - ensure_current_configuration_is_saved (); + ensure_current_configuration_is_saved (); - error = NULL; - if (!gnome_rr_config_save (app->current_configuration, &error)) + error = NULL; + if (!gnome_rr_config_save (app->current_configuration, &error)) { - error_message (app, _("Could not save the monitor configuration"), error->message); - g_error_free (error); - return FALSE; + error_message (app, _("Could not save the monitor configuration"), error->message); + g_error_free (error); + return FALSE; } - return TRUE; + return TRUE; } static void apply (App *app) { - GError *error = NULL; - GdkWindow *window; + GError *error = NULL; + GdkWindow *window; - if (!sanitize_and_save_configuration (app)) - return; + if (!sanitize_and_save_configuration (app)) + return; - g_assert (app->connection == NULL); - g_assert (app->proxy == NULL); - g_assert (app->proxy_call == NULL); + g_assert (app->connection == NULL); + g_assert (app->proxy == NULL); + g_assert (app->proxy_call == NULL); - app->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); - if (app->connection == NULL) { - error_message (app, _("Could not get session bus while applying display configuration"), error->message); - g_error_free (error); - return; - } + app->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); + if (app->connection == NULL) { + error_message (app, _("Could not get session bus while applying display configuration"), error->message); + g_error_free (error); + return; + } - gtk_widget_set_sensitive (app->panel, FALSE); + gtk_widget_set_sensitive (app->panel, FALSE); - window = gtk_widget_get_window (gtk_widget_get_toplevel (app->panel)); + window = gtk_widget_get_window (gtk_widget_get_toplevel (app->panel)); - begin_version2_apply_configuration (app, window, - app->apply_button_clicked_timestamp); + begin_version2_apply_configuration (app, window, + app->apply_button_clicked_timestamp); } #if 0 @@ -2091,84 +2091,84 @@ apply (App *app) static gboolean driver_is_randr_10 (GnomeRRConfig *config) { - /* In the Xorg code, see xserver/randr/rrinfo.c:RRScanOldConfig(). It gets - * called when the graphics driver doesn't support RANDR 1.2 yet, just 1.0. - * In that case, the X server's base code (which supports RANDR 1.2) will - * simulate having a single output called "default". For drivers that *do* - * support RANDR 1.2, the separate outputs will be named differently, we - * hope. - * - * This heuristic is courtesy of Dirk Mueller - * - * FIXME: however, we don't even check for XRRQueryVersion() returning 1.2, neither - * here nor in gnome-desktop/libgnomedesktop*.c. Do we need to check for that, - * or is gnome_rr_screen_new()'s return value sufficient? - */ + /* In the Xorg code, see xserver/randr/rrinfo.c:RRScanOldConfig(). It gets + * called when the graphics driver doesn't support RANDR 1.2 yet, just 1.0. + * In that case, the X server's base code (which supports RANDR 1.2) will + * simulate having a single output called "default". For drivers that *do* + * support RANDR 1.2, the separate outputs will be named differently, we + * hope. + * + * This heuristic is courtesy of Dirk Mueller + * + * FIXME: however, we don't even check for XRRQueryVersion() returning 1.2, neither + * here nor in gnome-desktop/libgnomedesktop*.c. Do we need to check for that, + * or is gnome_rr_screen_new()'s return value sufficient? + */ - return (count_all_outputs (config) == 1 && strcmp (config->outputs[0]->name, "default") == 0); + return (count_all_outputs (config) == 1 && strcmp (config->outputs[0]->name, "default") == 0); } #endif static void on_detect_displays (GtkWidget *widget, gpointer data) { - App *app = data; - GError *error; + App *app = data; + GError *error; - error = NULL; - if (!gnome_rr_screen_refresh (app->screen, &error)) { - if (error) { - error_message (app, _("Could not detect displays"), error->message); - g_error_free (error); - } + error = NULL; + if (!gnome_rr_screen_refresh (app->screen, &error)) { + if (error) { + error_message (app, _("Could not detect displays"), error->message); + g_error_free (error); } + } } static GnomeOutputInfo * get_nearest_output (GnomeRRConfig *configuration, int x, int y) { - int i; - int nearest_index; - int nearest_dist; + int i; + int nearest_index; + int nearest_dist; - nearest_index = -1; - nearest_dist = G_MAXINT; + nearest_index = -1; + nearest_dist = G_MAXINT; - for (i = 0; configuration->outputs[i] != NULL; i++) + for (i = 0; configuration->outputs[i] != NULL; i++) { - GnomeOutputInfo *output; - int dist_x, dist_y; + GnomeOutputInfo *output; + int dist_x, dist_y; - output = configuration->outputs[i]; + output = configuration->outputs[i]; - if (!(output->connected && output->on)) - continue; + if (!(output->connected && output->on)) + continue; - if (x < output->x) - dist_x = output->x - x; - else if (x >= output->x + output->width) - dist_x = x - (output->x + output->width) + 1; - else - dist_x = 0; + if (x < output->x) + dist_x = output->x - x; + else if (x >= output->x + output->width) + dist_x = x - (output->x + output->width) + 1; + else + dist_x = 0; - if (y < output->y) - dist_y = output->y - y; - else if (y >= output->y + output->height) - dist_y = y - (output->y + output->height) + 1; - else - dist_y = 0; + if (y < output->y) + dist_y = output->y - y; + else if (y >= output->y + output->height) + dist_y = y - (output->y + output->height) + 1; + else + dist_y = 0; - if (MIN (dist_x, dist_y) < nearest_dist) + if (MIN (dist_x, dist_y) < nearest_dist) { - nearest_dist = MIN (dist_x, dist_y); - nearest_index = i; + nearest_dist = MIN (dist_x, dist_y); + nearest_index = i; } } - if (nearest_index != -1) - return configuration->outputs[nearest_index]; - else - return NULL; + if (nearest_index != -1) + return configuration->outputs[nearest_index]; + else + return NULL; } @@ -2178,48 +2178,48 @@ get_nearest_output (GnomeRRConfig *configuration, int x, int y) static GnomeOutputInfo * get_output_for_window (GnomeRRConfig *configuration, GdkWindow *window) { - GdkRectangle win_rect; - int i; - int largest_area; - int largest_index; + GdkRectangle win_rect; + int i; + int largest_area; + int largest_index; - gdk_window_get_geometry (window, &win_rect.x, &win_rect.y, &win_rect.width, &win_rect.height, NULL); - gdk_window_get_origin (window, &win_rect.x, &win_rect.y); + gdk_window_get_geometry (window, &win_rect.x, &win_rect.y, &win_rect.width, &win_rect.height, NULL); + gdk_window_get_origin (window, &win_rect.x, &win_rect.y); - largest_area = 0; - largest_index = -1; + largest_area = 0; + largest_index = -1; - for (i = 0; configuration->outputs[i] != NULL; i++) + for (i = 0; configuration->outputs[i] != NULL; i++) { - GnomeOutputInfo *output; - GdkRectangle output_rect, intersection; + GnomeOutputInfo *output; + GdkRectangle output_rect, intersection; - output = configuration->outputs[i]; + output = configuration->outputs[i]; - output_rect.x = output->x; - output_rect.y = output->y; - output_rect.width = output->width; - output_rect.height = output->height; + output_rect.x = output->x; + output_rect.y = output->y; + output_rect.width = output->width; + output_rect.height = output->height; - if (output->connected && gdk_rectangle_intersect (&win_rect, &output_rect, &intersection)) + if (output->connected && gdk_rectangle_intersect (&win_rect, &output_rect, &intersection)) { - int area; + int area; - area = intersection.width * intersection.height; - if (area > largest_area) + area = intersection.width * intersection.height; + if (area > largest_area) { - largest_area = area; - largest_index = i; + largest_area = area; + largest_index = i; } } } - if (largest_index != -1) - return configuration->outputs[largest_index]; - else - return get_nearest_output (configuration, - win_rect.x + win_rect.width / 2, - win_rect.y + win_rect.height / 2); + if (largest_index != -1) + return configuration->outputs[largest_index]; + else + return get_nearest_output (configuration, + win_rect.x + win_rect.width / 2, + win_rect.y + win_rect.height / 2); } static void @@ -2237,18 +2237,18 @@ on_toplevel_realized (GtkWidget *widget, static void select_current_output_from_dialog_position (App *app) { - GtkWidget *toplevel; + GtkWidget *toplevel; - toplevel = gtk_widget_get_toplevel (app->panel); + toplevel = gtk_widget_get_toplevel (app->panel); - if (gtk_widget_get_realized (toplevel)) { - app->current_output = get_output_for_window (app->current_configuration, - gtk_widget_get_window (toplevel)); - rebuild_gui (app); - } else { - g_signal_connect (toplevel, "realize", G_CALLBACK (on_toplevel_realized), app); - app->current_output = NULL; - } + if (gtk_widget_get_realized (toplevel)) { + app->current_output = get_output_for_window (app->current_configuration, + gtk_widget_get_window (toplevel)); + rebuild_gui (app); + } else { + g_signal_connect (toplevel, "realize", G_CALLBACK (on_toplevel_realized), app); + app->current_output = NULL; + } } /* This is a GtkWidget::map-event handler. We wait for the display-properties @@ -2258,41 +2258,41 @@ select_current_output_from_dialog_position (App *app) static gboolean dialog_map_event_cb (GtkWidget *widget, GdkEventAny *event, gpointer data) { - App *app = data; + App *app = data; - select_current_output_from_dialog_position (app); - return FALSE; + select_current_output_from_dialog_position (app); + return FALSE; } static void apply_button_clicked_cb (GtkButton *button, gpointer data) { - App *app = data; + App *app = data; - /* We simply store the timestamp at which the Apply button was clicked. - * We'll just wait for the dialog to return from gtk_dialog_run(), and - * *then* use the timestamp when applying the RANDR configuration. - */ + /* We simply store the timestamp at which the Apply button was clicked. + * We'll just wait for the dialog to return from gtk_dialog_run(), and + * *then* use the timestamp when applying the RANDR configuration. + */ - app->apply_button_clicked_timestamp = gtk_get_current_event_time (); + app->apply_button_clicked_timestamp = gtk_get_current_event_time (); } static GtkWidget* _gtk_builder_get_widget (GtkBuilder *builder, const gchar *name) { - return GTK_WIDGET (gtk_builder_get_object (builder, name)); + return GTK_WIDGET (gtk_builder_get_object (builder, name)); } static void destroy_app (App *app) { - gnome_rr_screen_destroy (app->screen); - g_object_unref (app->builder); - gnome_rr_labeler_hide (app->labeler); - g_object_unref (app->labeler); + gnome_rr_screen_destroy (app->screen); + g_object_unref (app->builder); + gnome_rr_labeler_hide (app->labeler); + g_object_unref (app->labeler); - g_free (app); + g_free (app); } GtkWidget* @@ -2302,107 +2302,107 @@ run_application (void) #define UIDIR "." #endif #define UI_FILE UIDIR "/display-capplet.ui" - GtkBuilder *builder; - GtkWidget *align; - GError *error; - gchar *objects[] = {"display-panel", "rotation-liststore", NULL}; - App *app; + GtkBuilder *builder; + GtkWidget *align; + GError *error; + gchar *objects[] = {"display-panel", "rotation-liststore", NULL}; + App *app; - app = g_new0 (App, 1); + app = g_new0 (App, 1); - error = NULL; - app->builder = builder = gtk_builder_new (); + error = NULL; + app->builder = builder = gtk_builder_new (); - if (!gtk_builder_add_objects_from_file (builder, UI_FILE, objects, &error)) + if (!gtk_builder_add_objects_from_file (builder, UI_FILE, objects, &error)) { - g_warning ("Could not parse UI definition: %s", error->message); - g_error_free (error); - g_object_unref (builder); - return NULL; + g_warning ("Could not parse UI definition: %s", error->message); + g_error_free (error); + g_object_unref (builder); + return NULL; } - app->screen = gnome_rr_screen_new (gdk_screen_get_default (), - on_screen_changed, app, &error); - if (!app->screen) + app->screen = gnome_rr_screen_new (gdk_screen_get_default (), + on_screen_changed, app, &error); + if (!app->screen) { - error_message (NULL, _("Could not get screen information"), error->message); - g_error_free (error); - g_object_unref (builder); - return NULL; + error_message (NULL, _("Could not get screen information"), error->message); + g_error_free (error); + g_object_unref (builder); + return NULL; } - app->panel = _gtk_builder_get_widget (builder, "display-panel"); + app->panel = _gtk_builder_get_widget (builder, "display-panel"); - if (!app->panel) - g_warning ("Missing display-panel object"); - g_signal_connect_after (app->panel, "show", - G_CALLBACK (dialog_map_event_cb), app); + if (!app->panel) + g_warning ("Missing display-panel object"); + g_signal_connect_after (app->panel, "show", + G_CALLBACK (dialog_map_event_cb), app); - app->current_monitor_event_box = _gtk_builder_get_widget (builder, - "current_monitor_event_box"); - app->current_monitor_label = _gtk_builder_get_widget (builder, - "current_monitor_label"); + app->current_monitor_event_box = _gtk_builder_get_widget (builder, + "current_monitor_event_box"); + app->current_monitor_label = _gtk_builder_get_widget (builder, + "current_monitor_label"); - app->monitor_on_radio = _gtk_builder_get_widget (builder, - "monitor_on_radio"); - app->monitor_off_radio = _gtk_builder_get_widget (builder, - "monitor_off_radio"); - g_signal_connect (app->monitor_on_radio, "toggled", - G_CALLBACK (monitor_on_off_toggled_cb), app); - g_signal_connect (app->monitor_off_radio, "toggled", - G_CALLBACK (monitor_on_off_toggled_cb), app); + app->monitor_on_radio = _gtk_builder_get_widget (builder, + "monitor_on_radio"); + app->monitor_off_radio = _gtk_builder_get_widget (builder, + "monitor_off_radio"); + g_signal_connect (app->monitor_on_radio, "toggled", + G_CALLBACK (monitor_on_off_toggled_cb), app); + g_signal_connect (app->monitor_off_radio, "toggled", + G_CALLBACK (monitor_on_off_toggled_cb), app); - app->resolution_combo = _gtk_builder_get_widget (builder, - "resolution_combo"); - g_signal_connect (app->resolution_combo, "changed", - G_CALLBACK (on_resolution_changed), app); + app->resolution_combo = _gtk_builder_get_widget (builder, + "resolution_combo"); + g_signal_connect (app->resolution_combo, "changed", + G_CALLBACK (on_resolution_changed), app); - app->rotation_combo = _gtk_builder_get_widget (builder, "rotation_combo"); - g_signal_connect (app->rotation_combo, "changed", - G_CALLBACK (on_rotation_changed), app); + app->rotation_combo = _gtk_builder_get_widget (builder, "rotation_combo"); + g_signal_connect (app->rotation_combo, "changed", + G_CALLBACK (on_rotation_changed), app); - app->clone_checkbox = _gtk_builder_get_widget (builder, "clone_checkbox"); - g_signal_connect (app->clone_checkbox, "toggled", - G_CALLBACK (on_clone_changed), app); + app->clone_checkbox = _gtk_builder_get_widget (builder, "clone_checkbox"); + g_signal_connect (app->clone_checkbox, "toggled", + G_CALLBACK (on_clone_changed), app); - app->clone_label = _gtk_builder_get_widget (builder, "clone_resolution_warning_label"); + app->clone_label = _gtk_builder_get_widget (builder, "clone_resolution_warning_label"); - g_signal_connect (_gtk_builder_get_widget (builder, "detect_displays_button"), - "clicked", G_CALLBACK (on_detect_displays), app); + g_signal_connect (_gtk_builder_get_widget (builder, "detect_displays_button"), + "clicked", G_CALLBACK (on_detect_displays), app); - make_text_combo (app->resolution_combo, 4); - make_text_combo (app->rotation_combo, -1); + make_text_combo (app->resolution_combo, 4); + make_text_combo (app->rotation_combo, -1); - /* Scroll Area */ - app->area = (GtkWidget *)foo_scroll_area_new (); + /* Scroll Area */ + app->area = (GtkWidget *)foo_scroll_area_new (); - g_object_set_data (G_OBJECT (app->area), "app", app); + g_object_set_data (G_OBJECT (app->area), "app", app); - set_monitors_tooltip (app, FALSE); + set_monitors_tooltip (app, FALSE); - /* FIXME: this should be computed dynamically */ - foo_scroll_area_set_min_size (FOO_SCROLL_AREA (app->area), -1, 200); - gtk_widget_show (app->area); - g_signal_connect (app->area, "paint", - G_CALLBACK (on_area_paint), app); - g_signal_connect (app->area, "viewport_changed", - G_CALLBACK (on_viewport_changed), app); + /* FIXME: this should be computed dynamically */ + foo_scroll_area_set_min_size (FOO_SCROLL_AREA (app->area), -1, 200); + gtk_widget_show (app->area); + g_signal_connect (app->area, "paint", + G_CALLBACK (on_area_paint), app); + g_signal_connect (app->area, "viewport_changed", + G_CALLBACK (on_viewport_changed), app); - align = _gtk_builder_get_widget (builder, "align"); + align = _gtk_builder_get_widget (builder, "align"); - gtk_container_add (GTK_CONTAINER (align), app->area); + gtk_container_add (GTK_CONTAINER (align), app->area); - app->apply_button = _gtk_builder_get_widget (builder, "apply_button"); - g_signal_connect (app->apply_button, "clicked", - G_CALLBACK (apply_button_clicked_cb), app); + app->apply_button = _gtk_builder_get_widget (builder, "apply_button"); + g_signal_connect (app->apply_button, "clicked", + G_CALLBACK (apply_button_clicked_cb), app); - on_screen_changed (app->screen, app); + on_screen_changed (app->screen, app); - g_signal_connect_swapped (_gtk_builder_get_widget (builder, "apply_button"), - "clicked", G_CALLBACK (apply), app); + g_signal_connect_swapped (_gtk_builder_get_widget (builder, "apply_button"), + "clicked", G_CALLBACK (apply), app); - g_object_weak_ref (G_OBJECT (app->panel), (GWeakNotify) destroy_app, app); + g_object_weak_ref (G_OBJECT (app->panel), (GWeakNotify) destroy_app, app); - return app->panel; + return app->panel; }