gtkmenuitem.c 38.7 KB
Newer Older
Elliot Lee's avatar
Elliot Lee committed
1 2 3 4
/* GTK - The GIMP Toolkit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
Elliot Lee's avatar
Elliot Lee committed
6 7 8 9 10 11
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This 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
12
 * Lesser General Public License for more details.
Elliot Lee's avatar
Elliot Lee committed
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15 16 17
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
Elliot Lee's avatar
Elliot Lee committed
18
 */
19 20

/*
21
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
22 23 24 25 26
 * 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/. 
 */

27 28
#define GTK_MENU_INTERNALS

29
#include <config.h>
Elliot Lee's avatar
Elliot Lee committed
30
#include <string.h>
31 32

#include "gtkalias.h"
Tim Janik's avatar
Tim Janik committed
33
#include "gtkaccellabel.h"
Elliot Lee's avatar
Elliot Lee committed
34
#include "gtkmain.h"
35
#include "gtkmarshalers.h"
Elliot Lee's avatar
Elliot Lee committed
36
#include "gtkmenu.h"
37
#include "gtkmenubar.h"
Elliot Lee's avatar
Elliot Lee committed
38
#include "gtkmenuitem.h"
39
#include "gtkseparatormenuitem.h"
Elliot Lee's avatar
Elliot Lee committed
40 41 42 43 44

#define MENU_ITEM_CLASS(w)  GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)

enum {
  ACTIVATE,
45
  ACTIVATE_ITEM,
46 47
  TOGGLE_SIZE_REQUEST,
  TOGGLE_SIZE_ALLOCATE,
Elliot Lee's avatar
Elliot Lee committed
48 49 50 51 52 53 54
  LAST_SIGNAL
};


static void gtk_menu_item_class_init     (GtkMenuItemClass *klass);
static void gtk_menu_item_init           (GtkMenuItem      *menu_item);
static void gtk_menu_item_destroy        (GtkObject        *object);
55
static void gtk_menu_item_finalize       (GObject          *object);
Elliot Lee's avatar
Elliot Lee committed
56 57 58 59
static void gtk_menu_item_size_request   (GtkWidget        *widget,
					  GtkRequisition   *requisition);
static void gtk_menu_item_size_allocate  (GtkWidget        *widget,
					  GtkAllocation    *allocation);
60 61 62 63
static void gtk_menu_item_realize        (GtkWidget        *widget);
static void gtk_menu_item_unrealize      (GtkWidget        *widget);
static void gtk_menu_item_map            (GtkWidget        *widget);
static void gtk_menu_item_unmap          (GtkWidget        *widget);
Elliot Lee's avatar
Elliot Lee committed
64 65 66 67
static void gtk_menu_item_paint          (GtkWidget        *widget,
					  GdkRectangle     *area);
static gint gtk_menu_item_expose         (GtkWidget        *widget,
					  GdkEventExpose   *event);
68 69
static void gtk_menu_item_parent_set     (GtkWidget        *widget,
					  GtkWidget        *previous_parent);
70

71

72 73 74 75
static void gtk_real_menu_item_select               (GtkItem     *item);
static void gtk_real_menu_item_deselect             (GtkItem     *item);
static void gtk_real_menu_item_activate_item        (GtkMenuItem *item);
static void gtk_real_menu_item_toggle_size_request  (GtkMenuItem *menu_item,
76
						     gint        *requisition);
77
static void gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
78
						     gint         allocation);
79
static gboolean gtk_menu_item_mnemonic_activate     (GtkWidget   *widget,
80
						     gboolean     group_cycling);
81

Elliot Lee's avatar
Elliot Lee committed
82
static gint gtk_menu_item_select_timeout (gpointer          data);
83
static void gtk_menu_item_popup_submenu  (gpointer     data);
Elliot Lee's avatar
Elliot Lee committed
84 85 86
static void gtk_menu_item_position_menu  (GtkMenu          *menu,
					  gint             *x,
					  gint             *y,
87
					  gboolean         *push_in,
Elliot Lee's avatar
Elliot Lee committed
88
					  gpointer          user_data);
89 90
static void gtk_menu_item_show_all       (GtkWidget        *widget);
static void gtk_menu_item_hide_all       (GtkWidget        *widget);
91 92 93 94
static void gtk_menu_item_forall         (GtkContainer    *container,
					  gboolean         include_internals,
					  GtkCallback      callback,
					  gpointer         callback_data);
Owen Taylor's avatar
Owen Taylor committed
95 96
static gboolean gtk_menu_item_can_activate_accel (GtkWidget *widget,
						  guint      signal_id);
Elliot Lee's avatar
Elliot Lee committed
97

98

Elliot Lee's avatar
Elliot Lee committed
99
static GtkItemClass *parent_class;
100
static guint menu_item_signals[LAST_SIGNAL] = { 0 };
Elliot Lee's avatar
Elliot Lee committed
101

Manish Singh's avatar
Manish Singh committed
102
GType
103
gtk_menu_item_get_type (void)
Elliot Lee's avatar
Elliot Lee committed
104
{
Manish Singh's avatar
Manish Singh committed
105
  static GType menu_item_type = 0;
Elliot Lee's avatar
Elliot Lee committed
106 107 108

  if (!menu_item_type)
    {
109
      static const GTypeInfo menu_item_info =
Elliot Lee's avatar
Elliot Lee committed
110 111
      {
	sizeof (GtkMenuItemClass),
112 113 114 115 116 117 118 119
	NULL,           /* base_init */
	NULL,           /* base_finalize */
	(GClassInitFunc) gtk_menu_item_class_init,
	NULL,           /* class_finalize */
	NULL,           /* class_data */
	sizeof (GtkMenuItem),
	16,             /* n_preallocs */
	(GInstanceInitFunc) gtk_menu_item_init,
Elliot Lee's avatar
Elliot Lee committed
120 121
      };

Manish Singh's avatar
Manish Singh committed
122 123
      menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem",
					       &menu_item_info, 0);
Elliot Lee's avatar
Elliot Lee committed
124 125 126 127 128 129 130 131
    }

  return menu_item_type;
}

static void
gtk_menu_item_class_init (GtkMenuItemClass *klass)
{
132 133 134 135 136
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
  GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
  GtkItemClass *item_class = GTK_ITEM_CLASS (klass);
Elliot Lee's avatar
Elliot Lee committed
137

138
  parent_class = g_type_class_peek_parent (klass);
Elliot Lee's avatar
Elliot Lee committed
139

140
  gobject_class->finalize = gtk_menu_item_finalize;
141 142 143 144 145 146

  object_class->destroy = gtk_menu_item_destroy;

  widget_class->size_request = gtk_menu_item_size_request;
  widget_class->size_allocate = gtk_menu_item_size_allocate;
  widget_class->expose_event = gtk_menu_item_expose;
147 148 149 150
  widget_class->realize = gtk_menu_item_realize;
  widget_class->unrealize = gtk_menu_item_unrealize;
  widget_class->map = gtk_menu_item_map;
  widget_class->unmap = gtk_menu_item_unmap;
151 152
  widget_class->show_all = gtk_menu_item_show_all;
  widget_class->hide_all = gtk_menu_item_hide_all;
153
  widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
154
  widget_class->parent_set = gtk_menu_item_parent_set;
Owen Taylor's avatar
Owen Taylor committed
155
  widget_class->can_activate_accel = gtk_menu_item_can_activate_accel;
156
  
157 158 159 160 161 162 163 164 165 166 167 168
  container_class->forall = gtk_menu_item_forall;

  item_class->select = gtk_real_menu_item_select;
  item_class->deselect = gtk_real_menu_item_deselect;

  klass->activate = NULL;
  klass->activate_item = gtk_real_menu_item_activate_item;
  klass->toggle_size_request = gtk_real_menu_item_toggle_size_request;
  klass->toggle_size_allocate = gtk_real_menu_item_toggle_size_allocate;

  klass->hide_on_activate = TRUE;

Elliot Lee's avatar
Elliot Lee committed
169
  menu_item_signals[ACTIVATE] =
Manish Singh's avatar
Manish Singh committed
170 171 172 173 174 175 176
    g_signal_new ("activate",
		  G_OBJECT_CLASS_TYPE (gobject_class),
		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
		  G_STRUCT_OFFSET (GtkMenuItemClass, activate),
		  NULL, NULL,
		  _gtk_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);
177
  widget_class->activate_signal = menu_item_signals[ACTIVATE];
Elliot Lee's avatar
Elliot Lee committed
178

179
  menu_item_signals[ACTIVATE_ITEM] =
Manish Singh's avatar
Manish Singh committed
180 181 182 183 184 185 186
    g_signal_new ("activate_item",
		  G_OBJECT_CLASS_TYPE (gobject_class),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GtkMenuItemClass, activate_item),
		  NULL, NULL,
		  _gtk_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);
187

188
  menu_item_signals[TOGGLE_SIZE_REQUEST] =
Manish Singh's avatar
Manish Singh committed
189 190 191 192 193 194 195 196
    g_signal_new ("toggle_size_request",
		  G_OBJECT_CLASS_TYPE (gobject_class),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_request),
		  NULL, NULL,
		  _gtk_marshal_VOID__POINTER,
		  G_TYPE_NONE, 1,
		  G_TYPE_POINTER);
197 198

  menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
Manish Singh's avatar
Manish Singh committed
199 200 201 202 203 204 205 206
    g_signal_new ("toggle_size_allocate",
		  G_OBJECT_CLASS_TYPE (gobject_class),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_allocate),
		  NULL, NULL,
		  _gtk_marshal_NONE__INT,
		  G_TYPE_NONE, 1,
		  G_TYPE_INT);
207 208 209 210 211 212

  gtk_widget_class_install_style_property_parser (widget_class,
						  g_param_spec_enum ("selected_shadow_type",
								     "Selected Shadow Type",
								     "Shadow type when item is selected",
								     GTK_TYPE_SHADOW_TYPE,
213
								     GTK_SHADOW_NONE,
214 215
								     G_PARAM_READABLE),
						  gtk_rc_property_parse_enum);
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242

  gtk_widget_class_install_style_property (widget_class,
					   g_param_spec_int ("horizontal_padding",
							     "Horizontal Padding",
							     "Padding to left and right of the menu item",
							     0,
							     G_MAXINT,
							     3,
							     G_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,
					   g_param_spec_int ("toggle_spacing",
							     "Icon Spacing",
							     "Space between icon and label",
							     0,
							     G_MAXINT,
							     5,
							     G_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,
					   g_param_spec_int ("arrow_spacing",
							     "Arrow Spacing",
							     "Space between label and arrow",
							     0,
							     G_MAXINT,
							     10,
							     G_PARAM_READABLE));
Elliot Lee's avatar
Elliot Lee committed
243 244 245 246 247
}

static void
gtk_menu_item_init (GtkMenuItem *menu_item)
{
248 249
  GTK_WIDGET_SET_FLAGS (menu_item, GTK_NO_WINDOW);
  
Elliot Lee's avatar
Elliot Lee committed
250 251
  menu_item->submenu = NULL;
  menu_item->toggle_size = 0;
252
  menu_item->accelerator_width = 0;
Elliot Lee's avatar
Elliot Lee committed
253
  menu_item->show_submenu_indicator = FALSE;
254 255 256 257
  if (gtk_widget_get_direction (GTK_WIDGET (menu_item)) == GTK_TEXT_DIR_RTL)
    menu_item->submenu_direction = GTK_DIRECTION_LEFT;
  else
    menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
Elliot Lee's avatar
Elliot Lee committed
258 259 260 261 262 263 264
  menu_item->submenu_placement = GTK_TOP_BOTTOM;
  menu_item->right_justify = FALSE;

  menu_item->timer = 0;
}

GtkWidget*
265
gtk_menu_item_new (void)
Elliot Lee's avatar
Elliot Lee committed
266
{
Manish Singh's avatar
Manish Singh committed
267
  return g_object_new (GTK_TYPE_MENU_ITEM, NULL);
Elliot Lee's avatar
Elliot Lee committed
268 269 270 271 272 273
}

GtkWidget*
gtk_menu_item_new_with_label (const gchar *label)
{
  GtkWidget *menu_item;
Tim Janik's avatar
Tim Janik committed
274
  GtkWidget *accel_label;
Elliot Lee's avatar
Elliot Lee committed
275 276

  menu_item = gtk_menu_item_new ();
Tim Janik's avatar
Tim Janik committed
277 278
  accel_label = gtk_accel_label_new (label);
  gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
Elliot Lee's avatar
Elliot Lee committed
279

Tim Janik's avatar
Tim Janik committed
280 281 282
  gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
  gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
  gtk_widget_show (accel_label);
Elliot Lee's avatar
Elliot Lee committed
283 284 285 286

  return menu_item;
}

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304

/**
 * gtk_menu_item_new_with_mnemonic:
 * @label: The text of the button, with an underscore in front of the
 *         mnemonic character
 * @returns: a new #GtkMenuItem
 *
 * Creates a new #GtkMenuItem containing a label. The label
 * will be created using gtk_label_new_with_mnemonic(), so underscores
 * in @label indicate the mnemonic for the menu item.
 **/
GtkWidget*
gtk_menu_item_new_with_mnemonic (const gchar *label)
{
  GtkWidget *menu_item;
  GtkWidget *accel_label;

  menu_item = gtk_menu_item_new ();
Manish Singh's avatar
Manish Singh committed
305
  accel_label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
306 307 308 309 310 311 312 313 314 315
  gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), label);
  gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);

  gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
  gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
  gtk_widget_show (accel_label);

  return menu_item;
}

Elliot Lee's avatar
Elliot Lee committed
316 317 318 319 320 321 322 323 324 325
static void
gtk_menu_item_destroy (GtkObject *object)
{
  GtkMenuItem *menu_item;

  g_return_if_fail (GTK_IS_MENU_ITEM (object));

  menu_item = GTK_MENU_ITEM (object);

  if (menu_item->submenu)
326
    gtk_widget_destroy (menu_item->submenu);
Elliot Lee's avatar
Elliot Lee committed
327

328 329 330 331 332 333 334 335 336 337 338
  GTK_OBJECT_CLASS (parent_class)->destroy (object);
}

static void
gtk_menu_item_finalize (GObject *object)
{
  GtkMenuItem *menu_item = GTK_MENU_ITEM (object);

  g_free (menu_item->accel_path);

  G_OBJECT_CLASS (parent_class)->finalize (object);
Elliot Lee's avatar
Elliot Lee committed
339 340
}

341 342 343 344 345 346 347 348 349 350 351 352 353 354
static void
gtk_menu_item_detacher (GtkWidget     *widget,
			GtkMenu       *menu)
{
  GtkMenuItem *menu_item;

  g_return_if_fail (GTK_IS_MENU_ITEM (widget));

  menu_item = GTK_MENU_ITEM (widget);
  g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);

  menu_item->submenu = NULL;
}

Elliot Lee's avatar
Elliot Lee committed
355 356 357 358 359
void
gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
			   GtkWidget   *submenu)
{
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
360
  
361
  if (menu_item->submenu != submenu)
Elliot Lee's avatar
Elliot Lee committed
362
    {
363 364
      gtk_menu_item_remove_submenu (menu_item);
      
365
      menu_item->submenu = submenu;
366 367 368 369
      gtk_menu_attach_to_widget (GTK_MENU (submenu),
				 GTK_WIDGET (menu_item),
				 gtk_menu_item_detacher);
      
370 371
      if (GTK_WIDGET (menu_item)->parent)
	gtk_widget_queue_resize (GTK_WIDGET (menu_item));
Elliot Lee's avatar
Elliot Lee committed
372 373 374
    }
}

375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
/**
 * gtk_menu_item_get_submenu:
 * @menu_item: a #GtkMenuItem
 *
 * Gets the submenu underneath this menu item, if any. See
 * gtk_menu_item_set_submenu().
 *
 * Return value: submenu for this menu item, or %NULL if none.
 **/
GtkWidget *
gtk_menu_item_get_submenu (GtkMenuItem *menu_item)
{
  g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), NULL);

  return menu_item->submenu;
}

392 393 394 395 396 397 398 399 400
void
gtk_menu_item_remove_submenu (GtkMenuItem         *menu_item)
{
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
      
  if (menu_item->submenu)
    gtk_menu_detach (GTK_MENU (menu_item->submenu));
}

401 402 403
void _gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
				   GtkSubmenuPlacement  placement);

Elliot Lee's avatar
Elliot Lee committed
404
void
Owen Taylor's avatar
Owen Taylor committed
405
_gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
Elliot Lee's avatar
Elliot Lee committed
406 407 408 409 410 411 412 413 414 415
			     GtkSubmenuPlacement  placement)
{
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));

  menu_item->submenu_placement = placement;
}

void
gtk_menu_item_select (GtkMenuItem *menu_item)
{
416 417
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
  
Elliot Lee's avatar
Elliot Lee committed
418 419 420 421 422 423
  gtk_item_select (GTK_ITEM (menu_item));
}

void
gtk_menu_item_deselect (GtkMenuItem *menu_item)
{
424 425
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
  
Elliot Lee's avatar
Elliot Lee committed
426 427 428 429 430 431
  gtk_item_deselect (GTK_ITEM (menu_item));
}

void
gtk_menu_item_activate (GtkMenuItem *menu_item)
{
432 433
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
  
Manish Singh's avatar
Manish Singh committed
434
  g_signal_emit (menu_item, menu_item_signals[ACTIVATE], 0);
Elliot Lee's avatar
Elliot Lee committed
435 436
}

437 438
void
gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item,
439
				   gint        *requisition)
440 441 442
{
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));

Manish Singh's avatar
Manish Singh committed
443
  g_signal_emit (menu_item, menu_item_signals[TOGGLE_SIZE_REQUEST], 0, requisition);
444 445 446 447
}

void
gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
448
				    gint         allocation)
449 450 451
{
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));

Manish Singh's avatar
Manish Singh committed
452
  g_signal_emit (menu_item, menu_item_signals[TOGGLE_SIZE_ALLOCATE], 0, allocation);
453 454
}

455 456 457 458 459 460 461 462 463 464
static void
gtk_menu_item_accel_width_foreach (GtkWidget *widget,
				   gpointer data)
{
  guint *width = data;

  if (GTK_IS_ACCEL_LABEL (widget))
    {
      guint w;

465
      w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
466 467 468 469 470 471 472
      *width = MAX (*width, w);
    }
  else if (GTK_IS_CONTAINER (widget))
    gtk_container_foreach (GTK_CONTAINER (widget),
			   gtk_menu_item_accel_width_foreach,
			   data);
}
Elliot Lee's avatar
Elliot Lee committed
473

474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
static gint
get_minimum_width (GtkWidget *widget)
{
  PangoContext *context;
  PangoFontMetrics *metrics;
  gint height;

  context = gtk_widget_get_pango_context (widget);
  metrics = pango_context_get_metrics (context,
				       widget->style->font_desc,
				       pango_context_get_language (context));

  height = pango_font_metrics_get_ascent (metrics) +
      pango_font_metrics_get_descent (metrics);
  
  pango_font_metrics_unref (metrics);

  return PANGO_PIXELS (7 * height);
}

Elliot Lee's avatar
Elliot Lee committed
494 495 496 497
static void
gtk_menu_item_size_request (GtkWidget      *widget,
			    GtkRequisition *requisition)
{
Tim Janik's avatar
Tim Janik committed
498
  GtkMenuItem *menu_item;
Elliot Lee's avatar
Elliot Lee committed
499
  GtkBin *bin;
500
  guint accel_width;
501
  guint horizontal_padding;
Elliot Lee's avatar
Elliot Lee committed
502 503 504 505

  g_return_if_fail (GTK_IS_MENU_ITEM (widget));
  g_return_if_fail (requisition != NULL);

506
  gtk_widget_style_get (widget,
Matthias Clasen's avatar
Matthias Clasen committed
507
 			"horizontal_padding", &horizontal_padding,
508 509
			NULL);
  
Elliot Lee's avatar
Elliot Lee committed
510
  bin = GTK_BIN (widget);
Tim Janik's avatar
Tim Janik committed
511
  menu_item = GTK_MENU_ITEM (widget);
Elliot Lee's avatar
Elliot Lee committed
512 513

  requisition->width = (GTK_CONTAINER (widget)->border_width +
514
			widget->style->xthickness + horizontal_padding) * 2;
Elliot Lee's avatar
Elliot Lee committed
515
  requisition->height = (GTK_CONTAINER (widget)->border_width +
516
			 widget->style->ythickness) * 2;
Elliot Lee's avatar
Elliot Lee committed
517 518 519

  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
    {
520 521 522
      GtkRequisition child_requisition;
      
      gtk_widget_size_request (bin->child, &child_requisition);
Elliot Lee's avatar
Elliot Lee committed
523

524 525
      requisition->width += child_requisition.width;
      requisition->height += child_requisition.height;
526

527
      if (menu_item->submenu && menu_item->show_submenu_indicator)
528 529 530 531 532 533 534 535 536
	{
	  guint arrow_spacing;
	  
	  gtk_widget_style_get (widget,
				"arrow_spacing", &arrow_spacing,
				NULL);

	  requisition->width += child_requisition.height;
	  requisition->width += arrow_spacing;
537 538

	  requisition->width = MAX (requisition->width, get_minimum_width (widget));
539 540 541 542 543 544
	}
    }
  else
    {
      /* separator item */
      requisition->height += 4;
545
    }
546 547 548 549 550 551

  accel_width = 0;
  gtk_container_foreach (GTK_CONTAINER (menu_item),
			 gtk_menu_item_accel_width_foreach,
			 &accel_width);
  menu_item->accelerator_width = accel_width;
Elliot Lee's avatar
Elliot Lee committed
552 553 554 555 556 557
}

static void
gtk_menu_item_size_allocate (GtkWidget     *widget,
			     GtkAllocation *allocation)
{
Tim Janik's avatar
Tim Janik committed
558
  GtkMenuItem *menu_item;
Elliot Lee's avatar
Elliot Lee committed
559 560
  GtkBin *bin;
  GtkAllocation child_allocation;
561
  GtkTextDirection direction;
Elliot Lee's avatar
Elliot Lee committed
562 563 564 565

  g_return_if_fail (GTK_IS_MENU_ITEM (widget));
  g_return_if_fail (allocation != NULL);

Tim Janik's avatar
Tim Janik committed
566
  menu_item = GTK_MENU_ITEM (widget);
Elliot Lee's avatar
Elliot Lee committed
567
  bin = GTK_BIN (widget);
Tim Janik's avatar
Tim Janik committed
568
  
569 570
  direction = gtk_widget_get_direction (widget);

Tim Janik's avatar
Tim Janik committed
571
  widget->allocation = *allocation;
Elliot Lee's avatar
Elliot Lee committed
572 573 574

  if (bin->child)
    {
575
      GtkRequisition child_requisition;
576 577 578 579 580
      guint horizontal_padding;

      gtk_widget_style_get (widget,
			    "horizontal_padding", &horizontal_padding,
			    NULL);
581
      
Elliot Lee's avatar
Elliot Lee committed
582
      child_allocation.x = (GTK_CONTAINER (widget)->border_width +
583
                            widget->style->xthickness +
584
			    horizontal_padding);
Owen Taylor's avatar
Owen Taylor committed
585
      child_allocation.y = (GTK_CONTAINER (widget)->border_width +
586
			    widget->style->ythickness);
587 588
      child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
      child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
589 590
      if (direction == GTK_TEXT_DIR_LTR)
	child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
Tim Janik's avatar
Tim Janik committed
591
      child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
592 593
      child_allocation.x += widget->allocation.x;
      child_allocation.y += widget->allocation.y;
594 595

      gtk_widget_get_child_requisition (bin->child, &child_requisition);
596 597 598 599 600 601 602
      if (menu_item->submenu && menu_item->show_submenu_indicator) 
	{
	  if (direction == GTK_TEXT_DIR_RTL)
	    child_allocation.x += child_requisition.height;
	  child_allocation.width -= child_requisition.height;
	}
      
603 604 605
      if (child_allocation.width < 1)
	child_allocation.width = 1;

Elliot Lee's avatar
Elliot Lee committed
606 607 608
      gtk_widget_size_allocate (bin->child, &child_allocation);
    }

Tim Janik's avatar
Tim Janik committed
609
  if (GTK_WIDGET_REALIZED (widget))
610
    gdk_window_move_resize (menu_item->event_window,
Tim Janik's avatar
Tim Janik committed
611 612
                            allocation->x, allocation->y,
                            allocation->width, allocation->height);
Elliot Lee's avatar
Elliot Lee committed
613

Tim Janik's avatar
Tim Janik committed
614 615
  if (menu_item->submenu)
    gtk_menu_reposition (GTK_MENU (menu_item->submenu));
Elliot Lee's avatar
Elliot Lee committed
616 617
}

618 619 620 621 622 623 624 625 626 627
static void
gtk_menu_item_realize (GtkWidget *widget)
{
  GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
  GdkWindowAttr attributes;
  gint attributes_mask;

  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);

  widget->window = gtk_widget_get_parent_window (widget);
Manish Singh's avatar
Manish Singh committed
628
  g_object_ref (widget->window);
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
  
  attributes.x = widget->allocation.x;
  attributes.y = widget->allocation.y;
  attributes.width = widget->allocation.width;
  attributes.height = widget->allocation.height;
  attributes.window_type = GDK_WINDOW_CHILD;
  attributes.wclass = GDK_INPUT_ONLY;
  attributes.event_mask = (gtk_widget_get_events (widget) |
			   GDK_BUTTON_PRESS_MASK |
			   GDK_BUTTON_RELEASE_MASK |
			   GDK_ENTER_NOTIFY_MASK |
			   GDK_LEAVE_NOTIFY_MASK |
			   GDK_POINTER_MOTION_MASK);

  attributes_mask = GDK_WA_X | GDK_WA_Y;
  menu_item->event_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
  gdk_window_set_user_data (menu_item->event_window, widget);

  widget->style = gtk_style_attach (widget->style, widget->window);
}

static void
gtk_menu_item_unrealize (GtkWidget *widget)
{
  GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);

  gdk_window_set_user_data (menu_item->event_window, NULL);
  gdk_window_destroy (menu_item->event_window);
  menu_item->event_window = NULL;
  
  if (GTK_WIDGET_CLASS (parent_class)->unrealize)
    (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}

static void
gtk_menu_item_map (GtkWidget *widget)
{
  GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
  
  GTK_WIDGET_CLASS (parent_class)->map (widget);
669 670

  gdk_window_show (menu_item->event_window);
671 672 673 674 675 676 677 678 679 680 681 682
}

static void
gtk_menu_item_unmap (GtkWidget *widget)
{
  GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
    
  gdk_window_hide (menu_item->event_window);

  GTK_WIDGET_CLASS (parent_class)->unmap (widget);
}

Elliot Lee's avatar
Elliot Lee committed
683 684 685 686 687 688
static void
gtk_menu_item_paint (GtkWidget    *widget,
		     GdkRectangle *area)
{
  GtkMenuItem *menu_item;
  GtkStateType state_type;
689
  GtkShadowType shadow_type, selected_shadow_type;
Elliot Lee's avatar
Elliot Lee committed
690 691
  gint width, height;
  gint x, y;
692
  gint border_width = GTK_CONTAINER (widget)->border_width;
Elliot Lee's avatar
Elliot Lee committed
693 694 695 696 697 698

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      menu_item = GTK_MENU_ITEM (widget);

      state_type = widget->state;
699
      
700 701 702 703
      x = widget->allocation.x + border_width;
      y = widget->allocation.y + border_width;
      width = widget->allocation.width - border_width * 2;
      height = widget->allocation.height - border_width * 2;
704
      
Elliot Lee's avatar
Elliot Lee committed
705 706
      if ((state_type == GTK_STATE_PRELIGHT) &&
	  (GTK_BIN (menu_item)->child))
707 708 709 710 711 712 713 714 715 716 717 718
	{
	  gtk_widget_style_get (widget,
				"selected_shadow_type", &selected_shadow_type,
				NULL);
	  gtk_paint_box (widget->style,
			 widget->window,
			 GTK_STATE_PRELIGHT,
			 selected_shadow_type,
			 area, widget, "menuitem",
			 x, y, width, height);
	}
  
Tim Janik's avatar
Tim Janik committed
719
      if (menu_item->submenu && menu_item->show_submenu_indicator)
Elliot Lee's avatar
Elliot Lee committed
720
	{
721
	  GtkRequisition child_requisition;
722
	  gint arrow_x, arrow_y;
723 724
	  gint arrow_size;
	  gint arrow_extent;
725
	  guint horizontal_padding;
726 727
	  GtkTextDirection direction;
	  GtkArrowType arrow_type;
728 729 730 731
	  PangoContext *context;
	  PangoFontMetrics *metrics;
	  gint ascent, descent;
	  PangoLayout *layout;
732

733 734
	  direction = gtk_widget_get_direction (widget);
      
735 736 737 738
 	  gtk_widget_style_get (widget,
 				"horizontal_padding", &horizontal_padding,
 				NULL);
 	  
739 740 741 742 743 744 745 746 747 748
	  context = gtk_widget_get_pango_context (GTK_BIN (menu_item)->child);
	  metrics = pango_context_get_metrics (context, 
					       GTK_WIDGET (GTK_BIN (menu_item)->child)->style->font_desc,
					       pango_context_get_language (context));
	  
	  ascent = pango_font_metrics_get_ascent (metrics);
	  descent = pango_font_metrics_get_descent (metrics);
	  pango_font_metrics_unref (metrics);
	  
	  arrow_size = PANGO_PIXELS (ascent + descent) - 2 * widget->style->ythickness;
749

750
	  arrow_extent = arrow_size * 0.8;
751
	  
Elliot Lee's avatar
Elliot Lee committed
752 753 754 755
	  shadow_type = GTK_SHADOW_OUT;
	  if (state_type == GTK_STATE_PRELIGHT)
	    shadow_type = GTK_SHADOW_IN;

756 757 758 759 760 761 762 763 764 765
	  if (direction == GTK_TEXT_DIR_LTR)
	    {
	      arrow_x = x + width - horizontal_padding - arrow_extent;
	      arrow_type = GTK_ARROW_RIGHT;
	    }
	  else
	    {
	      arrow_x = x + horizontal_padding;
	      arrow_type = GTK_ARROW_LEFT;
	    }
766

767 768
	  arrow_y = y + (height - arrow_extent) / 2;

769 770 771
	  gtk_paint_arrow (widget->style, widget->window,
			   state_type, shadow_type, 
			   area, widget, "menuitem", 
772
			   arrow_type, TRUE,
773 774
			   arrow_x, arrow_y,
			   arrow_extent, arrow_extent);
Elliot Lee's avatar
Elliot Lee committed
775 776 777
	}
      else if (!GTK_BIN (menu_item)->child)
	{
778 779 780 781 782 783
	  guint horizontal_padding;

	  gtk_widget_style_get (widget,
				"horizontal_padding", &horizontal_padding,
				NULL);
	  
784 785
	  gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
			   area, widget, "menuitem",
786 787 788 789
			   widget->allocation.x + horizontal_padding + widget->style->xthickness,
			   widget->allocation.x + widget->allocation.width - horizontal_padding - widget->style->xthickness - 1,
			   widget->allocation.y + (widget->allocation.height -
						   widget->style->ythickness) / 2);
Elliot Lee's avatar
Elliot Lee committed
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
	}
    }
}

static gint
gtk_menu_item_expose (GtkWidget      *widget,
		      GdkEventExpose *event)
{
  g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      gtk_menu_item_paint (widget, &event->area);

805
      (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
Elliot Lee's avatar
Elliot Lee committed
806 807 808 809 810
    }

  return FALSE;
}

811 812 813 814 815 816 817 818 819 820 821 822 823
static gint
get_popup_delay (GtkMenuItem *menu_item)
{
  GtkWidget *parent = GTK_WIDGET (menu_item)->parent;

  if (GTK_IS_MENU_SHELL (parent))
    {
      return _gtk_menu_shell_get_popup_delay (GTK_MENU_SHELL (parent));
    }
  else
    {
      gint popup_delay;
      
824
      g_object_get (gtk_widget_get_settings (GTK_WIDGET (menu_item)),
825 826 827 828 829 830 831
		    "gtk-menu-popup-delay", &popup_delay,
		    NULL);

      return popup_delay;
    }
}

Elliot Lee's avatar
Elliot Lee committed
832 833 834 835 836 837 838 839 840
static void
gtk_real_menu_item_select (GtkItem *item)
{
  GtkMenuItem *menu_item;

  g_return_if_fail (GTK_IS_MENU_ITEM (item));

  menu_item = GTK_MENU_ITEM (item);

841 842
  if (menu_item->submenu &&
      !GTK_WIDGET_MAPPED (menu_item->submenu))
843
    {
844
      gint popup_delay;
845

846
      if (menu_item->timer)
847 848
	{
	  g_source_remove (menu_item->timer);
849
	  menu_item->timer = 0;
850 851 852 853
	  popup_delay = 0;
	}
      else
	popup_delay = get_popup_delay (menu_item);
854 855
      
      if (popup_delay > 0)
856
	{
857 858
	  GdkEvent *event = gtk_get_current_event ();
	  
859 860 861
	  menu_item->timer = g_timeout_add (popup_delay,
					    gtk_menu_item_select_timeout,
					    menu_item);
862 863 864 865 866 867
	  if (event &&
	      event->type != GDK_BUTTON_PRESS &&
	      event->type != GDK_ENTER_NOTIFY)
	    menu_item->timer_from_keypress = TRUE;
	  else
	    menu_item->timer_from_keypress = FALSE;
868 869

	  if (event)
870
	    gdk_event_free (event);
871
	}
872
      else
873
	gtk_menu_item_popup_submenu (menu_item);
874
    }
875
  
Elliot Lee's avatar
Elliot Lee committed
876
  gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
Soeren Sandmann's avatar
Soeren Sandmann committed
877
  gtk_widget_queue_draw (GTK_WIDGET (menu_item));
Elliot Lee's avatar
Elliot Lee committed
878 879 880 881 882 883 884 885 886 887 888 889 890 891
}

static void
gtk_real_menu_item_deselect (GtkItem *item)
{
  GtkMenuItem *menu_item;

  g_return_if_fail (GTK_IS_MENU_ITEM (item));

  menu_item = GTK_MENU_ITEM (item);

  if (menu_item->submenu)
    {
      if (menu_item->timer)
892
	{
893
	  g_source_remove (menu_item->timer);
894 895
	  menu_item->timer = 0;
	}
Elliot Lee's avatar
Elliot Lee committed
896 897 898 899 900
      else
	gtk_menu_popdown (GTK_MENU (menu_item->submenu));
    }

  gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
Soeren Sandmann's avatar
Soeren Sandmann committed
901
  gtk_widget_queue_draw (GTK_WIDGET (menu_item));
Elliot Lee's avatar
Elliot Lee committed
902 903
}

904
static gboolean
905
gtk_menu_item_mnemonic_activate (GtkWidget *widget,
906 907
				 gboolean   group_cycling)
{
908 909 910 911
  if (group_cycling &&
      widget->parent &&
      GTK_IS_MENU_SHELL (widget->parent) &&
      GTK_MENU_SHELL (widget->parent)->active)
912
    {
913 914
      gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent),
				  widget);
915 916
    }
  else
Manish Singh's avatar
Manish Singh committed
917
    g_signal_emit (widget, menu_item_signals[ACTIVATE_ITEM], 0);
918 919 920 921 922
  
  return TRUE;
}


923 924 925 926
static void
gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
{
  GtkWidget *widget;
927
  GtkMenuShell *submenu; 
928 929 930 931 932 933 934 935 936 937 938 939 940 941 942

  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));

  widget = GTK_WIDGET (menu_item);
  
  if (widget->parent &&
      GTK_IS_MENU_SHELL (widget->parent))
    {
      if (menu_item->submenu == NULL)
	gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
				      widget, TRUE);
      else
	{
	  GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);

943
	  _gtk_menu_shell_activate (menu_shell);
944

945 946 947
	  gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget); 
	  gtk_menu_item_popup_submenu (widget); 

948
	  gtk_menu_shell_select_first (GTK_MENU_SHELL (menu_item->submenu), TRUE);
949
	  submenu = GTK_MENU_SHELL (menu_item->submenu);
950 951 952
	}
    }
}
953 954
static void
gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
955
					gint        *requisition)
956 957 958 959 960 961 962 963
{
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));

  *requisition = 0;
}

static void
gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
964
					 gint         allocation)
965 966 967 968 969
{
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));

  menu_item->toggle_size = allocation;
}
970

Elliot Lee's avatar
Elliot Lee committed
971 972 973
static gint
gtk_menu_item_select_timeout (gpointer data)
{
974
  GtkMenuItem *menu_item;
975
  GtkWidget *parent;
976
  
977
  GDK_THREADS_ENTER ();
978

979
  menu_item = GTK_MENU_ITEM (data);
980 981 982

  parent = GTK_WIDGET (menu_item)->parent;

Matthias Clasen's avatar
Matthias Clasen committed
983 984
  if ((GTK_IS_MENU_SHELL (parent) && GTK_MENU_SHELL (parent)->active) || 
      (GTK_IS_MENU (parent) && GTK_MENU (parent)->torn_off))
985 986 987 988 989
    {
      gtk_menu_item_popup_submenu (data);
      if (menu_item->timer_from_keypress && menu_item->submenu)
	GTK_MENU_SHELL (menu_item->submenu)->ignore_enter = TRUE;
    }
990 991 992 993 994 995 996

  GDK_THREADS_LEAVE ();

  return FALSE;  
}

static void
997
gtk_menu_item_popup_submenu (gpointer data)
998
{
999
  GtkWidget *widget;
1000 1001
  GtkMenuItem *menu_item;

1002 1003
  widget = GTK_WIDGET (data);
  menu_item = GTK_MENU_ITEM (widget);
1004 1005

  if (menu_item->timer)
1006
    g_source_remove (menu_item->timer);
Elliot Lee's avatar
Elliot Lee committed
1007 1008
  menu_item->timer = 0;

1009
  if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
1010 1011 1012 1013 1014 1015 1016
    gtk_menu_popup (GTK_MENU (menu_item->submenu),
		    widget->parent,
		    widget,
		    gtk_menu_item_position_menu,
		    menu_item,
		    GTK_MENU_SHELL (widget->parent)->button,
		    0);
Elliot Lee's avatar
Elliot Lee committed
1017 1018
}

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
static void
get_offsets (GtkMenu *menu,
	     gint    *horizontal_offset,
	     gint    *vertical_offset)
{
  gint vertical_padding;
  
  gtk_widget_style_get (GTK_WIDGET (menu),
			"horizontal_offset", horizontal_offset,
			"vertical_offset", vertical_offset,
			"vertical_padding", &vertical_padding,
			NULL);

  *vertical_offset -= GTK_WIDGET (menu)->style->ythickness;
  *vertical_offset -= vertical_padding;
}

Elliot Lee's avatar
Elliot Lee committed
1036 1037 1038 1039
static void
gtk_menu_item_position_menu (GtkMenu  *menu,
			     gint     *x,
			     gint     *y,
1040
			     gboolean *push_in,
Elliot Lee's avatar
Elliot Lee committed
1041 1042 1043
			     gpointer  user_data)
{
  GtkMenuItem *menu_item;
1044
  GtkWidget *widget;
Tim Janik's avatar
Tim Janik committed
1045
  GtkWidget *parent_menu_item;
1046
  GdkScreen *screen;
Elliot Lee's avatar
Elliot Lee committed
1047 1048
  gint twidth, theight;
  gint tx, ty;
1049
  GtkTextDirection direction;
1050 1051
  GdkRectangle monitor;
  gint monitor_num;
1052 1053 1054
  gint horizontal_offset;
  gint vertical_offset;
  gint parent_xthickness;
Elliot Lee's avatar
Elliot Lee committed
1055 1056 1057 1058 1059 1060

  g_return_if_fail (menu != NULL);
  g_return_if_fail (x != NULL);
  g_return_if_fail (y != NULL);

  menu_item = GTK_MENU_ITEM (user_data);
1061
  widget = GTK_WIDGET (user_data);
Elliot Lee's avatar
Elliot Lee committed
1062

1063 1064 1065
  if (push_in)
    *push_in = FALSE;

1066 1067
  direction = gtk_widget_get_direction (widget);

Elliot Lee's avatar
Elliot Lee committed
1068 1069 1070
  twidth = GTK_WIDGET (menu)->requisition.width;
  theight = GTK_WIDGET (menu)->requisition.height;

1071
  screen = gtk_widget_get_screen (GTK_WIDGET (menu));
1072
  monitor_num = gdk_screen_get_monitor_at_window (screen, menu_item->event_window);
1073 1074 1075
  if (monitor_num < 0)
    monitor_num = 0;
  gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
Elliot Lee's avatar
Elliot Lee committed
1076

1077
  if (!gdk_window_get_origin (widget->window, &tx, &ty))
Owen Taylor's avatar
Owen Taylor committed
1078 1079 1080 1081
    {
      g_warning ("Menu not on screen");
      return;
    }
Elliot Lee's avatar
Elliot Lee committed
1082

1083 1084 1085
  tx += widget->allocation.x;
  ty += widget->allocation.y;

1086 1087
  get_offsets (menu, &horizontal_offset, &vertical_offset);
  
Elliot Lee's avatar
Elliot Lee committed
1088 1089 1090
  switch (menu_item->submenu_placement)
    {
    case GTK_TOP_BOTTOM:
1091 1092 1093 1094 1095 1096 1097 1098
      if (direction == GTK_TEXT_DIR_LTR)
	menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
      else 
	{
	  menu_item->submenu_direction = GTK_DIRECTION_LEFT;
	  tx += widget->allocation.width - twidth;
	}

1099
      if ((ty + widget->allocation.height + theight) <= monitor.y + monitor.height)
1100
	ty += widget->allocation.height;
1101
      else if ((ty - theight) >= monitor.y)
Elliot Lee's avatar
Elliot Lee committed
1102
	ty -= theight;
1103
      else if (monitor.y + monitor.height - (ty + widget->allocation.height) > ty)
1104
	ty += widget->allocation.height;
1105 1106
      else
	ty -= theight;
Elliot Lee's avatar
Elliot Lee committed
1107 1108 1109
      break;

    case GTK_LEFT_RIGHT:
1110
      parent_menu_item = GTK_MENU (widget->parent)->parent_menu_item;
1111
      parent_xthickness = widget->parent->style->xthickness;
1112 1113 1114
      if (parent_menu_item && 
	  !GTK_MENU (widget->parent)->torn_off && 
	  !GTK_MENU_SHELL (menu)->active)
Tim Janik's avatar
Tim Janik committed
1115
	menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
1116 1117 1118 1119
      else if (direction == GTK_TEXT_DIR_LTR)
	menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
      else
	menu_item->submenu_direction = GTK_DIRECTION_LEFT;
Elliot Lee's avatar
Elliot Lee committed
1120 1121 1122 1123

      switch (menu_item->submenu_direction)
	{
	case GTK_DIRECTION_LEFT:
1124 1125
	  if ((tx - twidth - parent_xthickness - horizontal_offset) >= monitor.x)
	    tx -= twidth + parent_xthickness + horizontal_offset;
Elliot Lee's avatar
Elliot Lee committed
1126 1127 1128
	  else
	    {
	      menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
1129
	      tx += widget->allocation.width + parent_xthickness + horizontal_offset;
Elliot Lee's avatar
Elliot Lee committed
1130 1131 1132 1133
	    }
	  break;

	case GTK_DIRECTION_RIGHT:
1134 1135
	  if ((tx + widget->allocation.width + parent_xthickness + horizontal_offset + twidth) <= monitor.x + monitor.width)
	    tx += widget->allocation.width + parent_xthickness + horizontal_offset;
Elliot Lee's avatar
Elliot Lee committed
1136 1137 1138
	  else
	    {
	      menu_item->submenu_direction = GTK_DIRECTION_LEFT;
1139
	      tx -= twidth + parent_xthickness + horizontal_offset;
Elliot Lee's avatar
Elliot Lee committed
1140 1141 1142 1143
	    }
	  break;
	}

1144 1145
      ty += vertical_offset;
      
1146
      /* If the height of the menu doesn't fit we move it upward. */
1147
      ty = CLAMP (ty, monitor.y, MAX (monitor.y, monitor.y + monitor.height - theight));
Elliot Lee's avatar
Elliot Lee committed
1148 1149 1150
      break;
    }

1151 1152
  /* If we have negative, tx, here it is because we can't get
   * the menu all the way on screen. Favor the left portion.
1153
   */
1154
  *x = CLAMP (tx, monitor.x, MAX (monitor.x, monitor.x + monitor.width - twidth));
1155
  *y = ty;
1156 1157

  gtk_menu_set_monitor (menu, monitor_num);
Elliot Lee's avatar
Elliot Lee committed
1158 1159
}

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
/**
 * gtk_menu_item_set_right_justified:
 * @menu_item: a #GtkMenuItem.
 * @right_justified: if %TRUE the menu item will appear at the 
 *   far right if added to a menu bar.
 * 
 * Sets whether the menu item appears justified at the right
 * side of a menu bar. This was traditionally done for "Help" menu
 * items, but is now considered a bad idea. (If the widget
 * layout is reversed for a right-to-left language like Hebrew
 * or Arabic, right-justified-menu-items appear at the left.)
 **/
Elliot Lee's avatar
Elliot Lee committed
1172
void
1173 1174
gtk_menu_item_set_right_justified (GtkMenuItem *menu_item,
				   gboolean     right_justified)
Elliot Lee's avatar
Elliot Lee committed
1175
{
1176 1177 1178
  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));

  right_justified = right_justified != FALSE;
Elliot Lee's avatar
Elliot Lee committed
1179

1180 1181 1182
  if (right_justified != menu_item->right_justify)
    {
      menu_item->right_justify = right_justified;
1183
      gtk_widget_queue_resize (GTK_WIDGET (menu_item));
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
    }
}

/**
 * gtk_menu_item_get_right_justified:
 * @menu_item: a #GtkMenuItem
 * 
 * Gets whether the menu item appears justified at the right
 * side of the menu bar.
 * 
 * Return value: %TRUE if the menu item will appear at the
 *   far right if added to a menu bar.
 **/
gboolean
gtk_menu_item_get_right_justified (GtkMenuItem *menu_item)
{
  g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), FALSE);
  
  return menu_item->right_justify;
Elliot Lee's avatar
Elliot Lee committed
1203
}
1204

1205

1206 1207 1208
static void
gtk_menu_item_show_all (GtkWidget *widget)
{
1209
  GtkMenuItem *menu_item;
1210 1211

  g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1212

1213 1214
  menu_item = GTK_MENU_ITEM (widget);

1215
  /* show children including submenu */
1216 1217
  if (menu_item->submenu)
    gtk_widget_show_all (menu_item->submenu);
1218 1219
  gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);

1220 1221 1222 1223 1224 1225
  gtk_widget_show (widget);
}

static void
gtk_menu_item_hide_all (GtkWidget *widget)
{
1226
  GtkMenuItem *menu_item;
1227 1228 1229 1230

  g_return_if_fail (GTK_IS_MENU_ITEM (widget));

  gtk_widget_hide (widget);
1231 1232 1233 1234 1235

  menu_item = GTK_MENU_ITEM (widget);

  /* hide children including submenu */
  gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
1236 1237
  if (menu_item->submenu)
    gtk_widget_hide_all (menu_item->submenu);
1238 1239
}

1240
static gboolean
Owen Taylor's avatar
Owen Taylor committed
1241 1242
gtk_menu_item_can_activate_accel (GtkWidget *widget,
				  guint      signal_id)
1243
{
Owen Taylor's avatar
Owen Taylor committed
1244
  /* Chain to the parent GtkMenu for further checks */
1245 1246 1247 1248
  return (GTK_WIDGET_IS_SENSITIVE (widget) && GTK_WIDGET_VISIBLE (widget) &&
          widget->parent && gtk_widget_can_activate_accel (widget->parent, signal_id));
}

1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
static void
gtk_menu_item_accel_name_foreach (GtkWidget *widget,
				  gpointer data)
{
  const gchar **path_p = data;

  if (!*path_p)
    {
      if (GTK_IS_LABEL (widget))
	{
	  *path_p = gtk_label_get_text (GTK_LABEL (widget));
	  if (*path_p && (*path_p)[0] == 0)
	    *path_p = NULL;
	}
      else if (GTK_IS_CONTAINER (widget))
	gtk_container_foreach (GTK_CONTAINER (widget),
			       gtk_menu_item_accel_name_foreach,
			       data);
    }
}

1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
static void
gtk_menu_item_parent_set (GtkWidget *widget,
			  GtkWidget *previous_parent)
{
  GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
  GtkMenu *menu = GTK_IS_MENU (widget->parent) ? GTK_MENU (widget->parent) : NULL;

  if (menu)
    _gtk_menu_item_refresh_accel_path (menu_item,
				       menu->accel_path,
				       menu->accel_group,
				       TRUE);

  if (GTK_WIDGET_CLASS (parent_class)->parent_set)
    GTK_WIDGET_CLASS (parent_class)->parent_set (widget, previous_parent);
}

1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
void
_gtk_menu_item_refresh_accel_path (GtkMenuItem   *menu_item,
				   const gchar   *prefix,
				   GtkAccelGroup *accel_group,
				   gboolean       group_changed)
{
  const gchar *path;
  GtkWidget *widget;

  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1297
  g_return_if_fail (!accel_group || GTK_IS_ACCEL_GROUP (accel_group));
1298 1299 1300

  widget = GTK_WIDGET (menu_item);

1301 1302
  if (!accel_group)
    {
1303
      gtk_widget_set_accel_path (widget, NULL, NULL);
1304 1305 1306
      return;
    }

1307
  path = _gtk_widget_get_accel_path (widget, NULL);
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
  if (!path)					/* no active accel_path yet */
    {
      path = menu_item->accel_path;
      if (!path && prefix)
	{
	  gchar *postfix = NULL;

	  /* try to construct one from label text */
	  gtk_container_foreach (GTK_CONTAINER (menu_item),
				 gtk_menu_item_accel_name_foreach,
				 &postfix);
	  menu_item->accel_path = postfix ? g_strconcat (prefix, "/", postfix, NULL) : NULL;
	  path = menu_item->accel_path;
	}
      if (path)
1323
	gtk_widget_set_accel_path (widget, path, accel_group);
1324 1325
    }
  else if (group_changed)			/* reinstall accelerators */
1326
    gtk_widget_set_accel_path (widget, path, accel_group);
1327 1328 1329 1330 1331
}

/**
 * gtk_menu_item_set_accel_path
 * @menu_item:  a valid #GtkMenuItem
1332 1333
 * @accel_path: accelerator path, corresponding to this menu item's
 *              functionality, or %NULL to unset the current path.
1334 1335 1336 1337 1338 1339 1340 1341
 *
 * Set the accelerator path on @menu_item, through which runtime changes of the
 * menu item's accelerator caused by the user can be identified and saved to
 * persistant storage (see gtk_accel_map_save() on this).
 * To setup a default accelerator for this menu item, call
 * gtk_accel_map_add_entry() with the same @accel_path.
 * See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
 * and gtk_menu_set_accel_path() for a more convenient variant of this function.
1342 1343 1344 1345
 *
 * This function is basically a convenience wrapper that handles calling
 * gtk_widget_set_accel_path() with the appropriate accelerator group for
 * the menu item.
Matthias Clasen's avatar
Matthias Clasen committed
1346 1347 1348
 *
 * Note that you do need to set an accelerator on the parent menu with
 * gtk_menu_set_accel_group() for this to work.
1349 1350 1351 1352 1353 1354 1355 1356
 */
void
gtk_menu_item_set_accel_path (GtkMenuItem *menu_item,
			      const gchar *accel_path)
{
  GtkWidget *widget;

  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1357 1358
  g_return_if_fail (accel_path == NULL ||
		    (accel_path[0] == '<' && strchr (accel_path, '/')));
1359 1360