* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#define GTK_MENU_INTERNALS
-#include <config.h>
-#include <string.h> /* memset */
+#include "config.h"
+#include <string.h>
#include "gdk/gdkkeysyms.h"
#include "gtkaccellabel.h"
#include "gtkaccelmap.h"
#include "gtkbindings.h"
-#include "gtklabel.h"
+#include "gtkcheckmenuitem.h"
+#include <gobject/gvaluecollector.h>
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtkmenu.h"
-#include "gtkmenuitem.h"
#include "gtktearoffmenuitem.h"
#include "gtkwindow.h"
#include "gtkhbox.h"
#include "gtkalias.h"
-#define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_GET_CLASS (w)
-
-#define DEFAULT_POPUP_DELAY 225
+#define DEFAULT_POPUP_DELAY 225
#define DEFAULT_POPDOWN_DELAY 1000
#define NAVIGATION_REGION_OVERSHOOT 50 /* How much the navigation region
* extends below the submenu
*/
-#define MENU_SCROLL_STEP1 8
-#define MENU_SCROLL_STEP2 15
-#define MENU_SCROLL_FAST_ZONE 8
-#define MENU_SCROLL_TIMEOUT1 50
-#define MENU_SCROLL_TIMEOUT2 20
+#define MENU_SCROLL_STEP1 8
+#define MENU_SCROLL_STEP2 15
+#define MENU_SCROLL_FAST_ZONE 8
+#define MENU_SCROLL_TIMEOUT1 50
+#define MENU_SCROLL_TIMEOUT2 20
#define ATTACH_INFO_KEY "gtk-menu-child-attach-info-key"
#define ATTACHED_MENUS "gtk-attached-menus"
struct _GtkMenuPrivate
{
- gboolean seen_item_enter;
-
- gboolean have_position;
gint x;
gint y;
+ gboolean initially_pushed_in;
/* info used for the table */
guint *heights;
gint monitor_num;
/* Cached layout information */
- gboolean have_layout;
gint n_rows;
gint n_columns;
GtkStateType lower_arrow_state;
GtkStateType upper_arrow_state;
- gboolean ignore_button_release;
- gboolean initially_pushed_in;
+ guint have_layout : 1;
+ guint seen_item_enter : 1;
+ guint have_position : 1;
+ guint ignore_button_release : 1;
+ guint no_toggle_size : 1;
};
typedef struct
enum {
PROP_0,
+ PROP_ACTIVE,
+ PROP_ACCEL_GROUP,
+ PROP_ACCEL_PATH,
+ PROP_ATTACH_WIDGET,
PROP_TEAROFF_STATE,
- PROP_TEAROFF_TITLE
+ PROP_TEAROFF_TITLE,
+ PROP_MONITOR,
+ PROP_RESERVE_TOGGLE_SIZE
};
enum {
static void _gtk_menu_refresh_accel_paths (GtkMenu *menu,
gboolean group_changed);
-static const gchar attach_data_key[] = "gtk-menu-attach-data";
+static const gchar attach_data_key[] = "gtk-menu-attach-data";
static guint menu_signals[LAST_SIGNAL] = { 0 };
menu_shell_class->move_current = gtk_menu_move_current;
menu_signals[MOVE_SCROLL] =
- _gtk_binding_signal_new (I_("move_scroll"),
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- G_CALLBACK (gtk_menu_real_move_scroll),
- NULL, NULL,
- _gtk_marshal_VOID__ENUM,
- G_TYPE_NONE, 1,
- GTK_TYPE_SCROLL_TYPE);
-
+ g_signal_new_class_handler (I_("move-scroll"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_CALLBACK (gtk_menu_real_move_scroll),
+ NULL, NULL,
+ _gtk_marshal_VOID__ENUM,
+ G_TYPE_NONE, 1,
+ GTK_TYPE_SCROLL_TYPE);
+
+ /**
+ * GtkMenu:active:
+ *
+ * The index of the currently selected menu item, or -1 if no
+ * menu item is selected.
+ *
+ * Since: 2.14
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_ACTIVE,
+ g_param_spec_int ("active",
+ P_("Active"),
+ P_("The currently selected menu item"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkMenu:accel-group:
+ *
+ * The accel group holding accelerators for the menu.
+ *
+ * Since: 2.14
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_ACCEL_GROUP,
+ g_param_spec_object ("accel-group",
+ P_("Accel Group"),
+ P_("The accel group holding accelerators for the menu"),
+ GTK_TYPE_ACCEL_GROUP,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkMenu:accel-path:
+ *
+ * An accel path used to conveniently construct accel paths of child items.
+ *
+ * Since: 2.14
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_ACCEL_PATH,
+ g_param_spec_string ("accel-path",
+ P_("Accel Path"),
+ P_("An accel path used to conveniently construct accel paths of child items"),
+ NULL,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkMenu:attach-widget:
+ *
+ * The widget the menu is attached to. Setting this property attaches
+ * the menu without a #GtkMenuDetachFunc. If you need to use a detacher,
+ * use gtk_menu_attach_to_widget() directly.
+ *
+ * Since: 2.14
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_ATTACH_WIDGET,
+ g_param_spec_object ("attach-widget",
+ P_("Attach Widget"),
+ P_("The widget the menu is attached to"),
+ GTK_TYPE_WIDGET,
+ GTK_PARAM_READWRITE));
+
g_object_class_install_property (gobject_class,
PROP_TEAROFF_TITLE,
g_param_spec_string ("tearoff-title",
FALSE,
GTK_PARAM_READWRITE));
+ /**
+ * GtkMenu:monitor:
+ *
+ * The monitor the menu will be popped up on.
+ *
+ * Since: 2.14
+ **/
+ g_object_class_install_property (gobject_class,
+ PROP_MONITOR,
+ g_param_spec_int ("monitor",
+ P_("Monitor"),
+ P_("The monitor the menu will be popped up on"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
+
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("vertical-padding",
P_("Vertical Padding"),
1,
GTK_PARAM_READABLE));
+ /**
+ * GtkMenu:reserve-toggle-size:
+ *
+ * A boolean that indicates whether the menu reserves space for
+ * toggles and icons, regardless of their actual presence.
+ *
+ * This property should only be changed from its default value
+ * for special-purposes such as tabular menus. Regular menus that
+ * are connected to a menu bar or context menus should reserve
+ * toggle space for consistency.
+ *
+ * Since: 2.18
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_RESERVE_TOGGLE_SIZE,
+ g_param_spec_boolean ("reserve-toggle-size",
+ P_("Reserve Toggle Size"),
+ P_("A boolean that indicates whether the menu reserves space for toggles and icons"),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("horizontal-padding",
P_("Horizontal Padding"),
TRUE,
GTK_PARAM_READABLE));
+ /**
+ * GtkMenu:arrow-placement:
+ *
+ * Indicates where scroll arrows should be placed.
+ *
+ * Since: 2.16
+ **/
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_enum ("arrow-placement",
+ P_("Arrow Placement"),
+ P_("Indicates where scroll arrows should be placed"),
+ GTK_TYPE_ARROW_PLACEMENT,
+ GTK_ARROWS_BOTH,
+ GTK_PARAM_READABLE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_LEFT_ATTACH,
-1, INT_MAX, -1,
GTK_PARAM_READWRITE));
+ /**
+ * GtkMenu::arrow-scaling
+ *
+ * Arbitrary constant to scale down the size of the scroll arrow.
+ *
+ * Since: 2.16
+ */
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_float ("arrow-scaling",
+ P_("Arrow Scaling"),
+ P_("Arbitrary constant to scale down the size of the scroll arrow"),
+ 0.0, 1.0, 0.7,
+ GTK_PARAM_READABLE));
+
binding_set = gtk_binding_set_by_class (class);
gtk_binding_entry_add_signal (binding_set,
GDK_Up, 0,
- I_("move_current"), 1,
+ I_("move-current"), 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PREV);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_Up, 0,
- "move_current", 1,
+ "move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PREV);
gtk_binding_entry_add_signal (binding_set,
GDK_Down, 0,
- "move_current", 1,
+ "move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_NEXT);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_Down, 0,
- "move_current", 1,
+ "move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_NEXT);
gtk_binding_entry_add_signal (binding_set,
GDK_Left, 0,
- "move_current", 1,
+ "move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PARENT);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_Left, 0,
- "move_current", 1,
+ "move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PARENT);
gtk_binding_entry_add_signal (binding_set,
GDK_Right, 0,
- "move_current", 1,
+ "move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_CHILD);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_Right, 0,
- "move_current", 1,
+ "move-current", 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_CHILD);
gtk_binding_entry_add_signal (binding_set,
GDK_Home, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_START);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_Home, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_START);
gtk_binding_entry_add_signal (binding_set,
GDK_End, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_END);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_End, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_END);
gtk_binding_entry_add_signal (binding_set,
GDK_Page_Up, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_UP);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_Page_Up, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_UP);
gtk_binding_entry_add_signal (binding_set,
GDK_Page_Down, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_DOWN);
gtk_binding_entry_add_signal (binding_set,
GDK_KP_Page_Down, 0,
- "move_scroll", 1,
+ "move-scroll", 1,
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_DOWN);
}
-static void
+static void
gtk_menu_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
- GtkMenu *menu;
-
- menu = GTK_MENU (object);
-
+ GtkMenu *menu = GTK_MENU (object);
+
switch (prop_id)
{
+ case PROP_ACTIVE:
+ gtk_menu_set_active (menu, g_value_get_int (value));
+ break;
+ case PROP_ACCEL_GROUP:
+ gtk_menu_set_accel_group (menu, g_value_get_object (value));
+ break;
+ case PROP_ACCEL_PATH:
+ gtk_menu_set_accel_path (menu, g_value_get_string (value));
+ break;
+ case PROP_ATTACH_WIDGET:
+ {
+ GtkWidget *widget;
+
+ widget = gtk_menu_get_attach_widget (menu);
+ if (widget)
+ gtk_menu_detach (menu);
+
+ widget = (GtkWidget*) g_value_get_object (value);
+ if (widget)
+ gtk_menu_attach_to_widget (menu, widget, NULL);
+ }
+ break;
case PROP_TEAROFF_STATE:
gtk_menu_set_tearoff_state (menu, g_value_get_boolean (value));
break;
case PROP_TEAROFF_TITLE:
gtk_menu_set_title (menu, g_value_get_string (value));
- break;
+ break;
+ case PROP_MONITOR:
+ gtk_menu_set_monitor (menu, g_value_get_int (value));
+ break;
+ case PROP_RESERVE_TOGGLE_SIZE:
+ gtk_menu_set_reserve_toggle_size (menu, g_value_get_boolean (value));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
-static void
+static void
gtk_menu_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
- GtkMenu *menu;
-
- menu = GTK_MENU (object);
-
+ GtkMenu *menu = GTK_MENU (object);
+
switch (prop_id)
{
+ case PROP_ACTIVE:
+ g_value_set_int (value, g_list_index (GTK_MENU_SHELL (menu)->children, gtk_menu_get_active (menu)));
+ break;
+ case PROP_ACCEL_GROUP:
+ g_value_set_object (value, gtk_menu_get_accel_group (menu));
+ break;
+ case PROP_ACCEL_PATH:
+ g_value_set_string (value, gtk_menu_get_accel_path (menu));
+ break;
+ case PROP_ATTACH_WIDGET:
+ g_value_set_object (value, gtk_menu_get_attach_widget (menu));
+ break;
case PROP_TEAROFF_STATE:
g_value_set_boolean (value, gtk_menu_get_tearoff_state (menu));
break;
case PROP_TEAROFF_TITLE:
g_value_set_string (value, gtk_menu_get_title (menu));
break;
+ case PROP_MONITOR:
+ g_value_set_int (value, gtk_menu_get_monitor (menu));
+ break;
+ case PROP_RESERVE_TOGGLE_SIZE:
+ g_value_set_boolean (value, gtk_menu_get_reserve_toggle_size (menu));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
"child", menu,
NULL),
"signal::event", gtk_menu_window_event, menu,
- "signal::size_request", gtk_menu_window_size_request, menu,
+ "signal::size-request", gtk_menu_window_size_request, menu,
"signal::destroy", gtk_widget_destroyed, &menu->toplevel,
NULL);
gtk_window_set_resizable (GTK_WINDOW (menu->toplevel), FALSE);
priv->lower_arrow_state = GTK_STATE_NORMAL;
priv->have_layout = FALSE;
+ priv->monitor_num = -1;
}
static void
data = g_slice_new (GtkMenuAttachData);
data->attach_widget = attach_widget;
- g_signal_connect (attach_widget, "screen_changed",
+ g_signal_connect (attach_widget, "screen-changed",
G_CALLBACK (attach_widget_screen_changed), menu);
attach_widget_screen_changed (attach_widget, NULL, menu);
if (xgrab_shell == widget)
popup_grab_on_window (widget->window, activate_time, grab_keyboard); /* Should always succeed */
gtk_grab_add (GTK_WIDGET (menu));
+
+ if (parent_menu_shell)
+ {
+ gboolean keyboard_mode;
+
+ keyboard_mode = _gtk_menu_shell_get_keyboard_mode (GTK_MENU_SHELL (parent_menu_shell));
+ _gtk_menu_shell_set_keyboard_mode (menu_shell, keyboard_mode);
+ }
+ else if (menu_shell->button == 0) /* a keynav-activated context menu */
+ _gtk_menu_shell_set_keyboard_mode (menu_shell, TRUE);
+
+ _gtk_menu_shell_update_mnemonics (menu_shell);
}
void
}
}
+
+/**
+ * gtk_menu_set_accel_group:
+ * @accel_group: (allow-none):
+ */
void
gtk_menu_set_accel_group (GtkMenu *menu,
GtkAccelGroup *accel_group)
/**
* gtk_menu_set_accel_path
* @menu: a valid #GtkMenu
- * @accel_path: a valid accelerator path
+ * @accel_path: (allow-none): a valid accelerator path
*
* Sets an accelerator path for this menu from which accelerator paths
* for its immediate children, its menu items, can be constructed.
_gtk_menu_refresh_accel_paths (menu, FALSE);
}
+/**
+ * gtk_menu_get_accel_path
+ * @menu: a valid #GtkMenu
+ *
+ * Retrieves the accelerator path set on the menu.
+ *
+ * Returns: the accelerator path set on the menu.
+ *
+ * Since: 2.14
+ */
+const gchar*
+gtk_menu_get_accel_path (GtkMenu *menu)
+{
+ g_return_val_if_fail (GTK_IS_MENU (menu), NULL);
+
+ return menu->accel_path;
+}
+
typedef struct {
GtkMenu *menu;
gboolean group_changed;
}
static void
-_gtk_menu_refresh_accel_paths (GtkMenu *menu,
- gboolean group_changed)
+_gtk_menu_refresh_accel_paths (GtkMenu *menu,
+ gboolean group_changed)
{
g_return_if_fail (GTK_IS_MENU (menu));
-
+
if (menu->accel_path && menu->accel_group)
{
AccelPropagation prop;
else if (GTK_IS_WIDGET (attach))
{
toplevel = gtk_widget_get_toplevel (attach);
- if (GTK_WIDGET_TOPLEVEL (toplevel))
+ if (gtk_widget_is_toplevel (toplevel))
return toplevel;
}
height/2,
height));
g_object_connect (menu->tearoff_adjustment,
- "signal::value_changed", gtk_menu_scrollbar_changed, menu,
+ "signal::value-changed", gtk_menu_scrollbar_changed, menu,
NULL);
menu->tearoff_scrollbar = gtk_vscrollbar_new (menu->tearoff_adjustment);
}
static void
-get_arrows_border (GtkMenu *menu, GtkBorder *border)
+get_arrows_border (GtkMenu *menu,
+ GtkBorder *border)
{
guint scroll_arrow_height;
+ GtkArrowPlacement arrow_placement;
gtk_widget_style_get (GTK_WIDGET (menu),
"scroll-arrow-vlength", &scroll_arrow_height,
+ "arrow_placement", &arrow_placement,
NULL);
- border->top = menu->upper_arrow_visible ? scroll_arrow_height : 0;
- border->bottom = menu->lower_arrow_visible ? scroll_arrow_height : 0;
+ switch (arrow_placement)
+ {
+ case GTK_ARROWS_BOTH:
+ border->top = menu->upper_arrow_visible ? scroll_arrow_height : 0;
+ border->bottom = menu->lower_arrow_visible ? scroll_arrow_height : 0;
+ break;
+
+ case GTK_ARROWS_START:
+ border->top = (menu->upper_arrow_visible ||
+ menu->lower_arrow_visible) ? scroll_arrow_height : 0;
+ border->bottom = 0;
+ break;
+
+ case GTK_ARROWS_END:
+ border->top = 0;
+ border->bottom = (menu->upper_arrow_visible ||
+ menu->lower_arrow_visible) ? scroll_arrow_height : 0;
+ break;
+ }
border->left = border->right = 0;
}
gdk_window_destroy (menu->bin_window);
menu->bin_window = NULL;
- (* GTK_WIDGET_CLASS (gtk_menu_parent_class)->unrealize) (widget);
+ GTK_WIDGET_CLASS (gtk_menu_parent_class)->unrealize (widget);
}
static void
priv->heights[t] = MAX (priv->heights[t], part);
}
+ /* If the menu doesn't include any images or check items
+ * reserve the space so that all menus are consistent.
+ * We only do this for 'ordinary' menus, not for combobox
+ * menus or multi-column menus
+ */
+ if (max_toggle_size == 0 &&
+ gtk_menu_get_n_columns (menu) == 1 &&
+ !priv->no_toggle_size)
+ {
+ guint toggle_spacing;
+ guint indicator_size;
+
+ gtk_style_get (widget->style,
+ GTK_TYPE_CHECK_MENU_ITEM,
+ "toggle-spacing", &toggle_spacing,
+ "indicator-size", &indicator_size,
+ NULL);
+
+ max_toggle_size = indicator_size + toggle_spacing;
+ }
+
for (i = 0; i < gtk_menu_get_n_rows (menu); i++)
requisition->height += priv->heights[i];
- requisition->width += max_toggle_size + max_accel_width;
+ requisition->width += 2 * max_toggle_size + max_accel_width;
requisition->width *= gtk_menu_get_n_columns (menu);
gtk_widget_style_get (GTK_WIDGET (menu),
}
static void
-get_arrows_visible_area (GtkMenu *menu,
+get_arrows_visible_area (GtkMenu *menu,
GdkRectangle *border,
GdkRectangle *upper,
GdkRectangle *lower,
- gint *arrow_space)
+ gint *arrow_space)
{
GtkWidget *widget = GTK_WIDGET (menu);
guint vertical_padding;
guint horizontal_padding;
gint scroll_arrow_height;
-
+ GtkArrowPlacement arrow_placement;
+
gtk_widget_style_get (widget,
"vertical-padding", &vertical_padding,
"horizontal-padding", &horizontal_padding,
"scroll-arrow-vlength", &scroll_arrow_height,
+ "arrow-placement", &arrow_placement,
NULL);
border->x = GTK_CONTAINER (widget)->border_width + widget->style->xthickness + horizontal_padding;
border->y = GTK_CONTAINER (widget)->border_width + widget->style->ythickness + vertical_padding;
gdk_drawable_get_size (widget->window, &border->width, &border->height);
- upper->x = border->x;
- upper->y = border->y;
- upper->width = border->width - 2 * border->x;
- upper->height = scroll_arrow_height;
+ switch (arrow_placement)
+ {
+ case GTK_ARROWS_BOTH:
+ upper->x = border->x;
+ upper->y = border->y;
+ upper->width = border->width - 2 * border->x;
+ upper->height = scroll_arrow_height;
+
+ lower->x = border->x;
+ lower->y = border->height - border->y - scroll_arrow_height;
+ lower->width = border->width - 2 * border->x;
+ lower->height = scroll_arrow_height;
+ break;
+
+ case GTK_ARROWS_START:
+ upper->x = border->x;
+ upper->y = border->y;
+ upper->width = (border->width - 2 * border->x) / 2;
+ upper->height = scroll_arrow_height;
- lower->x = border->x;
- lower->y = border->height - border->y - scroll_arrow_height;
- lower->width = border->width - 2 * border->x;
- lower->height = scroll_arrow_height;
+ lower->x = border->x + upper->width;
+ lower->y = border->y;
+ lower->width = (border->width - 2 * border->x) / 2;
+ lower->height = scroll_arrow_height;
+ break;
+
+ case GTK_ARROWS_END:
+ upper->x = border->x;
+ upper->y = border->height - border->y - scroll_arrow_height;
+ upper->width = (border->width - 2 * border->x) / 2;
+ upper->height = scroll_arrow_height;
+
+ lower->x = border->x + upper->width;
+ lower->y = border->height - border->y - scroll_arrow_height;
+ lower->width = (border->width - 2 * border->x) / 2;
+ lower->height = scroll_arrow_height;
+ break;
+
+ default:
+ g_assert_not_reached();
+ upper->x = upper->y = upper->width = upper->height = 0;
+ lower->x = lower->y = lower->width = lower->height = 0;
+ }
*arrow_space = scroll_arrow_height - 2 * widget->style->ythickness;
}
if (event->window == widget->window)
{
- gint arrow_size = 0.7 * arrow_space;
+ 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,
if (GTK_WIDGET_DRAWABLE (widget))
{
gtk_menu_paint (widget, event);
-
- (* GTK_WIDGET_CLASS (gtk_menu_parent_class)->expose_event) (widget, event);
+
+ GTK_WIDGET_CLASS (gtk_menu_parent_class)->expose_event (widget, event);
}
return FALSE;
static gboolean
check_threshold (GtkWidget *widget,
- int start_x, int start_y,
- int x, int y)
+ gint start_x,
+ gint start_y,
+ gint x,
+ gint y)
{
#define THRESHOLD 8
}
static gboolean
-definitely_within_item (GtkWidget *widget,
- int x,
- int y)
+definitely_within_item (GtkWidget *widget,
+ gint x,
+ gint y)
{
GdkWindow *window = GTK_MENU_ITEM (widget)->event_window;
int w, h;
}
static gboolean
-gtk_menu_motion_notify (GtkWidget *widget,
- GdkEventMotion *event)
+gtk_menu_motion_notify (GtkWidget *widget,
+ GdkEventMotion *event)
{
GtkWidget *menu_item;
GtkMenu *menu;
static gboolean
get_double_arrows (GtkMenu *menu)
{
- GtkMenuPrivate *priv = gtk_menu_get_private (menu);
- gboolean double_arrows;
+ GtkMenuPrivate *priv = gtk_menu_get_private (menu);
+ gboolean double_arrows;
+ GtkArrowPlacement arrow_placement;
gtk_widget_style_get (GTK_WIDGET (menu),
"double-arrows", &double_arrows,
+ "arrow-placement", &arrow_placement,
NULL);
+ if (arrow_placement != GTK_ARROWS_BOTH)
+ return TRUE;
+
return double_arrows || (priv->initially_pushed_in &&
menu->scroll_offset != 0);
}
}
static void
-get_arrows_sensitive_area (GtkMenu *menu,
+get_arrows_sensitive_area (GtkMenu *menu,
GdkRectangle *upper,
GdkRectangle *lower)
{
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);
gtk_widget_style_get (GTK_WIDGET (menu),
"vertical-padding", &vertical_padding,
"scroll-arrow-vlength", &scroll_arrow_height,
+ "arrow-placement", &arrow_placement,
NULL);
border = GTK_CONTAINER (menu)->border_width +
gdk_window_get_position (GTK_WIDGET (menu)->window, &win_x, &win_y);
- if (upper)
+ switch (arrow_placement)
{
- upper->x = win_x;
- upper->y = win_y;
- upper->width = width;
- upper->height = scroll_arrow_height + border;
- }
+ case GTK_ARROWS_BOTH:
+ if (upper)
+ {
+ upper->x = win_x;
+ upper->y = win_y;
+ upper->width = width;
+ upper->height = scroll_arrow_height + border;
+ }
- if (lower)
- {
- lower->x = win_x;
- lower->y = win_y + height - border - scroll_arrow_height;
- lower->width = width;
- lower->height = scroll_arrow_height + border;
+ if (lower)
+ {
+ lower->x = win_x;
+ lower->y = win_y + height - border - scroll_arrow_height;
+ lower->width = width;
+ lower->height = scroll_arrow_height + border;
+ }
+ break;
+
+ case GTK_ARROWS_START:
+ if (upper)
+ {
+ upper->x = win_x;
+ upper->y = win_y;
+ upper->width = width / 2;
+ upper->height = scroll_arrow_height + border;
+ }
+
+ if (lower)
+ {
+ lower->x = win_x + width / 2;
+ lower->y = win_y;
+ lower->width = width / 2;
+ lower->height = scroll_arrow_height + border;
+ }
+ break;
+
+ case GTK_ARROWS_END:
+ if (upper)
+ {
+ upper->x = win_x;
+ upper->y = win_y + height - border - scroll_arrow_height;
+ upper->width = width / 2;
+ upper->height = scroll_arrow_height + border;
+ }
+
+ if (lower)
+ {
+ lower->x = win_x + width / 2;
+ lower->y = win_y + height - border - scroll_arrow_height;
+ lower->width = width / 2;
+ lower->height = scroll_arrow_height + border;
+ }
+ break;
}
}
GtkWidget *menu_item;
gboolean touchscreen_mode;
+ if (event->mode == GDK_CROSSING_GTK_GRAB ||
+ event->mode == GDK_CROSSING_GTK_UNGRAB ||
+ event->mode == GDK_CROSSING_STATE_CHANGED)
+ return TRUE;
+
g_object_get (gtk_widget_get_settings (widget),
"gtk-touchscreen-mode", &touchscreen_mode,
NULL);
GtkMenuItem *menu_item;
GtkWidget *event_widget;
+ if (event->mode == GDK_CROSSING_GTK_GRAB ||
+ event->mode == GDK_CROSSING_GTK_UNGRAB ||
+ event->mode == GDK_CROSSING_STATE_CHANGED)
+ return TRUE;
+
menu = GTK_MENU (widget);
menu_shell = GTK_MENU_SHELL (widget);
{
(* menu->position_func) (menu, &x, &y, &private->initially_pushed_in,
menu->position_func_data);
+
if (private->monitor_num < 0)
private->monitor_num = gdk_screen_get_monitor_at_point (screen, x, y);
}
static void
-gtk_menu_scroll_item_visible (GtkMenuShell *menu_shell,
- GtkWidget *menu_item)
+gtk_menu_scroll_item_visible (GtkMenuShell *menu_shell,
+ GtkWidget *menu_item)
{
GtkMenu *menu;
gint child_offset, child_height;
}
static void
-gtk_menu_select_item (GtkMenuShell *menu_shell,
- GtkWidget *menu_item)
+gtk_menu_select_item (GtkMenuShell *menu_shell,
+ GtkWidget *menu_item)
{
GtkMenu *menu = GTK_MENU (menu_shell);
* (the image of the menu) is left in place.
*/
static void
-gtk_menu_reparent (GtkMenu *menu,
- GtkWidget *new_parent,
- gboolean unrealize)
+gtk_menu_reparent (GtkMenu *menu,
+ GtkWidget *new_parent,
+ gboolean unrealize)
{
GtkObject *object = GTK_OBJECT (menu);
GtkWidget *widget = GTK_WIDGET (menu);
/**
* gtk_menu_set_screen:
* @menu: a #GtkMenu.
- * @screen: a #GdkScreen, or %NULL if the screen should be
+ * @screen: (allow-none): a #GdkScreen, or %NULL if the screen should be
* determined by the widget the menu is attached to.
*
* Sets the #GdkScreen on which the menu will be displayed.
- *
+ *
* Since: 2.2
**/
void
}
static void
-gtk_menu_move_current (GtkMenuShell *menu_shell,
- GtkMenuDirectionType direction)
+gtk_menu_move_current (GtkMenuShell *menu_shell,
+ GtkMenuDirectionType direction)
{
GtkMenu *menu = GTK_MENU (menu_shell);
gint i;
priv->monitor_num = monitor_num;
}
+/**
+ * gtk_menu_get_monitor:
+ * @menu: a #GtkMenu
+ *
+ * Retrieves the number of the monitor on which to show the menu.
+ *
+ * Returns: the number of the monitor on which the menu should
+ * be popped up or -1, if no monitor has been set
+ *
+ * Since: 2.14
+ **/
+gint
+gtk_menu_get_monitor (GtkMenu *menu)
+{
+ GtkMenuPrivate *priv;
+ g_return_val_if_fail (GTK_IS_MENU (menu), -1);
+
+ priv = gtk_menu_get_private (menu);
+
+ return priv->monitor_num;
+}
+
/**
* gtk_menu_get_for_attach_widget:
* @widget: a #GtkWidget
* Returns a list of the menus which are attached to this widget.
* This list is owned by GTK+ and must not be modified.
*
- * Return value: the list of menus attached to his widget.
+ * Return value: (element-type GtkWidget) (transfer none): the list of menus attached to his widget.
*
* Since: 2.6
**/
}
}
+/**
+ * gtk_menu_set_reserve_toggle_size:
+ * @menu: a #GtkMenu
+ * @reserve_toggle_size: whether to reserve size for toggles
+ *
+ * Sets whether the menu should reserve space for drawing toggles
+ * or icons, regardless of their actual presence.
+ *
+ * Since: 2.18
+ */
+void
+gtk_menu_set_reserve_toggle_size (GtkMenu *menu,
+ gboolean reserve_toggle_size)
+{
+ GtkMenuPrivate *priv = gtk_menu_get_private (menu);
+ gboolean no_toggle_size;
+
+ no_toggle_size = !reserve_toggle_size;
+
+ if (priv->no_toggle_size != no_toggle_size)
+ {
+ priv->no_toggle_size = no_toggle_size;
+
+ g_object_notify (G_OBJECT (menu), "reserve-toggle-size");
+ }
+}
+
+/**
+ * gtk_menu_get_reserve_toggle_size:
+ * @menu: a #GtkMenu
+ *
+ * Returns whether the menu reserves space for toggles and
+ * icons, regardless of their actual presence.
+ *
+ * Returns: Whether the menu reserves toggle space
+ *
+ * Since: 2.18
+ */
+gboolean
+gtk_menu_get_reserve_toggle_size (GtkMenu *menu)
+{
+ GtkMenuPrivate *priv = gtk_menu_get_private (menu);
+
+ return !priv->no_toggle_size;
+}
+
#define __GTK_MENU_C__
#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff