diff options
Diffstat (limited to 'eel/eel-gtk-extensions.c')
| -rw-r--r-- | eel/eel-gtk-extensions.c | 1247 |
1 files changed, 1247 insertions, 0 deletions
diff --git a/eel/eel-gtk-extensions.c b/eel/eel-gtk-extensions.c new file mode 100644 index 00000000..da78a532 --- /dev/null +++ b/eel/eel-gtk-extensions.c @@ -0,0 +1,1247 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ + +/* eel-gtk-extensions.c - implementation of new functions that operate on + gtk classes. Perhaps some of these should be + rolled into gtk someday. + + Copyright (C) 1999, 2000, 2001 Eazel, Inc. + + The Mate Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The Mate Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the Mate Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + + Authors: John Sullivan <[email protected]> + Ramiro Estrugo <[email protected]> + Darin Adler <[email protected]> +*/ + +#include <config.h> +#include "eel-gtk-extensions.h" + +#include "eel-gdk-pixbuf-extensions.h" +#include "eel-glib-extensions.h" +#include "eel-mate-extensions.h" +#include "eel-pango-extensions.h" +#include "eel-string.h" +#include <X11/Xlib.h> +#include <X11/Xatom.h> +#include <gdk/gdk.h> +#include <gdk/gdkprivate.h> +#include <gdk/gdkx.h> +#include <gtk/gtk.h> +#include <math.h> +#include "eel-marshal.h" +#include "eel-marshal.c" + +/* This number is fairly arbitrary. Long enough to show a pretty long + * menu title, but not so long to make a menu grotesquely wide. + */ +#define MAXIMUM_MENU_TITLE_LENGTH 48 + +/* Used for window position & size sanity-checking. The sizes are big enough to prevent + * at least normal-sized mate panels from obscuring the window at the screen edges. + */ +#define MINIMUM_ON_SCREEN_WIDTH 100 +#define MINIMUM_ON_SCREEN_HEIGHT 100 + + +/** + * eel_gtk_window_get_geometry_string: + * @window: a #GtkWindow + * + * Obtains the geometry string for this window, suitable for + * set_geometry_string(); assumes the window has NorthWest gravity + * + * Return value: geometry string, must be freed + **/ +char* +eel_gtk_window_get_geometry_string (GtkWindow *window) +{ + char *str; + int w, h, x, y; + + g_return_val_if_fail (GTK_IS_WINDOW (window), NULL); + g_return_val_if_fail (gtk_window_get_gravity (window) == + GDK_GRAVITY_NORTH_WEST, NULL); + + gtk_window_get_position (window, &x, &y); + gtk_window_get_size (window, &w, &h); + + str = g_strdup_printf ("%dx%d+%d+%d", w, h, x, y); + + return str; +} + +static void +send_delete_event (GtkWindow *window) +{ + /* Synthesize delete_event to close window. */ + + GdkEvent event; + GtkWidget *widget; + + widget = GTK_WIDGET (window); + + event.any.type = GDK_DELETE; + event.any.window = gtk_widget_get_window (widget); + event.any.send_event = TRUE; + + g_object_ref (event.any.window); + gtk_main_do_event (&event); + g_object_unref (event.any.window); +} + +static int +handle_standard_close_accelerator (GtkWindow *window, + GdkEventKey *event, + gpointer user_data) +{ + g_assert (GTK_IS_WINDOW (window)); + g_assert (event != NULL); + g_assert (user_data == NULL); + + if (eel_gtk_window_event_is_close_accelerator (window, event)) + { + send_delete_event (window); + g_signal_stop_emission_by_name ( + G_OBJECT (window), "key_press_event"); + return TRUE; + } + + return FALSE; +} + +/** + * eel_gtk_window_event_is_close_accelerator: + * + * Tests whether a key event is a standard window close accelerator. + * Not needed for clients that use eel_gtk_window_set_up_close_accelerator; + * use only if you must set up your own key_event handler for your own reasons. + **/ +gboolean +eel_gtk_window_event_is_close_accelerator (GtkWindow *window, GdkEventKey *event) +{ + g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + if (event->state & GDK_CONTROL_MASK) + { + /* Note: menu item equivalents are case-sensitive, so we will + * be case-sensitive here too. + */ + if (event->keyval == EEL_STANDARD_CLOSE_WINDOW_CONTROL_KEY) + { + return TRUE; + } + } + + + return FALSE; +} + +/** + * eel_gtk_window_set_up_close_accelerator: + * + * Sets up the standard keyboard equivalent to close the window. + * Call this for windows that don't set up a keyboard equivalent to + * close the window some other way, e.g. via a menu item accelerator. + * + * NOTE: do not use for GtkDialog, it already sets up the right + * stuff here. + * + * @window: The GtkWindow that should be hidden when the standard + * keyboard equivalent is typed. + **/ +void +eel_gtk_window_set_up_close_accelerator (GtkWindow *window) +{ + g_return_if_fail (GTK_IS_WINDOW (window)); + + if (GTK_IS_DIALOG (window)) + { + g_warning ("eel_gtk_window_set_up_close_accelerator: Should not mess with close accelerator on GtkDialogs"); + return; + } + + g_signal_connect (window, + "key_press_event", + G_CALLBACK (handle_standard_close_accelerator), + NULL); +} + +static void +sanity_check_window_position (int *left, int *top) +{ + g_assert (left != NULL); + g_assert (top != NULL); + + /* Make sure the top of the window is on screen, for + * draggability (might not be necessary with all window managers, + * but seems reasonable anyway). Make sure the top of the window + * isn't off the bottom of the screen, or so close to the bottom + * that it might be obscured by the panel. + */ + *top = CLAMP (*top, 0, gdk_screen_height() - MINIMUM_ON_SCREEN_HEIGHT); + + /* FIXME bugzilla.eazel.com 669: + * If window has negative left coordinate, set_uposition sends it + * somewhere else entirely. Not sure what level contains this bug (XWindows?). + * Hacked around by pinning the left edge to zero, which just means you + * can't set a window to be partly off the left of the screen using + * this routine. + */ + /* Make sure the left edge of the window isn't off the right edge of + * the screen, or so close to the right edge that it might be + * obscured by the panel. + */ + *left = CLAMP (*left, 0, gdk_screen_width() - MINIMUM_ON_SCREEN_WIDTH); +} + +static void +sanity_check_window_dimensions (guint *width, guint *height) +{ + g_assert (width != NULL); + g_assert (height != NULL); + + /* Pin the size of the window to the screen, so we don't end up in + * a state where the window is so big essential parts of it can't + * be reached (might not be necessary with all window managers, + * but seems reasonable anyway). + */ + *width = MIN (*width, gdk_screen_width()); + *height = MIN (*height, gdk_screen_height()); +} + +/** + * eel_gtk_window_set_initial_geometry: + * + * Sets the position and size of a GtkWindow before the + * GtkWindow is shown. It is an error to call this on a window that + * is already on-screen. Takes into account screen size, and does + * some sanity-checking on the passed-in values. + * + * @window: A non-visible GtkWindow + * @geometry_flags: A EelGdkGeometryFlags value defining which of + * the following parameters have defined values + * @left: pixel coordinate for left of window + * @top: pixel coordinate for top of window + * @width: width of window in pixels + * @height: height of window in pixels + */ +void +eel_gtk_window_set_initial_geometry (GtkWindow *window, + EelGdkGeometryFlags geometry_flags, + int left, + int top, + guint width, + guint height) +{ + GdkScreen *screen; + int real_left, real_top; + int screen_width, screen_height; + + g_return_if_fail (GTK_IS_WINDOW (window)); + + /* Setting the default size doesn't work when the window is already showing. + * Someday we could make this move an already-showing window, but we don't + * need that functionality yet. + */ + g_return_if_fail (!gtk_widget_get_visible (GTK_WIDGET (window))); + + if ((geometry_flags & EEL_GDK_X_VALUE) && (geometry_flags & EEL_GDK_Y_VALUE)) + { + real_left = left; + real_top = top; + + screen = gtk_window_get_screen (window); + screen_width = gdk_screen_get_width (screen); + screen_height = gdk_screen_get_height (screen); + + /* This is sub-optimal. GDK doesn't allow us to set win_gravity + * to South/East types, which should be done if using negative + * positions (so that the right or bottom edge of the window + * appears at the specified position, not the left or top). + * However it does seem to be consistent with other MATE apps. + */ + if (geometry_flags & EEL_GDK_X_NEGATIVE) + { + real_left = screen_width - real_left; + } + if (geometry_flags & EEL_GDK_Y_NEGATIVE) + { + real_top = screen_height - real_top; + } + + sanity_check_window_position (&real_left, &real_top); + gtk_window_move (window, real_left, real_top); + } + + if ((geometry_flags & EEL_GDK_WIDTH_VALUE) && (geometry_flags & EEL_GDK_HEIGHT_VALUE)) + { + sanity_check_window_dimensions (&width, &height); + gtk_window_set_default_size (GTK_WINDOW (window), (int)width, (int)height); + } +} + +/** + * eel_gtk_window_set_initial_geometry_from_string: + * + * Sets the position and size of a GtkWindow before the + * GtkWindow is shown. The geometry is passed in as a string. + * It is an error to call this on a window that + * is already on-screen. Takes into account screen size, and does + * some sanity-checking on the passed-in values. + * + * @window: A non-visible GtkWindow + * @geometry_string: A string suitable for use with eel_gdk_parse_geometry + * @minimum_width: If the width from the string is smaller than this, + * use this for the width. + * @minimum_height: If the height from the string is smaller than this, + * use this for the height. + * @ignore_position: If true position data from string will be ignored. + */ +void +eel_gtk_window_set_initial_geometry_from_string (GtkWindow *window, + const char *geometry_string, + guint minimum_width, + guint minimum_height, + gboolean ignore_position) +{ + int left, top; + guint width, height; + EelGdkGeometryFlags geometry_flags; + + g_return_if_fail (GTK_IS_WINDOW (window)); + g_return_if_fail (geometry_string != NULL); + + /* Setting the default size doesn't work when the window is already showing. + * Someday we could make this move an already-showing window, but we don't + * need that functionality yet. + */ + g_return_if_fail (!gtk_widget_get_visible (GTK_WIDGET (window))); + + geometry_flags = eel_gdk_parse_geometry (geometry_string, &left, &top, &width, &height); + + /* Make sure the window isn't smaller than makes sense for this window. + * Other sanity checks are performed in set_initial_geometry. + */ + if (geometry_flags & EEL_GDK_WIDTH_VALUE) + { + width = MAX (width, minimum_width); + } + if (geometry_flags & EEL_GDK_HEIGHT_VALUE) + { + height = MAX (height, minimum_height); + } + + /* Ignore saved window position if requested. */ + if (ignore_position) + { + geometry_flags &= ~(EEL_GDK_X_VALUE | EEL_GDK_Y_VALUE); + } + + eel_gtk_window_set_initial_geometry (window, geometry_flags, left, top, width, height); +} + +/** + * eel_pop_up_context_menu: + * + * Pop up a context menu under the mouse. + * The menu is sunk after use, so it will be destroyed unless the + * caller first ref'ed it. + * + * This function is more of a helper function than a gtk extension, + * so perhaps it belongs in a different file. + * + * @menu: The menu to pop up under the mouse. + * @offset_x: Number of pixels to displace the popup menu vertically + * @offset_y: Number of pixels to displace the popup menu horizontally + * @event: The event that invoked this popup menu. + **/ +void +eel_pop_up_context_menu (GtkMenu *menu, + gint16 offset_x, + gint16 offset_y, + GdkEventButton *event) +{ + GdkPoint offset; + int button; + + g_return_if_fail (GTK_IS_MENU (menu)); + + offset.x = offset_x; + offset.y = offset_y; + + /* The event button needs to be 0 if we're popping up this menu from + * a button release, else a 2nd click outside the menu with any button + * other than the one that invoked the menu will be ignored (instead + * of dismissing the menu). This is a subtle fragility of the GTK menu code. + */ + + if (event) + { + button = event->type == GDK_BUTTON_RELEASE + ? 0 + : event->button; + } + else + { + button = 0; + } + + gtk_menu_popup (menu, /* menu */ + NULL, /* parent_menu_shell */ + NULL, /* parent_menu_item */ + NULL, + &offset, /* data */ + button, /* button */ + event ? event->time : GDK_CURRENT_TIME); /* activate_time */ + + g_object_ref_sink (menu); + g_object_unref (menu); +} + +GtkMenuItem * +eel_gtk_menu_append_separator (GtkMenu *menu) +{ + return eel_gtk_menu_insert_separator (menu, -1); +} + +GtkMenuItem * +eel_gtk_menu_insert_separator (GtkMenu *menu, int index) +{ + GtkWidget *menu_item; + + menu_item = gtk_separator_menu_item_new (); + gtk_widget_show (menu_item); + gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menu_item, index); + + return GTK_MENU_ITEM (menu_item); +} + +void +eel_gtk_menu_set_item_visibility (GtkMenu *menu, int index, gboolean visible) +{ + GList *children; + GtkWidget *menu_item; + + g_return_if_fail (GTK_IS_MENU (menu)); + + children = gtk_container_get_children (GTK_CONTAINER (menu)); + g_return_if_fail (index >= 0 && index < (int) g_list_length (children)); + + menu_item = GTK_WIDGET (g_list_nth_data (children, index)); + if (visible) + { + gtk_widget_show (menu_item); + } + else + { + gtk_widget_hide (menu_item); + } + + g_list_free (children); +} + +GtkWidget * +eel_gtk_menu_tool_button_get_button (GtkMenuToolButton *tool_button) +{ + GtkContainer *container; + GList *children; + GtkWidget *button; + + g_return_val_if_fail (GTK_IS_MENU_TOOL_BUTTON (tool_button), NULL); + + /* The menu tool button's button is the first child + * of the child hbox. */ + container = GTK_CONTAINER (gtk_bin_get_child (GTK_BIN (tool_button))); + children = gtk_container_get_children (container); + button = GTK_WIDGET (children->data); + + g_list_free (children); + + return button; +} + +gboolean +eel_point_in_allocation (const GtkAllocation *allocation, + int x, int y) +{ + g_return_val_if_fail (allocation != NULL, FALSE); + return x >= allocation->x + && y >= allocation->y + && x < allocation->x + allocation->width + && y < allocation->y + allocation->height; +} + +/* FIXME this function is dangerous, because gtk_widget_get_window (widget) coords (or + * other window-belonging-to-widget coords) do not need to be in the + * same coordinate system as widget->allocation. + * If you use this function, be aware of that. Someone should probably + * audit all uses, too. + */ +gboolean +eel_point_in_widget (GtkWidget *widget, + int x, int y) +{ + GtkAllocation allocation; + if (widget == NULL) + { + return FALSE; + } + g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); + gtk_widget_get_allocation (widget, &allocation); + return eel_point_in_allocation (&allocation, x, y); +} + +/** + * eel_gtk_widget_set_shown + * + * Show or hide a widget. + * @widget: The widget. + * @shown: Boolean value indicating whether the widget should be shown or hidden. + **/ +void +eel_gtk_widget_set_shown (GtkWidget *widget, gboolean shown) +{ + g_return_if_fail (GTK_IS_WIDGET (widget)); + + if (shown) + { + gtk_widget_show (widget); + } + else + { + gtk_widget_hide (widget); + } +} + +/* This stuff is stolen from Gtk. */ + +typedef struct DisconnectInfo +{ + GtkObject *object1; + guint disconnect_handler1; + guint signal_handler; + GtkObject *object2; + guint disconnect_handler2; +} DisconnectInfo; + +static void +alive_disconnecter (GtkObject *object, DisconnectInfo *info) +{ + g_assert (info != NULL); + g_assert (GTK_IS_OBJECT (info->object1)); + g_assert (info->disconnect_handler1 != 0); + g_assert (info->signal_handler != 0); + g_assert (GTK_IS_OBJECT (info->object2)); + g_assert (info->disconnect_handler2 != 0); + g_assert (object == info->object1 || object == info->object2); + + g_signal_handler_disconnect (info->object1, info->disconnect_handler1); + g_signal_handler_disconnect (info->object1, info->signal_handler); + g_signal_handler_disconnect (info->object2, info->disconnect_handler2); + + g_free (info); +} + +/** + * eel_gtk_signal_connect_full_while_alive + * + * Like gtk_signal_connect_while_alive, but works with full parameters. + **/ +void +eel_gtk_signal_connect_full_while_alive (GtkObject *object, + const gchar *name, + GCallback func, + GtkCallbackMarshal marshal, + gpointer data, + GDestroyNotify destroy_func, + gboolean object_signal, + gboolean after, + GtkObject *alive_object) +{ + DisconnectInfo *info; + + g_return_if_fail (GTK_IS_OBJECT (object)); + g_return_if_fail (name != NULL); + g_return_if_fail (func != NULL || marshal != NULL); + g_return_if_fail (object_signal == FALSE || object_signal == TRUE); + g_return_if_fail (after == FALSE || after == TRUE); + g_return_if_fail (GTK_IS_OBJECT (alive_object)); + + info = g_new (DisconnectInfo, 1); + info->object1 = object; + info->object2 = alive_object; + + + info->signal_handler = g_signal_connect_closure ( + object, name, + (object_signal + ? g_cclosure_new_swap + : g_cclosure_new) (func, data, (GClosureNotify) destroy_func), + after); + + info->disconnect_handler1 = g_signal_connect (G_OBJECT (object), + "destroy", + G_CALLBACK (alive_disconnecter), + info); + info->disconnect_handler2 = g_signal_connect (G_OBJECT (alive_object), + "destroy", + G_CALLBACK (alive_disconnecter), + info); +} + +typedef struct +{ + GtkObject *object; + guint object_destroy_handler; + + GtkWidget *realized_widget; + guint realized_widget_destroy_handler; + guint realized_widget_unrealized_handler; + + guint signal_handler; +} RealizeDisconnectInfo; + +static void +while_realized_disconnecter (GtkObject *object, + RealizeDisconnectInfo *info) +{ + g_assert (GTK_IS_OBJECT (object)); + g_assert (info != NULL); + g_assert (GTK_IS_OBJECT (info->object)); + g_assert (info->object_destroy_handler != 0); + g_assert (info->object_destroy_handler != 0); + g_assert (info->realized_widget_destroy_handler != 0); + g_assert (info->realized_widget_unrealized_handler != 0); + + g_signal_handler_disconnect (info->object, info->object_destroy_handler); + g_signal_handler_disconnect (info->object, info->signal_handler); + g_signal_handler_disconnect (info->realized_widget, info->realized_widget_destroy_handler); + g_signal_handler_disconnect (info->realized_widget, info->realized_widget_unrealized_handler); + g_free (info); +} + +/** + * eel_gtk_signal_connect_while_realized: + * + * @object: Object to connect to. + * @name: Name of signal to connect to. + * @callback: Caller's callback. + * @callback_data: Caller's callback_data. + * @realized_widget: Widget to monitor for realized state. Signal is connected + * while this wigget is realized. + * + * Connect to a signal of an object while another widget is realized. This is + * useful for non windowed widgets that need to monitor events in their ancestored + * windowed widget. The signal is automatically disconnected when &widget is + * unrealized. Also, the signal is automatically disconnected when either &object + * or &widget are destroyed. + **/ +void +eel_gtk_signal_connect_while_realized (GtkObject *object, + const char *name, + GCallback callback, + gpointer callback_data, + GtkWidget *realized_widget) +{ + RealizeDisconnectInfo *info; + + g_return_if_fail (GTK_IS_OBJECT (object)); + g_return_if_fail (name != NULL); + g_return_if_fail (name[0] != '\0'); + g_return_if_fail (callback != NULL); + g_return_if_fail (GTK_IS_WIDGET (realized_widget)); + g_return_if_fail (gtk_widget_get_realized (realized_widget)); + + info = g_new0 (RealizeDisconnectInfo, 1); + + info->object = object; + info->object_destroy_handler = + g_signal_connect (G_OBJECT (info->object), + "destroy", + G_CALLBACK (while_realized_disconnecter), + info); + + info->realized_widget = realized_widget; + info->realized_widget_destroy_handler = + g_signal_connect (G_OBJECT (info->realized_widget), + "destroy", + G_CALLBACK (while_realized_disconnecter), + info); + info->realized_widget_unrealized_handler = + g_signal_connect_after (G_OBJECT (info->realized_widget), + "unrealize", + G_CALLBACK (while_realized_disconnecter), + info); + + info->signal_handler = g_signal_connect (G_OBJECT (info->object), + name, callback, callback_data); +} + +/** + * eel_gtk_container_get_first_child. + * + * Returns the first child of a container. + * @container: The container. + **/ + +static void +get_first_callback (GtkWidget *widget, gpointer callback_data) +{ + GtkWidget **first_child_slot; + + g_assert (GTK_IS_WIDGET (widget)); + g_assert (callback_data != NULL); + + first_child_slot = callback_data; + + if (*first_child_slot == NULL) + { + *first_child_slot = widget; + /* We'd stop the iterating now if we could. */ + } + else + { + g_assert (GTK_IS_WIDGET (*first_child_slot)); + } +} + +GtkWidget * +eel_gtk_container_get_first_child (GtkContainer *container) +{ + GtkWidget *first_child; + + g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL); + + first_child = NULL; + gtk_container_foreach (container, get_first_callback, &first_child); + g_assert (first_child == NULL || GTK_IS_WIDGET (first_child)); + return first_child; +} + +typedef struct +{ + GtkCallback callback; + gpointer callback_data; +} container_foreach_deep_callback_data; + +static void +container_foreach_deep_callback (GtkWidget *child, gpointer data) +{ + container_foreach_deep_callback_data *deep_data; + + deep_data = (container_foreach_deep_callback_data *) data; + + deep_data->callback (child, deep_data->callback_data); + + if (GTK_IS_CONTAINER (child)) + { + gtk_container_foreach (GTK_CONTAINER (child), container_foreach_deep_callback, data); + } +} + +void +eel_gtk_container_foreach_deep (GtkContainer *container, + GtkCallback callback, + gpointer callback_data) +{ + container_foreach_deep_callback_data deep_data; + deep_data.callback = callback; + deep_data.callback_data = callback_data; + gtk_container_foreach (container, container_foreach_deep_callback, &deep_data); +} + +/* The standard gtk_adjustment_set_value ignores page size, which + * disagrees with the logic used by scroll bars, for example. + */ +void +eel_gtk_adjustment_set_value (GtkAdjustment *adjustment, + float value) +{ + float upper_page_start, clamped_value; + + g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment)); + + upper_page_start = MAX (gtk_adjustment_get_upper (adjustment) - + gtk_adjustment_get_page_size (adjustment), + gtk_adjustment_get_lower (adjustment)); + clamped_value = CLAMP (value, gtk_adjustment_get_lower (adjustment), upper_page_start); + if (clamped_value != gtk_adjustment_get_value (adjustment)) + { + gtk_adjustment_set_value (adjustment, clamped_value); + gtk_adjustment_value_changed (adjustment); + } +} + +/* Clamp a value if the minimum or maximum has changed. */ +void +eel_gtk_adjustment_clamp_value (GtkAdjustment *adjustment) +{ + g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment)); + + eel_gtk_adjustment_set_value (adjustment, + gtk_adjustment_get_value (adjustment)); +} + +/** + * eel_gtk_label_make_bold. + * + * Switches the font of label to a bold equivalent. + * @label: The label. + **/ +void +eel_gtk_label_make_bold (GtkLabel *label) +{ + PangoFontDescription *font_desc; + + font_desc = pango_font_description_new (); + + pango_font_description_set_weight (font_desc, + PANGO_WEIGHT_BOLD); + + /* This will only affect the weight of the font, the rest is + * from the current state of the widget, which comes from the + * theme or user prefs, since the font desc only has the + * weight flag turned on. + */ + gtk_widget_modify_font (GTK_WIDGET (label), font_desc); + + pango_font_description_free (font_desc); +} + +/** + * eel_gtk_label_set_scale: + * @label: + * @num_steps: + * + * Function is broken, see eel_gtk_label_make_larger() for explanation + * + **/ +void +eel_gtk_label_set_scale (GtkLabel *label, + double scale_factor) +{ + PangoAttrList *old_attr_list; + PangoAttrList *attr_list; + + g_return_if_fail (GTK_IS_LABEL (label)); + g_return_if_fail (scale_factor > 0); + + old_attr_list = gtk_label_get_attributes (label); + attr_list = eel_pango_attr_list_apply_global_attribute (old_attr_list, + pango_attr_scale_new (scale_factor)); + gtk_label_set_attributes (label, attr_list); + pango_attr_list_unref (attr_list); +} + +static void +get_layout_location (GtkLabel *label, + gint *xp, + gint *yp) +{ + GtkMisc *misc; + GtkWidget *widget; + float xalign, yalign; + int x, y, xpad, ypad; + int shadow_offset; + GtkAllocation allocation; + GtkRequisition req; + + shadow_offset = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (label), + "eel-label-shadow-offset")); + + misc = GTK_MISC (label); + widget = GTK_WIDGET (label); + gtk_misc_get_alignment (misc, &xalign, &yalign); + gtk_misc_get_padding (misc, &xpad, &ypad); + + if (gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR) + xalign = 1.0 - xalign; + + gtk_widget_get_allocation (widget, &allocation); + gtk_widget_get_requisition (widget, &req); + x = floor (allocation.x + xpad + + ((allocation.width - req.width - shadow_offset) * xalign) + + 0.5); + + y = floor (allocation.y + ypad + + ((allocation.height - req.height - shadow_offset) * yalign) + + 0.5); + + + if (xp) + *xp = x; + + if (yp) + *yp = y; +} + +static gboolean +eel_gtk_label_expose_event (GtkLabel *label, GdkEventExpose *event, gpointer user_data) +{ + int x, y; + GdkColor color; + GtkWidget *widget; + GdkGC *gc; + guint32 shadow_color; + int shadow_offset; + + shadow_color = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (label), + "eel-label-shadow-color")); + shadow_offset = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (label), + "eel-label-shadow-offset")); + + color = eel_gdk_rgb_to_color (shadow_color); + + get_layout_location (label, &x, &y); + + widget = GTK_WIDGET (label); + if (shadow_offset > 0) + { + gc = gdk_gc_new (gtk_widget_get_window (widget)); + gdk_gc_set_rgb_fg_color (gc, &color); + gdk_gc_set_clip_rectangle (gc, &event->area); + + gdk_draw_layout (gtk_widget_get_window (widget), + gc, + x + shadow_offset, y + shadow_offset, + gtk_label_get_layout (label)); + g_object_unref (gc); + } + + gtk_paint_layout (gtk_widget_get_style (widget), + gtk_widget_get_window (widget), + gtk_widget_get_state (widget), + FALSE, + &event->area, + widget, + "label", + x, y, + gtk_label_get_layout (label)); + + return TRUE; +} + +static void +eel_gtk_label_size_request (GtkLabel *label, GtkRequisition *requisition, gpointer user_data) +{ + gint shadow_offset; + + shadow_offset = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (label), + "eel-label-shadow-offset")); + + requisition->width += shadow_offset; + requisition->height += shadow_offset; +} + +static void +set_up_label (GtkLabel *label) +{ + + if (g_object_get_data (G_OBJECT (label), "eel-label-set-up") != NULL) + { + return; + } + + g_signal_connect (label, "expose_event", + G_CALLBACK (eel_gtk_label_expose_event), NULL); + g_signal_connect_after (label, "size_request", + G_CALLBACK (eel_gtk_label_size_request), NULL); + + g_object_set_data (G_OBJECT (label), "eel-label-set-up", "eel-label-set-up"); +} + +void +eel_gtk_label_set_drop_shadow_color (GtkLabel *label, + guint32 color) +{ + set_up_label (label); + + g_object_set_data (G_OBJECT (label), "eel-label-shadow-color", + GINT_TO_POINTER (color)); + + gtk_widget_queue_draw (GTK_WIDGET (label)); +} + +void +eel_gtk_label_set_drop_shadow_offset (GtkLabel *label, + gint offset) +{ + set_up_label (label); + + g_object_set_data (G_OBJECT (label), "eel-label-shadow-offset", + GINT_TO_POINTER (offset)); + + gtk_widget_queue_draw (GTK_WIDGET (label)); +} + +void +eel_gtk_widget_set_background_color (GtkWidget *widget, + const char *color_spec) +{ + GdkColor color; + + g_return_if_fail (GTK_IS_WIDGET (widget)); + + eel_gdk_color_parse_with_white_default (color_spec, &color); + + gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, &color); + gtk_widget_modify_base (widget, GTK_STATE_NORMAL, &color); + gtk_widget_modify_bg (widget, GTK_STATE_ACTIVE, &color); + gtk_widget_modify_base (widget, GTK_STATE_ACTIVE, &color); +} + +void +eel_gtk_widget_set_foreground_color (GtkWidget *widget, + const char *color_spec) +{ + GdkColor color; + + g_return_if_fail (GTK_IS_WIDGET (widget)); + + eel_gdk_color_parse_with_white_default (color_spec, &color); + + gtk_widget_modify_fg (widget, GTK_STATE_NORMAL, &color); + gtk_widget_modify_text (widget, GTK_STATE_NORMAL, &color); + gtk_widget_modify_fg (widget, GTK_STATE_ACTIVE, &color); + gtk_widget_modify_text (widget, GTK_STATE_ACTIVE, &color); +} + +GtkWidget * +eel_gtk_widget_find_windowed_ancestor (GtkWidget *widget) +{ + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); + + while (widget && !gtk_widget_get_has_window (widget)) + { + widget = gtk_widget_get_parent (widget); + } + + return widget; +} + +/* eel_gtk_get_system_font: + * + * Return the system font as selected in the control center. Need to + * g_object_unref() the result when done with it. + * + * Perhaps there is a better way to figure out what that font is, but + * the following is simple enough and it works. + */ +PangoFontDescription * +eel_gtk_get_system_font (void) +{ + GtkWidget *label; + PangoFontDescription *font; + + label = gtk_label_new (""); + + gtk_widget_ensure_style (label); + + font = pango_font_description_copy (gtk_widget_get_style (label)->font_desc); + + g_object_ref_sink (label); + g_object_unref (label); + + return font; +} + +void +eel_gtk_widget_get_button_event_location (GtkWidget *widget, + const GdkEventButton *event, + int *x, + int *y) +{ + int window_x, window_y; + GtkAllocation allocation; + + g_return_if_fail (GTK_IS_WIDGET (widget)); + g_return_if_fail (event != NULL); + + gdk_window_get_position (event->window, &window_x, &window_y); + gtk_widget_get_allocation (widget, &allocation); + if (x != NULL) + { + *x = event->x + window_x - allocation.x; + } + if (y != NULL) + { + *y = event->y + window_y - allocation.y; + } +} + +void +eel_gtk_widget_get_motion_event_location (GtkWidget *widget, + const GdkEventMotion *event, + int *x, + int *y) +{ + eel_gtk_widget_get_button_event_location (widget, (const GdkEventButton *) event, x, y); +} + +static gboolean +tree_view_button_press_callback (GtkWidget *tree_view, + GdkEventButton *event, + gpointer data) +{ + GtkTreePath *path; + GtkTreeViewColumn *column; + + if (event->button == 1 && event->type == GDK_BUTTON_PRESS) + { + if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), + event->x, event->y, + &path, + &column, + NULL, + NULL)) + { + gtk_tree_view_row_activated + (GTK_TREE_VIEW (tree_view), path, column); + } + } + + return FALSE; +} + +void +eel_gtk_tree_view_set_activate_on_single_click (GtkTreeView *tree_view, + gboolean should_activate) +{ + guint button_press_id; + + button_press_id = GPOINTER_TO_UINT + (g_object_get_data (G_OBJECT (tree_view), + "eel-tree-view-activate")); + + if (button_press_id && !should_activate) + { + g_signal_handler_disconnect (tree_view, button_press_id); + g_object_set_data (G_OBJECT (tree_view), + "eel-tree-view-activate", + NULL); + } + else if (!button_press_id && should_activate) + { + button_press_id = g_signal_connect + (tree_view, + "button_press_event", + G_CALLBACK (tree_view_button_press_callback), + NULL); + g_object_set_data (G_OBJECT (tree_view), + "eel-tree-view-activate", + GUINT_TO_POINTER (button_press_id)); + } +} + +gboolean +eel_gtk_viewport_get_visible_rect (GtkViewport *viewport, + GdkRectangle *rect) +{ + GdkRectangle viewport_rect; + GdkRectangle child_rect; + gboolean return_val; + + g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), FALSE); + g_return_val_if_fail (rect != NULL, FALSE); + + if (gtk_widget_get_realized (GTK_WIDGET (viewport))) + { + viewport_rect.x = 0; + viewport_rect.y = 0; + +#if GTK_CHECK_VERSION(3, 0, 0) + viewport_rect.width = gdk_window_get_width(GDK_WINDOW(gtk_viewport_get_view_window(viewport))); + viewport_rect.height = gdk_window_get_height(GDK_WINDOW(gtk_viewport_get_view_window(viewport))); +#else + gdk_drawable_get_size(gtk_viewport_get_view_window(viewport), &viewport_rect.width, &viewport_rect.height); +#endif + + gdk_window_get_position (gtk_viewport_get_bin_window (viewport), + &child_rect.x, + &child_rect.y); + +#if GTK_CHECK_VERSION(3, 0, 0) + child_rect.width = gdk_window_get_width(GDK_WINDOW(gtk_viewport_get_view_window(viewport))); + child_rect.height = gdk_window_get_height(GDK_WINDOW(gtk_viewport_get_view_window(viewport))); +#else + gdk_drawable_get_size(gtk_viewport_get_bin_window(viewport), &child_rect.width, &child_rect.height); +#endif + + return_val = gdk_rectangle_intersect (&viewport_rect, + &child_rect, + rect); + rect->x -= child_rect.x; + rect->y -= child_rect.y; + + return return_val; + } + + rect->x = rect->y = rect->width = rect->height = 0; + return FALSE; +} + +void +eel_gtk_viewport_scroll_to_rect (GtkViewport *viewport, + GdkRectangle *rect) +{ + GdkRectangle visible_rect; + int scroll_x; + int scroll_y; + GtkAdjustment *adjustment; + + g_return_if_fail (GTK_IS_VIEWPORT (viewport)); + g_return_if_fail (rect != NULL); + + if (eel_gtk_viewport_get_visible_rect (viewport, &visible_rect)) + { + scroll_x = -1; + scroll_y = -1; + + if (rect->x + rect->width > visible_rect.x + visible_rect.width) + { + scroll_x = rect->x - (visible_rect.width - rect->width); + } + if (rect->y + rect->height > visible_rect.y + visible_rect.height) + { + scroll_y = rect->y - (visible_rect.height - rect->height); + } + + if (rect->x < visible_rect.x) + { + scroll_x = rect->x; + } + + if (rect->y < visible_rect.y) + { + scroll_y = rect->y; + } + + adjustment = gtk_viewport_get_hadjustment (viewport); + if (adjustment && scroll_x != -1) + { + eel_gtk_adjustment_set_value (adjustment, + (double)scroll_x); + } + + adjustment = gtk_viewport_get_vadjustment (viewport); + if (adjustment && scroll_y != -1) + { + eel_gtk_adjustment_set_value (adjustment, + (double)scroll_y); + } + } +} |