* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#define GTK_MENU_INTERNALS
#include "config.h"
#include <string.h>
#include "gdk/gdkkeysyms.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtkmenu.h"
+#include "gtkmenuprivate.h"
#include "gtktearoffmenuitem.h"
#include "gtkwindow.h"
#include "gtkhbox.h"
#include "gtkvscrollbar.h"
#include "gtksettings.h"
-#include "gtksizerequest.h"
#include "gtkprivate.h"
#include "gtkintl.h"
-#define DEFAULT_POPUP_DELAY 225
-#define DEFAULT_POPDOWN_DELAY 1000
-
#define NAVIGATION_REGION_OVERSHOOT 50 /* How much the navigation region
* extends below the submenu
*/
gint y;
gboolean initially_pushed_in;
+ GDestroyNotify position_func_data_destroy;
+
/* info used for the table */
guint *heights;
gint heights_length;
guint property_id,
GValue *value,
GParamSpec *pspec);
-static void gtk_menu_destroy (GtkObject *object);
+static void gtk_menu_destroy (GtkWidget *widget);
static void gtk_menu_realize (GtkWidget *widget);
static void gtk_menu_unrealize (GtkWidget *widget);
static void gtk_menu_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static void gtk_menu_paint (GtkWidget *widget,
- GdkEventExpose *expose);
static void gtk_menu_show (GtkWidget *widget);
-static gboolean gtk_menu_expose (GtkWidget *widget,
- GdkEventExpose *event);
+static gboolean gtk_menu_draw (GtkWidget *widget,
+ cairo_t *cr);
static gboolean gtk_menu_key_press (GtkWidget *widget,
GdkEventKey *event);
static gboolean gtk_menu_scroll (GtkWidget *widget,
static void gtk_menu_deactivate (GtkMenuShell *menu_shell);
static void gtk_menu_show_all (GtkWidget *widget);
-static void gtk_menu_hide_all (GtkWidget *widget);
static void gtk_menu_position (GtkMenu *menu);
static void gtk_menu_reparent (GtkMenu *menu,
GtkWidget *new_parent,
static void _gtk_menu_refresh_accel_paths (GtkMenu *menu,
gboolean group_changed);
-static void gtk_menu_size_request_init (GtkSizeRequestIface *iface);
-static void gtk_menu_get_width (GtkSizeRequest *widget,
- gint *minimum_size,
- gint *natural_size);
-static void gtk_menu_get_height (GtkSizeRequest *widget,
- gint *minimum_size,
- gint *natural_size);
-static void gtk_menu_get_height_for_width (GtkSizeRequest *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size);
+static void gtk_menu_get_preferred_width (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size);
+static void gtk_menu_get_preferred_height (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size);
+static void gtk_menu_get_preferred_height_for_width (GtkWidget *widget,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size);
static const gchar attach_data_key[] = "gtk-menu-attach-data";
return G_TYPE_INSTANCE_GET_PRIVATE (menu, GTK_TYPE_MENU, GtkMenuPrivate);
}
-G_DEFINE_TYPE_WITH_CODE (GtkMenu, gtk_menu, GTK_TYPE_MENU_SHELL,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_SIZE_REQUEST,
- gtk_menu_size_request_init))
+G_DEFINE_TYPE (GtkMenu, gtk_menu, GTK_TYPE_MENU_SHELL)
static void
menu_queue_resize (GtkMenu *menu)
int *t,
int *b)
{
- GtkMenu *menu = GTK_MENU (child->parent);
+ GtkMenu *menu = GTK_MENU (gtk_widget_get_parent (child));
AttachInfo *ai;
menu_ensure_layout (menu);
gtk_menu_class_init (GtkMenuClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
- GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (class);
GtkMenuShellClass *menu_shell_class = GTK_MENU_SHELL_CLASS (class);
gobject_class->set_property = gtk_menu_set_property;
gobject_class->get_property = gtk_menu_get_property;
- object_class->destroy = gtk_menu_destroy;
-
+ widget_class->destroy = gtk_menu_destroy;
widget_class->realize = gtk_menu_realize;
widget_class->unrealize = gtk_menu_unrealize;
widget_class->size_allocate = gtk_menu_size_allocate;
widget_class->show = gtk_menu_show;
- widget_class->expose_event = gtk_menu_expose;
+ widget_class->draw = gtk_menu_draw;
widget_class->scroll_event = gtk_menu_scroll;
widget_class->key_press_event = gtk_menu_key_press;
widget_class->button_press_event = gtk_menu_button_press;
widget_class->button_release_event = gtk_menu_button_release;
widget_class->motion_notify_event = gtk_menu_motion_notify;
widget_class->show_all = gtk_menu_show_all;
- widget_class->hide_all = gtk_menu_hide_all;
widget_class->enter_notify_event = gtk_menu_enter_notify;
widget_class->leave_notify_event = gtk_menu_leave_notify;
widget_class->style_set = gtk_menu_style_set;
widget_class->focus = gtk_menu_focus;
widget_class->can_activate_accel = gtk_menu_real_can_activate_accel;
widget_class->grab_notify = gtk_menu_grab_notify;
+ widget_class->get_preferred_width = gtk_menu_get_preferred_width;
+ widget_class->get_preferred_height = gtk_menu_get_preferred_height;
+ widget_class->get_preferred_height_for_width = gtk_menu_get_preferred_height_for_width;
container_class->remove = gtk_menu_remove;
container_class->get_child_property = gtk_menu_get_child_property;
menu_signals[MOVE_SCROLL] =
g_signal_new_class_handler (I_("move-scroll"),
- G_OBJECT_CLASS_TYPE (object_class),
+ G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gtk_menu_real_move_scroll),
NULL, NULL,
binding_set = gtk_binding_set_by_class (class);
gtk_binding_entry_add_signal (binding_set,
- GDK_Up, 0,
+ GDK_KEY_Up, 0,
I_("move-current"), 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PREV);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Up, 0,
+ GDK_KEY_KP_Up, 0,
"move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PREV);
gtk_binding_entry_add_signal (binding_set,
- GDK_Down, 0,
+ GDK_KEY_Down, 0,
"move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_NEXT);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Down, 0,
+ GDK_KEY_KP_Down, 0,
"move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_NEXT);
gtk_binding_entry_add_signal (binding_set,
- GDK_Left, 0,
+ GDK_KEY_Left, 0,
"move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PARENT);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Left, 0,
+ GDK_KEY_KP_Left, 0,
"move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PARENT);
gtk_binding_entry_add_signal (binding_set,
- GDK_Right, 0,
+ GDK_KEY_Right, 0,
"move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_CHILD);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Right, 0,
+ GDK_KEY_KP_Right, 0,
"move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_CHILD);
gtk_binding_entry_add_signal (binding_set,
- GDK_Home, 0,
+ GDK_KEY_Home, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_START);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Home, 0,
+ GDK_KEY_KP_Home, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_START);
gtk_binding_entry_add_signal (binding_set,
- GDK_End, 0,
+ GDK_KEY_End, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_END);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_End, 0,
+ GDK_KEY_KP_End, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_END);
gtk_binding_entry_add_signal (binding_set,
- GDK_Page_Up, 0,
+ GDK_KEY_Page_Up, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_UP);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Page_Up, 0,
+ GDK_KEY_KP_Page_Up, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_UP);
gtk_binding_entry_add_signal (binding_set,
- GDK_Page_Down, 0,
+ GDK_KEY_Page_Down, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_DOWN);
gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Page_Down, 0,
+ GDK_KEY_KP_Page_Down, 0,
"move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_DOWN);
- gtk_settings_install_property (g_param_spec_boolean ("gtk-can-change-accels",
- P_("Can change accelerators"),
- P_("Whether menu accelerators can be changed by pressing a key over the menu item"),
- FALSE,
- GTK_PARAM_READWRITE));
-
- gtk_settings_install_property (g_param_spec_int ("gtk-menu-popup-delay",
- P_("Delay before submenus appear"),
- P_("Minimum time the pointer must stay over a menu item before the submenu appear"),
- 0,
- G_MAXINT,
- DEFAULT_POPUP_DELAY,
- GTK_PARAM_READWRITE));
-
- gtk_settings_install_property (g_param_spec_int ("gtk-menu-popdown-delay",
- P_("Delay before hiding a submenu"),
- P_("The time before hiding a submenu when the pointer is moving towards the submenu"),
- 0,
- G_MAXINT,
- DEFAULT_POPDOWN_DELAY,
- GTK_PARAM_READWRITE));
-
g_type_class_add_private (gobject_class, sizeof (GtkMenuPrivate));
}
}
static void
-gtk_menu_destroy (GtkObject *object)
+gtk_menu_destroy (GtkWidget *widget)
{
- GtkMenu *menu = GTK_MENU (object);
+ GtkMenu *menu = GTK_MENU (widget);
GtkMenuAttachData *data;
GtkMenuPrivate *priv;
gtk_menu_remove_scroll_timeout (menu);
- data = g_object_get_data (G_OBJECT (object), attach_data_key);
+ data = g_object_get_data (G_OBJECT (widget), attach_data_key);
if (data)
gtk_menu_detach (menu);
if (menu->needs_destruction_ref_count)
{
menu->needs_destruction_ref_count = FALSE;
- g_object_ref (object);
+ g_object_ref (widget);
}
if (menu->accel_group)
priv->title = NULL;
}
- GTK_OBJECT_CLASS (gtk_menu_parent_class)->destroy (object);
+ if (priv->position_func_data_destroy)
+ {
+ priv->position_func_data_destroy (menu->position_func_data);
+ menu->position_func_data = NULL;
+ priv->position_func_data_destroy = NULL;
+ }
+
+ GTK_WIDGET_CLASS (gtk_menu_parent_class)->destroy (widget);
}
static void
if (menu->torn_off)
{
- GdkPixmap *pixmap;
+ GdkWindow *window;
+ cairo_surface_t *surface;
+ cairo_pattern_t *pattern;
cairo_t *cr;
menu->tearoff_active = FALSE;
menu->saved_scroll_offset = menu->scroll_offset;
-
- gdk_drawable_get_size (menu->tearoff_window->window, &width, &height);
-
- pixmap = gdk_pixmap_new (menu->tearoff_window->window,
- width,
- height,
- -1);
-
- cr = gdk_cairo_create (pixmap);
- /* Let's hope that function never notices we're not passing it a pixmap */
- gdk_cairo_set_source_pixmap (cr,
- menu->tearoff_window->window,
+
+ window = gtk_widget_get_window (menu->tearoff_window);
+ width = gdk_window_get_width (window);
+ height = gdk_window_get_height (window);
+
+ surface = gdk_window_create_similar_surface (window,
+ CAIRO_CONTENT_COLOR,
+ width,
+ height);
+
+ cr = cairo_create (surface);
+ gdk_cairo_set_source_window (cr,
+ window,
0, 0);
cairo_paint (cr);
cairo_destroy (cr);
width,
height);
- gdk_window_set_back_pixmap (menu->tearoff_window->window, pixmap, FALSE);
- g_object_unref (pixmap);
+ pattern = cairo_pattern_create_for_surface (surface);
+ gdk_window_set_background_pattern (window, pattern);
+
+ cairo_pattern_destroy (pattern);
+ cairo_surface_destroy (surface);
}
}
* gtk_menu_popup_for_device:
* @menu: a #GtkMenu.
* @device: (allow-none): a #GdkDevice
- * @parent_menu_shell: (allow-none): the menu shell containing the triggering menu item, or %NULL
- * @parent_menu_item: (allow-none): the menu item whose activation triggered the popup, or %NULL
- * @func: (allow-none): a user supplied function used to position the menu, or %NULL
- * @data: (allow-none): user supplied data to be passed to @func.
- * @button: the mouse button which was pressed to initiate the event.
- * @activate_time: the time at which the activation event occurred.
+ * @parent_menu_shell: (allow-none): the menu shell containing the triggering
+ * menu item, or %NULL
+ * @parent_menu_item: (allow-none): the menu item whose activation triggered
+ * the popup, or %NULL
+ * @func: (allow-none): a user supplied function used to position the menu,
+ * or %NULL
+ * @data: (allow-none): user supplied data to be passed to @func
+ * @destroy: (allow-none): destroy notify for @data
+ * @button: the mouse button which was pressed to initiate the event
+ * @activate_time: the time at which the activation event occurred
*
- * Displays a menu and makes it available for selection. Applications can use
- * this function to display context-sensitive menus, and will typically supply
- * %NULL for the @parent_menu_shell, @parent_menu_item, @func and @data
- * parameters. The default menu positioning function will position the menu
- * at the current position of @device (or its corresponding pointer).
+ * Displays a menu and makes it available for selection.
+ *
+ * Applications can use this function to display context-sensitive menus,
+ * and will typically supply %NULL for the @parent_menu_shell,
+ * @parent_menu_item, @func, @data and @destroy parameters. The default
+ * menu positioning function will position the menu at the current position
+ * of @device (or its corresponding pointer).
*
* The @button parameter should be the mouse button pressed to initiate
* the menu popup. If the menu popup was initiated by something other than
GtkWidget *parent_menu_item,
GtkMenuPositionFunc func,
gpointer data,
+ GDestroyNotify destroy,
guint button,
guint32 activate_time)
{
GdkDevice *keyboard, *pointer;
g_return_if_fail (GTK_IS_MENU (menu));
- g_return_if_fail (GDK_IS_DEVICE (device));
+ g_return_if_fail (device == NULL || GDK_IS_DEVICE (device));
+
+ if (device == NULL)
+ device = gtk_get_current_event_device ();
+
+ if (device == NULL)
+ {
+ GdkDisplay *display;
+ GdkDeviceManager *device_manager;
+ GList *devices;
+
+ display = gtk_widget_get_display (GTK_WIDGET (menu));
+ device_manager = gdk_display_get_device_manager (display);
+ devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+
+ device = devices->data;
+
+ g_list_free (devices);
+ }
widget = GTK_WIDGET (menu);
menu_shell = GTK_MENU_SHELL (menu);
viewable = FALSE;
break;
}
- tmp = tmp->parent;
+ tmp = gtk_widget_get_parent (tmp);
}
if (viewable)
if (xgrab_shell && xgrab_shell != widget)
{
- if (popup_grab_on_window (xgrab_shell->window, keyboard, pointer, activate_time))
+ if (popup_grab_on_window (gtk_widget_get_window (xgrab_shell), keyboard, pointer, activate_time))
{
_gtk_menu_shell_set_grab_device (GTK_MENU_SHELL (xgrab_shell), pointer);
GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
menu->parent_menu_item = parent_menu_item;
menu->position_func = func;
menu->position_func_data = data;
+ priv->position_func_data_destroy = destroy;
menu_shell->activate_time = activate_time;
/* We need to show the menu here rather in the init function because
/* Instead of trusting the menu position function to queue a resize when the
* menu goes out of bounds, invalidate the cached size here. */
gtk_widget_queue_resize (GTK_WIDGET (menu));
- gtk_size_request_get_size (GTK_SIZE_REQUEST (menu->toplevel), &tmp_request, NULL);
+ gtk_widget_get_preferred_size (menu->toplevel, &tmp_request, NULL);
tmp_allocation.width = tmp_request.width;
tmp_allocation.height = tmp_request.height;
gtk_widget_show (menu->toplevel);
if (xgrab_shell == widget)
- popup_grab_on_window (widget->window, keyboard, pointer, activate_time); /* Should always succeed */
+ popup_grab_on_window (gtk_widget_get_window (widget), keyboard, pointer, activate_time); /* Should always succeed */
gtk_device_grab_add (GTK_WIDGET (menu), pointer, TRUE);
guint button,
guint32 activate_time)
{
- GdkDevice *device;
-
g_return_if_fail (GTK_IS_MENU (menu));
- device = gtk_get_current_event_device ();
-
- if (!device)
- {
- GdkDisplay *display;
- GdkDeviceManager *device_manager;
- GList *devices;
-
- display = gtk_widget_get_display (GTK_WIDGET (menu));
- device_manager = gdk_display_get_device_manager (display);
- devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
-
- device = devices->data;
-
- g_list_free (devices);
- }
-
- gtk_menu_popup_for_device (menu, device,
+ gtk_menu_popup_for_device (menu,
+ NULL,
parent_menu_shell,
parent_menu_item,
- func, data,
+ func, data, NULL,
button, activate_time);
}
if (gtk_widget_get_visible (menu->tearoff_scrollbar))
{
- gtk_widget_size_request (menu->tearoff_scrollbar, NULL);
- width += menu->tearoff_scrollbar->requisition.width;
+ GtkRequisition requisition;
+
+ gtk_widget_get_preferred_size (menu->tearoff_scrollbar,
+ &requisition, NULL);
+ width += requisition.width;
}
geometry_hints.min_width = width;
attach = gtk_menu_get_attach_widget (GTK_MENU (menu));
if (GTK_IS_MENU_ITEM (attach))
- attach = attach->parent;
+ attach = gtk_widget_get_parent (attach);
if (GTK_IS_MENU (attach))
return gtk_menu_get_toplevel (attach);
gtk_menu_set_tearoff_state (GtkMenu *menu,
gboolean torn_off)
{
- gint width, height;
+ gint height;
GtkMenuPrivate *priv;
g_return_if_fail (GTK_IS_MENU (menu));
if (toplevel != NULL)
gtk_window_set_transient_for (GTK_WINDOW (menu->tearoff_window),
GTK_WINDOW (toplevel));
-
- menu->tearoff_hbox = gtk_hbox_new (FALSE, FALSE);
+
+ menu->tearoff_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 0);
gtk_container_add (GTK_CONTAINER (menu->tearoff_window), menu->tearoff_hbox);
- gdk_drawable_get_size (GTK_WIDGET (menu)->window, &width, &height);
- menu->tearoff_adjustment =
- GTK_ADJUSTMENT (gtk_adjustment_new (0,
- 0,
- priv->requested_height,
- MENU_SCROLL_STEP2,
- height/2,
- height));
+ height = gdk_window_get_height (gtk_widget_get_window (GTK_WIDGET (menu)));
+ menu->tearoff_adjustment = gtk_adjustment_new (0,
+ 0, priv->requested_height,
+ MENU_SCROLL_STEP2,
+ height/2,
+ height);
g_object_connect (menu->tearoff_adjustment,
"signal::value-changed", gtk_menu_scrollbar_changed, menu,
NULL);
- menu->tearoff_scrollbar = gtk_vscrollbar_new (menu->tearoff_adjustment);
+ menu->tearoff_scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, menu->tearoff_adjustment);
gtk_box_pack_end (GTK_BOX (menu->tearoff_hbox),
menu->tearoff_scrollbar,
gtk_menu_reparent (menu, menu->tearoff_hbox, FALSE);
- gdk_drawable_get_size (GTK_WIDGET (menu)->window, &width, NULL);
-
/* Update menu->requisition
*/
- gtk_widget_size_request (GTK_WIDGET (menu), NULL);
-
- gtk_menu_set_tearoff_hints (menu, width);
+ gtk_widget_get_preferred_size (GTK_WIDGET (menu),
+ NULL, NULL);
+
+ gtk_menu_set_tearoff_hints (menu, gdk_window_get_width (gtk_widget_get_window (GTK_WIDGET (menu))));
gtk_widget_realize (menu->tearoff_window);
gtk_menu_position (menu);
if (gtk_widget_get_realized (widget))
{
GtkMenu *menu = GTK_MENU (widget);
-
- gtk_style_set_background (widget->style, menu->bin_window, GTK_STATE_NORMAL);
- gtk_style_set_background (widget->style, menu->view_window, GTK_STATE_NORMAL);
- gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+ GtkStyle *style;
+
+ style = gtk_widget_get_style (widget);
+
+ gtk_style_set_background (style, menu->bin_window, GTK_STATE_NORMAL);
+ gtk_style_set_background (style, menu->view_window, GTK_STATE_NORMAL);
+ gtk_style_set_background (style, gtk_widget_get_window (widget), GTK_STATE_NORMAL);
}
}
static void
gtk_menu_realize (GtkWidget *widget)
{
+ GtkAllocation allocation;
+ GtkStyle *style;
+ GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
gint border_width;
priv = gtk_menu_get_private (menu);
gtk_widget_set_realized (widget, TRUE);
-
+
+ gtk_widget_get_allocation (widget, &allocation);
+
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.x = allocation.x;
+ attributes.y = allocation.y;
+ attributes.width = allocation.width;
+ attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
-
attributes.event_mask = gtk_widget_get_events (widget);
-
attributes.event_mask |= (GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK );
-
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, widget);
-
+
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
+
+ window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
+ gtk_widget_set_window (widget, window);
+ gdk_window_set_user_data (window, widget);
+
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+ style = gtk_widget_get_style (widget);
gtk_widget_style_get (GTK_WIDGET (menu),
"vertical-padding", &vertical_padding,
"horizontal-padding", &horizontal_padding,
NULL);
- attributes.x = border_width + widget->style->xthickness + horizontal_padding;
- attributes.y = border_width + widget->style->ythickness + vertical_padding;
- attributes.width = MAX (1, widget->allocation.width - attributes.x * 2);
- attributes.height = MAX (1, widget->allocation.height - attributes.y * 2);
+ gtk_widget_get_allocation (widget, &allocation);
+
+ attributes.x = border_width + style->xthickness + horizontal_padding;
+ attributes.y = border_width + style->ythickness + vertical_padding;
+ attributes.width = MAX (1, allocation.width - attributes.x * 2);
+ attributes.height = MAX (1, allocation.height - attributes.y * 2);
get_arrows_border (menu, &arrow_border);
attributes.y += arrow_border.top;
attributes.height -= arrow_border.top;
attributes.height -= arrow_border.bottom;
- menu->view_window = gdk_window_new (widget->window, &attributes, attributes_mask);
+ menu->view_window = gdk_window_new (window,
+ &attributes, attributes_mask);
gdk_window_set_user_data (menu->view_window, menu);
+ gtk_widget_get_allocation (widget, &allocation);
+
attributes.x = 0;
attributes.y = 0;
- attributes.width = MAX (1, widget->allocation.width - (border_width + widget->style->xthickness + horizontal_padding) * 2);
- attributes.height = MAX (1, priv->requested_height - (border_width + widget->style->ythickness + vertical_padding) * 2);
-
- menu->bin_window = gdk_window_new (menu->view_window, &attributes, attributes_mask);
+ attributes.width = MAX (1, allocation.width - (border_width + style->xthickness + horizontal_padding) * 2);
+ attributes.height = MAX (1, priv->requested_height - (border_width + style->ythickness + vertical_padding) * 2);
+
+ menu->bin_window = gdk_window_new (menu->view_window,
+ &attributes, attributes_mask);
gdk_window_set_user_data (menu->bin_window, menu);
children = GTK_MENU_SHELL (menu)->children;
gtk_widget_set_parent_window (child, menu->bin_window);
}
-
- widget->style = gtk_style_attach (widget->style, widget->window);
- gtk_style_set_background (widget->style, menu->bin_window, GTK_STATE_NORMAL);
- gtk_style_set_background (widget->style, menu->view_window, GTK_STATE_NORMAL);
- gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+
+ gtk_widget_style_attach (widget);
+ gtk_style_set_background (style, menu->bin_window, GTK_STATE_NORMAL);
+ gtk_style_set_background (style, menu->view_window, GTK_STATE_NORMAL);
+ gtk_style_set_background (style, window, GTK_STATE_NORMAL);
if (GTK_MENU_SHELL (widget)->active_menu_item)
gtk_menu_scroll_item_visible (GTK_MENU_SHELL (widget),
NULL);
border_width = gtk_container_get_border_width (GTK_CONTAINER (menu));
- avail_width -= (border_width + horizontal_padding + widget->style->xthickness) * 2;
+ avail_width -= (border_width + horizontal_padding + gtk_widget_get_style (widget)->xthickness) * 2;
for (children = menu_shell->children; children; children = children->next)
{
part = avail_width / (r - l);
- gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (child), part,
- &child_min, &child_nat);
+ gtk_widget_get_preferred_height_for_width (child, part,
+ &child_min, &child_nat);
gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child), &toggle_size);
part = MAX (child_nat, toggle_size) / (b - t);
nat_heights[t] = MAX (nat_heights[t], part);
-
}
if (ret_min_heights)
GtkWidget *child;
GtkAllocation child_allocation;
GtkMenuPrivate *priv;
+ GtkStyle *style;
GList *children;
gint x, y, i;
gint width, height;
menu_shell = GTK_MENU_SHELL (widget);
priv = gtk_menu_get_private (menu);
- widget->allocation = *allocation;
+ gtk_widget_set_allocation (widget, allocation);
+
+ style = gtk_widget_get_style (widget);
gtk_widget_style_get (GTK_WIDGET (menu),
"vertical-padding", &vertical_padding,
NULL);
/* refresh our cached height request */
- priv->requested_height = (border_width + vertical_padding + GTK_WIDGET (widget)->style->ythickness) * 2;
+ priv->requested_height = (border_width + vertical_padding + style->ythickness) * 2;
for (i = 0; i < priv->heights_length; i++)
priv->requested_height += priv->heights[i];
- x = border_width + widget->style->xthickness + horizontal_padding;
- y = border_width + widget->style->ythickness + vertical_padding;
+ x = border_width + style->xthickness + horizontal_padding;
+ y = border_width + style->ythickness + vertical_padding;
width = MAX (1, allocation->width - x * 2);
height = MAX (1, allocation->height - y * 2);
if (gtk_widget_get_realized (widget))
{
- gdk_window_move_resize (widget->window,
+ gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
if (menu->tearoff_active)
{
- if (allocation->height >= priv->requested_height)
+ if (height >= priv->requested_height)
{
if (gtk_widget_get_visible (menu->tearoff_scrollbar))
{
GdkRectangle *lower,
gint *arrow_space)
{
+ GtkArrowPlacement arrow_placement;
+ GtkStyle *style;
GtkWidget *widget = GTK_WIDGET (menu);
guint border_width;
guint vertical_padding;
guint horizontal_padding;
gint scroll_arrow_height;
- GtkArrowPlacement arrow_placement;
+
+ style = gtk_widget_get_style (widget);
gtk_widget_style_get (widget,
"vertical-padding", &vertical_padding,
NULL);
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
- border->x = border_width + widget->style->xthickness + horizontal_padding;
- border->y = border_width + widget->style->ythickness + vertical_padding;
- gdk_drawable_get_size (widget->window, &border->width, &border->height);
+ border->x = border_width + style->xthickness + horizontal_padding;
+ border->y = border_width + style->ythickness + vertical_padding;
+ border->width = gdk_window_get_width (gtk_widget_get_window (widget));
+ border->height = gdk_window_get_height (gtk_widget_get_window (widget));
switch (arrow_placement)
{
lower->x = lower->y = lower->width = lower->height = 0;
}
- *arrow_space = scroll_arrow_height - 2 * widget->style->ythickness;
+ *arrow_space = scroll_arrow_height - 2 * style->ythickness;
}
-static void
-gtk_menu_paint (GtkWidget *widget,
- GdkEventExpose *event)
+static gboolean
+gtk_menu_draw (GtkWidget *widget,
+ cairo_t *cr)
{
GtkMenu *menu;
GtkMenuPrivate *priv;
+ GtkStyle *style;
GdkRectangle border;
GdkRectangle upper;
GdkRectangle lower;
+ GdkWindow *window;
gint arrow_space;
- g_return_if_fail (GTK_IS_MENU (widget));
-
menu = GTK_MENU (widget);
priv = gtk_menu_get_private (menu);
+ style = gtk_widget_get_style (widget);
+ window = gtk_widget_get_window (widget);
+
get_arrows_visible_area (menu, &border, &upper, &lower, &arrow_space);
- if (event->window == widget->window)
+ if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
{
gfloat arrow_scaling;
gint arrow_size;
gtk_widget_style_get (widget, "arrow-scaling", &arrow_scaling, NULL);
arrow_size = arrow_scaling * arrow_space;
- gtk_paint_box (widget->style,
- widget->window,
+ gtk_paint_box (style,
+ cr,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
- &event->area, widget, "menu",
- 0, 0, -1, -1);
+ widget, "menu",
+ 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
if (menu->upper_arrow_visible && !menu->tearoff_active)
{
- gtk_paint_box (widget->style,
- widget->window,
+ gtk_paint_box (style,
+ cr,
priv->upper_arrow_state,
GTK_SHADOW_OUT,
- &event->area, widget, "menu_scroll_arrow_up",
+ widget, "menu_scroll_arrow_up",
upper.x,
upper.y,
upper.width,
upper.height);
- gtk_paint_arrow (widget->style,
- widget->window,
+ gtk_paint_arrow (style,
+ cr,
priv->upper_arrow_state,
GTK_SHADOW_OUT,
- &event->area, widget, "menu_scroll_arrow_up",
+ widget, "menu_scroll_arrow_up",
GTK_ARROW_UP,
TRUE,
upper.x + (upper.width - arrow_size) / 2,
- upper.y + widget->style->ythickness + (arrow_space - arrow_size) / 2,
+ upper.y + style->ythickness + (arrow_space - arrow_size) / 2,
arrow_size, arrow_size);
}
if (menu->lower_arrow_visible && !menu->tearoff_active)
{
- gtk_paint_box (widget->style,
- widget->window,
+ gtk_paint_box (style,
+ cr,
priv->lower_arrow_state,
GTK_SHADOW_OUT,
- &event->area, widget, "menu_scroll_arrow_down",
+ widget, "menu_scroll_arrow_down",
lower.x,
lower.y,
lower.width,
lower.height);
- gtk_paint_arrow (widget->style,
- widget->window,
+ gtk_paint_arrow (style,
+ cr,
priv->lower_arrow_state,
GTK_SHADOW_OUT,
- &event->area, widget, "menu_scroll_arrow_down",
+ widget, "menu_scroll_arrow_down",
GTK_ARROW_DOWN,
TRUE,
lower.x + (lower.width - arrow_size) / 2,
- lower.y + widget->style->ythickness + (arrow_space - arrow_size) / 2,
+ lower.y + style->ythickness + (arrow_space - arrow_size) / 2,
arrow_size, arrow_size);
}
}
- else if (event->window == menu->bin_window)
+
+ if (gtk_cairo_should_draw_window (cr, menu->bin_window))
{
gint y = -border.y + menu->scroll_offset;
+
+ cairo_save (cr);
+ gtk_cairo_transform_to_window (cr, widget, menu->bin_window);
if (!menu->tearoff_active)
{
y -= arrow_border.top;
}
- gtk_paint_box (widget->style,
- menu->bin_window,
+ gtk_paint_box (style,
+ cr,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
- &event->area, widget, "menu",
+ widget, "menu",
- border.x, y,
border.width, border.height);
- }
-}
-static gboolean
-gtk_menu_expose (GtkWidget *widget,
- GdkEventExpose *event)
-{
- g_return_val_if_fail (GTK_IS_MENU (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+ cairo_restore (cr);
+ }
- if (gtk_widget_is_drawable (widget))
- {
- gtk_menu_paint (widget, event);
+ GTK_WIDGET_CLASS (gtk_menu_parent_class)->draw (widget, cr);
- GTK_WIDGET_CLASS (gtk_menu_parent_class)->expose_event (widget, event);
- }
-
return FALSE;
}
}
-
static void
-gtk_menu_size_request_init (GtkSizeRequestIface *iface)
-{
- iface->get_width = gtk_menu_get_width;
- iface->get_height = gtk_menu_get_height;
- iface->get_height_for_width = gtk_menu_get_height_for_width;
-}
-
-static void
-gtk_menu_get_width (GtkSizeRequest *widget,
- gint *minimum_size,
- gint *natural_size)
+gtk_menu_get_preferred_width (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkMenu *menu;
GtkMenuShell *menu_shell;
GtkMenuPrivate *priv;
+ GtkStyle *style;
GtkWidget *child;
GList *children;
guint max_toggle_size;
menu = GTK_MENU (widget);
menu_shell = GTK_MENU_SHELL (widget);
priv = gtk_menu_get_private (menu);
-
+
+ style = gtk_widget_get_style (GTK_WIDGET (widget));
+
min_width = nat_width = 0;
max_toggle_size = 0;
*/
GTK_MENU_ITEM (child)->show_submenu_indicator = TRUE;
- gtk_size_request_get_width (GTK_SIZE_REQUEST (child), &child_min, &child_nat);
+ gtk_widget_get_preferred_width (child, &child_min, &child_nat);
gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child), &toggle_size);
max_toggle_size = MAX (max_toggle_size, toggle_size);
guint toggle_spacing;
guint indicator_size;
- gtk_style_get (GTK_WIDGET (widget)->style,
+ gtk_style_get (style,
GTK_TYPE_CHECK_MENU_ITEM,
"toggle-spacing", &toggle_spacing,
"indicator-size", &indicator_size,
NULL);
border_width = gtk_container_get_border_width (GTK_CONTAINER (menu));
- min_width += (border_width + horizontal_padding + GTK_WIDGET (widget)->style->xthickness) * 2;
- nat_width += (border_width + horizontal_padding + GTK_WIDGET (widget)->style->xthickness) * 2;
+ min_width += (border_width + horizontal_padding + style->xthickness) * 2;
+ nat_width += (border_width + horizontal_padding + style->xthickness) * 2;
menu->toggle_size = max_toggle_size;
priv->accel_size = max_accel_width;
}
static void
-gtk_menu_get_height (GtkSizeRequest *widget,
- gint *minimum_size,
- gint *natural_size)
+gtk_menu_get_preferred_height (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
{
gint min_width;
/* Menus are height-for-width only, just return the height for the minimum width */
- gtk_size_request_get_width (widget, &min_width, NULL);
- gtk_size_request_get_height_for_width (widget, min_width, minimum_size, natural_size);
+ GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);
+ GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, minimum_size, natural_size);
}
static void
-gtk_menu_get_height_for_width (GtkSizeRequest *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+gtk_menu_get_preferred_height_for_width (GtkWidget *widget,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkMenu *menu = GTK_MENU (widget);
GtkMenuPrivate *private = gtk_menu_get_private (menu);
gtk_widget_style_get (GTK_WIDGET (menu), "vertical-padding", &vertical_padding, NULL);
border_width = gtk_container_get_border_width (GTK_CONTAINER (menu));
- min_height = nat_height = (border_width + vertical_padding + GTK_WIDGET (widget)->style->ythickness) * 2;
+ min_height = nat_height = (border_width + vertical_padding + gtk_widget_get_style (GTK_WIDGET (widget))->ythickness) * 2;
n_heights =
calculate_line_heights (menu, for_size, &min_heights, &nat_heights);
gdouble x_root,
gdouble y_root)
{
+ GtkAllocation allocation;
GtkMenu *menu = GTK_MENU (widget);
if (gtk_widget_get_mapped (menu->toplevel))
GtkMenuShell *menu_shell;
gint window_x, window_y;
- gdk_window_get_position (menu->toplevel->window, &window_x, &window_y);
+ gdk_window_get_position (gtk_widget_get_window (menu->toplevel),
+ &window_x, &window_y);
- if (x_root >= window_x && x_root < window_x + widget->allocation.width &&
- y_root >= window_y && y_root < window_y + widget->allocation.height)
+ gtk_widget_get_allocation (widget, &allocation);
+ if (x_root >= window_x && x_root < window_x + allocation.width &&
+ y_root >= window_y && y_root < window_y + allocation.height)
return TRUE;
menu_shell = GTK_MENU_SHELL (widget);
switch (event->keyval)
{
- case GDK_Delete:
- case GDK_KP_Delete:
- case GDK_BackSpace:
+ case GDK_KEY_Delete:
+ case GDK_KEY_KP_Delete:
+ case GDK_KEY_BackSpace:
delete = TRUE;
break;
default:
GdkWindow *window = GTK_MENU_ITEM (widget)->event_window;
int w, h;
- gdk_drawable_get_size (window, &w, &h);
+ w = gdk_window_get_width (window);
+ h = gdk_window_get_height (window);
return
check_threshold (widget, 0, 0, x, y) &&
GtkWidget *menu_item;
GtkMenu *menu;
GtkMenuShell *menu_shell;
+ GtkWidget *parent;
gboolean need_enter;
* which may be different from 'widget'.
*/
menu_item = gtk_get_event_widget ((GdkEvent*) event);
+ parent = gtk_widget_get_parent (menu_item);
if (!GTK_IS_MENU_ITEM (menu_item) ||
- !GTK_IS_MENU (menu_item->parent))
+ !GTK_IS_MENU (parent))
return FALSE;
- menu_shell = GTK_MENU_SHELL (menu_item->parent);
+ menu_shell = GTK_MENU_SHELL (parent);
menu = GTK_MENU (menu_shell);
if (definitely_within_item (menu_item, event->x, event->y))
/* The menu is now sensitive to enter events on its items, but
* was previously sensitive. So we fake an enter event.
*/
- gint width, height;
-
menu_shell->ignore_enter = FALSE;
- gdk_drawable_get_size (event->window, &width, &height);
- if (event->x >= 0 && event->x < width &&
- event->y >= 0 && event->y < height)
+ if (event->x >= 0 && event->x < gdk_window_get_width (event->window) &&
+ event->y >= 0 && event->y < gdk_window_get_height (event->window))
{
GdkEvent *send_event = gdk_event_new (GDK_ENTER_NOTIFY);
gboolean result;
gtk_menu_scroll_by (GtkMenu *menu,
gint step)
{
+ GtkMenuPrivate *priv;
+ GtkBorder arrow_border;
GtkWidget *widget;
gint offset;
- gint view_width, view_height;
+ gint view_height;
gboolean double_arrows;
- GtkBorder arrow_border;
- GtkMenuPrivate *priv;
-
+
widget = GTK_WIDGET (menu);
offset = menu->scroll_offset + step;
priv = gtk_menu_get_private (menu);
if ((menu->scroll_offset >= 0) && (offset < 0))
offset = 0;
- gdk_drawable_get_size (widget->window, &view_width, &view_height);
+ view_height = gdk_window_get_height (gtk_widget_get_window (widget));
if (menu->scroll_offset == 0 &&
view_height >= priv->requested_height)
GdkRectangle *upper,
GdkRectangle *lower)
{
+ GtkArrowPlacement arrow_placement;
+ GtkWidget *widget = GTK_WIDGET (menu);
+ GdkWindow *window;
gint width, height;
guint border;
guint vertical_padding;
gint win_x, win_y;
gint scroll_arrow_height;
- GtkArrowPlacement arrow_placement;
- gdk_drawable_get_size (GTK_WIDGET (menu)->window, &width, &height);
+ window = gtk_widget_get_window (widget);
+ width = gdk_window_get_width (window);
+ height = gdk_window_get_height (window);
- gtk_widget_style_get (GTK_WIDGET (menu),
+ gtk_widget_style_get (widget,
"vertical-padding", &vertical_padding,
"scroll-arrow-vlength", &scroll_arrow_height,
"arrow-placement", &arrow_placement,
NULL);
border = gtk_container_get_border_width (GTK_CONTAINER (menu)) +
- GTK_WIDGET (menu)->style->ythickness + vertical_padding;
+ gtk_widget_get_style (widget)->ythickness + vertical_padding;
- gdk_window_get_position (GTK_WIDGET (menu)->window, &win_x, &win_y);
+ gdk_window_get_position (window, &win_x, &win_y);
switch (arrow_placement)
{
"gtk-touchscreen-mode", &touchscreen_mode,
NULL);
- gdk_window_get_position (menu->toplevel->window, &top_x, &top_y);
+ gdk_window_get_position (gtk_widget_get_window (menu->toplevel),
+ &top_x, &top_y);
x -= top_x;
y -= top_y;
{
priv->upper_arrow_state = arrow_state;
- gdk_window_invalidate_rect (GTK_WIDGET (menu)->window,
+ gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (menu)),
&rect, FALSE);
}
}
{
priv->lower_arrow_state = arrow_state;
- gdk_window_invalidate_rect (GTK_WIDGET (menu)->window,
+ gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (menu)),
&rect, FALSE);
}
}
GdkEventCrossing *event)
{
GtkWidget *menu_item;
+ GtkWidget *parent;
gboolean touchscreen_mode;
if (event->mode == GDK_CROSSING_GTK_GRAB ||
if (!touchscreen_mode && GTK_IS_MENU_ITEM (menu_item))
{
- GtkWidget *menu = menu_item->parent;
+ GtkWidget *menu = gtk_widget_get_parent (menu_item);
if (GTK_IS_MENU (menu))
{
* will not correspond to the event widget's parent. Check to see
* if we are in the parent's navigation region.
*/
- if (GTK_IS_MENU_ITEM (menu_item) && GTK_IS_MENU (menu_item->parent) &&
- gtk_menu_navigating_submenu (GTK_MENU (menu_item->parent),
+ parent = gtk_widget_get_parent (menu_item);
+ if (GTK_IS_MENU_ITEM (menu_item) && GTK_IS_MENU (parent) &&
+ gtk_menu_navigating_submenu (GTK_MENU (parent),
event->x_root, event->y_root))
return TRUE;
GtkWidget *event_widget;
GtkMenuPopdownData *popdown_data;
GtkMenuPrivate *priv;
+ GdkWindow *window;
g_return_if_fail (menu_item->submenu != NULL);
g_return_if_fail (event != NULL);
priv = gtk_menu_get_private (menu);
event_widget = gtk_get_event_widget ((GdkEvent*) event);
-
- gdk_window_get_origin (menu_item->submenu->window, &submenu_left, &submenu_top);
- gdk_drawable_get_size (menu_item->submenu->window, &width, &height);
-
- submenu_right = submenu_left + width;
- submenu_bottom = submenu_top + height;
-
- gdk_drawable_get_size (event_widget->window, &width, &height);
-
+
+ window = gtk_widget_get_window (menu_item->submenu);
+ gdk_window_get_origin (window, &submenu_left, &submenu_top);
+
+ submenu_right = submenu_left + gdk_window_get_width (window);
+ submenu_bottom = submenu_top + gdk_window_get_height (window);
+
+ width = gdk_window_get_width (gtk_widget_get_window (event_widget));
+ height = gdk_window_get_height (gtk_widget_get_window (event_widget));
+
if (event->x >= 0 && event->x < width)
{
gint popdown_delay;
/* Get the minimum height for minimum width to figure out
* the right place to popup the menu.
*/
- gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL);
+ gtk_widget_get_preferred_size (widget, &requisition, NULL);
if (pointer_screen != screen)
{
}
else
{
+ GtkStyle *style = gtk_widget_get_style (widget);
gint space_left, space_right, space_above, space_below;
gint needed_width;
gint needed_height;
- gint xthickness = widget->style->xthickness;
- gint ythickness = widget->style->ythickness;
+ gint xthickness = style->xthickness;
+ gint ythickness = style->ythickness;
gboolean rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
/* The placement of popup menus horizontally works like this (with
gtk_menu_scroll_to (GtkMenu *menu,
gint offset)
{
+ GtkMenuPrivate *priv;
+ GtkAllocation allocation;
+ GtkBorder arrow_border;
+ GtkStyle *style;
GtkWidget *widget;
gint x, y;
gint view_width, view_height;
guint vertical_padding;
guint horizontal_padding;
gboolean double_arrows;
- GtkBorder arrow_border;
- GtkMenuPrivate *priv;
-
+
widget = GTK_WIDGET (menu);
priv = gtk_menu_get_private (menu);
}
/* Move/resize the viewport according to arrows: */
- view_width = widget->allocation.width;
- view_height = widget->allocation.height;
+ gtk_widget_get_allocation (widget, &allocation);
+ view_width = allocation.width;
+ view_height = allocation.height;
+
+ style = gtk_widget_get_style (widget);
gtk_widget_style_get (GTK_WIDGET (menu),
"vertical-padding", &vertical_padding,
double_arrows = get_double_arrows (menu);
border_width = gtk_container_get_border_width (GTK_CONTAINER (menu));
- view_width -= (border_width + widget->style->xthickness + horizontal_padding) * 2;
- view_height -= (border_width + widget->style->ythickness + vertical_padding) * 2;
- menu_height = priv->requested_height -
- (border_width + widget->style->ythickness + vertical_padding) * 2;
- x = border_width + widget->style->xthickness + horizontal_padding;
- y = border_width + widget->style->ythickness + vertical_padding;
+ view_width -= (border_width + style->xthickness + horizontal_padding) * 2;
+ view_height -= (border_width + style->ythickness + vertical_padding) * 2;
+ menu_height = priv->requested_height - (border_width + style->ythickness + vertical_padding) * 2;
+
+ x = border_width + style->xthickness + horizontal_padding;
+ y = border_width + style->ythickness + vertical_padding;
if (double_arrows && !menu->tearoff_active)
{
gtk_menu_scroll_item_visible (GtkMenuShell *menu_shell,
GtkWidget *menu_item)
{
- GtkMenu *menu;
+ GtkMenu *menu = GTK_MENU (menu_shell);
+ GtkWidget *widget = GTK_WIDGET (menu_shell);
gint child_offset, child_height;
gint width, height;
gint y;
gint arrow_height;
gboolean last_child = 0;
-
- menu = GTK_MENU (menu_shell);
/* We need to check if the selected item fully visible.
* If not we need to scroll the menu so that it becomes fully
gboolean double_arrows;
y = menu->scroll_offset;
- gdk_drawable_get_size (GTK_WIDGET (menu)->window, &width, &height);
+ width = gdk_window_get_width (gtk_widget_get_window (widget));
+ height = gdk_window_get_height (gtk_widget_get_window (widget));
- gtk_widget_style_get (GTK_WIDGET (menu),
+ gtk_widget_style_get (widget,
"vertical-padding", &vertical_padding,
NULL);
double_arrows = get_double_arrows (menu);
- height -= 2*gtk_container_get_border_width (GTK_CONTAINER (menu)) + 2*GTK_WIDGET (menu)->style->ythickness + 2*vertical_padding;
-
+ height -= 2 * gtk_container_get_border_width (GTK_CONTAINER (menu)) +
+ 2 * gtk_widget_get_style (widget)->ythickness +
+ 2 * vertical_padding;
if (child_offset < y)
{
/* Ignore the enter event we might get if the pointer is on the menu
GtkWidget *new_parent,
gboolean unrealize)
{
- GtkObject *object = GTK_OBJECT (menu);
+ GObject *object = G_OBJECT (menu);
GtkWidget *widget = GTK_WIDGET (menu);
gboolean was_floating = g_object_is_floating (object);
if (unrealize)
{
g_object_ref (object);
- gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
+ gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (widget)), widget);
gtk_container_add (GTK_CONTAINER (new_parent), widget);
g_object_unref (object);
}
else
- gtk_widget_reparent (GTK_WIDGET (menu), new_parent);
-
+ gtk_widget_reparent (widget, new_parent);
+
if (was_floating)
- g_object_force_floating (G_OBJECT (object));
+ g_object_force_floating (object);
else
g_object_unref (object);
}
gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
}
-
-static void
-gtk_menu_hide_all (GtkWidget *widget)
-{
- /* Hide children, but not self. */
- gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
-}
-
/**
* gtk_menu_set_screen:
* @menu: a #GtkMenu.
guint bottom_attach)
{
GtkMenuShell *menu_shell;
-
+ GtkWidget *parent;
+
g_return_if_fail (GTK_IS_MENU (menu));
g_return_if_fail (GTK_IS_MENU_ITEM (child));
- g_return_if_fail (child->parent == NULL ||
- child->parent == GTK_WIDGET (menu));
+ parent = gtk_widget_get_parent (child);
+ g_return_if_fail (parent == NULL || parent == GTK_WIDGET (menu));
g_return_if_fail (left_attach < right_attach);
g_return_if_fail (top_attach < bottom_attach);
menu_shell = GTK_MENU_SHELL (menu);
-
- if (!child->parent)
+
+ if (!parent)
{
AttachInfo *ai = get_attach_info (child);
}
else
{
- gtk_container_child_set (GTK_CONTAINER (child->parent), child,
+ gtk_container_child_set (GTK_CONTAINER (parent), child,
"left-attach", left_attach,
"right-attach", right_attach,
"top-attach", top_attach,
static gint
get_visible_size (GtkMenu *menu)
{
+ GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (menu);
GtkContainer *container = GTK_CONTAINER (menu);
-
- gint menu_height = (widget->allocation.height
- - 2 * (gtk_container_get_border_width (container)
- + widget->style->ythickness));
+ gint menu_height;
+
+ gtk_widget_get_allocation (widget, &allocation);
+ menu_height = (allocation.height
+ - 2 * (gtk_container_get_border_width (container)
+ + gtk_widget_get_style (widget)->ythickness));
if (!menu->tearoff_active)
{
{
GtkRequisition child_requisition;
- gtk_widget_size_request (children->data, &child_requisition);
+ gtk_widget_get_preferred_size (children->data,
+ &child_requisition, NULL);
if (_gtk_menu_item_is_selectable (children->data) &&
child_offset >= lower &&
static gint
get_menu_height (GtkMenu *menu)
{
- gint height;
- GtkWidget *widget = GTK_WIDGET (menu);
GtkAllocation allocation;
+ GtkWidget *widget = GTK_WIDGET (menu);
+ gint height;
gtk_widget_get_allocation (widget, &allocation);
height = allocation.height;
- height -= gtk_container_get_border_width (GTK_CONTAINER (widget) + widget->style->ythickness) * 2;
+ height -= (gtk_container_get_border_width (GTK_CONTAINER (widget)) + gtk_widget_get_style (widget)->ythickness) * 2;
if (!menu->tearoff_active)
{
projects / ~andy / gtk / blobdiff